@d3ara1n/pi-hashline-edit 0.1.1 → 0.2.0

package/src/pi/pi.test.ts

@@ -1,28 +1,16 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import { canonicalPath } from "./read-tool.ts";
-import { missingInputError } from "./edit-tool.ts";
+import { homedir } from "node:os";
 
-test("canonicalPath resolves relative/absolute", () => {
+test("canonicalPath resolves relative and absolute", () => {
 	assert.equal(canonicalPath("/cwd", "foo.ts"), "/cwd/foo.ts");
 	assert.equal(canonicalPath("/cwd", "./foo.ts"), "/cwd/foo.ts");
 	assert.equal(canonicalPath("/cwd", "/abs/x.ts"), "/abs/x.ts");
 });
 
-test("missingInputError: edits array → explicit no-degradation message", () => {
-	const msg = missingInputError("f.ts", { edits: [{ oldText: "a", newText: "b" }] });
-	assert.ok(msg.includes("legacy"), msg);
-	assert.ok(msg.includes("ONLY"), msg);
-	assert.ok(msg.includes("f.ts"), msg);
-});
-
-test("missingInputError: top-level oldText/newText also recognized as legacy", () => {
-	const msg = missingInputError("f.ts", { oldText: "a", newText: "b" });
-	assert.ok(msg.includes("legacy"));
-});
-
-test("missingInputError: only input missing (not legacy)", () => {
-	const msg = missingInputError("f.ts", {});
-	assert.ok(msg.includes("missing"));
-	assert.ok(!msg.includes("legacy"));
+test("canonicalPath expands ~ to home directory", () => {
+	const home = homedir();
+	assert.equal(canonicalPath("/cwd", "~"), home);
+	assert.equal(canonicalPath("/cwd", "~/foo.ts"), `${home}/foo.ts`);
 });

package/src/pi/read-tool.ts

@@ -1,23 +1,40 @@
 /**
- * Override read: text files output "lineNo#hash│content" and record a snapshot;
- * non-text (images/binary) and read errors delegate to the built-in read, whose
- * renderer is inherited automatically.
+ * Override read: text files output "lineNo#hash│content"; non-text (images /
+ * binary) and read errors delegate to the built-in read.
+ *
+ * Hashes are computed from the current content on the fly — nothing is stored.
+ * The hash is `(line number, content)`, recomputed and checked at edit time, so
+ * no snapshot is needed to verify an anchor later.
  *
  * @module pi-hashline-edit/pi
  */
 
 import { createReadTool } from "@earendil-works/pi-coding-agent";
 import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
-import { splitLines } from "../core/snapshot.ts";
-import { getState, getSnapshot, recordSnapshot } from "./state.ts";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { hashFileLines } from "../core/hash.ts";
+import { splitLines } from "../core/lines.ts";
+import { getState } from "./state.ts";
 
 const MAX_LINES = 2000;
 const MAX_BYTES = 256 * 1024;
 
-/** canonical path: shared by read/edit to keep the snapshot key consistent. */
+/**
+ * Canonical absolute path: shared by read/edit/grep to resolve a file consistently.
+ * Expands a leading `~` / `~/` to the user's home directory. (`~user` is not supported.)
+ */
 export function canonicalPath(cwd: string, p: string): string {
-	return resolve(cwd, p);
+	return resolve(cwd, expandTilde(p));
+}
+
+/** Mirrors pi core's `normalizePath` tilde handling: expands `~` / `~/` (and `~\` on Windows), leaves `~user` untouched. */
+function expandTilde(p: string): string {
+	if (p === "~") return homedir();
+	if (p.startsWith("~/") || (process.platform === "win32" && p.startsWith("~\\"))) {
+		return join(homedir(), p.slice(2));
+	}
+	return p;
 }
 
 /** Build the read override (a ToolDefinition fragment for registerTool). */
@@ -55,9 +72,7 @@ export function makeReadOverride(cwd: string) {
 			const text = buf.toString("utf-8");
 			const allLines = splitLines(text);
 			const totalLines = allLines.length;
-
-			// record a full-file snapshot (edit anchors are based on full-file line numbers)
-			const snap = recordSnapshot(absPath, text);
+			const hashes = hashFileLines(allLines, getState().config.hashLen);
 
 			// offset/limit
 			const offset = (params.offset as number | undefined) ?? 1;
@@ -70,7 +85,7 @@ export function makeReadOverride(cwd: string) {
 			let truncated = false;
 			for (let i = startIdx; i < endIdx; i++) {
 				const lineNo = i + 1;
-				const row = `${lineNo}#${snap.lineHashes[i]}│${allLines[i]}`;
+				const row = `${lineNo}#${hashes[i]}│${allLines[i]}`;
 				bytes += Buffer.byteLength(row, "utf-8");
 				if (bytes > MAX_BYTES) {
 					truncated = true;
@@ -91,8 +106,3 @@ export function makeReadOverride(cwd: string) {
 		},
 	};
 }
-
-/** Reused by the edit override: look up a recorded snapshot for a path (by canonical path). */
-export function lookupSnapshot(cwd: string, p: string) {
-	return getSnapshot(canonicalPath(cwd, p));
-}

package/src/pi/state.ts

@@ -1,28 +1,18 @@
 /**
- * Session-level state: file snapshot store (LRU) + config.
+ * Session-level config holder.
  *
- * globalThis singleton (avoids Bun module-identity issues; see the repo AGENTS).
- * Snapshot LRU eviction (default 64 files) prevents unbounded memory growth in
- * long sessions — cold files are pushed out by new ones. read records; edit
- * verifies; key is the canonical absolute path.
- * config lives in state and is reloaded on session_start.
+ * globalThis singleton (consistent with the repo's module-identity guidance).
+ * Config is loaded on session_start and read by the read/edit overrides.
  *
  * @module pi-hashline-edit/pi
  */
 
-import { createSnapshot } from "../core/snapshot.ts";
-import type { FileSnapshot } from "../core/types.ts";
 import type { HashlineEditConfig } from "./config.ts";
 
 const GLOBAL_KEY = "__piHashlineEdit";
-const DEFAULT_CONFIG: HashlineEditConfig = { enabled: true, hashLen: 4 };
-/** Maximum number of cached file snapshots; beyond this the least-recently-accessed is evicted. */
-const MAX_SNAPSHOTS = 64;
+const DEFAULT_CONFIG: HashlineEditConfig = { enabled: true, hashLen: 4, shiftRadius: 15 };
 
 export interface HashlineEditState {
-	/** canonical path → snapshot. LRU order: Map insertion order, most recently accessed at the end. */
-	readonly snapshots: Map<string, FileSnapshot>;
-	hashLen: number;
 	config: HashlineEditConfig;
 }
 
@@ -30,51 +20,7 @@ export function getState(): HashlineEditState {
 	const g = globalThis as Record<string, unknown>;
 	const existing = g[GLOBAL_KEY];
 	if (existing) return existing as HashlineEditState;
-	const state: HashlineEditState = {
-		snapshots: new Map(),
-		hashLen: DEFAULT_CONFIG.hashLen,
-		config: DEFAULT_CONFIG,
-	};
+	const state: HashlineEditState = { config: DEFAULT_CONFIG };
 	g[GLOBAL_KEY] = state;
 	return state;
 }
-
-/** Write a snapshot and maintain LRU: move to the end (most recently used); evict the oldest (Map's first entry) when over the limit. */
-function touchAndEvict(map: Map<string, FileSnapshot>, path: string, snap: FileSnapshot): void {
-	if (map.has(path)) map.delete(path);
-	map.set(path, snap);
-	while (map.size > MAX_SNAPSHOTS) {
-		const oldest = map.keys().next().value;
-		if (oldest === undefined) break;
-		map.delete(oldest);
-	}
-}
-
-/** Record a file snapshot (called on read): compute line hashes + LRU bookkeeping. */
-export function recordSnapshot(canonicalPath: string, text: string): FileSnapshot {
-	const state = getState();
-	const snap = createSnapshot(canonicalPath, text, state.hashLen);
-	touchAndEvict(state.snapshots, canonicalPath, snap);
-	return snap;
-}
-
-/** Store an already-computed snapshot (updated after a successful edit), via LRU. */
-export function putSnapshot(canonicalPath: string, snap: FileSnapshot): void {
-	touchAndEvict(getState().snapshots, canonicalPath, snap);
-}
-
-/** Get a file snapshot (for edit verification); on a hit move it to the end (LRU touch). */
-export function getSnapshot(canonicalPath: string): FileSnapshot | undefined {
-	const map = getState().snapshots;
-	const snap = map.get(canonicalPath);
-	if (snap) {
-		map.delete(canonicalPath);
-		map.set(canonicalPath, snap);
-	}
-	return snap;
-}
-
-/** Clear all snapshots (on session restart). */
-export function clearSnapshots(): void {
-	getState().snapshots.clear();
-}

package/src/core/diff.test.ts

@@ -1,21 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { buildDiff } from "./diff.ts";
-
-test("single hunk", () => {
-	const d = buildDiff("f.ts", ["a", "b", "c"], [{ lo: 1, hi: 2, newLines: ["X"] }]);
-	assert.ok(d.startsWith("--- a/f.ts\n"));
-	assert.ok(d.includes("+++ b/f.ts"));
-	assert.ok(d.includes("@@ -2 +2 @@"));
-	assert.ok(d.includes("-b"));
-	assert.ok(d.includes("+X"));
-});
-
-test("multi-line range hunk carries counts", () => {
-	const d = buildDiff("f", ["a", "b", "c", "d"], [{ lo: 0, hi: 3, newLines: ["X"] }]);
-	assert.ok(d.includes("@@ -1,3 +1 @@")); // newCount=1 omits the count (git convention)
-});
-
-test("empty ops returns empty string", () => {
-	assert.equal(buildDiff("f", ["a"], []), "");
-});

package/src/core/diff.ts

@@ -1,41 +0,0 @@
-/**
- * Ops-based unified diff preview.
- *
- * Each SpanOp produces one hunk; the `@@` line numbers are based on the
- * original file (each op's own original position), so the content is accurate.
- * This is a Phase 1 approximation; if precise multi-op line numbers are needed,
- * LCS can replace it later.
- *
- * @module pi-hashline-edit/core
- */
-
-interface SpanOpLike {
-	lo: number;
-	hi: number;
-	newLines: string[];
-}
-
-/**
- * Build a unified diff.
- *
- * @param path     file path (for the diff header)
- * @param oldLines original line array before applying
- * @param ops      line-level operations applied
- */
-export function buildDiff(path: string, oldLines: readonly string[], ops: readonly SpanOpLike[]): string {
-	if (ops.length === 0) return "";
-	const out: string[] = [`--- a/${path}`, `+++ b/${path}`];
-	for (const op of ops) {
-		const oldCount = op.hi - op.lo;
-		const oldStart = oldCount === 0 ? op.lo : op.lo + 1; // zero-width (insertion point) uses lo, following the unified-diff "after line N" convention
-		const newCount = op.newLines.length;
-		const newStart = op.lo + 1;
-		// single-line hunks omit the count, following the unified-diff convention
-		const oldRange = oldCount === 1 ? `${oldStart}` : `${oldStart},${oldCount}`;
-		const newRange = newCount === 1 ? `${newStart}` : `${newStart},${newCount}`;
-		out.push(`@@ -${oldRange} +${newRange} @@`);
-		for (let i = op.lo; i < op.hi; i++) out.push(`-${oldLines[i]}`);
-		for (const nl of op.newLines) out.push(`+${nl}`);
-	}
-	return out.join("\n") + "\n";
-}

package/src/core/parse.test.ts

@@ -1,117 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { parsePatch } from "./parse.ts";
-
-test("parse replace single line", () => {
-	const r = parsePatch("file: f.ts\n\nreplace 4#ABCD:\n+new line\n");
-	assert.equal(r.ok, true);
-	if (r.ok) {
-		assert.equal(r.patch.path, "f.ts");
-		assert.equal(r.patch.edits.length, 1);
-		assert.equal(r.patch.edits[0].op, "replace");
-	}
-});
-
-test("parse replace range", () => {
-	const r = parsePatch("file: f.ts\nreplace 3#AAA..5#BBB:\n+a\n+b\n");
-	assert.equal(r.ok, true);
-	if (r.ok) {
-		const e = r.patch.edits[0];
-		if (e.op === "replace") {
-			assert.equal(e.start.line, 3);
-			assert.equal(e.end?.line, 5);
-			assert.deepEqual(e.body, ["a", "b"]);
-		}
-	}
-});
-
-test("parse delete (no body)", () => {
-	const r = parsePatch("file: f.ts\ndelete 2#XYZ\n");
-	assert.equal(r.ok, true);
-	if (r.ok) assert.equal(r.patch.edits[0].op, "delete");
-});
-
-test("parse insert_after / insert_before", () => {
-	const r = parsePatch("file: f.ts\ninsert_after 3#ABC:\n+x\n\ninsert_before 5#DEF:\n+y\n");
-	assert.equal(r.ok, true);
-	if (r.ok) assert.equal(r.patch.edits.length, 2);
-});
-
-test("parse append / prepend", () => {
-	const r = parsePatch("file: f.ts\nappend:\n+z\n\nprepend:\n+w\n");
-	assert.equal(r.ok, true);
-	if (r.ok) {
-		assert.equal(r.patch.edits[0].op, "append");
-		assert.equal(r.patch.edits[1].op, "prepend");
-	}
-});
-
-test("multiple mixed operations", () => {
-	const r = parsePatch("file: f.ts\n\nreplace 1#A:\n+x\n\ndelete 3#C\n\ninsert_after 5#E:\n+y\n");
-	assert.equal(r.ok, true);
-	if (r.ok) assert.equal(r.patch.edits.length, 3);
-});
-
-test("body kept literally (with + prefix, markdown)", () => {
-	const r = parsePatch("file: f.ts\nreplace 1#A:\n++i\n+- item\n+\n");
-	assert.equal(r.ok, true);
-	if (r.ok) {
-		const e = r.patch.edits[0];
-		if (e.op === "replace") assert.deepEqual(e.body, ["+i", "- item", ""]);
-	}
-});
-
-test("colon is optional", () => {
-	const r = parsePatch("file: f.ts\nreplace 1#A\n+x\n");
-	assert.equal(r.ok, true);
-});
-
-test("CRLF normalization", () => {
-	const r = parsePatch("file: f.ts\r\nreplace 1#A:\r\n+x\r\n");
-	assert.equal(r.ok, true);
-	if (r.ok) {
-		const e = r.patch.edits[0];
-		if (e.op === "replace") assert.deepEqual(e.body, ["x"]); // no \r
-	}
-});
-
-// --- error paths ---
-
-test("missing file header errors", () => {
-	const r = parsePatch("replace 1#A:\n+x\n");
-	assert.equal(r.ok, false);
-});
-
-test("empty input errors", () => {
-	assert.equal(parsePatch("").ok, false);
-	assert.equal(parsePatch("\n\n").ok, false);
-});
-
-test("empty body errors", () => {
-	const r = parsePatch("file: f.ts\nreplace 1#A:\n");
-	assert.equal(r.ok, false);
-	if (!r.ok) assert.equal(r.error.kind, "parse");
-});
-
-test("unknown verb errors (rejects SWAP/DEL)", () => {
-	const r = parsePatch("file: f.ts\nSWAP 1#A:\n+x\n");
-	assert.equal(r.ok, false);
-	if (!r.ok) assert.equal(r.error.kind, "parse");
-});
-
-test("stray body errors", () => {
-	const r = parsePatch("file: f.ts\n+x\n");
-	assert.equal(r.ok, false);
-});
-
-test("delete with body errors", () => {
-	const r = parsePatch("file: f.ts\ndelete 2#X\n+leak\n");
-	// a + line right after delete → the next round treats it as a stray body
-	assert.equal(r.ok, false);
-});
-
-test("error includes the input line number", () => {
-	const r = parsePatch("file: f.ts\n\nreplace 1#A:\n+x\n\nSWAP 2#B:\n+y\n");
-	assert.equal(r.ok, false);
-	if (!r.ok) assert.ok(r.error.line && r.error.line >= 5);
-});

package/src/core/parse.ts

@@ -1,166 +0,0 @@
-/**
- * Strict parser: patch string → {@link ParsedPatch}.
- *
- * Core principle — zero guessing: only the canonical format is accepted (correct
- * verb + correct anchor + `+` body rows). Any variant (bare lines, legacy
- * `oldText`/`newText`, `SWAP`/`DEL`, etc.) is rejected and left to the
- * `transforms/normalize-legacy` middleware to normalize before parsing.
- *
- * Format:
- *
- * ```
- * file: <path>
- *
- * replace <line>#<hash>[..<line>#<hash>]:
- * +<text>
- *
- * delete <line>#<hash>[..<line>#<hash>]
- *
- * insert_after <line>#<hash>:
- * +<text>
- *
- * append:
- * +<text>
- * ```
- *
- * @module pi-hashline-edit/core
- */
-
-import type { Anchor, Edit, ParsedPatch, PatchError } from "./types.ts";
-
-export type ParseResult =
-	| { readonly ok: true; readonly patch: ParsedPatch }
-	| { readonly ok: false; readonly error: PatchError };
-
-function parseError(message: string, line?: number): PatchError {
-	return { kind: "parse", message, line };
-}
-
-const ANCHOR_RE = /^(\d+)#([0-9A-Za-z]+)$/;
-
-function parseAnchorStr(s: string): Anchor | null {
-	const m = ANCHOR_RE.exec(s);
-	return m ? { line: Number(m[1]), hash: m[2] } : null;
-}
-
-function parseRangeStr(s: string): { start: Anchor; end?: Anchor } | null {
-	const idx = s.indexOf("..");
-	if (idx === -1) {
-		const a = parseAnchorStr(s);
-		return a ? { start: a } : null;
-	}
-	const a = parseAnchorStr(s.slice(0, idx));
-	const b = parseAnchorStr(s.slice(idx + 2));
-	if (!a || !b) return null;
-	return { start: a, end: b };
-}
-
-type ParsedHeader =
-	| { readonly error: string }
-	| {
-			readonly verb: string;
-			readonly hasBody: boolean;
-			readonly build: (body: string[]) => Edit;
-	  };
-
-/** Parse a single operation header (already trimmed). Trailing colon is optional (for body-bearing verbs). */
-function parseOpHeader(s: string): ParsedHeader {
-	let core = s;
-	if (core.endsWith(":")) core = core.slice(0, -1).trimEnd();
-
-	const sp = core.indexOf(" ");
-	const verb = sp === -1 ? core : core.slice(0, sp);
-	const rest = sp === -1 ? "" : core.slice(sp + 1).trim();
-
-	switch (verb) {
-		case "replace": {
-			const r = parseRangeStr(rest);
-			if (!r) return { error: `replace needs "<line>#<hash>[..<line>#<hash>]", got: "${s}"` };
-			return { verb, hasBody: true, build: (body) => ({ op: "replace", start: r.start, end: r.end, body }) };
-		}
-		case "delete": {
-			const r = parseRangeStr(rest);
-			if (!r) return { error: `delete needs "<line>#<hash>[..<line>#<hash>]", got: "${s}"` };
-			return { verb, hasBody: false, build: () => ({ op: "delete", start: r.start, end: r.end }) };
-		}
-		case "insert_after":
-		case "insert_before": {
-			const a = parseAnchorStr(rest);
-			if (!a) return { error: `${verb} needs "<line>#<hash>", got: "${s}"` };
-			return { verb, hasBody: true, build: (body) => ({ op: verb, anchor: a, body }) };
-		}
-		case "append":
-		case "prepend": {
-			if (rest !== "") return { error: `${verb} takes no anchor, got: "${s}"` };
-			return { verb, hasBody: true, build: (body) => ({ op: verb, body }) };
-		}
-		default:
-			return {
-				error: `unknown verb "${verb}". Use replace / delete / insert_after / insert_before / append / prepend`,
-			};
-	}
-}
-
-/**
- * Strictly parse a patch.
- *
- * @param input patch string (CRLF is normalized to LF automatically)
- * @returns parse result; malformed input returns `ok: false` + PatchError (with the input line number)
- */
-export function parsePatch(input: string): ParseResult {
-	const normalized = input.replace(/\r\n/g, "\n");
-	const lines = normalized.split("\n");
-	const n = lines.length;
-	let i = 0;
-
-	while (i < n && lines[i].trim() === "") i++;
-	if (i >= n) return { ok: false, error: parseError("empty input", 1) };
-
-	const fileMatch = /^file:\s*(.+?)\s*$/i.exec(lines[i]);
-	if (!fileMatch) {
-		return {
-			ok: false,
-			error: parseError(`expected "file: <path>" on first non-blank line, got: "${lines[i]}"`, i + 1),
-		};
-	}
-	const path = fileMatch[1];
-	i++;
-
-	const edits: Edit[] = [];
-	while (i < n) {
-		while (i < n && lines[i].trim() === "") i++;
-		if (i >= n) break;
-
-		const headerLineNo = i + 1;
-		const raw = lines[i];
-		const trimmed = raw.trim();
-
-		if (trimmed.startsWith("+")) {
-			return { ok: false, error: parseError(`stray body row has no preceding header: "${raw}"`, headerLineNo) };
-		}
-
-		const parsed = parseOpHeader(trimmed);
-		if ("error" in parsed) {
-			return { ok: false, error: parseError(parsed.error, headerLineNo) };
-		}
-		i++;
-
-		let body: string[] = [];
-		if (parsed.hasBody) {
-			while (i < n && lines[i].startsWith("+")) {
-				body.push(lines[i].slice(1));
-				i++;
-			}
-			if (body.length === 0) {
-				return {
-					ok: false,
-					error: parseError(`"${parsed.verb}" needs at least one "+TEXT" body row`, headerLineNo),
-				};
-			}
-		}
-
-		edits.push(parsed.build(body));
-	}
-
-	return { ok: true, patch: { path, edits } };
-}

package/src/core/snapshot.test.ts

@@ -1,60 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { splitLines, joinLines, createSnapshot, verifyAnchor } from "./snapshot.ts";
-
-test("splitLines edge cases", () => {
-	assert.deepEqual(splitLines(""), []);
-	assert.deepEqual(splitLines("a"), ["a"]);
-	assert.deepEqual(splitLines("a\nb"), ["a", "b"]);
-	assert.deepEqual(splitLines("a\nb\n"), ["a", "b"]);
-	assert.deepEqual(splitLines("a\n\n"), ["a", ""]);
-	assert.deepEqual(splitLines("\n"), [""]);
-});
-
-test("splitLines strips CRLF \\r", () => {
-	assert.deepEqual(splitLines("a\r\nb\r\n"), ["a", "b"]);
-	assert.deepEqual(splitLines("a\r\nb"), ["a", "b"]);
-});
-
-test("joinLines restores line endings", () => {
-	assert.equal(joinLines(["a", "b"]), "a\nb\n");
-	assert.equal(joinLines([]), "");
-	assert.equal(joinLines(["a", "b"], "crlf"), "a\r\nb\r\n");
-	assert.equal(joinLines(["a", "b"], "lf"), "a\nb\n");
-});
-
-test("createSnapshot records path/text/hashLen", () => {
-	const s = createSnapshot("f.ts", "a\nb\nc\n");
-	assert.equal(s.path, "f.ts");
-	assert.equal(s.text, "a\nb\nc\n");
-	assert.equal(s.lineHashes.length, 3);
-	assert.equal(s.hashLen, 4);
-});
-
-test("createSnapshot custom hashLen", () => {
-	assert.equal(createSnapshot("f", "a\n", 6).hashLen, 6);
-});
-
-test("createSnapshot records lineEnding", () => {
-	assert.equal(createSnapshot("f", "a\nb\n").lineEnding, "lf");
-	assert.equal(createSnapshot("f", "a\r\nb\r\n").lineEnding, "crlf");
-});
-
-test("verifyAnchor match", () => {
-	const s = createSnapshot("f", "a\nb\n");
-	assert.deepEqual(verifyAnchor(s, { line: 2, hash: s.lineHashes[1] }), { ok: true, line: 2 });
-});
-
-test("verifyAnchor hash_not_found", () => {
-	const s = createSnapshot("f", "a\nb\n");
-	const r = verifyAnchor(s, { line: 1, hash: "ZZZZ" });
-	assert.equal(r.ok, false);
-	if (!r.ok) assert.equal(r.error, "hash_not_found");
-});
-
-test("verifyAnchor line_mismatch (drift)", () => {
-	const s = createSnapshot("f", "a\nb\n");
-	const r = verifyAnchor(s, { line: 1, hash: s.lineHashes[1] });
-	assert.equal(r.ok, false);
-	if (!r.ok) assert.equal(r.error, "line_mismatch");
-});