@cortexkit/opencode-magic-context 0.47.0 → 0.49.0

package/src/shared/project-directory-key.test.ts

@@ -13,6 +13,7 @@ import {
     __setCanonicalDirectoryRealpathForTests,
     canonicalProjectDirectory,
     projectDirectoryKey,
+    sameProjectDirectory,
 } from "./project-directory-key";
 import { projectHash, rpcPortDirsForLookup } from "./rpc-utils";
 import { createTestTempDirFromPath } from "./test-temp-dir";
@@ -109,3 +110,61 @@ describe("one discovery directory per project directory", () => {
         expect(dirs[0]).toBe(join("/storage", "rpc", projectHash("C:\\Users\\A\\Proj\\")));
     });
 });
+
+/**
+ * Background-session code compares a session's recorded directory with the
+ * plugin's own. OpenCode 2 on Windows records `D:/coding/app` while the plugin
+ * knows `D:\coding\app`; both must count as one directory, and a different
+ * directory must never be taken for this one.
+ */
+describe("sameProjectDirectory", () => {
+    for (const [name, left, right] of WINDOWS_PAIRS) {
+        test(`Windows ${name} is the same directory`, () => {
+            expect(sameProjectDirectory(left, right)).toBe(true);
+            expect(sameProjectDirectory(right, left)).toBe(true);
+        });
+    }
+
+    test("Windows forward slashes against backslashes, as OpenCode 2 stores them", () => {
+        expect(
+            sameProjectDirectory(
+                "D:/coding/siac/wt/migracion-asincrona",
+                "D:\\coding\\siac\\wt\\migracion-asincrona",
+            ),
+        ).toBe(true);
+    });
+
+    test("Windows `.` and `..` segments and a trailing forward slash", () => {
+        expect(
+            sameProjectDirectory("C:\\Users\\dev\\.\\work\\tmp\\..\\app", "C:/Users/dev/work/app/"),
+        ).toBe(true);
+    });
+
+    test("POSIX trailing slash and `..` segments", () => {
+        expect(sameProjectDirectory("/work/app/", "/work/app")).toBe(true);
+        expect(sameProjectDirectory("/work/tmp/../app", "/work/app")).toBe(true);
+    });
+
+    test("different directories are refused", () => {
+        expect(
+            sameProjectDirectory(
+                "D:/coding/siac/wt/notificaciones-pui",
+                "D:\\coding\\siac\\wt\\migracion-asincrona",
+            ),
+        ).toBe(false);
+        // A sibling whose name extends this one, a parent, and another drive.
+        expect(sameProjectDirectory("C:/Users/dev/app-worktree", "C:\\Users\\dev\\app")).toBe(
+            false,
+        );
+        expect(sameProjectDirectory("C:/Users/dev", "C:\\Users\\dev\\app")).toBe(false);
+        expect(sameProjectDirectory("D:/Users/dev/app", "C:\\Users\\dev\\app")).toBe(false);
+        // POSIX paths are case-sensitive.
+        expect(sameProjectDirectory("/work/App", "/work/app")).toBe(false);
+    });
+
+    test("an empty directory matches nothing, not even the process's working directory", () => {
+        expect(sameProjectDirectory("", process.cwd())).toBe(false);
+        expect(sameProjectDirectory(process.cwd(), "")).toBe(false);
+        expect(sameProjectDirectory("", "")).toBe(false);
+    });
+});

package/src/shared/project-directory-key.ts

@@ -20,6 +20,26 @@ export function projectDirectoryKey(directory: string): string {
     return path.resolve(directory);
 }
 
+/**
+ * Whether two spellings name the same directory, judged by spelling alone.
+ *
+ * Hosts and the plugin do not agree on how to write a directory: OpenCode 2 on
+ * Windows stores a session's directory as `D:/work/app` while the plugin's own
+ * location is `D:\work\app`, and a drive letter can arrive in either case.
+ * Both sides go through `projectDirectoryKey`, so separators, Windows case,
+ * `\\?\` prefixes, trailing separators and `.`/`..` segments cannot make one
+ * directory look like two. POSIX paths keep their case. Symlinks are not
+ * resolved here; callers that must follow them use `canonicalProjectDirectory`.
+ *
+ * An empty spelling never matches anything: `path.resolve("")` is the process's
+ * working directory, and a session with no recorded directory must not be
+ * taken for one in the directory the process happens to run in.
+ */
+export function sameProjectDirectory(a: string, b: string): boolean {
+    if (a.length === 0 || b.length === 0) return false;
+    return projectDirectoryKey(a) === projectDirectoryKey(b);
+}
+
 let realpathForCanonicalDirectory: (directory: string) => string = (directory) =>
     realpathSync.native(directory);
 

package/src/shared/sqlite.test.ts

@@ -1,12 +1,64 @@
 import { describe, expect, it } from "bun:test";
+import { spawnSync } from "node:child_process";
 import {
     Database,
+    detectSqliteRuntime,
     getSqliteMemoryStats,
     loadSqliteModule,
     SqliteRuntimeUnavailableError,
 } from "./sqlite";
 
 describe("SQLite runtime selector", () => {
+    it("suppresses only the node:sqlite experimental warning in a real Node process", () => {
+        // Node 24.21 no longer emits this warning, so inject it during loading
+        // to keep the suppression assertion load-bearing on newer runtimes.
+        const selectorUrl = new URL("./sqlite.ts", import.meta.url).href;
+        const script = `
+            import { loadSqliteModule } from ${JSON.stringify(selectorUrl)};
+            const originalEmitWarning = process.emitWarning;
+            let listenerSawX = false;
+            process.on("warning", (warning) => {
+                if (warning.message === "x") listenerSawX = true;
+            });
+            await loadSqliteModule("Node.js", async (specifier) => {
+                if (specifier !== "node:sqlite") throw new Error("unexpected backend: " + specifier);
+                process.emitWarning("SQLite is an experimental feature and might change at any time", "ExperimentalWarning");
+                process.emitWarning("x", "ExperimentalWarning");
+                return {};
+            });
+            if (process.emitWarning !== originalEmitWarning) throw new Error("emitWarning was not restored");
+            process.emitWarning("after", "ExperimentalWarning");
+            await new Promise((resolve) => setImmediate(resolve));
+            if (!listenerSawX) throw new Error("the original warning listener was not called");
+        `;
+        const child = spawnSync("node", ["--trace-warnings", "--input-type=module", "-e", script], {
+            encoding: "utf8",
+            windowsHide: true,
+        });
+
+        expect(child.error).toBeUndefined();
+        expect(child.status).toBe(0);
+        expect(child.stderr).not.toContain("SQLite is an experimental feature");
+        expect(child.stderr).toContain("ExperimentalWarning: x");
+        expect(child.stderr).toContain("ExperimentalWarning: after");
+        expect(child.stderr).toMatch(/ExperimentalWarning: x[\s\S]*?\n\s+at /);
+    });
+
+    it("leaves Bun and OpenCode warning emission untouched", async () => {
+        expect(detectSqliteRuntime()).toBe("Bun");
+        const originalEmitWarning = process.emitWarning;
+        let requestedSpecifier = "";
+
+        await loadSqliteModule("Bun", async (specifier) => {
+            requestedSpecifier = specifier;
+            expect(process.emitWarning).toBe(originalEmitWarning);
+            return {};
+        });
+
+        expect(requestedSpecifier).toBe("bun:sqlite");
+        expect(process.emitWarning).toBe(originalEmitWarning);
+    });
+
     it("reports live connection PRAGMAs and removes closed handles", () => {
         const before = getSqliteMemoryStats().connectionCount;
         const db = new Database(":memory:");

package/src/shared/sqlite.ts

@@ -41,6 +41,7 @@
 
 import { AsyncLocalStorage } from "node:async_hooks";
 import { statSync } from "node:fs";
+
 // Type import only — runtime is loaded dynamically below. @types/better-sqlite3
 // has the richest definitions and is a structural superset of the API surface
 // we use, so calls typed against BetterSqlite3 work under bun:sqlite and
@@ -169,13 +170,51 @@ export class SqliteRuntimeUnavailableError extends Error {
     }
 }
 
+// Node requests this warning during node:sqlite's module evaluation, although
+// warning delivery happens later. Intercept only the request while importing;
+// replacing warning listeners would not suppress the default stderr output.
+function isNodeSqliteExperimentalWarning(args: unknown[]): boolean {
+    const [warning, options] = args;
+    const message = warning instanceof Error ? warning.message : warning;
+    const type =
+        typeof options === "string"
+            ? options
+            : options && typeof options === "object"
+              ? (options as { type?: unknown }).type
+              : undefined;
+    return (
+        type === "ExperimentalWarning" &&
+        typeof message === "string" &&
+        message.startsWith("SQLite is an experimental feature")
+    );
+}
+
+async function importSqliteModuleForRuntime(
+    runtime: SqliteRuntime,
+    specifier: string,
+    importer: (specifier: string) => Promise<SqliteModule>,
+): Promise<SqliteModule> {
+    if (runtime !== "Node.js") return importer(specifier);
+
+    const originalEmitWarning = process.emitWarning;
+    process.emitWarning = function (this: unknown, ...args: unknown[]): void {
+        if (isNodeSqliteExperimentalWarning(args)) return;
+        Reflect.apply(originalEmitWarning, this, args);
+    } as typeof process.emitWarning;
+    try {
+        return await importer(specifier);
+    } finally {
+        process.emitWarning = originalEmitWarning;
+    }
+}
+
 export async function loadSqliteModule(
     runtime: SqliteRuntime = detectSqliteRuntime(),
     importer: (specifier: string) => Promise<SqliteModule> = importSqliteModule,
 ): Promise<SqliteModule> {
     const specifier = runtime === "Bun" ? bunSpec : nodeSpec;
     try {
-        return await importer(specifier);
+        return await importSqliteModuleForRuntime(runtime, specifier, importer);
     } catch (error) {
         if (isModuleNotFoundError(error, specifier)) {
             throw new SqliteRuntimeUnavailableError(runtime, specifier, error);
@@ -234,6 +273,110 @@ export interface SqliteMemoryStats {
 const trackedSqliteConnections = new Map<number, TrackedSqliteConnection>();
 let nextSqliteConnectionSequence = 1;
 
+/**
+ * Columns of Magic Context's `tags` table (context.db) that never decide which
+ * message a tag belongs to, its number, its type, or its reasoning token estimate.
+ */
+const TAG_COLUMNS_OUTSIDE_IDENTITY = new Set([
+    "status",
+    "drop_mode",
+    "byte_size",
+    "input_byte_size",
+    "reasoning_byte_size",
+    "token_count",
+    "input_token_count",
+    "caveman_depth",
+    "entry_fingerprint",
+    "tool_name",
+    "harness",
+]);
+
+let tagIdentityWriteGeneration = 0;
+
+/**
+ * Whether a write statement may change an existing `tags` row's identity
+ * (session, number, type, owner message, reasoning token count) or remove a
+ * row. Plain appends without an explicit `id`, and updates that assign only
+ * columns in {@link TAG_COLUMNS_OUTSIDE_IDENTITY}, cannot; everything else that
+ * names the table is treated as if it could, including DDL and multi-statement
+ * scripts. Erring towards true only costs a cache rebuild.
+ */
+export function mayChangeTagIdentity(sql: string): boolean {
+    if (!/\btags\b/i.test(sql) || /^\s*(?:SELECT|EXPLAIN|PRAGMA)\b/i.test(sql)) return false;
+    if (/^\s*WITH\b/i.test(sql) && !/\b(?:INSERT|UPDATE|DELETE|REPLACE)\b/i.test(sql)) return false;
+    // One statement only: a script can hide a DELETE behind a harmless first statement.
+    if (/;\s*\S/.test(sql) || /\bREPLACE\b/i.test(sql) || /\bON\s+CONFLICT\b/i.test(sql))
+        return true;
+    const insert = /^\s*INSERT\s+INTO\s+(?:main\.)?["`]?tags["`]?\s*\(([^)]*)\)/i.exec(sql);
+    if (insert) {
+        const columns = (insert[1] ?? "").split(",").map((column) =>
+            column
+                .trim()
+                .replace(/["`[\]]/g, "")
+                .toLowerCase(),
+        );
+        return columns.includes("id") || columns.includes("rowid");
+    }
+    const update = /^\s*UPDATE\s+(?:main\.)?["`]?tags["`]?\s+SET\s+([\s\S]*?)\bWHERE\b/i.exec(sql);
+    if (update && !/\bSELECT\b/i.test(sql)) {
+        // Provably identity-free only when every top-level assignment is a plain
+        // `column = ...` naming an allowed column. A tuple assignment such as
+        // `(tag_number, reasoning_token_count) = (...)`, or anything this cannot
+        // read, counts as an identity write.
+        const assignments = topLevelCommaSegments(update[1] ?? "");
+        if (!assignments) return true;
+        return !assignments.every((assignment) => {
+            const column = /^\s*["`]?(\w+)["`]?\s*=(?!=)/.exec(assignment)?.[1];
+            return column !== undefined && TAG_COLUMNS_OUTSIDE_IDENTITY.has(column.toLowerCase());
+        });
+    }
+    return true;
+}
+
+/**
+ * Split SQL text at commas outside parentheses and quotes. Returns null when
+ * the parentheses or quotes do not balance.
+ */
+function topLevelCommaSegments(text: string): string[] | null {
+    const segments: string[] = [];
+    let depth = 0;
+    let quote: string | null = null;
+    let start = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (quote) {
+            // A doubled quote inside a quoted run is an escaped quote.
+            if (char === quote) {
+                if (text[index + 1] === quote) index += 1;
+                else quote = null;
+            }
+            continue;
+        }
+        if (char === "'" || char === '"' || char === "`") quote = char;
+        else if (char === "(") depth += 1;
+        else if (char === ")") {
+            depth -= 1;
+            if (depth < 0) return null;
+        } else if (char === "," && depth === 0) {
+            segments.push(text.slice(start, index));
+            start = index + 1;
+        }
+    }
+    if (quote || depth !== 0) return null;
+    segments.push(text.slice(start));
+    return segments;
+}
+
+/**
+ * Counts executions, on any connection this process opened, of statements for
+ * which {@link mayChangeTagIdentity} is true. A cache built from `tags` stays
+ * valid for this process's own writes while the count is unchanged; commits by
+ * other connections show up in `PRAGMA data_version` instead.
+ */
+export function getTagIdentityWriteGeneration(): number {
+    return tagIdentityWriteGeneration;
+}
+
 /** Route native Bun and Node transaction entry through the same acquisition retry.
  * Native Bun transaction wrappers execute BEGIN internally, bypassing an exec override,
  * so both runtimes use this small synchronous wrapper instead. Writable handles
@@ -257,8 +400,15 @@ function installTransactionRouting(db: BetterSqlite3.Database, readonly: boolean
             }
             if (WRITER_TRANSACTION_END.test(sql) && openWriterTransactions.has(db))
                 return endWriterTransaction(db, () => nativeExec(sql), sql);
-            if (!/^\s*(?:SELECT|EXPLAIN|PRAGMA|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(sql))
-                return withAutocommitTimeout(db, () => nativeExec(sql));
+            if (
+                !/^\s*(?:SELECT|EXPLAIN|PRAGMA|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(sql)
+            ) {
+                try {
+                    return withAutocommitTimeout(db, () => nativeExec(sql));
+                } finally {
+                    if (mayChangeTagIdentity(sql)) tagIdentityWriteGeneration += 1;
+                }
+            }
             return nativeExec(sql);
         },
     });
@@ -271,15 +421,22 @@ function installTransactionRouting(db: BetterSqlite3.Database, readonly: boolean
             // SELECT/EXPLAIN cannot acquire a writer. Treat CTEs conservatively:
             // WITH can introduce INSERT/UPDATE/DELETE as well as a read query.
             if (!readonly && !/^\s*(?:SELECT|EXPLAIN|PRAGMA)\b/i.test(sql)) {
+                const changesTagIdentity = mayChangeTagIdentity(sql);
                 for (const method of ["run", "get", "all"] as const) {
                     const execute = statement[method].bind(statement);
                     Object.defineProperty(statement, method, {
                         configurable: true,
                         // biome-ignore lint/suspicious/noExplicitAny: retain SQLite's native binding overloads.
-                        value: (...args: any[]) =>
-                            withAutocommitTimeout(db, () => execute(...args)),
+                        value: (...args: any[]) => {
+                            try {
+                                return withAutocommitTimeout(db, () => execute(...args));
+                            } finally {
+                                if (changesTagIdentity) tagIdentityWriteGeneration += 1;
+                            }
+                        },
                     });
                 }
+                if (changesTagIdentity) wrapRemainingTagWriteForms(statement);
             }
             return statement;
         },
@@ -330,6 +487,43 @@ function installTransactionRouting(db: BetterSqlite3.Database, readonly: boolean
     });
 }
 
+/**
+ * Count tag identity writes made through the statement forms the transaction
+ * routing does not wrap. `iterate()` runs the statement while its result is
+ * consumed, so the generation moves both when iteration starts and when it
+ * ends: a summary read in between is then rebuilt on its next read.
+ */
+// biome-ignore lint/suspicious/noExplicitAny: statements from both backends share these method names.
+function wrapRemainingTagWriteForms(statement: any): void {
+    if (typeof statement.iterate === "function") {
+        const iterate = statement.iterate.bind(statement);
+        Object.defineProperty(statement, "iterate", {
+            configurable: true,
+            value: function* (...args: unknown[]) {
+                tagIdentityWriteGeneration += 1;
+                try {
+                    yield* iterate(...args);
+                } finally {
+                    tagIdentityWriteGeneration += 1;
+                }
+            },
+        });
+    }
+    if (typeof statement.values === "function") {
+        const values = statement.values.bind(statement);
+        Object.defineProperty(statement, "values", {
+            configurable: true,
+            value: (...args: unknown[]) => {
+                try {
+                    return values(...args);
+                } finally {
+                    tagIdentityWriteGeneration += 1;
+                }
+            },
+        });
+    }
+}
+
 function trackSqliteConnection(
     db: BetterSqlite3.Database,
     filename: unknown,
@@ -440,6 +634,11 @@ export function getSqliteDatabasePath(db: Database): string | null {
                 : connection.filename;
         }
     }
+    // Native Bun/better-sqlite3 handles can reach readers without our constructor
+    // wrapper. Their filename is still available without a SQLite query.
+    const native = db as unknown as { filename?: unknown; name?: unknown };
+    const path = native.filename ?? native.name;
+    if (typeof path === "string" && path !== ":memory:" && path !== "") return path;
     return null;
 }
 
@@ -569,6 +768,33 @@ interface StatementOwner {
 const statementOwners = new WeakMap<Database, StatementOwner>();
 const FIRST_PRUNE_AT = 256;
 
+/**
+ * Bun's default close (`sqlite3_close_v2`) only releases the native connection
+ * once every statement created by prepare() is finalized. The close override
+ * in ownPreparedStatement can finalize only statements that are still
+ * reachable. Once the garbage collector
+ * has marked a one-shot statement dead, its weak reference is already cleared,
+ * but the statement is finalized only when its memory is later swept. Until
+ * then the closed connection keeps the database, WAL and shared-memory files
+ * open, for an unbounded time.
+ *
+ * `close(true)` finalizes every outstanding statement, reachable or not, and
+ * releases the connection immediately. When the caller did not ask for errors
+ * and that close fails, fall back to the caller's own close so a teardown path
+ * never starts throwing; the fallback can defer the release as before.
+ */
+function closeReleasingStatements(
+    close: (...args: unknown[]) => unknown,
+    args: unknown[],
+): unknown {
+    if (args[0] === true) return close(true);
+    try {
+        return close(true);
+    } catch {
+        return close(...args);
+    }
+}
+
 function ownPreparedStatement(db: Database, statement: Statement): Statement {
     const finalizable = statement as FinalizableStatement;
     // Node finalizes its statements on close and exposes no finalize() method.
@@ -592,7 +818,7 @@ function ownPreparedStatement(db: Database, statement: Statement): Statement {
                     }
                 }
                 references.clear();
-                const result = close(...args);
+                const result = closeReleasingStatements(close, args);
                 if (failure) throw failure;
                 return result;
             },
@@ -650,22 +876,31 @@ export function withSqliteBackgroundWriter<T>(operation: () => T): T {
 export function withSqliteTransformPass<T>(operation: () => T): T {
     const existing = transformPassScope.getStore();
     if (existing?.active) return operation();
-    const lease = { active: true, remainingWaitMs: FOREGROUND_IN_PASS_BUSY_TIMEOUT_MS };
-    return transformPassScope.run(lease, () => {
-        try {
-            const result = operation();
-            if (result && typeof (result as { then?: unknown }).then === "function") {
-                return Promise.resolve(result).finally(() => {
-                    lease.active = false;
-                }) as T;
+    const reservation = reserveForegroundSqliteTurn();
+    const run = (release: () => void): T => {
+        const lease = { active: true, remainingWaitMs: FOREGROUND_IN_PASS_BUSY_TIMEOUT_MS };
+        return transformPassScope.run(lease, () => {
+            try {
+                const result = operation();
+                if (result && typeof (result as { then?: unknown }).then === "function") {
+                    return Promise.resolve(result).finally(() => {
+                        lease.active = false;
+                        release();
+                    }) as T;
+                }
+                lease.active = false;
+                release();
+                return result;
+            } catch (error) {
+                lease.active = false;
+                release();
+                throw error;
             }
-            lease.active = false;
-            return result;
-        } catch (error) {
-            lease.active = false;
-            throw error;
-        }
-    });
+        });
+    };
+    // Foreground callers racing maintenance are awaited transforms. Idle
+    // synchronous callers keep the existing immediate return/throw behavior.
+    return typeof reservation === "function" ? run(reservation) : (reservation.then(run) as T);
 }
 
 /** Start detached maintenance work without borrowing a foreground pass's budget. */
@@ -836,16 +1071,20 @@ function acquireShort(db: Database, acquire: () => unknown, site: string): void
  * `acquireShort`, then report how long the writer waited for the lock
  * (`acquire_ms`) and how long it then held it (`hold_ms`) when either crosses
  * the threshold. A long hold blocks every other process's writer, so it is
- * worth seeing even when the lock itself came quickly.
+ * worth seeing even when the lock itself came quickly. The native end statement's
+ * `end_ms` is reported separately, so a slow FTS merge or checkpoint at COMMIT
+ * is not mistaken for acquisition time.
  */
 function endWriterTransaction(db: Database, end: () => unknown, sql: string): unknown {
     let ended = false;
+    const endStarted = performance.now();
     try {
         const result = end();
         ended = true;
         return result;
     } finally {
         const open = openWriterTransactions.get(db);
+        const endMs = performance.now() - endStarted;
         // A COMMIT that failed with the transaction still open has not ended it.
         if (open && !isInTransaction(db)) {
             openWriterTransactions.delete(db);
@@ -857,7 +1096,7 @@ function endWriterTransaction(db: Database, end: () => unknown, sql: string): un
                       ? "committed"
                       : "failed";
                 reportSqliteDiagnostic(
-                    `sqlite writer site=${open.site} lane=${open.lane} acquire_ms=${Math.round(open.acquireMs)} hold_ms=${Math.round(holdMs)} attempts=${open.attempts} outcome=${outcome}`,
+                    `sqlite writer site=${open.site} lane=${open.lane} acquire_ms=${Math.round(open.acquireMs)} hold_ms=${Math.round(holdMs)} end_ms=${Math.round(endMs)} attempts=${open.attempts} outcome=${outcome}`,
                 );
             }
         }
@@ -1056,3 +1295,80 @@ export function withPrivilegedWriter<T>(db: Database, operation: () => T): T {
         throw error;
     }
 }
+
+// Process-local admission only; SQLite remains the cross-process writer arbiter.
+const indexCoordinationKey = Symbol.for("magic-context.index-foreground-coordination.v1");
+const indexCoordinationHeap = globalThis as unknown as Record<
+    symbol,
+    SharedArrayBuffer | undefined
+>;
+const indexCoordinationBuffer =
+    indexCoordinationHeap[indexCoordinationKey] ??
+    new SharedArrayBuffer(3 * Int32Array.BYTES_PER_ELEMENT);
+indexCoordinationHeap[indexCoordinationKey] = indexCoordinationBuffer;
+const indexCoordinationState = new Int32Array(indexCoordinationBuffer);
+// Slots: foreground interest, current maintenance owner, next owner token.
+
+export function indexCoordinationInput(): {
+    indexCoordination: SharedArrayBuffer;
+    indexOwner: number;
+} {
+    return {
+        indexCoordination: indexCoordinationBuffer,
+        indexOwner: Atomics.add(indexCoordinationState, 2, 1) + 1,
+    };
+}
+
+const yieldIndexTurn = () => new Promise<void>((resolve) => setTimeout(resolve, 1));
+
+/** Announce interest before waiting, so no maintenance chunk overtakes a foreground turn. */
+function reserveForegroundSqliteTurn(): (() => void) | Promise<() => void> {
+    Atomics.add(indexCoordinationState, 0, 1);
+    const release = () => {
+        Atomics.sub(indexCoordinationState, 0, 1);
+        Atomics.notify(indexCoordinationState, 0);
+    };
+    if (Atomics.load(indexCoordinationState, 1) === 0) return release;
+    return (async () => {
+        while (Atomics.load(indexCoordinationState, 1) !== 0) await yieldIndexTurn();
+        return release;
+    })();
+}
+
+export function releaseIndexOwner(input: {
+    indexCoordination?: SharedArrayBuffer;
+    indexOwner?: number;
+}): void {
+    if (!input.indexCoordination || !input.indexOwner) return;
+    const shared = new Int32Array(input.indexCoordination);
+    Atomics.compareExchange(shared, 1, input.indexOwner, 0);
+    Atomics.notify(shared, 1);
+}
+
+/** One synchronous transaction per permit; release the permit before yielding. */
+export async function withIndexChunk<T>(
+    input: { indexCoordination?: SharedArrayBuffer; indexOwner?: number },
+    operation: () => T,
+): Promise<T> {
+    if (!input.indexCoordination || !input.indexOwner) return operation();
+    const shared = new Int32Array(input.indexCoordination);
+    for (;;) {
+        if (
+            Atomics.load(shared, 0) === 0 &&
+            Atomics.compareExchange(shared, 1, 0, input.indexOwner) === 0
+        ) {
+            if (Atomics.load(shared, 0) === 0) break;
+            releaseIndexOwner(input);
+        }
+        await yieldIndexTurn();
+    }
+    try {
+        return await operation();
+    } finally {
+        releaseIndexOwner(input);
+    }
+}
+
+export async function yieldIndexChunk(): Promise<void> {
+    await yieldIndexTurn();
+}