@gengage/assistant-fe 0.6.49 → 0.7.0

package/dist/chat/api.d.ts

@@ -1,6 +1,6 @@
 import type { ChatTransportConfig } from '../common/api-paths.js';
 import type { ActionEnrichmentContext, ProcessActionRequest, StreamCallbacks } from '../common/transport.js';
-export type { ActionEnrichmentContext, BackendRequestMeta, InjectorAdapter, ProcessActionRequest, StreamCallbacks, } from '../common/transport.js';
+export type { ActionEnrichmentContext, BackendRequestMeta, ProcessActionRequest, StreamCallbacks, } from '../common/transport.js';
 /**
  * Enriches action payloads with fields the backend expects.
  * Only adds fields that are not already present in the payload.

package/dist/chat/components/ChatDrawer.d.ts

@@ -148,6 +148,7 @@ export declare class ChatDrawer {
     private _beautyPhotoStepEl;
     private _cartToastEl;
     private _cartToastTimerId;
+    private _dragCloseTimerId;
     private _renderPhotoAnalysisCard;
     private _createLegacyHeaderPoweredBy;
     private _createFooterAttribution;
@@ -326,7 +327,6 @@ export declare class ChatDrawer {
     private _createLoadingSequence;
     private _applyLoadingSteps;
     private _normalizeLoadingSteps;
-    private _uniqueLoadingSteps;
     private _clearLoadingBindingInterval;
     private _destroyLoadingBinding;
     private _updateSendEnabled;
@@ -373,6 +373,8 @@ export declare class ChatDrawer {
     }>): void;
     /** Clear input-area chips. */
     clearInputAreaChips(): void;
+    /** Remove the active focus-trap keydown handler without restoring focus. */
+    private _detachTrapHandler;
     /** Activate focus trap — Tab/Shift+Tab cycles within the drawer. */
     trapFocus(): void;
     /** Release the focus trap and restore previously focused element. */

package/dist/chat/features/beauty-consulting/mode-controller.d.ts

@@ -40,7 +40,7 @@ export declare class AssistantModeController {
      * Returns true if the mode actually switched.
      */
     handleRedirect(redirectPayload: unknown): boolean;
-    /** Switch to a new assistant mode. */
+    /** Switch to a new assistant mode. No-op if already in that mode. */
     switchMode(mode: AssistantMode): void;
     /**
      * Derive mode and ui_hints from a backend CONTEXT panel payload.

package/dist/chat/features/beauty-consulting/stream-handler.d.ts

@@ -30,7 +30,13 @@ export interface BeautyStreamContext {
     ensureRendered: () => void;
     cancelTypewriter: () => void;
     sendSkipMessage: () => void;
-    streamDone: boolean;
+    /**
+     * Live getter for stream-completion state. Must be a getter (not a snapshot
+     * boolean) because the context is built early — while the stream is still
+     * open (streamDone === false) — but onSkip can fire after the stream finishes.
+     * A snapshot would always read false and silently drop the post-stream skip.
+     */
+    isStreamDone: () => boolean;
 }
 /**
  * Handle a beauty-specific UISpec component during stream processing.

package/dist/chat/history-storage.d.ts

@@ -1,4 +1,5 @@
 import type { BackendContext, UISpec } from '../common/types.js';
+import type { GengageIndexedDB } from '../common/indexed-db.js';
 import type { ChatMessage } from './types.js';
 import type { PanelSource } from './panel-manager.js';
 type LegacyThumbnailEntry = {
@@ -72,18 +73,49 @@ export interface SaveHistorySessionParams {
     sku?: string | undefined;
     attachmentPlaceholder?: string | undefined;
 }
+/**
+ * The chat-history archive (past chat sessions).
+ *
+ * Backed by IndexedDB so bulk history is NOT kept in the origin-shared
+ * localStorage. A lightweight index is hydrated into memory at init so the
+ * history panel can list sessions synchronously; full records are read lazily
+ * (async `loadSession`) and writes go through to IndexedDB behind a small mutex.
+ * Existing localStorage history is migrated into IndexedDB once, on `hydrate()`.
+ */
 export declare class ChatHistoryStorage {
     private readonly _appId;
     private readonly _userId;
-    private readonly _storage;
+    private readonly _db;
+    private readonly _localStorage;
     private readonly _scope;
-    constructor(_appId: string, _userId: string, _storage?: Storage | null);
+    /** Lightweight index, newest-first; the synchronous read surface. */
+    private _index;
+    private _hydrated;
+    /** Serializes write-through so concurrent saves/deletes don't race. */
+    private _writeChain;
+    constructor(_appId: string, _userId: string, _db: GengageIndexedDB | null, _localStorage?: Storage | null);
+    /**
+     * Migrate any legacy localStorage history into IndexedDB, then load the index
+     * into memory. Idempotent; safe to await once after the DB is open.
+     */
+    hydrate(): Promise<void>;
     createHistoryId(): string;
     findSessionId(sourceSessionId: string, createdAt: string): string | null;
     listSessions(): ChatHistoryIndexEntry[];
-    loadSession(historyId: string): ChatHistorySessionRecord | null;
+    /** Resolves once all queued write-through operations have settled. */
+    flush(): Promise<void>;
+    loadSession(historyId: string): Promise<ChatHistorySessionRecord | null>;
+    /**
+     * Build and persist a history record. The record is built synchronously (it
+     * reads live panel DOM) and the in-memory index is updated synchronously so
+     * callers see it immediately; the IndexedDB write happens asynchronously
+     * behind the write mutex. Returns the built record, or null when there is
+     * nothing worth saving / no backing store.
+     */
     saveSession(params: SaveHistorySessionParams): ChatHistorySessionRecord | null;
     deleteSession(historyId: string): void;
-    private _commitRecord;
+    /** Queue a best-effort IndexedDB write; failures are swallowed (persistence is best-effort). */
+    private _enqueueWrite;
+    private _migrateFromLocalStorage;
 }
 export {};

package/dist/chat/runtime.d.ts

@@ -86,6 +86,22 @@ export declare class GengageChat extends BaseWidget<ChatWidgetConfig> {
     private _pdpLaunched;
     private _plpLaunched;
     private _homepageLaunched;
+    /**
+     * True ONLY when this widget actually restored a non-empty thread that now owns the
+     * surface. When set, the generic page-context auto-launch (homepage/PLP greeting) is
+     * suppressed so the restored thread — and its in-flight continuation — are not
+     * clobbered by a "Merhaba!" welcome. See R1 (yataş store-finder nav clobber).
+     *
+     * INVARIANT (regression #1 fix): this flag is tied to ACTUAL restored on-screen
+     * content, never to mere restore-KEY presence. If a restore no-ops (stale/missing
+     * session, cross-SKU guard, IDB absent, empty thread, rejected freshness token) the
+     * flag stays/returns false so the NORMAL greeting/auto-launch fires — the surface is
+     * never left blank.
+     */
+    private _restorePending;
+    /** One-shot gate for an assistant-driven soft navigation update in the same document. */
+    private _assistantSoftNavigationPending;
+    private _assistantSoftNavigationTimer;
     private _entryContextPrimed;
     /** True while a silent context-prime launch (PDP/PLP/homepage) is in flight. */
     private _contextPrimingInFlight;
@@ -177,6 +193,42 @@ export declare class GengageChat extends BaseWidget<ChatWidgetConfig> {
     }): void;
     close(): void;
     saveSession(sessionId: string, sku: string): void;
+    /**
+     * Set the restore handoff marker for an assistant-driven PAGE navigation that has
+     * no associated product (R1, e.g. the store-finder redirect). Mirrors saveSession()
+     * but without a SKU — the destination is not a PDP, so there is nothing to gate the
+     * restore on. The restore session id alone tells the re-mounted widget "the chat
+     * navigated you here; restore the thread and continue, do not auto-launch a greeting".
+     *
+     * Only stamps the marker when there is a real session id to restore; otherwise it is
+     * a no-op (a user/site navigation should stay a fresh session).
+     */
+    saveSessionForNavigation(): void;
+    /** Read the persisted same-document nav sequence (0 when absent/corrupt). */
+    private _readNavSeq;
+    /**
+     * Stamp the freshness token onto the current restore marker: bump the nav seq and
+     * record it (with a timestamp) so the immediately-following mount can recognize this
+     * marker as fresh. Best-effort — non-fatal if sessionStorage is unavailable.
+     */
+    private _stampRestoreFreshnessToken;
+    /**
+     * True when the current restore marker was produced by the immediately-preceding
+     * navigation (its token's seq matches the current nav seq). A stale/stranded marker
+     * — or one with no/corrupt token (e.g. an empty-SKU saveSession) — is NOT fresh.
+     */
+    private _isRestoreMarkerFresh;
+    /**
+     * Clear the restore marker and its freshness token in one place — the single
+     * guaranteed-consume point so a marker never strands. Called on mount (onInit, after
+     * the freshness decision) and on any state reset (_resetForNewPage / soft-nav).
+     * Leaves gengage_nav_seq intact: it is the monotonic clock, not part of the marker.
+     */
+    private _clearRestoreMarker;
+    private _markAssistantSoftNavigationPending;
+    private _clearAssistantSoftNavigationPending;
+    private _expireAssistantSoftNavigationIfUnclaimed;
+    private _scheduleAssistantSoftNavigationExpiry;
     get isOpen(): boolean;
     /**
      * Register a callback for integration events (e.g. 'gengage-cart-add', 'gengage-product-favorite').
@@ -262,6 +314,7 @@ export declare class GengageChat extends BaseWidget<ChatWidgetConfig> {
     private _flushQueuedUserMessages;
     /** Apply ui_hints from the backend CONTEXT event — delegates to mode controller. */
     private _applyUiHints;
+    /** Returns true if the redirect actually switched the assistant mode. */
     private _handleRedirectMetadata;
     private _sendAction;
     /** Return messages visible at the current thread cursor. */
@@ -318,11 +371,10 @@ export declare class GengageChat extends BaseWidget<ChatWidgetConfig> {
     private _productNumber;
     /** Rewind the conversation to the given thread. */
     private _rollbackToThread;
-    private _persistHistoryToLocalStorage;
+    private _persistHistory;
     private _persistConversationState;
     private _persistConversationStateForNavigation;
     private _formatHistoryTimestamp;
-    private _resolvePanelRestorePreviewLabel;
     private _resolveHistoryPreviewText;
     private _openHistoryPanel;
     private _buildHistoryPageEl;
@@ -339,11 +391,29 @@ export declare class GengageChat extends BaseWidget<ChatWidgetConfig> {
     private _hasUnavailableProductContext;
     private _ensureAssistantMessageRendered;
     private _saveSessionAndOpenURL;
+    /**
+     * Assistant-driven page navigation (R1): persist the thread, stamp the restore
+     * handoff marker, then navigate. On the SPA re-mount the widget restores the thread
+     * and continues its flow — the homepage/PLP auto-launch greeting is suppressed
+     * (see _restorePending / _primeOpenPageContext) so the assistant's answer is not
+     * clobbered by a generic welcome. Same-origin only; cross-origin/new-tab callers
+     * keep the raw navigation since the current page (and its thread) is not replaced.
+     *
+     * The restore-key stamp is the durable "the chat initiated this navigation" marker
+     * across the navigation boundary — we distinguish assistant-vs-user navigation by
+     * WHO called this (an assistant action handler), never by inspecting the URL.
+     */
+    private _navigateAssistantDriven;
     private _loadPayload;
     /**
      * Attempt to restore chat session from IndexedDB.
-     * Always restores when IDB has session data for the current sessionId.
+     * Restores when IDB has non-empty session data for the current sessionId AND an
+     * explicit handoff is pending.
      * Best-effort — failures are silently ignored.
+     *
+     * @returns true ONLY when a non-empty thread was actually replayed onto the surface.
+     * Every no-op/early-return path returns false so the caller leaves the normal
+     * greeting/auto-launch enabled (regression #1: never suppress launch over nothing).
      */
     private _restoreFromIndexedDB;
     /**

package/dist/chat/utils/chat-presentation-debug.d.ts

@@ -1,18 +1,4 @@
 /**
  * Opt-in debug logging for chat presentation (query ?chat_debug=1 or localStorage gengage_chat_debug=1).
  */
-type Entry = {
-    seq: number;
-    time: string;
-    scope: string;
-    message: string;
-    payload?: unknown;
-};
-declare global {
-    interface Window {
-        __gengageChatPresentationDebugLog?: Entry[];
-        __gengageChatPresentationDebugSeq?: number;
-    }
-}
 export declare function logChatPresentation(scope: string, message: string, payload?: unknown): void;
-export {};

package/dist/chat-runtime.js

@@ -1,4 +1,4 @@
-import { c as e, d as t, f as r, i as s, l as n, n as i, r as l, s as C, t as c, u as d } from "./runtime-COLQGOkl.js";
+import { c as e, d as t, f as r, i as s, l as n, n as i, r as l, s as C, t as c, u as d } from "./runtime-BSIrZhF2.js";
 export {
   d as CHAT_SCROLL_ELEMENT_ID,
   s as ChatPresentationState,