@syntrologie/adapt-faq 2.8.0-canary.37 → 2.8.0-canary.371

package/dist/FAQWidgetLit.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Adaptive FAQ - FAQWidgetLit
+ *
+ * Lit web component equivalent of FAQWidget.tsx.
+ * Renders a collapsible Q&A accordion with search, category grouping,
+ * feedback, and markdown rendering — all as a custom element with no
+ * Shadow DOM (light DOM via createRenderRoot).
+ *
+ * Tag name: <syntro-faq-accordion>
+ *
+ * Decorator-free: uses `static override properties` (tsconfig has no
+ * experimentalDecorators).
+ */
+import { LitElement, nothing } from 'lit';
+import type { FAQWidgetRuntime } from './faq-types';
+import type { FAQConfig, FeedbackValue } from './types';
+/**
+ * <syntro-faq-accordion> — light-DOM Lit web component.
+ *
+ * Set properties imperatively (no attribute serialisation for objects):
+ *   el.faqConfig = { expandBehavior: 'single', ... };
+ *   el.runtime   = runtimeInstance;
+ *   el.instanceId = 'my-faq';
+ */
+export declare class FAQAccordionElement extends LitElement {
+    static properties: {
+        faqConfig: {
+            attribute: boolean;
+        };
+        runtime: {
+            attribute: boolean;
+        };
+        instanceId: {
+            type: StringConstructor;
+        };
+        _openId: {
+            state: boolean;
+        };
+        _highlightId: {
+            state: boolean;
+        };
+        _searchQuery: {
+            state: boolean;
+        };
+        _feedbackState: {
+            state: boolean;
+        };
+        _hoveredId: {
+            state: boolean;
+        };
+    };
+    faqConfig: FAQConfig;
+    runtime: FAQWidgetRuntime | null;
+    instanceId: string;
+    _openId: string | null;
+    _highlightId: string | null;
+    _searchQuery: string;
+    _feedbackState: Map<string, FeedbackValue>;
+    _hoveredId: string | null;
+    private _unsubContext;
+    private _unsubAccumulator;
+    private _unsubCta;
+    private _unsubDeepLink;
+    private _unsubSessionMetrics;
+    private _highlightTimer;
+    private _unsubCompositional;
+    private _tileId;
+    /** Instance ids already appended via the compositional bus — dedups
+     *  the subscribe-then-replay path (and re-subscribes on runtime change). */
+    private _llmAppendedIds;
+    createRenderRoot(): this;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    updated(changedProps: Map<string, unknown>): void;
+    private _subscribeAll;
+    /**
+     * Subscribe to `element.compositional_*` events targeting this accordion's
+     * tile, and ask the element store to replay any items it already holds for
+     * us (covers the case where the accordion mounts AFTER the item did — the
+     * inline-slot hydration race that otherwise silently drops the question).
+     */
+    private _subscribeCompositional;
+    /** Tile id for compositional filtering: the enclosing tile card's
+     *  `data-tile-id` (set by SyntroTileCard), falling back to `instanceId`
+     *  when the accordion is mounted outside a tile card. */
+    private _resolveTileId;
+    /** Append (or prepend) a faq:question the LLM mounted. The wire shape is a
+     *  fully-formed `{kind, config}` envelope, so we store it verbatim. */
+    private _insertItem;
+    /** Replace an existing question's content (full replacement). */
+    private _patchItem;
+    /** Remove a question by instance id. */
+    private _removeItem;
+    private _unsubscribeAll;
+    /**
+     * Master→detail takeover: tapping a list row opens its single-Q&A detail
+     * view (the whole widget swaps), so a long answer fills — and never
+     * overflows — the bounded velvet tile. There is no simultaneous multi-expand;
+     * one question owns the tile at a time.
+     */
+    private _handleOpen;
+    /** Back affordance: return from the detail view to the full list. */
+    private _handleBack;
+    private _handleFeedback;
+    /**
+     * Unified render list. Merges compositionally-appended rows
+     * (`faqConfig.actions`, the container-then-stream path) with atomically
+     * authored rows (`faqConfig.questions`, the struct_list path) normalized
+     * into the same `FAQQuestionAction` shape. The atomic path is how the LLM
+     * mounts a complete FAQ in one call — so it renders whole, never empty.
+     */
+    private _allQuestions;
+    private _visibleQuestions;
+    private _orderedQuestions;
+    private _filteredQuestions;
+    private _categoryGroups;
+    private _renderAnswer;
+    private _renderFeedback;
+    /**
+     * LIST-view row. A tappable question with its chevron \u2014 but NO inline answer
+     * body. Tapping it takes over the tile with the question's detail view (see
+     * {@link _renderDetail}). Keeps the per-row look/markers/highlight from the
+     * old accordion minus the inline-expanded answer that overflowed the tile.
+     */
+    private _renderItem;
+    private _renderItems;
+    /**
+     * DETAIL view \u2014 the master\u2192detail takeover. Renders ONLY the open question:
+     * a back affordance, the question prominently, and its full answer via the
+     * SAME {@link _renderAnswer}/`renderAnswerHtml` path (all answer formats still
+     * work). The answer area scrolls if extremely long, so a single answer fills
+     * the bounded velvet tile and never pushes content past the `overflow:hidden`
+     * clip.
+     */
+    private _renderDetail;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+}
+export default FAQAccordionElement;
+//# sourceMappingURL=FAQWidgetLit.d.ts.map

package/dist/FAQWidgetLit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAQWidgetLit.d.ts","sourceRoot":"","sources":["../src/FAQWidgetLit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAQ,UAAU,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAKhD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAEV,SAAS,EAGT,aAAa,EACd,MAAM,SAAS,CAAC;AAkDjB;;;;;;;GAOG;AACH,qBAAa,mBAAoB,SAAQ,UAAU;IAKjD,OAAgB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;MAcxB;IAMF,SAAS,EAAE,SAAS,CAKlB;IAEF,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAAQ;IAExC,UAAU,EAAE,MAAM,CAAgB;IAMlC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAQ;IAC9B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAQ;IACnC,YAAY,EAAE,MAAM,CAAM;IAC1B,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAa;IACvD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAQ;IAGjC,OAAO,CAAC,aAAa,CAA6B;IAClD,OAAO,CAAC,iBAAiB,CAA6B;IACtD,OAAO,CAAC,SAAS,CAA6B;IAC9C,OAAO,CAAC,cAAc,CAA6B;IACnD,OAAO,CAAC,oBAAoB,CAA6B;IACzD,OAAO,CAAC,eAAe,CAA8C;IAMrE,OAAO,CAAC,mBAAmB,CAA6B;IACxD,OAAO,CAAC,OAAO,CAAuB;IACtC;gFAC4E;IAC5E,OAAO,CAAC,eAAe,CAA0B;IAMxC,gBAAgB;IAQhB,iBAAiB;IAKjB,oBAAoB;IAUpB,OAAO,CAAC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC;IAWnD,OAAO,CAAC,aAAa;IAmHrB;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB;IAyB/B;;6DAEyD;IACzD,OAAO,CAAC,cAAc;IAOtB;2EACuE;IACvE,OAAO,CAAC,WAAW;IAcnB,iEAAiE;IACjE,OAAO,CAAC,UAAU;IAgBlB,wCAAwC;IACxC,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,eAAe;IAmBvB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAWnB,qEAAqE;IACrE,OAAO,CAAC,WAAW;IAcnB,OAAO,CAAC,eAAe;IAYvB;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IA4BrB,OAAO,CAAC,iBAAiB;IASzB,OAAO,CAAC,iBAAiB;IAOzB,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,eAAe;IAgBvB,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,eAAe;IAsCvB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAoDnB,OAAO,CAAC,YAAY;IAIpB;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IAuDZ,MAAM;CAoJhB;AAUD,eAAe,mBAAmB,CAAC"}

package/dist/FAQWidgetLit.editable.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Adaptive FAQ - FAQWidgetLit.editable
+ *
+ * Editable variant of the FAQ accordion for the canvas editor surface.
+ * Renders the same Q&A rows as <syntro-faq-accordion> but adds:
+ *   - Pencil button per row (shows on hover, calls controller.editItem on click)
+ *   - Click on question text expands/collapses to show the answer (normal FAQ behavior)
+ *   - Drag handle per row when items.length >= 2
+ *   - Drag-and-drop reorder via the sortable utility (injected via mount config)
+ *   - Read-only fallback when controller is null
+ *
+ * Tag name: <syntro-faq-accordion-editable>
+ *
+ * Decorator-free: uses `static override properties` (matches codebase convention).
+ * Light DOM: inherits host-page CSS variables (same as <syntro-faq-accordion>).
+ *
+ * Cross-package import safety:
+ *   The controller is typed as a structural `ControllerLike` interface defined
+ *   locally — NOT imported from @syntrologie/editor-sdk. This prevents a
+ *   dependency cycle (editor-sdk imports adapt-faq's editable; adapt-faq cannot
+ *   import editor-sdk). The real EditModeController satisfies ControllerLike
+ *   structurally.
+ *
+ *   Similarly, `makeSortable` is passed in as a `SortableFn` option rather than
+ *   imported directly. The editor-sdk bootstrap (setupEditModeBootstrap.ts) threads
+ *   the real makeSortable through the FAQWidgetLitEditableMountable.mount() call.
+ *   This is Alternative C from the architecture decision log, and matches the
+ *   structural-interface pattern already used for the controller.
+ */
+import { LitElement } from 'lit';
+import type { FAQConfig } from './types';
+/**
+ * Structural interface — describes only the methods the editable widget needs.
+ * The real EditModeController satisfies this by structural subtyping.
+ *
+ * `tileId` (the host tile's id, threaded in via `instanceId` at mount) scopes
+ * controller calls to the active tile when a canvas has multiple FAQ tiles.
+ * It is optional so single-tile and v2 actions-shape canvases continue to work.
+ */
+export interface ControllerLike {
+    editItem(adaptive: string, itemId: string, tileId?: string): void;
+    editContainer(adaptive: string, tileId?: string): void;
+    isModalOpen(): boolean;
+    reorderItems(adaptive: string, newOrder: string[], tileId?: string): void;
+}
+/** Return value from makeSortable. */
+export interface SortableHandle {
+    destroy(): void;
+}
+/** Options subset that FAQAccordionEditableElement passes into the sortable. */
+export interface SortableOptions {
+    itemSelector: string;
+    handleSelector: string;
+    getItems: () => string[];
+    onReorder: (newOrder: string[]) => void;
+    liveRegion: HTMLElement;
+}
+/**
+ * Structural type matching `makeSortable` from editor-sdk's sortable.ts.
+ * Injected at mount time by FAQWidgetLitEditableMountable.
+ */
+export type SortableFn = (host: HTMLElement, opts: SortableOptions) => SortableHandle;
+/**
+ * <syntro-faq-accordion-editable> — light-DOM Lit element.
+ *
+ * Set properties imperatively (no attribute serialisation for objects):
+ *   el.faqConfig = { ... };
+ *   el.controller = editModeControllerInstance;  // null → read-only
+ */
+export declare class FAQAccordionEditableElement extends LitElement {
+    static properties: {
+        faqConfig: {
+            attribute: boolean;
+        };
+        controller: {
+            attribute: boolean;
+        };
+        tileId: {
+            attribute: boolean;
+        };
+        _hoveredId: {
+            state: boolean;
+        };
+        _expandedId: {
+            state: boolean;
+        };
+        _containerHovered: {
+            state: boolean;
+        };
+    };
+    faqConfig: FAQConfig;
+    /** Null when loaded without an editor context — renders read-only accordion. */
+    controller: ControllerLike | null;
+    /**
+     * Host tile id, threaded in via the mountable's `instanceId`. Scopes every
+     * controller call so the right tile is targeted when the canvas has more
+     * than one FAQ tile (per-route FAQs). Empty string when unknown.
+     */
+    tileId: string;
+    /**
+     * The `makeSortable` factory to use. Injected by FAQWidgetLitEditableMountable
+     * from the editor-sdk bootstrap so there is no direct import from editor-sdk
+     * into this package (which would create a circular dependency).
+     *
+     * Null when running without the editor context (read-only mode).
+     */
+    sortable: SortableFn | null;
+    /**
+     * Shared aria-live region from the modal host, threaded in via mount config.
+     * Falls back to a detached element when running outside the editor context.
+     *
+     * TODO(phase-2-a11y): wire shared live region from modal host for real a11y.
+     */
+    liveRegion: HTMLElement | null;
+    _hoveredId: string | null;
+    _expandedId: string | null;
+    _containerHovered: boolean;
+    private _sortableHandle;
+    createRenderRoot(): this;
+    connectedCallback(): void;
+    /**
+     * Wire (or re-wire) the sortable whenever the properties it depends on change.
+     * `updated()` fires after every render, including the first, so we don't need
+     * a separate `firstUpdated()` call — using `updated()` alone avoids a double
+     * attach on mount (firstUpdated + updated both fire on first render).
+     */
+    protected updated(changed: Map<string, unknown>): void;
+    disconnectedCallback(): void;
+    private _attachSortable;
+    private _handleEdit;
+    private _handlePencilClick;
+    private _handleContainerEdit;
+    private _toggleExpand;
+    private _renderRow;
+    render(): import("lit-html").TemplateResult<1>;
+}
+/**
+ * Mountable for <syntro-faq-accordion-editable>.
+ *
+ * Follows the same mount pattern as FAQWidgetLitMountable in runtime.ts.
+ * Accepts a `controller` in addition to `faqConfig` so the editor can
+ * wire up the EditModeController at mount time.
+ */
+export declare const FAQWidgetLitEditableMountable: {
+    mount(container: HTMLElement, config?: FAQConfig & {
+        instanceId?: string;
+        controller?: ControllerLike | null;
+        /** makeSortable factory injected by editor-sdk bootstrap. Null → drag disabled. */
+        sortable?: SortableFn | null;
+        /** Shared aria-live region from the modal host for sortable announcements. */
+        liveRegion?: HTMLElement | null;
+    }): () => void;
+};
+//# sourceMappingURL=FAQWidgetLit.editable.d.ts.map

package/dist/FAQWidgetLit.editable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FAQWidgetLit.editable.d.ts","sourceRoot":"","sources":["../src/FAQWidgetLit.editable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAQ,UAAU,EAAW,MAAM,KAAK,CAAC;AAIhD,OAAO,KAAK,EAAE,SAAS,EAAqB,MAAM,SAAS,CAAC;AAM5D;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClE,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvD,WAAW,IAAI,OAAO,CAAC;IACvB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3E;AAMD,sCAAsC;AACtC,MAAM,WAAW,cAAc;IAC7B,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,gFAAgF;AAChF,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,MAAM,EAAE,CAAC;IACzB,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IACxC,UAAU,EAAE,WAAW,CAAC;CACzB;AAED;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,eAAe,KAAK,cAAc,CAAC;AAuJtF;;;;;;GAMG;AACH,qBAAa,2BAA4B,SAAQ,UAAU;IAKzD,OAAgB,UAAU;;;;;;;;;;;;;;;;;;;MASxB;IAMF,SAAS,EAAE,SAAS,CAKlB;IAEF,gFAAgF;IAChF,UAAU,EAAE,cAAc,GAAG,IAAI,CAAQ;IAEzC;;;;OAIG;IACH,MAAM,SAAM;IAEZ;;;;;;OAMG;IACH,QAAQ,EAAE,UAAU,GAAG,IAAI,CAAQ;IAEnC;;;;;OAKG;IACH,UAAU,EAAE,WAAW,GAAG,IAAI,CAAQ;IAEtC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAQ;IACjC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAQ;IAClC,iBAAiB,UAAS;IAM1B,OAAO,CAAC,eAAe,CAA+B;IAM7C,gBAAgB;IAIhB,iBAAiB,IAAI,IAAI;IASlC;;;;;OAKG;cACgB,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAQtD,oBAAoB,IAAI,IAAI;IAMrC,OAAO,CAAC,eAAe;IAuBvB,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,kBAAkB;IAK1B,OAAO,CAAC,oBAAoB;IAM5B,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,UAAU;IA2DT,MAAM;CAuEhB;AAcD;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B;qBAE3B,WAAW,WACb,SAAS,GAAG;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;QACnC,mFAAmF;QACnF,QAAQ,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;QAC7B,8EAA8E;QAC9E,UAAU,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;KACjC;CAkCJ,CAAC"}

package/dist/answerRendering.d.ts

@@ -0,0 +1,4 @@
+import type { FAQAnswer } from './types';
+export declare function getAnswerText(answer: FAQAnswer): string;
+export declare function renderAnswerHtml(answer: FAQAnswer): string;
+//# sourceMappingURL=answerRendering.d.ts.map

package/dist/answerRendering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"answerRendering.d.ts","sourceRoot":"","sources":["../src/answerRendering.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAIzC,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAIvD;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAQ1D"}

package/dist/chunk-5WRI5ZAA.js

@@ -0,0 +1,31 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __toESM
+};
+//# sourceMappingURL=chunk-5WRI5ZAA.js.map

package/dist/chunk-5WRI5ZAA.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/chunk-IGCYULL7.js

@@ -0,0 +1,223 @@
+// ../../sdk-contracts/dist/mount-plumbing.js
+var MOUNT_PLUMBING_KEYS = ["instanceId", "runtime", "tileId"];
+function stripMountPlumbing(config) {
+  if (!config || typeof config !== "object") {
+    return {};
+  }
+  const out = { ...config };
+  for (const key of MOUNT_PLUMBING_KEYS) {
+    delete out[key];
+  }
+  return out;
+}
+
+// ../../sdk-contracts/dist/schemas.js
+import { z } from "zod";
+var AnchorIdZ = z.object({
+  selector: z.string(),
+  route: z.union([z.string(), z.array(z.string())])
+}).strict();
+var AuthoringFieldsZ = {
+  id: z.string().optional().describe('Stable action identifier (e.g. "act_3db6a14d2ab0").'),
+  title: z.string().max(200).optional().describe("Authoring-only: short label shown on the action plan dashboard. Stripped before serving to the runtime SDK."),
+  description: z.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: z.array(z.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 = z.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 = z.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 = z.object({
+  type: z.literal("page_url"),
+  url: z.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 = z.object({
+  type: z.literal("route"),
+  routeId: z.string().describe("Named route ID from the route filter")
+}).describe("Fires when the current route matches a named route ID.");
+var AnchorVisibleConditionZ = z.object({
+  type: z.literal("anchor_visible"),
+  anchorId: z.string().describe("CSS selector of the anchor element"),
+  state: z.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 = z.object({
+  type: z.literal("event_occurred"),
+  eventName: z.string().describe('Event name (e.g. "ui.click", "$pageview")'),
+  withinMs: z.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 = z.object({
+  type: z.literal("state_equals"),
+  key: z.string().describe("Key in the SDK persistent state store (localStorage). Only valid for keys the host app explicitly sets via syntro.state.set()."),
+  value: z.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 = z.object({
+  type: z.literal("viewport"),
+  minWidth: z.number().optional().describe("Minimum viewport width in pixels"),
+  maxWidth: z.number().optional().describe("Maximum viewport width in pixels"),
+  minHeight: z.number().optional().describe("Minimum viewport height in pixels"),
+  maxHeight: z.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 = z.object({
+  type: z.literal("session_metric"),
+  key: SessionMetricKeyZ,
+  operator: z.enum(["gte", "lte", "eq", "gt", "lt"]),
+  threshold: z.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 = z.object({
+  type: z.literal("dismissed"),
+  key: z.string().describe("Dismissal key (usually a tile or action ID)"),
+  inverted: z.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 = z.object({
+  type: z.literal("cooldown_active"),
+  key: z.string().describe("Cooldown key"),
+  inverted: z.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 = z.object({
+  type: z.literal("frequency_limit"),
+  key: z.string().describe("Frequency counter key"),
+  limit: z.number().describe("Maximum allowed count"),
+  inverted: z.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 = z.object({
+  equals: z.union([z.string(), z.number(), z.boolean()]).optional(),
+  contains: z.string().optional()
+}).describe("Match operator for counter filters. Exactly one of equals or contains must be specified.");
+var CounterDefZ = z.object({
+  events: z.array(CountableEventZ).min(1).describe("Event names to count. Use values from the countable events enum."),
+  match: z.record(z.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 = z.object({
+  type: z.literal("event_count"),
+  key: z.string().describe("Unique key for this counter (used for accumulator registration)"),
+  operator: z.enum(["gte", "lte", "eq", "gt", "lt"]),
+  count: z.number().int().min(0).describe("Target count threshold"),
+  withinMs: z.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 = z.discriminatedUnion("type", [
+  PageUrlConditionZ,
+  RouteConditionZ,
+  AnchorVisibleConditionZ,
+  EventOccurredConditionZ,
+  StateEqualsConditionZ,
+  ViewportConditionZ,
+  SessionMetricConditionZ,
+  DismissedConditionZ,
+  CooldownActiveConditionZ,
+  FrequencyLimitConditionZ,
+  EventCountConditionZ
+]);
+var RuleZ = z.object({
+  conditions: z.array(ConditionZ).describe("Array of conditions \u2014 ALL must match (AND logic) for this rule to fire."),
+  value: z.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 = z.object({
+  type: z.literal("rules"),
+  rules: z.array(RuleZ).describe("Ordered list of rules. Evaluated top-to-bottom \u2014 first match wins."),
+  default: z.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 = z.object({
+  type: z.literal("score"),
+  field: z.string(),
+  threshold: z.number(),
+  above: z.unknown(),
+  below: z.unknown()
+}).describe("Score-based strategy. Compares a field value against a threshold.");
+var ModelStrategyZ = z.object({
+  type: z.literal("model"),
+  modelId: z.string(),
+  inputs: z.array(z.string()),
+  outputMapping: z.record(z.string(), z.unknown()),
+  default: z.unknown()
+}).describe("ML model strategy. Sends inputs to a model and maps outputs.");
+var ExternalStrategyZ = z.object({
+  type: z.literal("external"),
+  endpoint: z.string(),
+  method: z.enum(["GET", "POST"]).optional(),
+  default: z.unknown(),
+  timeoutMs: z.number().optional()
+}).describe("External API strategy. Calls an endpoint to determine the value.");
+var DecisionStrategyZ = z.discriminatedUnion("type", [
+  RuleStrategyZ,
+  ScoreStrategyZ,
+  ModelStrategyZ,
+  ExternalStrategyZ
+]);
+var TriggerWhenZ = DecisionStrategyZ.nullable().optional();
+var EventScopeZ = z.object({
+  events: z.array(z.string()),
+  urlContains: z.string().optional(),
+  props: z.record(z.union([z.string(), z.number(), z.boolean()])).optional()
+});
+var NotifyZ = z.object({
+  title: z.string().optional(),
+  body: z.string().optional(),
+  icon: z.string().optional()
+}).nullable().optional();
+
+// ../../../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/routes.js
+var utf8Decoder = new TextDecoder("utf-8", { fatal: false });
+
+export {
+  stripMountPlumbing,
+  AnchorIdZ,
+  AuthoringFieldsZ,
+  DecisionStrategyZ,
+  TriggerWhenZ,
+  NotifyZ
+};
+/*! 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-IGCYULL7.js.map