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

package/dist/chunk-EWPPVPJ4.js

@@ -0,0 +1,14 @@
+// src/elements/store-singleton.ts
+var _activeStore = null;
+function setElementInstanceStore(store) {
+  _activeStore = store;
+}
+function getElementInstanceStore() {
+  return _activeStore;
+}
+
+export {
+  setElementInstanceStore,
+  getElementInstanceStore
+};
+//# sourceMappingURL=chunk-EWPPVPJ4.js.map

package/dist/chunk-EWPPVPJ4.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/elements/store-singleton.ts"],
+  "sourcesContent": ["import type { ElementInstanceStore } from './ElementInstanceStore';\n\nlet _activeStore: ElementInstanceStore | null = null;\n\nexport function setElementInstanceStore(store: ElementInstanceStore | null): void {\n  _activeStore = store;\n}\n\nexport function getElementInstanceStore(): ElementInstanceStore | null {\n  return _activeStore;\n}\n"],
+  "mappings": ";AAEA,IAAI,eAA4C;AAEzC,SAAS,wBAAwB,OAA0C;AAChF,iBAAe;AACjB;AAEO,SAAS,0BAAuD;AACrE,SAAO;AACT;",
+  "names": []
+}

package/dist/chunk-GP4OSTZT.js

@@ -0,0 +1,641 @@
+import {
+  AuthoringFieldsZ,
+  NotifyZ,
+  TriggerWhenZ
+} from "./chunk-KPWW7N27.js";
+
+// src/AdaptiveChipsStrip.ts
+import { html, LitElement, nothing } from "lit";
+import { styleMap } from "lit/directives/style-map.js";
+import { z } from "zod";
+var ChipPayloadZ = z.object({
+  widget: z.string().min(1).describe(
+    "Widget id from the runtime registry \u2014 same vocabulary as a tile's `widget` field. Click \u2192 strip mounts this widget into the chip drawer. Built-ins shipped by adaptive-chatbot: `adaptive-chatbot:text-answer`. Other adaptives register their own (e.g. `adaptive-faq:question-card`, `adaptive-product:mini`)."
+  ),
+  props: z.record(z.unknown()).optional().describe("Props passed to the mounted widget. The widget owns its own props schema.")
+}).strict().describe(
+  "The content that mounts in the chip's drawer when it opens. Same { widget, props } shape used by slots.lid and tile configs \u2014 chips are tiles by another name."
+);
+var SuggestionChipSchema = z.object({
+  ...AuthoringFieldsZ,
+  kind: z.literal("suggestions:chip").describe(
+    "Compositional action type for a single chip in the AdaptiveChipsStrip. Rendered by the strip widget; not executed by the runtime action engine."
+  ),
+  config: z.object({
+    id: z.string().min(1).describe("Stable identity for keyed rendering and event payloads."),
+    title: z.string().min(1).describe("Chip label \u2014 single line, ~32ch typical, ellipsis-truncates beyond."),
+    payload: ChipPayloadZ
+  }).describe(
+    "Per-chip configuration: identity, label, and the payload that opens in the drawer."
+  ),
+  triggerWhen: TriggerWhenZ.describe(
+    "Conditional visibility strategy. When null or omitted, the chip is always shown. Use a rules strategy to show/hide based on page URL, event counts, or session metrics \u2014 same evaluator that powers tile activation."
+  ),
+  notify: NotifyZ.describe(
+    "Toast notification shown when triggerWhen transitions false \u2192 true. Required when triggerWhen is set \u2014 pass null to opt out of the toast."
+  )
+}).refine((data) => !data.triggerWhen || data.notify !== void 0, {
+  message: "notify is required when triggerWhen is present (use null to opt out of notifications)"
+}).describe(
+  "A single suggestion chip in the chips strip. Same authoring shape as faq:question \u2014 discriminator + config body + optional conditional gating + optional proactive notification."
+);
+var AdaptiveChipsStrip = class extends LitElement {
+  constructor() {
+    super(...arguments);
+    this.chips = [];
+    /**
+     * Runtime reference — provides `widgets.has(id)` and
+     * `widgets.mount(id, container, props)` so the strip can render
+     * chip payloads through the same registry that mounts tile widgets.
+     * Null until the host wires it (the AdaptiveChipsStripMountable
+     * passes it in from the runtime).
+     */
+    this.runtimeRef = null;
+    /**
+     * Strip-level chrome toggle — applies uniformly to all chips +
+     * the payload drawer. Resolved upstream from `tile.chromeless`
+     * (which itself defaults from `slot.theme.chromeless`). Per-chip
+     * inconsistency would break the mini-canvas visual rhythm so
+     * there's no per-chip flag — one strip, one style.
+     */
+    this.chromeless = false;
+    this._openId = null;
+    /**
+     * Horizontal-scroll affordance state. The strip is a single row that
+     * overflows horizontally when there are more chips than the panel
+     * width can hold; the left/right chevron buttons are visible only
+     * when the user can actually scroll in that direction. ResizeObserver
+     * + scroll listener keep these in sync.
+     */
+    this._canScrollLeft = false;
+    this._canScrollRight = false;
+    this._stripResizeObserver = null;
+    /** Unsubscribe handle for the compositional-append/patch/remove event
+     *  subscription on `runtime.events`. Null when the strip hasn't yet
+     *  resolved its tile id (no parent container yet) or the runtime
+     *  doesn't expose an event bus. */
+    this._compositionalUnsub = null;
+    /** Tile id this strip occupies. Resolved on first `updated()` pass by
+     *  walking the DOM ancestor chain for `data-tile-id`. Cached because
+     *  the lookup is stable for the lifetime of the mount. Null while
+     *  unresolved (or when not running inside a SyntroTileCard, e.g.
+     *  in standalone test fixtures). */
+    this._tileId = null;
+    /** Instance ids of chips appended by LLM mounts (vs. authored chip
+     *  configs from `props.chips`). Tracked so `removeItem(instance_id)`
+     *  can find and prune by id. */
+    this._llmAppendedIds = /* @__PURE__ */ new Set();
+    /**
+     * Tracks the currently-mounted payload widget so we can swap on chip
+     * change + unmount on close. Same lifecycle pattern as
+     * `SyntroCanvasOverlay._lidMountHandle`.
+     */
+    this._payloadMount = null;
+    this._onStripScroll = () => {
+      this._updateScrollAffordances();
+    };
+    this._onPayloadClose = () => {
+      this._openId = null;
+    };
+  }
+  createRenderRoot() {
+    return this;
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this._unmountPayload();
+    this._stripResizeObserver?.disconnect();
+    this._stripResizeObserver = null;
+    this._compositionalUnsub?.();
+    this._compositionalUnsub = null;
+  }
+  updated(changed) {
+    super.updated(changed);
+    if (changed.has("_openId") || changed.has("chips") || changed.has("runtimeRef")) {
+      this._syncPayloadMount();
+    }
+    this._syncStripObserver();
+    this._updateScrollAffordances();
+    if (changed.has("runtimeRef")) {
+      this._compositionalUnsub?.();
+      this._compositionalUnsub = null;
+      this._tileId = this._resolveTileId();
+    }
+    if (!this._compositionalUnsub && this._tileId == null) {
+      this._tileId = this._resolveTileId();
+    }
+    if (!this._compositionalUnsub) {
+      this._subscribeCompositional();
+    }
+  }
+  _resolveTileId() {
+    const anchor = this.closest("[data-tile-id]");
+    return anchor?.getAttribute("data-tile-id") ?? null;
+  }
+  /**
+   * Subscribe to the runtime's event bus for compositional-item events
+   * targeting this strip's tile id. The subscription survives until
+   * disconnect; when an event arrives with a non-matching tile_id, it's
+   * a no-op (the same subscription handles all strips on the page —
+   * filter is just per-event check).
+   */
+  _subscribeCompositional() {
+    const bus = this.runtimeRef?.events;
+    if (!bus?.subscribe || !this._tileId) return;
+    const tileId = this._tileId;
+    this._compositionalUnsub = bus.subscribe((event) => {
+      const props = event.props ?? {};
+      if (props.tile_id !== tileId) return;
+      if (event.name === "element.compositional_append") {
+        this.insertItem(
+          String(props.instance_id ?? ""),
+          props.item,
+          props.position ?? "append"
+        );
+      } else if (event.name === "element.compositional_patch") {
+        this.patchItem(String(props.instance_id ?? ""), props.item);
+      } else if (event.name === "element.compositional_remove") {
+        this.removeItem(String(props.instance_id ?? ""));
+      }
+    });
+    bus.publish?.("element.compositional_replay_request", { tile_id: tileId });
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // CompositionalContainer contract — `ItemHandler` translates wire
+  // mutations into events that call these methods. The wire `item`
+  // shape is fully formed (`{kind, config: {id, title, payload, …}}`);
+  // the strip just appends, patches, or removes by `instance_id`.
+  // `instance_id` is the canonical id; chip.config.id is set to it by
+  // the backend, so they're the same value. We store the id on
+  // `chip.config.id` and use that as the lookup key.
+  // ─────────────────────────────────────────────────────────────────────────
+  /** Append (or prepend) a new chip authored by the LLM. */
+  insertItem(instanceId, item, position) {
+    if (!instanceId) return;
+    if (this._llmAppendedIds.has(instanceId)) return;
+    const incoming = item;
+    if (!incoming?.config?.id) return;
+    const chip = {
+      ...incoming,
+      config: { ...incoming.config, id: instanceId }
+    };
+    this._llmAppendedIds.add(instanceId);
+    this.chips = position === "prepend" ? [chip, ...this.chips] : [...this.chips, chip];
+  }
+  /** Replace the existing chip's content. v1: full replacement (no
+   *  in-place merge); the chip widget already re-renders on chip data
+   *  changes. */
+  patchItem(instanceId, item) {
+    if (!instanceId) return;
+    const idx = this.chips.findIndex((c) => c.config.id === instanceId);
+    if (idx < 0) return;
+    const next = [...this.chips];
+    next[idx] = item;
+    this.chips = next;
+  }
+  /** Remove a chip by instance id. Closes the payload drawer if the
+   *  removed chip was the open one. */
+  removeItem(instanceId) {
+    if (!instanceId) return;
+    const next = this.chips.filter((c) => c.config.id !== instanceId);
+    if (next.length === this.chips.length) return;
+    this.chips = next;
+    this._llmAppendedIds.delete(instanceId);
+    if (this._openId === instanceId) this._openId = null;
+  }
+  /**
+   * Attach a ResizeObserver to the scroll container so we recompute
+   * left/right arrow visibility when chips are added/removed or the
+   * panel width changes. The scroll listener on the strip element
+   * handles user-driven scrolls.
+   */
+  _syncStripObserver() {
+    const strip = this.querySelector("[data-chips-strip]");
+    if (!strip) {
+      this._stripResizeObserver?.disconnect();
+      this._stripResizeObserver = null;
+      return;
+    }
+    if (typeof ResizeObserver === "undefined") return;
+    if (!this._stripResizeObserver) {
+      this._stripResizeObserver = new ResizeObserver(() => this._updateScrollAffordances());
+    }
+    this._stripResizeObserver.disconnect();
+    this._stripResizeObserver.observe(strip);
+  }
+  /**
+   * Recompute whether the left/right scroll arrows should be visible.
+   * Left arrow ⇐ scrollLeft > 0. Right arrow ⇐ there are more chips
+   * to the right (scrollLeft + clientWidth < scrollWidth). Threshold
+   * of 1px tolerance handles sub-pixel rounding on scaled displays.
+   */
+  _updateScrollAffordances() {
+    const strip = this.querySelector("[data-chips-strip]");
+    if (!strip) return;
+    const canLeft = strip.scrollLeft > 1;
+    const canRight = strip.scrollLeft + strip.clientWidth < strip.scrollWidth - 1;
+    if (canLeft !== this._canScrollLeft) this._canScrollLeft = canLeft;
+    if (canRight !== this._canScrollRight) this._canScrollRight = canRight;
+  }
+  /**
+   * Scroll the strip by ~80% of its visible width, so each arrow click
+   * advances the user past most-but-not-all of the current chips
+   * (a small overlap helps the user keep their place in the row).
+   */
+  _scrollBy(direction) {
+    const strip = this.querySelector("[data-chips-strip]");
+    if (!strip) return;
+    const delta = strip.clientWidth * 0.8 * (direction === "left" ? -1 : 1);
+    strip.scrollBy({ left: delta, behavior: "smooth" });
+  }
+  _unmountPayload() {
+    if (this._payloadMount) {
+      try {
+        this._payloadMount.handle.unmount();
+      } catch (err) {
+        console.warn("[adaptive-chips-strip] payload widget unmount threw:", err);
+      }
+      this._payloadMount = null;
+    }
+  }
+  /**
+   * Reconcile the payload mount with the current `_openId`:
+   *   - drawer closed / no runtime / widget id unknown → tear down
+   *   - same chip + same widget id → no-op (or props update)
+   *   - different chip → unmount old, mount new
+   */
+  _syncPayloadMount() {
+    const chip = this.chips.find((c) => c.config.id === this._openId) ?? null;
+    const widgets = this.runtimeRef?.widgets;
+    if (!chip || !widgets || !widgets.has(chip.config.payload.widget)) {
+      this._unmountPayload();
+      return;
+    }
+    const nextWidget = chip.config.payload.widget;
+    const nextProps = chip.config.payload.props ?? {};
+    if (this._payloadMount?.chipId === chip.config.id && this._payloadMount.widgetId === nextWidget) {
+      this._payloadMount.handle.update?.(nextProps);
+      return;
+    }
+    this._unmountPayload();
+    const container = this.querySelector("[data-chip-payload-mount]");
+    if (!container) {
+      requestAnimationFrame(() => {
+        if (this._openId !== chip.config.id) return;
+        if (this._payloadMount?.chipId === chip.config.id && this._payloadMount.widgetId === nextWidget) {
+          return;
+        }
+        const retry = this.querySelector("[data-chip-payload-mount]");
+        if (!retry) return;
+        const handle2 = widgets.mount(nextWidget, retry, nextProps);
+        this._payloadMount = { chipId: chip.config.id, widgetId: nextWidget, handle: handle2 };
+      });
+      return;
+    }
+    const handle = widgets.mount(nextWidget, container, nextProps);
+    this._payloadMount = { chipId: chip.config.id, widgetId: nextWidget, handle };
+  }
+  _onChipClick(chip) {
+    if (this._openId === chip.config.id) {
+      this._openId = null;
+      return;
+    }
+    this._openId = chip.config.id;
+    this.dispatchEvent(
+      new CustomEvent("chip-revealed", {
+        detail: { id: chip.config.id, payload: chip.config.payload },
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  _onChipDismiss(chip, e) {
+    e.stopPropagation();
+    if (this._openId === chip.config.id) this._openId = null;
+    this.dispatchEvent(
+      new CustomEvent("chip-dismissed", {
+        detail: { id: chip.config.id },
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  render() {
+    const open = this.chips.find((c) => c.config.id === this._openId) ?? null;
+    return html`
+      <div data-syntro-chips-tile style=${styleMap(rootStyles())}>
+      <div data-chips-strip-frame style=${styleMap(stripFrameStyles())}>
+        ${this._canScrollLeft ? html`<button
+                type="button"
+                data-chips-scroll="left"
+                aria-label="Scroll suggestions left"
+                @click=${() => this._scrollBy("left")}
+                style=${styleMap(scrollButtonStyles("left"))}
+              >‹</button>` : nothing}
+        <div
+          data-chips-strip
+          style=${styleMap(stripStyles())}
+          @scroll=${this._onStripScroll}
+        >
+          ${this.chips.map(
+      (chip) => html`<button
+                type="button"
+                data-chip-id=${chip.config.id}
+                data-syntro-element-id=${chip.config.id}
+                data-state=${this._openId === chip.config.id ? "open" : "closed"}
+                data-chromeless=${this.chromeless ? "true" : "false"}
+                style=${styleMap(chipStyles(this._openId === chip.config.id, this.chromeless))}
+                @click=${() => this._onChipClick(chip)}
+              >
+                <span style=${styleMap(chipTitleStyles())}>${chip.config.title}</span>
+                <span style=${styleMap(chipGlyphStyles())}>
+                  ${this._openId === chip.config.id ? "\u25BC" : "\u203A"}
+                </span>
+                ${// Per-chip dismiss × is suppressed when the strip is
+      // chromeless — LLM-curated suggestions in a mini-
+      // canvas surface shouldn't be user-dismissible (the
+      // model picks them; the user can't "remove" them
+      // any more than they can remove a paragraph of
+      // prose). Also suppressed on the open chip in any
+      // mode (the chip's button-toggle handles close).
+      this.chromeless || this._openId === chip.config.id ? nothing : html`<span
+                        role="button"
+                        tabindex="0"
+                        data-chip-dismiss=${chip.config.id}
+                        aria-label="Dismiss suggestion"
+                        title="Dismiss"
+                        style=${styleMap(chipDismissStyles())}
+                        @click=${(e) => this._onChipDismiss(chip, e)}
+                        @keydown=${(e) => {
+        if (e.key === "Enter" || e.key === " ") {
+          e.preventDefault();
+          this._onChipDismiss(chip, e);
+        }
+      }}
+                      >×</span>`}
+              </button>`
+    )}
+        </div>
+        ${this._canScrollRight ? html`<button
+                type="button"
+                data-chips-scroll="right"
+                aria-label="Scroll suggestions right"
+                @click=${() => this._scrollBy("right")}
+                style=${styleMap(scrollButtonStyles("right"))}
+              >›</button>` : nothing}
+      </div>
+        ${open ? html`<div
+                data-chip-payload
+                data-for-chip=${open.config.id}
+                data-chromeless=${this.chromeless ? "true" : "false"}
+                style=${styleMap(payloadStyles(this.chromeless))}
+              >
+                <!--
+                  Drawer header — title (the Q in Q&A) ALWAYS renders
+                  because it's the actual content of the answer
+                  pairing, not chrome. Chromeless mode drops the
+                  surrounding chrome (border, background, ⌃ close)
+                  but the title stays so the chip → answer link is
+                  visible above the body. User closes by re-clicking
+                  the chip.
+                -->
+                <div
+                  data-chip-payload-header
+                  style=${styleMap(payloadHeaderStyles(this.chromeless))}
+                >
+                  <span>${open.config.title}</span>
+                  ${this.chromeless ? nothing : html`<button
+                          type="button"
+                          data-chip-payload-close
+                          aria-label="Collapse"
+                          @click=${this._onPayloadClose}
+                          style=${styleMap(payloadCloseStyles())}
+                        >⌃</button>`}
+                </div>
+                <div style=${styleMap(payloadBodyStyles(this.chromeless))}>
+                  <!--
+                    Payload widget mounts here imperatively in updated().
+                    The mount container is a stable element across renders so
+                    the runtime registry can track + update + unmount
+                    properly. If the widget id is unknown to the registry,
+                    we leave a labeled placeholder so the gap is visible
+                    in development rather than silently empty.
+                  -->
+                  ${this.runtimeRef?.widgets?.has(open.config.payload.widget) ? html`<div data-chip-payload-mount></div>` : html`<p style=${styleMap(unresolvedStyles())}>
+                          Widget <code>${open.config.payload.widget}</code> not registered.
+                        </p>`}
+                </div>
+              </div>` : nothing}
+      </div>
+    `;
+  }
+};
+AdaptiveChipsStrip.properties = {
+  chips: { attribute: false },
+  runtimeRef: { attribute: false },
+  chromeless: { type: Boolean, reflect: true },
+  _openId: { state: true },
+  _canScrollLeft: { state: true },
+  _canScrollRight: { state: true }
+};
+function rootStyles() {
+  return {
+    display: "flex",
+    flexDirection: "column",
+    gap: "10px",
+    width: "100%"
+  };
+}
+function stripFrameStyles() {
+  return {
+    position: "relative",
+    display: "flex",
+    alignItems: "center",
+    width: "100%"
+  };
+}
+function stripStyles() {
+  return {
+    display: "flex",
+    flexDirection: "row",
+    // Single row — chips never wrap. Horizontal overflow becomes
+    // a scrollable region with left/right arrow affordances on either
+    // side of the frame. `flex-wrap: wrap` (the old behavior) packed
+    // chips into multiple rows, which broke the mini-canvas surface's
+    // visual rhythm — chat-bar above, ONE row of chips, payload below.
+    flexWrap: "nowrap",
+    gap: "8px",
+    width: "100%",
+    overflowX: "auto",
+    overflowY: "hidden",
+    // Hide the native scrollbar — the chevron buttons are the
+    // affordance. Firefox: `scrollbarWidth: 'none'`. WebKit: the
+    // global `::-webkit-scrollbar { display: none }` rule in
+    // chatTrailGlobalStyles.ts (which is shared chat-surface CSS) is
+    // what hides it across all our scroll surfaces.
+    scrollbarWidth: "none",
+    scrollSnapType: "x proximity",
+    scrollBehavior: "smooth",
+    // Don't let touch scroll bubble up to the page when the strip
+    // can scroll horizontally — keeps wheel scroll on the canvas
+    // intact while letting the strip move under the cursor.
+    overscrollBehavior: "contain"
+  };
+}
+function scrollButtonStyles(side) {
+  return {
+    position: "absolute",
+    [side]: "0",
+    top: "50%",
+    transform: "translateY(-50%)",
+    zIndex: "2",
+    width: "24px",
+    height: "24px",
+    display: "inline-flex",
+    alignItems: "center",
+    justifyContent: "center",
+    padding: "0",
+    borderRadius: "9999px",
+    border: "1px solid hsl(var(--sc-tile-border-color, 0 0% 100%) / 0.18)",
+    background: "hsl(var(--sc-accent-color) / 0.18)",
+    backdropFilter: "blur(6px)",
+    WebkitBackdropFilter: "blur(6px)",
+    color: "var(--sc-tile-title-color, currentColor)",
+    fontSize: "14px",
+    lineHeight: "1",
+    cursor: "pointer",
+    opacity: "0.85",
+    transition: "opacity 150ms ease, background 150ms ease"
+  };
+}
+function chipStyles(isOpen, _chromeless) {
+  return {
+    display: "inline-flex",
+    alignItems: "center",
+    gap: "6px",
+    // Flex to text width up to a sane cap. The title span inside owns
+    // the ellipsis safety net for genuinely-long titles.
+    maxWidth: "32ch",
+    color: isOpen ? "var(--sc-tile-title-color, currentColor)" : "var(--sc-tile-text-color, currentColor)",
+    fontSize: "12px",
+    fontWeight: "600",
+    cursor: "pointer",
+    transition: "background 180ms ease, border-color 180ms ease, color 180ms ease",
+    padding: "6px 12px",
+    borderRadius: "9999px",
+    border: isOpen ? "1px solid hsl(var(--sc-accent-color) / 0.45)" : "1px solid hsl(var(--sc-tile-border-color, 0 0% 100%) / 0.18)",
+    background: isOpen ? "hsl(var(--sc-accent-color) / 0.10)" : "transparent"
+  };
+}
+function chipTitleStyles() {
+  return {
+    whiteSpace: "nowrap",
+    overflow: "hidden",
+    textOverflow: "ellipsis",
+    minWidth: "0"
+  };
+}
+function chipDismissStyles() {
+  return {
+    display: "inline-flex",
+    alignItems: "center",
+    justifyContent: "center",
+    width: "16px",
+    height: "16px",
+    marginLeft: "2px",
+    borderRadius: "9999px",
+    color: "inherit",
+    fontSize: "12px",
+    lineHeight: "1",
+    cursor: "pointer",
+    opacity: "0.45",
+    flexShrink: "0",
+    transition: "opacity 150ms ease, background 150ms ease"
+  };
+}
+function chipGlyphStyles() {
+  return {
+    fontSize: "10px",
+    opacity: "0.7",
+    flexShrink: "0"
+  };
+}
+function payloadStyles(chromeless) {
+  const base = {
+    display: "flex",
+    flexDirection: "column",
+    gap: "6px",
+    color: "var(--sc-tile-title-color, currentColor)"
+  };
+  if (chromeless) {
+    return {
+      ...base,
+      padding: "4px 0 0",
+      borderRadius: "0",
+      border: "none",
+      background: "transparent"
+    };
+  }
+  return {
+    ...base,
+    padding: "10px 12px",
+    borderRadius: "var(--sc-tile-border-radius, 12px)",
+    border: "1px solid hsl(var(--sc-accent-color) / 0.18)",
+    background: "hsl(var(--sc-accent-color) / 0.04)"
+  };
+}
+function payloadHeaderStyles(chromeless) {
+  return {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "space-between",
+    gap: "8px",
+    fontSize: "12px",
+    fontWeight: "600",
+    // In chromeless mode the header is the only visible heading for
+    // the answer below (no surrounding box/border). Use the accent
+    // color so the Q reads distinctly as the prompt for the A.
+    ...chromeless ? { color: "hsl(var(--sc-accent-color) / 0.95)" } : {}
+  };
+}
+function payloadCloseStyles() {
+  return {
+    width: "22px",
+    height: "22px",
+    display: "inline-flex",
+    alignItems: "center",
+    justifyContent: "center",
+    borderRadius: "9999px",
+    background: "transparent",
+    border: "1px solid hsl(var(--sc-tile-border-color, 0 0% 100%) / 0.18)",
+    color: "inherit",
+    fontSize: "11px",
+    cursor: "pointer",
+    opacity: "0.65"
+  };
+}
+function payloadBodyStyles(chromeless) {
+  return {
+    fontSize: "12px",
+    lineHeight: "1.55",
+    color: "var(--sc-tile-text-color, currentColor)",
+    // No top divider needed when the header is suppressed.
+    ...chromeless ? {} : {}
+  };
+}
+function unresolvedStyles() {
+  return {
+    margin: "0",
+    fontStyle: "italic",
+    opacity: "0.7"
+  };
+}
+if (!customElements.get("adaptive-chips-strip")) {
+  customElements.define("adaptive-chips-strip", AdaptiveChipsStrip);
+}
+
+export {
+  SuggestionChipSchema,
+  AdaptiveChipsStrip
+};
+//# sourceMappingURL=chunk-GP4OSTZT.js.map