@syntrologie/adapt-chatbot 2.8.0-canary.62 → 2.8.0-canary.621

package/dist/LeaveAMessageLit.d.ts

@@ -0,0 +1,329 @@
+/**
+ * <syntro-leave-a-message> — escalation-only async human handoff
+ * (spec: docs/superpowers/specs/2026-08-13-async-handoff-crisp-design.md).
+ * Five states: form (compose only) → email (optional, fallback framing) →
+ * sent → mail ("You got mail!") → flipped (reply + inline follow-up). All
+ * delivery through an injected SupportChatBridge; fail closed when the
+ * bridge is absent or the vendor SDK undetected.
+ *
+ * REDESIGN (owner brief, 2026-08-13): the compose step used to bundle an
+ * email input + message textarea + one Send button into a single
+ * "required everything up front" form. That's backwards — the message is
+ * the thing that matters (it's already drafted for the visitor); email is
+ * a nice-to-have fallback for if they leave the page before a reply
+ * arrives. So: send the message FIRST (compose step, message box only),
+ * THEN ask for email as a distinct, skippable second step. Every visitor-
+ * facing string moved to `copy` (workspace configuration) — the bundle
+ * ships no English fallback text anywhere; absent copy means that piece
+ * does not render (mirrors the pre-existing `replyToast` precedent).
+ *
+ * FINAL LAYOUT CORRECTION (owner, same day): the send/submit control lives
+ * INSIDE the field's own border — bottom-right, exactly like
+ * `<syntro-chat>`'s composer — never below the field, never beside it as a
+ * sibling button. And nothing renders below the field's box at all: one
+ * line of framing/prompt copy above it, then the box, full stop (the card
+ * is clamped to ~276px by the deck it lives in). See `fieldWrapStyles` /
+ * `embeddedIconButtonStyles` below for the mechanics, and `srOnlyStyles`
+ * for how a field still gets a REAL accessible label without spending any
+ * of that vertical budget.
+ *
+ * SECOND CORRECTION (owner, same day): "why is it reinventing the wheel"
+ * — the live-chat face mounts the REAL `<adaptive-chat-trail>` transcript
+ * renderer (`./AdaptiveChatTrail.ts`) instead of hand-rolled bubble
+ * markup. It is explicitly NOT bound to the concierge's shared
+ * `chatSession` singleton (`./ChatSession.ts`) — this file never imports
+ * that module, directly or transitively (the trail's own import graph is
+ * `@syntrologie/chat` + `lit` only). Each card owns its own
+ * `_transcript` instance field and feeds it to its own
+ * `<adaptive-chat-trail>` element; see `LeaveAMessageLit.test.ts`'s
+ * singleton-isolation suite for the mutation-proven guarantee.
+ */
+import { LitElement, nothing } from 'lit';
+import './AdaptiveChatTrail.js';
+import type { SupportChatBridge } from './support-chat/types';
+/** One line of the visitor↔operator conversation, persisted so a page
+ *  remount can rebuild the exact transcript in order. */
+export interface TranscriptEntry {
+    role: 'visitor' | 'operator';
+    text: string;
+}
+/** Namespace + key the widget persists {state, transcript, email} under
+ *  via `runtime.state.ns()` (I2, final-review fixes 2026-08-13) —
+ *  see `LeaveAMessageLit#_loadPersisted` / `#_persist`. The page-level
+ *  inbox (support-chat/inbox.ts) writes the same record when a team
+ *  message arrives with no card mounted, so the next card picks it up. */
+export declare const LEAVE_A_MESSAGE_PERSIST_NAMESPACE = "supportchat";
+export declare const LEAVE_A_MESSAGE_PERSIST_KEY = "leave-a-message";
+export type LeaveAMessageState = 'form' | 'email' | 'sent' | 'mail' | 'flipped';
+export declare function liveLeaveAMessageCards(): ReadonlySet<LeaveAMessageLit>;
+/**
+ * Every visitor-facing string on this card — authored entirely by the
+ * workspace (`default_widget_props.copy`), same pattern as `replyToast`.
+ * The bundle ships NO English fallback for any of these: absent copy means
+ * that piece of UI does not render. For the icon-only send/submit
+ * controls this isn't just a style choice — an icon button with no
+ * accessible name is a real usability defect, so `sendLabel` /
+ * `emailSubmitLabel` / `replySendLabel` double as BOTH the control's
+ * aria-label AND the gate on whether the control renders at all.
+ */
+export interface LeaveAMessageCopy {
+    /** Framing line above the message box (form step) — explains the
+     *  message was drafted from the conversation and remains editable. */
+    framing?: string;
+    /** Accessible (visually-hidden) label for the message textarea. */
+    messageLabel?: string;
+    /** Accessible name for the compose step's embedded send control.
+     *  Absence removes the control (see interface doc above). */
+    sendLabel?: string;
+    /** Prompt shown on the email step — frames the address as optional, a
+     *  fallback for a reply if the visitor leaves the page. */
+    emailPrompt?: string;
+    /** Accessible (visually-hidden) label for the email input. */
+    emailLabel?: string;
+    /** Placeholder for the email input — distinct copy from the label, never
+     *  doubling as it. */
+    emailPlaceholder?: string;
+    /** Accessible name for the email step's embedded submit control.
+     *  Absence removes the control. */
+    emailSubmitLabel?: string;
+    /** Quiet inline decline text, beside the email field. Absence removes
+     *  the control — the visitor can still get the same effect by
+     *  submitting a blank field. */
+    emailSkipLabel?: string;
+    /** Confirmation paragraph shown in the 'sent' state. */
+    sentBody?: string;
+    /** Button text for the 'mail' state ("You got mail!" tap target). */
+    mailLabel?: string;
+    /** Accessible (visually-hidden) label for the reply input. */
+    replyLabel?: string;
+    /** Placeholder for the reply input (flipped state). */
+    replyPlaceholder?: string;
+    /** Accessible name for the flipped state's embedded send control.
+     *  Absence removes the control. */
+    replySendLabel?: string;
+}
+/**
+ * Minimal runtime slice the widget needs to raise the "You got mail!"
+ * toast — mirrors adaptive-nav's `NavWidgetRuntime.events` shape (see
+ * `NavWidgetLit#publishEvent`) so tile `notifications` rules (which
+ * subscribe to the runtime EventBus, not DOM CustomEvents) can match
+ * on `supportchat:reply_received`.
+ */
+export interface LeaveAMessageRuntime {
+    events: {
+        publish: (name: string, props?: Record<string, unknown>) => void;
+    };
+    /**
+     * Optional persistence seam (I2, final-review fixes 2026-08-13) — mirrors
+     * adaptive-overlays' `WorkflowWidgetLit.runtimeRef?.state?.ns?.(...)`
+     * pattern exactly. On an MPA the tile unmounts and remounts fresh per
+     * page; without this, a visitor who already sent a message and is
+     * waiting on a reply loses that thread on their very next click (state
+     * resets to 'form', the operator's reply becomes invisible). Optional
+     * because older host bundles / the playground don't inject it — the
+     * widget still works, it just can't survive navigation.
+     */
+    state?: {
+        ns?: (namespace: string) => {
+            get: (key: string) => unknown;
+            set: (key: string, value: unknown) => void;
+        };
+    };
+}
+/** Shape persisted under `runtime.state.ns('supportchat')`. */
+export interface PersistedLeaveAMessage {
+    state?: LeaveAMessageState;
+    transcript?: TranscriptEntry[];
+    email?: string;
+}
+export declare class LeaveAMessageLit extends LitElement {
+    static properties: {
+        bridge: {
+            attribute: boolean;
+        };
+        message: {
+            type: StringConstructor;
+        };
+        contextSummary: {
+            attribute: boolean;
+        };
+        state: {
+            type: StringConstructor;
+        };
+        runtime: {
+            attribute: boolean;
+        };
+        replyToast: {
+            attribute: boolean;
+        };
+        copy: {
+            attribute: boolean;
+        };
+    };
+    bridge: SupportChatBridge | undefined;
+    message: string;
+    contextSummary: string;
+    state: LeaveAMessageState;
+    /** Runtime plumbing injected by the mountable — undefined outside a live SDK mount. */
+    runtime: LeaveAMessageRuntime | undefined;
+    /**
+     * Visitor-facing toast copy, authored by the WORKSPACE CONFIG
+     * (`default_widget_props.replyToast`) — presentation belongs to
+     * configuration, not to this bundle: every workspace has its own voice
+     * and language. The built-in fallback below exists only so an
+     * unconfigured mount still says something truthful.
+     */
+    replyToast: {
+        title?: string;
+        body?: string;
+    } | undefined;
+    /** Every OTHER visitor-facing string on this card — see
+     *  `LeaveAMessageCopy` doc. */
+    copy: LeaveAMessageCopy | undefined;
+    /** Unique per-instance id prefix so `<label for>` never collides across
+     *  more than one card mounted on the same page. */
+    private readonly _uid;
+    private _email;
+    private _reply;
+    /**
+     * Has the VISITOR typed something not yet consumed? Set only by the fields'
+     * own `@input` handlers, cleared on every state transition (the input has
+     * either been sent or explicitly declined). Drives the Escape guard
+     * (BUG-1787284155).
+     *
+     * Deliberately a flag and NOT "current value vs. a baseline captured at
+     * mount". The card mounts PREFILLED, and `LeaveAMessageMountable.update()`
+     * patches `message` in place mid-conversation whenever the agent rewrites
+     * the prefill — which is the case that method exists for. A captured
+     * baseline goes stale on exactly that patch, and every later Escape gets
+     * swallowed on a card the visitor never touched (adversarial review F1).
+     * An `@input` event is the only thing that means a person typed.
+     */
+    private _touched;
+    /** Visitor↔operator conversation, in order — rendered as a chat
+     *  transcript once the visitor taps into the mail state (see render()'s
+     *  'flipped' branch). Seeded with the visitor's own compose-step message
+     *  in `_submitMessage`. */
+    private _transcript;
+    private _unsubscribe;
+    private _readyUnsub;
+    createRenderRoot(): HTMLElement;
+    connectedCallback(): void;
+    updated(): void;
+    disconnectedCallback(): void;
+    /** Is this card's own vendor subscription delivering replies? While it
+     *  is, the page-level inbox leaves every message to the card. */
+    get isListening(): boolean;
+    /** Hand the card a team message that arrived through the page-level
+     *  inbox (support-chat/inbox.ts) while the card was mounted but not yet
+     *  listening — a compose-step card the concierge put up moments before
+     *  the team's own message landed. */
+    receiveOperatorMessage(text: string): void;
+    /** Open the thread face — what tapping the mail face or an announcement
+     *  does. Used by the page-level inbox when its announcement is tapped
+     *  after a card has already mounted and hydrated the thread. */
+    showThread(): void;
+    /** Read the injected persistence store, if any (I2). */
+    private _persistStore;
+    /** Hydrate {state, transcript, email} from a prior page's mount. */
+    private _loadPersisted;
+    /** Snapshot {state, transcript, email} so the NEXT mount (a fresh page
+     *  in the same session) can pick the thread back up. */
+    private _persist;
+    /** The pending reply announcement, if the canvas gave us a handle to it. */
+    private _noticeHandle;
+    /**
+     * Is the visitor LOOKING at this card right now? True only when the card
+     * has a laid-out box inside the viewport, the document is visible, and a
+     * hit-test at the card's center lands on the card itself — so a deck card
+     * stacked behind another, a card under a maximized chat, or a closed
+     * canvas all read as "not on screen". The hit-test descends through open
+     * shadow roots (`document.elementFromPoint` stops at the outermost host).
+     * Canvas-agnostic on purpose: the card never asks a canvas which tile is
+     * front. Anything this can't evaluate (jsdom, no layout) is "not on
+     * screen": when unsure, announce — a missed reply costs more than an
+     * extra toast.
+     */
+    private _isOnScreen;
+    /** The tile id sc-mount stamps on every widget's container, so the card can
+     *  name itself to the canvas when the visitor taps its announcement. */
+    private _instanceId;
+    /**
+     * Tap on the reply announcement: open the thread and ask the canvas to
+     * bring this tile to the front. `tile-recall` is the same composed event
+     * AdaptiveChatBar already raises for its own recalls — velvet cycles the
+     * deck to the card and un-maximizes the chat; the host opens the canvas
+     * if it was closed.
+     */
+    private _recall;
+    /**
+     * Announce a reply through the canvas element. Pierces shadow roots to
+     * find `<smart-canvas>` (same resolution AdaptiveChatBarMountable uses), and
+     * no-ops when no canvas is present — the tile's own "You got mail!" face is
+     * always the durable signal. The announcement is PERSISTENT: a human's
+     * reply is the one thing the visitor was waiting on, so it stays until
+     * tapped or until the visitor opens the thread themselves (`_flip`).
+     */
+    private _announceReply;
+    /** Paint our own focus ring from the theme. The border now lives on the
+     *  field SHELL (`data-lam-field-wrap`), not the borderless inner
+     *  textarea/input, so the ring targets that ancestor via `closest()`. */
+    private _focusOn;
+    private _focusOff;
+    private _onReply;
+    /** Compose step → email step. Delivers the message immediately; email
+     *  capture is a SEPARATE, later, optional step (owner redesign). Seeds
+     *  the chat transcript with the visitor's OWN plain message text (not
+     *  the context-prefixed string sent to the bridge — that prefix is
+     *  internal plumbing for the human agent, not something the visitor
+     *  should see echoed back at themselves). */
+    private _submitMessage;
+    /** Email step → sent. Blank email is a valid submission (the field is
+     *  optional) and simply skips `setVisitorEmail`; an invalid non-blank
+     *  email blocks advancing so a mistyped address doesn't silently vanish. */
+    private _submitEmail;
+    /** Explicit decline — advances regardless of whatever is typed, without
+     *  ever calling `setVisitorEmail`. Distinct from submitting a blank
+     *  field only in that it discards partial input the visitor may not
+     *  have meant to send. */
+    private _skipEmail;
+    private _flip;
+    /** Maps this card's OWN `_transcript` (never the concierge's) to the
+     *  shape `<adaptive-chat-trail>` renders. `visitor` → `'user'` (right-
+     *  aligned, branded) and `operator` → `'assistant'` (left-aligned,
+     *  neutral) purely for the trail's existing visual treatment — no
+     *  claim that a human Crisp operator IS the AI assistant. Freshly
+     *  computed on every render from local state; nothing here reads from
+     *  or writes to `chatSession`. */
+    private _trailMessages;
+    private _sendReply;
+    /** Does the visitor have text here that closing the card would destroy? */
+    private _hasUnsavedInput;
+    /**
+     * Escape must not silently discard a draft (BUG-1787284155).
+     *
+     * The runtime's canvas Escape handler (`CanvasDialogA11y`,
+     * `packages/runtime-sdk/src/a11y/canvasDialog.ts`) closes the surface from a
+     * document-level listener — but stands down on `e.defaultPrevented`,
+     * explicitly so an inner component that owns unsaved state can claim the
+     * key. That seam is what this uses; the widget owns the decision, not the
+     * runtime, because only the widget knows whether anything is at stake.
+     *
+     * A CLEAN card lets Escape through and the canvas closes — normal dialog
+     * behaviour, and the reflex the visitor expects. A DIRTY one swallows the
+     * first Escape and blurs the field: visible feedback that the key did
+     * something, the text still on screen, and a second Escape (focus now
+     * outside the field) closes as usual. Defended once, not held hostage.
+     * WCAG 3.3.4 in spirit — losing typed input to a reflex keystroke, with no
+     * prompt and no undo, is the failure this prevents.
+     *
+     * Scope is the card's own subtree (see the host binding in
+     * `connectedCallback`). A visitor whose focus has moved on to the host page
+     * gets the normal dismiss — the widget claims only keys that reach it.
+     */
+    private _onKeyDown;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+}
+/** Idempotent registration — called by the mountable on first mount. */
+export declare function registerLeaveAMessageLit(): void;
+//# sourceMappingURL=LeaveAMessageLit.d.ts.map

package/dist/LeaveAMessageLit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LeaveAMessageLit.d.ts","sourceRoot":"","sources":["../src/LeaveAMessageLit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,OAAO,EAAQ,UAAU,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAGhD,OAAO,wBAAwB,CAAC;AAIhC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAmQ9D;yDACyD;AACzD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,SAAS,GAAG,UAAU,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;0EAI0E;AAC1E,eAAO,MAAM,iCAAiC,gBAAgB,CAAC;AAC/D,eAAO,MAAM,2BAA2B,oBAAoB,CAAC;AAI7D,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AAIhF,wBAAgB,sBAAsB,IAAI,WAAW,CAAC,gBAAgB,CAAC,CAEtE;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,iBAAiB;IAChC;0EACsE;IACtE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;iEAC6D;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;+DAC2D;IAC3D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8DAA8D;IAC9D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;0BACsB;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;uCACmC;IACnC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;oCAEgC;IAChC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8DAA8D;IAC9D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uDAAuD;IACvD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;uCACmC;IACnC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE;QACN,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;KAClE,CAAC;IACF;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE;QACN,EAAE,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK;YAC1B,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;YAC9B,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;SAC5C,CAAC;KACH,CAAC;CACH;AAED,+DAA+D;AAC/D,MAAM,WAAW,sBAAsB;IACrC,KAAK,CAAC,EAAE,kBAAkB,CAAC;IAC3B,UAAU,CAAC,EAAE,eAAe,EAAE,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAID,qBAAa,gBAAiB,SAAQ,UAAU;IAC9C,OAAgB,UAAU;;;;;;;;;;;;;;;;;;;;;;MAQxB;IAEF,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACtC,OAAO,SAAM;IACb,cAAc,SAAM;IACpB,KAAK,EAAE,kBAAkB,CAAU;IACnC,uFAAuF;IACvF,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAE1C;;;;;;OAMG;IACH,UAAU,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;IAE1D;mCAC+B;IAC/B,IAAI,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAEpC;uDACmD;IACnD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA4B;IAEjD,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,MAAM,CAAM;IACpB;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,QAAQ,CAAS;IACzB;;;+BAG2B;IAC3B,OAAO,CAAC,WAAW,CAAyB;IAC5C,OAAO,CAAC,YAAY,CAA2B;IAC/C,OAAO,CAAC,WAAW,CAA2B;IAErC,gBAAgB,IAAI,WAAW;IAI/B,iBAAiB,IAAI,IAAI;IA2BzB,OAAO,IAAI,IAAI;IAcf,oBAAoB,IAAI,IAAI;IAcrC;qEACiE;IACjE,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED;;;yCAGqC;IACrC,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI1C;;oEAEgE;IAChE,UAAU,IAAI,IAAI;IAIlB,wDAAwD;IACxD,OAAO,CAAC,aAAa;IAIrB,oEAAoE;IACpE,OAAO,CAAC,cAAc;IAUtB;4DACwD;IACxD,OAAO,CAAC,QAAQ;IAahB,4EAA4E;IAC5E,OAAO,CAAC,aAAa,CAAsC;IAE3D;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,WAAW;IAwBnB;4EACwE;IACxE,OAAO,CAAC,WAAW;IAInB;;;;;;OAMG;IACH,OAAO,CAAC,OAAO,CAOb;IAEF;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IA2BtB;;6EAEyE;IACzE,OAAO,CAAC,QAAQ,CAKd;IAEF,OAAO,CAAC,SAAS,CAIf;IAEF,OAAO,CAAC,QAAQ,CAmCd;IAEF;;;;;iDAK6C;IAC7C,OAAO,CAAC,cAAc,CAQpB;IAEF;;gFAE4E;IAC5E,OAAO,CAAC,YAAY,CAQlB;IAEF;;;8BAG0B;IAC1B,OAAO,CAAC,UAAU,CAIhB;IAEF,OAAO,CAAC,KAAK,CAQX;IAEF;;;;;;sCAMkC;IAClC,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,UAAU,CAWhB;IAEF,2EAA2E;IAC3E,OAAO,CAAC,gBAAgB;IAIxB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,CAAC,UAAU,CAKhB;IAEO,MAAM;CAkNhB;AAED,wEAAwE;AACxE,wBAAgB,wBAAwB,IAAI,IAAI,CAI/C"}

package/dist/LeaveAMessageLit.test.d.ts

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

package/dist/LeaveAMessageLit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LeaveAMessageLit.test.d.ts","sourceRoot":"","sources":["../src/LeaveAMessageLit.test.ts"],"names":[],"mappings":"AAKA,OAAO,oBAAoB,CAAC"}

package/dist/LeaveAMessageMountable.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=LeaveAMessageMountable.test.d.ts.map

package/dist/LeaveAMessageMountable.test.d.ts.map

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

package/dist/NavLinkMountable.d.ts

@@ -0,0 +1,25 @@
+/**
+ * NavLinkMountable — `MountableWidget` used as the payload of an
+ * LLM-authored navigation chip.
+ *
+ * Flow:
+ *   LLM mounts `suggest-navigation` ItemTemplate with `{title, url}`
+ *   → backend builds chip with payload `{widget: 'adaptive-chatbot:nav-link', props: {url}}`
+ *   → user clicks the chip → chips-strip mounts THIS widget into the
+ *     chip's drawer
+ *   → user clicks the "Go to <url>" button this widget renders
+ *   → same-origin SPA navigation via pushState + popstate (matches
+ *     `adaptive-nav`'s `executeNavigate` path for SPA-router compatibility)
+ *
+ * Registered as widget id `adaptive-chatbot:nav-link`.
+ *
+ * Security note: only http(s), same-origin destinations are honored.
+ * `javascript:`, `data:`, and cross-origin URLs are silently dropped at
+ * URL construction. The ItemTemplate's EnumField allowlist is the
+ * primary constraint; this is defense-in-depth.
+ */
+export declare const NavLinkMountable: {
+    mount(container: HTMLElement, mountConfig?: Record<string, unknown>): () => void;
+    update(container: HTMLElement, mountConfig?: Record<string, unknown>): void;
+};
+//# sourceMappingURL=NavLinkMountable.d.ts.map

package/dist/NavLinkMountable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavLinkMountable.d.ts","sourceRoot":"","sources":["../src/NavLinkMountable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAoFH,eAAO,MAAM,gBAAgB;qBACV,WAAW,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,IAAI;sBAkB9D,WAAW,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;CAO5E,CAAC"}

package/dist/NavLinkMountable.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=NavLinkMountable.test.d.ts.map

package/dist/NavLinkMountable.test.d.ts.map

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

package/dist/TextAnswerMountable.d.ts

@@ -0,0 +1,17 @@
+/**
+ * TextAnswerMountable — `MountableWidget` for the simplest chip payload
+ * kind: a single paragraph of body text.
+ *
+ * Registered as widget id `adaptive-chatbot:text-answer`. Used by
+ * `AdaptiveChipsStrip` when a chip's payload references it.
+ *
+ * Replaces the old hand-rolled resolver path. Customers wanting richer
+ * payloads (markdown, mini-product cards, embedded charts, etc.) ship
+ * their own mountable through the same registry — no special
+ * resolver-map seam.
+ */
+export declare const TextAnswerMountable: {
+    mount(container: HTMLElement, mountConfig?: Record<string, unknown>): () => void;
+    update(container: HTMLElement, mountConfig?: Record<string, unknown>): void;
+};
+//# sourceMappingURL=TextAnswerMountable.d.ts.map

package/dist/TextAnswerMountable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextAnswerMountable.d.ts","sourceRoot":"","sources":["../src/TextAnswerMountable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAwBH,eAAO,MAAM,mBAAmB;qBACb,WAAW,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,IAAI;sBAqB9D,WAAW,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;CAO5E,CAAC"}

package/dist/TextAnswerMountable.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=TextAnswerMountable.test.d.ts.map

package/dist/TextAnswerMountable.test.d.ts.map

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

package/dist/Turnstile.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Turnstile — shared Cloudflare bot-check helpers.
+ *
+ * Originally lived inline in ChatAssistantLit. Extracted so the new
+ * ChatTransport adapter can use the same managed-challenge flow
+ * without duplicating the panel-portal logic.
+ *
+ * Verify-panel is mounted to `document.body` (NOT into the calling
+ * widget's shadow-rooted container). Cloudflare Turnstile crashes
+ * with `Cannot read properties of undefined (reading 'toLowerCase')`
+ * when its host element lives inside a shadow root (verified on
+ * healthmaxxer 2026-05-22 — chat tile inside `<smart-canvas>`'s open
+ * shadow root). So we portal the host out and position it as a fixed
+ * overlay at the bottom-center of the viewport.
+ *
+ * The panel is ALWAYS mounted (CF needs a DOM target in case it
+ * decides to challenge) but is off-screen by default. For clean
+ * traffic, CF passive-grades silently with
+ * `appearance: 'interaction-only'` — nothing is ever visible. For
+ * flagged sessions, CF's `before-interactive-callback` fires and the
+ * orchestration helper reveals the panel.
+ *
+ * Copy is intentionally generic — customer end-users see this when CF
+ * flags their session, regardless of customer.
+ */
+export declare const TURNSTILE_SITEKEY = "0x4AAAAAADSzPbGWxeguF4YJ";
+export interface AcquireTurnstileOptions {
+    /** Widget size. `flexible` (default for managed-mode sitekeys). */
+    size?: 'flexible' | 'normal' | 'compact' | 'invisible';
+    /** `interaction-only` keeps the widget invisible during passive grading. */
+    appearance?: 'always' | 'execute' | 'interaction-only';
+    /** Where to mount the widget. Off-screen host created when omitted. */
+    host?: HTMLElement;
+    /** Fires when CF decides a challenge is needed — surface "verifying" copy. */
+    onBeforeInteractive?: () => void;
+    /** Cancels an in-flight acquisition. Required for clean unmount-during-challenge. */
+    signal?: AbortSignal;
+}
+/**
+ * Acquire a Cloudflare Turnstile token. Returns null when:
+ *   • TURNSTILE_SITEKEY is empty (Turnstile disabled at build time)
+ *   • the script fails to load (customer CSP blocks Cloudflare, etc.)
+ *   • the render callback doesn't fire within TURNSTILE_ACQUIRE_TIMEOUT_MS
+ *   • Cloudflare returns an error-callback (e.g., rate-limited, bad sitekey)
+ *
+ * Calls `turnstile.remove(widgetId)` on settle so CF's internal widget
+ * registry doesn't leak across re-mounts.
+ *
+ * Exported for tests and for the higher-level acquireTokenWithChallenge
+ * helper below.
+ */
+export declare function acquireTurnstileToken(opts?: AcquireTurnstileOptions): Promise<string | null>;
+/**
+ * Mount the off-screen verify-panel that hosts the managed Turnstile
+ * widget. Returns the panel element; callers MUST call panel.remove()
+ * when done (the panel is mounted on document.body and won't be
+ * garbage-collected with their widget).
+ */
+export declare function renderVerifyPanel(): HTMLElement;
+/**
+ * Move the verify panel on-screen when CF signals via
+ * `before-interactive-callback` that the checkbox is about to appear.
+ * No-op if the panel was already torn down (race with token resolution).
+ */
+export declare function revealVerifyPanel(panel: HTMLElement | null): void;
+export interface AcquireWithChallengeResult {
+    token: string | null;
+    outcome: 'disabled' | 'silent_succeeded' | 'interactive_succeeded' | 'acquisition_failed';
+}
+/**
+ * Orchestrated acquire: mount the verify panel, ask CF for a token,
+ * reveal the panel if CF decides to challenge interactively, then
+ * clean up regardless of outcome.
+ *
+ * `outcome` is set so callers can distinguish silent-pass from
+ * interactive-pass from failure — useful telemetry for "how many
+ * sessions actually saw the checkbox?". `disabled` means
+ * TURNSTILE_SITEKEY was empty at build time.
+ */
+export declare function acquireTokenWithChallenge(options?: {
+    signal?: AbortSignal;
+}): Promise<AcquireWithChallengeResult>;
+export type BotCheckMode = 'off' | 'soft' | 'hard';
+/** Test seam: forget cached modes (the cache is per page load). */
+export declare function resetBotCheckModeCache(): void;
+/**
+ * The backend's bot-check mode, read once per backend per page load.
+ * `null` means it could not be read.
+ */
+export declare function fetchBotCheckMode(backendUrl: string): Promise<BotCheckMode | null>;
+/**
+ * Acquire a bot-check token for a visitor SEND. Call this from the send path
+ * only — never from mount, configure, or a passive stream.
+ *
+ * Resolves `{ token: null, outcome: 'disabled' }` without touching Cloudflare
+ * when the build has no sitekey or the backend reports `off`.
+ */
+export declare function acquireBotCheckTokenForSend(backendUrl: string, options?: {
+    signal?: AbortSignal;
+}): Promise<AcquireWithChallengeResult>;
+//# sourceMappingURL=Turnstile.d.ts.map

package/dist/Turnstile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Turnstile.d.ts","sourceRoot":"","sources":["../src/Turnstile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAwBH,eAAO,MAAM,iBAAiB,6BAA6B,CAAC;AAmE5D,MAAM,WAAW,uBAAuB;IACtC,mEAAmE;IACnE,IAAI,CAAC,EAAE,UAAU,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,CAAC;IACvD,4EAA4E;IAC5E,UAAU,CAAC,EAAE,QAAQ,GAAG,SAAS,GAAG,kBAAkB,CAAC;IACvD,uEAAuE;IACvE,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,8EAA8E;IAC9E,mBAAmB,CAAC,EAAE,MAAM,IAAI,CAAC;IACjC,qFAAqF;IACrF,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,GAAE,uBAA4B,GACjC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAyFxB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,IAAI,WAAW,CAkC/C;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,GAAG,IAAI,CAMjE;AAED,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,OAAO,EAAE,UAAU,GAAG,kBAAkB,GAAG,uBAAuB,GAAG,oBAAoB,CAAC;CAC3F;AAED;;;;;;;;;GASG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAO,GACrC,OAAO,CAAC,0BAA0B,CAAC,CAgDrC;AAoBD,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAKnD,mEAAmE;AACnE,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C;AAmBD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAYlF;AAED;;;;;;GAMG;AACH,wBAAsB,2BAA2B,CAC/C,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAO,GACrC,OAAO,CAAC,0BAA0B,CAAC,CAKrC"}

package/dist/cdn.d.ts

@@ -4,11 +4,7 @@
  * This module is bundled for CDN delivery and self-registers with the global
  * SynOS app registry when loaded dynamically via the AppLoader.
  */
-import ChatbotEditor from './editor';
-/**
- * App manifest for registry registration.
- * Follows the AppManifest interface expected by AppLoader/AppRegistry.
- */
+import { ChatbotEditorLit } from './editor-lit';
 export declare const manifest: {
     id: string;
     version: string;
@@ -16,7 +12,7 @@ export declare const manifest: {
     description: string;
     runtime: {
         actions: never[];
-        widgets: {
+        widgets: ({
             id: string;
             component: {
                 mount(container: HTMLElement, mountConfig?: Record<string, unknown>): () => void;
@@ -26,10 +22,22 @@ export declare const manifest: {
                 description: string;
                 icon: string;
             };
-        }[];
+        } | {
+            id: string;
+            component: {
+                mount(container: HTMLElement, config?: (Record<string, unknown> & import("packages/sdk-contracts/dist").MountPlumbing) | null): () => void;
+                update(container: HTMLElement, config?: (Record<string, unknown> & import("packages/sdk-contracts/dist").MountPlumbing) | null): void;
+            };
+            metadata: {
+                name: string;
+                description: string;
+                icon: string;
+            };
+        })[];
+        onActivate: typeof import("./hostAgentController").activateHostAgent;
     };
     editor: {
-        component: typeof ChatbotEditor;
+        component: typeof ChatbotEditorLit;
         panel: {
             title: string;
             icon: string;

package/dist/cdn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cdn.d.ts","sourceRoot":"","sources":["../src/cdn.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,aAA8B,MAAM,UAAU,CAAC;AAGtD;;;GAGG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAapB,CAAC;AAaF,eAAe,QAAQ,CAAC"}
+{"version":3,"file":"cdn.d.ts","sourceRoot":"","sources":["../src/cdn.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGhD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqBpB,CAAC;AAaF,eAAe,QAAQ,CAAC"}