@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/core/projection/projection-life-observer.js

@@ -1,101 +0,0 @@
-import { isIncompatibleProjectionGenerationStoreError, openProjectionGenerationStoreReadOnly, } from "./generation/store.js";
-import { deriveProjectionLife, selectCurrentGeneration, } from "./projection-life-protocol.js";
-import { observeProjectionRunnerLock } from "./projection-runner-lock.js";
-function errorDetail(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-/**
- * Observe the current generation without creating, repairing, or mutating
- * projection storage. Generation history is the ordering authority; the
- * runner lock is consulted only for an adopted, non-terminal generation.
- */
-export function observeProjectionLifeSnapshot(projectionDirectory, options) {
-    const readRecords = () => {
-        const store = openProjectionGenerationStoreReadOnly(projectionDirectory);
-        try {
-            return store.readRecords();
-        }
-        finally {
-            store.close();
-        }
-    };
-    for (let attempt = 0; attempt < 4; attempt += 1) {
-        let records;
-        try {
-            records = readRecords();
-        }
-        catch (error) {
-            if (isIncompatibleProjectionGenerationStoreError(error)) {
-                return { compatibility: "incompatible", diagnostic: errorDetail(error) };
-            }
-            return {
-                compatibility: "current",
-                life: {
-                    phase: "unknown",
-                    diagnostic: `generation history could not be observed: ${errorDetail(error)}`,
-                },
-            };
-        }
-        const current = selectCurrentGeneration(records);
-        if (!current || current.verdict || !current.adoption) {
-            return {
-                compatibility: "current",
-                life: deriveProjectionLife({
-                    records,
-                    nowMs: options.nowMs,
-                    startupTimeoutMs: options.startupTimeoutMs,
-                }),
-                records,
-            };
-        }
-        const lock = observeProjectionRunnerLock(projectionDirectory, options.platform);
-        let after;
-        try {
-            after = readRecords();
-        }
-        catch (error) {
-            if (isIncompatibleProjectionGenerationStoreError(error)) {
-                return { compatibility: "incompatible", diagnostic: errorDetail(error) };
-            }
-            return {
-                compatibility: "current",
-                life: {
-                    phase: "unknown",
-                    executionId: current.launch.executionId,
-                    diagnostic: `generation history could not be re-observed: ${errorDetail(error)}`,
-                },
-            };
-        }
-        const beforeTail = records.at(-1)?.seq;
-        const afterTail = after.at(-1)?.seq;
-        if (records.length !== after.length || beforeTail !== afterTail)
-            continue;
-        return {
-            compatibility: "current",
-            life: deriveProjectionLife({
-                records,
-                runnerLock: lock.state === "held"
-                    ? "held"
-                    : lock.state === "released"
-                        ? "released"
-                        : "unknown",
-                nowMs: options.nowMs,
-                startupTimeoutMs: options.startupTimeoutMs,
-            }),
-            records,
-        };
-    }
-    return {
-        compatibility: "current",
-        life: {
-            phase: "unknown",
-            diagnostic: "generation history changed during runner-lock observation",
-        },
-    };
-}
-export function observeProjectionLife(projectionDirectory, options) {
-    const snapshot = observeProjectionLifeSnapshot(projectionDirectory, options);
-    return snapshot.compatibility === "current"
-        ? snapshot.life
-        : { phase: "unknown", diagnostic: snapshot.diagnostic };
-}

package/build/core/projection/projection-life-protocol.js

@@ -1,115 +0,0 @@
-export const GENERATION_VERDICT_STATES = [
-    "completed",
-    "failed",
-    "launch-failed",
-    "lost-runner",
-    "dismissed",
-    "interrupted",
-    "killed",
-];
-function asLaunch(record) {
-    return record.kind === "launch"
-        ? record
-        : undefined;
-}
-function asAdoption(record) {
-    return record.kind === "adoption"
-        ? record
-        : undefined;
-}
-function asKillIntent(record) {
-    return record.kind === "kill-intent"
-        ? record
-        : undefined;
-}
-function asInterruptIntent(record) {
-    return record.kind === "interrupt-intent"
-        ? record
-        : undefined;
-}
-function asVerdict(record) {
-    return record.kind === "verdict"
-        ? record
-        : undefined;
-}
-/**
- * Select the current generation using ledger sequence only. The store validates
- * dense sequence and transition legality before records reach this fold.
- */
-export function selectCurrentGeneration(records) {
-    let launch;
-    for (const record of records) {
-        const candidate = asLaunch(record);
-        if (candidate)
-            launch = candidate;
-    }
-    if (!launch)
-        return null;
-    let adoption;
-    let killIntent;
-    let interruptIntent;
-    let verdict;
-    for (const record of records) {
-        if (record.seq <= launch.seq || record.executionId !== launch.executionId)
-            continue;
-        adoption ??= asAdoption(record);
-        killIntent ??= asKillIntent(record);
-        interruptIntent ??= asInterruptIntent(record);
-        verdict ??= asVerdict(record);
-    }
-    return {
-        launch,
-        ...(adoption ? { adoption } : {}),
-        ...(killIntent ? { killIntent } : {}),
-        ...(interruptIntent ? { interruptIntent } : {}),
-        ...(verdict ? { verdict } : {}),
-    };
-}
-function verdictState(record) {
-    const state = record?.facts.state;
-    return typeof state === "string"
-        && GENERATION_VERDICT_STATES.includes(state)
-        ? state
-        : undefined;
-}
-function phaseForVerdict(state) {
-    switch (state) {
-        case "completed": return "done";
-        case "dismissed": return "dismissed";
-        case "interrupted": return "done";
-        case "killed": return "killed";
-        case "lost-runner": return "lost";
-        case "failed":
-        case "launch-failed":
-            return "failed";
-    }
-}
-export function deriveProjectionLife(input) {
-    const chain = selectCurrentGeneration(input.records);
-    if (!chain)
-        return { phase: "quiescent" };
-    const executionId = chain.launch.executionId;
-    if (chain.verdict) {
-        const state = verdictState(chain.verdict);
-        return state
-            ? { phase: phaseForVerdict(state), executionId, verdict: state }
-            : { phase: "unknown", executionId, diagnostic: "current generation has an invalid verdict" };
-    }
-    if (!chain.adoption) {
-        const createdAt = chain.launch.facts.createdAt;
-        const launchedAtMs = typeof createdAt === "string" ? Date.parse(createdAt) : Number.NaN;
-        if (!Number.isFinite(launchedAtMs)) {
-            return { phase: "unknown", executionId, diagnostic: "current launch has an invalid createdAt fact" };
-        }
-        return input.nowMs - launchedAtMs >= input.startupTimeoutMs
-            ? { phase: "startup-timeout", executionId }
-            : { phase: "minting", executionId };
-    }
-    switch (input.runnerLock) {
-        case "held": return { phase: "active", executionId };
-        case "released": return { phase: "lost", executionId };
-        case "unknown":
-        case undefined:
-            return { phase: "unknown", executionId, diagnostic: "runner lock could not be determined" };
-    }
-}

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

@@ -1,172 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { isErrnoException } from "../../errno.js";
-import { ProjectionStateError, randomHex8 } from "../atomic-publish.js";
-import { isoFromNowMs, PROJECTION_ROOT_SEGMENTS, projectionDir, projectionRoot, } from "./projection-core.js";
-import { parseExecutionAuthoritySelection, parseExecutionPact, parseExecutionPactFields, } from "../execution-pact.js";
-import { openProjectionGenerationStore } from "./generation/store.js";
-import { initializeProjectionRunnerLockDatabase } from "./projection-runner-lock.js";
-export class ProjectionMintCollisionError extends Error {
-    code = "PROJECTION_MINT_COLLISION";
-    constructor(message, options) {
-        super(message, options);
-        this.name = "ProjectionMintCollisionError";
-    }
-}
-const DEFAULT_MINT_ATTEMPTS = 16;
-function assertMintSlug(slug) {
-    const normalized = slug.trim();
-    if (!normalized) {
-        throw new ProjectionStateError("projection slug cannot be empty");
-    }
-    if (!/^[a-zA-Z0-9]+(?:[.-][a-zA-Z0-9]+)*$/.test(normalized)) {
-        throw new ProjectionStateError(`invalid projection slug: ${slug}`);
-    }
-    return normalized;
-}
-function removeEmptyAkumaRoot(dir) {
-    try {
-        fs.rmdirSync(dir);
-    }
-    catch (error) {
-        if (isErrnoException(error) && ["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code ?? ""))
-            return;
-        throw error;
-    }
-}
-/**
- * Validate mint inputs that can fail, then reserve one private staging directory.
- * Dot-prefixed staging is never a published projection address.
- */
-async function reserveProjectionDirectory(input) {
-    const slug = assertMintSlug(input.slug);
-    if (!Number.isInteger(input.pid) || input.pid < 0) {
-        throw new ProjectionStateError("projection pid must be a non-negative integer");
-    }
-    if (!Number.isSafeInteger(input.nowMs) || input.nowMs < 0) {
-        throw new ProjectionStateError("nowMs must be a safe non-negative integer");
-    }
-    const maxAttempts = input.maxAttempts ?? DEFAULT_MINT_ATTEMPTS;
-    if (!Number.isInteger(maxAttempts) || maxAttempts < 1) {
-        throw new ProjectionStateError("maxAttempts must be a positive integer");
-    }
-    const root = await projectionRoot(input.cwd);
-    fs.mkdirSync(root, { recursive: true });
-    const akumaRoot = path.join(root, slug);
-    const createdAkumaRoot = !fs.existsSync(akumaRoot);
-    fs.mkdirSync(akumaRoot, { recursive: true });
-    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-        const hex = (input.randomHex?.(attempt) ?? randomHex8()).toLowerCase();
-        if (!/^[0-9a-f]{8}$/.test(hex)) {
-            if (createdAkumaRoot)
-                removeEmptyAkumaRoot(akumaRoot);
-            throw new ProjectionStateError(`projection id random segment must be 8 hex chars, got ${hex}`);
-        }
-        const id = `${slug}/${hex}`;
-        const dir = await projectionDir(input.cwd, id);
-        const stagingDir = path.join(akumaRoot, `.mint-${hex}`);
-        if (fs.existsSync(dir))
-            continue;
-        try {
-            fs.mkdirSync(stagingDir);
-        }
-        catch (error) {
-            if (isErrnoException(error) && error.code === "EEXIST") {
-                continue;
-            }
-            if (createdAkumaRoot)
-                removeEmptyAkumaRoot(akumaRoot);
-            throw error;
-        }
-        if (fs.existsSync(dir)) {
-            fs.rmdirSync(stagingDir);
-            continue;
-        }
-        return { id, dir, stagingDir };
-    }
-    if (createdAkumaRoot)
-        removeEmptyAkumaRoot(akumaRoot);
-    throw new ProjectionMintCollisionError(`exhausted ${maxAttempts} projection id attempts under ${PROJECTION_ROOT_SEGMENTS.join("/")} (PROJECTION_MINT_COLLISION)`);
-}
-/** Build the pact fields shared by both authority variants. */
-function buildMintPactFields(input) {
-    return {
-        version: 1,
-        pid: input.pid,
-        akuma: input.akuma,
-        provider: input.provider,
-        binding: input.binding,
-        mintedAt: isoFromNowMs(input.nowMs),
-        workspaceRoot: input.workspaceRoot ?? path.resolve(input.cwd),
-        ...(input.effectivePolicy ? { effectivePolicy: input.effectivePolicy } : {}),
-    };
-}
-/**
- * Build both hard projection organs in private staging, close every database
- * handle, then publish the complete projection with one directory rename.
- */
-function publishReservedProjection(pact, reserved) {
-    let published = false;
-    try {
-        const heart = openProjectionGenerationStore(reserved.stagingDir);
-        try {
-            heart.initializeIdentity(pact);
-        }
-        finally {
-            heart.close();
-        }
-        initializeProjectionRunnerLockDatabase(reserved.stagingDir);
-        fs.renameSync(reserved.stagingDir, reserved.dir);
-        published = true;
-        return { id: reserved.id, dir: reserved.dir, pact };
-    }
-    finally {
-        if (!published) {
-            fs.rmSync(reserved.stagingDir, { recursive: true, force: true });
-            const parent = path.dirname(reserved.stagingDir);
-            removeEmptyAkumaRoot(parent);
-        }
-    }
-}
-/**
- * Mint a user-authority projection directory.
- * Order (closed): validate → reserve staging → heart + leash → atomic rename.
- */
-export async function mintProjection(input) {
-    const authority = parseExecutionAuthoritySelection(input.authority, "projection identity", "user");
-    const fields = parseExecutionPactFields(buildMintPactFields(input));
-    const pact = parseExecutionPact({
-        version: fields.version,
-        pid: fields.pid,
-        akuma: fields.akuma,
-        provider: fields.provider,
-        authority,
-        binding: fields.binding,
-        mintedAt: fields.mintedAt,
-        workspaceRoot: fields.workspaceRoot,
-        ...(fields.effectivePolicy !== undefined ? { effectivePolicy: fields.effectivePolicy } : {}),
-    });
-    const reserved = await reserveProjectionDirectory(input);
-    return publishReservedProjection(pact, reserved);
-}
-/**
- * Mint a repository-authority projection.
- * Order: validate complete identity → reserve staging → heart + leash → atomic rename.
- */
-export async function mintRepositoryProjection(input) {
-    parseExecutionAuthoritySelection(input.authority, "projection identity", "repository");
-    const fields = parseExecutionPactFields(buildMintPactFields(input));
-    const reserved = await reserveProjectionDirectory(input);
-    const pact = parseExecutionPact({
-        version: fields.version,
-        pid: fields.pid,
-        akuma: fields.akuma,
-        provider: fields.provider,
-        authority: { kind: "repository" },
-        binding: fields.binding,
-        mintedAt: fields.mintedAt,
-        workspaceRoot: fields.workspaceRoot,
-        ...(fields.effectivePolicy !== undefined ? { effectivePolicy: fields.effectivePolicy } : {}),
-    });
-    return publishReservedProjection(pact, reserved);
-}

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 */ }
-    }
-}