@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/seal.js

@@ -1,364 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { requireCommitCoordinate } from "../git/commits.js";
-import { createGit, parseRevListOutput, wrapGitError } from "../git/core.js";
-import { effectiveScope } from "./lifecycle-history.js";
-import { scopePathEvidence, } from "./scope.js";
-import { isTerminalState } from "./status/lifecycle.js";
-import { currentLifecycleState, lookupCurrentContract, readRepositoryLifecycle, } from "./repository-ledger/read-model.js";
-import { runLifecycle } from "./lifecycle-runner.js";
-import { taskNamespaceFromScope } from "./task/coordinate.js";
-export { effectiveScope } from "./lifecycle-history.js";
-function findBind(entries) {
-    const bind = entries.find((entry) => entry.kind === "bind");
-    if (!bind)
-        throw new FlowError("INTERNAL_STATE", "ledger must contain bind entry");
-    return bind;
-}
-export function findOpenArc(entries) {
-    let open = null;
-    for (const entry of entries) {
-        if (entry.kind === "arc")
-            open = entry;
-        if (entry.kind === "seal" && open?.data.arc === entry.data.arc)
-            open = null;
-    }
-    return open;
-}
-export function getMaxArc(entries) {
-    return entries.reduce((max, entry) => entry.kind === "arc" ? Math.max(max, entry.data.arc) : max, 0);
-}
-export function getFence(entries) {
-    let fence = findBind(entries).data.base;
-    for (const entry of entries) {
-        if (entry.kind === "seal") {
-            fence = entry.data.newFence;
-            continue;
-        }
-        if (entry.kind === "renew")
-            fence = entry.data.newHead;
-    }
-    return fence;
-}
-export async function receiptsAfterFence(cwd, entries, head = "HEAD") {
-    return revList(cwd, getFence(entries), await resolveCommit(cwd, head));
-}
-async function resolveCommit(cwd, revision) {
-    return (await requireCommitCoordinate(cwd, revision)).commit;
-}
-async function revList(cwd, from, to) {
-    const git = createGit(cwd);
-    try {
-        return parseRevListOutput(await git.raw(["rev-list", "--reverse", `${from}..${to}`]));
-    }
-    catch (error) {
-        throw wrapGitError(`rev-list ${from}..${to}`, error, cwd);
-    }
-}
-async function changedPaths(cwd, from, to) {
-    const git = createGit(cwd);
-    try {
-        return (await git.raw(["diff", "--name-only", "-z", `${from}..${to}`]))
-            .split("\0")
-            .filter(Boolean);
-    }
-    catch (error) {
-        throw wrapGitError(`diff --name-only ${from}..${to}`, error, cwd);
-    }
-}
-async function diffstat(cwd, from, to) {
-    const git = createGit(cwd);
-    try {
-        const output = await git.raw(["diff", "--numstat", `${from}..${to}`]);
-        return output.split(/\r?\n/).reduce((total, line) => {
-            if (!line.trim())
-                return total;
-            const [added, removed] = line.split("\t");
-            total.files += 1;
-            total.insertions += Number.parseInt(added ?? "0", 10) || 0;
-            total.deletions += Number.parseInt(removed ?? "0", 10) || 0;
-            return total;
-        }, { files: 0, insertions: 0, deletions: 0 });
-    }
-    catch (error) {
-        throw wrapGitError(`diff --numstat ${from}..${to}`, error, cwd);
-    }
-}
-async function scopeViolations(cwd, paths, scope) {
-    return (await scopePathEvidence(cwd, scope, paths)).filter((evidence) => !evidence.matched);
-}
-function taskNamespaceViolations(paths, scope) {
-    const taskPaths = paths.filter((path) => path.startsWith(".keiyaku/tasks/"));
-    if (taskPaths.length === 0)
-        return [];
-    const namespaces = scope.flatMap((term) => taskNamespaceFromScope(term) ?? []);
-    if (namespaces.length !== 1) {
-        throw new FlowError("INTERNAL_STATE", "accepted bind must carry exactly one contract task namespace");
-    }
-    const prefix = `.keiyaku/tasks/${namespaces[0]}/`;
-    return taskPaths
-        .filter((path) => !path.startsWith(prefix))
-        .map((path) => ({ path, patterns: [], matched: false, outcome: "no-positive-match" }));
-}
-async function acceptedBindScope(cwd, contract) {
-    const outcome = lookupCurrentContract(await readRepositoryLifecycle(cwd), contract);
-    if (outcome.status !== "healthy") {
-        throw new FlowError("INTERNAL_STATE", `cannot resolve accepted bind namespace for contract ${contract}`);
-    }
-    const bind = outcome.model.history.find(({ entry }) => entry.kind === "bind")?.entry;
-    if (!bind || bind.kind !== "bind")
-        throw new FlowError("INTERNAL_STATE", `contract ${contract} has no accepted bind entry`);
-    return bind.data.scope;
-}
-async function auditScope(cwd, entries, paths) {
-    const scope = effectiveScope(entries);
-    const scopeViolationEvidence = [
-        ...await scopeViolations(cwd, paths, scope),
-        ...taskNamespaceViolations(paths, findBind(entries).data.scope),
-    ].filter((row, index, all) => all.findIndex((candidate) => candidate.path === row.path) === index);
-    const violations = scopeViolationEvidence.map((violation) => violation.path);
-    return {
-        scopeAudit: { violations },
-        scopeViolationEvidence,
-    };
-}
-function admitScope(contract, scope, capture, policy) {
-    if (policy === "refuse" && capture.scopeViolationEvidence.length > 0) {
-        throw new ScopeAuditError(contract, scope, capture.scopeViolationEvidence);
-    }
-    return capture;
-}
-export class ScopeAuditError extends FlowError {
-    scopeViolationEvidence;
-    constructor(_contractId, scope, evidence) {
-        const count = evidence.length;
-        const fileLabel = count === 1 ? "file" : "files";
-        super("SCOPE_VIOLATION", `scope violation — ${count} ${fileLabel} outside declared scope`, {
-            facts: {
-                kind: "scope_violation",
-                scope: [...scope],
-                violations: evidence,
-            },
-        });
-        this.name = "ScopeAuditError";
-        this.scopeViolationEvidence = evidence;
-    }
-}
-function assertOperable(contractId, model) {
-    const state = currentLifecycleState(model);
-    if (isTerminalState(state) || state.state === "petitioned") {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot seal from state ${state.state}`);
-    }
-}
-function currentFoldedSealArc(model) {
-    return model.seal === null ? model.intent.arc : null;
-}
-/** Current-read admission capture: scope and fence come only from the folded model. */
-export async function captureFoldedSeal(cwd, model, head = "HEAD", scopeAppend = [], scopePolicy) {
-    const arc = currentFoldedSealArc(model);
-    if (arc === null)
-        return null;
-    const oldFence = model.pins.delivery;
-    const newFence = await resolveCommit(cwd, head);
-    const [receipts, paths, stat] = await Promise.all([
-        revList(cwd, oldFence, newFence),
-        changedPaths(cwd, oldFence, newFence),
-        diffstat(cwd, oldFence, newFence),
-    ]);
-    const effectiveScope = [...model.effectiveScope, ...scopeAppend];
-    const bind = model.history.find((row) => row.entry.kind === "bind")?.entry;
-    const ordinaryViolations = await scopeViolations(cwd, paths, effectiveScope);
-    const namespaceViolations = taskNamespaceViolations(paths, bind?.kind === "bind" ? bind.data.scope : []);
-    if (namespaceViolations.length > 0) {
-        throw new ScopeAuditError(model.contract, effectiveScope, namespaceViolations);
-    }
-    const scopeViolationEvidence = ordinaryViolations
-        .filter((row, index, all) => all.findIndex((candidate) => candidate.path === row.path) === index);
-    const scopeAudit = admitScope(model.contract, effectiveScope, {
-        scopeAudit: { violations: scopeViolationEvidence.map((violation) => violation.path) },
-        scopeViolationEvidence,
-    }, scopePolicy);
-    return { arc, oldFence, newFence, receipts, diffstat: stat, ...scopeAudit };
-}
-/** Current seal intent: open explicit arc, else derived a0 while no explicit arc has ever existed. */
-export function currentSealArc(entries) {
-    const open = findOpenArc(entries);
-    if (open)
-        return open.data.arc;
-    if (getMaxArc(entries) === 0)
-        return 0;
-    return null;
-}
-/** Stable read-only coordinate naming the receipt source a petition would seal. */
-export function petitionSealSource(entries) {
-    return {
-        arc: currentSealArc(entries),
-        fence: getFence(entries),
-    };
-}
-/** Shared read-only owner for the seal capture and its compact changed-path evidence. */
-export async function previewSeal(cwd, entries, head = "HEAD") {
-    const arc = currentSealArc(entries);
-    if (arc === null)
-        return { capture: null, paths: [] };
-    const oldFence = getFence(entries);
-    const newFence = await resolveCommit(cwd, head);
-    const [receipts, paths, stat] = await Promise.all([
-        revList(cwd, oldFence, newFence),
-        changedPaths(cwd, oldFence, newFence),
-        diffstat(cwd, oldFence, newFence),
-    ]);
-    const scopeAudit = await auditScope(cwd, entries, paths);
-    return {
-        capture: {
-            arc,
-            oldFence,
-            newFence,
-            receipts,
-            diffstat: stat,
-            ...scopeAudit,
-        },
-        paths,
-    };
-}
-export async function captureSeal(cwd, entries, head = "HEAD") {
-    const preview = await previewSeal(cwd, entries, head);
-    if (!preview.capture)
-        return null;
-    admitScope("direct seal", effectiveScope(entries), {
-        scopeAudit: preview.capture.scopeAudit,
-        scopeViolationEvidence: preview.capture.scopeViolationEvidence,
-    }, "refuse");
-    return preview.capture;
-}
-/** Folded renew capture: preserve receipt hashes while auditing rebased delivery content. */
-export async function captureFoldedRenewSeal(input) {
-    if (!input.receiptSegmentOpen)
-        return null;
-    const arc = input.intent.arc;
-    const oldFence = input.deliveryFence;
-    const [receiptHead, contentBase, contentHead] = await Promise.all([
-        resolveCommit(input.cwd, input.receiptHead),
-        resolveCommit(input.cwd, input.contentBase),
-        resolveCommit(input.cwd, input.contentHead),
-    ]);
-    const [receipts, paths, stat] = await Promise.all([
-        revList(input.cwd, oldFence, receiptHead),
-        changedPaths(input.cwd, contentBase, contentHead),
-        diffstat(input.cwd, contentBase, contentHead),
-    ]);
-    const scope = [...input.effectiveScope, ...input.pendingScopeOverlay];
-    const bindScope = await acceptedBindScope(input.cwd, input.contract);
-    const ordinaryViolations = await scopeViolations(input.cwd, paths, scope);
-    const namespaceViolations = taskNamespaceViolations(paths, bindScope);
-    if (namespaceViolations.length > 0) {
-        throw new ScopeAuditError(input.contract, scope, namespaceViolations);
-    }
-    const scopeViolationEvidence = ordinaryViolations
-        .filter((row, index, all) => all.findIndex((candidate) => candidate.path === row.path) === index);
-    const scopeAudit = admitScope(input.contract, scope, {
-        scopeAudit: { violations: scopeViolationEvidence.map((violation) => violation.path) },
-        scopeViolationEvidence,
-    }, input.scopePolicy);
-    return {
-        arc,
-        oldFence,
-        newFence: receiptHead,
-        receipts,
-        diffstat: stat,
-        ...scopeAudit,
-    };
-}
-export async function sealCurrentArc(input) {
-    const execution = await runLifecycle({
-        cwd: input.cwd,
-        contractId: input.contractId,
-        mutation: {
-            verb: "seal",
-            matchesAccepted: (transaction) => {
-                const accepted = transaction.entries.at(-1);
-                if (transaction.entries.length !== 1 || accepted?.kind !== "seal" || accepted.data.sealedBy !== input.sealedBy)
-                    return false;
-                if (input.capture === undefined)
-                    return true;
-                if (input.capture === null)
-                    return false;
-                const { scopeViolationEvidence: _evidence, ...durableCapture } = input.capture;
-                return JSON.stringify(accepted.data) === JSON.stringify({ ...durableCapture, sealedBy: input.sealedBy });
-            },
-        },
-        signal: input.signal,
-        admit: (session, replay) => {
-            assertOperable(input.contractId, session.lifecycle);
-            if (session.target.status !== "available")
-                throw new FlowError("INTERNAL_STATE", session.target.reason);
-            const transaction = replay.state === "verb-committed" ? replay.transaction : undefined;
-            const accepted = transaction?.entries.at(-1);
-            let existing;
-            if (accepted?.kind === "seal") {
-                existing = {
-                    transactionObjectId: transaction.transactionObjectId,
-                    capture: {
-                        arc: accepted.data.arc,
-                        oldFence: accepted.data.oldFence,
-                        newFence: accepted.data.newFence,
-                        receipts: [...accepted.data.receipts],
-                        diffstat: { ...accepted.data.diffstat },
-                        scopeAudit: { violations: [...accepted.data.scopeAudit.violations] },
-                        scopeViolationEvidence: [],
-                    },
-                };
-            }
-            return { lifecycle: session.lifecycle, targetRoot: session.target.root, ...(existing ? { existing } : {}) };
-        },
-        prepare: async (admission) => {
-            if (admission.business.existing)
-                return { capture: admission.business.existing.capture, existing: { transactionObjectId: admission.business.existing.transactionObjectId } };
-            return { capture: input.capture ?? await captureFoldedSeal(admission.business.targetRoot, admission.business.lifecycle, "HEAD", [], "refuse") };
-        },
-        revalidate: ({ session, prepared }) => {
-            assertOperable(input.contractId, session.lifecycle);
-            if (prepared.existing) {
-                return session.repository.topology.nodes.some((node) => node.objectId === prepared.existing.transactionObjectId)
-                    ? undefined
-                    : { code: "SEAL_STATE_CHANGED", message: "accepted seal changed during replay preparation" };
-            }
-            if (!prepared.capture)
-                return;
-            const currentArc = currentFoldedSealArc(session.lifecycle);
-            if (currentArc !== prepared.capture.arc || session.lifecycle.pins.delivery !== prepared.capture.oldFence)
-                return { code: "SEAL_COORDINATES_CHANGED", message: `contract ${input.contractId} changed while sealing arc a${prepared.capture.arc}` };
-        },
-        effect: async ({ context, prepared }) => {
-            const capture = prepared.capture;
-            if (!capture)
-                return { kind: "refused-before-effects", authoritativeHead: context.session.pins.repositoryLedgerHead, refusal: { code: "NO_OPEN_ARC", message: "no current arc requires sealing" } };
-            const at = new Date(input.nowMs).toISOString();
-            {
-                const { scopeViolationEvidence: _scopeViolationEvidence, ...durableCapture } = capture;
-                const entry = {
-                    v: 2,
-                    kind: "seal",
-                    contract: input.contractId,
-                    at,
-                    actor: "engine",
-                    data: { ...durableCapture, sealedBy: input.sealedBy },
-                };
-                const result = prepared.existing
-                    ? await context.replayCommitted({ transactionObjectId: prepared.existing.transactionObjectId })
-                    : await context.publishAuthoritative({ verb: "seal", admittedLedgerHead: context.session.pins.repositoryLedgerHead, acceptedLifecycleTail: context.session.lifecycle.contractHead, entries: [entry] });
-                if (result.status === "indeterminate")
-                    return { kind: "precommit-effects-only", authoritativeHead: result.currentHead ?? context.session.pins.repositoryLedgerHead };
-                if (result.status !== "committed")
-                    return { kind: "refused-before-effects", authoritativeHead: result.currentHead ?? context.session.pins.repositoryLedgerHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed while sealing` } };
-                return { kind: "committed", commit: result, entryKind: "seal", value: {
-                        ...capture,
-                        sealedBy: input.sealedBy,
-                        ledgerHead: result.transaction.entryObjectIds[result.transaction.entries.findIndex((candidate) => candidate.kind === "seal")],
-                    } };
-            }
-        },
-    });
-    if (execution.kind === "noncommitted" || execution.kind === "contained")
-        return execution.outcome;
-    return execution.payload;
-}

package/build/core/settlement/claim-delivery.js

@@ -1,82 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { createGit, runGitProcess } from "../../git/core.js";
-import { readCommitCoordinate, shortCommitHash } from "../../git/commits.js";
-import { assertHonestClaimEvidence, buildHonestClaimMerge, } from "../repository-ledger/claim-evidence.js";
-async function successfulGit(cwd, args, input) {
-    const result = await runGitProcess(cwd, args, input === undefined ? undefined : { input });
-    if (result.status !== 0 || result.error) {
-        const detail = result.stderr.trim() || result.error?.message || `exit ${String(result.status)}`;
-        throw new FlowError(args[0] === "merge-tree" ? "CLOSE_MERGE_CONFLICT" : "INTERNAL_STATE", `git ${args.join(" ")} failed: ${detail}`, { cause: result.error });
-    }
-    return result.stdout.trim();
-}
-/** Build unreachable claim objects using only the approved frozen coordinates. */
-export async function buildClaimLanding(input) {
-    try {
-        const built = await buildHonestClaimMerge(input);
-        return { ...input.coordinates, ...built };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new FlowError(message.includes("not conflict-free") ? "CLOSE_MERGE_CONFLICT" : "INTERNAL_STATE", message, { cause: error });
-    }
-}
-export async function resolveCommit(cwd, rev) {
-    const read = await readCommitCoordinate(cwd, rev);
-    if (read.status === "ok")
-        return read.coordinate.commit;
-    if (read.status === "failed") {
-        const detail = read.result.stderr.trim() || read.error.message || `exit ${String(read.result.status)}`;
-        throw new FlowError("INTERNAL_STATE", `git rev-parse ${rev} failed: ${detail}`, { cause: read.error });
-    }
-    if (read.status === "malformed") {
-        throw new FlowError("INTERNAL_STATE", `git rev-parse ${rev} failed: ${read.detail}`);
-    }
-    throw new FlowError("INTERNAL_STATE", `git rev-parse ${rev} failed: revision does not resolve to a commit`);
-}
-export async function resolveCommitOrNull(cwd, rev) {
-    const read = await readCommitCoordinate(cwd, rev);
-    if (read.status === "ok")
-        return read.coordinate.commit;
-    if (read.status === "missing" || read.status === "non-commit")
-        return null;
-    if (read.status === "malformed") {
-        throw new FlowError("INTERNAL_STATE", `git rev-parse ${rev} failed: ${read.detail}`);
-    }
-    const detail = read.result.stderr.trim() || read.error.message || `exit ${String(read.result.status)}`;
-    throw new FlowError("INTERNAL_STATE", `git rev-parse ${rev} failed: ${detail}`, { cause: read.error });
-}
-/** Prove parent order and tree identity independently of mutable refs. */
-export async function proveClaimLanding(cwd, landing) {
-    await assertHonestClaimEvidence(cwd, landing);
-}
-/** Display path for preview cleanup effects; delivery owns path mechanics. */
-export function relativeDisplayPath(from, to) {
-    return (to.startsWith(from) ? to.slice(from.length).replace(/^\//, "") : to) || ".";
-}
-async function findWorktreePathForRef(cwd, target) {
-    const output = await successfulGit(cwd, ["worktree", "list", "--porcelain", "-z"]);
-    let worktree;
-    for (const field of output.split("\0")) {
-        if (field.startsWith("worktree "))
-            worktree = field.slice("worktree ".length);
-        if (field === `branch ${target}`)
-            return worktree;
-    }
-    return undefined;
-}
-/** Align a checked-out target after the atomic claim. Failure leaves authority intact. */
-export async function replayClaimTargetWorktree(cwd, landing) {
-    const worktree = await findWorktreePathForRef(cwd, landing.target);
-    if (!worktree)
-        return [];
-    try {
-        await createGit(worktree).raw(["read-tree", "-m", "-u", landing.targetHead, landing.mergeCommit]);
-        return [];
-    }
-    catch {
-        return [
-            `Target worktree ${worktree} remains behind after claim advanced '${landing.target.slice("refs/heads/".length)}' to ${shortCommitHash(landing.mergeCommit)}.`,
-        ];
-    }
-}