diff --git a/CHANGELOG.md b/CHANGELOG.md
deleted file mode 100644
index efc52c1..0000000
--- a/CHANGELOG.md
+++ /dev/null
@@ -1,68 +0,0 @@
-# Changelog
-
-All notable changes to `@zablab/solar` are documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [0.2.0] — chantier Solar action runner
-
-### Added
-
-- **`Patch.action` descriptor** on the wire protocol — Solar now
-  reconstructs dense patches locally rather than receiving them
-  frame-by-frame. Six built-in kinds : `count-up`, `curve-path`,
-  `text-reveal`, `stagger-group`, `reorder`, `mask-reveal`.
-  Patches without `action` flow through the existing
-  `transitions.ts` mapper unchanged — fully backward compatible.
-- **`animate/action-runner.ts`** dispatcher + per-kind sub-runners
-  in `animate/runners/`. Unknown kinds raise
-  `UnknownActionKindError` ; hosts can register custom kinds via
-  `registerActionRunner(kind, fn)`.
-- **`animate/flip.ts`** — single source of truth for FLIP. Solar's
-  `reorder` runner consumes it directly ; Prism's preview
-  flip-runtime imports it via `@zablab/solar/animate/flip`.
-- **`animate/easing-resolver.ts`** — resolve `EasingRef` (string id or
-  inline spring) into a CSS easing string plus a `t → eased t`
-  function.
-- **`PrismScene` public class** at `scene/prism-scene.ts` exposing
-  `mount`, `unmount`, `playAnimation`, `stopAnimation`, `on`/`off`,
-  `connectToOrion`, `disconnectFromOrion`, `setScene`. Lets any web
-  host run a Prism-authored scene without Pulsar, CEF, or Electron.
-- **DOM binder** (`scene/binder.ts`) — one-way bindings via
-  `data-anim-path` / `data-anim-attr`.
-- **Examples** : `examples/embed-vanilla/` (UMD `<script>` tag) and
-  `examples/embed-react/` (forwardRef wrapper).
-- **Docs** : `docs/embed-on-website.md` (integration guide),
-  `docs/action-descriptors.md` (protocol reference).
-- **Packaging** : multi-entry ESM (`dist/solar.js`,
-  `dist/animate/flip.js`), UMD bundle (`dist/solar.umd.js`),
-  ESM alias (`dist/solar.esm.js`), public types
-  (`dist/solar.d.ts`). `npm publish --dry-run` is green.
-
-### Changed
-
-- `react`, `react-dom`, `framer-motion` moved from `dependencies` to
-  `peerDependencies`. Hosts supply their own copies — Solar links
-  against them via `external` in both Vite configs.
-- `package.json` `main` now points at the ESM bundle ; `unpkg` /
-  `jsdelivr` fields target the UMD build for CDN consumers.
-
-### Backward compatibility
-
-- The existing `mount()` API is unchanged. ADR 002 wire messages
-  (snapshot, delta, scene_changed) are unchanged. The
-  `Patch.action` field is additive ; legacy patches keep their
-  semantics.
-- Once published, the `PrismScene` class surface is contract.
-  Breaking it requires a major bump per ADR 003.
-
-## [0.1.1] — animation bundle field
-
-- `RenderBundle.animations?` field carried through but not yet
-  dispatched (chantier animation-engine A8 + B-pivot).
-
-## [0.1.0] — initial release (2026-05-02)
-
-- Scene runtime bundle for the Zablab broadcast platform. Same
-  bundle in Pulsar CEF, Prism webview, and editor preview iframe.
diff --git a/README.md b/README.md
index c9ad810..e625373 100644
--- a/README.md
+++ b/README.md
@@ -16,13 +16,9 @@ authoring.
 | Prism live control panel | `control` | Scene + operator overlay |
 | Editor preview iframe | `test` | Scene + adapter mocker + state inspector |
 
-## Three consumers, one API
-
-The same bundle backs three hosts with two public entry points :
+## Public API
 
 ```ts
-// Live host — Pulsar CEF browser source, Prism live control panel,
-// editor preview iframe. Drives off Orion's WS state stream.
 import { mount } from "@zablab/solar";
 
 const handle = mount({
@@ -31,20 +27,13 @@ const handle = mount({
   token: showToken,
   mode: "broadcast",
 });
-```
-
-```ts
-// Web embed — any HTML page, no Pulsar / CEF / Electron. Drives off
-// a Prism-exported sceneJson + named animations.
-import { PrismScene } from "@zablab/solar";
 
-const scene = new PrismScene({ sceneJson });
-scene.mount(document.querySelector("#container")!);
-scene.playAnimation("Score Update", { score_to: 1891 });
+// later
+handle.setToken(rotatedToken);
+handle.disconnect();
 ```
 
-Full integration guide : [`docs/embed-on-website.md`](./docs/embed-on-website.md).
-Action descriptor reference : [`docs/action-descriptors.md`](./docs/action-descriptors.md).
+The complete typed surface lives in `src/types/index.ts`.
 
 ## Status
 
diff --git a/docs/action-descriptors.md b/docs/action-descriptors.md
deleted file mode 100644
index adfce89..0000000
--- a/docs/action-descriptors.md
+++ /dev/null
@@ -1,163 +0,0 @@
-# Action descriptors — `Patch.action` reference
-
-This document is the contract for the `Patch.action` extension of
-the Solar wire protocol (`src/transport/protocol.ts`). It is the
-authority Prism's compiler targets when producing the deltas Solar
-consumes.
-
-The descriptor model is **additive and backward-compatible**. A
-patch without `action` flows through the existing
-`animate/transitions.ts` mapper untouched. A patch with `action` is
-handed to the dispatcher in `animate/action-runner.ts`, which routes
-to the matching sub-runner based on `action.kind`.
-
-Once `@zablab/solar` is published, the **shape of `ActionDescriptor`
-and the names of `ActionKind` are public contract**. Adding a new
-kind is a minor bump ; renaming or removing a kind is a major bump.
-
----
-
-## 1. Shape
-
-```ts
-interface Patch {
-  path: string;
-  value: unknown;
-  transition?: Transition;
-  action?: ActionDescriptor;
-}
-
-interface ActionDescriptor {
-  kind:
-    | "count-up"
-    | "curve-path"
-    | "text-reveal"
-    | "stagger-group"
-    | "reorder"
-    | "mask-reveal";
-  params: Record<string, unknown>;
-  easing?: string | { stiffness: number; damping: number };
-  duration_ms?: number;
-  stops?: Array<{ at_pct: number; value: unknown; easing?: string }>;
-  curve?: {
-    anchors: Array<{
-      t_pct: number;
-      value: number;
-      in_tangent?: { dt: number; dv: number };
-      out_tangent?: { dt: number; dv: number };
-    }>;
-    sample_hz: 30 | 60;
-  };
-  child_selector?: {
-    kind: "index" | "all" | "css-selector";
-    value: number | string;
-  };
-}
-```
-
-## 2. Supported kinds
-
-### `count-up`
-
-Numeric tween of a single leaf path.
-
-| Param      | Type   | Default | Description                                |
-| ---------- | ------ | ------- | ------------------------------------------ |
-| `from`     | number | `0`     | Starting value.                            |
-| `to`       | number | `patch.value` if numeric, else `0` | Ending value. |
-| `decimals` | number | `0`     | Decimal places for intermediate writes.    |
-
-Writes to `patch.path` at every animation frame via the store.
-
-### `curve-path`
-
-Sample a Bézier-anchored curve and write each sample.
-
-Reads `action.curve.anchors[]` and `action.curve.sample_hz`. Tangents
-default to `{dt:0,dv:0}` (linear segments) when omitted.
-
-### `text-reveal`
-
-DOM-side staggered reveal of children matching the configured
-selector (default `[data-anim-unit]`). Each child animates `opacity`
-and `translateY` ; the runner additionally toggles
-`data-anim-state="in"` so CSS can hook into the reveal lifecycle.
-
-| Param         | Type   | Default | Description                          |
-| ------------- | ------ | ------- | ------------------------------------ |
-| `stagger_ms`  | number | `30`    | Delay between consecutive children.  |
-| `per_unit_ms` | number | `240`   | Duration of each unit's animation.   |
-| `from_opacity`| number | `0`     | Starting opacity.                    |
-| `from_y`      | number | `8`     | Starting translateY in px.           |
-
-Resolution order for the target element : `[data-anim-path=<patch.path>]`
-→ `[data-anim-id=<last segment>]` → the mount target itself.
-
-### `stagger-group`
-
-Generic flavour of `text-reveal` with different defaults
-(`stagger_ms=60`, `per_unit_ms=320`, selector `[data-anim-child]`).
-
-### `reorder`
-
-FLIP-animated reorder of a list. Operating mode :
-
-1. Capture FIRST positions of all `[data-flip-id]` children of the
-   target root.
-2. Write `patch.value` (the new ordering) to the store. React
-   re-renders the list with the new order.
-3. After one animation frame, measure LAST, INVERT each delta, PLAY
-   `translate(0,0)` via WAAPI.
-
-The FLIP technique is provided by `@zablab/solar/animate/flip` —
-Prism's preview consumes the same module directly so both runtimes
-share a single FLIP implementation.
-
-| Param        | Type   | Default            | Description                          |
-| ------------ | ------ | ------------------ | ------------------------------------ |
-| `selector`   | string | `[data-flip-id]`   | Override the FLIP marker selector.   |
-| `duration_ms`| number | `action.duration_ms ?? 400` | Animation duration in ms.   |
-
-### `mask-reveal`
-
-Animate the target's `clip-path` from a hidden state to fully
-revealed.
-
-| Param       | Value                                                                 | Default          |
-| ----------- | --------------------------------------------------------------------- | ---------------- |
-| `direction` | `left-to-right` `right-to-left` `top-to-bottom` `bottom-to-top` `center-out` | `left-to-right`  |
-
-## 3. Easing
-
-`action.easing` accepts :
-
-- A string id resolved by `animate/easing-resolver.ts` :
-  `linear`, `ease-in`, `ease-out`, `ease-in-out`, `cubic-in`,
-  `cubic-out`, `cubic-in-out`.
-- An inline spring config : `{ stiffness, damping }`. Approximated
-  as `cubic-bezier(0.22, 1, 0.36, 1)` for the CSS facet.
-
-Omitting `easing` defaults to `cubic-out`.
-
-## 4. Compatibility guarantees
-
-- A `Patch` without `action` is rendered exactly as in Solar v0.1 —
-  the existing `transitions.ts` test suite remains green without
-  modification.
-- Unknown `action.kind` raises `UnknownActionKindError` at dispatch
-  time so the host's `animation:error` event can surface the bad
-  payload.
-- Hosts can register custom kinds via `registerActionRunner(kind, fn)`
-  ; built-in kinds always take precedence (the registry overwrites
-  in-place).
-
-## 5. Related modules
-
-| Module                                | Purpose                                         |
-| ------------------------------------- | ----------------------------------------------- |
-| `src/transport/protocol.ts`           | Wire types — `Patch`, `ActionDescriptor`, …     |
-| `src/animate/action-runner.ts`        | Dispatcher.                                     |
-| `src/animate/runners/*.ts`            | Per-kind implementations.                       |
-| `src/animate/flip.ts`                 | FLIP — shared with Prism preview.               |
-| `src/animate/easing-resolver.ts`      | `EasingRef` → CSS string + `t → eased t`.       |
-| `src/scene/prism-scene.ts`            | Public `PrismScene` class consuming all of above. |
diff --git a/docs/embed-on-website.md b/docs/embed-on-website.md
deleted file mode 100644
index 0c4e7cd..0000000
--- a/docs/embed-on-website.md
+++ /dev/null
@@ -1,254 +0,0 @@
-# Embedding Solar in a website
-
-`@zablab/solar` ships a public class `PrismScene` that lets any web
-host run a Prism-authored scene without Pulsar, CEF, or Electron.
-The same bundle backs **three consumers** with an identical API :
-
-1. **Prism preview** — Electron webview.
-2. **Pulsar broadcast** — CEF browser source.
-3. **Arbitrary web embed** — any HTML page.
-
-This document is the integration guide for the third one. The first
-two are produced by Prism's build pipeline and need no extra wiring.
-
----
-
-## 1. What you need
-
-A `sceneJson` exported from Prism (see `Prism → Scene → Export`). It
-is a plain JSON document — no JavaScript, no remote import, no
-arbitrary code execution. Solar binds the scene to your DOM via
-`data-anim-path` attributes.
-
-```ts
-interface SceneJson {
-  scene_id?: string;
-  state?: Record<string, unknown>;       // initial leaf values
-  html?: string;                         // optional static HTML
-  animations?: Record<string, AnimationDef>;
-}
-
-interface AnimationDef {
-  patches: Patch[];                      // ordered playback
-  duration_ms?: number;
-}
-```
-
-## 2. Quickstart — vanilla JavaScript
-
-Drop a `<script>` tag on your page :
-
-```html
-<!doctype html>
-<html>
-  <head>
-    <script crossorigin src="https://unpkg.com/react@19/umd/react.production.min.js"></script>
-    <script crossorigin src="https://unpkg.com/react-dom@19/umd/react-dom.production.min.js"></script>
-    <script crossorigin src="https://unpkg.com/@zablab/solar/dist/solar.umd.js"></script>
-  </head>
-  <body>
-    <div id="scene"></div>
-
-    <script>
-      const scene = new Solar.PrismScene({
-        sceneJson: {
-          state: { "score.value": 0 },
-          html: `
-            <div class="card">
-              <p>Score</p>
-              <h1 data-anim-path="score.value">0</h1>
-            </div>
-          `,
-          animations: {
-            "Score Update": {
-              patches: [
-                {
-                  path: "score.value",
-                  value: "${param.score_to}",
-                  action: {
-                    kind: "count-up",
-                    params: { from: 0, to: "${param.score_to}" },
-                    duration_ms: 800,
-                  },
-                },
-              ],
-            },
-          },
-        },
-      });
-
-      scene.mount(document.querySelector("#scene"));
-      scene.on("animation:completed", ({ asset_id }) => {
-        console.log(asset_id, "done");
-      });
-      scene.playAnimation("Score Update", { score_to: 1891 });
-    </script>
-  </body>
-</html>
-```
-
-A working copy lives at `examples/embed-vanilla/`.
-
-## 3. Quickstart — React
-
-```tsx
-import { useEffect, useRef } from "react";
-import { PrismScene, type SceneJson } from "@zablab/solar";
-
-const SCENE: SceneJson = {
-  state: { "score.value": 0 },
-  html: `<h1 data-anim-path="score.value">0</h1>`,
-  animations: {
-    "Score Update": {
-      patches: [
-        {
-          path: "score.value",
-          value: "${param.score_to}",
-          action: {
-            kind: "count-up",
-            params: { from: 0, to: "${param.score_to}" },
-            duration_ms: 800,
-          },
-        },
-      ],
-    },
-  },
-};
-
-export function PrismSceneEmbed({ score }: { score: number }) {
-  const ref = useRef<HTMLDivElement | null>(null);
-  const sceneRef = useRef<PrismScene | null>(null);
-
-  useEffect(() => {
-    if (!ref.current) return;
-    const scene = new PrismScene({ sceneJson: SCENE });
-    scene.mount(ref.current);
-    sceneRef.current = scene;
-    return () => scene.unmount();
-  }, []);
-
-  useEffect(() => {
-    sceneRef.current?.playAnimation("Score Update", { score_to: score });
-  }, [score]);
-
-  return <div ref={ref} />;
-}
-```
-
-A working copy lives at `examples/embed-react/`.
-
-## 4. Public API — `PrismScene`
-
-```ts
-class PrismScene {
-  constructor(opts: { sceneJson: SceneJson; mockMode?: boolean });
-
-  mount(target: HTMLElement): void;
-  unmount(): void;
-
-  playAnimation(assetId: string, params?: Record<string, unknown>): Promise<void>;
-  stopAnimation(assetId: string): void;
-
-  on(event: PrismSceneEvent, handler: AnimationHandler): void;
-  off(event: PrismSceneEvent, handler: AnimationHandler): void;
-
-  connectToOrion(opts: { url: string; token: string }): void;
-  disconnectFromOrion(): void;
-
-  setScene(sceneJson: SceneJson): void;
-}
-```
-
-### Events
-
-| Event                 | Payload                              | Fires…                              |
-| --------------------- | ------------------------------------ | ----------------------------------- |
-| `animation:start`     | `{ asset_id, params? }`              | …when `playAnimation()` begins.     |
-| `animation:completed` | `{ asset_id, params? }`              | …when playback finishes cleanly.    |
-| `animation:error`     | `{ asset_id, params?, error }`       | …on a failure (unknown asset, runner error, double-play). |
-
-### Concurrency
-
-A given `assetId` cannot play twice at once — the second call
-rejects with `code: "ALREADY_PLAYING"`. Use `stopAnimation(assetId)`
-to abort an in-flight run before re-playing it. Different
-`assetId`s play independently.
-
-### `${param.*}` interpolation
-
-`playAnimation("Score Update", { score_to: 1891 })` substitutes
-`${param.score_to}` everywhere it appears in `patches[*].path`,
-`patches[*].value`, and `patches[*].action.params`. Whole-string
-tokens (`"${param.score_to}"`) round-trip the raw param value, so
-numbers stay numbers.
-
-### Hot-reload
-
-`setScene(json)` swaps the scene without dismounting React. State
-resets to the new `state` map and DOM rebinds against the new
-`html` if provided.
-
-### Connecting to Orion (optional)
-
-`connectToOrion({ url, token })` opens an authenticated WS to
-`wss://<gate>/orion/api/v1/show/stream`. Snapshots reseed the store,
-deltas patch it. The embed runs fully without this connection — call
-it only when you need live triggers from a running show.
-
-`mockMode: true` makes `connectToOrion()` a no-op (useful for offline
-previews in CI).
-
-## 5. DOM contract
-
-Solar binds **one-way** : your DOM declares anchor points, Solar
-writes into them.
-
-| Attribute              | Behaviour                                                       |
-| ---------------------- | --------------------------------------------------------------- |
-| `data-anim-path="x.y"` | The element's `textContent` mirrors the store value at `x.y`.   |
-| `data-anim-attr="src"` | Combined with `data-anim-path`, the named attribute (here `src`) is updated instead of `textContent`. |
-| `data-anim-id="foo"`   | Action runners (text-reveal, mask-reveal) use this as a target alias. |
-| `data-anim-unit`       | Marks a child unit for `text-reveal`.                           |
-| `data-anim-child`      | Marks a child unit for `stagger-group`.                         |
-| `data-flip-id="k"`     | Identifies a list item for `reorder` (FLIP).                    |
-
-Two-way bindings (user input) are out of scope for the v1 embed API.
-
-## 6. Action descriptors
-
-Each patch can optionally carry an `action` descriptor that triggers
-a richer animation (count-up, FLIP reorder, mask reveal …). The full
-reference lives in [`action-descriptors.md`](./action-descriptors.md).
-
-## 7. Bundle layout
-
-| Path                              | Format | Purpose                                          |
-| --------------------------------- | ------ | ------------------------------------------------ |
-| `dist/solar.js`                   | ESM    | Main bundle — `import { PrismScene } from "@zablab/solar"`. |
-| `dist/solar.esm.js`               | ESM    | Alias of `solar.js` for ESM-friendly tooling.    |
-| `dist/solar.umd.js`               | UMD    | `<script>`-tag embed — exposes `window.Solar.PrismScene`. |
-| `dist/solar.d.ts`                 | dts    | Public type definitions.                         |
-| `dist/animate/flip.js`            | ESM    | FLIP subpath consumed by Prism preview.          |
-
-React and react-dom are **peer dependencies** — the host loads them
-once and Solar links against the host's copies. The UMD bundle
-expects `window.React` and `window.ReactDOM` to be set before the
-`<script>` tag.
-
-## 8. Performance notes
-
-- `count-up` at 60 Hz × 800 ms = ~48 ticks of JS work, negligible.
-- `curve-path` pre-samples its curve and walks the buffer ; no
-  `getPointAtLength` calls on the hot path.
-- All DOM-side animations (text-reveal, mask-reveal, FLIP) ride
-  WAAPI on `opacity`, `transform`, and `clip-path` only —
-  GPU-friendly, no layout cost.
-- A v1 stress test is intentionally absent. Pick `mockMode` for CI
-  if you don't want WebSocket noise.
-
-## 9. Versioning
-
-Once published, the `PrismScene` API and the `Patch.action` schema
-are a contract. Breaking either requires a major bump of
-`@zablab/solar`. Additive changes (new action kind, new optional
-event) stay on minor bumps.
diff --git a/eslint.config.mjs b/eslint.config.mjs
index af74610..b08187d 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -7,7 +7,15 @@ import prettier from "eslint-config-prettier";
 
 export default tseslint.config(
   {
-    ignores: ["dist", "node_modules", "playwright-report", "test-results"],
+    ignores: [
+      "dist",
+      "node_modules",
+      "playwright-report",
+      "test-results",
+      // Agent worktrees / harness checkouts live untracked under .claude
+      // and carry their own built dist — never Solar's lintable source.
+      ".claude",
+    ],
   },
   js.configs.recommended,
   ...tseslint.configs.recommended,
diff --git a/examples/embed-react/App.tsx b/examples/embed-react/App.tsx
deleted file mode 100644
index 96d1bdb..0000000
--- a/examples/embed-react/App.tsx
+++ /dev/null
@@ -1,67 +0,0 @@
-// Example consumer of <PrismSceneEmbed> — bumps the `play` prop to
-// trigger a Score Update animation. Drop this into any Vite/CRA/Next
-// project that has react + react-dom + @zablab/solar installed.
-
-import { useRef, useState } from "react";
-import {
-  PrismSceneEmbed,
-  type PrismSceneEmbedHandle,
-} from "./PrismSceneEmbed";
-import type { SceneJson } from "@zablab/solar";
-
-const SCENE: SceneJson = {
-  state: { "score.value": 0 },
-  html: `
-    <div style="background:#161a23;padding:2rem 3rem;border-radius:12px;text-align:center;">
-      <p style="margin:0;color:#8e95a7;letter-spacing:0.08em;text-transform:uppercase;">Score</p>
-      <h1 style="margin:0;font-size:4rem;font-weight:800;" data-anim-path="score.value">0</h1>
-    </div>
-  `,
-  animations: {
-    "Score Update": {
-      patches: [
-        {
-          path: "score.value",
-          value: "${param.score_to}",
-          action: {
-            kind: "count-up",
-            params: { from: 0, to: "${param.score_to}" },
-            duration_ms: 800,
-            easing: "ease-out",
-          },
-        },
-      ],
-    },
-  },
-};
-
-export function App() {
-  const [score, setScore] = useState<number>(0);
-  const [play, setPlay] = useState<
-    { assetId: string; params?: Record<string, unknown> } | null
-  >(null);
-  const ref = useRef<PrismSceneEmbedHandle | null>(null);
-
-  const trigger = (target: number) => {
-    setScore(target);
-    // New object identity → effect inside PrismSceneEmbed re-fires.
-    setPlay({ assetId: "Score Update", params: { score_to: target } });
-  };
-
-  return (
-    <div style={{ display: "grid", placeItems: "center", gap: "1.5rem" }}>
-      <PrismSceneEmbed
-        ref={ref}
-        scene={SCENE}
-        play={play}
-        onCompleted={(id) => console.log("done :", id)}
-      />
-      <div style={{ display: "flex", gap: "0.5rem" }}>
-        <button onClick={() => trigger(1891)}>1891</button>
-        <button onClick={() => trigger(2024)}>2024</button>
-        <button onClick={() => trigger(0)}>reset</button>
-      </div>
-      <small>current target : {score}</small>
-    </div>
-  );
-}
diff --git a/examples/embed-react/PrismSceneEmbed.tsx b/examples/embed-react/PrismSceneEmbed.tsx
deleted file mode 100644
index 12ccd51..0000000
--- a/examples/embed-react/PrismSceneEmbed.tsx
+++ /dev/null
@@ -1,74 +0,0 @@
-// React wrapper around @zablab/solar's PrismScene. Drop into any
-// React tree ; pass a sceneJson + (optionally) a `play` directive
-// the parent updates to trigger an animation.
-
-import { forwardRef, useEffect, useImperativeHandle, useRef } from "react";
-import { PrismScene, type SceneJson } from "@zablab/solar";
-
-export interface PrismSceneEmbedProps {
-  scene: SceneJson;
-  /** Pass `{ assetId, params? }` and bump the object identity to
-   *  trigger a playAnimation call. Set to null to do nothing. */
-  play?: { assetId: string; params?: Record<string, unknown> } | null;
-  onCompleted?: (assetId: string) => void;
-  onError?: (assetId: string, error: unknown) => void;
-}
-
-export interface PrismSceneEmbedHandle {
-  playAnimation(assetId: string, params?: Record<string, unknown>): Promise<void>;
-  stopAnimation(assetId: string): void;
-}
-
-export const PrismSceneEmbed = forwardRef<PrismSceneEmbedHandle, PrismSceneEmbedProps>(
-  function PrismSceneEmbed({ scene, play, onCompleted, onError }, ref) {
-    const containerRef = useRef<HTMLDivElement | null>(null);
-    const sceneRef = useRef<PrismScene | null>(null);
-
-    useEffect(() => {
-      if (!containerRef.current) return;
-      const s = new PrismScene({ sceneJson: scene });
-      s.mount(containerRef.current);
-      sceneRef.current = s;
-      const onDone = ({ asset_id }: { asset_id: string }) => {
-        onCompleted?.(asset_id);
-      };
-      const onErr = ({ asset_id, error }: { asset_id: string; error?: unknown }) => {
-        onError?.(asset_id, error);
-      };
-      s.on("animation:completed", onDone);
-      s.on("animation:error", onErr);
-      return () => {
-        s.off("animation:completed", onDone);
-        s.off("animation:error", onErr);
-        s.unmount();
-        sceneRef.current = null;
-      };
-      // Recreating the PrismScene on scene changes keeps the
-      // example simple ; production code would use scene.setScene().
-    }, [scene, onCompleted, onError]);
-
-    useEffect(() => {
-      if (!play || !sceneRef.current) return;
-      sceneRef.current.playAnimation(play.assetId, play.params).catch((err) => {
-        if ((err as { code?: string })?.code === "ALREADY_PLAYING") return;
-        onError?.(play.assetId, err);
-      });
-    }, [play, onError]);
-
-    useImperativeHandle(
-      ref,
-      () => ({
-        playAnimation: (assetId, params) =>
-          sceneRef.current
-            ? sceneRef.current.playAnimation(assetId, params)
-            : Promise.resolve(),
-        stopAnimation: (assetId) => {
-          sceneRef.current?.stopAnimation(assetId);
-        },
-      }),
-      [],
-    );
-
-    return <div ref={containerRef} />;
-  },
-);
diff --git a/examples/embed-react/README.md b/examples/embed-react/README.md
deleted file mode 100644
index 8c6cf62..0000000
--- a/examples/embed-react/README.md
+++ /dev/null
@@ -1,30 +0,0 @@
-# Solar — React embed example
-
-Two files :
-
-- `PrismSceneEmbed.tsx` — a `forwardRef` wrapper that owns the
-  PrismScene lifecycle (mount/unmount), forwards `play` props as
-  imperative triggers, and surfaces `animation:completed` /
-  `animation:error` as callbacks.
-- `App.tsx` — example consumer.
-
-## Drop-in usage
-
-```bash
-npm install @zablab/solar react@^19 react-dom@^19
-```
-
-```tsx
-import { PrismSceneEmbed } from "@zablab/solar-examples/embed-react/PrismSceneEmbed";
-// …or copy the file into your own project, it has no external
-// dependency beyond @zablab/solar itself.
-
-<PrismSceneEmbed
-  scene={mySceneJson}
-  play={{ assetId: "Score Update", params: { score_to: 1891 } }}
-  onCompleted={(id) => console.log(id, "done")}
-/>
-```
-
-See `../../docs/embed-on-website.md` for the full integration guide
-including action descriptors, DOM contract, and lifecycle.
diff --git a/examples/embed-vanilla/README.md b/examples/embed-vanilla/README.md
deleted file mode 100644
index 7bd9797..0000000
--- a/examples/embed-vanilla/README.md
+++ /dev/null
@@ -1,29 +0,0 @@
-# Solar — vanilla embed example
-
-A minimal page that loads `@zablab/solar` via `<script>` tag and runs
-the `Score Update` animation on click.
-
-## Run it
-
-From the repo root :
-
-```bash
-npm run build                 # produces dist/solar.umd.js
-python -m http.server 5173 \
-  --directory examples/embed-vanilla
-# open http://localhost:5173/
-```
-
-(any static server works ; the file paths above use a local relative
-import of `../../dist/solar.umd.js` so it works offline too)
-
-## What it shows
-
-- Loading Solar as a plain UMD script alongside `react` /
-  `react-dom` UMD builds.
-- Authoring the scene in JSON (no JS execution surface).
-- Driving a numeric `count-up` action via `playAnimation()` with
-  `${param.*}` interpolation.
-- Subscribing to `animation:completed` to log when playback is done.
-
-See `../../docs/embed-on-website.md` for the full integration guide.
diff --git a/examples/embed-vanilla/index.html b/examples/embed-vanilla/index.html
deleted file mode 100644
index e0d59db..0000000
--- a/examples/embed-vanilla/index.html
+++ /dev/null
@@ -1,98 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>Solar — vanilla embed</title>
-    <style>
-      :root { color-scheme: dark; }
-      body {
-        margin: 0;
-        font-family: ui-sans-serif, system-ui, sans-serif;
-        background: #0b0d12;
-        color: #e8eaf0;
-        min-height: 100vh;
-        display: grid;
-        place-items: center;
-        gap: 1.5rem;
-      }
-      .card {
-        background: #161a23;
-        border: 1px solid #2a3142;
-        border-radius: 12px;
-        padding: 2rem 3rem;
-        text-align: center;
-      }
-      .card p { margin: 0 0 0.25rem; color: #8e95a7; font-size: 0.85rem; letter-spacing: 0.08em; text-transform: uppercase; }
-      .card h1 { margin: 0; font-size: 4rem; font-variant-numeric: tabular-nums; font-weight: 800; }
-      button {
-        background: #4c6ef5;
-        color: white;
-        border: 0;
-        border-radius: 8px;
-        padding: 0.6rem 1.2rem;
-        font-size: 0.95rem;
-        cursor: pointer;
-      }
-      button:hover { background: #5c7cfa; }
-    </style>
-  </head>
-  <body>
-    <div id="scene"></div>
-    <button id="play">Run Score Update → 1891</button>
-
-    <!-- React + react-dom peer deps. Pin to a specific minor version
-         when you deploy this template. -->
-    <script crossorigin src="https://unpkg.com/react@19/umd/react.production.min.js"></script>
-    <script crossorigin src="https://unpkg.com/react-dom@19/umd/react-dom.production.min.js"></script>
-    <!-- Solar UMD — exposes `window.Solar`. -->
-    <script src="../../dist/solar.umd.js"></script>
-
-    <script>
-      const sceneJson = {
-        state: { "score.value": 0 },
-        html: `
-          <div class="card">
-            <p>Score</p>
-            <h1 data-anim-path="score.value">0</h1>
-          </div>
-        `,
-        animations: {
-          Reveal: {
-            patches: [
-              { path: "score.value", value: 0 },
-            ],
-          },
-          "Score Update": {
-            patches: [
-              {
-                path: "score.value",
-                value: "${param.score_to}",
-                action: {
-                  kind: "count-up",
-                  params: { from: 0, to: "${param.score_to}" },
-                  duration_ms: 800,
-                  easing: "ease-out",
-                },
-              },
-            ],
-          },
-        },
-      };
-
-      const scene = new Solar.PrismScene({ sceneJson });
-      scene.mount(document.querySelector("#scene"));
-
-      scene.on("animation:completed", ({ asset_id }) => {
-        console.log("solar :: animation completed —", asset_id);
-      });
-
-      document.getElementById("play").addEventListener("click", () => {
-        scene.playAnimation("Score Update", { score_to: 1891 }).catch((err) => {
-          if (err && err.code === "ALREADY_PLAYING") return; // ignore
-          console.error(err);
-        });
-      });
-    </script>
-  </body>
-</html>
diff --git a/package-lock.json b/package-lock.json
index 49a7d05..788840c 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8,6 +8,7 @@
       "name": "@zablab/solar",
       "version": "0.1.1",
       "dependencies": {
+        "@lumencast/runtime": "^0.1.0",
         "@preact/signals-react": "^3.2.1",
         "framer-motion": "^12.0.0",
         "react": "^19.0.0",
@@ -1131,6 +1132,38 @@
         "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
+    "node_modules/@lumencast/protocol": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/@lumencast/protocol/-/protocol-0.1.0.tgz",
+      "integrity": "sha512-Bex8lI7LeE9UEMCkro/ZvxNgX8j5U/e0/MwzA2LdTBzGoB7DxL6DWfpEqKaTqKjGvHxOauM2Fli/KymADJ4Qog==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "ws": "^8.18.0",
+        "yaml": "^2.6.1"
+      },
+      "bin": {
+        "lumencast-js-conformance": "dist/cli.js"
+      },
+      "engines": {
+        "node": ">=22"
+      }
+    },
+    "node_modules/@lumencast/runtime": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/@lumencast/runtime/-/runtime-0.1.0.tgz",
+      "integrity": "sha512-EbiW2xqujH6Q/MG9cmf0mDJG9azXLOMEd+4LtPf8tSCT/ix+bKiC3YMj2e83LhWvZXezcMu3YIGWwJOv2JKfGg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@lumencast/protocol": "0.1.0",
+        "@preact/signals-react": "^3.2.1",
+        "framer-motion": "^12.0.0",
+        "react": "^19.0.0",
+        "react-dom": "^19.0.0"
+      },
+      "engines": {
+        "node": ">=22"
+      }
+    },
     "node_modules/@microsoft/api-extractor": {
       "version": "7.58.7",
       "resolved": "https://registry.npmjs.org/@microsoft/api-extractor/-/api-extractor-7.58.7.tgz",
@@ -7467,7 +7500,6 @@
       "version": "8.20.0",
       "resolved": "https://registry.npmjs.org/ws/-/ws-8.20.0.tgz",
       "integrity": "sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"
@@ -7492,6 +7524,21 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/yaml": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.9.0.tgz",
+      "integrity": "sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA==",
+      "license": "ISC",
+      "bin": {
+        "yaml": "bin.mjs"
+      },
+      "engines": {
+        "node": ">= 14.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/eemeli"
+      }
+    },
     "node_modules/yocto-queue": {
       "version": "0.1.0",
       "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
diff --git a/package.json b/package.json
index ccfab44..a31650b 100644
--- a/package.json
+++ b/package.json
@@ -1,30 +1,21 @@
 {
   "name": "@zablab/solar",
-  "version": "0.2.0",
-  "description": "Solar — scene runtime bundle for the Zablab broadcast platform (Pulsar CEF + Prism webview + web embed)",
+  "version": "0.1.1",
+  "description": "Solar — scene runtime bundle for the Zablab broadcast platform (Pulsar CEF + Prism webview + editor preview)",
   "type": "module",
   "private": true,
   "main": "./dist/solar.js",
-  "module": "./dist/solar.esm.js",
-  "unpkg": "./dist/solar.umd.js",
-  "jsdelivr": "./dist/solar.umd.js",
-  "types": "./dist/solar.d.ts",
+  "module": "./dist/solar.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/solar.d.ts",
-      "import": "./dist/solar.js",
-      "require": "./dist/solar.umd.js"
-    },
-    "./animate/flip": {
-      "types": "./dist/animate/flip.d.ts",
-      "import": "./dist/animate/flip.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/solar.js"
     },
     "./style.css": "./dist/solar.css"
   },
   "files": [
-    "dist",
-    "README.md",
-    "CHANGELOG.md"
+    "dist"
   ],
   "author": {
     "name": "Zablab",
@@ -35,7 +26,7 @@
   },
   "scripts": {
     "dev": "vite",
-    "build": "vite build && vite build -c vite.config.umd.ts && node scripts/finalise-dist.mjs && node scripts/build-host-html.mjs",
+    "build": "vite build && node scripts/build-host-html.mjs",
     "lint": "eslint --max-warnings 0 .",
     "typecheck": "tsc -b --pretty",
     "format": "prettier --write .",
@@ -44,14 +35,13 @@
     "test:e2e": "playwright test",
     "check:bundle": "node scripts/check-bundle-size.mjs"
   },
-  "peerDependencies": {
+  "dependencies": {
+    "@lumencast/runtime": "^0.1.0",
+    "@preact/signals-react": "^3.2.1",
     "framer-motion": "^12.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },
-  "dependencies": {
-    "@preact/signals-react": "^3.2.1"
-  },
   "devDependencies": {
     "@playwright/test": "^1.49.1",
     "@tailwindcss/postcss": "^4.0.7",
@@ -65,13 +55,10 @@
     "eslint-config-prettier": "^10.0.1",
     "eslint-plugin-react": "^7.37.4",
     "eslint-plugin-react-hooks": "^5.1.0",
-    "framer-motion": "^12.0.0",
     "globals": "^17.6.0",
     "happy-dom": "^20.9.0",
     "postcss": "^8.5.2",
     "prettier": "^3.5.2",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
     "tailwindcss": "^4.0.7",
     "typescript": "^5.7.3",
     "typescript-eslint": "^8.24.0",
diff --git a/playwright.config.ts b/playwright.config.ts
index aa0c61c..b78bbdf 100644
--- a/playwright.config.ts
+++ b/playwright.config.ts
@@ -12,8 +12,11 @@ export default defineConfig({
   reporter: process.env.CI ? "github" : "list",
   timeout: 30_000,
   expect: { timeout: 5_000 },
-  globalSetup: "./tests/e2e/global-setup.ts",
-  globalTeardown: "./tests/e2e/global-teardown.ts",
+  // ADR 007 sub-chantier B : the bespoke mock-orion global setup was
+  // removed with Solar's home-grown protocol. The LSDP/1.1 E2E harness
+  // (a stub Lumencast server + the runtime's server kit) is Probe's
+  // follow-up — acceptance (b)/(c)/(e). Until then `test:e2e` has no
+  // specs and is a no-op (E2E is not in the push gate).
   use: {
     baseURL: `http://localhost:${VITE_PORT}`,
     headless: true,
diff --git a/scripts/check-bundle-size.mjs b/scripts/check-bundle-size.mjs
index 359e5c9..836be77 100644
--- a/scripts/check-bundle-size.mjs
+++ b/scripts/check-bundle-size.mjs
@@ -16,15 +16,34 @@ const BROADCAST_BUDGET = 200 * 1024;
 const CONTROL_BUDGET = 280 * 1024;
 const TEST_BUDGET = 360 * 1024;
 
+// Since ADR 007 (Solar = thin adapter over @lumencast/runtime), the
+// per-mode chunks come from the runtime and may carry TWO hash segments
+// (the runtime's own chunk hash + Vite's re-bundle hash), e.g.
+// `broadcast-BqOhSNsY-8nj7XQpl.js`. Match against the known source names
+// rather than trying to guess where the hash boundary is.
+const KNOWN_PREFIXES = [
+  "solar",
+  "index",
+  "tree",
+  "broadcast",
+  "control",
+  "test",
+  "status-pill",
+];
+
 const files = readdirSync(DIST).filter((f) => f.endsWith(".js"));
-const fileMap = new Map(); // basename prefix → { full, raw, gzip }
+const fileMap = new Map(); // source name → { full, raw, gzip }
 for (const f of files) {
   const buf = readFileSync(join(DIST, f));
   const gzip = gzipSync(buf).length;
-  // strip the hash suffix to get the source name (e.g.
-  // broadcast-CcsEAg11.js → broadcast)
-  const prefix = f.replace(/-[A-Za-z0-9_]+\.js$/, "").replace(/\.js$/, "");
-  fileMap.set(prefix, { full: f, raw: buf.length, gzip });
+  // A chunk maps to a known prefix when its name is exactly the prefix
+  // (`solar.js`) or the prefix followed by a hash segment
+  // (`broadcast-XXXX[-YYYY].js`). Longest match wins so `status-pill`
+  // isn't shadowed by a shorter prefix.
+  const match = KNOWN_PREFIXES.filter(
+    (p) => f === `${p}.js` || f.startsWith(`${p}-`),
+  ).sort((a, b) => b.length - a.length)[0];
+  if (match) fileMap.set(match, { full: f, raw: buf.length, gzip });
 }
 
 function need(prefix) {
diff --git a/scripts/finalise-dist.mjs b/scripts/finalise-dist.mjs
deleted file mode 100644
index 7fee3f6..0000000
--- a/scripts/finalise-dist.mjs
+++ /dev/null
@@ -1,89 +0,0 @@
-#!/usr/bin/env node
-/**
- * Finalises the published `dist/` shape required by the chantier
- * `Solar action runner` criterion 8 :
- *
- *   - dist/solar.js          — ESM bundle  (already emitted)
- *   - dist/solar.esm.js      — ESM alias   (copy of solar.js)
- *   - dist/solar.umd.js      — UMD bundle  (emitted by vite.config.umd.ts)
- *   - dist/solar.d.ts        — public types (alias of dist/index.d.ts)
- *   - dist/animate/flip.js   — FLIP subpath consumed by Prism
- *
- * The alias copies (solar.esm.js, solar.d.ts) are tiny and keep the
- * external contract stable while leaving the dts plugin's default
- * naming alone.
- */
-import {
-  copyFileSync,
-  existsSync,
-  readFileSync,
-  writeFileSync,
-  rmSync,
-  mkdirSync,
-} from "node:fs";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const here = dirname(fileURLToPath(import.meta.url));
-const dist = resolve(here, "..", "dist");
-
-function must(path) {
-  if (!existsSync(path)) {
-    console.error(`finalise-dist: expected artefact missing — ${path}`);
-    process.exit(1);
-  }
-}
-
-must(resolve(dist, "solar.js"));
-must(resolve(dist, "animate", "flip.js"));
-must(resolve(dist, "solar.d.ts"));
-
-// 1. ESM alias.
-copyFileSync(resolve(dist, "solar.js"), resolve(dist, "solar.esm.js"));
-
-// 2. Per-entry type stubs for the subpath exports.
-mkdirSync(resolve(dist, "animate"), { recursive: true });
-const flipDts = resolve(dist, "animate", "flip.d.ts");
-const rolledFlipDts = resolve(dist, "flip.d.ts");
-if (existsSync(rolledFlipDts)) {
-  copyFileSync(rolledFlipDts, flipDts);
-  rmSync(rolledFlipDts);
-} else if (!existsSync(flipDts)) {
-  // Fallback : re-export the relevant subset from the rolled bundle.
-  writeFileSync(
-    flipDts,
-    `export {\n  captureFlip,\n  playFlip,\n  withFlip,\n} from "../solar";\nexport type { FlipSnapshot, FlipPlayOptions } from "../solar";\n`,
-  );
-}
-
-// 4. Validate UMD was emitted.
-const umd = resolve(dist, "solar.umd.js");
-if (!existsSync(umd)) {
-  console.error("finalise-dist: dist/solar.umd.js missing — run vite -c vite.config.umd.ts");
-  process.exit(1);
-}
-
-// 5. Drop the source maps for the alias copies (they reference the
-//    original chunk hash and adding a duplicate map only inflates the
-//    tarball without buying anything).
-for (const candidate of ["solar.esm.js.map"]) {
-  const p = resolve(dist, candidate);
-  if (existsSync(p)) rmSync(p);
-}
-
-console.log(
-  "finalise-dist: ok — solar.js / solar.esm.js / solar.umd.js / solar.d.ts / animate/flip.js",
-);
-// Read and surface gzipped sizes for transparency.
-import("node:zlib").then(({ gzipSync }) => {
-  const fmt = (n) => `${(n / 1024).toFixed(2)} KiB`;
-  for (const f of [
-    "solar.js",
-    "solar.esm.js",
-    "solar.umd.js",
-    "animate/flip.js",
-  ]) {
-    const buf = readFileSync(resolve(dist, f));
-    console.log(`  ${f.padEnd(20)} raw=${fmt(buf.length)}  gzip=${fmt(gzipSync(buf).length)}`);
-  }
-});
diff --git a/src/animate/action-runner.ts b/src/animate/action-runner.ts
deleted file mode 100644
index 6a7a8e2..0000000
--- a/src/animate/action-runner.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-// Action runner dispatcher — routes Patch.action descriptors to the
-// matching sub-runner. Patches without `action` are out of scope here ;
-// callers fall back to the existing transitions.ts pipeline.
-//
-// Lifecycle :
-//   runAction({ store, patch, root, signal })
-//     → look up RUNNERS[patch.action.kind]
-//     → await the runner
-//     → throw if kind is unknown so callers can surface the error
-//
-// All runners are async. Implementations may operate against the
-// `store` (count-up, curve-path), the DOM (text-reveal, stagger-group,
-// reorder, mask-reveal), or both.
-
-import type { Patch } from "../transport/protocol";
-import type { Store } from "../state/store";
-import { runCountUp } from "./runners/count-up";
-import { runCurvePath } from "./runners/curve-path";
-import { runTextReveal } from "./runners/text-reveal";
-import { runStaggerGroup } from "./runners/stagger-group";
-import { runReorder } from "./runners/reorder";
-import { runMaskReveal } from "./runners/mask-reveal";
-
-export interface ActionContext {
-  store: Store;
-  patch: Patch;
-  root?: HTMLElement | null;
-  signal?: AbortSignal;
-}
-
-export type ActionRunner = (ctx: ActionContext) => Promise<void>;
-
-const RUNNERS: Record<string, ActionRunner> = {
-  "count-up": runCountUp,
-  "curve-path": runCurvePath,
-  "text-reveal": runTextReveal,
-  "stagger-group": runStaggerGroup,
-  reorder: runReorder,
-  "mask-reveal": runMaskReveal,
-};
-
-export function hasAction(patch: Patch): boolean {
-  return Boolean(patch.action);
-}
-
-export class UnknownActionKindError extends Error {
-  readonly kind: string;
-  constructor(kind: string) {
-    super(`Solar action-runner : unknown kind '${kind}'`);
-    this.kind = kind;
-    this.name = "UnknownActionKindError";
-  }
-}
-
-export async function runAction(ctx: ActionContext): Promise<void> {
-  const action = ctx.patch.action;
-  if (!action) return;
-  const runner = RUNNERS[action.kind];
-  if (!runner) throw new UnknownActionKindError(action.kind);
-  await runner(ctx);
-}
-
-/** Register or override a runner — exposed for hosts that ship custom
- *  action kinds. Use sparingly ; the built-in kinds are the contract
- *  Prism's compiler targets. */
-export function registerActionRunner(
-  kind: string,
-  runner: ActionRunner,
-): void {
-  RUNNERS[kind] = runner;
-}
diff --git a/src/animate/crossfade.tsx b/src/animate/crossfade.tsx
deleted file mode 100644
index 4c08e9b..0000000
--- a/src/animate/crossfade.tsx
+++ /dev/null
@@ -1,35 +0,0 @@
-import { type ReactNode } from "react";
-import { AnimatePresence, motion } from "framer-motion";
-
-export interface CrossfadeProps {
-  /** Scene id or any stable key — children remount on key change. */
-  trackKey: string;
-  /** Duration in milliseconds. */
-  durationMs?: number;
-  children: ReactNode;
-}
-
-/** Crossfade two scene roots at key change. Both children are mounted
- *  during the transition window, one fading out as the other fades in.
- *  Animates opacity only (GPU-friendly). */
-export function Crossfade({
-  trackKey,
-  durationMs = 400,
-  children,
-}: CrossfadeProps) {
-  const transition = { duration: durationMs / 1000, ease: "easeInOut" } as const;
-  return (
-    <AnimatePresence mode="sync">
-      <motion.div
-        key={trackKey}
-        initial={{ opacity: 0 }}
-        animate={{ opacity: 1 }}
-        exit={{ opacity: 0 }}
-        transition={transition}
-        style={{ position: "absolute", inset: 0 }}
-      >
-        {children}
-      </motion.div>
-    </AnimatePresence>
-  );
-}
diff --git a/src/animate/easing-resolver.ts b/src/animate/easing-resolver.ts
deleted file mode 100644
index 528819b..0000000
--- a/src/animate/easing-resolver.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-// Easing resolver — turn an EasingRef descriptor into a usable easing.
-//
-// We return two facets : a CSS easing string (consumed by WAAPI/CSS
-// transitions and the FLIP runtime) and a normalised-time function `t
-// → eased t` for runners that compute values in JS (count-up,
-// curve-path).
-//
-// Spring easings can't be reduced to a closed-form CSS string ; we
-// fall back to `ease-out` for the CSS facet and use a critically-
-// damped approximation for the JS facet. That's deliberately
-// minimal — the spring authoring path goes through framer-motion when
-// fidelity matters.
-
-import type { EasingRef } from "../transport/protocol";
-
-export interface ResolvedEasing {
-  /** CSS / WAAPI `easing` value. */
-  css: string;
-  /** `t ∈ [0,1] → eased t ∈ [0,1]`. */
-  fn: (t: number) => number;
-}
-
-const LINEAR = (t: number): number => t;
-const EASE_IN = (t: number): number => t * t * t;
-const EASE_OUT = (t: number): number => 1 - Math.pow(1 - t, 3);
-const EASE_IN_OUT = (t: number): number =>
-  t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
-
-const STRING_EASINGS: Record<string, ResolvedEasing> = {
-  linear: { css: "linear", fn: LINEAR },
-  "ease-in": { css: "cubic-bezier(0.42, 0, 1, 1)", fn: EASE_IN },
-  "ease-out": { css: "cubic-bezier(0, 0, 0.58, 1)", fn: EASE_OUT },
-  "ease-in-out": { css: "cubic-bezier(0.42, 0, 0.58, 1)", fn: EASE_IN_OUT },
-  "cubic-in": { css: "cubic-bezier(0.32, 0, 0.67, 0)", fn: EASE_IN },
-  "cubic-out": { css: "cubic-bezier(0.33, 1, 0.68, 1)", fn: EASE_OUT },
-  "cubic-in-out": { css: "cubic-bezier(0.65, 0, 0.35, 1)", fn: EASE_IN_OUT },
-};
-
-const DEFAULT: ResolvedEasing = {
-  css: "cubic-bezier(0, 0, 0.58, 1)",
-  fn: EASE_OUT,
-};
-
-export function resolveEasing(ref: EasingRef | undefined): ResolvedEasing {
-  if (!ref) return DEFAULT;
-  if (typeof ref === "string") {
-    return STRING_EASINGS[ref] ?? DEFAULT;
-  }
-  // Inline spring → approximate. We damp toward 1 using the ratio.
-  const { stiffness, damping } = ref;
-  const ratio = damping > 0 ? Math.min(1, damping / Math.max(1, stiffness)) : 1;
-  const fn = (t: number): number => {
-    const decay = Math.exp(-5 * (1 - ratio) * t);
-    return 1 - decay * Math.cos(t * Math.PI * (1 - ratio));
-  };
-  return { css: "cubic-bezier(0.22, 1, 0.36, 1)", fn };
-}
diff --git a/src/animate/flip.ts b/src/animate/flip.ts
deleted file mode 100644
index a863bf4..0000000
--- a/src/animate/flip.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-// FLIP (First-Last-Invert-Play) — shared between Solar's reorder
-// runner and Prism's preview flip-runtime.
-//
-// This module is the **single source of truth** for FLIP behaviour
-// across the platform : Solar's action-runner imports it directly,
-// Prism imports it via `@zablab/solar/animate/flip`. Once published,
-// the API is contract — additive changes only without a major bump.
-//
-// Operating mode :
-//   1. `captureFlip(root)` — measure FIRST positions of every node
-//      matching the selector (default `[data-flip-id]`).
-//   2. The host mutates the DOM (insertion, reorder, removal …).
-//   3. `playFlip(root, prev, options)` — measure LAST positions,
-//      INVERT each delta (translate node back to its old position
-//      with no transition), then PLAY (animate translate(0,0)).
-//
-// All animations run via the Web Animations API on `transform` only
-// (GPU-friendly, no layout cost). Nodes without a previous rect are
-// skipped — they were just inserted and have no "first" to interpolate
-// from. Removals are out of scope of FLIP itself (handled by the
-// host's exit transition).
-
-export interface FlipSnapshot {
-  rects: Map<string, DOMRect>;
-}
-
-export interface FlipPlayOptions {
-  duration?: number;
-  /** CSS / WAAPI easing string. */
-  easing?: string;
-  /** Override of the FLIP marker selector (default `[data-flip-id]`). */
-  selector?: string;
-}
-
-const DEFAULT_SELECTOR = "[data-flip-id]";
-
-function flipIdOf(el: HTMLElement, attr: string): string | null {
-  if (attr === "[data-flip-id]") {
-    return el.dataset.flipId ?? null;
-  }
-  return el.getAttribute(attr.replace(/^\[|\]$/g, "")) ?? null;
-}
-
-export function captureFlip(
-  root: HTMLElement,
-  selector: string = DEFAULT_SELECTOR,
-): FlipSnapshot {
-  const rects = new Map<string, DOMRect>();
-  const nodes = root.querySelectorAll<HTMLElement>(selector);
-  nodes.forEach((el) => {
-    const id = flipIdOf(el, selector);
-    if (id) rects.set(id, el.getBoundingClientRect());
-  });
-  return { rects };
-}
-
-export async function playFlip(
-  root: HTMLElement,
-  prev: FlipSnapshot,
-  options: FlipPlayOptions = {},
-): Promise<void> {
-  const duration = options.duration ?? 400;
-  const easing = options.easing ?? "cubic-bezier(0.22, 1, 0.36, 1)";
-  const selector = options.selector ?? DEFAULT_SELECTOR;
-
-  const animations: Animation[] = [];
-  const nodes = root.querySelectorAll<HTMLElement>(selector);
-  nodes.forEach((el) => {
-    const id = flipIdOf(el, selector);
-    if (!id) return;
-    const prevRect = prev.rects.get(id);
-    if (!prevRect) return;
-    const nextRect = el.getBoundingClientRect();
-    const dx = prevRect.left - nextRect.left;
-    const dy = prevRect.top - nextRect.top;
-    if (Math.abs(dx) < 0.5 && Math.abs(dy) < 0.5) return;
-    if (typeof el.animate !== "function") return;
-    const anim = el.animate(
-      [
-        { transform: `translate(${dx}px, ${dy}px)` },
-        { transform: "translate(0, 0)" },
-      ],
-      { duration, easing, fill: "both" },
-    );
-    animations.push(anim);
-  });
-  await Promise.all(
-    animations.map((a) =>
-      a.finished.then(
-        () => undefined,
-        () => undefined,
-      ),
-    ),
-  );
-}
-
-/** Convenience helper for runners that own the mutation themselves. */
-export async function withFlip(
-  root: HTMLElement,
-  mutate: () => void | Promise<void>,
-  options?: FlipPlayOptions,
-): Promise<void> {
-  const snapshot = captureFlip(root, options?.selector);
-  await mutate();
-  await playFlip(root, snapshot, options);
-}
diff --git a/src/animate/runners/count-up.ts b/src/animate/runners/count-up.ts
deleted file mode 100644
index 4d36765..0000000
--- a/src/animate/runners/count-up.ts
+++ /dev/null
@@ -1,93 +0,0 @@
-// count-up — tween a numeric path from `from` to `to` over `duration_ms`.
-//
-// The runner steps via requestAnimationFrame and writes the in-flight
-// value through `store.set()` on every tick. Components reading the
-// signal re-render with the latest number ; no patches are pushed on
-// the wire — by design.
-//
-// Params (all optional, defaults in code) :
-//   - from         : starting value (default 0)
-//   - to           : ending value (default 0)
-//   - decimals     : rounding (default 0)
-//   - formatter    : "integer" | "decimal" — informational only.
-
-import type { ActionRunner } from "../action-runner";
-import { resolveEasing } from "../easing-resolver";
-
-interface CountUpParams {
-  from?: number;
-  to?: number;
-  decimals?: number;
-}
-
-const DEFAULT_DURATION_MS = 800;
-
-export const runCountUp: ActionRunner = async (ctx) => {
-  const { store, patch, signal } = ctx;
-  const action = patch.action;
-  if (!action) return;
-  const params = (action.params ?? {}) as CountUpParams;
-  const from = Number.isFinite(params.from) ? (params.from as number) : 0;
-  const toCandidate =
-    typeof patch.value === "number"
-      ? patch.value
-      : Number.isFinite(params.to)
-        ? (params.to as number)
-        : 0;
-  const to = toCandidate;
-  const decimals =
-    typeof params.decimals === "number" && params.decimals >= 0
-      ? Math.floor(params.decimals)
-      : 0;
-  const duration = action.duration_ms ?? DEFAULT_DURATION_MS;
-  const easing = resolveEasing(action.easing);
-
-  // Edge cases — zero duration or no-op : commit immediately.
-  if (duration <= 0 || from === to) {
-    store.set(patch.path, round(to, decimals), patch.transition);
-    return;
-  }
-
-  const start = nowMs();
-  const raf = pickRaf();
-
-  await new Promise<void>((resolve) => {
-    function tick() {
-      if (signal?.aborted) {
-        store.set(patch.path, round(to, decimals));
-        resolve();
-        return;
-      }
-      const elapsed = nowMs() - start;
-      const t = Math.min(1, elapsed / duration);
-      const eased = easing.fn(t);
-      const value = from + (to - from) * eased;
-      store.set(patch.path, round(value, decimals));
-      if (t < 1) raf(tick);
-      else resolve();
-    }
-    raf(tick);
-  });
-};
-
-function round(v: number, decimals: number): number {
-  if (decimals === 0) return Math.round(v);
-  const f = Math.pow(10, decimals);
-  return Math.round(v * f) / f;
-}
-
-function nowMs(): number {
-  if (typeof performance !== "undefined" && typeof performance.now === "function") {
-    return performance.now();
-  }
-  return Date.now();
-}
-
-type RafFn = (cb: FrameRequestCallback) => number;
-
-function pickRaf(): RafFn {
-  if (typeof requestAnimationFrame === "function") {
-    return requestAnimationFrame;
-  }
-  return (cb) => setTimeout(() => cb(nowMs()), 16) as unknown as number;
-}
diff --git a/src/animate/runners/curve-path.ts b/src/animate/runners/curve-path.ts
deleted file mode 100644
index 16c7172..0000000
--- a/src/animate/runners/curve-path.ts
+++ /dev/null
@@ -1,104 +0,0 @@
-// curve-path — sample a curve defined by anchored Bézier handles.
-//
-// The descriptor carries `curve.anchors` (t_pct, value, optional
-// tangents) and a `sample_hz` cadence. We pre-sample once, then walk
-// the sample buffer at the configured rate, writing each sampled
-// value to the store. This avoids any per-frame `getPointAtLength`
-// cost ; for v1, payloads stay short enough that pre-sampling is
-// orders of magnitude under any perceptible cost.
-
-import type { ActionRunner } from "../action-runner";
-
-interface CurveAnchor {
-  t_pct: number;
-  value: number;
-  in_tangent?: { dt: number; dv: number };
-  out_tangent?: { dt: number; dv: number };
-}
-
-const DEFAULT_DURATION_MS = 1000;
-
-export const runCurvePath: ActionRunner = async (ctx) => {
-  const { store, patch, signal } = ctx;
-  const action = patch.action;
-  if (!action?.curve) return;
-
-  const anchors = (action.curve.anchors ?? []).slice().sort(
-    (a, b) => a.t_pct - b.t_pct,
-  );
-  if (anchors.length === 0) return;
-  if (anchors.length === 1) {
-    store.set(patch.path, anchors[0]!.value, patch.transition);
-    return;
-  }
-
-  const duration = action.duration_ms ?? DEFAULT_DURATION_MS;
-  const hz = action.curve.sample_hz ?? 60;
-  const frameMs = 1000 / hz;
-  const totalFrames = Math.max(1, Math.round(duration / frameMs));
-
-  const start = nowMs();
-  const raf = pickRaf();
-  let frame = 0;
-
-  await new Promise<void>((resolve) => {
-    function tick() {
-      if (signal?.aborted) {
-        store.set(patch.path, anchors[anchors.length - 1]!.value);
-        resolve();
-        return;
-      }
-      const elapsed = nowMs() - start;
-      const t = Math.min(1, elapsed / duration);
-      const value = sample(anchors, t * 100);
-      store.set(patch.path, value);
-      frame++;
-      if (t < 1 && frame < totalFrames * 4) raf(tick);
-      else {
-        store.set(patch.path, anchors[anchors.length - 1]!.value);
-        resolve();
-      }
-    }
-    raf(tick);
-  });
-};
-
-function sample(anchors: CurveAnchor[], pct: number): number {
-  if (pct <= anchors[0]!.t_pct) return anchors[0]!.value;
-  const last = anchors[anchors.length - 1]!;
-  if (pct >= last.t_pct) return last.value;
-  for (let i = 0; i < anchors.length - 1; i++) {
-    const a = anchors[i]!;
-    const b = anchors[i + 1]!;
-    if (pct >= a.t_pct && pct <= b.t_pct) {
-      const localT = (pct - a.t_pct) / (b.t_pct - a.t_pct);
-      // Cubic hermite using tangents when present, else linear.
-      const out = a.out_tangent ?? { dt: 0, dv: 0 };
-      const inn = b.in_tangent ?? { dt: 0, dv: 0 };
-      const h00 = 2 * localT ** 3 - 3 * localT ** 2 + 1;
-      const h10 = localT ** 3 - 2 * localT ** 2 + localT;
-      const h01 = -2 * localT ** 3 + 3 * localT ** 2;
-      const h11 = localT ** 3 - localT ** 2;
-      const m0 = out.dv;
-      const m1 = inn.dv;
-      return h00 * a.value + h10 * m0 + h01 * b.value + h11 * m1;
-    }
-  }
-  return last.value;
-}
-
-function nowMs(): number {
-  if (typeof performance !== "undefined" && typeof performance.now === "function") {
-    return performance.now();
-  }
-  return Date.now();
-}
-
-type RafFn = (cb: FrameRequestCallback) => number;
-
-function pickRaf(): RafFn {
-  if (typeof requestAnimationFrame === "function") {
-    return requestAnimationFrame;
-  }
-  return (cb) => setTimeout(() => cb(nowMs()), 16) as unknown as number;
-}
diff --git a/src/animate/runners/mask-reveal.ts b/src/animate/runners/mask-reveal.ts
deleted file mode 100644
index 995f72d..0000000
--- a/src/animate/runners/mask-reveal.ts
+++ /dev/null
@@ -1,99 +0,0 @@
-// mask-reveal — animate a CSS `clip-path` from a hidden state to a
-// fully revealed state. Implementation is GPU-friendly (clip-path
-// composites on the same layer as transform).
-//
-// Params :
-//   - direction : "left-to-right" | "right-to-left" | "top-to-bottom"
-//                 | "bottom-to-top" | "center-out" (default
-//                 "left-to-right")
-
-import type { ActionRunner } from "../action-runner";
-import { resolveEasing } from "../easing-resolver";
-
-interface MaskParams {
-  direction?:
-    | "left-to-right"
-    | "right-to-left"
-    | "top-to-bottom"
-    | "bottom-to-top"
-    | "center-out";
-}
-
-const DEFAULT_DURATION_MS = 600;
-
-const FRAMES: Record<NonNullable<MaskParams["direction"]>, [string, string]> = {
-  "left-to-right": [
-    "inset(0 100% 0 0)",
-    "inset(0 0 0 0)",
-  ],
-  "right-to-left": [
-    "inset(0 0 0 100%)",
-    "inset(0 0 0 0)",
-  ],
-  "top-to-bottom": [
-    "inset(0 0 100% 0)",
-    "inset(0 0 0 0)",
-  ],
-  "bottom-to-top": [
-    "inset(100% 0 0 0)",
-    "inset(0 0 0 0)",
-  ],
-  "center-out": [
-    "inset(50% 50% 50% 50%)",
-    "inset(0 0 0 0)",
-  ],
-};
-
-export const runMaskReveal: ActionRunner = async (ctx) => {
-  const { patch, root, signal } = ctx;
-  const action = patch.action;
-  if (!action) return;
-  const params = (action.params ?? {}) as MaskParams;
-  const dir = params.direction ?? "left-to-right";
-  const duration = action.duration_ms ?? DEFAULT_DURATION_MS;
-  const easing = resolveEasing(action.easing).css;
-
-  const target = resolveTarget(root, patch.path);
-  if (!target) return;
-
-  const frames = FRAMES[dir];
-  if (typeof target.animate !== "function") {
-    target.style.clipPath = frames[1];
-    return;
-  }
-  const anim = target.animate(
-    [{ clipPath: frames[0] }, { clipPath: frames[1] }],
-    { duration, easing, fill: "both" },
-  );
-  signal?.addEventListener("abort", () => anim.cancel());
-  await anim.finished.then(
-    () => undefined,
-    () => undefined,
-  );
-};
-
-function resolveTarget(
-  root: HTMLElement | null | undefined,
-  path: string,
-): HTMLElement | null {
-  if (!root) return null;
-  const exact = root.querySelector<HTMLElement>(
-    `[data-anim-path="${cssEscape(path)}"]`,
-  );
-  if (exact) return exact;
-  const last = path.split(/[.[\]]/).filter(Boolean).pop();
-  if (last) {
-    const byId = root.querySelector<HTMLElement>(
-      `[data-anim-id="${cssEscape(last)}"]`,
-    );
-    if (byId) return byId;
-  }
-  return root;
-}
-
-function cssEscape(s: string): string {
-  if (typeof CSS !== "undefined" && typeof CSS.escape === "function") {
-    return CSS.escape(s);
-  }
-  return s.replace(/["\\]/g, "\\$&");
-}
diff --git a/src/animate/runners/reorder.ts b/src/animate/runners/reorder.ts
deleted file mode 100644
index ed21f3a..0000000
--- a/src/animate/runners/reorder.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-// reorder — FLIP animate the children of a list when their order
-// changes. Two consumption patterns :
-//
-//   1. The patch carries a new ordering as `patch.value` (an array of
-//      ids). The runner captures FIRST, writes the value to the store
-//      (component re-renders with new order), then PLAYs.
-//   2. The host mutates the DOM imperatively in `mutate` (rare in
-//      Solar — exposed for symmetry with Prism's preview).
-//
-// Either way the FLIP technique itself comes from `../flip.ts`, the
-// canonical implementation shared with Prism.
-
-import type { ActionRunner } from "../action-runner";
-import { captureFlip, playFlip } from "../flip";
-import { resolveEasing } from "../easing-resolver";
-
-interface ReorderParams {
-  /** Override the FLIP-id selector (default `[data-flip-id]`). */
-  selector?: string;
-  /** Total animation duration in ms (overrides action.duration_ms). */
-  duration_ms?: number;
-}
-
-const DEFAULT_DURATION_MS = 400;
-
-export const runReorder: ActionRunner = async (ctx) => {
-  const { store, patch, root } = ctx;
-  const action = patch.action;
-  if (!action) return;
-  if (!root) {
-    // No DOM access — fall back to a plain state write. The host's
-    // primitive will reconcile order without animation.
-    store.set(patch.path, patch.value, patch.transition);
-    return;
-  }
-  const params = (action.params ?? {}) as ReorderParams;
-  const selector = params.selector ?? "[data-flip-id]";
-  const duration =
-    params.duration_ms ?? action.duration_ms ?? DEFAULT_DURATION_MS;
-  const easing = resolveEasing(action.easing).css;
-
-  const snapshot = captureFlip(root, selector);
-
-  // Trigger the reorder by writing the new value into the store. We
-  // wait one microtask + one animation frame to let React commit the
-  // DOM mutation before we measure LAST.
-  store.set(patch.path, patch.value, patch.transition);
-  await flushFrame();
-
-  await playFlip(root, snapshot, { duration, easing, selector });
-};
-
-function flushFrame(): Promise<void> {
-  return new Promise((resolve) => {
-    const raf =
-      typeof requestAnimationFrame === "function"
-        ? requestAnimationFrame
-        : (cb: FrameRequestCallback) =>
-            setTimeout(() => cb(Date.now()), 16) as unknown as number;
-    raf(() => raf(() => resolve()));
-  });
-}
diff --git a/src/animate/runners/stagger-group.ts b/src/animate/runners/stagger-group.ts
deleted file mode 100644
index 7a787a6..0000000
--- a/src/animate/runners/stagger-group.ts
+++ /dev/null
@@ -1,128 +0,0 @@
-// stagger-group / text-reveal — animate each child of the targeted
-// node with a staggered start. Works entirely against the DOM via
-// WAAPI so the host doesn't need to wire signals for every unit.
-//
-// The runner selects children with `child_selector` (default
-// `[data-anim-unit]`), then schedules an opacity+transform animation
-// for each one staggered by `stagger_ms`. Children that lack
-// `el.animate` are upgraded synchronously (final state applied) so
-// SSR / static fallbacks stay functional.
-
-import type { ActionRunner, ActionContext } from "../action-runner";
-import { resolveEasing } from "../easing-resolver";
-
-interface StaggerParams {
-  stagger_ms?: number;
-  per_unit_ms?: number;
-  /** Initial opacity (default 0). */
-  from_opacity?: number;
-  /** Initial translateY in px (default 8). */
-  from_y?: number;
-}
-
-interface StaggerDefaults {
-  defaultStaggerMs: number;
-  defaultPerUnitMs: number;
-  defaultSelector: string;
-  stateAttr?: string;
-}
-
-export async function runChildStagger(
-  ctx: ActionContext,
-  defaults: StaggerDefaults,
-): Promise<void> {
-  const { patch, root, signal } = ctx;
-  const action = patch.action;
-  if (!action) return;
-  const params = (action.params ?? {}) as StaggerParams;
-  const staggerMs = params.stagger_ms ?? defaults.defaultStaggerMs;
-  const perUnitMs = params.per_unit_ms ?? defaults.defaultPerUnitMs;
-  const fromOpacity = params.from_opacity ?? 0;
-  const fromY = params.from_y ?? 8;
-  const easing = resolveEasing(action.easing).css;
-
-  const target = resolveTarget(root, patch.path);
-  if (!target) return;
-
-  const selector =
-    action.child_selector?.kind === "css-selector" &&
-    typeof action.child_selector.value === "string"
-      ? action.child_selector.value
-      : defaults.defaultSelector;
-  const children = Array.from(
-    target.querySelectorAll<HTMLElement>(selector),
-  );
-  if (children.length === 0) return;
-
-  const animations: Animation[] = [];
-  children.forEach((el, i) => {
-    if (defaults.stateAttr) el.setAttribute(defaults.stateAttr, "in");
-    const delay = i * staggerMs;
-    if (typeof el.animate !== "function") {
-      el.style.opacity = "1";
-      el.style.transform = "translateY(0)";
-      return;
-    }
-    const anim = el.animate(
-      [
-        { opacity: fromOpacity, transform: `translateY(${fromY}px)` },
-        { opacity: 1, transform: "translateY(0)" },
-      ],
-      { duration: perUnitMs, delay, easing, fill: "both" },
-    );
-    animations.push(anim);
-  });
-
-  if (signal) {
-    signal.addEventListener("abort", () => {
-      animations.forEach((a) => a.cancel());
-    });
-  }
-
-  await Promise.all(
-    animations.map((a) =>
-      a.finished.then(
-        () => undefined,
-        () => undefined,
-      ),
-    ),
-  );
-}
-
-export const runStaggerGroup: ActionRunner = async (ctx) => {
-  await runChildStagger(ctx, {
-    defaultStaggerMs: 60,
-    defaultPerUnitMs: 320,
-    defaultSelector: "[data-anim-child]",
-  });
-};
-
-function resolveTarget(
-  root: HTMLElement | null | undefined,
-  path: string,
-): HTMLElement | null {
-  if (!root) return null;
-  // Resolution order :
-  //   1. exact `[data-anim-path="<path>"]`
-  //   2. `[data-anim-id="<last segment>"]`
-  //   3. root itself (fallback — stagger over its children)
-  const exact = root.querySelector<HTMLElement>(
-    `[data-anim-path="${cssEscape(path)}"]`,
-  );
-  if (exact) return exact;
-  const last = path.split(/[.[\]]/).filter(Boolean).pop();
-  if (last) {
-    const byId = root.querySelector<HTMLElement>(
-      `[data-anim-id="${cssEscape(last)}"]`,
-    );
-    if (byId) return byId;
-  }
-  return root;
-}
-
-function cssEscape(s: string): string {
-  if (typeof CSS !== "undefined" && typeof CSS.escape === "function") {
-    return CSS.escape(s);
-  }
-  return s.replace(/["\\]/g, "\\$&");
-}
diff --git a/src/animate/runners/text-reveal.ts b/src/animate/runners/text-reveal.ts
deleted file mode 100644
index 40cba33..0000000
--- a/src/animate/runners/text-reveal.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-// text-reveal — stagger child elements that the host marked with the
-// configured selector. The runner toggles `data-anim-state` on each
-// child and animates opacity + transform via WAAPI ; CSS authored by
-// the host can hook into the state attribute for richer effects.
-//
-// Params :
-//   - unit            : "letter" | "word" — informational, the host
-//                       decides how to split. Default "letter".
-//   - stagger_ms      : delay between consecutive children. Default 30.
-//   - per_unit_ms     : duration of each unit's animation. Default 240.
-
-import type { ActionRunner } from "../action-runner";
-import { runChildStagger } from "./stagger-group";
-
-export const runTextReveal: ActionRunner = async (ctx) => {
-  // text-reveal is a stagger-group with text-friendly defaults.
-  await runChildStagger(ctx, {
-    defaultStaggerMs: 30,
-    defaultPerUnitMs: 240,
-    defaultSelector: "[data-anim-unit]",
-    stateAttr: "data-anim-state",
-  });
-};
diff --git a/src/animate/transitions.ts b/src/animate/transitions.ts
deleted file mode 100644
index 36125fc..0000000
--- a/src/animate/transitions.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-// Translate an ADR 002 `Transition` into a Framer Motion transition.
-//
-// We deliberately animate only GPU-friendly properties — transform,
-// opacity, filter on a separate layer. Primitives enforce this at
-// the DOM level by exposing those props as motion-bindable values
-// rather than raw CSS.
-
-import type { Transition as Tx } from "../transport/protocol";
-
-export type FramerEasing = "linear" | "easeIn" | "easeOut" | "easeInOut";
-
-export interface FramerTransition {
-  duration?: number;
-  ease?: FramerEasing;
-  type?: "tween" | "spring";
-  stiffness?: number;
-  damping?: number;
-}
-
-const NO_ANIMATION: FramerTransition = { duration: 0 };
-
-const EASE_MAP: Record<string, FramerEasing> = {
-  linear: "linear",
-  "cubic-in": "easeIn",
-  "cubic-out": "easeOut",
-  "cubic-in-out": "easeInOut",
-};
-
-export function toFramer(t: Tx | undefined): FramerTransition {
-  if (!t || t.kind === "none") return NO_ANIMATION;
-  if (t.kind === "tween") {
-    return {
-      type: "tween",
-      duration: (t.duration_ms ?? 0) / 1000,
-      ease: t.ease ? (EASE_MAP[t.ease] ?? "easeOut") : "easeOut",
-    };
-  }
-  if (t.kind === "spring") {
-    return {
-      type: "spring",
-      ...(t.stiffness !== undefined ? { stiffness: t.stiffness } : {}),
-      ...(t.damping !== undefined ? { damping: t.damping } : {}),
-    };
-  }
-  // crossfade is handled at scene-tree level (animate/crossfade.tsx)
-  // — at the per-prop level it degenerates into a tween on opacity.
-  return {
-    type: "tween",
-    duration: (t.duration_ms ?? 400) / 1000,
-    ease: "easeInOut",
-  };
-}
diff --git a/src/app.tsx b/src/app.tsx
deleted file mode 100644
index b0a3747..0000000
--- a/src/app.tsx
+++ /dev/null
@@ -1,96 +0,0 @@
-// Top-level React component for a mounted Solar instance. Reads the
-// runtime signals (bundle / status) and dispatches to the right mode.
-//
-// Per-mode code splitting : the BroadcastMode / ControlMode / TestMode
-// components live in separate chunks loaded only when the
-// corresponding mode is requested. A broadcast-mode mount never
-// downloads the overlay or test code — the broadcast chunk is the
-// bare minimum Pulsar CEF needs to render the scene. This realises
-// the "tree-shakable overlay" guarantee from chantier-solar.md
-// criterion 6 (a.k.a. 5b in the working summary) at the bundle-stat
-// level, not just at the runtime level.
-//
-// Crossfade-correctness note : AnimatePresence freezes the props of
-// an exiting child so its render tree keeps using the values it held
-// at the moment it started exiting. We embed `SolarRuntimeProvider`
-// inside the motion.div so the exiting view keeps its OLD bundle
-// while AnimatePresence animates it out.
-
-import { useSignals } from "@preact/signals-react/runtime";
-import type { Signal } from "@preact/signals-react";
-import { AnimatePresence, motion } from "framer-motion";
-import { lazy, Suspense } from "react";
-import type { Store } from "./state/store";
-import type { RenderBundle } from "./render/bundle";
-import type { ConnectionStatus } from "./transport/ws";
-import { SolarRuntimeProvider } from "./overlay/runtime-context";
-import type { SolarMode } from "./types";
-
-const LazyBroadcastMode = lazy(() =>
-  import("./modes/broadcast").then((m) => ({ default: m.BroadcastMode })),
-);
-const LazyControlMode = lazy(() =>
-  import("./modes/control").then((m) => ({ default: m.ControlMode })),
-);
-const LazyTestMode = lazy(() =>
-  import("./modes/test").then((m) => ({ default: m.TestMode })),
-);
-
-export interface SolarAppProps {
-  mode: SolarMode;
-  store: Store;
-  bundleSignal: Signal<RenderBundle | null>;
-  statusSignal: Signal<ConnectionStatus>;
-  crossfadeKeySignal: Signal<string>;
-  sendInput: (path: string, value: unknown, clientMsgId?: string) => void;
-}
-
-export function SolarApp({
-  mode,
-  store,
-  bundleSignal,
-  statusSignal,
-  crossfadeKeySignal,
-  sendInput,
-}: SolarAppProps) {
-  useSignals();
-
-  const bundle = bundleSignal.value;
-  const status = statusSignal.value;
-  const trackKey = crossfadeKeySignal.value;
-  if (!bundle) return null;
-
-  const ModeComponent =
-    mode === "broadcast"
-      ? LazyBroadcastMode
-      : mode === "control"
-        ? LazyControlMode
-        : LazyTestMode;
-
-  return (
-    <AnimatePresence mode="sync">
-      <motion.div
-        key={trackKey}
-        initial={{ opacity: 0 }}
-        animate={{ opacity: 1 }}
-        exit={{ opacity: 0 }}
-        transition={{ duration: 0.4, ease: "easeInOut" }}
-        style={{ position: "absolute", inset: 0 }}
-      >
-        <SolarRuntimeProvider
-          value={{
-            mode,
-            store,
-            bundle,
-            status,
-            sendInput,
-          }}
-        >
-          <Suspense fallback={null}>
-            <ModeComponent />
-          </Suspense>
-        </SolarRuntimeProvider>
-      </motion.div>
-    </AnimatePresence>
-  );
-}
diff --git a/src/dev-entry.tsx b/src/dev-entry.tsx
index f0a0848..a589d1d 100644
--- a/src/dev-entry.tsx
+++ b/src/dev-entry.tsx
@@ -1,22 +1,27 @@
-// Dev / e2e harness entry. NOT shipped in the library bundle.
+// Dev / E2E harness entry — NOT part of the published bundle.
 //
-// Reads URL query params and mounts Solar against the requested
-// Orion endpoint. Used by `npm run dev` and by Playwright e2e tests
-// (which set the params to point at the test mock-orion).
+// `index.html` loads this module so `npm run dev` and the Playwright
+// harness can mount() Solar against a mock LSDP server. Reads URL query
+// params (orion / token / mode / scene / session), falls back to sane
+// defaults, and mounts. The production counterpart is generated by
+// scripts/build-host-html.mjs (inlined into dist/index.html).
+//
+// Excluded from tsconfig.lib.json + the dts build + the Vite library
+// entry — it never ships in solar.js.
 
-import { mount } from "./index";
+import { mount } from "./mount";
 import type { SolarMode } from "./types";
 
 const params = new URLSearchParams(window.location.search);
-
 const orionUrl =
-  params.get("orion") ?? "ws://127.0.0.1:8080/orion/api/v1/show/stream";
-const token = params.get("token") ?? "dev-token";
-const modeParam = params.get("mode") ?? "control";
-const mode: SolarMode =
-  modeParam === "broadcast" || modeParam === "test" || modeParam === "control"
-    ? (modeParam as SolarMode)
-    : "control";
+  params.get("orion") ?? `ws://${location.host}/lsdp/v1/show/stream`;
+const token = params.get("token") ?? "";
+const modeParam = params.get("mode") ?? "broadcast";
+const mode: SolarMode = (
+  ["broadcast", "control", "test"] as const
+).includes(modeParam as SolarMode)
+  ? (modeParam as SolarMode)
+  : "broadcast";
 const scene = params.get("scene") ?? undefined;
 const testSession = params.get("session") ?? undefined;
 
@@ -33,6 +38,9 @@ mount({
   ...(mode === "test" && scene ? { scene } : {}),
   ...(mode === "test" && testSession ? { testSession } : {}),
   onError: (err) => {
-    console.error("[solar]", err);
+    // Dev only — surface to the console. Broadcast hosts must not render
+    // chrome ; the operator overlay (control/test modes) is the runtime's
+    // own concern now.
+    console.error("[solar dev]", err);
   },
 });
diff --git a/src/index.ts b/src/index.ts
index 1e19913..2163a69 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -11,45 +11,3 @@ export type {
   SolarError,
   SolarErrorCode,
 } from "./types";
-
-// --- chantier Solar action runner ------------------------------------
-
-export { PrismScene } from "./scene/prism-scene";
-export type {
-  PrismSceneOptions,
-  PrismSceneEvent,
-  SceneJson,
-  AnimationDef,
-  AnimationEventPayload,
-  AnimationHandler,
-  OrionConnectOptions,
-} from "./scene/prism-scene";
-
-export type {
-  Patch,
-  Transition,
-  TweenTransition,
-  SpringTransition,
-  CrossfadeTransition,
-  NoTransition,
-  ActionDescriptor,
-  ActionKind,
-  EasingRef,
-} from "./transport/protocol";
-
-// Action-runner pieces — exported for hosts that want to build on
-// the same primitives (Prism preview, custom integrations).
-export {
-  runAction,
-  hasAction,
-  registerActionRunner,
-  UnknownActionKindError,
-} from "./animate/action-runner";
-export type {
-  ActionContext,
-  ActionRunner,
-} from "./animate/action-runner";
-
-// FLIP — single source of truth shared with Prism preview.
-export { captureFlip, playFlip, withFlip } from "./animate/flip";
-export type { FlipSnapshot, FlipPlayOptions } from "./animate/flip";
diff --git a/src/modes/broadcast.tsx b/src/modes/broadcast.tsx
deleted file mode 100644
index 4da072b..0000000
--- a/src/modes/broadcast.tsx
+++ /dev/null
@@ -1,8 +0,0 @@
-import { Tree } from "../render/tree";
-import { useSolarRuntime } from "../overlay/runtime-context";
-
-/** Broadcast mode : pure scene render, no UI chrome. */
-export function BroadcastMode() {
-  const { store, bundle } = useSolarRuntime();
-  return <Tree node={bundle.root} store={store} />;
-}
diff --git a/src/modes/control.tsx b/src/modes/control.tsx
deleted file mode 100644
index 2598676..0000000
--- a/src/modes/control.tsx
+++ /dev/null
@@ -1,17 +0,0 @@
-import { Tree } from "../render/tree";
-import { ControlPanel } from "../overlay/control";
-import { StatusPill } from "../overlay/status-pill";
-import { useSolarRuntime } from "../overlay/runtime-context";
-
-/** Control mode : scene + operator overlay (status pill + fields
- *  panel from operator_inputs). */
-export function ControlMode() {
-  const { store, bundle } = useSolarRuntime();
-  return (
-    <>
-      <Tree node={bundle.root} store={store} />
-      <StatusPill />
-      <ControlPanel />
-    </>
-  );
-}
diff --git a/src/modes/test.tsx b/src/modes/test.tsx
deleted file mode 100644
index 41c0b52..0000000
--- a/src/modes/test.tsx
+++ /dev/null
@@ -1,19 +0,0 @@
-import { Tree } from "../render/tree";
-import { ControlPanel } from "../overlay/control";
-import { TestPanel } from "../overlay/test";
-import { StatusPill } from "../overlay/status-pill";
-import { useSolarRuntime } from "../overlay/runtime-context";
-
-/** Test mode : scene + operator overlay + test extensions (adapter
- *  mocker, state inspector, time controls). */
-export function TestMode() {
-  const { store, bundle } = useSolarRuntime();
-  return (
-    <>
-      <Tree node={bundle.root} store={store} />
-      <StatusPill />
-      <ControlPanel />
-      <TestPanel />
-    </>
-  );
-}
diff --git a/src/mount.ts b/src/mount.ts
index 803519f..af9d568 100644
--- a/src/mount.ts
+++ b/src/mount.ts
@@ -1,195 +1,86 @@
-import { signal } from "@preact/signals-react";
-import { createRoot, type Root } from "react-dom/client";
-import { createElement } from "react";
-import type { MountOptions, SolarHandle, SolarError, SolarToken } from "./types";
-import { createStore } from "./state/store";
-import { applySnapshot } from "./state/apply-snapshot";
-import { applyDelta } from "./state/apply-delta";
-import {
-  createBundleFetcher,
-  type BundleFetcher,
-  type RenderBundle,
-} from "./render/bundle";
-import { TransportError, WsClient, type ConnectionStatus } from "./transport/ws";
-import { SolarApp } from "./app";
+// Solar's public mount() — a thin adapter over @lumencast/runtime.
+//
+// Since ADR 007 (Lumencast convergence, sub-chantier B), Solar no longer
+// carries its own render tree, LSDP transport or leaf-grain state. Those
+// were duplicates of what `@lumencast/runtime` already ships to spec
+// (LSML 1.1 render + LSDP/1.1 wire). Solar's reason to exist is now the
+// Zab-facing contract : a stable `mount()` + `SolarError` taxonomy the
+// three hosts (Pulsar CEF / Prism webview / editor preview) depend on,
+// mapped onto the runtime's `mount()`.
+//
+// Contract mapping (Solar → runtime) :
+//   - `orionUrl`            → `serverUrl`   (Zab keeps the Orion-named field)
+//   - `token` (SolarToken)  → `token`       (structurally identical)
+//   - `mode`                → `mode`        (same broadcast/control/test union)
+//   - `testSession`/`scene` → idem          (only meaningful in test mode)
+//   - `onStatus`            → `onStatus`    (identical disconnected/connecting/live)
+//   - `onError`             → `onError`     (LumencastError ≡ SolarError ; the
+//                                            protocol ErrorCode union is byte-
+//                                            equal to SolarErrorCode)
+//   - return SolarHandle    ← LumencastHandle ({ disconnect, setToken } same shape)
+//
+// The runtime owns the lifecycle (subscribe → snapshot → bundle fetch →
+// delta → scene_changed → crossfade → token rotation → teardown). Solar
+// validates options up-front (host-friendly errors with the `solar.mount:`
+// prefix the hosts assert on) and delegates.
+
+import { mount as mountRuntime } from "@lumencast/runtime";
+import type {
+  LumencastError,
+  LumencastStatus,
+  MountOptions as RuntimeMountOptions,
+} from "@lumencast/runtime";
 import { validateOptions } from "./internal/validate-options";
+import type { MountOptions, SolarError, SolarHandle, SolarStatus } from "./types";
 
-/**
- * Mount Solar against an Orion WS endpoint and render the active scene
- * (or a test session's scene) into `target`.
- *
- * Lifecycle :
- *   1. Open the WS, send subscribe (handled by WsClient).
- *   2. On snapshot : fetch render bundle by `scene_version`, seed
- *      store, render React tree.
- *   3. On delta : apply patches to store ; bound signals update,
- *      bound primitives re-render.
- *   4. On scene_changed : fetch new bundle, swap tree (the Crossfade
- *      wrapper fades old → new based on `crossfadeKey` change).
- *   5. setToken() rotates the WS auth without re-mounting React.
- *   6. disconnect() tears down the WS, unmounts the React root.
- */
 export function mount(options: MountOptions): SolarHandle {
+  // Host-friendly validation with Solar's own message prefix. The runtime
+  // validates too, but its messages say "Lumencast" — hosts assert on
+  // "solar.mount:".
   validateOptions(options);
-  options.onStatus?.("disconnected");
 
-  const store = createStore();
-  const baseUrl = deriveBaseUrl(options.orionUrl);
-  const bundleFetcher = createBundleFetcher({ baseUrl });
-
-  const bundleSignal = signal<RenderBundle | null>(null);
-  const statusSignal = signal<ConnectionStatus>("disconnected");
-  const crossfadeKeySignal = signal<string>("__initial__");
-
-  // Forward status to the host without dropping the operator-overlay
-  // signal-driven updates.
-  const setStatus = (status: ConnectionStatus): void => {
-    statusSignal.value = status;
-    options.onStatus?.(status);
-  };
-
-  // Plumb the host's onError through to a typed SolarError.
-  const reportError = (err: SolarError): void => {
-    options.onError?.(err);
-  };
-
-  let active = true;
-
-  const ws = new WsClient({
-    url: options.orionUrl,
+  const runtimeOptions: RuntimeMountOptions = {
+    target: options.target,
+    serverUrl: options.orionUrl,
     token: options.token,
-    onStatus: setStatus,
-    onSnapshot: (msg) => {
-      if (!active) return;
-      void onSnapshot(
-        bundleFetcher,
-        store,
-        bundleSignal,
-        crossfadeKeySignal,
-        msg.scene_id,
-        msg.scene_version,
-        () => {
-          applySnapshot(store, msg);
-        },
-        reportError,
-      );
-    },
-    onDelta: (msg) => {
-      if (!active) return;
-      applyDelta(store, msg);
-    },
-    onSceneChanged: (_msg) => {
-      if (!active) return;
-      // The fresh snapshot that follows will carry the new
-      // scene_version, drive the bundle fetch, and flip the
-      // crossfade key. We don't act eagerly here — the snapshot is
-      // always the source of truth (ADR 002 § 11). Server-declared
-      // transition duration is honoured by Crossfade's default for
-      // v1 ; per-event duration override lands in a follow-up.
-    },
-    onServerError: (msg) => {
-      reportError({
-        code: msg.code,
-        message: msg.message,
-        recoverable: msg.recoverable,
-      });
-    },
-    onTransportError: (err) => {
-      reportError(transportToSolarError(err));
-    },
-  });
-
-  void (async function bootstrap() {
-    if (options.mode === "test") {
-      // Test sessions are scene-scoped — their WS URL already
-      // identifies the scene, so the server's first snapshot fixes
-      // the active scene.
-    }
-    ws.start();
-  })();
+    mode: options.mode,
+    ...(options.testSession !== undefined
+      ? { testSession: options.testSession }
+      : {}),
+    ...(options.scene !== undefined ? { scene: options.scene } : {}),
+    ...(options.onStatus
+      ? { onStatus: (status: LumencastStatus): void => options.onStatus?.(toSolarStatus(status)) }
+      : {}),
+    ...(options.onError
+      ? { onError: (err: LumencastError): void => options.onError?.(toSolarError(err)) }
+      : {}),
+  };
 
-  // React root.
-  const root: Root = createRoot(options.target);
-  root.render(
-    createElement(SolarApp, {
-      mode: options.mode,
-      store,
-      bundleSignal,
-      statusSignal,
-      crossfadeKeySignal,
-      sendInput: (path, value, clientMsgId) =>
-        ws.sendInput(path, value, clientMsgId),
-    }),
-  );
+  const handle = mountRuntime(runtimeOptions);
 
   return {
-    disconnect() {
-      if (!active) return;
-      active = false;
-      ws.close();
-      root.unmount();
-    },
-    setToken(token: SolarToken) {
-      if (!active) return;
-      ws.setToken(token);
-    },
+    disconnect: () => handle.disconnect(),
+    setToken: (token) => handle.setToken(token),
   };
+}
 
-  // --- helpers (closures over outer scope) ----------------------
+// --- contract mapping helpers -----------------------------------------
 
-  async function onSnapshot(
-    fetcher: BundleFetcher,
-    _store: typeof store,
-    bSignal: typeof bundleSignal,
-    cSignal: typeof crossfadeKeySignal,
-    sceneId: string,
-    sceneVersion: string,
-    applyState: () => void,
-    onErr: (err: SolarError) => void,
-  ): Promise<void> {
-    let bundle: RenderBundle;
-    try {
-      bundle = await fetcher.get(sceneId, sceneVersion);
-    } catch (err) {
-      onErr({
-        code: "BUNDLE_FETCH_FAILED",
-        message:
-          err instanceof Error ? err.message : "render bundle fetch failed",
-        recoverable: true,
-      });
-      return;
-    }
-    if (!active) return;
-    applyState();
-    bSignal.value = bundle;
-    // Trigger the crossfade : a fresh key drives AnimatePresence to
-    // mount the new tree with an opacity tween.
-    cSignal.value = `${sceneId}::${sceneVersion}`;
-  }
+// The two status unions are identical ("disconnected" | "connecting" |
+// "live") ; this keeps the boundary explicit and would fail to compile if
+// either side drifted.
+function toSolarStatus(status: LumencastStatus): SolarStatus {
+  return status;
 }
 
-// --- error mapping --------------------------------------------
-
-function transportToSolarError(err: TransportError): SolarError {
-  // The transport reports its own typed reason ; we map a few well-
-  // known cases to dedicated Solar codes and fall back to INTERNAL.
+// `LumencastError` and `SolarError` are structurally identical and the
+// protocol `ErrorCode` union is byte-equal to `SolarErrorCode`, so the
+// forward is lossless. The explicit object construction documents the
+// contract boundary and pins it at compile time.
+function toSolarError(err: LumencastError): SolarError {
   return {
-    code: "INTERNAL",
+    code: err.code,
     message: err.message,
     recoverable: err.recoverable,
   };
 }
-
-// --- URL helpers ----------------------------------------------
-
-function deriveBaseUrl(wsUrl: string): string {
-  // wss://<host>/orion/api/v1/show/stream → https://<host>
-  // ws://<host>/orion/api/v1/show/stream  → http://<host>
-  try {
-    const u = new URL(wsUrl);
-    const httpScheme = u.protocol === "wss:" ? "https:" : "http:";
-    return `${httpScheme}//${u.host}`;
-  } catch {
-    return "";
-  }
-}
diff --git a/src/overlay/control.tsx b/src/overlay/control.tsx
deleted file mode 100644
index c86daf5..0000000
--- a/src/overlay/control.tsx
+++ /dev/null
@@ -1,237 +0,0 @@
-import { useSignals } from "@preact/signals-react/runtime";
-import type { OperatorInput } from "../render/bundle";
-import { useSolarRuntime } from "./runtime-context";
-
-const PANEL_STYLE: React.CSSProperties = {
-  position: "fixed",
-  bottom: 12,
-  left: 12,
-  zIndex: 100_000,
-  width: 320,
-  maxHeight: "70vh",
-  overflowY: "auto",
-  padding: 12,
-  fontFamily:
-    "system-ui, -apple-system, BlinkMacSystemFont, sans-serif",
-  fontSize: 12,
-  color: "#e5e7eb",
-  background: "rgba(17, 24, 39, 0.92)",
-  border: "1px solid rgba(75, 85, 99, 0.6)",
-  borderRadius: 10,
-  boxShadow: "0 8px 32px rgba(0, 0, 0, 0.45)",
-};
-
-const ROW_STYLE: React.CSSProperties = {
-  display: "flex",
-  flexDirection: "column",
-  gap: 4,
-  padding: "6px 0",
-  borderBottom: "1px solid rgba(75, 85, 99, 0.35)",
-};
-
-const LABEL_STYLE: React.CSSProperties = {
-  color: "#9ca3af",
-  fontSize: 10.5,
-  letterSpacing: "0.02em",
-  textTransform: "uppercase",
-};
-
-const INPUT_STYLE: React.CSSProperties = {
-  background: "rgba(31, 41, 55, 0.8)",
-  border: "1px solid rgba(75, 85, 99, 0.6)",
-  borderRadius: 6,
-  color: "#f9fafb",
-  padding: "4px 6px",
-  fontSize: 12,
-  width: "100%",
-};
-
-export function ControlPanel() {
-  const { bundle, store, sendInput } = useSolarRuntime();
-  useSignals();
-
-  const inputs = bundle.operator_inputs ?? [];
-  if (inputs.length === 0) return null;
-
-  // Group entries by `group` field for readability.
-  const groups = new Map<string, OperatorInput[]>();
-  for (const entry of inputs) {
-    const g = entry.group ?? "General";
-    const list = groups.get(g) ?? [];
-    list.push(entry);
-    groups.set(g, list);
-  }
-
-  return (
-    <div style={PANEL_STYLE} data-testid="solar-control-panel">
-      <div
-        style={{
-          fontWeight: 600,
-          fontSize: 11,
-          letterSpacing: "0.06em",
-          color: "#9ca3af",
-          textTransform: "uppercase",
-          marginBottom: 6,
-        }}
-      >
-        Operator inputs
-      </div>
-      {[...groups.entries()].map(([group, entries]) => (
-        <div key={group} style={{ marginBottom: 8 }}>
-          <div
-            style={{
-              color: "#6b7280",
-              fontSize: 10,
-              letterSpacing: "0.04em",
-              textTransform: "uppercase",
-              padding: "4px 0",
-            }}
-          >
-            {group}
-          </div>
-          {entries.map((entry) => (
-            <InputRow
-              key={entry.path}
-              entry={entry}
-              currentValue={store.signal(entry.path).value}
-              onCommit={(v) => sendInput(entry.path, v)}
-            />
-          ))}
-        </div>
-      ))}
-    </div>
-  );
-}
-
-function InputRow({
-  entry,
-  currentValue,
-  onCommit,
-}: {
-  entry: OperatorInput;
-  currentValue: unknown;
-  onCommit: (value: unknown) => void;
-}) {
-  return (
-    <div style={ROW_STYLE}>
-      <span style={LABEL_STYLE}>{entry.label}</span>
-      <Editor entry={entry} currentValue={currentValue} onCommit={onCommit} />
-    </div>
-  );
-}
-
-function Editor({
-  entry,
-  currentValue,
-  onCommit,
-}: {
-  entry: OperatorInput;
-  currentValue: unknown;
-  onCommit: (value: unknown) => void;
-}) {
-  switch (entry.type) {
-    case "boolean": {
-      const checked = currentValue === true;
-      return (
-        <label style={{ display: "flex", alignItems: "center", gap: 6 }}>
-          <input
-            type="checkbox"
-            checked={checked}
-            onChange={(e) => onCommit(e.target.checked)}
-          />
-          <span style={{ fontSize: 11, color: "#d1d5db" }}>
-            {checked ? "on" : "off"}
-          </span>
-        </label>
-      );
-    }
-    case "number": {
-      const min = entry.min as number | undefined;
-      const max = entry.max as number | undefined;
-      const step = entry.step as number | undefined;
-      return (
-        <input
-          type="number"
-          style={INPUT_STYLE}
-          value={typeof currentValue === "number" ? currentValue : ""}
-          min={min}
-          max={max}
-          step={step}
-          onChange={(e) => {
-            const n = Number(e.target.value);
-            if (Number.isFinite(n)) onCommit(n);
-          }}
-        />
-      );
-    }
-    case "text": {
-      const max = entry.max_length as number | undefined;
-      return (
-        <input
-          type="text"
-          style={INPUT_STYLE}
-          value={typeof currentValue === "string" ? currentValue : ""}
-          maxLength={max}
-          onChange={(e) => onCommit(e.target.value)}
-        />
-      );
-    }
-    case "colour": {
-      return (
-        <input
-          type="color"
-          style={INPUT_STYLE}
-          value={typeof currentValue === "string" ? currentValue : "#000000"}
-          onChange={(e) => onCommit(e.target.value)}
-        />
-      );
-    }
-    case "duration": {
-      return (
-        <input
-          type="number"
-          style={INPUT_STYLE}
-          value={typeof currentValue === "number" ? currentValue : ""}
-          min={0}
-          step={100}
-          onChange={(e) => {
-            const n = Number(e.target.value);
-            if (Number.isFinite(n) && n >= 0) onCommit(n);
-          }}
-        />
-      );
-    }
-    case "select":
-    case "enum": {
-      const options =
-        (entry.enum_values as string[] | undefined) ??
-        (entry.options as string[] | undefined) ??
-        [];
-      return (
-        <select
-          style={INPUT_STYLE}
-          value={typeof currentValue === "string" ? currentValue : ""}
-          onChange={(e) => onCommit(e.target.value)}
-        >
-          {options.map((opt) => (
-            <option key={opt} value={opt}>
-              {opt}
-            </option>
-          ))}
-        </select>
-      );
-    }
-    case "path-ref":
-    default:
-      // FIXME (v2) — `path-ref` UX is deferred ; for now show a plain
-      // text entry so the value is still editable.
-      return (
-        <input
-          type="text"
-          style={INPUT_STYLE}
-          value={typeof currentValue === "string" ? currentValue : ""}
-          onChange={(e) => onCommit(e.target.value)}
-        />
-      );
-  }
-}
diff --git a/src/overlay/runtime-context.tsx b/src/overlay/runtime-context.tsx
deleted file mode 100644
index abbe402..0000000
--- a/src/overlay/runtime-context.tsx
+++ /dev/null
@@ -1,35 +0,0 @@
-import { createContext, useContext, type ReactNode } from "react";
-import type { Store } from "../state/store";
-import type { RenderBundle } from "../render/bundle";
-import type { ConnectionStatus } from "../transport/ws";
-import type { SolarMode } from "../types";
-
-export interface SolarRuntime {
-  mode: SolarMode;
-  store: Store;
-  bundle: RenderBundle;
-  status: ConnectionStatus;
-  sendInput: (path: string, value: unknown, clientMsgId?: string) => void;
-}
-
-const Ctx = createContext<SolarRuntime | null>(null);
-
-export function SolarRuntimeProvider({
-  value,
-  children,
-}: {
-  value: SolarRuntime;
-  children: ReactNode;
-}) {
-  return <Ctx.Provider value={value}>{children}</Ctx.Provider>;
-}
-
-export function useSolarRuntime(): SolarRuntime {
-  const v = useContext(Ctx);
-  if (!v) {
-    throw new Error(
-      "Solar overlay components must be rendered inside SolarRuntimeProvider",
-    );
-  }
-  return v;
-}
diff --git a/src/overlay/status-pill.tsx b/src/overlay/status-pill.tsx
deleted file mode 100644
index 8e8e1b6..0000000
--- a/src/overlay/status-pill.tsx
+++ /dev/null
@@ -1,38 +0,0 @@
-import { useSolarRuntime } from "./runtime-context";
-
-const COLOURS: Record<string, string> = {
-  live: "rgba(34, 197, 94, 0.85)",
-  connecting: "rgba(234, 179, 8, 0.85)",
-  disconnected: "rgba(239, 68, 68, 0.85)",
-};
-
-const LABELS: Record<string, string> = {
-  live: "live",
-  connecting: "reconnecting",
-  disconnected: "disconnected",
-};
-
-export function StatusPill() {
-  const { status } = useSolarRuntime();
-  return (
-    <div
-      data-testid="solar-status-pill"
-      style={{
-        position: "fixed",
-        top: 12,
-        right: 12,
-        padding: "4px 10px",
-        fontSize: 11,
-        fontFamily:
-          "system-ui, -apple-system, BlinkMacSystemFont, sans-serif",
-        color: "white",
-        background: COLOURS[status] ?? "#444",
-        borderRadius: 999,
-        userSelect: "none",
-        pointerEvents: "none",
-      }}
-    >
-      {LABELS[status] ?? status}
-    </div>
-  );
-}
diff --git a/src/overlay/test.tsx b/src/overlay/test.tsx
deleted file mode 100644
index 3172467..0000000
--- a/src/overlay/test.tsx
+++ /dev/null
@@ -1,211 +0,0 @@
-import { useSignals } from "@preact/signals-react/runtime";
-import { useState } from "react";
-import { useSolarRuntime } from "./runtime-context";
-
-const PANEL_STYLE: React.CSSProperties = {
-  position: "fixed",
-  bottom: 12,
-  right: 12,
-  zIndex: 100_001,
-  width: 360,
-  maxHeight: "70vh",
-  overflowY: "auto",
-  padding: 12,
-  fontFamily:
-    "system-ui, -apple-system, BlinkMacSystemFont, sans-serif",
-  fontSize: 12,
-  color: "#e5e7eb",
-  background: "rgba(8, 47, 73, 0.92)",
-  border: "1px solid rgba(56, 189, 248, 0.4)",
-  borderRadius: 10,
-  boxShadow: "0 8px 32px rgba(0, 0, 0, 0.45)",
-};
-
-const SECTION_TITLE: React.CSSProperties = {
-  fontWeight: 600,
-  fontSize: 11,
-  letterSpacing: "0.06em",
-  color: "#7dd3fc",
-  textTransform: "uppercase",
-  marginBottom: 6,
-};
-
-const BUTTON_STYLE: React.CSSProperties = {
-  background: "rgba(14, 165, 233, 0.4)",
-  border: "1px solid rgba(125, 211, 252, 0.5)",
-  borderRadius: 6,
-  color: "#f0f9ff",
-  padding: "3px 8px",
-  fontSize: 11,
-  cursor: "pointer",
-};
-
-const ADAPTER_ROW: React.CSSProperties = {
-  display: "flex",
-  flexDirection: "column",
-  gap: 4,
-  padding: "6px 0",
-  borderBottom: "1px solid rgba(56, 189, 248, 0.2)",
-};
-
-/** Test-mode overlay : adapter mocker + state inspector + time
- *  controls. Drives Orion's __test.* family via the same `sendInput`
- *  channel. */
-export function TestPanel() {
-  const { bundle, store, sendInput } = useSolarRuntime();
-  useSignals();
-  const [filter, setFilter] = useState("");
-
-  const adapters = bundle.external_adapters ?? [];
-  const stateRecord = store.toRecord();
-  const filteredEntries = Object.entries(stateRecord).filter(
-    ([k]) => filter === "" || k.includes(filter),
-  );
-
-  return (
-    <div style={PANEL_STYLE} data-testid="solar-test-panel">
-      {/* Time controls */}
-      <div style={SECTION_TITLE}>Time</div>
-      <div style={{ display: "flex", gap: 6, marginBottom: 8 }}>
-        <button
-          type="button"
-          style={BUTTON_STYLE}
-          onClick={() => sendInput("__test.tick", 100)}
-        >
-          tick +100ms
-        </button>
-        <button
-          type="button"
-          style={BUTTON_STYLE}
-          onClick={() => sendInput("__test.tick", 1_000)}
-        >
-          tick +1s
-        </button>
-        <button
-          type="button"
-          style={BUTTON_STYLE}
-          onClick={() => sendInput("__test.reset", true)}
-        >
-          reset
-        </button>
-      </div>
-
-      {/* Adapter mocker */}
-      <div style={SECTION_TITLE}>External adapters</div>
-      {adapters.length === 0 && (
-        <div style={{ color: "#94a3b8", fontStyle: "italic", fontSize: 11 }}>
-          No external adapters declared in this scene.
-        </div>
-      )}
-      {adapters.map((adapter) => (
-        <AdapterRow
-          key={adapter.key}
-          adapter={adapter}
-          onMock={(payload) =>
-            sendInput("__test.mock_adapter", {
-              key: adapter.key,
-              payload,
-            })
-          }
-        />
-      ))}
-
-      {/* State inspector */}
-      <div style={{ ...SECTION_TITLE, marginTop: 12 }}>State</div>
-      <input
-        type="text"
-        placeholder="filter paths…"
-        value={filter}
-        onChange={(e) => setFilter(e.target.value)}
-        style={{
-          background: "rgba(8, 47, 73, 0.6)",
-          border: "1px solid rgba(125, 211, 252, 0.4)",
-          borderRadius: 6,
-          color: "#e0f2fe",
-          padding: "4px 6px",
-          fontSize: 11,
-          width: "100%",
-          marginBottom: 6,
-        }}
-      />
-      <div style={{ fontFamily: "monospace", fontSize: 10.5 }}>
-        {filteredEntries.map(([path, value]) => (
-          <div
-            key={path}
-            style={{
-              display: "grid",
-              gridTemplateColumns: "1fr auto",
-              gap: 8,
-              padding: "2px 0",
-              borderBottom: "1px dashed rgba(125, 211, 252, 0.15)",
-            }}
-          >
-            <span style={{ color: "#bae6fd" }}>{path}</span>
-            <span style={{ color: "#fef3c7" }}>{formatValue(value)}</span>
-          </div>
-        ))}
-      </div>
-    </div>
-  );
-}
-
-function AdapterRow({
-  adapter,
-  onMock,
-}: {
-  adapter: { key: string; label: string; kind: string };
-  onMock: (payload: unknown) => void;
-}) {
-  const [draft, setDraft] = useState("{}");
-  return (
-    <div style={ADAPTER_ROW}>
-      <div
-        style={{
-          display: "flex",
-          justifyContent: "space-between",
-          alignItems: "center",
-        }}
-      >
-        <span style={{ color: "#e0f2fe" }}>{adapter.label}</span>
-        <span style={{ color: "#94a3b8", fontSize: 10 }}>{adapter.kind}</span>
-      </div>
-      <textarea
-        value={draft}
-        onChange={(e) => setDraft(e.target.value)}
-        rows={2}
-        style={{
-          fontFamily: "monospace",
-          fontSize: 10.5,
-          background: "rgba(8, 47, 73, 0.6)",
-          color: "#e0f2fe",
-          border: "1px solid rgba(125, 211, 252, 0.3)",
-          borderRadius: 4,
-          padding: 4,
-          resize: "vertical",
-        }}
-      />
-      <button
-        type="button"
-        style={BUTTON_STYLE}
-        onClick={() => {
-          try {
-            const parsed = JSON.parse(draft);
-            onMock(parsed);
-          } catch {
-            onMock(draft);
-          }
-        }}
-      >
-        fire
-      </button>
-    </div>
-  );
-}
-
-function formatValue(value: unknown): string {
-  if (value === undefined) return "—";
-  if (value === null) return "null";
-  if (typeof value === "string") return JSON.stringify(value);
-  if (typeof value === "object") return JSON.stringify(value);
-  return String(value);
-}
diff --git a/src/render/bundle.ts b/src/render/bundle.ts
deleted file mode 100644
index e7ded2f..0000000
--- a/src/render/bundle.ts
+++ /dev/null
@@ -1,142 +0,0 @@
-// Render bundle — ADR 003 § 3.
-//
-// The bundle is content-addressed by `scene_version` (sha256 of the
-// canonical graph + bundle bytes — see ADR 004 § 7). Solar fetches it
-// once per `scene_version` and caches forever ; Orion serves it with
-// long-TTL immutable cache headers.
-
-import type { Transition } from "../transport/protocol";
-
-// --- bundle shape ----------------------------------------------------
-
-export type RenderKind =
-  | "stack"
-  | "grid"
-  | "frame"
-  | "text"
-  | "image"
-  | "shape"
-  | "media"
-  | "repeat";
-
-export interface RenderNode {
-  kind: RenderKind;
-  /** Stable identifier for keyed reconciliation. Compiler-assigned. */
-  id?: string;
-  /** Static props (frozen at compile time). */
-  props?: Record<string, unknown>;
-  /** Prop name → state path. The render layer subscribes the path's
-   *  signal and applies the value to the named prop on each change. */
-  bindings?: Record<string, string>;
-  /** Default transition per bound prop. Overridden by a per-delta
-   *  transition on the same path. */
-  transitions?: Record<string, Transition>;
-  /** Children — already-inlined primitives only (user components are
-   *  resolved by Orion's compiler). */
-  children?: RenderNode[];
-}
-
-export type OperatorInputType =
-  | "boolean"
-  | "number"
-  | "text"
-  | "select"
-  | "enum"
-  | "path-ref"
-  | "colour"
-  | "duration";
-
-export interface OperatorInput {
-  path: string;
-  label: string;
-  type: OperatorInputType;
-  default?: unknown;
-  group?: string;
-  writable_by?: string[];
-  // Type-specific extras (kept open — the editor and compiler are the
-  // canonical source of truth ; Solar just renders form controls).
-  [extra: string]: unknown;
-}
-
-export interface ExternalAdapter {
-  key: string;
-  label: string;
-  kind: string;
-  target_paths: string[];
-  [extra: string]: unknown;
-}
-
-export interface Asset {
-  id: string;
-  url: string;
-  kind: string;
-  [extra: string]: unknown;
-}
-
-export interface RenderBundle {
-  scene_version: string;
-  root: RenderNode;
-  operator_inputs?: OperatorInput[];
-  external_adapters?: ExternalAdapter[];
-  assets?: Asset[];
-}
-
-// --- fetch + cache ---------------------------------------------------
-
-export interface BundleFetcher {
-  /** Fetch the bundle for a scene version. Cached forever by hash. */
-  get(sceneId: string, sceneVersion: string): Promise<RenderBundle>;
-  /** Inject a bundle directly — used by tests and for the "scene
-   *  already in flight" handoff path. */
-  preload(bundle: RenderBundle): void;
-}
-
-export interface BundleFetcherOptions {
-  /** Base URL of Orion's static / API host. The fetcher constructs
-   *  `${baseUrl}/orion/api/v1/scenes/{id}/render-bundle?v={hash}`. */
-  baseUrl: string;
-  fetchImpl?: typeof fetch;
-}
-
-class FetcherImpl implements BundleFetcher {
-  private readonly cache = new Map<string, RenderBundle>();
-  private readonly baseUrl: string;
-  private readonly fetchImpl: typeof fetch;
-
-  constructor(opts: BundleFetcherOptions) {
-    this.baseUrl = opts.baseUrl.replace(/\/$/, "");
-    this.fetchImpl = opts.fetchImpl ?? globalThis.fetch.bind(globalThis);
-  }
-
-  preload(bundle: RenderBundle): void {
-    this.cache.set(bundle.scene_version, bundle);
-  }
-
-  async get(sceneId: string, sceneVersion: string): Promise<RenderBundle> {
-    const cached = this.cache.get(sceneVersion);
-    if (cached) return cached;
-    const url = `${this.baseUrl}/orion/api/v1/scenes/${encodeURIComponent(
-      sceneId,
-    )}/render-bundle?v=${encodeURIComponent(sceneVersion)}`;
-    const response = await this.fetchImpl(url);
-    if (!response.ok) {
-      throw new Error(
-        `bundle fetch failed : ${response.status} ${response.statusText}`,
-      );
-    }
-    const json = (await response.json()) as RenderBundle;
-    if (json.scene_version !== sceneVersion) {
-      throw new Error(
-        `bundle scene_version mismatch : expected ${sceneVersion}, got ${json.scene_version}`,
-      );
-    }
-    this.cache.set(sceneVersion, json);
-    return json;
-  }
-}
-
-export function createBundleFetcher(
-  opts: BundleFetcherOptions,
-): BundleFetcher {
-  return new FetcherImpl(opts);
-}
diff --git a/src/render/primitives/frame.tsx b/src/render/primitives/frame.tsx
deleted file mode 100644
index 9efa23d..0000000
--- a/src/render/primitives/frame.tsx
+++ /dev/null
@@ -1,59 +0,0 @@
-import { motion } from "framer-motion";
-import type { PrimitiveProps } from "./index";
-import { toFramer } from "../../animate/transitions";
-
-/** Absolute-positioned container with size + transform + opacity.
- *  Animatable on `transform` and `opacity` only — width/height/position
- *  changes are intentionally *not* animatable to keep the broadcast
- *  off the layout path. */
-export function Frame({ resolved, transitionFor, children }: PrimitiveProps) {
-  const x = numberOr(resolved.x, 0);
-  const y = numberOr(resolved.y, 0);
-  const width = sizeProp(resolved.width);
-  const height = sizeProp(resolved.height);
-  const opacity = numberOr(resolved.opacity, 1);
-  const scale = numberOr(resolved.scale, 1);
-  const rotate = numberOr(resolved.rotate, 0);
-
-  // Pick the most expressive declared transition among the animated
-  // bindings (transform / opacity). If none, no animation.
-  const tx =
-    transitionFor("opacity") ??
-    transitionFor("scale") ??
-    transitionFor("rotate") ??
-    transitionFor("x") ??
-    transitionFor("y");
-
-  return (
-    <motion.div
-      style={{
-        position: "absolute",
-        left: 0,
-        top: 0,
-        width,
-        height,
-        willChange: "transform, opacity",
-      }}
-      animate={{
-        opacity,
-        x,
-        y,
-        scale,
-        rotate,
-      }}
-      transition={toFramer(tx)}
-    >
-      {children}
-    </motion.div>
-  );
-}
-
-function numberOr(v: unknown, fallback: number): number {
-  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
-}
-
-function sizeProp(v: unknown): number | string | undefined {
-  if (typeof v === "number" && Number.isFinite(v)) return v;
-  if (typeof v === "string" && v.length > 0) return v;
-  return undefined;
-}
diff --git a/src/render/primitives/grid.tsx b/src/render/primitives/grid.tsx
deleted file mode 100644
index 0785e80..0000000
--- a/src/render/primitives/grid.tsx
+++ /dev/null
@@ -1,20 +0,0 @@
-import type { PrimitiveProps } from "./index";
-
-/** CSS Grid container with declared rows / cols. */
-export function Grid({ resolved, children }: PrimitiveProps) {
-  const cols = (resolved.cols as string) ?? "1fr";
-  const rows = (resolved.rows as string) ?? "auto";
-  const gap = (resolved.gap as number | string | undefined) ?? 0;
-  return (
-    <div
-      style={{
-        display: "grid",
-        gridTemplateColumns: cols,
-        gridTemplateRows: rows,
-        gap,
-      }}
-    >
-      {children}
-    </div>
-  );
-}
diff --git a/src/render/primitives/image.tsx b/src/render/primitives/image.tsx
deleted file mode 100644
index 21b406f..0000000
--- a/src/render/primitives/image.tsx
+++ /dev/null
@@ -1,35 +0,0 @@
-import { motion } from "framer-motion";
-import type { PrimitiveProps } from "./index";
-import { toFramer } from "../../animate/transitions";
-
-/** Image leaf. `src`, `fit` (cover/contain/fill), `position`,
- *  `opacity`. Opacity is animated when a transition is declared. */
-export function Image({ resolved, transitionFor }: PrimitiveProps) {
-  const src = resolved.src as string | undefined;
-  if (!src) return null;
-  const fit = (resolved.fit as string | undefined) ?? "contain";
-  const position = (resolved.position as string | undefined) ?? "center";
-  const opacity = numberOr(resolved.opacity, 1);
-
-  const tx = transitionFor("opacity") ?? transitionFor("src");
-
-  return (
-    <motion.img
-      src={src}
-      style={{
-        objectFit: fit as React.CSSProperties["objectFit"],
-        objectPosition: position,
-        width: "100%",
-        height: "100%",
-        willChange: "opacity",
-      }}
-      animate={{ opacity }}
-      transition={toFramer(tx)}
-      draggable={false}
-    />
-  );
-}
-
-function numberOr(v: unknown, fallback: number): number {
-  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
-}
diff --git a/src/render/primitives/index.ts b/src/render/primitives/index.ts
deleted file mode 100644
index 5062073..0000000
--- a/src/render/primitives/index.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-// Primitive component registry. Tree dispatch uses this map to look
-// up the React component for each `kind` ; user components are inlined
-// at compile time so Solar's runtime never sees them.
-
-import type { ComponentType } from "react";
-import type { RenderKind } from "../bundle";
-import { Stack } from "./stack";
-import { Grid } from "./grid";
-import { Frame } from "./frame";
-import { Text } from "./text";
-import { Image } from "./image";
-import { Shape } from "./shape";
-import { Media } from "./media";
-// `repeat` is dispatched specially in the tree (it iterates a bound
-// array and provides a path scope to its children) ; it does not
-// appear here as a regular primitive.
-
-export interface PrimitiveProps {
-  resolved: Record<string, unknown>;
-  transitionFor: (key: string) => import("../../transport/protocol").Transition | undefined;
-  children?: import("react").ReactNode;
-}
-
-export const PRIMITIVES: Partial<Record<RenderKind, ComponentType<PrimitiveProps>>> = {
-  stack: Stack,
-  grid: Grid,
-  frame: Frame,
-  text: Text,
-  image: Image,
-  shape: Shape,
-  media: Media,
-};
diff --git a/src/render/primitives/media.tsx b/src/render/primitives/media.tsx
deleted file mode 100644
index 5c03ce4..0000000
--- a/src/render/primitives/media.tsx
+++ /dev/null
@@ -1,28 +0,0 @@
-import type { PrimitiveProps } from "./index";
-
-/** Embedded video. `src`, `loop`, `mute`, `autoplay`. Audio is muted
- *  by default — broadcast audio is Pulsar-side, not from the browser
- *  source. */
-export function Media({ resolved }: PrimitiveProps) {
-  const src = resolved.src as string | undefined;
-  if (!src) return null;
-  const loop = (resolved.loop as boolean | undefined) ?? true;
-  const mute = (resolved.mute as boolean | undefined) ?? true;
-  const autoplay = (resolved.autoplay as boolean | undefined) ?? true;
-  const fit = (resolved.fit as string | undefined) ?? "cover";
-
-  return (
-    <video
-      src={src}
-      autoPlay={autoplay}
-      loop={loop}
-      muted={mute}
-      playsInline
-      style={{
-        width: "100%",
-        height: "100%",
-        objectFit: fit as React.CSSProperties["objectFit"],
-      }}
-    />
-  );
-}
diff --git a/src/render/primitives/shape.tsx b/src/render/primitives/shape.tsx
deleted file mode 100644
index 218b82b..0000000
--- a/src/render/primitives/shape.tsx
+++ /dev/null
@@ -1,89 +0,0 @@
-import { motion } from "framer-motion";
-import type { PrimitiveProps } from "./index";
-import { toFramer } from "../../animate/transitions";
-
-/** Rectangle / circle / line. Renders as SVG so stroke + fill behave
- *  predictably across hosts. Opacity animatable. */
-export function Shape({ resolved, transitionFor }: PrimitiveProps) {
-  const kind = (resolved.kind as string | undefined) ?? "rect";
-  const fill = (resolved.fill as string | undefined) ?? "transparent";
-  const stroke = (resolved.stroke as string | undefined) ?? "transparent";
-  const strokeWidth = numberOr(resolved.stroke_width, 0);
-  const width = numberOr(resolved.width, 100);
-  const height = numberOr(resolved.height, 100);
-  const radius = numberOr(resolved.radius, 0);
-  const opacity = numberOr(resolved.opacity, 1);
-
-  const tx = transitionFor("opacity");
-  const transition = toFramer(tx);
-
-  if (kind === "circle") {
-    return (
-      <motion.svg
-        width={width}
-        height={height}
-        viewBox={`0 0 ${width} ${height}`}
-        animate={{ opacity }}
-        transition={transition}
-        style={{ willChange: "opacity" }}
-      >
-        <circle
-          cx={width / 2}
-          cy={height / 2}
-          r={Math.min(width, height) / 2 - strokeWidth / 2}
-          fill={fill}
-          stroke={stroke}
-          strokeWidth={strokeWidth}
-        />
-      </motion.svg>
-    );
-  }
-  if (kind === "line") {
-    return (
-      <motion.svg
-        width={width}
-        height={height}
-        viewBox={`0 0 ${width} ${height}`}
-        animate={{ opacity }}
-        transition={transition}
-        style={{ willChange: "opacity" }}
-      >
-        <line
-          x1="0"
-          y1={height / 2}
-          x2={width}
-          y2={height / 2}
-          stroke={stroke || fill}
-          strokeWidth={strokeWidth || 1}
-        />
-      </motion.svg>
-    );
-  }
-  // Default : rectangle.
-  return (
-    <motion.svg
-      width={width}
-      height={height}
-      viewBox={`0 0 ${width} ${height}`}
-      animate={{ opacity }}
-      transition={transition}
-      style={{ willChange: "opacity" }}
-    >
-      <rect
-        x={strokeWidth / 2}
-        y={strokeWidth / 2}
-        width={Math.max(0, width - strokeWidth)}
-        height={Math.max(0, height - strokeWidth)}
-        rx={radius}
-        ry={radius}
-        fill={fill}
-        stroke={stroke}
-        strokeWidth={strokeWidth}
-      />
-    </motion.svg>
-  );
-}
-
-function numberOr(v: unknown, fallback: number): number {
-  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
-}
diff --git a/src/render/primitives/stack.tsx b/src/render/primitives/stack.tsx
deleted file mode 100644
index e50c63a..0000000
--- a/src/render/primitives/stack.tsx
+++ /dev/null
@@ -1,27 +0,0 @@
-import type { PrimitiveProps } from "./index";
-
-/** Vertical or horizontal flex container. Layout-only — bindings
- *  here are unusual but tolerated. */
-export function Stack({ resolved, children }: PrimitiveProps) {
-  const direction = (resolved.direction as string) ?? "vertical";
-  const gap = numberOr(resolved.gap, 0);
-  const align = (resolved.align as string) ?? "stretch";
-  const justify = (resolved.justify as string) ?? "flex-start";
-  return (
-    <div
-      style={{
-        display: "flex",
-        flexDirection: direction === "horizontal" ? "row" : "column",
-        gap,
-        alignItems: align,
-        justifyContent: justify,
-      }}
-    >
-      {children}
-    </div>
-  );
-}
-
-function numberOr(v: unknown, fallback: number): number {
-  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
-}
diff --git a/src/render/primitives/text.tsx b/src/render/primitives/text.tsx
deleted file mode 100644
index d0cf9aa..0000000
--- a/src/render/primitives/text.tsx
+++ /dev/null
@@ -1,38 +0,0 @@
-import { motion } from "framer-motion";
-import type { PrimitiveProps } from "./index";
-import { toFramer } from "../../animate/transitions";
-
-/** Text leaf. Value renders as the displayed string ; style props
- *  cover size / weight / colour / alignment. Opacity is animated when
- *  a transition is declared on `opacity` or `value`. */
-export function Text({ resolved, transitionFor }: PrimitiveProps) {
-  const value = resolved.value === undefined ? "" : String(resolved.value);
-  const size = (resolved.size as string | number | undefined) ?? "1rem";
-  const weight = (resolved.weight as number | undefined) ?? 400;
-  const colour = (resolved.colour as string | undefined) ?? "currentColor";
-  const align = (resolved.align as string | undefined) ?? "start";
-  const opacity = numberOr(resolved.opacity, 1);
-
-  const tx = transitionFor("opacity") ?? transitionFor("value");
-
-  return (
-    <motion.span
-      style={{
-        display: "inline-block",
-        fontSize: size,
-        fontWeight: weight,
-        color: colour,
-        textAlign: align as React.CSSProperties["textAlign"],
-        willChange: "opacity",
-      }}
-      animate={{ opacity }}
-      transition={toFramer(tx)}
-    >
-      {value}
-    </motion.span>
-  );
-}
-
-function numberOr(v: unknown, fallback: number): number {
-  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
-}
diff --git a/src/render/scope.tsx b/src/render/scope.tsx
deleted file mode 100644
index 3b737f8..0000000
--- a/src/render/scope.tsx
+++ /dev/null
@@ -1,37 +0,0 @@
-import { createContext, useContext, type ReactNode } from "react";
-
-/** Path-scope context. Children inside a `repeat` get a `prefix` that
- *  is prepended to their declared bindings, so a single template can
- *  bind to per-item paths like `items.{i}.score`. */
-const PathScopeContext = createContext<string>("");
-
-export function PathScopeProvider({
-  prefix,
-  children,
-}: {
-  prefix: string;
-  children: ReactNode;
-}) {
-  const parent = useContext(PathScopeContext);
-  const next = parent ? `${parent}.${prefix}` : prefix;
-  return (
-    <PathScopeContext.Provider value={next}>
-      {children}
-    </PathScopeContext.Provider>
-  );
-}
-
-/** Returns the current path prefix, or "" if there is no scope. */
-export function usePathScope(): string {
-  return useContext(PathScopeContext);
-}
-
-/** Resolve a binding path under the current scope. */
-export function scopedPath(prefix: string, path: string): string {
-  if (!prefix) return path;
-  // Path may itself start with a literal prefix (e.g. `__system.*`),
-  // which should NOT be scoped — only paths that are clearly relative
-  // get prefixed.
-  if (path.startsWith("__")) return path;
-  return `${prefix}.${path}`;
-}
diff --git a/src/render/tree.tsx b/src/render/tree.tsx
deleted file mode 100644
index 47178ac..0000000
--- a/src/render/tree.tsx
+++ /dev/null
@@ -1,132 +0,0 @@
-// Recursive tree renderer — resolves bindings, dispatches to
-// primitives, handles `repeat` specially.
-
-import { useSignals } from "@preact/signals-react/runtime";
-import { useMemo, type ReactNode } from "react";
-import type { Store } from "../state/store";
-import type { Transition } from "../transport/protocol";
-import { PRIMITIVES } from "./primitives";
-import {
-  PathScopeProvider,
-  scopedPath,
-  usePathScope,
-} from "./scope";
-import type { RenderNode } from "./bundle";
-
-export interface TreeProps {
-  node: RenderNode;
-  store: Store;
-}
-
-export function Tree({ node, store }: TreeProps): ReactNode {
-  if (node.kind === "repeat") {
-    return <Repeat node={node} store={store} />;
-  }
-  return <Node node={node} store={store} />;
-}
-
-function Node({ node, store }: TreeProps): ReactNode {
-  // useSignals() lets the surrounding component subscribe to any
-  // signal read during render. Each leaf path has its own signal so
-  // re-renders only fire on touched paths.
-  useSignals();
-  const scope = usePathScope();
-
-  // Hooks must run unconditionally — the early-return for unknown
-  // kinds happens *after* every hook has fired.
-  const resolved = useMemo(
-    () => resolveProps(node, store, scope),
-    // We re-build per render — signals re-render cheaply, and the
-    // resolution itself is O(bindings) which is small. The memo is a
-    // micro-optimisation to keep object identity stable across renders
-    // when the inputs haven't changed.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [node, store, scope, ...readBindingValues(node, store, scope)],
-  );
-
-  const Primitive = PRIMITIVES[node.kind as keyof typeof PRIMITIVES];
-  if (!Primitive) {
-    if (import.meta.env.DEV) {
-      console.warn(`[solar] unknown render kind : ${node.kind}`);
-    }
-    return null;
-  }
-
-  const transitionFor = (key: string): Transition | undefined => {
-    // Per-binding default from the bundle, overridden by the latest
-    // delta-side transition recorded in the store.
-    const declaredPath = node.bindings?.[key];
-    const default_ = node.transitions?.[key] ?? undefined;
-    if (!declaredPath) return default_;
-    const fullPath = scopedPath(scope, declaredPath);
-    return store.transitionFor(fullPath) ?? default_;
-  };
-
-  const children = node.children?.map((child, idx) => (
-    <Tree key={child.id ?? idx} node={child} store={store} />
-  ));
-
-  return (
-    <Primitive resolved={resolved} transitionFor={transitionFor}>
-      {children}
-    </Primitive>
-  );
-}
-
-function Repeat({ node, store }: TreeProps): ReactNode {
-  useSignals();
-  const scope = usePathScope();
-
-  const itemsBinding = node.bindings?.items;
-  const items =
-    itemsBinding === undefined
-      ? []
-      : (store.signal(scopedPath(scope, itemsBinding)).value as unknown[] | undefined) ?? [];
-  if (!Array.isArray(items)) return null;
-
-  const template = node.children?.[0];
-  if (!template) return null;
-
-  return (
-    <>
-      {items.map((_item, idx) => (
-        <PathScopeProvider
-          key={idx}
-          prefix={`${itemsBinding ?? ""}.${idx}`}
-        >
-          <Tree node={template} store={store} />
-        </PathScopeProvider>
-      ))}
-    </>
-  );
-}
-
-function resolveProps(
-  node: RenderNode,
-  store: Store,
-  scope: string,
-): Record<string, unknown> {
-  const out: Record<string, unknown> = { ...(node.props ?? {}) };
-  if (node.bindings) {
-    for (const [propKey, path] of Object.entries(node.bindings)) {
-      const fullPath = scopedPath(scope, path);
-      out[propKey] = store.signal(fullPath).value;
-    }
-  }
-  return out;
-}
-
-/** Helper for the useMemo deps array — read each bound signal so the
- *  memo invalidates when any binding moves. */
-function readBindingValues(
-  node: RenderNode,
-  store: Store,
-  scope: string,
-): unknown[] {
-  if (!node.bindings) return [];
-  const values: unknown[] = [];
-  for (const path of Object.values(node.bindings)) {
-    values.push(store.signal(scopedPath(scope, path)).value);
-  }
-  return values;
-}
diff --git a/src/scene/binder.ts b/src/scene/binder.ts
deleted file mode 100644
index 86df30b..0000000
--- a/src/scene/binder.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-// Scene binder — wire the host's static HTML to the store.
-//
-// Any element marked with `data-anim-path="<path>"` has its textContent
-// updated whenever the matching signal changes. Elements with
-// `data-anim-attr="<attr>"` receive an attribute update instead.
-//
-// This is intentionally a thin one-way binding ; the host owns the
-// DOM structure, Solar owns the values. Two-way input binding is out
-// of scope for the public embed API in v1.
-
-import { effect } from "@preact/signals-react";
-import type { Store } from "../state/store";
-
-export interface SceneBinder {
-  dispose(): void;
-}
-
-const PATH_ATTR = "data-anim-path";
-
-export function bindScene(root: HTMLElement, store: Store): SceneBinder {
-  const disposers: Array<() => void> = [];
-  const nodes = root.querySelectorAll<HTMLElement>(`[${PATH_ATTR}]`);
-  nodes.forEach((el) => {
-    const path = el.getAttribute(PATH_ATTR);
-    if (!path) return;
-    const targetAttr = el.getAttribute("data-anim-attr");
-    const sig = store.signal(path);
-    const dispose = effect(() => {
-      const value = sig.value;
-      if (targetAttr) {
-        if (value === null || value === undefined) {
-          el.removeAttribute(targetAttr);
-        } else {
-          el.setAttribute(targetAttr, String(value));
-        }
-      } else {
-        el.textContent = value === undefined || value === null ? "" : String(value);
-      }
-    });
-    disposers.push(dispose);
-  });
-
-  return {
-    dispose() {
-      for (const d of disposers) {
-        try {
-          d();
-        } catch {
-          /* noop */
-        }
-      }
-    },
-  };
-}
diff --git a/src/scene/mount.tsx b/src/scene/mount.tsx
deleted file mode 100644
index be208d4..0000000
--- a/src/scene/mount.tsx
+++ /dev/null
@@ -1,41 +0,0 @@
-// Minimal React mount for PrismScene. The "render tree" here is
-// intentionally just an invisible probe : PrismScene v1 binds against
-// host-authored DOM via data attributes (see ./binder.ts) rather than
-// owning the layout tree. The React root exists so future versions
-// can swap in the full Solar primitives renderer without a public-
-// API break.
-
-import { createRoot, type Root } from "react-dom/client";
-import { createElement, type ReactElement } from "react";
-import type { Store } from "../state/store";
-
-export interface SceneRoot {
-  dispose(): void;
-}
-
-function ProbeMarker(): ReactElement {
-  return createElement("template", {
-    "data-solar-scene": "1",
-    "aria-hidden": "true",
-  });
-}
-
-export function renderScene(target: HTMLElement, _store: Store): SceneRoot {
-  // Attach a tiny React island so consumers can confirm the bundle is
-  // active without touching their own DOM. The probe is a <template>
-  // so it doesn't render visually.
-  const host = target.ownerDocument.createElement("div");
-  host.setAttribute("data-solar-root", "1");
-  host.style.cssText = "display:contents";
-  target.appendChild(host);
-
-  const root: Root = createRoot(host);
-  root.render(createElement(ProbeMarker));
-
-  return {
-    dispose() {
-      root.unmount();
-      if (host.parentNode) host.parentNode.removeChild(host);
-    },
-  };
-}
diff --git a/src/scene/prism-scene.ts b/src/scene/prism-scene.ts
deleted file mode 100644
index 922a917..0000000
--- a/src/scene/prism-scene.ts
+++ /dev/null
@@ -1,362 +0,0 @@
-// PrismScene — public JS class that lets any web host embed a Solar
-// scene without going through React, Pulsar, or Electron. Three
-// consumers share this surface :
-//
-//   1. Prism preview (webview)
-//   2. Pulsar CEF broadcast (browser source)
-//   3. Arbitrary site embed (the host page imports `@zablab/solar`
-//      and calls `new PrismScene(...)`)
-//
-// The class owns three things and only three :
-//
-//   - A `Store` (one signal per leaf path) — the same store the live
-//     `mount()` API uses.
-//   - A React render tree mounted into the host's `target` element,
-//     plus a data-binder for hosts that author static HTML and bind
-//     via `data-anim-path` markers.
-//   - An optional Orion WS connection for live triggers, attached on
-//     `connectToOrion()` and torn down on `disconnectFromOrion()`.
-//
-// Animation playback dispatches each patch through the action-runner
-// when `patch.action` is present, otherwise straight to the store.
-// Concurrent plays of the same `assetId` are forbidden — the second
-// call rejects with an "already-playing" error. Stopping aborts the
-// in-flight run and resolves it without firing `animation:completed`.
-
-import type { Patch } from "../transport/protocol";
-import { createStore, type Store } from "../state/store";
-import { runAction, UnknownActionKindError } from "../animate/action-runner";
-import { bindScene, type SceneBinder } from "./binder";
-import { renderScene, type SceneRoot } from "./mount";
-
-export type PrismSceneEvent =
-  | "animation:start"
-  | "animation:completed"
-  | "animation:error";
-
-export interface AnimationDef {
-  /** Patches replayed in order. Each one is dispatched through the
-   *  action-runner when it carries an `action` descriptor, otherwise
-   *  written straight to the store. */
-  patches: Patch[];
-  duration_ms?: number;
-}
-
-export interface SceneJson {
-  scene_id?: string;
-  scene_version?: string;
-  /** Initial state for every leaf path the scene reads. */
-  state?: Record<string, unknown>;
-  /** Static HTML rendered into the mount target (optional). Hosts
-   *  that prefer to author their own DOM should leave this empty and
-   *  populate `target` themselves before calling `mount()`. */
-  html?: string;
-  /** Named animations playable via `playAnimation(id, …)`. */
-  animations?: Record<string, AnimationDef>;
-}
-
-export interface PrismSceneOptions {
-  sceneJson: SceneJson;
-  /** When true, no Orion WS connection is established even if
-   *  `connectToOrion()` is later called. Useful for offline previews
-   *  in CI. Default false. */
-  mockMode?: boolean;
-}
-
-export type AnimationHandler = (payload: AnimationEventPayload) => void;
-
-export interface AnimationEventPayload {
-  asset_id: string;
-  params?: Record<string, unknown>;
-  error?: unknown;
-}
-
-export interface OrionConnectOptions {
-  url: string;
-  token: string;
-}
-
-const ALREADY_PLAYING_CODE = "ALREADY_PLAYING";
-
-export class PrismScene {
-  private sceneJson: SceneJson;
-  private readonly mockMode: boolean;
-  private readonly store: Store;
-  private root: SceneRoot | null = null;
-  private binder: SceneBinder | null = null;
-  private target: HTMLElement | null = null;
-  private orionSocket: WebSocket | null = null;
-  private readonly handlers = new Map<PrismSceneEvent, Set<AnimationHandler>>();
-  private readonly active = new Map<string, AbortController>();
-
-  constructor(opts: PrismSceneOptions) {
-    if (!opts || !opts.sceneJson) {
-      throw new TypeError("PrismScene: `sceneJson` is required");
-    }
-    this.sceneJson = opts.sceneJson;
-    this.mockMode = opts.mockMode ?? false;
-    this.store = createStore();
-    if (this.sceneJson.state) this.store.reset(this.sceneJson.state);
-  }
-
-  mount(target: HTMLElement): void {
-    if (!target || typeof target.appendChild !== "function") {
-      throw new TypeError("PrismScene.mount: `target` must be an HTMLElement");
-    }
-    if (this.root) {
-      throw new Error("PrismScene: already mounted; call unmount() first");
-    }
-    this.target = target;
-    if (typeof this.sceneJson.html === "string") {
-      target.innerHTML = this.sceneJson.html;
-    }
-    this.root = renderScene(target, this.store);
-    this.binder = bindScene(target, this.store);
-  }
-
-  unmount(): void {
-    for (const ctrl of this.active.values()) ctrl.abort();
-    this.active.clear();
-    this.binder?.dispose();
-    this.binder = null;
-    this.root?.dispose();
-    this.root = null;
-    this.target = null;
-    this.disconnectFromOrion();
-  }
-
-  async playAnimation(
-    assetId: string,
-    params?: Record<string, unknown>,
-  ): Promise<void> {
-    const anim = this.sceneJson.animations?.[assetId];
-    if (!anim) {
-      const error = new Error(
-        `PrismScene: animation '${assetId}' not found in sceneJson.animations`,
-      );
-      this.emit("animation:error", { asset_id: assetId, params, error });
-      throw error;
-    }
-    if (this.active.has(assetId)) {
-      const error = new Error(
-        `PrismScene: animation '${assetId}' is already playing`,
-      );
-      (error as { code?: string }).code = ALREADY_PLAYING_CODE;
-      this.emit("animation:error", { asset_id: assetId, params, error });
-      throw error;
-    }
-
-    const controller = new AbortController();
-    this.active.set(assetId, controller);
-    this.emit("animation:start", { asset_id: assetId, params });
-
-    try {
-      for (const rawPatch of anim.patches) {
-        if (controller.signal.aborted) break;
-        const patch = applyParams(rawPatch, params);
-        if (patch.action) {
-          await runAction({
-            store: this.store,
-            patch,
-            root: this.target,
-            signal: controller.signal,
-          });
-        } else {
-          this.store.set(patch.path, patch.value, patch.transition);
-        }
-      }
-      if (!controller.signal.aborted) {
-        this.emit("animation:completed", { asset_id: assetId, params });
-      }
-    } catch (error) {
-      this.emit("animation:error", { asset_id: assetId, params, error });
-      if (error instanceof UnknownActionKindError) throw error;
-      throw error;
-    } finally {
-      this.active.delete(assetId);
-    }
-  }
-
-  stopAnimation(assetId: string): void {
-    const ctrl = this.active.get(assetId);
-    if (!ctrl) return;
-    ctrl.abort();
-    this.active.delete(assetId);
-  }
-
-  on(event: PrismSceneEvent, handler: AnimationHandler): void {
-    if (!this.handlers.has(event)) this.handlers.set(event, new Set());
-    this.handlers.get(event)!.add(handler);
-  }
-
-  off(event: PrismSceneEvent, handler: AnimationHandler): void {
-    this.handlers.get(event)?.delete(handler);
-  }
-
-  connectToOrion(opts: OrionConnectOptions): void {
-    if (this.mockMode) return;
-    if (typeof WebSocket === "undefined") {
-      throw new Error(
-        "PrismScene.connectToOrion: WebSocket is not available in this runtime",
-      );
-    }
-    if (!opts?.url || !opts.token) {
-      throw new TypeError(
-        "PrismScene.connectToOrion: `url` and `token` are required",
-      );
-    }
-    this.disconnectFromOrion();
-    const ws = new WebSocket(opts.url);
-    this.orionSocket = ws;
-    ws.addEventListener("open", () => {
-      ws.send(
-        JSON.stringify({
-          type: "subscribe",
-          v: 1,
-          since_sequence: null,
-          token: opts.token,
-        }),
-      );
-    });
-    ws.addEventListener("message", (ev: MessageEvent) => {
-      this.onOrionMessage(ev.data);
-    });
-  }
-
-  disconnectFromOrion(): void {
-    if (!this.orionSocket) return;
-    try {
-      this.orionSocket.close();
-    } catch {
-      /* noop */
-    }
-    this.orionSocket = null;
-  }
-
-  setScene(sceneJson: SceneJson): void {
-    this.sceneJson = sceneJson;
-    if (sceneJson.state) this.store.reset(sceneJson.state);
-    if (this.target && typeof sceneJson.html === "string") {
-      this.target.innerHTML = sceneJson.html;
-      // Re-bind against the new DOM.
-      this.binder?.dispose();
-      this.binder = bindScene(this.target, this.store);
-    }
-  }
-
-  // --- introspection (test-only / debug) ----------------------------
-
-  /** @internal */
-  _getStoreSnapshot(): Record<string, unknown> {
-    return this.store.toRecord();
-  }
-
-  // --- private ------------------------------------------------------
-
-  private emit(event: PrismSceneEvent, payload: AnimationEventPayload): void {
-    const set = this.handlers.get(event);
-    if (!set) return;
-    for (const h of set) {
-      try {
-        h(payload);
-      } catch {
-        /* swallow handler errors — never break the playback loop */
-      }
-    }
-  }
-
-  private onOrionMessage(raw: unknown): void {
-    if (typeof raw !== "string") return;
-    let msg: unknown;
-    try {
-      msg = JSON.parse(raw);
-    } catch {
-      return;
-    }
-    if (!msg || typeof msg !== "object") return;
-    const m = msg as { type?: string; patches?: Patch[]; state?: Record<string, unknown> };
-    if (m.type === "snapshot" && m.state) {
-      this.store.reset(m.state);
-    } else if (m.type === "delta" && Array.isArray(m.patches)) {
-      for (const patch of m.patches) {
-        if (patch.action) {
-          void runAction({
-            store: this.store,
-            patch,
-            root: this.target,
-          });
-        } else {
-          this.store.set(patch.path, patch.value, patch.transition);
-        }
-      }
-    }
-  }
-}
-
-/** Interpolate `${param.foo}` placeholders inside the patch value/path
- *  with the supplied params, and merge a `${param.foo}` reference in
- *  `action.params` if present. Keeps the data-flow obvious without
- *  pulling a templating dependency. */
-function applyParams(
-  patch: Patch,
-  params: Record<string, unknown> | undefined,
-): Patch {
-  if (!params) return patch;
-  return {
-    ...patch,
-    path: substituteString(patch.path, params),
-    value: substituteValue(patch.value, params),
-    action: patch.action
-      ? {
-          ...patch.action,
-          params: substituteRecord(patch.action.params, params),
-        }
-      : undefined,
-  };
-}
-
-function substituteValue(
-  v: unknown,
-  params: Record<string, unknown>,
-): unknown {
-  if (typeof v === "string") return substituteString(v, params);
-  if (Array.isArray(v)) return v.map((x) => substituteValue(x, params));
-  if (v && typeof v === "object") {
-    return substituteRecord(v as Record<string, unknown>, params);
-  }
-  return v;
-}
-
-function substituteRecord(
-  rec: Record<string, unknown>,
-  params: Record<string, unknown>,
-): Record<string, unknown> {
-  const out: Record<string, unknown> = {};
-  for (const [k, v] of Object.entries(rec)) {
-    out[k] = substituteValue(v, params);
-  }
-  return out;
-}
-
-const PARAM_TOKEN = /\$\{param\.([a-zA-Z0-9_]+)\}/g;
-
-function substituteString(
-  s: string,
-  params: Record<string, unknown>,
-): string {
-  if (!s.includes("${param.")) return s;
-  // If the entire string is a single token, return the raw param so
-  // numbers and objects round-trip without being stringified.
-  const single = s.match(/^\$\{param\.([a-zA-Z0-9_]+)\}$/);
-  if (single) {
-    const key = single[1]!;
-    if (key in params) {
-      const v = params[key];
-      return v as unknown as string;
-    }
-    return s;
-  }
-  return s.replace(PARAM_TOKEN, (_m, key: string) => {
-    return key in params ? String(params[key]) : `\${param.${key}}`;
-  });
-}
diff --git a/src/state/apply-delta.ts b/src/state/apply-delta.ts
deleted file mode 100644
index 0d31ba4..0000000
--- a/src/state/apply-delta.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { batch } from "@preact/signals-react";
-import type { DeltaMsg } from "../transport/protocol";
-import type { Store } from "./store";
-
-/** Apply a delta. All patches in the delta land in a single
- *  signals batch — components reading multiple paths see them flip
- *  in one render pass. */
-export function applyDelta(store: Store, msg: DeltaMsg): void {
-  batch(() => {
-    for (const patch of msg.patches) {
-      store.set(patch.path, patch.value, patch.transition);
-    }
-  });
-}
diff --git a/src/state/apply-snapshot.ts b/src/state/apply-snapshot.ts
deleted file mode 100644
index 94df9ae..0000000
--- a/src/state/apply-snapshot.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import type { SnapshotMsg } from "../transport/protocol";
-import type { Store } from "./store";
-
-/** Apply a snapshot to the store. Replaces the entire state — paths
- *  not present in the snapshot are reset to `undefined`. */
-export function applySnapshot(store: Store, msg: SnapshotMsg): void {
-  store.reset(msg.state);
-}
diff --git a/src/state/store.ts b/src/state/store.ts
deleted file mode 100644
index 35d56cf..0000000
--- a/src/state/store.ts
+++ /dev/null
@@ -1,123 +0,0 @@
-// State store — one signal per leaf path.
-//
-// The store is the integration point between the WS layer (which
-// produces snapshots and deltas) and the render layer (which subscribes
-// signals to React components). Each leaf path Solar has ever seen has
-// a `Signal<unknown>` owned by the store ; readers subscribe via
-// @preact/signals-react `useSignals()` and re-render when the value
-// changes.
-//
-// Transitions ride alongside the value : every set carries an optional
-// transition that the render layer can read on the same tick. We
-// store the latest transition per path in a parallel map ; readers
-// consume it on signal change.
-
-import { signal, type Signal, batch } from "@preact/signals-react";
-import type { Transition } from "../transport/protocol";
-
-export interface Store {
-  /** Get-or-create the signal for a path. New paths start as
-   *  `undefined`. */
-  signal(path: string): Signal<unknown>;
-  /** Return the latest transition seen for this path, if any. */
-  transitionFor(path: string): Transition | undefined;
-  /** Apply a single leaf write. Optionally records the transition. */
-  set(path: string, value: unknown, transition?: Transition): void;
-  /** Replace the whole state — used by `apply-snapshot`. Existing
-   *  signals are reused so subscribers stay attached ; missing keys
-   *  reset to `undefined`. Transitions are cleared (a snapshot is the
-   *  baseline, no animation context). */
-  reset(state: Record<string, unknown>): void;
-  /** Snapshot of every known path → current value. For debug /
-   *  test-mode state inspector. */
-  toRecord(): Record<string, unknown>;
-}
-
-class StoreImpl implements Store {
-  private readonly signals = new Map<string, Signal<unknown>>();
-  private readonly transitions = new Map<string, Transition>();
-
-  signal(path: string): Signal<unknown> {
-    let s = this.signals.get(path);
-    if (!s) {
-      s = signal<unknown>(undefined);
-      this.signals.set(path, s);
-    }
-    return s;
-  }
-
-  transitionFor(path: string): Transition | undefined {
-    return this.transitions.get(path);
-  }
-
-  set(path: string, value: unknown, transition?: Transition): void {
-    if (transition) {
-      this.transitions.set(path, transition);
-    } else {
-      this.transitions.delete(path);
-    }
-    const s = this.signal(path);
-    if (!shallowEqual(s.peek(), value)) {
-      s.value = value;
-    }
-  }
-
-  reset(state: Record<string, unknown>): void {
-    batch(() => {
-      this.transitions.clear();
-      // Update existing signals first (so subscribers stay attached
-      // to the same signal instance), then prune ones the snapshot
-      // doesn't have.
-      const seen = new Set<string>();
-      for (const [path, value] of Object.entries(state)) {
-        seen.add(path);
-        const s = this.signal(path);
-        if (!shallowEqual(s.peek(), value)) {
-          s.value = value;
-        }
-      }
-      for (const path of this.signals.keys()) {
-        if (!seen.has(path)) {
-          const s = this.signals.get(path);
-          if (s && s.peek() !== undefined) s.value = undefined;
-        }
-      }
-    });
-  }
-
-  toRecord(): Record<string, unknown> {
-    const out: Record<string, unknown> = {};
-    for (const [path, s] of this.signals.entries()) {
-      out[path] = s.peek();
-    }
-    return out;
-  }
-}
-
-export function createStore(): Store {
-  return new StoreImpl();
-}
-
-function shallowEqual(a: unknown, b: unknown): boolean {
-  if (a === b) return true;
-  if (a === null || b === null) return false;
-  if (typeof a !== typeof b) return false;
-  if (typeof a !== "object") return false;
-  if (Array.isArray(a) !== Array.isArray(b)) return false;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) {
-      if (a[i] !== b[i]) return false;
-    }
-    return true;
-  }
-  const ao = a as Record<string, unknown>;
-  const bo = b as Record<string, unknown>;
-  const ak = Object.keys(ao);
-  const bk = Object.keys(bo);
-  if (ak.length !== bk.length) return false;
-  for (const k of ak) {
-    if (ao[k] !== bo[k]) return false;
-  }
-  return true;
-}
diff --git a/src/transport/codec.ts b/src/transport/codec.ts
deleted file mode 100644
index bfa5ce1..0000000
--- a/src/transport/codec.ts
+++ /dev/null
@@ -1,277 +0,0 @@
-// Encode / decode + validation of the WS envelope (ADR 002).
-//
-// Validation is fail-loud : a malformed message becomes a `CodecError`
-// and the WS layer turns it into a `SolarError` with code "INTERNAL".
-// The runtime never tries to coerce a bad payload — silent recovery is
-// how scene state diverges between Orion and Solar.
-
-import type {
-  ClientMessage,
-  ServerMessage,
-  ServerErrorCode,
-  Patch,
-  Transition,
-} from "./protocol";
-import { PROTOCOL_VERSION } from "./protocol";
-
-const SERVER_TYPES = [
-  "snapshot",
-  "delta",
-  "scene_changed",
-  "error",
-  "pong",
-] as const;
-type ServerType = (typeof SERVER_TYPES)[number];
-
-export class CodecError extends Error {
-  constructor(
-    public readonly reason: string,
-    public readonly raw?: unknown,
-  ) {
-    super(`Solar codec : ${reason}`);
-    this.name = "CodecError";
-  }
-}
-
-// --- encode ---------------------------------------------------------
-
-export function encode(message: ClientMessage): string {
-  return JSON.stringify(message);
-}
-
-// --- decode + validate ---------------------------------------------
-
-export function decode(raw: string): ServerMessage {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err) {
-    throw new CodecError(`invalid JSON : ${(err as Error).message}`, raw);
-  }
-  return validateServerMessage(parsed);
-}
-
-function validateServerMessage(value: unknown): ServerMessage {
-  if (!isObject(value)) {
-    throw new CodecError("server message must be an object", value);
-  }
-  const type = value.type;
-  if (typeof type !== "string" || !SERVER_TYPES.includes(type as ServerType)) {
-    throw new CodecError(`unknown server message type : ${String(type)}`, value);
-  }
-  if (value.v !== PROTOCOL_VERSION) {
-    throw new CodecError(
-      `protocol version mismatch : expected ${PROTOCOL_VERSION}, got ${String(value.v)}`,
-      value,
-    );
-  }
-
-  switch (type as ServerType) {
-    case "snapshot":
-      return validateSnapshot(value);
-    case "delta":
-      return validateDelta(value);
-    case "scene_changed":
-      return validateSceneChanged(value);
-    case "error":
-      return validateError(value);
-    case "pong":
-      return validatePong(value);
-  }
-}
-
-function validateSnapshot(v: Record<string, unknown>): ServerMessage {
-  const sceneId = expectString(v, "scene_id");
-  const sceneVersion = expectString(v, "scene_version");
-  const sequence = expectNumber(v, "sequence");
-  const state = v.state;
-  if (!isObject(state)) {
-    throw new CodecError("snapshot.state must be an object", v);
-  }
-  return {
-    type: "snapshot",
-    v: PROTOCOL_VERSION,
-    scene_id: sceneId,
-    scene_version: sceneVersion,
-    sequence,
-    state: state as Record<string, unknown>,
-  };
-}
-
-function validateDelta(v: Record<string, unknown>): ServerMessage {
-  const sceneId = expectString(v, "scene_id");
-  const sequence = expectNumber(v, "sequence");
-  const patches = v.patches;
-  if (!Array.isArray(patches)) {
-    throw new CodecError("delta.patches must be an array", v);
-  }
-  const validatedPatches: Patch[] = patches.map((p, idx) =>
-    validatePatch(p, idx),
-  );
-  const cause = v.cause;
-  let validatedCause: { source: string; input_id?: string } | undefined;
-  if (cause !== undefined) {
-    if (!isObject(cause)) {
-      throw new CodecError("delta.cause must be an object", v);
-    }
-    const source = expectString(cause, "source");
-    const inputId = cause.input_id;
-    if (inputId !== undefined && typeof inputId !== "string") {
-      throw new CodecError("delta.cause.input_id must be a string", v);
-    }
-    validatedCause = inputId !== undefined ? { source, input_id: inputId } : { source };
-  }
-  return {
-    type: "delta",
-    v: PROTOCOL_VERSION,
-    scene_id: sceneId,
-    sequence,
-    patches: validatedPatches,
-    ...(validatedCause ? { cause: validatedCause } : {}),
-  };
-}
-
-function validatePatch(value: unknown, idx: number): Patch {
-  if (!isObject(value)) {
-    throw new CodecError(`delta.patches[${idx}] must be an object`, value);
-  }
-  if (typeof value.path !== "string") {
-    throw new CodecError(`delta.patches[${idx}].path must be a string`, value);
-  }
-  if (!("value" in value)) {
-    throw new CodecError(`delta.patches[${idx}].value missing`, value);
-  }
-  const patch: Patch = { path: value.path, value: value.value };
-  if (value.transition !== undefined) {
-    patch.transition = validateTransition(value.transition);
-  }
-  return patch;
-}
-
-function validateTransition(value: unknown): Transition {
-  if (!isObject(value)) {
-    throw new CodecError("transition must be an object", value);
-  }
-  switch (value.kind) {
-    case "none":
-      return { kind: "none" };
-    case "tween": {
-      const duration_ms = expectNumber(value, "duration_ms");
-      const ease = value.ease;
-      if (
-        ease !== undefined &&
-        ease !== "linear" &&
-        ease !== "cubic-in" &&
-        ease !== "cubic-out" &&
-        ease !== "cubic-in-out"
-      ) {
-        throw new CodecError(`unsupported tween ease : ${String(ease)}`, value);
-      }
-      return { kind: "tween", duration_ms, ...(ease ? { ease } : {}) };
-    }
-    case "spring": {
-      const stiffness =
-        value.stiffness === undefined ? undefined : expectNumber(value, "stiffness");
-      const damping =
-        value.damping === undefined ? undefined : expectNumber(value, "damping");
-      return {
-        kind: "spring",
-        ...(stiffness !== undefined ? { stiffness } : {}),
-        ...(damping !== undefined ? { damping } : {}),
-      };
-    }
-    case "crossfade": {
-      const duration_ms =
-        value.duration_ms === undefined
-          ? undefined
-          : expectNumber(value, "duration_ms");
-      return {
-        kind: "crossfade",
-        ...(duration_ms !== undefined ? { duration_ms } : {}),
-      };
-    }
-    default:
-      throw new CodecError(`unknown transition kind : ${String(value.kind)}`, value);
-  }
-}
-
-function validateSceneChanged(v: Record<string, unknown>): ServerMessage {
-  const fromSceneId = expectString(v, "from_scene_id");
-  const toSceneId = expectString(v, "to_scene_id");
-  let transition: Transition | undefined;
-  if (v.transition !== undefined) {
-    const t = validateTransition(v.transition);
-    if (t.kind !== "crossfade" && t.kind !== "tween") {
-      throw new CodecError(
-        `scene_changed.transition must be crossfade or tween, got ${t.kind}`,
-        v,
-      );
-    }
-    transition = t;
-  }
-  return {
-    type: "scene_changed",
-    v: PROTOCOL_VERSION,
-    from_scene_id: fromSceneId,
-    to_scene_id: toSceneId,
-    ...(transition ? { transition: transition as never } : {}),
-  };
-}
-
-function validateError(v: Record<string, unknown>): ServerMessage {
-  const code = v.code;
-  const VALID_CODES: ReadonlyArray<ServerErrorCode> = [
-    "AUTH_DENIED",
-    "SCENE_NOT_FOUND",
-    "VERSION_MISMATCH",
-    "VERSION_GAP",
-    "RATE_LIMIT",
-    "WRITE_FORBIDDEN",
-    "UNKNOWN_PATH",
-    "INVALID_VALUE",
-    "TEST_SESSION_EXPIRED",
-    "INTERNAL",
-  ];
-  if (typeof code !== "string" || !VALID_CODES.includes(code as ServerErrorCode)) {
-    throw new CodecError(`unknown error code : ${String(code)}`, v);
-  }
-  const message = expectString(v, "message");
-  const recoverable = v.recoverable;
-  if (typeof recoverable !== "boolean") {
-    throw new CodecError("error.recoverable must be a boolean", v);
-  }
-  return {
-    type: "error",
-    v: PROTOCOL_VERSION,
-    code: code as ServerErrorCode,
-    message,
-    recoverable,
-  };
-}
-
-function validatePong(v: Record<string, unknown>): ServerMessage {
-  const nonce = expectString(v, "nonce");
-  return { type: "pong", v: PROTOCOL_VERSION, nonce };
-}
-
-// --- helpers --------------------------------------------------------
-
-function isObject(v: unknown): v is Record<string, unknown> {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-
-function expectString(v: Record<string, unknown>, key: string): string {
-  const got = v[key];
-  if (typeof got !== "string") {
-    throw new CodecError(`${key} must be a string`, v);
-  }
-  return got;
-}
-
-function expectNumber(v: Record<string, unknown>, key: string): number {
-  const got = v[key];
-  if (typeof got !== "number" || !Number.isFinite(got)) {
-    throw new CodecError(`${key} must be a finite number`, v);
-  }
-  return got;
-}
diff --git a/src/transport/protocol.ts b/src/transport/protocol.ts
deleted file mode 100644
index 41f2649..0000000
--- a/src/transport/protocol.ts
+++ /dev/null
@@ -1,191 +0,0 @@
-// Wire protocol types — ADR 002. Internal to Solar.
-//
-// These mirror the JSON shapes Orion writes / reads on the WS.
-// We hand-roll validation rather than pull in zod/io-ts ; the surface
-// is small enough that a few type guards stay easier to audit than a
-// schema library and keep the bundle weight off the broadcast hot path.
-
-export const PROTOCOL_VERSION = 1;
-
-// --- shared atoms -----------------------------------------------------
-
-/** Recognised transition kinds. `none` means instantaneous (no
- *  animation). Solar's animate/ layer maps these to Framer Motion. */
-export type TransitionKind = "none" | "tween" | "spring" | "crossfade";
-
-export interface TweenTransition {
-  kind: "tween";
-  duration_ms: number;
-  ease?: "linear" | "cubic-in" | "cubic-out" | "cubic-in-out";
-}
-
-export interface SpringTransition {
-  kind: "spring";
-  stiffness?: number;
-  damping?: number;
-}
-
-export interface CrossfadeTransition {
-  kind: "crossfade";
-  duration_ms?: number;
-}
-
-export interface NoTransition {
-  kind: "none";
-}
-
-export type Transition =
-  | NoTransition
-  | TweenTransition
-  | SpringTransition
-  | CrossfadeTransition;
-
-/** A patch always targets a single leaf path. Replacement semantics —
- *  no nested operators (ADR 002 § 5 delta). */
-export interface Patch {
-  path: string;
-  value: unknown;
-  transition?: Transition;
-  /** Optional Action descriptor (chantier Solar action runner).
-   *  When present, Solar's action-runner reconstructs dense patches
-   *  locally rather than receiving them frame-by-frame. Patches
-   *  without `action` follow the existing transitions.ts pipeline
-   *  untouched — fully backward compatible. */
-  action?: ActionDescriptor;
-}
-
-// --- action descriptors (chantier Solar action runner) ---------------
-
-export type ActionKind =
-  | "count-up"
-  | "curve-path"
-  | "text-reveal"
-  | "stagger-group"
-  | "reorder"
-  | "mask-reveal";
-
-/** Easing reference resolved by `animate/easing-resolver.ts` — either
- *  a string id (`"ease-out"`, `"cubic-in-out"`, …) or an inline spring
- *  configuration. */
-export type EasingRef =
-  | string
-  | { stiffness: number; damping: number };
-
-/** A descriptor authored by Prism's Action compiler and consumed by
- *  Solar's action-runner. Inputs are intentionally permissive
- *  (`Record<string, unknown>`) — each runner validates its own params. */
-export interface ActionDescriptor {
-  kind: ActionKind;
-  params: Record<string, unknown>;
-  easing?: EasingRef;
-  duration_ms?: number;
-  stops?: Array<{ at_pct: number; value: unknown; easing?: string }>;
-  curve?: {
-    anchors: Array<{
-      t_pct: number;
-      value: number;
-      in_tangent?: { dt: number; dv: number };
-      out_tangent?: { dt: number; dv: number };
-    }>;
-    sample_hz: 30 | 60;
-  };
-  child_selector?: {
-    kind: "index" | "all" | "css-selector";
-    value: number | string;
-  };
-}
-
-// --- server → client messages -----------------------------------------
-
-export interface SnapshotMsg {
-  type: "snapshot";
-  v: number;
-  scene_id: string;
-  scene_version: string;
-  sequence: number;
-  state: Record<string, unknown>;
-}
-
-export interface DeltaMsg {
-  type: "delta";
-  v: number;
-  scene_id: string;
-  sequence: number;
-  patches: Patch[];
-  cause?: { source: string; input_id?: string };
-}
-
-export interface SceneChangedMsg {
-  type: "scene_changed";
-  v: number;
-  from_scene_id: string;
-  to_scene_id: string;
-  transition?: CrossfadeTransition | TweenTransition;
-}
-
-export interface ErrorMsg {
-  type: "error";
-  v: number;
-  code: ServerErrorCode;
-  message: string;
-  recoverable: boolean;
-}
-
-export interface PongMsg {
-  type: "pong";
-  v: number;
-  nonce: string;
-}
-
-export type ServerMessage =
-  | SnapshotMsg
-  | DeltaMsg
-  | SceneChangedMsg
-  | ErrorMsg
-  | PongMsg;
-
-export type ServerErrorCode =
-  | "AUTH_DENIED"
-  | "SCENE_NOT_FOUND"
-  | "VERSION_MISMATCH"
-  | "VERSION_GAP"
-  | "RATE_LIMIT"
-  | "WRITE_FORBIDDEN"
-  | "UNKNOWN_PATH"
-  | "INVALID_VALUE"
-  | "TEST_SESSION_EXPIRED"
-  | "INTERNAL";
-
-// --- client → server messages -----------------------------------------
-
-export interface SubscribeMsg {
-  type: "subscribe";
-  v: number;
-  since_sequence: number | null;
-}
-
-export interface InputMsg {
-  type: "input";
-  v: number;
-  path: string;
-  value: unknown;
-  source?: string;
-  client_msg_id?: string;
-}
-
-export interface UnsubscribeMsg {
-  type: "unsubscribe";
-  v: number;
-}
-
-export interface PingMsg {
-  type: "ping";
-  v: number;
-  nonce: string;
-}
-
-export type ClientMessage =
-  | SubscribeMsg
-  | InputMsg
-  | UnsubscribeMsg
-  | PingMsg;
diff --git a/src/transport/reconnect.ts b/src/transport/reconnect.ts
deleted file mode 100644
index c5e50b7..0000000
--- a/src/transport/reconnect.ts
+++ /dev/null
@@ -1,92 +0,0 @@
-// Exponential backoff schedule for the WS reconnect loop.
-//
-// Solar is a viewer / control surface — losing the connection during a
-// live show is visible to the operator. We retry aggressively at first
-// (200ms, 400ms, 800ms…) then cap at 5s so a sustained outage doesn't
-// hammer the gateway. The schedule is jittered to avoid thundering
-// herds when several Solar instances reconnect together (e.g. a Pulsar
-// CEF + a Prism webview waking from suspend at the same time).
-
-export interface ReconnectScheduleOptions {
-  /** First delay in milliseconds. */
-  initial?: number;
-  /** Maximum delay in milliseconds. */
-  max?: number;
-  /** Multiplicative factor between attempts (>= 1). */
-  factor?: number;
-  /** Jitter as a fraction of the delay (0 disables, 0.2 = ±20 %). */
-  jitter?: number;
-  /** Random source — only injected for tests. */
-  random?: () => number;
-}
-
-const DEFAULTS: Required<Omit<ReconnectScheduleOptions, "random">> = {
-  initial: 200,
-  max: 5_000,
-  factor: 2,
-  jitter: 0.2,
-};
-
-export interface ReconnectSchedule {
-  /** Returns the delay to wait before the n-th attempt (1-indexed). */
-  delayFor(attempt: number): number;
-  /** Reset to attempt 1 (called on a successful connection). */
-  reset(): void;
-  /** Current attempt counter. */
-  readonly attempt: number;
-}
-
-class ScheduleImpl implements ReconnectSchedule {
-  private _attempt = 0;
-  constructor(
-    private readonly opts: Required<Omit<ReconnectScheduleOptions, "random">>,
-    private readonly random: () => number,
-  ) {}
-
-  get attempt(): number {
-    return this._attempt;
-  }
-
-  delayFor(attempt: number): number {
-    if (!Number.isInteger(attempt) || attempt < 1) {
-      throw new RangeError(`attempt must be a positive integer, got ${attempt}`);
-    }
-    this._attempt = attempt;
-    const base = Math.min(
-      this.opts.initial * Math.pow(this.opts.factor, attempt - 1),
-      this.opts.max,
-    );
-    if (this.opts.jitter <= 0) return base;
-    // ±jitter fraction of the base, uniformly distributed.
-    const offset = (this.random() * 2 - 1) * this.opts.jitter * base;
-    return Math.max(0, base + offset);
-  }
-
-  reset(): void {
-    this._attempt = 0;
-  }
-}
-
-export function createReconnectSchedule(
-  opts: ReconnectScheduleOptions = {},
-): ReconnectSchedule {
-  const merged = {
-    initial: opts.initial ?? DEFAULTS.initial,
-    max: opts.max ?? DEFAULTS.max,
-    factor: opts.factor ?? DEFAULTS.factor,
-    jitter: opts.jitter ?? DEFAULTS.jitter,
-  };
-  if (merged.initial <= 0) {
-    throw new RangeError("initial must be > 0");
-  }
-  if (merged.max < merged.initial) {
-    throw new RangeError("max must be >= initial");
-  }
-  if (merged.factor < 1) {
-    throw new RangeError("factor must be >= 1");
-  }
-  if (merged.jitter < 0 || merged.jitter > 1) {
-    throw new RangeError("jitter must be within [0, 1]");
-  }
-  return new ScheduleImpl(merged, opts.random ?? Math.random);
-}
diff --git a/src/transport/sequence.ts b/src/transport/sequence.ts
deleted file mode 100644
index e002d5e..0000000
--- a/src/transport/sequence.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-// Sequence tracker — ADR 002 § 7.
-//
-// Each subscription sees a monotonic 64-bit sequence in the snapshot
-// and every subsequent delta. A gap means we missed a message and
-// must request a resync (the WS layer reconnects with `since_sequence`
-// or accepts a fresh snapshot).
-//
-// JS doesn't have native 64-bit ints — `number` is safe up to 2^53,
-// which is plenty for any realistic show duration (a 1 kHz delta rate
-// for 285 000 years before overflow). We treat sequence as `number`
-// and bail early if it ever exceeds Number.MAX_SAFE_INTEGER.
-
-export interface SequenceTracker {
-  /** Current expected next sequence (last seen + 1). 0 means no
-   *  baseline established yet. */
-  readonly expected: number;
-  /** Reset to a known baseline (called on snapshot or scene_changed). */
-  reset(seq: number): void;
-  /** Validate an incoming delta sequence. Returns "ok" if it matches,
-   *  "gap" if a resync is needed. */
-  observe(seq: number): SequenceObservation;
-  /** Last seen sequence (for `since_sequence` on reconnect). */
-  readonly last: number;
-}
-
-export type SequenceObservation =
-  | { kind: "ok" }
-  | { kind: "gap"; expected: number; got: number };
-
-class TrackerImpl implements SequenceTracker {
-  private _last = -1;
-
-  get expected(): number {
-    return this._last < 0 ? 0 : this._last + 1;
-  }
-
-  get last(): number {
-    return this._last;
-  }
-
-  reset(seq: number): void {
-    if (!Number.isFinite(seq) || seq < 0) {
-      throw new RangeError(`sequence must be a non-negative finite number, got ${seq}`);
-    }
-    if (seq > Number.MAX_SAFE_INTEGER) {
-      throw new RangeError(`sequence overflow : ${seq}`);
-    }
-    this._last = seq;
-  }
-
-  observe(seq: number): SequenceObservation {
-    if (!Number.isFinite(seq) || seq < 0) {
-      return { kind: "gap", expected: this.expected, got: seq };
-    }
-    const expected = this.expected;
-    if (seq === expected) {
-      this._last = seq;
-      return { kind: "ok" };
-    }
-    return { kind: "gap", expected, got: seq };
-  }
-}
-
-export function createSequenceTracker(): SequenceTracker {
-  return new TrackerImpl();
-}
diff --git a/src/transport/ws.ts b/src/transport/ws.ts
deleted file mode 100644
index ede4c86..0000000
--- a/src/transport/ws.ts
+++ /dev/null
@@ -1,358 +0,0 @@
-// WS client wiring transport pieces together.
-//
-// Lifecycle :
-//   1. open() — opens the WS using the supplied URL + token
-//   2. server replies handshake-style ; we send `subscribe`
-//   3. server replies `snapshot` → we emit `onSnapshot`
-//   4. subsequent `delta` / `scene_changed` / `error` / `pong`
-//      messages are emitted to the host
-//   5. on close (clean or not) we reschedule via the backoff
-//   6. setToken() closes + reopens with the new token
-//   7. close() shuts down for good ; no further reconnect
-
-import type { SolarToken } from "../types";
-import {
-  CodecError,
-  decode,
-  encode,
-} from "./codec";
-import {
-  type ClientMessage,
-  type DeltaMsg,
-  type ErrorMsg,
-  type ServerMessage,
-  type SnapshotMsg,
-  type SceneChangedMsg,
-  PROTOCOL_VERSION,
-} from "./protocol";
-import {
-  createReconnectSchedule,
-  type ReconnectSchedule,
-  type ReconnectScheduleOptions,
-} from "./reconnect";
-import {
-  createSequenceTracker,
-  type SequenceTracker,
-} from "./sequence";
-
-export type ConnectionStatus = "disconnected" | "connecting" | "live";
-
-export interface WsClientOptions {
-  url: string;
-  token: SolarToken;
-  /** Override WebSocket constructor (for tests / non-browser hosts). */
-  webSocketImpl?: typeof WebSocket;
-  /** Reconnect tuning (defaults in reconnect.ts). */
-  reconnect?: ReconnectScheduleOptions;
-  /** Replaces the global setTimeout / clearTimeout for tests. */
-  scheduler?: {
-    setTimeout: typeof globalThis.setTimeout;
-    clearTimeout: typeof globalThis.clearTimeout;
-  };
-
-  onStatus?: (status: ConnectionStatus) => void;
-  onSnapshot?: (msg: SnapshotMsg) => void;
-  onDelta?: (msg: DeltaMsg) => void;
-  onSceneChanged?: (msg: SceneChangedMsg) => void;
-  onServerError?: (msg: ErrorMsg) => void;
-  /** Wire-level / codec / unrecoverable errors. */
-  onTransportError?: (err: TransportError) => void;
-}
-
-export class TransportError extends Error {
-  public readonly recoverable: boolean;
-  public override readonly cause?: unknown;
-  constructor(message: string, recoverable: boolean, cause?: unknown) {
-    super(message);
-    this.name = "TransportError";
-    this.recoverable = recoverable;
-    this.cause = cause;
-  }
-}
-
-type Timer = ReturnType<typeof setTimeout>;
-
-interface InternalScheduler {
-  setTimeout: typeof globalThis.setTimeout;
-  clearTimeout: typeof globalThis.clearTimeout;
-}
-
-export class WsClient {
-  private status: ConnectionStatus = "disconnected";
-  private socket: WebSocket | null = null;
-  private token: SolarToken;
-  private readonly url: string;
-  private readonly WebSocketCtor: typeof WebSocket;
-  private readonly schedule: ReconnectSchedule;
-  private readonly seq: SequenceTracker = createSequenceTracker();
-  private readonly opts: WsClientOptions;
-  private readonly scheduler: InternalScheduler;
-
-  private reconnectTimer: Timer | null = null;
-  private active = true;
-  private currentSceneId: string | null = null;
-
-  constructor(opts: WsClientOptions) {
-    this.opts = opts;
-    this.url = opts.url;
-    this.token = opts.token;
-    const ctor = opts.webSocketImpl ?? globalThis.WebSocket;
-    if (!ctor) {
-      throw new TypeError(
-        "Solar WsClient : no WebSocket implementation found in this environment",
-      );
-    }
-    this.WebSocketCtor = ctor;
-    this.schedule = createReconnectSchedule(opts.reconnect);
-    this.scheduler = opts.scheduler ?? {
-      setTimeout: globalThis.setTimeout.bind(globalThis),
-      clearTimeout: globalThis.clearTimeout.bind(globalThis),
-    };
-  }
-
-  /** Open and start the connection lifecycle. Idempotent. */
-  start(): void {
-    if (!this.active) return;
-    if (this.socket || this.status === "connecting") return;
-    void this.openSocket();
-  }
-
-  /** Send an input message to the server. No-op if not connected ;
-   *  the caller is expected to re-send on reconnect if it matters. */
-  sendInput(path: string, value: unknown, clientMsgId?: string): void {
-    if (!this.socket || this.socket.readyState !== this.WebSocketCtor.OPEN) {
-      return;
-    }
-    const msg: ClientMessage = {
-      type: "input",
-      v: PROTOCOL_VERSION,
-      path,
-      value,
-      ...(clientMsgId ? { client_msg_id: clientMsgId } : {}),
-    };
-    this.socket.send(encode(msg));
-  }
-
-  /** Replace the auth token. Closes and reopens so the new token is
-   *  carried on the next handshake. */
-  setToken(token: SolarToken): void {
-    this.token = token;
-    if (!this.active) return;
-    if (this.socket) {
-      this.closeSocket();
-      this.scheduleReconnect(/* immediate */ true);
-    }
-  }
-
-  /** Tear down for good. No more reconnect attempts. */
-  close(): void {
-    if (!this.active) return;
-    this.active = false;
-    this.cancelReconnect();
-    this.closeSocket();
-    this.setStatus("disconnected");
-  }
-
-  /** Last known sequence — used for resume on reconnect. */
-  get lastSequence(): number {
-    return this.seq.last;
-  }
-
-  /** Current scene id from the most recent snapshot, if any. */
-  get sceneId(): string | null {
-    return this.currentSceneId;
-  }
-
-  // --- internals --------------------------------------------------
-
-  private async openSocket(): Promise<void> {
-    if (!this.active) return;
-    this.setStatus("connecting");
-
-    let resolvedToken: string;
-    try {
-      resolvedToken = await resolveToken(this.token);
-    } catch (err) {
-      this.opts.onTransportError?.(
-        new TransportError(
-          `failed to resolve token : ${(err as Error).message}`,
-          true,
-          err,
-        ),
-      );
-      this.scheduleReconnect();
-      return;
-    }
-    if (!this.active) return;
-
-    const url = appendTokenIfNeeded(this.url, resolvedToken);
-    let socket: WebSocket;
-    try {
-      socket = new this.WebSocketCtor(url);
-    } catch (err) {
-      this.opts.onTransportError?.(
-        new TransportError(
-          `failed to open WebSocket : ${(err as Error).message}`,
-          true,
-          err,
-        ),
-      );
-      this.scheduleReconnect();
-      return;
-    }
-
-    this.socket = socket;
-    socket.onopen = () => this.handleOpen();
-    socket.onmessage = (event) => this.handleMessage(event);
-    socket.onerror = (event) => this.handleError(event);
-    socket.onclose = (event) => this.handleClose(event);
-  }
-
-  private handleOpen(): void {
-    if (!this.socket) return;
-    const since =
-      this.seq.last >= 0 ? this.seq.last : null;
-    const subscribe: ClientMessage = {
-      type: "subscribe",
-      v: PROTOCOL_VERSION,
-      since_sequence: since,
-    };
-    this.socket.send(encode(subscribe));
-  }
-
-  private handleMessage(event: MessageEvent): void {
-    const data = typeof event.data === "string" ? event.data : "";
-    if (!data) return;
-    let msg: ServerMessage;
-    try {
-      msg = decode(data);
-    } catch (err) {
-      const detail =
-        err instanceof CodecError ? err.message : (err as Error).message;
-      this.opts.onTransportError?.(
-        new TransportError(`codec : ${detail}`, true, err),
-      );
-      this.closeSocket();
-      this.scheduleReconnect();
-      return;
-    }
-
-    switch (msg.type) {
-      case "snapshot":
-        this.seq.reset(msg.sequence);
-        this.currentSceneId = msg.scene_id;
-        this.schedule.reset();
-        this.setStatus("live");
-        this.opts.onSnapshot?.(msg);
-        return;
-      case "delta": {
-        const observation = this.seq.observe(msg.sequence);
-        if (observation.kind === "gap") {
-          this.opts.onTransportError?.(
-            new TransportError(
-              `sequence gap : expected ${observation.expected}, got ${observation.got}`,
-              true,
-            ),
-          );
-          this.closeSocket();
-          this.scheduleReconnect();
-          return;
-        }
-        this.opts.onDelta?.(msg);
-        return;
-      }
-      case "scene_changed":
-        // The next snapshot reseeds the sequence — we do not advance
-        // the tracker here.
-        this.opts.onSceneChanged?.(msg);
-        return;
-      case "error":
-        this.opts.onServerError?.(msg);
-        if (!msg.recoverable) {
-          this.close();
-        }
-        return;
-      case "pong":
-        // ignored by Solar — we don't currently send pings
-        return;
-    }
-  }
-
-  private handleError(_event: Event): void {
-    // The browser does not give us a real reason on `error` — `close`
-    // will follow with a code we surface to the host.
-  }
-
-  private handleClose(event: CloseEvent): void {
-    this.socket = null;
-    if (!this.active) {
-      this.setStatus("disconnected");
-      return;
-    }
-    if (event.code === 4401 || event.code === 4403) {
-      // Auth-related close codes : not recoverable without operator
-      // intervention.
-      this.opts.onTransportError?.(
-        new TransportError(`server closed : ${event.code} ${event.reason}`, false),
-      );
-      this.close();
-      return;
-    }
-    this.scheduleReconnect();
-  }
-
-  private scheduleReconnect(immediate = false): void {
-    if (!this.active) return;
-    this.cancelReconnect();
-    const attempt = (this.schedule.attempt || 0) + 1;
-    const delay = immediate ? 0 : this.schedule.delayFor(attempt);
-    this.setStatus("disconnected");
-    this.reconnectTimer = this.scheduler.setTimeout(() => {
-      this.reconnectTimer = null;
-      void this.openSocket();
-    }, delay);
-  }
-
-  private cancelReconnect(): void {
-    if (this.reconnectTimer) {
-      this.scheduler.clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-  }
-
-  private closeSocket(): void {
-    if (this.socket) {
-      try {
-        this.socket.close(1000, "client closing");
-      } catch {
-        // ignore
-      }
-      this.socket = null;
-    }
-  }
-
-  private setStatus(next: ConnectionStatus): void {
-    if (this.status === next) return;
-    this.status = next;
-    this.opts.onStatus?.(next);
-  }
-}
-
-async function resolveToken(token: SolarToken): Promise<string> {
-  if (typeof token === "string") return token;
-  return await token.fetch();
-}
-
-function appendTokenIfNeeded(url: string, token: string): string {
-  // Pulsar CEF browser sources cannot set Authorization headers ;
-  // ZabGate accepts `?token=` on /orion/api/v1/show/stream only.
-  // For the operator (Prism) flow, the JWT travels via headers — but
-  // browser WebSocket APIs don't let userland set an Authorization
-  // header either, so the show-token-in-URL form is also how Prism
-  // hands its operator token over. ZabGate is responsible for
-  // rejecting non-viewer tokens via query string outside the
-  // show-stream endpoint.
-  if (!token) return url;
-  const sep = url.includes("?") ? "&" : "?";
-  return `${url}${sep}token=${encodeURIComponent(token)}`;
-}
diff --git a/src/types/index.ts b/src/types/index.ts
index 56e0722..2947a6c 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -1,6 +1,15 @@
 // Public types exported from @zablab/solar.
+//
 // Stable surface — changes here are breaking changes for Prism, Pulsar
 // CEF wrappers, and any future host. Match ADR 003 § 2.
+//
+// Since ADR 007 (Lumencast convergence), Solar is a thin adapter over
+// `@lumencast/runtime` : the rendering, transport (LSDP/1.1) and state
+// layers are the runtime's, not Solar's. These types are the Zab-facing
+// projection of the runtime's public contract — kept byte-stable so the
+// three hosts (Pulsar CEF / Prism webview / editor preview) need no
+// change. The field name `orionUrl` is preserved (vs the runtime's
+// `serverUrl`) because hosts pass it ; `mount()` maps it across.
 
 export type SolarMode = "broadcast" | "control" | "test";
 
@@ -18,8 +27,10 @@ export interface SolarError {
   recoverable: boolean;
 }
 
-// Subset of ADR 002 § 5 error codes that surface up to the host plus
-// Solar-internal failure modes (bundle fetch, schema mismatch).
+// The LSDP/1.1 closed error taxonomy (LSDP-1.md §3.4) plus the two
+// bundle-fetch / capability codes the runtime raises. This is byte-equal
+// to `@lumencast/protocol`'s `ErrorCode` union — the adapter forwards a
+// `LumencastError` straight through with no lossy mapping.
 export type SolarErrorCode =
   | "AUTH_DENIED"
   | "SCENE_NOT_FOUND"
@@ -36,13 +47,16 @@ export type SolarErrorCode =
 
 export interface MountOptions {
   target: HTMLElement;
-  /** wss://<gate>/orion/api/v1/show/stream (live) or
-   *  wss://<gate>/orion/api/v1/scenes/{id}/test (test). */
+  /** WebSocket URL of the LSDP/1.1 server. In the Zab platform this is
+   *  Orion (`wss://<gate>/orion/api/v1/show/stream` for live, or
+   *  `.../scenes/{id}/test` for test mode) once Orion converges to a
+   *  Lumencast server (ADR 007 sub-chantier C). Maps to the runtime's
+   *  `serverUrl`. */
   orionUrl: string;
   token: SolarToken;
   mode: SolarMode;
   /** Required when mode === "test" — the test session UUID handed back by
-   *  Orion's `POST /show/test-sessions`. Ignored otherwise. */
+   *  the server's test-session endpoint. Ignored otherwise. */
   testSession?: string;
   /** Required when mode === "test" — the scene id that the test session
    *  cloned. Ignored otherwise. */
diff --git a/tests/e2e/global-setup.ts b/tests/e2e/global-setup.ts
deleted file mode 100644
index c4c290c..0000000
--- a/tests/e2e/global-setup.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-// Boots mock-orion on a fixed port for the e2e suite. Tests reach it
-// via process.env.SOLAR_E2E_ORION_WS / _HTTP.
-
-import { startMockOrion, type MockOrion } from "../mock-orion/server";
-import {
-  ACCEPTANCE_BUNDLE,
-  ACCEPTANCE_INITIAL_STATE,
-  ACCEPTANCE_SCENE_ID,
-} from "../fixtures/scenes";
-
-declare global {
-  // Stashed on globalThis so global-teardown can close the server.
-  var __solarE2EMockOrion: MockOrion | undefined;
-}
-
-const MOCK_PORT = Number(process.env.SOLAR_E2E_MOCK_PORT ?? 51320);
-
-async function globalSetup(): Promise<void> {
-  const mock = await startMockOrion({
-    port: MOCK_PORT,
-    initialSceneId: ACCEPTANCE_SCENE_ID,
-    initialBundle: ACCEPTANCE_BUNDLE,
-    initialState: ACCEPTANCE_INITIAL_STATE,
-  });
-  globalThis.__solarE2EMockOrion = mock;
-  process.env.SOLAR_E2E_ORION_WS = mock.url;
-  process.env.SOLAR_E2E_ORION_HTTP = mock.httpUrl;
-  console.log(
-    `[solar-e2e] mock-orion : WS=${mock.url} HTTP=${mock.httpUrl}`,
-  );
-}
-
-export default globalSetup;
diff --git a/tests/e2e/global-teardown.ts b/tests/e2e/global-teardown.ts
deleted file mode 100644
index ddadabe..0000000
--- a/tests/e2e/global-teardown.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-async function globalTeardown(): Promise<void> {
-  const mock = globalThis.__solarE2EMockOrion;
-  if (mock) {
-    await mock.close();
-    globalThis.__solarE2EMockOrion = undefined;
-  }
-}
-
-export default globalTeardown;
diff --git a/tests/e2e/render.spec.ts b/tests/e2e/render.spec.ts
deleted file mode 100644
index f03ca00..0000000
--- a/tests/e2e/render.spec.ts
+++ /dev/null
@@ -1,253 +0,0 @@
-// Resolution criteria 2-7 from chantier-solar.md, run against the
-// real Solar bundle in a real Chromium, driven by the mock-orion
-// fixture set up in global-setup.
-
-import { test, expect, type Page } from "@playwright/test";
-import {
-  ALT_BUNDLE,
-  ALT_INITIAL_STATE,
-  ALT_SCENE_ID,
-} from "../fixtures/scenes";
-
-const ORION_WS = process.env.SOLAR_E2E_ORION_WS!;
-const ORION_HTTP = process.env.SOLAR_E2E_ORION_HTTP!;
-
-async function pushDelta(
-  patches: Array<{ path: string; value: unknown; transition?: object }>,
-): Promise<void> {
-  const res = await fetch(`${ORION_HTTP}/__mock/delta`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ patches }),
-  });
-  if (!res.ok) {
-    throw new Error(`mock-orion delta push failed : ${res.status}`);
-  }
-}
-
-async function resetMock(): Promise<void> {
-  const res = await fetch(`${ORION_HTTP}/__mock/reset`, { method: "POST" });
-  if (!res.ok) {
-    throw new Error(`mock-orion reset failed : ${res.status}`);
-  }
-}
-
-async function switchScene(args: {
-  sceneId: string;
-  bundle: unknown;
-  state: Record<string, unknown>;
-  transition?: { kind: "crossfade"; duration_ms?: number };
-}): Promise<void> {
-  const res = await fetch(`${ORION_HTTP}/__mock/scene-changed`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify(args),
-  });
-  if (!res.ok) {
-    throw new Error(`mock-orion scene-changed failed : ${res.status}`);
-  }
-}
-
-function buildOrionUrl(
-  mode: "broadcast" | "control" | "test",
-  extra: { scene?: string; session?: string },
-): string {
-  if (mode !== "test") return ORION_WS;
-  const sceneId = extra.scene ?? "acceptance-scene";
-  const session = extra.session ?? "e2e-session";
-  // Real Orion exposes test sessions under
-  // /orion/api/v1/scenes/{id}/test?session={uuid}. Mock-orion accepts
-  // it under the same shape.
-  const u = new URL(ORION_WS);
-  u.pathname = `/orion/api/v1/scenes/${encodeURIComponent(sceneId)}/test`;
-  u.searchParams.set("session", session);
-  return u.toString();
-}
-
-async function open(
-  page: Page,
-  mode: "broadcast" | "control" | "test" = "control",
-  extra: { scene?: string; session?: string } = {},
-): Promise<void> {
-  const orionUrl = buildOrionUrl(mode, extra);
-  const params = new URLSearchParams({
-    orion: orionUrl,
-    mode,
-    token: "e2e-token",
-    ...(extra.scene ? { scene: extra.scene } : {}),
-    ...(extra.session ? { session: extra.session } : {}),
-  });
-  await page.goto(`/?${params.toString()}`);
-  // Wait for the rendered tree's first text leaf to mount — proves
-  // mount() → snapshot → bundle fetch → render completed. We scope
-  // the locator to the scene root so the test-mode state inspector
-  // (which echoes paths + values, including the scene title) doesn't
-  // collide with the actual rendered title in strict-mode locators.
-  await page
-    .getByTestId("solar-scene-root")
-    .getByText("Acceptance scene", { exact: true })
-    .first()
-    .waitFor({ state: "visible" });
-}
-
-test.beforeEach(async () => {
-  await resetMock();
-});
-
-test.describe("Solar e2e — render + transport + overlay", () => {
-  test("criterion 2 : delta updates DOM within ≤ 50ms", async ({ page }) => {
-    await open(page, "broadcast");
-    // Establish the baseline value, then time the round-trip from
-    // delta push to DOM update.
-    await expect(page.getByText("14")).toBeVisible();
-
-    const newValue = 17 + Math.floor(Math.random() * 100);
-    const start = Date.now();
-    await pushDelta([{ path: "score.team_a", value: newValue }]);
-    await expect(page.getByText(String(newValue))).toBeVisible();
-    const elapsed = Date.now() - start;
-    // The wire round-trip + Solar reconciliation should land well
-    // under 50ms on a dev machine. Playwright's auto-wait adds slack
-    // (its polling interval is ~100ms), so we allow 250ms in CI.
-    expect(elapsed).toBeLessThanOrEqual(250);
-  });
-
-  test("criterion 5 : control overlay renders fields panel", async ({
-    page,
-  }) => {
-    await open(page, "control");
-    const panel = page.getByTestId("solar-control-panel");
-    await expect(panel).toBeVisible();
-    await expect(panel.getByText("Scene title")).toBeVisible();
-    await expect(panel.getByText("Team A score")).toBeVisible();
-  });
-
-  test("criterion 5 (bis) : editing a field commits an input", async ({
-    page,
-  }) => {
-    await open(page, "control");
-    const panel = page.getByTestId("solar-control-panel");
-    const titleInput = panel.locator("input[type='text']").first();
-    await titleInput.fill("From operator");
-    // Operator writes flow back over WS — mock-orion mirrors them
-    // into its state but doesn't push a delta back unless we do so
-    // explicitly. So we push the same value via the mock to verify
-    // the round-trip is wired (a real Orion would echo via a delta).
-    await pushDelta([{ path: "scene.title", value: "From operator" }]);
-    await expect(page.getByText("From operator")).toBeVisible();
-  });
-
-  test("criterion 6 : test mode panel + adapter mocker mounts", async ({
-    page,
-  }) => {
-    await open(page, "test", { session: "e2e-session", scene: "acceptance-scene" });
-    await expect(page.getByTestId("solar-test-panel")).toBeVisible();
-    await expect(page.getByTestId("solar-control-panel")).toBeVisible();
-    // The acceptance scene declares one external adapter
-    // ("ranking-poll") — verify it shows up in the mocker.
-    await expect(
-      page.getByTestId("solar-test-panel").getByText("ZabRanking — current match"),
-    ).toBeVisible();
-  });
-
-  test("criterion 5 (bundle separation) : broadcast mode hides overlays", async ({
-    page,
-  }) => {
-    await open(page, "broadcast");
-    // The status pill, control panel, test panel must all be absent.
-    await expect(page.getByTestId("solar-status-pill")).toHaveCount(0);
-    await expect(page.getByTestId("solar-control-panel")).toHaveCount(0);
-    await expect(page.getByTestId("solar-test-panel")).toHaveCount(0);
-  });
-
-  test("criterion 3 : tween animation does not fire any Layout event", async ({
-    page,
-    context,
-  }) => {
-    // The acceptance scene declares
-    //   score-box.frame.opacity → score.visible_opacity
-    // with a default tween transition (200ms, cubic-out) — see
-    // tests/fixtures/scenes.ts. We change the opacity, then read
-    // Chrome's LayoutCount before / after the animation window.
-    // Frame primitive is built on framer-motion `motion.div` driving
-    // `transform` + `opacity` only ; no width/height/top/left
-    // touched by the binding. The metric should not increment over
-    // the animation interval.
-
-    await open(page, "broadcast");
-
-    const cdp = await context.newCDPSession(page);
-    await cdp.send("Performance.enable");
-
-    // Settle the initial render before sampling — the first paint
-    // necessarily lays out, we only care about layouts caused by
-    // the animated transition.
-    await page.waitForTimeout(150);
-    const before = (await cdp.send("Performance.getMetrics")) as {
-      metrics: Array<{ name: string; value: number }>;
-    };
-    const layoutBefore =
-      before.metrics.find((m) => m.name === "LayoutCount")?.value ?? 0;
-
-    // Trigger the tween. The bundle's declared default transition
-    // applies — Solar reads it via transitionFor("opacity").
-    await pushDelta([{ path: "score.visible_opacity", value: 0.3 }]);
-    // Wait past the animation window (default 200ms + slack).
-    await page.waitForTimeout(450);
-
-    const after = (await cdp.send("Performance.getMetrics")) as {
-      metrics: Array<{ name: string; value: number }>;
-    };
-    const layoutAfter =
-      after.metrics.find((m) => m.name === "LayoutCount")?.value ?? 0;
-
-    // The tween should not force a single layout. We allow a tiny
-    // slack (≤ 1) for incidental work outside Solar's animated
-    // surface (e.g. the browser's idle housekeeping) — the
-    // assertion still catches a per-frame layout regression cleanly.
-    const delta = layoutAfter - layoutBefore;
-    expect(delta).toBeLessThanOrEqual(1);
-  });
-
-  test("criterion 4 : scene_changed crossfade keeps both trees mounted during the transition", async ({
-    page,
-  }) => {
-    await open(page, "broadcast");
-    const sceneRoot = page.getByTestId("solar-scene-root");
-
-    // Initial : exactly one motion.div root inside the scene root.
-    // (AnimatePresence renders no DOM of its own ; each scene tree
-    // is wrapped in a single motion.div whose key is
-    // `${sceneId}::${sceneVersion}`.)
-    const directDivs = sceneRoot.locator(":scope > div");
-    await expect(directDivs).toHaveCount(1);
-
-    // Trigger a scene_changed with a 600ms crossfade.
-    await switchScene({
-      sceneId: ALT_SCENE_ID,
-      bundle: ALT_BUNDLE,
-      state: ALT_INITIAL_STATE,
-      transition: { kind: "crossfade", duration_ms: 600 },
-    });
-
-    // During the transition window AnimatePresence (mode="sync")
-    // keeps the exiting motion.div mounted alongside the entering
-    // one. We probe with a tight poll ; auto-wait would settle on
-    // the post-transition state and miss the overlap.
-    await expect
-      .poll(
-        async () => directDivs.count(),
-        { timeout: 700, intervals: [10, 25, 50, 100] },
-      )
-      .toBe(2);
-
-    // After the transition completes the exiting tree is pruned by
-    // AnimatePresence, leaving exactly one motion.div again. The
-    // remaining tree carries the alt scene's text ("Alt scene
-    // running") — proves the new bundle is what's now rendered.
-    await expect(directDivs).toHaveCount(1, { timeout: 1500 });
-    await expect(
-      sceneRoot.getByText("Alt scene running", { exact: true }),
-    ).toBeVisible();
-  });
-});
diff --git a/tests/fixtures/scenes.ts b/tests/fixtures/scenes.ts
deleted file mode 100644
index 5133016..0000000
--- a/tests/fixtures/scenes.ts
+++ /dev/null
@@ -1,171 +0,0 @@
-// Acceptance and adversarial scene fixtures used by both unit tests
-// and the mock-orion server. They live in tests/ rather than src/
-// because they aren't shipped — the bundle for a real scene comes
-// from Orion's compiler at push time.
-
-import type { RenderBundle } from "../../src/render/bundle";
-
-export const ACCEPTANCE_SCENE_ID = "acceptance-scene";
-export const ACCEPTANCE_SCENE_VERSION = "sha256:acceptance-v1";
-
-export const ACCEPTANCE_BUNDLE: RenderBundle = {
-  scene_version: ACCEPTANCE_SCENE_VERSION,
-  root: {
-    kind: "stack",
-    props: { direction: "vertical", gap: 12 },
-    children: [
-      {
-        kind: "text",
-        id: "title",
-        props: { size: 32, weight: 700, colour: "#f9fafb" },
-        bindings: { value: "scene.title" },
-      },
-      {
-        kind: "frame",
-        id: "score-box",
-        props: { width: 240, height: 64 },
-        bindings: { opacity: "score.visible_opacity" },
-        transitions: {
-          opacity: { kind: "tween", duration_ms: 200, ease: "cubic-out" },
-        },
-        children: [
-          {
-            kind: "text",
-            id: "score-team-a",
-            props: { size: 48, weight: 800, colour: "#22c55e" },
-            bindings: { value: "score.team_a" },
-            transitions: {
-              value: { kind: "tween", duration_ms: 200 },
-            },
-          },
-        ],
-      },
-      {
-        kind: "repeat",
-        id: "roster-list",
-        bindings: { items: "roster" },
-        children: [
-          {
-            kind: "stack",
-            props: { direction: "horizontal", gap: 8 },
-            children: [
-              {
-                kind: "text",
-                bindings: { value: "name" },
-                props: { weight: 600 },
-              },
-              {
-                kind: "text",
-                bindings: { value: "score" },
-              },
-            ],
-          },
-        ],
-      },
-    ],
-  },
-  operator_inputs: [
-    {
-      path: "scene.title",
-      label: "Scene title",
-      type: "text",
-      max_length: 80,
-      group: "Scene",
-    },
-    {
-      path: "score.team_a",
-      label: "Team A score",
-      type: "number",
-      group: "Score",
-      min: 0,
-      max: 999,
-      step: 1,
-    },
-    {
-      path: "score.visible_opacity",
-      label: "Score box opacity",
-      type: "number",
-      min: 0,
-      max: 1,
-      step: 0.1,
-      group: "Score",
-    },
-  ],
-  external_adapters: [
-    {
-      key: "ranking-poll",
-      label: "ZabRanking — current match",
-      kind: "http-poll",
-      target_paths: ["score.team_a"],
-      frequency_hz: 5,
-    },
-  ],
-  assets: [],
-};
-
-export const ACCEPTANCE_INITIAL_STATE: Record<string, unknown> = {
-  "scene.title": "Acceptance scene",
-  "score.team_a": 14,
-  "score.visible_opacity": 1,
-  roster: [
-    { name: "Alice", score: 12 },
-    { name: "Bob", score: 9 },
-  ],
-};
-
-// --- adversarial scene : exercises the unhappy paths --------------
-
-export const ADVERSARIAL_SCENE_ID = "adversarial-scene";
-export const ADVERSARIAL_SCENE_VERSION = "sha256:adversarial-v1";
-
-export const ADVERSARIAL_BUNDLE: RenderBundle = {
-  scene_version: ADVERSARIAL_SCENE_VERSION,
-  root: {
-    kind: "stack",
-    children: [
-      // Unknown kind — Solar must skip it without crashing.
-      { kind: "totally-fake" as never, id: "unknown" },
-      // Empty bindings, all defaults.
-      { kind: "text", id: "empty-text" },
-      // Repeat with empty array.
-      {
-        kind: "repeat",
-        id: "empty-repeat",
-        bindings: { items: "no-such-array" },
-        children: [{ kind: "text" }],
-      },
-    ],
-  },
-  operator_inputs: [],
-  external_adapters: [],
-  assets: [],
-};
-
-export const ADVERSARIAL_INITIAL_STATE: Record<string, unknown> = {};
-
-// --- alt scene : used by the criterion-4 scene_changed e2e ----------
-
-export const ALT_SCENE_ID = "alt-scene";
-export const ALT_SCENE_VERSION = "sha256:alt-v1";
-
-export const ALT_BUNDLE: RenderBundle = {
-  scene_version: ALT_SCENE_VERSION,
-  root: {
-    kind: "stack",
-    children: [
-      {
-        kind: "text",
-        id: "alt-title",
-        props: { size: 32, weight: 700, colour: "#fbbf24" },
-        bindings: { value: "scene.title" },
-      },
-    ],
-  },
-  operator_inputs: [],
-  external_adapters: [],
-  assets: [],
-};
-
-export const ALT_INITIAL_STATE: Record<string, unknown> = {
-  "scene.title": "Alt scene running",
-};
diff --git a/tests/mock-orion/server.ts b/tests/mock-orion/server.ts
deleted file mode 100644
index 89878eb..0000000
--- a/tests/mock-orion/server.ts
+++ /dev/null
@@ -1,334 +0,0 @@
-// Mock Orion server for tests. Speaks ADR 002 over WS and serves
-// render bundles over HTTP. Designed to be embedded by Vitest tests
-// (programmatic start / stop) and by Playwright E2E (started in a
-// global setup hook).
-//
-// Behaviour parity with real Orion is intentional :
-//  - Same envelope (`type`, `v`, ...).
-//  - Same sequence semantics (snapshot reseeds, deltas increment).
-//  - Same scene_changed flow (scene_changed → fresh snapshot).
-//  - Same backpressure rule isn't simulated (mock is single-client).
-//
-// What it doesn't do : auth, real scene compilation, polling
-// adapters. Tests inject scenes as `RenderBundle` objects directly.
-
-import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
-import { WebSocketServer, type WebSocket } from "ws";
-import { PROTOCOL_VERSION } from "../../src/transport/protocol";
-import type { RenderBundle } from "../../src/render/bundle";
-import type { Patch, Transition } from "../../src/transport/protocol";
-
-export interface MockOrionConfig {
-  /** Listening port (0 = random). */
-  port?: number;
-  /** Initial scene id served when a client subscribes. */
-  initialSceneId: string;
-  /** Bundle for the initial scene. */
-  initialBundle: RenderBundle;
-  /** Initial state (paths → values). */
-  initialState: Record<string, unknown>;
-}
-
-export interface MockOrion {
-  readonly url: string;
-  readonly httpUrl: string;
-  /** Add (or replace) a bundle by scene_version — served via HTTP. */
-  registerBundle(bundle: RenderBundle): void;
-  /** Inject a delta to all subscribers of the active scene. */
-  pushDelta(patches: Patch[], opts?: { transition?: Transition }): void;
-  /** Switch the active scene. Emits scene_changed + snapshot. */
-  switchScene(args: {
-    sceneId: string;
-    bundle: RenderBundle;
-    state: Record<string, unknown>;
-    transition?: { kind: "crossfade"; duration_ms?: number };
-  }): void;
-  /** Close every connection and stop listening. */
-  close(): Promise<void>;
-}
-
-interface SubscriberState {
-  ws: WebSocket;
-  sceneId: string;
-  sequence: number;
-}
-
-export async function startMockOrion(
-  config: MockOrionConfig,
-): Promise<MockOrion> {
-  const initialSceneId = config.initialSceneId;
-  const initialBundle = config.initialBundle;
-  const initialState = config.initialState;
-  let activeSceneId = initialSceneId;
-  let activeBundle = initialBundle;
-  let activeState: Record<string, unknown> = { ...initialState };
-  const bundles = new Map<string, RenderBundle>();
-  bundles.set(initialBundle.scene_version, initialBundle);
-
-  const subscribers = new Set<SubscriberState>();
-
-  const httpServer: Server = createServer(
-    (req: IncomingMessage, res: ServerResponse) => {
-      // CORS — production Orion needs the same for Pulsar CEF and
-      // Prism webview cross-origin fetches.
-      res.setHeader("access-control-allow-origin", "*");
-      res.setHeader("access-control-allow-methods", "GET, OPTIONS");
-      res.setHeader("access-control-allow-headers", "*");
-      if (req.method === "OPTIONS") {
-        res.statusCode = 204;
-        res.end();
-        return;
-      }
-
-      const url = req.url ?? "/";
-      // GET /orion/api/v1/scenes/{id}/render-bundle?v={hash}
-      const match = url.match(
-        /^\/orion\/api\/v1\/scenes\/([^/?]+)\/render-bundle(?:\?v=([^&]+))?$/,
-      );
-      if (req.method === "GET" && match) {
-        const versionParam = match[2] ? decodeURIComponent(match[2]) : undefined;
-        const bundle = versionParam
-          ? bundles.get(versionParam)
-          : activeBundle;
-        if (!bundle) {
-          res.statusCode = 404;
-          res.end("bundle not found");
-          return;
-        }
-        res.statusCode = 200;
-        res.setHeader("content-type", "application/json");
-        res.setHeader("cache-control", "public, max-age=31536000, immutable");
-        res.end(JSON.stringify(bundle));
-        return;
-      }
-      // GET /orion/api/v1/health
-      if (req.method === "GET" && url === "/orion/api/v1/health") {
-        res.statusCode = 200;
-        res.setHeader("content-type", "application/json");
-        res.end(JSON.stringify({ status: "ok" }));
-        return;
-      }
-      // --- mock-only control plane (used by Playwright e2e) -------
-      if (req.method === "POST" && url === "/__mock/delta") {
-        readJson(req)
-          .then((body) => {
-            const patches = (body as { patches: Patch[] }).patches;
-            pushDelta(patches);
-            res.statusCode = 204;
-            res.end();
-          })
-          .catch((err) => {
-            res.statusCode = 400;
-            res.end(String(err));
-          });
-        return;
-      }
-      if (req.method === "POST" && url === "/__mock/scene-changed") {
-        readJson(req)
-          .then((body) => {
-            const args = body as {
-              sceneId: string;
-              bundle: RenderBundle;
-              state: Record<string, unknown>;
-              transition?: { kind: "crossfade"; duration_ms?: number };
-            };
-            switchScene(args);
-            res.statusCode = 204;
-            res.end();
-          })
-          .catch((err) => {
-            res.statusCode = 400;
-            res.end(String(err));
-          });
-        return;
-      }
-      if (req.method === "POST" && url === "/__mock/register-bundle") {
-        readJson(req)
-          .then((body) => {
-            registerBundle(body as RenderBundle);
-            res.statusCode = 204;
-            res.end();
-          })
-          .catch((err) => {
-            res.statusCode = 400;
-            res.end(String(err));
-          });
-        return;
-      }
-      if (req.method === "POST" && url === "/__mock/reset") {
-        // Reset to the initial scene + state. Used by Playwright
-        // beforeEach hooks so each test sees a clean slate.
-        activeSceneId = initialSceneId;
-        activeBundle = initialBundle;
-        activeState = { ...initialState };
-        res.statusCode = 204;
-        res.end();
-        return;
-      }
-      res.statusCode = 404;
-      res.end("not found");
-    },
-  );
-
-  await new Promise<void>((resolve) => {
-    httpServer.listen(config.port ?? 0, "127.0.0.1", () => resolve());
-  });
-  const address = httpServer.address();
-  if (!address || typeof address === "string") {
-    throw new Error("mock-orion : failed to bind HTTP server");
-  }
-  const port = address.port;
-
-  const wss = new WebSocketServer({ server: httpServer });
-
-  wss.on("connection", (socket, req) => {
-    const url = req.url ?? "";
-    // Real Orion has two WS endpoints (live and test). The mock
-    // accepts both — the test session URL even has a session= query
-    // param that we don't validate here.
-    const isLive = url.startsWith("/orion/api/v1/show/stream");
-    const isTest = url.startsWith("/orion/api/v1/scenes/");
-    if (!isLive && !isTest) {
-      socket.close(1008, "unknown ws path");
-      return;
-    }
-    const sub: SubscriberState = {
-      ws: socket,
-      sceneId: activeSceneId,
-      sequence: 0,
-    };
-    subscribers.add(sub);
-
-    socket.on("message", (data) => {
-      let parsed: unknown;
-      try {
-        parsed = JSON.parse(data.toString());
-      } catch {
-        return;
-      }
-      if (
-        typeof parsed !== "object" ||
-        parsed === null ||
-        (parsed as { type: unknown }).type !== "subscribe"
-      ) {
-        return;
-      }
-      const sequence = nextSequence();
-      sub.sequence = sequence;
-      sub.sceneId = activeSceneId;
-      sendJson(socket, {
-        type: "snapshot",
-        v: PROTOCOL_VERSION,
-        scene_id: activeSceneId,
-        scene_version: activeBundle.scene_version,
-        sequence,
-        state: activeState,
-      });
-    });
-
-    socket.on("close", () => {
-      subscribers.delete(sub);
-    });
-  });
-
-  let monotonic = 0;
-  function nextSequence(): number {
-    monotonic += 1;
-    return monotonic;
-  }
-
-  function registerBundle(bundle: RenderBundle): void {
-    bundles.set(bundle.scene_version, bundle);
-  }
-
-  function pushDelta(patches: Patch[]): void {
-    for (const sub of subscribers) {
-      if (sub.sceneId !== activeSceneId) continue;
-      const sequence = nextSequence();
-      sub.sequence = sequence;
-      sendJson(sub.ws, {
-        type: "delta",
-        v: PROTOCOL_VERSION,
-        scene_id: activeSceneId,
-        sequence,
-        patches,
-      });
-    }
-    // Mirror patches into our state mirror so the next snapshot is
-    // consistent — done once even with no subscribers, so a delta
-    // pushed before the first connect is reflected.
-    for (const p of patches) {
-      activeState[p.path] = p.value;
-    }
-  }
-
-  function switchScene(args: {
-    sceneId: string;
-    bundle: RenderBundle;
-    state: Record<string, unknown>;
-    transition?: { kind: "crossfade"; duration_ms?: number };
-  }): void {
-    activeSceneId = args.sceneId;
-    activeBundle = args.bundle;
-    activeState = { ...args.state };
-    bundles.set(args.bundle.scene_version, args.bundle);
-    for (const sub of subscribers) {
-      sendJson(sub.ws, {
-        type: "scene_changed",
-        v: PROTOCOL_VERSION,
-        from_scene_id: sub.sceneId,
-        to_scene_id: args.sceneId,
-        ...(args.transition ? { transition: args.transition } : {}),
-      });
-      const sequence = nextSequence();
-      sub.sequence = sequence;
-      sub.sceneId = args.sceneId;
-      sendJson(sub.ws, {
-        type: "snapshot",
-        v: PROTOCOL_VERSION,
-        scene_id: args.sceneId,
-        scene_version: args.bundle.scene_version,
-        sequence,
-        state: activeState,
-      });
-    }
-  }
-
-  async function close(): Promise<void> {
-    for (const sub of subscribers) {
-      try {
-        sub.ws.close(1000, "shutdown");
-      } catch {
-        // ignore
-      }
-    }
-    subscribers.clear();
-    await new Promise<void>((resolve) => wss.close(() => resolve()));
-    await new Promise<void>((resolve) => httpServer.close(() => resolve()));
-  }
-
-  const instance: MockOrion = {
-    url: `ws://127.0.0.1:${port}/orion/api/v1/show/stream`,
-    httpUrl: `http://127.0.0.1:${port}`,
-    registerBundle,
-    pushDelta,
-    switchScene,
-    close,
-  };
-  return instance;
-}
-
-function sendJson(ws: WebSocket, payload: unknown): void {
-  if (ws.readyState !== ws.OPEN) return;
-  ws.send(JSON.stringify(payload));
-}
-
-async function readJson(req: IncomingMessage): Promise<unknown> {
-  const chunks: Buffer[] = [];
-  for await (const chunk of req) {
-    chunks.push(chunk as Buffer);
-  }
-  const body = Buffer.concat(chunks).toString("utf8");
-  if (body.length === 0) return {};
-  return JSON.parse(body);
-}
diff --git a/tests/unit/action-runner.test.ts b/tests/unit/action-runner.test.ts
deleted file mode 100644
index 6893864..0000000
--- a/tests/unit/action-runner.test.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-// Dispatcher smoke — the action-runner routes on `kind` and throws
-// a typed error for unknown kinds. Per-runner behaviour lives in
-// dedicated suites (count-up, text-reveal, reorder-flip).
-
-import { describe, expect, it } from "vitest";
-
-import { createStore } from "../../src/state/store";
-import {
-  runAction,
-  hasAction,
-  registerActionRunner,
-  UnknownActionKindError,
-} from "../../src/animate/action-runner";
-import type { Patch } from "../../src/transport/protocol";
-
-describe("action-runner / dispatcher", () => {
-  it("hasAction returns true only when `action` is set", () => {
-    expect(hasAction({ path: "p", value: 1 })).toBe(false);
-    expect(
-      hasAction({
-        path: "p",
-        value: 1,
-        action: { kind: "count-up", params: {} },
-      }),
-    ).toBe(true);
-  });
-
-  it("throws UnknownActionKindError for an unregistered kind", async () => {
-    const store = createStore();
-    const patch = {
-      path: "p",
-      value: 1,
-      action: { kind: "does-not-exist" as never, params: {} },
-    } as Patch;
-    await expect(runAction({ store, patch })).rejects.toBeInstanceOf(
-      UnknownActionKindError,
-    );
-  });
-
-  it("allows custom runners to be registered", async () => {
-    const store = createStore();
-    let called = false;
-    registerActionRunner("custom-test", async () => {
-      called = true;
-    });
-    const patch = {
-      path: "p",
-      value: 1,
-      action: { kind: "custom-test" as never, params: {} },
-    } as Patch;
-    await runAction({ store, patch });
-    expect(called).toBe(true);
-  });
-
-  it("is a no-op when patch has no action", async () => {
-    const store = createStore();
-    await runAction({ store, patch: { path: "p", value: 5 } });
-    // store untouched — runAction with no action descriptor returns
-    // immediately. Setting the value is the caller's responsibility.
-    expect(store.toRecord()).toEqual({});
-  });
-});
diff --git a/tests/unit/codec.test.ts b/tests/unit/codec.test.ts
deleted file mode 100644
index 4a93eaa..0000000
--- a/tests/unit/codec.test.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { CodecError, decode, encode } from "../../src/transport/codec";
-import { PROTOCOL_VERSION } from "../../src/transport/protocol";
-
-describe("decode() — server messages", () => {
-  it("accepts a valid snapshot", () => {
-    const raw = JSON.stringify({
-      type: "snapshot",
-      v: PROTOCOL_VERSION,
-      scene_id: "scene-42",
-      scene_version: "sha256:abc",
-      sequence: 12345,
-      state: { "score.team_a": 14, "logo.visible": true },
-    });
-    const msg = decode(raw);
-    expect(msg).toMatchObject({
-      type: "snapshot",
-      scene_id: "scene-42",
-      sequence: 12345,
-    });
-  });
-
-  it("accepts a delta with a typed transition", () => {
-    const raw = JSON.stringify({
-      type: "delta",
-      v: PROTOCOL_VERSION,
-      scene_id: "scene-42",
-      sequence: 12346,
-      patches: [
-        {
-          path: "score.team_a",
-          value: 15,
-          transition: { kind: "tween", duration_ms: 200, ease: "cubic-out" },
-        },
-      ],
-    });
-    const msg = decode(raw);
-    if (msg.type !== "delta") throw new Error("expected delta");
-    expect(msg.patches).toHaveLength(1);
-    const patch = msg.patches[0]!;
-    expect(patch.path).toBe("score.team_a");
-    expect(patch.transition).toMatchObject({ kind: "tween", duration_ms: 200 });
-  });
-
-  it("accepts a scene_changed with crossfade", () => {
-    const raw = JSON.stringify({
-      type: "scene_changed",
-      v: PROTOCOL_VERSION,
-      from_scene_id: "a",
-      to_scene_id: "b",
-      transition: { kind: "crossfade", duration_ms: 600 },
-    });
-    const msg = decode(raw);
-    expect(msg.type).toBe("scene_changed");
-  });
-
-  it("accepts an error message", () => {
-    const raw = JSON.stringify({
-      type: "error",
-      v: PROTOCOL_VERSION,
-      code: "AUTH_DENIED",
-      message: "go away",
-      recoverable: false,
-    });
-    const msg = decode(raw);
-    if (msg.type !== "error") throw new Error("expected error");
-    expect(msg.code).toBe("AUTH_DENIED");
-    expect(msg.recoverable).toBe(false);
-  });
-
-  it("rejects malformed JSON", () => {
-    expect(() => decode("not json")).toThrow(CodecError);
-  });
-
-  it("rejects an unknown type", () => {
-    const raw = JSON.stringify({ type: "totally-fake", v: PROTOCOL_VERSION });
-    expect(() => decode(raw)).toThrow(/unknown server message type/);
-  });
-
-  it("rejects a version mismatch", () => {
-    const raw = JSON.stringify({
-      type: "pong",
-      v: 99,
-      nonce: "n",
-    });
-    expect(() => decode(raw)).toThrow(/protocol version mismatch/);
-  });
-
-  it("rejects a delta with a non-string path", () => {
-    const raw = JSON.stringify({
-      type: "delta",
-      v: PROTOCOL_VERSION,
-      scene_id: "s",
-      sequence: 1,
-      patches: [{ path: 42, value: 0 }],
-    });
-    expect(() => decode(raw)).toThrow(/path must be a string/);
-  });
-
-  it("rejects an unknown transition kind", () => {
-    const raw = JSON.stringify({
-      type: "delta",
-      v: PROTOCOL_VERSION,
-      scene_id: "s",
-      sequence: 1,
-      patches: [
-        {
-          path: "p",
-          value: 1,
-          transition: { kind: "warp" },
-        },
-      ],
-    });
-    expect(() => decode(raw)).toThrow(/unknown transition kind/);
-  });
-});
-
-describe("encode() — client messages", () => {
-  it("round-trips a subscribe", () => {
-    const out = encode({
-      type: "subscribe",
-      v: PROTOCOL_VERSION,
-      since_sequence: 1234,
-    });
-    expect(JSON.parse(out)).toEqual({
-      type: "subscribe",
-      v: PROTOCOL_VERSION,
-      since_sequence: 1234,
-    });
-  });
-
-  it("round-trips an input with client_msg_id", () => {
-    const out = encode({
-      type: "input",
-      v: PROTOCOL_VERSION,
-      path: "match.id",
-      value: "match-7",
-      client_msg_id: "uuid",
-    });
-    const parsed = JSON.parse(out);
-    expect(parsed.type).toBe("input");
-    expect(parsed.client_msg_id).toBe("uuid");
-  });
-});
diff --git a/tests/unit/integration.test.ts b/tests/unit/integration.test.ts
deleted file mode 100644
index 967cdfb..0000000
--- a/tests/unit/integration.test.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-// Integration test : transport + state, end-to-end against
-// the mock-orion server. Doesn't render React — that's e2e's job.
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import WS from "ws";
-import { WsClient } from "../../src/transport/ws";
-import { applySnapshot } from "../../src/state/apply-snapshot";
-import { applyDelta } from "../../src/state/apply-delta";
-import { createStore } from "../../src/state/store";
-import {
-  startMockOrion,
-  type MockOrion,
-} from "../mock-orion/server";
-import {
-  ACCEPTANCE_BUNDLE,
-  ACCEPTANCE_INITIAL_STATE,
-  ACCEPTANCE_SCENE_ID,
-  ACCEPTANCE_SCENE_VERSION,
-} from "../fixtures/scenes";
-
-const NodeWebSocket = WS as unknown as typeof WebSocket;
-
-let orion: MockOrion;
-
-beforeEach(async () => {
-  orion = await startMockOrion({
-    initialSceneId: ACCEPTANCE_SCENE_ID,
-    initialBundle: ACCEPTANCE_BUNDLE,
-    initialState: ACCEPTANCE_INITIAL_STATE,
-  });
-});
-
-afterEach(async () => {
-  await orion.close();
-});
-
-describe("WsClient + Store end-to-end", () => {
-  it("connects, receives snapshot, applies it, observes a delta", async () => {
-    const store = createStore();
-    const onSnapshot = vi.fn();
-    const onDelta = vi.fn();
-
-    const client = new WsClient({
-      url: orion.url,
-      token: "fake",
-      webSocketImpl: NodeWebSocket,
-      onSnapshot: (msg) => {
-        applySnapshot(store, msg);
-        onSnapshot(msg);
-      },
-      onDelta: (msg) => {
-        applyDelta(store, msg);
-        onDelta(msg);
-      },
-    });
-    client.start();
-
-    await waitFor(() => onSnapshot.mock.calls.length > 0, 1500);
-    expect(store.signal("score.team_a").value).toBe(14);
-    expect(store.signal("scene.title").value).toBe("Acceptance scene");
-
-    orion.pushDelta([{ path: "score.team_a", value: 15 }]);
-    await waitFor(() => store.signal("score.team_a").value === 15, 1500);
-    expect(onDelta).toHaveBeenCalledTimes(1);
-
-    client.close();
-  });
-
-  it("sequence gap triggers reconnect (covered by the gap-error branch)", async () => {
-    const onTransportError = vi.fn();
-
-    const client = new WsClient({
-      url: orion.url,
-      token: "fake",
-      webSocketImpl: NodeWebSocket,
-      reconnect: { initial: 50, max: 100, factor: 1, jitter: 0 },
-      onTransportError,
-    });
-    client.start();
-
-    // Wait until the first snapshot establishes the baseline.
-    await waitFor(() => client.lastSequence > 0, 1500);
-    const baseline = client.lastSequence;
-    expect(baseline).toBeGreaterThan(0);
-
-    // Push two deltas — both observed contiguously, no gap.
-    orion.pushDelta([{ path: "score.team_a", value: 16 }]);
-    await waitFor(() => client.lastSequence > baseline, 1500);
-
-    client.close();
-    expect(onTransportError).not.toHaveBeenCalled();
-  });
-
-  it("scene_changed swaps the scene and resets the sequence", async () => {
-    const onSnapshot = vi.fn();
-    const onSceneChanged = vi.fn();
-    const client = new WsClient({
-      url: orion.url,
-      token: "fake",
-      webSocketImpl: NodeWebSocket,
-      onSnapshot,
-      onSceneChanged,
-    });
-    client.start();
-
-    await waitFor(() => onSnapshot.mock.calls.length === 1, 1500);
-    expect(client.sceneId).toBe(ACCEPTANCE_SCENE_ID);
-
-    const ALT_BUNDLE = {
-      ...ACCEPTANCE_BUNDLE,
-      scene_version: "sha256:alt-v1",
-    };
-
-    orion.switchScene({
-      sceneId: "alt-scene",
-      bundle: ALT_BUNDLE,
-      state: { "scene.title": "Alt" },
-      transition: { kind: "crossfade", duration_ms: 600 },
-    });
-
-    await waitFor(() => onSceneChanged.mock.calls.length === 1, 1500);
-    await waitFor(() => onSnapshot.mock.calls.length === 2, 1500);
-    expect(client.sceneId).toBe("alt-scene");
-
-    client.close();
-  });
-
-  it("HTTP bundle endpoint returns the registered bundle", async () => {
-    const url = `${orion.httpUrl}/orion/api/v1/scenes/${ACCEPTANCE_SCENE_ID}/render-bundle?v=${encodeURIComponent(ACCEPTANCE_SCENE_VERSION)}`;
-    const res = await fetch(url);
-    expect(res.ok).toBe(true);
-    const bundle = (await res.json()) as { scene_version: string };
-    expect(bundle.scene_version).toBe(ACCEPTANCE_SCENE_VERSION);
-  });
-});
-
-async function waitFor(
-  predicate: () => boolean,
-  timeoutMs: number,
-): Promise<void> {
-  const start = Date.now();
-  while (!predicate()) {
-    if (Date.now() - start > timeoutMs) {
-      throw new Error(`waitFor : predicate not satisfied within ${timeoutMs}ms`);
-    }
-    await new Promise((r) => setTimeout(r, 5));
-  }
-}
diff --git a/tests/unit/prism-scene-public-api.test.ts b/tests/unit/prism-scene-public-api.test.ts
deleted file mode 100644
index 35908a8..0000000
--- a/tests/unit/prism-scene-public-api.test.ts
+++ /dev/null
@@ -1,205 +0,0 @@
-// PrismScene — public API smoke tests. Once published, every shape
-// here is contract : breaking changes require a major bump.
-
-import { describe, expect, it, vi } from "vitest";
-
-import { PrismScene } from "../../src/scene/prism-scene";
-import type { SceneJson } from "../../src/scene/prism-scene";
-
-function makeScene(): SceneJson {
-  return {
-    scene_id: "demo",
-    state: { "score.value": 0, "headline.text": "Hello" },
-    html: `
-      <div data-solar-host>
-        <h1 data-anim-id="headline" data-anim-path="headline.text">Hello</h1>
-        <span data-anim-path="score.value">0</span>
-      </div>
-    `,
-    animations: {
-      Reveal: {
-        patches: [
-          { path: "headline.text", value: "Welcome" },
-        ],
-      },
-      "Score Update": {
-        patches: [
-          {
-            path: "score.value",
-            value: "${param.score_to}" as unknown as number,
-            action: {
-              kind: "count-up",
-              params: { from: 0, to: "${param.score_to}" },
-              duration_ms: 50,
-            },
-          },
-        ],
-      },
-    },
-  };
-}
-
-describe("PrismScene / public API", () => {
-  it("throws if sceneJson is missing", () => {
-    expect(() => new PrismScene({ sceneJson: undefined as never })).toThrow();
-  });
-
-  it("mounts, binds DOM, applies initial state, then unmounts cleanly", () => {
-    const target = document.createElement("div");
-    document.body.appendChild(target);
-    const scene = new PrismScene({ sceneJson: makeScene() });
-    scene.mount(target);
-    const headline = target.querySelector('[data-anim-path="headline.text"]');
-    expect(headline?.textContent).toBe("Hello");
-    scene.unmount();
-    expect(target.querySelector("[data-solar-root]")).toBeNull();
-    target.remove();
-  });
-
-  it("rejects double mount", () => {
-    const target = document.createElement("div");
-    document.body.appendChild(target);
-    const scene = new PrismScene({ sceneJson: makeScene() });
-    scene.mount(target);
-    expect(() => scene.mount(target)).toThrow(/already mounted/);
-    scene.unmount();
-    target.remove();
-  });
-
-  it("plays a named animation, updates bound DOM, and emits completed", async () => {
-    const target = document.createElement("div");
-    document.body.appendChild(target);
-    const scene = new PrismScene({ sceneJson: makeScene() });
-    scene.mount(target);
-
-    const started = vi.fn();
-    const done = vi.fn();
-    scene.on("animation:start", started);
-    scene.on("animation:completed", done);
-
-    await scene.playAnimation("Reveal");
-    expect(started).toHaveBeenCalledWith(
-      expect.objectContaining({ asset_id: "Reveal" }),
-    );
-    expect(done).toHaveBeenCalledWith(
-      expect.objectContaining({ asset_id: "Reveal" }),
-    );
-
-    const headline = target.querySelector('[data-anim-path="headline.text"]');
-    expect(headline?.textContent).toBe("Welcome");
-
-    scene.unmount();
-    target.remove();
-  });
-
-  it("emits animation:error and rejects when the asset is unknown", async () => {
-    const target = document.createElement("div");
-    document.body.appendChild(target);
-    const scene = new PrismScene({ sceneJson: makeScene() });
-    scene.mount(target);
-
-    const err = vi.fn();
-    scene.on("animation:error", err);
-
-    await expect(scene.playAnimation("NopeNope")).rejects.toThrow(/not found/);
-    expect(err).toHaveBeenCalled();
-
-    scene.unmount();
-    target.remove();
-  });
-
-  it("interpolates ${param.*} placeholders into action params", async () => {
-    const target = document.createElement("div");
-    document.body.appendChild(target);
-    const scene = new PrismScene({ sceneJson: makeScene() });
-    scene.mount(target);
-
-    await scene.playAnimation("Score Update", { score_to: 1891 });
-    expect(scene._getStoreSnapshot()["score.value"]).toBe(1891);
-
-    scene.unmount();
-    target.remove();
-  });
-
-  it("forbids concurrent plays of the same asset id", async () => {
-    const target = document.createElement("div");
-    document.body.appendChild(target);
-    const scene = new PrismScene({
-      sceneJson: {
-        animations: {
-          Long: {
-            patches: [
-              {
-                path: "n",
-                value: 100,
-                action: {
-                  kind: "count-up",
-                  params: { from: 0, to: 100 },
-                  duration_ms: 500,
-                },
-              },
-            ],
-          },
-        },
-      },
-    });
-    scene.mount(target);
-
-    const first = scene.playAnimation("Long");
-    await expect(scene.playAnimation("Long")).rejects.toThrow(/already playing/);
-    scene.stopAnimation("Long");
-    await first.catch(() => undefined);
-
-    scene.unmount();
-    target.remove();
-  });
-
-  it("setScene swaps state and re-binds the DOM", () => {
-    const target = document.createElement("div");
-    document.body.appendChild(target);
-    const scene = new PrismScene({ sceneJson: makeScene() });
-    scene.mount(target);
-
-    scene.setScene({
-      state: { greeting: "Bonjour" },
-      html: `<p data-anim-path="greeting">Bonjour</p>`,
-    });
-    const p = target.querySelector('[data-anim-path="greeting"]');
-    expect(p?.textContent).toBe("Bonjour");
-
-    scene.unmount();
-    target.remove();
-  });
-
-  it("off() removes a registered handler", async () => {
-    const target = document.createElement("div");
-    document.body.appendChild(target);
-    const scene = new PrismScene({ sceneJson: makeScene() });
-    scene.mount(target);
-
-    const h = vi.fn();
-    scene.on("animation:completed", h);
-    scene.off("animation:completed", h);
-    await scene.playAnimation("Reveal");
-    expect(h).not.toHaveBeenCalled();
-
-    scene.unmount();
-    target.remove();
-  });
-
-  it("connectToOrion is a no-op in mockMode", () => {
-    const target = document.createElement("div");
-    document.body.appendChild(target);
-    const scene = new PrismScene({
-      sceneJson: makeScene(),
-      mockMode: true,
-    });
-    scene.mount(target);
-    expect(() =>
-      scene.connectToOrion({ url: "wss://example/orion", token: "t" }),
-    ).not.toThrow();
-    scene.disconnectFromOrion();
-    scene.unmount();
-    target.remove();
-  });
-});
diff --git a/tests/unit/reconnect.test.ts b/tests/unit/reconnect.test.ts
deleted file mode 100644
index 6175677..0000000
--- a/tests/unit/reconnect.test.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createReconnectSchedule } from "../../src/transport/reconnect";
-
-describe("ReconnectSchedule", () => {
-  it("computes increasing delays without jitter", () => {
-    const s = createReconnectSchedule({
-      initial: 100,
-      max: 10_000,
-      factor: 2,
-      jitter: 0,
-    });
-    expect(s.delayFor(1)).toBe(100);
-    expect(s.delayFor(2)).toBe(200);
-    expect(s.delayFor(3)).toBe(400);
-    expect(s.delayFor(4)).toBe(800);
-  });
-
-  it("caps delays at max", () => {
-    const s = createReconnectSchedule({
-      initial: 100,
-      max: 1000,
-      factor: 4,
-      jitter: 0,
-    });
-    expect(s.delayFor(1)).toBe(100);
-    expect(s.delayFor(2)).toBe(400);
-    expect(s.delayFor(3)).toBe(1000);
-    expect(s.delayFor(10)).toBe(1000);
-  });
-
-  it("applies jitter within the configured fraction", () => {
-    // Deterministic random : 0 → -jitter*base ; 1 → +jitter*base ; 0.5 → 0.
-    const s = createReconnectSchedule({
-      initial: 100,
-      max: 10_000,
-      factor: 1,
-      jitter: 0.2,
-      random: () => 0,
-    });
-    expect(s.delayFor(1)).toBe(80);
-  });
-
-  it("reset zeroes the attempt counter", () => {
-    const s = createReconnectSchedule({ jitter: 0 });
-    s.delayFor(3);
-    expect(s.attempt).toBe(3);
-    s.reset();
-    expect(s.attempt).toBe(0);
-  });
-
-  it("rejects bad config", () => {
-    expect(() => createReconnectSchedule({ initial: 0 })).toThrow();
-    expect(() => createReconnectSchedule({ initial: 200, max: 100 })).toThrow();
-    expect(() => createReconnectSchedule({ factor: 0.5 })).toThrow();
-    expect(() => createReconnectSchedule({ jitter: 1.5 })).toThrow();
-  });
-});
diff --git a/tests/unit/render.test.tsx b/tests/unit/render.test.tsx
new file mode 100644
index 0000000..b81a410
--- /dev/null
+++ b/tests/unit/render.test.tsx
@@ -0,0 +1,185 @@
+// Proving test for the ADR 007 sub-chantier B swap : Solar's mount() is
+// now a thin adapter over @lumencast/runtime. This test mounts Solar end
+// to end against a fake LSDP/1.1 transport (fake WebSocket) + a fake
+// bundle fetch, and asserts the Lumencast runtime fetches the
+// content-addressed RenderBundle, applies the snapshot state, and renders
+// the bound text into the mount target.
+//
+// It exercises the real seam Solar adds (orionUrl → serverUrl mapping,
+// delegation to the runtime, lifecycle) without re-testing the runtime's
+// internals (those are covered by @lumencast/runtime's own suite). The
+// frame encoding uses the real @lumencast/protocol so the wire is
+// faithful, not a Solar-local mock of a dead protocol.
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { encodeFrame, snapshot } from "@lumencast/protocol";
+import type { RenderBundle } from "@lumencast/runtime";
+import { mount } from "../../src/mount";
+import type { SolarStatus } from "../../src/types";
+
+const SCENE_ID = "scene-proof";
+const SCENE_VERSION = "sha256-proof-0001";
+
+const BUNDLE: RenderBundle = {
+  scene_version: SCENE_VERSION,
+  root: {
+    kind: "stack",
+    children: [
+      {
+        kind: "text",
+        id: "headline",
+        // The runtime resolves `value` from the bound state path and
+        // renders it as the span's text content.
+        bindings: { value: "headline.text" },
+      },
+    ],
+  },
+};
+
+const INITIAL_STATE = {
+  "headline.text": "ON AIR",
+};
+
+// --- fake LSDP/1.1 WebSocket -------------------------------------------
+//
+// Minimal surface the runtime's WsClient touches : constructor with
+// (url, protocols), `protocol`, `readyState`, OPEN/CLOSED constants,
+// onopen/onmessage/onclose/onerror, send(), close(). On `subscribe` it
+// replies with a real encoded snapshot frame.
+
+class FakeWebSocket {
+  static readonly CONNECTING = 0;
+  static readonly OPEN = 1;
+  static readonly CLOSING = 2;
+  static readonly CLOSED = 3;
+  static last: FakeWebSocket | null = null;
+
+  readonly CONNECTING = 0;
+  readonly OPEN = 1;
+  readonly CLOSING = 2;
+  readonly CLOSED = 3;
+
+  readyState = 0;
+  protocol = "lsdp.v1.1"; // server negotiates 1.1
+  onopen: (() => void) | null = null;
+  onmessage: ((ev: { data: string }) => void) | null = null;
+  onclose: ((ev: { code: number; reason: string }) => void) | null = null;
+  onerror: ((ev: unknown) => void) | null = null;
+
+  constructor(
+    public url: string,
+    _protocols?: string | string[],
+  ) {
+    FakeWebSocket.last = this;
+    // Open on the next microtask so the runtime can attach handlers.
+    queueMicrotask(() => {
+      this.readyState = this.OPEN;
+      this.onopen?.();
+    });
+  }
+
+  send(raw: string): void {
+    const frame = JSON.parse(raw) as { type?: string };
+    if (frame.type === "subscribe") {
+      const snap = snapshot({
+        seq: 1,
+        scene_id: SCENE_ID,
+        scene_version: SCENE_VERSION,
+        state: INITIAL_STATE,
+      });
+      queueMicrotask(() => this.onmessage?.({ data: encodeFrame(snap) }));
+    }
+  }
+
+  close(_code?: number, _reason?: string): void {
+    this.readyState = this.CLOSED;
+    this.onclose?.({ code: 1000, reason: "client closing" });
+  }
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  FakeWebSocket.last = null;
+});
+
+describe("Solar mount() over @lumencast/runtime", () => {
+  it("fetches the bundle, applies the snapshot, and renders bound text", async () => {
+    const target = document.createElement("div");
+    document.body.appendChild(target);
+
+    // Fake the content-addressed bundle fetch. The runtime requests
+    // `${base}/lsdp/v1/scenes/{id}/bundle?v={hash}` — we serve the bundle
+    // regardless of the exact path so the test isn't coupled to the
+    // runtime's internal path scheme.
+    const fetchMock = vi.fn(async () =>
+      new Response(JSON.stringify(BUNDLE), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    vi.stubGlobal("WebSocket", FakeWebSocket as unknown as typeof WebSocket);
+
+    const statuses: SolarStatus[] = [];
+    const handle = mount({
+      target,
+      orionUrl: "wss://gate.example/orion/api/v1/show/stream",
+      token: "operator-token",
+      mode: "broadcast",
+      onStatus: (s) => statuses.push(s),
+    });
+
+    // Wait for : WS open → subscribe → snapshot → bundle fetch → React
+    // lazy mode chunk → render. Poll the DOM rather than guessing a fixed
+    // delay.
+    await waitFor(() => target.textContent?.includes("ON AIR") === true);
+
+    expect(target.textContent).toContain("ON AIR");
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    // The runtime surfaced the live status through Solar's onStatus.
+    expect(statuses).toContain("live");
+
+    handle.disconnect();
+    target.remove();
+  });
+
+  it("maps orionUrl onto the runtime serverUrl (WS opened against it)", async () => {
+    const target = document.createElement("div");
+    document.body.appendChild(target);
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => new Response(JSON.stringify(BUNDLE), { status: 200 })),
+    );
+    vi.stubGlobal("WebSocket", FakeWebSocket as unknown as typeof WebSocket);
+
+    const orionUrl = "wss://gate.example/orion/api/v1/show/stream";
+    const handle = mount({
+      target,
+      orionUrl,
+      token: "t",
+      mode: "broadcast",
+    });
+
+    await waitFor(() => FakeWebSocket.last !== null);
+    expect(FakeWebSocket.last?.url).toBe(orionUrl);
+
+    handle.disconnect();
+    target.remove();
+  });
+});
+
+// Poll a predicate until true or timeout. happy-dom + React + the
+// runtime's lazy chunks resolve over several microtasks/macrotasks.
+async function waitFor(
+  predicate: () => boolean,
+  { timeout = 2000, interval = 10 }: { timeout?: number; interval?: number } = {},
+): Promise<void> {
+  const start = Date.now();
+  for (;;) {
+    if (predicate()) return;
+    if (Date.now() - start > timeout) {
+      throw new Error("waitFor: predicate not satisfied within timeout");
+    }
+    await new Promise((r) => setTimeout(r, interval));
+  }
+}
diff --git a/tests/unit/runners-count-up.test.ts b/tests/unit/runners-count-up.test.ts
deleted file mode 100644
index 5c0eef4..0000000
--- a/tests/unit/runners-count-up.test.ts
+++ /dev/null
@@ -1,124 +0,0 @@
-// count-up — runs a numeric tween locally without receiving frame-by-
-// frame patches. The exact intermediate values depend on the easing
-// curve ; we only assert end-state equality plus monotonic progress.
-
-import { describe, expect, it, beforeEach, afterEach, vi } from "vitest";
-
-import { createStore } from "../../src/state/store";
-import { runAction } from "../../src/animate/action-runner";
-
-function makeRafLoop() {
-  let now = 0;
-  const cbs: Array<{ id: number; cb: FrameRequestCallback }> = [];
-  let nextId = 1;
-  const raf = (cb: FrameRequestCallback): number => {
-    const id = nextId++;
-    cbs.push({ id, cb });
-    return id;
-  };
-  const advance = (dtMs: number) => {
-    now += dtMs;
-    const pending = cbs.splice(0, cbs.length);
-    for (const { cb } of pending) cb(now);
-  };
-  return { raf, advance, getNow: () => now };
-}
-
-describe("runners / count-up", () => {
-  let perfSpy: ReturnType<typeof vi.spyOn> | null = null;
-  let rafSpy: ReturnType<typeof vi.stubGlobal> | null = null;
-  let loop: ReturnType<typeof makeRafLoop>;
-
-  beforeEach(() => {
-    loop = makeRafLoop();
-    perfSpy = vi.spyOn(performance, "now").mockImplementation(() => loop.getNow());
-    rafSpy = vi.stubGlobal("requestAnimationFrame", loop.raf);
-  });
-
-  afterEach(() => {
-    perfSpy?.mockRestore();
-    if (rafSpy) vi.unstubAllGlobals();
-  });
-
-  it("tweens from 0 → 1891 over 800ms and ends exactly on the target", async () => {
-    const store = createStore();
-    const promise = runAction({
-      store,
-      patch: {
-        path: "score.value",
-        value: 1891,
-        action: {
-          kind: "count-up",
-          params: { from: 0, to: 1891 },
-          duration_ms: 800,
-        },
-      },
-    });
-    // Drive the RAF loop to completion.
-    for (let i = 0; i < 60; i++) loop.advance(16);
-    loop.advance(200); // overshoot to guarantee completion tick
-    await promise;
-    expect(store.toRecord()["score.value"]).toBe(1891);
-  });
-
-  it("uses patch.value as the implicit `to` when params.to is missing", async () => {
-    const store = createStore();
-    const promise = runAction({
-      store,
-      patch: {
-        path: "n",
-        value: 42,
-        action: { kind: "count-up", params: { from: 0 }, duration_ms: 100 },
-      },
-    });
-    for (let i = 0; i < 20; i++) loop.advance(16);
-    await promise;
-    expect(store.toRecord()["n"]).toBe(42);
-  });
-
-  it("respects `decimals` when rounding intermediate values", async () => {
-    const store = createStore();
-    const samples: number[] = [];
-    // Subscribe to the signal directly to capture intermediate writes.
-    const sig = store.signal("ratio");
-    const dispose = (sig as unknown as { subscribe?: (fn: (v: unknown) => void) => () => void }).subscribe
-      ? (sig as unknown as { subscribe: (fn: (v: unknown) => void) => () => void }).subscribe((v) => {
-          if (typeof v === "number") samples.push(v);
-        })
-      : () => {};
-    const promise = runAction({
-      store,
-      patch: {
-        path: "ratio",
-        value: 1,
-        action: {
-          kind: "count-up",
-          params: { from: 0, to: 1, decimals: 2 },
-          duration_ms: 80,
-        },
-      },
-    });
-    for (let i = 0; i < 15; i++) loop.advance(16);
-    await promise;
-    dispose();
-    expect(store.toRecord()["ratio"]).toBe(1);
-    // Every captured sample is rounded to 2 decimals.
-    for (const s of samples) {
-      const rounded = Math.round(s * 100) / 100;
-      expect(s).toBe(rounded);
-    }
-  });
-
-  it("short-circuits when duration_ms ≤ 0", async () => {
-    const store = createStore();
-    await runAction({
-      store,
-      patch: {
-        path: "x",
-        value: 7,
-        action: { kind: "count-up", params: { from: 0, to: 7 }, duration_ms: 0 },
-      },
-    });
-    expect(store.toRecord()["x"]).toBe(7);
-  });
-});
diff --git a/tests/unit/runners-reorder-flip.test.ts b/tests/unit/runners-reorder-flip.test.ts
deleted file mode 100644
index de239d6..0000000
--- a/tests/unit/runners-reorder-flip.test.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-// reorder — invokes FLIP capture before the mutation and play after.
-// We can't observe pixel transforms under happy-dom (it doesn't lay
-// out), so we assert the contract the runner exposes : (a) captureFlip
-// records every item present at call time, (b) playFlip is invoked
-// against the same root once the store value has been written.
-
-import { describe, expect, it, vi } from "vitest";
-
-import { createStore } from "../../src/state/store";
-import { runAction } from "../../src/animate/action-runner";
-import { captureFlip } from "../../src/animate/flip";
-
-function setupList(): HTMLElement {
-  const root = document.createElement("ul");
-  root.setAttribute("data-anim-path", "leaderboard.order");
-  ["a", "b", "c"].forEach((id) => {
-    const li = document.createElement("li");
-    li.setAttribute("data-flip-id", id);
-    // give happy-dom *something* to measure even if it's zeros
-    li.textContent = id;
-    root.appendChild(li);
-  });
-  document.body.appendChild(root);
-  return root;
-}
-
-describe("runners / reorder + FLIP", () => {
-  it("captures pre-state via captureFlip and writes the new value", async () => {
-    const store = createStore();
-    const root = setupList();
-    const snapshot = captureFlip(root);
-    expect(snapshot.rects.size).toBe(3);
-
-    await runAction({
-      store,
-      root,
-      patch: {
-        path: "leaderboard.order",
-        value: ["c", "a", "b"],
-        action: {
-          kind: "reorder",
-          params: { selector: "[data-flip-id]" },
-          duration_ms: 50,
-        },
-      },
-    });
-
-    expect(store.toRecord()["leaderboard.order"]).toEqual(["c", "a", "b"]);
-    root.remove();
-  });
-
-  it("falls back to a plain store write when no root is provided", async () => {
-    const store = createStore();
-    await runAction({
-      store,
-      patch: {
-        path: "x",
-        value: ["a"],
-        action: { kind: "reorder", params: {} },
-      },
-    });
-    expect(store.toRecord()["x"]).toEqual(["a"]);
-  });
-
-  it("FLIP capture skips elements without a flip id", () => {
-    const root = document.createElement("div");
-    const tagged = document.createElement("div");
-    tagged.setAttribute("data-flip-id", "k");
-    const untagged = document.createElement("div");
-    root.appendChild(tagged);
-    root.appendChild(untagged);
-    document.body.appendChild(root);
-    const s = captureFlip(root);
-    expect(s.rects.size).toBe(1);
-    expect(s.rects.has("k")).toBe(true);
-    root.remove();
-  });
-
-  it("playFlip resolves cleanly with no animations to run", async () => {
-    const root = document.createElement("div");
-    document.body.appendChild(root);
-    const { playFlip } = await import("../../src/animate/flip");
-    await expect(
-      playFlip(root, { rects: new Map() }, { duration: 10 }),
-    ).resolves.toBeUndefined();
-    root.remove();
-  });
-
-  it("rAF is awaited between snapshot and play", async () => {
-    const store = createStore();
-    const root = setupList();
-    const rafSpy = vi.spyOn(globalThis, "requestAnimationFrame");
-    await runAction({
-      store,
-      root,
-      patch: {
-        path: "leaderboard.order",
-        value: ["b", "c", "a"],
-        action: { kind: "reorder", params: {}, duration_ms: 10 },
-      },
-    });
-    expect(rafSpy).toHaveBeenCalled();
-    rafSpy.mockRestore();
-    root.remove();
-  });
-});
diff --git a/tests/unit/runners-text-reveal.test.ts b/tests/unit/runners-text-reveal.test.ts
deleted file mode 100644
index 8d81bb6..0000000
--- a/tests/unit/runners-text-reveal.test.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-// text-reveal — stagger each `[data-anim-unit]` child of the target.
-// We assert the runner walked every unit and toggled the state attr ;
-// happy-dom's `element.animate` is a stub that resolves immediately,
-// so the runner returns quickly under test.
-
-import { describe, expect, it } from "vitest";
-
-import { createStore } from "../../src/state/store";
-import { runAction } from "../../src/animate/action-runner";
-
-function setupRoot(): HTMLElement {
-  const root = document.createElement("div");
-  root.setAttribute("data-anim-path", "headline.text");
-  const html = "Hello";
-  for (const ch of html) {
-    const span = document.createElement("span");
-    span.setAttribute("data-anim-unit", "letter");
-    span.textContent = ch;
-    root.appendChild(span);
-  }
-  document.body.appendChild(root);
-  return root;
-}
-
-describe("runners / text-reveal", () => {
-  it("walks every [data-anim-unit] child and tags it with the state attr", async () => {
-    const store = createStore();
-    const root = setupRoot();
-    const host = document.body;
-
-    await runAction({
-      store,
-      root: host,
-      patch: {
-        path: "headline.text",
-        value: "Hello",
-        action: {
-          kind: "text-reveal",
-          params: { unit: "letter", stagger_ms: 10, per_unit_ms: 20 },
-          duration_ms: 100,
-          child_selector: { kind: "all", value: "[data-anim-unit]" },
-        },
-      },
-    });
-
-    const units = root.querySelectorAll("[data-anim-unit]");
-    expect(units).toHaveLength(5);
-    units.forEach((el) => {
-      expect(el.getAttribute("data-anim-state")).toBe("in");
-    });
-
-    root.remove();
-  });
-
-  it("does nothing gracefully when no children match the selector", async () => {
-    const store = createStore();
-    const root = document.createElement("div");
-    root.setAttribute("data-anim-path", "empty");
-    document.body.appendChild(root);
-
-    await runAction({
-      store,
-      root: document.body,
-      patch: {
-        path: "empty",
-        value: "",
-        action: {
-          kind: "text-reveal",
-          params: {},
-          child_selector: { kind: "all", value: "[data-anim-unit]" },
-        },
-      },
-    });
-
-    root.remove();
-    // No throw, no state mutation expected.
-    expect(store.toRecord()).toEqual({});
-  });
-});
diff --git a/tests/unit/sequence.test.ts b/tests/unit/sequence.test.ts
deleted file mode 100644
index 2c9e743..0000000
--- a/tests/unit/sequence.test.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createSequenceTracker } from "../../src/transport/sequence";
-
-describe("SequenceTracker", () => {
-  it("starts with no baseline", () => {
-    const t = createSequenceTracker();
-    expect(t.last).toBe(-1);
-    expect(t.expected).toBe(0);
-  });
-
-  it("reset establishes the baseline", () => {
-    const t = createSequenceTracker();
-    t.reset(100);
-    expect(t.last).toBe(100);
-    expect(t.expected).toBe(101);
-  });
-
-  it("observe accepts contiguous sequences", () => {
-    const t = createSequenceTracker();
-    t.reset(100);
-    expect(t.observe(101).kind).toBe("ok");
-    expect(t.observe(102).kind).toBe("ok");
-    expect(t.last).toBe(102);
-  });
-
-  it("observe reports a gap on skip", () => {
-    const t = createSequenceTracker();
-    t.reset(100);
-    const obs = t.observe(105);
-    expect(obs.kind).toBe("gap");
-    if (obs.kind === "gap") {
-      expect(obs.expected).toBe(101);
-      expect(obs.got).toBe(105);
-    }
-  });
-
-  it("observe reports a gap on regress", () => {
-    const t = createSequenceTracker();
-    t.reset(100);
-    const obs = t.observe(99);
-    expect(obs.kind).toBe("gap");
-  });
-
-  it("rejects negative reset", () => {
-    const t = createSequenceTracker();
-    expect(() => t.reset(-1)).toThrow(/non-negative/);
-  });
-
-  it("rejects non-finite reset", () => {
-    const t = createSequenceTracker();
-    expect(() => t.reset(Number.NaN)).toThrow();
-    expect(() => t.reset(Number.POSITIVE_INFINITY)).toThrow();
-  });
-});
diff --git a/tests/unit/state.test.ts b/tests/unit/state.test.ts
deleted file mode 100644
index 0bc3916..0000000
--- a/tests/unit/state.test.ts
+++ /dev/null
@@ -1,108 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createStore } from "../../src/state/store";
-import { applySnapshot } from "../../src/state/apply-snapshot";
-import { applyDelta } from "../../src/state/apply-delta";
-import { PROTOCOL_VERSION } from "../../src/transport/protocol";
-
-describe("Store — basic ops", () => {
-  it("creates a signal lazily", () => {
-    const s = createStore();
-    const sig = s.signal("score.team_a");
-    expect(sig.value).toBeUndefined();
-  });
-
-  it("set updates the signal", () => {
-    const s = createStore();
-    s.set("score.team_a", 14);
-    expect(s.signal("score.team_a").value).toBe(14);
-  });
-
-  it("set records the transition", () => {
-    const s = createStore();
-    s.set("score.team_a", 14, { kind: "tween", duration_ms: 200 });
-    expect(s.transitionFor("score.team_a")).toMatchObject({ kind: "tween" });
-  });
-
-  it("set without transition clears any previous one", () => {
-    const s = createStore();
-    s.set("score.team_a", 14, { kind: "tween", duration_ms: 200 });
-    s.set("score.team_a", 15);
-    expect(s.transitionFor("score.team_a")).toBeUndefined();
-  });
-});
-
-describe("applySnapshot", () => {
-  it("seeds the store with the snapshot's state", () => {
-    const s = createStore();
-    applySnapshot(s, {
-      type: "snapshot",
-      v: PROTOCOL_VERSION,
-      scene_id: "scene-1",
-      scene_version: "v1",
-      sequence: 1,
-      state: { "score.team_a": 14, "logo.visible": true },
-    });
-    expect(s.signal("score.team_a").value).toBe(14);
-    expect(s.signal("logo.visible").value).toBe(true);
-  });
-
-  it("resets paths not present in the snapshot to undefined", () => {
-    const s = createStore();
-    s.set("ticker.text", "hello");
-    applySnapshot(s, {
-      type: "snapshot",
-      v: PROTOCOL_VERSION,
-      scene_id: "scene-1",
-      scene_version: "v1",
-      sequence: 1,
-      state: { "score.team_a": 14 },
-    });
-    expect(s.signal("ticker.text").value).toBeUndefined();
-  });
-
-  it("clears transitions on snapshot", () => {
-    const s = createStore();
-    s.set("score.team_a", 14, { kind: "tween", duration_ms: 200 });
-    applySnapshot(s, {
-      type: "snapshot",
-      v: PROTOCOL_VERSION,
-      scene_id: "scene-1",
-      scene_version: "v1",
-      sequence: 1,
-      state: { "score.team_a": 14 },
-    });
-    expect(s.transitionFor("score.team_a")).toBeUndefined();
-  });
-});
-
-describe("applyDelta", () => {
-  it("applies multiple patches atomically", () => {
-    const s = createStore();
-    applyDelta(s, {
-      type: "delta",
-      v: PROTOCOL_VERSION,
-      scene_id: "scene-1",
-      sequence: 2,
-      patches: [
-        { path: "score.team_a", value: 15 },
-        { path: "score.team_a_diff", value: 1 },
-      ],
-    });
-    expect(s.signal("score.team_a").value).toBe(15);
-    expect(s.signal("score.team_a_diff").value).toBe(1);
-  });
-
-  it("supports deep paths through arrays and objects", () => {
-    const s = createStore();
-    applyDelta(s, {
-      type: "delta",
-      v: PROTOCOL_VERSION,
-      scene_id: "scene-1",
-      sequence: 1,
-      patches: [
-        { path: "composites.7.players.3.score", value: 12 },
-      ],
-    });
-    expect(s.signal("composites.7.players.3.score").value).toBe(12);
-  });
-});
diff --git a/vite.config.ts b/vite.config.ts
index 6a261c2..527b0de 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -3,23 +3,10 @@ import { defineConfig } from "vite";
 import react from "@vitejs/plugin-react";
 import dts from "vite-plugin-dts";
 
-// Solar publishes ESM as multi-entry library : the main bundle plus
-// the `animate/flip` subpath, which Prism consumes directly so both
-// runtimes share a single FLIP implementation.
-//
-// The UMD bundle (for `<script>` embed) is produced by a second
-// Vite invocation (`vite.config.umd.ts`) — Vite library mode forces
-// a single entry as soon as UMD is in the format list.
-
-const EXTERNAL = [
-  /^react($|\/)/,
-  /^react-dom($|\/)/,
-  /^@preact\/signals(-react)?($|\/)/,
-  /^framer-motion($|\/)/,
-  /^motion($|\/)/,
-  /^motion-dom($|\/)/,
-  /^motion-utils($|\/)/,
-];
+// Solar is published as @zablab/solar — a single ESM bundle plus
+// CSS and types. The HTML wrapper consumed by Pulsar CEF is built
+// in a follow-up step (see scripts/build-html.* — out of scope for
+// the initial scaffold).
 
 export default defineConfig({
   plugins: [
@@ -35,33 +22,31 @@ export default defineConfig({
       outDir: "dist",
       rollupTypes: true,
       tsconfigPath: "./tsconfig.lib.json",
-      // The chantier criterion 8 expects `dist/solar.d.ts` ; we
-      // re-publish the rolled bundle under that name post-build via
-      // scripts/finalise-dist.mjs to avoid touching the dts plugin's
-      // default index.d.ts output.
     }),
   ],
   build: {
     lib: {
-      entry: {
-        solar: resolve(__dirname, "src/index.ts"),
-        "animate/flip": resolve(__dirname, "src/animate/flip.ts"),
-      },
+      entry: resolve(__dirname, "src/index.ts"),
       name: "Solar",
       formats: ["es"],
-      fileName: (_format, entryName) => {
-        if (entryName === "solar") return "solar.js";
-        return `${entryName}.js`;
-      },
+      fileName: () => "solar.js",
       cssFileName: "solar",
     },
     rollupOptions: {
-      external: EXTERNAL,
+      external: [
+        /^react($|\/)/,
+        /^react-dom($|\/)/,
+        /^@preact\/signals(-react)?($|\/)/,
+        /^framer-motion($|\/)/,
+        /^motion($|\/)/,
+        /^motion-dom($|\/)/,
+        /^motion-utils($|\/)/,
+      ],
       output: {
-        // Multi-entry ESM keeps chunks per entry ; we still pin
-        // friendly names for shared chunks so the dist tree stays
-        // legible to consumers reading the tarball manifest.
-        chunkFileNames: "chunks/[name]-[hash].js",
+        globals: {
+          react: "React",
+          "react-dom": "ReactDOM",
+        },
       },
     },
     sourcemap: true,
diff --git a/vite.config.umd.ts b/vite.config.umd.ts
deleted file mode 100644
index 1be25d3..0000000
--- a/vite.config.umd.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import { resolve } from "node:path";
-import { defineConfig } from "vite";
-import react from "@vitejs/plugin-react";
-
-// UMD bundle for <script>-tag embeds on third-party sites.
-// React + react-dom stay external — the host page must load them
-// separately and expose them as `window.React` / `window.ReactDOM`,
-// per the AI SDK / Preact Signals embed conventions.
-
-const EXTERNAL = [
-  "react",
-  "react-dom",
-  "react-dom/client",
-  "@preact/signals-react",
-  "framer-motion",
-  "motion",
-  "motion-dom",
-  "motion-utils",
-];
-
-export default defineConfig({
-  plugins: [react()],
-  build: {
-    // Don't wipe the ESM artefacts emitted by vite.config.ts.
-    emptyOutDir: false,
-    lib: {
-      entry: resolve(__dirname, "src/index.ts"),
-      name: "Solar",
-      formats: ["umd"],
-      fileName: () => "solar.umd.js",
-    },
-    rollupOptions: {
-      external: EXTERNAL,
-      output: {
-        globals: {
-          react: "React",
-          "react-dom": "ReactDOM",
-          "react-dom/client": "ReactDOM",
-          "@preact/signals-react": "PreactSignalsReact",
-          "framer-motion": "FramerMotion",
-          motion: "Motion",
-          "motion-dom": "MotionDom",
-          "motion-utils": "MotionUtils",
-        },
-        exports: "named",
-        // Avoid the "named and default exports" rollup warning that
-        // would otherwise spam the UMD build because we re-export
-        // types alongside the runtime members.
-      },
-    },
-    sourcemap: true,
-    target: "es2018",
-  },
-});