@alxxsck/ai-assistant 2.22.3 → 2.24.0

package/dist/api/chat-attachments.api.d.ts

@@ -0,0 +1,36 @@
+import type { AppApi } from "@/App";
+import { type ChatAttachmentTransport } from "@/domain/message/chat-experience";
+import type { WidgetConfig } from "@/index.types";
+export declare const CHAT_ATTACHMENT_MAX_FILES = 10;
+export declare const CHAT_ATTACHMENT_MAX_BYTES: number;
+export declare const CHAT_ATTACHMENT_MAX_TOTAL_BYTES: number;
+export declare const CHAT_ATTACHMENT_CONTENT_TYPES: readonly ["application/pdf", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "application/vnd.openxmlformats-officedocument.presentationml.presentation", "image/jpeg", "image/png", "image/webp", "text/csv", "text/plain"];
+export declare const CHAT_ATTACHMENT_ACCEPT: string;
+type AttachmentContentType = (typeof CHAT_ATTACHMENT_CONTENT_TYPES)[number];
+export declare class ChatAttachmentApiError extends Error {
+    readonly code: string;
+    readonly status?: number | undefined;
+    constructor(code: string, status?: number | undefined);
+}
+export declare const validAttachmentDisplayFilename: (raw: string) => boolean;
+export declare const acceptedAttachmentContentType: (file: Pick<File, "name" | "type">) => AttachmentContentType | null;
+declare const abortableDelay: (durationMs: number, signal?: AbortSignal) => Promise<void>;
+export declare const sha256Hex: (file: Blob) => Promise<string>;
+declare const uploadPresignedFile: ({ file, requiredHeaders, signal, uploadUrl, onProgress, }: {
+    file: File;
+    requiredHeaders: Record<string, string>;
+    signal?: AbortSignal;
+    uploadUrl: string;
+    onProgress?: (progress: number) => void;
+}) => Promise<void>;
+type BackendTransportDependencies = {
+    fetchImpl?: typeof fetch;
+    uploadFile?: typeof uploadPresignedFile;
+    digest?: typeof sha256Hex;
+    wait?: typeof abortableDelay;
+    pollIntervalMs?: number;
+    maxPolls?: number;
+    createId?: () => string;
+};
+export declare const createBackendChatAttachmentTransport: (config: WidgetConfig, api: Pick<AppApi, "onSessionExpired">, dependencies?: BackendTransportDependencies) => ChatAttachmentTransport;
+export {};

package/dist/api/messages.api.d.ts

@@ -1,7 +1,7 @@
 import type { AppApi } from "@/App";
 import type { WidgetConfig } from "@/index.types";
 import { type ConversationData, type MessageData, type RawConversationData, type RawMessageData, type SendMessageResult } from "./messages.api.types";
-import type { ChatAttachment } from "@/domain/message/chat-experience";
+import { type ChatAttachment } from "@/domain/message/chat-experience";
 export declare const MAX_FETCH_MESSAGES = 100;
 export type CursorPage<T> = {
     items: T[];
@@ -28,6 +28,8 @@ export declare const normalizeMessageAuthorPresentation: (role: RawMessageData["
     presentationVersion: number | null;
     legacyAvatarUrl: string | null;
 }> | null;
+export declare const normalizeChatAttachment: (candidate: unknown) => ChatAttachment | null;
+export declare const normalizeChatAttachments: (values: readonly unknown[] | undefined) => ChatAttachment[];
 export declare const normalizeMessageForSession: (message: RawMessageData, interactionSessionId: string) => MessageData;
 export declare const listConversations: (config: WidgetConfig, api: AppApi, cursor?: string, signal?: AbortSignal) => Promise<VersionedCursorPage<ConversationData>>;
 export declare const listConversationMessages: (config: WidgetConfig, api: AppApi, conversationId: string, cursor?: string, signal?: AbortSignal) => Promise<CursorPage<MessageData>>;

package/dist/api/messages.api.types.d.ts

@@ -108,6 +108,19 @@ export type RawConversationData = Omit<ConversationData, "responderPresentation"
     responderPresentation?: unknown;
 };
 export type MessageRole = "USER" | "ASSISTANT" | "ADMIN" | "SCENARIO" | "SYSTEM";
+export type RawChatAttachment = {
+    id?: unknown;
+    displayFilename?: unknown;
+    contentType?: unknown;
+    sizeBytes?: unknown;
+    /** Compatibility fields for custom transports used before durable snapshots. */
+    fileName?: unknown;
+    mediaType?: unknown;
+    size?: unknown;
+    kind?: unknown;
+    downloadUrl?: unknown;
+    previewUrl?: unknown;
+};
 export type RawMessageData = {
     id: string;
     threadId: string;
@@ -119,7 +132,7 @@ export type RawMessageData = {
     ordinal?: number;
     clientMessageId?: string | null;
     author?: unknown;
-    attachments?: ChatAttachment[];
+    attachments?: unknown[];
     delivery?: MessageDelivery;
     createdAt: string;
     updatedAt: string;

package/dist/bridge-ai-chat-widget.es.js

@@ -1,8 +1,8 @@
-import { a1 as A, a2 as e, a4 as s, F as n, a3 as r } from "./index-BBsPIKJB.js";
+import { C as A, E as e, S as s, d as E, c } from "./index-WDFSbfaV.js";
 export {
   A as ChatWidgetInstance,
   e as EXTERNALLY_AVAILABLE_ACTIONS,
   s as SUPPORTED_LOCALES,
-  n as createMockAttachmentTransport,
-  r as isExternallyAvailableAction
+  E as createMockAttachmentTransport,
+  c as isExternallyAvailableAction
 };

package/dist/context/ChatWidgetContext.d.ts

@@ -1,12 +1,14 @@
 import type { AppApi } from "@/App";
 import type { Avatar } from "@/avatar/Avatar";
 import type { WidgetConfig } from "@/index.types";
-import type { CtaCommandContext } from "@/domain/command/command.types";
+import type { CtaActionExecutionResult, CtaCommandContext } from "@/domain/command/command.types";
 import type { SurfaceTransitionContext } from "@/domain/scenario-interaction/scenario-interaction.types";
+import { CompactPreviewController } from "@/domain/compact-preview/CompactPreviewController";
 type ChatWidgetContextValue = {
     open: boolean;
     setOpen: (v: boolean) => void;
     transitionSurface: (open: boolean, context: SurfaceTransitionContext) => void;
+    openCompactPreview: (context: SurfaceTransitionContext) => Promise<boolean> | null;
     surfaceEpisodeId: string | null;
     isFullscreen: boolean;
     setFullscreen: (fullscreen: boolean) => void;
@@ -31,8 +33,15 @@ type ChatWidgetContextValue = {
     ctaTelegramBotUsername: string | null;
     ctaTelegramDeepLink: string | null;
     ctaManualCommand: string | null;
-    executeCta: () => Promise<void>;
-    dismissCta: () => void;
+    hasUnreadCta: boolean;
+    compactPreviewController: CompactPreviewController;
+    getCtaPresentation: (commandId: string) => {
+        busy: boolean;
+        buttonLabel: string | null;
+        feedback: string | null;
+    };
+    executeCta: (commandId?: string, compactSurfaceEpisodeId?: string) => Promise<CtaActionExecutionResult>;
+    dismissCta: (commandId?: string, compactSurfaceEpisodeId?: string) => boolean;
 };
 export declare const ChatWidgetContextProvider: ({ children, config, api, }: {
     children: React.ReactNode;

package/dist/domain/command/CommandRuntime.d.ts

@@ -1,13 +1,13 @@
 import type { CustomerInteractionSession } from "@/types";
-import { type CommandAck, type CommandEnvelope, type CommandEventDetail, type CtaCommandContext, type HostCommandHandlerName, type HostCommandHandlers, type SpeakTextCommandContext, type StartVoiceConversationCommandContext, type UiTarget } from "./command.types";
+import { type CommandAck, type CommandEnvelope, type CommandEventDetail, type CtaActionExecutionResult, type CtaCommandContext, type HostCommandHandlerName, type HostCommandHandlers, type SpeakTextCommandContext, type StartVoiceConversationCommandContext, type UiTarget } from "./command.types";
 import type { ScenarioInteractionRuntime } from "@/domain/scenario-interaction/ScenarioInteractionRuntime";
 type AckSender = (ack: CommandAck) => Promise<unknown>;
 type InternalHandlers = {
     setAssistantVisible?: (visible: boolean, commandId: string) => void;
-    setChatOpen?: (open: boolean, commandId: string) => void;
+    setChatOpen?: (open: boolean, commandId: string) => void | Promise<void>;
     playAnimation?: (animation: string, expiresAt?: string | null) => void | Promise<void>;
     showCta?: (context: CtaCommandContext) => void;
-    connectTelegram?: (context: CtaCommandContext) => void | Promise<void>;
+    connectTelegram?: (context: CtaCommandContext) => CtaActionExecutionResult | Promise<CtaActionExecutionResult>;
     speakText?: (context: SpeakTextCommandContext) => void | Promise<void>;
     startVoiceConversation?: (context: StartVoiceConversationCommandContext) => void | Promise<void>;
 };
@@ -20,6 +20,10 @@ export declare class CommandRuntime {
     private resolveInternalHandlers;
     private readonly completed;
     private readonly inFlight;
+    private readonly completedCtaActions;
+    private readonly terminalCtaActions;
+    private readonly ctaActionRetentionOrder;
+    private readonly inFlightCtaActions;
     private readonly highlights;
     private readonly targetObservationCleanups;
     private readonly targetActivationOwners;
@@ -34,7 +38,9 @@ export declare class CommandRuntime {
     setInternalHandlers(handlers: InternalHandlers): () => void;
     execute(envelope: CommandEnvelope, session: CustomerInteractionSession, sendAck: AckSender): Promise<void>;
     updateSession(session: CustomerInteractionSession): void;
-    executeCtaAction(context: CtaCommandContext): Promise<void>;
+    executeCtaAction(context: CtaCommandContext): Promise<CtaActionExecutionResult>;
+    private executeCtaActionOnce;
+    private retainCtaAction;
     destroy(): void;
     private executeOnce;
     private dispatch;

package/dist/domain/command/command.types.d.ts

@@ -100,11 +100,23 @@ export type HighlightCommandContext = HostCommandContext & {
 };
 export type CtaCommandContext = Omit<HostCommandContext, "target"> & {
     label: string;
+    text?: string;
     action: "none" | "open_modal" | "open_page" | "connect_telegram";
+    conversationId?: string;
+    scenarioRunId: string;
+    expiresAt: string | null;
+    presentation: "PRIMARY";
+    attention: "NONE" | "NUDGE_ONCE";
     target?: string;
     /** Resolved once when SHOW_CTA arrives and reused unchanged after the click. */
     uiAction?: Readonly<UiCommandActionSnapshot>;
 };
+/**
+ * User-activation outcome. A terminal failure may be ambiguous: the host side
+ * effect could already have happened, so the same command must not be offered
+ * for retry.
+ */
+export type CtaActionExecutionResult = "COMPLETED" | "AWAITING_CONFIRMATION" | "RETRYABLE_FAILURE" | "TERMINAL_FAILURE";
 export type StartVoiceConversationCommandContext = {
     commandId: string;
     commandType: "start_voice_conversation";

package/dist/domain/compact-preview/CompactPreviewController.d.ts

@@ -0,0 +1,123 @@
+import { type MessageData } from "@/api/messages.api.types";
+import type { CtaCommandContext } from "@/domain/command/command.types";
+import { type ScenarioChoiceCommand, type ScenarioChoiceLifecycleChanged } from "@/domain/scenario/scenario-choice";
+export type CompactPreviewKind = "INFO" | "CHOICE" | "CTA";
+export type CompactPreviewDisplayMode = "DIRECT" | "OPEN_IN_CHAT" | "ACTION_ONLY";
+export type CompactPreviewPhase = "IDLE" | "ENTERING" | "INTERACTIVE" | "EXITING" | "GAP";
+export type CompactPreviewExitReason = "DISMISSED" | "COLLAPSED" | "ACTIVATED" | "ANSWERED" | "RESOLVED" | "EXPIRED" | "OPENED_CHAT" | "ROUTING_CHANGED";
+export type CompactPreviewAdmission = "SHOWN" | "QUEUED" | "DUPLICATE" | "QUEUE_OVERFLOW" | "SUPPRESSED_OPEN_CHAT" | "SUPPRESSED_HIDDEN_CHROME" | "SUPPRESSED_HIDDEN_DOCUMENT" | "SUPPRESSED_STARTUP_HISTORY" | "INELIGIBLE" | "EXPIRED" | "RESOLVED";
+export type CompactPreviewMessageSource = "LIVE" | "HISTORY_REPLAY";
+type CompactPreviewCandidateBase = {
+    key: string;
+    kind: CompactPreviewKind;
+    principalSessionId: string;
+    conversationId: string;
+    scenarioRunId?: string;
+    subjectId: string;
+    attributionHandle: string;
+    messageId?: string;
+    text: string;
+    leadText: string;
+    displayMode: CompactPreviewDisplayMode;
+    createdAt: string;
+    expiresAt: string | null;
+    /** Local monotonic deadline derived from the authoritative server clock. */
+    deadlineAtMs: number | null;
+    coalescedCount: number;
+};
+export type CompactPreviewInfoCandidate = CompactPreviewCandidateBase & {
+    kind: "INFO";
+    message: MessageData;
+};
+export type CompactPreviewChoiceCandidate = CompactPreviewCandidateBase & {
+    kind: "CHOICE";
+    message: MessageData;
+    choice: ScenarioChoiceCommand;
+    lifecycleRevision: number;
+};
+export type CompactPreviewCtaCandidate = CompactPreviewCandidateBase & {
+    kind: "CTA";
+    cta: CtaCommandContext;
+};
+export type CompactPreviewCandidate = CompactPreviewInfoCandidate | CompactPreviewChoiceCandidate | CompactPreviewCtaCandidate;
+export type CompactPreviewSnapshot = {
+    principalSessionId: string;
+    active: CompactPreviewCandidate | null;
+    queue: readonly CompactPreviewCandidate[];
+    phase: CompactPreviewPhase;
+    exitReason: CompactPreviewExitReason | null;
+    surfaceEpisodeId: string | null;
+    dragSuspended: boolean;
+    error: string | null;
+};
+type CompactPreviewRouting = {
+    chatOpen: boolean;
+    chromeVisible: boolean;
+    launcherVisible: boolean;
+};
+type CompactPreviewControllerOptions = {
+    enabled: boolean;
+    principalSessionId: string;
+    createId?: () => string;
+    now?: () => number;
+    isDocumentVisible?: () => boolean;
+    diagnostics?: CompactPreviewDiagnostics;
+};
+type CompactPreviewDiagnostics = (event: string, details?: Readonly<Record<string, unknown>>) => void;
+export declare class CompactPreviewController {
+    private state;
+    private routing;
+    private readonly listeners;
+    private readonly dragSuspensionListeners;
+    private readonly seen;
+    private readonly seenChoiceMessages;
+    private readonly scenarioRunsByConversation;
+    private readonly createId;
+    private readonly now;
+    private readonly isDocumentVisible;
+    private diagnostics?;
+    private enabled;
+    private insertionSequence;
+    private readonly insertionOrder;
+    private resolvedWhileOpeningKey;
+    private gestureDragSuspended;
+    private dragBaseSnapshot;
+    private dragTransientSnapshot;
+    constructor(options: CompactPreviewControllerOptions);
+    getSnapshot: () => CompactPreviewSnapshot;
+    subscribe: (listener: () => void) => (() => void);
+    subscribeDragSuspension: (listener: (suspended: boolean) => void) => (() => void);
+    setDiagnostics(diagnostics?: CompactPreviewDiagnostics): void;
+    setEnabled(enabled: boolean): void;
+    setRouting(routing: CompactPreviewRouting): void;
+    rememberScenarioConversation(conversationId: string, scenarioRunId?: string): void;
+    replacePrincipal(principalSessionId: string): void;
+    receiveMessage(message: MessageData, source?: CompactPreviewMessageSource): CompactPreviewAdmission;
+    receiveCta(context: CtaCommandContext): CompactPreviewAdmission;
+    handleChoiceLifecycle(event: ScenarioChoiceLifecycleChanged): void;
+    markInteractive(): void;
+    forceOpenInChat(candidateKey: string): void;
+    beginExit(reason: CompactPreviewExitReason): void;
+    restoreAfterError(message: string): void;
+    completeExit(): void;
+    promoteNext(): void;
+    setDragSuspended(dragSuspended: boolean): void;
+    expireDue(): void;
+    clear(reason: CompactPreviewExitReason): void;
+    private admit;
+    private reconcileMessageCandidate;
+    private reconcileRemovedChoice;
+    private reconcileTerminalChoice;
+    private refreshLiveCandidate;
+    private rememberSeen;
+    private rememberChoiceMessage;
+    private infoCandidate;
+    private choiceCandidate;
+    private key;
+    private messageIdentity;
+    private sortQueue;
+    private report;
+    private setState;
+    private emit;
+}
+export {};

package/dist/domain/message/cable/CableContext.d.ts

@@ -4,17 +4,32 @@ import { NetworkStatus } from "./CableContext.types";
 import type { WidgetConfig } from "@/index.types";
 import type { CommandRuntime } from "@/domain/command/CommandRuntime";
 import { EndUserTypingClient } from "@/domain/message/typing/end-user-typing.client";
+import type { MessageData } from "@/api/messages.api.types";
+import type { ScenarioChoiceLifecycleChanged, ScenarioChoiceSubmissionResult } from "@/domain/scenario/scenario-choice";
+import type { CompactPreviewMessageSource } from "@/domain/compact-preview/CompactPreviewController";
+import type { ScenarioConversationCreated } from "./widget-message";
+import { ScenarioChoiceSubmissionController } from "@/domain/scenario/ScenarioChoiceSubmissionController";
 interface CableContextType {
     anycableService: AnyCableService | null;
     endUserTypingClient: EndUserTypingClient;
     networkStatus: NetworkStatus;
+    scenarioChoiceSubmissionController: ScenarioChoiceSubmissionController;
 }
+export type CableServiceFactory = (url: string, onMessage?: (message: unknown) => void, onAuthenticationError?: () => void) => AnyCableService;
 interface CableProviderProps {
     children: ReactNode;
     config: WidgetConfig;
     commandRuntime: CommandRuntime;
     onSessionExpired?: () => void;
+    frameHandlers?: CableFrameHandlers;
+    createCableService?: CableServiceFactory;
 }
-export declare const CableProvider: ({ children, config, commandRuntime, onSessionExpired, }: CableProviderProps) => import("react/jsx-runtime").JSX.Element;
+export type CableFrameHandlers = {
+    onScenarioConversation?: (conversation: ScenarioConversationCreated) => void;
+    onRealtimeMessage?: (message: MessageData, source: CompactPreviewMessageSource) => void;
+    onScenarioChoiceLifecycle?: (event: ScenarioChoiceLifecycleChanged) => void;
+    onScenarioChoiceSubmissionResult?: (result: ScenarioChoiceSubmissionResult) => void;
+};
+export declare const CableProvider: ({ children, config, commandRuntime, onSessionExpired, frameHandlers, createCableService, }: CableProviderProps) => import("react/jsx-runtime").JSX.Element;
 export declare const useCable: () => CableContextType;
 export {};

package/dist/domain/message/cable/widget-frame.d.ts

@@ -2,12 +2,21 @@ import type { CustomerInteractionSession } from "@/types";
 import type { CommandAck } from "@/domain/command/command.types";
 import type { CommandRuntime } from "@/domain/command/CommandRuntime";
 import type { MessageStoreActions } from "@/domain/message/message.store";
+import type { MessageData } from "@/api/messages.api.types";
+import type { ScenarioChoiceLifecycleChanged, ScenarioChoiceSubmissionResult } from "@/domain/scenario/scenario-choice";
+import type { CompactPreviewMessageSource } from "@/domain/compact-preview/CompactPreviewController";
+import type { ScenarioConversationCreated } from "./widget-message";
 type WidgetFrameDependencies = {
     messageActions: Pick<MessageStoreActions, "handleConversationCreated" | "handleScenarioChoiceLifecycleChanged" | "handleScenarioChoiceSubmissionResult" | "handleMessageDelta" | "handleMessagesAgenticSteps" | "handleMessage" | "handleChatTyping" | "handleResponderPresentationChanged">;
     commandRuntime: CommandRuntime;
     session: CustomerInteractionSession;
     sendAck: (ack: CommandAck) => Promise<unknown>;
     onPresenceOnline: () => void;
+    onScenarioConversation?: (conversation: ScenarioConversationCreated) => void;
+    realtimeMessageSource?: CompactPreviewMessageSource;
+    onRealtimeMessage?: (message: MessageData, source: CompactPreviewMessageSource) => void;
+    onScenarioChoiceLifecycle?: (event: ScenarioChoiceLifecycleChanged) => void;
+    onScenarioChoiceSubmissionResult?: (result: ScenarioChoiceSubmissionResult) => void;
 };
 export declare const dispatchWidgetFrame: (message: unknown, dependencies: WidgetFrameDependencies) => Promise<void> | null;
 export {};

package/dist/domain/message/chat-experience.d.ts

@@ -5,16 +5,30 @@ export type ChatAttachment = {
     mediaType: string;
     size: number;
     kind: ChatAttachmentKind;
-    downloadUrl: string;
+    /** Ephemeral local/demo URLs only. Durable backend snapshots never contain URLs. */
+    downloadUrl?: string;
     previewUrl?: string;
 };
+export type ChatAttachmentUploadStage = "preparing" | "uploading" | "scanning";
 export type ChatAttachmentUploadInput = {
     file: File;
+    conversationId?: string;
     signal?: AbortSignal;
     onProgress?: (progress: number) => void;
+    onStage?: (stage: ChatAttachmentUploadStage) => void;
+};
+export type ChatAttachmentAccessInput = {
+    attachmentId: string;
+    conversationId?: string;
+};
+export type ChatAttachmentGrant = {
+    url: string;
+    expiresAt: string;
 };
 export interface ChatAttachmentTransport {
     upload(input: ChatAttachmentUploadInput): Promise<ChatAttachment>;
+    grant?(input: ChatAttachmentAccessInput): Promise<ChatAttachmentGrant>;
+    revoke?(input: ChatAttachmentAccessInput): Promise<void>;
 }
 export type ChatTypingState = {
     conversationId: string;
@@ -28,6 +42,7 @@ export type ChatTypingState = {
 export declare const normalizeChatExperienceFrame: (frame: unknown) => {
     typing: ChatTypingState | null;
 };
+export declare const attachmentKindFor: (mediaType: string) => ChatAttachmentKind;
 /**
  * A deterministic transport for visual QA and integration tests. Production
  * integrators replace it with their signed-upload adapter through WidgetConfig.

package/dist/domain/message/message.store.d.ts

@@ -66,15 +66,16 @@ export type MessageStore = {
     assistantSuspendedConversationIds: Set<string>;
     actions: MessageStoreActions;
 };
+export type MessageFrameHandlingResult = "INSERTED" | "UPDATED" | "DUPLICATE" | "IGNORED";
 export type MessageStoreActions = {
     initMessageStore: (config: WidgetConfig, api: AppApi) => Promise<void>;
     disposeMessageStore: () => void;
     setCurrentThread: (conversationId: string) => Promise<void>;
     createNewConversation: () => Promise<string>;
     handleConversationCreated: (conversation: ScenarioConversationCreated) => void;
-    handleScenarioChoiceLifecycleChanged: (event: ScenarioChoiceLifecycleChanged) => void;
+    handleScenarioChoiceLifecycleChanged: (event: ScenarioChoiceLifecycleChanged) => boolean;
     handleScenarioChoiceSubmissionResult: (result: ScenarioChoiceSubmissionResult) => void;
-    handleMessage: (message: MessageData) => void;
+    handleMessage: (message: MessageData) => MessageFrameHandlingResult;
     handleResponderPresentationChanged: (hint: ResponderPresentationChanged) => void;
     refreshResponderPresentation: (conversationId: string, minimumRevision?: string, retryAfterTransportFailure?: boolean) => void;
     handleMessageDelta: (delta: ChatMessageDeltaData) => void;

package/dist/domain/message/unread.d.ts

@@ -0,0 +1 @@
+export declare function isLatestMessageUnread(latestMessageDate: string | null, latestReadMessageDate: string | null): boolean;

package/dist/domain/scenario/ScenarioChoiceSubmissionController.d.ts

@@ -0,0 +1,49 @@
+import type { ScenarioChoiceInput, ScenarioChoiceLifecycle, ScenarioChoiceSubmissionResult } from "./scenario-choice";
+export type ScenarioChoiceSubmissionKey = Readonly<{
+    principalId: string;
+    inputRequestId: string;
+}>;
+export type ScenarioChoiceSubmissionRequest = ScenarioChoiceSubmissionKey & Readonly<{
+    optionId: string;
+    presentationContext?: ScenarioChoiceInput["presentationContext"];
+}>;
+export type ScenarioChoiceSubmissionStatus = "idle" | "submitting" | "error" | "terminal";
+export type ScenarioChoiceSubmissionSnapshot = Readonly<{
+    status: ScenarioChoiceSubmissionStatus;
+    clientEventId: string | null;
+    selectedOptionId: string | null;
+    presentationContext: ScenarioChoiceInput["presentationContext"] | null;
+    lastOutcome: ScenarioChoiceSubmissionResult["outcome"] | null;
+    failure: "network" | "timeout" | null;
+}>;
+export type ScenarioChoiceTransport = (input: ScenarioChoiceInput) => Promise<unknown>;
+export type ScenarioChoiceSubmissionControllerOptions = Readonly<{
+    submitChoice: ScenarioChoiceTransport;
+    createClientEventId?: () => string;
+    confirmationTimeoutMs?: number;
+    retryDelayMs?: number;
+}>;
+export declare class ScenarioChoiceSubmissionController {
+    private readonly entries;
+    private readonly listeners;
+    private submitChoice;
+    private readonly createClientEventId;
+    private readonly confirmationTimeoutMs;
+    private readonly retryDelayMs;
+    constructor({ submitChoice, createClientEventId, confirmationTimeoutMs, retryDelayMs, }: ScenarioChoiceSubmissionControllerOptions);
+    getSnapshot(key: ScenarioChoiceSubmissionKey): ScenarioChoiceSubmissionSnapshot;
+    setTransport(submitChoice: ScenarioChoiceTransport): void;
+    subscribe(key: ScenarioChoiceSubmissionKey, listener: () => void): () => void;
+    submit(request: ScenarioChoiceSubmissionRequest): Promise<void>;
+    handleLifecycle(key: ScenarioChoiceSubmissionKey, lifecycle: ScenarioChoiceLifecycle): void;
+    handleResult(principalId: string, result: ScenarioChoiceSubmissionResult): void;
+    reset(): void;
+    dispose(): void;
+    private startConfirmationWindow;
+    private send;
+    private scheduleRetry;
+    private transitionToError;
+    private pruneEntries;
+    private clearTimers;
+    private emit;
+}

package/dist/domain/scenario/scenario-choice.d.ts

@@ -2,6 +2,8 @@ import type { MessageData } from "@/api/messages.api.types";
 export type ScenarioChoiceOption = {
     id: string;
     label: string;
+    presentation: "PRIMARY" | "TERTIARY";
+    attention: "NONE" | "NUDGE_ONCE";
 };
 export declare const SCENARIO_CHOICE_LIFECYCLE_STATUSES: readonly ["PENDING", "ANSWERED", "TIMED_OUT", "CANCELLED"];
 export type ScenarioChoiceLifecycleStatus = (typeof SCENARIO_CHOICE_LIFECYCLE_STATUSES)[number];
@@ -49,6 +51,10 @@ export type ScenarioChoiceInput = {
     inputRequestId: string;
     optionId: string;
     clientEventId: string;
+    presentationContext?: {
+        surface: "CHAT" | "COMPACT_PREVIEW";
+        surfaceEpisodeId: string;
+    };
 };
 export declare const parseScenarioChoiceLifecycle: (value: unknown) => ScenarioChoiceLifecycle | null;
 export declare const parseScenarioChoiceLifecycleChanged: (value: unknown) => ScenarioChoiceLifecycleChanged | null;

package/dist/domain/scenario-interaction/ScenarioInteractionRuntime.d.ts

@@ -1,10 +1,11 @@
 import type { CustomerInteractionSession } from "@/types";
 import { ScenarioInteractionCollector } from "./ScenarioInteractionCollector";
-import type { EngagementSubject, PresentationSubject, SurfaceState, SurfaceTransition, SurfaceTransitionContext } from "./scenario-interaction.types";
+import type { CompactEngagementSubject, CompactPresentationSubject, EngagementSubject, PresentationSubject, SurfaceState, SurfaceTransition, SurfaceTransitionContext } from "./scenario-interaction.types";
 type RuntimeOptions = ConstructorParameters<typeof ScenarioInteractionCollector>[2];
 export declare class ScenarioInteractionRuntime {
     readonly collector: ScenarioInteractionCollector;
     private readonly surfaceController;
+    private compactSurfaceEpisode;
     private readonly presented;
     private readonly engaged;
     constructor(getSession: () => CustomerInteractionSession, onSessionExpired: () => void, options?: RuntimeOptions);
@@ -14,6 +15,11 @@ export declare class ScenarioInteractionRuntime {
     transitionSurface(nextState: SurfaceState, context: SurfaceTransitionContext): SurfaceTransition;
     getSurfaceState(): SurfaceState;
     getSurfaceEpisodeId(): string | null;
+    openCompactSurfaceEpisode(episodeId?: string): string;
+    closeCompactSurfaceEpisode(expectedEpisodeId?: string | undefined): boolean;
+    getCompactSurfaceEpisodeId(): string | null;
+    recordCompactPresented(subject: CompactPresentationSubject, expectedEpisodeId?: string | undefined): boolean;
+    recordCompactEngagement(subject: CompactEngagementSubject, expectedEpisodeId?: string | undefined): boolean;
     getPrincipalSessionId(): string;
     recordPresented(subject: PresentationSubject, expectedEpisodeId?: string | null): boolean;
     recordEngagement(subject: EngagementSubject): boolean;

package/dist/domain/scenario-interaction/presentation-observer.d.ts

@@ -8,5 +8,10 @@ type PresentationObserverInput = {
     intersectionRatio?: number;
     dwellMs?: number;
 };
-export declare const observePresentedElement: ({ element, isActive, isPresentable, onPresented, intersectionRatio, dwellMs, }: PresentationObserverInput) => (() => void);
+export type PresentationObserverHandle = (() => void) & {
+    pause: () => void;
+    resume: () => void;
+    refresh: () => void;
+};
+export declare const observePresentedElement: ({ element, isActive, isPresentable, onPresented, intersectionRatio, dwellMs, }: PresentationObserverInput) => PresentationObserverHandle;
 export {};

package/dist/domain/scenario-interaction/scenario-interaction.types.d.ts

@@ -5,13 +5,16 @@ export declare const SCENARIO_INTERACTION_ACTORS: readonly ["USER", "SCENARIO",
 export declare const SCENARIO_INTERACTION_SUBJECT_KINDS: readonly ["SURFACE", "MESSAGE", "CHOICE", "CTA", "TARGET"];
 export declare const SCENARIO_INTERACTION_RESULTS: readonly ["SUCCEEDED", "FAILED"];
 export declare const SCENARIO_INTERACTION_REASONS: readonly ["USER_LAUNCHER", "USER_CLOSE_BUTTON", "HOST_SET_OPEN", "SCENARIO_COMMAND", "UNKNOWN"];
+export declare const PRESENTATION_SURFACES: readonly ["CHAT", "COMPACT_PREVIEW"];
 export type ScenarioInteractionKind = (typeof SCENARIO_INTERACTION_KINDS)[number];
 export type ScenarioInteractionType = (typeof SCENARIO_INTERACTION_TYPES)[number];
 export type ScenarioInteractionActor = (typeof SCENARIO_INTERACTION_ACTORS)[number];
 export type ScenarioInteractionSubjectKind = (typeof SCENARIO_INTERACTION_SUBJECT_KINDS)[number];
 export type ScenarioInteractionResult = (typeof SCENARIO_INTERACTION_RESULTS)[number];
 export type ScenarioInteractionReason = (typeof SCENARIO_INTERACTION_REASONS)[number];
+export type PresentationSurface = (typeof PRESENTATION_SURFACES)[number];
 export type ScenarioInteractionDetails = {
+    surface?: PresentationSurface;
     presentationOrdinal?: number;
 };
 export type ScenarioInteractionObservation = {
@@ -82,3 +85,10 @@ export type EngagementSubject = {
     attributionHandle?: string;
     result?: ScenarioInteractionResult;
 };
+export type CompactPresentationSubject = Omit<PresentationSubject, "subjectKind"> & {
+    subjectKind: Extract<PresentationSubject["subjectKind"], "MESSAGE" | "CHOICE" | "CTA">;
+};
+export type CompactEngagementSubject = Omit<EngagementSubject, "type" | "subjectKind"> & {
+    type: Extract<EngagementSubject["type"], "CTA_CLICKED" | "CTA_DISMISSED">;
+    subjectKind: "CTA";
+};

package/dist/domain/ui/ui.service.d.ts

@@ -1,13 +1,14 @@
-import type { Point } from "./widget-geometry";
+import { type DockedLauncher, type Point, type Viewport } from "./widget-geometry";
 type PanelGeometry = Partial<Point> & {
     width: number;
     height: number;
 };
 export type WidgetUIData = {
-    version: 2;
-    launcher?: Point;
+    version: 3;
+    launcher: DockedLauncher;
     panel: PanelGeometry;
 };
-export declare function loadWidgetUIData(): WidgetUIData | null;
-export declare function saveWidgetUIData(data: WidgetUIData): void;
+export declare function loadWidgetUIData(scope?: string | null, viewport?: Viewport): WidgetUIData | null;
+export declare function claimLegacyWidgetUIData(scope: string | null | undefined, viewport: Viewport): WidgetUIData | null;
+export declare function saveWidgetUIData(scope: string | null | undefined, data: WidgetUIData, viewport: Viewport): void;
 export {};

package/dist/domain/ui/widget-geometry.d.ts

@@ -8,16 +8,44 @@ export type Size = {
 };
 export type Rect = Point & Size;
 export type Viewport = Rect;
+export type ViewportInsets = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+export type LauncherSide = "LEFT" | "RIGHT";
+export type DockedLauncher = {
+    side: LauncherSide;
+    yRatio: number;
+};
+export type CompactPreviewPlacement = "above" | "below";
+export type CompactPreviewLayout = {
+    x: number;
+    y: number;
+    width: number;
+    maxHeight: number;
+    placement: CompactPreviewPlacement;
+    avoidanceFailed: boolean;
+};
 export declare const LAUNCHER_SIZE = 52;
+export declare const LAUNCHER_EDGE_INSET = 24;
 export declare const VIEWPORT_MARGIN = 16;
 export declare const MIN_WIDGET_WIDTH = 240;
 export declare const DEFAULT_WIDGET_WIDTH = 360;
 export declare const MIN_WIDGET_HEIGHT = 320;
 export declare const DEFAULT_WIDGET_HEIGHT = 680;
+export declare const COMPACT_PREVIEW_MAX_WIDTH = 320;
+export declare const COMPACT_PREVIEW_MARGIN = 12;
+export declare const COMPACT_PREVIEW_GAP = 12;
 export declare function getViewport(): Viewport;
+export declare function insetViewport(viewport: Viewport, insets: ViewportInsets): Viewport;
 export declare function getDefaultLauncherPosition(viewport: Viewport): Point;
+export declare function dockLauncherPosition(point: Point, viewport: Viewport): DockedLauncher;
+export declare function launcherPointFromDock(launcher: DockedLauncher, viewport: Viewport): Point;
 export declare function clampLauncherPosition(point: Point, viewport: Viewport): Point;
 export declare function clampPanelRect(rect: Rect, viewport: Viewport): Rect;
 export declare function placePanelFromLauncher(launcher: Point, size: Size, viewport: Viewport): Rect;
+export declare function placeCompactPreview(launcher: Point, measuredSize: Size, viewport: Viewport, side: LauncherSide, avoidRect?: Rect | null): CompactPreviewLayout;
 export declare function resizePanelFromNorthWest(start: Rect, delta: Point, axes: "top" | "left" | "corner", viewport: Viewport): Rect;
 export declare function resizePanelFromSouthEast(start: Rect, delta: Point, viewport: Viewport): Rect;