diff --git a/.gitignore b/.gitignore
index f8285e5..31b6f2c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -68,3 +68,4 @@ jspm_packages/
 
 # Stores VSCode versions used for testing VSCode extensions
 .vscode-test
+/.agent-shell/
diff --git a/package.json b/package.json
index 7ac8795..2a7a3d2 100644
--- a/package.json
+++ b/package.json
@@ -24,10 +24,12 @@
         "build": "bsh build",
         "format": "bsh format",
         "lint": "bsh lint",
-        "test": "bsh test"
+        "test": "bsh test",
+        "demo": "node scripts/demo.mjs"
     },
     "devDependencies": {
-        "@bomb.sh/tools": "latest"
+        "@bomb.sh/tools": "latest",
+        "typescript": "^6.0.3"
     },
     "publishConfig": {
         "access": "public"
diff --git a/packages/demo/package.json b/packages/demo/package.json
index eecc05f..0609031 100644
--- a/packages/demo/package.json
+++ b/packages/demo/package.json
@@ -23,8 +23,11 @@
         "test": "bsh test"
     },
     "dependencies": {
-        "@bomb.sh/tty": "latest",
-        "@types/node": "^26.0.0"
+        "@bomb.sh/freedom": "workspace:*",
+        "@bomb.sh/input": "workspace:^",
+        "@bomb.sh/tty": "https://pkg.pr.new/@bomb.sh/tty@103",
+        "@types/node": "^26.0.0",
+        "effection": "4.1.0-alpha.9"
     },
     "devDependencies": {
         "@bomb.sh/tools": "latest"
diff --git a/packages/demo/src/freedom-focus-text-input.ts b/packages/demo/src/freedom-focus-text-input.ts
new file mode 100644
index 0000000..0ac14de
--- /dev/null
+++ b/packages/demo/src/freedom-focus-text-input.ts
@@ -0,0 +1,231 @@
+// oxlint-disable bombshell-dev/no-generic-error
+import { each, ensure, main, spawn, until } from "effection";
+import {
+  advance,
+  createNodeData,
+  createRoot,
+  type Node,
+  retreat,
+  useFocus,
+} from "@bomb.sh/freedom";
+import {
+  initInput,
+  KeyboardApi,
+  useInput,
+  useReadlineKeymap,
+} from "@bomb.sh/input";
+import {
+  alternateBuffer,
+  close,
+  createTerm,
+  cursor,
+  fit,
+  grow,
+  type Op,
+  open,
+  percent,
+  rgba,
+  settings,
+  text,
+} from "@bomb.sh/tty";
+import { stdin, stdout } from "node:process";
+import { useInput as decodeBytes } from "./use-input.ts";
+import { useStdin } from "./use-stdin.ts";
+
+const GRAY = rgba(100, 100, 100);
+
+interface LayoutOptions {
+  node: Node;
+  children: Iterable<Op>;
+}
+
+const layoutKey = createNodeData<(options: LayoutOptions) => Op[]>(
+  "demo:layout",
+  () => [],
+);
+
+function layout(node: Node, body: (options: LayoutOptions) => Op[]): void {
+  node.data.set(layoutKey, body);
+}
+
+// A bordered text input. Editing, caret, and focus state come from
+// `@bomb.sh/input` (`makeInput`); the demo owns only how it's drawn. The focused
+// input passes its `caret` (a code-point offset) to `text()`, so tty positions
+// the terminal's native cursor there rather than drawing a glyph.
+function textInput(node: Node): void {
+  initInput(node);
+  layout(node, () => {
+    const focused = node.props.focused;
+    const value = String(node.props.value ?? "");
+    const caret = Math.min(Number(node.props.caret ?? 0), [...value].length);
+    const color = focused ? rgba(255, 255, 255) : GRAY;
+    const border = { color, top: 1, right: 1, bottom: 1, left: 1 };
+    return [
+      open(node.id, {
+        border,
+        layout: {
+          height: fit(3),
+          width: percent(0.3),
+          padding: { top: 1, right: 1, bottom: 1, left: 1 },
+        },
+      }),
+      // An empty focused field has no cell for the native cursor, so render a
+      // single space to give the caret at 0 somewhere to sit.
+      focused ? text(value || " ", { caret }) : text(value),
+      close(),
+    ];
+  });
+}
+
+function screenBody({ node, children }: LayoutOptions): Op[] {
+  return [
+    open(node.id, {
+      layout: {
+        height: grow(),
+        width: grow(),
+        direction: "ttb",
+        padding: { top: 1, right: 1, bottom: 1, left: 1 },
+      },
+      border: {
+        color: rgba(255, 255, 255),
+        top: 1,
+        right: 1,
+        bottom: 1,
+        left: 1,
+      },
+    }),
+    ...children,
+    close(),
+  ];
+}
+
+function containerBody({ node, children }: LayoutOptions): Op[] {
+  return [
+    open(node.id, {
+      border: { color: 0xFFF, top: 1, right: 1, bottom: 1, left: 1 },
+      layout: {
+        height: fit(),
+        width: grow(),
+        direction: "ttb",
+        padding: { top: 1, right: 1, bottom: 1, left: 1 },
+      },
+    }),
+    ...children,
+    close(),
+  ];
+}
+
+await main(function* () {
+  if (!stdin.isTTY) {
+    throw new Error("freedom demo requires an interactive TTY");
+  }
+
+  const root = createRoot();
+
+  // Route keyboard events to the focused input's editing behavior.
+  useInput(root);
+  useReadlineKeymap(root.node);
+
+  // Tab/Backtab move focus between inputs. Installed at the root scope so it
+  // wraps the focused input's editing behavior (root is an ancestor of where
+  // `KeyboardApi` is invoked): Tab/Backtab are consumed here, every other key
+  // falls through via `next` to the input.
+  root.node.scope.around(KeyboardApi, {
+    keydown([node, event], next) {
+      if (event.code === "Tab") {
+        advance(root.node);
+      } else if (event.code === "Backtab") {
+        retreat(root.node);
+      } else {
+        next(node, event);
+      }
+    },
+    keyrepeat([node, event], next) {
+      if (event.code === "Tab") {
+        advance(root.node);
+      } else if (event.code === "Backtab") {
+        retreat(root.node);
+      } else {
+        next(node, event);
+      }
+    },
+  });
+
+  layout(root.node, screenBody);
+
+  const container = root.node.createChild("input-1");
+  layout(container, containerBody);
+
+  textInput(container.createChild("input-1-1"));
+  textInput(container.createChild("input-1-2"));
+  textInput(root.node.createChild("input-2"));
+
+  useFocus(root.node); // seed focus now that focusable inputs exist (input-1-1)
+
+  const { columns, rows } = stdout.isTTY
+    ? { columns: stdout.columns, rows: stdout.rows }
+    : { columns: 80, rows: 24 };
+
+  stdin.setRawMode(true);
+  yield* ensure(() => {
+    stdin.setRawMode(false);
+    stdin.pause();
+  });
+
+  const bytes = yield* useStdin();
+  const stream = decodeBytes(bytes);
+
+  let term = yield* until(createTerm({ height: rows, width: columns }));
+
+  const events = yield* spawn(function* () {
+    for (const event of yield* each(stream)) {
+      if (event.type === "keydown" && event.ctrl && event.code === "c") {
+        break;
+      }
+      if (event.type === "resize") {
+        term = yield* until(createTerm({
+          height: event.height,
+          width: event.width,
+        }));
+        render();
+      }
+
+      root.dispatch(event);
+
+      yield* each.next();
+    }
+  });
+
+  function render(): void {
+    const ops = walk(root.node);
+    const { output } = term.render(ops);
+    stdout.write(output);
+  }
+
+  const tty = settings(cursor(true), alternateBuffer());
+
+  try {
+    stdout.write(tty.apply);
+
+    render();
+    yield* spawn(function* () {
+      for (const _ of yield* each(root)) {
+        render();
+        yield* each.next();
+      }
+    });
+
+    yield* events;
+  } finally {
+    stdout.write(tty.revert);
+  }
+});
+
+function walk(node: Node): Op[] {
+  const children: Op[] = [];
+  for (const child of node.children) {
+    children.push(...walk(child));
+  }
+  const body = node.data.get(layoutKey);
+  return body ? body({ node, children }) : children;
+}
diff --git a/packages/demo/src/pizza.ts b/packages/demo/src/pizza.ts
new file mode 100644
index 0000000..c0c3b9e
--- /dev/null
+++ b/packages/demo/src/pizza.ts
@@ -0,0 +1,322 @@
+// oxlint-disable bombshell-dev/no-generic-error
+import { each, ensure, main, spawn, until } from "effection";
+import {
+  advance,
+  createNodeData,
+  createRoot,
+  focusable,
+  focusPush,
+  type Node,
+  retreat,
+  type Root,
+  useFocus,
+} from "@bomb.sh/freedom";
+import {
+  initInput,
+  KeyboardApi,
+  useInput as installInput,
+  useReadlineKeymap,
+} from "@bomb.sh/input";
+import {
+  alternateBuffer,
+  close,
+  createTerm,
+  fit,
+  grow,
+  type KeyEvent,
+  type Op,
+  open,
+  rgba,
+  settings,
+  text,
+} from "@bomb.sh/tty";
+import { stdin, stdout } from "node:process";
+import { pathToFileURL } from "node:url";
+import { useInput } from "./use-input.ts";
+import { useStdin } from "./use-stdin.ts";
+
+const WHITE = rgba(255, 255, 255); // all text, and the focused border
+const GRAY = rgba(100, 100, 100); // unfocused border only
+
+interface LayoutOptions {
+  node: Node;
+  children: Iterable<Op>;
+}
+
+const layoutKey = createNodeData<(options: LayoutOptions) => Op[]>(
+  "demo:layout",
+  () => [],
+);
+
+function layout(node: Node, body: (options: LayoutOptions) => Op[]): void {
+  node.data.set(layoutKey, body);
+}
+
+// The centering screen: holds the form box in the middle of the terminal.
+function screenBody({ node, children }: LayoutOptions): Op[] {
+  return [
+    open(node.id, {
+      layout: { width: grow(), height: grow(), alignX: "center", alignY: "center" },
+    }),
+    ...children,
+    close(),
+  ];
+}
+
+// The titled, bordered form panel.
+function formBody({ node, children }: LayoutOptions): Op[] {
+  return [
+    open(node.id, {
+      border: { color: WHITE, top: 1, right: 1, bottom: 1, left: 1 },
+      layout: {
+        direction: "ttb",
+        width: fit(48),
+        height: fit(),
+        padding: { top: 1, right: 1, bottom: 1, left: 1 },
+        gap: 1,
+      },
+    }),
+    text("Pizza Delivery", { color: WHITE }),
+    ...children,
+    close(),
+  ];
+}
+
+// A labelled text input. Readline editing is provided by @bomb.sh/input; the
+// focused field renders a native cursor via the value text's `caret`.
+function makeField(node: Node, label: string): void {
+  initInput(node); // focusable + input:true + value:"" + caret:0
+  layout(node, () => {
+    const focused = node.props.focused === true;
+    const border = focused ? WHITE : GRAY;
+    return [
+      open(`${node.id}-field`, {
+        layout: { direction: "ttb", width: grow(), padding: { left: 1, right: 1 } },
+      }),
+      text(label, { color: WHITE }),
+      open(node.id, {
+        border: { color: border, top: 1, right: 1, bottom: 1, left: 1 },
+        layout: {
+          width: grow(),
+          height: fit(3),
+          padding: { top: 1, right: 1, bottom: 1, left: 1 },
+        },
+      }),
+      text(String(node.props.value ?? ""), {
+        color: WHITE,
+        caret: focused ? Number(node.props.caret ?? 0) : undefined,
+      }),
+      close(),
+      close(),
+    ];
+  });
+}
+
+// A single-line activatable control (link/button). Focused shows `› text ‹`
+// over a background that eases in.
+function makeControl(node: Node, label: string): void {
+  focusable(node);
+  node.set("label", label);
+  layout(node, () => {
+    const focused = node.props.focused === true;
+    const caption = String(node.props.label ?? "");
+    // Reserve the caret columns in both states so the label never shifts.
+    const content = focused ? `› ${caption} ‹` : `  ${caption}  `;
+    return [
+      open(node.id, {
+        layout: { width: grow(), padding: { left: 1, right: 1 } },
+      }),
+      text(content, { color: WHITE }),
+      close(),
+    ];
+  });
+}
+
+// Fire `onActivate` when the focused control receives Enter or Space; other
+// keys bubble so Tab/Backtab still navigate.
+function activatable(node: Node, onActivate: () => void): void {
+  node.scope.around(KeyboardApi, {
+    keydown([n, event], next) {
+      if (event.code === "Enter" || event.code === " ") {
+        onActivate();
+      } else {
+        next(n, event);
+      }
+    },
+  });
+}
+
+// The credit-card modal: a floating panel centered over (and occluding) the
+// form, on top via zIndex. Its own focus root traps Tab/Backtab (§12).
+function cardModalBody({ node, children }: LayoutOptions): Op[] {
+  return [
+    open(node.id, {
+      border: { color: WHITE, top: 1, right: 1, bottom: 1, left: 1 },
+      bg: rgba(0, 0, 0),
+      floating: {
+        attachTo: "root",
+        attachPoints: { element: "center-center", parent: "center-center" },
+        zIndex: 10,
+      },
+      layout: {
+        direction: "ttb",
+        width: fit(40),
+        height: fit(),
+        padding: { top: 1, right: 1, bottom: 1, left: 1 },
+        gap: 1,
+      },
+    }),
+    text("Card details", { color: WHITE }),
+    ...children,
+    close(),
+  ];
+}
+
+function isConfirmed(value: unknown): value is { last4: string } {
+  return !!value && typeof value === "object" && "last4" in value;
+}
+
+// Open the card modal: build its subtree, push it as the focus root, and wire
+// Cancel/Confirm to pop with a result the push callback acts on.
+function openCardModal(root: Root, card: Node): void {
+  const modal = root.node.createChild("card-modal");
+  layout(modal, cardModalBody);
+  const number = modal.createChild("card-number");
+  makeField(number, "Card number");
+  makeField(modal.createChild("expiry"), "Expiry");
+  makeField(modal.createChild("cvc"), "CVC");
+  const cancel = modal.createChild("cancel");
+  makeControl(cancel, "Cancel");
+  const confirm = modal.createChild("confirm");
+  makeControl(confirm, "Confirm");
+
+  const pop = focusPush(modal, (value) => {
+    if (isConfirmed(value)) {
+      card.set("label", `Edit card •••• ${value.last4}`);
+    }
+    void modal.remove(); // focus already restored to the card link
+  });
+
+  activatable(cancel, () => pop({ cancelled: true }));
+  activatable(confirm, () => {
+    const digits = String(number.props.value ?? "").replace(/\D/g, "");
+    pop({ last4: digits.slice(-4) || "????" });
+  });
+}
+
+// Build the pizza form's node tree: a centered panel holding two text fields
+// and two activatable controls, with Tab/Backtab focus navigation installed.
+export function buildPizza(): Root {
+  const root = createRoot();
+
+  // Demux + readline editing (insert-at-caret, Backspace/Delete, arrows,
+  // Home/End) from @bomb.sh/input, plus its emacs Ctrl-A/E/F/B/D keymap.
+  installInput(root);
+  useReadlineKeymap(root.node);
+
+  // Tab/Backtab navigation, bubbled up from nodes that don't consume the key.
+  function tab([node, event]: [Node, KeyEvent], next: (node: Node, event: KeyEvent) => void): void {
+    if (event.code === "Tab") {
+      advance(root.node);
+    } else if (event.code === "Backtab") {
+      retreat(root.node);
+    } else {
+      next(node, event);
+    }
+  }
+  root.node.scope.around(KeyboardApi, { keydown: tab });
+
+  layout(root.node, screenBody);
+
+  const panel = root.node.createChild("form");
+  layout(panel, formBody);
+
+  makeField(panel.createChild("name"), "Name");
+  makeField(panel.createChild("address"), "Address");
+  const card = panel.createChild("card");
+  makeControl(card, "Add card");
+  activatable(card, () => openCardModal(root, card));
+  makeControl(panel.createChild("submit"), "Submit");
+
+  useFocus(root.node); // seed focus now that focusable controls exist (name)
+
+  return root;
+}
+
+export function walk(node: Node): Op[] {
+  const children: Op[] = [];
+  for (const child of node.children) {
+    children.push(...walk(child));
+  }
+  const body = node.data.get(layoutKey);
+  return body ? body({ node, children }) : children;
+}
+
+function* run() {
+  if (!stdin.isTTY) {
+    throw new Error("pizza demo requires an interactive TTY");
+  }
+
+  const root = buildPizza();
+
+  const { columns, rows } = stdout.isTTY
+    ? { columns: stdout.columns, rows: stdout.rows }
+    : { columns: 80, rows: 24 };
+
+  stdin.setRawMode(true);
+  yield* ensure(() => {
+    stdin.setRawMode(false);
+    stdin.pause();
+  });
+
+  const bytes = yield* useStdin();
+  const input = useInput(bytes);
+
+  let term = yield* until(createTerm({ height: rows, width: columns }));
+
+  function render(): void {
+    const { output } = term.render(walk(root.node), { deltaTime: 0 });
+    if (output.length > 0) {
+      stdout.write(output);
+    }
+  }
+
+  const tty = settings(alternateBuffer()); // native cursor shown via text carets
+
+  try {
+    stdout.write(tty.apply);
+
+    // Event-driven: paint once, then only when the tree changes. Rendering
+    // every frame would re-emit the cursor position each tick and reset the
+    // terminal's blink timer, so an idle cursor would never blink.
+    render();
+    yield* spawn(function* () {
+      for (const _ of yield* each(root)) {
+        render();
+        yield* each.next();
+      }
+    });
+
+    for (const event of yield* each(input)) {
+      if (event.type === "keydown" && event.ctrl && event.code === "c") {
+        break;
+      }
+      if (event.type === "resize") {
+        term = yield* until(createTerm({
+          height: event.height,
+          width: event.width,
+        }));
+        render();
+      }
+      root.dispatch(event);
+      yield* each.next();
+    }
+  } finally {
+    stdout.write(tty.revert);
+  }
+}
+
+// Run the IO loop only when executed directly, not when imported for testing.
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
+  await main(run);
+}
diff --git a/packages/demo/src/use-input.ts b/packages/demo/src/use-input.ts
new file mode 100644
index 0000000..2606c56
--- /dev/null
+++ b/packages/demo/src/use-input.ts
@@ -0,0 +1,70 @@
+import {
+  call,
+  createChannel,
+  each,
+  type Operation,
+  race,
+  resource,
+  sleep,
+  spawn,
+  type Stream,
+  suspend,
+  until,
+} from "effection";
+import {
+  createInput,
+  type InputEvent,
+  type InputOptions,
+} from "@bomb.sh/tty";
+
+function nothing() {
+  return suspend() as unknown as Operation<
+    IteratorResult<Uint8Array, void>
+  >;
+}
+
+// Parse a raw byte Stream into a Stream of decoded terminal InputEvents.
+export function useInput(
+  stream: Stream<Uint8Array, void>,
+  options?: InputOptions,
+): Stream<InputEvent, void> {
+  return resource(function* (provide) {
+    const input = yield* until(createInput(options));
+    const subscription = yield* stream;
+
+    let pending = nothing();
+
+    const events = createChannel<InputEvent, void>();
+
+    yield* spawn(function* () {
+      let next = yield* subscription.next();
+      while (!next.done) {
+        const result = input.scan(next.value);
+        pending = result.pending ? rescan(result.pending.delay) : nothing();
+        for (const event of result.events) {
+          yield* events.send(event);
+        }
+        next = yield* race([subscription.next(), pending]);
+      }
+      yield* events.close();
+    });
+
+    yield* race([provide(yield* events), drain(events)]);
+  });
+}
+
+function rescan(delay: number): ReturnType<typeof nothing> {
+  return call(function* (): Operation<IteratorResult<Uint8Array, void>> {
+    yield* sleep(delay);
+    return {
+      done: false,
+      value: new Uint8Array(),
+    };
+  });
+}
+
+function* drain<T, TClose>(stream: Stream<T, TClose>): Operation<void> {
+  for (const _ of yield* each(stream)) {
+    yield* each.next();
+  }
+}
diff --git a/packages/demo/src/use-stdin.ts b/packages/demo/src/use-stdin.ts
new file mode 100644
index 0000000..eb2c9ca
--- /dev/null
+++ b/packages/demo/src/use-stdin.ts
@@ -0,0 +1,37 @@
+import {
+  createChannel,
+  each,
+  type Operation,
+  race,
+  resource,
+  spawn,
+  type Stream,
+  until,
+} from "effection";
+import { stdin } from "node:process";
+
+// Bridge Node's process.stdin (raw bytes) into an Effection Stream.
+export function useStdin(): Operation<Stream<Uint8Array, void>> {
+  return resource(function* (provide) {
+    const channel = createChannel<Uint8Array, void>();
+
+    const iterator = stdin[Symbol.asyncIterator]();
+
+    yield* spawn(function* () {
+      let next = yield* until(iterator.next());
+      while (!next.done) {
+        yield* channel.send(next.value);
+        next = yield* until(iterator.next());
+      }
+      yield* channel.close();
+    });
+
+    yield* race([provide(channel), drain(channel)]);
+  });
+}
+
+function* drain<T, TClose>(stream: Stream<T, TClose>): Operation<void> {
+  for (const _ of yield* each(stream)) {
+    yield* each.next();
+  }
+}
diff --git a/packages/freedom-react/examples/counter.tsx b/packages/freedom-react/examples/counter.tsx
new file mode 100644
index 0000000..0a85807
--- /dev/null
+++ b/packages/freedom-react/examples/counter.tsx
@@ -0,0 +1,247 @@
+// oxlint-disable bombshell-dev/no-generic-error
+// A counter rendered through the freedom-react reconciler to @bomb.sh/tty.
+//
+// Run it:  pnpm --filter @bomb.sh/freedom-react counter
+//
+// JSX (<box>/<text>/<button>) reconciles into a freedom tree; `walk` turns that
+// tree into tty draw ops. Keypresses are routed through `root.dispatch`, so the
+// button's handler runs inside the dispatch cycle and the resulting prop change
+// flips the tree dirty -> the root stream notifies -> we redraw.
+//
+// onClick can't ride on props yet (the reconciler skips function props — that
+// integration comes later), so the button registers its handler via the `ref`
+// escape hatch: getPublicInstance returns the freedom node.
+import { type ReactNode, useCallback, useState } from "react";
+import { each, ensure, main, spawn, until } from "effection";
+import { createRoot, DispatchApi, type Node } from "@bomb.sh/freedom";
+import { mount } from "../src/index.ts";
+import {
+  alternateBuffer,
+  close,
+  createTerm,
+  cursor,
+  fit,
+  grow,
+  type KeyEvent,
+  type Op,
+  open,
+  rgba,
+  settings,
+  text,
+} from "@bomb.sh/tty";
+import { stdin, stdout } from "node:process";
+import { useInput } from "./use-input.ts";
+import { useStdin } from "./use-stdin.ts";
+
+declare global {
+  // oxlint-disable-next-line no-namespace
+  namespace JSX {
+    interface IntrinsicElements {
+      box: { children?: ReactNode };
+      text: { value?: string };
+      button: { label?: string; ref?: (node: Node | null) => void };
+    }
+  }
+}
+
+const presses = new Map<Node, () => void>();
+
+function Button(props: { label: string; onPress: () => void }): ReactNode {
+  const ref = useCallback((node: Node | null) => {
+    if (node) {
+      presses.set(node, props.onPress);
+    }
+  }, [props.onPress]);
+  return <button label={ props.label } ref = { ref } />;
+}
+
+function Counter(): ReactNode {
+  const [count, setCount] = useState(0);
+  const increment = useCallback(() => setCount((c) => c + 1), []);
+  return (
+    <box>
+    <text value= {`Count: ${count}`
+} />
+  < text value = "" />
+    <Button label="  +  " onPress = { increment } />
+      <text value="" />
+        <text value="space/enter to increment · ctrl-c to quit" />
+          </box>
+  );
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// Invoke the first button's registered handler.
+function press(node: Node): void {
+  for (const child of node.children) {
+    if (child.name === "button") {
+      presses.get(child)?.();
+      return;
+    }
+    press(child);
+  }
+}
+
+function isActivate(event: unknown): boolean {
+  const e = event as KeyEvent;
+  if (!e || e.type !== "keydown") {
+    return false;
+  }
+  return e.key === " " || e.code === "Space" || e.code === "Enter" ||
+    e.code === "Return";
+}
+
+// Turn the freedom tree into tty draw ops, dispatching on element name.
+function walk(node: Node): Op[] {
+  const kids: Op[] = [];
+  for (const child of node.children) {
+    kids.push(...walk(child));
+  }
+  switch (node.name) {
+    case "box":
+      return [
+        open(node.id, {
+          layout: {
+            direction: "ttb",
+            width: grow(),
+            height: grow(),
+            padding: { top: 1, right: 2, bottom: 1, left: 2 },
+          },
+          border: { color: rgba(255, 255, 255), top: 1, right: 1, bottom: 1, left: 1 },
+        }),
+        ...kids,
+        close(),
+      ];
+    case "button":
+      return [
+        open(node.id, {
+          layout: {
+            width: fit(),
+            height: fit(),
+            padding: { top: 0, right: 1, bottom: 0, left: 1 },
+          },
+          border: { color: rgba(120, 200, 255), top: 1, right: 1, bottom: 1, left: 1 },
+        }),
+        text(String(node.props["label"] ?? "")),
+        ...kids,
+        close(),
+      ];
+    case "text":
+      return [text(String(node.props["value"] ?? ""))];
+    default:
+      return kids;
+  }
+}
+
+await main(function*() {
+  if (!stdin.isTTY) {
+    throw new Error("counter example requires an interactive TTY");
+  }
+
+  const root = createRoot();
+  mount(<Counter />, root.node);
+
+  // Route activation keys to the button inside the dispatch cycle, so the
+  // resulting prop change is picked up by the dirty -> notify -> render loop.
+  root.node.scope.around(DispatchApi, {
+    *dispatch([event], next) {
+      if (isActivate(event)) {
+        press(root.node);
+        return { ok: true, value: true };
+      }
+      return yield* next(event);
+    },
+  });
+
+  const { columns, rows } = stdout.isTTY
+    ? { columns: stdout.columns, rows: stdout.rows }
+    : { columns: 80, rows: 24 };
+
+  stdin.setRawMode(true);
+  yield* ensure(() => {
+    stdin.setRawMode(false);
+    stdin.pause();
+  });
+
+  const bytes = yield* useStdin();
+  const input = useInput(bytes);
+
+  let term = yield* until(createTerm({ height: rows, width: columns }));
+
+  const events = yield* spawn(function*() {
+    for (const event of yield* each(input)) {
+      if (event.type === "keydown" && event.ctrl && event.code === "c") {
+        break;
+      }
+      if (event.type === "resize") {
+        term = yield* until(createTerm({
+          height: event.height,
+          width: event.width,
+        }));
+      }
+
+      root.dispatch(event);
+
+      yield* each.next();
+    }
+  });
+
+  function render(): void {
+    const { output } = term.render(walk(root.node));
+    stdout.write(output);
+  }
+
+  const tty = settings(cursor(false), alternateBuffer());
+
+  try {
+    stdout.write(tty.apply);
+
+    render();
+    yield* spawn(function*() {
+      for (const _ of yield* each(root)) {
+        render();
+        yield* each.next();
+      }
+    });
+
+    yield* events;
+  } finally {
+    stdout.write(tty.revert);
+  }
+});
diff --git a/packages/freedom-react/examples/use-input.ts b/packages/freedom-react/examples/use-input.ts
new file mode 100644
index 0000000..a2bd010
--- /dev/null
+++ b/packages/freedom-react/examples/use-input.ts
@@ -0,0 +1,66 @@
+import {
+  call,
+  createChannel,
+  each,
+  type Operation,
+  race,
+  resource,
+  sleep,
+  spawn,
+  type Stream,
+  suspend,
+  until,
+} from "effection";
+import { createInput, type InputEvent, type InputOptions } from "@bomb.sh/tty";
+
+function nothing() {
+  return suspend() as unknown as Operation<
+    IteratorResult<Uint8Array, void>
+  >;
+}
+
+// Parse a raw byte Stream into a Stream of decoded terminal InputEvents.
+export function useInput(
+  stream: Stream<Uint8Array, void>,
+  options?: InputOptions,
+): Stream<InputEvent, void> {
+  return resource(function* (provide) {
+    const input = yield* until(createInput(options));
+    const subscription = yield* stream;
+
+    let pending = nothing();
+
+    const events = createChannel<InputEvent, void>();
+
+    yield* spawn(function* () {
+      let next = yield* subscription.next();
+      while (!next.done) {
+        const result = input.scan(next.value);
+        pending = result.pending ? rescan(result.pending.delay) : nothing();
+        for (const event of result.events) {
+          yield* events.send(event);
+        }
+        next = yield* race([subscription.next(), pending]);
+      }
+      yield* events.close();
+    });
+
+    yield* race([provide(yield* events), drain(events)]);
+  });
+}
+
+function rescan(delay: number): ReturnType<typeof nothing> {
+  return call(function* (): Operation<IteratorResult<Uint8Array, void>> {
+    yield* sleep(delay);
+    return {
+      done: false,
+      value: new Uint8Array(),
+    };
+  });
+}
+
+function* drain<T, TClose>(stream: Stream<T, TClose>): Operation<void> {
+  for (const _ of yield* each(stream)) {
+    yield* each.next();
+  }
+}
diff --git a/packages/freedom-react/examples/use-stdin.ts b/packages/freedom-react/examples/use-stdin.ts
new file mode 100644
index 0000000..eb2c9ca
--- /dev/null
+++ b/packages/freedom-react/examples/use-stdin.ts
@@ -0,0 +1,37 @@
+import {
+  createChannel,
+  each,
+  type Operation,
+  race,
+  resource,
+  spawn,
+  type Stream,
+  until,
+} from "effection";
+import { stdin } from "node:process";
+
+// Bridge Node's process.stdin (raw bytes) into an Effection Stream.
+export function useStdin(): Operation<Stream<Uint8Array, void>> {
+  return resource(function* (provide) {
+    const channel = createChannel<Uint8Array, void>();
+
+    const iterator = stdin[Symbol.asyncIterator]();
+
+    yield* spawn(function* () {
+      let next = yield* until(iterator.next());
+      while (!next.done) {
+        yield* channel.send(next.value);
+        next = yield* until(iterator.next());
+      }
+      yield* channel.close();
+    });
+
+    yield* race([provide(channel), drain(channel)]);
+  });
+}
+
+function* drain<T, TClose>(stream: Stream<T, TClose>): Operation<void> {
+  for (const _ of yield* each(stream)) {
+    yield* each.next();
+  }
+}
diff --git a/packages/freedom-react/package.json b/packages/freedom-react/package.json
new file mode 100644
index 0000000..754cb81
--- /dev/null
+++ b/packages/freedom-react/package.json
@@ -0,0 +1,57 @@
+{
+	"name": "@bomb.sh/freedom-react",
+	"version": "0.0.0",
+	"private": true,
+	"license": "ISC",
+	"author": {
+		"name": "Bombshell",
+		"email": "oss@bomb.sh",
+		"url": "https://bomb.sh"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/bombshell-dev/playground.git",
+		"directory": "packages/freedom-react"
+	},
+	"type": "module",
+	"exports": {
+		".": {
+			"import": "./dist/index.mjs"
+		},
+		"./package.json": "./package.json"
+	},
+	"scripts": {
+		"dev": "bsh dev",
+		"build": "bsh build",
+		"format": "bsh format",
+		"lint": "bsh lint",
+		"test": "bsh test",
+		"counter": "tsx examples/counter.tsx"
+	},
+	"dependencies": {
+		"@bomb.sh/freedom": "workspace:*",
+		"@bomb.sh/tty": "latest",
+		"effection": "4.1.0-alpha.9",
+		"react": "^18.3.1",
+		"react-reconciler": "^0.29.2"
+	},
+	"devDependencies": {
+		"@bomb.sh/tools": "latest",
+		"@types/node": "^26.0.0",
+		"@types/react": "^18.3.12",
+		"@types/react-reconciler": "^0.28.9",
+		"tsx": "^4.19.2"
+	},
+	"devEngines": {
+		"packageManager": {
+			"name": "pnpm",
+			"version": "10.7.0",
+			"onFail": "error"
+		},
+		"runtime": {
+			"name": "node",
+			"version": "22.14.0",
+			"onFail": "error"
+		}
+	}
+}
diff --git a/packages/freedom-react/src/index.ts b/packages/freedom-react/src/index.ts
new file mode 100644
index 0000000..c24cb0a
--- /dev/null
+++ b/packages/freedom-react/src/index.ts
@@ -0,0 +1,230 @@
+// oxlint-disable bombshell-dev/no-generic-error
+// oxlint-disable max-params
+import ReactReconciler from 'react-reconciler';
+import { DefaultEventPriority, LegacyRoot } from 'react-reconciler/constants.js';
+import type { ReactNode } from 'react';
+import type { CreateChildOptions, JsonValue, Node } from '@bomb.sh/freedom';
+
+type Props = Record<string, unknown>;
+
+// A host element with this type owns its freedom node but NOT its children:
+// the reconciler refuses to reconcile them, leaving the subtree to a foreign
+// driver (another framework adapter, or an imperative freedom decorator). Grab
+// the node with a `ref` (getPublicInstance returns it) and drive it yourself.
+const FOREIGN = 'foreign';
+
+// react-reconciler builds instances detached (createInstance has no parent),
+// then wires them bottom-up. freedom nodes must be born from a parent, so an
+// Instance is a lightweight descriptor that holds the shape until its subtree
+// attaches to a real node — at which point `realize` creates the nodes top-down.
+interface Instance {
+	type: string;
+	props: Props;
+	node: Node | null;
+	kids: Child[];
+}
+
+interface TextInstance {
+	text: string;
+	node: Node | null;
+}
+
+type Child = Instance | TextInstance;
+
+function isText(child: Child): child is TextInstance {
+	return 'text' in child;
+}
+
+function realize(parent: Node, child: Child, before?: Node): void {
+	const options: CreateChildOptions | undefined = before ? { before } : undefined;
+	if (isText(child)) {
+		const node = parent.createChild('#text', options);
+		node.set('text', child.text);
+		child.node = node;
+		return;
+	}
+	const node = parent.createChild(child.type, options);
+	child.node = node;
+	apply(node, {}, child.props);
+	if (child.type !== FOREIGN) {
+		for (const kid of child.kids) {
+			realize(node, kid);
+		}
+	}
+}
+
+function apply(node: Node, prev: Props, next: Props): void {
+	for (const key of Object.keys(prev)) {
+		if (key !== 'children' && !(key in next)) {
+			node.unset(key);
+		}
+	}
+	for (const [key, value] of Object.entries(next)) {
+		if (key === 'children' || typeof value === 'function' || value === undefined) {
+			continue;
+		}
+		if (prev[key] !== value) {
+			node.set(key, value as JsonValue);
+		}
+	}
+}
+
+type Config = ReactReconciler.HostConfig<
+	string, // Type
+	Props, // Props
+	Node, // Container
+	Instance, // Instance
+	TextInstance, // TextInstance
+	never, // SuspenseInstance
+	never, // HydratableInstance
+	Node | null, // PublicInstance
+	null, // HostContext
+	true, // UpdatePayload
+	never, // ChildSet
+	ReturnType<typeof setTimeout>, // TimeoutHandle
+	-1 // NoTimeout
+>;
+
+const config: Config = {
+	supportsMutation: true,
+	supportsPersistence: false,
+	supportsHydration: false,
+	isPrimaryRenderer: true,
+	noTimeout: -1,
+	scheduleTimeout: setTimeout,
+	cancelTimeout: clearTimeout,
+
+	createInstance(type, props) {
+		return { type, props, node: null, kids: [] };
+	},
+	createTextInstance(text) {
+		return { text, node: null };
+	},
+	appendInitialChild(parent, child) {
+		parent.kids.push(child);
+	},
+	finalizeInitialChildren() {
+		return false;
+	},
+	shouldSetTextContent() {
+		return false;
+	},
+	prepareUpdate() {
+		return true;
+	},
+	getRootHostContext() {
+		return null;
+	},
+	getChildHostContext(parent) {
+		return parent;
+	},
+	getPublicInstance(instance) {
+		return instance.node;
+	},
+	prepareForCommit() {
+		return null;
+	},
+	resetAfterCommit() {},
+	preparePortalMount() {},
+	getCurrentEventPriority() {
+		return DefaultEventPriority;
+	},
+	getInstanceFromNode() {
+		return null;
+	},
+	beforeActiveInstanceBlur() {},
+	afterActiveInstanceBlur() {},
+	prepareScopeUpdate() {},
+	getInstanceFromScope() {
+		return null;
+	},
+	detachDeletedInstance() {},
+
+	appendChild(parent, child) {
+		parent.kids.push(child);
+		if (parent.node && parent.type !== FOREIGN && !child.node) {
+			realize(parent.node, child);
+		}
+	},
+	appendChildToContainer(container, child) {
+		realize(container, child);
+	},
+	insertBefore(parent, child, before) {
+		const at = parent.kids.indexOf(child);
+		if (at >= 0) {
+			parent.kids.splice(at, 1);
+		}
+		const mark = parent.kids.indexOf(before);
+		parent.kids.splice(mark < 0 ? parent.kids.length : mark, 0, child);
+		// Fresh insert positions correctly via createChild({ before }). Moving an
+		// already-realized child is not yet supported (needs a same-parent reorder
+		// op in freedom) — see the embedding notes.
+		if (parent.node && parent.type !== FOREIGN && !child.node) {
+			realize(parent.node, child, before.node ?? undefined);
+		}
+	},
+	insertInContainerBefore(container, child, before) {
+		if (!child.node) {
+			realize(container, child, before.node ?? undefined);
+		}
+	},
+	removeChild(parent, child) {
+		const at = parent.kids.indexOf(child);
+		if (at >= 0) {
+			parent.kids.splice(at, 1);
+		}
+		void child.node?.remove();
+		child.node = null;
+	},
+	removeChildFromContainer(_container, child) {
+		void child.node?.remove();
+		child.node = null;
+	},
+	resetTextContent() {},
+	commitTextUpdate(textInstance, _old, text) {
+		textInstance.node?.set('text', text);
+	},
+	commitUpdate(instance, _payload, _type, prev, next) {
+		if (instance.node) {
+			apply(instance.node, prev, next);
+		}
+	},
+	hideInstance(instance) {
+		instance.node?.set('hidden', true);
+	},
+	hideTextInstance() {},
+	unhideInstance(instance) {
+		instance.node?.unset('hidden');
+	},
+	unhideTextInstance() {},
+	clearContainer(container) {
+		for (const child of Array.from(container.children)) {
+			void child.remove();
+		}
+	},
+};
+
+const reconciler = ReactReconciler(config);
+
+export type Mount = ReturnType<typeof reconciler.createContainer>;
+
+/**
+ * Drive `node`'s children with a React element tree. Uses a legacy
+ * (synchronous) root, so the freedom tree is fully built when `mount` returns.
+ */
+export function mount(element: ReactNode, node: Node): Mount {
+	const container = reconciler.createContainer(
+		node,
+		LegacyRoot,
+		null,
+		false,
+		null,
+		'',
+		(error) => {
+			throw error;
+		},
+		null,
+	);
+	reconciler.updateContainer(element, container, null, null);
+	return container;
+}
diff --git a/packages/freedom-react/test/mount.test.ts b/packages/freedom-react/test/mount.test.ts
new file mode 100644
index 0000000..5cbc206
--- /dev/null
+++ b/packages/freedom-react/test/mount.test.ts
@@ -0,0 +1,120 @@
+import { createElement as h, type ReactNode, useState } from 'react';
+import { createRoot, type Node } from '@bomb.sh/freedom';
+import { mount } from '../src/index.ts';
+import { describe, expect, it } from './suite.ts';
+
+function kids(node: Node): Node[] {
+	return [...node.children];
+}
+
+describe('mount', () => {
+	it('builds a freedom subtree under the node', () => {
+		const root = createRoot();
+		mount(h('box', { color: 'red' }, h('label', { value: 'hi' })), root.node);
+
+		const [box] = kids(root.node);
+		expect(box.name).toEqual('box');
+		expect(box.props['color']).toEqual('red');
+
+		const [label] = kids(box);
+		expect(label.name).toEqual('label');
+		expect(label.props['value']).toEqual('hi');
+
+		root.destroy();
+	});
+
+	it('renders text children as #text nodes', () => {
+		const root = createRoot();
+		mount(h('label', null, 'hello'), root.node);
+
+		const [label] = kids(root.node);
+		const [text] = kids(label);
+		expect(text.name).toEqual('#text');
+		expect(text.props['text']).toEqual('hello');
+
+		root.destroy();
+	});
+
+	it('skips function and undefined props', () => {
+		const root = createRoot();
+		mount(h('box', { onClick: () => {}, missing: undefined, n: 1 }), root.node);
+
+		const [box] = kids(root.node);
+		expect('onClick' in box.props).toBe(false);
+		expect('missing' in box.props).toBe(false);
+		expect(box.props['n']).toEqual(1);
+
+		root.destroy();
+	});
+
+	it('does not reconcile children of a <foreign> node', () => {
+		const root = createRoot();
+		mount(h('foreign', null, h('box'), h('box')), root.node);
+
+		const [foreign] = kids(root.node);
+		expect(foreign.name).toEqual('foreign');
+		expect(kids(foreign).length).toEqual(0);
+
+		root.destroy();
+	});
+
+	it('updates props on state change', () => {
+		const root = createRoot();
+
+		let set: (n: number) => void = () => {};
+		function App(): ReactNode {
+			const [n, setN] = useState(0);
+			set = setN;
+			return h('box', { n });
+		}
+
+		mount(h(App), root.node);
+		const [box] = kids(root.node);
+		expect(box.props['n']).toEqual(0);
+
+		set(5);
+		expect(box.props['n']).toEqual(5);
+
+		root.destroy();
+	});
+
+	it('inserts a new child before a sibling', () => {
+		const root = createRoot();
+
+		let set: (items: string[]) => void = () => {};
+		function App(): ReactNode {
+			const [items, setItems] = useState(['a', 'c']);
+			set = setItems;
+			return h('box', null, ...items.map((k) => h('item', { key: k, value: k })));
+		}
+
+		mount(h(App), root.node);
+		const [box] = kids(root.node);
+		expect(kids(box).map((c) => c.props['value'])).toEqual(['a', 'c']);
+
+		set(['a', 'b', 'c']);
+		expect(kids(box).map((c) => c.props['value'])).toEqual(['a', 'b', 'c']);
+
+		root.destroy();
+	});
+
+	it('removes a child', () => {
+		const root = createRoot();
+
+		let set: (items: string[]) => void = () => {};
+		function App(): ReactNode {
+			const [items, setItems] = useState(['a', 'b']);
+			set = setItems;
+			return h('box', null, ...items.map((k) => h('item', { key: k, value: k })));
+		}
+
+		mount(h(App), root.node);
+		const [box] = kids(root.node);
+		expect(kids(box).map((c) => c.props['value'])).toEqual(['a', 'b']);
+
+		set(['a']);
+		expect(kids(box).map((c) => c.props['value'])).toEqual(['a']);
+
+		root.destroy();
+	});
+});
diff --git a/packages/freedom-react/test/suite.ts b/packages/freedom-react/test/suite.ts
new file mode 100644
index 0000000..8051944
--- /dev/null
+++ b/packages/freedom-react/test/suite.ts
@@ -0,0 +1 @@
+export { afterEach, beforeEach, describe, expect, it } from 'vitest';
diff --git a/packages/freedom-react/tsconfig.json b/packages/freedom-react/tsconfig.json
new file mode 100644
index 0000000..369caac
--- /dev/null
+++ b/packages/freedom-react/tsconfig.json
@@ -0,0 +1,6 @@
+{
+	"extends": ["@bomb.sh/tools/tsconfig.json"],
+	"compilerOptions": {
+		"jsx": "react-jsx"
+	}
+}
diff --git a/packages/freedom/AGENTS.md b/packages/freedom/AGENTS.md
new file mode 100644
index 0000000..9a39f2f
--- /dev/null
+++ b/packages/freedom/AGENTS.md
@@ -0,0 +1,56 @@
+# AGENTS.md
+
+## Spec-driven development
+
+- Specs in `specs/` are the source of truth. Code conforms to specs, not the
+  other way around.
+
+- Never add, remove, or change a public API (interfaces, operations, context
+  APIs) in code without first updating the relevant spec and getting explicit
+  approval from the user. This includes changes to `Node`, `Tree`, `FreedomApi`,
+  `DispatchApi`, `FocusApi`, and any future spec'd interfaces.
+
+- The workflow is: propose the spec change, wait for approval, then implement.
+  Do not combine spec changes with implementation in a single step.
+
+## Effection patterns
+
+- Never use `sleep(0)` for synchronization. If you need to coordinate between
+  tasks, use `withResolvers()` from Effection.
+
+- Structured concurrency handles cleanup. Do not add explicit "alive" guards,
+  flags, or checks for whether a scope has been destroyed. When a scope exits,
+  its signals are inert and its tasks are halted.
+
+- Do not reimplement middleware. If the spec says `createApi`, use `createApi`
+  and its `around()` method. Do not maintain a parallel list of handlers.
+
+- When delegating `[Symbol.iterator]`, bind directly:
+  `[Symbol.iterator]: source[Symbol.iterator]` — not a wrapper generator.
+
+- Effection methods are pre-bound. Do not use `.bind()` when assigning them —
+  just assign directly: `child.remove = task.halt`.
+
+## Naming conventions
+
+- API interfaces are named for the domain: `Freedom`, `Dispatch`.
+- API constants are the interface name suffixed with `Api`: `FreedomApi`,
+  `DispatchApi`.
+- Always export both the interface and the API constant.
+- Effection resources use the `useX()` naming convention, not `createX()`. For
+  example: `useTree()`, not `createTree()`.
+
+## State
+
+- Do not use module-level mutable state (counters, maps, etc.). Scope state to
+  the resource or tree that owns it.
+
+## Testing
+
+- Tests should not need to know internal IDs. If a test needs a node reference,
+  get it from the tree structure or from the return value of `append`.
+- Use `node.eval()` to run operations in a node's scope from tests. Do not rely
+  on component bodies having run by the time `createTree` returns.
+- Each test file tests exactly one spec. `freedom.test.ts` tests
+  `freedom-spec.md`. `focus.test.ts` tests `freedom-focus-spec.md`. Do not put
+  tests for one spec into another spec's test file.
diff --git a/packages/freedom/package.json b/packages/freedom/package.json
new file mode 100644
index 0000000..fdf75a2
--- /dev/null
+++ b/packages/freedom/package.json
@@ -0,0 +1,50 @@
+{
+    "name": "@bomb.sh/freedom",
+    "version": "0.0.0",
+    "private": true,
+    "type": "module",
+    "license": "ISC",
+    "author": {
+        "name": "Bombshell",
+        "email": "oss@bomb.sh",
+        "url": "https://bomb.sh"
+    },
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.mts",
+            "import": "./dist/index.mjs"
+        },
+        "./package.json": "./package.json"
+    },
+    "scripts": {
+        "dev": "bsh dev --dts",
+        "build": "bsh build --dts",
+        "format": "bsh format",
+        "lint": "bsh lint",
+        "test": "bsh test"
+    },
+    "dependencies": {
+        "effection": "4.1.0-alpha.9"
+    },
+    "devDependencies": {
+        "@bomb.sh/tools": "latest",
+        "@types/node": "^26.0.0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/bombshell-dev/playground.git",
+        "directory": "packages/freedom"
+    },
+    "devEngines": {
+        "runtime": {
+            "name": "node",
+            "version": "22.14.0",
+            "onFail": "error"
+        },
+        "packageManager": {
+            "name": "pnpm",
+            "version": "10.7.0",
+            "onFail": "error"
+        }
+    }
+}
diff --git a/packages/freedom/research/focus.md b/packages/freedom/research/focus.md
new file mode 100644
index 0000000..d5073e8
--- /dev/null
+++ b/packages/freedom/research/focus.md
@@ -0,0 +1,289 @@
+# Focus Management Systems: Research Summary
+
+## Universal Principles
+
+Across web, TUI, game UI, and mobile paradigms, focus management converges on:
+
+1. **Focus is always a singleton.** Exactly one node receives input at any time.
+2. **Two levels of navigation.** Nearly every system distinguishes _between
+   groups_ (Tab) from _within groups_ (arrows).
+3. **Scoping enables composition.** Without focus scopes, every focusable
+   element competes in a single flat order. Scopes let subtrees manage focus
+   independently (dialogs, menus, panels).
+4. **Restoration is universally needed.** When a focus scope closes (modal
+   dismiss, node removal), every system needs a strategy for where focus goes.
+   Dominant pattern: remember what was focused before the scope activated.
+5. **Focus lifecycle is tightly coupled to component lifecycle.** When a focused
+   node unmounts, focus must move somewhere — this is a source of bugs in every
+   framework.
+
+---
+
+## Web/DOM Focus Management
+
+### Native Focus Model (WHATWG HTML Spec)
+
+**Focusable Areas**: Regions that can receive keyboard input — elements with
+non-null tabindex, natively focusable elements (buttons, inputs, links), image
+map shapes, scrollable regions, and document viewports.
+
+**Tabindex Processing Model**:
+
+- Null/omitted: UA determines focusability per platform conventions
+- Negative integer: Programmatically focusable via `.focus()` but excluded from
+  sequential tab navigation
+- Zero: Focusable and sequentially navigable; position follows DOM tree order
+- Positive integer: Creates explicit ordering (discouraged by spec)
+
+**Focus Navigation Scopes**: Each Document, shadow host, slot element, and
+showing popover is a scope owner. The flattened tabindex-ordered focus
+navigation scope is computed by recursively inlining child scope contents after
+their scope owners.
+
+**Shadow DOM**: Shadow hosts are scope owners. `delegatesFocus: true` delegates
+focus to the first focusable descendant.
+
+**Focus Events**: `focus`/`blur` do not bubble. `focusin`/`focusout` do bubble.
+Events fire along the focus chain.
+
+**Focus Navigation Start Point** (per Sarah Higley): When a focused element is
+removed from the DOM, browsers maintain a "sequential focus navigation starting
+point" at the removed element's former position. Screen readers largely ignore
+this mechanism.
+
+### ARIA Focus Management Patterns (W3C APG)
+
+**Roving Tabindex**: Manages focus in composite widgets (radio groups, tablists,
+toolbars, trees, grids):
+
+1. Set `tabindex="0"` on active element, `tabindex="-1"` on siblings
+2. On arrow key: old element → `-1`, new element → `0`, call `.focus()`
+3. Browser automatically scrolls newly focused element into view
+
+**aria-activedescendant**: Keeps DOM focus on container while logically pointing
+to active child. Critical limitations (per Sarah Higley):
+
+- Purely a screen reader construct; no effect on keyboard events or DOM focus
+- No automatic scroll-into-view
+- VoiceOver Safari macOS essentially ignores it
+- Mobile screen readers bypass it entirely
+- Best suited for comboboxes only
+
+**Focus traps** (modals/dialogs): Intercept Tab at boundaries and wrap. Requires
+initial focus, wrapping Tab/Shift+Tab at boundaries, and focus restoration on
+close.
+
+### Open UI `focusgroup` Proposal
+
+The most ambitious standardization attempt:
+
+- Arrow-key navigation within a declared subtree, guaranteed tab stop, automatic
+  last-focused memory
+- Crosses shadow DOM boundaries by default; `focusgroup=none` opts out
+- **Independence principle**: Nested `focusgroup` exits ancestor's group; each
+  element belongs to exactly one focusgroup
+- Values: empty (linear), `grid`, `manual-grid`, `none`
+- Modifiers: `inline`/`block` (direction), `wrap`/`flow` (boundary), `no-memory`
+- Grid navigation: `row-wrap`, `col-wrap`, `row-flow`, `col-flow`
+
+---
+
+## React Focus Management
+
+### React Aria FocusScope (Adobe)
+
+Three declarative props:
+
+- **`contain`**: Prevents focus from leaving scope; Tab wraps at boundaries
+- **`restoreFocus`**: Stores `document.activeElement` on mount; restores on
+  unmount
+- **`autoFocus`**: Focuses first focusable descendant on mount
+
+`useFocusManager()` hook: `focusNext({wrap})`, `focusPrevious({wrap})`,
+`focusFirst()`, `focusLast()`.
+
+Implementation uses sentinel nodes as boundary markers in the DOM.
+
+### react-focus-lock (theKashey)
+
+- **No keyboard event interception**: Watches focus behavior via `focus` events,
+  not `keydown`
+- `data-focus-lock=[group-name]` for scattered focus groups/shards (critical for
+  portals)
+- Core `focus-lock` package is 1.5kb
+
+### Radix UI FocusScope
+
+- Tab interception only at boundaries (native browser handles mid-scope)
+- `TreeWalker`-based element discovery
+- Container gets `tabIndex={-1}` as fallback
+- Focus scope stack: parent paused when child activates, resumes on child
+  unmount
+
+### React Issue #16009 — Rethinking Focus
+
+- Collecting focusable elements is O(n), measured at 850ms on Android Chrome
+- Proposed ID-based focus with propagating lookups through nested scopes
+- Cross-platform abstraction independent of DOM
+
+---
+
+## Terminal/TUI Focus Management
+
+### Textual (Python) — Most Complete TUI System
+
+- **Opt-in**: `can_focus` (default `False`) and `can_focus_children` (default
+  `True`)
+- **Focus chain**: Computed ordered list of all focusable widgets; Tab/Shift+Tab
+  traverse it
+- **`can_focus_children=False`**: Skips children during Tab navigation
+  (primitive containment)
+- **Programmatic**: `focus_next()`, `focus_previous()`, `widget.focus()`,
+  `set_focus()`
+- **Events**: `Focus`, `Blur`, `DescendantFocus`, `DescendantBlur`
+- **CSS**: `:focus` pseudo-class, `has_focus_within` property
+- **Scroll**: `focus(scroll_visible=True)`
+
+### Ink (React for terminals)
+
+- `useFocus()` hook makes component focusable; returns `{isFocused}`
+- `useFocusManager()`: `focusNext()`, `focusPrevious()`, `focus(id)`
+- Focus order follows render order
+- No focus scoping — focus is global
+
+### Bubble Tea (Go)
+
+- Terminal-level only: `FocusMsg`/`BlurMsg` for window focus
+- Component focus is entirely DIY via `focusIndex` integer
+- Community `bubbletea-nav`: flat `FocusManager` with Tab/Shift+Tab
+
+### Ratatui (Rust)
+
+- No built-in focus; community crates: `rat-focus` (FocusFlag + FocusBuilder),
+  `ratatui-interact` (FocusManager), `focusable` (derive macro)
+
+### Common TUI Pattern
+
+All converge on: flat ordered list of focusable widgets, Tab/Shift+Tab
+navigation. None have built-in focus scoping or containment. Focus ordering is
+explicit (manual index) or render/mount order.
+
+---
+
+## Game UI / Spatial Focus
+
+### Unity UI Navigation
+
+Four modes per `Selectable`:
+
+- **Automatic**: Spatial proximity-based neighbor computation
+- **Explicit**: Manual `selectOnUp/Down/Left/Right` per element
+- **Horizontal/Vertical**: Navigation restricted to one axis
+- **None**: Disables navigation
+
+### ImGui Navigation
+
+Directional algorithm: collect navigable items, score by distance + direction
+alignment, select lowest score. Two NavLayers (Main, Menu). Window-level focus
+with cross-window navigation support.
+
+### Microsoft WinUI/UWP 2D Navigation
+
+**XYFocusKeyboardNavigation**: `Auto`, `Enabled`, `Disabled` — creates
+directional areas.
+
+Three strategies:
+
+1. **Projection**: Projects focused element's edge in navigation direction
+2. **NavigationDirectionDistance**: Extends bounding rect, finds closest to
+   navigation axis
+3. **RectilinearDistance**: Manhattan distance scoring
+
+**TabFocusNavigation**: `Local` (subtree tab indexes), `Once` (group tab stop),
+`Cycle` (wrap within container).
+
+### SwiftUI Focus System
+
+- `@FocusState`: Property wrapper tracking focus (Boolean or Hashable enum)
+- `.focused($state, equals:)`: Binds view focus to state variable
+- `.defaultFocus()`: Initial focus target when scope appears
+- `.focusSection()`: Groups views for directional navigation without making
+  section focusable
+
+---
+
+## Focus Ordering Strategies
+
+| Strategy            | Description                                   | Used By                             |
+| ------------------- | --------------------------------------------- | ----------------------------------- |
+| DOM/tree order      | Source order in document/tree                 | HTML default, Ink, Textual          |
+| Explicit tab order  | Numeric index overrides tree order            | HTML `tabindex`, WinUI              |
+| Roving within group | Arrows within group, Tab between groups       | ARIA composites, `focusgroup`       |
+| Spatial/directional | Nearest element in pressed direction          | WinUI, Unity, ImGui, tvOS           |
+| Scope-local         | Tab order computed within scope               | HTML focus scopes, WinUI `Local`    |
+| Cycle/wrap          | Focus wraps at boundaries                     | WinUI `Cycle`, FocusScope `contain` |
+| Once (group stop)   | Container is single Tab stop; arrows internal | WinUI `Once`, ARIA composites       |
+| Render order        | Component render/mount order                  | Ink, Bubble Tea                     |
+| Custom/programmatic | Application logic determines order            | All frameworks                      |
+
+---
+
+## Focus Scoping Comparison
+
+| System               | Scoping Mechanism           | Containment              | Restoration            | Nesting                     |
+| -------------------- | --------------------------- | ------------------------ | ---------------------- | --------------------------- |
+| DOM/HTML             | Focus navigation scopes     | No built-in trap         | No built-in            | Hierarchical via shadow DOM |
+| Open UI `focusgroup` | `focusgroup` attribute      | Independent groups       | Last-focused memory    | Nested auto-exits parent    |
+| React Aria           | `<FocusScope>`              | `contain` prop           | `restoreFocus` prop    | Parent paused               |
+| Radix                | `<FocusScope>`              | `loop` prop              | Stores `activeElement` | Focus scope stack           |
+| react-focus-lock     | `data-focus-lock`           | Focus observation        | `returnFocus` prop     | Focus shards                |
+| WinUI/UWP            | `XYFocusKeyboardNavigation` | `Cycle` mode             | No built-in            | Inheritance                 |
+| SwiftUI              | `@FocusState` + sections    | Sections guide direction | `.defaultFocus()`      | Nestable                    |
+| Textual              | `can_focus_children=False`  | Prevents Tab entry       | No built-in            | Widget tree                 |
+| ImGui                | Window flags, modals        | Modal windows            | No built-in            | NavLayer                    |
+
+---
+
+## Focus and Lifecycle
+
+### Focused Component Unmount
+
+- **DOM**: `document.activeElement` falls back to `<body>`; navigation start
+  point remembered
+- **React**: `onBlur` does not fire on parent when React unmounts focused child
+- **React Aria**: `restoreFocus` stores previous element, restores on unmount
+- **Radix**: Stores `activeElement` before activation, restores on unmount
+- **Textual**: `blur()` moves focus to next available widget
+
+### Focus Side Effects
+
+- **Scroll into view**: Browser auto-scrolls on `.focus()` and roving tabindex;
+  NOT on `aria-activedescendant`
+- **Screen reader**: Focus changes trigger announcement of focused element's
+  name and role
+- **Focus visible**: `:focus-visible` distinguishes keyboard from mouse/touch
+  focus
+
+---
+
+## Sources
+
+- [WHATWG HTML - The tabindex attribute](https://html.spec.whatwg.org/multipage/interaction.html)
+- [W3C APG - Keyboard Interface](https://www.w3.org/WAI/ARIA/apg/practices/keyboard-interface/)
+- [Open UI focusgroup Explainer](https://open-ui.org/components/focusgroup.explainer/)
+- [React Aria FocusScope](https://react-aria.adobe.com/FocusScope)
+- [React Focus Management RFC](https://github.com/devongovett/rfcs-1/blob/patch-1/text/2019-focus-management.md)
+- [React Issue #16009](https://github.com/facebook/react/issues/16009)
+- [react-focus-lock](https://github.com/theKashey/react-focus-lock)
+- [Radix UI FocusScope](https://www.npmjs.com/package/@radix-ui/react-focus-scope)
+- [Sarah Higley - aria-activedescendant](https://sarahmhigley.com/writing/activedescendant/)
+- [Sarah Higley - Focus navigation start point](https://sarahmhigley.com/writing/focus-navigation-start-point/)
+- [Textual Input Guide](https://textual.textualize.io/guide/input/)
+- [Ink](https://github.com/vadimdemedes/ink)
+- [Bubble Tea](https://github.com/charmbracelet/bubbletea)
+- [ImGui Navigation](https://deepwiki.com/ocornut/imgui/2.6-input-and-navigation)
+- [WinUI Focus Navigation](https://learn.microsoft.com/en-us/windows/apps/design/input/focus-navigation)
+- [Unity UI Navigation](https://learn.unity.com/tutorial/ui-navigation-2019-3)
+- [WICG CSS Spatial Navigation](https://github.com/WICG/spatial-navigation)
+- [SwiftUI Focus - WWDC23](https://developer.apple.com/videos/play/wwdc2023/10162/)
+- [Cloudscape Focus Principles](https://cloudscape.design/foundation/core-principles/accessibility/focus-management-principles/)
diff --git a/packages/freedom/specs/freedom-focus-spec.md b/packages/freedom/specs/freedom-focus-spec.md
new file mode 100644
index 0000000..210bc2b
--- /dev/null
+++ b/packages/freedom/specs/freedom-focus-spec.md
@@ -0,0 +1,482 @@
+# Freedom Focus Specification
+
+**Version:** 0.1 — Draft\
+**Status:** Normative draft\
+**Depends on:** Freedom Specification 0.1, Effection 4.1-alpha
+
+---
+
+## 1. Purpose
+
+Focus tracks which node in the tree is currently receiving input. At any point
+in time at most one node is focused; while at least one focusable node exists,
+exactly one is. The focus system provides structured,
+linear navigation through focusable nodes and exposes focus state as an
+observable node property.
+
+Focus is an extension to Freedom, not a core primitive. It is installed by the
+root component and built entirely on Freedom's context APIs — property
+operations, middleware interception, and scoped evaluation.
+
+---
+
+## 2. Design Philosophy
+
+### 2.1 Minimal and linear
+
+This specification covers linear focus navigation only: forward, backward, and
+explicit. Directional navigation (up/down/left/right), focus groups, focus
+trapping, and focus restoration are deferred to future extensions.
+
+### 2.2 Opt-in focusability
+
+Nodes are not focusable by default. A node becomes focusable by calling
+`yield* focusable()` in its component body. This sets the `focused` property to
+`false`, adding the node to the focus chain without granting it focus.
+
+### 2.3 Observable via properties
+
+Focus state is a regular node property: `node.props.focused`. Renderers observe
+focus the same way they observe any other property — by reading props after a
+notification. No special subscription mechanism is needed.
+
+### 2.4 Built on Freedom APIs
+
+Focus operations are **synchronous functions** that take a node and use the
+node's synchronous methods. Focus movement calls `node.set("focused", …)`
+directly. Focus cleanup installs a synchronous interceptor on `remove` via
+`node.scope.around(NodeApi, …)`. No internal state is accessed directly.
+
+---
+
+## 3. Terminology
+
+**Focusable node.** A node whose property bag contains the key `"focused"`. The
+value is `true` (this node has focus) or `false` (this node can receive focus
+but does not currently have it). A node without a `"focused"` property is not
+focusable.
+
+**Focused node.** The unique node whose `focused` property is `true`. When the
+focus system is installed and the container has at least one focusable
+descendant, exactly one node is focused. With no focusable descendants, no node
+is focused and `current()` falls back to the container (§4.2 F17).
+
+**Focus chain.** The ordered sequence of all focusable nodes in the tree,
+computed by depth-first traversal. The focus chain determines the order in which
+`advance` and `retreat` move focus. The chain is computed on demand — it is not
+stored.
+
+---
+
+## 4. Focus API
+
+### 4.1 API Definition
+
+Focus is a set of **synchronous functions** that take a `Node` (used to locate
+the tree root), plus `useFocus` to install it:
+
+```
+focusable(node: Node): void
+advance(node: Node): void
+retreat(node: Node): void
+focus(target: Node): void
+current(node: Node): Node
+useFocus(node: Node): void
+focusPush(node: Node, callback?: (value: unknown) => void): PopFocus
+```
+
+where `PopFocus = (value?: unknown) => void` is the bound pop function returned
+by `focusPush` (§12).
+
+These are plain functions (not `createApi` operations) and are not
+middleware-interceptable in this version; focus trapping and the like remain
+deferred (§9). Focus movement is performed with `node.set("focused", …)`.
+
+### 4.2 Operations
+
+**focusable**
+
+F1. `focusable()` makes the current node focusable by setting its `focused`
+property to `false` via `yield* set("focused", false)`.
+
+F2. If the current node is already focusable (the `focused` property already
+exists), `focusable()` is a no-op.
+
+F3. `focusable()` is a `createApi` operation and can be intercepted by
+middleware. A parent MAY install middleware on `focusable` to prevent a child
+from becoming focusable.
+
+**advance**
+
+F4. `advance()` moves focus to the next focusable node in the focus chain (§5).
+
+F5. If the currently focused node is the last in the focus chain, `advance()`
+wraps to the first focusable node.
+
+F6. Focus movement sets the old node's `focused` property to `false` and the new
+node's `focused` property to `true`, using `node.eval()` to run property
+operations in each node's scope (§6.2).
+
+F7. If the focus chain contains only one focusable node (including root),
+`advance()` is a no-op.
+
+**retreat**
+
+F8. `retreat()` moves focus to the previous focusable node in the focus chain
+(§5).
+
+F9. If the currently focused node is the first in the focus chain, `retreat()`
+wraps to the last focusable node.
+
+F10. Focus movement follows the same mechanism as `advance` (F6).
+
+F11. If the focus chain contains only one focusable node, `retreat()` is a
+no-op.
+
+**focus**
+
+F12. `focus(node)` sets focus to the given node explicitly.
+
+F13. The target node MUST be a member of the active focus chain (§12.3): it MUST
+be focusable (its `focused` property MUST exist) **and** a descendant of the
+active focus root. `focus` MUST raise an error for a target that is not
+focusable, or that is focusable but lies outside the active focus root (§12.6,
+FS12).
+
+F14. Focus movement follows the same mechanism as `advance` (F6).
+
+F15. If the target node is already focused, `focus()` is a no-op.
+
+**current**
+
+F16. `current()` returns the currently focused node — the node whose `focused`
+property is `true`.
+
+F17. `current()` always returns a `Node`. It never returns `undefined`: it
+returns the focused node, or — when no node is focused — falls back to the
+active focus root (§12.3, which is the tree root when the focus stack is empty).
+Never-null is guaranteed by the fallback, not by making the container a member
+of the focus chain.
+
+F18. `current()` is a `createApi` operation and can be intercepted by
+middleware. This enables future extensions (e.g., focus scoping) to override
+which node is considered "current" within a subtree.
+
+### 4.3 Middleware Interception
+
+F19. Because `focusable`, `advance`, `retreat`, `focus`, and `current` are
+`createApi` operations, they can be intercepted by middleware installed in
+ancestor scopes.
+
+F20. A parent component MAY install middleware on `freedom:focus` to redirect
+focus, prevent focus changes, or add side effects (e.g., scroll-into-view).
+
+---
+
+## 5. Focus Chain
+
+### 5.1 Computation
+
+FC1. The focus chain is the ordered sequence of all focusable nodes in the
+subtree of the **active focus root** (§12.3), determined by a depth-first
+traversal starting from that root. When the focus stack is empty the active
+focus root is the tree root, so the chain spans the whole tree; when a node has
+been pushed (§12.4) the chain is confined to that node's subtree.
+
+FC2. A node is included in the focus chain if and only if its property bag
+contains the key `"focused"` (with value `true` or `false`).
+
+FC3. The traversal visits children in their iteration order (`node.children`),
+which respects any active sort function (§5.6 of the Freedom spec). This means a
+parent's sort function affects focus order.
+
+FC4. The focus chain is computed on demand — when `advance`, `retreat`, or
+`current` needs it. It is not stored or cached. This ensures the chain is always
+consistent with the current tree state.
+
+### 5.2 Dynamic behavior
+
+FC5. The focus chain changes dynamically as nodes become focusable
+(`focusable()`), are removed (`remove`), or are reordered (sort function
+changes).
+
+FC6. Adding a new focusable node does not move focus. The new node joins the
+chain at its tree-order position with `focused: false`.
+
+FC7. Changing a parent's sort function may reorder the focus chain. Focus does
+not move — the focused node retains `focused: true` regardless of its new
+position in the chain.
+
+---
+
+## 6. Focus Lifecycle
+
+### 6.1 Installation
+
+FL1. Focus is installed by calling `useFocus(root.node)`:
+
+    ```ts
+    const root = createRoot();
+    useFocus(root.node);
+    ```
+
+FL2. `useFocus(node)` performs two actions: 1. Seeds initial focus on the first
+focusable descendant in chain order (§5), if any. The container node itself is
+not focused and is not added to the focus chain. If there are no focusable
+descendants, nothing is focused and `current()` falls back to the container. 2.
+Installs a synchronous `remove` interceptor on the node's scope
+(`node.scope.around(NodeApi, …)`) to handle focused-node removal (§6.3). Because
+it is installed on the node's scope, the interceptor applies to all descendants.
+
+FL3. Seeding is one-shot: it happens only at the `useFocus` call. A focusable
+descendant added later does not become focused automatically. Maintaining "one
+focused descendant whenever any focusable descendant exists" is deferred to the
+focus-container extension (§9).
+
+### 6.2 Focus movement
+
+FL4. When focus moves from node A to node B, the focus system calls
+`A.set("focused", false)` and `B.set("focused", true)` — synchronous mutations.
+
+FL5. Both changes go through `NodeApi`. Interceptors on `set` see focus changes
+and may react to or redirect them.
+
+FL6. Both changes mark the tree dirty; they coalesce into a single notification
+if they occur within the same dispatch cycle.
+
+### 6.3 Focused node removal
+
+FL7. `useFocus` installs a synchronous `remove` interceptor that, when the node
+being removed is focused, moves focus to its successor before teardown:
+
+    ```ts
+    node.scope.around(NodeApi, {
+      remove([target], next) {
+        if (target.props.focused === true) {
+          const successor = successorOf(target);
+          if (successor && successor !== target) focus(successor);
+        }
+        return next(target);
+      },
+    });
+    ```
+
+FL8. If the removed node is the only focusable node, there is no successor; after
+removal nothing is focused and `current()` falls back to the container.
+(Removing root is an error, C-rm3.)
+
+FL9. The successor is focused before `next(target)` tears the node down, so focus
+never lands on a destroyed node.
+
+---
+
+## 7. Interaction with Notification
+
+FN1. Focus changes are property changes. They flow through Freedom's existing
+notification system — no special notification mechanism is needed.
+
+FN2. When focus moves during a dispatch cycle (e.g., in response to a keypress),
+the focus property changes coalesce with other property changes into a single
+notification.
+
+FN3. When focus moves outside a dispatch cycle (e.g., during component
+initialization via `useFocus()`), the property change emits its own notification
+per Freedom's existing rules (T11).
+
+FN4. Renderers observe focus by reading `node.props.focused` after a
+notification, the same way they read any other property.
+
+---
+
+## 8. Invariants
+
+FI1. **Singleton focus.** At most one node in the tree has `focused: true` at
+any time. When the focus system is installed and at least one focusable
+descendant exists, exactly one node has `focused: true`; with no focusable
+descendants, none does.
+
+FI2. **Focus chain consistency.** The focus chain is always derivable from the
+current tree state by depth-first traversal. No external data structure is
+needed.
+
+FI3. **The active focus root is a non-participating container.** By default the
+root node is not enrolled in the focus chain (it has no `focused` property), so
+`advance`/`retreat` ring only over its focusable descendants — root is never a
+focus stop. Root serves as the last-resort focus target through `current()`'s
+fallback, not through chain membership. Escape hatch: explicitly calling
+`focusable(root)` enrolls root into the ring like any other node. The focus
+stack (§12) generalizes this: at any time the active focus root — the top of the
+stack, or the tree root when the stack is empty — is the non-participating
+container the ring is confined to.
+
+FI4. **Cleanup on removal.** When a focused node is removed, focus advances to
+the next node in the chain before the node is destroyed. This is guaranteed by
+middleware on `remove`.
+
+FI5. **API consistency.** All focus operations go through `createApi` and are
+middleware-interceptable. Focus movement uses `node.eval()` and the
+`freedom:node` context API for property changes.
+
+---
+
+## 9. Deferred Extensions
+
+The following are explicitly out of scope for this version.
+
+### 9.1 Focus Trapping and Locking
+
+**Status: trapping is now provided by the focus stack (§12).** A focus trap
+prevents focus from leaving a subtree (e.g., a modal dialog); `focusPush`
+establishes exactly such a trap by confining the focus chain to the pushed
+node's subtree. A focus **lock** (preventing focus from changing at all) remains
+deferred.
+
+### 9.2 Focus Groups
+
+Focus groups partition the focus chain into segments navigated independently —
+arrow keys move within a group, Tab moves between groups. This requires a second
+level of navigation beyond the linear `advance`/`retreat` model.
+
+### 9.3 Focus Restoration
+
+**Status: now provided by the focus stack (§12).** `focusPush` records the node
+focused at push time; the `PopFocus` it returns restores that node. Restoration
+is stack-based rather than tied to the component lifecycle.
+
+### 9.4 Directional Navigation
+
+Spatial or directional navigation (up/down/left/right) requires a layout-aware
+focus algorithm that scores candidate nodes by position and direction. This is
+independent of linear navigation and may require renderer-specific information
+(e.g., bounding rectangles).
+
+---
+
+## 10. Implementation Files
+
+**`lib/focus.ts`** — `createApi("freedom:focus", ...)`. `focusable`, `advance`,
+`retreat`, `focus`, `current` operations. `useFocus()` installation resource.
+`focusPush` (returning `PopFocus`) stack operation and the active-focus-root
+resolution (§12).
+
+**`lib/mod.ts`** — Re-exports focus API and operations.
+
+---
+
+## 11. Dependencies
+
+Freedom Focus depends on:
+
+- Freedom Specification 0.1 — `freedom:node` context API (`get`, `set`,
+  `remove`), `Node`, `Tree`, `node.eval()`
+- Effection 4.1-alpha — `createApi`, `Operation`, `resource`
+
+---
+
+## 12. Focus Stack (Trapping and Restoration)
+
+### 12.1 Purpose
+
+Focus trapping (§9.1) and focus restoration (§9.3) are provided by the **focus
+stack**. The stack generalizes the single non-participating container of FI3
+(the tree root) into a LIFO stack of **focus roots**. Pushing a node makes it
+the active focus root: forward and backward cycling are confined to its
+focusable descendants, to the exclusion of every other node in the tree. Popping
+restores focus to where it was before the push and delivers a result value to
+the pusher.
+
+### 12.2 API
+
+One plain function, consistent with §4.1 (not a `createApi` operation in this
+version). It returns the **bound pop function** for the push:
+
+```
+type PopFocus = (value?: unknown) => void
+
+focusPush(node: Node, callback?: (value: unknown) => void): PopFocus
+```
+
+There is no standalone `focusPop`: popping is done by calling the `PopFocus`
+returned by the matching `focusPush`. The returned function closes over the
+tree, so no node or ambient pointer is needed to pop (this is why `focusPush`
+returns it rather than exposing a free `focusPop(value)`).
+
+### 12.3 The stack and the active focus root
+
+FS1. The focus stack is an ordered (LIFO) list of **entries**. Each entry is
+`{ node, restore, callback }`: `node` is the pushed focus root, `restore` is the
+node that was focused at the moment of the push (or `undefined` if none), and
+`callback` is the optional function passed to `focusPush`.
+
+FS2. The stack is scoped to the tree, not module-global (AGENTS "State"). It
+lives in the tree's `TreeState`, which is held on the root node's scope context
+(`root.scope.set(TreeContext, …)`); `focusPush` reaches it from its `node`
+argument via `node.scope.expect(TreeContext)`. The returned `PopFocus` closes
+over that same `TreeState`, so popping needs no node or ambient pointer. The
+stack is empty by default.
+
+FS3. The **active focus root** is the `node` of the top stack entry, or — when
+the stack is empty — the tree root (the non-participating container of FI3).
+
+FS4. The focus chain (§5) is computed from the active focus root, not the tree
+root. `advance`, `retreat`, `current`, and successor-on-removal (§6.3) all
+operate over this chain. Only focusable descendants of the active focus root
+participate; every other node is excluded. Cycling is airtight (FS14).
+
+### 12.4 focusPush
+
+FS5. `focusPush(node, callback?)` pushes an entry `{ node, restore, callback }`,
+where `restore` is the currently focused node (the member of the active focus
+chain with `focused: true`), or `undefined` if none is focused. It returns a
+`PopFocus` bound to this entry (FS9).
+
+FS6. After pushing, focus moves to the first focusable descendant of `node` in
+chain order (§5), via `focus()` (§4.2). If `node` has no focusable descendant,
+nothing is focused and `current()` falls back to `node` (FS3, F17).
+
+FS7. `node` is a non-participating container: it is not itself a focus stop
+unless it was separately made focusable (FI3, generalized).
+
+FS8. Nesting is allowed. `focusPush` MAY be called while the stack is non-empty;
+the new entry becomes the active focus root. `node` need not be a descendant of
+the previously active focus root — peer containers are permitted.
+
+### 12.5 Popping (the returned `PopFocus`)
+
+FS9. `focusPush` returns a `PopFocus` bound to the entry it pushed. Calling it,
+`pop(value?)`, removes the top stack entry. The entry it removes MUST be the
+entry this `pop` was bound to — i.e. push/pop are balanced (LIFO). Calling a
+`pop` when its entry is not on top, or when the stack is empty, is a bug and
+MUST raise an error. A `pop` is idempotent-safe only in that a second call (its
+entry already gone) raises the same balance error.
+
+FS10. After removing the entry, focus is restored: if the entry's `restore` node
+still exists and is a member of the now-active focus chain, `focus(restore)` is
+called; otherwise focus is seeded on the first focusable descendant of the
+now-active focus root, and if there is none, nothing is focused.
+
+FS11. The entry's `callback`, if present, is then invoked exactly once with
+`value`. It is invoked **after** focus has been restored (FS10).
+
+### 12.6 Interaction with explicit focus and removal
+
+FS12. `focus(target)` is constrained by the active focus root: a valid target
+MUST be a member of the active focus chain — focusable **and** a descendant of
+the active focus root. `focus()` on a node that is not focusable, or that is
+focusable but lies outside the active focus root, MUST raise an error (this
+revises F13). Because `pop` removes the top entry *before* restoring focus
+(FS10), the `restore` target is evaluated against the now-active root and is a
+valid target.
+
+FS13. Successor-on-removal (§6.3, FL7) computes the successor within the active
+focus chain, so removing the focused node keeps focus inside the active focus
+root.
+
+### 12.7 Invariants
+
+FS14. **Airtight cycling.** `advance` and `retreat` never move focus to a node
+outside the active focus root.
+
+FS15. **Balanced restoration.** Each `focusPush` is paired with a call to its
+returned `PopFocus` that restores the pre-push focus (FS10) and invokes the
+push's callback exactly once (FS11).
diff --git a/packages/freedom/specs/freedom-focus-test-plan.md b/packages/freedom/specs/freedom-focus-test-plan.md
new file mode 100644
index 0000000..fd8f11b
--- /dev/null
+++ b/packages/freedom/specs/freedom-focus-test-plan.md
@@ -0,0 +1,180 @@
+# Freedom Focus — Conformance Test Plan
+
+**Tests:** Freedom Focus Specification
+
+---
+
+## 1. Test Plan Scope
+
+### 1.1 What This Plan Covers
+
+This test plan defines conformance criteria for the Freedom Focus extension as
+specified in the Freedom Focus Specification. It covers:
+
+- Installation via `useFocus()` (§6.1)
+- `focusable()` operation (§4.2)
+- Focus chain computation via depth-first traversal (§5)
+- `advance()` and `retreat()` with wrapping (§4.2)
+- `focus(node)` explicit focus (§4.2)
+- `current()` query (§4.2)
+- Focused node removal (§6.3)
+- Notification interaction (§7)
+- All invariants (§8)
+
+It also covers the core spec additions required by focus:
+
+- `get(key)` operation (Freedom Spec §6.2)
+- `remove(node)` operation (Freedom Spec §6.2)
+
+### 1.2 What This Plan Does Not Cover
+
+- Focus trapping and locking (§9.1)
+- Focus groups (§9.2)
+- Focus restoration (§9.3)
+- Directional navigation (§9.4)
+- Focus middleware interception (tested by applications)
+
+### 1.3 Tiers
+
+**Core:** Tests that every conforming implementation MUST pass.
+
+**Extended:** Tests for edge cases and robustness.
+
+---
+
+## 2. Core Spec Additions
+
+### 2.1 Core: get operation
+
+GA1. `set("k", 42)` then `get("k")` — returns `42`. GA2. `get("missing")` —
+returns `undefined`. GA3. `get` middleware can intercept reads.
+
+### 2.2 Core: remove operation
+
+RA1. `remove(child)` destroys the child node. The child no longer appears in
+parent's `children`. RA2. `remove(root)` raises an error. RA3. `remove`
+middleware can intercept removal. RA4. `remove` middleware runs before teardown
+— the node is still in the tree when middleware executes.
+
+---
+
+## 3. Installation
+
+### 3.1 Core: useFocus
+
+FI1. After `useFocus()`, root has `focused: true`. FI2. After `useFocus()`, root
+is in the focus chain. FI3. `current()` returns root after installation.
+
+---
+
+## 4. focusable()
+
+### 4.1 Core: Opt-in
+
+FF1. `focusable()` sets `focused: false` on the current node. FF2. After
+`focusable()`, the node appears in the focus chain. FF3. `focusable()` on an
+already-focusable node is a no-op. FF4. A node that never calls `focusable()` is
+not in the focus chain.
+
+---
+
+## 5. Focus Chain
+
+### 5.1 Core: Depth-First Order
+
+FC1. Root with children A, B, C — all focusable. Chain order is root, A, B, C.
+FC2. Root with child A (focusable), A has child A1 (focusable), root has child B
+(focusable). Chain order is root, A, A1, B. FC3. Non-focusable nodes are
+skipped. Root (focusable), A (not focusable), B (focusable). Chain is root, B.
+
+### 5.2 Core: Sort Function Interaction
+
+FC4. Parent has sort function reversing children. Children A, B, C appended in
+order but sorted as C, B, A. Focus chain reflects sorted order.
+
+---
+
+## 6. advance()
+
+### 6.1 Core: Forward Navigation
+
+FA1. Focus on root, advance → focus moves to first focusable child. FA2. Focus
+on child A, advance → focus moves to child B. FA3. Old node gets
+`focused: false`, new node gets `focused: true`.
+
+### 6.2 Core: Wrapping
+
+FA4. Focus on last focusable node, advance → wraps to first focusable node
+(root).
+
+### 6.3 Core: Single Node
+
+FA5. Only one focusable node (root). `advance()` is a no-op. Root stays focused.
+
+---
+
+## 7. retreat()
+
+### 7.1 Core: Backward Navigation
+
+FR1. Focus on child B, retreat → focus moves to child A. FR2. Focus on first
+focusable child, retreat → wraps to last focusable node.
+
+### 7.2 Core: Single Node
+
+FR3. Only one focusable node. `retreat()` is a no-op.
+
+---
+
+## 8. focus(node)
+
+### 8.1 Core: Explicit Focus
+
+FE1. `focus(childB)` — childB gets `focused: true`, old focused node gets
+`focused: false`. FE2. `focus(node)` on a non-focusable node raises an error.
+FE3. `focus(node)` on the already-focused node is a no-op.
+
+---
+
+## 9. current()
+
+### 9.1 Core: Query
+
+CU1. After `useFocus()`, `current()` returns root. CU2. After `advance()`,
+`current()` returns the new focused node. CU3. `current()` never returns
+`undefined`.
+
+---
+
+## 10. Focused Node Removal
+
+### 10.1 Core: Advance on Remove
+
+FR1. Remove the focused node. Focus advances to the next node in the chain. FR2.
+Remove the last focused node in the chain. Focus wraps to the first. FR3. After
+removal, the removed node is gone from the focus chain.
+
+### 10.2 Extended: Edge Cases
+
+FR4. Remove a non-focused focusable node. Focus does not move. FR5. Remove the
+only non-root focusable node. Focus returns to root.
+
+---
+
+## 11. Notification
+
+### 11.1 Core: Focus Changes Notify
+
+FN1. `advance()` triggers a tree notification (focus property changes). FN2.
+`focusable()` triggers a tree notification (property set). FN3. Multiple focus
+operations in one dispatch cycle coalesce into a single notification.
+
+---
+
+## 12. Explicit Non-Tests
+
+The following are explicitly NOT tested:
+
+NT1. Focus trapping / containment (§9.1). NT2. Focus group navigation (§9.2).
+NT3. Focus restoration on scope exit (§9.3). NT4. Directional / spatial
+navigation (§9.4). NT5. Focus middleware interception patterns (app-level).
diff --git a/packages/freedom/specs/freedom-spec.md b/packages/freedom/specs/freedom-spec.md
new file mode 100644
index 0000000..690efe1
--- /dev/null
+++ b/packages/freedom/specs/freedom-spec.md
@@ -0,0 +1,837 @@
+# Freedom Specification
+
+**Version:** 0.1 — Draft\
+**Status:** Normative draft\
+**Depends on:** Effection 4.1-alpha (`createApi`, `createContext`, `Signal`,
+`Stream`, `resource`, `spawn`, `Result`)
+
+---
+
+## 1. Purpose
+
+Freedom ("free DOM") is a general-purpose abstract component tree built on
+Effection's structured concurrency. It maintains a tree of long-lived, stateful
+component nodes where each node is an Effection resource with a scope, a
+property bag, and ordered children.
+
+The tree is a **bidirectional firehose**:
+
+- **Input:** A synchronous `dispatch(event)` entry point accepts events of any
+  shape at any rate.
+- **Output:** A `Stream<void>` emits a notification after every mutation cycle,
+  signaling renderers to walk the tree and rebuild output.
+
+Freedom is renderer-agnostic. It has no opinion about what properties mean, what
+events look like, or how output is produced. Renderers, event vocabularies, and
+display systems are consumers that operate on the tree from the outside.
+
+---
+
+## 2. Design Philosophy
+
+### 2.1 Renderer independence
+
+Freedom provides structure, state, events, and change notification. It does not
+provide layout, rendering, styling, or any visual vocabulary. A clayterm
+renderer reads `node.props["clay"]`. A DOM renderer reads `node.props["html"]`.
+Freedom does not know or care.
+
+### 2.2 Event agnosticism
+
+Freedom defines exactly one event operation: `dispatch(event: unknown)`. It does
+not define keyboard events, mouse events, or any other vocabulary. Applications
+and framework layers install middleware at the root scope to demux raw events
+into their own typed APIs. This allows Freedom to serve DOM applications,
+terminal applications, game engines, or any other event source without
+modification.
+
+### 2.3 Synchronous mutations, async events
+
+Node mutations (`set`, `update`, `unset`, `createChild`, `remove`, `sort`) are
+**synchronous methods** on the `Node` object. They remain interceptable —
+synchronous interceptors installed via `node.scope.around` can validate,
+transform, log, or reject changes in a subtree (§6). Only event **dispatch**
+(§7) is operation-based; that is where asynchronous work lives. This keeps the
+tree drivable imperatively (e.g., by a React/Svelte reconciler).
+
+### 2.4 Orthogonal concerns
+
+Identity, properties, and child ordering are fully independent:
+
+- **Identity** is intrinsic (object reference) with a framework-assigned unique
+  `id` for external use.
+- **Properties** are a JSON-like bag with conventional namespacing.
+- **Ordering** is a separate axis: insertion order by default, or a custom sort
+  function owned by the parent.
+
+### 2.5 Immediate-mode output
+
+The output stream emits `void` — a pure notification that something changed.
+Renderers walk the tree and read properties to produce output. This matches
+immediate-mode rendering patterns (e.g., clayterm rebuilds `Op[]` every frame).
+The JSON-like property constraint does not foreclose on richer change records in
+the future.
+
+### 2.6 Read-only data, synchronous mutators
+
+The `Node` object's data fields — `id`, `name`, `props`, `children`, `parent` —
+are for reading only. All mutations go through synchronous `Node` methods
+(`set`, `update`, `unset`, `createChild`, `sort`, `remove`), each interceptable
+by synchronous middleware installed on the node's scope (§6). `node.remove()`
+tears a node down (detach + dispose its scope); the whole tree is torn down via
+`root.destroy()`.
+
+---
+
+## 3. Terminology
+
+**Root.** The synchronous entry created by `createRoot()`. Externally it exposes
+the root `node`, an event sink (`dispatch`), a change source (`Stream<void>`),
+and `destroy()`. The root node owns the top scope and runs the event loop. Root
+replaces the former `Tree`.
+
+**Node.** A long-lived Effection resource within the tree. Each node has a
+framework-assigned unique `id`, an optional name, a property bag, an ordered
+list of children, and a parent (except the root). A node's in-memory identity is
+its object reference; its externalizable identity is its `id`. The Node's data
+fields are read-only — all mutations go through synchronous methods (§6). Each
+node owns an Effection scope created in its constructor. `node.remove()` detaches
+the node and tears down its scope (and descendants); synchronous interceptors on
+the node's scope participate.
+
+**Property bag.** A `Record<string, JsonValue>` on each node. Properties are the
+node's state AND its renderable description — they are the same thing.
+Properties are namespaced by convention (e.g., `"clay"`, `"aria"`).
+
+**JsonValue.** The set of permissible property values:
+`string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue }`.
+No `undefined`. Properties are removed with `unset()`.
+
+**Dispatch.** The synchronous entry point for events. `root.dispatch(event)`
+pushes an event into the root's internal Signal. The event is then processed
+operationally (asynchronously) through dispatch middleware (§7).
+
+**Middleware.** An Effection `createApi` middleware function that intercepts an
+operation. In Freedom, middleware is used for both event handling
+(`dispatch.around(...)`) and property mutation interception
+(`node.around(...)`).
+
+**Demux.** Application-level middleware installed at the root scope that routes
+raw `dispatch` events into typed, application-specific APIs. Demuxing is NOT a
+Freedom concept — it is a pattern that applications implement.
+
+**Notification.** A `void` emission on the tree's output stream indicating that
+the tree may have changed. At most one notification is emitted per dispatch
+cycle. A dispatch cycle that produces no property or structural changes MUST NOT
+emit a notification.
+
+---
+
+## 4. JsonValue
+
+### 4.1 Definition
+
+```
+JsonValue = string
+          | number
+          | boolean
+          | null
+          | JsonValue[]
+          | { [key: string]: JsonValue }
+```
+
+### 4.2 Constraints
+
+J1. `undefined` is NOT a valid JsonValue. Implementations MUST reject
+`undefined` in `set()` and `update()`.
+
+J2. `NaN`, `Infinity`, and `-Infinity` are NOT valid JsonValues. Implementations
+MUST reject them.
+
+J3. Functions, symbols, class instances, `Date`, `Map`, `Set`, `RegExp`, and
+other non-JSON-serializable values are NOT valid JsonValues.
+
+J4. Implementations SHOULD validate values at the `set()` and `update()`
+boundary. Invalid values MUST NOT be stored in the property bag.
+
+### 4.3 Rationale
+
+The JsonValue constraint ensures properties are:
+
+- serializable (devtools, snapshots, undo/redo),
+- structurally comparable (deep equality is well-defined),
+- diffable (for future change record support).
+
+Application-level state that requires richer types (functions, class instances,
+Dates) belongs in the component's generator scope as local variables, not in the
+property bag.
+
+---
+
+## 5. Node
+
+### 5.1 Structure
+
+Each node has:
+
+- **id** (`string`) — a unique, framework-assigned identifier. Stable for the
+  node's lifetime. Used by renderers and external systems to reference the node
+  (e.g., clayterm named elements, ARIA ids, devtools).
+- **name** (`string`, optional) — a human-readable label. Defaults to `""`. Not
+  required to be unique. Used for debugging and optional lookup.
+- **props** (`Record<string, JsonValue>`) — the property bag. Initially empty.
+  Read-only; mutate via context API only.
+- **children** (`Iterable<Node>`) — ordered child nodes. Initially empty.
+  Read-only.
+- **parent** (`Node | undefined`) — the parent node. The root node's parent is
+  `undefined`. Read-only.
+
+```ts
+interface Node {
+  readonly id: string;
+  readonly name: string;
+  readonly props: Record<string, JsonValue>;
+  readonly children: Iterable<Node>;
+  readonly parent: Node | undefined;
+  readonly data: NodeData;
+  get(key: string): JsonValue | undefined;
+  set(key: string, value: JsonValue): void;
+  update(key: string, fn: (prev: JsonValue | undefined) => JsonValue): void;
+  unset(key: string): void;
+  createChild(name?: string, options?: { before?: Node }): Node;
+  sort(fn?: (a: Node, b: Node) => number): void;
+  remove(): Promise<void>;
+}
+```
+
+The Node's data fields are read-only; all mutations go through the synchronous
+methods (§6). Each node creates its own Effection scope in its constructor
+(§5.3), inheriting the parent's contexts; mutations and their interceptors
+resolve against that scope. `remove()` detaches the node and tears it down by
+disposing its scope. `data` provides typed, symbol-keyed storage for private,
+non-serializable per-node state (§5.7).
+
+### 5.2 Identity
+
+N1. A node's in-memory identity is its object reference. Two nodes are the same
+node if and only if they are the same object (`===`).
+
+N2. Each node has a unique `id` string assigned by the framework at creation
+time. The `id` is immutable — it MUST NOT change for the node's lifetime. The
+`id` MUST be unique across all nodes in the tree at any given time. Two nodes
+are the same node if and only if `a.id === b.id`.
+
+N3. The `id` is the externalizable identity. Renderers and external systems use
+it to correlate nodes across render cycles, reference nodes in output (e.g.,
+named elements in clayterm), and track nodes in devtools.
+
+N4. The format of `id` is implementation-defined. It MAY be a monotonic counter,
+a UUID, or any other scheme that guarantees uniqueness within the tree.
+
+N5. Nodes are long-lived Effection resources. A node is created once and exists
+until explicitly removed or its parent scope exits.
+
+N6. The `name` field is informational. It does NOT participate in identity,
+uniqueness, or reconciliation.
+
+### 5.3 Node Scope
+
+Each node owns an Effection **scope**, created in its constructor as a child of
+its parent's scope (`createScope(parent?.scope)`), so it inherits the parent's
+contexts. Mutations (§6) and their synchronous interceptors resolve against this
+scope. There is no eval loop, no channel, and no `eval` method.
+
+N-scope1. A node's scope is created with the node and torn down when the node is
+removed — or, for the root, when `root.destroy()` is called. Disposing the scope
+halts all descendant node scopes and resources.
+
+N-scope2. Synchronous interceptors installed via `node.scope.around(...)` are
+visible to mutations on this node and its descendants, via context inheritance.
+
+### 5.4 Lifecycle
+
+N7. A node is created by `parent.createChild(name?, options?)`: the constructor
+creates the child's scope (a child of the parent's), the child is attached to the
+parent's children, and it is returned synchronously. If `options.before` is
+given, the child is inserted immediately before that sibling in insertion order
+instead of being appended (C14).
+
+N8. A node is torn down by `node.remove()` (detach + dispose its scope). The
+whole tree is torn down via `root.destroy()`, which disposes the root node's
+scope. There is no public `destroy()` on `Node`; disposing a scope halts all
+descendant node scopes and resources.
+
+N9. When a node is torn down, its interceptors disappear automatically because
+its Effection scope is destroyed.
+
+N10. When a parent node is torn down, all descendant nodes are torn down per
+Effection's structured concurrency guarantees.
+
+N11. `node.remove()` detaches the node from its parent, marks the tree dirty
+(§8), and disposes its scope.
+
+N12. Calling `remove()` on the root node is an error (C-rm3).
+
+### 5.5 Property Bag
+
+N13. Properties are accessed via `node.props`, which returns a read-only
+`Record<string, JsonValue>`. Implementations SHOULD return a frozen or proxied
+object to enforce read-only access at runtime.
+
+N14. Properties MUST NOT be mutated by direct assignment to the `props` object.
+The ONLY way to modify properties is through the `freedom:node` context API
+operations (`set`, `update`, `unset`). See §6.
+
+N15. The `props` object MUST reflect the latest state at all times. There is no
+staleness window.
+
+N16. Properties are namespaced by convention. Top-level keys (e.g., `"clay"`,
+`"aria"`, `"app"`) serve as namespaces. Freedom does not enforce or validate
+namespaces.
+
+### 5.6 Children and Ordering
+
+N17. Children are ordered. The default ordering is **insertion order** —
+children appear in the order they were appended.
+
+N18. A parent MAY install a **sort function** via the `sort` context API
+operation. When a sort function is active, iterating `node.children` applies the
+sort function to produce the ordering. Insertion order serves as tiebreaker for
+children that compare equal.
+
+N19. A parent MAY clear the sort function via `sort(undefined)`, which reverts
+to insertion order.
+
+N20. The sort function is applied at **read time** — when `node.children` is
+iterated. There is no eager re-sorting on property changes. The sort is always
+fresh because it runs against current property values at iteration time.
+
+N21. Installing or clearing a sort function via `sort()` MUST emit a
+notification (§8), because the iteration order of children may have changed.
+
+N22. A child MAY be inserted at a specific position via
+`createChild(name, { before })` (C14). This sets its position in **insertion
+order**; it does not bypass an active sort function (N20). The `options` object
+is the extension point for future positioning hints (e.g. `after`, `at`).
+
+### 5.7 Node Data
+
+Node data is typed, symbol-keyed storage for non-serializable, private values
+associated with a node. It exists to give extensions and middleware a place to
+store per-node state that is invisible to other extensions, renderers, and
+application code.
+
+The property bag (§5.5) is the node's public, renderable state — constrained to
+JsonValue, frozen, and observable via notifications. Node data is the
+complement: private state owned by a specific extension, unconstrained in type,
+and invisible to the rest of the system. Only code holding the key can read or
+write the data. All NodeData operations are synchronous — no scope resolution is
+needed because the node reference provides direct access to its data.
+
+```ts
+interface NodeDataKey<T> {
+  readonly symbol: symbol;
+  readonly defaultValue?: T;
+}
+
+interface NodeData {
+  get<T>(key: NodeDataKey<T>): T | undefined;
+  set<T>(key: NodeDataKey<T>, value: T): void;
+  expect<T>(key: NodeDataKey<T>): T;
+}
+
+function createNodeData<T>(
+  name: string,
+  defaultValue?: T,
+): NodeDataKey<T>;
+```
+
+D1. `createNodeData(name, defaultValue?)` creates a typed data key backed by a
+`Symbol(name)`. The symbol ensures true privacy — only code holding the key can
+access the data.
+
+D2. `node.data.get(key)` returns the stored value, or `undefined` if no value
+was set.
+
+D3. `node.data.set(key, value)` stores a value on the node under the given key.
+
+D4. `node.data.expect(key)` returns the stored value, or `defaultValue` if no
+value was set. If neither exists, it throws an error.
+
+D5. Node data does NOT trigger tree notifications. It is invisible to renderers.
+
+The Node interface is extended:
+
+```ts
+interface Node {
+  readonly id: string;
+  readonly name: string;
+  readonly props: Record<string, JsonValue>;
+  readonly children: Iterable<Node>;
+  readonly parent: Node | undefined;
+  readonly data: NodeData;
+  get(key: string): JsonValue | undefined;
+  set(key: string, value: JsonValue): void;
+  update(key: string, fn: (prev: JsonValue | undefined) => JsonValue): void;
+  unset(key: string): void;
+  createChild(name?: string, options?: { before?: Node }): Node;
+  sort(fn?: (a: Node, b: Node) => number): void;
+  remove(): Promise<void>;
+}
+```
+
+---
+
+## 6. Node Context API
+
+### 6.1 API Definition
+
+The `freedom:node` API is **synchronous**. Its operations are methods on `Node`
+(§5); they are not Effection operations. Interceptors are synchronous functions
+installed per scope via `scope.around`:
+
+```
+node.get(key): JsonValue | undefined
+node.set(key, value): void
+node.update(key, fn: (prev: JsonValue | undefined) => JsonValue): void
+node.unset(key): void
+node.createChild(name?, options?: { before?: Node }): Node
+node.sort(fn?: (a: Node, b: Node) => number): void
+node.remove(): Promise<void>
+```
+
+C-api1. A mutation resolves its composed interceptor chain off the node's scope
+and invokes it **synchronously**, passing the `node`.
+
+C-api2. There is no `useNode` and no `eval` — components are removed (§9); nodes
+are referenced directly.
+
+### 6.2 Operations
+
+All operations are synchronous methods on `Node`.
+
+**get**
+
+C-get1. `get(key)` returns the value of `key` in the node's property bag, or
+`undefined` if the key does not exist.
+
+**set**
+
+C1. `set(key, value)` stores `value` under `key` in the node's property bag.
+
+C2. `value` MUST be a valid JsonValue (§4). If not, `set` throws.
+
+C3. If `key` already exists, the previous value is replaced.
+
+C4. `set` marks the tree dirty (§8).
+
+**update**
+
+C5. `update(key, fn)` calls `fn` with the current value of `key` (or `undefined`
+if the key does not exist) and stores the result.
+
+C6. The return value of `fn` MUST be a valid JsonValue (§4). If not, `update`
+throws.
+
+C7. `update` marks the tree dirty (§8).
+
+**unset**
+
+C8. `unset(key)` removes `key` from the node's property bag.
+
+C9. If `key` does not exist, `unset` is a no-op. It MUST NOT throw.
+
+C10. `unset` marks the tree dirty (§8) only if the key existed.
+
+**createChild**
+
+C11. `createChild(name?)` creates a new child node with the given name (default
+`""`) and a unique `id`. The child's constructor creates its scope as a child of
+this node's scope (inheriting contexts).
+
+C12. `createChild` attaches the child to this node's children and returns it
+**synchronously**.
+
+C13. `createChild` marks the tree dirty (§8).
+
+C14. `createChild(name?, options?)`: if `options.before` is provided, it MUST be a
+current child of this node; the new child is inserted **immediately before** it in
+insertion order. If `before` is not a current child, `createChild` throws. If
+`before` is omitted, the child is appended.
+
+C15. The `before` position sets the child's place in **insertion order**. An
+active sort function (N18) still reorders at read time, with insertion order as
+the equal-compare tiebreaker (N20). `options` is an open object reserved for
+future positioning hints (e.g. `after`, `at`).
+
+**sort**
+
+C19. `sort(fn)` installs a sort function on the node. When `fn` is defined,
+iterating this node's `children` applies `fn` to determine ordering. When `fn` is
+`undefined`, the sort function is cleared and ordering reverts to insertion
+order.
+
+C20. `sort` marks the tree dirty (§8) (N19).
+
+**remove**
+
+C-rm1. `remove()` detaches the node from its parent (synchronously) and tears
+down its scope and all descendants (disposing the scope). It **returns the
+teardown `Promise`**; callers MAY await it or ignore it — the teardown is
+initiated regardless.
+
+C-rm3. `remove()` on the root node is an error. The whole tree is torn down via
+`root.destroy()` (§8).
+
+C-rm4. `remove` marks the tree dirty (§8).
+
+### 6.3 Middleware Interception
+
+C21. Interceptors are installed with `node.scope.around(...)` as **synchronous
+functions** of shape `(node, args, next) => result`, registered per scope and
+inherited by descendant scopes.
+
+C22. Interceptors run synchronously. They receive the `node` and MAY read any
+context via the synchronous `node.scope.get/expect(...)`.
+
+C23. An interceptor MAY transform args, skip `next` to reject a mutation, or act
+after `next`. An interceptor MUST NOT perform asynchronous work (`await` /
+`yield*`); async concerns belong on the dispatch/event side (§7).
+
+---
+
+## 7. Event Dispatch
+
+### 7.1 The Dispatch API
+
+Freedom provides a dispatch API with event dispatch and node lookup:
+
+```
+createApi("freedom:dispatch", {
+  *dispatch(event: unknown): Operation<Result<true>> {
+    return { ok: false };
+  },
+  *getNodeById(id: string): Operation<Node | undefined>,
+})
+```
+
+E1. The `dispatch` operation accepts a single argument of type `unknown`.
+Freedom does not constrain, inspect, or interpret the event in any way.
+
+E2. The default handler (at the bottom of the middleware chain) returns
+`{ ok: false }`, indicating the event was unhandled.
+
+E3. Middleware that handles an event MUST return `{ ok: true, value: true }`.
+
+E4. If middleware throws an exception, the result MUST capture it as
+`{ ok: false, error }`. The dispatch loop MUST NOT crash. The tree MUST remain
+alive.
+
+E4a. `getNodeById(id)` returns the node with the given `id`, or `undefined` if
+no such node exists. This allows dispatch middleware to resolve event targets by
+id and use `node.eval()` to dispatch application-level APIs in the target node's
+scope.
+
+### 7.2 The Synchronous Bridge
+
+E5. `tree.dispatch(event)` is synchronous. It pushes the event into an Effection
+`Signal`.
+
+E6. Internally, an event loop reads from the Signal and dispatches each event
+through the root node's scope:
+`yield* root.eval(() => dispatch.operations.dispatch(event))`. The event loop
+itself MAY run anywhere — it enters the root node's scope via `eval`, so
+dispatch middleware installed by the root component is always in the chain.
+
+E7. Events are processed sequentially — one at a time, in the order they were
+dispatched. A new event is not processed until the previous event's entire
+middleware chain has completed.
+
+### 7.3 Demuxing
+
+E8. Freedom does NOT provide built-in demuxing. It does not define event types,
+event shapes, or event routing.
+
+E9. Demuxing is the root component's responsibility. The root component installs
+middleware on `freedom:dispatch` that routes events to application-specific
+APIs.
+
+E10. The root component is the first component to run, so its middleware is the
+outermost layer — it sees every event before any child middleware.
+
+E10a. Dispatch middleware uses `getNodeById()` and `node.eval()` to route events
+to specific nodes. When an event targets a particular node, the middleware
+resolves the node by id, then uses `eval` to invoke an application-level API in
+that node's scope. The target node's middleware on that application API
+participates because `eval` runs in the node's scope.
+
+    ```ts
+    // Example demux middleware (application-level, NOT Freedom)
+    yield* DispatchApi.around({
+      *dispatch([event], next) {
+        if (isKeydown(event)) {
+          let node = yield* DispatchApi.operations.getNodeById(event.targetId);
+          if (node) {
+            yield* node.eval(() => KeyboardApi.operations.keydown(event));
+          }
+          return { ok: true, value: true };
+        }
+        return yield* next(event);
+      },
+    });
+    ```
+
+E11. Applications define their own event APIs using `createApi`. These are NOT
+part of Freedom.
+
+E12. Multiple demux layers MAY compose. A root breaks raw events into
+`keyboard`/`mouse` APIs. A child further breaks `keyboard` into `shortcut` based
+on key bindings. Each layer is middleware on an API.
+
+### 7.4 Event Helpers
+
+E13. Per-event-type helper functions are an application-level pattern, NOT part
+of Freedom. They are the sanctioned way for applications and framework layers to
+build ergonomic event APIs on top of Freedom's generic `dispatch` + `around()`.
+
+A helper wraps the raw `around()` API to hide the tuple destructuring and
+provide TypeScript type narrowing:
+
+```ts
+// Definition (in the app's event layer, NOT in Freedom)
+function onkeydown(
+  handler: (
+    event: KeydownEvent,
+    next: (event: KeydownEvent) => Operation<void>,
+  ) => Operation<void>,
+): Operation<void> {
+  return keyboard.around({
+    *keydown([event], next) {
+      return yield* handler(event, (e) => next(e));
+    },
+  });
+}
+
+// Usage in a component
+function* searchBox(): Operation<void> {
+  yield* set("query", "");
+
+  yield* onkeydown(function* (event, next) {
+    if (event.key === "Enter") {
+      yield* update("query", () => event.text);
+    } else {
+      yield* next(event);
+    }
+  });
+}
+```
+
+The helper is better than raw middleware because:
+
+- The consumer sees `(event, next)` instead of `([event], next)`.
+- TypeScript narrows `event` to `KeydownEvent` automatically.
+- The `keyboard` API reference is encapsulated — the consumer does not need to
+  know which API object to call `around()` on.
+
+---
+
+## 8. Root and Notification
+
+### 8.1 Root Interface
+
+```
+interface Root extends Stream<void, never> {
+  node: Node;
+  dispatch(event: unknown): void;
+  destroy(): Promise<void>;
+}
+```
+
+T1. The root node owns the top Effection scope, which owns all nodes and runs the
+event loop.
+
+T2. `root.node` is the root node, created by `createRoot()` and existing for the
+root's lifetime.
+
+T3. `root.dispatch(event)` is the synchronous event entry point (§7.2).
+
+T4. `Root` is a `Stream<void, never>`. Subscribing yields notifications when the
+tree changes.
+
+### 8.2 Creation
+
+T5. `createRoot(): Root` synchronously creates a root. It: 1. Creates the tree
+state and Signals. 2. Constructs the root node (whose constructor creates the top
+scope). 3. Sets `TreeContext` and installs the `markDirty` interceptor via
+`scope.around`. 4. Starts the event-loop task on the root node's scope. 5.
+Returns the `Root`.
+
+T6. `createRoot()` is synchronous: the root and its node are fully usable when it
+returns. There is no component to run.
+
+### 8.3 Notification
+
+T7. The tree emits a `void` notification on its output stream after each
+dispatch cycle — that is, after one event has been fully processed through the
+middleware chain and all resulting property mutations and structural changes
+have settled.
+
+T8. A dispatch cycle that produces no property changes, structural changes, or
+sort function changes MUST NOT emit a notification.
+
+T9. Multiple property mutations within a single dispatch cycle MUST coalesce
+into a single notification. The renderer sees the final state, never
+intermediate states.
+
+T10. Structural changes (append, remove) and sort changes within a dispatch
+cycle also coalesce with property changes into a single notification.
+
+T11. Property mutations or structural changes that occur outside of a dispatch
+cycle (e.g., during component initialization) MUST also emit notifications.
+
+T12. The notification is `void`. It carries no information about what changed.
+The renderer MUST walk the tree and read properties to determine the current
+state.
+
+### 8.4 Lifecycle
+
+T13. `root.destroy()` disposes the root node's scope, which destroys all nodes,
+stops the event loop, and closes the output stream; it returns a `Promise<void>`.
+
+T14. Events dispatched after the root is destroyed are silently dropped — the
+event Signal is inert once the scope exits. Implementations do NOT need an
+explicit alive check.
+
+---
+
+## 9. Components (removed)
+
+Components (`() => Operation<void>`) are removed in this version. Nodes are
+created imperatively via `parent.createChild(...)` (§6) and configured through
+their synchronous methods; setup that previously lived in a component (e.g. focus
+installation) is installed imperatively via `node.scope.around(...)`.
+
+---
+
+## 10. Invariants
+
+I1. **Scope-tree correspondence.** The node tree and the Effection scope tree
+are isomorphic. Each node's scope is a child of its parent node's scope.
+
+I2. **Structured teardown.** Removing a node destroys all its descendants in
+reverse creation order. No orphaned nodes can exist.
+
+I3. **Middleware scope binding.** Middleware installed in a node's scope is
+active only while that node exists. When the node is removed, its middleware is
+automatically removed.
+
+I4. **Sequential dispatch.** Events are processed one at a time. No two events
+are in-flight simultaneously.
+
+I5. **Consistent notification.** The tree state visible to a renderer after a
+notification is complete and consistent — all mutations from the triggering
+dispatch cycle have been applied.
+
+I6. **Property validity.** Every value in every node's property bag is a valid
+JsonValue at all times.
+
+I7. **Ordering consistency.** `node.children` always reflects the current
+ordering — either insertion order or the sort function applied at read time
+against current property values.
+
+I8. **Node read-only plus methods.** The Node object's data fields (`id`,
+`name`, `props`, `children`, `parent`) are read-only. All property reads and
+mutations go through the `freedom:node` context API (`get`, `set`, `update`,
+`unset`, `append`, `remove`, `sort`). `eval()` provides scoped operation
+execution. `remove()` is both a convenience method and a context API operation —
+the method delegates to the operation.
+
+---
+
+## 11. Deferred Extensions
+
+The following are explicitly out of scope for this version.
+
+### 11.1 Rich Change Records
+
+The output stream emits `void`. A future version MAY emit structured change
+records (`PropertyChange`, `StructuralChange`) with per-node, per-property
+granularity. The JsonValue constraint and property bag structure are designed to
+support this without API changes.
+
+### 11.2 JSX Transform
+
+A JSX transform that provides declarative sugar for `append()` calls is a
+natural extension. Display properties would be set separately by each component
+via the context API. JSX is a consumer of Freedom's imperative API, not a core
+feature.
+
+### 11.3 Reconciliation
+
+Key-based reconciliation (matching old nodes to new declarations during
+declarative re-rendering) is not supported. Nodes are managed imperatively via
+`append` and `remove`. A reconciliation layer could be built on top of Freedom.
+
+### 11.4 Computed Properties
+
+Derived properties that update automatically when their dependencies change are
+not supported. Components can implement this pattern manually by installing
+middleware on `set`.
+
+### 11.5 Node Queries
+
+Querying the tree by property values, name patterns, or other criteria is not
+provided. `getNodeById()` is provided as part of the dispatch API (§7.1) for
+event targeting. For other queries, consumers walk the tree via `root` and
+`children`.
+
+### 11.6 Event Bubbling / Capturing
+
+Freedom does not define event propagation phases. Middleware composition through
+the scope tree provides a similar capability, but the traversal order is
+determined by middleware installation order, not by a DOM-style capture/bubble
+model.
+
+### 11.7 Explicit Index Ordering
+
+A built-in ordering mode based on an `index` property is not provided. If an
+application wants index-based ordering, it sets an `index` property on child
+nodes and provides a sort function that reads it.
+
+---
+
+## 12. Implementation Files
+
+**`lib/types.ts`** — `JsonValue`, `Component`, `Node` interface, `Tree`
+interface.
+
+**`lib/tree.ts`** — `createTree(root: Component)`. Root scope, event Signal,
+output stream, event loop, notification coalescing.
+
+**`lib/node.ts`** — Node resource. Child scope, property bag, children list with
+read-time sort.
+
+**`lib/dispatch.ts`** — `createApi("freedom:dispatch", ...)`.
+`dispatch(event: unknown) → Result<true>` and
+`getNodeById(id: string) → Node | undefined`. Sync→operational bridge via
+Signal.
+
+**`lib/freedom.ts`** — `createApi("freedom:node", ...)`. `useNode`, `get`,
+`set`, `update`, `unset`, `append`, `remove`, `sort` operations.
+
+**`lib/mod.ts`** — Re-exports.
+
+---
+
+## 13. Dependencies
+
+Freedom depends on Effection 4.1-alpha for:
+
+- `createApi` — context-scoped API with middleware
+- `createContext` — scoped state
+- `Signal` — synchronous write, operational read
+- `Stream` — async iteration protocol
+- `resource` — long-lived scoped values
+- `spawn` — concurrent child tasks
+- `Result` — success/failure envelope
+- `Operation` — the base computation type
diff --git a/packages/freedom/specs/freedom-test-plan.md b/packages/freedom/specs/freedom-test-plan.md
new file mode 100644
index 0000000..70bd203
--- /dev/null
+++ b/packages/freedom/specs/freedom-test-plan.md
@@ -0,0 +1,371 @@
+# Freedom — Conformance Test Plan
+
+**Tests:** Freedom Specification
+
+---
+
+## 1. Test Plan Scope
+
+### 1.1 What This Plan Covers
+
+This test plan defines conformance criteria for the Freedom component tree as
+specified in the Freedom Specification. It covers:
+
+- JsonValue validation at the `set`/`update` boundary (§4)
+- Node lifecycle: creation via `append`, destruction via `remove`, structured
+  teardown (§5.3)
+- Node identity: unique `id` assignment (§5.2)
+- Property bag: `set`, `update`, `unset` operations (§6.2)
+- Property bag read-only enforcement (§5.4)
+- Child ordering: insertion order, custom sort at read time (§5.5)
+- Sort installation/removal notification (N19)
+- Node context API middleware interception (§6.3)
+- Event dispatch: single API, `Result<true>` signaling, error capture (§7.1)
+- Synchronous bridge: Signal-based dispatch, sequential processing (§7.2)
+- Tree creation and lifecycle (§8.2, §8.4)
+- Notification coalescing, including no-change suppression (§8.3)
+- Component execution model (§9)
+- All invariants (§10)
+
+### 1.2 What This Plan Does Not Cover
+
+- JSX transforms (§11.2)
+- Reconciliation (§11.3)
+- Computed properties (§11.4)
+- Node queries (§11.5)
+- Event bubbling/capturing (§11.6)
+- Explicit index ordering (§11.7)
+- Rich change records (§11.1)
+- Application-level demux patterns (§7.3) — these are tested in application test
+  suites, not Freedom's
+- Event helper functions (§7.4) — application-level pattern
+
+### 1.3 Tiers
+
+**Core:** Tests that every conforming implementation MUST pass. A Freedom
+implementation is non-conforming if any Core test fails.
+
+**Extended:** Tests for edge cases, boundary conditions, and robustness.
+Recommended but not strictly required.
+
+---
+
+## 2. JsonValue Validation
+
+### 2.1 Core: Valid Values
+
+JV1. `set("k", "hello")` — string accepted. JV2. `set("k", 42)` — number
+accepted. JV3. `set("k", 0)` — zero accepted. JV4. `set("k", -1.5)` — negative
+float accepted. JV5. `set("k", true)` — boolean accepted. JV6. `set("k", false)`
+— boolean false accepted. JV7. `set("k", null)` — null accepted. JV8.
+`set("k", [1, "a", true, null])` — array accepted. JV9.
+`set("k", { a: 1, b: "c" })` — object accepted. JV10.
+`set("k", { nested: { deep: [1, 2] } })` — nested structures accepted. JV11.
+`set("k", [])` — empty array accepted. JV12. `set("k", {})` — empty object
+accepted.
+
+### 2.2 Core: Invalid Values
+
+JV13. `set("k", undefined)` — MUST raise error (J1). JV14. `set("k", NaN)` —
+MUST raise error (J2). JV15. `set("k", Infinity)` — MUST raise error (J2). JV16.
+`set("k", -Infinity)` — MUST raise error (J2). JV17. `set("k", () => {})` — MUST
+raise error (J3). JV18. `set("k", Symbol())` — MUST raise error (J3). JV19.
+`set("k", new Date())` — MUST raise error (J3). JV20. `set("k", new Map())` —
+MUST raise error (J3).
+
+### 2.3 Core: update() Validation
+
+JV21. `update("k", () => undefined)` — MUST raise error. The return value of the
+update function is validated. JV22. `update("k", () => NaN)` — MUST raise error.
+JV23. `update("k", () => 42)` — accepted.
+
+---
+
+## 3. Node Lifecycle
+
+### 3.1 Core: Creation
+
+NL1. `append("child", component)` creates a child node. The returned node has
+`name === "child"`. NL2. The child appears in `parent.children`. NL3. The
+child's `parent` is the appending node. NL4. The child's `props` is initially
+empty (`{}`). NL5. The child's component runs within the child's scope. NL6.
+Multiple children can be appended to the same parent.
+
+### 3.2 Core: Node ID
+
+NL7. Each created node has a non-empty `id` string (N2). NL8. Two sibling nodes
+have different `id` values (N2). NL9. A node's `id` does not change after
+creation (N2). NL10. Nodes in different subtrees have different `id` values (N2
+— unique across the tree). NL11. The root node has an `id`.
+
+### 3.3 Core: Destruction
+
+NL12. `remove()` destroys the node. The node no longer appears in its parent's
+`children`. NL13. `remove()` on a node with children destroys all descendants.
+NL14. Descendant destruction occurs in reverse creation order (LIFO). NL15.
+After `remove()`, middleware installed by the node's component is no longer
+active. NL16. `remove()` on the root node MUST raise an error (C18).
+
+### 3.4 Extended: Edge Cases
+
+NL17. Appending to a node that is being removed — behavior is
+implementation-defined but MUST NOT corrupt the tree. NL18. A component that
+returns immediately (no loop) — the node remains alive (P4).
+
+---
+
+## 4. Property Bag
+
+### 4.1 Core: set
+
+PB1. `set("a", 1)` — `node.props["a"]` is `1`. PB2. `set("a", 1)` then
+`set("a", 2)` — `node.props["a"]` is `2`. PB3. `set("a", 1)` then `set("b", 2)`
+— both keys present. PB4. `set("ns", { x: 1, y: 2 })` — namespaced object
+stored. PB5. `node.props` reflects the update immediately after `set` completes
+(N13).
+
+### 4.2 Core: update
+
+PB6. `set("n", 1)` then `update("n", (v) => v + 1)` — `node.props["n"]` is `2`.
+PB7. `update("missing", (v) => v ?? 0)` — `fn` receives `undefined`, stores `0`.
+PB8. `update` is atomic: `node.props` reflects the new value after `update`
+completes.
+
+### 4.3 Core: unset
+
+PB9. `set("a", 1)` then `unset("a")` — `"a"` is no longer in `node.props`. PB10.
+`unset("nonexistent")` — no error, no notification (C9, C10).
+
+### 4.4 Core: Read-Only Enforcement
+
+PB11. Direct assignment to `node.props["x"] = 1` MUST NOT modify the property
+bag OR MUST throw (N12). Implementations SHOULD freeze or proxy `props`.
+
+---
+
+## 5. Child Ordering
+
+### 5.1 Core: Insertion Order
+
+CO1. Append A, B, C. `children` yields A, B, C. CO2. Append A, B, C. Remove B.
+`children` yields A, C. CO3. Append A, B. Remove A. `children` yields B.
+
+### 5.2 Core: Custom Sort
+
+CO4. Set sort function `(a, b) => cmp(a.props.priority, b.props.priority)`.
+Append A (priority=3), B (priority=1), C (priority=2). `children` yields B, C,
+A. CO5. With active sort, change B's priority from 1 to 10. Next iteration of
+`children` yields C, A, B (sort applied at read time, N18). CO6. Clear sort
+function via `sort(undefined)`. `children` reverts to insertion order: A, B, C.
+
+### 5.3 Core: Sort Notification
+
+CO7. Install a sort function. Stream emits notification (N19, C20). CO8. Clear a
+sort function. Stream emits notification (N19, C20).
+
+### 5.4 Extended: Sort Edge Cases
+
+CO9. Sort function that throws — behavior is implementation-defined but MUST NOT
+corrupt the children list. CO10. Sort with equal comparisons — insertion order
+is the tiebreaker (N16).
+
+---
+
+## 5b. useNode Operation
+
+### 5b.1 Core: Node Resolution
+
+UN1. `useNode()` in the root component returns the root node.
+`node === tree.root`.
+
+UN2. `useNode()` inside a child component returns the child node. `node.name`
+matches the child's name and `node !== tree.root`.
+
+UN3. `useNode()` via `node.eval()` returns the eval target node.
+
+### 5b.2 Core: Middleware Interception
+
+UN4. Parent installs middleware on `useNode`. Child calls `useNode()`. Parent
+middleware intercepts and may substitute a different node reference.
+
+---
+
+## 6. Node Context API Middleware
+
+### 6.1 Core: Interception
+
+MW1. Parent installs middleware on `set`. Child calls `set("x", 1)`. Parent
+middleware receives `["x", 1]` and `next`. Parent calls `next("x", 1)`.
+`child.props["x"]` is `1`.
+
+MW2. Parent middleware transforms: receives `["x", 1]`, calls `next("x", 2)`.
+`child.props["x"]` is `2`.
+
+MW3. Parent middleware rejects: receives `["x", 1]`, does NOT call `next`.
+`child.props["x"]` is unchanged.
+
+MW4. Middleware on `update` receives the `[key, fn]` tuple.
+
+MW5. Middleware on `append` can intercept child creation.
+
+MW6. Middleware on `sort` can intercept sort installation.
+
+### 6.2 Core: Scope Isolation
+
+MW7. Middleware installed in node A's scope does NOT intercept operations in
+node A's sibling B.
+
+MW8. Middleware installed in a parent's scope intercepts operations in all
+descendants (scope inheritance).
+
+MW9. After `remove()` on a node, its middleware is inactive. Subsequent
+operations in sibling nodes are not affected.
+
+---
+
+## 7. Event Dispatch
+
+### 7.1 Core: Basic Dispatch
+
+ED1. Dispatch an event. Root middleware receives it. Returns
+`{ ok: true, value: true }`. Result indicates handled.
+
+ED2. Dispatch an event with no middleware installed beyond the default handler.
+Result is `{ ok: false }` — unhandled.
+
+ED3. Dispatch two events sequentially. Each is processed in order. The second
+event's middleware sees state changes from the first.
+
+### 7.2 Core: Error Capture
+
+ED4. Middleware throws an exception. Result is `{ ok: false, error }`. The tree
+is still alive. Subsequent dispatches work normally.
+
+ED5. Middleware throws in a child scope. The error is captured. The child node
+is NOT destroyed (the dispatch loop catches the error, the scope survives).
+
+### 7.3 Core: Middleware Composition
+
+ED6. Root installs dispatch middleware. Child installs dispatch middleware.
+Event flows through root middleware first (outermost), then child middleware.
+
+ED7. Root middleware can short-circuit by not calling `next`. Child middleware
+never sees the event.
+
+ED8. Child middleware handles an event (returns handled result). Root
+middleware's `next` receives the child's result.
+
+### 7.4 Core: Sequential Processing
+
+ED9. Dispatch event A, then event B while A is still processing. B is queued. B
+is processed after A completes.
+
+ED10. Within one dispatch cycle, all property mutations are visible to
+subsequent middleware in the same chain.
+
+---
+
+## 8. Tree and Notification
+
+### 8.1 Core: Creation
+
+TN1. `createTree(root)` returns a Tree. `tree.root` is a Node.
+`tree.root.parent` is `undefined`.
+
+TN2. The root component runs before `createTree` returns (T6). Properties set
+during initialization are visible on `tree.root.props`.
+
+TN3. Middleware installed by the root component during initialization is active
+for the first dispatched event.
+
+### 8.2 Core: Notification Stream
+
+TN4. Subscribe to tree stream. Call `set` on any node. Stream emits `void`.
+
+TN5. Subscribe to tree stream. Call `append`. Stream emits `void`.
+
+TN6. Subscribe to tree stream. Call `remove`. Stream emits `void`.
+
+TN7. Within one dispatch cycle, call `set` three times on different nodes.
+Stream emits exactly ONE `void` (coalescing, T9).
+
+TN8. Within one dispatch cycle, call `set` and `append`. Stream emits exactly
+ONE `void` (T10).
+
+TN9. Dispatch an event whose middleware makes no property or structural changes.
+Stream MUST NOT emit (T8).
+
+### 8.3 Core: Initialization Notification
+
+TN10. Root component calls `set` during initialization (before any dispatch).
+Stream emits a notification (T11).
+
+### 8.4 Core: Lifecycle
+
+TN11. Destroy the tree (exit its Effection scope). The output stream closes.
+
+TN12. Dispatch an event after the tree is destroyed. No error, no effect (T14).
+
+---
+
+## 9. Component
+
+### 9.1 Core: Execution
+
+CP1. A component's generator runs when the node is created.
+
+CP2. A component that returns without looping — the node remains alive (P4).
+Properties set during execution persist. Middleware installed during execution
+remains active.
+
+CP3. A component in an infinite loop continues reacting until the node is
+removed.
+
+CP4. A component can set properties, install middleware, and append children
+before returning or entering a loop (P6).
+
+### 9.2 Core: Cancellation
+
+CP5. When a node is removed, the component's operation is cancelled. `finally`
+blocks in the component run (Effection structured concurrency).
+
+---
+
+## 10. Invariant Verification
+
+### 10.1 Core
+
+IV1. After any sequence of operations, the node tree and scope tree are
+isomorphic (I1). Verify by walking both trees and comparing structure.
+
+IV2. After removing a subtree, no orphaned nodes exist (I2). Verify that removed
+nodes do not appear in any `children` iteration.
+
+IV3. After removing a node, its middleware is inactive (I3). Verify by
+dispatching an event and confirming the removed node's middleware is not called.
+
+IV4. Two concurrent dispatches do not interleave (I4). Verify by dispatching two
+events that each set a property, and confirming the final state reflects
+sequential execution.
+
+IV5. After a notification, `node.props` and `node.children` reflect the final
+state of all mutations from the triggering cycle (I5).
+
+IV6. No invalid JsonValue can exist in any node's property bag at any time (I6).
+
+IV7. Node fields are read-only (I8). Direct mutation of `id`, `name`, `props`,
+`children`, or `parent` is rejected or has no effect.
+
+---
+
+## 11. Explicit Non-Tests
+
+The following scenarios are explicitly NOT tested because they correspond to
+deferred extensions (§11 of the spec):
+
+NT1. JSX transform producing `append` calls. NT2. Key-based reconciliation of
+children. NT3. Computed/derived properties. NT4. Tree query operations. NT5.
+DOM-style event bubbling or capturing phases. NT6. Structured change records on
+the output stream. NT7. Application-level demux middleware (tested by apps).
+NT8. Event helper functions like `onkeydown` (app-level). NT9. Explicit index
+ordering mode.
diff --git a/packages/freedom/src/index.ts b/packages/freedom/src/index.ts
new file mode 100644
index 0000000..945209d
--- /dev/null
+++ b/packages/freedom/src/index.ts
@@ -0,0 +1 @@
+export * from "./lib/mod.ts";
diff --git a/packages/freedom/src/lib/dispatch.ts b/packages/freedom/src/lib/dispatch.ts
new file mode 100644
index 0000000..d14286d
--- /dev/null
+++ b/packages/freedom/src/lib/dispatch.ts
@@ -0,0 +1,24 @@
+// oxlint-disable require-yield
+import type { Api, Operation, Result } from "effection";
+import { createApi } from "effection/experimental";
+import type { Node } from "./types.ts";
+import { TreeContext } from "./state.ts";
+
+export interface Dispatch {
+  dispatch(event: unknown): Operation<Result<true>>;
+  getNodeById(id: string): Operation<Node | undefined>;
+}
+
+export const DispatchApi: Api<Dispatch> = createApi<Dispatch>(
+  "freedom:dispatch",
+  {
+    *dispatch(_event: unknown): Operation<Result<true>> {
+      return { ok: false, error: new Error("unhandled") };
+    },
+
+    *getNodeById(id: string): Operation<Node | undefined> {
+      const tree = yield* TreeContext.expect();
+      return tree.nodes.get(id);
+    },
+  },
+);
diff --git a/packages/freedom/src/lib/focus.ts b/packages/freedom/src/lib/focus.ts
new file mode 100644
index 0000000..d0a85b9
--- /dev/null
+++ b/packages/freedom/src/lib/focus.ts
@@ -0,0 +1,195 @@
+// oxlint-disable bombshell-dev/no-generic-error
+
+//TODO: export as freedom/focus
+import { createContext } from "effection";
+import type { Node } from "./types.ts";
+import { NodeApi } from "./node.ts";
+
+// A pushed focus root: the boundary cycling is trapped within, the focus to
+// restore, and the callback to notify when it is popped (§12).
+interface FocusEntry {
+  node: Node;
+  restore: Node | undefined;
+  callback?: (value: unknown) => void;
+}
+
+export type PopFocus = (value?: unknown) => void;
+
+// The focus stack lives on the tree root's scope, not module state (§12, FS2).
+const FocusStackContext = createContext<FocusEntry[]>("freedom:focus-stack");
+
+function findRoot(node: Node): Node {
+  let n = node;
+  while (n.parent) {
+    n = n.parent;
+  }
+  return n;
+}
+
+// The tree's focus stack, lazily created on the root scope on first use.
+function focusStack(node: Node): FocusEntry[] {
+  const root = findRoot(node);
+  let stack = root.scope.get(FocusStackContext);
+  if (!stack) {
+    stack = [];
+    root.scope.set(FocusStackContext, stack);
+  }
+  return stack;
+}
+
+// The active focus root: the top of the stack, or the tree root (§12.3).
+function focusRoot(node: Node): Node {
+  const stack = focusStack(node);
+  return stack.length > 0 ? stack[stack.length - 1].node : findRoot(node);
+}
+
+function focusChain(node: Node): Node[] {
+  const result: Node[] = [];
+  if ("focused" in node.props) {
+    result.push(node);
+  }
+  for (const child of node.children) {
+    result.push(...focusChain(child));
+  }
+  return result;
+}
+
+function successorOf(node: Node): Node | undefined {
+  const nodes = focusChain(focusRoot(node));
+  if (nodes.length <= 1) {
+    return undefined;
+  }
+  const idx = nodes.indexOf(node);
+  if (idx === -1) {
+    return undefined;
+  }
+  return nodes[(idx + 1) % nodes.length];
+}
+
+// TODO nename -> setFocusable
+export function focusable(node: Node): void {
+  if (!("focused" in node.props)) {
+    node.set("focused", false);
+  }
+}
+
+// TODO: rename -> getCurrentFocus()
+export function current(node: Node): Node {
+  const root = focusRoot(node);
+  return focusChain(root).find((n) => n.props.focused === true) ?? root;
+}
+
+export function advance(node: Node): void {
+  const nodes = focusChain(focusRoot(node));
+  if (nodes.length <= 1) {
+    return;
+  }
+  const idx = nodes.findIndex((n) => n.props.focused === true);
+  if (idx === -1) {
+    return;
+  }
+  nodes[idx].set("focused", false);
+  nodes[(idx + 1) % nodes.length].set("focused", true);
+}
+
+export function retreat(node: Node): void {
+  const nodes = focusChain(focusRoot(node));
+  if (nodes.length <= 1) {
+    return;
+  }
+  const idx = nodes.findIndex((n) => n.props.focused === true);
+  if (idx === -1) {
+    return;
+  }
+  nodes[idx].set("focused", false);
+  nodes[(idx - 1 + nodes.length) % nodes.length].set("focused", true);
+}
+
+export function focus(target: Node): void {
+  if (!("focused" in target.props)) {
+    throw new Error("Cannot focus a non-focusable node");
+  }
+  if (!focusChain(focusRoot(target)).includes(target)) {
+    throw new Error("Cannot focus a node outside the active focus root");
+  }
+  if (target.props.focused === true) {
+    return;
+  }
+  const old = focusChain(findRoot(target)).find((n) => n.props.focused === true);
+  if (old) {
+    old.set("focused", false);
+  }
+  target.set("focused", true);
+}
+
+export function useFocus(node: Node): void {
+  const first = focusChain(node).find((n) => n !== node);
+  if (first) {
+    focus(first);
+  }
+  node.scope.around(NodeApi, {
+    remove([target], next) {
+      if (target.props.focused === true) {
+        const successor = successorOf(target);
+        if (successor && successor !== target) {
+          focus(successor);
+        }
+      }
+      return next(target);
+    },
+  });
+}
+
+// Push `node` as the active focus root: cycling is trapped within its focusable
+// descendants (§12.4). Returns the bound pop (§12.5).
+export function focusPush(
+  node: Node,
+  callback?: (value: unknown) => void,
+): PopFocus {
+  const stack = focusStack(node);
+  const restore = focusChain(focusRoot(node)).find(
+    (n) => n.props.focused === true,
+  );
+  const entry: FocusEntry = { node, restore, callback };
+  stack.push(entry);
+
+  const first = focusChain(node).find((n) => n !== node);
+  if (first) {
+    focus(first); // seed inside; clears the pre-push focus (FS6)
+  } else if (restore) {
+    restore.set("focused", false); // empty container: nothing focused (FS6)
+  }
+
+  return (value?: unknown) => {
+    if (stack[stack.length - 1] !== entry) {
+      throw new Error("focus pop out of order (unbalanced push/pop)");
+    }
+    stack.pop();
+    restoreFocus(node, restore);
+    if (callback) {
+      callback(value);
+    }
+  };
+}
+
+// Restore focus after a pop: the remembered node if still valid, else the first
+// focusable descendant of the now-active root, else clear any residual focus.
+function restoreFocus(node: Node, restore: Node | undefined): void {
+  const root = focusRoot(node);
+  const chain = focusChain(root);
+  if (restore && chain.includes(restore)) {
+    focus(restore);
+  } else {
+    const first = chain.find((n) => n !== root);
+    if (first) {
+      focus(first);
+    } else {
+      const residual = focusChain(findRoot(node)).find(
+        (n) => n.props.focused === true,
+      );
+      if (residual) {
+        residual.set("focused", false);
+      }
+    }
+  }
+}
diff --git a/packages/freedom/src/lib/mod.ts b/packages/freedom/src/lib/mod.ts
new file mode 100644
index 0000000..504c542
--- /dev/null
+++ b/packages/freedom/src/lib/mod.ts
@@ -0,0 +1,25 @@
+export type {
+  JsonValue,
+  Node,
+  NodeData,
+  NodeDataKey,
+  Root,
+} from "./types.ts";
+
+export { createNodeData } from "./types.ts";
+
+export { createRoot } from "./root.ts";
+export { NodeApi } from "./node.ts";
+
+export { type Dispatch, DispatchApi } from "./dispatch.ts";
+
+export {
+  advance,
+  current,
+  focus,
+  focusable,
+  focusPush,
+  type PopFocus,
+  retreat,
+  useFocus,
+} from "./focus.ts";
diff --git a/packages/freedom/src/lib/node.ts b/packages/freedom/src/lib/node.ts
new file mode 100644
index 0000000..6647c68
--- /dev/null
+++ b/packages/freedom/src/lib/node.ts
@@ -0,0 +1,194 @@
+// oxlint-disable bombshell-dev/no-generic-error
+// oxlint-disable max-params
+import {
+  type Context,
+  createContext,
+  createScope,
+  type Scope,
+} from "effection";
+import { createApi } from "effection/experimental";
+import type {
+  CreateChildOptions,
+  JsonValue,
+  Node,
+  NodeData,
+  NodeDataKey,
+} from "./types.ts";
+import { TreeContext } from "./state.ts";
+import { validateJsonValue } from "./validate.ts";
+
+class NodeDataImpl implements NodeData {
+  _map: Map<symbol, unknown> = new Map();
+
+  get<T>(key: NodeDataKey<T>): T | undefined {
+    return this._map.get(key.symbol) as T | undefined;
+  }
+
+  set<T>(key: NodeDataKey<T>, value: T): void {
+    this._map.set(key.symbol, value);
+  }
+
+  expect<T>(key: NodeDataKey<T>): T {
+    const val = this._map.get(key.symbol);
+    if (val !== undefined) {
+      return val as T;
+    } else if (key.defaultValue !== undefined) {
+      return key.defaultValue;
+    } else {
+      throw new Error(`NodeData '${key.symbol.description}' not found`);
+    }
+  }
+}
+
+export class NodeImpl implements Node {
+  _props: Record<string, JsonValue> = {};
+  _children: Set<NodeImpl> = new Set();
+  _sortFn: ((a: Node, b: Node) => number) | undefined = undefined;
+  data: NodeData = new NodeDataImpl();
+  scope: Scope;
+  #dispose: () => Promise<void>;
+
+  constructor(
+    readonly id: string,
+    readonly name: string,
+    readonly _parent: NodeImpl | undefined,
+  ) {
+    const [scope, dispose] = createScope(_parent?.scope);
+    this.scope = scope;
+    this.#dispose = dispose;
+    scope.set(NodeContext, this);
+  }
+
+  get props(): Record<string, JsonValue> {
+    return Object.freeze({ ...this._props });
+  }
+
+  get children(): Iterable<Node> {
+    if (this._sortFn) {
+      const fn = this._sortFn;
+      const indexed = [...this._children].map((c, i) => [c, i] as const);
+      indexed.sort(([a, ai], [b, bi]) => {
+        const result = fn(a, b);
+        if (result !== 0) {
+          return result;
+        } else {
+          return ai - bi;
+        }
+      });
+      return indexed.map(([c]) => c);
+    } else {
+      return this._children;
+    }
+  }
+
+  get parent(): Node | undefined {
+    return this._parent;
+  }
+
+  get(key: string): JsonValue | undefined {
+    return NodeApi.invoke(this.scope, "get", [this, key]);
+  }
+
+  set(key: string, value: JsonValue): void {
+    NodeApi.invoke(this.scope, "set", [this, key, value]);
+  }
+
+  update(key: string, fn: (prev: JsonValue | undefined) => JsonValue): void {
+    NodeApi.invoke(this.scope, "update", [this, key, fn]);
+  }
+
+  unset(key: string): void {
+    NodeApi.invoke(this.scope, "unset", [this, key]);
+  }
+
+  createChild(name = "", options?: CreateChildOptions): Node {
+    return NodeApi.invoke(this.scope, "createChild", [this, name, options]);
+  }
+
+  sort(fn?: (a: Node, b: Node) => number): void {
+    NodeApi.invoke(this.scope, "sort", [this, fn]);
+  }
+
+  // Internal scope teardown — not on the public `Node` interface. Used by
+  // `remove` and by `root.destroy()`; disposing the scope cascades to all
+  // descendants. Removing a non-root node should go through `remove`, which also
+  // detaches and notifies.
+  destroy(): Promise<void> {
+    return this.#dispose();
+  }
+
+  remove(): Promise<void> {
+    return NodeApi.invoke(this.scope, "remove", [this]);
+  }
+}
+
+// Synchronous node mutation API. Core methods take the node first; interceptors
+// are installed per scope via `node.scope.around(NodeApi, ...)`.
+export const NodeApi = createApi("freedom:node", {
+  get(node: NodeImpl, key: string): JsonValue | undefined {
+    return node._props[key];
+  },
+  set(node: NodeImpl, key: string, value: JsonValue): void {
+    validateJsonValue(value);
+    node._props[key] = value;
+    node.scope.expect(TreeContext).markDirty();
+  },
+  update(
+    node: NodeImpl,
+    key: string,
+    fn: (prev: JsonValue | undefined) => JsonValue,
+  ): void {
+    const value = fn(node._props[key]);
+    validateJsonValue(value);
+    node._props[key] = value;
+    node.scope.expect(TreeContext).markDirty();
+  },
+  unset(node: NodeImpl, key: string): void {
+    if (key in node._props) {
+      delete node._props[key];
+      node.scope.expect(TreeContext).markDirty();
+    }
+  },
+  createChild(node: NodeImpl, name: string, options?: CreateChildOptions): Node {
+    const state = node.scope.expect(TreeContext);
+    const child = new NodeImpl(state.nextId(), name, node);
+    const before = options?.before;
+    if (before) {
+      if (!node._children.has(before as NodeImpl)) {
+        throw new Error("createChild: `before` is not a child of this node");
+      }
+      // Set has no positional insert, so rebuild it with `child` spliced in.
+      const reordered = new Set<NodeImpl>();
+      for (const existing of node._children) {
+        if (existing === before) {
+          reordered.add(child);
+        }
+        reordered.add(existing);
+      }
+      node._children = reordered;
+    } else {
+      node._children.add(child);
+    }
+    state.nodes.set(child.id, child);
+    state.markDirty();
+    return child;
+  },
+  sort(node: NodeImpl, fn: ((a: Node, b: Node) => number) | undefined): void {
+    node._sortFn = fn;
+    node.scope.expect(TreeContext).markDirty();
+  },
+  remove(node: NodeImpl): Promise<void> {
+    if (!node._parent) {
+      throw new Error("Cannot remove root node");
+    }
+    const state = node.scope.expect(TreeContext);
+    node._parent._children.delete(node);
+    state.nodes.delete(node.id);
+    state.markDirty();
+    return node.destroy();
+  },
+});
+
+export const NodeContext: Context<NodeImpl> = createContext<NodeImpl>(
+  "freedom:current-node",
+);
diff --git a/packages/freedom/src/lib/root.ts b/packages/freedom/src/lib/root.ts
new file mode 100644
index 0000000..062c2b4
--- /dev/null
+++ b/packages/freedom/src/lib/root.ts
@@ -0,0 +1,56 @@
+import { createQueue, createSignal } from "effection";
+import type { Root } from "./types.ts";
+import { NodeImpl } from "./node.ts";
+import { TreeContext, type TreeState } from "./state.ts";
+import { DispatchApi } from "./dispatch.ts";
+
+export function createRoot(): Root {
+  const output = createSignal<void, never>();
+  // Internal, always-drained buffer: createRoot is synchronous, so the drain
+  // loop subscribes asynchronously — a Queue keeps events dispatched before the
+  // loop runs from being lost (bounded, since the loop drains immediately).
+  const events = createQueue<unknown, void>();
+
+  let counter = 0;
+  const state: TreeState = {
+    dirty: false,
+    output,
+    nodes: new Map(),
+    nextId() {
+      return `node-${++counter}`;
+    },
+    markDirty() {
+      state.dirty = true;
+    },
+  };
+
+  const node = new NodeImpl(state.nextId(), "", undefined);
+  node.scope.set(TreeContext, state);
+  state.nodes.set(node.id, node);
+
+  // Dispatch loop: drain events through the demux middleware chain.
+  node.scope.run(function* () {
+    while (true) {
+      const next = yield* events.next();
+      if (next.done) {
+        break;
+      }
+      state.dirty = false;
+      yield* DispatchApi.operations.dispatch(next.value);
+      if (state.dirty) {
+        output.send();
+      }
+    }
+  });
+
+  return {
+    node,
+    dispatch(event) {
+      events.add(event);
+    },
+    [Symbol.iterator]: output[Symbol.iterator],
+    destroy() {
+      return node.destroy();
+    },
+  };
+}
diff --git a/packages/freedom/src/lib/state.ts b/packages/freedom/src/lib/state.ts
new file mode 100644
index 0000000..455d1d9
--- /dev/null
+++ b/packages/freedom/src/lib/state.ts
@@ -0,0 +1,12 @@
+import { createContext, type Signal } from "effection";
+import type { NodeImpl } from "./node.ts";
+
+export interface TreeState {
+  dirty: boolean;
+  output: Signal<void, never>;
+  nodes: Map<string, NodeImpl>;
+  nextId(): string;
+  markDirty(): void;
+}
+
+export const TreeContext = createContext<TreeState>("freedom:tree");
diff --git a/packages/freedom/src/lib/types.ts b/packages/freedom/src/lib/types.ts
new file mode 100644
index 0000000..f721639
--- /dev/null
+++ b/packages/freedom/src/lib/types.ts
@@ -0,0 +1,54 @@
+import type { Scope, Stream } from "effection";
+
+export type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | JsonValue[]
+  | { [key: string]: JsonValue };
+
+export interface NodeDataKey<T> {
+  readonly symbol: symbol;
+  readonly defaultValue?: T;
+}
+
+export function createNodeData<T>(
+  name: string,
+  defaultValue?: T,
+): NodeDataKey<T> {
+  return { symbol: Symbol(name), defaultValue };
+}
+
+export interface NodeData {
+  get<T>(key: NodeDataKey<T>): T | undefined;
+  set<T>(key: NodeDataKey<T>, value: T): void;
+  expect<T>(key: NodeDataKey<T>): T;
+}
+
+export interface CreateChildOptions {
+  before?: Node;
+}
+
+export interface Node {
+  readonly id: string;
+  readonly name: string;
+  readonly props: Record<string, JsonValue>;
+  readonly children: Iterable<Node>;
+  readonly parent: Node | undefined;
+  readonly data: NodeData;
+  readonly scope: Scope;
+  get(key: string): JsonValue | undefined;
+  set(key: string, value: JsonValue): void;
+  update(key: string, fn: (prev: JsonValue | undefined) => JsonValue): void;
+  unset(key: string): void;
+  createChild(name?: string, options?: CreateChildOptions): Node;
+  sort(fn?: (a: Node, b: Node) => number): void;
+  remove(): Promise<void>;
+}
+
+export interface Root extends Stream<void, never> {
+  node: Node;
+  dispatch(event: unknown): void;
+  destroy(): Promise<void>;
+}
diff --git a/packages/freedom/src/lib/validate.ts b/packages/freedom/src/lib/validate.ts
new file mode 100644
index 0000000..d14c524
--- /dev/null
+++ b/packages/freedom/src/lib/validate.ts
@@ -0,0 +1,56 @@
+// oxlint-disable bombshell-dev/no-generic-error
+import type { JsonValue } from "./types.ts";
+
+export function validateJsonValue(value: unknown): asserts value is JsonValue {
+  if (value === undefined) {
+    throw new Error("undefined is not a valid JsonValue");
+  }
+  if (typeof value === "number") {
+    if (Number.isNaN(value)) {
+      throw new Error("NaN is not a valid JsonValue");
+    }
+    if (!Number.isFinite(value)) {
+      throw new Error(`${value} is not a valid JsonValue`);
+    }
+    return;
+  }
+  if (
+    typeof value === "string" || typeof value === "boolean" || value === null
+  ) {
+    return;
+  }
+  if (typeof value === "function") {
+    throw new Error("functions are not valid JsonValues");
+  }
+  if (typeof value === "symbol") {
+    throw new Error("symbols are not valid JsonValues");
+  }
+  if (typeof value === "bigint") {
+    throw new Error("bigints are not valid JsonValues");
+  }
+  if (value instanceof Date) {
+    throw new Error("Date instances are not valid JsonValues");
+  }
+  if (value instanceof Map) {
+    throw new Error("Map instances are not valid JsonValues");
+  }
+  if (value instanceof Set) {
+    throw new Error("Set instances are not valid JsonValues");
+  }
+  if (value instanceof RegExp) {
+    throw new Error("RegExp instances are not valid JsonValues");
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      validateJsonValue(item);
+    }
+    return;
+  }
+  if (typeof value === "object" && value !== null) {
+    for (const key of Object.keys(value)) {
+      validateJsonValue((value as Record<string, unknown>)[key]);
+    }
+    return;
+  }
+  throw new Error(`${String(value)} is not a valid JsonValue`);
+}
diff --git a/packages/freedom/test/focus.test.ts b/packages/freedom/test/focus.test.ts
new file mode 100644
index 0000000..8247e36
--- /dev/null
+++ b/packages/freedom/test/focus.test.ts
@@ -0,0 +1,418 @@
+import { describe, expect, it } from "../test/suite.ts";
+import {
+  advance,
+  createRoot,
+  current,
+  focus,
+  focusable,
+  focusPush,
+  retreat,
+  useFocus,
+} from "../src/index.ts";
+
+describe("Focus installation", () => {
+  it("seeds the first focusable descendant", () => {
+    const root = createRoot();
+    const a = root.node.createChild("A");
+    focusable(a);
+    focusable(root.node.createChild("B"));
+    useFocus(root.node);
+    expect(current(root.node)).toBe(a);
+    expect(a.props.focused).toBe(true);
+    root.destroy();
+  });
+
+  it("focuses nothing on an empty container; current falls back to root", () => {
+    const root = createRoot();
+    useFocus(root.node);
+    expect(current(root.node)).toBe(root.node);
+    expect(root.node.props.focused).toBe(undefined);
+    root.destroy();
+  });
+
+  it("does not enroll root in the ring", () => {
+    const root = createRoot();
+    focusable(root.node.createChild("A"));
+    focusable(root.node.createChild("B"));
+    useFocus(root.node); // seeds A
+    const names: string[] = [];
+    for (let i = 0; i < 3; i++) {
+      names.push(current(root.node).name);
+      advance(root.node);
+    }
+    expect(names).toEqual(["A", "B", "A"]); // wraps A->B->A; root never appears
+    root.destroy();
+  });
+
+  it("escape hatch: explicit focusable(root) keeps root in the ring", () => {
+    const root = createRoot();
+    focusable(root.node); // explicit enrollment
+    const a = root.node.createChild("A");
+    focusable(a);
+    useFocus(root.node); // seeds A (first descendant, skipping root)
+    expect(current(root.node)).toBe(a);
+    advance(root.node); // A -> root (wrap now includes root)
+    expect(current(root.node)).toBe(root.node);
+    root.destroy();
+  });
+});
+
+describe("focusable()", () => {
+  it("sets focused:false on the node", () => {
+    const root = createRoot();
+    const child = root.node.createChild("child");
+    focusable(child);
+    expect(child.props.focused).toBe(false);
+    root.destroy();
+  });
+
+  it("is a no-op on an already-focusable node", () => {
+    const root = createRoot();
+    const child = root.node.createChild("child");
+    focusable(child);
+    focusable(child);
+    expect(child.props.focused).toBe(false);
+    root.destroy();
+  });
+
+  it("a node without focusable is skipped by the chain", () => {
+    const root = createRoot();
+    root.node.createChild("skip"); // not focusable
+    const here = root.node.createChild("here");
+    focusable(here);
+    useFocus(root.node); // seeds "here", skipping "skip"
+    expect(current(root.node).name).toEqual("here");
+    root.destroy();
+  });
+});
+
+describe("Focus chain", () => {
+  it("depth-first order, flat children", () => {
+    const root = createRoot();
+    for (const name of ["A", "B", "C"]) {
+      focusable(root.node.createChild(name));
+    }
+    useFocus(root.node); // seeds A
+    const names: string[] = [];
+    for (let i = 0; i < 4; i++) {
+      names.push(current(root.node).name);
+      advance(root.node);
+    }
+    expect(names).toEqual(["A", "B", "C", "A"]);
+    root.destroy();
+  });
+
+  it("depth-first order, nested children", () => {
+    const root = createRoot();
+    const a = root.node.createChild("A");
+    focusable(a);
+    focusable(a.createChild("A1"));
+    focusable(root.node.createChild("B"));
+    useFocus(root.node); // seeds A
+    const names: string[] = [];
+    for (let i = 0; i < 4; i++) {
+      names.push(current(root.node).name);
+      advance(root.node);
+    }
+    expect(names).toEqual(["A", "A1", "B", "A"]);
+    root.destroy();
+  });
+});
+
+describe("advance()", () => {
+  it("moves focus forward", () => {
+    const root = createRoot();
+    const a = root.node.createChild("A");
+    focusable(a);
+    const b = root.node.createChild("B");
+    focusable(b);
+    useFocus(root.node); // seeds A
+    expect(a.props.focused).toBe(true);
+    advance(root.node); // A -> B
+    expect(a.props.focused).toBe(false);
+    expect(b.props.focused).toBe(true);
+    root.destroy();
+  });
+
+  it("wraps from last to first", () => {
+    const root = createRoot();
+    const a = root.node.createChild("A");
+    focusable(a);
+    const b = root.node.createChild("B");
+    focusable(b);
+    useFocus(root.node); // seeds A
+    advance(root.node); // A -> B
+    advance(root.node); // B -> A (wrap)
+    expect(current(root.node)).toBe(a);
+    root.destroy();
+  });
+
+  it("single focusable node is a no-op", () => {
+    const root = createRoot();
+    const a = root.node.createChild("A");
+    focusable(a);
+    useFocus(root.node); // seeds A
+    advance(root.node); // no-op (chain length 1)
+    expect(current(root.node)).toBe(a);
+    root.destroy();
+  });
+
+  it("nothing focused is a no-op", () => {
+    const root = createRoot();
+    useFocus(root.node); // empty container
+    advance(root.node);
+    expect(current(root.node)).toBe(root.node);
+    root.destroy();
+  });
+});
+
+describe("retreat()", () => {
+  it("moves focus backward", () => {
+    const root = createRoot();
+    focusable(root.node.createChild("A"));
+    focusable(root.node.createChild("B"));
+    useFocus(root.node); // seeds A
+    advance(root.node); // A -> B
+    expect(current(root.node).name).toEqual("B");
+    retreat(root.node); // B -> A
+    expect(current(root.node).name).toEqual("A");
+    root.destroy();
+  });
+
+  it("wraps from first to last", () => {
+    const root = createRoot();
+    focusable(root.node.createChild("A"));
+    const b = root.node.createChild("B");
+    focusable(b);
+    useFocus(root.node); // seeds A
+    retreat(root.node); // A -> B (wrap to last)
+    expect(current(root.node)).toBe(b);
+    root.destroy();
+  });
+});
+
+describe("focus(node)", () => {
+  it("explicitly focuses a node", () => {
+    const root = createRoot();
+    const a = root.node.createChild("A");
+    focusable(a);
+    const b = root.node.createChild("B");
+    focusable(b);
+    useFocus(root.node); // seeds A
+    focus(b);
+    expect(current(root.node)).toBe(b);
+    expect(a.props.focused).toBe(false);
+    expect(b.props.focused).toBe(true);
+    root.destroy();
+  });
+
+  it("throws on a non-focusable node", () => {
+    const root = createRoot();
+    const child = root.node.createChild("nope");
+    useFocus(root.node);
+    expect(() => focus(child)).toThrow();
+    root.destroy();
+  });
+
+  it("is a no-op when already focused", () => {
+    const root = createRoot();
+    const a = root.node.createChild("A");
+    focusable(a);
+    useFocus(root.node); // seeds A
+    focus(a); // already focused -> no-op
+    expect(current(root.node)).toBe(a);
+    root.destroy();
+  });
+});
+
+describe("Focused node removal", () => {
+  it("removing the focused node advances focus", async () => {
+    const root = createRoot();
+    const a = root.node.createChild("A");
+    focusable(a);
+    focusable(root.node.createChild("B"));
+    useFocus(root.node); // seeds A
+    expect(a.props.focused).toBe(true);
+    await a.remove();
+    expect(current(root.node).name).toEqual("B");
+    root.destroy();
+  });
+
+  it("removing a non-focused node does not move focus", async () => {
+    const root = createRoot();
+    focusable(root.node.createChild("A"));
+    const b = root.node.createChild("B");
+    focusable(b);
+    useFocus(root.node); // seeds A
+    await b.remove();
+    expect(current(root.node).name).toEqual("A");
+    root.destroy();
+  });
+});
+
+describe("Focus stack (§12)", () => {
+  it("push seeds the first focusable descendant of the pushed node", () => {
+    const root = createRoot();
+    focusable(root.node.createChild("A"));
+    const modal = root.node.createChild("modal");
+    const m1 = modal.createChild("m1");
+    focusable(m1);
+    focusable(modal.createChild("m2"));
+    useFocus(root.node); // seeds A
+    focusPush(modal);
+    expect(current(root.node)).toBe(m1);
+    root.destroy();
+  });
+
+  it("forward cycling is contained within the pushed node", () => {
+    const root = createRoot();
+    focusable(root.node.createChild("A"));
+    focusable(root.node.createChild("B"));
+    const modal = root.node.createChild("modal");
+    focusable(modal.createChild("m1"));
+    focusable(modal.createChild("m2"));
+    useFocus(root.node);
+    focusPush(modal); // seeds m1
+    const names: string[] = [];
+    for (let i = 0; i < 4; i++) {
+      names.push(current(root.node).name);
+      advance(root.node);
+    }
+    expect(names).toEqual(["m1", "m2", "m1", "m2"]); // never A/B
+    root.destroy();
+  });
+
+  it("backward cycling is contained within the pushed node", () => {
+    const root = createRoot();
+    focusable(root.node.createChild("A"));
+    const modal = root.node.createChild("modal");
+    focusable(modal.createChild("m1"));
+    focusable(modal.createChild("m2"));
+    useFocus(root.node);
+    focusPush(modal); // seeds m1
+    retreat(root.node); // m1 -> m2 (wrap within modal)
+    expect(current(root.node).name).toEqual("m2");
+    retreat(root.node); // m2 -> m1
+    expect(current(root.node).name).toEqual("m1");
+    root.destroy();
+  });
+
+  it("pop restores focus to the pre-push node", () => {
+    const root = createRoot();
+    focusable(root.node.createChild("A"));
+    const b = root.node.createChild("B");
+    focusable(b);
+    const modal = root.node.createChild("modal");
+    focusable(modal.createChild("m1"));
+    useFocus(root.node); // seeds A
+    advance(root.node); // A -> B; B is the pre-push focus
+    const pop = focusPush(modal); // seeds m1
+    expect(current(root.node).name).toEqual("m1");
+    pop();
+    expect(current(root.node)).toBe(b); // restored
+    root.destroy();
+  });
+
+  it("pop invokes the callback once, with the value, after focus is restored", () => {
+    const root = createRoot();
+    focusable(root.node.createChild("A"));
+    const modal = root.node.createChild("modal");
+    focusable(modal.createChild("m1"));
+    useFocus(root.node); // seeds A
+    const calls: Array<{ value: unknown; focused: string }> = [];
+    const pop = focusPush(modal, (value) => {
+      calls.push({ value, focused: current(root.node).name });
+    });
+    pop("4242");
+    expect(calls).toEqual([{ value: "4242", focused: "A" }]); // restore happened first
+    root.destroy();
+  });
+
+  it("focus() on a node outside the active focus root throws", () => {
+    const root = createRoot();
+    const a = root.node.createChild("A");
+    focusable(a);
+    const modal = root.node.createChild("modal");
+    focusable(modal.createChild("m1"));
+    useFocus(root.node);
+    focusPush(modal);
+    expect(() => focus(a)).toThrow(); // A is outside the modal
+    root.destroy();
+  });
+
+  it("focus() on a node inside the active focus root works", () => {
+    const root = createRoot();
+    focusable(root.node.createChild("A"));
+    const modal = root.node.createChild("modal");
+    focusable(modal.createChild("m1"));
+    const m2 = modal.createChild("m2");
+    focusable(m2);
+    useFocus(root.node);
+    focusPush(modal); // seeds m1
+    focus(m2);
+    expect(current(root.node)).toBe(m2);
+    root.destroy();
+  });
+
+  it("popping the same push twice is an unbalanced-pop error", () => {
+    const root = createRoot();
+    const modal = root.node.createChild("modal");
+    focusable(modal.createChild("m1"));
+    useFocus(root.node);
+    const pop = focusPush(modal);
+    pop();
+    expect(() => pop()).toThrow(); // already popped
+    root.destroy();
+  });
+
+  it("nesting: inner cycling is contained; popping inner returns to outer containment", () => {
+    const root = createRoot();
+    focusable(root.node.createChild("A"));
+    const outer = root.node.createChild("outer");
+    focusable(outer.createChild("o1"));
+    focusable(outer.createChild("o2"));
+    const inner = outer.createChild("inner");
+    focusable(inner.createChild("i1"));
+    focusable(inner.createChild("i2"));
+    useFocus(root.node); // seeds A
+    focusPush(outer); // seeds o1
+    const popInner = focusPush(inner); // seeds i1
+    const innerNames: string[] = [];
+    for (let i = 0; i < 3; i++) {
+      innerNames.push(current(root.node).name);
+      advance(root.node);
+    }
+    expect(innerNames).toEqual(["i1", "i2", "i1"]); // contained to inner
+    popInner();
+    expect(current(root.node).name).toEqual("o1"); // back inside outer
+    advance(root.node);
+    expect(current(root.node).name).toEqual("o2"); // outer containment
+    root.destroy();
+  });
+
+  it("current() falls back to the pushed node when it has no focusable descendant", () => {
+    const root = createRoot();
+    const a = root.node.createChild("A");
+    focusable(a);
+    const modal = root.node.createChild("modal"); // no focusable children
+    useFocus(root.node); // seeds A
+    focusPush(modal);
+    expect(current(root.node)).toBe(modal); // fallback to container
+    expect(a.props.focused).toBe(false); // pre-push focus cleared
+    root.destroy();
+  });
+
+  it("removing the focused node keeps focus within the container", async () => {
+    const root = createRoot();
+    focusable(root.node.createChild("A"));
+    const modal = root.node.createChild("modal");
+    const m1 = modal.createChild("m1");
+    focusable(m1);
+    focusable(modal.createChild("m2"));
+    useFocus(root.node);
+    focusPush(modal); // seeds m1
+    await m1.remove();
+    expect(current(root.node).name).toEqual("m2"); // successor within modal
+    root.destroy();
+  });
+});
diff --git a/packages/freedom/test/freedom.test.ts b/packages/freedom/test/freedom.test.ts
new file mode 100644
index 0000000..8d74ee4
--- /dev/null
+++ b/packages/freedom/test/freedom.test.ts
@@ -0,0 +1,297 @@
+import { describe, expect, it } from "../test/suite.ts";
+import { run, sleep } from "effection";
+import { createRoot, DispatchApi, NodeApi } from "../src/index.ts";
+
+describe("JsonValue validation", () => {
+  it("accepts valid JsonValues", () => {
+    const root = createRoot();
+    const { node } = root;
+    node.set("str", "hello");
+    node.set("num", 42);
+    node.set("zero", 0);
+    node.set("neg", -1.5);
+    node.set("bool", true);
+    node.set("nil", null);
+    node.set("arr", [1, "a", true, null]);
+    node.set("obj", { a: 1, b: "c" });
+    node.set("nested", { nested: { deep: [1, 2] } });
+    expect(node.props["str"]).toEqual("hello");
+    expect(node.props["nil"]).toEqual(null);
+    expect(node.props["nested"]).toEqual({ nested: { deep: [1, 2] } });
+    root.destroy();
+  });
+
+  it("rejects undefined", () => {
+    const root = createRoot();
+    expect(() => root.node.set("k", undefined as unknown as null)).toThrow();
+    root.destroy();
+  });
+
+  it("rejects NaN and Infinity", () => {
+    const root = createRoot();
+    for (const val of [NaN, Infinity, -Infinity]) {
+      expect(() => root.node.set("k", val)).toThrow();
+    }
+    root.destroy();
+  });
+
+  it("rejects non-JSON types", () => {
+    const root = createRoot();
+    for (const val of [() => {}, Symbol(), new Date(), new Map()]) {
+      expect(() => root.node.set("k", val as unknown as null)).toThrow();
+    }
+    root.destroy();
+  });
+
+  it("validates update return values", () => {
+    const root = createRoot();
+    root.node.set("n", 1);
+    root.node.update("n", () => 42);
+    expect(root.node.props["n"]).toEqual(42);
+    expect(() => root.node.update("n", () => undefined as unknown as number))
+      .toThrow();
+    root.destroy();
+  });
+});
+
+describe("Property bag", () => {
+  it("set replaces, get reads", () => {
+    const root = createRoot();
+    const { node } = root;
+    node.set("a", 1);
+    node.set("a", 2);
+    node.set("b", 2);
+    expect(node.get("a")).toEqual(2);
+    expect(node.props["b"]).toEqual(2);
+    root.destroy();
+  });
+
+  it("update transforms", () => {
+    const root = createRoot();
+    root.node.set("n", 1);
+    root.node.update("n", (v) => (v as number) + 1);
+    expect(root.node.props["n"]).toEqual(2);
+    root.destroy();
+  });
+
+  it("unset removes the key", () => {
+    const root = createRoot();
+    root.node.set("a", 1);
+    root.node.unset("a");
+    expect("a" in root.node.props).toBe(false);
+    root.destroy();
+  });
+
+  it("unset of a missing key is a no-op", () => {
+    const root = createRoot();
+    expect(() => root.node.unset("nope")).not.toThrow();
+    root.destroy();
+  });
+
+  it("props is read-only", () => {
+    const root = createRoot();
+    root.node.set("x", 1);
+    expect(() => {
+      (root.node.props as Record<string, number>)["x"] = 2;
+    }).toThrow();
+    root.destroy();
+  });
+});
+
+describe("Children and ordering", () => {
+  it("createChild appends in insertion order", () => {
+    const root = createRoot();
+    root.node.createChild("A");
+    root.node.createChild("B");
+    root.node.createChild("C");
+    expect([...root.node.children].map((c) => c.name)).toEqual(["A", "B", "C"]);
+    root.destroy();
+  });
+
+  it("createChild inserts before a sibling", () => {
+    const root = createRoot();
+    root.node.createChild("A");
+    const c = root.node.createChild("C");
+    root.node.createChild("B", { before: c });
+    expect([...root.node.children].map((n) => n.name)).toEqual(["A", "B", "C"]);
+    root.destroy();
+  });
+
+  it("createChild before the first child inserts at the front", () => {
+    const root = createRoot();
+    const a = root.node.createChild("A");
+    root.node.createChild("Z", { before: a });
+    expect([...root.node.children].map((n) => n.name)).toEqual(["Z", "A"]);
+    root.destroy();
+  });
+
+  it("createChild throws when before is not a child", () => {
+    const root = createRoot();
+    const a = root.node.createChild("A");
+    const stranger = root.node.createChild("B").createChild("nested");
+    expect(() => a.createChild("x", { before: stranger })).toThrow();
+    root.destroy();
+  });
+
+  it("before sets insertion order under an active sort tiebreaker", () => {
+    const root = createRoot();
+    const a = root.node.createChild("A");
+    const c = root.node.createChild("C");
+    const b = root.node.createChild("B", { before: c });
+    for (const n of [a, b, c]) {
+      n.set("priority", 1);
+    }
+    root.node.sort((x, y) =>
+      (x.props["priority"] as number) - (y.props["priority"] as number)
+    );
+    // all equal -> insertion order (with B spliced before C) is the tiebreaker
+    expect([...root.node.children].map((n) => n.name)).toEqual(["A", "B", "C"]);
+    root.destroy();
+  });
+
+  it("custom sort reorders children", () => {
+    const root = createRoot();
+    const a = root.node.createChild("A");
+    const b = root.node.createChild("B");
+    const c = root.node.createChild("C");
+    a.set("priority", 3);
+    b.set("priority", 1);
+    c.set("priority", 2);
+    root.node.sort((x, y) =>
+      (x.props["priority"] as number) - (y.props["priority"] as number)
+    );
+    expect([...root.node.children].map((n) => n.name)).toEqual(["B", "C", "A"]);
+    root.node.sort(undefined);
+    expect([...root.node.children].map((n) => n.name)).toEqual(["A", "B", "C"]);
+    root.destroy();
+  });
+
+  it("child ids are unique and the parent is wired", () => {
+    const root = createRoot();
+    const a = root.node.createChild("a");
+    const b = a.createChild("b");
+    expect(b.parent).toBe(a);
+    expect(new Set([root.node.id, a.id, b.id]).size).toEqual(3);
+    root.destroy();
+  });
+});
+
+describe("Mutation interception (NodeApi)", () => {
+  it("set interceptor can transform values", () => {
+    const root = createRoot();
+    root.node.scope.around(NodeApi, {
+      set([node, key, value], next) {
+        next(node, key, key === "doubled" ? (value as number) * 2 : value);
+      },
+    });
+    root.node.set("doubled", 21);
+    root.node.set("plain", 5);
+    expect(root.node.props["doubled"]).toEqual(42);
+    expect(root.node.props["plain"]).toEqual(5);
+    root.destroy();
+  });
+
+  it("get interceptor can transform reads", () => {
+    const root = createRoot();
+    root.node.set("k", 1);
+    root.node.scope.around(NodeApi, {
+      get([node, key], next) {
+        const val = next(node, key);
+        return key === "k" ? (val as number) * 10 : val;
+      },
+    });
+    expect(root.node.get("k")).toEqual(10);
+    root.destroy();
+  });
+
+  it("interceptors are inherited by descendants", () => {
+    const root = createRoot();
+    let appended = 0;
+    root.node.scope.around(NodeApi, {
+      createChild([node, name], next) {
+        appended++;
+        return next(node, name);
+      },
+    });
+    const a = root.node.createChild("a");
+    a.createChild("b");
+    expect(appended).toEqual(2);
+    root.destroy();
+  });
+});
+
+describe("Dispatch and notification", () => {
+  it("demux middleware handles an event", async () => {
+    await run(function* () {
+      const root = createRoot();
+      let handled = false;
+      root.node.scope.around(DispatchApi, {
+        *dispatch([event], next) {
+          if (event === "ping") {
+            handled = true;
+            return { ok: true as const, value: true as const };
+          }
+          return yield* next(event);
+        },
+      });
+      root.dispatch("ping");
+      yield* sleep(0);
+      expect(handled).toBe(true);
+      yield* root.destroy();
+    });
+  });
+
+  it("mutations in a dispatch cycle emit one coalesced notification", async () => {
+    await run(function* () {
+      const root = createRoot();
+      root.node.scope.around(DispatchApi, {
+        *dispatch([_event], _next) {
+          root.node.set("a", 1);
+          root.node.set("b", 2);
+          root.node.set("c", 3);
+          return { ok: true as const, value: true as const };
+        },
+      });
+      const sub = yield* root;
+      root.dispatch("multi");
+      const next = yield* sub.next();
+      expect(next.done).toBe(false);
+      expect(root.node.props["a"]).toEqual(1);
+      yield* root.destroy();
+    });
+  });
+
+  it("a no-change dispatch does not notify", async () => {
+    await run(function* () {
+      const root = createRoot();
+      root.node.scope.around(DispatchApi, {
+        *dispatch([_event], _next) {
+          return { ok: true as const, value: true as const };
+        },
+      });
+      yield* root;
+      root.dispatch("noop");
+      yield* sleep(0);
+      yield* root.destroy();
+    });
+  });
+
+  it("processes events sequentially", async () => {
+    await run(function* () {
+      const root = createRoot();
+      const order: string[] = [];
+      root.node.scope.around(DispatchApi, {
+        *dispatch([event], _next) {
+          order.push(event as string);
+          return { ok: true as const, value: true as const };
+        },
+      });
+      root.dispatch("first");
+      root.dispatch("second");
+      yield* sleep(0);
+      yield* sleep(0);
+      expect(order).toEqual(["first", "second"]);
+      yield* root.destroy();
+    });
+  });
+});
diff --git a/packages/freedom/test/helpers.ts b/packages/freedom/test/helpers.ts
new file mode 100644
index 0000000..f01479f
--- /dev/null
+++ b/packages/freedom/test/helpers.ts
@@ -0,0 +1,35 @@
+import { expect as viExpect } from "vitest";
+import { type Operation, sleep } from "effection";
+import type { Node } from "../src/index.ts";
+
+type Assertion = ReturnType<typeof viExpect>;
+type NodeExpected = Assertion & {
+  toEval(fn: () => Operation<void>): Operation<void>;
+};
+
+export function expect(value: Node): NodeExpected;
+export function expect<T>(value: T): Assertion;
+export function expect(value: unknown): NodeExpected | Assertion {
+  let base = viExpect(value);
+  if (value && typeof value === "object" && "eval" in value) {
+    let node = value as Node;
+    return new Proxy(base as unknown as NodeExpected, {
+      get(target, prop, receiver) {
+        if (prop === "toEval") {
+          return (fn: () => Operation<void>): Operation<void> => ({
+            *[Symbol.iterator]() {
+              // let pending child component tasks settle
+              yield* sleep(0);
+              let r = yield* node.eval(fn);
+              if (!r.ok) {
+                throw r.error;
+              }
+            },
+          });
+        }
+        return Reflect.get(target, prop, receiver);
+      },
+    });
+  }
+  return base;
+}
diff --git a/packages/freedom/test/root.test.ts b/packages/freedom/test/root.test.ts
new file mode 100644
index 0000000..1d2c5fc
--- /dev/null
+++ b/packages/freedom/test/root.test.ts
@@ -0,0 +1,45 @@
+import { describe, expect, it } from "../test/suite.ts";
+import { createRoot, NodeApi } from "../src/index.ts";
+
+describe("createRoot", () => {
+  it("returns a root with a parentless node that has an id", () => {
+    const root = createRoot();
+    expect(root.node).toBeTruthy();
+    expect(root.node.parent).toBeUndefined();
+    expect(root.node.id).toBeTruthy();
+    root.destroy();
+  });
+
+  it("createChild attaches a child synchronously with a unique id", () => {
+    const root = createRoot();
+    const a = root.node.createChild("a");
+    const b = root.node.createChild("b");
+
+    expect(a.name).toEqual("a");
+    expect(a.parent).toBe(root.node);
+    expect(a.id).not.toEqual(b.id);
+    expect(a.id).not.toEqual(root.node.id);
+    expect([...root.node.children]).toEqual([a, b]);
+
+    root.destroy();
+  });
+
+  it("a sync interceptor (scope.around NodeApi) transforms a mutation", () => {
+    const root = createRoot();
+    root.node.scope.around(NodeApi, {
+      set([node, key, value], next) {
+        next(node, key, typeof value === "number" ? value * 10 : value);
+      },
+    });
+
+    root.node.set("n", 5);
+    expect(root.node.props["n"]).toEqual(50);
+
+    // interceptor is inherited by descendants via the scope chain
+    const child = root.node.createChild("c");
+    child.set("m", 2);
+    expect(child.props["m"]).toEqual(20);
+
+    root.destroy();
+  });
+});
diff --git a/packages/freedom/test/suite.ts b/packages/freedom/test/suite.ts
new file mode 100644
index 0000000..4be959e
--- /dev/null
+++ b/packages/freedom/test/suite.ts
@@ -0,0 +1 @@
+export { afterEach, beforeEach, describe, it, expect } from "vitest";
diff --git a/packages/freedom/tsconfig.json b/packages/freedom/tsconfig.json
new file mode 100644
index 0000000..b9fbbb0
--- /dev/null
+++ b/packages/freedom/tsconfig.json
@@ -0,0 +1,5 @@
+{
+    "extends": [
+        "@bomb.sh/tools/tsconfig.json"
+    ]
+}
diff --git a/packages/input/package.json b/packages/input/package.json
new file mode 100644
index 0000000..743927e
--- /dev/null
+++ b/packages/input/package.json
@@ -0,0 +1,53 @@
+{
+    "name": "@bomb.sh/input",
+    "version": "0.0.0",
+    "private": true,
+    "type": "module",
+    "license": "ISC",
+    "author": {
+        "name": "Bombshell",
+        "email": "oss@bomb.sh",
+        "url": "https://bomb.sh"
+    },
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.mts",
+            "import": "./dist/index.mjs"
+        },
+        "./package.json": "./package.json"
+    },
+    "scripts": {
+        "dev": "bsh dev --dts",
+        "build": "bsh build --dts",
+        "format": "bsh format",
+        "lint": "bsh lint",
+        "test": "bsh test"
+    },
+    "dependencies": {
+        "@bomb.sh/freedom": "workspace:*",
+        "@bomb.sh/tty": "^0.8.0",
+        "effection": "4.1.0-alpha.9"
+    },
+    "devDependencies": {
+        "@bomb.sh/tools": "latest",
+        "@types/node": "^26.0.0",
+        "vitest": "^4.1.2"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/bombshell-dev/playground.git",
+        "directory": "packages/input"
+    },
+    "devEngines": {
+        "runtime": {
+            "name": "node",
+            "version": "22.14.0",
+            "onFail": "error"
+        },
+        "packageManager": {
+            "name": "pnpm",
+            "version": "10.7.0",
+            "onFail": "error"
+        }
+    }
+}
diff --git a/packages/input/src/index.ts b/packages/input/src/index.ts
new file mode 100644
index 0000000..945209d
--- /dev/null
+++ b/packages/input/src/index.ts
@@ -0,0 +1 @@
+export * from "./lib/mod.ts";
diff --git a/packages/input/src/lib/input.ts b/packages/input/src/lib/input.ts
new file mode 100644
index 0000000..8f242d9
--- /dev/null
+++ b/packages/input/src/lib/input.ts
@@ -0,0 +1,174 @@
+import { createApi } from "effection/experimental";
+import { DispatchApi, focusable, current, type Node, type Root } from "@bomb.sh/freedom";
+import type { KeyDown, KeyEvent, KeyRepeat, KeyUp } from "@bomb.sh/tty";
+
+export const KeyboardApi = createApi("@bomb.sh/keyboard", {
+  keydown(node: Node, event: KeyDown): void {
+    if (node.get("input")) {
+      if (event.text && event.text?.length > 0) {
+        insert(node, event.text);
+      } else if (event.code === "Backspace") {
+        deleteBackward(node);
+      } else if (event.code === "Delete") {
+        deleteForward(node);
+      } else if (event.code === "ArrowLeft") {
+        moveBack(node);
+      } else if (event.code === "ArrowRight") {
+        moveForward(node);
+      } else if (event.code === "Home") {
+        moveMin(node);
+      } else if (event.code === "End") {
+        moveMax(node);
+      }
+    }
+  },
+  keyup(_node: Node, _event: KeyUp): void { },
+  keyrepeat(node: Node, event: KeyRepeat): void {
+    KeyboardApi.invoke(node.scope, "keydown", [node, {
+      ...event,
+      type: "keydown",
+    }]);
+  },
+})
+
+export const Input = createApi("@bomb.sh/input", {
+  insert(node: Node, text: string): void {
+    const codepoints = [...node.get("value") as string];
+    const caret = node.get("caret") as number;
+    codepoints.splice(caret, 0, text);
+    node.set("value", codepoints.join(""));
+    node.set("caret", caret + 1);
+  },
+  deleteBackward(node: Node): void {
+    const codepoints = [...node.get("value") as string];
+    let caret = node.get("caret") as number;
+    const length = codepoints.length;
+    if (caret > length) {
+      console.warn("caret mismatch: ${caret}, value length: ${length}");
+      caret = length;
+    }
+    if (caret > 0) {
+      codepoints.splice(caret - 1, 1);
+      node.set("value", codepoints.join(""));
+      node.set("caret", caret - 1);
+    }
+  },
+  deleteForward(node: Node): void {
+    const codepoints = [...node.get("value") as string];
+    let caret = node.get("caret") as number;
+    const length = codepoints.length;
+    if (caret > length) {
+      console.warn("caret mismatch: ${caret}, value length: ${length}");
+      caret = length;
+    }
+    if (caret < length) {
+      codepoints.splice(caret, 1);
+      node.set("value", codepoints.join(""));
+    }
+  },
+  moveBack(node: Node): void {
+    const caret = node.get("caret") as number;
+    node.set("caret", Math.max(0, caret - 1));
+  },
+  moveForward(node: Node): void {
+    const caret = node.get("caret") as number;
+    const codepoints = [...node.get("value") as string];
+    node.set("caret", Math.min(codepoints.length, caret + 1));
+  },
+  moveMin(node: Node): void {
+    node.set("caret", 0);
+  },
+  moveMax(node: Node): void {
+    node.set("caret", [...node.get("value") as string].length);
+  },
+})
+
+// Install a text input onto a node. This stub seeds only the DOM-shaped state
+// (`value`, `selectionStart`, `selectionEnd`, `selectionDirection`) and makes
+// the node focusable. Editing behavior is enumerated as skipped specs under
+// `test/` and is not yet implemented — the interaction API is intentionally
+// left unprescribed until the state model is settled.
+export function initInput(node: Node): void {
+  focusable(node);
+  node.set("input", true);
+  node.set("value", "");
+  node.set("caret", 0);
+}
+
+export function useInput(root: Root): void {
+  root.node.scope.around(DispatchApi, {
+    *dispatch([event], next) {
+      if (isKeyEvent(event)) {
+        let target = current(root.node);
+        KeyboardApi.invoke(target.scope, event.type, [target, event as KeyDown & KeyUp & KeyRepeat]);
+        return { ok: true, value: true };
+      }
+      return yield* next(event);
+    }
+  });
+
+  root.node.scope.around(KeyboardApi, {
+    keydown([node, event], next): void {
+      if (node.get("input")) {
+        if (event.text && event.text?.length > 0) {
+          insert(node, event.text);
+        } else if (event.code === "Backspace") {
+          deleteBackward(node);
+        } else if (event.code === "Delete") {
+          deleteForward(node);
+        } else if (event.code === "ArrowLeft") {
+          moveBack(node);
+        } else if (event.code === "ArrowRight") {
+          moveForward(node);
+        } else if (event.code === "Home") {
+          moveMin(node);
+        } else if (event.code === "End") {
+          moveMax(node);
+        } else {
+          next(node, event);
+        }
+      } else {
+        next(node, event);
+      }
+    }
+  })
+}
+
+function isKeyEvent(event: unknown): event is KeyEvent {
+  const x = event as KeyEvent;
+  //  console.log({ x, key: typeof x.key === "string", code: typeof x.code === "string", type: ["keyup", "keydown", "keyrepeat"].includes(x.type) });
+  return !!x && typeof x.key === "string" && typeof x.code === "string" &&
+    ["keyup", "keydown", "keyrepeat"].includes(x.type);
+}
+
+// Exported operation wrappers over the `Input` API. Each invokes the
+// corresponding method at the node's scope so callers — the key dispatch above
+// and any custom keymap — don't reach for `Input.invoke` directly.
+export function insert(node: Node, text: string): void {
+  Input.invoke(node.scope, "insert", [node, text]);
+}
+
+export function deleteBackward(node: Node): void {
+  Input.invoke(node.scope, "deleteBackward", [node]);
+}
+
+export function deleteForward(node: Node): void {
+  Input.invoke(node.scope, "deleteForward", [node]);
+}
+
+export function moveBack(node: Node): void {
+  Input.invoke(node.scope, "moveBack", [node]);
+}
+
+export function moveForward(node: Node): void {
+  Input.invoke(node.scope, "moveForward", [node]);
+}
+
+export function moveMin(node: Node): void {
+  Input.invoke(node.scope, "moveMin", [node]);
+}
+
+export function moveMax(node: Node): void {
+  Input.invoke(node.scope, "moveMax", [node]);
+}
+
diff --git a/packages/input/src/lib/mod.ts b/packages/input/src/lib/mod.ts
new file mode 100644
index 0000000..c0e0ff5
--- /dev/null
+++ b/packages/input/src/lib/mod.ts
@@ -0,0 +1,2 @@
+export { Input, initInput, useInput, KeyboardApi } from "./input.ts";
+export { useReadlineKeymap } from "./readline-layout.ts";
diff --git a/packages/input/src/lib/readline-layout.ts b/packages/input/src/lib/readline-layout.ts
new file mode 100644
index 0000000..04c1a6d
--- /dev/null
+++ b/packages/input/src/lib/readline-layout.ts
@@ -0,0 +1,27 @@
+import type { Node } from "@bomb.sh/freedom";
+import { deleteForward, KeyboardApi, moveBack, moveForward, moveMax, moveMin } from "./input.ts";
+
+export function useReadlineKeymap({ scope }: Node): void {
+  scope.around(KeyboardApi, {
+    keydown([node, event], next) {
+      if (node.get("input") && event.ctrl) {
+        let { code } = event;
+        if (code === "a") {
+          moveMin(node);
+        } else if (code === "e") {
+          moveMax(node);
+        } else if (code === "f") {
+          moveForward(node);
+        } else if (code === "b") {
+          moveBack(node);
+        } else if (code === "d") {
+          deleteForward(node);
+        } else {
+          next(node, event);
+        }
+      } else {
+        next(node, event);
+      }
+    }
+  })
+}
diff --git a/packages/input/test/level-1-text-entry.test.ts b/packages/input/test/level-1-text-entry.test.ts
new file mode 100644
index 0000000..eb504ed
--- /dev/null
+++ b/packages/input/test/level-1-text-entry.test.ts
@@ -0,0 +1,158 @@
+import { focus, type Node } from "@bomb.sh/freedom";
+import { afterEach, beforeEach, createTestInterface, describe, expect, it, type TestInterface } from "./suite.ts";
+import { initInput } from "../src/index.ts";
+
+// Level 1 — Text entry & caret (the foundation)
+describe("Level 1 — text entry & caret", () => {
+  let root: TestInterface;
+  let input: Node;
+  beforeEach(async () => {
+    root = createTestInterface();
+    input = root.node.createChild("input")
+    initInput(input);
+    focus(input);
+  });
+  afterEach(() => root.destroy());
+
+  it("installs input state onto a node", () => {
+    expect(input.get("value")).toEqual("");
+    expect(input.get("focused")).toEqual(true);
+  });
+
+  it("starts empty with the caret at 0", () => {
+    expect(input.get("caret")).toEqual(0);
+  });
+
+  it("inserts a printable character at the caret and advances the caret", () => {
+    root.type("h");
+    expect(input.get("value")).toEqual("h");
+    expect(input.get("caret")).toEqual(1);
+  });
+
+  it("inserts a run of characters left-to-right", () => {
+    root.type("cat");
+    expect(input.get("value")).toEqual("cat");
+    expect(input.get("caret")).toEqual(3);
+  });
+
+  it("inserts a character at the caret when the caret is mid-string", () => {
+    root.type("cat");
+    root.keydown("ArrowLeft"); // caret between "ca" and "t"
+    root.type("x");
+    expect(input.get("value")).toEqual("caxt");
+    expect(input.get("caret")).toEqual(3);
+  });
+
+  it("does not insert a newline on Enter", () => {
+    root.keydown("Enter");
+    expect(input.get("value")).toEqual("");
+    expect(input.get("caret")).toEqual(0);
+  });
+
+  it("removes the character before the caret on Backspace", () => {
+    input.set("value", "cat");
+    input.set("caret", 1);
+    root.keydown("Backspace");
+    expect(input.get("value")).toEqual("at");
+    expect(input.get("caret")).toEqual(0);
+  });
+
+  it("removes the last character on Backspace at the end of the value", () => {
+    root.type("cat");
+    expect(input.get("caret")).toEqual(3);
+    root.keydown("Backspace");
+    expect(input.get("value")).toEqual("ca");
+    expect(input.get("caret")).toEqual(2);
+  });
+
+  it("does nothing on Backspace at the start of the value", () => {
+    input.set("value", "cat");
+    input.set("caret", 0);
+    root.keydown("Backspace");
+    expect(input.get("value")).toEqual("cat");
+    expect(input.get("caret")).toEqual(0);
+  });
+
+  it("removes a whole multi-code-unit character on Backspace (code-point safe)", () => {
+    // "😀" is a surrogate pair — two UTF-16 units, one code point.
+    root.type("a😀");
+    expect(input.get("value")).toEqual("a😀");
+    expect(input.get("caret")).toEqual(2);
+    root.keydown("Backspace");
+    expect(input.get("value")).toEqual("a");
+    expect(input.get("caret")).toEqual(1);
+  });
+  
+  it("removes the character after the caret on Delete", () => {
+    input.set("value", "cat");
+    input.set("caret", 1);
+    root.keydown("Delete");
+    expect(input.get("value")).toEqual("ct");
+    expect(input.get("caret")).toEqual(1);
+  });
+  
+  it("does nothing on Delete at the end of the value", () => {
+    input.set("value", "cat");
+    input.set("caret", 3);
+    root.keydown("Delete");
+    expect(input.get("value")).toEqual("cat");
+    expect(input.get("caret")).toEqual(3);
+  });
+
+  it("moves the caret one character toward the start on ArrowLeft", () => {
+    input.set("value", "cat");
+    input.set("caret", 2);
+    root.keydown("ArrowLeft");
+    expect(input.get("caret")).toEqual(1);
+    expect(input.get("value")).toEqual("cat");
+  });
+
+  it("moves the caret one character toward the end on ArrowRight", () => {
+    input.set("value", "cat");
+    input.set("caret", 1);
+    root.keydown("ArrowRight");
+    expect(input.get("caret")).toEqual(2);
+    expect(input.get("value")).toEqual("cat");
+  });
+
+  it("does not move the caret on ArrowLeft at the start", () => {
+    input.set("value", "cat");
+    input.set("caret", 0);
+    root.keydown("ArrowLeft");
+    expect(input.get("caret")).toEqual(0);
+  });
+
+  it("does not move the caret on ArrowRight at the end", () => {
+    input.set("value", "cat");
+    input.set("caret", 3);
+    root.keydown("ArrowRight");
+    expect(input.get("caret")).toEqual(3);
+  });
+
+  it("moves the caret to the start on Home", () => {
+    input.set("value", "cat");
+    input.set("caret", 2);
+    root.keydown("Home");
+    expect(input.get("caret")).toEqual(0);
+  });
+
+  it("moves the caret to the end on End", () => {
+    input.set("value", "cat");
+    input.set("caret", 0);
+    root.keydown("End");
+    expect(input.get("caret")).toEqual(3);
+  });
+
+  it.skip("keeps the selection collapsed throughout (direction none)", () => {
+    // The Level 1 model tracks a single `caret` and no selection range, so a
+    // selection is collapsed by construction. Written with fallbacks so it holds
+    // in the caret-only model and stays meaningful if selectionStart/End/direction
+    // are added later — they must equal the caret with direction "none".
+    root.type("cat");
+    root.keydown("ArrowLeft");
+    const caret = input.get("caret");
+    expect(input.get("selectionStart") ?? caret).toEqual(caret);
+    expect(input.get("selectionEnd") ?? caret).toEqual(caret);
+    expect(input.get("selectionDirection") ?? "none").toEqual("none");
+  });
+});
diff --git a/packages/input/test/level-2-selection.test.ts b/packages/input/test/level-2-selection.test.ts
new file mode 100644
index 0000000..3389c18
--- /dev/null
+++ b/packages/input/test/level-2-selection.test.ts
@@ -0,0 +1,21 @@
+import { describe, it } from "./suite.ts";
+
+// Level 2 — Selection
+//
+// The selection can span a range. `selectionDirection` records which edge is
+// the anchor. Editing over a selection replaces or removes the whole range.
+describe("Level 2 — selection", () => {
+  it.skip("shift+right extends the selection one character toward the end");
+  it.skip("shift+left extends the selection one character toward the start");
+  it.skip("shift+home extends the selection to the start");
+  it.skip("shift+end extends the selection to the end");
+  it.skip("select-all selects the entire value");
+  it.skip("extending from a caret sets the direction");
+  it.skip("extending past the anchor flips the direction");
+  it.skip("a plain right collapses a selection to its end");
+  it.skip("a plain left collapses a selection to its start");
+  it.skip("home / end collapse the selection");
+  it.skip("typing a character replaces the selection");
+  it.skip("backspace deletes the selection, leaving the caret at the start");
+  it.skip("delete deletes the selection, leaving the caret at the start");
+});
diff --git a/packages/input/test/level-3-word.test.ts b/packages/input/test/level-3-word.test.ts
new file mode 100644
index 0000000..ce6977d
--- /dev/null
+++ b/packages/input/test/level-3-word.test.ts
@@ -0,0 +1,18 @@
+import { describe, it } from "./suite.ts";
+
+// Level 3 — Word-wise motion & deletion
+//
+// Motion and deletion operate over word boundaries. Word deletion collapses to
+// deleting the selection when one is present.
+describe("Level 3 — word-wise motion & deletion", () => {
+  it.skip("word-left moves the caret to the previous word boundary");
+  it.skip("word-right moves the caret to the next word boundary");
+  it.skip("word motion skips whitespace before landing on a word edge");
+  it.skip("word-left at the start clamps");
+  it.skip("word-right at the end clamps");
+  it.skip("shift+word-left extends the selection by a word");
+  it.skip("shift+word-right extends the selection by a word");
+  it.skip("delete-word-backward removes to the previous word boundary");
+  it.skip("delete-word-forward removes to the next word boundary");
+  it.skip("word deletion over a selection deletes the selection instead");
+});
diff --git a/packages/input/test/level-4-clipboard.test.ts b/packages/input/test/level-4-clipboard.test.ts
new file mode 100644
index 0000000..15f9c8f
--- /dev/null
+++ b/packages/input/test/level-4-clipboard.test.ts
@@ -0,0 +1,16 @@
+import { describe, it } from "./suite.ts";
+
+// Level 4 — Clipboard & kill
+//
+// Cut / copy / paste and kill / yank operate against an injectable buffer; there
+// is no OS clipboard integration yet.
+describe("Level 4 — clipboard & kill", () => {
+  it.skip("copy captures the selected text without changing the value");
+  it.skip("copy with a collapsed selection captures nothing");
+  it.skip("cut captures the selected text and removes it, collapsing to the start");
+  it.skip("paste inserts captured text at the caret");
+  it.skip("paste replaces the current selection");
+  it.skip("kill-to-end removes from the caret to the end and captures it");
+  it.skip("kill-to-start removes from the start of the value to the caret and captures it");
+  it.skip("yank re-inserts the most recently killed or cut text");
+});
diff --git a/packages/input/test/level-5-undo.test.ts b/packages/input/test/level-5-undo.test.ts
new file mode 100644
index 0000000..9f23d84
--- /dev/null
+++ b/packages/input/test/level-5-undo.test.ts
@@ -0,0 +1,15 @@
+import { describe, it } from "./suite.ts";
+
+// Level 5 — Undo / redo
+//
+// An undo step captures value and selection. Consecutive insertions coalesce;
+// caret- and selection-only changes are not undoable.
+describe("Level 5 — undo / redo", () => {
+  it.skip("undo restores value and selection to before the last edit");
+  it.skip("redo re-applies an undone edit");
+  it.skip("a fresh edit after undo clears the redo stack");
+  it.skip("consecutive insertions coalesce into one undo step");
+  it.skip("a deletion is its own undo step");
+  it.skip("caret-only moves create no undo step");
+  it.skip("selection-only changes create no undo step");
+});
diff --git a/packages/input/test/readline-keymap.test.ts b/packages/input/test/readline-keymap.test.ts
new file mode 100644
index 0000000..b75ec9e
--- /dev/null
+++ b/packages/input/test/readline-keymap.test.ts
@@ -0,0 +1,67 @@
+import { focus, type Node } from "@bomb.sh/freedom";
+import {
+  afterEach,
+  beforeEach,
+  createTestInterface,
+  describe,
+  expect,
+  it,
+  type TestInterface,
+} from "./suite.ts";
+import { initInput } from "../src/index.ts";
+import { useReadlineKeymap } from "../src/lib/readline-layout.ts";
+
+// Readline/emacs keymap — control-key aliases layered on the base bindings:
+//   Ctrl+A → Home        Ctrl+E → End
+//   Ctrl+B → ArrowLeft   Ctrl+F → ArrowRight
+//   Ctrl+D → Delete
+// Each spec asserts the alias produces the same effect as the key it stands in
+// for. `root.keydown(code, { ctrl: true })` sends the modifier.
+describe("readline keymap", () => {
+  let root: TestInterface;
+  let input: Node;
+  beforeEach(async () => {
+    root = createTestInterface();
+    useReadlineKeymap(root.node);
+    input = root.node.createChild("input");
+    initInput(input);
+    focus(input);
+  });
+  afterEach(() => root.destroy());
+
+  it("moves the caret to the start on Ctrl+A", () => {
+    input.set("value", "cat");
+    input.set("caret", 2);
+    root.keydown("a", { ctrl: true });
+    expect(input.get("caret")).toEqual(0);
+  });
+
+  it("moves the caret to the end on Ctrl+E", () => {
+    input.set("value", "cat");
+    input.set("caret", 0);
+    root.keydown("e", { ctrl: true });
+    expect(input.get("caret")).toEqual(3);
+  });
+
+  it("moves the caret one character toward the end on Ctrl+F", () => {
+    input.set("value", "cat");
+    input.set("caret", 1);
+    root.keydown("f", { ctrl: true });
+    expect(input.get("caret")).toEqual(2);
+  });
+
+  it("moves the caret one character toward the start on Ctrl+B", () => {
+    input.set("value", "cat");
+    input.set("caret", 2);
+    root.keydown("b", { ctrl: true });
+    expect(input.get("caret")).toEqual(1);
+  });
+
+  it("removes the character after the caret on Ctrl+D", () => {
+    input.set("value", "cat");
+    input.set("caret", 1);
+    root.keydown("d", { ctrl: true });
+    expect(input.get("value")).toEqual("ct");
+    expect(input.get("caret")).toEqual(1);
+  });
+});
diff --git a/packages/input/test/suite.ts b/packages/input/test/suite.ts
new file mode 100644
index 0000000..8a43e94
--- /dev/null
+++ b/packages/input/test/suite.ts
@@ -0,0 +1,33 @@
+import { createRoot, type Root } from "@bomb.sh/freedom";
+import { useInput } from "../src/lib/input.ts";
+import type { KeyCode, KeyModifiers } from "@bomb.sh/tty";
+export { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+export interface TestInterface extends Root {
+  type(str: string): void;
+  keydown(code: KeyCode, modifiers?: KeyModifiers): void;
+}
+
+export function createTestInterface(): TestInterface {
+  const root = createRoot() as TestInterface;
+  useInput(root);
+  root.type = (str) => {
+    for (let char of [...str]) {
+      root.dispatch({
+        type: "keydown",
+        key: char,
+        code: char,
+        text: char,
+      })
+    }
+  };
+  root.keydown = (code, modifiers) => {
+    root.dispatch({
+      type: "keydown",
+      key: code,
+      code,
+      ...modifiers,
+    });
+  };
+  return root;
+}
diff --git a/packages/input/tsconfig.json b/packages/input/tsconfig.json
new file mode 100644
index 0000000..3edc752
--- /dev/null
+++ b/packages/input/tsconfig.json
@@ -0,0 +1,8 @@
+{
+    "extends": [
+        "@bomb.sh/tools/tsconfig.json"
+    ],
+    "compilerOptions": {
+        "types": ["node"]
+    }
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index d0654b8..4a36e1a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -10,35 +10,112 @@ importers:
     devDependencies:
       '@bomb.sh/tools':
         specifier: latest
-        version: 0.5.3(@types/node@26.0.0)(oxc-resolver@11.21.3)(vite@8.1.0(@types/node@26.0.0)(jiti@2.7.0)(yaml@2.9.0))
+        version: 0.5.4(@types/node@26.0.0)(oxc-resolver@11.21.3)(tsx@4.22.4)(typescript@6.0.3)(unrun@0.2.39)(vite@8.1.0(@types/node@26.0.0)(esbuild@0.28.1)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
+      typescript:
+        specifier: ^6.0.3
+        version: 6.0.3
 
   packages/demo:
     dependencies:
+      '@bomb.sh/freedom':
+        specifier: workspace:*
+        version: link:../freedom
+      '@bomb.sh/input':
+        specifier: workspace:^
+        version: link:../input
+      '@bomb.sh/tty':
+        specifier: https://pkg.pr.new/@bomb.sh/tty@103
+        version: https://pkg.pr.new/@bomb.sh/tty@103
+      '@types/node':
+        specifier: ^26.0.0
+        version: 26.0.0
+      effection:
+        specifier: 4.1.0-alpha.9
+        version: 4.1.0-alpha.9
+    devDependencies:
+      '@bomb.sh/tools':
+        specifier: latest
+        version: 0.5.4(@types/node@26.0.0)(oxc-resolver@11.21.3)(tsx@4.22.4)(typescript@6.0.3)(unrun@0.2.39)(vite@8.1.0(@types/node@26.0.0)(esbuild@0.28.1)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
+
+  packages/freedom:
+    dependencies:
+      effection:
+        specifier: 4.1.0-alpha.9
+        version: 4.1.0-alpha.9
+    devDependencies:
+      '@bomb.sh/tools':
+        specifier: latest
+        version: 0.5.4(@types/node@26.0.0)(oxc-resolver@11.21.3)(tsx@4.22.4)(typescript@6.0.3)(unrun@0.2.39)(vite@8.1.0(@types/node@26.0.0)(esbuild@0.28.1)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
+      '@types/node':
+        specifier: ^26.0.0
+        version: 26.0.0
+
+  packages/freedom-react:
+    dependencies:
+      '@bomb.sh/freedom':
+        specifier: workspace:*
+        version: link:../freedom
       '@bomb.sh/tty':
         specifier: latest
-        version: 0.7.0
+        version: 0.8.0
+      effection:
+        specifier: 4.1.0-alpha.9
+        version: 4.1.0-alpha.9
+      react:
+        specifier: ^18.3.1
+        version: 18.3.1
+      react-reconciler:
+        specifier: ^0.29.2
+        version: 0.29.2(react@18.3.1)
+    devDependencies:
+      '@bomb.sh/tools':
+        specifier: latest
+        version: 0.5.4(@types/node@26.0.0)(oxc-resolver@11.21.3)(tsx@4.22.4)(typescript@6.0.3)(unrun@0.2.39)(vite@8.1.0(@types/node@26.0.0)(esbuild@0.28.1)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
       '@types/node':
         specifier: ^26.0.0
         version: 26.0.0
+      '@types/react':
+        specifier: ^18.3.12
+        version: 18.3.31
+      '@types/react-reconciler':
+        specifier: ^0.28.9
+        version: 0.28.9(@types/react@18.3.31)
+      tsx:
+        specifier: ^4.19.2
+        version: 4.22.4
+
+  packages/input:
+    dependencies:
+      '@bomb.sh/freedom':
+        specifier: workspace:*
+        version: link:../freedom
+      '@bomb.sh/tty':
+        specifier: ^0.8.0
+        version: 0.8.0
+      effection:
+        specifier: 4.1.0-alpha.9
+        version: 4.1.0-alpha.9
     devDependencies:
       '@bomb.sh/tools':
         specifier: latest
-        version: 0.5.3(@types/node@26.0.0)(oxc-resolver@11.21.3)(vite@8.1.0(@types/node@26.0.0)(jiti@2.7.0)(yaml@2.9.0))
+        version: 0.5.4(@types/node@26.0.0)(oxc-resolver@11.21.3)(tsx@4.22.4)(typescript@6.0.3)(unrun@0.2.39)(vite@8.1.0(@types/node@26.0.0)(esbuild@0.28.1)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
+      '@types/node':
+        specifier: ^26.0.0
+        version: 26.0.0
+      vitest:
+        specifier: ^4.1.2
+        version: 4.1.9(@types/node@26.0.0)(vite@8.1.0(@types/node@26.0.0)(esbuild@0.28.1)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
 
 packages:
 
-  '@babel/generator@8.0.0-rc.3':
-    resolution: {integrity: sha512-em37/13/nR320G4jab/nIIHZgc2Wz2y/D39lxnTyxB4/D/omPQncl/lSdlnJY1OhQcRGugTSIF2l/69o31C9dA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
+  '@babel/generator@8.0.0':
+    resolution: {integrity: sha512-NT9NrVwJsbSV6Y2FSstWa71EETOnzrjkL5/wX3D2mYHtKM+qvqB1DvR4D0Setb/gDBsHzRICifwEWMO8CnTF6g==}
+    engines: {node: ^22.18.0 || >=24.11.0}
 
   '@babel/helper-string-parser@8.0.0':
     resolution: {integrity: sha512-6mJgmFFFIIO82vvoLt9XtRC7/TkzXfts1t/SpRX4IHSzMgqoPYCWesVu1udUPUWioAE/2fcG6WuI8zrkE1gwrg==}
     engines: {node: ^22.18.0 || >=24.11.0}
 
-  '@babel/helper-validator-identifier@8.0.0-rc.3':
-    resolution: {integrity: sha512-8AWCJ2VJJyDFlGBep5GpaaQ9AAaE/FjAcrqI7jyssYhtL7WGV0DOKpJsQqM037xDbpRLHXsY8TwU7zDma7coOw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-
   '@babel/helper-validator-identifier@8.0.2':
     resolution: {integrity: sha512-9Fr9QeyCAyi1BR1jKZ6uYQ24EIhQUx5ReHfQU7drOE+TPOb+w11/dsqLkMOT2U29OdCT71XajrOT8xDc1C7orA==}
     engines: {node: ^22.18.0 || >=24.11.0}
@@ -48,28 +125,24 @@ packages:
     engines: {node: ^22.18.0 || >=24.11.0}
     hasBin: true
 
-  '@babel/parser@8.0.0-rc.3':
-    resolution: {integrity: sha512-B20dvP3MfNc/XS5KKCHy/oyWl5IA6Cn9YjXRdDlCjNmUFrjvLXMNUfQq/QUy9fnG2gYkKKcrto2YaF9B32ToOQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    hasBin: true
-
   '@babel/types@8.0.0':
     resolution: {integrity: sha512-K8ponJDxBwDHigkeFqaqT5wLGl4bTlwMafR8k7b5CPxr6Ww+UG9ls8Yx6Tcpboxu97eeGVEEyKcHmEyOwN1vSw==}
     engines: {node: ^22.18.0 || >=24.11.0}
 
-  '@babel/types@8.0.0-rc.3':
-    resolution: {integrity: sha512-mOm5ZrYmphGfqVWoH5YYMTITb3cDXsFgmvFlvkvWDMsR9X8RFnt7a0Wb6yNIdoFsiMO9WjYLq+U/FMtqIYAF8Q==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-
   '@bomb.sh/args@0.3.1':
     resolution: {integrity: sha512-CwxKrfgcorUPP6KfYD59aRdBYWBTsfsxT+GmoLVnKo5Tmyoqbpo0UNcjngRMyU+6tiPbd18RuIYxhgAn44wU/Q==}
 
-  '@bomb.sh/tools@0.5.3':
-    resolution: {integrity: sha512-665My/wDcVUKFWGy4O4MP6LfuCxd8dITRfahc2UIpufq5wtqJ+1MWuNDkMFpC6jY7/GWOWG11urB1v2KkV2Jtg==}
+  '@bomb.sh/tools@0.5.4':
+    resolution: {integrity: sha512-OGbhambOn0o2w9LX5N4MoyMBxVLXByD1aCIFlAbQvCbLt60sMffjy1FbGMJtnpcwSr6TePWBKnGC7OaU1r29wg==}
     hasBin: true
 
-  '@bomb.sh/tty@0.7.0':
-    resolution: {integrity: sha512-htTavc3o84vR6uSoyF+Y9u81GG8NoTJkwOovahcNOY4nVeiM86vodCHdPvAXoj2ucmx04frpwMrOJ4ipLSSJfw==}
+  '@bomb.sh/tty@0.8.0':
+    resolution: {integrity: sha512-tEE0mtqnEp2uJt4kQS5AjdghCD5KN4BobqHOlfhaiNyrigxFBKk61XkDy//4D7V/AejrTvubh44B4NV35lsnxw==}
+    engines: {node: '>= 22'}
+
+  '@bomb.sh/tty@https://pkg.pr.new/@bomb.sh/tty@103':
+    resolution: {tarball: https://pkg.pr.new/@bomb.sh/tty@103}
+    version: 0.8.0-pr
     engines: {node: '>= 22'}
 
   '@emnapi/core@1.10.0':
@@ -96,6 +169,162 @@ packages:
   '@emnapi/wasi-threads@1.2.2':
     resolution: {integrity: sha512-c95qOXkHdydNKhscBTebqEC1CVAZpyqOfVfBzQ1qgzyl3gfeldUjIggDbIZgDKsHLgnsM+igH7TJ/eAasaVuMA==}
 
+  '@esbuild/aix-ppc64@0.28.1':
+    resolution: {integrity: sha512-Svl7tq8k/08+p6CXPpRjQ1fKX+1odH/BQbb48fV6fj3CWHhsoIOoY87w1oHXm0qEpkIK3ZfVgp0hed3XBXzXMQ==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/android-arm64@0.28.1':
+    resolution: {integrity: sha512-34EGEbCIAgosYz6goLcopX6Mo7NyGv9tfwEM2/7Ce2VcVRk568iSvniGWcUXIy7wEDR1wzolcxcriFVrWYcwBg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/android-arm@0.28.1':
+    resolution: {integrity: sha512-0k2F129Xdio1TdJfzJ8sy1Q47vUD2NnwdhiAf7drUN1EBTfPf4hsFCtmMgu/6m8JSzsBrlmVjudMBQqOfG8usQ==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/android-x64@0.28.1':
+    resolution: {integrity: sha512-dbwY7ltSMDWsRatcRpCnES4F+im88OCUgGZjy52shC7GqHRE/cYlxNbB4Z4UpJswpcc4Qxd2oE/ufM0p61IKng==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/darwin-arm64@0.28.1':
+    resolution: {integrity: sha512-TZbWkQY7kvTAXbXUT7uVACR5cMHsDiSz9z7ZKAX/RTq/WJEk3QyRr0wZpNhBDX+/0CtdqUIJlOiodQcta6tY3Q==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/darwin-x64@0.28.1':
+    resolution: {integrity: sha512-zfdzgK9ACBNZLI/CyHTOx81SyNbM6YXn7rxSgX97VjyiPl9W1i4Ka4fgKECEoFCKGpvBj5qArWIGgQjOwkgskQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/freebsd-arm64@0.28.1':
+    resolution: {integrity: sha512-wG2EA8ENdEI0qhkSZMjfqrdY+ziCYCPMmtZjjIwOmXFjmyzEHn+UUxk5of+SYsjtfs3VpnlC7QLzSI5hY/rOAw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-x64@0.28.1':
+    resolution: {integrity: sha512-i7dZ9vQgnvSCzi/rYCXNgtF/U+eKZNJBzu3eTQbRgHnM7tNSizLOkRFAl3qzVc/Op/u5YkHHa4pf/3DOYHthLQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/linux-arm64@0.28.1':
+    resolution: {integrity: sha512-yHs+0uc8+nvEAfAfxrWQKK5peSNzBc4PegcMO0EJ2hT71uA7vB8Ihg2e77R2P7SG5uYjPbHlLLmve4LLLRCf0g==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/linux-arm@0.28.1':
+    resolution: {integrity: sha512-qVXBOHQS+d5Y722GwJzJUtOLlX7km3CraOaGormF1pDtPd2C/l1SHRPgjLunLGe51Sh5YYWKMFDyV4SxgMQYTQ==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/linux-ia32@0.28.1':
+    resolution: {integrity: sha512-d1z4ZuP0ajrfz/FhGT4vv278rX8KnPPJx8i5+AtK7TYbx9Le9F1hyzurZpkEyjkGa9dUGhQow4C1NmeGvqxN2w==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/linux-loong64@0.28.1':
+    resolution: {integrity: sha512-M5sRjUVZrkm1OAPR3dlOYzNmN+loZKGVi1VUQGrwuqLcbR6qeAz+famMhjASeH3YVKvZz+zT1jlh/keC3Rj/lg==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/linux-mips64el@0.28.1':
+    resolution: {integrity: sha512-mRObBZeHh2OxcBFPWE/FjylkRgZdYuiTR3vaTozquCGOH14iP9oN4x4Ge81CoIDYQrXmIxpFumJBu5MtZpnQJQ==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/linux-ppc64@0.28.1':
+    resolution: {integrity: sha512-slScBsMAb3GFDcdrCgLwZtPYRoH2H/youv10QiZyRjmsP48fznoveWytSgCI/R0ZcUgpc0ZhIUEx6LHts8yrfQ==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/linux-riscv64@0.28.1':
+    resolution: {integrity: sha512-kw0owk1o0GFETUJyW0jc0G4Yzs0BHZn0JDZ8JRT088vjJYX777BAs1fDGxAC+q831qOs2DTC96mNsG2opdfyyQ==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/linux-s390x@0.28.1':
+    resolution: {integrity: sha512-/lAIjX8aYFRByhh6L5rYtPEDRqa9de/4V/juOXcta5frjvzXO4/sqEtyytse0g3zZFuWu5cDN0MkLz2qRDD2Ag==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/linux-x64@0.28.1':
+    resolution: {integrity: sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/netbsd-arm64@0.28.1':
+    resolution: {integrity: sha512-oks0DYbLwWMmaakTsCb+zL4E+aHRVLom9IJZOAthMQEPiQmydXHkziYEsGYRx0uNV/IjEKGAV941JzH02pflqw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-x64@0.28.1':
+    resolution: {integrity: sha512-aeL6lAnN89Hz43Mlh1G8ARasbuoYvSITDEx0tHh5b7jJnHcssqgjy9Yx430GDpmCa6OyrKoS0aNRjKundRizGg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/openbsd-arm64@0.28.1':
+    resolution: {integrity: sha512-MEFJe5C3R8pwXdZ5Y21oo6m7ePiS0d9pWucn99O/wvyJZChoIQKrQDxKrGeW8F5+T0okTHesAmDeiHDTIq0V/Q==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-x64@0.28.1':
+    resolution: {integrity: sha512-i/ZLIOafE0Z8cI/XANJAixoJL/uRAoS2xOA3rb0xN+KK0K177cMAsQYkzHtBrtMXAKuAc7HGgcWiZ/sRC1Nxgw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/openharmony-arm64@0.28.1':
+    resolution: {integrity: sha512-ge+Z7EXFNt2BO1oAMsVpiQ8EwndV9i1xXerAeTIK7AtPs3bKFXQM7nlRxDSIUIMeueR1CNXxqztLzdNeReKBJg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@esbuild/sunos-x64@0.28.1':
+    resolution: {integrity: sha512-BEjgtECkL3vY+SaSQ6nzVfiALUeFxpawyp8Jmf5PtYhf1Ug40N1h/hxlhts+f1FvSvarEigdxS3BlSMI2PJLcQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/win32-arm64@0.28.1':
+    resolution: {integrity: sha512-lCv9eK/H6ZJWbE7bh2nw54CZ9M2nupBxJcTsdk/QQnWkdSjKGuxmmH8/GWrlT1eMmZfn4dGcCjRte397WqfQXA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/win32-ia32@0.28.1':
+    resolution: {integrity: sha512-zvb/mB2bSCoJOpoCBgYKKpX6YM6mJBlBUVUtVj41DlZJVEB6/0CKlRYxP5wWl1C1ILiCoAU5wZZ4q1P3qeS6Eg==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/win32-x64@0.28.1':
+    resolution: {integrity: sha512-bm4Mowrv+GXMlpWX++EcXw/iLyd1o3+bJkC2DkWXYVvgZCqD/bSj9ctZeAMC3cIxgjRVR2Dufaiu4YPxr5gW1A==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
   '@humanfs/core@0.19.2':
     resolution: {integrity: sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA==}
     engines: {node: '>=18.18.0'}
@@ -791,50 +1020,61 @@ packages:
   '@types/node@26.0.0':
     resolution: {integrity: sha512-vf2YFi1iY9lHGwNJMs01biZFbKJkrZR1T6/MlzjhJLPdntOHLhTrDSnSVcdtvjihi4VQNlrFRIxLsDBlQpAipA==}
 
-  '@typescript/native-preview-darwin-arm64@7.0.0-dev.20260427.1':
-    resolution: {integrity: sha512-8zxaaEgIpHSadCoCAvUsp0C6WDH0dUXix7Mm7IBjh+EhSxI2clhXwPZTqgtDqbowXHeE82BG5mBbQx+CXDwGOQ==}
+  '@types/prop-types@15.7.15':
+    resolution: {integrity: sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==}
+
+  '@types/react-reconciler@0.28.9':
+    resolution: {integrity: sha512-HHM3nxyUZ3zAylX8ZEyrDNd2XZOnQ0D5XfunJF5FLQnZbHHYq4UWvW1QfelQNXv1ICNkwYhfxjwfnqivYB6bFg==}
+    peerDependencies:
+      '@types/react': '*'
+
+  '@types/react@18.3.31':
+    resolution: {integrity: sha512-vfEqpXTvwT91yhmwdfouStN2hSKwTvyRs8qpLfADyrq/kxDw0hZM7Wk9Ug1FELj8hIby+S/+kQCSRFF32nv2Qw==}
+
+  '@typescript/native-preview-darwin-arm64@7.0.0-dev.20260623.1':
+    resolution: {integrity: sha512-8AX9NwC+G6Sbh5hNLnx8YgxoRV/8BH8FQRtZ86OTtUQfESMRvwszOGTtfcC32g86O5jsEQPDHXKVSnsIzWh6lg==}
     engines: {node: '>=16.20.0'}
     cpu: [arm64]
     os: [darwin]
 
-  '@typescript/native-preview-darwin-x64@7.0.0-dev.20260427.1':
-    resolution: {integrity: sha512-6MjekGfajPtny/bBoBYJ+8dTOlgw6nhSSgJ3Us4R/4L8R90ll803Krz+iz907r1SnYeK5eWubDMV/p1ryLNXkQ==}
+  '@typescript/native-preview-darwin-x64@7.0.0-dev.20260623.1':
+    resolution: {integrity: sha512-ef+JmOjtTu0BRdhAq69WbzCWjZsG6gqS8xDI4fKABdWXlrVojPkrD2OObog3PC7Qte8us6QspQvvnKTf7yKFSQ==}
     engines: {node: '>=16.20.0'}
     cpu: [x64]
     os: [darwin]
 
-  '@typescript/native-preview-linux-arm64@7.0.0-dev.20260427.1':
-    resolution: {integrity: sha512-a1yG/vrLaN3dORvaMuNqXz5jcTaTEPBfhmq77vzqRn8As7EdqxtizPosfxB9K1s7PEB8NeGQKqHEQroPUCsPFg==}
+  '@typescript/native-preview-linux-arm64@7.0.0-dev.20260623.1':
+    resolution: {integrity: sha512-xb9m0WXvIPHOogGTC02iBv3cwRJ7q+Ql2ABcsu4kHYc1p02JSbIBEfu3g58TpcFZyODsO+8WaDylx/hBiGzlVw==}
     engines: {node: '>=16.20.0'}
     cpu: [arm64]
     os: [linux]
 
-  '@typescript/native-preview-linux-arm@7.0.0-dev.20260427.1':
-    resolution: {integrity: sha512-3bhv/NxU9FHIN3MSmoplIAkIHF62mlF9l5XooAFawwj8yscvPZih/m5fkYIiP5qGri3828XwGyT1Cksaft6FWQ==}
+  '@typescript/native-preview-linux-arm@7.0.0-dev.20260623.1':
+    resolution: {integrity: sha512-8f9dT1RaOK3Wy/puboAcCik4HBX6mfWt5hOMipWehDfInNFI6XP3ZYErShowBQ0Tkln5qdGqDIoq452PO/ZwCA==}
     engines: {node: '>=16.20.0'}
     cpu: [arm]
     os: [linux]
 
-  '@typescript/native-preview-linux-x64@7.0.0-dev.20260427.1':
-    resolution: {integrity: sha512-lqaA9oF9ZSw1jn87+Ncxo0Sf0d65eVXMjAD0z44ne7QKFRgWd+QpvK4AXAG4lxnFR+XdndWlVm6O1/tdvcG7xQ==}
+  '@typescript/native-preview-linux-x64@7.0.0-dev.20260623.1':
+    resolution: {integrity: sha512-AZRp6q0SyVw9xe9kpyfTmavqkQKizDhmOLglDHbxAu4Y3inL6r2GSE7q3w/eO4R259dIwl5TM52DZKK8onoT6Q==}
     engines: {node: '>=16.20.0'}
     cpu: [x64]
     os: [linux]
 
-  '@typescript/native-preview-win32-arm64@7.0.0-dev.20260427.1':
-    resolution: {integrity: sha512-ZGXRDC0WPVK/Ky2fZRhy2EcNmdHg22biVYWcWgOUK5tCbJd/KJs3VXk758gn0UbFHEQAR5d7dsvDucCCjZkWpA==}
+  '@typescript/native-preview-win32-arm64@7.0.0-dev.20260623.1':
+    resolution: {integrity: sha512-DXRMXOe/JEmf2CULZZn1xvRuJrnZ9DxzDubxtW85pE0aSLgl+VuplWCsZrBxaCZDrWMRIfMDV8Y0y+Yftx/jeQ==}
     engines: {node: '>=16.20.0'}
     cpu: [arm64]
     os: [win32]
 
-  '@typescript/native-preview-win32-x64@7.0.0-dev.20260427.1':
-    resolution: {integrity: sha512-Ut4Hncq1IuSeNIfcPs1s719j8H3ZA+ogsJ53W3s/Wy1UF5BIhu5Hkspdc7TzGgJgYqGJKo/+pr4vsRnbBPdWgQ==}
+  '@typescript/native-preview-win32-x64@7.0.0-dev.20260623.1':
+    resolution: {integrity: sha512-kYB1I6tdxWHjhSt8B2v9CHmpOJwJvD88LUCxiBS9C59pwrGe+LAwZvbTTJxvULNaUEjxdiMomYerWWhD/09Y3g==}
     engines: {node: '>=16.20.0'}
     cpu: [x64]
     os: [win32]
 
-  '@typescript/native-preview@7.0.0-dev.20260427.1':
-    resolution: {integrity: sha512-g6L7hed1Y2OGwAzZ+vXoGSvtJUdWUtTqtsn/16+UjYbu3+6pol0cggdWj26SFxI41R+jLfnT2+JGtoXRBdH+RQ==}
+  '@typescript/native-preview@7.0.0-dev.20260623.1':
+    resolution: {integrity: sha512-33AkAhmRu1/w4nRFLnJ9lic7FSzW4zWfU1u5DP7A2+j1445SSNvf3Q4WGtDzdAR5HSlk8vXEa0B4xUHR5vM1tg==}
     engines: {node: '>=16.20.0'}
     hasBin: true
 
@@ -893,6 +1133,9 @@ packages:
   convert-source-map@2.0.0:
     resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}
 
+  csstype@3.2.3:
+    resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==}
+
   defu@6.1.7:
     resolution: {integrity: sha512-7z22QmUWiQ/2d0KkdYmANbRUVABpZ9SNYyH5vx6PZ+nE5bcC0l7uFvEfHlyld/HcGBFTL536ClDt3DEcSlEJAQ==}
 
@@ -900,15 +1143,19 @@ packages:
     resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==}
     engines: {node: '>=8'}
 
-  dts-resolver@2.1.3:
-    resolution: {integrity: sha512-bihc7jPC90VrosXNzK0LTE2cuLP6jr0Ro8jk+kMugHReJVLIpHz/xadeq3MhuwyO4TD4OA3L1Q8pBBFRc08Tsw==}
-    engines: {node: '>=20.19.0'}
+  dts-resolver@3.0.0:
+    resolution: {integrity: sha512-1T1f+z+4tl9XD+m+0HBgWoL/nm0bOIffyWaUuUSBlFg/86IWvfx+wjNaO/ybU0AJzG9/Mi5hBUgGV6zCmWEN7Q==}
+    engines: {node: ^22.18.0 || >=24.0.0}
     peerDependencies:
       oxc-resolver: '>=11.0.0'
     peerDependenciesMeta:
       oxc-resolver:
         optional: true
 
+  effection@4.1.0-alpha.9:
+    resolution: {integrity: sha512-vjZ2RRoXagbjuPin21TCusmO6VScPT7Kru/LWiE8t78MsQJA8qRmzaGTGw2PFIiHcfzrrXpgMvHXUy0aW3/Uhg==}
+    engines: {node: '>= 16'}
+
   empathic@2.0.1:
     resolution: {integrity: sha512-YGRs8knHhKHVShLkFET/rWAU8kmHbOV5LwN938RHI0pljAJ1Gf6SzXsSmRaEzcXTtOOmVqJ5+WtQPL5uigY50Q==}
     engines: {node: '>=14'}
@@ -916,6 +1163,11 @@ packages:
   es-module-lexer@2.1.0:
     resolution: {integrity: sha512-n27zTYMjYu1aj4MjCWzSP7G9r75utsaoc8m61weK+W8JMBGGQybd43GstCXZ3WNmSFtGT9wi59qQTW6mhTR5LQ==}
 
+  esbuild@0.28.1:
+    resolution: {integrity: sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==}
+    engines: {node: '>=18'}
+    hasBin: true
+
   estree-walker@3.0.3:
     resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
 
@@ -948,17 +1200,24 @@ packages:
   get-tsconfig@4.14.0:
     resolution: {integrity: sha512-yTb+8DXzDREzgvYmh6s9vHsSVCHeC0G3PI5bEXNBHtmshPnO+S5O7qgLEOn0I5QvMy6kpZN8K1NKGyilLb93wA==}
 
+  get-tsconfig@5.0.0-beta.5:
+    resolution: {integrity: sha512-/6gFNr0N04nob252sTQxyFLi3eKFRqIg1I87YcqAMT1i6SQrSF6KujUEQrtrjMV0H/eejTCltLdDSTEMzHbnsQ==}
+    engines: {node: '>=20.20.0'}
+
   hookable@6.1.1:
     resolution: {integrity: sha512-U9LYDy1CwhMCnprUfeAZWZGByVbhd54hwepegYTK7Pi5NvqEj63ifz5z+xukznehT7i6NIZRu89Ay1AZmRsLEQ==}
 
-  import-without-cache@0.3.3:
-    resolution: {integrity: sha512-bDxwDdF04gm550DfZHgffvlX+9kUlcz32UD0AeBTmVPFiWkrexF2XVmiuFFbDhiFuP8fQkrkvI2KdSNPYWAXkQ==}
-    engines: {node: '>=20.19.0'}
+  import-without-cache@0.4.0:
+    resolution: {integrity: sha512-NkJQA7oZ4YHQhd2+H3BoRFKF3d/XNsiKpHZCQEMH9pDX27hQQLsTyOocyRgaIVtf8gHX3Nt3LPkR4e5EdtPAGQ==}
+    engines: {node: ^22.18.0 || >=24.0.0}
 
   jiti@2.7.0:
     resolution: {integrity: sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==}
     hasBin: true
 
+  js-tokens@4.0.0:
+    resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
+
   jsesc@3.1.0:
     resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==}
     engines: {node: '>=6'}
@@ -1039,6 +1298,10 @@ packages:
     resolution: {integrity: sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==}
     engines: {node: '>= 12.0.0'}
 
+  loose-envify@1.4.0:
+    resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==}
+    hasBin: true
+
   magic-string@0.30.21:
     resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
 
@@ -1105,18 +1368,28 @@ packages:
   quansync@1.0.0:
     resolution: {integrity: sha512-5xZacEEufv3HSTPQuchrvV6soaiACMFnq1H8wkVioctoH3TRha9Sz66lOxRwPK/qZj7HPiSveih9yAyh98gvqA==}
 
+  react-reconciler@0.29.2:
+    resolution: {integrity: sha512-zZQqIiYgDCTP/f1N/mAR10nJGrPD2ZR+jDSEsKWJHYC7Cm2wodlwbR3upZRdC3cjIjSlTLNVyO7Iu0Yy7t2AYg==}
+    engines: {node: '>=0.10.0'}
+    peerDependencies:
+      react: ^18.3.1
+
+  react@18.3.1:
+    resolution: {integrity: sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==}
+    engines: {node: '>=0.10.0'}
+
   resolve-pkg-maps@1.0.0:
     resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
 
-  rolldown-plugin-dts@0.23.2:
-    resolution: {integrity: sha512-PbSqLawLgZBGcOGT3yqWBGn4cX+wh2nt5FuBGdcMHyOhoukmjbhYAl8NT9sE4U38Cm9tqLOIQeOrvzeayM0DLQ==}
-    engines: {node: '>=20.19.0'}
+  rolldown-plugin-dts@0.26.0:
+    resolution: {integrity: sha512-e+kEPtUiDES0htk5iqkSeF4EzAV7R+vugGB44iPDuw1Kw9E+WyL1VG7PaV0IIjGHLiacztMBcMTyrr8ON9CT1Q==}
+    engines: {node: ^22.18.0 || >=24.11.0}
     peerDependencies:
       '@ts-macro/tsc': ^0.3.6
       '@typescript/native-preview': '>=7.0.0-dev.20260325.1'
-      rolldown: ^1.0.0-rc.12
+      rolldown: ^1.0.0
       typescript: ^5.0.0 || ^6.0.0
-      vue-tsc: ~3.2.0
+      vue-tsc: ~3.2.0 || ~3.3.0
     peerDependenciesMeta:
       '@ts-macro/tsc':
         optional: true
@@ -1141,6 +1414,9 @@ packages:
     resolution: {integrity: sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A==}
     engines: {node: '>=6'}
 
+  scheduler@0.23.2:
+    resolution: {integrity: sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==}
+
   semver@7.8.5:
     resolution: {integrity: sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==}
     engines: {node: '>=10'}
@@ -1190,18 +1466,20 @@ packages:
     resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==}
     hasBin: true
 
-  tsdown@0.21.10:
-    resolution: {integrity: sha512-3wk73yBhZe/wX7REqSdivNQ84TDs1mJ+IlnzrrEREP70xlJ/AEIzqaI04l/TzMKVIdkTdC3CPaADn2Lk/0SkdA==}
-    engines: {node: '>=20.19.0'}
+  tsdown@0.22.3:
+    resolution: {integrity: sha512-louqbfA8Qf//B9jTTL0FPtXTNpjCWv1VPkbcmQMph2pTpzs+LnB1tbe4tDDRVpo2BjF5SgUXaTZe45SxB8pWHg==}
+    engines: {node: ^22.18.0 || >=24.11.0}
     hasBin: true
     peerDependencies:
       '@arethetypeswrong/core': ^0.18.1
-      '@tsdown/css': 0.21.10
-      '@tsdown/exe': 0.21.10
+      '@tsdown/css': 0.22.3
+      '@tsdown/exe': 0.22.3
       '@vitejs/devtools': '*'
-      publint: ^0.3.0
+      publint: ^0.3.8
+      tsx: '*'
       typescript: ^5.0.0 || ^6.0.0
       unplugin-unused: ^0.5.0
+      unrun: '*'
     peerDependenciesMeta:
       '@arethetypeswrong/core':
         optional: true
@@ -1213,14 +1491,28 @@ packages:
         optional: true
       publint:
         optional: true
+      tsx:
+        optional: true
       typescript:
         optional: true
       unplugin-unused:
         optional: true
+      unrun:
+        optional: true
 
   tslib@2.8.1:
     resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
 
+  tsx@4.22.4:
+    resolution: {integrity: sha512-X8EX+XV4QR5xCsrgxaED954zTDfY8KqlDtskKEL0cHhyS/P8b4IFOvGDQpsC9Q1XnLq915wEfwwY/zzskCtmhg==}
+    engines: {node: '>=18.0.0'}
+    hasBin: true
+
+  typescript@6.0.3:
+    resolution: {integrity: sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
   ultramatter@0.0.4:
     resolution: {integrity: sha512-1f/hO3mR+/Hgue4eInOF/Qm/wzDqwhYha4DxM0hre9YIUyso3fE2XtrAU6B4njLqTC8CM49EZaYgsVSa+dXHGw==}
 
@@ -1352,10 +1644,10 @@ packages:
 
 snapshots:
 
-  '@babel/generator@8.0.0-rc.3':
+  '@babel/generator@8.0.0':
     dependencies:
-      '@babel/parser': 8.0.0-rc.3
-      '@babel/types': 8.0.0-rc.3
+      '@babel/parser': 8.0.0
+      '@babel/types': 8.0.0
       '@jridgewell/gen-mapping': 0.3.13
       '@jridgewell/trace-mapping': 0.3.31
       '@types/jsesc': 2.5.1
@@ -1363,45 +1655,34 @@ snapshots:
 
   '@babel/helper-string-parser@8.0.0': {}
 
-  '@babel/helper-validator-identifier@8.0.0-rc.3': {}
-
   '@babel/helper-validator-identifier@8.0.2': {}
 
   '@babel/parser@8.0.0':
     dependencies:
       '@babel/types': 8.0.0
 
-  '@babel/parser@8.0.0-rc.3':
-    dependencies:
-      '@babel/types': 8.0.0-rc.3
-
   '@babel/types@8.0.0':
     dependencies:
       '@babel/helper-string-parser': 8.0.0
       '@babel/helper-validator-identifier': 8.0.2
 
-  '@babel/types@8.0.0-rc.3':
-    dependencies:
-      '@babel/helper-string-parser': 8.0.0
-      '@babel/helper-validator-identifier': 8.0.0-rc.3
-
   '@bomb.sh/args@0.3.1': {}
 
-  '@bomb.sh/tools@0.5.3(@types/node@26.0.0)(oxc-resolver@11.21.3)(vite@8.1.0(@types/node@26.0.0)(jiti@2.7.0)(yaml@2.9.0))':
+  '@bomb.sh/tools@0.5.4(@types/node@26.0.0)(oxc-resolver@11.21.3)(tsx@4.22.4)(typescript@6.0.3)(unrun@0.2.39)(vite@8.1.0(@types/node@26.0.0)(esbuild@0.28.1)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))':
     dependencies:
       '@bomb.sh/args': 0.3.1
       '@humanfs/node': 0.16.8
       '@humanfs/types': 0.15.0
-      '@typescript/native-preview': 7.0.0-dev.20260427.1
+      '@typescript/native-preview': 7.0.0-dev.20260623.1
       knip: 6.18.0
       oxfmt: 0.47.0
       oxlint: 1.71.0
       publint: 0.3.21
       tinyexec: 1.2.4
-      tsdown: 0.21.10(@typescript/native-preview@7.0.0-dev.20260427.1)(oxc-resolver@11.21.3)(publint@0.3.21)
+      tsdown: 0.22.3(@typescript/native-preview@7.0.0-dev.20260623.1)(oxc-resolver@11.21.3)(publint@0.3.21)(tsx@4.22.4)(typescript@6.0.3)(unrun@0.2.39)
       ultramatter: 0.0.4
-      vitest: 4.1.9(@types/node@26.0.0)(vite@8.1.0(@types/node@26.0.0)(jiti@2.7.0)(yaml@2.9.0))
-      vitest-ansi-serializer: 0.2.1(vitest@4.1.9(@types/node@26.0.0)(vite@8.1.0(@types/node@26.0.0)(jiti@2.7.0)(yaml@2.9.0)))
+      vitest: 4.1.9(@types/node@26.0.0)(vite@8.1.0(@types/node@26.0.0)(esbuild@0.28.1)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
+      vitest-ansi-serializer: 0.2.1(vitest@4.1.9(@types/node@26.0.0)(vite@8.1.0(@types/node@26.0.0)(esbuild@0.28.1)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0)))
     transitivePeerDependencies:
       - '@arethetypeswrong/core'
       - '@edge-runtime/vm'
@@ -1422,14 +1703,17 @@ snapshots:
       - msw
       - oxc-resolver
       - oxlint-tsgolint
-      - synckit
+      - tsx
       - typescript
       - unplugin-unused
+      - unrun
       - vite
       - vite-plus
       - vue-tsc
 
-  '@bomb.sh/tty@0.7.0': {}
+  '@bomb.sh/tty@0.8.0': {}
+
+  '@bomb.sh/tty@https://pkg.pr.new/@bomb.sh/tty@103': {}
 
   '@emnapi/core@1.10.0':
     dependencies:
@@ -1474,6 +1758,84 @@ snapshots:
       tslib: 2.8.1
     optional: true
 
+  '@esbuild/aix-ppc64@0.28.1':
+    optional: true
+
+  '@esbuild/android-arm64@0.28.1':
+    optional: true
+
+  '@esbuild/android-arm@0.28.1':
+    optional: true
+
+  '@esbuild/android-x64@0.28.1':
+    optional: true
+
+  '@esbuild/darwin-arm64@0.28.1':
+    optional: true
+
+  '@esbuild/darwin-x64@0.28.1':
+    optional: true
+
+  '@esbuild/freebsd-arm64@0.28.1':
+    optional: true
+
+  '@esbuild/freebsd-x64@0.28.1':
+    optional: true
+
+  '@esbuild/linux-arm64@0.28.1':
+    optional: true
+
+  '@esbuild/linux-arm@0.28.1':
+    optional: true
+
+  '@esbuild/linux-ia32@0.28.1':
+    optional: true
+
+  '@esbuild/linux-loong64@0.28.1':
+    optional: true
+
+  '@esbuild/linux-mips64el@0.28.1':
+    optional: true
+
+  '@esbuild/linux-ppc64@0.28.1':
+    optional: true
+
+  '@esbuild/linux-riscv64@0.28.1':
+    optional: true
+
+  '@esbuild/linux-s390x@0.28.1':
+    optional: true
+
+  '@esbuild/linux-x64@0.28.1':
+    optional: true
+
+  '@esbuild/netbsd-arm64@0.28.1':
+    optional: true
+
+  '@esbuild/netbsd-x64@0.28.1':
+    optional: true
+
+  '@esbuild/openbsd-arm64@0.28.1':
+    optional: true
+
+  '@esbuild/openbsd-x64@0.28.1':
+    optional: true
+
+  '@esbuild/openharmony-arm64@0.28.1':
+    optional: true
+
+  '@esbuild/sunos-x64@0.28.1':
+    optional: true
+
+  '@esbuild/win32-arm64@0.28.1':
+    optional: true
+
+  '@esbuild/win32-ia32@0.28.1':
+    optional: true
+
+  '@esbuild/win32-x64@0.28.1':
+    optional: true
+
   '@humanfs/core@0.19.2':
     dependencies:
       '@humanfs/types': 0.15.0
@@ -1587,7 +1949,8 @@ snapshots:
   '@oxc-parser/binding-win32-x64-msvc@0.137.0':
     optional: true
 
-  '@oxc-project/types@0.127.0': {}
+  '@oxc-project/types@0.127.0':
+    optional: true
 
   '@oxc-project/types@0.137.0': {}
 
@@ -1872,7 +2235,8 @@ snapshots:
   '@rolldown/binding-win32-x64-msvc@1.1.2':
     optional: true
 
-  '@rolldown/pluginutils@1.0.0-rc.17': {}
+  '@rolldown/pluginutils@1.0.0-rc.17':
+    optional: true
 
   '@rolldown/pluginutils@1.0.1': {}
 
@@ -1898,36 +2262,47 @@ snapshots:
     dependencies:
       undici-types: 8.3.0
 
-  '@typescript/native-preview-darwin-arm64@7.0.0-dev.20260427.1':
+  '@types/prop-types@15.7.15': {}
+
+  '@types/react-reconciler@0.28.9(@types/react@18.3.31)':
+    dependencies:
+      '@types/react': 18.3.31
+
+  '@types/react@18.3.31':
+    dependencies:
+      '@types/prop-types': 15.7.15
+      csstype: 3.2.3
+
+  '@typescript/native-preview-darwin-arm64@7.0.0-dev.20260623.1':
     optional: true
 
-  '@typescript/native-preview-darwin-x64@7.0.0-dev.20260427.1':
+  '@typescript/native-preview-darwin-x64@7.0.0-dev.20260623.1':
     optional: true
 
-  '@typescript/native-preview-linux-arm64@7.0.0-dev.20260427.1':
+  '@typescript/native-preview-linux-arm64@7.0.0-dev.20260623.1':
     optional: true
 
-  '@typescript/native-preview-linux-arm@7.0.0-dev.20260427.1':
+  '@typescript/native-preview-linux-arm@7.0.0-dev.20260623.1':
     optional: true
 
-  '@typescript/native-preview-linux-x64@7.0.0-dev.20260427.1':
+  '@typescript/native-preview-linux-x64@7.0.0-dev.20260623.1':
     optional: true
 
-  '@typescript/native-preview-win32-arm64@7.0.0-dev.20260427.1':
+  '@typescript/native-preview-win32-arm64@7.0.0-dev.20260623.1':
     optional: true
 
-  '@typescript/native-preview-win32-x64@7.0.0-dev.20260427.1':
+  '@typescript/native-preview-win32-x64@7.0.0-dev.20260623.1':
     optional: true
 
-  '@typescript/native-preview@7.0.0-dev.20260427.1':
+  '@typescript/native-preview@7.0.0-dev.20260623.1':
     optionalDependencies:
-      '@typescript/native-preview-darwin-arm64': 7.0.0-dev.20260427.1
-      '@typescript/native-preview-darwin-x64': 7.0.0-dev.20260427.1
-      '@typescript/native-preview-linux-arm': 7.0.0-dev.20260427.1
-      '@typescript/native-preview-linux-arm64': 7.0.0-dev.20260427.1
-      '@typescript/native-preview-linux-x64': 7.0.0-dev.20260427.1
-      '@typescript/native-preview-win32-arm64': 7.0.0-dev.20260427.1
-      '@typescript/native-preview-win32-x64': 7.0.0-dev.20260427.1
+      '@typescript/native-preview-darwin-arm64': 7.0.0-dev.20260623.1
+      '@typescript/native-preview-darwin-x64': 7.0.0-dev.20260623.1
+      '@typescript/native-preview-linux-arm': 7.0.0-dev.20260623.1
+      '@typescript/native-preview-linux-arm64': 7.0.0-dev.20260623.1
+      '@typescript/native-preview-linux-x64': 7.0.0-dev.20260623.1
+      '@typescript/native-preview-win32-arm64': 7.0.0-dev.20260623.1
+      '@typescript/native-preview-win32-x64': 7.0.0-dev.20260623.1
 
   '@vitest/expect@4.1.9':
     dependencies:
@@ -1938,13 +2313,13 @@ snapshots:
       chai: 6.2.2
       tinyrainbow: 3.1.0
 
-  '@vitest/mocker@4.1.9(vite@8.1.0(@types/node@26.0.0)(jiti@2.7.0)(yaml@2.9.0))':
+  '@vitest/mocker@4.1.9(vite@8.1.0(@types/node@26.0.0)(esbuild@0.28.1)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))':
     dependencies:
       '@vitest/spy': 4.1.9
       estree-walker: 3.0.3
       magic-string: 0.30.21
     optionalDependencies:
-      vite: 8.1.0(@types/node@26.0.0)(jiti@2.7.0)(yaml@2.9.0)
+      vite: 8.1.0(@types/node@26.0.0)(esbuild@0.28.1)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0)
 
   '@vitest/pretty-format@4.1.9':
     dependencies:
@@ -1988,18 +2363,51 @@ snapshots:
 
   convert-source-map@2.0.0: {}
 
+  csstype@3.2.3: {}
+
   defu@6.1.7: {}
 
   detect-libc@2.1.2: {}
 
-  dts-resolver@2.1.3(oxc-resolver@11.21.3):
+  dts-resolver@3.0.0(oxc-resolver@11.21.3):
     optionalDependencies:
       oxc-resolver: 11.21.3
 
+  effection@4.1.0-alpha.9: {}
+
   empathic@2.0.1: {}
 
   es-module-lexer@2.1.0: {}
 
+  esbuild@0.28.1:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.28.1
+      '@esbuild/android-arm': 0.28.1
+      '@esbuild/android-arm64': 0.28.1
+      '@esbuild/android-x64': 0.28.1
+      '@esbuild/darwin-arm64': 0.28.1
+      '@esbuild/darwin-x64': 0.28.1
+      '@esbuild/freebsd-arm64': 0.28.1
+      '@esbuild/freebsd-x64': 0.28.1
+      '@esbuild/linux-arm': 0.28.1
+      '@esbuild/linux-arm64': 0.28.1
+      '@esbuild/linux-ia32': 0.28.1
+      '@esbuild/linux-loong64': 0.28.1
+      '@esbuild/linux-mips64el': 0.28.1
+      '@esbuild/linux-ppc64': 0.28.1
+      '@esbuild/linux-riscv64': 0.28.1
+      '@esbuild/linux-s390x': 0.28.1
+      '@esbuild/linux-x64': 0.28.1
+      '@esbuild/netbsd-arm64': 0.28.1
+      '@esbuild/netbsd-x64': 0.28.1
+      '@esbuild/openbsd-arm64': 0.28.1
+      '@esbuild/openbsd-x64': 0.28.1
+      '@esbuild/openharmony-arm64': 0.28.1
+      '@esbuild/sunos-x64': 0.28.1
+      '@esbuild/win32-arm64': 0.28.1
+      '@esbuild/win32-ia32': 0.28.1
+      '@esbuild/win32-x64': 0.28.1
+
   estree-walker@3.0.3:
     dependencies:
       '@types/estree': 1.0.9
@@ -2025,12 +2433,18 @@ snapshots:
     dependencies:
       resolve-pkg-maps: 1.0.0
 
+  get-tsconfig@5.0.0-beta.5:
+    dependencies:
+      resolve-pkg-maps: 1.0.0
+
   hookable@6.1.1: {}
 
-  import-without-cache@0.3.3: {}
+  import-without-cache@0.4.0: {}
 
   jiti@2.7.0: {}
 
+  js-tokens@4.0.0: {}
+
   jsesc@3.1.0: {}
 
   knip@6.18.0:
@@ -2098,6 +2512,10 @@ snapshots:
       lightningcss-win32-arm64-msvc: 1.32.0
       lightningcss-win32-x64-msvc: 1.32.0
 
+  loose-envify@1.4.0:
+    dependencies:
+      js-tokens: 4.0.0
+
   magic-string@0.30.21:
     dependencies:
       '@jridgewell/sourcemap-codec': 1.5.5
@@ -2224,23 +2642,32 @@ snapshots:
 
   quansync@1.0.0: {}
 
+  react-reconciler@0.29.2(react@18.3.1):
+    dependencies:
+      loose-envify: 1.4.0
+      react: 18.3.1
+      scheduler: 0.23.2
+
+  react@18.3.1:
+    dependencies:
+      loose-envify: 1.4.0
+
   resolve-pkg-maps@1.0.0: {}
 
-  rolldown-plugin-dts@0.23.2(@typescript/native-preview@7.0.0-dev.20260427.1)(oxc-resolver@11.21.3)(rolldown@1.0.0-rc.17):
+  rolldown-plugin-dts@0.26.0(@typescript/native-preview@7.0.0-dev.20260623.1)(oxc-resolver@11.21.3)(rolldown@1.1.2)(typescript@6.0.3):
     dependencies:
-      '@babel/generator': 8.0.0-rc.3
-      '@babel/helper-validator-identifier': 8.0.0-rc.3
-      '@babel/parser': 8.0.0-rc.3
-      '@babel/types': 8.0.0-rc.3
+      '@babel/generator': 8.0.0
+      '@babel/helper-validator-identifier': 8.0.2
+      '@babel/parser': 8.0.0
       ast-kit: 3.0.0
       birpc: 4.0.0
-      dts-resolver: 2.1.3(oxc-resolver@11.21.3)
-      get-tsconfig: 4.14.0
+      dts-resolver: 3.0.0(oxc-resolver@11.21.3)
+      get-tsconfig: 5.0.0-beta.5
       obug: 2.1.3
-      picomatch: 4.0.4
-      rolldown: 1.0.0-rc.17
+      rolldown: 1.1.2
     optionalDependencies:
-      '@typescript/native-preview': 7.0.0-dev.20260427.1
+      '@typescript/native-preview': 7.0.0-dev.20260623.1
+      typescript: 6.0.3
     transitivePeerDependencies:
       - oxc-resolver
 
@@ -2264,6 +2691,7 @@ snapshots:
       '@rolldown/binding-wasm32-wasi': 1.0.0-rc.17
       '@rolldown/binding-win32-arm64-msvc': 1.0.0-rc.17
       '@rolldown/binding-win32-x64-msvc': 1.0.0-rc.17
+    optional: true
 
   rolldown@1.1.2:
     dependencies:
@@ -2290,6 +2718,10 @@ snapshots:
     dependencies:
       mri: 1.2.0
 
+  scheduler@0.23.2:
+    dependencies:
+      loose-envify: 1.4.0
+
   semver@7.8.5: {}
 
   siginfo@2.0.0: {}
@@ -2319,36 +2751,45 @@ snapshots:
 
   tree-kill@1.2.2: {}
 
-  tsdown@0.21.10(@typescript/native-preview@7.0.0-dev.20260427.1)(oxc-resolver@11.21.3)(publint@0.3.21):
+  tsdown@0.22.3(@typescript/native-preview@7.0.0-dev.20260623.1)(oxc-resolver@11.21.3)(publint@0.3.21)(tsx@4.22.4)(typescript@6.0.3)(unrun@0.2.39):
     dependencies:
       ansis: 4.3.1
       cac: 7.0.0
       defu: 6.1.7
       empathic: 2.0.1
       hookable: 6.1.1
-      import-without-cache: 0.3.3
+      import-without-cache: 0.4.0
       obug: 2.1.3
       picomatch: 4.0.4
-      rolldown: 1.0.0-rc.17
-      rolldown-plugin-dts: 0.23.2(@typescript/native-preview@7.0.0-dev.20260427.1)(oxc-resolver@11.21.3)(rolldown@1.0.0-rc.17)
+      rolldown: 1.1.2
+      rolldown-plugin-dts: 0.26.0(@typescript/native-preview@7.0.0-dev.20260623.1)(oxc-resolver@11.21.3)(rolldown@1.1.2)(typescript@6.0.3)
       semver: 7.8.5
       tinyexec: 1.2.4
       tinyglobby: 0.2.17
       tree-kill: 1.2.2
       unconfig-core: 7.5.0
-      unrun: 0.2.39
     optionalDependencies:
       publint: 0.3.21
+      tsx: 4.22.4
+      typescript: 6.0.3
+      unrun: 0.2.39
     transitivePeerDependencies:
       - '@ts-macro/tsc'
       - '@typescript/native-preview'
       - oxc-resolver
-      - synckit
       - vue-tsc
 
   tslib@2.8.1:
     optional: true
 
+  tsx@4.22.4:
+    dependencies:
+      esbuild: 0.28.1
+    optionalDependencies:
+      fsevents: 2.3.3
+
+  typescript@6.0.3: {}
+
   ultramatter@0.0.4: {}
 
   unbash@4.0.1: {}
@@ -2363,8 +2804,9 @@ snapshots:
   unrun@0.2.39:
     dependencies:
       rolldown: 1.0.0-rc.17
+    optional: true
 
-  vite@8.1.0(@types/node@26.0.0)(jiti@2.7.0)(yaml@2.9.0):
+  vite@8.1.0(@types/node@26.0.0)(esbuild@0.28.1)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0):
     dependencies:
       lightningcss: 1.32.0
       picomatch: 4.0.4
@@ -2373,18 +2815,20 @@ snapshots:
       tinyglobby: 0.2.17
     optionalDependencies:
       '@types/node': 26.0.0
+      esbuild: 0.28.1
       fsevents: 2.3.3
       jiti: 2.7.0
+      tsx: 4.22.4
       yaml: 2.9.0
 
-  vitest-ansi-serializer@0.2.1(vitest@4.1.9(@types/node@26.0.0)(vite@8.1.0(@types/node@26.0.0)(jiti@2.7.0)(yaml@2.9.0))):
+  vitest-ansi-serializer@0.2.1(vitest@4.1.9(@types/node@26.0.0)(vite@8.1.0(@types/node@26.0.0)(esbuild@0.28.1)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))):
     dependencies:
-      vitest: 4.1.9(@types/node@26.0.0)(vite@8.1.0(@types/node@26.0.0)(jiti@2.7.0)(yaml@2.9.0))
+      vitest: 4.1.9(@types/node@26.0.0)(vite@8.1.0(@types/node@26.0.0)(esbuild@0.28.1)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
 
-  vitest@4.1.9(@types/node@26.0.0)(vite@8.1.0(@types/node@26.0.0)(jiti@2.7.0)(yaml@2.9.0)):
+  vitest@4.1.9(@types/node@26.0.0)(vite@8.1.0(@types/node@26.0.0)(esbuild@0.28.1)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0)):
     dependencies:
       '@vitest/expect': 4.1.9
-      '@vitest/mocker': 4.1.9(vite@8.1.0(@types/node@26.0.0)(jiti@2.7.0)(yaml@2.9.0))
+      '@vitest/mocker': 4.1.9(vite@8.1.0(@types/node@26.0.0)(esbuild@0.28.1)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0))
       '@vitest/pretty-format': 4.1.9
       '@vitest/runner': 4.1.9
       '@vitest/snapshot': 4.1.9
@@ -2401,7 +2845,7 @@ snapshots:
       tinyexec: 1.2.4
       tinyglobby: 0.2.17
       tinyrainbow: 3.1.0
-      vite: 8.1.0(@types/node@26.0.0)(jiti@2.7.0)(yaml@2.9.0)
+      vite: 8.1.0(@types/node@26.0.0)(esbuild@0.28.1)(jiti@2.7.0)(tsx@4.22.4)(yaml@2.9.0)
       why-is-node-running: 2.3.0
     optionalDependencies:
       '@types/node': 26.0.0
diff --git a/scripts/demo.mjs b/scripts/demo.mjs
new file mode 100644
index 0000000..54d17fb
--- /dev/null
+++ b/scripts/demo.mjs
@@ -0,0 +1,14 @@
+import { spawnSync } from "node:child_process";
+
+const name = process.argv[2];
+if (!name) {
+  console.error("usage: pnpm demo <name>   (e.g. pnpm demo freedom-focus-text-input)");
+  process.exit(1);
+}
+
+const { status } = spawnSync(
+  "node",
+  ["--experimental-transform-types", "--no-warnings", `packages/demo/src/${name}.ts`],
+  { stdio: "inherit" }, // inherit the real TTY: setRawMode works, ANSI renders cleanly
+);
+process.exit(status ?? 0);