@syntrologie/adapt-chatbot 2.55.1 → 2.57.0

package/dist/chunk-VIRIVP7H.js

@@ -0,0 +1,898 @@
+import {
+  TILE_MOUNTED_EVENT,
+  TILE_PATCHED_EVENT,
+  TILE_REPLAY_REQUEST_EVENT,
+  TILE_UNMOUNTED_EVENT,
+  parseTileLayout
+} from "./chunk-4V5L7IRV.js";
+
+// src/elements/tileLifecycleProps.ts
+function tileMountProps(instance2, widget) {
+  const layout = parseTileLayout(instance2.layout);
+  return {
+    slot: instance2.placement.slot,
+    instance_id: instance2.instance_id,
+    widget,
+    props: instance2.content ?? {},
+    ...layout ? { layout } : {}
+  };
+}
+
+// src/elements/ElementInstanceStore.ts
+var COMPOSITIONAL_REPLAY_REQUEST_EVENT = "element.compositional_replay_request";
+var COMPOSITIONAL_APPEND_EVENT = "element.compositional_append";
+var CHAT_INLINE_SLOT = "chat-inline";
+function firstText(...candidates) {
+  for (const c of candidates) if (typeof c === "string" && c.trim()) return c.trim();
+  return void 0;
+}
+function receiptTitle(raw) {
+  const c = raw ?? {};
+  const list = (v) => Array.isArray(v) ? v : [];
+  return firstText(
+    c.product?.name,
+    c.title,
+    c.heading,
+    ...list(c.questions).map((q) => q?.question),
+    ...list(c.actions).map((a) => a?.config?.question),
+    setTitle(list(c.products), " vs "),
+    setTitle(list(c.items), null)
+  ) ?? "Details";
+}
+function setTitle(entries, pair) {
+  const names = entries.map((e) => e?.name).filter((n) => typeof n === "string" && n.trim().length > 0).map((n) => n.trim());
+  if (names.length === 0) return void 0;
+  if (names.length === 1) return names[0];
+  if (names.length === 2 && pair) return `${names[0]}${pair}${names[1]}`;
+  return `${names[0]} + ${names.length - 1} more`;
+}
+var ElementInstanceStore = class {
+  constructor(options) {
+    this._instances = /* @__PURE__ */ new Map();
+    /** Active TTL timeout — replaced on each call to `scheduleClientTtl`. */
+    this._ttlTimer = null;
+    this._disposed = false;
+    this._disposing = false;
+    /** Instance IDs the client has dismissed. Persists across canvas remounts
+     *  so a dismissed tile never silently reappears on replay/broadcast. */
+    this._dismissedIds = /* @__PURE__ */ new Set();
+    this._actions = options.actions;
+    this._events = options.events;
+    this._resolveTileWidget = options.resolveTileWidget;
+    this._handlers = /* @__PURE__ */ new Map();
+    for (const handler of options.handlers ?? []) {
+      this._handlers.set(handler.typeName, handler);
+    }
+    this._logger = options.logger ?? console;
+    this._subscribeReplayRequests();
+  }
+  /**
+   * Listen for `element.compositional_replay_request` from container
+   * widgets and re-publish `element.compositional_append` for every
+   * matching item still tracked in `_instances`. This keeps LLM-authored
+   * items visible across SPA navigations: the store is a module-level
+   * singleton that survives chat-bar unmount/remount, so when a fresh
+   * chips-strip mounts and subscribes, asking for a replay re-populates
+   * its chip array.
+   */
+  _subscribeReplayRequests() {
+    const subscribe = this._events?.subscribe;
+    const publish = this._events?.publish;
+    if (!subscribe || !publish) return;
+    this._unsubscribeReplay = subscribe(
+      {
+        names: [
+          COMPOSITIONAL_REPLAY_REQUEST_EVENT,
+          TILE_REPLAY_REQUEST_EVENT,
+          TILE_UNMOUNTED_EVENT
+        ]
+      },
+      (event) => {
+        if (this._disposed) return;
+        if (event.name === TILE_UNMOUNTED_EVENT) {
+          const id = String(event.props?.instance_id ?? "");
+          if (id) this._dismissedIds.add(id);
+          return;
+        }
+        if (event.name === COMPOSITIONAL_REPLAY_REQUEST_EVENT) {
+          const tileId = String(event.props?.tile_id ?? "");
+          if (!tileId) return;
+          this._replayItems(tileId, publish);
+          return;
+        }
+        if (event.name === TILE_REPLAY_REQUEST_EVENT) {
+          this._replayTiles(publish);
+          return;
+        }
+      }
+    );
+  }
+  _replayItems(tileId, publish) {
+    for (const instance2 of this._instances.values()) {
+      if (this._disposed) return;
+      if (instance2.element_type !== "item") continue;
+      if (instance2.placement.type !== "parent_tile") continue;
+      if (instance2.placement.tile_id !== tileId) continue;
+      if (instance2.state !== "active") continue;
+      publish(COMPOSITIONAL_APPEND_EVENT, {
+        tile_id: tileId,
+        instance_id: instance2.instance_id,
+        item: instance2.content,
+        position: instance2.placement.position
+      });
+    }
+  }
+  _replayTiles(publish) {
+    for (const instance2 of this._instances.values()) {
+      if (this._disposed) return;
+      if (instance2.element_type !== "tile") continue;
+      if (instance2.placement.type !== "slot") continue;
+      if (instance2.state !== "active") continue;
+      if (this._dismissedIds.has(instance2.instance_id)) continue;
+      const props = tileMountProps(
+        { ...instance2, placement: instance2.placement },
+        this._resolveTileWidget?.(instance2.template_id) ?? instance2.template_id
+      );
+      publish(TILE_MOUNTED_EVENT, props);
+    }
+  }
+  registerHandler(handler) {
+    this._handlers.set(handler.typeName, handler);
+  }
+  isDismissed(instanceId) {
+    return this._dismissedIds.has(instanceId);
+  }
+  getDismissedIds() {
+    return this._dismissedIds;
+  }
+  /** Store-driven receipt source for the chat trail (one per active slot-tile). */
+  listTileReceipts() {
+    const out = [];
+    for (const inst of this._instances.values()) {
+      if (inst.element_type !== "tile" || inst.placement.type !== "slot") continue;
+      if (inst.state !== "active") continue;
+      if (inst.placement.slot === CHAT_INLINE_SLOT) continue;
+      const title = receiptTitle(inst.content);
+      const imgContent = inst.content;
+      const imageCandidate = imgContent?.product?.image?.src ?? imgContent?.items?.[0]?.image_url ?? imgContent?.products?.[0]?.image?.src;
+      const imageUrl = typeof imageCandidate === "string" && imageCandidate.trim() ? imageCandidate : void 0;
+      if (inst.placement.slot === "alert") {
+        out.push({
+          kind: "alert",
+          instanceId: inst.instance_id,
+          title,
+          turnId: inst.mounted_by?.turn_id,
+          toolCallId: inst.tool_call_id ?? void 0
+        });
+      } else {
+        out.push({
+          kind: "tile",
+          instanceId: inst.instance_id,
+          title,
+          dismissed: this._dismissedIds.has(inst.instance_id),
+          turnId: inst.mounted_by?.turn_id,
+          toolCallId: inst.tool_call_id ?? void 0,
+          ...imageUrl ? { imageUrl } : {}
+        });
+      }
+    }
+    return out;
+  }
+  /**
+   * Store-driven inline-widget source for the chat trail — one entry per
+   * active `chat-inline` slot-tile. The trail mounts each entry's widget
+   * element (by tag name, via `document.createElement`) inline in the
+   * conversation flow. Distinct from {@link listTileReceipts}: those are
+   * chips that recall a deck tile; these ARE the rendered widget.
+   */
+  listInlineWidgets() {
+    const out = [];
+    for (const inst of this._instances.values()) {
+      if (inst.element_type !== "tile" || inst.placement.type !== "slot") continue;
+      if (inst.placement.slot !== CHAT_INLINE_SLOT) continue;
+      if (inst.state !== "active") continue;
+      if (this._dismissedIds.has(inst.instance_id)) continue;
+      out.push({
+        instanceId: inst.instance_id,
+        tag: this._resolveTileWidget?.(inst.template_id) ?? inst.template_id,
+        props: inst.content ?? {},
+        turnId: inst.mounted_by?.turn_id,
+        toolCallId: inst.tool_call_id ?? void 0
+      });
+    }
+    return out;
+  }
+  /** Clear a client dismissal and re-publish the tile's mount from retained content. */
+  recreate(instanceId) {
+    if (this._disposed) return;
+    const instance2 = this._instances.get(instanceId);
+    const publish = this._events?.publish;
+    if (!instance2 || instance2.element_type !== "tile" || instance2.placement.type !== "slot" || !publish) {
+      return;
+    }
+    this._dismissedIds.delete(instanceId);
+    const props = tileMountProps(
+      { ...instance2, placement: instance2.placement },
+      this._resolveTileWidget?.(instance2.template_id) ?? instance2.template_id
+    );
+    publish(TILE_MOUNTED_EVENT, props);
+  }
+  /**
+   * Apply the server-provided boot snapshot. For each instance:
+   *   - stateful: validated + mounted via the type handler;
+   *   - imperative + already-applied: recorded only (no DOM action);
+   *   - any: tracked in the in-memory map for future patches.
+   *
+   * Safe to call once on SDK init. Calling again would re-mount
+   * stateful instances; callers should not.
+   */
+  async hydrate(snapshot) {
+    await this._hydrateWithReport(snapshot);
+  }
+  async _hydrateWithReport(snapshot, reconcile = false) {
+    const rejectedInstanceIds = [];
+    for (const instance2 of snapshot) {
+      if (this._disposed) return { ok: false, rejectedInstanceIds };
+      const existing = this._instances.get(instance2.instance_id);
+      if (existing && (existing.version > instance2.version || existing.version === instance2.version && (!reconcile || existing.state === instance2.state))) {
+        continue;
+      }
+      if (reconcile && existing?.state !== "active")
+        this._dismissedIds.delete(instance2.instance_id);
+      const handler = this._handlers.get(instance2.element_type);
+      if (!handler) {
+        rejectedInstanceIds.push(instance2.instance_id);
+        this._logger.warn("elements: hydrate skipped \u2014 unknown element_type", {
+          element_type: instance2.element_type,
+          instance_id: instance2.instance_id
+        });
+        continue;
+      }
+      this._instances.set(instance2.instance_id, instance2);
+      if (handler.lifecycle === "imperative") {
+        continue;
+      }
+      if (instance2.state !== "active") {
+        continue;
+      }
+      if (!await this._mount(handler, instance2)) {
+        rejectedInstanceIds.push(instance2.instance_id);
+        if (!this._disposed) {
+          if (existing) this._instances.set(instance2.instance_id, existing);
+          else this._instances.delete(instance2.instance_id);
+        }
+      }
+    }
+    this._broadcastActive();
+    return { ok: !this._disposed && rejectedInstanceIds.length === 0, rejectedInstanceIds };
+  }
+  /**
+   * Re-publish `element.tile_mounted` / `element.compositional_append`
+   * for every active LLM-authored instance in the store. Idempotent —
+   * receivers key by `instance_id` (tiles) or by widget identity
+   * (items via tile_id filter).
+   */
+  _broadcastActive() {
+    if (this._disposed) return;
+    const publish = this._events?.publish;
+    if (!publish) return;
+    this._replayTiles(publish);
+    const itemTileIds = /* @__PURE__ */ new Set();
+    for (const instance2 of this._instances.values()) {
+      if (instance2.element_type !== "item") continue;
+      if (instance2.placement.type !== "parent_tile") continue;
+      if (instance2.state !== "active") continue;
+      itemTileIds.add(instance2.placement.tile_id);
+    }
+    for (const tileId of itemTileIds) {
+      this._replayItems(tileId, publish);
+    }
+  }
+  /**
+   * Apply a batch of mutations, atomically per-batch. Each mutation is
+   * version-checked (mount: must not conflict with existing instance;
+   * patch: resulting_version must be > current; unmount: idempotent).
+   */
+  async apply(mutations) {
+    await this.applyWithReport(mutations);
+  }
+  async applyWithReport(mutations) {
+    return this._applyWithReport(mutations, false);
+  }
+  async _applyWithReport(mutations, authoritative) {
+    const rejectedInstanceIds = [];
+    for (const mutation of mutations) {
+      if (this._disposed) return { ok: false, rejectedInstanceIds };
+      const id = (mutation?.op === "mount" ? mutation.instance?.instance_id : mutation?.instance_id) ?? "<invalid>";
+      try {
+        if (!await this._applyOne(mutation, authoritative)) rejectedInstanceIds.push(id);
+      } catch {
+        rejectedInstanceIds.push(id);
+        this._logger.error("elements: mutation failed", { instance_id: id });
+      }
+    }
+    return { ok: !this._disposed && rejectedInstanceIds.length === 0, rejectedInstanceIds };
+  }
+  /** Read-only snapshot of currently-known instances. */
+  getInstances() {
+    return Array.from(this._instances.values());
+  }
+  getInstance(instance_id) {
+    return this._instances.get(instance_id);
+  }
+  /** Replace a host-provided complete UI snapshot; never replay imperative actions. */
+  async reconcileSnapshot(snapshot) {
+    const rejected = /* @__PURE__ */ new Set();
+    if (this._disposed) return { ok: false, rejectedInstanceIds: [] };
+    const active = snapshot.filter(
+      (instance2) => instance2.state === "active" && instance2.element_type !== "action"
+    );
+    const ids = new Set(active.map((instance2) => instance2.instance_id));
+    for (const instance2 of this._instances.values()) {
+      if (this._disposed) return { ok: false, rejectedInstanceIds: [...rejected] };
+      if (ids.has(instance2.instance_id)) continue;
+      if (instance2.state === "active") {
+        const report2 = await this.applyWithReport([
+          { op: "unmount", instance_id: instance2.instance_id }
+        ]);
+        if (!report2.ok) {
+          rejected.add(instance2.instance_id);
+          continue;
+        }
+      }
+      if (this._disposed) return { ok: false, rejectedInstanceIds: [...rejected] };
+      this._instances.delete(instance2.instance_id);
+      this._dismissedIds.delete(instance2.instance_id);
+    }
+    for (const instance2 of active) {
+      if (this._disposed) return { ok: false, rejectedInstanceIds: [...rejected] };
+      const existing = this._instances.get(instance2.instance_id);
+      if (!existing || existing.state !== "active" || existing.version === instance2.version)
+        continue;
+      const report2 = await this._applyWithReport(
+        [
+          {
+            op: "patch",
+            instance_id: instance2.instance_id,
+            patches: [],
+            expected_version: existing.version,
+            resulting_version: instance2.version,
+            resulting_content: instance2.content
+          }
+        ],
+        true
+      );
+      for (const id of report2.rejectedInstanceIds) rejected.add(id);
+    }
+    const report = await this._hydrateWithReport(
+      active.filter((instance2) => !rejected.has(instance2.instance_id)),
+      true
+    );
+    for (const id of report.rejectedInstanceIds) rejected.add(id);
+    return { ok: report.ok && rejected.size === 0, rejectedInstanceIds: [...rejected] };
+  }
+  /** Release page-lifetime listeners and timers; queued work becomes inert. */
+  dispose(unmount = false) {
+    if (this._disposed || this._disposing) return;
+    this._disposing = true;
+    if (unmount) {
+      for (const instance2 of this._instances.values()) {
+        const handler = this._handlers.get(instance2.element_type);
+        if (instance2.state === "active" && handler?.lifecycle !== "imperative") {
+          void handler?.unmount(instance2, this._ctx()).catch(() => {
+          });
+        }
+      }
+    }
+    this._disposed = true;
+    this._disposing = false;
+    this._unsubscribeReplay?.();
+    this._unsubscribeReplay = void 0;
+    if (this._ttlTimer !== null) clearTimeout(this._ttlTimer);
+    this._ttlTimer = null;
+    this._instances.clear();
+    this._dismissedIds.clear();
+  }
+  /**
+   * Schedule a client-side TTL that unmounts every active stateful
+   * instance when the server-side session expires. Replaces any
+   * previously-scheduled TTL.
+   *
+   * Avoids the orphan-window where session-expired tiles linger on the
+   * page until manual refresh — the server forgets at the 24h mark and
+   * the SDK tears down concurrently. Re-schedule on each boot fetch /
+   * mutation event that carries a refreshed `session_expires_at`.
+   *
+   * Pass `null` to clear the existing timer without scheduling a new one.
+   * Pass a past timestamp to trigger cleanup immediately.
+   */
+  scheduleClientTtl(session_expires_at) {
+    if (this._disposed) return;
+    if (this._ttlTimer !== null) {
+      clearTimeout(this._ttlTimer);
+      this._ttlTimer = null;
+    }
+    if (session_expires_at === null) return;
+    const expiryMs = Date.parse(session_expires_at);
+    if (Number.isNaN(expiryMs)) {
+      this._logger.warn("elements: invalid session_expires_at", { session_expires_at });
+      return;
+    }
+    const delay = Math.max(0, expiryMs - Date.now());
+    this._ttlTimer = setTimeout(() => {
+      this._ttlTimer = null;
+      void this._handleSessionExpiry();
+    }, delay);
+  }
+  // -------------------------------------------------------------------
+  // Internals
+  // -------------------------------------------------------------------
+  async _handleSessionExpiry() {
+    const unmounts = [];
+    for (const instance2 of this._instances.values()) {
+      if (instance2.state !== "active") continue;
+      const handler = this._handlers.get(instance2.element_type);
+      if (!handler || handler.lifecycle === "imperative") continue;
+      unmounts.push({ op: "unmount", instance_id: instance2.instance_id });
+    }
+    if (unmounts.length > 0) {
+      this._logger.info("elements: client TTL fired \u2014 unmounting active instances", {
+        count: unmounts.length
+      });
+      await this.apply(unmounts);
+    }
+  }
+  async _applyOne(mutation, authoritative = false) {
+    if (mutation.op === "mount") {
+      const existing = this._instances.get(mutation.instance.instance_id);
+      if (existing && existing.version >= mutation.instance.version) {
+        return true;
+      }
+      const handler = this._handlers.get(mutation.instance.element_type);
+      if (!handler) {
+        this._logger.warn("elements: mount dropped \u2014 unknown element_type", {
+          element_type: mutation.instance.element_type
+        });
+        return false;
+      }
+      const isActiveStateful = mutation.instance.state === "active" && handler.lifecycle !== "imperative";
+      const isAppliedImperative = mutation.instance.state === "applied" && handler.lifecycle === "imperative";
+      if (isActiveStateful || isAppliedImperative) {
+        this._instances.set(mutation.instance.instance_id, mutation.instance);
+        const applied = await this._mount(handler, mutation.instance);
+        if (this._disposed) return false;
+        if (!applied) {
+          if (existing) {
+            this._instances.set(mutation.instance.instance_id, existing);
+          } else {
+            this._instances.delete(mutation.instance.instance_id);
+          }
+        }
+        return applied;
+      }
+      this._instances.set(mutation.instance.instance_id, mutation.instance);
+      return true;
+    }
+    if (mutation.op === "patch") {
+      const existing = this._instances.get(mutation.instance_id);
+      if (!existing) {
+        this._logger.warn("elements: patch dropped \u2014 unknown instance", {
+          instance_id: mutation.instance_id
+        });
+        return false;
+      }
+      if (typeof mutation.resulting_version !== "number" || mutation.resulting_content == null || typeof mutation.resulting_content !== "object") {
+        this._logger.warn("elements: patch dropped \u2014 malformed envelope (missing resulting_*)", {
+          instance_id: mutation.instance_id
+        });
+        return false;
+      }
+      if (!authoritative && mutation.resulting_version <= existing.version) {
+        return true;
+      }
+      const patched = {
+        ...existing,
+        content: mutation.resulting_content,
+        version: mutation.resulting_version
+      };
+      const handler = this._handlers.get(patched.element_type);
+      if (handler) {
+        const validation = handler.validate(patched, this._ctx());
+        if (!validation.accepted) {
+          this._logger.warn("elements: patch validation failed", {
+            instance_id: mutation.instance_id,
+            reason: validation.reason
+          });
+          return false;
+        }
+        try {
+          await handler.patch(patched, this._ctx());
+        } catch (err) {
+          this._logger.warn("elements: handler.patch threw", {
+            instance_id: mutation.instance_id,
+            err
+          });
+          return false;
+        }
+      }
+      if (this._disposed) return false;
+      this._instances.set(mutation.instance_id, patched);
+      return true;
+    }
+    if (mutation.op === "unmount") {
+      const existing = this._instances.get(mutation.instance_id);
+      if (!existing) {
+        return true;
+      }
+      const reverted = { ...existing, state: "reverted" };
+      this._instances.set(mutation.instance_id, reverted);
+      const handler = this._handlers.get(existing.element_type);
+      if (handler) {
+        try {
+          await handler.unmount(reverted, this._ctx());
+        } catch (err) {
+          if (!this._disposed) this._instances.set(mutation.instance_id, existing);
+          this._logger.warn("elements: handler.unmount threw", {
+            instance_id: mutation.instance_id,
+            err
+          });
+          return false;
+        }
+      }
+      return !this._disposed;
+    }
+    return false;
+  }
+  async _mount(handler, instance2) {
+    try {
+      const validation = handler.validate(instance2, this._ctx());
+      if (!validation.accepted) {
+        this._logger.warn("elements: mount validation failed", {
+          instance_id: instance2.instance_id,
+          reason: validation.reason,
+          detail: validation.detail
+        });
+        return false;
+      }
+      await handler.mount(instance2, this._ctx());
+    } catch (err) {
+      this._logger.warn("elements: handler.mount threw", {
+        instance_id: instance2.instance_id,
+        err
+      });
+      return false;
+    }
+    return !this._disposed;
+  }
+  _ctx() {
+    return {
+      actions: this._actions,
+      events: this._events && {
+        publish: (name, props) => {
+          if (!this._disposed) this._events?.publish(name, props);
+        }
+      }
+    };
+  }
+};
+
+// src/elements/TileHandler.ts
+var TileHandler = class {
+  constructor(resolveWidget) {
+    this.resolveWidget = resolveWidget;
+    this.typeName = "tile";
+    this.lifecycle = "stateful";
+  }
+  _widgetFor(instance2) {
+    return this.resolveWidget?.(instance2.template_id) ?? instance2.template_id;
+  }
+  validate(instance2, _ctx) {
+    if (instance2.element_type !== "tile") {
+      return { accepted: false, reason: "wrong_element_type", detail: instance2.element_type };
+    }
+    if (instance2.placement.type !== "slot") {
+      return {
+        accepted: false,
+        reason: "tile_requires_slot_placement",
+        detail: `got placement.type=${instance2.placement.type}`
+      };
+    }
+    if (typeof instance2.template_id !== "string" || instance2.template_id.length === 0) {
+      return { accepted: false, reason: "missing_template_id" };
+    }
+    if (this.resolveWidget && this.resolveWidget(instance2.template_id) === void 0) {
+      return { accepted: false, reason: "unknown_template_id", detail: instance2.template_id };
+    }
+    return { accepted: true };
+  }
+  async mount(instance2, ctx) {
+    if (!ctx.events) return;
+    const placement = instance2.placement;
+    const props = tileMountProps({ ...instance2, placement }, this._widgetFor(instance2));
+    ctx.events.publish(TILE_MOUNTED_EVENT, props);
+  }
+  async patch(instance2, ctx) {
+    if (!ctx.events) return;
+    const placement = instance2.placement;
+    const props = tileMountProps({ ...instance2, placement }, this._widgetFor(instance2));
+    ctx.events.publish(TILE_PATCHED_EVENT, props);
+  }
+  async unmount(instance2, ctx) {
+    if (!ctx.events) return;
+    const placement = instance2.placement;
+    const props = {
+      slot: placement.slot,
+      instance_id: instance2.instance_id
+    };
+    ctx.events.publish(TILE_UNMOUNTED_EVENT, props);
+  }
+};
+
+// src/elements/ActionHandler.ts
+var ActionHandler = class {
+  constructor() {
+    this.typeName = "action";
+    // v1: only imperative actions are wired. Stateful content-mutation
+    // actions arrive with Phase 7 (Portable Text renderer).
+    this.lifecycle = "imperative";
+  }
+  validate(instance2, _ctx) {
+    if (instance2.element_type !== "action") {
+      return { accepted: false, reason: "wrong_element_type" };
+    }
+    const kind = instance2.content.__kind;
+    if (typeof kind !== "string" || kind.length === 0) {
+      return { accepted: false, reason: "missing_action_kind" };
+    }
+    return { accepted: true };
+  }
+  async mount(instance2, ctx) {
+    const action = this._actionFromInstance(instance2);
+    await ctx.actions.applyBatch([action]);
+  }
+  async patch(_instance, _ctx) {
+  }
+  async unmount(_instance, _ctx) {
+  }
+  _actionFromInstance(instance2) {
+    const { __kind, ...params } = instance2.content;
+    const placement = instance2.placement;
+    const anchorOverride = placement.type === "selector" ? { anchorId: { selector: placement.selector, route: "**" } } : {};
+    if (typeof params.anchorId === "string") {
+      params.anchorId = { selector: params.anchorId, route: "**" };
+    }
+    return {
+      kind: __kind,
+      ...params,
+      ...anchorOverride,
+      label: `action:${instance2.template_id}:${instance2.instance_id}`
+    };
+  }
+};
+
+// src/elements/ItemHandler.ts
+var COMPOSITIONAL_APPEND_EVENT2 = "element.compositional_append";
+var COMPOSITIONAL_PATCH_EVENT = "element.compositional_patch";
+var COMPOSITIONAL_REMOVE_EVENT = "element.compositional_remove";
+var ItemHandler = class {
+  constructor() {
+    this.typeName = "item";
+    this.lifecycle = "stateful";
+  }
+  validate(instance2, _ctx) {
+    if (instance2.element_type !== "item") {
+      return {
+        accepted: false,
+        reason: "wrong_element_type",
+        detail: instance2.element_type
+      };
+    }
+    if (instance2.placement.type !== "parent_tile") {
+      return {
+        accepted: false,
+        reason: "item_requires_parent_tile_placement",
+        detail: `got placement.type=${instance2.placement.type}`
+      };
+    }
+    if (typeof instance2.template_id !== "string" || instance2.template_id.length === 0) {
+      return { accepted: false, reason: "missing_template_id" };
+    }
+    return { accepted: true };
+  }
+  async mount(instance2, ctx) {
+    if (!ctx.events) return;
+    const placement = instance2.placement;
+    ctx.events.publish(COMPOSITIONAL_APPEND_EVENT2, {
+      tile_id: placement.tile_id,
+      instance_id: instance2.instance_id,
+      item: instance2.content,
+      position: placement.position
+    });
+  }
+  async patch(instance2, ctx) {
+    if (!ctx.events) return;
+    const placement = instance2.placement;
+    ctx.events.publish(COMPOSITIONAL_PATCH_EVENT, {
+      tile_id: placement.tile_id,
+      instance_id: instance2.instance_id,
+      item: instance2.content
+    });
+  }
+  async unmount(instance2, ctx) {
+    if (!ctx.events) return;
+    const placement = instance2.placement;
+    ctx.events.publish(COMPOSITIONAL_REMOVE_EVENT, {
+      tile_id: placement.tile_id,
+      instance_id: instance2.instance_id
+    });
+  }
+};
+
+// src/elements/createElementStore.ts
+function createTemplateWidgetResolver() {
+  const widgets = /* @__PURE__ */ new Map();
+  return {
+    resolve: (templateId) => widgets.get(templateId),
+    refresh(uiTemplates) {
+      widgets.clear();
+      widgets.set("syntro-product-reco-carousel", "syntro-product-reco-carousel");
+      const tiles = uiTemplates?.tiles;
+      if (!Array.isArray(tiles)) return;
+      for (const template of tiles) {
+        if (typeof template?.id === "string" && template.id && typeof template?.widget === "string" && template.widget) {
+          widgets.set(template.id, template.widget);
+        }
+      }
+    }
+  };
+}
+function createElementStore(runtime, resolveTileWidget) {
+  return new ElementInstanceStore({
+    actions: runtime.actions,
+    events: {
+      publish: runtime.events.publish.bind(runtime.events),
+      subscribe: runtime.events.subscribe?.bind(runtime.events)
+    },
+    handlers: [new TileHandler(resolveTileWidget), new ActionHandler(), new ItemHandler()],
+    resolveTileWidget
+  });
+}
+
+// src/elements/ElementSessionController.ts
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function text(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function integer(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function expiry(value) {
+  return value === null || typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function instance(value) {
+  if (!record(value) || !text(value.instance_id) || !text(value.template_id) || !record(value.content) || !record(value.placement) || !record(value.mounted_by) || !text(value.mounted_by.agent_id) || !text(value.mounted_by.turn_id) || typeof value.mounted_at !== "string" || !Number.isFinite(Date.parse(value.mounted_at)) || !integer(value.version) || value.version < 1 || typeof value.state !== "string" || !["active", "applied", "reverted", "expired"].includes(value.state))
+    return false;
+  if (value.element_type === "tile")
+    return value.placement.type === "slot" && text(value.placement.slot);
+  if (value.element_type === "item")
+    return value.placement.type === "parent_tile" && text(value.placement.tile_id) && typeof value.placement.position === "string" && ["append", "prepend"].includes(value.placement.position);
+  if (value.element_type !== "action") return false;
+  return value.placement.type === "none" || value.placement.type === "selector" && text(value.placement.selector) && typeof value.placement.position === "string" && ["beforebegin", "afterbegin", "beforeend", "afterend", "replace", "modify"].includes(
+    value.placement.position
+  );
+}
+function frame(value) {
+  if (!record(value) || value.schema_version !== "v1" || value.kind !== "snapshot" || !text(value.session_ref) || !text(value.result_id) || !expiry(value.session_expires_at) || !Array.isArray(value.mounted_elements) || !value.mounted_elements.every(instance))
+    return false;
+  return new Set(value.mounted_elements.map((item) => item.instance_id)).size === value.mounted_elements.length;
+}
+var APPLIED_HISTORY = 32;
+function createElementSessionController(options) {
+  const templates = createTemplateWidgetResolver();
+  templates.refresh(options.templates);
+  const resolveTileWidget = (id) => templates.resolve(id) ?? (options.legacyTemplateFallback && !options.hostScope ? id : void 0);
+  const store = createElementStore(options, resolveTileWidget);
+  const cleanups = /* @__PURE__ */ new Set();
+  const scope = options.hostScope;
+  let generation = 0;
+  let disposed = false;
+  let hydrated = false;
+  let pending = Promise.resolve();
+  let lastAppliedResultId;
+  const appliedResultIds = /* @__PURE__ */ new Set();
+  function enqueue(operation) {
+    const next = pending.then(operation);
+    pending = next.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    return next;
+  }
+  const rejected = (reason) => ({ status: "rejected", reason });
+  return {
+    store,
+    resolveTileWidget,
+    whenIdle: () => pending,
+    configureTemplates(next) {
+      if (!disposed) templates.refresh(next);
+    },
+    acceptHostFrame(payload) {
+      return enqueue(async () => {
+        if (disposed) return rejected("disposed");
+        if (!frame(payload)) return rejected("invalid");
+        if (!scope || payload.session_ref !== scope.sessionRef) return rejected("wrong_scope");
+        if (payload.result_id === lastAppliedResultId || appliedResultIds.has(payload.result_id))
+          return { status: "duplicate", resultId: payload.result_id };
+        const report = await store.reconcileSnapshot(payload.mounted_elements);
+        if (disposed) return rejected("disposed");
+        if (!report.ok) return rejected("projection_failed");
+        lastAppliedResultId = payload.result_id;
+        appliedResultIds.add(payload.result_id);
+        if (appliedResultIds.size > APPLIED_HISTORY) {
+          appliedResultIds.delete(appliedResultIds.values().next().value);
+        }
+        store.scheduleClientTtl(payload.session_expires_at);
+        return { status: "applied", resultId: payload.result_id };
+      });
+    },
+    applyLegacyEnvelope(envelope) {
+      return enqueue(async () => {
+        if (!disposed) await store.apply(envelope.mutations);
+      });
+    },
+    hydrateLegacy(instances, expiresAt) {
+      return enqueue(async () => {
+        if (disposed) return;
+        await store.hydrate(instances);
+        if (!disposed) store.scheduleClientTtl(expiresAt);
+      });
+    },
+    hydrateOnce(load) {
+      if (hydrated || disposed) return;
+      hydrated = true;
+      const started = generation;
+      void load().then((response) => {
+        if (disposed || started !== generation || !response) return;
+        return enqueue(async () => {
+          if (disposed || started !== generation) return;
+          await store.hydrate(response.mounted_elements);
+          if (!disposed) store.scheduleClientTtl(response.session_expires_at);
+        });
+      }).catch(() => {
+      });
+    },
+    listen(target, name, listener) {
+      if (disposed) return () => {
+      };
+      target.addEventListener(name, listener);
+      const remove = () => {
+        target.removeEventListener(name, listener);
+        cleanups.delete(remove);
+      };
+      cleanups.add(remove);
+      return remove;
+    },
+    dispose() {
+      if (!disposed) {
+        disposed = true;
+        generation++;
+        for (const cleanup of cleanups) cleanup();
+        store.dispose(true);
+        templates.refresh(void 0);
+      }
+      return pending;
+    }
+  };
+}
+
+export {
+  ElementInstanceStore,
+  TileHandler,
+  createTemplateWidgetResolver,
+  createElementSessionController
+};
+//# sourceMappingURL=chunk-VIRIVP7H.js.map