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

package/dist/elements/ElementTypeHandler.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Per-type handler interface for `ElementInstanceStore`.
+ *
+ * Adding a future element type (overlay / tour / form) is one new
+ * `ElementTypeHandler` implementation registered in the store —
+ * `ElementInstanceStore` itself stays type-neutral.
+ *
+ * Handlers own their per-type lifecycle. They receive the current
+ * `MountedElement` snapshot and the runtime's `ActionEngine` and either
+ * call `applyBatch` to drive DOM changes or hold on to returned
+ * `ActionHandle`s for later cleanup.
+ *
+ * Design choices the handlers MUST honor:
+ *
+ * - **Imperative actions never re-fire on boot.** When the store
+ *   hydrates an element with `lifecycle === 'imperative'` and `state ===
+ *   'applied'`, the handler's `mount()` is NOT called. The backend
+ *   records the prior invocation for audit but the SDK does not replay
+ *   it (would re-scroll, re-navigate, etc.).
+ * - **Defense-in-depth content validation.** `validate()` is called
+ *   before every mount/patch. The backend already validated, but the
+ *   handler should refuse malformed content so a buggy server can't
+ *   crash the runtime.
+ */
+import type { ActionEngine } from '../types';
+import type { ElementMutation, MountedElement } from './types';
+/** Lifecycle classification used to decide whether to apply on boot rehydrate. */
+export type ElementLifecycle = 'stateful' | 'imperative' | 'ephemeral';
+export interface ElementHandlerContext {
+    /** Runtime's ActionEngine — handlers use `applyBatch` to drive DOM
+     *  changes via existing executors (`core:mountWidget`, etc.). */
+    actions: ActionEngine;
+    /** Runtime's event bus — handlers publish typed events that container
+     *  widgets subscribe to. Used by `ItemHandler` to broadcast
+     *  `element.compositional_append` so chip-strip / FAQ / nav-tips
+     *  containers can insert LLM-authored items.
+     *  Optional so test fixtures that exercise only DOM action handlers
+     *  don't need to stub the bus.
+     */
+    events?: {
+        publish: (name: string, props?: Record<string, unknown>) => void;
+    };
+}
+export type ValidateResult = {
+    accepted: true;
+} | {
+    accepted: false;
+    reason: string;
+    detail?: string;
+};
+export interface ElementTypeHandler {
+    readonly typeName: 'tile' | 'action' | 'item';
+    /** Whether the handler's elements survive a boot rehydrate. Imperative
+     *  handlers (action handler in v1) DO NOT replay applied instances. */
+    readonly lifecycle: ElementLifecycle;
+    /** Defense-in-depth — refuse malformed content/placement before the
+     *  handler touches the DOM. The store calls this before `mount` and
+     *  `patch`; a rejection is logged but does not throw — the store
+     *  records the rejection on the instance and skips the apply. */
+    validate(instance: MountedElement, ctx: ElementHandlerContext): ValidateResult;
+    /** Apply a new mount to the DOM. Called once per mount; the store
+     *  passes the instance object so the handler can read `placement`,
+     *  `content`, `template_id`, etc. */
+    mount(instance: MountedElement, ctx: ElementHandlerContext): Promise<void>;
+    /** Apply a patch — typically by re-mounting the widget with merged
+     *  content. v1 has no fine-grained reactivity; full re-mount is
+     *  expected. */
+    patch(instance: MountedElement, ctx: ElementHandlerContext): Promise<void>;
+    /** Remove the element from the DOM. Idempotent — called for both
+     *  user-initiated unmounts and TTL-triggered cleanup. */
+    unmount(instance: MountedElement, ctx: ElementHandlerContext): Promise<void>;
+}
+export interface ElementMutationContext extends ElementHandlerContext {
+    /** Op being processed — handler-side telemetry / debug surface. */
+    mutation: ElementMutation;
+}
+//# sourceMappingURL=ElementTypeHandler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ElementTypeHandler.d.ts","sourceRoot":"","sources":["../../src/elements/ElementTypeHandler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE/D,kFAAkF;AAClF,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,YAAY,GAAG,WAAW,CAAC;AAEvE,MAAM,WAAW,qBAAqB;IACpC;qEACiE;IACjE,OAAO,EAAE,YAAY,CAAC;IACtB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE;QACP,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;KAClE,CAAC;CACH;AAED,MAAM,MAAM,cAAc,GACtB;IAAE,QAAQ,EAAE,IAAI,CAAA;CAAE,GAClB;IAAE,QAAQ,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;IAE9C;2EACuE;IACvE,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAC;IAErC;;;qEAGiE;IACjE,QAAQ,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,EAAE,qBAAqB,GAAG,cAAc,CAAC;IAE/E;;yCAEqC;IACrC,KAAK,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3E;;oBAEgB;IAChB,KAAK,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3E;6DACyD;IACzD,OAAO,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9E;AAED,MAAM,WAAW,sBAAuB,SAAQ,qBAAqB;IACnE,mEAAmE;IACnE,QAAQ,EAAE,eAAe,CAAC;CAC3B"}

package/dist/elements/ItemHandler.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Item element handler — translates `parent_tile`-placed mount/patch/
+ * unmount mutations into pub/sub events that container widgets subscribe
+ * to.
+ *
+ * Container widgets (chips strip, FAQ accordion, nav tips) declare
+ * themselves participants by implementing the `CompositionalContainer`
+ * contract and subscribing to `runtime.events` with
+ * `element.compositional_append` / `element.compositional_patch` /
+ * `element.compositional_remove`. Each container filters by
+ * `props.tile_id === this.tileId`.
+ *
+ * Why pub/sub rather than DOM lookup? The runtime's event bus is
+ * domain-agnostic and already exists. Container widgets that aren't
+ * mounted yet (slow inline-slot wrapper hydration) miss the event,
+ * but the next subscribe-then-replay pass at container mount time picks
+ * up the durable session state from the LLM's `mounted_elements`. No
+ * DOM crawling, no MutationObserver wiring, no ordering assumption.
+ *
+ * The handler is dumb: it forwards the wire `content` as the `item`
+ * payload. The backend wrote that content as a fully-formed
+ * compositional-item envelope (`{kind, config: {id, title, payload}}`)
+ * so the receiving container can append it verbatim.
+ */
+import type { ElementHandlerContext, ElementTypeHandler, ValidateResult } from './ElementTypeHandler';
+import type { MountedElement } from './types';
+/** Event names. Kept as module constants so subscribers can import them
+ *  instead of memorizing strings. */
+export declare const COMPOSITIONAL_APPEND_EVENT = "element.compositional_append";
+export declare const COMPOSITIONAL_PATCH_EVENT = "element.compositional_patch";
+export declare const COMPOSITIONAL_REMOVE_EVENT = "element.compositional_remove";
+export interface CompositionalAppendEvent {
+    /** Parent tile id from the mount's placement. Receivers filter on this. */
+    tile_id: string;
+    /** Unique id of the mounted item — the receiving container should also
+     *  set this on the item's DOM as `data-syntro-element-id`. */
+    instance_id: string;
+    /** Wire shape constructed by the backend — `{kind, config: {…}}`. */
+    item: Record<string, unknown>;
+    /** Insertion position — receivers honor this when appending. */
+    position: 'append' | 'prepend';
+}
+export interface CompositionalPatchEvent {
+    tile_id: string;
+    instance_id: string;
+    item: Record<string, unknown>;
+}
+export interface CompositionalRemoveEvent {
+    tile_id: string;
+    instance_id: string;
+}
+export declare class ItemHandler implements ElementTypeHandler {
+    readonly typeName: "item";
+    readonly lifecycle: "stateful";
+    validate(instance: MountedElement, _ctx: ElementHandlerContext): ValidateResult;
+    mount(instance: MountedElement, ctx: ElementHandlerContext): Promise<void>;
+    patch(instance: MountedElement, ctx: ElementHandlerContext): Promise<void>;
+    unmount(instance: MountedElement, ctx: ElementHandlerContext): Promise<void>;
+}
+//# sourceMappingURL=ItemHandler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ItemHandler.d.ts","sourceRoot":"","sources":["../../src/elements/ItemHandler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EACV,qBAAqB,EACrB,kBAAkB,EAClB,cAAc,EACf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,cAAc,EAAuB,MAAM,SAAS,CAAC;AAEnE;qCACqC;AACrC,eAAO,MAAM,0BAA0B,iCAAiC,CAAC;AACzE,eAAO,MAAM,yBAAyB,gCAAgC,CAAC;AACvE,eAAO,MAAM,0BAA0B,iCAAiC,CAAC;AAEzE,MAAM,WAAW,wBAAwB;IACvC,2EAA2E;IAC3E,OAAO,EAAE,MAAM,CAAC;IAChB;kEAC8D;IAC9D,WAAW,EAAE,MAAM,CAAC;IACpB,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,gEAAgE;IAChE,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAC;CAChC;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,WAAY,YAAW,kBAAkB;IACpD,QAAQ,CAAC,QAAQ,EAAG,MAAM,CAAU;IACpC,QAAQ,CAAC,SAAS,EAAG,UAAU,CAAU;IAEzC,QAAQ,CAAC,QAAQ,EAAE,cAAc,EAAE,IAAI,EAAE,qBAAqB,GAAG,cAAc;IAqBzE,KAAK,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IAW1E,KAAK,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IAU1E,OAAO,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;CAQnF"}

package/dist/elements/ItemHandler.test.d.ts

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

package/dist/elements/ItemHandler.test.d.ts.map

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

package/dist/elements/TileHandler.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Tile element handler — translates `slot`-placed mount/patch/unmount
+ * mutations into pub/sub events that the runtime SDK subscribes to.
+ *
+ * The runtime SDK's `SmartCanvasElementLit` already routes config-driven
+ * tiles to inline slots via `tile.slot === slotName`. LLM-authored tiles
+ * use the same path: we publish a TileConfig-shaped envelope and the
+ * runtime merges it into its tile array, then existing routing renders
+ * it inside the slot's `<syntro-tile-stack>` alongside any config tiles.
+ *
+ * Why pub/sub instead of `core:mountWidget` via ActionEngine?
+ *
+ *   - `Surfaces.mount` is exclusive per slot — a second LLM tile to the
+ *     same slot would displace the first.
+ *   - `Surfaces` only knows built-in slot names; inline slots resolve
+ *     anchors via SyntroInlineSlot, not via Surfaces.
+ *   - Tiles need the SyntroTileCard chrome (chromeless handling, theme
+ *     overrides, dismiss control) that `core:mountWidget` skips.
+ *
+ * Container widgets stay dumb: the runtime owns one tile array per slot
+ * and renders it the same way regardless of provenance. Subscribers
+ * filter on `slot === this.name`.
+ *
+ * Event names + payload types live in `@syntrologie/sdk-contracts` so
+ * both packages share the contract. Renaming a field there is a TS
+ * error here and in the runtime subscriber — no silent drift.
+ */
+import type { ElementHandlerContext, ElementTypeHandler, ValidateResult } from './ElementTypeHandler';
+import type { MountedElement } from './types';
+export { TILE_MOUNTED_EVENT, TILE_PATCHED_EVENT, TILE_UNMOUNTED_EVENT, } from '@syntrologie/sdk-contracts';
+/**
+ * Optional template→widget resolver. ``uiTemplates`` declares both
+ * the LLM-facing ``id`` (e.g. ``"product-card"``) and the runtime
+ * widget the chrome should render (e.g. ``"adaptive-product:card"``).
+ * Without this resolver, the handler falls back to ``template_id`` as
+ * the widget id — which only works when the admin chose ids matching
+ * the widget registry, and silently mounts to "Widget not available"
+ * when they don't.
+ */
+export type TileTemplateWidgetResolver = (templateId: string) => string | undefined;
+export declare class TileHandler implements ElementTypeHandler {
+    private readonly resolveWidget?;
+    readonly typeName: "tile";
+    readonly lifecycle: "stateful";
+    constructor(resolveWidget?: TileTemplateWidgetResolver | undefined);
+    private _widgetFor;
+    validate(instance: MountedElement, _ctx: ElementHandlerContext): ValidateResult;
+    mount(instance: MountedElement, ctx: ElementHandlerContext): Promise<void>;
+    patch(instance: MountedElement, ctx: ElementHandlerContext): Promise<void>;
+    unmount(instance: MountedElement, ctx: ElementHandlerContext): Promise<void>;
+}
+//# sourceMappingURL=TileHandler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TileHandler.d.ts","sourceRoot":"","sources":["../../src/elements/TileHandler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAUH,OAAO,KAAK,EACV,qBAAqB,EACrB,kBAAkB,EAClB,cAAc,EACf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,SAAS,CAAC;AAE7D,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,4BAA4B,CAAC;AAEpC;;;;;;;;GAQG;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;AAEpF,qBAAa,WAAY,YAAW,kBAAkB;IAIxC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC;IAH3C,QAAQ,CAAC,QAAQ,EAAG,MAAM,CAAU;IACpC,QAAQ,CAAC,SAAS,EAAG,UAAU,CAAU;gBAEZ,aAAa,CAAC,EAAE,0BAA0B,YAAA;IAEvE,OAAO,CAAC,UAAU;IAIlB,QAAQ,CAAC,QAAQ,EAAE,cAAc,EAAE,IAAI,EAAE,qBAAqB,GAAG,cAAc;IA2BzE,KAAK,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IAY1E,KAAK,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IAY1E,OAAO,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;CASnF"}

package/dist/elements/TileHandler.test.d.ts

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

package/dist/elements/TileHandler.test.d.ts.map

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

package/dist/elements/__tests__/ElementInstanceStore.recall.test.d.ts

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

package/dist/elements/__tests__/ElementInstanceStore.recall.test.d.ts.map

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

package/dist/elements/blockRenderer.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Portable Text block renderer — Phase 7 of the LLM-authored UI element
+ * instantiation work.
+ *
+ * `renderBlocks(blocks)` walks a Portable Text tree and produces a
+ * `DocumentFragment` of known-safe DOM. Calling code attaches the
+ * fragment via `target.appendChild(fragment)` /
+ * `target.insertAdjacentElement(...)` — **never** via `innerHTML`.
+ *
+ * The safety story:
+ *
+ * 1. **No `innerHTML` from agent data, ever.** Every text reaches the
+ *    DOM through `document.createTextNode` or `element.textContent`.
+ *    Even if an agent slips a `<script>` tag into a span's text, it's
+ *    rendered as the literal characters `<script>` inside a text node,
+ *    never parsed as HTML.
+ * 2. **Closed mark vocabulary.** Only `bold` / `italic` / `code` / `link`
+ *    are honored. Unknown marks are dropped at render time.
+ * 3. **Closed block vocabulary.** Only `paragraph` / `heading` / `list` /
+ *    `list_item` / `code` are honored. Unknown block types are dropped.
+ * 4. **Link href validation.** Backend already rejects `javascript:` /
+ *    `data:` / `vbscript:` etc., but the renderer re-checks for defense
+ *    in depth. Rejected links render as plain text spans.
+ * 5. **No inline styles, no event handlers, no custom attributes.**
+ *    Every attribute set on the output DOM is hard-coded in this file.
+ *
+ * Forward-compat: unknown block / mark types drop silently rather than
+ * throw — a future schema bump can add types without breaking today's
+ * renderer.
+ */
+import type { BlockNode } from './blocks';
+export interface RenderOptions {
+    /** Override the document used for `createElement` / `createTextNode`.
+     *  Tests inject jsdom's document; SSR contexts can pass a custom impl
+     *  if needed. Defaults to `globalThis.document`. */
+    doc?: Document;
+}
+/**
+ * Render an array of blocks into a `DocumentFragment` of safe DOM.
+ *
+ * Unknown / malformed entries are silently dropped — the caller has
+ * already validated server-side; the renderer is the last line of
+ * defense and stays fault-tolerant.
+ */
+export declare function renderBlocks(blocks: BlockNode[], options?: RenderOptions): DocumentFragment;
+//# sourceMappingURL=blockRenderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blockRenderer.d.ts","sourceRoot":"","sources":["../../src/elements/blockRenderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EACV,SAAS,EAQV,MAAM,UAAU,CAAC;AAQlB,MAAM,WAAW,aAAa;IAC5B;;wDAEoD;IACpD,GAAG,CAAC,EAAE,QAAQ,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,OAAO,GAAE,aAAkB,GAAG,gBAAgB,CAiB/F"}

package/dist/elements/blockRenderer.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Tests for the Portable Text block renderer — Phase 7.
+ *
+ * The bulk of this file is a hostile-input corpus. The point of the
+ * renderer is that **agent-authored text cannot produce script execution
+ * or unsafe DOM**, by construction, regardless of what the agent
+ * sends. Each test below pumps a different attack shape through
+ * `renderBlocks` and asserts that the resulting DOM contains no
+ * dangerous nodes, no live script content, and no `javascript:` /
+ * `data:` URIs on anchor tags.
+ */
+export {};
+//# sourceMappingURL=blockRenderer.test.d.ts.map

package/dist/elements/blockRenderer.test.d.ts.map

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

package/dist/elements/blocks.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Portable Text block + mark types — Phase 7 of the LLM-authored UI
+ * element instantiation work.
+ *
+ * Mirror of `platform/common/syntrologie_common/sdk/blocks.py`. Closed
+ * vocabulary (block types + mark types) the LLM may author in
+ * `rich_text_blocks` fields. The renderer walks this tree and produces
+ * DOM via `document.createElement` + `textContent` — **agent never
+ * writes HTML strings**. XSS-class attacks have no surface because
+ * there's no HTML on the wire.
+ *
+ * Forward-compat: unknown block types and unknown marks are dropped at
+ * render time (not thrown). A future protocol bump can add new types
+ * without breaking today's renderer.
+ */
+/**
+ * The closed inline-mark vocabulary. Adding a mark is a deliberate
+ * code change with review, never an allowlist tweak.
+ */
+export type MarkType = 'bold' | 'italic' | 'code' | 'link';
+export type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+export type ListStyle = 'bullet' | 'numbered';
+export interface LinkMark {
+    /** Validated server-side; renderer revalidates for defense in depth. */
+    href: string;
+}
+export interface TextSpan {
+    text: string;
+    marks?: MarkType[];
+    link?: LinkMark;
+}
+export interface ParagraphBlock {
+    type: 'paragraph';
+    spans: TextSpan[];
+}
+export interface HeadingBlock {
+    type: 'heading';
+    level: HeadingLevel;
+    spans: TextSpan[];
+}
+export interface ListItemBlock {
+    type: 'list_item';
+    spans: TextSpan[];
+}
+export interface ListBlock {
+    type: 'list';
+    style: ListStyle;
+    items: ListItemBlock[];
+}
+export interface CodeBlock {
+    type: 'code';
+    /** Raw code text. Rendered inside `<pre><code>` via `textContent` —
+     *  no HTML interpretation, no syntax-highlight injection. */
+    text: string;
+    language?: string;
+}
+export type BlockNode = ParagraphBlock | HeadingBlock | ListBlock | CodeBlock;
+//# sourceMappingURL=blocks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.d.ts","sourceRoot":"","sources":["../../src/elements/blocks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;AAE3D,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEjD,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE9C,MAAM,WAAW,QAAQ;IACvB,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC;IACnB,IAAI,CAAC,EAAE,QAAQ,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,YAAY,CAAC;IACpB,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,aAAa,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb;iEAC6D;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,SAAS,GAAG,cAAc,GAAG,YAAY,GAAG,SAAS,GAAG,SAAS,CAAC"}

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,106 @@
+/**
+ * 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;
+    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,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":""}