@syntrologie/adapt-chatbot 2.8.0-canary.64 → 2.8.0-canary.641

package/dist/AdaptiveChatBar.ask-bar.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The ask-bar canvas hosts the chat bar with its own trail hidden, reads the
+ * conversation through the transcript event, and focuses the input inside the
+ * shopper's tap (FEAT-1793648175).
+ */
+export {};
+//# sourceMappingURL=AdaptiveChatBar.ask-bar.test.d.ts.map

package/dist/AdaptiveChatBar.ask-bar.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdaptiveChatBar.ask-bar.test.d.ts","sourceRoot":"","sources":["../src/AdaptiveChatBar.ask-bar.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/AdaptiveChatBar.composer.test.d.ts

@@ -0,0 +1,2 @@
+import './AdaptiveChatBar';
+//# sourceMappingURL=AdaptiveChatBar.composer.test.d.ts.map

package/dist/AdaptiveChatBar.composer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdaptiveChatBar.composer.test.d.ts","sourceRoot":"","sources":["../src/AdaptiveChatBar.composer.test.ts"],"names":[],"mappings":"AAkBA,OAAO,mBAAmB,CAAC"}

package/dist/AdaptiveChatBar.d.ts

@@ -0,0 +1,280 @@
+/**
+ * AdaptiveChatBar — the canvas lid composition for the chat-canvas
+ * experience. Renders the bubble-up trail on top and an always-visible
+ * input row below.
+ *
+ * Wiring contract (events out):
+ *   - `chat-message-sent` ({ text, via, turn }): the user submitted text
+ *     via Enter, the send button, an intro suggestion, or a reply pill.
+ *     The owning code is responsible for pushing this into the
+ *     conversation history and producing a reply.
+ *
+ * Wiring contract (props in):
+ *   - `messages`: the conversation trail, passed straight through to
+ *     `<adaptive-chat-trail>`.
+ *   - `placeholder`: input placeholder copy. Defaults to a generic
+ *     "Ask, find, or navigate…" — the host (typically the slot's lid
+ *     widget mount) can override to a context-specific string.
+ *
+ * Light DOM. Glassmorphism is applied at the input-row level so the
+ * trail above floats over the host page without chrome. See PRD §4.4.
+ */
+import { LitElement } from 'lit';
+import { type InlineTrailWidget, type InlineWidgetMounter, type TileReceipt, type TrailMessage } from './AdaptiveChatTrail.js';
+import { type ChatPersona } from './personas.js';
+export declare class AdaptiveChatBar extends LitElement {
+    #private;
+    static properties: {
+        personas: {
+            attribute: boolean;
+        };
+        _persona: {
+            state: boolean;
+        };
+        messages: {
+            attribute: boolean;
+        };
+        placeholder: {
+            type: StringConstructor;
+        };
+        assistantName: {
+            type: StringConstructor;
+        };
+        greeting: {
+            type: StringConstructor;
+        };
+        inFlight: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+        turn: {
+            type: NumberConstructor;
+        };
+        thinkingText: {
+            attribute: boolean;
+        };
+        introSuggestion: {
+            attribute: boolean;
+        };
+        forceExpanded: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+        maximized: {
+            type: BooleanConstructor;
+        };
+        readOnly: {
+            type: BooleanConstructor;
+            attribute: string;
+        };
+        chatControl: {
+            type: StringConstructor;
+        };
+        interleaved: {
+            type: BooleanConstructor;
+        };
+        controlsTabIndex: {
+            attribute: boolean;
+        };
+        tileReceipts: {
+            attribute: boolean;
+        };
+        inlineWidgets: {
+            attribute: boolean;
+        };
+        mountInlineWidget: {
+            attribute: boolean;
+        };
+        voiceInput: {
+            type: BooleanConstructor;
+        };
+        _input: {
+            state: boolean;
+        };
+        _composerFocused: {
+            state: boolean;
+        };
+        _micListening: {
+            state: boolean;
+        };
+        _micDisabled: {
+            state: boolean;
+        };
+    };
+    messages: TrailMessage[];
+    /**
+     * Mirrored from the chat session by the mountable. The bar keeps no
+     * counter of its own — this is the number of sends already committed;
+     * a send this bar makes opens turn `this.turn + 1`.
+     */
+    turn: number;
+    maximized: boolean;
+    /** Preview frames: shows the given messages, accepts no input. */
+    readOnly: boolean;
+    /**
+     * Which trailing control the bar renders.
+     *
+     * An explicit literal, never inferred from the presence of a prop: a canvas
+     * that forgot to inject it would otherwise silently get the wrong control.
+     * Default keeps velvet's behaviour untouched.
+     */
+    chatControl: 'maximize' | 'interleave' | 'none';
+    /** Reflected state for the interleave control. Owned by the canvas. */
+    interleaved: boolean;
+    /**
+     * `tabindex` for every control in the composer row (input, send, mic and
+     * the trailing control); null (the default) leaves it absent. The ask-bar
+     * canvas keeps this bar rendered but see-through while closed so the
+     * runtime can focus it inside the opening tap, and passes -1 then: the
+     * resting launcher bar is the keyboard entry point, so Tab must skip the
+     * whole row (FEAT-1793648175).
+     */
+    controlsTabIndex: number | null;
+    tileReceipts: TileReceipt[];
+    /** Widgets rendered inline in the trail (reco carousel), sourced from
+     *  the store's `chat-inline` slot mounts. Forwarded to the trail. */
+    inlineWidgets: InlineTrailWidget[];
+    /** Registry-backed mounter for inline widgets whose id is not their
+     *  custom-element tag (product card, comparison, FAQ). Set by the
+     *  mountable from `runtime.widgets`; forwarded to the trail. */
+    mountInlineWidget: InlineWidgetMounter | undefined;
+    /**
+     * Live reasoning narration from the model — streamed in via
+     * AG-UI THINKING_TEXT_MESSAGE_CONTENT events and forwarded by
+     * the ChatSession subscription on the host (mountable).
+     * Forwarded verbatim to the trail, which renders it in place of
+     * the silent loading dots between turns. Empty string when no
+     * thinking turn is active.
+     */
+    thinkingText: string;
+    /**
+     * Pre-conversation suggestion button — forwarded to the trail's
+     * empty-state pane. When the visitor clicks it the trail emits
+     * `trail-intro-suggestion`; we catch that here and submit the
+     * configured prompt through the normal send path.
+     */
+    introSuggestion: {
+        label: string;
+        prompt: string;
+    } | undefined;
+    /** Pass-through to {@link AdaptiveChatTrail}'s ``forceExpanded`` prop.
+     *  Hosts that mount the chat-bar in a full-screen surface (mobile
+     *  panel, agent app, etc.) set this to skip the collapse affordance
+     *  — there is no smaller state to fall back to. */
+    forceExpanded: boolean;
+    placeholder: string;
+    /**
+     * Name shown in the (forceExpanded) header. Defaults to a generic
+     * "Assistant". Hosts can override per-workspace (e.g. Vela sets
+     * "Vela Concierge") without inventing new SDK surface — it threads
+     * through the same mount config the placeholder does.
+     */
+    assistantName: string;
+    /** Persona roster from config (FEAT-1784917430); one is sticky-assigned. */
+    personas: ChatPersona[] | null;
+    /** @internal — the visitor's sticky persona, resolved from the roster. */
+    _persona: ChatPersona | null;
+    /**
+     * Initial assistant message shown before any real conversation
+     * starts. Renders inside the trail as a phantom assistant chip
+     * when messages.length === 0; auto-disappears as soon as the
+     * first user message lands. Mirrors ChatAssistantLit's greeting.
+     */
+    greeting: string | undefined;
+    /**
+     * Whether a chat round-trip is in flight (request sent, awaiting
+     * reply). The single send/stop button morphs accordingly: ↑ when
+     * ready, ⏹ when in-flight. Parent owns this state — set true after
+     * `chat-message-sent` fires, false when the reply lands or the
+     * request is aborted. Enter is inert while in-flight.
+     */
+    inFlight: boolean;
+    /** Show a dictation mic when the Web Speech API is available. Config-gated, default off. */
+    voiceInput: boolean;
+    _input: string;
+    _micListening: boolean;
+    _micDisabled: boolean;
+    private _micBase;
+    private _micNetworkErrors;
+    private _dictation;
+    /** True while focus is inside the composer row — drives the accent
+     *  focus ring so the active text-entry surface is unmistakable on any
+     *  theme (the idle pill is deliberately subtle). */
+    _composerFocused: boolean;
+    createRenderRoot(): HTMLElement;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onInput;
+    private _onMicClick;
+    private _onKeyDown;
+    private _onSendOrInterrupt;
+    private _onTileReceiptActivate;
+    private _onAlertReceiptActivate;
+    private _onComposerFocusIn;
+    private _onComposerFocusOut;
+    private _onMaximizeToggle;
+    /**
+     * Focus the composer input now. Synchronous on purpose: iOS only raises the
+     * keyboard for a focus() inside the shopper's tap, so a canvas cannot wait
+     * for a render. Returns whether the input really took focus (false when
+     * read-only or not rendered yet).
+     */
+    focusInput(): boolean;
+    /**
+     * Send one of the agent's suggested replies as the shopper's message, the
+     * way a tap on the trail's reply chip does (queued, never dropped, while a
+     * reply is still closing). For a canvas that draws the chips itself
+     * because it hides this bar's trail.
+     */
+    sendSuggestedReply(text: string): void;
+    /**
+     * A canvas that hides this bar's trail (`chatControl: 'none'`) still has to
+     * show the conversation, so the bar publishes it (FEAT-1793648175). Only
+     * then: a bar showing its own trail dispatches nothing, as before
+     * (Ruling R18). Switching to 'none' publishes what the bar already holds.
+     */
+    protected updated(changed: Map<string, unknown>): void;
+    private _onInterleaveToggle;
+    /** The one channel every send path uses; `turn` is the turn this send opens. */
+    private _dispatchSent;
+    private _send;
+    /**
+     * Visitor tapped the intro suggestion button in the empty-state
+     * trail. Submit the configured prompt through the same channel as
+     * a typed message so listeners (mountable → chatSession.send) see
+     * a uniform shape — no need for a parallel "suggestion-sent" path.
+     * The trail's intro pane auto-disappears the moment the first
+     * message lands, so this also closes the empty state in one go.
+     */
+    private _onIntroSuggestion;
+    /**
+     * Reply-chip tap that arrived during the run TAIL. Chips render the
+     * moment the reply text lands, but `inFlight` (which includes
+     * `runActive` — typing events, tool tail, RUN_FINISHED) can lag for
+     * seconds. The old `if (this.inFlight) return;` guard silently ATE
+     * those taps — the visitor's chosen reply never appeared as their
+     * message (live repro, deployed vela 2026-07-08). Now the tap queues
+     * (latest wins) and dispatches when `inFlight` clears.
+     */
+    private _queuedSuggestedReply;
+    protected willUpdate(changed: Map<string, unknown>): void;
+    /**
+     * Visitor tapped an inline `suggest_replies` chip in the trail. Submit
+     * the chip text through the SAME `chat-message-sent` channel a typed
+     * message uses, so the reply rides the existing send path (mountable →
+     * chatSession.send → transport) — no fabricated AG-UI events. The
+     * trail clears the chips on its own once the reply lands and a newer
+     * assistant turn becomes the latest.
+     *
+     * A tap while the previous run is still closing is QUEUED, never
+     * dropped — see `_queuedSuggestedReply`.
+     */
+    private _onSuggestedReply;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'adaptive-chat-bar': AdaptiveChatBar;
+    }
+}
+//# sourceMappingURL=AdaptiveChatBar.d.ts.map

package/dist/AdaptiveChatBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdaptiveChatBar.d.ts","sourceRoot":"","sources":["../src/AdaptiveChatBar.ts"],"names":[],"mappings":"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"}

package/dist/AdaptiveChatBar.interleave.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The chat bar's trailing control is chosen by an explicit mode string.
+ *
+ * Keying on the PRESENCE of a prop would mean a canvas that forgets to inject
+ * it silently gets the wrong control, so `chatControl` is a literal the caller
+ * states. Default stays `'maximize'` so velvet is untouched.
+ */
+export {};
+//# sourceMappingURL=AdaptiveChatBar.interleave.test.d.ts.map

package/dist/AdaptiveChatBar.interleave.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdaptiveChatBar.interleave.test.d.ts","sourceRoot":"","sources":["../src/AdaptiveChatBar.interleave.test.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/AdaptiveChatBar.js

@@ -0,0 +1,12 @@
+import {
+  AdaptiveChatBar
+} from "./chunk-Q6LWX6IF.js";
+import "./chunk-EWPPVPJ4.js";
+import "./chunk-QQOQJPXA.js";
+import "./chunk-SIHWRD2B.js";
+import "./chunk-VGWC2UIK.js";
+import "./chunk-LY5AGXVD.js";
+export {
+  AdaptiveChatBar
+};
+//# sourceMappingURL=AdaptiveChatBar.js.map

package/dist/AdaptiveChatBar.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/AdaptiveChatBarMountable.d.ts

@@ -0,0 +1,93 @@
+/**
+ * AdaptiveChatBarMountable — `MountableWidget` adapter that turns the
+ * standalone `<adaptive-chat-bar>` Lit element into something the
+ * runtime widget registry can mount.
+ *
+ * Registered as widget id `adaptive-chatbot:chat-bar`. Customers
+ * reference it from canvas config — either as a slot's `lid` widget
+ * (replaces the launcher when referenced from `slots.drawer.lid`) or
+ * as a regular tile widget.
+ *
+ * The bar is a VIEW. State lives in the singleton `chatSession` —
+ * whether the bar mounts in the mini-canvas lid, the drawer lid, or
+ * both, they're all views of the same conversation. The mountable:
+ *   - subscribes to chatSession.subscribe() and pushes state into
+ *     the bar's `messages` + `inFlight` props on every change
+ *   - routes the bar's `chat-message-sent` event → chatSession.send()
+ *   - routes the bar's `chat-interrupt` event → chatSession.interrupt()
+ *   - bubbles the bar's `canvas-close` event → optional onClose
+ *     callback (canvas-level concern, not session-level)
+ *
+ * Props (passed via mountConfig):
+ *   - `placeholder?: string` — input placeholder copy
+ *   - `onClose?: () => void` — fires on ✕ click (canvas-level)
+ *
+ * Note: messages and inFlight are NOT props. They flow from chatSession.
+ * A canvas-config author who wants to pre-seed messages should do so
+ * via the session directly (e.g. via a startup action) — but typical
+ * use is to let the conversation start empty.
+ */
+import './AdaptiveChatBar';
+import type { ChatbotWidgetRuntime } from './types.js';
+/**
+ * Every canvas-settable field this function is responsible for forwarding.
+ *
+ * This list exists because the function above is a hand-written allowlist —
+ * the cherry-pick shape COE-001 is about. A canvas can set a prop on its chat
+ * tile, `sc-mount` will hand it to `mount()`, and if the name is missing from
+ * `applyPlaceholder` it is silently dropped with no type error and no test
+ * failure. That is exactly how velvet-stream's interleave control shipped
+ * dead: the canvas set `chatControl`, nothing forwarded it, the bar kept its
+ * default, and the button never rendered.
+ *
+ * `AdaptiveChatBarMountable.forwarding.test.ts` drives the real mount path and
+ * asserts each of these actually lands on the element, so the next field added
+ * to the config and forgotten here fails rather than vanishing.
+ */
+export declare const FORWARDED_BAR_FIELDS: readonly ["placeholder", "assistantName", "personas", "greeting", "voiceInput", "introSuggestion", "forceExpanded", "maximized", "chatControl", "interleaved", "controlsTabIndex"];
+/**
+ * Test-only: drop the warm store singleton (and its hydration latch) so each
+ * test can wire a fresh store to its own event bus / registry. Without this,
+ * the first test in a file permanently binds the store to ITS bus and the
+ * per-instance version dedup silently drops every later test's re-mounts.
+ * Mirrors `observer/index.ts` `_resetObserverForTests`.
+ */
+export declare function _resetElementStoreForTests(): void;
+/**
+ * Live ``template_id → widget`` map. Re-derived on each ``configure()``
+ * from the chat-bar's ``uiTemplates`` prop (which mirrors what the admin
+ * declared in canvas-config). Both the TileHandler (live mount path) and
+ * the ElementInstanceStore (rehydrate replay path) read through this map
+ * so the widget id stays consistent regardless of mount provenance.
+ *
+ * Without this, an LLM-authored mount with ``template_id: "product-card"``
+ * emits ``widget: "product-card"`` to the runtime, which then renders the
+ * tile chrome with a "Widget not available: product-card" body because
+ * the actual widget is registered as ``adaptive-product:card``.
+ */
+export declare function resolveTileWidget(templateId: string): string | undefined;
+export declare function refreshTemplateWidgetMap(templates: Record<string, unknown> | undefined): void;
+export { buildObserverEnrich } from './observer/wire';
+/**
+ * Surface reaction to a proactive nudge (FEAT-1783640628). The transport
+ * settles the nudge message into the trail and emits `syntro:nudge`; this
+ * layer owns what the VISITOR notices on top of that:
+ *   1. refresh persisted mounts — the headless turn's mount landed server-side
+ *      in `mounted_elements`; re-running the replay fetch applies it live
+ *      through the same hydrate path boot uses (no parallel mount wire shape);
+ *   2. a toast via the canvas overlay's notification primitive, so a visitor
+ *      with the chat closed learns the agent spoke.
+ *
+ * Exported for direct testing (real DOM listener, fetch-stubbed network).
+ */
+export declare function wireNudgeSurface(runtime: ChatbotWidgetRuntime, backendUrl: string): void;
+/** Test seam: reset the nudge-surface once-guard AND detach the listener. */
+export declare function _resetNudgeSurfaceForTests(): void;
+/** @internal test hook */
+export declare function _resetTemplatePublishForTests(): void;
+export declare function _resetMountableObserverForTests(): void;
+export declare const AdaptiveChatBarMountable: {
+    mount(container: HTMLElement, mountConfig?: Record<string, unknown>): () => void;
+    update(container: HTMLElement, mountConfig?: Record<string, unknown>): void;
+};
+//# sourceMappingURL=AdaptiveChatBarMountable.d.ts.map

package/dist/AdaptiveChatBarMountable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdaptiveChatBarMountable.d.ts","sourceRoot":"","sources":["../src/AdaptiveChatBarMountable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,mBAAmB,CAAC;AA+B3B,OAAO,KAAK,EAAmB,oBAAoB,EAAE,MAAM,YAAY,CAAC;AA0IxE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,oLAYvB,CAAC;AAuBX;;;;;;GAMG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAMjD;AACD;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKxE;AACD,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAAG,IAAI,CAG7F;AAuCD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAMtD;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CA0DxF;AAED,6EAA6E;AAC7E,wBAAgB,0BAA0B,IAAI,IAAI,CAGjD;AAmHD,0BAA0B;AAC1B,wBAAgB,6BAA6B,IAAI,IAAI,CAEpD;AAiFD,wBAAgB,+BAA+B,IAAI,IAAI,CAQtD;AAmED,eAAO,MAAM,wBAAwB;qBAClB,WAAW,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,IAAI;sBA4H9D,WAAW,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;CAqB5E,CAAC"}

package/dist/AdaptiveChatTrail.anchor-scroll.test.d.ts

@@ -0,0 +1,2 @@
+import './AdaptiveChatTrail';
+//# sourceMappingURL=AdaptiveChatTrail.anchor-scroll.test.d.ts.map

package/dist/AdaptiveChatTrail.anchor-scroll.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdaptiveChatTrail.anchor-scroll.test.d.ts","sourceRoot":"","sources":["../src/AdaptiveChatTrail.anchor-scroll.test.ts"],"names":[],"mappings":"AA0BA,OAAO,qBAAqB,CAAC"}