Module resolver 

Re-anchoring resolver for durable review threads.

A persisted ReviewAnchor stores a drift-robust location (path + side + line + content hash + a few context lines). The diff is re-scanned on every overlay open, so the anchor must be re-resolved to a fresh positional index into the new FileHunks. resolve_anchor reports whether the line is still in place, moved, or could not be placed at all.

Relocation requires one unambiguous match: the line, plus at least one recorded neighbour agreeing within CONTEXT_RADIUS on each side the candidate has neighbours. Anything less is left where it was and marked outdated, because a comment silently attached to the wrong code costs far more than one the reviewer has to go looking for.

A distance bound does not make that safer. Bounding how far a match may be found still leaves several candidates inside the bound, and choosing among them by proximity is exactly the guess uniqueness refuses to make.

Enums

AnchorPlacement

One anchor’s landing in the terms a view draws it: no positional indices into one scan’s arrays, just the line the anchor sits on now and, when it could not be placed, the resolver’s own reason.

AnchorResolution

Where a re-resolved anchor landed against a fresh diff scan. Indices address files[file_idx].hunks[hunk_idx].lines[line_idx].

OutdatedReason

Why an anchor did not relocate. Attaching a comment to the wrong code costs more than leaving it behind, so anything short of one certain match lands here rather than being guessed at.

Constants

CONTEXT_RADIUS

Lines captured on each side of an anchored line for fuzzy re-anchor disambiguation.

Functions

anchor_hash

The hash to persist for a newly captured anchor. Whitespace-normalised so a cargo fmt reflow reads as the same line.

capture_context

Capture up to radius lines on each side of line_idx within hunk (excluding the line itself) as fuzzy-match context.

content_hash

content_hash_bytes over a diff line’s text.

content_hash_bytes

FNV-1a hash of raw bytes: what both a line’s text and a whole document go through, so one implementation pins both.

place_anchor_in_content

resolve_anchor_in_content, narrowed to what a view draws.

place_anchor_in_lines

One seat-tree anchor placed against a file’s whole current lines - the files page’s resolution. The scope’s numbering IS the file’s own (the seat’s tree is where the comment was written), so unlike a diff scope whose numbering may belong to another base, the recorded line is trusted: in place when it still carries the anchor’s text, otherwise re-found by content plus neighbours, and Gone / Ambiguous as the diff resolver reports them.

place_anchor_in_lines_with

The whole-file placement with the diff resolver’s trust rule: with trust_line_number the recorded line is evidence too, because the file handed in is numbered the way the anchor was written; otherwise the match is earned by content and neighbours alone.

place_document_anchor

A document anchor placed against the document’s whole current lines: the thread’s FIRST captured line is the key, looked for by content.

resolve_anchor

Re-resolve anchor against a fresh files scan. trust_line_number says whether files is numbered the same way the anchor was recorded in. Only then does the recorded line carry information; from another scope’s diff that number addresses whatever happens to sit there, so the match has to be earned by content and neighbours like any other.

resolve_anchor_in_content

Re-resolve anchor against the socket’s bounded content read, whose files carry hunks but not the overlay scan’s own shape. Same resolution as resolve_anchor, one implementation.