@astrosheep/keiyaku 2.9.13 → 4.0.0

package/build/core/renew-plan.js

@@ -1,264 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { currentLifecycleState } from "./repository-ledger/read-model.js";
-import { buildDetachedRenewChain, continueDetachedRenewChain, renewScratchName } from "./renew-rewrite.js";
-import { hasStrandableProjectionGeneration } from "./projection/index.js";
-import { readCommitCoordinate } from "../git/commits.js";
-import { runGitProcess } from "../git/core.js";
-import { assertCleanTrackedWorkingTree } from "../git/worktree.js";
-import { normalizeScopePattern } from "./scope.js";
-import { captureFoldedRenewSeal } from "./seal.js";
-function assertOperable(contractId, model) {
-    if ((model.phase !== "active" && model.phase !== "sealed") || model.petition.state !== "none") {
-        const state = currentLifecycleState(model);
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot renew from state ${state.state}`);
-    }
-}
-export function checkCancellation(signal) {
-    if (signal?.aborted)
-        throw new FlowError("CARRIER_GATE_CANCELLED", "contract lifecycle operation cancelled before durable effects");
-}
-async function deliveryChain(cwd, oldBase, oldHead) {
-    if (oldBase === oldHead)
-        return [];
-    const result = await runGitProcess(cwd, ["rev-list", "--reverse", "--ancestry-path", `${oldBase}..${oldHead}`]);
-    if (result.status !== 0 || result.error) {
-        throw new FlowError("INTERNAL_STATE", result.stderr.trim() || result.error?.message || "cannot read renew delivery chain", { cause: result.error });
-    }
-    return result.stdout.split(/\r?\n/).filter(Boolean);
-}
-export function scopeEntry(input) {
-    const patterns = (input.appendScope ?? []).map(normalizeScopePattern);
-    return patterns.length === 0 ? null : {
-        v: 2,
-        kind: "amend",
-        contract: input.contractId,
-        at: new Date(input.nowMs).toISOString(),
-        actor: input.actor,
-        data: { amendment: "Scope extended by lifecycle command.", scopeDelta: { add: patterns } },
-    };
-}
-function effectiveScope(model, amendment) {
-    return [...model.effectiveScope, ...(amendment?.data.scopeDelta?.add ?? [])];
-}
-async function gitTree(cwd, revision) {
-    const read = await readCommitCoordinate(cwd, revision);
-    return read.status === "ok" ? read.coordinate.tree : null;
-}
-async function acceptedRenewIsReplayable(targetRoot, entry) {
-    const [index, oldTree, newTree, worktree] = await Promise.all([
-        runGitProcess(targetRoot, ["write-tree"]),
-        gitTree(targetRoot, entry.data.oldHead),
-        gitTree(targetRoot, entry.data.newHead),
-        runGitProcess(targetRoot, ["diff-files", "--quiet"]),
-    ]);
-    if (index.status !== 0 || index.error || oldTree === null || newTree === null)
-        return false;
-    const indexTree = index.stdout.trim();
-    return (indexTree === oldTree || indexTree === newTree) && worktree.status === 0 && !worktree.error;
-}
-async function acceptedRenewFromReplay(model, targetRoot, deliveryHead, targetHead, replay) {
-    if (replay.state !== "verb-committed")
-        return null;
-    const renewIndex = replay.transaction.entries.findIndex((entry) => entry.kind === "renew");
-    const sealIndex = replay.transaction.entries.findIndex((entry) => entry.kind === "seal");
-    const renew = renewIndex < 0 ? undefined : replay.transaction.entries[renewIndex];
-    const seal = sealIndex < 0 ? undefined : replay.transaction.entries[sealIndex];
-    if (renew?.kind !== "renew" ||
-        seal?.kind !== "seal" ||
-        seal.data.sealedBy !== "renew" ||
-        renew.data.newBase !== targetHead ||
-        renew.data.newHead !== deliveryHead ||
-        model.pins.base !== renew.data.newBase ||
-        model.pins.delivery !== renew.data.newHead ||
-        !await acceptedRenewIsReplayable(targetRoot, renew))
-        return null;
-    return {
-        transactionObjectId: replay.transaction.transactionObjectId,
-        renewObjectId: replay.transaction.entryObjectIds[renewIndex],
-        sealObjectId: replay.transaction.entryObjectIds[sealIndex],
-        entry: structuredClone(renew),
-        seal: structuredClone(seal),
-    };
-}
-function acceptedFreshScopeFromReplay(model, replay, expected) {
-    if (replay.state !== "verb-committed" || !expected)
-        return null;
-    const accepted = replay.transaction.entries.at(-1);
-    if (accepted?.kind !== "amend")
-        return null;
-    return accepted.data.amendment === expected.data.amendment
-        && JSON.stringify(accepted.data.scopeDelta ?? null) === JSON.stringify(expected.data.scopeDelta ?? null)
-        ? { transactionObjectId: replay.transaction.transactionObjectId, entry: structuredClone(accepted) }
-        : null;
-}
-export async function admitRenew(session, input, replay, expected) {
-    const model = session.lifecycle;
-    assertOperable(input.contractId, model);
-    if (session.target.status !== "available")
-        throw new FlowError("INTERNAL_STATE", session.target.reason);
-    const oldHead = session.pins.delivery.head;
-    const newBase = session.pins.target.head;
-    if (!oldHead || !newBase)
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} has missing delivery or target coordinates`);
-    if (session.pins.delivery.ref !== model.resources.deliveryRef || session.pins.target.ref !== model.pins.target.ref) {
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} carrier pins disagree with the lifecycle read model`);
-    }
-    const amendment = scopeEntry(input);
-    const observedLedgerHead = session.repository.observedLedgerHead;
-    if (!observedLedgerHead)
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} has no observed repository ledger head`);
-    const lifecycleHead = model.contractHead;
-    const acceptedReplay = await acceptedRenewFromReplay(model, session.target.root, oldHead, newBase, replay);
-    if (acceptedReplay) {
-        return {
-            model,
-            repository: session.repository,
-            observedLedgerHead,
-            targetRoot: session.target.root,
-            oldBase: acceptedReplay.entry.data.oldBase,
-            oldFence: acceptedReplay.seal.data.oldFence,
-            oldHead: acceptedReplay.entry.data.oldHead,
-            newBase: acceptedReplay.entry.data.newBase,
-            deliveryRef: model.resources.deliveryRef,
-            targetRef: model.pins.target.ref,
-            effectiveScope: [...model.effectiveScope],
-            amendment: null,
-            lifecycleHead,
-            acceptedReplay,
-            acceptedScopeReplay: null,
-        };
-    }
-    const acceptedScopeReplay = acceptedFreshScopeFromReplay(model, replay, amendment);
-    if (acceptedScopeReplay) {
-        return {
-            model,
-            repository: session.repository,
-            observedLedgerHead,
-            targetRoot: session.target.root,
-            oldBase: model.pins.base,
-            oldFence: model.pins.delivery,
-            oldHead,
-            newBase,
-            deliveryRef: model.resources.deliveryRef,
-            targetRef: model.pins.target.ref,
-            effectiveScope: [...model.effectiveScope],
-            amendment: null,
-            lifecycleHead,
-            acceptedReplay: null,
-            acceptedScopeReplay,
-        };
-    }
-    await assertCleanTrackedWorkingTree(session.target.root);
-    if (await hasStrandableProjectionGeneration({ cwd: session.stableRoot, commissionId: input.contractId, deliveryWorktree: session.target.root, nowMs: input.nowMs })) {
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} has a live projection that owns the delivery worktree`);
-    }
-    const scope = effectiveScope(model, amendment);
-    const admission = {
-        model,
-        repository: session.repository,
-        observedLedgerHead,
-        targetRoot: session.target.root,
-        oldBase: model.pins.base,
-        oldFence: model.pins.delivery,
-        oldHead,
-        newBase,
-        deliveryRef: model.resources.deliveryRef,
-        targetRef: model.pins.target.ref,
-        effectiveScope: scope,
-        amendment,
-        lifecycleHead,
-        acceptedReplay: null,
-        acceptedScopeReplay: null,
-    };
-    if (expected && (expected.lifecycleHead !== lifecycleHead ||
-        expected.deliveryRef !== admission.deliveryRef ||
-        expected.targetRef !== admission.targetRef ||
-        expected.oldBase !== admission.oldBase ||
-        expected.oldHead !== admission.oldHead ||
-        (JSON.stringify(expected.effectiveScope) !== JSON.stringify(model.effectiveScope)
-            && JSON.stringify(expected.effectiveScope) !== JSON.stringify(scope)))) {
-        throw new FlowError("CONCURRENT_MODIFICATION", `renew scratch coordinates no longer match ${input.contractId}`);
-    }
-    return admission;
-}
-export async function prepareRenew(admission, input, continuation) {
-    if (admission.acceptedReplay || admission.acceptedScopeReplay)
-        return { build: null, capture: null, prefix: [], entry: null };
-    if (admission.oldBase === admission.newBase) {
-        return { build: null, capture: null, prefix: admission.amendment ? [admission.amendment] : [], entry: null };
-    }
-    const build = continuation
-        ? await continueDetachedRenewChain({
-            cwd: input.cwd,
-            scratchName: continuation.scratch.scratchName,
-            resolution: continuation.resolution,
-            refresh: {
-                latestTarget: admission.newBase,
-                observedLedgerHead: admission.observedLedgerHead,
-                effectiveScope: admission.effectiveScope,
-                lifecycleHead: admission.lifecycleHead,
-            },
-            signal: input.signal,
-        })
-        : await buildDetachedRenewChain({
-            cwd: input.cwd,
-            scratchName: renewScratchName(input.contractId),
-            observedLedgerHead: admission.observedLedgerHead,
-            lifecycleHead: admission.lifecycleHead,
-            deliveryRef: admission.deliveryRef,
-            targetRef: admission.targetRef,
-            effectiveScope: admission.effectiveScope,
-            oldBase: admission.oldBase,
-            oldHead: admission.oldHead,
-            newBase: admission.newBase,
-            deliveryCommits: await deliveryChain(input.cwd, admission.oldBase, admission.oldHead),
-            signal: input.signal,
-        });
-    if (build.status === "conflict")
-        return { build, capture: null, prefix: [], entry: null };
-    const capture = await captureFoldedRenewSeal({
-        cwd: input.cwd,
-        contract: admission.model.contract,
-        intent: admission.model.intent,
-        receiptSegmentOpen: admission.model.seal === null,
-        deliveryFence: admission.model.pins.delivery,
-        effectiveScope: admission.model.effectiveScope,
-        pendingScopeOverlay: admission.amendment?.data.scopeDelta?.add ?? [],
-        receiptHead: admission.oldHead,
-        contentBase: admission.newBase,
-        contentHead: build.newHead,
-        scopePolicy: "warn",
-    });
-    if (!capture)
-        throw new FlowError("NO_OPEN_ARC", `contract ${input.contractId} has no active folded receipt segment to renew`);
-    const { scopeViolationEvidence: _scopeViolationEvidence, ...durableCapture } = capture;
-    const seal = {
-        v: 2,
-        kind: "seal",
-        contract: input.contractId,
-        at: new Date(input.nowMs).toISOString(),
-        actor: "engine",
-        data: { ...durableCapture, newFence: build.newHead, sealedBy: "renew" },
-    };
-    const entry = {
-        v: 1,
-        kind: "renew",
-        contract: input.contractId,
-        at: new Date(input.nowMs).toISOString(),
-        actor: input.actor,
-        data: { oldBase: admission.oldBase, newBase: admission.newBase, oldHead: admission.oldHead, newHead: build.newHead },
-    };
-    const prefix = admission.amendment ? [admission.amendment, seal] : [seal];
-    return { build, capture, prefix, entry };
-}
-export function sameAdmission(current, pinned) {
-    return current.observedLedgerHead === pinned.observedLedgerHead &&
-        current.oldBase === pinned.oldBase && current.oldFence === pinned.oldFence &&
-        current.oldHead === pinned.oldHead && current.newBase === pinned.newBase &&
-        current.deliveryRef === pinned.deliveryRef && current.targetRef === pinned.targetRef &&
-        current.targetRoot === pinned.targetRoot &&
-        current.lifecycleHead === pinned.lifecycleHead &&
-        JSON.stringify(current.effectiveScope) === JSON.stringify(pinned.effectiveScope) &&
-        current.acceptedReplay?.renewObjectId === pinned.acceptedReplay?.renewObjectId &&
-        current.acceptedScopeReplay?.transactionObjectId === pinned.acceptedScopeReplay?.transactionObjectId;
-}

package/build/core/renew-rewrite.js

@@ -1,118 +0,0 @@
-import { createHash } from "node:crypto";
-import { requireCommitCoordinate } from "../git/commits.js";
-import { deriveHostGitCoordinates, readCommitObject } from "./repository-ledger/git-object-store.js";
-import { stableRepoRoot } from "./worktree-path.js";
-import { assertTree, buildCommit, cleanupRenewScratch, evidenceResult, interrupted, persistConflict, readScratchState, renewScratchBase, replayFrom, replayResolvedDelivery, scratchPaths, treeFromScratchFiles, validateCoordinates, validateScratchProgress, RenewBuildError } from "./renew-build.js";
-export * from "./renew-build.js";
-export function renewScratchName(contractId) {
-    return `renew-${createHash("sha256").update(contractId).digest("hex").slice(0, 24)}`;
-}
-export async function readDetachedRenewScratch(input) {
-    const repositoryRoot = await stableRepoRoot(input.cwd);
-    const scratch = scratchPaths(await renewScratchBase(repositoryRoot), input.scratchName);
-    const state = await readScratchState(scratch);
-    const coordinates = await deriveHostGitCoordinates(repositoryRoot);
-    await assertTree(repositoryRoot, coordinates, state.conflictTree);
-    return {
-        status: "conflict",
-        ...evidenceResult(state),
-        scratchName: state.scratchName,
-        scratchPath: scratch.root,
-        filesPath: scratch.files,
-        conflictCommit: state.conflictCommit,
-        conflictPaths: [...state.conflictPaths],
-    };
-}
-export async function continueDetachedRenewChain(input) {
-    const repositoryRoot = await stableRepoRoot(input.cwd);
-    const scratchBase = await renewScratchBase(repositoryRoot);
-    const scratch = scratchPaths(scratchBase, input.scratchName);
-    const state = await readScratchState(scratch);
-    const coordinates = await deriveHostGitCoordinates(repositoryRoot);
-    await assertTree(repositoryRoot, coordinates, state.conflictTree);
-    const commits = await validateCoordinates({ ...state, cwd: repositoryRoot, coordinates });
-    await validateScratchProgress(repositoryRoot, coordinates, state, commits);
-    interrupted(input.signal);
-    const original = commits[state.nextIndex];
-    let resolvedHead;
-    let resolvedTree;
-    if (input.resolution.kind === "tree") {
-        await assertTree(repositoryRoot, coordinates, input.resolution.tree);
-        resolvedTree = input.resolution.tree;
-        resolvedHead = await buildCommit(repositoryRoot, coordinates, original, resolvedTree, state.currentHead);
-    }
-    else if (input.resolution.kind === "commit") {
-        const resolved = await readCommitObject(repositoryRoot, coordinates, input.resolution.commit);
-        if (resolved.parents.length !== 1 || resolved.parents[0] !== state.currentHead) {
-            throw new RenewBuildError("INVALID_RENEW_RESOLUTION", `resolved commit ${input.resolution.commit} must have exactly parent ${state.currentHead}`);
-        }
-        resolvedHead = input.resolution.commit;
-        resolvedTree = (await requireCommitCoordinate(repositoryRoot, resolvedHead)).tree;
-        await assertTree(repositoryRoot, coordinates, resolvedTree);
-    }
-    else {
-        resolvedTree = await treeFromScratchFiles(repositoryRoot, coordinates, scratch, state);
-        resolvedHead = await buildCommit(repositoryRoot, coordinates, original, resolvedTree, state.currentHead);
-    }
-    if (input.refresh) {
-        state.observedLedgerHead = input.refresh.observedLedgerHead;
-        state.effectiveScope = [...input.refresh.effectiveScope];
-        state.lifecycleHead = input.refresh.lifecycleHead;
-        if (input.refresh.latestTarget !== state.newBase) {
-            const resolvedPrefix = commits.slice(0, state.nextIndex + 1).map((commit, index) => ({
-                original: commit,
-                resolvedHead: index === state.nextIndex ? resolvedHead : state.evidenceMap[commit.objectId],
-            }));
-            state.newBase = input.refresh.latestTarget;
-            state.currentHead = input.refresh.latestTarget;
-            state.evidenceMap = {};
-            for (let index = 0; index < resolvedPrefix.length; index += 1) {
-                const resolved = resolvedPrefix[index];
-                const commit = await readCommitObject(repositoryRoot, coordinates, resolved.resolvedHead);
-                if (commit.parents.length !== 1) {
-                    throw new RenewBuildError("INVALID_RENEW_SCRATCH", `resolved commit ${resolved.resolvedHead} must have exactly one parent`);
-                }
-                const tree = (await requireCommitCoordinate(repositoryRoot, resolved.resolvedHead)).tree;
-                const replay = await replayResolvedDelivery({
-                    cwd: repositoryRoot,
-                    coordinates,
-                    capturedTarget: commit.parents[0],
-                    latestTarget: state.currentHead,
-                    resolvedTree: tree,
-                    identity: resolved.original,
-                });
-                if (replay.status === "conflict") {
-                    state.nextIndex = index;
-                    state.conflictTree = replay.tree;
-                    state.conflictPaths = [...replay.paths];
-                    state.conflictIndex = [...replay.index];
-                    state.conflictCommit = resolved.original.objectId;
-                    return await persistConflict(repositoryRoot, scratchBase, state, false);
-                }
-                const refreshedHead = await buildCommit(repositoryRoot, coordinates, resolved.original, replay.tree, state.currentHead);
-                state.evidenceMap[resolved.original.objectId] = refreshedHead;
-                state.currentHead = refreshedHead;
-            }
-            resolvedHead = state.currentHead;
-        }
-    }
-    state.evidenceMap[original.objectId] = resolvedHead;
-    state.currentHead = resolvedHead;
-    state.nextIndex += 1;
-    const result = await replayFrom({
-        cwd: repositoryRoot,
-        scratchBase,
-        coordinates,
-        state,
-        commits,
-        createScratch: false,
-        signal: input.signal,
-    });
-    return result;
-}
-export async function abortDetachedRenewChain(input) {
-    const repositoryRoot = await stableRepoRoot(input.cwd);
-    const scratch = scratchPaths(await renewScratchBase(repositoryRoot), input.scratchName);
-    const cleanup = await cleanupRenewScratch({ cwd: repositoryRoot, scratch });
-    return { ...cleanup, scratchName: input.scratchName };
-}