@bastani/atomic 0.9.2 → 0.9.3-alpha.2

package/dist/core/tools/hashline-engine/recovery.d.ts

@@ -0,0 +1,41 @@
+import type { SnapshotStore } from "./snapshots.js";
+import type { Edit } from "./types.js";
+export interface RecoveryArgs {
+    path: string;
+    currentText: string;
+    fileHash: string;
+    edits: readonly Edit[];
+}
+export interface RecoveryResult {
+    /** Post-recovery text. */
+    text: string;
+    /** First changed line (1-indexed) relative to the live `currentText`, or `undefined`. */
+    firstChangedLine: number | undefined;
+    /** Warnings collected during recovery, including the user-facing recovery banner. */
+    warnings: string[];
+}
+/**
+ * Stateless recovery driver over a {@link SnapshotStore}. Construct once and
+ * call {@link Recovery.tryRecover} per stale-tag incident. The default
+ * implementation tries two strategies in order:
+ *
+ * 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;
+    constructor(store: SnapshotStore);
+    /**
+     * Attempt recovery. Returns `null` when no path forward is found — the
+     * caller should then surface a {@link MismatchError}.
+     */
+    tryRecover(args: RecoveryArgs): RecoveryResult | null;
+}
+//# sourceMappingURL=recovery.d.ts.map

package/dist/core/tools/hashline-engine/recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../../../../src/core/tools/hashline-engine/recovery.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAY,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC9D,OAAO,KAAK,EAAuB,IAAI,EAAE,MAAM,YAAY,CAAC;AAO5D,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC9B,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,yFAAyF;IACzF,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,qFAAqF;IACrF,QAAQ,EAAE,MAAM,EAAE,CAAC;CACnB;AAkHD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,QAAQ;IACpB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,YAAY,KAAK,EAAE,aAAa,EAAyB;IACzD;;;OAGG;IACH,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,cAAc,GAAG,IAAI,CAcpD;CACD","sourcesContent":["// @generated vendored verbatim from oh-my-pi packages/hashline @ 15b5c1397fc -- DO NOT EDIT.\n// Parity source for the Atomic hashline edit engine (issue #1483); adapted only for Atomic's Node runtime (relative imports, Bun->Node host calls, erasable constructor syntax).\n/**\n * Recover from a stale section snapshot tag by replaying the would-be edit\n * against a cached pre-edit snapshot of the file and 3-way-merging the\n * result onto the current on-disk content.\n *\n * The patcher consults this when a section tag resolves to a snapshot that no\n * longer matches the live file content. The recovery class is stateless apart\n * from the {@link SnapshotStore} it queries; the snapshot store is the seam\n * lets you plug in your own caching strategy.\n */\nimport * as Diff from \"diff\";\nimport { applyEdits } from \"./apply.js\";\nimport { RECOVERY_EXTERNAL_WARNING, RECOVERY_SESSION_CHAIN_WARNING, RECOVERY_SESSION_REPLAY_WARNING } from \"./messages.js\";\nimport type { Snapshot, SnapshotStore } from \"./snapshots.js\";\nimport type { Anchor, ApplyResult, Edit } from \"./types.js\";\n\n// Section tags are line-precise; never let Diff.applyPatch slide a hunk\n// onto a duplicate closer 100+ lines away. If snapshot replay does not\n// align exactly, refuse and let the caller re-read.\nconst RECOVERY_FUZZ_FACTOR = 0;\n\nexport interface RecoveryArgs {\n\tpath: string;\n\tcurrentText: string;\n\tfileHash: string;\n\tedits: readonly Edit[];\n}\n\nexport interface RecoveryResult {\n\t/** Post-recovery text. */\n\ttext: string;\n\t/** First changed line (1-indexed) relative to the live `currentText`, or `undefined`. */\n\tfirstChangedLine: number | undefined;\n\t/** Warnings collected during recovery, including the user-facing recovery banner. */\n\twarnings: string[];\n}\n\nfunction applyEditsToSnapshot(\n\tpreviousText: string,\n\tcurrentText: string,\n\tedits: readonly Edit[],\n\trecoveryWarning: string,\n): RecoveryResult | null {\n\tlet applied: ApplyResult;\n\ttry {\n\t\tapplied = applyEdits(previousText, [...edits]);\n\t} catch {\n\t\treturn null;\n\t}\n\tif (applied.text === previousText) return null;\n\n\tconst patch = Diff.structuredPatch(\"file\", \"file\", previousText, applied.text, \"\", \"\", { context: 3 });\n\tconst merged = Diff.applyPatch(currentText, patch, { fuzzFactor: RECOVERY_FUZZ_FACTOR });\n\tif (typeof merged !== \"string\" || merged === currentText) return null;\n\n\tconst firstChangedLine = findFirstChangedLine(currentText, merged) ?? applied.firstChangedLine;\n\tconst hasNetChange = firstChangedLine !== undefined;\n\tconst warnings = hasNetChange ? [recoveryWarning, ...(applied.warnings ?? [])] : [...(applied.warnings ?? [])];\n\n\treturn { text: merged, firstChangedLine, warnings };\n}\n\nfunction collectAnchorLines(edits: readonly Edit[]): number[] {\n\tconst lines: number[] = [];\n\tfor (const edit of edits) {\n\t\tfor (const anchor of getEditAnchors(edit)) lines.push(anchor.line);\n\t}\n\treturn lines;\n}\n\nfunction getEditAnchors(edit: Edit): Anchor[] {\n\tif (edit.kind === \"delete\") return [edit.anchor];\n\t// Recovery only ever receives already-resolved edits (no `block`); this arm\n\t// exists for type-exhaustiveness over the full `Edit` union.\n\tif (edit.kind === \"block\") return [edit.anchor];\n\treturn edit.cursor.kind === \"before_anchor\" || edit.cursor.kind === \"after_anchor\" ? [edit.cursor.anchor] : [];\n}\n\n/**\n * Returns true when every anchor line in `edits` has identical content in\n * `previousText` and `currentText`. The session-chain replay fast-path\n * requires this: if the prior in-session edit rewrote the line the model is\n * now re-targeting with a stale hash, replaying onto current would silently\n * overwrite the new content with whatever the model authored against the\n * old content — a corruption window, not a recovery.\n */\nfunction verifyAnchorContent(previousText: string, currentText: string, edits: readonly Edit[]): boolean {\n\tconst lines = collectAnchorLines(edits);\n\tif (lines.length === 0) return true;\n\tconst prev = previousText.split(\"\\n\");\n\tconst curr = currentText.split(\"\\n\");\n\tfor (const line of lines) {\n\t\tconst idx = line - 1;\n\t\tif (idx < 0 || idx >= prev.length || idx >= curr.length) return false;\n\t\tif (prev[idx] !== curr[idx]) return false;\n\t}\n\treturn true;\n}\n\nfunction replaySessionChainOnCurrent(\n\tpreviousText: string,\n\tcurrentText: string,\n\tedits: readonly Edit[],\n): RecoveryResult | null {\n\t// Two guards narrow the corruption window. Neither alone is sufficient,\n\t// and even together they don't fully prove correctness — replay is the\n\t// less-certain recovery mode and emits RECOVERY_SESSION_REPLAY_WARNING\n\t// so the caller can verify the diff.\n\t//   - Equal line counts: every line number in `edits` still resolves to\n\t//     SOME logical row (no net shift across the prior chain). A\n\t//     coincidental insert+delete pair can still leave indices pointing\n\t//     at different logical rows than the model anchored against.\n\t//   - Anchor-content alignment: the row at each anchor's line index has\n\t//     identical content in previous and current. Catches the common\n\t//     case of a prior edit rewriting the targeted line; can still be\n\t//     coincidentally satisfied by a duplicated row at the shifted\n\t//     index.\n\tif (previousText.split(\"\\n\").length !== currentText.split(\"\\n\").length) return null;\n\tif (!verifyAnchorContent(previousText, currentText, edits)) return null;\n\tlet applied: ApplyResult;\n\ttry {\n\t\tapplied = applyEdits(currentText, [...edits]);\n\t} catch {\n\t\treturn null;\n\t}\n\tif (applied.text === currentText) return null;\n\treturn {\n\t\ttext: applied.text,\n\t\tfirstChangedLine: applied.firstChangedLine,\n\t\twarnings: [RECOVERY_SESSION_REPLAY_WARNING, ...(applied.warnings ?? [])],\n\t};\n}\n\n/** First 1-indexed line at which `a` and `b` diverge, or `undefined` if equal. */\nfunction findFirstChangedLine(a: string, b: string): number | undefined {\n\tif (a === b) return undefined;\n\tconst aLines = a.split(\"\\n\");\n\tconst bLines = b.split(\"\\n\");\n\tconst max = Math.max(aLines.length, bLines.length);\n\tfor (let i = 0; i < max; i++) {\n\t\tif (aLines[i] !== bLines[i]) return i + 1;\n\t}\n\treturn undefined;\n}\n\nfunction isHeadSnapshot(head: Snapshot | null, snapshot: Snapshot): boolean {\n\treturn head === snapshot;\n}\n\n/**\n * Stateless recovery driver over a {@link SnapshotStore}. Construct once and\n * call {@link Recovery.tryRecover} per stale-tag incident. The default\n * implementation tries two strategies in order:\n *\n * 1. Apply the edits on the full-file version the tag names, then 3-way-merge\n *    the resulting patch onto the live content (handles external writes).\n * 2. (Session chain) If that version wasn't the head, replay the edits onto\n *    the live content directly when line counts match AND every edit's anchor\n *    line content is unchanged between version and current — a prior in-session\n *    edit advanced the tag and the model's anchors still name the same logical\n *    rows. Emits a dedicated {@link RECOVERY_SESSION_REPLAY_WARNING} because\n *    even with both guards a coincidental insert+delete pair on duplicate rows\n *    can still land the edit on the wrong row; see {@link replaySessionChainOnCurrent}.\n */\nexport class Recovery {\n\treadonly store: SnapshotStore;\n\tconstructor(store: SnapshotStore) { this.store = store; }\n\t/**\n\t * Attempt recovery. Returns `null` when no path forward is found — the\n\t * caller should then surface a {@link MismatchError}.\n\t */\n\ttryRecover(args: RecoveryArgs): RecoveryResult | null {\n\t\tconst { path, currentText, fileHash, edits } = args;\n\t\tconst snapshot = this.store.byHash(path, fileHash);\n\t\tif (!snapshot) return null;\n\t\tconst isHead = isHeadSnapshot(this.store.head(path), snapshot);\n\t\tconst recoveryWarning = isHead ? RECOVERY_EXTERNAL_WARNING : RECOVERY_SESSION_CHAIN_WARNING;\n\t\tconst merged = applyEditsToSnapshot(snapshot.text, currentText, edits, recoveryWarning);\n\t\tif (merged !== null) return merged;\n\t\t// Session-chain fallback: the 3-way merge on the version refused.\n\t\t// Replay onto current is gated by line-count equality AND\n\t\t// anchor-content alignment — see `replaySessionChainOnCurrent`\n\t\t// for why both guards together still don't fully prove correctness.\n\t\tif (!isHead) return replaySessionChainOnCurrent(snapshot.text, currentText, edits);\n\t\treturn null;\n\t}\n}\n"]}

package/dist/core/tools/hashline-engine/recovery.js

@@ -0,0 +1,168 @@
+// @generated vendored verbatim from oh-my-pi packages/hashline @ 15b5c1397fc -- DO NOT EDIT.
+// Parity source for the Atomic hashline edit engine (issue #1483); adapted only for Atomic's Node runtime (relative imports, Bun->Node host calls, erasable constructor syntax).
+/**
+ * Recover from a stale section snapshot tag by replaying the would-be edit
+ * against a cached pre-edit snapshot of the file and 3-way-merging the
+ * result onto the current on-disk content.
+ *
+ * The patcher consults this when a section tag resolves to a snapshot that no
+ * longer matches the live file content. The recovery class is stateless apart
+ * from the {@link SnapshotStore} it queries; the snapshot store is the seam
+ * lets you plug in your own caching strategy.
+ */
+import * as Diff from "diff";
+import { applyEdits } from "./apply.js";
+import { RECOVERY_EXTERNAL_WARNING, RECOVERY_SESSION_CHAIN_WARNING, RECOVERY_SESSION_REPLAY_WARNING } from "./messages.js";
+// Section tags are line-precise; never let Diff.applyPatch slide a hunk
+// onto a duplicate closer 100+ lines away. If snapshot replay does not
+// align exactly, refuse and let the caller re-read.
+const RECOVERY_FUZZ_FACTOR = 0;
+function applyEditsToSnapshot(previousText, currentText, edits, recoveryWarning) {
+    let applied;
+    try {
+        applied = applyEdits(previousText, [...edits]);
+    }
+    catch {
+        return null;
+    }
+    if (applied.text === previousText)
+        return null;
+    const patch = Diff.structuredPatch("file", "file", previousText, applied.text, "", "", { context: 3 });
+    const merged = Diff.applyPatch(currentText, patch, { fuzzFactor: RECOVERY_FUZZ_FACTOR });
+    if (typeof merged !== "string" || merged === currentText)
+        return null;
+    const firstChangedLine = findFirstChangedLine(currentText, merged) ?? applied.firstChangedLine;
+    const hasNetChange = firstChangedLine !== undefined;
+    const warnings = hasNetChange ? [recoveryWarning, ...(applied.warnings ?? [])] : [...(applied.warnings ?? [])];
+    return { text: merged, firstChangedLine, warnings };
+}
+function collectAnchorLines(edits) {
+    const lines = [];
+    for (const edit of edits) {
+        for (const anchor of getEditAnchors(edit))
+            lines.push(anchor.line);
+    }
+    return lines;
+}
+function getEditAnchors(edit) {
+    if (edit.kind === "delete")
+        return [edit.anchor];
+    // Recovery only ever receives already-resolved edits (no `block`); this arm
+    // exists for type-exhaustiveness over the full `Edit` union.
+    if (edit.kind === "block")
+        return [edit.anchor];
+    return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor" ? [edit.cursor.anchor] : [];
+}
+/**
+ * Returns true when every anchor line in `edits` has identical content in
+ * `previousText` and `currentText`. The session-chain replay fast-path
+ * requires this: if the prior in-session edit rewrote the line the model is
+ * now re-targeting with a stale hash, replaying onto current would silently
+ * overwrite the new content with whatever the model authored against the
+ * old content — a corruption window, not a recovery.
+ */
+function verifyAnchorContent(previousText, currentText, edits) {
+    const lines = collectAnchorLines(edits);
+    if (lines.length === 0)
+        return true;
+    const prev = previousText.split("\n");
+    const curr = currentText.split("\n");
+    for (const line of lines) {
+        const idx = line - 1;
+        if (idx < 0 || idx >= prev.length || idx >= curr.length)
+            return false;
+        if (prev[idx] !== curr[idx])
+            return false;
+    }
+    return true;
+}
+function replaySessionChainOnCurrent(previousText, currentText, edits) {
+    // Two guards narrow the corruption window. Neither alone is sufficient,
+    // and even together they don't fully prove correctness — replay is the
+    // less-certain recovery mode and emits RECOVERY_SESSION_REPLAY_WARNING
+    // so the caller can verify the diff.
+    //   - Equal line counts: every line number in `edits` still resolves to
+    //     SOME logical row (no net shift across the prior chain). A
+    //     coincidental insert+delete pair can still leave indices pointing
+    //     at different logical rows than the model anchored against.
+    //   - Anchor-content alignment: the row at each anchor's line index has
+    //     identical content in previous and current. Catches the common
+    //     case of a prior edit rewriting the targeted line; can still be
+    //     coincidentally satisfied by a duplicated row at the shifted
+    //     index.
+    if (previousText.split("\n").length !== currentText.split("\n").length)
+        return null;
+    if (!verifyAnchorContent(previousText, currentText, edits))
+        return null;
+    let applied;
+    try {
+        applied = applyEdits(currentText, [...edits]);
+    }
+    catch {
+        return null;
+    }
+    if (applied.text === currentText)
+        return null;
+    return {
+        text: applied.text,
+        firstChangedLine: applied.firstChangedLine,
+        warnings: [RECOVERY_SESSION_REPLAY_WARNING, ...(applied.warnings ?? [])],
+    };
+}
+/** First 1-indexed line at which `a` and `b` diverge, or `undefined` if equal. */
+function findFirstChangedLine(a, b) {
+    if (a === b)
+        return undefined;
+    const aLines = a.split("\n");
+    const bLines = b.split("\n");
+    const max = Math.max(aLines.length, bLines.length);
+    for (let i = 0; i < max; i++) {
+        if (aLines[i] !== bLines[i])
+            return i + 1;
+    }
+    return undefined;
+}
+function isHeadSnapshot(head, snapshot) {
+    return head === snapshot;
+}
+/**
+ * Stateless recovery driver over a {@link SnapshotStore}. Construct once and
+ * call {@link Recovery.tryRecover} per stale-tag incident. The default
+ * implementation tries two strategies in order:
+ *
+ * 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 class Recovery {
+    constructor(store) { this.store = store; }
+    /**
+     * Attempt recovery. Returns `null` when no path forward is found — the
+     * caller should then surface a {@link MismatchError}.
+     */
+    tryRecover(args) {
+        const { path, currentText, fileHash, edits } = args;
+        const snapshot = this.store.byHash(path, fileHash);
+        if (!snapshot)
+            return null;
+        const isHead = isHeadSnapshot(this.store.head(path), snapshot);
+        const recoveryWarning = isHead ? RECOVERY_EXTERNAL_WARNING : RECOVERY_SESSION_CHAIN_WARNING;
+        const merged = applyEditsToSnapshot(snapshot.text, currentText, edits, recoveryWarning);
+        if (merged !== null)
+            return merged;
+        // Session-chain fallback: the 3-way merge on the version refused.
+        // Replay onto current is gated by line-count equality AND
+        // anchor-content alignment — see `replaySessionChainOnCurrent`
+        // for why both guards together still don't fully prove correctness.
+        if (!isHead)
+            return replaySessionChainOnCurrent(snapshot.text, currentText, edits);
+        return null;
+    }
+}
+//# sourceMappingURL=recovery.js.map

package/dist/core/tools/hashline-engine/recovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.js","sourceRoot":"","sources":["../../../../src/core/tools/hashline-engine/recovery.ts"],"names":[],"mappings":"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","sourcesContent":["// @generated vendored verbatim from oh-my-pi packages/hashline @ 15b5c1397fc -- DO NOT EDIT.\n// Parity source for the Atomic hashline edit engine (issue #1483); adapted only for Atomic's Node runtime (relative imports, Bun->Node host calls, erasable constructor syntax).\n/**\n * Recover from a stale section snapshot tag by replaying the would-be edit\n * against a cached pre-edit snapshot of the file and 3-way-merging the\n * result onto the current on-disk content.\n *\n * The patcher consults this when a section tag resolves to a snapshot that no\n * longer matches the live file content. The recovery class is stateless apart\n * from the {@link SnapshotStore} it queries; the snapshot store is the seam\n * lets you plug in your own caching strategy.\n */\nimport * as Diff from \"diff\";\nimport { applyEdits } from \"./apply.js\";\nimport { RECOVERY_EXTERNAL_WARNING, RECOVERY_SESSION_CHAIN_WARNING, RECOVERY_SESSION_REPLAY_WARNING } from \"./messages.js\";\nimport type { Snapshot, SnapshotStore } from \"./snapshots.js\";\nimport type { Anchor, ApplyResult, Edit } from \"./types.js\";\n\n// Section tags are line-precise; never let Diff.applyPatch slide a hunk\n// onto a duplicate closer 100+ lines away. If snapshot replay does not\n// align exactly, refuse and let the caller re-read.\nconst RECOVERY_FUZZ_FACTOR = 0;\n\nexport interface RecoveryArgs {\n\tpath: string;\n\tcurrentText: string;\n\tfileHash: string;\n\tedits: readonly Edit[];\n}\n\nexport interface RecoveryResult {\n\t/** Post-recovery text. */\n\ttext: string;\n\t/** First changed line (1-indexed) relative to the live `currentText`, or `undefined`. */\n\tfirstChangedLine: number | undefined;\n\t/** Warnings collected during recovery, including the user-facing recovery banner. */\n\twarnings: string[];\n}\n\nfunction applyEditsToSnapshot(\n\tpreviousText: string,\n\tcurrentText: string,\n\tedits: readonly Edit[],\n\trecoveryWarning: string,\n): RecoveryResult | null {\n\tlet applied: ApplyResult;\n\ttry {\n\t\tapplied = applyEdits(previousText, [...edits]);\n\t} catch {\n\t\treturn null;\n\t}\n\tif (applied.text === previousText) return null;\n\n\tconst patch = Diff.structuredPatch(\"file\", \"file\", previousText, applied.text, \"\", \"\", { context: 3 });\n\tconst merged = Diff.applyPatch(currentText, patch, { fuzzFactor: RECOVERY_FUZZ_FACTOR });\n\tif (typeof merged !== \"string\" || merged === currentText) return null;\n\n\tconst firstChangedLine = findFirstChangedLine(currentText, merged) ?? applied.firstChangedLine;\n\tconst hasNetChange = firstChangedLine !== undefined;\n\tconst warnings = hasNetChange ? [recoveryWarning, ...(applied.warnings ?? [])] : [...(applied.warnings ?? [])];\n\n\treturn { text: merged, firstChangedLine, warnings };\n}\n\nfunction collectAnchorLines(edits: readonly Edit[]): number[] {\n\tconst lines: number[] = [];\n\tfor (const edit of edits) {\n\t\tfor (const anchor of getEditAnchors(edit)) lines.push(anchor.line);\n\t}\n\treturn lines;\n}\n\nfunction getEditAnchors(edit: Edit): Anchor[] {\n\tif (edit.kind === \"delete\") return [edit.anchor];\n\t// Recovery only ever receives already-resolved edits (no `block`); this arm\n\t// exists for type-exhaustiveness over the full `Edit` union.\n\tif (edit.kind === \"block\") return [edit.anchor];\n\treturn edit.cursor.kind === \"before_anchor\" || edit.cursor.kind === \"after_anchor\" ? [edit.cursor.anchor] : [];\n}\n\n/**\n * Returns true when every anchor line in `edits` has identical content in\n * `previousText` and `currentText`. The session-chain replay fast-path\n * requires this: if the prior in-session edit rewrote the line the model is\n * now re-targeting with a stale hash, replaying onto current would silently\n * overwrite the new content with whatever the model authored against the\n * old content — a corruption window, not a recovery.\n */\nfunction verifyAnchorContent(previousText: string, currentText: string, edits: readonly Edit[]): boolean {\n\tconst lines = collectAnchorLines(edits);\n\tif (lines.length === 0) return true;\n\tconst prev = previousText.split(\"\\n\");\n\tconst curr = currentText.split(\"\\n\");\n\tfor (const line of lines) {\n\t\tconst idx = line - 1;\n\t\tif (idx < 0 || idx >= prev.length || idx >= curr.length) return false;\n\t\tif (prev[idx] !== curr[idx]) return false;\n\t}\n\treturn true;\n}\n\nfunction replaySessionChainOnCurrent(\n\tpreviousText: string,\n\tcurrentText: string,\n\tedits: readonly Edit[],\n): RecoveryResult | null {\n\t// Two guards narrow the corruption window. Neither alone is sufficient,\n\t// and even together they don't fully prove correctness — replay is the\n\t// less-certain recovery mode and emits RECOVERY_SESSION_REPLAY_WARNING\n\t// so the caller can verify the diff.\n\t//   - Equal line counts: every line number in `edits` still resolves to\n\t//     SOME logical row (no net shift across the prior chain). A\n\t//     coincidental insert+delete pair can still leave indices pointing\n\t//     at different logical rows than the model anchored against.\n\t//   - Anchor-content alignment: the row at each anchor's line index has\n\t//     identical content in previous and current. Catches the common\n\t//     case of a prior edit rewriting the targeted line; can still be\n\t//     coincidentally satisfied by a duplicated row at the shifted\n\t//     index.\n\tif (previousText.split(\"\\n\").length !== currentText.split(\"\\n\").length) return null;\n\tif (!verifyAnchorContent(previousText, currentText, edits)) return null;\n\tlet applied: ApplyResult;\n\ttry {\n\t\tapplied = applyEdits(currentText, [...edits]);\n\t} catch {\n\t\treturn null;\n\t}\n\tif (applied.text === currentText) return null;\n\treturn {\n\t\ttext: applied.text,\n\t\tfirstChangedLine: applied.firstChangedLine,\n\t\twarnings: [RECOVERY_SESSION_REPLAY_WARNING, ...(applied.warnings ?? [])],\n\t};\n}\n\n/** First 1-indexed line at which `a` and `b` diverge, or `undefined` if equal. */\nfunction findFirstChangedLine(a: string, b: string): number | undefined {\n\tif (a === b) return undefined;\n\tconst aLines = a.split(\"\\n\");\n\tconst bLines = b.split(\"\\n\");\n\tconst max = Math.max(aLines.length, bLines.length);\n\tfor (let i = 0; i < max; i++) {\n\t\tif (aLines[i] !== bLines[i]) return i + 1;\n\t}\n\treturn undefined;\n}\n\nfunction isHeadSnapshot(head: Snapshot | null, snapshot: Snapshot): boolean {\n\treturn head === snapshot;\n}\n\n/**\n * Stateless recovery driver over a {@link SnapshotStore}. Construct once and\n * call {@link Recovery.tryRecover} per stale-tag incident. The default\n * implementation tries two strategies in order:\n *\n * 1. Apply the edits on the full-file version the tag names, then 3-way-merge\n *    the resulting patch onto the live content (handles external writes).\n * 2. (Session chain) If that version wasn't the head, replay the edits onto\n *    the live content directly when line counts match AND every edit's anchor\n *    line content is unchanged between version and current — a prior in-session\n *    edit advanced the tag and the model's anchors still name the same logical\n *    rows. Emits a dedicated {@link RECOVERY_SESSION_REPLAY_WARNING} because\n *    even with both guards a coincidental insert+delete pair on duplicate rows\n *    can still land the edit on the wrong row; see {@link replaySessionChainOnCurrent}.\n */\nexport class Recovery {\n\treadonly store: SnapshotStore;\n\tconstructor(store: SnapshotStore) { this.store = store; }\n\t/**\n\t * Attempt recovery. Returns `null` when no path forward is found — the\n\t * caller should then surface a {@link MismatchError}.\n\t */\n\ttryRecover(args: RecoveryArgs): RecoveryResult | null {\n\t\tconst { path, currentText, fileHash, edits } = args;\n\t\tconst snapshot = this.store.byHash(path, fileHash);\n\t\tif (!snapshot) return null;\n\t\tconst isHead = isHeadSnapshot(this.store.head(path), snapshot);\n\t\tconst recoveryWarning = isHead ? RECOVERY_EXTERNAL_WARNING : RECOVERY_SESSION_CHAIN_WARNING;\n\t\tconst merged = applyEditsToSnapshot(snapshot.text, currentText, edits, recoveryWarning);\n\t\tif (merged !== null) return merged;\n\t\t// Session-chain fallback: the 3-way merge on the version refused.\n\t\t// Replay onto current is gated by line-count equality AND\n\t\t// anchor-content alignment — see `replaySessionChainOnCurrent`\n\t\t// for why both guards together still don't fully prove correctness.\n\t\tif (!isHead) return replaySessionChainOnCurrent(snapshot.text, currentText, edits);\n\t\treturn null;\n\t}\n}\n"]}

package/dist/core/tools/hashline-engine/snapshots.d.ts

@@ -0,0 +1,65 @@
+/**
+ * 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}.
+ */
+export interface Snapshot {
+    /** Canonical path this version belongs to. */
+    readonly path: 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 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 recorded version for `path`, or `null` if none. */
+    abstract head(path: string): Snapshot | null;
+    /** Recorded unambiguous version for `path` whose tag equals `hash`, or `null`. */
+    abstract byHash(path: string, hash: string): Snapshot | null;
+    /** Recorded version for `path` whose tag and full text both match, or `null`. */
+    byHashAndText(path: string, hash: string, text: 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 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;
+    /**
+     * Global ceiling on retained snapshot text summed across every path's
+     * version history, measured in UTF-16 code units (default 64 MiB).
+     * Least-recently-used path histories are evicted to stay under it.
+     */
+    maxTotalBytes?: number;
+}
+/**
+ * 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, hash: string): Snapshot | null;
+    byHashAndText(path: string, hash: string, text: string): Snapshot | null;
+    record(path: string, fullText: string): string;
+    invalidate(path: string): void;
+    clear(): void;
+}
+//# sourceMappingURL=snapshots.d.ts.map

package/dist/core/tools/hashline-engine/snapshots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshots.d.ts","sourceRoot":"","sources":["../../../../src/core/tools/hashline-engine/snapshots.ts"],"names":[],"mappings":"AA2BA;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACxB,8CAA8C;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,mFAAmF;IACnF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,8BAAsB,aAAa;IAClC,oEAAoE;IACpE,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAAC;IAE7C,kFAAkF;IAClF,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAAC;IAE7D,iFAAiF;IACjF,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAGvE;IAED,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAExD,kDAAkD;IAClD,QAAQ,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAExC,kCAAkC;IAClC,QAAQ,CAAC,KAAK,IAAI,IAAI,CAAC;CACvB;AAOD,MAAM,WAAW,4BAA4B;IAC5C,mFAAmF;IACnF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sFAAsF;IACtF,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,qBAAa,qBAAsB,SAAQ,aAAa;;IAIvD,YAAY,OAAO,GAAE,4BAAiC,EAYrD;IAED,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAElC;IAED,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAKlD;IAEQ,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAEhF;IAED,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAoB7C;IAED,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAE7B;IAED,KAAK,IAAI,IAAI,CAEZ;CACD","sourcesContent":["// @generated vendored verbatim from oh-my-pi packages/hashline @ 15b5c1397fc -- DO NOT EDIT.\n// Parity source for the Atomic hashline edit engine (issue #1483); adapted only for Atomic's Node runtime (relative imports, Bun->Node host calls, erasable constructor syntax).\n/**\n * Per-session snapshot store used by {@link Recovery} and {@link Patcher} to\n * bind hashline section tags to the exact file content that minted them.\n *\n * A section tag is a content-derived hash of the *whole file* (see\n * {@link computeFileHash}). Any read of byte-identical content mints the same\n * tag, so reads of one file state fuse onto one anchor and a follow-up edit\n * anchored at any line validates whenever the live file still hashes to it.\n *\n * Producers (typically `read` / `search` / `write` tools) call\n * {@link SnapshotStore.record} with the full normalized text they observed.\n * The store hashes it, dedups against the per-path history, and returns the\n * tag. Consumers (the patcher) resolve an unambiguous stale tag back to the\n * recorded full text via {@link SnapshotStore.byHash} and 3-way-merge the\n * would-be edit onto the live content.\n *\n * The abstract base class lets callers plug in whatever storage they like\n * (LRU, persistent SQLite, etc.). {@link InMemorySnapshotStore} ships as a\n * sensible default backed by `lru-cache`: a bounded set of paths, each with a\n * short history of full-file versions so in-session edit chains can still\n * recover against the version a stale tag names.\n */\nimport { LRUCache } from \"lru-cache/raw\";\nimport { computeFileHash } from \"./format.js\";\n\n/**\n * One full-file version observed at a point in time. The tag the model sees is\n * {@link Snapshot.hash}; recovery replays edits against {@link Snapshot.text}.\n */\nexport interface Snapshot {\n\t/** Canonical path this version belongs to. */\n\treadonly path: string;\n\t/** Full normalized (LF, no BOM) file text as observed. */\n\treadonly text: string;\n\t/** Content-derived tag for {@link Snapshot.text} (see {@link computeFileHash}). */\n\treadonly hash: string;\n\t/** Timestamp (ms since epoch) the version was recorded. */\n\trecordedAt: number;\n}\n\n/**\n * Storage seam for full-file version snapshots. The patcher calls {@link head}\n * for the latest version of a path and {@link byHash} when it needs the\n * specific historical version a section's stale tag names.\n */\nexport abstract class SnapshotStore {\n\t/** Most-recently recorded version for `path`, or `null` if none. */\n\tabstract head(path: string): Snapshot | null;\n\n\t/** Recorded unambiguous version for `path` whose tag equals `hash`, or `null`. */\n\tabstract byHash(path: string, hash: string): Snapshot | null;\n\n\t/** Recorded version for `path` whose tag and full text both match, or `null`. */\n\tbyHashAndText(path: string, hash: string, text: string): Snapshot | null {\n\t\tconst snapshot = this.byHash(path, hash);\n\t\treturn snapshot?.text === text ? snapshot : null;\n\t}\n\n\t/** Record the full normalized text of `path` and return its content tag. */\n\tabstract record(path: string, fullText: string): string;\n\n\t/** Drop the version history for a single path. */\n\tabstract invalidate(path: string): void;\n\n\t/** Drop every version history. */\n\tabstract clear(): void;\n}\n\nconst DEFAULT_MAX_PATHS = 30;\nconst DEFAULT_MAX_VERSIONS_PER_PATH = 4;\n/** Global ceiling on retained snapshot text across all paths (UTF-16 code units). */\nconst DEFAULT_MAX_TOTAL_BYTES = 64 * 1024 * 1024;\n\nexport interface InMemorySnapshotStoreOptions {\n\t/** Maximum number of distinct paths tracked at once (default 30). LRU eviction. */\n\tmaxPaths?: number;\n\t/** Maximum full-file versions retained per path (default 4). Oldest dropped first. */\n\tmaxVersionsPerPath?: number;\n\t/**\n\t * Global ceiling on retained snapshot text summed across every path's\n\t * version history, measured in UTF-16 code units (default 64 MiB).\n\t * Least-recently-used path histories are evicted to stay under it.\n\t */\n\tmaxTotalBytes?: number;\n}\n\n/**\n * In-memory {@link SnapshotStore} backed by `lru-cache`. Per-path history is a\n * short ring of full-file versions (oldest dropped first); per-session path\n * tracking is LRU-bounded so cold paths age out automatically.\n *\n * Recording byte-identical content again refreshes recency and reuses the\n * existing tag (read fusion); recording new content unshifts a fresh version\n * onto the front of the path history.\n */\nexport class InMemorySnapshotStore extends SnapshotStore {\n\treadonly #versions: LRUCache<string, Snapshot[]>;\n\treadonly #maxVersionsPerPath: number;\n\n\tconstructor(options: InMemorySnapshotStoreOptions = {}) {\n\t\tsuper();\n\t\tthis.#versions = new LRUCache<string, Snapshot[]>({\n\t\t\tmax: options.maxPaths ?? DEFAULT_MAX_PATHS,\n\t\t\tmaxSize: options.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES,\n\t\t\tsizeCalculation: history => {\n\t\t\t\tlet total = 1;\n\t\t\t\tfor (const version of history) total += version.text.length;\n\t\t\t\treturn total;\n\t\t\t},\n\t\t});\n\t\tthis.#maxVersionsPerPath = options.maxVersionsPerPath ?? DEFAULT_MAX_VERSIONS_PER_PATH;\n\t}\n\n\thead(path: string): Snapshot | null {\n\t\treturn this.#versions.get(path)?.[0] ?? null;\n\t}\n\n\tbyHash(path: string, hash: string): Snapshot | null {\n\t\tconst matches = this.#versions.get(path)?.filter(version => version.hash === hash) ?? [];\n\t\t// A 4-hex tag can collide. Recovery only proceeds when the tag maps to a\n\t\t// single retained snapshot; otherwise the caller must re-read.\n\t\treturn matches.length === 1 ? matches[0]! : null;\n\t}\n\n\toverride byHashAndText(path: string, hash: string, text: string): Snapshot | null {\n\t\treturn this.#versions.get(path)?.find(version => version.hash === hash && version.text === text) ?? null;\n\t}\n\n\trecord(path: string, fullText: string): string {\n\t\tconst hash = computeFileHash(fullText);\n\t\t// `get` refreshes LRU recency for `path`.\n\t\tconst history = this.#versions.get(path) ?? [];\n\t\tconst existing = history.find(version => version.hash === hash && version.text === fullText);\n\t\tif (existing) {\n\t\t\t// Same content state observed again: refresh recency and promote to\n\t\t\t// head (it is the current file content), then reuse the tag. Hash\n\t\t\t// collisions with different text must be retained as distinct\n\t\t\t// snapshots; the 4-hex tag is only a lookup key, not proof of identity.\n\t\t\texisting.recordedAt = Date.now();\n\t\t\tif (history[0] !== existing) {\n\t\t\t\tthis.#versions.set(path, [existing, ...history.filter(version => version !== existing)]);\n\t\t\t}\n\t\t\treturn hash;\n\t\t}\n\n\t\tconst snapshot: Snapshot = { path, text: fullText, hash, recordedAt: Date.now() };\n\t\tthis.#versions.set(path, [snapshot, ...history].slice(0, this.#maxVersionsPerPath));\n\t\treturn hash;\n\t}\n\n\tinvalidate(path: string): void {\n\t\tthis.#versions.delete(path);\n\t}\n\n\tclear(): void {\n\t\tthis.#versions.clear();\n\t}\n}\n"]}

package/dist/core/tools/hashline-engine/snapshots.js

@@ -0,0 +1,108 @@
+// @generated vendored verbatim from oh-my-pi packages/hashline @ 15b5c1397fc -- DO NOT EDIT.
+// Parity source for the Atomic hashline edit engine (issue #1483); adapted only for Atomic's Node runtime (relative imports, Bun->Node host calls, erasable constructor syntax).
+/**
+ * Per-session snapshot store used by {@link Recovery} and {@link Patcher} to
+ * bind hashline section tags to the exact file content that minted them.
+ *
+ * A section tag is a content-derived hash of the *whole file* (see
+ * {@link computeFileHash}). Any read of byte-identical content mints the same
+ * tag, so reads of one file state fuse onto one anchor and a follow-up edit
+ * anchored at any line validates whenever the live file still hashes to it.
+ *
+ * Producers (typically `read` / `search` / `write` tools) call
+ * {@link SnapshotStore.record} with the full normalized text they observed.
+ * The store hashes it, dedups against the per-path history, and returns the
+ * tag. Consumers (the patcher) resolve an unambiguous stale tag back to the
+ * recorded full text via {@link SnapshotStore.byHash} and 3-way-merge the
+ * would-be edit onto the live content.
+ *
+ * The abstract base class lets callers plug in whatever storage they like
+ * (LRU, persistent SQLite, etc.). {@link InMemorySnapshotStore} ships as a
+ * sensible default backed by `lru-cache`: a bounded set of paths, each with a
+ * short history of full-file versions so in-session edit chains can still
+ * recover against the version a stale tag names.
+ */
+import { LRUCache } from "lru-cache/raw";
+import { computeFileHash } from "./format.js";
+/**
+ * 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 class SnapshotStore {
+    /** Recorded version for `path` whose tag and full text both match, or `null`. */
+    byHashAndText(path, hash, text) {
+        const snapshot = this.byHash(path, hash);
+        return snapshot?.text === text ? snapshot : null;
+    }
+}
+const DEFAULT_MAX_PATHS = 30;
+const DEFAULT_MAX_VERSIONS_PER_PATH = 4;
+/** Global ceiling on retained snapshot text across all paths (UTF-16 code units). */
+const DEFAULT_MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+/**
+ * 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 class InMemorySnapshotStore extends SnapshotStore {
+    #versions;
+    #maxVersionsPerPath;
+    constructor(options = {}) {
+        super();
+        this.#versions = new LRUCache({
+            max: options.maxPaths ?? DEFAULT_MAX_PATHS,
+            maxSize: options.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES,
+            sizeCalculation: history => {
+                let total = 1;
+                for (const version of history)
+                    total += version.text.length;
+                return total;
+            },
+        });
+        this.#maxVersionsPerPath = options.maxVersionsPerPath ?? DEFAULT_MAX_VERSIONS_PER_PATH;
+    }
+    head(path) {
+        return this.#versions.get(path)?.[0] ?? null;
+    }
+    byHash(path, hash) {
+        const matches = this.#versions.get(path)?.filter(version => version.hash === hash) ?? [];
+        // A 4-hex tag can collide. Recovery only proceeds when the tag maps to a
+        // single retained snapshot; otherwise the caller must re-read.
+        return matches.length === 1 ? matches[0] : null;
+    }
+    byHashAndText(path, hash, text) {
+        return this.#versions.get(path)?.find(version => version.hash === hash && version.text === text) ?? null;
+    }
+    record(path, fullText) {
+        const hash = computeFileHash(fullText);
+        // `get` refreshes LRU recency for `path`.
+        const history = this.#versions.get(path) ?? [];
+        const existing = history.find(version => version.hash === hash && version.text === fullText);
+        if (existing) {
+            // Same content state observed again: refresh recency and promote to
+            // head (it is the current file content), then reuse the tag. Hash
+            // collisions with different text must be retained as distinct
+            // snapshots; the 4-hex tag is only a lookup key, not proof of identity.
+            existing.recordedAt = Date.now();
+            if (history[0] !== existing) {
+                this.#versions.set(path, [existing, ...history.filter(version => version !== existing)]);
+            }
+            return hash;
+        }
+        const snapshot = { path, text: fullText, hash, recordedAt: Date.now() };
+        this.#versions.set(path, [snapshot, ...history].slice(0, this.#maxVersionsPerPath));
+        return hash;
+    }
+    invalidate(path) {
+        this.#versions.delete(path);
+    }
+    clear() {
+        this.#versions.clear();
+    }
+}
+//# sourceMappingURL=snapshots.js.map

package/dist/core/tools/hashline-engine/snapshots.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshots.js","sourceRoot":"","sources":["../../../../src/core/tools/hashline-engine/snapshots.ts"],"names":[],"mappings":"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","sourcesContent":["// @generated vendored verbatim from oh-my-pi packages/hashline @ 15b5c1397fc -- DO NOT EDIT.\n// Parity source for the Atomic hashline edit engine (issue #1483); adapted only for Atomic's Node runtime (relative imports, Bun->Node host calls, erasable constructor syntax).\n/**\n * Per-session snapshot store used by {@link Recovery} and {@link Patcher} to\n * bind hashline section tags to the exact file content that minted them.\n *\n * A section tag is a content-derived hash of the *whole file* (see\n * {@link computeFileHash}). Any read of byte-identical content mints the same\n * tag, so reads of one file state fuse onto one anchor and a follow-up edit\n * anchored at any line validates whenever the live file still hashes to it.\n *\n * Producers (typically `read` / `search` / `write` tools) call\n * {@link SnapshotStore.record} with the full normalized text they observed.\n * The store hashes it, dedups against the per-path history, and returns the\n * tag. Consumers (the patcher) resolve an unambiguous stale tag back to the\n * recorded full text via {@link SnapshotStore.byHash} and 3-way-merge the\n * would-be edit onto the live content.\n *\n * The abstract base class lets callers plug in whatever storage they like\n * (LRU, persistent SQLite, etc.). {@link InMemorySnapshotStore} ships as a\n * sensible default backed by `lru-cache`: a bounded set of paths, each with a\n * short history of full-file versions so in-session edit chains can still\n * recover against the version a stale tag names.\n */\nimport { LRUCache } from \"lru-cache/raw\";\nimport { computeFileHash } from \"./format.js\";\n\n/**\n * One full-file version observed at a point in time. The tag the model sees is\n * {@link Snapshot.hash}; recovery replays edits against {@link Snapshot.text}.\n */\nexport interface Snapshot {\n\t/** Canonical path this version belongs to. */\n\treadonly path: string;\n\t/** Full normalized (LF, no BOM) file text as observed. */\n\treadonly text: string;\n\t/** Content-derived tag for {@link Snapshot.text} (see {@link computeFileHash}). */\n\treadonly hash: string;\n\t/** Timestamp (ms since epoch) the version was recorded. */\n\trecordedAt: number;\n}\n\n/**\n * Storage seam for full-file version snapshots. The patcher calls {@link head}\n * for the latest version of a path and {@link byHash} when it needs the\n * specific historical version a section's stale tag names.\n */\nexport abstract class SnapshotStore {\n\t/** Most-recently recorded version for `path`, or `null` if none. */\n\tabstract head(path: string): Snapshot | null;\n\n\t/** Recorded unambiguous version for `path` whose tag equals `hash`, or `null`. */\n\tabstract byHash(path: string, hash: string): Snapshot | null;\n\n\t/** Recorded version for `path` whose tag and full text both match, or `null`. */\n\tbyHashAndText(path: string, hash: string, text: string): Snapshot | null {\n\t\tconst snapshot = this.byHash(path, hash);\n\t\treturn snapshot?.text === text ? snapshot : null;\n\t}\n\n\t/** Record the full normalized text of `path` and return its content tag. */\n\tabstract record(path: string, fullText: string): string;\n\n\t/** Drop the version history for a single path. */\n\tabstract invalidate(path: string): void;\n\n\t/** Drop every version history. */\n\tabstract clear(): void;\n}\n\nconst DEFAULT_MAX_PATHS = 30;\nconst DEFAULT_MAX_VERSIONS_PER_PATH = 4;\n/** Global ceiling on retained snapshot text across all paths (UTF-16 code units). */\nconst DEFAULT_MAX_TOTAL_BYTES = 64 * 1024 * 1024;\n\nexport interface InMemorySnapshotStoreOptions {\n\t/** Maximum number of distinct paths tracked at once (default 30). LRU eviction. */\n\tmaxPaths?: number;\n\t/** Maximum full-file versions retained per path (default 4). Oldest dropped first. */\n\tmaxVersionsPerPath?: number;\n\t/**\n\t * Global ceiling on retained snapshot text summed across every path's\n\t * version history, measured in UTF-16 code units (default 64 MiB).\n\t * Least-recently-used path histories are evicted to stay under it.\n\t */\n\tmaxTotalBytes?: number;\n}\n\n/**\n * In-memory {@link SnapshotStore} backed by `lru-cache`. Per-path history is a\n * short ring of full-file versions (oldest dropped first); per-session path\n * tracking is LRU-bounded so cold paths age out automatically.\n *\n * Recording byte-identical content again refreshes recency and reuses the\n * existing tag (read fusion); recording new content unshifts a fresh version\n * onto the front of the path history.\n */\nexport class InMemorySnapshotStore extends SnapshotStore {\n\treadonly #versions: LRUCache<string, Snapshot[]>;\n\treadonly #maxVersionsPerPath: number;\n\n\tconstructor(options: InMemorySnapshotStoreOptions = {}) {\n\t\tsuper();\n\t\tthis.#versions = new LRUCache<string, Snapshot[]>({\n\t\t\tmax: options.maxPaths ?? DEFAULT_MAX_PATHS,\n\t\t\tmaxSize: options.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES,\n\t\t\tsizeCalculation: history => {\n\t\t\t\tlet total = 1;\n\t\t\t\tfor (const version of history) total += version.text.length;\n\t\t\t\treturn total;\n\t\t\t},\n\t\t});\n\t\tthis.#maxVersionsPerPath = options.maxVersionsPerPath ?? DEFAULT_MAX_VERSIONS_PER_PATH;\n\t}\n\n\thead(path: string): Snapshot | null {\n\t\treturn this.#versions.get(path)?.[0] ?? null;\n\t}\n\n\tbyHash(path: string, hash: string): Snapshot | null {\n\t\tconst matches = this.#versions.get(path)?.filter(version => version.hash === hash) ?? [];\n\t\t// A 4-hex tag can collide. Recovery only proceeds when the tag maps to a\n\t\t// single retained snapshot; otherwise the caller must re-read.\n\t\treturn matches.length === 1 ? matches[0]! : null;\n\t}\n\n\toverride byHashAndText(path: string, hash: string, text: string): Snapshot | null {\n\t\treturn this.#versions.get(path)?.find(version => version.hash === hash && version.text === text) ?? null;\n\t}\n\n\trecord(path: string, fullText: string): string {\n\t\tconst hash = computeFileHash(fullText);\n\t\t// `get` refreshes LRU recency for `path`.\n\t\tconst history = this.#versions.get(path) ?? [];\n\t\tconst existing = history.find(version => version.hash === hash && version.text === fullText);\n\t\tif (existing) {\n\t\t\t// Same content state observed again: refresh recency and promote to\n\t\t\t// head (it is the current file content), then reuse the tag. Hash\n\t\t\t// collisions with different text must be retained as distinct\n\t\t\t// snapshots; the 4-hex tag is only a lookup key, not proof of identity.\n\t\t\texisting.recordedAt = Date.now();\n\t\t\tif (history[0] !== existing) {\n\t\t\t\tthis.#versions.set(path, [existing, ...history.filter(version => version !== existing)]);\n\t\t\t}\n\t\t\treturn hash;\n\t\t}\n\n\t\tconst snapshot: Snapshot = { path, text: fullText, hash, recordedAt: Date.now() };\n\t\tthis.#versions.set(path, [snapshot, ...history].slice(0, this.#maxVersionsPerPath));\n\t\treturn hash;\n\t}\n\n\tinvalidate(path: string): void {\n\t\tthis.#versions.delete(path);\n\t}\n\n\tclear(): void {\n\t\tthis.#versions.clear();\n\t}\n}\n"]}

package/dist/core/tools/hashline-engine/stream.d.ts

@@ -0,0 +1,3 @@
+import type { StreamOptions } from "./types.js";
+export declare function streamHashLines(source: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>, options?: StreamOptions): AsyncGenerator<string>;
+//# sourceMappingURL=stream.d.ts.map

package/dist/core/tools/hashline-engine/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../../src/core/tools/hashline-engine/stream.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAoFhD,wBAAuB,eAAe,CACrC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,EAC9D,OAAO,GAAE,aAAkB,GACzB,cAAc,CAAC,MAAM,CAAC,CAkCxB","sourcesContent":["// @generated vendored verbatim from oh-my-pi packages/hashline @ 15b5c1397fc -- DO NOT EDIT.\n// Parity source for the Atomic hashline edit engine (issue #1483); adapted only for Atomic's Node runtime (relative imports, Bun->Node host calls, erasable constructor syntax).\n/**\n * Lazily format a stream of UTF-8 bytes into hashline-numbered lines, yielded\n * as bounded text chunks. Used to send `read`-style file content to consumers\n * without materializing the full file at once.\n *\n * Each yielded chunk is at most {@link StreamOptions.maxChunkLines} lines and\n * at most {@link StreamOptions.maxChunkBytes} UTF-8 bytes (whichever fires\n * first).\n */\nimport { formatNumberedLine } from \"./format.js\";\nimport type { StreamOptions } from \"./types.js\";\n\ninterface ResolvedStreamOptions {\n\tstartLine: number;\n\tmaxChunkLines: number;\n\tmaxChunkBytes: number;\n}\n\nfunction resolveStreamOptions(options: StreamOptions): ResolvedStreamOptions {\n\treturn {\n\t\tstartLine: options.startLine ?? 1,\n\t\tmaxChunkLines: options.maxChunkLines ?? 200,\n\t\tmaxChunkBytes: options.maxChunkBytes ?? 64 * 1024,\n\t};\n}\n\ninterface ChunkEmitter {\n\tpushLine: (line: string) => string[];\n\tflush: () => string | undefined;\n}\n\nfunction createChunkEmitter(options: ResolvedStreamOptions): ChunkEmitter {\n\tlet lineNumber = options.startLine;\n\tlet outLines: string[] = [];\n\tlet outBytes = 0;\n\n\tconst flush = (): string | undefined => {\n\t\tif (outLines.length === 0) return undefined;\n\t\tconst chunk = outLines.join(\"\\n\");\n\t\toutLines = [];\n\t\toutBytes = 0;\n\t\treturn chunk;\n\t};\n\n\tconst pushLine = (line: string): string[] => {\n\t\tconst formatted = formatNumberedLine(lineNumber, line);\n\t\tlineNumber++;\n\n\t\tconst chunks: string[] = [];\n\t\tconst sepBytes = outLines.length === 0 ? 0 : 1;\n\t\tconst lineBytes = Buffer.byteLength(formatted, \"utf-8\");\n\t\tconst wouldOverflow =\n\t\t\toutLines.length >= options.maxChunkLines || outBytes + sepBytes + lineBytes > options.maxChunkBytes;\n\n\t\tif (outLines.length > 0 && wouldOverflow) {\n\t\t\tconst flushed = flush();\n\t\t\tif (flushed) chunks.push(flushed);\n\t\t}\n\n\t\toutLines.push(formatted);\n\t\toutBytes += (outLines.length === 1 ? 0 : 1) + lineBytes;\n\n\t\tif (outLines.length >= options.maxChunkLines || outBytes >= options.maxChunkBytes) {\n\t\t\tconst flushed = flush();\n\t\t\tif (flushed) chunks.push(flushed);\n\t\t}\n\t\treturn chunks;\n\t};\n\n\treturn { pushLine, flush };\n}\n\nfunction isReadableStream(value: unknown): value is ReadableStream<Uint8Array> {\n\treturn (\n\t\ttypeof value === \"object\" &&\n\t\tvalue !== null &&\n\t\t\"getReader\" in value &&\n\t\ttypeof (value as { getReader?: unknown }).getReader === \"function\"\n\t);\n}\n\nasync function* bytesFromReadableStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<Uint8Array> {\n\tconst reader = stream.getReader();\n\ttry {\n\t\twhile (true) {\n\t\t\tconst { done, value } = await reader.read();\n\t\t\tif (done) return;\n\t\t\tif (value) yield value;\n\t\t}\n\t} finally {\n\t\treader.releaseLock();\n\t}\n}\n\nexport async function* streamHashLines(\n\tsource: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>,\n\toptions: StreamOptions = {},\n): AsyncGenerator<string> {\n\tconst resolved = resolveStreamOptions(options);\n\tconst decoder = new TextDecoder(\"utf-8\");\n\tconst chunks = isReadableStream(source) ? bytesFromReadableStream(source) : source;\n\tconst emitter = createChunkEmitter(resolved);\n\n\tlet pending = \"\";\n\tlet sawAnyLine = false;\n\n\tfor await (const chunk of chunks) {\n\t\tpending += decoder.decode(chunk, { stream: true });\n\t\tlet nl = pending.indexOf(\"\\n\");\n\t\twhile (nl !== -1) {\n\t\t\tconst raw = pending.slice(0, nl);\n\t\t\tconst line = raw.endsWith(\"\\r\") ? raw.slice(0, -1) : raw;\n\t\t\tsawAnyLine = true;\n\t\t\tfor (const out of emitter.pushLine(line)) yield out;\n\t\t\tpending = pending.slice(nl + 1);\n\t\t\tnl = pending.indexOf(\"\\n\");\n\t\t}\n\t}\n\n\tpending += decoder.decode();\n\tif (pending.length > 0) {\n\t\tsawAnyLine = true;\n\t\tconst tail = pending.endsWith(\"\\r\") ? pending.slice(0, -1) : pending;\n\t\tfor (const out of emitter.pushLine(tail)) yield out;\n\t}\n\tif (!sawAnyLine) {\n\t\tfor (const out of emitter.pushLine(\"\")) yield out;\n\t}\n\n\tconst last = emitter.flush();\n\tif (last) yield last;\n}\n"]}

package/dist/core/tools/hashline-engine/stream.js

@@ -0,0 +1,111 @@
+// @generated vendored verbatim from oh-my-pi packages/hashline @ 15b5c1397fc -- DO NOT EDIT.
+// Parity source for the Atomic hashline edit engine (issue #1483); adapted only for Atomic's Node runtime (relative imports, Bun->Node host calls, erasable constructor syntax).
+/**
+ * Lazily format a stream of UTF-8 bytes into hashline-numbered lines, yielded
+ * as bounded text chunks. Used to send `read`-style file content to consumers
+ * without materializing the full file at once.
+ *
+ * Each yielded chunk is at most {@link StreamOptions.maxChunkLines} lines and
+ * at most {@link StreamOptions.maxChunkBytes} UTF-8 bytes (whichever fires
+ * first).
+ */
+import { formatNumberedLine } from "./format.js";
+function resolveStreamOptions(options) {
+    return {
+        startLine: options.startLine ?? 1,
+        maxChunkLines: options.maxChunkLines ?? 200,
+        maxChunkBytes: options.maxChunkBytes ?? 64 * 1024,
+    };
+}
+function createChunkEmitter(options) {
+    let lineNumber = options.startLine;
+    let outLines = [];
+    let outBytes = 0;
+    const flush = () => {
+        if (outLines.length === 0)
+            return undefined;
+        const chunk = outLines.join("\n");
+        outLines = [];
+        outBytes = 0;
+        return chunk;
+    };
+    const pushLine = (line) => {
+        const formatted = formatNumberedLine(lineNumber, line);
+        lineNumber++;
+        const chunks = [];
+        const sepBytes = outLines.length === 0 ? 0 : 1;
+        const lineBytes = Buffer.byteLength(formatted, "utf-8");
+        const wouldOverflow = outLines.length >= options.maxChunkLines || outBytes + sepBytes + lineBytes > options.maxChunkBytes;
+        if (outLines.length > 0 && wouldOverflow) {
+            const flushed = flush();
+            if (flushed)
+                chunks.push(flushed);
+        }
+        outLines.push(formatted);
+        outBytes += (outLines.length === 1 ? 0 : 1) + lineBytes;
+        if (outLines.length >= options.maxChunkLines || outBytes >= options.maxChunkBytes) {
+            const flushed = flush();
+            if (flushed)
+                chunks.push(flushed);
+        }
+        return chunks;
+    };
+    return { pushLine, flush };
+}
+function isReadableStream(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "getReader" in value &&
+        typeof value.getReader === "function");
+}
+async function* bytesFromReadableStream(stream) {
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                return;
+            if (value)
+                yield value;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+export async function* streamHashLines(source, options = {}) {
+    const resolved = resolveStreamOptions(options);
+    const decoder = new TextDecoder("utf-8");
+    const chunks = isReadableStream(source) ? bytesFromReadableStream(source) : source;
+    const emitter = createChunkEmitter(resolved);
+    let pending = "";
+    let sawAnyLine = false;
+    for await (const chunk of chunks) {
+        pending += decoder.decode(chunk, { stream: true });
+        let nl = pending.indexOf("\n");
+        while (nl !== -1) {
+            const raw = pending.slice(0, nl);
+            const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+            sawAnyLine = true;
+            for (const out of emitter.pushLine(line))
+                yield out;
+            pending = pending.slice(nl + 1);
+            nl = pending.indexOf("\n");
+        }
+    }
+    pending += decoder.decode();
+    if (pending.length > 0) {
+        sawAnyLine = true;
+        const tail = pending.endsWith("\r") ? pending.slice(0, -1) : pending;
+        for (const out of emitter.pushLine(tail))
+            yield out;
+    }
+    if (!sawAnyLine) {
+        for (const out of emitter.pushLine(""))
+            yield out;
+    }
+    const last = emitter.flush();
+    if (last)
+        yield last;
+}
+//# sourceMappingURL=stream.js.map

package/dist/core/tools/hashline-engine/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","sourceRoot":"","sources":["../../../../src/core/tools/hashline-engine/stream.ts"],"names":[],"mappings":"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","sourcesContent":["// @generated vendored verbatim from oh-my-pi packages/hashline @ 15b5c1397fc -- DO NOT EDIT.\n// Parity source for the Atomic hashline edit engine (issue #1483); adapted only for Atomic's Node runtime (relative imports, Bun->Node host calls, erasable constructor syntax).\n/**\n * Lazily format a stream of UTF-8 bytes into hashline-numbered lines, yielded\n * as bounded text chunks. Used to send `read`-style file content to consumers\n * without materializing the full file at once.\n *\n * Each yielded chunk is at most {@link StreamOptions.maxChunkLines} lines and\n * at most {@link StreamOptions.maxChunkBytes} UTF-8 bytes (whichever fires\n * first).\n */\nimport { formatNumberedLine } from \"./format.js\";\nimport type { StreamOptions } from \"./types.js\";\n\ninterface ResolvedStreamOptions {\n\tstartLine: number;\n\tmaxChunkLines: number;\n\tmaxChunkBytes: number;\n}\n\nfunction resolveStreamOptions(options: StreamOptions): ResolvedStreamOptions {\n\treturn {\n\t\tstartLine: options.startLine ?? 1,\n\t\tmaxChunkLines: options.maxChunkLines ?? 200,\n\t\tmaxChunkBytes: options.maxChunkBytes ?? 64 * 1024,\n\t};\n}\n\ninterface ChunkEmitter {\n\tpushLine: (line: string) => string[];\n\tflush: () => string | undefined;\n}\n\nfunction createChunkEmitter(options: ResolvedStreamOptions): ChunkEmitter {\n\tlet lineNumber = options.startLine;\n\tlet outLines: string[] = [];\n\tlet outBytes = 0;\n\n\tconst flush = (): string | undefined => {\n\t\tif (outLines.length === 0) return undefined;\n\t\tconst chunk = outLines.join(\"\\n\");\n\t\toutLines = [];\n\t\toutBytes = 0;\n\t\treturn chunk;\n\t};\n\n\tconst pushLine = (line: string): string[] => {\n\t\tconst formatted = formatNumberedLine(lineNumber, line);\n\t\tlineNumber++;\n\n\t\tconst chunks: string[] = [];\n\t\tconst sepBytes = outLines.length === 0 ? 0 : 1;\n\t\tconst lineBytes = Buffer.byteLength(formatted, \"utf-8\");\n\t\tconst wouldOverflow =\n\t\t\toutLines.length >= options.maxChunkLines || outBytes + sepBytes + lineBytes > options.maxChunkBytes;\n\n\t\tif (outLines.length > 0 && wouldOverflow) {\n\t\t\tconst flushed = flush();\n\t\t\tif (flushed) chunks.push(flushed);\n\t\t}\n\n\t\toutLines.push(formatted);\n\t\toutBytes += (outLines.length === 1 ? 0 : 1) + lineBytes;\n\n\t\tif (outLines.length >= options.maxChunkLines || outBytes >= options.maxChunkBytes) {\n\t\t\tconst flushed = flush();\n\t\t\tif (flushed) chunks.push(flushed);\n\t\t}\n\t\treturn chunks;\n\t};\n\n\treturn { pushLine, flush };\n}\n\nfunction isReadableStream(value: unknown): value is ReadableStream<Uint8Array> {\n\treturn (\n\t\ttypeof value === \"object\" &&\n\t\tvalue !== null &&\n\t\t\"getReader\" in value &&\n\t\ttypeof (value as { getReader?: unknown }).getReader === \"function\"\n\t);\n}\n\nasync function* bytesFromReadableStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<Uint8Array> {\n\tconst reader = stream.getReader();\n\ttry {\n\t\twhile (true) {\n\t\t\tconst { done, value } = await reader.read();\n\t\t\tif (done) return;\n\t\t\tif (value) yield value;\n\t\t}\n\t} finally {\n\t\treader.releaseLock();\n\t}\n}\n\nexport async function* streamHashLines(\n\tsource: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>,\n\toptions: StreamOptions = {},\n): AsyncGenerator<string> {\n\tconst resolved = resolveStreamOptions(options);\n\tconst decoder = new TextDecoder(\"utf-8\");\n\tconst chunks = isReadableStream(source) ? bytesFromReadableStream(source) : source;\n\tconst emitter = createChunkEmitter(resolved);\n\n\tlet pending = \"\";\n\tlet sawAnyLine = false;\n\n\tfor await (const chunk of chunks) {\n\t\tpending += decoder.decode(chunk, { stream: true });\n\t\tlet nl = pending.indexOf(\"\\n\");\n\t\twhile (nl !== -1) {\n\t\t\tconst raw = pending.slice(0, nl);\n\t\t\tconst line = raw.endsWith(\"\\r\") ? raw.slice(0, -1) : raw;\n\t\t\tsawAnyLine = true;\n\t\t\tfor (const out of emitter.pushLine(line)) yield out;\n\t\t\tpending = pending.slice(nl + 1);\n\t\t\tnl = pending.indexOf(\"\\n\");\n\t\t}\n\t}\n\n\tpending += decoder.decode();\n\tif (pending.length > 0) {\n\t\tsawAnyLine = true;\n\t\tconst tail = pending.endsWith(\"\\r\") ? pending.slice(0, -1) : pending;\n\t\tfor (const out of emitter.pushLine(tail)) yield out;\n\t}\n\tif (!sawAnyLine) {\n\t\tfor (const out of emitter.pushLine(\"\")) yield out;\n\t}\n\n\tconst last = emitter.flush();\n\tif (last) yield last;\n}\n"]}