@retaw106/mmc-oc 2.3.0 → 2.5.0

package/src/shared/rpc-discovery-cleanup.test.ts

@@ -0,0 +1,125 @@
+import { expect, spyOn, test } from "bun:test";
+import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { reapDeadRpcDiscovery } from "./rpc-discovery-cleanup";
+import { MagicContextRpcServer } from "./rpc-server";
+import * as utils from "./rpc-utils";
+import * as storage from "./storage-permissions";
+import { createTestTempDirFromPath } from "./test-temp-dir";
+
+test("RPC startup reaps dead records across projects but keeps live and inconclusive records", async () => {
+    const root = createTestTempDirFromPath(join(tmpdir(), "rpc-reap-"));
+    const server = new MagicContextRpcServer(root, "/current-project");
+    const dir = utils.rpcPortDir(root, "/other-project");
+    const empty = utils.rpcPortDir(root, "/empty-project");
+    mkdirSync(dir, { recursive: true });
+    mkdirSync(empty, { recursive: true });
+    for (const pid of [999999, 888888, process.pid])
+        writeFileSync(
+            join(dir, `port-${pid}.json`),
+            JSON.stringify({ port: 1234, pid, token: "do-not-log" }),
+        );
+    const probe = spyOn(utils, "inspectProcessesAsync").mockResolvedValue({
+        pi: { state: "absent", processIds: [] },
+        evidence: () => ({ processStartTime: null, commandLine: null, imageName: null }),
+        liveness: (pid: number) =>
+            pid === 999999 ? "dead" : pid === 888888 ? "inconclusive" : "alive",
+    } as Awaited<ReturnType<typeof utils.inspectProcessesAsync>>);
+    try {
+        await server.start();
+        expect(readdirSync(dir).sort()).toEqual(
+            [`port-${process.pid}.json`, "port-888888.json"].sort(),
+        );
+        expect(existsSync(empty)).toBe(false);
+    } finally {
+        server.stop();
+        probe.mockRestore();
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test("cleanup keeps changed, malformed and out-of-scope records and requests fresh evidence", async () => {
+    const root = createTestTempDirFromPath(join(tmpdir(), "rpc-reap-race-"));
+    const directory = utils.rpcPortDir(root, "/project");
+    const outside = join(root, "rpc", "not-a-project-hash");
+    mkdirSync(directory, { recursive: true });
+    mkdirSync(outside, { recursive: true });
+    const path = join(directory, "port-999999.json");
+    writeFileSync(path, JSON.stringify({ port: 1234, pid: 999999, token: "old" }));
+    writeFileSync(join(directory, "port-888888.json"), "not json");
+    writeFileSync(join(directory, "unrelated.json"), "keep");
+    mkdirSync(join(directory, "port-777777.json"));
+    writeFileSync(join(outside, "port-999999.json"), "keep");
+    const probe = spyOn(utils, "inspectProcessesAsync").mockImplementation(async (fresh) => {
+        expect(fresh).toBe(true);
+        writeFileSync(path, JSON.stringify({ port: 1234, pid: 999999, token: "new" }));
+        return {
+            pi: { state: "absent", processIds: [] },
+            evidence: () => ({ startTime: null, commandLine: null }),
+            liveness: () => "dead",
+        };
+    });
+    try {
+        await reapDeadRpcDiscovery(root);
+        expect(probe).toHaveBeenCalledTimes(1);
+        expect(readdirSync(directory)).toHaveLength(4);
+        expect(existsSync(join(outside, "port-999999.json"))).toBe(true);
+    } finally {
+        probe.mockRestore();
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test("stop during startup prevents listening and publishing", async () => {
+    const root = createTestTempDirFromPath(join(tmpdir(), "rpc-start-stop-"));
+    const server = new MagicContextRpcServer(root, root);
+    try {
+        const starting = server.start();
+        server.stop();
+        expect(await starting).toBe(0);
+        expect(existsSync(utils.rpcPortDir(root, root))).toBe(false);
+    } finally {
+        server.stop();
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test.each(["ENOENT", "EACCES"])("publishing retries only ENOENT (%s)", async (code) => {
+    const root = createTestTempDirFromPath(join(tmpdir(), "rpc-publish-race-"));
+    const server = new MagicContextRpcServer(root, root);
+    const original = storage.writeStorageFileAtomicSync;
+    let calls = 0;
+    const writer = spyOn(storage, "writeStorageFileAtomicSync").mockImplementation((...args) => {
+        if (++calls === 1) throw Object.assign(new Error("publish race"), { code });
+        return original(...args);
+    });
+    try {
+        await server.start();
+        expect(calls).toBe(code === "ENOENT" ? 2 : 1);
+        expect(existsSync(utils.rpcPortDir(root, root))).toBe(code === "ENOENT");
+    } finally {
+        server.stop();
+        writer.mockRestore();
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test("RPC stop removes its empty discovery directory but preserves other instances", async () => {
+    const root = createTestTempDirFromPath(join(tmpdir(), "rpc-stop-reap-"));
+    const first = new MagicContextRpcServer(root, root);
+    const second = new MagicContextRpcServer(root, root);
+    const directory = utils.rpcPortDir(root, root);
+    try {
+        await first.start();
+        await second.start();
+        first.stop();
+        expect(readdirSync(directory)).toHaveLength(1);
+        second.stop();
+        expect(existsSync(directory)).toBe(false);
+    } finally {
+        first.stop();
+        second.stop();
+        rmSync(root, { recursive: true, force: true });
+    }
+});

package/src/shared/rpc-discovery-cleanup.ts

@@ -0,0 +1,57 @@
+import { type Dirent, promises as fs } from "node:fs";
+import { join } from "node:path";
+import { inspectProcessesAsync, parseRpcPortFile } from "./rpc-utils";
+
+/** Reap only records proven dead; live, unreadable and uncertain records stay. */
+export async function reapDeadRpcDiscovery(storageDir: string): Promise<void> {
+    const root = join(storageDir, "rpc");
+    let directories: Dirent[];
+    try {
+        directories = await fs.readdir(root, { withFileTypes: true });
+    } catch {
+        return;
+    }
+    const records: { path: string; content: string; pid: number }[] = [];
+    const projectDirs: string[] = [];
+    for (const entry of directories) {
+        if (!entry.isDirectory() || !/^[0-9a-f]{16}$/.test(entry.name)) continue;
+        const directory = join(root, entry.name);
+        projectDirs.push(directory);
+        try {
+            for (const name of await fs.readdir(directory)) {
+                const match = /^port-(\d+)(?:-[0-9a-f]+)?\.json$/.exec(name);
+                if (!match) continue;
+                const path = join(directory, name);
+                try {
+                    const content = await fs.readFile(path, "utf8");
+                    const record = parseRpcPortFile(content, Number(match[1]));
+                    if (record && record.pid === Number(match[1]))
+                        records.push({ path, content, pid: record.pid });
+                } catch {
+                    // Another host may be publishing or stopping this record.
+                }
+            }
+        } catch {
+            // An inaccessible project must not prevent cleanup of other projects.
+        }
+    }
+    // Read records before a fresh process snapshot so a recently started host
+    // cannot be mistaken for a PID missing from an older cached snapshot.
+    const processes = records.length ? await inspectProcessesAsync(true) : undefined;
+    for (const record of records) {
+        if (processes?.liveness(record.pid) !== "dead") continue;
+        try {
+            if ((await fs.readFile(record.path, "utf8")) === record.content)
+                await fs.unlink(record.path);
+        } catch {
+            // Leave the record for a later pass; never recursively remove its directory.
+        }
+    }
+    for (const directory of projectDirs) {
+        try {
+            await fs.rmdir(directory);
+        } catch {
+            // Leave non-empty directories untouched; their owners may not be proven dead.
+        }
+    }
+}

package/src/shared/rpc-server.ts

@@ -1,7 +1,8 @@
 import { randomBytes, timingSafeEqual } from "node:crypto";
-import { readdirSync, readFileSync, unlinkSync } from "node:fs";
+import { readdirSync, readFileSync, rmdirSync, unlinkSync } from "node:fs";
 import type { Server, ServerWebSocket } from "bun";
 import { log } from "./logger";
+import { reapDeadRpcDiscovery } from "./rpc-discovery-cleanup";
 import {
     acknowledgeNotifications,
     drainNotifications,
@@ -82,6 +83,7 @@ export class MagicContextRpcServer {
     private portFilePath: string;
     private portDir: string;
     private startedAt = Date.now();
+    private stopped = false;
     private readonly instanceId = randomBytes(8).toString("hex");
     private unregisterOwnInstance: (() => void) | null = null;
     /** Every authenticated WS socket, so dispose can close them all. */
@@ -93,7 +95,10 @@ export class MagicContextRpcServer {
     // discovers/guesses the port.
     private readonly token = randomBytes(32).toString("hex");
 
-    constructor(storageDir: string, directory: string) {
+    constructor(
+        private storageDir: string,
+        directory: string,
+    ) {
         this.portFilePath = rpcPortFilePath(storageDir, directory, process.pid, this.instanceId);
         this.portDir = rpcPortDir(storageDir, directory);
     }
@@ -131,6 +136,9 @@ export class MagicContextRpcServer {
             log("rpc server skipped: Bun runtime not available (no TUI consumer)");
             return 0;
         }
+        this.stopped = false;
+        await reapDeadRpcDiscovery(this.storageDir);
+        if (this.stopped) return 0;
         this.startedAt = Date.now();
         const self = this;
         const server = Bun.serve<WsData>({
@@ -170,17 +178,26 @@ export class MagicContextRpcServer {
             // The discovery file carries the RPC bearer token. The shared writer
             // creates its directory and temporary file with owner-only modes.
             this.unregisterOwnInstance ??= registerOwnRpcServerInstance(this.instanceId);
-            writeStorageFileAtomicSync(
-                this.portFilePath,
-                JSON.stringify({
-                    port: this.port,
-                    pid: process.pid,
-                    started_at: this.startedAt,
-                    kind: "OpenCode server",
-                    token: this.token,
-                    instance_id: this.instanceId,
-                }),
-            );
+            const publish = () =>
+                writeStorageFileAtomicSync(
+                    this.portFilePath,
+                    JSON.stringify({
+                        port: this.port,
+                        pid: process.pid,
+                        started_at: this.startedAt,
+                        kind: "OpenCode server",
+                        token: this.token,
+                        instance_id: this.instanceId,
+                    }),
+                );
+            try {
+                publish();
+            } catch (error) {
+                // An empty-directory reaper can race the writer before its temp
+                // file exists. Recreate the directory and retry that case only.
+                if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+                publish();
+            }
             log(`[rpc] server listening on 127.0.0.1:${this.port}`);
         } catch (err) {
             log(`[rpc] failed to write port file: ${err}`);
@@ -191,6 +208,7 @@ export class MagicContextRpcServer {
 
     /** Stop the server: close every socket, stop accepting, remove port file. */
     stop(): void {
+        this.stopped = true;
         for (const ws of this.sockets) {
             try {
                 if (ws.data.authTimer) clearTimeout(ws.data.authTimer);
@@ -211,6 +229,11 @@ export class MagicContextRpcServer {
         } catch {
             // Intentional: port file may already be gone
         }
+        try {
+            rmdirSync(this.portDir);
+        } catch {
+            // Other instances' discovery records must survive this server's stop.
+        }
         this.unregisterOwnInstance?.();
         this.unregisterOwnInstance = null;
     }

package/src/shared/search-text.test.ts

@@ -0,0 +1,30 @@
+import { expect, test } from "bun:test";
+import { cleanSearchText, keywordRelevance, matchedSearchSnippet } from "./search-text";
+
+test("notification trees never contribute relevance or display text", () => {
+    expect(
+        cleanSearchText(
+            '<task_cohort id="parent"><task>hidden</task>status</task_cohort> actual answer',
+        ),
+    ).toBe("actual answer");
+    expect(cleanSearchText("kept <task>hidden </task_cohort> still hidden</task> kept")).toBe(
+        "kept kept",
+    );
+    expect(cleanSearchText('<task id="truncated">background result…')).toBe("");
+    expect(keywordRelevance("historian cache wiring", "<task>historian cache wiring</task>")).toBe(
+        0,
+    );
+});
+
+test("keyword relevance measures distinct coverage rather than rank", () => {
+    expect(keywordRelevance("explain historian cache wiring", "cache icons")).toBeCloseTo(0.2);
+    expect(keywordRelevance("historian cache wiring", "historian cache wiring")).toBeCloseTo(0.8);
+});
+
+test("snippets prefer dense passages over an irrelevant header", () => {
+    const content = `Header cache. ${"padding ".repeat(150)}Historian cache wiring uses incremental pools. ${"trailing ".repeat(100)}`;
+    const snippet = matchedSearchSnippet(content, "historian cache wiring", 80);
+    expect(snippet).toContain("Historian cache wiring");
+    expect(snippet).not.toContain("Header");
+    expect(matchedSearchSnippet(content, "unrelated deployment")).toBe("");
+});

package/src/shared/search-text.ts

@@ -0,0 +1,62 @@
+import { removeNestedBlocks } from "./system-directive";
+
+export function removeTaskNotifications(text: string): string {
+    return removeNestedBlocks(text, ["task", "task_cohort"]);
+}
+
+/** Remove injected notifications before scoring or rendering; saved hints replay unchanged. */
+export function cleanSearchText(text: string): string {
+    return removeNestedBlocks(text, ["system-reminder", "task", "task_cohort"])
+        .replace(/\s+/g, " ")
+        .trim();
+}
+
+const QUERY_STOP_WORDS = new Set(
+    "a an and are as at be been by can could did do does for from how i in is it me my of on or our please should that the their them there these they this to us was we were what when where which who why will with would you your".split(
+        " ",
+    ),
+);
+
+function terms(text: string): string[] {
+    return [
+        ...new Set(
+            (text.toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? []).filter(
+                (term) => !QUERY_STOP_WORDS.has(term),
+            ),
+        ),
+    ];
+}
+
+/** Score distinct query coverage independently of other results. */
+export function keywordRelevance(query: string, content: string): number {
+    const needles = terms(query);
+    if (needles.length === 0) return 0;
+    const words = new Set(terms(cleanSearchText(content)));
+    return (0.8 * needles.filter((term) => words.has(term)).length) / needles.length;
+}
+
+/** Pick the densest matching passage before compression discards matched words. */
+export function matchedSearchSnippet(content: string, query: string, cap = 220): string {
+    const text = cleanSearchText(content);
+    const needles = new Set(terms(query));
+    const matches = [...text.matchAll(/[\p{L}\p{N}_]+/gu)].filter((match) =>
+        needles.has(match[0].toLowerCase()),
+    );
+    if (matches.length === 0) return "";
+    let bestStart = matches[0].index;
+    let bestCoverage = -1;
+    for (const match of matches) {
+        const start = Math.max(0, match.index - Math.floor(cap / 5));
+        const coverage = keywordRelevance(query, text.slice(start, start + cap));
+        if (coverage > bestCoverage) {
+            bestStart = start;
+            bestCoverage = coverage;
+        }
+    }
+    if (bestStart > 0) {
+        const boundary = text.indexOf(" ", bestStart);
+        if (boundary >= 0 && boundary < matches[matches.length - 1].index) bestStart = boundary + 1;
+    }
+    const passage = text.slice(bestStart, bestStart + cap).trim();
+    return `${bestStart > 0 ? "…" : ""}${passage}${bestStart + cap < text.length ? "…" : ""}`;
+}

package/src/shared/sqlite-busy-budget-review.test.ts

@@ -0,0 +1,291 @@
+import { expect, test } from "bun:test";
+import { rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+    Database,
+    guardSqliteTransformPass,
+    SqliteAcquisitionBusyError,
+    withSqliteBackgroundWriter,
+    withSqliteTransformPass,
+} from "./sqlite";
+import { createTestTempDirFromPath } from "./test-temp-dir";
+
+function fixture() {
+    const dir = createTestTempDirFromPath(join(tmpdir(), "mc-busy-review-"));
+    const path = join(dir, "context.db");
+    const db = new Database(path);
+    db.exec("PRAGMA busy_timeout=5000; CREATE TABLE result(id INTEGER PRIMARY KEY, n INTEGER)");
+    db.exec("INSERT INTO result VALUES (1, 0)");
+    return {
+        db,
+        path,
+        close() {
+            db.close();
+            rmSync(dir, { recursive: true, force: true });
+        },
+    };
+}
+
+async function lock(path: string, mode: "read" | "write" | "exclusive", holdMs: number) {
+    const child = Bun.spawn(
+        [
+            "bun",
+            "--eval",
+            `import { Database } from "bun:sqlite";
+        const db = new Database(process.argv[1]);
+        db.exec(process.argv[2] === "read" ? "BEGIN; SELECT * FROM result"
+            : process.argv[2] === "write" ? "BEGIN IMMEDIATE" : "BEGIN EXCLUSIVE");
+        console.log("LOCKED");
+        Bun.sleepSync(Number(process.argv[3]));
+        db.exec("COMMIT");
+        db.close();`,
+            path,
+            mode,
+            String(holdMs),
+        ],
+        { stdout: "pipe", stderr: "pipe", windowsHide: true },
+    );
+    const reader = child.stdout.getReader();
+    let output = "";
+    while (!output.includes("LOCKED\n")) {
+        const chunk = await reader.read();
+        if (chunk.done) {
+            throw new Error(`locker failed: ${await new Response(child.stderr).text()}`);
+        }
+        output += new TextDecoder().decode(chunk.value);
+    }
+    reader.releaseLock();
+    return { exited: child.exited };
+}
+
+for (const method of ["run", "get", "all", "exec"] as const) {
+    test(`a rollback-journal commit BUSY retries ${method} exactly once after the reader leaves`, async () => {
+        const { db, path, close } = fixture();
+        const sql = "UPDATE result SET n = n + 1 WHERE id = 1";
+        const statement = db.prepare(`${sql} RETURNING n`);
+        const { exited } = await lock(path, "read", 150);
+        try {
+            await withSqliteTransformPass(() => {
+                if (method === "exec") db.exec(sql);
+                else statement[method]();
+            });
+            expect(db.prepare("SELECT * FROM result").all()).toEqual([{ id: 1, n: 1 }]);
+            expect(db.inTransaction).toBe(false);
+        } finally {
+            expect(await exited).toBe(0);
+            close();
+        }
+    });
+}
+
+for (const scope of ["foreground", "background", "unscoped"] as const) {
+    test(`exec in ${scope} does not wait on an unrelated attached database schema`, async () => {
+        const main = fixture();
+        const aux = fixture();
+        main.db.prepare("ATTACH DATABASE ? AS aux").run(aux.path);
+        const { exited } = await lock(aux.path, "exclusive", 2500);
+        try {
+            const started = performance.now();
+            const operation = () => main.db.exec("UPDATE main.result SET n = n + 1");
+            if (scope === "foreground") {
+                await withSqliteTransformPass(() => {
+                    guardSqliteTransformPass({ assert() {}, remainingMs: () => 75 });
+                    operation();
+                });
+            } else if (scope === "background") withSqliteBackgroundWriter(operation);
+            else operation();
+            expect(performance.now() - started).toBeLessThan(1500);
+            expect(main.db.prepare("SELECT n FROM main.result").get()).toEqual({ n: 1 });
+        } finally {
+            expect(await exited).toBe(0);
+            main.close();
+            aux.close();
+        }
+    }, 10_000);
+}
+
+for (const location of ["main", "aux"] as const) {
+    test(`BUSY retries leave single-statement effects atomic in ${location}, including AFTER triggers`, async () => {
+        const main = fixture();
+        const aux = fixture();
+        main.db.prepare("ATTACH DATABASE ? AS aux").run(aux.path);
+        main.db.exec("CREATE TABLE audit(n INTEGER)");
+        main.db.exec(`CREATE TEMP TRIGGER audit_insert AFTER INSERT ON ${location}.result
+            BEGIN INSERT INTO audit VALUES (new.n); END`);
+        main.db.exec(`CREATE TEMP TRIGGER audit_update AFTER UPDATE ON ${location}.result
+            BEGIN INSERT INTO audit VALUES (new.n); END`);
+        main.db.exec(`CREATE TEMP TRIGGER audit_delete AFTER DELETE ON ${location}.result
+            BEGIN INSERT INTO audit VALUES (old.n); END`);
+        const forms = [
+            `INSERT INTO ${location}.result VALUES (2, 10)`,
+            `INSERT OR IGNORE INTO ${location}.result VALUES (2, 20)`,
+            `INSERT OR REPLACE INTO ${location}.result VALUES (2, 30)`,
+            `INSERT INTO ${location}.result VALUES (2, 40) ON CONFLICT(id) DO UPDATE SET n=n+1`,
+            `UPDATE ${location}.result SET n=n+1 WHERE id=2`,
+            `DELETE FROM ${location}.result WHERE id=2`,
+        ];
+        try {
+            for (const sql of forms) {
+                const statement = main.db.prepare(`${sql} RETURNING *`);
+                const blocker = new Database(location === "main" ? main.path : aux.path);
+                blocker.exec("BEGIN IMMEDIATE");
+                main.db.exec("PRAGMA busy_timeout=0");
+                const before = main.db
+                    .prepare(`SELECT * FROM ${location}.result ORDER BY id`)
+                    .all();
+                const beforeAudit = main.db.prepare("SELECT * FROM audit").all();
+                try {
+                    expect(() => statement.all()).toThrow("locked");
+                    expect(
+                        main.db.prepare(`SELECT * FROM ${location}.result ORDER BY id`).all(),
+                    ).toEqual(before);
+                    expect(main.db.prepare("SELECT * FROM audit").all()).toEqual(beforeAudit);
+                    expect(main.db.inTransaction).toBe(false);
+                } finally {
+                    blocker.exec("ROLLBACK");
+                    blocker.close();
+                }
+                const { exited } = await lock(
+                    location === "main" ? main.path : aux.path,
+                    "write",
+                    60,
+                );
+                try {
+                    await withSqliteTransformPass(() => statement.all());
+                } finally {
+                    expect(await exited).toBe(0);
+                }
+            }
+            expect(main.db.prepare(`SELECT * FROM ${location}.result ORDER BY id`).all()).toEqual([
+                { id: 1, n: 0 },
+            ]);
+            expect(main.db.prepare("SELECT * FROM audit").all()).toEqual([
+                { n: 10 },
+                { n: 30 },
+                { n: 31 },
+                { n: 32 },
+                { n: 32 },
+            ]);
+        } finally {
+            main.close();
+            aux.close();
+        }
+    }, 10_000);
+}
+
+test("an attached DML-only committed prefix is not replayed after a later BUSY", () => {
+    const main = fixture();
+    const free = fixture();
+    const blocked = fixture();
+    try {
+        main.db.prepare("ATTACH DATABASE ? AS free").run(free.path);
+        main.db.prepare("ATTACH DATABASE ? AS blocked").run(blocked.path);
+        blocked.db.exec("BEGIN IMMEDIATE");
+        withSqliteTransformPass(() => {
+            expect(() =>
+                main.db.exec("UPDATE free.result SET n=n+1; UPDATE blocked.result SET n=n+1"),
+            ).toThrow(SqliteAcquisitionBusyError);
+        });
+        expect(main.db.prepare("SELECT n FROM free.result").get()).toEqual({ n: 1 });
+        expect(main.db.prepare("SELECT n FROM blocked.result").get()).toEqual({ n: 0 });
+    } finally {
+        blocked.db.exec("ROLLBACK");
+        main.close();
+        free.close();
+        blocked.close();
+    }
+});
+
+for (const location of ["main", "free"] as const) {
+    test(`an ignored AUTOINCREMENT prefix in ${location} is committed only once before a later BUSY`, () => {
+        const main = fixture();
+        const free = fixture();
+        const blocked = fixture();
+        try {
+            main.db.prepare("ATTACH DATABASE ? AS free").run(free.path);
+            main.db.exec(`CREATE TABLE ${location}.numbered(id INTEGER PRIMARY KEY AUTOINCREMENT, value TEXT UNIQUE);
+            INSERT INTO ${location}.numbered(value) VALUES ('existing')`);
+            main.db.prepare("ATTACH DATABASE ? AS blocked").run(blocked.path);
+            blocked.db.exec("BEGIN IMMEDIATE");
+            const before = main.db.prepare("SELECT total_changes() AS n").get();
+            withSqliteTransformPass(() => {
+                guardSqliteTransformPass({ assert() {}, remainingMs: () => 50 });
+                expect(() =>
+                    main.db.exec(
+                        `INSERT OR IGNORE INTO ${location}.numbered(value) VALUES ('existing'); UPDATE blocked.result SET n=n+1`,
+                    ),
+                ).toThrow(SqliteAcquisitionBusyError);
+            });
+            expect(main.db.prepare("SELECT total_changes() AS n").get()).toEqual(before);
+            expect(
+                main.db
+                    .prepare(`SELECT seq FROM ${location}.sqlite_sequence WHERE name='numbered'`)
+                    .get(),
+            ).toEqual({ seq: 2 });
+            expect(main.db.prepare(`SELECT * FROM ${location}.numbered`).all()).toEqual([
+                { id: 1, value: "existing" },
+            ]);
+        } finally {
+            blocked.db.exec("ROLLBACK");
+            main.close();
+            free.close();
+            blocked.close();
+        }
+    });
+}
+
+test("a WAL BUSY_SNAPSHOT in an explicit read transaction is not retried", () => {
+    const { db, path, close } = fixture();
+    db.exec("PRAGMA journal_mode=WAL");
+    const other = new Database(path);
+    try {
+        db.exec("BEGIN; SELECT * FROM result");
+        other.exec("UPDATE result SET n=n+1");
+        withSqliteTransformPass(() => {
+            expect(() => db.prepare("UPDATE result SET n=n+10").run()).toThrow("locked");
+        });
+        expect(db.inTransaction).toBe(true);
+        db.exec("ROLLBACK");
+        expect(db.prepare("SELECT n FROM result").get()).toEqual({ n: 1 });
+    } finally {
+        if (db.inTransaction) db.exec("ROLLBACK");
+        other.close();
+        close();
+    }
+});
+
+test("a BUSY from an AFTER trigger writing an attached database rolls back the outer statement", async () => {
+    const main = fixture();
+    const aux = fixture();
+    main.db.prepare("ATTACH DATABASE ? AS aux").run(aux.path);
+    // The TEMP trigger resolves an unqualified table in main first; give the
+    // attached target its own name so the trigger must write the other file.
+    main.db.exec("ALTER TABLE aux.result RENAME TO attached_result");
+    main.db.exec(`CREATE TEMP TRIGGER update_aux AFTER UPDATE ON main.result
+        BEGIN UPDATE attached_result SET n=n+1 WHERE id=1; END`);
+    const statement = main.db.prepare("UPDATE main.result SET n=n+1 RETURNING n");
+    const blocker = new Database(aux.path);
+    try {
+        blocker.exec("BEGIN IMMEDIATE");
+        main.db.exec("PRAGMA busy_timeout=0");
+        expect(() => statement.all()).toThrow("locked");
+        expect(main.db.prepare("SELECT n FROM main.result").get()).toEqual({ n: 0 });
+        expect(main.db.prepare("SELECT n FROM aux.attached_result").get()).toEqual({ n: 0 });
+        expect(main.db.inTransaction).toBe(false);
+        blocker.exec("ROLLBACK");
+        const { exited } = await lock(aux.path, "write", 100);
+        try {
+            await withSqliteTransformPass(() => statement.all());
+        } finally {
+            expect(await exited).toBe(0);
+        }
+        expect(main.db.prepare("SELECT n FROM main.result").get()).toEqual({ n: 1 });
+        expect(main.db.prepare("SELECT n FROM aux.attached_result").get()).toEqual({ n: 1 });
+    } finally {
+        if (blocker.inTransaction) blocker.exec("ROLLBACK");
+        blocker.close();
+        main.close();
+        aux.close();
+    }
+});