@iloveagents/foundry-web-shell 0.3.1 → 0.5.0

package/dist/types.d.ts

@@ -0,0 +1,174 @@
+import type { ComponentType, ReactNode } from "react";
+import type { ThemeLayer } from "@iloveagents/foundry-web-ui";
+/**
+ * Per-mount inputs the shell hands the module's history-adapter
+ * factory. Either ``urlMatch`` (resumed chat — the user clicked a
+ * Recents entry) or ``aguiThreadId`` alone (fresh chat — assistant-ui
+ * just minted a UUID) drives the canonical conversation id, depending
+ * on what the module's backend treats as authoritative.
+ */
+export interface ChatConversationFactoryArgs {
+    /**
+     * The conversation id captured from the URL via
+     * :attr:`ChatConversationConfig.pathPattern`. Set when the user
+     * resumed a known chat; ``undefined`` on a fresh thread.
+     */
+    urlMatch?: string;
+    /**
+     * The assistant-ui adapter's stable thread id (a client-minted
+     * UUID, unique per "New Thread" click). Always set. Use this as the
+     * key for a lazy ``create_or_get`` when ``urlMatch`` is missing so
+     * fresh chats also persist.
+     */
+    aguiThreadId: string;
+}
+/**
+ * URL-driven chat persistence wiring. Modules declare this so the
+ * shell can stand up an assistant-ui :type:`ThreadHistoryAdapter` on
+ * every mount of :type:`AGUIRuntimeProvider` — both resumed chats
+ * (matched URL) and fresh chats.
+ *
+ * The shell stays free of feature-specific knowledge: it captures
+ * the URL match (if any) and the assistant-ui-minted thread id, and
+ * hands both to :attr:`buildHistoryAdapter`. The module owns the
+ * actual backend API shape and "fresh chat vs. resume" semantics.
+ */
+export interface ChatConversationConfig {
+    /**
+     * Regex with exactly one capture group that yields the conversation
+     * id from ``window.location.pathname``. Example:
+     * ``/^\/chat\/([^/]+)$/``.
+     */
+    pathPattern: RegExp;
+    /**
+     * Optional hook giving the module's view of "what conversation is
+     * the user currently engaged with" — separate from the URL.
+     *
+     * Why this exists: ChatGPT-style UX wants the chat runtime to stay
+     * alive while the user browses Workspaces, Jobs, etc. If we drove
+     * the runtime's ``threadId`` from the URL only, every non-chat
+     * navigation would remount the runtime and wipe in-flight messages.
+     *
+     * When provided, the shell prefers this value over the URL match
+     * for the ``AGUIRuntimeProvider.threadId`` prop. The module is
+     * expected to update its sticky state on URL transitions itself
+     * (e.g. via :type:`useTrackActiveChatFromUrl` in Spaces).
+     *
+     * Return ``null`` when the user has no active chat (initial app
+     * load, or just clicked "New Thread"). The shell then lets the
+     * AG-UI adapter mint a fresh UUID, same as before this hook.
+     */
+    useStickyConversationId?: () => string | null;
+    /**
+     * Build an assistant-ui :type:`ThreadHistoryAdapter` for the
+     * current mount. Called inside the runtime provider once the
+     * AG-UI adapter has minted (or accepted) its thread id, so both
+     * ``urlMatch`` and ``aguiThreadId`` are available.
+     *
+     * The returned adapter is wired into ``useLocalRuntime``'s
+     * ``adapters.history`` slot — assistant-ui calls ``load()`` on
+     * mount and ``append()`` after every completed turn.
+     *
+     * Modules typically:
+     *   - On resume (``urlMatch`` set): use it directly as the
+     *     conversation id for load/append.
+     *   - On fresh (``urlMatch`` undefined): lazily ``create_or_get``
+     *     a server row keyed by ``aguiThreadId``, cache the resulting
+     *     conversation id, then load/append against that.
+     */
+    buildHistoryAdapter: (args: ChatConversationFactoryArgs) => import("@assistant-ui/react").ThreadHistoryAdapter;
+}
+/** Route entry contributed by a module or the host app. */
+export interface ShellPage {
+    path: string;
+    element: ReactNode;
+}
+/**
+ * A ChatModule is the unit of composition for `bootstrapShell`. Each field is
+ * optional — modules contribute what they need:
+ *
+ * - `useInit`: React hook body called once per layout render (rules-of-hooks
+ *   apply). Use for cross-store sync, registry registration, etc.
+ *   Modules wanting to mutate `useNavStore` config (sidebar nav items)
+ *   do it inside `useInit` — see Spaces' `useSpacesNavSync()` for the
+ *   canonical pattern.
+ * - `toolUIs`: ReactNode rendered inside `<AGUIRuntimeProvider>`. Use to
+ *   register `makeAssistantToolUI` instances.
+ * - `layoutExtras`: ReactNode rendered inside the shell layout (banners,
+ *   global dialogs, popovers).
+ * - `wrappers`: ComponentType<{children}>[] applied outer→inner from the
+ *   array. Wrap providers like SpacesQueryProvider here.
+ * - `useThemeLayers`: hook returning ThemeLayer[]; merged on top of the
+ *   static `theme` prop in module-array order.
+ * - `pages`: ShellPage[] appended to Routes; customer-supplied `pages` win
+ *   on path collision.
+ * - `fetchInterceptor`: zero-arg installer called once before `createRoot`.
+ *   Use to install `window.fetch` wrappers.
+ */
+export interface ChatModule {
+    name: string;
+    useInit?: () => void;
+    toolUIs?: ReactNode;
+    layoutExtras?: ReactNode;
+    wrappers?: ComponentType<{
+        children: ReactNode;
+    }>[];
+    useThemeLayers?: () => ThemeLayer[];
+    pages?: ShellPage[];
+    fetchInterceptor?: () => void;
+    /**
+     * URL-driven chat persistence.
+     *
+     * Selection order (see ``ChatConversationAwareRuntime`` in
+     * ``shell-app.tsx``):
+     *
+     * 1. URL match. If a module's ``pathPattern`` matches the current
+     *    pathname and captures a non-empty group, that module's config
+     *    wins and its captured id is fed to the history adapter as
+     *    ``urlMatch``.
+     * 2. Fallback. If nothing matches the URL, the shell falls back to
+     *    the FIRST registered config (``configs[0]``) so a fresh-chat
+     *    runtime still gets a history adapter and the chat persists
+     *    from the very first message. ``urlMatch`` is ``undefined``
+     *    in this case.
+     * 3. None. With zero configs registered, the runtime stays in
+     *    legacy in-memory mode (no persistence).
+     *
+     * Modules without a config don't participate in selection.
+     */
+    chatConversation?: ChatConversationConfig;
+}
+/**
+ * Adapter for plugging in an auth Provider. The Provider renders children
+ * once authenticated and is responsible for resolving its own config
+ * (the default reads MSAL settings from `import.meta.env`). Tests and
+ * non-MSAL deployments override with a different Provider.
+ */
+export interface AuthAdapter {
+    Provider: ComponentType<{
+        children: ReactNode;
+    }>;
+}
+export interface BootstrapShellOptions {
+    modules?: ChatModule[];
+    /** Customer-supplied pages — win over module pages on `path` collision. */
+    pages?: ShellPage[];
+    /** Static base theme layers; modules' useThemeLayers stack on top. */
+    theme?: ThemeLayer[];
+    /** Override default MSAL-backed auth provider (e.g. for tests). */
+    authProvider?: AuthAdapter;
+    /**
+     * Override the agent transport used by the AG-UI runtime.
+     *
+     * Defaults to the MSAL-backed `defaultAgentFetch`. Apps can pass a custom
+     * fetch to point at a local demo agent, a mock AG-UI transport, or a
+     * production backend without patching global `window.fetch`.
+     */
+    agentFetch?: typeof fetch;
+    /** Wrap the tree in <StrictMode>. Default: true. */
+    strictMode?: boolean;
+    /** DOM element to mount into. Default: document.getElementById("root"). */
+    rootElement?: HTMLElement;
+}
+/** Pass-through helper that adds nothing at runtime — pure type marker. */
+export declare function defineChatModule(m: ChatModule): ChatModule;

package/dist/types.js

@@ -0,0 +1,4 @@
+/** Pass-through helper that adds nothing at runtime — pure type marker. */
+export function defineChatModule(m) {
+    return m;
+}

package/package.json

@@ -1,12 +1,21 @@
 {
   "name": "@iloveagents/foundry-web-shell",
-  "version": "0.3.1",
-  "license": "SEE LICENSE IN LICENSE",
+  "version": "0.5.0",
+  "license": "MIT",
   "type": "module",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "publishConfig": {
     "access": "public"
   },
@@ -19,20 +28,27 @@
     "zustand": "^5.0.0"
   },
   "dependencies": {
-    "@iloveagents/foundry-agent": "0.3.1",
-    "@iloveagents/foundry-web-primitives": "0.3.1",
-    "@iloveagents/foundry-web-ui": "0.3.1"
+    "@iloveagents/foundry-agent": "^0.5.0",
+    "@iloveagents/foundry-web-primitives": "^0.5.0",
+    "@iloveagents/foundry-web-ui": "^0.5.0"
   },
   "devDependencies": {
-    "typescript": "~5.9.3",
+    "@assistant-ui/react": "^0.12.25",
+    "@testing-library/react": "^16.0.0",
     "@types/react": "^19.2.2",
     "@types/react-dom": "^19.2.2",
+    "jsdom": "^28.1.0",
+    "lucide-react": ">=0.400.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-router": "^7.0.0",
+    "typescript": "~5.9.3",
     "vite": "^7.2.2",
     "vitest": "^4.1.4",
-    "jsdom": "^28.1.0",
-    "@testing-library/react": "^16.0.0"
+    "zustand": "^5.0.0"
   },
   "scripts": {
+    "build": "tsc -p tsconfig.build.json && node ../../scripts/fix-dts-extensions.mjs dist",
     "test:unit": "vitest run",
     "typecheck": "tsc --noEmit"
   }

package/AGENTS.md

@@ -1,82 +0,0 @@
-Browser bootstrap for the LastSpace agent UI starter. Published as `@iloveagents/foundry-web-shell`. Composes `@iloveagents/foundry-web-primitives`, `@iloveagents/foundry-agent` (and `@iloveagents/foundry-agent/msal`), and `@iloveagents/foundry-web-ui` into a generic mounting point — customers and modules contribute pages, theme layers, layout extras, tool UIs, and per-request fetch interceptors via the `ChatModule` protocol.
-
-# Architecture
-
-Source-shipping (no build step) — same convention as the other `@iloveagents/foundry-*` packages.
-
-```
-src/
-  index.ts                 ← public barrel (bootstrapShell, ChatModule, defineChatModule, types)
-  bootstrap-shell.tsx      ← entry point: installs fetch interceptors, calls createRoot
-  shell-app.tsx            ← <BrowserRouter> → AuthProvider → [wrappers outer→inner] → AGUIRuntimeProvider → {toolUIs} → Suspense → Routes
-  shell-layout.tsx         ← generic layout (Sidebar + ChatHeader + ToolPanelLayout + ChatBubble + GlobalSelectionPopover + module layoutExtras)
-  types.ts                 ← ChatModule, ShellPage, AuthAdapter, BootstrapShellOptions
-  auth-default.tsx         ← default authProvider (wraps @iloveagents/foundry-web-ui's AuthProvider; reads MsalAuthConfig from import.meta.env)
-  service-fetch-default.ts ← default fetchFn (createServiceFetch + tokenFetch wiring)
-```
-
-# Public API
-
-```ts
-import { bootstrapShell, defineChatModule, type ChatModule } from "@iloveagents/foundry-web-shell";
-```
-
-`bootstrapShell({ modules, pages, theme, authProvider, strictMode })` mounts the SPA. Each `ChatModule` may contribute:
-
-- `useInit?: () => void` — React hook body called inside the layout (rules-of-hooks apply).
-- `toolUIs?: ReactNode` — rendered inside `<AGUIRuntimeProvider>`.
-- `layoutExtras?: ReactNode` — rendered inside the layout (banners, dialogs, popovers).
-- `wrappers?: ComponentType<{ children }>[]` — applied outer→inner from array.
-- `useThemeLayers?: () => ThemeLayer[]` — hook returning theme layers; merged on top of static `theme` prop.
-- `pages?: { path; element }[]` — appended to Routes; customer `pages` win on path collision. (Sidebar nav items are mutated via `useNavStore.getState().setConfig(...)` inside `useInit` — see Spaces' `useSpacesNavSync` for the pattern.)
-- `fetchInterceptor?: () => void` — installed before `createRoot` (use to install global fetch wrappers).
-
-# Wrapper ordering
-
-```
-<StrictMode>
-  <BrowserRouter>
-    <AuthProvider>
-      {wrappers outer→inner from modules}
-        <AGUIRuntimeProvider>
-          {toolUIs}
-          <Suspense>
-            <Routes>
-              <Route element={<ShellLayout />}>
-                {pages — customer wins on path collision}
-              </Route>
-            </Routes>
-          </Suspense>
-        </AGUIRuntimeProvider>
-      {/wrappers}
-    </AuthProvider>
-  </BrowserRouter>
-</StrictMode>
-```
-
-Asserted by `src/__tests__/wrapper-order.test.tsx`.
-
-# Import boundary (enforced by guard test)
-
-`@iloveagents/foundry-web-shell` MAY import: `@iloveagents/foundry-web-primitives`, `@iloveagents/foundry-web-ui`, `@iloveagents/foundry-agent` (+ subpaths). MUST NOT import `@lastspace/spaces-web-ui` — modules are runtime parameters, never compile-time deps. Enforced by `OPEN_CORE_GRAPH` in `packages/web-ui/src/__tests__/open-core-guards.test.ts`.
-
-`packages/web-shell/src/` MUST stay ≤ 15 files (file-count ceiling, hardFail).
-
-# Theme
-
-`bootstrapShell({ theme })` provides static base layers. Modules' `useThemeLayers()` hooks return additional layers stacked on top in module-array order. Final layers feed `<ThemeRuntimeProvider layers={...}>`.
-
-# Auth
-
-The default `authProvider` reads `VITE_MSAL_CLIENT_ID`, `VITE_MSAL_AUTHORITY`, `VITE_MSAL_API_SCOPE` from `import.meta.env`. Missing keys render the `AuthConfigError` UI. Customers can override with `authProvider={{ Provider: MyAuthProvider }}` for testing or non-MSAL deployments.
-
-# Commands
-
-```bash
-pnpm --filter @iloveagents/foundry-web-shell test:unit   # vitest run
-pnpm --filter @iloveagents/foundry-web-shell typecheck   # tsc --noEmit
-```
-
-# Authoring a module
-
-The `ChatModule` protocol is documented in **Public API** above; the canonical type definitions live in [`src/types.ts`](src/types.ts) (`ChatModule`, `defineChatModule`). For the nav-mutation-from-`useInit` pattern, have your module's `useInit` write the sidebar nav `config` into `useNavStore` (the same store [`src/shell-layout.tsx`](src/shell-layout.tsx) reads via `useNavStore((s) => s.config)`).

package/CHANGELOG.md

@@ -1,184 +0,0 @@
-# @iloveagents/foundry-web-shell
-
-## 0.3.1
-
-### Patch Changes
-
-- Updated dependencies [9ec870e]
-  - @iloveagents/foundry-web-ui@0.3.1
-  - @iloveagents/foundry-agent@0.3.1
-  - @iloveagents/foundry-web-primitives@0.3.1
-
-## 0.3.0
-
-### Minor Changes
-
-- df383c9: Add runtime configuration support so the web app can ship as a single prebuilt
-  container image that boots for any environment without a rebuild. New
-  `runtimeConfig(key)` helper resolves `window.__APP_CONFIG__[key]` (injected by
-  the container at startup) before `import.meta.env[key]` (build-time Vite env,
-  the local-dev fallback). The default MSAL auth adapter and agent fetch client
-  now read `VITE_MSAL_*` / `VITE_API_BASE_URL` through it. Local `pnpm dev` is
-  unchanged (no `/config.js` → falls back to `import.meta.env`).
-
-### Patch Changes
-
-- @iloveagents/foundry-agent@0.3.0
-- @iloveagents/foundry-web-primitives@0.3.0
-- @iloveagents/foundry-web-ui@0.3.0
-
-## 0.2.2
-
-### Patch Changes
-
-- 8184a8c: shell: URL is authoritative for the runtime threadId — fixes
-  resume-creates-new-conversation race
-
-  `ChatConversationAwareRuntime` previously computed
-  `effectiveThreadId = sticky ?? urlMatch ?? freshIdRef.current`.
-  When the user navigated from one chat to another via a Recents
-  click, the synchronous render that followed the URL change had:
-  - `urlMatch = B` (read from the now-updated `useLocation`)
-  - `sticky = A` (the active-chat-store hadn't been updated by
-    `useTrackActiveChatFromUrl`'s `useEffect` yet — effects run
-    AFTER the commit phase)
-
-  `sticky ?? urlMatch` picked `A` (the previous chat). The AG-UI
-  adapter was constructed with `threadId = A`. The first message the
-  user sent went to `/api/agent` with `thread_id = A`, the middleware
-  created a new row keyed by `A`... wait actually no, here's what
-  happens — the runtime mints a fresh runner UUID when given a
-  mismatched threadId; that fresh UUID became a new conversation row,
-  appearing as "Untitled chat" at the top of the sidebar while the
-  URL still said `/chat/B`. Two active-looking dots: one for `B`
-  (NavLink URL match), one for the new row (statusDot from the
-  updated active-chat-store after the lazy ensure ran).
-
-  Swap the priority: `urlMatch ?? sticky ?? freshIdRef.current`. The
-  URL is authoritative whenever it's set (i.e. on `/chat/<id>`
-  routes), eliminating the stale-sticky race entirely. `sticky` is
-  still consulted as the second-priority fallback for non-chat
-  routes (`/spaces`, `/tasks`) so the popout chat stays "live" while
-  the user browses workspaces — that's the original purpose of
-  `useStickyConversationId` and it's preserved.
-
-- Updated dependencies [395f0cd]
-- Updated dependencies [1ba01ef]
-- Updated dependencies [8184a8c]
-  - @iloveagents/foundry-web-ui@0.2.2
-  - @iloveagents/foundry-agent@0.2.2
-  - @iloveagents/foundry-web-primitives@0.2.2
-
-## 0.2.1
-
-### Patch Changes
-
-- No source changes. Bumped in lock-step with the fixed group so the
-  whole group can publish at a version number that's free across all
-  four packages. (`shell@0.2.0` already published cleanly; this is a
-  follow-the-group patch bump.)
-
-## 0.2.0
-
-### Minor Changes
-
-- shell: ChatConversationConfig API + sticky-runtime threadId
-
-  Lets a downstream module (e.g. `@ltwlf/spaces-web-ui`) attach a
-  `ChatConversationConfig` to its `ChatModule`. The shell then:
-  - Pre-mints a fresh thread UUID via `useRef` so the AG-UI runtime's
-    `threadId` is defined from first render — no `undefined → defined`
-    remount mid-conversation when the user sends the first message.
-  - Calls `config.useStickyConversationId()` (when declared) and
-    feeds the resulting id into the runtime so the chat stays "live"
-    while the user browses non-chat routes (Workspaces, Jobs, etc.).
-  - Per-config keyed child components (`StickyAwareRuntime` vs
-    `UrlOnlyRuntime`) so optional hooks satisfy Rules-of-Hooks across
-    multi-module config swaps.
-
-### Patch Changes
-
-- Move `@iloveagents/foundry-agent`, `-web-primitives`, `-web-ui` from
-  `peerDependencies` to `dependencies`. They always ship together as a
-  coordinated fixed group from this monorepo — they were never
-  independently-versioned peers. Declaring them as peerDeps caused
-  changesets' `shouldBumpMajor` cascade to promote the entire group to
-  a major version on every minor changeset. See the root `foundry-agent`
-  CHANGELOG entry for details.
-
-- Updated dependencies
-  - @iloveagents/foundry-web-ui@0.2.0
-  - @iloveagents/foundry-agent@0.2.0
-  - @iloveagents/foundry-web-primitives@0.2.0
-
-### NOTE: 1.0.1 was accidental
-
-Version 1.0.1 was published briefly on 2026-05-27 due to the peerDep
-cascade bug described above (1.0.0 was reserved but not published —
-1.0.1 was the retry). It has been unpublished. Both 1.0.0 and 1.0.1
-are now permanently reserved on npm and CANNOT be re-published. Do
-not depend on 1.0.x.
-
-## 0.1.5
-
-### Patch Changes
-
-- Updated dependencies [f9144ca]
-  - @iloveagents/foundry-web-ui@0.1.5
-  - @iloveagents/foundry-agent@0.1.5
-  - @iloveagents/foundry-web-primitives@0.1.5
-
-## 0.1.4
-
-### Patch Changes
-
-- Updated dependencies [07ace7e]
-  - @iloveagents/foundry-agent@0.1.4
-  - @iloveagents/foundry-web-ui@0.1.4
-  - @iloveagents/foundry-web-primitives@0.1.4
-
-## 0.1.3
-
-### Patch Changes
-
-- Updated dependencies [d9b0460]
-  - @iloveagents/foundry-agent@0.1.3
-  - @iloveagents/foundry-web-ui@0.1.3
-  - @iloveagents/foundry-web-primitives@0.1.3
-
-## 0.1.2
-
-### Patch Changes
-
-- Updated dependencies [30a4346]
-  - @iloveagents/foundry-agent@0.1.2
-  - @iloveagents/foundry-web-ui@0.1.2
-  - @iloveagents/foundry-web-primitives@0.1.2
-
-## 0.1.1
-
-### Patch Changes
-
-- 689d3e9: feat(sidebar): distinct file-drop affordance for nav containers
-
-  `useNavItemDnd` now exposes `isFileDragOver` separately from `isDragOver`
-  so consuming nav items can render a prominent file-drop visual (dashed
-  primary outline + soft primary background + Upload icon) when the user
-  is dragging native files over the container. Previously file drags
-  shared the same subtle ring as entity-move drags, so users couldn't
-  tell that a folder accepted external files. Applies to all five nav-
-  item shapes (action-row leaf, button leaf, `NestedFolderItem`,
-  `CollapsibleNavItem` with children/actions, `NavLink` fallthrough) and
-  updates `ContainerDropZone` for visual parity.
-
-  Also fixes a related regression: the capture-phase
-  `onDragEnterCapture` / `onDragOverCapture` handlers were calling
-  `e.stopPropagation()`, which short-circuits React's synthetic dispatch
-  and prevented the bubble-phase `onDragEnter` (where state actually
-  mutates) from running. Removed — `preventDefault()` alone is enough to
-  mark the element as droppable.
-
-- Updated dependencies [689d3e9]
-  - @iloveagents/foundry-web-ui@0.1.1
-  - @iloveagents/foundry-agent@0.1.1
-  - @iloveagents/foundry-web-primitives@0.1.1

package/CLAUDE.md

@@ -1 +0,0 @@
-@AGENTS.md

package/src/__tests__/module-bootstrap.test.tsx

@@ -1,142 +0,0 @@
-/**
- * Module-bootstrap test.
- *
- * Asserts that every ChatModule extension point fires when ShellApp is
- * rendered. Bypasses bootstrap-shell.tsx (which calls createRoot) and
- * renders ShellApp directly so we can probe React's tree.
- */
-import { describe, expect, it, vi } from "vitest";
-import { render, screen, waitFor } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { defineChatModule, type ChatModule, type ShellPage } from "../types.ts";
-
-// Mock the web-ui surface the shell consumes. Don't spread the real
-// module — its top-level zustand stores call window.matchMedia at import
-// time, which jsdom doesn't provide. We only need the symbols ShellApp
-// + ShellLayout import directly.
-vi.mock("@iloveagents/foundry-web-ui", () => ({
-  AuthProvider: ({ children }: { children: ReactNode }) => <>{children}</>,
-  AGUIRuntimeProvider: ({ children }: { children: ReactNode }) => <>{children}</>,
-  Sidebar: () => <div data-testid="sidebar" />,
-  ChatHeader: () => <div data-testid="chat-header" />,
-  ChatBubble: () => <div data-testid="chat-bubble" />,
-  ChatContent: () => <div data-testid="chat-content" />,
-  ToolPanelLayout: ({ children }: { children: ReactNode }) => <>{children}</>,
-  ThemeRuntimeProvider: ({ children }: { children: ReactNode }) => <>{children}</>,
-  ThemeScope: ({ children }: { children: ReactNode }) => <>{children}</>,
-  ThemeDocumentMetadata: () => null,
-  GlobalSelectionPopover: () => null,
-  ContextPins: () => null,
-  TooltipIconButton: ({ children }: { children: ReactNode }) => <>{children}</>,
-  findNavItem: () => undefined,
-  useAppStore: (selector: (s: any) => unknown) =>
-    selector({ setCurrentPage: () => undefined, setNavContext: () => undefined }),
-  useNavStore: (selector: (s: any) => unknown) => selector({ config: [] }),
-  useChatBubbleStore: Object.assign(
-    (selector: (s: any) => unknown) =>
-      selector({
-        isExpanded: false,
-        showPagePanel: false,
-        togglePagePanel: () => undefined,
-      }),
-    { getState: () => ({ close: () => undefined }) },
-  ),
-  useThemeStore: (selector: (s: any) => unknown) => selector({ mode: "system" }),
-}));
-
-vi.mock("@iloveagents/foundry-web-primitives", () => ({
-  cn: (...classes: unknown[]) => classes.filter(Boolean).join(" "),
-}));
-
-vi.mock("@iloveagents/foundry-agent", () => ({
-  createServiceFetch: () => fetch,
-}));
-
-vi.mock("@iloveagents/foundry-agent/msal", () => ({
-  authStore: { getState: () => ({ getAccessToken: () => Promise.resolve("") }) },
-}));
-
-import { ShellApp } from "../shell-app.tsx";
-import type { AuthAdapter } from "../types.ts";
-
-const noopAuth: AuthAdapter = {
-  Provider: ({ children }) => <>{children}</>,
-};
-
-describe("ChatModule bootstrap composition", () => {
-  it("calls every extension point when ShellApp renders", async () => {
-    const useInit = vi.fn();
-    const useThemeLayers = vi.fn(() => []);
-    const wrapperRendered = vi.fn();
-
-    function ProbeWrapper({ children }: { children: ReactNode }) {
-      wrapperRendered();
-      return <div data-testid="probe-wrapper">{children}</div>;
-    }
-
-    const homePage: ShellPage = {
-      path: "/",
-      element: <div data-testid="home-page">home</div>,
-    };
-
-    const moduleHome: ShellPage = {
-      path: "/",
-      element: <div data-testid="module-home">module home</div>,
-    };
-
-    const modulePage: ShellPage = {
-      path: "elsewhere",
-      element: <div data-testid="module-page">module elsewhere</div>,
-    };
-
-    const m: ChatModule = defineChatModule({
-      name: "test",
-      useInit,
-      useThemeLayers,
-      toolUIs: <div data-testid="tool-ui-marker" />,
-      layoutExtras: <div data-testid="layout-extra-marker" />,
-      wrappers: [ProbeWrapper],
-      pages: [moduleHome, modulePage],
-    });
-
-    render(
-      <ShellApp
-        modules={[m]}
-        pages={[homePage]}
-        baseThemeLayers={[]}
-        authProvider={noopAuth}
-        agentFetch={fetch}
-      />,
-    );
-
-    // useInit hook fired.
-    await waitFor(() => expect(useInit).toHaveBeenCalled());
-
-    // useThemeLayers hook fired.
-    expect(useThemeLayers).toHaveBeenCalled();
-
-    // Module wrapper rendered.
-    expect(screen.getByTestId("probe-wrapper")).toBeTruthy();
-    expect(wrapperRendered).toHaveBeenCalled();
-
-    // Tool UI rendered.
-    expect(screen.getByTestId("tool-ui-marker")).toBeTruthy();
-
-    // Layout extra rendered.
-    expect(screen.getByTestId("layout-extra-marker")).toBeTruthy();
-
-    // Customer page wins on path collision (/ resolves to home-page, not module-home).
-    expect(screen.getByTestId("home-page")).toBeTruthy();
-    expect(screen.queryByTestId("module-home")).toBeNull();
-  });
-
-  it("invokes fetchInterceptor (verified by bootstrap-shell test)", () => {
-    // bootstrap-shell.tsx wraps installSpacesFetchInterceptor BEFORE createRoot.
-    // The contract is that ShellApp itself does not invoke it — bootstrap-shell does.
-    // This test just guards the type marker (`defineChatModule` is identity-typed).
-    const interceptor = vi.fn();
-    const m = defineChatModule({ name: "x", fetchInterceptor: interceptor });
-    expect(m.fetchInterceptor).toBe(interceptor);
-    expect(interceptor).not.toHaveBeenCalled();
-  });
-});