@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/contract-carrier-runtime.js

@@ -1,512 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { FlowError } from "../flow-error.js";
-import { isCommitAncestor, readCommitCoordinate } from "../git/commits.js";
-import { runGitProcess } from "../git/core.js";
-import { replayCommittedDerivedState } from "./derived-replay.js";
-import { EffectJournal } from "./outcome-base.js";
-import { resolveAcceptedLifecycleTransaction } from "./repository-ledger/accepted-tail.js";
-import { publishAuthoritativeTransaction } from "./repository-ledger/write-transaction.js";
-import { cleanupContractWorkspace, contractWorktreePathFromStableRoot, observeTerminalDeliveryRef, resolveContractCarrierTarget, stableRepoRoot } from "./worktree-path.js";
-import { defaultCreateWorktree } from "./bind-workspace.js";
-import { replayClaimTargetWorktree } from "./settlement/claim-delivery.js";
-import { lifecycleTransactionId } from "./repository-ledger/identity.js";
-let acceptedBind, acquireGate, carrierMatches, checkCancellation;
-let expectedCarrierIdentity, observe, observedLedgerHead, publishCarrier;
-let verifyCarrier, reconcileFoldedDeliveryWorktree, releaseGate, retireTerminalHereCarrier;
-export function installCarrierRuntimePorts(ports) {
-    ({ acceptedBind, acquireGate, carrierMatches, checkCancellation, expectedCarrierIdentity, observe, observedLedgerHead,
-        publishCarrier, verifyCarrier, reconcileFoldedDeliveryWorktree,
-        releaseGate, retireTerminalHereCarrier } = ports);
-}
-export async function withContractCarrierSession(input, action) {
-    const stableRoot = await stableRepoRoot(input.cwd);
-    if (input.mode === "observe-only") {
-        checkCancellation(input.signal);
-        const { repository, lifecycle, target, pins } = await observe(stableRoot, input.contractId);
-        const projectedCarrier = target.status === "available" ? await verifyCarrier({ target: target.path, lifecycle }) : undefined;
-        const initialCarrier = target.status === "available"
-            ? { status: projectedCarrier && carrierMatches(projectedCarrier) ? "current" : "stale", contractHead: lifecycle.contractHead, target: target.path }
-            : { status: "target-unavailable", contractHead: lifecycle.contractHead, reason: target.reason };
-        return action(createSession(input.mode, stableRoot, input.contractId, repository, lifecycle, target, pins, initialCarrier, input.signal, input.contractViewWriter, input.renewDeliveryProjector, input.terminalWorkspaceCleanup, input.transactionRunner));
-    }
-    // Publication coordination is scoped to the contract's proven physical target.
-    const preGateObserved = await observe(stableRoot, input.contractId);
-    const gate = await acquireGate(stableRoot, input.contractId, preGateObserved.target.status === "available" ? preGateObserved.target.path : `unavailable:${input.contractId}`, input.signal);
-    try {
-        checkCancellation(input.signal);
-        const { repository, lifecycle, target, pins } = preGateObserved;
-        const projectedCarrier = target.status === "available" ? await verifyCarrier({ target: target.path, lifecycle }) : undefined;
-        const initialCarrier = target.status === "available"
-            ? { status: projectedCarrier && carrierMatches(projectedCarrier) ? "current" : "stale", contractHead: lifecycle.contractHead, target: target.path }
-            : { status: "target-unavailable", contractHead: lifecycle.contractHead, reason: target.reason };
-        checkCancellation(input.signal);
-        const session = createSession(input.mode, stableRoot, input.contractId, repository, lifecycle, target, pins, initialCarrier, input.signal, input.contractViewWriter, input.renewDeliveryProjector, input.terminalWorkspaceCleanup, input.transactionRunner);
-        return await action(session);
-    }
-    finally {
-        releaseGate(gate);
-    }
-}
-/** Bind-only carrier admission from the immutable Observe snapshot. */
-export async function withObservedContractCarrierSession(input, action) {
-    checkCancellation(input.signal);
-    const gate = await acquireGate(input.stableRoot, input.contractId, input.observation.target.status === "available" ? input.observation.target.path : `unavailable:${input.contractId}`, input.signal);
-    try {
-        const { repository, lifecycle, target, pins } = input.observation;
-        const projectedCarrier = target.status === "available" ? await verifyCarrier({ target: target.path, lifecycle }) : undefined;
-        const initialCarrier = target.status === "available"
-            ? { status: projectedCarrier && carrierMatches(projectedCarrier) ? "current" : "stale", contractHead: lifecycle.contractHead, target: target.path }
-            : { status: "target-unavailable", contractHead: lifecycle.contractHead, reason: target.reason };
-        return await action(createSession("mutation", input.stableRoot, input.contractId, repository, lifecycle, target, pins, initialCarrier, input.signal, input.contractViewWriter, undefined, input.terminalWorkspaceCleanup, undefined));
-    }
-    finally {
-        releaseGate(gate);
-    }
-}
-function createSession(mode, stableRoot, contractId, repository, lifecycle, target, pins, initialCarrier, signal, contractViewWriter, renewDeliveryProjector, terminalWorkspaceCleanup, transactionRunner) {
-    const admittedLedgerHead = pins.repositoryLedgerHead;
-    const admittedLifecycleTail = lifecycle.contractHead;
-    let currentLifecycle = lifecycle;
-    let currentObservation = { repository, lifecycle, target, pins };
-    let authoritativeTransactionSelected = false;
-    let effectsStarted = false;
-    let committedResult;
-    const journal = new EffectJournal(`${contractId}:${lifecycle.contractHead}`);
-    async function finalizeCommitted(input) {
-        effectsStarted = true;
-        let resolvedTransaction;
-        await journal.run({
-            effect: "committed-ledger-reread",
-            idempotencyKey: `${contractId}:${input.head}:ledger-reread`,
-            run: async () => {
-                const observed = await observe(stableRoot, contractId);
-                currentLifecycle = observed.lifecycle;
-                const accepted = resolveAcceptedLifecycleTransaction({ read: observed.repository, transactionObjectId: input.head, expectedContract: contractId });
-                if (accepted.status !== "accepted")
-                    throw new FlowError("COMMITTED_LEDGER_REREAD_FAILED", `accepted ledger transaction ${input.head} could not be reread (${accepted.reason})`);
-                resolvedTransaction = accepted;
-                return { head: observed.lifecycle.contractHead };
-            },
-        });
-        journal.beginDerivedReplay();
-        const carrier = input.carrier === "retire"
-            ? { status: "retired", contractHead: currentLifecycle.contractHead, reason: "terminal" }
-            : target.status === "available"
-                ? { status: "stale", contractHead: currentLifecycle.contractHead, target: target.path }
-                : { status: "target-unavailable", contractHead: currentLifecycle.contractHead, reason: target.reason };
-        committedResult = {
-            status: "committed",
-            head: input.head,
-            transaction: resolvedTransaction ?? (() => { throw new FlowError("COMMITTED_LEDGER_REREAD_FAILED", `accepted ledger transaction ${input.head} was not reread`); })(),
-            carrier,
-            effects: journal.all(),
-            cancellationObserved: effectsStarted && (signal?.aborted ?? false),
-        };
-        return committedResult;
-    }
-    async function publishRepository(transaction) {
-        if (mode !== "mutation")
-            throw new FlowError("INTERNAL_STATE", `carrier ${mode} session cannot publish repository ledger facts`);
-        if (!effectsStarted)
-            checkCancellation(signal);
-        let replayed;
-        let carrier = target.status === "available"
-            ? { status: "stale", contractHead: currentLifecycle.contractHead, target: target.path }
-            : { status: "target-unavailable", contractHead: currentLifecycle.contractHead, reason: target.reason };
-        const replayPlan = {
-            steps: [
-                {
-                    effect: "committed-ledger-reread",
-                    dependencies: [],
-                    run: async ({ ledgerHead }) => {
-                        replayed = await observe(stableRoot, contractId);
-                        if (replayed.repository.observedLedgerHead !== ledgerHead) {
-                            throw new FlowError("COMMITTED_LEDGER_REREAD_FAILED", `committed ledger head ${ledgerHead} could not be reread (observed ${replayed.repository.observedLedgerHead})`);
-                        }
-                        currentLifecycle = replayed.lifecycle;
-                        currentObservation = replayed;
-                    },
-                },
-            ],
-        };
-        const publication = await publishAuthoritativeTransaction(stableRoot, transaction, {
-            replayPlan,
-            ...(transactionRunner ? { transactionRunner } : {}),
-        });
-        const result = publication.write;
-        if (result.family === "refused-before-effects") {
-            return {
-                status: "refused-before-effects",
-                reason: "conflict",
-                currentHead: observedLedgerHead(result.observations),
-                code: result.code,
-                cause: result.cause,
-                observations: result.observations,
-                effects: [],
-            };
-        }
-        if (result.family === "indeterminate") {
-            effectsStarted = true;
-            const currentHead = observedLedgerHead(result.observations);
-            journal.record({
-                effect: "ledger-cas",
-                idempotencyKey: `${contractId}:${result.builtLedgerHead}:ledger-cas`,
-                status: "failed",
-                cause: {
-                    code: result.code,
-                    message: result.cause,
-                    facts: { builtHead: result.builtLedgerHead, currentHead },
-                },
-            });
-            return { status: "indeterminate", builtHead: result.builtLedgerHead, currentHead, effects: journal.all() };
-        }
-        effectsStarted = true;
-        const accepted = publication.builtTail.entries.at(-1);
-        const ledgerCasKey = `${contractId}:${result.ledgerHead}:ledger-cas`;
-        journal.record({
-            effect: "ledger-cas",
-            idempotencyKey: ledgerCasKey,
-            status: "succeeded",
-            receipt: {
-                head: result.ledgerHead,
-                entryKind: accepted.entry.kind,
-                authorityProof: result.authorityProof,
-            },
-        });
-        const replayDependencyEffects = { "committed-ledger-reread": ledgerCasKey };
-        const replayKeys = new Map();
-        for (const effect of result.replay.effects) {
-            const idempotencyKey = `${contractId}:${result.ledgerHead}:${effect.effect}`;
-            replayKeys.set(effect.effect, idempotencyKey);
-            const dependencyEffect = replayDependencyEffects[effect.effect];
-            const dependency = dependencyEffect === ledgerCasKey ? ledgerCasKey : dependencyEffect ? replayKeys.get(dependencyEffect) : undefined;
-            const row = effect.status === "succeeded"
-                ? { effect: effect.effect, idempotencyKey, ...(dependency ? { dependency } : {}), status: "succeeded" }
-                : effect.status === "failed"
-                    ? { effect: effect.effect, idempotencyKey, ...(dependency ? { dependency } : {}), status: "failed", cause: effect.cause }
-                    : {
-                        effect: effect.effect,
-                        idempotencyKey,
-                        dependency: replayKeys.get(effect.dependency) ?? effect.dependency,
-                        status: "not-attempted",
-                        cause: { code: "DEPENDENCY_FAILED", message: `dependency ${effect.dependency} did not succeed` },
-                    };
-            journal.record(row);
-        }
-        const observedTransaction = resolveAcceptedLifecycleTransaction({
-            read: replayed?.repository ?? (await observe(stableRoot, contractId)).repository,
-            transactionObjectId: lifecycleTransactionId(result.ledgerHead),
-            expectedContract: contractId,
-        });
-        if (observedTransaction.status !== "accepted") {
-            throw new FlowError("COMMITTED_LEDGER_REREAD_FAILED", `accepted ledger transaction ${result.ledgerHead} could not be reread (${observedTransaction.reason})`);
-        }
-        committedResult = {
-            status: "committed",
-            head: lifecycleTransactionId(result.ledgerHead),
-            transaction: observedTransaction,
-            carrier,
-            effects: journal.all(),
-            cancellationObserved: signal?.aborted ?? false,
-        };
-        return committedResult;
-    }
-    async function replayDerivedState() {
-        const observed = currentObservation.lifecycle.contractHead === currentLifecycle.contractHead
-            ? currentObservation
-            : await observe(stableRoot, contractId);
-        currentObservation = observed;
-        currentLifecycle = observed.lifecycle;
-        const bind = acceptedBind(observed.lifecycle);
-        let committedTarget = observed.target;
-        let materialized = {
-            status: "failed",
-            contractHead: observed.lifecycle.contractHead,
-            cause: "carrier projection was not attempted",
-        };
-        await replayCommittedDerivedState({
-            cwd: stableRoot,
-            repository: observed.repository,
-            lifecycle: observed.lifecycle,
-            target: committedTarget,
-            journal,
-            adapters: {
-                reconcileActiveWorktree: async () => {
-                    committedTarget = await resolveContractCarrierTarget(stableRoot, contractId, bind);
-                    let created = false;
-                    if (committedTarget.status !== "available" && bind.data.workspace === "worktree") {
-                        const worktreePath = contractWorktreePathFromStableRoot(stableRoot, contractId, bind);
-                        try {
-                            await fs.access(worktreePath);
-                            throw Object.assign(new Error(`worktree path ${worktreePath} is occupied by an unowned filesystem entry`), { code: "BIND_WORKTREE_PATH_OCCUPIED", facts: { path: worktreePath, occupant: "unowned-filesystem-entry" } });
-                        }
-                        catch (error) {
-                            if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT")
-                                throw error;
-                        }
-                        await defaultCreateWorktree({
-                            cwd: stableRoot,
-                            id: contractId,
-                            branch: `keiyaku/${contractId}`,
-                            base: bind.data.base,
-                            worktreePath,
-                        });
-                        committedTarget = await resolveContractCarrierTarget(stableRoot, contractId, bind);
-                        created = true;
-                    }
-                    if (committedTarget.status !== "available")
-                        throw new FlowError("CARRIER_TARGET_UNAVAILABLE", committedTarget.reason);
-                    return { status: created ? "created" : "already-present", target: committedTarget };
-                },
-                reconcileRenewDelivery: async ({ lifecycle: accepted, target: acceptedTarget, transaction }) => {
-                    if (acceptedTarget.status !== "available")
-                        throw new FlowError("CARRIER_TARGET_UNAVAILABLE", acceptedTarget.reason);
-                    const renew = transaction.entries.find((entry) => entry.kind === "renew");
-                    if (!renew || renew.kind !== "renew") {
-                        throw new FlowError("INTERNAL_STATE", `accepted renew transaction ${transaction.transactionObjectId} has no renew entry`);
-                    }
-                    if (renewDeliveryProjector) {
-                        await renewDeliveryProjector(acceptedTarget, renew.data.oldHead, renew.data.newHead);
-                        return "created";
-                    }
-                    return reconcileFoldedDeliveryWorktree({ targetRoot: acceptedTarget.root, lifecycle: accepted });
-                },
-                materializeContractView: async ({ lifecycle: accepted, target: acceptedTarget }) => {
-                    const projected = await convergeCarrier(stableRoot, contractId, accepted, acceptedTarget, contractViewWriter);
-                    materialized = projected;
-                    if (projected.status === "failed")
-                        throw new FlowError("CARRIER_MATERIALIZATION_FAILED", projected.cause);
-                    if (projected.status === "target-unavailable")
-                        throw new FlowError("CARRIER_TARGET_UNAVAILABLE", projected.reason);
-                    return projected.status === "current" ? "already-present" : "created";
-                },
-                retireContractView: async ({ lifecycle: accepted, target: acceptedTarget }) => {
-                    return retireTerminalHereCarrier(accepted, acceptedTarget);
-                },
-                expectedCarrierIdentity,
-                inspectSurface: async ({ obligation }) => {
-                    switch (obligation.surface) {
-                        case "carrier": {
-                            if (committedTarget.status !== "available")
-                                return null;
-                            const verification = await verifyCarrier({ target: committedTarget.path, lifecycle: observed.lifecycle });
-                            return verification.status === "current" ? verification.actual : null;
-                        }
-                        case "carrier-retirement": {
-                            if (committedTarget.status !== "available")
-                                return obligation.expected;
-                            try {
-                                await fs.access(committedTarget.path);
-                                return null;
-                            }
-                            catch (error) {
-                                return error instanceof Error && "code" in error && error.code === "ENOENT" ? obligation.expected : null;
-                            }
-                        }
-                        case "narrow-ignore": {
-                            if (committedTarget.status !== "available")
-                                return null;
-                            const expected = JSON.parse(obligation.expected.inventory);
-                            const bytes = expected.length === 0 ? "" : `${expected.join("\n")}\n`;
-                            try {
-                                return await fs.readFile(path.join(committedTarget.root, ".gitignore"), "utf8") === bytes ? obligation.expected : null;
-                            }
-                            catch {
-                                return null;
-                            }
-                        }
-                        case "worktree": {
-                            if (observed.lifecycle.phase === "claimed" || observed.lifecycle.phase === "forfeited") {
-                                return committedTarget.workspace === "here" || committedTarget.status === "unavailable"
-                                    ? obligation.expected
-                                    : null;
-                            }
-                            if (committedTarget.status !== "available")
-                                return null;
-                            const [head, clean] = await Promise.all([
-                                readCommitCoordinate(committedTarget.root, "HEAD"),
-                                runGitProcess(committedTarget.root, ["status", "--porcelain=v1", "--untracked-files=no"]),
-                            ]);
-                            const expectedHead = obligation.expected.deliveryHead;
-                            return head.status === "ok" && clean.status === 0 && !clean.error && head.coordinate.commit === expectedHead && clean.stdout === ""
-                                ? obligation.expected
-                                : null;
-                        }
-                        case "renew-delivery": {
-                            if (committedTarget.status !== "available")
-                                return null;
-                            const [head, clean] = await Promise.all([
-                                readCommitCoordinate(committedTarget.root, "HEAD"),
-                                runGitProcess(committedTarget.root, ["status", "--porcelain=v1", "--untracked-files=no"]),
-                            ]);
-                            const expectedHead = obligation.expected.newHead;
-                            return head.status === "ok" && clean.status === 0 && !clean.error && head.coordinate.commit === expectedHead && clean.stdout === ""
-                                ? obligation.expected
-                                : null;
-                        }
-                        case "delivery-ref": {
-                            const projection = await observeTerminalDeliveryRef(stableRoot, contractId);
-                            return projection.status === "aligned" ? obligation.expected : null;
-                        }
-                        case "target-worktree": {
-                            const expected = obligation.expected;
-                            const listed = await runGitProcess(stableRoot, ["worktree", "list", "--porcelain", "-z"]);
-                            if (listed.error || listed.status !== 0)
-                                return null;
-                            let worktree;
-                            for (const field of listed.stdout.split("\0")) {
-                                if (field.startsWith("worktree "))
-                                    worktree = field.slice("worktree ".length);
-                                if (field === `branch ${expected.target}` && worktree) {
-                                    const [head, clean, target] = await Promise.all([
-                                        readCommitCoordinate(worktree, "HEAD"),
-                                        runGitProcess(worktree, ["status", "--porcelain=v1", "--untracked-files=no"]),
-                                        readCommitCoordinate(stableRoot, expected.target),
-                                    ]);
-                                    return head.status === "ok"
-                                        && clean.status === 0 && !clean.error && clean.stdout === ""
-                                        && target.status === "ok" && head.coordinate.commit === target.coordinate.commit
-                                        ? obligation.expected
-                                        : null;
-                                }
-                            }
-                            return obligation.expected;
-                        }
-                        case "task-board": {
-                            // An open bind projects the exact bind-base task bytes into the
-                            // index and working tree. Terminal task settlement has distinct
-                            // target/ref semantics and is deliberately reconciled below.
-                            if (observed.lifecycle.phase === "claimed" || observed.lifecycle.phase === "forfeited")
-                                return null;
-                            const bind = acceptedBind(observed.lifecycle);
-                            const taskIds = obligation.expected.taskIds;
-                            const paths = taskIds.map((taskId) => `.keiyaku/tasks/${taskId}.md`);
-                            const [cached, worktree] = await Promise.all([
-                                runGitProcess(stableRoot, ["diff", "--quiet", "--cached", bind.data.base, "--", ...paths]),
-                                runGitProcess(stableRoot, ["diff", "--quiet", "--", ...paths]),
-                            ]);
-                            return cached.status === 0 && !cached.error && worktree.status === 0 && !worktree.error
-                                ? obligation.expected
-                                : null;
-                        }
-                    }
-                },
-                replayClaimTarget: (landing) => replayClaimTargetWorktree(stableRoot, landing),
-                cleanupWorkspace: terminalWorkspaceCleanup ?? cleanupContractWorkspace,
-                observeDeliveryRef: observeTerminalDeliveryRef,
-            },
-        });
-        const carrierProjection = journal.all().find((row) => row.effect === "carrier-retirement-projection");
-        if (["claimed", "forfeited"].includes(observed.lifecycle.phase) && carrierProjection?.status === "succeeded") {
-            materialized = { status: "retired", contractHead: observed.lifecycle.contractHead, reason: "terminal" };
-        }
-        return materialized;
-    }
-    return {
-        mode,
-        stableRoot,
-        contractId,
-        lifecycle,
-        repository,
-        target,
-        initialCarrier,
-        pins,
-        journal,
-        async completeReplay(_carrierMode = "project") {
-            if (!committedResult)
-                throw new FlowError("INTERNAL_STATE", `contract ${contractId} has no committed mutation to replay`);
-            const materialized = await replayDerivedState();
-            committedResult = {
-                ...committedResult,
-                carrier: materialized,
-                effects: journal.all(),
-                cancellationObserved: effectsStarted && (signal?.aborted ?? false),
-            };
-            return materialized;
-        },
-        replayDerivedState,
-        async reread() {
-            if (!effectsStarted)
-                checkCancellation(signal);
-            const observed = await observe(stableRoot, contractId);
-            currentLifecycle = observed.lifecycle;
-            currentObservation = observed;
-            if (!effectsStarted)
-                checkCancellation(signal);
-            return { lifecycle: observed.lifecycle, repository: observed.repository, target: observed.target, pins: observed.pins };
-        },
-        async revalidate() {
-            if (!effectsStarted)
-                checkCancellation(signal);
-            const observed = await observe(stableRoot, contractId);
-            currentLifecycle = observed.lifecycle;
-            currentObservation = observed;
-            if (!effectsStarted)
-                checkCancellation(signal);
-            return { lifecycle: observed.lifecycle, repository: observed.repository, target: observed.target, pins: observed.pins };
-        },
-        beginEffects() {
-            if (!effectsStarted)
-                checkCancellation(signal);
-            effectsStarted = true;
-        },
-        effectsStarted() {
-            return effectsStarted;
-        },
-        cancellationObserved() {
-            return effectsStarted && (signal?.aborted ?? false);
-        },
-        committedResult() {
-            return committedResult;
-        },
-        async publishAuthoritative(transaction) {
-            if (authoritativeTransactionSelected)
-                throw new FlowError("INTERNAL_STATE", `carrier session ${contractId} already selected an authoritative transaction`);
-            authoritativeTransactionSelected = true;
-            if (transaction.entries.some((entry) => entry.contract !== contractId))
-                throw new FlowError("INTERNAL_STATE", `authoritative transaction does not belong to carrier session ${contractId}`);
-            if (transaction.admittedLedgerHead !== admittedLedgerHead)
-                throw new FlowError("CONCURRENT_MODIFICATION", `authoritative transaction ledger CAS does not match immutable carrier admission ${contractId}`);
-            if (transaction.acceptedLifecycleTail !== admittedLifecycleTail)
-                throw new FlowError("CONCURRENT_MODIFICATION", `authoritative transaction lifecycle tail does not match immutable carrier admission ${contractId}`);
-            return publishRepository(transaction);
-        },
-        async replayCommitted(input) {
-            if (mode !== "mutation")
-                throw new FlowError("INTERNAL_STATE", `carrier ${mode} session cannot replay committed ledger facts`);
-            const observed = await observe(stableRoot, contractId);
-            const accepted = resolveAcceptedLifecycleTransaction({ read: observed.repository, transactionObjectId: input.transactionObjectId, expectedContract: contractId });
-            if (accepted.status !== "accepted")
-                throw new FlowError("CONCURRENT_MODIFICATION", `cannot replay unproved transaction ${input.transactionObjectId}`);
-            const renew = accepted.entries.find((entry) => entry.kind === "renew");
-            const deliveryDescendsFromRenew = renew && observed.pins.delivery.head
-                ? await isCommitAncestor(stableRoot, renew.data.newHead, observed.pins.delivery.head)
-                : false;
-            if (renew && (observed.lifecycle.pins.base !== renew.data.newBase
-                || observed.lifecycle.pins.delivery !== renew.data.newHead
-                || !deliveryDescendsFromRenew)) {
-                throw new FlowError("CONCURRENT_MODIFICATION", `accepted renew transaction ${input.transactionObjectId} no longer matches current coordinates`);
-            }
-            currentLifecycle = observed.lifecycle;
-            return finalizeCommitted({ head: input.transactionObjectId, carrier: input.carrier });
-        },
-    };
-}
-async function convergeCarrier(stableRoot, contractId, lifecycle, target, contractViewWriter) {
-    return publishCarrier({ stableRoot, contractId, lifecycle, target, contractViewWriter });
-}
-export async function convergeContractCarrier(input) {
-    return withContractCarrierSession({ ...input, mode: "observe-only" }, async (session) => ({ lifecycle: session.lifecycle, repository: session.repository, target: session.target, carrier: session.initialCarrier }));
-}
-/** Carrier surface step for the shared reconciler while it owns the carrier gate. */
-export async function reconcileContractCarrierProjection(input) {
-    checkCancellation(input.signal);
-    const stableRoot = await stableRepoRoot(input.cwd);
-    return withContractCarrierSession({ cwd: stableRoot, contractId: input.contractId, mode: "mutation", signal: input.signal, contractViewWriter: input.contractViewWriter }, async (session) => ({
-        lifecycle: session.lifecycle,
-        repository: session.repository,
-        target: session.target,
-        carrier: await convergeCarrier(stableRoot, input.contractId, session.lifecycle, session.target, input.contractViewWriter),
-    }));
-}