@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/library/reconcile.js

@@ -0,0 +1,179 @@
+import { AuthorityCorruptionError } from "../core/facts/errors.js";
+import { reconcileAllOperation, reconcileObservationFailure, reconcileOperation, stateOperation, worldContractStates, } from "../protocol/operations.js";
+import { settle, settleAll } from "../settlement/settle.js";
+import { projectContractWorktree, } from "../contract-worktree.js";
+import { appointManagedWorktrees, placeRegisterPath, releaseManagedWorktrees, } from "../workspace-place.js";
+function registerLag(scope, error) {
+    return {
+        kind: "contract-file-failed",
+        worktree: scope.primaryWorktree,
+        path: placeRegisterPath(scope),
+        diagnostic: error instanceof Error ? error.message : String(error),
+    };
+}
+function emptySettlement() {
+    return { actions: [], lags: [] };
+}
+function isManagedWorktree(state) {
+    return state.coordinates.workspace === "worktree";
+}
+function isManagedTerminal(state) {
+    return state !== null && isManagedWorktree(state) && state.terminal !== null;
+}
+function appointableManagedContracts(states) {
+    return states
+        .filter((state) => isManagedWorktree(state) && state.terminal === null)
+        .map((state) => state.id);
+}
+async function appointPlaces(scope, states) {
+    return await appointManagedWorktrees(scope, appointableManagedContracts(states));
+}
+function releaseEligible(state, cleanup, appointed) {
+    return cleanup !== undefined
+        && cleanup.lag.length === 0
+        && isManagedTerminal(state)
+        && appointed;
+}
+async function releaseAppointments(scope, contracts) {
+    try {
+        await releaseManagedWorktrees(scope, contracts);
+        return undefined;
+    }
+    catch (error) {
+        if (error instanceof AuthorityCorruptionError || error instanceof TypeError)
+            throw error;
+        return registerLag(scope, error);
+    }
+}
+async function observeState(scope, channel, contractId) {
+    try {
+        return { state: await stateOperation({ scope, channel, contractId }) };
+    }
+    catch (error) {
+        if (error instanceof AuthorityCorruptionError || error instanceof TypeError)
+            throw error;
+        return { failed: reconcileObservationFailure(error) };
+    }
+}
+async function appointForContract(scope, state) {
+    if (!isManagedWorktree(state))
+        return {};
+    try {
+        const register = await appointPlaces(scope, [state]);
+        const place = register.byContract.get(state.id)?.place;
+        if (place === undefined) {
+            if (state.terminal !== null)
+                return { register };
+            throw new Error(`Place appointment was not recorded: ${state.id}`);
+        }
+        return { place, register };
+    }
+    catch (error) {
+        if (error instanceof AuthorityCorruptionError || error instanceof TypeError)
+            throw error;
+        return { lag: registerLag(scope, error) };
+    }
+}
+export async function completeReconcile(input) {
+    const observed = await observeState(input.scope, input.channel, input.contractId);
+    if ("failed" in observed) {
+        return { effects: observed.failed.effects, lag: observed.failed.lag, settlement: emptySettlement() };
+    }
+    const appointment = await appointForContract(input.scope, observed.state);
+    if ("lag" in appointment) {
+        return { effects: [], lag: [appointment.lag], settlement: emptySettlement() };
+    }
+    const appointed = appointment.place === undefined ? {} : { place: appointment.place };
+    const retained = await reconcileOperation({
+        ...input,
+        retainTerminalWorktree: true,
+        ...appointed,
+    });
+    const projection = await projectContractWorktree(input.scope, retained.state, appointment.register);
+    const settlement = await settle({
+        repository: input.scope,
+        channel: input.channel,
+        state: retained.state,
+        effects: retained.report.effects,
+    });
+    const cleanup = isManagedTerminal(retained.state)
+        ? await reconcileOperation({ ...input, ...appointed })
+        : null;
+    const release = releaseEligible(retained.state, cleanup?.report, appointment.place !== undefined)
+        ? await releaseAppointments(input.scope, [input.contractId])
+        : undefined;
+    return {
+        effects: [...retained.report.effects, ...projection.effects, ...(cleanup?.report.effects ?? [])],
+        lag: [...retained.report.lag, ...projection.lag, ...(cleanup?.report.lag ?? []), ...(release === undefined ? [] : [release])],
+        settlement,
+    };
+}
+function attachReleaseLag(contracts, released, lag) {
+    const affected = new Set(released);
+    return {
+        contracts: contracts.map((contract) => affected.has(contract.contractId)
+            ? { ...contract, report: { ...contract.report, lag: [...contract.report.lag, lag] } }
+            : contract),
+    };
+}
+export async function completeRepoReconcile(input) {
+    const states = await worldContractStates(input);
+    let appointed;
+    try {
+        appointed = await appointPlaces(input.scope, states);
+    }
+    catch (error) {
+        if (error instanceof AuthorityCorruptionError || error instanceof TypeError)
+            throw error;
+        const lag = registerLag(input.scope, error);
+        const contracts = [];
+        for (const state of states) {
+            contracts.push({
+                contractId: state.id,
+                report: isManagedWorktree(state)
+                    ? { effects: [], lag: [lag], settlement: emptySettlement() }
+                    : await completeReconcile({ ...input, contractId: state.id }),
+            });
+        }
+        return { contracts };
+    }
+    const places = new Map(appointed.appointments.map((appointment) => [appointment.contract, appointment.place]));
+    const retained = await reconcileAllOperation({
+        ...input,
+        retainTerminalWorktree: true,
+        places,
+    });
+    const settlements = await settleAll({
+        repository: input.scope,
+        channel: input.channel,
+        contracts: retained.contracts.map((contract) => ({
+            state: contract.state,
+            effects: contract.report.effects,
+        })),
+    });
+    const cleanup = retained.contracts.some((contract) => isManagedTerminal(contract.state))
+        ? await reconcileAllOperation({ ...input, places })
+        : null;
+    const later = cleanup === null
+        ? null
+        : new Map(cleanup.contracts.map((contract) => [contract.contractId, contract.report]));
+    const released = [];
+    const contracts = [];
+    for (const [index, contract] of retained.contracts.entries()) {
+        const report = later?.get(contract.contractId);
+        if (releaseEligible(contract.state, report, places.has(contract.contractId))) {
+            released.push(contract.contractId);
+        }
+        const projection = await projectContractWorktree(input.scope, contract.state, appointed);
+        contracts.push({
+            contractId: contract.contractId,
+            report: {
+                effects: [...contract.report.effects, ...projection.effects, ...(report?.effects ?? [])],
+                lag: [...contract.report.lag, ...projection.lag, ...(report?.lag ?? [])],
+                settlement: settlements[index],
+            },
+        });
+    }
+    const lag = await releaseAppointments(input.scope, released);
+    return lag === undefined ? { contracts } : attachReleaseLag(contracts, released, lag);
+}

package/build/src/library/refusal.d.ts

@@ -0,0 +1,21 @@
+import type { ContractId } from "../core/facts/types.js";
+import type { IntentOutcome, IntentRefusal, IntentRetry } from "../protocol/operations.js";
+import type { AcceptedIntent } from "./mutation.js";
+export type ContractAppointmentRefusal = Readonly<{
+    kind: "here-worktree-appointed";
+    path: string;
+    contract?: ContractId;
+}>;
+export type KeiyakuRefusal = IntentRefusal | ContractAppointmentRefusal;
+export type KeiyakuRetryReason = IntentRetry;
+export declare class KeiyakuRefused extends Error {
+    readonly refusal: KeiyakuRefusal;
+    constructor(refusal: KeiyakuRefusal);
+    get code(): KeiyakuRefusal["kind"];
+}
+export declare class KeiyakuRetry extends Error {
+    readonly reason: KeiyakuRetryReason;
+    constructor(reason: KeiyakuRetryReason);
+    get code(): KeiyakuRetryReason["kind"];
+}
+export declare function requireAccepted<Value, Refusal extends KeiyakuRefusal>(result: IntentOutcome<Value, Refusal>): AcceptedIntent<Value>;

package/build/src/library/refusal.js

@@ -0,0 +1,29 @@
+export class KeiyakuRefused extends Error {
+    refusal;
+    constructor(refusal) {
+        super(`Keiyaku refused: ${refusal.kind}`);
+        this.refusal = refusal;
+        this.name = "KeiyakuRefused";
+    }
+    get code() {
+        return this.refusal.kind;
+    }
+}
+export class KeiyakuRetry extends Error {
+    reason;
+    constructor(reason) {
+        super(reason.kind === "publication-failed" ? reason.diagnostic : `Keiyaku retry required: ${reason.kind}`);
+        this.reason = reason;
+        this.name = "KeiyakuRetry";
+    }
+    get code() {
+        return this.reason.kind;
+    }
+}
+export function requireAccepted(result) {
+    if (result.kind === "refused")
+        throw new KeiyakuRefused(result.refusal);
+    if (result.kind === "retry")
+        throw new KeiyakuRetry(result.reason);
+    return result;
+}

package/build/src/library/region.d.ts

@@ -1,5 +1,7 @@
 import type { ContractId } from "../core/facts/types.js";
+import type { GitDecodeChannel } from "../git/read-observation.js";
 import { type RepositoryScope } from "../protocol/operations.js";
+import type { ContractDocumentProjection } from "../protocol/operations.js";
 export type RegionOverlap = Readonly<{
     contract: ContractId;
     patterns: readonly Readonly<{
@@ -14,4 +16,15 @@ export type RegionObservation = Readonly<{
     overlapFailure: string;
     overlaps?: never;
 }>;
-export declare function observeRegion(scope: RepositoryScope, self: ContractId, mine: readonly string[]): RegionObservation;
+export type RegionDeclarationRead = Readonly<{
+    contract: ContractId;
+    patterns: readonly string[];
+}>;
+export declare function readRegionDeclarations(documents: readonly ContractDocumentProjection[]): readonly RegionDeclarationRead[];
+export declare function regionIntersections(left: readonly string[], right: readonly string[]): readonly Readonly<{
+    left: string;
+    right: string;
+}>[];
+export declare function regionPathMatches(patterns: readonly string[], path: string): readonly string[];
+export declare function validateRegionPath(path: unknown): asserts path is string;
+export declare function observeRegion(scope: RepositoryScope, channel: GitDecodeChannel, self: ContractId, mine: readonly string[]): Promise<RegionObservation>;

package/build/src/library/region.js

@@ -1,13 +1,27 @@
 import { decodeContractDocument } from "../body/decode.js";
-import { regionsOverlap } from "../body/region.js";
-import { documentsOperation } from "../protocol/operations.js";
+import { assertCanonicalRegionPath, regionPatternsMatchPath, regionsOverlap } from "../body/region.js";
+import { documentsOperationAt } from "../protocol/operations.js";
+export function readRegionDeclarations(documents) {
+    return documents.map((document) => ({ contract: document.contract, patterns: decodeContractDocument(document.documentBytes).region }));
+}
+export function regionIntersections(left, right) {
+    return regionsOverlap(left, right).map(([leftPattern, rightPattern]) => ({ left: leftPattern, right: rightPattern }));
+}
+export function regionPathMatches(patterns, path) {
+    return regionPatternsMatchPath(patterns, path);
+}
+export function validateRegionPath(path) {
+    if (typeof path !== "string")
+        throw new Error("Region path must be a string");
+    assertCanonicalRegionPath(path);
+}
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
-export function observeRegion(scope, self, mine) {
+export async function observeRegion(scope, channel, self, mine) {
     try {
         const overlaps = [];
-        for (const peer of documentsOperation({ scope })) {
+        for (const peer of await documentsOperationAt(scope, channel)) {
             if (peer.contract === self)
                 continue;
             try {

package/build/src/library/repo.d.ts

@@ -1,8 +1,8 @@
-import { NoGitWorldError, type ReconcileReport as ProtocolReconcileReport, type RepositoryScope } from "../protocol/operations.js";
-import { type SettlementReport } from "../settlement/settle.js";
+import { NoGitWorldError, type RepositoryScope } from "../protocol/operations.js";
 import { type WorktreeHooks } from "./configuration.js";
-import type { ContractId } from "../core/facts/types.js";
+import { type RepoContractReconcileReport, type RepoReconcileReport } from "./reconcile.js";
 export { NoGitWorldError };
+export type { RepoContractReconcileReport, RepoReconcileReport };
 export type RepoAtInput = Readonly<{
     path?: string;
 }>;
@@ -10,15 +10,6 @@ export type ReconcileInput = Readonly<{
     hooks?: WorktreeHooks;
     retryHooks?: boolean;
 }>;
-export type RepoContractReconcileReport = Readonly<ProtocolReconcileReport & {
-    settlement: SettlementReport;
-}>;
-export type RepoReconcileReport = Readonly<{
-    contracts: readonly Readonly<{
-        contractId: ContractId;
-        report: RepoContractReconcileReport;
-    }>[];
-}>;
 export declare function reconcileInput(input: ReconcileInput | undefined): Readonly<{
     hooks: WorktreeHooks;
     retryHooks: boolean;
@@ -26,7 +17,7 @@ export declare function reconcileInput(input: ReconcileInput | undefined): Reado
 export declare class Repo {
     readonly root: string;
     private constructor();
-    static at(input?: RepoAtInput): Repo;
+    static at(input?: RepoAtInput): Promise<Repo>;
     currentBranch(): Promise<string | null>;
     reconcile(input?: ReconcileInput): Promise<RepoReconcileReport>;
 }

package/build/src/library/repo.js

@@ -1,11 +1,12 @@
-import { currentBranchOperation, NoGitWorldError, reconcileAllOperation, scopeOperation, } from "../protocol/operations.js";
-import { settleAll } from "../settlement/settle.js";
+import { currentBranchOperation, NoGitWorldError, scopeOperation, } from "../protocol/operations.js";
 import { optionalNonblank, requireInput } from "./input.js";
 import { worktreeHooksOption } from "./configuration.js";
+import { withGitDecodeChannel } from "../git/read-observation.js";
+import { completeRepoReconcile, } from "./reconcile.js";
 export { NoGitWorldError };
 const REPO_SCOPES = new WeakMap();
-function resolvePinnedScope(path) {
-    return scopeOperation({ coordinate: path === undefined ? process.cwd() : path });
+async function resolvePinnedScope(path) {
+    return await scopeOperation({ coordinate: path === undefined ? process.cwd() : path });
 }
 export function reconcileInput(input) {
     const values = input === undefined ? undefined : requireInput(input, "reconcile input");
@@ -23,32 +24,21 @@ export class Repo {
         this.root = scope.primaryWorktree;
         REPO_SCOPES.set(this, scope);
     }
-    static at(input) {
+    static async at(input) {
         const values = input === undefined ? undefined : requireInput(input, "Repo.at input");
-        return new Repo(resolvePinnedScope(optionalNonblank(values?.path, "repository path")));
+        return new Repo(await resolvePinnedScope(optionalNonblank(values?.path, "repository path")));
     }
     async currentBranch() {
-        return currentBranchOperation({ scope: scopeForRepo(this) });
+        return await currentBranchOperation({ scope: scopeForRepo(this) });
     }
     async reconcile(input) {
         const scope = scopeForRepo(this);
-        const reconciled = await reconcileAllOperation({ scope, ...reconcileInput(input) });
-        const settlements = await settleAll({
-            repository: scope,
-            contracts: reconciled.contracts.map((contract) => ({
-                state: contract.state,
-                effects: contract.report.effects,
-            })),
-        });
-        return {
-            contracts: reconciled.contracts.map((contract, index) => ({
-                contractId: contract.contractId,
-                report: {
-                    ...contract.report,
-                    settlement: settlements[index],
-                },
-            })),
-        };
+        const options = reconcileInput(input);
+        return await withGitDecodeChannel(scope, (channel) => completeRepoReconcile({
+            scope,
+            channel,
+            ...options,
+        }));
     }
 }
 export function scopeForRepo(value) {

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

@@ -1,9 +1,14 @@
 import { type PublicationFailed } from "../git/admission.js";
 import { type GitDecisionObservation } from "../git/observe.js";
-import { type GitRepository } from "../git/repository.js";
+import type { GitDecodeChannel } from "../git/read-observation.js";
+import { type GitRefAssertion, type GitRepository } from "../git/repository.js";
 import type { AttemptContext } from "../core/decide.js";
 import type { Offer } from "../core/facts/offer.js";
-import { type ContractId, type ContractState, type JournalEntry } from "../core/facts/types.js";
+import { type ContractId, type ContractState, type EntryUlid, type JournalEntry } from "../core/facts/types.js";
+export declare function mintEntryUlids(count: number): readonly EntryUlid[];
+export declare function mintAttempts(input: Readonly<{
+    entryCount: number;
+}>): readonly AttemptContext[];
 export type UnknownAttemptClassification = Readonly<{
     kind: "accepted";
 }> | Readonly<{
@@ -29,7 +34,15 @@ export type DecidedOfferResult = AcceptedAdmission | AttemptTerminal | Readonly<
     kind: "redecide";
 }>;
 /** Admit one decided offer without making another legal decision. */
-export declare function admitDecidedOffer(repository: GitRepository, decisionObservation: GitDecisionObservation, attempt: AttemptContext, offer: Offer, primaryContract: ContractId): DecidedOfferResult;
+export declare function admitDecidedOffer(input: Readonly<{
+    channel: GitDecodeChannel;
+    repository: GitRepository;
+    decisionObservation: GitDecisionObservation;
+    attempt: AttemptContext;
+    offer: Offer;
+    primaryContract: ContractId;
+    assertions?: readonly GitRefAssertion[];
+}>): Promise<DecidedOfferResult>;
 /** Classify an unknown atomic-publication outcome using only a captured Git observation. */
 export declare function classifyUnknownAttempt(observation: Readonly<{
     contracts: GitDecisionObservation["journals"];

package/build/src/protocol/attempt.js

@@ -1,9 +1,35 @@
+import { randomBytes } from "node:crypto";
 import { encodeEntry } from "../core/facts/codec.js";
 import { admit } from "../git/admission.js";
-import { observeContracts } from "../git/observe.js";
+import { observeContractsForAdmissionAt } from "../git/observe.js";
 import { GIT_REF, readRef } from "../git/repository.js";
 import { foldJournal } from "../core/facts/fold.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
+import { entryUlid, } from "../core/facts/types.js";
+const ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+const MAX_SEMANTIC_ATTEMPTS = 3;
+function nextEntryUlid() {
+    let value = "";
+    let time = BigInt(Date.now());
+    for (let index = 0; index < 10; index += 1) {
+        value = ALPHABET[Number(time & 31n)] + value;
+        time >>= 5n;
+    }
+    let random = BigInt(`0x${randomBytes(10).toString("hex")}`);
+    for (let index = 0; index < 16; index += 1) {
+        value += ALPHABET[Number(random & 31n)];
+        random >>= 5n;
+    }
+    return entryUlid(value);
+}
+export function mintEntryUlids(count) {
+    return Array.from({ length: count }, nextEntryUlid);
+}
+export function mintAttempts(input) {
+    return Array.from({ length: MAX_SEMANTIC_ATTEMPTS }, () => ({
+        entryUlids: mintEntryUlids(input.entryCount),
+    }));
+}
 function offerEntries(offer) {
     return offer.facts.flatMap((append) => append.entries);
 }
@@ -51,17 +77,22 @@ function recoveredAcceptance(observation, offer, primaryContract) {
         journal: record.entries,
     };
 }
-function publicationPremiseMoved(repository, observation, offer) {
-    if (readRef(repository, GIT_REF) !== observation.admission.snapshot.commit)
+async function publicationPremiseMoved(repository, observation, offer, assertions) {
+    if (await readRef(repository, GIT_REF) !== observation.admission.snapshot.commit)
         return true;
+    for (const assertion of assertions)
+        if (await readRef(repository, assertion.ref) !== assertion.oid)
+            return true;
     return offer.target !== undefined
-        && readRef(repository, offer.target.target) !== offer.target.expectedOid;
+        && await readRef(repository, offer.target.target) !== offer.target.expectedOid;
 }
 /** Admit one decided offer without making another legal decision. */
-export function admitDecidedOffer(repository, decisionObservation, attempt, offer, primaryContract) {
+export async function admitDecidedOffer(input) {
+    const { channel, repository, decisionObservation, attempt, offer, primaryContract } = input;
+    const assertions = input.assertions ?? [];
     validateOffer(offer, attempt);
     const primary = primaryAppend(offer, primaryContract);
-    const admission = admit(repository, offer, decisionObservation.admission);
+    const admission = await admit(repository, offer, decisionObservation.admission, assertions);
     if (admission.kind === "accepted") {
         return {
             kind: "accepted",
@@ -71,14 +102,14 @@ export function admitDecidedOffer(repository, decisionObservation, attempt, offe
         };
     }
     if (admission.kind === "publication-failed") {
-        return publicationPremiseMoved(repository, decisionObservation, offer)
+        return await publicationPremiseMoved(repository, decisionObservation, offer, assertions)
             ? { kind: "redecide" }
             : admission;
     }
-    const recovered = observeContracts(repository, offer.facts.map((append) => append.contractId));
-    const classification = classifyUnknownAttempt(recovered, offer);
+    const recovered = await observeContractsForAdmissionAt(repository, channel, offer.facts.map((append) => append.contractId));
+    const classification = classifyUnknownAttempt({ contracts: recovered.journals }, offer);
     if (classification.kind === "accepted")
-        return recoveredAcceptance(recovered, offer, primaryContract);
+        return recoveredAcceptance({ contracts: recovered.journals }, offer, primaryContract);
     return classification.kind === "collision" ? { kind: "collision" } : { kind: "redecide" };
 }
 /** Classify an unknown atomic-publication outcome using only a captured Git observation. */

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

@@ -1,4 +1,5 @@
 import type { GitRepository } from "../git/repository.js";
+import type { GitDecodeChannel } from "../git/read-observation.js";
 import type { BindData, ActorId, ContractId } from "../core/facts/types.js";
 import { type BindRefusal } from "../core/verbs/bind.js";
 export type { BindRefusal } from "../core/verbs/bind.js";
@@ -9,9 +10,14 @@ export type TargetInputRefusal = Readonly<{
     kind: "invalid-target";
 }> | Readonly<{
     kind: "target-missing";
+}> | Readonly<{
+    kind: "here-target-mismatch";
+    target: string;
+    branch: string | null;
 }>;
 type BindOperationInput = Readonly<{
     scope: GitRepository;
+    channel: GitDecodeChannel;
     title: string;
     terms: BindData["terms"];
     verification: VerificationDeclarationPreparation;
@@ -19,7 +25,8 @@ type BindOperationInput = Readonly<{
     workspace: "worktree" | "here";
     actor?: ActorId;
     decorateOffer?: CompanionDecorator;
+    contractId?: ContractId;
 }>;
-export declare function bindOperation(input: BindOperationInput): IntentOutcome<Readonly<{
+export declare function bindOperation(input: BindOperationInput): Promise<IntentOutcome<Readonly<{
     contractId: ContractId;
-}>, BindRefusal | TargetInputRefusal | VerificationDeclarationRefusal>;
+}>, BindRefusal | TargetInputRefusal | VerificationDeclarationRefusal>>;

package/build/src/protocol/bind.js

@@ -1,62 +1,70 @@
-import { randomBytes } from "node:crypto";
 import { normalizeTargetBranch, observeBindCoordinates } from "../git/observe.js";
+import { gitObjectIdForSnapshot } from "../git/identity.js";
 import { contractIdFromSegment } from "../core/facts/types.js";
 import { decideBind } from "../core/verbs/bind.js";
-import { fitIdentityStem, normalizeIdentityStem } from "../identity/normalize.js";
 import { admitIntent } from "./intent.js";
 import { complete } from "./outcome.js";
-const CONTRACT_ID_STEM_BYTES = 72;
-const CROCKFORD_BASE32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-function mintCollisionSuffix() {
-    let random = BigInt(`0x${randomBytes(5).toString("hex")}`);
-    let suffix = "";
-    for (let index = 0; index < 8; index += 1) {
-        suffix = CROCKFORD_BASE32[Number(random & 31n)] + suffix;
-        random >>= 5n;
-    }
-    return suffix.toLowerCase();
+import { fitIdentityStem, normalizeIdentityStem } from "../identity/normalize.js";
+const COLLISION_ATTEMPTS = 3;
+function contractIdFor(title, suffix) {
+    const stem = fitIdentityStem({ stem: normalizeIdentityStem({ source: title }) || "contract", maxBytes: 48 });
+    return contractIdFromSegment(suffix === undefined ? stem : `${stem}-${suffix}`);
 }
-function contractIdFromStem(stem, suffix) {
-    return contractIdFromSegment(fitIdentityStem({
-        stem,
-        maxBytes: CONTRACT_ID_STEM_BYTES,
-        ...(suffix === undefined ? {} : { suffix }),
-    }));
+async function bindPreparation(input, target, seed) {
+    if (input.verification.kind === "refused") {
+        return { kind: "prepared", input: { ...seed, preparation: input.verification } };
+    }
+    const observed = await observeBindCoordinates(input.scope, target);
+    if (observed === null)
+        return { kind: "refused", refusal: { kind: "target-missing" } };
+    if (input.workspace === "here" && target !== undefined && observed.branch !== target) {
+        return { kind: "refused", refusal: { kind: "here-target-mismatch", target, branch: observed.branch } };
+    }
+    const oid = gitObjectIdForSnapshot(observed.start);
+    const assertions = [{ ref: target ?? "HEAD", oid }];
+    return {
+        kind: "prepared",
+        input: {
+            ...seed,
+            preparation: {
+                kind: "prepared",
+                data: {
+                    coordinates: {
+                        start: observed.start,
+                        ...(observed.target === undefined ? {} : { target: observed.target }),
+                        workspace: input.workspace,
+                    },
+                    terms: input.terms,
+                },
+            },
+        },
+        assertions,
+    };
 }
-export function bindOperation(input) {
+export async function bindOperation(input) {
     let target;
     if (input.target !== undefined) {
-        const normalized = normalizeTargetBranch(input.scope, input.target);
+        const normalized = await normalizeTargetBranch(input.scope, input.target);
         if (normalized === null)
             return { kind: "refused", refusal: { kind: "invalid-target" } };
         target = normalized;
     }
-    const observed = observeBindCoordinates(input.scope, target);
-    if (observed === null)
-        return { kind: "refused", refusal: { kind: "target-missing" } };
-    const data = {
-        coordinates: {
-            start: observed.start,
-            ...(observed.target === undefined ? {} : { target: observed.target }),
-            workspace: input.workspace,
-        },
-        terms: input.terms,
-    };
-    const stem = normalizeIdentityStem({ source: input.title }) || "contract";
     const at = new Date().toISOString();
-    const attempt = (id) => complete(admitIntent(input.scope, {
+    const attempt = async (id) => complete(await admitIntent(input.channel, input.scope, {
         contractId: id,
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         at,
-        preparation: input.verification.kind === "prepared"
-            ? { kind: "prepared", data }
-            : { kind: "refused", refusal: input.verification.refusal },
     }, decideBind, {
         observedContracts: [id, ...input.terms.after],
+        prepareInput: async (_observation, original) => bindPreparation(input, target, original),
         ...(input.decorateOffer === undefined ? {} : { decorateOffer: input.decorateOffer }),
     }), { contractId: id });
-    const first = attempt(contractIdFromStem(stem));
-    return first.kind === "refused" && first.refusal.kind === "contract-exists"
-        ? attempt(contractIdFromStem(stem, mintCollisionSuffix()))
-        : first;
+    if (input.contractId !== undefined)
+        return attempt(input.contractId);
+    let result = await attempt(contractIdFor(input.title));
+    for (let collision = 0; collision < COLLISION_ATTEMPTS && result.kind === "refused" && result.refusal.kind === "contract-exists"; collision += 1) {
+        result = await attempt(contractIdFor(input.title, randomBytes(8).toString("hex")));
+    }
+    return result;
 }
+import { randomBytes } from "node:crypto";