@astrosheep/keiyaku 4.0.4 → 4.0.6

package/build/src/protocol/operations.js

@@ -1,31 +1,11 @@
-import { materializeIntegrationSnapshot, planIntegration, readDeliveryDiff, readDeliveryScope, worktreeChangeId, } from "../git/integration.js";
-import { captureTender, dirtyTenderDelta, dirtyTenderRefusal, materializeTenderSnapshot, prepareDeliveryCommitMetadata, } from "../git/tender.js";
-import { currentBranch, extendContractsForAdmissionAt, observeContractAt, observeContractWorld, observeContractsForAdmissionAt, } from "../git/observe.js";
-import { reconcile, reconcileBatch, reconcileObservationFailure, } from "../git/reconcile.js";
-import { NoGitWorldError, repositoryAt } from "../git/repository.js";
+import { readDeliveryDiff } from "../git/integration.js";
+import { currentBranch, observeContractAt } from "../git/observe.js";
+import { repositoryAt } from "../git/repository.js";
 import { withGitReadObservation } from "../git/read-observation.js";
-import { dependencyKeySet } from "../core/subject.js";
-import { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { activeContract, contractState, documentIsCurrent } from "../core/facts/observation.js";
-import { gate } from "../core/facts/types.js";
-import { decideAbandon } from "../core/verbs/abandon.js";
-import { decideAmend } from "../core/verbs/amend.js";
-import { decideArc } from "../core/verbs/arc.js";
-import { decideDeliver } from "../core/verbs/deliver.js";
-import { decideAttestation } from "../core/verbs/attestation.js";
-import { admitIntent, currentVerifiedAttestation, verifyDelivery, } from "./intent.js";
-import { admitPlacement, } from "./placement.js";
-import { adjudicateAuditTarget } from "../git/target-placement.js";
 import { readDocuments } from "./read/documents.js";
 import { readContractBoard, readContractObservationAt, } from "./read/status.js";
-import { admitDecidedOffer, mintAttempts } from "./attempt.js";
-import { appointmentFor, readManagedWorktreeAppointment, readPlaceRegister, } from "../workspace-place.js";
-export { bindOperation } from "./bind.js";
-export { reconcileObservationFailure } from "../git/reconcile.js";
-import { accepted, admitted, complete, } from "./outcome.js";
-const REVIEWED = gate("reviewed");
-function timestamp() { return new Date().toISOString(); }
-function mergeAdmissions(current, next) {
+export function timestamp() { return new Date().toISOString(); }
+export function mergeAdmissions(current, next) {
     const effects = [...(current.physical?.effects ?? []), ...(next.physical?.effects ?? [])];
     const lag = [...(current.physical?.lag ?? []), ...(next.physical?.lag ?? [])];
     return {
@@ -34,19 +14,15 @@ function mergeAdmissions(current, next) {
         ...(effects.length === 0 && lag.length === 0 ? {} : { physical: { effects, lag } }),
     };
 }
-function stepStop(result) {
+export function stepStop(result) {
     if (result.kind === "accepted")
         return undefined;
     return result.kind === "refused" ? { refusal: result.refusal } : { retry: result };
 }
-function verificationStop(step) {
-    return "failure" in step ? step : stepStop(step);
-}
-function unpackVerificationOutcome(verification) {
-    const stop = verificationStop(verification.step);
-    const admission = !("failure" in verification.step) && verification.step.kind === "accepted"
-        ? verification.step
-        : undefined;
+export function unpackVerificationOutcome(verification) {
+    const step = verification.step;
+    const stop = "failure" in step ? step : stepStop(step);
+    const admission = !("failure" in step) && step.kind === "accepted" ? step : undefined;
     return {
         ...(verification.cleanup === undefined ? {} : { cleanup: verification.cleanup }),
         ...(verification.leak === undefined ? {} : { leak: verification.leak }),
@@ -55,30 +31,28 @@ function unpackVerificationOutcome(verification) {
         ...(verification.counts === undefined ? {} : { counts: verification.counts }),
     };
 }
-function placementStop(result) {
+export function placementStop(result) {
     if (result.kind === "accepted")
         return undefined;
-    if (result.kind === "placement-failed") {
+    if (result.kind === "placement-failed")
         return { failure: "target-placement-failed", diagnostic: result.diagnostic };
-    }
     if (result.kind === "target-moved") {
         const { contractId, target, expected, observed } = result;
         return { failure: "target-moved", contractId, target, expected, observed };
     }
     return result.kind === "refused" ? { refusal: result.refusal } : { retry: result };
 }
-export { NoGitWorldError };
 export async function scopeOperation(input) {
-    return await repositoryAt(input.coordinate);
+    return await repositoryAt(input.coordinate, input.gitPath);
 }
 export async function currentBranchOperation(input) {
     return await currentBranch(input.scope);
 }
 export async function contractsOperation(input) {
-    return withGitReadObservation(input.scope, input.channel, readContractBoard);
+    return withGitReadObservation(input.scope, input.channel, (observation) => readContractBoard(observation, undefined, input.hereWorkspace));
 }
 export async function contractObservationOperation(input) {
-    return await readContractObservationAt(input.scope, input.channel, input.contractId);
+    return await readContractObservationAt(input.scope, input.channel, input.contractId, input.hereWorkspace);
 }
 export async function documentsOperationAt(scope, channel) {
     return withGitReadObservation(scope, channel, readDocuments);
@@ -91,605 +65,12 @@ export async function stateOperation(input) {
 }
 export async function deliveryOperation(input) {
     const state = (await observeContractAt(input.scope, input.channel, input.contractId)).state;
-    return state?.delivery?.data ?? null;
-}
-export async function deliveryDiffOperation(input) { return await readDeliveryDiff(input.scope, input.integrationPredecessor, input.integrationSnapshot); }
-async function extendPrerequisiteClosureAt(channel, observation, seeds) {
-    let current = observation;
-    const visited = new Set();
-    let pending = [...seeds];
-    while (pending.length > 0) {
-        const batch = [...new Set(pending.filter((id) => !visited.has(id)))];
-        pending = [];
-        if (batch.length === 0)
-            break;
-        current = await extendContractsForAdmissionAt(channel, current, batch);
-        for (const id of batch) {
-            visited.add(id);
-            const state = contractState(current.decision, id);
-            if (state !== null)
-                pending.push(...state.terms.after);
-        }
-    }
-    return current;
-}
-export async function amendOperation(input) {
-    const attempts = mintAttempts({ entryCount: 1 });
-    let source = input.source;
-    for (let index = 0; index < attempts.length; index += 1) {
-        let observation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
-        const state = contractState(observation.decision, input.contractId);
-        if (source === undefined && state !== null)
-            source = state.terms;
-        const amendment = source === undefined || input.deriveAmendment === undefined
-            ? undefined
-            : { source, ...input.deriveAmendment(source) };
-        if (amendment !== undefined) {
-            observation = await extendPrerequisiteClosureAt(input.channel, observation, [...new Set([...(state?.terms.after ?? []), ...amendment.terms.after])]);
-        }
-        const preparation = amendment === undefined
-            ? undefined
-            : amendment.verification.kind === "prepared"
-                ? { kind: "prepared", data: amendment.terms }
-                : { kind: "refused", refusal: amendment.verification.refusal };
-        const decision = decideAmend({
-            input: {
-                contractId: input.contractId,
-                ...(input.actor === undefined ? {} : { actor: input.actor }),
-                at: timestamp(),
-                ...(amendment === undefined ? {} : { source: amendment.source }),
-                ...(preparation === undefined ? {} : { preparation }),
-            },
-            attempt: attempts[index],
-            observation: observation.decision,
-        });
-        if (decision.kind === "refused")
-            return decision;
-        const admission = await admitDecidedOffer({
-            channel: input.channel,
-            repository: input.scope,
-            decisionObservation: observation,
-            attempt: attempts[index],
-            offer: decision.offer,
-            primaryContract: input.contractId,
-        });
-        if (admission.kind === "accepted") {
-            if (amendment === undefined)
-                throw new Error("accepted amendment is missing its document derivation");
-            return admitted(admission, amendment);
-        }
-        if (admission.kind === "publication-failed")
-            return { kind: "retry", reason: admission };
-        if (admission.kind === "collision" && index + 1 === attempts.length)
-            return { kind: "retry", reason: admission };
-    }
-    return { kind: "retry", reason: { kind: "exhausted" } };
-}
-export async function prepareDelivery(repository, stage, input) {
-    const { contractId, coordinates } = stage;
-    if (coordinates.workspace === "here" && coordinates.target !== undefined) {
-        const branch = await currentBranch(repository);
-        if (branch !== coordinates.target) {
-            return { kind: "refused", refusal: { kind: "workspace-not-on-target", contractId, target: coordinates.target, branch } };
-        }
-    }
-    const appointed = coordinates.workspace === "worktree"
-        ? stage.appointment === undefined
-            ? appointmentFor(await readPlaceRegister(repository), contractId)
-            : { contract: contractId, place: stage.appointment.place }
-        : undefined;
-    const tender = await captureTender(repository, {
-        contractId,
-        coordinates,
-        ...(appointed === undefined ? {} : { place: appointed.place }),
-    });
-    if (tender.kind === "refused")
-        return tender;
-    if ((tender.data.dirty && input.includeDirty !== true) || tender.data.changes.submodules.length > 0) {
-        return { kind: "refused", refusal: await dirtyTenderRefusal(repository, contractId, tender.data) };
-    }
-    const commit = await prepareDeliveryCommitMetadata(repository, {
-        contractId,
-        title: input.title,
-        document: input.document,
-        at: tender.data.at,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        ...(input.message === undefined ? {} : { message: input.message }),
-    });
-    const tenderSnapshot = await materializeTenderSnapshot(repository, tender.data, commit);
-    const requireBranchesToBeUpToDate = input.requireBranchesToBeUpToDate ?? false;
-    const integration = await planIntegration(repository, { contractId, coordinates }, { ...tender.data, head: tenderSnapshot }, requireBranchesToBeUpToDate);
-    if (integration.kind === "refused")
-        return integration;
-    const integrationSnapshot = coordinates.target === undefined
-        ? tenderSnapshot
-        : await materializeIntegrationSnapshot(repository, integration.data.tree, integration.data.predecessor, commit);
-    return {
-        kind: "prepared",
-        data: {
-            tenderSnapshot,
-            integration: {
-                predecessor: integration.data.predecessor,
-                snapshot: integrationSnapshot,
-                changeId: await worktreeChangeId(repository, { contractId, coordinates }, tender.data),
-            },
-            method: "squash",
-            policy: { requireBranchesToBeUpToDate },
-        },
-    };
-}
-async function captureReviewableWorktree(repository, stage) {
-    const appointed = stage.coordinates.workspace === "worktree"
-        ? appointmentFor(await readPlaceRegister(repository), stage.contractId)
-        : undefined;
-    const tender = await captureTender(repository, {
-        ...stage,
-        ...(appointed === undefined ? {} : { place: appointed.place }),
-    });
-    if (tender.kind === "refused")
-        return tender;
-    if (tender.data.changes.submodules.length > 0) {
-        return { kind: "refused", refusal: await dirtyTenderRefusal(repository, stage.contractId, tender.data) };
-    }
-    const workspace = await dirtyTenderDelta(repository, tender.data);
-    return {
-        kind: "prepared",
-        data: {
-            changeId: await worktreeChangeId(repository, stage, tender.data),
-            tender: tender.data,
-            ...(workspace === undefined ? {} : { workspace }),
-        },
-    };
-}
-export async function prepareReview(repository, stage) {
-    const prepared = await captureReviewableWorktree(repository, stage);
-    if (prepared.kind === "refused")
-        return prepared;
-    return {
-        kind: "prepared",
-        data: {
-            changeId: prepared.data.changeId,
-            ...(prepared.data.workspace === undefined ? {} : { workspace: prepared.data.workspace }),
-        },
-    };
-}
-async function deliverAttempt(input, attempt) {
-    const decisionObservation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
-    const state = contractState(decisionObservation.decision, input.contractId);
-    const derivation = state === null || input.deriveDocument === undefined
-        ? undefined
-        : input.deriveDocument(state);
-    let preparation;
-    if (state === null || derivation === undefined) {
-        preparation = { kind: "unavailable" };
-    }
-    else if (derivation.verification.kind === "refused") {
-        preparation = {
-            kind: "refused",
-            document: derivation.document,
-            refusal: derivation.verification.refusal,
-        };
-    }
-    else {
-        const prepared = await prepareDelivery(input.scope, {
-            contractId: state.id,
-            coordinates: state.coordinates,
-        }, {
-            title: derivation.title,
-            document: derivation.bytes,
-            ...(input.actor === undefined ? {} : { actor: input.actor }),
-            ...(input.message === undefined ? {} : { message: input.message }),
-            requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
-            includeDirty: input.includeDirty,
-        });
-        preparation = prepared.kind === "refused"
-            ? { kind: "refused", document: derivation.document, refusal: prepared.refusal }
-            : { kind: "prepared", document: derivation.document, data: prepared.data };
-    }
-    const decisionInput = {
-        contractId: input.contractId,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        at: timestamp(),
-        preparation,
-    };
-    const decision = decideDeliver({ input: decisionInput, attempt, observation: decisionObservation.decision });
-    if (decision.kind === "refused")
-        return { kind: "refused", refusal: decision.refusal };
-    if (preparation.kind !== "prepared") {
-        throw new Error("offered delivery is missing its mechanical preparation");
-    }
-    const admitted = await admitDecidedOffer({
-        channel: input.channel,
-        repository: input.scope,
-        decisionObservation,
-        attempt,
-        offer: decision.offer,
-        primaryContract: input.contractId,
-    });
-    if (admitted.kind === "accepted") {
-        if (derivation === undefined)
-            throw new Error("accepted delivery is missing its document derivation");
-        return { ...admitted, value: { delivery: preparation.data, derivation } };
-    }
-    return admitted;
-}
-async function completeDelivery(input, first) {
-    const derivation = first.value.derivation;
-    if (derivation.verification.kind !== "prepared") {
-        throw new Error("accepted delivery is missing its Verification preparation");
-    }
-    let admission = first;
-    let verificationValue;
-    let verificationReuse;
-    let cleanup;
-    let leak;
-    const currentVerified = currentVerifiedAttestation(first.state);
-    if (currentVerified !== undefined) {
-        verificationReuse = currentVerified;
-    }
-    else {
-        const verification = await verifyDelivery({
-            channel: input.channel,
-            repository: input.scope,
-            contractId: input.contractId,
-            ...(input.actor === undefined ? {} : { actor: input.actor }),
-            at: timestamp(),
-            state: first.state,
-            snapshot: first.value.delivery.integration.snapshot,
-            environment: process.env,
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-            ...(derivation.verification.data === null
-                ? {}
-                : { verification: derivation.verification.data }),
-        });
-        if (verification !== null) {
-            const unpacked = unpackVerificationOutcome(verification);
-            cleanup = unpacked.cleanup;
-            leak = unpacked.leak;
-            verificationValue = unpacked.stop;
-            if (unpacked.admission !== undefined)
-                admission = mergeAdmissions(admission, unpacked.admission);
-        }
-    }
-    const placement = await admitPlacement(input.channel, input.scope, first.state.coordinates.target, {
-        contractId: input.contractId,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        at: timestamp(),
-    });
-    const placementValue = placementStop(placement);
-    if (placement.kind === "accepted")
-        admission = mergeAdmissions(admission, placement);
-    return admitted(admission, {
-        ...first.value.delivery,
-        ...(verificationValue === undefined ? {} : { verification: verificationValue }),
-        ...(verificationReuse === undefined ? {} : { verificationReuse }),
-        ...(placementValue === undefined ? {} : { placement: placementValue }),
-        ...(cleanup === undefined ? {} : { cleanup }),
-        ...(leak === undefined ? {} : { leak }),
-    });
-}
-export async function deliverOperation(input) {
-    const attempts = mintAttempts({ entryCount: 2 });
-    let first = null;
-    for (let index = 0; index < attempts.length; index += 1) {
-        const result = await deliverAttempt(input, attempts[index]);
-        if (result.kind === "accepted") {
-            first = result;
-            break;
-        }
-        if (result.kind === "refused")
-            return result;
-        if (result.kind === "publication-failed")
-            return { kind: "retry", reason: result };
-        if (result.kind === "collision" && index + 1 === attempts.length)
-            return { kind: "retry", reason: result };
-        if (result.kind === "redecide")
-            continue;
-    }
-    if (first === null)
-        return { kind: "retry", reason: { kind: "exhausted" } };
-    return await completeDelivery(input, first);
-}
-export async function abandonOperation(input) {
-    return complete(await admitIntent(input.channel, input.scope, {
-        contractId: input.contractId,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        at: timestamp(),
-        ...(input.note === undefined ? {} : { note: input.note }),
-    }, decideAbandon, {
-        ...(input.decorateOffer === undefined ? {} : { decorateOffer: input.decorateOffer }),
-        ...(input.observationSelection === undefined ? {} : { observationSelection: input.observationSelection }),
-    }), undefined);
-}
-export async function arcOperation(input) {
-    return complete(await admitIntent(input.channel, input.scope, {
-        contractId: input.contractId,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        at: timestamp(),
-        data: input.chapter,
-    }, decideArc), undefined);
-}
-function reviewValue(value, placement) {
-    return {
-        ...(value.workspace === undefined ? {} : { workspace: value.workspace }),
-        ...(placement === undefined ? {} : { placement }),
-    };
-}
-async function reviewAttempt(input, attempt) {
-    const decisionObservation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
-    const state = contractState(decisionObservation.decision, input.contractId);
-    let preparation;
-    let workspace;
-    let tender;
-    if (state !== null) {
-        const prepared = await captureReviewableWorktree(input.scope, { contractId: state.id, coordinates: state.coordinates });
-        preparation = prepared.kind === "refused"
-            ? { kind: "refused", refusal: prepared.refusal }
-            : {
-                kind: "prepared",
-                data: {
-                    gate: REVIEWED,
-                    subject: dependencyKeySet([
-                        { kind: "document", value: state.terms.document.key },
-                        { kind: "change", value: prepared.data.changeId },
-                    ]),
-                    verdict: input.verdict,
-                    ...(input.summary === undefined ? {} : { summary: input.summary }),
-                },
-            };
-        if (prepared.kind === "prepared") {
-            workspace = prepared.data.workspace;
-            tender = prepared.data.tender;
-        }
-    }
-    const decisionInput = {
-        contractId: input.contractId,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        at: timestamp(),
-        ...(preparation === undefined ? {} : { preparation }),
-    };
-    const decision = decideAttestation({ input: decisionInput, attempt, observation: decisionObservation.decision });
-    if (decision.kind === "refused")
-        return { kind: "refused", refusal: decision.refusal };
-    const admitted = await admitDecidedOffer({
-        channel: input.channel,
-        repository: input.scope,
-        decisionObservation,
-        attempt,
-        offer: decision.offer,
-        primaryContract: input.contractId,
-    });
-    if (admitted.kind === "accepted")
-        return {
-            ...admitted,
-            value: {
-                ...(workspace === undefined ? {} : { workspace }),
-                ...(tender === undefined ? {} : { tender }),
-            },
-        };
-    return admitted;
-}
-export async function reviewOperation(input) {
-    const git = input.scope;
-    const attempts = mintAttempts({ entryCount: 1 });
-    let review = null;
-    for (let index = 0; index < attempts.length; index += 1) {
-        const result = await reviewAttempt(input, attempts[index]);
-        if (result.kind === "accepted" || result.kind === "refused") {
-            review = result;
-            break;
-        }
-        if (result.kind === "publication-failed")
-            return { kind: "retry", reason: result };
-        if (result.kind === "collision" && index + 1 === attempts.length)
-            return { kind: "retry", reason: result };
-    }
-    if (review === null)
-        return { kind: "retry", reason: { kind: "exhausted" } };
-    if (review.kind !== "accepted")
-        return review;
-    if (input.verdict !== "satisfied")
-        return admitted(review, reviewValue(review.value));
-    const target = review.state.coordinates.target;
-    const tender = review.value.tender;
-    const placement = await admitPlacement(input.channel, git, target, {
-        contractId: input.contractId,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        at: timestamp(),
-    }, tender === undefined || target === undefined ? undefined : async () => {
-        const integration = await planIntegration(git, {
-            contractId: input.contractId,
-            coordinates: review.state.coordinates,
-        }, tender, false);
-        if (integration.kind === "refused" && integration.refusal.kind !== "target-missing") {
-            return { kind: "refused", refusal: integration.refusal };
-        }
-        return undefined;
-    });
-    const stopped = placementStop(placement);
-    const admission = placement.kind === "accepted" ? mergeAdmissions(review, placement) : review;
-    return admitted(admission, reviewValue(review.value, stopped));
-}
-async function auditWorkspace(repository, state) {
-    if (state.coordinates.workspace === "here") {
-        return { kind: "ready", answer: { kind: "here", path: repository.effectiveCwd } };
-    }
-    const appointed = await readManagedWorktreeAppointment(repository, state.id);
-    if (appointed.kind === "failed")
-        throw new Error(appointed.diagnostic);
-    if (appointed.kind === "unappointed")
-        return appointed;
-    return {
-        kind: "ready",
-        answer: { kind: "worktree", path: appointed.path },
-        appointment: appointed,
-    };
-}
-function auditDeliveryRelation(state, candidate) {
-    const recorded = state.delivery?.data.integration.changeId;
-    if (recorded === undefined)
-        return undefined;
-    return {
-        changeId: recorded,
-        relation: recorded === candidate.integration.changeId ? "identical" : "differs",
-    };
-}
-async function auditCandidateVerification(input, state, snapshot, definition) {
-    const verification = await verifyDelivery({
-        channel: input.channel,
-        repository: input.scope,
-        contractId: input.contractId,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        at: timestamp(),
-        state,
-        snapshot,
-        environment: process.env,
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-        verification: definition,
-    });
-    if (verification === null) {
-        throw new Error("audit verification preparation unexpectedly produced no attempt");
-    }
-    return unpackVerificationOutcome(verification);
-}
-function auditVerificationAnswer(verified) {
-    if (verified === undefined)
-        return { kind: "not-run" };
-    if (verified.stop !== undefined)
-        return { kind: "stopped", stop: verified.stop };
-    if (verified.counts === undefined) {
-        throw new Error("terminal Verification is missing producer counts");
-    }
-    return {
-        kind: verified.counts.verdict,
-        passed: verified.counts.passed,
-        total: verified.counts.total,
-        ...(verified.counts.summary === undefined ? {} : { summary: verified.counts.summary }),
-    };
-}
-async function readyAuditCandidate(repository, candidate, workspace, showDiff) {
-    const predecessor = candidate.integration.predecessor;
-    const snapshot = candidate.integration.snapshot;
-    const scope = await readDeliveryScope(repository, predecessor, snapshot, showDiff);
-    const diff = showDiff ? await readDeliveryDiff(repository, predecessor, snapshot) : undefined;
-    return {
-        kind: "ready",
-        workspace,
-        identity: candidate,
-        scope,
-        ...(diff === undefined || diff === null ? {} : { diff }),
-    };
-}
-async function auditTargetAnswer(repository, state, candidate) {
-    const target = state.coordinates.target;
-    if (target === undefined)
-        return { kind: "not-observed" };
-    return await adjudicateAuditTarget(repository, {
-        contractId: state.id,
-        coordinates: { ...state.coordinates, target },
-        predecessor: candidate.integration.predecessor,
-        candidate: candidate.integration.snapshot,
-    });
-}
-function blockedAudit(refusal) {
-    return {
-        candidate: { kind: "blocked", refusal },
-        verification: { kind: "not-run" },
-        target: { kind: "not-observed" },
-    };
-}
-function completedAudit(state, verified, value) {
-    const obligations = {
-        ...(verified?.cleanup === undefined ? {} : { cleanup: verified.cleanup }),
-        ...(verified?.leak === undefined ? {} : { leak: verified.leak }),
-    };
-    return verified?.admission === undefined
-        ? accepted(state, [], value, undefined, obligations)
-        : {
-            ...admitted(verified.admission, value),
-            ...obligations,
-        };
-}
-export async function auditOperation(input) {
-    const observed = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
-    const state = activeContract(observed.decision, input.contractId);
-    if ("kind" in state)
-        return { kind: "refused", refusal: state };
-    const derivation = input.deriveDocument?.(state);
-    if (derivation === undefined || !documentIsCurrent(state, derivation.document)) {
-        return { kind: "refused", refusal: { kind: "document-moved", contractId: input.contractId } };
-    }
-    if (derivation.verification.kind === "refused") {
-        return { kind: "refused", refusal: derivation.verification.refusal };
-    }
-    const workspace = await auditWorkspace(input.scope, state);
-    if (workspace.kind === "unappointed") {
-        return accepted(state, [], blockedAudit({ kind: "worktree-missing", contractId: state.id }));
-    }
-    const prepared = await prepareDelivery(input.scope, {
-        contractId: state.id,
-        coordinates: state.coordinates,
-        ...(workspace.appointment === undefined ? {} : { appointment: workspace.appointment }),
-    }, {
-        title: derivation.title,
-        document: derivation.bytes,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate ?? false,
-        includeDirty: input.includeDirty ?? false,
-    });
-    if (prepared.kind === "refused") {
-        return accepted(state, [], blockedAudit(prepared.refusal));
-    }
-    const verified = derivation.verification.data === null
-        ? undefined
-        : await auditCandidateVerification(input, state, prepared.data.integration.snapshot, derivation.verification.data);
-    const delivery = auditDeliveryRelation(state, prepared.data);
-    const verification = auditVerificationAnswer(verified);
-    const value = {
-        candidate: await readyAuditCandidate(input.scope, prepared.data, workspace.answer, input.showDiff === true),
-        verification,
-        target: verification.kind === "stopped"
-            ? { kind: "not-observed" }
-            : await auditTargetAnswer(input.scope, state, prepared.data),
-        ...(delivery === undefined ? {} : { delivery }),
-    };
-    return completedAudit(state, verified, value);
-}
-export async function reconcileOperation(input) {
-    try {
-        const observation = await reconcile({
-            repository: input.scope,
-            channel: input.channel,
-            contractId: input.contractId,
-            hooks: input.hooks,
-            retryHooks: input.retryHooks,
-            ...(input.retainTerminalWorktree === undefined ? {} : { retainTerminalWorktree: input.retainTerminalWorktree }),
-            ...(input.place === undefined ? {} : { place: input.place }),
-        });
-        return { state: observation.state, report: observation.result };
-    }
-    catch (error) {
-        if (error instanceof AuthorityCorruptionError || error instanceof TypeError)
-            throw error;
-        return { state: null, report: reconcileObservationFailure(error) };
-    }
-}
-export async function worldContractStates(input) {
-    const observation = await withGitReadObservation(input.scope, input.channel, async (read) => await observeContractWorld(read));
-    return [...observation.contracts.values()].flatMap((value) => value.state === null ? [] : [value.state]);
-}
-export async function reconcileAllOperation(input) {
-    const git = input.scope;
-    const observation = await withGitReadObservation(input.scope, input.channel, async (read) => await observeContractWorld(read));
-    const contracts = (await reconcileBatch(git, input.channel, observation.contracts.keys(), {
-        hooks: input.hooks,
-        retryHooks: input.retryHooks,
-        retainTerminalWorktree: input.retainTerminalWorktree ?? false,
-        ...(input.places === undefined ? {} : { places: input.places }),
-    })).map((item) => ({
-        contractId: item.contract,
-        state: item.state,
-        report: item.result,
-    }));
-    return { contracts };
+    if (state === null || state === undefined || state.delivery === null)
+        return null;
+    return state.currentIntegration === null
+        ? state.delivery.data
+        : { ...state.delivery.data, integration: state.currentIntegration };
+}
+export async function deliveryDiffOperation(input) {
+    return await readDeliveryDiff(input.scope, input.integrationPredecessor, input.integrationSnapshot);
 }