@astrosheep/keiyaku 4.6.11 → 4.6.13

package/build/src/kanshi/read.js

@@ -152,18 +152,35 @@ async function readHolders(observation) {
         return { kind: "failed", failure: { message: diagnostic(error) } };
     }
 }
-function attachRoster(contracts, akuma) {
+function attachRoster(contracts, akuma, dispatches) {
     if (contracts.kind !== "present")
         return contracts;
+    if (dispatches.kind === "failed" || akuma.kind === "failed") {
+        return {
+            kind: "present",
+            value: {
+                ...contracts.value,
+                rows: contracts.value.rows.map((row) => ({ ...row, roster: [], rosterUnavailable: true })),
+            },
+        };
+    }
+    if (dispatches.kind === "absent" || akuma.kind === "absent") {
+        return {
+            kind: "present",
+            value: { ...contracts.value, rows: contracts.value.rows.map((row) => ({ ...row, roster: [] })) },
+        };
+    }
     const attachments = new Map();
-    if (akuma.kind === "present") {
-        for (const row of akuma.value.rows) {
-            if (row.contract === undefined)
-                continue;
-            const current = attachments.get(row.contract.id) ?? [];
-            current.push({ id: row.id, aliases: row.aliases });
-            attachments.set(row.contract.id, current);
-        }
+    for (const row of akuma.value.rows) {
+        if (row.contract === undefined)
+            continue;
+        const current = attachments.get(row.contract.id) ?? [];
+        current.push({
+            id: row.id,
+            aliases: row.aliases,
+            ...(akuma.value.aliasesUnavailable === true ? { aliasesUnavailable: true } : {}),
+        });
+        attachments.set(row.contract.id, current);
     }
     return {
         kind: "present",
@@ -173,7 +190,7 @@ function attachRoster(contracts, akuma) {
         },
     };
 }
-function decorateContracts(contracts, holders, namespaceDebts) {
+function decorateContracts(contracts, holders, dispatches, namespaceDebts) {
     if (contracts.kind !== "present")
         return contracts;
     return {
@@ -182,22 +199,17 @@ function decorateContracts(contracts, holders, namespaceDebts) {
             ...contracts.value,
             rows: contracts.value.rows.map((row) => {
                 const selected = namespaceDebts?.(row.id);
-                if (holders.kind === "failed") {
-                    return {
-                        ...row,
-                        holder: { kind: "unavailable" },
-                        roster: [],
-                        ...(selected === undefined ? {} : { namespaceDebts: selected }),
-                    };
-                }
                 const holder = holders.kind === "present" ? holders.value.get(row.id) : undefined;
                 return {
                     ...row,
                     roster: [],
+                    ...(dispatches.kind === "failed" ? { rosterUnavailable: true } : {}),
                     ...(selected === undefined ? {} : { namespaceDebts: selected }),
-                    holder: holder?.disposition === "held"
-                        ? { kind: "held", debtId: holder.debtId }
-                        : { kind: "none" },
+                    holder: holders.kind === "failed"
+                        ? { kind: "unavailable" }
+                        : holder?.disposition === "held"
+                            ? { kind: "held", debtId: holder.debtId }
+                            : { kind: "none" },
                 };
             }),
         },
@@ -214,18 +226,26 @@ function contractEndpointObserver(contracts) {
         return "hasMore" in contracts.value ? "unavailable" : "missing";
     };
 }
-function joinDebts(rows, holders, observeContract) {
+function joinDebts(section, holders, observeContract) {
+    if (section.kind !== "present")
+        return section;
     const associations = new Map(holders.kind === "present"
         ? [...holders.value.values()]
             .filter((holder) => holder.disposition === "held")
             .map((holder) => [holder.debtId, holder.contractId])
         : []);
-    return rows.map((row) => {
-        const contractId = associations.get(row.id);
-        if (contractId === undefined)
-            return row;
-        return { ...row, contract: { id: contractId, observed: observeContract(contractId) } };
-    });
+    return {
+        kind: "present",
+        value: {
+            ...section.value,
+            rows: section.value.rows.map((row) => {
+                if (holders.kind === "failed")
+                    return { ...row, contractAssociationUnavailable: true };
+                const id = associations.get(row.id);
+                return id === undefined ? row : { ...row, contract: { id, observed: observeContract(id) } };
+            }),
+        },
+    };
 }
 /** Attribute a Debt board failure to the malformed document that caused it, when one is known. */
 function debtFailure(error) {
@@ -257,13 +277,38 @@ function namespaceDebtSection(board, id) {
         return undefined;
     return { kind: "present", value: board.observation.selectNamespace(contractNamespace(id)) };
 }
-async function readDebts(path, holders, observeContract) {
-    if (holders.kind === "failed")
-        return { kind: "failed", failure: holders.failure };
-    return observeRecentDebtStatus(path, { limit: 10 }).then((recent) => ({
+function debtRowsFromBoard(path, board) {
+    if (path === null || board.kind === "absent")
+        return { kind: "absent" };
+    if (board.kind === "failed")
+        return { kind: "failed", failure: board.failure };
+    const recent = board.observation.selectRecentStatus(10);
+    return {
         kind: "present",
-        value: { root: path, hasMore: recent.hasMore, rows: joinDebts(recent.rows, holders, observeContract) },
-    }), (error) => ({ kind: "failed", failure: debtFailure(error) }));
+        value: {
+            root: path,
+            hasMore: recent.hasMore,
+            rows: recent.rows.map((row) => {
+                const copy = { ...row };
+                delete copy.children;
+                return copy;
+            }),
+        },
+    };
+}
+async function readDebtRows(path) {
+    if (path === null)
+        return { kind: "absent" };
+    try {
+        const recent = await observeRecentDebtStatus(path, { limit: 10 });
+        return {
+            kind: "present",
+            value: { root: path, hasMore: recent.hasMore, rows: recent.rows },
+        };
+    }
+    catch (error) {
+        return { kind: "failed", failure: debtFailure(error) };
+    }
 }
 /**
  * Placement discharge for the observed roster snapshots: an associated Contract
@@ -285,33 +330,10 @@ async function claimedAssociatedContracts(observation, dispatches) {
     }));
     return claimed;
 }
-async function joinAkuma(path, observeContract, isContractClaimed, dispatches, input) {
-    const { aliases, limit = ROSTER_VISIBLE_ROWS } = input;
-    if (aliases.kind !== "present")
-        return aliases;
+async function readAkumaProduct(path, limit = ROSTER_VISIBLE_ROWS) {
     try {
         const source = await observeAkumaRoster(path, limit);
-        const aliasById = new Map();
-        for (const binding of aliases.value)
-            aliasById.set(binding.akuId, [...(aliasById.get(binding.akuId) ?? []), binding]);
-        const dispatchById = new Map(dispatches.map((dispatch) => [dispatch.akuId, dispatch]));
-        const rows = source.rows.map((row) => {
-            const dispatch = dispatchById.get(row.id);
-            return {
-                ...row,
-                aliases: (aliasById.get(row.id) ?? []).map((binding) => binding.alias),
-                ...(dispatch === undefined
-                    ? {}
-                    : {
-                        contract: {
-                            id: dispatch.contractId,
-                            observed: observeContract(dispatch.contractId),
-                        },
-                    }),
-            };
-        });
-        const snapshotRows = rows.slice(0, ROSTER_SNAPSHOT_ROWS);
-        const snapshots = new Map(await Promise.all(snapshotRows.map(async (row) => {
+        const snapshots = new Map(await Promise.all(source.rows.slice(0, ROSTER_SNAPSHOT_ROWS).map(async (row) => {
             try {
                 return [row.id, await readAkumaTimeline(path, row.id)];
             }
@@ -323,12 +345,9 @@ async function joinAkuma(path, observeContract, isContractClaimed, dispatches, i
             kind: "present",
             value: {
                 ...source,
-                rows: rows.map((row) => {
+                rows: source.rows.map((row) => {
                     const snapshot = snapshots.get(row.id);
-                    if (snapshot === undefined)
-                        return row;
-                    const placed = row.contract !== undefined && isContractClaimed(row.contract.id);
-                    return { ...row, snapshot: placed ? withoutReportedChanges(snapshot) : snapshot };
+                    return snapshot === undefined ? row : { ...row, snapshot };
                 }),
             },
         };
@@ -337,6 +356,43 @@ async function joinAkuma(path, observeContract, isContractClaimed, dispatches, i
         return { kind: "failed", failure: { message: diagnostic(error) } };
     }
 }
+function attachAkumaAssociations(product, aliases, dispatches, observeContract, claimed) {
+    if (product.kind !== "present")
+        return product;
+    const aliasById = new Map();
+    if (aliases.kind === "present") {
+        for (const binding of aliases.value)
+            aliasById.set(binding.akuId, [...(aliasById.get(binding.akuId) ?? []), binding]);
+    }
+    const dispatchById = new Map(dispatches.kind === "present" ? dispatches.value.map((dispatch) => [dispatch.akuId, dispatch]) : []);
+    return {
+        kind: "present",
+        value: {
+            ...product.value,
+            ...(aliases.kind === "failed" ? { aliasesUnavailable: true } : {}),
+            rows: product.value.rows.map((row) => {
+                const dispatch = dispatchById.get(row.id);
+                const { snapshot } = row;
+                const placed = dispatch !== undefined && claimed.has(dispatch.contractId);
+                return {
+                    ...row,
+                    aliases: aliases.kind === "present" ? (aliasById.get(row.id) ?? []).map((binding) => binding.alias) : [],
+                    ...(dispatches.kind === "failed"
+                        ? { contractAssociationUnavailable: true }
+                        : dispatch === undefined
+                            ? {}
+                            : {
+                                contract: {
+                                    id: dispatch.contractId,
+                                    observed: observeContract(dispatch.contractId),
+                                },
+                            }),
+                    ...(snapshot === undefined ? {} : { snapshot: placed ? withoutReportedChanges(snapshot) : snapshot }),
+                };
+            }),
+        },
+    };
+}
 async function readAliasBindings(path) {
     try {
         return { kind: "present", value: await readAliases(path) };
@@ -356,12 +412,15 @@ async function readDispatches(observation) {
 async function observeWithoutRepo(world, region, observedAt, branch) {
     const contracts = { kind: "absent" };
     const holders = { kind: "absent" };
+    const dispatches = { kind: "absent" };
+    const [debtRows, aliases, akumaProduct] = world === null
+        ? [{ kind: "absent" }, { kind: "absent" }, { kind: "absent" }]
+        : await Promise.all([readDebtRows(world), readAliasBindings(world), readAkumaProduct(world)]);
     const observeContract = contractEndpointObserver(contracts);
-    const debts = world === null ? { kind: "absent" } : await readDebts(world, holders, observeContract);
-    const aliases = world === null ? { kind: "absent" } : await readAliasBindings(world);
+    const debts = world === null ? debtRows : joinDebts(debtRows, holders, observeContract);
     const akuma = world === null
-        ? { kind: "absent" }
-        : await joinAkuma(world, observeContract, () => false, [], { aliases });
+        ? akumaProduct
+        : attachAkumaAssociations(akumaProduct, aliases, dispatches, observeContract, new Set());
     return {
         report: {
             root: world,
@@ -375,8 +434,42 @@ async function observeWithoutRepo(world, region, observedAt, branch) {
         aliases,
     };
 }
+/**
+ * The repository-observation failure view: a failed Contract and Region beside the
+ * independently observed Debt, Alias, and Akuma sections. Debt reports the rows
+ * already observed before the failure and performs the existing fallback read only
+ * when none were.
+ */
+async function observeRepoFailure(input, error, akumaProduct, aliases, observedDebtRows) {
+    const { world, region, observedAt, branch } = input;
+    const failure = { kind: "failed", failure: { message: diagnostic(error) } };
+    const debtRows = observedDebtRows ?? (await readDebtRows(world));
+    const observeContract = contractEndpointObserver(failure);
+    return {
+        report: {
+            root: world,
+            observedAt,
+            branch,
+            contracts: failure,
+            debts: world === null ? { kind: "absent" } : joinDebts(debtRows, failure, observeContract),
+            akuma: world === null
+                ? { kind: "absent" }
+                : attachAkumaAssociations(akumaProduct, aliases, failure, observeContract, new Set()),
+            ...(region === undefined ? {} : { region: failure }),
+        },
+        aliases,
+    };
+}
 async function observeRepo(input) {
     const { world, repo, region, contract, observedAt, branch } = input;
+    const [initialDebtRows, aliases, akumaProduct] = world === null
+        ? [{ kind: "absent" }, { kind: "absent" }, { kind: "absent" }]
+        : await Promise.all([
+            contract === undefined ? readDebtRows(world) : Promise.resolve(undefined),
+            readAliasBindings(world),
+            readAkumaProduct(world),
+        ]);
+    let observedDebtRows = initialDebtRows;
     try {
         return await withGitDecodeChannel(repo, (channel) => withGitReadObservation(repo, channel, async (observation) => {
             const [contractSection, holders, dispatches, regionSection] = await Promise.all([
@@ -389,23 +482,26 @@ async function observeRepo(input) {
                 contractSection.kind === "present" &&
                 contractSection.value.rows.some((row) => row.id === contract);
             const board = selectedContract ? await readDebtWorld(world) : undefined;
-            const contracts = decorateContracts(contractSection, holders, selectedContract ? (id) => (id === contract ? namespaceDebtSection(board, id) : undefined) : undefined);
+            observedDebtRows =
+                world === null
+                    ? { kind: "absent" }
+                    : board === undefined
+                        ? (initialDebtRows ?? (await readDebtRows(world)))
+                        : debtRowsFromBoard(world, board);
+            const contracts = decorateContracts(contractSection, holders, dispatches, board === undefined ? undefined : (id) => (id === contract ? namespaceDebtSection(board, id) : undefined));
             const observeContract = contractEndpointObserver(contracts);
-            const aliases = world === null ? { kind: "absent" } : await readAliasBindings(world);
-            const debts = world === null ? { kind: "absent" } : await readDebts(world, holders, observeContract);
+            const debts = world === null ? observedDebtRows : joinDebts(observedDebtRows, holders, observeContract);
             const claimed = dispatches.kind === "present"
                 ? await claimedAssociatedContracts(observation, dispatches.value)
                 : new Set();
             const akuma = world === null
-                ? { kind: "absent" }
-                : dispatches.kind === "failed"
-                    ? dispatches
-                    : await joinAkuma(world, observeContract, (id) => claimed.has(id), dispatches.value, { aliases });
+                ? akumaProduct
+                : attachAkumaAssociations(akumaProduct, aliases, dispatches, observeContract, claimed);
             const assembled = {
                 root: world,
                 observedAt,
                 branch,
-                contracts: attachRoster(contracts, akuma),
+                contracts: attachRoster(contracts, akuma, dispatches),
                 debts,
                 akuma,
                 ...(regionSection === undefined ? {} : { region: regionSection }),
@@ -423,19 +519,7 @@ async function observeRepo(input) {
         }));
     }
     catch (error) {
-        const failure = { kind: "failed", failure: { message: diagnostic(error) } };
-        return {
-            report: {
-                root: world,
-                observedAt,
-                branch,
-                contracts: failure,
-                debts: world === null ? { kind: "absent" } : failure,
-                akuma: world === null ? { kind: "absent" } : failure,
-                ...(region === undefined ? {} : { region: failure }),
-            },
-            aliases: world === null ? { kind: "absent" } : failure,
-        };
+        return await observeRepoFailure(input, error, akumaProduct, aliases, observedDebtRows);
     }
 }
 export async function observeKanshi(input) {
@@ -459,25 +543,23 @@ async function observeAkumaCategory(world, repo, limit, observedAt) {
     });
     if (world === null)
         return report({ kind: "absent" });
-    const composed = async (observation) => {
-        const aliases = await readAliasBindings(world);
-        if (aliases.kind !== "present")
-            return report(aliases);
-        if (observation === undefined)
-            return report(await joinAkuma(world, () => "unavailable", () => false, [], { aliases, limit }));
-        const dispatches = await readDispatches(observation);
-        if (dispatches.kind === "failed")
-            return report(dispatches);
-        const claimed = await claimedAssociatedContracts(observation, dispatches.value);
-        return report(await joinAkuma(world, () => "unavailable", (id) => claimed.has(id), dispatches.value, { aliases, limit }));
-    };
+    const aliases = await readAliasBindings(world);
+    const product = await readAkumaProduct(world, limit);
+    const compose = (dispatches, claimed) => report(attachAkumaAssociations(product, aliases, dispatches, () => "unavailable", claimed));
     if (repo === undefined)
-        return await composed();
+        return compose({ kind: "absent" }, new Set());
     try {
-        return await withGitDecodeChannel(repo, (channel) => withGitReadObservation(repo, channel, composed));
+        return await withGitDecodeChannel(repo, (channel) => withGitReadObservation(repo, channel, async (observation) => {
+            const dispatches = await readDispatches(observation);
+            const claimed = dispatches.kind === "present"
+                ? await claimedAssociatedContracts(observation, dispatches.value)
+                : new Set();
+            return compose(dispatches, claimed);
+        }));
     }
     catch (error) {
-        return report({ kind: "failed", failure: { message: diagnostic(error) } });
+        const failure = { kind: "failed", failure: { message: diagnostic(error) } };
+        return compose(failure, new Set());
     }
 }
 async function observeContractCategory(world, repo, limit, observedAt) {
@@ -493,7 +575,7 @@ async function observeContractCategory(world, repo, limit, observedAt) {
                 readContracts(observation, undefined, limit),
                 readHolders(observation),
             ]);
-            return report(decorateContracts(contracts, holders));
+            return report(decorateContracts(contracts, holders, { kind: "absent" }));
         }));
     }
     catch (error) {

package/build/src/kanshi/report.d.ts

@@ -33,11 +33,13 @@ export type ContractHolderObservation = Readonly<{
 export type ContractRosterAttachment = Readonly<{
     id: string;
     aliases: readonly AkumaAlias[];
+    aliasesUnavailable?: true;
 }>;
 export type ContractKanshiRow = ContractBoard["rows"][number] & Readonly<{
     phase: ContractPhase;
     holder: ContractHolderObservation;
     roster: readonly ContractRosterAttachment[];
+    rosterUnavailable?: true;
     namespaceDebts?: Section<readonly DebtRow[]>;
     issue?: CurrentPhysicalIssue;
 }>;
@@ -50,6 +52,7 @@ export type DebtKanshiRow = DebtRow & Readonly<{
         id: string;
         observed: ContractEndpointObservation;
     }>;
+    contractAssociationUnavailable?: true;
     blockers?: readonly DebtRef[];
 }>;
 export type DebtKanshiWorld = BoundedList<DebtKanshiRow> & Readonly<{
@@ -61,10 +64,12 @@ export type AkumaKanshiRow = (AkumaListRow | UnbornAkumaListRow) & Readonly<{
         id: string;
         observed: ContractEndpointObservation;
     }>;
+    contractAssociationUnavailable?: true;
     snapshot?: ActivitySnapshot;
 }>;
 export type AkumaKanshiWorld = Omit<AkumaList, "rows"> & Readonly<{
     rows: readonly AkumaKanshiRow[];
+    aliasesUnavailable?: true;
 }>;
 export type KanshiRegionSelection = Readonly<{
     kind: "declarations";

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

@@ -3,8 +3,9 @@ import { type AliasBinding } from "../alias/index.js";
 import { type AkuId } from "../akuma/identity.js";
 import { contractId } from "../core/facts/types.js";
 import { type AkumaAlias } from "../identity/selector.js";
+import type { Section } from "../kanshi/index.js";
+import type { ContractRow } from "../protocol/read/status.js";
 import { type WorldRoot } from "../world.js";
-import type { KanshiReport, Section } from "../kanshi/index.js";
 import { type Repo } from "./repo.js";
 export type AkumaAddressInput = Readonly<{
     akuma: string;
@@ -46,11 +47,24 @@ export type NamedAddress = Readonly<{
     kind: "akuma";
     id: AkuId;
 }>;
-export type NamedAddressInput = Readonly<{
-    selector: string;
-    report: KanshiReport;
+/** The frozen authority a named selector is adjudicated against. */
+export type NamedAddressAuthority = Readonly<{
+    contracts: Section<readonly ContractRow[]>;
     aliases: Section<readonly AliasBinding[]>;
 }>;
+export type NamedAddressInput = NamedAddressAuthority & Readonly<{
+    selector: string;
+}>;
+/**
+ * Freeze the one complete Contract candidate observation and the Alias
+ * observation a named selector is judged against. The complete candidate set is
+ * the Contract owner's board, so display-age bounds never decide membership. An
+ * absent Repo is a World without a Contract family, not a failed observation.
+ */
+export declare function observeNamedAddress(input: Readonly<{
+    world: WorldRoot | null;
+    repo: Repo | null;
+}>): Promise<NamedAddressAuthority>;
 export declare function resolveNamedAddress(input: NamedAddressInput): NamedAddress;
 type AddressedAkuma = Readonly<{
     path: WorldRoot;

package/build/src/library/address.js

@@ -7,7 +7,7 @@ import { contractId } from "../core/facts/types.js";
 import { readDispatches } from "../dispatch/index.js";
 import { matchesAkumaGlob, parseReadableAkumaAlias, parseAkumaGlob, } from "../identity/selector.js";
 import { World } from "../world.js";
-import { matchContractCandidates } from "./contract-address.js";
+import { matchContractCandidates, readCompleteContractCandidates } from "./contract-address.js";
 import { requireInput } from "./input.js";
 import { scopeForRepo } from "./repo.js";
 export class AkumaAddressError extends Error {
@@ -63,6 +63,27 @@ async function directId(path, selector) {
     }
     return parseAddressId(selector).id;
 }
+async function observe(read) {
+    try {
+        return { kind: "present", value: await read() };
+    }
+    catch (error) {
+        return { kind: "failed", failure: { message: error instanceof Error ? error.message : String(error) } };
+    }
+}
+/**
+ * Freeze the one complete Contract candidate observation and the Alias
+ * observation a named selector is judged against. The complete candidate set is
+ * the Contract owner's board, so display-age bounds never decide membership. An
+ * absent Repo is a World without a Contract family, not a failed observation.
+ */
+export async function observeNamedAddress(input) {
+    const { world, repo } = input;
+    return {
+        contracts: repo === null ? { kind: "absent" } : await observe(() => readCompleteContractCandidates(repo)),
+        aliases: world === null ? { kind: "absent" } : await observe(() => readAliases(world)),
+    };
+}
 export function resolveNamedAddress(input) {
     const selector = nonblank(input.selector, "selector");
     if (selector.startsWith("kei/"))
@@ -70,7 +91,9 @@ export function resolveNamedAddress(input) {
     if (selector.startsWith("aku/"))
         return { kind: "akuma", id: parseAddressId(selector).id };
     const alias = parseAddressAlias(selector);
-    const contractMatches = matchContractCandidates(input.report.contracts.kind === "present" ? input.report.contracts.value.rows : [], { selector: alias });
+    const contractMatches = matchContractCandidates(input.contracts.kind === "present" ? input.contracts.value : [], {
+        selector: alias,
+    });
     const aliasId = input.aliases.kind === "present"
         ? (input.aliases.value.find((binding) => binding.alias === alias)?.akuId ?? null)
         : null;
@@ -84,12 +107,10 @@ export function resolveNamedAddress(input) {
         return { kind: "contract", id: contractMatches[0].id };
     if (contractMatches.length > 1)
         throw new TypeError(`ambiguous Contract selector: ${selector}`);
-    if (input.report.contracts.kind === "failed") {
+    if (input.contracts.kind === "failed")
         throw new TypeError("cannot resolve a named selector while the Contract world is failed");
-    }
-    if (input.aliases.kind === "failed") {
+    if (input.aliases.kind === "failed")
         throw new TypeError("cannot resolve a named selector while Alias authority is failed");
-    }
     throw new AkumaAddressError({ kind: "akuma-alias-not-found", alias });
 }
 /**

package/build/src/library/contract-address.d.ts

@@ -1,9 +1,15 @@
 import type { ContractRow } from "../protocol/read/status.js";
 import type { ContractResolution, ContractResolveInput } from "./contract-types.js";
+import { type Repo } from "./repo.js";
 /** Pure Contract membership shared with mixed Address; no cross-family judgment. */
 export declare function matchContractCandidates(rows: readonly ContractRow[], selection: Readonly<{
     selector: string;
 }> | Readonly<{
     cwd: string;
 }>): readonly ContractRow[];
+/**
+ * The complete live Contract candidates a named selection judges membership
+ * against. No display bound applies, so age never decides which names exist.
+ */
+export declare function readCompleteContractCandidates(repo: Repo): Promise<readonly ContractRow[]>;
 export declare function resolveContract(input: ContractResolveInput): Promise<ContractResolution>;

package/build/src/library/contract-address.js

@@ -15,6 +15,17 @@ export function matchContractCandidates(rows, selection) {
             ? `@${row.id.slice("kei/".length)}` === selection.selector
             : normalize(row.worktreePath) === selection.cwd));
 }
+/** The complete live Contract board: the Contract owner's own candidate set, never a display catalogue. */
+function completeBoard(scope) {
+    return withGitDecodeChannel(scope, (channel) => contractsOperation({ scope, channel }));
+}
+/**
+ * The complete live Contract candidates a named selection judges membership
+ * against. No display bound applies, so age never decides which names exist.
+ */
+export async function readCompleteContractCandidates(repo) {
+    return (await completeBoard(scopeForRepo(repo))).rows;
+}
 export async function resolveContract(input) {
     const values = requireInput(input, "Keiyaku.with().resolve input", ["repo", "selector", "cwd"]);
     const scope = scopeForRepo(values.repo);
@@ -54,7 +65,7 @@ export async function resolveContract(input) {
             };
         }
     }
-    const board = await readContractValue(() => withGitDecodeChannel(scope, (channel) => contractsOperation({ scope, channel })));
+    const board = await readContractValue(() => completeBoard(scope));
     const candidates = matchContractCandidates(board.rows, selector === undefined ? { cwd } : { selector });
     if (candidates.length === 1)
         return { kind: "resolved", id: candidates[0].id };

package/build/src/library/contract-execution.d.ts

@@ -1,7 +1,7 @@
 import { type ExecutionContext } from "../akuma/requests.js";
 import { type ContractId } from "../core/facts/types.js";
 import { type RepositoryScope } from "../protocol/operations.js";
-import type { AbandonOutcome, AmendOutcome, ArcOutcome, AuditInput, AuditOutcome, DeliverOutcome, MutationObservation, ReviewOutcome } from "./contract-outcomes.js";
+import type { AbandonOutcome, AmendOutcome, ArcOutcome, DeliveryPreviewInput, DeliveryPreviewOutcome, DeliverOutcome, MutationObservation, ReviewOutcome } from "./contract-outcomes.js";
 import { type LocalContractCompositionCapture } from "./contract-settings.js";
 import type { AbandonInput, AmendInput, ArcInput, DeliverInput, ReviewInput } from "./contract-types.js";
 export declare class ContractExecution {
@@ -23,7 +23,7 @@ export declare class ContractExecution {
     review(input: ReviewInput, options?: MutationObservation): Promise<ReviewOutcome>;
     abandon(input?: AbandonInput): Promise<AbandonOutcome>;
     arc(input: ArcInput): Promise<ArcOutcome>;
-    audit(input?: AuditInput, options?: MutationObservation): Promise<AuditOutcome>;
+    previewDelivery(input?: DeliveryPreviewInput, options?: MutationObservation): Promise<DeliveryPreviewOutcome>;
     /** One accumulator before the first admission-capable await, one projector after teardown. */
     private local;
     private conclude;