@v-tilt/browser 1.10.10 → 1.12.0

package/dist/core/remote-config.d.ts

@@ -3,48 +3,45 @@
  *
  * Handles loading, fetching, caching, and applying remote configuration
  * from the /decide endpoint. Supports bootstrap data for instant loading.
+ *
+ * Config merge precedence: client init > remote > defaults
+ * Uses _initConfig snapshot to distinguish user-set values from cache-applied values.
+ *
+ * @see docs/patterns/tracker-feature-lifecycle.md
  */
 import { VTiltConfig, RemoteConfig } from "../types";
-/**
- * Interface for the VTilt instance methods needed by RemoteConfigManager.
- * Using a minimal interface avoids circular dependency.
- */
+import type { FeatureManager } from "./feature-manager";
 export interface RemoteConfigHost {
     getConfig(): VTiltConfig;
     updateConfig(config: Partial<VTiltConfig>): void;
+    buildEndpointUrl(path: string): string;
     __loaded: boolean;
-    startSessionRecording?(): void;
-    startAutocapture?(): void;
-    _initChat?(): void;
+    featureManager: FeatureManager;
 }
-/**
- * Callback when remote config is loaded/applied
- */
 export type RemoteConfigCallback = (config: RemoteConfig) => void;
 export declare class RemoteConfigManager {
     private _host;
     private _remoteConfig;
     private _onApply?;
     private _onLoad?;
+    private _initConfig;
     constructor(host: RemoteConfigHost);
-    /** Get the current remote config (may be null if not loaded) */
     get config(): RemoteConfig | null;
-    /** Set callback for when config is applied */
     onApply(callback: RemoteConfigCallback): void;
-    /** Set callback for when fresh config is loaded */
     onLoad(callback: RemoteConfigCallback): void;
     /**
      * Load remote config from cache and fetch fresh in background.
      * Priority: 1) Bootstrap config 2) Window bootstrap 3) localStorage cache
      */
     load(): void;
-    /**
-     * Fetch remote config from /decide endpoint.
-     */
     private _fetch;
     /**
      * Apply remote config to current config.
-     * Local config takes precedence over remote.
+     * Uses _initConfig snapshot: only values NOT set by the user in vt.init() are applied.
+     * Feature config is mapped via FeatureManager descriptors; non-feature config is handled inline.
+     *
+     * @param fromCache When true, analytics toggles are skipped to avoid acting on stale
+     *   localStorage data before the fresh /decide fetch resolves.
      */
     private _apply;
 }

package/dist/extensions/chat/bubble-drag.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Draggable bubble utility.
+ *
+ * Attaches pointer-based drag behavior to a fixed-position bubble element.
+ * Persists the drag offset in localStorage so the position survives page
+ * navigations and transfers between the lightweight and full bubbles.
+ */
+interface DraggableOptions {
+    /** Element that initiates the drag (defaults to the target element itself) */
+    handle?: HTMLElement;
+}
+interface DragHandle {
+    destroy: () => void;
+}
+/**
+ * Make a fixed-position element draggable.
+ *
+ * @param el      The element to reposition via translate3d.
+ * @param opts.handle  Optional drag handle element (e.g. bubble inside a container).
+ *                     Pointer events listen on the handle; transform applies to `el`.
+ *                     Defaults to `el` itself.
+ *
+ * - Restores persisted position from localStorage on attach.
+ * - Persists position on drag end.
+ * - Distinguishes click from drag via a 5px movement threshold.
+ *   When dragged, the subsequent `click` event on the handle is suppressed once.
+ * - Re-clamps on viewport resize.
+ */
+export declare function makeDraggable(el: HTMLElement, opts?: DraggableOptions): DragHandle;
+export {};

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

@@ -0,0 +1,15 @@
+/**
+ * Chat widget API – HTTP helpers and endpoint constants.
+ */
+import type { VTiltConfig } from "../../types";
+export declare const API: {
+    readonly channels: "/api/chat/widget/channels";
+    readonly messages: (channelId: string) => string;
+    readonly read: (channelId: string) => string;
+    readonly ablyToken: "/api/chat/token/widget";
+};
+/** Minimal host surface for HTTP helpers (lazy chat bundle must not rely on `VTilt` prototype methods). */
+export interface ApiRequestInstance {
+    getConfig(): Pick<VTiltConfig, "api_host" | "token">;
+}
+export declare function apiRequest<T>(instance: ApiRequestInstance, endpoint: string, options?: RequestInit): Promise<T | null>;

package/dist/extensions/chat/chat-styles.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Chat widget style and HTML string builders.
+ * Keeps all style/logic in TS (no separate CSS file), aligned with Intercom/PostHog.
+ */
+export type ChatWidgetPosition = "bottom-right" | "bottom-left";
+export interface ChatTheme {
+    primaryColor: string;
+    fontFamily: string;
+    borderRadius?: string;
+}
+export declare function getContainerStyles(theme: ChatTheme, position?: ChatWidgetPosition): string;
+export declare function getBubbleStyles(theme: ChatTheme): string;
+export declare function getBubbleHTML(): string;
+export declare function getWidgetStyles(): string;
+/**
+ * Container styles when the widget is fullscreen on mobile.
+ * The container (direct child of body) becomes the fullscreen overlay;
+ * any drag transform is cleared so position:fixed works correctly.
+ */
+export declare function getMobileContainerStyles(theme: ChatTheme): string;
+/**
+ * Widget styles when fullscreen on mobile.
+ * Widget fills the container with absolute positioning.
+ * Display is omitted — set by _updateUI based on open state.
+ */
+export declare function getMobileWidgetStyles(): string;
+export declare function getWidgetHTML(theme: ChatTheme): string;

package/dist/extensions/chat/chat-wrapper.d.ts

@@ -1,12 +1,9 @@
 /**
  * Chat Wrapper
  *
- * Lightweight wrapper that handles the decision of WHEN to load the chat widget.
+ * Extends LazyFeature to handle lazy-loading the chat widget script.
  * The actual chat logic is in LazyLoadedChat which is loaded on demand.
  *
- * Implements the Feature interface for consistent lifecycle management.
- * This follows the same pattern as SessionRecordingWrapper.
- *
  * ## Initialization Modes (Intercom-like flexibility)
  *
  * 1. **Snippet-only (dashboard configured)**:
@@ -30,193 +27,71 @@
  *    ```
  *
  * Code config always takes precedence over dashboard settings.
+ *
+ * @see docs/patterns/tracker-feature-lifecycle.md
  */
 import type { VTilt } from "../../vtilt";
-import type { VTiltConfig, RemoteConfig } from "../../types";
-import type { Feature } from "../../feature";
-import { type ChatConfig, type ChatChannelSummary, type ChatWidgetView } from "../../utils/globals";
+import type { VTiltConfig } from "../../types";
+import { LazyFeature } from "../../feature";
+import { type ChatConfig, type ChatChannelSummary, type ChatWidgetView, type LazyLoadedChatInterface, type SendChatMessageContent, type SendChatMessageOptions } from "../../utils/globals";
 import type { MessageCallback, TypingCallback, ConnectionCallback, Unsubscribe } from "./types";
-/** Status when lazy loading is in progress */
 export declare const CHAT_LOADING: "loading";
-/**
- * Chat Wrapper
- *
- * This is the lightweight class that lives in the main bundle.
- * Implements Feature for consistent lifecycle management.
- *
- * It handles:
- * - Auto-fetching settings from dashboard (Intercom-like)
- * - Merging server settings with code config
- * - Deciding if chat should be enabled
- * - Lazy loading the actual chat widget code
- * - Delegating to LazyLoadedChat
- * - Queuing messages/callbacks before widget loads
- */
-export declare class ChatWrapper implements Feature {
-    private readonly _instance;
+export declare class ChatWrapper extends LazyFeature<ChatConfig, LazyLoadedChatInterface> {
     readonly name = "Chat";
-    private _lazyLoadedChat;
-    private _config;
+    readonly scriptName = "chat";
     private _serverConfig;
     private _configFetched;
-    private _isLoading;
-    private _isStarted;
     private _loadError;
+    private _bubbleDragHandle;
     private _pendingMessages;
     private _pendingCallbacks;
     private _messageCallbacks;
     private _typingCallbacks;
     private _connectionCallbacks;
-    constructor(_instance: VTilt, config?: ChatConfig);
-    /**
-     * Extract chat config from VTiltConfig.
-     * Self-contained - vtilt.ts doesn't need to know config details.
-     */
+    /** True after vt.showChat() so preloaded widget stays visible after replacing the lightweight bubble. */
+    private _bubbleExplicitShow;
+    constructor(instance: VTilt, config?: ChatConfig);
     static extractConfig(config: VTiltConfig): ChatConfig;
     get isEnabled(): boolean;
-    get isStarted(): boolean;
     /**
-     * Start chat if enabled (Feature interface).
-     * This is async because it may fetch server settings.
+     * Chat has a custom start flow: fetch server settings, show bubble,
+     * lazy-load full widget on user interaction.
      */
     startIfEnabled(): void;
-    /**
-     * Stop the chat widget (Feature interface).
-     */
     stop(): void;
-    /**
-     * Handle config updates (Feature interface).
-     */
     onConfigUpdate(config: VTiltConfig): void;
-    /**
-     * Handle remote config updates (Feature interface).
-     */
-    onRemoteConfig(remoteConfig: RemoteConfig): void;
-    /**
-     * Async start implementation
-     */
+    protected _createLoaded(): LazyLoadedChatInterface;
+    protected _onLoaded(loaded: LazyLoadedChatInterface): void;
     private _startAsync;
-    /**
-     * Whether the chat widget is open
-     */
     get isOpen(): boolean;
-    /**
-     * Whether connected to realtime service
-     */
     get isConnected(): boolean;
-    /**
-     * Whether the widget is loading
-     */
     get isLoading(): boolean;
-    /**
-     * Number of unread messages
-     */
     get unreadCount(): number;
-    /**
-     * Current channel (if any)
-     */
     get channel(): import("./types").ChatChannel | null;
-    /**
-     * List of user's channels (multi-channel support)
-     */
     get channels(): ChatChannelSummary[];
-    /**
-     * Current view state ('list' or 'conversation')
-     */
     get currentView(): ChatWidgetView;
-    /**
-     * Open the chat widget
-     */
     open(): void;
-    /**
-     * Close the chat widget
-     */
     close(): void;
-    /**
-     * Toggle the chat widget open/closed
-     */
     toggle(): void;
-    /**
-     * Show the chat widget (make visible but not necessarily open)
-     */
     show(): void;
-    /**
-     * Hide the chat widget
-     */
     hide(): void;
-    /**
-     * Fetch/refresh the list of user's channels
-     */
     getChannels(): void;
-    /**
-     * Select a channel and load its messages
-     */
     selectChannel(channelId: string): void;
-    /**
-     * Create a new channel and enter it
-     */
     createChannel(): void;
-    /**
-     * Go back to channel list from conversation view
-     */
     goToChannelList(): void;
-    /**
-     * Send a message
-     */
-    sendMessage(content: string): void;
-    /**
-     * Mark messages as read
-     */
+    sendMessage(content: SendChatMessageContent, options?: SendChatMessageOptions): void;
     markAsRead(): void;
-    /**
-     * Subscribe to new messages
-     */
+    registerWidget(definition: Parameters<NonNullable<LazyLoadedChatInterface["registerWidget"]>>[0]): void;
     onMessage(callback: MessageCallback): Unsubscribe;
-    /**
-     * Subscribe to typing indicators
-     */
     onTyping(callback: TypingCallback): Unsubscribe;
-    /**
-     * Subscribe to connection changes
-     */
     onConnectionChange(callback: ConnectionCallback): Unsubscribe;
-    /**
-     * Update configuration
-     */
     updateConfig(config: Partial<ChatConfig>): void;
-    /**
-     * Get the merged configuration (server + code, code takes precedence)
-     */
     getMergedConfig(): ChatConfig;
-    /**
-     * Destroy the chat widget
-     */
     destroy(): void;
-    /**
-     * Fetch chat settings from the server
-     * This enables "snippet-only" installation where widget configures from dashboard
-     */
     private _fetchServerSettings;
-    /**
-     * Show the chat bubble (launcher button) without fully loading the widget
-     * This creates a lightweight bubble that loads the full widget on click
-     */
+    private _fetchUnreadForBubble;
     private _showBubble;
-    private get _scriptName();
-    /**
-     * Schedule preload on idle
-     */
+    private _onVisibilityChange;
     private _schedulePreload;
-    /**
-     * Lazy load and then execute callback
-     */
     private _lazyLoadAndThen;
-    /**
-     * Lazy load the chat script
-     */
-    private _lazyLoad;
-    /**
-     * Called after the chat script is loaded
-     */
-    private _onScriptLoaded;
 }

package/dist/extensions/chat/chat.d.ts

@@ -2,8 +2,9 @@
  * Chat Widget - Lazy loaded chat implementation using Ably for real-time messaging.
  */
 import type { VTilt } from "../../vtilt";
-import { type ChatConfig, type ChatChannel, type ChatChannelSummary, type ChatWidgetView, type LazyLoadedChatInterface } from "../../utils/globals";
+import { type ChatConfig, type ChatChannel, type ChatChannelSummary, type ChatWidgetView, type LazyLoadedChatInterface, type SendChatMessageContent, type SendChatMessageOptions } from "../../utils/globals";
 import { type MessageCallback, type TypingCallback, type ConnectionCallback, type Unsubscribe } from "./types";
+import { type WidgetContext } from "./widget-registry";
 export declare class LazyLoadedChat implements LazyLoadedChatInterface {
     private _instance;
     private _config;
@@ -11,10 +12,19 @@ export declare class LazyLoadedChat implements LazyLoadedChatInterface {
     private _container;
     private _widget;
     private _bubble;
+    private _bubbleDragHandle;
+    private _chatTheme;
+    private _widgetResizeCleanup;
     private _ably;
+    private _notificationsChannel;
     private _ablyChannel;
     private _typingChannel;
     private _connectionState;
+    private _ablyProjectId;
+    /** Channel id included in the last per-channel Ably token authorize. */
+    private _realtimeChannelId;
+    /** Channel id we are connecting to (select/create in flight). */
+    private _pendingRealtimeChannelId;
     private _messageCallbacks;
     private _typingCallbacks;
     private _connectionCallbacks;
@@ -22,6 +32,9 @@ export declare class LazyLoadedChat implements LazyLoadedChatInterface {
     private _isUserTyping;
     private _initialUserReadAt;
     private _isMarkingRead;
+    private _widgetRegistry;
+    /** Tracks whether show() was explicitly called (vs open() temporarily revealing the container). */
+    private _bubbleExplicitShow;
     constructor(instance: VTilt, config?: ChatConfig);
     get isOpen(): boolean;
     get isConnected(): boolean;
@@ -48,9 +61,15 @@ export declare class LazyLoadedChat implements LazyLoadedChatInterface {
     getChannels(): Promise<void>;
     selectChannel(channelId: string): Promise<void>;
     createChannel(): Promise<void>;
-    goToChannelList(): void;
-    sendMessage(content: string): Promise<void>;
+    goToChannelList(): Promise<void>;
+    sendMessage(content: SendChatMessageContent, options?: SendChatMessageOptions): Promise<void>;
     markAsRead(): void;
+    /**
+     * Send a silent trigger to the messages API after a widget action completes.
+     * This makes the AI respond to the action (e.g., acknowledge email collection)
+     * without creating a visible user message in the chat.
+     */
+    private _triggerAIAfterWidgetAction;
     private _autoMarkAsRead;
     private _isMessageReadByUser;
     /**
@@ -62,32 +81,87 @@ export declare class LazyLoadedChat implements LazyLoadedChatInterface {
     onTyping(callback: TypingCallback): Unsubscribe;
     onConnectionChange(callback: ConnectionCallback): Unsubscribe;
     destroy(): void;
-    private _connectRealtime;
-    private _disconnectRealtime;
+    /**
+     * Ensure Ably client is connected and subscribed to the project notifications channel.
+     * Called when the widget opens. Safe to call multiple times.
+     */
+    private _ensureAblyConnected;
+    /**
+     * Request an Ably token for the current connection scope.
+     * Pass channelId when subscribing to a conversation; omit on channel list.
+     */
+    private _refreshAblyToken;
+    /**
+     * Subscribe to per-channel messages and typing for a specific conversation.
+     */
+    private _connectChannel;
+    /**
+     * Unsubscribe, detach, and release per-channel Ably channels.
+     * Ably only allows release() when the channel is initialized, detached, or
+     * failed — not when attached. So we detach first, then release.
+     * Releasing removes the channel from the Ably internal registry so a
+     * subsequent auth.authorize() with narrower capabilities won't try to
+     * reattach it and fail with "Channel denied access."
+     */
+    private _disconnectChannel;
+    /**
+     * Fully disconnect from Ably — unsubscribe everything and close the connection.
+     */
+    private _disconnectAll;
+    /**
+     * Handle project-level notifications (new channels, updates, closes).
+     * Updates channel list and badge count in real time.
+     */
+    private _handleNotification;
     private _handleNewMessage;
     private _handleTypingEvent;
     private _handleReadCursorEvent;
     private _notifyConnectionChange;
     private _createUI;
     private _attachEventListeners;
+    /**
+     * Mark a widget as submitted in local message metadata.
+     * Called after a successful widget action — _renderWidgets() uses this
+     * to show the confirmation UI instead of the input form.
+     */
+    private _markWidgetSubmitted;
     private _handleUserTyping;
     private _sendTypingIndicator;
     private _handleSend;
     private _updateUI;
+    private _isMobile;
+    private _containerBaseStyle;
+    private _savedTransform;
+    private _isMobileFullscreen;
+    /**
+     * Mobile fullscreen: make the *container* fullscreen instead of the widget.
+     * Using position:fixed on the widget is unreliable because the container
+     * may have a CSS transform (from drag) which creates a new containing block.
+     * The container is a direct child of <body> so position:fixed is always safe.
+     *
+     * Both elements get their full style replaced atomically via setAttribute.
+     * Display is set by _updateUI after this call.
+     */
+    private _applyMobileFullscreen;
+    private _removeMobileFullscreen;
+    private _scrollY;
+    private _lockBodyScroll;
+    /**
+     * Ensure the opened widget:
+     * 1. Covers the bubble (anchored at container bottom-right) for UI consistency.
+     * 2. Stays fully inside the viewport by shifting its position when near edges (no size change).
+     *
+     * On mobile the CSS media query handles fullscreen positioning, so this is a no-op.
+     */
+    private _constrainWidgetToViewport;
     private _updateHeader;
     private _getChannelListHTML;
     private _getChannelItemHTML;
     private _getConversationHTML;
     private _attachChannelListListeners;
     private _attachConversationListeners;
-    private _escapeHtml;
     private _formatRelativeTime;
     private _renderMessages;
-    private _getContainerStyles;
-    private _getBubbleStyles;
-    private _getBubbleHTML;
-    private _getWidgetStyles;
-    private _getWidgetHTML;
     private _getMessageHTML;
     private _isMessageReadByAgent;
     /**
@@ -99,8 +173,51 @@ export declare class LazyLoadedChat implements LazyLoadedChatInterface {
      * Remove temporary message by ID
      */
     private _removeTempMessage;
-    private _apiRequest;
     private _getTimeOpen;
+    /**
+     * Bubble body for any message — plain escaped text or sanitized rich HTML,
+     * using the same rules for user (html/markdown) and agent/AI messages.
+     */
+    private _renderMessageContent;
+    private _renderMessageHtml;
+    /**
+     * Render widgets for a message. Widget data sources (checked in order):
+     * 1. metadata._widgets -- set during streaming (temp messages)
+     * 2. metadata.widgets -- persisted in DB (loaded on refresh, received via Ably)
+     * 3. Content markers -- fallback for legacy messages with <!--vtilt:widget:...--> in content
+     *
+     * If a widget has submitted=true in metadata, render the confirmation instead of the input.
+     */
+    private _renderWidgets;
+    /**
+     * Build WidgetContext for widget renderers.
+     */
+    private _getWidgetContext;
+    /**
+     * Extract widget blocks from streamed text, strip them, and return parsed widgets.
+     */
+    private _parseWidgetBlocks;
+    /**
+     * Public method for SDK consumers to register custom widgets.
+     */
+    registerWidget(definition: {
+        type: string;
+        toolDescription: string;
+        parameters: Record<string, {
+            type: string;
+            description: string;
+        }>;
+        render: (params: Record<string, unknown>, context: WidgetContext) => string;
+        onAction: (action: string, data: Record<string, unknown>, context: WidgetContext) => Promise<{
+            replaceHTML?: string;
+            sendMessage?: string;
+        }>;
+    }): void;
     private _escapeHTML;
+    /**
+     * Get a human-readable preview for a message (for channel list).
+     * Falls back to widget labels if content is empty (tool-only messages).
+     */
+    private _getMessagePreview;
     private _formatTime;
 }

package/dist/extensions/chat/message-content-styles.d.ts

@@ -0,0 +1 @@
+export declare const CHAT_MESSAGE_CONTENT_CSS = "\n  #vtilt-chat-widget .vtilt-md {\n    max-width: 100%;\n    overflow-wrap: anywhere;\n    word-break: break-word;\n    font-size: inherit;\n    line-height: 1.45;\n  }\n  #vtilt-chat-widget .vtilt-md * {\n    box-sizing: border-box;\n  }\n  #vtilt-chat-widget .vtilt-md :is(p, h1, h2, h3, h4, h5, h6, ul, ol, blockquote, pre) {\n    margin: 0;\n  }\n  #vtilt-chat-widget .vtilt-md p { margin: 0 0 0.5em 0; }\n  #vtilt-chat-widget .vtilt-md p:last-child { margin-bottom: 0; }\n  #vtilt-chat-widget .vtilt-md :is(b, strong) { font-weight: 600; }\n  #vtilt-chat-widget .vtilt-md :is(i, em) { font-style: italic; }\n  #vtilt-chat-widget .vtilt-md u { text-decoration: underline; }\n  #vtilt-chat-widget .vtilt-md :is(h1, h2, h3, h4, h5, h6) {\n    font-size: 1em;\n    font-weight: 600;\n    margin: 0.65em 0 0.35em 0;\n    line-height: 1.3;\n  }\n  #vtilt-chat-widget .vtilt-md :is(h1, h2, h3):first-child { margin-top: 0.15em; }\n\n  /* Lists \u2014 flex rows + ::before bullets (beats host list-item / ::marker resets) */\n  #vtilt-chat-widget .vtilt-md :is(ul, ol) {\n    list-style: none !important;\n    margin: 0.5em 0 !important;\n    padding: 0 0 0 0.35em !important;\n  }\n  #vtilt-chat-widget .vtilt-md li {\n    display: flex !important;\n    flex-direction: row !important;\n    flex-wrap: wrap !important;\n    align-items: flex-start !important;\n    gap: 0.35em !important;\n    margin: 0.2em 0 !important;\n    padding: 0 !important;\n    line-height: 1.45;\n    list-style: none !important;\n    list-style-type: none !important;\n  }\n  #vtilt-chat-widget .vtilt-md li::marker {\n    content: \"\" !important;\n    font-size: 0 !important;\n    color: transparent !important;\n  }\n  #vtilt-chat-widget .vtilt-md li::-webkit-list-marker {\n    display: none !important;\n  }\n  #vtilt-chat-widget .vtilt-md ul > li::before {\n    content: \"\u2022\" !important;\n    display: inline-block !important;\n    position: static !important;\n    flex: 0 0 auto;\n    line-height: 1.45;\n  }\n  #vtilt-chat-widget .vtilt-md ul ul > li::before {\n    content: \"\u25E6\" !important;\n  }\n  #vtilt-chat-widget .vtilt-md ol { counter-reset: vtilt-ol; }\n  #vtilt-chat-widget .vtilt-md ol > li { counter-increment: vtilt-ol; }\n  #vtilt-chat-widget .vtilt-md ol > li::before {\n    content: counter(vtilt-ol) \".\" !important;\n    display: inline-block !important;\n    position: static !important;\n    flex: 0 0 auto;\n    min-width: 1.1em;\n    line-height: 1.45;\n  }\n  #vtilt-chat-widget .vtilt-md ol ol { counter-reset: vtilt-ol; }\n  #vtilt-chat-widget .vtilt-md li > :is(ul, ol) {\n    flex: 1 0 100% !important;\n    width: 100% !important;\n    margin: 0.25em 0 0 0 !important;\n    padding-left: 0.75em !important;\n  }\n\n  #vtilt-chat-widget .vtilt-md code {\n    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;\n    font-size: 0.9em;\n    background: rgba(0, 0, 0, 0.06);\n    padding: 0.1em 0.35em;\n    border-radius: 4px;\n  }\n  #vtilt-chat-widget .vtilt-md pre {\n    margin: 0.5em 0;\n    padding: 0.5em 0.65em;\n    border-radius: 6px;\n    background: rgba(0, 0, 0, 0.06);\n    overflow-x: auto;\n    white-space: pre-wrap;\n  }\n  #vtilt-chat-widget .vtilt-md pre code { background: none; padding: 0; }\n  #vtilt-chat-widget .vtilt-md blockquote {\n    margin: 0.5em 0;\n    padding-left: 0.75em;\n    border-left: 3px solid rgba(0, 0, 0, 0.15);\n  }\n  #vtilt-chat-widget .vtilt-md a { color: inherit; text-decoration: underline; }\n  #vtilt-chat-widget .vtilt-md br { line-height: inherit; }\n\n  /* Widget visitor bubble (brand color) */\n  #vtilt-chat-widget .vtilt-user-md code { background: rgba(255, 255, 255, 0.2); }\n  #vtilt-chat-widget .vtilt-user-md pre { background: rgba(255, 255, 255, 0.15); }\n  #vtilt-chat-widget .vtilt-user-md pre code { background: none; }\n  #vtilt-chat-widget .vtilt-user-md blockquote { border-left-color: rgba(255, 255, 255, 0.35); }\n";

package/dist/extensions/chat/message-html.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Convert stored message content to safe HTML for bubble rendering.
+ */
+export declare function formatMessageBodyHtml(text: string, contentType: "text" | "html" | "attachment", doc: Document | null): string;
+/** Plain-text preview for channel list (strips widgets and HTML). */
+export declare function plainTextMessagePreview(content: string, maxLength?: number): string;

package/dist/extensions/chat/message-markdown.d.ts

@@ -0,0 +1,8 @@
+/** Detect content that already contains HTML block-level tags. */
+export declare const HTML_BLOCK_TAG_RE: RegExp;
+/**
+ * Best-effort markdown → HTML. Returns input unchanged when it already looks like HTML.
+ */
+export declare function markdownToHtml(src: string): string;
+/** Whether markdown conversion should run before sanitization. */
+export declare function shouldUseMarkdownPipeline(contentType: "text" | "html" | "attachment", cleanText: string): boolean;

package/dist/extensions/chat/normalize-send-content.d.ts

@@ -0,0 +1,24 @@
+import type { SendChatMessageContent, SendChatMessageOptions } from "../../utils/globals";
+import type { ContentType } from "./types";
+/** Metadata key for markdown stored as `content_type: text`. Must match dashboard `message-rendering.ts`. */
+export declare const RICH_FORMAT_METADATA_KEY = "rich_format";
+export declare const RICH_FORMAT_MARKDOWN = "markdown";
+export interface NormalizedOutgoingMessage {
+    content: string;
+    content_type: ContentType;
+    metadata: Record<string, unknown>;
+}
+export declare function isRichUserMessage(message: {
+    content_type: string;
+    metadata?: Record<string, unknown>;
+}): boolean;
+/** Whether a stored message should use the rich HTML renderer in the widget. */
+export declare function messageUsesRichRendering(message: {
+    sender_type: string;
+    content_type: string;
+    metadata?: Record<string, unknown>;
+}): boolean;
+/**
+ * Normalize integrator input into stored message fields.
+ */
+export declare function normalizeSendChatMessageContent(input: SendChatMessageContent, options?: SendChatMessageOptions): NormalizedOutgoingMessage | null;