@astrosheep/keiyaku 4.5.20 → 4.5.21

package/build/src/protocol/reintegrate.js

@@ -5,6 +5,7 @@ import { observeContractsForAdmissionAt } from "../git/observe.js";
 import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, withPrivateStatePublicationSeat, } from "../git/private-state-seat.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { timestamp } from "./operations.js";
+import { contractStateWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
 import { runUnderTargetPlacementFence } from "./placement.js";
 function reintegrationResultWithSeatClose(outcome) {
     return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
@@ -13,38 +14,59 @@ function reintegrationResultWithSeatClose(outcome) {
         return { ...value, seatClose: appendPrivateStateSeatClose(value.seatClose, closeLag) };
     });
 }
+/** Plan and materialize the target-specific reintegration artifacts outside the publication seat. */
+async function prepareExternalReintegration(input) {
+    const observation = await observeContractsForAdmissionAt(input.repository, input.channel, [input.contractId]);
+    const state = contractState(observation.decision, input.contractId);
+    if (state === null)
+        return { kind: "unavailable" };
+    return {
+        kind: "artifacts",
+        witness: contractStateWitness(state),
+        artifacts: await planReintegrationArtifacts(input, state),
+    };
+}
+async function planReintegrationArtifacts(input, state) {
+    if (state.delivery === null || state.currentIntegration === null)
+        return { kind: "defer" };
+    const planned = await planIntegration(input.repository, { contractId: input.contractId, coordinates: state.coordinates }, await persistedTender(input.repository, state.delivery.data.tenderSnapshot), state.delivery.data.policy.requireBranchesToBeUpToDate);
+    if (planned.kind === "refused")
+        return { kind: "refused", refusal: planned.refusal };
+    const snapshot = await materializeReintegrationSnapshot(input.repository, planned.data.tree, planned.data.predecessor, state.delivery.data.integration.snapshot);
+    return {
+        kind: "prepared",
+        data: { predecessor: planned.data.predecessor, snapshot },
+        assertion: { ref: input.target, oid: planned.data.predecessor },
+    };
+}
+/** Assemble the decision input from the fresh Contract; spent artifacts restart the whole cycle. */
+function assembleReintegrationAttempt(input, observation, external) {
+    const state = contractState(observation.decision, input.contractId);
+    if (state === null) {
+        return external.kind === "unavailable"
+            ? { kind: "unavailable", refusal: { kind: "contract-missing", contractId: input.contractId } }
+            : STALE_PRIVATE_STATE_PREPARATION;
+    }
+    if (external.kind === "unavailable")
+        return STALE_PRIVATE_STATE_PREPARATION;
+    if (external.witness.head !== state.head)
+        return STALE_PRIVATE_STATE_PREPARATION;
+    if (state.delivery === null || state.currentIntegration === null) {
+        return { kind: "unavailable", refusal: { kind: "delivery-missing", contractId: input.contractId } };
+    }
+    return external.artifacts.kind === "defer" ? STALE_PRIVATE_STATE_PREPARATION : external.artifacts;
+}
 async function runReintegration(input) {
-    return reintegrationResultWithSeatClose(await withPrivateStatePublicationSeat(input.repository, async (seat) => {
-        const attempts = mintAttempts({ entryCount: 1 });
-        for (let index = 0; index < attempts.length; index += 1) {
-            const attempt = attempts[index];
+    const attempts = mintAttempts({ entryCount: 1 });
+    for (let index = 0; index < attempts.length; index += 1) {
+        const attempt = attempts[index];
+        const external = await prepareExternalReintegration(input);
+        const result = reintegrationResultWithSeatClose(await withPrivateStatePublicationSeat(input.repository, async (seat) => {
             const observation = await observeContractsForAdmissionAt(input.repository, input.channel, [input.contractId]);
-            const state = contractState(observation.decision, input.contractId);
-            let preparation;
-            let assertions = [];
-            if (state === null || state.delivery === null || state.currentIntegration === null) {
-                preparation = {
-                    kind: "refused",
-                    refusal: {
-                        kind: state === null ? "contract-missing" : "delivery-missing",
-                        contractId: input.contractId,
-                    },
-                };
-            }
-            else {
-                const planned = await planIntegration(input.repository, { contractId: input.contractId, coordinates: state.coordinates }, await persistedTender(input.repository, state.delivery.data.tenderSnapshot), state.delivery.data.policy.requireBranchesToBeUpToDate);
-                if (planned.kind === "refused") {
-                    preparation = planned;
-                }
-                else {
-                    const snapshot = await materializeReintegrationSnapshot(input.repository, planned.data.tree, planned.data.predecessor, state.delivery.data.integration.snapshot);
-                    preparation = {
-                        kind: "prepared",
-                        data: { predecessor: planned.data.predecessor, snapshot },
-                    };
-                    assertions = [{ ref: input.target, oid: planned.data.predecessor }];
-                }
-            }
+            const assembled = assembleReintegrationAttempt(input, observation, external);
+            if (assembled.kind === "stale")
+                return assembled;
+            const preparation = assembled.kind === "unavailable" ? { kind: "refused", refusal: assembled.refusal } : assembled;
             const decision = decideReintegrate({
                 input: {
                     contractId: input.contractId,
@@ -57,7 +79,7 @@ async function runReintegration(input) {
             });
             if (decision.kind === "refused")
                 return { kind: "refused", refusal: decision.refusal };
-            const result = await admitDecidedOffer({
+            const admitted = await admitDecidedOffer({
                 channel: input.channel,
                 repository: input.repository,
                 seat,
@@ -65,21 +87,26 @@ async function runReintegration(input) {
                 attempt,
                 offer: decision.offer,
                 primaryContract: input.contractId,
-                ...(input.progress === undefined ? {} : input.progress === undefined ? {} : { progress: input.progress }),
-                assertions,
+                ...(input.progress === undefined ? {} : { progress: input.progress }),
+                ...(assembled.kind === "prepared" ? { assertions: [assembled.assertion] } : {}),
             });
-            if (result.kind === "accepted") {
-                if (preparation.kind !== "prepared")
+            if (admitted.kind === "accepted") {
+                if (assembled.kind !== "prepared")
                     throw new Error("accepted reintegration has no preparation");
-                return { ...result, value: preparation.data };
+                return { ...admitted, value: assembled.data };
             }
-            if (result.kind === "publication-failed")
-                return { kind: "retry", reason: result };
-            if (result.kind === "collision" && index + 1 === attempts.length)
-                return { kind: "retry", reason: result };
-        }
-        return { kind: "retry", reason: { kind: "exhausted" } };
-    }));
+            return admitted;
+        }));
+        if (result.kind === "accepted" || result.kind === "refused")
+            return result;
+        if (result.kind === "stale" || result.kind === "redecide")
+            continue;
+        if (result.kind === "publication-failed")
+            return { kind: "retry", reason: result };
+        if (result.kind === "collision" && index + 1 === attempts.length)
+            return { kind: "retry", reason: result };
+    }
+    return { kind: "retry", reason: { kind: "exhausted" } };
 }
 export async function reintegrateOperation(input) {
     return await runUnderTargetPlacementFence(input.repository, input.target, async () => await runReintegration(input));

package/build/src/protocol/result-codec.js

@@ -109,10 +109,10 @@ export function decodeDeliverConflictRefusal(value) {
     const object = record(value, ["kind", "contractId", "reason", "targetHead", "conflictPaths", "recovery"]);
     if (object.kind !== "integration-failed" || object.reason !== "conflict")
         fail();
-    const recovery = record(object.recovery, ["materialize", "continue", "staging"]);
+    const recovery = record(object.recovery, ["materialize", "deliver", "staging"]);
     if (recovery.materialize !== "deliver --materialize-conflict --include-dirty")
         fail();
-    if (recovery.continue !== "deliver --include-dirty")
+    if (recovery.deliver !== "deliver --include-dirty")
         fail();
     if (recovery.staging !== "not-required")
         fail();
@@ -124,7 +124,7 @@ export function decodeDeliverConflictRefusal(value) {
         conflictPaths: strings(object.conflictPaths),
         recovery: {
             materialize: "deliver --materialize-conflict --include-dirty",
-            continue: "deliver --include-dirty",
+            deliver: "deliver --include-dirty",
             staging: "not-required",
         },
     };
@@ -299,9 +299,11 @@ export function decodeVerificationCleanupFailure(value) {
     return { phase: "destroy", name: nonblank(object.name), detail: decodeHookFailure(object.detail) };
 }
 export function decodeCandidateCompletion(value) {
-    const object = record(value, ["integration"], ["verification"]);
+    const object = record(value, ["integration"], ["predecessor", "target", "verification"]);
     const completion = {
         integration: decodeSnapshotId(object.integration),
+        ...(object.predecessor === undefined ? {} : { predecessor: decodeSnapshotId(object.predecessor) }),
+        ...(object.target === undefined ? {} : { target: nonblank(object.target) }),
         ...(object.verification === undefined
             ? {}
             : {
@@ -339,10 +341,10 @@ export function decodeMaterializedConflict(value) {
     const object = record(value, ["kind", "targetHead", "conflictPaths", "workspace", "handoffBase", "recovery"]);
     if (object.kind !== "integration-conflict-materialized")
         fail();
-    const recovery = record(object.recovery, ["materialize", "continue", "staging"]);
+    const recovery = record(object.recovery, ["materialize", "deliver", "staging"]);
     if (recovery.materialize !== "deliver --materialize-conflict --include-dirty")
         fail();
-    if (recovery.continue !== "deliver --include-dirty")
+    if (recovery.deliver !== "deliver --include-dirty")
         fail();
     if (recovery.staging !== "not-required")
         fail();
@@ -354,7 +356,7 @@ export function decodeMaterializedConflict(value) {
         handoffBase: decodeSnapshotId(object.handoffBase),
         recovery: {
             materialize: "deliver --materialize-conflict --include-dirty",
-            continue: "deliver --include-dirty",
+            deliver: "deliver --include-dirty",
             staging: "not-required",
         },
     };

package/build/src/protocol/review.js

@@ -2,7 +2,7 @@ import { worktreeChangeId } from "../git/integration.js";
 import { captureTender, dirtyTenderDelta, dirtyTenderRefusal, } from "../git/tender.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
 import { unmergedWorkspacePaths, worktreePath } from "../git/workspace.js";
-import { matchingPrivateRootObservation, privateStateSeatAttempt, sameSpeculativeWorktreeInput, } from "./run.js";
+import { contractStateWitness, privateStateSeatAttempt, sameWorktreeWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
 import { dependencyKeySet } from "../core/subject.js";
 import { contractState } from "../core/facts/observation.js";
 import { gate } from "../core/facts/types.js";
@@ -58,14 +58,14 @@ export async function prepareReview(repository, stage) {
         },
     };
 }
-function preparedReviewCapture(input, state, prepared) {
+function preparedReviewCapture(input, state, changeId) {
     return {
         kind: "prepared",
         data: {
             gate: REVIEWED,
             subject: dependencyKeySet([
                 { kind: "document", value: state.terms.document.key },
-                { kind: "change", value: prepared.data.changeId },
+                { kind: "change", value: changeId },
             ]),
             verdict: input.verdict,
             ...(input.summary === undefined ? {} : { summary: input.summary }),
@@ -88,32 +88,56 @@ async function recaptureReviewWorktree(input, state) {
     });
     return prepared.kind === "prepared" ? reviewWorktreeInput(prepared) : undefined;
 }
-async function speculateReview(input) {
+/** Capture the reviewable worktree from one non-authoritative private-state read. */
+async function prepareExternalReview(input) {
     const observation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
     const state = contractState(observation.decision, input.contractId);
     if (state === null)
-        return { observation };
+        return { kind: "unavailable" };
     const prepared = await captureReviewableWorktree(input.scope, {
         contractId: state.id,
         coordinates: state.coordinates,
     });
-    if (prepared.kind === "refused") {
-        return { observation, preparation: { kind: "refused", refusal: prepared.refusal } };
+    return {
+        kind: "artifacts",
+        witness: contractStateWitness(state),
+        artifacts: prepared.kind === "refused"
+            ? { kind: "refused", refusal: prepared.refusal }
+            : {
+                kind: "captured",
+                ...(prepared.data.workspace === undefined ? {} : { workspace: prepared.data.workspace }),
+                worktree: reviewWorktreeInput(prepared),
+            },
+    };
+}
+/** Assemble the in-custody attestation input from the fresh Contract and validated artifacts. */
+async function assembleReviewAttempt(input, observation, external) {
+    const state = contractState(observation.decision, input.contractId);
+    if (external.kind === "unavailable")
+        return state === null ? { kind: "assembled" } : { kind: "stale" };
+    if (state === null)
+        return { kind: "stale" };
+    if (external.witness.head !== state.head)
+        return { kind: "stale" };
+    if (external.artifacts.kind === "refused") {
+        return { kind: "assembled", preparation: { kind: "refused", refusal: external.artifacts.refusal } };
+    }
+    if (!sameWorktreeWitness(external.artifacts.worktree, await recaptureReviewWorktree(input, state))) {
+        return { kind: "stale" };
     }
     return {
-        observation,
-        preparation: preparedReviewCapture(input, state, prepared),
-        ...(prepared.data.workspace === undefined ? {} : { workspace: prepared.data.workspace }),
-        worktree: reviewWorktreeInput(prepared),
+        kind: "assembled",
+        preparation: preparedReviewCapture(input, state, external.artifacts.worktree.changeId),
+        ...(external.artifacts.workspace === undefined ? {} : { workspace: external.artifacts.workspace }),
     };
 }
-async function decideAndAdmitReview(input, attempt, seat, observation, speculated) {
+async function decideAndAdmitReview(input, attempt, seat, observation, assembled) {
     const decision = decideAttestation({
         input: {
             contractId: input.contractId,
             ...(input.actor === undefined ? {} : { actor: input.actor }),
             at: timestamp(),
-            ...(speculated.preparation === undefined ? {} : { preparation: speculated.preparation }),
+            ...(assembled.preparation === undefined ? {} : { preparation: assembled.preparation }),
         },
         attempt,
         observation: observation.decision,
@@ -128,33 +152,30 @@ async function decideAndAdmitReview(input, attempt, seat, observation, speculate
         attempt,
         offer: decision.offer,
         primaryContract: input.contractId,
-        ...(input.progress === undefined ? {} : input.progress === undefined ? {} : { progress: input.progress }),
+        ...(input.progress === undefined ? {} : { progress: input.progress }),
     });
     if (admission.kind !== "accepted")
         return admission;
     return {
         ...admission,
         value: {
-            ...(speculated.workspace === undefined ? {} : { workspace: speculated.workspace }),
+            ...(assembled.workspace === undefined ? {} : { workspace: assembled.workspace }),
         },
     };
 }
-async function reviewAttemptInPrivateStateSeat(input, attempt, seat, speculated) {
-    const observation = await matchingPrivateRootObservation(input.scope, input.channel, input.contractId, speculated.observation, async (fresh) => {
-        if (speculated.worktree === undefined)
-            return true;
-        const state = contractState(fresh.decision, input.contractId);
-        if (state === null)
-            return false;
-        return sameSpeculativeWorktreeInput(speculated.worktree, await recaptureReviewWorktree(input, state));
-    });
-    return "kind" in observation
-        ? observation
-        : await decideAndAdmitReview(input, attempt, seat, observation, speculated);
-}
+/**
+ * One review attempt: the repeatable worktree capture happens outside custody, then a single
+ * in-custody observation, witness validation, subject assembly, decision, and publication.
+ */
 async function reviewAttempt(input, attempt) {
-    const speculated = await speculateReview(input);
-    return await privateStateSeatAttempt(input.scope, async (seat) => await reviewAttemptInPrivateStateSeat(input, attempt, seat, speculated), attemptDecisionWithSeatClose);
+    const external = await prepareExternalReview(input);
+    return await privateStateSeatAttempt(input.scope, async (seat) => {
+        const observation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
+        const assembled = await assembleReviewAttempt(input, observation, external);
+        if (assembled.kind === "stale")
+            return STALE_PRIVATE_STATE_PREPARATION;
+        return await decideAndAdmitReview(input, attempt, seat, observation, assembled);
+    }, attemptDecisionWithSeatClose);
 }
 export async function admitReviewOperation(input) {
     const attempts = mintAttempts({ entryCount: 1 });
@@ -167,6 +188,8 @@ export async function admitReviewOperation(input) {
         }
         if (result.kind === "publication-failed")
             return { kind: "retry", reason: result };
+        if (result.kind === "stale" || result.kind === "redecide")
+            continue;
         if (result.kind === "collision" && index + 1 === attempts.length)
             return { kind: "retry", reason: result };
     }

package/build/src/protocol/run.d.ts

@@ -3,15 +3,14 @@ import { type GitDecisionObservation } from "../git/observe.js";
 import { type PrivateStatePublicationSeat, type PrivateStateSeatOutcome } from "../git/private-state-seat.js";
 import type { GitDecodeChannel, GitTreeSelection } from "../git/read-observation.js";
 import type { GitRepository } from "../git/process.js";
-import { type GitOid, type GitRefAssertion } from "../git/repository.js";
+import { type GitRefAssertion } from "../git/repository.js";
 import type { AttemptContext, DecideInput, OfferDecision } from "../core/decide.js";
 import type { Offer, TreeUpdate } from "../core/facts/offer.js";
-import { type ChangeId, type ContractId, type SnapshotId } from "../core/facts/types.js";
-import { type AcceptedAdmission, type AttemptTerminal } from "./attempt.js";
+import type { ChangeId, ContractHead, ContractId, SnapshotId } from "../core/facts/types.js";
 import type { GitObjectId } from "../git/identity.js";
+import { type AcceptedAdmission, type AttemptTerminal } from "./attempt.js";
 export declare const STALE_PRIVATE_STATE_PREPARATION: {
-    readonly kind: "publication-failed";
-    readonly diagnostic: "stale private-state preparation";
+    readonly kind: "stale";
 };
 export type ProtocolTerminal = Readonly<{
     kind: "exhausted";
@@ -26,11 +25,40 @@ export type CompanionDecorator = (input: Readonly<{
     contractId: ContractId;
     offer: Offer;
 }>) => readonly TreeUpdate[] | Promise<readonly TreeUpdate[]>;
-export type RunProtocolInput<Input extends Readonly<{
-    contractId: ContractId;
-}>, Refusal, Seed extends Readonly<{
+/**
+ * Seat-external preparation: immutable artifacts plus the currentness witnesses they carry.
+ * It never observes private state as authority and never forms an offer.
+ */
+export type ExternalProtocolPreparation<Prepared, Refusal> = Readonly<{
+    kind: "prepared";
+    prepared: Prepared;
+    assertions?: readonly GitRefAssertion[];
+}> | Readonly<{
+    kind: "refused";
+    refusal: Refusal;
+}>;
+/**
+ * In-custody assembly of one decision input from the fresh observation and an external artifact.
+ * `stale` means only that the outside preparation is spent: discard it and restart the cycle.
+ */
+export type InCustodyProtocolPreparation<Input, Refusal> = Readonly<{
+    kind: "prepared";
+    input: Input;
+    assertions?: readonly GitRefAssertion[];
+}> | Readonly<{
+    kind: "stale";
+}> | Readonly<{
+    kind: "refused";
+    refusal: Refusal;
+}>;
+/** The one split-preparation mechanism: repeatable work outside custody, assembly inside it. */
+export type ProtocolPreparation<Input, Refusal, Seed, Prepared> = Readonly<{
+    external: (seed: Seed) => ExternalProtocolPreparation<Prepared, Refusal> | Promise<ExternalProtocolPreparation<Prepared, Refusal>>;
+    assemble: (observation: GitDecisionObservation, seed: Seed, prepared: Prepared) => InCustodyProtocolPreparation<Input, Refusal> | Promise<InCustodyProtocolPreparation<Input, Refusal>>;
+}>;
+type ProtocolAdmission<Input extends Readonly<{
     contractId: ContractId;
-}> = Input> = Readonly<{
+}>, Refusal> = Readonly<{
     channel: GitDecodeChannel;
     repository: GitRepository;
     progress?: ExecutionProgress;
@@ -45,28 +73,31 @@ export type RunProtocolInput<Input extends Readonly<{
     decorateOffer?: CompanionDecorator;
     validateAdmission?: (observation: GitDecisionObservation) => Refusal | undefined | Promise<Refusal | undefined>;
     observationSelection?: GitTreeSelection;
-}> & (Readonly<{
-    input: Input;
-    prepareInput?: never;
-}> | Readonly<{
+}>;
+/** An intent whose invocation is already its decision input. */
+export type DirectRunProtocolInput<Seed extends Readonly<{
+    contractId: ContractId;
+}>, Refusal> = ProtocolAdmission<Seed, Refusal> & Readonly<{
+    input: Seed;
+    preparation?: undefined;
+}>;
+/** An intent whose repeatable preparation runs outside custody and is assembled inside it. */
+export type SplitRunProtocolInput<Input extends Readonly<{
+    contractId: ContractId;
+}>, Refusal, Seed extends Readonly<{
+    contractId: ContractId;
+}>, Prepared> = ProtocolAdmission<Input, Refusal> & Readonly<{
     input: Seed;
-    prepareInput: (observation: GitDecisionObservation, input: Seed) => Readonly<{
-        kind: "prepared";
-        input: Input;
-        assertions?: readonly GitRefAssertion[];
-    }> | Readonly<{
-        kind: "refused";
-        refusal: Refusal;
-    }> | Promise<Readonly<{
-        kind: "prepared";
-        input: Input;
-        assertions?: readonly GitRefAssertion[];
-    }> | Readonly<{
-        kind: "refused";
-        refusal: Refusal;
-    }>>;
-}>);
+    preparation: ProtocolPreparation<Input, Refusal, Seed, Prepared>;
+}>;
+export type RunProtocolInput<Input extends Readonly<{
+    contractId: ContractId;
+}>, Refusal, Seed extends Readonly<{
+    contractId: ContractId;
+}> = Input, Prepared = Seed> = DirectRunProtocolInput<Seed, Refusal> | SplitRunProtocolInput<Input, Refusal, Seed, Prepared>;
 export type PreparedProtocolAttempt<Refusal> = Readonly<{
+    kind: "stale";
+}> | Readonly<{
     kind: "refused";
     refusal: Refusal;
 }> | Readonly<{
@@ -76,29 +107,45 @@ export type PreparedProtocolAttempt<Refusal> = Readonly<{
     offer: Offer;
     assertions: readonly GitRefAssertion[];
 }>;
-export declare function privateRootCommit(observation: GitDecisionObservation): GitOid | null;
-export declare function samePrivateRootObservation(prepared: GitDecisionObservation, fresh: GitDecisionObservation): boolean;
-export type SpeculativeWorktreeInput = Readonly<{
+/**
+ * The private-state witness a seat-external preparation was computed against. Equal journal heads
+ * mean the same decoded contract state, so the same document, coordinates, and facts.
+ */
+export type ContractStateWitness = Readonly<{
+    head: ContractHead | null;
+}>;
+export declare function contractStateWitness(state: ContractStateWitness): ContractStateWitness;
+/**
+ * A physical worktree capture carried across custody as a witness, never as authority.
+ *
+ * Unlike a ref or a journal head, uncommitted worktree bytes are covered by no atomic
+ * compare-and-swap, so the only sound proof that a seat-external capture still describes the
+ * bytes about to be published is a fresh capture compared against this witness under custody.
+ * A cheaper structural signature (head, merge head, dirty flag, changed paths) cannot judge it:
+ * a writer that rewrites an already-changed path - a conflict materialization, for instance -
+ * leaves every path-level signature identical while the bytes that would be published differ.
+ */
+export type WorktreeWitness = Readonly<{
     tree: GitObjectId;
     head: SnapshotId;
     mergeHead?: SnapshotId;
     dirty: boolean;
     changeId: ChangeId;
 }>;
-export declare function sameSpeculativeWorktreeInput(prepared: SpeculativeWorktreeInput | undefined, fresh: SpeculativeWorktreeInput | undefined): boolean;
+export declare function sameWorktreeWitness(prepared: WorktreeWitness | undefined, fresh: WorktreeWitness | undefined): boolean;
 export declare function privateStateAssertionsMatch(repository: GitRepository, assertions: readonly GitRefAssertion[]): Promise<boolean>;
 export declare function publicationFailedFromSeatError(error: unknown): AttemptTerminal;
-export declare function matchingPrivateRootObservation(repository: GitRepository, channel: GitDecodeChannel, contractId: ContractId, prepared: GitDecisionObservation, revalidate?: (fresh: GitDecisionObservation) => boolean | Promise<boolean>): Promise<GitDecisionObservation | typeof STALE_PRIVATE_STATE_PREPARATION>;
 export declare function privateStateSeatAttempt<T>(repository: GitRepository, action: (seat: PrivateStatePublicationSeat) => Promise<T>, wrap: (outcome: PrivateStateSeatOutcome<T>) => T): Promise<T | AttemptTerminal>;
 /** Form one decided offer without admitting or reinterpreting it. */
 export declare function prepareProtocolAttempt<Input extends Readonly<{
     contractId: ContractId;
 }>, Refusal, Seed extends Readonly<{
     contractId: ContractId;
-}> = Input>(input: RunProtocolInput<Input, Refusal, Seed>, baseAttempt: AttemptContext): Promise<PreparedProtocolAttempt<Refusal>>;
+}> = Input, Prepared = Seed>(input: RunProtocolInput<Input, Refusal, Seed, Prepared>, baseAttempt: AttemptContext): Promise<PreparedProtocolAttempt<Refusal>>;
 /** Run bounded, verb-neutral attempts and return one real admission on acceptance. */
 export declare function runProtocol<Input extends Readonly<{
     contractId: ContractId;
 }>, Refusal, Seed extends Readonly<{
     contractId: ContractId;
-}> = Input>(input: RunProtocolInput<Input, Refusal, Seed>): Promise<ProtocolResult<Refusal>>;
+}> = Input, Prepared = Seed>(input: RunProtocolInput<Input, Refusal, Seed, Prepared>): Promise<ProtocolResult<Refusal>>;
+export {};