@astrosheep/keiyaku 4.1.0 → 4.1.2

package/build/src/library/reconcile.js

@@ -3,7 +3,7 @@ import { reconcileAllOperation, reconcileOperation, worldContractStates, } from
 import { reconcileObservationFailure } from "../git/reconcile.js";
 import { stateOperation } from "../protocol/operations.js";
 import { settle, settleAll } from "../settlement/settle.js";
-import { projectContractWorktree, } from "../contract-worktree.js";
+import { projectContractWorktree } from "../contract-worktree.js";
 import { appointManagedWorktrees, placeRegisterPath, releaseManagedWorktrees, } from "../workspace-place.js";
 function registerLag(scope, error) {
     return {
@@ -13,9 +13,6 @@ function registerLag(scope, error) {
         diagnostic: error instanceof Error ? error.message : String(error),
     };
 }
-function hereConflict(diagnostic) {
-    throw new AuthorityCorruptionError(diagnostic);
-}
 function emptySettlement() {
     return { actions: [], lags: [] };
 }
@@ -26,18 +23,13 @@ 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);
+    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;
+    return cleanup !== undefined && cleanup.lag.length === 0 && isManagedTerminal(state) && appointed;
 }
 async function releaseAppointments(scope, contracts) {
     try {
@@ -94,35 +86,50 @@ export async function completeReconcile(input) {
         retainTerminalWorktree: true,
         ...appointed,
     });
-    const projection = await projectContractWorktree(input.scope, retained.state, appointment.register, hereConflict);
+    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 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])],
+        lag: [
+            ...retained.report.lag,
+            ...projection.lag,
+            ...(cleanup?.report.lag ?? []),
+            ...(release === undefined ? [] : [release]),
+        ],
         settlement,
     };
 }
 function attachReleaseLag(contracts, released, lag) {
     const affected = new Set(released);
     return {
+        kind: "completed",
         contracts: contracts.map((contract) => affected.has(contract.contractId)
             ? { ...contract, report: { ...contract.report, lag: [...contract.report.lag, lag] } }
             : contract),
     };
 }
+function worldObservationDiagnostic(error) {
+    return (error instanceof Error ? error.message : String(error)).trim();
+}
 export async function completeRepoReconcile(input) {
-    const states = await worldContractStates(input);
+    let states;
+    try {
+        states = await worldContractStates(input);
+    }
+    catch (error) {
+        if (error instanceof AuthorityCorruptionError || error instanceof TypeError)
+            throw error;
+        return { kind: "world-observation-failed", diagnostic: worldObservationDiagnostic(error) };
+    }
     let appointed;
     try {
         appointed = await appointPlaces(input.scope, states);
@@ -140,11 +147,12 @@ export async function completeRepoReconcile(input) {
                     : await completeReconcile({ ...input, contractId: state.id }),
             });
         }
-        return { contracts };
+        return { kind: "completed", contracts };
     }
     const places = new Map(appointed.appointments.map((appointment) => [appointment.contract, appointment.place]));
     const retained = await reconcileAllOperation({
         ...input,
+        states,
         retainTerminalWorktree: true,
         places,
     });
@@ -157,11 +165,9 @@ export async function completeRepoReconcile(input) {
         })),
     });
     const cleanup = retained.contracts.some((contract) => isManagedTerminal(contract.state))
-        ? await reconcileAllOperation({ ...input, places })
+        ? await reconcileAllOperation({ ...input, states, places })
         : null;
-    const later = cleanup === null
-        ? null
-        : new Map(cleanup.contracts.map((contract) => [contract.contractId, contract.report]));
+    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()) {
@@ -169,7 +175,7 @@ export async function completeRepoReconcile(input) {
         if (releaseEligible(contract.state, report, places.has(contract.contractId))) {
             released.push(contract.contractId);
         }
-        const projection = await projectContractWorktree(input.scope, contract.state, appointed, hereConflict);
+        const projection = await projectContractWorktree(input.scope, contract.state, appointed);
         contracts.push({
             contractId: contract.contractId,
             report: {
@@ -180,5 +186,5 @@ export async function completeRepoReconcile(input) {
         });
     }
     const lag = await releaseAppointments(input.scope, released);
-    return lag === undefined ? { contracts } : attachReleaseLag(contracts, released, lag);
+    return lag === undefined ? { kind: "completed", contracts } : attachReleaseLag(contracts, released, lag);
 }

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

@@ -1,10 +1,9 @@
 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 ForkSourceRefusal = Readonly<{
+    kind: "fork-source-missing" | "fork-source-unavailable" | "fork-source-invalid" | "fork-source-moved";
+    contractId: ContractId;
 }>;
 export type NukeConfirmationRefusal = Readonly<{
     kind: "nuke-confirmation-mismatch";
@@ -15,7 +14,7 @@ export type NukeConfirmationRequiredRefusal = Readonly<{
     kind: "nuke-confirmation-required";
     world: string;
 }>;
-export type KeiyakuRefusal = IntentRefusal | ContractAppointmentRefusal | NukeConfirmationRefusal | NukeConfirmationRequiredRefusal;
+export type KeiyakuRefusal = IntentRefusal | ForkSourceRefusal | NukeConfirmationRefusal | NukeConfirmationRequiredRefusal;
 export type KeiyakuRetryReason = IntentRetry;
 export declare class KeiyakuRefused extends Error {
     readonly refusal: KeiyakuRefusal;
@@ -28,3 +27,12 @@ export declare class KeiyakuRetry extends Error {
     get code(): KeiyakuRetryReason["kind"];
 }
 export declare function requireAccepted<Value, Refusal extends KeiyakuRefusal>(result: IntentOutcome<Value, Refusal>): AcceptedIntent<Value>;
+export declare function forwardedMutationFailure(error: unknown): Readonly<{
+    result: Readonly<{
+        kind: "refused";
+        refusal: KeiyakuRefusal;
+    } | {
+        kind: "retry";
+        reason: KeiyakuRetryReason;
+    }>;
+}>;

package/build/src/library/refusal.js

@@ -27,3 +27,10 @@ export function requireAccepted(result) {
         throw new KeiyakuRetry(result.reason);
     return result;
 }
+export function forwardedMutationFailure(error) {
+    if (error instanceof KeiyakuRefused)
+        return { result: { kind: "refused", refusal: error.refusal } };
+    if (error instanceof KeiyakuRetry)
+        return { result: { kind: "retry", reason: error.reason } };
+    throw error;
+}

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

@@ -1,5 +1,5 @@
 import type { ContractId } from "../core/facts/types.js";
-import type { GitDecodeChannel } from "../git/read-observation.js";
+import { type GitDecodeChannel } from "../git/read-observation.js";
 import { type RepositoryScope } from "../protocol/operations.js";
 import type { ContractDocumentProjection } from "../protocol/read/documents.js";
 export type RegionOverlap = Readonly<{
@@ -16,15 +16,16 @@ export type RegionObservation = Readonly<{
     overlapFailure: string;
     overlaps?: never;
 }>;
+export type AmendRegionObservation = RegionObservation | Readonly<{
+    overlaps?: never;
+    overlapFailure?: never;
+}>;
 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 regionOverlaps(mine: readonly string[], declarations: readonly RegionDeclarationRead[]): readonly RegionOverlap[];
+export declare function validateRegionPatterns(patterns: unknown): readonly [string, ...string[]];
 export declare function observeRegion(scope: RepositoryScope, channel: GitDecodeChannel, self: ContractId, mine: readonly string[]): Promise<RegionObservation>;
+export declare function observeChangedRegion(scope: RepositoryScope, self: ContractId, changed: ReadonlySet<string> | undefined, mine: readonly string[]): Promise<AmendRegionObservation>;

package/build/src/library/region.js

@@ -1,19 +1,34 @@
 import { decodeContractDocument } from "../body/decode.js";
-import { assertCanonicalRegionPath, regionPatternsMatchPath, regionsOverlap } from "../body/region.js";
+import { assertRegionPattern, regionsOverlap } from "../body/region.js";
+import { withGitDecodeChannel } from "../git/read-observation.js";
 import { documentsOperationAt } from "../protocol/operations.js";
 export function readRegionDeclarations(documents) {
-    return documents.map((document) => ({ contract: document.contract, patterns: decodeContractDocument(document.documentBytes).region }));
+    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 regionOverlaps(mine, declarations) {
+    const overlaps = [];
+    for (const declaration of declarations) {
+        const pairs = regionsOverlap(mine, declaration.patterns);
+        if (pairs.length === 0)
+            continue;
+        overlaps.push({
+            contract: declaration.contract,
+            patterns: pairs.map(([minePattern, theirsPattern]) => ({ mine: minePattern, theirs: theirsPattern })),
+        });
+    }
+    return overlaps;
 }
-export function validateRegionPath(path) {
-    if (typeof path !== "string")
-        throw new Error("Region path must be a string");
-    assertCanonicalRegionPath(path);
+export function validateRegionPatterns(patterns) {
+    if (!Array.isArray(patterns) || patterns.length === 0)
+        throw new Error("Region query requires one or more path patterns");
+    return patterns.map((pattern) => {
+        if (typeof pattern !== "string")
+            throw new Error("Region path patterns must be strings");
+        return assertRegionPattern(pattern);
+    });
 }
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
@@ -42,3 +57,8 @@ export async function observeRegion(scope, channel, self, mine) {
         return { overlapFailure: diagnostic(error) };
     }
 }
+export async function observeChangedRegion(scope, self, changed, mine) {
+    if (!changed?.has("region"))
+        return {};
+    return await withGitDecodeChannel(scope, async (channel) => await observeRegion(scope, channel, self, mine));
+}

package/build/src/library/repo.js

@@ -1,9 +1,9 @@
-import { currentBranchOperation, scopeOperation, } from "../protocol/operations.js";
+import { currentBranchOperation, scopeOperation } from "../protocol/operations.js";
 import { NoGitWorldError } from "../git/repository.js";
 import { optionalNonblank, requireInput } from "./input.js";
 import { worktreeHooksOption } from "./configuration.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
-import { completeRepoReconcile, } from "./reconcile.js";
+import { completeRepoReconcile } from "./reconcile.js";
 export { NoGitWorldError };
 const REPO_SCOPES = new WeakMap();
 async function resolvePinnedScope(path, gitPath) {

package/build/src/markdown/lex.js

@@ -52,7 +52,11 @@ function header(line) {
         level += 1;
     if (level === 0 || (line[level] !== " " && line[level] !== "\t"))
         return null;
-    const text = line.slice(level).trim().replace(/[ \t]+#+[ \t]*$/, "").trimEnd();
+    const text = line
+        .slice(level)
+        .trim()
+        .replace(/[ \t]+#+[ \t]*$/, "")
+        .trimEnd();
     return text.length === 0 ? null : { level, text };
 }
 function listMarker(line) {
@@ -149,7 +153,10 @@ function frontmatter(lines) {
         closing += 1;
     if (closing >= lines.length)
         return null;
-    const yaml = lines.slice(1, closing).map((line) => line.text).join("\n");
+    const yaml = lines
+        .slice(1, closing)
+        .map((line) => line.text)
+        .join("\n");
     const entries = parseFrontmatter(yaml);
     const selected = lines.slice(0, closing + 1);
     return {

package/build/src/markdown/parse.js

@@ -149,12 +149,14 @@ class Parser {
     }
     parseListItem(marker, indent) {
         const bodyOffset = marker.bodyStart - marker.span.start;
-        const itemTokens = [{
+        const itemTokens = [
+            {
                 type: "text",
                 raw: marker.raw.slice(bodyOffset),
                 span: { start: marker.bodyStart, end: marker.span.end },
                 leadingSpaces: 0,
-            }];
+            },
+        ];
         let end = marker.span.end;
         while (!this.done()) {
             const token = this.peek();
@@ -173,15 +175,18 @@ class Parser {
             end = token.span.end;
         }
         const childSpan = { start: itemTokens[0].span.start, end: itemTokens.at(-1).span.end };
-        const children = new Parser(itemTokens, { mode: "item" })
-            .parseDocument("", childSpan, 0).children;
+        const children = new Parser(itemTokens, { mode: "item" }).parseDocument("", childSpan, 0).children;
         return { type: "list_item", span: { start: marker.span.start, end }, marker: marker.marker, indent, children };
     }
     parseText(stop) {
         const tokens = [];
         while (!this.done() && !stop()) {
             const token = this.peek();
-            if (token === undefined || token.type === "fence" || token.type === "header" || token.type === "blockquote" || token.type === "frontmatter")
+            if (token === undefined ||
+                token.type === "fence" ||
+                token.type === "header" ||
+                token.type === "blockquote" ||
+                token.type === "frontmatter")
                 break;
             if (token.type === "list_marker" && (this.options.mode === "item" || token.indent <= 3))
                 break;
@@ -216,6 +221,5 @@ class Parser {
 }
 export function parseToAST(source) {
     const bomLength = source.startsWith("\uFEFF") ? 1 : 0;
-    return new Parser(lexMarkdown(source), { mode: "document" })
-        .parseDocument(source, { start: 0, end: source.length }, bomLength);
+    return new Parser(lexMarkdown(source), { mode: "document" }).parseDocument(source, { start: 0, end: source.length }, bomLength);
 }

package/build/src/markdown/query.js

@@ -42,8 +42,10 @@ export function sectionContent(document, section) {
 }
 export function indexedHeadings(index, query) {
     const candidates = query.title === undefined
-        ? query.level === undefined ? [] : index.byLevel.get(query.level) ?? []
-        : index.byTitle.get(normalizeTitle(query.title)) ?? [];
+        ? query.level === undefined
+            ? []
+            : (index.byLevel.get(query.level) ?? [])
+        : (index.byTitle.get(normalizeTitle(query.title)) ?? []);
     return query.level === undefined ? candidates : candidates.filter((node) => node.level === query.level);
 }
 export function directChildren(node, type) {

package/build/src/protocol/amend.js

@@ -35,7 +35,9 @@ export async function amendOperation(input) {
             ? undefined
             : { source, ...input.deriveAmendment(source) };
         if (amendment !== undefined) {
-            observation = await extendPrerequisiteClosureAt(input.channel, observation, [...new Set([...(state?.terms.after ?? []), ...amendment.terms.after])]);
+            observation = await extendPrerequisiteClosureAt(input.channel, observation, [
+                ...new Set([...(state?.terms.after ?? []), ...amendment.terms.after]),
+            ]);
         }
         const preparation = amendment === undefined
             ? undefined

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

@@ -31,11 +31,14 @@ export type AcceptedAdmission = Readonly<{
 export type AttemptTerminal = Readonly<{
     kind: "collision";
 }> | PublicationFailed;
-export type DecidedOfferResult = AcceptedAdmission | AttemptTerminal | Readonly<{
+export type DecidedOfferResult<Refusal = never> = AcceptedAdmission | AttemptTerminal | Readonly<{
     kind: "redecide";
+}> | Readonly<{
+    kind: "refused";
+    refusal: Refusal;
 }>;
 /** Admit one decided offer without making another legal decision. */
-export declare function admitDecidedOffer(input: Readonly<{
+export declare function admitDecidedOffer<Refusal = never>(input: Readonly<{
     channel: GitDecodeChannel;
     repository: GitRepository;
     decisionObservation: GitDecisionObservation;
@@ -43,7 +46,8 @@ export declare function admitDecidedOffer(input: Readonly<{
     offer: Offer;
     primaryContract: ContractId;
     assertions?: readonly GitRefAssertion[];
-}>): Promise<DecidedOfferResult>;
+    validateAdmission?: (observation: GitDecisionObservation) => Refusal | undefined | Promise<Refusal | undefined>;
+}>): Promise<DecidedOfferResult<Refusal>>;
 /** 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

@@ -78,13 +78,12 @@ function recoveredAcceptance(observation, offer, primaryContract) {
     };
 }
 async function publicationPremiseMoved(repository, observation, offer, assertions) {
-    if (await readRef(repository, GIT_REF) !== observation.admission.snapshot.commit)
+    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)
+        if ((await readRef(repository, assertion.ref)) !== assertion.oid)
             return true;
-    return offer.target !== undefined
-        && await readRef(repository, offer.target.target) !== offer.target.expectedOid;
+    return offer.target !== undefined && (await readRef(repository, offer.target.target)) !== offer.target.expectedOid;
 }
 /** Admit one decided offer without making another legal decision. */
 export async function admitDecidedOffer(input) {
@@ -92,6 +91,11 @@ export async function admitDecidedOffer(input) {
     const assertions = input.assertions ?? [];
     validateOffer(offer, attempt);
     const primary = primaryAppend(offer, primaryContract);
+    if (input.validateAdmission !== undefined) {
+        const refusal = await input.validateAdmission(decisionObservation);
+        if (refusal !== undefined)
+            return { kind: "refused", refusal };
+    }
     const admission = await admit(repository, offer, decisionObservation.admission, assertions);
     if (admission.kind === "accepted") {
         return {
@@ -102,7 +106,7 @@ export async function admitDecidedOffer(input) {
         };
     }
     if (admission.kind === "publication-failed") {
-        return await publicationPremiseMoved(repository, decisionObservation, offer, assertions)
+        return (await publicationPremiseMoved(repository, decisionObservation, offer, assertions))
             ? { kind: "redecide" }
             : admission;
     }

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

@@ -3,7 +3,7 @@ import type { ChangeId, ContractState, DeliverData } from "../core/facts/types.j
 import { type AuditTargetAnswer } from "../git/target-placement.js";
 import type { DeliveryPreparationRefusal, DocumentDerivation, IntentOutcome, MutationOperationInput, VerificationStop } from "./operations.js";
 type AuditWorkspace = Readonly<{
-    kind: "worktree" | "here";
+    kind: "worktree";
     path: string;
 }>;
 type DiffScope = DeliveryDiffScope;

package/build/src/protocol/audit.js

@@ -7,15 +7,7 @@ import { verifyDelivery } from "./intent.js";
 import { accepted, admitted } from "./outcome.js";
 import { prepareDelivery } from "./deliver.js";
 import { timestamp, unpackVerificationOutcome } from "./operations.js";
-async function auditWorkspace(repository, state, resolveHereWorkspace) {
-    if (state.coordinates.workspace === "here") {
-        const path = resolveHereWorkspace === undefined
-            ? repository.effectiveCwd
-            : await resolveHereWorkspace(state.id);
-        return path === undefined
-            ? { kind: "unappointed" }
-            : { kind: "ready", answer: { kind: "here", path } };
-    }
+async function auditWorkspace(repository, state) {
     const appointed = await readManagedWorktreeAppointment(repository, state.id);
     if (appointed.kind === "failed")
         throw new Error(appointed.diagnostic);
@@ -73,7 +65,7 @@ async function readyAuditCandidate(repository, candidate, workspace, showDiff) {
         ...(diff === undefined || diff === null ? {} : { diff }),
     };
 }
-async function auditTargetAnswer(repository, state, candidate, workspacePath) {
+async function auditTargetAnswer(repository, state, candidate) {
     const target = state.coordinates.target;
     if (target === undefined)
         return { kind: "not-observed" };
@@ -82,7 +74,6 @@ async function auditTargetAnswer(repository, state, candidate, workspacePath) {
         coordinates: { ...state.coordinates, target },
         predecessor: candidate.integration.predecessor,
         candidate: candidate.integration.snapshot,
-        ...(workspacePath === undefined ? {} : { hereWorkspacePath: workspacePath }),
     });
 }
 function blockedAudit(refusal) {
@@ -112,7 +103,7 @@ export async function auditOperation(input) {
     }
     if (derivation.verification.kind === "refused")
         return { kind: "refused", refusal: derivation.verification.refusal };
-    const workspace = await auditWorkspace(input.scope, state, input.resolveHereWorkspace);
+    const workspace = await auditWorkspace(input.scope, state);
     if (workspace.kind === "unappointed") {
         return accepted(state, [], blockedAudit({ kind: "worktree-missing", contractId: state.id }));
     }
@@ -120,7 +111,6 @@ export async function auditOperation(input) {
         contractId: state.id,
         coordinates: state.coordinates,
         ...(workspace.appointment === undefined ? {} : { appointment: workspace.appointment }),
-        ...(workspace.answer.kind === "here" ? { workspacePath: workspace.answer.path } : {}),
     }, {
         title: derivation.title,
         document: derivation.bytes,
@@ -140,7 +130,7 @@ export async function auditOperation(input) {
         verification,
         target: verification.kind === "stopped"
             ? { kind: "not-observed" }
-            : await auditTargetAnswer(input.scope, state, prepared.data, workspace.answer.kind === "here" ? workspace.answer.path : undefined),
+            : await auditTargetAnswer(input.scope, state, prepared.data),
         ...(delivery === undefined ? {} : { delivery }),
     };
     return completedAudit(state, verified, value);

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

@@ -1,3 +1,5 @@
+import { type BindTargetSelection } from "../git/observe.js";
+export type { BindTargetSelection };
 import type { GitRepository } from "../git/process.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
 import type { BindData, ActorId, ContractId } from "../core/facts/types.js";
@@ -11,21 +13,32 @@ export type TargetInputRefusal = Readonly<{
 }> | Readonly<{
     kind: "target-missing";
 }> | Readonly<{
-    kind: "here-target-mismatch";
-    target: string;
-    branch: string | null;
+    kind: "unborn-head";
+}>;
+export type ForkSourceMovedRefusal = Readonly<{
+    kind: "fork-source-moved";
+    contractId: ContractId;
 }>;
 type BindOperationInput = Readonly<{
     scope: GitRepository;
     channel: GitDecodeChannel;
     terms: BindData["terms"];
     verification: VerificationDeclarationPreparation;
-    target?: string;
-    workspace: "worktree" | "here";
+    targetSelection?: BindTargetSelection;
+    workspace: "worktree";
     actor?: ActorId;
     decorateOffer?: CompanionDecorator;
     contractId: ContractId;
+    coordinates?: Readonly<{
+        start: import("../core/facts/types.js").SnapshotId;
+    }>;
+    source?: Readonly<{
+        contractId: ContractId;
+        head: import("../core/facts/types.js").ContractHead | null;
+        start: import("../core/facts/types.js").SnapshotId;
+        document: import("../core/facts/types.js").DocumentKey;
+    }>;
 }>;
 export declare function bindOperation(input: BindOperationInput): Promise<IntentOutcome<Readonly<{
     contractId: ContractId;
-}>, BindRefusal | TargetInputRefusal | VerificationDeclarationRefusal>>;
+}>, BindRefusal | TargetInputRefusal | VerificationDeclarationRefusal | ForkSourceMovedRefusal>>;

package/build/src/protocol/bind.js

@@ -3,18 +3,19 @@ import { gitObjectIdForSnapshot } from "../git/identity.js";
 import { decideBind } from "../core/verbs/bind.js";
 import { admitIntent } from "./intent.js";
 import { complete } from "./outcome.js";
-async function bindPreparation(input, target, seed) {
+async function bindPreparation(input, selection, seed) {
     if (input.verification.kind === "refused") {
         return { kind: "prepared", input: { ...seed, preparation: input.verification } };
     }
-    const observed = await observeBindCoordinates(input.scope, target);
+    const observed = await observeBindCoordinates(input.scope, selection);
     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 } };
+    if (!("start" in observed)) {
+        return { kind: "refused", refusal: { kind: "unborn-head" } };
     }
-    const oid = gitObjectIdForSnapshot(observed.start);
-    const assertions = [{ ref: target ?? "HEAD", oid }];
+    const start = input.coordinates?.start ?? observed.start;
+    const oid = gitObjectIdForSnapshot(input.coordinates === undefined ? start : observed.start);
+    const assertions = input.coordinates === undefined ? [{ ref: observed.target ?? "HEAD", oid }] : [];
     return {
         kind: "prepared",
         input: {
@@ -23,7 +24,7 @@ async function bindPreparation(input, target, seed) {
                 kind: "prepared",
                 data: {
                     coordinates: {
-                        start: observed.start,
+                        start,
                         ...(observed.target === undefined ? {} : { target: observed.target }),
                         workspace: input.workspace,
                     },
@@ -35,12 +36,12 @@ async function bindPreparation(input, target, seed) {
     };
 }
 export async function bindOperation(input) {
-    let target;
-    if (input.target !== undefined) {
-        const normalized = await normalizeTargetBranch(input.scope, input.target);
+    let selection = input.targetSelection ?? { kind: "targetless" };
+    if (selection.kind === "explicit") {
+        const normalized = await normalizeTargetBranch(input.scope, selection.target);
         if (normalized === null)
             return { kind: "refused", refusal: { kind: "invalid-target" } };
-        target = normalized;
+        selection = { kind: "explicit", target: normalized };
     }
     const at = new Date().toISOString();
     const id = input.contractId;
@@ -49,8 +50,22 @@ export async function bindOperation(input) {
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         at,
     }, decideBind, {
-        observedContracts: [id, ...input.terms.after],
-        prepareInput: async (_observation, original) => bindPreparation(input, target, original),
+        observedContracts: [id, ...input.terms.after, ...(input.source === undefined ? [] : [input.source.contractId])],
+        prepareInput: async (_observation, original) => bindPreparation(input, selection, original),
+        ...(input.source === undefined
+            ? {}
+            : {
+                validateAdmission: (observation) => {
+                    const current = observation.decision.get(input.source.contractId);
+                    return current !== null &&
+                        current !== undefined &&
+                        current.head === input.source.head &&
+                        current.coordinates.start === input.source.start &&
+                        current.terms.document.key === input.source.document
+                        ? undefined
+                        : { kind: "fork-source-moved", contractId: input.source.contractId };
+                },
+            }),
         ...(input.decorateOffer === undefined ? {} : { decorateOffer: input.decorateOffer }),
     }), { contractId: id });
 }

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

@@ -32,7 +32,6 @@ type CompletionInput = Readonly<{
     verification: VerificationDeclarationPreparation;
     initial: AcceptedProtocolStep;
     verifyInitial: boolean;
-    hereWorkspacePath?: string;
 }>;
 export type CompletionResult = Readonly<{
     admission: AcceptedProtocolStep;