@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/library/address.js

@@ -0,0 +1,165 @@
+import { readAliases } from "../alias/index.js";
+import { Akuma } from "../akuma/akuma.js";
+import { probeBornAkuma } from "../akuma/index.js";
+import { parseAkuId } from "../akuma/identity.js";
+import { contractId } from "../core/facts/types.js";
+import { readDispatches } from "../dispatch/index.js";
+import { matchesAkumaGlob, parseAkumaAlias, parseAkumaGlob, } from "../identity/selector.js";
+import { requireInput } from "./input.js";
+import { scopeForRepo } from "./repo.js";
+export class AkumaWorldScopeError extends TypeError {
+    refusal;
+    constructor(refusal) {
+        super(`akuma-not-in-world ${refusal.world} ${refusal.ids.join(" ")}`);
+        this.name = "AkumaWorldScopeError";
+        this.refusal = refusal;
+    }
+}
+function nonblank(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0)
+        throw new TypeError(`${label} must be a nonblank string`);
+    return value;
+}
+function settingsOption(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "object" || value === null || typeof value.namespace !== "function") {
+        throw new TypeError("settings must be a Settings");
+    }
+    return value;
+}
+function world(path, settings) {
+    return Akuma.of(path, settings);
+}
+async function directId(path, selector) {
+    if (selector.startsWith("@")) {
+        const alias = parseAkumaAlias(selector);
+        const resolved = (await readAliases(path)).find((binding) => binding.alias === alias)?.akuId ?? null;
+        if (resolved === null)
+            throw new TypeError(`unknown Akuma alias: ${alias}`);
+        return resolved;
+    }
+    return parseAkuId(selector).id;
+}
+export async function resolveNamedAddress(input) {
+    const selector = nonblank(input.selector, "selector");
+    if (selector.startsWith("kei/"))
+        return { kind: "contract", id: contractId(selector) };
+    if (selector.startsWith("aku/"))
+        return { kind: "akuma", id: parseAkuId(selector).id };
+    const alias = parseAkumaAlias(selector);
+    const contractMatches = input.contracts.filter((row) => row.disposition === "active"
+        && row.workspace === "worktree" && row.worktreePath !== null
+        && `@${row.id.slice("kei/".length)}` === alias);
+    const aliasId = input.path === null
+        ? null
+        : (await readAliases(input.path)).find((binding) => binding.alias === alias)?.akuId ?? null;
+    if (contractMatches.length > 0 && aliasId !== null)
+        throw new TypeError(`ambiguous selector matches Contract and Akuma: ${selector}`);
+    if (contractMatches.length === 1)
+        return { kind: "contract", id: contractMatches[0].id };
+    if (contractMatches.length > 1)
+        throw new TypeError(`ambiguous Contract selector: ${selector}`);
+    if (aliasId !== null)
+        return { kind: "akuma", id: aliasId };
+    throw new TypeError(`unknown selector: ${selector}`);
+}
+export async function addressAkuma(input) {
+    const values = requireInput(input, "Akuma address input");
+    for (const key of Object.keys(values)) {
+        if (!["path", "akuma", "settings", "repo"].includes(key))
+            throw new TypeError(`Akuma address input has unknown field: ${key}`);
+    }
+    if (values.repo !== undefined)
+        scopeForRepo(values.repo);
+    const path = nonblank(values.path, "path");
+    const settings = settingsOption(values.settings);
+    return { path, id: await directId(path, nonblank(values.akuma, "akuma")), ...(settings === undefined ? {} : { settings }) };
+}
+function idsFromFleet(fleet) {
+    return fleet.rows.map((row) => row.id);
+}
+function parseSetSelector(raw) {
+    const selector = nonblank(raw, "akuma selector");
+    if (selector.startsWith("kei/"))
+        return { kind: "contract", value: contractId(selector) };
+    if (selector.includes("*"))
+        return { kind: "glob", value: parseAkumaGlob(selector) };
+    if (selector.startsWith("@"))
+        return { kind: "alias", value: parseAkumaAlias(selector) };
+    return { kind: "direct", value: parseAkuId(selector).id };
+}
+function hasSelectorKind(selectors, kind) {
+    return selectors.some((selector) => selector.kind === kind);
+}
+function addSelectorIds(selector, sources, selected, contractMembers) {
+    if (selector.kind === "contract") {
+        for (const dispatch of sources.dispatches) {
+            if (dispatch.contractId !== selector.value)
+                continue;
+            selected.add(dispatch.akuId);
+            contractMembers.add(dispatch.akuId);
+        }
+        return;
+    }
+    if (selector.kind === "glob") {
+        for (const id of sources.fleetIds)
+            if (matchesAkumaGlob(selector.value, id))
+                selected.add(id);
+        return;
+    }
+    if (selector.kind === "alias") {
+        const id = sources.aliases.get(selector.value);
+        if (id === undefined)
+            throw new TypeError(`unknown Akuma alias: ${selector.value}`);
+        selected.add(id);
+        return;
+    }
+    selected.add(selector.value);
+}
+async function contractMemberInWorld(path, id) {
+    return await probeBornAkuma(path, id);
+}
+async function refuseForeignContractMembers(path, ids, contractMembers) {
+    const foreign = [];
+    for (const id of ids) {
+        if (contractMembers.has(id) && !await contractMemberInWorld(path, id))
+            foreign.push(id);
+    }
+    if (foreign.length > 0)
+        throw new AkumaWorldScopeError({ kind: "akuma-not-in-world", ids: foreign, world: path });
+}
+export async function addressAkumaSet(input) {
+    const values = requireInput(input, "Akuma set address input");
+    for (const key of Object.keys(values)) {
+        if (!["path", "akuma", "settings", "repo"].includes(key))
+            throw new TypeError(`Akuma set address input has unknown field: ${key}`);
+    }
+    if (!Array.isArray(values.akuma) || values.akuma.length === 0)
+        throw new TypeError("akuma must be a nonempty selector array");
+    const path = nonblank(values.path, "path");
+    const settings = settingsOption(values.settings);
+    const selectors = values.akuma.map(parseSetSelector);
+    if (hasSelectorKind(selectors, "contract") && values.repo === undefined) {
+        throw new TypeError("Contract Akuma selector requires repo");
+    }
+    const fleetIds = hasSelectorKind(selectors, "glob")
+        ? idsFromFleet(await world(path, settings).list())
+        : [];
+    const aliases = hasSelectorKind(selectors, "alias")
+        ? new Map((await readAliases(path)).map((binding) => [binding.alias, binding.akuId]))
+        : new Map();
+    const dispatches = hasSelectorKind(selectors, "contract")
+        ? await readDispatches(scopeForRepo(values.repo))
+        : [];
+    const selected = new Set();
+    const contractMembers = new Set();
+    const sources = { fleetIds, aliases, dispatches };
+    for (const selector of selectors)
+        addSelectorIds(selector, sources, selected, contractMembers);
+    const ids = [...selected].sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right)));
+    if (ids.length === 0)
+        throw new TypeError("Akuma selector snapshot is empty");
+    await refuseForeignContractMembers(path, ids, contractMembers);
+    return { path, ids, ...(settings === undefined ? {} : { settings }) };
+}

package/build/src/library/akuma-creation.d.ts

@@ -1,9 +1,10 @@
 import { type AliasBinding } from "../alias/index.js";
-import { type AkumaStatus, type ForkReceipt } from "../akuma/akuma.js";
-import { type AkuId } from "../akuma/identity.js";
+import { type AkumaStatus, type ForkReceipt, type ReadonlyRestraint } from "../akuma/akuma.js";
+import type { AkuId } from "../akuma/identity.js";
 import { type Dispatch, type DispatchFailure } from "../dispatch/index.js";
 import { type AkumaAlias } from "../identity/selector.js";
 import type { Settings } from "../settings.js";
+import type { WorldRoot } from "../world.js";
 import { type Keiyaku } from "./contract.js";
 import { type Repo } from "./repo.js";
 export type { AkumaStatus } from "../akuma/akuma.js";
@@ -34,7 +35,7 @@ export type AliasStage = Readonly<{
     failure: IntegrationFailure;
 }>;
 export type CallInput = Readonly<{
-    path: string;
+    path: WorldRoot;
     archetype: string;
     body: string;
     cwd?: string;
@@ -56,24 +57,32 @@ export type CallObservation = Readonly<{
 export type CallResult = Readonly<{
     kind: "called";
     akuma: AkuId;
+    readonly?: ReadonlyRestraint;
+    execution: Readonly<{
+        cwd: string;
+        source: "input" | "world" | "contract-worktree";
+    }>;
     dispatch: DispatchStage;
     alias: AliasStage;
     observation: CallObservation;
 }>;
 export type ForkInput = Readonly<{
-    path: string;
-    akuma: AkuId;
+    path: WorldRoot;
+    akuma: string;
     at: string;
     settings?: Settings;
     repo?: Repo;
 }>;
 export type ForkResult = Readonly<{
     kind: "forked";
+    parent: AkuId;
     child: AkuId;
     dispatch: DispatchStage;
-}> | Exclude<ForkReceipt, Readonly<{
+}> | (Exclude<ForkReceipt, Readonly<{
     kind: "forked";
     child: AkuId;
-}>>;
+}>> & Readonly<{
+    parent: AkuId;
+}>);
 export declare function callKeiyaku(input: CallInput): Promise<CallResult>;
 export declare function forkKeiyaku(input: ForkInput): Promise<ForkResult>;

package/build/src/library/akuma-creation.js

@@ -1,12 +1,13 @@
-import { resolve } from "node:path";
+import { realpath, stat } from "node:fs/promises";
 import { moveAlias } from "../alias/index.js";
-import { Akuma } from "../akuma/akuma.js";
-import { parseAkuId } from "../akuma/identity.js";
+import { Akuma, } from "../akuma/akuma.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { publishDispatch, readDispatch, } from "../dispatch/index.js";
 import { parseAkumaAlias } from "../identity/selector.js";
+import { readManagedWorktreeAppointment } from "../workspace-place.js";
 import { requireInput } from "./input.js";
-import { seatForKeiyaku } from "./contract.js";
+import { addressAkuma } from "./address.js";
+import { KeiyakuRefused, seatForKeiyaku } from "./contract.js";
 import { scopeForRepo } from "./repo.js";
 function nonblank(value, label) {
     if (typeof value !== "string" || value.trim().length === 0) {
@@ -68,9 +69,9 @@ async function observeCall(handle, mode, timeoutMs) {
         return { kind: "failed", failure: integrationFailure(error) };
     }
 }
-function dispatchStage(input) {
+async function dispatchStage(input) {
     try {
-        const published = publishDispatch(input);
+        const published = await publishDispatch(input);
         return published.kind === "dispatched"
             ? { kind: "dispatched", dispatch: published.dispatch }
             : { kind: "failed", failure: published.failure };
@@ -79,21 +80,78 @@ function dispatchStage(input) {
         return { kind: "failed", failure: integrationFailure(error) };
     }
 }
-function forkDispatchStage(input) {
+async function forkDispatchStage(input) {
     try {
-        const parent = readDispatch(input.repository, input.parent);
+        const parent = await readDispatch(input.repository, input.parent);
         return parent === null
             ? { kind: "none" }
-            : dispatchStage({ repository: input.repository, akuId: input.child, contractId: parent.contractId });
+            : await dispatchStage({ repository: input.repository, akuId: input.child, contractId: parent.contractId });
     }
     catch (error) {
         return { kind: "failed", failure: integrationFailure(error) };
     }
 }
+async function canonicalizeExistingDirectory(path, diagnostic) {
+    try {
+        const real = await realpath(path);
+        if (!(await stat(real)).isDirectory())
+            throw new Error(diagnostic);
+        return real;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === diagnostic)
+            throw error;
+        throw new Error(diagnostic);
+    }
+}
+function unavailableWorkspace(contractId, detail) {
+    return new Error(`Contract workspace is unavailable: ${contractId} ${detail}`);
+}
+async function currentManagedContract(contract, contractId) {
+    let state;
+    try {
+        state = await contract.state();
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === `contract does not exist: ${contractId}`) {
+            throw new KeiyakuRefused({ kind: "contract-missing", contractId });
+        }
+        throw error;
+    }
+    if (state.terminal !== null)
+        throw new KeiyakuRefused({ kind: "terminal", contractId: state.id });
+    if (state.coordinates.workspace !== "worktree") {
+        throw unavailableWorkspace(state.id, "is here");
+    }
+    return state;
+}
+async function resolveCallExecution(input) {
+    if (input.cwd !== undefined) {
+        return {
+            cwd: await canonicalizeExistingDirectory(input.cwd, `cwd is not an existing directory: ${input.cwd}`),
+            source: "input",
+        };
+    }
+    if (input.contract === undefined)
+        return { cwd: input.path, source: "world" };
+    const seat = seatForKeiyaku(input.contract);
+    const state = await currentManagedContract(input.contract, seat.id);
+    const appointment = await readManagedWorktreeAppointment(seat.scope, state.id);
+    if (appointment.kind === "unappointed") {
+        throw unavailableWorkspace(state.id, "is unappointed; use reconcile");
+    }
+    if (appointment.kind === "failed") {
+        throw new Error(`${appointment.diagnostic}; use reconcile`);
+    }
+    return {
+        cwd: await canonicalizeExistingDirectory(appointment.path, `Contract workspace is unavailable: ${appointment.path}`),
+        source: "contract-worktree",
+    };
+}
 export async function callKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.call input");
     onlyKeys(values, ["path", "archetype", "body", "cwd", "mode", "timeoutMs", "settings", "contract", "alias"], "Keiyaku.call input");
-    const path = resolve(nonblank(values.path, "path"));
+    const path = nonblank(values.path, "path");
     const archetype = nonblank(values.archetype, "archetype");
     const body = text(values.body, "body");
     const cwd = values.cwd === undefined ? undefined : nonblank(values.cwd, "cwd");
@@ -104,14 +162,20 @@ export async function callKeiyaku(input) {
         ? undefined
         : parseAkumaAlias(nonblank(values.alias, "alias"));
     const seat = values.contract === undefined ? undefined : seatForKeiyaku(values.contract);
-    const handle = await Akuma.at({ path, ...(settings === undefined ? {} : { settings }) }).call({
+    const execution = await resolveCallExecution({
+        path,
+        ...(cwd === undefined ? {} : { cwd }),
+        ...(seat === undefined ? {} : { contract: values.contract }),
+    });
+    const handle = await Akuma.of(path, settings).call({
         archetype,
         body,
-        ...(cwd === undefined ? {} : { cwd }),
+        cwd: execution.cwd,
     });
+    const readonly = (await handle.status()).readonly;
     const dispatch = seat === undefined
         ? { kind: "none" }
-        : dispatchStage({ repository: seat.scope, akuId: handle.id, contractId: seat.id });
+        : await dispatchStage({ repository: seat.scope, akuId: handle.id, contractId: seat.id });
     let aliasStage = { kind: "none" };
     if (alias !== undefined) {
         if (dispatch.kind === "failed")
@@ -127,25 +191,35 @@ export async function callKeiyaku(input) {
         }
     }
     const observation = await observeCall(handle, mode, timeoutMs);
-    return { kind: "called", akuma: handle.id, dispatch, alias: aliasStage, observation };
+    return {
+        kind: "called",
+        akuma: handle.id,
+        ...(readonly === undefined ? {} : { readonly }),
+        execution,
+        dispatch,
+        alias: aliasStage,
+        observation,
+    };
 }
 export async function forkKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.fork input");
     onlyKeys(values, ["path", "akuma", "at", "settings", "repo"], "Keiyaku.fork input");
-    const path = resolve(nonblank(values.path, "path"));
-    if (typeof values.akuma !== "string")
-        throw new TypeError("akuma must be an AkuId");
-    const akuma = parseAkuId(values.akuma).id;
+    const path = nonblank(values.path, "path");
     const at = nonblank(values.at, "at");
     const settings = settingsOption(values.settings);
+    const akuma = (await addressAkuma({
+        path,
+        akuma: nonblank(values.akuma, "akuma"),
+        ...(settings === undefined ? {} : { settings }),
+    })).id;
     const repository = values.repo === undefined ? undefined : scopeForRepo(values.repo);
-    const receipt = await Akuma.at({ path, ...(settings === undefined ? {} : { settings }) })
+    const receipt = await Akuma.of(path, settings)
         .of({ id: akuma })
         .fork({ at });
     if (receipt.kind !== "forked")
-        return receipt;
+        return { ...receipt, parent: akuma };
     const dispatch = repository === undefined
         ? { kind: "none" }
-        : forkDispatchStage({ repository, parent: akuma, child: receipt.child });
-    return { kind: "forked", child: receipt.child, dispatch };
+        : await forkDispatchStage({ repository, parent: akuma, child: receipt.child });
+    return { kind: "forked", parent: akuma, child: receipt.child, dispatch };
 }

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

@@ -0,0 +1,18 @@
+import type { ContractId } from "../core/facts/types.js";
+import { type AuditReport, type RepositoryScope } from "../protocol/operations.js";
+import { type WorktreeHooks } from "./configuration.js";
+import { type MutationResult } from "./mutation.js";
+export type AuditInput = Readonly<{
+    actor?: string;
+    hooks?: WorktreeHooks;
+    includeDirty?: boolean;
+    showDiff?: boolean;
+    requireBranchesToBeUpToDate?: boolean;
+    signal?: AbortSignal;
+}>;
+/** Normalize public audit input and project the protocol audit operation. */
+export declare function auditContract(input: Readonly<{
+    scope: RepositoryScope;
+    contractId: ContractId;
+    input?: AuditInput;
+}>): Promise<MutationResult<AuditReport>>;

package/build/src/library/audit.js

@@ -0,0 +1,44 @@
+import { decodeContractDocument } from "../body/decode.js";
+import { withGitDecodeChannel } from "../git/read-observation.js";
+import { auditOperation, } from "../protocol/operations.js";
+import { worktreeHooksOption } from "./configuration.js";
+import { actorOption, documentDerivation, optionalBoolean, optionalSignal, requireInput, } from "./input.js";
+import { completeMutation } from "./mutation.js";
+import { requireAccepted } from "./refusal.js";
+function normalizeAuditInput(input) {
+    const values = input === undefined ? undefined : requireInput(input, "audit input");
+    const signal = optionalSignal(values?.signal);
+    return {
+        hooks: worktreeHooksOption(values?.hooks),
+        ...actorOption(values?.actor),
+        includeDirty: optionalBoolean(values?.includeDirty, "includeDirty") ?? false,
+        showDiff: optionalBoolean(values?.showDiff, "showDiff") ?? false,
+        requireBranchesToBeUpToDate: optionalBoolean(values?.requireBranchesToBeUpToDate, "requireBranchesToBeUpToDate") ?? false,
+        ...(signal === undefined ? {} : { signal }),
+    };
+}
+/** Normalize public audit input and project the protocol audit operation. */
+export async function auditContract(input) {
+    const normalized = normalizeAuditInput(input.input);
+    return withGitDecodeChannel(input.scope, async (channel) => {
+        const accepted = requireAccepted(await auditOperation({
+            scope: input.scope,
+            channel,
+            contractId: input.contractId,
+            deriveDocument: (state) => documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id),
+            includeDirty: normalized.includeDirty,
+            showDiff: normalized.showDiff,
+            requireBranchesToBeUpToDate: normalized.requireBranchesToBeUpToDate,
+            ...(normalized.signal === undefined ? {} : { signal: normalized.signal }),
+            ...(normalized.actor === undefined ? {} : { actor: normalized.actor }),
+        }));
+        return completeMutation({
+            scope: input.scope,
+            channel,
+            contractId: input.contractId,
+            accepted,
+            value: (report) => report,
+            hooks: normalized.hooks,
+        });
+    });
+}

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

@@ -0,0 +1,21 @@
+import { type ActorId, type ContractId } from "../core/facts/types.js";
+import type { GitDecodeChannel } from "../git/read-observation.js";
+import { bindOperation, type IntentOutcome, type RepositoryScope } from "../protocol/operations.js";
+import type { TaskId } from "../task/identity.js";
+import type { VerificationDeclarationPreparation } from "../verification/declaration.js";
+import type { KeiyakuRefusal } from "./refusal.js";
+type BindAttemptInput = Readonly<{
+    scope: RepositoryScope;
+    channel: GitDecodeChannel;
+    title: string;
+    terms: Parameters<typeof bindOperation>[0]["terms"];
+    verification: VerificationDeclarationPreparation;
+    workspace: "worktree" | "here";
+    target?: string;
+    task?: TaskId;
+    actor?: ActorId;
+}>;
+export declare function admitBindWithAppointment(input: BindAttemptInput): Promise<IntentOutcome<Readonly<{
+    contractId: ContractId;
+}>, KeiyakuRefusal>>;
+export {};

package/build/src/library/bind.js

@@ -0,0 +1,56 @@
+import { randomBytes } from "node:crypto";
+import { releaseContractWorktree, reserveContractWorktree, withContractWorktreeAppointment, } from "../contract-worktree.js";
+import { contractIdFromSegment } from "../core/facts/types.js";
+import { fitIdentityStem, normalizeIdentityStem } from "../identity/normalize.js";
+import { bindOperation } from "../protocol/operations.js";
+import { claimTaskHolder } from "../settlement/holder.js";
+function candidateId(title, collision) {
+    const stem = fitIdentityStem({ stem: normalizeIdentityStem({ source: title }) || "contract", maxBytes: 48 });
+    const suffix = collision === 0 ? "" : `-${randomBytes(8).toString("hex")}`;
+    return contractIdFromSegment(`${stem}${suffix}`);
+}
+async function attempt(input, id) {
+    return bindOperation({
+        scope: input.scope,
+        channel: input.channel,
+        title: input.title,
+        terms: input.terms,
+        verification: input.verification,
+        workspace: input.workspace,
+        contractId: id,
+        ...(input.target === undefined ? {} : { target: input.target }),
+        ...(input.task === undefined ? {} : {
+            decorateOffer: ({ contractId: owner }) => [claimTaskHolder(input.task, owner)],
+        }),
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+    });
+}
+async function attemptCandidates(input) {
+    for (let collision = 0; collision <= 3; collision += 1) {
+        const id = candidateId(input.title, collision);
+        let reserved = false;
+        if (input.workspace === "here") {
+            const reservation = await reserveContractWorktree(input.scope, id);
+            if (reservation.kind !== "reserved") {
+                return { kind: "refused", refusal: {
+                        kind: "here-worktree-appointed",
+                        path: reservation.path,
+                        ...(reservation.kind === "appointed" ? { contract: reservation.contract } : {}),
+                    } };
+            }
+            reserved = true;
+        }
+        const result = await attempt(input, id);
+        if (result.kind === "accepted")
+            return result;
+        if (reserved)
+            await releaseContractWorktree(input.scope, id);
+        if (result.kind !== "refused" || result.refusal.kind !== "contract-exists")
+            return result;
+    }
+    throw new Error("contract identity collision attempts exhausted");
+}
+export async function admitBindWithAppointment(input) {
+    const action = () => attemptCandidates(input);
+    return input.workspace === "here" ? await withContractWorktreeAppointment(input.scope, action) : action();
+}

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

@@ -0,0 +1,58 @@
+import { type AkumaList } from "../akuma/akuma.js";
+import { type ArchetypeCatalogRow } from "../akuma/archetype.js";
+import type { Settings } from "../settings.js";
+import type { TaskRow } from "../task/index.js";
+import { type ContractBoard } from "./contract.js";
+import { Repo } from "./repo.js";
+import type { WorldRoot } from "../world.js";
+export type CatalogQuery = Readonly<{
+    kind: "tasks";
+}> | Readonly<{
+    kind: "contracts";
+}> | Readonly<{
+    kind: "archetypes";
+}> | Readonly<{
+    kind: "akuma";
+    archetype?: string;
+}>;
+export type CatalogInput = Readonly<{
+    query: Extract<CatalogQuery, {
+        kind: "tasks";
+    }>;
+    path: WorldRoot;
+}> | Readonly<{
+    query: Extract<CatalogQuery, {
+        kind: "contracts";
+    }>;
+    repo: Repo;
+}> | Readonly<{
+    query: Extract<CatalogQuery, {
+        kind: "archetypes";
+    }>;
+    settings: Settings;
+}> | Readonly<{
+    query: Extract<CatalogQuery, {
+        kind: "akuma";
+    }>;
+    path: WorldRoot;
+}>;
+export type Catalog = Readonly<{
+    kind: "tasks";
+    root: WorldRoot;
+    rows: readonly TaskRow[];
+}> | Readonly<{
+    kind: "contracts";
+    root: string;
+    state: string | null;
+    rows: ContractBoard["rows"];
+}> | Readonly<{
+    kind: "archetypes";
+    rows: readonly ArchetypeCatalogRow[];
+}> | Readonly<{
+    kind: "akuma";
+    root: WorldRoot;
+    archetype: string | null;
+    rows: AkumaList["rows"];
+    searched: readonly string[];
+}>;
+export declare function listCatalog(input: CatalogInput): Promise<Catalog>;

package/build/src/library/catalog.js

@@ -0,0 +1,69 @@
+import { Akuma } from "../akuma/akuma.js";
+import { listArchetypeDefinitions } from "../akuma/archetype.js";
+import { observeTaskCatalogRows } from "../task/operations.js";
+import { listKeiyaku } from "./contract.js";
+import { requireInput } from "./input.js";
+import { Repo } from "./repo.js";
+function settingsValue(value) {
+    if (typeof value !== "object" || value === null
+        || typeof value.namespace !== "function") {
+        throw new TypeError("settings must be a Settings");
+    }
+    return value;
+}
+function worldRoot(value) {
+    if (typeof value !== "string" || value.trim().length === 0)
+        throw new TypeError("path must be a WorldRoot");
+    return value;
+}
+function queryValue(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new TypeError("Keiyaku.ls query must be an object");
+    }
+    const query = value;
+    if (query.kind !== "tasks" && query.kind !== "contracts" && query.kind !== "archetypes" && query.kind !== "akuma") {
+        throw new TypeError("Keiyaku.ls query kind is invalid");
+    }
+    for (const key of Object.keys(query)) {
+        if (key !== "kind" && !(query.kind === "akuma" && key === "archetype")) {
+            throw new TypeError(`Keiyaku.ls query has unknown field: ${key}`);
+        }
+    }
+    if (query.kind !== "akuma")
+        return { kind: query.kind };
+    if (query.archetype !== undefined && typeof query.archetype !== "string") {
+        throw new TypeError("Keiyaku.ls Akuma name must be a string");
+    }
+    return { kind: "akuma", ...(query.archetype === undefined ? {} : { archetype: query.archetype }) };
+}
+export async function listCatalog(input) {
+    const values = requireInput(input, "Keiyaku.ls input");
+    const query = queryValue(values.query);
+    const allowed = query.kind === "contracts" ? ["query", "repo"]
+        : query.kind === "archetypes" ? ["query", "settings"] : ["query", "path"];
+    for (const key of Object.keys(values)) {
+        if (!allowed.includes(key))
+            throw new TypeError(`Keiyaku.ls input has unknown field: ${key}`);
+    }
+    if (query.kind === "contracts") {
+        if (!(values.repo instanceof Repo))
+            throw new TypeError("repo must be a Repo");
+        const board = await listKeiyaku({ repo: values.repo });
+        return { kind: "contracts", root: board.root, state: board.state, rows: board.rows };
+    }
+    if (query.kind === "archetypes") {
+        return { kind: "archetypes", rows: await listArchetypeDefinitions({ settings: settingsValue(values.settings) }) };
+    }
+    const path = worldRoot(values.path);
+    if (query.kind === "tasks") {
+        return { kind: "tasks", root: path, rows: await observeTaskCatalogRows(path) };
+    }
+    const listed = await Akuma.of(path).list(query.archetype === undefined ? undefined : { archetype: query.archetype });
+    return {
+        kind: "akuma",
+        root: path,
+        archetype: query.archetype ?? null,
+        rows: listed.rows,
+        searched: listed.searched,
+    };
+}