@astrosheep/keiyaku 2.9.12 → 2.9.13

package/build/core/projection/projection-runner-lock.js

@@ -1,211 +0,0 @@
-import * as path from "node:path";
-import { initializeSqliteProcessLifetimeLockDatabase, isSqliteProcessLifetimeLockContention, isSqliteProcessLifetimeLockPlatformSupported, openSqliteProcessLifetimeLockTransaction, SqliteProcessLifetimeLockError, sqliteProcessLifetimeLockErrorDetail, } from "../sqlite-process-lifetime-lock.js";
-export const PROJECTION_RUNNER_LOCK_DATABASE = "leash";
-export class ProjectionRunnerLockUnavailableError extends Error {
-    code = "PROJECTION_RUNNER_LOCK_UNAVAILABLE";
-    constructor(message, options) {
-        super(message, options);
-        this.name = "ProjectionRunnerLockUnavailableError";
-    }
-}
-export class ProjectionRunnerLockUnsupportedError extends Error {
-    code = "PROJECTION_RUNNER_LOCK_UNSUPPORTED";
-    constructor(platform) {
-        super(`projection runner locks are unsupported on platform '${platform}'`);
-        this.name = "ProjectionRunnerLockUnsupportedError";
-    }
-}
-export function projectionRunnerLockPath(projectionDirectory) {
-    return path.join(projectionDirectory, PROJECTION_RUNNER_LOCK_DATABASE);
-}
-export function isProjectionRunnerLockPlatformSupported(platform = process.platform) {
-    return isSqliteProcessLifetimeLockPlatformSupported(platform);
-}
-function errorDetail(error) {
-    return sqliteProcessLifetimeLockErrorDetail(error);
-}
-function isContention(error) {
-    return isSqliteProcessLifetimeLockContention(error)
-        || (error instanceof SqliteProcessLifetimeLockError && error.reason === "busy");
-}
-function openGuard(lockPath, busyTimeoutMs) {
-    return openSqliteProcessLifetimeLockTransaction({ path: lockPath, mode: "deferred", busyTimeoutMs });
-}
-function openReservation(lockPath, busyTimeoutMs) {
-    return openSqliteProcessLifetimeLockTransaction({ path: lockPath, mode: "immediate", busyTimeoutMs });
-}
-function closeTransaction(transaction) {
-    try {
-        transaction.close();
-    }
-    catch (error) {
-        return error;
-    }
-}
-function createHeldLock(lockPath, busyTimeoutMs, guard, initialReservation) {
-    let closed = false;
-    let reservation = initialReservation;
-    return {
-        path: lockPath,
-        releaseReservationForTransfer() {
-            if (closed || reservation === undefined)
-                return;
-            const released = reservation;
-            reservation = undefined;
-            const failure = closeTransaction(released);
-            if (failure !== undefined)
-                throw new ProjectionRunnerLockUnavailableError(`projection runner reservation release failed: ${errorDetail(failure)}`, { cause: failure });
-        },
-        reclaimReservation() {
-            if (closed || reservation !== undefined)
-                return;
-            try {
-                reservation = openReservation(lockPath, busyTimeoutMs);
-            }
-            catch (error) {
-                throw new ProjectionRunnerLockUnavailableError(`projection runner reservation reclaim failed: ${errorDetail(error)}`, { cause: error });
-            }
-        },
-        close() {
-            if (closed)
-                return;
-            closed = true;
-            let failure;
-            if (reservation !== undefined)
-                failure = closeTransaction(reservation);
-            failure ??= closeTransaction(guard);
-            if (failure !== undefined)
-                throw new ProjectionRunnerLockUnavailableError(`projection runner lock release failed: ${errorDetail(failure)}`, { cause: failure });
-        },
-    };
-}
-function unavailable(operation, error) {
-    return new ProjectionRunnerLockUnavailableError(`${operation}: ${errorDetail(error)}`, { cause: error });
-}
-/** Mint-time schema initialization retains no process-life authority. */
-export function initializeProjectionRunnerLockDatabase(projectionDirectory, platform = process.platform) {
-    if (!isProjectionRunnerLockPlatformSupported(platform))
-        throw new ProjectionRunnerLockUnsupportedError(platform);
-    try {
-        return initializeSqliteProcessLifetimeLockDatabase(projectionRunnerLockPath(projectionDirectory), platform);
-    }
-    catch (error) {
-        throw unavailable("projection runner lock database could not be initialized", error);
-    }
-}
-/**
- * Projection policy: hold a SHARED guard plus a RESERVED claim. The transfer
- * target overlaps its guard before the reservation moves, preserving exclusion.
- */
-export function acquireProjectionRunnerLock(projectionDirectory, platform = process.platform, busyTimeoutMs = 0) {
-    if (!isProjectionRunnerLockPlatformSupported(platform))
-        throw new ProjectionRunnerLockUnsupportedError(platform);
-    const lockPath = projectionRunnerLockPath(projectionDirectory);
-    let guard;
-    try {
-        guard = openGuard(lockPath, busyTimeoutMs);
-    }
-    catch (error) {
-        throw unavailable("projection runner lock database could not be opened", error);
-    }
-    try {
-        return createHeldLock(lockPath, busyTimeoutMs, guard, openReservation(lockPath, busyTimeoutMs));
-    }
-    catch (error) {
-        closeTransaction(guard);
-        if (isContention(error))
-            throw new ProjectionRunnerLockUnavailableError("projection runner lock is already held", { cause: error });
-        throw unavailable("projection runner lock acquisition failed", error);
-    }
-}
-export function acquireProjectionRunnerTransferTarget(projectionDirectory, platform = process.platform, busyTimeoutMs = 0) {
-    if (!isProjectionRunnerLockPlatformSupported(platform))
-        throw new ProjectionRunnerLockUnsupportedError(platform);
-    const lockPath = projectionRunnerLockPath(projectionDirectory);
-    let guard;
-    try {
-        guard = openGuard(lockPath, busyTimeoutMs);
-    }
-    catch (error) {
-        throw unavailable("projection runner transfer acquisition failed", error);
-    }
-    let closed = false;
-    return {
-        path: lockPath,
-        promote() {
-            if (closed)
-                throw new ProjectionRunnerLockUnavailableError("projection runner transfer target is closed");
-            try {
-                const reservation = openReservation(lockPath, busyTimeoutMs);
-                closed = true;
-                return createHeldLock(lockPath, busyTimeoutMs, guard, reservation);
-            }
-            catch (error) {
-                throw unavailable("projection runner transfer promotion failed", error);
-            }
-        },
-        close() {
-            if (closed)
-                return;
-            closed = true;
-            const failure = closeTransaction(guard);
-            if (failure !== undefined)
-                throw unavailable("projection runner transfer release failed", failure);
-        },
-    };
-}
-/** Acquire positive death evidence. An active guard or transfer blocks this. */
-export function acquireProjectionRunnerSettlementLock(projectionDirectory, platform = process.platform, busyTimeoutMs = 0) {
-    if (!isProjectionRunnerLockPlatformSupported(platform))
-        throw new ProjectionRunnerLockUnsupportedError(platform);
-    const lockPath = projectionRunnerLockPath(projectionDirectory);
-    let transaction;
-    try {
-        transaction = openSqliteProcessLifetimeLockTransaction({ path: lockPath, mode: "exclusive", busyTimeoutMs });
-    }
-    catch (error) {
-        if (isContention(error))
-            throw new ProjectionRunnerLockUnavailableError("projection runner lock is already held", { cause: error });
-        throw unavailable("projection runner settlement lock acquisition failed", error);
-    }
-    let closed = false;
-    return {
-        path: lockPath,
-        close() {
-            if (closed)
-                return;
-            closed = true;
-            const failure = closeTransaction(transaction);
-            if (failure !== undefined)
-                throw unavailable("projection runner settlement lock release failed", failure);
-        },
-    };
-}
-/** Positive death probe without creating a missing lock database. */
-export function observeProjectionRunnerLock(projectionDirectory, platform = process.platform) {
-    if (!isProjectionRunnerLockPlatformSupported(platform)) {
-        return { state: "unknown", reason: "unsupported-platform", detail: `projection runner locks are unsupported on platform '${platform}'` };
-    }
-    const lockPath = projectionRunnerLockPath(projectionDirectory);
-    let probe;
-    try {
-        probe = openSqliteProcessLifetimeLockTransaction({ path: lockPath, mode: "exclusive", busyTimeoutMs: 0 });
-        return { state: "released" };
-    }
-    catch (error) {
-        if (isContention(error))
-            return { state: "held" };
-        const detail = errorDetail(error);
-        return {
-            state: "unknown",
-            reason: detail.includes("rollback-journal") ? "unsupported-journal-mode" : "probe-failed",
-            detail,
-        };
-    }
-    finally {
-        try {
-            probe?.close();
-        }
-        catch { /* no probe cleanup result is death evidence */ }
-    }
-}

package/build/core/projection/tell/database.js

@@ -1,127 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import { ProjectionStateError } from "../../atomic-publish.js";
-import { PROJECTION_GENERATION_STORE_FILE, } from "../generation/store.js";
-import { configureHeartBusyTimeout } from "../heart.js";
-function databasePath(projectionDirectory) {
-    return path.join(projectionDirectory, PROJECTION_GENERATION_STORE_FILE);
-}
-function openDatabase(projectionDirectory, readOnly) {
-    const target = databasePath(projectionDirectory);
-    if (!fs.lstatSync(target).isFile()) {
-        throw new ProjectionStateError("projection heart must be a regular file");
-    }
-    const database = new DatabaseSync(target, {
-        readOnly,
-        enableForeignKeyConstraints: true,
-        enableDoubleQuotedStringLiterals: false,
-        allowExtension: false,
-    });
-    configureHeartBusyTimeout(database);
-    if (!readOnly) {
-        database.exec("PRAGMA foreign_keys = ON");
-        database.exec("PRAGMA trusted_schema = OFF");
-    }
-    return database;
-}
-function rollbackQuietly(database) {
-    try {
-        database.exec("ROLLBACK");
-    }
-    catch {
-        // Preserve the transition failure.
-    }
-}
-export function withRead(projectionDirectory, read) {
-    const database = openDatabase(projectionDirectory, true);
-    try {
-        return read(database);
-    }
-    finally {
-        database.close();
-    }
-}
-export function withReadSnapshot(projectionDirectory, read) {
-    const database = openDatabase(projectionDirectory, true);
-    try {
-        database.exec("BEGIN");
-        try {
-            const result = read(database);
-            database.exec("COMMIT");
-            return result;
-        }
-        catch (error) {
-            rollbackQuietly(database);
-            throw error;
-        }
-    }
-    finally {
-        database.close();
-    }
-}
-export function withWrite(projectionDirectory, write) {
-    const database = openDatabase(projectionDirectory, false);
-    try {
-        database.exec("BEGIN IMMEDIATE");
-        try {
-            const result = write(database);
-            database.exec("COMMIT");
-            return result;
-        }
-        catch (error) {
-            rollbackQuietly(database);
-            throw error;
-        }
-    }
-    finally {
-        database.close();
-    }
-}
-export function openProjectionTellObserver(projectionDirectory) {
-    const database = openDatabase(projectionDirectory, true);
-    let closed = false;
-    let observedDataVersion;
-    const assertOpen = () => {
-        if (closed)
-            throw new ProjectionStateError("projection tell observer is closed");
-    };
-    const readDataVersion = () => {
-        assertOpen();
-        const row = database.prepare("PRAGMA data_version").get();
-        const raw = row?.data_version;
-        const value = typeof raw === "bigint" ? Number(raw) : raw;
-        if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
-            throw new ProjectionStateError("PRAGMA data_version returned an invalid value");
-        }
-        return value;
-    };
-    return {
-        hasDataVersionChanged() {
-            const current = readDataVersion();
-            if (observedDataVersion === undefined) {
-                observedDataVersion = current;
-                return true;
-            }
-            if (current === observedDataVersion)
-                return false;
-            observedDataVersion = current;
-            return true;
-        },
-        hasInbox() {
-            assertOpen();
-            return database.prepare(`
-        SELECT 1
-        FROM projection_tells
-        WHERE state = 'inbox'
-        LIMIT 1
-      `).get() !== undefined;
-        },
-        close() {
-            if (closed)
-                return;
-            closed = true;
-            database.close();
-        },
-    };
-}

package/build/core/settlement/verification-coordination.js

@@ -1,305 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import { z } from "zod";
-const COORDINATION_SCHEMA_VERSION = 1;
-const MAX_RECEIPT_BYTES = 1_048_576;
-const DATABASE_BUSY_TIMEOUT_MS = 5_000;
-export const VERIFICATION_COMPLETED_RECEIPT_LIMIT = 8;
-const outputTailSchema = z.object({
-    tail: z.string(),
-    truncated: z.boolean(),
-    omittedBytes: z.number().int().nonnegative(),
-}).strict();
-const executionSchema = z.discriminatedUnion("status", [
-    z.object({
-        status: z.literal("executed"),
-        code: z.number().int(),
-        durationMs: z.number().nonnegative(),
-        stdout: outputTailSchema,
-        stderr: outputTailSchema,
-    }).strict(),
-    z.object({
-        status: z.literal("runner_failed"),
-        durationMs: z.number().nonnegative(),
-        stdout: outputTailSchema,
-        stderr: outputTailSchema,
-        cause: z.object({
-            code: z.enum(["SPAWN_FAILED", "PROCESS_TERMINATED", "TIMED_OUT", "CANCELLED", "TREE_TERMINATION_FAILED"]),
-            message: z.string(),
-        }).strict(),
-    }).strict(),
-]);
-const resultSchema = z.object({
-    source: z.enum(["contract", "repository-gate"]),
-    label: z.string(),
-    declaration: z.string(),
-    command: z.string(),
-    args: z.array(z.string()),
-    shell: z.boolean(),
-    timeoutMs: z.number().int().positive(),
-    candidate: z.object({ head: z.string(), tree: z.string() }).strict(),
-    executor: z.string(),
-    execution: executionSchema,
-}).strict();
-const receiptSchema = z.object({
-    version: z.literal(COORDINATION_SCHEMA_VERSION),
-    results: z.array(resultSchema),
-}).strict();
-function processIsLive(pid) {
-    if (pid <= 0)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        return !(error && typeof error === "object" && "code" in error && error.code === "ESRCH");
-    }
-}
-function rollbackQuietly(database) {
-    try {
-        database.exec("ROLLBACK");
-    }
-    catch { }
-}
-function pragmaNumber(database, name) {
-    const row = database.prepare(`PRAGMA ${name}`).get();
-    const value = row ? Object.values(row)[0] : undefined;
-    if (typeof value !== "number" && typeof value !== "bigint") {
-        throw new Error(`verification coordination PRAGMA ${name} is invalid`);
-    }
-    return Number(value);
-}
-function initializeOrValidate(database) {
-    database.exec("BEGIN EXCLUSIVE");
-    try {
-        const version = pragmaNumber(database, "user_version");
-        const objects = database.prepare(`
-      SELECT name, type FROM sqlite_schema
-      WHERE name NOT LIKE 'sqlite_%' ORDER BY name
-    `).all();
-        if (version === 0 && objects.length === 0) {
-            database.exec(`
-        CREATE TABLE verification_coordination_schema (
-          singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
-          version INTEGER NOT NULL CHECK (version = ${COORDINATION_SCHEMA_VERSION})
-        ) STRICT;
-        CREATE TABLE verification_executions (
-          fingerprint TEXT PRIMARY KEY CHECK (length(fingerprint) = 64),
-          owner_token TEXT NOT NULL CHECK (length(owner_token) > 0),
-          owner_pid INTEGER NOT NULL CHECK (owner_pid >= 0),
-          started_at_ms INTEGER NOT NULL CHECK (started_at_ms >= 0),
-          supervisor_pid INTEGER CHECK (supervisor_pid IS NULL OR supervisor_pid > 0),
-          supervisor_platform TEXT CHECK (supervisor_platform IS NULL OR supervisor_platform IN ('posix', 'win32')),
-          completed_at_ms INTEGER CHECK (completed_at_ms IS NULL OR completed_at_ms >= 0),
-          receipt_json TEXT CHECK (receipt_json IS NULL OR json_valid(receipt_json)),
-          CHECK ((supervisor_pid IS NULL) = (supervisor_platform IS NULL)),
-          CHECK ((receipt_json IS NULL) = (completed_at_ms IS NULL)),
-          CHECK (receipt_json IS NULL OR (owner_pid = 0 AND supervisor_pid IS NULL))
-        ) STRICT;
-      `);
-            database.prepare("INSERT INTO verification_coordination_schema (singleton, version) VALUES (1, ?)")
-                .run(COORDINATION_SCHEMA_VERSION);
-            database.exec(`PRAGMA user_version = ${COORDINATION_SCHEMA_VERSION}`);
-        }
-        else if (version !== COORDINATION_SCHEMA_VERSION) {
-            throw new Error(`incompatible verification coordination schema version ${version}; expected ${COORDINATION_SCHEMA_VERSION}`);
-        }
-        const signature = database.prepare(`
-      SELECT name, type FROM sqlite_schema
-      WHERE name NOT LIKE 'sqlite_%' ORDER BY name
-    `).all().map((object) => {
-            const row = object;
-            return `${row.type}:${row.name}`;
-        }).join(",");
-        if (signature !== "table:verification_coordination_schema,table:verification_executions") {
-            throw new Error(`verification coordination schema contains unexpected objects: ${signature || "none"}`);
-        }
-        const columns = database.prepare("PRAGMA table_info(verification_executions)").all();
-        const columnSignature = columns
-            .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
-            .join(",");
-        if (columnSignature !== "fingerprint:TEXT:1:1,owner_token:TEXT:1:0,owner_pid:INTEGER:1:0,started_at_ms:INTEGER:1:0,supervisor_pid:INTEGER:0:0,supervisor_platform:TEXT:0:0,completed_at_ms:INTEGER:0:0,receipt_json:TEXT:0:0") {
-            throw new Error("verification coordination execution schema is malformed");
-        }
-        const metadata = database.prepare("SELECT singleton, version FROM verification_coordination_schema").all();
-        if (metadata.length !== 1 || Number(metadata[0].singleton) !== 1 || Number(metadata[0].version) !== COORDINATION_SCHEMA_VERSION) {
-            throw new Error("verification coordination schema metadata is malformed");
-        }
-        const quickCheck = database.prepare("PRAGMA quick_check").get();
-        if (!quickCheck || Object.values(quickCheck)[0] !== "ok") {
-            throw new Error("verification coordination database failed quick_check");
-        }
-        database.exec("COMMIT");
-    }
-    catch (error) {
-        rollbackQuietly(database);
-        throw error;
-    }
-}
-function parseReceipt(raw) {
-    if (Buffer.byteLength(raw) > MAX_RECEIPT_BYTES)
-        throw new Error("verification receipt exceeds its size bound");
-    return receiptSchema.parse(JSON.parse(raw)).results;
-}
-function serializeReceipt(results) {
-    const raw = JSON.stringify(receiptSchema.parse({ version: COORDINATION_SCHEMA_VERSION, results }));
-    if (Buffer.byteLength(raw) > MAX_RECEIPT_BYTES)
-        throw new Error("verification receipt exceeds its size bound");
-    return raw;
-}
-export class VerificationCoordination {
-    #databasePath;
-    constructor(repositoryRoot) {
-        const directory = path.join(repositoryRoot, ".keiyaku", "runtime");
-        fs.mkdirSync(directory, { recursive: true });
-        this.#databasePath = path.join(directory, "verification.sqlite");
-        this.#withDatabase(() => undefined);
-    }
-    fingerprint(key) {
-        return createHash("sha256").update(key).digest("hex");
-    }
-    claim(fingerprint, staleAfterMs, nowMs = Date.now()) {
-        return this.#withTransaction((database) => {
-            const row = database.prepare(`
-        SELECT owner_token, owner_pid, started_at_ms, supervisor_pid, supervisor_platform, completed_at_ms, receipt_json
-        FROM verification_executions WHERE fingerprint = ?
-      `).get(fingerprint);
-            if (row?.receipt_json !== null && row?.receipt_json !== undefined) {
-                return { status: "receipt", results: parseReceipt(row.receipt_json) };
-            }
-            const token = randomUUID();
-            if (!row) {
-                database.prepare(`
-          INSERT INTO verification_executions
-            (fingerprint, owner_token, owner_pid, started_at_ms, supervisor_pid, supervisor_platform, completed_at_ms, receipt_json)
-          VALUES (?, ?, ?, ?, NULL, NULL, NULL, NULL)
-        `).run(fingerprint, token, process.pid, nowMs);
-                return { status: "owner", token };
-            }
-            const ownerPid = Number(row.owner_pid);
-            const stale = nowMs - Number(row.started_at_ms) > staleAfterMs;
-            if (processIsLive(ownerPid) && !stale)
-                return { status: "wait" };
-            database.prepare(`
-        UPDATE verification_executions
-        SET owner_token = ?, owner_pid = ?, started_at_ms = ?
-        WHERE fingerprint = ?
-      `).run(token, process.pid, nowMs, fingerprint);
-            const platform = row.supervisor_platform;
-            const supervisorPid = row.supervisor_pid === null ? undefined : Number(row.supervisor_pid);
-            return {
-                status: "owner",
-                token,
-                ...(supervisorPid && (platform === "posix" || platform === "win32")
-                    ? { priorSupervisor: { pid: supervisorPid, platform } }
-                    : {}),
-            };
-        });
-    }
-    recordSupervisor(fingerprint, token, identity) {
-        this.#ownedUpdate(fingerprint, token, (database) => {
-            database.prepare(`
-        UPDATE verification_executions SET supervisor_pid = ?, supervisor_platform = ?
-        WHERE fingerprint = ? AND owner_token = ? AND receipt_json IS NULL
-      `).run(identity.pid, identity.platform, fingerprint, token);
-        });
-    }
-    clearSupervisor(fingerprint, token) {
-        this.#ownedUpdate(fingerprint, token, (database) => {
-            database.prepare(`
-        UPDATE verification_executions SET supervisor_pid = NULL, supervisor_platform = NULL
-        WHERE fingerprint = ? AND owner_token = ? AND receipt_json IS NULL
-      `).run(fingerprint, token);
-        });
-    }
-    complete(fingerprint, token, results, completedAtMs = Date.now()) {
-        const recoveryRequired = results.some((result) => result.execution.status === "runner_failed"
-            && result.execution.cause.code === "TREE_TERMINATION_FAILED");
-        return this.#withTransaction((database) => {
-            if (recoveryRequired) {
-                const changed = database.prepare(`
-          UPDATE verification_executions
-          SET owner_pid = 0, started_at_ms = 0
-          WHERE fingerprint = ? AND owner_token = ? AND receipt_json IS NULL
-        `).run(fingerprint, token).changes;
-                return Number(changed) === 1
-                    ? { status: "recovery-required" }
-                    : { status: "ownership-lost" };
-            }
-            const receipt = serializeReceipt(results);
-            const changed = database.prepare(`
-        UPDATE verification_executions
-        SET owner_pid = 0, supervisor_pid = NULL, supervisor_platform = NULL, completed_at_ms = ?, receipt_json = ?
-        WHERE fingerprint = ? AND owner_token = ? AND receipt_json IS NULL
-      `).run(completedAtMs, receipt, fingerprint, token).changes;
-            if (Number(changed) !== 1)
-                return { status: "ownership-lost" };
-            const countRow = database.prepare(`
-        SELECT count(*) AS count FROM verification_executions WHERE receipt_json IS NOT NULL
-      `).get();
-            const excess = Number(countRow.count) - VERIFICATION_COMPLETED_RECEIPT_LIMIT;
-            if (excess > 0) {
-                database.prepare(`
-          DELETE FROM verification_executions
-          WHERE fingerprint IN (
-            SELECT fingerprint FROM verification_executions
-            WHERE receipt_json IS NOT NULL
-            ORDER BY completed_at_ms ASC, fingerprint ASC
-            LIMIT ?
-          )
-        `).run(excess);
-            }
-            return { status: "published" };
-        });
-    }
-    releaseForTakeover(fingerprint, token) {
-        this.#withTransaction((database) => {
-            database.prepare(`
-        UPDATE verification_executions SET owner_pid = 0, started_at_ms = 0
-        WHERE fingerprint = ? AND owner_token = ? AND receipt_json IS NULL
-      `).run(fingerprint, token);
-        });
-    }
-    #ownedUpdate(fingerprint, token, update) {
-        this.#withTransaction((database) => {
-            update(database);
-            const row = database.prepare(`
-        SELECT owner_token FROM verification_executions
-        WHERE fingerprint = ? AND receipt_json IS NULL
-      `).get(fingerprint);
-            if (row?.owner_token !== token)
-                throw new Error("verification coordination ownership changed");
-        });
-    }
-    #withTransaction(operation) {
-        return this.#withDatabase((database) => {
-            database.exec("BEGIN IMMEDIATE");
-            try {
-                const result = operation(database);
-                database.exec("COMMIT");
-                return result;
-            }
-            catch (error) {
-                rollbackQuietly(database);
-                throw error;
-            }
-        });
-    }
-    #withDatabase(operation) {
-        const database = new DatabaseSync(this.#databasePath, {
-            enableDoubleQuotedStringLiterals: false,
-            allowExtension: false,
-        });
-        try {
-            database.exec(`PRAGMA busy_timeout = ${DATABASE_BUSY_TIMEOUT_MS}`);
-            initializeOrValidate(database);
-            return operation(database);
-        }
-        finally {
-            database.close();
-        }
-    }
-}