glirastes 0.3.2 → 0.5.0

package/dist/cjs/embed/glirastes-chat-element.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlirastesChatElement = exports.GLIRASTES_CHAT_TAG = void 0;
+exports.defineGlirastesChatElement = defineGlirastesChatElement;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const client_1 = require("react-dom/client");
+const chat_interactions_js_1 = require("../contracts/chat-interactions.js");
+const ai_chat_panel_js_1 = require("../react/components/ai-chat-panel.js");
+const definitions_js_1 = require("../react/interactions/definitions.js");
+const ai_chat_provider_js_1 = require("../react/provider/ai-chat-provider.js");
+const chat_context_js_1 = require("../react/provider/chat-context.js");
+const vercel_ai_chat_js_1 = require("../react/transports/vercel/vercel-ai-chat.js");
+const chat_styles_generated_js_1 = require("./chat-styles.generated.js");
+const theme_js_1 = require("./theme.js");
+exports.GLIRASTES_CHAT_TAG = 'glirastes-chat';
+function EmbedBridge({ emit, onSendReady, }) {
+    const { send, mentionEntity, isLoading, error } = (0, chat_context_js_1.useChatContext)();
+    const previous = (0, react_1.useRef)(null);
+    const state = error ? 'error' : isLoading ? 'busy' : 'idle';
+    (0, react_1.useEffect)(() => {
+        onSendReady({ send: (text) => send(text), mentionEntity });
+        return () => onSendReady(null);
+    }, [send, mentionEntity, onSendReady]);
+    (0, react_1.useEffect)(() => {
+        emit('glirastes-chat:ready', {});
+    }, [emit]);
+    (0, react_1.useEffect)(() => {
+        if (previous.current === state)
+            return;
+        previous.current = state;
+        emit('glirastes-chat:status', { state });
+    }, [state, emit]);
+    return null;
+}
+function EmbeddedChat({ endpoint, transport, config, theme, welcomeMessage, emit, onSendReady, }) {
+    const { headers, bodyExtras, onToolResult, ...providerConfig } = config;
+    const shared = {
+        ...providerConfig,
+        // Colours come from the shadow-root CSS (`themeScope: 'inherit'` skips the
+        // inline variables); the preset still drives effects such as glass blur.
+        theme,
+        themeScope: 'inherit',
+        onToolResult: (toolName, result) => {
+            onToolResult?.(toolName, result);
+            emit('glirastes-chat:tool-result', { toolName, result });
+        },
+    };
+    const body = ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)(EmbedBridge, { emit: emit, onSendReady: onSendReady }), (0, jsx_runtime_1.jsx)(ai_chat_panel_js_1.AiChatPanel, { welcomeMessage: welcomeMessage })] }));
+    if (transport) {
+        return (0, jsx_runtime_1.jsx)(ai_chat_provider_js_1.AiChatProvider, { transport: transport, ...shared, children: body });
+    }
+    return ((0, jsx_runtime_1.jsx)(vercel_ai_chat_js_1.VercelAiChat, { endpoint: endpoint, headers: headers, bodyExtras: bodyExtras, ...shared, children: body }));
+}
+// Importing on a server (SSR) must not touch DOM globals.
+const BaseElement = (typeof HTMLElement === 'undefined'
+    ? class {
+    }
+    : HTMLElement);
+/**
+ * `<glirastes-chat endpoint="/api/chat">`: the React chat UI inside a Shadow
+ * DOM for Vue, Angular, Svelte or plain HTML hosts.
+ *
+ * Attributes: `endpoint` (required unless `transport` is set), `theme`
+ * (preset name), `placeholder`, `welcome-message`, `voice`, `voice-language`,
+ * `interactions` (load `@` entities and `/` commands with a GET from the
+ * endpoint or the given URL; labels follow the nearest `lang`).
+ * Properties: `config`, `transport`, `interactions`. Methods: `send(text)`,
+ * `defineEntity(definition)`, `defineCommand(definition)`,
+ * `mentionEntity(type, id)`.
+ * Events (bubbling, composed): `glirastes-chat:ready`, `:status`,
+ * `:tool-result`, `:error`. Styling: `--glirastes-chat-*` CSS variables.
+ * Removing the element unmounts React and releases the microphone.
+ */
+class GlirastesChatElement extends BaseElement {
+    static get observedAttributes() {
+        return ['endpoint', 'theme', 'placeholder', 'welcome-message', 'voice', 'voice-language', 'interactions', 'lang'];
+    }
+    #root = null;
+    #style = null;
+    #config = {};
+    #transport;
+    #api = null;
+    #pendingUnmount = false;
+    #entities = [];
+    #commands = [];
+    #interactions;
+    #interactionsFromProperty = false;
+    #interactionsLoad = null;
+    #emit = (name, detail) => {
+        this.dispatchEvent(new CustomEvent(name, { detail, bubbles: true, composed: true }));
+    };
+    #onSendReady = (api) => {
+        this.#api = api;
+    };
+    get config() {
+        return this.#config;
+    }
+    set config(value) {
+        this.#config = value ?? {};
+        this.#render();
+    }
+    get transport() {
+        return this.#transport;
+    }
+    set transport(value) {
+        this.#transport = value;
+        this.#render();
+    }
+    /** Derived `@` entities and `/` commands, e.g. the generated module's `chatInteractions`. */
+    get interactions() {
+        return this.#interactions;
+    }
+    set interactions(value) {
+        this.#interactionsLoad?.abort();
+        this.#interactions = value ? (0, chat_interactions_js_1.parseChatInteractions)(value) : undefined;
+        this.#interactionsFromProperty = Boolean(value);
+        this.#render();
+    }
+    /** Adds or replaces (same type) an `@` entity; same definition as `defineChatEntity`. */
+    defineEntity(definition) {
+        const entity = (0, definitions_js_1.defineChatEntity)(definition);
+        this.#entities = [...this.#entities.filter((entry) => entry.type !== entity.type), entity];
+        this.#render();
+    }
+    /** Adds or replaces (same id) a `/` command; same definition as `defineChatCommand`. */
+    defineCommand(definition) {
+        const command = (0, definitions_js_1.defineChatCommand)(definition);
+        this.#commands = [...this.#commands.filter((entry) => entry.id !== command.id), command];
+        this.#render();
+    }
+    /** Adds a reference to an entity, resolved by id, to the composer. False before mount or when refused. */
+    async mentionEntity(type, id) {
+        return this.#api ? this.#api.mentionEntity(type, id) : false;
+    }
+    /** Sends a user message through the embedded chat. False before mount. */
+    send(text) {
+        if (!this.#api || !text.trim())
+            return false;
+        return this.#api.send(text);
+    }
+    connectedCallback() {
+        this.#pendingUnmount = false;
+        this.#loadInteractions();
+        if (!this.#root) {
+            const shadow = this.shadowRoot ?? this.attachShadow({ mode: 'open' });
+            const style = document.createElement('style');
+            const mount = document.createElement('div');
+            mount.setAttribute('data-part', 'mount');
+            shadow.replaceChildren(style, mount);
+            this.#style = style;
+            this.#root = (0, client_1.createRoot)(mount);
+        }
+        this.#render();
+    }
+    disconnectedCallback() {
+        // A move (disconnect + connect in one task) keeps the mounted chat.
+        this.#pendingUnmount = true;
+        queueMicrotask(() => {
+            if (!this.#pendingUnmount || this.isConnected)
+                return;
+            this.#pendingUnmount = false;
+            const root = this.#root;
+            this.#root = null;
+            this.#style = null;
+            this.#api = null;
+            this.#interactionsLoad?.abort();
+            root?.unmount();
+            this.shadowRoot?.replaceChildren();
+        });
+    }
+    attributeChangedCallback(name) {
+        if (name === 'interactions' || name === 'endpoint')
+            this.#loadInteractions();
+        this.#render();
+    }
+    #locale() {
+        const lang = this.closest('[lang]')?.getAttribute('lang') ?? '';
+        return lang.toLowerCase().startsWith('de') ? 'de' : 'en';
+    }
+    /** `interactions` attribute: GET the data from its URL, or from the endpoint when empty. */
+    #loadInteractions() {
+        if (this.#interactionsFromProperty || !this.isConnected)
+            return;
+        this.#interactionsLoad?.abort();
+        this.#interactionsLoad = null;
+        const attribute = this.getAttribute('interactions');
+        const url = attribute === null ? '' : attribute || this.getAttribute('endpoint') || '';
+        if (!url)
+            return;
+        const controller = new AbortController();
+        this.#interactionsLoad = controller;
+        void (async () => {
+            try {
+                const response = await fetch(url, {
+                    method: 'GET',
+                    credentials: 'same-origin',
+                    headers: { accept: 'application/json' },
+                    signal: controller.signal,
+                });
+                if (!response.ok)
+                    throw new Error(`HTTP ${response.status}`);
+                const data = (0, chat_interactions_js_1.parseChatInteractions)(await response.json());
+                if (controller.signal.aborted)
+                    return;
+                this.#interactions = data;
+                this.#render();
+            }
+            catch {
+                if (!controller.signal.aborted)
+                    this.#emit('glirastes-chat:error', { message: 'Chat interactions unavailable' });
+            }
+        })();
+    }
+    #chatInteractions() {
+        const base = this.#config.chatInteractions;
+        const data = this.#interactions ?? base?.data;
+        if (!base && !data && this.#entities.length === 0 && this.#commands.length === 0)
+            return undefined;
+        return {
+            ...base,
+            locale: base?.locale ?? this.#locale(),
+            ...(data ? { data } : {}),
+            entities: [...(base?.entities ?? []), ...this.#entities],
+            commands: [...(base?.commands ?? []), ...this.#commands],
+        };
+    }
+    #render() {
+        if (!this.#root || !this.#style)
+            return;
+        const themeAttribute = this.getAttribute('theme');
+        const theme = (0, theme_js_1.isChatThemePreset)(themeAttribute) ? themeAttribute : undefined;
+        this.#style.textContent = `${chat_styles_generated_js_1.CHAT_STYLES}\n${(0, theme_js_1.embedThemeCss)(theme)}`;
+        const endpoint = this.getAttribute('endpoint') ?? '';
+        if (!endpoint && !this.#transport) {
+            this.#root.render(null);
+            this.#emit('glirastes-chat:error', { message: 'Missing endpoint attribute' });
+            return;
+        }
+        const placeholder = this.getAttribute('placeholder');
+        const voiceLanguage = this.getAttribute('voice-language');
+        const chatInteractions = this.#chatInteractions();
+        const config = {
+            ...this.#config,
+            ...(chatInteractions ? { chatInteractions } : {}),
+            ...(placeholder
+                ? { locale: { ...(this.#config.locale ?? {}), placeholder } }
+                : {}),
+            ...(this.hasAttribute('voice')
+                ? {
+                    voice: {
+                        ...(this.#config.voice ?? {}),
+                        enabled: true,
+                        ...(voiceLanguage ? { language: voiceLanguage } : {}),
+                    },
+                }
+                : {}),
+        };
+        this.#root.render((0, jsx_runtime_1.jsx)(EmbeddedChat, { endpoint: endpoint, transport: this.#transport, config: config, theme: theme, welcomeMessage: this.getAttribute('welcome-message') ?? undefined, emit: this.#emit, onSendReady: this.#onSendReady }));
+    }
+}
+exports.GlirastesChatElement = GlirastesChatElement;
+/**
+ * Registers the element once per tag name and returns its class. Each tag
+ * gets its own subclass, so a page may register several names.
+ */
+function defineGlirastesChatElement(tagName = exports.GLIRASTES_CHAT_TAG) {
+    if (typeof customElements === 'undefined') {
+        throw new Error('glirastes/embed needs a browser with Custom Elements support');
+    }
+    const existing = customElements.get(tagName);
+    if (existing) {
+        if (!(existing.prototype instanceof GlirastesChatElement)) {
+            throw new Error(`<${tagName}> is already defined by another element`);
+        }
+        return existing;
+    }
+    const ElementClass = class extends GlirastesChatElement {
+    };
+    customElements.define(tagName, ElementClass);
+    return ElementClass;
+}

package/dist/cjs/embed/index.d.ts

@@ -0,0 +1,4 @@
+export { GLIRASTES_CHAT_TAG, GlirastesChatElement, defineGlirastesChatElement, type GlirastesChatElementConfig, type GlirastesChatEventMap, type GlirastesChatEventName, } from './glirastes-chat-element.js';
+export { EMBED_CSS_VARIABLES, embedThemeCss } from './theme.js';
+export { defineChatCommand, defineChatEntity, type ChatCommandDefinition, type ChatEntityAction, type ChatEntityCard, type ChatEntityDefinition, type ChatEntityItem, type ChatEntitySearchContext, } from '../react/interactions/definitions.js';
+export type { ChatInteractionArg, ChatInteractionsData, ChatLocaleCode, ChatText, } from '../contracts/chat-interactions.js';

package/dist/cjs/embed/index.js

@@ -0,0 +1,20 @@
+"use strict";
+// ============================================================================
+// glirastes/embed
+//
+// Framework-neutral chat embedding: <glirastes-chat> wraps the React chat UI
+// in a Shadow DOM for non-React hosts (Vue, Angular, Svelte, plain HTML).
+// Peer requirements: react, react-dom, @ai-sdk/react and ai.
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineChatEntity = exports.defineChatCommand = exports.embedThemeCss = exports.EMBED_CSS_VARIABLES = exports.defineGlirastesChatElement = exports.GlirastesChatElement = exports.GLIRASTES_CHAT_TAG = void 0;
+var glirastes_chat_element_js_1 = require("./glirastes-chat-element.js");
+Object.defineProperty(exports, "GLIRASTES_CHAT_TAG", { enumerable: true, get: function () { return glirastes_chat_element_js_1.GLIRASTES_CHAT_TAG; } });
+Object.defineProperty(exports, "GlirastesChatElement", { enumerable: true, get: function () { return glirastes_chat_element_js_1.GlirastesChatElement; } });
+Object.defineProperty(exports, "defineGlirastesChatElement", { enumerable: true, get: function () { return glirastes_chat_element_js_1.defineGlirastesChatElement; } });
+var theme_js_1 = require("./theme.js");
+Object.defineProperty(exports, "EMBED_CSS_VARIABLES", { enumerable: true, get: function () { return theme_js_1.EMBED_CSS_VARIABLES; } });
+Object.defineProperty(exports, "embedThemeCss", { enumerable: true, get: function () { return theme_js_1.embedThemeCss; } });
+var definitions_js_1 = require("../react/interactions/definitions.js");
+Object.defineProperty(exports, "defineChatCommand", { enumerable: true, get: function () { return definitions_js_1.defineChatCommand; } });
+Object.defineProperty(exports, "defineChatEntity", { enumerable: true, get: function () { return definitions_js_1.defineChatEntity; } });

package/dist/cjs/embed/theme.d.ts

@@ -0,0 +1,10 @@
+import type { ChatThemePreset } from '../react/types.js';
+/** Public CSS custom properties a host page may set on `<glirastes-chat>`. */
+export declare const EMBED_CSS_VARIABLES: readonly ["--glirastes-chat-primary", "--glirastes-chat-primary-soft", "--glirastes-chat-primary-tint", "--glirastes-chat-bg", "--glirastes-chat-bg-muted", "--glirastes-chat-bubble-user", "--glirastes-chat-bubble-assistant", "--glirastes-chat-text", "--glirastes-chat-text-muted", "--glirastes-chat-border", "--glirastes-chat-danger", "--glirastes-chat-radius", "--glirastes-chat-radius-sm", "--glirastes-chat-font"];
+export declare function isChatThemePreset(value: string | null | undefined): value is ChatThemePreset;
+/**
+ * Shadow-root theme rules. Host CSS variables (`--glirastes-chat-*`) win;
+ * the selected preset supplies the fallback. Inline panel variables are
+ * disabled in the embed (`themeScope: 'inherit'`) so these rules apply.
+ */
+export declare function embedThemeCss(preset?: ChatThemePreset): string;

package/dist/cjs/embed/theme.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMBED_CSS_VARIABLES = void 0;
+exports.isChatThemePreset = isChatThemePreset;
+exports.embedThemeCss = embedThemeCss;
+const themes_js_1 = require("../react/themes.js");
+/** Public CSS custom properties a host page may set on `<glirastes-chat>`. */
+exports.EMBED_CSS_VARIABLES = Object.freeze([
+    '--glirastes-chat-primary',
+    '--glirastes-chat-primary-soft',
+    '--glirastes-chat-primary-tint',
+    '--glirastes-chat-bg',
+    '--glirastes-chat-bg-muted',
+    '--glirastes-chat-bubble-user',
+    '--glirastes-chat-bubble-assistant',
+    '--glirastes-chat-text',
+    '--glirastes-chat-text-muted',
+    '--glirastes-chat-border',
+    '--glirastes-chat-danger',
+    '--glirastes-chat-radius',
+    '--glirastes-chat-radius-sm',
+    '--glirastes-chat-font',
+]);
+function isChatThemePreset(value) {
+    return typeof value === 'string' && Object.hasOwn(themes_js_1.CHAT_THEME_PRESETS, value);
+}
+/**
+ * Shadow-root theme rules. Host CSS variables (`--glirastes-chat-*`) win;
+ * the selected preset supplies the fallback. Inline panel variables are
+ * disabled in the embed (`themeScope: 'inherit'`) so these rules apply.
+ */
+function embedThemeCss(preset) {
+    const declarations = Object.entries((0, themes_js_1.getThemeVars)(preset))
+        .map(([name, value]) => {
+        const publicName = name.replace(/^--cm-/, '--glirastes-chat-');
+        return `  ${name}: var(${publicName}, ${value});`;
+    })
+        .join('\n');
+    return [
+        ':host { display: block; position: relative; height: 100%; min-height: 0; }',
+        ':host([hidden]) { display: none; }',
+        '[data-part="mount"] { height: 100%; }',
+        `[data-component="ai-chat-panel"] {\n${declarations}\n}`,
+    ].join('\n');
+}

package/dist/cjs/index.d.ts

@@ -1 +1,2 @@
 export * from './types.js';
+export * from './diagnostics/index.js';

package/dist/cjs/index.js

@@ -21,3 +21,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // Subpath exports (`glirastes/server`, `glirastes/react`, etc.) remain the
 // primary API surface for runtime functionality.
 __exportStar(require("./types.js"), exports);
+__exportStar(require("./diagnostics/index.js"), exports);

package/dist/cjs/react/assistant/assistant-layout.d.ts

@@ -0,0 +1,55 @@
+import { type ReactNode } from 'react';
+/** Docked on the right of the page, or a detached window above it. */
+export type AssistantLayoutMode = 'sidebar' | 'floating';
+export interface AssistantLayoutState {
+    open: boolean;
+    mode: AssistantLayoutMode;
+    /**
+     * The layout the assistant opens in. Detaching or docking the open
+     * assistant updates it, so a closed window comes back as a window.
+     */
+    defaultMode: AssistantLayoutMode;
+    /** Sidebar folded to a narrow rail. */
+    collapsed: boolean;
+    /** Sidebar width in pixels. */
+    width: number;
+}
+export interface AssistantLayoutLimits {
+    minWidth: number;
+    maxWidth: number;
+    defaultWidth: number;
+    defaultMode: AssistantLayoutMode;
+}
+export declare const DEFAULT_ASSISTANT_LAYOUT_KEY = "glirastes:assistant-layout:v1";
+export declare const DEFAULT_ASSISTANT_LAYOUT_LIMITS: AssistantLayoutLimits;
+export declare function clampAssistantWidth(width: number, limits?: Partial<AssistantLayoutLimits>): number;
+export declare function defaultAssistantLayout(limits?: Partial<AssistantLayoutLimits>): AssistantLayoutState;
+/** Reads a stored layout; anything invalid falls back to the defaults. */
+export declare function parseAssistantLayout(raw: string | null, limits?: Partial<AssistantLayoutLimits>): AssistantLayoutState;
+export interface AssistantLayout extends AssistantLayoutState {
+    limits: AssistantLayoutLimits;
+    openChat(): void;
+    closeChat(): void;
+    toggleChat(): void;
+    /** Switches the layout and remembers it for the next opening. */
+    setMode(mode: AssistantLayoutMode): void;
+    /** Sets the layout the next opening uses, without moving an open assistant. */
+    setDefaultMode(mode: AssistantLayoutMode): void;
+    setCollapsed(value: boolean): void;
+    toggleCollapsed(): void;
+    setWidth(width: number): void;
+}
+export interface AssistantLayoutProviderProps extends Partial<AssistantLayoutLimits> {
+    children: ReactNode;
+    /** localStorage key; `null` keeps the layout in memory only. Scope it per user when several share a browser. */
+    storageKey?: string | null;
+}
+/**
+ * Open state, layout and sidebar width of the assistant, persisted per
+ * browser. Storage is read after hydration, so server and client render
+ * the same closed assistant first.
+ */
+export declare function AssistantLayoutProvider({ children, storageKey, minWidth, maxWidth, defaultWidth, defaultMode, }: AssistantLayoutProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useAssistantLayout(): AssistantLayout;
+/** The surrounding layout, or null outside an `AssistantLayoutProvider`. */
+export declare function useOptionalAssistantLayout(): AssistantLayout | null;

package/dist/cjs/react/assistant/assistant-layout.js

@@ -0,0 +1,107 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ASSISTANT_LAYOUT_LIMITS = exports.DEFAULT_ASSISTANT_LAYOUT_KEY = void 0;
+exports.clampAssistantWidth = clampAssistantWidth;
+exports.defaultAssistantLayout = defaultAssistantLayout;
+exports.parseAssistantLayout = parseAssistantLayout;
+exports.AssistantLayoutProvider = AssistantLayoutProvider;
+exports.useAssistantLayout = useAssistantLayout;
+exports.useOptionalAssistantLayout = useOptionalAssistantLayout;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+exports.DEFAULT_ASSISTANT_LAYOUT_KEY = 'glirastes:assistant-layout:v1';
+exports.DEFAULT_ASSISTANT_LAYOUT_LIMITS = Object.freeze({
+    minWidth: 400,
+    maxWidth: 800,
+    defaultWidth: 420,
+    defaultMode: 'sidebar',
+});
+function limitsOf(limits) {
+    return { ...exports.DEFAULT_ASSISTANT_LAYOUT_LIMITS, ...limits };
+}
+function clampAssistantWidth(width, limits) {
+    const { minWidth, maxWidth, defaultWidth } = limitsOf(limits);
+    return Math.max(minWidth, Math.min(maxWidth, Number.isFinite(width) ? width : defaultWidth));
+}
+function defaultAssistantLayout(limits) {
+    const { defaultMode, defaultWidth } = limitsOf(limits);
+    return { open: false, mode: defaultMode, defaultMode, collapsed: false, width: clampAssistantWidth(defaultWidth, limits) };
+}
+/** Reads a stored layout; anything invalid falls back to the defaults. */
+function parseAssistantLayout(raw, limits) {
+    const fallback = defaultAssistantLayout(limits);
+    try {
+        const value = JSON.parse(raw ?? 'null');
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return fallback;
+        const mode = value.mode === 'floating' || value.mode === 'sidebar' ? value.mode : fallback.mode;
+        const defaultMode = value.defaultMode === 'floating' || value.defaultMode === 'sidebar'
+            ? value.defaultMode
+            : value.mode === 'floating' || value.mode === 'sidebar' ? value.mode : fallback.defaultMode;
+        return {
+            open: typeof value.open === 'boolean' ? value.open : false,
+            mode,
+            defaultMode,
+            collapsed: typeof value.collapsed === 'boolean' ? value.collapsed : false,
+            width: typeof value.width === 'number' ? clampAssistantWidth(value.width, limits) : fallback.width,
+        };
+    }
+    catch {
+        return fallback;
+    }
+}
+const AssistantLayoutContext = (0, react_1.createContext)(null);
+/**
+ * Open state, layout and sidebar width of the assistant, persisted per
+ * browser. Storage is read after hydration, so server and client render
+ * the same closed assistant first.
+ */
+function AssistantLayoutProvider({ children, storageKey = exports.DEFAULT_ASSISTANT_LAYOUT_KEY, minWidth, maxWidth, defaultWidth, defaultMode, }) {
+    const limits = (0, react_1.useMemo)(() => limitsOf(Object.fromEntries(Object.entries({ minWidth, maxWidth, defaultWidth, defaultMode }).filter(([, v]) => v !== undefined))), [minWidth, maxWidth, defaultWidth, defaultMode]);
+    const [state, setState] = (0, react_1.useState)(() => defaultAssistantLayout(limits));
+    const [ready, setReady] = (0, react_1.useState)(false);
+    (0, react_1.useEffect)(() => {
+        if (!storageKey) {
+            setReady(true);
+            return;
+        }
+        const frame = requestAnimationFrame(() => {
+            try {
+                setState(parseAssistantLayout(localStorage.getItem(storageKey), limits));
+            }
+            catch { /* Storage disabled */ }
+            setReady(true);
+        });
+        return () => cancelAnimationFrame(frame);
+    }, [storageKey, limits]);
+    (0, react_1.useEffect)(() => {
+        if (ready && storageKey)
+            try {
+                localStorage.setItem(storageKey, JSON.stringify(state));
+            }
+            catch { /* Storage full */ }
+    }, [ready, state, storageKey]);
+    const openChat = (0, react_1.useCallback)(() => setState(s => ({ ...s, open: true, mode: s.open ? s.mode : s.defaultMode, collapsed: false })), []);
+    const closeChat = (0, react_1.useCallback)(() => setState(s => ({ ...s, open: false })), []);
+    const toggleChat = (0, react_1.useCallback)(() => setState(s => s.open && s.collapsed && s.mode === 'sidebar'
+        ? { ...s, collapsed: false }
+        : { ...s, open: !s.open, mode: s.open ? s.mode : s.defaultMode, collapsed: false }), []);
+    const setMode = (0, react_1.useCallback)((mode) => setState(s => ({ ...s, mode, defaultMode: mode })), []);
+    const setDefaultMode = (0, react_1.useCallback)((mode) => setState(s => ({ ...s, defaultMode: mode, mode: s.open ? s.mode : mode })), []);
+    const setCollapsed = (0, react_1.useCallback)((collapsed) => setState(s => ({ ...s, collapsed })), []);
+    const toggleCollapsed = (0, react_1.useCallback)(() => setState(s => ({ ...s, collapsed: !s.collapsed })), []);
+    const setWidth = (0, react_1.useCallback)((width) => setState(s => ({ ...s, width: clampAssistantWidth(width, limits) })), [limits]);
+    const value = (0, react_1.useMemo)(() => ({ ...state, limits, openChat, closeChat, toggleChat, setMode, setDefaultMode, setCollapsed, toggleCollapsed, setWidth }), [state, limits, openChat, closeChat, toggleChat, setMode, setDefaultMode, setCollapsed, toggleCollapsed, setWidth]);
+    return (0, jsx_runtime_1.jsx)(AssistantLayoutContext.Provider, { value: value, children: children });
+}
+function useAssistantLayout() {
+    const value = (0, react_1.useContext)(AssistantLayoutContext);
+    if (!value)
+        throw new Error('useAssistantLayout must be used inside <AssistantLayoutProvider>');
+    return value;
+}
+/** The surrounding layout, or null outside an `AssistantLayoutProvider`. */
+function useOptionalAssistantLayout() {
+    return (0, react_1.useContext)(AssistantLayoutContext);
+}