@astrosheep/keiyaku 2.9.12 → 4.0.0

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

@@ -1,220 +0,0 @@
-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 recordDeadStartup(projectionDirectory, executionId, detail, stage, terminalAt) {
-    const store = openProjectionGenerationStore(projectionDirectory);
-    try {
-        return store.settleStartupFailure({
-            executionId,
-            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)}`;
-        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();
-        const store = openProjectionGenerationStore(projectionDirectory);
-        try {
-            const current = store.readCurrentGeneration();
-            if (current?.launch.executionId !== executionId) {
-                return {
-                    status: "failed",
-                    cause: "adoption",
-                    detail: "launch stopped being current before adoption",
-                };
-            }
-            if (current.adoption)
-                return { status: "adopted", child };
-            if (current.verdict) {
-                return {
-                    status: "failed",
-                    cause: "adoption",
-                    detail: typeof current.verdict.facts.detail === "string"
-                        ? current.verdict.facts.detail
-                        : `launch ended as ${String(current.verdict.facts.state)}`,
-                };
-            }
-        }
-        finally {
-            store.close();
-        }
-        if (observedAt >= deadline)
-            break;
-        await sleep(Math.max(0, Math.min(PROJECTION_ADOPTION_POLL_MS, deadline - observedAt)));
-    }
-    const store = openProjectionGenerationStore(projectionDirectory);
-    try {
-        const current = store.readCurrentGeneration();
-        if (current?.launch.executionId === executionId && current.adoption) {
-            return { status: "adopted", child };
-        }
-    }
-    finally {
-        store.close();
-    }
-    return { status: "pending", child };
-}

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

@@ -1,46 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { spawn as nodeSpawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { executionStdioLogPath } from "./projection-generation-identity.js";
-const MODULE_FILE = fileURLToPath(import.meta.url);
-// Lives at src/core/projection/generation/ — four levels up is the package root.
-const PACKAGE_ROOT = path.resolve(path.dirname(MODULE_FILE), "..", "..", "..", "..");
-const RUNNER_ENTRY = MODULE_FILE.endsWith(".ts")
-    ? [process.execPath, "--import", "tsx", path.join(PACKAGE_ROOT, "src", "index.ts")]
-    : [process.execPath, path.join(PACKAGE_ROOT, "build", "index.js")];
-export function projectionGenerationRunnerArgv(projectionDirectory, executionId) {
-    return [
-        ...RUNNER_ENTRY,
-        "__keiyaku-wake",
-        path.resolve(projectionDirectory),
-        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;
-    const closeSync = dependencies.closeSync ?? fs.closeSync;
-    const absoluteDirectory = path.resolve(projectionDirectory);
-    const [command, ...args] = projectionGenerationRunnerArgv(absoluteDirectory, executionId);
-    if (!command)
-        throw new Error("projection runner command is empty");
-    const logPath = executionStdioLogPath(absoluteDirectory, executionId);
-    const logFd = openSync(logPath, "a");
-    try {
-        const child = spawn(command, args, {
-            detached: true,
-            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");
-        }
-        child.unref();
-        return child;
-    }
-    finally {
-        closeSync(logFd);
-    }
-}