@syntrologie/adapt-chatbot 2.55.0 → 2.56.0

package/dist/runtime.js

@@ -1,34 +1,37 @@
 import {
-  ActionHandler,
   AgUiTransport,
   ChatAssistantLitMountable,
-  ElementInstanceStore,
-  ItemHandler,
-  TileHandler,
-  acquireTokenWithChallenge,
+  acquireBotCheckTokenForSend,
   decodeMutationEnvelope,
   fetchMountedElements,
   renderFallbackHtml
-} from "./chunk-57MPLQOL.js";
+} from "./chunk-7QXC475Y.js";
+import {
+  ElementInstanceStore,
+  TileHandler,
+  createElementSessionController,
+  createTemplateWidgetResolver
+} from "./chunk-23E6WZOO.js";
 import {
   pickPersona
-} from "./chunk-VFWA5W56.js";
+} from "./chunk-XPUHW2YO.js";
 import {
   getElementInstanceStore,
   setElementInstanceStore
 } from "./chunk-EWPPVPJ4.js";
-import "./chunk-LJEPZI6Y.js";
-import "./chunk-TZA7572J.js";
-import "./chunk-ETDHHQS3.js";
+import "./chunk-WQIDXGGS.js";
+import "./chunk-GN7Z5IVP.js";
+import "./chunk-NMYFYMJI.js";
 import {
   DIVE_DEEPER_EVENT,
   TELEMETRY_DOM_EVENT,
   TILE_MOUNTED_EVENT,
   TILE_UNMOUNTED_EVENT,
   isCanonicalBusEvent,
+  reportCardStage,
   stripMountPlumbing
-} from "./chunk-NGV35N4T.js";
-import "./chunk-UVKRO5ER.js";
+} from "./chunk-Z3YR4JFE.js";
+import "./chunk-LY5AGXVD.js";
 
 // src/ChatSession.ts
 var _userIdCounter = 0;
@@ -540,6 +543,9 @@ var ChatTransport = class {
     this._firstDeltaAt = null;
     this._runMounts = 0;
     this._runCards = 0;
+    /** The mount_* tool of every mount this run fired, in order — which surfaces
+     *  the concierge chose (a carousel on one turn, separate cards on another). */
+    this._runMountTools = [];
     /**
      * Count of RUN_FINISHED events the server still owes us that must be
      * swallowed, not reported — one per interrupt. NOT a boolean: an
@@ -723,6 +729,7 @@ var ChatTransport = class {
     this._firstDeltaAt = null;
     this._runMounts = 0;
     this._runCards = 0;
+    this._runMountTools = [];
     this._pendingSuppressedFinishes = 0;
   }
   /**
@@ -745,9 +752,6 @@ var ChatTransport = class {
     const headers2 = {};
     const token = readRuntimeToken(this._config?.runtime);
     if (token) headers2.Authorization = `Bearer ${token}`;
-    const cft = await this._acquireTurnstileWithChallenge();
-    if (cft) headers2["CF-Turnstile-Token"] = cft;
-    if (abort.signal.aborted) return;
     const readIds = () => {
       try {
         const rt = this._config?.runtime;
@@ -987,6 +991,7 @@ var ChatTransport = class {
         this._firstDeltaAt = null;
         this._runMounts = 0;
         this._runCards = 0;
+        this._runMountTools = [];
         this._reportAtom("syntro_chat_message_sent", { turn, chars: text.length, via });
         void this._forwardUserMessage(text, id);
       }
@@ -1093,6 +1098,23 @@ var ChatTransport = class {
           if (!runtime2) return;
           const mutations = decodeMutationEnvelope(payload);
           if (mutations !== null) {
+            const config = this._config;
+            if (config?.onElementEnvelope) {
+              void config.onElementEnvelope({
+                type: "syntro.element.mutation",
+                schema_version: "v0",
+                mutations
+              }).then(() => {
+                if (this._config === config)
+                  runtime2.events.publish("chatbot.element_mutation_applied", {
+                    source: "chat-transport",
+                    count: mutations.length
+                  });
+              }).catch(() => {
+                console.error("[chat-transport] element mutation apply failed");
+              });
+              return;
+            }
             const handler = this._config?.onElementMutation;
             if (handler) {
               try {
@@ -1129,13 +1151,15 @@ var ChatTransport = class {
     }
   }
   /**
-   * 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.
+   * Acquire a Turnstile token for a visitor send. Only reached from
+   * `_ensureConnected`, i.e. on interaction. Returns null without touching
+   * Cloudflare when the build has no sitekey or the backend does not enforce
+   * the check; null also when acquisition fails.
    */
   async _acquireTurnstileWithChallenge() {
-    const { token } = await acquireTokenWithChallenge();
+    if (!this._config) return null;
+    const backendUrl = this._config.backendUrl.replace(/\/$/, "");
+    const { token } = await acquireBotCheckTokenForSend(backendUrl);
     return token;
   }
   // -------------------------------------------------------------------------
@@ -1309,6 +1333,7 @@ var ChatTransport = class {
         if (!existing && event.toolCall.name.startsWith("mount_")) {
           this._runMounts += 1;
           if (/card/i.test(event.toolCall.name)) this._runCards += 1;
+          this._runMountTools.push(event.toolCall.name);
         }
         if (!existing) {
           this._startThinkingCycle(toolNarrationVariants(event.toolCall.name));
@@ -1406,7 +1431,8 @@ var ChatTransport = class {
             ttft_ms: (this._firstDeltaAt ?? end) - this._runStartedAt,
             total_ms: end - this._runStartedAt,
             mounts: this._runMounts,
-            cards: this._runCards
+            cards: this._runCards,
+            mount_tools: [...this._runMountTools]
           });
         }
         this._runStartedAt = 0;
@@ -1440,6 +1466,38 @@ function findSmartCanvas() {
   return find(document);
 }
 
+// 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/observer/allowlist.ts
 var MAX_TEXT_LEN = 200;
 var SIGNIFICANT_CLICK_TAGS = /* @__PURE__ */ new Set(["button", "a"]);
@@ -1942,36 +2000,74 @@ function _makeHandle(owner) {
   };
 }
 
-// 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;
-  }
+// src/observer/wire.ts
+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;
+  };
 }
-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 ?? {} } };
+function wireObserver(runtime2) {
+  if (typeof window === "undefined" || !runtime2?.events?.subscribe) return () => {
+  };
+  const trimmed = (runtime2.backendUrl ?? "").replace(/\/$/, "");
+  const url = trimmed ? `${trimmed}/api/adaptive/observation` : "/api/adaptive/observation";
+  const runtimeId = (method) => {
+    try {
+      const value = runtime2.telemetry?.[method]?.();
+      return typeof value === "string" && value.length > 0 ? value : null;
+    } catch {
+      return null;
+    }
+  };
+  const token = () => typeof runtime2.token === "string" ? runtime2.token : "";
+  const handle = startObserver({
+    url,
+    token,
+    getDistinctId: () => runtimeId("getDistinctId"),
+    getSessionId: () => runtimeId("getSessionId"),
+    enrich: buildObserverEnrich(runtime2)
+  });
+  window.__syntroObserverStats = () => handle.stats();
+  const unsubscribe = runtime2.events.subscribe({}, (event) => {
+    const raw = busEventToRawEvent(event);
+    if (raw) handle.ingest(raw);
+  });
+  let stopped = false;
+  return () => {
+    if (stopped) return;
+    stopped = true;
+    unsubscribe();
+    handle.stop();
+  };
 }
 
 // src/support-chat/registry.ts
@@ -3067,106 +3163,41 @@ function applyPlaceholder(bar, cfg2) {
   if (typeof cfg2.maximized === "boolean") {
     bar.maximized = cfg2.maximized;
   }
+  if (cfg2.chatControl !== void 0) bar.chatControl = cfg2.chatControl;
+  if (typeof cfg2.interleaved === "boolean") bar.interleaved = cfg2.interleaved;
 }
-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 _elementSession = null;
+var _pendingTemplates;
+function refreshTemplateWidgetMap(templates) {
+  _pendingTemplates = templates;
+  _elementSession?.configureTemplates(templates);
+}
+function getOrCreateElementSession(runtime2) {
+  if (_elementSession) return _elementSession;
+  _elementSession = createElementSessionController({ ...runtime2, templates: _pendingTemplates });
+  setElementInstanceStore(_elementSession.store);
+  return _elementSession;
 }
-var _hydrationStarted = false;
 function hydrateOnce(runtime2, backendUrl) {
-  if (_hydrationStarted) return;
-  _hydrationStarted = true;
-  const store = getOrCreateElementStore(runtime2);
+  const session = getOrCreateElementSession(runtime2);
   const trimmed = backendUrl.replace(/\/$/, "");
   const endpoint = trimmed ? `${trimmed}/api/adaptive/mounted_elements` : "/api/adaptive/mounted_elements";
-  fetchMountedElements({ endpoint, token: runtime2.token }).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;
-  };
+  session.hydrateOnce(() => fetchMountedElements({ endpoint, token: runtime2.token }));
 }
-var _nudgeSurfaceWired = false;
-var _nudgeListener = null;
+var _removeNudgeListener = null;
 function wireNudgeSurface(runtime2, backendUrl) {
-  if (_nudgeSurfaceWired || typeof document === "undefined") return;
-  _nudgeSurfaceWired = true;
-  _nudgeListener = (e) => {
+  if (_removeNudgeListener || typeof document === "undefined") return;
+  const listener = (e) => {
     try {
       const detail = e.detail;
       const isIntent = detail?.phase === "intent";
       if (!isIntent) {
-        const store = getOrCreateElementStore(runtime2);
+        const session = getOrCreateElementSession(runtime2);
         const trimmed = backendUrl.replace(/\/$/, "");
         const endpoint = trimmed ? `${trimmed}/api/adaptive/mounted_elements` : "/api/adaptive/mounted_elements";
         void fetchMountedElements({ endpoint, token: runtime2.token }).then((response) => {
           if (!response) return;
-          void store.hydrate(response.mounted_elements);
+          void session.hydrateLegacy(response.mounted_elements, response.session_expires_at);
         });
       }
       if (detail?.suppressToast === true) return;
@@ -3182,7 +3213,11 @@ function wireNudgeSurface(runtime2, backendUrl) {
       console.warn("[adaptive-chatbot] nudge surface reaction failed", err);
     }
   };
-  document.addEventListener("syntro:nudge", _nudgeListener);
+  document.addEventListener("syntro:nudge", listener);
+  _removeNudgeListener = () => {
+    document.removeEventListener("syntro:nudge", listener);
+    _removeNudgeListener = null;
+  };
 }
 function configureTransportIfPossible(cfg2) {
   if (!cfg2.runtime) return;
@@ -3193,9 +3228,7 @@ function configureTransportIfPossible(cfg2) {
   const forwardedProps = elementsActive ? { elementsEnabled: true, uiTemplates: cfg2.uiTemplates } : void 0;
   if (elementsActive) publishTemplatesIfPossible(backendUrl, cfg2.uiTemplates, cfg2.runtime?.token);
   const runtime2 = cfg2.runtime;
-  const onElementMutation = elementsActive ? (mutations) => {
-    void getOrCreateElementStore(runtime2).apply(mutations);
-  } : void 0;
+  const onElementEnvelope = elementsActive ? (envelope) => getOrCreateElementSession(runtime2).applyLegacyEnvelope(envelope) : void 0;
   if (elementsActive) {
     hydrateOnce(runtime2, backendUrl);
   }
@@ -3204,7 +3237,7 @@ function configureTransportIfPossible(cfg2) {
     ...cfg2,
     backendUrl,
     forwardedProps,
-    onElementMutation,
+    onElementEnvelope,
     activeLidSlot: cfg2._syntroSlotName,
     personaId: persona?.id,
     personaName: persona?.name,
@@ -3251,46 +3284,19 @@ function wireDiveDeeperListener() {
 }
 var _observerStarted = false;
 var _observerRuntime = null;
-var _observerHandle = null;
-var _observerBusUnsubscribe = null;
+var _observerStop = null;
 function startObserverIfPossible(cfg2) {
   if (typeof window === "undefined") return;
   const runtimeRef = cfg2.runtime;
   if (!runtimeRef?.events?.subscribe) return;
   if (_observerStarted && _observerRuntime === runtimeRef) return;
   if (_observerStarted) {
-    _observerBusUnsubscribe?.();
-    _observerHandle?.stop();
-    _observerBusUnsubscribe = null;
-    _observerHandle = null;
+    _observerStop?.();
+    _observerStop = 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 t = runtimeRef.token;
-    return typeof t === "string" ? t : "";
-  };
-  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);
-  });
+  _observerStop = wireObserver(runtimeRef);
   _observerRuntime = runtimeRef;
-  _observerHandle = handle;
-  _observerBusUnsubscribe = unsubscribe;
   _observerStarted = true;
 }
 function wireListeners(bar, state) {
@@ -3359,7 +3365,7 @@ var AdaptiveChatBarMountable = {
     });
     const runtimeEvents = cfg2.runtime ? cfg2.runtime.events : void 0;
     const refreshReceipts = () => {
-      const store = _elementStore;
+      const store = _elementSession?.store;
       if (store) {
         bar.tileReceipts = store.listTileReceipts();
         bar.inlineWidgets = store.listInlineWidgets();
@@ -3472,6 +3478,658 @@ var AdaptiveChipsStripMountable = {
   }
 };
 
+// src/hostAgentController.ts
+var READ_TOOL = "read_brand_view";
+var MISSING_RESULT_MS = 8e3;
+var PENDING_MAX_MS = 12e4;
+var AGENT_TURN_KEY = "syntro/agent-turn";
+var CARD_HEARTBEAT_PREFIX = "syntro:mcp-card:";
+var heartbeatPrefix = (sessionRef) => `${CARD_HEARTBEAT_PREFIX}${sessionRef}:`;
+var CARD_HEARTBEAT_INTERVAL_MS = 2e3;
+var CARD_SIBLING_WINDOW_MS = 6e3;
+var CARD_HEARTBEAT_STALE_MS = 6e4;
+var CARD_SUPERSEDED = "canvas:superseded";
+var DOCKED_PREFIX = "syntro:mcp-docked:";
+var DOCKED_FOR_MS = 24 * 60 * 60 * 1e3;
+function coarsePointer() {
+  try {
+    return typeof matchMedia === "function" && matchMedia("(pointer: coarse)").matches;
+  } catch {
+    return false;
+  }
+}
+function cardStorage() {
+  try {
+    return globalThis.localStorage ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+var STAR_TOOL = "star_card_tile";
+function decodeStars(value) {
+  if (!record(value)) return void 0;
+  const out = {};
+  for (const [instanceId, star] of Object.entries(value)) {
+    if (nonempty(instanceId) && record(star) && typeof star.starred === "boolean" && typeof star.updatedAt === "string")
+      out[instanceId] = {
+        starred: star.starred,
+        updatedAt: star.updatedAt,
+        ...typeof star.changedAt === "string" ? { changedAt: star.changedAt } : {}
+      };
+  }
+  return out;
+}
+function mergeStars(held, incoming) {
+  const out = { ...held ?? {} };
+  for (const [instanceId, next] of Object.entries(incoming)) {
+    const current = out[instanceId];
+    const keepCurrent = current?.changedAt !== void 0 && (next.changedAt === void 0 || current.changedAt > next.changedAt);
+    if (!keepCurrent) out[instanceId] = next;
+  }
+  return out;
+}
+var interactionOwners = /* @__PURE__ */ new WeakMap();
+function hostUiSubscription(value) {
+  return record(value) && typeof value.subscribeHostUi === "function";
+}
+function validSession(value) {
+  if (!record(value) || !nonempty(value.session_ref) || !(value.session_expires_at === null || value.session_expires_at === void 0 || typeof value.session_expires_at === "string" && Number.isFinite(Date.parse(value.session_expires_at))) || !(value.verified_templates === null || value.verified_templates === void 0 || record(value.verified_templates)))
+    return false;
+  const tiles = value.verified_templates?.tiles;
+  return tiles === void 0 || tiles === null || Array.isArray(tiles) && tiles.every((tile) => record(tile) && nonempty(tile.id) && nonempty(tile.widget));
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function nonempty(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function expiry(value) {
+  return value === null || typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function decodeAgentTurn(result) {
+  if (!record(result) || !record(result._meta)) return;
+  const payload = result._meta["syntro/agent-turn"];
+  if (!record(payload)) return;
+  if (payload.version !== 1 && payload.version !== 2) return;
+  const sessionRef = payload.sessionRef ?? payload.sessionId;
+  if (!nonempty(sessionRef) || !nonempty(payload.turnId) || !record(payload.uiTemplates) || !record(payload.snapshot))
+    return;
+  const snapshot = payload.snapshot;
+  if (snapshot.schema_version !== "v0" || !Array.isArray(snapshot.mounted_elements) || !expiry(snapshot.session_expires_at))
+    return;
+  const sessionExpiresAt = payload.sessionExpiresAt ?? snapshot.session_expires_at;
+  if (!expiry(sessionExpiresAt)) return;
+  const tiles = payload.uiTemplates.tiles;
+  if (tiles !== void 0 && (!Array.isArray(tiles) || tiles.some(
+    (template) => !record(template) || !nonempty(template.id) || !nonempty(template.widget)
+  )))
+    return;
+  const templates = createTemplateWidgetResolver();
+  templates.refresh(payload.uiTemplates);
+  for (const candidate of snapshot.mounted_elements) {
+    if (record(candidate) && candidate.element_type === "tile" && candidate.state === "active" && (!nonempty(candidate.template_id) || !templates.resolve(candidate.template_id)))
+      return;
+  }
+  const session = {
+    session_ref: sessionRef,
+    session_expires_at: sessionExpiresAt,
+    verified_templates: payload.uiTemplates
+  };
+  const frame = {
+    schema_version: "v1",
+    kind: "snapshot",
+    session_ref: sessionRef,
+    // The turn id IS the dedup id: the runtime commits one snapshot per
+    // accepted request and names it with that request's id.
+    result_id: payload.turnId,
+    session_expires_at: snapshot.session_expires_at,
+    mounted_elements: snapshot.mounted_elements
+  };
+  const issuedAt = typeof payload.issuedAt === "number" && Number.isFinite(payload.issuedAt) ? payload.issuedAt : void 0;
+  const stars = decodeStars(payload.stars);
+  return {
+    session,
+    frame,
+    ...issuedAt !== void 0 ? { issuedAt } : {},
+    ...stars ? { stars } : {}
+  };
+}
+function activateHostAgentController(runtime2, bridge, hostUi, options = {}) {
+  let controller = createElementSessionController(runtime2);
+  let disposed = false;
+  let pending = Promise.resolve();
+  let session;
+  let generation = 0;
+  const retiredScopes = /* @__PURE__ */ new Set();
+  let stopObserver;
+  let readRequested = false;
+  let applied = 0;
+  const cardId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+  let heartbeatKey;
+  let heartbeatTimer;
+  let popOutDecided = false;
+  let born;
+  let showingEarlyRead = false;
+  let answerIssuedAt;
+  let heartbeatSession;
+  let folded = false;
+  function hostSurface() {
+    try {
+      return runtime2.context?.get().surface ?? {};
+    } catch {
+      return {};
+    }
+  }
+  function readHeartbeat(key) {
+    try {
+      const raw = cardStorage()?.getItem(key);
+      if (!raw) return;
+      const parsed = JSON.parse(raw);
+      if (!record(parsed) || !nonempty(parsed.id) || typeof parsed.ts !== "number") return;
+      return {
+        id: parsed.id,
+        ts: parsed.ts,
+        mode: typeof parsed.mode === "string" ? parsed.mode : void 0,
+        born: typeof parsed.born === "number" ? parsed.born : void 0
+      };
+    } catch {
+      return;
+    }
+  }
+  function writeHeartbeat() {
+    if (!heartbeatKey) return;
+    try {
+      cardStorage()?.setItem(
+        heartbeatKey,
+        JSON.stringify({ id: cardId, ts: Date.now(), mode: hostSurface().displayMode, born })
+      );
+    } catch {
+    }
+    considerFold();
+  }
+  function considerFold() {
+    if (folded || disposed || !heartbeatSession || born === void 0) return;
+    const surface = hostSurface();
+    if (surface.type !== "mcp-app" || surface.displayMode !== "inline") return;
+    if (!surface.availableDisplayModes || popsOut(surface, heartbeatSession)) return;
+    const mine = born;
+    if (!freshSiblings(heartbeatSession).some((beat) => (beat.born ?? 0) > mine)) return;
+    folded = true;
+    runtime2.events.publish(CARD_SUPERSEDED, { superseded: true });
+  }
+  function pruneHeartbeats() {
+    try {
+      const store = cardStorage();
+      if (!store) return;
+      const stale = [];
+      for (let index = 0; index < store.length; index++) {
+        const key = store.key(index);
+        if (!key?.startsWith(CARD_HEARTBEAT_PREFIX) || key === heartbeatKey) continue;
+        const beat = readHeartbeat(key);
+        if (!beat || Date.now() - beat.ts > CARD_HEARTBEAT_STALE_MS) stale.push(key);
+      }
+      for (const key of stale) store.removeItem(key);
+    } catch {
+    }
+  }
+  const releaseHeartbeat = () => stopHeartbeat();
+  const onVisibilityChange = () => {
+    if (!heartbeatKey) return;
+    if (document.visibilityState === "hidden") {
+      if (heartbeatTimer !== void 0) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = void 0;
+      }
+      return;
+    }
+    if (heartbeatTimer !== void 0) return;
+    writeHeartbeat();
+    heartbeatTimer = setInterval(writeHeartbeat, CARD_HEARTBEAT_INTERVAL_MS);
+  };
+  let unsubscribeModeWatch;
+  function startHeartbeat(sessionRef) {
+    const key = heartbeatPrefix(sessionRef) + cardId;
+    if (heartbeatKey === key) return;
+    if (heartbeatKey) stopHeartbeat();
+    heartbeatKey = key;
+    heartbeatSession = sessionRef;
+    pruneHeartbeats();
+    writeHeartbeat();
+    heartbeatTimer = setInterval(writeHeartbeat, CARD_HEARTBEAT_INTERVAL_MS);
+    let heartbeatMode = hostSurface().displayMode;
+    try {
+      unsubscribeModeWatch = runtime2.context?.subscribe?.(() => {
+        const mode = hostSurface().displayMode;
+        if (mode === heartbeatMode) return;
+        if (heartbeatMode === "pip" && mode === "inline" && heartbeatSession)
+          rememberDocked(heartbeatSession);
+        heartbeatMode = mode;
+        writeHeartbeat();
+      });
+    } catch {
+    }
+    if (typeof window !== "undefined") {
+      window.addEventListener("pagehide", releaseHeartbeat);
+      window.addEventListener("beforeunload", releaseHeartbeat);
+    }
+    if (typeof document !== "undefined")
+      document.addEventListener("visibilitychange", onVisibilityChange);
+  }
+  function stopHeartbeat() {
+    if (heartbeatTimer !== void 0) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = void 0;
+    }
+    unsubscribeModeWatch?.();
+    unsubscribeModeWatch = void 0;
+    const key = heartbeatKey;
+    heartbeatKey = void 0;
+    if (typeof window !== "undefined") {
+      window.removeEventListener("pagehide", releaseHeartbeat);
+      window.removeEventListener("beforeunload", releaseHeartbeat);
+    }
+    if (typeof document !== "undefined")
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+    if (!key) return;
+    try {
+      cardStorage()?.removeItem(key);
+    } catch {
+    }
+  }
+  function freshSiblings(sessionRef) {
+    const siblings = [];
+    try {
+      const store = cardStorage();
+      if (!store) return siblings;
+      const prefix = heartbeatPrefix(sessionRef);
+      for (let index = 0; index < store.length; index++) {
+        const key = store.key(index);
+        if (!key?.startsWith(prefix)) continue;
+        const beat = readHeartbeat(key);
+        if (!beat || beat.id === cardId) continue;
+        if (Date.now() - beat.ts > CARD_SIBLING_WINDOW_MS) continue;
+        siblings.push(beat);
+      }
+    } catch {
+      return siblings;
+    }
+    return siblings;
+  }
+  function considerPopOut(sessionRef) {
+    if (popOutDecided) return;
+    popOutDecided = true;
+    const siblings = freshSiblings(sessionRef);
+    if (siblings.some((beat) => beat.mode !== "inline")) return;
+    const surface = hostSurface();
+    if (surface.type !== "mcp-app" || surface.displayMode !== "inline") return;
+    if (!popsOut(surface, sessionRef)) return;
+    runtime2.events.publish("canvas:request-display-mode", { mode: "pip" });
+  }
+  function popsOut(surface, sessionRef) {
+    if (!surface.availableDisplayModes?.includes("pip")) return false;
+    if (coarsePointer()) return false;
+    return !shopperDocked(sessionRef);
+  }
+  function shopperDocked(sessionRef) {
+    try {
+      const raw = cardStorage()?.getItem(DOCKED_PREFIX + sessionRef);
+      const at = raw ? Number(raw) : Number.NaN;
+      return Number.isFinite(at) && Date.now() - at < DOCKED_FOR_MS;
+    } catch {
+      return false;
+    }
+  }
+  function rememberDocked(sessionRef) {
+    try {
+      cardStorage()?.setItem(DOCKED_PREFIX + sessionRef, String(Date.now()));
+    } catch {
+    }
+  }
+  let interactiveState;
+  function interactive(value) {
+    if (disposed || interactiveState === value) return;
+    interactiveState = value;
+    hostUi?.setInteractive?.(value);
+    runtime2.events.publish("host.ui_state", { interactive: value });
+  }
+  function queue(operation) {
+    const expected = generation;
+    pending = pending.then(async () => {
+      if (!disposed && expected === generation) await operation();
+    }).catch(() => {
+      if (!disposed && expected === generation) {
+        interactive(false);
+        runtime2.events.publish("host.ui_error", { reason: "projection_failed" });
+      }
+    });
+  }
+  function scheduleHostRead(sessionRef, why = "reload") {
+    if (disposed || readRequested || typeof bridge.callServerTool !== "function") return;
+    const call = bridge.callServerTool.bind(bridge);
+    readRequested = true;
+    const expected = generation;
+    const readAgain = () => {
+      if (disposed || why !== "turn_started") return;
+      readRequested = false;
+      if (session) scheduleHostRead(session.session_ref);
+    };
+    void Promise.resolve().then(() => {
+      if (disposed) return;
+      if (expected !== generation) return readAgain();
+      queue(async () => {
+        const appliedAtIssue = applied;
+        reportCardStage("read_brand_view_called", { why });
+        void call({ name: READ_TOOL, arguments: { sessionRef } }).then((result) => {
+          reportReadAnswer(why, result);
+          if (disposed) return;
+          if (expected !== generation) return readAgain();
+          if (applied !== appliedAtIssue) {
+            reportCardStage("tool_result_rejected", { reason: "stale" });
+            return;
+          }
+          return consumeToolResult(result, { earlyRead: why === "turn_started" });
+        }).catch((error) => {
+          reportCardStage("read_brand_view_answered", {
+            why,
+            ok: false,
+            withAgentTurn: false,
+            // The host's own words for the refusal: a read that never
+            // reaches the connector leaves no other record of why.
+            reason: readFailureReason(error instanceof Error ? error.message : String(error))
+          });
+          if (why === "turn_started") return readAgain();
+          if (!disposed && expected === generation)
+            runtime2.events.publish("host.ui_error", { reason: "refresh_required" });
+        });
+      });
+    });
+  }
+  function reportReadAnswer(why, result) {
+    const failed = record(result) && result.isError === true;
+    const text = failed ? firstText(result) : void 0;
+    reportCardStage("read_brand_view_answered", {
+      why,
+      ok: !failed,
+      withAgentTurn: decodeAgentTurn(result) !== void 0,
+      ...text ? { reason: readFailureReason(text) } : {}
+    });
+  }
+  const missingAfterMs = options.missingResultMs ?? MISSING_RESULT_MS;
+  let missingTimer = setTimeout(
+    reportMissingResult,
+    missingAfterMs
+  );
+  function standDown() {
+    if (missingTimer !== void 0) clearTimeout(missingTimer);
+    missingTimer = void 0;
+  }
+  function reportMissingResult() {
+    missingTimer = void 0;
+    if (disposed) return;
+    reportCardStage("tool_result_missing", { afterMs: missingAfterMs });
+  }
+  function acceptHostUi2(payload) {
+    if (disposed || !record(payload)) return;
+    if (payload.kind === "session") {
+      if (!validSession(payload.session)) {
+        interactive(false);
+        runtime2.events.publish("host.ui_error", { reason: "invalid_session" });
+        return;
+      }
+      const next = payload.session;
+      standDown();
+      if (retiredScopes.has(next.session_ref)) return;
+      if (session && next.session_ref === session.session_ref) {
+        session = next;
+        controller.configureTemplates(next.verified_templates ?? void 0);
+        interactive(true);
+        return;
+      }
+      if (session) retiredScopes.add(session.session_ref);
+      generation++;
+      const shutdown = controller.dispose();
+      controller = createElementSessionController({
+        ...runtime2,
+        templates: next.verified_templates ?? void 0,
+        hostScope: { sessionRef: next.session_ref }
+      });
+      pending = shutdown;
+      session = next;
+      stopObserver ?? (stopObserver = wireObserver(runtime2));
+      interactive(true);
+      reportCardStage("session_bound", { sessionRef: next.session_ref });
+      scheduleHostRead(next.session_ref);
+      return;
+    }
+    if (payload.kind !== "frame") return;
+    const active = controller;
+    const frame = payload.frame;
+    queue(async () => {
+      const outcome = await active.acceptHostFrame(payload.frame);
+      if (active !== controller || disposed) return;
+      if (outcome.status === "rejected") {
+        reportCardStage("tool_result_rejected", { reason: outcome.reason });
+        if (outcome.reason === "projection_failed") interactive(false);
+        runtime2.events.publish("host.ui_error", { reason: outcome.reason });
+      } else if (outcome.status === "duplicate") {
+        reportCardStage("tool_result_rejected", {
+          reason: "duplicate",
+          turnId: outcome.resultId
+        });
+      } else if (outcome.status === "applied") {
+        applied++;
+        const tiles = (Array.isArray(frame?.mounted_elements) ? frame.mounted_elements : []).filter(
+          (element) => element.element_type === "tile" && element.state === "active"
+        );
+        reportCardStage("frame_applied", {
+          turnId: outcome.resultId,
+          tiles: tiles.length,
+          templateIds: [...new Set(tiles.map((element) => element.template_id))].filter((id) => typeof id === "string" && id.length > 0 && id.length <= 80).slice(0, 12)
+        });
+        runtime2.events.publish("host.frame_applied", {
+          result_id: outcome.resultId,
+          tiles: tiles.length
+        });
+        if (born === void 0 && tiles.length > 0 && !showingEarlyRead) {
+          born = answerIssuedAt ?? Date.now();
+          writeHeartbeat();
+        }
+        interactive(true);
+      }
+    });
+  }
+  async function consumeToolResult(result, { earlyRead = false } = {}) {
+    if (disposed) return;
+    const turn = decodeAgentTurn(result);
+    if (!turn) {
+      if (record(result) && record(result._meta) && AGENT_TURN_KEY in result._meta)
+        reportCardStage("tool_result_rejected", { reason: "decode_failed" });
+      return;
+    }
+    showingEarlyRead = earlyRead;
+    if (!earlyRead) {
+      answerIssuedAt ?? (answerIssuedAt = turn.issuedAt ?? Date.now());
+      considerPopOut(turn.session.session_ref);
+    }
+    acceptHostUi2({ kind: "session", session: turn.session });
+    acceptHostUi2({ kind: "frame", frame: turn.frame });
+    startHeartbeat(turn.session.session_ref);
+    boundSessionRef = turn.session.session_ref;
+    if (turn.stars) {
+      knownStars = mergeStars(knownStars, turn.stars);
+      publishStars();
+    }
+  }
+  let boundSessionRef;
+  let knownStars;
+  function publishStars() {
+    if (disposed || !knownStars) return;
+    runtime2.events.publish("host.stars", { stars: { ...knownStars } });
+  }
+  async function requestStar(props) {
+    const instanceId = props?.instanceId;
+    const starred = props?.starred;
+    if (!nonempty(instanceId) || typeof starred !== "boolean") return;
+    const failed = () => {
+      if (!disposed) runtime2.events.publish("host.star_failed", { instanceId });
+    };
+    if (!boundSessionRef || typeof bridge.callServerTool !== "function") return failed();
+    let result;
+    try {
+      result = await bridge.callServerTool({
+        name: STAR_TOOL,
+        arguments: { sessionRef: boundSessionRef, instanceId, starred }
+      });
+    } catch {
+      return failed();
+    }
+    const stored = record(result) && !result.isError ? result.structuredContent : void 0;
+    if (!record(stored) || stored.instanceId !== instanceId || typeof stored.starred !== "boolean" || typeof stored.updatedAt !== "string")
+      return failed();
+    knownStars = mergeStars(knownStars, {
+      [instanceId]: {
+        starred: stored.starred,
+        updatedAt: stored.updatedAt,
+        ...typeof stored.changedAt === "string" ? { changedAt: stored.changedAt } : {}
+      }
+    });
+    publishStars();
+  }
+  const stopStarRequests = runtime2.events.subscribe?.(
+    { names: ["canvas:star-request", "canvas:stars-request"] },
+    (event) => {
+      if (disposed) return;
+      if (event.name === "canvas:stars-request") publishStars();
+      else void requestStar(event.props);
+    }
+  );
+  const deliver = (result) => {
+    standDown();
+    void consumeToolResult(result);
+  };
+  const stopActivity = bridge.subscribeToolActivity?.(standDown);
+  let turnPending;
+  let pendingTimer;
+  function publishTurnPending(value) {
+    if (disposed || turnPending === value) return;
+    turnPending = value;
+    if (pendingTimer !== void 0) clearTimeout(pendingTimer);
+    pendingTimer = value ? setTimeout(() => publishTurnPending(false), PENDING_MAX_MS) : void 0;
+    runtime2.events.publish("host.turn_pending", { pending: value });
+  }
+  const stopPendingRequests = runtime2.events.subscribe?.(
+    { names: ["canvas:turn-pending-request"] },
+    () => {
+      if (!disposed && turnPending !== void 0)
+        runtime2.events.publish("host.turn_pending", { pending: turnPending });
+    }
+  );
+  const stopToolCall = bridge.subscribeToolCall?.((call) => {
+    if (disposed) return;
+    if (call.phase === "input") {
+      publishTurnPending(true);
+      const sessionRef = call.arguments.sessionRef;
+      if (nonempty(sessionRef) && !session) scheduleHostRead(sessionRef, "turn_started");
+      return;
+    }
+    void Promise.resolve().then(() => queue(async () => publishTurnPending(false)));
+  });
+  const unsubscribe = bridge.subscribeToolResults(deliver, {
+    metadataKey: AGENT_TURN_KEY
+  });
+  return {
+    acceptHostUi: acceptHostUi2,
+    consumeToolResult,
+    whenIdle: async () => {
+      await pending;
+      await controller.whenIdle();
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      generation++;
+      if (missingTimer !== void 0) clearTimeout(missingTimer);
+      missingTimer = void 0;
+      stopActivity?.();
+      stopToolCall?.();
+      stopPendingRequests?.();
+      if (pendingTimer !== void 0) clearTimeout(pendingTimer);
+      stopStarRequests?.();
+      stopHeartbeat();
+      stopObserver?.();
+      stopObserver = void 0;
+      unsubscribe();
+      void controller.dispose();
+    }
+  };
+}
+var READ_REASON_MAX = 120;
+function readFailureReason(text) {
+  const flat = text.replace(/\s+/g, " ").replace(/[A-Za-z0-9_\-+/=]{24,}/g, "[id]").trim();
+  return flat.length > READ_REASON_MAX ? `${flat.slice(0, READ_REASON_MAX - 1)}~` : flat || "unknown";
+}
+function firstText(result) {
+  if (!Array.isArray(result.content)) return void 0;
+  for (const block of result.content) {
+    if (record(block) && block.type === "text" && typeof block.text === "string") return block.text;
+  }
+  return void 0;
+}
+function activateHostAgent(runtime2) {
+  if (!record(runtime2) || !record(runtime2.context) || typeof runtime2.context.get !== "function")
+    return;
+  const context = runtime2.context.get();
+  if (!record(context) || !record(context.surface) || context.surface.type !== "mcp-app") return;
+  if (!record(runtime2.actions) || typeof runtime2.actions.apply !== "function" || typeof runtime2.actions.applyBatch !== "function" || !record(runtime2.events) || typeof runtime2.events.publish !== "function" || typeof window === "undefined")
+    return;
+  const host = window.MCPApp?.bridge;
+  if (typeof host?.subscribeToolResults !== "function") return;
+  const receiver = hostUiSubscription(runtime2.hostUi) ? runtime2.hostUi : void 0;
+  const interactionOwner = /* @__PURE__ */ Symbol("host-view");
+  let interactionCanvas = null;
+  let previousInert = false;
+  let previousDisabled = null;
+  const controller = activateHostAgentController(
+    runtime2,
+    host,
+    receiver ? {
+      setInteractive: (value) => {
+        const canvas = findSmartCanvas();
+        if (!canvas) return;
+        if (interactionCanvas !== canvas) {
+          interactionCanvas = canvas;
+          const previous = interactionOwners.get(canvas);
+          previousInert = previous ? previous.inert : canvas.inert;
+          previousDisabled = previous ? previous.disabled : canvas.getAttribute("aria-disabled");
+          interactionOwners.set(canvas, {
+            owner: interactionOwner,
+            inert: previousInert,
+            disabled: previousDisabled
+          });
+        }
+        if (interactionOwners.get(canvas)?.owner !== interactionOwner) return;
+        canvas.inert = !value || previousInert;
+        canvas.setAttribute("aria-disabled", value ? previousDisabled ?? "false" : "true");
+      }
+    } : void 0
+  );
+  const unsubscribe = receiver?.subscribeHostUi(controller.acceptHostUi);
+  return () => {
+    unsubscribe?.();
+    controller.dispose();
+    if (interactionCanvas && interactionOwners.get(interactionCanvas)?.owner === interactionOwner) {
+      interactionCanvas.inert = previousInert;
+      if (previousDisabled === null) interactionCanvas.removeAttribute("aria-disabled");
+      else interactionCanvas.setAttribute("aria-disabled", previousDisabled);
+      interactionOwners.delete(interactionCanvas);
+    }
+  };
+}
+function acceptHostUi(runtime2, payload) {
+  runtime2.acceptHostUi?.(payload);
+}
+
 // src/NavLinkMountable.ts
 var STATE_KEY3 = "__syntroNavLinkMount";
 var SAFE_NAVIGATION_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
@@ -3656,6 +4314,8 @@ var runtime = {
   name: "Chat Assistant",
   description: "AI chat assistant powered by @syntrologie/chat with SSE transport",
   executors: [],
+  onActivate: activateHostAgent,
+  acceptHostUi,
   widgets: [
     {
       id: "adaptive-chatbot:assistant",