@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/contract-carrier.js

@@ -1,353 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { setTimeout as delay } from "node:timers/promises";
-import { DatabaseSync } from "node:sqlite";
-import { FlowError } from "../flow-error.js";
-import { isCommitAncestor, readCommitCoordinate } from "../git/commits.js";
-import { isFullGitObjectId, runGitProcess } from "../git/core.js";
-import { resolveExactRefHeads } from "../git/refs.js";
-import { KEIYAKU_FILE } from "../keiyaku.js";
-import { renderCanonicalCarrierBody } from "./contract-view.js";
-import { isCommissionId } from "./ids.js";
-import { activeWorkspaceHereContracts } from "./repository-ledger/inventory.js";
-import { lookupCurrentContract, readRepositoryLifecycle, } from "./repository-ledger/read-model.js";
-import { REPOSITORY_LEDGER_REF, } from "./repository-ledger/codec.js";
-import { resolveContractCarrierTarget, stableRepoRoot, } from "./worktree-path.js";
-import { carrierDigest, carrierInputIdentity, contractHead, } from "./repository-ledger/identity.js";
-import { installCarrierRuntimePorts } from "./contract-carrier-runtime.js";
-export { convergeContractCarrier, reconcileContractCarrierProjection, withContractCarrierSession, withObservedContractCarrierSession } from "./contract-carrier-runtime.js";
-const BUSY_SLICE_MS = 25;
-const CARRIER_HEADER = "<!-- keiyaku-carrier";
-const CARRIER_HEADER_END = "-->";
-const CARRIER_ID_LINE = "contract-id";
-const CARRIER_HEAD_LINE = "contract-head";
-const CARRIER_DIGEST_LINE = "carrier-digest";
-export function acceptedBind(lifecycle) {
-    for (const { entry } of lifecycle.history) {
-        if (entry.kind === "bind")
-            return entry;
-    }
-    throw new FlowError("INTERNAL_STATE", `contract ${lifecycle.contract} lifecycle is missing bind entry`);
-}
-function diagnostic(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-export async function projectRenewDeliveryWorktree(target, oldHead, newHead) {
-    if (target.status !== "available")
-        throw new FlowError("CARRIER_TARGET_UNAVAILABLE", target.reason);
-    await projectRenewDeliveryRoot(target.root, oldHead, newHead);
-}
-async function projectRenewDeliveryRoot(root, oldHead, newHead) {
-    const update = await runGitProcess(root, ["read-tree", "-m", "-u", oldHead, newHead]);
-    if (update.status !== 0 || update.error) {
-        throw new FlowError("INTERNAL_STATE", update.stderr.trim() || update.error?.message || `read-tree exited ${String(update.status)}`, { cause: update.error });
-    }
-    const [head, status] = await Promise.all([
-        readCommitCoordinate(root, "HEAD"),
-        runGitProcess(root, ["status", "--porcelain=v1", "--untracked-files=no"]),
-    ]);
-    if (head.status !== "ok" || head.coordinate.commit !== newHead || status.status !== 0 || status.error || status.stdout !== "") {
-        throw new FlowError("INTERNAL_STATE", "delivery worktree did not align to the committed renew head");
-    }
-}
-/** Reconstruct the folded delivery projection without creating lifecycle facts. */
-export async function reconcileFoldedDeliveryWorktree(input) {
-    const renew = [...input.lifecycle.history].reverse().find(({ entry }) => (entry.kind === "renew" && entry.data.newHead === input.lifecycle.pins.delivery));
-    if (!renew || renew.entry.kind !== "renew")
-        return "already-present";
-    const [index, worktree] = await Promise.all([
-        runGitProcess(input.targetRoot, ["write-tree"]),
-        runGitProcess(input.targetRoot, ["diff-files", "--quiet"]),
-    ]);
-    if (index.status !== 0 || index.error) {
-        throw new FlowError("INTERNAL_STATE", index.stderr.trim() || index.error?.message || "cannot inspect delivery worktree index", { cause: index.error });
-    }
-    const indexTree = index.stdout.trim();
-    const newTree = await resolveCommitTree(input.targetRoot, renew.entry.data.newHead);
-    const oldTree = await resolveCommitTree(input.targetRoot, renew.entry.data.oldHead);
-    if (indexTree === newTree && worktree.status === 0 && !worktree.error)
-        return "already-present";
-    if (indexTree !== oldTree
-        && worktree.status === 0
-        && !worktree.error
-        && await isCommitAncestor(input.targetRoot, renew.entry.data.newHead, "HEAD")) {
-        return "already-present";
-    }
-    if (indexTree !== oldTree || worktree.status !== 0 || worktree.error) {
-        throw new FlowError("INTERNAL_STATE", `delivery worktree cannot be safely reconstructed for accepted renew ${renew.objectId}`);
-    }
-    await projectRenewDeliveryRoot(input.targetRoot, renew.entry.data.oldHead, renew.entry.data.newHead);
-    return "created";
-}
-async function resolveCommitTree(cwd, commit) {
-    const read = await readCommitCoordinate(cwd, commit);
-    if (read.status !== "ok") {
-        if (read.status === "failed") {
-            throw new FlowError("INTERNAL_STATE", read.result.stderr.trim() || read.error.message || `cannot resolve tree for ${commit}`, { cause: read.error });
-        }
-        throw new FlowError("INTERNAL_STATE", `cannot resolve tree for ${commit}`);
-    }
-    return read.coordinate.tree;
-}
-export function observedLedgerHead(observations) {
-    const observation = observations.find((item) => item.ref === REPOSITORY_LEDGER_REF)?.observed;
-    return observation?.status === "present" ? observation.objectId : null;
-}
-function isBusy(error) {
-    const code = error?.code;
-    return code === "SQLITE_BUSY" || code === "SQLITE_LOCKED" || /database is (?:locked|busy)/i.test(diagnostic(error));
-}
-function throwCancelled() {
-    throw new FlowError("CARRIER_GATE_CANCELLED", "contract carrier operation cancelled before durable effects");
-}
-export function checkCancellation(signal) {
-    if (signal?.aborted)
-        throwCancelled();
-}
-export function carrierPublicationGatePath(stableRoot, contractId, targetPath) {
-    const key = createHash("sha256").update(`${contractId}\0${targetPath}`).digest("hex");
-    return path.join(stableRoot, ".keiyaku", "carrier-gates", `${key}.sqlite`);
-}
-export async function acquireGate(stableRoot, contractId, targetPath, signal) {
-    checkCancellation(signal);
-    const databasePath = carrierPublicationGatePath(stableRoot, contractId, targetPath);
-    const directory = path.dirname(databasePath);
-    await fs.mkdir(directory, { recursive: true });
-    checkCancellation(signal);
-    let database;
-    try {
-        database = new DatabaseSync(databasePath);
-        database.exec(`PRAGMA busy_timeout = ${BUSY_SLICE_MS}`);
-    }
-    catch (error) {
-        throw new FlowError("CARRIER_GATE_UNAVAILABLE", "contract carrier gate is unavailable", { cause: error });
-    }
-    for (;;) {
-        checkCancellation(signal);
-        try {
-            database.exec("BEGIN IMMEDIATE");
-            return database;
-        }
-        catch (error) {
-            if (!isBusy(error)) {
-                database.close();
-                throw new FlowError("CARRIER_GATE_UNAVAILABLE", "contract carrier gate is unavailable", { cause: error });
-            }
-            await delay(BUSY_SLICE_MS, undefined, signal ? { signal } : undefined).catch(() => throwCancelled());
-        }
-    }
-}
-export function releaseGate(database) {
-    try {
-        database.exec("ROLLBACK");
-    }
-    finally {
-        database.close();
-    }
-}
-/** Serialize cross-process committed replay decisions without exposing gate coordinates. */
-export async function withContractReplayGate(cwd, contractId, targetPath, signal, action) {
-    const stableRoot = await stableRepoRoot(cwd);
-    const gate = await acquireGate(stableRoot, contractId, targetPath, signal);
-    try {
-        return await action(stableRoot);
-    }
-    finally {
-        releaseGate(gate);
-    }
-}
-function canonicalBody(lifecycle) {
-    return Buffer.from(renderCanonicalCarrierBody(lifecycle), "utf8");
-}
-export function expectedCarrierIdentity(lifecycle) {
-    return carrierInputIdentity({
-        contractId: lifecycle.contract,
-        contractHead: lifecycle.contractHead,
-        bodyDigest: carrierDigest(createHash("sha256").update(canonicalBody(lifecycle)).digest("hex")),
-    });
-}
-export function renderCarrier(lifecycle) {
-    const identity = expectedCarrierIdentity(lifecycle);
-    return [
-        CARRIER_HEADER,
-        `${CARRIER_ID_LINE}: ${identity.contractId}`,
-        `${CARRIER_HEAD_LINE}: ${identity.contractHead}`,
-        `${CARRIER_DIGEST_LINE}: ${identity.bodyDigest}`,
-        CARRIER_HEADER_END,
-        "",
-        canonicalBody(lifecycle).toString("utf8"),
-    ].join("\n");
-}
-function parsedCarrierFromBytes(source) {
-    if (source.subarray(0, 3).equals(Buffer.from([0xef, 0xbb, 0xbf])))
-        return null;
-    const text = source.toString("utf8");
-    if (!Buffer.from(text, "utf8").equals(source))
-        return null;
-    const lines = text.split("\n");
-    if (lines.length < 7 || lines[0] !== CARRIER_HEADER || lines[4] !== CARRIER_HEADER_END || lines[5] !== "")
-        return null;
-    const field = (line, name) => line.startsWith(`${name}: `) ? line.slice(name.length + 2) : null;
-    const contractId = field(lines[1], CARRIER_ID_LINE);
-    const head = field(lines[2], CARRIER_HEAD_LINE);
-    const digest = field(lines[3], CARRIER_DIGEST_LINE);
-    if (contractId === null || head === null || digest === null || !isCommissionId(contractId) || !isFullGitObjectId(head))
-        return null;
-    try {
-        return {
-            identity: carrierInputIdentity({ contractId, contractHead: contractHead(head), bodyDigest: carrierDigest(digest) }),
-            body: Buffer.from(lines.slice(6).join("\n"), "utf8"),
-        };
-    }
-    catch {
-        return null;
-    }
-}
-/** Strict current-version parser; it intentionally accepts no legacy carrier format. */
-export function parseCarrierIdentity(source) {
-    const parsed = parsedCarrierFromBytes(Buffer.from(source, "utf8"));
-    if (!parsed)
-        return null;
-    const digest = carrierDigest(createHash("sha256").update(parsed.body).digest("hex"));
-    return digest === parsed.identity.bodyDigest ? parsed.identity : null;
-}
-export async function verifyCarrier(input) {
-    const expected = expectedCarrierIdentity(input.lifecycle);
-    let source;
-    try {
-        source = await fs.readFile(input.target);
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return { status: "missing", expected, target: input.target };
-        return { status: "invalid-header", expected, target: input.target };
-    }
-    const parsed = parsedCarrierFromBytes(source);
-    if (!parsed)
-        return { status: "invalid-header", expected, target: input.target };
-    const actualBodyDigest = carrierDigest(createHash("sha256").update(parsed.body).digest("hex"));
-    if (!parsed.body.equals(canonicalBody(input.lifecycle)) || actualBodyDigest !== parsed.identity.bodyDigest) {
-        return { status: "modified", expected, actual: parsed.identity, target: input.target };
-    }
-    if (parsed.identity.contractId !== expected.contractId
-        || parsed.identity.contractHead !== expected.contractHead
-        || parsed.identity.bodyDigest !== expected.bodyDigest) {
-        return { status: "identity-mismatch", expected, actual: parsed.identity, target: input.target };
-    }
-    return { status: "current", expected, actual: parsed.identity, target: input.target };
-}
-export function carrierMatches(verification) {
-    return verification.status === "current";
-}
-export async function retireTerminalHereCarrier(lifecycle, target) {
-    if (target.status !== "available" || target.workspace !== "here")
-        return "already-present";
-    try {
-        await fs.access(target.path);
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return "already-present";
-        throw error;
-    }
-    const verification = await verifyCarrier({ target: target.path, lifecycle });
-    if (!carrierMatches(verification))
-        return "already-present";
-    try {
-        await fs.unlink(target.path);
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return "already-present";
-        throw error;
-    }
-    return "retired";
-}
-export async function publishCarrier(input) {
-    if (input.target.status === "unavailable") {
-        return { status: "target-unavailable", contractHead: input.lifecycle.contractHead, reason: input.target.reason };
-    }
-    const target = input.target;
-    const hasExpectedTarget = async () => {
-        const observed = await observe(input.stableRoot, input.contractId);
-        if (observed.lifecycle.contractHead !== input.lifecycle.contractHead)
-            return false;
-        if (observed.target.status !== "available" || observed.target.path !== target.path || observed.target.workspace !== target.workspace)
-            return false;
-        if (observed.target.workspace === "here") {
-            const occupants = activeWorkspaceHereContracts(observed.repository);
-            return occupants.length === 1 && occupants[0] === input.contractId;
-        }
-        return true;
-    };
-    if (target.workspace === "here" && !await hasExpectedTarget()) {
-        return {
-            status: "failed",
-            contractHead: input.lifecycle.contractHead,
-            target: target.path,
-            cause: `workspace-here carrier occupancy does not admit ${input.contractId}`,
-        };
-    }
-    if (carrierMatches(await verifyCarrier({ target: target.path, lifecycle: input.lifecycle }))) {
-        return { status: "current", contractHead: input.lifecycle.contractHead, target: target.path };
-    }
-    const directory = path.dirname(target.path);
-    const temporary = path.join(directory, `.${path.basename(KEIYAKU_FILE)}.${process.pid}.${randomUUID()}.tmp`);
-    try {
-        await fs.mkdir(directory, { recursive: true });
-        await fs.writeFile(temporary, renderCarrier(input.lifecycle), { encoding: "utf8", flag: "wx" });
-        if (!await hasExpectedTarget()) {
-            await fs.unlink(temporary);
-            return { status: "failed", contractHead: input.lifecycle.contractHead, target: target.path, cause: "contract carrier target changed before replacement" };
-        }
-        await (input.contractViewWriter?.replace ?? fs.rename)(temporary, target.path);
-        const verification = await verifyCarrier({ target: target.path, lifecycle: input.lifecycle });
-        if (!await hasExpectedTarget() || !carrierMatches(verification)) {
-            return { status: "failed", contractHead: input.lifecycle.contractHead, target: target.path, cause: "carrier post-check did not prove the published contract identity" };
-        }
-        return { status: "materialized", contractHead: input.lifecycle.contractHead, target: target.path };
-    }
-    catch (error) {
-        await fs.unlink(temporary).catch(() => undefined);
-        return { status: "failed", contractHead: input.lifecycle.contractHead, target: target.path, cause: diagnostic(error) };
-    }
-}
-export async function observe(stableRoot, contractId) {
-    const repository = await readRepositoryLifecycle(stableRoot);
-    const outcome = lookupCurrentContract(repository, contractId);
-    if (outcome.status !== "healthy") {
-        const detail = outcome.status === "absent" ? "not found" : `unavailable (${outcome.status})`;
-        const diagnosticDetail = outcome.status === "absent"
-            ? ""
-            : `: ${outcome.diagnostics.map(({ code, detail: message }) => `${code}: ${message}`).join("; ")}`;
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} is ${detail} in the repository lifecycle read model${diagnosticDetail}`, {
-            ...(outcome.status === "absent" ? {} : { facts: { kind: "repository_lifecycle_disease", contractId, status: outcome.status, diagnostics: outcome.diagnostics.map((item) => ({ ...item })) } }),
-        });
-    }
-    const lifecycle = outcome.model;
-    const bind = acceptedBind(lifecycle);
-    const target = await resolveContractCarrierTarget(stableRoot, contractId, bind);
-    const targetRef = lifecycle.pins.target.ref;
-    const deliveryRef = lifecycle.resources.deliveryRef;
-    const heads = await resolveExactRefHeads(stableRoot, [targetRef, deliveryRef]);
-    const targetHead = heads.get(targetRef) ?? null;
-    const deliveryHead = heads.get(deliveryRef) ?? null;
-    if (repository.observedLedgerHead === null)
-        throw new FlowError("INTERNAL_STATE", "accepted contract has no repository ledger observation");
-    return { repository, lifecycle, target, pins: { repositoryLedgerHead: repository.observedLedgerHead, target: { ref: targetRef, head: targetHead }, delivery: { ref: deliveryRef, head: deliveryHead } } };
-}
-installCarrierRuntimePorts({
-    acceptedBind,
-    acquireGate,
-    carrierMatches,
-    checkCancellation,
-    expectedCarrierIdentity,
-    observe,
-    observedLedgerHead,
-    publishCarrier,
-    verifyCarrier,
-    reconcileFoldedDeliveryWorktree,
-    releaseGate,
-    retireTerminalHereCarrier,
-});

package/build/core/contract-view.js

@@ -1,319 +0,0 @@
-import { shortCommitHash } from "../git/commits.js";
-import { effectiveCriteria, effectiveVerification } from "./lifecycle-history.js";
-import { renderScopeFragment } from "./scope.js";
-import { renderVerificationDeclarations } from "./verification-declaration.js";
-import { currentLifecycleState, } from "./repository-ledger/read-model.js";
-export { currentLifecycleState } from "./repository-ledger/read-model.js";
-const VERB_COLUMN_WIDTH = 11;
-const TIME_COLUMN_WIDTH = 6;
-const ACTOR_COLUMN_WIDTH = 11;
-function compactWhitespace(value) {
-    return value.replace(/\s+/g, " ").trim();
-}
-function elapsedLabel(anchorAt, at) {
-    const anchorMs = Date.parse(anchorAt);
-    const currentMs = Date.parse(at);
-    if (!Number.isFinite(anchorMs) || !Number.isFinite(currentMs) || currentMs >= anchorMs) {
-        return "now";
-    }
-    const seconds = Math.max(0, Math.floor((anchorMs - currentMs) / 1_000));
-    if (seconds < 60)
-        return `${seconds}s`;
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 60)
-        return `${minutes}m`;
-    const hours = Math.floor(minutes / 60);
-    if (hours < 24)
-        return `${hours}h`;
-    return `${Math.floor(hours / 24)}d`;
-}
-function sealAggregate(entries) {
-    return entries.reduce((total, entry) => {
-        if (entry.kind !== "seal")
-            return total;
-        return {
-            insertions: total.insertions + entry.data.diffstat.insertions,
-            deletions: total.deletions + entry.data.diffstat.deletions,
-        };
-    }, { insertions: 0, deletions: 0 });
-}
-function scopeStatusFact(entry) {
-    if (entry.data.scopeAudit.violations.length === 0)
-        return "scope ✓ clean";
-    return `scope ✕ ${entry.data.scopeAudit.violations.length}`;
-}
-function formatDiffstat(insertions, deletions) {
-    return `+${insertions} −${deletions}`;
-}
-function joinFactClusters(clusters) {
-    return clusters.filter((cluster) => Boolean(cluster)).join(" · ");
-}
-function sealsByArc(entries) {
-    const seals = new Map();
-    for (const entry of entries) {
-        if (entry.kind === "seal") {
-            seals.set(entry.data.arc, entry);
-        }
-    }
-    return seals;
-}
-function renderOpenArcFact(entry) {
-    return joinFactClusters([`open ${compactWhitespace(entry.data.title)}`, compactWhitespace(entry.data.brief)]);
-}
-function renderSealFacts(entry) {
-    return [
-        joinFactClusters([
-            `${entry.data.receipts.length} receipts`,
-            formatDiffstat(entry.data.diffstat.insertions, entry.data.diffstat.deletions),
-            scopeStatusFact(entry),
-        ]),
-    ];
-}
-function bootstrapTimeoutMs(entries) {
-    const bind = entries.find((entry) => entry.kind === "bind");
-    return bind && "bootstrap" in bind.data ? bind.data.bootstrap?.timeoutMs : undefined;
-}
-function renderBootstrapFacts(entry, entries) {
-    const duration = `duration ${entry.data.durationMs}ms`;
-    let first;
-    switch (entry.data.result.kind) {
-        case "exit":
-            first = joinFactClusters([`exit ${entry.data.result.code}`, duration]);
-            break;
-        case "signal":
-            first = joinFactClusters([`signal ${entry.data.result.signal}`, duration]);
-            break;
-        case "timeout": {
-            const timeoutMs = bootstrapTimeoutMs(entries);
-            first =
-                timeoutMs === undefined
-                    ? joinFactClusters([`timeout`, duration])
-                    : joinFactClusters([`timeout ${timeoutMs}ms`, duration]);
-            break;
-        }
-        case "spawn":
-            first = joinFactClusters([
-                "spawn error",
-                compactWhitespace(entry.data.result.message),
-                duration,
-            ]);
-            break;
-    }
-    const facts = [first];
-    if (entry.data.stderrTail !== undefined) {
-        const tail = compactWhitespace(entry.data.stderrTail);
-        facts.push(entry.data.stderrTruncated ? `┆ stderr …${tail}` : `┆ stderr ${tail}`);
-    }
-    return facts;
-}
-function renderEventFacts(entry, entries) {
-    switch (entry.kind) {
-        case "bind":
-            return [
-                joinFactClusters([
-                    `workspace ${entry.data.workspace}`,
-                    entry.data.workspace === "worktree" ? `place ${entry.data.place}` : null,
-                    `base ${shortCommitHash(entry.data.base)}`,
-                    `scope ${entry.data.scope.length}`,
-                    entry.data.after && entry.data.after.length > 0 ? `after ${entry.data.after.length}` : null,
-                ]),
-            ];
-        case "bootstrap":
-            return renderBootstrapFacts(entry, entries);
-        case "arc":
-            return [renderOpenArcFact(entry)];
-        case "seal":
-            return renderSealFacts(entry);
-        case "amend":
-            return [compactWhitespace(entry.data.amendment)];
-        case "renew":
-            return [
-                `${shortCommitHash(entry.data.oldBase)}..${shortCommitHash(entry.data.oldHead)} → ${shortCommitHash(entry.data.newBase)}..${shortCommitHash(entry.data.newHead)}`,
-            ];
-        case "petition":
-            return [joinFactClusters([`intent ${entry.data.intent}`]), "┆ 誓言"];
-        case "verdict": {
-            const seal = entry.data.result === "approved" ? "準" : "却";
-            return [`${seal} ${compactWhitespace(entry.data.summary)}`];
-        }
-        case "claim": {
-            const aggregate = sealAggregate(entries);
-            return [joinFactClusters([formatDiffstat(aggregate.insertions, aggregate.deletions), `ledger ${entries.length}`])];
-        }
-        case "forfeit":
-            return [
-                joinFactClusters([
-                    entry.data.reason === "manual" ? "裁决人" : entry.data.reason,
-                    entry.data.note ? `「${compactWhitespace(entry.data.note)}」` : null,
-                    `by ${entry.data.actor}`,
-                ]),
-            ];
-    }
-}
-function headGlyph(entry) {
-    if (entry.kind === "forfeit")
-        return "×";
-    return "·";
-}
-function renderDisplayRow(row) {
-    const [firstFact = "", ...restFacts] = row.facts;
-    return [
-        `${row.glyph}  ${row.verb.padEnd(VERB_COLUMN_WIDTH)}${row.time.padEnd(TIME_COLUMN_WIDTH)}${row.actor.padEnd(ACTOR_COLUMN_WIDTH)}${firstFact}`.trimEnd(),
-        ...restFacts,
-    ];
-}
-function displayRowForEntry(entry, anchorAt, entries) {
-    const actor = entry.kind === "claim" ? "engine" : entry.kind === "petition" ? "holder" : entry.actor;
-    const verb = entry.kind === "arc" ? `arc ${entry.data.arc}` : entry.kind;
-    return {
-        glyph: headGlyph(entry),
-        time: elapsedLabel(anchorAt, entry.at),
-        actor,
-        verb,
-        facts: renderEventFacts(entry, entries),
-    };
-}
-function displayRowForSeal(entry, anchorAt) {
-    return {
-        glyph: headGlyph(entry),
-        time: elapsedLabel(anchorAt, entry.at),
-        actor: entry.actor,
-        verb: `arc ${entry.data.arc}`,
-        facts: renderSealFacts(entry),
-    };
-}
-function renderLedgerRows(entries) {
-    const anchorAt = entries.at(-1)?.at ?? entries[0].at;
-    const body = [...terminalHeader(entries)];
-    const sealedArcs = sealsByArc(entries);
-    const newestFirst = [...entries].reverse();
-    for (const entry of newestFirst) {
-        if (entry.kind === "arc" && sealedArcs.has(entry.data.arc)) {
-            continue;
-        }
-        const row = entry.kind === "seal"
-            ? displayRowForSeal(entry, anchorAt)
-            : displayRowForEntry(entry, anchorAt, entries);
-        body.push(...renderDisplayRow(row));
-    }
-    return body;
-}
-export function terminalHeader(entries) {
-    const terminal = entries.at(-1);
-    if (!terminal || terminal.kind !== "claim")
-        return [];
-    return [`◆  現世 ${shortCommitHash(terminal.data.mergeCommit)}`, "├─╯"];
-}
-export function renderVerticalLog(input) {
-    if (input.entries.length === 0) {
-        return "(empty ledger)";
-    }
-    return renderLedgerRows(input.entries).join("\n");
-}
-export function renderContractView(input) {
-    const bind = input.entries.find((entry) => entry.kind === "bind");
-    const state = input.state;
-    if (!bind) {
-        return [
-            "# Keiyaku Contract",
-            "",
-            "generated by keiyaku - edits are not read back",
-            "",
-            `id: ${input.id}`,
-            `state: ${state.state}`,
-            ...(input.ledgerHead ? [`ledger: ${input.ledgerHead}`] : []),
-            "",
-            "log:",
-            renderVerticalLog(input),
-            "",
-        ].join("\n");
-    }
-    const verification = effectiveVerification(input.entries);
-    return [
-        `# ${bind.data.title}`,
-        "",
-        "generated by keiyaku - edits are not read back",
-        "",
-        `id: ${input.id}`,
-        `state: ${state.state}`,
-        ...(input.ledgerHead ? [`ledger: ${input.ledgerHead}`] : []),
-        `base: ${bind.data.base}`,
-        `workspace: ${bind.data.workspace}`,
-        `place: ${bind.data.workspace === "worktree" ? bind.data.place : "(none)"}`,
-        `after: ${(bind.data.after ?? []).join(", ") || "(none)"}`,
-        "",
-        "## Context",
-        bind.data.context,
-        "",
-        "## Objective",
-        bind.data.objective,
-        "",
-        "## Design & Approach",
-        bind.data.design,
-        "",
-        "## Scope",
-        ...renderScopeFragment(input.effectiveScope).split("\n"),
-        "",
-        "## Criteria",
-        ...effectiveCriteria(input.entries).map((criterion) => `- ${criterion}`),
-        "",
-        ...(verification.length > 0
-            ? ["## Verification", renderVerificationDeclarations(verification), ""]
-            : []),
-        ...(bind.data.extensions.length > 0
-            ? [
-                ...bind.data.extensions.flatMap((extension) => extension.content.length > 0
-                    ? [`## ${extension.title}`, extension.content, ""]
-                    : [`## ${extension.title}`, ""]),
-            ]
-            : []),
-        "log:",
-        renderVerticalLog(input),
-        "",
-    ].join("\n");
-}
-/** Exact UTF-8/LF carrier body; metadata and diagnostic renderings stay outside it. */
-export function renderCanonicalCarrierBody(model) {
-    const entries = model.history.map(({ entry }) => entry);
-    const bind = entries.find((entry) => entry.kind === "bind");
-    if (!bind)
-        throw new Error(`contract ${model.contract} has no bind body to render`);
-    const verification = effectiveVerification(entries);
-    return [
-        `# ${bind.data.title}`,
-        "",
-        "## Context",
-        bind.data.context,
-        "",
-        "## Objective",
-        bind.data.objective,
-        "",
-        "## Design & Approach",
-        bind.data.design,
-        "",
-        "## Scope",
-        ...renderScopeFragment(model.effectiveScope).split("\n"),
-        "",
-        "## Criteria",
-        ...effectiveCriteria(entries).map((criterion) => `- ${criterion}`),
-        "",
-        ...(verification.length > 0
-            ? ["## Verification", renderVerificationDeclarations(verification), ""]
-            : []),
-        ...(bind.data.extensions.length > 0
-            ? bind.data.extensions.flatMap((extension) => extension.content.length > 0
-                ? [`## ${extension.title}`, extension.content, ""]
-                : [`## ${extension.title}`, ""])
-            : []),
-    ].join("\n").replace(/\n*$/, "\n");
-}
-export function renderCurrentContractView(model, observedLedgerHead) {
-    const entries = model.history.map(({ entry }) => entry);
-    return renderContractView({
-        id: model.contract,
-        entries,
-        ledgerHead: observedLedgerHead ?? undefined,
-        state: currentLifecycleState(model),
-        effectiveScope: model.effectiveScope,
-    });
-}

package/build/core/contract.js

@@ -1,19 +0,0 @@
-import { z } from "zod";
-import { verificationDeclarationSchema } from "./verification-declaration.js";
-export const contractStateSchema = z.enum(["bound", "active", "petitioned", "claimed", "forfeited"]);
-export const contractRecordSchema = z
-    .object({
-    id: z.string().trim().min(1),
-    title: z.string().trim().min(1),
-    context: z.string().trim().min(1),
-    objective: z.string().trim().min(1),
-    design: z.string().trim().min(1),
-    scope: z.array(z.string().trim().min(1)).min(1),
-    criteria: z.array(z.string().trim().min(1)).min(1),
-    verification: z.array(verificationDeclarationSchema),
-    base: z.string().trim().min(1),
-    place: z.string().trim().min(1).nullable().optional(),
-    after: z.array(z.string().trim().min(1)),
-    state: contractStateSchema,
-})
-    .strict();