@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/renew.js

@@ -1,345 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { getCurrentBranch, requireGitRepository } from "../git/branches.js";
-import { ACTOR_IDENTITY } from "../keiyaku.js";
-import { resolveContractAddress, withResolvedAddress } from "./addressing.js";
-import { withContractCarrierSession } from "./contract-carrier.js";
-import { runLifecycle } from "./lifecycle-runner.js";
-import { committedLifecycleFacts, derivedCleanupFacts, isCompleteLifecycleOutcome, } from "./outcome-base.js";
-import { abortDetachedRenewChain, readDetachedRenewScratch, renewScratchName, } from "./renew-rewrite.js";
-import { scopePathEvidence } from "./scope.js";
-import { persistResponseHistory } from "./transcripts.js";
-import { admitRenew, checkCancellation, prepareRenew, sameAdmission, scopeEntry } from "./renew-plan.js";
-async function persistRenewResponse(journal, facts, persist) {
-    if (!persist)
-        return;
-    let response;
-    await journal.run({
-        effect: "response-history-persistence",
-        idempotencyKey: `${facts.contractId}:${facts.ledgerHead}:response-history-persistence`,
-        run: async () => { response = await persist(facts); return response; },
-    });
-    if (response) {
-        facts.responsePath = response.responsePath;
-        facts.artifactId = response.artifactId;
-    }
-}
-async function executeRenew(input, continuation) {
-    const execution = await runLifecycle({
-        cwd: input.cwd,
-        contractId: input.contractId,
-        mutation: {
-            verb: "renew",
-            matchesAccepted: (transaction) => {
-                const accepted = transaction.entries.at(-1);
-                const expectedAmend = scopeEntry(input);
-                if (accepted?.kind === "amend") {
-                    return transaction.entries.length === 1
-                        && expectedAmend !== null
-                        && accepted.data.amendment === expectedAmend.data.amendment
-                        && JSON.stringify(accepted.data.scopeDelta ?? null) === JSON.stringify(expectedAmend.data.scopeDelta ?? null);
-                }
-                if (accepted?.kind !== "renew")
-                    return false;
-                const acceptedAmend = transaction.entries.find((entry) => entry.kind === "amend");
-                return JSON.stringify(acceptedAmend?.kind === "amend" ? acceptedAmend.data.scopeDelta ?? null : null)
-                    === JSON.stringify(expectedAmend?.data.scopeDelta ?? null);
-            },
-        },
-        signal: input.signal,
-        ...(input.renewDeliveryProjector ? { renewDeliveryProjector: input.renewDeliveryProjector } : {}),
-        ...(input.transactionRunner ? { transactionRunner: input.transactionRunner } : {}),
-        admit: (session, replay) => admitRenew(session, input, replay, continuation?.scratch),
-        prepare: (admission) => prepareRenew(admission.business, input, continuation),
-        revalidate: async ({ session, admission }) => {
-            const current = await admitRenew(session, input, admission.replay, continuation?.scratch);
-            if (!sameAdmission(current, admission.business)) {
-                return { code: "RENEW_COORDINATES_CHANGED", message: "renew coordinates changed during detached construction" };
-            }
-        },
-        effect: async ({ context, admission, prepared }) => {
-            if (admission.business.acceptedScopeReplay) {
-                const accepted = admission.business.acceptedScopeReplay;
-                const replayed = await context.replayCommitted({ transactionObjectId: accepted.transactionObjectId });
-                const value = {
-                    ...committedLifecycleFacts({ head: accepted.transactionObjectId, entryKind: "amend", contractId: input.contractId, carrier: replayed.carrier }),
-                    contractId: input.contractId,
-                    oldBase: admission.business.oldBase,
-                    newBase: admission.business.newBase,
-                    oldHead: admission.business.oldHead,
-                    newHead: admission.business.oldHead,
-                    ledgerHead: accepted.transactionObjectId,
-                    alreadyFresh: true,
-                    sealOid: null,
-                    renewOid: null,
-                    sealed: null,
-                    carrier: replayed.carrier,
-                    targetRoot: admission.business.targetRoot,
-                };
-                await persistRenewResponse(context.journal, value, input.persistResponse);
-                return { kind: "committed", commit: replayed, entryKind: "amend", value };
-            }
-            if (admission.business.acceptedReplay) {
-                const accepted = admission.business.acceptedReplay;
-                const replayed = await context.replayCommitted({ transactionObjectId: accepted.transactionObjectId });
-                const sealed = {
-                    ...accepted.seal.data,
-                    scopeViolationEvidence: await scopePathEvidence(admission.business.targetRoot, admission.business.model.effectiveScope, accepted.seal.data.scopeAudit.violations),
-                    ledgerHead: accepted.sealObjectId,
-                };
-                const value = {
-                    ...committedLifecycleFacts({ head: accepted.transactionObjectId, entryKind: "renew", contractId: input.contractId, carrier: replayed.carrier }),
-                    contractId: input.contractId,
-                    oldBase: accepted.entry.data.oldBase,
-                    newBase: accepted.entry.data.newBase,
-                    oldHead: accepted.entry.data.oldHead,
-                    newHead: accepted.entry.data.newHead,
-                    ledgerHead: accepted.transactionObjectId,
-                    alreadyFresh: false,
-                    sealOid: accepted.sealObjectId,
-                    renewOid: accepted.renewObjectId,
-                    sealed,
-                    carrier: replayed.carrier,
-                    targetRoot: admission.business.targetRoot,
-                };
-                await persistRenewResponse(context.journal, value, input.persistResponse);
-                return { kind: "committed", commit: replayed, entryKind: "renew", value };
-            }
-            if (prepared.build?.status === "conflict") {
-                const conflict = prepared.build;
-                context.beginEffects();
-                context.journal.record({
-                    effect: "renew-conflict-scratch",
-                    idempotencyKey: `${input.contractId}:${admission.ledgerHead}:renew-conflict-scratch:${conflict.scratchName}`,
-                    status: "failed",
-                    cause: {
-                        code: "CLOSE_MERGE_CONFLICT",
-                        message: `renew conflict for ${input.contractId}`,
-                        facts: {
-                            kind: "renew_conflict_scratch",
-                            contractId: input.contractId,
-                            scratchName: conflict.scratchName,
-                            scratchPath: conflict.scratchPath,
-                            observedLedgerHead: admission.ledgerHead,
-                            deliveryRef: admission.business.deliveryRef,
-                            targetRef: admission.business.targetRef,
-                            oldBase: admission.business.oldBase,
-                            oldHead: admission.business.oldHead,
-                            newBase: admission.business.newBase,
-                            effectiveScope: admission.business.effectiveScope,
-                            conflictCommit: conflict.conflictCommit,
-                            conflictPaths: [...conflict.conflictPaths],
-                            nextAction: "continue-or-abort",
-                            authoritativeRefsChanged: false,
-                        },
-                    },
-                });
-                return { kind: "precommit-effects-only", authoritativeHead: admission.ledgerHead };
-            }
-            if (admission.business.oldBase === admission.business.newBase) {
-                if (!admission.business.amendment) {
-                    const transactionObjectId = admission.replay.state === "verb-committed"
-                        ? admission.replay.transaction.transactionObjectId
-                        : admission.replay.transactionObjectId;
-                    const replayed = await context.replayCommitted({ transactionObjectId });
-                    const accepted = replayed.transaction.entries.at(-1);
-                    if (!accepted)
-                        throw new FlowError("INTERNAL_STATE", `transaction ${transactionObjectId} has no accepted lifecycle entry`);
-                    const value = {
-                        ...committedLifecycleFacts({ head: transactionObjectId, entryKind: accepted.kind, contractId: input.contractId, carrier: replayed.carrier }),
-                        contractId: input.contractId,
-                        oldBase: admission.business.oldBase,
-                        newBase: admission.business.newBase,
-                        oldHead: admission.business.oldHead,
-                        newHead: admission.business.oldHead,
-                        ledgerHead: transactionObjectId,
-                        alreadyFresh: true,
-                        sealOid: null,
-                        renewOid: null,
-                        sealed: null,
-                        carrier: replayed.carrier,
-                        targetRoot: admission.business.targetRoot,
-                    };
-                    await persistRenewResponse(context.journal, value, input.persistResponse);
-                    return { kind: "committed", commit: replayed, entryKind: accepted.kind, value };
-                }
-                const published = await context.publishAuthoritative({
-                    verb: "renew",
-                    admittedLedgerHead: admission.ledgerHead,
-                    acceptedLifecycleTail: context.session.lifecycle.contractHead,
-                    entries: [admission.business.amendment],
-                });
-                if (published.status === "refused-before-effects")
-                    return { kind: "refused-before-effects", authoritativeHead: admission.ledgerHead, refusal: { code: "CONCURRENT_MODIFICATION", message: "repository ledger changed before scope amendment" } };
-                if (published.status === "indeterminate")
-                    return { kind: "precommit-effects-only", authoritativeHead: admission.ledgerHead };
-                const value = {
-                    ...committedLifecycleFacts({ head: published.head, entryKind: "amend", contractId: input.contractId, carrier: published.carrier }),
-                    contractId: input.contractId,
-                    oldBase: admission.business.oldBase,
-                    newBase: admission.business.newBase,
-                    oldHead: admission.business.oldHead,
-                    newHead: admission.business.oldHead,
-                    ledgerHead: published.head,
-                    alreadyFresh: true,
-                    sealOid: null,
-                    renewOid: null,
-                    sealed: null,
-                    carrier: published.carrier,
-                    targetRoot: admission.business.targetRoot,
-                };
-                await persistRenewResponse(context.journal, value, input.persistResponse);
-                return { kind: "committed", commit: published, entryKind: "amend", value };
-            }
-            if (!prepared.entry || prepared.build?.status !== "clean" || !prepared.capture)
-                throw new FlowError("INTERNAL_STATE", "renew detached build is incomplete");
-            const entries = prepared.prefix.length === 0
-                ? [prepared.entry]
-                : prepared.prefix[0].kind === "seal"
-                    ? [prepared.prefix[0], prepared.entry]
-                    : prepared.prefix.length === 1
-                        ? [prepared.entry]
-                        : [prepared.prefix[0], prepared.prefix[1], prepared.entry];
-            const published = await context.publishAuthoritative({
-                verb: "renew",
-                admittedLedgerHead: admission.ledgerHead,
-                acceptedLifecycleTail: context.session.lifecycle.contractHead,
-                entries,
-                target: {
-                    ref: admission.business.targetRef,
-                    expectedOid: prepared.entry.data.newBase,
-                },
-                delivery: {
-                    ref: admission.business.deliveryRef,
-                    expectedOid: prepared.entry.data.oldHead,
-                },
-            });
-            if (published.status === "refused-before-effects")
-                return { kind: "refused-before-effects", authoritativeHead: admission.ledgerHead, refusal: { code: "CONCURRENT_MODIFICATION", message: "repository target, ledger, or delivery ref changed before renew transaction" } };
-            if (published.status === "indeterminate")
-                return { kind: "precommit-effects-only", authoritativeHead: admission.ledgerHead };
-            const sealIndex = published.transaction.entries.findIndex((entry) => entry.kind === "seal");
-            const renewIndex = published.transaction.entries.findIndex((entry) => entry.kind === "renew");
-            const sealOid = sealIndex < 0 ? null : published.transaction.entryObjectIds[sealIndex];
-            const renewOid = renewIndex < 0 ? null : published.transaction.entryObjectIds[renewIndex];
-            const sealed = {
-                ...prepared.capture,
-                newFence: prepared.build.newHead,
-                sealedBy: "renew",
-                ledgerHead: sealOid,
-            };
-            const value = {
-                ...committedLifecycleFacts({ head: published.head, entryKind: "renew", contractId: input.contractId, carrier: published.carrier }),
-                contractId: input.contractId,
-                oldBase: admission.business.oldBase,
-                newBase: admission.business.newBase,
-                oldHead: admission.business.oldHead,
-                newHead: prepared.build.newHead,
-                ledgerHead: published.head,
-                alreadyFresh: false,
-                sealOid,
-                renewOid,
-                sealed,
-                carrier: published.carrier,
-                targetRoot: admission.business.targetRoot,
-            };
-            await persistRenewResponse(context.journal, value, input.persistResponse);
-            return { kind: "committed", commit: published, entryKind: "renew", value };
-        },
-    });
-    if (execution.kind === "noncommitted")
-        return execution.outcome;
-    if (execution.kind === "contained")
-        return { ...execution.outcome, contractId: input.contractId };
-    return { ...execution.payload, ...execution.outcome };
-}
-export async function renewContract(input) {
-    return executeRenew(input);
-}
-export async function continueRenewContract(input) {
-    const scratchName = renewScratchName(input.contractId);
-    for (let attempt = 0; attempt < 2; attempt += 1) {
-        let scratch;
-        try {
-            scratch = await readDetachedRenewScratch({ cwd: input.cwd, scratchName });
-        }
-        catch (error) {
-            throw new FlowError("RENEW_SCRATCH_NOT_FOUND", `no renew conflict scratch is open for ${input.contractId}`, { cause: error });
-        }
-        const result = await executeRenew(input, { scratch, resolution: input.resolution ?? { kind: "scratch-files" } });
-        const code = result.family === "refused-before-effects" ? result.failedInvariant.code : null;
-        if (attempt === 0 && (code === "LIFECYCLE_COORDINATES_CHANGED"
-            || code === "LIFECYCLE_REPLAY_COORDINATES_CHANGED"
-            || code === "RENEW_COORDINATES_CHANGED"
-            || code === "CONCURRENT_MODIFICATION"))
-            continue;
-        if (isCompleteLifecycleOutcome(result)) {
-            await abortDetachedRenewChain({ cwd: input.cwd, scratchName: scratch.scratchName });
-        }
-        return result;
-    }
-    throw new FlowError("INTERNAL_STATE", "bounded renew continuation retry exhausted unexpectedly");
-}
-export async function abortRenewContract(input) {
-    checkCancellation(input.signal);
-    return withContractCarrierSession({ cwd: input.cwd, contractId: input.contractId, mode: "observe-only", signal: input.signal }, async (session) => {
-        const scratchName = renewScratchName(input.contractId);
-        checkCancellation(input.signal);
-        const cleanup = await abortDetachedRenewChain({ cwd: input.cwd, scratchName });
-        if (cleanup.status === "absent") {
-            throw new FlowError("RENEW_SCRATCH_NOT_FOUND", `no renew conflict scratch is open for ${input.contractId}`);
-        }
-        return {
-            ...derivedCleanupFacts({
-                contractId: input.contractId,
-                authoritativeHead: session.pins.repositoryLedgerHead,
-                effect: "renew-conflict-scratch-cleanup",
-                receipt: { status: cleanup.status, scratchName },
-            }),
-            contractId: input.contractId,
-            scratchName,
-            carrier: session.initialCarrier,
-        };
-    });
-}
-export async function renewKeiyaku(input) {
-    await requireGitRepository(input.cwd, "renew");
-    const address = input.address ?? await resolveContractAddress(input.cwd, input.contractId, input.contractAddressSource);
-    return withResolvedAddress(address, async () => {
-        const result = await renewContract({ cwd: input.cwd, contractId: address.binding.commissionId, actor: ACTOR_IDENTITY, nowMs: Date.now(), appendScope: input.appendScope, signal: input.signal, persistResponse: renewResponsePersistence(input.cwd, address) });
-        return isCompleteLifecycleOutcome(result) ? buildRenewOutcome(address, result) : result;
-    });
-}
-function renewResponsePersistence(cwd, address) {
-    return async (facts) => {
-        const contractId = address.binding.commissionId;
-        const summary = facts.alreadyFresh ? `Contract ${contractId} is already fresh; nothing touched.` : `Contract ${contractId} renewed onto ${facts.newBase}.`;
-        return persistResponseHistory({ cwd, tool: "renew", provenance: { authority: { kind: "repository" }, binding: address.binding, evidenceCwd: cwd }, title: contractId, oldBase: facts.oldBase, newBase: facts.newBase, oldHead: facts.oldHead, newHead: facts.newHead, ledgerCommit: facts.ledgerHead, summary, emptyDiffLabel: "nothing sealed", ...(facts.sealed ? { sealed: facts.sealed } : {}) });
-    };
-}
-async function buildRenewOutcome(address, renewed) {
-    const { targetRoot, ...facts } = renewed;
-    return {
-        status: "success",
-        ...facts,
-        currentBranch: await getCurrentBranch(targetRoot),
-        baseBranch: address.target.branch.slice("refs/heads/".length),
-        diff: "",
-        sealed: renewed.sealed ?? undefined,
-        summary: renewed.alreadyFresh ? `Contract ${renewed.contractId} is already fresh; nothing touched.` : `Contract ${renewed.contractId} renewed onto ${renewed.newBase}.`,
-        address,
-    };
-}
-export async function continueRenewKeiyaku(input) {
-    await requireGitRepository(input.cwd, "renew --continue");
-    return withResolvedAddress(input.address, async () => {
-        const result = await continueRenewContract({ cwd: input.cwd, contractId: input.address.binding.commissionId, actor: ACTOR_IDENTITY, nowMs: Date.now(), appendScope: input.appendScope, signal: input.signal, persistResponse: renewResponsePersistence(input.cwd, input.address) });
-        return isCompleteLifecycleOutcome(result) ? buildRenewOutcome(input.address, result) : result;
-    });
-}
-export async function abortRenewKeiyaku(input) {
-    await requireGitRepository(input.cwd, "renew --abort");
-    return withResolvedAddress(input.address, async () => {
-        const result = await abortRenewContract({ cwd: input.cwd, contractId: input.address.binding.commissionId, signal: input.signal });
-        return { status: "success", ...result, address: input.address, summary: `Renew conflict scratch for ${result.contractId} aborted; authoritative refs were untouched.` };
-    });
-}

package/build/core/repository-ledger/accepted-fold-read.js

@@ -1,22 +0,0 @@
-import { resolveLocalBranchHead } from "../../git/refs.js";
-import { foldRepositoryLedger } from "./fold-repository.js";
-import { REPOSITORY_LEDGER_REF } from "./codec.js";
-import { repositoryLedgerHead } from "./identity.js";
-import { traverseRepositoryLedger } from "./traversal.js";
-export async function observeRepositoryLedgerHead(cwd) {
-    const head = (await resolveLocalBranchHead(cwd, REPOSITORY_LEDGER_REF))?.head;
-    return head === undefined ? null : repositoryLedgerHead(head);
-}
-/** The shared current-head typed traversal and fold used by full and targeted reads. */
-export async function readAcceptedRepositoryFold(cwd, options = {}) {
-    const observed = await (options.observeHead ?? observeRepositoryLedgerHead)(cwd);
-    if (observed === null)
-        return { observedLedgerHead: null, traversed: null, folded: null };
-    const observedLedgerHead = repositoryLedgerHead(observed);
-    const traversed = await traverseRepositoryLedger(cwd, observedLedgerHead, options.signal, { historicalSemanticEvidence: false });
-    return {
-        observedLedgerHead,
-        traversed,
-        folded: foldRepositoryLedger(traversed),
-    };
-}

package/build/core/repository-ledger/accepted-tail.js

@@ -1,116 +0,0 @@
-import { validateTransactionMembership, } from "./transaction-membership.js";
-function topologyParents(node) {
-    return node.type === "transaction" || node.type === "join" || node.type === "disease"
-        ? node.ledgerParents
-        : [];
-}
-function reachableLedgerNodes(head, nodes) {
-    const objectIds = new Set();
-    const pending = [head];
-    while (pending.length > 0) {
-        const objectId = pending.pop();
-        if (objectIds.has(objectId))
-            continue;
-        const node = nodes.get(objectId);
-        if (!node)
-            return { status: "malformed", detail: `ledger topology is missing ${objectId}` };
-        if (node.type === "lifecycle") {
-            return { status: "malformed", detail: `lifecycle entry ${objectId} occupies a ledger-topology edge` };
-        }
-        if (node.type === "disease") {
-            return { status: "malformed", detail: `diseased node ${objectId} occupies ledger topology` };
-        }
-        objectIds.add(objectId);
-        pending.push(...topologyParents(node));
-    }
-    return { status: "reachable", objectIds };
-}
-function acceptedRows(read) {
-    const rows = new Map();
-    for (const model of read.contracts) {
-        for (const row of model.history) {
-            if (rows.has(row.objectId))
-                return null;
-            rows.set(row.objectId, row);
-        }
-    }
-    return rows;
-}
-/** Resolve one immutable mutation identity from its containing transaction node. */
-export function resolveAcceptedLifecycleTransaction(input) {
-    const { read, transactionObjectId } = input;
-    if (transactionObjectId.length === 0)
-        return { status: "refused", reason: "missing", transactionObjectId };
-    const nodes = new Map();
-    for (const node of read.topology.nodes) {
-        if (nodes.has(node.objectId)) {
-            return { status: "refused", reason: "malformed", transactionObjectId, detail: `duplicate topology identity ${node.objectId}` };
-        }
-        nodes.set(node.objectId, node);
-    }
-    const node = nodes.get(transactionObjectId);
-    if (!node)
-        return { status: "refused", reason: "missing", transactionObjectId };
-    if (read.topology.head === null)
-        return { status: "refused", reason: "unreachable", transactionObjectId };
-    const reachable = reachableLedgerNodes(read.topology.head, nodes);
-    if (reachable.status === "malformed") {
-        return { status: "refused", reason: "malformed", transactionObjectId, detail: reachable.detail };
-    }
-    if (!reachable.objectIds.has(transactionObjectId)) {
-        return { status: "refused", reason: "unreachable", transactionObjectId };
-    }
-    if (node.type === "disease") {
-        return { status: "refused", reason: "malformed", transactionObjectId, detail: "transaction boundary is diseased" };
-    }
-    if (node.type !== "transaction") {
-        return { status: "refused", reason: "nonconforming", transactionObjectId, detail: "accepted identity is not a transaction node" };
-    }
-    if (node.entryObjectIds.length === 0 || node.finalEntryObjectId !== node.entryObjectIds.at(-1)) {
-        return { status: "refused", reason: "malformed", transactionObjectId, detail: "transaction has no coherent ordered final member" };
-    }
-    if (new Set(node.entryObjectIds).size !== node.entryObjectIds.length) {
-        return { status: "refused", reason: "malformed", transactionObjectId, detail: "transaction repeats a member link" };
-    }
-    if (input.expectedContract !== undefined && input.expectedContract !== node.contract) {
-        return {
-            status: "refused",
-            reason: "wrong-contract",
-            transactionObjectId,
-            expectedContract: input.expectedContract,
-            actualContract: node.contract,
-        };
-    }
-    const rows = acceptedRows(read);
-    if (!rows) {
-        return { status: "refused", reason: "malformed", transactionObjectId, detail: "accepted fold repeats an entry identity" };
-    }
-    const entries = [];
-    for (const entryObjectId of node.entryObjectIds) {
-        const row = rows.get(entryObjectId);
-        if (!row) {
-            return {
-                status: "refused",
-                reason: "nonconforming",
-                transactionObjectId,
-                detail: `transaction member ${entryObjectId} was not accepted by fold`,
-            };
-        }
-        if (row.entry.contract !== node.contract) {
-            return { status: "refused", reason: "malformed", transactionObjectId, detail: "transaction contract disagrees with an accepted member" };
-        }
-        entries.push(row.entry);
-    }
-    const validation = validateTransactionMembership(node.verb, entries);
-    if (validation.status === "invalid") {
-        return { status: "refused", reason: "nonconforming", transactionObjectId, detail: validation.detail };
-    }
-    return {
-        status: "accepted",
-        transactionObjectId,
-        predecessor: node.ledgerParents[0] ?? null,
-        contract: node.contract,
-        entryObjectIds: [...node.entryObjectIds],
-        ...validation.membership,
-    };
-}

package/build/core/repository-ledger/admission.js

@@ -1,38 +0,0 @@
-import { lookupCurrentContract, } from "./read-model.js";
-export function admitRepositoryLifecycleContract(read, contract) {
-    const outcome = lookupCurrentContract(read, contract);
-    switch (outcome.status) {
-        case "healthy":
-            return {
-                status: "healthy",
-                contract,
-                model: outcome.model,
-                diagnostics: outcome.diagnostics,
-            };
-        case "diseased":
-            return {
-                status: "diseased",
-                contract,
-                model: outcome.model,
-                diagnostics: outcome.diagnostics,
-            };
-        case "isolated":
-            return {
-                status: "isolated",
-                contract,
-                diagnostics: outcome.diagnostics,
-            };
-        case "indeterminate":
-            return {
-                status: "indeterminate",
-                contract,
-                diagnostics: outcome.diagnostics,
-            };
-        case "absent":
-            return {
-                status: "absent",
-                contract,
-                diagnostics: outcome.diagnostics,
-            };
-    }
-}

package/build/core/repository-ledger/authoritative-transaction.js

@@ -1 +0,0 @@
-export {};

package/build/core/repository-ledger/claim-evidence.js

@@ -1,147 +0,0 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { runGitProcess } from "../../git/core.js";
-import { assertReadableCommit, deriveHostGitCoordinates, readCommitObject, RepositoryObjectError, writeCommitObject, } from "./git-object-store.js";
-export class ClaimEvidenceMismatchError extends Error {
-    constructor(message, options) {
-        super(message, options);
-        this.name = "ClaimEvidenceMismatchError";
-    }
-}
-export class ClaimEvidenceOperationalError extends Error {
-    retryable = true;
-    constructor(message, options) {
-        super(message, options);
-        this.name = "ClaimEvidenceOperationalError";
-    }
-}
-function claimCommitReadError(error) {
-    if (error instanceof RepositoryObjectError &&
-        (error.reason === "commit-format" || error.reason === "object-id")) {
-        return new ClaimEvidenceMismatchError("claim merge commit has malformed persisted structure", { cause: error });
-    }
-    return new ClaimEvidenceOperationalError("cannot read claim merge commit for verification", { cause: error });
-}
-function claimCommitClosureError(error) {
-    if (error instanceof RepositoryObjectError && error.reason === "incomplete-commit-closure") {
-        return new ClaimEvidenceMismatchError("claim merge commit has incomplete persisted object closure", { cause: error });
-    }
-    return new ClaimEvidenceOperationalError("cannot verify claim merge commit object closure", { cause: error });
-}
-async function honestMergeTree(cwd, coordinates) {
-    const result = await runGitProcess(cwd, [
-        "merge-tree",
-        "--write-tree",
-        "--merge-base",
-        coordinates.base,
-        coordinates.targetHead,
-        coordinates.deliveryHead,
-    ]);
-    if (result.status !== 0 || result.error) {
-        const detail = result.stderr.trim() || result.error?.message || `exit ${String(result.status)}`;
-        throw new Error(`claim frozen three-way merge is not conflict-free: ${detail}`, { cause: result.error });
-    }
-    return result.stdout.trim();
-}
-export async function repositoryObjectDirectory(cwd, signal) {
-    const result = await runGitProcess(cwd, ["rev-parse", "--path-format=absolute", "--git-path", "objects"], { signal });
-    if (result.error?.name === "AbortError")
-        throw result.error;
-    if (result.status !== 0 || result.error || !path.isAbsolute(result.stdout.trim())) {
-        const detail = result.stderr.trim() || result.error?.message || "Git did not return an absolute object directory";
-        throw new ClaimEvidenceOperationalError(`cannot resolve repository object storage for claim verification: ${detail}`, { cause: result.error });
-    }
-    return result.stdout.trim();
-}
-async function isolatedHonestMergeTree(cwd, coordinates, objectDirectory, signal) {
-    let temporaryRoot;
-    try {
-        const repositoryObjects = objectDirectory ?? await repositoryObjectDirectory(cwd, signal);
-        temporaryRoot = await fs.mkdtemp(path.join(os.tmpdir(), "keiyaku-claim-evidence-"));
-        const temporaryObjects = path.join(temporaryRoot, "objects");
-        await fs.mkdir(temporaryObjects);
-        const result = await runGitProcess(cwd, [
-            "merge-tree",
-            "--write-tree",
-            "--merge-base",
-            coordinates.base,
-            coordinates.targetHead,
-            coordinates.deliveryHead,
-        ], {
-            env: {
-                GIT_OBJECT_DIRECTORY: temporaryObjects,
-                GIT_ALTERNATE_OBJECT_DIRECTORIES: repositoryObjects,
-            },
-            signal,
-        });
-        if (result.error?.name === "AbortError")
-            throw result.error;
-        if (result.status !== 0 || result.error || result.stdout.trim() === "") {
-            const detail = result.stderr.trim() || result.error?.message || `exit ${String(result.status)}`;
-            throw new ClaimEvidenceOperationalError(`cannot compute frozen claim merge for verification: ${detail}`, { cause: result.error });
-        }
-        return result.stdout.trim();
-    }
-    catch (error) {
-        if (error instanceof ClaimEvidenceOperationalError)
-            throw error;
-        throw new ClaimEvidenceOperationalError("cannot prepare isolated claim evidence verification", { cause: error });
-    }
-    finally {
-        if (temporaryRoot !== undefined) {
-            try {
-                await fs.rm(temporaryRoot, { recursive: true, force: true });
-            }
-            catch (error) {
-                throw new ClaimEvidenceOperationalError("cannot clean isolated claim evidence verification storage", { cause: error });
-            }
-        }
-    }
-}
-export async function buildHonestClaimMerge(input) {
-    const mergeTree = await honestMergeTree(input.cwd, input.coordinates);
-    const host = await deriveHostGitCoordinates(input.cwd);
-    const identity = { name: input.actor, email: "keiyaku@localhost", date: input.at };
-    const mergeCommit = await writeCommitObject({
-        cwd: input.cwd,
-        coordinates: host,
-        tree: mergeTree,
-        parents: [input.coordinates.targetHead, input.coordinates.deliveryHead],
-        author: identity,
-        committer: identity,
-        message: `keiyaku: claim ${input.contractId}\n\nMerge contract ${input.contractId} into ${input.coordinates.target.slice("refs/heads/".length)}.\n`,
-    });
-    await assertHonestClaimEvidence(input.cwd, { ...input.coordinates, mergeCommit });
-    return { mergeTree, mergeCommit };
-}
-export async function assertHonestClaimEvidence(cwd, evidence, readContext) {
-    let merge;
-    try {
-        const coordinates = readContext?.coordinates ?? await deriveHostGitCoordinates(cwd);
-        merge = readContext?.reader === undefined
-            ? await readCommitObject(cwd, coordinates, evidence.mergeCommit)
-            : await readContext.reader.read(evidence.mergeCommit);
-    }
-    catch (error) {
-        throw claimCommitReadError(error);
-    }
-    if (merge.parents.length !== 2 ||
-        merge.parents[0] !== evidence.targetHead ||
-        merge.parents[1] !== evidence.deliveryHead) {
-        throw new ClaimEvidenceMismatchError("claim merge commit must have exactly targetHead then deliveryHead as parents");
-    }
-    const expectedTree = await isolatedHonestMergeTree(cwd, evidence, readContext?.objectDirectory, readContext?.signal);
-    if (merge.tree !== expectedTree) {
-        throw new ClaimEvidenceMismatchError(`claim merge tree ${merge.tree} does not equal honest frozen merge tree ${expectedTree}`);
-    }
-}
-export async function assertHonestClaimEvidenceClosure(cwd, mergeCommit) {
-    try {
-        const coordinates = await deriveHostGitCoordinates(cwd);
-        await assertReadableCommit(cwd, coordinates, mergeCommit);
-    }
-    catch (error) {
-        throw claimCommitClosureError(error);
-    }
-}