diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a1277004..aac27b7d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -33,7 +33,7 @@ jobs:
 
       - uses: actions/setup-node@v6
         with:
-          node-version: 24
+          node-version-file: .nvmrc
           cache: pnpm
 
       - run: pnpm install --frozen-lockfile
diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml
index a42f276a..8585882d 100644
--- a/.github/workflows/deploy-docs.yml
+++ b/.github/workflows/deploy-docs.yml
@@ -26,7 +26,7 @@ jobs:
 
       - uses: actions/setup-node@v6
         with:
-          node-version: 22
+          node-version-file: .nvmrc
           cache: pnpm
 
       - run: pnpm install --frozen-lockfile
diff --git a/package.json b/package.json
index 731ebbc1..2e671f75 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "data-monorepo",
-  "version": "0.9.92",
+  "version": "0.9.93",
   "private": true,
   "engines": {
     "node": ">=24"
diff --git a/packages/data-ai/.claude-plugin/plugin.json b/packages/data-ai/.claude-plugin/plugin.json
index b20f1ba3..24b24366 100644
--- a/packages/data-ai/.claude-plugin/plugin.json
+++ b/packages/data-ai/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "adobe-data-ai",
-  "version": "0.9.92",
+  "version": "0.9.93",
   "description": "Architecture skills for @adobe/data — data-oriented modelling, archetype iteration, hot-path performance, and related conventions.",
   "author": {
     "name": "Adobe"
diff --git a/packages/data-ai/.claude/rules/features/data/index.md b/packages/data-ai/.claude/rules/features/data/index.md
index 2a851b52..06d6c540 100644
--- a/packages/data-ai/.claude/rules/features/data/index.md
+++ b/packages/data-ai/.claude/rules/features/data/index.md
@@ -5,11 +5,17 @@ paths:
 
 # data/ — the data model
 
-The foundation layer: the feature's **data types**. A data type is a
-readonly, JSON-serializable value suitable for persistence and for
-communication over the wire — no functions, no handles, just plain data.
-It depends on nothing but `@adobe/data` and other `data/` declarations, and
-needs no knowledge of anything built on top of it.
+The foundation layer: the feature's **data types** and the pure declarations
+over them. A data type is a readonly, JSON-serializable value suitable for
+persistence and for communication over the wire — no functions, no handles, just
+plain data. A `data/` **type** depends on nothing but `@adobe/data` and other
+`data/` types, and needs no knowledge of anything built on top of it. The
+**transitions** over those types are less restricted: when one injects a service
+it may import freely from `services/` — the service type and any utilities its
+namespace exposes (see `state.md`). What it must **never** touch is `ui/`:
+`data/` never depends on presentation — that isolation is strict and inviolable.
+Only *services themselves* are never authored here; that is what makes this the
+value-type layer.
 
 Each data type is its own namespace folder (see `global/namespace.md`), holding
 its hand-authored type, its (optional, matching) schema, and its pure
diff --git a/packages/data-ai/.claude/rules/features/data/state.md b/packages/data-ai/.claude/rules/features/data/state.md
index 1b90d8ea..3ac88c94 100644
--- a/packages/data-ai/.claude/rules/features/data/state.md
+++ b/packages/data-ai/.claude/rules/features/data/state.md
@@ -5,55 +5,212 @@ paths:
 
 # data/state/ — the State specification
 
-`State` is the whole feature modelled as **one immutable object** — the
-pure, fully-tested source of truth for the feature. Modelling everything as
-a single value keeps each transform a small, trivially-testable function of
-state: collections of entity sub-types plus scalar fields.
+`State` is the whole feature as **one immutable object** — the pure, fully-tested
+source of truth. Each transition is a read→write **patch** over state; each
+derivation a pure selector. Reference: `data-lit-todo`'s `data/state/`.
 
-Every feature that has ECS resources or transactions owns a `State` — including
-a host whose aggregate is a single scalar (`{ playing: boolean }`) or even when there is no state in which case use `{}`. 
 ```ts
-// state.ts — the aggregate, plus the namespace of transforms/derivations.
-export type State = {
-    readonly todos: readonly Todo[];        // a collection of entity sub-types
-    readonly displayCompleted: boolean;     // a scalar field
-};
+// state.ts — the aggregate + the transition/derivation namespace.
+export type State = { readonly todos: readonly Todo[]; readonly displayCompleted: boolean };
 export * as State from "./public.js";
 ```
 
-## Transforms — one per file, `(state, …args) => state`
-
-- **Pure.** No I/O, no framework, no mutation — return a new value.
-- **Narrow in, same shape out.** Write on the smallest slice the transform
-  needs and keep the input generic over that slice so it lifts to
-  full-state-in / full-state-out:
-
-  ```ts
-  export const playMove = <T extends Pick<State, "board" | "firstPlayer">>(
-      state: T,
-      input: PlayMoveArgs,
-  ): T => { /* … return { ...state, board: … } */ };
-  ```
-
-  A whole-`State` transform (`restartGame(state: State): State`) is fine when
-  it genuinely touches everything.
-- Args may be **narrowed or omitted** (`toggleDisplayCompleted(state)`).
-- Guard and **return `state` unchanged** on a no-op / illegal input rather
-  than throwing — this keeps transforms idempotent under repeated application.
-- Each transform has a sibling `*.test.ts`; performance is irrelevant here,
-  correctness is everything. The test file **exports** its cases —
-  `export const cases: ConformanceCase<Args>[]` (the shared `conformance-case.ts`
-  type) — right alongside the `describe`/`it` that exercise them. This is
-  spec-owned truth the matching main-service conformance test imports **from the
-  `<transform>.test.js` file** unchanged (see `services/main-service/conformance.md`).
-  Keeping the cases in the test file rather than a separate `<transform>.cases.ts`
-  removes a file per transform — less folder clutter, same reuse. Author
-  `before`/`after` as full `State` (`{ ...State.create(), …overrides }`); the
-  generic-slice signature lets them flow through. Tolerant full-`State` equality is
-  the shared `expect-state-matches.ts`.
-
-## Derivations — `(state) => value`
-
-Pure selectors (`visibleTodos(state)`). Sub-type math (a winner, a status)
-lives on the relevant `data/<type>` namespace; `state/` only composes over
-the whole aggregate.
+Every feature with ECS resources/transactions owns a `State` (a scalar
+`{ playing: boolean }`, or `{}` when there is none).
+
+**`State` has a standard shape.** Two exports are conventional and drive
+conformance:
+
+- **`create(): State`** (`data/state/create.ts`) — the default state. Every
+  conformance case's `before` is a **delta over `State.create()`**, and both the
+  pure `spec.test.ts` and the ecs `runFeature` seed from it.
+- **`samples: readonly State[]`** (`data/state/samples.ts`) — representative
+  **full** states `runFeature` round-trips through the projection
+  (`toState ∘ fromState ≡ identity`, see `conformance.md`).
+
+Both are re-exported through `public.js`, so `State.create()` / `State.samples`
+are namespace members. (A `cases` literal must still not touch `public.js` at
+load — import `create` from `./create.js` directly there; see below.)
+
+**The discovered transitions are a test-only sibling, NOT on the namespace.**
+`data/state/transitions.ts` exports one `import.meta.glob` of the folder — the
+`{ fn, cases }` modules — imported by *both* `spec.test.ts` and the ecs
+`conformance.test.ts` so the glob is authored once per feature:
+
+```ts
+// data/state/transitions.ts — test-only; both test entry points import it
+export const transitions = import.meta.glob<Record<string, unknown>>(
+  ["./*.ts", "!./*.test.ts", "!./*.type-test.ts", "!./transitions.ts"],
+  { eager: true },
+);
+```
+
+It stays **out of `public.js`** deliberately: unlike `create`/`samples` (plain
+prod-safe values), `transitions` is the test-case graph — hanging it on `State`
+would drag `import.meta.glob` (a Vite-only construct) and every `cases` fixture
+(fake services, matchers, the whole `@adobe/data/testing` module) into every
+production import of `State`, none of which tree-shakes off a live namespace
+re-export. So `create`/`samples` earn a namespace slot; `transitions` is a test
+concern the tests import directly.
+
+## One file per transform: the function **and** its cases
+
+A transform file exports **exactly two things** — the function and its
+`cases` — nothing else (a private helper is fine; a second export is not, and the
+spec aggregator throws if it finds one). The cases are the spec-owned truth every
+conformance runner reuses; co-locating them removes the per-transform `.cases.ts`
+and `.test.ts`.
+
+**Why co-locate `cases` (not a sibling `*.test.ts`)?** They are spec-owned
+fixtures the pure `spec.test.ts` **and** the ecs `runFeature` call both reuse
+(driving transaction / action / computed conformance) — the transform's contract
+expressed as data, not a per-file test — so they belong
+beside the thing they specify, and `Conformance<typeof fn>` binds them to the
+signature so they can't drift. Kept inert (no `describe`; one aggregator runs
+them) they also sidestep the double execution vitest triggers when a single file
+both exports cases and runs its own `describe`. Coverage is then enforced
+centrally by the shared driver's barrel-driven guard rather than by eyeballing
+one test file per transform — and genuine non-transition helpers still keep
+their own `*.test.ts` (see below).
+
+The case types, matchers, and runners all live in the shared
+**`@adobe/data/testing`** module (two namespaces, `Match` and `Conformance`;
+`vitest` is an *optional* peer dependency, already satisfied here). Only one
+tiny per-feature file remains — a ~10-line alias, `conformance-case.ts`, that
+binds `State` once so transform/derivation files can write a one-parameter type:
+
+```ts
+// data/state/conformance-case.ts — the only per-feature conformance declaration
+import { Conformance as ConformanceApi } from "@adobe/data/testing";
+import type { State } from "./state.js";
+export type Conformance<F extends (...args: never[]) => unknown> = ConformanceApi.Cases<State, F>;
+export type Derivation<F extends (...args: never[]) => unknown> = ConformanceApi.DerivationCases<F>;
+export type Effects<Args> = ConformanceApi.Effects<Args>;
+// The entity-reference marker for identity-addressed case args, re-exported so
+// cases import it beside `Conformance`: `args: { id: entity(2) }`.
+export const entity = ConformanceApi.entity;
+```
+
+```ts
+// create-todo.ts
+import { Match } from "@adobe/data/testing";
+import type { Conformance } from "./conformance-case.js"; // the thin per-feature alias above
+export const createTodo = (
+    state: Pick<State, "todos">,
+    { name, complete, analytics }: { name: string; complete?: boolean; analytics: AnalyticsService },
+): Pick<State, "todos"> => {
+    analytics.todoCreated({ name });
+    return { todos: [...state.todos, { name, complete: complete ?? false }] }; // writes patch only
+};
+
+export const cases: Conformance<typeof createTodo> = [
+    { name: "appends the first todo",
+      before: {},                       // empty delta — the default State.create()
+      args: { name: "a", analytics: AnalyticsService.createFake() },
+      after: { todos: [{ id: Match.anyNumber, name: "a", complete: false }] }, // only the changed field
+      effects: { analytics: [["todoCreated", { name: "a" }]] } },
+];
+```
+
+- **Signature** `(state: Pick<State, …reads>, args) => Pick<State, …writes>` — a
+  **read→write patch**. The parameter is the smallest `Pick<State,…>` the
+  transition **reads**; the return is *only the fields it **writes***. **No
+  `<T> => T` generic, no `...state` spread** in the return — return the patch and
+  let the runner merge it. **All non-state inputs go in the single `args` object**
+  (`Conformance<typeof fn>` reads `Parameters[1]`) — bundle a `dt`, an injected
+  service, etc. into it, never as a third positional. A transition that takes
+  **no** args omits `args` from each case entirely (the shared `Case` type makes
+  `args` optional exactly then). **Guard no-ops by returning an empty patch `{}`**
+  (or the unchanged slice), never throw.
+- **A composer merges sub-patches explicitly.** A transition built from smaller
+  ones spreads them — `return { ...s, ...sub(s) }` — so each sub-patch's writes
+  layer in; a transition that merely **delegates** to one sub-transition returns
+  that delegate's patch directly (no spread needed).
+- **Co-located `cases` must not touch the feature's `public.js` barrel at module
+  load** — that barrel re-exports this very file, so calling `State.create()` (or
+  any barrel member) in a top-level `cases` literal dead-locks the import cycle.
+  Import the concrete helper directly (`import { create } from "./create.js"`) or
+  inline full-`State` literals.
+- **`Conformance<typeof fn>`** (the alias above) derives the case `args` type from
+  the function's own signature — author it once, and cases can't drift from what
+  the function accepts. **`before` is a delta over `State.create()`** — list only
+  the fields this case sets differently from the default; **`after` is the writes
+  patch** — only the fields the transition changes. The runner seeds
+  `{ ...State.create(), ...before }` and compares against
+  `{ ...State.create(), ...before, ...after }`, so any field a case doesn't mention
+  is the default and stays unchanged. (A full `before`/`after` still works — it just
+  overrides the default wholesale.)
+- **`after` leaves minted values open** with the shared matchers `Match.anyNumber`
+  / `Match.anyString`, imported from `@adobe/data/testing` — there is **no**
+  per-feature `matchers.ts` anymore. An id the ECS assigns from its own id-space is
+  `id: Match.anyNumber`, so the pure spec and the ECS satisfy the same case — match
+  by content, not by the value you don't control. `Match` is framework-agnostic and
+  honors any asymmetric matcher, so vitest's `expect.stringContaining(...)` interops
+  on the expected side too. When an id must **line up in two places** within one
+  comparison — a `selectedId` that points at a specific todo, say — use
+  `Match.ref(label)`: it asserts id *correspondence* (a bijection up to renaming),
+  not a pinned value, so the two occurrences of the label must resolve to the same
+  actual id and two labels can't collide. `anyNumber`/`anyString` are for an id a
+  case does not pin at all; `ref` for one that must be consistent across the case.
+- **Entity-addressed cases use `entity(specId)`.** A transition that addresses an
+  entity by id writes it as `args: { id: entity(2) }` — `entity` imported from the
+  feature's `conformance-case.ts` (re-exported from `@adobe/data/testing`). It types
+  as the id it stands for (like `Match.anyNumber`), so it slots into the transform's
+  own arg type. `runSpec` unwraps it to the plain data-id for the pure side; the ECS
+  runners resolve it to the seeded entity (see `conformance.md`).
+- No per-transform test. The single **`spec.test.ts`** is one call —
+  `Conformance.runSpec({ state: State, transitions })` importing `transitions`
+  from the test-only `./transitions.js` (above) — that auto-discovers every module
+  exporting `cases`, enforces the two-exports rule, and dispatches on case shape (a
+  `value` case → derivation; otherwise a transition whose declared `effects` are
+  also asserted). Passing `{ state: State }` (the same `state` shape `runFeature`
+  takes) is what makes each case's `before`/`input` a delta over `State.create()`.
+  Add `match` alongside it only when
+  the feature needs float tolerance or unordered collections (see `conformance.md`).
+  There is no per-feature `expect-state-matches.ts`, `record-effects.ts`,
+  `expect-conforms.ts`, or `conformance-case.type-test.ts` — those are gone; the
+  shared driver owns comparison, effect recording, and name-based auto-pairing, and
+  the `Effects` type-test now lives once in `@adobe/data/testing`. A genuine **non-transition helper** in
+  `state/` — a `create()` constructor, a single-field predicate — has no `cases`
+  and isn't a `(state,args)=>state` transform, so `runSpec` skips it: **keep its own
+  sibling `*.test.ts`** rather than deleting it and losing coverage.
+
+## Injected services and side effects
+
+A transform that needs an outside capability receives it as a **named parameter**
+in the args object, keyed by the service name minus its `-service` suffix
+(`AnalyticsService` → `analytics`, `NameGeneratorService` → `nameGenerator`);
+plain data args sit alongside. Import the service straight from `services/` (an
+ordinary import — layers split by kind of type, not dependency). The **same
+services appear on `db.services` for the matching action**, so the transition is
+the complete spec of *both* the state change and the service calls.
+
+- A transition **is deterministic given its dependencies** — inject a fixed
+  double and the output (and its calls) are fixed. An **async** dependency makes
+  the transition `Promise<State>`; keep sync the default.
+- **Side effects are declared in the case's `effects`**, keyed by the service
+  arg, as `[methodName, ...args]` tuples — an `Array` asserts these calls in
+  order, a `Set` in any order. Only listed services are checked (a value-returning
+  read like `generateName` you don't list is ignored). See `conformance.md` for
+  how the recording double captures them.
+- Tests inject **deterministic doubles** (never production) whose published
+  responses the case's `after`/`effects` are authored against — doubles live
+  adjacent to the interface (`features/services/index.md`).
+
+## Derivations — `(state) => value`, cases `{ input, value }`
+
+Pure selectors that **compose the aggregate** — a value drawn from **two or more
+`State` fields** (`visibleTodos` from `todos` + `displayCompleted`;
+`currentPlayer` from `board` + `firstPlayer`). A value computed from a **single**
+`State` field is that field's own type math and lives on its `data/<type>`
+namespace (`winner`/`status` from `board` → `data/board-state`), tested there —
+**not** in `state/`. A feature may therefore have zero `state/` derivations.
+
+A `state/` derivation co-locates cases shaped `{ input, value }`, typed
+`Derivation<typeof fn>` (input + value read from the signature). Take the **full
+`State`** as the parameter (not a `Pick` slice like a transform) — so the case
+`input` type is the full `State` and computed conformance can seed it via
+`fromState`; `value` may use matchers. The same `spec.test.ts` runs them (dispatching on case shape),
+and each ECS computed backing one is conformance-tested from the same cases
+(`conformance.md`). Sub-type math (a winner, a status) lives on the
+relevant `data/<type>` namespace; `state/` only composes over the aggregate.
diff --git a/packages/data-ai/.claude/rules/features/index.md b/packages/data-ai/.claude/rules/features/index.md
index b580ac15..47f6de9c 100644
--- a/packages/data-ai/.claude/rules/features/index.md
+++ b/packages/data-ai/.claude/rules/features/index.md
@@ -26,9 +26,25 @@ derive a fast one that provably behaves the same.
 
 ## The layers
 
-`ui → services → data` — higher imports lower, never the reverse. `data/`
-depends on nothing but `@adobe/data` and other `data/` declarations. A feature
-creates only the layers it uses.
+**The layers organize by the *kind of type* each folder holds, not by a strict
+dependency wall.** `data/` holds **value types** (pure, serializable data) and
+the pure declarations over them; `services/` holds **service types** (interfaces
+**and** implementations); `ui/` holds presentation. The rule is about *what
+lives where*: a service is never authored under `data/`, a value type is never
+authored under `services/`.
+
+**`ui/` isolation is strict and inviolable.** `ui/` sits at the top: neither
+`data/` nor `services/` may ever import from `ui/`, no exceptions. Presentation
+depends on the model; the model never depends on presentation.
+
+Beneath that hard line, `data/` and `services/` are **not** strictly ordered.
+Value types are fundamental — a `data/` **type** depends on nothing but
+`@adobe/data` and other `data/` types. But the **transition functions** over
+them may depend on `services/` **without restriction**: they import whatever they
+need — service interfaces they inject, and any associated utilities the service
+namespace exposes — as ordinary imports, not type-only. So the strict wall is
+`ui/` above `data/` + `services/`; the `data/ ↔ services/` boundary is the loose
+one. A feature creates only the layers it uses.
 
 | Layer | Role |
 |-------|------|
@@ -85,13 +101,16 @@ The tie between `data/` (spec) and `main-service` (implementation) is
 **conformance**, one property —
 `toState(apply(fromState(before), args)) ≡ transform(before, args)`: each
 main-service mutation, seeded and read back through a test-only store↔`State`
-projection, equals the pure `data/` transform it stands for. The projection and
-its runner live in `services/main-service/conformance/` (see
-`services/main-service/conformance.md`); the shared `{ before, args, after }`
-cases are spec-owned (exported from `data/state/<transform>.test.ts`), so conforming the
-implementation is "substitute the implementation, reuse the expectations." This
-lets `main-service` be largely mechanical and agent-generated, with the spec as
-oracle. *How* to author each layer lives in the per-folder rules below.
+projection, equals the pure `data/` transform it stands for. The per-feature
+projection lives in `services/main-service/conformance/`, and a **single
+`Conformance.runFeature({...})` call** replays the shared cases against the ecs —
+pairing each ECS op to its same-named transition automatically and round-tripping
+the projection (see `services/main-service/conformance.md`);
+the shared `{ before, args, after }` cases are spec-owned — co-located in each
+`data/state/<transform>.ts`, which exports its function plus `cases` — so
+conforming the implementation is "substitute the implementation, reuse the
+expectations." This lets `main-service` be largely mechanical and agent-generated,
+with the spec as oracle. *How* to author each layer lives in the per-folder rules below.
 
 ## Reference implementations
 
diff --git a/packages/data-ai/.claude/rules/features/services/index.md b/packages/data-ai/.claude/rules/features/services/index.md
index 655e4373..90e7d7ba 100644
--- a/packages/data-ai/.claude/rules/features/services/index.md
+++ b/packages/data-ai/.claude/rules/features/services/index.md
@@ -33,6 +33,25 @@ portability and lazy loading (`AsyncDataService.createLazy`).
 - Members are async only: `void | Promise<T> | AsyncGenerator<T> | Observe<T>`.
 - Provide `create*` factories.
 
+## Deterministic test doubles, adjacent to the contract
+
+A service is the seam consumers swap out under test — `data/` transitions that
+take it as an injected dependency (`data/state.md`), actions, systems. Ship a
+**deterministic test double** alongside the interface, in the same namespace
+folder and under the same `global/namespace.md` standard: `create-fake.ts` is a
+**single export**, `createFake`, re-exported through `public.ts` so callers reach
+it as `MyService.createFake` (mirroring the `create` / `factory` pair).
+
+Because tests assert on exact `after` values, the double must be **deterministic
+and its responses caller-controlled**: `createFake` takes the exact response — the
+fixed value, or the ordered sequence each method returns — as a parameter, with a
+small inline default. A conformance case then **injects the responses it needs**
+(`createFake(["random task"])`, `createFake([4])`) and authors its `after` /
+`effects` against those values it supplied — nothing is read from a shared
+published constant (that would be a second export, and it makes the assertion
+guess at a value it doesn't own). The injected schedule is exactly what makes the
+double a dependable oracle: the test controls both the input and the expectation.
+
 ## Where the I/O types live
 
 Most input/output types belong to a single service — declare them **on that
diff --git a/packages/data-ai/.claude/rules/features/services/main-service/actions.md b/packages/data-ai/.claude/rules/features/services/main-service/actions.md
index 8220d1ff..3499d14f 100644
--- a/packages/data-ai/.claude/rules/features/services/main-service/actions.md
+++ b/packages/data-ai/.claude/rules/features/services/main-service/actions.md
@@ -10,6 +10,20 @@ argument and pure `data/` args. Actions orchestrate anything *outside* a
 single transaction — awaiting a `services/` port, sequencing calls, deriving
 timing — and then commit the result through a transaction.
 
+**Every *app-facing, transaction-backed* transition has a corresponding
+same-named action** — the async realization the UI drives. It reads the same
+services the transition injects from `db.services`, so it reproduces both the
+transition's state change (through a transaction) and its side effects. It may
+reuse another transition's transaction (`createRandomTodo` reuses `createTodo`) —
+there need not be a same-named transaction; transactions are the looser layer.
+
+**Per-frame / system transitions are exempt.** In a real-time feature the `step*`
+/ physics / collision transitions are realized by the **systems** tick loop, not
+by an action, and are conformed by the tick-loop test (`systems.md`), not the
+action surface of `runFeature`. Give an action only to transitions a user/UI invokes directly
+(and skip it too when the realization needs more than one transaction — e.g. a
+`newGame` that both sets bounds and resets is conformed via its transaction).
+
 ```ts
 import type { ServiceDatabase } from "../../service-database/service-database.js";
 
@@ -29,4 +43,24 @@ export const addRandomTodo = async (service: ServiceDatabase) => {
   awaited-internally, never surfaced to the caller.
 - Do the outside-world work here: await/sequence `services/` calls, and if a
   slow call needs timing, compute it here around the call.
+- **Read current state synchronously from the store** (`db.resources` / `db.read`
+  / `db.select`, then a pure `data/` helper) — never from a cached `computed`.
+  Reactive computeds refresh only on a committed transaction, so an imperative
+  read of one can hand back a stale shared cache (and it's the UI's layer, not
+  the action's). This also keeps the action correct under the conformance seed.
+- **Conformance** is the action surface of the feature's single
+  `conformance/conformance.test.ts` `Conformance.runFeature({...})` call. It pulls
+  actions off **`plugin.actions`** and pairs each to the **same-named** `data/state`
+  transition. **The action is the primary seam** — it reads injected services from
+  `db.services`, so the case's service args become recording overrides (the runner
+  builds `Database.toSystemDatabase(Database.create(plugin, { services }))`); it
+  splits the case `args` into services and plain input, runs the action, then
+  `Match.assert`s `toState ≡ after` **and** checks the recorded calls against the
+  case's `effects`. There is no `define`/`conforms` and no coverage guard. A thin
+  **same-named** action gives a transaction-only or renamed transition something to
+  pair with (todo's `reorderTodo`). A streaming/capability action with no transition
+  is skipped. **A per-transition action kept out of the facet** (to bound the
+  plugin's type) is discovered via `runFeature`'s `ops.actions` glob —
+  `ops: { actions: import.meta.glob([".../actions/*.ts", "!.../actions/index.ts"], { eager: true }) }`
+  (p2p negotiation). That is the *only* reason to pass `ops` (see `conformance.md`).
 - An `index.ts` barrel feeds the `actions` plugin facet.
diff --git a/packages/data-ai/.claude/rules/features/services/main-service/computed.md b/packages/data-ai/.claude/rules/features/services/main-service/computed.md
index 8d6e8133..92534aa2 100644
--- a/packages/data-ai/.claude/rules/features/services/main-service/computed.md
+++ b/packages/data-ai/.claude/rules/features/services/main-service/computed.md
@@ -10,6 +10,27 @@ returns an `Observe` of state projected through pure `data/` helpers.
 Derivation logic itself lives in `data/`; a computed only wires a service
 observable to it.
 
+**Reuse tested pure logic; let performance pick the wiring.** Prefer wiring the
+pure **`data/<type>` helper** (or composing indexes) directly — the tictactoe
+computeds delegate their observable straight to
+`BoardState.deriveStatus`/`getWinner`/`currentPlayer` — because a helper reads
+exactly the resource/entities it needs, and both the computed and the matching
+`state/` derivation call it, so they agree by construction.
+
+You **may** also import a pure `state/` derivation `(state) => value` into a
+computed where performance is adequate: a small-N or resource/scalar composition,
+not a hot per-entity or large-N path. Reusing a tested derivation is good — the
+only cost is that it takes the **whole `State`**, so the computed must observe the
+full-state projection and re-runs on *any* field change (fine for a small feature,
+wasteful on a large or hot one, where you hand-wire the minimal resource/index
+reads instead). A derivation takes **no services**, so its co-located `cases` are
+inert `{ input, value }` data (no test-doubles) that tree-shake out of the app
+build (they reference the `@adobe/data/testing` matchers only, and that module is
+`sideEffects: false`) — the one hazard is a `cases` literal touching the
+`public.js` barrel at load, which `state.md` already forbids. **Performance is the
+first-class constraint**: reuse freely where it doesn't matter, hand-wire minimal
+reads where it does.
+
 ```ts
 import { cached } from "@adobe/data/cache";
 import { Observe } from "@adobe/data/observe";
@@ -24,3 +45,33 @@ export const status = cached((service: IndexDatabase) =>
 Type the parameter on the lowest database layer that exposes what it
 reads. An `index.ts` barrel re-exports every computed; `computed-database.ts`
 registers it under the `computed` facet.
+
+**Conform a computed to its `data/state` derivation** whenever one exists. The
+derivation co-locates `{ input, value }` cases (`Derivation<typeof fn>`), and the
+feature's single `conformance/conformance.test.ts` `Conformance.runFeature({...})`
+call conforms computeds: it pulls them off **`computedPlugin.computed`**, pairs each
+to its **same-named** derivation, seeds the store from `input`, reads the computed's
+synchronous emission, and `Match.assert`s it against `value` (see `conformance.md`).
+There is no `define`/`conforms` wiring. **`computedPlugin` is the `ComputedDatabase`
+layer** — the runner builds computed conformance from that layer, not the assembled
+`MainService`, so a `withCache` above can't hand back a stale pre-seed value (a
+direct `fromState` seed emits no transaction to invalidate it). Comparison is
+identity by default; a computed that emits an **entity-id list** names itself in
+`hydrate: [...]` (todo's `visibleTodos`) so the runner projects each id through
+`toData`. A computed with **no `state/` derivation is skipped** —
+single-`data/<type>` math is covered by that helper's own test. A feature with no
+`state/` derivation omits `computedPlugin` entirely.
+
+**What needs conformance is proportional to wiring logic.** A computed that
+composes/branches over the aggregate *is* a `state/` derivation (composes ≥2
+fields) and is conformed here. A computed that **trivially applies one
+`data/<type>` helper to one field** (`winner` ← `BoardState.getWinner(board)`) is
+already covered by its parts — the field by `toState` conformance, the math by
+that helper's unit test — so an added conformance would just re-invoke the same
+helper on both sides (tautological); the helper's unit test is sufficient. Two
+exceptions: (1) to pin a particular non-obvious wiring, promote it to a thin
+`state/` derivation `(state) => Type.helper(state.field)` and the runner conforms
+it — no new mechanism; (2) if a computed folds **entities into a value with no
+intermediate `State` field**, that projection *is* unconformed — promote the
+intermediate to a `State` field so `toState` covers it, making it a normal
+`state/` derivation.
diff --git a/packages/data-ai/.claude/rules/features/services/main-service/conformance.md b/packages/data-ai/.claude/rules/features/services/main-service/conformance.md
index 52e74a33..2a22b975 100644
--- a/packages/data-ai/.claude/rules/features/services/main-service/conformance.md
+++ b/packages/data-ai/.claude/rules/features/services/main-service/conformance.md
@@ -3,70 +3,216 @@ paths:
   - '**/features/*/services/main-service/**/conformance/**/*.ts'
 ---
 
-# services/main-service/conformance/ — spec↔implementation projection (test-only)
-
-The bridge that keeps the ecs implementation honest against the `data/` spec.
-**Test-only**: imported solely by `*.test.ts` and in no facet barrel, so it never
-enters the runtime bundle (test-support may import the test framework — it is not
-a runtime declaration). **Never call `fromState` / `toState` (or a shared
-clear-all + reinsert helper used only for that projection) from systems,
-transactions, or UI** — that is a full-store rewrite, not an O(1) ECS update.
-**Feature-level**: one projection per feature, reused by every transaction test
-and the system tick-loop test — don't nest it under `transaction-database/`.
-
-The property, per `{ before, args, after }` case:
-`toState(apply(fromState(before), args)) ≡ spec(before, args)`.
-
-Conformance test-support splits by concern along the layer boundary:
-
-- **Store-side, here in `services/main-service/conformance/`:**
-  - `from-state.ts` → `fromState(store: CoreDatabase.Store, state: State): void`
-    seeds the store (clear tail→head → insert entities → set resources) to a `State`.
-  - `to-state.ts` → `toState(store): State` reads the store back — each kind via
-    its full named-archetype component set, so the shapes never alias.
-  - `expect-conforms.ts` → **one export, `expectConforms({ cases, spec, apply })`**.
-    Per case it asserts `spec(before, args) ≡ after` (keeps the case honest), then
-    `fromState(before)` → `apply(store, args)` → `toState ≡ after`.
-- **Spec-side, in `data/state/`** (State values, no store — so both the `data/`
-  transform tests and this runner import them without a layer violation):
-  `conformance-case.ts` (`ConformanceCase<Args>`), the cases **exported from each
-  `<transform>.test.ts`** (`import { cases } from "…/<transform>.test.js"` — no
-  separate `.cases.ts` file), and `expect-state-matches.ts` (State equality).
-
-## No cast — build on `Store.create`, not a `Database`
-
-A **transaction is `(store, args) => void`**, so transaction conformance needs no
-`Database`: `Store.create(<schema-layer>.plugin)` returns a cast-free writable
-`CoreDatabase.Store` — pass the plugin directly, `Store.create` reads its schema
-facets. Source it from the **lowest layer that declares all the schema** —
-`IndexDatabase`, or `CoreDatabase` if the feature has no indexes — **not**
-`MainService`: the store needs only schema, and the behaviour layers
-(transactions / computed / systems) add none.
-`fromState`/`toState`/`apply` all operate on it, and `apply` calls the **raw
-transaction function** directly:
+# services/main-service/conformance/ — keeping the ECS honest against the spec
+
+Test-only (imported only by `*.test.ts`, in no facet barrel). The `data/state`
+cases are the shared truth; the shared **`@adobe/data/testing`** runner replays
+them against the ECS. This folder holds only the *feature-specific projection*
+(`projection.ts`) plus one `conformance.test.ts` that makes a **single**
+`Conformance.runFeature({...})` call. Reference: `data-lit-tictactoe`'s
+`conformance/` (the zero-config example) and `data-lit-todo` (entity markers +
+`hydrate`); `data-lit-space-rock-game` for the entity-bag / real-time variant.
+
+**The projection helpers — `fromState`, `toState`, and the
+`toData(store, entity)` reader — are strictly for conformance tests and MUST
+NEVER run in production code, ever.** `fromState`/`toState` rewrite the whole
+store out-of-band; runtime code reads through observables/indexes and writes
+through transactions. (This conformance `toData(store, entity)` reader is
+unrelated to the library's `db.toData()` store-serialization method, which *is*
+a normal runtime API — the collision is only in the name.) Likewise
+`Match.matches` / `Match.assert` are comparison helpers for `*.test.ts` only —
+never a runtime branch.
+
+## What `@adobe/data/testing` gives you
+
+Two namespaces, imported only from `*.test.ts` (the module is
+`sideEffects: false`, and `vitest` is an optional peer dependency, satisfied
+here):
+
+- **`Match`** — the tolerant, matcher-aware value comparison: `matches(actual,
+  expected, options?)` and its throwing wrapper `assert(...)`, plus the matchers
+  `Match.anyNumber` / `Match.anyString` / `Match.ref(label)`. Options are
+  `{ unordered?: ReadonlySet<string>; tolerance?: number }` — arrays compare **in
+  order** (default) unless a key is named in `unordered`, and numbers snap to
+  `tolerance` (default `0.01`) to absorb F32↔f64 / trig noise. Framework-agnostic:
+  it honors any asymmetric matcher, so vitest's `expect.any(...)` interops.
+- **`Conformance`** — the case types (`Case`, `Cases`, `DerivationCase`,
+  `DerivationCases`, `Effects`, `ServiceCall`), the `entity(specId)` identity
+  marker, the id `resolver(map)`, the whole-feature driver **`runFeature`**, the
+  pure-spec driver **`runSpec`**, and the lower-level per-surface drivers
+  `runTransactions` / `runActions` / `runComputeds` (internals of `runFeature`,
+  exported for the escape hatch below). Auto-pairing (transition ⇄ op by name),
+  effect recording, and id resolution are built **into** the drivers — no
+  per-feature helper writes them. The `Effects` type-test also lives here (once),
+  so there is no per-feature `conformance-case.type-test.ts` to author.
+
+## Projection (store ⇄ State) — the one per-feature piece
+
+`projection.ts` is the only feature-specific file, and it is a **single
+aggregated export** — the three test-only helpers in one file, one `export`:
+
+```ts
+// conformance/projection.ts
+export const projection = { fromState, toState, toData };
+```
+
+- `fromState(store, state)` seeds a store to a `State` (clear tail→head, insert
+  entities, set resources). It **returns the `id → entity` map**
+  (`ReadonlyMap<Id, Entity>`) it built while seeding — the ECS assigns ids from
+  its own id-space, so the runner turns this map into a `resolve` via
+  `Conformance.resolver`; **no feature writes id resolution by hand**. A feature
+  whose transactions are index-addressed or singleton returns `void`, and any id
+  then resolves to `Entity.none`.
+- `toState(store)` reads the whole store back, built on `toData`.
+- `toData(store, entity)` reads one entity as its `data/` value — the single
+  place the ECS↔data mapping lives; the runner reuses it to hydrate id-list
+  computed outputs. **Present only when the feature has entities** (omit for a
+  scalar / resource-only feature).
+
+This replaces the old separate `create-store.ts` / `from-state.ts` /
+`to-state.ts` / `to-data.ts`. **`create-store` is gone** — `runFeature` builds
+every store/db itself with `Store.create(plugin)` / `Database.create(plugin)`.
+
+## ECS conformance is ONE call — `Conformance.runFeature`
+
+`conformance/conformance.test.ts` is a single call that conforms the whole
+feature — transaction + action + computed conformance **plus** the projection
+round-trip. No per-surface test file, no `define` callback, no `conforms(...)`
+adapters, no coverage guard.
+
+```ts
+import { State } from "../../../data/state/state.js";
+import { transitions } from "../../../data/state/transitions.js";
+
+Conformance.runFeature({
+  state: State,
+  transitions,
+  plugin: MainService.plugin,
+  computedPlugin: ComputedDatabase.plugin,   // omit if no state/ derivations
+  projection,
+  hydrate: ["visibleTodos"],                 // entity-id-list computeds; omit if none
+  match: { unordered: new Set(["bullets", "asteroids"]) }, // entity bags / tolerance; omit if none
+  ops: { actions: import.meta.glob([...]) }, // ONLY when ops aren't in the plugin facet
+});
+```
+
+- **`state`** is the `State` namespace itself — the runner calls `State.create()`
+  for the default each case's `before` deltas over, and round-trips `State.samples`
+  through the projection.
+- **`transitions`** is imported from the feature's test-only
+  `data/state/transitions.ts` (the single `import.meta.glob` of the `{ fn, cases }`
+  source, shared with `spec.test.ts` — see `data/state.md`). Never re-glob it here.
+- **Ops come off the plugin facets.** The runner reads
+  `plugin.transactions` / `plugin.actions` / `computedPlugin.computed` and builds
+  the stores/dbs itself (`Store.create(plugin)` for transactions,
+  `Database.create(plugin)` for actions, `Database.create(computedPlugin)` for
+  computeds). Each op pairs to its **same-named** transition/derivation; auto-pairing
+  can't forget an item, so there is **no coverage guard** — an op with **no
+  same-named transition** is infrastructure or system-dispatched and is simply
+  **skipped** (a streaming action with no transition is skipped too).
+- **`ops`** overrides the facet-discovered ops per surface — use it **only** when
+  an op isn't registered in the plugin facet: a per-transition action kept out of
+  the facet (to bound the plugin's type) is discovered via an
+  `ops.actions: import.meta.glob([".../actions/*.ts", "!.../actions/index.ts"], { eager: true })`
+  glob (p2p negotiation). Ordinary features omit `ops` entirely.
+- **`computedPlugin`** is the `ComputedDatabase` **layer** plugin — build computed
+  conformance from this layer, **not** the assembled `MainService`: a behaviour
+  layer above may `withCache` a pre-seed value that a direct `fromState` seed emits
+  no transaction to invalidate; the computed layer keeps the seed authoritative.
+  Omit it when the feature has no `state/` derivations (a computed with no
+  derivation is skipped anyway, and single-`data/<type>` math is covered by that
+  helper's own test).
+- **`hydrate`** names the computeds that emit an **entity-id list** (todo's
+  `visibleTodos`) so the runner maps each id through `toData` into the value shape
+  the derivation yields. Comparison is identity otherwise. Omit if none.
+- **`match`** threads `MatchOptions` through every comparison (see below). Omit if
+  none.
+- **Projection round-trip.** When `State.samples` is non-empty, the runner adds a
+  `toState ∘ fromState ≡ identity` test per sample — proving the pair round-trips
+  faithfully so a symmetric bug in `fromState`/`toState` can't cancel out and mask
+  a real ECS defect. No separate `projection.test.ts`.
+
+`data-lit-tictactoe` is the zero-config call (no `computedPlugin`, no `hydrate`,
+no `match`, no `ops` — moves are board-index addressed, so no `entity()`
+markers). `data-lit-todo` adds `hydrate: ["visibleTodos"]` and `entity()` markers.
+`data-lit-space-rock-game` adds `match: { unordered: … }` for its entity bags
+(its per-frame transitions are conformed by the systems tick loop, not here — see
+`systems.md`).
+
+## The pure spec — `data/state/spec.test.ts`
+
+Lives in `data/state/`, not here. One call, importing the same `transitions`:
 
 ```ts
-expectConforms({ cases, spec: State.hitTarget, apply: (store, args) => hitTarget(store, args) });
+import { State } from "./state.js";
+import { transitions } from "./transitions.js";
+
+Conformance.runSpec({ state: State, transitions });
 ```
 
-A mutation addressed by **entity id** resolves its entities from the seeded store
-inside `apply` (the shared cases stay spec-shaped). Reads never need a cast —
-`Database extends ReadonlyStore`.
-
-**Systems** are the one exception: they run via `db.system.functions` and reach
-the store through the db. Get that writable view with the library lens —
-`Database.toSystemDatabase(Database.create(plugin))` (the widening twin of
-`UIService.restrict`, cast-free) — then `fromState(db.store, before)` → drive one
-frame → `toState(db.store)`. Test **selection/detection** logic (which entities
-interact) separately, with seeded edge-case geometries.
-
-## State equality — ordering vs precision, kept separate
-
-`expect-state-matches.ts` compares with **`equalsUnordered`** from `@adobe/data`
-(arrays as multisets — archetype hole-fill reorders rows — objects key-order
-independent). Absorb float noise — F32↔f64 storage rounding **and** trig epsilon
-(a quadrant `cos`/`sin` yields ~3e-15 where a case authors `0`) — by quantizing
-every number on both sides onto a small grid (`Math.round(Math.fround(n)*k)/k`)
-before comparing. Ordering and precision stay separate concerns. **Guard the
-projection itself** with one `fromState → toState` identity test on
-representative states.
+It discovers every file exporting `cases`, enforces the two-exports rule, and
+dispatches on case shape (transition → state + effects, derivation →
+`fn(input) ≡ value`), seeding each case's `before`/`input` as a delta over
+`State.create()`. Unwraps any `entity(specId)` arg marker to its plain data-id for
+the pure side.
+
+## The exception — a per-surface `userId`, via the lower-level runners
+
+A feature that needs **ambient per-case context differing per surface** — a
+user-scoped `userId` that must be seeded before the raw transaction *and*
+independently before the action dispatch (**p2p presence**) — does **not** use
+`runFeature`. It calls `Conformance.runTransactions` / `runActions` (still
+exported) directly, each with its own `seedContext` (and any per-surface
+concurrency), because the seam differs between the transaction store and the
+action db. `runFeature` has no place to thread two different `seedContext`s, so
+this feature drops to the lower level. This is the escape hatch — ordinary
+features never touch these drivers directly.
+
+## Identity — the `entity(specId)` marker
+
+An entity-addressed transition writes its addressed id as `args: { id: entity(2) }`
+— import `entity`, re-exported from the feature's `data/state/conformance-case.ts`.
+`runSpec` unwraps it to the plain data-id; the ECS runner resolves it to the
+**seeded entity** via the id→entity map `fromState` returns (turned into a `resolve`
+by `Conformance.resolver` — no feature writes `resolve` by hand). Two conventions
+make the wiring vanish: the ECS op takes the entity **under the transition's own arg
+key** (`{ id }`, same-shape args, no reshape), and `fromState` returns the
+`ReadonlyMap<Id, Entity>` id→entity map (or `void` for an index-addressed / singleton
+feature, whose ids then resolve to `Entity.none`). `data-lit-todo` is the reference.
+
+## Name-parity — add a same-named op, never a per-item adapter
+
+Every app transition is realized by a **same-named** transaction and/or action. When
+the real UI op is richer or renamed — todo's `dragTodo`, space-rock's `newGame` — that
+op is infra, and a thin **same-named** op (todo's `reorderTodo` action, space-rock's
+`createInitial` transaction) gives the transition something to pair with. Do **not**
+reintroduce a per-item adapter to bridge a name mismatch — add the same-named op.
+
+## Ordering, tolerance, `ref` — all via `match`
+
+`runFeature` threads `match?: MatchOptions` through to every comparison, so
+per-feature tuning is data, not code:
+
+- **Ordered by default.** `toState` reads a display-ordered collection in order —
+  that is what verifies a reorder — and positional tuples (a `Vec2`) must stay in
+  order.
+- **Entity bags compare as multisets.** A collection the ECS materialises with no
+  display order (bullets, asteroids) is named in
+  `match: { unordered: new Set(["bullets", "asteroids"]) }` so just those fields
+  compare order-independently — never blanket-unordered (it would conflate
+  `[100,180]` with `[180,100]`).
+- **Float noise** is absorbed by the default `tolerance` (`0.01`); raise it only
+  when a case genuinely needs a looser grid.
+- **`Match.ref(label)`** on the expected side asserts id correspondence for a
+  referential feature (an id that must line up in two places); `Match.anyNumber` /
+  `anyString` leave an id a case doesn't pin fully open.
+
+## Recording side effects — built in, no Proxy
+
+Effect recording lives in the drivers: they enumerate a plain-object service's own
+methods and closure-wrap each to record `[method, ...args]` calls, then delegate
+(no `Proxy`, per the repo rule). `runSpec` records the case's injected service
+`args`; the action surface records the `db.services` overrides. A case's `effects`
+asserts each **declared** service's calls exactly (`Array` = ordered, `Set` = any
+order); undeclared services (value-returning reads like `generateName`) are
+ignored.
diff --git a/packages/data-ai/.claude/rules/features/services/main-service/transactions.md b/packages/data-ai/.claude/rules/features/services/main-service/transactions.md
index 98a957e7..9a8de75e 100644
--- a/packages/data-ai/.claude/rules/features/services/main-service/transactions.md
+++ b/packages/data-ai/.claude/rules/features/services/main-service/transactions.md
@@ -30,12 +30,21 @@ export const playMove = (t: CoreDatabase.Store, { index }: PlayMoveArgs) => {
   than throwing.
 - Decisions come from pure `data/` helpers; the transaction only applies the
   result — read the touched slice, call the `data/` transform, write the diff.
-- **Conform every transaction to its `data/` transform** in its sibling
-  `*.test.ts`, via `expectConforms` over the spec's shared cases (see
-  `services/main-service/conformance.md`): seed `fromState(before)`, dispatch, assert `toState ≡
-  after`, covering every branch and edge case. A transaction taking **entity
-  ids** resolves them from the seeded store in the `apply` closure; one with no
-  `data/` analogue (`setBounds`, `setInput`) gets a direct resource assertion.
+- Keep transaction files **single-export** (the `transactions/` barrel is
+  `export *`-ed into the plugin facet, so a second export would pollute it).
+- **Conformance is wired once, centrally, and auto-paired** — not per-file. The
+  feature's single `conformance/conformance.test.ts` `Conformance.runFeature({...})`
+  call conforms transactions: it pulls them off **`plugin.transactions`** (the
+  registered facet), pairs each to the **same-named** `data/state` transition, and
+  conforms it — seed `fromState(before)`, apply, `Match.assert` `toState ≡ after`
+  (state only; service effects are asserted through the action). There is **no**
+  `define`/`conforms` adapter and **no** `covers` guard. A transaction taking
+  **entity ids** takes them under the transition's own arg key (`{ id }`); the runner
+  resolves each `entity(specId)` marker via the id→entity map `fromState` returns. A
+  transaction with **no same-named transition** is infrastructure (`setInput`,
+  `setBounds`) or the drag UI op (`dragTodo`) or system-dispatched — it is simply
+  **skipped**, no guard needed. Don't add a per-item adapter for a renamed op; add a
+  thin same-named transaction instead (see `conformance.md`).
 - An `index.ts` barrel feeds the `transactions` plugin facet — so it must
   re-export **only** the mutations. A read/query helper shared by several
   transactions (`readShip`, `readBoard` — a `(t) => value` function) may live
diff --git a/packages/data-ai/README.md b/packages/data-ai/README.md
index a7a66128..d2ed97f4 100644
--- a/packages/data-ai/README.md
+++ b/packages/data-ai/README.md
@@ -11,46 +11,95 @@ It installs two things:
 - **skills** — `build-*` commands that scaffold features and applications.
 - **rules** — the path-scoped conventions those skills follow while building.
 
-> **For the installing agent:** find the block below that matches your host
-> (Claude Code or Cursor/other), run its commands, and stop. Each install owns a
-> namespaced folder and is a clean wipe-and-recopy, so re-running is also how you
-> **update** — it never touches files you authored.
+The **rules** are the part that evolves often, so `install` pins the package and
+re-copies them automatically on every install: bump the version and they refresh —
+no manual step, no committed diff, no hand-editing.
 
-## Install — Claude Code
+## Quick start
 
-Skills load as a marketplace plugin; rules install into the project. Run these
-three from a shell (agent-runnable):
+From your project folder root:
+
+**1. Install** — one command:
 
 ```
-claude plugin marketplace add adobe/data --scope project
-claude plugin install adobe-data-ai@adobe-data-skills --scope project
 npx @adobe/data-ai@latest install
 ```
 
-In an interactive Claude session you can instead use the slash-command form of
-the first two — `/plugin marketplace add adobe/data` then
-`/plugin install adobe-data-ai@adobe-data-skills` — but an agent driving a shell
-should use the `claude plugin …` commands above (slash commands aren't
-shell-runnable).
+*(Claude Code only:* also add the skills plugin once — see
+[Claude Code](#claude-code--add-the-skills-plugin-one-time). Cursor/Codex need
+nothing extra; `install` copies their skills.*)*
+
+**2. Restart your AI agent** so it loads the newly installed skills and rules.
+
+**3. Create an application** — ask your agent:
+
+```
+/build-application <a description of the app you want>
+```
+
+That's the whole flow. Everything below explains what `install` does and the
+other build skills available.
+
+## What `install` does
+
+`install` does two things: it **copies the bundle now** (rules →
+`.claude/rules/adobe-data-ai/`, and for Cursor/Codex skills →
+`.agents/skills/adobe-data-ai/`), and it **wires the repo so future installs
+self-update**, editing your `package.json` and `.gitignore` to:
 
-- Skills → the `adobe-data-ai` plugin. **Update:** `claude plugin update adobe-data-ai`.
-- Rules → `.claude/rules/adobe-data-ai/`. **Update:** re-run `npx @adobe/data-ai@latest install`.
+1. pin `@adobe/data-ai` in `devDependencies` at the **exact version it just
+   resolved** (never a range, so a later install can't silently pull an
+   unreviewed release);
+2. add `data-ai install` to **your own** `postinstall` script (chaining if one
+   exists) — it must be *your* script: pnpm does not run a dependency's lifecycle
+   scripts, so a `postinstall` shipped inside the package would silently not fire;
+3. gitignore the managed bundle folders.
 
-## Install — Cursor (and Codex / other `.agents` agents)
+The copied files are regenerated artifacts — never committed, never edited in
+place. The wiring is idempotent, so re-running is harmless; with `--global` or in a
+directory with no `package.json`, `install` just copies (no wiring).
 
-One command installs both:
+After that first run, sync your lockfile with a normal install (`pnpm install`) so
+the pinned dev-dependency is recorded; from then on every install refreshes the
+bundle via the postinstall.
+
+**Why `@latest` for the first command but a pinned version afterward?** The one
+command you type is a one-time, human-initiated bootstrap, so `@latest` is fine
+(the same posture as `npm create …@latest`). The part that *repeats* — every
+teammate's and CI's install — runs from the **exact version `install` pinned into
+your `devDependencies`**, never a moving tag, so no unreviewed release ever
+auto-executes. Pinning happens where it matters, automatically.
+
+**Update:** bump the `@adobe/data-ai` version in `package.json` and install again.
+That's it.
+
+### Claude Code — add the skills plugin (one time)
+
+Claude Code loads skills from a marketplace plugin, not from `.claude/skills/`, so
+its skills are a separate one-time install (the `install` step above already
+handles the rules for Claude Code):
 
 ```
-npx @adobe/data-ai@latest install
+claude plugin marketplace add adobe/data --scope project
+claude plugin install adobe-data-ai@adobe-data-skills --scope project
 ```
 
-- Skills → `.agents/skills/adobe-data-ai/`.
-- Rules → `.claude/rules/adobe-data-ai/`.
-- **Update:** re-run the same command.
+(Interactive sessions can use `/plugin marketplace add adobe/data` then
+`/plugin install adobe-data-ai@adobe-data-skills`.) **Update the skills:**
+`claude plugin update adobe-data-ai`. Cursor/Codex need no plugin — `install`
+copies their skills too.
+
+### Just the files, no managed dependency
 
-## Use
+If you don't want the auto-update wiring — a throwaway scaffold, a non-Node repo,
+or you'd rather commit the bundle and update it on your own schedule — run
+`install` where it can't wire (no `package.json`, or pass `--global`), or simply
+delete the `postinstall`/dev-dependency lines it added. Re-running `install` is
+always a clean wipe-and-recopy; you then update by re-running it yourself.
 
-Ask your agent to run a build command — skills are available by name:
+## Build skills
+
+Step 3 above uses `build-application`; the skills are available by name:
 
 - **`build-application`** — build a whole app: a base feature that hosts
   lazily-loaded peer features.
@@ -66,15 +115,16 @@ by name when you want a single phase or a specialized flow: `build-data`,
 in subagents), `review` (audit output against the rules), and `structure`
 (reason about layout).
 
-## One-liner: install + build an app
-
-Paste one of these into a shell, replacing the quoted text with your own app
-description. It installs the bundle, then runs `build-application` headlessly on
-your prompt.
+## One-liner: install + build an app (headless)
 
-This presumes you are already running the agent within the directory you want to use as your project root.
+Paste this into an agent already running in your project root, replacing the
+quoted text with your own app description. It installs the bundle, then runs
+`build-application` on your prompt:
 
 ```
-Find the @adobe/data-ai package on npmjs and then install it in the current directory.
-Next use it's /build-application skill to build <prompt here>
+Set up @adobe/data-ai in the current directory: run
+`npx @adobe/data-ai@latest install` (this copies the bundle and pins the exact
+version so rules auto-update on every install). On Claude Code also add the
+skills plugin per the package README. Then use its /build-application skill to
+build <prompt here>
 ```
diff --git a/packages/data-ai/bin/cli.mjs b/packages/data-ai/bin/cli.mjs
index c6dce388..96640618 100755
--- a/packages/data-ai/bin/cli.mjs
+++ b/packages/data-ai/bin/cli.mjs
@@ -157,6 +157,78 @@ version on every install. Package: <https://www.npmjs.com/package/${PKG_NAME}>
     return file;
 }
 
+// Wire the consumer repo for auto-updating installs (part of `install`, not a
+// separate step). Idempotently:
+//   1. pins `@adobe/data-ai` in devDependencies (exact version — never a range,
+//      so an install can't silently pull an unreviewed release),
+//   2. adds `data-ai install` to the consumer's OWN `postinstall` (a dependency's
+//      lifecycle script does NOT run under pnpm, so it must live here), and
+//   3. gitignores the managed, regenerated bundle folders.
+// After this, bumping the pinned version and re-installing recopies the bundle —
+// no manual step, no committed diff. Skips gracefully with a note when there is
+// no package.json (the bundle is still copied; the repo just isn't auto-wired).
+const MANAGED_GITIGNORE = [
+    `# ${PKG_NAME} — managed, regenerated on install; do not edit or commit`,
+    ".claude/rules/adobe-data-ai/",
+    ".claude/rules/adobe-data-ai-bootstrap.md",
+    ".agents/skills/adobe-data-ai/",
+];
+
+function wireManagedUpdates(base) {
+    const pkgPath = join(base, "package.json");
+    if (!existsSync(pkgPath)) {
+        process.stdout.write(
+            `  (no package.json in ${base} — auto-update not wired; the bundle was still copied.\n` +
+                `   Add one, re-run install to wire it, or re-run manually to update.)\n`,
+        );
+        return;
+    }
+    const consumer = JSON.parse(readFileSync(pkgPath, "utf8"));
+    const changes = [];
+
+    // 1. pinned devDependency
+    consumer.devDependencies ??= {};
+    let pinnedDep = false;
+    if (consumer.devDependencies[PKG_NAME] !== VERSION) {
+        consumer.devDependencies[PKG_NAME] = VERSION;
+        changes.push(`devDependencies["${PKG_NAME}"] = "${VERSION}" (exact)`);
+        pinnedDep = true;
+    }
+
+    // 2. own postinstall runs the installer (chain if one already exists)
+    consumer.scripts ??= {};
+    const INSTALL = "data-ai install";
+    const post = consumer.scripts.postinstall;
+    if (!post) {
+        consumer.scripts.postinstall = INSTALL;
+        changes.push(`scripts.postinstall = "${INSTALL}"`);
+    } else if (!post.includes(INSTALL)) {
+        consumer.scripts.postinstall = `${post} && ${INSTALL}`;
+        changes.push(`scripts.postinstall += " && ${INSTALL}"`);
+    }
+    if (changes.length) writeFileSync(pkgPath, JSON.stringify(consumer, null, 2) + "\n");
+
+    // 3. gitignore the managed bundle folders
+    const giPath = join(base, ".gitignore");
+    const gi = existsSync(giPath) ? readFileSync(giPath, "utf8") : "";
+    if (!gi.includes(MANAGED_GITIGNORE[0])) {
+        const sep = gi === "" ? "" : gi.endsWith("\n") ? "\n" : "\n\n";
+        writeFileSync(giPath, gi + sep + MANAGED_GITIGNORE.join("\n") + "\n");
+        changes.push(".gitignore += managed bundle paths");
+    }
+
+    for (const c of changes) process.stdout.write(`  wired: ${c}\n`);
+    if (!changes.length) process.stdout.write("  auto-update already wired\n");
+    // Adding/repinning the dev-dependency leaves the lockfile out of sync until a
+    // normal install records it (and CI with a frozen lockfile would fail until then).
+    if (pinnedDep) {
+        process.stdout.write(
+            "\nNext: run your package manager's install to sync the lockfile\n" +
+                "  pnpm install    # or npm install / yarn\n",
+        );
+    }
+}
+
 function parseArgs(argv) {
     const positional = [];
     const flags = new Set();
@@ -177,11 +249,17 @@ Install the architecture skills + rules for Cursor, Codex, and other agents.
 same way for every agent — see README.)
 
 Usage:
-  npx ${PKG_NAME}@latest install [options]
+  npx ${PKG_NAME}@latest install   # copy the bundle AND wire auto-updates (default)
   npx ${PKG_NAME}@latest list
 
 Commands:
-  install   Skills → .agents/skills/${BUNDLE}/, rules → .claude/rules/${BUNDLE}/ (default).
+  install   Copy the bundle (skills → .agents/skills/${BUNDLE}/, rules →
+            .claude/rules/${BUNDLE}/) AND wire this repo for auto-updating installs:
+            pin ${PKG_NAME} in devDependencies (exact), add \`data-ai install\` to the
+            repo's own postinstall, and gitignore the managed bundle folders. Run once;
+            thereafter a plain install refreshes the bundle and bumping the pinned
+            version updates it. Skips the wiring (copies only) with \`--global\` or when
+            there's no package.json.
   list      Print the skills bundled in this package.
 
 Options:
@@ -229,6 +307,10 @@ function main() {
     process.stdout.write(`  ${skills.length} skills → ${skillsDir}\n`);
     process.stdout.write(`  ${ruleCount} rules  → ${rulesDir}\n`);
     process.stdout.write(`  bootstrap → ${bootstrapFile}\n`);
+
+    // A project install also wires the repo for auto-updating installs (idempotent).
+    // A global install has no consumer package.json to wire, so it only copies.
+    if (!flags.has("global")) wireManagedUpdates(base);
 }
 
 main();
diff --git a/packages/data-ai/package.json b/packages/data-ai/package.json
index 5a90d235..0e3074e4 100644
--- a/packages/data-ai/package.json
+++ b/packages/data-ai/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@adobe/data-ai",
-  "version": "0.9.92",
+  "version": "0.9.93",
   "description": "Cross-agent architecture skills for @adobe/data — installable as a Claude Code plugin or copied into any Agent-Skills-compatible agent (Cursor, Codex).",
   "type": "module",
   "private": false,
diff --git a/packages/data-gpu-hopper/package.json b/packages/data-gpu-hopper/package.json
index 1db85b3b..9765465f 100644
--- a/packages/data-gpu-hopper/package.json
+++ b/packages/data-gpu-hopper/package.json
@@ -1,6 +1,6 @@
 {
   "name": "data-gpu-hopper",
-  "version": "0.9.92",
+  "version": "0.9.93",
   "description": "Hopper sample - real-time ECS game rendered as colored cubes via @adobe/data-gpu",
   "type": "module",
   "private": true,
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/conformance-case.ts b/packages/data-gpu-hopper/src/features/main/data/state/conformance-case.ts
index 44e5a8a5..4426eca4 100644
--- a/packages/data-gpu-hopper/src/features/main/data/state/conformance-case.ts
+++ b/packages/data-gpu-hopper/src/features/main/data/state/conformance-case.ts
@@ -1,13 +1,13 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Conformance as ConformanceApi } from "@adobe/data/testing";
 import type { State } from "./state.js";
 
-// One spec-owned conformance case: a `data/` transform's `{ before, args, after }`
-// authored as full `State`. Lives in `<transform>.cases.ts` and is shared,
-// unchanged, by the data transform test and the ecs conformance runner
-// (see `ecs/conformance/`).
-export type ConformanceCase<Args> = {
-  readonly name: string;
-  readonly before: State;
-  readonly args: Args;
-  readonly after: State;
-};
+// The conformance case types for this feature — the shared `@adobe/data/testing`
+// machinery with `State` bound once, so a transform authors `Conformance<typeof fn>`
+// and a derivation `Derivation<typeof fn>` (args/input/value read from the
+// function's own signature). This tiny file is the only per-feature conformance
+// type declaration; everything else lives in `@adobe/data/testing`.
+export type Conformance<F extends (...args: never[]) => unknown> =
+  ConformanceApi.Cases<State, F>;
+export type Derivation<F extends (...args: never[]) => unknown> =
+  ConformanceApi.DerivationCases<F>;
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/expect-state-matches.ts b/packages/data-gpu-hopper/src/features/main/data/state/expect-state-matches.ts
deleted file mode 100644
index 2575a2dd..00000000
--- a/packages/data-gpu-hopper/src/features/main/data/state/expect-state-matches.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { expect } from "vitest";
-import { equalsUnordered } from "@adobe/data";
-import type { State } from "./state.js";
-
-// Spec-owned tolerant `State` equality, shared by the data/ transform tests and
-// the ecs conformance runner. Two orthogonal concerns, kept separate:
-//
-//   precision — normalise every number on both sides onto a shared grid, so a
-//     value that differs only by F32↔f64 storage rounding compares equal.
-//     `Math.fround` collapses the F32 rounding; rounding to 1e-2 collapses any
-//     residual epsilon. `+ 0` normalises `-0` to `0`. (The frog's continuous
-//     position is a float, so this matters once the ecs stores it as F32.)
-//   ordering — `equalsUnordered` compares arrays as MULTISETS (archetype
-//     hole-fills make row order nondeterministic) and is object key-order
-//     independent.
-const quantize = (n: number): number => Math.round(Math.fround(n) * 100) / 100 + 0;
-
-const normalize = (value: unknown): unknown => {
-  if (typeof value === "number") return quantize(value);
-  if (Array.isArray(value)) return value.map(normalize);
-  if (value !== null && typeof value === "object") {
-    return Object.fromEntries(Object.entries(value).map(([key, v]) => [key, normalize(v)]));
-  }
-  return value;
-};
-
-export const expectStateMatches = (actual: State, expected: State): void => {
-  const a = normalize(actual);
-  const b = normalize(expected);
-  expect(
-    equalsUnordered(a, b),
-    `State mismatch:\n  actual   ${JSON.stringify(a)}\n  expected ${JSON.stringify(b)}`,
-  ).toBe(true);
-};
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/hop.cases.ts b/packages/data-gpu-hopper/src/features/main/data/state/hop.cases.ts
deleted file mode 100644
index b07b6d7c..00000000
--- a/packages/data-gpu-hopper/src/features/main/data/state/hop.cases.ts
+++ /dev/null
@@ -1,88 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { Direction } from "../direction/direction.js";
-import type { State } from "./state.js";
-import type { ConformanceCase } from "./conformance-case.js";
-
-// A bare 5-wide, 3-tall board. `hop` reads only frog / width / height / status,
-// so the lanes and hazards are irrelevant and left empty here.
-const base: Omit<State, "frog"> = {
-  width: 5,
-  height: 3,
-  lanes: [],
-  hazards: [],
-  lives: 3,
-  score: 0,
-  status: "playing",
-};
-
-// Spec-owned `{ before, args, after }` cases for `State.hop`, shared with the ecs
-// hop transaction. Covers each direction, clamping at all four board edges, the
-// grid-snap of a log-ridden fractional x, and the game-over no-op.
-export const cases: readonly ConformanceCase<Direction>[] = [
-  {
-    name: "hops up toward the goal",
-    before: { ...base, frog: { x: 2, y: 0 } },
-    args: "up",
-    after: { ...base, frog: { x: 2, y: 1 } },
-  },
-  {
-    name: "hops down toward the start",
-    before: { ...base, frog: { x: 2, y: 1 } },
-    args: "down",
-    after: { ...base, frog: { x: 2, y: 0 } },
-  },
-  {
-    name: "hops left",
-    before: { ...base, frog: { x: 2, y: 1 } },
-    args: "left",
-    after: { ...base, frog: { x: 1, y: 1 } },
-  },
-  {
-    name: "hops right",
-    before: { ...base, frog: { x: 2, y: 1 } },
-    args: "right",
-    after: { ...base, frog: { x: 3, y: 1 } },
-  },
-  {
-    name: "clamps at the bottom row",
-    before: { ...base, frog: { x: 2, y: 0 } },
-    args: "down",
-    after: { ...base, frog: { x: 2, y: 0 } },
-  },
-  {
-    name: "clamps at the top (goal) row",
-    before: { ...base, frog: { x: 2, y: 2 } },
-    args: "up",
-    after: { ...base, frog: { x: 2, y: 2 } },
-  },
-  {
-    name: "clamps at the left edge",
-    before: { ...base, frog: { x: 0, y: 1 } },
-    args: "left",
-    after: { ...base, frog: { x: 0, y: 1 } },
-  },
-  {
-    name: "clamps at the right edge",
-    before: { ...base, frog: { x: 4, y: 1 } },
-    args: "right",
-    after: { ...base, frog: { x: 4, y: 1 } },
-  },
-  {
-    name: "snaps a log-ridden fractional x while hopping sideways",
-    before: { ...base, frog: { x: 2.4, y: 1 } },
-    args: "right",
-    after: { ...base, frog: { x: 3, y: 1 } },
-  },
-  {
-    name: "snaps a log-ridden fractional x while hopping forward",
-    before: { ...base, frog: { x: 2.6, y: 1 } },
-    args: "up",
-    after: { ...base, frog: { x: 3, y: 2 } },
-  },
-  {
-    name: "ignores input once the game is over",
-    before: { ...base, status: "gameOver", frog: { x: 2, y: 1 } },
-    args: "up",
-    after: { ...base, status: "gameOver", frog: { x: 2, y: 1 } },
-  },
-];
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/hop.test.ts b/packages/data-gpu-hopper/src/features/main/data/state/hop.test.ts
deleted file mode 100644
index aae5de25..00000000
--- a/packages/data-gpu-hopper/src/features/main/data/state/hop.test.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./hop.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.hop", () => {
-  for (const { name, before, args, after } of cases) {
-    it(name, () => {
-      expectStateMatches(State.hop(before, args), after);
-    });
-  }
-});
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/hop.ts b/packages/data-gpu-hopper/src/features/main/data/state/hop.ts
index abd43962..a4f456f1 100644
--- a/packages/data-gpu-hopper/src/features/main/data/state/hop.ts
+++ b/packages/data-gpu-hopper/src/features/main/data/state/hop.ts
@@ -2,23 +2,63 @@
 import { Direction } from "../direction/direction.js";
 import { GameStatus } from "../game-status/game-status.js";
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
 
 const clamp = (value: number, max: number): number => Math.max(0, Math.min(max, value));
 
 // Snap the frog one cell in `direction`, re-aligning a log-ridden fractional `x`
 // back onto the grid and clamping to the board. A no-op unless the game is in
-// play, keeping it idempotent under repeated application.
-export const hop = <T extends Pick<State, "frog" | "width" | "height" | "status">>(
-  state: T,
+// play, keeping it idempotent. Writes only `frog`.
+export const hop = (
+  state: Pick<State, "frog" | "width" | "height" | "status">,
   direction: Direction,
-): T => {
-  if (!GameStatus.isPlaying(state.status)) return state;
+): Pick<State, "frog"> => {
+  if (!GameStatus.isPlaying(state.status)) return { frog: state.frog };
   const { dx, dy } = Direction.delta[direction];
   return {
-    ...state,
     frog: {
       x: clamp(Math.round(state.frog.x) + dx, state.width - 1),
       y: clamp(state.frog.y + dy, state.height - 1),
     },
   };
 };
+
+// A bare 5-wide, 3-tall board. `hop` reads only frog / width / height / status,
+// so the lanes and hazards are irrelevant and left empty here.
+const base: Omit<State, "frog"> = {
+  width: 5,
+  height: 3,
+  lanes: [],
+  hazards: [],
+  lives: 3,
+  score: 0,
+  status: "playing",
+};
+
+// Spec-owned cases, shared with the ecs `hop` transaction. `before` overrides the
+// default with a small test board; `after` is the writes patch (`frog` only).
+export const cases: Conformance<typeof hop> = [
+  { name: "hops up toward the goal",
+    before: { ...base, frog: { x: 2, y: 0 } }, args: "up", after: { frog: { x: 2, y: 1 } } },
+  { name: "hops down toward the start",
+    before: { ...base, frog: { x: 2, y: 1 } }, args: "down", after: { frog: { x: 2, y: 0 } } },
+  { name: "hops left",
+    before: { ...base, frog: { x: 2, y: 1 } }, args: "left", after: { frog: { x: 1, y: 1 } } },
+  { name: "hops right",
+    before: { ...base, frog: { x: 2, y: 1 } }, args: "right", after: { frog: { x: 3, y: 1 } } },
+  { name: "clamps at the bottom row",
+    before: { ...base, frog: { x: 2, y: 0 } }, args: "down", after: { frog: { x: 2, y: 0 } } },
+  { name: "clamps at the top (goal) row",
+    before: { ...base, frog: { x: 2, y: 2 } }, args: "up", after: { frog: { x: 2, y: 2 } } },
+  { name: "clamps at the left edge",
+    before: { ...base, frog: { x: 0, y: 1 } }, args: "left", after: { frog: { x: 0, y: 1 } } },
+  { name: "clamps at the right edge",
+    before: { ...base, frog: { x: 4, y: 1 } }, args: "right", after: { frog: { x: 4, y: 1 } } },
+  { name: "snaps a log-ridden fractional x while hopping sideways",
+    before: { ...base, frog: { x: 2.4, y: 1 } }, args: "right", after: { frog: { x: 3, y: 1 } } },
+  { name: "snaps a log-ridden fractional x while hopping forward",
+    before: { ...base, frog: { x: 2.6, y: 1 } }, args: "up", after: { frog: { x: 3, y: 2 } } },
+  { name: "ignores input once the game is over",
+    before: { ...base, status: "gameOver", frog: { x: 2, y: 1 } }, args: "up",
+    after: { frog: { x: 2, y: 1 } } },
+];
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/lose-life.cases.ts b/packages/data-gpu-hopper/src/features/main/data/state/lose-life.cases.ts
deleted file mode 100644
index 0b774538..00000000
--- a/packages/data-gpu-hopper/src/features/main/data/state/lose-life.cases.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { State } from "./state.js";
-import type { ConformanceCase } from "./conformance-case.js";
-
-// A 5-wide board, so the respawn column is `floor((5-1)/2) = 2`. loseLife reads
-// only lives / status / frog / width; the rest is inert here.
-const base: Omit<State, "lives" | "status" | "frog"> = {
-  width: 5,
-  height: 3,
-  lanes: [],
-  hazards: [],
-  score: 0,
-};
-
-// Spec-owned `{ before, args, after }` cases for `State.loseLife`, shared with the
-// ecs `loseLife` transaction: a life lost + respawn, the last life ending the
-// game (no respawn), and the finished-game no-op.
-export const cases: readonly ConformanceCase<void>[] = [
-  {
-    name: "spends a life and respawns the frog at the start",
-    before: { ...base, lives: 3, status: "playing", frog: { x: 1, y: 1 } },
-    args: undefined,
-    after: { ...base, lives: 2, status: "playing", frog: { x: 2, y: 0 } },
-  },
-  {
-    name: "the last life ends the game without respawning",
-    before: { ...base, lives: 1, status: "playing", frog: { x: 3, y: 2 } },
-    args: undefined,
-    after: { ...base, lives: 0, status: "gameOver", frog: { x: 3, y: 2 } },
-  },
-  {
-    name: "ignores a finished game (no-op)",
-    before: { ...base, lives: 0, status: "gameOver", frog: { x: 3, y: 2 } },
-    args: undefined,
-    after: { ...base, lives: 0, status: "gameOver", frog: { x: 3, y: 2 } },
-  },
-];
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/lose-life.ts b/packages/data-gpu-hopper/src/features/main/data/state/lose-life.ts
index 33a98178..8064830c 100644
--- a/packages/data-gpu-hopper/src/features/main/data/state/lose-life.ts
+++ b/packages/data-gpu-hopper/src/features/main/data/state/lose-life.ts
@@ -1,16 +1,42 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { GameStatus } from "../game-status/game-status.js";
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
 import { startPosition } from "./start-position.js";
 
 // Spend one life: respawn the frog at the start, or end the game if that was the
-// last life. A no-op once the game has finished, keeping it idempotent.
-export const loseLife = <T extends Pick<State, "lives" | "status" | "frog" | "width">>(
-  state: T,
-): T => {
-  if (!GameStatus.isPlaying(state.status)) return state;
+// last life. A no-op once the game has finished. Writes only `lives` + `status`
+// + `frog` (each branch supplies all three; some are unchanged).
+export const loseLife = (
+  state: Pick<State, "lives" | "status" | "frog" | "width">,
+): Pick<State, "lives" | "status" | "frog"> => {
+  if (!GameStatus.isPlaying(state.status))
+    return { lives: state.lives, status: state.status, frog: state.frog };
   const lives = state.lives - 1;
   return lives <= 0
-    ? { ...state, lives: 0, status: "gameOver" }
-    : { ...state, lives, frog: startPosition(state) };
+    ? { lives: 0, status: "gameOver", frog: state.frog }
+    : { lives, status: state.status, frog: startPosition(state) };
 };
+
+// A 5-wide board, so the respawn column is `floor((5-1)/2) = 2`. loseLife reads
+// only lives / status / frog / width; the rest is inert here.
+const base: Omit<State, "lives" | "status" | "frog"> = {
+  width: 5,
+  height: 3,
+  lanes: [],
+  hazards: [],
+  score: 0,
+};
+
+// Spec-owned cases, shared with the ecs `loseLife` transaction.
+export const cases: Conformance<typeof loseLife> = [
+  { name: "spends a life and respawns the frog at the start",
+    before: { ...base, lives: 3, status: "playing", frog: { x: 1, y: 1 } },
+    after: { lives: 2, status: "playing", frog: { x: 2, y: 0 } } },
+  { name: "the last life ends the game without respawning",
+    before: { ...base, lives: 1, status: "playing", frog: { x: 3, y: 2 } },
+    after: { lives: 0, status: "gameOver", frog: { x: 3, y: 2 } } },
+  { name: "ignores a finished game (no-op)",
+    before: { ...base, lives: 0, status: "gameOver", frog: { x: 3, y: 2 } },
+    after: { lives: 0, status: "gameOver", frog: { x: 3, y: 2 } } },
+];
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/new-game.cases.ts b/packages/data-gpu-hopper/src/features/main/data/state/new-game.cases.ts
deleted file mode 100644
index 7afbecbd..00000000
--- a/packages/data-gpu-hopper/src/features/main/data/state/new-game.cases.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { State } from "./state.js";
-import type { ConformanceCase } from "./conformance-case.js";
-
-// `newGame` ignores the prior state and resets to `State.create()`. The `before`
-// here differs in every field (dimensions, terrain, hazards, frog, lives, score,
-// status) so the case proves the reset is total. Shared with the ecs `newGame`
-// transaction, whose spec is `State.create`.
-export const cases: readonly ConformanceCase<void>[] = [
-  {
-    name: "resets a mid-game store to the initial game",
-    before: {
-      width: 3,
-      height: 3,
-      lanes: [
-        { row: 0, kind: "grass" },
-        { row: 1, kind: "river" },
-        { row: 2, kind: "goal" },
-      ],
-      hazards: [{ kind: "log", lane: 1, x: 0, width: 2, velocity: 1 }],
-      frog: { x: 1, y: 2 },
-      lives: 0,
-      score: 7,
-      status: "gameOver",
-    },
-    args: undefined,
-    after: State.create(),
-  },
-];
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/new-game.ts b/packages/data-gpu-hopper/src/features/main/data/state/new-game.ts
new file mode 100644
index 00000000..19a60629
--- /dev/null
+++ b/packages/data-gpu-hopper/src/features/main/data/state/new-game.ts
@@ -0,0 +1,35 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+import { create } from "./create.js";
+
+// A "new game" TRANSITION: it deliberately **ignores** the prior `state` and
+// produces the initial game (see `create`), which is exactly what the ecs
+// `newGame` transaction it maps to does (it clears whatever was there). The prior
+// state is still the first parameter so it fits the `(state, args) => state` shape
+// the co-located conformance cases derive from.
+export const newGame = (_state: State): State => create();
+
+// Spec-owned cases, shared with the ecs `newGame` transaction. `before` is a
+// fully-divergent mid-run state (dimensions, terrain, hazards, frog, lives, score,
+// status all differ) so the reset is proven total.
+export const cases: Conformance<typeof newGame> = [
+  {
+    name: "resets a mid-game store to the initial game",
+    before: {
+      width: 3,
+      height: 3,
+      lanes: [
+        { row: 0, kind: "grass" },
+        { row: 1, kind: "river" },
+        { row: 2, kind: "goal" },
+      ],
+      hazards: [{ kind: "log", lane: 1, x: 0, width: 2, velocity: 1 }],
+      frog: { x: 1, y: 2 },
+      lives: 0,
+      score: 7,
+      status: "gameOver",
+    },
+    after: create(),
+  },
+];
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/public.ts b/packages/data-gpu-hopper/src/features/main/data/state/public.ts
index f517d7e0..091178c5 100644
--- a/packages/data-gpu-hopper/src/features/main/data/state/public.ts
+++ b/packages/data-gpu-hopper/src/features/main/data/state/public.ts
@@ -1,9 +1,11 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 export { create } from "./create.js";
+export { samples } from "./samples.js";
 export { hop } from "./hop.js";
 export { step } from "./step.js";
 export { winGoal } from "./win-goal.js";
 export { loseLife } from "./lose-life.js";
+export { newGame } from "./new-game.js";
 export { startPosition } from "./start-position.js";
 export { laneAt } from "./lane-at.js";
 export { frogOutcome } from "./frog-outcome.js";
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/samples.ts b/packages/data-gpu-hopper/src/features/main/data/state/samples.ts
new file mode 100644
index 00000000..966ba282
--- /dev/null
+++ b/packages/data-gpu-hopper/src/features/main/data/state/samples.ts
@@ -0,0 +1,41 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+import { create } from "./create.js";
+
+// Representative full states for the projection round-trip (toState ∘ fromState ≡
+// identity). The initial game, a mid-run state with a fractional log-carried frog
+// and depleted lives, and a minimal empty board — together exercising the whole
+// ecs↔State map (resources, the frog entity, and the hazard bag).
+export const samples: readonly State[] = [
+  create(),
+  {
+    width: 5,
+    height: 3,
+    lanes: [
+      { row: 0, kind: "grass" },
+      { row: 1, kind: "river" },
+      { row: 2, kind: "goal" },
+    ],
+    hazards: [
+      { kind: "log", lane: 1, x: 1.5, width: 3, velocity: 1 },
+      { kind: "log", lane: 1, x: 4, width: 2, velocity: 1 },
+    ],
+    frog: { x: 2.5, y: 1 },
+    lives: 1,
+    score: 4,
+    status: "playing",
+  },
+  {
+    width: 4,
+    height: 2,
+    lanes: [
+      { row: 0, kind: "grass" },
+      { row: 1, kind: "goal" },
+    ],
+    hazards: [],
+    frog: { x: 1, y: 0 },
+    lives: 3,
+    score: 0,
+    status: "playing",
+  },
+];
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/spec.test.ts b/packages/data-gpu-hopper/src/features/main/data/state/spec.test.ts
new file mode 100644
index 00000000..284c732c
--- /dev/null
+++ b/packages/data-gpu-hopper/src/features/main/data/state/spec.test.ts
@@ -0,0 +1,15 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Conformance } from "@adobe/data/testing";
+import { State } from "./state.js";
+import { transitions } from "./transitions.js";
+
+// The single pure-spec test for every transform in this folder. `runSpec`
+// auto-discovers each module in `transitions` that exports `cases`, requires it to
+// export exactly its function plus `cases`, and dispatches on case shape. The
+// hazard bag the ecs materialises in nondeterministic row order compares as a
+// multiset via `match.unordered`.
+Conformance.runSpec({
+  state: State,
+  transitions,
+  match: { unordered: new Set(["hazards"]) },
+});
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/step.cases.ts b/packages/data-gpu-hopper/src/features/main/data/state/step.cases.ts
deleted file mode 100644
index a22c432e..00000000
--- a/packages/data-gpu-hopper/src/features/main/data/state/step.cases.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { Lane } from "../lane/lane.js";
-import type { ConformanceCase } from "./conformance-case.js";
-
-// Two 5-wide, 3-tall boards differing only in the middle lane's terrain.
-const roadLanes: readonly Lane[] = [
-  { row: 0, kind: "grass" },
-  { row: 1, kind: "road" },
-  { row: 2, kind: "goal" },
-];
-const riverLanes: readonly Lane[] = [
-  { row: 0, kind: "grass" },
-  { row: 1, kind: "river" },
-  { row: 2, kind: "goal" },
-];
-
-// Spec-owned `{ before, args, after }` cases for `State.step` (args is dt), shared
-// with the ecs tick. Every step here uses dt = 1 so hazard/carry displacements are
-// exact. Covers: hazards scrolling while the frog stays safe, a car hit (life lost
-// + respawn), the final-life game over, drowning over open water, riding a log,
-// being carried off the board edge (with a wrapping log), reaching the goal, and
-// the game-over no-op.
-export const cases: readonly ConformanceCase<number>[] = [
-  {
-    name: "scrolls hazards while the frog rests on grass",
-    before: {
-      width: 5, height: 3, lanes: roadLanes,
-      hazards: [{ kind:"car", lane: 1, x: 0, width: 1, velocity: 1 }],
-      frog: { x: 2, y: 0 }, lives: 3, score: 0, status: "playing",
-    },
-    args: 1,
-    after: {
-      width: 5, height: 3, lanes: roadLanes,
-      hazards: [{ kind:"car", lane: 1, x: 1, width: 1, velocity: 1 }],
-      frog: { x: 2, y: 0 }, lives: 3, score: 0, status: "playing",
-    },
-  },
-  {
-    name: "a car reaching the frog costs a life and respawns it",
-    before: {
-      width: 5, height: 3, lanes: roadLanes,
-      hazards: [{ kind:"car", lane: 1, x: 0, width: 1, velocity: 1 }],
-      frog: { x: 1, y: 1 }, lives: 3, score: 0, status: "playing",
-    },
-    args: 1,
-    after: {
-      width: 5, height: 3, lanes: roadLanes,
-      hazards: [{ kind:"car", lane: 1, x: 1, width: 1, velocity: 1 }],
-      frog: { x: 2, y: 0 }, lives: 2, score: 0, status: "playing",
-    },
-  },
-  {
-    name: "a car hit on the last life ends the game",
-    before: {
-      width: 5, height: 3, lanes: roadLanes,
-      hazards: [{ kind:"car", lane: 1, x: 0, width: 1, velocity: 1 }],
-      frog: { x: 1, y: 1 }, lives: 1, score: 0, status: "playing",
-    },
-    args: 1,
-    after: {
-      width: 5, height: 3, lanes: roadLanes,
-      hazards: [{ kind:"car", lane: 1, x: 1, width: 1, velocity: 1 }],
-      frog: { x: 1, y: 1 }, lives: 0, score: 0, status: "gameOver",
-    },
-  },
-  {
-    name: "open water with no log under the frog drowns it",
-    before: {
-      width: 5, height: 3, lanes: riverLanes,
-      hazards: [{ kind:"log", lane: 1, x: 3, width: 1, velocity: 0 }],
-      frog: { x: 1, y: 1 }, lives: 3, score: 0, status: "playing",
-    },
-    args: 1,
-    after: {
-      width: 5, height: 3, lanes: riverLanes,
-      hazards: [{ kind:"log", lane: 1, x: 3, width: 1, velocity: 0 }],
-      frog: { x: 2, y: 0 }, lives: 2, score: 0, status: "playing",
-    },
-  },
-  {
-    name: "a log carries the frog along and keeps it safe",
-    before: {
-      width: 5, height: 3, lanes: riverLanes,
-      hazards: [{ kind:"log", lane: 1, x: 0, width: 3, velocity: 1 }],
-      frog: { x: 1, y: 1 }, lives: 3, score: 0, status: "playing",
-    },
-    args: 1,
-    after: {
-      width: 5, height: 3, lanes: riverLanes,
-      hazards: [{ kind:"log", lane: 1, x: 1, width: 3, velocity: 1 }],
-      frog: { x: 2, y: 1 }, lives: 3, score: 0, status: "playing",
-    },
-  },
-  {
-    name: "a log carrying the frog past the edge drowns it",
-    before: {
-      width: 5, height: 3, lanes: riverLanes,
-      hazards: [{ kind:"log", lane: 1, x: 3, width: 2, velocity: 2 }],
-      frog: { x: 4, y: 1 }, lives: 3, score: 0, status: "playing",
-    },
-    args: 1,
-    after: {
-      width: 5, height: 3, lanes: riverLanes,
-      hazards: [{ kind:"log", lane: 1, x: 0, width: 2, velocity: 2 }],
-      frog: { x: 2, y: 0 }, lives: 2, score: 0, status: "playing",
-    },
-  },
-  {
-    name: "reaching the goal scores and wins",
-    before: {
-      width: 5, height: 3, lanes: roadLanes,
-      hazards: [{ kind:"car", lane: 1, x: 0, width: 1, velocity: 1 }],
-      frog: { x: 2, y: 2 }, lives: 3, score: 0, status: "playing",
-    },
-    args: 1,
-    after: {
-      width: 5, height: 3, lanes: roadLanes,
-      hazards: [{ kind:"car", lane: 1, x: 1, width: 1, velocity: 1 }],
-      frog: { x: 2, y: 2 }, lives: 3, score: 1, status: "won",
-    },
-  },
-  {
-    name: "does nothing once the game is over",
-    before: {
-      width: 5, height: 3, lanes: roadLanes,
-      hazards: [{ kind:"car", lane: 1, x: 0, width: 1, velocity: 1 }],
-      frog: { x: 2, y: 0 }, lives: 0, score: 0, status: "gameOver",
-    },
-    args: 1,
-    after: {
-      width: 5, height: 3, lanes: roadLanes,
-      hazards: [{ kind:"car", lane: 1, x: 0, width: 1, velocity: 1 }],
-      frog: { x: 2, y: 0 }, lives: 0, score: 0, status: "gameOver",
-    },
-  },
-];
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/step.test.ts b/packages/data-gpu-hopper/src/features/main/data/state/step.test.ts
deleted file mode 100644
index 6b531ae1..00000000
--- a/packages/data-gpu-hopper/src/features/main/data/state/step.test.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./step.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.step", () => {
-  for (const { name, before, args, after } of cases) {
-    it(name, () => {
-      expectStateMatches(State.step(before, args), after);
-    });
-  }
-});
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/step.ts b/packages/data-gpu-hopper/src/features/main/data/state/step.ts
index 6db5f81b..802eeb77 100644
--- a/packages/data-gpu-hopper/src/features/main/data/state/step.ts
+++ b/packages/data-gpu-hopper/src/features/main/data/state/step.ts
@@ -3,18 +3,35 @@ import { Hazard } from "../hazard/hazard.js";
 import { LaneKind } from "../lane-kind/lane-kind.js";
 import { Outcome } from "../outcome/outcome.js";
 import { GameStatus } from "../game-status/game-status.js";
+import type { Lane } from "../lane/lane.js";
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
 import { laneAt } from "./lane-at.js";
 import { frogOutcome } from "./frog-outcome.js";
 import { winGoal } from "./win-goal.js";
 import { loseLife } from "./lose-life.js";
 
+// The slice `step` writes. Every branch supplies all five keys; a composer layers
+// the outcome sub-patch (`winGoal` / `loseLife`) over the movement fields.
+type StepPatch = Pick<State, "hazards" | "frog" | "score" | "status" | "lives">;
+
 // Advance the simulation by `dt` seconds: scroll the hazards, carry the frog if
 // it is riding a log, then resolve its fate — score a win, or on a fatal outcome
 // spend a life and respawn (or end the game once the last life is gone). A no-op
 // once the game has ended, keeping it idempotent.
-export const step = (state: State, dt: number): State => {
-  if (!GameStatus.isPlaying(state.status)) return state;
+export const step = (
+  state: Pick<State, "hazards" | "frog" | "lanes" | "width" | "status" | "score" | "lives">,
+  dt: number,
+): StepPatch => {
+  if (!GameStatus.isPlaying(state.status)) {
+    return {
+      hazards: state.hazards,
+      frog: state.frog,
+      score: state.score,
+      status: state.status,
+      lives: state.lives,
+    };
+  }
 
   const hazards = state.hazards.map((hazard) => Hazard.advance(hazard, dt, state.width));
   const lane = laneAt(state, state.frog.y);
@@ -32,10 +49,98 @@ export const step = (state: State, dt: number): State => {
     ? { x: state.frog.x + carrier.velocity * dt, y: state.frog.y }
     : state.frog;
 
-  const moved: State = { ...state, hazards, frog };
+  // The moved world (full read slice + updated hazards/frog), fed to the outcome
+  // derivation and the winGoal / loseLife sub-transitions.
+  const moved = { ...state, hazards, frog };
+  // The movement-only patch the outcome sub-patch layers over.
+  const movedPatch: StepPatch = {
+    hazards,
+    frog,
+    score: state.score,
+    status: state.status,
+    lives: state.lives,
+  };
   const outcome = frogOutcome(moved);
 
-  if (outcome === "win") return winGoal(moved);
-  if (Outcome.isFatal[outcome]) return loseLife(moved);
-  return moved;
+  if (outcome === "win") return { ...movedPatch, ...winGoal(moved) };
+  if (Outcome.isFatal[outcome]) return { ...movedPatch, ...loseLife(moved) };
+  return movedPatch;
 };
+
+// Two 5-wide, 3-tall boards differing only in the middle lane's terrain.
+const roadLanes: readonly Lane[] = [
+  { row: 0, kind: "grass" },
+  { row: 1, kind: "road" },
+  { row: 2, kind: "goal" },
+];
+const riverLanes: readonly Lane[] = [
+  { row: 0, kind: "grass" },
+  { row: 1, kind: "river" },
+  { row: 2, kind: "goal" },
+];
+
+// Spec-owned cases (args is dt), shared with the ecs tick (the system loop conforms
+// to this — see systems.md). Every step here uses dt = 1 so hazard/carry
+// displacements are exact. `before` overrides the default with a small test board;
+// `after` is the writes patch (hazards / frog / score / status / lives). Covers:
+// hazards scrolling while the frog stays safe, a car hit (life lost + respawn), the
+// final-life game over, drowning over open water, riding a log, being carried off
+// the board edge (with a wrapping log), reaching the goal, and the game-over no-op.
+export const cases: Conformance<typeof step> = [
+  { name: "scrolls hazards while the frog rests on grass",
+    before: { width: 5, height: 3, lanes: roadLanes,
+      hazards: [{ kind: "car", lane: 1, x: 0, width: 1, velocity: 1 }],
+      frog: { x: 2, y: 0 }, lives: 3, score: 0, status: "playing" },
+    args: 1,
+    after: { hazards: [{ kind: "car", lane: 1, x: 1, width: 1, velocity: 1 }],
+      frog: { x: 2, y: 0 }, lives: 3, score: 0, status: "playing" } },
+  { name: "a car reaching the frog costs a life and respawns it",
+    before: { width: 5, height: 3, lanes: roadLanes,
+      hazards: [{ kind: "car", lane: 1, x: 0, width: 1, velocity: 1 }],
+      frog: { x: 1, y: 1 }, lives: 3, score: 0, status: "playing" },
+    args: 1,
+    after: { hazards: [{ kind: "car", lane: 1, x: 1, width: 1, velocity: 1 }],
+      frog: { x: 2, y: 0 }, lives: 2, score: 0, status: "playing" } },
+  { name: "a car hit on the last life ends the game",
+    before: { width: 5, height: 3, lanes: roadLanes,
+      hazards: [{ kind: "car", lane: 1, x: 0, width: 1, velocity: 1 }],
+      frog: { x: 1, y: 1 }, lives: 1, score: 0, status: "playing" },
+    args: 1,
+    after: { hazards: [{ kind: "car", lane: 1, x: 1, width: 1, velocity: 1 }],
+      frog: { x: 1, y: 1 }, lives: 0, score: 0, status: "gameOver" } },
+  { name: "open water with no log under the frog drowns it",
+    before: { width: 5, height: 3, lanes: riverLanes,
+      hazards: [{ kind: "log", lane: 1, x: 3, width: 1, velocity: 0 }],
+      frog: { x: 1, y: 1 }, lives: 3, score: 0, status: "playing" },
+    args: 1,
+    after: { hazards: [{ kind: "log", lane: 1, x: 3, width: 1, velocity: 0 }],
+      frog: { x: 2, y: 0 }, lives: 2, score: 0, status: "playing" } },
+  { name: "a log carries the frog along and keeps it safe",
+    before: { width: 5, height: 3, lanes: riverLanes,
+      hazards: [{ kind: "log", lane: 1, x: 0, width: 3, velocity: 1 }],
+      frog: { x: 1, y: 1 }, lives: 3, score: 0, status: "playing" },
+    args: 1,
+    after: { hazards: [{ kind: "log", lane: 1, x: 1, width: 3, velocity: 1 }],
+      frog: { x: 2, y: 1 }, lives: 3, score: 0, status: "playing" } },
+  { name: "a log carrying the frog past the edge drowns it",
+    before: { width: 5, height: 3, lanes: riverLanes,
+      hazards: [{ kind: "log", lane: 1, x: 3, width: 2, velocity: 2 }],
+      frog: { x: 4, y: 1 }, lives: 3, score: 0, status: "playing" },
+    args: 1,
+    after: { hazards: [{ kind: "log", lane: 1, x: 0, width: 2, velocity: 2 }],
+      frog: { x: 2, y: 0 }, lives: 2, score: 0, status: "playing" } },
+  { name: "reaching the goal scores and wins",
+    before: { width: 5, height: 3, lanes: roadLanes,
+      hazards: [{ kind: "car", lane: 1, x: 0, width: 1, velocity: 1 }],
+      frog: { x: 2, y: 2 }, lives: 3, score: 0, status: "playing" },
+    args: 1,
+    after: { hazards: [{ kind: "car", lane: 1, x: 1, width: 1, velocity: 1 }],
+      frog: { x: 2, y: 2 }, lives: 3, score: 1, status: "won" } },
+  { name: "does nothing once the game is over",
+    before: { width: 5, height: 3, lanes: roadLanes,
+      hazards: [{ kind: "car", lane: 1, x: 0, width: 1, velocity: 1 }],
+      frog: { x: 2, y: 0 }, lives: 0, score: 0, status: "gameOver" },
+    args: 1,
+    after: { hazards: [{ kind: "car", lane: 1, x: 0, width: 1, velocity: 1 }],
+      frog: { x: 2, y: 0 }, lives: 0, score: 0, status: "gameOver" } },
+];
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/transitions.ts b/packages/data-gpu-hopper/src/features/main/data/state/transitions.ts
new file mode 100644
index 00000000..1092fd91
--- /dev/null
+++ b/packages/data-gpu-hopper/src/features/main/data/state/transitions.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+/// <reference types="vite/client" />
+
+// The transform/derivation modules for conformance discovery — the `{ fn, cases }`
+// source shared by `spec.test.ts` (pure) and the ecs `conformance.test.ts`. The
+// glob must be authored where Vite can statically see it (an eager glob, excluding
+// tests and this file itself); consumers import the resolved map.
+export const transitions = import.meta.glob<Record<string, unknown>>(
+  ["./*.ts", "!./*.test.ts", "!./*.type-test.ts", "!./transitions.ts"],
+  { eager: true },
+);
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/win-goal.cases.ts b/packages/data-gpu-hopper/src/features/main/data/state/win-goal.cases.ts
deleted file mode 100644
index b9b43f3d..00000000
--- a/packages/data-gpu-hopper/src/features/main/data/state/win-goal.cases.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { State } from "./state.js";
-import type { ConformanceCase } from "./conformance-case.js";
-
-// winGoal reads only score / status; the rest is inert here.
-const base: Omit<State, "score" | "status"> = {
-  width: 5,
-  height: 3,
-  lanes: [],
-  hazards: [],
-  lives: 3,
-  frog: { x: 2, y: 2 },
-};
-
-// Spec-owned `{ before, args, after }` cases for `State.winGoal`, shared with the
-// ecs `winGoal` transaction: scoring the goal, and the finished-game no-op.
-export const cases: readonly ConformanceCase<void>[] = [
-  {
-    name: "scores the goal and wins",
-    before: { ...base, score: 2, status: "playing" },
-    args: undefined,
-    after: { ...base, score: 3, status: "won" },
-  },
-  {
-    name: "ignores a finished game (no-op)",
-    before: { ...base, score: 3, status: "won" },
-    args: undefined,
-    after: { ...base, score: 3, status: "won" },
-  },
-];
diff --git a/packages/data-gpu-hopper/src/features/main/data/state/win-goal.ts b/packages/data-gpu-hopper/src/features/main/data/state/win-goal.ts
index 715b3d21..4addcc6c 100644
--- a/packages/data-gpu-hopper/src/features/main/data/state/win-goal.ts
+++ b/packages/data-gpu-hopper/src/features/main/data/state/win-goal.ts
@@ -1,10 +1,31 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { GameStatus } from "../game-status/game-status.js";
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
 
 // Score the reached goal and end the game as won. A no-op once the game has
-// finished, keeping it idempotent.
-export const winGoal = <T extends Pick<State, "score" | "status">>(state: T): T => {
-  if (!GameStatus.isPlaying(state.status)) return state;
-  return { ...state, score: state.score + 1, status: "won" };
+// finished. Writes only `score` + `status`.
+export const winGoal = (
+  state: Pick<State, "score" | "status">,
+): Pick<State, "score" | "status"> => {
+  if (!GameStatus.isPlaying(state.status)) return { score: state.score, status: state.status };
+  return { score: state.score + 1, status: "won" };
 };
+
+// winGoal reads only score / status; the rest is inert here.
+const base: Omit<State, "score" | "status"> = {
+  width: 5,
+  height: 3,
+  lanes: [],
+  hazards: [],
+  lives: 3,
+  frog: { x: 2, y: 2 },
+};
+
+// Spec-owned cases, shared with the ecs `winGoal` transaction.
+export const cases: Conformance<typeof winGoal> = [
+  { name: "scores the goal and wins",
+    before: { ...base, score: 2, status: "playing" }, after: { score: 3, status: "won" } },
+  { name: "ignores a finished game (no-op)",
+    before: { ...base, score: 3, status: "won" }, after: { score: 3, status: "won" } },
+];
diff --git a/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/conformance.test.ts b/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/conformance.test.ts
new file mode 100644
index 00000000..ec8b591a
--- /dev/null
+++ b/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/conformance.test.ts
@@ -0,0 +1,22 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Conformance } from "@adobe/data/testing";
+import { State } from "../../../data/state/state.js";
+import { transitions } from "../../../data/state/transitions.js";
+import { MainService } from "../main-service.js";
+import { projection } from "./projection.js";
+
+// The whole ecs conformance for this feature in one call: `runFeature` pairs each
+// transaction on `MainService.plugin` (hop / winGoal / loseLife / newGame) with its
+// same-named `data/state` transition, seeds each case's `before` over
+// `State.create()`, and round-trips `State.samples` through the projection. The
+// hazard bag the ecs materialises in nondeterministic row order compares as a
+// multiset via `match.unordered`. `step` has no transaction — the per-frame system
+// loop conforms it in `system-database/tick-loop.test.ts` (see systems.md) — so it
+// is simply skipped here. Hopper has no derivations, so no `computedPlugin`.
+Conformance.runFeature({
+  state: State,
+  transitions,
+  plugin: MainService.plugin,
+  projection,
+  match: { unordered: new Set(["hazards"]) },
+});
diff --git a/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/create-store.ts b/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/create-store.ts
deleted file mode 100644
index 640d619a..00000000
--- a/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/create-store.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { Store } from "@adobe/data/ecs";
-import { CoreDatabase } from "../core-database/core-database.js";
-
-// A fresh writable store carrying the feature's whole schema. Hopper has no
-// index layer, so `CoreDatabase` is the lowest (and only schema) layer, and
-// `Store.create` reads its schema facets directly. Typed as `CoreDatabase.Store`:
-// the surface the projection (`fromState` / `toState`) and the raw transaction
-// functions use. Test-only.
-export const createStore = (): CoreDatabase.Store => Store.create(CoreDatabase.plugin);
diff --git a/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/create-system-database.ts b/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/create-system-database.ts
index c76e5086..89f7ce4a 100644
--- a/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/create-system-database.ts
+++ b/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/create-system-database.ts
@@ -1,6 +1,6 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Database } from "@adobe/data/ecs";
-import { FeatureDatabase } from "../feature-database.js";
+import { MainService } from "../main-service.js";
 
 // The assembled feature database viewed as its writable *system surface* — the
 // same `Database & { store }` a system's `create(db)` receives — obtained
@@ -9,5 +9,5 @@ import { FeatureDatabase } from "../feature-database.js";
 // `db.system.functions` and reach the store via `db.store`. Transaction and
 // projection conformance use `createStore` instead. Test-only.
 export const createSystemDatabase = (): Database.Plugin.ToSystemDatabase<
-  typeof FeatureDatabase.plugin
-> => Database.toSystemDatabase(Database.create(FeatureDatabase.plugin));
+  typeof MainService.plugin
+> => Database.toSystemDatabase(Database.create(MainService.plugin));
diff --git a/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/expect-conforms.ts b/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/expect-conforms.ts
deleted file mode 100644
index b21919ce..00000000
--- a/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/expect-conforms.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { it } from "vitest";
-import type { State } from "../../../data/state/state.js";
-import type { ConformanceCase } from "../../../data/state/conformance-case.js";
-import { expectStateMatches } from "../../../data/state/expect-state-matches.js";
-import type { CoreDatabase } from "../core-database/core-database.js";
-import { createStore } from "./create-store.js";
-import { fromState } from "./from-state.js";
-import { toState } from "./to-state.js";
-
-// The conformance runner, bound to THIS feature's projection (`fromState` /
-// `toState`). For each case it proves the one conformance property
-//
-//   toState(apply(fromState(before), args)) ≡ spec(before, args)
-//
-// in two asserted halves:
-//   1. `spec(before, args) ≡ after` — keeps the shared case honest (a
-//      mis-authored `after` is caught here, independent of the ecs path).
-//   2. seed `fromState(before)` → run the caller's `apply` → `toState ≡ after`
-//      — the ecs implementation reproduces the pure transform.
-//
-// `apply` receives the seeded writable store and calls the raw transaction
-// function directly (a transaction is `(store, args) => void`, so no `Database`
-// is involved). Hopper's transactions take plain data args (a direction, or
-// nothing), so no entity resolution is needed in `apply`. Entity collections
-// compare as multisets; scalars and resources exactly (see `expectStateMatches`).
-export const expectConforms = <Args>(config: {
-  readonly cases: readonly ConformanceCase<Args>[];
-  readonly spec: (before: State, args: Args) => State;
-  readonly apply: (store: CoreDatabase.Store, args: Args) => void;
-}): void => {
-  for (const testCase of config.cases) {
-    it(testCase.name, () => {
-      expectStateMatches(config.spec(testCase.before, testCase.args), testCase.after);
-
-      const store = createStore();
-      fromState(store, testCase.before);
-      config.apply(store, testCase.args);
-      expectStateMatches(toState(store), testCase.after);
-    });
-  }
-};
diff --git a/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/from-state.ts b/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/from-state.ts
deleted file mode 100644
index 2247f8dc..00000000
--- a/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/from-state.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { State } from "../../../data/state/state.js";
-import type { CoreDatabase } from "../core-database/core-database.js";
-
-// Seed a store to exactly match a `data/` `State`: clear the frog and every
-// hazard, set the scalar resources and terrain, then insert one frog entity and
-// one entity per hazard. The inverse of `toState`. Test-only — the bridge that
-// lets an ecs mutation be checked against the pure transform it stands for (see
-// `expect-conforms.ts`). Clearing iterates tail→head so each delete is from the
-// tail (no hole-fill shift).
-export const fromState = (store: CoreDatabase.Store, state: State): void => {
-  for (const arch of store.queryArchetypes(store.archetypes.Frog.components)) {
-    for (let row = arch.rowCount - 1; row >= 0; row--) store.delete(arch.columns.id.get(row));
-  }
-  for (const arch of store.queryArchetypes(store.archetypes.Hazard.components)) {
-    for (let row = arch.rowCount - 1; row >= 0; row--) store.delete(arch.columns.id.get(row));
-  }
-
-  store.resources.width = state.width;
-  store.resources.height = state.height;
-  store.resources.lives = state.lives;
-  store.resources.score = state.score;
-  store.resources.status = state.status;
-  store.resources.lanes = state.lanes;
-
-  store.archetypes.Frog.insert({ x: state.frog.x, y: state.frog.y });
-  for (const hazard of state.hazards) {
-    store.archetypes.Hazard.insert(hazard);
-  }
-};
diff --git a/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/projection.test.ts b/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/projection.test.ts
deleted file mode 100644
index 756d6cc2..00000000
--- a/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/projection.test.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// Guards the projection itself. `fromState` and `toState` are the bridge every
-// transaction conformance test trusts; a symmetric bug in the pair (e.g. both
-// dropping the same field) would cancel out and mask a real ecs defect. This
-// identity test — `toState(fromState(s)) ≡ s` over representative states —
-// proves the projection round-trips faithfully on its own.
-import { describe, it } from "vitest";
-import { State } from "../../../data/state/state.js";
-import type { State as StateType } from "../../../data/state/state.js";
-import { expectStateMatches } from "../../../data/state/expect-state-matches.js";
-import { createStore } from "./create-store.js";
-import { fromState } from "./from-state.js";
-import { toState } from "./to-state.js";
-
-const states: readonly { readonly name: string; readonly state: StateType }[] = [
-  { name: "the initial game", state: State.create() },
-  {
-    name: "a mid-run state with a carried frog and depleted lives",
-    state: {
-      width: 5,
-      height: 3,
-      lanes: [
-        { row: 0, kind: "grass" },
-        { row: 1, kind: "river" },
-        { row: 2, kind: "goal" },
-      ],
-      hazards: [
-        { kind: "log", lane: 1, x: 1.5, width: 3, velocity: 1 },
-        { kind: "log", lane: 1, x: 4, width: 2, velocity: 1 },
-      ],
-      frog: { x: 2.5, y: 1 },
-      lives: 1,
-      score: 4,
-      status: "playing",
-    },
-  },
-  {
-    name: "an empty board with no hazards",
-    state: {
-      width: 4,
-      height: 2,
-      lanes: [
-        { row: 0, kind: "grass" },
-        { row: 1, kind: "goal" },
-      ],
-      hazards: [],
-      frog: { x: 1, y: 0 },
-      lives: 3,
-      score: 0,
-      status: "playing",
-    },
-  },
-];
-
-describe("ecs/conformance projection round-trips (toState ∘ fromState ≡ identity)", () => {
-  for (const { name, state } of states) {
-    it(name, () => {
-      const store = createStore();
-      fromState(store, state);
-      expectStateMatches(toState(store), state);
-    });
-  }
-});
diff --git a/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/projection.ts b/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/projection.ts
new file mode 100644
index 00000000..7a5dbed2
--- /dev/null
+++ b/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/projection.ts
@@ -0,0 +1,78 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "../../../data/state/state.js";
+import type { Frog } from "../../../data/frog/frog.js";
+import type { Hazard } from "../../../data/hazard/hazard.js";
+import type { CoreDatabase } from "../core-database/core-database.js";
+
+// Read the single frog entity through the Frog archetype's full component set
+// (`x`, `y`) — hazards lack `y`, so the shapes never alias.
+const readFrog = (store: CoreDatabase.Store): Frog => {
+  for (const arch of store.queryArchetypes(store.archetypes.Frog.components)) {
+    for (let row = 0; row < arch.rowCount; row++) {
+      return { x: arch.columns.x.get(row), y: arch.columns.y.get(row) };
+    }
+  }
+  throw new Error("frog entity missing from store");
+};
+
+const readHazards = (store: CoreDatabase.Store): Hazard[] => {
+  const hazards: Hazard[] = [];
+  for (const arch of store.queryArchetypes(store.archetypes.Hazard.components)) {
+    for (let row = 0; row < arch.rowCount; row++) {
+      hazards.push({
+        kind: arch.columns.kind.get(row),
+        lane: arch.columns.lane.get(row),
+        x: arch.columns.x.get(row),
+        width: arch.columns.width.get(row),
+        velocity: arch.columns.velocity.get(row),
+      });
+    }
+  }
+  return hazards;
+};
+
+// The test-only ecs↔`State` projection, passed to `Conformance.runFeature` (and
+// reused by the system tick-loop / outcome-selection tests). Hopper is not
+// id-addressed (transactions take a direction, not an entity id), so `fromState`
+// returns no id map and there are no id-list computeds — hence no `toData`. These
+// are STRICTLY for conformance tests and MUST NEVER run in production code.
+export const projection = {
+  // Seed a store to exactly match a `data/` `State`: clear the frog and every
+  // hazard, set the scalar resources and terrain, then insert one frog entity and
+  // one entity per hazard. The inverse of `toState`. Clearing iterates tail→head
+  // so each delete is from the tail (no hole-fill shift). The loop-plumbing
+  // resources (frameDelta / pendingDirection) have no `State` analogue and keep
+  // their defaults.
+  fromState: (store: CoreDatabase.Store, state: State): void => {
+    for (const arch of store.queryArchetypes(store.archetypes.Frog.components)) {
+      for (let row = arch.rowCount - 1; row >= 0; row--) store.delete(arch.columns.id.get(row));
+    }
+    for (const arch of store.queryArchetypes(store.archetypes.Hazard.components)) {
+      for (let row = arch.rowCount - 1; row >= 0; row--) store.delete(arch.columns.id.get(row));
+    }
+
+    store.resources.width = state.width;
+    store.resources.height = state.height;
+    store.resources.lives = state.lives;
+    store.resources.score = state.score;
+    store.resources.status = state.status;
+    store.resources.lanes = state.lanes;
+
+    store.archetypes.Frog.insert({ x: state.frog.x, y: state.frog.y });
+    for (const hazard of state.hazards) {
+      store.archetypes.Hazard.insert(hazard);
+    }
+  },
+  // Read a store back into a `data/` `State` — the inverse of `fromState`. The
+  // scalar resources join the frog and the hazard entities.
+  toState: (store: CoreDatabase.Store): State => ({
+    width: store.resources.width,
+    height: store.resources.height,
+    lanes: store.resources.lanes,
+    hazards: readHazards(store),
+    frog: readFrog(store),
+    lives: store.resources.lives,
+    score: store.resources.score,
+    status: store.resources.status,
+  }),
+};
diff --git a/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/to-state.ts b/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/to-state.ts
deleted file mode 100644
index 6609af53..00000000
--- a/packages/data-gpu-hopper/src/features/main/services/main-service/conformance/to-state.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { State } from "../../../data/state/state.js";
-import type { Frog } from "../../../data/frog/frog.js";
-import type { Hazard } from "../../../data/hazard/hazard.js";
-import type { CoreDatabase } from "../core-database/core-database.js";
-
-// Read the single frog entity through the Frog archetype's full component set
-// (`x`, `y`) — hazards lack `y`, so the shapes never alias.
-const readFrog = (store: CoreDatabase.Store): Frog => {
-  for (const arch of store.queryArchetypes(store.archetypes.Frog.components)) {
-    for (let row = 0; row < arch.rowCount; row++) {
-      return { x: arch.columns.x.get(row), y: arch.columns.y.get(row) };
-    }
-  }
-  throw new Error("frog entity missing from store");
-};
-
-const readHazards = (store: CoreDatabase.Store): Hazard[] => {
-  const hazards: Hazard[] = [];
-  for (const arch of store.queryArchetypes(store.archetypes.Hazard.components)) {
-    for (let row = 0; row < arch.rowCount; row++) {
-      hazards.push({
-        kind: arch.columns.kind.get(row),
-        lane: arch.columns.lane.get(row),
-        x: arch.columns.x.get(row),
-        width: arch.columns.width.get(row),
-        velocity: arch.columns.velocity.get(row),
-      });
-    }
-  }
-  return hazards;
-};
-
-// Read a store back into a `data/` `State` — the inverse of `fromState`. The
-// scalar resources join the frog and the hazard entities. Test-only.
-export const toState = (store: CoreDatabase.Store): State => ({
-  width: store.resources.width,
-  height: store.resources.height,
-  lanes: store.resources.lanes,
-  hazards: readHazards(store),
-  frog: readFrog(store),
-  lives: store.resources.lives,
-  score: store.resources.score,
-  status: store.resources.status,
-});
diff --git a/packages/data-gpu-hopper/src/features/main/services/main-service/feature-database.ts b/packages/data-gpu-hopper/src/features/main/services/main-service/main-service.ts
similarity index 51%
rename from packages/data-gpu-hopper/src/features/main/services/main-service/feature-database.ts
rename to packages/data-gpu-hopper/src/features/main/services/main-service/main-service.ts
index 9778afba..60709299 100644
--- a/packages/data-gpu-hopper/src/features/main/services/main-service/feature-database.ts
+++ b/packages/data-gpu-hopper/src/features/main/services/main-service/main-service.ts
@@ -1,5 +1,5 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 // The whole assembled feature database. Consumers (ui/, the app entry) reference
-// `FeatureDatabase` — never the topmost layer by name — so adding or dropping a
+// `MainService` — never the topmost layer by name — so adding or dropping a
 // behaviour layer changes only this one line.
-export { SystemDatabase as FeatureDatabase } from "./system-database/system-database.js";
+export { SystemDatabase as MainService } from "./system-database/system-database.js";
diff --git a/packages/data-gpu-hopper/src/features/main/services/main-service/system-database/outcome-selection.test.ts b/packages/data-gpu-hopper/src/features/main/services/main-service/system-database/outcome-selection.test.ts
index 3a0d104b..67b2e999 100644
--- a/packages/data-gpu-hopper/src/features/main/services/main-service/system-database/outcome-selection.test.ts
+++ b/packages/data-gpu-hopper/src/features/main/services/main-service/system-database/outcome-selection.test.ts
@@ -11,8 +11,7 @@ import { describe, it, expect } from "vitest";
 import type { State } from "../../../data/state/state.js";
 import type { Lane } from "../../../data/lane/lane.js";
 import { createSystemDatabase } from "../conformance/create-system-database.js";
-import { fromState } from "../conformance/from-state.js";
-import { toState } from "../conformance/to-state.js";
+import { projection } from "../conformance/projection.js";
 import { driveFrame } from "../conformance/drive-frame.js";
 
 const roadLanes: readonly Lane[] = [
@@ -41,10 +40,10 @@ const base = (overrides: Partial<State>): State => ({
 // Seed the geometry, run exactly one selection-only frame (dt 0), project back.
 const detect = (state: State): State => {
   const db = createSystemDatabase();
-  fromState(db.store, state);
+  projection.fromState(db.store, state);
   db.store.resources.frameDelta = 0;
   driveFrame(db);
-  return toState(db.store);
+  return projection.toState(db.store);
 };
 
 describe("outcome selection — road", () => {
diff --git a/packages/data-gpu-hopper/src/features/main/services/main-service/system-database/tick-loop.test.ts b/packages/data-gpu-hopper/src/features/main/services/main-service/system-database/tick-loop.test.ts
index 7e1c446e..8777f6d5 100644
--- a/packages/data-gpu-hopper/src/features/main/services/main-service/system-database/tick-loop.test.ts
+++ b/packages/data-gpu-hopper/src/features/main/services/main-service/system-database/tick-loop.test.ts
@@ -12,29 +12,35 @@
 // frame `frameDelta` (a resource with no `data/` analogue, written straight to the
 // store as the oracle is fed `dt`), and — crucially — seed NO pending input, so
 // the per-frame systems' combined effect equals `State.step(before, dt)` exactly
-// (hop is covered by the transaction test). Then drive one headless frame and
-// assert `toState ≡ after`. Each case also asserts `State.step ≡ after` first,
-// keeping the shared case honest.
+// (hop is covered by the transaction conformance). Then drive one headless frame
+// and assert `toState ≡ after`. Each case also asserts `State.step ≡ after` first,
+// keeping the shared case honest. The hazard bag compares as a multiset.
 import { describe, it } from "vitest";
+import { Match } from "@adobe/data/testing";
 import { State } from "../../../data/state/state.js";
-import { cases } from "../../../data/state/step.cases.js";
-import { expectStateMatches } from "../../../data/state/expect-state-matches.js";
+import { cases } from "../../../data/state/step.js";
 import { createSystemDatabase } from "../conformance/create-system-database.js";
-import { fromState } from "../conformance/from-state.js";
-import { toState } from "../conformance/to-state.js";
+import { projection } from "../conformance/projection.js";
 import { driveFrame } from "../conformance/drive-frame.js";
 
+const unordered = { unordered: new Set(["hazards"]) };
+
 describe("ECS system tick loop conforms to State.step (one frame = one step)", () => {
   for (const testCase of cases) {
     it(testCase.name, () => {
       const dt = testCase.args;
-      expectStateMatches(State.step(testCase.before, dt), testCase.after);
+      // A case `before` is a delta over the feature default and `after` a writes
+      // patch (`Case.before`/`after` are `Partial<State>`), so materialise the full
+      // seed and the full expected state the same way the runners do.
+      const before = { ...State.create(), ...testCase.before };
+      const expected = { ...before, ...testCase.after };
+      Match.assert({ ...before, ...State.step(before, dt) }, expected, unordered);
 
       const db = createSystemDatabase();
-      fromState(db.store, testCase.before);
+      projection.fromState(db.store, before);
       db.store.resources.frameDelta = dt;
       driveFrame(db);
-      expectStateMatches(toState(db.store), testCase.after);
+      Match.assert(projection.toState(db.store), expected, unordered);
     });
   }
 });
diff --git a/packages/data-gpu-hopper/src/features/main/services/main-service/transaction-database/transactions/hop.test.ts b/packages/data-gpu-hopper/src/features/main/services/main-service/transaction-database/transactions/hop.test.ts
deleted file mode 100644
index ea0fb355..00000000
--- a/packages/data-gpu-hopper/src/features/main/services/main-service/transaction-database/transactions/hop.test.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `hop` conforms to `State.hop`. Both take a plain direction, so `apply` calls
-// the raw transaction directly on the seeded store — no entity resolution
-// needed. Every direction, edge clamp, the grid-snap, and the game-over no-op
-// are covered by the shared spec cases.
-import { describe } from "vitest";
-import { State } from "../../../../data/state/state.js";
-import { cases } from "../../../../data/state/hop.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { hop } from "./hop.js";
-
-describe("hop transaction conforms to State.hop", () => {
-  expectConforms({
-    cases,
-    spec: State.hop,
-    apply: hop,
-  });
-});
diff --git a/packages/data-gpu-hopper/src/features/main/services/main-service/transaction-database/transactions/lose-life.test.ts b/packages/data-gpu-hopper/src/features/main/services/main-service/transaction-database/transactions/lose-life.test.ts
deleted file mode 100644
index 6daf989c..00000000
--- a/packages/data-gpu-hopper/src/features/main/services/main-service/transaction-database/transactions/lose-life.test.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `loseLife` conforms to `State.loseLife` — spend a life and respawn, end the
-// game on the last life, and no-op once finished. Shared spec cases.
-import { describe } from "vitest";
-import { State } from "../../../../data/state/state.js";
-import { cases } from "../../../../data/state/lose-life.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { loseLife } from "./lose-life.js";
-
-describe("loseLife transaction conforms to State.loseLife", () => {
-  expectConforms({
-    cases,
-    spec: State.loseLife,
-    apply: loseLife,
-  });
-});
diff --git a/packages/data-gpu-hopper/src/features/main/services/main-service/transaction-database/transactions/new-game.test.ts b/packages/data-gpu-hopper/src/features/main/services/main-service/transaction-database/transactions/new-game.test.ts
deleted file mode 100644
index 6bdef1b8..00000000
--- a/packages/data-gpu-hopper/src/features/main/services/main-service/transaction-database/transactions/new-game.test.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `newGame` conforms to `State.create` — it discards whatever the store held and
-// re-seeds the initial game. The shared case seeds a fully-divergent mid-run
-// state so the reset is proven total.
-import { describe } from "vitest";
-import { State } from "../../../../data/state/state.js";
-import { cases } from "../../../../data/state/new-game.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { newGame } from "./new-game.js";
-
-describe("newGame transaction conforms to State.create", () => {
-  expectConforms({
-    cases,
-    spec: State.create,
-    apply: newGame,
-  });
-});
diff --git a/packages/data-gpu-hopper/src/features/main/services/main-service/transaction-database/transactions/win-goal.test.ts b/packages/data-gpu-hopper/src/features/main/services/main-service/transaction-database/transactions/win-goal.test.ts
deleted file mode 100644
index 66d3679a..00000000
--- a/packages/data-gpu-hopper/src/features/main/services/main-service/transaction-database/transactions/win-goal.test.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `winGoal` conforms to `State.winGoal` — score + win, and no-op once finished.
-// Shared spec cases.
-import { describe } from "vitest";
-import { State } from "../../../../data/state/state.js";
-import { cases } from "../../../../data/state/win-goal.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { winGoal } from "./win-goal.js";
-
-describe("winGoal transaction conforms to State.winGoal", () => {
-  expectConforms({
-    cases,
-    spec: State.winGoal,
-    apply: winGoal,
-  });
-});
diff --git a/packages/data-gpu-hopper/src/features/main/ui/hopper-app-plugin.ts b/packages/data-gpu-hopper/src/features/main/ui/hopper-app-plugin.ts
index 2245ae90..8e71721b 100644
--- a/packages/data-gpu-hopper/src/features/main/ui/hopper-app-plugin.ts
+++ b/packages/data-gpu-hopper/src/features/main/ui/hopper-app-plugin.ts
@@ -1,13 +1,13 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Database } from "@adobe/data/ecs";
-import { FeatureDatabase } from "../services/main-service/feature-database.js";
+import { MainService } from "../services/main-service/main-service.js";
 import { HopperRenderDatabase } from "./render/hopper-render-plugin.js";
 
-// The browser application: the headless simulation (`FeatureDatabase`) plus the
+// The browser application: the headless simulation (`MainService`) plus the
 // GPU renderer combined on top. `combine` dedupes the shared `scheduler` and the
 // shared `CoreDatabase` schema by identity, so there is one store and one frame
-// loop. The headless tests keep using `FeatureDatabase` alone.
-const hopperAppPlugin = Database.Plugin.combine(FeatureDatabase.plugin, HopperRenderDatabase.plugin);
+// loop. The headless tests keep using `MainService` alone.
+const hopperAppPlugin = Database.Plugin.combine(MainService.plugin, HopperRenderDatabase.plugin);
 
 export type HopperApp = Database.Plugin.ToDatabase<typeof hopperAppPlugin>;
 
diff --git a/packages/data-gpu-hopper/src/features/main/ui/render/hopper-render-plugin.ts b/packages/data-gpu-hopper/src/features/main/ui/render/hopper-render-plugin.ts
index a9373f48..e4b6a5b8 100644
--- a/packages/data-gpu-hopper/src/features/main/ui/render/hopper-render-plugin.ts
+++ b/packages/data-gpu-hopper/src/features/main/ui/render/hopper-render-plugin.ts
@@ -30,7 +30,7 @@ const UNIT_CUBE_BOUNDS: Aabb = { min: [-1, -1, -1], max: [1, 1, 1] };
 
 const colorKey = (color: readonly number[]): string => color.join(",");
 
-// The renderer, combined ON TOP of the headless `FeatureDatabase` at the element
+// The renderer, combined ON TOP of the headless `MainService` at the element
 // level (never inside it, so the simulation stays GPU-free). Draws the game as
 // colored cubes via `pbrIblRender` — with `light.environmentUrl` left null so its
 // IBL bake is procedural (zero network) — reusing the shared unit cube baked by
diff --git a/packages/data-gpu-samples/package.json b/packages/data-gpu-samples/package.json
index 00549167..7132f5fd 100644
--- a/packages/data-gpu-samples/package.json
+++ b/packages/data-gpu-samples/package.json
@@ -1,6 +1,6 @@
 {
   "name": "data-gpu-samples",
-  "version": "0.9.92",
+  "version": "0.9.93",
   "description": "WebGPU samples built on @adobe/data-gpu",
   "type": "module",
   "private": true,
diff --git a/packages/data-gpu/package.json b/packages/data-gpu/package.json
index e10089f1..c5cd1109 100644
--- a/packages/data-gpu/package.json
+++ b/packages/data-gpu/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@adobe/data-gpu",
-  "version": "0.9.92",
+  "version": "0.9.93",
   "description": "Adobe data WebGPU plugins and types for graphics and compute",
   "type": "module",
   "private": false,
diff --git a/packages/data-lit-space-rock-game/package.json b/packages/data-lit-space-rock-game/package.json
index 5cfcd558..249f61df 100644
--- a/packages/data-lit-space-rock-game/package.json
+++ b/packages/data-lit-space-rock-game/package.json
@@ -1,6 +1,6 @@
 {
   "name": "data-lit-space-rock-game",
-  "version": "0.9.92",
+  "version": "0.9.93",
   "description": "Space Rock Game sample - real-time ECS game with Lit and @adobe/data",
   "type": "module",
   "private": true,
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/conformance-case.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/conformance-case.ts
index 44e5a8a5..4426eca4 100644
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/conformance-case.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/data/state/conformance-case.ts
@@ -1,13 +1,13 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Conformance as ConformanceApi } from "@adobe/data/testing";
 import type { State } from "./state.js";
 
-// One spec-owned conformance case: a `data/` transform's `{ before, args, after }`
-// authored as full `State`. Lives in `<transform>.cases.ts` and is shared,
-// unchanged, by the data transform test and the ecs conformance runner
-// (see `ecs/conformance/`).
-export type ConformanceCase<Args> = {
-  readonly name: string;
-  readonly before: State;
-  readonly args: Args;
-  readonly after: State;
-};
+// The conformance case types for this feature — the shared `@adobe/data/testing`
+// machinery with `State` bound once, so a transform authors `Conformance<typeof fn>`
+// and a derivation `Derivation<typeof fn>` (args/input/value read from the
+// function's own signature). This tiny file is the only per-feature conformance
+// type declaration; everything else lives in `@adobe/data/testing`.
+export type Conformance<F extends (...args: never[]) => unknown> =
+  ConformanceApi.Cases<State, F>;
+export type Derivation<F extends (...args: never[]) => unknown> =
+  ConformanceApi.DerivationCases<F>;
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/create-initial.cases.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/create-initial.cases.ts
deleted file mode 100644
index ee84fd41..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/create-initial.cases.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { State } from "./state.js";
-import type { ConformanceCase } from "./conformance-case.js";
-import type { Vec2 } from "@adobe/data/math";
-
-// Spec-owned `{ before, args, after }` cases for `State.createInitial`
-// (args = the play-field bounds), shared with the ecs `newGame` transaction.
-// `createInitial` ignores `before` entirely — it produces a fresh game from the
-// bounds alone — so `before` here is a deliberately dirty state, which also
-// proves `newGame` clears whatever was there. A fresh game centres the ship,
-// resets score/lives/wave, and spawns wave 1 (asteroidsFor(1)=4 large in a
-// clean quadrant ring at radius min(bounds)·0.4), so every `after` is exact.
-const dirty: State = {
-  bounds: [1, 1],
-  ship: { position: [10, 10], velocity: [5, 5], rotation: 1 },
-  bullets: [{ position: [1, 1], velocity: [0, 0], age: 0.5 }],
-  asteroids: [{ position: [9, 9], velocity: [0, 0], size: "small" }],
-  score: 99,
-  lives: 1,
-  wave: 7,
-};
-
-export const cases: readonly ConformanceCase<Vec2>[] = [
-  {
-    name: "starts a fresh 200×200 game: centred ship, first wave, reset counters",
-    before: dirty,
-    args: [200, 200],
-    after: {
-      bounds: [200, 200],
-      ship: { position: [100, 100], velocity: [0, 0], rotation: -Math.PI / 2 },
-      bullets: [],
-      asteroids: [
-        { position: [180, 100], velocity: [0, 60], size: "large" },
-        { position: [100, 180], velocity: [-60, 0], size: "large" },
-        { position: [20, 100], velocity: [0, -60], size: "large" },
-        { position: [100, 20], velocity: [60, 0], size: "large" },
-      ],
-      score: 0,
-      lives: 3,
-      wave: 1,
-    },
-  },
-  {
-    name: "starts a fresh 400×400 game with the ring scaled to the field",
-    before: dirty,
-    args: [400, 400],
-    after: {
-      bounds: [400, 400],
-      ship: { position: [200, 200], velocity: [0, 0], rotation: -Math.PI / 2 },
-      bullets: [],
-      asteroids: [
-        { position: [360, 200], velocity: [0, 60], size: "large" },
-        { position: [200, 360], velocity: [-60, 0], size: "large" },
-        { position: [40, 200], velocity: [0, -60], size: "large" },
-        { position: [200, 40], velocity: [60, 0], size: "large" },
-      ],
-      score: 0,
-      lives: 3,
-      wave: 1,
-    },
-  },
-];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/create-initial.test.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/create-initial.test.ts
deleted file mode 100644
index ceb77eba..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/create-initial.test.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./create-initial.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.createInitial", () => {
-  for (const { name, args, after } of cases) {
-    it(name, () => {
-      expectStateMatches(State.createInitial(args), after);
-    });
-  }
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/create-initial.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/create-initial.ts
index 6d27f0cb..d91e46d7 100644
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/create-initial.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/data/state/create-initial.ts
@@ -1,13 +1,22 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Vec2 } from "@adobe/data/math";
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
 import { Ship } from "../ship/ship.js";
 import { spawnWave } from "./spawn-wave.js";
 
-// A fresh game for a `bounds`-sized field: ship centred, no bullets, three
-// lives, zero score, and the first wave of asteroids spawned in.
-export const createInitial = (bounds: Vec2): State =>
-  spawnWave({
+// A fresh game for a `bounds`-sized field: ship centred, no bullets, three lives,
+// zero score, and the first wave of asteroids spawned in. This is a "new game"
+// TRANSITION — it produces a fresh game from the `bounds` alone and deliberately
+// **ignores** the prior `state` (a reset), which is exactly what the ecs `newGame`
+// transaction it maps to does (it clears whatever was there). The prior state is
+// still the transition's first parameter so it fits the `(state, args) => state`
+// shape the co-located conformance cases derive their `args` type from.
+export const createInitial = (
+  _state: State,
+  { bounds }: { readonly bounds: Vec2 },
+): State => {
+  const fresh: State = {
     bounds,
     ship: Ship.spawn(Vec2.scale(bounds, 0.5)),
     bullets: [],
@@ -15,4 +24,64 @@ export const createInitial = (bounds: Vec2): State =>
     score: 0,
     lives: 3,
     wave: 0,
-  });
+  };
+  // spawnWave returns only { asteroids, wave }; layer it over the fresh game.
+  return { ...fresh, ...spawnWave(fresh) };
+};
+
+// Spec-owned cases, shared with the ecs `newGame` transaction. `createInitial`
+// ignores `before` entirely — it produces a fresh game from the bounds alone — so
+// `before` here is a deliberately dirty state, which also proves `newGame` clears
+// whatever was there. A fresh game centres the ship, resets score/lives/wave, and
+// spawns wave 1 (asteroidsFor(1)=4 large in a clean quadrant ring at radius
+// min(bounds)·0.4), so every `after` is exact.
+const dirty: State = {
+  bounds: [1, 1],
+  ship: { position: [10, 10], velocity: [5, 5], rotation: 1 },
+  bullets: [{ position: [1, 1], velocity: [0, 0], age: 0.5 }],
+  asteroids: [{ position: [9, 9], velocity: [0, 0], size: "small" }],
+  score: 99,
+  lives: 1,
+  wave: 7,
+};
+
+export const cases: Conformance<typeof createInitial> = [
+  {
+    name: "starts a fresh 200×200 game: centred ship, first wave, reset counters",
+    before: dirty,
+    args: { bounds: [200, 200] },
+    after: {
+      bounds: [200, 200],
+      ship: { position: [100, 100], velocity: [0, 0], rotation: -Math.PI / 2 },
+      bullets: [],
+      asteroids: [
+        { position: [180, 100], velocity: [0, 60], size: "large" },
+        { position: [100, 180], velocity: [-60, 0], size: "large" },
+        { position: [20, 100], velocity: [0, -60], size: "large" },
+        { position: [100, 20], velocity: [60, 0], size: "large" },
+      ],
+      score: 0,
+      lives: 3,
+      wave: 1,
+    },
+  },
+  {
+    name: "starts a fresh 400×400 game with the ring scaled to the field",
+    before: dirty,
+    args: { bounds: [400, 400] },
+    after: {
+      bounds: [400, 400],
+      ship: { position: [200, 200], velocity: [0, 0], rotation: -Math.PI / 2 },
+      bullets: [],
+      asteroids: [
+        { position: [360, 200], velocity: [0, 60], size: "large" },
+        { position: [200, 360], velocity: [-60, 0], size: "large" },
+        { position: [40, 200], velocity: [0, -60], size: "large" },
+        { position: [200, 40], velocity: [60, 0], size: "large" },
+      ],
+      score: 0,
+      lives: 3,
+      wave: 1,
+    },
+  },
+];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/expect-state-matches.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/expect-state-matches.ts
deleted file mode 100644
index 3838f595..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/expect-state-matches.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { expect } from "vitest";
-import { equalsUnordered } from "@adobe/data";
-import type { State } from "./state.js";
-
-// Spec-owned tolerant `State` equality, shared by the data/ transform tests
-// (f64, trig epsilon) and the ecs conformance runner (F32 columns, one storage
-// rounding off the f64 oracle). Two orthogonal concerns, kept separate:
-//
-//   precision — normalise every number on both sides onto a shared grid, so a
-//     value that differs only by F32↔f64 storage rounding OR by trig epsilon
-//     (a quadrant `cos`/`sin` yields ~3e-15 where a case authors 0) compares
-//     equal. `Math.fround` collapses the F32 rounding; rounding to 1e-2
-//     (the tolerance the old `toBeCloseTo(_, 2)` used — far under any real
-//     off-by-a-unit bug at this game's magnitudes) collapses the trig epsilon.
-//     `+ 0` normalises `-0` to `0`, since the compare below distinguishes them.
-//   ordering — `equalsUnordered` compares arrays as MULTISETS (archetype
-//     hole-fills and broad-phase order make row order nondeterministic) and is
-//     object key-order independent.
-const quantize = (n: number): number => Math.round(Math.fround(n) * 100) / 100 + 0;
-
-const normalize = (value: unknown): unknown => {
-  if (typeof value === "number") return quantize(value);
-  if (Array.isArray(value)) return value.map(normalize);
-  if (value !== null && typeof value === "object") {
-    return Object.fromEntries(Object.entries(value).map(([key, v]) => [key, normalize(v)]));
-  }
-  return value;
-};
-
-export const expectStateMatches = (actual: State, expected: State): void => {
-  const a = normalize(actual);
-  const b = normalize(expected);
-  expect(
-    equalsUnordered(a, b),
-    `State mismatch:\n  actual   ${JSON.stringify(a)}\n  expected ${JSON.stringify(b)}`,
-  ).toBe(true);
-};
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/fire-bullet.cases.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/fire-bullet.cases.ts
deleted file mode 100644
index 57b03e8a..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/fire-bullet.cases.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { State } from "./state.js";
-import type { ConformanceCase } from "./conformance-case.js";
-
-// Spec-owned `{ before, args, after }` cases for `State.fireBullet` (no args),
-// shared with the ecs `fireBullet` transaction. A bullet leaves the ship's nose
-// (position + facing·Ship.radius=12) inheriting the ship's momentum plus
-// Bullet.speed=400 along the facing. Rotation 0 → facing [1,0]; rotation −π/2 →
-// facing [0,−1] (up). The existing bullets pass through untouched.
-const field = { ...State.create(), bounds: [800, 600] as [number, number] };
-
-export const cases: readonly ConformanceCase<undefined>[] = [
-  {
-    name: "fires from a ship facing +x at rest",
-    before: { ...field, ship: { position: [100, 100], velocity: [0, 0], rotation: 0 }, bullets: [] },
-    args: undefined,
-    after: {
-      ...field,
-      ship: { position: [100, 100], velocity: [0, 0], rotation: 0 },
-      bullets: [{ position: [112, 100], velocity: [400, 0], age: 0 }],
-    },
-  },
-  {
-    name: "inherits the ship's momentum",
-    before: { ...field, ship: { position: [100, 100], velocity: [10, 20], rotation: 0 }, bullets: [] },
-    args: undefined,
-    after: {
-      ...field,
-      ship: { position: [100, 100], velocity: [10, 20], rotation: 0 },
-      bullets: [{ position: [112, 100], velocity: [410, 20], age: 0 }],
-    },
-  },
-  {
-    name: "appends without disturbing bullets already in flight",
-    before: {
-      ...field,
-      ship: { position: [100, 100], velocity: [0, 0], rotation: 0 },
-      bullets: [{ position: [0, 0], velocity: [1, 0], age: 0.2 }],
-    },
-    args: undefined,
-    after: {
-      ...field,
-      ship: { position: [100, 100], velocity: [0, 0], rotation: 0 },
-      bullets: [
-        { position: [0, 0], velocity: [1, 0], age: 0.2 },
-        { position: [112, 100], velocity: [400, 0], age: 0 },
-      ],
-    },
-  },
-  {
-    name: "fires along the ship's facing (rotation −π/2 points up)",
-    before: {
-      ...field,
-      ship: { position: [100, 100], velocity: [0, 0], rotation: -Math.PI / 2 },
-      bullets: [],
-    },
-    args: undefined,
-    after: {
-      ...field,
-      ship: { position: [100, 100], velocity: [0, 0], rotation: -Math.PI / 2 },
-      bullets: [{ position: [100, 88], velocity: [0, -400], age: 0 }],
-    },
-  },
-];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/fire-bullet.test.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/fire-bullet.test.ts
deleted file mode 100644
index a159d27e..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/fire-bullet.test.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./fire-bullet.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.fireBullet", () => {
-  for (const { name, before, after } of cases) {
-    it(name, () => {
-      expectStateMatches(State.fireBullet(before), after);
-    });
-  }
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/fire-bullet.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/fire-bullet.ts
index 302c8f75..67ee98d0 100644
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/fire-bullet.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/data/state/fire-bullet.ts
@@ -1,12 +1,84 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+import { create } from "./create.js";
 import { Bullet } from "../bullet/bullet.js";
 import { Ship } from "../ship/ship.js";
 
 // Fire one bullet from the ship's nose, inheriting its momentum. Composes the
 // ship's muzzle kinematics with the bullet's own speed constant.
-export const fireBullet = <T extends Pick<State, "ship" | "bullets">>(state: T): T => {
+export const fireBullet = (
+  state: Pick<State, "ship" | "bullets">,
+): Pick<State, "bullets"> => {
   const { position, velocity } = Ship.muzzle(state.ship, Bullet.speed);
   const bullet: Bullet = { position, velocity, age: 0 };
-  return { ...state, bullets: [...state.bullets, bullet] };
+  return { bullets: [...state.bullets, bullet] };
 };
+
+// Spec-owned cases, shared with the ecs `fireBullet` transaction. A bullet leaves
+// the ship's nose (position + facing·Ship.radius=12) inheriting the ship's
+// momentum plus Bullet.speed=400 along the facing. Rotation 0 → facing [1,0];
+// rotation −π/2 → facing [0,−1] (up). The existing bullets pass through untouched.
+const field = { ...create(), bounds: [800, 600] as [number, number] };
+
+export const cases: Conformance<typeof fireBullet> = [
+  {
+    name: "fires from a ship facing +x at rest",
+    before: {
+      ...field,
+      ship: { position: [100, 100], velocity: [0, 0], rotation: 0 },
+      bullets: [],
+    },
+    args: undefined,
+    after: {
+      ...field,
+      ship: { position: [100, 100], velocity: [0, 0], rotation: 0 },
+      bullets: [{ position: [112, 100], velocity: [400, 0], age: 0 }],
+    },
+  },
+  {
+    name: "inherits the ship's momentum",
+    before: {
+      ...field,
+      ship: { position: [100, 100], velocity: [10, 20], rotation: 0 },
+      bullets: [],
+    },
+    args: undefined,
+    after: {
+      ...field,
+      ship: { position: [100, 100], velocity: [10, 20], rotation: 0 },
+      bullets: [{ position: [112, 100], velocity: [410, 20], age: 0 }],
+    },
+  },
+  {
+    name: "appends without disturbing bullets already in flight",
+    before: {
+      ...field,
+      ship: { position: [100, 100], velocity: [0, 0], rotation: 0 },
+      bullets: [{ position: [0, 0], velocity: [1, 0], age: 0.2 }],
+    },
+    args: undefined,
+    after: {
+      ...field,
+      ship: { position: [100, 100], velocity: [0, 0], rotation: 0 },
+      bullets: [
+        { position: [0, 0], velocity: [1, 0], age: 0.2 },
+        { position: [112, 100], velocity: [400, 0], age: 0 },
+      ],
+    },
+  },
+  {
+    name: "fires along the ship's facing (rotation −π/2 points up)",
+    before: {
+      ...field,
+      ship: { position: [100, 100], velocity: [0, 0], rotation: -Math.PI / 2 },
+      bullets: [],
+    },
+    args: undefined,
+    after: {
+      ...field,
+      ship: { position: [100, 100], velocity: [0, 0], rotation: -Math.PI / 2 },
+      bullets: [{ position: [100, 88], velocity: [0, -400], age: 0 }],
+    },
+  },
+];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/is-game-over.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/is-game-over.ts
index 18b3d6e8..84665f91 100644
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/is-game-over.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/data/state/is-game-over.ts
@@ -2,4 +2,5 @@
 import type { State } from "./state.js";
 
 // The game is over once every life is spent.
-export const isGameOver = (state: Pick<State, "lives">): boolean => state.lives <= 0;
+export const isGameOver = (state: Pick<State, "lives">): boolean =>
+  state.lives <= 0;
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/public.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/public.ts
index f9d43dd6..86f77fe1 100644
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/public.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/data/state/public.ts
@@ -1,6 +1,7 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 export { create } from "./create.js";
+export { samples } from "./samples.js";
 export { createInitial } from "./create-initial.js";
 export { stepShip } from "./step-ship.js";
 export { fireBullet } from "./fire-bullet.js";
@@ -9,5 +10,6 @@ export { stepAsteroids } from "./step-asteroids.js";
 export { resolveBulletHits } from "./resolve-bullet-hits.js";
 export { resolveShipHits } from "./resolve-ship-hits.js";
 export { spawnWave } from "./spawn-wave.js";
+export { spawnRandomWave } from "./spawn-random-wave.js";
 export { isGameOver } from "./is-game-over.js";
 export { step } from "./step.js";
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-bullet-hits.cases.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-bullet-hits.cases.ts
deleted file mode 100644
index 06ed70ac..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-bullet-hits.cases.ts
+++ /dev/null
@@ -1,195 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { State } from "./state.js";
-import type { ConformanceCase } from "./conformance-case.js";
-
-// Spec-owned `{ before, args, after }` cases for `State.resolveBulletHits`
-// (args = the frame `dt`), shared with the ecs `hitAsteroid` transaction
-// (dispatched once per overlapping bullet by the collision system). Detection is
-// SWEPT: each bullet's path this frame is the segment [position - velocity*dt,
-// position], and it destroys the first asteroid that segment passes through,
-// scores it (large 20 / medium 50 / small 100), and replaces it with its split
-// children (large→2 medium, medium→2 small, small→none). Stationary parents
-// (velocity [0,0]) give children velocity [0,0], so every `after` is exact.
-// Bullet.radius 2, asteroid radii 40/20/10. Every case keeps each bullet
-// overlapping at most one asteroid, so the outcome is order-independent (the ecs
-// broad phase need not match the spec's order). Cases with velocity [0,0]
-// collapse the segment to a point (prev == position), so their expectations are
-// exactly the old point-vs-circle ones; the final case exercises tunnelling.
-const field = { ...State.create(), bounds: [800, 600] as [number, number] };
-
-export const cases: readonly ConformanceCase<number>[] = [
-  {
-    name: "destroys bullet + asteroid, scores, and spawns split children (large → 2 medium)",
-    before: {
-      ...field,
-      bullets: [{ position: [50, 50], velocity: [0, 0], age: 0 }],
-      asteroids: [{ position: [50, 50], velocity: [0, 0], size: "large" }],
-      score: 0,
-    },
-    args: 1 / 60,
-    after: {
-      ...field,
-      bullets: [],
-      asteroids: [
-        { position: [50, 50], velocity: [0, 0], size: "medium" },
-        { position: [50, 50], velocity: [0, 0], size: "medium" },
-      ],
-      score: 20,
-    },
-  },
-  {
-    name: "medium splits into two small",
-    before: {
-      ...field,
-      bullets: [{ position: [50, 50], velocity: [0, 0], age: 0 }],
-      asteroids: [{ position: [50, 50], velocity: [0, 0], size: "medium" }],
-      score: 5,
-    },
-    args: 1 / 60,
-    after: {
-      ...field,
-      bullets: [],
-      asteroids: [
-        { position: [50, 50], velocity: [0, 0], size: "small" },
-        { position: [50, 50], velocity: [0, 0], size: "small" },
-      ],
-      score: 55,
-    },
-  },
-  {
-    name: "the smallest tier is destroyed outright — no children",
-    before: {
-      ...field,
-      bullets: [{ position: [50, 50], velocity: [0, 0], age: 0 }],
-      asteroids: [{ position: [50, 50], velocity: [0, 0], size: "small" }],
-      score: 0,
-    },
-    args: 1 / 60,
-    after: { ...field, bullets: [], asteroids: [], score: 100 },
-  },
-  {
-    name: "a bullet that hits nothing is left untouched",
-    before: {
-      ...field,
-      bullets: [{ position: [10, 10], velocity: [0, 0], age: 0 }],
-      asteroids: [{ position: [500, 500], velocity: [0, 0], size: "large" }],
-      score: 7,
-    },
-    args: 1 / 60,
-    after: {
-      ...field,
-      bullets: [{ position: [10, 10], velocity: [0, 0], age: 0 }],
-      asteroids: [{ position: [500, 500], velocity: [0, 0], size: "large" }],
-      score: 7,
-    },
-  },
-  {
-    name: "only the overlapping asteroid is hit; distant ones remain",
-    before: {
-      ...field,
-      bullets: [{ position: [50, 50], velocity: [0, 0], age: 0 }],
-      asteroids: [
-        { position: [50, 50], velocity: [0, 0], size: "large" },
-        { position: [500, 500], velocity: [0, 0], size: "small" },
-      ],
-      score: 0,
-    },
-    args: 1 / 60,
-    after: {
-      ...field,
-      bullets: [],
-      asteroids: [
-        { position: [50, 50], velocity: [0, 0], size: "medium" },
-        { position: [50, 50], velocity: [0, 0], size: "medium" },
-        { position: [500, 500], velocity: [0, 0], size: "small" },
-      ],
-      score: 20,
-    },
-  },
-  {
-    name: "two bullets each destroy their own asteroid",
-    before: {
-      ...field,
-      bullets: [
-        { position: [50, 50], velocity: [0, 0], age: 0 },
-        { position: [500, 500], velocity: [0, 0], age: 0 },
-      ],
-      asteroids: [
-        { position: [50, 50], velocity: [0, 0], size: "small" },
-        { position: [500, 500], velocity: [0, 0], size: "small" },
-      ],
-      score: 0,
-    },
-    args: 1 / 60,
-    after: { ...field, bullets: [], asteroids: [], score: 200 },
-  },
-  {
-    name: "split children are not hittable by another bullet in the same pass",
-    before: {
-      ...field,
-      bullets: [
-        { position: [50, 50], velocity: [0, 0], age: 0 },
-        { position: [50, 50], velocity: [0, 0], age: 0 },
-      ],
-      asteroids: [{ position: [50, 50], velocity: [0, 0], size: "large" }],
-      score: 0,
-    },
-    args: 1 / 60,
-    after: {
-      ...field,
-      // One bullet destroys the large (→ 2 medium). The second finds no
-      // original target — the large is gone and its children, spawned this
-      // same pass, are not yet hittable — so it survives. (Buggy behaviour let
-      // it hit a fresh medium, chain-annihilating: [medium, small, small], 70.)
-      bullets: [{ position: [50, 50], velocity: [0, 0], age: 0 }],
-      asteroids: [
-        { position: [50, 50], velocity: [0, 0], size: "medium" },
-        { position: [50, 50], velocity: [0, 0], size: "medium" },
-      ],
-      score: 20,
-    },
-  },
-  {
-    name: "boundary: distance exactly equal to the radius sum still overlaps",
-    before: {
-      ...field,
-      bullets: [{ position: [0, 0], velocity: [0, 0], age: 0 }],
-      asteroids: [{ position: [42, 0], velocity: [0, 0], size: "large" }],
-      score: 0,
-    },
-    args: 1 / 60,
-    after: {
-      ...field,
-      bullets: [],
-      asteroids: [
-        { position: [42, 0], velocity: [0, 0], size: "medium" },
-        { position: [42, 0], velocity: [0, 0], size: "medium" },
-      ],
-      score: 20,
-    },
-  },
-  {
-    name: "a fast bullet whose path sweeps through a medium destroys it (no tunnelling)",
-    before: {
-      ...field,
-      // Over dt=1/60 the bullet travels 50px: prev = [0,0] - [-3000,0]/60 = [50,0].
-      // Both endpoints ([50,0] end position, [0,0] current) are 25px from the
-      // medium at [25,0] — outside the 22px (2+20) radius sum, so a point test at
-      // the current position misses. The travelled segment crosses [25,0], so a
-      // swept test hits.
-      bullets: [{ position: [0, 0], velocity: [-3000, 0], age: 0 }],
-      asteroids: [{ position: [25, 0], velocity: [0, 0], size: "medium" }],
-      score: 0,
-    },
-    args: 1 / 60,
-    after: {
-      ...field,
-      bullets: [],
-      asteroids: [
-        { position: [25, 0], velocity: [0, 0], size: "small" },
-        { position: [25, 0], velocity: [0, 0], size: "small" },
-      ],
-      score: 50,
-    },
-  },
-];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-bullet-hits.test.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-bullet-hits.test.ts
deleted file mode 100644
index 56ea84b6..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-bullet-hits.test.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./resolve-bullet-hits.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.resolveBulletHits", () => {
-  for (const { name, before, args, after } of cases) {
-    it(name, () => {
-      expectStateMatches(State.resolveBulletHits(before, args), after);
-    });
-  }
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-bullet-hits.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-bullet-hits.ts
index 4152d9ff..74c5e794 100644
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-bullet-hits.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-bullet-hits.ts
@@ -1,6 +1,8 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Vec2 } from "@adobe/data/math";
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+import { create } from "./create.js";
 import { Bullet } from "../bullet/bullet.js";
 import { Asteroid } from "../asteroid/asteroid.js";
 import { Collision } from "../collision/collision.js";
@@ -15,12 +17,10 @@ import { Collision } from "../collision/collision.js";
 // prev = position - velocity*dt — and test that whole segment against each
 // asteroid. Asteroids are treated as stationary at their current position: they
 // drift ~1px/frame, negligible against the bullet's sweep.
-export const resolveBulletHits = <
-  T extends Pick<State, "bullets" | "asteroids" | "score">,
->(
-  state: T,
+export const resolveBulletHits = (
+  state: Pick<State, "bullets" | "asteroids" | "score">,
   dt: number,
-): T => {
+): Pick<State, "bullets" | "asteroids" | "score"> => {
   const asteroids: Asteroid[] = [...state.asteroids];
   // Children spawned this pass are collected separately and appended only after
   // every bullet has resolved — a bullet may hit an asteroid that existed at the
@@ -29,9 +29,17 @@ export const resolveBulletHits = <
   const survivors: Bullet[] = [];
   let score = state.score;
   for (const bullet of state.bullets) {
-    const prev = Vec2.subtract(bullet.position, Vec2.scale(bullet.velocity, dt));
+    const prev = Vec2.subtract(
+      bullet.position,
+      Vec2.scale(bullet.velocity, dt),
+    );
     const hit = asteroids.findIndex((a) =>
-      Collision.segmentCircleOverlap(prev, bullet.position, a.position, Bullet.radius + Asteroid.radius(a)),
+      Collision.segmentCircleOverlap(
+        prev,
+        bullet.position,
+        a.position,
+        Bullet.radius + Asteroid.radius(a),
+      ),
     );
     if (hit < 0) {
       survivors.push(bullet);
@@ -41,5 +49,195 @@ export const resolveBulletHits = <
     score += Asteroid.score(asteroid);
     spawned.push(...Asteroid.split(asteroid));
   }
-  return { ...state, bullets: survivors, asteroids: [...asteroids, ...spawned], score };
+  return {
+    bullets: survivors,
+    asteroids: [...asteroids, ...spawned],
+    score,
+  };
 };
+
+// Spec-owned cases, shared with the ecs `hitAsteroid` transaction (dispatched
+// once per overlapping bullet by the collision system). Detection is SWEPT: each
+// bullet's path this frame is the segment [position - velocity*dt, position], and
+// it destroys the first asteroid that segment passes through, scores it (large 20
+// / medium 50 / small 100), and replaces it with its split children (large→2
+// medium, medium→2 small, small→none). Stationary parents give children velocity
+// [0,0]. Bullet.radius 2, asteroid radii 40/20/10. Every case keeps each bullet
+// overlapping at most one asteroid, so the outcome is order-independent (the ecs
+// broad phase need not match the spec's order — collections compare as multisets).
+const field = { ...create(), bounds: [800, 600] as [number, number] };
+
+export const cases: Conformance<typeof resolveBulletHits> = [
+  {
+    name: "destroys bullet + asteroid, scores, and spawns split children (large → 2 medium)",
+    before: {
+      ...field,
+      bullets: [{ position: [50, 50], velocity: [0, 0], age: 0 }],
+      asteroids: [{ position: [50, 50], velocity: [0, 0], size: "large" }],
+      score: 0,
+    },
+    args: 1 / 60,
+    after: {
+      ...field,
+      bullets: [],
+      asteroids: [
+        { position: [50, 50], velocity: [0, 0], size: "medium" },
+        { position: [50, 50], velocity: [0, 0], size: "medium" },
+      ],
+      score: 20,
+    },
+  },
+  {
+    name: "medium splits into two small",
+    before: {
+      ...field,
+      bullets: [{ position: [50, 50], velocity: [0, 0], age: 0 }],
+      asteroids: [{ position: [50, 50], velocity: [0, 0], size: "medium" }],
+      score: 5,
+    },
+    args: 1 / 60,
+    after: {
+      ...field,
+      bullets: [],
+      asteroids: [
+        { position: [50, 50], velocity: [0, 0], size: "small" },
+        { position: [50, 50], velocity: [0, 0], size: "small" },
+      ],
+      score: 55,
+    },
+  },
+  {
+    name: "the smallest tier is destroyed outright — no children",
+    before: {
+      ...field,
+      bullets: [{ position: [50, 50], velocity: [0, 0], age: 0 }],
+      asteroids: [{ position: [50, 50], velocity: [0, 0], size: "small" }],
+      score: 0,
+    },
+    args: 1 / 60,
+    after: { ...field, bullets: [], asteroids: [], score: 100 },
+  },
+  {
+    name: "a bullet that hits nothing is left untouched",
+    before: {
+      ...field,
+      bullets: [{ position: [10, 10], velocity: [0, 0], age: 0 }],
+      asteroids: [{ position: [500, 500], velocity: [0, 0], size: "large" }],
+      score: 7,
+    },
+    args: 1 / 60,
+    after: {
+      ...field,
+      bullets: [{ position: [10, 10], velocity: [0, 0], age: 0 }],
+      asteroids: [{ position: [500, 500], velocity: [0, 0], size: "large" }],
+      score: 7,
+    },
+  },
+  {
+    name: "only the overlapping asteroid is hit; distant ones remain",
+    before: {
+      ...field,
+      bullets: [{ position: [50, 50], velocity: [0, 0], age: 0 }],
+      asteroids: [
+        { position: [50, 50], velocity: [0, 0], size: "large" },
+        { position: [500, 500], velocity: [0, 0], size: "small" },
+      ],
+      score: 0,
+    },
+    args: 1 / 60,
+    after: {
+      ...field,
+      bullets: [],
+      asteroids: [
+        { position: [50, 50], velocity: [0, 0], size: "medium" },
+        { position: [50, 50], velocity: [0, 0], size: "medium" },
+        { position: [500, 500], velocity: [0, 0], size: "small" },
+      ],
+      score: 20,
+    },
+  },
+  {
+    name: "two bullets each destroy their own asteroid",
+    before: {
+      ...field,
+      bullets: [
+        { position: [50, 50], velocity: [0, 0], age: 0 },
+        { position: [500, 500], velocity: [0, 0], age: 0 },
+      ],
+      asteroids: [
+        { position: [50, 50], velocity: [0, 0], size: "small" },
+        { position: [500, 500], velocity: [0, 0], size: "small" },
+      ],
+      score: 0,
+    },
+    args: 1 / 60,
+    after: { ...field, bullets: [], asteroids: [], score: 200 },
+  },
+  {
+    name: "split children are not hittable by another bullet in the same pass",
+    before: {
+      ...field,
+      bullets: [
+        { position: [50, 50], velocity: [0, 0], age: 0 },
+        { position: [50, 50], velocity: [0, 0], age: 0 },
+      ],
+      asteroids: [{ position: [50, 50], velocity: [0, 0], size: "large" }],
+      score: 0,
+    },
+    args: 1 / 60,
+    after: {
+      ...field,
+      // One bullet destroys the large (→ 2 medium). The second finds no original
+      // target — the large is gone and its children, spawned this same pass, are
+      // not yet hittable — so it survives.
+      bullets: [{ position: [50, 50], velocity: [0, 0], age: 0 }],
+      asteroids: [
+        { position: [50, 50], velocity: [0, 0], size: "medium" },
+        { position: [50, 50], velocity: [0, 0], size: "medium" },
+      ],
+      score: 20,
+    },
+  },
+  {
+    name: "boundary: distance exactly equal to the radius sum still overlaps",
+    before: {
+      ...field,
+      bullets: [{ position: [0, 0], velocity: [0, 0], age: 0 }],
+      asteroids: [{ position: [42, 0], velocity: [0, 0], size: "large" }],
+      score: 0,
+    },
+    args: 1 / 60,
+    after: {
+      ...field,
+      bullets: [],
+      asteroids: [
+        { position: [42, 0], velocity: [0, 0], size: "medium" },
+        { position: [42, 0], velocity: [0, 0], size: "medium" },
+      ],
+      score: 20,
+    },
+  },
+  {
+    name: "a fast bullet whose path sweeps through a medium destroys it (no tunnelling)",
+    before: {
+      ...field,
+      // Over dt=1/60 the bullet travels 50px: prev = [0,0] - [-3000,0]/60 = [50,0].
+      // Both endpoints are 25px from the medium at [25,0] — outside the 22px radius
+      // sum, so a point test misses. The travelled segment crosses [25,0], so a
+      // swept test hits.
+      bullets: [{ position: [0, 0], velocity: [-3000, 0], age: 0 }],
+      asteroids: [{ position: [25, 0], velocity: [0, 0], size: "medium" }],
+      score: 0,
+    },
+    args: 1 / 60,
+    after: {
+      ...field,
+      bullets: [],
+      asteroids: [
+        { position: [25, 0], velocity: [0, 0], size: "small" },
+        { position: [25, 0], velocity: [0, 0], size: "small" },
+      ],
+      score: 50,
+    },
+  },
+];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-ship-hits.cases.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-ship-hits.cases.ts
deleted file mode 100644
index 8938c25e..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-ship-hits.cases.ts
+++ /dev/null
@@ -1,97 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { State } from "./state.js";
-import type { ConformanceCase } from "./conformance-case.js";
-import { Ship } from "../ship/ship.js";
-
-// Spec-owned `{ before, args, after }` cases for `State.resolveShipHits` (no
-// args), shared with the ecs `loseLife` transaction (dispatched by the
-// collision system only when the ship is actually struck). A touching asteroid
-// costs one life (floored at 0) and respawns the ship at the field centre;
-// otherwise the state is untouched. Field 200×200 → centre [100,100];
-// Ship.radius 12, large asteroid radius 40. Respawn = Ship.spawn(centre) =
-// { [100,100], [0,0], −π/2 }; the asteroids are left in place.
-const field = { ...State.create(), bounds: [200, 200] as [number, number] };
-const respawned = Ship.spawn([100, 100]);
-
-export const cases: readonly ConformanceCase<undefined>[] = [
-  {
-    name: "an asteroid on the ship costs a life and respawns it at centre",
-    before: {
-      ...field,
-      ship: { position: [10, 10], velocity: [5, 5], rotation: 1 },
-      asteroids: [{ position: [10, 10], velocity: [0, 0], size: "large" }],
-      lives: 3,
-    },
-    args: undefined,
-    after: {
-      ...field,
-      ship: respawned,
-      asteroids: [{ position: [10, 10], velocity: [0, 0], size: "large" }],
-      lives: 2,
-    },
-  },
-  {
-    name: "no asteroid touching the ship is a no-op",
-    before: {
-      ...field,
-      ship: { position: [10, 10], velocity: [0, 0], rotation: 0 },
-      asteroids: [{ position: [500, 500], velocity: [0, 0], size: "large" }],
-      lives: 3,
-    },
-    args: undefined,
-    after: {
-      ...field,
-      ship: { position: [10, 10], velocity: [0, 0], rotation: 0 },
-      asteroids: [{ position: [500, 500], velocity: [0, 0], size: "large" }],
-      lives: 3,
-    },
-  },
-  {
-    name: "lives never drop below zero, and the ship still respawns",
-    before: {
-      ...field,
-      ship: { position: [10, 10], velocity: [0, 0], rotation: 0 },
-      asteroids: [{ position: [10, 10], velocity: [0, 0], size: "large" }],
-      lives: 0,
-    },
-    args: undefined,
-    after: {
-      ...field,
-      ship: respawned,
-      asteroids: [{ position: [10, 10], velocity: [0, 0], size: "large" }],
-      lives: 0,
-    },
-  },
-  {
-    name: "boundary: distance exactly equal to the radius sum still counts as a hit",
-    before: {
-      ...field,
-      ship: { position: [0, 0], velocity: [0, 0], rotation: 0 },
-      asteroids: [{ position: [52, 0], velocity: [0, 0], size: "large" }],
-      lives: 3,
-    },
-    args: undefined,
-    after: {
-      ...field,
-      ship: respawned,
-      asteroids: [{ position: [52, 0], velocity: [0, 0], size: "large" }],
-      lives: 2,
-    },
-  },
-  {
-    name: "an empty field is a no-op",
-    before: {
-      ...field,
-      ship: { position: [10, 10], velocity: [0, 0], rotation: 0 },
-      asteroids: [],
-      lives: 3,
-    },
-    args: undefined,
-    after: {
-      ...field,
-      ship: { position: [10, 10], velocity: [0, 0], rotation: 0 },
-      asteroids: [],
-      lives: 3,
-    },
-  },
-];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-ship-hits.test.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-ship-hits.test.ts
deleted file mode 100644
index 8000872a..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-ship-hits.test.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./resolve-ship-hits.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.resolveShipHits", () => {
-  for (const { name, before, after } of cases) {
-    it(name, () => {
-      expectStateMatches(State.resolveShipHits(before), after);
-    });
-  }
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-ship-hits.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-ship-hits.ts
index dd67ecf2..4d97185b 100644
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-ship-hits.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/data/state/resolve-ship-hits.ts
@@ -1,26 +1,122 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Vec2 } from "@adobe/data/math";
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+import { create } from "./create.js";
 import { Ship } from "../ship/ship.js";
 import { Asteroid } from "../asteroid/asteroid.js";
 import { Collision } from "../collision/collision.js";
 
 // If any asteroid is touching the ship, it costs a life and the ship respawns
 // at the centre. No collision leaves the state untouched (idempotent).
-export const resolveShipHits = <
-  T extends Pick<State, "ship" | "asteroids" | "lives" | "bounds">,
->(
-  state: T,
-): T => {
+export const resolveShipHits = (
+  state: Pick<State, "ship" | "asteroids" | "lives" | "bounds">,
+): Pick<State, "ship" | "lives"> => {
   const struck = state.asteroids.some((a) =>
-    Collision.circlesOverlap(state.ship.position, Ship.radius, a.position, Asteroid.radius(a)),
+    Collision.circlesOverlap(
+      state.ship.position,
+      Ship.radius,
+      a.position,
+      Asteroid.radius(a),
+    ),
   );
   if (!struck) {
-    return state;
+    return { ship: state.ship, lives: state.lives };
   }
   return {
-    ...state,
     lives: Math.max(0, state.lives - 1),
     ship: Ship.spawn(Vec2.scale(state.bounds, 0.5)),
   };
 };
+
+// Spec-owned cases, shared with the ecs `loseLife` transaction (dispatched by the
+// collision system only when the ship is actually struck). A touching asteroid
+// costs one life (floored at 0) and respawns the ship at the field centre;
+// otherwise the state is untouched. Field 200×200 → centre [100,100]; Ship.radius
+// 12, large asteroid radius 40. Respawn = Ship.spawn(centre) = { [100,100], [0,0],
+// −π/2 }; the asteroids are left in place.
+const field = { ...create(), bounds: [200, 200] as [number, number] };
+const respawned = Ship.spawn([100, 100]);
+
+export const cases: Conformance<typeof resolveShipHits> = [
+  {
+    name: "an asteroid on the ship costs a life and respawns it at centre",
+    before: {
+      ...field,
+      ship: { position: [10, 10], velocity: [5, 5], rotation: 1 },
+      asteroids: [{ position: [10, 10], velocity: [0, 0], size: "large" }],
+      lives: 3,
+    },
+    args: undefined,
+    after: {
+      ...field,
+      ship: respawned,
+      asteroids: [{ position: [10, 10], velocity: [0, 0], size: "large" }],
+      lives: 2,
+    },
+  },
+  {
+    name: "no asteroid touching the ship is a no-op",
+    before: {
+      ...field,
+      ship: { position: [10, 10], velocity: [0, 0], rotation: 0 },
+      asteroids: [{ position: [500, 500], velocity: [0, 0], size: "large" }],
+      lives: 3,
+    },
+    args: undefined,
+    after: {
+      ...field,
+      ship: { position: [10, 10], velocity: [0, 0], rotation: 0 },
+      asteroids: [{ position: [500, 500], velocity: [0, 0], size: "large" }],
+      lives: 3,
+    },
+  },
+  {
+    name: "lives never drop below zero, and the ship still respawns",
+    before: {
+      ...field,
+      ship: { position: [10, 10], velocity: [0, 0], rotation: 0 },
+      asteroids: [{ position: [10, 10], velocity: [0, 0], size: "large" }],
+      lives: 0,
+    },
+    args: undefined,
+    after: {
+      ...field,
+      ship: respawned,
+      asteroids: [{ position: [10, 10], velocity: [0, 0], size: "large" }],
+      lives: 0,
+    },
+  },
+  {
+    name: "boundary: distance exactly equal to the radius sum still counts as a hit",
+    before: {
+      ...field,
+      ship: { position: [0, 0], velocity: [0, 0], rotation: 0 },
+      asteroids: [{ position: [52, 0], velocity: [0, 0], size: "large" }],
+      lives: 3,
+    },
+    args: undefined,
+    after: {
+      ...field,
+      ship: respawned,
+      asteroids: [{ position: [52, 0], velocity: [0, 0], size: "large" }],
+      lives: 2,
+    },
+  },
+  {
+    name: "an empty field is a no-op",
+    before: {
+      ...field,
+      ship: { position: [10, 10], velocity: [0, 0], rotation: 0 },
+      asteroids: [],
+      lives: 3,
+    },
+    args: undefined,
+    after: {
+      ...field,
+      ship: { position: [10, 10], velocity: [0, 0], rotation: 0 },
+      asteroids: [],
+      lives: 3,
+    },
+  },
+];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/samples.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/samples.ts
new file mode 100644
index 00000000..203bd44c
--- /dev/null
+++ b/packages/data-lit-space-rock-game/src/features/main/data/state/samples.ts
@@ -0,0 +1,46 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+
+// Representative full states for the projection round-trip (toState ∘ fromState ≡
+// identity). Varied ships / bullets / asteroids + non-default counters exercise the
+// whole ecs↔State map, including a multiset case (identical same-size asteroids).
+export const samples: readonly State[] = [
+  {
+    bounds: [800, 600],
+    ship: { position: [400, 300], velocity: [12, -7], rotation: 1.25 },
+    bullets: [
+      { position: [100, 100], velocity: [400, 0], age: 0.1 },
+      { position: [220, 340], velocity: [-100, 200], age: 0.9 },
+    ],
+    asteroids: [
+      { position: [50, 60], velocity: [10, 20], size: "large" },
+      { position: [700, 80], velocity: [-30, 5], size: "medium" },
+      { position: [640, 540], velocity: [0, -15], size: "small" },
+    ],
+    score: 240,
+    lives: 2,
+    wave: 5,
+  },
+  {
+    bounds: [320, 240],
+    ship: { position: [160, 120], velocity: [0, 0], rotation: -Math.PI / 2 },
+    bullets: [],
+    asteroids: [],
+    score: 0,
+    lives: 3,
+    wave: 0,
+  },
+  {
+    bounds: [500, 500],
+    ship: { position: [250, 250], velocity: [0, 0], rotation: 0 },
+    bullets: [],
+    asteroids: [
+      { position: [250, 250], velocity: [0, 0], size: "medium" },
+      { position: [250, 250], velocity: [0, 0], size: "medium" },
+      { position: [250, 250], velocity: [0, 0], size: "medium" },
+    ],
+    score: 90,
+    lives: 1,
+    wave: 3,
+  },
+];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/spawn-random-wave.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/spawn-random-wave.ts
new file mode 100644
index 00000000..b2ec52dd
--- /dev/null
+++ b/packages/data-lit-space-rock-game/src/features/main/data/state/spawn-random-wave.ts
@@ -0,0 +1,99 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Vec2 } from "@adobe/data/math";
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+import { create } from "./create.js";
+import type { Asteroid } from "../asteroid/asteroid.js";
+import { Size } from "../size/size.js";
+import { Motion } from "../motion/motion.js";
+import { RandomService } from "../../services/random-service/random-service.js";
+
+// Base drift speed; each rock's actual speed is jittered around it.
+const waveSpeed = 60;
+// Each cleared wave spawns this many more rocks than the last.
+const asteroidsFor = (wave: number): number => 3 + wave;
+
+/**
+ * The randomized sibling of {@link spawnWave} (the todo `createRandomTodo` ↔
+ * `createTodo` split): it takes an **injected `random` service** — keyed by the
+ * service name minus its `-service` suffix (`state.md`) — so the per-asteroid
+ * variation cannot be computed from `state` alone. Still **deterministic given
+ * the service**: inject a fixed sequence and the wave is fixed, which is how it
+ * is unit-tested and how the ECS `spawnRandomWave` transaction conforms to it.
+ *
+ * The ring layout (angles/positions) matches `spawnWave` exactly; only each
+ * rock's drift SPEED is scaled — `waveSpeed · (0.5 + random.next())`, i.e.
+ * `[0.5×, 1.5×)` — drawing one value per asteroid in ring order. A no-op while
+ * asteroids remain (draws nothing, returns the same reference).
+ */
+export const spawnRandomWave = (
+  state: Pick<State, "asteroids" | "wave" | "bounds">,
+  { random }: { random: RandomService },
+): Pick<State, "asteroids" | "wave"> => {
+  if (state.asteroids.length > 0) {
+    return { asteroids: state.asteroids, wave: state.wave };
+  }
+  const wave = state.wave + 1;
+  const count = asteroidsFor(wave);
+  const center = Vec2.scale(state.bounds, 0.5);
+  const ring = Math.min(state.bounds[0], state.bounds[1]) * 0.4;
+  const asteroids: Asteroid[] = [];
+  for (let i = 0; i < count; i++) {
+    const angle = (Math.PI * 2 * i) / count;
+    const outward = Motion.rotate([1, 0], angle);
+    const tangent = Motion.rotate([1, 0], angle + Math.PI / 2);
+    const speed = waveSpeed * (0.5 + random.next());
+    asteroids.push({
+      position: Vec2.add(center, Vec2.scale(outward, ring)),
+      velocity: Vec2.scale(tangent, speed),
+      size: Size.largest,
+    });
+  }
+  return { wave, asteroids };
+};
+
+// Spec-owned cases, shared with the ecs `spawnRandomWave` transaction. Each case
+// injects its own fixed random sequence and authors `after` against it — the same
+// double flows to both sides, so the randomized velocities are exact and the two
+// sides agree: conformance stays honest even though the transition draws
+// randomness. `next` is a value-returning read (not a fire-and-forget side
+// effect), so it is NOT declared in `effects`.
+//
+// The injected sequence has length 4 and a spawn draws exactly 4 values (one per
+// asteroid at `asteroidsFor(1) = 4`). Field 200×200 → centre [100,100], ring
+// radius 80; positions match `spawnWave`, only drift SPEED is jittered:
+// `speed(i) = 60·(0.5 + sequence[i])` → [30, 60, 45, 75] in ring order.
+const field = { ...create(), bounds: [200, 200] as [number, number] };
+const randoms = [0, 0.5, 0.25, 0.75];
+
+export const cases: Conformance<typeof spawnRandomWave> = [
+  {
+    name: "spawns a randomized wave (jittered drift speeds) when the field is clear",
+    before: { ...field, asteroids: [], wave: 0 },
+    args: { random: RandomService.createFake(randoms) },
+    after: {
+      ...field,
+      wave: 1,
+      asteroids: [
+        { position: [180, 100], velocity: [0, 30], size: "large" },
+        { position: [100, 180], velocity: [-60, 0], size: "large" },
+        { position: [20, 100], velocity: [0, -45], size: "large" },
+        { position: [100, 20], velocity: [75, 0], size: "large" },
+      ],
+    },
+  },
+  {
+    name: "does nothing while asteroids still remain",
+    before: {
+      ...field,
+      wave: 1,
+      asteroids: [{ position: [10, 10], velocity: [0, 0], size: "large" }],
+    },
+    args: { random: RandomService.createFake(randoms) },
+    after: {
+      ...field,
+      wave: 1,
+      asteroids: [{ position: [10, 10], velocity: [0, 0], size: "large" }],
+    },
+  },
+];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/spawn-wave.cases.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/spawn-wave.cases.ts
deleted file mode 100644
index 7af04f33..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/spawn-wave.cases.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { State } from "./state.js";
-import type { ConformanceCase } from "./conformance-case.js";
-
-// Spec-owned `{ before, args, after }` cases for `State.spawnWave` (no args),
-// shared with the ecs `spawnWave` transaction. When the field is clear it bumps
-// the wave and spawns a ring of large asteroids around the centre, each
-// drifting tangentially at 60px/s; while asteroids remain it is a no-op. Field
-// 200×200 → centre [100,100], ring radius 80. From wave 0 the count is
-// asteroidsFor(1)=4, so the ring lands on the four clean quadrant angles and
-// every `after` position/velocity is exact.
-const field = { ...State.create(), bounds: [200, 200] as [number, number] };
-
-export const cases: readonly ConformanceCase<undefined>[] = [
-  {
-    name: "spawns the next wave of large asteroids when the field is clear",
-    before: { ...field, asteroids: [], wave: 0 },
-    args: undefined,
-    after: {
-      ...field,
-      wave: 1,
-      asteroids: [
-        { position: [180, 100], velocity: [0, 60], size: "large" },
-        { position: [100, 180], velocity: [-60, 0], size: "large" },
-        { position: [20, 100], velocity: [0, -60], size: "large" },
-        { position: [100, 20], velocity: [60, 0], size: "large" },
-      ],
-    },
-  },
-  {
-    name: "does nothing while asteroids still remain",
-    before: {
-      ...field,
-      wave: 1,
-      asteroids: [{ position: [10, 10], velocity: [0, 0], size: "large" }],
-    },
-    args: undefined,
-    after: {
-      ...field,
-      wave: 1,
-      asteroids: [{ position: [10, 10], velocity: [0, 0], size: "large" }],
-    },
-  },
-];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/spawn-wave.test.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/spawn-wave.test.ts
deleted file mode 100644
index da50d795..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/spawn-wave.test.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it, expect } from "vitest";
-import { Vec2 } from "@adobe/data/math";
-import { State } from "./state.js";
-import { cases } from "./spawn-wave.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.spawnWave", () => {
-  for (const { name, before, after } of cases) {
-    it(name, () => {
-      expectStateMatches(State.spawnWave(before), after);
-    });
-  }
-
-  it("grows the wave each time the field is cleared", () => {
-    const bounds: Vec2 = [200, 200];
-    const first = State.spawnWave({ ...State.create(), bounds, wave: 0 });
-    const second = State.spawnWave({ ...State.create(), bounds, wave: 1 });
-    expect(second.asteroids.length).toBeGreaterThan(first.asteroids.length);
-  });
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/spawn-wave.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/spawn-wave.ts
index 5cc581a0..4ed2a018 100644
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/spawn-wave.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/data/state/spawn-wave.ts
@@ -1,6 +1,8 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Vec2 } from "@adobe/data/math";
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+import { create } from "./create.js";
 import type { Asteroid } from "../asteroid/asteroid.js";
 import { Size } from "../size/size.js";
 import { Motion } from "../motion/motion.js";
@@ -12,12 +14,15 @@ const asteroidsFor = (wave: number): number => 3 + wave;
 
 // When the field is clear, advance to the next wave: spawn a ring of large
 // asteroids around the centre (clear of the ship's spawn), each drifting
-// tangentially. Deterministic — the ECS layer may randomise; the spec does not.
-export const spawnWave = <T extends Pick<State, "asteroids" | "wave" | "bounds">>(
-  state: T,
-): T => {
+// tangentially at a fixed speed. Deterministic — this seeds the FIRST wave
+// (`createInitial`, so a fresh game always starts from the same fair layout).
+// The randomized sibling `spawnRandomWave` injects a `random` service for the
+// varied refill waves the tick loop spawns.
+export const spawnWave = (
+  state: Pick<State, "asteroids" | "wave" | "bounds">,
+): Pick<State, "asteroids" | "wave"> => {
   if (state.asteroids.length > 0) {
-    return state;
+    return { asteroids: state.asteroids, wave: state.wave };
   }
   const wave = state.wave + 1;
   const count = asteroidsFor(wave);
@@ -34,5 +39,45 @@ export const spawnWave = <T extends Pick<State, "asteroids" | "wave" | "bounds">
       size: Size.largest,
     });
   }
-  return { ...state, wave, asteroids };
+  return { wave, asteroids };
 };
+
+// Spec-owned cases for the deterministic `spawnWave` (no args) — the fixed FIRST
+// wave `createInitial` seeds (its randomized refill sibling is `spawnRandomWave`).
+// When the field is clear it bumps the wave and spawns a ring of large asteroids
+// around the centre, each drifting tangentially at 60px/s; while asteroids remain
+// it is a no-op. Field 200×200 → centre [100,100], ring radius 80. From wave 0 the
+// count is asteroidsFor(1)=4, so the ring lands on the four clean quadrant angles.
+const field = { ...create(), bounds: [200, 200] as [number, number] };
+
+export const cases: Conformance<typeof spawnWave> = [
+  {
+    name: "spawns the next wave of large asteroids when the field is clear",
+    before: { ...field, asteroids: [], wave: 0 },
+    args: undefined,
+    after: {
+      ...field,
+      wave: 1,
+      asteroids: [
+        { position: [180, 100], velocity: [0, 60], size: "large" },
+        { position: [100, 180], velocity: [-60, 0], size: "large" },
+        { position: [20, 100], velocity: [0, -60], size: "large" },
+        { position: [100, 20], velocity: [60, 0], size: "large" },
+      ],
+    },
+  },
+  {
+    name: "does nothing while asteroids still remain",
+    before: {
+      ...field,
+      wave: 1,
+      asteroids: [{ position: [10, 10], velocity: [0, 0], size: "large" }],
+    },
+    args: undefined,
+    after: {
+      ...field,
+      wave: 1,
+      asteroids: [{ position: [10, 10], velocity: [0, 0], size: "large" }],
+    },
+  },
+];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/spec.test.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/spec.test.ts
new file mode 100644
index 00000000..047b585d
--- /dev/null
+++ b/packages/data-lit-space-rock-game/src/features/main/data/state/spec.test.ts
@@ -0,0 +1,14 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Conformance } from "@adobe/data/testing";
+import { State } from "./state.js";
+import { transitions } from "./transitions.js";
+
+// The single pure-spec test for every transform AND derivation in this folder.
+// `runSpec` auto-discovers each module in `transitions` that exports `cases`,
+// requires it to export exactly its function plus `cases`, and dispatches on case
+// shape. Each case's `before`/`input` is a delta over `State.create()`.
+Conformance.runSpec({
+  state: State,
+  transitions,
+  match: { unordered: new Set(["bullets", "asteroids"]) },
+});
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/step-asteroids.cases.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/step-asteroids.cases.ts
deleted file mode 100644
index 004ee1e8..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/step-asteroids.cases.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { State } from "./state.js";
-import type { ConformanceCase } from "./conformance-case.js";
-import { Size } from "../size/size.js";
-
-// Spec-owned `{ before, args, after }` cases for `State.stepAsteroids`
-// (args = dt). Shared with the ecs system conformance (the asteroid half of
-// `movement` reproduces this). The 100×100 field forces wrap. Asteroids drift
-// by constant velocity, so `after` is exact.
-const field = { ...State.create(), bounds: [100, 100] as [number, number] };
-
-export const cases: readonly ConformanceCase<number>[] = [
-  {
-    name: "drifts an asteroid by its velocity",
-    before: { ...field, asteroids: [{ position: [10, 10], velocity: [30, 0], size: Size.largest }] },
-    args: 1,
-    after: { ...field, asteroids: [{ position: [40, 10], velocity: [30, 0], size: Size.largest }] },
-  },
-  {
-    name: "wraps an asteroid around the toroidal field",
-    before: { ...field, asteroids: [{ position: [80, 80], velocity: [50, 50], size: Size.largest }] },
-    args: 1,
-    after: { ...field, asteroids: [{ position: [30, 30], velocity: [50, 50], size: Size.largest }] },
-  },
-  {
-    name: "wraps negatively across the left edge",
-    before: { ...field, asteroids: [{ position: [10, 10], velocity: [-50, 0], size: "medium" }] },
-    args: 1,
-    after: { ...field, asteroids: [{ position: [60, 10], velocity: [-50, 0], size: "medium" }] },
-  },
-  {
-    name: "advances several asteroids of different sizes independently",
-    before: {
-      ...field,
-      asteroids: [
-        { position: [10, 10], velocity: [10, 0], size: "large" },
-        { position: [20, 20], velocity: [0, 10], size: "small" },
-      ],
-    },
-    args: 1,
-    after: {
-      ...field,
-      asteroids: [
-        { position: [20, 10], velocity: [10, 0], size: "large" },
-        { position: [20, 30], velocity: [0, 10], size: "small" },
-      ],
-    },
-  },
-  {
-    name: "an empty field stays empty",
-    before: { ...field, asteroids: [] },
-    args: 1,
-    after: { ...field, asteroids: [] },
-  },
-];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/step-asteroids.test.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/step-asteroids.test.ts
deleted file mode 100644
index e09d845e..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/step-asteroids.test.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./step-asteroids.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.stepAsteroids", () => {
-  for (const { name, before, args, after } of cases) {
-    it(name, () => {
-      expectStateMatches(State.stepAsteroids(before, args), after);
-    });
-  }
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/step-asteroids.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/step-asteroids.ts
index e98de906..a0ea1e60 100644
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/step-asteroids.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/data/state/step-asteroids.ts
@@ -1,15 +1,97 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+import { create } from "./create.js";
 import { Motion } from "../motion/motion.js";
+import { Size } from "../size/size.js";
 
 // Drift every asteroid one tick by its constant velocity, wrapping at edges.
-export const stepAsteroids = <T extends Pick<State, "asteroids" | "bounds">>(
-  state: T,
+export const stepAsteroids = (
+  state: Pick<State, "asteroids" | "bounds">,
   dt: number,
-): T => {
+): Pick<State, "asteroids"> => {
   const asteroids = state.asteroids.map((a) => ({
     ...a,
-    position: Motion.wrap(Motion.advance(a.position, a.velocity, dt), state.bounds),
+    position: Motion.wrap(
+      Motion.advance(a.position, a.velocity, dt),
+      state.bounds,
+    ),
   }));
-  return { ...state, asteroids };
+  return { asteroids };
 };
+
+// Spec-owned cases, shared with the ecs system conformance (the asteroid half of
+// `movement` reproduces this). The 100×100 field forces wrap. Asteroids drift by
+// constant velocity, so `after` is exact.
+const field = { ...create(), bounds: [100, 100] as [number, number] };
+
+export const cases: Conformance<typeof stepAsteroids> = [
+  {
+    name: "drifts an asteroid by its velocity",
+    before: {
+      ...field,
+      asteroids: [
+        { position: [10, 10], velocity: [30, 0], size: Size.largest },
+      ],
+    },
+    args: 1,
+    after: {
+      ...field,
+      asteroids: [
+        { position: [40, 10], velocity: [30, 0], size: Size.largest },
+      ],
+    },
+  },
+  {
+    name: "wraps an asteroid around the toroidal field",
+    before: {
+      ...field,
+      asteroids: [
+        { position: [80, 80], velocity: [50, 50], size: Size.largest },
+      ],
+    },
+    args: 1,
+    after: {
+      ...field,
+      asteroids: [
+        { position: [30, 30], velocity: [50, 50], size: Size.largest },
+      ],
+    },
+  },
+  {
+    name: "wraps negatively across the left edge",
+    before: {
+      ...field,
+      asteroids: [{ position: [10, 10], velocity: [-50, 0], size: "medium" }],
+    },
+    args: 1,
+    after: {
+      ...field,
+      asteroids: [{ position: [60, 10], velocity: [-50, 0], size: "medium" }],
+    },
+  },
+  {
+    name: "advances several asteroids of different sizes independently",
+    before: {
+      ...field,
+      asteroids: [
+        { position: [10, 10], velocity: [10, 0], size: "large" },
+        { position: [20, 20], velocity: [0, 10], size: "small" },
+      ],
+    },
+    args: 1,
+    after: {
+      ...field,
+      asteroids: [
+        { position: [20, 10], velocity: [10, 0], size: "large" },
+        { position: [20, 30], velocity: [0, 10], size: "small" },
+      ],
+    },
+  },
+  {
+    name: "an empty field stays empty",
+    before: { ...field, asteroids: [] },
+    args: 1,
+    after: { ...field, asteroids: [] },
+  },
+];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/step-bullets.cases.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/step-bullets.cases.ts
deleted file mode 100644
index a9931679..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/step-bullets.cases.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { State } from "./state.js";
-import type { ConformanceCase } from "./conformance-case.js";
-import { Bullet } from "../bullet/bullet.js";
-
-// Spec-owned `{ before, args, after }` cases for `State.stepBullets` (args = dt).
-// Shared with the ecs system conformance (the `lifetime` advance/age/expire
-// path reproduces this). `Bullet.lifetime` is 1.2; the 100×100 field forces
-// wrap. Covers move+age, wrap (both directions), expiry on the boundary,
-// survival just under it, mixed drop, and the empty list.
-const field = { ...State.create(), bounds: [100, 100] as [number, number] };
-
-export const cases: readonly ConformanceCase<number>[] = [
-  {
-    name: "moves and ages a live bullet",
-    before: { ...field, bullets: [{ position: [10, 50], velocity: [100, 0], age: 0 }] },
-    args: 0.1,
-    after: { ...field, bullets: [{ position: [20, 50], velocity: [100, 0], age: 0.1 }] },
-  },
-  {
-    name: "wraps a bullet across the right edge",
-    before: { ...field, bullets: [{ position: [95, 50], velocity: [100, 0], age: 0 }] },
-    args: 0.1,
-    after: { ...field, bullets: [{ position: [5, 50], velocity: [100, 0], age: 0.1 }] },
-  },
-  {
-    name: "drops a bullet that expires this tick (age + dt ≥ lifetime)",
-    before: { ...field, bullets: [{ position: [10, 50], velocity: [100, 0], age: Bullet.lifetime }] },
-    args: 0.1,
-    after: { ...field, bullets: [] },
-  },
-  {
-    name: "keeps and ages a bullet still under its lifetime",
-    before: { ...field, bullets: [{ position: [10, 50], velocity: [0, 0], age: 1.0 }] },
-    args: 0.1,
-    after: { ...field, bullets: [{ position: [10, 50], velocity: [0, 0], age: 1.1 }] },
-  },
-  {
-    name: "advances survivors and drops only the expired bullet",
-    before: {
-      ...field,
-      bullets: [
-        { position: [10, 50], velocity: [100, 0], age: 0 },
-        { position: [10, 60], velocity: [100, 0], age: Bullet.lifetime },
-      ],
-    },
-    args: 0.1,
-    after: { ...field, bullets: [{ position: [20, 50], velocity: [100, 0], age: 0.1 }] },
-  },
-  {
-    name: "an empty list stays empty",
-    before: { ...field, bullets: [] },
-    args: 0.1,
-    after: { ...field, bullets: [] },
-  },
-];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/step-bullets.test.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/step-bullets.test.ts
deleted file mode 100644
index c812fc4b..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/step-bullets.test.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./step-bullets.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.stepBullets", () => {
-  for (const { name, before, args, after } of cases) {
-    it(name, () => {
-      expectStateMatches(State.stepBullets(before, args), after);
-    });
-  }
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/step-bullets.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/step-bullets.ts
index 203cb08b..6f33fd82 100644
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/step-bullets.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/data/state/step-bullets.ts
@@ -1,20 +1,102 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+import { create } from "./create.js";
 import { Bullet } from "../bullet/bullet.js";
 import { Motion } from "../motion/motion.js";
 
 // Advance every bullet one tick: drop the ones that expire this tick, and move
 // + age + wrap the survivors.
-export const stepBullets = <T extends Pick<State, "bullets" | "bounds">>(
-  state: T,
+export const stepBullets = (
+  state: Pick<State, "bullets" | "bounds">,
   dt: number,
-): T => {
+): Pick<State, "bullets"> => {
   const bullets = state.bullets
     .filter((b) => !Bullet.isExpired(b.age, dt))
     .map((b) => ({
       ...b,
-      position: Motion.wrap(Motion.advance(b.position, b.velocity, dt), state.bounds),
+      position: Motion.wrap(
+        Motion.advance(b.position, b.velocity, dt),
+        state.bounds,
+      ),
       age: b.age + dt,
     }));
-  return { ...state, bullets };
+  return { bullets };
 };
+
+// Spec-owned cases, shared with the ecs system conformance (the `lifetime`
+// advance/age/expire path reproduces this). `Bullet.lifetime` is 1.2; the 100×100
+// field forces wrap. Covers move+age, wrap, expiry on the boundary, survival just
+// under it, mixed drop, and the empty list.
+const field = { ...create(), bounds: [100, 100] as [number, number] };
+
+export const cases: Conformance<typeof stepBullets> = [
+  {
+    name: "moves and ages a live bullet",
+    before: {
+      ...field,
+      bullets: [{ position: [10, 50], velocity: [100, 0], age: 0 }],
+    },
+    args: 0.1,
+    after: {
+      ...field,
+      bullets: [{ position: [20, 50], velocity: [100, 0], age: 0.1 }],
+    },
+  },
+  {
+    name: "wraps a bullet across the right edge",
+    before: {
+      ...field,
+      bullets: [{ position: [95, 50], velocity: [100, 0], age: 0 }],
+    },
+    args: 0.1,
+    after: {
+      ...field,
+      bullets: [{ position: [5, 50], velocity: [100, 0], age: 0.1 }],
+    },
+  },
+  {
+    name: "drops a bullet that expires this tick (age + dt ≥ lifetime)",
+    before: {
+      ...field,
+      bullets: [
+        { position: [10, 50], velocity: [100, 0], age: Bullet.lifetime },
+      ],
+    },
+    args: 0.1,
+    after: { ...field, bullets: [] },
+  },
+  {
+    name: "keeps and ages a bullet still under its lifetime",
+    before: {
+      ...field,
+      bullets: [{ position: [10, 50], velocity: [0, 0], age: 1.0 }],
+    },
+    args: 0.1,
+    after: {
+      ...field,
+      bullets: [{ position: [10, 50], velocity: [0, 0], age: 1.1 }],
+    },
+  },
+  {
+    name: "advances survivors and drops only the expired bullet",
+    before: {
+      ...field,
+      bullets: [
+        { position: [10, 50], velocity: [100, 0], age: 0 },
+        { position: [10, 60], velocity: [100, 0], age: Bullet.lifetime },
+      ],
+    },
+    args: 0.1,
+    after: {
+      ...field,
+      bullets: [{ position: [20, 50], velocity: [100, 0], age: 0.1 }],
+    },
+  },
+  {
+    name: "an empty list stays empty",
+    before: { ...field, bullets: [] },
+    args: 0.1,
+    after: { ...field, bullets: [] },
+  },
+];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/step-ship.cases.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/step-ship.cases.ts
deleted file mode 100644
index cea40be8..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/step-ship.cases.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { State } from "./state.js";
-import type { ConformanceCase } from "./conformance-case.js";
-import type { Input } from "../input/input.js";
-
-// Spec-owned `{ before, args, after }` cases for `State.stepShip`, shared with
-// the ecs system conformance (the `control` + ship half of `movement` reproduce
-// this). Full-`State` before/after; the generic-slice signature lets them flow
-// through. Geometry is chosen so every `after` is exact (turnRate 3,
-// thrustAccel 200, field 100×100 to force wrap).
-type Args = { readonly dt: number; readonly input: Input };
-const field = { ...State.create(), bounds: [100, 100] as [number, number] };
-const idle: Input = { turn: 0, thrust: false, fire: false };
-
-export const cases: readonly ConformanceCase<Args>[] = [
-  {
-    name: "turns right by a positive turn input",
-    before: { ...field, ship: { position: [50, 50], velocity: [0, 0], rotation: 0 } },
-    args: { dt: 1, input: { turn: 1, thrust: false, fire: false } },
-    after: { ...field, ship: { position: [50, 50], velocity: [0, 0], rotation: 3 } },
-  },
-  {
-    name: "turns left by a negative turn input",
-    before: { ...field, ship: { position: [50, 50], velocity: [0, 0], rotation: 0 } },
-    args: { dt: 1, input: { turn: -1, thrust: false, fire: false } },
-    after: { ...field, ship: { position: [50, 50], velocity: [0, 0], rotation: -3 } },
-  },
-  {
-    name: "no turn holds rotation and coasts by velocity",
-    before: { ...field, ship: { position: [50, 50], velocity: [10, 0], rotation: 0.7 } },
-    args: { dt: 1, input: idle },
-    after: { ...field, ship: { position: [60, 50], velocity: [10, 0], rotation: 0.7 } },
-  },
-  {
-    name: "thrusts along the facing, then coasts by the new velocity",
-    before: { ...field, ship: { position: [50, 50], velocity: [0, 0], rotation: 0 } },
-    args: { dt: 0.1, input: { turn: 0, thrust: true, fire: false } },
-    after: { ...field, ship: { position: [52, 50], velocity: [20, 0], rotation: 0 } },
-  },
-  {
-    name: "wraps across the right edge",
-    before: { ...field, ship: { position: [95, 50], velocity: [100, 0], rotation: 0 } },
-    args: { dt: 0.1, input: idle },
-    after: { ...field, ship: { position: [5, 50], velocity: [100, 0], rotation: 0 } },
-  },
-  {
-    name: "wraps across the top edge (negative wrap)",
-    before: { ...field, ship: { position: [5, 5], velocity: [0, -100], rotation: 0 } },
-    args: { dt: 0.1, input: idle },
-    after: { ...field, ship: { position: [5, 95], velocity: [0, -100], rotation: 0 } },
-  },
-  {
-    // Turn then thrust: −3 turns to 0, and thrust must use the NEW rotation 0
-    // (facing +x → velocity [200,0]); using the old −3 would point elsewhere.
-    name: "turn composes before thrust — thrust uses the post-turn rotation",
-    before: { ...field, ship: { position: [50, 50], velocity: [0, 0], rotation: -3 } },
-    args: { dt: 1, input: { turn: 1, thrust: true, fire: false } },
-    after: { ...field, ship: { position: [50, 50], velocity: [200, 0], rotation: 0 } },
-  },
-];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/step-ship.test.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/step-ship.test.ts
deleted file mode 100644
index e0882923..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/step-ship.test.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./step-ship.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-// The spec test runs the pure transform over the SHARED `{ before, args, after }`
-// cases (the same array the ecs system conformance imports). Keeping the
-// expectations here means "substitute the implementation, reuse the truth".
-describe("State.stepShip", () => {
-  for (const { name, before, args, after } of cases) {
-    it(name, () => {
-      expectStateMatches(State.stepShip(before, args.dt, args.input), after);
-    });
-  }
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/step-ship.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/step-ship.ts
index 147ed58d..1a2ab98a 100644
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/step-ship.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/data/state/step-ship.ts
@@ -1,19 +1,122 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+import { create } from "./create.js";
 import { Ship } from "../ship/ship.js";
 import { Input } from "../input/input.js";
 import { Motion } from "../motion/motion.js";
 
-// Advance the ship one tick: turn, optionally thrust, then coast by its
-// velocity and wrap at the screen edges.
-export const stepShip = <T extends Pick<State, "ship" | "bounds">>(
-  state: T,
-  dt: number,
-  input: Input,
-): T => {
+// Advance the ship one tick: turn, optionally thrust, then coast by its velocity
+// and wrap at the screen edges. `dt` and `input` are bundled into one args object
+// (second parameter) so the co-located conformance cases derive their `args` type
+// straight from this signature (`Conformance<typeof stepShip>`).
+export const stepShip = (
+  state: Pick<State, "ship" | "bounds">,
+  { dt, input }: { readonly dt: number; readonly input: Input },
+): Pick<State, "ship"> => {
   const { ship } = state;
   const rotation = Ship.turn(ship.rotation, input.turn, dt);
-  const velocity = input.thrust ? Ship.thrust(ship.velocity, rotation, dt) : ship.velocity;
-  const position = Motion.wrap(Motion.advance(ship.position, velocity, dt), state.bounds);
-  return { ...state, ship: { position, velocity, rotation } };
+  const velocity = input.thrust
+    ? Ship.thrust(ship.velocity, rotation, dt)
+    : ship.velocity;
+  const position = Motion.wrap(
+    Motion.advance(ship.position, velocity, dt),
+    state.bounds,
+  );
+  return { ship: { position, velocity, rotation } };
 };
+
+// Spec-owned cases, shared with the ecs system conformance (the `control` + ship
+// half of `movement` reproduce this). Geometry chosen so every `after` is exact
+// (turnRate 3, thrustAccel 200, field 100×100 to force wrap).
+const field = { ...create(), bounds: [100, 100] as [number, number] };
+const idle: Input = { turn: 0, thrust: false, fire: false };
+
+export const cases: Conformance<typeof stepShip> = [
+  {
+    name: "turns right by a positive turn input",
+    before: {
+      ...field,
+      ship: { position: [50, 50], velocity: [0, 0], rotation: 0 },
+    },
+    args: { dt: 1, input: { turn: 1, thrust: false, fire: false } },
+    after: {
+      ...field,
+      ship: { position: [50, 50], velocity: [0, 0], rotation: 3 },
+    },
+  },
+  {
+    name: "turns left by a negative turn input",
+    before: {
+      ...field,
+      ship: { position: [50, 50], velocity: [0, 0], rotation: 0 },
+    },
+    args: { dt: 1, input: { turn: -1, thrust: false, fire: false } },
+    after: {
+      ...field,
+      ship: { position: [50, 50], velocity: [0, 0], rotation: -3 },
+    },
+  },
+  {
+    name: "no turn holds rotation and coasts by velocity",
+    before: {
+      ...field,
+      ship: { position: [50, 50], velocity: [10, 0], rotation: 0.7 },
+    },
+    args: { dt: 1, input: idle },
+    after: {
+      ...field,
+      ship: { position: [60, 50], velocity: [10, 0], rotation: 0.7 },
+    },
+  },
+  {
+    name: "thrusts along the facing, then coasts by the new velocity",
+    before: {
+      ...field,
+      ship: { position: [50, 50], velocity: [0, 0], rotation: 0 },
+    },
+    args: { dt: 0.1, input: { turn: 0, thrust: true, fire: false } },
+    after: {
+      ...field,
+      ship: { position: [52, 50], velocity: [20, 0], rotation: 0 },
+    },
+  },
+  {
+    name: "wraps across the right edge",
+    before: {
+      ...field,
+      ship: { position: [95, 50], velocity: [100, 0], rotation: 0 },
+    },
+    args: { dt: 0.1, input: idle },
+    after: {
+      ...field,
+      ship: { position: [5, 50], velocity: [100, 0], rotation: 0 },
+    },
+  },
+  {
+    name: "wraps across the top edge (negative wrap)",
+    before: {
+      ...field,
+      ship: { position: [5, 5], velocity: [0, -100], rotation: 0 },
+    },
+    args: { dt: 0.1, input: idle },
+    after: {
+      ...field,
+      ship: { position: [5, 95], velocity: [0, -100], rotation: 0 },
+    },
+  },
+  {
+    // Turn then thrust: −3 turns to 0, and thrust must use the NEW rotation 0
+    // (facing +x → velocity [200,0]); using the old −3 would point elsewhere.
+    name: "turn composes before thrust — thrust uses the post-turn rotation",
+    before: {
+      ...field,
+      ship: { position: [50, 50], velocity: [0, 0], rotation: -3 },
+    },
+    args: { dt: 1, input: { turn: 1, thrust: true, fire: false } },
+    after: {
+      ...field,
+      ship: { position: [50, 50], velocity: [200, 0], rotation: 0 },
+    },
+  },
+];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/step.cases.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/step.cases.ts
deleted file mode 100644
index 10d5c2df..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/step.cases.ts
+++ /dev/null
@@ -1,167 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { State } from "./state.js";
-import type { ConformanceCase } from "./conformance-case.js";
-import { Ship } from "../ship/ship.js";
-import { Input } from "../input/input.js";
-
-// Spec-owned `{ before, args, after }` cases for the whole-tick `State.step`
-// (args = { dt, input }), shared with the ecs system tick-loop conformance
-// (one frame = one step). Each case exercises one branch of the step pipeline —
-// advance/wrap, fire, bullet↔asteroid resolution, ship↔asteroid resolution,
-// wave refill, and the game-over freeze — with geometry chosen so every `after`
-// is exact (stationary bodies, clean quadrant wave, F32-representable numbers).
-type Args = { readonly dt: number; readonly input: Input };
-
-export const cases: readonly ConformanceCase<Args>[] = [
-  {
-    // Ship and an asteroid both advance and wrap; neither reaches the other.
-    name: "advances and wraps every body (movement)",
-    before: {
-      bounds: [200, 200],
-      ship: { position: [190, 100], velocity: [30, 0], rotation: 0 },
-      bullets: [],
-      asteroids: [{ position: [190, 180], velocity: [30, 30], size: "large" }],
-      score: 0,
-      lives: 3,
-      wave: 1,
-    },
-    args: { dt: 1, input: Input.none },
-    after: {
-      bounds: [200, 200],
-      ship: { position: [20, 100], velocity: [30, 0], rotation: 0 },
-      bullets: [],
-      asteroids: [{ position: [20, 10], velocity: [30, 30], size: "large" }],
-      score: 0,
-      lives: 3,
-      wave: 1,
-    },
-  },
-  {
-    // fire fires from the POST-move ship (stepShip → fireBullet → stepBullets),
-    // then the new bullet is advanced + aged the same tick.
-    name: "fires from the post-move muzzle and advances the new bullet (lifetime)",
-    before: {
-      bounds: [400, 400],
-      ship: { position: [100, 100], velocity: [0, 0], rotation: 0 },
-      bullets: [],
-      asteroids: [{ position: [350, 350], velocity: [0, 0], size: "large" }],
-      score: 0,
-      lives: 3,
-      wave: 1,
-    },
-    args: { dt: 0.1, input: { turn: 0, thrust: false, fire: true } },
-    after: {
-      bounds: [400, 400],
-      ship: { position: [100, 100], velocity: [0, 0], rotation: 0 },
-      bullets: [{ position: [152, 100], velocity: [400, 0], age: 0.1 }],
-      asteroids: [{ position: [350, 350], velocity: [0, 0], size: "large" }],
-      score: 0,
-      lives: 3,
-      wave: 1,
-    },
-  },
-  {
-    // A stationary bullet overlapping a large asteroid: it scores 20 and the
-    // rock splits into two stationary mediums; the far ship is untouched.
-    name: "resolves a bullet↔asteroid hit (split + score)",
-    before: {
-      bounds: [800, 600],
-      ship: { position: [700, 500], velocity: [0, 0], rotation: 0 },
-      bullets: [{ position: [100, 100], velocity: [0, 0], age: 0 }],
-      asteroids: [{ position: [100, 100], velocity: [0, 0], size: "large" }],
-      score: 0,
-      lives: 3,
-      wave: 1,
-    },
-    args: { dt: 0.1, input: Input.none },
-    after: {
-      bounds: [800, 600],
-      ship: { position: [700, 500], velocity: [0, 0], rotation: 0 },
-      bullets: [],
-      asteroids: [
-        { position: [100, 100], velocity: [0, 0], size: "medium" },
-        { position: [100, 100], velocity: [0, 0], size: "medium" },
-      ],
-      score: 20,
-      lives: 3,
-      wave: 1,
-    },
-  },
-  {
-    // An asteroid on the centred ship costs a life and respawns it at centre.
-    name: "resolves a ship↔asteroid hit (lose a life, respawn at centre)",
-    before: {
-      bounds: [200, 200],
-      ship: Ship.spawn([100, 100]),
-      bullets: [],
-      asteroids: [{ position: [100, 100], velocity: [0, 0], size: "large" }],
-      score: 0,
-      lives: 3,
-      wave: 1,
-    },
-    args: { dt: 0.1, input: Input.none },
-    after: {
-      bounds: [200, 200],
-      ship: Ship.spawn([100, 100]),
-      bullets: [],
-      asteroids: [{ position: [100, 100], velocity: [0, 0], size: "large" }],
-      score: 0,
-      lives: 2,
-      wave: 1,
-    },
-  },
-  {
-    // A clear field refills: wave 0 → 1 (asteroidsFor(1)=4) as a clean quadrant
-    // ring. spawnWave runs AFTER resolveShipHits, so the new rocks don't strike
-    // the ship this tick.
-    name: "refills the field with a new wave once it is clear",
-    before: {
-      bounds: [200, 200],
-      ship: Ship.spawn([100, 100]),
-      bullets: [],
-      asteroids: [],
-      score: 0,
-      lives: 3,
-      wave: 0,
-    },
-    args: { dt: 0.1, input: Input.none },
-    after: {
-      bounds: [200, 200],
-      ship: Ship.spawn([100, 100]),
-      bullets: [],
-      asteroids: [
-        { position: [180, 100], velocity: [0, 60], size: "large" },
-        { position: [100, 180], velocity: [-60, 0], size: "large" },
-        { position: [20, 100], velocity: [0, -60], size: "large" },
-        { position: [100, 20], velocity: [60, 0], size: "large" },
-      ],
-      score: 0,
-      lives: 3,
-      wave: 1,
-    },
-  },
-  {
-    // Lives spent: the whole tick is frozen (idempotent). Every system must
-    // honour the game-over guard, so nothing — ship, bullet, asteroid — moves.
-    name: "freezes the whole tick once the game is over",
-    before: {
-      bounds: [200, 200],
-      ship: { position: [50, 50], velocity: [10, 0], rotation: 0 },
-      bullets: [{ position: [60, 60], velocity: [0, 0], age: 0.5 }],
-      asteroids: [{ position: [100, 100], velocity: [0, 0], size: "large" }],
-      score: 40,
-      lives: 0,
-      wave: 2,
-    },
-    args: { dt: 0.1, input: { turn: 1, thrust: true, fire: true } },
-    after: {
-      bounds: [200, 200],
-      ship: { position: [50, 50], velocity: [10, 0], rotation: 0 },
-      bullets: [{ position: [60, 60], velocity: [0, 0], age: 0.5 }],
-      asteroids: [{ position: [100, 100], velocity: [0, 0], size: "large" }],
-      score: 40,
-      lives: 0,
-      wave: 2,
-    },
-  },
-];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/step.test.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/step.test.ts
deleted file mode 100644
index bcf14d68..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/step.test.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it, expect } from "vitest";
-import { State } from "./state.js";
-import { Input } from "../input/input.js";
-import { cases } from "./step.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.step", () => {
-  for (const { name, before, args, after } of cases) {
-    it(name, () => {
-      expectStateMatches(State.step(before, args.dt, args.input), after);
-    });
-  }
-
-  it("returns the same reference (not just an equal value) when the game is over", () => {
-    const state = { ...State.create(), lives: 0 };
-    expect(State.step(state, 0.016, Input.none)).toBe(state);
-  });
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/step.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/step.ts
index bb8230e9..0a4cbc06 100644
--- a/packages/data-lit-space-rock-game/src/features/main/data/state/step.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/data/state/step.ts
@@ -1,31 +1,188 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
 import { Input } from "../input/input.js";
+import { Ship } from "../ship/ship.js";
 import { stepShip } from "./step-ship.js";
 import { fireBullet } from "./fire-bullet.js";
 import { stepBullets } from "./step-bullets.js";
 import { stepAsteroids } from "./step-asteroids.js";
 import { resolveBulletHits } from "./resolve-bullet-hits.js";
 import { resolveShipHits } from "./resolve-ship-hits.js";
-import { spawnWave } from "./spawn-wave.js";
+import { spawnRandomWave } from "./spawn-random-wave.js";
 import { isGameOver } from "./is-game-over.js";
+import { RandomService } from "../../services/random-service/random-service.js";
 
-// Advance the whole game one tick. This is the authoritative spec the ECS
-// systems are verified against: move the ship, fire, advance bullets and
-// asteroids, resolve collisions, then refill the wave if the field is clear.
-// A game that is over is frozen (idempotent).
-export const step = (state: State, dt: number, input: Input): State => {
+// Advance the whole game one tick. This is the authoritative spec the ECS systems
+// are verified against: move the ship, fire, advance bullets and asteroids,
+// resolve collisions, then refill the wave if the field is clear. A game that is
+// over is frozen (idempotent). `dt`, `input`, and the injected `random` service
+// are bundled into one args object (second parameter) so the co-located
+// conformance cases derive their `args` type from this signature.
+//
+// The refill draws randomness, so `step` threads the injected `random` service
+// down to `spawnRandomWave` — keeping the whole tick deterministic GIVEN the
+// service. The runtime ECS `waves` system supplies a real `Math.random`-backed
+// source; because that source cannot be shared with the pure oracle
+// frame-for-frame, the shared tick-loop conformance cases never clear the field
+// (the randomized refill is exercised directly in `spawn-random-wave.ts` cases and
+// conformed via the `spawnRandomWave` transaction).
+export const step = (
+  state: State,
+  {
+    dt,
+    input,
+    random,
+  }: {
+    readonly dt: number;
+    readonly input: Input;
+    readonly random: RandomService;
+  },
+): State => {
   if (isGameOver(state)) {
     return state;
   }
-  let next = stepShip(state, dt, input);
+  // Each sub-transition returns only the fields it writes; layer each patch over
+  // the running full state so the whole tick composes into one State.
+  let next: State = { ...state, ...stepShip(state, { dt, input }) };
   if (input.fire) {
-    next = fireBullet(next);
+    next = { ...next, ...fireBullet(next) };
   }
-  next = stepBullets(next, dt);
-  next = stepAsteroids(next, dt);
-  next = resolveBulletHits(next, dt);
-  next = resolveShipHits(next);
-  next = spawnWave(next);
+  next = { ...next, ...stepBullets(next, dt) };
+  next = { ...next, ...stepAsteroids(next, dt) };
+  next = { ...next, ...resolveBulletHits(next, dt) };
+  next = { ...next, ...resolveShipHits(next) };
+  next = { ...next, ...spawnRandomWave(next, { random }) };
   return next;
 };
+
+// Spec-owned cases for the whole-tick `step`, shared with the ecs system tick-loop
+// conformance (one frame = one step). Each case exercises one branch of the step
+// pipeline — advance/wrap, fire, bullet↔asteroid resolution, ship↔asteroid
+// resolution, and the game-over freeze — with geometry chosen so every `after` is
+// exact. NONE clears the field, so `random` is never drawn (a fresh double per
+// case satisfies the signature without affecting the outcome); the randomized
+// refill is conformed out-of-band via the `spawnRandomWave` transaction.
+export const cases: Conformance<typeof step> = [
+  {
+    name: "advances and wraps every body (movement)",
+    before: {
+      bounds: [200, 200],
+      ship: { position: [190, 100], velocity: [30, 0], rotation: 0 },
+      bullets: [],
+      asteroids: [{ position: [190, 180], velocity: [30, 30], size: "large" }],
+      score: 0,
+      lives: 3,
+      wave: 1,
+    },
+    args: { dt: 1, input: Input.none, random: RandomService.createFake() },
+    after: {
+      bounds: [200, 200],
+      ship: { position: [20, 100], velocity: [30, 0], rotation: 0 },
+      bullets: [],
+      asteroids: [{ position: [20, 10], velocity: [30, 30], size: "large" }],
+      score: 0,
+      lives: 3,
+      wave: 1,
+    },
+  },
+  {
+    name: "fires from the post-move muzzle and advances the new bullet (lifetime)",
+    before: {
+      bounds: [400, 400],
+      ship: { position: [100, 100], velocity: [0, 0], rotation: 0 },
+      bullets: [],
+      asteroids: [{ position: [350, 350], velocity: [0, 0], size: "large" }],
+      score: 0,
+      lives: 3,
+      wave: 1,
+    },
+    args: {
+      dt: 0.1,
+      input: { turn: 0, thrust: false, fire: true },
+      random: RandomService.createFake(),
+    },
+    after: {
+      bounds: [400, 400],
+      ship: { position: [100, 100], velocity: [0, 0], rotation: 0 },
+      bullets: [{ position: [152, 100], velocity: [400, 0], age: 0.1 }],
+      asteroids: [{ position: [350, 350], velocity: [0, 0], size: "large" }],
+      score: 0,
+      lives: 3,
+      wave: 1,
+    },
+  },
+  {
+    name: "resolves a bullet↔asteroid hit (split + score)",
+    before: {
+      bounds: [800, 600],
+      ship: { position: [700, 500], velocity: [0, 0], rotation: 0 },
+      bullets: [{ position: [100, 100], velocity: [0, 0], age: 0 }],
+      asteroids: [{ position: [100, 100], velocity: [0, 0], size: "large" }],
+      score: 0,
+      lives: 3,
+      wave: 1,
+    },
+    args: { dt: 0.1, input: Input.none, random: RandomService.createFake() },
+    after: {
+      bounds: [800, 600],
+      ship: { position: [700, 500], velocity: [0, 0], rotation: 0 },
+      bullets: [],
+      asteroids: [
+        { position: [100, 100], velocity: [0, 0], size: "medium" },
+        { position: [100, 100], velocity: [0, 0], size: "medium" },
+      ],
+      score: 20,
+      lives: 3,
+      wave: 1,
+    },
+  },
+  {
+    name: "resolves a ship↔asteroid hit (lose a life, respawn at centre)",
+    before: {
+      bounds: [200, 200],
+      ship: Ship.spawn([100, 100]),
+      bullets: [],
+      asteroids: [{ position: [100, 100], velocity: [0, 0], size: "large" }],
+      score: 0,
+      lives: 3,
+      wave: 1,
+    },
+    args: { dt: 0.1, input: Input.none, random: RandomService.createFake() },
+    after: {
+      bounds: [200, 200],
+      ship: Ship.spawn([100, 100]),
+      bullets: [],
+      asteroids: [{ position: [100, 100], velocity: [0, 0], size: "large" }],
+      score: 0,
+      lives: 2,
+      wave: 1,
+    },
+  },
+  {
+    name: "freezes the whole tick once the game is over",
+    before: {
+      bounds: [200, 200],
+      ship: { position: [50, 50], velocity: [10, 0], rotation: 0 },
+      bullets: [{ position: [60, 60], velocity: [0, 0], age: 0.5 }],
+      asteroids: [{ position: [100, 100], velocity: [0, 0], size: "large" }],
+      score: 40,
+      lives: 0,
+      wave: 2,
+    },
+    args: {
+      dt: 0.1,
+      input: { turn: 1, thrust: true, fire: true },
+      random: RandomService.createFake(),
+    },
+    after: {
+      bounds: [200, 200],
+      ship: { position: [50, 50], velocity: [10, 0], rotation: 0 },
+      bullets: [{ position: [60, 60], velocity: [0, 0], age: 0.5 }],
+      asteroids: [{ position: [100, 100], velocity: [0, 0], size: "large" }],
+      score: 40,
+      lives: 0,
+      wave: 2,
+    },
+  },
+];
diff --git a/packages/data-lit-space-rock-game/src/features/main/data/state/transitions.ts b/packages/data-lit-space-rock-game/src/features/main/data/state/transitions.ts
new file mode 100644
index 00000000..1092fd91
--- /dev/null
+++ b/packages/data-lit-space-rock-game/src/features/main/data/state/transitions.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+/// <reference types="vite/client" />
+
+// The transform/derivation modules for conformance discovery — the `{ fn, cases }`
+// source shared by `spec.test.ts` (pure) and the ecs `conformance.test.ts`. The
+// glob must be authored where Vite can statically see it (an eager glob, excluding
+// tests and this file itself); consumers import the resolved map.
+export const transitions = import.meta.glob<Record<string, unknown>>(
+  ["./*.ts", "!./*.test.ts", "!./*.type-test.ts", "!./transitions.ts"],
+  { eager: true },
+);
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/action-database/action-database.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/action-database/action-database.ts
new file mode 100644
index 00000000..f23aede5
--- /dev/null
+++ b/packages/data-lit-space-rock-game/src/features/main/services/main-service/action-database/action-database.ts
@@ -0,0 +1,20 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { ServiceDatabase } from "../service-database/service-database.js";
+import * as actions from "./actions/index.js";
+
+// Extends the service database with the `actions` facet: the async, app-facing
+// realizations that orchestrate a `services/` port and commit through a single
+// transaction. Per-frame step transitions are realized by the `systems` layer
+// (conformed via the tick-loop), not by actions.
+const actionDatabasePlugin = Database.Plugin.create({
+  extends: ServiceDatabase.plugin,
+  actions,
+});
+
+export type ActionDatabase = Database.Plugin.ToDatabase<typeof actionDatabasePlugin>;
+
+export namespace ActionDatabase {
+  export const plugin = actionDatabasePlugin;
+  export type Store = Database.Plugin.ToStore<typeof actionDatabasePlugin>;
+}
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/action-database/actions/fire-bullet.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/action-database/actions/fire-bullet.ts
new file mode 100644
index 00000000..540be73d
--- /dev/null
+++ b/packages/data-lit-space-rock-game/src/features/main/services/main-service/action-database/actions/fire-bullet.ts
@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+// The app-facing realization of `State.fireBullet`: a local shot needs no outside
+// capability, so it commits through the single `fireBullet` transaction (which
+// reads the current ship from the store and inserts the muzzle bullet). The UI
+// never awaits this — state flows back through observables.
+export const fireBullet = (db: ServiceDatabase) => {
+  db.transactions.fireBullet();
+};
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/action-database/actions/index.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/action-database/actions/index.ts
new file mode 100644
index 00000000..d40e650a
--- /dev/null
+++ b/packages/data-lit-space-rock-game/src/features/main/services/main-service/action-database/actions/index.ts
@@ -0,0 +1,3 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export * from "./fire-bullet.js";
+export * from "./spawn-random-wave.js";
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/action-database/actions/spawn-random-wave.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/action-database/actions/spawn-random-wave.ts
new file mode 100644
index 00000000..511e41d0
--- /dev/null
+++ b/packages/data-lit-space-rock-game/src/features/main/services/main-service/action-database/actions/spawn-random-wave.ts
@@ -0,0 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+// The app-facing realization of `State.spawnRandomWave` (which injects the same
+// `random` port): read the `random` service from `db.services` and commit the next
+// wave through the single `spawnRandomWave` transaction (which reads the current
+// field/wave/bounds from the store — never a cached computed — and is a no-op
+// while asteroids remain). `random.next()` is a value-returning read, not a
+// fire-and-forget effect, so it is not surfaced to the caller.
+export const spawnRandomWave = (db: ServiceDatabase) => {
+  db.transactions.spawnRandomWave({ random: db.services.random });
+};
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/conformance.test.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/conformance.test.ts
new file mode 100644
index 00000000..b4ce014e
--- /dev/null
+++ b/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/conformance.test.ts
@@ -0,0 +1,21 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Conformance } from "@adobe/data/testing";
+import { State } from "../../../data/state/state.js";
+import { transitions } from "../../../data/state/transitions.js";
+import { MainService } from "../main-service.js";
+import { projection } from "./projection.js";
+
+// The whole ecs conformance for this feature in one call: `runFeature` pulls the
+// transactions/actions off `MainService.plugin`, seeds each case's `before` (a
+// delta) over `State.create()`, and round-trips `State.samples` through the
+// projection. `transitions` (the discovered `{ fn, cases }` modules) is shared with
+// spec.test. The entity bags the ecs materialises in nondeterministic row order
+// (`bullets`, `asteroids`) compare as multisets via `match.unordered`. There is no
+// `computedPlugin` — space-rock has no `state/` derivations.
+Conformance.runFeature({
+  state: State,
+  transitions,
+  plugin: MainService.plugin,
+  projection,
+  match: { unordered: new Set(["bullets", "asteroids"]) },
+});
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/create-store.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/create-store.ts
deleted file mode 100644
index 4fa8cc16..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/create-store.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { Store } from "@adobe/data/ecs";
-import type { CoreDatabase } from "../core-database/core-database.js";
-import { IndexDatabase } from "../index-database/index-database.js";
-
-// A fresh writable store carrying the feature's whole schema. `IndexDatabase` is
-// the lowest layer that declares it all (components / resources / archetypes +
-// indexes) — the behaviour layers above (transactions / computed / systems) add
-// none — and `Store.create` reads a plugin's schema facets directly. Typed as
-// `CoreDatabase.Store`: the surface the projection (`fromState` / `toState`) and
-// the raw transaction functions use. Test-only.
-export const createStore = (): CoreDatabase.Store => Store.create(IndexDatabase.plugin);
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/create-system-database.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/create-system-database.ts
index a96b45f7..746f19d6 100644
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/create-system-database.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/create-system-database.ts
@@ -1,6 +1,6 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Database } from "@adobe/data/ecs";
-import { FeatureDatabase } from "../feature-database.js";
+import { MainService } from "../main-service.js";
 
 // The assembled feature database viewed as its writable *system surface* — the
 // same `Database & { store }` a system's `create(db)` receives — obtained
@@ -10,5 +10,5 @@ import { FeatureDatabase } from "../feature-database.js";
 // store via `db.store`. Transaction and projection conformance use `createStore`
 // instead (a transaction needs no `Database`). Test-only.
 export const createSystemDatabase = (): Database.Plugin.ToSystemDatabase<
-  typeof FeatureDatabase.plugin
-> => Database.toSystemDatabase(Database.create(FeatureDatabase.plugin));
+  typeof MainService.plugin
+> => Database.toSystemDatabase(Database.create(MainService.plugin));
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/drive-frame.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/drive-frame.ts
index b044ee3e..1d03634b 100644
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/drive-frame.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/drive-frame.ts
@@ -13,7 +13,10 @@ export const driveFrame = (db: SystemDatabase): void => {
       // `name` comes from `db.system.order`, so it is always one of this
       // database's declared system keys — an invariant the `string` element
       // type of `order` cannot carry.
-      const fn = db.system.functions[name as keyof SystemDatabase["system"]["functions"]];
+      const fn =
+        db.system.functions[
+          name as keyof SystemDatabase["system"]["functions"]
+        ];
       if (typeof fn === "function") fn();
     }
   }
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/expect-conforms.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/expect-conforms.ts
deleted file mode 100644
index baf3ca2c..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/expect-conforms.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { it } from "vitest";
-import type { State } from "../../../data/state/state.js";
-import type { ConformanceCase } from "../../../data/state/conformance-case.js";
-import { expectStateMatches } from "../../../data/state/expect-state-matches.js";
-import type { CoreDatabase } from "../core-database/core-database.js";
-import { createStore } from "./create-store.js";
-import { fromState } from "./from-state.js";
-import { toState } from "./to-state.js";
-
-// The conformance runner, bound to THIS feature's projection (`fromState` /
-// `toState`). For each case it proves the one conformance property
-//
-//   toState(apply(fromState(before), args)) ≡ spec(before, args)
-//
-// in two asserted halves:
-//   1. `spec(before, args) ≡ after` — keeps the shared case honest (a
-//      mis-authored `after` is caught here, independent of the ecs path).
-//   2. seed `fromState(before)` → run the caller's `apply` → `toState ≡ after`
-//      — the ecs implementation reproduces the pure transform.
-//
-// `apply` receives the seeded writable store and calls the raw transaction
-// function directly (a transaction is `(store, args) => void`, so no `Database`
-// is involved). A mutation addressed by entity id resolves its entities from the
-// seeded store there (the shared cases stay spec-shaped). Entity collections
-// compare as multisets; scalars and resources exactly (see `expectStateMatches`).
-export const expectConforms = <Args>(config: {
-  readonly cases: readonly ConformanceCase<Args>[];
-  readonly spec: (before: State, args: Args) => State;
-  readonly apply: (store: CoreDatabase.Store, args: Args) => void;
-}): void => {
-  for (const testCase of config.cases) {
-    it(testCase.name, () => {
-      expectStateMatches(config.spec(testCase.before, testCase.args), testCase.after);
-
-      const store = createStore();
-      fromState(store, testCase.before);
-      config.apply(store, testCase.args);
-      expectStateMatches(toState(store), testCase.after);
-    });
-  }
-};
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/from-state.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/from-state.ts
deleted file mode 100644
index 9745e1c6..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/from-state.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { State } from "../../../data/state/state.js";
-import type { CoreDatabase } from "../core-database/core-database.js";
-
-// Seed a store to exactly match a `data/` `State`: clear every entity, set the
-// scalar resources, then insert the ship, bullets, and asteroids. The inverse
-// of `toState`. Test-only — the bridge that lets an ecs mutation be checked
-// against the pure transform it stands for (see `expect-conforms.ts`).
-//
-// Clearing iterates tail→head so each delete is from the tail (no hole-fill
-// shift). Every entity carries `position`, so one query covers all three
-// archetypes. Row shapes equal their `data/` types (no stored broad-phase
-// column), so each value inserts directly.
-export const fromState = (store: CoreDatabase.Store, state: State): void => {
-  for (const arch of store.queryArchetypes(["position"])) {
-    for (let row = arch.rowCount - 1; row >= 0; row--) {
-      store.delete(arch.columns.id.get(row));
-    }
-  }
-  store.resources.bounds = state.bounds;
-  store.resources.score = state.score;
-  store.resources.lives = state.lives;
-  store.resources.wave = state.wave;
-  store.archetypes.Ship.insert(state.ship);
-  for (const bullet of state.bullets) {
-    store.archetypes.Bullet.insert(bullet);
-  }
-  for (const asteroid of state.asteroids) {
-    store.archetypes.Asteroid.insert(asteroid);
-  }
-};
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/projection.test.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/projection.test.ts
deleted file mode 100644
index 9384ad8d..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/projection.test.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// Guards the projection itself. `fromState` and `toState` are the bridge every
-// transaction / system conformance test trusts; a symmetric bug in the pair
-// (e.g. both dropping the same field) would cancel out and mask a real ecs
-// defect. This identity test — `toState(fromState(s)) ≡ s` over representative
-// states — proves the projection round-trips faithfully on its own.
-import { describe, it } from "vitest";
-import type { State } from "../../../data/state/state.js";
-import { expectStateMatches } from "../../../data/state/expect-state-matches.js";
-import { createStore } from "./create-store.js";
-import { fromState } from "./from-state.js";
-import { toState } from "./to-state.js";
-
-const states: readonly { readonly name: string; readonly state: State }[] = [
-  {
-    name: "a full game: ship + bullets + asteroids of every size, non-zero counters",
-    state: {
-      bounds: [800, 600],
-      ship: { position: [400, 300], velocity: [12, -7], rotation: 1.25 },
-      bullets: [
-        { position: [100, 100], velocity: [400, 0], age: 0.1 },
-        { position: [220, 340], velocity: [-100, 200], age: 0.9 },
-      ],
-      asteroids: [
-        { position: [50, 60], velocity: [10, 20], size: "large" },
-        { position: [700, 80], velocity: [-30, 5], size: "medium" },
-        { position: [640, 540], velocity: [0, -15], size: "small" },
-      ],
-      score: 240,
-      lives: 2,
-      wave: 5,
-    },
-  },
-  {
-    name: "no bullets and no asteroids (just the ship)",
-    state: {
-      bounds: [320, 240],
-      ship: { position: [160, 120], velocity: [0, 0], rotation: -Math.PI / 2 },
-      bullets: [],
-      asteroids: [],
-      score: 0,
-      lives: 3,
-      wave: 0,
-    },
-  },
-  {
-    name: "many same-size asteroids at the same point (multiset round-trip)",
-    state: {
-      bounds: [500, 500],
-      ship: { position: [250, 250], velocity: [0, 0], rotation: 0 },
-      bullets: [],
-      asteroids: [
-        { position: [250, 250], velocity: [0, 0], size: "medium" },
-        { position: [250, 250], velocity: [0, 0], size: "medium" },
-        { position: [250, 250], velocity: [0, 0], size: "medium" },
-      ],
-      score: 90,
-      lives: 1,
-      wave: 3,
-    },
-  },
-];
-
-describe("ecs/conformance projection round-trips (toState ∘ fromState ≡ identity)", () => {
-  for (const { name, state } of states) {
-    it(name, () => {
-      const store = createStore();
-      fromState(store, state);
-      expectStateMatches(toState(store), state);
-    });
-  }
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/projection.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/projection.ts
new file mode 100644
index 00000000..81a281d5
--- /dev/null
+++ b/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/projection.ts
@@ -0,0 +1,107 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Entity } from "@adobe/data/ecs";
+import type { State } from "../../../data/state/state.js";
+import type { Ship } from "../../../data/ship/ship.js";
+import type { Bullet } from "../../../data/bullet/bullet.js";
+import type { Asteroid } from "../../../data/asteroid/asteroid.js";
+import type { CoreDatabase } from "../core-database/core-database.js";
+
+// Read one entity back into its `data/` value — the per-entity projection
+// `toState` is built on, and the single place the ecs↔data mapping for the three
+// entity kinds lives. Unlike a single-archetype feature (todo), an entity here is
+// one of Ship / Bullet / Asteroid, so `toData` probes each named archetype (their
+// component sets are distinct — only Ship has `rotation`, only Bullet `age`, only
+// Asteroid `size`) and projects the first that matches. Test-only.
+const toData = (
+  store: CoreDatabase.Store,
+  entity: Entity,
+): Ship | Bullet | Asteroid => {
+  const ship = store.read(entity, store.archetypes.Ship);
+  if (ship !== null)
+    return {
+      position: ship.position,
+      velocity: ship.velocity,
+      rotation: ship.rotation,
+    };
+  const bullet = store.read(entity, store.archetypes.Bullet);
+  if (bullet !== null)
+    return {
+      position: bullet.position,
+      velocity: bullet.velocity,
+      age: bullet.age,
+    };
+  const asteroid = store.read(entity, store.archetypes.Asteroid);
+  if (asteroid !== null)
+    return {
+      position: asteroid.position,
+      velocity: asteroid.velocity,
+      size: asteroid.size,
+    };
+  throw new Error(
+    "conformance projection: entity is not a ship, bullet, or asteroid",
+  );
+};
+
+// The test-only ecs↔`State` projection, passed to `Conformance.runFeature`.
+// `fromState` seeds a store to a `State` (space-rock is not id-addressed, so it
+// returns no id map); `toState` reads it back through `toData`; `toData` reads one
+// entity. These are STRICTLY for conformance tests and MUST NEVER run in
+// production code.
+export const projection = {
+  // Seed a store to exactly match a `data/` `State`: clear every entity, set the
+  // scalar resources, then insert the ship, bullets, and asteroids. The inverse
+  // of `toState`. Clearing iterates tail→head so each delete is from the tail (no
+  // hole-fill shift). Every entity carries `position`, so one query covers all
+  // three archetypes. Row shapes equal their `data/` types (no stored broad-phase
+  // column), so each value inserts directly.
+  fromState: (store: CoreDatabase.Store, state: State): void => {
+    for (const arch of store.queryArchetypes(["position"])) {
+      for (let row = arch.rowCount - 1; row >= 0; row--) {
+        store.delete(arch.columns.id.get(row));
+      }
+    }
+    store.resources.bounds = state.bounds;
+    store.resources.score = state.score;
+    store.resources.lives = state.lives;
+    store.resources.wave = state.wave;
+    store.archetypes.Ship.insert(state.ship);
+    for (const bullet of state.bullets) {
+      store.archetypes.Bullet.insert(bullet);
+    }
+    for (const asteroid of state.asteroids) {
+      store.archetypes.Asteroid.insert(asteroid);
+    }
+  },
+  // Read a store back into a `data/` `State` — the inverse of `fromState`, built on
+  // the per-entity `toData` projection. Every entity carries `position`, so one
+  // query covers all three archetypes; each entity is projected through `toData`
+  // and sorted into the ship, bullets, or asteroids slot by its distinguishing
+  // member (`rotation` → ship, `age` → bullet, `size` → asteroid). Row order across
+  // archetypes is arbitrary, but the entity collections compare as multisets, so it
+  // need not be stable.
+  toState: (store: CoreDatabase.Store): State => {
+    let ship: Ship | undefined;
+    const bullets: Bullet[] = [];
+    const asteroids: Asteroid[] = [];
+    for (const arch of store.queryArchetypes(["position"])) {
+      for (let row = 0; row < arch.rowCount; row++) {
+        const value = toData(store, arch.columns.id.get(row));
+        if ("rotation" in value) ship = value;
+        else if ("age" in value) bullets.push(value);
+        else asteroids.push(value);
+      }
+    }
+    if (ship === undefined)
+      throw new Error("conformance projection: expected a ship entity");
+    return {
+      bounds: store.resources.bounds,
+      ship,
+      bullets,
+      asteroids,
+      score: store.resources.score,
+      lives: store.resources.lives,
+      wave: store.resources.wave,
+    };
+  },
+  toData,
+};
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/to-state.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/to-state.ts
deleted file mode 100644
index 6779998a..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/conformance/to-state.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { State } from "../../../data/state/state.js";
-import type { Ship } from "../../../data/ship/ship.js";
-import type { Bullet } from "../../../data/bullet/bullet.js";
-import type { Asteroid } from "../../../data/asteroid/asteroid.js";
-import type { CoreDatabase } from "../core-database/core-database.js";
-
-// Read a store back into a `data/` `State` — the inverse of `fromState`. Each
-// kind is read through its named archetype's full component set (not an
-// incidental single column), so the three entity shapes never alias. Test-only.
-const readShip = (store: CoreDatabase.Store): Ship => {
-  const [entity] = store.select(store.archetypes.Ship.components);
-  if (entity === undefined) throw new Error("conformance projection: expected a ship entity");
-  const row = store.read(entity, store.archetypes.Ship);
-  if (row === null) throw new Error("conformance projection: expected a ship entity");
-  return { position: row.position, velocity: row.velocity, rotation: row.rotation };
-};
-
-const readBullets = (store: CoreDatabase.Store): Bullet[] => {
-  const bullets: Bullet[] = [];
-  for (const arch of store.queryArchetypes(store.archetypes.Bullet.components)) {
-    for (let row = 0; row < arch.rowCount; row++) {
-      bullets.push({
-        position: arch.columns.position.get(row),
-        velocity: arch.columns.velocity.get(row),
-        age: arch.columns.age.get(row),
-      });
-    }
-  }
-  return bullets;
-};
-
-const readAsteroids = (store: CoreDatabase.Store): Asteroid[] => {
-  const asteroids: Asteroid[] = [];
-  for (const arch of store.queryArchetypes(store.archetypes.Asteroid.components)) {
-    for (let row = 0; row < arch.rowCount; row++) {
-      asteroids.push({
-        position: arch.columns.position.get(row),
-        velocity: arch.columns.velocity.get(row),
-        size: arch.columns.size.get(row),
-      });
-    }
-  }
-  return asteroids;
-};
-
-export const toState = (store: CoreDatabase.Store): State => ({
-  bounds: store.resources.bounds,
-  ship: readShip(store),
-  bullets: readBullets(store),
-  asteroids: readAsteroids(store),
-  score: store.resources.score,
-  lives: store.resources.lives,
-  wave: store.resources.wave,
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/feature-database.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/main-service.ts
similarity index 73%
rename from packages/data-lit-space-rock-game/src/features/main/services/main-service/feature-database.ts
rename to packages/data-lit-space-rock-game/src/features/main/services/main-service/main-service.ts
index 5bfb6a77..dfdf7c39 100644
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/feature-database.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/services/main-service/main-service.ts
@@ -3,4 +3,4 @@
 // The feature's assembled database, aliased once so consumers (ui/, the app
 // entry, ecs/conformance/) never name the topmost layer. Add or drop a layer →
 // change only this line.
-export { SystemDatabase as FeatureDatabase } from "./system-database/system-database.js";
+export { SystemDatabase as MainService } from "./system-database/system-database.js";
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/service-database/service-database.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/service-database/service-database.ts
new file mode 100644
index 00000000..85292398
--- /dev/null
+++ b/packages/data-lit-space-rock-game/src/features/main/services/main-service/service-database/service-database.ts
@@ -0,0 +1,24 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { ComputedDatabase } from "../computed-database/computed-database.js";
+import { RandomService } from "../../random-service/random-service.js";
+
+// Extends the computed database with the `services` facet. `random` is a
+// capability port with no ECS state to bind, so it is registered directly from
+// its `services/` contract (like data-lit-todo's `nameGenerator`): production
+// uses the real `Math.random`-backed source; tests inject
+// `RandomService.createFake` through the `Database.create` service override.
+// Consumers reach it as `db.services.random`.
+const serviceDatabasePlugin = Database.Plugin.create({
+  extends: ComputedDatabase.plugin,
+  services: {
+    random: RandomService.create,
+  },
+});
+
+export type ServiceDatabase = Database.Plugin.ToDatabase<typeof serviceDatabasePlugin>;
+
+export namespace ServiceDatabase {
+  export const plugin = serviceDatabasePlugin;
+  export type Store = Database.Plugin.ToStore<typeof serviceDatabasePlugin>;
+}
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/system-database/collision-detection.test.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/system-database/collision-detection.test.ts
index d70a5a6a..b632ced2 100644
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/system-database/collision-detection.test.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/services/main-service/system-database/collision-detection.test.ts
@@ -16,8 +16,7 @@ import { Ship } from "../../../data/ship/ship.js";
 import { Input } from "../../../data/input/input.js";
 import { Size } from "../../../data/size/size.js";
 import { createSystemDatabase } from "../conformance/create-system-database.js";
-import { fromState } from "../conformance/from-state.js";
-import { toState } from "../conformance/to-state.js";
+import { projection } from "../conformance/projection.js";
 import { driveFrame } from "../conformance/drive-frame.js";
 
 const base = (overrides: Partial<State>): State => ({
@@ -34,11 +33,11 @@ const base = (overrides: Partial<State>): State => ({
 // Seed the geometry, run exactly one detection-only frame (dt 0), project back.
 const detect = (state: State): State => {
   const db = createSystemDatabase();
-  fromState(db.store, state);
+  projection.fromState(db.store, state);
   db.store.resources.frameDelta = 0;
   db.transactions.setInput(Input.none);
   driveFrame(db);
-  return toState(db.store);
+  return projection.toState(db.store);
 };
 
 describe("collision detection — bullet ↔ asteroid selection", () => {
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/system-database/system-database.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/system-database/system-database.ts
index 4842f9df..ea2acc36 100644
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/system-database/system-database.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/services/main-service/system-database/system-database.ts
@@ -2,7 +2,7 @@
 import { Database, scheduler } from "@adobe/data/ecs";
 import type { Entity } from "@adobe/data/ecs";
 import { Vec2 } from "@adobe/data/math";
-import { ComputedDatabase } from "../computed-database/computed-database.js";
+import { ActionDatabase } from "../action-database/action-database.js";
 import { Motion } from "../../../data/motion/motion.js";
 import { Spatial } from "../../../data/spatial/spatial.js";
 import { Collision } from "../../../data/collision/collision.js";
@@ -11,8 +11,10 @@ import { Bullet } from "../../../data/bullet/bullet.js";
 import { Ship } from "../../../data/ship/ship.js";
 import { State } from "../../../data/state/state.js";
 
-// The real-time tick loop. Extends the computed database (schema + indexes +
-// transactions + computed) combined with the built-in `scheduler`, and declares
+// The real-time tick loop. Extends the action database (schema + indexes +
+// transactions + computed + services + actions) combined with the built-in
+// `scheduler` — systems come last in the pipeline, so they sit atop the service
+// and action layers the feature builds — and declares
 // the `systems` facet INLINE so each `create`'s `db` is strongly typed (the
 // assembled database with a *writable* store) and the scheduler can infer the
 // system-name union from the map's keys.
@@ -26,7 +28,7 @@ import { State } from "../../../data/state/state.js";
 //   lifetime → State.fireBullet THEN State.stepBullets (fire from the *post-move*
 //              muzzle, then advance + age + retire every bullet, new one included)
 //   collision→ resolveBulletHits then resolveShipHits (discrete transactions)
-//   waves    → State.spawnWave once the field is clear
+//   waves    → State.spawnRandomWave once the field is clear (injected random)
 //
 // Firing lives in `lifetime` (after `movement`) precisely so the bullet leaves
 // the ship's post-move muzzle and is advanced+aged in the same frame — matching
@@ -36,7 +38,7 @@ import { State } from "../../../data/state/state.js";
 // rAF and drives frames itself by invoking `db.system.functions[name]()` for each
 // name in `db.system.order`.
 const systemDatabasePlugin = Database.Plugin.create({
-  extends: Database.Plugin.combine(ComputedDatabase.plugin, scheduler),
+  extends: Database.Plugin.combine(ActionDatabase.plugin, scheduler),
   systems: {
     // Apply the player's intent to the ship: turn, then thrust along the new
     // facing — the rotation/velocity half of State.stepShip (movement advances
@@ -247,20 +249,27 @@ const systemDatabasePlugin = Database.Plugin.create({
       },
     },
 
-    // Refill the field once it is clear — the ecs wiring for State.spawnWave.
+    // Refill the field once it is clear — the ecs wiring for State.spawnRandomWave.
     // Only the Asteroid archetype carries `size`, so a non-empty match means rocks
-    // remain and there is nothing to do; otherwise dispatch spawnWave (which bumps
-    // `wave` and inserts the next ring through the data/-verified layout). Frozen
-    // once the game is over — step never reaches spawnWave after game over, so a
-    // dead game does not respawn a wave.
+    // remain and there is nothing to do; otherwise dispatch spawnRandomWave, which
+    // bumps `wave` and inserts the next ring through the data/-verified layout —
+    // its per-rock drift speeds jittered by the injected `random` service, so live
+    // waves vary run to run. The random source is the feature's `random` service
+    // (`db.services.random`, the real Math.random-backed source in production);
+    // it is read once here (in `create`, before the per-frame loop) and injected on
+    // every spawn. Frozen once the game is over — step never reaches the refill
+    // after game over, so a dead game does not respawn a wave.
     waves: {
       schedule: { after: ["collision"] },
-      create: (db) => () => {
-        if (State.isGameOver({ lives: db.store.resources.lives })) return;
-        for (const arch of db.store.queryArchetypes(["size"])) {
-          if (arch.rowCount > 0) return;
-        }
-        db.transactions.spawnWave();
+      create: (db) => {
+        const random = db.services.random;
+        return () => {
+          if (State.isGameOver({ lives: db.store.resources.lives })) return;
+          for (const arch of db.store.queryArchetypes(["size"])) {
+            if (arch.rowCount > 0) return;
+          }
+          db.transactions.spawnRandomWave({ random });
+        };
       },
     },
   },
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/system-database/tick-loop.test.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/system-database/tick-loop.test.ts
index 2cee6508..3963514c 100644
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/system-database/tick-loop.test.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/services/main-service/system-database/tick-loop.test.ts
@@ -13,27 +13,82 @@
 // straight to the store as the oracle is fed `args.dt`) and the player `input`,
 // drive one headless frame, then assert `toState(db.store) ≡ after`. Each case
 // also asserts `State.step ≡ after` first, keeping the shared case honest.
-import { describe, it } from "vitest";
+//
+// None of the shared cases clears the field, so neither the oracle nor the
+// `waves` system draws randomness — the injected `random` double is inert here
+// and both sides stay exact. The randomized refill (whose real `Math.random`
+// source can't be shared with the pure oracle frame-for-frame) is covered
+// out-of-band: `spawn-random-wave.test.ts` (transition), the `spawnRandomWave`
+// transaction conformance (ecs mutation), and the detection test below (the
+// `waves` system actually refilling a cleared field).
+import { describe, it, expect } from "vitest";
 import { State } from "../../../data/state/state.js";
-import { cases } from "../../../data/state/step.cases.js";
-import { expectStateMatches } from "../../../data/state/expect-state-matches.js";
+import { Ship } from "../../../data/ship/ship.js";
+import { Input } from "../../../data/input/input.js";
+import { cases } from "../../../data/state/step.js";
+import { Match } from "@adobe/data/testing";
 import { createSystemDatabase } from "../conformance/create-system-database.js";
-import { fromState } from "../conformance/from-state.js";
-import { toState } from "../conformance/to-state.js";
+import { projection } from "../conformance/projection.js";
 import { driveFrame } from "../conformance/drive-frame.js";
 
 describe("ECS system tick loop conforms to State.step (one frame = one step)", () => {
   for (const testCase of cases) {
     it(testCase.name, () => {
       const { dt, input } = testCase.args;
-      expectStateMatches(State.step(testCase.before, dt, input), testCase.after);
+      const unordered = { unordered: new Set(["bullets", "asteroids"]) };
+      // A case `before` is a delta over the feature default (`Case.before` is
+      // `Partial<State>`), so materialise the full seed the same way the runners do.
+      const before = { ...State.create(), ...testCase.before };
+      // The co-located case carries its own inert `random` double (no case clears
+      // the field, so it is never drawn), so drive the oracle with the case args.
+      Match.assert(
+        State.step(before, testCase.args),
+        testCase.after,
+        unordered,
+      );
 
       const db = createSystemDatabase();
-      fromState(db.store, testCase.before);
+      projection.fromState(db.store, before);
       db.store.resources.frameDelta = dt;
       db.transactions.setInput(input);
       driveFrame(db);
-      expectStateMatches(toState(db.store), testCase.after);
+      Match.assert(projection.toState(db.store), testCase.after, unordered);
     });
   }
+
+  // The `waves` system uses the REAL random source, so its drift speeds vary and
+  // can't be asserted against the pure oracle. Detection-style check instead: a
+  // driven frame over a cleared field must refill it with the fixed ring of four
+  // large asteroids and bump the wave — positions are deterministic (only speed
+  // is random), so assert those and the count, not the velocities.
+  it("waves system refills a cleared field with the large-asteroid ring", () => {
+    const db = createSystemDatabase();
+    projection.fromState(db.store, {
+      ...State.create(),
+      bounds: [200, 200],
+      ship: Ship.spawn([100, 100]),
+      asteroids: [],
+      wave: 0,
+    });
+    db.store.resources.frameDelta = 0.1;
+    db.transactions.setInput(Input.none);
+    driveFrame(db);
+
+    const after = projection.toState(db.store);
+    expect(after.wave).toBe(1);
+    expect(after.asteroids).toHaveLength(4);
+    expect(after.asteroids.every((a) => a.size === "large")).toBe(true);
+    const positions = after.asteroids.map((a) => [
+      Math.round(a.position[0]),
+      Math.round(a.position[1]),
+    ]);
+    expect(positions).toEqual(
+      expect.arrayContaining([
+        [180, 100],
+        [100, 180],
+        [20, 100],
+        [100, 20],
+      ]),
+    );
+  });
 });
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/create-initial.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/create-initial.ts
new file mode 100644
index 00000000..f5c7e9ce
--- /dev/null
+++ b/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/create-initial.ts
@@ -0,0 +1,17 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Vec2 } from "@adobe/data/math";
+import type { CoreDatabase } from "../../core-database/core-database.js";
+import { setBounds } from "./set-bounds.js";
+import { newGame } from "./new-game.js";
+
+// createInitial ⇄ State.createInitial: seed the play-field `bounds` the reset
+// reads, then start a fresh game. This single transaction realizes the
+// `createInitial` transition end-to-end so conformance can pair it by name;
+// `newGame`/`setBounds` remain the infra pieces the UI drives directly.
+export const createInitial = (
+  t: CoreDatabase.Store,
+  { bounds }: { bounds: Vec2 },
+): void => {
+  setBounds(t, bounds);
+  newGame(t);
+};
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/fire-bullet.test.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/fire-bullet.test.ts
deleted file mode 100644
index ecef0627..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/fire-bullet.test.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `fireBullet` conforms to `State.fireBullet`: it reads the seeded ship, defers
-// the muzzle kinematics to the transform, and inserts the bullet — leaving any
-// bullets already in flight untouched.
-import { describe } from "vitest";
-import { State } from "../../../../data/state/state.js";
-import { cases } from "../../../../data/state/fire-bullet.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { fireBullet } from "./fire-bullet.js";
-
-describe("fireBullet transaction conforms to State.fireBullet", () => {
-  expectConforms({
-    cases,
-    spec: State.fireBullet,
-    apply: fireBullet,
-  });
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/hit-asteroid.test.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/hit-asteroid.test.ts
deleted file mode 100644
index 38eaadf7..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/hit-asteroid.test.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `hitAsteroid` conforms to `State.resolveBulletHits`. The transform resolves
-// EVERY bullet's hit in one pass; the transaction resolves ONE (bullet,
-// asteroid) pair — the collision system dispatches it once per overlapping
-// bullet. The `apply` closure reproduces that dispatch loop: it resolves each
-// bullet's target from the seeded store (narrow-phase overlap, the same test
-// `resolveBulletHits` uses) and dispatches the transaction. Every shared case
-// keeps each bullet overlapping at most one asteroid, so the outcome is
-// order-independent and the whole per-bullet pass equals the transform.
-import { describe } from "vitest";
-import type { Entity } from "@adobe/data/ecs";
-import { Vec2 } from "@adobe/data/math";
-import { State } from "../../../../data/state/state.js";
-import { Collision } from "../../../../data/collision/collision.js";
-import { Bullet } from "../../../../data/bullet/bullet.js";
-import { Asteroid } from "../../../../data/asteroid/asteroid.js";
-import { cases } from "../../../../data/state/resolve-bullet-hits.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { hitAsteroid } from "./hit-asteroid.js";
-
-describe("hitAsteroid transaction conforms to State.resolveBulletHits", () => {
-  expectConforms({
-    cases,
-    spec: State.resolveBulletHits,
-    apply: (store, dt) => {
-      // Detect every (bullet, asteroid) pair FIRST, against the untouched store —
-      // so no child a split spawns this pass can be a target (and no reused entity
-      // id can alias one). Each asteroid is claimed by at most one bullet, matching
-      // resolveBulletHits (which splices the hit asteroid out). Detection is swept:
-      // reconstruct each bullet's path this frame (prev = position - velocity*dt)
-      // and test that segment, so a fast bullet cannot tunnel through. Then apply.
-      const asteroids: readonly Entity[] = [...store.select(store.archetypes.Asteroid.components)];
-      const claimed = new Set<Entity>();
-      const hits: { readonly bullet: Entity; readonly asteroid: Entity }[] = [];
-      for (const bullet of store.select(store.archetypes.Bullet.components)) {
-        const bulletRow = store.read(bullet, store.archetypes.Bullet);
-        if (bulletRow === null) continue;
-        const prev = Vec2.subtract(bulletRow.position, Vec2.scale(bulletRow.velocity, dt));
-        for (const asteroid of asteroids) {
-          if (claimed.has(asteroid)) continue;
-          const asteroidRow = store.read(asteroid, store.archetypes.Asteroid);
-          if (asteroidRow === null) continue;
-          if (
-            Collision.segmentCircleOverlap(
-              prev,
-              bulletRow.position,
-              asteroidRow.position,
-              Bullet.radius + Asteroid.radius(asteroidRow),
-            )
-          ) {
-            claimed.add(asteroid);
-            hits.push({ bullet, asteroid });
-            break;
-          }
-        }
-      }
-      for (const hit of hits) hitAsteroid(store, hit);
-    },
-  });
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/index.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/index.ts
index e1b725ab..650d1eb7 100644
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/index.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/index.ts
@@ -2,7 +2,8 @@
 export * from "./set-input.js";
 export * from "./set-bounds.js";
 export * from "./new-game.js";
-export * from "./spawn-wave.js";
+export * from "./create-initial.js";
+export * from "./spawn-random-wave.js";
 export * from "./fire-bullet.js";
 export * from "./hit-asteroid.js";
 export * from "./lose-life.js";
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/lose-life.test.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/lose-life.test.ts
deleted file mode 100644
index 3d659f28..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/lose-life.test.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `loseLife` conforms to `State.resolveShipHits`. The transform decides whether
-// the ship is struck AND applies the consequence; the transaction is only the
-// struck branch (spend a life, respawn at centre) — the collision system
-// dispatches it exactly when the ship overlaps an asteroid. The `apply` closure
-// reproduces that decision from the seeded store: it dispatches `loseLife` iff
-// the ship is struck, so the outcome equals the transform on every case
-// (struck, untouched, lives already zero, and the empty field).
-import { describe } from "vitest";
-import { State } from "../../../../data/state/state.js";
-import { Collision } from "../../../../data/collision/collision.js";
-import { Ship } from "../../../../data/ship/ship.js";
-import { Asteroid } from "../../../../data/asteroid/asteroid.js";
-import { cases } from "../../../../data/state/resolve-ship-hits.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { loseLife } from "./lose-life.js";
-
-describe("loseLife transaction conforms to State.resolveShipHits", () => {
-  expectConforms({
-    cases,
-    spec: State.resolveShipHits,
-    apply: (store) => {
-      const [shipId] = store.select(store.archetypes.Ship.components);
-      if (shipId === undefined) return;
-      const shipRow = store.read(shipId, store.archetypes.Ship);
-      if (shipRow === null) return;
-      let struck = false;
-      for (const asteroid of store.select(store.archetypes.Asteroid.components)) {
-        const asteroidRow = store.read(asteroid, store.archetypes.Asteroid);
-        if (asteroidRow === null) continue;
-        if (
-          Collision.circlesOverlap(
-            shipRow.position,
-            Ship.radius,
-            asteroidRow.position,
-            Asteroid.radius(asteroidRow),
-          )
-        ) {
-          struck = true;
-          break;
-        }
-      }
-      if (struck) loseLife(store);
-    },
-  });
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/new-game.test.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/new-game.test.ts
deleted file mode 100644
index 81904dd7..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/new-game.test.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `newGame` conforms to `State.createInitial`: dispatched over the shared cases,
-// the seeded store (deliberately dirty) is cleared and rebuilt into the fresh
-// game the transform computes from the bounds alone.
-import { describe } from "vitest";
-import { State } from "../../../../data/state/state.js";
-import { cases } from "../../../../data/state/create-initial.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { setBounds } from "./set-bounds.js";
-import { newGame } from "./new-game.js";
-
-describe("newGame conforms to State.createInitial", () => {
-  expectConforms({
-    cases,
-    spec: (_before, bounds) => State.createInitial(bounds),
-    apply: (store, bounds) => {
-      setBounds(store, bounds);
-      newGame(store);
-    },
-  });
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/new-game.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/new-game.ts
index d806df22..c1be62db 100644
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/new-game.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/new-game.ts
@@ -8,7 +8,7 @@ import { clearEntities } from "./clear-entities.js";
 // the ship, and spawn the first wave. `bounds` is preserved — it is set by the
 // UI on canvas resize, not part of the reset.
 export const newGame = (t: CoreDatabase.Store): void => {
-  const initial = State.createInitial(t.resources.bounds);
+  const initial = State.createInitial(State.create(), { bounds: t.resources.bounds });
   clearEntities(t);
   t.resources.score = initial.score;
   t.resources.lives = initial.lives;
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/set-bounds.test.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/set-bounds.test.ts
deleted file mode 100644
index c50038e6..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/set-bounds.test.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `setBounds` has no `data/` transform to conform to — it only records the
-// play-field size resource — so it gets a direct resource assertion.
-import { describe, it, expect } from "vitest";
-import { createStore } from "../../conformance/create-store.js";
-import { setBounds } from "./set-bounds.js";
-
-describe("setBounds", () => {
-  it("writes the dispatched bounds to the resource verbatim", () => {
-    const store = createStore();
-    setBounds(store, [800, 600]);
-    expect(store.resources.bounds).toEqual([800, 600]);
-  });
-
-  it("overwrites a previously set bounds (e.g. on canvas resize)", () => {
-    const store = createStore();
-    setBounds(store, [800, 600]);
-    setBounds(store, [1024, 768]);
-    expect(store.resources.bounds).toEqual([1024, 768]);
-  });
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/set-input.test.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/set-input.test.ts
deleted file mode 100644
index 77ff15af..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/set-input.test.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `setInput` has no `data/` transform to conform to — it only records the
-// player's intent resource — so it gets a direct resource assertion.
-import { describe, it, expect } from "vitest";
-import { createStore } from "../../conformance/create-store.js";
-import { setInput } from "./set-input.js";
-
-describe("setInput", () => {
-  it("writes the dispatched input to the resource verbatim", () => {
-    const store = createStore();
-    const input = { turn: 1, thrust: true, fire: false };
-    setInput(store, input);
-    expect(store.resources.input).toEqual(input);
-  });
-
-  it("overwrites a previously set input", () => {
-    const store = createStore();
-    setInput(store, { turn: 1, thrust: true, fire: true });
-    setInput(store, { turn: -1, thrust: false, fire: false });
-    expect(store.resources.input).toEqual({ turn: -1, thrust: false, fire: false });
-  });
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/spawn-random-wave.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/spawn-random-wave.ts
new file mode 100644
index 00000000..24252c21
--- /dev/null
+++ b/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/spawn-random-wave.ts
@@ -0,0 +1,30 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { State } from "../../../../data/state/state.js";
+import type { CoreDatabase } from "../../core-database/core-database.js";
+import { RandomService } from "../../../random-service/random-service.js";
+import { readAsteroids } from "./read-asteroids.js";
+
+// Advance to the next wave with a randomized layout. Thin wrapper over
+// State.spawnRandomWave: project the {asteroids, wave, bounds} slice, let the
+// data/ transform decide the count and per-rock drift with the INJECTED `random`
+// service, then bump `wave` and insert the spawned rocks. The transform is a
+// no-op while the field still has asteroids (returns the same object), so
+// dispatching mid-wave changes nothing. The `waves` system supplies the real
+// random source; tests inject RandomService.createFake for exact assertions.
+export const spawnRandomWave = (
+  t: CoreDatabase.Store,
+  { random }: { random: RandomService },
+): void => {
+  // spawnRandomWave is a no-op while the field still has asteroids; guard here so
+  // a mid-wave dispatch inserts nothing (the patch return is a fresh object, so it
+  // can no longer be reference-compared to detect the no-op).
+  if (readAsteroids(t).length > 0) return;
+  const after = State.spawnRandomWave(
+    { asteroids: [], wave: t.resources.wave, bounds: t.resources.bounds },
+    { random },
+  );
+  t.resources.wave = after.wave;
+  for (const asteroid of after.asteroids) {
+    t.archetypes.Asteroid.insert(asteroid);
+  }
+};
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/spawn-wave.test.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/spawn-wave.test.ts
deleted file mode 100644
index 98d51ded..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/spawn-wave.test.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `spawnWave` conforms to `State.spawnWave`: it reads the field/wave/bounds from
-// the seeded store, defers the count and ring layout to the transform, and
-// inserts the result — a no-op while asteroids remain.
-import { describe } from "vitest";
-import { State } from "../../../../data/state/state.js";
-import { cases } from "../../../../data/state/spawn-wave.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { spawnWave } from "./spawn-wave.js";
-
-describe("spawnWave transaction conforms to State.spawnWave", () => {
-  expectConforms({
-    cases,
-    spec: State.spawnWave,
-    apply: spawnWave,
-  });
-});
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/spawn-wave.ts b/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/spawn-wave.ts
deleted file mode 100644
index 3429788b..00000000
--- a/packages/data-lit-space-rock-game/src/features/main/services/main-service/transaction-database/transactions/spawn-wave.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { State } from "../../../../data/state/state.js";
-import type { CoreDatabase } from "../../core-database/core-database.js";
-import { readAsteroids } from "./read-asteroids.js";
-
-// Advance to the next wave. Thin wrapper over State.spawnWave: project the
-// {asteroids, wave, bounds} slice, let the data/ transform decide the count and
-// ring layout, then bump `wave` and insert the spawned rocks. The transform is
-// a no-op while the field still has asteroids (returns the same object), so
-// dispatching mid-wave changes nothing.
-export const spawnWave = (t: CoreDatabase.Store): void => {
-  const before = {
-    asteroids: readAsteroids(t),
-    wave: t.resources.wave,
-    bounds: t.resources.bounds,
-  };
-  const after = State.spawnWave(before);
-  if (after === before) return;
-  t.resources.wave = after.wave;
-  for (const asteroid of after.asteroids) {
-    t.archetypes.Asteroid.insert(asteroid);
-  }
-};
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/random-service/create-fake.ts b/packages/data-lit-space-rock-game/src/features/main/services/random-service/create-fake.ts
new file mode 100644
index 00000000..cfe42b18
--- /dev/null
+++ b/packages/data-lit-space-rock-game/src/features/main/services/random-service/create-fake.ts
@@ -0,0 +1,23 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { RandomService } from "./random-service.js";
+
+/**
+ * Deterministic test double for {@link RandomService}. Unlike the real source it
+ * uses no `Math.random`: `next` returns the `sequence` in order, cycling once
+ * exhausted. A case that needs specific draws passes its own `sequence`; the
+ * default is a harmless placeholder. This is the implementation tests inject so
+ * their assertions are predictable — see `features/services/index.md`.
+ */
+export const createFake = (
+  sequence: readonly number[] = [0],
+): RandomService => {
+  let index = 0;
+  return {
+    serviceName: "random",
+    next: () => {
+      const value = sequence[index % sequence.length];
+      index += 1;
+      return value;
+    },
+  };
+};
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/random-service/create.ts b/packages/data-lit-space-rock-game/src/features/main/services/random-service/create.ts
new file mode 100644
index 00000000..4231c898
--- /dev/null
+++ b/packages/data-lit-space-rock-game/src/features/main/services/random-service/create.ts
@@ -0,0 +1,13 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { RandomService } from "./random-service.js";
+
+/**
+ * The production random source: `next` delegates to `Math.random`. The ECS
+ * `waves` system constructs this once and injects it into the `spawnRandomWave`
+ * transaction, so live waves vary run to run. Tests inject
+ * {@link RandomService.createFake} instead.
+ */
+export const create = (): RandomService => ({
+  serviceName: "random",
+  next: () => Math.random(),
+});
diff --git a/packages/data-lit-todo/src/features/main/services/todo-analytics-service/public.ts b/packages/data-lit-space-rock-game/src/features/main/services/random-service/public.ts
similarity index 66%
rename from packages/data-lit-todo/src/features/main/services/todo-analytics-service/public.ts
rename to packages/data-lit-space-rock-game/src/features/main/services/random-service/public.ts
index 6523855b..56c941d3 100644
--- a/packages/data-lit-todo/src/features/main/services/todo-analytics-service/public.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/services/random-service/public.ts
@@ -1,2 +1,3 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 export { create } from "./create.js";
+export { createFake } from "./create-fake.js";
diff --git a/packages/data-lit-space-rock-game/src/features/main/services/random-service/random-service.ts b/packages/data-lit-space-rock-game/src/features/main/services/random-service/random-service.ts
new file mode 100644
index 00000000..0af3247f
--- /dev/null
+++ b/packages/data-lit-space-rock-game/src/features/main/services/random-service/random-service.ts
@@ -0,0 +1,20 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Service } from "@adobe/data/service";
+
+/**
+ * Capability port that supplies pseudo-randomness to pure transitions. `next`
+ * returns a number in `[0, 1)`, exactly like `Math.random`.
+ *
+ * Unlike the async capability contracts (`services/index.md` — network, model,
+ * persistence ports whose members are async so they can cross a process
+ * boundary), randomness has no outside-world latency, so this port is
+ * intentionally **synchronous**: a transition that injects it
+ * (`State.spawnRandomWave`) stays synchronous, and the game loop never awaits a
+ * random number. It is still the seam consumers swap out under test — inject
+ * {@link RandomService.createFake} and the transition becomes deterministic.
+ */
+export interface RandomService extends Service {
+  next: () => number;
+}
+
+export * as RandomService from "./public.js";
diff --git a/packages/data-lit-space-rock-game/src/features/main/ui/space-rock-game/space-rock-game-element.ts b/packages/data-lit-space-rock-game/src/features/main/ui/space-rock-game/space-rock-game-element.ts
index aa343bfe..6cfa6973 100644
--- a/packages/data-lit-space-rock-game/src/features/main/ui/space-rock-game/space-rock-game-element.ts
+++ b/packages/data-lit-space-rock-game/src/features/main/ui/space-rock-game/space-rock-game-element.ts
@@ -11,7 +11,7 @@ import {
   useRef,
   useWindowEvent,
 } from "@adobe/data-lit";
-import { FeatureDatabase } from "../../services/main-service/feature-database.js";
+import { MainService } from "../../services/main-service/main-service.js";
 import type { Input } from "../../data/input/input.js";
 import type { Size } from "../../data/size/size.js";
 import { styles } from "./space-rock-game.css.js";
@@ -45,7 +45,7 @@ const toInput = (held: Held, fire: boolean): Input => ({
 // render bridge, not game logic: the scheduler advances the sim on its own rAF,
 // mostly via in-place column writes that never fire observers, so the canvas
 // must read the current columns synchronously each frame rather than subscribe.
-const buildScene = (game: FeatureDatabase) => {
+const buildScene = (game: MainService) => {
   const ships: { position: Vec2; rotation: number }[] = [];
   for (const arch of game.queryArchetypes(["position", "rotation"])) {
     const position = arch.columns.position;
@@ -73,11 +73,11 @@ const buildScene = (game: FeatureDatabase) => {
 };
 
 @customElement(tagName)
-export class SpaceRockGameElement extends DatabaseElement<typeof FeatureDatabase.plugin> {
+export class SpaceRockGameElement extends DatabaseElement<typeof MainService.plugin> {
   static styles = styles;
 
   get plugin() {
-    return FeatureDatabase.plugin;
+    return MainService.plugin;
   }
 
   render() {
diff --git a/packages/data-lit-space-rock-game/src/index.ts b/packages/data-lit-space-rock-game/src/index.ts
index b9a8213b..7cb9ef87 100644
--- a/packages/data-lit-space-rock-game/src/index.ts
+++ b/packages/data-lit-space-rock-game/src/index.ts
@@ -7,7 +7,7 @@
 // consumers (per the cross-feature naming rule). Carries `.plugin` (schema +
 // indexes + transactions + computed, combined with the built-in rAF scheduler)
 // and `.Store` for consumers that build their own database from it.
-export { FeatureDatabase as SpaceRockGameDatabase } from "./features/main/services/main-service/feature-database.js";
+export { MainService as SpaceRockGameMainService } from "./features/main/services/main-service/main-service.js";
 
 export { SpaceRockGame } from "./features/main/ui/space-rock-game/space-rock-game.js";
 export { SpaceRockGameElement } from "./features/main/ui/space-rock-game/space-rock-game-element.js";
diff --git a/packages/data-lit-space-rock-game/src/main.ts b/packages/data-lit-space-rock-game/src/main.ts
index 9d7f51a9..d423f1f6 100644
--- a/packages/data-lit-space-rock-game/src/main.ts
+++ b/packages/data-lit-space-rock-game/src/main.ts
@@ -3,7 +3,7 @@
 import { render } from "lit";
 import { Database } from "@adobe/data/ecs";
 import { SpaceRockGame } from "./features/main/ui/space-rock-game/space-rock-game.js";
-import { FeatureDatabase } from "./features/main/services/main-service/feature-database.js";
+import { MainService } from "./features/main/services/main-service/main-service.js";
 
 const app = document.getElementById("app");
 if (app) {
@@ -11,6 +11,6 @@ if (app) {
   // combined with the built-in rAF scheduler). Built once here and passed to
   // the lazy wrapper via its `.service` seam so the upgraded element receives
   // the ticking database.
-  const service = Database.create(FeatureDatabase.plugin);
+  const service = Database.create(MainService.plugin);
   render(SpaceRockGame({ service }), app);
 }
diff --git a/packages/data-lit-tictactoe/package.json b/packages/data-lit-tictactoe/package.json
index 8c168905..b17cb3d1 100644
--- a/packages/data-lit-tictactoe/package.json
+++ b/packages/data-lit-tictactoe/package.json
@@ -1,6 +1,6 @@
 {
   "name": "data-lit-tictactoe",
-  "version": "0.9.92",
+  "version": "0.9.93",
   "description": "Tic-Tac-Toe sample - Lit web components with @adobe/data-lit and AgenticService",
   "type": "module",
   "private": true,
diff --git a/packages/data-lit-tictactoe/src/features/main/data/board-cell/blank.test.ts b/packages/data-lit-tictactoe/src/features/main/data/board-cell/blank.test.ts
new file mode 100644
index 00000000..af1d3414
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/board-cell/blank.test.ts
@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { blank } from "./blank.js";
+
+describe("blank", () => {
+  it("is the single-space unplayed-cell character", () => {
+    expect(blank).toBe(" ");
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/board-state/create-initial-board.test.ts b/packages/data-lit-tictactoe/src/features/main/data/board-state/create-initial-board.test.ts
new file mode 100644
index 00000000..3144596b
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/board-state/create-initial-board.test.ts
@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { createInitialBoard } from "./create-initial-board.js";
+
+describe("createInitialBoard", () => {
+  it("is nine blank cells", () => {
+    expect(createInitialBoard()).toBe("         ");
+    expect(createInitialBoard()).toHaveLength(9);
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/board-state/current-player.test.ts b/packages/data-lit-tictactoe/src/features/main/data/board-state/current-player.test.ts
new file mode 100644
index 00000000..c3aaa8dc
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/board-state/current-player.test.ts
@@ -0,0 +1,20 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { currentPlayer } from "./current-player.js";
+
+describe("currentPlayer", () => {
+  it("is the first player on an empty board", () => {
+    expect(currentPlayer("         ", "X")).toBe("X");
+  });
+
+  it("alternates after each move (first player X)", () => {
+    expect(currentPlayer("X        ", "X")).toBe("O");
+    expect(currentPlayer("XO       ", "X")).toBe("X");
+  });
+
+  it("honors a non-default first player", () => {
+    expect(currentPlayer("         ", "O")).toBe("O");
+    expect(currentPlayer("O        ", "O")).toBe("X");
+    expect(currentPlayer("OX       ", "O")).toBe("O");
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/board-state/derive-status.test.ts b/packages/data-lit-tictactoe/src/features/main/data/board-state/derive-status.test.ts
new file mode 100644
index 00000000..f029431b
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/board-state/derive-status.test.ts
@@ -0,0 +1,21 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { deriveStatus } from "./derive-status.js";
+
+describe("deriveStatus", () => {
+  it("is idle on an empty board", () => {
+    expect(deriveStatus("         ")).toBe("idle");
+  });
+
+  it("is in_progress once a mark is placed with no winner", () => {
+    expect(deriveStatus("X        ")).toBe("in_progress");
+  });
+
+  it("is won when a line is complete", () => {
+    expect(deriveStatus("XXXOO    ")).toBe("won");
+  });
+
+  it("is draw when the board is full with no winner", () => {
+    expect(deriveStatus("XOXXOOOXX")).toBe("draw");
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/board-state/from-marks.test.ts b/packages/data-lit-tictactoe/src/features/main/data/board-state/from-marks.test.ts
new file mode 100644
index 00000000..27cae201
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/board-state/from-marks.test.ts
@@ -0,0 +1,19 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { fromMarks } from "./from-marks.js";
+
+describe("fromMarks", () => {
+  it("is a blank board for no marks", () => {
+    expect(fromMarks([])).toBe("         ");
+  });
+
+  it("projects marks into their index-addressed cells", () => {
+    expect(
+      fromMarks([
+        { mark: "X", index: 0 },
+        { mark: "O", index: 4 },
+        { mark: "X", index: 8 },
+      ]),
+    ).toBe("X   O   X");
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/board-state/get-move-count.test.ts b/packages/data-lit-tictactoe/src/features/main/data/board-state/get-move-count.test.ts
new file mode 100644
index 00000000..46450a7c
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/board-state/get-move-count.test.ts
@@ -0,0 +1,14 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { getMoveCount } from "./get-move-count.js";
+
+describe("getMoveCount", () => {
+  it("is zero for an empty board", () => {
+    expect(getMoveCount("         ")).toBe(0);
+  });
+
+  it("counts both players' marks", () => {
+    expect(getMoveCount("XO       ")).toBe(2);
+    expect(getMoveCount("XOXXOOOXX")).toBe(9);
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/board-state/get-winner.test.ts b/packages/data-lit-tictactoe/src/features/main/data/board-state/get-winner.test.ts
new file mode 100644
index 00000000..034f055e
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/board-state/get-winner.test.ts
@@ -0,0 +1,33 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { getWinner } from "./get-winner.js";
+
+describe("getWinner", () => {
+  it("is null on an empty board", () => {
+    expect(getWinner("         ")).toBeNull();
+  });
+
+  it("is null while the game is still in progress", () => {
+    expect(getWinner("XO       ")).toBeNull();
+  });
+
+  it("returns the mark that completes a row", () => {
+    expect(getWinner("XXXOO    ")).toBe("X");
+  });
+
+  it("returns the mark that completes a column", () => {
+    expect(getWinner("XO XO X  ")).toBe("X");
+  });
+
+  it("returns the mark that completes a diagonal", () => {
+    expect(getWinner("XO OX   X")).toBe("X");
+  });
+
+  it("returns O when O wins", () => {
+    expect(getWinner("OOOXX    ")).toBe("O");
+  });
+
+  it("is 'cat' when the board is full with no winner", () => {
+    expect(getWinner("XOXXOOOXX")).toBe("cat");
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/board-state/get-winning-line.test.ts b/packages/data-lit-tictactoe/src/features/main/data/board-state/get-winning-line.test.ts
new file mode 100644
index 00000000..9f40dee7
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/board-state/get-winning-line.test.ts
@@ -0,0 +1,26 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { getWinningLine } from "./get-winning-line.js";
+
+describe("getWinningLine", () => {
+  it("is null when there is no completed line", () => {
+    expect(getWinningLine("         ")).toBeNull();
+    expect(getWinningLine("XO       ")).toBeNull();
+  });
+
+  it("finds a winning row", () => {
+    expect(getWinningLine("XXXOO    ")).toEqual([0, 1, 2]);
+  });
+
+  it("finds a winning column", () => {
+    expect(getWinningLine("XO XO X  ")).toEqual([0, 3, 6]);
+  });
+
+  it("finds a top-left-to-bottom-right diagonal", () => {
+    expect(getWinningLine("XO OX   X")).toEqual([0, 4, 8]);
+  });
+
+  it("finds a top-right-to-bottom-left diagonal", () => {
+    expect(getWinningLine("OOXXX X  ")).toEqual([2, 4, 6]);
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/board-state/is-board-full.test.ts b/packages/data-lit-tictactoe/src/features/main/data/board-state/is-board-full.test.ts
new file mode 100644
index 00000000..de5c19ad
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/board-state/is-board-full.test.ts
@@ -0,0 +1,17 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { isBoardFull } from "./is-board-full.js";
+
+describe("isBoardFull", () => {
+  it("is false for an empty board", () => {
+    expect(isBoardFull("         ")).toBe(false);
+  });
+
+  it("is false while any cell is blank", () => {
+    expect(isBoardFull("XOXXOOOX ")).toBe(false);
+  });
+
+  it("is true when every cell is filled", () => {
+    expect(isBoardFull("XOXXOOOXX")).toBe(true);
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/board-state/is-game-over.test.ts b/packages/data-lit-tictactoe/src/features/main/data/board-state/is-game-over.test.ts
new file mode 100644
index 00000000..e3a2b855
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/board-state/is-game-over.test.ts
@@ -0,0 +1,21 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { isGameOver } from "./is-game-over.js";
+
+describe("isGameOver", () => {
+  it("is false on an empty board", () => {
+    expect(isGameOver("         ")).toBe(false);
+  });
+
+  it("is false while the game is in progress", () => {
+    expect(isGameOver("XO       ")).toBe(false);
+  });
+
+  it("is true when there is a winning line", () => {
+    expect(isGameOver("XXXOO    ")).toBe(true);
+  });
+
+  it("is true when the board is full (draw)", () => {
+    expect(isGameOver("XOXXOOOXX")).toBe(true);
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/board-state/set-board-cell.test.ts b/packages/data-lit-tictactoe/src/features/main/data/board-state/set-board-cell.test.ts
new file mode 100644
index 00000000..b4ade5a4
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/board-state/set-board-cell.test.ts
@@ -0,0 +1,23 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { setBoardCell } from "./set-board-cell.js";
+
+describe("setBoardCell", () => {
+  it("places a mark at the first cell", () => {
+    expect(setBoardCell({ board: "         ", index: 0, mark: "X" })).toBe(
+      "X        ",
+    );
+  });
+
+  it("places a mark at the last cell", () => {
+    expect(setBoardCell({ board: "         ", index: 8, mark: "O" })).toBe(
+      "        O",
+    );
+  });
+
+  it("leaves the other cells untouched", () => {
+    expect(setBoardCell({ board: "X   O    ", index: 4, mark: "X" })).toBe(
+      "X   X    ",
+    );
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/game-status/is-active.test.ts b/packages/data-lit-tictactoe/src/features/main/data/game-status/is-active.test.ts
new file mode 100644
index 00000000..1c432c26
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/game-status/is-active.test.ts
@@ -0,0 +1,15 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { isActive } from "./is-active.js";
+
+describe("isActive", () => {
+  it("is true while the game still accepts moves", () => {
+    expect(isActive("idle")).toBe(true);
+    expect(isActive("in_progress")).toBe(true);
+  });
+
+  it("is false once the game has ended", () => {
+    expect(isActive("won")).toBe(false);
+    expect(isActive("draw")).toBe(false);
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/play-move-args/can-play-move.test.ts b/packages/data-lit-tictactoe/src/features/main/data/play-move-args/can-play-move.test.ts
new file mode 100644
index 00000000..2f7047df
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/play-move-args/can-play-move.test.ts
@@ -0,0 +1,38 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { canPlayMove } from "./can-play-move.js";
+
+describe("canPlayMove", () => {
+  it("allows a move into a blank cell of an in-progress game", () => {
+    expect(canPlayMove({ board: "         ", index: 4 })).toEqual({ ok: true });
+  });
+
+  it("rejects a non-integer, negative, or too-large index", () => {
+    expect(canPlayMove({ board: "         ", index: 1.5 })).toEqual({
+      ok: false,
+      reason: "index_out_of_bounds",
+    });
+    expect(canPlayMove({ board: "         ", index: -1 })).toEqual({
+      ok: false,
+      reason: "index_out_of_bounds",
+    });
+    expect(canPlayMove({ board: "         ", index: 9 })).toEqual({
+      ok: false,
+      reason: "index_out_of_bounds",
+    });
+  });
+
+  it("rejects a move once the game is over", () => {
+    expect(canPlayMove({ board: "XXXOO    ", index: 5 })).toEqual({
+      ok: false,
+      reason: "game_over",
+    });
+  });
+
+  it("rejects a move into an occupied cell", () => {
+    expect(canPlayMove({ board: "X        ", index: 0 })).toEqual({
+      ok: false,
+      reason: "cell_occupied",
+    });
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/player-mark/is.test.ts b/packages/data-lit-tictactoe/src/features/main/data/player-mark/is.test.ts
new file mode 100644
index 00000000..ec165e28
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/player-mark/is.test.ts
@@ -0,0 +1,17 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { is } from "./is.js";
+
+describe("is", () => {
+  it("accepts the two player marks", () => {
+    expect(is("X")).toBe(true);
+    expect(is("O")).toBe(true);
+  });
+
+  it("rejects anything else", () => {
+    expect(is(" ")).toBe(false);
+    expect(is("x")).toBe(false);
+    expect(is(1)).toBe(false);
+    expect(is(null)).toBe(false);
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/player-mark/mark-color.test.ts b/packages/data-lit-tictactoe/src/features/main/data/player-mark/mark-color.test.ts
new file mode 100644
index 00000000..6e557cac
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/player-mark/mark-color.test.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { markColor } from "./mark-color.js";
+
+describe("markColor", () => {
+  it("has a distinct colour string for each mark", () => {
+    expect(typeof markColor.X).toBe("string");
+    expect(typeof markColor.O).toBe("string");
+    expect(markColor.X).not.toBe(markColor.O);
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/player-mark/opponent.test.ts b/packages/data-lit-tictactoe/src/features/main/data/player-mark/opponent.test.ts
new file mode 100644
index 00000000..28841748
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/player-mark/opponent.test.ts
@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { opponent } from "./opponent.js";
+
+describe("opponent", () => {
+  it("maps each mark to the other", () => {
+    expect(opponent.X).toBe("O");
+    expect(opponent.O).toBe("X");
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/player-mark/values.test.ts b/packages/data-lit-tictactoe/src/features/main/data/player-mark/values.test.ts
new file mode 100644
index 00000000..12219fb2
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/player-mark/values.test.ts
@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { values } from "./values.js";
+
+describe("values", () => {
+  it("is the two player marks", () => {
+    expect(values).toEqual(["X", "O"]);
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/state/conformance-case.ts b/packages/data-lit-tictactoe/src/features/main/data/state/conformance-case.ts
index 44e5a8a5..0b87028e 100644
--- a/packages/data-lit-tictactoe/src/features/main/data/state/conformance-case.ts
+++ b/packages/data-lit-tictactoe/src/features/main/data/state/conformance-case.ts
@@ -1,13 +1,14 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Conformance as ConformanceApi } from "@adobe/data/testing";
 import type { State } from "./state.js";
 
-// One spec-owned conformance case: a `data/` transform's `{ before, args, after }`
-// authored as full `State`. Lives in `<transform>.cases.ts` and is shared,
-// unchanged, by the data transform test and the ecs conformance runner
-// (see `ecs/conformance/`).
-export type ConformanceCase<Args> = {
-  readonly name: string;
-  readonly before: State;
-  readonly args: Args;
-  readonly after: State;
-};
+// The conformance case types for this feature — the shared `@adobe/data/testing`
+// machinery with `State` bound once, so a transform authors `Conformance<typeof fn>`
+// and a derivation `Derivation<typeof fn>` (args/input/value read from the
+// function's own signature). This tiny file is the only per-feature conformance
+// type declaration; everything else lives in `@adobe/data/testing`.
+export type Conformance<F extends (...args: never[]) => unknown> =
+  ConformanceApi.Cases<State, F>;
+export type Derivation<F extends (...args: never[]) => unknown> =
+  ConformanceApi.DerivationCases<F>;
+export type Effects<Args> = ConformanceApi.Effects<Args>;
diff --git a/packages/data-lit-tictactoe/src/features/main/data/state/create.ts b/packages/data-lit-tictactoe/src/features/main/data/state/create.ts
new file mode 100644
index 00000000..5f3f275f
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/state/create.ts
@@ -0,0 +1,14 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { BoardState } from "../board-state/board-state.js";
+import type { State } from "./state.js";
+
+// The default game state: an empty board, X to move first, a zeroed scoreboard.
+// It is the baseline the conformance cases author their `before`/`input` as deltas
+// over (passed to the runners as `initial`), and the state a fresh game starts in.
+export const create = (): State => ({
+  board: BoardState.createInitialBoard(),
+  firstPlayer: "X",
+  xWins: 0,
+  oWins: 0,
+  draws: 0,
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/state/current-player.ts b/packages/data-lit-tictactoe/src/features/main/data/state/current-player.ts
new file mode 100644
index 00000000..678d2288
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/state/current-player.ts
@@ -0,0 +1,51 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { BoardState } from "../board-state/board-state.js";
+import type { PlayerMark } from "../player-mark/player-mark.js";
+import type { State } from "./state.js";
+import type { Derivation } from "./conformance-case.js";
+
+// Whose turn it is: composes TWO `State` fields — the board (move count) and the
+// `firstPlayer` — so it is a `state/` derivation, not single-field board math
+// (see `data/state.md`). The mark-counting itself is the board's own helper
+// (`BoardState.currentPlayer`), which the ecs implementation reuses directly; this
+// derivation is the spec the ecs `currentPlayer` computed is conformed against.
+export const currentPlayer = (
+  state: Pick<State, "board" | "firstPlayer">,
+): PlayerMark => BoardState.currentPlayer(state.board, state.firstPlayer);
+
+// Spec-owned cases, shared with the ecs `currentPlayer` computed. A derivation
+// case is `{ input, value }`; `input` is a full `State`, `value` the mark to move.
+export const cases: Derivation<typeof currentPlayer> = [
+  {
+    name: "the first player moves on an empty board",
+    input: {
+      board: "         ",
+      firstPlayer: "X",
+    },
+    value: "X",
+  },
+  {
+    name: "honors a first player of O on an empty board",
+    input: {
+      board: "         ",
+      firstPlayer: "O",
+    },
+    value: "O",
+  },
+  {
+    name: "alternates to the opponent after the first move",
+    input: {
+      board: "    X    ",
+      firstPlayer: "X",
+    },
+    value: "O",
+  },
+  {
+    name: "returns to the first player after both have moved",
+    input: {
+      board: "XO       ",
+      firstPlayer: "X",
+    },
+    value: "X",
+  },
+];
diff --git a/packages/data-lit-tictactoe/src/features/main/data/state/expect-state-matches.ts b/packages/data-lit-tictactoe/src/features/main/data/state/expect-state-matches.ts
deleted file mode 100644
index 0b9bfa27..00000000
--- a/packages/data-lit-tictactoe/src/features/main/data/state/expect-state-matches.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { expect } from "vitest";
-import { equalsUnordered } from "@adobe/data";
-import type { State } from "./state.js";
-
-// Spec-owned tolerant `State` equality, shared by the data/ transform tests and
-// the ecs conformance runner. Two orthogonal concerns, kept separate:
-//
-//   precision — normalise every number on both sides onto a shared grid, so a
-//     value that differs only by F32↔f64 storage rounding compares equal.
-//     `Math.fround` collapses the F32 rounding; rounding to 1e-2 collapses any
-//     residual epsilon. `+ 0` normalises `-0` to `0`. (Tic-tac-toe's scalars are
-//     integer counters and the board is a string, so this is a no-op here — kept
-//     to mirror the shared pattern and stay robust if a float field is added.)
-//   ordering — `equalsUnordered` compares arrays as MULTISETS (archetype
-//     hole-fills make row order nondeterministic) and is object key-order
-//     independent.
-const quantize = (n: number): number => Math.round(Math.fround(n) * 100) / 100 + 0;
-
-const normalize = (value: unknown): unknown => {
-  if (typeof value === "number") return quantize(value);
-  if (Array.isArray(value)) return value.map(normalize);
-  if (value !== null && typeof value === "object") {
-    return Object.fromEntries(Object.entries(value).map(([key, v]) => [key, normalize(v)]));
-  }
-  return value;
-};
-
-export const expectStateMatches = (actual: State, expected: State): void => {
-  const a = normalize(actual);
-  const b = normalize(expected);
-  expect(
-    equalsUnordered(a, b),
-    `State mismatch:\n  actual   ${JSON.stringify(a)}\n  expected ${JSON.stringify(b)}`,
-  ).toBe(true);
-};
diff --git a/packages/data-lit-tictactoe/src/features/main/data/state/play-move.cases.ts b/packages/data-lit-tictactoe/src/features/main/data/state/play-move.cases.ts
deleted file mode 100644
index aba06511..00000000
--- a/packages/data-lit-tictactoe/src/features/main/data/state/play-move.cases.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { PlayMoveArgs } from "../play-move-args/play-move-args.js";
-import type { ConformanceCase } from "./conformance-case.js";
-
-// Spec-owned `{ before, args, after }` cases for `State.playMove`, shared with
-// the ecs `playMove` transaction. Covers every branch of the move guard —
-// a legal placement, turn alternation by move count, a winning placement, plus
-// the three rejections (occupied cell, out of bounds, game already over) that
-// each leave the state unchanged.
-export const cases: readonly ConformanceCase<PlayMoveArgs>[] = [
-  {
-    name: "places the first player's mark into an empty cell",
-    before: { board: "         ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
-    args: { index: 4 },
-    after: { board: "    X    ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
-  },
-  {
-    name: "alternates to the opponent by move count",
-    before: { board: "    X    ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
-    args: { index: 0 },
-    after: { board: "O   X    ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
-  },
-  {
-    name: "completes a three-in-a-row (winning placement is still just a placement)",
-    before: { board: "XX  OO   ", firstPlayer: "X", xWins: 1, oWins: 2, draws: 0 },
-    args: { index: 2 },
-    after: { board: "XXX OO   ", firstPlayer: "X", xWins: 1, oWins: 2, draws: 0 },
-  },
-  {
-    name: "ignores an occupied cell (no-op)",
-    before: { board: "    X    ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
-    args: { index: 4 },
-    after: { board: "    X    ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
-  },
-  {
-    name: "ignores an out-of-bounds index (no-op)",
-    before: { board: "         ", firstPlayer: "O", xWins: 0, oWins: 0, draws: 0 },
-    args: { index: 9 },
-    after: { board: "         ", firstPlayer: "O", xWins: 0, oWins: 0, draws: 0 },
-  },
-  {
-    name: "ignores a move once the game is already won (no-op)",
-    before: { board: "XXX      ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
-    args: { index: 4 },
-    after: { board: "XXX      ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
-  },
-];
diff --git a/packages/data-lit-tictactoe/src/features/main/data/state/play-move.test.ts b/packages/data-lit-tictactoe/src/features/main/data/state/play-move.test.ts
deleted file mode 100644
index 0d1f24e4..00000000
--- a/packages/data-lit-tictactoe/src/features/main/data/state/play-move.test.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./play-move.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.playMove", () => {
-  for (const { name, before, args, after } of cases) {
-    it(name, () => {
-      expectStateMatches(State.playMove(before, args), after);
-    });
-  }
-});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/state/play-move.ts b/packages/data-lit-tictactoe/src/features/main/data/state/play-move.ts
index 025f8274..fe19e08c 100644
--- a/packages/data-lit-tictactoe/src/features/main/data/state/play-move.ts
+++ b/packages/data-lit-tictactoe/src/features/main/data/state/play-move.ts
@@ -2,19 +2,70 @@
 import { BoardState } from "../board-state/board-state.js";
 import { PlayMoveArgs } from "../play-move-args/play-move-args.js";
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
 
-// Place the current player's mark into `index`. Illegal moves (out of bounds,
-// occupied, game over) are ignored, keeping the transform idempotent.
-export const playMove = <T extends Pick<State, "board" | "firstPlayer">>(
-  state: T,
+// Place the current player's mark into `index`. Reads the board + first player,
+// writes the board — a `{ board }` patch. Illegal moves (out of bounds, occupied,
+// game over) leave the board unchanged, keeping the transform idempotent.
+export const playMove = (
+  state: Pick<State, "board" | "firstPlayer">,
   input: PlayMoveArgs,
-): T => {
-  if (!PlayMoveArgs.canPlayMove({ board: state.board, index: input.index }).ok) {
-    return state;
+): Pick<State, "board"> => {
+  if (
+    !PlayMoveArgs.canPlayMove({ board: state.board, index: input.index }).ok
+  ) {
+    return { board: state.board };
   }
   const mark = BoardState.currentPlayer(state.board, state.firstPlayer);
   return {
-    ...state,
-    board: BoardState.setBoardCell({ board: state.board, index: input.index, mark }),
+    board: BoardState.setBoardCell({
+      board: state.board,
+      index: input.index,
+      mark,
+    }),
   };
 };
+
+// Spec-owned cases, shared with the ecs `playMove` transaction. `before` is a
+// delta over `State.create()` (empty board, X first, zeroed scores); `after` lists
+// only what the move writes — the board. Covers a legal placement, turn alternation
+// by move count, a winning placement, and the three rejections (occupied, out of
+// bounds, already won) that leave the board as-is.
+export const cases: Conformance<typeof playMove> = [
+  {
+    name: "places the first player's mark into an empty cell",
+    before: {},
+    args: { index: 4 },
+    after: { board: "    X    " },
+  },
+  {
+    name: "alternates to the opponent by move count",
+    before: { board: "    X    " },
+    args: { index: 0 },
+    after: { board: "O   X    " },
+  },
+  {
+    name: "completes a three-in-a-row (winning placement is still just a placement)",
+    before: { board: "XX  OO   ", xWins: 1, oWins: 2 },
+    args: { index: 2 },
+    after: { board: "XXX OO   " },
+  },
+  {
+    name: "ignores an occupied cell (no-op)",
+    before: { board: "    X    " },
+    args: { index: 4 },
+    after: { board: "    X    " },
+  },
+  {
+    name: "ignores an out-of-bounds index (no-op)",
+    before: { firstPlayer: "O" },
+    args: { index: 9 },
+    after: { board: "         " },
+  },
+  {
+    name: "ignores a move once the game is already won (no-op)",
+    before: { board: "XXX      " },
+    args: { index: 4 },
+    after: { board: "XXX      " },
+  },
+];
diff --git a/packages/data-lit-tictactoe/src/features/main/data/state/public.ts b/packages/data-lit-tictactoe/src/features/main/data/state/public.ts
index 92b6ebd4..74cd0885 100644
--- a/packages/data-lit-tictactoe/src/features/main/data/state/public.ts
+++ b/packages/data-lit-tictactoe/src/features/main/data/state/public.ts
@@ -1,3 +1,6 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+export { create } from "./create.js";
+export { samples } from "./samples.js";
 export { playMove } from "./play-move.js";
 export { restartGame } from "./restart-game.js";
+export { currentPlayer } from "./current-player.js";
diff --git a/packages/data-lit-tictactoe/src/features/main/data/state/restart-game.cases.ts b/packages/data-lit-tictactoe/src/features/main/data/state/restart-game.cases.ts
deleted file mode 100644
index fc809519..00000000
--- a/packages/data-lit-tictactoe/src/features/main/data/state/restart-game.cases.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { ConformanceCase } from "./conformance-case.js";
-
-// Spec-owned `{ before, args, after }` cases for `State.restartGame` (no args),
-// shared with the ecs `restartGame` transaction. Every restart clears the board
-// and hands the first move to the other player; the scoreboard is bumped only
-// for the finished game's outcome — X win, O win, draw (cat), or, when the game
-// wasn't finished, no counter at all.
-export const cases: readonly ConformanceCase<undefined>[] = [
-  {
-    name: "tallies an X win, alternates first player, clears the board",
-    before: { board: "XXX      ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
-    args: undefined,
-    after: { board: "         ", firstPlayer: "O", xWins: 1, oWins: 0, draws: 0 },
-  },
-  {
-    name: "tallies an O win",
-    before: { board: "OOOXX    ", firstPlayer: "O", xWins: 1, oWins: 2, draws: 0 },
-    args: undefined,
-    after: { board: "         ", firstPlayer: "X", xWins: 1, oWins: 3, draws: 0 },
-  },
-  {
-    name: "tallies a draw (full board, no line)",
-    before: { board: "XOXXOOOXX", firstPlayer: "O", xWins: 2, oWins: 1, draws: 0 },
-    args: undefined,
-    after: { board: "         ", firstPlayer: "X", xWins: 2, oWins: 1, draws: 1 },
-  },
-  {
-    name: "restarts an unfinished game without touching any counter",
-    before: { board: "X O      ", firstPlayer: "X", xWins: 1, oWins: 1, draws: 1 },
-    args: undefined,
-    after: { board: "         ", firstPlayer: "O", xWins: 1, oWins: 1, draws: 1 },
-  },
-];
diff --git a/packages/data-lit-tictactoe/src/features/main/data/state/restart-game.test.ts b/packages/data-lit-tictactoe/src/features/main/data/state/restart-game.test.ts
deleted file mode 100644
index 6c22e7d9..00000000
--- a/packages/data-lit-tictactoe/src/features/main/data/state/restart-game.test.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./restart-game.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.restartGame", () => {
-  for (const { name, before, after } of cases) {
-    it(name, () => {
-      expectStateMatches(State.restartGame(before), after);
-    });
-  }
-});
diff --git a/packages/data-lit-tictactoe/src/features/main/data/state/restart-game.ts b/packages/data-lit-tictactoe/src/features/main/data/state/restart-game.ts
index 4ab570d2..6919116d 100644
--- a/packages/data-lit-tictactoe/src/features/main/data/state/restart-game.ts
+++ b/packages/data-lit-tictactoe/src/features/main/data/state/restart-game.ts
@@ -2,6 +2,7 @@
 import { BoardState } from "../board-state/board-state.js";
 import { PlayerMark } from "../player-mark/player-mark.js";
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
 
 // Tally the finished game into the scoreboard, hand the first move to the other
 // player, and clear the board.
@@ -16,3 +17,58 @@ export const restartGame = (state: State): State => {
     draws: state.draws + (status === "draw" ? 1 : 0),
   };
 };
+
+// Spec-owned cases (no args), shared with the ecs `restartGame` transaction.
+// Every restart clears the board and hands the first move to the other player;
+// the scoreboard is bumped only for the finished game's outcome — X win, O win,
+// draw (cat), or, when the game wasn't finished, no counter at all.
+export const cases: Conformance<typeof restartGame> = [
+  {
+    name: "tallies an X win, alternates first player, clears the board",
+    before: { board: "XXX      " },
+    args: undefined,
+    after: {
+      board: "         ",
+      firstPlayer: "O",
+      xWins: 1,
+      oWins: 0,
+      draws: 0,
+    },
+  },
+  {
+    name: "tallies an O win",
+    before: { board: "OOOXX    ", firstPlayer: "O", xWins: 1, oWins: 2 },
+    args: undefined,
+    after: {
+      board: "         ",
+      firstPlayer: "X",
+      xWins: 1,
+      oWins: 3,
+      draws: 0,
+    },
+  },
+  {
+    name: "tallies a draw (full board, no line)",
+    before: { board: "XOXXOOOXX", firstPlayer: "O", xWins: 2, oWins: 1 },
+    args: undefined,
+    after: {
+      board: "         ",
+      firstPlayer: "X",
+      xWins: 2,
+      oWins: 1,
+      draws: 1,
+    },
+  },
+  {
+    name: "restarts an unfinished game without touching any counter",
+    before: { board: "X O      ", xWins: 1, oWins: 1, draws: 1 },
+    args: undefined,
+    after: {
+      board: "         ",
+      firstPlayer: "O",
+      xWins: 1,
+      oWins: 1,
+      draws: 1,
+    },
+  },
+];
diff --git a/packages/data-lit-tictactoe/src/features/main/data/state/samples.ts b/packages/data-lit-tictactoe/src/features/main/data/state/samples.ts
new file mode 100644
index 00000000..497177af
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/state/samples.ts
@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+
+// Representative full states for the projection round-trip (toState ∘ fromState ≡
+// identity). Varied boards + non-default counters exercise the whole ecs↔State map.
+export const samples: readonly State[] = [
+  { board: "XOXXOOOXX", firstPlayer: "O", xWins: 3, oWins: 2, draws: 1 },
+  { board: "X O X    ", firstPlayer: "O", xWins: 1, oWins: 0, draws: 0 },
+];
diff --git a/packages/data-lit-tictactoe/src/features/main/data/state/spec.test.ts b/packages/data-lit-tictactoe/src/features/main/data/state/spec.test.ts
new file mode 100644
index 00000000..41791ede
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/state/spec.test.ts
@@ -0,0 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Conformance } from "@adobe/data/testing";
+import { State } from "./state.js";
+import { transitions } from "./transitions.js";
+
+// The single pure-spec test for every transform AND derivation. Each case's
+// `before`/`input` is a delta over `State.create()`.
+Conformance.runSpec({ state: State, transitions });
diff --git a/packages/data-lit-tictactoe/src/features/main/data/state/transitions.ts b/packages/data-lit-tictactoe/src/features/main/data/state/transitions.ts
new file mode 100644
index 00000000..1092fd91
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/state/transitions.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+/// <reference types="vite/client" />
+
+// The transform/derivation modules for conformance discovery — the `{ fn, cases }`
+// source shared by `spec.test.ts` (pure) and the ecs `conformance.test.ts`. The
+// glob must be authored where Vite can statically see it (an eager glob, excluding
+// tests and this file itself); consumers import the resolved map.
+export const transitions = import.meta.glob<Record<string, unknown>>(
+  ["./*.ts", "!./*.test.ts", "!./*.type-test.ts", "!./transitions.ts"],
+  { eager: true },
+);
diff --git a/packages/data-lit-tictactoe/src/features/main/data/winning-line/lines.test.ts b/packages/data-lit-tictactoe/src/features/main/data/winning-line/lines.test.ts
new file mode 100644
index 00000000..b1007fe9
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/data/winning-line/lines.test.ts
@@ -0,0 +1,26 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { lines } from "./lines.js";
+
+describe("lines", () => {
+  it("is the eight winning triples of board indices", () => {
+    expect(lines).toEqual([
+      [0, 1, 2],
+      [3, 4, 5],
+      [6, 7, 8],
+      [0, 3, 6],
+      [1, 4, 7],
+      [2, 5, 8],
+      [0, 4, 8],
+      [2, 4, 6],
+    ]);
+  });
+
+  it("references only valid cell indices, three per line", () => {
+    for (const line of lines) {
+      expect(line).toHaveLength(3);
+      for (const i of line) expect(i).toBeGreaterThanOrEqual(0);
+      for (const i of line) expect(i).toBeLessThanOrEqual(8);
+    }
+  });
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/services/main-service/action-database/action-database.ts b/packages/data-lit-tictactoe/src/features/main/services/main-service/action-database/action-database.ts
new file mode 100644
index 00000000..84dc6b4a
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/services/main-service/action-database/action-database.ts
@@ -0,0 +1,18 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { ServiceDatabase } from "../service-database/service-database.js";
+import * as actions from "./actions/index.js";
+
+const actionDatabasePlugin = Database.Plugin.create({
+  extends: ServiceDatabase.plugin,
+  actions,
+});
+
+export type ActionDatabase = Database.Plugin.ToDatabase<
+  typeof actionDatabasePlugin
+>;
+
+export namespace ActionDatabase {
+  export const plugin = actionDatabasePlugin;
+  export type Store = Database.Plugin.ToStore<typeof actionDatabasePlugin>;
+}
diff --git a/packages/data-lit-tictactoe/src/features/main/services/main-service/action-database/actions/index.ts b/packages/data-lit-tictactoe/src/features/main/services/main-service/action-database/actions/index.ts
new file mode 100644
index 00000000..72eba314
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/services/main-service/action-database/actions/index.ts
@@ -0,0 +1,3 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export * from "./play-move.js";
+export * from "./restart-game.js";
diff --git a/packages/data-lit-tictactoe/src/features/main/services/main-service/action-database/actions/play-move.ts b/packages/data-lit-tictactoe/src/features/main/services/main-service/action-database/actions/play-move.ts
new file mode 100644
index 00000000..15dd3408
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/services/main-service/action-database/actions/play-move.ts
@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { PlayMoveArgs } from "../../../../data/play-move-args/play-move-args.js";
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+// The app-facing realization of `State.playMove`: a local placement needs no
+// outside capability, so it commits the move through a single transaction.
+export const playMove = (db: ServiceDatabase, args: PlayMoveArgs) => {
+  db.transactions.playMove(args);
+};
diff --git a/packages/data-lit-tictactoe/src/features/main/services/main-service/action-database/actions/restart-game.ts b/packages/data-lit-tictactoe/src/features/main/services/main-service/action-database/actions/restart-game.ts
new file mode 100644
index 00000000..de0bca25
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/services/main-service/action-database/actions/restart-game.ts
@@ -0,0 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+// The app-facing realization of `State.restartGame`: no outside capability, so it
+// commits the scoreboard tally + board reset through a single transaction.
+export const restartGame = (db: ServiceDatabase) => {
+  db.transactions.restartGame();
+};
diff --git a/packages/data-lit-tictactoe/src/features/main/services/main-service/computed-database/computed/state.ts b/packages/data-lit-tictactoe/src/features/main/services/main-service/computed-database/computed/state.ts
index dfcae65a..f197d418 100644
--- a/packages/data-lit-tictactoe/src/features/main/services/main-service/computed-database/computed/state.ts
+++ b/packages/data-lit-tictactoe/src/features/main/services/main-service/computed-database/computed/state.ts
@@ -1,29 +1,21 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { cached } from "@adobe/data/cache";
 import { Observe } from "@adobe/data/observe";
-import { BoardState } from "../../../../data/board-state/board-state.js";
-import type { PlacedMark } from "../../../../data/placed-mark/placed-mark.js";
 import type { State } from "../../../../data/state/state.js";
 import type { IndexDatabase } from "../../index-database/index-database.js";
+import { board } from "./board.js";
 
 // The full logical `State` projected from the ECS — the conformance anchor
-// between the data-layer spec and this implementation. Mark entities are folded
-// back into the board string; scalars come straight from resources.
-export const state = cached((db: IndexDatabase) =>
-  Observe.withCache(db.derive((read): State => {
-    const marks: PlacedMark[] = [];
-    for (const id of read.select(db.archetypes.PlacedMark.components)) {
-      const m = read.read(id);
-      if (m && m.mark !== undefined && m.index !== undefined) {
-        marks.push({ mark: m.mark, index: m.index });
-      }
-    }
-    return {
-      board: BoardState.fromMarks(marks),
-      firstPlayer: read.resources.firstPlayer,
-      xWins: read.resources.xWins,
-      oWins: read.resources.oWins,
-      draws: read.resources.draws,
-    };
-  })),
+// between the data-layer spec and this implementation. Reuses the `board`
+// computed (which folds the placed-mark entities into the board string) and joins
+// it with the scalar resource observables, so the mark-fold lives in exactly one
+// place. Re-emits whenever the board or any counter changes.
+export const state = cached((db: IndexDatabase): Observe<State> =>
+  Observe.fromProperties({
+    board: board(db),
+    firstPlayer: db.observe.resources.firstPlayer,
+    xWins: db.observe.resources.xWins,
+    oWins: db.observe.resources.oWins,
+    draws: db.observe.resources.draws,
+  }),
 );
diff --git a/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/conformance.test.ts b/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/conformance.test.ts
new file mode 100644
index 00000000..d1de2870
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/conformance.test.ts
@@ -0,0 +1,20 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Conformance } from "@adobe/data/testing";
+import { State } from "../../../data/state/state.js";
+import { transitions } from "../../../data/state/transitions.js";
+import { MainService } from "../main-service.js";
+import { ComputedDatabase } from "../computed-database/computed-database.js";
+import { projection } from "./projection.js";
+
+// The whole ecs conformance for this feature in one call: `runFeature` pulls the
+// transactions/actions off `MainService.plugin`, the computeds off the
+// `ComputedDatabase` layer, seeds each case's `before` (a delta) over
+// `State.create()`, and round-trips `State.samples` through the projection.
+// `transitions` (the discovered `{ fn, cases }` modules) is shared with spec.test.
+Conformance.runFeature({
+  state: State,
+  transitions,
+  plugin: MainService.plugin,
+  computedPlugin: ComputedDatabase.plugin,
+  projection,
+});
diff --git a/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/create-store.ts b/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/create-store.ts
deleted file mode 100644
index c94f0d01..00000000
--- a/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/create-store.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { Store } from "@adobe/data/ecs";
-import type { CoreDatabase } from "../core-database/core-database.js";
-import { IndexDatabase } from "../index-database/index-database.js";
-
-// A fresh writable store carrying the feature's whole schema. `IndexDatabase` is
-// the lowest layer that declares it all (components / resources / archetypes +
-// indexes) — the behaviour layers above add none — and `Store.create` reads a
-// plugin's schema facets directly. Typed as `CoreDatabase.Store`: the surface the
-// projection (`fromState` / `toState`) and the raw transaction functions use.
-// Test-only.
-export const createStore = (): CoreDatabase.Store => Store.create(IndexDatabase.plugin);
diff --git a/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/expect-conforms.ts b/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/expect-conforms.ts
deleted file mode 100644
index 70ab6e41..00000000
--- a/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/expect-conforms.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { it } from "vitest";
-import type { State } from "../../../data/state/state.js";
-import type { ConformanceCase } from "../../../data/state/conformance-case.js";
-import { expectStateMatches } from "../../../data/state/expect-state-matches.js";
-import type { CoreDatabase } from "../core-database/core-database.js";
-import { createStore } from "./create-store.js";
-import { fromState } from "./from-state.js";
-import { toState } from "./to-state.js";
-
-// The conformance runner, bound to THIS feature's projection (`fromState` /
-// `toState`). For each case it proves the one conformance property
-//
-//   toState(apply(fromState(before), args)) ≡ spec(before, args)
-//
-// in two asserted halves:
-//   1. `spec(before, args) ≡ after` — keeps the shared case honest (a
-//      mis-authored `after` is caught here, independent of the ecs path).
-//   2. seed `fromState(before)` → run the caller's `apply` → `toState ≡ after`
-//      — the ecs implementation reproduces the pure transform.
-//
-// `apply` receives the seeded writable store and calls the raw transaction
-// function directly (a transaction is `(store, args) => void`, so no `Database`
-// is involved). tictactoe's transactions take plain data args (a board index,
-// or nothing), so no entity resolution is needed in `apply`. Entity collections
-// compare as multisets; scalars and resources exactly (see `expectStateMatches`).
-export const expectConforms = <Args>(config: {
-  readonly cases: readonly ConformanceCase<Args>[];
-  readonly spec: (before: State, args: Args) => State;
-  readonly apply: (store: CoreDatabase.Store, args: Args) => void;
-}): void => {
-  for (const testCase of config.cases) {
-    it(testCase.name, () => {
-      expectStateMatches(config.spec(testCase.before, testCase.args), testCase.after);
-
-      const store = createStore();
-      fromState(store, testCase.before);
-      config.apply(store, testCase.args);
-      expectStateMatches(toState(store), testCase.after);
-    });
-  }
-};
diff --git a/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/from-state.ts b/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/from-state.ts
deleted file mode 100644
index 2e5e097c..00000000
--- a/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/from-state.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { State } from "../../../data/state/state.js";
-import { PlayerMark } from "../../../data/player-mark/player-mark.js";
-import type { CoreDatabase } from "../core-database/core-database.js";
-
-// Seed a store to exactly match a `data/` `State`: clear every placed mark, set
-// the scalar resources, then insert one PlacedMark entity per occupied board
-// cell. The inverse of `toState`. Test-only — the bridge that lets an ecs
-// mutation be checked against the pure transform it stands for (see
-// `expect-conforms.ts`).
-//
-// Clearing iterates tail→head so each delete is from the tail (no hole-fill
-// shift). The board string carries the marks (tictactoe stores each mark as an
-// entity), so `PlayerMark.is` narrows each cell and skips the blanks.
-export const fromState = (store: CoreDatabase.Store, state: State): void => {
-  for (const arch of store.queryArchetypes(store.archetypes.PlacedMark.components)) {
-    for (let row = arch.rowCount - 1; row >= 0; row--) {
-      store.delete(arch.columns.id.get(row));
-    }
-  }
-  store.resources.firstPlayer = state.firstPlayer;
-  store.resources.xWins = state.xWins;
-  store.resources.oWins = state.oWins;
-  store.resources.draws = state.draws;
-  for (let index = 0; index < state.board.length; index++) {
-    const cell = state.board[index];
-    if (PlayerMark.is(cell)) {
-      store.archetypes.PlacedMark.insert({ mark: cell, index });
-    }
-  }
-};
diff --git a/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/projection.test.ts b/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/projection.test.ts
deleted file mode 100644
index 2de27bce..00000000
--- a/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/projection.test.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// Guards the projection itself. `fromState` and `toState` are the bridge every
-// transaction conformance test trusts; a symmetric bug in the pair (e.g. both
-// dropping the same field) would cancel out and mask a real ecs defect. This
-// identity test — `toState(fromState(s)) ≡ s` over representative states —
-// proves the projection round-trips faithfully on its own.
-import { describe, it } from "vitest";
-import type { State } from "../../../data/state/state.js";
-import { expectStateMatches } from "../../../data/state/expect-state-matches.js";
-import { createStore } from "./create-store.js";
-import { fromState } from "./from-state.js";
-import { toState } from "./to-state.js";
-
-const states: readonly { readonly name: string; readonly state: State }[] = [
-  {
-    name: "a full board with non-zero counters",
-    state: { board: "XOXXOOOXX", firstPlayer: "O", xWins: 3, oWins: 2, draws: 1 },
-  },
-  {
-    name: "an empty board (just the resources)",
-    state: { board: "         ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
-  },
-  {
-    name: "a game in progress",
-    state: { board: "X O X    ", firstPlayer: "O", xWins: 1, oWins: 0, draws: 0 },
-  },
-];
-
-describe("ecs/conformance projection round-trips (toState ∘ fromState ≡ identity)", () => {
-  for (const { name, state } of states) {
-    it(name, () => {
-      const store = createStore();
-      fromState(store, state);
-      expectStateMatches(toState(store), state);
-    });
-  }
-});
diff --git a/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/projection.ts b/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/projection.ts
new file mode 100644
index 00000000..c630babf
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/projection.ts
@@ -0,0 +1,51 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Entity } from "@adobe/data/ecs";
+import { BoardState } from "../../../data/board-state/board-state.js";
+import { PlayerMark } from "../../../data/player-mark/player-mark.js";
+import type { PlacedMark } from "../../../data/placed-mark/placed-mark.js";
+import type { State } from "../../../data/state/state.js";
+import type { CoreDatabase } from "../core-database/core-database.js";
+
+// Read one placed-mark entity back into its `data/` value — the per-entity mapping
+// `toState` folds over.
+const toData = (store: CoreDatabase.Store, entity: Entity): PlacedMark => {
+  const row = store.read(entity, store.archetypes.PlacedMark);
+  if (row === null)
+    throw new Error("conformance projection: expected a placed-mark entity");
+  return { mark: row.mark, index: row.index };
+};
+
+// The test-only ecs↔`State` projection, passed to `Conformance.runFeature`.
+// `fromState` seeds a store to a `State` (tictactoe is index-addressed, so it
+// returns no id map); `toState` reads it back; `toData` reads one entity.
+export const projection = {
+  fromState: (store: CoreDatabase.Store, state: State): void => {
+    for (const arch of store.queryArchetypes(
+      store.archetypes.PlacedMark.components,
+    )) {
+      for (let row = arch.rowCount - 1; row >= 0; row--)
+        store.delete(arch.columns.id.get(row));
+    }
+    store.resources.firstPlayer = state.firstPlayer;
+    store.resources.xWins = state.xWins;
+    store.resources.oWins = state.oWins;
+    store.resources.draws = state.draws;
+    for (let index = 0; index < state.board.length; index++) {
+      const cell = state.board[index];
+      if (PlayerMark.is(cell))
+        store.archetypes.PlacedMark.insert({ mark: cell, index });
+    }
+  },
+  toState: (store: CoreDatabase.Store): State => ({
+    board: BoardState.fromMarks(
+      [...store.select(store.archetypes.PlacedMark.components)].map((entity) =>
+        toData(store, entity),
+      ),
+    ),
+    firstPlayer: store.resources.firstPlayer,
+    xWins: store.resources.xWins,
+    oWins: store.resources.oWins,
+    draws: store.resources.draws,
+  }),
+  toData,
+};
diff --git a/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/to-state.ts b/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/to-state.ts
deleted file mode 100644
index 3488c548..00000000
--- a/packages/data-lit-tictactoe/src/features/main/services/main-service/conformance/to-state.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { State } from "../../../data/state/state.js";
-import { BoardState } from "../../../data/board-state/board-state.js";
-import type { PlacedMark } from "../../../data/placed-mark/placed-mark.js";
-import type { CoreDatabase } from "../core-database/core-database.js";
-
-// Read a store back into a `data/` `State` — the inverse of `fromState`. The
-// placed marks are read through the PlacedMark archetype's full component set
-// (not an incidental single column) and folded into the compact board string,
-// then joined with the scalar resources. Test-only.
-const readBoard = (store: CoreDatabase.Store): BoardState => {
-  const marks: PlacedMark[] = [];
-  for (const arch of store.queryArchetypes(store.archetypes.PlacedMark.components)) {
-    for (let row = 0; row < arch.rowCount; row++) {
-      marks.push({
-        mark: arch.columns.mark.get(row),
-        index: arch.columns.index.get(row),
-      });
-    }
-  }
-  return BoardState.fromMarks(marks);
-};
-
-export const toState = (store: CoreDatabase.Store): State => ({
-  board: readBoard(store),
-  firstPlayer: store.resources.firstPlayer,
-  xWins: store.resources.xWins,
-  oWins: store.resources.oWins,
-  draws: store.resources.draws,
-});
diff --git a/packages/data-lit-tictactoe/src/features/main/services/main-service/feature-database.ts b/packages/data-lit-tictactoe/src/features/main/services/main-service/feature-database.ts
deleted file mode 100644
index 07eb53ae..00000000
--- a/packages/data-lit-tictactoe/src/features/main/services/main-service/feature-database.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// The assembled feature database. Its topmost layer is `service-database`
-// (adds the AI agent services). Every consumer — `ui/`, the app entry,
-// `ecs/conformance/` — references `FeatureDatabase`, never the topmost layer,
-// so adding or dropping a layer changes only this one line.
-export { ServiceDatabase as FeatureDatabase } from "./service-database/service-database.js";
diff --git a/packages/data-lit-tictactoe/src/features/main/services/main-service/main-service.ts b/packages/data-lit-tictactoe/src/features/main/services/main-service/main-service.ts
new file mode 100644
index 00000000..d8d6816d
--- /dev/null
+++ b/packages/data-lit-tictactoe/src/features/main/services/main-service/main-service.ts
@@ -0,0 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+//
+// The assembled feature database. Its topmost layer is `action-database`
+// (adds the async app-facing actions). Every consumer — `ui/`, the app entry,
+// `services/main-service/conformance/` — references `MainService`, never the
+// topmost layer, so adding or dropping a layer changes only this one line.
+export { ActionDatabase as MainService } from "./action-database/action-database.js";
diff --git a/packages/data-lit-tictactoe/src/features/main/services/main-service/transaction-database/transactions/play-move.test.ts b/packages/data-lit-tictactoe/src/features/main/services/main-service/transaction-database/transactions/play-move.test.ts
deleted file mode 100644
index f12aeb3a..00000000
--- a/packages/data-lit-tictactoe/src/features/main/services/main-service/transaction-database/transactions/play-move.test.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `playMove` conforms to `State.playMove`. Both take a plain board index, so the
-// `apply` closure calls the raw transaction directly on the seeded store — no
-// entity resolution needed. Every branch of the move guard (legal placement,
-// alternation, win, occupied / out-of-bounds / game-over no-ops) is covered by
-// the shared cases.
-import { describe } from "vitest";
-import { State } from "../../../../data/state/state.js";
-import { cases } from "../../../../data/state/play-move.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { playMove } from "./play-move.js";
-
-describe("playMove transaction conforms to State.playMove", () => {
-  expectConforms({
-    cases,
-    spec: State.playMove,
-    apply: playMove,
-  });
-});
diff --git a/packages/data-lit-tictactoe/src/features/main/services/main-service/transaction-database/transactions/restart-game.test.ts b/packages/data-lit-tictactoe/src/features/main/services/main-service/transaction-database/transactions/restart-game.test.ts
deleted file mode 100644
index ae3420e5..00000000
--- a/packages/data-lit-tictactoe/src/features/main/services/main-service/transaction-database/transactions/restart-game.test.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `restartGame` conforms to `State.restartGame`. It takes no args, so the
-// `apply` closure just dispatches the raw transaction on the seeded store. The
-// shared cases cover each scoreboard outcome — X win, O win, draw, and an
-// unfinished restart that bumps no counter.
-import { describe } from "vitest";
-import { State } from "../../../../data/state/state.js";
-import { cases } from "../../../../data/state/restart-game.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { restartGame } from "./restart-game.js";
-
-describe("restartGame transaction conforms to State.restartGame", () => {
-  expectConforms({
-    cases,
-    spec: State.restartGame,
-    apply: restartGame,
-  });
-});
diff --git a/packages/data-lit-tictactoe/src/features/main/ui/tictactoe-element.ts b/packages/data-lit-tictactoe/src/features/main/ui/tictactoe-element.ts
index f51dd372..d02adb03 100644
--- a/packages/data-lit-tictactoe/src/features/main/ui/tictactoe-element.ts
+++ b/packages/data-lit-tictactoe/src/features/main/ui/tictactoe-element.ts
@@ -5,10 +5,10 @@ import { ComputedDatabase } from "../services/main-service/computed-database/com
 
 /**
  * Base class for all Tic-Tac-Toe elements. Deliberately typed on the minimal
- * base-game surface (`ComputedDatabase`), NOT the assembled `FeatureDatabase`,
+ * base-game surface (`ComputedDatabase`), NOT the assembled `MainService`,
  * so any database that *extends* the base game can be injected as `.service` —
  * the standalone agent-extended app and the p2p presence build both do this.
- * (This is the sanctioned exception to "type consumers on `FeatureDatabase`":
+ * (This is the sanctioned exception to "type consumers on `MainService`":
  * an element meant to be extended types on the layer it actually consumes.)
  */
 export class TictactoeElement extends DatabaseElement<
diff --git a/packages/data-lit-tictactoe/src/index.ts b/packages/data-lit-tictactoe/src/index.ts
index 902d7572..781a4f3b 100644
--- a/packages/data-lit-tictactoe/src/index.ts
+++ b/packages/data-lit-tictactoe/src/index.ts
@@ -7,11 +7,11 @@
 // services. Feature-qualified per the cross-feature naming rule so a peer or
 // downstream package never collides with another feature's database. Carries
 // `.plugin` / `.Store` for consumers that build their own database.
-export { FeatureDatabase as TictactoeDatabase } from "./features/main/services/main-service/feature-database.js";
+export { MainService as TictactoeMainService } from "./features/main/services/main-service/main-service.js";
 
 // The base game database — all game logic (resources, transactions, computed),
 // no AI. Combine its `.plugin` with P2P-specific plugins, or reach for
-// `TictactoeDatabase` to get the agent-extended assembly.
+// `TictactoeMainService` to get the agent-extended assembly.
 export { ComputedDatabase as TictactoeGameDatabase } from "./features/main/services/main-service/computed-database/computed-database.js";
 
 export { Tictactoe } from "./features/main/ui/tictactoe-app/tictactoe-app.js";
diff --git a/packages/data-lit-tictactoe/src/main.ts b/packages/data-lit-tictactoe/src/main.ts
index d87f3c3f..60eeeb9c 100644
--- a/packages/data-lit-tictactoe/src/main.ts
+++ b/packages/data-lit-tictactoe/src/main.ts
@@ -3,13 +3,13 @@
 import { render } from "lit";
 import { Database } from "@adobe/data/ecs";
 import { Tictactoe } from "./features/main/ui/tictactoe-app/tictactoe-app.js";
-import { FeatureDatabase } from "./features/main/services/main-service/feature-database.js";
+import { MainService } from "./features/main/services/main-service/main-service.js";
 
 const app = document.getElementById("app");
 if (app) {
     // The assembled feature database extends the base game with AI services.
     // Built once here and passed to the lazy wrapper so the upgraded element
     // receives the agent-extended database.
-    const service = Database.create(FeatureDatabase.plugin);
+    const service = Database.create(MainService.plugin);
     render(Tictactoe({ service }), app);
 }
diff --git a/packages/data-lit-todo/package.json b/packages/data-lit-todo/package.json
index d4abc531..a1240ecf 100644
--- a/packages/data-lit-todo/package.json
+++ b/packages/data-lit-todo/package.json
@@ -1,6 +1,6 @@
 {
   "name": "data-lit-todo",
-  "version": "0.9.92",
+  "version": "0.9.93",
   "description": "Todo application - Lit web components with @adobe/data ECS",
   "type": "module",
   "private": true,
diff --git a/packages/data-lit-todo/src/features/main/data/state/append-todo.ts b/packages/data-lit-todo/src/features/main/data/state/append-todo.ts
new file mode 100644
index 00000000..d9248d0b
--- /dev/null
+++ b/packages/data-lit-todo/src/features/main/data/state/append-todo.ts
@@ -0,0 +1,21 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+
+// Internal state helper — its own file per the namespace pattern, but NOT
+// re-exported through `public.ts`, so it is not a public `State.` transform and
+// carries no conformance cases. Shared by the `createTodo` and `createRandomTodo`
+// transitions so the pure append stays single-sourced while each fires its own
+// analytics side effect. Reads the todos, writes the todos — a `{ todos }` patch.
+export const appendTodo = (
+  state: Pick<State, "todos">,
+  input: { readonly name: string; readonly complete?: boolean },
+): Pick<State, "todos"> => {
+  const nextId =
+    state.todos.reduce((max, todo) => Math.max(max, todo.id), 0) + 1;
+  return {
+    todos: [
+      ...state.todos,
+      { id: nextId, name: input.name, complete: input.complete ?? false },
+    ],
+  };
+};
diff --git a/packages/data-lit-todo/src/features/main/data/state/conformance-case.ts b/packages/data-lit-todo/src/features/main/data/state/conformance-case.ts
index 44e5a8a5..6064cb56 100644
--- a/packages/data-lit-todo/src/features/main/data/state/conformance-case.ts
+++ b/packages/data-lit-todo/src/features/main/data/state/conformance-case.ts
@@ -1,13 +1,19 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Conformance as ConformanceApi } from "@adobe/data/testing";
 import type { State } from "./state.js";
 
-// One spec-owned conformance case: a `data/` transform's `{ before, args, after }`
-// authored as full `State`. Lives in `<transform>.cases.ts` and is shared,
-// unchanged, by the data transform test and the ecs conformance runner
-// (see `ecs/conformance/`).
-export type ConformanceCase<Args> = {
-  readonly name: string;
-  readonly before: State;
-  readonly args: Args;
-  readonly after: State;
-};
+// The conformance case types for this feature — the shared `@adobe/data/testing`
+// machinery with `State` bound once, so a transform authors `Conformance<typeof fn>`
+// and a derivation `Derivation<typeof fn>` (args/input/value read from the
+// function's own signature). This tiny file is the only per-feature conformance
+// type declaration; everything else lives in `@adobe/data/testing`.
+export type Conformance<F extends (...args: never[]) => unknown> =
+  ConformanceApi.Cases<State, F>;
+export type Derivation<F extends (...args: never[]) => unknown> =
+  ConformanceApi.DerivationCases<F>;
+export type Effects<Args> = ConformanceApi.Effects<Args>;
+
+// The entity-reference marker for case args: `args: { id: entity(2) }` names "the
+// entity seeded for spec-id 2". The pure spec reads `2`; the ecs runner resolves
+// it to the seeded entity. Re-exported here so cases import it beside `Conformance`.
+export const entity = ConformanceApi.entity;
diff --git a/packages/data-lit-todo/src/features/main/data/state/create-bulk-todos.cases.ts b/packages/data-lit-todo/src/features/main/data/state/create-bulk-todos.cases.ts
deleted file mode 100644
index 73839c9b..00000000
--- a/packages/data-lit-todo/src/features/main/data/state/create-bulk-todos.cases.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { ConformanceCase } from "./conformance-case.js";
-
-// Spec-owned `{ before, args, after }` cases for `State.createBulkTodos`, shared
-// with the ecs `createBulkTodos` transaction. `count` (floored, clamped at 0)
-// numbered placeholder todos are appended: name `Todo ${length + index}`, id
-// continuing max + 1. Todo ids run 1..N in display order for round-trip.
-type Args = { readonly count: number };
-
-export const cases: readonly ConformanceCase<Args>[] = [
-  {
-    name: "appends count numbered todos to an empty list",
-    before: { todos: [], displayCompleted: false },
-    args: { count: 3 },
-    after: {
-      todos: [
-        { id: 1, name: "Todo 0", complete: false },
-        { id: 2, name: "Todo 1", complete: false },
-        { id: 3, name: "Todo 2", complete: false },
-      ],
-      displayCompleted: false,
-    },
-  },
-  {
-    name: "continues names and ids after existing todos",
-    before: { todos: [{ id: 1, name: "a", complete: false }], displayCompleted: false },
-    args: { count: 2 },
-    after: {
-      todos: [
-        { id: 1, name: "a", complete: false },
-        { id: 2, name: "Todo 1", complete: false },
-        { id: 3, name: "Todo 2", complete: false },
-      ],
-      displayCompleted: false,
-    },
-  },
-  {
-    name: "floors a fractional count",
-    before: { todos: [], displayCompleted: false },
-    args: { count: 2.9 },
-    after: {
-      todos: [
-        { id: 1, name: "Todo 0", complete: false },
-        { id: 2, name: "Todo 1", complete: false },
-      ],
-      displayCompleted: false,
-    },
-  },
-  {
-    name: "is a no-op for count 0",
-    before: { todos: [{ id: 1, name: "a", complete: false }], displayCompleted: true },
-    args: { count: 0 },
-    after: { todos: [{ id: 1, name: "a", complete: false }], displayCompleted: true },
-  },
-];
diff --git a/packages/data-lit-todo/src/features/main/data/state/create-bulk-todos.test.ts b/packages/data-lit-todo/src/features/main/data/state/create-bulk-todos.test.ts
deleted file mode 100644
index e05049e7..00000000
--- a/packages/data-lit-todo/src/features/main/data/state/create-bulk-todos.test.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./create-bulk-todos.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.createBulkTodos", () => {
-  for (const { name, before, args, after } of cases) {
-    it(name, () => expectStateMatches(State.createBulkTodos(before, args), after));
-  }
-});
diff --git a/packages/data-lit-todo/src/features/main/data/state/create-bulk-todos.ts b/packages/data-lit-todo/src/features/main/data/state/create-bulk-todos.ts
index 6e5743f0..cf083f78 100644
--- a/packages/data-lit-todo/src/features/main/data/state/create-bulk-todos.ts
+++ b/packages/data-lit-todo/src/features/main/data/state/create-bulk-todos.ts
@@ -1,21 +1,81 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+import { AnalyticsService } from "../../services/analytics-service/analytics-service.js";
 import type { State } from "./state.js";
-
-/** Adds numbered placeholder todos for demos and performance testing. */
-export const createBulkTodos = <T extends Pick<State, "todos">>(
-  state: T,
-  input: { readonly count: number },
-): T => {
-  const count = Math.max(0, Math.floor(input.count));
-  if (count === 0) return state;
-
-  const startIndex = state.todos.length;
-  const nextId = state.todos.reduce((max, todo) => Math.max(max, todo.id), 0) + 1;
-  const newTodos = Array.from({ length: count }, (_, index) => ({
-    id: nextId + index,
-    name: `Todo ${startIndex + index}`,
-    complete: false,
-  }));
-
-  return { ...state, todos: [...state.todos, ...newTodos] };
+import type { Conformance } from "./conformance-case.js";
+import { appendTodo } from "./append-todo.js";
+import { Match } from "@adobe/data/testing";
+/** Adds numbered placeholder todos for demos and performance testing. Reads and
+ * writes the todos — a `{ todos }` patch. */
+export const createBulkTodos = (
+  state: Pick<State, "todos">,
+  {
+    count,
+    analytics,
+  }: { readonly count: number; readonly analytics: AnalyticsService },
+): Pick<State, "todos"> => {
+  analytics.bulkTodosCreated({ count });
+  const total = Math.max(0, Math.floor(count));
+  let next: Pick<State, "todos"> = state;
+  for (let index = 0; index < total; index++) {
+    next = appendTodo(next, { name: `Todo ${state.todos.length + index}` });
+  }
+  return next;
 };
+
+// Spec-owned cases, shared with the ecs `createBulkTodos` transaction. `before`
+// is a delta over `State.create()`; `after` lists only the written todos.
+// `count` (floored, clamped at 0) numbered todos are appended; the transition
+// logs `bulkTodosCreated` with the raw count (as the action does), even on a
+// no-op. Minted ids are left open (`Match.anyNumber`) — the ecs assigns its own.
+export const cases: Conformance<typeof createBulkTodos> = [
+  {
+    name: "appends count numbered todos to an empty list",
+    before: {},
+    args: { count: 3, analytics: AnalyticsService.createFake() },
+    after: {
+      todos: [
+        { id: Match.anyNumber, name: "Todo 0", complete: false },
+        { id: Match.anyNumber, name: "Todo 1", complete: false },
+        { id: Match.anyNumber, name: "Todo 2", complete: false },
+      ],
+    },
+    effects: { analytics: [["bulkTodosCreated", { count: 3 }]] },
+  },
+  {
+    name: "continues names after existing todos",
+    before: { todos: [{ id: 1, name: "a", complete: false }] },
+    args: { count: 2, analytics: AnalyticsService.createFake() },
+    after: {
+      todos: [
+        { id: Match.anyNumber, name: "a", complete: false },
+        { id: Match.anyNumber, name: "Todo 1", complete: false },
+        { id: Match.anyNumber, name: "Todo 2", complete: false },
+      ],
+    },
+    effects: { analytics: [["bulkTodosCreated", { count: 2 }]] },
+  },
+  {
+    name: "floors a fractional count",
+    before: {},
+    args: { count: 2.9, analytics: AnalyticsService.createFake() },
+    after: {
+      todos: [
+        { id: Match.anyNumber, name: "Todo 0", complete: false },
+        { id: Match.anyNumber, name: "Todo 1", complete: false },
+      ],
+    },
+    effects: { analytics: [["bulkTodosCreated", { count: 2.9 }]] },
+  },
+  {
+    name: "is a no-op for count 0 but still logs the request",
+    before: {
+      todos: [{ id: 1, name: "a", complete: false }],
+      displayCompleted: true,
+    },
+    args: { count: 0, analytics: AnalyticsService.createFake() },
+    after: {
+      todos: [{ id: Match.anyNumber, name: "a", complete: false }],
+    },
+    effects: { analytics: [["bulkTodosCreated", { count: 0 }]] },
+  },
+];
diff --git a/packages/data-lit-todo/src/features/main/data/state/create-random-todo.ts b/packages/data-lit-todo/src/features/main/data/state/create-random-todo.ts
new file mode 100644
index 00000000..528a0b91
--- /dev/null
+++ b/packages/data-lit-todo/src/features/main/data/state/create-random-todo.ts
@@ -0,0 +1,88 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { NameGeneratorService } from "../../services/name-generator-service/name-generator-service.js";
+import { AnalyticsService } from "../../services/analytics-service/analytics-service.js";
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+import { appendTodo } from "./append-todo.js";
+import { Match } from "@adobe/data/testing";
+/**
+ * Async, service-injected transition: brackets the slow name generation with
+ * analytics timing, then appends the todo via the shared {@link appendTodo} (so
+ * it does NOT fire `todoCreated` — it logs its own `randomTodoAdded`). Reads and
+ * writes the todos — a `{ todos }` patch. Awaiting an async port makes it
+ * `Promise<Pick<State, "todos">>`, but it stays deterministic given its injected
+ * services — which is how it is unit-tested.
+ */
+export const createRandomTodo = async (
+  state: Pick<State, "todos">,
+  {
+    nameGenerator,
+    analytics,
+  }: {
+    readonly nameGenerator: NameGeneratorService;
+    readonly analytics: AnalyticsService;
+  },
+): Promise<Pick<State, "todos">> => {
+  const timing = await analytics.randomTodoRequested();
+  const name = await nameGenerator.generateName();
+  const next = appendTodo(state, { name });
+  analytics.randomTodoAdded({ timing, name });
+  return next;
+};
+
+// Spec-owned cases. `before` is a delta over `State.create()`; `after` lists only
+// the written todos. Each injects deterministic doubles with the exact responses
+// it needs and authors `after` + `effects` against those self-owned values (the
+// name it schedules, the fixed `{ startedAt: 0 }` timing the analytics double
+// resolves). The value-returning reads (`randomTodoRequested`, `generateName`)
+// are still calls on `analytics`, so — analytics being a declared service — its
+// full call sequence is listed; `nameGenerator` is not declared, so its read is
+// ignored.
+export const cases: Conformance<typeof createRandomTodo> = [
+  {
+    name: "names the new todo from the generator and logs the timed add",
+    before: {},
+    args: {
+      nameGenerator: NameGeneratorService.createFake(["random task"]),
+      analytics: AnalyticsService.createFake(),
+    },
+    after: {
+      todos: [
+        {
+          id: Match.anyNumber,
+          name: "random task",
+          complete: false,
+        },
+      ],
+    },
+    effects: {
+      analytics: [
+        ["randomTodoRequested"],
+        [
+          "randomTodoAdded",
+          {
+            timing: { startedAt: 0 },
+            name: "random task",
+          },
+        ],
+      ],
+    },
+  },
+  {
+    name: "uses an explicit response schedule when supplied",
+    before: {},
+    args: {
+      nameGenerator: NameGeneratorService.createFake(["only name"]),
+      analytics: AnalyticsService.createFake(),
+    },
+    after: {
+      todos: [{ id: Match.anyNumber, name: "only name", complete: false }],
+    },
+    effects: {
+      analytics: [
+        ["randomTodoRequested"],
+        ["randomTodoAdded", { timing: { startedAt: 0 }, name: "only name" }],
+      ],
+    },
+  },
+];
diff --git a/packages/data-lit-todo/src/features/main/data/state/create-todo.cases.ts b/packages/data-lit-todo/src/features/main/data/state/create-todo.cases.ts
deleted file mode 100644
index 29c7d540..00000000
--- a/packages/data-lit-todo/src/features/main/data/state/create-todo.cases.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { ConformanceCase } from "./conformance-case.js";
-
-// Spec-owned `{ before, args, after }` cases for `State.createTodo`, shared with
-// the ecs `createTodo` transaction. A todo is appended with the next id
-// (max existing id + 1) and `complete` defaulting to false. Todo ids run 1..N in
-// display order so the ecs projection (which assigns entity ids in that order)
-// round-trips — see `ecs/conformance/from-state.ts`.
-type Args = { readonly name: string; readonly complete?: boolean };
-
-export const cases: readonly ConformanceCase<Args>[] = [
-  {
-    name: "appends the first todo (id 1) to an empty list",
-    before: { todos: [], displayCompleted: false },
-    args: { name: "a" },
-    after: { todos: [{ id: 1, name: "a", complete: false }], displayCompleted: false },
-  },
-  {
-    name: "appends a complete todo with the next id",
-    before: { todos: [{ id: 1, name: "a", complete: false }], displayCompleted: false },
-    args: { name: "b", complete: true },
-    after: {
-      todos: [
-        { id: 1, name: "a", complete: false },
-        { id: 2, name: "b", complete: true },
-      ],
-      displayCompleted: false,
-    },
-  },
-  {
-    name: "takes the next id as max + 1 over a longer list",
-    before: {
-      todos: [
-        { id: 1, name: "a", complete: false },
-        { id: 2, name: "b", complete: true },
-        { id: 3, name: "c", complete: false },
-      ],
-      displayCompleted: true,
-    },
-    args: { name: "d" },
-    after: {
-      todos: [
-        { id: 1, name: "a", complete: false },
-        { id: 2, name: "b", complete: true },
-        { id: 3, name: "c", complete: false },
-        { id: 4, name: "d", complete: false },
-      ],
-      displayCompleted: true,
-    },
-  },
-];
diff --git a/packages/data-lit-todo/src/features/main/data/state/create-todo.test.ts b/packages/data-lit-todo/src/features/main/data/state/create-todo.test.ts
deleted file mode 100644
index 7e55ace1..00000000
--- a/packages/data-lit-todo/src/features/main/data/state/create-todo.test.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./create-todo.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.createTodo", () => {
-  for (const { name, before, args, after } of cases) {
-    it(name, () => expectStateMatches(State.createTodo(before, args), after));
-  }
-});
diff --git a/packages/data-lit-todo/src/features/main/data/state/create-todo.ts b/packages/data-lit-todo/src/features/main/data/state/create-todo.ts
index 1c5951f3..c8209f91 100644
--- a/packages/data-lit-todo/src/features/main/data/state/create-todo.ts
+++ b/packages/data-lit-todo/src/features/main/data/state/create-todo.ts
@@ -1,16 +1,77 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+import { AnalyticsService } from "../../services/analytics-service/analytics-service.js";
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+import { appendTodo } from "./append-todo.js";
+import { Match } from "@adobe/data/testing";
 
-const nextTodoId = (state: Pick<State, "todos">): number =>
-  state.todos.reduce((max, todo) => Math.max(max, todo.id), 0) + 1;
+// Reads the todos, writes the todos — a `{ todos }` patch — by delegating to the
+// shared `appendTodo`; also logs `todoCreated`.
+export const createTodo = (
+  state: Pick<State, "todos">,
+  {
+    name,
+    complete,
+    analytics,
+  }: {
+    readonly name: string;
+    readonly complete?: boolean;
+    readonly analytics: AnalyticsService;
+  },
+): Pick<State, "todos"> => {
+  analytics.todoCreated({ name });
+  return appendTodo(state, { name, complete });
+};
 
-export const createTodo = <T extends Pick<State, "todos">>(
-  state: T,
-  input: { readonly name: string; readonly complete?: boolean },
-): T => ({
-  ...state,
-  todos: [
-    ...state.todos,
-    { id: nextTodoId(state), name: input.name, complete: input.complete ?? false },
-  ],
-});
+// Spec-owned cases, shared with the ecs `createTodo` transaction. `before` is a
+// delta over `State.create()` (no todos, completed hidden); `after` lists only
+// what the transition writes — the todos (minted id left open as `Match.anyNumber`,
+// the ecs assigns its own). `complete` defaults to false; it logs `todoCreated`.
+export const cases: Conformance<typeof createTodo> = [
+  {
+    name: "appends the first todo to an empty list",
+    before: {},
+    args: { name: "a", analytics: AnalyticsService.createFake() },
+    after: {
+      todos: [{ id: Match.anyNumber, name: "a", complete: false }],
+    },
+    effects: { analytics: [["todoCreated", { name: "a" }]] },
+  },
+  {
+    name: "appends a complete todo",
+    before: { todos: [{ id: 1, name: "a", complete: false }] },
+    args: {
+      name: "b",
+      complete: true,
+      analytics: AnalyticsService.createFake(),
+    },
+    after: {
+      todos: [
+        { id: Match.anyNumber, name: "a", complete: false },
+        { id: Match.anyNumber, name: "b", complete: true },
+      ],
+    },
+    effects: { analytics: [["todoCreated", { name: "b" }]] },
+  },
+  {
+    name: "appends onto a longer list",
+    before: {
+      todos: [
+        { id: 1, name: "a", complete: false },
+        { id: 2, name: "b", complete: true },
+        { id: 3, name: "c", complete: false },
+      ],
+      displayCompleted: true,
+    },
+    args: { name: "d", analytics: AnalyticsService.createFake() },
+    after: {
+      todos: [
+        { id: Match.anyNumber, name: "a", complete: false },
+        { id: Match.anyNumber, name: "b", complete: true },
+        { id: Match.anyNumber, name: "c", complete: false },
+        { id: Match.anyNumber, name: "d", complete: false },
+      ],
+    },
+    effects: { analytics: [["todoCreated", { name: "d" }]] },
+  },
+];
diff --git a/packages/data-lit-todo/src/features/main/data/state/create.ts b/packages/data-lit-todo/src/features/main/data/state/create.ts
new file mode 100644
index 00000000..3517e7c8
--- /dev/null
+++ b/packages/data-lit-todo/src/features/main/data/state/create.ts
@@ -0,0 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+
+// The default application state: no todos, completed items hidden. It is the
+// baseline the conformance cases author their `before`/`input` as deltas over
+// (passed to the runners as `initial`), and the state a fresh app starts in.
+export const create = (): State => ({ todos: [], displayCompleted: false });
diff --git a/packages/data-lit-todo/src/features/main/data/state/delete-all-todos.cases.ts b/packages/data-lit-todo/src/features/main/data/state/delete-all-todos.cases.ts
deleted file mode 100644
index b8ac59e0..00000000
--- a/packages/data-lit-todo/src/features/main/data/state/delete-all-todos.cases.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { ConformanceCase } from "./conformance-case.js";
-
-// Spec-owned `{ before, args, after }` cases for `State.deleteAllTodos` (no
-// args), shared with the ecs `deleteAllTodos` transaction. Every todo is
-// removed; `displayCompleted` is left untouched.
-export const cases: readonly ConformanceCase<undefined>[] = [
-  {
-    name: "empties a populated list, preserving displayCompleted",
-    before: {
-      todos: [
-        { id: 1, name: "a", complete: false },
-        { id: 2, name: "b", complete: true },
-        { id: 3, name: "c", complete: false },
-      ],
-      displayCompleted: true,
-    },
-    args: undefined,
-    after: { todos: [], displayCompleted: true },
-  },
-  {
-    name: "is a no-op on an already empty list",
-    before: { todos: [], displayCompleted: false },
-    args: undefined,
-    after: { todos: [], displayCompleted: false },
-  },
-];
diff --git a/packages/data-lit-todo/src/features/main/data/state/delete-all-todos.test.ts b/packages/data-lit-todo/src/features/main/data/state/delete-all-todos.test.ts
deleted file mode 100644
index f2d292fc..00000000
--- a/packages/data-lit-todo/src/features/main/data/state/delete-all-todos.test.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./delete-all-todos.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.deleteAllTodos", () => {
-  for (const { name, before, after } of cases) {
-    it(name, () => expectStateMatches(State.deleteAllTodos(before), after));
-  }
-});
diff --git a/packages/data-lit-todo/src/features/main/data/state/delete-all-todos.ts b/packages/data-lit-todo/src/features/main/data/state/delete-all-todos.ts
index 05760f7c..7b7f413a 100644
--- a/packages/data-lit-todo/src/features/main/data/state/delete-all-todos.ts
+++ b/packages/data-lit-todo/src/features/main/data/state/delete-all-todos.ts
@@ -1,7 +1,42 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+import { AnalyticsService } from "../../services/analytics-service/analytics-service.js";
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
 
-export const deleteAllTodos = <T extends Pick<State, "todos">>(state: T): T => ({
-  ...state,
-  todos: [],
-});
+// Reads the todos, writes the todos — a `{ todos }` patch — clearing them;
+// `displayCompleted` is untouched. Logs `allTodosCleared`.
+export const deleteAllTodos = (
+  state: Pick<State, "todos">,
+  { analytics }: { readonly analytics: AnalyticsService },
+): Pick<State, "todos"> => {
+  analytics.allTodosCleared();
+  return { todos: [] };
+};
+
+// Spec-owned cases, shared with the ecs `deleteAllTodos` transaction. `before` is
+// a delta over `State.create()`; `after` lists only the written todos. Every todo
+// is removed and `displayCompleted` is untouched; the transition logs
+// `allTodosCleared` (as the action does).
+export const cases: Conformance<typeof deleteAllTodos> = [
+  {
+    name: "empties a populated list, preserving displayCompleted",
+    before: {
+      todos: [
+        { id: 1, name: "a", complete: false },
+        { id: 2, name: "b", complete: true },
+        { id: 3, name: "c", complete: false },
+      ],
+      displayCompleted: true,
+    },
+    args: { analytics: AnalyticsService.createFake() },
+    after: { todos: [] },
+    effects: { analytics: [["allTodosCleared"]] },
+  },
+  {
+    name: "is a no-op on an already empty list but still logs the clear",
+    before: {},
+    args: { analytics: AnalyticsService.createFake() },
+    after: { todos: [] },
+    effects: { analytics: [["allTodosCleared"]] },
+  },
+];
diff --git a/packages/data-lit-todo/src/features/main/data/state/delete-todo.cases.ts b/packages/data-lit-todo/src/features/main/data/state/delete-todo.cases.ts
deleted file mode 100644
index d9253a63..00000000
--- a/packages/data-lit-todo/src/features/main/data/state/delete-todo.cases.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { ConformanceCase } from "./conformance-case.js";
-
-// Spec-owned `{ before, args, after }` cases for `State.deleteTodo`, shared with
-// the ecs `deleteTodo` transaction. The todo with the given id is removed;
-// an unknown id is a no-op. Todo ids run 1..N in display order for round-trip.
-type Args = { readonly id: number };
-
-const three = [
-  { id: 1, name: "a", complete: false },
-  { id: 2, name: "b", complete: true },
-  { id: 3, name: "c", complete: false },
-];
-
-export const cases: readonly ConformanceCase<Args>[] = [
-  {
-    name: "removes a middle todo",
-    before: { todos: [...three], displayCompleted: false },
-    args: { id: 2 },
-    after: {
-      todos: [
-        { id: 1, name: "a", complete: false },
-        { id: 3, name: "c", complete: false },
-      ],
-      displayCompleted: false,
-    },
-  },
-  {
-    name: "removes the first todo",
-    before: { todos: [...three], displayCompleted: true },
-    args: { id: 1 },
-    after: {
-      todos: [
-        { id: 2, name: "b", complete: true },
-        { id: 3, name: "c", complete: false },
-      ],
-      displayCompleted: true,
-    },
-  },
-  {
-    name: "is a no-op for an unknown id",
-    before: { todos: [...three], displayCompleted: false },
-    args: { id: 99 },
-    after: { todos: [...three], displayCompleted: false },
-  },
-];
diff --git a/packages/data-lit-todo/src/features/main/data/state/delete-todo.test.ts b/packages/data-lit-todo/src/features/main/data/state/delete-todo.test.ts
deleted file mode 100644
index f23484d2..00000000
--- a/packages/data-lit-todo/src/features/main/data/state/delete-todo.test.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./delete-todo.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.deleteTodo", () => {
-  for (const { name, before, args, after } of cases) {
-    it(name, () => expectStateMatches(State.deleteTodo(before, args), after));
-  }
-});
diff --git a/packages/data-lit-todo/src/features/main/data/state/delete-todo.ts b/packages/data-lit-todo/src/features/main/data/state/delete-todo.ts
index 43ad7a59..9617455e 100644
--- a/packages/data-lit-todo/src/features/main/data/state/delete-todo.ts
+++ b/packages/data-lit-todo/src/features/main/data/state/delete-todo.ts
@@ -1,10 +1,69 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+import { AnalyticsService } from "../../services/analytics-service/analytics-service.js";
 import type { State } from "./state.js";
+import { entity, type Conformance } from "./conformance-case.js";
+import { Match } from "@adobe/data/testing";
 
-export const deleteTodo = <T extends Pick<State, "todos">>(
-  state: T,
-  input: { readonly id: number },
-): T => ({
-  ...state,
-  todos: state.todos.filter((todo) => todo.id !== input.id),
-});
+// Reads the todos, writes the todos — a `{ todos }` patch — dropping the
+// addressed id; also logs `todoDeleted`.
+export const deleteTodo = (
+  state: Pick<State, "todos">,
+  {
+    id,
+    analytics,
+  }: { readonly id: number; readonly analytics: AnalyticsService },
+): Pick<State, "todos"> => {
+  analytics.todoDeleted();
+  return { todos: state.todos.filter((todo) => todo.id !== id) };
+};
+
+const three = [
+  { id: 1, name: "a", complete: false },
+  { id: 2, name: "b", complete: true },
+  { id: 3, name: "c", complete: false },
+];
+
+// Spec-owned cases, shared with the ecs `deleteTodo` transaction. `before` is a
+// delta over `State.create()`; `after` lists only the written todos. The
+// addressed todo is removed; an unknown id is a no-op. The transition logs
+// `todoDeleted`. `before` ids are concrete (they address the delete); surviving
+// `after` ids are left open (`Match.anyNumber`) — the ecs assigns its own.
+export const cases: Conformance<typeof deleteTodo> = [
+  {
+    name: "removes a middle todo",
+    before: { todos: [...three] },
+    args: { id: entity(2), analytics: AnalyticsService.createFake() },
+    after: {
+      todos: [
+        { id: Match.anyNumber, name: "a", complete: false },
+        { id: Match.anyNumber, name: "c", complete: false },
+      ],
+    },
+    effects: { analytics: [["todoDeleted"]] },
+  },
+  {
+    name: "removes the first todo",
+    before: { todos: [...three], displayCompleted: true },
+    args: { id: entity(1), analytics: AnalyticsService.createFake() },
+    after: {
+      todos: [
+        { id: Match.anyNumber, name: "b", complete: true },
+        { id: Match.anyNumber, name: "c", complete: false },
+      ],
+    },
+    effects: { analytics: [["todoDeleted"]] },
+  },
+  {
+    name: "is a no-op for an unknown id but still logs the delete",
+    before: { todos: [...three] },
+    args: { id: entity(99), analytics: AnalyticsService.createFake() },
+    after: {
+      todos: [
+        { id: Match.anyNumber, name: "a", complete: false },
+        { id: Match.anyNumber, name: "b", complete: true },
+        { id: Match.anyNumber, name: "c", complete: false },
+      ],
+    },
+    effects: { analytics: [["todoDeleted"]] },
+  },
+];
diff --git a/packages/data-lit-todo/src/features/main/data/state/expect-state-matches.ts b/packages/data-lit-todo/src/features/main/data/state/expect-state-matches.ts
deleted file mode 100644
index 95b3dc36..00000000
--- a/packages/data-lit-todo/src/features/main/data/state/expect-state-matches.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { expect } from "vitest";
-import { equalsUnordered } from "@adobe/data";
-import type { State } from "./state.js";
-
-// Spec-owned tolerant `State` equality, shared by the data/ transform tests and
-// the ecs conformance runner. Two orthogonal concerns, kept separate:
-//
-//   precision — normalise every number on both sides onto a shared grid so a
-//     value that differs only by F32↔f64 storage rounding (the ecs `order`
-//     column is F32, the spec authors plain integers) compares equal.
-//     `Math.fround` collapses the F32 rounding; rounding to 1e-2 collapses any
-//     residue. `+ 0` normalises `-0` to `0`, which the compare below distinguishes.
-//   ordering — `equalsUnordered` compares arrays as MULTISETS (archetype
-//     hole-fills make row order nondeterministic) and is object key-order
-//     independent. Each todo carries its `id`, so the multiset still pins which
-//     todos exist with which `complete` flag.
-const quantize = (n: number): number => Math.round(Math.fround(n) * 100) / 100 + 0;
-
-const normalize = (value: unknown): unknown => {
-  if (typeof value === "number") return quantize(value);
-  if (Array.isArray(value)) return value.map(normalize);
-  if (value !== null && typeof value === "object") {
-    return Object.fromEntries(Object.entries(value).map(([key, v]) => [key, normalize(v)]));
-  }
-  return value;
-};
-
-export const expectStateMatches = (actual: State, expected: State): void => {
-  const a = normalize(actual);
-  const b = normalize(expected);
-  expect(
-    equalsUnordered(a, b),
-    `State mismatch:\n  actual   ${JSON.stringify(a)}\n  expected ${JSON.stringify(b)}`,
-  ).toBe(true);
-};
diff --git a/packages/data-lit-todo/src/features/main/data/state/public.ts b/packages/data-lit-todo/src/features/main/data/state/public.ts
index 45179cd8..2b941cbe 100644
--- a/packages/data-lit-todo/src/features/main/data/state/public.ts
+++ b/packages/data-lit-todo/src/features/main/data/state/public.ts
@@ -1,5 +1,8 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+export { create } from "./create.js";
+export { samples } from "./samples.js";
 export { createTodo } from "./create-todo.js";
+export { createRandomTodo } from "./create-random-todo.js";
 export { createBulkTodos } from "./create-bulk-todos.js";
 export { deleteTodo } from "./delete-todo.js";
 export { deleteAllTodos } from "./delete-all-todos.js";
diff --git a/packages/data-lit-todo/src/features/main/data/state/reorder-todo.cases.ts b/packages/data-lit-todo/src/features/main/data/state/reorder-todo.cases.ts
deleted file mode 100644
index a7706515..00000000
--- a/packages/data-lit-todo/src/features/main/data/state/reorder-todo.cases.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { ConformanceCase } from "./conformance-case.js";
-
-// Spec-owned `{ before, args, after }` cases for `State.reorderTodo`, shared with
-// the ecs `dragTodo` transaction (behaviourally the same move — `dragTodo`'s
-// final-drop `finalIndex` is `reorderTodo`'s `toIndex`). Every case keeps all
-// todos incomplete with `displayCompleted` true, so the visible list `dragTodo`
-// indexes into equals the full list `reorderTodo` indexes into. Todo ids run
-// 1..N in display order for round-trip. The unknown-id no-op branch is exercised
-// only by the pure transform test — `dragTodo` has no such guard.
-type Args = { readonly id: number; readonly toIndex: number };
-
-const three = [
-  { id: 1, name: "a", complete: false },
-  { id: 2, name: "b", complete: false },
-  { id: 3, name: "c", complete: false },
-];
-
-export const cases: readonly ConformanceCase<Args>[] = [
-  {
-    name: "moves the first todo to the end",
-    before: { todos: [...three], displayCompleted: true },
-    args: { id: 1, toIndex: 2 },
-    after: {
-      todos: [
-        { id: 2, name: "b", complete: false },
-        { id: 3, name: "c", complete: false },
-        { id: 1, name: "a", complete: false },
-      ],
-      displayCompleted: true,
-    },
-  },
-  {
-    name: "moves the last todo to the front",
-    before: { todos: [...three], displayCompleted: true },
-    args: { id: 3, toIndex: 0 },
-    after: {
-      todos: [
-        { id: 3, name: "c", complete: false },
-        { id: 1, name: "a", complete: false },
-        { id: 2, name: "b", complete: false },
-      ],
-      displayCompleted: true,
-    },
-  },
-  {
-    name: "clamps an out-of-range index to the end",
-    before: { todos: [...three], displayCompleted: true },
-    args: { id: 1, toIndex: 99 },
-    after: {
-      todos: [
-        { id: 2, name: "b", complete: false },
-        { id: 3, name: "c", complete: false },
-        { id: 1, name: "a", complete: false },
-      ],
-      displayCompleted: true,
-    },
-  },
-  {
-    name: "keeps the order when moving to the same index",
-    before: { todos: [...three], displayCompleted: true },
-    args: { id: 2, toIndex: 1 },
-    after: { todos: [...three], displayCompleted: true },
-  },
-];
diff --git a/packages/data-lit-todo/src/features/main/data/state/reorder-todo.test.ts b/packages/data-lit-todo/src/features/main/data/state/reorder-todo.test.ts
deleted file mode 100644
index 93666393..00000000
--- a/packages/data-lit-todo/src/features/main/data/state/reorder-todo.test.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it, expect } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./reorder-todo.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.reorderTodo", () => {
-  for (const { name, before, args, after } of cases) {
-    it(name, () => expectStateMatches(State.reorderTodo(before, args), after));
-  }
-
-  // Unknown-id no-op: pure-transform-only. The ecs `dragTodo` is always driven
-  // with a real entity, so this branch has no conformance counterpart.
-  it("returns the same state reference for an unknown id", () => {
-    const s: State = {
-      todos: [
-        { id: 1, name: "a", complete: false },
-        { id: 2, name: "b", complete: false },
-      ],
-      displayCompleted: true,
-    };
-    expect(State.reorderTodo(s, { id: 42, toIndex: 0 })).toBe(s);
-  });
-});
diff --git a/packages/data-lit-todo/src/features/main/data/state/reorder-todo.ts b/packages/data-lit-todo/src/features/main/data/state/reorder-todo.ts
index ffc783c9..157a977a 100644
--- a/packages/data-lit-todo/src/features/main/data/state/reorder-todo.ts
+++ b/packages/data-lit-todo/src/features/main/data/state/reorder-todo.ts
@@ -1,24 +1,89 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { State } from "./state.js";
-
+import { entity, type Conformance } from "./conformance-case.js";
+import { Match } from "@adobe/data/testing";
 /**
  * Moves the todo with the given id to `toIndex` within the list, preserving the
- * relative order of every other todo. Out-of-range indices are clamped and an
- * unknown id is a no-op.
+ * relative order of every other todo. Reads the todos, writes the todos — a
+ * `{ todos }` patch. Out-of-range indices are clamped and an unknown id is a
+ * no-op. A pure reorder — no side effects.
  */
-export const reorderTodo = <T extends Pick<State, "todos">>(
-  state: T,
+export const reorderTodo = (
+  state: Pick<State, "todos">,
   input: { readonly id: number; readonly toIndex: number },
-): T => {
+): Pick<State, "todos"> => {
   const fromIndex = state.todos.findIndex((todo) => todo.id === input.id);
-  if (fromIndex === -1) return state;
+  if (fromIndex === -1) return { todos: state.todos };
 
   const moved = state.todos[fromIndex];
   const without = state.todos.filter((todo) => todo.id !== input.id);
   const toIndex = Math.max(0, Math.min(input.toIndex, without.length));
 
   return {
-    ...state,
     todos: [...without.slice(0, toIndex), moved, ...without.slice(toIndex)],
   };
 };
+
+const three = [
+  { id: 1, name: "a", complete: false },
+  { id: 2, name: "b", complete: false },
+  { id: 3, name: "c", complete: false },
+];
+
+// Spec-owned cases, shared with the ecs `dragTodo` transaction (its final drop is
+// the same move — `finalIndex` is `toIndex`). `before` is a delta over
+// `State.create()`; `after` lists only the written todos. Every case keeps all
+// todos incomplete with `displayCompleted` true, so the visible list `dragTodo`
+// indexes equals the full list. `before` ids address the move; `after` ids are
+// open (`Match.anyNumber`) but their *order* is verified. The unknown-id no-op is
+// exercised only by the pure transform — `dragTodo` has no such guard.
+export const cases: Conformance<typeof reorderTodo> = [
+  {
+    name: "moves the first todo to the end",
+    before: { todos: [...three], displayCompleted: true },
+    args: { id: entity(1), toIndex: 2 },
+    after: {
+      todos: [
+        { id: Match.anyNumber, name: "b", complete: false },
+        { id: Match.anyNumber, name: "c", complete: false },
+        { id: Match.anyNumber, name: "a", complete: false },
+      ],
+    },
+  },
+  {
+    name: "moves the last todo to the front",
+    before: { todos: [...three], displayCompleted: true },
+    args: { id: entity(3), toIndex: 0 },
+    after: {
+      todos: [
+        { id: Match.anyNumber, name: "c", complete: false },
+        { id: Match.anyNumber, name: "a", complete: false },
+        { id: Match.anyNumber, name: "b", complete: false },
+      ],
+    },
+  },
+  {
+    name: "clamps an out-of-range index to the end",
+    before: { todos: [...three], displayCompleted: true },
+    args: { id: entity(1), toIndex: 99 },
+    after: {
+      todos: [
+        { id: Match.anyNumber, name: "b", complete: false },
+        { id: Match.anyNumber, name: "c", complete: false },
+        { id: Match.anyNumber, name: "a", complete: false },
+      ],
+    },
+  },
+  {
+    name: "keeps the order when moving to the same index",
+    before: { todos: [...three], displayCompleted: true },
+    args: { id: entity(2), toIndex: 1 },
+    after: {
+      todos: [
+        { id: Match.anyNumber, name: "a", complete: false },
+        { id: Match.anyNumber, name: "b", complete: false },
+        { id: Match.anyNumber, name: "c", complete: false },
+      ],
+    },
+  },
+];
diff --git a/packages/data-lit-todo/src/features/main/data/state/samples.ts b/packages/data-lit-todo/src/features/main/data/state/samples.ts
new file mode 100644
index 00000000..e2c6ffd9
--- /dev/null
+++ b/packages/data-lit-todo/src/features/main/data/state/samples.ts
@@ -0,0 +1,27 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Match } from "@adobe/data/testing";
+import type { State } from "./state.js";
+
+// Representative full states for the projection round-trip (toState ∘ fromState ≡
+// identity). Todo ids are authored as `anyNumber`: the ecs reassigns ids from its
+// own id-space, so the round-trip leaves them open. Varied lists (mixed
+// complete/incomplete, empty, duplicate names) exercise the whole ecs↔State map.
+export const samples: readonly State[] = [
+  {
+    todos: [
+      { id: Match.anyNumber, name: "buy milk", complete: false },
+      { id: Match.anyNumber, name: "walk dog", complete: true },
+      { id: Match.anyNumber, name: "write tests", complete: false },
+    ],
+    displayCompleted: true,
+  },
+  { todos: [], displayCompleted: false },
+  {
+    todos: [
+      { id: Match.anyNumber, name: "task", complete: false },
+      { id: Match.anyNumber, name: "task", complete: false },
+      { id: Match.anyNumber, name: "task", complete: true },
+    ],
+    displayCompleted: false,
+  },
+];
diff --git a/packages/data-lit-todo/src/features/main/data/state/spec.test.ts b/packages/data-lit-todo/src/features/main/data/state/spec.test.ts
new file mode 100644
index 00000000..9d5c4074
--- /dev/null
+++ b/packages/data-lit-todo/src/features/main/data/state/spec.test.ts
@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Conformance } from "@adobe/data/testing";
+import { State } from "./state.js";
+import { transitions } from "./transitions.js";
+
+// The single pure-spec test for every transform AND derivation in this folder.
+// `runSpec` auto-discovers each module in `transitions` that exports `cases`,
+// requires it to export exactly its function plus `cases`, and dispatches on case
+// shape. Each case's `before`/`input` is a delta over `State.create()`.
+Conformance.runSpec({ state: State, transitions });
diff --git a/packages/data-lit-todo/src/features/main/data/state/toggle-complete.cases.ts b/packages/data-lit-todo/src/features/main/data/state/toggle-complete.cases.ts
deleted file mode 100644
index 314ca4e2..00000000
--- a/packages/data-lit-todo/src/features/main/data/state/toggle-complete.cases.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { ConformanceCase } from "./conformance-case.js";
-
-// Spec-owned `{ before, args, after }` cases for `State.toggleComplete`, shared
-// with the ecs `toggleComplete` transaction. Only the matching todo's `complete`
-// flag flips; an unknown id is a no-op. Todo ids run 1..N in display order.
-type Args = { readonly id: number };
-
-export const cases: readonly ConformanceCase<Args>[] = [
-  {
-    name: "marks an incomplete todo complete",
-    before: {
-      todos: [
-        { id: 1, name: "a", complete: false },
-        { id: 2, name: "b", complete: false },
-      ],
-      displayCompleted: false,
-    },
-    args: { id: 1 },
-    after: {
-      todos: [
-        { id: 1, name: "a", complete: true },
-        { id: 2, name: "b", complete: false },
-      ],
-      displayCompleted: false,
-    },
-  },
-  {
-    name: "marks a complete todo incomplete",
-    before: {
-      todos: [
-        { id: 1, name: "a", complete: true },
-        { id: 2, name: "b", complete: false },
-      ],
-      displayCompleted: true,
-    },
-    args: { id: 1 },
-    after: {
-      todos: [
-        { id: 1, name: "a", complete: false },
-        { id: 2, name: "b", complete: false },
-      ],
-      displayCompleted: true,
-    },
-  },
-  {
-    name: "is a no-op for an unknown id",
-    before: { todos: [{ id: 1, name: "a", complete: false }], displayCompleted: false },
-    args: { id: 99 },
-    after: { todos: [{ id: 1, name: "a", complete: false }], displayCompleted: false },
-  },
-];
diff --git a/packages/data-lit-todo/src/features/main/data/state/toggle-complete.test.ts b/packages/data-lit-todo/src/features/main/data/state/toggle-complete.test.ts
deleted file mode 100644
index ea502251..00000000
--- a/packages/data-lit-todo/src/features/main/data/state/toggle-complete.test.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./toggle-complete.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.toggleComplete", () => {
-  for (const { name, before, args, after } of cases) {
-    it(name, () => expectStateMatches(State.toggleComplete(before, args), after));
-  }
-});
diff --git a/packages/data-lit-todo/src/features/main/data/state/toggle-complete.ts b/packages/data-lit-todo/src/features/main/data/state/toggle-complete.ts
index 7d62008d..739fc1bb 100644
--- a/packages/data-lit-todo/src/features/main/data/state/toggle-complete.ts
+++ b/packages/data-lit-todo/src/features/main/data/state/toggle-complete.ts
@@ -1,12 +1,76 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+import { AnalyticsService } from "../../services/analytics-service/analytics-service.js";
 import type { State } from "./state.js";
+import { entity, type Conformance } from "./conformance-case.js";
+import { Match } from "@adobe/data/testing";
 
-export const toggleComplete = <T extends Pick<State, "todos">>(
-  state: T,
-  input: { readonly id: number },
-): T => ({
-  ...state,
-  todos: state.todos.map((todo) =>
-    todo.id === input.id ? { ...todo, complete: !todo.complete } : todo,
-  ),
-});
+// Reads the todos, writes the todos — a `{ todos }` patch — flipping the
+// addressed todo's `complete`; also logs `todoToggled`.
+export const toggleComplete = (
+  state: Pick<State, "todos">,
+  {
+    id,
+    analytics,
+  }: { readonly id: number; readonly analytics: AnalyticsService },
+): Pick<State, "todos"> => {
+  analytics.todoToggled();
+  return {
+    todos: state.todos.map((todo) =>
+      todo.id === id ? { ...todo, complete: !todo.complete } : todo,
+    ),
+  };
+};
+
+// Spec-owned cases, shared with the ecs `toggleComplete` transaction. `before` is
+// a delta over `State.create()`; `after` lists only the written todos. Only the
+// addressed todo's `complete` flips; an unknown id is a no-op. The transition
+// logs `todoToggled` unconditionally (as the action does). `before` ids address
+// the toggle; `after` ids are left open (`Match.anyNumber`).
+export const cases: Conformance<typeof toggleComplete> = [
+  {
+    name: "marks an incomplete todo complete",
+    before: {
+      todos: [
+        { id: 1, name: "a", complete: false },
+        { id: 2, name: "b", complete: false },
+      ],
+    },
+    args: { id: entity(1), analytics: AnalyticsService.createFake() },
+    after: {
+      todos: [
+        { id: Match.anyNumber, name: "a", complete: true },
+        { id: Match.anyNumber, name: "b", complete: false },
+      ],
+    },
+    effects: { analytics: [["todoToggled"]] },
+  },
+  {
+    name: "marks a complete todo incomplete",
+    before: {
+      todos: [
+        { id: 1, name: "a", complete: true },
+        { id: 2, name: "b", complete: false },
+      ],
+      displayCompleted: true,
+    },
+    args: { id: entity(1), analytics: AnalyticsService.createFake() },
+    after: {
+      todos: [
+        { id: Match.anyNumber, name: "a", complete: false },
+        { id: Match.anyNumber, name: "b", complete: false },
+      ],
+    },
+    effects: { analytics: [["todoToggled"]] },
+  },
+  {
+    name: "is a no-op for an unknown id but still logs the toggle",
+    before: {
+      todos: [{ id: 1, name: "a", complete: false }],
+    },
+    args: { id: entity(99), analytics: AnalyticsService.createFake() },
+    after: {
+      todos: [{ id: Match.anyNumber, name: "a", complete: false }],
+    },
+    effects: { analytics: [["todoToggled"]] },
+  },
+];
diff --git a/packages/data-lit-todo/src/features/main/data/state/toggle-display-completed.cases.ts b/packages/data-lit-todo/src/features/main/data/state/toggle-display-completed.cases.ts
deleted file mode 100644
index ba775673..00000000
--- a/packages/data-lit-todo/src/features/main/data/state/toggle-display-completed.cases.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { ConformanceCase } from "./conformance-case.js";
-
-// Spec-owned `{ before, args, after }` cases for `State.toggleDisplayCompleted`
-// (no args), shared with the ecs `toggleDisplayCompleted` transaction. Only the
-// `displayCompleted` flag flips; the todos are untouched.
-export const cases: readonly ConformanceCase<undefined>[] = [
-  {
-    name: "turns the completed view on",
-    before: { todos: [], displayCompleted: false },
-    args: undefined,
-    after: { todos: [], displayCompleted: true },
-  },
-  {
-    name: "turns the completed view off, leaving todos intact",
-    before: { todos: [{ id: 1, name: "a", complete: true }], displayCompleted: true },
-    args: undefined,
-    after: { todos: [{ id: 1, name: "a", complete: true }], displayCompleted: false },
-  },
-];
diff --git a/packages/data-lit-todo/src/features/main/data/state/toggle-display-completed.test.ts b/packages/data-lit-todo/src/features/main/data/state/toggle-display-completed.test.ts
deleted file mode 100644
index e65e04ae..00000000
--- a/packages/data-lit-todo/src/features/main/data/state/toggle-display-completed.test.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it } from "vitest";
-import { State } from "./state.js";
-import { cases } from "./toggle-display-completed.cases.js";
-import { expectStateMatches } from "./expect-state-matches.js";
-
-describe("State.toggleDisplayCompleted", () => {
-  for (const { name, before, after } of cases) {
-    it(name, () => expectStateMatches(State.toggleDisplayCompleted(before), after));
-  }
-});
diff --git a/packages/data-lit-todo/src/features/main/data/state/toggle-display-completed.ts b/packages/data-lit-todo/src/features/main/data/state/toggle-display-completed.ts
index e5758322..1c1f1031 100644
--- a/packages/data-lit-todo/src/features/main/data/state/toggle-display-completed.ts
+++ b/packages/data-lit-todo/src/features/main/data/state/toggle-display-completed.ts
@@ -1,9 +1,45 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+import { AnalyticsService } from "../../services/analytics-service/analytics-service.js";
 import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+import { Match } from "@adobe/data/testing";
 
-export const toggleDisplayCompleted = <T extends Pick<State, "displayCompleted">>(
-  state: T,
-): T => ({
-  ...state,
-  displayCompleted: !state.displayCompleted,
-});
+// Reads `displayCompleted`, writes `displayCompleted` — a `{ displayCompleted }`
+// patch — flipping the flag; also logs `displayCompletedToggled`.
+export const toggleDisplayCompleted = (
+  state: Pick<State, "displayCompleted">,
+  { analytics }: { readonly analytics: AnalyticsService },
+): Pick<State, "displayCompleted"> => {
+  analytics.displayCompletedToggled();
+  return { displayCompleted: !state.displayCompleted };
+};
+
+// Spec-owned cases, shared with the ecs `toggleDisplayCompleted` transaction.
+// `before` is a delta over `State.create()`; `after` lists only the written
+// `displayCompleted`. Only the flag flips; todos are untouched; the transition
+// logs `displayCompletedToggled` (as the action does).
+export const cases: Conformance<typeof toggleDisplayCompleted> = [
+  {
+    name: "turns the completed view on",
+    before: {},
+    args: { analytics: AnalyticsService.createFake() },
+    after: { displayCompleted: true },
+    effects: { analytics: [["displayCompletedToggled"]] },
+  },
+  {
+    name: "turns the completed view off, leaving todos intact",
+    before: {
+      todos: [{ id: 1, name: "a", complete: true }],
+      displayCompleted: true,
+    },
+    args: { analytics: AnalyticsService.createFake() },
+    // Only `displayCompleted` is written, but the carried-through todo holds an
+    // ecs-minted id, so it is restated with `Match.anyNumber` to bridge the
+    // seeded data id (1) and the id the ecs assigns on the round-trip.
+    after: {
+      todos: [{ id: Match.anyNumber, name: "a", complete: true }],
+      displayCompleted: false,
+    },
+    effects: { analytics: [["displayCompletedToggled"]] },
+  },
+];
diff --git a/packages/data-lit-todo/src/features/main/data/state/transitions.ts b/packages/data-lit-todo/src/features/main/data/state/transitions.ts
new file mode 100644
index 00000000..1092fd91
--- /dev/null
+++ b/packages/data-lit-todo/src/features/main/data/state/transitions.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+/// <reference types="vite/client" />
+
+// The transform/derivation modules for conformance discovery — the `{ fn, cases }`
+// source shared by `spec.test.ts` (pure) and the ecs `conformance.test.ts`. The
+// glob must be authored where Vite can statically see it (an eager glob, excluding
+// tests and this file itself); consumers import the resolved map.
+export const transitions = import.meta.glob<Record<string, unknown>>(
+  ["./*.ts", "!./*.test.ts", "!./*.type-test.ts", "!./transitions.ts"],
+  { eager: true },
+);
diff --git a/packages/data-lit-todo/src/features/main/data/state/visible-todos.test.ts b/packages/data-lit-todo/src/features/main/data/state/visible-todos.test.ts
deleted file mode 100644
index 1beceab9..00000000
--- a/packages/data-lit-todo/src/features/main/data/state/visible-todos.test.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { describe, it, expect } from "vitest";
-import { State } from "./state.js";
-
-const s: State = {
-  todos: [
-    { id: 1, name: "a", complete: false },
-    { id: 2, name: "b", complete: true },
-  ],
-  displayCompleted: false,
-};
-
-describe("State.visibleTodos", () => {
-  it("hides completed todos unless displayCompleted", () => {
-    expect(State.visibleTodos(s).map((t) => t.id)).toEqual([1]);
-    expect(State.visibleTodos({ ...s, displayCompleted: true }).map((t) => t.id)).toEqual([1, 2]);
-  });
-});
diff --git a/packages/data-lit-todo/src/features/main/data/state/visible-todos.ts b/packages/data-lit-todo/src/features/main/data/state/visible-todos.ts
index e099c888..028ba12f 100644
--- a/packages/data-lit-todo/src/features/main/data/state/visible-todos.ts
+++ b/packages/data-lit-todo/src/features/main/data/state/visible-todos.ts
@@ -1,7 +1,8 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { State } from "./state.js";
 import type { Todo } from "../todo/todo.js";
-
+import type { Derivation } from "./conformance-case.js";
+import { Match } from "@adobe/data/testing";
 // The todos the user should see, in display order: all of them when
 // `displayCompleted`, otherwise only the incomplete ones.
 export const visibleTodos = (
@@ -10,3 +11,38 @@ export const visibleTodos = (
   state.displayCompleted
     ? state.todos
     : state.todos.filter((todo) => !todo.complete);
+
+// Spec-owned cases, shared with the ecs `visibleTodos` computed. A derivation
+// case is `{ input, value }`; `value` leaves ids open (`Match.anyNumber`) and its order
+// is significant (display order).
+export const cases: Derivation<typeof visibleTodos> = [
+  {
+    name: "hides completed todos unless the completed view is on",
+    input: {
+      todos: [
+        { id: 1, name: "a", complete: false },
+        { id: 2, name: "b", complete: true },
+        { id: 3, name: "c", complete: false },
+      ],
+      displayCompleted: false,
+    },
+    value: [
+      { id: Match.anyNumber, name: "a", complete: false },
+      { id: Match.anyNumber, name: "c", complete: false },
+    ],
+  },
+  {
+    name: "shows every todo when the completed view is on",
+    input: {
+      todos: [
+        { id: 1, name: "a", complete: false },
+        { id: 2, name: "b", complete: true },
+      ],
+      displayCompleted: true,
+    },
+    value: [
+      { id: Match.anyNumber, name: "a", complete: false },
+      { id: Match.anyNumber, name: "b", complete: true },
+    ],
+  },
+];
diff --git a/packages/data-lit-todo/src/features/main/services/todo-analytics-service/todo-analytics-service.ts b/packages/data-lit-todo/src/features/main/services/analytics-service/analytics-service.ts
similarity index 79%
rename from packages/data-lit-todo/src/features/main/services/todo-analytics-service/todo-analytics-service.ts
rename to packages/data-lit-todo/src/features/main/services/analytics-service/analytics-service.ts
index a8ff3c55..4f07d838 100644
--- a/packages/data-lit-todo/src/features/main/services/todo-analytics-service/todo-analytics-service.ts
+++ b/packages/data-lit-todo/src/features/main/services/analytics-service/analytics-service.ts
@@ -7,9 +7,10 @@ import type { Assert } from "@adobe/data/types";
  * Opaque handle returned by `randomTodoRequested` and handed straight back to
  * `randomTodoAdded`. The action treats it as a black box — it never inspects or
  * constructs one — so timing lives entirely in the service without the service
- * holding any state between the two calls.
+ * holding any state between the two calls. Exported (not re-exported through
+ * `public.ts`) so the adjacent `create-fake.ts` double can name it.
  */
-type Timing = { readonly startedAt: number };
+export type Timing = { readonly startedAt: number };
 
 /**
  * Feature-specific analytics port. One named method per user interaction, each
@@ -19,7 +20,7 @@ type Timing = { readonly startedAt: number };
  * so no event-name strings or payload shaping leak into the actions.
  * Fire-and-forget (`void`) so the UI never awaits telemetry.
  */
-export interface TodoAnalyticsService extends Service {
+export interface AnalyticsService extends Service {
   todoCreated: (args: { readonly name: string }) => void;
   bulkTodosCreated: (args: { readonly count: number }) => void;
   todoToggled: () => void;
@@ -31,6 +32,6 @@ export interface TodoAnalyticsService extends Service {
 }
 
 // Contract conforms to the async-data-service pattern (void / async members only).
-type _Valid = Assert<AsyncDataService.IsValid<TodoAnalyticsService>>;
+type _Valid = Assert<AsyncDataService.IsValid<AnalyticsService>>;
 
-export * as TodoAnalyticsService from "./public.js";
+export * as AnalyticsService from "./public.js";
diff --git a/packages/data-lit-todo/src/features/main/services/analytics-service/create-fake.ts b/packages/data-lit-todo/src/features/main/services/analytics-service/create-fake.ts
new file mode 100644
index 00000000..da40c49c
--- /dev/null
+++ b/packages/data-lit-todo/src/features/main/services/analytics-service/create-fake.ts
@@ -0,0 +1,22 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { AnalyticsService } from "./analytics-service.js";
+
+/**
+ * Deterministic test double for {@link AnalyticsService}. The `void`
+ * fire-and-forget methods do nothing; `randomTodoRequested` resolves a fixed
+ * timing of `{ startedAt: 0 }` on the microtask queue instead of reading the
+ * clock. A case that asserts on the timing references that literal directly.
+ * This is the implementation tests inject so their
+ * assertions are predictable — see `features/services/index.md`.
+ */
+export const createFake = (): AnalyticsService => ({
+  serviceName: "analytics",
+  todoCreated: () => {},
+  bulkTodosCreated: () => {},
+  todoToggled: () => {},
+  todoDeleted: () => {},
+  allTodosCleared: () => {},
+  displayCompletedToggled: () => {},
+  randomTodoRequested: () => Promise.resolve({ startedAt: 0 }),
+  randomTodoAdded: () => {},
+});
diff --git a/packages/data-lit-todo/src/features/main/services/todo-analytics-service/create.ts b/packages/data-lit-todo/src/features/main/services/analytics-service/create.ts
similarity index 74%
rename from packages/data-lit-todo/src/features/main/services/todo-analytics-service/create.ts
rename to packages/data-lit-todo/src/features/main/services/analytics-service/create.ts
index 06b2538b..9e0f657e 100644
--- a/packages/data-lit-todo/src/features/main/services/todo-analytics-service/create.ts
+++ b/packages/data-lit-todo/src/features/main/services/analytics-service/create.ts
@@ -1,11 +1,11 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { TodoAnalyticsService } from "./todo-analytics-service.js";
+import type { AnalyticsService } from "./analytics-service.js";
 
-const log = (message: string): void => console.log(`[todo-analytics] ${message}`);
+const log = (message: string): void => console.log(`[analytics] ${message}`);
 
 /** Development implementation: owns the timing and formats each named event. */
-export const create = (): TodoAnalyticsService => ({
-  serviceName: "todoAnalytics",
+export const create = (): AnalyticsService => ({
+  serviceName: "analytics",
   todoCreated: ({ name }) => log(`created todo "${name}"`),
   bulkTodosCreated: ({ count }) => log(`created ${count} todos`),
   todoToggled: () => log("toggled a todo's completion"),
diff --git a/packages/data-lit-todo/src/features/main/services/analytics-service/public.ts b/packages/data-lit-todo/src/features/main/services/analytics-service/public.ts
new file mode 100644
index 00000000..56c941d3
--- /dev/null
+++ b/packages/data-lit-todo/src/features/main/services/analytics-service/public.ts
@@ -0,0 +1,3 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { create } from "./create.js";
+export { createFake } from "./create-fake.js";
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/add-random-todo.ts b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/add-random-todo.ts
deleted file mode 100644
index 5054f89d..00000000
--- a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/add-random-todo.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { ServiceDatabase } from "../../service-database/service-database.js";
-
-/**
- * Showcase of an async service inside an action: bracket the slow
- * name-generation call with analytics start/end events so the telemetry
- * captures how long the outbound call took, then commit the result through a
- * single transaction. The UI never awaits this — state flows back via
- * observables.
- */
-export const addRandomTodo = async (db: ServiceDatabase) => {
-  // The service owns timing: it mints an opaque token here and computes the
-  // elapsed time when we hand it back — this action never sees the clock.
-  const timing = await db.services.todoAnalytics.randomTodoRequested();
-  const name = await db.services.nameGenerator.generateName();
-  db.transactions.createTodo({ name });
-  db.services.todoAnalytics.randomTodoAdded({ timing, name });
-};
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/create-bulk-todos.ts b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/create-bulk-todos.ts
index 9c7a780f..1fe87f84 100644
--- a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/create-bulk-todos.ts
+++ b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/create-bulk-todos.ts
@@ -5,6 +5,6 @@ export const createBulkTodos = (
   db: ServiceDatabase,
   input: { readonly count: number },
 ) => {
-  db.services.todoAnalytics.bulkTodosCreated({ count: input.count });
+  db.services.analytics.bulkTodosCreated({ count: input.count });
   db.transactions.createBulkTodos(input);
 };
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/create-random-todo.ts b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/create-random-todo.ts
new file mode 100644
index 00000000..c5abe52e
--- /dev/null
+++ b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/create-random-todo.ts
@@ -0,0 +1,20 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+/**
+ * Efficient ecs counterpart to the pure `State.createRandomTodo` spec (which
+ * injects the same `nameGenerator` port): here the port is reached through the
+ * `services` facet and the append is an O(1) `createTodo` transaction rather
+ * than a whole-`State` rebuild. This action additionally brackets the slow
+ * name-generation call with analytics start/end events so the telemetry
+ * captures how long the outbound call took. The UI never awaits this — state
+ * flows back via observables.
+ */
+export const createRandomTodo = async (db: ServiceDatabase) => {
+  // The service owns timing: it mints an opaque token here and computes the
+  // elapsed time when we hand it back — this action never sees the clock.
+  const timing = await db.services.analytics.randomTodoRequested();
+  const name = await db.services.nameGenerator.generateName();
+  db.transactions.createTodo({ name });
+  db.services.analytics.randomTodoAdded({ timing, name });
+};
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/create-todo.ts b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/create-todo.ts
index a7a5ec2f..7d2ee364 100644
--- a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/create-todo.ts
+++ b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/create-todo.ts
@@ -5,6 +5,6 @@ export const createTodo = (
   db: ServiceDatabase,
   input: { readonly name: string; readonly complete?: boolean },
 ) => {
-  db.services.todoAnalytics.todoCreated({ name: input.name });
+  db.services.analytics.todoCreated({ name: input.name });
   db.transactions.createTodo(input);
 };
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/delete-all-todos.ts b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/delete-all-todos.ts
index ab470ab3..9c4c5afa 100644
--- a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/delete-all-todos.ts
+++ b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/delete-all-todos.ts
@@ -2,6 +2,6 @@
 import type { ServiceDatabase } from "../../service-database/service-database.js";
 
 export const deleteAllTodos = (db: ServiceDatabase) => {
-  db.services.todoAnalytics.allTodosCleared();
+  db.services.analytics.allTodosCleared();
   db.transactions.deleteAllTodos();
 };
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/delete-todo.ts b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/delete-todo.ts
index 2e16adf1..07a4da8e 100644
--- a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/delete-todo.ts
+++ b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/delete-todo.ts
@@ -2,7 +2,7 @@
 import type { Entity } from "@adobe/data/ecs";
 import type { ServiceDatabase } from "../../service-database/service-database.js";
 
-export const deleteTodo = (db: ServiceDatabase, id: Entity) => {
-  db.services.todoAnalytics.todoDeleted();
-  db.transactions.deleteTodo(id);
+export const deleteTodo = (db: ServiceDatabase, { id }: { id: Entity }) => {
+  db.services.analytics.todoDeleted();
+  db.transactions.deleteTodo({ id });
 };
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/index.ts b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/index.ts
index 4e542a0c..b9746cb3 100644
--- a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/index.ts
+++ b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/index.ts
@@ -1,8 +1,9 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 export * from "./create-todo.js";
 export * from "./create-bulk-todos.js";
-export * from "./add-random-todo.js";
+export * from "./create-random-todo.js";
 export * from "./toggle-complete.js";
 export * from "./delete-todo.js";
 export * from "./delete-all-todos.js";
 export * from "./toggle-display-completed.js";
+export * from "./reorder-todo.js";
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/reorder-todo.ts b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/reorder-todo.ts
new file mode 100644
index 00000000..c236d909
--- /dev/null
+++ b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/reorder-todo.ts
@@ -0,0 +1,18 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Entity } from "@adobe/data/ecs";
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+// Move a todo to `toIndex` — the programmatic counterpart of the drag UI (which
+// dispatches the richer `dragTodo` transaction directly). Reproduces
+// `State.reorderTodo` as a single final-drop `dragTodo` commit, so it is the
+// same-named action that conforms the `reorderTodo` transition.
+export const reorderTodo = (
+  db: ServiceDatabase,
+  { id, toIndex }: { id: Entity; toIndex: number },
+) => {
+  db.transactions.dragTodo({
+    entity: id,
+    dragPosition: 0,
+    finalIndex: toIndex,
+  });
+};
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/toggle-complete.ts b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/toggle-complete.ts
index 5ff19009..1c28b624 100644
--- a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/toggle-complete.ts
+++ b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/toggle-complete.ts
@@ -2,7 +2,7 @@
 import type { Entity } from "@adobe/data/ecs";
 import type { ServiceDatabase } from "../../service-database/service-database.js";
 
-export const toggleComplete = (db: ServiceDatabase, id: Entity) => {
-  db.services.todoAnalytics.todoToggled();
-  db.transactions.toggleComplete(id);
+export const toggleComplete = (db: ServiceDatabase, { id }: { id: Entity }) => {
+  db.services.analytics.todoToggled();
+  db.transactions.toggleComplete({ id });
 };
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/toggle-display-completed.ts b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/toggle-display-completed.ts
index d79f17bc..2207e706 100644
--- a/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/toggle-display-completed.ts
+++ b/packages/data-lit-todo/src/features/main/services/main-service/action-database/actions/toggle-display-completed.ts
@@ -2,6 +2,6 @@
 import type { ServiceDatabase } from "../../service-database/service-database.js";
 
 export const toggleDisplayCompleted = (db: ServiceDatabase) => {
-  db.services.todoAnalytics.displayCompletedToggled();
+  db.services.analytics.displayCompletedToggled();
   db.transactions.toggleDisplayCompleted();
 };
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/conformance/conformance.test.ts b/packages/data-lit-todo/src/features/main/services/main-service/conformance/conformance.test.ts
new file mode 100644
index 00000000..fb951fc0
--- /dev/null
+++ b/packages/data-lit-todo/src/features/main/services/main-service/conformance/conformance.test.ts
@@ -0,0 +1,23 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Conformance } from "@adobe/data/testing";
+import { State } from "../../../data/state/state.js";
+import { transitions } from "../../../data/state/transitions.js";
+import { MainService } from "../main-service.js";
+import { ComputedDatabase } from "../computed-database/computed-database.js";
+import { projection } from "./projection.js";
+
+// The whole ecs conformance for this feature in one call: `runFeature` pulls the
+// transactions/actions off `MainService.plugin`, the computeds off the
+// `ComputedDatabase` layer, seeds each case's `before` (a delta) over
+// `State.create()`, and round-trips `State.samples` through the projection.
+// `transitions` (the discovered `{ fn, cases }` modules) is shared with spec.test.
+// `visibleTodos` emits entity ids, so it is named in `hydrate` to project each
+// through `toData` into the `Todo[]` the derivation yields.
+Conformance.runFeature({
+  state: State,
+  transitions,
+  plugin: MainService.plugin,
+  computedPlugin: ComputedDatabase.plugin,
+  projection,
+  hydrate: ["visibleTodos"],
+});
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/conformance/create-store.ts b/packages/data-lit-todo/src/features/main/services/main-service/conformance/create-store.ts
deleted file mode 100644
index c94f0d01..00000000
--- a/packages/data-lit-todo/src/features/main/services/main-service/conformance/create-store.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { Store } from "@adobe/data/ecs";
-import type { CoreDatabase } from "../core-database/core-database.js";
-import { IndexDatabase } from "../index-database/index-database.js";
-
-// A fresh writable store carrying the feature's whole schema. `IndexDatabase` is
-// the lowest layer that declares it all (components / resources / archetypes +
-// indexes) — the behaviour layers above add none — and `Store.create` reads a
-// plugin's schema facets directly. Typed as `CoreDatabase.Store`: the surface the
-// projection (`fromState` / `toState`) and the raw transaction functions use.
-// Test-only.
-export const createStore = (): CoreDatabase.Store => Store.create(IndexDatabase.plugin);
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/conformance/expect-conforms.ts b/packages/data-lit-todo/src/features/main/services/main-service/conformance/expect-conforms.ts
deleted file mode 100644
index c2b0ca38..00000000
--- a/packages/data-lit-todo/src/features/main/services/main-service/conformance/expect-conforms.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { it } from "vitest";
-import { Entity } from "@adobe/data/ecs";
-import type { State } from "../../../data/state/state.js";
-import type { ConformanceCase } from "../../../data/state/conformance-case.js";
-import { expectStateMatches } from "../../../data/state/expect-state-matches.js";
-import type { CoreDatabase } from "../core-database/core-database.js";
-import { createStore } from "./create-store.js";
-import { fromState } from "./from-state.js";
-import { toState } from "./to-state.js";
-import { expectStateMatchesIgnoringIds } from "./expect-state-matches-ignoring-ids.js";
-
-// Resolve a spec domain `id` to the ecs entity seeded for it. `fromState`
-// returns the seeded entities in display order, so the i-th `before` todo maps
-// to the i-th entity; an id no todo carries resolves to `Entity.none`, so an
-// id-addressed transaction reads no such entity and is a no-op.
-export type ResolveEntity = (specId: number) => Entity;
-
-// The conformance runner, bound to THIS feature's projection (`fromState` /
-// `toState`). For each case it proves the one conformance property
-//
-//   toState(apply(fromState(before), args)) ≡ spec(before, args)
-//
-// in two asserted halves:
-//   1. `spec(before, args) ≡ after` — keeps the shared case honest (a
-//      mis-authored `after` is caught here, independent of the ecs path).
-//   2. seed `fromState(before)` → run the caller's `apply` → `toState ≡ after`
-//      — the ecs implementation reproduces the pure transform.
-//
-// `apply` receives the seeded writable store, the case args, and a `resolve`
-// that maps a spec `id` to the seeded entity, then calls the raw transaction
-// function directly (a transaction is `(store, …) => void`, so no `Database`
-// is involved). Half 2 compares ignoring todo `id` (`expectStateMatchesIgnoringIds`):
-// the ecs owns its entity-id space, so the projection conforms only up to a
-// renaming of ids. Half 1 stays id-strict — the spec fully owns its domain ids.
-export const expectConforms = <Args>(config: {
-  readonly cases: readonly ConformanceCase<Args>[];
-  readonly spec: (before: State, args: Args) => State;
-  readonly apply: (store: CoreDatabase.Store, args: Args, resolve: ResolveEntity) => void;
-}): void => {
-  for (const testCase of config.cases) {
-    it(testCase.name, () => {
-      expectStateMatches(config.spec(testCase.before, testCase.args), testCase.after);
-
-      const store = createStore();
-      const entities = fromState(store, testCase.before);
-      const bySpecId = new Map(testCase.before.todos.map((todo, i) => [todo.id, entities[i]]));
-      const resolve: ResolveEntity = (specId) => bySpecId.get(specId) ?? Entity.none;
-      config.apply(store, testCase.args, resolve);
-      expectStateMatchesIgnoringIds(toState(store), testCase.after);
-    });
-  }
-};
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/conformance/expect-state-matches-ignoring-ids.ts b/packages/data-lit-todo/src/features/main/services/main-service/conformance/expect-state-matches-ignoring-ids.ts
deleted file mode 100644
index 5ef1da1d..00000000
--- a/packages/data-lit-todo/src/features/main/services/main-service/conformance/expect-state-matches-ignoring-ids.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { State } from "../../../data/state/state.js";
-import { expectStateMatches } from "../../../data/state/expect-state-matches.js";
-
-// Like `expectStateMatches`, but compares todos without regard to their `id`.
-// The ecs projects each todo's entity id — drawn from its own quadrant-encoded
-// id-space — into `State.id`, which does not match the spec's domain `id`. The
-// projection therefore conforms only up to a renaming of ids: canonicalise both
-// sides to a single id so the comparison rests on the visible fields (`name`,
-// `complete`) and the resource, never the id value. Duplicates still count
-// (the multiset comparison is by value), so name-sharing round-trips hold.
-const canonicalizeIds = (state: State): State => ({
-  ...state,
-  todos: state.todos.map((todo) => ({ ...todo, id: 0 })),
-});
-
-export const expectStateMatchesIgnoringIds = (actual: State, expected: State): void =>
-  expectStateMatches(canonicalizeIds(actual), canonicalizeIds(expected));
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/conformance/from-state.ts b/packages/data-lit-todo/src/features/main/services/main-service/conformance/from-state.ts
deleted file mode 100644
index f7e15a3c..00000000
--- a/packages/data-lit-todo/src/features/main/services/main-service/conformance/from-state.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { Entity } from "@adobe/data/ecs";
-import type { State } from "../../../data/state/state.js";
-import type { CoreDatabase } from "../core-database/core-database.js";
-
-// Seed a store to exactly match a `data/` `State`: clear every todo, set the
-// `displayCompleted` resource, then insert the todos in display order. The
-// inverse of `toState`. Test-only — the bridge that lets an ecs mutation be
-// checked against the pure transform it stands for (see `expect-conforms.ts`).
-//
-// Clearing iterates tail→head so each delete is from the tail (no hole-fill
-// shift). Todos are inserted in array (display) order with `order` = the index;
-// the implementation-only slots (`dragPosition`, `assignees`) are seeded empty.
-//
-// The ecs assigns entity ids from its own quadrant-encoded id-space, unrelated
-// to the spec's domain `id`. So the seeded entities are returned in display
-// order and the caller maps spec `id` → entity positionally (see
-// `expect-conforms.ts`); nothing here assumes the two id-spaces coincide.
-export const fromState = (store: CoreDatabase.Store, state: State): readonly Entity[] => {
-  for (const arch of store.queryArchetypes(store.archetypes.Todo.components)) {
-    for (let row = arch.rowCount - 1; row >= 0; row--) {
-      store.delete(arch.columns.id.get(row));
-    }
-  }
-  store.resources.displayCompleted = state.displayCompleted;
-  return state.todos.map((todo, index) =>
-    store.archetypes.Todo.insert({
-      todo: true,
-      name: todo.name,
-      complete: todo.complete,
-      order: index,
-      dragPosition: null,
-      assignees: [],
-    }),
-  );
-};
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/conformance/projection.test.ts b/packages/data-lit-todo/src/features/main/services/main-service/conformance/projection.test.ts
deleted file mode 100644
index 48bce4e8..00000000
--- a/packages/data-lit-todo/src/features/main/services/main-service/conformance/projection.test.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// Guards the projection itself. `fromState` and `toState` are the bridge every
-// transaction conformance test trusts; a symmetric bug in the pair (e.g. both
-// dropping the same field) would cancel out and mask a real ecs defect. This
-// identity test — `toState(fromState(s)) ≡ s` over representative states —
-// proves the projection round-trips faithfully on its own.
-import { describe, it } from "vitest";
-import type { State } from "../../../data/state/state.js";
-import { expectStateMatchesIgnoringIds } from "./expect-state-matches-ignoring-ids.js";
-import { createStore } from "./create-store.js";
-import { fromState } from "./from-state.js";
-import { toState } from "./to-state.js";
-
-const states: readonly { readonly name: string; readonly state: State }[] = [
-  {
-    name: "a mixed list of complete and incomplete todos, completed view on",
-    state: {
-      todos: [
-        { id: 1, name: "buy milk", complete: false },
-        { id: 2, name: "walk dog", complete: true },
-        { id: 3, name: "write tests", complete: false },
-      ],
-      displayCompleted: true,
-    },
-  },
-  {
-    name: "an empty list with the completed view off",
-    state: { todos: [], displayCompleted: false },
-  },
-  {
-    name: "todos sharing a name (multiset round-trip), completed view off",
-    state: {
-      todos: [
-        { id: 1, name: "task", complete: false },
-        { id: 2, name: "task", complete: false },
-        { id: 3, name: "task", complete: true },
-      ],
-      displayCompleted: false,
-    },
-  },
-];
-
-describe("ecs/conformance projection round-trips (toState ∘ fromState ≡ identity)", () => {
-  for (const { name, state } of states) {
-    it(name, () => {
-      const store = createStore();
-      fromState(store, state);
-      expectStateMatchesIgnoringIds(toState(store), state);
-    });
-  }
-});
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/conformance/projection.ts b/packages/data-lit-todo/src/features/main/services/main-service/conformance/projection.ts
new file mode 100644
index 00000000..0d333054
--- /dev/null
+++ b/packages/data-lit-todo/src/features/main/services/main-service/conformance/projection.ts
@@ -0,0 +1,66 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Entity } from "@adobe/data/ecs";
+import type { State } from "../../../data/state/state.js";
+import type { Todo } from "../../../data/todo/todo.js";
+import type { CoreDatabase } from "../core-database/core-database.js";
+
+// Read one entity back into its `data/` value — the per-entity projection
+// `toState` is built on, and the single place the ecs↔data mapping for a todo
+// lives. Reused by the computed conformance to hydrate id-based computed outputs
+// (e.g. `visibleTodos` returns entity ids) into the value shape a derivation
+// yields, so those computeds need no bespoke projection. Test-only.
+const toData = (store: CoreDatabase.Store, entity: Entity): Todo => {
+  const row = store.read(entity, store.archetypes.Todo);
+  if (row === null)
+    throw new Error("conformance projection: expected a todo entity");
+  return { id: row.id, name: row.name, complete: row.complete };
+};
+
+// The test-only ecs↔`State` projection, passed to `Conformance.runFeature`.
+// `fromState` seeds a store to a `State` (clearing every todo, setting the
+// `displayCompleted` resource, then inserting the todos in display order with
+// `order` = the index; the implementation-only slots (`dragPosition`,
+// `assignees`) are seeded empty). Clearing iterates tail→head so each delete is
+// from the tail (no hole-fill shift). The ecs assigns entity ids from its own
+// id-space, unrelated to the spec's domain `id`; `fromState` returns the `spec id
+// → seeded entity` map so the runners resolve id-addressed operations generically.
+// `toState` reads it back (todos in ascending `order`, each through its full
+// archetype so the row shape never aliases; only the spec fields are projected);
+// `toData` reads one entity.
+export const projection = {
+  fromState: (
+    store: CoreDatabase.Store,
+    state: State,
+  ): ReadonlyMap<number, Entity> => {
+    for (const arch of store.queryArchetypes(
+      store.archetypes.Todo.components,
+    )) {
+      for (let row = arch.rowCount - 1; row >= 0; row--) {
+        store.delete(arch.columns.id.get(row));
+      }
+    }
+    store.resources.displayCompleted = state.displayCompleted;
+    return new Map(
+      state.todos.map((todo, index) => [
+        todo.id,
+        store.archetypes.Todo.insert({
+          todo: true,
+          name: todo.name,
+          complete: todo.complete,
+          order: index,
+          dragPosition: null,
+          assignees: [],
+        }),
+      ]),
+    );
+  },
+  toState: (store: CoreDatabase.Store): State => ({
+    todos: [
+      ...store.select(store.archetypes.Todo.components, {
+        order: { order: true },
+      }),
+    ].map((entity) => toData(store, entity)),
+    displayCompleted: store.resources.displayCompleted,
+  }),
+  toData,
+};
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/conformance/to-state.ts b/packages/data-lit-todo/src/features/main/services/main-service/conformance/to-state.ts
deleted file mode 100644
index 6c0e68ac..00000000
--- a/packages/data-lit-todo/src/features/main/services/main-service/conformance/to-state.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { State } from "../../../data/state/state.js";
-import type { Todo } from "../../../data/todo/todo.js";
-import type { CoreDatabase } from "../core-database/core-database.js";
-
-// Read a store back into a `data/` `State` — the inverse of `fromState`. Todos
-// are read in ascending `order` (the ecs materialisation of display order),
-// each through its full `Todo` archetype so the row shape never aliases; only
-// the spec fields (`id`, `name`, `complete`) are projected — the ecs-only
-// `order` / `dragPosition` / `assignees` slots stay behind. The projected `id`
-// is the entity id (the ecs's own id-space, not the spec's domain id), so
-// conformance comparisons ignore it — see `expect-state-matches-ignoring-ids`.
-// Test-only.
-const readTodos = (store: CoreDatabase.Store): Todo[] => {
-  const todos: Todo[] = [];
-  for (const entity of store.select(store.archetypes.Todo.components, { order: { order: true } })) {
-    const row = store.read(entity, store.archetypes.Todo);
-    if (row === null) throw new Error("conformance projection: expected a todo entity");
-    todos.push({ id: row.id, name: row.name, complete: row.complete });
-  }
-  return todos;
-};
-
-export const toState = (store: CoreDatabase.Store): State => ({
-  todos: readTodos(store),
-  displayCompleted: store.resources.displayCompleted,
-});
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/feature-database.ts b/packages/data-lit-todo/src/features/main/services/main-service/feature-database.ts
deleted file mode 100644
index c0edaacc..00000000
--- a/packages/data-lit-todo/src/features/main/services/main-service/feature-database.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-export { ActionDatabase as FeatureDatabase } from "./action-database/action-database.js";
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/main-service.ts b/packages/data-lit-todo/src/features/main/services/main-service/main-service.ts
new file mode 100644
index 00000000..b0c4bfc7
--- /dev/null
+++ b/packages/data-lit-todo/src/features/main/services/main-service/main-service.ts
@@ -0,0 +1,2 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { ActionDatabase as MainService } from "./action-database/action-database.js";
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/service-database/service-database.ts b/packages/data-lit-todo/src/features/main/services/main-service/service-database/service-database.ts
index 31f52ab8..bfc2a8ed 100644
--- a/packages/data-lit-todo/src/features/main/services/main-service/service-database/service-database.ts
+++ b/packages/data-lit-todo/src/features/main/services/main-service/service-database/service-database.ts
@@ -2,7 +2,7 @@
 import { Database } from "@adobe/data/ecs";
 import { ComputedDatabase } from "../computed-database/computed-database.js";
 import { NameGeneratorService } from "../../name-generator-service/name-generator-service.js";
-import { TodoAnalyticsService } from "../../todo-analytics-service/todo-analytics-service.js";
+import { AnalyticsService } from "../../analytics-service/analytics-service.js";
 
 // These services are async ports with no ECS state to bind, so they are
 // registered directly from their `services/` contracts. A service that reads
@@ -12,7 +12,7 @@ const serviceDatabasePlugin = Database.Plugin.create({
   extends: ComputedDatabase.plugin,
   services: {
     nameGenerator: NameGeneratorService.create,
-    todoAnalytics: TodoAnalyticsService.create,
+    analytics: AnalyticsService.create,
   },
 });
 
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/create-bulk-todos.test.ts b/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/create-bulk-todos.test.ts
deleted file mode 100644
index f9e62795..00000000
--- a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/create-bulk-todos.test.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `createBulkTodos` conforms to `State.createBulkTodos`: it appends `count`
-// (floored, clamped at 0) numbered placeholder todos after the existing ones.
-import { describe } from "vitest";
-import { State } from "../../../../data/state/state.js";
-import { cases } from "../../../../data/state/create-bulk-todos.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { createBulkTodos } from "./create-bulk-todos.js";
-
-describe("createBulkTodos transaction conforms to State.createBulkTodos", () => {
-  expectConforms({
-    cases,
-    spec: State.createBulkTodos,
-    apply: createBulkTodos,
-  });
-});
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/create-todo.test.ts b/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/create-todo.test.ts
deleted file mode 100644
index 80ff7669..00000000
--- a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/create-todo.test.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `createTodo` conforms to `State.createTodo`: it appends one todo with the next
-// order and the defaulted `complete` flag, leaving existing todos untouched.
-import { describe } from "vitest";
-import { State } from "../../../../data/state/state.js";
-import { cases } from "../../../../data/state/create-todo.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { createTodo } from "./create-todo.js";
-
-describe("createTodo transaction conforms to State.createTodo", () => {
-  expectConforms({
-    cases,
-    spec: State.createTodo,
-    apply: createTodo,
-  });
-});
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/delete-all-todos.test.ts b/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/delete-all-todos.test.ts
deleted file mode 100644
index 6c7b670a..00000000
--- a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/delete-all-todos.test.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `deleteAllTodos` conforms to `State.deleteAllTodos`: it clears every todo,
-// leaving `displayCompleted` untouched.
-import { describe } from "vitest";
-import { State } from "../../../../data/state/state.js";
-import { cases } from "../../../../data/state/delete-all-todos.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { deleteAllTodos } from "./delete-all-todos.js";
-
-describe("deleteAllTodos transaction conforms to State.deleteAllTodos", () => {
-  expectConforms({
-    cases,
-    spec: State.deleteAllTodos,
-    apply: deleteAllTodos,
-  });
-});
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/delete-todo.test.ts b/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/delete-todo.test.ts
deleted file mode 100644
index 651ffcad..00000000
--- a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/delete-todo.test.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `deleteTodo` conforms to `State.deleteTodo`: it removes the addressed todo and
-// is a no-op for an unknown id. The spec `id` is the seeded entity id (see
-// `fromState`), so `apply` passes it straight through.
-import { describe } from "vitest";
-import { State } from "../../../../data/state/state.js";
-import { cases } from "../../../../data/state/delete-todo.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { deleteTodo } from "./delete-todo.js";
-
-describe("deleteTodo transaction conforms to State.deleteTodo", () => {
-  expectConforms({
-    cases,
-    spec: State.deleteTodo,
-    apply: (store, args, resolve) => deleteTodo(store, resolve(args.id)),
-  });
-});
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/delete-todo.ts b/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/delete-todo.ts
index b3d8bc8a..ae375c23 100644
--- a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/delete-todo.ts
+++ b/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/delete-todo.ts
@@ -2,7 +2,7 @@
 import type { Entity } from "@adobe/data/ecs";
 import type { CoreDatabase } from "../../core-database/core-database.js";
 
-export const deleteTodo = (t: CoreDatabase.Store, id: Entity) => {
+export const deleteTodo = (t: CoreDatabase.Store, { id }: { id: Entity }) => {
   const todo = t.read(id);
   if (todo) {
     t.delete(id);
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/drag-todo.test.ts b/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/drag-todo.test.ts
deleted file mode 100644
index 18bb3ab3..00000000
--- a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/drag-todo.test.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `dragTodo`'s final drop conforms to `State.reorderTodo`: assigning a fractional
-// `order` between the new visible neighbours then normalizing back to contiguous
-// integers reproduces the pure list move. The shared cases keep every todo
-// incomplete with `displayCompleted` true, so the visible list `dragTodo` indexes
-// equals the full list `reorderTodo` indexes — `finalIndex` maps to `toIndex`.
-// The spec `id` is the seeded entity id (see `fromState`), passed as `entity`.
-import { describe } from "vitest";
-import { State } from "../../../../data/state/state.js";
-import { cases } from "../../../../data/state/reorder-todo.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { dragTodo } from "./drag-todo.js";
-
-describe("dragTodo transaction conforms to State.reorderTodo", () => {
-  expectConforms({
-    cases,
-    spec: State.reorderTodo,
-    apply: (store, args, resolve) =>
-      dragTodo(store, { entity: resolve(args.id), dragPosition: 0, finalIndex: args.toIndex }),
-  });
-});
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/toggle-complete.test.ts b/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/toggle-complete.test.ts
deleted file mode 100644
index 217e9e6c..00000000
--- a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/toggle-complete.test.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `toggleComplete` conforms to `State.toggleComplete`: it flips only the
-// addressed todo's `complete` flag and is a no-op for an unknown id. The spec
-// `id` is the seeded entity id (see `fromState`), passed straight through.
-import { describe } from "vitest";
-import { State } from "../../../../data/state/state.js";
-import { cases } from "../../../../data/state/toggle-complete.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { toggleComplete } from "./toggle-complete.js";
-
-describe("toggleComplete transaction conforms to State.toggleComplete", () => {
-  expectConforms({
-    cases,
-    spec: State.toggleComplete,
-    apply: (store, args, resolve) => toggleComplete(store, resolve(args.id)),
-  });
-});
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/toggle-complete.ts b/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/toggle-complete.ts
index 85e3b963..704bcbe0 100644
--- a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/toggle-complete.ts
+++ b/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/toggle-complete.ts
@@ -2,7 +2,7 @@
 import type { Entity } from "@adobe/data/ecs";
 import type { CoreDatabase } from "../../core-database/core-database.js";
 
-export const toggleComplete = (t: CoreDatabase.Store, id: Entity) => {
+export const toggleComplete = (t: CoreDatabase.Store, { id }: { id: Entity }) => {
   const todo = t.read(id);
   if (todo) {
     t.update(id, { complete: !todo.complete });
diff --git a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/toggle-display-completed.test.ts b/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/toggle-display-completed.test.ts
deleted file mode 100644
index 20ca4ce1..00000000
--- a/packages/data-lit-todo/src/features/main/services/main-service/transaction-database/transactions/toggle-display-completed.test.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// `toggleDisplayCompleted` conforms to `State.toggleDisplayCompleted`: it flips
-// the `displayCompleted` resource, leaving the todos untouched.
-import { describe } from "vitest";
-import { State } from "../../../../data/state/state.js";
-import { cases } from "../../../../data/state/toggle-display-completed.cases.js";
-import { expectConforms } from "../../conformance/expect-conforms.js";
-import { toggleDisplayCompleted } from "./toggle-display-completed.js";
-
-describe("toggleDisplayCompleted transaction conforms to State.toggleDisplayCompleted", () => {
-  expectConforms({
-    cases,
-    spec: State.toggleDisplayCompleted,
-    apply: toggleDisplayCompleted,
-  });
-});
diff --git a/packages/data-lit-todo/src/features/main/services/name-generator-service/create-fake.ts b/packages/data-lit-todo/src/features/main/services/name-generator-service/create-fake.ts
new file mode 100644
index 00000000..67a55ea7
--- /dev/null
+++ b/packages/data-lit-todo/src/features/main/services/name-generator-service/create-fake.ts
@@ -0,0 +1,24 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { NameGeneratorService } from "./name-generator-service.js";
+
+/**
+ * Deterministic test double for {@link NameGeneratorService}. Unlike the real
+ * generator it uses no randomness and no timers: `generateName` returns the
+ * `responses` in order, cycling once exhausted, each resolved on the microtask
+ * queue. A case that needs specific names passes its own `responses`; the
+ * default is a harmless placeholder. This is the implementation tests inject so
+ * their assertions are predictable — see `features/services/index.md`.
+ */
+export const createFake = (
+  responses: readonly string[] = ["a task"],
+): NameGeneratorService => {
+  let index = 0;
+  return {
+    serviceName: "nameGenerator",
+    generateName: () => {
+      const name = responses[index % responses.length];
+      index += 1;
+      return Promise.resolve(name);
+    },
+  };
+};
diff --git a/packages/data-lit-todo/src/features/main/services/name-generator-service/public.ts b/packages/data-lit-todo/src/features/main/services/name-generator-service/public.ts
index 6523855b..56c941d3 100644
--- a/packages/data-lit-todo/src/features/main/services/name-generator-service/public.ts
+++ b/packages/data-lit-todo/src/features/main/services/name-generator-service/public.ts
@@ -1,2 +1,3 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 export { create } from "./create.js";
+export { createFake } from "./create-fake.js";
diff --git a/packages/data-lit-todo/src/features/main/ui/todo-app/todo-app.ts b/packages/data-lit-todo/src/features/main/ui/todo-app/todo-app.ts
index 238bb9fa..a194ff73 100644
--- a/packages/data-lit-todo/src/features/main/ui/todo-app/todo-app.ts
+++ b/packages/data-lit-todo/src/features/main/ui/todo-app/todo-app.ts
@@ -1,14 +1,14 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { html, type TemplateResult } from "lit";
 import type { Database } from "@adobe/data/ecs";
-import type { FeatureDatabase } from "../../services/main-service/feature-database.js";
+import type { MainService } from "../../services/main-service/main-service.js";
 
-type TodoService = Database.Plugin.ToDatabase<typeof FeatureDatabase.plugin>;
+type TodoService = Database.Plugin.ToDatabase<typeof MainService.plugin>;
 
 /**
  * Generic over `S` so callers may pass a database built from any plugin
  * that extends the todo plugin. The element is typed on the minimal
- * `FeatureDatabase` surface.
+ * `MainService` surface.
  */
 export const TodoApp = <S extends TodoService>(args: { service: S }): TemplateResult => {
   void import("./todo-app-element.js");
diff --git a/packages/data-lit-todo/src/features/main/ui/todo-element.ts b/packages/data-lit-todo/src/features/main/ui/todo-element.ts
index f6df6757..b8196b85 100644
--- a/packages/data-lit-todo/src/features/main/ui/todo-element.ts
+++ b/packages/data-lit-todo/src/features/main/ui/todo-element.ts
@@ -1,14 +1,14 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { DatabaseElement } from "@adobe/data-lit";
-import { FeatureDatabase } from "../services/main-service/feature-database.js";
+import { MainService } from "../services/main-service/main-service.js";
 
 /**
- * Base class for all todo elements. Typed on the assembled `FeatureDatabase`
+ * Base class for all todo elements. Typed on the assembled `MainService`
  * plugin surface so every child element can read computed values off `.service`
  * and dispatch `.service.actions.*` (which orchestrate analytics + transactions).
  */
-export class TodoElement extends DatabaseElement<typeof FeatureDatabase.plugin> {
+export class TodoElement extends DatabaseElement<typeof MainService.plugin> {
   get plugin() {
-    return FeatureDatabase.plugin;
+    return MainService.plugin;
   }
 }
diff --git a/packages/data-lit-todo/src/features/main/ui/todo-row/todo-row-element.ts b/packages/data-lit-todo/src/features/main/ui/todo-row/todo-row-element.ts
index e5bd82f7..fa60cc1f 100644
--- a/packages/data-lit-todo/src/features/main/ui/todo-row/todo-row-element.ts
+++ b/packages/data-lit-todo/src/features/main/ui/todo-row/todo-row-element.ts
@@ -75,8 +75,8 @@ export class TodoRowElement extends TodoElement {
       toggleEditing: () => setEditing(!editing),
       index: this.index,
       entity: this.entity,
-      toggleComplete: () => this.service.actions.toggleComplete(this.entity),
-      deleteTodo: () => this.service.actions.deleteTodo(this.entity),
+      toggleComplete: () => this.service.actions.toggleComplete({ id: this.entity }),
+      deleteTodo: () => this.service.actions.deleteTodo({ id: this.entity }),
     });
   }
 }
diff --git a/packages/data-lit-todo/src/features/main/ui/todo-toolbar/todo-toolbar-element.ts b/packages/data-lit-todo/src/features/main/ui/todo-toolbar/todo-toolbar-element.ts
index 658cc7bd..9e98856f 100644
--- a/packages/data-lit-todo/src/features/main/ui/todo-toolbar/todo-toolbar-element.ts
+++ b/packages/data-lit-todo/src/features/main/ui/todo-toolbar/todo-toolbar-element.ts
@@ -42,7 +42,7 @@ export class TodoToolbarElement extends TodoElement {
       displayCompleted: values?.displayCompleted ?? false,
       setDraftName,
       addTodo,
-      addRandomTodo: () => this.service.actions.addRandomTodo(),
+      addRandomTodo: () => this.service.actions.createRandomTodo(),
       addBulkTodos: (count) => this.service.actions.createBulkTodos({ count }),
       toggleDisplayCompleted: () => this.service.actions.toggleDisplayCompleted(),
       clearAll: () => this.service.actions.deleteAllTodos(),
diff --git a/packages/data-lit-todo/src/index.ts b/packages/data-lit-todo/src/index.ts
index e6541cc9..d11b4236 100644
--- a/packages/data-lit-todo/src/index.ts
+++ b/packages/data-lit-todo/src/index.ts
@@ -2,7 +2,7 @@
 //
 // Library entry point for data-lit-todo.
 
-export { FeatureDatabase as TodoDatabase } from "./features/main/services/main-service/feature-database.js";
+export { MainService as TodoMainService } from "./features/main/services/main-service/main-service.js";
 export { TodoElement } from "./features/main/ui/todo-element.js";
 export { TodoApp } from "./features/main/ui/todo-app/todo-app.js";
 export { Todo } from "./features/main/data/todo/todo.js";
diff --git a/packages/data-lit-todo/src/main.ts b/packages/data-lit-todo/src/main.ts
index 49e58695..64a1cbbf 100644
--- a/packages/data-lit-todo/src/main.ts
+++ b/packages/data-lit-todo/src/main.ts
@@ -1,7 +1,7 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { html, render } from "lit";
 import { Database } from "@adobe/data/ecs";
-import { FeatureDatabase } from "./features/main/services/main-service/feature-database.js";
+import { MainService } from "./features/main/services/main-service/main-service.js";
 import { TodoApp } from "./features/main/ui/todo-app/todo-app.js";
 
 // Spectrum 2 theme registration (side-effect imports).
@@ -11,7 +11,7 @@ import "@spectrum-web-components/theme/spectrum-two/scale-medium.js";
 
 const app = document.getElementById("app");
 if (app) {
-  const service = Database.create(FeatureDatabase.plugin);
+  const service = Database.create(MainService.plugin);
 
   service.actions.createTodo({ name: "Buy groceries" });
   service.actions.createTodo({ name: "Pick up dry cleaning" });
diff --git a/packages/data-lit/package.json b/packages/data-lit/package.json
index 6a5f6edf..4df97351 100644
--- a/packages/data-lit/package.json
+++ b/packages/data-lit/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@adobe/data-lit",
-  "version": "0.9.92",
+  "version": "0.9.93",
   "description": "Adobe data Lit bindings - hooks, elements, decorators",
   "type": "module",
   "private": false,
diff --git a/packages/data-p2p-tictactoe/package.json b/packages/data-p2p-tictactoe/package.json
index b5beebdc..897827d3 100644
--- a/packages/data-p2p-tictactoe/package.json
+++ b/packages/data-p2p-tictactoe/package.json
@@ -1,6 +1,6 @@
 {
   "name": "data-p2p-tictactoe",
-  "version": "0.9.92",
+  "version": "0.9.93",
   "description": "Serverless P2P tic-tac-toe — WebRTC DataChannel + @adobe/data-sync",
   "type": "module",
   "private": true,
diff --git a/packages/data-p2p-tictactoe/src/negotiation/types/connection-state.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/connection-state/connection-state.ts
similarity index 83%
rename from packages/data-p2p-tictactoe/src/negotiation/types/connection-state.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/data/connection-state/connection-state.ts
index 26e7e09d..bdf98e3b 100644
--- a/packages/data-p2p-tictactoe/src/negotiation/types/connection-state.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/connection-state/connection-state.ts
@@ -7,3 +7,4 @@ export type ConnectionState =
   | "connected"
   | "disconnected"
   | "reconnecting";
+export * as ConnectionState from "./public.js";
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/services/index.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/connection-state/public.ts
similarity index 57%
rename from packages/data-p2p-tictactoe/src/negotiation/database/services/index.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/data/connection-state/public.ts
index 2b4973cf..363fd32b 100644
--- a/packages/data-p2p-tictactoe/src/negotiation/database/services/index.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/connection-state/public.ts
@@ -1,2 +1,2 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-export * from "./negotiation-service.js";
+export { schema } from "./schema.js";
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/connection-state/schema.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/connection-state/schema.ts
new file mode 100644
index 00000000..4c8c02b4
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/connection-state/schema.ts
@@ -0,0 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Schema } from "@adobe/data/schema";
+import type { Assert, Equal } from "@adobe/data/types";
+import type { ConnectionState } from "./connection-state.js";
+
+export const schema = {
+  type: "string",
+  enum: ["idle", "connecting", "connected", "disconnected", "reconnecting"],
+} as const satisfies Schema;
+
+// Compile-time pin: fails to build if schema and type diverge.
+type _Pin = Assert<Equal<Schema.ToType<typeof schema>, ConnectionState>>;
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/phase/phase.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/phase/phase.ts
new file mode 100644
index 00000000..f48b46a6
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/phase/phase.ts
@@ -0,0 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+/**
+ * Local-only screen the peer is currently on. Held as a nonPersistent resource
+ * so it never reaches the wire — only the local signaling UI reads it.
+ */
+export type Phase = "idle" | "host-signaling" | "join-signaling" | "game";
+export * as Phase from "./public.js";
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/phase/public.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/phase/public.ts
new file mode 100644
index 00000000..363fd32b
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/phase/public.ts
@@ -0,0 +1,2 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { schema } from "./schema.js";
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/phase/schema.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/phase/schema.ts
new file mode 100644
index 00000000..5458021a
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/phase/schema.ts
@@ -0,0 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Schema } from "@adobe/data/schema";
+import type { Assert, Equal } from "@adobe/data/types";
+import type { Phase } from "./phase.js";
+
+export const schema = {
+  type: "string",
+  enum: ["idle", "host-signaling", "join-signaling", "game"],
+} as const satisfies Schema;
+
+// Compile-time pin: fails to build if schema and type diverge.
+type _Pin = Assert<Equal<Schema.ToType<typeof schema>, Phase>>;
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/role/public.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/role/public.ts
new file mode 100644
index 00000000..363fd32b
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/role/public.ts
@@ -0,0 +1,2 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { schema } from "./schema.js";
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/role/role.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/role/role.ts
new file mode 100644
index 00000000..02264a6b
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/role/role.ts
@@ -0,0 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+/** Which side of the handshake this peer drives. Host plays X, joiner plays O. */
+export type Role = "host" | "joiner";
+export * as Role from "./public.js";
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/role/schema.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/role/schema.ts
new file mode 100644
index 00000000..31250f38
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/role/schema.ts
@@ -0,0 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Schema } from "@adobe/data/schema";
+import type { Assert, Equal } from "@adobe/data/types";
+import type { Role } from "./role.js";
+
+export const schema = {
+  type: "string",
+  enum: ["host", "joiner"],
+} as const satisfies Schema;
+
+// Compile-time pin: fails to build if schema and type diverge.
+type _Pin = Assert<Equal<Schema.ToType<typeof schema>, Role>>;
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/state/conformance-case.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/conformance-case.ts
new file mode 100644
index 00000000..4426eca4
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/conformance-case.ts
@@ -0,0 +1,13 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Conformance as ConformanceApi } from "@adobe/data/testing";
+import type { State } from "./state.js";
+
+// The conformance case types for this feature — the shared `@adobe/data/testing`
+// machinery with `State` bound once, so a transform authors `Conformance<typeof fn>`
+// and a derivation `Derivation<typeof fn>` (args/input/value read from the
+// function's own signature). This tiny file is the only per-feature conformance
+// type declaration; everything else lives in `@adobe/data/testing`.
+export type Conformance<F extends (...args: never[]) => unknown> =
+  ConformanceApi.Cases<State, F>;
+export type Derivation<F extends (...args: never[]) => unknown> =
+  ConformanceApi.DerivationCases<F>;
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/state/create.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/create.ts
new file mode 100644
index 00000000..49fe3123
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/create.ts
@@ -0,0 +1,16 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+
+/** The initial negotiation state: idle, no role, all codes empty. */
+export const create = (): State => ({
+  phase: "idle",
+  connection: "idle",
+  role: null,
+  sessionId: null,
+  offerCode: "",
+  answerCode: "",
+  bannerText: "",
+  bannerError: false,
+  hostAnswerInput: "",
+  joinerOfferInput: "",
+});
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/state/enter-game.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/enter-game.ts
new file mode 100644
index 00000000..37558aa6
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/enter-game.ts
@@ -0,0 +1,35 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+
+/**
+ * Transition to the live game once the peer connection is established. The
+ * non-serializable game database handle it accompanies is stored separately by
+ * the ecs `setGameDb` transaction; this pure step models only the visible
+ * phase / connection change.
+ */
+export const enterGame = <T extends State>(state: T): T => ({
+  ...state,
+  phase: "game",
+  connection: "connected",
+});
+
+// Spec-owned cases, shared with the ecs `setGameDb` transaction (a differently
+// named transaction whose visible effect is exactly this) and the `enterGame`
+// action. A no-arg transition, so `args` is `undefined`.
+export const cases: Conformance<typeof enterGame> = [
+  {
+    name: "moves to the game phase, connected",
+    before: {
+      phase: "host-signaling", connection: "connecting", role: "host", sessionId: null,
+      offerCode: "", answerCode: "", bannerText: "", bannerError: false,
+      hostAnswerInput: "", joinerOfferInput: "",
+    },
+    args: undefined,
+    after: {
+      phase: "game", connection: "connected", role: "host", sessionId: null,
+      offerCode: "", answerCode: "", bannerText: "", bannerError: false,
+      hostAnswerInput: "", joinerOfferInput: "",
+    },
+  },
+];
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/state/public.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/public.ts
new file mode 100644
index 00000000..c8049674
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/public.ts
@@ -0,0 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { create } from "./create.js";
+export { samples } from "./samples.js";
+export { startHostSignaling } from "./start-host-signaling.js";
+export { startJoinSignaling } from "./start-join-signaling.js";
+export { setOfferCode } from "./set-offer-code.js";
+export { setAnswerCode } from "./set-answer-code.js";
+export { setBanner } from "./set-banner.js";
+export { setConnection } from "./set-connection.js";
+export { setHostAnswerInput } from "./set-host-answer-input.js";
+export { setJoinerOfferInput } from "./set-joiner-offer-input.js";
+export { enterGame } from "./enter-game.js";
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/state/samples.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/samples.ts
new file mode 100644
index 00000000..4be3c505
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/samples.ts
@@ -0,0 +1,29 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { create } from "./create.js";
+import type { State } from "./state.js";
+
+// Representative full negotiation states for the projection round-trip
+// (toState ∘ fromState ≡ identity). Varied phase / role / connection / code /
+// banner fields exercise the whole store↔State resource map.
+export const samples: readonly State[] = [
+  create(),
+  {
+    ...create(),
+    phase: "host-signaling",
+    role: "host",
+    connection: "connecting",
+    offerCode: "OFFER-123",
+    hostAnswerInput: "partial",
+    bannerText: "Waiting for a joiner…",
+  },
+  {
+    ...create(),
+    phase: "game",
+    role: "joiner",
+    connection: "connected",
+    sessionId: "sess-9",
+    answerCode: "ANSWER-9",
+    bannerText: "Connection failed",
+    bannerError: true,
+  },
+];
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-answer-code.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-answer-code.ts
new file mode 100644
index 00000000..f0df080b
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-answer-code.ts
@@ -0,0 +1,27 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+
+/** Record the generated joiner answer code and clear any pending banner. */
+export const setAnswerCode = <T extends State>(
+  state: T,
+  { code }: { code: string },
+): T => ({ ...state, answerCode: code, bannerText: "" });
+
+// Spec-owned cases, shared with the ecs `setAnswerCode` transaction and action.
+export const cases: Conformance<typeof setAnswerCode> = [
+  {
+    name: "stores the answer code and clears the banner",
+    before: {
+      phase: "idle", connection: "idle", role: null, sessionId: null,
+      offerCode: "", answerCode: "", bannerText: "Generating answer — please wait…",
+      bannerError: false, hostAnswerInput: "", joinerOfferInput: "",
+    },
+    args: { code: "ANSWER-456" },
+    after: {
+      phase: "idle", connection: "idle", role: null, sessionId: null,
+      offerCode: "", answerCode: "ANSWER-456", bannerText: "", bannerError: false,
+      hostAnswerInput: "", joinerOfferInput: "",
+    },
+  },
+];
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-banner.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-banner.ts
new file mode 100644
index 00000000..37ae7730
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-banner.ts
@@ -0,0 +1,41 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+
+/** Set the banner text and whether it should be styled as an error. */
+export const setBanner = <T extends State>(
+  state: T,
+  { text, error = false }: { text: string; error?: boolean },
+): T => ({ ...state, bannerText: text, bannerError: error });
+
+// Spec-owned cases, shared with the ecs `setBanner` transaction and action.
+export const cases: Conformance<typeof setBanner> = [
+  {
+    name: "sets an informational banner",
+    before: {
+      phase: "idle", connection: "idle", role: null, sessionId: null,
+      offerCode: "", answerCode: "", bannerText: "", bannerError: false,
+      hostAnswerInput: "", joinerOfferInput: "",
+    },
+    args: { text: "Generating answer — please wait…" },
+    after: {
+      phase: "idle", connection: "idle", role: null, sessionId: null,
+      offerCode: "", answerCode: "", bannerText: "Generating answer — please wait…",
+      bannerError: false, hostAnswerInput: "", joinerOfferInput: "",
+    },
+  },
+  {
+    name: "sets an error banner",
+    before: {
+      phase: "idle", connection: "idle", role: null, sessionId: null,
+      offerCode: "", answerCode: "", bannerText: "", bannerError: false,
+      hostAnswerInput: "", joinerOfferInput: "",
+    },
+    args: { text: "Connection failed: boom", error: true },
+    after: {
+      phase: "idle", connection: "idle", role: null, sessionId: null,
+      offerCode: "", answerCode: "", bannerText: "Connection failed: boom",
+      bannerError: true, hostAnswerInput: "", joinerOfferInput: "",
+    },
+  },
+];
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-connection.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-connection.ts
new file mode 100644
index 00000000..cc706e1d
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-connection.ts
@@ -0,0 +1,49 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ConnectionState } from "../connection-state/connection-state.js";
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+
+/**
+ * Update the connection lifecycle, optionally recording the sync session id.
+ * Omitting `sessionId` leaves the existing value untouched.
+ */
+export const setConnection = <T extends State>(
+  state: T,
+  { connection, sessionId }: { connection: ConnectionState; sessionId?: string | null },
+): T => ({
+  ...state,
+  connection,
+  sessionId: sessionId !== undefined ? sessionId : state.sessionId,
+});
+
+// Spec-owned cases, shared with the ecs `setConnection` transaction and action.
+export const cases: Conformance<typeof setConnection> = [
+  {
+    name: "records a connected state with a session id",
+    before: {
+      phase: "idle", connection: "connecting", role: null, sessionId: null,
+      offerCode: "", answerCode: "", bannerText: "", bannerError: false,
+      hostAnswerInput: "", joinerOfferInput: "",
+    },
+    args: { connection: "connected", sessionId: "sess-1" },
+    after: {
+      phase: "idle", connection: "connected", role: null, sessionId: "sess-1",
+      offerCode: "", answerCode: "", bannerText: "", bannerError: false,
+      hostAnswerInput: "", joinerOfferInput: "",
+    },
+  },
+  {
+    name: "updates only the connection when no session id is supplied",
+    before: {
+      phase: "idle", connection: "connected", role: null, sessionId: "sess-1",
+      offerCode: "", answerCode: "", bannerText: "", bannerError: false,
+      hostAnswerInput: "", joinerOfferInput: "",
+    },
+    args: { connection: "disconnected" },
+    after: {
+      phase: "idle", connection: "disconnected", role: null, sessionId: "sess-1",
+      offerCode: "", answerCode: "", bannerText: "", bannerError: false,
+      hostAnswerInput: "", joinerOfferInput: "",
+    },
+  },
+];
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-host-answer-input.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-host-answer-input.ts
new file mode 100644
index 00000000..09072188
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-host-answer-input.ts
@@ -0,0 +1,27 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+
+/** Store the live value of the host's "paste answer" textarea. */
+export const setHostAnswerInput = <T extends State>(
+  state: T,
+  { value }: { value: string },
+): T => ({ ...state, hostAnswerInput: value });
+
+// Spec-owned cases, shared with the ecs `setHostAnswerInput` transaction and action.
+export const cases: Conformance<typeof setHostAnswerInput> = [
+  {
+    name: "stores the host answer input",
+    before: {
+      phase: "idle", connection: "idle", role: null, sessionId: null,
+      offerCode: "", answerCode: "", bannerText: "", bannerError: false,
+      hostAnswerInput: "", joinerOfferInput: "",
+    },
+    args: { value: "ANSWER-abc" },
+    after: {
+      phase: "idle", connection: "idle", role: null, sessionId: null,
+      offerCode: "", answerCode: "", bannerText: "", bannerError: false,
+      hostAnswerInput: "ANSWER-abc", joinerOfferInput: "",
+    },
+  },
+];
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-joiner-offer-input.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-joiner-offer-input.ts
new file mode 100644
index 00000000..1dcef038
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-joiner-offer-input.ts
@@ -0,0 +1,27 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+
+/** Store the live value of the joiner's "paste offer" textarea. */
+export const setJoinerOfferInput = <T extends State>(
+  state: T,
+  { value }: { value: string },
+): T => ({ ...state, joinerOfferInput: value });
+
+// Spec-owned cases, shared with the ecs `setJoinerOfferInput` transaction and action.
+export const cases: Conformance<typeof setJoinerOfferInput> = [
+  {
+    name: "stores the joiner offer input",
+    before: {
+      phase: "idle", connection: "idle", role: null, sessionId: null,
+      offerCode: "", answerCode: "", bannerText: "", bannerError: false,
+      hostAnswerInput: "", joinerOfferInput: "",
+    },
+    args: { value: "OFFER-xyz" },
+    after: {
+      phase: "idle", connection: "idle", role: null, sessionId: null,
+      offerCode: "", answerCode: "", bannerText: "", bannerError: false,
+      hostAnswerInput: "", joinerOfferInput: "OFFER-xyz",
+    },
+  },
+];
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-offer-code.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-offer-code.ts
new file mode 100644
index 00000000..af6107d2
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/set-offer-code.ts
@@ -0,0 +1,27 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+
+/** Record the generated host invite code and clear any pending banner. */
+export const setOfferCode = <T extends State>(
+  state: T,
+  { code }: { code: string },
+): T => ({ ...state, offerCode: code, bannerText: "" });
+
+// Spec-owned cases, shared with the ecs `setOfferCode` transaction and action.
+export const cases: Conformance<typeof setOfferCode> = [
+  {
+    name: "stores the offer code and clears the banner",
+    before: {
+      phase: "idle", connection: "idle", role: null, sessionId: null,
+      offerCode: "", answerCode: "", bannerText: "please wait", bannerError: false,
+      hostAnswerInput: "", joinerOfferInput: "",
+    },
+    args: { code: "OFFER-123" },
+    after: {
+      phase: "idle", connection: "idle", role: null, sessionId: null,
+      offerCode: "OFFER-123", answerCode: "", bannerText: "", bannerError: false,
+      hostAnswerInput: "", joinerOfferInput: "",
+    },
+  },
+];
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/state/spec.test.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/spec.test.ts
new file mode 100644
index 00000000..9d5c4074
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/spec.test.ts
@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Conformance } from "@adobe/data/testing";
+import { State } from "./state.js";
+import { transitions } from "./transitions.js";
+
+// The single pure-spec test for every transform AND derivation in this folder.
+// `runSpec` auto-discovers each module in `transitions` that exports `cases`,
+// requires it to export exactly its function plus `cases`, and dispatches on case
+// shape. Each case's `before`/`input` is a delta over `State.create()`.
+Conformance.runSpec({ state: State, transitions });
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/state/start-host-signaling.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/start-host-signaling.ts
new file mode 100644
index 00000000..b6c76675
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/start-host-signaling.ts
@@ -0,0 +1,32 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+
+/** Enter the host signaling screen and begin waiting for an invite code. */
+export const startHostSignaling = <T extends State>(state: T): T => ({
+  ...state,
+  phase: "host-signaling",
+  role: "host",
+  connection: "connecting",
+  bannerText: "Generating invite code — please wait…",
+  bannerError: false,
+});
+
+// Spec-owned cases, shared with the ecs `startHostSignaling` transaction and
+// action. A no-arg transition, so `args` is `undefined`.
+export const cases: Conformance<typeof startHostSignaling> = [
+  {
+    name: "enters host-signaling as host, connecting, with a waiting banner",
+    before: {
+      phase: "idle", connection: "idle", role: null, sessionId: null,
+      offerCode: "", answerCode: "", bannerText: "", bannerError: false,
+      hostAnswerInput: "", joinerOfferInput: "",
+    },
+    args: undefined,
+    after: {
+      phase: "host-signaling", connection: "connecting", role: "host", sessionId: null,
+      offerCode: "", answerCode: "", bannerText: "Generating invite code — please wait…",
+      bannerError: false, hostAnswerInput: "", joinerOfferInput: "",
+    },
+  },
+];
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/state/start-join-signaling.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/start-join-signaling.ts
new file mode 100644
index 00000000..5c9018f6
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/start-join-signaling.ts
@@ -0,0 +1,32 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+
+/** Enter the joiner signaling screen, ready to paste the host's invite code. */
+export const startJoinSignaling = <T extends State>(state: T): T => ({
+  ...state,
+  phase: "join-signaling",
+  role: "joiner",
+  connection: "connecting",
+  bannerText: "",
+  bannerError: false,
+});
+
+// Spec-owned cases, shared with the ecs `startJoinSignaling` transaction and
+// action. A no-arg transition, so `args` is `undefined`.
+export const cases: Conformance<typeof startJoinSignaling> = [
+  {
+    name: "enters join-signaling as joiner, connecting, clearing the banner",
+    before: {
+      phase: "idle", connection: "idle", role: null, sessionId: null,
+      offerCode: "", answerCode: "", bannerText: "stale", bannerError: true,
+      hostAnswerInput: "", joinerOfferInput: "",
+    },
+    args: undefined,
+    after: {
+      phase: "join-signaling", connection: "connecting", role: "joiner", sessionId: null,
+      offerCode: "", answerCode: "", bannerText: "", bannerError: false,
+      hostAnswerInput: "", joinerOfferInput: "",
+    },
+  },
+];
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/state/state.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/state.ts
new file mode 100644
index 00000000..20b752c1
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/state.ts
@@ -0,0 +1,24 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Phase } from "../phase/phase.js";
+import type { ConnectionState } from "../connection-state/connection-state.js";
+import type { Role } from "../role/role.js";
+
+/**
+ * The serializable negotiation (signaling) state as one immutable object — the
+ * spec the ECS main-service is verified against. The non-serializable game
+ * database handle is deliberately *not* modelled here: it is session-only ECS
+ * state, invisible to this pure spec.
+ */
+export type State = {
+  readonly phase: Phase;
+  readonly connection: ConnectionState;
+  readonly role: Role | null;
+  readonly sessionId: string | null;
+  readonly offerCode: string;
+  readonly answerCode: string;
+  readonly bannerText: string;
+  readonly bannerError: boolean;
+  readonly hostAnswerInput: string;
+  readonly joinerOfferInput: string;
+};
+export * as State from "./public.js";
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/data/state/transitions.ts b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/transitions.ts
new file mode 100644
index 00000000..1092fd91
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/data/state/transitions.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+/// <reference types="vite/client" />
+
+// The transform/derivation modules for conformance discovery — the `{ fn, cases }`
+// source shared by `spec.test.ts` (pure) and the ecs `conformance.test.ts`. The
+// glob must be authored where Vite can statically see it (an eager glob, excluding
+// tests and this file itself); consumers import the resolved map.
+export const transitions = import.meta.glob<Record<string, unknown>>(
+  ["./*.ts", "!./*.test.ts", "!./*.type-test.ts", "!./transitions.ts"],
+  { eager: true },
+);
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/action-database.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/action-database.ts
new file mode 100644
index 00000000..d7ed2b08
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/action-database.ts
@@ -0,0 +1,24 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { ServiceDatabase } from "../service-database/service-database.js";
+import * as actions from "./actions/index.js";
+
+/**
+ * The full negotiation database: state surface + the imperative `connection`
+ * service + the UI-facing actions that drive it. Each action is a one-line
+ * delegation, so a container element calls `service.actions.startHost()` and
+ * never touches the full database.
+ */
+const actionDatabasePlugin = Database.Plugin.create({
+  extends: ServiceDatabase.plugin,
+  actions,
+});
+
+export type ActionDatabase = Database.Plugin.ToDatabase<
+  typeof actionDatabasePlugin
+>;
+
+export namespace ActionDatabase {
+  export const plugin = actionDatabasePlugin;
+  export type Store = Database.Plugin.ToStore<typeof actionDatabasePlugin>;
+}
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/configure.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/configure.ts
new file mode 100644
index 00000000..4d76e7da
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/configure.ts
@@ -0,0 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { NegotiationConfig } from "../../service-database/services/create-connection-service.js";
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+export const configure = (db: ServiceDatabase, config: NegotiationConfig) =>
+  db.services.connection.configure(config);
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/dispose.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/dispose.ts
new file mode 100644
index 00000000..baf2a8ee
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/dispose.ts
@@ -0,0 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+export const dispose = (db: ServiceDatabase) => db.services.connection.dispose();
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/enter-game.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/enter-game.ts
new file mode 100644
index 00000000..7c866e87
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/enter-game.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+// App-facing realization of `State.enterGame`: reuses the `setGameDb` transaction
+// (a differently-named transaction whose visible phase/connection effect is
+// exactly `enterGame`), preserving the current game-database handle read
+// synchronously from the store. There is no same-named transaction — transactions
+// are the looser layer.
+export const enterGame = (db: ServiceDatabase) => {
+  db.transactions.setGameDb({ gameDb: db.resources.gameDb });
+};
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/generate-answer.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/generate-answer.ts
new file mode 100644
index 00000000..e68b2cd3
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/generate-answer.ts
@@ -0,0 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+export const generateAnswer = (db: ServiceDatabase) =>
+  db.services.connection.generateAnswer();
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/index.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/index.ts
new file mode 100644
index 00000000..a7aa1cd5
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/index.ts
@@ -0,0 +1,24 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+//
+// The `actions` plugin facet. Only the capability-orchestration verbs (the
+// UI-facing actions that drive the imperative `connection` service) are
+// registered here.
+//
+// The per-transition actions (`start-host-signaling.ts`, `set-offer-code.ts`, …
+// — the same-named app-facing realization of each `data/state` transition) are
+// deliberately NOT re-exported into the facet: registering them would grow the
+// composed database's `actions`/`transactions` type past tsc's instantiation
+// budget (Database.Plugin extends is quadratic), which silently degrades the
+// inferred restricted-service type the `ui/` binds to. They live beside this
+// barrel as plain functions and are exercised directly by
+// `conformance/actions.test.ts` — exactly how the reference runner imports and
+// calls action functions (never through `db.actions`). The UI never dispatches
+// them (it uses `transactions.*` and the orchestration verbs), so keeping them
+// unregistered costs nothing at runtime.
+export * from "./configure.js";
+export * from "./start-host.js";
+export * from "./start-join.js";
+export * from "./submit-answer.js";
+export * from "./generate-answer.js";
+export * from "./reconnect.js";
+export * from "./dispose.js";
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/reconnect.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/reconnect.ts
new file mode 100644
index 00000000..692c02de
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/reconnect.ts
@@ -0,0 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+export const reconnect = (db: ServiceDatabase) => db.services.connection.reconnect();
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-answer-code.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-answer-code.ts
new file mode 100644
index 00000000..cc289a1a
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-answer-code.ts
@@ -0,0 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+// App-facing realization of `State.setAnswerCode`: commits the state transition
+// through a single transaction.
+export const setAnswerCode = (db: ServiceDatabase, { code }: { code: string }) => {
+  db.transactions.setAnswerCode({ code });
+};
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-banner.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-banner.ts
new file mode 100644
index 00000000..2fbff926
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-banner.ts
@@ -0,0 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+// App-facing realization of `State.setBanner`: commits the state transition
+// through a single transaction.
+export const setBanner = (db: ServiceDatabase, { text, error }: { text: string; error?: boolean }) => {
+  db.transactions.setBanner({ text, error });
+};
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-connection.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-connection.ts
new file mode 100644
index 00000000..0263d4a8
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-connection.ts
@@ -0,0 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ConnectionState } from "../../../../data/connection-state/connection-state.js";
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+// App-facing realization of `State.setConnection`: commits the state transition
+// through a single transaction.
+export const setConnection = (
+  db: ServiceDatabase,
+  { connection, sessionId }: { connection: ConnectionState; sessionId?: string | null },
+) => {
+  db.transactions.setConnection({ connection, sessionId });
+};
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-host-answer-input.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-host-answer-input.ts
new file mode 100644
index 00000000..2faa7960
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-host-answer-input.ts
@@ -0,0 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+// App-facing realization of `State.setHostAnswerInput`: commits the state
+// transition through a single transaction.
+export const setHostAnswerInput = (db: ServiceDatabase, { value }: { value: string }) => {
+  db.transactions.setHostAnswerInput({ value });
+};
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-joiner-offer-input.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-joiner-offer-input.ts
new file mode 100644
index 00000000..a756d819
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-joiner-offer-input.ts
@@ -0,0 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+// App-facing realization of `State.setJoinerOfferInput`: commits the state
+// transition through a single transaction.
+export const setJoinerOfferInput = (db: ServiceDatabase, { value }: { value: string }) => {
+  db.transactions.setJoinerOfferInput({ value });
+};
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-offer-code.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-offer-code.ts
new file mode 100644
index 00000000..542bf9bf
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/set-offer-code.ts
@@ -0,0 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+// App-facing realization of `State.setOfferCode`: commits the state transition
+// through a single transaction.
+export const setOfferCode = (db: ServiceDatabase, { code }: { code: string }) => {
+  db.transactions.setOfferCode({ code });
+};
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/start-host-signaling.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/start-host-signaling.ts
new file mode 100644
index 00000000..65382668
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/start-host-signaling.ts
@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+// App-facing realization of `State.startHostSignaling`: a pure state transition,
+// so it commits through a single transaction. (The imperative signaling that
+// follows is orchestrated by the `connection` service, driven from `startHost`.)
+export const startHostSignaling = (db: ServiceDatabase) => {
+  db.transactions.startHostSignaling();
+};
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/start-host.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/start-host.ts
new file mode 100644
index 00000000..0907a097
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/start-host.ts
@@ -0,0 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+export const startHost = (db: ServiceDatabase) => db.services.connection.startHost();
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/start-join-signaling.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/start-join-signaling.ts
new file mode 100644
index 00000000..2aa37a56
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/start-join-signaling.ts
@@ -0,0 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+// App-facing realization of `State.startJoinSignaling`: commits the state
+// transition through a single transaction.
+export const startJoinSignaling = (db: ServiceDatabase) => {
+  db.transactions.startJoinSignaling();
+};
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/start-join.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/start-join.ts
new file mode 100644
index 00000000..b0f4be60
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/start-join.ts
@@ -0,0 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+export const startJoin = (db: ServiceDatabase) => db.services.connection.startJoin();
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/submit-answer.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/submit-answer.ts
new file mode 100644
index 00000000..fa858265
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/action-database/actions/submit-answer.ts
@@ -0,0 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServiceDatabase } from "../../service-database/service-database.js";
+
+export const submitAnswer = (db: ServiceDatabase) =>
+  db.services.connection.submitAnswer();
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/conformance/conformance.test.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/conformance/conformance.test.ts
new file mode 100644
index 00000000..d4777088
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/conformance/conformance.test.ts
@@ -0,0 +1,29 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+/// <reference types="vite/client" />
+import { Conformance } from "@adobe/data/testing";
+import { State } from "../../../data/state/state.js";
+import { transitions } from "../../../data/state/transitions.js";
+import { MainService } from "../main-service.js";
+import { projection } from "./projection.js";
+
+// The whole ecs conformance for this feature in one call: `runFeature` pulls the
+// transactions off `MainService.plugin`, seeds each case's `before` (a delta) over
+// `State.create()`, and round-trips `State.samples` through the projection.
+// `transitions` (the discovered `{ fn, cases }` modules) is shared with spec.test.
+// Negotiation's per-transition actions (set-offer-code, enter-game, …) are
+// deliberately kept out of the plugin's `actions` facet (that would grow the plugin
+// type past tsc's budget), so they are discovered via the actions-directory glob
+// (`ops.actions`) instead of off `plugin.actions`. Transactions ARE registered, so
+// no transactions override; there are no derivations, so no `computedPlugin`.
+Conformance.runFeature({
+  state: State,
+  transitions,
+  plugin: MainService.plugin,
+  projection,
+  ops: {
+    actions: import.meta.glob(
+      ["../action-database/actions/*.ts", "!**/index.ts"],
+      { eager: true },
+    ),
+  },
+});
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/conformance/projection.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/conformance/projection.ts
new file mode 100644
index 00000000..5b70e5a8
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/conformance/projection.ts
@@ -0,0 +1,35 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "../../../data/state/state.js";
+import type { CoreDatabase } from "../core-database/core-database.js";
+
+// The test-only store↔`State` projection, passed to `Conformance.runFeature`.
+// Negotiation is resource-only (no entity collections), so `fromState` seeds the
+// scalar resources and returns nothing — ids resolve to `Entity.none` — and there
+// is no per-entity `toData`. The non-serializable `gameDb` resource is deliberately
+// left at its default: it is session-only ECS state, invisible to the spec.
+export const projection = {
+  fromState: (store: CoreDatabase.Store, state: State): void => {
+    store.resources.phase = state.phase;
+    store.resources.connection = state.connection;
+    store.resources.role = state.role;
+    store.resources.sessionId = state.sessionId;
+    store.resources.offerCode = state.offerCode;
+    store.resources.answerCode = state.answerCode;
+    store.resources.bannerText = state.bannerText;
+    store.resources.bannerError = state.bannerError;
+    store.resources.hostAnswerInput = state.hostAnswerInput;
+    store.resources.joinerOfferInput = state.joinerOfferInput;
+  },
+  toState: (store: CoreDatabase.Store): State => ({
+    phase: store.resources.phase,
+    connection: store.resources.connection,
+    role: store.resources.role,
+    sessionId: store.resources.sessionId,
+    offerCode: store.resources.offerCode,
+    answerCode: store.resources.answerCode,
+    bannerText: store.resources.bannerText,
+    bannerError: store.resources.bannerError,
+    hostAnswerInput: store.resources.hostAnswerInput,
+    joinerOfferInput: store.resources.joinerOfferInput,
+  }),
+};
diff --git a/packages/data-p2p-tictactoe/src/presence/database/core-database.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/core-database/core-database.ts
similarity index 71%
rename from packages/data-p2p-tictactoe/src/presence/database/core-database.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/core-database/core-database.ts
index d861a24d..c79c4f70 100644
--- a/packages/data-p2p-tictactoe/src/presence/database/core-database.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/core-database/core-database.ts
@@ -1,6 +1,6 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Database } from "@adobe/data/ecs";
-import * as resources from "../data/resources/index.js";
+import { resources } from "./resources.js";
 
 const coreDatabasePlugin = Database.Plugin.create({
   resources,
@@ -11,9 +11,9 @@ export type CoreDatabase = Database.Plugin.ToDatabase<typeof coreDatabasePlugin>
 export namespace CoreDatabase {
   export const plugin = coreDatabasePlugin;
   /**
-   * The store this database's transactions operate on — resources, index
-   * handles, and the initiating `userId`. A store *is* the transaction
-   * context; there is no separate transaction type.
+   * The store this database's transactions operate on — resources and the
+   * initiating `userId`. A store *is* the transaction context; there is no
+   * separate transaction type.
    */
   export type Store = Database.Plugin.ToStore<typeof coreDatabasePlugin>;
 }
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/core-database/resources.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/core-database/resources.ts
new file mode 100644
index 00000000..3f8e370e
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/core-database/resources.ts
@@ -0,0 +1,29 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Phase } from "../../../data/phase/phase.js";
+import type { ConnectionState } from "../../../data/connection-state/connection-state.js";
+import type { Role } from "../../../data/role/role.js";
+
+/**
+ * Negotiation state surface: resources only. Every resource is `nonPersistent`
+ * (session scope) so the negotiation database is never replicated — it is always
+ * local-only. Authored as plain `{ default, nonPersistent }` entries rather than
+ * `Database.resources({ session: … })`: `gameDb` holds a non-serializable live
+ * database handle that no `Schema` can express, and the whole set is session-only
+ * runtime state.
+ */
+export const resources = {
+  phase: { default: "idle" as Phase, nonPersistent: true },
+  connection: { default: "idle" as ConnectionState, nonPersistent: true },
+  role: { default: null as Role | null, nonPersistent: true },
+  sessionId: { default: null as string | null, nonPersistent: true },
+  offerCode: { default: "" as string, nonPersistent: true },
+  answerCode: { default: "" as string, nonPersistent: true },
+  bannerText: { default: "" as string, nonPersistent: true },
+  bannerError: { default: false as boolean, nonPersistent: true },
+  hostAnswerInput: { default: "" as string, nonPersistent: true },
+  joinerOfferInput: { default: "" as string, nonPersistent: true },
+  // The synced game database, populated by the connection service after the
+  // WebRTC channel opens. `unknown` so the negotiation plugin stays
+  // game-agnostic; the UI narrows it at the render boundary.
+  gameDb: { default: null as unknown, nonPersistent: true },
+};
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/main-service.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/main-service.ts
new file mode 100644
index 00000000..6df0f930
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/main-service.ts
@@ -0,0 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+//
+// The assembled negotiation feature database. Its topmost layer is
+// `action-database` (adds the UI-facing actions). Every consumer — `ui/`, the app
+// entry, `conformance/` — references `MainService`, never the topmost layer, so
+// adding or dropping a layer changes only this one line.
+export { ActionDatabase as MainService } from "./action-database/action-database.js";
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/service-database.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/service-database/service-database.ts
similarity index 70%
rename from packages/data-p2p-tictactoe/src/negotiation/database/service-database.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/service-database/service-database.ts
index af5dfb27..db37f1cf 100644
--- a/packages/data-p2p-tictactoe/src/negotiation/database/service-database.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/service-database/service-database.ts
@@ -1,12 +1,12 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Database } from "@adobe/data/ecs";
-import { TransactionDatabase } from "./transaction-database.js";
-import { createNegotiationService } from "./services/index.js";
+import { TransactionDatabase } from "../transaction-database/transaction-database.js";
+import { createConnectionService } from "./services/index.js";
 
 const serviceDatabasePlugin = Database.Plugin.create({
   extends: TransactionDatabase.plugin,
   services: {
-    negotiation: (db) => createNegotiationService(db),
+    connection: (db) => createConnectionService(db),
   },
 });
 
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/service-database/services/create-connection-service.test.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/service-database/services/create-connection-service.test.ts
new file mode 100644
index 00000000..acec12bc
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/service-database/services/create-connection-service.test.ts
@@ -0,0 +1,37 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { Database } from "@adobe/data/ecs";
+import { TransactionDatabase } from "../../transaction-database/transaction-database.js";
+import { SignalingService } from "../../../signaling-service/signaling-service.js";
+import { createConnectionService } from "./create-connection-service.js";
+
+// A microtask/timer flush so the fake signaling promises resolve.
+const flush = () => new Promise<void>((resolve) => setTimeout(resolve, 0));
+
+describe("connection service (deterministic fake signaling)", () => {
+  it("startHost enters host-signaling and records the invite code", async () => {
+    const db = Database.create(TransactionDatabase.plugin);
+    const service = createConnectionService(db, SignalingService.createFake);
+
+    service.startHost();
+    expect(db.resources.phase).toBe("host-signaling");
+    expect(db.resources.role).toBe("host");
+    expect(db.resources.connection).toBe("connecting");
+
+    await flush();
+    expect(db.resources.offerCode).toBe("fake-invite-code");
+  });
+
+  it("generateAnswer records the answer code", async () => {
+    const db = Database.create(TransactionDatabase.plugin);
+    const service = createConnectionService(db, SignalingService.createFake);
+
+    db.transactions.setJoinerOfferInput({ value: "OFFER-xyz" });
+    service.startJoin();
+    expect(db.resources.phase).toBe("join-signaling");
+
+    service.generateAnswer();
+    await flush();
+    expect(db.resources.answerCode).toBe("fake-answer-code");
+  });
+});
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/service-database/services/create-connection-service.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/service-database/services/create-connection-service.ts
new file mode 100644
index 00000000..7583bc73
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/service-database/services/create-connection-service.ts
@@ -0,0 +1,223 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+//
+// Database-bound orchestrator for the peer-to-peer connection lifecycle. It
+// drives the outside-world `signaling-service` capability (copy-paste WebRTC
+// handshake) for the serializable code exchange, then wires @adobe/data-sync and
+// constructs the synced game database when a peer link comes up. All results flow
+// back to the UI purely through negotiation transactions — the UI calls
+// `service.actions.*` and renders from observable state, never touching this
+// surface directly.
+//
+// The service retains its own closure-scoped procedural state (sync handles, the
+// game database, the current peer link) because it is non-serializable and tied
+// to per-instance browser objects — exactly what a service is for.
+
+import { Database, createRebaseReplayConcurrency } from "@adobe/data/ecs";
+import { createSyncServer, createSyncService, createLoopbackTransport, type SyncService, type ServerTransport, type ClientTransport } from "@adobe/data-sync";
+import { SignalingService } from "../../../signaling-service/signaling-service.js";
+import type { Role } from "../../../../data/role/role.js";
+import type { TransactionDatabase } from "../../transaction-database/transaction-database.js";
+
+type GameDb = Database<any, any, any, any, any, any, any, any>;
+
+/**
+ * Per-instance configuration handed to the service via `configure()` after
+ * mount. The game plugin / userId mapping live here because they are necessarily
+ * game-specific and cannot be encoded into the negotiation plugin itself.
+ */
+export interface NegotiationConfig {
+  readonly gamePlugin: Database.Plugin<any, any, any, any, any, any, any, any>;
+  readonly assignUserId: (role: Role) => string;
+}
+
+export interface ConnectionService {
+  configure(config: NegotiationConfig): void;
+  startHost(): void;
+  startJoin(): void;
+  submitAnswer(): void;
+  generateAnswer(): void;
+  reconnect(): void;
+  dispose(): void;
+}
+
+const log = (msg: string) => console.log(`[connection] ${msg}`);
+const syncLog = (msg: string) => console.log(`[sync] ${msg}`);
+const serverLog = (msg: string) => console.log(`[sync-server] ${msg}`);
+
+/**
+ * Create the connection service bound to its database. `signalingFactory`
+ * defaults to the production {@link SignalingService.create}; tests inject
+ * {@link SignalingService.createFake} for deterministic code exchange.
+ */
+export const createConnectionService = (
+  db: TransactionDatabase,
+  signalingFactory: (handlers: SignalingService.Handlers) => SignalingService = SignalingService.create,
+): ConnectionService => {
+  let config: NegotiationConfig | undefined;
+  const requireConfig = (): NegotiationConfig => {
+    if (!config) throw new Error("connection service used before configure()");
+    return config;
+  };
+
+  let joinStarted = false;
+  let syncService: SyncService | undefined;
+  let syncServer: ReturnType<typeof createSyncServer> | undefined;
+  let gameDb: GameDb | undefined;
+
+  const reportError = (text: string, err: unknown) =>
+    db.transactions.setBanner({ text: `${text}: ${String(err)}`, error: true });
+
+  const onTransportClose = () => {
+    log(`transport close observed; current connection=${db.resources.connection}`);
+    if (db.resources.connection === "connected" || db.resources.connection === "reconnecting") {
+      db.transactions.setConnection({ connection: "disconnected" });
+    }
+  };
+
+  const wireHostSync = (serverTransport: ServerTransport) => {
+    const priorSessionId = syncService?.sessionId();
+    const initialWatermark = syncService?.lastAppliedTime() ?? 0;
+    syncService?.dispose();
+
+    const { client: loopbackClient, server: loopbackServer } = createLoopbackTransport();
+    if (!syncServer) {
+      syncServer = createSyncServer({ logger: serverLog });
+    }
+    syncServer.connect(serverTransport);
+    syncServer.connect(loopbackServer);
+    syncService = createSyncService({
+      database: gameDb!,
+      transport: loopbackClient,
+      priorSessionId,
+      initialWatermark,
+      logger: syncLog,
+      onWelcome: ({ resetRequired }) => {
+        if (resetRequired) {
+          log(`welcome.resetRequired=true → resetting game DB`);
+          gameDb!.reset();
+        }
+      },
+    });
+
+    serverTransport.onClose(onTransportClose);
+    db.transactions.setConnection({ connection: "connected", sessionId: syncServer.sessionId });
+  };
+
+  const wireJoinerSync = (clientTransport: ClientTransport) => {
+    const priorSessionId = syncService?.sessionId();
+    const initialWatermark = syncService?.lastAppliedTime() ?? 0;
+    syncService?.dispose();
+
+    syncService = createSyncService({
+      database: gameDb!,
+      transport: clientTransport,
+      priorSessionId,
+      initialWatermark,
+      logger: syncLog,
+      onWelcome: ({ sessionId, resetRequired }) => {
+        if (resetRequired) {
+          log(`welcome.resetRequired=true → resetting game DB`);
+          gameDb!.reset();
+        }
+        db.transactions.setConnection({ connection: "connected", sessionId });
+      },
+    });
+
+    clientTransport.onClose(onTransportClose);
+  };
+
+  const wireGameDb = (userId: string, wireSync: () => void) => {
+    if (!gameDb) {
+      log(`creating game DB for userId=${userId}`);
+      gameDb = Database.create(requireConfig().gamePlugin, { concurrency: createRebaseReplayConcurrency(userId) });
+    }
+    wireSync();
+    db.transactions.setGameDb({ gameDb });
+  };
+
+  // A completed handshake: build the game DB (once) and wire sync for the role.
+  // The peer link auto-triggers ICE restart internally when the path degrades.
+  const signaling = signalingFactory({
+    onConnected: (connection) => {
+      log(`${connection.role} peer link established`);
+      if (connection.role === "host") {
+        wireGameDb(requireConfig().assignUserId("host"), () => wireHostSync(connection.transport));
+      } else {
+        wireGameDb(requireConfig().assignUserId("joiner"), () => wireJoinerSync(connection.transport));
+      }
+    },
+  });
+
+  const startHost = () => {
+    log(`startHost`);
+    db.transactions.startHostSignaling();
+    signaling
+      .createHostInvite()
+      .then((code) => {
+        log(`offer code generated (${code.length} chars)`);
+        db.transactions.setOfferCode({ code });
+      })
+      .catch((err: unknown) => reportError("Error generating offer", err));
+  };
+
+  const startJoin = () => {
+    log(`startJoin`);
+    db.transactions.startJoinSignaling();
+  };
+
+  const submitAnswer = () => {
+    const code = db.resources.hostAnswerInput.trim();
+    if (!code) return;
+    log(`submitting answer (${code.length} chars)`);
+    signaling.acceptHostAnswer(code).catch((err: unknown) => reportError("Connection failed", err));
+  };
+
+  const generateAnswer = () => {
+    const offerCodeFromHost = db.resources.joinerOfferInput.trim();
+    if (joinStarted || !offerCodeFromHost) return;
+    joinStarted = true;
+    log(`generating answer for offer (${offerCodeFromHost.length} chars)`);
+    db.transactions.setBanner({ text: "Generating answer — please wait…" });
+
+    signaling
+      .createJoinAnswer(offerCodeFromHost)
+      .then((code) => {
+        log(`answer code generated (${code.length} chars)`);
+        db.transactions.setAnswerCode({ code });
+      })
+      .catch((err: unknown) => reportError("Error creating answer", err));
+  };
+
+  const reconnect = () => {
+    const role = db.resources.role;
+    if (!gameDb || !role) return;
+    if (db.resources.connection === "reconnecting") return;
+    log(`reconnect (role=${role})`);
+    db.transactions.setConnection({ connection: "reconnecting" });
+    joinStarted = false;
+    // Tear down the dead peer link before building a new one.
+    signaling.reset();
+
+    if (role === "host") {
+      signaling
+        .createHostInvite()
+        .then((code) => db.transactions.setOfferCode({ code }))
+        .catch((err: unknown) => reportError("Error generating offer", err));
+    } else {
+      // For joiner, re-enter the signaling phase so the UI shows the textarea.
+      db.transactions.startJoinSignaling();
+      db.transactions.setConnection({ connection: "reconnecting" });
+    }
+  };
+
+  const dispose = () => {
+    log(`dispose`);
+    signaling.dispose();
+    syncService?.dispose();
+    syncServer?.dispose();
+  };
+
+  const configure = (c: NegotiationConfig) => { config = c; };
+
+  return { configure, startHost, startJoin, submitAnswer, generateAnswer, reconnect, dispose };
+};
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/service-database/services/index.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/service-database/services/index.ts
new file mode 100644
index 00000000..dc145582
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/service-database/services/index.ts
@@ -0,0 +1,2 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export * from "./create-connection-service.js";
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/transaction-database.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transaction-database.ts
similarity index 69%
rename from packages/data-p2p-tictactoe/src/negotiation/database/transaction-database.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transaction-database.ts
index eff08970..6f05583e 100644
--- a/packages/data-p2p-tictactoe/src/negotiation/database/transaction-database.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transaction-database.ts
@@ -1,6 +1,6 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Database } from "@adobe/data/ecs";
-import { CoreDatabase } from "./core-database.js";
+import { CoreDatabase } from "../core-database/core-database.js";
 import * as transactions from "./transactions/index.js";
 
 const transactionDatabasePlugin = Database.Plugin.create({
@@ -9,9 +9,9 @@ const transactionDatabasePlugin = Database.Plugin.create({
 });
 
 /**
- * The negotiation state surface the service writes to (resources +
- * transactions). The imperative `negotiation` service is layered on top by
- * {@link NegotiationDatabase}.
+ * The negotiation state surface the connection service writes to (resources +
+ * transactions). The imperative `connection` service is layered on top by the
+ * service database.
  */
 export type TransactionDatabase = Database.Plugin.ToDatabase<
   typeof transactionDatabasePlugin
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/index.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/index.ts
similarity index 100%
rename from packages/data-p2p-tictactoe/src/negotiation/database/transactions/index.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/index.ts
index fdb2071c..9ed5853a 100644
--- a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/index.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/index.ts
@@ -4,7 +4,7 @@ export * from "./start-join-signaling.js";
 export * from "./set-offer-code.js";
 export * from "./set-answer-code.js";
 export * from "./set-banner.js";
+export * from "./set-connection.js";
 export * from "./set-host-answer-input.js";
 export * from "./set-joiner-offer-input.js";
-export * from "./set-connection.js";
 export * from "./set-game-db.js";
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-answer-code.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-answer-code.ts
similarity index 74%
rename from packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-answer-code.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-answer-code.ts
index e8c5e4a4..83a01170 100644
--- a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-answer-code.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-answer-code.ts
@@ -1,5 +1,5 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { CoreDatabase } from "../core-database.js";
+import type { CoreDatabase } from "../../core-database/core-database.js";
 
 export const setAnswerCode = (t: CoreDatabase.Store, { code }: { code: string }) => {
   t.resources.answerCode = code;
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-banner.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-banner.ts
similarity index 77%
rename from packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-banner.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-banner.ts
index 6ea63d44..6a2bd108 100644
--- a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-banner.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-banner.ts
@@ -1,5 +1,5 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { CoreDatabase } from "../core-database.js";
+import type { CoreDatabase } from "../../core-database/core-database.js";
 
 export const setBanner = (
   t: CoreDatabase.Store,
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-connection.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-connection.ts
new file mode 100644
index 00000000..5822925e
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-connection.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ConnectionState } from "../../../../data/connection-state/connection-state.js";
+import type { CoreDatabase } from "../../core-database/core-database.js";
+
+export const setConnection = (
+  t: CoreDatabase.Store,
+  { connection, sessionId }: { connection: ConnectionState; sessionId?: string | null },
+) => {
+  t.resources.connection = connection;
+  if (sessionId !== undefined) t.resources.sessionId = sessionId;
+};
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-game-db.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-game-db.ts
new file mode 100644
index 00000000..4cfc67d1
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-game-db.ts
@@ -0,0 +1,15 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { CoreDatabase } from "../../core-database/core-database.js";
+
+/**
+ * Store the constructed (non-serializable) game database handle and transition
+ * to the live game. The visible phase / connection change is exactly the pure
+ * `State.enterGame` transform — see `set-game-db.test.ts`, which conforms this
+ * transaction to it by passing `gameDb: null` (the handle is invisible to the
+ * spec's serializable `State`).
+ */
+export const setGameDb = (t: CoreDatabase.Store, { gameDb }: { gameDb: unknown }) => {
+  t.resources.gameDb = gameDb;
+  t.resources.phase = "game";
+  t.resources.connection = "connected";
+};
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-host-answer-input.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-host-answer-input.ts
similarity index 72%
rename from packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-host-answer-input.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-host-answer-input.ts
index 71df9a1f..3ad8004f 100644
--- a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-host-answer-input.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-host-answer-input.ts
@@ -1,5 +1,5 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { CoreDatabase } from "../core-database.js";
+import type { CoreDatabase } from "../../core-database/core-database.js";
 
 export const setHostAnswerInput = (
   t: CoreDatabase.Store,
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-joiner-offer-input.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-joiner-offer-input.ts
similarity index 73%
rename from packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-joiner-offer-input.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-joiner-offer-input.ts
index 40c52af4..060e118e 100644
--- a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-joiner-offer-input.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-joiner-offer-input.ts
@@ -1,5 +1,5 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { CoreDatabase } from "../core-database.js";
+import type { CoreDatabase } from "../../core-database/core-database.js";
 
 export const setJoinerOfferInput = (
   t: CoreDatabase.Store,
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-offer-code.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-offer-code.ts
similarity index 73%
rename from packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-offer-code.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-offer-code.ts
index 4d2961a6..17ff29a3 100644
--- a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-offer-code.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/set-offer-code.ts
@@ -1,5 +1,5 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { CoreDatabase } from "../core-database.js";
+import type { CoreDatabase } from "../../core-database/core-database.js";
 
 export const setOfferCode = (t: CoreDatabase.Store, { code }: { code: string }) => {
   t.resources.offerCode = code;
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/start-host-signaling.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/start-host-signaling.ts
similarity index 82%
rename from packages/data-p2p-tictactoe/src/negotiation/database/transactions/start-host-signaling.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/start-host-signaling.ts
index 6e00b2f1..47572712 100644
--- a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/start-host-signaling.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/start-host-signaling.ts
@@ -1,5 +1,5 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { CoreDatabase } from "../core-database.js";
+import type { CoreDatabase } from "../../core-database/core-database.js";
 
 export const startHostSignaling = (t: CoreDatabase.Store) => {
   t.resources.phase = "host-signaling";
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/start-join-signaling.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/start-join-signaling.ts
similarity index 80%
rename from packages/data-p2p-tictactoe/src/negotiation/database/transactions/start-join-signaling.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/start-join-signaling.ts
index f11c810b..fc85fd53 100644
--- a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/start-join-signaling.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/main-service/transaction-database/transactions/start-join-signaling.ts
@@ -1,5 +1,5 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { CoreDatabase } from "../core-database.js";
+import type { CoreDatabase } from "../../core-database/core-database.js";
 
 export const startJoinSignaling = (t: CoreDatabase.Store) => {
   t.resources.phase = "join-signaling";
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/create-fake.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/create-fake.ts
new file mode 100644
index 00000000..0f865d2f
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/create-fake.ts
@@ -0,0 +1,25 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { SignalingService } from "./signaling-service.js";
+import type { Handlers } from "./types.js";
+
+/**
+ * Deterministic test double for {@link SignalingService}. Unlike the real
+ * service it performs no WebRTC I/O: `createHostInvite` always resolves
+ * `"fake-invite-code"`, `createJoinAnswer` always resolves `"fake-answer-code"`,
+ * and the connection-completion path (`onConnected`) never fires — the double
+ * exercises the deterministic *code-exchange* orchestration, which is exactly the
+ * part a unit test can assert on. A test asserts those fixed codes as literals it
+ * controls. The `handlers` are accepted for signature parity with `create` but
+ * `onConnected` is intentionally never invoked. (Full transport wiring is
+ * integration-tested against the live app.) This is the implementation the
+ * negotiation main-service tests inject so their assertions are predictable —
+ * see `features/services/index.md`.
+ */
+export const createFake = (_handlers: Handlers): SignalingService => ({
+  serviceName: "signaling",
+  createHostInvite: () => Promise.resolve("fake-invite-code"),
+  acceptHostAnswer: () => Promise.resolve(),
+  createJoinAnswer: () => Promise.resolve("fake-answer-code"),
+  reset: () => {},
+  dispose: () => {},
+});
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/create.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/create.ts
new file mode 100644
index 00000000..1f321812
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/create.ts
@@ -0,0 +1,87 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { startHostSignaling, startJoinerSignaling } from "./internal/signaling.js";
+import { createRenegotiator } from "./internal/renegotiator.js";
+import type { Role } from "../../data/role/role.js";
+import type { SignalingService } from "./signaling-service.js";
+import type { Handlers, PeerLink } from "./types.js";
+
+const renegLog = (msg: string) => console.log(`[reneg] ${msg}`);
+
+/**
+ * Wrap a freshly negotiated peer connection as a {@link PeerLink}: create its
+ * renegotiator and, on the host side, auto-trigger an ICE restart the moment the
+ * path degrades to "disconnected" (a transient state where the signal channel
+ * may still deliver renegotiation messages).
+ */
+const makeLink = (pc: RTCPeerConnection, signalChannel: RTCDataChannel, role: Role): PeerLink => {
+  const renegotiator = createRenegotiator(pc, signalChannel, role, renegLog);
+  const degradedCallbacks = new Set<() => void>();
+
+  pc.addEventListener("connectionstatechange", () => {
+    if (pc.connectionState === "disconnected") {
+      for (const cb of degradedCallbacks) cb();
+      if (role === "host") {
+        renegotiator.triggerIceRestart().catch((err) => renegLog(`triggerIceRestart rejected: ${String(err)}`));
+      }
+    }
+  });
+
+  return {
+    onDegraded: (callback) => { degradedCallbacks.add(callback); },
+    restartIce: () => renegotiator.triggerIceRestart(),
+    dispose: () => {
+      renegotiator.dispose();
+      degradedCallbacks.clear();
+      pc.close();
+    },
+  };
+};
+
+/**
+ * The production signaling service. Drives the real WebRTC copy-paste handshake
+ * (see `./internal/`) and, on completion, hands the sync transport + peer-link to
+ * `handlers.onConnected`.
+ */
+export const create = (handlers: Handlers): SignalingService => {
+  let host: ReturnType<typeof startHostSignaling> | undefined;
+  let currentLink: PeerLink | undefined;
+
+  return {
+    serviceName: "signaling",
+    createHostInvite: () => {
+      host = startHostSignaling();
+      host.connected
+        .then(({ transport, pc, signalChannel }) => {
+          currentLink?.dispose();
+          currentLink = makeLink(pc, signalChannel, "host");
+          handlers.onConnected({ role: "host", transport, link: currentLink });
+        })
+        .catch(() => undefined);
+      return host.offerCode;
+    },
+    acceptHostAnswer: async (answerCode: string) => {
+      host?.submitAnswer(answerCode);
+    },
+    createJoinAnswer: (inviteCode: string) => {
+      const session = startJoinerSignaling(inviteCode);
+      session.connected
+        .then(({ transport, pc, signalChannel }) => {
+          currentLink?.dispose();
+          currentLink = makeLink(pc, signalChannel, "joiner");
+          handlers.onConnected({ role: "joiner", transport, link: currentLink });
+        })
+        .catch(() => undefined);
+      return session.answerCode;
+    },
+    reset: () => {
+      currentLink?.dispose();
+      currentLink = undefined;
+      host = undefined;
+    },
+    dispose: () => {
+      currentLink?.dispose();
+      currentLink = undefined;
+      host = undefined;
+    },
+  };
+};
diff --git a/packages/data-p2p-tictactoe/src/renegotiator.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/internal/renegotiator.ts
similarity index 72%
rename from packages/data-p2p-tictactoe/src/renegotiator.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/internal/renegotiator.ts
index 560026a0..79b1a405 100644
--- a/packages/data-p2p-tictactoe/src/renegotiator.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/internal/renegotiator.ts
@@ -2,35 +2,12 @@
 //
 // ICE-restart driver layered on top of an open RTCPeerConnection and a
 // pre-established side-channel (RTCDataChannel) that carries renegotiation
-// messages: offer, answer, and trickled ICE candidates.
-//
-// Why ICE restart matters: the SCTP/DTLS state of an established connection
-// is bound to specific ICE credentials and a specific NAT mapping. When the
-// path breaks (Wi-Fi → ethernet, NAT remap, brief outage), ICE restart
-// generates fresh candidates and credentials *while reusing the existing
-// DTLS keys*, so the data channels survive the path change without a new
-// copy-paste handshake.
-//
-// Why an existing data channel: WebRTC has no built-in signaling channel.
-// Once the initial offer/answer is exchanged, peers need *some* transport
-// to ferry the renegotiation. We use a second pre-negotiated data channel
-// dedicated to that purpose so we don't multiplex our own envelopes onto
-// the application's sync stream.
-//
-// Limitation: this only works while the signal channel is still alive. If
-// the channel has already closed, the controller falls back to the manual
-// reconnect flow.
+// messages: offer, answer, and trickled ICE candidates. Used only inside the
+// signaling-service implementation (see `../create.ts`).
 
 export type Role = "host" | "joiner";
 
 export interface Renegotiator {
-    /**
-     * Host-only: kicks off an ICE restart by creating a new offer with
-     * `iceRestart: true`, setting it as the local description, and sending
-     * it to the joiner over the signal channel. The joiner responds with an
-     * answer, candidates trickle, and the connection re-converges to
-     * `connected`. No-op on the joiner side.
-     */
     readonly triggerIceRestart: () => Promise<void>;
     readonly dispose: () => void;
 }
@@ -62,8 +39,6 @@ export const createRenegotiator = (
         return true;
     };
 
-    // Trickle every locally-gathered ICE candidate to the peer so it can
-    // attach the new path as soon as it materialises.
     const onIceCandidate = (e: RTCPeerConnectionIceEvent) => {
         if (e.candidate === null) return;
         safeSend({ kind: "ice", candidate: e.candidate.toJSON() });
diff --git a/packages/data-p2p-tictactoe/src/signaling.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/internal/signaling.ts
similarity index 70%
rename from packages/data-p2p-tictactoe/src/signaling.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/internal/signaling.ts
index c07cb4aa..1371a9c5 100644
--- a/packages/data-p2p-tictactoe/src/signaling.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/internal/signaling.ts
@@ -1,20 +1,16 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 //
-// Serverless WebRTC signaling via copy-paste.
+// Serverless WebRTC signaling via copy-paste. Internal to the signaling-service
+// implementation (see `../create.ts`); not part of the public contract.
 //
 // The full ICE candidate list is embedded in the SDP by waiting for
-// iceGatheringState === "complete" before exposing the blob — one
-// copy-paste in each direction is sufficient for the initial handshake.
+// iceGatheringState === "complete" before exposing the blob — one copy-paste in
+// each direction is sufficient for the initial handshake.
 //
 // Both peers pre-create two `negotiated: true` data channels with matching
 // stream ids:
 //   - id 0 ("sync")   — carries @adobe/data-sync messages
-//   - id 1 ("signal") — carries WebRTC renegotiation messages used by the
-//                       renegotiator (ICE restart offer/answer/candidates).
-//
-// Pre-negotiated channels mean both sides have the channel objects in hand
-// before SDP is exchanged, so no `ondatachannel` event race and no SDP
-// renegotiation is needed to bring the second channel up.
+//   - id 1 ("signal") — carries WebRTC renegotiation messages (ICE restart).
 
 import {
     waitForIceComplete,
@@ -50,24 +46,12 @@ const waitForChannelOpen = (pc: RTCPeerConnection, channel: RTCDataChannel): Pro
         });
     });
 
-// ---------------------------------------------------------------------------
-// Host signaling
-// ---------------------------------------------------------------------------
-
 export interface HostConnection {
     readonly transport: ServerTransport;
     readonly pc: RTCPeerConnection;
     readonly signalChannel: RTCDataChannel;
 }
 
-/**
- * Initiates the host side of the WebRTC handshake.
- *
- * Returns:
- * - `offerCode` — base64 string to send to the joiner (display in a textarea)
- * - `submitAnswer(code)` — call when the joiner pastes their answer code
- * - `connected` — resolves to a {@link HostConnection} once both data channels open
- */
 export const startHostSignaling = (): {
     offerCode: Promise<string>;
     submitAnswer: (answerCode: string) => void;
@@ -90,9 +74,6 @@ export const startHostSignaling = (): {
         const code = await answerPromise;
         await pc.setRemoteDescription(decodeSession(code));
         await waitForChannelOpen(pc, syncChannel);
-        // The signal channel uses the same underlying SCTP association; once
-        // the connection is up it opens almost immediately, but await it
-        // explicitly so callers can use it without a readyState dance.
         await waitForChannelOpen(pc, signalChannel);
         return {
             transport: createWebRTCServerTransport(syncChannel),
@@ -104,31 +85,17 @@ export const startHostSignaling = (): {
     return { offerCode, submitAnswer, connected };
 };
 
-// ---------------------------------------------------------------------------
-// Joiner signaling
-// ---------------------------------------------------------------------------
-
 export interface JoinerConnection {
     readonly transport: ClientTransport;
     readonly pc: RTCPeerConnection;
     readonly signalChannel: RTCDataChannel;
 }
 
-/**
- * Initiates the joiner side of the WebRTC handshake.
- *
- * Returns:
- * - `answerCode` — base64 string to send back to the host
- * - `connected` — resolves to a {@link JoinerConnection} once both data channels open
- */
 export const startJoinerSignaling = (offerCode: string): {
     answerCode: Promise<string>;
     connected: Promise<JoinerConnection>;
 } => {
     const pc = new RTCPeerConnection(RTC_CONFIG);
-    // Pre-create the negotiated channels with matching ids BEFORE setting the
-    // remote description, so they're ready to open as soon as the SCTP
-    // association comes up.
     const { sync: syncChannel, signal: signalChannel } = createPair(pc);
 
     const answerCode = (async () => {
diff --git a/packages/data-p2p-tictactoe/src/webrtc-transport.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/internal/webrtc-transport.ts
similarity index 91%
rename from packages/data-p2p-tictactoe/src/webrtc-transport.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/internal/webrtc-transport.ts
index aa690951..81bbde32 100644
--- a/packages/data-p2p-tictactoe/src/webrtc-transport.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/internal/webrtc-transport.ts
@@ -11,17 +11,6 @@ import type { ClientTransport, ServerTransport, ClientMessage, ServerMessage } f
 const encode = (msg: unknown): string => JSON.stringify(msg);
 const decode = <T>(raw: string): T => JSON.parse(raw) as T;
 
-/**
- * Two adapters wrap an open RTCDataChannel as a sync transport:
- *
- *   - `createWebRTCServerTransport` — used by the **host**, which runs
- *     `createSyncServer` in-process and wraps each connected peer's
- *     channel as a `ServerTransport`.
- *   - `createWebRTCClientTransport` — used by the **joiner**, which wraps
- *     its channel as a `ClientTransport` and passes it to
- *     `createSyncService({ database, transport })`.
- */
-
 /**
  * Creates a ClientTransport backed by an RTCDataChannel.
  * Use on the joining peer (the "client" in sync terms).
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/public.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/public.ts
new file mode 100644
index 00000000..3e5a7d56
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/public.ts
@@ -0,0 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export type * from "./types.js";
+export { create } from "./create.js";
+export { createFake } from "./create-fake.js";
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/signaling-service.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/signaling-service.ts
new file mode 100644
index 00000000..a756ab26
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/signaling-service.ts
@@ -0,0 +1,34 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Service } from "@adobe/data/service";
+import { AsyncDataService } from "@adobe/data/service";
+import type { Assert } from "@adobe/data/types";
+
+/**
+ * The outside-world peer-connection port: the serverless copy-paste WebRTC
+ * handshake. Its public surface is intentionally Data-only (codes in, codes
+ * out) so it satisfies the async-data-service contract; the non-serializable
+ * result of a completed handshake — the sync transport and a peer-link — is
+ * delivered out-of-band to the `onConnected` handler supplied at construction
+ * (see {@link SignalingService.Handlers}). No WebRTC / SDK type names leak into
+ * this interface.
+ *
+ * Reached only through the negotiation `main-service` (its connection service
+ * wires it to ecs state); never imported by the UI.
+ */
+export interface SignalingService extends Service {
+  /** Host: create the invite code to share. Resolves once ICE gathering completes. */
+  createHostInvite: () => Promise<string>;
+  /** Host: submit the joiner's answer code, completing the handshake. */
+  acceptHostAnswer: (answerCode: string) => Promise<void>;
+  /** Joiner: consume the host's invite code and produce an answer code to send back. */
+  createJoinAnswer: (inviteCode: string) => Promise<string>;
+  /** Forget any in-flight host session so a fresh handshake can begin (reconnect). */
+  reset: () => void;
+  /** Tear down the live peer connection and its renegotiator. */
+  dispose: () => void;
+}
+
+// Contract conforms to the async-data-service pattern (Data-only members).
+type _Valid = Assert<AsyncDataService.IsValid<SignalingService>>;
+
+export * as SignalingService from "./public.js";
diff --git a/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/types.ts b/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/types.ts
new file mode 100644
index 00000000..581b12b6
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/services/signaling-service/types.ts
@@ -0,0 +1,30 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ServerTransport, ClientTransport } from "@adobe/data-sync";
+
+/**
+ * A live peer link surfaced when a handshake completes: a clean wrapper over the
+ * underlying peer connection and its ICE-restart renegotiator. Hides all WebRTC
+ * types from the contract.
+ */
+export type PeerLink = {
+  /** Register a callback fired when the path degrades (connection may recover). */
+  readonly onDegraded: (callback: () => void) => void;
+  /** Host-only: force an ICE restart to recover a degraded path. No-op on the joiner. */
+  readonly restartIce: () => Promise<void>;
+  /** Dispose the renegotiator and close the underlying connection. */
+  readonly dispose: () => void;
+};
+
+/**
+ * The result of a completed handshake, delivered to {@link Handlers.onConnected}.
+ * Discriminated on `role` so the transport narrows to the correct sync direction
+ * (host → `ServerTransport`, joiner → `ClientTransport`) with no cast.
+ */
+export type Connection =
+  | { readonly role: "host"; readonly transport: ServerTransport; readonly link: PeerLink }
+  | { readonly role: "joiner"; readonly transport: ClientTransport; readonly link: PeerLink };
+
+/** Construction-time handlers. Non-serializable, so delivered here, not via a member. */
+export type Handlers = {
+  readonly onConnected: (connection: Connection) => void;
+};
diff --git a/packages/data-p2p-tictactoe/src/copy-text.ts b/packages/data-p2p-tictactoe/src/features/negotiation/ui/copy-text.ts
similarity index 62%
rename from packages/data-p2p-tictactoe/src/copy-text.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/ui/copy-text.ts
index c9de6032..8481525f 100644
--- a/packages/data-p2p-tictactoe/src/copy-text.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/ui/copy-text.ts
@@ -2,9 +2,9 @@
 
 /**
  * Copy text to the clipboard, fire-and-forget. A pure UI affordance — not
- * application state — so it lives as a plain utility a container passes
- * straight to its presentation, never as a database transaction or action.
+ * application state — so it lives as a plain utility a container passes straight
+ * to its presentation, never as a database transaction or action.
  */
 export const copyText = (text: string): void => {
-    void navigator.clipboard.writeText(text).catch(() => undefined);
+  void navigator.clipboard.writeText(text).catch(() => undefined);
 };
diff --git a/packages/data-p2p-tictactoe/src/elements/p2p-app/p2p-app.ts b/packages/data-p2p-tictactoe/src/features/negotiation/ui/p2p-app/p2p-app.ts
similarity index 61%
rename from packages/data-p2p-tictactoe/src/elements/p2p-app/p2p-app.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/ui/p2p-app/p2p-app.ts
index 8e2793f5..186cd87d 100644
--- a/packages/data-p2p-tictactoe/src/elements/p2p-app/p2p-app.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/ui/p2p-app/p2p-app.ts
@@ -1,18 +1,18 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 //
-// Pure composition wrapper for the serverless P2P Tic-Tac-Toe shell. No
-// custom element here — the bootstrap is just data: combine the game
-// plugin, decide who is X / O, and pass lazy renderers for the game and
-// presence overlay to the generic Negotiation container.
+// Pure composition wrapper for the serverless P2P Tic-Tac-Toe shell. No custom
+// element here — the bootstrap is just data: combine the game plugin with the
+// presence peer plugin, decide who is X / O, and pass lazy renderers for the game
+// and presence overlay to the generic Negotiation container.
 
 import type { TemplateResult } from "lit";
 import { Database } from "@adobe/data/ecs";
 import { Tictactoe, TictactoeGameDatabase, PlayerMark } from "data-lit-tictactoe";
-import { PresenceDatabase } from "../../presence/database/presence-database.js";
+import { MainService as PresenceMainService } from "../../../presence/services/main-service/main-service.js";
+import { PresenceOverlay } from "../../../presence/ui/p2p-presence-overlay/p2p-presence-overlay.js";
 import { Negotiation } from "../p2p-negotiation/p2p-negotiation.js";
-import { PresenceOverlay } from "../p2p-presence-overlay/p2p-presence-overlay.js";
 
-const gamePlugin = Database.Plugin.combine(TictactoeGameDatabase.plugin, PresenceDatabase.plugin);
+const gamePlugin = Database.Plugin.combine(TictactoeGameDatabase.plugin, PresenceMainService.plugin);
 
 const assignUserId = (role: "host" | "joiner"): PlayerMark =>
     PlayerMark.values[role === "host" ? 0 : 1];
diff --git a/packages/data-p2p-tictactoe/src/elements/p2p-negotiation/p2p-negotiation-element.ts b/packages/data-p2p-tictactoe/src/features/negotiation/ui/p2p-negotiation/p2p-negotiation-element.ts
similarity index 85%
rename from packages/data-p2p-tictactoe/src/elements/p2p-negotiation/p2p-negotiation-element.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/ui/p2p-negotiation/p2p-negotiation-element.ts
index 10c095e4..c94b543e 100644
--- a/packages/data-p2p-tictactoe/src/elements/p2p-negotiation/p2p-negotiation-element.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/ui/p2p-negotiation/p2p-negotiation-element.ts
@@ -1,16 +1,16 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 //
-// Container for serverless P2P play. The negotiation database's `negotiation`
-// service is the imperative signaling machine; this element renders purely
-// from observable state and forwards user intent through `service.actions.*`.
-// It supplies the game-specific config once after mount and tears the service
-// down on unmount. No business logic, no full-database access.
+// Container for serverless P2P play. The negotiation main-service's `connection`
+// service is the imperative signaling machine; this element renders purely from
+// observable state and forwards user intent through `service.actions.*`. It
+// supplies the game-specific config once after mount and tears the service down
+// on unmount. No business logic, no full-database access.
 
 import { customElement, property } from "lit/decorators.js";
 import { Database } from "@adobe/data/ecs";
 import { DatabaseElement, useObservableValues, useEffect } from "@adobe/data-lit";
-import { NegotiationDatabase } from "../../negotiation/database/negotiation-database.js";
-import { copyText } from "../../copy-text.js";
+import { MainService } from "../../services/main-service/main-service.js";
+import { copyText } from "../copy-text.js";
 import { styles } from "./p2p-negotiation.css.js";
 import * as presentation from "./p2p-negotiation-presentation.js";
 import type { RenderGame, RenderPresence } from "./p2p-negotiation-presentation.js";
@@ -27,7 +27,7 @@ type GamePlugin = Database.Plugin<any, any, any, any, any, any, any, any>;
 type AssignUserId = (role: "host" | "joiner") => string;
 
 @customElement(tagName)
-export class P2pNegotiationElement extends DatabaseElement<typeof NegotiationDatabase.plugin> {
+export class P2pNegotiationElement extends DatabaseElement<typeof MainService.plugin> {
     static styles = styles;
 
     // Game-specific config: which game to negotiate and how to assign peer ids.
@@ -46,7 +46,7 @@ export class P2pNegotiationElement extends DatabaseElement<typeof NegotiationDat
     renderPresence?: RenderPresence;
 
     get plugin() {
-        return NegotiationDatabase.plugin;
+        return MainService.plugin;
     }
 
     render() {
diff --git a/packages/data-p2p-tictactoe/src/elements/p2p-negotiation/p2p-negotiation-presentation.test.ts b/packages/data-p2p-tictactoe/src/features/negotiation/ui/p2p-negotiation/p2p-negotiation-presentation.test.ts
similarity index 100%
rename from packages/data-p2p-tictactoe/src/elements/p2p-negotiation/p2p-negotiation-presentation.test.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/ui/p2p-negotiation/p2p-negotiation-presentation.test.ts
diff --git a/packages/data-p2p-tictactoe/src/elements/p2p-negotiation/p2p-negotiation-presentation.ts b/packages/data-p2p-tictactoe/src/features/negotiation/ui/p2p-negotiation/p2p-negotiation-presentation.ts
similarity index 98%
rename from packages/data-p2p-tictactoe/src/elements/p2p-negotiation/p2p-negotiation-presentation.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/ui/p2p-negotiation/p2p-negotiation-presentation.ts
index cbacc0c5..5be84da1 100644
--- a/packages/data-p2p-tictactoe/src/elements/p2p-negotiation/p2p-negotiation-presentation.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/ui/p2p-negotiation/p2p-negotiation-presentation.ts
@@ -1,8 +1,8 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import { html, nothing, type TemplateResult } from "lit";
-import type { Phase } from "../../types/phase/phase.js";
-import type { ConnectionState } from "../../negotiation/types/connection-state.js";
+import type { Phase } from "../../data/phase/phase.js";
+import type { ConnectionState } from "../../data/connection-state/connection-state.js";
 
 export type RenderGame = (args: { service: unknown }) => TemplateResult;
 export type RenderPresence = (args: { service: unknown; children: TemplateResult }) => TemplateResult;
@@ -230,4 +230,3 @@ function renderDisconnected({ reconnect }: { reconnect: () => void }) {
         </div>
     `;
 }
-
diff --git a/packages/data-p2p-tictactoe/src/elements/p2p-negotiation/p2p-negotiation.css.ts b/packages/data-p2p-tictactoe/src/features/negotiation/ui/p2p-negotiation/p2p-negotiation.css.ts
similarity index 100%
rename from packages/data-p2p-tictactoe/src/elements/p2p-negotiation/p2p-negotiation.css.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/ui/p2p-negotiation/p2p-negotiation.css.ts
diff --git a/packages/data-p2p-tictactoe/src/elements/p2p-negotiation/p2p-negotiation.ts b/packages/data-p2p-tictactoe/src/features/negotiation/ui/p2p-negotiation/p2p-negotiation.ts
similarity index 77%
rename from packages/data-p2p-tictactoe/src/elements/p2p-negotiation/p2p-negotiation.ts
rename to packages/data-p2p-tictactoe/src/features/negotiation/ui/p2p-negotiation/p2p-negotiation.ts
index 3e2425f4..d82afd4e 100644
--- a/packages/data-p2p-tictactoe/src/elements/p2p-negotiation/p2p-negotiation.ts
+++ b/packages/data-p2p-tictactoe/src/features/negotiation/ui/p2p-negotiation/p2p-negotiation.ts
@@ -6,13 +6,12 @@ import type { RenderGame, RenderPresence } from "./p2p-negotiation-presentation.
 
 /**
  * Generic over `P` (the game plugin) so callers' `renderGame` and
- * `renderPresence` callbacks receive a fully-typed `service` argument
- * matching the plugin they passed in. The element internally stores the
- * game database as `unknown` (the negotiation plugin is monomorphic), so
- * we adapt the typed callbacks at this boundary. The cast is justified:
- * the negotiation service constructs the game database from `args.gamePlugin`,
- * so by construction the value stored in the `gameDb` resource is a
- * `Database.Plugin.ToDatabase<P>`.
+ * `renderPresence` callbacks receive a fully-typed `service` argument matching
+ * the plugin they passed in. The element internally stores the game database as
+ * `unknown` (the negotiation plugin is monomorphic), so we adapt the typed
+ * callbacks at this boundary. The cast is justified: the connection service
+ * constructs the game database from `args.gamePlugin`, so by construction the
+ * value stored in the `gameDb` resource is a `Database.Plugin.ToDatabase<P>`.
  */
 export const Negotiation = <P extends Database.Plugin>(args: {
     gamePlugin: P;
diff --git a/packages/data-p2p-tictactoe/src/features/presence/data/cursors/cursors.ts b/packages/data-p2p-tictactoe/src/features/presence/data/cursors/cursors.ts
new file mode 100644
index 00000000..2027f9fd
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/data/cursors/cursors.ts
@@ -0,0 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Vec2 } from "@adobe/data/math";
+import type { PlayerMark } from "data-lit-tictactoe";
+
+/**
+ * Each connected peer's cursor position in normalised `[0..1, 0..1]` coordinates
+ * relative to the overlay element, keyed by `PlayerMark`. Entries appear when a
+ * peer first reports a position and may be absent for peers that have never moved
+ * their cursor.
+ */
+export type Cursors = Partial<Record<PlayerMark, Vec2>>;
+export * as Cursors from "./public.js";
diff --git a/packages/data-p2p-tictactoe/src/presence/data/resources/index.ts b/packages/data-p2p-tictactoe/src/features/presence/data/cursors/public.ts
similarity index 65%
rename from packages/data-p2p-tictactoe/src/presence/data/resources/index.ts
rename to packages/data-p2p-tictactoe/src/features/presence/data/cursors/public.ts
index 334918d3..1e5eef99 100644
--- a/packages/data-p2p-tictactoe/src/presence/data/resources/index.ts
+++ b/packages/data-p2p-tictactoe/src/features/presence/data/cursors/public.ts
@@ -1,2 +1,2 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-export * from "./cursors.js";
+export * from "./set.js";
diff --git a/packages/data-p2p-tictactoe/src/features/presence/data/cursors/set.ts b/packages/data-p2p-tictactoe/src/features/presence/data/cursors/set.ts
new file mode 100644
index 00000000..5f7ebe26
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/data/cursors/set.ts
@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Vec2 } from "@adobe/data/math";
+import type { PlayerMark } from "data-lit-tictactoe";
+import type { Cursors } from "./cursors.js";
+
+/** Return a copy of `cursors` with `mark`'s position set to `[x, y]`. */
+export const set = (cursors: Cursors, mark: PlayerMark, x: number, y: number): Cursors => ({
+  ...cursors,
+  [mark]: [x, y] as Vec2,
+});
diff --git a/packages/data-p2p-tictactoe/src/features/presence/data/state/conformance-case.ts b/packages/data-p2p-tictactoe/src/features/presence/data/state/conformance-case.ts
new file mode 100644
index 00000000..4426eca4
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/data/state/conformance-case.ts
@@ -0,0 +1,13 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Conformance as ConformanceApi } from "@adobe/data/testing";
+import type { State } from "./state.js";
+
+// The conformance case types for this feature — the shared `@adobe/data/testing`
+// machinery with `State` bound once, so a transform authors `Conformance<typeof fn>`
+// and a derivation `Derivation<typeof fn>` (args/input/value read from the
+// function's own signature). This tiny file is the only per-feature conformance
+// type declaration; everything else lives in `@adobe/data/testing`.
+export type Conformance<F extends (...args: never[]) => unknown> =
+  ConformanceApi.Cases<State, F>;
+export type Derivation<F extends (...args: never[]) => unknown> =
+  ConformanceApi.DerivationCases<F>;
diff --git a/packages/data-p2p-tictactoe/src/features/presence/data/state/create.ts b/packages/data-p2p-tictactoe/src/features/presence/data/state/create.ts
new file mode 100644
index 00000000..808a7317
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/data/state/create.ts
@@ -0,0 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+
+/** The initial presence state: no cursors reported yet. */
+export const create = (): State => ({ cursors: {} });
diff --git a/packages/data-p2p-tictactoe/src/features/presence/data/state/move-presence.ts b/packages/data-p2p-tictactoe/src/features/presence/data/state/move-presence.ts
new file mode 100644
index 00000000..36173d8e
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/data/state/move-presence.ts
@@ -0,0 +1,37 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { PlayerMark } from "data-lit-tictactoe";
+import type { Vec2 } from "@adobe/data/math";
+import { Cursors } from "../cursors/cursors.js";
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+
+/**
+ * Update the given peer's cursor position. `mark` identifies the peer — in the
+ * ecs implementation it is injected from the transaction's `userId` (the peer's
+ * assigned mark), so each peer only ever writes its own entry.
+ */
+export const movePresence = <T extends State>(
+  state: T,
+  { mark, x, y }: { mark: PlayerMark; x: number; y: number },
+): T => ({
+  ...state,
+  cursors: Cursors.set(state.cursors, mark, x, y),
+});
+
+const at = (x: number, y: number): Vec2 => [x, y] as Vec2;
+
+// Spec-owned cases, shared with the ecs `movePresence` transaction and action.
+export const cases: Conformance<typeof movePresence> = [
+  {
+    name: "records the first cursor position for a peer",
+    before: { cursors: {} },
+    args: { mark: "X", x: 0.5, y: 0.25 },
+    after: { cursors: { X: at(0.5, 0.25) } },
+  },
+  {
+    name: "updates one peer's cursor while preserving the other's",
+    before: { cursors: { X: at(0.5, 0.25) } },
+    args: { mark: "O", x: 0.75, y: 0.5 },
+    after: { cursors: { X: at(0.5, 0.25), O: at(0.75, 0.5) } },
+  },
+];
diff --git a/packages/data-p2p-tictactoe/src/features/presence/data/state/public.ts b/packages/data-p2p-tictactoe/src/features/presence/data/state/public.ts
new file mode 100644
index 00000000..437afe36
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/data/state/public.ts
@@ -0,0 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { create } from "./create.js";
+export { samples } from "./samples.js";
+export { movePresence } from "./move-presence.js";
diff --git a/packages/data-p2p-tictactoe/src/features/presence/data/state/samples.ts b/packages/data-p2p-tictactoe/src/features/presence/data/state/samples.ts
new file mode 100644
index 00000000..8e88e804
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/data/state/samples.ts
@@ -0,0 +1,13 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Vec2 } from "@adobe/data/math";
+import type { State } from "./state.js";
+import { create } from "./create.js";
+
+const at = (x: number, y: number): Vec2 => [x, y] as Vec2;
+
+/** Representative presence states the conformance projection round-trips. */
+export const samples: readonly State[] = [
+  create(), // no cursors reported yet
+  { cursors: { X: at(0.5, 0.25) } }, // one peer cursor
+  { cursors: { X: at(0.5, 0.25), O: at(0.75, 0.5) } }, // both peer cursors
+];
diff --git a/packages/data-p2p-tictactoe/src/features/presence/data/state/spec.test.ts b/packages/data-p2p-tictactoe/src/features/presence/data/state/spec.test.ts
new file mode 100644
index 00000000..fa0ada48
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/data/state/spec.test.ts
@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Conformance } from "@adobe/data/testing";
+import { transitions } from "./transitions.js";
+
+// The single pure-spec test for every transform AND derivation in this folder.
+// `runSpec` auto-discovers each module in `transitions` that exports `cases`,
+// requires it to export exactly its function plus `cases`, and dispatches on case
+// shape. Presence cases carry a full `before`, so no `state` default is passed.
+// Cursor positions are `Vec2` tuples compared in order; `cursors` compares by key.
+Conformance.runSpec({ transitions });
diff --git a/packages/data-p2p-tictactoe/src/features/presence/data/state/state.ts b/packages/data-p2p-tictactoe/src/features/presence/data/state/state.ts
new file mode 100644
index 00000000..38b9115b
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/data/state/state.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Cursors } from "../cursors/cursors.js";
+
+/**
+ * The presence state as one immutable object: the peer cursor positions. The
+ * spec the ECS presence main-service is verified against.
+ */
+export type State = {
+  readonly cursors: Cursors;
+};
+export * as State from "./public.js";
diff --git a/packages/data-p2p-tictactoe/src/features/presence/data/state/transitions.ts b/packages/data-p2p-tictactoe/src/features/presence/data/state/transitions.ts
new file mode 100644
index 00000000..1092fd91
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/data/state/transitions.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+/// <reference types="vite/client" />
+
+// The transform/derivation modules for conformance discovery — the `{ fn, cases }`
+// source shared by `spec.test.ts` (pure) and the ecs `conformance.test.ts`. The
+// glob must be authored where Vite can statically see it (an eager glob, excluding
+// tests and this file itself); consumers import the resolved map.
+export const transitions = import.meta.glob<Record<string, unknown>>(
+  ["./*.ts", "!./*.test.ts", "!./*.type-test.ts", "!./transitions.ts"],
+  { eager: true },
+);
diff --git a/packages/data-p2p-tictactoe/src/features/presence/services/main-service/action-database/action-database.ts b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/action-database/action-database.ts
new file mode 100644
index 00000000..0bdd4b72
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/action-database/action-database.ts
@@ -0,0 +1,24 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { TransactionDatabase } from "../transaction-database/transaction-database.js";
+import * as actions from "./actions/index.js";
+
+/**
+ * The assembled presence plugin: state surface + the `trackPresence` action.
+ * Combined onto the synced game database at the app shell (see the `p2p-app`
+ * composition) — presence is a P2P-specific concern, so it lives here rather than
+ * in the standalone game library.
+ */
+const actionDatabasePlugin = Database.Plugin.create({
+  extends: TransactionDatabase.plugin,
+  actions,
+});
+
+export type ActionDatabase = Database.Plugin.ToDatabase<
+  typeof actionDatabasePlugin
+>;
+
+export namespace ActionDatabase {
+  export const plugin = actionDatabasePlugin;
+  export type Store = Database.Plugin.ToStore<typeof actionDatabasePlugin>;
+}
diff --git a/packages/data-p2p-tictactoe/src/features/presence/services/main-service/action-database/actions/index.ts b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/action-database/actions/index.ts
new file mode 100644
index 00000000..1737d13a
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/action-database/actions/index.ts
@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+//
+// The `actions` plugin facet. Only `trackPresence` (the UI-facing streaming pump)
+// is registered. The same-named per-transition action `move-presence.ts` (the
+// discrete realization of `State.movePresence`) is deliberately NOT re-exported
+// into the facet: it is conformance-only and the UI never dispatches it (it uses
+// the streaming `trackPresence`). It lives beside this barrel as a plain function
+// exercised directly by `conformance/actions.test.ts` — mirroring how the
+// reference runner imports and calls action functions, never through `db.actions`.
+export * from "./track-presence.js";
diff --git a/packages/data-p2p-tictactoe/src/features/presence/services/main-service/action-database/actions/move-presence.ts b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/action-database/actions/move-presence.ts
new file mode 100644
index 00000000..419f518e
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/action-database/actions/move-presence.ts
@@ -0,0 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { TransactionDatabase } from "../../transaction-database/transaction-database.js";
+
+// App-facing realization of `State.movePresence`: commit one cursor move for the
+// calling peer through a single (non-streaming) transaction dispatch. The peer
+// identity (`mark`) is read by the transaction from the store's `userId`, so this
+// takes only the plain `{ x, y }` payload. The live UI drives cursor updates as a
+// stream via the `trackPresence` action; this discrete action is the same-named
+// transition realization the conformance runner exercises.
+export const movePresence = (db: TransactionDatabase, { x, y }: { x: number; y: number }) => {
+  db.transactions.movePresence({ x, y });
+};
diff --git a/packages/data-p2p-tictactoe/src/presence/database/actions/track-presence.ts b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/action-database/actions/track-presence.ts
similarity index 72%
rename from packages/data-p2p-tictactoe/src/presence/database/actions/track-presence.ts
rename to packages/data-p2p-tictactoe/src/features/presence/services/main-service/action-database/actions/track-presence.ts
index 8f8ca188..ab2f718a 100644
--- a/packages/data-p2p-tictactoe/src/presence/database/actions/track-presence.ts
+++ b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/action-database/actions/track-presence.ts
@@ -1,11 +1,11 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { TransactionDatabase } from "../transaction-database.js";
+import type { TransactionDatabase } from "../../transaction-database/transaction-database.js";
 
 /**
  * Pump a stream of normalised cursor positions into the synced presence
  * transient. The UI passes a positions generator factory (sourced from local
- * pointer events) and the action owns the fire-and-forget streaming
- * transaction, so the container never touches the full transactional surface.
+ * pointer events) and the action owns the fire-and-forget streaming transaction,
+ * so the container never touches the full transactional surface.
  */
 export const trackPresence = (
   db: TransactionDatabase,
diff --git a/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/actions.test.ts b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/actions.test.ts
new file mode 100644
index 00000000..2cefac9c
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/actions.test.ts
@@ -0,0 +1,52 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+/// <reference types="vite/client" />
+import { Database } from "@adobe/data/ecs";
+import type { ConcurrencyStrategyFactory } from "@adobe/data/ecs";
+import { Conformance } from "@adobe/data/testing";
+import { transitions } from "../../../data/state/transitions.js";
+import { MainService } from "../main-service.js";
+import { fromState } from "./from-state.js";
+import { toState } from "./to-state.js";
+
+// `movePresence`'s peer identity is the transaction `userId`, stamped by the db's
+// concurrency at dispatch. A test-only concurrency reads it from a closure that
+// `seedContext` primes with the case's `mark` just before the action runs; it
+// otherwise commits immediately. This is the one residual seam (user-scoped
+// context). The per-transition `movePresence` action isn't in the facet barrel
+// (the UI streams via `trackPresence`), so it's discovered via the actions glob.
+let peerUserId: string | undefined;
+const peerConcurrency: ConcurrencyStrategyFactory = (
+  execute,
+  getTransaction,
+) => ({
+  deferredCommit: false,
+  apply: (envelope) => {
+    if (envelope.time === 0) return undefined;
+    const transaction = getTransaction(envelope.name);
+    if (!transaction) throw new Error(`Unknown transaction: ${envelope.name}`);
+    return execute((t) => transaction(t, envelope.args), {
+      intermediate: envelope.time < 0,
+      userId: peerUserId,
+    });
+  },
+  cancel: () => {},
+  onReset: () => {},
+});
+
+Conformance.runActions({
+  makeDb: () =>
+    Database.toSystemDatabase(
+      Database.create(MainService.plugin, { concurrency: peerConcurrency }),
+    ),
+  store: (db) => db.store,
+  fromState,
+  toState,
+  transitions,
+  actions: import.meta.glob(
+    ["../action-database/actions/*.ts", "!../action-database/actions/index.ts"],
+    { eager: true },
+  ),
+  seedContext: (_db, _before, args) => {
+    peerUserId = (args as { mark: string }).mark;
+  },
+});
diff --git a/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/create-store.ts b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/create-store.ts
new file mode 100644
index 00000000..eba77b11
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/create-store.ts
@@ -0,0 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Store } from "@adobe/data/ecs";
+import { CoreDatabase } from "../core-database/core-database.js";
+
+// A fresh writable store carrying the presence schema. `CoreDatabase` is the only
+// schema layer. Test-only.
+export const createStore = (): CoreDatabase.Store => Store.create(CoreDatabase.plugin);
diff --git a/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/from-state.ts b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/from-state.ts
new file mode 100644
index 00000000..e8748c6e
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/from-state.ts
@@ -0,0 +1,16 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Entity } from "@adobe/data/ecs";
+import type { State } from "../../../data/state/state.js";
+import type { CoreDatabase } from "../core-database/core-database.js";
+
+// Seed a store to match a `data/` presence `State`. The inverse of `toState`.
+// Presence keeps its whole state in the `cursors` resource — there are no entity
+// collections — so the returned `spec id → seeded entity` map is empty and the
+// conformance runners' `resolve` is never used. Test-only.
+export const fromState = (
+  store: CoreDatabase.Store,
+  state: State,
+): ReadonlyMap<never, Entity> => {
+  store.resources.cursors = state.cursors;
+  return new Map<never, Entity>();
+};
diff --git a/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/projection.test.ts b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/projection.test.ts
new file mode 100644
index 00000000..d66ef3af
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/projection.test.ts
@@ -0,0 +1,22 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+//
+// Guards the presence projection: `toState(fromState(s)) ≡ s` over `State.samples`.
+// Presence uses the lower-level runners (see conformance.md), so — unlike a
+// `runFeature` feature, which folds this round-trip into the one call — its
+// projection round-trip is a standalone test over the same shared samples.
+import { describe, it } from "vitest";
+import { Match } from "@adobe/data/testing";
+import { State } from "../../../data/state/state.js";
+import { createStore } from "./create-store.js";
+import { fromState } from "./from-state.js";
+import { toState } from "./to-state.js";
+
+describe("presence conformance projection round-trips (toState ∘ fromState ≡ identity)", () => {
+  State.samples.forEach((state, i) => {
+    it(`sample ${i}`, () => {
+      const store = createStore();
+      fromState(store, state);
+      Match.assert(toState(store), state);
+    });
+  });
+});
diff --git a/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/seed-user-id.ts b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/seed-user-id.ts
new file mode 100644
index 00000000..24b4f3a1
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/seed-user-id.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { CoreDatabase } from "../core-database/core-database.js";
+
+/**
+ * Seed the transaction `userId` on a test store — impersonating the peer identity
+ * a live rebase-replay concurrency stamps at runtime (it is otherwise read-only,
+ * set only when the game database is created). Test-only.
+ */
+export const seedUserId = (store: CoreDatabase.Store, userId: string): void => {
+  Object.assign(store, { userId });
+};
diff --git a/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/to-state.ts b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/to-state.ts
new file mode 100644
index 00000000..de3f881b
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/to-state.ts
@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "../../../data/state/state.js";
+import type { CoreDatabase } from "../core-database/core-database.js";
+
+// Read a store back into a `data/` presence `State`. The inverse of `fromState`.
+// Test-only.
+export const toState = (store: CoreDatabase.Store): State => ({
+  cursors: store.resources.cursors,
+});
diff --git a/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/transactions.test.ts b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/transactions.test.ts
new file mode 100644
index 00000000..76d48e76
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/conformance/transactions.test.ts
@@ -0,0 +1,21 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Conformance } from "@adobe/data/testing";
+import { transitions } from "../../../data/state/transitions.js";
+import * as transactions from "../transaction-database/transactions/index.js";
+import { createStore } from "./create-store.js";
+import { seedUserId } from "./seed-user-id.js";
+import { fromState } from "./from-state.js";
+import { toState } from "./to-state.js";
+
+// `movePresence` reads the peer identity from the transaction `userId` (the peer's
+// mark) — ambient context not derivable from the case, so `seedContext` seeds it
+// from the case's `mark` before the raw transaction runs (the one residual hook).
+Conformance.runTransactions({
+  createStore,
+  fromState,
+  toState,
+  transitions,
+  transactions,
+  seedContext: (store, _before, args) =>
+    seedUserId(store, (args as { mark: string }).mark),
+});
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/core-database.ts b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/core-database/core-database.ts
similarity index 65%
rename from packages/data-p2p-tictactoe/src/negotiation/database/core-database.ts
rename to packages/data-p2p-tictactoe/src/features/presence/services/main-service/core-database/core-database.ts
index 43d0cb76..22f05754 100644
--- a/packages/data-p2p-tictactoe/src/negotiation/database/core-database.ts
+++ b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/core-database/core-database.ts
@@ -1,9 +1,7 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Database } from "@adobe/data/ecs";
-import * as resources from "../data/resources/index.js";
+import { resources } from "./resources.js";
 
-// Negotiation state surface: resources only. All resources are `nonPersistent`
-// so the negotiation database is never replicated (it is always local-only).
 const coreDatabasePlugin = Database.Plugin.create({
   resources,
 });
diff --git a/packages/data-p2p-tictactoe/src/features/presence/services/main-service/core-database/resources.ts b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/core-database/resources.ts
new file mode 100644
index 00000000..7e02b2d5
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/core-database/resources.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Cursors } from "../../../data/cursors/cursors.js";
+
+/**
+ * Presence state surface: the synced peer cursor positions. Written only through
+ * transient (never-committed) envelopes by `movePresence`, so it needs no schema
+ * flags — an absent entry simply means that peer hasn't moved yet.
+ */
+export const resources = {
+  cursors: { default: {} as Cursors },
+};
diff --git a/packages/data-p2p-tictactoe/src/features/presence/services/main-service/main-service.ts b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/main-service.ts
new file mode 100644
index 00000000..979daeaf
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/main-service.ts
@@ -0,0 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+//
+// The assembled presence feature database. Its topmost layer is `action-database`
+// (adds the `trackPresence` action). Every consumer references `MainService`,
+// never the topmost layer. Combined onto the game database at the app shell.
+export { ActionDatabase as MainService } from "./action-database/action-database.js";
diff --git a/packages/data-p2p-tictactoe/src/presence/database/transaction-database.ts b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/transaction-database/transaction-database.ts
similarity index 89%
rename from packages/data-p2p-tictactoe/src/presence/database/transaction-database.ts
rename to packages/data-p2p-tictactoe/src/features/presence/services/main-service/transaction-database/transaction-database.ts
index 8b279005..451e077c 100644
--- a/packages/data-p2p-tictactoe/src/presence/database/transaction-database.ts
+++ b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/transaction-database/transaction-database.ts
@@ -1,6 +1,6 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Database } from "@adobe/data/ecs";
-import { CoreDatabase } from "./core-database.js";
+import { CoreDatabase } from "../core-database/core-database.js";
 import * as transactions from "./transactions/index.js";
 
 const transactionDatabasePlugin = Database.Plugin.create({
diff --git a/packages/data-p2p-tictactoe/src/presence/database/transactions/index.ts b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/transaction-database/transactions/index.ts
similarity index 100%
rename from packages/data-p2p-tictactoe/src/presence/database/transactions/index.ts
rename to packages/data-p2p-tictactoe/src/features/presence/services/main-service/transaction-database/transactions/index.ts
diff --git a/packages/data-p2p-tictactoe/src/features/presence/services/main-service/transaction-database/transactions/move-presence.ts b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/transaction-database/transactions/move-presence.ts
new file mode 100644
index 00000000..eb8ddad5
--- /dev/null
+++ b/packages/data-p2p-tictactoe/src/features/presence/services/main-service/transaction-database/transactions/move-presence.ts
@@ -0,0 +1,19 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { PlayerMark } from "data-lit-tictactoe";
+import { State } from "../../../../data/state/state.js";
+import type { CoreDatabase } from "../../core-database/core-database.js";
+
+/**
+ * Update the calling peer's cursor position. Driven as a never-ending
+ * async-generator transaction by the `trackPresence` action — each yield applies
+ * as a transient (never committed) envelope. Reads `t.userId` as a `PlayerMark`
+ * so each peer only writes its own cursor entry; foreign or unset `userId`s are
+ * ignored. The write itself is delegated to the pure `State.movePresence` spec.
+ */
+export const movePresence = (t: CoreDatabase.Store, { x, y }: { x: number; y: number }) => {
+  if (!PlayerMark.is(t.userId)) return;
+  t.resources.cursors = State.movePresence(
+    { cursors: t.resources.cursors },
+    { mark: t.userId, x, y },
+  ).cursors;
+};
diff --git a/packages/data-p2p-tictactoe/src/elements/p2p-presence-overlay/p2p-presence-overlay-element.ts b/packages/data-p2p-tictactoe/src/features/presence/ui/p2p-presence-overlay/p2p-presence-overlay-element.ts
similarity index 75%
rename from packages/data-p2p-tictactoe/src/elements/p2p-presence-overlay/p2p-presence-overlay-element.ts
rename to packages/data-p2p-tictactoe/src/features/presence/ui/p2p-presence-overlay/p2p-presence-overlay-element.ts
index 3d3e4ad5..101d334a 100644
--- a/packages/data-p2p-tictactoe/src/elements/p2p-presence-overlay/p2p-presence-overlay-element.ts
+++ b/packages/data-p2p-tictactoe/src/features/presence/ui/p2p-presence-overlay/p2p-presence-overlay-element.ts
@@ -1,15 +1,15 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 //
-// Optional presence overlay container. Subscribes to peer cursor positions
-// from the synced game database and feeds local pointer movement back through
-// the `trackPresence` action. A pure container: it observes state, observes
-// local pointer events (a genuine UI concern), and delegates everything else
-// to the action / presentation.
+// Optional presence overlay container. Subscribes to peer cursor positions from
+// the synced game database and feeds local pointer movement back through the
+// `trackPresence` action. A pure container: it observes state, observes local
+// pointer events (a genuine UI concern), and delegates everything else to the
+// action / presentation.
 
 import { customElement } from "lit/decorators.js";
 import { DatabaseElement, useObservableValues, usePointerObserve, useEffect, useElement } from "@adobe/data-lit";
 import { Observe } from "@adobe/data/observe";
-import { PresenceDatabase } from "../../presence/database/presence-database.js";
+import { MainService } from "../../services/main-service/main-service.js";
 import { styles } from "./p2p-presence-overlay.css.js";
 import * as presentation from "./p2p-presence-overlay-presentation.js";
 
@@ -22,11 +22,11 @@ declare global {
 }
 
 @customElement(tagName)
-export class P2pPresenceOverlayElement extends DatabaseElement<typeof PresenceDatabase.plugin> {
+export class P2pPresenceOverlayElement extends DatabaseElement<typeof MainService.plugin> {
     static styles = styles;
 
     get plugin() {
-        return PresenceDatabase.plugin;
+        return MainService.plugin;
     }
 
     render() {
@@ -43,9 +43,9 @@ export class P2pPresenceOverlayElement extends DatabaseElement<typeof PresenceDa
         useEffect(() => {
             const positions = Observe.toAsyncGenerator(pointerPos, () => false);
 
-            // Normalise local pointer events against the overlay's own size —
-            // a DOM concern that has to live in the element — then hand the
-            // stream to the action, which owns the transient transaction.
+            // Normalise local pointer events against the overlay's own size — a DOM
+            // concern that has to live in the element — then hand the stream to the
+            // action, which owns the transient transaction.
             async function* normalised() {
                 for await (const [px, py] of positions) {
                     const { width, height } = element.getBoundingClientRect();
@@ -62,8 +62,8 @@ export class P2pPresenceOverlayElement extends DatabaseElement<typeof PresenceDa
         }, [pointerPos, element]);
 
         // The peer identity is the rebase-replay concurrency userId (set to the
-        // player's mark when the game DB was created); survives the restricted
-        // view since it is a plain value.
+        // player's mark when the game DB was created); survives the restricted view
+        // since it is a plain value.
         const localMark = concurrency.userId;
 
         return presentation.render({ cursors: values?.cursors, localMark });
diff --git a/packages/data-p2p-tictactoe/src/elements/p2p-presence-overlay/p2p-presence-overlay-presentation.test.ts b/packages/data-p2p-tictactoe/src/features/presence/ui/p2p-presence-overlay/p2p-presence-overlay-presentation.test.ts
similarity index 100%
rename from packages/data-p2p-tictactoe/src/elements/p2p-presence-overlay/p2p-presence-overlay-presentation.test.ts
rename to packages/data-p2p-tictactoe/src/features/presence/ui/p2p-presence-overlay/p2p-presence-overlay-presentation.test.ts
diff --git a/packages/data-p2p-tictactoe/src/elements/p2p-presence-overlay/p2p-presence-overlay-presentation.ts b/packages/data-p2p-tictactoe/src/features/presence/ui/p2p-presence-overlay/p2p-presence-overlay-presentation.ts
similarity index 100%
rename from packages/data-p2p-tictactoe/src/elements/p2p-presence-overlay/p2p-presence-overlay-presentation.ts
rename to packages/data-p2p-tictactoe/src/features/presence/ui/p2p-presence-overlay/p2p-presence-overlay-presentation.ts
diff --git a/packages/data-p2p-tictactoe/src/elements/p2p-presence-overlay/p2p-presence-overlay.css.ts b/packages/data-p2p-tictactoe/src/features/presence/ui/p2p-presence-overlay/p2p-presence-overlay.css.ts
similarity index 100%
rename from packages/data-p2p-tictactoe/src/elements/p2p-presence-overlay/p2p-presence-overlay.css.ts
rename to packages/data-p2p-tictactoe/src/features/presence/ui/p2p-presence-overlay/p2p-presence-overlay.css.ts
diff --git a/packages/data-p2p-tictactoe/src/elements/p2p-presence-overlay/p2p-presence-overlay.ts b/packages/data-p2p-tictactoe/src/features/presence/ui/p2p-presence-overlay/p2p-presence-overlay.ts
similarity index 51%
rename from packages/data-p2p-tictactoe/src/elements/p2p-presence-overlay/p2p-presence-overlay.ts
rename to packages/data-p2p-tictactoe/src/features/presence/ui/p2p-presence-overlay/p2p-presence-overlay.ts
index 5d5f907d..a7bc80fd 100644
--- a/packages/data-p2p-tictactoe/src/elements/p2p-presence-overlay/p2p-presence-overlay.ts
+++ b/packages/data-p2p-tictactoe/src/features/presence/ui/p2p-presence-overlay/p2p-presence-overlay.ts
@@ -1,16 +1,16 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import { html, type TemplateResult } from "lit";
-import type { PresenceDatabase } from "../../presence/database/presence-database.js";
+import type { Database } from "@adobe/data/ecs";
+import type { MainService } from "../../services/main-service/main-service.js";
 
-type PresenceService = PresenceDatabase;
+type PresenceService = Database.Plugin.ToDatabase<typeof MainService.plugin>;
 
 /**
- * Generic over `S` so callers may pass a database built from any plugin
- * that extends the presence plugin (e.g. one that combines presence with a
- * game plugin like `TictactoeGameDatabase.plugin`). The element class itself is typed
- * on the minimal `PresenceDatabase` surface and ignores the extra
- * capabilities.
+ * Generic over `S` so callers may pass a database built from any plugin that
+ * extends the presence plugin (e.g. one that combines presence with a game
+ * plugin like the tic-tac-toe game database). The element class itself is typed
+ * on the minimal presence surface and ignores the extra capabilities.
  */
 export const PresenceOverlay = <S extends PresenceService>(args: {
     service: S;
diff --git a/packages/data-p2p-tictactoe/src/main.ts b/packages/data-p2p-tictactoe/src/main.ts
index 22cc2610..0c8c7d3a 100644
--- a/packages/data-p2p-tictactoe/src/main.ts
+++ b/packages/data-p2p-tictactoe/src/main.ts
@@ -1,7 +1,7 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import { render } from "lit";
-import { P2pApp } from "./elements/p2p-app/p2p-app.js";
+import { P2pApp } from "./features/negotiation/ui/p2p-app/p2p-app.js";
 
 const app = document.getElementById("app");
 if (app) {
diff --git a/packages/data-p2p-tictactoe/src/negotiation/data/resources/answer-code.ts b/packages/data-p2p-tictactoe/src/negotiation/data/resources/answer-code.ts
deleted file mode 100644
index 44750b31..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/data/resources/answer-code.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-export const answerCode = { default: "" as string, nonPersistent: true };
diff --git a/packages/data-p2p-tictactoe/src/negotiation/data/resources/banner-error.ts b/packages/data-p2p-tictactoe/src/negotiation/data/resources/banner-error.ts
deleted file mode 100644
index 9b9b17d1..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/data/resources/banner-error.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-export const bannerError = { default: false as boolean, nonPersistent: true };
diff --git a/packages/data-p2p-tictactoe/src/negotiation/data/resources/banner-text.ts b/packages/data-p2p-tictactoe/src/negotiation/data/resources/banner-text.ts
deleted file mode 100644
index 00ba122f..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/data/resources/banner-text.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-export const bannerText = { default: "" as string, nonPersistent: true };
diff --git a/packages/data-p2p-tictactoe/src/negotiation/data/resources/connection.ts b/packages/data-p2p-tictactoe/src/negotiation/data/resources/connection.ts
deleted file mode 100644
index 76372b04..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/data/resources/connection.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { ConnectionState } from "../../types/connection-state.js";
-
-export const connection = { default: "idle" as ConnectionState, nonPersistent: true };
diff --git a/packages/data-p2p-tictactoe/src/negotiation/data/resources/game-db.ts b/packages/data-p2p-tictactoe/src/negotiation/data/resources/game-db.ts
deleted file mode 100644
index fd923a5a..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/data/resources/game-db.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-// The synced game database, populated by the negotiation service after the
-// WebRTC channel opens. `unknown` so the plugin stays game-agnostic; consumers
-// cast at the render boundary.
-export const gameDb = { default: null as unknown, nonPersistent: true };
diff --git a/packages/data-p2p-tictactoe/src/negotiation/data/resources/host-answer-input.ts b/packages/data-p2p-tictactoe/src/negotiation/data/resources/host-answer-input.ts
deleted file mode 100644
index bf91db75..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/data/resources/host-answer-input.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-// Live value of the host's "paste answer" textarea. Backing it with a resource
-// keeps the textarea controlled and avoids touching the DOM from actions.
-export const hostAnswerInput = { default: "" as string, nonPersistent: true };
diff --git a/packages/data-p2p-tictactoe/src/negotiation/data/resources/index.ts b/packages/data-p2p-tictactoe/src/negotiation/data/resources/index.ts
deleted file mode 100644
index cc4edf5e..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/data/resources/index.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-export * from "./phase.js";
-export * from "./connection.js";
-export * from "./role.js";
-export * from "./session-id.js";
-export * from "./offer-code.js";
-export * from "./answer-code.js";
-export * from "./banner-text.js";
-export * from "./banner-error.js";
-export * from "./host-answer-input.js";
-export * from "./joiner-offer-input.js";
-export * from "./game-db.js";
diff --git a/packages/data-p2p-tictactoe/src/negotiation/data/resources/joiner-offer-input.ts b/packages/data-p2p-tictactoe/src/negotiation/data/resources/joiner-offer-input.ts
deleted file mode 100644
index b60ea246..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/data/resources/joiner-offer-input.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-// Live value of the joiner's "paste offer" textarea. Backing it with a
-// resource keeps the textarea controlled and avoids touching the DOM.
-export const joinerOfferInput = { default: "" as string, nonPersistent: true };
diff --git a/packages/data-p2p-tictactoe/src/negotiation/data/resources/offer-code.ts b/packages/data-p2p-tictactoe/src/negotiation/data/resources/offer-code.ts
deleted file mode 100644
index 9ef498c4..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/data/resources/offer-code.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-export const offerCode = { default: "" as string, nonPersistent: true };
diff --git a/packages/data-p2p-tictactoe/src/negotiation/data/resources/phase.ts b/packages/data-p2p-tictactoe/src/negotiation/data/resources/phase.ts
deleted file mode 100644
index 838d4af5..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/data/resources/phase.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { Phase } from "../../../types/phase/phase.js";
-
-export const phase = { default: "idle" as Phase, nonPersistent: true };
diff --git a/packages/data-p2p-tictactoe/src/negotiation/data/resources/role.ts b/packages/data-p2p-tictactoe/src/negotiation/data/resources/role.ts
deleted file mode 100644
index 1d88b484..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/data/resources/role.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-export const role = { default: null as "host" | "joiner" | null, nonPersistent: true };
diff --git a/packages/data-p2p-tictactoe/src/negotiation/data/resources/session-id.ts b/packages/data-p2p-tictactoe/src/negotiation/data/resources/session-id.ts
deleted file mode 100644
index 21b671f0..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/data/resources/session-id.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-export const sessionId = { default: null as string | null, nonPersistent: true };
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/actions/configure.ts b/packages/data-p2p-tictactoe/src/negotiation/database/actions/configure.ts
deleted file mode 100644
index 987593b4..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/database/actions/configure.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { NegotiationConfig } from "../services/index.js";
-import type { ServiceDatabase } from "../service-database.js";
-
-export const configure = (db: ServiceDatabase, config: NegotiationConfig) =>
-  db.services.negotiation.configure(config);
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/actions/dispose.ts b/packages/data-p2p-tictactoe/src/negotiation/database/actions/dispose.ts
deleted file mode 100644
index c0cef82b..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/database/actions/dispose.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { ServiceDatabase } from "../service-database.js";
-
-export const dispose = (db: ServiceDatabase) => db.services.negotiation.dispose();
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/actions/generate-answer.ts b/packages/data-p2p-tictactoe/src/negotiation/database/actions/generate-answer.ts
deleted file mode 100644
index ce9e32a4..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/database/actions/generate-answer.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { ServiceDatabase } from "../service-database.js";
-
-export const generateAnswer = (db: ServiceDatabase) =>
-  db.services.negotiation.generateAnswer();
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/actions/index.ts b/packages/data-p2p-tictactoe/src/negotiation/database/actions/index.ts
deleted file mode 100644
index 503a3b14..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/database/actions/index.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-export * from "./configure.js";
-export * from "./start-host.js";
-export * from "./start-join.js";
-export * from "./submit-answer.js";
-export * from "./generate-answer.js";
-export * from "./reconnect.js";
-export * from "./dispose.js";
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/actions/reconnect.ts b/packages/data-p2p-tictactoe/src/negotiation/database/actions/reconnect.ts
deleted file mode 100644
index dbe314dc..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/database/actions/reconnect.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { ServiceDatabase } from "../service-database.js";
-
-export const reconnect = (db: ServiceDatabase) => db.services.negotiation.reconnect();
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/actions/start-host.ts b/packages/data-p2p-tictactoe/src/negotiation/database/actions/start-host.ts
deleted file mode 100644
index 3c1b35a8..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/database/actions/start-host.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { ServiceDatabase } from "../service-database.js";
-
-export const startHost = (db: ServiceDatabase) => db.services.negotiation.startHost();
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/actions/start-join.ts b/packages/data-p2p-tictactoe/src/negotiation/database/actions/start-join.ts
deleted file mode 100644
index b2f04f3f..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/database/actions/start-join.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { ServiceDatabase } from "../service-database.js";
-
-export const startJoin = (db: ServiceDatabase) => db.services.negotiation.startJoin();
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/actions/submit-answer.ts b/packages/data-p2p-tictactoe/src/negotiation/database/actions/submit-answer.ts
deleted file mode 100644
index 5832932b..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/database/actions/submit-answer.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { ServiceDatabase } from "../service-database.js";
-
-export const submitAnswer = (db: ServiceDatabase) =>
-  db.services.negotiation.submitAnswer();
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/negotiation-database.ts b/packages/data-p2p-tictactoe/src/negotiation/database/negotiation-database.ts
deleted file mode 100644
index 565c0c62..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/database/negotiation-database.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { Database } from "@adobe/data/ecs";
-import { ServiceDatabase } from "./service-database.js";
-import * as actions from "./actions/index.js";
-
-/**
- * The full negotiation database: state surface + the imperative `negotiation`
- * service + the UI-facing actions that drive it. Each action is a one-line
- * delegation, so a container element calls `service.actions.startHost()` and
- * never touches the full database.
- *
- * Static (not parameterised by game): the plugin — and so the service — is
- * built during `connectedCallback`, before a container's bound props exist,
- * so a container must supply the game-specific `NegotiationConfig` after mount
- * via `actions.configure(...)`.
- */
-const negotiationDatabasePlugin = Database.Plugin.create({
-  extends: ServiceDatabase.plugin,
-  actions,
-});
-
-export type NegotiationDatabase = Database.Plugin.ToDatabase<
-  typeof negotiationDatabasePlugin
->;
-
-export namespace NegotiationDatabase {
-  export const plugin = negotiationDatabasePlugin;
-  export type Store = Database.Plugin.ToStore<typeof negotiationDatabasePlugin>;
-}
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/services/negotiation-service.ts b/packages/data-p2p-tictactoe/src/negotiation/database/services/negotiation-service.ts
deleted file mode 100644
index 89becdd6..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/database/services/negotiation-service.ts
+++ /dev/null
@@ -1,291 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-//
-// Imperative state machine wrapping signaling + sync wiring + game DB
-// construction. Registered as the `negotiation` service on the negotiation
-// database (see `service-database.ts`) and driven through the actions layer
-// (see `negotiation-database.ts`), so the UI never touches this surface
-// directly — it calls `service.actions.startHost()` and renders purely from
-// observable state.
-//
-// The service intentionally retains its own closure-scoped procedural state
-// (signaling promises, sync server / service handles, peer-connection +
-// renegotiator handles). That state is not appropriate for ECS resources
-// because it is non-serialisable and tied to per-instance browser objects —
-// which is exactly what a service is for.
-
-import { Database, createRebaseReplayConcurrency } from "@adobe/data/ecs";
-import { createSyncServer, createSyncService, createLoopbackTransport, type SyncService } from "@adobe/data-sync";
-import { startHostSignaling, startJoinerSignaling, type HostConnection, type JoinerConnection } from "../../../signaling.js";
-import { createRenegotiator, type Renegotiator } from "../../../renegotiator.js";
-import type { TransactionDatabase } from "../transaction-database.js";
-
-type GameDb = Database<any, any, any, any, any, any, any, any>;
-
-/**
- * Per-instance configuration handed to the service via `configure()` after
- * mount. The game plugin / userId mapping live here because they are
- * necessarily game-specific and cannot be encoded into the negotiation
- * plugin itself.
- */
-export interface NegotiationConfig {
-    readonly gamePlugin: Database.Plugin<any, any, any, any, any, any, any, any>;
-    readonly assignUserId: (role: "host" | "joiner") => string;
-}
-
-export interface NegotiationService {
-    /**
-     * Supply the game-specific configuration. Called once after mount, when
-     * the container's props are available — the plugin (and therefore this
-     * service) is constructed during `connectedCallback`, before bound props
-     * exist, so config cannot be closed over at construction.
-     */
-    configure(config: NegotiationConfig): void;
-    startHost(): void;
-    startJoin(): void;
-    /** Submit the value currently in `hostAnswerInput` to the host signaling flow. */
-    submitAnswer(): void;
-    /** Begin joiner signaling using the value currently in `joinerOfferInput`. */
-    generateAnswer(): void;
-    /** Attempt to re-establish a dropped P2P connection via manual re-signaling. */
-    reconnect(): void;
-    dispose(): void;
-}
-
-const log = (msg: string) => console.log(`[negotiation] ${msg}`);
-const syncLog = (msg: string) => console.log(`[sync] ${msg}`);
-const serverLog = (msg: string) => console.log(`[sync-server] ${msg}`);
-const renegLog = (msg: string) => console.log(`[reneg] ${msg}`);
-
-/**
- * Creates the negotiation service bound to its database. The service writes
- * to the database via transactions, so consumers only need to subscribe to
- * that database to render reactive UI.
- */
-export const createNegotiationService = (
-    db: TransactionDatabase,
-): NegotiationService => {
-    let config: NegotiationConfig | undefined;
-    const requireConfig = (): NegotiationConfig => {
-        if (!config) throw new Error("negotiation service used before configure()");
-        return config;
-    };
-
-    let submitHostAnswer: ((code: string) => void) | undefined;
-    let joinStarted = false;
-    let syncService: SyncService | undefined;
-    let syncServer: ReturnType<typeof createSyncServer> | undefined;
-    // Retained for reconnect: the game DB and accumulated watermark.
-    let gameDb: GameDb | undefined;
-    // Retained for ICE restart: the live PC and renegotiator. Replaced on
-    // every successful (re)connect; cleared on full close.
-    let pc: RTCPeerConnection | undefined;
-    let renegotiator: Renegotiator | undefined;
-
-    const reportError = (text: string, err: unknown) =>
-        db.transactions.setBanner({ text: `${text}: ${String(err)}`, error: true });
-
-    const onTransportClose = () => {
-        log(`transport close observed; current connection=${db.resources.connection}`);
-        if (db.resources.connection === "connected" || db.resources.connection === "reconnecting") {
-            db.transactions.setConnection({ state: "disconnected" });
-        }
-    };
-
-    /**
-     * Wires the lifecycle of a freshly negotiated peer connection: replaces
-     * the retained `pc`/`renegotiator`, listens for connection-state
-     * degradation, and triggers ICE restart on the host side when the path
-     * goes "disconnected" — a transient state where the existing channels
-     * may still deliver renegotiation messages. If the path subsequently
-     * goes "failed" the existing transport-close path takes over.
-     */
-    const wirePeerConnection = (newPc: RTCPeerConnection, signalChannel: RTCDataChannel, role: "host" | "joiner") => {
-        renegotiator?.dispose();
-        pc = newPc;
-        renegotiator = createRenegotiator(newPc, signalChannel, role, renegLog);
-
-        newPc.addEventListener("connectionstatechange", () => {
-            log(`pc.connectionState=${newPc.connectionState}`);
-            if (newPc.connectionState === "disconnected" && role === "host") {
-                renegotiator?.triggerIceRestart().catch((err) =>
-                    log(`triggerIceRestart rejected: ${String(err)}`),
-                );
-            }
-        });
-        newPc.addEventListener("iceconnectionstatechange", () => {
-            log(`pc.iceConnectionState=${newPc.iceConnectionState}`);
-        });
-    };
-
-    const wireHostSync = (serverTransport: HostConnection["transport"]) => {
-        const priorSessionId = syncService?.sessionId();
-        const initialWatermark = syncService?.lastAppliedTime() ?? 0;
-        syncService?.dispose();
-
-        const { client: loopbackClient, server: loopbackServer } = createLoopbackTransport();
-        if (!syncServer) {
-            syncServer = createSyncServer({ logger: serverLog });
-        }
-        syncServer.connect(serverTransport);
-        syncServer.connect(loopbackServer);
-        syncService = createSyncService({
-            database: gameDb!,
-            transport: loopbackClient,
-            priorSessionId,
-            initialWatermark,
-            logger: syncLog,
-            onWelcome: ({ resetRequired }) => {
-                if (resetRequired) {
-                    log(`welcome.resetRequired=true → resetting game DB`);
-                    gameDb!.reset();
-                }
-            },
-        });
-
-        serverTransport.onClose(onTransportClose);
-        db.transactions.setConnection({ state: "connected", sessionId: syncServer.sessionId });
-    };
-
-    const wireJoinerSync = (clientTransport: JoinerConnection["transport"]) => {
-        const priorSessionId = syncService?.sessionId();
-        const initialWatermark = syncService?.lastAppliedTime() ?? 0;
-        syncService?.dispose();
-
-        syncService = createSyncService({
-            database: gameDb!,
-            transport: clientTransport,
-            priorSessionId,
-            initialWatermark,
-            logger: syncLog,
-            onWelcome: ({ sessionId, resetRequired }) => {
-                if (resetRequired) {
-                    log(`welcome.resetRequired=true → resetting game DB`);
-                    gameDb!.reset();
-                }
-                db.transactions.setConnection({ state: "connected", sessionId });
-            },
-        });
-
-        clientTransport.onClose(onTransportClose);
-    };
-
-    const wireGameDb = (
-        userId: string,
-        wireSync: () => void,
-    ) => {
-        if (!gameDb) {
-            log(`creating game DB for userId=${userId}`);
-            gameDb = Database.create(requireConfig().gamePlugin, { concurrency: createRebaseReplayConcurrency(userId) });
-        }
-        wireSync();
-        db.transactions.setGameDb({ gameDb });
-    };
-
-    const startHost = () => {
-        log(`startHost`);
-        db.transactions.startHostSignaling();
-
-        const { offerCode, submitAnswer, connected } = startHostSignaling();
-        submitHostAnswer = submitAnswer;
-
-        offerCode
-            .then((code) => {
-                log(`offer code generated (${code.length} chars)`);
-                db.transactions.setOfferCode({ code });
-            })
-            .catch((err: unknown) => reportError("Error generating offer", err));
-
-        connected
-            .then(({ transport, pc: newPc, signalChannel }) => {
-                log(`host data channels open`);
-                wirePeerConnection(newPc, signalChannel, "host");
-                wireGameDb(requireConfig().assignUserId("host"), () => wireHostSync(transport));
-            })
-            .catch((err: unknown) => reportError("Connection failed", err));
-    };
-
-    const startJoin = () => {
-        log(`startJoin`);
-        db.transactions.startJoinSignaling();
-    };
-
-    const submitAnswer = () => {
-        const code = db.resources.hostAnswerInput.trim();
-        if (code && submitHostAnswer) {
-            log(`submitting answer (${code.length} chars)`);
-            submitHostAnswer(code);
-        }
-    };
-
-    const generateAnswer = () => {
-        const offerCodeFromHost = db.resources.joinerOfferInput.trim();
-        if (joinStarted || !offerCodeFromHost) return;
-        joinStarted = true;
-        log(`generating answer for offer (${offerCodeFromHost.length} chars)`);
-        db.transactions.setBanner({ text: "Generating answer — please wait…" });
-
-        const { answerCode, connected } = startJoinerSignaling(offerCodeFromHost);
-
-        answerCode
-            .then((code) => {
-                log(`answer code generated (${code.length} chars)`);
-                db.transactions.setAnswerCode({ code });
-            })
-            .catch((err: unknown) => reportError("Error creating answer", err));
-
-        connected
-            .then(({ transport, pc: newPc, signalChannel }) => {
-                log(`joiner data channels open`);
-                wirePeerConnection(newPc, signalChannel, "joiner");
-                wireGameDb(requireConfig().assignUserId("joiner"), () => wireJoinerSync(transport));
-            })
-            .catch((err: unknown) => reportError("Connection failed", err));
-    };
-
-    const reconnect = () => {
-        const role = db.resources.role;
-        if (!gameDb || !role) return;
-        if (db.resources.connection === "reconnecting") return;
-        log(`reconnect (role=${role})`);
-        db.transactions.setConnection({ state: "reconnecting" });
-        joinStarted = false;
-        // Tear down the dead PC + renegotiator before building a new one.
-        renegotiator?.dispose();
-        renegotiator = undefined;
-        pc?.close();
-        pc = undefined;
-
-        if (role === "host") {
-            const { offerCode, submitAnswer: sa, connected } = startHostSignaling();
-            submitHostAnswer = sa;
-            offerCode
-                .then((code) => db.transactions.setOfferCode({ code }))
-                .catch((err: unknown) => reportError("Error generating offer", err));
-            connected
-                .then(({ transport, pc: newPc, signalChannel }) => {
-                    log(`host data channels open (reconnect)`);
-                    wirePeerConnection(newPc, signalChannel, "host");
-                    wireHostSync(transport);
-                })
-                .catch((err: unknown) => reportError("Reconnection failed", err));
-        } else {
-            // For joiner, re-enter the signaling phase so the UI shows the textarea.
-            db.transactions.startJoinSignaling();
-            db.transactions.setConnection({ state: "reconnecting" });
-        }
-    };
-
-    const dispose = () => {
-        log(`dispose`);
-        renegotiator?.dispose();
-        renegotiator = undefined;
-        pc?.close();
-        pc = undefined;
-        syncService?.dispose();
-        syncServer?.dispose();
-    };
-
-    const configure = (c: NegotiationConfig) => { config = c; };
-
-    return { configure, startHost, startJoin, submitAnswer, generateAnswer, reconnect, dispose };
-};
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-connection.ts b/packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-connection.ts
deleted file mode 100644
index eae9b507..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-connection.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { ConnectionState } from "../../types/connection-state.js";
-import type { CoreDatabase } from "../core-database.js";
-
-export const setConnection = (
-  t: CoreDatabase.Store,
-  { state, sessionId }: { state: ConnectionState; sessionId?: string | null },
-) => {
-  t.resources.connection = state;
-  if (sessionId !== undefined) t.resources.sessionId = sessionId;
-};
diff --git a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-game-db.ts b/packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-game-db.ts
deleted file mode 100644
index 9e938ab3..00000000
--- a/packages/data-p2p-tictactoe/src/negotiation/database/transactions/set-game-db.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { CoreDatabase } from "../core-database.js";
-
-/**
- * Store the constructed game DB and transition to the game phase. Called by
- * the negotiation service after sync transports are wired and the WebRTC
- * channel is open.
- */
-export const setGameDb = (t: CoreDatabase.Store, { gameDb }: { gameDb: unknown }) => {
-  t.resources.gameDb = gameDb;
-  t.resources.phase = "game";
-  t.resources.connection = "connected";
-};
diff --git a/packages/data-p2p-tictactoe/src/presence/data/resources/cursors.ts b/packages/data-p2p-tictactoe/src/presence/data/resources/cursors.ts
deleted file mode 100644
index 4b4fdc87..00000000
--- a/packages/data-p2p-tictactoe/src/presence/data/resources/cursors.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { Vec2 } from "@adobe/data/math";
-import type { PlayerMark } from "data-lit-tictactoe";
-
-/**
- * Each connected peer's cursor position in normalised `[0..1, 0..1]`
- * coordinates relative to the overlay element, keyed by `PlayerMark`. Entries
- * appear when a peer first reports a position and may be absent for peers that
- * have never moved their cursor.
- */
-export const cursors = { default: {} as Partial<Record<PlayerMark, Vec2>> };
diff --git a/packages/data-p2p-tictactoe/src/presence/database/presence-database.ts b/packages/data-p2p-tictactoe/src/presence/database/presence-database.ts
deleted file mode 100644
index 7a5e6ff6..00000000
--- a/packages/data-p2p-tictactoe/src/presence/database/presence-database.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import { Database } from "@adobe/data/ecs";
-import { TransactionDatabase } from "./transaction-database.js";
-import * as actions from "./actions/index.js";
-
-/**
- * Optional presence plugin. Combine with the base game plugin at the sample
- * level:
- *
- * ```ts
- * const gamePlugin = Database.Plugin.combine(TictactoeGameDatabase.plugin, PresenceDatabase.plugin);
- * ```
- *
- * Presence lives in `data-p2p-tictactoe`, not in `data-lit-tictactoe`, because
- * it is a P2P-specific concern — standalone / AI play has no remote cursors.
- */
-const presenceDatabasePlugin = Database.Plugin.create({
-  extends: TransactionDatabase.plugin,
-  actions,
-});
-
-export type PresenceDatabase = Database.Plugin.ToDatabase<
-  typeof presenceDatabasePlugin
->;
-
-export namespace PresenceDatabase {
-  export const plugin = presenceDatabasePlugin;
-  export type Store = Database.Plugin.ToStore<typeof presenceDatabasePlugin>;
-}
diff --git a/packages/data-p2p-tictactoe/src/presence/database/transactions/move-presence.ts b/packages/data-p2p-tictactoe/src/presence/database/transactions/move-presence.ts
deleted file mode 100644
index 99332147..00000000
--- a/packages/data-p2p-tictactoe/src/presence/database/transactions/move-presence.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-import type { Vec2 } from "@adobe/data/math";
-import { PlayerMark } from "data-lit-tictactoe";
-import type { CoreDatabase } from "../core-database.js";
-
-/**
- * Update the calling peer's cursor position. Driven as a never-ending
- * async-generator transaction by the `trackPresence` action — each yield
- * applies as a transient (never committed) envelope. Reads `t.userId` as a
- * `PlayerMark` so each peer only writes its own cursor entry; foreign or unset
- * `userId`s are ignored.
- */
-export const movePresence = (
-  t: CoreDatabase.Store,
-  args: { x: number; y: number },
-) => {
-  if (!PlayerMark.is(t.userId)) return;
-  t.resources.cursors = {
-    ...t.resources.cursors,
-    [t.userId]: [args.x, args.y] as Vec2,
-  };
-};
diff --git a/packages/data-p2p-tictactoe/src/types/phase/phase.ts b/packages/data-p2p-tictactoe/src/types/phase/phase.ts
deleted file mode 100644
index e98e2c9f..00000000
--- a/packages/data-p2p-tictactoe/src/types/phase/phase.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-/**
- * Local-only screen the peer is currently on. Stored as a nonPersistent
- * resource so it never reaches the wire — only the local UI reads it.
- */
-export type Phase = "idle" | "host-signaling" | "join-signaling" | "game";
diff --git a/packages/data-persistence/package.json b/packages/data-persistence/package.json
index 112f8de4..013161ed 100644
--- a/packages/data-persistence/package.json
+++ b/packages/data-persistence/package.json
@@ -1,6 +1,6 @@
 {
     "name": "@adobe/data-persistence",
-    "version": "0.9.92",
+    "version": "0.9.93",
     "description": "Worker-based incremental persistence layer for @adobe/data ECS over OPFS (browser) and node:fs (server).",
     "type": "module",
     "sideEffects": false,
diff --git a/packages/data-react-hello/package.json b/packages/data-react-hello/package.json
index 867cae7f..c6ed3fdf 100644
--- a/packages/data-react-hello/package.json
+++ b/packages/data-react-hello/package.json
@@ -1,6 +1,6 @@
 {
   "name": "data-react-hello",
-  "version": "0.9.92",
+  "version": "0.9.93",
   "description": "Hello World sample - click counter using @adobe/data-react",
   "type": "module",
   "private": true,
diff --git a/packages/data-react-pixie/package.json b/packages/data-react-pixie/package.json
index d799c8ec..3859c042 100644
--- a/packages/data-react-pixie/package.json
+++ b/packages/data-react-pixie/package.json
@@ -1,13 +1,14 @@
 {
   "name": "data-react-pixie",
-  "version": "0.9.92",
+  "version": "0.9.93",
   "description": "PixiJS React sample - ECS sprites (bunny, fox) with @adobe/data-react",
   "type": "module",
   "private": true,
   "scripts": {
     "build": "vite build",
     "dev": "vite",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest --run --passWithNoTests"
   },
   "dependencies": {
     "@adobe/data": "workspace:*",
@@ -21,8 +22,10 @@
     "@types/react": "^19",
     "@types/react-dom": "^19",
     "@vitejs/plugin-react": "^4.3.0",
+    "jsdom": "^24.1.0",
     "typescript": "^5.8.3",
     "vite": "^5.1.1",
-    "vite-plugin-checker": "^0.12.0"
+    "vite-plugin-checker": "^0.12.0",
+    "vitest": "^1.6.0"
   }
 }
diff --git a/packages/data-react-pixie/src/components/filter-selector/filter-selector.tsx b/packages/data-react-pixie/src/components/filter-selector/filter-selector.tsx
deleted file mode 100644
index 229d6cd0..00000000
--- a/packages/data-react-pixie/src/components/filter-selector/filter-selector.tsx
+++ /dev/null
@@ -1,22 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import { useObservableValues } from "@adobe/data-react";
-import { usePixieDatabase } from "../../state/use-pixie-database";
-import * as presentation from "./filter-selector-presentation";
-
-export function FilterSelector() {
-  const db = usePixieDatabase();
-  const values = useObservableValues(
-    () => ({
-      filterType: db.observe.resources.filterType,
-    }),
-    [],
-  );
-
-  const currentFilter = values?.filterType ?? "none";
-
-  return presentation.render({
-    currentFilter,
-    setFilterType: (filterType) => db.transactions.setFilterType({ filterType }),
-  });
-}
diff --git a/packages/data-react-pixie/src/components/sprite/sprite.tsx b/packages/data-react-pixie/src/components/sprite/sprite.tsx
deleted file mode 100644
index 688b9c50..00000000
--- a/packages/data-react-pixie/src/components/sprite/sprite.tsx
+++ /dev/null
@@ -1,37 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import type { Entity } from "@adobe/data/ecs";
-import { useObservableValues } from "@adobe/data-react";
-import { usePixieDatabase } from "../../state/use-pixie-database";
-import { SpriteType } from "../../types/sprite-type/sprite-type";
-import { useSpriteTexture } from "./use-sprite-texture";
-import * as presentation from "./sprite-presentation";
-
-export function Sprite({ entity }: { entity: Entity }) {
-  const db = usePixieDatabase();
-  const values = useObservableValues(
-    () => ({
-      sprite: db.observe.entity(entity, db.archetypes.Sprite),
-    }),
-    [entity],
-  );
-
-  const spriteType = values?.sprite?.sprite ?? "bunny";
-  const texture = useSpriteTexture(SpriteType.image[spriteType]);
-
-  if (!values?.sprite || !texture) return null;
-
-  const { sprite } = values;
-  const scale = sprite.active ? 1.5 : sprite.hovered ? 1.25 : 1;
-
-  return presentation.render({
-    texture,
-    x: sprite.position[0],
-    y: sprite.position[1],
-    rotation: sprite.rotation,
-    scale,
-    toggleSpriteActive: () => db.transactions.toggleSpriteActive({ entity }),
-    setSpriteHoveredTrue: () => db.transactions.setSpriteHovered({ entity, hovered: true }),
-    setSpriteHoveredFalse: () => db.transactions.setSpriteHovered({ entity, hovered: false }),
-  });
-}
diff --git a/packages/data-react-pixie/src/features/main/data/filter-kind/filter-kind.ts b/packages/data-react-pixie/src/features/main/data/filter-kind/filter-kind.ts
new file mode 100644
index 00000000..20dc8f0f
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/filter-kind/filter-kind.ts
@@ -0,0 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+// The colour filter applied to the whole scene. A pure, serializable value; the
+// human-readable label for each kind is presentation and lives in `ui/`.
+export type FilterKind = "none" | "sepia" | "blur" | "vintage" | "night";
+export * as FilterKind from "./public.js";
diff --git a/packages/data-react-pixie/src/features/main/data/filter-kind/public.ts b/packages/data-react-pixie/src/features/main/data/filter-kind/public.ts
new file mode 100644
index 00000000..363fd32b
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/filter-kind/public.ts
@@ -0,0 +1,2 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { schema } from "./schema.js";
diff --git a/packages/data-react-pixie/src/features/main/data/filter-kind/schema.ts b/packages/data-react-pixie/src/features/main/data/filter-kind/schema.ts
new file mode 100644
index 00000000..dda82502
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/filter-kind/schema.ts
@@ -0,0 +1,14 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Schema } from "@adobe/data/schema";
+import type { Assert, Equal } from "@adobe/data/types";
+import type { FilterKind } from "./filter-kind.js";
+
+// Carries a `default` so it binds directly as the `filter` resource schema.
+export const schema = {
+  type: "string",
+  enum: ["none", "sepia", "blur", "vintage", "night"],
+  default: "none",
+} as const satisfies Schema;
+
+// Compile-time pin: fails to build if schema and type diverge.
+type _Pin = Assert<Equal<Schema.ToType<typeof schema>, FilterKind>>;
diff --git a/packages/data-react-pixie/src/features/main/data/sprite-kind/public.ts b/packages/data-react-pixie/src/features/main/data/sprite-kind/public.ts
new file mode 100644
index 00000000..363fd32b
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/sprite-kind/public.ts
@@ -0,0 +1,2 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { schema } from "./schema.js";
diff --git a/packages/data-react-pixie/src/features/main/data/sprite-kind/schema.ts b/packages/data-react-pixie/src/features/main/data/sprite-kind/schema.ts
new file mode 100644
index 00000000..9e9ce5b1
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/sprite-kind/schema.ts
@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Schema } from "@adobe/data/schema";
+import type { Assert, Equal } from "@adobe/data/types";
+import type { SpriteKind } from "./sprite-kind.js";
+
+export const schema = { type: "string", enum: ["bunny", "fox"] } as const satisfies Schema;
+
+// Compile-time pin: fails to build if schema and type diverge.
+type _Pin = Assert<Equal<Schema.ToType<typeof schema>, SpriteKind>>;
diff --git a/packages/data-react-pixie/src/features/main/data/sprite-kind/sprite-kind.ts b/packages/data-react-pixie/src/features/main/data/sprite-kind/sprite-kind.ts
new file mode 100644
index 00000000..139c3cb1
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/sprite-kind/sprite-kind.ts
@@ -0,0 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+// Which sprite a rendered entity is. A pure, serializable value; the texture
+// URL each kind maps to is a presentation concern and lives in `ui/`.
+export type SpriteKind = "bunny" | "fox";
+export * as SpriteKind from "./public.js";
diff --git a/packages/data-p2p-tictactoe/src/presence/database/actions/index.ts b/packages/data-react-pixie/src/features/main/data/sprite/public.ts
similarity index 60%
rename from packages/data-p2p-tictactoe/src/presence/database/actions/index.ts
rename to packages/data-react-pixie/src/features/main/data/sprite/public.ts
index d6092a3b..12e95997 100644
--- a/packages/data-p2p-tictactoe/src/presence/database/actions/index.ts
+++ b/packages/data-react-pixie/src/features/main/data/sprite/public.ts
@@ -1,2 +1,2 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-export * from "./track-presence.js";
+export {};
diff --git a/packages/data-react-pixie/src/features/main/data/sprite/sprite.ts b/packages/data-react-pixie/src/features/main/data/sprite/sprite.ts
new file mode 100644
index 00000000..3e315bc5
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/sprite/sprite.ts
@@ -0,0 +1,16 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Vec2, F32 } from "@adobe/data/math";
+import type { SpriteKind } from "../sprite-kind/sprite-kind.js";
+
+// One sprite entity in the logical application State. `id` is the sprite's
+// domain identity; the ECS materialises each sprite as an entity whose id is
+// drawn from its own id-space (conformance compares ignoring ids).
+export type Sprite = {
+  readonly id: number;
+  readonly position: Vec2;
+  readonly rotation: F32;
+  readonly kind: SpriteKind;
+  readonly hovered: boolean;
+  readonly active: boolean;
+};
+export * as Sprite from "./public.js";
diff --git a/packages/data-react-pixie/src/features/main/data/state/conformance-case.ts b/packages/data-react-pixie/src/features/main/data/state/conformance-case.ts
new file mode 100644
index 00000000..6d387ed4
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/state/conformance-case.ts
@@ -0,0 +1,18 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Conformance as ConformanceApi } from "@adobe/data/testing";
+import type { State } from "./state.js";
+
+// The conformance case types for this feature — the shared `@adobe/data/testing`
+// machinery with `State` bound once, so a transform authors `Conformance<typeof fn>`
+// and a derivation `Derivation<typeof fn>` (args/input/value read from the
+// function's own signature). This tiny file is the only per-feature conformance
+// type declaration; everything else lives in `@adobe/data/testing`.
+export type Conformance<F extends (...args: never[]) => unknown> =
+  ConformanceApi.Cases<State, F>;
+export type Derivation<F extends (...args: never[]) => unknown> =
+  ConformanceApi.DerivationCases<F>;
+
+// The entity-reference marker for case args: `args: { id: entity(2) }` names "the
+// entity seeded for spec-id 2". The pure spec reads `2`; the ecs runner resolves
+// it to the seeded entity. Re-exported here so cases import it beside `Conformance`.
+export const entity = ConformanceApi.entity;
diff --git a/packages/data-react-pixie/src/features/main/data/state/create-sprite.ts b/packages/data-react-pixie/src/features/main/data/state/create-sprite.ts
new file mode 100644
index 00000000..7790920d
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/state/create-sprite.ts
@@ -0,0 +1,92 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Vec2 } from "@adobe/data/math";
+import type { SpriteKind } from "../sprite-kind/sprite-kind.js";
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+import { Match } from "@adobe/data/testing";
+
+const nextSpriteId = (state: Pick<State, "sprites">): number =>
+  state.sprites.reduce((max, sprite) => Math.max(max, sprite.id), 0) + 1;
+
+// Append a sprite to the scene. Returns only the field it writes (`sprites`).
+export const createSprite = (
+  state: Pick<State, "sprites">,
+  input: {
+    readonly position: Vec2;
+    readonly rotation?: number;
+    readonly kind: SpriteKind;
+  },
+): Pick<State, "sprites"> => ({
+  sprites: [
+    ...state.sprites,
+    {
+      id: nextSpriteId(state),
+      position: input.position,
+      rotation: input.rotation ?? 0,
+      kind: input.kind,
+      hovered: false,
+      active: false,
+    },
+  ],
+});
+
+// Spec-owned cases, shared with the ecs `createSprite` transaction. A sprite is
+// appended (minted id left open as `anyNumber` — the ecs assigns its own) with
+// rotation defaulting to 0 and hovered/active to false; existing sprites are
+// untouched. `before` is a delta over `State.create()`; `after` is the writes patch.
+export const cases: Conformance<typeof createSprite> = [
+  {
+    name: "appends the first sprite to an empty scene",
+    before: {},
+    args: { position: [100, 100], kind: "bunny" },
+    after: {
+      sprites: [
+        {
+          id: Match.anyNumber,
+          position: [100, 100],
+          rotation: 0,
+          kind: "bunny",
+          hovered: false,
+          active: false,
+        },
+      ],
+    },
+  },
+  {
+    name: "appends a fox with the next id and an explicit rotation",
+    before: {
+      sprites: [
+        {
+          id: 1,
+          position: [100, 100],
+          rotation: 0,
+          kind: "bunny",
+          hovered: false,
+          active: false,
+        },
+      ],
+      filter: "sepia",
+    },
+    args: { position: [300, 200], rotation: 1, kind: "fox" },
+    after: {
+      sprites: [
+        {
+          id: Match.anyNumber,
+          position: [100, 100],
+          rotation: 0,
+          kind: "bunny",
+          hovered: false,
+          active: false,
+        },
+        {
+          id: Match.anyNumber,
+          position: [300, 200],
+          rotation: 1,
+          kind: "fox",
+          hovered: false,
+          active: false,
+        },
+      ],
+    },
+  },
+];
diff --git a/packages/data-react-pixie/src/features/main/data/state/create.ts b/packages/data-react-pixie/src/features/main/data/state/create.ts
new file mode 100644
index 00000000..bf661de4
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/state/create.ts
@@ -0,0 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+
+// The default scene state: no sprites, no filter. It is the baseline the
+// conformance cases author their `before` as deltas over, and the state a fresh
+// scene starts in.
+export const create = (): State => ({ sprites: [], filter: "none" });
diff --git a/packages/data-react-pixie/src/features/main/data/state/public.ts b/packages/data-react-pixie/src/features/main/data/state/public.ts
new file mode 100644
index 00000000..b53ae5d7
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/state/public.ts
@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { create } from "./create.js";
+export { samples } from "./samples.js";
+export { createSprite } from "./create-sprite.js";
+export { setSpriteHovered } from "./set-sprite-hovered.js";
+export { setSpriteActive } from "./set-sprite-active.js";
+export { toggleSpriteActive } from "./toggle-sprite-active.js";
+export { tick } from "./tick.js";
+export { setFilter } from "./set-filter.js";
diff --git a/packages/data-react-pixie/src/features/main/data/state/samples.ts b/packages/data-react-pixie/src/features/main/data/state/samples.ts
new file mode 100644
index 00000000..596c968c
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/state/samples.ts
@@ -0,0 +1,64 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Match } from "@adobe/data/testing";
+import type { State } from "./state.js";
+
+// Representative full states for the projection round-trip (toState ∘ fromState ≡
+// identity). Sprite ids are authored as `anyNumber`: the ecs reassigns ids from
+// its own id-space, so the round-trip leaves them open. Varied sprite collections
+// + scene filters exercise the whole ecs↔State map.
+export const samples: readonly State[] = [
+  {
+    sprites: [
+      {
+        id: Match.anyNumber,
+        position: [100, 100],
+        rotation: 0,
+        kind: "bunny",
+        hovered: false,
+        active: false,
+      },
+      {
+        id: Match.anyNumber,
+        position: [300, 200],
+        rotation: 1,
+        kind: "fox",
+        hovered: true,
+        active: false,
+      },
+      {
+        id: Match.anyNumber,
+        position: [150, 250],
+        rotation: 0.5,
+        kind: "bunny",
+        hovered: false,
+        active: true,
+      },
+    ],
+    filter: "sepia",
+  },
+  {
+    sprites: [],
+    filter: "none",
+  },
+  {
+    sprites: [
+      {
+        id: Match.anyNumber,
+        position: [10, 10],
+        rotation: 0,
+        kind: "fox",
+        hovered: false,
+        active: false,
+      },
+      {
+        id: Match.anyNumber,
+        position: [20, 20],
+        rotation: 0,
+        kind: "fox",
+        hovered: false,
+        active: false,
+      },
+    ],
+    filter: "blur",
+  },
+];
diff --git a/packages/data-react-pixie/src/features/main/data/state/set-filter.ts b/packages/data-react-pixie/src/features/main/data/state/set-filter.ts
new file mode 100644
index 00000000..122db4a8
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/state/set-filter.ts
@@ -0,0 +1,26 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { FilterKind } from "../filter-kind/filter-kind.js";
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+
+// Replace the scene-wide filter. Writes only `filter`; sprites are untouched.
+export const setFilter = (
+  _state: Pick<State, "filter">,
+  input: { readonly filter: FilterKind },
+): Pick<State, "filter"> => ({ filter: input.filter });
+
+// Spec-owned cases, shared with the ecs `setFilter` transaction.
+export const cases: Conformance<typeof setFilter> = [
+  {
+    name: "sets the filter from none to sepia",
+    before: {},
+    args: { filter: "sepia" },
+    after: { filter: "sepia" },
+  },
+  {
+    name: "replaces an existing filter",
+    before: { filter: "blur" },
+    args: { filter: "night" },
+    after: { filter: "night" },
+  },
+];
diff --git a/packages/data-react-pixie/src/features/main/data/state/set-sprite-active.ts b/packages/data-react-pixie/src/features/main/data/state/set-sprite-active.ts
new file mode 100644
index 00000000..7d4547b6
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/state/set-sprite-active.ts
@@ -0,0 +1,49 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Sprite } from "../sprite/sprite.js";
+import type { State } from "./state.js";
+import { entity, type Conformance } from "./conformance-case.js";
+import { Match } from "@adobe/data/testing";
+
+// Set the addressed sprite's `active` flag. Writes only `sprites`.
+export const setSpriteActive = (
+  state: Pick<State, "sprites">,
+  input: { readonly id: number; readonly active: boolean },
+): Pick<State, "sprites"> => ({
+  sprites: state.sprites.map((sprite) =>
+    sprite.id === input.id ? { ...sprite, active: input.active } : sprite,
+  ),
+});
+
+const bunny: Sprite = {
+  id: 1, position: [100, 100], rotation: 0, kind: "bunny", hovered: false, active: false,
+};
+const fox: Sprite = {
+  id: 2, position: [300, 200], rotation: 1, kind: "fox", hovered: false, active: false,
+};
+
+// Spec-owned cases, shared with the ecs `setSpriteActive` transaction. `before`
+// ids address the sprite (`entity(2)`); `after` ids are left open (`anyNumber`).
+export const cases: Conformance<typeof setSpriteActive> = [
+  {
+    name: "sets active true on the addressed sprite only",
+    before: { sprites: [bunny, fox] },
+    args: { id: entity(2), active: true },
+    after: {
+      sprites: [
+        { ...bunny, id: Match.anyNumber },
+        { ...fox, id: Match.anyNumber, active: true },
+      ],
+    },
+  },
+  {
+    name: "is a no-op for an unknown id",
+    before: { sprites: [bunny, fox] },
+    args: { id: entity(99), active: true },
+    after: {
+      sprites: [
+        { ...bunny, id: Match.anyNumber },
+        { ...fox, id: Match.anyNumber },
+      ],
+    },
+  },
+];
diff --git a/packages/data-react-pixie/src/features/main/data/state/set-sprite-hovered.ts b/packages/data-react-pixie/src/features/main/data/state/set-sprite-hovered.ts
new file mode 100644
index 00000000..2bebae98
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/state/set-sprite-hovered.ts
@@ -0,0 +1,49 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Sprite } from "../sprite/sprite.js";
+import type { State } from "./state.js";
+import { entity, type Conformance } from "./conformance-case.js";
+import { Match } from "@adobe/data/testing";
+
+// Set the addressed sprite's `hovered` flag. Writes only `sprites`.
+export const setSpriteHovered = (
+  state: Pick<State, "sprites">,
+  input: { readonly id: number; readonly hovered: boolean },
+): Pick<State, "sprites"> => ({
+  sprites: state.sprites.map((sprite) =>
+    sprite.id === input.id ? { ...sprite, hovered: input.hovered } : sprite,
+  ),
+});
+
+const bunny: Sprite = {
+  id: 1, position: [100, 100], rotation: 0, kind: "bunny", hovered: false, active: false,
+};
+const fox: Sprite = {
+  id: 2, position: [300, 200], rotation: 1, kind: "fox", hovered: false, active: false,
+};
+
+// Spec-owned cases, shared with the ecs `setSpriteHovered` transaction. `before`
+// ids address the sprite (`entity(1)`); `after` ids are left open (`anyNumber`).
+export const cases: Conformance<typeof setSpriteHovered> = [
+  {
+    name: "sets hovered true on the addressed sprite only",
+    before: { sprites: [bunny, fox] },
+    args: { id: entity(1), hovered: true },
+    after: {
+      sprites: [
+        { ...bunny, id: Match.anyNumber, hovered: true },
+        { ...fox, id: Match.anyNumber },
+      ],
+    },
+  },
+  {
+    name: "is a no-op for an unknown id",
+    before: { sprites: [bunny, fox] },
+    args: { id: entity(99), hovered: true },
+    after: {
+      sprites: [
+        { ...bunny, id: Match.anyNumber },
+        { ...fox, id: Match.anyNumber },
+      ],
+    },
+  },
+];
diff --git a/packages/data-react-pixie/src/features/main/data/state/spec.test.ts b/packages/data-react-pixie/src/features/main/data/state/spec.test.ts
new file mode 100644
index 00000000..9d5c4074
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/state/spec.test.ts
@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Conformance } from "@adobe/data/testing";
+import { State } from "./state.js";
+import { transitions } from "./transitions.js";
+
+// The single pure-spec test for every transform AND derivation in this folder.
+// `runSpec` auto-discovers each module in `transitions` that exports `cases`,
+// requires it to export exactly its function plus `cases`, and dispatches on case
+// shape. Each case's `before`/`input` is a delta over `State.create()`.
+Conformance.runSpec({ state: State, transitions });
diff --git a/packages/data-react-pixie/src/features/main/data/state/state.ts b/packages/data-react-pixie/src/features/main/data/state/state.ts
new file mode 100644
index 00000000..7a324d5b
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/state/state.ts
@@ -0,0 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Sprite } from "../sprite/sprite.js";
+import type { FilterKind } from "../filter-kind/filter-kind.js";
+
+// The full application state as one immutable object — the specification the
+// ECS implementation is verified against. `sprites` is an unordered collection;
+// `filter` is the scene-wide colour filter.
+export type State = {
+  readonly sprites: readonly Sprite[];
+  readonly filter: FilterKind;
+};
+export * as State from "./public.js";
diff --git a/packages/data-react-pixie/src/features/main/data/state/tick.ts b/packages/data-react-pixie/src/features/main/data/state/tick.ts
new file mode 100644
index 00000000..2c283c44
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/state/tick.ts
@@ -0,0 +1,47 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Sprite } from "../sprite/sprite.js";
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+import { Match } from "@adobe/data/testing";
+
+// Advance one animation frame: every sprite rotates by `delta * 0.1` radians.
+// `delta` is the frame time step, supplied by the caller (the render loop).
+// Writes only `sprites`.
+export const tick = (
+  state: Pick<State, "sprites">,
+  input: { readonly delta: number },
+): Pick<State, "sprites"> => ({
+  sprites: state.sprites.map((sprite) => ({
+    ...sprite,
+    rotation: sprite.rotation + input.delta * 0.1,
+  })),
+});
+
+const bunny: Sprite = {
+  id: 1, position: [100, 100], rotation: 0, kind: "bunny", hovered: false, active: false,
+};
+const fox: Sprite = {
+  id: 2, position: [300, 200], rotation: 1, kind: "fox", hovered: false, active: false,
+};
+
+// Spec-owned cases, shared with the ecs `tick` transaction. Every sprite's
+// rotation advances by delta * 0.1; ids are left open (`anyNumber`).
+export const cases: Conformance<typeof tick> = [
+  {
+    name: "advances every sprite's rotation by delta * 0.1",
+    before: { sprites: [bunny, fox] },
+    args: { delta: 10 },
+    after: {
+      sprites: [
+        { ...bunny, id: Match.anyNumber, rotation: 1 },
+        { ...fox, id: Match.anyNumber, rotation: 2 },
+      ],
+    },
+  },
+  {
+    name: "is a no-op on an empty scene",
+    before: { sprites: [], filter: "blur" },
+    args: { delta: 5 },
+    after: { sprites: [] },
+  },
+];
diff --git a/packages/data-react-pixie/src/features/main/data/state/toggle-sprite-active.ts b/packages/data-react-pixie/src/features/main/data/state/toggle-sprite-active.ts
new file mode 100644
index 00000000..b2d6b609
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/state/toggle-sprite-active.ts
@@ -0,0 +1,60 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Sprite } from "../sprite/sprite.js";
+import type { State } from "./state.js";
+import { entity, type Conformance } from "./conformance-case.js";
+import { Match } from "@adobe/data/testing";
+
+// Flip the addressed sprite's `active` flag. Writes only `sprites`.
+export const toggleSpriteActive = (
+  state: Pick<State, "sprites">,
+  input: { readonly id: number },
+): Pick<State, "sprites"> => ({
+  sprites: state.sprites.map((sprite) =>
+    sprite.id === input.id ? { ...sprite, active: !sprite.active } : sprite,
+  ),
+});
+
+const bunny: Sprite = {
+  id: 1, position: [100, 100], rotation: 0, kind: "bunny", hovered: false, active: false,
+};
+const activeFox: Sprite = {
+  id: 2, position: [300, 200], rotation: 1, kind: "fox", hovered: false, active: true,
+};
+
+// Spec-owned cases, shared with the ecs `toggleSpriteActive` transaction. `before`
+// ids address the sprite; `after` ids are left open (`anyNumber`).
+export const cases: Conformance<typeof toggleSpriteActive> = [
+  {
+    name: "toggles a sprite from inactive to active",
+    before: { sprites: [bunny, activeFox] },
+    args: { id: entity(1) },
+    after: {
+      sprites: [
+        { ...bunny, id: Match.anyNumber, active: true },
+        { ...activeFox, id: Match.anyNumber },
+      ],
+    },
+  },
+  {
+    name: "toggles a sprite from active to inactive",
+    before: { sprites: [bunny, activeFox] },
+    args: { id: entity(2) },
+    after: {
+      sprites: [
+        { ...bunny, id: Match.anyNumber },
+        { ...activeFox, id: Match.anyNumber, active: false },
+      ],
+    },
+  },
+  {
+    name: "is a no-op for an unknown id",
+    before: { sprites: [bunny, activeFox] },
+    args: { id: entity(99) },
+    after: {
+      sprites: [
+        { ...bunny, id: Match.anyNumber },
+        { ...activeFox, id: Match.anyNumber },
+      ],
+    },
+  },
+];
diff --git a/packages/data-react-pixie/src/features/main/data/state/transitions.ts b/packages/data-react-pixie/src/features/main/data/state/transitions.ts
new file mode 100644
index 00000000..1092fd91
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/data/state/transitions.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+/// <reference types="vite/client" />
+
+// The transform/derivation modules for conformance discovery — the `{ fn, cases }`
+// source shared by `spec.test.ts` (pure) and the ecs `conformance.test.ts`. The
+// glob must be authored where Vite can statically see it (an eager glob, excluding
+// tests and this file itself); consumers import the resolved map.
+export const transitions = import.meta.glob<Record<string, unknown>>(
+  ["./*.ts", "!./*.test.ts", "!./*.type-test.ts", "!./transitions.ts"],
+  { eager: true },
+);
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/action-database/action-database.ts b/packages/data-react-pixie/src/features/main/services/main-service/action-database/action-database.ts
new file mode 100644
index 00000000..ce5e0f99
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/action-database/action-database.ts
@@ -0,0 +1,19 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { TransactionDatabase } from "../transaction-database/transaction-database.js";
+import * as actions from "./actions/index.js";
+
+// The action layer: the async, app-facing realizations of the state transitions.
+// This feature injects no capability services, so actions extend the transaction
+// layer directly (the lowest layer exposing `db.transactions`).
+const actionDatabasePlugin = Database.Plugin.create({
+  extends: TransactionDatabase.plugin,
+  actions,
+});
+
+export type ActionDatabase = Database.Plugin.ToDatabase<typeof actionDatabasePlugin>;
+
+export namespace ActionDatabase {
+  export const plugin = actionDatabasePlugin;
+  export type Store = Database.Plugin.ToStore<typeof actionDatabasePlugin>;
+}
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/create-sprite.ts b/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/create-sprite.ts
new file mode 100644
index 00000000..582fafbe
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/create-sprite.ts
@@ -0,0 +1,13 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Vec2 } from "@adobe/data/math";
+import type { SpriteKind } from "../../../../data/sprite-kind/sprite-kind.js";
+import type { TransactionDatabase } from "../../transaction-database/transaction-database.js";
+
+// The app-facing realization of `State.createSprite`. This transition injects no
+// services, so the action just commits through the same-named transaction.
+export const createSprite = (
+  db: TransactionDatabase,
+  input: { readonly position: Vec2; readonly rotation?: number; readonly kind: SpriteKind },
+) => {
+  db.transactions.createSprite(input);
+};
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/index.ts b/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/index.ts
new file mode 100644
index 00000000..aef80ba3
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/index.ts
@@ -0,0 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export * from "./create-sprite.js";
+export * from "./set-filter.js";
+export * from "./set-sprite-active.js";
+export * from "./set-sprite-hovered.js";
+export * from "./toggle-sprite-active.js";
+export * from "./tick.js";
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/set-filter.ts b/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/set-filter.ts
new file mode 100644
index 00000000..e1133063
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/set-filter.ts
@@ -0,0 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { FilterKind } from "../../../../data/filter-kind/filter-kind.js";
+import type { TransactionDatabase } from "../../transaction-database/transaction-database.js";
+
+// The app-facing realization of `State.setFilter`.
+export const setFilter = (db: TransactionDatabase, input: { readonly filter: FilterKind }) => {
+  db.transactions.setFilter(input);
+};
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/set-sprite-active.ts b/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/set-sprite-active.ts
new file mode 100644
index 00000000..64339b29
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/set-sprite-active.ts
@@ -0,0 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Entity } from "@adobe/data/ecs";
+import type { TransactionDatabase } from "../../transaction-database/transaction-database.js";
+
+// The app-facing realization of `State.setSpriteActive`. The ui supplies the
+// entity directly; the action commits through the same-named transaction.
+export const setSpriteActive = (
+  db: TransactionDatabase,
+  input: { readonly id: Entity; readonly active: boolean },
+) => {
+  db.transactions.setSpriteActive(input);
+};
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/set-sprite-hovered.ts b/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/set-sprite-hovered.ts
new file mode 100644
index 00000000..01c206ed
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/set-sprite-hovered.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Entity } from "@adobe/data/ecs";
+import type { TransactionDatabase } from "../../transaction-database/transaction-database.js";
+
+// The app-facing realization of `State.setSpriteHovered`.
+export const setSpriteHovered = (
+  db: TransactionDatabase,
+  input: { readonly id: Entity; readonly hovered: boolean },
+) => {
+  db.transactions.setSpriteHovered(input);
+};
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/tick.ts b/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/tick.ts
new file mode 100644
index 00000000..28a83a9e
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/tick.ts
@@ -0,0 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { TransactionDatabase } from "../../transaction-database/transaction-database.js";
+
+// The app-facing realization of `State.tick`, driven per-frame by the render loop.
+export const tick = (db: TransactionDatabase, input: { readonly delta: number }) => {
+  db.transactions.tick(input);
+};
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/toggle-sprite-active.ts b/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/toggle-sprite-active.ts
new file mode 100644
index 00000000..a12f6786
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/action-database/actions/toggle-sprite-active.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Entity } from "@adobe/data/ecs";
+import type { TransactionDatabase } from "../../transaction-database/transaction-database.js";
+
+// The app-facing realization of `State.toggleSpriteActive`.
+export const toggleSpriteActive = (
+  db: TransactionDatabase,
+  { id }: { readonly id: Entity },
+) => {
+  db.transactions.toggleSpriteActive({ id });
+};
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/conformance/conformance.test.ts b/packages/data-react-pixie/src/features/main/services/main-service/conformance/conformance.test.ts
new file mode 100644
index 00000000..2e7d551d
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/conformance/conformance.test.ts
@@ -0,0 +1,19 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Conformance } from "@adobe/data/testing";
+import { State } from "../../../data/state/state.js";
+import { transitions } from "../../../data/state/transitions.js";
+import { MainService } from "../main-service.js";
+import { projection } from "./projection.js";
+
+// The whole ecs conformance for this feature in one call: `runFeature` pulls the
+// transactions/actions off `MainService.plugin`, seeds each case's `before` (a
+// delta) over `State.create()`, resolves each entity-addressed case's `entity()`
+// markers through the `fromState` id map, and round-trips `State.samples` through
+// the projection. `transitions` (the discovered `{ fn, cases }` modules) is shared
+// with spec.test. This feature has no derivations, so no `computedPlugin`.
+Conformance.runFeature({
+  state: State,
+  transitions,
+  plugin: MainService.plugin,
+  projection,
+});
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/conformance/projection.ts b/packages/data-react-pixie/src/features/main/services/main-service/conformance/projection.ts
new file mode 100644
index 00000000..47ec85ef
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/conformance/projection.ts
@@ -0,0 +1,62 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Entity } from "@adobe/data/ecs";
+import type { Sprite } from "../../../data/sprite/sprite.js";
+import type { State } from "../../../data/state/state.js";
+import type { CoreDatabase } from "../core-database/core-database.js";
+
+// Read one entity back into its `data/` value — the per-entity projection
+// `toState` folds over, and the single place the ecs↔data mapping for a sprite
+// lives. The projected `id` is the entity id (the ecs's own id-space).
+const toData = (store: CoreDatabase.Store, entity: Entity): Sprite => {
+  const row = store.read(entity, store.archetypes.Sprite);
+  if (row === null)
+    throw new Error("conformance projection: expected a sprite entity");
+  return {
+    id: row.id,
+    position: row.position,
+    rotation: row.rotation,
+    kind: row.kind,
+    hovered: row.hovered,
+    active: row.active,
+  };
+};
+
+// The test-only ecs↔`State` projection, passed to `Conformance.runFeature`.
+// `fromState` seeds a store to a `State` (clear every sprite, set `filter`, then
+// insert the sprites) and returns the `spec id → seeded entity` map so the
+// runners resolve id-addressed operations generically; `toState` reads it back;
+// `toData` reads one entity.
+export const projection = {
+  fromState: (
+    store: CoreDatabase.Store,
+    state: State,
+  ): ReadonlyMap<number, Entity> => {
+    for (const arch of store.queryArchetypes(
+      store.archetypes.Sprite.components,
+    )) {
+      for (let row = arch.rowCount - 1; row >= 0; row--) {
+        store.delete(arch.columns.id.get(row));
+      }
+    }
+    store.resources.filter = state.filter;
+    return new Map(
+      state.sprites.map((sprite) => [
+        sprite.id,
+        store.archetypes.Sprite.insert({
+          position: sprite.position,
+          rotation: sprite.rotation,
+          kind: sprite.kind,
+          hovered: sprite.hovered,
+          active: sprite.active,
+        }),
+      ]),
+    );
+  },
+  toState: (store: CoreDatabase.Store): State => ({
+    sprites: [...store.select(store.archetypes.Sprite.components)].map(
+      (entity) => toData(store, entity),
+    ),
+    filter: store.resources.filter,
+  }),
+  toData,
+};
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/core-database/archetypes.ts b/packages/data-react-pixie/src/features/main/services/main-service/core-database/archetypes.ts
new file mode 100644
index 00000000..9b2f2260
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/core-database/archetypes.ts
@@ -0,0 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { components } from "./components.js";
+
+export const archetypes = Database.archetypes(components, {
+  Sprite: ["position", "rotation", "kind", "hovered", "active"],
+});
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/core-database/components.ts b/packages/data-react-pixie/src/features/main/services/main-service/core-database/components.ts
new file mode 100644
index 00000000..9d988dad
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/core-database/components.ts
@@ -0,0 +1,15 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { Boolean } from "@adobe/data/schema";
+import { Vec2, F32 } from "@adobe/data/math";
+import { SpriteKind } from "../../../data/sprite-kind/sprite-kind.js";
+
+export const components = Database.components({
+  document: {
+    position: Vec2.schema,
+    rotation: F32.schema,
+    kind: SpriteKind.schema,
+    hovered: Boolean.schema,
+    active: Boolean.schema,
+  },
+});
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/core-database/core-database.ts b/packages/data-react-pixie/src/features/main/services/main-service/core-database/core-database.ts
new file mode 100644
index 00000000..6f1face2
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/core-database/core-database.ts
@@ -0,0 +1,19 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { components } from "./components.js";
+import { resources } from "./resources.js";
+import { archetypes } from "./archetypes.js";
+
+// The feature's whole schema, grouped by scope in components.ts / resources.ts.
+const coreDatabasePlugin = Database.Plugin.create({
+  components,
+  resources,
+  archetypes,
+});
+
+export type CoreDatabase = Database.Plugin.ToDatabase<typeof coreDatabasePlugin>;
+
+export namespace CoreDatabase {
+  export const plugin = coreDatabasePlugin;
+  export type Store = Database.Plugin.ToStore<typeof coreDatabasePlugin>;
+}
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/core-database/resources.ts b/packages/data-react-pixie/src/features/main/services/main-service/core-database/resources.ts
new file mode 100644
index 00000000..dc030619
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/core-database/resources.ts
@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { FilterKind } from "../../../data/filter-kind/filter-kind.js";
+
+export const resources = Database.resources({
+  settings: {
+    filter: FilterKind.schema, // scene-wide view filter; the schema carries a "none" default
+  },
+});
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/main-service.ts b/packages/data-react-pixie/src/features/main/services/main-service/main-service.ts
new file mode 100644
index 00000000..4652af7f
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/main-service.ts
@@ -0,0 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+//
+// The assembled feature database — the sole entrypoint the ui binds to. Aliased
+// from the topmost layer so consumers reference `MainService` (`.plugin` /
+// `.Store`) and never name that layer; add or drop a layer → change only this line.
+export { SystemDatabase as MainService } from "./system-database/system-database.js";
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/system-database/system-database.ts b/packages/data-react-pixie/src/features/main/services/main-service/system-database/system-database.ts
new file mode 100644
index 00000000..24e2b2b2
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/system-database/system-database.ts
@@ -0,0 +1,29 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { ActionDatabase } from "../action-database/action-database.js";
+
+// Systems come last in the pipeline, atop the feature's current top layer
+// (actions). `seedSprites` is init-only: its `create` runs ONCE at database
+// construction to populate the initial scene and returns `void` (no per-frame
+// work). Per-frame rotation is driven from the ui via the `tick` transaction, so
+// this feature needs no scheduler.
+const systemDatabasePlugin = Database.Plugin.create({
+  extends: ActionDatabase.plugin,
+  systems: {
+    seedSprites: {
+      create: (db) => {
+        db.store.archetypes.Sprite.insert({ position: [100, 100], rotation: 0, kind: "bunny", hovered: false, active: false });
+        db.store.archetypes.Sprite.insert({ position: [200, 150], rotation: 0.5, kind: "bunny", hovered: false, active: false });
+        db.store.archetypes.Sprite.insert({ position: [300, 200], rotation: 1, kind: "fox", hovered: false, active: false });
+        db.store.archetypes.Sprite.insert({ position: [150, 250], rotation: 0.2, kind: "fox", hovered: false, active: false });
+      },
+    },
+  },
+});
+
+export type SystemDatabase = Database.Plugin.ToDatabase<typeof systemDatabasePlugin>;
+
+export namespace SystemDatabase {
+  export const plugin = systemDatabasePlugin;
+  export type Store = Database.Plugin.ToStore<typeof systemDatabasePlugin>;
+}
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transaction-database.ts b/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transaction-database.ts
new file mode 100644
index 00000000..02a03684
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transaction-database.ts
@@ -0,0 +1,16 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { CoreDatabase } from "../core-database/core-database.js";
+import * as transactions from "./transactions/index.js";
+
+const transactionDatabasePlugin = Database.Plugin.create({
+  extends: CoreDatabase.plugin,
+  transactions,
+});
+
+export type TransactionDatabase = Database.Plugin.ToDatabase<typeof transactionDatabasePlugin>;
+
+export namespace TransactionDatabase {
+  export const plugin = transactionDatabasePlugin;
+  export type Store = Database.Plugin.ToStore<typeof transactionDatabasePlugin>;
+}
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/create-sprite.ts b/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/create-sprite.ts
new file mode 100644
index 00000000..98621c90
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/create-sprite.ts
@@ -0,0 +1,16 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Vec2 } from "@adobe/data/math";
+import type { SpriteKind } from "../../../../data/sprite-kind/sprite-kind.js";
+import type { CoreDatabase } from "../../core-database/core-database.js";
+
+export const createSprite = (
+  t: CoreDatabase.Store,
+  input: { readonly position: Vec2; readonly rotation?: number; readonly kind: SpriteKind },
+) =>
+  t.archetypes.Sprite.insert({
+    position: input.position,
+    rotation: input.rotation ?? 0,
+    kind: input.kind,
+    hovered: false,
+    active: false,
+  });
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/index.ts b/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/index.ts
new file mode 100644
index 00000000..3ef3a57b
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/index.ts
@@ -0,0 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export * from "./create-sprite.js";
+export * from "./set-sprite-hovered.js";
+export * from "./set-sprite-active.js";
+export * from "./toggle-sprite-active.js";
+export * from "./tick.js";
+export * from "./set-filter.js";
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/set-filter.ts b/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/set-filter.ts
new file mode 100644
index 00000000..5fa1704c
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/set-filter.ts
@@ -0,0 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { FilterKind } from "../../../../data/filter-kind/filter-kind.js";
+import type { CoreDatabase } from "../../core-database/core-database.js";
+
+export const setFilter = (t: CoreDatabase.Store, args: { readonly filter: FilterKind }) => {
+  t.resources.filter = args.filter;
+};
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/set-sprite-active.ts b/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/set-sprite-active.ts
new file mode 100644
index 00000000..d47581b1
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/set-sprite-active.ts
@@ -0,0 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Entity } from "@adobe/data/ecs";
+import type { CoreDatabase } from "../../core-database/core-database.js";
+
+export const setSpriteActive = (
+  t: CoreDatabase.Store,
+  args: { readonly id: Entity; readonly active: boolean },
+) => {
+  if (t.read(args.id)) {
+    t.update(args.id, { active: args.active });
+  }
+};
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/set-sprite-hovered.ts b/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/set-sprite-hovered.ts
new file mode 100644
index 00000000..de162ff5
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/set-sprite-hovered.ts
@@ -0,0 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Entity } from "@adobe/data/ecs";
+import type { CoreDatabase } from "../../core-database/core-database.js";
+
+export const setSpriteHovered = (
+  t: CoreDatabase.Store,
+  args: { readonly id: Entity; readonly hovered: boolean },
+) => {
+  if (t.read(args.id)) {
+    t.update(args.id, { hovered: args.hovered });
+  }
+};
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/tick.ts b/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/tick.ts
new file mode 100644
index 00000000..c3099ec6
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/tick.ts
@@ -0,0 +1,13 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { CoreDatabase } from "../../core-database/core-database.js";
+
+// Advance one animation frame: every sprite rotates by `delta * 0.1`. Mirrors
+// the pure `State.tick` transform (conformed in tick.test.ts).
+export const tick = (t: CoreDatabase.Store, args: { readonly delta: number }) => {
+  for (const entity of t.select(t.archetypes.Sprite.components)) {
+    const sprite = t.read(entity);
+    if (sprite?.rotation !== undefined) {
+      t.update(entity, { rotation: sprite.rotation + args.delta * 0.1 });
+    }
+  }
+};
diff --git a/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/toggle-sprite-active.ts b/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/toggle-sprite-active.ts
new file mode 100644
index 00000000..c0c89d7a
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/services/main-service/transaction-database/transactions/toggle-sprite-active.ts
@@ -0,0 +1,13 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Entity } from "@adobe/data/ecs";
+import type { CoreDatabase } from "../../core-database/core-database.js";
+
+export const toggleSpriteActive = (
+  t: CoreDatabase.Store,
+  args: { readonly id: Entity },
+) => {
+  const sprite = t.read(args.id);
+  if (sprite && sprite.active !== undefined) {
+    t.update(args.id, { active: !sprite.active });
+  }
+};
diff --git a/packages/data-react-pixie/src/app.tsx b/packages/data-react-pixie/src/features/main/ui/app.tsx
similarity index 54%
rename from packages/data-react-pixie/src/app.tsx
rename to packages/data-react-pixie/src/features/main/ui/app.tsx
index 61bf8a8c..3bd84c07 100644
--- a/packages/data-react-pixie/src/app.tsx
+++ b/packages/data-react-pixie/src/features/main/ui/app.tsx
@@ -2,14 +2,14 @@
 
 import { Application } from "@pixi/react";
 import { DatabaseProvider } from "@adobe/data-react";
-import { pixiePlugin } from "./state/pixie-plugin";
-import { FilterSelector } from "./components/filter-selector/filter-selector";
-import { PixieTick } from "./components/pixie-scene/pixie-tick";
-import { PixieScene } from "./components/pixie-scene/pixie-scene";
+import { MainService } from "../services/main-service/main-service.js";
+import { FilterSelector } from "./filter-selector/filter-selector.js";
+import { PixieTick } from "./pixie-scene/pixie-tick.js";
+import { PixieScene } from "./pixie-scene/pixie-scene.js";
 
 export function App() {
   return (
-    <DatabaseProvider plugin={pixiePlugin}>
+    <DatabaseProvider plugin={MainService.plugin}>
       <FilterSelector />
       <Application background="beige" width={640} height={480}>
         <PixieTick />
@@ -18,4 +18,3 @@ export function App() {
     </DatabaseProvider>
   );
 }
-
diff --git a/packages/data-react-pixie/src/components/filter-selector/filter-selector-presentation.tsx b/packages/data-react-pixie/src/features/main/ui/filter-selector/filter-selector-presentation.tsx
similarity index 50%
rename from packages/data-react-pixie/src/components/filter-selector/filter-selector-presentation.tsx
rename to packages/data-react-pixie/src/features/main/ui/filter-selector/filter-selector-presentation.tsx
index a5b1f41d..05e9162f 100644
--- a/packages/data-react-pixie/src/components/filter-selector/filter-selector-presentation.tsx
+++ b/packages/data-react-pixie/src/features/main/ui/filter-selector/filter-selector-presentation.tsx
@@ -1,8 +1,8 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import type { FilterType } from "../../types/filter-type";
+import type { FilterKind } from "../../data/filter-kind/filter-kind.js";
 
-const FILTER_LABELS: Record<FilterType, string> = {
+const filterLabels: Record<FilterKind, string> = {
   none: "None",
   sepia: "Sepia",
   blur: "Blur",
@@ -10,23 +10,23 @@ const FILTER_LABELS: Record<FilterType, string> = {
   night: "Night",
 };
 
-const FILTER_OPTIONS = (Object.entries(FILTER_LABELS) as [FilterType, string][]).map(([value, label]) => ({
-  value,
-  label,
-}));
+// Object.entries widens keys to string; filterLabels is keyed by exactly FilterKind.
+const filterOptions = (Object.entries(filterLabels) as [FilterKind, string][]).map(
+  ([value, label]) => ({ value, label }),
+);
 
 export function render(args: {
-  currentFilter: FilterType;
-  setFilterType: (filterType: FilterType) => void;
+  currentFilter: FilterKind;
+  setFilter: (filter: FilterKind) => void;
 }) {
-  const { currentFilter, setFilterType } = args;
+  const { currentFilter, setFilter } = args;
   return (
     <div style={{ display: "flex", gap: "0.5rem", marginBottom: "0.5rem" }}>
-      {FILTER_OPTIONS.map(({ value, label }) => (
+      {filterOptions.map(({ value, label }) => (
         <button
           key={value}
           type="button"
-          onClick={() => setFilterType(value)}
+          onClick={() => setFilter(value)}
           style={{
             padding: "0.25rem 0.5rem",
             fontWeight: currentFilter === value ? "bold" : "normal",
diff --git a/packages/data-react-pixie/src/features/main/ui/filter-selector/filter-selector.tsx b/packages/data-react-pixie/src/features/main/ui/filter-selector/filter-selector.tsx
new file mode 100644
index 00000000..983fb82e
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/ui/filter-selector/filter-selector.tsx
@@ -0,0 +1,22 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import { useObservableValues } from "@adobe/data-react";
+import { useMainService } from "../use-main-service.js";
+import * as presentation from "./filter-selector-presentation.js";
+
+export function FilterSelector() {
+  const db = useMainService();
+  const values = useObservableValues(
+    () => ({
+      filter: db.observe.resources.filter,
+    }),
+    [],
+  );
+
+  const currentFilter = values?.filter ?? "none";
+
+  return presentation.render({
+    currentFilter,
+    setFilter: (filter) => db.transactions.setFilter({ filter }),
+  });
+}
diff --git a/packages/data-react-pixie/src/components/pixie-scene/pixie-filters.ts b/packages/data-react-pixie/src/features/main/ui/pixie-scene/pixie-filters.ts
similarity index 62%
rename from packages/data-react-pixie/src/components/pixie-scene/pixie-filters.ts
rename to packages/data-react-pixie/src/features/main/ui/pixie-scene/pixie-filters.ts
index acf3b151..d2be9c80 100644
--- a/packages/data-react-pixie/src/components/pixie-scene/pixie-filters.ts
+++ b/packages/data-react-pixie/src/features/main/ui/pixie-scene/pixie-filters.ts
@@ -1,7 +1,7 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import { BlurFilter, ColorMatrixFilter } from "pixi.js";
-import type { FilterType } from "../../types/filter-type";
+import { BlurFilter, ColorMatrixFilter, type Filter } from "pixi.js";
+import type { FilterKind } from "../../data/filter-kind/filter-kind.js";
 
 const blurFilter = new BlurFilter({ strength: 2, quality: 2 });
 const sepiaFilter = new ColorMatrixFilter();
@@ -11,7 +11,7 @@ vintageFilter.vintage(false);
 const nightFilter = new ColorMatrixFilter();
 nightFilter.night(0.3, false);
 
-const filterMap: Record<FilterType, import("pixi.js").Filter[]> = {
+const filterMap: Record<FilterKind, Filter[]> = {
   none: [],
   sepia: [sepiaFilter],
   blur: [blurFilter],
@@ -19,6 +19,6 @@ const filterMap: Record<FilterType, import("pixi.js").Filter[]> = {
   night: [nightFilter],
 };
 
-export function getFiltersForType(filterType: FilterType) {
-  return filterMap[filterType];
+export function getFiltersForType(filter: FilterKind) {
+  return filterMap[filter];
 }
diff --git a/packages/data-react-pixie/src/components/pixie-scene/pixie-scene-presentation.tsx b/packages/data-react-pixie/src/features/main/ui/pixie-scene/pixie-scene-presentation.tsx
similarity index 89%
rename from packages/data-react-pixie/src/components/pixie-scene/pixie-scene-presentation.tsx
rename to packages/data-react-pixie/src/features/main/ui/pixie-scene/pixie-scene-presentation.tsx
index 12db075f..c26ddcfb 100644
--- a/packages/data-react-pixie/src/components/pixie-scene/pixie-scene-presentation.tsx
+++ b/packages/data-react-pixie/src/features/main/ui/pixie-scene/pixie-scene-presentation.tsx
@@ -1,7 +1,7 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import type { Filter } from "pixi.js";
-import { Sprite } from "../sprite/sprite";
+import { Sprite } from "../sprite/sprite.js";
 
 export function render(args: {
   filters: Filter[];
diff --git a/packages/data-react-pixie/src/components/pixie-scene/pixie-scene.tsx b/packages/data-react-pixie/src/features/main/ui/pixie-scene/pixie-scene.tsx
similarity index 54%
rename from packages/data-react-pixie/src/components/pixie-scene/pixie-scene.tsx
rename to packages/data-react-pixie/src/features/main/ui/pixie-scene/pixie-scene.tsx
index 8b1ca2f5..695d22e7 100644
--- a/packages/data-react-pixie/src/components/pixie-scene/pixie-scene.tsx
+++ b/packages/data-react-pixie/src/features/main/ui/pixie-scene/pixie-scene.tsx
@@ -1,23 +1,23 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import { useObservableValues } from "@adobe/data-react";
-import { usePixieDatabase } from "../../state/use-pixie-database";
-import { getFiltersForType } from "./pixie-filters";
-import * as presentation from "./pixie-scene-presentation";
+import { useMainService } from "../use-main-service.js";
+import { getFiltersForType } from "./pixie-filters.js";
+import * as presentation from "./pixie-scene-presentation.js";
 
 export function PixieScene() {
-  const db = usePixieDatabase();
+  const db = useMainService();
   const values = useObservableValues(
     () => ({
       sprites: db.observe.select(db.archetypes.Sprite.components),
-      filterType: db.observe.resources.filterType,
+      filter: db.observe.resources.filter,
     }),
     [],
   );
 
   if (!values) return null;
 
-  const filters = getFiltersForType(values.filterType ?? "none");
+  const filters = getFiltersForType(values.filter ?? "none");
 
   return presentation.render({
     filters,
diff --git a/packages/data-react-pixie/src/components/pixie-scene/pixie-tick.tsx b/packages/data-react-pixie/src/features/main/ui/pixie-scene/pixie-tick.tsx
similarity index 54%
rename from packages/data-react-pixie/src/components/pixie-scene/pixie-tick.tsx
rename to packages/data-react-pixie/src/features/main/ui/pixie-scene/pixie-tick.tsx
index 1e69c5b1..74603ec3 100644
--- a/packages/data-react-pixie/src/components/pixie-scene/pixie-tick.tsx
+++ b/packages/data-react-pixie/src/features/main/ui/pixie-scene/pixie-tick.tsx
@@ -1,12 +1,12 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import { useTick } from "@pixi/react";
-import { usePixieDatabase } from "../../state/use-pixie-database";
+import { useMainService } from "../use-main-service.js";
 
 export function PixieTick() {
-  const db = usePixieDatabase();
+  const db = useMainService();
   useTick((ticker) => {
-    db.transactions.tick(ticker.deltaTime);
+    db.transactions.tick({ delta: ticker.deltaTime });
   });
   return null;
 }
diff --git a/packages/data-react-pixie/src/types/sprite-type/bunny.png b/packages/data-react-pixie/src/features/main/ui/sprite/bunny.png
similarity index 100%
rename from packages/data-react-pixie/src/types/sprite-type/bunny.png
rename to packages/data-react-pixie/src/features/main/ui/sprite/bunny.png
diff --git a/packages/data-react-pixie/src/types/sprite-type/fox.png b/packages/data-react-pixie/src/features/main/ui/sprite/fox.png
similarity index 100%
rename from packages/data-react-pixie/src/types/sprite-type/fox.png
rename to packages/data-react-pixie/src/features/main/ui/sprite/fox.png
diff --git a/packages/data-react-pixie/src/features/main/ui/sprite/sprite-images.ts b/packages/data-react-pixie/src/features/main/ui/sprite/sprite-images.ts
new file mode 100644
index 00000000..d25336b7
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/ui/sprite/sprite-images.ts
@@ -0,0 +1,13 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import type { SpriteKind } from "../../data/sprite-kind/sprite-kind.js";
+import bunnyUrl from "./bunny.png";
+import foxUrl from "./fox.png";
+
+// Presentation-only mapping from a sprite kind to its texture URL. The bundler
+// resolves each `.png` import to an asset URL. Lives in `ui/` because the URLs
+// are a rendering concern, not part of the serializable data model.
+export const spriteImages = {
+  bunny: bunnyUrl,
+  fox: foxUrl,
+} as const satisfies Record<SpriteKind, string>;
diff --git a/packages/data-react-pixie/src/components/sprite/sprite-presentation.tsx b/packages/data-react-pixie/src/features/main/ui/sprite/sprite-presentation.tsx
similarity index 100%
rename from packages/data-react-pixie/src/components/sprite/sprite-presentation.tsx
rename to packages/data-react-pixie/src/features/main/ui/sprite/sprite-presentation.tsx
diff --git a/packages/data-react-pixie/src/features/main/ui/sprite/sprite.tsx b/packages/data-react-pixie/src/features/main/ui/sprite/sprite.tsx
new file mode 100644
index 00000000..675f6320
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/ui/sprite/sprite.tsx
@@ -0,0 +1,40 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import type { Entity } from "@adobe/data/ecs";
+import { useObservableValues } from "@adobe/data-react";
+import { useMainService } from "../use-main-service.js";
+import { spriteImages } from "./sprite-images.js";
+import { useSpriteTexture } from "./use-sprite-texture.js";
+import * as presentation from "./sprite-presentation.js";
+
+export function Sprite({ entity }: { entity: Entity }) {
+  const db = useMainService();
+  const values = useObservableValues(
+    () => ({
+      sprite: db.observe.entity(entity, db.archetypes.Sprite),
+    }),
+    [entity],
+  );
+
+  const kind = values?.sprite?.kind ?? "bunny";
+  const texture = useSpriteTexture(spriteImages[kind]);
+
+  if (!values?.sprite || !texture) return null;
+
+  const { sprite } = values;
+  const scale = sprite.active ? 1.5 : sprite.hovered ? 1.25 : 1;
+
+  return presentation.render({
+    texture,
+    x: sprite.position[0],
+    y: sprite.position[1],
+    rotation: sprite.rotation,
+    scale,
+    toggleSpriteActive: () =>
+      db.transactions.toggleSpriteActive({ id: entity }),
+    setSpriteHoveredTrue: () =>
+      db.transactions.setSpriteHovered({ id: entity, hovered: true }),
+    setSpriteHoveredFalse: () =>
+      db.transactions.setSpriteHovered({ id: entity, hovered: false }),
+  });
+}
diff --git a/packages/data-react-pixie/src/components/sprite/use-sprite-texture.ts b/packages/data-react-pixie/src/features/main/ui/sprite/use-sprite-texture.ts
similarity index 100%
rename from packages/data-react-pixie/src/components/sprite/use-sprite-texture.ts
rename to packages/data-react-pixie/src/features/main/ui/sprite/use-sprite-texture.ts
diff --git a/packages/data-react-pixie/src/features/main/ui/use-main-service.ts b/packages/data-react-pixie/src/features/main/ui/use-main-service.ts
new file mode 100644
index 00000000..c7b9128d
--- /dev/null
+++ b/packages/data-react-pixie/src/features/main/ui/use-main-service.ts
@@ -0,0 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { useDatabase } from "@adobe/data-react";
+import { MainService } from "../services/main-service/main-service.js";
+
+// The single main-service context every binding component reads. Wraps
+// `useDatabase(MainService.plugin)` so the plugin identity is named once.
+export const useMainService = () => useDatabase(MainService.plugin);
diff --git a/packages/data-react-pixie/src/main.tsx b/packages/data-react-pixie/src/main.tsx
index 1886d0ad..3640814b 100644
--- a/packages/data-react-pixie/src/main.tsx
+++ b/packages/data-react-pixie/src/main.tsx
@@ -3,7 +3,7 @@
 import { createRoot } from "react-dom/client";
 import { Container, Graphics, Sprite } from "pixi.js";
 import { extend } from "@pixi/react";
-import { App } from "./app";
+import { App } from "./features/main/ui/app.js";
 
 // Register PixiJS components for @pixi/react (pixiSprite, pixiContainer)
 extend({ Container, Graphics, Sprite });
diff --git a/packages/data-react-pixie/src/state/pixie-plugin.ts b/packages/data-react-pixie/src/state/pixie-plugin.ts
deleted file mode 100644
index e9517f6e..00000000
--- a/packages/data-react-pixie/src/state/pixie-plugin.ts
+++ /dev/null
@@ -1,97 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import { Database } from "@adobe/data/ecs";
-import { Boolean } from "@adobe/data/schema";
-import { Vec2, F32 } from "@adobe/data/math";
-import type { FilterType } from "../types/filter-type";
-import { SpriteType } from "../types/sprite-type/sprite-type";
-
-export const pixiePlugin = Database.Plugin.create({
-  components: {
-    position: Vec2.schema,
-    rotation: F32.schema,
-    sprite: SpriteType.schema,
-    hovered: Boolean.schema,
-    active: Boolean.schema,
-  },
-  resources: {
-    filterType: { default: "none" as FilterType },
-  },
-  archetypes: {
-    Sprite: ["position", "rotation", "sprite", "hovered", "active"],
-  },
-  transactions: {
-    tick: (t, delta: number) => {
-      const entities = t.select(["position", "rotation", "sprite", "hovered", "active"]);
-      for (const entity of entities) {
-        const row = t.read(entity);
-        if (row?.rotation !== undefined) {
-          t.update(entity, { rotation: row.rotation + delta * 0.1 });
-        }
-      }
-    },
-    createSprite: (
-      t,
-      args: { position: [number, number]; rotation?: number; sprite: "bunny" | "fox" },
-    ) => {
-      return t.archetypes.Sprite.insert({
-        position: args.position,
-        rotation: args.rotation ?? 0,
-        sprite: args.sprite,
-        hovered: false,
-        active: false,
-      });
-    },
-    setSpriteHovered: (t, args: { entity: number; hovered: boolean }) => {
-      t.update(args.entity, { hovered: args.hovered });
-    },
-    setSpriteActive: (t, args: { entity: number; active: boolean }) => {
-      t.update(args.entity, { active: args.active });
-    },
-    toggleSpriteActive: (t, args: { entity: number }) => {
-      const row = t.read(args.entity);
-      if (row?.active !== undefined) {
-        t.update(args.entity, { active: !row.active });
-      }
-    },
-    setFilterType: (t, args: { filterType: FilterType }) => {
-      t.resources.filterType = args.filterType;
-    },
-  },
-  systems: {
-    pixie_plugin_initialize: {
-      create: (db) => {
-        db.store.archetypes.Sprite.insert({
-          position: [100, 100],
-          rotation: 0,
-          sprite: "bunny",
-          hovered: false,
-          active: false,
-        });
-        db.store.archetypes.Sprite.insert({
-          position: [200, 150],
-          rotation: 0.5,
-          sprite: "bunny",
-          hovered: false,
-          active: false,
-        });
-        db.store.archetypes.Sprite.insert({
-          position: [300, 200],
-          rotation: 1,
-          sprite: "fox",
-          hovered: false,
-          active: false,
-        });
-        db.store.archetypes.Sprite.insert({
-          position: [150, 250],
-          rotation: 0.2,
-          sprite: "fox",
-          hovered: false,
-          active: false,
-        });
-      }
-    }
-  }
-});
-
-export type PixieDatabase = Database.FromPlugin<typeof pixiePlugin>;
diff --git a/packages/data-react-pixie/src/state/use-pixie-database.ts b/packages/data-react-pixie/src/state/use-pixie-database.ts
deleted file mode 100644
index a59c5284..00000000
--- a/packages/data-react-pixie/src/state/use-pixie-database.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import { useDatabase as useDatabaseHook } from "@adobe/data-react";
-import { pixiePlugin } from "./pixie-plugin";
-
-export const usePixieDatabase = () => useDatabaseHook(pixiePlugin);
diff --git a/packages/data-react-pixie/src/types/filter-type.ts b/packages/data-react-pixie/src/types/filter-type.ts
deleted file mode 100644
index fcf96464..00000000
--- a/packages/data-react-pixie/src/types/filter-type.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-export type FilterType = "none" | "sepia" | "blur" | "vintage" | "night";
diff --git a/packages/data-react-pixie/src/types/sprite-type/image.ts b/packages/data-react-pixie/src/types/sprite-type/image.ts
deleted file mode 100644
index e805770c..00000000
--- a/packages/data-react-pixie/src/types/sprite-type/image.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import { Schema } from "@adobe/data/schema";
-import { schema } from "./schema";
-
-import bunnyUrl from "./bunny.png";
-import foxUrl from "./fox.png";
-
-type SpriteType = Schema.ToType<typeof schema>;
-
-export const image = {
-  bunny: bunnyUrl,
-  fox: foxUrl,
-} as const satisfies Record<SpriteType, string>;
diff --git a/packages/data-react-pixie/src/types/sprite-type/public.ts b/packages/data-react-pixie/src/types/sprite-type/public.ts
deleted file mode 100644
index 95abd85b..00000000
--- a/packages/data-react-pixie/src/types/sprite-type/public.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-export { schema } from "./schema";
-export { image } from "./image";
diff --git a/packages/data-react-pixie/src/types/sprite-type/schema.ts b/packages/data-react-pixie/src/types/sprite-type/schema.ts
deleted file mode 100644
index d1a6fbf3..00000000
--- a/packages/data-react-pixie/src/types/sprite-type/schema.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import { Schema } from "@adobe/data/schema";
-
-export const schema = { enum: ["bunny", "fox"] } as const satisfies Schema;
diff --git a/packages/data-react-pixie/src/types/sprite-type/sprite-type.ts b/packages/data-react-pixie/src/types/sprite-type/sprite-type.ts
deleted file mode 100644
index a5766176..00000000
--- a/packages/data-react-pixie/src/types/sprite-type/sprite-type.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import { Schema } from "@adobe/data/schema";
-import { schema } from "./schema";
-
-export type SpriteType = Schema.ToType<typeof schema>;
-export * as SpriteType from "./public";
diff --git a/packages/data-react/package.json b/packages/data-react/package.json
index 346a70f3..6db84df7 100644
--- a/packages/data-react/package.json
+++ b/packages/data-react/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@adobe/data-react",
-  "version": "0.9.92",
+  "version": "0.9.93",
   "description": "Adobe data React bindings — hooks and context for ECS database",
   "type": "module",
   "private": false,
diff --git a/packages/data-solid-dashboard/README.md b/packages/data-solid-dashboard/README.md
index 2994ed22..85d705ab 100644
--- a/packages/data-solid-dashboard/README.md
+++ b/packages/data-solid-dashboard/README.md
@@ -27,29 +27,38 @@ pnpm dev        # starts Vite on http://localhost:3004
 
 ## Structure
 
+Organized into the feature-folder architecture — layered by the *kind of type*
+each folder holds (`data/` value types & pure transforms, `services/` the ECS
+implementation, `ui/` presentation):
+
 ```
 src/
-  state/
-    dashboard-plugin.ts        ECS plugin — resources and transactions
-  components/
-    control-panel.tsx           data wiring — observes count, exposes transactions
-    control-panel.presentation.tsx
-    counter-display.tsx         data wiring — observes count
-    counter-display.presentation.tsx
-    activity-log.tsx            data wiring — observes log
-    activity-log.presentation.tsx
-    status-bar.tsx              data wiring — observes userName, count, log
-    status-bar.presentation.tsx
-  app.tsx                       root component — sets up DatabaseProvider
-  main.tsx                      entry point
+  main.tsx                              entry point
+  features/main/
+    data/state/                         the spec — one immutable State + pure transforms
+      state.ts  create.ts  public.ts
+      increment.ts / .test.ts  decrement.ts / .test.ts  reset.ts / .test.ts
+      set-user-name.ts / .test.ts  clear-log.ts / .test.ts
+      conformance-case.ts  expect-state-matches.ts
+    services/main-service/              the implementation — the sole entrypoint the ui/ binds to
+      core-database/                    resources (count, userName, log) — no entities
+      transaction-database/transactions/  one mutation per file + conformance test
+      conformance/                      fromState / toState / expectConforms (test-only)
+      main-service.ts                   aliases the top layer as MainService
+    ui/                                 Solid components (element + pure presentation)
+      app/  status-bar/  control-panel/  counter-display/  activity-log/
 ```
 
+Each transaction is proven equivalent to its pure `data/` transform via
+`toState(apply(fromState(before), args)) ≡ State.transform(before, args)`, reusing
+the spec-owned cases exported from each `data/state/<transform>.test.ts`.
+
 ## Pattern summary
 
 ```tsx
 // data wiring: setup reactive graph, delegate to presentation
 function CounterDisplay() {
-  const db = useDatabase(dashboardPlugin);
+  const db = useDatabase(MainService.plugin);
   const count = fromObserve(db.observe.resources.count, 0);
   return presentation.render({ count });
 }
diff --git a/packages/data-solid-dashboard/package.json b/packages/data-solid-dashboard/package.json
index 5d25baa1..4a7b505b 100644
--- a/packages/data-solid-dashboard/package.json
+++ b/packages/data-solid-dashboard/package.json
@@ -1,13 +1,14 @@
 {
   "name": "data-solid-dashboard",
-  "version": "0.9.92",
+  "version": "0.9.93",
   "description": "Mini dashboard sample — multiple components sharing one @adobe/data ECS database with SolidJS",
   "type": "module",
   "private": true,
   "scripts": {
     "build": "vite build",
     "dev": "vite",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest --run --passWithNoTests"
   },
   "dependencies": {
     "@adobe/data": "workspace:*",
@@ -15,9 +16,11 @@
     "solid-js": "^1.9.12"
   },
   "devDependencies": {
+    "jsdom": "^24.1.0",
     "typescript": "^5.8.3",
     "vite": "^5.1.1",
     "vite-plugin-checker": "^0.12.0",
-    "vite-plugin-solid": "^2.11.0"
+    "vite-plugin-solid": "^2.11.0",
+    "vitest": "^1.6.0"
   }
 }
diff --git a/packages/data-solid-dashboard/src/features/main/data/state/clear-log.ts b/packages/data-solid-dashboard/src/features/main/data/state/clear-log.ts
new file mode 100644
index 00000000..2176c28d
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/data/state/clear-log.ts
@@ -0,0 +1,19 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+
+// Empty the activity log. The counter and user name are left untouched — the
+// runner keeps them, since this writes only `log`.
+export const clearLog = (
+  _state: Pick<State, "log">,
+): Pick<State, "log"> => ({ log: [] });
+
+// Spec-owned cases, shared with the ecs `clearLog` transaction and action.
+export const cases: Conformance<typeof clearLog> = [
+  { name: "empties a populated log, leaving count and name intact",
+    before: { count: 2, log: ["a", "b"], userName: "Ada" },
+    after: { log: [] } },
+  { name: "is a no-op on an already empty log",
+    before: {},
+    after: {} },
+];
diff --git a/packages/data-solid-dashboard/src/features/main/data/state/conformance-case.ts b/packages/data-solid-dashboard/src/features/main/data/state/conformance-case.ts
new file mode 100644
index 00000000..4426eca4
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/data/state/conformance-case.ts
@@ -0,0 +1,13 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Conformance as ConformanceApi } from "@adobe/data/testing";
+import type { State } from "./state.js";
+
+// The conformance case types for this feature — the shared `@adobe/data/testing`
+// machinery with `State` bound once, so a transform authors `Conformance<typeof fn>`
+// and a derivation `Derivation<typeof fn>` (args/input/value read from the
+// function's own signature). This tiny file is the only per-feature conformance
+// type declaration; everything else lives in `@adobe/data/testing`.
+export type Conformance<F extends (...args: never[]) => unknown> =
+  ConformanceApi.Cases<State, F>;
+export type Derivation<F extends (...args: never[]) => unknown> =
+  ConformanceApi.DerivationCases<F>;
diff --git a/packages/data-solid-dashboard/src/features/main/data/state/create.ts b/packages/data-solid-dashboard/src/features/main/data/state/create.ts
new file mode 100644
index 00000000..4267de00
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/data/state/create.ts
@@ -0,0 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+
+// The initial dashboard state — the defaults the ECS resources also carry.
+export const create = (): State => ({ count: 0, log: [], userName: "Guest" });
diff --git a/packages/data-solid-dashboard/src/features/main/data/state/decrement.ts b/packages/data-solid-dashboard/src/features/main/data/state/decrement.ts
new file mode 100644
index 00000000..6fdcd606
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/data/state/decrement.ts
@@ -0,0 +1,23 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+
+// Lower the counter by one, never below zero. At the floor it writes the slice
+// back unchanged (no log entry), keeping the transform idempotent at zero.
+export const decrement = (
+  state: Pick<State, "count" | "log">,
+): Pick<State, "count" | "log"> => {
+  if (state.count <= 0) return { count: state.count, log: state.log };
+  const count = state.count - 1;
+  return { count, log: [...state.log, `Decremented to ${count}`] };
+};
+
+// Spec-owned cases, shared with the ecs `decrement` transaction and action.
+export const cases: Conformance<typeof decrement> = [
+  { name: "decrements a positive count and logs the new value",
+    before: { count: 3, log: ["earlier"] },
+    after: { count: 2, log: ["earlier", "Decremented to 2"] } },
+  { name: "is a no-op at zero, leaving state untouched",
+    before: {},
+    after: {} },
+];
diff --git a/packages/data-solid-dashboard/src/features/main/data/state/increment.ts b/packages/data-solid-dashboard/src/features/main/data/state/increment.ts
new file mode 100644
index 00000000..3df45dda
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/data/state/increment.ts
@@ -0,0 +1,23 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+
+// Raise the counter by one and record it in the activity log. Returns only the
+// fields it writes (count + log); the runner merges the patch over the rest.
+export const increment = (
+  state: Pick<State, "count" | "log">,
+): Pick<State, "count" | "log"> => {
+  const count = state.count + 1;
+  return { count, log: [...state.log, `Incremented to ${count}`] };
+};
+
+// Spec-owned cases, shared with the ecs `increment` transaction and action.
+// `before` is a delta over `State.create()`; `after` is the writes patch.
+export const cases: Conformance<typeof increment> = [
+  { name: "increments from zero and logs the new value",
+    before: {},
+    after: { count: 1, log: ["Incremented to 1"] } },
+  { name: "increments an existing count, preserving prior log entries",
+    before: { count: 4, log: ["earlier"] },
+    after: { count: 5, log: ["earlier", "Incremented to 5"] } },
+];
diff --git a/packages/data-solid-dashboard/src/features/main/data/state/public.ts b/packages/data-solid-dashboard/src/features/main/data/state/public.ts
new file mode 100644
index 00000000..1b91e948
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/data/state/public.ts
@@ -0,0 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { create } from "./create.js";
+export { samples } from "./samples.js";
+export { increment } from "./increment.js";
+export { decrement } from "./decrement.js";
+export { reset } from "./reset.js";
+export { setUserName } from "./set-user-name.js";
+export { clearLog } from "./clear-log.js";
diff --git a/packages/data-solid-dashboard/src/features/main/data/state/reset.ts b/packages/data-solid-dashboard/src/features/main/data/state/reset.ts
new file mode 100644
index 00000000..9532afb4
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/data/state/reset.ts
@@ -0,0 +1,21 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+
+// Return the counter to zero and record the reset in the activity log.
+export const reset = (
+  state: Pick<State, "count" | "log">,
+): Pick<State, "count" | "log"> => ({
+  count: 0,
+  log: [...state.log, "Reset to 0"],
+});
+
+// Spec-owned cases, shared with the ecs `reset` transaction and action.
+export const cases: Conformance<typeof reset> = [
+  { name: "resets a positive count and logs the reset",
+    before: { count: 7, log: ["earlier"] },
+    after: { count: 0, log: ["earlier", "Reset to 0"] } },
+  { name: "logs the reset even when already at zero",
+    before: {},
+    after: { count: 0, log: ["Reset to 0"] } },
+];
diff --git a/packages/data-solid-dashboard/src/features/main/data/state/samples.ts b/packages/data-solid-dashboard/src/features/main/data/state/samples.ts
new file mode 100644
index 00000000..06542151
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/data/state/samples.ts
@@ -0,0 +1,14 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+
+// Representative full states for the projection round-trip (toState ∘ fromState ≡
+// identity). A populated dashboard and the initial defaults exercise the whole
+// ecs↔State map. The state is entirely scalar resources, so the compare is exact.
+export const samples: readonly State[] = [
+  {
+    count: 3,
+    log: ["Incremented to 1", "Name changed to Ada"],
+    userName: "Ada",
+  },
+  { count: 0, log: [], userName: "Guest" },
+];
diff --git a/packages/data-solid-dashboard/src/features/main/data/state/set-user-name.ts b/packages/data-solid-dashboard/src/features/main/data/state/set-user-name.ts
new file mode 100644
index 00000000..b7b2fe50
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/data/state/set-user-name.ts
@@ -0,0 +1,24 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+import type { Conformance } from "./conformance-case.js";
+
+// Change the active user's name and record the change in the activity log.
+export const setUserName = (
+  state: Pick<State, "userName" | "log">,
+  { name }: { name: string },
+): Pick<State, "userName" | "log"> => ({
+  userName: name,
+  log: [...state.log, `Name changed to ${name}`],
+});
+
+// Spec-owned cases, shared with the ecs `setUserName` transaction and action.
+export const cases: Conformance<typeof setUserName> = [
+  { name: "sets the name and logs the change",
+    before: {},
+    args: { name: "Ada" },
+    after: { userName: "Ada", log: ["Name changed to Ada"] } },
+  { name: "replaces an existing name, preserving prior log entries",
+    before: { log: ["earlier"], userName: "Ada" },
+    args: { name: "Grace" },
+    after: { userName: "Grace", log: ["earlier", "Name changed to Grace"] } },
+];
diff --git a/packages/data-solid-dashboard/src/features/main/data/state/spec.test.ts b/packages/data-solid-dashboard/src/features/main/data/state/spec.test.ts
new file mode 100644
index 00000000..9d5c4074
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/data/state/spec.test.ts
@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Conformance } from "@adobe/data/testing";
+import { State } from "./state.js";
+import { transitions } from "./transitions.js";
+
+// The single pure-spec test for every transform AND derivation in this folder.
+// `runSpec` auto-discovers each module in `transitions` that exports `cases`,
+// requires it to export exactly its function plus `cases`, and dispatches on case
+// shape. Each case's `before`/`input` is a delta over `State.create()`.
+Conformance.runSpec({ state: State, transitions });
diff --git a/packages/data-solid-dashboard/src/features/main/data/state/state.ts b/packages/data-solid-dashboard/src/features/main/data/state/state.ts
new file mode 100644
index 00000000..c3a9c914
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/data/state/state.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+// The whole dashboard modelled as one immutable value — the specification the
+// ECS implementation is verified against. Every field is a scalar (no entity
+// collections); `log` is an append-only activity trail in chronological order.
+export type State = {
+  readonly count: number;
+  readonly log: readonly string[];
+  readonly userName: string;
+};
+export * as State from "./public.js";
diff --git a/packages/data-solid-dashboard/src/features/main/data/state/transitions.ts b/packages/data-solid-dashboard/src/features/main/data/state/transitions.ts
new file mode 100644
index 00000000..1092fd91
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/data/state/transitions.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+/// <reference types="vite/client" />
+
+// The transform/derivation modules for conformance discovery — the `{ fn, cases }`
+// source shared by `spec.test.ts` (pure) and the ecs `conformance.test.ts`. The
+// glob must be authored where Vite can statically see it (an eager glob, excluding
+// tests and this file itself); consumers import the resolved map.
+export const transitions = import.meta.glob<Record<string, unknown>>(
+  ["./*.ts", "!./*.test.ts", "!./*.type-test.ts", "!./transitions.ts"],
+  { eager: true },
+);
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/action-database.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/action-database.ts
new file mode 100644
index 00000000..cc2572a2
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/action-database.ts
@@ -0,0 +1,18 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { TransactionDatabase } from "../transaction-database/transaction-database.js";
+import * as actions from "./actions/index.js";
+
+// Extends the transaction layer directly: this feature has no computed / service
+// layers between them (no derivations, no external capability services).
+const actionDatabasePlugin = Database.Plugin.create({
+  extends: TransactionDatabase.plugin,
+  actions,
+});
+
+export type ActionDatabase = Database.Plugin.ToDatabase<typeof actionDatabasePlugin>;
+
+export namespace ActionDatabase {
+  export const plugin = actionDatabasePlugin;
+  export type Store = Database.Plugin.ToStore<typeof actionDatabasePlugin>;
+}
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/clear-log.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/clear-log.ts
new file mode 100644
index 00000000..29942007
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/clear-log.ts
@@ -0,0 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { TransactionDatabase } from "../../transaction-database/transaction-database.js";
+
+// The app-facing realization of `State.clearLog` — commits the transaction.
+export const clearLog = (db: TransactionDatabase) => {
+  db.transactions.clearLog();
+};
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/decrement.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/decrement.ts
new file mode 100644
index 00000000..a751cfaf
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/decrement.ts
@@ -0,0 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { TransactionDatabase } from "../../transaction-database/transaction-database.js";
+
+// The app-facing realization of `State.decrement` — commits the transaction.
+export const decrement = (db: TransactionDatabase) => {
+  db.transactions.decrement();
+};
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/increment.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/increment.ts
new file mode 100644
index 00000000..3b4f3d2f
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/increment.ts
@@ -0,0 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { TransactionDatabase } from "../../transaction-database/transaction-database.js";
+
+// The app-facing realization of `State.increment`. This feature has no external
+// services to await, so the action just commits the transaction (exactly one).
+export const increment = (db: TransactionDatabase) => {
+  db.transactions.increment();
+};
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/index.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/index.ts
new file mode 100644
index 00000000..002f08a4
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/index.ts
@@ -0,0 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export * from "./increment.js";
+export * from "./decrement.js";
+export * from "./reset.js";
+export * from "./set-user-name.js";
+export * from "./clear-log.js";
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/reset.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/reset.ts
new file mode 100644
index 00000000..9c152c66
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/reset.ts
@@ -0,0 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { TransactionDatabase } from "../../transaction-database/transaction-database.js";
+
+// The app-facing realization of `State.reset` — commits the transaction.
+export const reset = (db: TransactionDatabase) => {
+  db.transactions.reset();
+};
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/set-user-name.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/set-user-name.ts
new file mode 100644
index 00000000..85f1e50f
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/action-database/actions/set-user-name.ts
@@ -0,0 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { TransactionDatabase } from "../../transaction-database/transaction-database.js";
+
+// The app-facing realization of `State.setUserName` — commits the transaction.
+export const setUserName = (db: TransactionDatabase, input: { readonly name: string }) => {
+  db.transactions.setUserName(input);
+};
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/conformance/conformance.test.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/conformance/conformance.test.ts
new file mode 100644
index 00000000..17d95570
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/conformance/conformance.test.ts
@@ -0,0 +1,18 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Conformance } from "@adobe/data/testing";
+import { State } from "../../../data/state/state.js";
+import { transitions } from "../../../data/state/transitions.js";
+import { MainService } from "../main-service.js";
+import { projection } from "./projection.js";
+
+// The whole ecs conformance for this feature in one call: `runFeature` pulls the
+// transactions/actions off `MainService.plugin`, seeds each case's `before` (a
+// delta) over `State.create()`, and round-trips `State.samples` through the
+// projection. `transitions` (the discovered `{ fn, cases }` modules) is shared with
+// spec.test. This feature has no derivations, so no `computedPlugin`.
+Conformance.runFeature({
+  state: State,
+  transitions,
+  plugin: MainService.plugin,
+  projection,
+});
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/conformance/projection.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/conformance/projection.ts
new file mode 100644
index 00000000..a8b8980d
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/conformance/projection.ts
@@ -0,0 +1,25 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Entity } from "@adobe/data/ecs";
+import type { State } from "../../../data/state/state.js";
+import type { CoreDatabase } from "../core-database/core-database.js";
+
+// The test-only ecs↔`State` projection, passed to `Conformance.runFeature`.
+// `fromState` seeds a store to a `State`; the whole state is scalar resources, so
+// seeding is three assignments, it mints no ids and returns an empty map.
+// `toState` reads it back — the inverse. No entities, so no `toData`.
+export const projection = {
+  fromState: (
+    store: CoreDatabase.Store,
+    state: State,
+  ): ReadonlyMap<number, Entity> => {
+    store.resources.count = state.count;
+    store.resources.log = state.log;
+    store.resources.userName = state.userName;
+    return new Map();
+  },
+  toState: (store: CoreDatabase.Store): State => ({
+    count: store.resources.count,
+    log: store.resources.log,
+    userName: store.resources.userName,
+  }),
+};
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/core-database/core-database.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/core-database/core-database.ts
new file mode 100644
index 00000000..e296d0e1
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/core-database/core-database.ts
@@ -0,0 +1,16 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { resources } from "./resources.js";
+
+// The core schema. This feature has no entities, so it declares only resources —
+// no `components` / `archetypes` boilerplate (all facets are optional).
+const coreDatabasePlugin = Database.Plugin.create({
+  resources,
+});
+
+export type CoreDatabase = Database.Plugin.ToDatabase<typeof coreDatabasePlugin>;
+
+export namespace CoreDatabase {
+  export const plugin = coreDatabasePlugin;
+  export type Store = Database.Plugin.ToStore<typeof coreDatabasePlugin>;
+}
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/core-database/resources.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/core-database/resources.ts
new file mode 100644
index 00000000..5c5b43a1
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/core-database/resources.ts
@@ -0,0 +1,13 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+
+// The whole dashboard is scalar state — three singleton resources, no entities.
+// All three are `document` scope (shared + durable, no scope flags), the default
+// home for feature state. Each carries the same default as `State.create()`.
+export const resources = Database.resources({
+  document: {
+    count: { type: "number", default: 0 },
+    userName: { type: "string", default: "Guest" },
+    log: { type: "array", items: { type: "string" }, default: [] },
+  },
+});
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/main-service.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/main-service.ts
new file mode 100644
index 00000000..14f15fb4
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/main-service.ts
@@ -0,0 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+// The assembled feature database — the sole entrypoint the `ui/` binds to.
+// Actions are the topmost layer this feature builds (no computed / service /
+// system layers), so `ActionDatabase` is `MainService`. Adding or dropping a
+// layer changes only this one line; consumers name `MainService`.
+export { ActionDatabase as MainService } from "./action-database/action-database.js";
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transaction-database.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transaction-database.ts
new file mode 100644
index 00000000..02a03684
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transaction-database.ts
@@ -0,0 +1,16 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { CoreDatabase } from "../core-database/core-database.js";
+import * as transactions from "./transactions/index.js";
+
+const transactionDatabasePlugin = Database.Plugin.create({
+  extends: CoreDatabase.plugin,
+  transactions,
+});
+
+export type TransactionDatabase = Database.Plugin.ToDatabase<typeof transactionDatabasePlugin>;
+
+export namespace TransactionDatabase {
+  export const plugin = transactionDatabasePlugin;
+  export type Store = Database.Plugin.ToStore<typeof transactionDatabasePlugin>;
+}
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/clear-log.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/clear-log.ts
new file mode 100644
index 00000000..83d5f929
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/clear-log.ts
@@ -0,0 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { State } from "../../../../data/state/state.js";
+import type { CoreDatabase } from "../../core-database/core-database.js";
+
+export const clearLog = (t: CoreDatabase.Store) => {
+  const next = State.clearLog({ log: t.resources.log });
+  t.resources.log = next.log;
+};
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/decrement.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/decrement.ts
new file mode 100644
index 00000000..e084b8d2
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/decrement.ts
@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { State } from "../../../../data/state/state.js";
+import type { CoreDatabase } from "../../core-database/core-database.js";
+
+export const decrement = (t: CoreDatabase.Store) => {
+  const next = State.decrement({ count: t.resources.count, log: t.resources.log });
+  t.resources.count = next.count;
+  t.resources.log = next.log;
+};
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/increment.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/increment.ts
new file mode 100644
index 00000000..61581a04
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/increment.ts
@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { State } from "../../../../data/state/state.js";
+import type { CoreDatabase } from "../../core-database/core-database.js";
+
+// Applies `State.increment` to the resource slice it touches — the decision is
+// the pure transform's, this only writes the diff back to the store.
+export const increment = (t: CoreDatabase.Store) => {
+  const next = State.increment({ count: t.resources.count, log: t.resources.log });
+  t.resources.count = next.count;
+  t.resources.log = next.log;
+};
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/index.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/index.ts
new file mode 100644
index 00000000..08dc41f2
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/index.ts
@@ -0,0 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { increment } from "./increment.js";
+export { decrement } from "./decrement.js";
+export { reset } from "./reset.js";
+export { setUserName } from "./set-user-name.js";
+export { clearLog } from "./clear-log.js";
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/reset.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/reset.ts
new file mode 100644
index 00000000..17861451
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/reset.ts
@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { State } from "../../../../data/state/state.js";
+import type { CoreDatabase } from "../../core-database/core-database.js";
+
+export const reset = (t: CoreDatabase.Store) => {
+  const next = State.reset({ count: t.resources.count, log: t.resources.log });
+  t.resources.count = next.count;
+  t.resources.log = next.log;
+};
diff --git a/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/set-user-name.ts b/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/set-user-name.ts
new file mode 100644
index 00000000..f87ade0b
--- /dev/null
+++ b/packages/data-solid-dashboard/src/features/main/services/main-service/transaction-database/transactions/set-user-name.ts
@@ -0,0 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { State } from "../../../../data/state/state.js";
+import type { CoreDatabase } from "../../core-database/core-database.js";
+
+export const setUserName = (t: CoreDatabase.Store, { name }: { name: string }) => {
+  const next = State.setUserName(
+    { userName: t.resources.userName, log: t.resources.log },
+    { name },
+  );
+  t.resources.userName = next.userName;
+  t.resources.log = next.log;
+};
diff --git a/packages/data-solid-dashboard/src/components/activity-log.presentation.tsx b/packages/data-solid-dashboard/src/features/main/ui/activity-log/activity-log.presentation.tsx
similarity index 100%
rename from packages/data-solid-dashboard/src/components/activity-log.presentation.tsx
rename to packages/data-solid-dashboard/src/features/main/ui/activity-log/activity-log.presentation.tsx
diff --git a/packages/data-solid-dashboard/src/components/activity-log.tsx b/packages/data-solid-dashboard/src/features/main/ui/activity-log/activity-log.tsx
similarity index 61%
rename from packages/data-solid-dashboard/src/components/activity-log.tsx
rename to packages/data-solid-dashboard/src/features/main/ui/activity-log/activity-log.tsx
index e0de3415..b46126f0 100644
--- a/packages/data-solid-dashboard/src/components/activity-log.tsx
+++ b/packages/data-solid-dashboard/src/features/main/ui/activity-log/activity-log.tsx
@@ -1,11 +1,11 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import { fromObserve, useDatabase } from "@adobe/data-solid";
-import { dashboardPlugin } from "../state/dashboard-plugin";
-import * as presentation from "./activity-log.presentation";
+import { MainService } from "../../services/main-service/main-service.js";
+import * as presentation from "./activity-log.presentation.jsx";
 
 export function ActivityLog() {
-  const db = useDatabase(dashboardPlugin);
+  const db = useDatabase(MainService.plugin);
   const log = fromObserve(db.observe.resources.log, []);
   const { clearLog } = db.transactions;
 
diff --git a/packages/data-solid-dashboard/src/app.css b/packages/data-solid-dashboard/src/features/main/ui/app/app.css
similarity index 100%
rename from packages/data-solid-dashboard/src/app.css
rename to packages/data-solid-dashboard/src/features/main/ui/app/app.css
diff --git a/packages/data-solid-dashboard/src/app.tsx b/packages/data-solid-dashboard/src/features/main/ui/app/app.tsx
similarity index 50%
rename from packages/data-solid-dashboard/src/app.tsx
rename to packages/data-solid-dashboard/src/features/main/ui/app/app.tsx
index d662a548..c9df0e90 100644
--- a/packages/data-solid-dashboard/src/app.tsx
+++ b/packages/data-solid-dashboard/src/features/main/ui/app/app.tsx
@@ -1,16 +1,16 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import { DatabaseProvider } from "@adobe/data-solid";
-import { dashboardPlugin } from "./state/dashboard-plugin";
-import { StatusBar } from "./components/status-bar";
-import { ControlPanel } from "./components/control-panel";
-import { CounterDisplay } from "./components/counter-display";
-import { ActivityLog } from "./components/activity-log";
+import { MainService } from "../../services/main-service/main-service.js";
+import { StatusBar } from "../status-bar/status-bar.jsx";
+import { ControlPanel } from "../control-panel/control-panel.jsx";
+import { CounterDisplay } from "../counter-display/counter-display.jsx";
+import { ActivityLog } from "../activity-log/activity-log.jsx";
 import "./app.css";
 
 export function App() {
   return (
-    <DatabaseProvider plugin={dashboardPlugin}>
+    <DatabaseProvider plugin={MainService.plugin}>
       <div class="dashboard">
         <StatusBar />
         <div class="main-content">
diff --git a/packages/data-solid-dashboard/src/components/control-panel.presentation.tsx b/packages/data-solid-dashboard/src/features/main/ui/control-panel/control-panel.presentation.tsx
similarity index 100%
rename from packages/data-solid-dashboard/src/components/control-panel.presentation.tsx
rename to packages/data-solid-dashboard/src/features/main/ui/control-panel/control-panel.presentation.tsx
diff --git a/packages/data-solid-dashboard/src/components/control-panel.tsx b/packages/data-solid-dashboard/src/features/main/ui/control-panel/control-panel.tsx
similarity index 56%
rename from packages/data-solid-dashboard/src/components/control-panel.tsx
rename to packages/data-solid-dashboard/src/features/main/ui/control-panel/control-panel.tsx
index 57e9e4b5..d482eaa7 100644
--- a/packages/data-solid-dashboard/src/components/control-panel.tsx
+++ b/packages/data-solid-dashboard/src/features/main/ui/control-panel/control-panel.tsx
@@ -1,13 +1,14 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import { fromObserve, useDatabase } from "@adobe/data-solid";
-import { dashboardPlugin } from "../state/dashboard-plugin";
-import * as presentation from "./control-panel.presentation";
+import { MainService } from "../../services/main-service/main-service.js";
+import * as presentation from "./control-panel.presentation.jsx";
 
 export function ControlPanel() {
-  const db = useDatabase(dashboardPlugin);
+  const db = useDatabase(MainService.plugin);
   const count = fromObserve(db.observe.resources.count, 0);
   const { increment, decrement, reset, setUserName } = db.transactions;
+  const setName = (name: string) => setUserName({ name });
 
-  return presentation.render({ count, increment, decrement, reset, setUserName });
+  return presentation.render({ count, increment, decrement, reset, setUserName: setName });
 }
diff --git a/packages/data-solid-dashboard/src/components/counter-display.presentation.tsx b/packages/data-solid-dashboard/src/features/main/ui/counter-display/counter-display.presentation.tsx
similarity index 100%
rename from packages/data-solid-dashboard/src/components/counter-display.presentation.tsx
rename to packages/data-solid-dashboard/src/features/main/ui/counter-display/counter-display.presentation.tsx
diff --git a/packages/data-solid-dashboard/src/components/counter-display.tsx b/packages/data-solid-dashboard/src/features/main/ui/counter-display/counter-display.tsx
similarity index 57%
rename from packages/data-solid-dashboard/src/components/counter-display.tsx
rename to packages/data-solid-dashboard/src/features/main/ui/counter-display/counter-display.tsx
index b4f9b8d5..2f71e8b3 100644
--- a/packages/data-solid-dashboard/src/components/counter-display.tsx
+++ b/packages/data-solid-dashboard/src/features/main/ui/counter-display/counter-display.tsx
@@ -1,11 +1,11 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import { fromObserve, useDatabase } from "@adobe/data-solid";
-import { dashboardPlugin } from "../state/dashboard-plugin";
-import * as presentation from "./counter-display.presentation";
+import { MainService } from "../../services/main-service/main-service.js";
+import * as presentation from "./counter-display.presentation.jsx";
 
 export function CounterDisplay() {
-  const db = useDatabase(dashboardPlugin);
+  const db = useDatabase(MainService.plugin);
   const count = fromObserve(db.observe.resources.count, 0);
 
   return presentation.render({ count });
diff --git a/packages/data-solid-dashboard/src/components/status-bar.presentation.tsx b/packages/data-solid-dashboard/src/features/main/ui/status-bar/status-bar.presentation.tsx
similarity index 100%
rename from packages/data-solid-dashboard/src/components/status-bar.presentation.tsx
rename to packages/data-solid-dashboard/src/features/main/ui/status-bar/status-bar.presentation.tsx
diff --git a/packages/data-solid-dashboard/src/components/status-bar.tsx b/packages/data-solid-dashboard/src/features/main/ui/status-bar/status-bar.tsx
similarity index 73%
rename from packages/data-solid-dashboard/src/components/status-bar.tsx
rename to packages/data-solid-dashboard/src/features/main/ui/status-bar/status-bar.tsx
index 26bdbe54..5f2cfe24 100644
--- a/packages/data-solid-dashboard/src/components/status-bar.tsx
+++ b/packages/data-solid-dashboard/src/features/main/ui/status-bar/status-bar.tsx
@@ -2,11 +2,11 @@
 
 import { createMemo } from "solid-js";
 import { fromObserve, useDatabase } from "@adobe/data-solid";
-import { dashboardPlugin } from "../state/dashboard-plugin";
-import * as presentation from "./status-bar.presentation";
+import { MainService } from "../../services/main-service/main-service.js";
+import * as presentation from "./status-bar.presentation.jsx";
 
 export function StatusBar() {
-  const db = useDatabase(dashboardPlugin);
+  const db = useDatabase(MainService.plugin);
   const userName = fromObserve(db.observe.resources.userName, "Guest");
   const count = fromObserve(db.observe.resources.count, 0);
   const log = fromObserve(db.observe.resources.log, []);
diff --git a/packages/data-solid-dashboard/src/main.tsx b/packages/data-solid-dashboard/src/main.tsx
index dfb12c85..8fbc4fd4 100644
--- a/packages/data-solid-dashboard/src/main.tsx
+++ b/packages/data-solid-dashboard/src/main.tsx
@@ -1,7 +1,7 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import { render } from "solid-js/web";
-import { App } from "./app";
+import { App } from "./features/main/ui/app/app.jsx";
 
 const root = document.getElementById("root");
 if (root) {
diff --git a/packages/data-solid-dashboard/src/state/dashboard-plugin.ts b/packages/data-solid-dashboard/src/state/dashboard-plugin.ts
deleted file mode 100644
index 9deb9151..00000000
--- a/packages/data-solid-dashboard/src/state/dashboard-plugin.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import { Database } from "@adobe/data/ecs";
-
-export const dashboardPlugin = Database.Plugin.create({
-  resources: {
-    count: { default: 0 as number },
-    log: { default: [] as readonly string[] },
-    userName: { default: "Guest" as string },
-  },
-  transactions: {
-    increment: (t) => {
-      t.resources.count += 1;
-      t.resources.log = [...t.resources.log, `Incremented to ${t.resources.count}`];
-    },
-    decrement: (t) => {
-      if (t.resources.count > 0) {
-        t.resources.count -= 1;
-        t.resources.log = [...t.resources.log, `Decremented to ${t.resources.count}`];
-      }
-    },
-    reset: (t) => {
-      t.resources.count = 0;
-      t.resources.log = [...t.resources.log, "Reset to 0"];
-    },
-    setUserName: (t, name: string) => {
-      t.resources.userName = name;
-      t.resources.log = [...t.resources.log, `Name changed to ${name}`];
-    },
-    clearLog: (t) => {
-      t.resources.log = [];
-    },
-  },
-});
diff --git a/packages/data-solid/package.json b/packages/data-solid/package.json
index 35bda073..55cd34bf 100644
--- a/packages/data-solid/package.json
+++ b/packages/data-solid/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@adobe/data-solid",
-  "version": "0.9.92",
+  "version": "0.9.93",
   "description": "Adobe data SolidJS bindings — context and provider for ECS database",
   "type": "module",
   "private": false,
diff --git a/packages/data-sync/package.json b/packages/data-sync/package.json
index 8481a413..31f2a680 100644
--- a/packages/data-sync/package.json
+++ b/packages/data-sync/package.json
@@ -1,6 +1,6 @@
 {
     "name": "@adobe/data-sync",
-    "version": "0.9.92",
+    "version": "0.9.93",
     "description": "Multi-user real-time synchronisation for @adobe/data ECS — server, client, and in-process loopback.",
     "type": "module",
     "sideEffects": false,
diff --git a/packages/data/package.json b/packages/data/package.json
index edb58236..d04b8478 100644
--- a/packages/data/package.json
+++ b/packages/data/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@adobe/data",
-  "version": "0.9.92",
+  "version": "0.9.93",
   "description": "Adobe data oriented programming library",
   "type": "module",
   "sideEffects": false,
@@ -91,6 +91,14 @@
     "hash-wasm": "^4.12.0",
     "jsonpath": "^1.1.1"
   },
+  "peerDependencies": {
+    "vitest": "^1.6.0"
+  },
+  "peerDependenciesMeta": {
+    "vitest": {
+      "optional": true
+    }
+  },
   "typesVersions": {
     "*": {
       "*": [
@@ -131,6 +139,9 @@
       ],
       "math": [
         "./dist/math/index.d.ts"
+      ],
+      "testing": [
+        "./dist/testing/index.d.ts"
       ]
     }
   },
@@ -139,6 +150,10 @@
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
+    "./testing": {
+      "import": "./dist/testing/index.js",
+      "types": "./dist/testing/index.d.ts"
+    },
     "./functions": {
       "import": "./dist/functions/index.js",
       "types": "./dist/functions/index.d.ts"
diff --git a/packages/data/src/testing/conformance/discover.ts b/packages/data/src/testing/conformance/discover.ts
new file mode 100644
index 00000000..c501dee6
--- /dev/null
+++ b/packages/data/src/testing/conformance/discover.ts
@@ -0,0 +1,56 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+// One discovered `data/state` file: its function and its cases.
+export interface Discovered {
+  readonly fn: (...args: unknown[]) => unknown;
+  readonly cases: readonly Record<string, unknown>[];
+}
+
+const scan = (
+  modules: Record<string, Record<string, unknown>>,
+  isKind: (firstCase: Record<string, unknown>) => boolean,
+): Map<string, Discovered> => {
+  const out = new Map<string, Discovered>();
+  for (const [path, module] of Object.entries(modules)) {
+    const names = Object.keys(module);
+    if (!names.includes("cases")) continue;
+    const cases = module["cases"];
+    if (!Array.isArray(cases) || cases.length === 0) continue;
+    const first = cases[0];
+    if (typeof first !== "object" || first === null || !isKind(first as Record<string, unknown>)) continue;
+    const fnName = names.find((key) => typeof module[key] === "function");
+    if (!fnName) throw new Error(`${path} exports \`cases\` but no function to pair`);
+    out.set(fnName, { fn: module[fnName] as Discovered["fn"], cases: cases as Discovered["cases"] });
+  }
+  return out;
+};
+
+// Transitions — files whose cases are `{ before, args?, after }` — keyed by the
+// transform's function name (the name the ecs transaction/action must share).
+export const discoverTransitions = (modules: Record<string, Record<string, unknown>>): Map<string, Discovered> =>
+  scan(modules, (c) => "after" in c);
+
+// Derivations — files whose cases are `{ input, value }` — keyed by the
+// derivation's function name (the name the ecs computed must share).
+export const discoverDerivations = (modules: Record<string, Record<string, unknown>>): Map<string, Discovered> =>
+  scan(modules, (c) => "value" in c);
+
+// Normalize the ecs-op source to `name → fn`. Accepts EITHER a facet barrel
+// (`import * as x` — values are the functions, keyed by export name) OR a directory
+// glob (`import.meta.glob(..., { eager: true })` — values are modules, each
+// contributing its function exports). The glob form finds ops that live beside a
+// barrel but aren't registered in it (a conformance-only action kept out of the
+// plugin facet), so they still pair by name.
+export const discoverOps = (source: Record<string, unknown>): Map<string, (...a: never[]) => unknown> => {
+  const out = new Map<string, (...a: never[]) => unknown>();
+  for (const [key, value] of Object.entries(source)) {
+    if (typeof value === "function") {
+      out.set(key, value as (...a: never[]) => unknown);
+    } else if (value !== null && typeof value === "object") {
+      for (const [name, member] of Object.entries(value)) {
+        if (typeof member === "function") out.set(name, member as (...a: never[]) => unknown);
+      }
+    }
+  }
+  return out;
+};
diff --git a/packages/data/src/testing/conformance/effects.type-test.ts b/packages/data/src/testing/conformance/effects.type-test.ts
new file mode 100644
index 00000000..72691120
--- /dev/null
+++ b/packages/data/src/testing/conformance/effects.type-test.ts
@@ -0,0 +1,59 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+//
+// Compile-time only (no runtime tests): proves the shared `Effects` conformance
+// shape accepts valid side-effect declarations and REJECTS invalid ones, ONCE for
+// the whole library rather than per feature. `tsc` checks this file; vitest does
+// not run it (it is not a `.test.ts`). If any `@ts-expect-error` stops erroring, or
+// any positive stops compiling, the build fails — which is the point.
+import type { Effects } from "./types.js";
+
+// A representative injected service, and a transition arg shape: plain data + the
+// service. (A stand-in for any feature's `SomethingService` — the type machinery
+// is identical, which is exactly why this test lives here and not per feature.)
+interface AnalyticsService {
+  readonly serviceName: "analytics";
+  todoCreated(input: { readonly name: string }): void;
+  todoToggled(): void;
+  allTodosCleared(): void;
+  displayCompletedToggled(): void;
+}
+type Args = { readonly name: string; readonly complete?: boolean; readonly analytics: AnalyticsService };
+
+// ===== POSITIVE — must compile =====
+const ordered: Effects<Args> = { analytics: [["todoCreated", { name: "a" }], ["todoToggled"]] };
+const anyOrder: Effects<Args> = {
+  analytics: new Set([["todoToggled"] as const, ["allTodosCleared"] as const]),
+};
+const noArgMethod: Effects<Args> = { analytics: [["displayCompletedToggled"]] };
+const empty: Effects<Args> = {};
+void ordered;
+void anyOrder;
+void noArgMethod;
+void empty;
+
+// ===== NEGATIVE — each must error =====
+const badMethod: Effects<Args> = {
+  // @ts-expect-error - "noSuchMethod" is not a method of AnalyticsService
+  analytics: [["noSuchMethod", { name: "a" }]],
+};
+const badArgs: Effects<Args> = {
+  // @ts-expect-error - todoCreated takes { name: string }, not { count }
+  analytics: [["todoCreated", { count: 1 }]],
+};
+const missingArgs: Effects<Args> = {
+  // @ts-expect-error - todoCreated requires its args element
+  analytics: [["todoCreated"]],
+};
+const extraArg: Effects<Args> = {
+  // @ts-expect-error - todoToggled takes no args
+  analytics: [["todoToggled", { name: "a" }]],
+};
+const dataKey: Effects<Args> = {
+  // @ts-expect-error - "name" is a data arg, not a service
+  name: [["todoCreated", { name: "a" }]],
+};
+void badMethod;
+void badArgs;
+void missingArgs;
+void extraArg;
+void dataKey;
diff --git a/packages/data/src/testing/conformance/entity-ref.ts b/packages/data/src/testing/conformance/entity-ref.ts
new file mode 100644
index 00000000..292ea7c2
--- /dev/null
+++ b/packages/data/src/testing/conformance/entity-ref.ts
@@ -0,0 +1,36 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Entity } from "../../ecs/entity/entity.js";
+import type { Resolve } from "./resolve.js";
+
+// A spec entity reference inside a case's `args`: `{ id: entity(1) }` names "the
+// entity seeded for spec-id 1". It closes the one irreducible spec↔ecs vocabulary
+// gap — identity: the pure spec reads the data-id, the ecs reads the entity the
+// runner resolves. Typed as the id it stands in for, so it slots into the
+// transform's own arg type (`{ id: number }`), exactly like `Match.anyNumber`.
+const ENTITY_REF = Symbol.for("@adobe/data/testing:entity-ref");
+
+export const entity = <T>(specId: T): T => ({ [ENTITY_REF]: specId }) as unknown as T;
+
+const isEntityRef = (value: unknown): value is { readonly [ENTITY_REF]: unknown } =>
+  typeof value === "object" && value !== null && ENTITY_REF in value;
+
+// Adapt a case's `args` for one side of the conformance. `resolve` present → the
+// ecs side (refs become seeded entities); absent → the pure-spec side (refs become
+// their data-id). Only the top-level arg values are inspected — a `ref` is always a
+// direct arg field. Non-ref values pass through untouched; a non-object `args`
+// (a scalar `dt`, or `undefined`) passes through whole.
+export const adaptArgs = <Args>(args: Args, resolve?: Resolve<unknown>): Args => {
+  if (args === null || typeof args !== "object" || Array.isArray(args)) return args;
+  let changed = false;
+  const next: Record<string, unknown> = { ...(args as object) };
+  for (const [key, value] of Object.entries(next)) {
+    if (isEntityRef(value)) {
+      const specId = value[ENTITY_REF];
+      next[key] = resolve ? (resolve(specId) as unknown) : specId;
+      changed = true;
+    }
+  }
+  return (changed ? next : args) as Args;
+};
+
+export type { Entity };
diff --git a/packages/data/src/testing/conformance/public.ts b/packages/data/src/testing/conformance/public.ts
new file mode 100644
index 00000000..bf546e41
--- /dev/null
+++ b/packages/data/src/testing/conformance/public.ts
@@ -0,0 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export type { Case, Cases, DerivationCase, DerivationCases, Effects, ServiceCall } from "./types.js";
+export { entity } from "./entity-ref.js";
+export { runSpec, type SpecRunConfig } from "./run-spec.js";
+export { runTransactions, type TransactionRunConfig } from "./run-transactions.js";
+export { runActions, type ActionRunConfig } from "./run-actions.js";
+export { runComputeds, type ComputedRunConfig } from "./run-computeds.js";
+export { runFeature, type FeatureRunConfig, type Projection } from "./run-feature.js";
diff --git a/packages/data/src/testing/conformance/record-effects.ts b/packages/data/src/testing/conformance/record-effects.ts
new file mode 100644
index 00000000..2db73639
--- /dev/null
+++ b/packages/data/src/testing/conformance/record-effects.ts
@@ -0,0 +1,118 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { equalsUnordered } from "../../equals-unordered.js";
+import { matches } from "../match/match.js";
+import type { Effects } from "./types.js";
+
+export type RecordedCall = readonly [string, ...unknown[]];
+
+// A runtime service value: a non-array object with at least one method (mirrors
+// the compile-time service detection in `types.ts`).
+const isServiceValue = (value: unknown): value is object =>
+  typeof value === "object" &&
+  value !== null &&
+  !Array.isArray(value) &&
+  Object.values(value).some((member) => typeof member === "function");
+
+// Wrap a plain-object service so each method call is recorded, then delegates.
+// No Proxy (services are plain objects with own enumerable methods), so we
+// enumerate and closure-wrap each function.
+export const recordCalls = <S extends object>(service: S): { service: S; calls: RecordedCall[] } => {
+  const calls: RecordedCall[] = [];
+  const wrapped = Object.fromEntries(
+    Object.entries(service).map(([key, value]) => [
+      key,
+      typeof value === "function"
+        ? (...args: unknown[]): unknown => {
+            calls.push([key, ...args]);
+            return (value as (...a: unknown[]) => unknown)(...args);
+          }
+        : value,
+    ]),
+  ) as S;
+  return { service: wrapped, calls };
+};
+
+// Wrap the injected services IN PLACE within a case's `args` (leaving plain data
+// untouched), returning the args ready to pass to a pure transform plus the
+// per-service `calls` map. Used by the pure spec runner, which calls the transform
+// with its full args; the ecs action runner uses `splitAndRecordServices` instead.
+export const recordArgServices = <Args>(
+  args: Args,
+): { args: Args; calls: Record<string, RecordedCall[]> } => {
+  const calls: Record<string, RecordedCall[]> = {};
+  if (args === null || typeof args !== "object" || Array.isArray(args)) return { args, calls };
+  const next = { ...(args as object) } as Record<string, unknown>;
+  for (const [key, value] of Object.entries(args as object)) {
+    if (isServiceValue(value)) {
+      const recorded = recordCalls(value);
+      next[key] = recorded.service;
+      calls[key] = recorded.calls;
+    }
+  }
+  return { args: next as Args, calls };
+};
+
+// Split a case's `args` into the injected services (wrapped for recording) and
+// the remaining plain data. Keyed by the same arg name so `calls` matches against
+// `effects`. A no-arg case (`undefined` args) splits into nothing.
+export const splitAndRecordServices = <Args>(
+  args: Args,
+): { services: Record<string, object>; input: Record<string, unknown>; calls: Record<string, RecordedCall[]> } => {
+  const services: Record<string, object> = {};
+  const input: Record<string, unknown> = {};
+  const calls: Record<string, RecordedCall[]> = {};
+  if (args !== null && typeof args === "object" && !Array.isArray(args)) {
+    for (const [key, value] of Object.entries(args)) {
+      if (isServiceValue(value)) {
+        const recorded = recordCalls(value);
+        services[key] = recorded.service;
+        calls[key] = recorded.calls;
+      } else {
+        input[key] = value;
+      }
+    }
+  }
+  return { services, input, calls };
+};
+
+const showCalls = (calls: unknown): string => {
+  try {
+    return JSON.stringify(calls) ?? String(calls);
+  } catch {
+    return String(calls);
+  }
+};
+
+// Assert the calls recorded against one service match the case's expectation for
+// it: an Array expects exactly these calls in order; a Set expects the same calls
+// in any order (multiset). Absent expectation ⇒ no calls expected. Ordered calls
+// compare matcher-aware, so a call arg may itself use `anyNumber`.
+const expectServiceCalls = (
+  key: string,
+  recorded: readonly RecordedCall[],
+  expected: readonly RecordedCall[] | ReadonlySet<RecordedCall> | undefined,
+): void => {
+  const ok =
+    expected instanceof Set ? equalsUnordered(recorded, [...expected]) : matches(recorded, expected ?? []);
+  if (!ok) {
+    throw new Error(
+      `effects mismatch on "${key}":\n  recorded: ${showCalls(recorded)}\n  expected: ${showCalls(
+        expected instanceof Set ? [...expected] : (expected ?? []),
+      )}`,
+    );
+  }
+};
+
+// Assert each service DECLARED in `effects` saw exactly its expected calls (an
+// extra or missing call on a declared service fails). Services not listed — e.g. a
+// value-returning read like `generateName` — are ignored, so `effects` captures the
+// fire-and-forget side effects a case chooses to assert.
+export const expectEffects = (
+  calls: Record<string, readonly RecordedCall[]>,
+  effects: Effects<Record<string, unknown>> | undefined,
+): void => {
+  const expected = (effects ?? {}) as Record<string, readonly RecordedCall[] | ReadonlySet<RecordedCall>>;
+  for (const key of Object.keys(expected)) {
+    expectServiceCalls(key, calls[key] ?? [], expected[key]);
+  }
+};
diff --git a/packages/data/src/testing/conformance/resolve.ts b/packages/data/src/testing/conformance/resolve.ts
new file mode 100644
index 00000000..052b3a9a
--- /dev/null
+++ b/packages/data/src/testing/conformance/resolve.ts
@@ -0,0 +1,16 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Entity } from "../../ecs/entity/entity.js";
+
+// Maps a spec-domain id to the ecs entity seeded for it. A feature's `fromState`
+// returns the `Id → Entity` map (it already loops its collections to seed); the
+// conformance runners turn that map into this resolver, so no feature writes id
+// resolution by hand. An id no entity carries resolves to `Entity.none`, so an
+// id-addressed transaction reads no such entity and is a no-op.
+export type Resolve<Id> = (id: Id) => Entity;
+
+// Build a resolver from a `fromState` seed map. A feature whose transactions are
+// addressed by index or are singleton (no id → entity mapping) returns `void`
+// from `fromState`; its resolver is then never called, and any id resolves to
+// `Entity.none`.
+export const resolver = <Id>(seeded: ReadonlyMap<Id, Entity> | void): Resolve<Id> => (id) =>
+  (seeded ? seeded.get(id) : undefined) ?? Entity.none;
diff --git a/packages/data/src/testing/conformance/run-actions.ts b/packages/data/src/testing/conformance/run-actions.ts
new file mode 100644
index 00000000..62df8b84
--- /dev/null
+++ b/packages/data/src/testing/conformance/run-actions.ts
@@ -0,0 +1,57 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it } from "vitest";
+import type { Entity } from "../../ecs/entity/entity.js";
+import { assert } from "../match/assert.js";
+import type { MatchOptions } from "../match/match.js";
+import { adaptArgs } from "./entity-ref.js";
+import { discoverTransitions, discoverOps } from "./discover.js";
+import { splitAndRecordServices, expectEffects } from "./record-effects.js";
+import { resolver } from "./resolve.js";
+
+// Discover transitions and the ecs actions (a facet barrel or a directory glob),
+// pair by name, and conform each — no per-item wiring. The action is the app-facing
+// seam: its injected services come from `db.services` (the case's service args
+// become recording overrides via `makeDb`), and its plain args are the case args
+// with service fields removed and `entity(specId)` markers resolved. Both the
+// resulting state and the declared `effects` are asserted. An action with no
+// same-named transition (e.g. a streaming port) is skipped.
+export interface ActionRunConfig<Db, Store, State> {
+  readonly makeDb: (services: Record<string, object>) => Db;
+  readonly store: (db: Db) => Store;
+  readonly fromState: (store: Store, before: State) => ReadonlyMap<unknown, Entity> | void;
+  readonly toState: (store: Store) => State;
+  readonly transitions: Record<string, Record<string, unknown>>;
+  readonly actions: Record<string, unknown>;
+  // The feature's default `State`; each case's `before` is merged over it.
+  readonly initial?: State;
+  // Optional ambient, non-spec context a user-scoped feature needs before dispatch
+  // (e.g. the acting peer's `userId`) — the one seam not derivable from cases.
+  readonly seedContext?: (db: Db, before: State, args: unknown) => void;
+  readonly match?: MatchOptions;
+}
+
+// The single conformance test for every ecs action: each transition's cases run
+// against its same-named action, asserting state and the declared effects.
+export function runActions<Db, Store, State>(config: ActionRunConfig<Db, Store, State>): void {
+  const transitions = discoverTransitions(config.transitions);
+  for (const [name, action] of discoverOps(config.actions)) {
+    const paired = transitions.get(name);
+    if (!paired) continue; // action with no transition (e.g. a streaming port) — not conformed here
+    describe(`${name} action conforms`, () => {
+      for (const testCase of paired.cases) {
+        it(testCase.name as string, async () => {
+          const { services, input, calls } = splitAndRecordServices(testCase.args);
+          // Case `before` is a delta over the feature default.
+          const before = { ...(config.initial ?? {}), ...(testCase.before as object) } as State;
+          const db = config.makeDb(services);
+          const resolve = resolver(config.fromState(config.store(db), before));
+          config.seedContext?.(db, before, testCase.args);
+          await (action as (d: Db, a?: unknown) => Promise<void> | void)(db, adaptArgs(input, resolve));
+          // `after` is a writes patch — compare `toState` against it merged over `before`.
+          assert(config.toState(config.store(db)), { ...(before as object), ...(testCase.after as object) }, config.match);
+          expectEffects(calls, testCase.effects as never);
+        });
+      }
+    });
+  }
+}
diff --git a/packages/data/src/testing/conformance/run-computeds.ts b/packages/data/src/testing/conformance/run-computeds.ts
new file mode 100644
index 00000000..2cbc6ef5
--- /dev/null
+++ b/packages/data/src/testing/conformance/run-computeds.ts
@@ -0,0 +1,68 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it } from "vitest";
+import type { Observe } from "../../observe/index.js";
+import type { Entity } from "../../ecs/entity/entity.js";
+import { assert } from "../match/assert.js";
+import type { MatchOptions } from "../match/match.js";
+import { discoverDerivations, discoverOps } from "./discover.js";
+
+// Read a computed's synchronous emission: subscribe once, capture, unsubscribe.
+const readComputed = <T>(observe: Observe<T>): T => {
+  let value!: T;
+  let read = false;
+  const unsubscribe = observe((next) => {
+    value = next;
+    read = true;
+  });
+  unsubscribe();
+  if (!read) throw new Error("computed did not emit synchronously on subscribe");
+  return value;
+};
+
+// Auto-pairing config: discover derivations and the registered computeds, pair by
+// name, and conform each — no per-item wiring. A computed with no same-named
+// derivation is skipped (single-`data/<type>` math is covered by that helper's own
+// test). The comparison is identity by default; a computed that emits an entity-id
+// list names itself in `hydrate` so the runner maps each id through `toData` into
+// the value shape the derivation yields.
+export interface ComputedRunConfig<Db, Store, State> {
+  readonly makeDb: () => Db;
+  readonly store: (db: Db) => Store;
+  readonly fromState: (store: Store, input: State) => unknown;
+  readonly toData?: (store: Store, entity: Entity) => unknown;
+  readonly derivations: Record<string, Record<string, unknown>>;
+  readonly computeds: Record<string, unknown>;
+  readonly hydrate?: readonly string[];
+  // The feature's default `State`; each case's `input` is merged over it before
+  // seeding, so a derivation case names only the fields it reads.
+  readonly initial?: State;
+  readonly match?: MatchOptions;
+}
+
+// The single conformance test for every ecs computed backing a `data/state`
+// derivation. Build `makeDb` from the `ComputedDatabase` layer (not the assembled
+// db): a behaviour layer above may `withCache` a pre-seed value that a direct
+// `fromState` seed cannot invalidate.
+export function runComputeds<Db, Store, State>(config: ComputedRunConfig<Db, Store, State>): void {
+  const derivations = discoverDerivations(config.derivations);
+  const hydrate = new Set(config.hydrate ?? []);
+  for (const [name, computed] of discoverOps(config.computeds)) {
+    const paired = derivations.get(name);
+    if (!paired) continue; // computed with no `state/` derivation — covered by its data/<type> helper
+    describe(`${name} computed conforms`, () => {
+      for (const testCase of paired.cases) {
+        it(testCase.name as string, () => {
+          const db = config.makeDb();
+          const input = { ...(config.initial ?? {}), ...(testCase.input as object) } as State;
+          config.fromState(config.store(db), input);
+          const raw = readComputed((computed as (d: Db) => Observe<unknown>)(db));
+          const value =
+            hydrate.has(name) && config.toData
+              ? (raw as readonly Entity[]).map((e) => config.toData!(config.store(db), e))
+              : raw;
+          assert(value, testCase.value, config.match);
+        });
+      }
+    });
+  }
+}
diff --git a/packages/data/src/testing/conformance/run-feature.ts b/packages/data/src/testing/conformance/run-feature.ts
new file mode 100644
index 00000000..2bbf15b7
--- /dev/null
+++ b/packages/data/src/testing/conformance/run-feature.ts
@@ -0,0 +1,117 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it } from "vitest";
+import { Database, Store } from "../../ecs/index.js";
+import type { Entity } from "../../ecs/entity/entity.js";
+import { assert } from "../match/assert.js";
+import type { MatchOptions } from "../match/match.js";
+import { runTransactions } from "./run-transactions.js";
+import { runActions } from "./run-actions.js";
+import { runComputeds } from "./run-computeds.js";
+
+// The feature's ecs↔`State` projection — the one genuinely feature-specific piece.
+export interface Projection<Store, State> {
+  readonly fromState: (store: Store, state: State) => ReadonlyMap<unknown, Entity> | void;
+  readonly toState: (store: Store) => State;
+  readonly toData?: (store: Store, entity: Entity) => unknown;
+}
+
+// One call conforms a whole feature. The runner pulls the ops off the plugin's
+// registered facets (`plugin.transactions` / `plugin.actions` /
+// `computedPlugin.computed`) and constructs the stores/dbs itself, so a feature
+// supplies only its `State` namespace (default + representative samples), the
+// `data/state` glob (the `{ fn, cases }` source), the plugin(s), and its
+// projection. It runs the transaction, action, and computed conformance plus a
+// projection round-trip (`toState ∘ fromState ≡ identity`) over `State.samples`.
+//
+// A feature whose ops aren't registered in the facet (a conformance-only action),
+// or that needs ambient per-case context (a user-scoped `userId`), uses the
+// lower-level `runTransactions`/`runActions`/`runComputeds` directly instead.
+export interface FeatureRunConfig<State, StoreT, Db extends { store: StoreT }> {
+  // The `State` namespace: `create()` is the default seed each case's `before`
+  // deltas over; `samples` (optional) are representative full states for the
+  // projection round-trip.
+  readonly state: { create(): State; readonly samples?: readonly State[] };
+  // `import.meta.glob(["../../../data/state/*.ts", "!**/*.test.ts", "!**/*.type-test.ts"], { eager: true })`.
+  readonly transitions: Record<string, Record<string, unknown>>;
+  // The assembled feature plugin (`MainService.plugin`) — its `.transactions` and
+  // `.actions` facets are the ops, and it builds the transaction store + action db.
+  readonly plugin: Database.Plugin;
+  // The `ComputedDatabase` layer plugin — its `.computed` facet is the ops, built
+  // from this layer for seed-freshness. Omit when the feature has no derivations.
+  readonly computedPlugin?: Database.Plugin;
+  readonly projection: Projection<StoreT, State>;
+  // Names of computeds that emit an entity-id list (hydrated through `toData`).
+  readonly hydrate?: readonly string[];
+  readonly match?: MatchOptions;
+  // Override the ops discovered from the plugin when they aren't registered in a
+  // facet (e.g. per-transition actions kept out of the plugin to bound its type).
+  readonly ops?: {
+    readonly transactions?: Record<string, unknown>;
+    readonly actions?: Record<string, unknown>;
+    readonly computeds?: Record<string, unknown>;
+  };
+}
+
+// Runtime invariant: a plugin object carries its registered facet maps (see
+// `create-plugin.ts`), so this reads the ops directly off it.
+type PluginFacets = { transactions: Record<string, unknown>; actions: Record<string, unknown>; computed: Record<string, unknown> };
+
+export function runFeature<State, StoreT, Db extends { store: StoreT }>(
+  config: FeatureRunConfig<State, StoreT, Db>,
+): void {
+  const initial = config.state.create();
+  const { fromState, toState, toData } = config.projection;
+  const facets = config.plugin as unknown as PluginFacets;
+  // A plugin carries the schema facets, so `Store.create` / `Database.create`
+  // accept it; the resulting store/db is the projection's `StoreT`/`Db`.
+  const makeStore = (): StoreT => Store.create(config.plugin as never) as StoreT;
+
+  runTransactions<StoreT, State>({
+    createStore: makeStore,
+    fromState,
+    toState,
+    initial,
+    transitions: config.transitions,
+    transactions: config.ops?.transactions ?? facets.transactions,
+    match: config.match,
+  });
+
+  runActions<Db, StoreT, State>({
+    makeDb: (services) => Database.toSystemDatabase(Database.create(config.plugin as never, { services })) as unknown as Db,
+    store: (db) => db.store,
+    fromState,
+    toState,
+    initial,
+    transitions: config.transitions,
+    actions: config.ops?.actions ?? facets.actions,
+    match: config.match,
+  });
+
+  if (config.computedPlugin) {
+    const computedFacets = config.computedPlugin as unknown as PluginFacets;
+    runComputeds<Db, StoreT, State>({
+      makeDb: () => Database.toSystemDatabase(Database.create(config.computedPlugin as never)) as unknown as Db,
+      store: (db) => db.store,
+      fromState,
+      toData,
+      initial,
+      derivations: config.transitions,
+      computeds: config.ops?.computeds ?? computedFacets.computed,
+      hydrate: config.hydrate,
+      match: config.match,
+    });
+  }
+
+  const samples = config.state.samples ?? [];
+  if (samples.length > 0) {
+    describe("projection round-trips (toState ∘ fromState ≡ identity)", () => {
+      samples.forEach((sample, index) => {
+        it(`sample ${index}`, () => {
+          const store = makeStore();
+          fromState(store, sample);
+          assert(toState(store), sample, config.match);
+        });
+      });
+    });
+  }
+}
diff --git a/packages/data/src/testing/conformance/run-spec.ts b/packages/data/src/testing/conformance/run-spec.ts
new file mode 100644
index 00000000..a3fe0a53
--- /dev/null
+++ b/packages/data/src/testing/conformance/run-spec.ts
@@ -0,0 +1,89 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it } from "vitest";
+import { assert } from "../match/assert.js";
+import type { MatchOptions } from "../match/match.js";
+import { adaptArgs } from "./entity-ref.js";
+import { recordArgServices, expectEffects } from "./record-effects.js";
+import type { DerivationCase, Effects } from "./types.js";
+
+const isDerivationCase = (c: unknown): c is DerivationCase<unknown, unknown> =>
+  typeof c === "object" && c !== null && "value" in c;
+
+export interface SpecRunConfig {
+  // The feature's `State` namespace (the same `state` `runFeature` takes). Its
+  // `create()` is the default each case's `before` deltas over, so a case names
+  // only the fields it sets differently. Omit it and cases must carry a full `before`.
+  readonly state?: { create(): object };
+  // `import.meta.glob(["./*.ts", "!./*.test.ts", "!./*.type-test.ts"], { eager: true })`
+  // — the same `transitions` glob `runFeature` takes.
+  readonly transitions: Record<string, Record<string, unknown>>;
+  // Passed through to `matches` (float tolerance, unordered collections).
+  readonly match?: MatchOptions;
+  // Override the `describe` label per module (default `State.<fnName>`).
+  readonly label?: (path: string, fnName: string | undefined) => string;
+}
+
+// The single pure-spec test for every transform AND derivation in a `data/state/`
+// folder. It auto-discovers each file that exports `cases`, requires that file to
+// export exactly its function plus `cases`, and dispatches on case shape: a `value`
+// case checks a derivation `(state) => value`; otherwise a transition `(state,
+// args) => state`, whose declared `effects` on injected services are also asserted.
+// A service-injected transition is async, so results are awaited uniformly.
+export const runSpec = (config: SpecRunConfig): void => {
+  for (const [path, module] of Object.entries(config.transitions)) {
+    const exportNames = Object.keys(module);
+    if (!exportNames.includes("cases")) continue;
+    const functionNames = exportNames.filter(
+      (key) => typeof module[key] === "function",
+    );
+    const fnName = functionNames.length === 1 ? functionNames[0] : undefined;
+    const label = config.label
+      ? config.label(path, fnName)
+      : `State.${fnName ?? path}`;
+    describe(label, () => {
+      if (exportNames.length !== 2 || functionNames.length !== 1) {
+        it("exports exactly its function and `cases`", () => {
+          throw new Error(
+            `${path} exports [${exportNames.join(", ")}] — expected one function + cases`,
+          );
+        });
+        return;
+      }
+      // Runtime invariant: a participating file exports one function and its cases.
+      const fn = module[functionNames[0]] as (...args: unknown[]) => unknown;
+      const cases = module["cases"] as readonly unknown[];
+      for (const testCase of cases) {
+        if (isDerivationCase(testCase)) {
+          it(testCase.name, () =>
+            assert(fn(testCase.input), testCase.value, config.match),
+          );
+          continue;
+        }
+        const tc = testCase as {
+          readonly name: string;
+          readonly before: unknown;
+          readonly args?: unknown;
+          readonly after: unknown;
+          readonly effects?: Effects<Record<string, unknown>>;
+        };
+        it(tc.name, async () => {
+          // Unwrap `entity(specId)` markers to their data-id for the pure spec, then
+          // wrap injected services so their calls are recorded.
+          const { args, calls } = recordArgServices(adaptArgs(tc.args));
+          // Case `before` is a delta over the feature default; `after` a writes patch.
+          const before = {
+            ...(config.state?.create() ?? {}),
+            ...(tc.before as Record<string, unknown>),
+          };
+          const result = (await fn(before, args)) as Record<string, unknown>;
+          assert(
+            { ...before, ...result },
+            { ...before, ...(tc.after as Record<string, unknown>) },
+            config.match,
+          );
+          expectEffects(calls, tc.effects);
+        });
+      }
+    });
+  }
+};
diff --git a/packages/data/src/testing/conformance/run-transactions.ts b/packages/data/src/testing/conformance/run-transactions.ts
new file mode 100644
index 00000000..686396c9
--- /dev/null
+++ b/packages/data/src/testing/conformance/run-transactions.ts
@@ -0,0 +1,58 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it } from "vitest";
+import type { Entity } from "../../ecs/entity/entity.js";
+import { assert } from "../match/assert.js";
+import type { MatchOptions } from "../match/match.js";
+import { adaptArgs } from "./entity-ref.js";
+import { discoverTransitions, discoverOps } from "./discover.js";
+import { resolver } from "./resolve.js";
+
+// Discover transitions (the `data/state` glob) and the ecs transactions (a facet
+// barrel or a directory glob), pair them by name, and conform each — no per-item
+// wiring. A transaction with no same-named transition is infrastructure (e.g.
+// `setInput`) or system-dispatched and is skipped; a transition realized by an
+// action is conformed there. Entity-addressed args carry a `Conformance.entity`
+// marker the runner resolves; a transaction ignores any injected-service arg (its
+// effects are asserted through the action).
+export interface TransactionRunConfig<Store, State> {
+  readonly createStore: () => Store;
+  readonly fromState: (store: Store, before: State) => ReadonlyMap<unknown, Entity> | void;
+  readonly toState: (store: Store) => State;
+  // `import.meta.glob("../../../data/state/*.ts", { eager: true })`.
+  readonly transitions: Record<string, Record<string, unknown>>;
+  // `import * as transactions from ".../transactions/index.js"`, OR a directory
+  // glob when ops live beside a barrel they aren't registered in.
+  readonly transactions: Record<string, unknown>;
+  // The feature's default `State`; each case's `before` is merged over it, so a
+  // case names only what differs from the default.
+  readonly initial?: State;
+  // Optional ambient, non-spec context a user-scoped feature needs before the raw
+  // transaction runs (e.g. seed the acting peer's `userId`) — the one seam not
+  // derivable from cases. Runs after `fromState`, before the transaction.
+  readonly seedContext?: (store: Store, before: State, args: unknown) => void;
+  readonly match?: MatchOptions;
+}
+
+// The single conformance test for every ecs transaction, proving
+// `toState(apply(fromState(before), args)) ≡ after` for each shared case.
+export function runTransactions<Store, State>(config: TransactionRunConfig<Store, State>): void {
+  const transitions = discoverTransitions(config.transitions);
+  for (const [name, transaction] of discoverOps(config.transactions)) {
+    const paired = transitions.get(name);
+    if (!paired) continue; // infrastructure / system-dispatched — no transition to conform to
+    describe(`${name} transaction conforms`, () => {
+      for (const testCase of paired.cases) {
+        it(testCase.name as string, () => {
+          // Case `before` is a delta over the feature default.
+          const before = { ...(config.initial ?? {}), ...(testCase.before as object) } as State;
+          const store = config.createStore();
+          const resolve = resolver(config.fromState(store, before));
+          config.seedContext?.(store, before, testCase.args);
+          (transaction as (s: Store, a?: unknown) => void)(store, adaptArgs(testCase.args, resolve));
+          // `after` is a writes patch — compare `toState` against it merged over `before`.
+          assert(config.toState(store), { ...(before as object), ...(testCase.after as object) }, config.match);
+        });
+      }
+    });
+  }
+}
diff --git a/packages/data/src/testing/conformance/types.ts b/packages/data/src/testing/conformance/types.ts
new file mode 100644
index 00000000..e5574fea
--- /dev/null
+++ b/packages/data/src/testing/conformance/types.ts
@@ -0,0 +1,72 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+// A service arg is an object with method members (not an array, not a function);
+// this is what distinguishes an injected service from plain data args.
+type MethodKeys<T> = { [K in keyof T]-?: T[K] extends (...a: never[]) => unknown ? K : never }[keyof T];
+type IsService<T> = T extends readonly unknown[]
+  ? false
+  : T extends (...a: never[]) => unknown
+    ? false
+    : T extends object
+      ? [MethodKeys<T>] extends [never]
+        ? false
+        : true
+      : false;
+
+// A strongly-typed call to one method of service `S`: `[methodName, ...its args]`.
+// A no-arg method is just `[methodName]`.
+export type ServiceCall<S> = {
+  [M in keyof S]-?: S[M] extends (...a: infer A) => unknown ? readonly [M, ...A] : never;
+}[keyof S];
+
+// Expected side effects for a case, keyed by the service-typed args only. An
+// `Array` value asserts these calls in this order; a `Set` value asserts the same
+// calls in any order. Method names and their args are checked against the service.
+export type Effects<Args> = {
+  readonly [K in keyof Args as IsService<Args[K]> extends true ? K : never]?:
+    | readonly ServiceCall<Args[K]>[]
+    | ReadonlySet<ServiceCall<Args[K]>>;
+};
+
+// The case `args` type read from a transform's own signature — its second
+// parameter, or `void` when it takes none.
+type ArgsOf<F extends (...args: never[]) => unknown> = Parameters<F> extends [unknown, infer Args, ...unknown[]]
+  ? Args
+  : void;
+
+// One spec-owned conformance case, authored as **deltas over the feature default**
+// (the runner's `initial` state). `before` lists only the fields this case sets
+// differently from the default; `after` is the transform's **writes patch** — only
+// the fields it changes. The runner seeds `{ ...initial, ...before }` and compares
+// against `{ ...initial, ...before, ...after }`, so every field a case doesn't
+// mention is the default and stays unchanged. (A full `before`/`after` still works
+// — it just overrides the default wholesale.) `args` is OMITTABLE exactly when the
+// transform takes none. Shared by the spec aggregator and the ecs runners.
+export type Case<State, Args> = {
+  readonly name: string;
+  readonly before: Partial<State>;
+  readonly after: Partial<State>;
+  readonly effects?: Effects<Args>;
+} & ([Args] extends [void] ? { readonly args?: undefined } : { readonly args: Args });
+
+// A transform's cases, with the case `args` derived from the transform's own
+// signature — author `export const cases: Conformance.Cases<State, typeof theTransform>`
+// (features alias it to a one-arg `Cases<F>` binding `State` once), so the cases
+// cannot drift from what the function accepts.
+export type Cases<State, F extends (...args: never[]) => unknown> = readonly Case<State, ArgsOf<F>>[];
+
+// One case for a derivation (`(state) => value`): a state `input` and the `value`
+// it yields. `value` may use asymmetric matchers. Both the pure derivation and its
+// ecs computed are checked against these.
+export type DerivationCase<Input, Value> = {
+  readonly name: string;
+  readonly input: Input;
+  readonly value: Value;
+};
+
+// A derivation's cases, with `input` and `value` read from the derivation's own
+// signature — the `Cases` analog for value-producing derivations.
+export type DerivationCases<F extends (...args: never[]) => unknown> = readonly DerivationCase<
+  Parameters<F>[0],
+  ReturnType<F>
+>[];
diff --git a/packages/data/src/testing/index.ts b/packages/data/src/testing/index.ts
new file mode 100644
index 00000000..992015f4
--- /dev/null
+++ b/packages/data/src/testing/index.ts
@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+// Shared test-only utilities for the spec↔ecs conformance pattern. Two namespaces:
+//   Match       — tolerant, matcher-aware value comparison (framework-agnostic).
+//   Conformance — the case types, effect recording, id resolution, and the
+//                 spec/transaction/action/computed runner drivers.
+// Import only from `*.test.ts`; `sideEffects: false` keeps it out of app builds.
+export * as Match from "./match/public.js";
+export * as Conformance from "./conformance/public.js";
diff --git a/packages/data/src/testing/match/assert.ts b/packages/data/src/testing/match/assert.ts
new file mode 100644
index 00000000..d29ef78c
--- /dev/null
+++ b/packages/data/src/testing/match/assert.ts
@@ -0,0 +1,19 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { matches, type MatchOptions } from "./match.js";
+
+const show = (value: unknown): string => {
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+};
+
+// Throwing assertion built on `matches` — a mismatch throws an `Error` the test
+// runner reports. Framework-agnostic (no `expect` import), so it works under any
+// runner; the message shows both sides.
+export const assert = (actual: unknown, expected: unknown, options?: MatchOptions): void => {
+  if (!matches(actual, expected, options)) {
+    throw new Error(`match failed:\n  actual:   ${show(actual)}\n  expected: ${show(expected)}`);
+  }
+};
diff --git a/packages/data/src/testing/match/match.test.ts b/packages/data/src/testing/match/match.test.ts
new file mode 100644
index 00000000..44688e83
--- /dev/null
+++ b/packages/data/src/testing/match/match.test.ts
@@ -0,0 +1,51 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { matches, ref, anyNumber, anyString } from "./public.js";
+
+describe("Match.matches", () => {
+  it("compares plain structures deeply", () => {
+    expect(matches({ a: 1, b: [2, 3] }, { a: 1, b: [2, 3] })).toBe(true);
+    expect(matches({ a: 1 }, { a: 2 })).toBe(false);
+    expect(matches({ a: 1, b: 2 }, { a: 1 })).toBe(false); // extra key on actual
+  });
+
+  it("absorbs F32/f64 and trig float noise onto the tolerance grid", () => {
+    expect(matches(Math.fround(0.1), 0.1)).toBe(true);
+    expect(matches(3e-15, 0)).toBe(true);
+    expect(matches(0.5, 0.5001)).toBe(true); // within 0.01
+    expect(matches(0.5, 0.52)).toBe(false); // outside 0.01
+    expect(matches(-0, 0)).toBe(true);
+  });
+
+  it("honors anyNumber / anyString and vitest-style asymmetric matchers", () => {
+    expect(matches({ id: 42, name: "x" }, { id: anyNumber, name: anyString })).toBe(true);
+    expect(matches({ id: "no" }, { id: anyNumber })).toBe(false);
+    expect(matches(7, expect.any(Number))).toBe(true);
+  });
+
+  it("compares arrays in order by default, as multisets when named", () => {
+    expect(matches([1, 2, 3], [1, 2, 3])).toBe(true);
+    expect(matches([1, 2, 3], [3, 2, 1])).toBe(false);
+    const opts = { unordered: new Set(["bag"]) };
+    expect(matches({ bag: [1, 2, 3] }, { bag: [3, 1, 2] }, opts)).toBe(true);
+    expect(matches({ bag: [1, 2] }, { bag: [1, 2, 3] }, opts)).toBe(false);
+  });
+
+  describe("ref — id correspondence up to renaming", () => {
+    it("binds a label to the first actual and requires later ones to match", () => {
+      // Same ecs id in two places must be the same actual value.
+      expect(matches({ sel: 100, items: [{ id: 100 }] }, { sel: ref("a"), items: [{ id: ref("a") }] })).toBe(
+        true,
+      );
+      // A dangling reference (sel points at an id no item has) fails.
+      expect(matches({ sel: 999, items: [{ id: 100 }] }, { sel: ref("a"), items: [{ id: ref("a") }] })).toBe(
+        false,
+      );
+    });
+
+    it("is injective — two labels cannot bind the same actual", () => {
+      expect(matches([5, 6], [ref("a"), ref("b")])).toBe(true);
+      expect(matches([5, 5], [ref("a"), ref("b")])).toBe(false);
+    });
+  });
+});
diff --git a/packages/data/src/testing/match/match.ts b/packages/data/src/testing/match/match.ts
new file mode 100644
index 00000000..2d410dbb
--- /dev/null
+++ b/packages/data/src/testing/match/match.ts
@@ -0,0 +1,102 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+// Options controlling the tolerant structural comparison.
+export interface MatchOptions {
+  // Object keys whose array values compare as multisets (order-independent) at
+  // any depth — for ecs entity collections materialised in nondeterministic row
+  // order. Every other array stays order-sensitive (positional tuples like a
+  // `Vec2`, or a display-ordered list whose order a case verifies).
+  readonly unordered?: ReadonlySet<string>;
+  // Float grid that absorbs F32↔f64 storage rounding and trig epsilon. Numbers
+  // are snapped to this grid before comparing. Default `0.01`.
+  readonly tolerance?: number;
+}
+
+// A `ref(label)` on the EXPECTED side asserts id CORRESPONDENCE without pinning
+// the value: the first occurrence of a label binds to whatever actual value sits
+// there; later occurrences of the same label must equal that binding, and two
+// labels can never bind the same actual (a bijection). This checks that ecs ids
+// line up structurally — e.g. a `selectedId` points at the entity a case means —
+// even though the ecs assigns ids from its own space. For an id a case does not
+// care about, use `anyNumber` instead.
+const REF = Symbol.for("@adobe/data/testing:ref");
+export const ref = (label: string): { readonly [REF]: string } => ({ [REF]: label });
+const isRef = (value: unknown): value is { readonly [REF]: string } =>
+  typeof value === "object" && value !== null && REF in value;
+
+// An asymmetric matcher (this module's `anyNumber`/`anyString`, or vitest's
+// `expect.any(...)`): honored on the EXPECTED side so a case asserts a shape it
+// does not pin. Recognised structurally, so no test framework is imported.
+const isMatcher = (value: unknown): value is { asymmetricMatch(actual: unknown): boolean } =>
+  typeof value === "object" &&
+  value !== null &&
+  typeof (value as { asymmetricMatch?: unknown }).asymmetricMatch === "function";
+
+const quantize = (n: number, tolerance: number): number => {
+  const factor = 1 / tolerance;
+  return Math.round(Math.fround(n) * factor) / factor + 0; // `+ 0` normalises `-0` to `0`
+};
+
+// Multiset (order-independent) match: greedy pairing, sufficient for concrete
+// values. Elements compare with the ordered, matcher-aware path; `ref` bindings
+// do not cross element boundaries here (ids in bags are `anyNumber`, not refs).
+const matchesUnordered = (
+  actual: readonly unknown[],
+  expected: readonly unknown[],
+  options: MatchOptions,
+): boolean => {
+  if (actual.length !== expected.length) return false;
+  const used = new Array<boolean>(actual.length).fill(false);
+  return expected.every((exp) => {
+    const index = actual.findIndex((act, i) => !used[i] && matchesWith(act, exp, options, new Map()));
+    if (index < 0) return false;
+    used[index] = true;
+    return true;
+  });
+};
+
+const matchesWith = (
+  actual: unknown,
+  expected: unknown,
+  options: MatchOptions,
+  bindings: Map<string, unknown>,
+): boolean => {
+  if (isRef(expected)) {
+    const label = expected[REF];
+    if (bindings.has(label)) return Object.is(bindings.get(label), actual);
+    for (const bound of bindings.values()) if (Object.is(bound, actual)) return false; // injective
+    bindings.set(label, actual);
+    return true;
+  }
+  if (isMatcher(expected)) return expected.asymmetricMatch(actual);
+  if (typeof expected === "number" && typeof actual === "number") {
+    const tolerance = options.tolerance ?? 0.01;
+    return quantize(actual, tolerance) === quantize(expected, tolerance);
+  }
+  if (Array.isArray(expected)) {
+    if (!Array.isArray(actual) || actual.length !== expected.length) return false;
+    return expected.every((exp, index) => matchesWith(actual[index], exp, options, bindings));
+  }
+  if (expected !== null && typeof expected === "object") {
+    if (actual === null || typeof actual !== "object" || Array.isArray(actual)) return false;
+    const expectedKeys = Object.keys(expected as object);
+    const actualKeys = Object.keys(actual as object);
+    if (expectedKeys.length !== actualKeys.length) return false;
+    return expectedKeys.every((key) => {
+      const exp = (expected as Record<string, unknown>)[key];
+      const act = (actual as Record<string, unknown>)[key];
+      if (options.unordered?.has(key) && Array.isArray(exp) && Array.isArray(act)) {
+        return matchesUnordered(act, exp, options);
+      }
+      return matchesWith(act, exp, options, bindings);
+    });
+  }
+  return Object.is(actual, expected);
+};
+
+// Tolerant structural comparison: honors asymmetric matchers and `ref`
+// correspondence on the expected side, absorbs float noise, and compares arrays
+// in order except where `options.unordered` names a multiset collection. Pure
+// and framework-agnostic — `assert` wraps it for a throwing test assertion.
+export const matches = (actual: unknown, expected: unknown, options: MatchOptions = {}): boolean =>
+  matchesWith(actual, expected, options, new Map());
diff --git a/packages/data/src/testing/match/matchers.ts b/packages/data/src/testing/match/matchers.ts
new file mode 100644
index 00000000..f25b7e4f
--- /dev/null
+++ b/packages/data/src/testing/match/matchers.ts
@@ -0,0 +1,15 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+// Asymmetric matchers for a value a case does not pin — chiefly an entity `id`
+// the ecs assigns from its own id-space, so the spec and the ecs projection
+// satisfy the same case without agreeing on the value. Plain `{ asymmetricMatch }`
+// objects (no test-framework dependency), recognised by `matches` and
+// interchangeable with vitest's `expect.any(Number)` / `expect.any(String)`.
+const numberMatcher = { asymmetricMatch: (actual: unknown): boolean => typeof actual === "number" };
+const stringMatcher = { asymmetricMatch: (actual: unknown): boolean => typeof actual === "string" };
+
+// Typed as the value each stands in for (as vitest types `expect.any`), so it
+// slots into a pinned `number` / `string` field of a case's expected value;
+// `matches` recognises the object at runtime by its `asymmetricMatch` method.
+export const anyNumber = numberMatcher as unknown as number;
+export const anyString = stringMatcher as unknown as string;
diff --git a/packages/data/src/testing/match/public.ts b/packages/data/src/testing/match/public.ts
new file mode 100644
index 00000000..6d7c2d91
--- /dev/null
+++ b/packages/data/src/testing/match/public.ts
@@ -0,0 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { matches, ref, type MatchOptions } from "./match.js";
+export { assert } from "./assert.js";
+export { anyNumber, anyString } from "./matchers.js";
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index f4ad2f05..bcc4864e 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -489,6 +489,9 @@ importers:
       '@vitejs/plugin-react':
         specifier: ^4.3.0
         version: 4.3.0(vite@5.1.1)
+      jsdom:
+        specifier: ^24.1.0
+        version: 24.1.0
       typescript:
         specifier: ^5.8.3
         version: 5.8.3
@@ -498,6 +501,9 @@ importers:
       vite-plugin-checker:
         specifier: ^0.12.0
         version: 0.12.0(typescript@5.8.3)(vite@5.1.1)
+      vitest:
+        specifier: ^1.6.0
+        version: 1.6.0(@types/node@25.6.0)(@vitest/browser@1.6.0)(jsdom@24.1.0)
 
   packages/data-solid:
     dependencies:
@@ -527,6 +533,9 @@ importers:
         specifier: ^1.9.12
         version: 1.9.12
     devDependencies:
+      jsdom:
+        specifier: ^24.1.0
+        version: 24.1.0
       typescript:
         specifier: ^5.8.3
         version: 5.8.3
@@ -539,6 +548,9 @@ importers:
       vite-plugin-solid:
         specifier: ^2.11.0
         version: 2.11.0(solid-js@1.9.12)(vite@5.1.1)
+      vitest:
+        specifier: ^1.6.0
+        version: 1.6.0(@types/node@25.6.0)(@vitest/browser@1.6.0)(jsdom@24.1.0)
 
   packages/data-sync:
     dependencies: