@astrosheep/keiyaku 2.9.13 → 4.0.0

package/build/core/lifecycle-runner.js

@@ -1,377 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { withContractCarrierSession, } from "./contract-carrier.js";
-import { cancelledLifecycleFacts, committedLifecycleFacts, containedCommittedLifecycleFacts, precommitLifecycleFacts, refusedLifecycleFacts, } from "./outcome-base.js";
-import { resolveAcceptedLifecycleTransaction } from "./repository-ledger/accepted-tail.js";
-import { reconcileCommittedMutation, } from "./lifecycle-recovery.js";
-function coordinateObject(pins, target) {
-    return {
-        ledgerHead: pins.repositoryLedgerHead,
-        targetRef: pins.target.ref,
-        targetHead: pins.target.head,
-        deliveryRef: pins.delivery.ref,
-        deliveryHead: pins.delivery.head,
-        carrierTarget: target.status === "available" ? target.path : null,
-    };
-}
-function sameCoordinates(admission, session) {
-    const left = coordinateObject(admission.pins, admission.target);
-    const right = coordinateObject(session.pins, session.target);
-    return JSON.stringify(left) === JSON.stringify(right);
-}
-function validateReplayCoordinate(session, coordinate) {
-    if (coordinate.state === "bind-aligned") {
-        const currentHead = session.pins.repositoryLedgerHead;
-        if (coordinate.authoritativeHead !== currentHead) {
-            return {
-                code: "LIFECYCLE_REPLAY_COORDINATES_CHANGED",
-                message: "repository ledger head changed during lifecycle admission; retry",
-                pinned: { authoritativeHead: coordinate.authoritativeHead },
-                current: { authoritativeHead: currentHead },
-            };
-        }
-        const bindObjectId = session.lifecycle.history.find(({ entry }) => entry.kind === "bind")?.objectId ?? null;
-        return bindObjectId === coordinate.bindObjectId
-            ? undefined
-            : {
-                code: "LIFECYCLE_REPLAY_COORDINATES_CHANGED",
-                message: "typed bind coordinate changed after replay classification; retry",
-                pinned: { bindObjectId: coordinate.bindObjectId },
-                current: { bindObjectId },
-            };
-    }
-    const resolved = resolveAcceptedLifecycleTransaction({
-        read: session.repository,
-        transactionObjectId: coordinate.transaction.transactionObjectId,
-        expectedContract: session.contractId,
-    });
-    if (resolved.status === "accepted" && resolved.verb === coordinate.invokedVerb)
-        return undefined;
-    return {
-        code: "LIFECYCLE_REPLAY_COORDINATES_CHANGED",
-        message: "accepted lifecycle transaction changed after replay classification; retry",
-        pinned: {
-            transactionObjectId: coordinate.transaction.transactionObjectId,
-            verb: coordinate.invokedVerb,
-        },
-        current: {
-            status: resolved.status,
-            authoritativeHead: session.pins.repositoryLedgerHead,
-        },
-    };
-}
-function surfaceCoordinateRefusal(mutation, refusal) {
-    return mutation.coordinateChangeRefusal
-        ? { ...refusal, ...mutation.coordinateChangeRefusal }
-        : refusal;
-}
-function isCancellation(error) {
-    return error instanceof FlowError && error.code === "CARRIER_GATE_CANCELLED";
-}
-function flowRefusal(error) {
-    return {
-        code: error.code,
-        message: error.message,
-        ...(error.facts ? { facts: error.facts } : {}),
-    };
-}
-function containedCause(error) {
-    const source = error;
-    return {
-        code: typeof source?.code === "string" ? source.code : "LIFECYCLE_EFFECT_FAILED",
-        message: typeof source?.message === "string" ? source.message : String(error),
-    };
-}
-function journalContainmentCause(session) {
-    const row = session.journal.all().find((candidate) => candidate.status !== "succeeded");
-    if (!row)
-        return undefined;
-    if (row.status === "failed")
-        return row.cause;
-    return {
-        code: row.cause.code,
-        message: row.cause.message,
-        facts: { effect: row.effect, dependency: row.dependency },
-    };
-}
-/** Canonical two-admission execution shape for an existing-contract lifecycle verb. */
-export async function runLifecycle(plan) {
-    let observedHead = null;
-    let admission;
-    try {
-        const reconciliation = await reconcileCommittedMutation({
-            cwd: plan.cwd,
-            contractId: plan.contractId,
-            mutation: plan.mutation,
-            signal: plan.signal,
-        });
-        if (reconciliation.kind === "refused") {
-            return {
-                kind: "noncommitted",
-                outcome: refusedLifecycleFacts({
-                    contractId: plan.contractId,
-                    authoritativeHead: reconciliation.authoritativeHead,
-                    ...reconciliation.refusal,
-                }),
-            };
-        }
-        const attempt = await withContractCarrierSession({ cwd: plan.cwd, contractId: plan.contractId, mode: "observe-only", signal: plan.signal }, async (session) => {
-            observedHead = session.pins.repositoryLedgerHead;
-            const replayRefusal = validateReplayCoordinate(session, reconciliation.coordinate);
-            if (replayRefusal) {
-                return { kind: "refused", outcome: refusedLifecycleFacts({
-                        contractId: plan.contractId,
-                        authoritativeHead: session.pins.repositoryLedgerHead,
-                        ...surfaceCoordinateRefusal(plan.mutation, replayRefusal),
-                    }) };
-            }
-            let business;
-            try {
-                business = await plan.admit(session, reconciliation.coordinate);
-            }
-            catch (error) {
-                if (error instanceof FlowError && !isCancellation(error)) {
-                    return { kind: "refused", outcome: refusedLifecycleFacts({ contractId: plan.contractId, authoritativeHead: session.pins.repositoryLedgerHead, ...flowRefusal(error) }) };
-                }
-                throw error;
-            }
-            return {
-                kind: "admitted",
-                ledgerHead: session.pins.repositoryLedgerHead,
-                lifecycle: session.lifecycle,
-                repository: session.repository,
-                pins: session.pins,
-                target: session.target,
-                carrier: session.initialCarrier,
-                replay: reconciliation.coordinate,
-                business,
-            };
-        });
-        if (attempt.kind === "refused")
-            return { kind: "noncommitted", outcome: attempt.outcome };
-        admission = attempt;
-    }
-    catch (error) {
-        if (isCancellation(error))
-            return { kind: "noncommitted", outcome: cancelledLifecycleFacts(plan.contractId, observedHead) };
-        throw error;
-    }
-    let prepared;
-    try {
-        if (plan.signal?.aborted)
-            return { kind: "noncommitted", outcome: cancelledLifecycleFacts(plan.contractId, observedHead) };
-        prepared = await plan.prepare(admission);
-        if (plan.signal?.aborted)
-            return { kind: "noncommitted", outcome: cancelledLifecycleFacts(plan.contractId, observedHead) };
-    }
-    catch (error) {
-        if (isCancellation(error) || plan.signal?.aborted)
-            return { kind: "noncommitted", outcome: cancelledLifecycleFacts(plan.contractId, observedHead) };
-        if (error instanceof FlowError) {
-            return { kind: "noncommitted", outcome: refusedLifecycleFacts({ contractId: plan.contractId, authoritativeHead: admission.ledgerHead, ...flowRefusal(error) }) };
-        }
-        throw error;
-    }
-    try {
-        return await withContractCarrierSession({ cwd: plan.cwd, contractId: plan.contractId, mode: "mutation", signal: plan.signal, ...(plan.renewDeliveryProjector ? { renewDeliveryProjector: plan.renewDeliveryProjector } : {}), ...(plan.terminalWorkspaceCleanup ? { terminalWorkspaceCleanup: plan.terminalWorkspaceCleanup } : {}), ...(plan.transactionRunner ? { transactionRunner: plan.transactionRunner } : {}) }, async (session) => {
-            observedHead = session.pins.repositoryLedgerHead;
-            const replayRefusal = validateReplayCoordinate(session, admission.replay);
-            if (replayRefusal) {
-                return { kind: "noncommitted", outcome: refusedLifecycleFacts({
-                        contractId: plan.contractId,
-                        authoritativeHead: session.pins.repositoryLedgerHead,
-                        ...surfaceCoordinateRefusal(plan.mutation, replayRefusal),
-                    }) };
-            }
-            if (!sameCoordinates(admission, session)) {
-                return { kind: "noncommitted", outcome: refusedLifecycleFacts({
-                        contractId: plan.contractId,
-                        authoritativeHead: session.pins.repositoryLedgerHead,
-                        code: "LIFECYCLE_COORDINATES_CHANGED",
-                        message: "contract coordinates changed during lifecycle preparation",
-                        pinned: coordinateObject(admission.pins, admission.target),
-                        current: coordinateObject(session.pins, session.target),
-                    }) };
-            }
-            let refusal;
-            try {
-                refusal = await plan.revalidate({ session, admission, prepared });
-            }
-            catch (error) {
-                if (!(error instanceof FlowError) || isCancellation(error))
-                    throw error;
-                refusal = flowRefusal(error);
-            }
-            if (refusal) {
-                return { kind: "noncommitted", outcome: refusedLifecycleFacts({ contractId: plan.contractId, authoritativeHead: session.pins.repositoryLedgerHead, ...refusal }) };
-            }
-            const effectSession = Object.freeze({
-                stableRoot: session.stableRoot,
-                lifecycle: session.lifecycle,
-                pins: session.pins,
-                completeReplay: (carrier) => session.completeReplay(carrier),
-            });
-            const context = {
-                session: effectSession,
-                journal: session.journal,
-                beginEffects: () => session.beginEffects(),
-                publishAuthoritative: (authoritativeTransaction) => {
-                    const submittedTransaction = authoritativeTransaction;
-                    if (submittedTransaction.verb !== plan.mutation.verb) {
-                        throw new FlowError("INTERNAL_STATE", `${plan.mutation.verb} lifecycle effect cannot publish ${submittedTransaction.verb} authoritative transaction`);
-                    }
-                    return session.publishAuthoritative(submittedTransaction);
-                },
-                replayCommitted: (input) => session.replayCommitted(input),
-            };
-            let result;
-            try {
-                result = await plan.effect({ context, admission, prepared });
-                if (result.kind === "committed") {
-                    const replayIncomplete = session.journal.all().some((row) => row.status !== "succeeded");
-                    if (!replayIncomplete) {
-                        await session.completeReplay(plan.mutation.verb === "claim" || plan.mutation.verb === "forfeit" ? "retire" : "project");
-                        result = { ...result, commit: session.committedResult() };
-                    }
-                }
-            }
-            catch (error) {
-                if (!session.effectsStarted()) {
-                    if (error instanceof FlowError && !isCancellation(error)) {
-                        return { kind: "noncommitted", outcome: refusedLifecycleFacts({
-                                contractId: plan.contractId,
-                                authoritativeHead: session.pins.repositoryLedgerHead,
-                                ...flowRefusal(error),
-                            }) };
-                    }
-                    throw error;
-                }
-                await session.journal.run({
-                    effect: "unhandled-effect-boundary",
-                    run: () => { throw error; },
-                });
-                const committed = session.committedResult();
-                if (committed) {
-                    const ledgerCas = session.journal.rows("prerequisite").find((row) => row.effect === "ledger-cas" && row.status === "succeeded");
-                    const entryKind = ledgerCas?.status === "succeeded" && typeof ledgerCas.receipt?.entryKind === "string"
-                        ? ledgerCas.receipt.entryKind
-                        : "unknown";
-                    return {
-                        kind: "contained",
-                        outcome: containedCommittedLifecycleFacts({
-                            head: committed.head,
-                            entryKind,
-                            contractId: plan.contractId,
-                            carrier: committed.carrier,
-                            cancellationObserved: session.cancellationObserved(),
-                            prerequisites: session.journal.rows("prerequisite"),
-                            downstream: session.journal.rows("downstream"),
-                            cause: containedCause(error),
-                        }),
-                        carrier: committed.carrier,
-                    };
-                }
-                return {
-                    kind: "noncommitted",
-                    outcome: precommitLifecycleFacts({
-                        contractId: plan.contractId,
-                        authoritativeHead: session.pins.repositoryLedgerHead,
-                        journal: session.journal,
-                        cancellationObserved: session.cancellationObserved(),
-                    }),
-                };
-            }
-            if (result.kind !== "committed") {
-                const committed = session.committedResult();
-                if (committed) {
-                    const ledgerCas = session.journal.all().find((row) => row.effect === "ledger-cas" && row.status === "succeeded");
-                    const entryKind = ledgerCas?.status === "succeeded" && typeof ledgerCas.receipt?.entryKind === "string"
-                        ? ledgerCas.receipt.entryKind
-                        : "unknown";
-                    const cause = journalContainmentCause(session) ?? {
-                        code: result.kind === "refused-before-effects" ? result.refusal.code : "LIFECYCLE_RECONCILIATION_INCOMPLETE",
-                        message: result.kind === "refused-before-effects" ? result.refusal.message : "committed lifecycle reconciliation did not complete",
-                    };
-                    return {
-                        kind: "contained",
-                        outcome: containedCommittedLifecycleFacts({
-                            head: committed.head,
-                            entryKind,
-                            contractId: plan.contractId,
-                            carrier: committed.carrier,
-                            cancellationObserved: session.cancellationObserved(),
-                            prerequisites: session.journal.rows("prerequisite"),
-                            downstream: session.journal.rows("downstream"),
-                            cause,
-                        }),
-                        carrier: committed.carrier,
-                    };
-                }
-            }
-            if (result.kind === "precommit-effects-only") {
-                return {
-                    kind: "noncommitted",
-                    outcome: precommitLifecycleFacts({
-                        contractId: plan.contractId,
-                        authoritativeHead: result.authoritativeHead,
-                        journal: session.journal,
-                        cancellationObserved: session.cancellationObserved(),
-                    }),
-                };
-            }
-            if (result.kind === "refused-before-effects") {
-                if (session.effectsStarted()) {
-                    return {
-                        kind: "noncommitted",
-                        outcome: precommitLifecycleFacts({
-                            contractId: plan.contractId,
-                            authoritativeHead: result.authoritativeHead,
-                            journal: session.journal,
-                            cancellationObserved: session.cancellationObserved(),
-                        }),
-                    };
-                }
-                return { kind: "noncommitted", outcome: refusedLifecycleFacts({
-                        contractId: plan.contractId,
-                        authoritativeHead: result.authoritativeHead,
-                        ...result.refusal,
-                    }) };
-            }
-            const degraded = journalContainmentCause(session);
-            if (degraded) {
-                return {
-                    kind: "contained",
-                    outcome: containedCommittedLifecycleFacts({
-                        head: result.commit.head,
-                        entryKind: result.entryKind,
-                        contractId: plan.contractId,
-                        carrier: result.commit.carrier,
-                        cancellationObserved: result.commit.cancellationObserved,
-                        prerequisites: session.journal.rows("prerequisite"),
-                        downstream: session.journal.rows("downstream"),
-                        cause: degraded,
-                    }),
-                    carrier: result.commit.carrier,
-                };
-            }
-            return {
-                kind: "complete",
-                outcome: committedLifecycleFacts({
-                    head: result.commit.head,
-                    entryKind: result.entryKind,
-                    contractId: plan.contractId,
-                    carrier: result.commit.carrier,
-                    cancellationObserved: result.commit.cancellationObserved,
-                    prerequisites: session.journal.rows("prerequisite"),
-                    downstream: session.journal.rows("downstream"),
-                }),
-                payload: result.value,
-                carrier: result.commit.carrier,
-            };
-        });
-    }
-    catch (error) {
-        if (isCancellation(error))
-            return { kind: "noncommitted", outcome: cancelledLifecycleFacts(plan.contractId, observedHead) };
-        throw error;
-    }
-}

package/build/core/log.js

@@ -1,50 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { getConfig } from "../config/env.js";
-import { renderCurrentContractView } from "./contract-view.js";
-import { currentLifecycleState, lookupCurrentContract, readRepositoryLifecycle, } from "./repository-ledger/read-model.js";
-function amendmentWarning(model) {
-    const state = currentLifecycleState(model);
-    if (state.state === "claimed" || state.state === "forfeited")
-        return undefined;
-    const amendmentCount = model.history.filter((row) => row.entry.kind === "amend").length;
-    const threshold = getConfig().amendmentWarning.threshold;
-    return amendmentCount > threshold ? { amendmentCount, threshold } : undefined;
-}
-function unavailableLogError(contractId, outcome) {
-    return new FlowError("INTERNAL_STATE", `contract ${contractId} is unavailable because repository lifecycle evidence is ${outcome.status}`, {
-        facts: {
-            kind: "repository_lifecycle_disease",
-            contractId,
-            status: outcome.status,
-            diagnostics: outcome.diagnostics.map((diagnostic) => ({
-                objectId: diagnostic.objectId,
-                code: diagnostic.code,
-                detail: diagnostic.detail,
-                ...(diagnostic.contract === undefined ? {} : { contract: diagnostic.contract }),
-            })),
-        },
-    });
-}
-export async function readContractLog(input) {
-    const read = await readRepositoryLifecycle(input.cwd);
-    const outcome = lookupCurrentContract(read, input.contractId);
-    if (outcome.status === "absent") {
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} not found`);
-    }
-    if (outcome.status !== "healthy")
-        throw unavailableLogError(input.contractId, outcome);
-    const model = outcome.model;
-    const warning = amendmentWarning(model);
-    return {
-        contractId: input.contractId,
-        state: currentLifecycleState(model),
-        entries: model.history.map(({ entry }, index) => ({
-            index: index + 1,
-            kind: entry.kind,
-            at: entry.at,
-            actor: entry.actor,
-        })),
-        markdown: renderCurrentContractView(model, read.observedLedgerHead),
-        ...(warning ? { amendmentWarning: warning } : {}),
-    };
-}