@syntrologie/adapt-reviews 2.55.1 → 2.56.0

package/dist/{chunk-ATGQNO24.js → chunk-M64YCKZP.js}

@@ -1,3 +1,7 @@
+import {
+  external_exports
+} from "./chunk-IGIU6S7P.js";
+
 // src/reviewDisplay.ts
 import { html, LitElement, nothing } from "lit";
 import { styleMap } from "lit/directives/style-map.js";
@@ -167,7 +171,7 @@ var SyntroReviews = class extends LitElement {
     const rootStyles = {
       display: "block",
       width: "100%",
-      color: "var(--sc-tile-text, var(--sc-overlay-text-color, #111827))",
+      color: "var(--sc-tile-text-color, var(--sc-overlay-text-color, #111827))",
       fontFamily: "var(--sc-font-family, inherit)"
     };
     return html`
@@ -229,7 +233,7 @@ var SyntroReviews = class extends LitElement {
   _panelStyles() {
     return {
       boxSizing: "border-box",
-      border: "1px solid var(--sc-tile-border-color, rgba(148, 163, 184, 0.24))",
+      border: "1px solid var(--sc-content-divider-color, rgba(148, 163, 184, 0.24))",
       borderRadius: "8px",
       background: "var(--sc-tile-background, #ffffff)",
       padding: "14px",
@@ -258,13 +262,13 @@ var SyntroReviews = class extends LitElement {
       display: "inline-flex",
       alignItems: "center",
       gap: "4px",
-      color: "var(--sc-accent, #2563eb)",
+      color: "hsl(var(--sc-accent-color, 221 83% 53%))",
       whiteSpace: "nowrap"
     };
   }
   _reviewStyles() {
     return {
-      borderTop: "1px solid var(--sc-tile-border-color, rgba(148, 163, 184, 0.2))",
+      borderTop: "1px solid var(--sc-content-divider-color, rgba(148, 163, 184, 0.2))",
       paddingTop: "10px"
     };
   }
@@ -280,7 +284,7 @@ var SyntroReviews = class extends LitElement {
   }
   _starsStyles() {
     return {
-      color: "var(--sc-accent, #2563eb)",
+      color: "hsl(var(--sc-accent-color, 221 83% 53%))",
       fontSize: "13px",
       lineHeight: "18px",
       whiteSpace: "nowrap"
@@ -295,7 +299,7 @@ var SyntroReviews = class extends LitElement {
   }
   _metaStyles() {
     return {
-      color: "var(--sc-muted-text, #64748b)",
+      color: "var(--sc-content-text-secondary-color, #64748b)",
       fontSize: "12px",
       lineHeight: "18px"
     };
@@ -303,7 +307,7 @@ var SyntroReviews = class extends LitElement {
   _stateStyles() {
     return {
       marginTop: "8px",
-      color: "var(--sc-muted-text, #64748b)",
+      color: "var(--sc-content-text-secondary-color, #64748b)",
       fontSize: "14px",
       lineHeight: "20px"
     };
@@ -403,8 +407,8 @@ var FlipController = class {
     this.animating = false;
     this.dir = "in";
     this.settleTimer = null;
-    this.onAnimationEnd = (e) => {
-      if (e.animationName === `${this.keyframePrefix}-in` || e.animationName === `${this.keyframePrefix}-out`) {
+    this.onAnimationEnd = (e2) => {
+      if (e2.animationName === `${this.keyframePrefix}-in` || e2.animationName === `${this.keyframePrefix}-out`) {
         this.settle();
       }
     };
@@ -506,6 +510,542 @@ var FlipController = class {
   }
 };
 
+// ../../../node_modules/@lit/context/lib/create-context.js
+function n(n2) {
+  return n2;
+}
+
+// ../../sdk-contracts/dist/canvas-context.js
+var canvasRuntimeContext = n("syntrologie:canvas-runtime");
+
+// ../../sdk-contracts/dist/telemetry-events.js
+var entry = (e2) => e2;
+var TELEMETRY_EVENTS = {
+  // --- intervention metrics (April 2026) — wire names unchanged, all plan-scope
+  syntro_config_served: entry({
+    subject: "config",
+    verb: "served",
+    scope: "plan",
+    props: ["tiles", "actions"]
+  }),
+  syntro_intervention_seen: entry({
+    subject: "intervention",
+    verb: "seen",
+    scope: "plan",
+    props: ["intervention_id", "intervention_kind"]
+  }),
+  syntro_intervention_triggered: entry({
+    subject: "intervention",
+    verb: "triggered",
+    scope: "plan",
+    props: ["intervention_id", "intervention_kind"]
+  }),
+  syntro_intervention_interacted: entry({
+    subject: "intervention",
+    verb: "interacted",
+    scope: "plan",
+    props: ["intervention_id", "intervention_kind", "interaction_type"]
+  }),
+  // --- concierge (FEAT-1789150184) ---------------------------------------
+  syntro_concierge_opened: entry({
+    subject: "concierge",
+    verb: "opened",
+    scope: "open",
+    props: ["trigger", "page_path"]
+    // trigger: ConciergeOpenTrigger
+  }),
+  syntro_concierge_closed: entry({
+    subject: "concierge",
+    verb: "closed",
+    scope: "open",
+    props: ["duration_ms", "reason", "messages_sent", "tiles_dismissed", "pages_viewed"]
+    // reason: ConciergeCloseReason
+  }),
+  /**
+   * The shopper asked to leave the canvas by a link. Emitted on intent, before
+   * the host answers, so refused or denied opens are counted too (parity with
+   * syntro_concierge_closed reason navigation).
+   *
+   * On a merchant's own page a link tap closes the canvas, and
+   * `syntro_concierge_closed { reason: 'navigation' }` is the row that
+   * records it. Inside a chat app's card the frame is sandboxed: the canvas
+   * cannot navigate, does not close, and asks the host to open the link
+   * instead, so that close row never fires. This is its counterpart, and it
+   * carries the same `reason` so one query covers both surfaces.
+   */
+  syntro_link_opened: entry({
+    subject: "link",
+    verb: "opened",
+    scope: "open",
+    props: ["kind", "reason"]
+    // kind: LinkOpenKind, reason: ConciergeCloseReason
+  }),
+  /**
+   * A store's product page opened inside a chat-app card instead of leaving
+   * through the host (the card's product view). `product` is the store's
+   * handle, never the display name; a rail switch is a new open. Its
+   * counterpart when the shopper goes back to the conversation's picks is
+   * syntro_product_view_closed.
+   *
+   * Plan scope, like the card's own syntro_card_lifecycle_seen: an inline
+   * card holds an open scope only while the host has it fullscreen, and a
+   * view opened from a tile fires before the host answers that request (or
+   * after it refused), so an open-scope row here would be dropped. The core
+   * still stamps surface and open_id whenever an open is live.
+   */
+  syntro_product_view_opened: entry({
+    subject: "product_view",
+    verb: "opened",
+    scope: "plan",
+    props: ["product", "from"]
+    // from: ProductViewOpenSource
+  }),
+  syntro_product_view_closed: entry({
+    subject: "product_view",
+    verb: "closed",
+    scope: "plan",
+    props: ["product"]
+  }),
+  syntro_deck_paged: entry({
+    subject: "deck",
+    verb: "paged",
+    scope: "open",
+    props: ["from_index", "to_index", "method"]
+    // method: DeckPageMethod
+  }),
+  syntro_tile_dismissed: entry({
+    subject: "tile",
+    verb: "dismissed",
+    scope: "open",
+    props: ["tile_id", "tile_kind", "visible_ms"]
+  }),
+  // A tile's own data load finished: the network wait between the concierge
+  // mounting a tile and the shopper seeing its content (BUG-1784767817 was a
+  // 30 s reviews hang here). `outcome` is 'ok' | 'error'; `requested` is how
+  // many items the tile asked for, `received` how many came back.
+  syntro_tile_data_received: entry({
+    subject: "tile_data",
+    verb: "received",
+    scope: "open",
+    props: ["tile_id", "tile_kind", "total_ms", "outcome", "requested", "received"]
+  }),
+  // The three chat atoms are OPEN-scope: they carry `surface` / `open_id` and
+  // only make sense inside a concierge open. An INLINE chat bar (no concierge)
+  // still dispatches them on every turn, and the core drops each one and
+  // increments the `telemetry_dropped` health counter. That is EXPECTED on an
+  // inline-chat host page, not a bug — `telemetry_dropped` there mixes "real
+  // defect" with "inline chat has no open scope", so do not alert on it alone.
+  syntro_chat_message_sent: entry({
+    subject: "chat_message",
+    verb: "sent",
+    scope: "open",
+    props: ["turn", "chars", "via"]
+    // via: ChatSendVia
+  }),
+  syntro_chat_reply_received: entry({
+    subject: "chat_reply",
+    verb: "received",
+    scope: "open",
+    // mount_tools: the mount_* tool name of every mount this reply fired, in order (two product cards appear twice).
+    props: ["turn", "ttft_ms", "total_ms", "mounts", "cards", "mount_tools"]
+  }),
+  syntro_chat_interrupted: entry({
+    subject: "chat",
+    verb: "interrupted",
+    scope: "open",
+    props: ["turn", "after_ms"]
+  }),
+  syntro_chat_maximize_toggled: entry({
+    subject: "chat_maximize",
+    verb: "toggled",
+    scope: "open",
+    props: ["maximized"]
+  }),
+  syntro_chat_takeover_triggered: entry({
+    subject: "chat_takeover",
+    verb: "triggered",
+    scope: "open",
+    props: ["turn"]
+  }),
+  // --- search takeover (2026-09-17) ---------------------------------------
+  // All plan-scope: the search interceptor fires before any concierge open
+  // exists. No prop here ever carries query text (SEE the contract test's
+  // no-text-prop rule) — classification/signal_hits are the interceptor's
+  // own derived signals, never the string itself.
+  syntro_search_sent: entry({
+    subject: "search",
+    verb: "sent",
+    scope: "plan",
+    props: ["classification", "word_count", "signal_hits", "entry_point", "platform"]
+    // classification: SearchClassification, entry_point: SearchEntryPoint
+  }),
+  // `ms_to_skeleton` is intentionally the only timing prop: it is always
+  // knowable the instant the surface mounts. `ms_to_first_content` is NOT
+  // declared here (revision 1 defect) because a surface that never painted
+  // content still fires this event, and a required prop it cannot supply
+  // would make TelemetryCore.emit drop exactly the row worth measuring.
+  syntro_search_surface_seen: entry({
+    subject: "search_surface",
+    verb: "seen",
+    scope: "plan",
+    props: ["variant", "classification", "result_count", "ms_to_skeleton"]
+    // variant: SearchVariant, classification: SearchClassification
+  }),
+  syntro_search_result_tapped: entry({
+    subject: "search_result",
+    verb: "tapped",
+    scope: "plan",
+    props: ["variant", "region_id", "module", "position"]
+    // variant: SearchVariant
+  }),
+  syntro_search_followup_sent: entry({
+    subject: "search_followup",
+    verb: "sent",
+    scope: "plan",
+    props: ["delta_kind", "variant"]
+    // delta_kind: SearchDeltaKind, variant: SearchVariant
+  }),
+  // Declares `ms_since_boot` (not a "since surface mounted" timing prop) so a
+  // not-ready fallback the takeover never rendered is still measurable —
+  // revision 1 emitted nothing on this path.
+  syntro_search_native_served: entry({
+    subject: "search_native",
+    verb: "served",
+    scope: "plan",
+    props: ["reason", "platform", "ms_since_boot"]
+    // reason: SearchFallbackReason
+  }),
+  syntro_search_takeover_dismissed: entry({
+    subject: "search_takeover",
+    verb: "dismissed",
+    scope: "plan",
+    props: ["variant", "reason"]
+    // variant: SearchVariant, reason: SearchDismissReason
+  }),
+  // --- chat-app card lifecycle (2026-09-24) --------------------------------
+  // One row per stage a card reached, from `reportCardStage` in
+  // card-lifecycle.ts. Plan scope: most stages happen before a config is
+  // served and none happen inside a concierge open. `stage` is a
+  // CardLifecycleStage; `since_shell_ms` is the card shell's own clock, so a
+  // card's rows order themselves from the first byte of the page. The same
+  // stages reach the connector through the shell's beacon, which is the only
+  // record of a card whose SDK never booted.
+  syntro_card_lifecycle_seen: entry({
+    subject: "card_lifecycle",
+    verb: "seen",
+    scope: "plan",
+    props: ["stage", "since_shell_ms"]
+    // stage: CardLifecycleStage
+  })
+};
+var TELEMETRY_EVENT_NAMES = Object.keys(TELEMETRY_EVENTS);
+var TELEMETRY_DOM_EVENT = "syntro:telemetry";
+
+// ../../sdk-contracts/dist/card-lifecycle.js
+var MCP_APP_SURFACE_ATTRIBUTES = Object.freeze({
+  surface_type: "mcp-app",
+  surface: "personal_agent"
+});
+
+// ../../sdk-contracts/dist/detector-events.js
+var DETECTOR_EVENT_NAMES = [
+  "ui.hover",
+  "ui.idle",
+  "ui.hesitate",
+  "ui.rage_click",
+  "ui.scroll_thrash",
+  "ui.focus_bounce"
+];
+var CANONICAL_BUS_EVENT_NAMES = [
+  ...DETECTOR_EVENT_NAMES,
+  "nav.section_viewed",
+  "nav.scroll_depth"
+];
+
+// ../../sdk-contracts/dist/routes.js
+var RESERVED_BYTES = /* @__PURE__ */ new Set([
+  33,
+  // !
+  35,
+  // #
+  36,
+  // $
+  38,
+  // &
+  39,
+  // '
+  40,
+  // (
+  41,
+  // )
+  42,
+  // *
+  43,
+  // +
+  44,
+  // ,
+  47,
+  // /
+  58,
+  // :
+  59,
+  // ;
+  61,
+  // =
+  63,
+  // ?
+  64,
+  // @
+  91,
+  // [
+  93
+  // ]
+]);
+var utf8Decoder = new TextDecoder("utf-8", { fatal: false });
+function decodeUnreservedOnly(input) {
+  let out = "";
+  let pending = [];
+  const flushPending = () => {
+    if (pending.length === 0)
+      return;
+    const bytes = new Uint8Array(pending);
+    out += utf8Decoder.decode(bytes);
+    pending = [];
+  };
+  let i2 = 0;
+  while (i2 < input.length) {
+    const ch = input[i2];
+    if (ch === "%" && i2 + 2 < input.length && isHex(input[i2 + 1]) && isHex(input[i2 + 2])) {
+      const byte = parseInt(input.slice(i2 + 1, i2 + 3), 16);
+      if (RESERVED_BYTES.has(byte)) {
+        flushPending();
+        out += `%${input.slice(i2 + 1, i2 + 3).toUpperCase()}`;
+        i2 += 3;
+      } else {
+        pending.push(byte);
+        i2 += 3;
+      }
+    } else {
+      flushPending();
+      out += ch;
+      i2 += 1;
+    }
+  }
+  flushPending();
+  return out;
+}
+function isHex(c2) {
+  return c2 >= "0" && c2 <= "9" || c2 >= "a" && c2 <= "f" || c2 >= "A" && c2 <= "F";
+}
+function stripQueryAndHash(s4) {
+  const q = s4.indexOf("?");
+  if (q !== -1)
+    s4 = s4.slice(0, q);
+  const h = s4.indexOf("#");
+  if (h !== -1)
+    s4 = s4.slice(0, h);
+  return s4;
+}
+function normalizeRoute(path) {
+  if (typeof path !== "string" || path.length === 0) {
+    throw new TypeError("normalizeRoute: input must be a non-empty string");
+  }
+  if (!path.startsWith("/")) {
+    throw new TypeError(`normalizeRoute: input must be absolute (start with '/'); got ${JSON.stringify(path)}`);
+  }
+  let s4 = stripQueryAndHash(path);
+  s4 = decodeUnreservedOnly(s4);
+  s4 = s4.replace(/\/+/g, "/");
+  if (s4.length > 1 && s4.endsWith("/"))
+    s4 = s4.slice(0, -1);
+  return s4;
+}
+
+// ../../sdk-contracts/dist/schemas.js
+var NO_CSS_BREAKOUT_PATTERN = /^[^{}]*$/;
+var AnchorIdZ = external_exports.object({
+  selector: external_exports.string().regex(NO_CSS_BREAKOUT_PATTERN, {
+    message: 'selector must not contain "{" or "}" \u2014 not valid CSS selector syntax, and content:hideBySelector injects this value directly into a <style> element where these characters would break out of the generated rule.'
+  }).describe("CSS selector for the target element"),
+  route: external_exports.union([external_exports.string(), external_exports.array(external_exports.string())]).superRefine((value, ctx) => {
+    for (const route of Array.isArray(value) ? value : [value]) {
+      let canonical;
+      try {
+        canonical = normalizeRoute(route);
+      } catch (err) {
+        ctx.addIssue({
+          code: external_exports.ZodIssueCode.custom,
+          message: `route must be an absolute path starting with "/" (got ${JSON.stringify(route)}): ${err instanceof Error ? err.message : String(err)}`
+        });
+        continue;
+      }
+      if (canonical !== route) {
+        ctx.addIssue({
+          code: external_exports.ZodIssueCode.custom,
+          message: `route ${JSON.stringify(route)} is not canonical \u2014 use ${JSON.stringify(canonical)} (this must match what the backend's RouteCanonicalityCheck accepts)`
+        });
+      }
+    }
+  }).describe("URL path(s) where this element exists")
+}).strict().describe("DOM element target. selector = CSS selector, route = URL path(s) where the element exists.");
+var AuthoringFieldsZ = {
+  id: external_exports.string().optional().describe('Stable action identifier (e.g. "act_3db6a14d2ab0").'),
+  title: external_exports.string().max(200).optional().describe("Authoring-only: short label shown on the action plan dashboard. Stripped before serving to the runtime SDK."),
+  description: external_exports.string().max(1e3).optional().describe("Authoring-only: one-sentence explanation of what this action does and why. Stripped before serving to the runtime SDK."),
+  validation: external_exports.array(external_exports.string().max(500)).max(10).optional().describe("Authoring-only: ordered steps a reviewer can follow to trigger this action and visually confirm it works. Each entry is one step. Stripped before serving to the runtime SDK.")
+};
+var COUNTABLE_EVENTS = [
+  // User interactions (from PostHog autocapture normalization)
+  "ui.click",
+  "ui.scroll",
+  "ui.input",
+  "ui.change",
+  "ui.submit",
+  // Behavioral detectors (from event-processor)
+  "ui.hover",
+  "ui.idle",
+  "ui.scroll_thrash",
+  "ui.focus_bounce",
+  "ui.hesitate",
+  "ui.rage_click",
+  // Navigation
+  "nav.page_view",
+  "nav.page_leave"
+];
+var CountableEventZ = external_exports.enum(COUNTABLE_EVENTS).describe("Event name to count. ui.* = user interactions and behavioral detectors (hesitate, rage_click, scroll_thrash, focus_bounce, idle, hover); nav.* = page navigation.");
+var SESSION_METRIC_KEYS = ["time_on_page", "page_views", "scroll_depth"];
+var SessionMetricKeyZ = external_exports.enum(SESSION_METRIC_KEYS).describe("Session metric key. time_on_page = seconds on current page, page_views = pages visited this session, scroll_depth = 0-100 percentage.");
+var PageUrlConditionZ = external_exports.object({
+  type: external_exports.literal("page_url"),
+  url: external_exports.string().describe('URL path to match (e.g. "/pricing", "/dashboard")')
+}).describe('Fires when the current page URL matches. Use for page-specific actions. Example: {"type": "page_url", "url": "/pricing"}');
+var RouteConditionZ = external_exports.object({
+  type: external_exports.literal("route"),
+  routeId: external_exports.string().describe("Named route ID from the route filter")
+}).describe("Fires when the current route matches a named route ID.");
+var AnchorVisibleConditionZ = external_exports.object({
+  type: external_exports.literal("anchor_visible"),
+  anchorId: external_exports.string().describe("CSS selector of the anchor element"),
+  state: external_exports.enum(["visible", "present", "absent"]).describe('"visible" = in viewport, "present" = in DOM, "absent" = not in DOM')
+}).describe(`Fires based on a DOM element's visibility state. Example: {"type": "anchor_visible", "anchorId": "#cta-button", "state": "visible"}`);
+var EventOccurredConditionZ = external_exports.object({
+  type: external_exports.literal("event_occurred"),
+  eventName: external_exports.string().describe('Event name (e.g. "ui.click", "$pageview")'),
+  withinMs: external_exports.number().optional().describe("Time window in ms. Omit = any time this session.")
+}).describe('Fires when a specific event has occurred during this session. Example: {"type": "event_occurred", "eventName": "ui.click", "withinMs": 5000}');
+var StateEqualsConditionZ = external_exports.object({
+  type: external_exports.literal("state_equals"),
+  key: external_exports.string().describe("Key in the SDK persistent state store (localStorage). Only valid for keys the host app explicitly sets via syntro.state.set()."),
+  value: external_exports.unknown().describe("Expected value to match against")
+}).describe("Checks the SDK persistent state store (localStorage). ONLY for host-app state set via syntro.state.set() \u2014 NOT for user attributes like region, device, or UTM params (those are handled by segment targeting). Do NOT use this for targeting. If you do not know the valid state keys, do not use this condition type.");
+var ViewportConditionZ = external_exports.object({
+  type: external_exports.literal("viewport"),
+  minWidth: external_exports.number().optional().describe("Minimum viewport width in pixels"),
+  maxWidth: external_exports.number().optional().describe("Maximum viewport width in pixels"),
+  minHeight: external_exports.number().optional().describe("Minimum viewport height in pixels"),
+  maxHeight: external_exports.number().optional().describe("Maximum viewport height in pixels")
+}).describe('Fires based on viewport (screen) size. Use for responsive behavior. Example: {"type": "viewport", "minWidth": 768} \u2014 fires on tablet and larger.');
+var SessionMetricConditionZ = external_exports.object({
+  type: external_exports.literal("session_metric"),
+  key: SessionMetricKeyZ,
+  operator: external_exports.enum(["gte", "lte", "eq", "gt", "lt"]),
+  threshold: external_exports.number().describe("Numeric threshold to compare against")
+}).describe('Fires when a session metric crosses a threshold. Valid keys: "time_on_page" (seconds), "page_views" (count), "scroll_depth" (0-100). Example: {"type": "session_metric", "key": "time_on_page", "operator": "gte", "threshold": 30}');
+var DismissedConditionZ = external_exports.object({
+  type: external_exports.literal("dismissed"),
+  key: external_exports.string().describe("Dismissal key (usually a tile or action ID)"),
+  inverted: external_exports.boolean().optional().describe("When true, fires if NOT dismissed (default behavior)")
+}).describe("Checks if an item has been dismissed by the user. Use with inverted: true to show only if not dismissed.");
+var CooldownActiveConditionZ = external_exports.object({
+  type: external_exports.literal("cooldown_active"),
+  key: external_exports.string().describe("Cooldown key"),
+  inverted: external_exports.boolean().optional().describe("When true, fires if cooldown is NOT active")
+}).describe("Checks if a cooldown timer is currently active. Use to prevent showing the same intervention too frequently.");
+var FrequencyLimitConditionZ = external_exports.object({
+  type: external_exports.literal("frequency_limit"),
+  key: external_exports.string().describe("Frequency counter key"),
+  limit: external_exports.number().describe("Maximum allowed count"),
+  inverted: external_exports.boolean().optional().describe("When true, fires if limit NOT reached")
+}).describe("Checks if a frequency limit has been reached. Use to cap how many times an action fires per session.");
+var MatchOpZ = external_exports.object({
+  equals: external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean()]).optional(),
+  contains: external_exports.string().optional()
+}).refine((operator) => Number(operator.equals !== void 0) + Number(operator.contains !== void 0) === 1, {
+  message: "Exactly one of equals or contains must be specified."
+}).describe("Match operator for counter filters. Exactly one of equals or contains must be specified.");
+var CounterDefZ = external_exports.object({
+  events: external_exports.array(CountableEventZ).min(1).describe("Event names to count. Use values from the countable events enum."),
+  match: external_exports.record(external_exports.string(), MatchOpZ).optional().describe("Property filters. Keys are event prop names or element-chain fields (tag_name, $el_text, attr__*). All entries AND together.")
+}).describe("Defines what events to count. Registered as an accumulator predicate at config-load time.");
+var EventCountConditionZ = external_exports.object({
+  type: external_exports.literal("event_count"),
+  key: external_exports.string().describe("Unique key for this counter (used for accumulator registration)"),
+  operator: external_exports.enum(["gte", "lte", "eq", "gt", "lt"]),
+  count: external_exports.number().int().min(0).describe("Target count threshold"),
+  withinMs: external_exports.number().positive().optional().describe("Time window in ms. Omit = count across entire session."),
+  counter: CounterDefZ.optional().describe("Inline counter definition. Defines what events to count.")
+}).describe('Fires when accumulated event count crosses a threshold. Most powerful trigger type. Example: {"type": "event_count", "key": "pricing-clicks", "operator": "gte", "count": 3, "counter": {"events": ["ui.click"], "match": {"attr__data-cta": {"contains": "pricing"}}}}');
+var ConditionZ = external_exports.discriminatedUnion("type", [
+  PageUrlConditionZ,
+  RouteConditionZ,
+  AnchorVisibleConditionZ,
+  EventOccurredConditionZ,
+  StateEqualsConditionZ,
+  ViewportConditionZ,
+  SessionMetricConditionZ,
+  DismissedConditionZ,
+  CooldownActiveConditionZ,
+  FrequencyLimitConditionZ,
+  EventCountConditionZ
+]);
+var RuleZ = external_exports.object({
+  conditions: external_exports.array(ConditionZ).describe("Array of conditions \u2014 ALL must match (AND logic) for this rule to fire."),
+  value: external_exports.unknown().describe("Value returned when all conditions match. For triggerWhen: true = fire the action.")
+}).describe("A single rule. ALL conditions must match (AND logic). Rules in a strategy are evaluated top-to-bottom \u2014 first rule where all conditions match wins and returns its value.");
+var RuleStrategyZ = external_exports.object({
+  type: external_exports.literal("rules"),
+  rules: external_exports.array(RuleZ).describe("Ordered list of rules. Evaluated top-to-bottom \u2014 first match wins."),
+  default: external_exports.unknown().describe("Fallback value when no rule matches. For triggerWhen: false = do not fire by default.")
+}).describe("Rule-based strategy. Evaluates rules top-to-bottom. First rule where ALL conditions match returns its value. If no rule matches, returns default. For triggerWhen: set value=true on matching rules, default=false.");
+var ScoreStrategyZ = external_exports.object({
+  type: external_exports.literal("score"),
+  field: external_exports.string(),
+  threshold: external_exports.number(),
+  above: external_exports.unknown(),
+  below: external_exports.unknown()
+}).describe("Score-based strategy. Compares a field value against a threshold.");
+var ModelStrategyZ = external_exports.object({
+  type: external_exports.literal("model"),
+  modelId: external_exports.string(),
+  inputs: external_exports.array(external_exports.string()),
+  outputMapping: external_exports.record(external_exports.string(), external_exports.unknown()),
+  default: external_exports.unknown()
+}).describe("ML model strategy. Sends inputs to a model and maps outputs.");
+var ExternalStrategyZ = external_exports.object({
+  type: external_exports.literal("external"),
+  endpoint: external_exports.string(),
+  method: external_exports.enum(["GET", "POST"]).optional(),
+  default: external_exports.unknown(),
+  timeoutMs: external_exports.number().optional()
+}).describe("External API strategy. Calls an endpoint to determine the value.");
+var DecisionStrategyZ = external_exports.discriminatedUnion("type", [
+  RuleStrategyZ,
+  ScoreStrategyZ,
+  ModelStrategyZ,
+  ExternalStrategyZ
+]);
+var TriggerWhenZ = DecisionStrategyZ.nullable().optional();
+var EventScopeZ = external_exports.object({
+  events: external_exports.array(external_exports.string()),
+  urlContains: external_exports.string().optional(),
+  props: external_exports.record(external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean()])).optional()
+});
+var NotifyZ = external_exports.object({
+  title: external_exports.string().optional().describe("Notification title"),
+  body: external_exports.string().optional().describe("Notification body text"),
+  icon: external_exports.string().optional().describe("Notification icon (emoji or URL)")
+}).describe("Optional toast notification shown when this action triggers.").nullable().optional();
+
 // src/reviewsFlip.ts
 import { html as html2, LitElement as LitElement2, nothing as nothing2 } from "lit";
 import { styleMap as styleMap2 } from "lit/directives/style-map.js";
@@ -526,6 +1066,7 @@ function reviewOneLiner(review) {
   const body = (review.body ?? "").trim().replace(/\s+/g, " ");
   return body.length > 90 ? `${body.slice(0, 89)}\u2026` : body;
 }
+var REVIEWS_FLIP_WIDGET_ID = "adaptive-reviews:reviews-flip";
 function defaultLoadReviewsByIds(ids) {
   const authedFetch = window.SynOS?.authedFetch;
   if (!authedFetch) {
@@ -599,20 +1140,49 @@ var SyntroReviewsFlip = class extends LitElement2 {
     }
     this._isLoading = true;
     this._error = null;
+    const startedAt = performance.now();
     try {
       const loader = this.loadReviewsByIds ?? defaultLoadReviewsByIds;
       const data = await loader(ids);
       if (requestId !== this._requestId) return;
       const byId = new Map(data.reviews.map((r) => [r.id, r]));
       this._reviews = ids.map((id) => byId.get(id)).filter((r) => Boolean(r));
+      this._reportLoad(startedAt, "ok", ids.length, this._reviews.length);
     } catch {
       if (requestId !== this._requestId) return;
       this._reviews = [];
       this._error = "Reviews are unavailable";
+      this._reportLoad(startedAt, "error", ids.length, 0);
     } finally {
       if (requestId === this._requestId) this._isLoading = false;
     }
   }
+  /**
+   * Report how long this load took. The reviews fetch is the network wait
+   * between the concierge mounting this tile and the shopper seeing it
+   * (BUG-1784767817 was a 30 s hang here), so it goes to telemetry on every
+   * load rather than living only in the promotion playbook. Superseded loads
+   * report nothing: their result is never shown.
+   */
+  _reportLoad(startedAt, outcome, requested, received) {
+    this.dispatchEvent(
+      new CustomEvent(TELEMETRY_DOM_EVENT, {
+        detail: {
+          name: "syntro_tile_data_received",
+          props: {
+            tile_id: this._scopeId,
+            tile_kind: REVIEWS_FLIP_WIDGET_ID,
+            total_ms: Math.round(performance.now() - startedAt),
+            outcome,
+            requested,
+            received
+          }
+        },
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
   _applyPendingFocus() {
     if (this._pendingFocus === null) return;
     const target = this._pendingFocus;
@@ -814,9 +1384,11 @@ var SyntroReviewsFlip = class extends LitElement2 {
   }
   _starsStyles() {
     return {
-      // Brand accent — the SAME token the FAQ uses for its primary marks, so the
-      // rating follows the workspace brand (not a hardcoded blue).
-      color: "var(--sc-color-primary, #723b32)",
+      // Brand accent, the SAME token the FAQ uses for its primary marks, so
+      // the rating follows the workspace brand (not a hardcoded blue). On a
+      // host card the accent is ink on the CHAT APP's ground, where it is only
+      // a contrast risk, so the host's own ink wins when it sent one.
+      color: "var(--sc-host-link-color, var(--sc-color-primary, #723b32))",
       fontSize: "13px",
       lineHeight: "18px",
       whiteSpace: "nowrap"
@@ -904,7 +1476,6 @@ if (!customElements.get("syntro-reviews-flip")) {
 // src/runtime.ts
 var REVIEWS_ADAPTIVE_APP_ID = "adaptive-reviews";
 var REVIEWS_ADAPTIVE_WIDGET_ID = "adaptive-reviews:reviews";
-var REVIEWS_FLIP_WIDGET_ID = "adaptive-reviews:reviews-flip";
 function asPositiveLimit(value) {
   const numeric = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
   if (!Number.isFinite(numeric)) return void 0;
@@ -1008,13 +1579,41 @@ var reviewsAdaptiveRuntime = runtime;
 var runtime_default = runtime;
 
 export {
+  REVIEWS_FLIP_WIDGET_ID,
   REVIEWS_ADAPTIVE_APP_ID,
   REVIEWS_ADAPTIVE_WIDGET_ID,
-  REVIEWS_FLIP_WIDGET_ID,
   reviewsWidget,
   reviewsFlipWidget,
   runtime,
   reviewsAdaptiveRuntime,
   runtime_default
 };
-//# sourceMappingURL=chunk-ATGQNO24.js.map
+/*! Bundled license information:
+
+@lit/context/lib/context-request-event.js:
+@lit/context/lib/create-context.js:
+@lit/context/lib/controllers/context-consumer.js:
+@lit/context/lib/value-notifier.js:
+@lit/context/lib/controllers/context-provider.js:
+@lit/context/lib/context-root.js:
+  (**
+   * @license
+   * Copyright 2021 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+
+@lit/context/lib/decorators/provide.js:
+  (**
+   * @license
+   * Copyright 2017 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+
+@lit/context/lib/decorators/consume.js:
+  (**
+   * @license
+   * Copyright 2022 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+*/
+//# sourceMappingURL=chunk-M64YCKZP.js.map