@retaw106/mmc-oc 2.2.1 → 2.4.0

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();
+    }
+});

package/src/shared/sqlite-foreground-wait.test.ts

@@ -0,0 +1,304 @@
+import { expect, spyOn, test } from "bun:test";
+import { rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { log } from "./logger";
+import {
+    Database,
+    guardSqliteTransformPass,
+    registerSqliteDiagnosticSink,
+    SqliteAcquisitionBusyError,
+    withPrivilegedWriter,
+    withSqliteTransformPass,
+} from "./sqlite";
+import { startSqliteWriteLocker } from "./sqlite-write-locker-test-support";
+import { createTestTempDirFromPath } from "./test-temp-dir";
+
+function fixture() {
+    const dir = createTestTempDirFromPath(join(tmpdir(), "mc-foreground-wait-"));
+    const path = join(dir, "context.db");
+    const db = new Database(path);
+    db.exec(`
+        PRAGMA journal_mode=WAL;
+        PRAGMA busy_timeout=5000;
+        CREATE TABLE context_privilege_state(id INTEGER PRIMARY KEY, enabled INTEGER);
+        CREATE TABLE result(value TEXT);
+    `);
+    return {
+        db,
+        path,
+        close() {
+            db.close();
+            rmSync(dir, { recursive: true, force: true });
+        },
+    };
+}
+
+// Upstream also drives two cases through the OC1 messages-transform handler
+// (1 s hold served, 2.5 s hold refused with StorageBusyRefusalError). That
+// adapter is deleted in this fork; the in-pass acquisition-wait behavior those
+// cases cover is exercised here against the core primitives instead, and the
+// 1 s/2.5 s boundaries are additionally covered by scripts/smoke-node-sqlite.ts.
+for (const mode of ["BEGIN", "autocommit"]) {
+    test(`foreground ${mode} wait is capped by the pass deadline`, () => {
+        const { db, path, close } = fixture();
+        const blocker = new Database(path);
+        blocker.exec("BEGIN IMMEDIATE");
+        const diagnostics: string[] = [];
+        registerSqliteDiagnosticSink((line) => diagnostics.push(line));
+        try {
+            const started = performance.now();
+            withSqliteTransformPass(() => {
+                guardSqliteTransformPass({ assert() {}, remainingMs: () => 100 });
+                expect(() => {
+                    if (mode === "BEGIN") withPrivilegedWriter(db, () => undefined);
+                    else db.prepare("INSERT INTO result VALUES ('late')").run();
+                }).toThrow(SqliteAcquisitionBusyError);
+            });
+            expect(performance.now() - started).toBeGreaterThanOrEqual(75);
+            expect(performance.now() - started).toBeLessThan(700);
+            expect(db.prepare("SELECT * FROM result").all()).toEqual([]);
+            expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 5000 });
+        } finally {
+            registerSqliteDiagnosticSink(log);
+            blocker.exec("ROLLBACK");
+            blocker.close();
+            close();
+        }
+    });
+}
+
+// Fork shape: upstream drives the "slow uncontended SQL preserves admission"
+// pair through the OC1 messages-transform handler (deleted in this fork — see
+// the note above); the lease invariant it protects is asserted here against
+// the core primitives instead.
+test("uncontended autocommit work does not consume the foreground wait budget", async () => {
+    const { db, path, close } = fixture();
+    const blocker = new Database(path);
+    const timeouts: number[] = [];
+    const nativeExec = db.exec.bind(db);
+    const exec = spyOn(db, "exec").mockImplementation((sql) => {
+        const timeout = /^PRAGMA busy_timeout=(\d+)$/.exec(sql);
+        if (timeout) timeouts.push(Number(timeout[1]));
+        return nativeExec(sql);
+    });
+    try {
+        await withSqliteTransformPass(async () => {
+            guardSqliteTransformPass({ assert() {}, remainingMs: () => 30_000 });
+            // Spend ~1.5s inside successful, uncontended SQL. Recursive CTEs
+            // keep this independent of CPU speed and UDF APIs.
+            const cte =
+                "WITH RECURSIVE n(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM n WHERE x<1000000)";
+            const slowWrite = db.prepare(
+                `${cte} INSERT INTO result SELECT sum(x) FROM n RETURNING value`,
+            );
+            const slowRead = db.prepare(`${cte} SELECT sum(x) FROM n`);
+            const started = performance.now();
+            do {
+                slowWrite.all();
+                slowRead.all();
+            } while (performance.now() - started < 1500);
+            // The contended retry must still see (nearly) the full budget.
+            blocker.exec("BEGIN IMMEDIATE");
+            timeouts.length = 0;
+            expect(() => db.prepare("INSERT INTO result VALUES ('blocked')").run()).toThrow(
+                SqliteAcquisitionBusyError,
+            );
+        });
+        expect(timeouts[0]).toBe(0);
+        expect(timeouts[1]).toBeGreaterThanOrEqual(1900);
+    } finally {
+        exec.mockRestore();
+        if (blocker.inTransaction) blocker.exec("ROLLBACK");
+        blocker.close();
+        close();
+    }
+}, 30_000);
+
+test("BUSY autocommit probes do not double-apply INSERT OR IGNORE, UPSERT or RETURNING", async () => {
+    const { db, path, close } = fixture();
+    db.exec(
+        "CREATE TABLE counter(id INTEGER PRIMARY KEY, n INTEGER); INSERT INTO counter VALUES (1, 0)",
+    );
+    const forms = [
+        ["INSERT OR IGNORE INTO counter VALUES (2, 1)", "run"],
+        ["INSERT INTO counter VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET n = n + 1", "run"],
+        ["UPDATE counter SET n = n + 1 WHERE id = 1 RETURNING n", "get"],
+        [
+            "INSERT INTO counter VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET n = n + 1 RETURNING n",
+            "all",
+        ],
+    ] as const;
+    try {
+        for (const [sql, method] of forms) {
+            const blocker = new Database(path);
+            blocker.exec("BEGIN IMMEDIATE");
+            db.exec("PRAGMA busy_timeout=0");
+            const before = db.prepare("SELECT * FROM counter ORDER BY id").all();
+            try {
+                expect(() => db.prepare(sql)[method]()).toThrow("locked");
+                expect(db.prepare("SELECT * FROM counter ORDER BY id").all()).toEqual(before);
+                expect(db.inTransaction).toBe(false);
+            } finally {
+                blocker.exec("ROLLBACK");
+                blocker.close();
+            }
+            const locker = await startSqliteWriteLocker(path, 100);
+            try {
+                await withSqliteTransformPass(() => db.prepare(sql)[method]());
+            } finally {
+                expect(await locker.exited).toBe(0);
+            }
+        }
+        expect(db.prepare("SELECT * FROM counter ORDER BY id").all()).toEqual([
+            { id: 1, n: 3 },
+            { id: 2, n: 1 },
+        ]);
+    } finally {
+        close();
+    }
+}, 30_000);
+
+test("many contended autocommit writes share at most two seconds of lock waiting", async () => {
+    const { db, path, close } = fixture();
+    const blocker = new Database(path);
+    blocker.exec("BEGIN IMMEDIATE");
+    const timeouts: number[] = [];
+    const nativeExec = db.exec.bind(db);
+    const exec = spyOn(db, "exec").mockImplementation((sql) => {
+        const timeout = /^PRAGMA busy_timeout=(\d+)$/.exec(sql);
+        if (timeout) timeouts.push(Number(timeout[1]));
+        return nativeExec(sql);
+    });
+    try {
+        await withSqliteTransformPass(() => {
+            // Use real BUSY failures but a controlled accounting clock: each
+            // retry costs 400ms regardless of runner scheduling. The deadline
+            // keeps the real waits short without hiding lease exhaustion.
+            guardSqliteTransformPass({ assert() {}, remainingMs: () => 10 });
+            let now = 0;
+            const clock = spyOn(performance, "now").mockImplementation(() => (now += 400));
+            try {
+                for (let i = 0; i < 8; i++) {
+                    expect(() => db.prepare("INSERT INTO result VALUES ('one')").run()).toThrow(
+                        SqliteAcquisitionBusyError,
+                    );
+                }
+            } finally {
+                clock.mockRestore();
+            }
+            // Five charged retries exhaust 2000ms. All later retries must have
+            // zero timeout even though the deadline still offers another 10ms.
+            expect(timeouts).toEqual([
+                ...Array.from({ length: 5 }, () => [0, 10, 5000]).flat(),
+                ...Array.from({ length: 3 }, () => [0, 0, 5000]).flat(),
+            ]);
+            blocker.exec("ROLLBACK");
+            db.prepare("INSERT INTO result VALUES ('uncontended')").run();
+        });
+        expect(db.prepare("SELECT * FROM result").all()).toEqual([{ value: "uncontended" }]);
+    } finally {
+        exec.mockRestore();
+        if (blocker.inTransaction) blocker.exec("ROLLBACK");
+        blocker.close();
+        close();
+    }
+}, 30_000);
+
+test("an exec script charges its single attempt without a zero-wait probe", () => {
+    const { db, path, close } = fixture();
+    const blocker = new Database(path);
+    const timeouts: number[] = [];
+    const nativeExec = db.exec.bind(db);
+    const exec = spyOn(db, "exec").mockImplementation((sql) => {
+        const timeout = /^PRAGMA busy_timeout=(\d+)$/.exec(sql);
+        if (timeout) timeouts.push(Number(timeout[1]));
+        return nativeExec(sql);
+    });
+    try {
+        withSqliteTransformPass(() => {
+            let now = 0;
+            const clock = spyOn(performance, "now").mockImplementation(() => (now += 2500));
+            try {
+                db.exec(
+                    "INSERT INTO result VALUES ('prefix'); INSERT INTO result VALUES ('suffix')",
+                );
+            } finally {
+                clock.mockRestore();
+            }
+            blocker.exec("BEGIN IMMEDIATE");
+            expect(() => db.prepare("INSERT INTO result VALUES ('blocked')").run()).toThrow(
+                SqliteAcquisitionBusyError,
+            );
+        });
+        expect(timeouts).toEqual([2000, 5000, 0, 0, 5000]);
+        expect(db.prepare("SELECT * FROM result").all()).toEqual([
+            { value: "prefix" },
+            { value: "suffix" },
+        ]);
+    } finally {
+        exec.mockRestore();
+        if (blocker.inTransaction) blocker.exec("ROLLBACK");
+        blocker.close();
+        close();
+    }
+});
+
+test("an explicit transaction keeps its timeout and never probes or retries", () => {
+    const { db, path, close } = fixture();
+    const other = new Database(path);
+    db.exec("PRAGMA busy_timeout=0; BEGIN; SELECT * FROM result");
+    other.exec("INSERT INTO result VALUES ('other')");
+    const exec = spyOn(db, "exec");
+    try {
+        withSqliteTransformPass(() => {
+            expect(() => db.prepare("INSERT INTO result VALUES ('stale')").run()).toThrow("locked");
+        });
+        expect(exec).not.toHaveBeenCalled();
+        expect(db.inTransaction).toBe(true);
+        expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 0 });
+    } finally {
+        exec.mockRestore();
+        if (db.inTransaction) db.exec("ROLLBACK");
+        other.close();
+        close();
+    }
+});
+
+test("an autocommit exec script never replays a committed prefix after BUSY", () => {
+    const main = fixture();
+    const auxiliary = fixture();
+    const free = fixture();
+    try {
+        main.db.prepare("ATTACH DATABASE ? AS aux").run(auxiliary.path);
+        main.db.prepare("ATTACH DATABASE ? AS free").run(free.path);
+        auxiliary.db.exec("BEGIN IMMEDIATE");
+        withSqliteTransformPass(() => {
+            guardSqliteTransformPass({ assert() {}, remainingMs: () => 100 });
+            expect(() =>
+                main.db.exec(
+                    "INSERT INTO main.result VALUES ('prefix'); INSERT INTO aux.result VALUES ('blocked')",
+                ),
+            ).toThrow(SqliteAcquisitionBusyError);
+            expect(() =>
+                main.db.exec(
+                    "CREATE TABLE applied_once(id); INSERT INTO aux.result VALUES ('blocked')",
+                ),
+            ).toThrow(SqliteAcquisitionBusyError);
+            expect(() =>
+                main.db.exec(
+                    "CREATE TABLE free.applied_once(id); INSERT INTO aux.result VALUES ('blocked')",
+                ),
+            ).toThrow(SqliteAcquisitionBusyError);
+        });
+        expect(main.db.prepare("SELECT * FROM main.result").all()).toEqual([{ value: "prefix" }]);
+        expect(
+            main.db.prepare("SELECT name FROM sqlite_schema WHERE name='applied_once'").all(),
+        ).toHaveLength(1);
+    } finally {
+        auxiliary.db.exec("ROLLBACK");
+        auxiliary.close();
+        main.close();
+        free.close();
+    }
+});

package/src/shared/sqlite-pass-scope.test.ts

@@ -100,7 +100,7 @@ test("foreground admission keeps the loop ticking while a separate writer holds
     }
 }, 30000);
 
-test("a foreground in-pass writer has bounded 250ms tolerance and restores its timeout", () => {
+test("a foreground in-pass writer has bounded 2000ms tolerance and restores its timeout", () => {
     const { db, path, close } = fixture();
     const blocker = new Database(path);
     blocker.exec("BEGIN IMMEDIATE");
@@ -109,15 +109,15 @@ test("a foreground in-pass writer has bounded 250ms tolerance and restores its t
         expect(() =>
             withSqliteTransformPass(() => withPrivilegedWriter(db, () => undefined)),
         ).toThrow(SqliteAcquisitionBusyError);
-        expect(performance.now() - start).toBeGreaterThanOrEqual(200);
-        expect(performance.now() - start).toBeLessThan(400);
+        expect(performance.now() - start).toBeGreaterThanOrEqual(1900);
+        expect(performance.now() - start).toBeLessThan(2500);
         expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 5000 });
     } finally {
         blocker.exec("ROLLBACK");
         blocker.close();
         close();
     }
-});
+}, 30000);
 
 test("ready background publication retries on a timer and retains its write", async () => {
     const { db, path, close } = fixture();