@astrosheep/keiyaku 2.9.11 → 2.9.12

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

@@ -1,9 +1,6 @@
-import * as fs from "node:fs";
 import * as path from "node:path";
-import { DatabaseSync } from "node:sqlite";
+import { initializeSqliteProcessLifetimeLockDatabase, isSqliteProcessLifetimeLockContention, isSqliteProcessLifetimeLockPlatformSupported, openSqliteProcessLifetimeLockTransaction, SqliteProcessLifetimeLockError, sqliteProcessLifetimeLockErrorDetail, } from "../sqlite-process-lifetime-lock.js";
 export const PROJECTION_RUNNER_LOCK_DATABASE = "leash";
-const SQLITE_BUSY = 5;
-const SUPPORTED_PLATFORMS = new Set(["darwin", "linux", "win32"]);
 export class ProjectionRunnerLockUnavailableError extends Error {
     code = "PROJECTION_RUNNER_LOCK_UNAVAILABLE";
     constructor(message, options) {
@@ -22,72 +19,28 @@ export function projectionRunnerLockPath(projectionDirectory) {
     return path.join(projectionDirectory, PROJECTION_RUNNER_LOCK_DATABASE);
 }
 export function isProjectionRunnerLockPlatformSupported(platform = process.platform) {
-    return SUPPORTED_PLATFORMS.has(platform);
+    return isSqliteProcessLifetimeLockPlatformSupported(platform);
 }
 function errorDetail(error) {
-    return error instanceof Error ? error.message : String(error);
+    return sqliteProcessLifetimeLockErrorDetail(error);
 }
-function isSqliteBusy(error) {
-    return typeof error === "object"
-        && error !== null
-        && "errcode" in error
-        && error.errcode === SQLITE_BUSY;
-}
-function readJournalMode(database) {
-    const row = database.prepare("PRAGMA journal_mode").get();
-    return typeof row?.journal_mode === "string" ? row.journal_mode.toLowerCase() : undefined;
-}
-function assertCurrentLockSchema(database) {
-    database.prepare("SELECT id FROM lock_anchor LIMIT 1").get();
-}
-function assertBusyTimeout(busyTimeoutMs) {
-    if (!Number.isSafeInteger(busyTimeoutMs) || busyTimeoutMs < 0) {
-        throw new ProjectionRunnerLockUnavailableError("projection runner lock busy timeout must be a non-negative safe integer");
-    }
+function isContention(error) {
+    return isSqliteProcessLifetimeLockContention(error)
+        || (error instanceof SqliteProcessLifetimeLockError && error.reason === "busy");
 }
 function openGuard(lockPath, busyTimeoutMs) {
-    const database = new DatabaseSync(lockPath);
-    try {
-        database.exec(`PRAGMA busy_timeout=${busyTimeoutMs}`);
-        database.exec("BEGIN DEFERRED");
-        assertCurrentLockSchema(database);
-        if (readJournalMode(database) !== "delete") {
-            throw new ProjectionRunnerLockUnavailableError("projection runner lock database does not use rollback-journal mode");
-        }
-        return database;
-    }
-    catch (error) {
-        closeTransaction(database);
-        throw error;
-    }
+    return openSqliteProcessLifetimeLockTransaction({ path: lockPath, mode: "deferred", busyTimeoutMs });
 }
 function openReservation(lockPath, busyTimeoutMs) {
-    const database = new DatabaseSync(lockPath);
-    try {
-        database.exec(`PRAGMA busy_timeout=${busyTimeoutMs}`);
-        database.exec("BEGIN IMMEDIATE");
-        return database;
-    }
-    catch (error) {
-        closeTransaction(database);
-        throw error;
-    }
+    return openSqliteProcessLifetimeLockTransaction({ path: lockPath, mode: "immediate", busyTimeoutMs });
 }
-function closeTransaction(database) {
-    let failure;
-    try {
-        database.exec("ROLLBACK");
-    }
-    catch (error) {
-        failure = error;
-    }
+function closeTransaction(transaction) {
     try {
-        database.close();
+        transaction.close();
     }
     catch (error) {
-        failure ??= error;
+        return error;
     }
-    return failure;
 }
 function createHeldLock(lockPath, busyTimeoutMs, guard, initialReservation) {
     let closed = false;
@@ -100,9 +53,8 @@ function createHeldLock(lockPath, busyTimeoutMs, guard, initialReservation) {
             const released = reservation;
             reservation = undefined;
             const failure = closeTransaction(released);
-            if (failure !== undefined) {
+            if (failure !== undefined)
                 throw new ProjectionRunnerLockUnavailableError(`projection runner reservation release failed: ${errorDetail(failure)}`, { cause: failure });
-            }
         },
         reclaimReservation() {
             if (closed || reservation !== undefined)
@@ -121,123 +73,61 @@ function createHeldLock(lockPath, busyTimeoutMs, guard, initialReservation) {
             let failure;
             if (reservation !== undefined)
                 failure = closeTransaction(reservation);
-            const guardFailure = closeTransaction(guard);
-            failure ??= guardFailure;
-            if (failure !== undefined) {
+            failure ??= closeTransaction(guard);
+            if (failure !== undefined)
                 throw new ProjectionRunnerLockUnavailableError(`projection runner lock release failed: ${errorDetail(failure)}`, { cause: failure });
-            }
         },
     };
 }
-function closeAfterFailedAcquire(database, error) {
-    try {
-        database.close();
-    }
-    catch {
-        // The acquisition error remains the causal failure. Closing a connection
-        // that never became authoritative cannot turn it into a held lock.
-    }
-    if (isSqliteBusy(error)) {
-        throw new ProjectionRunnerLockUnavailableError("projection runner lock is already held", { cause: error });
-    }
-    throw new ProjectionRunnerLockUnavailableError(`projection runner lock acquisition failed: ${errorDetail(error)}`, { cause: error });
+function unavailable(operation, error) {
+    return new ProjectionRunnerLockUnavailableError(`${operation}: ${errorDetail(error)}`, { cause: error });
 }
-/**
- * Mint-time initialization for the fixed lock database. This creates storage,
- * forces rollback-journal mode, verifies the anchor schema, and closes without
- * retaining any process-life authority.
- */
+/** Mint-time schema initialization retains no process-life authority. */
 export function initializeProjectionRunnerLockDatabase(projectionDirectory, platform = process.platform) {
-    if (!isProjectionRunnerLockPlatformSupported(platform)) {
+    if (!isProjectionRunnerLockPlatformSupported(platform))
         throw new ProjectionRunnerLockUnsupportedError(platform);
-    }
-    const lockPath = projectionRunnerLockPath(projectionDirectory);
-    let database;
-    try {
-        database = new DatabaseSync(lockPath);
-    }
-    catch (error) {
-        throw new ProjectionRunnerLockUnavailableError(`projection runner lock database could not be initialized: ${errorDetail(error)}`, { cause: error });
-    }
-    let initializationError;
-    try {
-        database.exec("PRAGMA busy_timeout=0");
-        database.exec("PRAGMA journal_mode=DELETE");
-        database.exec("CREATE TABLE IF NOT EXISTS lock_anchor (id INTEGER PRIMARY KEY CHECK (id = 1))");
-        if (readJournalMode(database) !== "delete") {
-            throw new ProjectionRunnerLockUnavailableError("projection runner lock database does not use rollback-journal mode");
-        }
-        assertCurrentLockSchema(database);
-    }
-    catch (error) {
-        initializationError = error;
-    }
     try {
-        database.close();
+        return initializeSqliteProcessLifetimeLockDatabase(projectionRunnerLockPath(projectionDirectory), platform);
     }
     catch (error) {
-        initializationError ??= error;
-    }
-    if (initializationError !== undefined) {
-        throw new ProjectionRunnerLockUnavailableError(`projection runner lock database initialization failed: ${errorDetail(initializationError)}`, { cause: initializationError });
+        throw unavailable("projection runner lock database could not be initialized", error);
     }
-    return lockPath;
 }
 /**
- * Hold one rollback-mode SHARED guard plus the sole RESERVED claim until
- * close() or process death. An EXCLUSIVE probe cannot pass either component.
- * During handoff the child overlaps the guard before the RESERVED claim moves,
- * so kernel exclusion remains continuous without transferring a connection.
+ * 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)) {
+    if (!isProjectionRunnerLockPlatformSupported(platform))
         throw new ProjectionRunnerLockUnsupportedError(platform);
-    }
     const lockPath = projectionRunnerLockPath(projectionDirectory);
-    try {
-        if (!fs.lstatSync(lockPath).isFile()) {
-            throw new ProjectionRunnerLockUnavailableError("projection runner lock database is not a regular file");
-        }
-    }
-    catch (error) {
-        if (error instanceof ProjectionRunnerLockUnavailableError)
-            throw error;
-        throw new ProjectionRunnerLockUnavailableError(`projection runner lock database is not initialized: ${errorDetail(error)}`, { cause: error });
-    }
-    assertBusyTimeout(busyTimeoutMs);
     let guard;
     try {
         guard = openGuard(lockPath, busyTimeoutMs);
     }
     catch (error) {
-        throw new ProjectionRunnerLockUnavailableError(`projection runner lock database could not be opened: ${errorDetail(error)}`, { cause: error });
+        throw unavailable("projection runner lock database could not be opened", error);
     }
-    let reservation;
     try {
-        reservation = openReservation(lockPath, busyTimeoutMs);
+        return createHeldLock(lockPath, busyTimeoutMs, guard, openReservation(lockPath, busyTimeoutMs));
     }
     catch (error) {
-        if (reservation)
-            closeTransaction(reservation);
         closeTransaction(guard);
-        return closeAfterFailedAcquire(guard, error);
+        if (isContention(error))
+            throw new ProjectionRunnerLockUnavailableError("projection runner lock is already held", { cause: error });
+        throw unavailable("projection runner lock acquisition failed", error);
     }
-    return createHeldLock(lockPath, busyTimeoutMs, guard, reservation);
 }
 export function acquireProjectionRunnerTransferTarget(projectionDirectory, platform = process.platform, busyTimeoutMs = 0) {
-    if (!isProjectionRunnerLockPlatformSupported(platform)) {
+    if (!isProjectionRunnerLockPlatformSupported(platform))
         throw new ProjectionRunnerLockUnsupportedError(platform);
-    }
-    assertBusyTimeout(busyTimeoutMs);
     const lockPath = projectionRunnerLockPath(projectionDirectory);
     let guard;
     try {
         guard = openGuard(lockPath, busyTimeoutMs);
     }
     catch (error) {
-        if (guard)
-            closeTransaction(guard);
-        throw new ProjectionRunnerLockUnavailableError(`projection runner transfer acquisition failed: ${errorDetail(error)}`, { cause: error });
+        throw unavailable("projection runner transfer acquisition failed", error);
     }
     let closed = false;
     return {
@@ -245,55 +135,38 @@ export function acquireProjectionRunnerTransferTarget(projectionDirectory, platf
         promote() {
             if (closed)
                 throw new ProjectionRunnerLockUnavailableError("projection runner transfer target is closed");
-            let reservation;
             try {
-                reservation = openReservation(lockPath, busyTimeoutMs);
+                const reservation = openReservation(lockPath, busyTimeoutMs);
+                closed = true;
+                return createHeldLock(lockPath, busyTimeoutMs, guard, reservation);
             }
             catch (error) {
-                if (reservation)
-                    closeTransaction(reservation);
-                throw new ProjectionRunnerLockUnavailableError(`projection runner transfer promotion failed: ${errorDetail(error)}`, { cause: error });
+                throw unavailable("projection runner transfer promotion failed", error);
             }
-            closed = true;
-            return createHeldLock(lockPath, busyTimeoutMs, guard, reservation);
         },
         close() {
             if (closed)
                 return;
             closed = true;
             const failure = closeTransaction(guard);
-            if (failure !== undefined) {
-                throw new ProjectionRunnerLockUnavailableError(`projection runner transfer release failed: ${errorDetail(failure)}`, { cause: failure });
-            }
+            if (failure !== undefined)
+                throw unavailable("projection runner transfer release failed", failure);
         },
     };
 }
-/** Acquire positive death evidence. Any active guard or transfer blocks this. */
+/** Acquire positive death evidence. An active guard or transfer blocks this. */
 export function acquireProjectionRunnerSettlementLock(projectionDirectory, platform = process.platform, busyTimeoutMs = 0) {
-    if (!isProjectionRunnerLockPlatformSupported(platform)) {
+    if (!isProjectionRunnerLockPlatformSupported(platform))
         throw new ProjectionRunnerLockUnsupportedError(platform);
-    }
-    assertBusyTimeout(busyTimeoutMs);
     const lockPath = projectionRunnerLockPath(projectionDirectory);
-    let database;
+    let transaction;
     try {
-        database = new DatabaseSync(lockPath);
-        database.exec(`PRAGMA busy_timeout=${busyTimeoutMs}`);
-        database.exec("BEGIN EXCLUSIVE");
-        assertCurrentLockSchema(database);
-        if (readJournalMode(database) !== "delete") {
-            throw new ProjectionRunnerLockUnavailableError("projection runner lock database does not use rollback-journal mode");
-        }
+        transaction = openSqliteProcessLifetimeLockTransaction({ path: lockPath, mode: "exclusive", busyTimeoutMs });
     }
     catch (error) {
-        try {
-            database.close();
-        }
-        catch { }
-        if (isSqliteBusy(error)) {
+        if (isContention(error))
             throw new ProjectionRunnerLockUnavailableError("projection runner lock is already held", { cause: error });
-        }
-        throw new ProjectionRunnerLockUnavailableError(`projection runner settlement lock acquisition failed: ${errorDetail(error)}`, { cause: error });
+        throw unavailable("projection runner settlement lock acquisition failed", error);
     }
     let closed = false;
     return {
@@ -302,81 +175,37 @@ export function acquireProjectionRunnerSettlementLock(projectionDirectory, platf
             if (closed)
                 return;
             closed = true;
-            const failure = closeTransaction(database);
-            if (failure !== undefined) {
-                throw new ProjectionRunnerLockUnavailableError(`projection runner settlement lock release failed: ${errorDetail(failure)}`, { cause: failure });
-            }
+            const failure = closeTransaction(transaction);
+            if (failure !== undefined)
+                throw unavailable("projection runner settlement lock release failed", failure);
         },
     };
 }
-/**
- * Probe without creating the lock database. BEGIN EXCLUSIVE is the positive
- * death test: SQLITE_BUSY proves a SHARED guard or RESERVED owner remains;
- * success proves both are gone. Every other failure remains unknown.
- */
+/** 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}'`,
-        };
+        return { state: "unknown", reason: "unsupported-platform", detail: `projection runner locks are unsupported on platform '${platform}'` };
     }
     const lockPath = projectionRunnerLockPath(projectionDirectory);
+    let probe;
     try {
-        if (!fs.lstatSync(lockPath).isFile()) {
-            return {
-                state: "unknown",
-                reason: "open-failed",
-                detail: "projection runner lock database is not a regular file",
-            };
-        }
-    }
-    catch (error) {
-        return { state: "unknown", reason: "open-failed", detail: errorDetail(error) };
-    }
-    let database;
-    try {
-        database = new DatabaseSync(lockPath);
-    }
-    catch (error) {
-        return { state: "unknown", reason: "open-failed", detail: errorDetail(error) };
-    }
-    let transactionOpen = false;
-    try {
-        database.exec("PRAGMA busy_timeout=0");
-        database.exec("BEGIN EXCLUSIVE");
-        transactionOpen = true;
-        assertCurrentLockSchema(database);
-        const journalMode = readJournalMode(database);
-        if (journalMode !== "delete") {
-            return {
-                state: "unknown",
-                reason: "unsupported-journal-mode",
-                detail: `projection runner lock database uses journal mode '${journalMode ?? "unknown"}'`,
-            };
-        }
+        probe = openSqliteProcessLifetimeLockTransaction({ path: lockPath, mode: "exclusive", busyTimeoutMs: 0 });
         return { state: "released" };
     }
     catch (error) {
-        if (isSqliteBusy(error))
+        if (isContention(error))
             return { state: "held" };
-        return { state: "unknown", reason: "probe-failed", detail: errorDetail(error) };
+        const detail = errorDetail(error);
+        return {
+            state: "unknown",
+            reason: detail.includes("rollback-journal") ? "unsupported-journal-mode" : "probe-failed",
+            detail,
+        };
     }
     finally {
-        if (transactionOpen) {
-            try {
-                database.exec("ROLLBACK");
-            }
-            catch {
-                // Closing below still drops this observer's own ephemeral SHARED lock.
-            }
-        }
         try {
-            database.close();
-        }
-        catch {
-            // Observer cleanup failures cannot be converted into death evidence.
+            probe?.close();
         }
+        catch { /* no probe cleanup result is death evidence */ }
     }
 }

package/build/core/projection/projection-wait.js

@@ -223,8 +223,8 @@ export async function waitForProjection(input) {
         const verdict = current ? verdictFromCurrent(current, observedAtMs) : undefined;
         const terminal = verdict !== undefined;
         const terminalAtMs = verdict === undefined ? undefined : Date.parse(verdict.at);
-        const terminalWithinDeadline = terminal && (input.deadlineMs === undefined
-            || (typeof terminalAtMs === "number" && Number.isFinite(terminalAtMs) && terminalAtMs < input.deadlineMs));
+        const terminalWithinDeadline = terminal && (deadline === undefined
+            || (typeof terminalAtMs === "number" && Number.isFinite(terminalAtMs) && terminalAtMs < deadline));
         if (terminalWithinDeadline || (deadline !== undefined && observedAtMs >= deadline)) {
             const revalidated = readContinuationSnapshot(input.projectionDirectory, 10);
             if (revalidated.generationSequence !== continuation.generationSequence)

package/build/core/projection/projection-wake.js

@@ -234,6 +234,7 @@ export async function tellProjection(projectionDirectory, projectionId, effort,
                         const settled = store.settleKillIfRunnerDead({
                             executionId: current.launch.executionId,
                             releasedLockEvidence: { observedAt: terminalAt, state: "acquired" },
+                            terminalAt,
                         });
                         if (settled.status === "committed")
                             store.commitWriteTransaction();
@@ -300,6 +301,7 @@ export async function tellProjection(projectionDirectory, projectionId, effort,
                         const settled = store.settleKillIfRunnerDead({
                             executionId: current.launch.executionId,
                             releasedLockEvidence: { observedAt: terminalAt, state: "acquired" },
+                            terminalAt,
                         });
                         if (settled.status === "committed")
                             store.commitWriteTransaction();

package/build/core/repository-ledger/claim-evidence.js

@@ -119,7 +119,7 @@ export async function assertHonestClaimEvidence(cwd, evidence, readContext) {
     let merge;
     try {
         const coordinates = readContext?.coordinates ?? await deriveHostGitCoordinates(cwd);
-        merge = readContext === undefined
+        merge = readContext?.reader === undefined
             ? await readCommitObject(cwd, coordinates, evidence.mergeCommit)
             : await readContext.reader.read(evidence.mergeCommit);
     }