@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/core/contract-carrier.js

@@ -1,270 +0,0 @@
-import { 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 { createGit, errorContainsAnyPattern, isFullGitObjectId, MISSING_HEAD_PATTERNS, runGitProcess, wrapGitError } from "../git/core.js";
-import { KEIYAKU_FILE } from "../keiyaku.js";
-import { renderCurrentContractView } 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 { installCarrierRuntimePorts } from "./contract-carrier-runtime.js";
-export { convergeContractCarrier, reconcileContractCarrierProjection, withContractCarrierSession } from "./contract-carrier-runtime.js";
-const BUSY_SLICE_MS = 25;
-const CARRIER_CONTRACT = /^id: (\S+)$/m;
-const CARRIER_PROVENANCE = /^ledger: (\S+)$/m;
-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([
-        runGitProcess(root, ["rev-parse", "--verify", "HEAD^{commit}"]),
-        runGitProcess(root, ["status", "--porcelain=v1", "--untracked-files=no"]),
-    ]);
-    if (head.status !== 0 || head.error || head.stdout.trim() !== 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);
-    if (indexTree === newTree)
-        return "already-present";
-    const oldTree = await resolveCommitTree(input.targetRoot, renew.entry.data.oldHead);
-    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 result = await runGitProcess(cwd, ["rev-parse", "--verify", `${commit}^{tree}`]);
-    if (result.status !== 0 || result.error) {
-        throw new FlowError("INTERNAL_STATE", result.stderr.trim() || result.error?.message || `cannot resolve tree for ${commit}`, { cause: result.error });
-    }
-    return result.stdout.trim();
-}
-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 async function acquireGate(stableRoot, signal) {
-    checkCancellation(signal);
-    const directory = path.join(stableRoot, ".keiyaku");
-    await fs.mkdir(directory, { recursive: true });
-    checkCancellation(signal);
-    let database;
-    try {
-        database = new DatabaseSync(path.join(directory, "contract-carrier.sqlite"));
-        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, signal, action) {
-    const stableRoot = await stableRepoRoot(cwd);
-    const gate = await acquireGate(stableRoot, signal);
-    try {
-        return await action(stableRoot);
-    }
-    finally {
-        releaseGate(gate);
-    }
-}
-export async function readCarrierIdentity(target) {
-    try {
-        return parseCarrierIdentity(await fs.readFile(target, "utf8"));
-    }
-    catch {
-        return null;
-    }
-}
-export function parseCarrierIdentity(source) {
-    const contractId = source.match(CARRIER_CONTRACT)?.[1] ?? "";
-    const ledgerHead = source.match(CARRIER_PROVENANCE)?.[1] ?? "";
-    return isCommissionId(contractId) && isFullGitObjectId(ledgerHead) ? { contractId, ledgerHead } : null;
-}
-export function carrierMatches(identity, contractId, ledgerHead) {
-    return identity?.contractId === contractId && identity.ledgerHead === ledgerHead;
-}
-export async function retireTerminalHereCarrier(lifecycle, target) {
-    if (target.status !== "available" || target.workspace !== "here")
-        return "already-present";
-    let source;
-    try {
-        source = await fs.readFile(target.path, "utf8");
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return "already-present";
-        throw error;
-    }
-    if (parseCarrierIdentity(source)?.contractId !== lifecycle.contract)
-        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", ledgerHead: input.lifecycle.observedLedgerHead, reason: input.target.reason };
-    }
-    if (input.target.workspace === "here") {
-        const occupants = activeWorkspaceHereContracts(input.repository);
-        if (occupants.length !== 1 || occupants[0] !== input.contractId) {
-            return {
-                status: "failed",
-                ledgerHead: input.lifecycle.observedLedgerHead,
-                target: input.target.path,
-                cause: `workspace-here carrier occupancy does not admit ${input.contractId}`,
-            };
-        }
-    }
-    if (carrierMatches(await readCarrierIdentity(input.target.path), input.contractId, input.lifecycle.observedLedgerHead)) {
-        return { status: "current", ledgerHead: input.lifecycle.observedLedgerHead, target: input.target.path };
-    }
-    const directory = path.dirname(input.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, renderCurrentContractView(input.lifecycle), { encoding: "utf8", flag: "wx" });
-        if ((await resolveCommitOrNull(input.stableRoot, REPOSITORY_LEDGER_REF)) !== input.lifecycle.observedLedgerHead) {
-            await fs.unlink(temporary);
-            return { status: "failed", ledgerHead: input.lifecycle.observedLedgerHead, target: input.target.path, cause: "authoritative ledger head changed before carrier replacement" };
-        }
-        await (input.contractViewWriter?.replace ?? fs.rename)(temporary, input.target.path);
-        const [activeHead, carrierIdentity] = await Promise.all([
-            resolveCommitOrNull(input.stableRoot, REPOSITORY_LEDGER_REF),
-            readCarrierIdentity(input.target.path),
-        ]);
-        if (activeHead !== input.lifecycle.observedLedgerHead ||
-            !carrierMatches(carrierIdentity, input.contractId, input.lifecycle.observedLedgerHead)) {
-            return { status: "failed", ledgerHead: input.lifecycle.observedLedgerHead, target: input.target.path, cause: "carrier post-check did not prove the published contract identity and ledger head" };
-        }
-        return { status: "materialized", ledgerHead: input.lifecycle.observedLedgerHead, target: input.target.path };
-    }
-    catch (error) {
-        await fs.unlink(temporary).catch(() => undefined);
-        return { status: "failed", ledgerHead: input.lifecycle.observedLedgerHead, target: input.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 [targetHead, deliveryHead] = await Promise.all([
-        resolveCommitOrNull(stableRoot, targetRef),
-        resolveCommitOrNull(stableRoot, deliveryRef),
-    ]);
-    return { repository, lifecycle, target, pins: { ledgerHead: lifecycle.observedLedgerHead, target: { ref: targetRef, head: targetHead }, delivery: { ref: deliveryRef, head: deliveryHead } } };
-}
-export async function resolveCommitOrNull(cwd, ref) {
-    try {
-        return (await createGit(cwd).raw(["rev-parse", "--verify", `${ref}^{commit}`])).trim();
-    }
-    catch (error) {
-        if (errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS))
-            return null;
-        throw wrapGitError(`rev-parse ${ref}`, error, cwd);
-    }
-}
-installCarrierRuntimePorts({
-    acceptedBind,
-    acquireGate,
-    carrierMatches,
-    checkCancellation,
-    observe,
-    observedLedgerHead,
-    projectRenewDeliveryWorktree,
-    publishCarrier,
-    readCarrierIdentity,
-    reconcileFoldedDeliveryWorktree,
-    releaseGate,
-    resolveCommitOrNull,
-    retireTerminalHereCarrier,
-});

package/build/core/contract-view.js

@@ -1,282 +0,0 @@
-import { shortCommitHash } from "../git/commits.js";
-import { effectiveCriteria } from "./lifecycle-history.js";
-import { renderScopeFragment } from "./scope.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");
-    }
-    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}`),
-        "",
-        ...(bind.data.verification.length > 0
-            ? ["## Verification", ...bind.data.verification.map((declaration) => `- ${declaration}`), ""]
-            : []),
-        ...(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");
-}
-export function renderCurrentContractView(model) {
-    const entries = model.history.map(({ entry }) => entry);
-    return renderContractView({
-        id: model.contract,
-        entries,
-        ledgerHead: model.observedLedgerHead,
-        state: currentLifecycleState(model),
-        effectiveScope: model.effectiveScope,
-    });
-}

package/build/core/contract.js

@@ -1,18 +0,0 @@
-import { z } from "zod";
-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(z.string().trim().min(1)).min(1),
-    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();