@jini-ai/admin 0.3.10 → 0.4.1

package/dist/react/hooks/use-nav-sections.js

@@ -43,9 +43,9 @@ export const DEFAULT_NAV_SECTIONS_STORAGE_KEY = 'jini-admin-nav-sections';
  * Non-boolean entries are dropped individually rather than rejecting the whole map, so one bad key
  * cannot discard a user's other sections.
  */
-function readPersisted(storageKey) {
+function readPersisted(storageKey, storage) {
     try {
-        const raw = localStorage.getItem(storageKey);
+        const raw = storage.getItem(storageKey);
         if (raw === null)
             return {};
         const parsed = JSON.parse(raw);
@@ -62,9 +62,9 @@ function readPersisted(storageKey) {
         return {};
     }
 }
-function writePersisted(storageKey, state) {
+function writePersisted(storageKey, state, storage) {
     try {
-        localStorage.setItem(storageKey, JSON.stringify(state));
+        storage.setItem(storageKey, JSON.stringify(state));
     }
     catch {
         // Best-effort, exactly as in `use-sidebar-rail.ts`: a user who cannot persist still gets a
@@ -81,19 +81,19 @@ function writePersisted(storageKey, state) {
  * handful, fixed by the host's panel manifest, never user-variable.
  * @overallScore 100
  */
-export function useNavSections(storageKey = DEFAULT_NAV_SECTIONS_STORAGE_KEY) {
-    const [state, setState] = useState(() => readPersisted(storageKey));
-    const isOpen = useCallback((groupLabel) => state[groupLabel] ?? true, [state]);
-    const toggle = useCallback((groupLabel) => {
+export function useNavSections({ storage, events }, { storageKey = DEFAULT_NAV_SECTIONS_STORAGE_KEY } = {}) {
+    const [state, setState] = useState(() => readPersisted(storageKey, storage));
+    const isOpen = useCallback(({ groupLabel }) => state[groupLabel] ?? true, [state]);
+    const toggle = useCallback(({ groupLabel }) => {
         setState((current) => {
             // `?? true` here and in `isOpen` must agree: toggling a section that has never been stored
             // has to close it (it is currently rendered open), not open an already-open section — which
             // is what a bare `!current[label]` would do on the `undefined` first press.
             const next = { ...current, [groupLabel]: !(current[groupLabel] ?? true) };
-            writePersisted(storageKey, next);
+            writePersisted(storageKey, next, storage);
             return next;
         });
-    }, [storageKey]);
+    }, [storageKey, storage]);
     /** Cross-tab sync — two admin tabs should agree on the layout rather than diverging the moment
      *  either one collapses a section. Mirrors `useSidebarRail`'s listener, including treating a
      *  removed key (`newValue === null`, another tab clearing storage) as "no stored preference"
@@ -102,11 +102,11 @@ export function useNavSections(storageKey = DEFAULT_NAV_SECTIONS_STORAGE_KEY) {
         function onStorage(event) {
             if (event.key !== storageKey)
                 return;
-            setState(event.newValue === null ? {} : readPersisted(storageKey));
+            setState(event.newValue === null ? {} : readPersisted(storageKey, storage));
         }
-        window.addEventListener('storage', onStorage);
-        return () => window.removeEventListener('storage', onStorage);
-    }, [storageKey]);
+        events.addEventListener('storage', onStorage);
+        return () => events.removeEventListener('storage', onStorage);
+    }, [storageKey, storage, events]);
     return { isOpen, toggle };
 }
 //# sourceMappingURL=use-nav-sections.js.map

package/dist/react/hooks/use-sidebar-rail.d.ts

@@ -35,5 +35,11 @@ export interface SidebarRail {
  *
  * @complexity O(1) — one state read/write per toggle, no derived computation.
  */
-export declare function useSidebarRail(storageKey?: string, defaultCollapsed?: boolean): SidebarRail;
+export declare function useSidebarRail({ storage, events }: {
+    readonly storage: Pick<Storage, 'getItem' | 'setItem'>;
+    readonly events: Pick<Window, 'addEventListener' | 'removeEventListener'>;
+}, { storageKey, defaultCollapsed }?: {
+    readonly storageKey?: string | undefined;
+    readonly defaultCollapsed?: boolean | undefined;
+}): SidebarRail;
 //# sourceMappingURL=use-sidebar-rail.d.ts.map

package/dist/react/hooks/use-sidebar-rail.js

@@ -32,9 +32,9 @@ export const DEFAULT_SIDEBAR_RAIL_STORAGE_KEY = 'jini-admin-sidebar-rail-collaps
  * it collapsed again on every reload, because their explicit `'0'` would be indistinguishable from
  * never having chosen. A stored value always wins over the default; only its absence defers.
  */
-function readPersisted(storageKey) {
+function readPersisted(storageKey, storage) {
     try {
-        const raw = localStorage.getItem(storageKey);
+        const raw = storage.getItem(storageKey);
         if (raw === null)
             return undefined;
         return raw === '1';
@@ -43,9 +43,9 @@ function readPersisted(storageKey) {
         return undefined;
     }
 }
-function writePersisted(storageKey, collapsed) {
+function writePersisted(storageKey, collapsed, storage) {
     try {
-        localStorage.setItem(storageKey, collapsed ? '1' : '0');
+        storage.setItem(storageKey, collapsed ? '1' : '0');
     }
     catch {
         // Best-effort — a user who cannot persist the preference still gets a working toggle for the
@@ -64,15 +64,15 @@ function writePersisted(storageKey, collapsed) {
  *
  * @complexity O(1) — one state read/write per toggle, no derived computation.
  */
-export function useSidebarRail(storageKey = DEFAULT_SIDEBAR_RAIL_STORAGE_KEY, defaultCollapsed = false) {
-    const [collapsed, setCollapsed] = useState(() => readPersisted(storageKey) ?? defaultCollapsed);
+export function useSidebarRail({ storage, events }, { storageKey = DEFAULT_SIDEBAR_RAIL_STORAGE_KEY, defaultCollapsed = false } = {}) {
+    const [collapsed, setCollapsed] = useState(() => readPersisted(storageKey, storage) ?? defaultCollapsed);
     const toggle = useCallback(() => {
         setCollapsed((current) => {
             const next = !current;
-            writePersisted(storageKey, next);
+            writePersisted(storageKey, next, storage);
             return next;
         });
-    }, [storageKey]);
+    }, [storageKey, storage]);
     /** Cross-tab sync: two admin tabs open side by side should agree on the rail state rather than
      *  silently diverging the moment either one is toggled. */
     useEffect(() => {
@@ -85,9 +85,9 @@ export function useSidebarRail(storageKey = DEFAULT_SIDEBAR_RAIL_STORAGE_KEY, de
             // collapsed-by-default host in every other one.
             setCollapsed(event.newValue === null ? defaultCollapsed : event.newValue === '1');
         }
-        window.addEventListener('storage', onStorage);
-        return () => window.removeEventListener('storage', onStorage);
-    }, [storageKey, defaultCollapsed]);
+        events.addEventListener('storage', onStorage);
+        return () => events.removeEventListener('storage', onStorage);
+    }, [storageKey, defaultCollapsed, events]);
     return { collapsed, toggle };
 }
 //# sourceMappingURL=use-sidebar-rail.js.map

package/dist/react/index.d.ts

@@ -41,7 +41,7 @@ export type { ConfirmDialogController, UseConfirmDialog } from './components/Con
 export { ConfirmDialogDefaultsProvider } from './components/ConfirmDialog/ConfirmDialog.hooks.js';
 export type { ConfirmDialogDefaults, ConfirmDialogDefaultsProviderProps, } from './components/ConfirmDialog/ConfirmDialog.hooks.js';
 export { DataTable } from './components/DataTable.js';
-export type { DataTableColumn, DataTableProps } from './components/DataTable.js';
+export type { DataTableColumn, DataTableColumnSort, DataTableProps, DataTableSortDirection, DataTableSortState, } from './components/DataTable.js';
 export { InteractiveHtmlEditor } from './components/InteractiveHtmlEditor/InteractiveHtmlEditor.js';
 export type { InteractiveHtmlEditorProps } from './components/InteractiveHtmlEditor/InteractiveHtmlEditor.js';
 export { RowMenu } from './components/RowMenu/RowMenu.js';
@@ -52,4 +52,6 @@ export { DEFAULT_SIDEBAR_RAIL_STORAGE_KEY, useSidebarRail } from './hooks/use-si
 export type { SidebarRail } from './hooks/use-sidebar-rail.js';
 export { DEFAULT_NAV_SECTIONS_STORAGE_KEY, useNavSections } from './hooks/use-nav-sections.js';
 export type { NavSections, NavSectionState } from './hooks/use-nav-sections.js';
+export * from './shell/index.js';
+export * from './entities/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/react/index.js

@@ -39,8 +39,9 @@ export { ConfirmDialog } from './components/ConfirmDialog/ConfirmDialog.js';
 // Host-wide `ConfirmDialog` defaults (today just a translated `cancelLabel`), set once at an app
 // root rather than passed at every call site — see `ConfirmDialogDefaultsProvider`'s doc comment.
 export { ConfirmDialogDefaultsProvider } from './components/ConfirmDialog/ConfirmDialog.hooks.js';
-// The list table. Deliberately has no sorting, pagination or row selection — see its file header
-// for the corpus evidence behind each omission.
+// The list table. Sorting is opt-in per column (`DataTableColumn.sort`); pagination and row
+// selection are still deliberately absent — see its file header for the corpus evidence behind
+// every one of these decisions.
 export { DataTable } from './components/DataTable.js';
 // Visual click-into-text editing surface for a bespoke HTML document, built on GrapesJS. See its
 // own file header for the styling-contract exception it carries (vendor CSS import) and the
@@ -53,4 +54,6 @@ export { RowMenu } from './components/RowMenu/RowMenu.js';
 export { Sidebar, useSidebar } from './components/Sidebar.js';
 export { DEFAULT_SIDEBAR_RAIL_STORAGE_KEY, useSidebarRail } from './hooks/use-sidebar-rail.js';
 export { DEFAULT_NAV_SECTIONS_STORAGE_KEY, useNavSections } from './hooks/use-nav-sections.js';
+export * from './shell/index.js';
+export * from './entities/index.js';
 //# sourceMappingURL=index.js.map

package/dist/react/overlays.d.ts

@@ -0,0 +1,38 @@
+import type { ReactNode } from 'react';
+export interface OverlayEntry {
+    readonly id: number;
+    readonly render: () => ReactNode;
+}
+export interface OverlayPort {
+    open<T>(required: {
+        render: (required: {
+            resolve: (value: T | null) => void;
+            cancel: () => void;
+        }) => ReactNode;
+    }, optional?: {
+        signal?: AbortSignal;
+    }): Promise<T | null>;
+}
+/** One active overlay per host. A second request rejects instead of stealing the first
+ * caller's promise; abort/dispose settle null and release every event listener. */
+export declare function createOverlayController(_required?: Record<string, never>, _optional?: Record<string, never>): {
+    getSnapshot: () => Readonly<{
+        entries: readonly OverlayEntry[];
+    }>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    open<T>({ render, }: {
+        render: (required: {
+            resolve: (value: T | null) => void;
+            cancel: () => void;
+        }) => ReactNode;
+    }, { signal }?: {
+        signal?: AbortSignal;
+    }): Promise<T | null>;
+    cancel(_required?: Record<string, never>, _optional?: Record<string, never>): void;
+    dispose(_required?: Record<string, never>, _optional?: Record<string, never>): void;
+};
+export { OverlayHost } from './OverlayHost.js';
+export type { OverlayHostProps } from './OverlayHost.hooks.js';
+//# sourceMappingURL=overlays.d.ts.map

package/dist/react/overlays.js

@@ -0,0 +1,46 @@
+import { createControllerStore } from '../core/module/controller-store.js';
+/** One active overlay per host. A second request rejects instead of stealing the first
+ * caller's promise; abort/dispose settle null and release every event listener. */
+export function createOverlayController(_required = {}, _optional = {}) {
+    const store = createControllerStore({ initial: { entries: [] } });
+    let sequence = 0, cancelActive = null;
+    return {
+        getSnapshot: store.getSnapshot,
+        subscribe: store.subscribe,
+        open({ render, }, { signal } = {}) {
+            if (store.signal.aborted || signal?.aborted)
+                return Promise.resolve(null);
+            if (cancelActive)
+                return Promise.reject(new Error('An overlay is already open'));
+            return new Promise((resolve) => {
+                let settled = false;
+                const finish = (value) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    signal?.removeEventListener('abort', cancel);
+                    cancelActive = null;
+                    store.set({ patch: { entries: [] } });
+                    resolve(value);
+                };
+                const cancel = () => finish(null);
+                cancelActive = cancel;
+                signal?.addEventListener('abort', cancel, { once: true });
+                store.set({
+                    patch: {
+                        entries: [{ id: ++sequence, render: () => render({ resolve: finish, cancel }) }],
+                    },
+                });
+            });
+        },
+        cancel(_required = {}, _optional = {}) {
+            cancelActive?.();
+        },
+        dispose(_required = {}, _optional = {}) {
+            cancelActive?.();
+            store.dispose();
+        },
+    };
+}
+export { OverlayHost } from './OverlayHost.js';
+//# sourceMappingURL=overlays.js.map

package/dist/react/shell/AdminShell.d.ts

@@ -0,0 +1,9 @@
+import { type ReactNode } from 'react';
+import type { AdminShellProps } from './types.js';
+/**
+ * A host-composed admin layout with manifest navigation and a session gate.
+ * @param props Required host scope, ports, contributions, labels and slots; optional layout settings.
+ * @returns Loading/login/error UI or the authenticated sidebar, feature screen and pane slots.
+ */
+export declare function AdminShell(props: AdminShellProps): ReactNode;
+//# sourceMappingURL=AdminShell.d.ts.map

package/dist/react/shell/AdminShell.hooks.d.ts

@@ -0,0 +1,15 @@
+import { type Dispatch, type SetStateAction } from 'react';
+import type { AdminShellNavigationPort } from './types.js';
+/** Internal shell wiring: a route snapshot and host-installed SPA link interception. */
+export declare function useShellRoute(args: {
+    readonly navigation: AdminShellNavigationPort;
+    readonly base: string;
+}): string;
+/** Mobile overlay state, independent of the Sidebar's persisted desktop rail state. */
+export declare function useShellDrawer(args: {
+    readonly routePath: string;
+}): {
+    readonly open: boolean;
+    readonly setOpen: Dispatch<SetStateAction<boolean>>;
+};
+//# sourceMappingURL=AdminShell.hooks.d.ts.map

package/dist/react/shell/AdminShell.hooks.js

@@ -0,0 +1,27 @@
+import { useCallback, useEffect, useState, useSyncExternalStore } from 'react';
+/** Internal shell wiring: a route snapshot and host-installed SPA link interception. */
+export function useShellRoute(args) {
+    const { navigation, base } = args;
+    const subscribe = useCallback((onChange) => navigation.subscribe({ base, onChange }), [navigation, base]);
+    const read = useCallback(() => navigation.readRoute({ base }), [navigation, base]);
+    const routePath = useSyncExternalStore(subscribe, read, read);
+    useEffect(() => navigation.installLinkInterceptor({ base }), [navigation, base]);
+    return routePath;
+}
+/** Mobile overlay state, independent of the Sidebar's persisted desktop rail state. */
+export function useShellDrawer(args) {
+    const [open, setOpen] = useState(false);
+    useEffect(() => setOpen(false), [args.routePath]);
+    useEffect(() => {
+        if (!open)
+            return;
+        const onKeyDown = (event) => {
+            if (event.key === 'Escape')
+                setOpen(false);
+        };
+        document.addEventListener('keydown', onKeyDown);
+        return () => document.removeEventListener('keydown', onKeyDown);
+    }, [open]);
+    return { open, setOpen };
+}
+//# sourceMappingURL=AdminShell.hooks.js.map

package/dist/react/shell/AdminShell.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useId, useMemo } from 'react';
+import { Sidebar } from '../components/Sidebar.js';
+import { useShellDrawer, useShellRoute } from './AdminShell.hooks.js';
+import { resolveAdminShellModel } from './model.js';
+import { useAdminShellSession } from './use-admin-shell-session.js';
+import { useAdminTheme } from './use-admin-theme.js';
+/**
+ * A host-composed admin layout with manifest navigation and a session gate.
+ * @param props Required host scope, ports, contributions, labels and slots; optional layout settings.
+ * @returns Loading/login/error UI or the authenticated sidebar, feature screen and pane slots.
+ */
+export function AdminShell(props) {
+    const context = useMemo(() => ({ apiBase: props.apiBase, workspace: props.workspace }), [props.apiBase, props.workspace]);
+    const session = useAdminShellSession({ port: props.session, context });
+    const appearance = useAdminTheme({ userId: session.state.status === 'authenticated' ? session.state.session.user.id : null, workspace: context.workspace }, {
+        ...(props.theme ? { theme: props.theme } : {}),
+        ...(props.colorScheme ? { colorScheme: props.colorScheme } : {}),
+        ...(props.themeEnvironment ? { environment: props.themeEnvironment } : {}),
+        ...(props.themePreferenceStore ? { preferenceStore: props.themePreferenceStore } : {}),
+        ...(props.onColorSchemeChange ? { onColorSchemeChange: props.onColorSchemeChange } : {}),
+    });
+    const routePath = useShellRoute({ navigation: props.navigation, base: props.adminBase });
+    const drawer = useShellDrawer({ routePath });
+    const id = useId();
+    const sidebarId = `${id}-sidebar`;
+    const mainId = `${id}-main`;
+    if (session.state.status === 'checking')
+        return _jsx("div", { className: "boot-screen", role: "status", children: props.labels.loading });
+    if (session.state.status === 'anonymous')
+        return props.slots.login({ context, refreshSession: session.refresh });
+    if (session.state.status === 'error') {
+        if (props.slots.sessionError)
+            return props.slots.sessionError({ error: session.state.error, retry: session.refresh });
+        return _jsxs("div", { role: "alert", children: [_jsx("p", { children: props.labels.sessionError }), _jsx("button", { type: "button", onClick: () => { void session.refresh(); }, children: props.labels.retry })] });
+    }
+    const model = resolveAdminShellModel({ panels: props.panels, session: session.state.session, routePath, defaultPanelId: props.defaultPanelId }, { capabilities: props.capabilities ?? [] });
+    const slotArgs = {
+        context, session: session.state.session, route: model.route, logout: session.logout, refreshSession: session.refresh,
+        ...(appearance ? { appearance } : {}),
+    };
+    const nav = props.translateNav ? props.translateNav({ groups: model.nav }) : model.nav;
+    const assistant = props.slots.assistant;
+    return (_jsxs("div", { className: ['admin-layout', props.className].filter(Boolean).join(' '), children: [_jsx("a", { href: `#${mainId}`, className: "skip-link", children: props.labels.skipToContent }), _jsxs(Sidebar, { activeId: model.route.panelId ?? '', base: props.adminBase, open: drawer.open, id: sidebarId, label: props.labels.navigation, railStorageKey: props.railStorageKey, railDefaultCollapsed: props.railDefaultCollapsed ?? false, children: [props.slots.sidebarHeader, _jsx(Sidebar.Nav, { groups: nav, soonLabel: props.labels.soon, collapsibleGroups: props.collapsibleGroups ?? [] }), _jsxs(Sidebar.Footer, { children: [_jsx(Sidebar.RailToggle, { expandLabel: props.labels.expandSidebar, collapseLabel: props.labels.collapseSidebar }), props.slots.sidebarFooter?.(slotArgs)] })] }), drawer.open && _jsx("button", { type: "button", className: "sidebar-backdrop", "aria-label": props.labels.closeNavigation, onClick: () => drawer.setOpen(false) }), _jsxs("div", { className: "admin-main-col", children: [_jsxs("div", { className: "admin-topbar", children: [_jsx("button", { type: "button", className: "admin-topbar-toggle", "aria-expanded": drawer.open, "aria-controls": sidebarId, "aria-label": drawer.open ? props.labels.closeNavigation : props.labels.openNavigation, onClick: () => drawer.setOpen((open) => !open), children: _jsx("svg", { viewBox: "0 0 18 18", fill: "none", stroke: "currentColor", strokeWidth: 1.5, "aria-hidden": "true", children: _jsx("path", { d: "M2.5 5h13M2.5 9h13M2.5 13h13" }) }) }), _jsx("span", { className: "admin-topbar-title", children: props.title }), props.slots.topbar] }), _jsx("main", { ref: props.mainRef, id: mainId, className: "admin-content", tabIndex: -1, "data-agent-page": model.agentPageId ?? undefined, children: model.panel?.render(slotArgs) })] }), assistant && _jsx("aside", { className: "admin-assistant-pane", "aria-label": assistant.label, hidden: !assistant.open, children: assistant.content }), props.slots.overlays?.(slotArgs)] }));
+}
+//# sourceMappingURL=AdminShell.js.map

package/dist/react/shell/index.d.ts

@@ -0,0 +1,7 @@
+export { AdminShell } from './AdminShell.js';
+export { resolveAdminShellModel, type AdminShellModel } from './model.js';
+export { useAdminShellSession } from './use-admin-shell-session.js';
+export type { AdminShellContext, AdminShellLabels, AdminShellNavigationPort, AdminShellPanel, AdminShellProps, AdminShellRenderArgs, AdminShellSession, AdminShellSessionController, AdminShellSessionPort, AdminShellSessionState, AdminShellSlotArgs, AdminShellSlots, } from './types.js';
+export type { AdminThemePreferenceStorePort, AdminThemeEnvironment, AdminShellAppearance } from './theme-ports.js';
+export { useAdminTheme } from './use-admin-theme.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/react/shell/index.js

@@ -0,0 +1,5 @@
+export { AdminShell } from './AdminShell.js';
+export { resolveAdminShellModel } from './model.js';
+export { useAdminShellSession } from './use-admin-shell-session.js';
+export { useAdminTheme } from './use-admin-theme.js';
+//# sourceMappingURL=index.js.map

package/dist/react/shell/model.d.ts

@@ -0,0 +1,25 @@
+import { type AdminNavGroup } from '../../core/manifest/rules.js';
+import type { AdminRoute } from '../../core/routing/types.js';
+import type { AdminShellPanel, AdminShellSession } from './types.js';
+export interface AdminShellModel {
+    readonly panels: readonly AdminShellPanel[];
+    readonly panel: AdminShellPanel | undefined;
+    readonly route: AdminRoute;
+    readonly nav: readonly AdminNavGroup[];
+    readonly agentPageId: string | null;
+}
+/**
+ * Derive navigation and render dispatch from one resolved manifest.
+ * @param args Required host manifest, session, route and fallback panel.
+ * @param options Optional wired capability keys.
+ * @returns A matched route or a clean default index route. Never mutates contributions.
+ */
+export declare function resolveAdminShellModel(args: {
+    readonly panels: readonly AdminShellPanel[];
+    readonly session: AdminShellSession;
+    readonly routePath: string;
+    readonly defaultPanelId: string;
+}, options?: {
+    readonly capabilities?: readonly string[];
+}): AdminShellModel;
+//# sourceMappingURL=model.d.ts.map

package/dist/react/shell/model.js

@@ -0,0 +1,29 @@
+import { buildNav, resolveAgentPageId, resolvePanels } from '../../core/manifest/rules.js';
+import { matchRoute } from '../../core/routing/rules.js';
+/**
+ * Derive navigation and render dispatch from one resolved manifest.
+ * @param args Required host manifest, session, route and fallback panel.
+ * @param options Optional wired capability keys.
+ * @returns A matched route or a clean default index route. Never mutates contributions.
+ */
+export function resolveAdminShellModel(args, options = {}) {
+    const panels = resolvePanels({ panels: args.panels }, {
+        capabilities: options.capabilities ?? [],
+        permissions: args.session.effectivePermissions ?? [],
+    });
+    const matched = matchRoute({ routePath: args.routePath, panels });
+    const rawPath = args.routePath.split('?')[0] ?? '';
+    const isRoot = rawPath.split('/').filter(Boolean).length === 0;
+    // The existing matcher maps root to dashboard. The shell's default is host-owned.
+    const route = isRoot || matched.panelId === null
+        ? { panelId: args.defaultPanelId, view: null, params: {}, query: matched.query }
+        : matched;
+    return {
+        panels,
+        panel: panels.find((panel) => panel.id === route.panelId),
+        route,
+        nav: buildNav({ panels }, { defaultPanelId: args.defaultPanelId }),
+        agentPageId: resolveAgentPageId({ panels, panelId: route.panelId, view: route.view }),
+    };
+}
+//# sourceMappingURL=model.js.map

package/dist/react/shell/theme-ports.d.ts

@@ -0,0 +1,28 @@
+import type { AdminThemeDocument, AdminThemeTarget, ColorScheme, ColorSchemePreference, MatchMediaPort } from '@jini-ai/ui/theme';
+/** The host chooses storage and keys. Preferences are always scoped to a user and workspace. */
+export interface AdminThemePreferenceStorePort {
+    read(args: {
+        readonly userId: string;
+        readonly workspace: Readonly<Record<string, string>>;
+    }): ColorSchemePreference | null;
+    write(args: {
+        readonly userId: string;
+        readonly workspace: Readonly<Record<string, string>>;
+        readonly preference: ColorSchemePreference;
+    }): void;
+}
+/** Inject the same scope for the theme and color scheme; use the document root for portals. */
+export interface AdminThemeEnvironment {
+    readonly target: AdminThemeTarget;
+    readonly document: AdminThemeDocument;
+    readonly matchMedia: MatchMediaPort;
+}
+/** Exposed to slots so the host supplies its own light/dark/system picker and labels. */
+export interface AdminShellAppearance {
+    readonly preference: ColorSchemePreference;
+    readonly resolved: ColorScheme;
+    setPreference(args: {
+        readonly preference: ColorSchemePreference;
+    }): void;
+}
+//# sourceMappingURL=theme-ports.d.ts.map

package/dist/react/shell/theme-ports.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=theme-ports.js.map

package/dist/react/shell/types.d.ts

@@ -0,0 +1,99 @@
+import type { ReactNode, Ref } from 'react';
+import type { AdminTheme, ColorSchemePreference } from '@jini-ai/ui/theme';
+import type { AdminShellAppearance, AdminThemeEnvironment, AdminThemePreferenceStorePort } from './theme-ports.js';
+import type { AdminPanel } from '../../core/manifest/types.js';
+import type { AdminNavGroup } from '../../core/manifest/rules.js';
+import type { AdminRoute } from '../../core/routing/types.js';
+import type { AdminShellContext, AdminShellNavigationPort, AdminShellSession, AdminShellSessionPort } from '../../core/ports/shell.js';
+export type { AdminShellContext, AdminShellNavigationPort, AdminShellSession, AdminShellSessionPort } from '../../core/ports/shell.js';
+export interface AdminShellRenderArgs {
+    readonly context: AdminShellContext;
+    readonly session: AdminShellSession;
+    readonly route: AdminRoute;
+}
+/** A feature contribution uses the existing manifest, with a React renderer taking one object. */
+export type AdminShellPanel = AdminPanel<(args: AdminShellRenderArgs) => ReactNode>;
+export type AdminShellSessionState = {
+    readonly status: 'checking';
+} | {
+    readonly status: 'anonymous';
+} | {
+    readonly status: 'authenticated';
+    readonly session: AdminShellSession;
+} | {
+    readonly status: 'error';
+    readonly error: unknown;
+};
+export interface AdminShellSessionController {
+    readonly state: AdminShellSessionState;
+    /** Re-read after the host's login UI finishes; also refreshes effective permissions. */
+    readonly refresh: () => Promise<void>;
+    readonly logout: () => Promise<void>;
+}
+export interface AdminShellSlotArgs extends AdminShellRenderArgs {
+    readonly appearance?: AdminShellAppearance;
+    readonly logout: () => Promise<void>;
+    readonly refreshSession: () => Promise<void>;
+}
+export interface AdminShellSlots {
+    readonly login: (args: {
+        readonly context: AdminShellContext;
+        readonly refreshSession: () => Promise<void>;
+    }) => ReactNode;
+    readonly sessionError?: (args: {
+        readonly error: unknown;
+        readonly retry: () => Promise<void>;
+    }) => ReactNode;
+    readonly sidebarHeader?: ReactNode;
+    readonly sidebarFooter?: (args: AdminShellSlotArgs) => ReactNode;
+    readonly topbar?: ReactNode;
+    readonly overlays?: (args: AdminShellSlotArgs) => ReactNode;
+    /** Always mounted while authenticated; hidden when closed. The host owns pane controls. */
+    readonly assistant?: {
+        readonly content: ReactNode;
+        readonly label: string;
+        readonly open: boolean;
+    };
+}
+/** Required host copy, so branding and language never fall back to another product's values. */
+export interface AdminShellLabels {
+    readonly navigation: string;
+    readonly openNavigation: string;
+    readonly closeNavigation: string;
+    readonly skipToContent: string;
+    readonly loading: string;
+    readonly sessionError: string;
+    readonly retry: string;
+    readonly expandSidebar: string;
+    readonly collapseSidebar: string;
+    readonly soon: string;
+}
+export interface AdminShellProps extends AdminShellContext {
+    readonly theme?: AdminTheme;
+    /** Controlled when supplied; otherwise the injected store restores the user's choice. */
+    readonly colorScheme?: ColorSchemePreference;
+    readonly themeEnvironment?: AdminThemeEnvironment;
+    readonly themePreferenceStore?: AdminThemePreferenceStorePort;
+    readonly onColorSchemeChange?: (args: {
+        readonly preference: ColorSchemePreference;
+    }) => void;
+    readonly adminBase: string;
+    readonly defaultPanelId: string;
+    readonly railStorageKey: string;
+    readonly title: ReactNode;
+    readonly session: AdminShellSessionPort;
+    readonly navigation: AdminShellNavigationPort;
+    readonly panels: readonly AdminShellPanel[];
+    readonly slots: AdminShellSlots;
+    readonly labels: AdminShellLabels;
+    readonly capabilities?: readonly string[];
+    readonly railDefaultCollapsed?: boolean;
+    readonly collapsibleGroups?: readonly string[];
+    readonly translateNav?: (args: {
+        readonly groups: readonly AdminNavGroup[];
+    }) => readonly AdminNavGroup[];
+    /** Optional page-driver/measurement seam; the host owns any agent or screenshot integration. */
+    readonly mainRef?: Ref<HTMLElement>;
+    readonly className?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/react/shell/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/react/shell/use-admin-shell-session.d.ts

@@ -0,0 +1,13 @@
+import type { AdminShellContext, AdminShellSessionController, AdminShellSessionPort } from './types.js';
+interface Owner {
+    readonly context: AdminShellContext;
+    readonly port: AdminShellSessionPort;
+}
+/**
+ * Own session reads and invalidation without any host API imports.
+ * @param args Stable context and session port. Changing either starts a new session check.
+ * @returns Gate state plus refresh/logout actions; adapter failures become an error state.
+ */
+export declare function useAdminShellSession(args: Owner): AdminShellSessionController;
+export {};
+//# sourceMappingURL=use-admin-shell-session.d.ts.map