@syntrologie/adapt-chatbot 2.27.0 → 2.29.0

package/dist/runtime.js

@@ -1,8 +1,2291 @@
 import {
-  ChatAssistantLitMountable
-} from "./chunk-W457NMGD.js";
+  ActionHandler,
+  AgUiTransport,
+  ChatAssistantLitMountable,
+  ElementInstanceStore,
+  ItemHandler,
+  TileHandler,
+  acquireTokenWithChallenge,
+  decodeMutationEnvelope,
+  fetchMountedElements,
+  renderFallbackHtml
+} from "./chunk-ZXV4GXMO.js";
+import {
+  pickPersona
+} from "./chunk-FXHYE6FY.js";
+import {
+  getElementInstanceStore,
+  setElementInstanceStore
+} from "./chunk-EWPPVPJ4.js";
+import "./chunk-A7RBZLIX.js";
+import "./chunk-VZIUXXAM.js";
+import "./chunk-OIGVZGSX.js";
+import {
+  DIVE_DEEPER_EVENT,
+  TILE_MOUNTED_EVENT,
+  TILE_UNMOUNTED_EVENT
+} from "./chunk-EACGDSJI.js";
 import "./chunk-UVKRO5ER.js";
 
+// src/ChatSession.ts
+var _userIdCounter = 0;
+function generateUserMessageId() {
+  return `user-${Date.now()}-${++_userIdCounter}`;
+}
+var ChatSession = class {
+  constructor() {
+    this._messages = [];
+    this._inFlight = false;
+    this._runActive = false;
+    this._thinkingText = "";
+    this._nextId = 1;
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.sendListeners = /* @__PURE__ */ new Set();
+    this.interruptListeners = /* @__PURE__ */ new Set();
+    this.toolResultListeners = /* @__PURE__ */ new Set();
+  }
+  /** Snapshot the current state. Always returns a fresh immutable view. */
+  getState() {
+    return {
+      messages: [...this._messages],
+      inFlight: this._inFlight || this._runActive,
+      thinkingText: this._thinkingText
+    };
+  }
+  /**
+   * Append a delta to the active thinking turn's narration buffer.
+   * Forwarded from the AG-UI THINKING_TEXT_MESSAGE_CONTENT event so
+   * the chat trail can render the model's own reasoning instead of
+   * silent loading dots between turns.
+   */
+  appendThinkingDelta(delta) {
+    if (!delta) return;
+    this._thinkingText += delta;
+    this.notify();
+  }
+  /**
+   * Replace the active thinking narration outright (vs. appendThinkingDelta's
+   * streaming accumulation). Used to surface tool-call progress — e.g.
+   * "Searching…" while the agent works a tool — so a long tool phase shows
+   * what's happening instead of silent dots. No-op if unchanged.
+   */
+  setThinkingText(text) {
+    if (this._thinkingText === text) return;
+    this._thinkingText = text;
+    this.notify();
+  }
+  /**
+   * End the active thinking turn — drop any narration so the trail
+   * stops showing it. Fires on real text-message-start and on
+   * tool-call-start, the moment the model switches from reasoning
+   * to visible output.
+   */
+  clearThinking() {
+    if (!this._thinkingText) return;
+    this._thinkingText = "";
+    this.notify();
+  }
+  setRunActive(active) {
+    if (this._runActive === active) return;
+    this._runActive = active;
+    if (!active) this._thinkingText = "";
+    this.notify();
+  }
+  /**
+   * Subscribe to state changes. Called immediately with the current
+   * state, then again on every change. Returns an unsubscribe function.
+   */
+  subscribe(cb) {
+    this.subscribers.add(cb);
+    cb(this.getState());
+    return () => {
+      this.subscribers.delete(cb);
+    };
+  }
+  /**
+   * User submitted a message. Appends a user-role message, sets
+   * inFlight=true, notifies state subscribers, and fires a "send"
+   * event so transports can pick it up. Empty/whitespace text is a
+   * no-op (matches the chat bar's local guard).
+   */
+  send(text, opts) {
+    const trimmed = text.trim();
+    if (!trimmed) return;
+    const id = generateUserMessageId();
+    this._messages.push({ id, role: "user", text: trimmed });
+    this._inFlight = true;
+    this.notify();
+    const event = { text: trimmed, id };
+    if (opts?.activeLidSlot) event.activeLidSlot = opts.activeLidSlot;
+    if (opts?.forwardedProps) event.forwardedProps = opts.forwardedProps;
+    for (const listener of this.sendListeners) listener(event);
+  }
+  /**
+   * Single-shot assistant reply (no streaming). Equivalent to
+   * receiveStart + receiveDelta + receiveEnd in one call. Useful for
+   * stub transports and tests that don't model streaming.
+   */
+  receive(text) {
+    const id = `m-${this._nextId++}`;
+    this._messages.push({ id, role: "assistant", text, status: "complete" });
+    this._inFlight = false;
+    this.notify();
+  }
+  /**
+   * Begin a streaming assistant message. Appends an empty assistant
+   * message with status='streaming'. Caller (transport adapter) feeds
+   * deltas via receiveDelta(id, text) and signals completion via
+   * receiveEnd(id). `inFlight` stays true through the stream.
+   */
+  receiveStart(id) {
+    this._messages.push({ id, role: "assistant", text: "", status: "streaming" });
+    this._inFlight = true;
+    this.notify();
+  }
+  /**
+   * Append a delta to a streaming message. No-op when the id is
+   * unknown (race between transport events and reset, etc.) — never
+   * throws so transports can fire-and-forget.
+   */
+  receiveDelta(id, delta) {
+    const msg = this._messages.find((m) => m.id === id);
+    if (!msg || msg.status !== "streaming") return;
+    msg.text += delta;
+    this.notify();
+  }
+  /**
+   * Mark a streaming message complete and clear inFlight. No-op when
+   * the id is unknown (defensive against transport double-fires).
+   */
+  receiveEnd(id) {
+    const msg = this._messages.find((m) => m.id === id);
+    if (msg && msg.status === "streaming") {
+      msg.status = "complete";
+    }
+    this._inFlight = false;
+    this.notify();
+  }
+  /**
+   * Transport reports a fatal error. Marks any in-flight streaming
+   * message as 'error' (so the trail can render a styled error chip
+   * instead of pretending the partial text was a complete answer),
+   * appends a system-role message with the error text for visibility,
+   * and clears inFlight. Also drops any pending thinking narration
+   * — leaving stale "Let me check…" alongside an error chip reads
+   * as if the assistant is still working when it isn't.
+   */
+  error(message) {
+    for (const m of this._messages) {
+      if (m.status === "streaming") m.status = "error";
+    }
+    this._messages.push({
+      id: `err-${this._nextId++}`,
+      role: "system",
+      text: message,
+      status: "error"
+    });
+    this._inFlight = false;
+    this._runActive = false;
+    this._thinkingText = "";
+    this.notify();
+  }
+  /**
+   * User clicked the in-flight stop button. Clears inFlight and
+   * fires an "interrupt" event so transports can cancel their
+   * in-flight request. No-op if not in-flight (idempotent). Drops
+   * any pending thinking narration for the same reason as error():
+   * the visitor explicitly asked the assistant to stop, so it
+   * shouldn't keep narrating in the trail.
+   */
+  interrupt() {
+    if (!this._inFlight && !this._runActive) return;
+    this._inFlight = false;
+    this._runActive = false;
+    this._thinkingText = "";
+    this.notify();
+    for (const listener of this.interruptListeners) listener();
+  }
+  /**
+   * Wipe state. Used by the canvas-close path (start a fresh
+   * conversation next time) and by tests.
+   */
+  reset() {
+    this._messages = [];
+    this._inFlight = false;
+    this._runActive = false;
+    this._thinkingText = "";
+    this._nextId = 1;
+    this.notify();
+  }
+  /** Register a transport's send listener. Returns unsubscribe. */
+  onSend(listener) {
+    this.sendListeners.add(listener);
+    return () => {
+      this.sendListeners.delete(listener);
+    };
+  }
+  /**
+   * True when at least one transport has wired itself to the session's
+   * send pipeline. Views can use this to surface "no chat backend
+   * connected" affordances instead of hanging in `inFlight` after a
+   * send fires into the void.
+   */
+  hasTransport() {
+    return this.sendListeners.size > 0;
+  }
+  /** Register a transport's interrupt listener. Returns unsubscribe. */
+  onInterrupt(listener) {
+    this.interruptListeners.add(listener);
+    return () => {
+      this.interruptListeners.delete(listener);
+    };
+  }
+  /**
+   * Register a transport's tool-result listener. The transport
+   * forwards `tool-result` actions back to the agent after the user
+   * approves or rejects a client-tool call. Returns unsubscribe.
+   */
+  onToolResult(listener) {
+    this.toolResultListeners.add(listener);
+    return () => {
+      this.toolResultListeners.delete(listener);
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Tool calls
+  // -------------------------------------------------------------------------
+  /**
+   * Attach a tool call to a streaming assistant message. No-op when
+   * the message id is unknown (race between transport events and
+   * reset / late mount).
+   */
+  addToolCall(messageId, toolCall) {
+    const msg = this._messages.find((m) => m.id === messageId);
+    if (!msg) return;
+    msg.toolCalls = [...msg.toolCalls ?? [], { ...toolCall }];
+    this.notify();
+  }
+  /**
+   * Partially update a tool call by id. Used by the transport to
+   * advance status (args-streaming → running → done) as AG-UI events
+   * arrive. No-op when the id is unknown.
+   */
+  updateToolCall(toolCallId, patch) {
+    for (const msg of this._messages) {
+      const tcs = msg.toolCalls;
+      if (!tcs) continue;
+      const idx = tcs.findIndex((tc) => tc.id === toolCallId);
+      if (idx === -1) continue;
+      const next = [...tcs];
+      next[idx] = { ...next[idx], ...patch };
+      msg.toolCalls = next;
+      this.notify();
+      return;
+    }
+  }
+  /**
+   * Resolve a (client-) tool call. Marks the call done, persists, and
+   * fires onToolResult so the transport can forward the result + the
+   * user's approve/reject decision back to the agent. No-op when the
+   * id is unknown.
+   */
+  resolveToolCall(toolCallId, result, approved) {
+    let found = false;
+    for (const msg of this._messages) {
+      const tcs = msg.toolCalls;
+      if (!tcs) continue;
+      const idx = tcs.findIndex((tc) => tc.id === toolCallId);
+      if (idx === -1) continue;
+      const next = [...tcs];
+      next[idx] = { ...next[idx], status: "done" };
+      msg.toolCalls = next;
+      found = true;
+      break;
+    }
+    if (!found) return;
+    this.notify();
+    for (const listener of this.toolResultListeners) {
+      listener({ toolCallId, result, approved });
+    }
+  }
+  /**
+   * Hydrate from the server transcript (the /session SSE's
+   * messages-snapshot) — the server is the transcript of record
+   * (FEAT-1783701440). Snapshot order is truth: shared ids keep the
+   * LOCAL object (it may carry richer live tool-call state) but take the
+   * snapshot's position; snapshot-only messages (history on reload, a
+   * nudge missed during an SSE gap) are inserted; local-only messages
+   * (an in-flight turn, the greeting) float after in local order.
+   *
+   * Deploy-boundary guard: a user message persisted under a pre-Phase-2
+   * transport id (before ids were threaded) would arrive as
+   * "snapshot-only" next to its local twin — skip snapshot USER messages
+   * whose exact text already exists locally under a different id.
+   */
+  hydrate(snapshotMessages) {
+    if (!snapshotMessages.length) return;
+    const localById = new Map(this._messages.map((m) => [String(m.id), m]));
+    const twinBudget = /* @__PURE__ */ new Map();
+    for (const m of this._messages) {
+      if (m.role === "user") twinBudget.set(m.text, (twinBudget.get(m.text) ?? 0) + 1);
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const merged = [];
+    for (const sm of snapshotMessages) {
+      const key = String(sm.id);
+      const local = localById.get(key);
+      if (local) {
+        seen.add(key);
+        merged.push(local);
+        continue;
+      }
+      if (sm.role === "user") {
+        const budget = twinBudget.get(sm.text) ?? 0;
+        if (budget > 0) {
+          twinBudget.set(sm.text, budget - 1);
+          continue;
+        }
+      }
+      merged.push(sm);
+    }
+    for (const m of this._messages) {
+      if (!seen.has(String(m.id))) merged.push(m);
+    }
+    this._messages = merged;
+    this.notify();
+  }
+  notify() {
+    const state = this.getState();
+    for (const sub of this.subscribers) sub(state);
+  }
+};
+var chatSession = new ChatSession();
+
+// src/ChatTransport.ts
+var SESSION_READ_DEADLINE_MS = 6e4;
+var FALLBACK_DEBOUNCE_MS = 1500;
+function readSyntroToken() {
+  if (typeof window === "undefined") return void 0;
+  const cfg = window.__SYNTRO_CONFIG__;
+  const token = cfg?.token;
+  return typeof token === "string" && token.length > 0 ? token : void 0;
+}
+function debug(...args) {
+  if (typeof window === "undefined") return;
+  if (window.__SYNTRO_CHAT_DEBUG__) {
+    console.debug("[chat-transport]", ...args);
+  }
+}
+function parseToolCallArgs(toolCall) {
+  if (toolCall.args && typeof toolCall.args === "object") return toolCall.args;
+  const buf = toolCall.argsBuffer;
+  if (!buf) return null;
+  try {
+    const parsed = JSON.parse(buf);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function toolNarrationVariants(name) {
+  const n = (name || "").toLowerCase();
+  if (n.includes("search") || n.includes("retrieve"))
+    return ["Assembling relevant information", "Pulling together what matters for you"];
+  if (n.includes("route"))
+    return ["Diving deeper on specific products for you", "Exploring the best options for you"];
+  if (n.includes("read") || n.includes("section") || n.includes("overview"))
+    return ["Buttoning up details to point the right way", "Lining up the details for you"];
+  if (n.includes("selector"))
+    return ["Finalizing where to guide you", "Pinpointing the right spot for you"];
+  if (n.includes("wiki"))
+    return ["Looking that up for you", "Checking the knowledge base for you"];
+  if (n.includes("mount") || n.includes("unmount") || n.includes("element") || n.includes("response") || n.includes("primary") || n.includes("action"))
+    return ["Materializing the information for you", "Bringing it onto your screen"];
+  return ["Putting your answer together for you", "Almost there"];
+}
+function mergeForwardedProps(prev, next) {
+  if (next.forwardedProps !== void 0) return next;
+  if (!prev?.forwardedProps) return next;
+  return { ...next, forwardedProps: prev.forwardedProps };
+}
+var ChatTransport = class {
+  constructor() {
+    this._config = null;
+    this._status = "idle";
+    this._agui = null;
+    this._transportUnsub = null;
+    this._sessionUnsubSend = null;
+    this._sessionUnsubInterrupt = null;
+    this._sessionUnsubToolResult = null;
+    this._connectInFlight = null;
+    /** Bounded streaming-message id for the currently-being-typed assistant turn. */
+    this._currentAssistantMessageId = null;
+    /** Intent messageIds this transport actually dispatched (BUG-1784021805).
+     *  The server's `suppressToast` hint assumes the intent frame reached us —
+     *  but that frame is fire-and-forget, and a fresh visitor's connection gap
+     *  loses it. Only the transport knows what it dispatched, so suppression is
+     *  honored ONLY when the sibling intent (`{id}-intent`) went through here. */
+    this._dispatchedNudgeIntentIds = /* @__PURE__ */ new Set();
+    /** Outcome bookkeeping for telemetry. */
+    this._hadTurnstileToken = null;
+    /** Count of successful round-trips for telemetry payloads. */
+    this._messagesSucceeded = 0;
+    /** True once a successful assistant message has landed — gates fallback. */
+    this._hasSucceeded = false;
+    /** True once fallback has fired (one-shot). */
+    this._fallbackRendered = false;
+    /**
+     * 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.
+     */
+    this._pendingLidSlot = null;
+    /**
+     * Per-send forwardedProps override. Set in the ``chatSession.onSend``
+     * listener before each ``_forwardUserMessage`` and spread OVER the
+     * config-level forwardedProps for that one request (see
+     * ``_resolveForwardedProps``). Overwritten on EVERY send — ``null`` when
+     * the send carried no envelope — so turn provenance can never leak onto a
+     * later typed message and make it look synthetic. Same lifecycle as
+     * ``_pendingLidSlot``.
+     */
+    this._pendingForwardedProps = null;
+    /** Active debounce timer; null when no debounce pending. */
+    this._errorDebounceTimer = null;
+    /** Rotates thinking-chip phrasings during a long/looping tool phase (C9). */
+    this._thinkingCycleTimer = null;
+    /**
+     * 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).
+     */
+    this._thinkingClassSeq = /* @__PURE__ */ new Map();
+    /** Most recent error payload, captured so debounced fallback can attach it. */
+    this._lastErrorPayload = null;
+    this._fallbackListeners = /* @__PURE__ */ new Set();
+    /**
+     * 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.
+     */
+    this._transportId = `tx_${Math.random().toString(36).slice(2, 8)}`;
+    this._configuredAt = 0;
+    // -------------------------------------------------------------------------
+    // Session stream — server-initiated events (proactive nudges)
+    // -------------------------------------------------------------------------
+    /** AbortController for the live /session SSE reader; null = not running. */
+    this._sessionStreamAbort = null;
+    // (read-deadline constant lives at module scope: SESSION_READ_DEADLINE_MS)
+    /** Capped reconnect backoff for the session stream. */
+    this._sessionStreamBackoffMs = 2e3;
+  }
+  /**
+   * 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) {
+    const same = this._config && this._config.backendUrl === config.backendUrl && this._config.threadId === config.threadId;
+    if (same) {
+      this._config = { ...this._config, ...mergeForwardedProps(this._config, config) };
+      return;
+    }
+    this._disconnect();
+    this._config = config;
+    this._status = "configured";
+    this._transportId = `tx_${Math.random().toString(36).slice(2, 8)}`;
+    this._configuredAt = Date.now();
+    this._wireSession();
+    debug("configured", {
+      transportId: this._transportId,
+      backendUrl: config.backendUrl,
+      threadId: config.threadId
+    });
+  }
+  /** ms since the most recent configure() call. 0 before any configure. */
+  _ageMs() {
+    return this._configuredAt === 0 ? 0 : Date.now() - this._configuredAt;
+  }
+  /** True when configure() has been called and we're ready to lazy-connect on send. */
+  get isConfigured() {
+    return this._status !== "idle";
+  }
+  /** True when AgUiTransport is up. */
+  get isConnected() {
+    return this._status === "connected";
+  }
+  /**
+   * 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) {
+    this._fallbackListeners.add(listener);
+    return () => {
+      this._fallbackListeners.delete(listener);
+    };
+  }
+  /**
+   * 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) {
+    this._handleErrorEvent(payload);
+  }
+  /**
+   * 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) {
+    if (payload.midAnswer) this._currentAssistantMessageId = "test-mid-answer";
+    this._onTransportEvent({
+      type: "error",
+      message: payload.message ?? "boom",
+      status: payload.status ?? null,
+      body: payload.body ?? null,
+      errorName: payload.errorName ?? null
+    });
+  }
+  /**
+   * Test seam — register a synthetic successful message-complete so
+   * the hasSucceeded gate flips without a real AgUi round-trip.
+   */
+  simulateSuccessfulMessage() {
+    this._hasSucceeded = true;
+    this._messagesSucceeded += 1;
+    this._clearDebounceTimer();
+  }
+  /**
+   * 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() {
+    return this._pendingLidSlot ?? this._config?.activeLidSlot ?? 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.
+   */
+  _disconnect() {
+    if (this._transportUnsub) {
+      this._transportUnsub();
+      this._transportUnsub = null;
+    }
+    if (this._sessionUnsubSend) {
+      this._sessionUnsubSend();
+      this._sessionUnsubSend = null;
+    }
+    if (this._sessionUnsubInterrupt) {
+      this._sessionUnsubInterrupt();
+      this._sessionUnsubInterrupt = null;
+    }
+    if (this._sessionUnsubToolResult) {
+      this._sessionUnsubToolResult();
+      this._sessionUnsubToolResult = null;
+    }
+    if (this._agui) {
+      this._agui.disconnect();
+      this._agui = null;
+    }
+    this._clearDebounceTimer();
+    this._stopThinkingCycle();
+    this._thinkingClassSeq.clear();
+    this._config = null;
+    this._status = "idle";
+    this._connectInFlight = null;
+    this._currentAssistantMessageId = null;
+    this._hadTurnstileToken = null;
+    this._messagesSucceeded = 0;
+    this._hasSucceeded = false;
+    this._fallbackRendered = false;
+    this._lastErrorPayload = null;
+    this._pendingLidSlot = null;
+    this._pendingForwardedProps = null;
+  }
+  /**
+   * 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() {
+    this._disconnect();
+    this._fallbackListeners.clear();
+    this._dispatchedNudgeIntentIds.clear();
+    this.stopSessionStream();
+  }
+  /**
+   * 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.
+   */
+  async startSessionStream() {
+    if (this._sessionStreamAbort || !this._config) return;
+    const abort = new AbortController();
+    this._sessionStreamAbort = abort;
+    const baseUrl = this._config.backendUrl.replace(/\/$/, "");
+    const url = `${baseUrl}/api/adaptive/session`;
+    const headers = {};
+    const token = readSyntroToken();
+    if (token) headers.Authorization = `Bearer ${token}`;
+    const cft = await this._acquireTurnstileWithChallenge();
+    if (cft) headers["CF-Turnstile-Token"] = cft;
+    if (abort.signal.aborted) return;
+    const readIds = () => {
+      try {
+        const rt = this._config?.runtime;
+        const did = rt?.telemetry?.getDistinctId?.();
+        const sid = rt?.telemetry?.getSessionId?.();
+        return {
+          did: typeof did === "string" && did.length > 0 ? did : void 0,
+          sid: typeof sid === "string" && sid.length > 0 ? sid : void 0
+        };
+      } catch {
+        return {};
+      }
+    };
+    const hasTelemetryAccessor = () => {
+      try {
+        const rt = this._config?.runtime;
+        return typeof rt?.telemetry?.getDistinctId === "function";
+      } catch {
+        return false;
+      }
+    };
+    let ids = readIds();
+    for (let i = 0; i < 80 && hasTelemetryAccessor() && !ids.did && !abort.signal.aborted; i++) {
+      await new Promise((r) => setTimeout(r, 250));
+      ids = readIds();
+    }
+    if (abort.signal.aborted) return;
+    if (ids.did) headers["X-Distinct-Id"] = ids.did;
+    if (ids.sid) headers["X-Syntro-Session"] = ids.sid;
+    const runReader = async () => {
+      const connAbort = new AbortController();
+      const onOuterAbort = () => connAbort.abort();
+      abort.signal.addEventListener("abort", onOuterAbort, { once: true });
+      const abortRejection = new Promise((_, reject) => {
+        connAbort.signal.addEventListener(
+          "abort",
+          () => reject(new Error("session stream read deadline exceeded")),
+          { once: true }
+        );
+      });
+      abortRejection.catch(() => {
+      });
+      try {
+        const response = await fetch(url, {
+          headers,
+          credentials: "include",
+          signal: connAbort.signal
+        });
+        if (!response.ok || !response.body) {
+          throw new Error(`session stream connect failed: ${response.status}`);
+        }
+        this._sessionStreamBackoffMs = 2e3;
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        for (; ; ) {
+          const deadline = setTimeout(() => connAbort.abort(), SESSION_READ_DEADLINE_MS);
+          let result;
+          try {
+            result = await Promise.race([reader.read(), abortRejection]);
+          } catch (err) {
+            void reader.cancel().catch(() => {
+            });
+            throw err;
+          } finally {
+            clearTimeout(deadline);
+          }
+          const { done, value } = result;
+          if (done) return;
+          buffer += decoder.decode(value, { stream: true });
+          let sep = buffer.indexOf("\n\n");
+          while (sep >= 0) {
+            const frame = buffer.slice(0, sep);
+            buffer = buffer.slice(sep + 2);
+            sep = buffer.indexOf("\n\n");
+            const data = frame.split("\n").filter((l) => l.startsWith("data: ")).map((l) => l.slice(6)).join("");
+            if (!data) continue;
+            try {
+              this._onTransportEvent(JSON.parse(data));
+            } catch (err) {
+              console.warn("[adaptive-chatbot] session-stream frame parse failed", err);
+            }
+          }
+        }
+      } finally {
+        abort.signal.removeEventListener("abort", onOuterAbort);
+      }
+    };
+    void (async () => {
+      while (!abort.signal.aborted) {
+        try {
+          await runReader();
+        } catch (err) {
+          if (abort.signal.aborted) return;
+          console.warn("[adaptive-chatbot] session stream dropped; reconnecting", err);
+        }
+        if (abort.signal.aborted) return;
+        await new Promise((r) => setTimeout(r, this._sessionStreamBackoffMs));
+        this._sessionStreamBackoffMs = Math.min(this._sessionStreamBackoffMs * 2, 3e4);
+        const fresh = readIds();
+        if (fresh.did) headers["X-Distinct-Id"] = fresh.did;
+        if (fresh.sid) headers["X-Syntro-Session"] = fresh.sid;
+      }
+    })();
+    await Promise.resolve();
+  }
+  stopSessionStream() {
+    this._sessionStreamAbort?.abort();
+    this._sessionStreamAbort = null;
+    this._sessionStreamBackoffMs = 2e3;
+  }
+  _clearDebounceTimer() {
+    if (this._errorDebounceTimer) {
+      clearTimeout(this._errorDebounceTimer);
+      this._errorDebounceTimer = null;
+    }
+  }
+  /**
+   * 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.
+   */
+  _startThinkingCycle(variants) {
+    this._stopThinkingCycle();
+    const key = variants[0] ?? "";
+    const seq = this._thinkingClassSeq.get(key) ?? 0;
+    this._thinkingClassSeq.set(key, seq + 1);
+    let i = variants.length > 0 ? seq % variants.length : 0;
+    chatSession.setThinkingText(variants[i] ?? "Working on it\u2026");
+    if (variants.length < 2) return;
+    const id = setInterval(() => {
+      if (this._thinkingCycleTimer !== id) return;
+      i = (i + 1) % variants.length;
+      chatSession.setThinkingText(variants[i]);
+    }, 4e3);
+    this._thinkingCycleTimer = id;
+  }
+  _stopThinkingCycle() {
+    if (this._thinkingCycleTimer) {
+      clearInterval(this._thinkingCycleTimer);
+      this._thinkingCycleTimer = null;
+    }
+  }
+  /**
+   * 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).
+   */
+  _handleErrorEvent(payload) {
+    const status = payload.status ?? null;
+    const body = payload.body ? String(payload.body).slice(0, 200) : null;
+    this._lastErrorPayload = {
+      message: payload.message,
+      status,
+      body,
+      errorName: payload.errorName ?? null
+    };
+    this._stopThinkingCycle();
+    this._config?.runtime.events.publish("chatbot.transport_error", {
+      source: "chat-transport",
+      transportId: this._transportId,
+      transportAgeMs: this._ageMs(),
+      messagesSucceeded: this._messagesSucceeded,
+      hadTurnstileToken: this._hadTurnstileToken,
+      hasSucceeded: this._hasSucceeded,
+      errorMessage: payload.message ?? null,
+      errorStatus: status,
+      errorBody: body,
+      errorName: payload.errorName ?? null
+    });
+    if (this._hasSucceeded || this._fallbackRendered || this._errorDebounceTimer) return;
+    this._errorDebounceTimer = setTimeout(() => {
+      this._errorDebounceTimer = null;
+      if (this._hasSucceeded || this._fallbackRendered) return;
+      this._renderFallback("connect_failed");
+    }, FALLBACK_DEBOUNCE_MS);
+  }
+  /**
+   * 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.
+   */
+  _renderFallback(reason) {
+    if (this._fallbackRendered) return;
+    this._fallbackRendered = true;
+    debug("fallback", { reason, transportId: this._transportId, ageMs: this._ageMs() });
+    const fallback = this._config?.fallback ?? {};
+    const payload = {
+      reason,
+      fallback,
+      transportId: this._transportId,
+      transportAgeMs: this._ageMs(),
+      messagesSucceeded: this._messagesSucceeded,
+      hadTurnstileToken: this._hadTurnstileToken,
+      errorStatus: this._lastErrorPayload?.status ?? null,
+      errorBody: this._lastErrorPayload?.body ?? null,
+      errorMessage: this._lastErrorPayload?.message ?? null,
+      errorName: this._lastErrorPayload?.errorName ?? null
+    };
+    this._config?.runtime.events.publish(
+      "chatbot.fallback_rendered",
+      payload
+    );
+    for (const listener of this._fallbackListeners) listener(payload);
+  }
+  // -------------------------------------------------------------------------
+  // Internal: chatSession wiring
+  // -------------------------------------------------------------------------
+  /**
+   * forwardedProps for the NEXT outbound AG-UI request: the config-level
+   * value (late-bound — `configure()` can update uiTemplates /
+   * elementsEnabled mid-session without a reconnect, so this must be
+   * resolved per request, not captured at construction) with the per-send
+   * envelope spread over it. Shallow merge; per-send wins per top-level key.
+   */
+  _resolveForwardedProps() {
+    const raw = this._config?.forwardedProps;
+    const base = typeof raw === "function" ? raw() : raw;
+    const pending = this._pendingForwardedProps;
+    if (!pending) return base;
+    return { ...base ?? {}, ...pending };
+  }
+  _wireSession() {
+    this._sessionUnsubSend = chatSession.onSend(({ text, id, activeLidSlot, forwardedProps }) => {
+      this._pendingLidSlot = typeof activeLidSlot === "string" && activeLidSlot.length > 0 ? activeLidSlot : null;
+      this._pendingForwardedProps = forwardedProps ?? null;
+      void this._forwardUserMessage(text, id);
+    });
+    this._sessionUnsubInterrupt = chatSession.onInterrupt(() => {
+      this._agui?.send({ type: "stop-generation" });
+    });
+    this._sessionUnsubToolResult = chatSession.onToolResult(({ toolCallId, result, approved }) => {
+      this._agui?.send({ type: "tool-result", toolCallId, result, approved });
+    });
+  }
+  async _forwardUserMessage(text, id) {
+    let ok = false;
+    try {
+      ok = await this._ensureConnected();
+    } catch (err) {
+      this._status = "error";
+      this._handleErrorEvent({
+        message: err instanceof Error ? err.message : String(err),
+        errorName: err instanceof Error ? err.name : null
+      });
+    }
+    if (!ok || !this._agui) {
+      chatSession.error("Couldn't connect to chat. Please try again.");
+      return;
+    }
+    this._agui.send({ type: "user-message", text, ...id ? { id } : {} });
+  }
+  // -------------------------------------------------------------------------
+  // Internal: connect (lazy, Turnstile-gated)
+  // -------------------------------------------------------------------------
+  /**
+   * Ensure AgUiTransport is up. Idempotent — multiple concurrent calls
+   * dedupe to a single Turnstile acquisition + transport setup.
+   * Returns true on success, false on terminal failure.
+   */
+  async _ensureConnected() {
+    if (this._status === "connected" && this._agui) return true;
+    if (!this._config) return false;
+    if (this._connectInFlight) return this._connectInFlight;
+    this._connectInFlight = (async () => {
+      this._status = "acquiring";
+      const cft = await this._acquireTurnstileWithChallenge();
+      this._hadTurnstileToken = cft !== null;
+      if (this._config === null) return false;
+      const baseUrl = this._config.backendUrl.replace(/\/$/, "");
+      const streamUrl = `${baseUrl}/api/adaptive/stream`;
+      const token = readSyntroToken();
+      const buildHeaders = () => {
+        const h = {};
+        if (token) h.Authorization = `Bearer ${token}`;
+        if (cft) h["CF-Turnstile-Token"] = cft;
+        const lidSlot = this._pendingLidSlot ?? this._config?.activeLidSlot;
+        if (typeof lidSlot === "string" && lidSlot.length > 0) {
+          h["X-Active-Lid-Slot"] = lidSlot;
+        }
+        const asciiSafe = (v, max) => (v ?? "").replace(/[^\x20-\x7e]/g, "").slice(0, max).trim();
+        const pid = asciiSafe(this._config?.personaId, 32);
+        const pname = asciiSafe(this._config?.personaName, 24);
+        if (pid && pname) {
+          h["X-Syntro-Persona-Id"] = pid;
+          h["X-Syntro-Persona-Name"] = pname;
+          const prole = asciiSafe(this._config?.personaRole, 48);
+          if (prole) h["X-Syntro-Persona-Role"] = prole;
+        }
+        try {
+          const rt = this._config?.runtime;
+          const did = rt?.telemetry?.getDistinctId?.();
+          if (typeof did === "string" && did.length > 0) {
+            h["X-Distinct-Id"] = did;
+          }
+          const sid = rt?.telemetry?.getSessionId?.();
+          if (typeof sid === "string" && sid.length > 0) {
+            h["X-Syntro-Session"] = sid;
+          }
+        } catch {
+        }
+        return h;
+      };
+      const resolveForwardedProps = () => this._resolveForwardedProps();
+      this._agui = new AgUiTransport({
+        url: streamUrl,
+        headers: buildHeaders,
+        threadId: this._config.threadId,
+        clientTools: this._config.clientTools,
+        // Adaptive runtime SDK needs the `syntro_chat_session` cookie to
+        // round-trip cross-origin so subsequent boot fetches can rehydrate
+        // LLM-authored UI elements. Editor / action-plan chat surfaces
+        // auth via `?token=` and intentionally leave this unset (see
+        // AgUiTransportOptions.credentials docstring).
+        credentials: "include",
+        forwardedProps: resolveForwardedProps,
+        onA2UIEvent: (payload) => {
+          const runtime2 = this._config?.runtime;
+          if (!runtime2) return;
+          const mutations = decodeMutationEnvelope(payload);
+          if (mutations !== null) {
+            const handler = this._config?.onElementMutation;
+            if (handler) {
+              try {
+                handler(mutations);
+                runtime2.events.publish("chatbot.element_mutation_applied", {
+                  source: "chat-transport",
+                  count: mutations.length
+                });
+              } catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error("[chat-transport] element mutation apply failed:", msg);
+              }
+              return;
+            }
+            return;
+          }
+          runtime2.actions.applyBatch([payload]).then(() => {
+            runtime2.events.publish("chatbot.a2ui_applied", { source: "chat-transport" });
+          }).catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error("[chat-transport] A2UI apply failed:", msg);
+          });
+        }
+      });
+      this._agui.connect();
+      this._transportUnsub = this._agui.subscribe((event) => this._onTransportEvent(event));
+      this._status = "connected";
+      return true;
+    })();
+    try {
+      return await this._connectInFlight;
+    } finally {
+      this._connectInFlight = null;
+    }
+  }
+  /**
+   * 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.
+   */
+  async _acquireTurnstileWithChallenge() {
+    const { token } = await acquireTokenWithChallenge();
+    return token;
+  }
+  // -------------------------------------------------------------------------
+  // Internal: AgUi event → chatSession
+  // -------------------------------------------------------------------------
+  /**
+   * 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'.
+   */
+  _findToolCallStatus(toolCallId) {
+    const state = chatSession.getState();
+    for (const msg of state.messages) {
+      const tc = msg.toolCalls?.find((t) => t.id === toolCallId);
+      if (tc) return tc.status;
+    }
+    return null;
+  }
+  /**
+   * 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.
+   */
+  _snapshotToTrailMessage(raw) {
+    if (typeof raw !== "object" || raw === null) return null;
+    const m = raw;
+    const id = m.id;
+    const role = m.role;
+    if (typeof id !== "string" || !id) return null;
+    if (role !== "user" && role !== "assistant") return null;
+    const text = String(m.content ?? m.text ?? "");
+    const toolCalls = this._snapshotToolCalls(m.toolCalls);
+    if (!text && toolCalls.length === 0) return null;
+    const message = { id, role, text, status: "complete" };
+    if (toolCalls.length) message.toolCalls = toolCalls;
+    return message;
+  }
+  /** AG-UI wire-shape toolCalls → settled TrailToolCall receipts. */
+  _snapshotToolCalls(raw) {
+    if (!Array.isArray(raw)) return [];
+    const out = [];
+    for (const entry of raw) {
+      if (typeof entry !== "object" || entry === null) continue;
+      const tc = entry;
+      const fn = tc.function ?? {};
+      if (typeof tc.id !== "string" || typeof fn.name !== "string" || !fn.name) continue;
+      let args;
+      if (typeof fn.arguments === "string" && fn.arguments) {
+        try {
+          const parsed = JSON.parse(fn.arguments);
+          if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            args = parsed;
+          }
+        } catch {
+        }
+      }
+      out.push({ id: tc.id, name: fn.name, status: "done", ...args ? { args } : {} });
+    }
+    return out;
+  }
+  /** Map AG-UI ToolCallStatus to TrailToolCall status. */
+  _mapToolCallStatus(status) {
+    switch (status) {
+      case "args-streaming":
+        return "args-streaming";
+      case "pending":
+        return "pending";
+      case "running":
+        return "running";
+      case "done":
+        return "done";
+      case "error":
+        return "error";
+      default:
+        return "running";
+    }
+  }
+  _onTransportEvent(event) {
+    switch (event.type) {
+      case "session-ready":
+        return;
+      case "messages-snapshot": {
+        const converted = (event.messages ?? []).map((m) => this._snapshotToTrailMessage(m)).filter((m) => m !== null);
+        if (converted.length) chatSession.hydrate(converted);
+        return;
+      }
+      case "typing":
+        if (!event.isTyping) this._stopThinkingCycle();
+        chatSession.setRunActive(event.isTyping);
+        return;
+      case "message-append": {
+        this._stopThinkingCycle();
+        chatSession.clearThinking();
+        this._currentAssistantMessageId = event.message.id;
+        chatSession.receiveStart(event.message.id);
+        if (event.message.content && event.message.content.length > 0) {
+          chatSession.receiveDelta(event.message.id, event.message.content);
+        }
+        if (event.message.status === "complete") {
+          chatSession.receiveEnd(event.message.id);
+        }
+        return;
+      }
+      case "message-delta": {
+        const id = event.messageId ?? this._currentAssistantMessageId;
+        if (!id || !event.delta) return;
+        chatSession.receiveDelta(id, event.delta);
+        return;
+      }
+      case "nudge-intent": {
+        try {
+          if (event.messageId) this._dispatchedNudgeIntentIds.add(event.messageId);
+          document.dispatchEvent(
+            new CustomEvent("syntro:nudge", {
+              detail: {
+                pattern: event.pattern,
+                confidence: event.confidence,
+                messageId: event.messageId,
+                phase: "intent"
+              }
+            })
+          );
+        } catch {
+        }
+        return;
+      }
+      case "nudge": {
+        const id = event.messageId ?? this._currentAssistantMessageId;
+        if (id) chatSession.receiveEnd(id);
+        try {
+          const intentDispatched = id != null && this._dispatchedNudgeIntentIds.has(`${id}-intent`);
+          document.dispatchEvent(
+            new CustomEvent("syntro:nudge", {
+              detail: {
+                pattern: event.pattern,
+                confidence: event.confidence,
+                messageId: id,
+                suppressToast: event.suppressToast === true && intentDispatched
+              }
+            })
+          );
+        } catch {
+        }
+        return;
+      }
+      case "thinking-delta": {
+        return;
+      }
+      case "thinking-clear": {
+        this._stopThinkingCycle();
+        chatSession.clearThinking();
+        return;
+      }
+      case "message-complete": {
+        const id = event.messageId ?? this._currentAssistantMessageId;
+        if (!id) return;
+        this._stopThinkingCycle();
+        chatSession.receiveEnd(id);
+        this._currentAssistantMessageId = null;
+        this._messagesSucceeded += 1;
+        this._hasSucceeded = true;
+        this._clearDebounceTimer();
+        return;
+      }
+      case "tool-call": {
+        const existing = this._findToolCallStatus(event.toolCall.id);
+        if (!existing) {
+          this._startThinkingCycle(toolNarrationVariants(event.toolCall.name));
+        }
+        const targetMessageId = event.messageId ?? this._currentAssistantMessageId;
+        if (!targetMessageId) return;
+        const parsedArgs = parseToolCallArgs(event.toolCall);
+        if (!existing) {
+          chatSession.addToolCall(targetMessageId, {
+            id: event.toolCall.id,
+            name: event.toolCall.name,
+            status: this._mapToolCallStatus(event.toolCall.status),
+            ...parsedArgs ? { args: parsedArgs } : {}
+          });
+        } else {
+          chatSession.updateToolCall(event.toolCall.id, {
+            name: event.toolCall.name,
+            status: this._mapToolCallStatus(event.toolCall.status),
+            ...parsedArgs ? { args: parsedArgs } : {}
+          });
+        }
+        return;
+      }
+      case "tool-call-args-delta":
+        debug("tool-call-args-delta", event);
+        return;
+      case "tool-call-done": {
+        const doneArgs = parseToolCallArgs(event);
+        chatSession.updateToolCall(event.toolCallId, {
+          status: "done",
+          ...doneArgs ? { args: doneArgs } : {}
+        });
+        return;
+      }
+      case "a2ui":
+        return;
+      case "error": {
+        const status = event.status ?? null;
+        const body = event.body ? String(event.body).slice(0, 200) : null;
+        console.warn(
+          `[chat-transport] error status=${status ?? "no-status"} succeeded=${this._messagesSucceeded}`,
+          event
+        );
+        this._handleErrorEvent({
+          message: event.message,
+          status,
+          body,
+          errorName: event.errorName ?? null
+        });
+        const wasMidAnswer = this._currentAssistantMessageId != null;
+        chatSession.error(
+          wasMidAnswer ? "The connection dropped partway through \u2014 ask again and I'll pick it back up." : "Hmm, that didn't go through. Please try again."
+        );
+        this._currentAssistantMessageId = null;
+        if (this._agui) {
+          this._agui.disconnect();
+          this._agui = null;
+        }
+        if (this._transportUnsub) {
+          this._transportUnsub();
+          this._transportUnsub = null;
+        }
+        this._status = "error";
+        return;
+      }
+    }
+  }
+};
+var chatTransport = new ChatTransport();
+
+// src/observer/allowlist.ts
+var MAX_TEXT_LEN = 200;
+var SIGNIFICANT_CLICK_TAGS = /* @__PURE__ */ new Set(["button", "a"]);
+function truncate(s) {
+  return s.length <= MAX_TEXT_LEN ? s : `${s.slice(0, MAX_TEXT_LEN - 1)}\u2026`;
+}
+function firstElement(props) {
+  const els = props.$elements;
+  if (Array.isArray(els) && els.length > 0 && typeof els[0] === "object" && els[0] !== null) {
+    return els[0];
+  }
+  return null;
+}
+function elementText(props) {
+  const el = firstElement(props);
+  if (!el) return "";
+  const t = el.text;
+  return typeof t === "string" ? t.trim() : "";
+}
+function elementTag(props) {
+  const explicit = props.$element_tag_name;
+  if (typeof explicit === "string") return explicit.toLowerCase();
+  const el = firstElement(props);
+  if (el && typeof el.tag_name === "string") return el.tag_name.toLowerCase();
+  return "";
+}
+function elementRole(props) {
+  const el = firstElement(props);
+  if (!el) return "";
+  const role = el.attr__role;
+  return typeof role === "string" ? role.toLowerCase() : "";
+}
+function formName(props) {
+  const el = firstElement(props);
+  if (!el) return "unnamed";
+  const name = el.attr__name;
+  if (typeof name === "string" && name) return name;
+  const id = el.attr__id;
+  if (typeof id === "string" && id) return id;
+  return "unnamed";
+}
+function isSignificantClickTarget(props) {
+  const tag = elementTag(props);
+  if (SIGNIFICANT_CLICK_TAGS.has(tag)) return true;
+  if (elementRole(props) === "button") return true;
+  return false;
+}
+function pathname(props) {
+  const pn = props.$pathname;
+  return typeof pn === "string" ? pn : "/";
+}
+function renderCustomEvent(raw) {
+  const fields = [];
+  for (const [k, v] of Object.entries(raw.properties)) {
+    if (k.startsWith("$")) continue;
+    if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+      fields.push(`${k}=${v}`);
+      if (fields.length >= 2) break;
+    }
+  }
+  return fields.length > 0 ? `${raw.event} (${fields.join(", ")})` : raw.event;
+}
+function matchEvent(raw, opts = {}) {
+  const props = raw.properties;
+  switch (raw.event) {
+    case "$pageview": {
+      const path = pathname(props);
+      return {
+        ts: raw.timestamp,
+        kind: "nav",
+        text: truncate(`navigated to ${path}`),
+        ref: truncate(path)
+      };
+    }
+    case "$autocapture": {
+      const eventType = props.$event_type;
+      if (eventType === "click") {
+        if (!isSignificantClickTarget(props)) return null;
+        const text = elementText(props) || elementTag(props);
+        return {
+          ts: raw.timestamp,
+          kind: "click",
+          text: truncate(`clicked '${text}'`)
+        };
+      }
+      if (eventType === "submit" && elementTag(props) === "form") {
+        return {
+          ts: raw.timestamp,
+          kind: "form",
+          text: truncate(`submitted form '${formName(props)}'`)
+        };
+      }
+      return null;
+    }
+    case "$rageclick": {
+      const text = elementText(props) || elementTag(props);
+      return {
+        ts: raw.timestamp,
+        kind: "rage",
+        text: truncate(`rage-clicked '${text}'`)
+      };
+    }
+    case "$dead_click": {
+      const text = elementText(props) || elementTag(props);
+      return {
+        ts: raw.timestamp,
+        kind: "dead",
+        text: truncate(`clicked '${text}' (no response)`)
+      };
+    }
+    // ── Canonical runtime-bus events (sources: `'canvas'` instrumentation
+    //    or the event-processor's rrweb detectors). These don't go through
+    //    PostHog; the chat-bar's bus translator forwards them as-is with
+    //    the canonical event name, and matchEvent picks the right slot
+    //    here. Keeps a single allowlist as the source of truth for what
+    //    the agent's observation tail can carry.
+    case "nav.section_viewed": {
+      const section = typeof props.section === "string" ? props.section : "";
+      if (!section) return null;
+      return {
+        ts: raw.timestamp,
+        kind: "view",
+        text: truncate(`viewed the '${section}' section`),
+        ref: truncate(section)
+      };
+    }
+    case "nav.scroll_depth": {
+      const pct = typeof props.percent === "number" ? props.percent : null;
+      if (pct === null) return null;
+      return {
+        ts: raw.timestamp,
+        kind: "scroll",
+        text: truncate(`scrolled to ${pct}% of the page`)
+      };
+    }
+    case "ui.scroll_thrash": {
+      return {
+        ts: raw.timestamp,
+        kind: "scroll",
+        text: "scrolled up and down repeatedly (looking for something)"
+      };
+    }
+    case "ui.idle": {
+      const ms = typeof props.durationMs === "number" ? props.durationMs : null;
+      const secs = ms !== null ? Math.round(ms / 1e3) : null;
+      return {
+        ts: raw.timestamp,
+        kind: "idle",
+        text: secs !== null ? `idle for ${secs}s` : "idle"
+      };
+    }
+    case "ui.hover": {
+      const text = elementText(props) || elementTag(props);
+      return {
+        ts: raw.timestamp,
+        kind: "hover",
+        text: truncate(`hovered on '${text}'`)
+      };
+    }
+    // Canonical name is 'ui.hesitate' (StandardEvents.UI_HESITATE) — the rrweb
+    // hesitation detector emits coordinates + duration_ms, no element chain, so
+    // the summary is duration-based. (BUG-1784146789: this case was spelled
+    // 'ui.hesitation', a name nothing emits, so the signal never arrived.)
+    case "ui.hesitate": {
+      const ms = typeof props.duration_ms === "number" ? props.duration_ms : null;
+      const secs = ms !== null ? Math.round(ms / 1e3) : null;
+      return {
+        ts: raw.timestamp,
+        kind: "hesitation",
+        text: secs !== null ? `hesitated in place for ${secs}s` : "hesitated in place"
+      };
+    }
+    case "ui.focus_bounce": {
+      const text = elementText(props) || elementTag(props);
+      return {
+        ts: raw.timestamp,
+        kind: "form",
+        text: truncate(`focused '${text}' but didn't fill it`)
+      };
+    }
+    default: {
+      const allow = opts.observableEvents ?? [];
+      if (allow.includes(raw.event)) {
+        return {
+          ts: raw.timestamp,
+          kind: "custom",
+          text: truncate(renderCustomEvent(raw))
+        };
+      }
+      return null;
+    }
+  }
+}
+
+// src/observer/queue.ts
+var ObserverQueue = class {
+  constructor(opts) {
+    this._buffer = [];
+    this._sent = 0;
+    this._dropped = 0;
+    this._lastError = null;
+    this._disabled = false;
+    this._intervalTimer = null;
+    this._backoffTimer = null;
+    this._currentBackoffMs = 0;
+    this._inFlight = false;
+    this._opts = {
+      backoffStartMs: 1e3,
+      backoffCapMs: 3e4,
+      ...opts
+    };
+  }
+  push(event) {
+    if (this._disabled) return;
+    if (this._buffer.length >= this._opts.queueCap) {
+      this._buffer.shift();
+      this._dropped += 1;
+    }
+    this._buffer.push(event);
+    if (this._buffer.length >= this._opts.batchSize) {
+      this._scheduleImmediate();
+    } else {
+      this._scheduleInterval();
+    }
+  }
+  async flushNow() {
+    this._clearInterval();
+    await this._flush();
+  }
+  /**
+   * Synchronously hand the newest backend-sized batch to an unload-safe sender.
+   * Returns false when the sender rejected delivery and restores the batch so
+   * the caller can fall back to fetch({ keepalive: true }).
+   */
+  flushOnPageHide(send) {
+    if (this._disabled || this._buffer.length === 0) return true;
+    this._clearInterval();
+    const overflow = Math.max(0, this._buffer.length - 50);
+    if (overflow > 0) {
+      this._buffer.splice(0, overflow);
+      this._dropped += overflow;
+    }
+    const batch = this._buffer.splice(0, 50);
+    if (!send(batch)) {
+      this._buffer.unshift(...batch);
+      return false;
+    }
+    this._sent += batch.length;
+    this._lastError = null;
+    return true;
+  }
+  stats() {
+    return {
+      queued: this._buffer.length,
+      sent: this._sent,
+      dropped: this._dropped,
+      lastError: this._lastError,
+      disabled: this._disabled
+    };
+  }
+  _scheduleImmediate() {
+    queueMicrotask(() => {
+      void this._flush();
+    });
+  }
+  _scheduleInterval() {
+    if (this._intervalTimer != null) return;
+    this._intervalTimer = setTimeout(() => {
+      this._intervalTimer = null;
+      void this._flush();
+    }, this._opts.flushIntervalMs);
+  }
+  _clearInterval() {
+    if (this._intervalTimer != null) {
+      clearTimeout(this._intervalTimer);
+      this._intervalTimer = null;
+    }
+  }
+  async _flush() {
+    if (this._disabled || this._inFlight || this._buffer.length === 0) return;
+    this._clearInterval();
+    const batch = this._buffer.splice(0, this._opts.batchSize);
+    this._inFlight = true;
+    try {
+      await this._opts.flush(batch);
+      this._sent += batch.length;
+      this._currentBackoffMs = 0;
+      this._lastError = null;
+    } catch (err) {
+      this._buffer.unshift(...batch);
+      const perm = err?.permanent === true;
+      this._lastError = err instanceof Error ? err.message : String(err?.message ?? err);
+      if (perm) {
+        this._disabled = true;
+      } else {
+        this._scheduleBackoff();
+      }
+    } finally {
+      this._inFlight = false;
+    }
+  }
+  _scheduleBackoff() {
+    const next = this._currentBackoffMs === 0 ? this._opts.backoffStartMs : Math.min(this._currentBackoffMs * 2, this._opts.backoffCapMs);
+    this._currentBackoffMs = next;
+    if (this._backoffTimer != null) clearTimeout(this._backoffTimer);
+    this._backoffTimer = setTimeout(() => {
+      this._backoffTimer = null;
+      void this._flush();
+    }, next);
+  }
+};
+
+// src/observer/transport.ts
+function buildBody(distinctId, sessionId, batch) {
+  if (!distinctId || !sessionId) return null;
+  const body = { distinct_id: distinctId, session_id: sessionId, batch };
+  return JSON.stringify(body);
+}
+function createTransport(opts) {
+  return {
+    async send(batch) {
+      const body = buildBody(opts.getDistinctId(), opts.getSessionId(), batch);
+      if (body === null) return;
+      const resp = await fetch(opts.url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${opts.token()}`,
+          "Content-Type": "application/json"
+        },
+        body,
+        keepalive: true,
+        credentials: "include"
+      });
+      if (!resp.ok) {
+        const err = new Error(`observation POST ${resp.status}`);
+        if (resp.status >= 400 && resp.status < 500 && resp.status !== 429) {
+          err.permanent = true;
+        }
+        throw err;
+      }
+    },
+    sendBeacon(batch) {
+      const body = buildBody(opts.getDistinctId(), opts.getSessionId(), batch);
+      if (body === null) return false;
+      const blob = new Blob([body], { type: "application/json" });
+      const beacon = navigator?.sendBeacon;
+      if (typeof beacon !== "function") return false;
+      const separator = opts.url.includes("?") ? "&" : "?";
+      const url = `${opts.url}${separator}syn=${encodeURIComponent(opts.token())}`;
+      return beacon.call(navigator, url, blob);
+    }
+  };
+}
+
+// src/observer/index.ts
+var _active = null;
+function _attachPostHog(ingest, _observableEvents) {
+  const ph = globalThis.posthog;
+  if (!ph) return () => {
+  };
+  const addHook = ph._addCaptureHook;
+  if (typeof addHook !== "function") return () => {
+  };
+  const handler = (eventName, properties) => {
+    if (typeof eventName !== "string") return;
+    ingest({
+      event: eventName,
+      timestamp: Date.now(),
+      properties: properties ?? {}
+    });
+  };
+  addHook.call(ph, handler);
+  return () => {
+  };
+}
+function _attachPageHide(transport, queue) {
+  const handler = () => {
+    const stats = queue.stats();
+    if (stats.queued > 0) {
+      queue.flushOnPageHide((batch) => {
+        if (transport.sendBeacon(batch)) return true;
+        void transport.send(batch);
+        return true;
+      });
+    }
+  };
+  window.addEventListener("pagehide", handler, { capture: true });
+  return () => window.removeEventListener("pagehide", handler, { capture: true });
+}
+function startObserver(opts) {
+  if (_active) {
+    _active.refCount += 1;
+    return _makeHandle(_active);
+  }
+  const transport = opts.transport ?? createTransport(opts);
+  const queue = new ObserverQueue({
+    batchSize: 10,
+    flushIntervalMs: 2e3,
+    queueCap: 200,
+    flush: (batch) => transport.send(batch)
+  });
+  const ingest = (raw) => {
+    const matched = matchEvent(raw, { observableEvents: opts.observableEvents });
+    if (matched !== null) {
+      queue.push(opts.enrich ? opts.enrich(matched, raw) : matched);
+    }
+  };
+  const unsubscribePh = _attachPostHog(ingest, opts.observableEvents ?? []);
+  const unsubscribePageHide = _attachPageHide(transport, queue);
+  const active = {
+    refCount: 1,
+    queue,
+    unsubscribe: () => {
+      unsubscribePh();
+      unsubscribePageHide();
+    },
+    options: opts
+  };
+  _active = active;
+  return _makeHandle(active);
+}
+function _makeHandle(owner) {
+  return {
+    stop() {
+      if (_active !== owner) return;
+      owner.refCount -= 1;
+      if (owner.refCount <= 0) {
+        owner.unsubscribe();
+        _active = null;
+      }
+    },
+    stats() {
+      return (_active === owner ? owner.queue.stats() : null) ?? {
+        queued: 0,
+        sent: 0,
+        dropped: 0,
+        lastError: null,
+        disabled: true
+      };
+    },
+    ingest(raw) {
+      if (_active !== owner) return;
+      const matched = matchEvent(raw, {
+        observableEvents: owner.options.observableEvents
+      });
+      if (matched !== null) {
+        owner.queue.push(owner.options.enrich ? owner.options.enrich(matched, raw) : matched);
+      }
+    },
+    flushNow() {
+      return _active === owner ? owner.queue.flushNow() : Promise.resolve();
+    }
+  };
+}
+
+// src/observer/bus-translate.ts
+function eventTypeFromName(name) {
+  switch (name) {
+    case "ui.click":
+      return "click";
+    case "ui.submit":
+      return "submit";
+    case "ui.change":
+      return "change";
+    default:
+      return void 0;
+  }
+}
+function busEventToRawEvent(e) {
+  if (!e?.name) return null;
+  const ts = typeof e.ts === "number" ? e.ts : Date.now();
+  if (e.source === "posthog") {
+    const original = e.props?.originalEvent;
+    if (typeof original !== "string" || original.length === 0) return null;
+    const src = e.props ?? {};
+    const properties = { ...src };
+    if (Array.isArray(src.elements)) properties.$elements = src.elements;
+    if (typeof src.tagName === "string") properties.$element_tag_name = src.tagName;
+    if (typeof src.pathname === "string") properties.$pathname = src.pathname;
+    if (typeof src.url === "string") properties.$current_url = src.url;
+    const eventType = eventTypeFromName(e.name);
+    if (eventType) properties.$event_type = eventType;
+    return { event: original, timestamp: ts, properties };
+  }
+  return { event: e.name, timestamp: ts, properties: { ...e.props ?? {} } };
+}
+
+// src/AdaptiveChatBarMountable.ts
+var STATE_KEY = "__syntroChatBarMount";
+function getState(container) {
+  return container[STATE_KEY] ?? null;
+}
+function setState(container, state) {
+  container[STATE_KEY] = state;
+}
+function applyPlaceholder(bar, cfg) {
+  if (cfg.placeholder !== void 0) bar.placeholder = cfg.placeholder;
+  if (cfg.assistantName !== void 0) bar.assistantName = cfg.assistantName;
+  if (cfg.personas !== void 0) bar.personas = cfg.personas;
+  if (cfg.greeting !== void 0) bar.greeting = cfg.greeting;
+  if (cfg.voiceInput !== void 0) bar.voiceInput = cfg.voiceInput;
+  bar.introSuggestion = cfg.introSuggestion;
+  bar.forceExpanded = cfg.forceExpanded === true;
+  if (typeof cfg.maximized === "boolean") {
+    bar.maximized = cfg.maximized;
+  }
+}
+var _elementStore = null;
+var _templateWidgetMap = /* @__PURE__ */ new Map();
+var SERVER_MOUNTED_TILE_WIDGETS = ["syntro-product-reco-carousel"];
+function resolveTileWidget(templateId) {
+  return _templateWidgetMap.get(templateId);
+}
+function refreshTemplateWidgetMap(uiTemplates) {
+  _templateWidgetMap.clear();
+  for (const tag of SERVER_MOUNTED_TILE_WIDGETS) {
+    _templateWidgetMap.set(tag, tag);
+  }
+  if (!uiTemplates) return;
+  const tiles = uiTemplates.tiles;
+  if (!Array.isArray(tiles)) return;
+  for (const t of tiles) {
+    const id = typeof t?.id === "string" ? t.id : null;
+    const widget = typeof t?.widget === "string" ? t.widget : null;
+    if (id && widget) _templateWidgetMap.set(id, widget);
+  }
+}
+function getOrCreateElementStore(runtime2) {
+  if (_elementStore) return _elementStore;
+  _elementStore = new ElementInstanceStore({
+    actions: runtime2.actions,
+    // Pass the runtime's event bus so ItemHandler can broadcast
+    // `element.compositional_append` / `_patch` / `_remove` events
+    // to container widgets (chips strip, FAQ accordion, nav tips).
+    events: {
+      publish: runtime2.events.publish.bind(runtime2.events),
+      subscribe: runtime2.events.subscribe?.bind(runtime2.events)
+    },
+    handlers: [new TileHandler(resolveTileWidget), new ActionHandler(), new ItemHandler()],
+    resolveTileWidget
+  });
+  setElementInstanceStore(_elementStore);
+  return _elementStore;
+}
+var _hydrationStarted = false;
+function hydrateOnce(runtime2, backendUrl) {
+  if (_hydrationStarted) return;
+  _hydrationStarted = true;
+  const store = getOrCreateElementStore(runtime2);
+  const trimmed = backendUrl.replace(/\/$/, "");
+  const endpoint = trimmed ? `${trimmed}/api/adaptive/mounted_elements` : "/api/adaptive/mounted_elements";
+  fetchMountedElements({ endpoint }).then((response) => {
+    if (!response) return;
+    void store.hydrate(response.mounted_elements);
+  });
+}
+var PAGE_LEVEL_KINDS = /* @__PURE__ */ new Set(["view", "scroll", "idle", "hesitation", "hover", "nav"]);
+function buildObserverEnrich(runtimeRef) {
+  return (ev, raw) => {
+    const extract = runtimeRef.getProductIdentity;
+    if (typeof extract !== "function") return ev;
+    if (ev.kind === "click") {
+      const chain = raw.properties.$elements;
+      if (!Array.isArray(chain)) return ev;
+      const id = extract(chain);
+      if (!id) return ev;
+      return {
+        ...ev,
+        product: {
+          handle: id.productHandle,
+          url: id.productUrl,
+          ...id.productTitle ? { title: id.productTitle } : {}
+        }
+      };
+    }
+    if (!ev.product && PAGE_LEVEL_KINDS.has(ev.kind) && typeof location !== "undefined") {
+      const id = extract([{ href: location.pathname }]);
+      if (!id) return ev;
+      return {
+        ...ev,
+        product: {
+          handle: id.productHandle,
+          url: id.productUrl,
+          ...id.productTitle ? { title: id.productTitle } : {}
+        }
+      };
+    }
+    return ev;
+  };
+}
+var _nudgeSurfaceWired = false;
+var _nudgeListener = null;
+function wireNudgeSurface(runtime2, backendUrl) {
+  if (_nudgeSurfaceWired || typeof document === "undefined") return;
+  _nudgeSurfaceWired = true;
+  _nudgeListener = (e) => {
+    try {
+      const detail = e.detail;
+      const isIntent = detail?.phase === "intent";
+      if (!isIntent) {
+        const store = getOrCreateElementStore(runtime2);
+        const trimmed = backendUrl.replace(/\/$/, "");
+        const endpoint = trimmed ? `${trimmed}/api/adaptive/mounted_elements` : "/api/adaptive/mounted_elements";
+        void fetchMountedElements({ endpoint }).then((response) => {
+          if (!response) return;
+          void store.hydrate(response.mounted_elements);
+        });
+      }
+      if (detail?.suppressToast === true) return;
+      const findCanvas = (root) => {
+        const direct = root.querySelector("smart-canvas");
+        if (direct) return direct;
+        for (const el of root.querySelectorAll("*")) {
+          const sr = el.shadowRoot;
+          if (sr) {
+            const found = findCanvas(sr);
+            if (found) return found;
+          }
+        }
+        return null;
+      };
+      const canvas = findCanvas(document);
+      const messageId = e.detail?.messageId;
+      const nudgeText = messageId ? (chatSession.getState().messages.find((m) => m.id === messageId)?.text ?? "").trim() : "";
+      const title = nudgeText ? nudgeText.length > 140 ? `${nudgeText.slice(0, 137)}\u2026` : nudgeText : "I put something together for you";
+      canvas?.previewNotification?.({
+        title,
+        body: "Tap to take a look"
+      });
+    } catch (err) {
+      console.warn("[adaptive-chatbot] nudge surface reaction failed", err);
+    }
+  };
+  document.addEventListener("syntro:nudge", _nudgeListener);
+}
+function configureTransportIfPossible(cfg) {
+  if (!cfg.runtime) return;
+  const backendUrl = cfg.runtime.backendUrl;
+  if (!backendUrl) return;
+  const elementsActive = cfg.elementsEnabled === true && cfg.uiTemplates != null;
+  refreshTemplateWidgetMap(elementsActive ? cfg.uiTemplates : void 0);
+  const forwardedProps = elementsActive ? { elementsEnabled: true, uiTemplates: cfg.uiTemplates } : void 0;
+  if (elementsActive) publishTemplatesIfPossible(backendUrl, cfg.uiTemplates);
+  const runtime2 = cfg.runtime;
+  const onElementMutation = elementsActive ? (mutations) => {
+    void getOrCreateElementStore(runtime2).apply(mutations);
+  } : void 0;
+  if (elementsActive) {
+    hydrateOnce(runtime2, backendUrl);
+  }
+  const persona = pickPersona(cfg.personas ?? null);
+  chatTransport.configure({
+    ...cfg,
+    backendUrl,
+    forwardedProps,
+    onElementMutation,
+    activeLidSlot: cfg._syntroSlotName,
+    personaId: persona?.id,
+    personaName: persona?.name,
+    personaRole: persona?.role_title
+  });
+  void chatTransport.startSessionStream();
+  wireNudgeSurface(runtime2, backendUrl);
+  startObserverIfPossible(cfg);
+}
+var _templatesPublished = false;
+function publishTemplatesIfPossible(backendUrl, uiTemplates) {
+  if (_templatesPublished || typeof window === "undefined") return;
+  if (!uiTemplates || typeof uiTemplates !== "object") return;
+  _templatesPublished = true;
+  const cfg = window.__SYNTRO_CONFIG__;
+  const token = typeof cfg?.token === "string" && cfg.token.length > 0 ? cfg.token : void 0;
+  const headers = { "Content-Type": "application/json" };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const trimmed = backendUrl.replace(/\/$/, "");
+  void fetch(`${trimmed}/api/adaptive/templates`, {
+    method: "POST",
+    headers,
+    credentials: "include",
+    body: JSON.stringify({ ui_templates: uiTemplates })
+  }).catch(() => {
+  });
+}
+var _diveDeeperWired = false;
+function wireDiveDeeperListener() {
+  if (_diveDeeperWired || typeof window === "undefined") return;
+  _diveDeeperWired = true;
+  window.addEventListener(DIVE_DEEPER_EVENT, (e) => {
+    const detail = e.detail ?? {};
+    const prompt = typeof detail.prompt === "string" && detail.prompt.trim() ? detail.prompt : detail.title ? "I'd like to dive deeper on this, I didn't see what I needed." : "";
+    if (!prompt) return;
+    const origin = { kind: "dive-deeper" };
+    if (detail.title) origin.title = detail.title;
+    if (detail.context) origin.context = detail.context;
+    chatSession.send(prompt, { forwardedProps: { origin } });
+    if (!chatSession.hasTransport()) {
+      chatSession.error("Chat backend not configured \u2014 set backendUrl in the canvas config.");
+    }
+  });
+}
+var _observerStarted = false;
+var _observerRuntime = null;
+var _observerHandle = null;
+var _observerBusUnsubscribe = null;
+function startObserverIfPossible(cfg) {
+  if (typeof window === "undefined") return;
+  const runtimeRef = cfg.runtime;
+  if (!runtimeRef?.events?.subscribe) return;
+  if (_observerStarted && _observerRuntime === runtimeRef) return;
+  if (_observerStarted) {
+    _observerBusUnsubscribe?.();
+    _observerHandle?.stop();
+    _observerBusUnsubscribe = null;
+    _observerHandle = null;
+    _observerStarted = false;
+  }
+  const trimmed = (runtimeRef.backendUrl ?? "").replace(/\/$/, "");
+  const url = trimmed ? `${trimmed}/api/adaptive/observation` : "/api/adaptive/observation";
+  const runtimeId = (method) => {
+    try {
+      const v = runtimeRef.telemetry?.[method]?.();
+      return typeof v === "string" && v.length > 0 ? v : null;
+    } catch {
+      return null;
+    }
+  };
+  const getDistinctId = () => runtimeId("getDistinctId");
+  const getSessionId = () => runtimeId("getSessionId");
+  const token = () => {
+    const c = window.__SYNTRO_CONFIG__;
+    return typeof c?.token === "string" ? c.token : "";
+  };
+  const enrich = buildObserverEnrich(runtimeRef);
+  const handle = startObserver({ url, token, getDistinctId, getSessionId, enrich });
+  window.__syntroObserverStats = () => handle.stats();
+  const unsubscribe = runtimeRef.events.subscribe({}, (evt) => {
+    const raw = busEventToRawEvent(evt);
+    if (raw) handle.ingest(raw);
+  });
+  _observerRuntime = runtimeRef;
+  _observerHandle = handle;
+  _observerBusUnsubscribe = unsubscribe;
+  _observerStarted = true;
+}
+function wireListeners(bar, state) {
+  const onMessageSent = (e) => {
+    const text = e.detail.text;
+    chatSession.send(text, { activeLidSlot: state.cfg._syntroSlotName });
+    if (!chatSession.hasTransport()) {
+      chatSession.error("Chat backend not configured \u2014 set backendUrl in the canvas config.");
+    }
+  };
+  const onInterrupt = () => {
+    chatSession.interrupt();
+  };
+  const onToolCallApproved = (e) => {
+    const detail = e.detail;
+    chatSession.resolveToolCall(detail.toolCallId, {}, detail.approved);
+  };
+  const onClose = () => {
+    state.cfg.onClose?.();
+  };
+  bar.addEventListener("chat-message-sent", onMessageSent);
+  bar.addEventListener("chat-interrupt", onInterrupt);
+  bar.addEventListener("canvas-close", onClose);
+  bar.addEventListener("trail-toolcall-approved", onToolCallApproved);
+  return () => {
+    bar.removeEventListener("chat-message-sent", onMessageSent);
+    bar.removeEventListener("chat-interrupt", onInterrupt);
+    bar.removeEventListener("canvas-close", onClose);
+    bar.removeEventListener("trail-toolcall-approved", onToolCallApproved);
+  };
+}
+var AdaptiveChatBarMountable = {
+  mount(container, mountConfig) {
+    const cfg = mountConfig ?? {};
+    configureTransportIfPossible(cfg);
+    wireDiveDeeperListener();
+    const bar = document.createElement("adaptive-chat-bar");
+    applyPlaceholder(bar, cfg);
+    const widgets = cfg.runtime?.widgets;
+    if (widgets) {
+      bar.mountInlineWidget = (widgetId, container2, props) => {
+        if (!widgets.has(widgetId)) return null;
+        const handle = widgets.mount(widgetId, container2, props);
+        const element = container2.firstElementChild;
+        if (!element) {
+          handle.unmount?.();
+          return null;
+        }
+        return { element, cleanup: () => handle.unmount?.() };
+      };
+    }
+    const unsubSession = chatSession.subscribe((s) => {
+      bar.messages = [...s.messages];
+      bar.inFlight = s.inFlight;
+      bar.thinkingText = s.thinkingText;
+    });
+    const runtimeEvents = cfg.runtime ? cfg.runtime.events : void 0;
+    const refreshReceipts = () => {
+      const store = _elementStore;
+      if (store) {
+        bar.tileReceipts = store.listTileReceipts();
+        bar.inlineWidgets = store.listInlineWidgets();
+      }
+    };
+    let unsubReceipts;
+    if (runtimeEvents?.subscribe) {
+      unsubReceipts = runtimeEvents.subscribe(
+        { names: [TILE_MOUNTED_EVENT, TILE_UNMOUNTED_EVENT] },
+        refreshReceipts
+      );
+    }
+    refreshReceipts();
+    const state = { bar, cleanup: () => {
+    }, cfg };
+    const unwireListeners = wireListeners(bar, state);
+    container.appendChild(bar);
+    const unsubFallback = chatTransport.onFallback(() => {
+      bar.remove();
+      container.innerHTML = renderFallbackHtml(state.cfg.fallback);
+    });
+    state.cleanup = () => {
+      unsubSession();
+      unsubFallback();
+      unsubReceipts?.();
+      unwireListeners();
+      bar.remove();
+      setState(container, null);
+    };
+    setState(container, state);
+    return state.cleanup;
+  },
+  update(container, mountConfig) {
+    const state = getState(container);
+    if (!state) return;
+    const cfg = mountConfig ?? {};
+    configureTransportIfPossible(cfg);
+    applyPlaceholder(state.bar, cfg);
+    state.cfg = cfg;
+  }
+};
+
+// src/AdaptiveChipsStripMountable.ts
+var STATE_KEY2 = "__syntroChipsStripMount";
+function getState2(container) {
+  return container[STATE_KEY2] ?? null;
+}
+function setState2(container, state) {
+  container[STATE_KEY2] = state;
+}
+function applyProps(strip, cfg) {
+  if (cfg.chips !== void 0) strip.chips = cfg.chips;
+  if (cfg.runtime !== void 0) {
+    strip.runtimeRef = cfg.runtime;
+  }
+  if (cfg.chromeless !== void 0) strip.chromeless = cfg.chromeless;
+}
+var AdaptiveChipsStripMountable = {
+  mount(container, mountConfig) {
+    const cfg = mountConfig ?? {};
+    const strip = document.createElement("adaptive-chips-strip");
+    applyProps(strip, cfg);
+    const state = {
+      strip,
+      listeners: {
+        revealed: (e) => {
+          const cb = cfg.onChipRevealed;
+          if (cb) {
+            cb(
+              e.detail
+            );
+          }
+        },
+        dismissed: (e) => {
+          const cb = cfg.onChipDismissed;
+          if (cb) cb(e.detail);
+        }
+      }
+    };
+    strip.addEventListener("chip-revealed", state.listeners.revealed);
+    strip.addEventListener("chip-dismissed", state.listeners.dismissed);
+    container.appendChild(strip);
+    setState2(container, state);
+    return () => {
+      strip.removeEventListener("chip-revealed", state.listeners.revealed);
+      strip.removeEventListener("chip-dismissed", state.listeners.dismissed);
+      strip.remove();
+      setState2(container, null);
+    };
+  },
+  update(container, mountConfig) {
+    const state = getState2(container);
+    if (!state) return;
+    const cfg = mountConfig ?? {};
+    applyProps(state.strip, cfg);
+    state.strip.removeEventListener("chip-revealed", state.listeners.revealed);
+    state.strip.removeEventListener("chip-dismissed", state.listeners.dismissed);
+    state.listeners.revealed = (e) => {
+      const cb = cfg.onChipRevealed;
+      if (cb) {
+        cb(e.detail);
+      }
+    };
+    state.listeners.dismissed = (e) => {
+      const cb = cfg.onChipDismissed;
+      if (cb) cb(e.detail);
+    };
+    state.strip.addEventListener("chip-revealed", state.listeners.revealed);
+    state.strip.addEventListener("chip-dismissed", state.listeners.dismissed);
+  }
+};
+
+// src/NavLinkMountable.ts
+var STATE_KEY3 = "__syntroNavLinkMount";
+var SAFE_NAVIGATION_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+function getState3(container) {
+  return container[STATE_KEY3] ?? null;
+}
+function setState3(container, state) {
+  container[STATE_KEY3] = state;
+}
+function navigateTo(rawUrl) {
+  if (!rawUrl) return;
+  let resolved;
+  try {
+    resolved = new URL(rawUrl, window.location.origin);
+  } catch {
+    return;
+  }
+  if (resolved.origin !== window.location.origin) return;
+  if (!SAFE_NAVIGATION_PROTOCOLS.has(resolved.protocol)) return;
+  window.history.pushState(null, "", resolved.toString());
+  window.dispatchEvent(new PopStateEvent("popstate"));
+}
+function buildButton(cfg) {
+  const button = document.createElement("button");
+  button.type = "button";
+  button.dataset.syntroNavLink = "";
+  button.style.display = "inline-flex";
+  button.style.alignItems = "center";
+  button.style.gap = "6px";
+  button.style.padding = "6px 12px";
+  button.style.borderRadius = "8px";
+  button.style.fontFamily = "var(--sc-font-family, 'system-ui')";
+  button.style.fontSize = "12px";
+  button.style.fontWeight = "600";
+  button.style.cursor = "pointer";
+  button.style.color = "var(--sc-accent-foreground, currentColor)";
+  button.style.background = "hsl(var(--sc-accent-color) / 0.85)";
+  button.style.border = "1px solid hsl(var(--sc-accent-color) / 0.30)";
+  applyLabel(button, cfg);
+  return button;
+}
+function applyLabel(button, cfg) {
+  const url = String(cfg.url ?? "");
+  const label = cfg.label ?? (url ? `Go to ${url}` : "Go");
+  button.textContent = label;
+}
+var NavLinkMountable = {
+  mount(container, mountConfig) {
+    const cfg = mountConfig ?? {};
+    const button = buildButton(cfg);
+    const onClick = (_e) => {
+      const current = getState3(container);
+      const url = current?.cfg.url ?? cfg.url;
+      navigateTo(String(url ?? ""));
+    };
+    button.addEventListener("click", onClick);
+    container.appendChild(button);
+    setState3(container, { button, cfg, onClick });
+    return () => {
+      button.removeEventListener("click", onClick);
+      button.remove();
+      setState3(container, null);
+    };
+  },
+  update(container, mountConfig) {
+    const state = getState3(container);
+    if (!state) return;
+    const cfg = mountConfig ?? {};
+    applyLabel(state.button, cfg);
+    state.cfg = cfg;
+  }
+};
+
+// src/TextAnswerMountable.ts
+var STATE_KEY4 = "__syntroTextAnswerMount";
+function getState4(container) {
+  return container[STATE_KEY4] ?? null;
+}
+function setState4(container, state) {
+  container[STATE_KEY4] = state;
+}
+function applyText(p, text) {
+  p.textContent = text;
+}
+var TextAnswerMountable = {
+  mount(container, mountConfig) {
+    const cfg = mountConfig ?? {};
+    const paragraph = document.createElement("p");
+    paragraph.dataset.syntroTextAnswer = "";
+    paragraph.style.margin = "0";
+    paragraph.style.fontSize = "12px";
+    paragraph.style.lineHeight = "1.55";
+    paragraph.style.color = "var(--sc-tile-text-color, currentColor)";
+    applyText(paragraph, String(cfg.text ?? ""));
+    container.appendChild(paragraph);
+    setState4(container, { paragraph, cfg });
+    return () => {
+      paragraph.remove();
+      setState4(container, null);
+    };
+  },
+  update(container, mountConfig) {
+    const state = getState4(container);
+    if (!state) return;
+    const cfg = mountConfig ?? {};
+    applyText(state.paragraph, String(cfg.text ?? ""));
+    state.cfg = cfg;
+  }
+};
+
 // src/runtime.ts
 var runtime = {
   id: "adaptive-chatbot",
@@ -19,12 +2302,71 @@ var runtime = {
         description: "AI-powered chat assistant with SSE streaming and A2UI support",
         icon: "\u{1F4AC}"
       }
+    },
+    // PRD §3 chat lid: the standalone chat bar UI shell. Used as a slot
+    // `lid` widget (where it replaces the launcher) or as a regular
+    // tile widget (renders inside the drawer). Headless of any chat
+    // transport — emits chat-message-sent / chat-interrupt / canvas-close
+    // for the parent to wire to whatever pipeline it owns.
+    {
+      id: "adaptive-chatbot:chat-bar",
+      component: AdaptiveChatBarMountable,
+      metadata: {
+        name: "Chat Bar",
+        description: "Always-visible chat input row with bubble-up trail. Headless \u2014 wire to your own transport.",
+        icon: "\u2726"
+      }
+    },
+    // PRD §4.5 suggested-chips tile: horizontally-wrapping chip strip
+    // with click-to-reveal payload drawer. Each chip is a
+    // `suggestions:chip` action.
+    {
+      id: "adaptive-chatbot:chips-strip",
+      component: AdaptiveChipsStripMountable,
+      metadata: {
+        name: "Suggested Chips",
+        description: "Wrapping chip strip with click-to-reveal payloads.",
+        icon: "\u2728"
+      }
+    },
+    // Built-in chip payload — a single paragraph of body text. Chip
+    // payloads are widget references (same {widget,props} shape as
+    // tile/lid configs); this is the simplest one shipped out of the
+    // box so the chip pattern works without requiring a downstream
+    // adaptive for a "just answer with text" case.
+    {
+      id: "adaptive-chatbot:text-answer",
+      component: TextAnswerMountable,
+      metadata: {
+        name: "Text Answer",
+        description: "Single paragraph payload \u2014 the default chip-drawer content.",
+        icon: "\xB6"
+      }
+    },
+    // Chip payload for LLM-authored navigation suggestions. Backed by
+    // the `suggest-navigation` ItemTemplate: the backend wraps a curated
+    // URL into props.url, the chip's payload-drawer mounts this widget,
+    // user clicks "Go to <url>" → same-origin SPA navigation. Kept here
+    // (not in adaptive-nav) so chip payloads ship with the chatbot
+    // bundle that already provides chips-strip + text-answer.
+    {
+      id: "adaptive-chatbot:nav-link",
+      component: NavLinkMountable,
+      metadata: {
+        name: "Nav Link",
+        description: "Same-origin navigation button \u2014 used as a chip payload for LLM-authored nav suggestions.",
+        icon: "\u2192"
+      }
     }
   ]
 };
 var runtime_default = runtime;
 export {
+  ElementInstanceStore,
+  TileHandler,
   runtime_default as default,
-  runtime
+  getElementInstanceStore,
+  runtime,
+  setElementInstanceStore
 };
 //# sourceMappingURL=runtime.js.map