@marketrix.ai/widget 3.8.495 → 3.8.497

package/dist/src/components/base/LiveDot.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `LiveDot` — the ping/core span pair that keys `index.css`'s `mtx-live-dot*` rules, the pulsing dot the
+ * header's screen-share button and a video message's "Live" pill both wear. The markup contract is fixed
+ * by the CSS (an `mtx-live-dot` wrapper around an `mtx-live-dot-ping` and an `mtx-live-dot-core`); only
+ * `style` on the wrapper varies per caller (positioning it absolutely over an icon, or tinting it via
+ * `currentColor`).
+ */
+import type { CSSProperties } from 'react';
+export declare function LiveDot({ style }: {
+    style?: CSSProperties;
+}): import("react").JSX.Element;

package/dist/src/components/base/Surface.d.ts

@@ -6,6 +6,11 @@
  * tables — the `default`/`none` entries are empty, so a bare `Surface` is a plain element — and
  * `SurfaceProps` the prop surface: `LayoutProps` plus the host element's HTML attributes.
  *
+ * `floatingCard` is a `variant` shorthand for the card-background/border/card-elevation/card-padding/xl-
+ * rounded/margin bundle both `HomeView`'s recent-conversation card and `ChatView`'s composer card use —
+ * the margin lives in `variantStyles` since both call sites want it, while `ChatView`'s extra
+ * `marginTop: 'auto'` stays an override on its own `style` prop rather than joining the preset.
+ *
  * `className` is dropped from those attributes and re-declared because it is INTERNAL to `blocks/`:
  * layout props are the styling API everywhere else, and the only legitimate classes are the
  * `index.css` hooks the block components key on.
@@ -21,13 +26,16 @@
 import { type ElementType } from 'react';
 import { type ShadowToken } from '../../design-system/component-tokens';
 import { type LayoutProps } from './layoutProps';
-export type SurfaceBackground = 'default' | 'card';
-export type SurfacePadding = 'none' | 'card' | 'toast';
+type SurfaceBackground = 'default' | 'card';
+type SurfacePadding = 'none' | 'card' | 'toast';
+type SurfaceVariant = 'floatingCard';
 export interface SurfaceProps extends LayoutProps, Omit<React.HTMLAttributes<HTMLElement>, 'className'> {
     as?: ElementType;
     background?: SurfaceBackground;
     elevation?: ShadowToken;
     paddingPreset?: SurfacePadding;
+    variant?: SurfaceVariant;
     className?: string;
 }
 export declare const Surface: import("react").ForwardRefExoticComponent<SurfaceProps & import("react").RefAttributes<HTMLElement>>;
+export {};

package/dist/src/components/base/icons.d.ts

@@ -14,7 +14,7 @@
  * literal union of the keys, and `satisfies` fails a malformed entry at compile time without widening the
  * value type. The bundle is a single chunk, so every entry here is unconditional weight in each host page.
  */
-export interface IconPath {
+interface IconPath {
     d: string;
     fill?: string;
     stroke?: string;
@@ -130,3 +130,4 @@ export declare const icons: {
     };
 };
 export type IconName = keyof typeof icons;
+export {};

package/dist/src/components/base/layoutProps.d.ts

@@ -17,10 +17,15 @@
  * `LAYOUT_KEYS` must list every key of `LayoutProps`: `stripLayoutProps` filters by that set, so a
  * layout prop missing from it reaches the DOM as an unknown attribute. `as` and `style` are in it
  * because the consuming component (`Surface`) applies them itself rather than forwarding them.
+ *
+ * `withClass(base, extra)` appends an optional caller `className` to a component's fixed base class
+ * (`Button`, `Icon`, `Avatar`). It is NOT the banned `cn()`: there is no variant list to merge or
+ * dedup, just a plain conditional concat of one fixed string and one optional string — variants stay
+ * on `data-*` attributes per the styling rule in `../../../CLAUDE.md`.
  */
 import type { CSSProperties, ElementType } from 'react';
 import { type RadiusToken } from '../../design-system/component-tokens';
-export type SpacingToken = 'none' | '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+type SpacingToken = 'none' | '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
 export declare const SPACING_SCALE: Record<SpacingToken, string>;
 declare const ALIGN: {
     readonly start: "flex-start";
@@ -60,6 +65,7 @@ export interface LayoutProps {
     width?: 'full' | 'auto';
     height?: 'full' | 'auto';
     minWidth?: '0';
+    minHeight?: '0';
     border?: boolean | keyof typeof BORDER_SIDE;
     rounded?: boolean | RadiusToken;
     animate?: 'spin' | 'ping' | 'pulse' | 'fadeIn' | 'none';
@@ -69,4 +75,5 @@ export interface LayoutProps {
 }
 export declare function resolveLayoutStyle(props: LayoutProps): CSSProperties;
 export declare function stripLayoutProps<T extends LayoutProps>(props: T): Omit<T, keyof LayoutProps>;
+export declare const withClass: (base: string, extra?: string) => string;
 export {};

package/dist/src/components/blocks/Notifications.d.ts

@@ -1,33 +1,10 @@
-/**
- * The widget's one notification surface: a Base UI Toast provider, the toast renderer, and the effect
- * that drives toasts from widget state. Base UI owns the live region, the dismiss timers, hover-to-pause
- * and stacking; before this the widget announced nothing to a screen reader and ran its own setTimeout.
- *
- * `NotificationList` renders every live toast and stays a component of its own because `useToastManager`
- * only resolves inside `Toast.Provider`; both text lines truncate through `Text`'s own prop, a toast
- * carrying an action lets its title wrap instead, and a toast's `type` is a free string in Base UI, so it
- * is narrowed inline to the three tones `notificationToneStyles` understands, anything else falling back
- * to `neutral`. `NotificationProvider` wraps the provider, portal and viewport — `container` is the
- * widget's CLOSED shadow root, since portalling to `document.body` instead would leave the injected
- * styles behind, and `offsetBottom` raises the viewport above the launcher when the launcher also sits
- * at the bottom, so the two cannot overlap. `useNotifications` re-exports Base UI's toast manager as the
- * one door for adding and closing toasts.
- *
- * `WidgetNotifications` renders nothing; it mirrors the `error` and `greeting` props into toasts and
- * closes them when the prop clears. Both use a STABLE id, so `add` upserts and a re-render cannot stack
- * duplicates of the same condition. The error toast carries `timeout: 0` — it stays until acted on
- * (dismissed or retried); only the greeting is transient.
- */
-import { Toast } from '@base-ui/react/toast';
 import React from 'react';
-export declare const GREETING_TIMEOUT_MS = 8000;
 export interface NotificationProviderProps {
     children?: React.ReactNode;
     container?: HTMLElement | null;
     offsetBottom?: number;
 }
 export declare const NotificationProvider: React.FC<NotificationProviderProps>;
-export declare const useNotifications: typeof Toast.useToastManager;
 export interface WidgetNotificationsProps {
     error?: string;
     onClearError: () => void;

package/dist/src/components/chat/MessageItem.d.ts

@@ -15,7 +15,6 @@ import React from 'react';
 import type { ChatMessage } from '../../types';
 interface MessageItemProps {
     message: ChatMessage;
-    index: number;
     isLastMessage: boolean;
     onScreenAccessAllow?: () => void;
     onScreenAccessDeny?: () => void;

package/dist/src/context/ChatContext.d.ts

@@ -21,7 +21,7 @@
 import React from 'react';
 import type { ChatMessage, InstructionType } from '../types';
 import { type TaskState } from './sseReducer';
-export interface ChatActions {
+interface ChatActions {
     addMessage: (message: ChatMessage) => void;
     updateMessage: (messageId: string, updates: Partial<ChatMessage>) => void;
     removeMessage: (messageId: string) => void;
@@ -29,7 +29,7 @@ export interface ChatActions {
     clearMessages: () => void;
     messageDispatch: (content: string, mode?: InstructionType, skipUserMessage?: boolean) => Promise<void>;
 }
-export interface TaskActions {
+interface TaskActions {
     resetTask: () => void;
     stopTask: () => Promise<void>;
 }

package/dist/src/context/UIStateContext.d.ts

@@ -11,7 +11,7 @@ export interface UIState {
     currentMode: InstructionType;
     error?: string;
 }
-export interface UIStateActions {
+interface UIStateActions {
     setActiveView: (view: WidgetView) => void;
     toggleWidget: () => void;
     closeWidget: () => void;

package/dist/src/context/sseReducer.d.ts

@@ -20,7 +20,7 @@
  */
 import type { WidgetEvent } from '../sdk';
 import { type ChatMessage, type InstructionType } from '../types';
-export type TaskPhase = 'idle' | 'running' | 'stopped';
+type TaskPhase = 'idle' | 'running' | 'stopped';
 export interface TaskState {
     phase: TaskPhase;
     mode?: InstructionType;
@@ -37,7 +37,7 @@ export interface SseEffect {
     mode: InstructionType;
     explanation: string;
 }
-export interface ReduceResult {
+interface ReduceResult {
     state: SseState;
     effects: SseEffect[];
 }

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

@@ -2,11 +2,12 @@
  * Focus trap for the messenger panel: while `isActive`, focus starts inside `containerRef`, Tab cycles
  * within it, Escape calls `onEscape`, and on deactivation focus returns to whatever held it before.
  *
- * The tabbable-candidate query is `utils/dom`'s shared `TABBABLE_SELECTOR`; `activeElementIn` reads the
- * focused element as seen from a container's own root; `getFocusables` lists a container's visible tabbable elements; and
- * `useFocusTrap(containerRef, isActive, {onEscape, focusTargetRef})` focuses `focusTargetRef` (else the
- * first focusable), installs one capture-phase `keydown` listener on `document`, and restores focus on
- * the active→inactive edge.
+ * The tabbable candidates come from `utils/dom`'s shared `focusablesIn` (built on `TABBABLE_SELECTOR`,
+ * visibility and `aria-hidden` ancestry — the same filter `keySimulation`'s Tab simulation uses, so the
+ * widget's own tab order and the host page's can't re-diverge); `activeElementIn` reads the focused
+ * element as seen from a container's own root; and `useFocusTrap(containerRef, isActive, {onEscape,
+ * focusTargetRef})` focuses `focusTargetRef` (else the first focusable), installs one capture-phase
+ * `keydown` listener on `document`, and restores focus on the active→inactive edge.
  *
  * Inside the widget's closed shadow root `document.activeElement` retargets to the HOST, never naming
  * an element of the widget's own tree; `activeElementIn` reads through `container.getRootNode()`
@@ -16,7 +17,7 @@
  * the customer's page. Both key arms bail unless focus is currently inside the container, since the
  * listener sits on `document` ahead of host-page handlers and an unguarded Escape would close the
  * widget mid-typing. Tab `preventDefault`s only at the two ends; `previousActiveRef` edge-triggers the
- * restore once on close, and `getFocusables` drops hidden/`aria-hidden` elements the selector can't express.
+ * restore once on close.
  */
 export declare function useFocusTrap(containerRef: React.RefObject<HTMLElement | null>, isActive: boolean, options?: {
     onEscape?: () => void;

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

@@ -1,5 +1,5 @@
-import type { WidgetPosition } from '../types';
-export declare function useResize(settingsWidth: string | undefined, settingsHeight: string | undefined, position: WidgetPosition, tenantScope: string, isPreviewMode: boolean): {
+import type { MarketrixConfig, WidgetPosition } from '../types';
+export declare function useResize(settingsWidth: string | undefined, settingsHeight: string | undefined, position: WidgetPosition, config: MarketrixConfig, isPreviewMode: boolean): {
     widthPx: string;
     heightPx: string;
     grip: {

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

@@ -16,7 +16,7 @@
  * at. `notInteractableReason`'s `document.body.contains` check must stay first: ShowModeService uses it as its
  * removal watchdog and keeps no identity snapshot of its own.
  */
-export interface ValidatedElementResult {
+interface ValidatedElementResult {
     element: HTMLElement | null;
     error?: string;
 }
@@ -31,3 +31,4 @@ export declare class DomService {
     getValidatedElement(index: number): ValidatedElementResult;
 }
 export declare const domService: DomService;
+export {};

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

@@ -18,7 +18,7 @@
  * placement takes the first of right/left/above/below that fits then clamps, its 120px height an assumption,
  * and the watchdog tests `document.body.contains` first, covering removal as well as occlusion.
  */
-export interface ShowModeOptions {
+interface ShowModeOptions {
     element: HTMLElement;
     explanation: string;
     browserToolName: string;
@@ -49,3 +49,4 @@ export declare class ShowModeService {
     private escapeHtml;
 }
 export declare const showModeService: ShowModeService;
+export {};

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

@@ -17,9 +17,12 @@
  * The snapshot is `{messages, currentMode, isOpen}` — chat_id, config and timestamp are deliberately excluded.
  * Reading revives `timestamp` to a `Date` and backfills a text part for messages stored before `parts` existed;
  * writing drops `videoStream` (unserializable, dead on reload), rewriting it as `Screen sharing ended`.
+ *
+ * `scopedKey(name, config)` is the one place `<name>_<tenantScope>` is assembled — the position and resize-size
+ * keys share it with the chat context key, so all three browser-local entries partition by tenant identically.
  */
 import type { ChatMessage, InstructionType, MarketrixConfig, ValidWidgetConfig } from '../types';
-export type StoredMessage = Omit<ChatMessage, 'videoStream' | 'timestamp'> & {
+type StoredMessage = Omit<ChatMessage, 'videoStream' | 'timestamp'> & {
     timestamp: string;
 };
 export interface ChatSnapshot {
@@ -31,13 +34,14 @@ export type CredentialedConfig = ValidWidgetConfig & {
     mtxId: string;
     mtxKey: string;
 };
-export type MarketrixChatContext = Omit<ChatSnapshot, 'messages'> & {
+type MarketrixChatContext = Omit<ChatSnapshot, 'messages'> & {
     chat_id: string | null;
     messages: StoredMessage[];
     config: MarketrixConfig | null;
     timestamp: number;
 };
 export declare function tenantScope(config: MarketrixConfig): string;
+export declare function scopedKey(name: string, config: MarketrixConfig): string;
 export declare function readLocal(key: string): string | null;
 export declare function writeLocal(key: string, value: string): void;
 declare class StorageService {

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

@@ -21,7 +21,7 @@
 import { type WidgetCommand, type WidgetEvent } from '../sdk';
 export declare class StreamGaveUpError extends Error {
 }
-export interface StreamClientCallbacks {
+interface StreamClientCallbacks {
     onMessage?: (event: WidgetEvent) => void;
     onError?: (error: Error) => void;
 }
@@ -62,3 +62,4 @@ export declare class StreamClient {
     private clearReconnectTimer;
 }
 export declare const streamClient: StreamClient;
+export {};

package/dist/src/test/fixtures.d.ts

@@ -1,15 +1,8 @@
-/**
- * The shared widget-settings fixture the config-driven tests build from: `getMockWidgetConfig(overrides)`
- * returns a complete, schema-valid tenant config — every rendered setting plus the `mtxId`/`mtxKey` credential,
- * api host and preview flag a mounted widget needs — shallow-merged with `overrides`.
- *
- * `MockWidgetConfig` widens `ValidWidgetConfig` with the four render constants (`widget_border_radius`,
- * `widget_font_size`, `widget_animation_duration`, `widget_fade_duration`). `ValidWidgetConfig` is built on
- * `WidgetRenderedSettings`, which omits them, but callers hand this fixture straight to
- * `WidgetSettingsDataSchema.parse()`, which demands the whole wire shape. It is `Valid`, not partial, so
- * `renderWidget` can hand it to `WidgetRoot` without a cast — the fixture really does set every field.
- */
-import type { ValidWidgetConfig, WidgetSettingsData } from '../types';
+import type { ChatMessage, ValidWidgetConfig, WidgetSettingsData } from '../types';
+export declare const flushMicrotasks: () => Promise<void>;
+export declare const mountTarget: () => HTMLDivElement;
+export declare function agentMessage(overrides?: Partial<ChatMessage>): ChatMessage;
 type MockWidgetConfig = ValidWidgetConfig & Pick<WidgetSettingsData, 'widget_border_radius' | 'widget_font_size' | 'widget_animation_duration' | 'widget_fade_duration'>;
 export declare function getMockWidgetConfig(overrides?: Partial<MockWidgetConfig>): MockWidgetConfig;
+export declare function validSettings(overrides?: Partial<MockWidgetConfig>): WidgetSettingsData;
 export {};

package/dist/src/test/setup.d.ts

@@ -11,5 +11,10 @@
  *
  * Every fill is conditional, so a real implementation — a future jsdom, or a per-test override
  * installed before this file — wins.
+ *
+ * `resetDom` is the shared body-clearing helper for tests that mount outside Testing Library's own
+ * render tree (so RTL's automatic per-test cleanup does not reach them) — `replaceChildren()` over
+ * `innerHTML = ''` avoids re-parsing a fresh, empty document fragment on every reset.
  */
 import '@testing-library/jest-dom/vitest';
+export declare function resetDom(): void;

package/dist/src/types/index.d.ts

@@ -34,7 +34,7 @@ export type MarketrixConfig = Partial<WidgetRenderedSettings> & ClientOwnedConfi
     mtxApp?: number;
     isPreviewMode?: boolean;
 };
-export type ValidWidgetConfig = MarketrixConfig & Required<Pick<MarketrixConfig, keyof WidgetRenderedSettings>>;
+export type ValidWidgetConfig = MarketrixConfig & Required<Pick<MarketrixConfig, keyof WidgetRenderedSettings | 'isPreviewMode'>>;
 export interface ChatMessage {
     id: string;
     content: string;

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

@@ -1,7 +1,7 @@
 import { type Root } from 'react-dom/client';
 import type { NotificationTone } from '../design-system/component-tokens';
 import type { MarketrixConfig, ValidWidgetConfig } from '../types';
-export interface WidgetMount {
+interface WidgetMount {
     instance: Root;
     config: ValidWidgetConfig;
     container: HTMLElement;
@@ -22,3 +22,4 @@ export declare const getCurrentConfig: () => ValidWidgetConfig | null;
 export declare const showHostPageNotice: (message: string, tone?: NotificationTone) => void;
 export declare const hideHostPageNotice: () => void;
 export declare const autoInitializeWidget: (initWidget: (config: MarketrixConfig) => Promise<void>) => void;
+export {};

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

@@ -20,7 +20,7 @@
 import type { ChatMessage, InstructionType } from '../types';
 export declare const getModeDisplayName: (mode: InstructionType) => string;
 export declare const formatMessageTime: (date: Date | undefined) => string;
-export interface FindMessageOptions {
+interface FindMessageOptions {
     messages: ChatMessage[];
     isTaskRunning: boolean;
     currentMode: InstructionType;
@@ -40,3 +40,4 @@ export declare const SCREEN_ACCESS_PROMPT = "Can I take a look at your screen?";
 export declare const createScreenAccessRequestMessage: (mode: InstructionType | undefined, pendingContent?: string) => ChatMessage;
 export declare const createScreenshareMessage: (stream: MediaStream, mode?: InstructionType) => ChatMessage;
 export declare const createPlaceholderMessage: (mode: InstructionType) => ChatMessage;
+export {};

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

@@ -17,8 +17,16 @@
  * both chains are climbed. Its one `try` is deliberate — the host page owns this DOM and may have patched
  * anything on it, so a poisoned element is logged with the real error and skipped rather than aborting the
  * whole indexing pass.
+ *
+ * `focusablesIn` is the one home for "which `TABBABLE_SELECTOR` matches are actually reachable" —
+ * `useFocusTrap` (the widget's own tree) and `keySimulation`'s Tab simulation (the host page) both call
+ * it so they can't re-diverge. Per WAI-ARIA, `aria-hidden="true"` removes an element (and its whole
+ * subtree) from the accessibility tree, so it must not receive focus — `isAriaHidden` walks ancestors,
+ * not just the element itself, since a hidden container hides everything under it even though none of
+ * those descendants carry the attribute.
  */
 export declare const WIDGET_SHADOW_HOST_CLASS = "marketrix-widget-container";
 export declare const TABBABLE_SELECTOR = "a[href], button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex=\"-1\"])";
+export declare function focusablesIn(root: ParentNode): HTMLElement[];
 export declare function disabledReason(el: Element): string | null;
 export declare function isIndexable(el: Element | null): boolean;

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

@@ -23,7 +23,7 @@ export declare function isHTMLElement(element: Element | null): element is HTMLE
 export declare function isHTMLScriptElement(element: Element | null): element is HTMLScriptElement;
 declare const RENDER_CONSTANT_NAMES: readonly ["widget_border_radius", "widget_font_size", "widget_animation_duration", "widget_fade_duration"];
 export type WidgetRenderedSettings = Omit<WidgetSettingsData, (typeof RENDER_CONSTANT_NAMES)[number]>;
-export type WidgetSettingsResult = {
+type WidgetSettingsResult = {
     settings: WidgetRenderedSettings;
     invalidFields?: undefined;
 } | {

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

@@ -6,7 +6,7 @@
  * narrows an unknown — a value read back out of localStorage — to one of the four, testing a list of
  * names rather than `in CORNERS`, so the keys every object inherits (`toString`, `__proto__`) are
  * rejected. `getPanelPositionStyle` turns a corner into the inline style pinning an element to it.
- * `getResizeGrip`, whose return type is exported as `ResizeGrip`, describes the handle on the corner
+ * `getResizeGrip` describes the handle on the corner
  * diagonally OPPOSITE the pinned one — the panel grows away from its anchor, so that is the only
  * corner free to move; `growX`/`growY` are the signs converting pointer delta into size delta, and
  * `cursor` is the diagonal the grip itself lies on. `getAnchorTopLeft` resolves a corner to viewport
@@ -42,7 +42,6 @@ export declare const getResizeGrip: (position: WidgetPosition) => {
     growY: number;
     cursor: string;
 };
-export type ResizeGrip = ReturnType<typeof getResizeGrip>;
 export declare const getAnchorTopLeft: (position: WidgetPosition, vw: number, vh: number, w: number, h: number) => {
     x: number;
     y: number;