@syntrologie/adapt-chatbot 2.8.0-canary.43 → 2.8.0-canary.430

package/dist/ChatTransport.d.ts

@@ -0,0 +1,360 @@
+/**
+ * ChatTransport — singleton transport adapter that bridges chatSession
+ * (the view-side state holder) to the real backend chat pipeline
+ * (AG-UI SSE at `/api/adaptive/stream`).
+ *
+ * This is the unification of two formerly separate paths:
+ *   - `ChatAssistantLit` (old) owns the transport plumbing —
+ *     AgUiTransport, Cloudflare Turnstile, headers, A2UI passthrough,
+ *     telemetry, fallback card.
+ *   - `AdaptiveChatBar` + `chatSession` (new) owns the canvas-lid UX —
+ *     glassmorphism bar, bubble-up trail, per-page persistence.
+ *
+ * This module ports every transport-side concern from ChatAssistantLit
+ * into a session-shaped adapter so the new bar gets full backend
+ * parity. The bar stays a pure view; the transport stays a pure pipe.
+ *
+ * Lifecycle:
+ *   - `configure({ backendUrl, runtime, ... })` — called once by the
+ *     SDK runtime at bootstrap from chat config. Idempotent; second
+ *     call with the same backendUrl is a no-op.
+ *   - Connection is LAZY. The transport doesn't acquire Turnstile or
+ *     open the SSE until the first chatSession.send() — saves cost
+ *     on pages where the user never opens chat.
+ *   - On chatSession.send → transport ensures connected (acquires
+ *     Turnstile token, builds AgUiTransport) then forwards
+ *     `{type:'user-message', text}` to the agent.
+ *   - On chatSession.onInterrupt → transport sends stop-generation.
+ *   - AgUi events stream into chatSession via receiveStart / Delta /
+ *     End / error.
+ *   - A2UI custom events forward to runtime.actions.applyBatch so the
+ *     agent can drive canvas updates.
+ *
+ * Telemetry parity with ChatAssistantLit:
+ *   - chatbot.transport_error (every error, with status/body/name)
+ *   - chatbot.a2ui_applied
+ *   - chatbot.fallback_rendered — emitted when the transport gives up
+ *     (Turnstile failed AND backend rejected) so existing PostHog
+ *     queries keep working.
+ *
+ * Threading model: single-flight per page. Multiple concurrent sends
+ * are queued by AgUiTransport itself. Multiple bar mounts share this
+ * one transport via chatSession.
+ */
+import type { ElementMutation } from './elements';
+import type { ChatbotWidgetRuntime } from './types';
+/**
+ * Per-customer "chat unavailable" card config. Surfaced via onFallback
+ * when the transport gives up after repeated failures. Mirrors
+ * ChatbotFallback in types.ts so consumers can pass the same config.
+ */
+export interface ChatbotFallbackConfig {
+    title?: string;
+    message?: string;
+    ctaLabel?: string;
+    ctaHref?: string;
+}
+export interface ChatTransportConfig {
+    /** Backend host, e.g. "https://demo-api.syntrologie.com" or "" for same-origin. */
+    backendUrl: string;
+    /** Runtime hooks for A2UI apply + telemetry. */
+    runtime: ChatbotWidgetRuntime;
+    /** Optional thread id for conversation continuity across reloads. */
+    threadId?: string;
+    /**
+     * Optional set of client-tool names the transport should treat as
+     * "needs user approval" (surfaced via chatSession.toolCalls instead
+     * of auto-executed server-side). Empty by default — all tool calls
+     * are server-driven and the transport just emits the "tool call
+     * happened" event.
+     */
+    clientTools?: Set<string>;
+    /**
+     * Per-customer "chat unavailable" card. Rendered by the host
+     * (typically AdaptiveChatBarMountable) after repeated connect
+     * failures wipe the chat surface — exactly the same UX
+     * ChatAssistantLit's fallback path provides.
+     */
+    fallback?: ChatbotFallbackConfig;
+    /**
+     * Arbitrary JSON object attached to every AG-UI request as
+     * `forwardedProps`. Used by the adaptive chat surface to ship the
+     * LLM-authored UI element config (`uiTemplates`, `elementsEnabled`)
+     * per request — the backend reads these to enable the
+     * `mount_element` / `patch_element` / `unmount_element` tools.
+     * Callable form is re-evaluated on every turn so a config edit can
+     * land mid-conversation.
+     */
+    forwardedProps?: Record<string, unknown> | (() => Record<string, unknown> | undefined);
+    /**
+     * Optional callback for `syntro.element.mutation` AG-UI custom events.
+     * The transport decodes the envelope on receipt; if it matches the
+     * element-mutation schema, mutations are routed here instead of the
+     * generic `runtime.actions.applyBatch` legacy path. Consumers are
+     * expected to forward to `ElementInstanceStore.apply(mutations)` —
+     * we don't take a store reference directly so the transport stays
+     * agnostic of which surface owns the store (the chat-bar widget
+     * may own one; ChatAssistantLit owns its own; both share this
+     * singleton transport).
+     *
+     * When unset, element-mutation envelopes fall back to applyBatch,
+     * matching legacy behaviour (which would no-op since applyBatch
+     * doesn't know about MutationEnvelope).
+     */
+    onElementMutation?: (mutations: ElementMutation[]) => void;
+    /**
+     * Slot the chat-bar widget is mounted into (e.g. ``"drawer"``,
+     * ``"adaptive-chat"``). Forwarded as ``X-Active-Lid-Slot`` on every
+     * ``/api/adaptive/stream`` request so the backend can route mounts to
+     * the canvas next to whichever lid the visitor sent from. Optional —
+     * omitting it falls back to the template's static ``default_slot``
+     * server-side, which is the pre-change behaviour.
+     */
+    activeLidSlot?: string;
+}
+/**
+ * Debounce window for connect errors. Single transient errors
+ * (cold-start 502, brief CORS preflight failure) should NOT swap the
+ * chat to the fallback card; only sustained failure should. Matches
+ * ChatAssistantLit's ERROR_DEBOUNCE_MS.
+ */
+export declare const FALLBACK_DEBOUNCE_MS = 1500;
+export interface FallbackPayload {
+    reason: 'connect_failed' | 'connect_timeout';
+    fallback: ChatbotFallbackConfig;
+    transportId: string;
+    transportAgeMs: number;
+    messagesSucceeded: number;
+    hadTurnstileToken: boolean | null;
+    errorStatus: number | null;
+    errorBody: string | null;
+    errorMessage: string | null;
+    errorName: string | null;
+}
+export type FallbackListener = (payload: FallbackPayload) => void;
+/**
+ * Visitor-facing progress copy for a tool call, shown in the thinking chip.
+ * Returns an ORDERED set of phrasings for the tool's category: the first shows
+ * immediately, and `ChatTransport` rotates through the rest every few seconds
+ * while the same phase runs (see `_startThinkingCycle`) so a long — or looping
+ * — tool phase reads as live progress instead of one frozen string. Keyed on
+ * substrings of the (technical) tool name so it survives renames; never shows
+ * the raw name.
+ *
+ * Distinct buckets matter: `retrieve_wiki` (search), `get_wiki_route`
+ * (navigate) and `read_section` (read) all used to collapse to one identical
+ * "Finding the right page…", which made a multi-call research loop look like a
+ * single calm step. Check search/retrieve BEFORE the generic `wiki` fallback so
+ * `retrieve_wiki` lands on "Searching…", not "Looking that up…".
+ */
+export declare function toolNarrationVariants(name: string): string[];
+export declare class ChatTransport {
+    private _config;
+    private _status;
+    private _agui;
+    private _transportUnsub;
+    private _sessionUnsubSend;
+    private _sessionUnsubInterrupt;
+    private _sessionUnsubToolResult;
+    private _connectInFlight;
+    /** Bounded streaming-message id for the currently-being-typed assistant turn. */
+    private _currentAssistantMessageId;
+    /** Outcome bookkeeping for telemetry. */
+    private _hadTurnstileToken;
+    /** Count of successful round-trips for telemetry payloads. */
+    private _messagesSucceeded;
+    /** True once a successful assistant message has landed — gates fallback. */
+    private _hasSucceeded;
+    /** True once fallback has fired (one-shot). */
+    private _fallbackRendered;
+    /**
+     * Per-send override for ``X-Active-Lid-Slot``. Set in the
+     * ``chatSession.onSend`` listener immediately before each
+     * ``_forwardUserMessage`` and consumed by ``buildHeaders`` on the
+     * outbound request. The singleton transport is shared by every
+     * mounted chat-bar (drawer + inline) so cached ``_config.activeLidSlot``
+     * follows whichever bar last reconfigured — using that for routing
+     * silently misroutes tiles when both bars coexist. Per-send threading
+     * pins the header to the bar that actually sent the message.
+     */
+    private _pendingLidSlot;
+    /** Active debounce timer; null when no debounce pending. */
+    private _errorDebounceTimer;
+    /** Rotates thinking-chip phrasings during a long/looping tool phase (C9). */
+    private _thinkingCycleTimer;
+    /**
+     * Per-class rotation counter, keyed by the narration set's first variant.
+     * A NEW tool class shows its primary (variant A) so it's recognizable; a
+     * REPEATED same-class call advances to the next variant, so a research loop
+     * of (e.g.) several searches reads as different thinking, not one repeated
+     * label. Bounded to ~6 keys (one per tool class).
+     */
+    private _thinkingClassSeq;
+    /** Most recent error payload, captured so debounced fallback can attach it. */
+    private _lastErrorPayload;
+    private _fallbackListeners;
+    /**
+     * Per-configure-cycle id for correlating telemetry events from a
+     * single transport lifetime. Mirrors ChatAssistantLit's mountId
+     * but scoped to configure cycles since the transport is a
+     * singleton across mounts.
+     */
+    private _transportId;
+    private _configuredAt;
+    /**
+     * Configure the transport. Idempotent — calling again with the same
+     * backendUrl is a no-op; calling with a different backendUrl tears
+     * the connection down and re-arms.
+     */
+    configure(config: ChatTransportConfig): void;
+    /** ms since the most recent configure() call. 0 before any configure. */
+    private _ageMs;
+    /** True when configure() has been called and we're ready to lazy-connect on send. */
+    get isConfigured(): boolean;
+    /** True when AgUiTransport is up. */
+    get isConnected(): boolean;
+    /**
+     * Subscribe to fallback events — fires once per configure cycle
+     * when the transport gives up after sustained failure. Hosts
+     * (typically AdaptiveChatBarMountable) use this to swap the chat
+     * bar for a static "contact support" card.
+     */
+    onFallback(listener: FallbackListener): () => void;
+    /**
+     * Test seam — drive a synthetic error event through the transport's
+     * error handling without standing up a real AgUi transport. Production
+     * code path uses _onTransportEvent. Exported as a public method to
+     * keep the test isolation simple; not part of the documented API.
+     */
+    simulateError(payload: {
+        message?: string;
+        status?: number | null;
+        body?: string | null;
+        errorName?: string | null;
+    }): void;
+    /**
+     * Test seam — drive the FULL server-error path (fallback kernel + the
+     * visitor-facing chip), exactly what the `case 'error'` transport-event
+     * branch does. `midAnswer` simulates an assistant message having been
+     * mid-stream when the connection died.
+     */
+    simulateServerError(payload: {
+        message?: string;
+        status?: number | null;
+        body?: string | null;
+        errorName?: string | null;
+        midAnswer?: boolean;
+    }): void;
+    /**
+     * Test seam — register a synthetic successful message-complete so
+     * the hasSucceeded gate flips without a real AgUi round-trip.
+     */
+    simulateSuccessfulMessage(): void;
+    /**
+     * Test seam — return the lid slot that the next outbound request
+     * WOULD tag ``X-Active-Lid-Slot`` with, given current state. Mirrors
+     * the exact resolution buildHeaders uses (per-send slot wins over
+     * cached config). Not part of the documented API.
+     */
+    getActiveLidSlotForTest(): string | null;
+    /**
+     * Tear connection-level state down. Used internally by configure()
+     * to swap backends; preserves host-registered fallback listeners
+     * because the host UI handler (e.g. AdaptiveChatBarMountable's
+     * "swap to fallback card" callback) is configuration-independent.
+     */
+    private _disconnect;
+    /**
+     * Tear everything down — connection state PLUS host listeners.
+     * Use this in test teardown or when fully shutting the transport
+     * (page unload, integration test reset). The mountable calls
+     * _disconnect indirectly via reconfigure.
+     */
+    reset(): void;
+    /** AbortController for the live /session SSE reader; null = not running. */
+    private _sessionStreamAbort;
+    /** Capped reconnect backoff for the session stream. */
+    private _sessionStreamBackoffMs;
+    /**
+     * Open the persistent `/api/adaptive/session` SSE and feed its frames
+     * through the SAME `_onTransportEvent` switch the AG-UI path uses
+     * (FEAT-1783640628 — proactive nudges).
+     *
+     * The AG-UI cutover left this endpoint with no client consumer, so
+     * server-INITIATED events had nowhere to land. A fetch-based reader —
+     * unlike EventSource — can send the SDK token, and the visitor ids that
+     * write the server's nudge identity bridge. Idempotent; reconnects with
+     * capped backoff; `reset()`/`stopSessionStream()` tears it down.
+     */
+    startSessionStream(): Promise<void>;
+    stopSessionStream(): void;
+    private _clearDebounceTimer;
+    /**
+     * Show a per-call rotating variant in the thinking chip immediately (so
+     * consecutive tool calls differ), then rotate through the remaining phrasings
+     * every 4s while the same tool phase runs (C9). A
+     * single tool call can sit for tens of seconds (the model reasoning about the
+     * next step, or a slow retrieval); a static chip reads as frozen and hides a
+     * loop. Cycling makes a long/looping phase read as live progress. Restarting
+     * (a new tool), any output (message/thinking), or teardown clears the cycle.
+     */
+    private _startThinkingCycle;
+    private _stopThinkingCycle;
+    /**
+     * Shared error-handling kernel — called by the AG-UI subscriber and
+     * by the simulateError test seam. Publishes transport_error
+     * telemetry, captures lastErrorPayload, and starts the debounce
+     * timer that will fire fallback if no successful message arrives
+     * before it expires. Gated by hasSucceeded (post-success errors
+     * never fallback) and _fallbackRendered (one-shot).
+     */
+    private _handleErrorEvent;
+    /**
+     * Fire the fallback. One-shot per configure cycle. Notifies all
+     * fallback listeners with the per-customer card config and the
+     * diagnostic snapshot for telemetry/debug.
+     */
+    private _renderFallback;
+    private _wireSession;
+    private _forwardUserMessage;
+    /**
+     * Ensure AgUiTransport is up. Idempotent — multiple concurrent calls
+     * dedupe to a single Turnstile acquisition + transport setup.
+     * Returns true on success, false on terminal failure.
+     */
+    private _ensureConnected;
+    /**
+     * Acquire a Turnstile token via the managed-challenge flow.
+     * Delegates to the shared Turnstile helper that owns the verify
+     * panel lifecycle. Returns null when Turnstile is disabled at
+     * build time or acquisition fails.
+     */
+    private _acquireTurnstileWithChallenge;
+    /**
+     * Look up a tool call's current chatSession-side status by id.
+     * Used to decide between addToolCall (first sighting) and
+     * updateToolCall (subsequent updates) when AG-UI re-emits
+     * `tool-call` events for client tools transitioning to 'pending'.
+     */
+    private _findToolCallStatus;
+    /**
+     * Convert one server-transcript message (the session store shape:
+     * ``{id, role, content, timestamp, status, toolCalls?}`` with toolCalls
+     * in AG-UI wire shape) into a TrailMessage. Returns null for entries the
+     * trail can't render (missing id, system/tool roles, empty content with
+     * no tool receipts) — the transcript may legitimately contain them.
+     */
+    private _snapshotToTrailMessage;
+    /** AG-UI wire-shape toolCalls → settled TrailToolCall receipts. */
+    private _snapshotToolCalls;
+    /** Map AG-UI ToolCallStatus to TrailToolCall status. */
+    private _mapToolCallStatus;
+    private _onTransportEvent;
+}
+/**
+ * The module-level singleton. Imported by both the SDK runtime
+ * bootstrap (to call configure) and any code that needs to read
+ * transport state. Mirrors the chatSession singleton shape.
+ */
+export declare const chatTransport: ChatTransport;
+//# sourceMappingURL=ChatTransport.d.ts.map

package/dist/ChatTransport.d.ts.map

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

package/dist/InlineRegistryWidgetMount.test.d.ts

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

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

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

package/dist/InlineWidgetLiveMount.test.d.ts

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

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

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

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;AAoEH,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,83 @@
+/**
+ * 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>;
+//# 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"}

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;
@@ -29,7 +25,7 @@ export declare const manifest: {
         }[];
     };
     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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBpB,CAAC;AAaF,eAAe,QAAQ,CAAC"}