@astrosheep/keiyaku 4.5.11 → 4.5.13

package/build/integrations/pi/keiyaku.ts

@@ -1,91 +1,14 @@
 import { existsSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
-
-type Section = Readonly<{ kind?: string; value?: Readonly<{ rows?: readonly Record<string, unknown>[] }> }>;
-type Report = Readonly<{
-  contracts?: Section;
-  tasks?: Section;
-  akuma?: Section;
-}>;
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
 
 type ExecResult = Readonly<{ stdout: string; stderr: string; code: number }>;
 
-const REFRESH_TIMEOUT_MS = 10_000;
-
-function rows(section: Section | undefined): readonly Record<string, unknown>[] {
-  return section?.kind === "present" && Array.isArray(section.value?.rows) ? section.value.rows : [];
-}
-
-function failed(section: Section | undefined): boolean {
-  return section?.kind === "failed";
-}
-
-function contractNeedsAttention(row: Record<string, unknown>): boolean {
-  const gates = row.gates;
-  if (typeof gates === "object" && gates !== null && "reports" in gates && Array.isArray(gates.reports)) {
-    for (const report of gates.reports) {
-      if (
-        typeof report === "object" &&
-        report !== null &&
-        "current" in report &&
-        typeof report.current === "object" &&
-        report.current !== null &&
-        "kind" in report.current &&
-        report.current.kind === "attested" &&
-        "verdict" in report.current &&
-        report.current.verdict === "unsatisfied"
-      )
-        return true;
-    }
-  }
-  return row.targetLag !== undefined &&
-    typeof row.targetLag === "object" &&
-    row.targetLag !== null &&
-    "kind" in row.targetLag
-    ? row.targetLag.kind === "unknown"
-    : false;
-}
-
-function taskNeedsAttention(row: Record<string, unknown>): boolean {
-  return row.disposition === "blocked";
-}
-
-function akumaNeedsAttention(row: Record<string, unknown>): boolean {
-  return row.life === "stillborn" || row.life === "hung" || row.life === "untidy";
-}
-
-function summary(report: Report): string {
-  const contractRows = rows(report.contracts);
-  const taskRows = rows(report.tasks);
-  const akumaRows = rows(report.akuma);
-  const attention =
-    Number(failed(report.contracts)) +
-    Number(failed(report.tasks)) +
-    Number(failed(report.akuma)) +
-    contractRows.filter(contractNeedsAttention).length +
-    taskRows.filter(taskNeedsAttention).length +
-    akumaRows.filter(akumaNeedsAttention).length;
-  const parts = [`Keiyaku · ${contractRows.length} contracts`, `${akumaRows.length} fleet`, `${taskRows.length} tasks`];
-  if (attention > 0) parts.push(`! ${attention}`);
-  return parts.join(" · ");
-}
-
-function parseReport(result: ExecResult): Report | undefined {
-  if (result.code !== 0 || result.stdout.trim().length === 0) return undefined;
-  try {
-    const value: unknown = JSON.parse(result.stdout);
-    return typeof value === "object" && value !== null ? (value as Report) : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-async function run(pi: ExtensionAPI, args: readonly string[], timeout = REFRESH_TIMEOUT_MS): Promise<ExecResult> {
+async function runStatus(pi: ExtensionAPI): Promise<ExecResult> {
   const bundledCli = resolve(dirname(fileURLToPath(import.meta.url)), "../../src/cli/index.js");
-  if (existsSync(bundledCli)) return await pi.exec(process.execPath, [bundledCli, ...args], { timeout });
-  return await pi.exec("keiyaku", [...args], { timeout });
+  if (existsSync(bundledCli)) return await pi.exec(process.execPath, [bundledCli, "status"]);
+  return await pi.exec("keiyaku", ["status"]);
 }
 
 function lineForWidth(value: string, width: number): string {
@@ -119,49 +42,21 @@ function overlay(lines: readonly string[], theme: Theme, done: () => void) {
 }
 
 export default function keiyakuExtension(pi: ExtensionAPI): void {
-  let refreshInFlight: Promise<void> | undefined;
-
-  const refresh = async (ctx: Pick<ExtensionContext, "hasUI" | "ui">): Promise<void> => {
-    if (!ctx.hasUI) return;
-    refreshInFlight ??= (async () => {
-      try {
-        const result = await run(pi, ["status", "--json"]);
-        const report = parseReport(result);
-        if (report === undefined) {
-          const diagnostic = result.stderr.trim() || "status unavailable";
-          ctx.ui.setWidget("keiyaku", [`Keiyaku · ${lineForWidth(diagnostic, 100)}`]);
-        } else ctx.ui.setWidget("keiyaku", [summary(report)]);
-      } catch {
-        ctx.ui.setWidget("keiyaku", ["Keiyaku · status unavailable"]);
-      }
-    })().finally(() => {
-      refreshInFlight = undefined;
-    });
-    await refreshInFlight;
-  };
-
-  const scheduleRefresh = (ctx: Pick<ExtensionContext, "hasUI" | "ui">): void => {
-    void refresh(ctx).catch(() => undefined);
-  };
-
-  pi.on("session_start", (_event, ctx) => {
-    scheduleRefresh(ctx);
-  });
-  pi.on("agent_end", (_event, ctx) => {
-    scheduleRefresh(ctx);
-  });
   pi.registerCommand("keiyaku", {
     description: "Open the Kanshi world status",
     handler: async (_args, ctx) => {
       if (!ctx.hasUI) return;
-      const result = await run(pi, ["status"]);
-      const body =
-        result.code === 0 ? result.stdout.trimEnd().split("\n") : [result.stderr.trim() || "status unavailable"];
+      let body: string[];
+      try {
+        const result = await runStatus(pi);
+        body = result.code === 0 ? result.stdout.trimEnd().split("\n") : [result.stderr.trim() || "status unavailable"];
+      } catch {
+        body = ["status unavailable"];
+      }
       await ctx.ui.custom<void>((_tui, theme, _keybindings, done) => overlay(body, theme, done), {
         overlay: true,
         overlayOptions: { anchor: "center", width: 100, maxHeight: 40 },
       });
-      await refresh(ctx);
     },
   });
 }

package/build/src/akuma/akuma-errors.d.ts

@@ -1,4 +1,5 @@
 import type { AkuId } from "./identity.js";
+export { AkumaBusyError } from "./heart/facts.js";
 export declare class AkumaNotBornError extends Error {
     readonly id: AkuId;
     readonly kind = "akuma-not-born";

package/build/src/akuma/akuma-errors.js

@@ -1,3 +1,4 @@
+export { AkumaBusyError } from "./heart/facts.js";
 export class AkumaNotBornError extends Error {
     id;
     kind = "akuma-not-born";

package/build/src/akuma/akuma-handle.d.ts

@@ -11,6 +11,7 @@ export declare class AkumaHandle {
     readonly [CALL_EXECUTION]?: AkumaCallExecution;
     constructor(id: AkuId, worldPath: WorldRoot, execution?: AkumaCallExecution);
     private get paths();
+    private projectHistoryTurns;
     private exactHistory;
     status(): Promise<AkumaStatus>;
     history(input?: Readonly<{

package/build/src/akuma/akuma-handle.js

@@ -83,6 +83,10 @@ export class AkumaHandle {
     get paths() {
         return pathsForAkuId(this.worldPath, this.id);
     }
+    async projectHistoryTurns() {
+        const slice = await activitySlice(this.paths);
+        return projectTurns(slice.rows, { lowestRetained: slice.lowestRetained, highest: slice.highest });
+    }
     async exactHistory(input) {
         if (typeof input.id !== "string" || input.id.trim() === "")
             throw new TypeError("Akuma history id must be a nonblank string");
@@ -90,8 +94,7 @@ export class AkumaHandle {
             throw new TypeError("Akuma history id cannot be combined with before, since, or limit");
         if (parsePublicHistoryId(input.id) === null)
             throw new TypeError("Akuma history id must match turn/<positive safe integer>");
-        const slice = await activitySlice(this.paths);
-        return selectExactHistory(projectTurns(slice.rows, { lowestRetained: slice.lowestRetained, highest: slice.highest }).rows, input.id);
+        return selectExactHistory((await this.projectHistoryTurns()).rows, input.id);
     }
     async status() {
         return (await bornStatus(this.paths, this.id, { aperture: "monitoring" })).status;
@@ -114,11 +117,7 @@ export class AkumaHandle {
         if (!Number.isSafeInteger(limit) || limit <= 0 || limit > 5_000) {
             throw new TypeError("Akuma history limit must be a positive safe integer no greater than 5000");
         }
-        const slice = await activitySlice(this.paths);
-        return selectHistory(projectTurns(slice.rows, {
-            lowestRetained: slice.lowestRetained,
-            highest: slice.highest,
-        }), {
+        return selectHistory(await this.projectHistoryTurns(), {
             ...(input.before === undefined ? {} : { before: input.before }),
             ...(input.since === undefined ? {} : { since: input.since }),
             limit,

package/build/src/akuma/akuma-product.d.ts

@@ -1,5 +1,5 @@
 import { AkumaHandle } from "./akuma-handle.js";
-import type { AkumaCallContext, AkumaCallInput, AkumaConfiguration, AkumaList, AkumaListInput } from "./akuma.js";
+import type { AkumaCallContext, AkumaCallInput, AkumaCompleteList, AkumaConfiguration, AkumaList, AkumaListInput } from "./akuma.js";
 import { CALL_WITH_CONTEXT } from "./akuma-product-symbols.js";
 import type { WorldRoot } from "../world.js";
 import type { BodyLaunch } from "./body.js";
@@ -31,6 +31,8 @@ export type RequestedAkumaCall = Readonly<{
 }>;
 export type AkumaBornCall = BornAkumaCall | RequestedAkumaCall;
 type AkumaCallLaunchInput = AkumaCallInput;
+export declare const PAGE_POOL_SIZE = 16;
+export declare function boundedMap<Value, Result>(values: readonly Value[], mapper: (value: Value) => Promise<Result>): Promise<readonly Result[]>;
 export declare class Akuma {
     private readonly path;
     private readonly configuration;
@@ -43,16 +45,12 @@ export declare class Akuma {
     call(input: AkumaCallLaunchInput): Promise<AkumaHandle>;
     beginCall(input: AkumaCallLaunchInput, context: AkumaCallContext): Promise<AkumaBornCall>;
     finishCall(born: AkumaBornCall, completion?: Readonly<{
-        participantName?: string;
         contractId?: string;
     }>): Promise<AkumaHandle>;
     [CALL_WITH_CONTEXT](input: AkumaCallLaunchInput, context: AkumaCallContext): Promise<AkumaHandle>;
+    listComplete(input?: Readonly<{
+        archetype?: string;
+    }>): Promise<AkumaCompleteList>;
     list(input?: AkumaListInput): Promise<AkumaList>;
 }
-export declare function callAkumaWithContext(akuma: Akuma, input: AkumaCallLaunchInput, context: AkumaCallContext): Promise<AkumaHandle>;
-export declare function beginAkumaCall(akuma: Akuma, input: AkumaCallLaunchInput, context: AkumaCallContext): Promise<AkumaBornCall>;
-export declare function finishAkumaCall(akuma: Akuma, born: AkumaBornCall, completion?: Readonly<{
-    participantName?: string;
-    contractId?: string;
-}>): Promise<AkumaHandle>;
 export {};

package/build/src/akuma/akuma-product.js

@@ -1,8 +1,9 @@
 import { randomUUID } from "node:crypto";
-import { readdir, realpath, stat } from "node:fs/promises";
-import { resolve } from "node:path";
+import { readdir, stat } from "node:fs/promises";
+import { boundedListLimit, projectBoundedList } from "../bounded-list.js";
 import { AkumaHandle } from "./akuma-handle.js";
 import { CALL_WITH_CONTEXT } from "./akuma-product-symbols.js";
+import { callReadonly, canonicalBirthCwd } from "./call-input.js";
 import { fleetListRow, readAkumaBirthCwd } from "./akuma-observe.js";
 import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot, archetypeName, parseAkuId } from "./identity.js";
 import { loadArchetype, listArchetypes as readArchetypes } from "./archetype.js";
@@ -12,24 +13,98 @@ import { requestForwardedAkumaCall } from "./call-request.js";
 import { executionChannel } from "./requests.js";
 import { decodeAllowedActions, unionAllowedActions } from "./allowed.js";
 import { settings as readSettings } from "../settings.js";
-function callReadonly(value) {
-    if (value === undefined)
-        return {};
-    if (value !== true)
-        throw new TypeError("Akuma call readonly must be true");
-    return { readonly: true };
+export const PAGE_POOL_SIZE = 16;
+function activityAt(row) {
+    if (!("lifeAt" in row))
+        return null;
+    if (row.lifeAt === null)
+        return row.lastActivityAt;
+    if (row.lastActivityAt === null)
+        return row.lifeAt;
+    return row.lifeAt > row.lastActivityAt ? row.lifeAt : row.lastActivityAt;
 }
-async function canonicalBirthCwd(input) {
-    const selected = resolve(input);
+function compareActivity(left, right) {
+    if (left === right)
+        return 0;
+    if (left === null)
+        return 1;
+    if (right === null)
+        return -1;
+    return left > right ? -1 : 1;
+}
+function compareRows(left, right) {
+    const activity = compareActivity(activityAt(left), activityAt(right));
+    if (activity !== 0)
+        return activity;
+    return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+}
+export async function boundedMap(values, mapper) {
+    const results = [];
+    let index = 0;
+    const worker = async () => {
+        for (;;) {
+            const selected = index++;
+            if (selected >= values.length)
+                return;
+            results[selected] = await mapper(values[selected]);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(PAGE_POOL_SIZE, values.length) }, worker));
+    return results;
+}
+async function mtimeBound(paths) {
+    const read = async (path) => {
+        try {
+            return (await stat(path)).mtimeMs;
+        }
+        catch (error) {
+            return error.code === "ENOENT" ? 0 : Number.POSITIVE_INFINITY;
+        }
+    };
+    return Math.max(await read(paths.heart), await read(`${paths.heart}-wal`));
+}
+async function knownAkuma(path, selected) {
+    const runRoot = akumaRunRoot(path);
+    let names;
     try {
-        const canonical = await realpath(selected);
-        if (!(await stat(canonical)).isDirectory())
-            throw new Error("not a directory");
-        return canonical;
+        names = (await readdir(runRoot, { withFileTypes: true }))
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort();
     }
-    catch {
-        throw new Error(`cwd is not an existing directory: ${input}`);
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { runRoot, rows: [] };
+        throw error;
     }
+    const rows = [];
+    for (const name of names) {
+        let physical;
+        try {
+            physical = akuIdFromDirectoryName(name);
+        }
+        catch {
+            continue;
+        }
+        if (selected !== undefined && physical.archetype !== selected)
+            continue;
+        rows.push({
+            id: physical.id,
+            paths: akumaPaths({ runRoot, archetype: physical.archetype, suffix: physical.suffix }),
+        });
+    }
+    return { runRoot, rows };
+}
+async function readableRows(rows) {
+    const loaded = await boundedMap(rows, async ({ id, paths }) => {
+        try {
+            return await fleetListRow(paths, id);
+        }
+        catch {
+            return null;
+        }
+    });
+    return [...loaded].filter((row) => row !== null);
 }
 export class Akuma {
     path;
@@ -47,7 +122,10 @@ export class Akuma {
         return new AkumaHandle(parseAkuId(input.id).id, this.path);
     }
     async listArchetypes() {
-        return readArchetypes(this.configuration.home === undefined ? {} : { home: this.configuration.home });
+        return readArchetypes({
+            project: this.path,
+            ...(this.configuration.home === undefined ? {} : { home: this.configuration.home }),
+        });
     }
     async call(input) {
         return await this[CALL_WITH_CONTEXT](input, { initiatorCwd: process.cwd() });
@@ -57,7 +135,7 @@ export class Akuma {
         const name = archetypeName(input.archetype);
         const home = this.configuration.home === undefined ? {} : { home: this.configuration.home };
         const settings = this.configuration.settings ?? (await readSettings({ root: this.path, ...home }));
-        const archetype = await loadArchetype({ name, ...home, settings, ...readonly });
+        const archetype = await loadArchetype({ name, project: this.path, ...home, settings, ...readonly });
         const allowed = input.allowed === undefined
             ? archetype.allowed
             : unionAllowedActions(archetype.allowed, decodeAllowedActions(input.allowed, "Akuma call allowed"));
@@ -134,53 +212,59 @@ export class Akuma {
     async [CALL_WITH_CONTEXT](input, context) {
         return await this.finishCall(await this.beginCall(input, context));
     }
+    async listComplete(input = {}) {
+        if (typeof input !== "object" || input === null || Array.isArray(input))
+            throw new TypeError("Akuma complete list input must be an object");
+        const unknown = Object.keys(input).find((key) => key !== "archetype");
+        if (unknown !== undefined)
+            throw new TypeError(`Akuma complete list input has unknown field: ${unknown}`);
+        const selected = input.archetype === undefined ? undefined : archetypeName(input.archetype);
+        const known = await knownAkuma(this.path, selected);
+        return {
+            observedAt: new Date().toISOString(),
+            rows: [...(await readableRows(known.rows))].sort(compareRows),
+            searched: [known.runRoot],
+        };
+    }
     async list(input = {}) {
         if (typeof input !== "object" || input === null || Array.isArray(input))
             throw new TypeError("Akuma list input must be an object");
-        const unknown = Object.keys(input).find((key) => key !== "archetype");
+        const unknown = Object.keys(input).find((key) => key !== "archetype" && key !== "limit");
         if (unknown !== undefined)
             throw new TypeError(`Akuma list input has unknown field: ${unknown}`);
         const selected = input.archetype === undefined ? undefined : archetypeName(input.archetype);
+        const limit = boundedListLimit(input.limit);
         const observedAt = new Date().toISOString();
-        const runRoot = akumaRunRoot(this.path);
-        let names;
-        try {
-            names = (await readdir(runRoot, { withFileTypes: true }))
-                .filter((entry) => entry.isDirectory())
-                .map((entry) => entry.name)
-                .sort();
-        }
-        catch (error) {
-            if (error.code === "ENOENT")
-                return { observedAt, rows: [], searched: [runRoot] };
-            throw error;
-        }
-        const rows = [];
-        for (const name of names) {
-            let physical;
-            try {
-                physical = akuIdFromDirectoryName(name);
-            }
-            catch {
-                continue;
+        const known = await knownAkuma(this.path, selected);
+        const candidatesWithBounds = await boundedMap(known.rows, async (row) => ({
+            ...row,
+            bound: await mtimeBound(row.paths),
+        }));
+        const candidates = [...candidatesWithBounds].sort((left, right) => right.bound - left.bound);
+        const readable = [];
+        let cursor = 0;
+        while (cursor < candidates.length) {
+            const batch = candidates.slice(cursor, cursor + PAGE_POOL_SIZE);
+            readable.push(...(await readableRows(batch)));
+            cursor += batch.length;
+            const ranked = readable.sort(compareRows);
+            const lookahead = ranked[limit];
+            const activity = lookahead === undefined ? null : activityAt(lookahead);
+            const unreadBound = candidates[cursor]?.bound;
+            if (lookahead !== undefined &&
+                activity !== null &&
+                unreadBound !== undefined &&
+                Number.isFinite(unreadBound) &&
+                Number.isFinite(Date.parse(activity)) &&
+                unreadBound < Date.parse(activity)) {
+                break;
             }
-            if (selected !== undefined && physical.archetype !== selected)
-                continue;
-            const paths = akumaPaths({ runRoot, archetype: physical.archetype, suffix: physical.suffix });
-            try {
-                rows.push(await fleetListRow(paths, physical.id));
-            }
-            catch { }
         }
-        return { observedAt, rows, searched: [runRoot] };
+        const ranked = readable.sort(compareRows);
+        return {
+            observedAt,
+            searched: [known.runRoot],
+            ...projectBoundedList(ranked, limit),
+        };
     }
 }
-export async function callAkumaWithContext(akuma, input, context) {
-    return await akuma[CALL_WITH_CONTEXT](input, context);
-}
-export async function beginAkumaCall(akuma, input, context) {
-    return await akuma.beginCall(input, context);
-}
-export async function finishAkumaCall(akuma, born, completion = {}) {
-    return await akuma.finishCall(born, completion);
-}

package/build/src/akuma/akuma.d.ts

@@ -6,11 +6,8 @@ import type { WorldRoot } from "../world.js";
 import type { AllowedAction } from "./allowed.js";
 import type { ExecutionContext } from "./requests.js";
 import { z } from "zod";
+import type { BoundedList } from "../bounded-list.js";
 export declare const POLL_MS = 100;
-export declare function canonicalBirthCwd(input: string): Promise<string>;
-export declare function callReadonly(value: unknown): Readonly<{
-    readonly?: true;
-}>;
 export type AkumaListRow = Readonly<{
     id: AkuId;
     archetype: string;
@@ -419,13 +416,14 @@ export type UnbornAkumaListRow = Readonly<{
         at: string;
     }>;
 }>;
-export type AkumaList = Readonly<{
+export type AkumaList = BoundedList<AkumaListRow | UnbornAkumaListRow> & Readonly<{
     observedAt: string;
-    rows: readonly (AkumaListRow | UnbornAkumaListRow)[];
     searched: readonly string[];
 }>;
+export type AkumaCompleteList = Omit<AkumaList, "hasMore">;
 export type AkumaListInput = Readonly<{
     archetype?: string;
+    limit?: number;
 }>;
 export type AkumaCallExecution = Readonly<{
     cwd: string;
@@ -493,4 +491,4 @@ export type AkumaConfiguration = Readonly<{
     execution?: ExecutionContext;
 }>;
 export { AkumaHandle, akumaCallExecution, type LastAnswer } from "./akuma-handle.js";
-export { Akuma, callAkumaWithContext } from "./akuma-product.js";
+export { Akuma } from "./akuma-product.js";

package/build/src/akuma/akuma.js

@@ -1,31 +1,10 @@
 import { randomUUID } from "node:crypto";
-import { realpath, stat } from "node:fs/promises";
-import { resolve } from "node:path";
 import { CONTROL_RESPONSE_MS, handoffPendingTells, wakeRecordedTell, } from "./body.js";
 import { HeldAkumaLeash, readHeart, readKill, recordTell, requestStop, } from "./heart/index.js";
 import { parseAkuId, pathsForAkuId } from "./identity.js";
 import { activitySnapshotSchema } from "./projection.js";
 import { z } from "zod";
 export const POLL_MS = 100;
-export async function canonicalBirthCwd(input) {
-    const selected = resolve(input);
-    try {
-        const canonical = await realpath(selected);
-        if (!(await stat(canonical)).isDirectory())
-            throw new Error("not a directory");
-        return canonical;
-    }
-    catch {
-        throw new Error(`cwd is not an existing directory: ${input}`);
-    }
-}
-export function callReadonly(value) {
-    if (value === undefined)
-        return {};
-    if (value !== true)
-        throw new TypeError("Akuma call readonly must be true");
-    return { readonly: true };
-}
 export const akumaIdSchema = z.string().transform((value, context) => {
     try {
         const id = parseAkuId(value).id;
@@ -127,4 +106,4 @@ export async function killAkumaWithRecovery(paths, recover = handoffPendingTells
 }
 export { bornStatus, fleetListRow, readAkumaBirthCwd, readBudgetedStatus, } from "./akuma-observe.js";
 export { AkumaHandle, akumaCallExecution } from "./akuma-handle.js";
-export { Akuma, callAkumaWithContext } from "./akuma-product.js";
+export { Akuma } from "./akuma-product.js";

package/build/src/akuma/archetype.d.ts

@@ -30,14 +30,15 @@ export declare class AkumaArchetypeError extends Error {
     readonly kind = "akuma-archetype";
     constructor(archetype: string, searched: readonly string[], reason: string, guidance?: string);
 }
-export declare function listArchetypes(input?: Readonly<{
+type ArchetypeCoordinates = Readonly<{
+    project?: string;
     home?: string;
-}>): Promise<readonly string[]>;
-export declare function listArchetypeDefinitions(input?: Readonly<{
-    home?: string;
-}>): Promise<readonly ArchetypeCatalogRow[]>;
+}>;
+export declare function listArchetypes(input?: ArchetypeCoordinates): Promise<readonly string[]>;
+export declare function listArchetypeDefinitions(input?: ArchetypeCoordinates): Promise<readonly ArchetypeCatalogRow[]>;
 export declare function loadArchetype(input: Readonly<{
     name: string;
+    project?: string;
     home?: string;
     settings: Settings;
     readonly?: true;