@fungi.computer/puffball 0.0.0-stage → 0.0.1

package/dist/app-backend-binding-vocabulary.d.ts

@@ -0,0 +1,299 @@
+import type { AppCapabilityId } from "./app-vocabulary.js";
+/** Shared broker class, permission and effect metadata for a binding operation. */
+export type BindingOperationDefinition = Readonly<{
+    cap: string;
+    requires: readonly AppCapabilityId[];
+    effect: "read" | "write";
+}>;
+/** The runtime-neutral registry shared by declarations, admission and Exec. */
+export declare const appBackendBindingKinds: {
+    readonly BACKGROUND: {
+        readonly name: "BACKGROUND";
+        readonly operations: {
+            readonly admit: {
+                readonly cap: "app.background.admit";
+                readonly requires: readonly [];
+                readonly effect: "read";
+            };
+        };
+    };
+    readonly GIT: {
+        readonly name: "GIT";
+        readonly operations: {
+            readonly create: {
+                readonly cap: "app.git.create";
+                readonly requires: readonly ["git.repository"];
+                readonly effect: "write";
+            };
+            readonly fork: {
+                readonly cap: "app.git.fork";
+                readonly requires: readonly ["git.repository"];
+                readonly effect: "write";
+            };
+            readonly read: {
+                readonly cap: "app.git.read";
+                readonly requires: readonly ["git.repository"];
+                readonly effect: "read";
+            };
+            readonly write: {
+                readonly cap: "app.git.write";
+                readonly requires: readonly ["git.repository"];
+                readonly effect: "write";
+            };
+            readonly exchange: {
+                readonly cap: "app.git.exchange";
+                readonly requires: readonly ["git.repository"];
+                readonly effect: "write";
+            };
+        };
+    };
+    readonly EVENTS: {
+        readonly name: "EVENTS";
+        readonly operations: {
+            readonly emit: {
+                readonly cap: "app.events.emit";
+                readonly requires: readonly ["app.events.emit"];
+                readonly effect: "write";
+            };
+        };
+    };
+    readonly APPS: {
+        readonly name: "APPS";
+        readonly operations: {
+            readonly build: {
+                readonly cap: "app.build";
+                readonly requires: readonly ["git.repository", "computer.execute"];
+                readonly effect: "write";
+            };
+            /** Read one build job's current status; the host re-checks the caller is the owner. */
+            readonly buildStatus: {
+                readonly cap: "app.build";
+                readonly requires: readonly [];
+                readonly effect: "read";
+            };
+            /** Install a Release at an installation id, or switch a live one onto
+             * it; the host re-checks the caller is the owner. */
+            readonly select: {
+                readonly cap: "app.select";
+                readonly requires: readonly [];
+                readonly effect: "write";
+            };
+            readonly catalog: {
+                readonly cap: "app.catalog.read";
+                readonly requires: readonly ["team.workbenchHost"];
+                readonly effect: "read";
+            };
+            /** Fork a platform App's published source into its own Team-owned App. */
+            readonly fork: {
+                readonly cap: "app.fork";
+                readonly requires: readonly [];
+                readonly effect: "write";
+            };
+        };
+    };
+    readonly WORKFLOWS: {
+        readonly name: "WORKFLOWS";
+        readonly operations: {
+            /** The member's callable App methods, for an editor's palette. */
+            readonly catalog: {
+                readonly cap: "app.workflow.read";
+                readonly requires: readonly ["workflow.run"];
+                readonly effect: "read";
+            };
+            /** Compile and start a definition as the member on the pinned Computer. */
+            readonly runGraph: {
+                readonly cap: "app.workflow.run";
+                readonly requires: readonly ["workflow.run"];
+                readonly effect: "write";
+            };
+            readonly armSchedule: {
+                readonly cap: "app.workflow.run";
+                readonly requires: readonly ["workflow.run", "workflow.arm"];
+                readonly effect: "write";
+            };
+            readonly disarmSchedule: {
+                readonly cap: "app.workflow.run";
+                readonly requires: readonly ["workflow.run", "workflow.arm"];
+                readonly effect: "write";
+            };
+            readonly schedules: {
+                readonly cap: "app.workflow.read";
+                readonly requires: readonly ["workflow.run"];
+                readonly effect: "read";
+            };
+            readonly armEventTrigger: {
+                readonly cap: "app.workflow.run";
+                readonly requires: readonly ["workflow.run", "workflow.arm"];
+                readonly effect: "write";
+            };
+            readonly disarmEventTrigger: {
+                readonly cap: "app.workflow.run";
+                readonly requires: readonly ["workflow.run", "workflow.arm"];
+                readonly effect: "write";
+            };
+            readonly eventTriggers: {
+                readonly cap: "app.workflow.read";
+                readonly requires: readonly ["workflow.run"];
+                readonly effect: "read";
+            };
+            /** A person's answer to one of a run's reviews; Agents never answer. */
+            readonly cancel: {
+                readonly cap: "app.workflow.run";
+                readonly requires: readonly ["workflow.run"];
+                readonly effect: "write";
+            };
+            readonly answerReview: {
+                readonly cap: "app.workflow.run";
+                readonly requires: readonly ["workflow.run"];
+                readonly effect: "write";
+            };
+            /** One of the member's runs: node events, reviews and engine status. */
+            readonly graphStatus: {
+                readonly cap: "app.workflow.read";
+                readonly requires: readonly ["workflow.run"];
+                readonly effect: "read";
+            };
+            /** Up to 50 runs of this library, newest first; source and initiator included. */
+            readonly runs: {
+                readonly cap: "app.workflow.read";
+                readonly requires: readonly ["workflow.run"];
+                readonly effect: "read";
+            };
+        };
+    };
+    readonly APP_STORAGE: {
+        readonly name: "APP_STORAGE";
+        readonly operations: {
+            readonly read: {
+                readonly cap: "app.storage.read";
+                readonly requires: readonly ["app.storage"];
+                readonly effect: "read";
+            };
+            readonly write: {
+                readonly cap: "app.storage.write";
+                readonly requires: readonly ["app.storage"];
+                readonly effect: "write";
+            };
+            readonly reset: {
+                readonly cap: "app.storage.write";
+                readonly requires: readonly ["app.storage"];
+                readonly effect: "write";
+            };
+        };
+    };
+    readonly MEDIA: {
+        readonly name: "MEDIA";
+        readonly operations: {
+            readonly models: {
+                readonly cap: "app.media.read";
+                readonly requires: readonly ["media.generation"];
+                readonly effect: "read";
+            };
+            readonly generate: {
+                readonly cap: "app.media.generate";
+                readonly requires: readonly ["media.generation", "computer.writeFile"];
+                readonly effect: "write";
+            };
+        };
+    };
+    readonly COMPUTER: {
+        readonly name: "COMPUTER";
+        readonly operations: {
+            readonly list: {
+                readonly cap: "app.computer.read";
+                readonly requires: readonly ["computer.list"];
+                readonly effect: "read";
+            };
+            readonly read: {
+                readonly cap: "app.computer.read";
+                readonly requires: readonly ["computer.readFile"];
+                readonly effect: "read";
+            };
+            readonly ports: {
+                readonly cap: "app.computer.read";
+                readonly requires: readonly ["computer.execute"];
+                readonly effect: "read";
+            };
+            readonly processes: {
+                readonly cap: "app.computer.read";
+                readonly requires: readonly ["computer.execute"];
+                readonly effect: "read";
+            };
+            readonly write: {
+                readonly cap: "app.computer.write";
+                readonly requires: readonly ["computer.writeFile"];
+                readonly effect: "write";
+            };
+            readonly workflowGitPass: {
+                readonly cap: "app.computer.exec";
+                readonly requires: readonly ["computer.execute"];
+                readonly effect: "write";
+            };
+            readonly preview: {
+                readonly cap: "app.computer.exec";
+                readonly requires: readonly ["computer.execute"];
+                readonly effect: "write";
+            };
+            readonly processKill: {
+                readonly cap: "app.computer.exec";
+                readonly requires: readonly ["computer.execute"];
+                readonly effect: "write";
+            };
+            readonly processStart: {
+                readonly cap: "app.computer.exec";
+                readonly requires: readonly ["computer.execute"];
+                readonly effect: "write";
+            };
+            readonly exec: {
+                readonly cap: "app.computer.exec";
+                readonly requires: readonly ["computer.execute"];
+                readonly effect: "write";
+            };
+        };
+    };
+    readonly INBOX: {
+        readonly name: "INBOX";
+        readonly operations: {
+            readonly page: {
+                readonly cap: "inbox.read";
+                readonly requires: readonly ["agent.read"];
+                readonly effect: "read";
+            };
+            readonly visit: {
+                readonly cap: "inbox.visit";
+                readonly requires: readonly ["agent.read"];
+                readonly effect: "write";
+            };
+        };
+    };
+    readonly AGENTS: {
+        readonly name: "AGENTS";
+        readonly operations: {
+            readonly list: {
+                readonly cap: "agent.list";
+                readonly requires: readonly ["agent.list"];
+                readonly effect: "read";
+            };
+            readonly send: {
+                readonly cap: "agent.send";
+                readonly requires: readonly ["agent.send"];
+                readonly effect: "write";
+            };
+        };
+    };
+};
+/** A registered backend binding kind. */
+export type AppBackendBindingName = keyof typeof appBackendBindingKinds;
+/** One author-selected binding; its operation names are checked by the registry decoder. */
+export type AppBackendBinding = Readonly<{
+    name: AppBackendBindingName;
+    operations: readonly string[];
+}>;
+/** RPC method names exposed by the registered kinds. */
+export type AppBackendBindingMethod = {
+    [Kind in AppBackendBindingName]: keyof (typeof appBackendBindingKinds)[Kind]["operations"];
+}[AppBackendBindingName];
+/** The required permissions, effect and broker class of a registered operation. */
+export type AppBackendBindingOperation = {
+    [Kind in AppBackendBindingName]: (typeof appBackendBindingKinds)[Kind]["operations"][keyof (typeof appBackendBindingKinds)[Kind]["operations"]];
+}[AppBackendBindingName];

package/dist/app-backend-binding-vocabulary.js

@@ -0,0 +1,257 @@
+/** The runtime-neutral registry shared by declarations, admission and Exec. */
+export const appBackendBindingKinds = {
+    BACKGROUND: {
+        name: "BACKGROUND",
+        operations: {
+            admit: { cap: "app.background.admit", requires: [], effect: "read" },
+        },
+    },
+    GIT: {
+        name: "GIT",
+        operations: {
+            create: {
+                cap: "app.git.create",
+                requires: ["git.repository"],
+                effect: "write",
+            },
+            fork: {
+                cap: "app.git.fork",
+                requires: ["git.repository"],
+                effect: "write",
+            },
+            read: {
+                cap: "app.git.read",
+                requires: ["git.repository"],
+                effect: "read",
+            },
+            write: {
+                cap: "app.git.write",
+                requires: ["git.repository"],
+                effect: "write",
+            },
+            exchange: {
+                cap: "app.git.exchange",
+                requires: ["git.repository"],
+                effect: "write",
+            },
+        },
+    },
+    EVENTS: {
+        name: "EVENTS",
+        operations: {
+            emit: {
+                cap: "app.events.emit",
+                requires: ["app.events.emit"],
+                effect: "write",
+            },
+        },
+    },
+    APPS: {
+        name: "APPS",
+        operations: {
+            build: {
+                cap: "app.build",
+                requires: ["git.repository", "computer.execute"],
+                effect: "write",
+            },
+            /** Read one build job's current status; the host re-checks the caller is the owner. */
+            buildStatus: {
+                cap: "app.build",
+                requires: [],
+                effect: "read",
+            },
+            /** Install a Release at an installation id, or switch a live one onto
+             * it; the host re-checks the caller is the owner. */
+            select: {
+                cap: "app.select",
+                requires: [],
+                effect: "write",
+            },
+            catalog: {
+                cap: "app.catalog.read",
+                requires: ["team.workbenchHost"],
+                effect: "read",
+            },
+            /** Fork a platform App's published source into its own Team-owned App. */
+            fork: {
+                cap: "app.fork",
+                requires: [],
+                effect: "write",
+            },
+        },
+    },
+    WORKFLOWS: {
+        name: "WORKFLOWS",
+        operations: {
+            /** The member's callable App methods, for an editor's palette. */
+            catalog: {
+                cap: "app.workflow.read",
+                requires: ["workflow.run"],
+                effect: "read",
+            },
+            /** Compile and start a definition as the member on the pinned Computer. */
+            runGraph: {
+                cap: "app.workflow.run",
+                requires: ["workflow.run"],
+                effect: "write",
+            },
+            armSchedule: {
+                cap: "app.workflow.run",
+                requires: ["workflow.run", "workflow.arm"],
+                effect: "write",
+            },
+            disarmSchedule: {
+                cap: "app.workflow.run",
+                requires: ["workflow.run", "workflow.arm"],
+                effect: "write",
+            },
+            schedules: {
+                cap: "app.workflow.read",
+                requires: ["workflow.run"],
+                effect: "read",
+            },
+            armEventTrigger: {
+                cap: "app.workflow.run",
+                requires: ["workflow.run", "workflow.arm"],
+                effect: "write",
+            },
+            disarmEventTrigger: {
+                cap: "app.workflow.run",
+                requires: ["workflow.run", "workflow.arm"],
+                effect: "write",
+            },
+            eventTriggers: {
+                cap: "app.workflow.read",
+                requires: ["workflow.run"],
+                effect: "read",
+            },
+            /** A person's answer to one of a run's reviews; Agents never answer. */
+            cancel: {
+                cap: "app.workflow.run",
+                requires: ["workflow.run"],
+                effect: "write",
+            },
+            answerReview: {
+                cap: "app.workflow.run",
+                requires: ["workflow.run"],
+                effect: "write",
+            },
+            /** One of the member's runs: node events, reviews and engine status. */
+            graphStatus: {
+                cap: "app.workflow.read",
+                requires: ["workflow.run"],
+                effect: "read",
+            },
+            /** Up to 50 runs of this library, newest first; source and initiator included. */
+            runs: {
+                cap: "app.workflow.read",
+                requires: ["workflow.run"],
+                effect: "read",
+            },
+        },
+    },
+    APP_STORAGE: {
+        name: "APP_STORAGE",
+        operations: {
+            read: {
+                cap: "app.storage.read",
+                requires: ["app.storage"],
+                effect: "read",
+            },
+            write: {
+                cap: "app.storage.write",
+                requires: ["app.storage"],
+                effect: "write",
+            },
+            reset: {
+                cap: "app.storage.write",
+                requires: ["app.storage"],
+                effect: "write",
+            },
+        },
+    },
+    MEDIA: {
+        name: "MEDIA",
+        operations: {
+            models: {
+                cap: "app.media.read",
+                requires: ["media.generation"],
+                effect: "read",
+            },
+            generate: {
+                cap: "app.media.generate",
+                requires: ["media.generation", "computer.writeFile"],
+                effect: "write",
+            },
+        },
+    },
+    COMPUTER: {
+        name: "COMPUTER",
+        operations: {
+            list: {
+                cap: "app.computer.read",
+                requires: ["computer.list"],
+                effect: "read",
+            },
+            read: {
+                cap: "app.computer.read",
+                requires: ["computer.readFile"],
+                effect: "read",
+            },
+            ports: {
+                cap: "app.computer.read",
+                requires: ["computer.execute"],
+                effect: "read",
+            },
+            processes: {
+                cap: "app.computer.read",
+                requires: ["computer.execute"],
+                effect: "read",
+            },
+            write: {
+                cap: "app.computer.write",
+                requires: ["computer.writeFile"],
+                effect: "write",
+            },
+            workflowGitPass: {
+                cap: "app.computer.exec",
+                requires: ["computer.execute"],
+                effect: "write",
+            },
+            preview: {
+                cap: "app.computer.exec",
+                requires: ["computer.execute"],
+                effect: "write",
+            },
+            processKill: {
+                cap: "app.computer.exec",
+                requires: ["computer.execute"],
+                effect: "write",
+            },
+            processStart: {
+                cap: "app.computer.exec",
+                requires: ["computer.execute"],
+                effect: "write",
+            },
+            exec: {
+                cap: "app.computer.exec",
+                requires: ["computer.execute"],
+                effect: "write",
+            },
+        },
+    },
+    INBOX: {
+        name: "INBOX",
+        operations: {
+            page: { cap: "inbox.read", requires: ["agent.read"], effect: "read" },
+            visit: { cap: "inbox.visit", requires: ["agent.read"], effect: "write" },
+        },
+    },
+    AGENTS: {
+        name: "AGENTS",
+        operations: {
+            list: { cap: "agent.list", requires: ["agent.list"], effect: "read" },
+            send: { cap: "agent.send", requires: ["agent.send"], effect: "write" },
+        },
+    },
+};

package/dist/app-backend-bindings.d.ts

@@ -0,0 +1,21 @@
+import { type AppBackendBindingName, type AppBackendBindingOperation } from "./app-backend-binding-vocabulary.js";
+export { appBackendBindingKinds, type AppBackendBindingName, type AppBackendBindingMethod, type AppBackendBindingOperation, } from "./app-backend-binding-vocabulary.js";
+import * as Schema from "effect/Schema";
+/** Author declarations select named operations from registered binding kinds. */
+export declare const appBackendBindingsSchema: Schema.$Array<Schema.Union<Schema.Struct<{
+    readonly name: Schema.Literal<"BACKGROUND" | "GIT" | "EVENTS" | "APPS" | "WORKFLOWS" | "APP_STORAGE" | "MEDIA" | "COMPUTER" | "INBOX" | "AGENTS">;
+    readonly operations: Schema.$Array<Schema.Literals<string[]>>;
+}>[]>>;
+/** Signed shard bindings pair each operation with its exact broker class. */
+export declare const appBackendShardBindingsSchema: Schema.$Array<Schema.Union<Schema.Struct<{
+    readonly name: Schema.Literal<"BACKGROUND" | "GIT" | "EVENTS" | "APPS" | "WORKFLOWS" | "APP_STORAGE" | "MEDIA" | "COMPUTER" | "INBOX" | "AGENTS">;
+    readonly operations: Schema.$Array<Schema.Union<Schema.Struct<{
+        readonly name: Schema.Literal<string>;
+        readonly cap: Schema.Literal<"agent.list" | "agent.send" | "app.events.emit" | "app.background.admit" | "app.git.create" | "app.git.fork" | "app.git.read" | "app.git.write" | "app.git.exchange" | "app.build" | "app.select" | "app.catalog.read" | "app.fork" | "app.workflow.read" | "app.workflow.run" | "app.storage.read" | "app.storage.write" | "app.media.read" | "app.media.generate" | "app.computer.read" | "app.computer.write" | "app.computer.exec" | "inbox.read" | "inbox.visit">;
+    }>[]>>;
+}>[]>>;
+/** Look up an operation within its declared kind; unknown names have no authority. */
+export declare function appBackendBindingOperation(name: AppBackendBindingName, operation: string): AppBackendBindingOperation | undefined;
+/** Keep only operations required by the verified method and allowed by its write ceiling.
+ * Without a method, installation-scoped calls still respect the captured ceiling. */
+export declare function scopeOperationToMethod(operation: AppBackendBindingOperation, method: Pick<import("./app-vocabulary.js").AppApi["methods"][string], "requires" | "effect"> | undefined, ceiling: "read" | "write"): boolean;

package/dist/app-backend-bindings.js

@@ -0,0 +1,47 @@
+import { appBackendBindingKinds, } from "./app-backend-binding-vocabulary.js";
+export { appBackendBindingKinds, } from "./app-backend-binding-vocabulary.js";
+import * as Schema from "effect/Schema";
+import { appApiMethodNameSchema } from "./app-api.js";
+const unique = (values) => new Set(values).size === values.length;
+function bindingKind(name, operations) {
+    const names = Object.keys(operations);
+    for (const operation of names)
+        Schema.decodeUnknownSync(appApiMethodNameSchema)(operation);
+    const declaration = Schema.Struct({
+        name: Schema.Literal(name),
+        operations: Schema.Array(Schema.Literals(names)).pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(names.length)), Schema.check(Schema.makeFilter(unique))),
+    });
+    const shard = Schema.Struct({
+        name: Schema.Literal(name),
+        operations: Schema.Array(Schema.Union(Object.entries(operations).map(([name, operation]) => Schema.Struct({
+            name: Schema.Literal(name),
+            cap: Schema.Literal(operation.cap),
+        })))).pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(names.length)), Schema.check(Schema.makeFilter((ops) => unique(ops.map((op) => op.name)), {
+            message: "App backend operation repeated",
+        }))),
+    });
+    return { declaration, shard };
+}
+const kinds = Object.values(appBackendBindingKinds).map((kind) => bindingKind(kind.name, kind.operations));
+const count = kinds.length;
+/** Author declarations select named operations from registered binding kinds. */
+export const appBackendBindingsSchema = Schema.Array(Schema.Union(kinds.map((kind) => kind.declaration))).pipe(Schema.check(Schema.isMaxLength(count)), Schema.check(Schema.makeFilter((bindings) => unique(bindings.map((binding) => binding.name)))));
+/** Signed shard bindings pair each operation with its exact broker class. */
+export const appBackendShardBindingsSchema = Schema.Array(Schema.Union(kinds.map((kind) => kind.shard))).pipe(Schema.check(Schema.isMaxLength(count)), Schema.check(Schema.makeFilter((bindings) => unique(bindings.map((binding) => binding.name)))));
+const operationCatalog = new Map(Object.entries(appBackendBindingKinds).map(([name, operations]) => [
+    name,
+    new Map(Object.entries(operations.operations)),
+]));
+/** Look up an operation within its declared kind; unknown names have no authority. */
+export function appBackendBindingOperation(name, operation) {
+    return operationCatalog.get(name)?.get(operation);
+}
+/** Keep only operations required by the verified method and allowed by its write ceiling.
+ * Without a method, installation-scoped calls still respect the captured ceiling. */
+export function scopeOperationToMethod(operation, method, ceiling) {
+    return ((method === undefined ||
+        operation.requires.every((capability) => method.requires.includes(capability))) &&
+        (operation.effect === "read" ||
+            ((method === undefined || method.effect === "write") &&
+                ceiling === "write")));
+}

package/dist/app-declaration.d.ts

@@ -0,0 +1,46 @@
+import * as Schema from "effect/Schema";
+import { type AppDeclaration, type AppDeclaredCommand } from "./app-vocabulary.js";
+export declare const appRoleSchema: Schema.Literals<readonly ["dashboard", "inbox", "files", "media", "sessions", "terminal"]>;
+export declare const appCapabilityIdSchema: Schema.Literals<readonly ["agent.list", "agent.manage", "agent.rename", "agent.toolPolicy", "agent.read", "agent.send", "computer.list", "computer.readFile", "computer.writeFile", "computer.execute", "llm.generation", "media.generation", "games:servers", "git.repository", "apps.open", "apps.call", "app.storage", "app.events.emit", "team.workbenchHost", "marketplace.browse", "marketplace.purchase", "workflow.run", "workflow.publish", "workflow.arm", "world", "channels.read", "channels.personal.manage"]>;
+export declare const appHandlerSchema: Schema.Literals<readonly ["file.open"]>;
+/**
+ * One declared command: a Whistle definition's identity and projections.
+ * Runtime-only facts (availability, typed actions, slash argument grammar)
+ * are not part of the digest-covered declaration and are dropped on decode.
+ */
+export declare const appDeclaredCommandSchema: Schema.Codec<AppDeclaredCommand>;
+/** Maintained grammar for one bounded key in an App's private storage. */
+export declare const appStorageKeyNameSchema: Schema.String;
+export declare const appStorageKeySchema: Schema.declareConstructor<{
+    readonly key: string;
+    readonly scopes: readonly ("team" | "member")[];
+    readonly maxBytes: number;
+}, {
+    readonly key: string;
+    readonly scopes: readonly ("team" | "member")[];
+    readonly maxBytes: number;
+}, readonly [Schema.Struct<{
+    readonly key: Schema.String;
+    readonly scopes: Schema.$Array<Schema.Literals<readonly ["team", "member"]>>;
+    readonly maxBytes: Schema.Int;
+}>], {
+    readonly key: string;
+    readonly scopes: readonly ("team" | "member")[];
+    readonly maxBytes: number;
+}>;
+/** The bounded, digest-covered allowlist shown when approving member App calls. */
+export declare const appCallsSchema: Schema.$Array<Schema.declareConstructor<{
+    readonly appId: string;
+    readonly methods: readonly string[];
+}, {
+    readonly appId: string;
+    readonly methods: readonly string[];
+}, readonly [Schema.Struct<{
+    readonly appId: Schema.String;
+    readonly methods: Schema.$Array<Schema.String>;
+}>], {
+    readonly appId: string;
+    readonly methods: readonly string[];
+}>>;
+/** Boundary codec for the digest-covered {@link AppDeclaration}. */
+export declare const appDeclarationSchema: Schema.Codec<AppDeclaration>;