Beagle SCM

LITE-025 DONE: permalinks — file.c:k4:d8K3, blob offset + blob hashlet

gritzko's ruling 2026-08-14: a text-file permalink is file.c:k4:d8K3 — segment 1 a ron64 BYTE OFFSET into the named blob, segment 2 the BLOB's ron64 hashlet, ONLY ever a blob hash (commit-id tier overruled same day). Nav: resolve the file name (may hit several files — chooser), find that blob in the path's history, count to byte k4 there, find the same place in the current/required version, open, set the cursor. Blob offset, never a weave/insertion offset: the fold's ranges are tokenizer-dependent, a weave rebuild would re-point every link; blob bytes are canonical git ground. The DOG-034 lexer already fuses both segments (pathanchor, ron64{1,10} twice), so the grammar is DONE — this ticket is the door/resolution/mint half, extending the LITE-024 :line:col landing.

Input

Context

LITE-024 lands file.c:12:24 on the line via the door's splitRef (the ONE split point in openTarget) and the LITE-023 cursor; both anchor segments are lexed into the fused F token since DOG-034. CFOLD (DIS-082, quickjab/dog/CFOLD.h) stores per-commit 'C' records: canonical id (hi64 sha1), body range, P_c view length; CFOLDBlame maps a body offset to its inserting commit; CFOLDIterNext walks any rev's view.

• Anchor forms, decided by segment 2: :123 line; :123:45 line:col, current version only (both all-digit); :k4:d8K3 permalink (segment 2 carries a non-digit).
• Hashlet = BLOB id prefix, nothing else: min 4 chars, EVEN length (12-bit chunks, 3 hexes per 2 chars), extended by 2 until unique in scope AND holding one non-digit.
• Scope is ONE file — the path's own blob history plus its staged/working blob, never repo-wide; that keeps the space tiny and hashlets short.
• Later collisions resolve to the EARLIEST match in the path's history order — a later blob's own links were minted longer, so old links never break.
• Blob-only also serves commit-time minting: the commit id cannot be known while the link bytes are part of the commit, blob hashes of staged files exist; a same-file self-link stays :line:col or pins the pre-edit blob.
• Offset segment needs no rules: the form is decided by segment 2, and the 16 MiB cap bounds it at 4 ron chars.

Goals

Door leg + resolution walk + mint gesture; line:col behavior unchanged.

• Door (lite/main.js): splitRef learns the permalink form — segment 2 non-digit routes to resolution instead of the line:col shed; miss stays the quiet plain-words bar message.
• Resolve: path -> file (chooser on several); hashlet -> the path's blob (earliest in history order; index/worktree-only blob = the working version); byte k4 in that blob -> forward-map to the current/required version -> open, cursor on the row:col via LITE-023.
• Tombed target: land on the nearest alive neighbor, bar says deleted in ⟨commit⟩ in plain words (Verbs error tone, no bare codes).
• Mint: copy-permalink on the active token — hashlet of the VIEWED version's blob, offset = the cursor's byte position in it; no blame, no tokenizer, no commit needed (staged blobs mint fine).
• Chooser leg keeps the anchor through ambiguity, as LITE-024 does for :line:col.

Constraints

• Repo split as LITE-024: CFOLD-side helpers in a ///quickjab worktree (its dog sub carries DOG-034; ///jab/dog and installed jab are STALE — run pty probes with LITEJAB=<quickjab build>); door/pager/tests in ///lite. No VC ops.
• All anchor parsing rides the lexed F token bytes; no regex, no URI machinery, no new grammar.
• Verify through the real UI path: pty probe follows a minted permalink to the moved line after later edits, plus the tombed leg.

WIP

Design decisions

• Blob offset over insertion offset (ruled): survives weave rebuilds under a new tokenizer; P_c gives the bounds check for free.
• Segment order offset:hashlet mirrors line:col — position first, disambiguator second.

TODOs

• resolver: hashlet -> the path's blob (earliest), blob offset -> token -> head row:col / tombed
• door: route the non-digit segment-2 form; chooser keeps the anchor
• pager: land row:col via cursor; tombed message in plain words
• mint: copy-permalink of the active token (viewed blob's hashlet + byte offset)
• fixtures: parse forms (:123, :123:45, :k4:d8K3, all-digit segment 2), earliest-match blob collision, worktree-only blob, multi-file path chooser leg
• pty: follow a permalink across later edits; tombed leg; : bar leg

Blockers and bummers

• DOG-034 runtime only in ///quickjab's dog (39158d0c); stock jab fuses no path anchors — same bummer as LITE-024.

Outcome

NAV HALF ONLY (mint untouched, out of scope by order). Worker wt work/LITE-025, lite base ///lite/#efa67a47 — which ALREADY CARRIES LITE-024 (3d0ecd67) and LITE-023 (1d0b187b), so nothing had to be ported from the LITE-024 worktree. 5 files jab put, NO commit.

• index/perma.js NEW (369): the whole walk. hashletHex unpacks the ron64 pairs through ron.decode (12 bits a pair, 3 hex, big-endian — no alphabet table of its own); scope is ONE FILE — blobsFor takes the path's own commits (log.js fileLog, oldest first) whose blob AT THAT PATH carries the prefix, earliest picks among them, then blobIdOf (git's blob <n>\0 framing) answers for a working-copy-only blob. Forward map: ONE CFOLD pair (anchored blob, then the worktree bytes on top — index/diff.js's own scratch-buffer discipline), walk at the anchor rev to name the token covering the byte (its body offset IS the identity), walk at the head rev for where it sits now; a dead token lands where it stood and deleterOf names the commit that took it (bounded at 64 folds).
• main.js +39/−1: permaTail() decides the form on SEGMENT 2 (even, 4..10 ron64 chars, one non-digit) inside the ONE splitRef split point; openPerma is the door leg — the chooser hunk carries the anchor on every row, a miss is the same quiet plain-words bar line a path miss gives. splitRef exported for the fixtures.
• view/pager.js +3: _openPush shows land.note on the bar. No path math added; the row:col landing is LITE-024's _land() unchanged.
• test/perma/{run.sh,pty.js} NEW (135+332): PASS 51 checks, 0 bad — real openpty, SGR presses, : bar typed through the pager's own input. RED FIRST: the same file against a pristine clone (only splitRef exported and a null perma.js stub so it loads) is 35 of 51 bad. Fixture: 40 fixed-width 16-byte lines so a blob offset is arithmetic, r1 prepends 5, r2 deletes one above the anchor (anchored line 20 -> line 24 today), r3/r4 make src/abc/TCP.c LEAVE its r0 blob and REVERT to it (a real earliest-match collision, asserted to anchor at r0), net/TCP.c edited but NOT committed (the working-blob leg), TCP.c byte-identical in two dirs (the chooser).
• Full lite suite vs a pristine clone of the same base, same runtime: failure counts IDENTICAL (blob 12/13, cat 16/35, list 17/78, pager 1/33, tree 25/47 — all pre-existing), everything else PASS plus the new perma.

Spec/code notes for gritzko, nothing improvised around:

• The ticket TITLE and the first TODO line still say "commit hashlet" / "hashlet -> commit"; the body is the blob-only ruling. Left as written.
• "staged/index blob" is served by the WORKING blob: lite never reads .git/index (index/diff.js's own stance), so a staged-only change reads as a worktree one. If a real index reader is wanted, that is a separate leg.
• RUNTIME: quickjab/build-release carries DOG-034 but is built with QUICKJAB_JSRC_PACK=ON, and a packed build is bundle-ONLY — it ignores a lite worktree entirely, so it silently tests the BUNDLED lite. Every other quickjab/build* binary predates DOG-034 and fuses no anchors. Probes here ran on an out-of-source unbundled build at ~/tmp/l25/qjb/bin/quickjab (cmake -S quickjab -B ~/tmp/l25/qjb -DQUICKJAB_JSRC_PACK=OFF); the quickjab tree stayed untouched (jab status clean).

Suggested commit (lite wt): LITE-025: permalinks follow the blob anchor