@alxxsck/ai-assistant 2.18.0 → 2.21.0

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

@@ -1,6 +1,6 @@
 import type { AppApi } from "@/App";
 import type { WidgetConfig } from "@/index.types";
-import { type ConversationData, type MessageData, type RawMessageData, type SendMessageResult } from "./messages.api.types";
+import { type ConversationData, type MessageData, type RawConversationData, type RawMessageData, type SendMessageResult } from "./messages.api.types";
 import type { ChatAttachment } from "@/domain/message/chat-experience";
 export declare const MAX_FETCH_MESSAGES = 100;
 export type CursorPage<T> = {
@@ -10,7 +10,6 @@ export type CursorPage<T> = {
 type VersionedCursorPage<T> = CursorPage<T> & {
     contractVersion?: unknown;
 };
-type ConversationsResponse = VersionedCursorPage<ConversationData>;
 export declare class ChatApiError extends Error {
     readonly status: number;
     constructor(status: number, message: string);
@@ -20,12 +19,19 @@ export declare class ChatContractError extends Error {
 }
 export declare const isConversationClosedError: (error: unknown) => boolean;
 export declare const requestChatJson: <T>(config: WidgetConfig, api: AppApi, path: string, init?: RequestInit) => Promise<T>;
-export declare const normalizeConversation: (conversation: ConversationData) => ConversationData;
+export declare const normalizeConversation: (conversation: RawConversationData) => ConversationData;
 export declare const normalizeMessage: (message: RawMessageData, config: WidgetConfig) => MessageData;
+export declare const normalizeMessageAuthorPresentation: (role: RawMessageData["role"], author: unknown) => Readonly<{
+    contractState: "VERSIONED" | "LEGACY";
+    displayName: string;
+    avatarAsset: import("@/domain/support-presentation/support-presentation.types").PresentationAvatarAsset | null;
+    presentationVersion: number | null;
+    legacyAvatarUrl: string | null;
+}> | null;
 export declare const normalizeMessageForSession: (message: RawMessageData, interactionSessionId: string) => MessageData;
-export declare const listConversations: (config: WidgetConfig, api: AppApi, cursor?: string, signal?: AbortSignal) => Promise<ConversationsResponse>;
+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>>;
-export declare const createConversation: (config: WidgetConfig, api: AppApi) => Promise<ConversationData>;
+export declare const createConversation: (config: WidgetConfig, api: AppApi, signal?: AbortSignal) => Promise<ConversationData>;
 export declare const selectConversation: (config: WidgetConfig, api: AppApi, conversationId: string, signal?: AbortSignal) => Promise<ConversationData>;
 export declare const getConversation: (config: WidgetConfig, api: AppApi, conversationId: string, signal?: AbortSignal) => Promise<ConversationData>;
 export declare function sendMessage(config: WidgetConfig, api: AppApi, messageText: string, conversationId?: string, clientMessageId?: `${string}-${string}-${string}-${string}-${string}`, attachments?: readonly ChatAttachment[]): Promise<SendMessageResult>;

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

@@ -103,6 +103,10 @@ export type ConversationData = {
     aiSuspension?: ConversationAISuspension;
     responderPresentation?: import("@/domain/support-presentation/support-presentation.types").SafeResponderPresentation;
 };
+/** Untrusted transport shape before responder contract normalization. */
+export type RawConversationData = Omit<ConversationData, "responderPresentation"> & {
+    responderPresentation?: unknown;
+};
 export type MessageRole = "USER" | "ASSISTANT" | "ADMIN" | "SCENARIO" | "SYSTEM";
 export type RawMessageData = {
     id: string;

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

@@ -1,4 +1,4 @@
-import { a0 as A, a1 as e, a3 as s, G as n, a2 as r } from "./index-raaheNwM.js";
+import { a1 as A, a2 as e, a4 as s, F as n, a3 as r } from "./index-o7DbTuwa.js";
 export {
   A as ChatWidgetInstance,
   e as EXTERNALLY_AVAILABLE_ACTIONS,

package/dist/context/ChatWidgetContext.d.ts

@@ -2,9 +2,12 @@ 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 { SurfaceTransitionContext } from "@/domain/scenario-interaction/scenario-interaction.types";
 type ChatWidgetContextValue = {
     open: boolean;
     setOpen: (v: boolean) => void;
+    transitionSurface: (open: boolean, context: SurfaceTransitionContext) => void;
+    surfaceEpisodeId: string | null;
     isFullscreen: boolean;
     setFullscreen: (fullscreen: boolean) => void;
     contentActivated: boolean;

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

@@ -1,9 +1,10 @@
 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 { ScenarioInteractionRuntime } from "@/domain/scenario-interaction/ScenarioInteractionRuntime";
 type AckSender = (ack: CommandAck) => Promise<unknown>;
 type InternalHandlers = {
-    setAssistantVisible?: (visible: boolean) => void;
-    setChatOpen?: (open: boolean) => void;
+    setAssistantVisible?: (visible: boolean, commandId: string) => void;
+    setChatOpen?: (open: boolean, commandId: string) => void;
     playAnimation?: (animation: string, expiresAt?: string | null) => void | Promise<void>;
     showCta?: (context: CtaCommandContext) => void;
     connectTelegram?: (context: CtaCommandContext) => void | Promise<void>;
@@ -12,6 +13,7 @@ type InternalHandlers = {
 };
 export declare class CommandRuntime {
     private readonly onStatus?;
+    private readonly scenarioInteractions?;
     private readonly uiCommands;
     private readonly internalHandlers;
     private readonly internalHandlersReady;
@@ -19,16 +21,25 @@ export declare class CommandRuntime {
     private readonly completed;
     private readonly inFlight;
     private readonly highlights;
-    constructor(targets?: Record<string, UiTarget>, handlers?: HostCommandHandlers, onStatus?: ((detail: CommandEventDetail) => void) | undefined);
+    private readonly targetObservationCleanups;
+    private readonly targetActivationOwners;
+    private readonly activeCustomHighlights;
+    private readonly targetHighlightOperations;
+    private principalSessionId;
+    private principalGeneration;
+    private destroyed;
+    constructor(targets?: Record<string, UiTarget>, handlers?: HostCommandHandlers, onStatus?: ((detail: CommandEventDetail) => void) | undefined, scenarioInteractions?: ScenarioInteractionRuntime | undefined);
     registerTarget(code: string, target: UiTarget): () => void;
     registerHostHandler<K extends HostCommandHandlerName>(name: K, handler: NonNullable<HostCommandHandlers[K]>): () => void;
     setInternalHandlers(handlers: InternalHandlers): () => void;
     execute(envelope: CommandEnvelope, session: CustomerInteractionSession, sendAck: AckSender): Promise<void>;
+    updateSession(session: CustomerInteractionSession): void;
     executeCtaAction(context: CtaCommandContext): Promise<void>;
     destroy(): void;
     private executeOnce;
     private dispatch;
     private executeHighlight;
+    private executeHighlightSerial;
     private executeShowCta;
     private executeConnectTelegram;
     private requireTarget;
@@ -37,10 +48,22 @@ export declare class CommandRuntime {
     private findTargetElement;
     private applyDefaultHighlight;
     private removeDefaultHighlight;
+    private observeTarget;
+    private createTargetActivationReporter;
+    private removeTargetObservation;
+    private removeTargetTracking;
+    private deactivateCustomHighlight;
+    private removeCustomHighlightForCommand;
+    private invokeCustomHighlight;
+    private queueCustomHighlightCleanup;
+    private clearCustomHighlights;
     private requireInternal;
     private requireString;
     private firstDefined;
     private finish;
+    private ensurePrincipal;
+    private resetPrincipalState;
+    private isCurrentPrincipal;
     private storageKey;
     private loadCompleted;
     private saveCompleted;

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

@@ -91,6 +91,12 @@ export type UiCommandActionSnapshot = {
 export type HighlightCommandContext = HostCommandContext & {
     active: boolean;
     element?: Element;
+    /**
+     * Reports the product action caused by this active highlight. Call it
+     * synchronously from the host-owned action handler, before navigation. The
+     * SDK records only that activation happened; it does not infer its outcome.
+     */
+    reportActivation: () => void;
 };
 export type CtaCommandContext = Omit<HostCommandContext, "target"> & {
     label: string;

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

@@ -3,8 +3,10 @@ import { AnyCableService } from "./AnyCable.service";
 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";
 interface CableContextType {
     anycableService: AnyCableService | null;
+    endUserTypingClient: EndUserTypingClient;
     networkStatus: NetworkStatus;
 }
 interface CableProviderProps {

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

@@ -3,7 +3,7 @@ import type { CommandAck } from "@/domain/command/command.types";
 import type { CommandRuntime } from "@/domain/command/CommandRuntime";
 import type { MessageStoreActions } from "@/domain/message/message.store";
 type WidgetFrameDependencies = {
-    messageActions: Pick<MessageStoreActions, "handleConversationCreated" | "handleScenarioChoiceLifecycleChanged" | "handleScenarioChoiceSubmissionResult" | "handleMessageDelta" | "handleMessagesAgenticSteps" | "handleMessage" | "handleChatTyping" | "handleSupportPresence" | "handleResponderPresentationChanged">;
+    messageActions: Pick<MessageStoreActions, "handleConversationCreated" | "handleScenarioChoiceLifecycleChanged" | "handleScenarioChoiceSubmissionResult" | "handleMessageDelta" | "handleMessagesAgenticSteps" | "handleMessage" | "handleChatTyping" | "handleResponderPresentationChanged">;
     commandRuntime: CommandRuntime;
     session: CustomerInteractionSession;
     sendAck: (ack: CommandAck) => Promise<unknown>;

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

@@ -20,14 +20,6 @@ export type ChatTypingState = {
     conversationId: string;
     actor: "ASSISTANT" | "ADMIN";
     active: boolean;
-    displayName?: string;
-    avatarUrl?: string | null;
-};
-export type SupportPresenceState = {
-    conversationId: string;
-    live: boolean;
-    displayName?: string;
-    avatarUrl?: string | null;
 };
 /**
  * Opt-in future frame fields. Unknown frames are ignored so the SDK remains
@@ -35,7 +27,6 @@ export type SupportPresenceState = {
  */
 export declare const normalizeChatExperienceFrame: (frame: unknown) => {
     typing: ChatTypingState | null;
-    presence: SupportPresenceState | null;
 };
 /**
  * A deterministic transport for visual QA and integration tests. Production

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

@@ -2,7 +2,7 @@ import { type AgenticStepsAppendedData, type ChatMessageDeltaData, type Conversa
 import type { AppApi } from "@/App";
 import type { WidgetConfig } from "@/index.types";
 import { type MessageStreamState } from "./message-stream";
-import type { ChatAttachment, ChatTypingState, SupportPresenceState } from "./chat-experience";
+import type { ChatAttachment, ChatTypingState } from "./chat-experience";
 import type { ResponderPresentationChanged, ScenarioConversationCreated } from "./cable/widget-message";
 import { type ScenarioChoiceLifecycleChanged, type ScenarioChoiceSubmissionResult } from "@/domain/scenario/scenario-choice";
 export interface ThreadSummary {
@@ -21,6 +21,7 @@ export type PendingCustomerMessage = {
     conversationId: string | undefined;
     afterMessageId: string | null;
     acknowledged: boolean;
+    acceptanceConfirmed?: boolean;
     canonicalMessageId: string | null;
     attachments: ChatAttachment[];
     readByAssistant: boolean;
@@ -54,7 +55,14 @@ export type MessageStore = {
     responsePhase: AgentResponsePhase;
     sendInFlight: boolean;
     typingByConversation: Map<string, ChatTypingState>;
-    supportPresenceByConversation: Map<string, SupportPresenceState>;
+    concealedConversationIds: Set<string>;
+    concealedMessageIds: Set<string>;
+    inactiveConversationIds: Set<string>;
+    inactiveConversationUpdatedAt: Map<string, string | null>;
+    inactiveConversationRevalidation: Map<string, "ANY_OPEN" | "NEWER_OPEN" | "EXACT_ONLY">;
+    conversationScanCandidateIds: Set<string>;
+    conversationScanAuthorityVersion: number | null;
+    conversationScanSnapshots: Map<string, ConversationData>;
     assistantSuspendedConversationIds: Set<string>;
     actions: MessageStoreActions;
 };
@@ -68,6 +76,7 @@ export type MessageStoreActions = {
     handleScenarioChoiceSubmissionResult: (result: ScenarioChoiceSubmissionResult) => void;
     handleMessage: (message: MessageData) => void;
     handleResponderPresentationChanged: (hint: ResponderPresentationChanged) => void;
+    refreshResponderPresentation: (conversationId: string, minimumRevision?: string, retryAfterTransportFailure?: boolean) => void;
     handleMessageDelta: (delta: ChatMessageDeltaData) => void;
     settleMessageStream: (messageId: string) => void;
     sendMessage: (message: string, attachments?: ChatAttachment[]) => Promise<SendMessageResult | undefined>;
@@ -83,11 +92,10 @@ export type MessageStoreActions = {
     cancelThreadMessagesRequest: (conversationId: string) => void;
     cancelConversationPagination: () => void;
     setCurrentThreadMessages: (conversationId: string) => void;
-    sendServiceMessage: (message: string) => Promise<void>;
     handleChatTyping: (typing: ChatTypingState) => void;
-    handleSupportPresence: (presence: SupportPresenceState) => void;
+    clearTransientRealtimeState: () => void;
     updateConfig: (config: WidgetConfig, api: AppApi) => void;
-    recoverMessages: (preserveLoadedConversations?: boolean) => Promise<void>;
+    recoverMessages: (preserveLoadedConversations?: boolean, preserveCurrentThread?: boolean) => Promise<void>;
     fetchMoreConversations: () => Promise<void>;
 };
 export declare const useMessageStore: import("zustand").UseBoundStore<import("zustand").StoreApi<MessageStore>>;
@@ -99,8 +107,9 @@ export declare const useIsLoadingMoreConversations: () => boolean;
 export declare const useCurrentThreadId: () => string | undefined;
 export declare const useCurrentResponderPresentation: () => Readonly<{
     contractState: "CURRENT" | "LEGACY" | "INCOMPATIBLE";
-    schemaVersion: 0 | 1;
-    mode: import("@/domain/support-presentation/support-presentation.types").ResponderMode | "UNKNOWN";
+    schemaVersion: 0 | 2;
+    humanSupport: import("@/domain/support-presentation/support-presentation.types").ResponderHumanSupportState | "UNKNOWN";
+    ai: import("@/domain/support-presentation/support-presentation.types").ResponderAIState | "UNKNOWN";
     identity: import("@/domain/support-presentation/support-presentation.types").ResponderIdentity;
     displayName: string | null;
     avatarAsset: import("@/domain/support-presentation/support-presentation.types").PresentationAvatarAsset | null;
@@ -124,8 +133,8 @@ export declare const useIsResponseActive: () => boolean;
 export declare const selectCurrentThreadPendingCustomerMessage: (state: MessageStore) => PendingCustomerMessage | null;
 export declare const usePendingCustomerMessage: () => PendingCustomerMessage | null;
 export declare const useMessageStream: (messageId: string) => MessageStreamState | undefined;
-export declare const useCurrentChatTyping: () => ChatTypingState | null;
-export declare const useCurrentSupportPresence: () => SupportPresenceState | null;
+export declare const selectCurrentChatTypingByActor: (state: MessageStore, actor: ChatTypingState["actor"]) => ChatTypingState | null;
+export declare const useCurrentChatTypingByActor: (actor: ChatTypingState["actor"]) => ChatTypingState | null;
 export declare const selectIsCurrentConversationAISuspended: (state: MessageStore) => boolean;
 export declare const useCurrentConversationAISuspended: () => boolean;
 export declare const useMessageStoreActions: () => MessageStoreActions;

package/dist/domain/message/typing/end-user-typing.client.d.ts

@@ -0,0 +1,38 @@
+export declare const END_USER_TYPING_IDLE_MS = 2000;
+export declare const END_USER_TYPING_RENEW_MS = 3000;
+export type EndUserTypingCommand = Readonly<{
+    conversationId: string;
+    isTyping: boolean;
+}>;
+export interface EndUserTypingSocket {
+    isConnected(): boolean;
+    onConnect(listener: () => void): void;
+    offConnect(listener: () => void): void;
+    connect(): void;
+    disconnect(): void;
+    send(command: EndUserTypingCommand): void;
+}
+type EndUserTypingSocketFactory = (accessToken: string) => EndUserTypingSocket;
+/**
+ * Sends content-free, volatile typing hints for the one conversation being edited.
+ * The socket is created lazily and no command is queued while the transport is offline.
+ */
+export declare class EndUserTypingClient {
+    private readonly accessToken;
+    private readonly socketFactory;
+    private readonly now;
+    private socket;
+    private conversationId;
+    private lastPublicationAt;
+    private idleTimer;
+    constructor(accessToken: string, socketFactory?: EndUserTypingSocketFactory, now?: () => number);
+    markActivity(conversationId: string): void;
+    stop(): void;
+    dispose(): void;
+    private readonly handleConnect;
+    private publish;
+    private ensureSocket;
+    private scheduleIdleStop;
+    private clearIdleTimer;
+}
+export {};

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

@@ -0,0 +1,91 @@
+import type { CustomerInteractionSession } from "@/types";
+import { type ScenarioInteractionDraft, type ScenarioInteractionObservation } from "./scenario-interaction.types";
+type CollectorOptions = {
+    baseUrl?: string;
+    queueLimit?: number;
+    batchLimit?: number;
+    flushIntervalMs?: number;
+    requestTimeoutMs?: number;
+    fetch?: typeof fetch;
+    createId?: () => string;
+    now?: () => number;
+    random?: () => number;
+};
+export declare class ScenarioInteractionCollector {
+    private readonly getSession;
+    private readonly onSessionExpired;
+    private readonly queue;
+    private readonly baseUrl;
+    private readonly queueLimit;
+    private readonly batchLimit;
+    private readonly flushIntervalMs;
+    private readonly requestTimeoutMs;
+    private readonly fetchImpl;
+    private readonly createId;
+    private readonly now;
+    private readonly random;
+    private sequence;
+    private capabilities;
+    private capabilityRequest;
+    private flushRequest;
+    private capabilityRequestControl;
+    private batchRequestControl;
+    private batchRequestUsesKeepalive;
+    private flushTimer;
+    private retryTimer;
+    private capabilityRetryTimer;
+    private retryAttempt;
+    private capabilityRetryAttempt;
+    private batchRetriesSuspended;
+    private capabilityRetriesSuspended;
+    private awaitingRenewalToken;
+    private sessionGeneration;
+    private quotaBlockedUntil;
+    private admissionWindowStartedAt;
+    private admissionCount;
+    private started;
+    private destroyed;
+    private principalSessionId;
+    private principalAccessToken;
+    constructor(getSession: () => CustomerInteractionSession, onSessionExpired: () => void, options?: CollectorOptions);
+    start(): void;
+    destroy(): void;
+    updateSession(session: CustomerInteractionSession): boolean;
+    enqueue(draft: ScenarioInteractionDraft): string | null;
+    getQueueSnapshot(): readonly ScenarioInteractionObservation[];
+    isSendingEnabled(): boolean;
+    getPrincipalSessionId(): string;
+    flush(options?: {
+        keepalive?: boolean;
+    }): Promise<void>;
+    private readonly onOnlineOrFocus;
+    private readonly onVisibilityChange;
+    private readonly onPageHide;
+    private buildObservation;
+    private buildDetails;
+    private ensureCapabilities;
+    private loadCapabilities;
+    private flushOnce;
+    private selectBatch;
+    private dropUnsupportedObservations;
+    private isSupported;
+    private sessionNeedsRenewal;
+    private isCurrentGeneration;
+    private nextSequence;
+    private abortPendingRequests;
+    private createRequestControl;
+    private finishRequestControl;
+    private handleUnauthorized;
+    private scheduleFlush;
+    private scheduleRetry;
+    private scheduleCapabilityRetry;
+    private clearFlushTimer;
+    private clearTimers;
+    private clearRetryTimer;
+    private clearCapabilityRetryTimer;
+    private retryDelay;
+    private disableSending;
+    private admitWithinSessionQuota;
+    private isQuotaBlocked;
+}
+export {};

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

@@ -0,0 +1,28 @@
+import type { CustomerInteractionSession } from "@/types";
+import { ScenarioInteractionCollector } from "./ScenarioInteractionCollector";
+import type { 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 readonly presented;
+    private readonly engaged;
+    constructor(getSession: () => CustomerInteractionSession, onSessionExpired: () => void, options?: RuntimeOptions);
+    start(): void;
+    destroy(): void;
+    updateSession(session: CustomerInteractionSession): void;
+    transitionSurface(nextState: SurfaceState, context: SurfaceTransitionContext): SurfaceTransition;
+    getSurfaceState(): SurfaceState;
+    getSurfaceEpisodeId(): string | null;
+    getPrincipalSessionId(): string;
+    recordPresented(subject: PresentationSubject, expectedEpisodeId?: string | null): boolean;
+    recordEngagement(subject: EngagementSubject): boolean;
+    recordTargetPresented(commandId: string, surfaceEpisodeId?: string | null): boolean;
+    recordTargetActivation(commandId: string, surfaceEpisodeId?: string | null): boolean;
+    observeHighlightedTarget(input: {
+        element: Element;
+        commandId: string;
+    }): () => void;
+    private markCurrentTargetContext;
+}
+export {};

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

@@ -0,0 +1,13 @@
+import type { ScenarioInteractionDraft, SurfaceState, SurfaceTransition, SurfaceTransitionContext } from "./scenario-interaction.types";
+export declare class SurfaceController {
+    private readonly observe;
+    private readonly createId;
+    private state;
+    private episode;
+    constructor(observe: (draft: ScenarioInteractionDraft) => void, createId?: () => string);
+    transition(nextState: SurfaceState, context: SurfaceTransitionContext): SurfaceTransition;
+    getState(): SurfaceState;
+    getEpisodeId(): string | null;
+    markScenarioContext(attributionHandle: string): void;
+    replacePrincipal(): void;
+}

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

@@ -0,0 +1,12 @@
+export declare const PRESENTATION_INTERSECTION_RATIO = 0.5;
+export declare const PRESENTATION_DWELL_MS = 500;
+type PresentationObserverInput = {
+    element: Element;
+    isActive: () => boolean;
+    isPresentable?: () => boolean;
+    onPresented: () => void;
+    intersectionRatio?: number;
+    dwellMs?: number;
+};
+export declare const observePresentedElement: ({ element, isActive, isPresentable, onPresented, intersectionRatio, dwellMs, }: PresentationObserverInput) => (() => void);
+export {};

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

@@ -0,0 +1,7 @@
+import type { ScenarioInteractionRuntime } from "./ScenarioInteractionRuntime";
+export type ScenarioInteractionContextValue = {
+    open: boolean;
+    surfaceEpisodeId: string | null;
+    runtime: ScenarioInteractionRuntime;
+};
+export declare const ScenarioInteractionContext: import("react").Context<ScenarioInteractionContextValue | null>;

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

@@ -0,0 +1,84 @@
+export declare const SCENARIO_INTERACTION_VERSION: 1;
+export declare const SCENARIO_INTERACTION_KINDS: readonly ["SURFACE_STATE_CHANGED", "EXPERIENCE_PRESENTED", "EXPERIENCE_ENGAGED"];
+export declare const SCENARIO_INTERACTION_TYPES: readonly ["CHAT_OPENED", "CHAT_CLOSED", "MESSAGE_PRESENTED", "CHOICE_PRESENTED", "CTA_PRESENTED", "CTA_CLICKED", "CTA_DISMISSED", "TARGET_PRESENTED", "TARGET_ACTIVATED"];
+export declare const SCENARIO_INTERACTION_ACTORS: readonly ["USER", "SCENARIO", "HOST"];
+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 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 ScenarioInteractionDetails = {
+    presentationOrdinal?: number;
+};
+export type ScenarioInteractionObservation = {
+    clientObservationId: string;
+    version: typeof SCENARIO_INTERACTION_VERSION;
+    kind: ScenarioInteractionKind;
+    type: ScenarioInteractionType;
+    actor: ScenarioInteractionActor;
+    occurredAt: string;
+    sequence: number;
+    surfaceEpisodeId?: string;
+    subjectKind?: ScenarioInteractionSubjectKind;
+    subjectId?: string;
+    result?: ScenarioInteractionResult;
+    reason?: ScenarioInteractionReason;
+    attributionHandle?: string;
+    details?: ScenarioInteractionDetails;
+};
+export type ScenarioInteractionDraft = Omit<ScenarioInteractionObservation, "clientObservationId" | "version" | "occurredAt" | "sequence">;
+export type ScenarioInteractionCapabilities = {
+    version: number;
+    maxBatchItems: number;
+    maxRequestBytes: number;
+    sessionHourlyLimit: number;
+    retentionDays: number;
+    kinds: readonly ScenarioInteractionKind[];
+    types: readonly ScenarioInteractionType[];
+    actors: readonly ScenarioInteractionActor[];
+    attributionHandleSupported: boolean;
+};
+export type ScenarioInteractionReceipt = {
+    clientObservationId: string;
+    status: "ACCEPTED" | "DUPLICATE" | "IGNORED_NO_INTEREST" | "REJECTED";
+    code?: string | null;
+    observationId?: string | null;
+    runId?: string | null;
+};
+export type ScenarioInteractionBatchResponse = {
+    receipts: ScenarioInteractionReceipt[];
+};
+export type SurfaceState = "OPEN" | "CLOSED";
+export type SurfaceTransitionActor = ScenarioInteractionActor | "SYSTEM";
+/** Exact SDK-local reasons; state-changing reasons are preserved on the wire. */
+export type SurfaceTransitionReason = "USER_LAUNCHER" | "USER_CLOSE_BUTTON" | "VOICE_SWITCH_TO_TEXT" | "HOST_SET_OPEN" | "SCENARIO_COMMAND" | "SYSTEM_RESTORE";
+export type SurfaceTransitionContext = {
+    actor: SurfaceTransitionActor;
+    reason: SurfaceTransitionReason;
+    sourceCommandId?: string;
+};
+export type SurfaceTransition = {
+    changed: boolean;
+    from: SurfaceState;
+    to: SurfaceState;
+    episodeId: string | null;
+    context: SurfaceTransitionContext;
+};
+export type PresentationSubject = {
+    subjectKind: Extract<ScenarioInteractionSubjectKind, "MESSAGE" | "CHOICE" | "CTA" | "TARGET">;
+    subjectId: string;
+    actor?: ScenarioInteractionActor;
+    attributionHandle?: string;
+    presentationOrdinal?: number;
+};
+export type EngagementSubject = {
+    type: Extract<ScenarioInteractionType, "CTA_CLICKED" | "CTA_DISMISSED" | "TARGET_ACTIVATED">;
+    subjectKind: Extract<ScenarioInteractionSubjectKind, "CTA" | "TARGET">;
+    subjectId: string;
+    attributionHandle?: string;
+    result?: ScenarioInteractionResult;
+};

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

@@ -0,0 +1,4 @@
+import { type RefObject } from "react";
+import type { PresentationSubject } from "./scenario-interaction.types";
+import type { ScenarioInteractionRuntime } from "./ScenarioInteractionRuntime";
+export declare const useScenarioPresentation: (runtime: ScenarioInteractionRuntime | undefined, ref: RefObject<Element | null>, active: boolean, episodeId: string | null, subject: PresentationSubject | null, isPresentable?: () => boolean) => void;

package/dist/domain/support-presentation/PresentationAvatarResolver.d.ts

@@ -34,11 +34,13 @@ export declare class PresentationAvatarResolver {
     private readonly queue;
     private readonly authorityListeners;
     private readonly conversationEpochs;
+    private readonly activeKeys;
     private activeCount;
     private generation;
     constructor(config: WidgetConfig, api: AppApi, options?: ResolverOptions);
     resolve(request: PresentationAvatarRequest): Promise<ResolvedPresentationAvatar | null>;
     private drainQueue;
+    private releaseActiveSlot;
     private trimCache;
     private loadGrant;
     replaceSession(config: WidgetConfig, api: AppApi): void;

package/dist/domain/support-presentation/support-presentation.reconciliation.d.ts

@@ -0,0 +1,13 @@
+import { type SafeResponderPresentation } from "./support-presentation.types";
+export type ResponderReconciliationOutcome = "APPLIED" | "REPLAY" | "STALE" | "HINT_AHEAD" | "INCOMPATIBLE";
+export type ResponderReconciliation = Readonly<{
+    presentation: SafeResponderPresentation;
+    outcome: ResponderReconciliationOutcome;
+}>;
+export declare const compareResponderRevisions: (left: string, right: string) => number;
+/**
+ * The one merge rule for REST snapshots and revision-only realtime hints.
+ * The backend owns the compound revision; consumers never compare or advance
+ * individual source revisions themselves.
+ */
+export declare function reconcileResponderPresentation(current: SafeResponderPresentation | undefined, incoming: SafeResponderPresentation, minimumRevision?: string): ResponderReconciliation;