@fungi.computer/agar 0.0.0-stage → 0.0.1

package/dist/test-kit/git.js

@@ -0,0 +1,174 @@
+import { pathToFileURL } from "node:url";
+import { execFileSync, spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import * as z from "zod";
+/** Real smart HTTP writes and git plumbing reads in one disposable bare repository. */
+export function realGit() {
+    const root = mkdtempSync(join(tmpdir(), "agar-real-git-"));
+    const run = (name, ...args) => execFileSync("git", [`--git-dir=${join(root, `${name}.git`)}`, ...args], {
+        encoding: "utf8",
+    }).trim();
+    const info = (name) => existsSync(join(root, `${name}.git`))
+        ? { name, defaultBranch: "main", lastPushAt: null, source: null }
+        : null;
+    const readCommit = (name, hash) => {
+        const found = spawnSync("git", [`--git-dir=${join(root, `${name}.git`)}`, "cat-file", "-t", hash], { encoding: "utf8" });
+        if (found.status !== 0 || found.stdout.trim() !== "commit")
+            return null;
+        const [oid, treeHash, parents, authorName, authorEmail, committerName, committerEmail, authoredAt, committedAt, message,] = z
+            .tuple([
+            z.string(),
+            z.string(),
+            z.string(),
+            z.string(),
+            z.string(),
+            z.string(),
+            z.string(),
+            z.string(),
+            z.string(),
+            z.string(),
+        ])
+            .parse(run(name, "show", "-s", "--format=%H%x00%T%x00%P%x00%an%x00%ae%x00%cn%x00%ce%x00%at%x00%ct%x00%B", hash).split("\0"));
+        return {
+            hash: oid,
+            treeHash,
+            parents: parents ? parents.split(" ") : [],
+            author: { name: authorName, email: authorEmail },
+            committer: { name: committerName, email: committerEmail },
+            authoredAt: Number(authoredAt),
+            committedAt: Number(committedAt),
+            message,
+        };
+    };
+    const git = {
+        cloneUrl: (name) => {
+            if (info(name) === null)
+                return Promise.reject(new Error("Repository unavailable"));
+            return Promise.resolve(pathToFileURL(join(root, `${name}.git`)).href);
+        },
+        info: (name) => Promise.resolve(info(name)),
+        create: (name, options) => {
+            if (!info(name)) {
+                execFileSync("git", [
+                    "init",
+                    "--bare",
+                    "-q",
+                    "-b",
+                    options?.defaultBranch ?? "main",
+                    `${name}.git`,
+                ], { cwd: root });
+                run(name, "config", "http.receivepack", "true");
+            }
+            const created = info(name);
+            if (!created)
+                throw new Error("Repository creation failed");
+            return Promise.resolve(created);
+        },
+        fork: () => Promise.reject(new Error("Unexpected fork")),
+        delete: (name) => {
+            const existed = info(name) !== null;
+            rmSync(join(root, `${name}.git`), { recursive: true, force: true });
+            return Promise.resolve(existed);
+        },
+        readCommit: (name, hash) => Promise.resolve(readCommit(name, hash)),
+        log: (name, { ref, limit = 50, offset = 0 }) => {
+            if (!readCommit(name, ref))
+                return Promise.resolve([]);
+            return Promise.resolve(run(name, "rev-list", "--first-parent", `--max-count=${String(limit)}`, `--skip=${String(offset)}`, ref)
+                .split("\n")
+                .filter(Boolean)
+                .map((hash) => {
+                const commit = readCommit(name, hash);
+                if (!commit)
+                    throw new Error("Commit disappeared");
+                return commit;
+            }));
+        },
+        readTree: (name, hash) => Promise.resolve(run(name, "ls-tree", "-z", hash)
+            .split("\0")
+            .filter(Boolean)
+            .map((line) => {
+            const [head, entryName] = z
+                .tuple([z.string(), z.string()])
+                .parse(line.split("\t"));
+            const [mode, type, oid] = z
+                .tuple([
+                z.string(),
+                z.enum(["tree", "blob", "commit"]),
+                z.string(),
+            ])
+                .parse(head.split(" "));
+            return { name: entryName, mode, type, hash: oid };
+        })),
+        readBlob: (name, hash) => Promise.resolve(new Uint8Array(execFileSync("git", [
+            `--git-dir=${join(root, `${name}.git`)}`,
+            "cat-file",
+            "blob",
+            hash,
+        ]))),
+        refs: (name) => Promise.resolve(info(name)
+            ? run(name, "for-each-ref", "--format=%(refname) %(objectname)")
+                .split("\n")
+                .filter(Boolean)
+                .map((line) => {
+                const [ref, hash] = z
+                    .tuple([z.string(), z.string()])
+                    .parse(line.split(" "));
+                return { name: ref, hash };
+            })
+            : []),
+        exchange: (name, request) => {
+            const result = spawnSync("git", ["http-backend"], {
+                input: request.body ?? new Uint8Array(),
+                // A whole App source pack is far over spawnSync's 1 MiB default.
+                maxBuffer: 256 * 1024 * 1024,
+                env: {
+                    ...process.env,
+                    GIT_PROJECT_ROOT: root,
+                    GIT_HTTP_EXPORT_ALL: "1",
+                    PATH_INFO: request.phase === "advertise"
+                        ? `/${name}.git/info/refs`
+                        : `/${name}.git/git-${request.service}`,
+                    REQUEST_METHOD: request.phase === "advertise" ? "GET" : "POST",
+                    QUERY_STRING: request.phase === "advertise"
+                        ? `service=git-${request.service}`
+                        : "",
+                    CONTENT_TYPE: request.headers["content-type"] ?? "",
+                    GIT_PROTOCOL: request.headers["git-protocol"] ?? "",
+                },
+            });
+            if (result.status !== 0)
+                throw new Error("git http-backend failed");
+            const output = Buffer.from(result.stdout);
+            const split = output.indexOf("\r\n\r\n");
+            const headers = {};
+            let status = 200;
+            for (const line of output
+                .subarray(0, split)
+                .toString("utf8")
+                .split("\r\n")) {
+                const colon = line.indexOf(":");
+                const key = line.slice(0, colon).toLowerCase();
+                const value = line.slice(colon + 1).trim();
+                if (key === "status")
+                    status = Number(value.split(" ")[0]);
+                else
+                    headers[key] = value;
+            }
+            return Promise.resolve({
+                status,
+                headers,
+                body: new Uint8Array(result.stdout.subarray(split + 4)),
+            });
+        },
+    };
+    return {
+        git,
+        run,
+        close: () => {
+            rmSync(root, { recursive: true });
+        },
+    };
+}

package/dist/ui.d.ts

@@ -0,0 +1,169 @@
+/** Deliberately narrow shell affordances; domain work belongs to capabilities. */
+export type HostUi = {
+    /** Open the host-owned Computer picker; selection arrives through App context. */
+    requestComputerChoice(): Promise<void>;
+    /** Request a host browser action from a fresh user click in this App. */
+    requestBrowserAction(input: AppBrowserAction): Promise<AppBrowserActionOutcome>;
+    /**
+     * Ask the trusted host for App rights. The host, never the App, renders the
+     * consent and writes any grant; an empty request opens App permissions.
+     */
+    requestAppPermissions(input: AppPermissionRequest): Promise<AppPermissionOutcome>;
+    /** Ask the host to open an already admitted Computer file. */
+    openNavigation(input: FileNavigationInput): Promise<void>;
+    /**
+     * Declare this window's status bar items, such as "2 documents" or a Ports
+     * button. The host renders them beside the Computer it owns; the newest
+     * report wins and an empty list clears them.
+     */
+    reportStatus(items: readonly AppStatusItem[]): Promise<void>;
+    /**
+     * Hear the person use one of this window's declared status items. One
+     * owner at a time; the host never renders App UI in its chrome.
+     */
+    onStatusAction(handler: AppStatusActionHandler): () => void;
+    /** Leave the App for the host's Billing page for this Team. */
+    openTeamBilling(): Promise<void>;
+    /** Suggest this App's desktop Gills while focused with browser activation.
+     * The host shows a notice; the member must choose Review to open Settings.
+     * The App receives no layout or placement authority. */
+    openDesktopSettings(): Promise<void>;
+    /** Tell the host which Agent conversation this App currently has
+     * selected, or null when none is selected. */
+    reportAgentSessionSelection(selection: AgentSessionSelection | null): Promise<void>;
+    /** Ask the host to show a transient toast notification. */
+    showToast(input: ToastInput): Promise<void>;
+};
+/** The most readouts one App window's status bar shows. */
+export declare const APP_STATUS_ITEMS_MAX = 6;
+/** The longest readout a window's status bar shows. */
+export declare const APP_STATUS_TEXT_MAX = 80;
+/** The most choices one status menu offers. */
+export declare const APP_STATUS_OPTIONS_MAX = 16;
+/** The marks a host can draw before a status button's label. */
+export type AppStatusIcon = "folder" | "ports" | "processes" | "access";
+/** A readout's live state, shown as a small light before its text. */
+export type AppStatusTone = "neutral" | "success" | "warning" | "error";
+/** One choice in a status menu, such as a folder or a port. */
+export type AppStatusOption = Readonly<{
+    id: string;
+    text: string;
+    /** Marks the current choice in a picker-style menu. */
+    checked?: boolean;
+    disabled?: boolean;
+}>;
+/**
+ * One item an App declares for its window's status bar, as data: a readout,
+ * a button, a toggle, or a menu of choices. Using one delivers an
+ * {@link AppStatusAction} back to the App.
+ */
+export type AppStatusItem = Readonly<{
+    id: string;
+    text: string;
+    /** Hold this item at the bar's far end, like a save state. */
+    end?: boolean;
+    kind: "text";
+    tone?: AppStatusTone;
+}> | Readonly<{
+    id: string;
+    text: string;
+    /** Hold this item at the bar's far end, like a save state. */
+    end?: boolean;
+    kind: "button";
+    /** A host-drawn mark before the label. */
+    icon?: AppStatusIcon;
+    /** A positive count after the label; zero is hidden. */
+    count?: number;
+    /** A longer description, such as a full folder path. */
+    title?: string;
+    disabled?: boolean;
+    /** The button opens App UI: a tray or a dialog. */
+    opens?: "dialog";
+    /** Whether the UI this button opens is open now. */
+    expanded?: boolean;
+}> | Readonly<{
+    id: string;
+    text: string;
+    /** Hold this item at the bar's far end, like a save state. */
+    end?: boolean;
+    kind: "toggle";
+    pressed: boolean;
+}> | Readonly<{
+    id: string;
+    text: string;
+    /** Hold this item at the bar's far end, like a save state. */
+    end?: boolean;
+    kind: "menu";
+    count?: number;
+    title?: string;
+    options: readonly AppStatusOption[];
+}>;
+/**
+ * The person used a status item; `optionId` names a chosen menu option.
+ * `anchor` is where the item sits along the App's surface, in CSS pixels from
+ * its inline start, so App UI it opens can sit above it.
+ */
+export type AppStatusAction = Readonly<{
+    itemId: string;
+    optionId?: string;
+    anchor?: Readonly<{
+        start: number;
+        width: number;
+    }>;
+}>;
+/** Handles one status action; `true` when the App acted on it. */
+export type AppStatusActionHandler = (action: AppStatusAction) => boolean | Promise<boolean>;
+/** Exact Agent conversation selected by an App for the authenticated shell. */
+export type AgentSessionSelection = Readonly<{
+    agentId: string;
+    sessionId: string;
+}>;
+/** A presentation-neutral request to open an already admitted Computer file. */
+export type FileNavigationInput = {
+    readonly computerId: string;
+    readonly path: string;
+};
+/** A transient notification an App asks its host to show. */
+export type ToastInput = {
+    readonly message: string;
+    readonly tone?: "error" | "info" | "success" | "warning";
+};
+/** Agent rights an App may ask its host to grant through consent. */
+export type AgentAccessOperation = "agent.list" | "agent.manage" | "agent.read" | "agent.send";
+/** Computer rights an App may ask its host to grant through consent. */
+export type ComputerAccessOperation = "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute";
+/** The rights an App asks for; the host bounds them by its declared ceiling. */
+export type AppPermissionRequest = Readonly<{
+    agents?: readonly AgentAccessOperation[];
+    computers?: readonly ComputerAccessOperation[];
+}>;
+/**
+ * `granted`: the host saved a grant covering the request. `declined`: the user
+ * said not now. `customize`: the host opened its full permission settings.
+ */
+export type AppPermissionOutcome = "granted" | "declined" | "customize";
+/** Maximum file size sent through the user-initiated host browser door. */
+export declare const APP_BROWSER_SAVE_MAX_BYTES: number;
+/** Maximum UTF-8 text size sent to the host clipboard. */
+export declare const APP_BROWSER_COPY_MAX_BYTES: number;
+/** Data only; browser authority and the gesture check belong to the host. */
+export type AppBrowserAction = Readonly<{
+    kind: "saveFile";
+    name: string;
+    mime: string;
+    bytes: Uint8Array;
+}> | Readonly<{
+    kind: "copyText";
+    text: string;
+}>;
+/** A browser action can be refused without disconnecting the App. */
+export type AppBrowserActionRefusal = Readonly<{
+    kind: "refused";
+    reason: "no-user-gesture" | "too-large" | "invalid-request" | "unavailable" | "denied" | "busy";
+}>;
+/** Saved means a browser download was initiated, not a confirmed disk write. */
+export type AppBrowserActionOutcome = Readonly<{
+    kind: "saved";
+}> | Readonly<{
+    kind: "copied";
+}> | AppBrowserActionRefusal;

package/dist/ui.js

@@ -0,0 +1,10 @@
+/** The most readouts one App window's status bar shows. */
+export const APP_STATUS_ITEMS_MAX = 6;
+/** The longest readout a window's status bar shows. */
+export const APP_STATUS_TEXT_MAX = 80;
+/** The most choices one status menu offers. */
+export const APP_STATUS_OPTIONS_MAX = 16;
+/** Maximum file size sent through the user-initiated host browser door. */
+export const APP_BROWSER_SAVE_MAX_BYTES = 32 * 1024 * 1024;
+/** Maximum UTF-8 text size sent to the host clipboard. */
+export const APP_BROWSER_COPY_MAX_BYTES = 1024 * 1024;

package/dist/window.d.ts

@@ -0,0 +1,41 @@
+import type { Disposer } from "./store.js";
+/** Consulted before the person closes the App's window; return (or
+ * resolve) `true` to allow the close. */
+export type BeforeAppClose = () => boolean | Promise<boolean>;
+/**
+ * Version of the navigation contract an App publishes. The host rejects any
+ * other version, so a future shape can never be misread as this one.
+ */
+export declare const APP_NAVIGATION_CONTRACT_VERSION: 1;
+/** The longest page title a host shows beside the App's own name. */
+export declare const APP_NAVIGATION_TITLE_MAX = 80;
+/**
+ * What the App's own router can do right now. The App owns its history; the
+ * host only offers a Back affordance and relays the person's request.
+ */
+export type AppNavigationState = Readonly<{
+    canGoBack: boolean;
+    /** The current page's title, shown after the App name in window chrome. */
+    title?: string;
+}>;
+/** Go back one step in the App's own history; `true` when it moved. */
+export type AppBackHandler = () => boolean | Promise<boolean>;
+/** The App's half of the host navigation contract. */
+export type HostNavigation = Readonly<{
+    /** Report the latest navigation state; the newest report wins. */
+    publish(state: AppNavigationState): Promise<void>;
+    /** Own the host's Back requests; one owner at a time. */
+    onBack(handler: AppBackHandler): Disposer;
+}>;
+/** App-owned presentation policy consulted before a user closes its window. */
+export type AppWindow = Readonly<{
+    /** Register a close-guard handler; one owner at a time. Call the
+     * returned Disposer to withdraw it. */
+    onBeforeClose(handler: BeforeAppClose): Disposer;
+    navigation: HostNavigation;
+}>;
+/**
+ * Navigation for a root with no host chrome, such as a workbench fixture: it
+ * accepts every report and never asks the App to go back.
+ */
+export declare const inertHostNavigation: HostNavigation;

package/dist/window.js

@@ -0,0 +1,15 @@
+/**
+ * Version of the navigation contract an App publishes. The host rejects any
+ * other version, so a future shape can never be misread as this one.
+ */
+export const APP_NAVIGATION_CONTRACT_VERSION = 1;
+/** The longest page title a host shows beside the App's own name. */
+export const APP_NAVIGATION_TITLE_MAX = 80;
+/**
+ * Navigation for a root with no host chrome, such as a workbench fixture: it
+ * accepts every report and never asks the App to go back.
+ */
+export const inertHostNavigation = Object.freeze({
+    publish: () => Promise.resolve(),
+    onBack: () => () => undefined,
+});

package/dist/world.d.ts

@@ -0,0 +1,16 @@
+/** Public MCP world-seat vocabulary, independent of any engine or host. */
+export declare const worldToolNames: Readonly<{
+    readonly observe: "world_observe";
+    readonly command: "world_command";
+    readonly explain: "world_explain";
+    readonly say: "world_say";
+    readonly snapshot: "world_snapshot";
+    readonly advance: "world_advance";
+}>;
+export declare const worldMcpManifest: Readonly<{
+    id: "world-mcp-v1";
+    module: "world";
+    tools: Readonly<{
+        [k: string]: string;
+    }>;
+}>;

package/dist/world.js

@@ -0,0 +1,17 @@
+/** Public MCP world-seat vocabulary, independent of any engine or host. */
+export const worldToolNames = Object.freeze({
+    observe: "world_observe",
+    command: "world_command",
+    explain: "world_explain",
+    say: "world_say",
+    snapshot: "world_snapshot",
+    advance: "world_advance",
+});
+export const worldMcpManifest = Object.freeze({
+    id: "world-mcp-v1",
+    module: "world",
+    tools: Object.freeze(Object.fromEntries(Object.entries(worldToolNames).map(([operation, name]) => [
+        name,
+        operation,
+    ]))),
+});

package/docs/api/README.md

@@ -0,0 +1,28 @@
+<!-- Generated by Botanical API docs (TypeDoc + typedoc-plugin-markdown). Do not edit. -->
+
+**@fungi.computer/agar**
+
+---
+
+# Agar API overview
+
+| Import                                     | Export                                                 | Purpose                                                                                  |
+| ------------------------------------------ | ------------------------------------------------------ | ---------------------------------------------------------------------------------------- |
+| `@fungi.computer/agar`                     | `connectApp`                                           | Connect a host-mounted App frontend and receive its context and grants.                  |
+| `@fungi.computer/agar`                     | `defineCapability`, `AppError`                         | Declare a typed host capability; the SDK's one typed failure.                            |
+| `@fungi.computer/agar/host`                | `connectAppHost`                                       | Mount an App in an author-owned iframe test or standalone page.                          |
+| `@fungi.computer/agar/react`               | `mountApp`, `useAppContext`                            | Mount a React App and read its host context.                                             |
+| `@fungi.computer/agar/query`               | `queryKeys`                                            | TanStack Query keys and live feeds for host data.                                        |
+| `@fungi.computer/agar/errors`              | `describeAppError`                                     | Turn a failure into approved, action-hinted UI copy.                                     |
+| `@fungi.computer/agar/backend-definition`  | `defineAppBackend`, `defineAppMethod`                  | Define typed backend methods once, with Zod input and output.                            |
+| `@fungi.computer/agar/backend-declaration` | `buildAppApi`, `buildAppDeclaration`                   | Project the backend definition to the JSON Schema App API at build time.                 |
+| `@fungi.computer/agar/backend`             | `appBackend`                                           | Call the App's own backend from its frontend.                                            |
+| `@fungi.computer/agar/rpc`                 | `rpcHandleSchema`, `rpcMethod`                         | Validate object-capability handles received over Cap'n Web.                              |
+| `@fungi.computer/agar/files`               | `readAppFile`, `writeAppFile`                          | Turn a host-owned file read or write handle into a `File` or an upload.                  |
+| `@fungi.computer/agar/storage`             | `appStorage`                                           | Read, write and watch the App's own member and Team data.                                |
+| `@fungi.computer/agar/computer-contracts`  | `workflowGitPassResultSchema`, `WorkflowGitPassResult` | Validate host-issued, credential-free Workflow pass metadata without granting authority. |
+
+A host decides what an App may do: the frontend asks for a capability and the
+host grants, denies or revokes it. The backend definition is runtime-neutral;
+the same methods back the App's own UI and, through the generated App API, the
+tools a host offers to Agents. The generated module pages below list every type.

package/docs/api/app-build-contract.md

@@ -0,0 +1,113 @@
+<!-- Generated by Botanical API docs (TypeDoc + typedoc-plugin-markdown). Do not edit. -->
+
+[**@fungi.computer/agar**](README.md)
+
+---
+
+[@fungi.computer/agar](modules.md) / app-build-contract
+
+# app-build-contract
+
+## Variables
+
+### teamAppBuildFailureCodeSchema
+
+```ts
+const teamAppBuildFailureCodeSchema: ZodEnum<{
+  unavailable: "unavailable";
+  denied: "denied";
+  invalid: "invalid";
+  conflict: "conflict";
+  build_failed: "build_failed";
+}>;
+```
+
+Refusals emitted by the Team App build owner.
+
+---
+
+### appBuildReplySchema
+
+```ts
+const appBuildReplySchema: ZodUnion<
+  readonly [
+    ZodObject<
+      {
+        kind: ZodLiteral<"pending">;
+        retryAfterMs: ZodNumber;
+      },
+      $strict
+    >,
+    ZodObject<
+      {
+        releaseId: ZodString;
+        previewUrl: ZodURL;
+      },
+      $strict
+    >,
+    ZodObject<
+      {
+        error: ZodEnum<{
+          unavailable: "unavailable";
+          denied: "denied";
+          invalid: "invalid";
+          conflict: "conflict";
+          build_failed: "build_failed";
+        }>;
+      },
+      $strict
+    >,
+  ]
+>;
+```
+
+Pending, completed or failed reply from the App build owner.
+
+---
+
+### appBuildBrokerResultSchema
+
+```ts
+const appBuildBrokerResultSchema: ZodUnion<
+  readonly [
+    ZodUnion<
+      readonly [
+        ZodObject<
+          {
+            kind: ZodLiteral<"pending">;
+            retryAfterMs: ZodNumber;
+          },
+          $strict
+        >,
+        ZodObject<
+          {
+            releaseId: ZodString;
+            previewUrl: ZodURL;
+          },
+          $strict
+        >,
+        ZodObject<
+          {
+            error: ZodEnum<{
+              unavailable: "unavailable";
+              denied: "denied";
+              invalid: "invalid";
+              conflict: "conflict";
+              build_failed: "build_failed";
+            }>;
+          },
+          $strict
+        >,
+      ]
+    >,
+    ZodObject<
+      {
+        error: ZodString;
+      },
+      $strict
+    >,
+  ]
+>;
+```
+
+Complete App build binding reply, including broker admission failures.

package/docs/api/backend-declaration.md

@@ -0,0 +1,62 @@
+<!-- Generated by Botanical API docs (TypeDoc + typedoc-plugin-markdown). Do not edit. -->
+
+[**@fungi.computer/agar**](README.md)
+
+---
+
+[@fungi.computer/agar](modules.md) / backend-declaration
+
+# backend-declaration
+
+## Functions
+
+### buildAppApi()
+
+```ts
+function buildAppApi<Context>(backend): AppApi;
+```
+
+Build-only API projection from the schemas used by runtime calls.
+
+#### Type Parameters
+
+| Type Parameter |
+| -------------- |
+| `Context`      |
+
+#### Parameters
+
+| Parameter | Type                                                                                                                                     |
+| --------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `backend` | `Pick`\<[`AppBackendDefinition`](backend-definition.md#appbackenddefinition)\<`Context`\>, `"methods"` \| `"events"` \| `"toolFamily"`\> |
+
+#### Returns
+
+`AppApi`
+
+---
+
+### buildAppDeclaration()
+
+```ts
+function buildAppDeclaration<Context>(backend, declaration): AppDeclaration;
+```
+
+Strict build-only declaration generation; Workers never import this module.
+
+#### Type Parameters
+
+| Type Parameter |
+| -------------- |
+| `Context`      |
+
+#### Parameters
+
+| Parameter     | Type                                                                                                                                                              |
+| ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `backend`     | `Pick`\<[`AppBackendDefinition`](backend-definition.md#appbackenddefinition)\<`Context`\>, `"methods"` \| `"events"` \| `"gills"` \| `"sync"` \| `"toolFamily"`\> |
+| `declaration` | `unknown`                                                                                                                                                         |
+
+#### Returns
+
+`AppDeclaration`