@fungi.computer/tourtois 0.0.0-stage → 0.0.1

package/dist/app-directory-reconciliation.d.ts

@@ -0,0 +1,14 @@
+import type { AppWindowManager, AppLaunchDescriptor } from "./app-windows.js";
+export type AppWindowReconciliationTrigger = Readonly<{
+    kind: "background-directory-update";
+}> | Readonly<{
+    kind: "selection-changed";
+}>;
+/** Replace open windows when the owner-issued App directory changes authority. */
+export declare function reconcileAppDirectory<A extends {
+    surfaceId: string;
+}>(appWindows: AppWindowManager, apps: readonly A[], launchFor: (app: A, currentLaunch?: AppLaunchDescriptor) => AppLaunchDescriptor | null, onFailure: (action: "close" | "replace") => void): Promise<void>;
+/** Refresh one stale mount and report whether its old generation was retired. */
+export declare function reconcileAppWindowFromDirectory<A extends {
+    surfaceId: string;
+}>(appWindows: AppWindowManager, staleLaunch: AppLaunchDescriptor, apps: readonly A[], launchFor: (app: A, currentLaunch?: AppLaunchDescriptor) => AppLaunchDescriptor | null, trigger: AppWindowReconciliationTrigger, onFailure: (action: "close" | "replace") => void): Promise<boolean>;

package/dist/app-directory-reconciliation.js

@@ -0,0 +1,72 @@
+import { sameOfferedComputers } from "./app-launch.js";
+/** Replace open windows when the owner-issued App directory changes authority. */
+export async function reconcileAppDirectory(appWindows, apps, launchFor, onFailure) {
+    await Promise.all(appWindows.read().windows.map(async (open) => {
+        await reconcileAppWindowFromDirectory(appWindows, open.launch, apps, launchFor, { kind: "background-directory-update" }, onFailure);
+    }));
+}
+/** Refresh one stale mount and report whether its old generation was retired. */
+export async function reconcileAppWindowFromDirectory(appWindows, staleLaunch, apps, launchFor, trigger, onFailure) {
+    const current = appWindows
+        .read()
+        .windows.find((window) => window.windowId === staleLaunch.windowId);
+    if (!current?.launch ||
+        appLaunchRequiresReplacement(staleLaunch, current.launch))
+        return true;
+    const app = apps.find((candidate) => candidate.surfaceId === staleLaunch.surfaceId);
+    const next = app ? launchFor(app, current.launch) : null;
+    if (next &&
+        !(trigger.kind === "selection-changed"
+            ? appLaunchRequiresReplacement(current.launch, next)
+            : appLaunchRequiresDirectoryUpdate(current.launch, next))) {
+        // The same mount keeps its iframe; only the Computers its status bar
+        // offers follow the Team's current grants and names. An unreadable
+        // inventory offers nothing new, so the window keeps its last offer.
+        const offered = next.computers;
+        if (offered !== undefined && !sameOfferedComputers(current.launch, next))
+            // Only the offer changes, applied to the launch committed when the
+            // queue reaches it: a Computer switch queued ahead of it stands.
+            await appWindows
+                .update(current.windowId, (latest) => ({
+                ...latest,
+                computers: offered,
+            }))
+                .catch((cause) => {
+                console.error("App Computer offer refresh failed", cause);
+            });
+        return false;
+    }
+    const generation = current.generation;
+    try {
+        if (next)
+            await appWindows.replace(current.windowId, next);
+        else
+            await appWindows.close(current.windowId);
+    }
+    catch (cause) {
+        console.error("App directory reconciliation failed", cause);
+        onFailure(next ? "replace" : "close");
+        return false;
+    }
+    const after = appWindows
+        .read()
+        .windows.find((window) => window.windowId === current.windowId);
+    return after?.generation !== generation;
+}
+function appLaunchRequiresReplacement(current, next) {
+    return (next.appId !== current.appId ||
+        next.surfaceId !== current.surfaceId ||
+        next.releaseId !== current.releaseId ||
+        stableLaunchHref(next.href) !== stableLaunchHref(current.href));
+}
+function appLaunchRequiresDirectoryUpdate(current, next) {
+    return (next.appId !== current.appId ||
+        next.surfaceId !== current.surfaceId ||
+        stableLaunchHref(next.href, true) !== stableLaunchHref(current.href, true));
+}
+function stableLaunchHref(href, ignoreReleaseId = false) {
+    const url = new URL(href, "https://tourtois.invalid");
+    if (ignoreReleaseId)
+        url.searchParams.delete("releaseId");
+    return url.pathname + url.search;
+}

package/dist/app-directory.d.ts

@@ -0,0 +1,206 @@
+import { type WorkbenchDirectory } from "@fungi.computer/oyster/shell/workbench-directory";
+/** Shell composition keeps an unread directory distinct from an empty one. */
+export declare function useAppDirectory(teamId: string, directoryReader: () => Promise<WorkbenchDirectory>): {
+    query: import("@tanstack/react-query").UseQueryResult<{
+        apps: {
+            address: {
+                kind: "default";
+                appId: string;
+            } | {
+                kind: "installation";
+                installationId: string;
+            };
+            installationId: string | null;
+            surfaceId: string;
+            appId: string;
+            releaseId: string | null;
+            authorityVersion: number;
+            enforcement: {
+                requestId: string;
+                address: {
+                    kind: "default";
+                    appId: string;
+                } | {
+                    kind: "installation";
+                    installationId: string;
+                };
+                authorityVersion: number;
+                state: "unaffected" | "pending" | "applied" | "expired";
+                outstanding: number;
+            } | null;
+            handlers: "file.open"[];
+            roles: string[];
+            declaredCapabilities: string[];
+            commands: Readonly<{
+                id: string;
+                title: string;
+                category: string;
+                description?: string | undefined;
+                sigil?: string | undefined;
+                projections?: Readonly<{
+                    bindings?: (Readonly<{
+                        order?: number | undefined;
+                    }> & Readonly<{
+                        values: readonly string[];
+                    }>) | undefined;
+                    agent?: (Readonly<{
+                        order?: number | undefined;
+                    }> & Readonly<{
+                        keybind?: string | undefined;
+                    }>) | undefined;
+                    help?: Readonly<{
+                        order?: number | undefined;
+                    }> | undefined;
+                    menu?: Readonly<{
+                        order?: number | undefined;
+                    }> | undefined;
+                    palette?: Readonly<{
+                        order?: number | undefined;
+                    }> | undefined;
+                    slash?: (Readonly<{
+                        order?: number | undefined;
+                    }> & Readonly<{
+                        aliases: readonly string[];
+                    }>) | undefined;
+                }> | undefined;
+            }>[];
+            gills: import("@fungi.computer/oyster/shell/app-directory").AppDirectoryGill[];
+            availability: "available" | "unavailable";
+            surface: {
+                stableRoute: string;
+            } | null;
+            surfacePath: string;
+            displayName?: string | undefined;
+            icon?: string | null | undefined;
+            calls?: readonly {
+                readonly appId: string;
+                readonly methods: readonly string[];
+            }[] | undefined;
+            computer?: {
+                computerId: string;
+                name: string;
+            } | undefined;
+            computerPermission?: {
+                kind: "selected-computers";
+                computers: {
+                    computerId: string;
+                    operations: ("computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute")[];
+                }[];
+            } | {
+                kind: "all-team-computers";
+                operations: ("computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute")[];
+            } | null | undefined;
+        }[];
+        roles: Record<string, {
+            surfaceId: string | null;
+            chosen: boolean;
+        }>;
+        computer?: {
+            computerId: string;
+            name: string;
+        } | undefined;
+        needsUpdate?: {
+            installationId: string | null;
+            appId: string | null;
+            displayName: string;
+        }[] | undefined;
+    }, Error>;
+    apps: {
+        address: {
+            kind: "default";
+            appId: string;
+        } | {
+            kind: "installation";
+            installationId: string;
+        };
+        installationId: string | null;
+        surfaceId: string;
+        appId: string;
+        releaseId: string | null;
+        authorityVersion: number;
+        enforcement: {
+            requestId: string;
+            address: {
+                kind: "default";
+                appId: string;
+            } | {
+                kind: "installation";
+                installationId: string;
+            };
+            authorityVersion: number;
+            state: "unaffected" | "pending" | "applied" | "expired";
+            outstanding: number;
+        } | null;
+        handlers: "file.open"[];
+        roles: string[];
+        declaredCapabilities: string[];
+        commands: Readonly<{
+            id: string;
+            title: string;
+            category: string;
+            description?: string | undefined;
+            sigil?: string | undefined;
+            projections?: Readonly<{
+                bindings?: (Readonly<{
+                    order?: number | undefined;
+                }> & Readonly<{
+                    values: readonly string[];
+                }>) | undefined;
+                agent?: (Readonly<{
+                    order?: number | undefined;
+                }> & Readonly<{
+                    keybind?: string | undefined;
+                }>) | undefined;
+                help?: Readonly<{
+                    order?: number | undefined;
+                }> | undefined;
+                menu?: Readonly<{
+                    order?: number | undefined;
+                }> | undefined;
+                palette?: Readonly<{
+                    order?: number | undefined;
+                }> | undefined;
+                slash?: (Readonly<{
+                    order?: number | undefined;
+                }> & Readonly<{
+                    aliases: readonly string[];
+                }>) | undefined;
+            }> | undefined;
+        }>[];
+        gills: import("@fungi.computer/oyster/shell/app-directory").AppDirectoryGill[];
+        availability: "available" | "unavailable";
+        surface: {
+            stableRoute: string;
+        } | null;
+        surfacePath: string;
+        displayName?: string | undefined;
+        icon?: string | null | undefined;
+        calls?: readonly {
+            readonly appId: string;
+            readonly methods: readonly string[];
+        }[] | undefined;
+        computer?: {
+            computerId: string;
+            name: string;
+        } | undefined;
+        computerPermission?: {
+            kind: "selected-computers";
+            computers: {
+                computerId: string;
+                operations: ("computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute")[];
+            }[];
+        } | {
+            kind: "all-team-computers";
+            operations: ("computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute")[];
+        } | null | undefined;
+    }[] | undefined;
+    needsUpdate: {
+        installationId: string | null;
+        appId: string | null;
+        displayName: string;
+    }[];
+    roles: Record<string, {
+        surfaceId: string | null;
+        chosen: boolean;
+    }>;
+};

package/dist/app-directory.js

@@ -0,0 +1,21 @@
+import { tourtoisQueryKeys } from "./queries.js";
+import { useQuery } from "@tanstack/react-query";
+import { workbenchDirectorySchema, } from "@fungi.computer/oyster/shell/workbench-directory";
+const noRoles = {};
+/** Shell composition keeps an unread directory distinct from an empty one. */
+export function useAppDirectory(teamId, directoryReader) {
+    const query = useQuery({
+        queryKey: tourtoisQueryKeys.appDirectory(teamId),
+        queryFn: async () => workbenchDirectorySchema.parse(await directoryReader()),
+        retry: false,
+        // The host's selection read can finish before Tourtois mounts. Keep the
+        // result fresh for that handoff; explicit mutations still invalidate it.
+        staleTime: 5_000,
+    });
+    return {
+        query,
+        apps: query.data?.apps,
+        needsUpdate: query.data?.needsUpdate ?? [],
+        roles: query.data?.roles ?? noRoles,
+    };
+}

package/dist/app-icon.d.ts

@@ -0,0 +1,9 @@
+/** The App's role Sigil, then its declared icon when the role has no mark. */
+export declare function AppIcon({ roles, icon, }: {
+    roles: readonly string[];
+    icon?: string | null | undefined;
+}): React.JSX.Element;
+/** An App keeps its declared mark, or a neutral placeholder. */
+export declare function DeclaredAppIcon({ icon, }: {
+    icon?: string | null | undefined;
+}): React.JSX.Element;

package/dist/app-icon.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Monogram } from "@fungi.computer/caps/components/monogram";
+import { isSigilName, Sigil } from "@fungi.computer/sigils";
+/**
+ * Shell marks follow a declared role when one is known; roleless Apps use their
+ * own declared Sigil name.
+ */
+const roleSigils = new Map([
+    ["sessions", "chat"],
+    ["inbox", "chat"],
+    ["files", "inkcap"],
+    ["media", "prints"],
+    ["terminal", "computer"],
+]);
+/** The App's role Sigil, then its declared icon when the role has no mark. */
+export function AppIcon({ roles, icon, }) {
+    const sigil = roles
+        .map((role) => roleSigils.get(role))
+        .find((name) => name !== undefined);
+    if (sigil)
+        return _jsx(Sigil, { name: sigil });
+    return _jsx(DeclaredAppIcon, { icon: icon });
+}
+/** An App keeps its declared mark, or a neutral placeholder. */
+export function DeclaredAppIcon({ icon, }) {
+    return icon && isSigilName(icon) ? (_jsx(Sigil, { name: icon })) : (_jsx(Monogram, { name: "?", subject: "app" }));
+}

package/dist/app-launch.d.ts

@@ -0,0 +1,53 @@
+import type { AppOpenInput } from "@fungi.computer/agar/apps";
+import type { WhistleSnapshot } from "@fungi.computer/whistle";
+import { type TourtoisAppSurfaceHost } from "./app-surface.js";
+import { createAppWindowManager, type AppLaunchDescriptor, type AppWindowManager, type AppWindowProjection } from "./app-windows.js";
+import type { WorkbenchDirectory } from "@fungi.computer/oyster/shell/workbench-directory";
+export type AppDirectoryApp = WorkbenchDirectory["apps"][number];
+export type AppDirectoryRoles = WorkbenchDirectory["roles"];
+/** The Team's effective App for a role when it can be launched now. */
+export declare function appForRole(apps: readonly AppDirectoryApp[], roles: AppDirectoryRoles, role: string): AppDirectoryApp | undefined;
+/** Project a role intent through the Team's current default, including forks. */
+export declare function launchForRoleIntent(apps: readonly AppDirectoryApp[], roles: AppDirectoryRoles, input: AppOpenInput, requestId: string, launchFor: (app: AppDirectoryApp) => AppLaunchDescriptor | null): AppLaunchDescriptor;
+export declare const composeOpenRequests: Readonly<{
+    readonly request: import("@fungi.computer/cairn/id").IdCodec<"tourtois-compose-open-request", "request", 1>;
+}>;
+export type ComputerOption = Readonly<{
+    computerId: string;
+    name: string;
+}>;
+/** Build the owner-issued launch descriptor for one currently available surface. */
+export declare function createAppLaunchDescriptor(installation: AppDirectoryApp, homeComputerId: string | null, origin: string, computers: readonly ComputerOption[], computersUnavailable?: boolean): AppLaunchDescriptor | null;
+/**
+ * Attach one window to the Computer the person chose in its status bar,
+ * from the window's offered list. Only that window changes; a stale or
+ * unoffered choice changes nothing.
+ * Resolves `false` when the window already uses that Computer.
+ */
+export declare function attachWindowComputer(appWindows: Pick<AppWindowManager, "read" | "update">, windowId: string, computerId: string): Promise<boolean>;
+/** Whether two launches offer the same Computers, in the same order. */
+export declare function sameOfferedComputers(left: AppLaunchDescriptor, right: AppLaunchDescriptor): boolean;
+export declare function launchComputerId(href: string): string | null;
+/** Keep the admitted App identity and point its existing surface at one Computer. */
+export declare function launchForComputer(launch: AppLaunchDescriptor, computerId: string): AppLaunchDescriptor;
+/** Find the user's already-open editor by its admitted open-file command. */
+export declare function findOpenFileEditor<Window extends Pick<AppWindowProjection, "launch">>(windows: readonly Window[], snapshot: WhistleSnapshot): Window | undefined;
+/**
+ * Select the Team's Files App for file navigation before it is mounted, or
+ * any App that declares it opens files when no Files App handles them.
+ */
+export declare function findFileNavigationApp(apps: readonly AppDirectoryApp[], roles: AppDirectoryRoles): AppDirectoryApp | undefined;
+export declare function resolveFileEditorWindow(options: {
+    apps: readonly AppDirectoryApp[];
+    roles: AppDirectoryRoles;
+    appWindows: ReturnType<typeof createAppWindowManager>;
+    appSurfaceHost: TourtoisAppSurfaceHost;
+    computerId: string;
+    computers: readonly ComputerOption[];
+    origin: string;
+    onPermissionNeeded: (app: AppDirectoryApp) => void;
+}): Promise<Readonly<{
+    launch: AppLaunchDescriptor;
+    opened: boolean;
+}>>;
+export declare function requireHandledNavigation(outcome: Awaited<ReturnType<TourtoisAppSurfaceHost["execute"]>>): void;

package/dist/app-launch.js

@@ -0,0 +1,204 @@
+import { defineIdFamily } from "@fungi.computer/cairn/id";
+import {} from "./app-surface.js";
+import { AppError } from "@fungi.computer/agar";
+import { createAppWindowManager, } from "./app-windows.js";
+/** The Team's effective App for a role when it can be launched now. */
+export function appForRole(apps, roles, role) {
+    const surfaceId = roles[role]?.surfaceId;
+    return surfaceId == null
+        ? undefined
+        : apps.find((app) => app.surfaceId === surfaceId &&
+            app.availability === "available" &&
+            app.releaseId !== null &&
+            app.surface !== null);
+}
+/** Project a role intent through the Team's current default, including forks. */
+export function launchForRoleIntent(apps, roles, input, requestId, launchFor) {
+    const recipient = "appId" in input
+        ? apps.find((app) => app.appId === input.appId &&
+            app.availability === "available" &&
+            app.releaseId !== null &&
+            app.surface !== null)
+        : appForRole(apps, roles, input.role);
+    if (!recipient)
+        throw new Error("The requested App is not available in this Team.");
+    const launch = launchFor(recipient);
+    if (!launch)
+        throw new Error("The chosen App is unavailable.");
+    return {
+        ...launch,
+        openRequest: { ...input.intent, requestId },
+    };
+}
+export const composeOpenRequests = defineIdFamily({
+    family: "tourtois-compose-open-request",
+    version: 1,
+    kinds: { request: { prefix: "request" } },
+});
+/** Build the owner-issued launch descriptor for one currently available surface. */
+export function createAppLaunchDescriptor(installation, homeComputerId, origin, computers, computersUnavailable = false) {
+    if (installation.availability !== "available" ||
+        installation.surface === null ||
+        installation.releaseId === null)
+        return null;
+    const href = new URL(installation.surfacePath, origin);
+    href.searchParams.set("teamHasComputers", computersUnavailable ? "unknown" : String(computers.length > 0));
+    const allowedComputers = computersForApp(installation, computers);
+    const attachesToComputer = installation.computer !== undefined ||
+        installation.declaredCapabilities.some((capability) => capability.startsWith("computer."));
+    const selectedComputer = allowedComputers.find((computer) => computer.computerId === homeComputerId) ?? allowedComputers[0];
+    if (selectedComputer)
+        href.searchParams.set("computerId", selectedComputer.computerId);
+    href.searchParams.set("authorityVersion", String(installation.authorityVersion));
+    href.searchParams.set("releaseId", installation.releaseId);
+    href.searchParams.set("surfaceRoute", installation.surface.stableRoute);
+    return {
+        windowId: "app:" + installation.surfaceId,
+        surfaceId: installation.surfaceId,
+        installationId: installation.installationId,
+        appId: installation.appId,
+        releaseId: installation.releaseId,
+        title: installation.displayName ?? "App",
+        href: href.pathname + href.search,
+        openRequest: null,
+        roles: installation.roles,
+        commands: installation.commands,
+        ...(attachesToComputer &&
+            !computersUnavailable && {
+            computers: allowedComputers.map(({ computerId, name }) => ({
+                computerId,
+                name,
+            })),
+        }),
+    };
+}
+/**
+ * Attach one window to the Computer the person chose in its status bar,
+ * from the window's offered list. Only that window changes; a stale or
+ * unoffered choice changes nothing.
+ * Resolves `false` when the window already uses that Computer.
+ */
+export async function attachWindowComputer(appWindows, windowId, computerId) {
+    const open = appWindows
+        .read()
+        .windows.find((item) => item.windowId === windowId);
+    if (!open?.launch.computers?.some((computer) => computer.computerId === computerId))
+        throw new AppError("That Computer is not offered to this App", {
+            code: "CAPABILITY_DENIED",
+            retryable: false,
+        });
+    if (launchComputerId(open.launch.href) === computerId)
+        return false;
+    // Derive from the launch committed when the window's queue reaches this
+    // change, so a concurrent offer refresh is neither lost nor reverted.
+    await appWindows.update(windowId, (latest) => {
+        if (!latest.computers?.some((computer) => computer.computerId === computerId))
+            throw new AppError("That Computer is no longer offered to this App", {
+                code: "CAPABILITY_DENIED",
+                retryable: false,
+            });
+        return launchForComputer(latest, computerId);
+    });
+    return true;
+}
+/** Whether two launches offer the same Computers, in the same order. */
+export function sameOfferedComputers(left, right) {
+    if (left.computers === undefined || right.computers === undefined)
+        return left.computers === right.computers;
+    const next = right.computers;
+    return (left.computers.length === next.length &&
+        left.computers.every((computer, index) => {
+            const other = next.at(index);
+            return (computer.computerId === other?.computerId &&
+                computer.name === other.name);
+        }));
+}
+function computersForApp(app, computers) {
+    // A standalone host supplies its fixed context, not fabricated Team grants.
+    // Only an offered inventory entry can become a window's Computer choice.
+    if (app.computer !== undefined)
+        return computers.filter((computer) => computer.computerId === app.computer?.computerId);
+    const permission = app.computerPermission;
+    if (!permission)
+        return [];
+    if (permission.kind === "all-team-computers" &&
+        permission.operations.length > 0)
+        return computers;
+    if (permission.kind !== "selected-computers")
+        return [];
+    const allowedIds = new Set(permission.computers
+        .filter((computer) => computer.operations.length > 0)
+        .map((computer) => computer.computerId));
+    return computers.filter((computer) => allowedIds.has(computer.computerId));
+}
+export function launchComputerId(href) {
+    return new URL(href, "https://tourtois.invalid").searchParams.get("computerId");
+}
+/** Keep the admitted App identity and point its existing surface at one Computer. */
+export function launchForComputer(launch, computerId) {
+    const href = new URL(launch.href, "https://tourtois.invalid");
+    href.searchParams.set("computerId", computerId);
+    return {
+        ...launch,
+        href: href.pathname + href.search,
+    };
+}
+/** Find the user's already-open editor by its admitted open-file command. */
+export function findOpenFileEditor(windows, snapshot) {
+    return windows.find((window) => snapshot.menu.some((command) => command.commandId === `${window.launch.surfaceId}:open-file`));
+}
+/**
+ * Select the Team's Files App for file navigation before it is mounted, or
+ * any App that declares it opens files when no Files App handles them.
+ */
+export function findFileNavigationApp(apps, roles) {
+    const files = appForRole(apps, roles, "files");
+    if (files?.handlers.includes("file.open"))
+        return files;
+    return apps.find((app) => app.availability === "available" &&
+        app.releaseId !== null &&
+        app.surface !== null &&
+        app.handlers.includes("file.open"));
+}
+export async function resolveFileEditorWindow(options) {
+    const existing = findOpenFileEditor(options.appWindows.read().windows, options.appSurfaceHost.snapshot());
+    const installation = existing
+        ? options.apps.find((app) => app.surfaceId === existing.launch.surfaceId)
+        : findFileNavigationApp(options.apps, options.roles);
+    if (!installation)
+        throw new Error("No file editor is available for this Team.");
+    if (!computersForApp(installation, options.computers).some((computer) => computer.computerId === options.computerId)) {
+        options.onPermissionNeeded(installation);
+        throw new Error("The file editor needs permission to use this Computer.");
+    }
+    if (existing)
+        return { launch: existing.launch, opened: false };
+    const candidate = createAppLaunchDescriptor(installation, options.computerId, options.origin, options.computers);
+    if (!candidate)
+        throw new Error("No file editor is available for this Team.");
+    await options.appWindows.open(candidate);
+    const mounted = options.appWindows
+        .read()
+        .windows.find((window) => window.windowId === candidate.windowId);
+    const editor = mounted
+        ? findOpenFileEditor([mounted], options.appSurfaceHost.snapshot())
+        : undefined;
+    if (editor)
+        return { launch: editor.launch, opened: true };
+    await options.appWindows.close(candidate.windowId).catch((cause) => {
+        console.error("App workbench operation failed", cause);
+        return undefined;
+    });
+    throw new Error("The configured file editor is unavailable.");
+}
+export function requireHandledNavigation(outcome) {
+    if (outcome.status === "handled")
+        return;
+    if (outcome.status === "failed")
+        throw new Error(outcome.error.message);
+    if (outcome.status === "unavailable")
+        throw new Error(outcome.reason);
+    if (outcome.status === "closed")
+        throw new Error("The editor has closed.");
+    throw new Error("The editor's open-file command is unavailable.");
+}

package/dist/app-menus.d.ts

@@ -0,0 +1,6 @@
+import type { AppSurfaceCommandHost } from "@fungi.computer/oyster/shell/command-host";
+/** Render the focused App's Whistle commands in the desktop's system bar. */
+export declare function AppMenus({ host, container: popover, }: Readonly<{
+    host: Pick<AppSurfaceCommandHost, "subscribe" | "menu" | "execute"> | null;
+    container: HTMLElement | null;
+}>): React.JSX.Element | null;