@astrosheep/keiyaku 2.9.8 → 2.9.10

package/build/core/lifecycle-history.js

@@ -0,0 +1,35 @@
+import { FlowError } from "../flow-error.js";
+import { normalizeSectionTitle } from "./markdown/titles.js";
+import { markdownSourceSections } from "./scope.js";
+export function effectiveScope(entries) {
+    const bind = entries.find((entry) => entry.kind === "bind");
+    if (!bind)
+        throw new FlowError("INTERNAL_STATE", "lifecycle history must contain bind entry");
+    const scope = [...bind.data.scope];
+    for (const entry of entries) {
+        if (entry.kind === "amend" && entry.data.scopeDelta)
+            scope.push(...entry.data.scopeDelta.add);
+    }
+    return scope;
+}
+/** Ordered contract-wide criteria derived from admitted lifecycle history. */
+export function effectiveCriteria(entries) {
+    const bind = entries.find((entry) => entry.kind === "bind");
+    if (!bind)
+        throw new FlowError("INTERNAL_STATE", "lifecycle history must contain bind entry");
+    const criteria = [...bind.data.criteria];
+    for (const entry of entries) {
+        if (entry.kind !== "amend")
+            continue;
+        for (const section of markdownSourceSections(entry.data.amendment)) {
+            if (section.level !== 2 || normalizeSectionTitle(section.title) !== "criteria")
+                continue;
+            for (const line of entry.data.amendment.slice(section.contentStart, section.end).split(/\r?\n/)) {
+                const match = line.match(/^\s*-\s+(.+)$/);
+                if (match)
+                    criteria.push(match[1].trim());
+            }
+        }
+    }
+    return criteria;
+}

package/build/core/lifecycle-recovery.js

@@ -0,0 +1,117 @@
+import { withContractCarrierSession } from "./contract-carrier.js";
+import { resolveAcceptedLifecycleTransaction, } from "./repository-ledger/accepted-tail.js";
+export async function reconcileCommittedMutation(plan) {
+    const observed = await withContractCarrierSession({ cwd: plan.cwd, contractId: plan.contractId, mode: "observe-only", signal: plan.signal }, async (session) => ({
+        model: session.lifecycle,
+        repository: session.repository,
+    }));
+    const authoritativeHead = observed.model.observedLedgerHead;
+    const accepted = findLatestAcceptedTransaction(observed.repository, plan.contractId, observed.model.history.at(-1)?.objectId ?? null);
+    if (accepted.status === "refused") {
+        return {
+            kind: "refused",
+            authoritativeHead,
+            refusal: {
+                code: "OUTSTANDING_REPLAY_UNPROVEN",
+                message: `contract ${plan.contractId} recovery transaction is not accepted by the current typed ledger fold`,
+                facts: { reason: accepted.reason, transactionObjectId: accepted.transactionObjectId },
+            },
+        };
+    }
+    if (accepted.status === "accepted") {
+        if (accepted.transaction.verb === "bind" || accepted.transaction.verb === "bootstrap") {
+            const replayed = await alignDerivedTransaction(plan, accepted.transaction);
+            if (replayed.kind === "refused")
+                return replayed;
+            return observeOrdinaryCoordinate(plan);
+        }
+        if (accepted.transaction.verb !== plan.mutation.verb) {
+            const replayed = await alignDerivedTransaction(plan, accepted.transaction);
+            if (replayed.kind === "refused")
+                return replayed;
+            return observeOrdinaryCoordinate(plan);
+        }
+        const transaction = accepted.transaction;
+        if (plan.mutation.matchesAccepted && !plan.mutation.matchesAccepted(transaction)) {
+            const replayed = await alignDerivedTransaction(plan, transaction);
+            if (replayed.kind === "refused")
+                return replayed;
+            return observeOrdinaryCoordinate(plan);
+        }
+        return {
+            kind: "aligned",
+            coordinate: { state: "verb-committed", invokedVerb: plan.mutation.verb, transaction, authoritativeHead },
+        };
+    }
+    if (observed.model.phase === "claimed" || observed.model.phase === "forfeited") {
+        return {
+            kind: "refused",
+            authoritativeHead,
+            refusal: { code: "CONTRACT_TERMINAL", message: `contract ${plan.contractId} is terminal (${observed.model.phase})` },
+        };
+    }
+    const bindObjectId = observed.model.history.find(({ entry }) => entry.kind === "bind")?.objectId;
+    if (!bindObjectId) {
+        return {
+            kind: "refused",
+            authoritativeHead,
+            refusal: { code: "INTERNAL_STATE", message: `contract ${plan.contractId} typed lifecycle has no bind object` },
+        };
+    }
+    return {
+        kind: "aligned",
+        coordinate: {
+            state: "bind-aligned",
+            invokedVerb: plan.mutation.verb,
+            bindObjectId,
+            authoritativeHead,
+        },
+    };
+}
+async function alignDerivedTransaction(plan, transaction) {
+    return withContractCarrierSession({ cwd: plan.cwd, contractId: plan.contractId, mode: "mutation", signal: plan.signal }, async (session) => {
+        try {
+            await session.replayCommitted({
+                transactionObjectId: transaction.transactionObjectId,
+                ...(transaction.verb === "claim" || transaction.verb === "forfeit" ? { carrier: "retire" } : {}),
+            });
+            await session.completeReplay(transaction.verb === "claim" || transaction.verb === "forfeit" ? "retire" : "project");
+            return { kind: "aligned" };
+        }
+        catch (error) {
+            return {
+                kind: "refused",
+                authoritativeHead: session.lifecycle.observedLedgerHead,
+                refusal: {
+                    code: "LIFECYCLE_RECONCILIATION_INCOMPLETE",
+                    message: error instanceof Error ? error.message : `contract ${plan.contractId} derived replay did not complete`,
+                },
+            };
+        }
+    });
+}
+async function observeOrdinaryCoordinate(plan) {
+    return withContractCarrierSession({ cwd: plan.cwd, contractId: plan.contractId, mode: "observe-only", signal: plan.signal }, async (session) => bindAligned(session.lifecycle.history, plan, session.lifecycle.observedLedgerHead));
+}
+function bindAligned(history, plan, authoritativeHead) {
+    const bindObjectId = history.find(({ entry }) => entry.kind === "bind")?.objectId;
+    if (!bindObjectId) {
+        return {
+            kind: "refused",
+            authoritativeHead,
+            refusal: { code: "INTERNAL_STATE", message: "typed lifecycle has no bind object" },
+        };
+    }
+    return { kind: "aligned", coordinate: { state: "bind-aligned", invokedVerb: plan.mutation.verb, bindObjectId, authoritativeHead } };
+}
+function findLatestAcceptedTransaction(read, contractId, finalEntryObjectId) {
+    if (finalEntryObjectId === null)
+        return { status: "none" };
+    const node = read.topology.nodes.find((candidate) => candidate.type === "transaction"
+        && candidate.contract === contractId
+        && candidate.finalEntryObjectId === finalEntryObjectId);
+    if (!node || node.type !== "transaction")
+        return { status: "none" };
+    const resolved = resolveAcceptedLifecycleTransaction({ read, transactionObjectId: node.objectId, expectedContract: contractId });
+    return resolved.status === "accepted" ? { status: "accepted", transaction: resolved } : resolved;
+}

package/build/core/lifecycle-runner.js

@@ -0,0 +1,377 @@
+import { FlowError } from "../flow-error.js";
+import { withContractCarrierSession, } from "./contract-carrier.js";
+import { cancelledLifecycleFacts, committedLifecycleFacts, containedCommittedLifecycleFacts, precommitLifecycleFacts, refusedLifecycleFacts, } from "./outcome-base.js";
+import { resolveAcceptedLifecycleTransaction } from "./repository-ledger/accepted-tail.js";
+import { reconcileCommittedMutation, } from "./lifecycle-recovery.js";
+function coordinateObject(pins, target) {
+    return {
+        ledgerHead: pins.ledgerHead,
+        targetRef: pins.target.ref,
+        targetHead: pins.target.head,
+        deliveryRef: pins.delivery.ref,
+        deliveryHead: pins.delivery.head,
+        carrierTarget: target.status === "available" ? target.path : null,
+    };
+}
+function sameCoordinates(admission, session) {
+    const left = coordinateObject(admission.pins, admission.target);
+    const right = coordinateObject(session.pins, session.target);
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function validateReplayCoordinate(session, coordinate) {
+    if (coordinate.state === "bind-aligned") {
+        const currentHead = session.lifecycle.observedLedgerHead;
+        if (coordinate.authoritativeHead !== currentHead) {
+            return {
+                code: "LIFECYCLE_REPLAY_COORDINATES_CHANGED",
+                message: "repository ledger head changed during lifecycle admission; retry",
+                pinned: { authoritativeHead: coordinate.authoritativeHead },
+                current: { authoritativeHead: currentHead },
+            };
+        }
+        const bindObjectId = session.lifecycle.history.find(({ entry }) => entry.kind === "bind")?.objectId ?? null;
+        return bindObjectId === coordinate.bindObjectId
+            ? undefined
+            : {
+                code: "LIFECYCLE_REPLAY_COORDINATES_CHANGED",
+                message: "typed bind coordinate changed after replay classification; retry",
+                pinned: { bindObjectId: coordinate.bindObjectId },
+                current: { bindObjectId },
+            };
+    }
+    const resolved = resolveAcceptedLifecycleTransaction({
+        read: session.repository,
+        transactionObjectId: coordinate.transaction.transactionObjectId,
+        expectedContract: session.contractId,
+    });
+    if (resolved.status === "accepted" && resolved.verb === coordinate.invokedVerb)
+        return undefined;
+    return {
+        code: "LIFECYCLE_REPLAY_COORDINATES_CHANGED",
+        message: "accepted lifecycle transaction changed after replay classification; retry",
+        pinned: {
+            transactionObjectId: coordinate.transaction.transactionObjectId,
+            verb: coordinate.invokedVerb,
+        },
+        current: {
+            status: resolved.status,
+            authoritativeHead: session.lifecycle.observedLedgerHead,
+        },
+    };
+}
+function surfaceCoordinateRefusal(mutation, refusal) {
+    return mutation.coordinateChangeRefusal
+        ? { ...refusal, ...mutation.coordinateChangeRefusal }
+        : refusal;
+}
+function isCancellation(error) {
+    return error instanceof FlowError && error.code === "CARRIER_GATE_CANCELLED";
+}
+function flowRefusal(error) {
+    return {
+        code: error.code,
+        message: error.message,
+        ...(error.facts ? { facts: error.facts } : {}),
+    };
+}
+function containedCause(error) {
+    const source = error;
+    return {
+        code: typeof source?.code === "string" ? source.code : "LIFECYCLE_EFFECT_FAILED",
+        message: typeof source?.message === "string" ? source.message : String(error),
+    };
+}
+function journalContainmentCause(session) {
+    const row = session.journal.all().find((candidate) => candidate.status !== "succeeded");
+    if (!row)
+        return undefined;
+    if (row.status === "failed")
+        return row.cause;
+    return {
+        code: row.cause.code,
+        message: row.cause.message,
+        facts: { effect: row.effect, dependency: row.dependency },
+    };
+}
+/** Canonical two-admission execution shape for an existing-contract lifecycle verb. */
+export async function runLifecycle(plan) {
+    let observedHead = null;
+    let admission;
+    try {
+        const reconciliation = await reconcileCommittedMutation({
+            cwd: plan.cwd,
+            contractId: plan.contractId,
+            mutation: plan.mutation,
+            signal: plan.signal,
+        });
+        if (reconciliation.kind === "refused") {
+            return {
+                kind: "noncommitted",
+                outcome: refusedLifecycleFacts({
+                    contractId: plan.contractId,
+                    authoritativeHead: reconciliation.authoritativeHead,
+                    ...reconciliation.refusal,
+                }),
+            };
+        }
+        const attempt = await withContractCarrierSession({ cwd: plan.cwd, contractId: plan.contractId, mode: "observe-only", signal: plan.signal }, async (session) => {
+            observedHead = session.lifecycle.observedLedgerHead;
+            const replayRefusal = validateReplayCoordinate(session, reconciliation.coordinate);
+            if (replayRefusal) {
+                return { kind: "refused", outcome: refusedLifecycleFacts({
+                        contractId: plan.contractId,
+                        authoritativeHead: session.lifecycle.observedLedgerHead,
+                        ...surfaceCoordinateRefusal(plan.mutation, replayRefusal),
+                    }) };
+            }
+            let business;
+            try {
+                business = await plan.admit(session, reconciliation.coordinate);
+            }
+            catch (error) {
+                if (error instanceof FlowError && !isCancellation(error)) {
+                    return { kind: "refused", outcome: refusedLifecycleFacts({ contractId: plan.contractId, authoritativeHead: session.lifecycle.observedLedgerHead, ...flowRefusal(error) }) };
+                }
+                throw error;
+            }
+            return {
+                kind: "admitted",
+                ledgerHead: session.lifecycle.observedLedgerHead,
+                lifecycle: session.lifecycle,
+                repository: session.repository,
+                pins: session.pins,
+                target: session.target,
+                carrier: session.initialCarrier,
+                replay: reconciliation.coordinate,
+                business,
+            };
+        });
+        if (attempt.kind === "refused")
+            return { kind: "noncommitted", outcome: attempt.outcome };
+        admission = attempt;
+    }
+    catch (error) {
+        if (isCancellation(error))
+            return { kind: "noncommitted", outcome: cancelledLifecycleFacts(plan.contractId, observedHead) };
+        throw error;
+    }
+    let prepared;
+    try {
+        if (plan.signal?.aborted)
+            return { kind: "noncommitted", outcome: cancelledLifecycleFacts(plan.contractId, observedHead) };
+        prepared = await plan.prepare(admission);
+        if (plan.signal?.aborted)
+            return { kind: "noncommitted", outcome: cancelledLifecycleFacts(plan.contractId, observedHead) };
+    }
+    catch (error) {
+        if (isCancellation(error) || plan.signal?.aborted)
+            return { kind: "noncommitted", outcome: cancelledLifecycleFacts(plan.contractId, observedHead) };
+        if (error instanceof FlowError) {
+            return { kind: "noncommitted", outcome: refusedLifecycleFacts({ contractId: plan.contractId, authoritativeHead: admission.ledgerHead, ...flowRefusal(error) }) };
+        }
+        throw error;
+    }
+    try {
+        return await withContractCarrierSession({ cwd: plan.cwd, contractId: plan.contractId, mode: "mutation", signal: plan.signal, ...(plan.renewDeliveryProjector ? { renewDeliveryProjector: plan.renewDeliveryProjector } : {}), ...(plan.terminalWorkspaceCleanup ? { terminalWorkspaceCleanup: plan.terminalWorkspaceCleanup } : {}) }, async (session) => {
+            observedHead = session.lifecycle.observedLedgerHead;
+            const replayRefusal = validateReplayCoordinate(session, admission.replay);
+            if (replayRefusal) {
+                return { kind: "noncommitted", outcome: refusedLifecycleFacts({
+                        contractId: plan.contractId,
+                        authoritativeHead: session.lifecycle.observedLedgerHead,
+                        ...surfaceCoordinateRefusal(plan.mutation, replayRefusal),
+                    }) };
+            }
+            if (!sameCoordinates(admission, session)) {
+                return { kind: "noncommitted", outcome: refusedLifecycleFacts({
+                        contractId: plan.contractId,
+                        authoritativeHead: session.lifecycle.observedLedgerHead,
+                        code: "LIFECYCLE_COORDINATES_CHANGED",
+                        message: "contract coordinates changed during lifecycle preparation",
+                        pinned: coordinateObject(admission.pins, admission.target),
+                        current: coordinateObject(session.pins, session.target),
+                    }) };
+            }
+            let refusal;
+            try {
+                refusal = await plan.revalidate({ session, admission, prepared });
+            }
+            catch (error) {
+                if (!(error instanceof FlowError) || isCancellation(error))
+                    throw error;
+                refusal = flowRefusal(error);
+            }
+            if (refusal) {
+                return { kind: "noncommitted", outcome: refusedLifecycleFacts({ contractId: plan.contractId, authoritativeHead: session.lifecycle.observedLedgerHead, ...refusal }) };
+            }
+            const effectSession = Object.freeze({
+                stableRoot: session.stableRoot,
+                lifecycle: session.lifecycle,
+                pins: session.pins,
+                completeReplay: (carrier) => session.completeReplay(carrier),
+            });
+            const context = {
+                session: effectSession,
+                journal: session.journal,
+                beginEffects: () => session.beginEffects(),
+                publishAuthoritative: (authoritativeTransaction) => {
+                    const submittedTransaction = authoritativeTransaction;
+                    if (submittedTransaction.verb !== plan.mutation.verb) {
+                        throw new FlowError("INTERNAL_STATE", `${plan.mutation.verb} lifecycle effect cannot publish ${submittedTransaction.verb} authoritative transaction`);
+                    }
+                    return session.publishAuthoritative(submittedTransaction);
+                },
+                replayCommitted: (input) => session.replayCommitted(input),
+            };
+            let result;
+            try {
+                result = await plan.effect({ context, admission, prepared });
+                if (result.kind === "committed") {
+                    const replayIncomplete = session.journal.all().some((row) => row.status !== "succeeded");
+                    if (!replayIncomplete) {
+                        await session.completeReplay(plan.mutation.verb === "claim" || plan.mutation.verb === "forfeit" ? "retire" : "project");
+                        result = { ...result, commit: session.committedResult() };
+                    }
+                }
+            }
+            catch (error) {
+                if (!session.effectsStarted()) {
+                    if (error instanceof FlowError && !isCancellation(error)) {
+                        return { kind: "noncommitted", outcome: refusedLifecycleFacts({
+                                contractId: plan.contractId,
+                                authoritativeHead: session.lifecycle.observedLedgerHead,
+                                ...flowRefusal(error),
+                            }) };
+                    }
+                    throw error;
+                }
+                await session.journal.run({
+                    effect: "unhandled-effect-boundary",
+                    run: () => { throw error; },
+                });
+                const committed = session.committedResult();
+                if (committed) {
+                    const ledgerCas = session.journal.rows("prerequisite").find((row) => row.effect === "ledger-cas" && row.status === "succeeded");
+                    const entryKind = ledgerCas?.status === "succeeded" && typeof ledgerCas.receipt?.entryKind === "string"
+                        ? ledgerCas.receipt.entryKind
+                        : "unknown";
+                    return {
+                        kind: "contained",
+                        outcome: containedCommittedLifecycleFacts({
+                            head: committed.head,
+                            entryKind,
+                            contractId: plan.contractId,
+                            carrier: committed.carrier,
+                            cancellationObserved: session.cancellationObserved(),
+                            prerequisites: session.journal.rows("prerequisite"),
+                            downstream: session.journal.rows("downstream"),
+                            cause: containedCause(error),
+                        }),
+                        carrier: committed.carrier,
+                    };
+                }
+                return {
+                    kind: "noncommitted",
+                    outcome: precommitLifecycleFacts({
+                        contractId: plan.contractId,
+                        authoritativeHead: session.lifecycle.observedLedgerHead,
+                        journal: session.journal,
+                        cancellationObserved: session.cancellationObserved(),
+                    }),
+                };
+            }
+            if (result.kind !== "committed") {
+                const committed = session.committedResult();
+                if (committed) {
+                    const ledgerCas = session.journal.all().find((row) => row.effect === "ledger-cas" && row.status === "succeeded");
+                    const entryKind = ledgerCas?.status === "succeeded" && typeof ledgerCas.receipt?.entryKind === "string"
+                        ? ledgerCas.receipt.entryKind
+                        : "unknown";
+                    const cause = journalContainmentCause(session) ?? {
+                        code: result.kind === "refused-before-effects" ? result.refusal.code : "LIFECYCLE_RECONCILIATION_INCOMPLETE",
+                        message: result.kind === "refused-before-effects" ? result.refusal.message : "committed lifecycle reconciliation did not complete",
+                    };
+                    return {
+                        kind: "contained",
+                        outcome: containedCommittedLifecycleFacts({
+                            head: committed.head,
+                            entryKind,
+                            contractId: plan.contractId,
+                            carrier: committed.carrier,
+                            cancellationObserved: session.cancellationObserved(),
+                            prerequisites: session.journal.rows("prerequisite"),
+                            downstream: session.journal.rows("downstream"),
+                            cause,
+                        }),
+                        carrier: committed.carrier,
+                    };
+                }
+            }
+            if (result.kind === "precommit-effects-only") {
+                return {
+                    kind: "noncommitted",
+                    outcome: precommitLifecycleFacts({
+                        contractId: plan.contractId,
+                        authoritativeHead: result.authoritativeHead,
+                        journal: session.journal,
+                        cancellationObserved: session.cancellationObserved(),
+                    }),
+                };
+            }
+            if (result.kind === "refused-before-effects") {
+                if (session.effectsStarted()) {
+                    return {
+                        kind: "noncommitted",
+                        outcome: precommitLifecycleFacts({
+                            contractId: plan.contractId,
+                            authoritativeHead: result.authoritativeHead,
+                            journal: session.journal,
+                            cancellationObserved: session.cancellationObserved(),
+                        }),
+                    };
+                }
+                return { kind: "noncommitted", outcome: refusedLifecycleFacts({
+                        contractId: plan.contractId,
+                        authoritativeHead: result.authoritativeHead,
+                        ...result.refusal,
+                    }) };
+            }
+            const degraded = journalContainmentCause(session);
+            if (degraded) {
+                return {
+                    kind: "contained",
+                    outcome: containedCommittedLifecycleFacts({
+                        head: result.commit.head,
+                        entryKind: result.entryKind,
+                        contractId: plan.contractId,
+                        carrier: result.commit.carrier,
+                        cancellationObserved: result.commit.cancellationObserved,
+                        prerequisites: session.journal.rows("prerequisite"),
+                        downstream: session.journal.rows("downstream"),
+                        cause: degraded,
+                    }),
+                    carrier: result.commit.carrier,
+                };
+            }
+            return {
+                kind: "complete",
+                outcome: committedLifecycleFacts({
+                    head: result.commit.head,
+                    entryKind: result.entryKind,
+                    contractId: plan.contractId,
+                    carrier: result.commit.carrier,
+                    cancellationObserved: result.commit.cancellationObserved,
+                    prerequisites: session.journal.rows("prerequisite"),
+                    downstream: session.journal.rows("downstream"),
+                }),
+                payload: result.value,
+                carrier: result.commit.carrier,
+            };
+        });
+    }
+    catch (error) {
+        if (isCancellation(error))
+            return { kind: "noncommitted", outcome: cancelledLifecycleFacts(plan.contractId, observedHead) };
+        throw error;
+    }
+}

package/build/core/log.js

@@ -1,24 +1,50 @@
 import { FlowError } from "../flow-error.js";
-import { readLedger } from "./ledger.js";
-import { renderContractView } from "./contract-view.js";
-import { deriveContractState } from "./status/lifecycle.js";
+import { getConfig } from "../config/env.js";
+import { renderCurrentContractView } from "./contract-view.js";
+import { currentLifecycleState, lookupCurrentContract, readRepositoryLifecycle, } from "./repository-ledger/read-model.js";
+function amendmentWarning(model) {
+    const state = currentLifecycleState(model);
+    if (state.state === "claimed" || state.state === "forfeited")
+        return undefined;
+    const amendmentCount = model.history.filter((row) => row.entry.kind === "amend").length;
+    const threshold = getConfig().amendmentWarning.threshold;
+    return amendmentCount > threshold ? { amendmentCount, threshold } : undefined;
+}
+function unavailableLogError(contractId, outcome) {
+    return new FlowError("INTERNAL_STATE", `contract ${contractId} is unavailable because repository lifecycle evidence is ${outcome.status}`, {
+        facts: {
+            kind: "repository_lifecycle_disease",
+            contractId,
+            status: outcome.status,
+            diagnostics: outcome.diagnostics.map((diagnostic) => ({
+                objectId: diagnostic.objectId,
+                code: diagnostic.code,
+                detail: diagnostic.detail,
+                ...(diagnostic.contract === undefined ? {} : { contract: diagnostic.contract }),
+            })),
+        },
+    });
+}
 export async function readContractLog(input) {
-    const ledger = await readLedger(input.cwd, input.contractId);
-    if (!ledger) {
+    const read = await readRepositoryLifecycle(input.cwd);
+    const outcome = lookupCurrentContract(read, input.contractId);
+    if (outcome.status === "absent") {
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} not found`);
     }
+    if (outcome.status !== "healthy")
+        throw unavailableLogError(input.contractId, outcome);
+    const model = outcome.model;
+    const warning = amendmentWarning(model);
     return {
         contractId: input.contractId,
-        state: deriveContractState(ledger.entries),
-        entries: ledger.entries.map((entry, index) => ({
+        state: currentLifecycleState(model),
+        entries: model.history.map(({ entry }, index) => ({
             index: index + 1,
             kind: entry.kind,
             at: entry.at,
             actor: entry.actor,
         })),
-        markdown: renderContractView({
-            id: input.contractId,
-            entries: ledger.entries,
-        }),
+        markdown: renderCurrentContractView(model),
+        ...(warning ? { amendmentWarning: warning } : {}),
     };
 }