@fungi.computer/tourtois 0.0.0-stage → 0.1.0

package/dist/shell.d.ts

@@ -0,0 +1,6 @@
+import type { MountShell } from "@fungi.computer/oyster/shell/shell-module";
+/**
+ * Tourtois's shell module contract: render Tourtois as the host's trusted
+ * shell in this top-level document.
+ */
+export declare const mountShell: MountShell;

package/dist/shell.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { tourtoisQueryKeys } from "./queries.js";
+import { useEffect } from "react";
+import { createRoot } from "react-dom/client";
+import { createQueryClient } from "@fungi.computer/agar/query";
+import { DropdownMenuItem } from "@fungi.computer/caps/components/dropdown-menu";
+import { tourtoisLaunchers } from "./desktop/own-launchers.js";
+import { Sigil } from "@fungi.computer/sigils";
+import { QueryClientProvider, useQuery, useQueryClient, } from "@tanstack/react-query";
+import { TeamTourtois } from "./TeamDesktop.js";
+import { AppSurfaceHostProvider } from "./app-surface.js";
+import { accountAvatarQuery, MemberAvatarSource } from "./member-avatar.js";
+import { createTourtoisShell } from "./shell-host.js";
+function CanonicalStatus({ message }) {
+    return (_jsx("main", { className: "tourtois-shell tourtois-team-desktop", "data-tourtois-shell": true, children: _jsx("p", { className: "tourtois-directory-status", role: "status", children: message }) }));
+}
+/** Tourtois's own settings page for the Team's role defaults. */
+const settingsLaunchers = tourtoisLaunchers.map((launcher) => ({
+    ...launcher,
+    icon: _jsx(Sigil, { name: launcher.icon }),
+}));
+/** Read the host's Team and offered destinations before mounting the desktop. */
+function MountedTourtois({ shell, }) {
+    const directory = useQuery({
+        queryKey: tourtoisQueryKeys.workbench(),
+        staleTime: Infinity,
+        gcTime: 0,
+        queryFn: async ({ signal }) => {
+            const workbench = createTourtoisShell(shell.workbench);
+            const [team, destinations, sections] = await Promise.all([
+                workbench.team(),
+                workbench.platformDestinations(),
+                workbench.settingsSections(),
+            ]);
+            signal.throwIfAborted();
+            return {
+                team,
+                destinations,
+                sections,
+                workbench,
+            };
+        },
+    });
+    const connection = directory.data;
+    const client = useQueryClient();
+    const platform = connection?.workbench.platform;
+    // Avatar edits happen in host-rendered Settings; re-read the saved avatar.
+    useEffect(() => platform?.subscribeChanges(() => {
+        void client.invalidateQueries({ queryKey: accountAvatarQuery });
+    }), [client, platform]);
+    if (directory.isError)
+        return _jsx(CanonicalStatus, { message: "This Team dashboard is unavailable." });
+    if (!connection)
+        return _jsx(CanonicalStatus, { message: "Connecting\u2026" });
+    return (_jsx(AppSurfaceHostProvider, { value: connection.workbench.host, children: _jsx(MemberAvatarSource, { read: () => connection.workbench.memberAvatar(), children: _jsx(TeamTourtois, { teamId: connection.team.teamId, teamName: connection.team.name, computersReader: (signal) => connection.workbench
+                    .computers({ limit: 100, offset: 0 })
+                    .then((page) => {
+                    if (signal.aborted)
+                        throw new DOMException("", "AbortError");
+                    return page.computers;
+                }), directoryReader: () => connection.workbench.directory(), takeAppOpenRequest: () => connection.workbench.takeAppOpenRequest(), platform: connection.workbench.platform, desktopStorage: shell.storage, desktopMethods: shell.methods, gills: connection.workbench, settingsLaunchers: settingsLaunchers.filter((launcher) => connection.sections === null ||
+                    connection.sections.includes(launcher.location.category)), systemMenuItems: connection.destinations.map(({ id, label }) => (_jsx(DropdownMenuItem, { onSelect: () => {
+                        void connection.workbench
+                            .openPlatformDestination(id)
+                            .catch((cause) => {
+                            console.error("Tourtois host operation failed", cause);
+                            return undefined;
+                        });
+                    }, children: label }, id))) }, connection.team.teamId) }) }));
+}
+/**
+ * Tourtois's shell module contract: render Tourtois as the host's trusted
+ * shell in this top-level document.
+ */
+export const mountShell = (root, shell) => {
+    const queryClient = createQueryClient();
+    const reactRoot = createRoot(root);
+    reactRoot.render(_jsx(QueryClientProvider, { client: queryClient, children: _jsx(MountedTourtois, { shell: shell }) }));
+    return Promise.resolve(() => {
+        reactRoot.unmount();
+        queryClient.clear();
+    });
+};

package/dist/spa.css

@@ -0,0 +1,11 @@
+html,
+body,
+#tourtois-root {
+  height: 100%;
+  margin: 0;
+}
+
+#tourtois-root {
+  background: var(--color-base-100);
+  overflow: hidden;
+}

package/dist/status-bar.d.ts

@@ -0,0 +1,9 @@
+import type { AppStatusAction, AppStatusItem as AppStatusItemData } from "@fungi.computer/agar";
+/** One App-declared status item, drawn by the shell as a flat status chip. */
+export declare function WindowStatusItem({ item, container, onAction, anchorFor, }: {
+    item: AppStatusItemData;
+    container: HTMLElement | null;
+    onAction: (action: AppStatusAction) => void;
+    /** Where a chip sits along the App's surface, for UI the App opens. */
+    anchorFor: (key: HTMLElement) => AppStatusAction["anchor"];
+}): import("react/jsx-runtime").JSX.Element;

package/dist/status-bar.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { AppStatusItem } from "@fungi.computer/caps/blocks/app-status-bar";
+import { Button, } from "@fungi.computer/caps/components/button";
+import { CountBadge } from "@fungi.computer/caps/components/count-badge";
+import { Status } from "@fungi.computer/caps/components/status";
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger, } from "@fungi.computer/caps/components/dropdown-menu";
+import { Activity, Check, Folder, Plug, ShieldCheck } from "lucide-react";
+const statusIcons = {
+    folder: _jsx(Folder, { "aria-hidden": "true" }),
+    ports: _jsx(Plug, { "aria-hidden": "true" }),
+    processes: _jsx(Activity, { "aria-hidden": "true" }),
+    access: _jsx(ShieldCheck, { "aria-hidden": "true" }),
+};
+/**
+ * The one control every App status action draws with: a flat chip beside
+ * the Computer picker, never a raised key. Caps' status-bar chip replaces
+ * this composition when it ships.
+ */
+const StatusBarButton = forwardRef(function StatusBarButton({ label, icon, count, pressed, expanded, ...props }, ref) {
+    return (_jsxs(Button, { ...props, ref: ref, variant: "ghost", size: "xs", className: "caps-status-bar-picker tourtois-status-chip", ...(pressed === undefined ? {} : { "aria-pressed": pressed }), ...(expanded === undefined ? {} : { "aria-expanded": expanded }), children: [icon, _jsx("span", { className: "caps-status-bar-picker-label tourtois-status-chip-label", children: label }), count] }));
+});
+/** One App-declared status item, drawn by the shell as a flat status chip. */
+export function WindowStatusItem({ item, container, onAction, anchorFor, }) {
+    const count = (item.kind === "button" || item.kind === "menu") &&
+        item.count !== undefined &&
+        item.count > 0 ? (_jsx(CountBadge, { count: item.count })) : null;
+    switch (item.kind) {
+        case "text":
+            return item.tone === undefined ? (_jsx(AppStatusItem, { role: "status", children: item.text })) : (_jsx(Status, { size: "compact", tone: item.tone, label: item.text }));
+        case "button":
+            return (_jsx(StatusBarButton, { label: item.text, icon: item.icon === undefined ? undefined : statusIcons[item.icon], count: count, title: item.title ?? item.text, disabled: item.disabled, "aria-haspopup": item.opens, ...(item.expanded === undefined ? {} : { expanded: item.expanded }), onClick: (event) => {
+                    const anchor = anchorFor(event.currentTarget);
+                    onAction(anchor === undefined
+                        ? { itemId: item.id }
+                        : { itemId: item.id, anchor });
+                } }));
+        case "toggle":
+            return (_jsx(StatusBarButton, { label: item.text, pressed: item.pressed, onClick: () => {
+                    onAction({ itemId: item.id });
+                } }));
+        case "menu":
+            // An App's menu is a plain chip: only the host's picker wears the
+            // up-down mark, so an App can't pass a menu off as the Computer.
+            return (_jsxs(DropdownMenu, { modal: false, children: [_jsx(DropdownMenuTrigger, { render: _jsx(StatusBarButton, { label: item.text, count: count, title: item.title }) }), _jsx(DropdownMenuContent, { container: container, align: "start", children: item.options.map((option) => (_jsxs(DropdownMenuItem, { disabled: option.disabled, ...(option.checked === undefined
+                                ? {}
+                                : { role: "menuitemradio", "aria-checked": option.checked }), onSelect: () => {
+                                onAction({ itemId: item.id, optionId: option.id });
+                            }, children: [_jsx("span", { className: "flex-1", children: option.text }), option.checked === true ? (_jsx(Check, { "aria-hidden": "true", size: 16 })) : null] }, option.id))) })] }));
+    }
+}

package/dist/team-directory.d.ts

@@ -0,0 +1,3 @@
+export declare const requestIds: Readonly<{
+    readonly request: import("@fungi.computer/cairn/id").IdCodec<"tourtois-browser-request", "request", 1>;
+}>;

package/dist/team-directory.js

@@ -0,0 +1,6 @@
+import { defineIdFamily } from "@fungi.computer/cairn/id";
+export const requestIds = defineIdFamily({
+    family: "tourtois-browser-request",
+    version: 1,
+    kinds: { request: { prefix: "request" } },
+});

package/dist/use-window-motion.d.ts

@@ -0,0 +1,3 @@
+import type { MaosaicoItemBinding } from "@fungi.computer/maosaico";
+/** Animate layout changes, but track pointer gestures and reduced motion directly. */
+export declare function useWindowMotion(binding: MaosaicoItemBinding, interacting: boolean): import("react").RefObject<HTMLElement>;

package/dist/use-window-motion.js

@@ -0,0 +1,37 @@
+import { animate } from "animejs";
+import { useEffect, useLayoutEffect, useRef, useState } from "react";
+/** Animate layout changes, but track pointer gestures and reduced motion directly. */
+export function useWindowMotion(binding, interacting) {
+    const element = useRef(null);
+    const placed = useRef(false);
+    const [reduced, setReduced] = useState(true);
+    useEffect(() => {
+        const media = window.matchMedia("(prefers-reduced-motion: reduce)");
+        const update = () => {
+            setReduced(media.matches);
+        };
+        update();
+        media.addEventListener("change", update);
+        return () => {
+            media.removeEventListener("change", update);
+        };
+    }, []);
+    const { x, y, width, height } = binding.frame;
+    useLayoutEffect(() => {
+        if (!element.current || !binding.visible)
+            return;
+        const motion = animate(element.current, {
+            x,
+            y,
+            width,
+            height,
+            duration: !placed.current || interacting || reduced ? 0 : 200,
+            ease: "outQuad",
+        });
+        placed.current = true;
+        return () => {
+            motion.cancel();
+        };
+    }, [x, y, width, height, binding.visible, interacting, reduced]);
+    return element;
+}

package/dist/useAppOpenUrlHandoff.d.ts

@@ -0,0 +1,11 @@
+import type { AppOpenInput } from "@fungi.computer/agar/apps";
+import type { TourtoisAppSurfaceHost } from "./app-surface.js";
+/** Consume the host or browser address once, after the App directory is ready. */
+export declare function useAppOpenUrlHandoff({ teamId, host, ready, takeAppOpenRequest, onOpen, setError, }: {
+    teamId: string;
+    host: TourtoisAppSurfaceHost | null;
+    ready: boolean;
+    takeAppOpenRequest: (() => Promise<AppOpenInput | null>) | undefined;
+    onOpen: (input: AppOpenInput) => Promise<void>;
+    setError: (error: Error) => void;
+}): void;

package/dist/useAppOpenUrlHandoff.js

@@ -0,0 +1,62 @@
+import { useEffect, useRef } from "react";
+import { appOpenInputFromUrl, cleanInvalidAppOpenUrlSearch, withoutAppOpenUrlSearch, } from "./app-open-url.js";
+/** Consume the host or browser address once, after the App directory is ready. */
+export function useAppOpenUrlHandoff({ teamId, host, ready, takeAppOpenRequest, onOpen, setError, }) {
+    const handledAppOpenUrl = useRef(null);
+    const handlers = useRef({ onOpen, setError });
+    handlers.current = { onOpen, setError };
+    const takeAppOpenRequestRef = useRef(takeAppOpenRequest);
+    useEffect(() => {
+        const take = takeAppOpenRequestRef.current;
+        if (!take || !host || !ready)
+            return;
+        // An isolated dashboard's own address never carries the handoff; its host
+        // hands over the one from the visitor's address, exactly once.
+        takeAppOpenRequestRef.current = undefined;
+        void (async () => {
+            try {
+                const input = await take();
+                if (input)
+                    await handlers.current.onOpen(input);
+            }
+            catch (error) {
+                const { setError } = handlers.current;
+                setError(error instanceof Error
+                    ? error
+                    : new Error("This App could not open.", { cause: error }));
+            }
+        })();
+    }, [host, ready]);
+    useEffect(() => {
+        if (takeAppOpenRequest)
+            return;
+        const current = window.location.search;
+        const cleaned = cleanInvalidAppOpenUrlSearch(current);
+        if (cleaned !== current) {
+            const destination = new URL(window.location.href);
+            destination.search = cleaned;
+            window.history.replaceState(window.history.state, "", destination);
+            return;
+        }
+        if (!host || !ready || !current)
+            return;
+        const input = appOpenInputFromUrl(current);
+        if (!input || handledAppOpenUrl.current === current)
+            return;
+        handledAppOpenUrl.current = current;
+        const destination = new URL(window.location.href);
+        destination.search = withoutAppOpenUrlSearch(current);
+        window.history.replaceState(window.history.state, "", destination);
+        void (async () => {
+            try {
+                await handlers.current.onOpen(input);
+            }
+            catch (error) {
+                const { setError } = handlers.current;
+                setError(error instanceof Error
+                    ? error
+                    : new Error("This App could not open.", { cause: error }));
+            }
+        })();
+    }, [host, ready, teamId]);
+}

package/dist/useAppWindowManager.d.ts

@@ -0,0 +1,351 @@
+import type { TourtoisAppMountEvents, TourtoisAppSurfaceHost } from "./app-surface.js";
+import { type AppLaunchDescriptor } from "./app-windows.js";
+export type WindowEvents = Required<Pick<TourtoisAppMountEvents, "onNavigation" | "onAppOpen" | "onAppRole">> & {
+    onSelectionChanged: (launch: AppLaunchDescriptor) => Promise<boolean>;
+    /** The App's own document took focus; raise its window. */
+    onAppFocus: (launch: AppLaunchDescriptor) => void;
+};
+/** One mounted host connection owns its windows, including StrictMode teardown. */
+export declare function useAppWindowManager(host: TourtoisAppSurfaceHost | null, teamId: string, events: WindowEvents): Readonly<{
+    open: (launch: Readonly<{
+        windowId: string;
+        surfaceId: string;
+        installationId: string | null;
+        appId: string;
+        releaseId: string;
+        title: string;
+        href: string;
+        openRequest: import("@fungi.computer/agar").AppOpenRequest | null;
+        roles: readonly string[];
+        commands: readonly 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;
+        }>[];
+        computers?: readonly Readonly<{
+            computerId: string;
+            name: string;
+        }>[];
+    }>) => Promise<void>;
+    attach: (windowId: string) => void;
+    minimize: (windowId: string) => Promise<void>;
+    restore: (windowId: string) => Promise<void>;
+    hideAll: () => Promise<void>;
+    restoreHidden: () => Promise<void>;
+    close: (windowId: string) => Promise<void>;
+    reconfigure: (windowId: string, launch: Readonly<{
+        windowId: string;
+        surfaceId: string;
+        installationId: string | null;
+        appId: string;
+        releaseId: string;
+        title: string;
+        href: string;
+        openRequest: import("@fungi.computer/agar").AppOpenRequest | null;
+        roles: readonly string[];
+        commands: readonly 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;
+        }>[];
+        computers?: readonly Readonly<{
+            computerId: string;
+            name: string;
+        }>[];
+    }>) => Promise<void>;
+    update: (windowId: string, derive: (current: Readonly<{
+        windowId: string;
+        surfaceId: string;
+        installationId: string | null;
+        appId: string;
+        releaseId: string;
+        title: string;
+        href: string;
+        openRequest: import("@fungi.computer/agar").AppOpenRequest | null;
+        roles: readonly string[];
+        commands: readonly 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;
+        }>[];
+        computers?: readonly Readonly<{
+            computerId: string;
+            name: string;
+        }>[];
+    }>) => Readonly<{
+        windowId: string;
+        surfaceId: string;
+        installationId: string | null;
+        appId: string;
+        releaseId: string;
+        title: string;
+        href: string;
+        openRequest: import("@fungi.computer/agar").AppOpenRequest | null;
+        roles: readonly string[];
+        commands: readonly 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;
+        }>[];
+        computers?: readonly Readonly<{
+            computerId: string;
+            name: string;
+        }>[];
+    }>) => Promise<void>;
+    replace: (windowId: string, launch: Readonly<{
+        windowId: string;
+        surfaceId: string;
+        installationId: string | null;
+        appId: string;
+        releaseId: string;
+        title: string;
+        href: string;
+        openRequest: import("@fungi.computer/agar").AppOpenRequest | null;
+        roles: readonly string[];
+        commands: readonly 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;
+        }>[];
+        computers?: readonly Readonly<{
+            computerId: string;
+            name: string;
+        }>[];
+    }>) => Promise<void>;
+    back: (windowId: string) => Promise<boolean>;
+    activateNavigation: (windowId: string, activation: import("@fungi.computer/agar").AppNavigationActivation) => Promise<boolean>;
+    activateStatus: (windowId: string, action: import("@fungi.computer/agar").AppStatusAction) => Promise<boolean>;
+    registerComputerChoice: (windowId: string, handler: () => void) => () => void;
+    dispose: () => Promise<void>;
+    read: () => Readonly<{
+        windows: readonly Readonly<{
+            windowId: string;
+            launch: Readonly<{
+                windowId: string;
+                surfaceId: string;
+                installationId: string | null;
+                appId: string;
+                releaseId: string;
+                title: string;
+                href: string;
+                openRequest: import("@fungi.computer/agar").AppOpenRequest | null;
+                roles: readonly string[];
+                commands: readonly 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;
+                }>[];
+                computers?: readonly Readonly<{
+                    computerId: string;
+                    name: string;
+                }>[];
+            }>;
+            container: HTMLElement;
+            status: import("@fungi.computer/oyster/shell/window-manager").WindowStatus;
+            generation: number;
+            error?: unknown;
+            cleanupError?: unknown;
+            navigation: Readonly<{
+                canGoBack: boolean;
+                title?: string;
+                crumbs?: readonly Readonly<{
+                    id: string;
+                    label: string;
+                    siblings?: readonly Readonly<{
+                        id: string;
+                        label: string;
+                    }>[];
+                }>[];
+                primary?: readonly Readonly<{
+                    id: string;
+                    label: string;
+                    variant?: "primary" | "outline" | "ghost";
+                    tone?: "destructive";
+                    disabled?: boolean;
+                }>[];
+                menu?: readonly Readonly<{
+                    id: string;
+                    label: string;
+                    variant?: "primary" | "outline" | "ghost";
+                    tone?: "destructive";
+                    disabled?: boolean;
+                }>[];
+                status?: readonly Readonly<{
+                    id: string;
+                    label: string;
+                    tone?: "neutral" | "info" | "warning" | "success" | "error";
+                }>[];
+            }> | null;
+            statusItems: readonly import("@fungi.computer/agar").AppStatusItem[];
+        }>[];
+    }>;
+    subscribe: (listener: () => void) => () => void;
+}>;