@oh-my-pi/hashline 15.5.12 → 15.5.13

package/dist/types/format.d.ts

@@ -3,49 +3,63 @@
  * display helpers. These are the single source of truth for the parser, the
  * tokenizer, the prompt, and the formal grammar.
  */
+import type { Cursor } from "./types";
 /** File-section header prefix: `¶path#hash`. */
 export declare const HL_FILE_PREFIX = "\u00B6";
 /** Payload sigil for literal body rows. */
 export declare const HL_PAYLOAD_REPLACE = "+";
-/** Payload sigil for body rows that repeat original file lines. */
-export declare const HL_PAYLOAD_REPEAT = "&";
-/** All hashline payload sigils, concatenated for fast membership tests. */
-export declare const HL_PAYLOAD_CHARS = "+&";
+/** Hunk-header keyword for concrete line replacement. */
+export declare const HL_REPLACE_KEYWORD = "replace";
+/** Hunk-header keyword for concrete line deletion. */
+export declare const HL_DELETE_KEYWORD = "delete";
+/** Hunk-header keyword for insertion operations. */
+export declare const HL_INSERT_KEYWORD = "insert";
+/** Insert position keyword for inserting before a concrete line. */
+export declare const HL_INSERT_BEFORE = "before";
+/** Insert position keyword for inserting after a concrete line. */
+export declare const HL_INSERT_AFTER = "after";
+/** Insert position keyword for inserting at the start of the file. */
+export declare const HL_INSERT_HEAD = "head";
+/** Insert position keyword for inserting at the end of the file. */
+export declare const HL_INSERT_TAIL = "tail";
+/** Hunk-header terminator for body-bearing operations. */
+export declare const HL_HEADER_COLON = ":";
 /** Separator between a hashline file path and its opaque snapshot tag. */
 export declare const HL_FILE_HASH_SEP = "#";
 /** Separator between two line numbers in a range, e.g. `5..10`. */
 export declare const HL_RANGE_SEP = "..";
 /** Separator between a line number and displayed line content in hashline mode. */
 export declare const HL_LINE_BODY_SEP = ":";
-/**
- * Decoration prefix that may precede a line number in tool output:
- * `*` (match line), `>` (context line in grep). Any combination, in any
- * order, surrounded by optional whitespace. Output formatters emit at most
- * one decoration per line; the parser stays liberal because it accepts
- * whatever the model echoes back.
- */
-export declare const HL_ANCHOR_DECORATION_RE_RAW = "\\s*[>*]*\\s*";
-/** Capture-group regex source for a decorated bare line-number anchor. */
-export declare const HL_ANCHOR_RE_RAW = "\\s*[>*]*\\s*(\\d+)";
 /** Bare positive line-number Lid (no decorations, no captures, no anchors). */
 export declare const HL_LINE_RE_RAW = "[1-9]\\d*";
 /** Capture-group form of {@link HL_LINE_RE_RAW}. */
 export declare const HL_LINE_CAPTURE_RE_RAW = "([1-9]\\d*)";
-/** Regex for repeat payload rows (`&A..B`). */
-export declare const HL_PAYLOAD_REPEAT_RE: RegExp;
-/** Number of hex characters in an opaque snapshot tag. */
-export declare const HL_FILE_HASH_LENGTH = 3;
-/** Canonical uppercase hexadecimal opaque snapshot tag carried by a hashline section header. */
-export declare const HL_FILE_HASH_RE_RAW = "[0-9A-F]{3}";
+/** Format a concrete replacement hunk header. */
+export declare function formatReplaceHeader(start: number, end: number): string;
+/** Format a concrete deletion hunk header. */
+export declare function formatDeleteHeader(start: number, end?: number): string;
+/** Format an insertion hunk header for a cursor position. */
+export declare function formatInsertHeader(cursor: Cursor): string;
+/** Number of hex characters in a content-derived file-hash tag. */
+export declare const HL_FILE_HASH_LENGTH = 4;
+/** Canonical uppercase hexadecimal content-hash tag carried by a hashline section header. */
+export declare const HL_FILE_HASH_RE_RAW = "[0-9A-F]{4}";
 /** Capture-group form of {@link HL_FILE_HASH_RE_RAW}. */
-export declare const HL_FILE_HASH_CAPTURE_RE_RAW = "([0-9A-F]{3})";
+export declare const HL_FILE_HASH_CAPTURE_RE_RAW = "([0-9A-F]{4})";
 /** Regex-escaped form of {@link HL_LINE_BODY_SEP}, safe for embedding inside a regex. */
 export declare const HL_LINE_BODY_SEP_RE_RAW: string;
 /**
- * Representative snapshot tags for use in user-facing error messages and
+ * Representative file-hash tags for use in user-facing error messages and
  * prompt examples.
  */
-export declare const HL_FILE_HASH_EXAMPLES: readonly ["0A3", "1F7", "3C9"];
+export declare const HL_FILE_HASH_EXAMPLES: readonly ["1A2B", "3C4D", "9F3E"];
+/**
+ * Compute the content-derived hash tag carried by a hashline section header.
+ * The tag is a 4-hex fingerprint of the whole file's normalized text: any read
+ * of byte-identical content mints the same tag, and a follow-up edit anchored
+ * at any line validates whenever the live file still hashes to it.
+ */
+export declare function computeFileHash(text: string): string;
 /**
  * Format a comma-separated list of example anchors with an optional line-number
  * prefix, quoted for inclusion in error messages: `"160", "42", "7"`.

package/dist/types/input.d.ts

@@ -36,9 +36,9 @@ export declare class PatchSection {
     /** Warnings emitted during parsing of this section. */
     get warnings(): readonly string[];
     /**
-     * True when at least one edit anchors to concrete file content. Pure BOF/EOF
-     * literal inserts do not count: those are safe to apply to files that don't
-     * yet exist.
+     * True when at least one edit anchors to concrete file content. Pure
+     * `insert head:` / `insert tail:` literal inserts do not count: those are
+     * safe to apply to files that don't yet exist.
      */
     get hasAnchorScopedEdit(): boolean;
     /** Anchor lines touched by this section, sorted ascending and deduplicated. */

package/dist/types/messages.d.ts

@@ -16,40 +16,20 @@ export declare const END_PATCH_MARKER = "*** End Patch";
  * parsing — terminates the line loop — and does not surface a warning.
  */
 export declare const ABORT_MARKER = "*** Abort";
-/**
- * Warning text appended when two consecutive hunks target the exact same
- * concrete range. The second hunk wins; the first is discarded.
- */
-export declare const REPLACE_PAIR_COALESCED_WARNING = "Detected two identical-range hashline hunks; kept only the second hunk. Issue ONE hunk per range \u2014 payload is the final desired content, never both old and new.";
-/**
- * Warning text appended when a bare hunk header (`A B` with no body)
- * is followed by an overlapping concrete hunk. The earlier bare hunk is
- * dropped on the assumption that the model expressed an old/new pair across
- * two hunks; only the second hunk's payload is applied.
- */
-export declare const REPLACE_PAIR_COALESCED_OVERLAP_WARNING = "Detected an overlapping bare hashline hunk immediately followed by a concrete hunk; dropped the earlier bare hunk. Issue ONE hunk per range \u2014 payload is the final desired content, never both old and new.";
-/**
- * Warning text appended when bare body rows (no `+` / `&` prefix) follow a
- * hunk header and the parser auto-converts them to `+literal` rows because
- * no `+`/`&` row was present in the hunk. Helps the model learn the
- * canonical body-row syntax while keeping the patch applying.
- */
-export declare const BARE_BODY_AUTO_PIPED_WARNING = "Auto-prefixed bare body row(s) with `+`. Always start payload rows with `+TEXT` (literal) or `&A..B` (repeat) \u2014 pasting raw code as payload is not a portable shape.";
-/**
- * Warning text emitted when a body row begins with `+&A..B` — the model
- * mistakenly prefixed a repeat row with the `+` literal sigil. We reroute
- * the row as a `&A..B` repeat so the patch still applies, then surface this
- * warning so the model sees the mistake on the next turn.
- */
-export declare const PLUS_PREFIXED_REPEAT_WARNING = "A body row started with `+&A..B`. `+` (literal text) and `&A..B` (repeat) are sibling row kinds \u2014 a row uses exactly one of them. Treated as `&A..B`; remove the leading `+` next time.";
-/**
- * Warning text emitted when a hunk body contains unified-diff-style rows
- * (`-old`, ` context`) and the parser silently converts them: `-` rows are
- * dropped (the hunk header's range already deletes those lines), and the
- * leading metadata-space on context rows is stripped once unified-diff
- * mode is detected. Bare body rows are auto-prefixed with `+` regardless.
- */
-export declare const UNIFIED_DIFF_BODY_AUTO_CONVERT_WARNING = "Hunk body contained unified-diff-style rows (`-old`, ` context`). The `-` rows were dropped (the hunk header's range already deletes those lines); context rows were treated as `+TEXT` literals. Use `+TEXT` (literal) or `&A..B` (repeat) directly next time.";
+/** Warning text appended when two consecutive hunks target the exact same concrete range. */
+export declare const REPLACE_PAIR_COALESCED_WARNING = "Detected two identical-range hashline hunks; kept only the second hunk. Issue ONE `replace N..M:` hunk per range \u2014 payload is the final desired content, never both old and new.";
+/** Warning text appended when an empty bodyless hunk is followed by an overlapping concrete hunk. */
+export declare const REPLACE_PAIR_COALESCED_OVERLAP_WARNING = "Detected an overlapping bare hashline hunk immediately followed by a concrete hunk; dropped the earlier bare hunk. Issue ONE `replace N..M:` hunk per range \u2014 payload is the final desired content, never both old and new.";
+/** Warning text appended when bare body rows are auto-converted to literal rows. */
+export declare const BARE_BODY_AUTO_PIPED_WARNING = "Auto-prefixed bare body row(s) with `+`. Body rows must be `+TEXT` literal lines; pasting raw code as payload is not a portable shape.";
+/** Error text emitted when a hunk body contains a unified-diff-style `-` row. */
+export declare const MINUS_ROW_REJECTED = "`-` rows are not valid; hashline ranges already name the lines being changed. To insert a literal line starting with `-`, write `+-\u2026`.";
+/** Error text emitted when a replace hunk has no body. */
+export declare const EMPTY_REPLACE = "`replace N..M:` needs at least one `+TEXT` body row. To delete lines, use `delete N..M`.";
+/** Error text emitted when a delete hunk receives a body row. */
+export declare const DELETE_TAKES_NO_BODY = "`delete N..M` does not take body rows. Remove the body, or use `replace N..M:`.";
+/** Error text emitted when an insert hunk has no body. */
+export declare const EMPTY_INSERT = "`insert` needs at least one `+TEXT` body row.";
 /** Warning text emitted by `Recovery` when an external write fits a cached snapshot. */
 export declare const RECOVERY_EXTERNAL_WARNING = "Recovered from a stale file hash using a previous read snapshot (file changed externally between read and edit).";
 /** Warning text emitted by `Recovery` when a prior in-session edit advanced the hash. */

package/dist/types/parser.d.ts

@@ -1,75 +1,22 @@
 import { type Token } from "./tokenizer";
 import type { Edit } from "./types";
-/**
- * Token-driven state machine that turns a stream of {@link Token}s into a
- * flat list of {@link Edit}s.
- *
- * `feed()` accepts tokens one at a time; hunk body rows accumulate until
- * the next hunk header or {@link end} flushes them. After `terminated`
- * flips true (on `envelope-end` or `abort`) subsequent feeds are silently
- * ignored so callers can keep draining their tokenizer.
- */
 export declare class Executor {
     #private;
-    /** True once an `envelope-end` or `abort` token has been observed. */
-    get terminated(): boolean;
-    /**
-     * Consume one token. After `terminated` flips true subsequent feeds are
-     * silently ignored so callers can keep draining the tokenizer without
-     * explicit early-exit guards.
-     */
     feed(token: Token): void;
-    /**
-     * Flush any open pending hunk and return the accumulated edits and
-     * warnings. The executor is single-use; {@link reset} is required for
-     * reuse.
-     *
-     * Throws if two hunks target the same line with non-identical ranges.
-     * Identical-range hunks in the same patch are coalesced last-wins by
-     * `feed()` with a warning, so they never reach the validator.
-     */
     end(): {
         edits: Edit[];
         warnings: string[];
     };
-    /**
-     * Streaming-tolerant variant of {@link end}. Identical, except a pending
-     * hunk whose body has not yet accumulated any rows is treated as still
-     * in flight and dropped instead of flushed (which would otherwise commit
-     * a destructive delete while the model may still be typing payload).
-     */
     endStreaming(): {
         edits: Edit[];
         warnings: string[];
     };
-    /** Reset to a fresh state so the same instance can drive another parse. */
     reset(): void;
 }
-/**
- * Drive a full hashline diff through the tokenizer + executor pipeline and
- * return the resulting edits plus any parse-time warnings. This is the
- * convenience entry point most callers want; reach for {@link Tokenizer} /
- * {@link Executor} directly only when you need streaming feeds, cross-section
- * state, or custom token handling.
- */
 export declare function parsePatch(diff: string): {
     edits: Edit[];
     warnings: string[];
 };
-/**
- * Streaming-tolerant variant of {@link parsePatch}. Returns whatever edits
- * parsed successfully when the diff is still being typed:
- *
- * - per-token feed errors stop the drain but preserve the edits already
- *   collected (the trailing hunk is malformed mid-stream — wait for the
- *   next chunk),
- * - the trailing pending hunk is dropped if it has no payload yet (avoids
- *   a destructive bare-delete preview while payload may still be coming).
- *
- * Throws only on the cross-hunk overlap validator, which catches conflicting
- * shapes (two hunks hitting the same anchor). Streaming preview callers
- * should treat any throw here as "no preview this tick".
- */
 export declare function parsePatchStreaming(diff: string): {
     edits: Edit[];
     warnings: string[];

package/dist/types/recovery.d.ts

@@ -16,20 +16,18 @@ export interface RecoveryResult {
 }
 /**
  * Stateless recovery driver over a {@link SnapshotStore}. Construct once and
- * call {@link Recovery.tryRecover} per stale-hash incident. The default
- * implementation tries three strategies in order:
+ * call {@link Recovery.tryRecover} per stale-tag incident. The default
+ * implementation tries two strategies in order:
  *
- * 1. Apply on the cached `fullText` snapshot, then 3-way-merge onto current.
- * 2. (Session chain) If the snapshot wasn't the head, retry on current text
- *    when line counts match AND every edit's anchor line content is unchanged
- *    between snapshot and current — the previous in-session edit advanced
- *    the hash and the model's anchors still name the same logical rows. Emits
- *    a dedicated {@link RECOVERY_SESSION_REPLAY_WARNING} because even with
- *    both guards a coincidental insert+delete pair on duplicate rows can
- *    still land the edit on the wrong row; see {@link replaySessionChainOnCurrent}.
- * 3. Reconstruct from a sparse snapshot (lines map only), then 3-way-merge.
- *    Sparse snapshots that still match the live file are direct-apply cases
- *    owned by the patcher, so recovery declines them.
+ * 1. Apply the edits on the full-file version the tag names, then 3-way-merge
+ *    the resulting patch onto the live content (handles external writes).
+ * 2. (Session chain) If that version wasn't the head, replay the edits onto
+ *    the live content directly when line counts match AND every edit's anchor
+ *    line content is unchanged between version and current — a prior in-session
+ *    edit advanced the tag and the model's anchors still name the same logical
+ *    rows. Emits a dedicated {@link RECOVERY_SESSION_REPLAY_WARNING} because
+ *    even with both guards a coincidental insert+delete pair on duplicate rows
+ *    can still land the edit on the wrong row; see {@link replaySessionChainOnCurrent}.
  */
 export declare class Recovery {
     readonly store: SnapshotStore;

package/dist/types/snapshots.d.ts

@@ -1,133 +1,55 @@
 /**
- * Per-session snapshot store used by {@link Recovery} and {@link Patcher} to
- * bind hashline section tags to the exact file view that minted them.
- *
- * Producers (typically `read` / `search` tools) record the lines they showed
- * the model. The store returns a three-hex opaque tag. Consumers resolve that
- * tag back to the recorded snapshot and verify the recorded lines against the
- * live file before applying anchored edits.
- *
- * Tags are scrambled by a deterministic permutation of the 12-bit hex space
- * built once at module load. Slot index `i` always maps to the same tag
- * across restarts (good for tests and reproducibility), but consecutive slot
- * indices produce unrelated tags — `mint()` followed by another `mint()` does
- * not return e.g. `000` then `001`, and the first tag a store ever hands out
- * is not `000`. This is hallucination prevention, not adversarial security: it
- * stops an LLM from guessing `001` after observing `000`, or assuming any
- * monotonic counter pattern. The patcher catches stale-tag misuse via
- * content verification at apply time, so determinism doesn't reduce safety.
- *
- * Tag → slot resolution is a single `Map` lookup (no `parseInt`, no regex):
- * the inverse table is populated with both lowercase and uppercase forms of
- * every tag at module load.
- *
- * Snapshots are an open abstract type. The two concrete impls cover the
- * shapes producers actually emit: {@link ContiguousSnapshot} for `read`-style
- * runs (no map allocation, range arithmetic for lookup and superset checks)
- * and {@link SparseSnapshot} for `search`-style hits.
- *
- * The abstract base class lets callers plug in whatever storage they like.
- * {@link InMemorySnapshotStore} ships as a single 4096-slot ring shared across
- * paths — snapshots carry their own path, so the global ring is fine and
- * `byHash` rejects cross-path lookups.
+ * One full-file version observed at a point in time. The tag the model sees is
+ * {@link Snapshot.hash}; recovery replays edits against {@link Snapshot.text}.
  */
-/**
- * One snapshot of a file view as observed at a point in time. The two
- * primitive methods subclasses must supply — `get` and `entries` — give callers
- * (and the default `isSuperset` / `matchesLiveFile` impls) everything they
- * need to verify recorded content against the live file.
- */
-export declare abstract class Snapshot {
-    /** Canonical path this snapshot belongs to. */
-    abstract readonly path: string;
-    /** Timestamp (ms since epoch) the snapshot was recorded. */
-    abstract readonly recordedAt: number;
-    /** Full normalized text when the read observed the whole file. */
-    abstract readonly fullText?: string;
-    /** Recorded content for 1-indexed `lineNumber`, or `undefined` if this snapshot doesn't cover that line. */
-    abstract get(lineNumber: number): string | undefined;
-    /** Iterate (1-indexed lineNumber, content) pairs in stable order. */
-    abstract entries(): Iterable<[number, string]>;
-    /** True iff every (line, content) the `other` snapshot asserts is also present here with matching content. */
-    isSuperset(other: Snapshot): boolean;
-    /** True iff every recorded line matches `currentLines` (0-indexed array of live file lines). */
-    matchesLiveFile(currentLines: readonly string[]): boolean;
-}
-/**
- * A contiguous run of lines starting at `offset` (1-indexed). Backed by a
- * plain `string[]`; lookup is `lines[n - offset]`, superset against another
- * contiguous snapshot is pure range arithmetic.
- */
-export declare class ContiguousSnapshot extends Snapshot {
-    readonly path: string;
-    readonly offset: number;
-    readonly lines: readonly string[];
-    readonly fullText?: string | undefined;
-    readonly recordedAt: number;
-    constructor(path: string, offset: number, lines: readonly string[], fullText?: string | undefined, recordedAt?: number);
-    get(lineNumber: number): string | undefined;
-    entries(): IterableIterator<[number, string]>;
-    isSuperset(other: Snapshot): boolean;
-    matchesLiveFile(currentLines: readonly string[]): boolean;
-}
-/**
- * A sparse `(lineNumber → content)` map, used for snapshots that don't cover a
- * single contiguous run — e.g. search hits plus their context windows.
- */
-export declare class SparseSnapshot extends Snapshot {
+export interface Snapshot {
+    /** Canonical path this version belongs to. */
     readonly path: string;
-    readonly lines: ReadonlyMap<number, string>;
-    readonly fullText?: string | undefined;
-    readonly recordedAt: number;
-    constructor(path: string, lines: ReadonlyMap<number, string>, fullText?: string | undefined, recordedAt?: number);
-    get(lineNumber: number): string | undefined;
-    entries(): IterableIterator<[number, string]>;
-}
-/** Optional metadata supplied at snapshot record time. */
-export interface SnapshotMetadata {
-    /** Full normalized text, when the producer observed the whole file. */
-    fullText?: string;
+    /** Full normalized (LF, no BOM) file text as observed. */
+    readonly text: string;
+    /** Content-derived tag for {@link Snapshot.text} (see {@link computeFileHash}). */
+    readonly hash: string;
+    /** Timestamp (ms since epoch) the version was recorded. */
+    recordedAt: number;
 }
 /**
- * Storage seam for file-content snapshots. Hashline section tags are opaque
- * store pointers; without the store that minted them they carry no meaning.
+ * Storage seam for full-file version snapshots. The patcher calls {@link head}
+ * for the latest version of a path and {@link byHash} when it needs the
+ * specific historical version a section's stale tag names.
  */
 export declare abstract class SnapshotStore {
-    /** Most-recently pushed snapshot for `path`, or `null` if none. */
+    /** Most-recently recorded version for `path`, or `null` if none. */
     abstract head(path: string): Snapshot | null;
-    /** Snapshot currently occupying `tag`'s slot for `path`, or `null`. */
-    abstract byHash(path: string, tag: string): Snapshot | null;
-    /** Record a contiguous run of lines (e.g. from a `read` tool). `startLine` is 1-indexed. */
-    abstract recordContiguous(path: string, startLine: number, lines: readonly string[], metadata?: SnapshotMetadata): string;
-    /** Record sparse `(lineNumber, content)` pairs (e.g. a `search` match plus context). */
-    abstract recordSparse(path: string, entries: Iterable<readonly [number, string]>, metadata?: SnapshotMetadata): string;
-    /** Drop snapshots belonging to a single path. */
+    /** Recorded version for `path` whose tag equals `hash`, or `null`. */
+    abstract byHash(path: string, hash: string): Snapshot | null;
+    /** Record the full normalized text of `path` and return its content tag. */
+    abstract record(path: string, fullText: string): string;
+    /** Drop the version history for a single path. */
     abstract invalidate(path: string): void;
-    /** Drop every snapshot. */
+    /** Drop every version history. */
     abstract clear(): void;
 }
+export interface InMemorySnapshotStoreOptions {
+    /** Maximum number of distinct paths tracked at once (default 30). LRU eviction. */
+    maxPaths?: number;
+    /** Maximum full-file versions retained per path (default 4). Oldest dropped first. */
+    maxVersionsPerPath?: number;
+}
 /**
- * In-memory {@link SnapshotStore} backed by a flat 4096-slot ring shared across
- * all paths. Slot allocation is a simple `counter & 0xfff`; the tag the model
- * sees is `FORWARD[slot]` from the module-level permutation, so consecutive
- * pushes hand out unrelated tags. Before allocating, {@link InMemorySnapshotStore}
- * folds a new view into an existing same-path slot when the two agree on every
- * shared line: one covering the other reuses it verbatim (dedup), overlapping
- * or abutting runs extend in place, and gapped runs union into a sparse view
- * (coalesce). All reuse the original tag, so sequential reads of an unchanged
- * file collapse onto one anchor instead of fragmenting. A disagreeing shared
- * line means the file changed on disk, so a fresh slot (new tag) is minted.
- * Slot reuse on wrap is intentional: stale tags may
- * alias after 4096 distinct pushes, and the patcher catches misuse by verifying
- * the resolved snapshot's content (and path) against the live file before
- * applying edits.
+ * In-memory {@link SnapshotStore} backed by `lru-cache`. Per-path history is a
+ * short ring of full-file versions (oldest dropped first); per-session path
+ * tracking is LRU-bounded so cold paths age out automatically.
+ *
+ * Recording byte-identical content again refreshes recency and reuses the
+ * existing tag (read fusion); recording new content unshifts a fresh version
+ * onto the front of the path history.
  */
 export declare class InMemorySnapshotStore extends SnapshotStore {
     #private;
+    constructor(options?: InMemorySnapshotStoreOptions);
     head(path: string): Snapshot | null;
-    byHash(path: string, tag: string): Snapshot | null;
-    recordContiguous(path: string, startLine: number, lines: readonly string[], metadata?: SnapshotMetadata): string;
-    recordSparse(path: string, entries: Iterable<readonly [number, string]>, metadata?: SnapshotMetadata): string;
+    byHash(path: string, hash: string): Snapshot | null;
+    record(path: string, fullText: string): string;
     invalidate(path: string): void;
     clear(): void;
 }

package/dist/types/tokenizer.d.ts

@@ -1,43 +1,26 @@
-/**
- * Stateful, line-oriented classifier for hashline diff text.
- *
- * The {@link Tokenizer} can be fed in chunks ({@link Tokenizer.feed}/{@link
- * Tokenizer.end}) for streaming use, or in one shot ({@link
- * Tokenizer.tokenizeAll}). Each emitted token carries its 1-indexed source
- * line number so downstream consumers (parser, validators, error messages)
- * can refer back to the input precisely.
- *
- * Format shape:
- * ```
- * *** path/to/file.ts#0A3
- * @@ 5,7 @@
- * +literal new line
- * &3,4
- * ```
- * Each `***` line opens a new file section; each `@@ A,B @@` line opens a
- * new hunk whose body (zero or more `+`/`&` rows) replaces the selected
- * range. Empty body = delete the selected range.
- */
 import type { Anchor, Cursor, ParsedRange } from "./types";
-/**
- * Split a hashline diff into individual lines without losing the trailing
- * empty line that callers may rely on for explicit blank payloads. CRLF pairs
- * are normalized to a single line break.
- */
 export declare function splitHashlineLines(text: string): string[];
 export declare function cloneCursor(cursor: Cursor): Cursor;
 /** Parse a bare line-number anchor. Throws on malformed input. */
 export declare function parseLid(raw: string, lineNum: number): Anchor;
 export type BlockTarget = {
-    kind: "range";
+    kind: "replace";
     range: ParsedRange;
+} | {
+    kind: "delete";
+    range: ParsedRange;
+} | {
+    kind: "insert_before";
+    anchor: Anchor;
+} | {
+    kind: "insert_after";
+    anchor: Anchor;
 } | {
     kind: "bof";
 } | {
     kind: "eof";
 };
 interface TokenBase {
-    /** 1-indexed line number in the original input stream. */
     lineNum: number;
 }
 export type Token = (TokenBase & {
@@ -58,42 +41,16 @@ export type Token = (TokenBase & {
 }) | (TokenBase & {
     kind: "payload-literal";
     text: string;
-}) | (TokenBase & {
-    kind: "payload-repeat";
-    range: ParsedRange;
 }) | (TokenBase & {
     kind: "raw";
     text: string;
 });
-/**
- * Stateful, line-oriented classifier for hashline diff text. Use the
- * streaming {@link feed}/{@link end} pair to ingest text in chunks (each
- * completed line emits exactly one token; a trailing partial line stays
- * buffered until the next chunk or {@link end}). Use the stateless
- * {@link tokenize}/predicate methods for callers that already hold whole
- * lines and only need classification without buffering.
- */
 export declare class Tokenizer {
     #private;
-    /**
-     * Ingest a chunk of input text. Each newline-terminated line in the
-     * combined buffer produces one token. A trailing partial line (no `\n`
-     * yet, possibly ending in a lone `\r`) stays buffered until the next
-     * `feed`/`end` call so CRLF pairs that straddle chunk boundaries are
-     * still normalized correctly.
-     */
     feed(chunk: string): Token[];
-    /**
-     * Flush any buffered residual line (the last line of input when it lacks
-     * a trailing newline) and mark the tokenizer closed. Calling `end` a
-     * second time returns `[]`; reuse requires `reset`.
-     */
     end(): Token[];
-    /** Discard any buffered text and reset the line counter to 1. */
     reset(): void;
-    /** Convenience: feed an entire text and immediately flush. */
     tokenizeAll(text: string): Token[];
-    /** Stateless one-shot classification. Does not touch the streaming buffer. */
     tokenize(line: string, lineNum?: number): Token;
     isOp(line: string): boolean;
     isHeader(line: string): boolean;

package/dist/types/types.d.ts

@@ -7,7 +7,7 @@
 export interface Anchor {
     line: number;
 }
-/** Where an `insert` or `repeat` edit should land relative to existing content. */
+/** Where an `insert` edit should land relative to existing content. */
 export type Cursor = {
     kind: "bof";
 } | {
@@ -15,12 +15,15 @@ export type Cursor = {
 } | {
     kind: "before_anchor";
     anchor: Anchor;
+} | {
+    kind: "after_anchor";
+    anchor: Anchor;
 };
 /**
  * A single low-level edit produced by the parser and consumed by the applier.
- * Multi-line replacements decompose to one `insert`/`repeat` per replacement
- * line plus one `delete` per consumed line. Replacement payloads are tagged so
- * the applier can distinguish literal insertion from new content for a deleted
+ * Multi-line replacements decompose to one `insert` per replacement line plus
+ * one `delete` per consumed line. Replacement payloads are tagged so the
+ * applier can distinguish literal insertion from new content for a deleted
  * line.
  */
 export type Edit = {
@@ -30,13 +33,6 @@ export type Edit = {
     lineNum: number;
     index: number;
     mode?: "replacement";
-} | {
-    kind: "repeat";
-    cursor: Cursor;
-    range: ParsedRange;
-    lineNum: number;
-    index: number;
-    mode?: "replacement";
 } | {
     kind: "delete";
     anchor: Anchor;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/hashline",
-	"version": "15.5.12",
+	"version": "15.5.13",
 	"description": "Hashline: a compact, line-anchored patch language and applier. Pluggable FS/IO so it works over disk, in-memory, or any custom backend.",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -33,7 +33,8 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"diff": "^9.0.0"
+		"diff": "^9.0.0",
+		"lru-cache": "11.3.6"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"