@marketrix.ai/widget 3.8.455 → 3.8.456

package/dist/src/hooks/useResize.d.ts

@@ -1,7 +1,5 @@
 export type ResizeCorner = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 export declare function useResize(settingsWidth: string | undefined, settingsHeight: string | undefined, workspaceId: string, isMinimized: boolean, isPreviewMode: boolean): {
-    width: number;
-    height: number;
     widthPx: string;
     heightPx: string;
     onResizeStart: (corner: ResizeCorner) => (e: React.MouseEvent) => void;

package/dist/src/hooks/useWidget.d.ts

@@ -1,32 +1,33 @@
-import type { ChatMessage, InstructionType, MarketrixConfig, WidgetSettingsData, WidgetState, WidgetView } from '../types';
+import type { MarketrixConfig, WidgetSettingsData, WidgetState } from '../types';
 export type ValidWidgetConfig = MarketrixConfig & Required<Pick<MarketrixConfig, keyof WidgetSettingsData>>;
 interface UseWidgetProps {
     config?: MarketrixConfig;
 }
-interface UseWidgetActions {
-    setActiveView: (view: WidgetView) => void;
-    toggleWidget: () => void;
-    closeWidget: () => void;
-    setMode: (mode: InstructionType) => void;
-    setLoading: (loading: boolean) => void;
-    setAgentAvailable: (available: boolean) => void;
-    setError: (error: string | undefined) => void;
-    clearError: () => void;
-    setTaskState: (payload: {
-        activeTaskId: string | null;
-        isTaskRunning: boolean;
-    }) => void;
-    addMessage: (message: ChatMessage) => void;
-    updateMessage: (messageId: string, updates: Partial<ChatMessage>) => void;
-    removeMessage: (messageId: string) => void;
-    setMessages: (messages: ChatMessage[]) => void;
-    stopTask: () => Promise<void>;
-    clearChatHistory: () => void;
-    messageDispatch: (content: string, mode?: InstructionType, skipUserMessage?: boolean) => Promise<void>;
-}
 export declare const useWidget: ({ config }?: UseWidgetProps) => {
     state: WidgetState;
-    actions: UseWidgetActions;
+    actions: {
+        clearChatHistory: () => void;
+        addMessage: (message: import("..").ChatMessage) => void;
+        updateMessage: (messageId: string, updates: Partial<import("..").ChatMessage>) => void;
+        removeMessage: (messageId: string) => void;
+        setMessages: (messages: import("..").ChatMessage[]) => void;
+        clearMessages: () => void;
+        messageDispatch: (content: string, mode?: import("..").InstructionType, skipUserMessage?: boolean) => Promise<void>;
+        setTaskState: (payload: {
+            activeTaskId: string | null;
+            isTaskRunning: boolean;
+        }) => void;
+        stopTask: () => Promise<void>;
+        setActiveView: (view: import("../types").WidgetView) => void;
+        toggleWidget: () => void;
+        closeWidget: () => void;
+        setMode: (mode: import("..").InstructionType) => void;
+        setLoading: (loading: boolean) => void;
+        setAgentAvailable: (available: boolean) => void;
+        setError: (error: string | undefined) => void;
+        clearError: () => void;
+        applyState: (payload: Partial<import("../context/UIStateContext").UIState>) => void;
+    };
     config: ValidWidgetConfig;
     shouldShow: boolean;
     isPreviewMode: boolean;

package/dist/src/services/ApiService.d.ts

@@ -1,4 +1,3 @@
 import type { MarketrixConfig, MessageDispatchRequest } from '../types';
-export declare function getChatId(): string | null;
 /** Fire-and-forget send over the typed stream; the reply arrives asynchronously as a chat/response event. */
 export declare function messageDispatch(config: MarketrixConfig, request: MessageDispatchRequest): Promise<void>;

package/dist/src/services/BrowserToolService.d.ts

@@ -74,7 +74,6 @@ export interface ExtractParams {
 }
 export declare class BrowserToolService {
     executeTool(browserToolName: string, args: Record<string, unknown>, mode?: string, explanation?: string): Promise<ToolExecutionResult<unknown>>;
-    private requiresHighlight;
     private navigate;
     private search;
     private clickElement;

package/dist/src/services/ChatService.d.ts

@@ -1,19 +1,7 @@
 import type { ChatMessage, InstructionType } from '../types';
-export interface ChatSnapshot {
-    messages: ChatMessage[];
-    isTaskRunning: boolean;
-    activeTaskId: string | null;
-    currentMode: InstructionType;
-    isOpen: boolean;
-    isMinimized: boolean;
-    isLoading: boolean;
-}
+import { type ChatSnapshot } from './StorageService';
 export declare class ChatService {
-    private chatId;
-    initError: Error | null;
-    initialize(chatId: string | null): void;
-    createInitialContext(chatId: string): void;
-    getInitError(): Error | null;
+    private restored;
     restore(): ChatSnapshot;
     persist(snapshot: ChatSnapshot): void;
 }

package/dist/src/services/ChatSessionManager.d.ts

@@ -1,13 +1,8 @@
 declare class ChatSessionManager {
-    private chatId;
-    private initializationPromise;
-    constructor();
-    getChatId(): string | null;
-    /** Promise-based lock: concurrent callers all await the same creation promise. */
+    private creation;
+    /** Promise-based lock: concurrent callers all await the same creation. */
     getOrCreateChatId(): Promise<string>;
     private createChatId;
-    private getStoredChatId;
-    private storeChatId;
 }
 export declare const chatSessionManager: ChatSessionManager;
 export {};

package/dist/src/services/DomService.d.ts

@@ -25,14 +25,13 @@ export declare class DomService {
     private generateFingerprint;
     private matchesFingerprint;
     private validateElementAtIndex;
-    indexInteractableElements(): Array<[number, Element]>;
+    private indexInteractableElements;
     private getElementCoordinates;
     private isStackingContext;
     private calculateGlobalZOrder;
     getSnapshotHtml(): string;
     getSequenceForElement(element: Element): number | undefined;
-    clearIndex(): void;
-    private checkInteractability;
+    private clearIndex;
     checkElementInteractable(element: HTMLElement, index: number): string | null;
     getValidatedElement(index: number): ValidatedElementResult;
 }

package/dist/src/services/ShowModeService.d.ts

@@ -14,12 +14,12 @@ export declare class ShowModeService {
     private rejectPromise;
     private clickHandler;
     private scrollHandler;
-    private updateHighlightPosition;
-    private rafId;
     private mutationObserver;
     private visibilityCheckInterval;
     showToolAction(options: ShowModeOptions): Promise<boolean>;
     cleanup(): void;
+    /** Detach both settlers before calling one — the click handler, the Continue button and the two watchdogs race. */
+    private takeSettlers;
     private createHighlight;
     private createPopup;
     private setupPositionUpdates;

package/dist/src/services/StorageService.d.ts

@@ -1,33 +1,32 @@
 import type { ChatMessage, InstructionType, MarketrixConfig } from '../types';
-type StoredMessage = Omit<ChatMessage, 'videoStream' | 'timestamp'> & {
+export type StoredMessage = Omit<ChatMessage, 'videoStream' | 'timestamp'> & {
     timestamp: string;
 };
-export interface MarketrixChatContext {
-    chat_id: string | null;
-    messages: StoredMessage[];
+/** The live half of the persisted context: exactly what the widget's three React stores hold between them. */
+export interface ChatSnapshot {
+    messages: ChatMessage[];
     isTaskRunning: boolean;
     activeTaskId: string | null;
     currentMode: InstructionType;
     isOpen: boolean;
     isMinimized: boolean;
     isLoading: boolean;
+}
+export type MarketrixChatContext = Omit<ChatSnapshot, 'messages'> & {
+    chat_id: string | null;
+    messages: StoredMessage[];
     config: MarketrixConfig | null;
     timestamp: number;
-}
+};
 declare class StorageService {
     private context;
-    constructor();
-    private loadContext;
-    private saveContext;
     getContext(): MarketrixChatContext;
     updateContext(updates: Partial<MarketrixChatContext>): void;
-    private isValidChatId;
-    /** window.name takes priority over localStorage — it persists across page navigations. */
+    /** window.name takes priority over localStorage — it is what survives host-page navigation. */
     getChatId(): string | null;
-    setChatId(chatId: string | null): void;
+    setChatId(chatId: string): void;
     getConfig(): MarketrixConfig | null;
-    setConfig(config: MarketrixConfig | null): void;
-    hasValidContext(): boolean;
+    setConfig(config: MarketrixConfig): void;
 }
 export declare const storageService: StorageService;
 export {};

package/dist/src/services/StreamClient.d.ts

@@ -17,7 +17,6 @@ export declare class StreamClient {
     private reconnectDelay;
     private readonly maxReconnectDelay;
     private reconnectTimer;
-    private config?;
     private connectionId;
     private readonly tabId;
     private registrationWaiters;
@@ -27,11 +26,7 @@ export declare class StreamClient {
     removeCallbacks(callbacks: StreamClientCallbacks): void;
     isConnected(): boolean;
     waitUntilRegistered(): Promise<void>;
-    connect(chatId: string, config?: {
-        mtxId?: string;
-        mtxKey?: string;
-        mtxApp?: number;
-    }): Promise<void>;
+    connect(chatId: string): Promise<void>;
     private consumeEvents;
     disconnect(): void;
     send(command: WidgetCommand): Promise<void>;

package/dist/src/services/WidgetService.d.ts

@@ -1,2 +1,6 @@
+import { type WidgetSettingsData } from '../sdk';
 import type { MarketrixConfig } from '../types';
+export declare function createConfigFromSettings(widgetSettings: WidgetSettingsData, baseConfig?: Partial<MarketrixConfig>): MarketrixConfig;
+/** Per-tenant scope for browser-local keys: the credential id, else the application id. */
+export declare function tenantScope(config: MarketrixConfig): string;
 export declare function loadWidgetConfig(config: MarketrixConfig): Promise<MarketrixConfig>;

package/dist/src/utils/bootstrap.d.ts

@@ -1,20 +1,18 @@
 import { type Root } from 'react-dom/client';
 import type { MarketrixConfig } from '../types';
+export declare const widgetState: {
+    instance: Root | null;
+    config: MarketrixConfig | null;
+    programmaticInit: boolean;
+};
 export declare const createWidgetContainer: (parentContainer?: HTMLElement, containerId?: string) => {
     container: HTMLElement;
     shadowRoot: ShadowRoot;
     mountEl: HTMLElement;
 };
 export declare const mountWidgetToContainer: (mountEl: HTMLElement, config: MarketrixConfig, previewMode?: boolean) => Root;
-export declare const destroyWidgetContainer: (container: HTMLElement) => void;
-export declare const getWidgetInstance: () => Root | null;
-export declare const setWidgetInstance: (instance: Root | null) => void;
-export declare const getCurrentConfig: () => MarketrixConfig | null;
-export declare const setCurrentConfig: (config: MarketrixConfig | null) => void;
 export declare const isWidgetInitialized: () => boolean;
-export declare const clearWidgetState: () => void;
-export declare const setProgrammaticInitInProgress: (inProgress: boolean) => void;
-export declare const isProgrammaticInitInProgress: () => boolean;
+export declare const getCurrentConfig: () => MarketrixConfig | null;
 export declare const showWidgetSettingsLoader: (message?: string) => void;
 export declare const hideWidgetSettingsLoader: () => void;
 export declare const autoInitializeWidget: () => void;

package/dist/src/utils/chat.d.ts

@@ -9,7 +9,8 @@ export interface FindMessageOptions {
     currentMode: InstructionType;
     requireContent?: boolean;
 }
-export declare function findMessageForProgress(options: FindMessageOptions): {
+/** Ranked predicates: the first rank matching anything wins, and within it the newest message. */
+export declare function findMessageForProgress({ messages, isTaskRunning, currentMode, requireContent, }: FindMessageOptions): {
     index: number;
     message: ChatMessage;
 } | null;

package/dist/src/utils/widgetPositioning.d.ts

@@ -1,5 +1,23 @@
 import type React from 'react';
 import type { WidgetPosition } from '../types';
+export declare const getCorner: (position: WidgetPosition) => {
+    readonly classes: "bottom-5 right-5";
+    readonly vertical: "bottom";
+    readonly horizontal: "right";
+} | {
+    readonly classes: "bottom-5 left-5";
+    readonly vertical: "bottom";
+    readonly horizontal: "left";
+} | {
+    readonly classes: "top-5 right-5";
+    readonly vertical: "top";
+    readonly horizontal: "right";
+} | {
+    readonly classes: "top-5 left-5";
+    readonly vertical: "top";
+    readonly horizontal: "left";
+};
+export declare const isWidgetPosition: (value: unknown) => value is WidgetPosition;
 export declare const getPositionClasses: (position: WidgetPosition) => string;
 export declare const getPanelPositionStyle: (position: WidgetPosition) => React.CSSProperties;
 export declare const getAnchorTopLeft: (position: WidgetPosition, vw: number, vh: number, w: number, h: number) => {