@gengage/assistant-fe 0.5.7 → 0.6.1

package/dist/chat.js

@@ -1,4 +1,4 @@
-import { a as e, c as t, d as r, i as s, l as n, n as i, o as c, r as l, s as o, t as C, u as h } from "./runtime-G3idwfkM.js";
+import { a as e, c as t, d as r, i as s, l as n, n as i, o as c, r as l, s as o, t as C, u as h } from "./runtime-C66Wp6OR.js";
 import { t as p } from "./chat-CrEa2W-e.js";
 export {
   n as CHAT_SCROLL_ELEMENT_ID,

package/dist/common/action-router.d.ts

@@ -0,0 +1,26 @@
+import type { UnknownActionPolicy } from './config-schema.js';
+import type { ActionPayload, AddToCartParams, StreamEventAction } from './types.js';
+export interface HostActionHandlers {
+    openChat?: (payload?: ActionPayload | unknown) => void;
+    navigate?: (params: {
+        url: string;
+        newTab?: boolean;
+    }) => void;
+    saveSession?: (params: {
+        sessionId: string;
+        sku: string;
+    }) => void;
+    addToCart?: (params: AddToCartParams) => void;
+    scriptCall?: (params: {
+        name: string;
+        payload?: Record<string, unknown>;
+    }) => void;
+    unknown?: (action: StreamEventAction['action']) => void;
+}
+export interface ActionRouterOptions {
+    allowScriptCall?: boolean;
+    unknownActionPolicy?: UnknownActionPolicy;
+    logger?: Pick<Console, 'warn' | 'error' | 'debug'>;
+    defaultNavigate?: (url: string, newTab?: boolean) => void;
+}
+export declare function routeStreamAction(event: StreamEventAction, handlers: HostActionHandlers, options?: ActionRouterOptions): void;

package/dist/common/api-paths.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Endpoint path helpers.
+ *
+ * All endpoints use `/chat/*` prefix. API versioning is handled via
+ * request-level compatibility params or feature-toggle params.
+ */
+import type { InjectorAdapter } from './transport.js';
+export type ChatEndpointName = 'process_action' | 'launcher_action' | 'similar_products' | 'product_groupings';
+export interface ChatTransportConfig {
+    middlewareUrl: string;
+    attachment?: File;
+    /** Account ID (used in URL path when needed). */
+    accountId?: string;
+    /**
+     * AGENTIC_ADAPTER_SEAM.
+     *
+     * Optional in-browser adaptor mounted by gengage-assistant-injector.
+     * When present, chat delegates turns to this function instead of `middlewareUrl`.
+     */
+    injectorAdapter?: InjectorAdapter;
+}
+export declare function normalizeMiddlewareUrl(input?: string): string;
+export declare function buildChatEndpointUrl(endpoint: ChatEndpointName, config: ChatTransportConfig): string;

package/dist/common/client.d.ts

@@ -0,0 +1,27 @@
+import type { AccountRuntimeConfig } from './config-schema.js';
+import type { OverlayWidgetsController, OverlayWidgetsOptions } from './overlay.js';
+import type { AddToCartHandlerResult, AddToCartParams, PageContext } from './types.js';
+export interface HostActions {
+    onAddToCart?: (params: AddToCartParams) => AddToCartHandlerResult;
+    onProductNavigate?: (url: string, sku: string, sessionId: string | null) => void;
+    onFindSimilar?: (detail: {
+        sku: string;
+        imageUrl?: string;
+    }) => void;
+    onScriptCall?: (params: {
+        name: string;
+        payload?: Record<string, unknown>;
+    }) => void;
+}
+export interface GengageClientOptions {
+    runtimeConfig: AccountRuntimeConfig | unknown;
+    contextResolver?: () => Partial<PageContext>;
+    hostActions?: HostActions;
+    preflight?: boolean;
+}
+/**
+ * Maps validated account runtime config to overlay widget options.
+ * Exported for unit tests.
+ */
+export declare function mapAccountRuntimeConfigToOverlayOptions(config: AccountRuntimeConfig, hostActions?: HostActions, initialContext?: Partial<PageContext>): OverlayWidgetsOptions;
+export declare function initGengageClient(options: GengageClientOptions): Promise<OverlayWidgetsController>;

package/dist/common/communication-bridge.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Two-way communication bridge between the host page and embedded widgets.
+ *
+ * Host -> Widget: The host sends `window.postMessage({ gengage, type, payload })`.
+ * The bridge validates the origin, checks the namespace, and routes to handlers.
+ *
+ * Widget -> Host: The bridge dispatches a `CustomEvent('gengage:bridge:message')`
+ * on window so the host can listen without tight coupling.
+ *
+ * Built-in message types:
+ *   - 'addToCart'    -- host confirms cart addition
+ *   - 'productFavorite' -- widget → host: product card heart toggled (payload: sku, product, favorited, sessionId)
+ *   - 'navigate'     -- host navigates to URL
+ *   - 'openChat'     -- programmatic open
+ *   - 'closeChat'    -- programmatic close
+ *   - 'getContext'   -- host requests current context
+ */
+export interface BridgeMessage {
+    type: string;
+    payload?: unknown;
+}
+export interface CommunicationBridgeOptions {
+    /** Widget namespace for message identification (e.g. 'chat', 'qna'). */
+    namespace: string;
+    /** Allowed origins for postMessage security (default: ['*']). */
+    allowedOrigins?: string[];
+    /** Callback when a message is received from the host. */
+    onMessage?: (msg: BridgeMessage) => void;
+}
+type BridgeHandler = (payload: unknown) => void;
+export declare class CommunicationBridge {
+    private readonly _namespace;
+    private readonly _allowedOrigins;
+    private readonly _onMessage;
+    private readonly _handlers;
+    private readonly _messageListener;
+    private _destroyed;
+    constructor(options: CommunicationBridgeOptions);
+    /** Send a message to the host page via CustomEvent on window. */
+    send(type: string, payload?: unknown): void;
+    /**
+     * Register a handler for a specific message type.
+     * Returns an unsubscribe function.
+     */
+    on(type: string, handler: BridgeHandler): () => void;
+    /** Clean up all event listeners and handlers. */
+    destroy(): void;
+    private _handlePostMessage;
+    private _isOriginAllowed;
+}
+export {};

package/dist/common/config-constants.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_IDEMPOTENCY_KEY = "__gengageWidgetsInit";

package/dist/common/config-schema.d.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+export declare const UnknownActionPolicySchema: z.ZodEnum<{
+    "log-and-ignore": "log-and-ignore";
+    throw: "throw";
+    delegate: "delegate";
+}>;
+export declare const AccountRuntimeConfigSchema: z.ZodObject<{
+    version: z.ZodLiteral<"1">;
+    accountId: z.ZodString;
+    middlewareUrl: z.ZodString;
+    locale: z.ZodOptional<z.ZodString>;
+    widgets: z.ZodObject<{
+        chat: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        qna: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        simrel: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        simbut: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    mounts: z.ZodDefault<z.ZodObject<{
+        chat: z.ZodOptional<z.ZodString>;
+        qna: z.ZodOptional<z.ZodString>;
+        simrel: z.ZodOptional<z.ZodString>;
+        simbut: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    transport: z.ZodDefault<z.ZodObject<{}, z.core.$strip>>;
+    gtm: z.ZodDefault<z.ZodObject<{
+        idempotencyKey: z.ZodDefault<z.ZodString>;
+        requireDomReady: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    actionHandling: z.ZodDefault<z.ZodObject<{
+        unknownActionPolicy: z.ZodDefault<z.ZodEnum<{
+            "log-and-ignore": "log-and-ignore";
+            throw: "throw";
+            delegate: "delegate";
+        }>>;
+        allowScriptCall: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AccountRuntimeConfig = z.infer<typeof AccountRuntimeConfigSchema>;
+export type UnknownActionPolicy = z.infer<typeof UnknownActionPolicySchema>;
+export declare function parseAccountRuntimeConfig(input: unknown): AccountRuntimeConfig;
+export declare function safeParseAccountRuntimeConfig(input: unknown): ReturnType<typeof AccountRuntimeConfigSchema.safeParse>;
+export declare function createDefaultAccountRuntimeConfig(params: {
+    accountId: string;
+    middlewareUrl: string;
+    locale?: string;
+}): AccountRuntimeConfig;

package/dist/common/connection-warning.d.ts

@@ -0,0 +1,8 @@
+export declare function configureConnectionWarning(options: {
+    probeUrl?: string;
+}): void;
+export interface ConnectionWarningRequestOptions {
+    source: 'chat' | 'qna' | 'simrel';
+    locale?: string | undefined;
+}
+export declare function trackConnectionWarningRequest(options: ConnectionWarningRequestOptions): () => void;

package/dist/common/consulting-sources.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Wire-protocol source strings that indicate consulting-style product grids.
+ *
+ * Kept in `common/` because both the protocol adapter and chat-specific
+ * renderers need to agree on which sources activate style-variation grids.
+ */
+/** Whether a wire-protocol source string is a consulting source. */
+export declare function isConsultingSource(source: string | undefined): boolean;

package/dist/common/context.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Page context management.
+ *
+ * Best practice for passing page context to widgets:
+ *
+ * ## SSR / Static pages
+ * Set window.gengage.pageContext before widget scripts load:
+ *
+ *   <script>
+ *     window.gengage = {
+ *       pageContext: {
+ *         pageType: 'pdp',
+ *         sku: '{{ product.sku }}',
+ *         price: '{{ product.price }}',
+ *         categoryTree: {{ product.categories | json }},
+ *       }
+ *     };
+ *   </script>
+ *   <script src="https://cdn.gengage.ai/widgets/latest/chat.iife.js"></script>
+ *
+ * ## CSR / SPA (React, Vue, Next.js, etc.)
+ * Call widget.update() after each navigation:
+ *
+ *   router.afterEach((to) => {
+ *     chatWidget.update({
+ *       pageType: to.meta.pageType,
+ *       sku: to.params.sku,
+ *     });
+ *   });
+ *
+ * ## Event-based (loosest coupling)
+ * Dispatch 'gengage:context:update' from anywhere:
+ *
+ *   window.dispatchEvent(new CustomEvent('gengage:context:update', {
+ *     detail: { pageType: 'pdp', sku: '12345' }
+ *   }));
+ */
+import type { PageContext, SessionContext } from './types.js';
+/**
+ * Returns the shared session ID for this browser tab session.
+ * Creates and persists it on first call.
+ *
+ * Call this once at page load and share the result with all widget configs:
+ *
+ *   const sessionId = bootstrapSession();
+ *   chatWidget.init({ ..., session: { sessionId } });
+ *   qnaWidget.init({ ..., session: { sessionId } });
+ */
+export declare function bootstrapSession(): string;
+/**
+ * Reads the current page context from window.gengage.pageContext.
+ * Returns null if not set.
+ */
+export declare function getWindowPageContext(): PageContext | null;
+/**
+ * Merges a partial context update into the current window.gengage.pageContext.
+ * Dispatches 'gengage:context:update' so all listening widgets update.
+ */
+export declare function updatePageContext(patch: Partial<PageContext>): void;
+/**
+ * Resolves the session context, bootstrapping if necessary.
+ * Merges provided overrides with auto-generated session ID.
+ */
+export declare function resolveSession(overrides?: Partial<SessionContext>): SessionContext;

package/dist/common/css-escape.d.ts

@@ -0,0 +1 @@
+export declare function escapeCssIdentifier(value: string): string;

package/dist/common/customization-factories.d.ts

@@ -0,0 +1,59 @@
+import type { ChatWidgetConfig } from '../chat/types.js';
+import type { InjectorAdapter } from './transport.js';
+import type { QNAWidgetConfig } from '../qna/types.js';
+import type { SimRelWidgetConfig } from '../simrel/types.js';
+import type { WidgetTheme } from './types.js';
+export declare const DEFAULT_CUSTOMIZATION_LOCALE = "tr";
+export interface AccountIdentityConfig {
+    accountId: string;
+    middlewareUrl: string;
+    locale?: string;
+}
+export interface AccountIdentity {
+    ACCOUNT_ID: string;
+    MIDDLEWARE_URL: string;
+    LOCALE: string;
+}
+interface BaseAccountWidgetConfigInput {
+    accountId: string;
+    middlewareUrl: string;
+    sessionId: string;
+    theme?: WidgetTheme;
+    injectorAdapter?: InjectorAdapter;
+}
+export interface FloatingChatConfigInput extends BaseAccountWidgetConfigInput {
+    locale?: string;
+}
+export interface PdpQnaConfigInput extends BaseAccountWidgetConfigInput {
+    sku: string;
+    mountTarget: QNAWidgetConfig['mountTarget'];
+}
+export interface PdpSimRelConfigInput extends BaseAccountWidgetConfigInput {
+    sku: string;
+    mountTarget: SimRelWidgetConfig['mountTarget'];
+}
+type FloatingChatConfigOverrides = Omit<Partial<ChatWidgetConfig>, 'accountId' | 'middlewareUrl' | 'session' | 'variant' | 'theme' | 'locale'>;
+type PdpQnaConfigOverrides = Omit<Partial<QNAWidgetConfig>, 'accountId' | 'middlewareUrl' | 'session' | 'pageContext' | 'mountTarget' | 'theme'>;
+type SimRelAccountConfig = Omit<SimRelWidgetConfig, 'onAddToCart' | 'onProductNavigate'>;
+type PdpSimRelConfigOverrides = Omit<Partial<SimRelAccountConfig>, 'accountId' | 'middlewareUrl' | 'session' | 'sku' | 'mountTarget' | 'theme'>;
+export declare function discoverInjectorAdapter(accountId?: string): InjectorAdapter | undefined;
+/**
+ * Shared account identity factory used by all customization folders.
+ * Keeps middleware URL + locale defaults centralized in the SDK layer.
+ */
+export declare function createAccountIdentity(config: AccountIdentityConfig): AccountIdentity;
+/**
+ * Shared floating-chat baseline used by account customizations.
+ * Account files only pass differences via `overrides`.
+ */
+export declare function createFloatingChatConfig(input: FloatingChatConfigInput, overrides?: FloatingChatConfigOverrides): ChatWidgetConfig;
+/**
+ * Shared PDP QNA baseline used by account customizations.
+ */
+export declare function createPdpQnaConfig(input: PdpQnaConfigInput, overrides?: PdpQnaConfigOverrides): QNAWidgetConfig;
+/**
+ * Shared PDP SimRel baseline used by account customizations.
+ * Host-level commerce callbacks stay in account init wrappers.
+ */
+export declare function createPdpSimRelConfig(input: PdpSimRelConfigInput, overrides?: PdpSimRelConfigOverrides): SimRelAccountConfig;
+export {};

package/dist/common/debug.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Debug logging for integrators.
+ *
+ * Enable with: `localStorage.setItem('gengage:debug', '1')`
+ * Disable with: `localStorage.removeItem('gengage:debug')`
+ *
+ * When disabled, all debug calls are no-ops with zero overhead
+ * (the check is a single localStorage read cached per page load).
+ */
+/** Log a debug message (only when gengage:debug is enabled). */
+export declare function debugLog(category: string, message: string, data?: unknown): void;
+/** Reset the cached enabled state (for testing). */
+export declare function _resetDebugCache(): void;

package/dist/common/events.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Cross-widget event bus utilities.
+ *
+ * All Gengage widgets communicate through window CustomEvents following
+ * the naming convention:  gengage:<widget>:<action>
+ *
+ * This creates a loosely-coupled event bus — widgets don't import each other,
+ * host pages can intercept any event, and third-party analytics can hook in.
+ */
+import type { GengageEventDetailMap, GengageEventName } from './types.js';
+/**
+ * Dispatch a typed Gengage event on window.
+ *
+ * @example
+ * dispatch('gengage:qna:action', { title: 'About shipping', type: 'query', payload: 'shipping' });
+ */
+export declare function dispatch<K extends GengageEventName>(name: K, detail: GengageEventDetailMap[K]): void;
+/**
+ * Listen for a typed Gengage event on window.
+ * Returns an unsubscribe function.
+ *
+ * @example
+ * const off = listen('gengage:qna:action', (detail) => {
+ *   window.gengage?.chat?.openWithAction(detail);
+ * });
+ * // Later:
+ * off();
+ */
+export declare function listen<K extends GengageEventName>(name: K, handler: (detail: GengageEventDetailMap[K]) => void): () => void;
+export interface WireQNAToChatOptions {
+    onChatUnavailable?: () => void;
+}
+/**
+ * Convenience: wire QNA → Chat automatically.
+ * Call this once after both widgets are initialised.
+ *
+ * Listens for 'gengage:qna:action' and forwards to window.gengage.chat.openWithAction().
+ * Listens for 'gengage:qna:open-chat' and forwards to window.gengage.chat.open().
+ *
+ * If chat is not available at dispatch time, emits a one-time console.warn and
+ * calls options.onChatUnavailable (every time) if provided.
+ *
+ * @returns unsubscribe function that removes both listeners.
+ */
+export declare function wireQNAToChat(options?: WireQNAToChatOptions): () => void;
+/**
+ * Convenience: wire Similar Products → Chat for cross-page session continuity.
+ * Call this once after both widgets are initialised.
+ *
+ * When the user navigates to a product page, the chat widget can restore
+ * the conversation where it left off using saveSession().
+ *
+ * @returns unsubscribe function.
+ */
+export declare function wireSimilarToChat(): () => void;

package/dist/common/fastIntent.d.ts

@@ -0,0 +1 @@
+export declare function detectFastIntent(text: string): string | null;

package/dist/common/find-similar-payload.d.ts

@@ -0,0 +1,3 @@
+export declare function firstNonEmptyStringValue(...values: unknown[]): string | undefined;
+export declare function nonEmptyStringList(value: unknown): string[];
+export declare function normalizeFindSimilarPayload(payload: Record<string, unknown>): Record<string, unknown>;

package/dist/common/ga-datalayer.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Google Analytics dataLayer integration.
+ *
+ * Pushes chat activity events to `window.dataLayer` when GA is available.
+ * Silently skips pushes when GA is not detected.
+ *
+ * Event naming follows the GA4 recommended event pattern:
+ *   - All lowercase, hyphen-separated
+ *   - Prefixed with `gengage-` for easy filtering in GA dashboards
+ *
+ * Clients can build custom chat funnels in GA using these events.
+ */
+interface DataLayerEvent {
+    event: string;
+    [key: string]: unknown;
+}
+declare global {
+    interface Window {
+        dataLayer?: DataLayerEvent[];
+    }
+}
+/** Widget icon/avatar displayed on page. */
+export declare function trackInit(widget: string): void;
+/** Widget opened / shown to user. */
+export declare function trackShow(widget: string): void;
+/** Widget closed / hidden. */
+export declare function trackHide(widget: string): void;
+/** User clicked a suggested question / action button. */
+export declare function trackSuggestedQuestion(title: string, type: string): void;
+/** User clicked "Find Similar" for a product. */
+export declare function trackFindSimilars(sku: string): void;
+/** User pre-selected a product for comparison. */
+export declare function trackComparePreselection(sku: string): void;
+/** User submitted the comparison (clicked "Compare Selected"). */
+export declare function trackCompareSelected(skus: string[]): void;
+/** User cleared the comparison selection. */
+export declare function trackCompareClear(): void;
+/** Comparison results received and rendered. */
+export declare function trackCompareReceived(productCount: number): void;
+/** User liked / favorited a product. */
+export declare function trackLikeProduct(sku: string): void;
+/** User clicked the favorites/likes list button. */
+export declare function trackLikeList(): void;
+/** Product list / search results displayed. */
+export declare function trackSearch(query?: string, resultCount?: number): void;
+/** User clicked on a product to view details. */
+export declare function trackProductDetail(sku: string, name?: string): void;
+/** SimRel (or chat-routed similar) product card click — distinct from generic PDP detail views. */
+export declare function trackSimilarProductClick(sku: string, extras?: {
+    url?: string;
+    name?: string;
+    session_id?: string | null;
+}): void;
+/** User clicked the floating comparison dock primary action (popup bar). */
+export declare function trackCompareProduct(skus: string[]): void;
+/** Chat MainPane (assistant left panel) expanded into split view. */
+export declare function trackChatbotMaximized(): void;
+/**
+ * SDK / bridge could not become ready after bounded retries (e.g. chat not initialized).
+ * Also used when overlay bootstrap fails fatally.
+ */
+export declare function trackInterfaceNotReady(params?: {
+    reason?: string;
+    attempts?: number;
+    message?: string;
+}): void;
+/** User added a product to cart from the widget. */
+export declare function trackCartAdd(sku: string, quantity: number): void;
+/** User sent a chat message. */
+export declare function trackMessageSent(): void;
+/** Assistant responded with text. */
+export declare function trackMessageReceived(): void;
+/** User started a new conversation. */
+export declare function trackConversationStart(): void;
+/** User used voice input. */
+export declare function trackVoiceInput(): void;
+/** Widget or stream error occurred. */
+export declare function trackError(widget: string, error: string): void;
+export declare function wireGADataLayer(): () => void;
+export {};

package/dist/common/global-error-toast.d.ts

@@ -0,0 +1,6 @@
+import type { GengageEventDetailMap } from './types.js';
+export declare function isLikelyConnectivityIssue(error?: unknown): boolean;
+export declare function getGlobalErrorMessage(locale?: string, error?: unknown): string;
+export declare function registerGlobalErrorToastListener(): void;
+export declare function showGlobalErrorToast(detail: GengageEventDetailMap['gengage:global:error']): void;
+export declare function dismissGlobalErrorToast(): void;

package/dist/common/index.d.ts

@@ -0,0 +1,47 @@
+export type { PageContext, SessionContext, BaseWidgetConfig, WidgetTheme, GengageWidget, StreamEvent, StreamEventMetadata, StreamEventTextChunk, StreamEventUISpec, StreamEventAction, StreamEventError, StreamEventDone, UISpec, UIElement, ActionPayload, GengageEventName, GengageEventDetailMap, } from './types.js';
+export { BaseWidget } from './widget-base.js';
+export type { ChatPublicAPI } from './widget-base.js';
+export { GENGAGE_VERSION, GENGAGE_BUILD_FLAVOR } from './sdk-version.js';
+export { consumeStream, streamPost } from './streaming.js';
+export type { StreamOptions, StreamEventHandler } from './streaming.js';
+export { dispatch, listen, wireQNAToChat, wireSimilarToChat } from './events.js';
+export type { WireQNAToChatOptions } from './events.js';
+export { bootstrapSession, getWindowPageContext, updatePageContext, resolveSession } from './context.js';
+export { initOverlayWidgets, getOverlayWidgets, destroyOverlayWidgets, buildOverlayIdempotencyKey } from './overlay.js';
+export type { OverlayWidgetsController, OverlayWidgetsOptions, OverlayChatOptions, OverlayQNAOptions, OverlaySimRelOptions, OverlaySimButOptions, } from './overlay.js';
+export { detectNativeEnvironment, applyNativeSession, createNativeWebViewBridge, initNativeOverlayWidgets, } from './native-webview.js';
+export type { NativeBridgeEnvironment, NativeSessionPayload, NativeBridgeMessage, NativeWebViewBridgeOptions, NativeWebViewBridge, NativeOverlayInitOptions, NativeOverlayInitResult, } from './native-webview.js';
+export { buildChatEndpointUrl, normalizeMiddlewareUrl } from './api-paths.js';
+export type { ChatTransportConfig, ChatEndpointName } from './api-paths.js';
+export type { ActionEnrichmentContext, BackendRequestMeta, InjectorAdapter, ProcessActionRequest, StreamCallbacks, } from './transport.js';
+export { AccountRuntimeConfigSchema, UnknownActionPolicySchema, parseAccountRuntimeConfig, safeParseAccountRuntimeConfig, createDefaultAccountRuntimeConfig, } from './config-schema.js';
+export type { AccountRuntimeConfig, UnknownActionPolicy } from './config-schema.js';
+export { routeStreamAction } from './action-router.js';
+export type { HostActionHandlers, ActionRouterOptions } from './action-router.js';
+export { sanitizeHtml } from './safe-html.js';
+export { renderUISpecWithRegistry, defaultUnknownUISpecRenderer } from './renderer/index.js';
+export { mergeUISpecRegistry } from './renderer/index.js';
+export type { UISpecRenderHelpers, UISpecRendererOverrides, UISpecDomComponentRenderParams, UISpecDomComponentRenderer, UISpecDomRegistry, UISpecDomUnknownRendererParams, UISpecDomUnknownRenderer, RenderUISpecWithRegistryOptions, } from './renderer/index.js';
+export { BASE_WIDGET_THEME, withBaseTheme } from './theme-utils.js';
+export { DEFAULT_WIDGET_THEME_TOKENS, withDefaultWidgetTheme } from './ui-theme.js';
+export { registerGlobalErrorToastListener, showGlobalErrorToast, dismissGlobalErrorToast, getGlobalErrorMessage, } from './global-error-toast.js';
+export { trackConnectionWarningRequest, configureConnectionWarning } from './connection-warning.js';
+export type { ConnectionWarningRequestOptions } from './connection-warning.js';
+export { DEFAULT_CUSTOMIZATION_LOCALE, createAccountIdentity, createFloatingChatConfig, createPdpQnaConfig, createPdpSimRelConfig, } from './customization-factories.js';
+export type { AccountIdentityConfig, AccountIdentity } from './customization-factories.js';
+export { initGengageClient } from './client.js';
+export type { GengageClientOptions, HostActions } from './client.js';
+export { preflightDiagnostics } from './preflight.js';
+export type { PreflightResult, PreflightWarning } from './preflight.js';
+export { adaptBackendEvent, productToNormalized, normalizeSimilarProductsResponse, normalizeProductGroupingsResponse, } from './protocol-adapter.js';
+export { wireGADataLayer } from './ga-datalayer.js';
+export { isVoiceInputSupported, VoiceInput } from './voice-input.js';
+export type { VoiceInputState, VoiceInputErrorCode, VoiceInputCallbacks, VoiceInputOptions } from './voice-input.js';
+export { detectPageType, extractSkuFromUrl, autoDetectPageContext } from './page-detect.js';
+export type { DetectablePageType, PageDetectionRule } from './page-detect.js';
+export type { NormalizedProduct, SimilarProductsJsonResponse, ProductGroupingsJsonResponse, } from './protocol-adapter.js';
+export { getSuggestedSearchKeywords, getSuggestedSearchKeywordsText } from './suggested-search-keywords.js';
+export type { SuggestedSearchKeywordSource } from './suggested-search-keywords.js';
+export { detectFastIntent } from './fastIntent.js';
+export { makePillLauncher } from './pill-launcher.js';
+export type { PillLauncherOptions, PillLauncherKit } from './pill-launcher.js';

package/dist/common/indexed-db.d.ts

@@ -0,0 +1,89 @@
+/**
+ * IndexedDB persistence for chat sessions, backend context, and message payloads.
+ *
+ * Three stores:
+ *   - `sessions`  — full session state (messages, thread cursors, timestamps)
+ *   - `context`   — per-thread backend context snapshots (compound key)
+ *   - `payload`   — message UISpec payloads (lean message pattern)
+ *
+ * All operations are best-effort: IndexedDB unavailability is non-fatal.
+ */
+import type { SerializableChatMessage } from '../chat/types.js';
+import type { UISpec } from './types.js';
+export interface SessionData {
+    userId: string;
+    appId: string;
+    sessionId: string;
+    messages: SerializableChatMessage[];
+    currentThreadId: string | null;
+    lastThreadId: string | null;
+    createdAt: string;
+    /** Thread IDs that produced panel content, in creation order. */
+    panelThreads?: string[] | undefined;
+    /** Legacy thumbnail-strip data kept optional for backward compatibility with older sessions. */
+    thumbnailEntries?: Array<{
+        sku: string;
+        imageUrl: string;
+        threadId: string;
+    }> | undefined;
+    /** Serialized panel HTML keyed by bot message ID (for panel snapshot restore). */
+    panelSnapshotHtml?: Record<string, string> | undefined;
+    /** Panel component type keyed by snapshot message ID. */
+    panelSnapshotTypes?: Record<string, string> | undefined;
+    /** Latest panel AI-zone UISpec keyed by thread ID. */
+    panelAiSpecByThread?: Record<string, UISpec> | undefined;
+    /** SKU active when session was saved — prevents cross-SKU restore. */
+    sku?: string | undefined;
+}
+export interface ContextData {
+    sessionId: string;
+    threadId: string;
+    context: import('./types.js').BackendContext;
+}
+export interface PayloadData {
+    threadId: string;
+    messageId: string;
+    uiSpec: UISpec;
+}
+export interface FavoriteData {
+    userId: string;
+    appId: string;
+    sku: string;
+    name?: string | undefined;
+    imageUrl?: string | undefined;
+    price?: string | undefined;
+    savedAt: string;
+}
+export declare class GengageIndexedDB {
+    private _db;
+    private _dbName;
+    private _version;
+    constructor(dbName?: string, version?: number);
+    open(): Promise<IDBDatabase>;
+    close(): void;
+    saveSession(data: SessionData): Promise<void>;
+    loadSession(userId: string, appId: string, sessionId: string): Promise<SessionData | null>;
+    saveContext(data: ContextData): Promise<void>;
+    loadContext(sessionId: string, threadId: string): Promise<ContextData | null>;
+    /**
+     * Delete all context entries for a session whose threadId is lexicographically
+     * greater than the given threadId. Used during rollback to prune future branches.
+     *
+     * Thread IDs are UUIDv7 (lexicographically sortable by time), so string
+     * comparison is sufficient.
+     */
+    deleteContextsAfterThread(sessionId: string, threadId: string): Promise<void>;
+    /**
+     * Load the most recent context for a session (latest threadId).
+     * Uses lexicographic ordering of UUIDv7 threadIds for chronological sort.
+     */
+    loadLatestContext(sessionId: string): Promise<ContextData | null>;
+    savePayload(data: PayloadData): Promise<void>;
+    loadPayload(threadId: string, messageId: string): Promise<PayloadData | null>;
+    loadPayloadsByThread(threadId: string): Promise<PayloadData[]>;
+    saveFavorite(data: FavoriteData): Promise<void>;
+    removeFavorite(userId: string, appId: string, sku: string): Promise<void>;
+    loadFavorites(userId: string, appId: string): Promise<FavoriteData[]>;
+    isFavorite(userId: string, appId: string, sku: string): Promise<boolean>;
+    private _requireDb;
+}

package/dist/common/locale.d.ts

@@ -0,0 +1 @@
+export declare function resolveLocaleTag(locale: string | null | undefined): string;