@kitn.ai/ui 0.28.0 → 0.29.0

package/src/primitives/visualizer-sequences.ts

@@ -1,350 +0,0 @@
-/**
- * Pure `state -> highlight set` mappers for the audio visualizer variants.
- *
- * Ported from livekit/components-js `packages/shadcn/hooks/agents-ui/`
- * (Apache License 2.0). Upstream runs four separate animator hooks, each with
- * its own requestAnimationFrame loop. We keep the sequences (verbatim) but move
- * the timing into one shared driver, `use-sequencer.ts`.
- *
- * Every generator returns a NON-EMPTY array so callers can index with
- * `sequence[tick % sequence.length]` without a guard.
- */
-
-export type VisualizerState =
-  | 'idle'
-  | 'connecting'
-  | 'listening'
-  | 'thinking'
-  | 'speaking'
-  | 'disconnected';
-
-export interface Coordinate {
-  x: number;
-  y: number;
-}
-
-const KNOWN: readonly VisualizerState[] = [
-  'idle',
-  'connecting',
-  'listening',
-  'thinking',
-  'speaking',
-  // First-class since 2026-08-10 (Rob): the dead-connection look (flat wave,
-  // nothing lit) upstream renders for its 'disconnected' state. It was an
-  // alias for 'idle' until idle adopted upstream's gentle wave, which left
-  // the flat line unreachable.
-  'disconnected',
-];
-
-/**
- * LiveKit's AgentState carries room-lifecycle values that mean nothing here.
- * Accept them so markup ported from LiveKit works unchanged.
- */
-const ALIASES: Record<string, VisualizerState> = {
-  // Both are dead-connection looks upstream, so 'failed' rides with
-  // 'disconnected' rather than 'idle'.
-  failed: 'disconnected',
-  initializing: 'connecting',
-  'pre-connect-buffering': 'connecting',
-};
-
-export function normalizeState(input: string | undefined): VisualizerState {
-  if (!input) return 'idle';
-  if ((KNOWN as readonly string[]).includes(input)) return input as VisualizerState;
-  return ALIASES[input] ?? 'idle';
-}
-
-// ---------------------------------------------------------------- bar
-
-export function barSequence(state: VisualizerState, barCount: number): number[][] {
-  switch (state) {
-    case 'connecting': {
-      // A mirrored pair sweeping outward: [0, n-1], [1, n-2], ...
-      const seq: number[][] = [];
-      for (let x = 0; x < barCount; x++) seq.push([x, barCount - 1 - x]);
-      return seq.length ? seq : [[]];
-    }
-    case 'listening':
-    case 'thinking': {
-      // Blink the center bar. -1 is a deliberate no-index frame (the "off" beat).
-      return [[Math.floor(barCount / 2)], [-1]];
-    }
-    case 'speaking':
-      return [Array.from({ length: barCount }, (_, i) => i)];
-    // Dead-connection look: mirrors idle (nothing lit) for now. A dedicated
-    // arm so the pending LiveKit disconnected-state measurement can adjust
-    // it in one line.
-    case 'disconnected':
-      return [[]];
-    case 'idle':
-    default:
-      return [[]];
-  }
-}
-
-export function barInterval(state: VisualizerState, barCount: number): number {
-  switch (state) {
-    // The whole sweep should take 2s regardless of how many bars it crosses.
-    case 'connecting':
-      return 2000 / Math.max(1, barCount);
-    case 'listening':
-      return 500;
-    case 'thinking':
-      return 150;
-    default:
-      return 1000;
-  }
-}
-
-// ---------------------------------------------------------------- grid
-
-/**
- * Walk the perimeter of a ring `spread` cells out from center, clockwise.
- *
- * NOTE: This diverges from upstream use-agent-audio-visualizer-grid.ts in two ways:
- * (1) We use separate centerX and centerY (upstream uses row-center for both axes).
- *     Upstream never ships non-square grids, so the bug never manifested. Our public
- *     API is square-only too now (the grid's single `count` prop, 2026-08-09), but
- *     this function keeps taking rows/columns as plain params, so the correct
- *     arbitrary-shape handling stays -- it costs nothing and guards any future caller.
- * (2) We distinguish spread === 0 from spread === undefined (upstream treats 0 as falsy).
- *     Again, upstream never ships spread=0 explicitly; we do for API completeness.
- */
-function gridRing(rows: number, columns: number, spread: number): Coordinate[] {
-  const seq: Coordinate[] = [];
-  const centerX = Math.floor(columns / 2);
-  const centerY = Math.floor(rows / 2);
-  const topLeft = { x: Math.max(0, centerX - spread), y: Math.max(0, centerY - spread) };
-  const bottomRight = {
-    x: Math.min(columns - 1, centerX + spread),
-    y: Math.min(rows - 1, centerY + spread),
-  };
-
-  for (let x = topLeft.x; x <= bottomRight.x; x++) seq.push({ x, y: topLeft.y });
-  for (let y = topLeft.y + 1; y <= bottomRight.y; y++) seq.push({ x: bottomRight.x, y });
-  for (let x = bottomRight.x - 1; x >= topLeft.x; x--) seq.push({ x, y: bottomRight.y });
-  for (let y = bottomRight.y - 1; y > topLeft.y; y--) seq.push({ x: topLeft.x, y });
-
-  return seq;
-}
-
-export function gridSequence(
-  state: VisualizerState,
-  rows: number,
-  columns: number,
-  spread?: number,
-): Coordinate[] {
-  const center = { x: Math.floor(columns / 2), y: Math.floor(rows / 2) };
-
-  switch (state) {
-    case 'connecting': {
-      const maxSpread = Math.floor(Math.max(rows, columns) / 2);
-      const clamped = spread !== undefined ? Math.min(spread, maxSpread) : maxSpread;
-      const ring = gridRing(rows, columns, clamped);
-      return ring.length ? ring : [center];
-    }
-    case 'listening': {
-      // One lit frame followed by eight dark ones: a slow heartbeat.
-      const off = { x: -1, y: -1 };
-      return [center, off, off, off, off, off, off, off, off];
-    }
-    case 'thinking': {
-      // Sweep the middle row left to right, then back.
-      const y = Math.floor(rows / 2);
-      const seq: Coordinate[] = [];
-      for (let x = 0; x < columns; x++) seq.push({ x, y });
-      for (let x = columns - 1; x >= 0; x--) seq.push({ x, y });
-      return seq.length ? seq : [center];
-    }
-    // Dead-connection look: the same centre resting frame as idle
-    // (variant-grid suppresses the highlight for both, so nothing lights).
-    // A dedicated arm so the pending LiveKit measurement can adjust it in
-    // one line.
-    case 'disconnected':
-      return [center];
-    default:
-      return [center];
-  }
-}
-
-// ---------------------------------------------------------------- radial
-
-/** Largest divisor of `n` that is at most `max`. Always at least 1. */
-function largestDivisorAtMost(n: number, max: number): number {
-  const gcd = (a: number, b: number): number => {
-    while (b !== 0) {
-      const t = b;
-      b = a % b;
-      a = t;
-    }
-    return a;
-  };
-  for (let i = max; i >= 1; i--) if (gcd(n, i) === i) return i;
-  return 1;
-}
-
-/**
- * Partition the ring into interleaved groups. Lighting one group per tick reads
- * as a rotating pattern rather than a single travelling dot. Every index appears
- * in exactly one group.
- */
-function radialGroups(barCount: number): number[][] {
-  const divisor =
-    barCount > 8
-      ? barCount / largestDivisorAtMost(barCount, 4)
-      : largestDivisorAtMost(barCount, 2);
-  const safe = Math.max(1, Math.floor(divisor));
-  const perGroup = Math.floor(barCount / safe);
-  return Array.from({ length: safe }, (_, i) =>
-    Array.from({ length: perGroup }, (_, j) => j * safe + i),
-  );
-}
-
-export function radialSequence(state: VisualizerState, barCount: number): number[][] {
-  switch (state) {
-    case 'connecting': {
-      // Pair each bar with the one opposite it, sweeping around the circle.
-      const center = Math.floor(barCount / 2);
-      const seq: number[][] = [];
-      for (let x = 0; x < barCount; x++) seq.push([x, (x + center) % barCount]);
-      return seq.length ? seq : [[]];
-    }
-    case 'listening':
-    case 'thinking': {
-      const groups = radialGroups(barCount);
-      return groups.length ? groups : [[]];
-    }
-    case 'speaking':
-      return [Array.from({ length: barCount }, (_, i) => i)];
-    // Dead-connection look: mirrors idle (nothing lit) for now, one-line
-    // adjustable once the LiveKit measurement lands.
-    case 'disconnected':
-      return [[]];
-    case 'idle':
-    default:
-      return [[]];
-  }
-}
-
-export function radialInterval(state: VisualizerState): number {
-  switch (state) {
-    case 'connecting':
-    case 'listening':
-      return 500;
-    // Infinity parks the sequencer: `thinking` spins the whole container in CSS
-    // with every bar lit, so ticking would fight the animation.
-    case 'thinking':
-      return Infinity;
-    default:
-      return 1000;
-  }
-}
-
-// ---------------------------------------------------------------- shader
-
-/**
- * Uniform targets for the aura and custom shaders. An array intensity means
- * "ping-pong between these two" (see create-tween). `speaking` intensity is
- * omitted from the pulse because live volume drives it instantly instead.
- */
-export function shaderTargets(
-  state: VisualizerState,
-): { intensity: number | [number, number]; speed: number } {
-  switch (state) {
-    case 'listening':
-      return { intensity: [0.5, 0.8], speed: 2.5 };
-    case 'thinking':
-      return { intensity: [0.25, 0.5], speed: 4.0 };
-    // Same pulse as thinking, its own speed: uSpeed is the only
-    // state-correlated scalar besides intensity that reaches a custom
-    // shader's GLSL (see customUniforms in variant-custom.tsx), so the two
-    // transitional states sharing 4.0 made them indistinguishable to any
-    // consumer shader keying off the kit's uniforms -- the Custom story's
-    // per-state looks are the concrete consumer. Every state now maps to a
-    // distinct speed: idle 1, listening/speaking 2.5 (told apart by band
-    // energy), thinking 4, connecting 6.
-    case 'connecting':
-      return { intensity: [0.25, 0.5], speed: 6.0 };
-    case 'speaking':
-      return { intensity: 0.3, speed: 2.5 };
-    // Dead-connection look: idle's dim intensity but its OWN speed, so a
-    // shader keying off uSpeed can draw a dead line distinct from idle's
-    // calm ridge (see the connecting arm's comment: uSpeed is the only
-    // other state-correlated scalar reaching consumer GLSL). Still
-    // one-line adjustable once the LiveKit measurement lands.
-    case 'disconnected':
-      return { intensity: 0.3, speed: 0.5 };
-    case 'idle':
-    default:
-      return { intensity: 0.3, speed: 1 };
-  }
-}
-
-const WAVE_SPEED = 5;
-const WAVE_AMPLITUDE = 0.025;
-const WAVE_FREQUENCY = 10;
-
-/** Uniform targets for the wave shader. Same shape, different curve. */
-export function waveTargets(state: VisualizerState): {
-  speed: number;
-  amplitude: number;
-  frequency: number;
-  opacity: number | [number, number];
-  pulseDuration: number;
-} {
-  switch (state) {
-    case 'listening':
-      return {
-        speed: WAVE_SPEED,
-        amplitude: WAVE_AMPLITUDE,
-        frequency: WAVE_FREQUENCY,
-        opacity: [1.0, 0.3],
-        pulseDuration: 0.75,
-      };
-    case 'thinking':
-    case 'connecting':
-      return {
-        speed: WAVE_SPEED * 4,
-        amplitude: WAVE_AMPLITUDE / 4,
-        frequency: WAVE_FREQUENCY * 4,
-        opacity: [1.0, 0.3],
-        pulseDuration: 0.4,
-      };
-    case 'speaking':
-    // Upstream's wave switch has NO 'idle' arm: idle falls through to this
-    // same speaking/default arm (speed 10, amplitude 0.025, frequency 10,
-    // opacity 1), a gentle undulation (~1.05px centreline waviness, ~1.5px/s
-    // phase drift, measured on the md tile). Upstream's explicitly FLAT
-    // state is 'disconnected' -- the dedicated arm below. We had flattened
-    // idle instead; Rob wants upstream's look (2026-08-09).
-    case 'idle':
-      return {
-        speed: WAVE_SPEED * 2,
-        amplitude: WAVE_AMPLITUDE,
-        frequency: WAVE_FREQUENCY,
-        opacity: 1.0,
-        pulseDuration: 0,
-      };
-    // Upstream's EXPLICIT flat state, measured: 'disconnected' is the one
-    // arm of their wave switch that zeroes the line. First-class here since
-    // 2026-08-10 (Rob: 'the disconnected wave needs to be that kind of flat
-    // line'). `default` keeps the same flat targets for out-of-union
-    // strings, which normalizeState prevents real callers from reaching.
-    case 'disconnected':
-      return {
-        speed: WAVE_SPEED,
-        amplitude: 0,
-        frequency: 0,
-        opacity: 1.0,
-        pulseDuration: 0,
-      };
-    default:
-      return {
-        speed: WAVE_SPEED,
-        amplitude: 0,
-        frequency: 0,
-        opacity: 1.0,
-        pulseDuration: 0,
-      };
-  }
-}

package/src/remote/host-embed.ts

@@ -1,345 +0,0 @@
-// src/remote/host-embed.ts
-// The host embed SDK: mountRemoteCard() + the RemoteCardHandle. Drops one sandboxed
-// cross-origin iframe, runs the handshake (origin+source+nonce+version), pushes
-// CardContext + CardEnvelope down, validates inbound up-frames, and routes every
-// CardEvent through the SAME routeCardEvent the native transport uses. Auto-sizes the
-// iframe from `resize`, intercepts `focus-edge`.
-//
-// Security-critical, stateful, vanilla DOM ONLY — NO SolidJS imports. See the
-// iframe-transport design spec ("Host embed SDK surface" + addendum H-A/H-C/H-D/H-E/
-// H-F/H-G/H-O).
-
-import {
-  type CardEnvelope,
-  type CardContext,
-  type CardEvent,
-  type CardPolicy,
-} from '../primitives/card-contract';
-import { createPacker, isCardWireFrame, type WireMessage } from './wire';
-import { assertCrossOrigin, redactFrame } from './origin';
-import { isValidVersion } from './version';
-import { hasPollutionKey, isKnownEventKind } from './validate';
-import { routeCardEvent } from '../primitives/card-routing';
-
-export interface MountRemoteCardOptions {
-  /** Where to mount the iframe. */
-  container: HTMLElement;
-  /** The card to render (carried down as a `render` frame). */
-  envelope: CardEnvelope;
-  /** EXACT provider origin (https). Pinned for all origin checks. */
-  providerOrigin: string;
-  /** The provider URL the iframe frames (must be same-origin as providerOrigin). */
-  src: string;
-  /** Ambient context; theme/locale/conversationId/short-lived authToken. */
-  context: CardContext;
-  /** The SAME routing policy native cards use. resize/focus-edge are handled by the SDK. */
-  policy?: CardPolicy;
-  /** Override sandbox. Default: allow-scripts allow-forms allow-same-origin (NO allow-popups — H-G). */
-  sandbox?: string;
-  /** Cap auto-height (px); frame scrolls internally beyond it. */
-  maxHeight?: number;
-  /** Handshake timeout (ms). Default 5000. */
-  handshakeTimeoutMs?: number;
-}
-
-export interface RemoteCardHandle {
-  /** Push new ambient context (theme toggle, token refresh). Shallow top-level merge;
-   *  `theme`/`a11y` replaced wholesale. Always sends a FULL resolved CardContext. */
-  updateContext(context: Partial<CardContext>): void;
-  /** Re-render with a new/updated envelope (same id = update). */
-  update(envelope: CardEnvelope): void;
-  /** Send `teardown`, stop listeners, remove the iframe. Idempotent. */
-  destroy(): void;
-  /** Current bridge state for the host to reflect in UI. */
-  state(): 'connecting' | 'open' | 'error' | 'closed';
-}
-
-type BridgeState = 'connecting' | 'open' | 'error' | 'closed';
-
-const HOST_SUPPORTED_VERSIONS = ['1'];
-const DEFAULT_SANDBOX = 'allow-scripts allow-forms allow-same-origin';
-const DEFAULT_HANDSHAKE_TIMEOUT_MS = 5000;
-
-/** Provider host for the iframe title (best-effort; never throws). */
-function providerHost(providerOrigin: string): string {
-  try { return new URL(providerOrigin).host; } catch { return providerOrigin; }
-}
-
-export function mountRemoteCard(options: MountRemoteCardOptions): RemoteCardHandle {
-  const {
-    container,
-    providerOrigin,
-    src,
-    policy,
-    maxHeight,
-  } = options;
-
-  // ── Cross-origin precondition (H-F): fail closed BEFORE mounting. ──
-  const hostOrigin = typeof window !== 'undefined' ? window.location.origin : '';
-  assertCrossOrigin(src, providerOrigin, hostOrigin);
-
-  const handshakeTimeoutMs = options.handshakeTimeoutMs ?? DEFAULT_HANDSHAKE_TIMEOUT_MS;
-
-  // ── Bridge identity + generation (H-A). A new nonce per generation; stale frames are
-  //    rejected by construction (generation capture + nonce equality). ──
-  let generation = 0;
-  let nonce = mintNonce();
-  let packer = createPacker('1', nonce); // provisional until `ready` negotiates the version.
-
-  // ── State machine (H-E). ──
-  let state: BridgeState = 'connecting';
-
-  // ── Latest-wins pre-OPEN buffer (H-E). Always the newest pending context/render. ──
-  let currentContext: CardContext = resolveContext(options.context);
-  let currentEnvelope: CardEnvelope = options.envelope;
-  let pendingContext: CardContext | null = null;
-  let pendingRender: CardEnvelope | null = null;
-
-  let iframe: HTMLIFrameElement | null = null;
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  let listener: ((e: MessageEvent) => void) | null = null;
-
-  function warn(data: unknown): void {
-    try { console.warn('[kai-remote]', redactFrame(data)); } catch { /* best-effort */ }
-  }
-
-  function postDown(message: WireMessage): void {
-    const cw = iframe?.contentWindow;
-    if (!cw) return;
-    try { cw.postMessage(packer(message), providerOrigin); } catch { /* best-effort */ }
-  }
-
-  function clearTimer(): void {
-    if (timer !== undefined) { clearTimeout(timer); timer = undefined; }
-  }
-
-  function sendContext(ctx: CardContext): void {
-    if (state === 'open') postDown({ dir: 'down', kind: 'context', context: ctx });
-    else if (state === 'connecting') pendingContext = ctx; // latest-wins; no buffer in error/closed
-  }
-
-  function sendRender(envelope: CardEnvelope): void {
-    if (state === 'open') postDown({ dir: 'down', kind: 'render', envelope });
-    else if (state === 'connecting') pendingRender = envelope; // latest-wins; no buffer in error/closed
-  }
-
-  function flushBuffer(): void {
-    // Order: context → render (H-E), so the runtime themes before first paint.
-    if (pendingContext) { postDown({ dir: 'down', kind: 'context', context: pendingContext }); pendingContext = null; }
-    if (pendingRender) { postDown({ dir: 'down', kind: 'render', envelope: pendingRender }); pendingRender = null; }
-  }
-
-  function renderFallback(message: string): void {
-    // Replace the iframe with an inline accessible fallback + a Retry button.
-    const fallback = document.createElement('div');
-    fallback.setAttribute('role', 'alert');
-    fallback.dataset.kaiRemoteFallback = '';
-    const msg = document.createElement('p');
-    msg.textContent = message;
-    fallback.appendChild(msg);
-    const retry = document.createElement('button');
-    retry.type = 'button';
-    retry.textContent = 'Retry';
-    retry.addEventListener('click', () => retryMount());
-    fallback.appendChild(retry);
-    if (iframe && iframe.parentNode === container) container.replaceChild(fallback, iframe);
-    else container.appendChild(fallback);
-    iframe = null;
-  }
-
-  function toError(message: string): void {
-    if (state === 'closed') return;
-    clearTimer();
-    state = 'error';
-    pendingContext = null;
-    pendingRender = null; // discard the coalesced buffer (H-O)
-    renderFallback(message);
-  }
-
-  /** Build the iframe, wire the listener BEFORE setting src (race closure), append, set src. */
-  function createIframe(): void {
-    const myGen = generation;
-    const el = document.createElement('iframe');
-    el.setAttribute('sandbox', options.sandbox ?? DEFAULT_SANDBOX);
-    el.setAttribute('referrerpolicy', 'no-referrer');
-    el.setAttribute('allow', '');
-    const titleBase = currentEnvelope.title ?? currentEnvelope.type;
-    el.setAttribute('title', `${titleBase} — provided by ${providerHost(providerOrigin)}`);
-    el.style.border = '0';
-    el.style.width = '100%';
-
-    el.addEventListener('load', () => {
-      if (generation !== myGen || state !== 'connecting') return;
-      // Provisional packer (negotiated version is set on `ready`).
-      packer = createPacker('1', nonce);
-      postDown({ dir: 'down', kind: 'hello', supportedVersions: HOST_SUPPORTED_VERSIONS });
-      clearTimer();
-      timer = setTimeout(() => {
-        if (generation !== myGen || state !== 'connecting') return;
-        toError('[timeout] The card took too long to load.');
-        policy?.onError?.(currentEnvelope.id, '[timeout] handshake timed out');
-      }, handshakeTimeoutMs);
-    });
-
-    // Listener BEFORE src (H — load-before-listener race closure).
-    listener = (event: MessageEvent) => onMessage(event, myGen);
-    window.addEventListener('message', listener);
-
-    iframe = el;
-    container.appendChild(el);
-    el.setAttribute('src', src); // set LAST.
-  }
-
-  function retryMount(): void {
-    // Guard: only retry from error state; a double-click (or stray call) is a no-op.
-    if (state !== 'error') return;
-    // New generation + new nonce; stale frames from the dead iframe are rejected.
-    generation += 1;
-    nonce = mintNonce();
-    packer = createPacker('1', nonce);
-    state = 'connecting';
-    pendingContext = null;
-    pendingRender = null;
-    clearTimer();
-    if (listener) { window.removeEventListener('message', listener); listener = null; }
-    // Defensively remove any lingering iframe before creating a fresh one.
-    if (iframe) { iframe.remove(); iframe = null; }
-    // Always re-push the latest resolved context + envelope after the new handshake.
-    pendingContext = currentContext;
-    pendingRender = currentEnvelope;
-    // Remove any existing fallback before re-mounting.
-    container.querySelectorAll('[data-kai-remote-fallback]').forEach((n) => n.remove());
-    createIframe();
-  }
-
-  function sizeIframe(height: number): void {
-    if (!iframe) return;
-    const clamped = Math.min(height, maxHeight ?? Infinity);
-    iframe.style.height = `${clamped}px`;
-  }
-
-  function moveFocusPastIframe(): void {
-    // v1 focus-edge handling: blur the iframe so default browser tab order moves past it.
-    // (A richer "next host focusable" mover is a later refinement; blur is deterministic
-    //  and never routes through CardPolicy.)
-    if (iframe) { try { iframe.blur(); } catch { /* best-effort */ } }
-  }
-
-  function onMessage(event: MessageEvent, myGen: number): void {
-    // ── Stale-generation defense (H-A): ignore frames from a superseded/closed bridge. ──
-    if (myGen !== generation || state === 'closed' || state === 'error') return;
-    const data = event.data;
-
-    // ── Inbound security gates, in order (H-A/H-C/H-D): ──
-    // 1. origin pin   2. source-window pin   3. structural + direction guard
-    // 4. nonce equality (bridge-instance binding)
-    if (event.origin !== providerOrigin) return;
-    if (event.source !== iframe?.contentWindow) return;
-    if (!isCardWireFrame(data, 'up')) return;
-    if (data.nonce !== nonce) return;
-
-    // A throw past the gate must NOT kill the listener.
-    try {
-      const message = data.message;
-      switch (message.kind) {
-        case 'ready': {
-          if (state !== 'connecting') return;
-          const accepted = message.acceptedVersion;
-          // 5. version: accepted MUST be a host-supported version (H-C).
-          if (!isValidVersion(accepted) || !HOST_SUPPORTED_VERSIONS.includes(accepted)) {
-            toError('[version-unsupported] This card needs a different host version.');
-            policy?.onError?.(currentEnvelope.id, '[version-unsupported] no compatible protocol version');
-            return;
-          }
-          // Rebuild the packer with the negotiated version (H-C).
-          packer = createPacker(accepted, nonce);
-          clearTimer();
-          state = 'open';
-          // Seed the buffer with the current resolved context + envelope, then flush.
-          if (!pendingContext) pendingContext = currentContext;
-          if (!pendingRender) pendingRender = currentEnvelope;
-          flushBuffer();
-          return;
-        }
-        case 'event': {
-          if (state !== 'open') return;
-          const ev: CardEvent = message.event;
-          // cardId fence (H-E): drop in-flight events for a replaced/stale card.
-          if (ev.cardId !== currentEnvelope.id) return;
-          // resize is transport plumbing — intercept, never route (H-J / spec UP table).
-          if (ev.kind === 'resize') { sizeIframe(ev.height); return; }
-          // Schema/pollution gate before routing (H-D).
-          if (!isKnownEventKind(ev.kind) || hasPollutionKey(ev)) { warn(data); return; }
-          routeCardEvent(policy ?? {}, ev);
-          return;
-        }
-        case 'focus-edge': {
-          // a11y plumbing — intercept, never route (H-O).
-          moveFocusPastIframe();
-          return;
-        }
-        case 'fault': {
-          const code = message.code;
-          const reason = message.message;
-          toError(`[${code}] The card reported a problem.`);
-          policy?.onError?.(currentEnvelope.id, `[${code}] ${reason}`);
-          return;
-        }
-        default:
-          return;
-      }
-    } catch {
-      warn(data);
-    }
-  }
-
-  // ── Public handle ──────────────────────────────────────────────────────────
-  const handle: RemoteCardHandle = {
-    updateContext(partial: Partial<CardContext>): void {
-      if (state === 'closed') return;
-      currentContext = mergeContext(currentContext, partial);
-      sendContext(currentContext);
-    },
-    update(envelope: CardEnvelope): void {
-      if (state === 'closed') return;
-      currentEnvelope = envelope;
-      sendRender(envelope);
-    },
-    destroy(): void {
-      if (state === 'closed') return;
-      generation += 1; // tombstone the current generation (rejects stale inbound).
-      if (state === 'open') postDown({ dir: 'down', kind: 'teardown' });
-      state = 'closed';
-      clearTimer();
-      if (listener) { window.removeEventListener('message', listener); listener = null; }
-      if (iframe) { iframe.remove(); iframe = null; }
-      container.querySelectorAll('[data-kai-remote-fallback]').forEach((n) => n.remove());
-    },
-    state(): BridgeState {
-      return state;
-    },
-  };
-
-  createIframe();
-  return handle;
-}
-
-/** Crypto-random hex nonce (H-A): 16 bytes → 32 hex chars. */
-function mintNonce(): string {
-  const bytes = new Uint8Array(16);
-  crypto.getRandomValues(bytes);
-  let out = '';
-  for (const b of bytes) out += b.toString(16).padStart(2, '0');
-  return out;
-}
-
-/** A shallow copy so the caller's context object isn't mutated by later merges. */
-function resolveContext(ctx: CardContext): CardContext {
-  return { ...ctx };
-}
-
-/** Shallow top-level merge (H-E): `theme` and `a11y` are replaced wholesale, not
- *  deep-merged. Returns a new full resolved CardContext. */
-function mergeContext(base: CardContext, partial: Partial<CardContext>): CardContext {
-  return { ...base, ...partial };
-}

package/src/remote/index.ts

@@ -1,2 +0,0 @@
-export { mountRemoteCard } from './host-embed';
-export type { MountRemoteCardOptions, RemoteCardHandle } from './host-embed';