@syntrologie/adapt-chatbot 2.27.0 → 2.29.0

package/dist/elements/envelope.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Helpers for decoding AG-UI custom event payloads — Phase 6b.
+ *
+ * `AgUiTransport.onA2UIEvent` historically forwarded the raw `event.value`
+ * payload as an `ActionStep` directly to `runtime.actions.applyBatch`.
+ * Phase 5's backend now also emits `syntro.element.mutation` envelopes
+ * (mounts/patches/unmounts authored by the LLM via `mount_element` &c.),
+ * which the SDK routes to `ElementInstanceStore.apply` instead.
+ *
+ * Discrimination is by the envelope's `type` field. Non-element payloads
+ * (raw ActionStep, A2UI `createSurface` / `updateDataModel` envelopes
+ * from any A2UI integration) fall through to the legacy path.
+ */
+import type { ElementMutation } from './types';
+/**
+ * Returns the mutations array if `payload` is a well-formed
+ * `syntro.element.mutation` envelope, otherwise `null`.
+ *
+ * Validates only the discriminator + the structural shape needed to
+ * route to the store. Per-mutation validation lives in the store / its
+ * type handlers (defense in depth), so this stays small.
+ */
+export declare function decodeMutationEnvelope(payload: unknown): ElementMutation[] | null;
+//# sourceMappingURL=envelope.d.ts.map

package/dist/elements/envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../../src/elements/envelope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAoB,MAAM,SAAS,CAAC;AAEjE;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,eAAe,EAAE,GAAG,IAAI,CAOjF"}

package/dist/elements/fetcher.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Boot-time fetcher for `GET /api/adaptive/mounted_elements`.
+ *
+ * Follows the SDK's vanilla-fetch convention (see
+ * `packages/runtime-sdk/src/overlays/fetcher.ts` for the sibling pattern
+ * — no shared HTTP client, no axios, no fetch wrapper).
+ *
+ * Auth: forwards the SDK token from `window.__SYNTRO_CONFIG__.token`
+ * as a Bearer header, plus the runtime's visitor ids (`X-Distinct-Id` /
+ * `X-Syntro-Session`) so the backend rehydrates mounts under the same
+ * session-keyed Redis state the chat persisted to.
+ *
+ * 404 contract: the backend returns 404 only when the workspace's SDK
+ * token doesn't resolve to a workspace. The SDK treats 404 as
+ * "feature unavailable" — no error UI, no retries — per the design doc.
+ * Network errors are logged + swallowed so the SDK boot path stays
+ * resilient to backend hiccups.
+ */
+import type { MountedElementsResponse } from './types';
+export interface FetchMountedElementsOptions {
+    /** Override the endpoint URL (defaults to same-origin
+     *  `/api/adaptive/mounted_elements`). Tests + multi-environment
+     *  deploys use this. */
+    endpoint?: string;
+    /** SDK token. Defaults to `window.__SYNTRO_CONFIG__.token`. */
+    token?: string;
+    /** Custom fetch implementation — used by tests to mock the network. */
+    fetchImpl?: typeof fetch;
+    /** Logger — used by tests to capture log output. */
+    logger?: Pick<Console, 'warn'>;
+}
+/**
+ * Fetch the visitor's currently-mounted elements + session expiry.
+ *
+ * Returns `null` on any failure (404, network error, malformed JSON,
+ * etc.). The caller treats `null` as "feature unavailable, no
+ * rehydrate" — boot continues normally with an empty element store.
+ */
+export declare function fetchMountedElements(options?: FetchMountedElementsOptions): Promise<MountedElementsResponse | null>;
+//# sourceMappingURL=fetcher.d.ts.map

package/dist/elements/fetcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetcher.d.ts","sourceRoot":"","sources":["../../src/elements/fetcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAIvD,MAAM,WAAW,2BAA2B;IAC1C;;4BAEwB;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+DAA+D;IAC/D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uEAAuE;IACvE,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IACzB,oDAAoD;IACpD,MAAM,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;CAChC;AAED;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC,CA2DzC"}

package/dist/elements/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Element-instantiation machinery for the adaptive chatbot.
+ *
+ * Originally added in runtime-sdk; moved here in two passes:
+ *  - Phase 6c: store / handlers / fetcher / envelope / wire types
+ *    (every consumer was the chat surface).
+ *  - Phase 6c.1: Portable Text vocab + safe renderer (`renderBlocks`,
+ *    `BlockNode`, etc.). Generic by shape but zero non-chat consumers
+ *    in practice, so leaving it in the universal CDN bundle made every
+ *    non-chat customer pay the bundle cost for nothing — the
+ *    runtime-as-OS principle says don't ship interfaces with no
+ *    consumers in the universal bundle.
+ *
+ * If a second adaptive ever needs Portable Text rendering, promote
+ * `blocks.ts` + `blockRenderer.ts` to a leaf shared package
+ * (`@syntrologie/portable-text`) and have both consumers depend on it.
+ * Do NOT push it back into runtime-sdk.
+ */
+export { ActionHandler } from './ActionHandler';
+export type { RenderOptions } from './blockRenderer';
+export { renderBlocks } from './blockRenderer';
+export type { BlockNode, CodeBlock, HeadingBlock, HeadingLevel, LinkMark, ListBlock, ListItemBlock, ListStyle, MarkType, ParagraphBlock, TextSpan, } from './blocks';
+export { ElementInstanceStore } from './ElementInstanceStore';
+export type { ElementHandlerContext, ElementLifecycle, ElementMutationContext, ElementTypeHandler, ValidateResult, } from './ElementTypeHandler';
+export { decodeMutationEnvelope } from './envelope';
+export type { FetchMountedElementsOptions } from './fetcher';
+export { fetchMountedElements } from './fetcher';
+export type { CompositionalAppendEvent, CompositionalPatchEvent, CompositionalRemoveEvent, } from './ItemHandler';
+export { COMPOSITIONAL_APPEND_EVENT, COMPOSITIONAL_PATCH_EVENT, COMPOSITIONAL_REMOVE_EVENT, ItemHandler, } from './ItemHandler';
+export { getElementInstanceStore, setElementInstanceStore } from './store-singleton';
+export { TileHandler } from './TileHandler';
+export type { AgentProvenance, ElementMutation, ElementState, MountedElement, MountedElementsResponse, MountMutation, Mutation, MutationEnvelope, NoPlacement, ParentTilePlacement, PatchMutation, Placement, SelectorPlacement, SlotPlacement, UnmountMutation, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/elements/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/elements/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,YAAY,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,YAAY,EACV,SAAS,EACT,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,QAAQ,EACR,SAAS,EACT,aAAa,EACb,SAAS,EACT,QAAQ,EACR,cAAc,EACd,QAAQ,GACT,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,YAAY,EACV,qBAAqB,EACrB,gBAAgB,EAChB,sBAAsB,EACtB,kBAAkB,EAClB,cAAc,GACf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACpD,YAAY,EAAE,2BAA2B,EAAE,MAAM,WAAW,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AACjD,YAAY,EACV,wBAAwB,EACxB,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,0BAA0B,EAC1B,WAAW,GACZ,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AACrF,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EACV,eAAe,EACf,eAAe,EACf,YAAY,EACZ,cAAc,EACd,uBAAuB,EACvB,aAAa,EACb,QAAQ,EACR,gBAAgB,EAChB,WAAW,EACX,mBAAmB,EACnB,aAAa,EACb,SAAS,EACT,iBAAiB,EACjB,aAAa,EACb,eAAe,GAChB,MAAM,SAAS,CAAC"}

package/dist/elements/store-singleton.d.ts

@@ -0,0 +1,4 @@
+import type { ElementInstanceStore } from './ElementInstanceStore';
+export declare function setElementInstanceStore(store: ElementInstanceStore | null): void;
+export declare function getElementInstanceStore(): ElementInstanceStore | null;
+//# sourceMappingURL=store-singleton.d.ts.map

package/dist/elements/store-singleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-singleton.d.ts","sourceRoot":"","sources":["../../src/elements/store-singleton.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAInE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,oBAAoB,GAAG,IAAI,GAAG,IAAI,CAEhF;AAED,wBAAgB,uBAAuB,IAAI,oBAAoB,GAAG,IAAI,CAErE"}

package/dist/elements/types.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Wire types for LLM-authored UI element instantiation — Phase 6.
+ *
+ * These mirror the backend Pydantic models in
+ * `platform/backend/app/services/agents/elements_models.py`. Kept as
+ * plain TypeScript types (no Zod validators) for v1 — the SDK trusts
+ * what it fetches from the workspace's own backend per the design doc's
+ * "backend is the sole enforcer" stance. Add Zod here if defence-in-depth
+ * ever becomes a real concern.
+ *
+ * Wire format documented in
+ * `docs/plans/current/2026-05-24-adaptive-chatbot-action-triggers-design.md`.
+ */
+export type ElementState = 'active' | 'applied' | 'reverted' | 'expired';
+export interface AgentProvenance {
+    agent_id: string;
+    turn_id: string;
+}
+export interface Mutation {
+    op: 'mount' | 'patch' | 'unmount';
+    at: string;
+    by: AgentProvenance;
+    paths?: string[];
+}
+export interface SlotPlacement {
+    type: 'slot';
+    slot: string;
+}
+export interface SelectorPlacement {
+    type: 'selector';
+    selector: string;
+    position: 'beforebegin' | 'afterbegin' | 'beforeend' | 'afterend' | 'replace' | 'modify';
+}
+export interface NoPlacement {
+    type: 'none';
+}
+/**
+ * Compositional-item placement — for chips, FAQ items, nav tips that
+ * mount INSIDE an existing tile's compositional-actions list rather
+ * than occupying their own slot. `tile_id` references a tile by its
+ * config-time id (e.g. `hero-chips`); `position` controls insertion
+ * order in the parent's items array.
+ *
+ * Backend mirror: `ParentTilePlacement` in
+ * `platform/backend/app/services/agents/elements_models.py`.
+ */
+export interface ParentTilePlacement {
+    type: 'parent_tile';
+    tile_id: string;
+    position: 'append' | 'prepend';
+}
+export type Placement = SlotPlacement | SelectorPlacement | NoPlacement | ParentTilePlacement;
+export interface MountedElement {
+    instance_id: string;
+    element_type: 'tile' | 'action' | 'item';
+    template_id: string;
+    placement: Placement;
+    content: Record<string, unknown>;
+    state: ElementState;
+    mounted_by: AgentProvenance;
+    mounted_at: string;
+    /** Model-issued id of the tool call that mounted this element — the SDK
+     * anchors the restored element to the transcript message hosting this
+     * call (BUG-1784935730). Absent on pre-existing sessions. */
+    tool_call_id?: string | null;
+    version: number;
+    mutation_log?: Mutation[];
+}
+/**
+ * Live-mutation envelope carried on the `syntro.element.mutation`
+ * AG-UI custom event.
+ */
+export interface MutationEnvelope {
+    type: 'syntro.element.mutation';
+    schema_version: 'v0';
+    mutations: ElementMutation[];
+}
+export type ElementMutation = MountMutation | PatchMutation | UnmountMutation;
+export interface MountMutation {
+    op: 'mount';
+    instance: MountedElement;
+}
+export interface PatchMutation {
+    op: 'patch';
+    instance_id: string;
+    patches: {
+        path: string;
+        value: unknown;
+    }[];
+    expected_version: number;
+    /** New version after patch, sent by the backend. SDK uses this for dedup. */
+    resulting_version: number;
+    /** Full content snapshot after patch — saves the SDK from having to
+     *  apply patches client-side. */
+    resulting_content: Record<string, unknown>;
+}
+export interface UnmountMutation {
+    op: 'unmount';
+    instance_id: string;
+}
+/**
+ * Response shape from `GET /api/adaptive/mounted_elements`. Matches the
+ * backend `MountedElementsResponse` (Phase 4).
+ */
+export interface MountedElementsResponse {
+    mounted_elements: MountedElement[];
+    session_expires_at: string | null;
+    schema_version: 'v0';
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/elements/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/elements/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC;AAEzE,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,eAAe,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,aAAa,GAAG,YAAY,GAAG,WAAW,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;CAC1F;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAC;CAChC;AAED,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG,iBAAiB,GAAG,WAAW,GAAG,mBAAmB,CAAC;AAE9F,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,KAAK,EAAE,YAAY,CAAC;IACpB,UAAU,EAAE,eAAe,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB;;iEAE6D;IAC7D,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,QAAQ,EAAE,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,yBAAyB,CAAC;IAChC,cAAc,EAAE,IAAI,CAAC;IACrB,SAAS,EAAE,eAAe,EAAE,CAAC;CAC9B;AAED,MAAM,MAAM,eAAe,GAAG,aAAa,GAAG,aAAa,GAAG,eAAe,CAAC;AAE9E,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,OAAO,CAAC;IACZ,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,OAAO,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,EAAE,CAAC;IAC5C,gBAAgB,EAAE,MAAM,CAAC;IACzB,6EAA6E;IAC7E,iBAAiB,EAAE,MAAM,CAAC;IAC1B;qCACiC;IACjC,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC5C;AAED,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,SAAS,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,gBAAgB,EAAE,cAAc,EAAE,CAAC;IACnC,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,cAAc,EAAE,IAAI,CAAC;CACtB"}

package/dist/observer/__tests__/allowlist.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Tests for the pure event-allowlist module.
+ *
+ * Each PostHog autocapture event shape maps to either:
+ *   - a templated ObservationEvent ready for transport, or
+ *   - null (drop — not significant).
+ */
+export {};
+//# sourceMappingURL=allowlist.test.d.ts.map

package/dist/observer/__tests__/allowlist.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"allowlist.test.d.ts","sourceRoot":"","sources":["../../../src/observer/__tests__/allowlist.test.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/observer/__tests__/bus-translate.test.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Real-seam tests for the bus-fed observer path.
+ *
+ * On hosts without a `window.posthog` global, click / rage / dead / form
+ * observations reach the chat agent only via the runtime bus, which carries
+ * NORMALIZED events (event-processor's PostHog normalizer). This drives the
+ * ACTUAL translator (`busEventToRawEvent`) into the ACTUAL matcher
+ * (`matchEvent`) with authentic bus-shaped inputs — the exact shape
+ * `packages/event-processor/src/normalizers/posthog.ts` emits.
+ *
+ * Pre-fix, the translator only re-prefixed pathname/url, so matchEvent's
+ * `$autocapture` branch read `$event_type: undefined` → returned null. These
+ * tests fail against that behavior and pass once the mapping is fixed.
+ */
+export {};
+//# sourceMappingURL=bus-translate.test.d.ts.map

package/dist/observer/__tests__/bus-translate.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bus-translate.test.d.ts","sourceRoot":"","sources":["../../../src/observer/__tests__/bus-translate.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}

package/dist/observer/__tests__/lifecycle.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lifecycle.test.d.ts.map

package/dist/observer/__tests__/lifecycle.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.test.d.ts","sourceRoot":"","sources":["../../../src/observer/__tests__/lifecycle.test.ts"],"names":[],"mappings":""}

package/dist/observer/__tests__/observer-enrich.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tests for the observer's per-observation `enrich` hook.
+ *
+ * The chat-bar uses this hook to attach normalized product identity (from the
+ * ACTIVE platform adapter) to click observations before they're queued for the
+ * observation POST. The observer itself stays platform-neutral — it just
+ * applies whatever transform it's given, AFTER matchEvent, BEFORE queueing.
+ */
+export {};
+//# sourceMappingURL=observer-enrich.test.d.ts.map

package/dist/observer/__tests__/observer-enrich.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observer-enrich.test.d.ts","sourceRoot":"","sources":["../../../src/observer/__tests__/observer-enrich.test.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/observer/__tests__/observer-isolation.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Isolation tests for the observer.
+ *
+ * The observer must never include host-page PII in observation text.
+ * PostHog autocapture strips sensitive properties from $elements before
+ * delivery, but we add a belt-and-suspenders check here against text
+ * fields that look like emails, phones, or credit-card patterns.
+ *
+ * If this test ever fails, the templates in allowlist.ts have regressed
+ * — fix there, not by suppressing this test.
+ */
+export {};
+//# sourceMappingURL=observer-isolation.test.d.ts.map

package/dist/observer/__tests__/observer-isolation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observer-isolation.test.d.ts","sourceRoot":"","sources":["../../../src/observer/__tests__/observer-isolation.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}

package/dist/observer/__tests__/queue.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=queue.test.d.ts.map

package/dist/observer/__tests__/queue.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.test.d.ts","sourceRoot":"","sources":["../../../src/observer/__tests__/queue.test.ts"],"names":[],"mappings":""}

package/dist/observer/__tests__/transport.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=transport.test.d.ts.map

package/dist/observer/__tests__/transport.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.test.d.ts","sourceRoot":"","sources":["../../../src/observer/__tests__/transport.test.ts"],"names":[],"mappings":""}

package/dist/observer/allowlist.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pure mapping from raw PostHog events to ObservationEvents.
+ *
+ * One function: matchEvent(raw, opts) → ObservationEvent | null. Null means
+ * "drop, not significant." This module is the single source of truth for what
+ * the chat agent sees on the in-session timeline; the SDK observer never
+ * forwards anything matchEvent returns null for.
+ *
+ * Kept dependency-free (no DOM access, no PostHog SDK imports) so the
+ * Vitest unit tests run without any browser shim.
+ */
+import type { ObservationEvent as ObservationEventContract } from '@syntrologie/runtime-contracts';
+/** The templated event kinds (nav/click/form/rage/…) — the backend enum. */
+export type ObservationKind = ObservationEventContract['kind'];
+/** One templated host-page event — the SDK↔backend wire contract. */
+export type ObservationEvent = ObservationEventContract;
+/** Shape of a raw event reaching matchEvent. Loose by design — PostHog's
+ *  event shape evolves, and we want matchEvent to be resilient to extra
+ *  properties. */
+export interface RawEvent {
+    event: string;
+    timestamp: number;
+    properties: Record<string, unknown>;
+}
+export interface MatchOptions {
+    /** Workspace-configured custom event names to forward as kind="custom". */
+    observableEvents?: readonly string[];
+}
+export declare function matchEvent(raw: RawEvent, opts?: MatchOptions): ObservationEvent | null;
+//# sourceMappingURL=allowlist.d.ts.map

package/dist/observer/allowlist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"allowlist.d.ts","sourceRoot":"","sources":["../../src/observer/allowlist.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,OAAO,KAAK,EAAE,gBAAgB,IAAI,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAEnG,4EAA4E;AAC5E,MAAM,MAAM,eAAe,GAAG,wBAAwB,CAAC,MAAM,CAAC,CAAC;AAE/D,qEAAqE;AACrE,MAAM,MAAM,gBAAgB,GAAG,wBAAwB,CAAC;AAExD;;kBAEkB;AAClB,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AAED,MAAM,WAAW,YAAY;IAC3B,2EAA2E;IAC3E,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AA0ED,wBAAgB,UAAU,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,GAAE,YAAiB,GAAG,gBAAgB,GAAG,IAAI,CAiJ1F"}

package/dist/observer/bus-translate.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Runtime-bus → observer translation.
+ *
+ * On hosts where `window.posthog` isn't exposed as a global, the observer's
+ * PostHog auto-attach is a no-op; instead the chat-bar subscribes to the
+ * SYNTRO runtime event bus and forwards events into the observer's allowlist.
+ *
+ * The catch: bus events have already been NORMALIZED by the event-processor
+ * (see `packages/event-processor/src/normalizers/posthog.ts`). The raw PostHog
+ * `$`-prefixed properties `matchEvent` reads (`$event_type`, `$elements`,
+ * `$element_tag_name`, `$pathname`, `$current_url`) were renamed to
+ * (`—dropped—`, `elements`, `tagName`, `pathname`, `url`) and the click/submit
+ * distinction moved from `$event_type` into the normalized event `name`
+ * (`ui.click` / `ui.submit`). This function re-derives the raw shape so
+ * `matchEvent` — the single source of truth, also fed directly by the
+ * `window.posthog`-global path — stays untouched.
+ */
+import type { RawEvent } from './allowlist';
+/** A normalized event as it arrives on the SYNTRO runtime bus. */
+export interface BusEvent {
+    ts?: number;
+    name?: string;
+    source?: string;
+    props?: Record<string, unknown> & {
+        originalEvent?: string;
+    };
+}
+/**
+ * Translate one bus event into the `RawEvent` the observer allowlist expects,
+ * or null to drop it.
+ */
+export declare function busEventToRawEvent(e: BusEvent): RawEvent | null;
+//# sourceMappingURL=bus-translate.d.ts.map

package/dist/observer/bus-translate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bus-translate.d.ts","sourceRoot":"","sources":["../../src/observer/bus-translate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,kEAAkE;AAClE,MAAM,WAAW,QAAQ;IACvB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;QAAE,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9D;AAoBD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,IAAI,CAyB/D"}

package/dist/observer/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Observer entry point.
+ *
+ * startObserver wires the four pieces — allowlist filter + queue +
+ * transport + PostHog subscription — into a single lifecycle controlled
+ * via the returned handle. The handle is reference-counted: multiple
+ * call sites (e.g. multiple chatbot widgets on the same page) share
+ * one observer.
+ *
+ * Idempotent: calling startObserver twice with equivalent options
+ * returns the same instance. Calling stop() decrements the ref count;
+ * the observer tears down only when the count reaches zero.
+ */
+import { type ObservationEvent, type RawEvent } from './allowlist';
+import { type ObserverStats } from './queue';
+import { type Transport } from './transport';
+export interface StartObserverOptions {
+    url: string;
+    token: () => string;
+    getDistinctId: () => string | null;
+    getSessionId: () => string | null;
+    observableEvents?: readonly string[];
+    /**
+     * Optional per-observation enrichment applied AFTER matchEvent, BEFORE the
+     * observation is queued for POST. Given the matched observation plus the raw
+     * event (element chain intact), returns a possibly-augmented observation —
+     * e.g. attaching normalized product identity from the active platform
+     * adapter. Kept as a generic transform so the observer stays platform-neutral.
+     */
+    enrich?: (ev: ObservationEvent, raw: RawEvent) => ObservationEvent;
+    /** Test seam: override fetch/timer behavior by injecting a custom transport. */
+    transport?: Transport;
+}
+export interface ObserverHandle {
+    stop(): void;
+    stats(): ObserverStats;
+    /** Test seam: ingest a raw event directly without depending on PostHog being loaded. */
+    ingest(raw: RawEvent): void;
+    flushNow(): Promise<void>;
+}
+export declare function startObserver(opts: StartObserverOptions): ObserverHandle;
+/** Test-only: reset module singleton state. */
+export declare function _resetObserverForTests(): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/observer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/observer/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAc,KAAK,gBAAgB,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC/E,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,SAAS,CAAC;AAC5D,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE9D,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IACnC,YAAY,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IAClC,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,gBAAgB,EAAE,GAAG,EAAE,QAAQ,KAAK,gBAAgB,CAAC;IACnE,gFAAgF;IAChF,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,IAAI,IAAI,CAAC;IACb,KAAK,IAAI,aAAa,CAAC;IACvB,wFAAwF;IACxF,MAAM,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC5B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AA2DD,wBAAgB,aAAa,CAAC,IAAI,EAAE,oBAAoB,GAAG,cAAc,CAqCxE;AAsCD,+CAA+C;AAC/C,wBAAgB,sBAAsB,IAAI,IAAI,CAK7C"}

package/dist/observer/queue.d.ts

@@ -0,0 +1,63 @@
+/**
+ * In-memory batching queue for ObservationEvents.
+ *
+ * Holds events until either a size threshold or a time interval triggers
+ * a flush. The flush function is injected so transport choice (fetch vs.
+ * sendBeacon) and auth wiring stay out of this module.
+ *
+ * Backoff strategy: pure exponential, starting at 1s and capping at 30s
+ * (1s → 2s → 4s → 8s → 16s → 30s). Reset on first successful flush.
+ * Jitter is intentionally omitted — the observer queue is per-client, so
+ * thundering-herd at recovery is not a meaningful risk, and deterministic
+ * timing keeps unit tests fast and stable. A "permanent" failure (4xx
+ * marked by the caller) disables the queue entirely — no further flushes
+ * are attempted; lastError is exposed via stats().
+ */
+import type { ObservationEvent } from './allowlist';
+export interface FlushError extends Error {
+    /** When true, the queue stops trying forever. Set by transport for 4xx. */
+    permanent?: boolean;
+}
+export interface ObserverQueueOptions {
+    batchSize: number;
+    flushIntervalMs: number;
+    queueCap: number;
+    flush: (batch: ObservationEvent[]) => Promise<void>;
+    backoffStartMs?: number;
+    backoffCapMs?: number;
+}
+export interface ObserverStats {
+    queued: number;
+    sent: number;
+    dropped: number;
+    lastError: string | null;
+    disabled: boolean;
+}
+export declare class ObserverQueue {
+    private readonly _opts;
+    private readonly _buffer;
+    private _sent;
+    private _dropped;
+    private _lastError;
+    private _disabled;
+    private _intervalTimer;
+    private _backoffTimer;
+    private _currentBackoffMs;
+    private _inFlight;
+    constructor(opts: ObserverQueueOptions);
+    push(event: ObservationEvent): void;
+    flushNow(): Promise<void>;
+    /**
+     * Synchronously hand the newest backend-sized batch to an unload-safe sender.
+     * Returns false when the sender rejected delivery and restores the batch so
+     * the caller can fall back to fetch({ keepalive: true }).
+     */
+    flushOnPageHide(send: (batch: ObservationEvent[]) => boolean): boolean;
+    stats(): ObserverStats;
+    private _scheduleImmediate;
+    private _scheduleInterval;
+    private _clearInterval;
+    private _flush;
+    private _scheduleBackoff;
+}
+//# sourceMappingURL=queue.d.ts.map

package/dist/observer/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../src/observer/queue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,MAAM,WAAW,UAAW,SAAQ,KAAK;IACvC,2EAA2E;IAC3E,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,KAAK,EAAE,gBAAgB,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiC;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAClD,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,aAAa,CAA8C;IACnE,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,SAAS,CAAS;gBAEd,IAAI,EAAE,oBAAoB;IAQtC,IAAI,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI;IAe7B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAK/B;;;;OAIG;IACH,eAAe,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,gBAAgB,EAAE,KAAK,OAAO,GAAG,OAAO;IAkBtE,KAAK,IAAI,aAAa;IAUtB,OAAO,CAAC,kBAAkB;IAM1B,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,cAAc;YAOR,MAAM;IA0BpB,OAAO,CAAC,gBAAgB;CAazB"}

package/dist/observer/transport.d.ts

@@ -0,0 +1,27 @@
+/**
+ * HTTP transport for the observer queue.
+ *
+ * Two send paths:
+ *   - send(batch) — async fetch. Used for normal flushes. Throws on
+ *     non-2xx; sets the FlushError.permanent flag for 4xx so the queue
+ *     stops trying.
+ *   - sendBeacon(batch) — fire-and-forget via navigator.sendBeacon.
+ *     Used on `pagehide` so the last batch survives navigation. No
+ *     error path — beacon failure is invisible by design.
+ *
+ * Auth: same syn_ Bearer token mechanism as /stream. The token is read
+ * via a getter so SDK tokens that rotate live get refreshed naturally.
+ */
+import type { ObservationEvent } from './allowlist';
+export interface TransportOptions {
+    url: string;
+    token: () => string;
+    getDistinctId: () => string | null;
+    getSessionId: () => string | null;
+}
+export interface Transport {
+    send(batch: ObservationEvent[]): Promise<void>;
+    sendBeacon(batch: ObservationEvent[]): boolean;
+}
+export declare function createTransport(opts: TransportOptions): Transport;
+//# sourceMappingURL=transport.d.ts.map

package/dist/observer/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/observer/transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IACnC,YAAY,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;CACnC;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,CAAC,KAAK,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,UAAU,CAAC,KAAK,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAAC;CAChD;AAsBD,wBAAgB,eAAe,CAAC,IAAI,EAAE,gBAAgB,GAAG,SAAS,CA4CjE"}

package/dist/personas.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Chat personas — the "human face" of the concierge (FEAT-1784917430).
+ *
+ * A workspace ships a persona ROSTER in the chat-bar's props (plain config,
+ * like assistantName). Assignment is 50:50 sticky-random per visitor: first
+ * visit picks uniformly, the pick persists in localStorage, and every later
+ * session reuses it — consistency reads as a real team member, not a slot
+ * machine. An invalid/vanished persisted id re-picks (roster changes are
+ * config changes; visitors must never be stranded on a ghost).
+ *
+ * The persona never claims to be human: the header carries an explicit
+ * "AI concierge" microline (see renderHeader) and the server threads the
+ * no-human-claim rule into the prompt (Moffatt/R-001 lineage).
+ */
+export interface PersonaAvatar {
+    sm?: string;
+    md?: string;
+    lg?: string;
+}
+export interface ChatPersona {
+    id: string;
+    name: string;
+    role_title?: string;
+    pronouns?: string;
+    avatar?: PersonaAvatar;
+    intro_line?: string;
+}
+/** Pick (or recall) the visitor's sticky persona from the roster. */
+export declare function pickPersona(roster: ChatPersona[] | undefined | null): ChatPersona | null;
+//# sourceMappingURL=personas.d.ts.map

package/dist/personas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"personas.d.ts","sourceRoot":"","sources":["../src/personas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,aAAa;IAC5B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAID,qEAAqE;AACrE,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,SAAS,GAAG,IAAI,GAAG,WAAW,GAAG,IAAI,CAiBxF"}

package/dist/runtime.d.ts

@@ -3,7 +3,16 @@
  *
  * Runtime manifest for the AI chat assistant adaptive.
  * Uses @syntrologie/chat for the UI — no React dependency.
+ *
+ * Chat surfaces are config-driven: customers reference the chat-bar
+ * widget id (`adaptive-chatbot:chat-bar`) from `slots.drawer.lid` (to
+ * replace the launcher FAB) or any other slot's `lid` / tile slot. The
+ * adaptive no longer auto-registers a canvas lid renderer.
  */
+import './AdaptiveChatBar';
+import './AdaptiveChatTrail';
+export { ElementInstanceStore, TileHandler } from './elements';
+export { getElementInstanceStore, setElementInstanceStore } from './elements/store-singleton';
 export declare const runtime: {
     id: string;
     version: string;

package/dist/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;CAmBnB,CAAC;AAEF,eAAe,OAAO,CAAC"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,mBAAmB,CAAC;AAC3B,OAAO,qBAAqB,CAAC;AAW7B,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAE9F,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;CA4EnB,CAAC;AAEF,eAAe,OAAO,CAAC"}