sela-core 1.0.6 → 1.0.8

package/dist/services/WorkspaceSnapshotService.js

@@ -0,0 +1,200 @@
+"use strict";
+// src/services/WorkspaceSnapshotService.ts
+//
+// Clean-Room Architecture - file 1 of 2.
+//
+// Tracks the EXACT content of every file Sela mutates during a session, so:
+//   • The HTML report diff can be generated from an isolated in-memory diff
+//     (developer's dirty pre-existing edits NEVER bleed in).
+//   • PRAutomationService can restore the developer's pre-Sela workspace
+//     byte-for-byte after a PR is opened on an isolated branch.
+//
+// Lifecycle:
+//   preWrite(path)   - first call per file records `contentBefore` (disk
+//                      snapshot right before Sela touches it) + HEAD blob.
+//   postWrite(path)  - refreshes `contentAfter` (latest disk state).
+//   restoreOriginal()- writes contentBefore back to every tracked file.
+//   restoreMutated() - writes contentAfter back to every tracked file.
+//   clear()          - empties the ledger.
+//
+// Singleton `sharedWorkspaceSnapshot` is the canonical instance the
+// SourceUpdater / ASTSourceUpdater write hooks talk to.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sharedWorkspaceSnapshot = exports.WorkspaceSnapshotService = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+class WorkspaceSnapshotService {
+    snapshots = new Map();
+    cwd;
+    constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+    }
+    /** Override the cwd used for relative-path + HEAD lookups (tests). */
+    setCwd(cwd) {
+        this.cwd = cwd;
+    }
+    /**
+     * Record the pre-mutation state of `filePath` if not already tracked.
+     * Idempotent - only the FIRST call per file matters.
+     */
+    preWrite(filePath) {
+        const abs = this.normalise(filePath);
+        if (this.snapshots.has(abs))
+            return;
+        const exists = fs.existsSync(abs);
+        const contentBefore = exists ? fs.readFileSync(abs, "utf8") : "";
+        const headContent = this.readHeadContent(abs);
+        const hadUncommittedChanges = headContent !== null && headContent !== contentBefore;
+        this.snapshots.set(abs, {
+            absolutePath: abs,
+            relativePath: this.toRelative(abs),
+            contentBefore,
+            contentAfter: null,
+            headContent,
+            hadUncommittedChanges,
+            createdBySela: !exists,
+        });
+    }
+    /**
+     * Refresh the post-mutation state. Safe to call multiple times - each
+     * call overwrites `contentAfter` with the latest disk state.
+     */
+    postWrite(filePath) {
+        const abs = this.normalise(filePath);
+        const snap = this.snapshots.get(abs);
+        if (!snap)
+            return;
+        snap.contentAfter = fs.existsSync(abs) ? fs.readFileSync(abs, "utf8") : "";
+    }
+    /** Lookup by absolute or relative path. Returns `null` when untracked. */
+    getSnapshot(filePath) {
+        return this.snapshots.get(this.normalise(filePath)) ?? null;
+    }
+    /** Every tracked snapshot. Insertion order. */
+    getAllSnapshots() {
+        return Array.from(this.snapshots.values());
+    }
+    /**
+     * Did Sela actually mutate this file? True when contentAfter exists and
+     * differs from contentBefore.
+     */
+    isMutated(filePath) {
+        const snap = this.getSnapshot(filePath);
+        if (!snap || snap.contentAfter === null)
+            return false;
+        return snap.contentAfter !== snap.contentBefore;
+    }
+    /** All snapshots with a real mutation recorded. */
+    getMutatedSnapshots() {
+        return this.getAllSnapshots().filter((s) => s.contentAfter !== null && s.contentAfter !== s.contentBefore);
+    }
+    /**
+     * Rewind every tracked file on disk to `contentBefore` - restoring the
+     * developer's pre-Sela workspace state byte-for-byte.
+     */
+    restoreOriginal() {
+        for (const snap of this.snapshots.values()) {
+            this.rewindSnapshot(snap);
+        }
+    }
+    /**
+     * Rewind a SINGLE tracked file on disk to `contentBefore`. Used by the
+     * Local DX interactive review flow when the developer rejects a fix.
+     * Returns true when the rewind happened, false when the file is untracked.
+     */
+    restoreOriginalByPath(filePath) {
+        const snap = this.getSnapshot(filePath);
+        if (!snap)
+            return false;
+        this.rewindSnapshot(snap);
+        return true;
+    }
+    rewindSnapshot(snap) {
+        if (snap.createdBySela) {
+            if (fs.existsSync(snap.absolutePath)) {
+                fs.unlinkSync(snap.absolutePath);
+            }
+            return;
+        }
+        fs.writeFileSync(snap.absolutePath, snap.contentBefore, "utf8");
+    }
+    /**
+     * Forward every tracked file on disk to `contentAfter` (no-op for files
+     * that were never written). Used by PRAutomationService to reapply
+     * Sela's mutations after a `git stash pop` round-trip.
+     */
+    restoreMutated() {
+        for (const snap of this.snapshots.values()) {
+            if (snap.contentAfter === null)
+                continue;
+            fs.writeFileSync(snap.absolutePath, snap.contentAfter, "utf8");
+        }
+    }
+    clear() {
+        this.snapshots.clear();
+    }
+    // ────────────────────────────────────────────────────────────────
+    // INTERNAL
+    // ────────────────────────────────────────────────────────────────
+    normalise(raw) {
+        if (!raw)
+            return raw;
+        const abs = path.isAbsolute(raw) ? raw : path.resolve(this.cwd, raw);
+        return path.normalize(abs);
+    }
+    toRelative(abs) {
+        const rel = path.relative(this.cwd, abs);
+        return rel.split(path.sep).join("/");
+    }
+    readHeadContent(abs) {
+        try {
+            const rel = this.toRelative(abs);
+            const out = (0, child_process_1.execSync)(`git show HEAD:"${rel}"`, {
+                cwd: this.cwd,
+                encoding: "utf8",
+                stdio: ["pipe", "pipe", "pipe"],
+                windowsHide: true,
+            });
+            return out.toString();
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.WorkspaceSnapshotService = WorkspaceSnapshotService;
+exports.sharedWorkspaceSnapshot = new WorkspaceSnapshotService();

package/dist/types/index.d.ts

@@ -2,7 +2,7 @@ export interface AncestorNode {
     tag: string;
     id: string | null;
     classes: string[];
-    /** "{tag}#{id}[{classes_sorted_asc}]" — stable fingerprint for drift comparison */
+    /** "{tag}#{id}[{classes_sorted_asc}]" - stable fingerprint for drift comparison */
     fingerprint: string;
 }
 export type GhostCondition = "G1_DISPLAY_NONE" | "G2_VISIBILITY_HIDDEN" | "G3_OPACITY_ZERO" | "G4_POINTER_EVENTS_NONE" | "G5_ZERO_AREA" | "G6_CONTENT_VISIBILITY_HIDDEN";

package/dist/utils/IsolatedDiff.d.ts

@@ -0,0 +1,45 @@
+export interface IsolatedDiffOptions {
+    /** Lines of unchanged context around each hunk. Default 3 (git default). */
+    context?: number;
+    /**
+     * Path to render in the `--- a/<path>` / `+++ b/<path>` preamble. When
+     * omitted the preamble is dropped entirely (hunks only).
+     */
+    filePath?: string;
+}
+/**
+ * Generate a `git`-style unified diff between two in-memory strings.
+ * Returns `""` when the two buffers are identical.
+ */
+export declare function generateUnifiedDiff(before: string, after: string, opts?: IsolatedDiffOptions): string;
+export interface ChangeBlock {
+    /** Old text (newlines preserved). Empty string for pure additions. */
+    oldBlock: string;
+    /** New text (newlines preserved). Empty string for pure deletions. */
+    newBlock: string;
+    /** 1-based line in `before` where the block starts (0 if pure add). */
+    oldLineStart: number;
+    /** 1-based line in `after` where the block starts (0 if pure delete). */
+    newLineStart: number;
+    /**
+     * For pure additions: a non-empty line of unchanged anchor text immediately
+     * PRECEDING the new block in the `before` buffer. The replayer uses this
+     * to locate the insertion point. `null` when adding at the very top.
+     */
+    anchorBefore: string | null;
+}
+export declare function extractChangeBlocks(before: string, after: string): ChangeBlock[];
+export interface ApplyBlocksResult {
+    ok: boolean;
+    result?: string;
+    /** Human-readable failure reason - surfaced in the PR-automation log. */
+    reason?: string;
+}
+/**
+ * Replay a list of change blocks against a fresh base buffer (typically
+ * the file's `HEAD` blob). Each block is applied via UNIQUE substring
+ * replacement - when the old block is missing or ambiguous in the base,
+ * we fail loudly rather than silently mutating the wrong spot.
+ */
+export declare function applyChangeBlocks(base: string, blocks: ChangeBlock[]): ApplyBlocksResult;
+//# sourceMappingURL=IsolatedDiff.d.ts.map

package/dist/utils/IsolatedDiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsolatedDiff.d.ts","sourceRoot":"","sources":["../../src/utils/IsolatedDiff.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,mBAAmB;IAClC,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,mBAAwB,GAC7B,MAAM,CAsBR;AA6PD,MAAM,WAAW,WAAW;IAC1B,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAC;IACjB,uEAAuE;IACvE,YAAY,EAAE,MAAM,CAAC;IACrB,yEAAyE;IACzE,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,WAAW,EAAE,CAoDf;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,WAAW,EAAE,GACpB,iBAAiB,CAuDnB"}

package/dist/utils/IsolatedDiff.js

@@ -0,0 +1,382 @@
+"use strict";
+// src/utils/IsolatedDiff.ts
+//
+// Pure-JS unified-diff generator. No external `diff` package, no shell-out to
+// `git diff` - the result is guaranteed to be a function ONLY of the two
+// in-memory buffers passed in, never of any global working-tree state.
+//
+// This is the foundation of the Clean-Room Architecture: the HTML report
+// renders diffs computed here, so a developer's pre-existing uncommitted
+// edits CANNOT leak into Sela's report.
+//
+// Algorithm: classic LCS over lines, then a unified-diff emitter with
+// configurable context. Memory is O(N*M) which is fine for the spec files
+// Sela mutates (typically a few thousand lines max).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUnifiedDiff = generateUnifiedDiff;
+exports.extractChangeBlocks = extractChangeBlocks;
+exports.applyChangeBlocks = applyChangeBlocks;
+/**
+ * Generate a `git`-style unified diff between two in-memory strings.
+ * Returns `""` when the two buffers are identical.
+ */
+function generateUnifiedDiff(before, after, opts = {}) {
+    if (before === after)
+        return "";
+    const context = Math.max(0, opts.context ?? 3);
+    const a = splitKeepEol(before);
+    const b = splitKeepEol(after);
+    const ops = diffLines(a, b);
+    if (ops.length === 0)
+        return "";
+    const hunks = groupHunks(ops, { a, b, context });
+    if (hunks.length === 0)
+        return "";
+    const out = [];
+    if (opts.filePath) {
+        const p = opts.filePath.split(/[\\/]/).join("/");
+        out.push(`diff --git a/${p} b/${p}`);
+        out.push(`--- a/${p}`);
+        out.push(`+++ b/${p}`);
+    }
+    for (const hunk of hunks) {
+        out.push(formatHunkHeader(hunk));
+        for (const row of hunk.rows)
+            out.push(row);
+    }
+    return out.join("\n") + "\n";
+}
+// ────────────────────────────────────────────────────────────────────
+// LINE SPLITTER - preserves trailing newline / CRLF so we can emit the
+// canonical `` marker when needed.
+// ────────────────────────────────────────────────────────────────────
+function splitKeepEol(text) {
+    if (text.length === 0)
+        return [];
+    const out = [];
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        if (text.charCodeAt(i) === 10 /* \n */) {
+            out.push(text.slice(start, i + 1));
+            start = i + 1;
+        }
+    }
+    if (start < text.length)
+        out.push(text.slice(start));
+    return out;
+}
+function stripEol(line) {
+    if (line.endsWith("\r\n"))
+        return line.slice(0, -2);
+    if (line.endsWith("\n"))
+        return line.slice(0, -1);
+    return line;
+}
+function hasEol(line) {
+    return line.endsWith("\n");
+}
+function diffLines(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const w = n + 1;
+    const dp = new Uint32Array((m + 1) * w);
+    for (let i = m - 1; i >= 0; i--) {
+        const ai = a[i];
+        for (let j = n - 1; j >= 0; j--) {
+            if (ai === b[j]) {
+                dp[i * w + j] = dp[(i + 1) * w + (j + 1)] + 1;
+            }
+            else {
+                const down = dp[(i + 1) * w + j];
+                const right = dp[i * w + (j + 1)];
+                dp[i * w + j] = down >= right ? down : right;
+            }
+        }
+    }
+    const ops = [];
+    let i = 0;
+    let j = 0;
+    while (i < m && j < n) {
+        if (a[i] === b[j]) {
+            ops.push({ kind: "eq", a: i, b: j });
+            i++;
+            j++;
+        }
+        else if (dp[(i + 1) * w + j] >= dp[i * w + (j + 1)]) {
+            ops.push({ kind: "del", a: i });
+            i++;
+        }
+        else {
+            ops.push({ kind: "add", b: j });
+            j++;
+        }
+    }
+    while (i < m) {
+        ops.push({ kind: "del", a: i });
+        i++;
+    }
+    while (j < n) {
+        ops.push({ kind: "add", b: j });
+        j++;
+    }
+    return ops;
+}
+function groupHunks(ops, ctx) {
+    const hunks = [];
+    const ctxN = ctx.context;
+    let i = 0;
+    while (i < ops.length) {
+        // Locate the next non-equal op.
+        let firstChange = -1;
+        for (let k = i; k < ops.length; k++) {
+            if (ops[k].kind !== "eq") {
+                firstChange = k;
+                break;
+            }
+        }
+        if (firstChange === -1)
+            break;
+        // Leading-context start, bounded by previous hunk end.
+        let hunkStart = firstChange - ctxN;
+        if (hunkStart < i)
+            hunkStart = i;
+        if (hunkStart < 0)
+            hunkStart = 0;
+        let hunkEnd = firstChange;
+        // Extend by merging change groups separated by <= 2*ctxN equality lines.
+        // Avoid merging across the very end of `ops`.
+        while (true) {
+            let cursor = hunkEnd + 1;
+            let runEqs = 0;
+            let nextChange = -1;
+            while (cursor < ops.length) {
+                if (ops[cursor].kind === "eq") {
+                    runEqs++;
+                    cursor++;
+                    continue;
+                }
+                nextChange = cursor;
+                break;
+            }
+            if (nextChange !== -1 && runEqs <= 2 * ctxN) {
+                hunkEnd = nextChange;
+            }
+            else {
+                break;
+            }
+        }
+        // Trailing context.
+        let trailing = 0;
+        while (hunkEnd + 1 < ops.length &&
+            ops[hunkEnd + 1].kind === "eq" &&
+            trailing < ctxN) {
+            hunkEnd++;
+            trailing++;
+        }
+        // Materialise rows + compute header coordinates.
+        const rows = [];
+        let oldStartIdx = -1;
+        let newStartIdx = -1;
+        let oldLen = 0;
+        let newLen = 0;
+        for (let k = hunkStart; k <= hunkEnd; k++) {
+            const op = ops[k];
+            if (op.kind === "eq") {
+                if (oldStartIdx === -1)
+                    oldStartIdx = op.a;
+                if (newStartIdx === -1)
+                    newStartIdx = op.b;
+                const line = ctx.a[op.a];
+                rows.push(" " + stripEol(line));
+                oldLen++;
+                newLen++;
+                if (!hasEol(line))
+                    rows.push("\");
+            }
+            else if (op.kind === "del") {
+                if (oldStartIdx === -1)
+                    oldStartIdx = op.a;
+                if (newStartIdx === -1) {
+                    // Anchor on the corresponding `b` position. For pure-deletions at
+                    // the top of file `op.a === 0` ⇒ newStart should be 0 (special
+                    // header form `+0,0`). For mid-file deletions use the running b
+                    // cursor - derive it from prior ops.
+                    newStartIdx = computeBAnchor(ops, k);
+                }
+                const line = ctx.a[op.a];
+                rows.push("-" + stripEol(line));
+                oldLen++;
+                if (!hasEol(line))
+                    rows.push("\");
+            }
+            else {
+                if (newStartIdx === -1)
+                    newStartIdx = op.b;
+                if (oldStartIdx === -1)
+                    oldStartIdx = computeAAnchor(ops, k);
+                const line = ctx.b[op.b];
+                rows.push("+" + stripEol(line));
+                newLen++;
+                if (!hasEol(line))
+                    rows.push("\");
+            }
+        }
+        hunks.push({
+            oldStart: oldLen === 0 ? oldStartIdx : oldStartIdx + 1,
+            oldLen,
+            newStart: newLen === 0 ? newStartIdx : newStartIdx + 1,
+            newLen,
+            rows,
+        });
+        i = hunkEnd + 1;
+    }
+    return hunks;
+}
+/**
+ * For a pure-add op at position `k`, walk backwards to find the prior
+ * `a` index (so we know which line of the old file the hunk starts at).
+ */
+function computeAAnchor(ops, k) {
+    for (let p = k - 1; p >= 0; p--) {
+        const op = ops[p];
+        if (op.kind === "eq")
+            return op.a + 1;
+        if (op.kind === "del")
+            return op.a + 1;
+    }
+    return 0;
+}
+function computeBAnchor(ops, k) {
+    for (let p = k - 1; p >= 0; p--) {
+        const op = ops[p];
+        if (op.kind === "eq")
+            return op.b + 1;
+        if (op.kind === "add")
+            return op.b + 1;
+    }
+    return 0;
+}
+function formatHunkHeader(hunk) {
+    const oldPart = hunk.oldLen === 1 ? `${hunk.oldStart}` : `${hunk.oldStart},${hunk.oldLen}`;
+    const newPart = hunk.newLen === 1 ? `${hunk.newStart}` : `${hunk.newStart},${hunk.newLen}`;
+    return `@@ -${oldPart} +${newPart} @@`;
+}
+function extractChangeBlocks(before, after) {
+    if (before === after)
+        return [];
+    const a = splitKeepEol(before);
+    const b = splitKeepEol(after);
+    const ops = diffLines(a, b);
+    const blocks = [];
+    let i = 0;
+    while (i < ops.length) {
+        if (ops[i].kind === "eq") {
+            i++;
+            continue;
+        }
+        const start = i;
+        while (i < ops.length && ops[i].kind !== "eq")
+            i++;
+        const oldLines = [];
+        const newLines = [];
+        let oldStart = -1;
+        let newStart = -1;
+        for (let k = start; k < i; k++) {
+            const op = ops[k];
+            if (op.kind === "del") {
+                if (oldStart === -1)
+                    oldStart = op.a;
+                oldLines.push(a[op.a]);
+            }
+            else if (op.kind === "add") {
+                if (newStart === -1)
+                    newStart = op.b;
+                newLines.push(b[op.b]);
+            }
+        }
+        let anchorBefore = null;
+        if (oldLines.length === 0) {
+            // Pure addition - find preceding unchanged anchor line.
+            for (let k = start - 1; k >= 0; k--) {
+                const op = ops[k];
+                if (op.kind === "eq") {
+                    anchorBefore = a[op.a];
+                    break;
+                }
+            }
+        }
+        blocks.push({
+            oldBlock: oldLines.join(""),
+            newBlock: newLines.join(""),
+            oldLineStart: oldStart >= 0 ? oldStart + 1 : 0,
+            newLineStart: newStart >= 0 ? newStart + 1 : 0,
+            anchorBefore,
+        });
+    }
+    return blocks;
+}
+/**
+ * Replay a list of change blocks against a fresh base buffer (typically
+ * the file's `HEAD` blob). Each block is applied via UNIQUE substring
+ * replacement - when the old block is missing or ambiguous in the base,
+ * we fail loudly rather than silently mutating the wrong spot.
+ */
+function applyChangeBlocks(base, blocks) {
+    let working = base;
+    for (const block of blocks) {
+        if (block.oldBlock.length === 0) {
+            // Pure addition.
+            if (block.anchorBefore === null) {
+                if (working.length === 0) {
+                    // Empty file - prepend.
+                    working = block.newBlock + working;
+                    continue;
+                }
+                // Prepend at top of file.
+                working = block.newBlock + working;
+                continue;
+            }
+            const idx = working.indexOf(block.anchorBefore);
+            if (idx === -1) {
+                return {
+                    ok: false,
+                    reason: `pure-add anchor not found in clean base: "${snippet(block.anchorBefore)}"`,
+                };
+            }
+            const lastIdx = working.lastIndexOf(block.anchorBefore);
+            if (idx !== lastIdx) {
+                return {
+                    ok: false,
+                    reason: `pure-add anchor is not unique in clean base: "${snippet(block.anchorBefore)}"`,
+                };
+            }
+            const insertAt = idx + block.anchorBefore.length;
+            working =
+                working.slice(0, insertAt) + block.newBlock + working.slice(insertAt);
+            continue;
+        }
+        const idx = working.indexOf(block.oldBlock);
+        if (idx === -1) {
+            return {
+                ok: false,
+                reason: `block not found in clean base - developer's dirty state likely overlaps Sela's mutation site: "${snippet(block.oldBlock)}"`,
+            };
+        }
+        const lastIdx = working.lastIndexOf(block.oldBlock);
+        if (idx !== lastIdx) {
+            return {
+                ok: false,
+                reason: `block matches multiple locations in clean base - refusing to guess: "${snippet(block.oldBlock)}"`,
+            };
+        }
+        working =
+            working.slice(0, idx) +
+                block.newBlock +
+                working.slice(idx + block.oldBlock.length);
+    }
+    return { ok: true, result: working };
+}
+function snippet(s) {
+    const flat = s.replace(/\r?\n/g, "\\n");
+    return flat.length > 80 ? flat.slice(0, 77) + "..." : flat;
+}