@astrosheep/keiyaku 2.9.7 → 2.9.8

package/build/core/ledger-batch.js

@@ -0,0 +1,194 @@
+import { wrapGitError, runGitProcess } from "../git/core.js";
+import { GitStreamingBatchFramingError, GitStreamingBatchResponseEndedError, openGitStreamingBatch, } from "../git/streaming-batch.js";
+import { parseLedgerEntryCommitMessage } from "./entry.js";
+import { ACTIVE_LEDGER_REF_PREFIX, activeLedgerRef, } from "./ledger.js";
+const MAX_LEDGER_COMMIT_BYTES = 1024 * 1024;
+async function runLedgerGit(cwd, args) {
+    const result = await runGitProcess(cwd, args);
+    if (result.error || result.status !== 0) {
+        throw wrapGitError(args.join(" "), {
+            message: result.error?.message
+                ?? `git exited with status ${result.status ?? "unknown"}`,
+            stderr: result.stderr,
+            stdout: result.stdout,
+        }, cwd);
+    }
+    return Buffer.from(result.stdout, "utf8");
+}
+async function queryBatchObject(batch, expression) {
+    const record = await batch.request(expression, {
+        maxContentBytes: MAX_LEDGER_COMMIT_BYTES,
+    });
+    if (record.kind === "missing")
+        return null;
+    if (record.kind === "ambiguous") {
+        throw new Error(`[git cat-file ${expression}] object is ambiguous`);
+    }
+    return {
+        oid: record.record.oid,
+        type: record.record.type,
+        content: record.record.content,
+    };
+}
+function parseCommitObject(object) {
+    if (object.type !== "commit") {
+        throw new Error(`git cat-file expected commit ${object.oid}, received ${object.type}`);
+    }
+    const content = object.content.toString("utf8");
+    const messageStart = content.indexOf("\n\n");
+    if (messageStart < 0)
+        throw new Error(`git commit ${object.oid} has no message separator`);
+    const parents = [];
+    for (const line of content.slice(0, messageStart).split("\n")) {
+        if (!line.startsWith("parent "))
+            continue;
+        const parent = line.slice("parent ".length);
+        if (!/^[0-9a-f]{40,64}$/.test(parent)) {
+            throw new Error(`git commit ${object.oid} has an invalid parent header`);
+        }
+        parents.push(parent);
+    }
+    return { oid: object.oid, parents, message: content.slice(messageStart + 2) };
+}
+function parseLedgerRefs(output) {
+    return output
+        .toString("utf8")
+        .split(/\r?\n/)
+        .filter((ref) => ref.startsWith(ACTIVE_LEDGER_REF_PREFIX))
+        .map((ref) => ({ contractId: ref.slice(ACTIVE_LEDGER_REF_PREFIX.length), ref }));
+}
+async function readLedgerFromBatch(batch, ref, commits) {
+    const headObject = await queryBatchObject(batch, `${ref.ref}^{commit}`);
+    if (!headObject)
+        return null;
+    const head = parseCommitObject(headObject);
+    commits.set(head.oid, Promise.resolve(head));
+    const ordered = [];
+    const visited = new Set();
+    const visiting = new Set();
+    const visit = async (oid) => {
+        if (visited.has(oid))
+            return;
+        if (visiting.has(oid))
+            throw new Error(`git ledger ancestry contains a cycle at ${oid}`);
+        visiting.add(oid);
+        let pending = commits.get(oid);
+        if (!pending) {
+            pending = queryBatchObject(batch, oid).then((object) => {
+                if (!object)
+                    throw new Error(`[git cat-file ${oid}] object is missing`);
+                return parseCommitObject(object);
+            });
+            commits.set(oid, pending);
+        }
+        const commit = await pending;
+        for (const parent of commit.parents)
+            await visit(parent);
+        visiting.delete(oid);
+        visited.add(oid);
+        ordered.push(commit);
+    };
+    await visit(head.oid);
+    return {
+        contractId: ref.contractId,
+        ref: ref.ref,
+        head: head.oid,
+        entries: ordered.map((commit) => parseLedgerEntryCommitMessage(commit.message)),
+    };
+}
+async function closeBatch(cwd, batch) {
+    const close = await batch.close();
+    if (!close.aborted && (close.timedOut || close.signal || close.code !== 0)) {
+        throw wrapGitError("cat-file --batch", {
+            message: close.timedOut
+                ? "git timed out"
+                : close.signal
+                    ? `git exited from signal ${close.signal}`
+                    : `git exited with status ${close.code ?? "unknown"}`,
+            stderr: close.stderr.toString("utf8"),
+        }, cwd);
+    }
+}
+async function readLedgerRefs(cwd, refs) {
+    if (refs.length === 0)
+        return [];
+    const batch = openGitStreamingBatch(cwd);
+    const commits = new Map();
+    const results = [];
+    let readError;
+    try {
+        for (let index = 0; index < refs.length; index += 1) {
+            const ref = refs[index];
+            try {
+                const ledger = await readLedgerFromBatch(batch, ref, commits);
+                if (ledger)
+                    results.push(ledger);
+                else
+                    results.push({ id: ref.contractId, error: new Error(`ledger ref disappeared: ${ref.ref}`) });
+            }
+            catch (error) {
+                const diagnostic = error instanceof Error ? error : new Error(String(error));
+                results.push({ id: ref.contractId, error: diagnostic });
+                if (error instanceof GitStreamingBatchFramingError
+                    || error instanceof GitStreamingBatchResponseEndedError) {
+                    const isolationReason = error instanceof GitStreamingBatchResponseEndedError
+                        ? "response ended"
+                        : "malformed frame";
+                    for (const pending of refs.slice(index + 1)) {
+                        results.push({
+                            id: pending.contractId,
+                            error: new Error(`git cat-file batch terminated after ${isolationReason}: ${diagnostic.message}`),
+                        });
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    catch (error) {
+        readError = error;
+    }
+    try {
+        await closeBatch(cwd, batch);
+    }
+    catch (error) {
+        if (!readError)
+            readError = error;
+    }
+    if (readError)
+        throw readError;
+    return results;
+}
+/** Read every ledger with two Git processes regardless of ledger or entry count. */
+export async function readAllLedgerSnapshots(cwd) {
+    const refOutput = await runLedgerGit(cwd, [
+        "for-each-ref",
+        "--sort=refname",
+        "--format=%(refname)",
+        ACTIVE_LEDGER_REF_PREFIX,
+    ]);
+    return readLedgerRefs(cwd, parseLedgerRefs(refOutput));
+}
+/** Read one exact ledger with one Git process and without enumerating other refs. */
+export async function readLedgerSnapshot(cwd, contractId) {
+    const ref = activeLedgerRef(contractId);
+    const batch = openGitStreamingBatch(cwd);
+    let ledger = null;
+    let readError;
+    try {
+        ledger = await readLedgerFromBatch(batch, { contractId, ref }, new Map());
+    }
+    catch (error) {
+        readError = error;
+    }
+    try {
+        await closeBatch(cwd, batch);
+    }
+    catch (error) {
+        if (!readError)
+            readError = error;
+    }
+    if (readError)
+        throw readError;
+    return ledger;
+}

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

@@ -295,6 +295,8 @@ export function writeTransition(database, readOnly, run) {
     if (readOnly) {
         throw new ProjectionGenerationStoreError("projection generation store is read-only");
     }
+    if (database.isTransaction)
+        return run();
     database.exec("BEGIN IMMEDIATE");
     try {
         const result = run();
@@ -306,6 +308,26 @@ export function writeTransition(database, readOnly, run) {
         throw error;
     }
 }
+export function beginGenerationWriteTransaction(database, readOnly) {
+    assertDatabaseOpen(database);
+    if (readOnly)
+        throw new ProjectionGenerationStoreError("projection generation store is read-only");
+    if (database.isTransaction)
+        throw new ProjectionGenerationStoreError("projection generation write transaction is already open");
+    database.exec("BEGIN IMMEDIATE");
+}
+export function commitGenerationWriteTransaction(database) {
+    assertDatabaseOpen(database);
+    if (!database.isTransaction)
+        throw new ProjectionGenerationStoreError("projection generation write transaction is not open");
+    database.exec("COMMIT");
+}
+export function rollbackGenerationWriteTransaction(database) {
+    assertDatabaseOpen(database);
+    if (!database.isTransaction)
+        return;
+    rollbackQuietly(database);
+}
 export function closeDatabase(database) {
     if (closedDatabases.has(database))
         return;

package/build/core/projection/generation/projection-generation-execution.js

@@ -136,7 +136,7 @@ async function completionFacts(projectionDirectory, executionId, inputs, outcome
  * Construct the public Projection once and expose a provider-neutral execution
  * handle. Provider adapters and harness public types are unchanged.
  */
-export function executeProjectionGeneration(projectionDirectory, launch, providerLoaderPorts = {}) {
+export function prepareProjectionGenerationExecution(projectionDirectory, launch, providerLoaderPorts = {}) {
     const inputs = parseLaunchInputs(launch);
     initializeConfig(process.env, inputs.cwd);
     const executionId = launch.executionId;
@@ -160,43 +160,51 @@ export function executeProjectionGeneration(projectionDirectory, launch, provide
         executionId,
         initialTellIds,
     });
-    let projection;
-    try {
-        projection = inputs.session
-            ? revive({
-                ...terms,
-                session: inputs.session,
-                resumePath: inputs.resumePath ?? projectionDirectory,
-            }, { observer: observerController.observer })
-            : call(terms, { observer: observerController.observer });
-    }
-    catch (error) {
-        void observerController.close();
-        throw error;
-    }
-    const outcome = projection.outcome.then(async (result) => {
-        try {
+    return {
+        start() {
+            let projection;
+            try {
+                projection = inputs.session
+                    ? revive({
+                        ...terms,
+                        session: inputs.session,
+                        resumePath: inputs.resumePath ?? projectionDirectory,
+                    }, { observer: observerController.observer })
+                    : call(terms, { observer: observerController.observer });
+            }
+            catch (error) {
+                void observerController.close();
+                throw error;
+            }
+            const outcome = projection.outcome.then(async (result) => {
+                try {
+                    return {
+                        verdict: result.status === "completed"
+                            ? "completed"
+                            : result.status === "dismissed"
+                                ? "dismissed"
+                                : result.status === "interrupted"
+                                    ? "interrupted"
+                                    : "failed",
+                        facts: await completionFacts(projectionDirectory, executionId, inputs, result),
+                    };
+                }
+                finally {
+                    await observerController.close();
+                }
+            }, async (error) => {
+                await observerController.close();
+                throw error;
+            });
             return {
-                verdict: result.status === "completed"
-                    ? "completed"
-                    : result.status === "dismissed"
-                        ? "dismissed"
-                        : result.status === "interrupted"
-                            ? "interrupted"
-                            : "failed",
-                facts: await completionFacts(projectionDirectory, executionId, inputs, result),
+                events: projection.events,
+                outcome,
+                abort: (mode) => projection.abort(mode),
             };
-        }
-        finally {
-            await observerController.close();
-        }
-    }, async (error) => {
-        await observerController.close();
-        throw error;
-    });
-    return {
-        events: projection.events,
-        outcome,
-        abort: (mode) => projection.abort(mode),
+        },
+        dispose: () => observerController.close(),
     };
 }
+export function executeProjectionGeneration(projectionDirectory, launch, providerLoaderPorts = {}) {
+    return prepareProjectionGenerationExecution(projectionDirectory, launch, providerLoaderPorts).start();
+}

package/build/core/projection/generation/projection-generation-launcher.js

@@ -1,37 +1,179 @@
 import { setTimeout as delay } from "node:timers/promises";
 import { openProjectionGenerationStore } from "./store.js";
 import { spawnProjectionGenerationRunner, } from "./projection-generation-process.js";
+import { acquireProjectionRunnerLock, observeProjectionRunnerLock, } from "../projection-runner-lock.js";
 export const PROJECTION_ADOPTION_TIMEOUT_MS = 4_000;
 export const PROJECTION_ADOPTION_POLL_MS = 20;
 function errorDetail(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function recordLaunchFailure(projectionDirectory, executionId, detail, stage, terminalAt) {
+function recordDeadStartup(projectionDirectory, executionId, detail, stage, terminalAt) {
     const store = openProjectionGenerationStore(projectionDirectory);
     try {
-        return store.verdictIfOpen({
+        return store.settleStartupFailure({
             executionId,
-            verdict: "launch-failed",
-            facts: { stage, detail, ...(terminalAt ? { terminalAt } : {}) },
+            releasedLockEvidence: { stage, detail },
+            diagnostic: { stage, detail },
+            terminalAt,
         }).status === "committed";
     }
     finally {
         store.close();
     }
 }
+function observeBootstrapMessages(child, executionId) {
+    const seen = new Set();
+    const waiters = new Map();
+    let failure;
+    const onMessage = (value) => {
+        const message = value;
+        if (message.executionId !== executionId)
+            return;
+        if (message.kind !== "leash-inherited" && message.kind !== "leash-acquired")
+            return;
+        seen.add(message.kind);
+        const waiter = waiters.get(message.kind);
+        if (waiter) {
+            waiter.resolve();
+            waiters.delete(message.kind);
+        }
+    };
+    const onError = (error) => {
+        failure = error;
+        for (const waiter of waiters.values())
+            waiter.reject(error);
+        waiters.clear();
+    };
+    const onExit = () => onError(new Error("runner exited during bootstrap"));
+    child.on("message", onMessage);
+    child.on("error", onError);
+    child.on("exit", onExit);
+    return {
+        waitFor(kind) {
+            if (seen.has(kind))
+                return Promise.resolve();
+            if (failure)
+                return Promise.reject(failure);
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    waiters.delete(kind);
+                    reject(failure ?? new Error(`runner did not report ${kind} before startup timeout`));
+                }, PROJECTION_ADOPTION_TIMEOUT_MS);
+                waiters.set(kind, {
+                    resolve: () => {
+                        clearTimeout(timer);
+                        waiters.delete(kind);
+                        resolve();
+                    },
+                    reject: (error) => {
+                        clearTimeout(timer);
+                        waiters.delete(kind);
+                        reject(error);
+                    },
+                });
+            });
+        },
+        close() {
+            child.off("message", onMessage);
+            child.off("error", onError);
+            child.off("exit", onExit);
+        },
+    };
+}
+function sendBootstrapCommand(child, command) {
+    return new Promise((resolve, reject) => {
+        if (!child.send || !child.connected) {
+            reject(new Error("runner bootstrap channel is unavailable"));
+            return;
+        }
+        child.send(command, (error) => error ? reject(error) : resolve());
+    });
+}
 /** Spawn one committed launch and return only after its exact adoption row. */
 export async function startProjectionGeneration(projectionDirectory, executionId, dependencies = {}) {
     const now = dependencies.now ?? Date.now;
     const sleep = dependencies.sleep ?? ((milliseconds) => delay(milliseconds));
+    const launcherAcquiredOwnership = dependencies.launchOwnership === undefined;
+    let launchOwnership;
+    try {
+        launchOwnership = dependencies.launchOwnership
+            ?? acquireProjectionRunnerLock(projectionDirectory);
+    }
+    catch (error) {
+        if (observeProjectionRunnerLock(projectionDirectory).state === "held") {
+            return { status: "pending" };
+        }
+        return {
+            status: "failed",
+            cause: "adoption",
+            detail: `runner construction failed: ${errorDetail(error)}`,
+        };
+    }
+    let launchCommitted = false;
+    let childPromoted = false;
     let child;
     try {
         child = spawnProjectionGenerationRunner(projectionDirectory, executionId, dependencies);
     }
     catch (error) {
         const detail = `runner spawn failed: ${errorDetail(error)}`;
-        recordLaunchFailure(projectionDirectory, executionId, detail, "spawn", new Date(now()).toISOString());
+        recordDeadStartup(projectionDirectory, executionId, detail, "spawn", new Date(now()).toISOString());
+        launchOwnership.close();
         return { status: "failed", cause: "spawn", detail };
     }
+    const bootstrap = observeBootstrapMessages(child, executionId);
+    try {
+        await bootstrap.waitFor("leash-inherited");
+        if (dependencies.commitLaunch && !dependencies.commitLaunch()) {
+            await sendBootstrapCommand(child, { kind: "launch-rejected", executionId });
+            if (launcherAcquiredOwnership)
+                launchOwnership.close();
+            return { status: "failed", cause: "adoption", detail: "generation launch transaction was rejected" };
+        }
+        launchCommitted = true;
+        launchOwnership.releaseReservationForTransfer();
+        await sendBootstrapCommand(child, { kind: "promote-leash", executionId });
+        await bootstrap.waitFor("leash-acquired");
+        childPromoted = true;
+        await sendBootstrapCommand(child, { kind: "launch-committed", executionId });
+        try {
+            launchOwnership.close();
+        }
+        catch {
+            // The promoted child owns lifecycle truth; parent guard cleanup is diagnostic only.
+        }
+    }
+    catch (error) {
+        void sendBootstrapCommand(child, { kind: "launch-rejected", executionId }).catch(() => { });
+        if (childPromoted) {
+            try {
+                launchOwnership.close();
+            }
+            catch { }
+            return { status: "pending", child };
+        }
+        if (!launchCommitted) {
+            launchOwnership.close();
+            return { status: "failed", cause: "adoption", detail: `runner construction failed: ${errorDetail(error)}` };
+        }
+        try {
+            launchOwnership.reclaimReservation();
+        }
+        catch {
+            launchOwnership.close();
+            return { status: "pending", child };
+        }
+        try {
+            recordDeadStartup(projectionDirectory, executionId, `runner construction failed: ${errorDetail(error)}`, "adoption", new Date(now()).toISOString());
+        }
+        finally {
+            launchOwnership.close();
+        }
+        return { status: "failed", cause: "adoption", detail: `runner construction failed: ${errorDetail(error)}` };
+    }
+    finally {
+        bootstrap.close();
+    }
     const deadline = now() + PROJECTION_ADOPTION_TIMEOUT_MS;
     for (;;) {
         const observedAt = now();
@@ -74,19 +216,5 @@ export async function startProjectionGeneration(projectionDirectory, executionId
     finally {
         store.close();
     }
-    const detail = "runner did not commit adoption before startup timeout";
-    if (!recordLaunchFailure(projectionDirectory, executionId, detail, "adoption", new Date(now()).toISOString())) {
-        const raced = openProjectionGenerationStore(projectionDirectory);
-        try {
-            const current = raced.readCurrentGeneration();
-            if (current?.launch.executionId === executionId && current.adoption) {
-                return { status: "adopted", child };
-            }
-        }
-        finally {
-            raced.close();
-        }
-    }
-    child.kill("SIGTERM");
-    return { status: "failed", cause: "adoption", detail };
+    return { status: "pending", child };
 }

package/build/core/projection/generation/projection-generation-process.js

@@ -17,6 +17,7 @@ export function projectionGenerationRunnerArgv(projectionDirectory, executionId)
         executionId,
     ];
 }
+export const PROJECTION_RUNNER_BOOTSTRAP_ENV = "KEIYAKU_PROJECTION_RUNNER_BOOTSTRAP";
 export function spawnProjectionGenerationRunner(projectionDirectory, executionId, dependencies = {}) {
     const spawn = dependencies.spawn ?? nodeSpawn;
     const openSync = dependencies.openSync ?? fs.openSync;
@@ -30,7 +31,8 @@ export function spawnProjectionGenerationRunner(projectionDirectory, executionId
     try {
         const child = spawn(command, args, {
             detached: true,
-            stdio: ["ignore", logFd, logFd],
+            stdio: ["ignore", logFd, logFd, "ipc"],
+            env: { ...process.env, [PROJECTION_RUNNER_BOOTSTRAP_ENV]: "1" },
         });
         if (child.pid === undefined) {
             throw new Error("projection runner did not expose a process id");