@fungi.computer/tourtois 0.0.0-stage → 0.1.0

package/dist/settings-sections.d.ts

@@ -0,0 +1,74 @@
+import type { ComponentType } from "react";
+import type { AgentMcpServersPort } from "./AgentMcpServers.js";
+import type { KeysPort } from "./Keys.js";
+import type { MemberAvatarReader, MemberAvatarSave } from "./member-avatar.js";
+import { type SettingsLocation } from "./settings-routes.js";
+export type SettingsCategory = SettingsLocation["category"];
+export type Navigate = (location: SettingsLocation | null) => void;
+export type Accepted = () => Promise<void>;
+export type ConnectorsTarget = Extract<SettingsLocation, {
+    category: "connectors";
+}>["target"];
+/** Team administration a host links to from the Settings home. */
+export type TeamAdministrationPort = Readonly<{
+    openMembers: () => void;
+    /** Present only when the signed-in member may close the Team. */
+    close?: Readonly<{
+        available: boolean;
+        open: () => void;
+    }>;
+}>;
+/**
+ * The Settings sections an embedding host implements. Tourtois renders a
+ * section only when its port is present; an absent port is a section this
+ * host does not offer, never a mode flag.
+ */
+export type SettingsSectionPorts = Readonly<{
+    /** The person's avatar, read and saved through the host's account. */
+    avatar?: Readonly<{
+        read: MemberAvatarReader;
+        save: MemberAvatarSave;
+    }>;
+    /** Connectors settings: the host's Agent MCP server custody. */
+    agentMcpServers?: AgentMcpServersPort;
+    /** A host's own Connectors editor, used when it has no Agent MCP port. */
+    connectors?: ComponentType<{
+        target: ConnectorsTarget;
+        onNavigate: Navigate;
+    }>;
+    /** Each Computer's outside access. */
+    computers?: ComponentType;
+    /** Keys settings: the host's owner-direct Keys custody. */
+    keys?: KeysPort;
+    /** The Team's role defaults. */
+    defaults?: ComponentType<{
+        onAccepted: Accepted;
+    }>;
+    /** Channels and website assistants. */
+    channels?: ComponentType;
+    /** Selling Apps; a host offers it only to members who may sell. */
+    selling?: ComponentType<{
+        appId: string | null;
+        onNavigate: Navigate;
+    }>;
+    /** An App's Permissions tab. Without it, Apps show their Desktop tab. */
+    appPermissions?: ComponentType<{
+        selectedKey: string | null;
+        onAccepted: Accepted;
+    }>;
+    /** An App's Advanced tab, kept mounted so its drafts survive tab changes. */
+    appAdvanced?: ComponentType<{
+        selectedKey: string | null;
+        visible: boolean;
+        onNavigate: Navigate;
+        onAccepted: Accepted;
+    }>;
+    team?: TeamAdministrationPort;
+    /** Counts the host already loaded for the Settings home. Null is not zero. */
+    summary?: Readonly<{
+        defaultAppCount: number | null;
+        computerCount: number | null;
+    }>;
+}>;
+/** Categories within the host's ceiling that a port actually backs. */
+export declare function offeredSettings(ceiling: readonly SettingsCategory[] | undefined, ports: SettingsSectionPorts): readonly SettingsCategory[];

package/dist/settings-sections.js

@@ -0,0 +1,17 @@
+import { settingsLocationSchema, } from "./settings-routes.js";
+const categories = settingsLocationSchema.options.map((option) => option.shape.category.value);
+/** Categories within the host's ceiling that a port actually backs. */
+export function offeredSettings(ceiling, ports) {
+    const backed = {
+        home: true,
+        apps: true,
+        avatar: ports.avatar !== undefined,
+        connectors: ports.agentMcpServers !== undefined || ports.connectors !== undefined,
+        computers: ports.computers !== undefined,
+        keys: ports.keys !== undefined,
+        defaults: ports.defaults !== undefined,
+        channels: ports.channels !== undefined,
+        selling: ports.selling !== undefined,
+    };
+    return categories.filter((category) => backed[category] && (ceiling === undefined || ceiling.includes(category)));
+}

package/dist/shell-commands.d.ts

@@ -0,0 +1,15 @@
+import { CommandDialogs, type ShellCommandState } from "./command-dialogs.js";
+import { type ShellActions } from "@fungi.computer/oyster/shell/commands";
+import type { TourtoisAppSurfaceHost } from "./app-surface.js";
+/** The Back hint for this platform, e.g. "Back (Ctrl K, then [)". */
+export declare function backHint(): string;
+/**
+ * Register the shell's commands, dispatch their direct chords from the host
+ * document, and own the which-key and `:` line open state.
+ */
+export declare function useShellCommands(host: TourtoisAppSurfaceHost | null, actions: Omit<ShellActions, "showKeys" | "showCommandLine" | "back"> & Readonly<{
+    back: () => void;
+    showDesktop: () => Promise<void>;
+}>): ShellCommandState;
+/** Draw the shared shell dialogs in Tourtois's dialog layer. */
+export declare function ShellCommandDialogs(props: Omit<Parameters<typeof CommandDialogs>[0], "container" | "renderIcon">): React.JSX.Element;

package/dist/shell-commands.js

@@ -0,0 +1,95 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CommandDialogs } from "./command-dialogs.js";
+import { useLayer } from "@fungi.computer/maosaico";
+import { Sigil, isSigilName } from "@fungi.computer/sigils";
+import { backBinding, shellCommands, } from "@fungi.computer/oyster/shell/commands";
+import { useEffect, useMemo, useRef, useState, useSyncExternalStore, } from "react";
+import { AppIcon } from "./app-icon.js";
+import { installShellKeys } from "@fungi.computer/oyster/shell/keys";
+/** The Back hint for this platform, e.g. "Back (Ctrl K, then [)". */
+export function backHint() {
+    const key = backBinding.slice("<leader> ".length);
+    return `Back (${isMac() ? "⌘K" : "Ctrl K"}, then ${key})`;
+}
+const emptySnapshot = Object.freeze({
+    bindings: Object.freeze([]),
+    palette: Object.freeze([]),
+    slash: Object.freeze([]),
+    help: Object.freeze([]),
+    menu: Object.freeze([]),
+    agent: Object.freeze([]),
+});
+const noSubscription = () => () => undefined;
+const emptyReader = () => emptySnapshot;
+function isMac() {
+    return /Mac|iPhone|iPad/u.test(navigator.userAgent);
+}
+/**
+ * Register the shell's commands, dispatch their direct chords from the host
+ * document, and own the which-key and `:` line open state.
+ */
+export function useShellCommands(host, actions) {
+    const [keysOpen, setKeysOpen] = useState(false);
+    const [commandLineOpen, setCommandLineOpen] = useState(false);
+    const keysOpenRef = useRef(keysOpen);
+    keysOpenRef.current = keysOpen;
+    const active = useSyncExternalStore(host?.subscribe ?? noSubscription, host?.active ?? emptyReader, host?.active ?? emptyReader);
+    // Commands register once per host; each run reads the latest behavior.
+    const latest = useRef(actions);
+    latest.current = actions;
+    const commands = useMemo(() => [
+        ...shellCommands({
+            openApp: () => {
+                setKeysOpen(false);
+                setCommandLineOpen(false);
+                latest.current.openApp();
+            },
+            // The leader twice opens the `:` line, like tmux's prefix-prefix.
+            showKeys: () => {
+                const again = keysOpenRef.current;
+                setKeysOpen(!again);
+                setCommandLineOpen(again);
+            },
+            showCommandLine: () => {
+                setKeysOpen(false);
+                setCommandLineOpen(true);
+            },
+            focusStep: (step) => {
+                latest.current.focusStep(step);
+            },
+            swapStep: (step) => {
+                latest.current.swapStep(step);
+            },
+            toggleZoom: () => {
+                latest.current.toggleZoom();
+            },
+            back: () => {
+                latest.current.back();
+            },
+        }),
+        {
+            id: "desktop.show",
+            title: "Show desktop",
+            category: "Window",
+            description: "Hide visible Apps, or restore the Apps hidden by Show desktop.",
+            projections: {
+                bindings: { values: ["<leader> d"], order: 8 },
+                palette: { order: 18 },
+                help: { order: 8 },
+            },
+            handler: async () => {
+                setKeysOpen(false);
+                setCommandLineOpen(false);
+                await latest.current.showDesktop();
+            },
+        },
+    ], []);
+    useEffect(() => host?.registerShellCommands?.(commands), [host, commands]);
+    useEffect(() => (host ? installShellKeys(document.body, host, isMac()) : undefined), [host]);
+    return { active, keysOpen, setKeysOpen, commandLineOpen, setCommandLineOpen };
+}
+/** Draw the shared shell dialogs in Tourtois's dialog layer. */
+export function ShellCommandDialogs(props) {
+    const container = useLayer("dialog");
+    return (_jsx(CommandDialogs, { ...props, container: container, renderIcon: (roles, sigil) => sigil && isSigilName(sigil) ? (_jsx(Sigil, { name: sigil })) : (_jsx(AppIcon, { roles: roles })) }));
+}

package/dist/shell-host.d.ts

@@ -0,0 +1,52 @@
+import { type TeamWorkbenchHostHandle, type WorkbenchPlatformDestination, type WorkbenchGillRequest, type WorkbenchGillWatch } from "@fungi.computer/oyster/shell/workbench";
+import { type PlatformControls } from "./platform-controls.js";
+import type { GillReply } from "@fungi.computer/gills";
+import type { MemberAvatar } from "@fungi.computer/sprite-zdog/avatar";
+import * as z from "zod";
+import { type AppOpenInput } from "@fungi.computer/agar/apps";
+import type { TourtoisAppSurfaceHost } from "./app-surface.js";
+import { type WorkbenchDirectory } from "@fungi.computer/oyster/shell/workbench-directory";
+declare const teamIdentitySchema: z.ZodObject<{
+    team: z.ZodObject<{
+        teamId: z.ZodString;
+        name: z.ZodString;
+        handle: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TeamIdentity = z.output<typeof teamIdentitySchema>["team"];
+declare const workbenchComputerDirectorySchema: z.ZodObject<{
+    nextOffset: z.ZodNullable<z.ZodNumber>;
+    computers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        computerId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type TeamComputerPage = z.output<typeof workbenchComputerDirectorySchema>;
+/**
+ * The trusted shell's view of its host: Team/Computer/App directory reads,
+ * child-App mounting and host-offered platform destinations. The host
+ * composes Tourtois into its own top-level document, so Tourtois runs with
+ * the host's escalated permissions; each child App stays in its own sandboxed
+ * frame, mounted inside its window.
+ */
+export type TourtoisShell = Readonly<{
+    team(): Promise<TeamIdentity>;
+    computers(input: {
+        limit: number;
+        offset: number;
+    }): Promise<TeamComputerPage>;
+    directory(): Promise<WorkbenchDirectory>;
+    platformDestinations(): Promise<readonly WorkbenchPlatformDestination[]>;
+    settingsSections(): Promise<readonly string[] | null>;
+    openPlatformDestination(id: string): Promise<void>;
+    takeAppOpenRequest(): Promise<AppOpenInput | null>;
+    memberAvatar(): Promise<MemberAvatar | null>;
+    /** Team administration the host renders with the owner's own authority. */
+    platform: PlatformControls;
+    /** Host-admitted Gill requests; the App never receives another App's fetch credentials. */
+    requestGill(input: WorkbenchGillRequest): Promise<GillReply>;
+    watchGillChanges(input: WorkbenchGillRequest, onChanged: () => Promise<void>): Promise<WorkbenchGillWatch>;
+    host: TourtoisAppSurfaceHost;
+}>;
+export declare function createTourtoisShell(workbench: TeamWorkbenchHostHandle): TourtoisShell;
+export {};

package/dist/shell-host.js

@@ -0,0 +1,288 @@
+import { APP_NAVIGATION_TITLE_MAX, parseAppStatusItems, APP_NAVIGATION_CRUMBS_MAX, APP_NAVIGATION_LABEL_MAX, APP_NAVIGATION_MENU_MAX, APP_NAVIGATION_PRIMARY_MAX, APP_NAVIGATION_SIBLINGS_MAX, APP_NAVIGATION_STATUS_MAX, } from "@fungi.computer/agar";
+import { teamComputerDirectorySchema, teamComputerSchema, } from "@fungi.computer/oyster/shell/workbench";
+import { createAppSurfaceCommandHost } from "@fungi.computer/oyster/shell/command-host";
+import * as Schema from "effect/Schema";
+import {} from "./platform-controls.js";
+import { parseMemberAvatar } from "./member-avatar.js";
+import * as z from "zod";
+import { appOpenInputSchema, } from "@fungi.computer/agar/apps";
+import { workbenchDirectorySchema, } from "@fungi.computer/oyster/shell/workbench-directory";
+const teamIdentitySchema = z.strictObject({
+    team: z.strictObject({
+        teamId: z.string().min(1),
+        name: z.string().min(1),
+        handle: z.string().min(1),
+    }),
+});
+const workbenchComputerDirectorySchema = teamComputerDirectorySchema.extend({
+    computers: z.array(teamComputerSchema.pick({ computerId: true, name: true }).strip()),
+});
+const platformDestinationsSchema = z
+    .array(z.strictObject({
+    id: z.string().min(1).max(64),
+    label: z.string().min(1).max(80),
+}))
+    .max(8);
+const relayId = z.string().min(1).max(64);
+const relayLabel = z.string().min(1).max(APP_NAVIGATION_LABEL_MAX);
+const relayCommands = (maximum) => z
+    .array(z.strictObject({
+    id: relayId,
+    label: relayLabel,
+    variant: z.enum(["primary", "outline", "ghost"]).optional(),
+    tone: z.literal("destructive").optional(),
+    disabled: z.boolean().optional(),
+}))
+    .max(maximum);
+const navigationRelaySchema = z
+    .strictObject({
+    canGoBack: z.boolean(),
+    title: z.string().trim().min(1).max(APP_NAVIGATION_TITLE_MAX).optional(),
+    crumbs: z
+        .array(z.strictObject({
+        id: relayId,
+        label: relayLabel,
+        siblings: z
+            .array(z.strictObject({ id: relayId, label: relayLabel }))
+            .max(APP_NAVIGATION_SIBLINGS_MAX)
+            .optional(),
+    }))
+        .max(APP_NAVIGATION_CRUMBS_MAX)
+        .optional(),
+    primary: relayCommands(APP_NAVIGATION_PRIMARY_MAX).optional(),
+    menu: relayCommands(APP_NAVIGATION_MENU_MAX).optional(),
+    status: z
+        .array(z.strictObject({
+        id: relayId,
+        label: relayLabel,
+        tone: z
+            .enum(["neutral", "info", "warning", "success", "error"])
+            .optional(),
+    }))
+        .max(APP_NAVIGATION_STATUS_MAX)
+        .optional(),
+})
+    .nullable();
+/** A child's navigation state as relayed by the host, re-checked here. */
+function parseNavigationRelay(value) {
+    const state = navigationRelaySchema.parse(value);
+    if (state === null)
+        return null;
+    let parsed = { canGoBack: state.canGoBack };
+    if (state.title !== undefined)
+        parsed = { ...parsed, title: state.title };
+    if (state.crumbs !== undefined)
+        parsed = {
+            ...parsed,
+            crumbs: state.crumbs.map((crumb) => {
+                const { siblings, ...rest } = crumb;
+                return siblings === undefined ? rest : { ...rest, siblings };
+            }),
+        };
+    if (state.primary !== undefined)
+        parsed = { ...parsed, primary: state.primary.map(commandOf) };
+    if (state.menu !== undefined)
+        parsed = { ...parsed, menu: state.menu.map(commandOf) };
+    if (state.status !== undefined)
+        parsed = { ...parsed, status: state.status.map(statusOf) };
+    return parsed;
+}
+function commandOf(command) {
+    let copy = { id: command.id, label: command.label };
+    if (command.variant !== undefined)
+        copy = { ...copy, variant: command.variant };
+    if (command.tone !== undefined)
+        copy = { ...copy, tone: command.tone };
+    if (command.disabled !== undefined)
+        copy = { ...copy, disabled: command.disabled };
+    return copy;
+}
+function statusOf(item) {
+    const copy = { id: item.id, label: item.label };
+    return item.tone === undefined ? copy : { ...copy, tone: item.tone };
+}
+function childLaunch(launch) {
+    return {
+        windowId: launch.windowId,
+        appId: launch.appId,
+        releaseId: launch.releaseId,
+        surfaceId: launch.surfaceId,
+        href: launch.href,
+        title: launch.title,
+        openRequest: launch.openRequest,
+    };
+}
+export function createTourtoisShell(workbench) {
+    // One Whistle graph for Tourtois's own shell commands and every mounted
+    // child's Release-validated commands, so the menu bar and Cmd-K follow focus.
+    const commands = createAppSurfaceCommandHost();
+    const mount = async (container, launch, signal, { onAgentSessionSelection, onComputerChoice, onNavigation, onAppOpen, onAppRole, onSelectionChanged, onNavigationState, onStatusItems, onFocus, }) => {
+        const commandMount = commands.mount(launch.surfaceId, launch.commands);
+        let resolveHandle = () => undefined;
+        const handleReady = new Promise((resolve) => {
+            resolveHandle = resolve;
+        });
+        let contribution;
+        const events = {
+            ...(onComputerChoice && { onComputerChoice }),
+            onAgentSessionSelection: (selection) => onAgentSessionSelection(selection),
+            ...(onNavigation && { onNavigation }),
+            ...(onAppOpen && { onAppOpen }),
+            ...(onAppRole && { onAppRole }),
+            ...(onSelectionChanged && { onSelectionChanged }),
+            onCommands: async (presented) => {
+                if (presented.length === 0) {
+                    contribution?.dispose();
+                    contribution = undefined;
+                    return;
+                }
+                if (contribution !== undefined) {
+                    contribution.update(presented);
+                    return;
+                }
+                contribution = await commandMount.handlers.registerCommands({
+                    commands: presented,
+                    invoke: async (commandId, invocation) => (await handleReady).invokeCommand(commandId, invocation.arguments === undefined
+                        ? { origin: invocation.origin }
+                        : {
+                            arguments: invocation.arguments,
+                            origin: invocation.origin,
+                        }),
+                });
+            },
+            onReservedChord: (input) => commandMount.handlers.invokeReservedChord(input),
+            onFocus: (focused) => {
+                if (focused) {
+                    commands.focus(launch.surfaceId);
+                    onFocus?.();
+                }
+                return Promise.resolve();
+            },
+            ...(onNavigationState && {
+                onNavigationState: (state) => 
+                // The host parsed this at the App's edge; parse again at ours.
+                Promise.resolve(state).then((relayed) => {
+                    onNavigationState(parseNavigationRelay(relayed));
+                }),
+            }),
+            ...(onStatusItems && {
+                onStatusItems: (items) => 
+                // The host parsed these at the App's edge; parse again at ours.
+                Promise.resolve(items).then((relayed) => {
+                    onStatusItems(parseAppStatusItems(relayed));
+                }),
+            }),
+        };
+        let handle;
+        try {
+            // The child's frame lives in this window's own slot, so the browser
+            // moves, clips and stacks it with the window.
+            handle = await workbench.mount(container, childLaunch(launch), events);
+        }
+        catch (error) {
+            commandMount.dispose();
+            throw error;
+        }
+        resolveHandle(handle);
+        if (signal.aborted) {
+            commandMount.dispose();
+            await handle.dispose();
+            throw signal.reason;
+        }
+        const close = async () => {
+            signal.removeEventListener("abort", closeFromParent);
+            commandMount.dispose();
+            await handle.dispose();
+        };
+        const closeFromParent = () => {
+            void close().catch((cause) => {
+                console.error("Tourtois shell operation failed", cause);
+                return undefined;
+            });
+        };
+        signal.addEventListener("abort", closeFromParent, { once: true });
+        return {
+            setVisibility: (visibility) => handle.setVisibility(visibility),
+            reconfigure: (nextLaunch) => handle.reconfigure(childLaunch(nextLaunch)),
+            requestClose: () => handle.requestClose(),
+            requestBack: () => handle.requestBack(),
+            activateNavigation: (activation) => handle.activateNavigation(activation),
+            activateStatus: (action) => handle.activateStatus(action),
+            dispose: close,
+        };
+    };
+    const host = Object.freeze({
+        mount,
+        reportAgentSessionSelection: (_teamId, windowId, selection) => workbench.reportAgentSessionSelection(windowId, selection),
+        focus: commands.focus,
+        registerShellCommands: commands.registerShellCommands,
+        registerDirectoryCommands: commands.registerDirectoryCommands,
+        menu: commands.menu,
+        snapshot: commands.snapshot,
+        active: commands.active,
+        execute: commands.execute,
+        subscribe: commands.subscribe,
+    });
+    const changeListeners = new Set();
+    let watching;
+    const platform = {
+        registerDesktopSettings: (handler) => workbench.registerDesktopSettings(handler),
+        openSettings: (location) => {
+            // The host renders Settings itself. Restore our own invoker only after
+            // that host-owned dialog closes.
+            const active = document.activeElement;
+            const invoker = active instanceof HTMLElement &&
+                active.closest('[role="menu"]') === null
+                ? active
+                : document.querySelector(".tourtois-system-menu-trigger");
+            void workbench
+                .openSettings(location)
+                .then(() => {
+                if (invoker?.isConnected)
+                    invoker.focus();
+            })
+                .catch((cause) => {
+                console.error("Tourtois shell operation failed", cause);
+                return undefined;
+            });
+        },
+        subscribeChanges: (listener) => {
+            changeListeners.add(listener);
+            watching ??= workbench
+                .watchSettingsChanges(() => {
+                for (const notify of changeListeners)
+                    notify();
+                return Promise.resolve();
+            })
+                .catch((cause) => {
+                console.error("Tourtois shell operation failed", cause);
+                return undefined;
+            });
+            return () => {
+                changeListeners.delete(listener);
+            };
+        },
+    };
+    return {
+        team: async () => teamIdentitySchema.parse(await workbench.team()).team,
+        computers: async (input) => workbenchComputerDirectorySchema.parse(await workbench.computers(input)),
+        directory: async () => workbenchDirectorySchema.parse(await workbench.directory()),
+        platformDestinations: async () => platformDestinationsSchema.parse(await workbench.platformDestinations()),
+        settingsSections: async () => z
+            .array(z.string())
+            .nullable()
+            .parse(await workbench.settingsSections()),
+        openPlatformDestination: (id) => workbench.openPlatformDestination(id),
+        takeAppOpenRequest: async () => {
+            const request = await workbench.takeAppOpenRequest();
+            return request === null
+                ? null
+                : Schema.decodeUnknownSync(appOpenInputSchema)(request);
+        },
+        memberAvatar: async () => parseMemberAvatar(await workbench.memberAvatar()),
+        platform,
+        requestGill: (input) => workbench.requestGill(input),
+        watchGillChanges: (input, onChanged) => workbench.watchGillChanges(input, onChanged),
+        host,
+    };
+}

package/dist/shell-module.d.ts

@@ -0,0 +1,12 @@
+import type { MountPlatformControls, MountShell } from "@fungi.computer/oyster/shell/shell-module";
+/**
+ * This Release's shell module, emitted as `shell.js` beside `index.html`.
+ * A host imports it from its own origin after first paint; Tourtois's code
+ * and styles then load as one lazy chunk under the module's own URL.
+ */
+export declare const mountShell: MountShell;
+/**
+ * Tourtois's own Settings for a host that has none, such as a standalone
+ * Oyster; they load as their own lazy chunk under this module's URL.
+ */
+export declare const mountPlatformControls: MountPlatformControls;

package/dist/shell-module.js

@@ -0,0 +1,17 @@
+/**
+ * This Release's shell module, emitted as `shell.js` beside `index.html`.
+ * A host imports it from its own origin after first paint; Tourtois's code
+ * and styles then load as one lazy chunk under the module's own URL.
+ */
+export const mountShell = async (root, input) => {
+    const shell = await import("./shell-release.js");
+    return shell.mountShell(root, input);
+};
+/**
+ * Tourtois's own Settings for a host that has none, such as a standalone
+ * Oyster; they load as their own lazy chunk under this module's URL.
+ */
+export const mountPlatformControls = async (root, input) => {
+    const settings = await import("./oyster-platform-controls.js");
+    return settings.mountPlatformControls(root, input);
+};

package/dist/shell-release.d.ts

@@ -0,0 +1,3 @@
+import "@fungi.computer/parakeet/styles.css";
+import "./shell.css";
+export { mountShell } from "./shell.js";

package/dist/shell-release.js

@@ -0,0 +1,4 @@
+// The shell brings its own look: the host page supplies only fonts.
+import "@fungi.computer/parakeet/styles.css";
+import "./shell.css";
+export { mountShell } from "./shell.js";