@astrosheep/keiyaku 2.9.13 → 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 "./generation/protocol.js";
-import { observeRunnerLease } from "../run-control/runner-lease.js";
-import { projectionRunnerLeasePath } from "./generation/projection-generation-identity.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 for every non-terminal generation. Launch age is
- * not lifecycle authority.
- */
-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) {
-            return {
-                compatibility: "current",
-                life: deriveProjectionLife({
-                    records,
-                    nowMs: options.nowMs,
-                }),
-                records,
-            };
-        }
-        const lock = observeRunnerLease(projectionRunnerLeasePath(projectionDirectory));
-        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,
-                runnerLease: lock.state === "held"
-                    ? "held"
-                    : lock.state === "released"
-                        ? "released"
-                        : "unknown",
-                nowMs: options.nowMs,
-            }),
-            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-mint.js

@@ -1,170 +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 { initializeRunnerLeaseDatabase } from "../run-control/runner-lease.js";
-import { projectionRunnerLeasePath } from "./generation/projection-generation-identity.js";
-import { isAkumaName } from "./akuma-name.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) {
-    if (!isAkumaName(slug)) {
-        throw new ProjectionStateError(`invalid projection slug: ${slug}`);
-    }
-    return slug;
-}
-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();
-        }
-        initializeRunnerLeaseDatabase(projectionRunnerLeasePath(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);
-}