diff --git a/.claude/plans/spf/discrete-signals-and-behavior-objects.md b/.claude/plans/spf/discrete-signals-and-behavior-objects.md
new file mode 100644
index 00000000..dc599ba4
--- /dev/null
+++ b/.claude/plans/spf/discrete-signals-and-behavior-objects.md
@@ -0,0 +1,463 @@
+---
+status: stages-A-B-C-D-shipped-pivoted-no-count-invariant
+branch: refactor/spf-discrete-signals-and-behavior-objects
+---
+
+# SPF: Discrete Signals + Behavior-as-Object
+
+> Captures a meeting follow-up on a coordinated set of architectural shifts in SPF. Stages A, B, C, and a scoped-down Stage D have landed. Stage D originally proposed a compose-time **writer-count invariant** (0-or-1 writer per signal) on top of per-slot read/write annotations — that part was dropped after the writer audit revealed multiple legitimate multi-writer patterns (intent+default, pipeline, two-way DOM sync). What shipped is the per-slot annotation work + writer audit; multi-writer slots are accepted as legitimate shapes. Findings feed back into `internal/design/spf/primitives.md` and `packages/spf/docs/hls-engine.md`.
+
+## Status snapshot
+
+- **Branch:** `refactor/spf-discrete-signals-and-behavior-objects` (off `docs/spf-hls-engine-composition`). Renamed from `refactor/spf-discrete-signals-stage-a` once scope expanded beyond Stage A.
+- **Stages A + B + C + D (scoped-down) complete** + engine-wrapper revisit + `buildSignalMap` export + Stage D-pre input mechanism (`shareSignals`) + per-slot read/write annotation propagation across all 17 behaviors. Tests green: 49 files, 759 tests passed.
+- **Build clean.** `pnpm typecheck`, `pnpm -F @videojs/spf test`, `pnpm exec biome check`, `pnpm check:workspace`, `pnpm build:packages` all pass.
+- **Stage D pivoted (no count invariant).** Per-slot `Signal<T>` (writable) / `ReadonlySignal<T>` (read-only) annotations are the contract — body-level write enforcement is shipped (commit `b7866e6a`). The originally-planned compose-time writer-count invariant ("0-or-1 writer behaviors per signal") was **dropped** once the writer audit (commit `c29fea1e`) confirmed that multi-writer slots are legitimate patterns, not violations. See `### Why we dropped the writer-count invariant` for the patterns and reasoning.
+- **Stage D-pre shipped.** The adapter's external writes flow through a generic `shareSignals` behavior factory: the engine instantiates `makeShareSignals<S, C>()` and the consumer captures writable signal refs via `config.onSignalsReady` at composition setup. Adapter migrated; sandbox harness rebuilt (also fixed: it had been on the pre-Stage-A monolithic API since Stage A landed). The 2-writer cases on `selectedVideoTrackId` / `selectedTextTrackId` are now documented in the writer audit as legitimate intent+default patterns; the harness's direct writes via `engine.state` retain `TODO(stage-d)` markers as cleanup hints (decompose into manual + ABR slots), but are no longer Stage D-blocking.
+- **Future follow-up:** custom linter rule that warns on multi-writer slots with an ignore-comment mechanism for intentional cases (`// writer-audit-allow: <reason>`). Captures the original Stage D intent (visibility into multi-writer cases) without forcing decomposition through types. See `### Follow-up: writer-audit lint rule`.
+- **Not yet:** PR opened; merge to main; doc updates to `hls-engine.md` / `fundamentals.md`.
+- **Memory:** `project_spf_stage_a_revisit.md` has the deeper "why we did it this way" notes for Stage A; updated for B/C carryovers.
+
+## Resuming — where to start the next session
+
+1. **Verify branch state.** `git log --oneline` should show recent commits including `c29fea1e docs(spf): add per-behavior + shareSignals writer audit to plan doc`, `b7866e6a refactor(spf): make per-slot read/write intent explicit in behaviors`, and `6b9801a4 refactor(spf): parameterize Behavior types over slot-map shapes`.
+2. **No major Stage D work pending.** The scoped-down Stage D shipped; the count invariant is dropped. Stage D's open questions (`### Open questions for Stage D implementation`) are largely resolved or moot.
+3. **Independent grooming work** (any order, can interleave):
+   - **Writer-audit lint rule.** The future follow-up — a custom rule that warns on multi-writer slots with a comment-based ignore mechanism for intentional cases. See `### Follow-up: writer-audit lint rule` for the sketch.
+   - **`selectedVideoTrackId` decomposition.** Replace the `abrDisabled` flag with a clean intent-vs-default split: separate `abrSelectedVideoTrackId` (written by `switchQuality`) and `manualSelectedVideoTrackId` (written by external code), derive `selectedVideoTrackId` as `manual ?? abr`. Already noted as a TODO at `quality-switching.ts:18`. Independent of Stage D.
+   - **Doc updates.** `packages/spf/docs/hls-engine.md` (parent `docs/spf-hls-engine-composition` branch) and `internal/design/spf/fundamentals.md` are stale. Refresh post-merge.
+   - **Code-reuse follow-up.** Three behavior modules (select-tracks, resolve-track, load-segments) lost some code reuse during the engine-wrapper revisit. Commit `77601054` documents the trade-off.
+   - **Open the PR.** Branch is shippable.
+
+## Stage A — what landed (early commits, pre-this-session)
+
+Stage A is on `refactor/spf-discrete-signals-stage-a` (10+ commits from `b00fa1a1` through `ad863bf1`). Key deviations from the original plan and details worth preserving live in the project memory: `project_spf_stage_a_revisit.md`. Highlights:
+
+- **Discrete signals + `owners` → `context`** as planned. Engine builds the signal maps externally and passes them to `createComposition`.
+- **Compose-time conflict detection preserved + tightened.** The first pass dropped the inferred-overload type machinery; we restored it and unified context conflicts with state (intersection-based; sibling-type context now correctly conflicts). The owners-subtype check is gone — context uses the same intersection rule as state.
+- **Single inferred overload only.** With discrete signals, the distributive-intersection inference issue from `044263f2` doesn't recur — the explicit-typed overload was removed. The HLS engine compiles cleanly with just the inferred form.
+- **All behaviors uniform.** Every behavior is now `Behavior<S, C, Cfg>` (single-arg BehaviorDeps shape — `{ state, context, config }`). The engine wrappers all read `({ config, ...deps }: Deps) => behavior({ ...deps, config: { type, ...config } })`.
+- **Engine config defaults `resolveTextTrackSegment`.** Removed the `setupTextTrackActors` engine wrapper that existed solely to inject the resolver.
+- **Latent bug fix:** `update-duration` referenced `videoSourceBuffer`/`audioSourceBuffer` keys the engine never wrote to; renamed to `videoBuffer`/`audioBuffer`.
+
+### Stage A side cleanups (not in original plan)
+
+- `selectVideoTrack` / `selectAudioTrack` collapsed into a single `selectMediaTrack` (bodies were byte-identical). **Note:** Stages B/C re-specialized them in commit `f6a7aecc` once narrow keys were unlocked; this Stage-A consolidation was the right move at the time but is no longer the final shape.
+- `QualitySwitchingConfig.defaultBandwidth` renamed to `initialBandwidth` for naming consistency with the engine config.
+- `switchQuality` reshaped to `({ state, config })` so the engine no longer needs a wrapper.
+- Conditional config-spreads in engine wrappers replaced with direct `{ type, ...config }` spreads (`exactOptionalPropertyTypes: false` on the SPF tsconfig made the conditional guards unnecessary).
+
+## Stage B — what landed (commits `5a39d4ef` → `550b7d6d`)
+
+Steps 1, 2a from the user's plan. Behaviors became objects with `defineBehavior(...)` factory enforcing single-behavior key/param consistency.
+
+- **Behaviors are now `{ stateKeys, contextKeys, setup }` objects** (`5a39d4ef`). Every behavior in `playback/behaviors/` was converted; engine wrappers were updated to wrap `.setup` calls.
+- **`defineBehavior<S, C, Cfg, SK, CK>` factory** with phantom-tag exhaustiveness check: declared `stateKeys` must equal `keyof S` (where S is inferred from the setup's `state` param type), same for `contextKeys` / `C`. Uses `const SK extends readonly (keyof S)[]` for literal-tuple capture (no `as const` needed at the call site).
+- **`DepsForCfg<S, C, Cfg>` conditional shape** — when a slice (state/context/config) has no keys, the corresponding deps field becomes optional. Lets test calls like `behavior.setup({state, context})` work without per-call `config: {}` boilerplate.
+- **`R` generic** preserves narrow setup return types (e.g. `() => void` instead of widening to the `BehaviorCleanup` union). Tests calling the cleanup directly without union-narrowing still typecheck.
+- **Tests added in `deda6ae1`** cover defineBehavior surface: 9 `@ts-expect-error` exhaustiveness cases, 10 `expectTypeOf` inference cases, 4 runtime-identity cases. Total +24 tests.
+- **`550b7d6d` consolidation:** the previous `create-composition-types.test.ts` was structurally typecheck-only (every test was `@ts-expect-error`-driven) but lived in a `.test.ts` file that runs at runtime. Two cases needed `if (Math.random() < 0)` runtime guards because the test bodies dereferenced missing config. Moved everything into `create-composition-types.test-d.ts` (typecheck-only via tsgo); the `Math.random` guards disappear since the file never executes.
+
+## Stage C — what landed (commits `6e518795` → `c2dfd365`)
+
+Step 2b + 3 from the user's plan. Composition derives signal maps internally; `initialState` / `initialContext` seed values.
+
+- **`createComposition` derives state/context signal maps** from the union of all behaviors' declared `stateKeys` / `contextKeys` (`6e518795`). Caller-supplied signal maps are gone — `CompositionOptions` is now just `{ config?, initialState?, initialContext? }`.
+- **Engine drops `createStateSignals` / `createContextSignals`** factories. `createSimpleHlsEngine` is now ~5 lines of "config + initialState" passed to `createComposition`.
+- **load-segments behavior fix** (same commit) — the previous `initialBandwidth !== undefined ? bridge : undefined` conditional was effectively always-true because the engine seeded `bandwidthState`. After 2b that became always-false, silently disabling ABR. Dropped the conditional — video tracks always bridge throughput updates back to engine state.
+- **`initialState` / `initialContext`** added in `c2dfd365` (`Partial<S>` / `Partial<C>`). Engine restores its `bandwidthState` seed via `initialState` so `switchQuality` fires on initial subscribe with the configured `initialBandwidth` fallback.
+- **`buildSignalMap` extracted, exported, tested** (`13046a01`, `4c66d394`):
+  - Functional pipeline: `flatMap → Set → Object.fromEntries`.
+  - Signature simplified from `(behaviors, keysOf, initial)` to `(keys: Iterable<PropertyKey>, initial: Partial<S>)`.
+  - Module-level export only (not in package's `index.ts` public API).
+  - 8 runtime tests + 7 type tests.
+- **Type cleanup in `21f43473`** — collapsed the two-overload pattern in `createComposition` into a single signature so the body has access to `Behaviors` directly. State/context inside the body are now typed as `StateSignals<ResolveBehaviorState<Behaviors>>` rather than the wide `Record<PropertyKey, Signal<unknown>>`. The runtime build still uses the wide shape (since TS can't follow imperative iteration), but the wide-to-narrow bridge is localized inside `buildSignalMap`. Two intentional casts remain in `createComposition` itself (the `behaviors as readonly AnyBehavior[]` for ValidateComposition, and the `config ?? {}` fallback when Cfg has no keys).
+
+## Engine-wrapper revisit (commits `f6a7aecc` → `e4ce10ae`)
+
+Originally flagged as "save for the end" of Stage B. The engine had 8 wrappers (`loadVideoSegments`, `selectAudioTrack`, `resolveTextTrack`, etc.) that each forwarded keys + reshaped config to inject a `type:` discriminant. We moved that specialization into the behavior modules, exporting per-type behaviors directly.
+
+- **`select-tracks.ts`** (`f6a7aecc`) — `selectMediaTrack` (one generic) split into `selectVideoTrack`, `selectAudioTrack`, `selectTextTrack`. Each declares narrow `stateKeys` (e.g. `selectVideoTrack` declares only `['presentation', 'selectedVideoTrackId']`). Bodies inlined; shared `pickFirstTrackId` helper for presentation traversal.
+- **`resolve-track.ts`** (`5c19b54a`) — `resolveTrack` split into `resolveVideoTrack`, `resolveAudioTrack`, `resolveTextTrack`. Body shared via `setupTrackResolution(state, type, selectedKey)` helper using a typed `K` generic over the selected-track key. State narrowed via `Pick<ResolveTrackState, 'presentation' | K>`.
+- **`load-segments.ts`** (`e4ce10ae`) — `loadSegments` split into `loadVideoSegments`, `loadAudioSegments`. Body shared via `setupSegmentLoading(state, context, type)` helper. **State/context keys still broad** — narrowing per specialization is a follow-up (see below).
+- **Engine** drops all 8 wrappers, the `Deps` shorthand, and the `StateSignals`/`ContextSignals` imports (no longer needed locally).
+
+## Stage D — pivoted: per-slot annotations are the contract
+
+The user's plan #4: read/write enforcement. **Shipped in scoped-down form (commit `b7866e6a`).** The original plan included a compose-time **writer-count invariant** ("0-or-1 writer behaviors per signal") on top of per-slot read/write annotations. The annotation work shipped; the count invariant was **dropped** after the writer audit (commit `c29fea1e`) confirmed multi-writer slots are legitimate patterns, not violations.
+
+### What shipped
+
+Behaviors declare per-slot access by typing the setup param's `state` / `context` slots as either `Signal<T>` (read+write) or `ReadonlySignal<T>` (read-only):
+
+```ts
+defineBehavior({
+  stateKeys: ['presentation', 'selectedVideoTrackId'],
+  setup: ({ state }: {
+    state: {
+      presentation: ReadonlySignal<MaybeResolvedPresentation | undefined>;
+      selectedVideoTrackId: Signal<string | undefined>;
+    };
+  }) => effect(() => { ... }),
+});
+```
+
+Why this works:
+
+- `ReadonlySignal<T>` already exists (`core/signals/primitives.ts`) as `Omit<Signal<T>, 'set'>`. The structural difference (no `.set`) drives body-level enforcement directly — TS rejects `.set()` on a slot typed as `ReadonlySignal<T>`. **No brands needed.**
+- `Behavior<>` / `BehaviorDeps<>` / `defineBehavior` are now parameterized over **slot maps** (`StateMap`, `ContextMap`) rather than data shapes (`S`, `C`). Slot maps are bounded as `Record<PropertyKey, ReadonlySignal<unknown>>` so heterogeneous slot maps (some writable, some read-only) typecheck cleanly. `StateSignals<S>` / `ContextSignals<C>` remain as helpers for "everything writable" cases (`Composition<S, C>`'s public surface still uses them — no read/write split externally).
+- Cross-behavior intersection (`InferBehaviorState` / `IntersectBehaviors`) is unchanged — `UnwrapSignals<M>` matches structurally on `{ get(): infer V }`, so both `Signal<T>` and `ReadonlySignal<T>` unwrap to `T`.
+
+All 17 playback behaviors were updated in commit `b7866e6a`. See `### Per-behavior writer audit (post-propagation)` for the full picture.
+
+### Why we dropped the writer-count invariant
+
+The original plan was: **0-or-1 writer behaviors per signal**, enforced at compose time via the type machinery. 0-writer slots would be required in `initialState`; 2+ writers would be a compile error.
+
+The writer audit revealed three legitimate multi-writer patterns we'd be ruling out:
+
+1. **Pipeline / patch** — `presentation` is written by the adapter (initial `{ url }` seed), then `resolvePresentation` (parses manifest), then `resolve{Video,Audio,Text}Track` (per-track segments), then `calculatePresentationDuration` (duration field). Each writer owns a different aspect of the same logical object. Forcing decomposition into separate `url` / `selectionSets` / `tracks.*.segments` / `duration` slots breaks the "presentation is one thing" model and pushes complexity to consumers (query 4 slots instead of 1). Forcing colocation breaks composition.
+
+2. **Intent + reactive default** — `selectedVideoTrackId` is written by `selectVideoTrack` (default-pick on presentation load), `switchQuality` (ABR), and external code (manual override, currently in the sandbox harness). Disambiguated today via the `abrDisabled` flag. A clean factoring exists (separate `abrSelectedVideoTrackId` + `manualSelectedVideoTrackId` slots, derive `selectedVideoTrackId` as `manual ?? abr` — see `quality-switching.ts:18`'s TODO), but we don't want to *force* this decomposition for every multi-writer case. The "two writers + mode-flag disambiguator" shape is sometimes the right answer.
+
+3. **Two-way DOM sync** — `preload` is written by `syncPreloadAttribute` (DOM → state mirror) and external code via `shareSignals` (state → drives downstream DOM behavior). The slot is a coordination point between observer and controller; both writers are legitimate.
+
+The 0-or-1 invariant would force decomposition for all three cases. That's too aggressive — it imposes a uniform shape on patterns that are genuinely different. Per-slot annotations alone (which we shipped) give us body-level write enforcement and self-documenting intent at the call site; the count invariant was layered on top but adds churn without proportional value.
+
+**Decision:** drop the count invariant. Multi-writer slots are legitimate. The writer audit (`### Per-behavior writer audit`) documents who writes what; review serves the same purpose the count invariant would have.
+
+### Composition surface stays writable (for now)
+
+The original plan made `composition.state` / `composition.context` **uniformly read-only externally** — all writes had to go through behaviors or the `shareSignals` callback. With the count invariant dropped, this enforcement isn't strictly necessary: the composition surface stays as `StateSignals<S>` / `ContextSignals<C>` (writable). External code can still write directly via `composition.state.X.set(...)` (the harness's deferred `selectedVideoTrackId` / `selectedTextTrackId` writes do this).
+
+Per-slot annotations are a **behavior-side** contract — they describe what each behavior reads and writes within its setup body. They're not a composition-surface contract today.
+
+### Follow-up: read-only public composition surface
+
+A future change could narrow `Composition<S, C>`'s public `state` and `context` to read-only views — `{ [K in keyof S]-?: ReadonlySignal<S[K]> }` — making `shareSignals` + `config.onSignalsReady` the *only* external write path. TypeScript-only narrowing is enough; the runtime signals stay writable, behaviors get the writable refs through deps, and `Signal<T>` is structurally assignable to `ReadonlySignal<T>` so no runtime change or cast is required at the boundary.
+
+**Why we'd want it:**
+
+- **One canonical write path.** Discoverability goes from "two ways, both legal" to "one way, with the type system pointing at it."
+- **Eliminates the harness's `TODO(stage-d)` direct writes** — they currently bypass `shareSignals` because they can. A read-only public surface forces them through the boundary.
+- **Per-slot annotations land naturally** at the consumer side too — the `onSignalsReady` callback can declare per-slot intent the same way behaviors do.
+
+**Why we deferred it:**
+
+- **Pedagogical cost.** `composition.state.x.set(...)` from outside is the simplest first thing to show in a tutorial. Forcing every external write through `shareSignals` makes the simplest examples one indirection deeper, which complicates the learning arc in `fundamentals.md`. A NOTE callout there flags the future direction without re-pivoting the doc's structure.
+- **Minor downstream churn.** Two harness writes need migration; tests that exercise behaviors via `composition.state.X.set()` would need to capture refs via `shareSignals` in their fixtures or call `behavior.setup` directly with hand-built slot maps. ~30–60 min of focused work, but not zero.
+
+**Preconditions when we revisit:**
+
+- The `selectedVideoTrackId` decomposition cleanup (`abrDisabled` → `manualSelectedVideoTrackId` + `abrSelectedVideoTrackId`, derived `selected = manual ?? abr`) is independent and can land before. Either order works.
+- Decide whether `fundamentals.md`'s early "drive from outside" pedagogy moves the writes inside a tiny `driveCount` behavior, or shifts to using `shareSignals` from the first example. The tradeoff is "introduce shareSignals before defineBehavior" vs. "show direct writes first, then converge on shareSignals later."
+
+Not in scope for the current branch. Worth a follow-up issue.
+
+### Follow-up: writer-audit lint rule
+
+A future custom linter rule could capture the original Stage D intent (visibility into multi-writer cases) without forcing decomposition through types:
+
+- **Detection.** Walk all `defineBehavior(...)` calls and `shareSignals.onSignalsReady` consumer callbacks; tally writers per slot.
+- **Warn on multi-writer slots.** Surface the writer list at each violating site so reviewers see the broader picture.
+- **Ignore mechanism.** A comment marker (e.g. `// writer-audit-allow: <reason>`) on the writing line opts the slot out of the warning. Forces the author to articulate intent ("this is the pipeline pattern" / "this is intent + default with `abrDisabled` mode flag" / "this is DOM ↔ state sync").
+- **Separate concerns.** Lives in tooling, not in types — keeps the type system simple and lets reviewers see the multi-writer landscape without compile-time churn.
+
+Not in scope for the current branch. Worth opening as a follow-up issue once the branch ships.
+
+### Stage D-pre — what landed (input mechanism)
+
+Stage D-pre routed external writes through a new generic behavior (`shareSignals`) so the call site for "external writes" became uniform. Originally framed as a precondition for Stage D's count invariant; with the invariant dropped, this work stands on its own as the canonical pattern for external writes. Audit (2026-05-04) showed the external writers to composition signals were:
+
+| Key | Slot | Trigger | Nature | Status |
+|---|---|---|---|---|
+| `mediaElement` | context | `attach()` / `detach()` | DOM lifecycle | ✅ migrated to `onSignalsReady` capture in adapter |
+| `preload` | state | `preload =` IDL setter | HTML attribute input | ✅ same |
+| `presentation` | state | `src =` IDL setter (writes `{ url }`) | HTML attribute input | ✅ same |
+| `playbackInitiated` | state | `play()` method | Imperative input | ✅ same |
+| `abrDisabled` | state | sandbox harness UI toggle | pure input, no overlap | ✅ same |
+| `selectedVideoTrackId` | state | sandbox harness rendition picker + `selectVideoTrack` (default-pick) + `switchQuality` (ABR) | **Multi-writer (intent + reactive default)** — accepted pattern; cleanup proposed at `quality-switching.ts:18` (decompose into `manualSelectedVideoTrackId` + `abrSelectedVideoTrackId`) |
+| `selectedTextTrackId` | state | sandbox harness auto-select + `selectTextTrack` (default-pick) + `syncTextTracks` (DOM-driven) | **Multi-writer** — accepted pattern; harness still writes directly with `TODO(stage-d)` markers as cleanup hints |
+
+**The harness was also on the pre-Stage-A monolithic API** (`engine.state.set({...engine.state.get(),...})` + `engine.owners`) since Stage A landed — broken at runtime, not just type-stale. Stage D-pre rebuilt it on the discrete-signals shape and routed all five non-overlap inputs through `onSignalsReady`. The two multi-writer cases stayed as direct writes via `engine.state` (no longer needing a reconciler — see "Reconciler shape — optional pattern").
+
+### Input mechanism — actual implementation (`shareSignals`)
+
+**The original sketch was more elaborate than what shipped.** The plan was to have the engine create a *separate* set of input signals, with `mirrorInputState` / `mirrorInputContext` behaviors copying each input → composition state, and `reconcileSelectedVideoTrackId` / `reconcileSelectedTextTrackId` replacing `selectVideoTrack` / `selectTextTrack`. Implementation collapsed that down: the "input signals" *are* the composition state signals — there's no parallel set, no mirror layer, and the two reconciler-overlap cases got deferred.
+
+What actually landed:
+
+1. **`shareSignals` is a generic behavior factory** in `core/composition/share-signals.ts`:
+   ```ts
+   export interface ShareSignalsConfig<S extends object, C extends object> {
+     onSignalsReady?: (signals: { state: StateSignals<S>; context: ContextSignals<C> }) => void;
+   }
+
+   export function makeShareSignals<S extends object, C extends object>(): Behavior<S, C, ShareSignalsConfig<S, C>> {
+     return {
+       stateKeys: [],
+       contextKeys: [],
+       setup: ({ state, context, config }) => {
+         config.onSignalsReady?.({ state, context });
+       },
+     };
+   }
+   ```
+   Uses a `Behavior<S, C, Cfg>` literal (not `defineBehavior`) so empty key arrays don't trip the exhaustiveness check. Its setup-param S/C describe what the consumer's callback receives, not keys this behavior needs created — the composition's signal map comes from other behaviors' `stateKeys` / `contextKeys` declarations. The factory is generic so it's not tied to a specific engine; the HLS engine instantiates it once at module load with its full state/context types.
+
+2. **Engine wiring** — one-liner instantiation, no separate input signals:
+   ```ts
+   // packages/spf/src/playback/engines/hls/engine.ts
+   const shareSignals = makeShareSignals<SimpleHlsEngineState, SimpleHlsEngineContext>();
+
+   export interface SimpleHlsEngineConfig extends ShareSignalsConfig<SimpleHlsEngineState, SimpleHlsEngineContext> {
+     initialBandwidth?: number;
+     // ...
+   }
+
+   export function createSimpleHlsEngine(config: SimpleHlsEngineConfig = {}) {
+     return createComposition([shareSignals, /* other behaviors */], { config: finalConfig, initialState: { ... } });
+   }
+   ```
+
+3. **`SimpleHlsEngineSignals`** — a named alias for the callback's parameter type, exported from `engine.ts` / `engines/hls/index.ts` so adapters and harnesses can type their captured refs:
+   ```ts
+   export type SimpleHlsEngineSignals = {
+     state: StateSignals<SimpleHlsEngineState>;
+     context: ContextSignals<SimpleHlsEngineContext>;
+   };
+   ```
+
+4. **Adapter capture** — straight ref-grab in the engine-creation path:
+   ```ts
+   #signals!: SimpleHlsEngineSignals;
+   #createEngine() {
+     return createSimpleHlsEngine({
+       ...this.#config,
+       onSignalsReady: (signals) => { this.#signals = signals; },
+     });
+   }
+   ```
+
+5. **Bidirectional usage** — the consumer's callback can already declare per-slot intent by typing captured refs as `Signal<T>` (write) or `ReadonlySignal<T>` (read-only) — `Signal<T>` is structurally a subtype of `ReadonlySignal<T>`, so the narrower assignment Just Works. Discipline is per-consumer; today's consumers (adapter, harness) declare everything writable since they need both reads and writes.
+
+**Why this is simpler than the original sketch.** The mirror-behaviors layer assumed the input signals had to be *separate* from composition state ("input signals are owned by the engine; composition state is owned by the composition"). But there's no actual benefit to that separation — the composition is owned by the engine factory, which is the same scope. The single signal set carries both roles.
+
+**The web-worker generalization** still works. If the engine moves into a worker, `onSignalsReady` is the IPC boundary. The composition's signals live on the worker side; the consumer captures proxies on the main-thread side. The callback shape is the same on either side — only the marshaling changes. (We haven't built that yet; this is forward-compat reasoning.)
+
+**The `set src` engine-recreate cost** is also unchanged. Each `set src` destroys the composition and creates a new one; the adapter's `onSignalsReady` re-fires and re-captures refs. The adapter holds adapter-level source-of-truth fields (`#preload`, etc.) and re-applies them to the new signals. Same as the original sketch.
+
+### Per-behavior writer audit (post-propagation)
+
+After the per-slot read/write annotation propagation (commit `b7866e6a`), each behavior's intent is legible from its setup signature alone — `Signal<T>` for writable slots, `ReadonlySignal<T>` for read-only. Body-level enforcement catches accidental writes at typecheck time.
+
+#### Internal writes (via `defineBehavior` setup bodies)
+
+| Behavior | State writes | Context writes |
+|---|---|---|
+| `selectVideoTrack` / `selectAudioTrack` / `selectTextTrack` | `selected{Video,Audio,Text}TrackId` (the corresponding one) | — |
+| `resolveVideoTrack` / `resolveAudioTrack` / `resolveTextTrack` | `presentation` (via shared `setupTrackResolution<K>`; merges resolved track segments into the existing presentation) | — |
+| `resolvePresentation` | `presentation` (parses manifest from `{ url }` seed) | — |
+| `calculatePresentationDuration` | `presentation` (sets the `duration` field on the existing presentation) | — |
+| `switchQuality` | `selectedVideoTrackId` (ABR decisions) | — |
+| `trackCurrentTime` | `currentTime` | — |
+| `trackPlaybackRate` | `playbackRate` | — |
+| `trackPlaybackInitiated` | `playbackInitiated` (from DOM `play` event + `paused` check) | — |
+| `syncTextTracks` | `selectedTextTrackId` (when DOM `<track>` mode change picks a new track) | — |
+| `syncPreloadAttribute` | `preload` (mirrors the DOM attribute when no explicit value set) | — |
+| `setupMediaSource` | `mediaSourceReadyState` (mirrors `MediaSource.readyState`) | `mediaSource` |
+| `setupSourceBuffers` | — | `videoBuffer`, `audioBuffer`, `videoBufferActor`, `audioBufferActor` |
+| `setupTextTrackActors` | — | `textTracksActor`, `segmentLoaderActor` |
+| `loadVideoSegments` | `bandwidthState` (per-chunk throughput sampling for ABR) | — |
+| `loadAudioSegments` | — (audio doesn't sample bandwidth) | — |
+| `loadTextTrackCues` / `updateDuration` / `endOfStream` | — (read-only — drive DOM properties / actor messages, not signal writes) | — |
+| `shareSignals` | — (forwards refs to consumer; see external-writes table below) | — |
+
+#### External writes (via `shareSignals.onSignalsReady` callback)
+
+`shareSignals` itself writes nothing — it forwards composition signal refs to the consumer-supplied `onSignalsReady` callback at composition setup. The consumer captures the refs and writes through them at runtime. Two consumers exist today:
+
+| Consumer | State writes | Context writes |
+|---|---|---|
+| `SimpleHlsMedia` adapter (`packages/spf/src/playback/engines/hls/adapter.ts`) | `presentation` (`set src`), `preload` (`set preload`), `playbackInitiated` (`play()`) | `mediaElement` (`attach()` / `detach()`) |
+| Sandbox harness (`apps/sandbox/templates/spf-segment-loading/main.ts`) | `presentation`, `preload`, `abrDisabled` (UI toggle) | `mediaElement` |
+
+Plus the deferred reconciler-overlap cases — the harness still writes these **directly via `engine.state`**, *not* via the `onSignalsReady` callback:
+
+| Direct writer | Slot | Marker |
+|---|---|---|
+| Sandbox harness rendition picker | `selectedVideoTrackId` (manual override) | `// TODO(stage-d)` |
+| Sandbox harness auto-select effect | `selectedTextTrackId` (initial pick) | `// TODO(stage-d)` |
+
+These slots are documented in the multi-writer table below as legitimate intent + default patterns; the harness's direct writes via `engine.state` are noted with `TODO(stage-d)` markers as cleanup hints (see `selectedVideoTrackId` decomposition below) but are no longer Stage D-blocking.
+
+#### Multi-writer slots — accepted patterns
+
+Slots with more than one writer once both internal and external writes are counted. With the count invariant dropped, these are **legitimate shapes**, not violations:
+
+| Slot | Writers | Pattern |
+|---|---|---|
+| `presentation` | adapter / harness (initial `{ url }`), `resolvePresentation` (parsed), `resolve{Video,Audio,Text}Track` (per-track resolution), `calculatePresentationDuration` (duration field) | **Pipeline** — each writer owns a different aspect of the same logical object; each builds on the previous via `{ ...current, fieldOwnedHere }` rather than overwriting. |
+| `preload` | `syncPreloadAttribute` (DOM → state), adapter / harness (state → drives DOM via downstream) | **Two-way DOM sync** — the slot is a coordination point between observer and controller. |
+| `selectedVideoTrackId` | `selectVideoTrack` (default-pick), `switchQuality` (ABR), harness direct write (manual override) | **Intent + reactive default** — disambiguated today via `abrDisabled` flag. Cleaner factoring exists (separate `manualSelectedVideoTrackId` + `abrSelectedVideoTrackId`, derive `selectedVideoTrackId` as `manual ?? abr`); see TODO at `quality-switching.ts:18`. Independent cleanup, not Stage D-mandated. |
+| `selectedTextTrackId` | `selectTextTrack` (default-pick), `syncTextTracks` (DOM-driven), harness direct write (auto-select) | Same intent + reactive default pattern. |
+| `playbackInitiated` | `trackPlaybackInitiated` (DOM observer), adapter `play()` write | **Imperative + observer** — adapter sets `true` on `play()` call; observer reflects DOM `paused` state on cleanup. |
+| `mediaElement` | adapter / harness only | Externally-driven only — single source from outside, no internal writers. |
+
+The future writer-audit lint rule (see `### Follow-up: writer-audit lint rule`) will surface multi-writer slots at review time and let the author confirm intent via an ignore comment, without forcing decomposition through types.
+
+### Reconciler shape — optional pattern (no longer Stage D-required)
+
+Originally the 2-writer cases on `selectedVideoTrackId` / `selectedTextTrackId` were going to need a reconciler to satisfy the count invariant. With the invariant dropped, **the reconciler pattern is now optional** — multiple direct writers are fine. We're keeping the sketch below as a documented pattern for cases where the intent-vs-reactive-default distinction is worth making explicit.
+
+```ts
+// Optional pattern — replaces a default-pick behavior with a reconciler that
+// also reads external intent. Useful when the consumer wants the intent vs.
+// default split to be visible in the type signature.
+export function reconcileSelectedVideoTrackId(intent: ReadonlySignal<string | undefined>) {
+  return defineBehavior({
+    stateKeys: ['presentation', 'selectedVideoTrackId'],
+    setup: ({ state }: {
+      state: {
+        presentation: ReadonlySignal<Presentation | undefined>;
+        selectedVideoTrackId: Signal<string | undefined>;
+      };
+    }) =>
+      effect(() => {
+        const presentation = state.presentation.get();
+        if (!presentation) return;
+
+        const userIntent = intent.get();
+        if (userIntent !== undefined) {
+          state.selectedVideoTrackId.set(userIntent);
+          return;
+        }
+
+        if (!state.selectedVideoTrackId.get()) {
+          const id = pickFirstTrackId(presentation, 'video');
+          if (id) state.selectedVideoTrackId.set(id);
+        }
+      }),
+  });
+}
+```
+
+The cleaner-still factoring (decompose into `manualSelectedVideoTrackId` + `abrSelectedVideoTrackId`, derive `selectedVideoTrackId` as `manual ?? abr`) eliminates the multi-writer entirely. Either approach works; the choice is per-case, not a framework rule.
+
+### Open product questions (still relevant if a reconciler is adopted)
+
+These are real questions about behavior, not architecture. Apply equally to the harness's current direct writes or to a future reconciler:
+
+- Default-pick re-fire on presentation reload — should `selectedVideoTrackId` reset to track 0 of the new presentation, or persist if user-selected and still valid?
+- Intent pointing at a track that doesn't exist in the current presentation — fall back to default? Reset intent? Both?
+- "Reset to auto" semantics — setting intent to `undefined` clears override; reactive default takes over.
+
+### Resolved questions (Stage D scope-down)
+
+1. ~~**`writeKeys` placement.**~~ **Resolved.** No `writeKeys`. Per-slot access lives in the setup signature.
+2. ~~**`ReadSignal<T>` / `WriteSignal<T>` shape.**~~ **Resolved.** Reuse `Signal<T>` (writable) and `ReadonlySignal<T>` (read-only). No brands.
+3. ~~**0-writer signals + `initialState`.**~~ **Moot — count invariant dropped.** 0-writer slots are still allowed (and seeded via `initialState` if needed); they just aren't enforced as a special case. `initialState` stays `Partial<S>`.
+4. ~~**Input mechanism for the adapter's writes.**~~ **Resolved (and shipped).** Generic `shareSignals` behavior factory hands writable signal refs to a consumer-supplied `config.onSignalsReady` callback at composition setup.
+5. ~~**Single-writer enforcement scope.**~~ **Moot — count invariant dropped.**
+6. ~~**Migration path for read/write annotations.**~~ **Resolved (and shipped).** All 17 behaviors migrated in commit `b7866e6a`.
+7. **Code-reuse follow-up convergence.** Still open. Three behavior modules (select-tracks, resolve-track, load-segments) lost code reuse during the engine-wrapper revisit. The per-slot annotation work didn't surface a clean factory shape; this is independent grooming.
+
+8. **The destroy reset loop.** Currently `for (const sig of Object.values(state)) sig.set(undefined)`. Stage D moves this into per-signal cleanup owned by the writer behavior. Open: 0-writer (seeded) signals — skip the reset (preserve seeded value, treating them as immutable constants)? The cleanest answer is "yes, skip" — once they're constants, there's nothing to reset.
+
+9. **Type machinery shape.** The accumulator-style walk over behaviors to count writers per key is straightforward but new. Worth a focused spike (4–6 lines of `AccumulateWriters<Behaviors>`) before committing to it. The existing `IntersectBehaviors` is a recursive tuple-walk too, so the shape is familiar.
+
+## Motivation
+
+A coordinated shift in SPF from **"shared bag mutated by everyone"** to **"declared signals with clear ownership."** Today, `state` and `owners` are each a single signal whose value is an object; any behavior can read or write any field. The shift makes each field its own signal and asks behaviors to declare which signals they read and which they write — surfacing the contract in types and making intent visible at the call site. (Originally the plan also included a compose-time writer-count invariant; that part was dropped after the writer audit confirmed multiple legitimate multi-writer patterns exist. See `### Why we dropped the writer-count invariant`.)
+
+## The six changes
+
+1. **State and `owners` become objects of discrete signals.** ✅ Stage A.
+2. **Rename `owners` → `context`.** ✅ Stage A.
+3. **Networking → shared singleton in `context`.** ❌ Deferred (Stage E or follow-up).
+4. **Behaviors: function → object with `stateKeys` / `contextKeys`.** ✅ Stage B.
+5. **No external signal setting from the composition.** ✅ Stage C — `createComposition` no longer accepts caller-built signal maps; behaviors own all writes (with `initialState` / `initialContext` for seed values). (The Stage-D follow-up here would have made `composition.state` read-only externally; that part was dropped — composition surface stays writable. External writes go through the `shareSignals.onSignalsReady` callback by convention rather than by enforcement.)
+6. **Read vs. write enforcement on signals.** ✅ Stage D, scope reduced — per-slot `Signal<T>` / `ReadonlySignal<T>` annotations on behavior setup signatures (body-level enforcement). The originally-planned compose-time writer-count invariant ("0-or-1 writer per slot") was **dropped** — multi-writer patterns are accepted as legitimate. Future custom linter rule will warn on multi-writer slots with an ignore mechanism.
+
+## Proposed staging (historical reference)
+
+| Stage | Change | Status |
+|---|---|---|
+| **A** | (1) discrete signals; (2) `owners` → `context` | ✅ Complete |
+| **B** | (4) behavior-as-object with `stateKeys` / `contextKeys` / `setup` | ✅ Complete |
+| **C** | (5) no external setting from composition + `initialState` | ✅ Complete |
+| **D-pre** | route adapter + harness writes through `shareSignals` / `onSignalsReady` callback | ✅ Shipped |
+| **D (scope-down)** | (6) per-slot `Signal<T>` / `ReadonlySignal<T>` annotations on all behaviors. Count invariant **dropped** — multi-writer slots are legitimate patterns. | ✅ Shipped (commit `b7866e6a`); writer-audit lint rule = future follow-up |
+| **E or parallel** | (3) networking singleton | ❌ Deferred |
+
+## Follow-ups to revisit
+
+### Type-specialized behaviors traded code reuse for narrow types
+
+The engine-wrapper consolidation moved type-specifying configs (`type:
+'video'`, `type: 'audio'`, etc.) from engine wrappers into per-type
+specialized behaviors exported from each behavior module. `select-tracks`
+went from one `selectMediaTrack` (dynamic key access via
+`state[SelectedTrackIdKeyByType[config.type]]`) plus engine wrappers, to
+three direct exports: `selectVideoTrack`, `selectAudioTrack`,
+`selectTextTrack` — each with narrow `stateKeys` and an inlined body.
+
+What we won: narrow per-behavior keys (e.g. `selectVideoTrack` only
+declares `['presentation', 'selectedVideoTrackId']`); no engine wrappers;
+no `config.type` discriminant carried at runtime; type-honest direct
+signal access (`state.selectedVideoTrackId.set(...)` instead of
+`state[selectedKey].set(...)`).
+
+What we lost: shared body code. Each specialization repeats the
+"read presentation, check if selected, pick by type, set if found"
+pattern with only the type literal and signal name varying.
+
+**Revisit each affected module after the engine-wrapper migration is
+complete.** Look for shareable abstractions that preserve the wins —
+e.g. a factory function `makeFirstTrackSelector(type, selectedKey)` that
+takes the variants as parameters and produces a `defineBehavior` result.
+The factory keeps narrow types (the selectedKey generic threads through
+`Pick<S, K>` in the setup param) but reuses the body.
+
+The trap to avoid: don't reintroduce a `config.type` discriminant or
+type-erased `state[dynamicKey]` access. The factory binds the type at
+definition time, not call time.
+
+Modules to revisit when time permits:
+- `select-tracks.ts` (3 specializations: video/audio/text) — bodies fully inlined; ripest for a factory pattern.
+- `resolve-track.ts` (3 specializations) — already shares `setupTrackResolution` via a typed K generic; body is shared but state shape is parameterized.
+- `load-segments.ts` (2 specializations: video/audio) — body shared via `setupSegmentLoading`, **but state/context keys still broad**. Per-specialization narrowing (e.g. `loadAudioSegments` dropping `bandwidthState` and the video buffer keys) is a follow-up; the body is dense (~120 lines) and a state-shape parameterization wants its own pass.
+
+### Doc updates pending
+
+- `packages/spf/docs/hls-engine.md` (parent branch `docs/spf-hls-engine-composition`) — uses `update`-style state writes and single-`owners` signal. Refresh once branch ships.
+- `internal/design/spf/fundamentals.md` — recommends external state writes from outside the composition; that's now disallowed (Stage C). Update post-merge.
+
+## Open questions to resolve before locking the plan
+
+1. ~~**Read vs. write split — Stage B or D?**~~ **Resolved (and shipped).** Single `stateKeys` shipped in Stage B; per-slot read/write annotations on setup signatures shipped in Stage D (commit `b7866e6a`).
+
+2. ~~**`setup` signature.**~~ **Resolved.** Receives `BehaviorDeps<S, C, Cfg>` = `{ state, context, config }`, with state/context/config optional via `DepsForCfg` when their slice has no keys. Returns `BehaviorCleanup` (narrowed via the `R` generic in `defineBehavior` so concrete returns survive).
+
+3. ~~**`createComposition` explicit-typed overload.**~~ **Resolved in Stage A** (and re-confirmed in `21f43473`'s single-signature collapse) — explicit overload removed; the inferred form alone handles the HLS engine's behaviors with no inference issues.
+
+4. ~~**Composition's read-only API surface.**~~ **Resolved (stays writable).** `Composition<S, C>` continues to expose `state: StateSignals<S>` / `context: ContextSignals<C>` (writable everywhere). The originally-planned readonly external surface was a Stage D enforcement promise that's no longer being made — per-slot read/write annotations live on **behavior** setup signatures, not the composition's external API.
+
+5. **Fundamentals doc updates.** Pending — see Doc updates above.
+
+6. **Networking singleton design (3).** Deferred to a separate plan.
+
+7. **Doc-driven cleanup loop continues.** The `hls-engine.md` walkthrough is the canary for whether the new shape reads well. Same friction-list pattern.
+
+## Risk and scope notes
+
+- **Stages A through D (scoped down) have landed.** Net: behaviors are objects with declared keys + per-slot read/write annotations; composition derives the signal map; type-specialized exports replace engine wrappers; `defineBehavior` / `buildSignalMap` / `makeShareSignals` are tested primitives. Multi-writer slots are accepted as legitimate patterns (see writer audit).
+- **Stage D's count invariant was dropped after the audit.** Per-slot `Signal<T>` / `ReadonlySignal<T>` annotations alone give us body-level write enforcement and self-documenting intent at the call site. The originally-planned compose-time writer-count invariant added churn without proportional value — see `### Why we dropped the writer-count invariant`.
+- **Backwards compatibility** within the SPF package is not a concern — there are no external consumers of the behavior shape yet. Move freely.
+
+## See also
+
+- `internal/design/spf/primitives.md` — original architecture spec, especially §5 on observable state.
+- `packages/spf/docs/hls-engine.md` — in-flight walkthrough that needs updates post-merge.
+- `internal/design/spf/fundamentals.md` — needs updating (Stage C's "no external writes" rule).
+- `.claude/plans/spf/signals-poc.md` — earlier signals spike that informed this direction.
diff --git a/apps/sandbox/templates/spf-segment-loading/main.ts b/apps/sandbox/templates/spf-segment-loading/main.ts
index 938d6b5e..80cd2483 100644
--- a/apps/sandbox/templates/spf-segment-loading/main.ts
+++ b/apps/sandbox/templates/spf-segment-loading/main.ts
@@ -8,8 +8,8 @@ import '@app/styles.css';
 //   autoplay=true        Start with autoplay enabled
 //   preload=auto|metadata|none  Initial preload mode
 
-import { effect } from '@videojs/spf';
-import type { SimpleHlsEngineState } from '@videojs/spf/hls';
+import { effect, snapshot } from '@videojs/spf';
+import type { SimpleHlsEngineSignals, SimpleHlsEngineState } from '@videojs/spf/hls';
 import { createSimpleHlsEngine } from '@videojs/spf/hls';
 
 // ── DOM refs ──────────────────────────────────────────────────────────────────
@@ -58,8 +58,8 @@ function formatBandwidth(bps: number): string {
   return `${Math.round(bps / 1000)} Kbps`;
 }
 
-function getVideoTracks(state: SimpleHlsEngineState) {
-  return state.presentation?.selectionSets?.find((s) => s.type === 'video')?.switchingSets[0]?.tracks ?? [];
+function getVideoTracks(presentation: SimpleHlsEngineState['presentation']) {
+  return presentation?.selectionSets?.find((s) => s.type === 'video')?.switchingSets[0]?.tracks ?? [];
 }
 
 // ── Display functions ─────────────────────────────────────────────────────────
@@ -77,7 +77,7 @@ function updateShareUrl() {
 
 function updateNowPlayingQuality() {
   if (!engine) return;
-  const segments = engine.owners.get().videoBufferActor?.snapshot.get().context.segments ?? [];
+  const segments = engine.context.videoBufferActor.get()?.snapshot.get().context.segments ?? [];
   const t = video.currentTime;
   const current = segments.find((s) => t >= s.startTime && t < s.startTime + s.duration);
   if (current?.trackBandwidth) {
@@ -100,7 +100,7 @@ function correctedEstimate(estimate: number, totalWeight: number, halfLife: numb
 
 function updateThroughputDisplay() {
   if (!engine) return;
-  const bs = engine.state.get().bandwidthState;
+  const bs = engine.state.bandwidthState.get();
   if (!bs || bs.bytesSampled === 0) {
     throughputDiv.textContent = '📶 Throughput: no samples yet';
     throughputDiv.className = '';
@@ -120,13 +120,14 @@ function updateThroughputDisplay() {
 }
 
 function renderRenditionPicker() {
-  if (!engine) return;
-  const state = engine.state.get();
-  const tracks = getVideoTracks(state);
-  const isManual = state.abrDisabled === true;
+  if (!engine || !signals) return;
+  const presentation = engine.state.presentation.get();
+  const selectedVideoTrackId = engine.state.selectedVideoTrackId.get();
+  const abrDisabled = engine.state.abrDisabled.get() === true;
+  const tracks = getVideoTracks(presentation);
 
   if (tracks.length === 0) {
-    renditionButtonsDiv.textContent = state.presentation ? 'No video tracks found' : 'Waiting for presentation…';
+    renditionButtonsDiv.textContent = presentation ? 'No video tracks found' : 'Waiting for presentation…';
     return;
   }
 
@@ -135,34 +136,37 @@ function renderRenditionPicker() {
   const statusRow = document.createElement('div');
   statusRow.className = 'abr-status';
   const modeLabel = document.createElement('span');
-  modeLabel.className = isManual ? 'mode-manual' : 'mode-abr';
-  modeLabel.textContent = isManual ? '🔒 Manual' : '⟳ ABR';
+  modeLabel.className = abrDisabled ? 'mode-manual' : 'mode-abr';
+  modeLabel.textContent = abrDisabled ? '🔒 Manual' : '⟳ ABR';
   statusRow.appendChild(modeLabel);
-  if (isManual) {
+  if (abrDisabled) {
     const enableBtn = document.createElement('button');
     enableBtn.type = 'button';
     enableBtn.className = 'enable-abr-btn';
     enableBtn.textContent = 'Enable ABR';
     enableBtn.addEventListener('click', () => {
       log('ABR re-enabled', 'success');
-      engine.state.set({ ...engine.state.get(), abrDisabled: false });
+      signals.state.abrDisabled.set(false);
     });
     statusRow.appendChild(enableBtn);
   }
   renditionButtonsDiv.appendChild(statusRow);
 
   for (const track of tracks) {
-    const isSelected = track.id === state.selectedVideoTrackId;
+    const isSelected = track.id === selectedVideoTrackId;
     const btn = document.createElement('button');
     btn.type = 'button';
-    btn.className = `rendition-btn${isSelected ? (isManual ? ' selected-manual' : ' selected-abr') : ''}`;
+    btn.className = `rendition-btn${isSelected ? (abrDisabled ? ' selected-manual' : ' selected-abr') : ''}`;
     const res = 'width' in track && track.width && track.height ? `${track.width}×${track.height} @ ` : '';
-    const badge = isSelected ? (isManual ? ' 🔒' : ' ⟳') : '';
+    const badge = isSelected ? (abrDisabled ? ' 🔒' : ' ⟳') : '';
     btn.textContent = `${res}${formatBandwidth(track.bandwidth)}${badge}`;
     btn.title = track.id;
     btn.addEventListener('click', () => {
       log(`Manual rendition select: ${formatBandwidth(track.bandwidth)} (ABR disabled)`, 'warning');
-      engine.state.set({ ...engine.state.get(), selectedVideoTrackId: track.id, abrDisabled: true });
+      // TODO(stage-d): selectedVideoTrackId is the deferred reconciler case —
+      // direct write into composition state until intent/state split lands.
+      engine.state.selectedVideoTrackId.set(track.id);
+      signals.state.abrDisabled.set(true);
     });
     renditionButtonsDiv.appendChild(btn);
   }
@@ -170,11 +174,11 @@ function renderRenditionPicker() {
 
 function renderResolutionStatus() {
   if (!engine) return;
-  const state = engine.state.get();
-  const tracks = getVideoTracks(state);
+  const presentation = engine.state.presentation.get();
+  const tracks = getVideoTracks(presentation);
 
   if (tracks.length === 0) {
-    resolutionListDiv.textContent = state.presentation ? 'No video tracks found' : 'Waiting for presentation…';
+    resolutionListDiv.textContent = presentation ? 'No video tracks found' : 'Waiting for presentation…';
     return;
   }
 
@@ -195,22 +199,22 @@ function inspectState() {
     stateDiv.innerHTML = '<h2>State Inspector</h2><div class="error">Engine not initialized</div>';
     return;
   }
-  const state = engine.state.get();
-  const owners = engine.owners.get();
+  const state = snapshot(engine.state);
+  const ctx = snapshot(engine.context);
 
-  const videoBufferRanges = owners.videoBuffer
+  const videoBufferRanges = ctx.videoBuffer
     ? Array.from(
-        { length: owners.videoBuffer.buffered.length },
+        { length: ctx.videoBuffer.buffered.length },
         (_, i) =>
-          `Range ${i}: ${owners.videoBuffer!.buffered.start(i).toFixed(2)}s - ${owners.videoBuffer!.buffered.end(i).toFixed(2)}s`
+          `Range ${i}: ${ctx.videoBuffer!.buffered.start(i).toFixed(2)}s - ${ctx.videoBuffer!.buffered.end(i).toFixed(2)}s`
       ).join('\n  ')
     : 'N/A';
 
-  const audioBufferRanges = owners.audioBuffer
+  const audioBufferRanges = ctx.audioBuffer
     ? Array.from(
-        { length: owners.audioBuffer.buffered.length },
+        { length: ctx.audioBuffer.buffered.length },
         (_, i) =>
-          `Range ${i}: ${owners.audioBuffer!.buffered.start(i).toFixed(2)}s - ${owners.audioBuffer!.buffered.end(i).toFixed(2)}s`
+          `Range ${i}: ${ctx.audioBuffer!.buffered.start(i).toFixed(2)}s - ${ctx.audioBuffer!.buffered.end(i).toFixed(2)}s`
       ).join('\n  ')
     : 'N/A';
 
@@ -220,36 +224,36 @@ function inspectState() {
     <h3>Playback State</h3>
     <pre>${JSON.stringify(state, null, 2)}</pre>
 
-    <h3>Owners (SourceBuffers)</h3>
-    <div>Video Buffer: ${owners.videoBuffer ? '✓ Created' : '✗ Not created'}</div>
-    <div>Audio Buffer: ${owners.audioBuffer ? '✓ Created' : '✗ Not created'}</div>
+    <h3>Context (SourceBuffers)</h3>
+    <div>Video Buffer: ${ctx.videoBuffer ? '✓ Created' : '✗ Not created'}</div>
+    <div>Audio Buffer: ${ctx.audioBuffer ? '✓ Created' : '✗ Not created'}</div>
 
     ${
-      owners.videoBuffer
+      ctx.videoBuffer
         ? `
       <h4>Video Buffer State</h4>
-      <div>Buffered ranges: ${owners.videoBuffer.buffered.length}</div>
+      <div>Buffered ranges: ${ctx.videoBuffer.buffered.length}</div>
       <pre>${videoBufferRanges}</pre>
     `
         : ''
     }
 
     ${
-      owners.audioBuffer
+      ctx.audioBuffer
         ? `
       <h4>Audio Buffer State</h4>
-      <div>Buffered ranges: ${owners.audioBuffer.buffered.length}</div>
+      <div>Buffered ranges: ${ctx.audioBuffer.buffered.length}</div>
       <pre>${audioBufferRanges}</pre>
     `
         : ''
     }
 
     <h3>MediaSource State</h3>
-    <div>readyState: ${owners.mediaSource?.readyState ?? 'N/A'}</div>
+    <div>readyState: ${ctx.mediaSource?.readyState ?? 'N/A'}</div>
 
     <h3>Buffer Model (actor context)</h3>
-    <div>Video segments loaded: ${owners.videoBufferActor?.snapshot.get().context.segments.length ?? 0}</div>
-    <div>Audio segments loaded: ${owners.audioBufferActor?.snapshot.get().context.segments.length ?? 0}</div>
+    <div>Video segments loaded: ${ctx.videoBufferActor?.snapshot.get().context.segments.length ?? 0}</div>
+    <div>Audio segments loaded: ${ctx.audioBufferActor?.snapshot.get().context.segments.length ?? 0}</div>
 
     <h3>Video Element State</h3>
     <div>readyState: ${video.readyState}</div>
@@ -266,20 +270,27 @@ log('=== SPF Segment Loading POC Test ===');
 log(`Stream: ${INITIAL_SRC}`);
 
 let engine: ReturnType<typeof createSimpleHlsEngine>;
+let signals: SimpleHlsEngineSignals;
 let cleanupEffects: () => void = () => {};
 
 function startEngine(src: string) {
   cleanupEffects();
   if (engine) engine.destroy();
 
-  engine = createSimpleHlsEngine({ initialBandwidth: 1_000_000 });
+  engine = createSimpleHlsEngine({
+    initialBandwidth: 1_000_000,
+    onSignalsReady: (refs) => {
+      signals = refs;
+    },
+  });
   (window as any).engine = engine;
-  (window as any).state = () => engine.state.get();
-  (window as any).owners = () => engine.owners.get();
+  (window as any).signals = signals;
+  (window as any).state = () => snapshot(engine.state);
+  (window as any).context = () => snapshot(engine.context);
 
   // ── Reactive effects ───────────────────────────────────────────────────────
 
-  // prev/prevOwners track one-time transitions for logging purposes.
+  // prev/prevContext track one-time transitions for logging purposes.
   // They are reset on each startEngine call so a new source logs correctly.
   const prev = {
     hasPresentation: false,
@@ -287,11 +298,11 @@ function startEngine(src: string) {
     selectedAudioTrackId: undefined as string | undefined,
     selectedTextTrackId: undefined as string | undefined,
   };
-  const prevOwners = { hasMediaSource: false, hasVideoBuffer: false, hasAudioBuffer: false };
+  const prevContext = { hasMediaSource: false, hasVideoBuffer: false, hasAudioBuffer: false };
 
   // State logger + auto-select first text track
   const stopStateLogger = effect(() => {
-    const state = engine.state.get();
+    const state = snapshot(engine.state);
 
     if (state.presentation && !prev.hasPresentation) {
       log('Presentation resolved');
@@ -304,7 +315,9 @@ function startEngine(src: string) {
       const firstText = textSet?.switchingSets?.[0]?.tracks?.[0];
       if (firstText) {
         log(`Auto-selecting text track: ${firstText.id}`);
-        engine.state.set({ ...engine.state.get(), selectedTextTrackId: firstText.id });
+        // TODO(stage-d): selectedTextTrackId is the deferred reconciler case —
+        // direct write into composition state until intent/state split lands.
+        engine.state.selectedTextTrackId.set(firstText.id);
       }
     }
 
@@ -325,26 +338,26 @@ function startEngine(src: string) {
 
   // Throughput + rendition picker + resolution status — re-render on any state change
   const stopStateUI = effect(() => {
-    engine.state.get(); // track all state changes
+    snapshot(engine.state); // track all state changes
     updateThroughputDisplay();
     renderRenditionPicker();
     renderResolutionStatus();
   });
 
-  // Owners logger
-  const stopOwnersLogger = effect(() => {
-    const owners = engine.owners.get();
+  // Context logger
+  const stopContextLogger = effect(() => {
+    const ctx = snapshot(engine.context);
 
-    if (owners.mediaSource && !prevOwners.hasMediaSource) {
-      log(`MediaSource created: ${owners.mediaSource.readyState}`, 'success');
-      prevOwners.hasMediaSource = true;
+    if (ctx.mediaSource && !prevContext.hasMediaSource) {
+      log(`MediaSource created: ${ctx.mediaSource.readyState}`, 'success');
+      prevContext.hasMediaSource = true;
     }
-    if (owners.videoBuffer && !prevOwners.hasVideoBuffer) {
+    if (ctx.videoBuffer && !prevContext.hasVideoBuffer) {
       log('Video SourceBuffer created', 'success');
-      prevOwners.hasVideoBuffer = true;
+      prevContext.hasVideoBuffer = true;
 
-      const origRemove = owners.videoBuffer.remove.bind(owners.videoBuffer);
-      owners.videoBuffer.remove = (start: number, end: number) => {
+      const origRemove = ctx.videoBuffer.remove.bind(ctx.videoBuffer);
+      ctx.videoBuffer.remove = (start: number, end: number) => {
         log(
           `📹 Video SourceBuffer.remove(${start.toFixed(2)}s → ${end === Infinity ? '∞' : end.toFixed(2)}s)`,
           'warning'
@@ -352,8 +365,8 @@ function startEngine(src: string) {
         return origRemove(start, end);
       };
 
-      owners.videoBuffer.addEventListener('updateend', () => {
-        const buf = engine.owners.get().videoBuffer;
+      ctx.videoBuffer.addEventListener('updateend', () => {
+        const buf = engine.context.videoBuffer.get();
         if (!buf) return;
         const ranges: string[] = [];
         for (let i = 0; i < buf.buffered.length; i++) {
@@ -362,12 +375,12 @@ function startEngine(src: string) {
         log(`📹 Video buffered: ${ranges.join(' ') || '(empty)'}`, 'info');
       });
     }
-    if (owners.audioBuffer && !prevOwners.hasAudioBuffer) {
+    if (ctx.audioBuffer && !prevContext.hasAudioBuffer) {
       log('Audio SourceBuffer created', 'success');
-      prevOwners.hasAudioBuffer = true;
+      prevContext.hasAudioBuffer = true;
 
-      const origRemove = owners.audioBuffer.remove.bind(owners.audioBuffer);
-      owners.audioBuffer.remove = (start: number, end: number) => {
+      const origRemove = ctx.audioBuffer.remove.bind(ctx.audioBuffer);
+      ctx.audioBuffer.remove = (start: number, end: number) => {
         log(
           `🔊 Audio SourceBuffer.remove(${start.toFixed(2)}s → ${end === Infinity ? '∞' : end.toFixed(2)}s)`,
           'warning'
@@ -375,8 +388,8 @@ function startEngine(src: string) {
         return origRemove(start, end);
       };
 
-      owners.audioBuffer.addEventListener('updateend', () => {
-        const buf = engine.owners.get().audioBuffer;
+      ctx.audioBuffer.addEventListener('updateend', () => {
+        const buf = engine.context.audioBuffer.get();
         if (!buf) return;
         const ranges: string[] = [];
         for (let i = 0; i < buf.buffered.length; i++) {
@@ -390,19 +403,19 @@ function startEngine(src: string) {
   cleanupEffects = () => {
     stopStateLogger();
     stopStateUI();
-    stopOwnersLogger();
+    stopContextLogger();
   };
 
   log('✓ Engine created', 'success');
-  log('Exposed as window.engine / window.state() / window.owners()');
+  log('Exposed as window.engine / window.signals / window.state() / window.context()');
   log('✓ Reactive effects active', 'success');
 
   // ── Wire media element ──────────────────────────────────────────────────────
-  // Set preload on the element BEFORE wiring owners so syncPreloadAttribute
+  // Set preload on the element BEFORE wiring context so syncPreloadAttribute
   // reads the correct value rather than the hardcoded "none" from the HTML.
   video.preload = preloadSelect.value as 'auto' | 'metadata' | 'none';
-  engine.owners.set({ mediaElement: video });
-  engine.state.set({ ...engine.state.get(), presentation: { url: src } });
+  signals.context.mediaElement.set(video);
+  signals.state.presentation.set({ url: src });
 
   log('✓ Orchestration started', 'success');
 
@@ -459,7 +472,7 @@ autoplayToggle.addEventListener('change', () => {
 
 preloadSelect.addEventListener('change', () => {
   const value = preloadSelect.value as 'auto' | 'metadata' | 'none';
-  engine.state.set({ ...engine.state.get(), preload: value });
+  signals.state.preload.set(value);
   log(`Preload: ${value}`);
   updateShareUrl();
 });
diff --git a/packages/spf/docs/fundamentals.md b/packages/spf/docs/fundamentals.md
index 04aeadc2..d5a49594 100644
--- a/packages/spf/docs/fundamentals.md
+++ b/packages/spf/docs/fundamentals.md
@@ -8,35 +8,40 @@ The framework doesn't know about your domain. It provides the composition model;
 
 ## Compositions
 
-A composition is SPF's unit of assembly. `createComposition` takes a list of **behaviors** — functions that each handle one concern — wires them to shared reactive channels, and returns a small API for reading state and tearing everything down.
+A composition is SPF's unit of assembly. `createComposition` takes a list of **behaviors** — declarative units that each handle one concern and declare which slots they read and write — wires them to shared per-slot signals, and returns a small API for reading state and tearing everything down.
 
 **What it is** — a factory that wires independent behaviors to shared reactive channels and returns a handle for reading state and tearing everything down.
 
-**When to use it** — when a problem has multiple concerns that share data and lifecycle. Each concern stays a standalone function; shared values flow through signals; cleanup happens together.
+**When to use it** — when a problem has multiple concerns that share data and lifecycle. Each concern stays a standalone unit; shared values flow through signals; cleanup happens together.
 
 ### A composition in action
 
 A composition with one stand-in behavior, driven entirely from outside:
 
 ```ts
-import { createComposition, effect, update, computed, type Signal } from '@videojs/spf';
+import { createComposition, defineBehavior, effect, computed } from '@videojs/spf';
+import type { Signal } from '@videojs/spf';
 
-function defineCount({ state }: { state: Signal<{ count?: number }> }) {
-  // no logic yet — this behavior exists to carry the type
-}
+const defineCount = defineBehavior({
+  stateKeys: ['count'],
+  contextKeys: [],
+  setup: ({ state }: { state: { count: Signal<number | undefined> } }) => {
+    // no logic yet — this behavior exists to declare the count slot
+  },
+});
 
 const composition = createComposition([defineCount]);
 
-composition.state.get(); // { count?: number }
+composition.state.count.get(); // undefined
 
 const stopLogging = effect(() => {
-  console.log(composition.state.get().count);
+  console.log(composition.state.count.get());
 });
 
-const doubled = computed(() => (composition.state.get().count ?? 0) * 2);
+const doubled = computed(() => (composition.state.count.get() ?? 0) * 2);
 
 const id = setInterval(() => {
-  update(composition.state, { count: (composition.state.get().count ?? 0) + 1 });
+  composition.state.count.set((composition.state.count.get() ?? 0) + 1);
 }, 250);
 
 await composition.destroy();
@@ -51,75 +56,92 @@ clearInterval(id);
 ```ts
 const composition = createComposition([defineCount]);
 
-composition.state;     // Signal<{ count?: number }>
-composition.owners;    // Signal<{}>
+composition.state;     // { count: Signal<number | undefined> }
+composition.context;   // {}
 composition.destroy(); // Promise<void>
 ```
 
-Those three properties — `state`, `owners`, `destroy` — are the composition's entire public API.
+Those three properties — `state`, `context`, `destroy` — are the composition's entire public API.
 
 > [!NOTE]
-> The set of reactive channels a composition exposes may grow. Additional channels — for example an event stream, either as another TC39 signal or an `EventTarget` — are under consideration. Treat `state` and `owners` as the current primitives, not a closed set.
+> The set of reactive channels a composition exposes may grow. Additional channels — for example an event stream, either as another TC39 signal or an `EventTarget` — are under consideration. Treat `state` and `context` as the current primitives, not a closed set.
 
-`state` and `owners` are [TC39 Signals](https://github.com/tc39/proposal-signals): reactive values that you read with `.get()` and write with `.set()`. SPF adds one convenience — `update(signal, partial)` shallow-merges a partial object into the current value, so behaviors can write one field without spreading the whole object.
+`state` and `context` are **maps of signals** — one [TC39 Signal](https://github.com/tc39/proposal-signals) per declared key. You read each with `.get()` and write each with `.set()`. Behaviors only see the slots they asked for in their `stateKeys` / `contextKeys` declarations.
 
 ### Giving state a shape
 
-`defineCount` is the smallest useful behavior: a function that does nothing except declare the shape of state it expects.
+`defineCount` is the smallest useful behavior: a `defineBehavior` call that does nothing except declare a state slot.
 
 ```ts
-function defineCount({ state }: { state: Signal<{ count?: number }> }) {
-  // no logic yet — this behavior exists to carry the type
-}
+const defineCount = defineBehavior({
+  stateKeys: ['count'],
+  contextKeys: [],
+  setup: ({ state }: { state: { count: Signal<number | undefined> } }) => {
+    // no logic yet
+  },
+});
 ```
 
-A behavior's parameter type is its contract with the composition. Because `defineCount` annotates its state as `Signal<{ count?: number }>`, the composition inherits that shape — and anything that tries to misuse it is caught at compile time:
+The setup parameter type is the contract. `state.count: Signal<number | undefined>` says: "this composition has a `count` slot that holds a number-or-undefined; this behavior can read and write it." `defineBehavior` enforces that the runtime `stateKeys` array matches exactly what the setup type declares — drift between the two is a compile error at the call site.
+
+When the composition runs, the `count` slot exists, every behavior that asks for it gets the same `Signal<number | undefined>` reference, and:
 
 ```ts
-composition.state.get(); // { count?: number }
+composition.state.count.set(3);
+composition.state.count.get(); // 3
 
-// @ts-expect-error — count must be a number
-composition.state.set({ count: 'not a number' });
+// @ts-expect-error — count must be a number-or-undefined
+composition.state.count.set('not a number');
 ```
 
-Without a behavior, none of that shape exists. `createComposition([])` resolves `state` and `owners` to `Signal<object>` — permissive on writes, useless on reads:
+Without behaviors, no slots exist. `createComposition([])` returns a composition with empty `state` and `context`:
 
 ```ts
 const empty = createComposition([]);
-
-empty.state.set({ anythingAtAll: true }); // accepted
-empty.state.get().count;                   // ❌ Property 'count' does not exist on type 'object'
+empty.state; // {}
 ```
 
-Types come from behaviors.
+Slots come from behaviors.
 
-> [!NOTE]
-> The exact error messages and inference rules are still evolving. The guarantee that conflicts are caught at compile time is stable; how they surface in your editor is not.
+When you pass multiple behaviors, their declarations are unioned — incompatible ones (two behaviors declaring the same slot with different value types) fail at compile time. That story is demonstrated in [Context](#context), where multiple behaviors first appear organically.
 
-When you pass multiple behaviors, their declarations are combined — incompatible ones fail at compile time. That story is demonstrated in [Owners](#owners), where multiple behaviors first appear organically.
+### Per-slot read/write intent
 
-`defineCount` is a placeholder. Real behaviors do work — run timers, wire up listeners, manage resources, return cleanup.
+Behaviors declare per-slot intent by typing each setup-param slot as `Signal<T>` (writable) or `ReadonlySignal<T>` (read-only):
+
+```ts
+const renderCount = defineBehavior({
+  stateKeys: ['count'],
+  contextKeys: [],
+  setup: ({ state }: { state: { count: ReadonlySignal<number | undefined> } }) =>
+    effect(() => console.log(state.count.get())),
+});
+```
+
+This behavior reads `count` but cannot write it — TS rejects `.set()` on `ReadonlySignal<T>` (which is `Omit<Signal<T>, 'set'>`). Body-level enforcement falls out structurally; nothing extra to remember.
+
+A behavior that writes a slot types it as `Signal<T>`. A behavior that only reads types it as `ReadonlySignal<T>`. The setup signature is self-documenting.
 
 ### Using the composition from outside
 
 From outside the composition — wherever your code called `createComposition` — you interact with its signals directly. Reading is synchronous:
 
 ```ts
-composition.state.get(); // { count?: number }
+composition.state.count.get(); // current value
 ```
 
 Observation uses `effect`: it runs its callback immediately, tracks every signal the callback reads, and re-runs the callback whenever any of those signals change. It returns a cleanup function.
 
 ```ts
 const stopLogging = effect(() => {
-  console.log(composition.state.get().count);
+  console.log(composition.state.count.get());
 });
 ```
 
 Derived values use `computed`: a read-only signal whose value is a function of other signals. It recomputes lazily — only when something reads it after a dependency has changed.
 
 ```ts
-const doubled = computed(() => (composition.state.get().count ?? 0) * 2);
+const doubled = computed(() => (composition.state.count.get() ?? 0) * 2);
 
 doubled.get(); // whatever `(count ?? 0) * 2` is
 ```
@@ -128,10 +150,15 @@ Writes from outside are uncommon — ongoing work almost always belongs in a beh
 
 ```ts
 const id = setInterval(() => {
-  update(composition.state, { count: (composition.state.get().count ?? 0) + 1 });
+  composition.state.count.set((composition.state.count.get() ?? 0) + 1);
 }, 250);
 ```
 
+For external code that needs to drive a composition over its lifetime — set state on user input, swap a media element, etc. — there's a generic pattern using the `shareSignals` behavior; see [shareSignals](#sharesignals).
+
+> [!NOTE]
+> Direct writes from outside via `composition.state.x.set(...)` work today but are mostly a pedagogical convenience. For code with a longer lifecycle — a wrapper class, an adapter, anything that drives the composition over time — the canonical pattern is [`shareSignals`](#sharesignals) + `config.onSignalsReady`. A future change may narrow `composition.state` / `composition.context` to read-only views on the public surface, making [`shareSignals`](#sharesignals) the only external write path. Examples below continue to use direct writes where it keeps the focus on the concept being introduced.
+
 Destroying the composition runs each behavior's cleanup and awaits any async work — but anything you started out here is on you:
 
 ```ts
@@ -144,11 +171,11 @@ clearInterval(id);            // the interval is on you
 
 ## State
 
-The `setInterval` and the logger that drove `count` from outside both work, but their lifecycles sit apart from the composition's. Moved inside as behaviors, each gets typed access to state, cleanup ties into `destroy()`, and they coordinate with each other through the shared signal.
+The `setInterval` and the logger that drove `count` from outside both work, but their lifecycles sit apart from the composition's. Moved inside as behaviors, each gets typed access to the slots it needs, cleanup ties into `destroy()`, and they coordinate with each other through the shared signals.
 
-State is the surface those behaviors share. A single reactive signal holding a plain object, shared across every behavior in a composition and visible from the outside through `composition.state`. Behaviors write to it when something happens; behaviors read it to know what's going on; the outside world subscribes when it needs to react. Because it's a signal, changes flow automatically — nobody coordinates, nobody wires things up.
+State is the surface those behaviors share. A map of discrete signals — one per declared key — visible from the outside through `composition.state`. Behaviors write to a slot when something happens; behaviors read a slot to know what's going on; the outside world subscribes when it needs to react. Because each slot is a signal, changes flow automatically — nobody coordinates, nobody wires things up.
 
-**What it is** — a reactive signal holding an object, shared across every behavior in a composition.
+**What it is** — a map of per-slot signals derived from each behavior's declared `stateKeys`.
 
 **When to use it** — for any value two or more behaviors (or the outside world) need to observe or drive. Counts, selections, flags, timestamps — anything that flows *through* the composition over time.
 
@@ -157,29 +184,37 @@ State is the surface those behaviors share. A single reactive signal holding a p
 A counter that ticks on an interval paired with a logger that reads the count as it changes — two behaviors coordinating entirely through shared state:
 
 ```ts
-import { createComposition, effect, update, type Signal } from '@videojs/spf';
+import { createComposition, defineBehavior, effect } from '@videojs/spf';
+import type { ReadonlySignal, Signal } from '@videojs/spf';
 
-function counter({
-  state,
-  config,
-}: {
-  state: Signal<{ count?: number }>;
-  config: { interval?: number };
-}) {
-  const id = setInterval(() => {
-    update(state, { count: (state.get().count ?? 0) + 1 });
-  }, config.interval ?? 1000);
+const counter = defineBehavior({
+  stateKeys: ['count'],
+  contextKeys: [],
+  setup: ({
+    state,
+    config,
+  }: {
+    state: { count: Signal<number | undefined> };
+    config: { interval?: number };
+  }) => {
+    const id = setInterval(() => {
+      state.count.set((state.count.get() ?? 0) + 1);
+    }, config.interval ?? 1000);
 
-  return () => clearInterval(id);
-}
+    return () => clearInterval(id);
+  },
+});
 
-function logCount({ state }: { state: Signal<{ count?: number }> }) {
-  // effect() returns its own cleanup; handing it back here ties
-  // the effect's lifecycle to composition.destroy()
-  return effect(() => {
-    console.log(state.get().count);
-  });
-}
+const logCount = defineBehavior({
+  stateKeys: ['count'],
+  contextKeys: [],
+  setup: ({ state }: { state: { count: ReadonlySignal<number | undefined> } }) =>
+    // effect() returns its own cleanup; handing it back here ties
+    // the effect's lifecycle to composition.destroy()
+    effect(() => {
+      console.log(state.count.get());
+    }),
+});
 
 const composition = createComposition([counter, logCount], {
   initialState: { count: 0 },
@@ -190,28 +225,30 @@ const composition = createComposition([counter, logCount], {
 await composition.destroy(); // clears the interval and stops the effect
 ```
 
-Neither behavior knows the other exists. `counter` writes to state; `logCount` reads it. They coordinate through the shared signal, and each hands back the cleanup that belongs to its own lifecycle — a `clearInterval` closure for `counter`, the function `effect()` returned for `logCount`. One call to `composition.destroy()` unwinds both.
+Neither behavior knows the other exists. `counter` writes to `state.count`; `logCount` reads it. They coordinate through the shared signal, and each hands back the cleanup that belongs to its own lifecycle — a `clearInterval` closure for `counter`, the function `effect()` returned for `logCount`. One call to `composition.destroy()` unwinds both.
+
+Note the read/write split: `counter` types `state.count` as `Signal` (it writes), `logCount` types it as `ReadonlySignal` (it only reads). At compose time, the union allows any behavior to read; only behaviors typed `Signal` can write. If you accidentally `.set()` on a slot you typed `ReadonlySignal`, TS rejects the call.
 
 ### `initialState`
 
-`initialState` sets the starting value of the state signal:
+`initialState` sets the starting value of each state slot:
 
 ```ts
 createComposition([counter], { initialState: { count: 0 } });
-composition.state.get(); // { count: 0 }
+composition.state.count.get(); // 0
 ```
 
-Its type is derived from the behaviors. Because `counter` annotates `state: Signal<{ count?: number }>`, TypeScript requires `initialState` to be assignable to `{ count?: number }`:
+Its type is derived from the behaviors. Because `counter` annotates `state.count` as `Signal<number | undefined>`, TypeScript requires `initialState.count` to be assignable to `number | undefined`:
 
 ```ts
 // ✅ matches the behavior's declared state
 createComposition([counter], { initialState: { count: 0 } });
 
-// @ts-expect-error — count must be a number
+// @ts-expect-error — count must be a number-or-undefined
 createComposition([counter], { initialState: { count: 'zero' } });
 ```
 
-If you omit `initialState`, the signal starts as `{}` — which is why `counter` falls back with `state.get().count ?? 0` on its first tick.
+If you omit a key from `initialState`, that slot starts as `undefined` — which is why `counter` falls back with `state.count.get() ?? 0` on its first tick.
 
 ### `config`
 
@@ -232,129 +269,126 @@ Behaviors read config directly (`config.interval`), usually with a fallback. Use
 
 ---
 
-## Owners
+## Context
 
-A ticking counter and a console log aren't much of an application. What you'd actually want is to render the count somewhere — say, into an element on the page. That needs access to the element itself: a `<div>`, a buffer, an open socket. These are **resources** — platform objects with imperative interfaces that don't fit cleanly into plain application data, and the **owners** channel is where they live.
+A ticking counter and a console log aren't much of an application. What you'd actually want is to render the count somewhere — say, into an element on the page. That needs access to the element itself: a `<div>`, a buffer, an open socket. These are **resources** — platform objects with imperative interfaces that don't fit cleanly into plain application data, and the **context** channel is where they live.
 
-The composition holds a signal whose value is a plain object mapping keys to resources. Behaviors read the keys they care about and act on the resources directly; `effect()` re-runs when a key appears, is replaced, or is cleared. The element itself is still the element — owners don't wrap or proxy it, they just make its lifecycle reactive.
+The composition holds a map of signals whose values are resources. Behaviors read the keys they care about and act on the resources directly; `effect()` re-runs when a key appears, is replaced, or is cleared. The element itself is still the element — context doesn't wrap or proxy it, it just makes its lifecycle reactive.
 
-**What it is** — a reactive signal holding a map of named resources, shared across every behavior in a composition.
+**What it is** — a map of per-slot signals for resources, parallel to state but holding values with identity rather than data.
 
-**When to use it** — for values that have identity and behavior, not just data — DOM elements, buffers, long-lived connections. If you'd pass the thing around by reference, it probably belongs in owners.
+**When to use it** — for values that have identity and behavior, not just data — DOM elements, buffers, long-lived connections. If you'd pass the thing around by reference, it probably belongs in context.
 
 > [!NOTE]
-> The name "owners" is provisional. The concept — a channel for mutable resources that behaviors observe and act on — is stable; the label itself may change, and "resources" is one candidate under consideration.
+> The split between `state` and `context` is structural at the framework level — both are signal maps with the same API — but conventional in practice. State is for plain data; context is for resources. The composition treats them identically; the split exists for code clarity.
 
 ### A DOM-renderer behavior
 
 A behavior that renders the counter to a DOM element, joining the counter and logger from the previous section:
 
 ```ts
-import { createComposition, effect, type Signal } from '@videojs/spf';
+import { createComposition, defineBehavior, effect } from '@videojs/spf';
+import type { ReadonlySignal } from '@videojs/spf';
 
 // counter, logCount — unchanged from the previous section
 
-function renderCount({
-  state,
-  owners,
-  config,
-}: {
-  state: Signal<{ count?: number }>;
-  owners: Signal<{ renderElement?: HTMLElement }>;
-  config: { defaultText?: string };
-}) {
-  return effect(() => {
-    const { renderElement } = owners.get();
-    if (!renderElement) return;
-    renderElement.textContent = String(state.get().count ?? config.defaultText ?? 'N/A');
-  });
-}
+const renderCount = defineBehavior({
+  stateKeys: ['count'],
+  contextKeys: ['renderElement'],
+  setup: ({
+    state,
+    context,
+    config,
+  }: {
+    state: { count: ReadonlySignal<number | undefined> };
+    context: { renderElement: ReadonlySignal<HTMLElement | undefined> };
+    config: { defaultText?: string };
+  }) =>
+    effect(() => {
+      const renderElement = context.renderElement.get();
+      if (!renderElement) return;
+      renderElement.textContent = String(state.count.get() ?? config.defaultText ?? 'N/A');
+    }),
+});
 
 const composition = createComposition([counter, logCount, renderCount], {
   initialState: { count: 0 },
   config: { interval: 250, defaultText: '--' },
-  initialOwners: { renderElement: document.getElementById('counter') },
+  initialContext: { renderElement: document.getElementById('counter') ?? undefined },
 });
 
 await composition.destroy();
 ```
 
-`renderCount` reads from both channels. `effect()` tracks every signal the callback reads and re-runs when any of them change — so when `count` ticks up, or when `renderElement` is swapped out or cleared, the renderCount function runs again. The guard `if (!renderElement) return` handles the case where the element isn't in owners yet (for example, if `initialOwners` was omitted or the DOM wasn't ready).
+`renderCount` reads from both channels. Both slots are typed `ReadonlySignal` — the behavior only reads, never writes. `effect()` tracks every signal the callback reads and re-runs when any of them change, so when `count` ticks up, or when `renderElement` is swapped out or cleared, the renderCount callback runs again. The guard `if (!renderElement) return` handles the case where the element isn't in context yet (for example, if `initialContext` was omitted or the DOM wasn't ready).
 
-### `initialOwners`
+### `initialContext`
 
-`initialOwners` seeds the owners signal, the same way `initialState` seeds state:
+`initialContext` seeds the context signals, the same way `initialState` seeds state:
 
 ```ts
 createComposition([counter, logCount, renderCount], {
-  initialOwners: { renderElement: document.getElementById('counter') },
+  initialContext: { renderElement: document.getElementById('counter') ?? undefined },
 });
 ```
 
-Its type is derived from the behaviors. Because `renderCount` annotates `owners: Signal<{ renderElement?: HTMLElement }>`, TypeScript requires `initialOwners` to be assignable to that shape:
+Its type is derived from the behaviors. Because `renderCount` annotates `context.renderElement` as a signal of `HTMLElement | undefined`, TypeScript requires `initialContext.renderElement` to be assignable to that:
 
 ```ts
 // @ts-expect-error — renderElement expects an HTMLElement, not a number
-createComposition([renderCount], { initialOwners: { renderElement: 42 } });
+createComposition([renderCount], { initialContext: { renderElement: 42 } });
 ```
 
-If you omit `initialOwners`, the signal starts as `{}` — which is why `renderCount` uses the optional annotation `renderElement?: HTMLElement` and guards the read.
+If you omit a context key, that slot starts as `undefined` — which is why `renderCount` guards with `if (!renderElement) return` before using it.
 
-### Updating owners from outside
+### Updating context from outside
 
-Owners is just a signal, so you can write to it the same way you write to state — usually from inside a behavior, occasionally from outside when orchestrating resources that live beyond the composition's scope.
+Context slots are signals like state — you can write to them the same way, usually from inside a behavior, occasionally from outside when orchestrating resources that live beyond the composition's scope.
 
-Swapping the element mid-composition updates what `renderCount` is rendering into. Because `effect()` tracks `owners`, the swap re-runs the callback and the new element starts receiving updates immediately:
+Swapping the element mid-composition updates what `renderCount` is rendering into. Because `effect()` tracks `context.renderElement`, the swap re-runs the callback and the new element starts receiving updates immediately:
 
 ```ts
 const anotherDiv = document.getElementById('other-counter');
-update(composition.owners, { renderElement: anotherDiv });
+composition.context.renderElement.set(anotherDiv ?? undefined);
 ```
 
-Unsetting back to `undefined` is also fine — the guard (`if (!renderElement) return`) turns the absence into a no-op:
+Unsetting back to `undefined` is also fine — the guard turns the absence into a no-op:
 
 ```ts
-update(composition.owners, { renderElement: undefined }); // renderCount stops writing to the DOM
-update(composition.owners, { renderElement: anotherDiv }); // and picks back up
+composition.context.renderElement.set(undefined); // renderCount stops writing to the DOM
+composition.context.renderElement.set(anotherDiv ?? undefined); // and picks back up
 ```
 
-The same pattern covers creation time: if you omit `initialOwners`, the signal starts as `{}`, the first effect run bails on the guard, and `renderCount` comes alive the moment a behavior (or outside code) attaches the element.
+The same pattern covers creation time: if you omit `initialContext`, the slot starts as `undefined`, the first effect run bails on the guard, and `renderCount` comes alive the moment a behavior (or outside code) attaches the element.
 
 This is the loose-coupling payoff. `renderCount` doesn't need to know *when* `renderElement` will exist, only what to do when it does. Resources can arrive late, be swapped, or disappear — the behavior adjusts.
 
+For a more structured way to do external writes — useful when a wrapper class or adapter needs to drive the composition over its lifetime — see [shareSignals](#sharesignals).
+
 ### Composing behaviors
 
-When you pass more than one behavior to `createComposition`, their declarations are combined and the compiler catches conflicts. The rule differs by channel.
-
-**State and config** use intersection: if two behaviors declare the same key with incompatible types, the intersection collapses and the composition is rejected.
+When you pass more than one behavior to `createComposition`, their declarations are unioned and the compiler catches conflicts. State and context are treated identically: each behavior contributes the per-slot types it declares, and slots with conflicting types across behaviors fail at compile time.
 
 ```ts
-const expectsNumber = (_deps: { state: Signal<{ value: number }> }) => {};
-const expectsString = (_deps: { state: Signal<{ value: string }> }) => {};
+const expectsNumber = defineBehavior({
+  stateKeys: ['value'],
+  contextKeys: [],
+  setup: ({ state }: { state: { value: Signal<number | undefined> } }) => {},
+});
+
+const expectsString = defineBehavior({
+  stateKeys: ['value'],
+  contextKeys: [],
+  setup: ({ state }: { state: { value: Signal<string | undefined> } }) => {},
+});
 
 // @ts-expect-error — behaviors have conflicting state types
 createComposition([expectsNumber, expectsString]);
 ```
 
-**Owners** use subtype compatibility, because owner values are concrete platform objects whose class hierarchy matters. Two behaviors can share an owner key if one type extends the other — the composition picks the more specific one:
+Two behaviors can share a slot if their declared types are compatible — typically the same type, or one being a subtype of the other (e.g. `HTMLVideoElement` vs `HTMLElement`). The compose-time validator picks the most specific type from the intersection.
 
-```ts
-const wantsElement = (_deps: { owners: Signal<{ el?: HTMLElement }> }) => {};
-const wantsVideo   = (_deps: { owners: Signal<{ el?: HTMLVideoElement }> }) => {};
-
-// ✅ HTMLVideoElement extends HTMLElement — fine
-createComposition([wantsElement, wantsVideo]);
-```
-
-Sibling types with no `extends` relationship are rejected:
-
-```ts
-const wantsCanvas = (_deps: { owners: Signal<{ el?: HTMLCanvasElement }> }) => {};
-const wantsVideo  = (_deps: { owners: Signal<{ el?: HTMLVideoElement }> }) => {};
-
-// @ts-expect-error — neither HTMLCanvasElement nor HTMLVideoElement extends the other
-createComposition([wantsCanvas, wantsVideo]);
-```
+The same rule applies to context. The framework doesn't distinguish "data slots" from "resource slots" structurally — it just unions the declared shapes per channel.
 
 ---
 
@@ -373,96 +407,112 @@ An `effect()` can't cleanly model that. It re-runs on every signal change with n
 A counter that can be paused and reset from DOM buttons. The counter is now a reactor; the rest are ordinary effect-based behaviors:
 
 ```ts
-import { createComposition, effect, createMachineReactor, update, type Signal } from '@videojs/spf';
+import { createComposition, defineBehavior, effect, createMachineReactor } from '@videojs/spf';
+import type { ReadonlySignal, Signal } from '@videojs/spf';
 import { listen } from '@videojs/utils/dom';
 
 // logCount, renderCount — unchanged from the previous section
 
-function counter({
-  state,
-  config,
-}: {
-  state: Signal<{ count?: number; paused?: boolean }>;
-  config: { interval?: number };
-}) {
-  return createMachineReactor({
-    initial: 'paused',
-    monitor: () => (state.get().paused ? 'paused' : 'running'),
-    states: {
-      paused: {},
-      running: {
-        // entry runs once on transition; its return value is cleanup,
-        // called on exit (pause or destroy)
-        entry: () => {
-          const id = setInterval(() => {
-            update(state, { count: (state.get().count ?? 0) + 1 });
-          }, config.interval ?? 1000);
-          return () => clearInterval(id);
+const counter = defineBehavior({
+  stateKeys: ['count', 'paused'],
+  contextKeys: [],
+  setup: ({
+    state,
+    config,
+  }: {
+    state: {
+      count: Signal<number | undefined>;
+      paused: ReadonlySignal<boolean | undefined>;
+    };
+    config: { interval?: number };
+  }) =>
+    createMachineReactor({
+      initial: 'paused',
+      monitor: () => (state.paused.get() ? 'paused' : 'running'),
+      states: {
+        paused: {},
+        running: {
+          // entry runs once on transition; its return value is cleanup,
+          // called on exit (pause or destroy)
+          entry: () => {
+            const id = setInterval(() => {
+              state.count.set((state.count.get() ?? 0) + 1);
+            }, config.interval ?? 1000);
+            return () => clearInterval(id);
+          },
         },
       },
-    },
-  });
-}
+    }),
+});
 
-function pauseButton({
-  state,
-  owners,
-}: {
-  state: Signal<{ paused?: boolean }>;
-  owners: Signal<{ pauseBtn?: HTMLElement }>;
-}) {
-  // Keep the button label in sync with paused
-  const stopLabel = effect(() => {
-    const { pauseBtn } = owners.get();
-    if (!pauseBtn) return;
-    pauseBtn.textContent = state.get().paused ? 'Start' : 'Pause';
-  });
-
-  // listen() attaches a click handler and returns a cleanup that removes it
-  const stopClick = effect(() => {
-    const { pauseBtn } = owners.get();
-    if (!pauseBtn) return;
-    return listen(pauseBtn, 'click', () => {
-      update(state, { paused: !state.get().paused });
+const pauseButton = defineBehavior({
+  stateKeys: ['paused'],
+  contextKeys: ['pauseBtn'],
+  setup: ({
+    state,
+    context,
+  }: {
+    state: { paused: Signal<boolean | undefined> };
+    context: { pauseBtn: ReadonlySignal<HTMLElement | undefined> };
+  }) => {
+    // Keep the button label in sync with paused
+    const stopLabel = effect(() => {
+      const pauseBtn = context.pauseBtn.get();
+      if (!pauseBtn) return;
+      pauseBtn.textContent = state.paused.get() ? 'Start' : 'Pause';
     });
-  });
 
-  return () => {
-    stopLabel();
-    stopClick();
-  };
-}
+    // listen() attaches a click handler and returns a cleanup that removes it
+    const stopClick = effect(() => {
+      const pauseBtn = context.pauseBtn.get();
+      if (!pauseBtn) return;
+      return listen(pauseBtn, 'click', () => {
+        state.paused.set(!state.paused.get());
+      });
+    });
 
-function resetButton({
-  state,
-  owners,
-}: {
-  state: Signal<{ count?: number }>;
-  owners: Signal<{ resetBtn?: HTMLElement }>;
-}) {
-  return effect(() => {
-    const { resetBtn } = owners.get();
-    if (!resetBtn) return;
-    return listen(resetBtn, 'click', () => update(state, { count: 0 }));
-  });
-}
+    return () => {
+      stopLabel();
+      stopClick();
+    };
+  },
+});
+
+const resetButton = defineBehavior({
+  stateKeys: ['count'],
+  contextKeys: ['resetBtn'],
+  setup: ({
+    state,
+    context,
+  }: {
+    state: { count: Signal<number | undefined> };
+    context: { resetBtn: ReadonlySignal<HTMLElement | undefined> };
+  }) =>
+    effect(() => {
+      const resetBtn = context.resetBtn.get();
+      if (!resetBtn) return;
+      return listen(resetBtn, 'click', () => state.count.set(0));
+    }),
+});
 
 const composition = createComposition([counter, logCount, renderCount, pauseButton, resetButton], {
   initialState: { count: 0, paused: true },
   config: { interval: 250, defaultText: '--' },
-  initialOwners: {
-    renderElement: document.getElementById('counter'),
-    pauseBtn: document.getElementById('pause'),
-    resetBtn: document.getElementById('reset'),
+  initialContext: {
+    renderElement: document.getElementById('counter') ?? undefined,
+    pauseBtn: document.getElementById('pause') ?? undefined,
+    resetBtn: document.getElementById('reset') ?? undefined,
   },
 });
 
 await composition.destroy();
 ```
 
-`counter` is now a reactor with two states, `paused` and `running`. Its `monitor` reads `state.get().paused` and returns the target. When the user clicks the pause button, `pauseButton` writes to state; `monitor` re-derives, and the reactor transitions. `entry` on `running` starts the interval; the cleanup it returns runs on the way back to `paused`. The framework handles the transition — `counter` never calls `transition()` itself.
+`counter` is now a reactor with two states, `paused` and `running`. Its `monitor` reads `state.paused.get()` and returns the target. When the user clicks the pause button, `pauseButton` writes to state; `monitor` re-derives, and the reactor transitions. `entry` on `running` starts the interval; the cleanup it returns runs on the way back to `paused`. The framework handles the transition — `counter` never calls `transition()` itself.
 
-`pauseButton`, `resetButton`, and `renderCount` are ordinary effect-based behaviors reacting to the same state the reactor derives from. None of them knows a reactor exists. Everything coordinates through the shared signal.
+`pauseButton`, `resetButton`, and `renderCount` are ordinary effect-based behaviors reacting to the same state the reactor derives from. None of them knows a reactor exists. Everything coordinates through the shared signals.
+
+The read/write split is visible across the behaviors: `counter` writes `count` (Signal) and only reads `paused` (ReadonlySignal); `pauseButton` writes `paused` (Signal); `resetButton` writes `count` (Signal). `count` and `paused` each have multiple readers but a clear set of writers — visible at each behavior's setup signature without needing to read bodies.
 
 ### Monitor, entry, and effects
 
@@ -491,60 +541,65 @@ A plain Promise can't express any of that. It starts running the moment you crea
 Saving the count to a server every five ticks, with one final save on destroy:
 
 ```ts
-import { createComposition, effect, Task, SerialRunner, computed, type Signal } from '@videojs/spf';
+import { createComposition, defineBehavior, effect, computed, Task, SerialRunner } from '@videojs/spf';
+import type { ReadonlySignal } from '@videojs/spf';
 
 // counter, logCount, renderCount, pauseButton, resetButton — unchanged from previous sections
 
-function persist({
-  state,
-  config,
-}: {
-  state: Signal<{ count?: number }>;
-  config: { saveEvery?: number };
-}) {
-  const runner = new SerialRunner();
+const persist = defineBehavior({
+  stateKeys: ['count'],
+  contextKeys: [],
+  setup: ({
+    state,
+    config,
+  }: {
+    state: { count: ReadonlySignal<number | undefined> };
+    config: { saveEvery?: number };
+  }) => {
+    const runner = new SerialRunner();
 
-  function save(count: number) {
-    runner.schedule(
-      new Task((signal) =>
-        fetch('/api/count', {
-          method: 'POST',
-          body: JSON.stringify({ count }),
-          signal,
-        }),
-      ),
-    );
-  }
-
-  // Isolate count so unrelated state changes don't trigger a save
-  const count = computed(() => state.get().count ?? 0);
-
-  // Watch count and save at every Nth tick
-  const stopEffect = effect(() => {
-    const c = count.get();
-    if (c > 0 && c % (config.saveEvery ?? 5) === 0) {
-      save(c);
+    function save(count: number) {
+      runner.schedule(
+        new Task((signal) =>
+          fetch('/api/count', {
+            method: 'POST',
+            body: JSON.stringify({ count }),
+            signal,
+          }),
+        ),
+      );
     }
-  });
 
-  // Async cleanup: save the final count, let the runner drain, then tear down
-  return async () => {
-    stopEffect();
-    save(count.get());
-    await runner.settled;
-    runner.destroy();
-  };
-}
+    // Isolate count so unrelated re-runs don't fire spurious saves
+    const count = computed(() => state.count.get() ?? 0);
+
+    // Watch count and save at every Nth tick
+    const stopEffect = effect(() => {
+      const c = count.get();
+      if (c > 0 && c % (config.saveEvery ?? 5) === 0) {
+        save(c);
+      }
+    });
+
+    // Async cleanup: save the final count, let the runner drain, then tear down
+    return async () => {
+      stopEffect();
+      save(count.get());
+      await runner.settled;
+      runner.destroy();
+    };
+  },
+});
 
 const composition = createComposition(
   [counter, logCount, renderCount, pauseButton, resetButton, persist],
   {
     initialState: { count: 0, paused: true },
     config: { interval: 250, defaultText: '--', saveEvery: 5 },
-    initialOwners: {
-      renderElement: document.getElementById('counter'),
-      pauseBtn: document.getElementById('pause'),
-      resetBtn: document.getElementById('reset'),
+    initialContext: {
+      renderElement: document.getElementById('counter') ?? undefined,
+      pauseBtn: document.getElementById('pause') ?? undefined,
+      resetBtn: document.getElementById('reset') ?? undefined,
     },
   },
 );
@@ -555,17 +610,17 @@ await composition.destroy();
 
 Three things are new. The `save()` closure wraps each network request in `new Task(...)`; the task's body receives an `AbortSignal` that `fetch` understands natively. The `SerialRunner` collects scheduled tasks and runs them one at a time — scheduling a second task while the first is still running queues it behind, with no overlap. And `persist`'s cleanup is `async`: it stops the effect, schedules one last save, `await`s `runner.settled` to let pending work finish, then destroys the runner. `composition.destroy()` awaits this cleanup like any other.
 
-One more detail is worth unpacking: why `count` is wrapped in a `computed` before the effect reads it.
+`persist` types `count` as `ReadonlySignal` — it observes but doesn't write the slot. The actual save state (in flight, last error, etc.) is internal to the closure. Making *that* observable is what actors are for; see the next section.
 
 ### Narrowing what an effect re-runs on
 
-Previous effects read `count` straight from state — `state.get().count`. Here it's wrapped in a `computed`:
+The save effect wraps `count` in a `computed`:
 
 ```ts
-const count = computed(() => state.get().count ?? 0);
+const count = computed(() => state.count.get() ?? 0);
 ```
 
-The reason is the shape of the effect that reads it. `save()` is a non-idempotent side effect: it schedules a network request. A state signal re-notifies on every write, so reading `state.get().count` directly would re-run the effect whenever `paused` toggled (or any unrelated field changed) and fire a save whenever the current count happened to be divisible by `saveEvery`. `computed` caches by value, so reading its `.get()` inside an effect only triggers a re-run when that value actually changed.
+The reason is the shape of the effect that reads it. `save()` is a non-idempotent side effect: it schedules a network request. A signal re-notifies on every write, even when the new value equals the old; reading `state.count.get()` directly inside an effect would re-fire on every write, even no-ops. `computed` caches by value: reading its `.get()` inside an effect only triggers a re-run when that value actually changed.
 
 For the DOM-update effects earlier in the doc — `renderCount` setting `textContent`, `pauseButton`'s label — spurious re-runs are harmless: the assignment just writes the same value already there. The `computed` guardrail matters when the effect's side effect isn't free to repeat.
 
@@ -599,7 +654,16 @@ Moving that work into an actor makes the save lifecycle observable. An actor is
 Refactor `persist`: the runner and save state move into an actor; `persist` sends messages to it; a new `renderSaving` behavior reads the actor's snapshot to surface in-flight status to a dedicated element; a new `cancelOnReset` behavior sends `cancel` when count returns to zero while a save is in flight.
 
 ```ts
-import { createComposition, effect, createMachineActor, Task, SerialRunner, computed, update, type Signal } from '@videojs/spf';
+import {
+  createComposition,
+  defineBehavior,
+  effect,
+  computed,
+  createMachineActor,
+  Task,
+  SerialRunner,
+} from '@videojs/spf';
+import type { ReadonlySignal, Signal } from '@videojs/spf';
 
 // counter, logCount, renderCount, pauseButton, resetButton — unchanged from previous sections
 
@@ -648,74 +712,89 @@ function createSaveActor() {
 
 type SaveActor = ReturnType<typeof createSaveActor>;
 
-function persist({
-  state,
-  owners,
-  config,
-}: {
-  state: Signal<{ count?: number }>;
-  owners: Signal<{ saveActor?: SaveActor }>;
-  config: { saveEvery?: number };
-}) {
-  const actor = createSaveActor();
-  update(owners, { saveActor: actor });
+const persist = defineBehavior({
+  stateKeys: ['count'],
+  contextKeys: ['saveActor'],
+  setup: ({
+    state,
+    context,
+    config,
+  }: {
+    state: { count: ReadonlySignal<number | undefined> };
+    context: { saveActor: Signal<SaveActor | undefined> };
+    config: { saveEvery?: number };
+  }) => {
+    const actor = createSaveActor();
+    context.saveActor.set(actor);
 
-  // Isolate count so unrelated state changes don't trigger a save
-  const count = computed(() => state.get().count ?? 0);
+    // Isolate count so unrelated re-runs don't fire spurious saves
+    const count = computed(() => state.count.get() ?? 0);
 
-  const stopEffect = effect(() => {
-    const c = count.get();
-    if (c > 0 && c % (config.saveEvery ?? 5) === 0) {
-      actor.send({ type: 'save', count: c });
-    }
-  });
+    const stopEffect = effect(() => {
+      const c = count.get();
+      if (c > 0 && c % (config.saveEvery ?? 5) === 0) {
+        actor.send({ type: 'save', count: c });
+      }
+    });
 
-  return () => {
-    stopEffect();
-    actor.destroy();
-  };
-}
+    return () => {
+      stopEffect();
+      actor.destroy();
+    };
+  },
+});
 
-function renderSaving({
-  owners,
-}: {
-  owners: Signal<{ savingElement?: HTMLElement; saveActor?: SaveActor }>;
-}) {
-  return effect(() => {
-    const { savingElement, saveActor } = owners.get();
-    if (!savingElement) return;
-    savingElement.textContent = saveActor?.snapshot.get().value === 'saving' ? 'saving...' : '';
-  });
-}
+const renderSaving = defineBehavior({
+  stateKeys: [],
+  contextKeys: ['savingElement', 'saveActor'],
+  setup: ({
+    context,
+  }: {
+    context: {
+      savingElement: ReadonlySignal<HTMLElement | undefined>;
+      saveActor: ReadonlySignal<SaveActor | undefined>;
+    };
+  }) =>
+    effect(() => {
+      const savingElement = context.savingElement.get();
+      const saveActor = context.saveActor.get();
+      if (!savingElement) return;
+      savingElement.textContent = saveActor?.snapshot.get().value === 'saving' ? 'saving...' : '';
+    }),
+});
 
-function cancelOnReset({
-  state,
-  owners,
-}: {
-  state: Signal<{ count?: number }>;
-  owners: Signal<{ saveActor?: SaveActor }>;
-}) {
-  // Isolate count so unrelated state changes don't fire spurious cancels
-  const count = computed(() => state.get().count);
+const cancelOnReset = defineBehavior({
+  stateKeys: ['count'],
+  contextKeys: ['saveActor'],
+  setup: ({
+    state,
+    context,
+  }: {
+    state: { count: ReadonlySignal<number | undefined> };
+    context: { saveActor: ReadonlySignal<SaveActor | undefined> };
+  }) => {
+    // Isolate count so unrelated state changes don't fire spurious cancels
+    const count = computed(() => state.count.get());
 
-  return effect(() => {
-    const { saveActor } = owners.get();
-    if (count.get() === 0 && saveActor?.snapshot.get().value === 'saving') {
-      saveActor.send({ type: 'cancel' });
-    }
-  });
-}
+    return effect(() => {
+      const saveActor = context.saveActor.get();
+      if (count.get() === 0 && saveActor?.snapshot.get().value === 'saving') {
+        saveActor.send({ type: 'cancel' });
+      }
+    });
+  },
+});
 
 const composition = createComposition(
   [counter, logCount, renderCount, pauseButton, resetButton, persist, renderSaving, cancelOnReset],
   {
     initialState: { count: 0, paused: true },
     config: { interval: 250, defaultText: '--', saveEvery: 5 },
-    initialOwners: {
-      renderElement: document.getElementById('counter'),
-      savingElement: document.getElementById('saving'),
-      pauseBtn: document.getElementById('pause'),
-      resetBtn: document.getElementById('reset'),
+    initialContext: {
+      renderElement: document.getElementById('counter') ?? undefined,
+      savingElement: document.getElementById('saving') ?? undefined,
+      pauseBtn: document.getElementById('pause') ?? undefined,
+      resetBtn: document.getElementById('reset') ?? undefined,
     },
   },
 );
@@ -723,10 +802,9 @@ const composition = createComposition(
 await composition.destroy();
 ```
 
-The actor makes the save lifecycle observable. `persist` publishes the actor through owners and forwards save triggers as messages; `renderSaving` reads `saveActor.snapshot.get().value` and writes "saving..." to its own dedicated element when the actor is in the `'saving'` state; `cancelOnReset` reads the same snapshot and sends a `cancel` message when count returns to zero during an in-flight save, aborting the work and transitioning the actor back to `idle`. None of these behaviors knows how a save is performed — they interact with the actor as a black box that happens to expose its current state. And `resetButton` no longer has to know anything about saving: it just writes `{ count: 0 }` to state; `cancelOnReset` handles the rest.
+The actor makes the save lifecycle observable. `persist` publishes the actor through `context.saveActor` and forwards save triggers as messages; `renderSaving` reads `saveActor.snapshot.get().value` and writes "saving..." to its own dedicated element when the actor is in the `'saving'` state; `cancelOnReset` reads the same snapshot and sends a `cancel` message when count returns to zero during an in-flight save, aborting the work and transitioning the actor back to `idle`. None of these behaviors knows how a save is performed — they interact with the actor as a black box that happens to expose its current state. And `resetButton` no longer has to know anything about saving: it just writes `state.count.set(0)`; `cancelOnReset` handles the rest.
 
-> [!NOTE]
-> Actors live in `owners` here because they fit the shape — imperative resources with identity that behaviors observe and act on. Whether they warrant a dedicated channel is an open question. Treat actors-in-owners as a working convention, not a fixed design.
+`saveActor` lives in `context` — actors fit the shape (imperative resources with identity that behaviors observe and act on). `persist` types it `Signal` because it writes the actor in once at setup; `renderSaving` and `cancelOnReset` type it `ReadonlySignal` because they only read.
 
 ### Messages, transitions, and snapshot
 
@@ -745,64 +823,143 @@ A reactor might send a message to an actor when a condition goes true; the actor
 
 ---
 
-## Advanced: Creating owners within behaviors
+## shareSignals
 
-Up through Actors, the caller had to hand every element the composition uses directly into `initialOwners` — `renderElement`, `savingElement`, `pauseBtn`, `resetBtn`, each looked up from the DOM before `createComposition` runs. Adding or renaming any of them means touching the caller too. Behaviors can close that loop: given a single `rootElement`, a behavior creates the descendants itself, registers them in owners, and cleans them up on teardown. That keeps resource creation inside the composition, which matters when a single composition needs several related resources that share a lifecycle.
+Most behaviors above keep their lifecycle inside the composition. But sometimes external code needs to drive a composition over its lifetime — a wrapper class setting `count` from a method call, an adapter forwarding DOM events into state. Reaching directly into `composition.state.count.set(...)` works, but it spreads composition knowledge into the caller and leaves no clear boundary for "the engine's input surface."
+
+`shareSignals` is a generic passthrough behavior that hands the composition's writable signal refs to a consumer-supplied `config.onSignalsReady` callback at composition setup. The consumer captures the refs and writes through them at runtime. The composition itself doesn't change — `shareSignals` just forwards what's already there.
+
+**What it is** — a behavior factory (`makeShareSignals<S, C>()`) that produces a passthrough behavior. The behavior declares no slots of its own; at setup time it invokes `config.onSignalsReady({ state, context })`.
+
+**When to use it** — when external code needs structured access to a composition's slots over its lifetime, especially when the composition will be re-created (e.g. on source change). The pattern is "create composition → capture refs in callback → drive from outside."
+
+### A counter wrapped via `shareSignals`
+
+```ts
+import {
+  createComposition,
+  defineBehavior,
+  makeShareSignals,
+  type ShareSignalsConfig,
+  type StateSignals,
+  type ContextSignals,
+} from '@videojs/spf';
+
+interface CounterState {
+  count?: number;
+  paused?: boolean;
+}
+interface CounterContext {
+  renderElement?: HTMLElement;
+}
+
+interface CounterEngineConfig extends ShareSignalsConfig<CounterState, CounterContext> {
+  interval?: number;
+  defaultText?: string;
+}
+
+const shareSignals = makeShareSignals<CounterState, CounterContext>();
+
+function createCounterEngine(config: CounterEngineConfig) {
+  return createComposition(
+    [counter, logCount, renderCount, shareSignals],
+    {
+      config,
+      initialState: { count: 0, paused: true },
+    },
+  );
+}
+
+// Usage from outside
+let signals: { state: StateSignals<CounterState>; context: ContextSignals<CounterContext> };
+
+const engine = createCounterEngine({
+  interval: 250,
+  onSignalsReady: (refs) => {
+    signals = refs;
+  },
+});
+
+// Drive the engine through the captured refs
+signals.context.renderElement.set(document.getElementById('counter') ?? undefined);
+signals.state.paused.set(false); // start ticking
+
+await engine.destroy();
+```
+
+The engine factory exposes a single config option (`onSignalsReady`); the consumer captures the signal refs and drives the engine through them. `shareSignals` is generic — `makeShareSignals<S, C>()` works for any composition, parameterized over the composition's state and context shapes.
+
+For real-world use, place `shareSignals` last in the behaviors array so every other behavior's setup has run by the time the callback fires. Initial state writes will be visible to the consumer immediately.
+
+---
+
+## Advanced: Creating context within behaviors
+
+Up through Actors, the caller had to hand every element the composition uses directly into `initialContext` — `renderElement`, `savingElement`, `pauseBtn`, `resetBtn`, each looked up from the DOM before `createComposition` runs. Adding or renaming any of them means touching the caller too. Behaviors can close that loop: given a single `rootElement`, a behavior creates the descendants itself, registers them in context, and cleans them up on teardown. That keeps resource creation inside the composition, which matters when a single composition needs several related resources that share a lifecycle.
 
 A `mount` behavior takes a single parent — `rootElement` — and creates the rest:
 
 ```ts
-import { effect, update, type Signal } from '@videojs/spf';
+import { defineBehavior, effect } from '@videojs/spf';
+import type { ReadonlySignal, Signal } from '@videojs/spf';
 
 // counter, logCount, renderCount, pauseButton, resetButton, persist, renderSaving, cancelOnReset — unchanged from previous sections
 
-function mount({
-  owners,
-}: {
-  owners: Signal<{
-    rootElement?: HTMLElement;
-    renderElement?: HTMLElement;
-    savingElement?: HTMLElement;
-    pauseBtn?: HTMLElement;
-    resetBtn?: HTMLElement;
-  }>;
-}) {
-  return effect(() => {
-    const { rootElement } = owners.get();
-    if (!rootElement) return;
+const mount = defineBehavior({
+  stateKeys: [],
+  contextKeys: ['rootElement', 'renderElement', 'savingElement', 'pauseBtn', 'resetBtn'],
+  setup: ({
+    context,
+  }: {
+    context: {
+      rootElement: ReadonlySignal<HTMLElement | undefined>;
+      renderElement: Signal<HTMLElement | undefined>;
+      savingElement: Signal<HTMLElement | undefined>;
+      pauseBtn: Signal<HTMLElement | undefined>;
+      resetBtn: Signal<HTMLElement | undefined>;
+    };
+  }) =>
+    effect(() => {
+      const rootElement = context.rootElement.get();
+      if (!rootElement) return;
 
-    const renderElement = document.createElement('div');
-    const savingElement = document.createElement('div');
-    const pauseBtn = document.createElement('button');
-    const resetBtn = document.createElement('button');
-    resetBtn.textContent = 'Reset';
+      const renderElement = document.createElement('div');
+      const savingElement = document.createElement('div');
+      const pauseBtn = document.createElement('button');
+      const resetBtn = document.createElement('button');
+      resetBtn.textContent = 'Reset';
 
-    rootElement.append(renderElement, savingElement, pauseBtn, resetBtn);
-    update(owners, { renderElement, savingElement, pauseBtn, resetBtn });
+      rootElement.append(renderElement, savingElement, pauseBtn, resetBtn);
+      context.renderElement.set(renderElement);
+      context.savingElement.set(savingElement);
+      context.pauseBtn.set(pauseBtn);
+      context.resetBtn.set(resetBtn);
 
-    // If this behavior needed cleanup when rootElement is cleared — to
-    // .remove() the descendants, or close a socket, observer, or
-    // MediaSource — we'd return a cleanup function from the effect here.
-  });
-}
+      // If this behavior needed cleanup when rootElement is cleared — to
+      // .remove() the descendants, or close a socket, observer, or
+      // MediaSource — we'd return a cleanup function from the effect here.
+    }),
+});
 
 const composition = createComposition(
   [counter, logCount, renderCount, pauseButton, resetButton, persist, renderSaving, cancelOnReset, mount],
   {
     initialState: { count: 0, paused: true },
     config: { interval: 250, defaultText: '--', saveEvery: 5 },
-    initialOwners: { rootElement: document.getElementById('counter') },
+    initialContext: { rootElement: document.getElementById('counter') ?? undefined },
   },
 );
 ```
 
-`mount` reads `rootElement`, creates four descendant elements, attaches them to the DOM, and writes them back into owners. The other behaviors — `renderCount`, `renderSaving`, `pauseButton`, `resetButton` — pick them up through the guards we've already written; none of them knows a mount step happened. On destroy, the descendants are discarded along with `rootElement`, and the composition clears every key in owners after all behavior cleanups have run — no manual bookkeeping on either side.
+`mount` reads `rootElement`, creates four descendant elements, attaches them to the DOM, and writes them back into context. The other behaviors — `renderCount`, `renderSaving`, `pauseButton`, `resetButton` — pick them up through the guards we've already written; none of them knows a mount step happened. On destroy, the descendants are discarded along with `rootElement`, and the composition clears every signal in context after all behavior cleanups have run — no manual bookkeeping on either side.
 
-Each descendant is registered under its own key in owners rather than left for other behaviors to pick out of `rootElement` themselves. The alternative — watch the subtree with a `MutationObserver` and identify elements by selector or data attribute — works mechanically, but trades away most of what owners gives you. You lose typed identity (`renderElement: HTMLElement` is not the same contract as "some `<div>` inside `rootElement`"), you swap synchronous guards for coalesced microtask callbacks, and every downstream behavior becomes coupled to whatever DOM layout `mount` happens to produce. Owners is a signal of named resources; behaviors reading it never have to know where those resources came from, only that they appeared.
+The slot map at `mount`'s setup site reads as documentation. `rootElement` is `ReadonlySignal` — it's an input only. The four descendants are `Signal` — `mount` writes them. Per-slot intent is visible at the boundary; reviewers don't have to spelunk the body to learn which way data flows.
 
-This is also where behaviors-as-units pays off. The contract every downstream behavior relies on is typed owners plus guards for missing keys — nothing about *how* the owners got populated. The same composition supports several equally valid shapes:
+Each descendant is registered under its own key in context rather than left for other behaviors to pick out of `rootElement` themselves. The alternative — watch the subtree with a `MutationObserver` and identify elements by selector or data attribute — works mechanically, but trades away most of what context gives you. You lose typed identity (`renderElement: HTMLElement` is not the same contract as "some `<div>` inside `rootElement`"), you swap synchronous guards for coalesced microtask callbacks, and every downstream behavior becomes coupled to whatever DOM layout `mount` happens to produce. Context is a map of named resources; behaviors reading it never have to know where those resources came from, only that they appeared.
 
-- **Omit `mount`.** Pass `renderElement`, `savingElement`, and the buttons through `initialOwners` directly, or write them later via `composition.owners.set(...)`. This is the shape the Actors example uses.
+This is also where behaviors-as-units pays off. The contract every downstream behavior relies on is typed context plus guards for missing keys — nothing about *how* the context got populated. The same composition supports several equally valid shapes:
+
+- **Omit `mount`.** Pass `renderElement`, `savingElement`, and the buttons through `initialContext` directly, or write them later via `composition.context.renderElement.set(...)`. This is the shape the Actors example uses.
 - **Replace `mount` with a different implementation.** A shadow-DOM variant, a React-rendered variant, one that clones a `<template>`, one that adopts pre-existing elements — any of them can slot in as long as they write the same keys.
 - **The one above.** `mount` owns subtree creation and teardown itself.
 
@@ -812,23 +969,33 @@ None of the other behaviors change across those permutations. Substitution at th
 
 ## Advanced: Wrapping a composition in a public API
 
-Compositions expose `state`, `owners`, and `destroy` — the right surface for behaviors and internal authors, too much and too low-level for outside consumers. Someone using your counter component doesn't want to write `update(composition.state, { paused: true })`; they want `counter.pause()`. And they don't want to subscribe to a signal; they want to `addEventListener('countchange', ...)`.
+Compositions expose `state`, `context`, and `destroy` — the right surface for behaviors and internal authors, too much and too low-level for outside consumers. Someone using your counter component doesn't want to write `composition.state.paused.set(true)`; they want `counter.pause()`. And they don't want to subscribe to a signal; they want to `addEventListener('countchange', ...)`.
 
-A wrapper sits in front of the composition and projects exactly the surface you choose. A `Counter` class that extends `EventTarget` gives consumers a DOM-shaped API:
+A wrapper sits in front of the composition and projects exactly the surface you choose. A `Counter` class that extends `EventTarget` gives consumers a DOM-shaped API. Here we use `shareSignals` to capture the refs the wrapper needs to drive the composition:
 
 ```ts
-import { createComposition, effect, computed, update, type Composition } from '@videojs/spf';
+import {
+  createComposition,
+  defineBehavior,
+  effect,
+  computed,
+  makeShareSignals,
+} from '@videojs/spf';
+import type { Composition, ShareSignalsConfig, StateSignals, ContextSignals } from '@videojs/spf';
 
-// counter, logCount, renderCount, pauseButton, resetButton, persist, renderSaving, cancelOnReset, mount — unchanged from previous sections
+// counter, logCount, renderCount, pauseButton, resetButton, persist, renderSaving, cancelOnReset, mount — unchanged
 
-type CounterState = { count?: number; paused?: boolean };
-type CounterOwners = {
+interface CounterState {
+  count?: number;
+  paused?: boolean;
+}
+interface CounterContext {
   rootElement?: HTMLElement;
   renderElement?: HTMLElement;
   savingElement?: HTMLElement;
   pauseBtn?: HTMLElement;
   resetBtn?: HTMLElement;
-};
+}
 
 interface CounterOptions {
   rootElement: HTMLElement;
@@ -839,9 +1006,12 @@ interface CounterOptions {
   autoSaveEveryTicks?: number;
 }
 
+const shareSignals = makeShareSignals<CounterState, CounterContext>();
+
 class Counter extends EventTarget {
   readonly #options: Required<CounterOptions>;
-  readonly #composition: Composition<CounterState, CounterOwners>;
+  readonly #composition: Composition<CounterState, CounterContext>;
+  readonly #signals: { state: StateSignals<CounterState>; context: ContextSignals<CounterContext> };
   #teardowns: Array<() => void> | undefined;
 
   constructor(options: CounterOptions) {
@@ -856,24 +1026,35 @@ class Counter extends EventTarget {
       ...options,
     };
 
+    let captured!: { state: StateSignals<CounterState>; context: ContextSignals<CounterContext> };
+
     this.#composition = createComposition(
-      [counter, logCount, renderCount, pauseButton, resetButton, persist, renderSaving, cancelOnReset, mount],
+      [counter, logCount, renderCount, pauseButton, resetButton, persist, renderSaving, cancelOnReset, mount, shareSignals],
       {
         initialState: { count: this.#options.initialCount, paused: this.#options.paused },
         config: {
           interval: this.#options.tickIntervalMs,
           defaultText: this.#options.placeholder,
           saveEvery: this.#options.autoSaveEveryTicks,
+          onSignalsReady: (refs) => {
+            captured = refs;
+          },
+        } satisfies ShareSignalsConfig<CounterState, CounterContext> & {
+          interval?: number;
+          defaultText?: string;
+          saveEvery?: number;
         },
-        initialOwners: { rootElement: this.#options.rootElement },
+        initialContext: { rootElement: this.#options.rootElement },
       },
     );
 
+    this.#signals = captured;
+
     // One effect per state-derived event. Each reads a single `computed`,
     // so it only re-runs when that specific value changes — no local
     // "what changed this time?" diffing across fields.
-    const count = computed(() => this.#composition.state.get().count);
-    const paused = computed(() => this.#composition.state.get().paused);
+    const count = computed(() => this.#signals.state.count.get());
+    const paused = computed(() => this.#signals.state.paused.get());
 
     this.#teardowns = [
       effect(() => {
@@ -890,23 +1071,23 @@ class Counter extends EventTarget {
   }
 
   get count(): number {
-    return this.#composition.state.get().count ?? this.#options.initialCount;
+    return this.#signals.state.count.get() ?? this.#options.initialCount;
   }
 
   get paused(): boolean {
-    return this.#composition.state.get().paused ?? this.#options.paused;
+    return this.#signals.state.paused.get() ?? this.#options.paused;
   }
 
   pause(): void {
-    update(this.#composition.state, { paused: true });
+    this.#signals.state.paused.set(true);
   }
 
   resume(): void {
-    update(this.#composition.state, { paused: false });
+    this.#signals.state.paused.set(false);
   }
 
   reset(): void {
-    update(this.#composition.state, { count: 0 });
+    this.#signals.state.count.set(0);
   }
 
   async destroy(): Promise<void> {
@@ -922,7 +1103,7 @@ From outside, consumers see something that looks and feels like a native DOM obj
 
 ```ts
 const counter = new Counter({
-  rootElement: document.getElementById('counter-root'),
+  rootElement: document.getElementById('counter-root')!,
   tickIntervalMs: 100,
   paused: false,
 });
@@ -941,67 +1122,27 @@ console.log(counter.paused);  // false
 await counter.destroy();
 ```
 
-No signals in sight. No `composition.state.get()`, no `update(...)`, no `effect()`. The wrapper maps every piece of the composition surface onto a consumer-shaped primitive: the constructor takes one flat options bag, getters project current state, methods forward to `update()`, and a single bridging `effect()` translates state transitions into events on `this` (which is an `EventTarget`, so `addEventListener` and `dispatchEvent` just work).
+No signals in sight. No `composition.state.count.get()`, no `.set()`, no `effect()`. The wrapper maps every piece of the composition surface onto a consumer-shaped primitive: the constructor takes one flat options bag, getters project current state, methods forward to writes via the captured refs, and a single bridging `effect()` translates state transitions into events on `this` (which is an `EventTarget`, so `addEventListener` and `dispatchEvent` just work).
 
-The options shape is also its own translation layer. Consumers don't see the `state` / `config` / `initialOwners` split the composition uses internally; they pass one bag of named values. The constructor merges those over defaults into a `#options` object, then splits it across `createComposition` — `initialCount` and `paused` seed state, `tickIntervalMs` / `placeholder` / `autoSaveEveryTicks` become internal config keys (`interval`, `defaultText`, `saveEvery`), and `rootElement` seeds owners. `#options` stays around so the getters can reuse those defaulted values — `count` falls through to `this.#options.initialCount` when state is unset. `reset()` keeps its own hard-coded `0`: that value triggers the composition's `cancelOnReset` behavior, so it belongs to the internal contract rather than the caller-facing options.
+Two things `shareSignals` is doing here. First, it gives the wrapper a clean place to capture writable refs without spreading composition knowledge across every method — `pause()`, `resume()`, `reset()` all write through `this.#signals`, not through `this.#composition.state`. Second, it makes the boundary explicit: "these are the slots external code is allowed to drive." If a future change makes some slots read-only on the public surface, the `shareSignals` callback's parameter type is the natural place to declare it.
+
+The options shape is also its own translation layer. Consumers don't see the `state` / `config` / `initialContext` split the composition uses internally; they pass one bag of named values. The constructor merges those over defaults into a `#options` object, then splits it across `createComposition` — `initialCount` and `paused` seed state, `tickIntervalMs` / `placeholder` / `autoSaveEveryTicks` become internal config keys (`interval`, `defaultText`, `saveEvery`), and `rootElement` seeds context. `#options` stays around so the getters can reuse those defaulted values — `count` falls through to `this.#options.initialCount` when state is unset. `reset()` keeps its own hard-coded `0`: that value triggers the composition's `cancelOnReset` behavior, so it belongs to the internal contract rather than the caller-facing options.
 
 The bridge is one effect per derivation, not one effect that diffs every field on each run. `count` and `paused` are pulled out as `computed` signals; each gets its own `effect` dispatching the matching event; and the pair of stop functions is held on `#teardowns`. No `lastCount` / `lastPaused` flags to keep in sync, and each effect re-runs only when its own derivation's value changes. The inverse shape — a single `effect` that reads the whole state and compares each field to a local `let last*` — is imperative diffing wearing a reactive costume; it works, but it stops scaling the moment a third or fourth field shows up.
 
 `destroy()` is the one place the wrapper's own cleanup lives. It iterates `#teardowns` to stop every bridging effect, clears the array so a second `destroy()` is a no-op, then awaits `this.#composition.destroy()` to tear down every behavior. Consumers get a single `Promise` to await.
 
-More events can be wired the same way — a `saving`/`saved` pair reading `saveActor.snapshot`, a `destroy` event dispatched before teardown, custom events derived from any signal worth surfacing. Each is another `computed` + `effect` pushed onto `#teardowns`. The pattern scales: every piece of composition state that matters to a consumer gets its own projection.
-
-### Bridge as a behavior?
-
-The `#teardowns` array is a small piece of manual lifecycle tracking — we create effects, hold their stop functions, run them on destroy. That's the same shape we had at the very start of the doc, when `setInterval` and `stopLogging` lived outside the composition and the caller had to manage both. Moving them inside as behaviors tied their cleanup to `composition.destroy()` automatically. So why isn't the bridge a behavior too?
-
-It could be. A `forwardEvents` behavior that took the `EventTarget` itself as an owner would work:
-
-```ts
-function forwardEvents({
-  state,
-  owners,
-}: {
-  state: Signal<{ count?: number; paused?: boolean }>;
-  owners: Signal<{ target?: EventTarget }>;
-}) {
-  const count = computed(() => state.get().count);
-  const paused = computed(() => state.get().paused);
-
-  const stopCount = effect(() => {
-    const { target } = owners.get();
-    if (!target) return;
-    target.dispatchEvent(new CustomEvent('countchange', { detail: count.get() ?? 0 }));
-  });
-
-  const stopPaused = effect(() => {
-    const { target } = owners.get();
-    if (!target) return;
-    target.dispatchEvent(new Event(paused.get() ? 'pause' : 'play'));
-  });
-
-  return () => {
-    stopCount();
-    stopPaused();
-  };
-}
-```
-
-The wrapper would pass `this` through `initialOwners.target`, and `#teardowns` would disappear — `composition.destroy()` would handle it.
-
-We didn't do that, because the bridge is adapter work, not composition work. Dispatching `CustomEvent('countchange')` knows about the public API shape — the event name, the `detail` payload, the fact that a consumer is listening to an `EventTarget` at all. None of that has anything to do with the composition's domain. Leaving the bridge on the wrapper keeps that split clean: behaviors do composition work, the wrapper translates to the consumer-shaped surface. The `#teardowns` bookkeeping is a small cost paid to keep composition concerns from leaking out.
-
-This is the Adapter shape — the composition stays generic; the wrapper projects whatever surface the consumer expects.
+More events can be wired the same way — a `saving`/`saved` pair reading `saveActor.snapshot` (which is reachable via `this.#signals.context.saveActor`), a `destroy` event dispatched before teardown, custom events derived from any signal worth surfacing. Each is another `computed` + `effect` pushed onto `#teardowns`. The pattern scales: every piece of composition state that matters to a consumer gets its own projection.
 
 ---
 
 ## Bringing it all together
 
-By the end of the last section, we'd built a running counter with an internal tick, a logger, a DOM renderer, two buttons, a save pipeline, a save actor with observable status, automatic cancel-on-reset, a root-creating mount behavior, and an adapter wrapper with a DOM-shaped public API — nine behaviors in total, each a small function, each unaware of the others. Everything above this section taught how that works by doing. This section pulls the patterns out into the open: what holds across every composition, what's always optional, and what the model is really asking of you.
+By the end of the last section, we'd built a running counter with an internal tick, a logger, a DOM renderer, two buttons, a save pipeline, a save actor with observable status, automatic cancel-on-reset, a root-creating mount behavior, a `shareSignals` passthrough, and an adapter wrapper with a DOM-shaped public API — eleven behaviors in total, each a small unit, each unaware of the others. Everything above this section taught how that works by doing. This section pulls the patterns out into the open: what holds across every composition, what's always optional, and what the model is really asking of you.
 
 ### Additive, not rewriting
 
-Every section added new behaviors without touching the ones that came before. `counter` and `logCount` stayed the same from State onward; `renderCount` stayed the same from Owners onward; the buttons from Reactors onward. New capabilities landed as appended behaviors in the composition list, not as edits to existing ones.
+Every section added new behaviors without touching the ones that came before. `counter` and `logCount` stayed the same from State onward; `renderCount` stayed the same from Context onward; the buttons from Reactors onward. New capabilities landed as appended behaviors in the composition list, not as edits to existing ones.
 
 The exceptions are informative. `counter` was redefined in Reactors — its internal `setInterval` became a reactor-managed effect so it could enter and leave a `running` state. `persist` was redefined in Actors — its runner and in-flight flag moved into a dedicated actor, and `persist` itself shrank to a message forwarder. Neither rewrite reached outside the behavior being replaced: `counter` still read and wrote `state.count`; `persist` still triggered on the same Nth-tick condition. The contract each behavior exposed stayed stable; the implementation swapped.
 
@@ -1009,30 +1150,43 @@ That's the normal way to extend a composition. Replace a behavior with a differe
 
 ### Use what you need
 
-None of the primitives are mandatory. A composition with one behavior that increments `count` is a real composition — no reactors, no tasks, no actors, no owners, no wrapper. Each primitive exists to solve a problem that a simpler shape couldn't:
+None of the primitives are mandatory. A composition with one behavior that increments `count` is a real composition — no reactors, no tasks, no actors, no context, no wrapper. Each primitive exists to solve a problem that a simpler shape couldn't:
 
 - **Reactors** earn their keep when lifecycle depends on state — setup runs while a condition holds, teardown fires when it stops, and nothing has to guard "is this still relevant?" on each tick.
 - **Tasks** earn their keep when async work needs introspection or cancellation. If a plain Promise works, a plain Promise is fine.
 - **Actors** earn their keep when the imperative work a behavior performs is observable state the rest of the composition needs to see or drive.
-- **Owner-creating behaviors** earn their keep when a composition needs several related resources that share a lifecycle.
+- **Context-creating behaviors** earn their keep when a composition needs several related resources that share a lifecycle.
+- **`shareSignals`** earns its keep when external code needs structured access to drive the composition over its lifetime.
 - **Adapter wrappers** earn their keep when the public API shape diverges from the composition's internal signals.
 
 Each is reachable when the problem becomes real, and sits out of the way when it doesn't. The cost of unused primitives is zero — you never imported them.
 
 ### Contracts, not couplings
 
-No behavior in this doc imported another. `renderCount` doesn't know `counter` exists; `cancelOnReset` doesn't know `persist` or the actor factory by name. The only interface between behaviors is the shape of their shared signals — state keys, owners keys, config keys. If two behaviors agree on a key and its type, they can coordinate; if they don't share a key, they're invisible to each other.
+No behavior in this doc imported another. `renderCount` doesn't know `counter` exists; `cancelOnReset` doesn't know `persist` or the actor factory by name. The only interface between behaviors is the shape of their shared signals — state slots, context slots, config keys. If two behaviors agree on a slot and its type, they can coordinate; if they don't share a slot, they're invisible to each other.
 
-That's why additive composition works. A new behavior only needs to declare which keys it reads and writes. The composition-level type system takes care of merging its declarations with everyone else's and fails at compile time if a key's type disagrees across behaviors. Nothing has to be taught about a new behavior; nothing gets broken by removing one.
+That's why additive composition works. A new behavior only needs to declare which slots it reads and writes. The composition-level type system takes care of merging its declarations with everyone else's and fails at compile time if a slot's type disagrees across behaviors. Nothing has to be taught about a new behavior; nothing gets broken by removing one.
+
+### Multi-writer slots are accepted patterns
+
+A given slot can have multiple writers. The framework doesn't enforce a "single writer per slot" rule — it leaves that judgment to the author. Three patterns recur:
+
+- **Pipeline / patch.** Multiple behaviors each write a different aspect of the same logical object, building on each other (e.g. an adapter seeds an initial value; downstream behaviors progressively patch in derived fields).
+- **Intent + reactive default.** One writer is the default-pick (e.g. ABR setting `selectedTrack`); another writer is an external override; a mode flag (`abrDisabled`) disambiguates which one is currently in charge.
+- **Two-way DOM sync.** A slot is both a DOM observer's output (DOM event → signal) and a controller's input (signal → drives DOM). The slot is a coordination point.
+
+Per-slot read/write annotations keep these patterns visible at each behavior's setup signature. A reviewer can scan the writer set across behaviors without spelunking bodies.
 
 ### Conventions we leaned on
 
 A handful of conventions keep showing up because they pay off across every shape a composition can take. All of them surface earlier in this doc; this is just the index.
 
-- **Guard for missing owners.** Every behavior that reads an owner checks `if (!ownerKey) return;` before using it. Owners can arrive late or be cleared, and effects re-run when they do; the guard is what makes that safe.
+- **Guard for missing context.** Every behavior that reads a context slot checks `if (!resourceKey) return;` before using it. Resources can arrive late or be cleared, and effects re-run when they do; the guard is what makes that safe.
+- **Per-slot read/write annotations.** Setup-param slots are typed as `Signal<T>` (writable) or `ReadonlySignal<T>` (read-only). Body-level enforcement falls out structurally — TS rejects `.set()` on a read-only slot — and the signature documents intent.
 - **Isolate dependencies with `computed`.** When an effect's side effect is non-idempotent (scheduling a save, dispatching an event), wrap the specific field the effect cares about in `computed` so an unrelated state write doesn't re-fire it.
 - **One effect per derivation.** When a wrapper translates multiple state fields into separate events, each gets its own `effect` reading its own `computed`. Single-effect-with-diff-flags is imperative tracking wearing a reactive costume.
-- **Options bag, flat.** Public constructors take one caller-facing options bag; the wrapper splits it across `initialState` / `config` / `initialOwners` internally. Consumers never see the split.
+- **Options bag, flat.** Public constructors take one caller-facing options bag; the wrapper splits it across `initialState` / `config` / `initialContext` internally. Consumers never see the split.
+- **Capture refs once via `shareSignals`.** Wrappers and adapters use `shareSignals` to capture writable refs at composition setup, not by reaching into `composition.state` per method. Keeps the public surface and the internal composition decoupled.
 - **Cleanup returned, not scattered.** Behaviors return their cleanup function (or an object with `destroy()`), and the composition runs them all on destroy. External lifetime management (like the `#teardowns` array in the Counter wrapper) is only for things outside the composition.
 
-Everything in this doc is fundamentals. Real compositions do more — more behaviors, richer state, deeper owner graphs, multiple actors — but none of the primitives change shape. Once the composition model is familiar, the rest is your domain.
+Everything in this doc is fundamentals. Real compositions do more — more behaviors, richer state, deeper context graphs, multiple actors — but none of the primitives change shape. Once the composition model is familiar, the rest is your domain.
diff --git a/packages/spf/docs/hls-engine.md b/packages/spf/docs/hls-engine.md
index 494b4a88..e022d2b2 100644
--- a/packages/spf/docs/hls-engine.md
+++ b/packages/spf/docs/hls-engine.md
@@ -15,9 +15,11 @@ For SPF primitives (signals, reactors, tasks, actors), see [fundamentals.md](./f
 `createSimpleHlsEngine` is a thin wrapper around `createComposition`. The full composition, lifted from `src/playback/engines/hls/engine.ts`:
 
 ```ts
+const shareSignals = makeShareSignals<SimpleHlsEngineState, SimpleHlsEngineContext>();
+
 export function createSimpleHlsEngine(
   config: SimpleHlsEngineConfig = {}
-): Composition<SimpleHlsEngineState, SimpleHlsEngineOwners> {
+): Composition<SimpleHlsEngineState, SimpleHlsEngineContext> {
   return createComposition(
     [
       syncPreloadAttribute,
@@ -57,8 +59,14 @@ export function createSimpleHlsEngine(
       syncTextTracks,
       setupTextTrackActors,
       loadTextTrackCues,
+
+      // Hands writable signal refs to the consumer's onSignalsReady callback
+      // so external code (the adapter, or any direct consumer) can drive the
+      // engine. Placed last so other behaviors' setup has run by the time the
+      // callback fires — initial state writes are visible to the consumer.
+      shareSignals,
     ],
-    { config, initialState, initialOwners }
+    { config, initialState }
   );
 }
 ```
@@ -67,15 +75,15 @@ Read top to bottom, the engine tells a story: resolve a manifest, pick tracks, s
 
 Three things are doing the work here:
 
-1. **`createComposition`** — the SPF primitive that wires the behaviors together. It owns the lifecycle and gives each behavior access to two shared reactive channels — `state` and `owners` — plus the engine's static `config`.
-2. **The behaviors** — independent functions, each declaring its slice of the state and owners shapes and its job.
-3. **The engine wrapper** — a few small helpers that adapt behaviors to the engine's specific needs (closing over media types, threading config). Nothing structural; just glue.
+1. **`createComposition`** — the SPF primitive that wires the behaviors together. It owns the lifecycle, derives the state and context signal maps from each behavior's declared `stateKeys` / `contextKeys`, and gives each behavior access to the slots it asks for plus the engine's static `config`.
+2. **The behaviors** — independent, type-specialized objects built with `defineBehavior`. Each declares which slots it reads and writes and contributes its body. No engine-side wrappers — `selectVideoTrack`, `loadAudioSegments`, etc. are imported directly from their behavior modules.
+3. **`shareSignals`** — a generic passthrough behavior that hands the composition's writable signal refs to a consumer-supplied `config.onSignalsReady` callback at setup time. The canonical way to drive the engine from outside.
 
 The rest of this doc walks each stage.
 
 ---
 
-## State, owners, and config
+## State, context, and config
 
 Every SPF composition is parameterized by three shapes:
 
@@ -97,7 +105,7 @@ export interface SimpleHlsEngineState {
   mediaSourceReadyState?: MediaSource['readyState'];
 }
 
-export interface SimpleHlsEngineOwners {
+export interface SimpleHlsEngineContext {
   mediaElement?: HTMLMediaElement;
   mediaSource?: MediaSource;
   videoBuffer?: SourceBuffer;
@@ -108,7 +116,7 @@ export interface SimpleHlsEngineOwners {
   segmentLoaderActor?: TextTrackSegmentLoaderActor;
 }
 
-export interface SimpleHlsEngineConfig {
+export interface SimpleHlsEngineConfig extends ShareSignalsConfig<SimpleHlsEngineState, SimpleHlsEngineContext> {
   initialBandwidth?: number;
   preferredAudioLanguage?: string;
   preferredSubtitleLanguage?: string;
@@ -119,13 +127,13 @@ export interface SimpleHlsEngineConfig {
 
 The split:
 
-- **State** holds reactive playback data — the manifest, selected track ids, current time, bandwidth estimate. It flows through the composition over time. Each field is a slot in the state signal that any behavior can read or write.
-- **Owners** holds **resources** — values with identity and imperative interfaces, not just data. The `<video>` element, the `MediaSource`, source buffers, the actors managing text-track lifecycles. If you'd pass the thing around by reference and call methods on it, it belongs in owners. Behaviors observe and act on resources directly; the signal makes their lifecycle (appearance, replacement, removal) reactive.
-- **Config** holds static creation-time options — thresholds, language preferences, feature flags. It doesn't change during the engine's lifetime. Behaviors read it directly, usually with a fallback.
+- **State** holds reactive playback data — the manifest, selected track ids, current time, bandwidth estimate. It flows through the composition over time. Each field is its own discrete signal that any behavior can read or (if the behavior typed the slot writable) write.
+- **Context** holds **resources** — values with identity and imperative interfaces, not just data. The `<video>` element, the `MediaSource`, source buffers, the actors managing text-track lifecycles. If you'd pass the thing around by reference and call methods on it, it belongs in context. Behaviors observe and act on resources directly; the signal makes their lifecycle (appearance, replacement, removal) reactive.
+- **Config** holds static creation-time options — thresholds, language preferences, feature flags. It doesn't change during the engine's lifetime. Behaviors read it directly, usually with a fallback. The HLS engine's config also extends `ShareSignalsConfig<S, C>` so consumers can pass `onSignalsReady` to capture writable signal refs (see Stage 10).
 
 The shapes are unions of what every behavior in the composition needs. Adding a new behavior that requires a new state field means adding it to the engine's state interface. Removing a behavior is the inverse.
 
-Each behavior receives `{ state, owners, config }` and reads or writes only the slots it cares about. Nothing else. A behavior that only reads `mediaElement` doesn't know about `bandwidthState` and can't accidentally interact with it. (The HLS engine's source aliases this argument shape as `Deps` for brevity in the wrapper helpers — it's a local convenience, not framework vocabulary.)
+Each behavior receives `{ state, context, config }` — but only the slots it declared. The body literally cannot reference slots it didn't list, because the setup-param type only includes them. A behavior that only reads `mediaElement` doesn't see `bandwidthState` and can't accidentally interact with it. **Per-slot read/write intent is part of the type:** `Signal<T>` for writable slots, `ReadonlySignal<T>` for read-only — TS rejects `.set()` on a slot typed read-only.
 
 ---
 
@@ -147,6 +155,29 @@ resolvePresentation,
 
 A pattern shows up here that recurs throughout: **behaviors gate themselves on preconditions and write their results back to state.** They don't take inputs as function arguments. They read from a known signal slot, do their work, and write to a known signal slot. The composition is wired through state, not through call ordering.
 
+Look at `selectVideoTrack`'s setup signature — the pattern in miniature:
+
+```ts
+export const selectVideoTrack = defineBehavior({
+  stateKeys: ['presentation', 'selectedVideoTrackId'],
+  contextKeys: [],
+  setup: ({ state }: {
+    state: {
+      presentation: ReadonlySignal<TrackSelectionState['presentation']>;
+      selectedVideoTrackId: Signal<TrackSelectionState['selectedVideoTrackId']>;
+    };
+  }) =>
+    effect(() => {
+      const presentation = state.presentation.get();
+      if (!presentation || state.selectedVideoTrackId.get()) return;
+      const id = pickFirstTrackId(presentation, 'video');
+      if (id) state.selectedVideoTrackId.set(id);
+    }),
+});
+```
+
+`presentation` is `ReadonlySignal` — the body can `.get()` it but not `.set()` (TS would reject the call). `selectedVideoTrackId` is `Signal` — readable and writable. `stateKeys` is the runtime expression of the same contract: the composition uses it to derive the state signal map.
+
 ---
 
 ## Stage 2 — Track selection
@@ -159,33 +190,20 @@ selectAudioTrack,
 selectTextTrack,
 ```
 
-These are *wrappers* defined in `engine.ts` that share their names with — and close over — the imported behaviors from `playback/behaviors/select-tracks.ts`. The imported behaviors accept their own configuration parameter (initial bandwidth for video, preferred language for audio, and so on); the wrapper closes over the engine's config and threads the relevant fields into the behavior:
+Each is a separate `defineBehavior` export from `playback/behaviors/select-tracks.ts`, with narrow `stateKeys` matching exactly the slots it touches:
 
-```ts
-import { selectVideoTrack as _selectVideoTrack } from '../../behaviors/select-tracks';
+- `selectVideoTrack` declares `['presentation', 'selectedVideoTrackId']`
+- `selectAudioTrack` declares `['presentation', 'selectedAudioTrackId']`
+- `selectTextTrack` declares `['presentation', 'selectedTextTrackId']` and reads `config` for preferred-language / default-track preferences
 
-const selectVideoTrack = ({ config, ...deps }: Deps) =>
-  _selectVideoTrack(deps, {
-    type: 'video',
-    ...(config.initialBandwidth !== undefined && { initialBandwidth: config.initialBandwidth }),
-  });
-```
-
-The wrapper takes the natural name; the imported behavior gets a leading-underscore alias for local use. The composition list reads as a flat list of behaviors at the right level of abstraction — the wrappers vanish into anonymity, which is exactly right since they're just adapter glue.
-
-This is the **wrapper pattern** that recurs throughout the engine. Two kinds, both visible in the composition list:
-
-- **Media-type wrappers** (`loadVideoSegments`, `resolveVideoTrack`, …) close over a fixed `type: 'video' | 'audio' | 'text'` value. Their underlying behavior takes the type as config; the wrapper makes it concrete.
-- **Config-aware wrappers** (`selectVideoTrack`, `switchQuality`, the engine-local versions) close over the engine's config and pass relevant fields to the underlying behavior's own config parameter.
-
-The wrappers exist because the underlying behaviors are **engine-agnostic** — `_selectVideoTrack` doesn't know about `SimpleHlsEngineConfig` or that `bandwidthState` lives on engine state. It accepts a `VideoSelectionConfig` from its caller. The engine wrapper is the thin layer that says "for this engine's config, the initial bandwidth comes from `config.initialBandwidth`."
+The behaviors share a small `pickFirstTrackId` helper for the presentation traversal, but the bodies are inlined per type. No engine-side wrappers, no `config.type` discriminant carried at runtime — each export is type-honest about which signal it writes (`state.selectedVideoTrackId.set(...)` vs. `state.selectedAudioTrackId.set(...)`).
 
 The behaviors themselves are split across two locations on purpose:
 
-- **Pure logic** lives in `media/primitives/select-tracks.ts` — `pickVideoTrack`, `pickAudioTrack`, `pickTextTrack`, `canSelectTrack`, `shouldSelectTrack`. No signals, no effects. Just functions that take a `Presentation` and a config and return an id.
+- **Pure logic** lives in `media/primitives/select-tracks.ts` — `pickVideoTrack`, `pickAudioTrack`, `pickTextTrack`. No signals, no effects. Just functions that take a `Presentation` and a config and return an id.
 - **Orchestrations** live in `playback/behaviors/select-tracks.ts` — `selectVideoTrack`, `selectAudioTrack`, `selectTextTrack`. These wrap the pure logic in `effect()`, gate on preconditions, and write the chosen id to `state.selected{Video,Audio,Text}TrackId`.
 
-The split keeps the SPF-free CML-style helpers reusable outside SPF, while the SPF-integrated behaviors stay thin and easy to swap.
+The split keeps the framework-free helpers reusable outside SPF, while the SPF-integrated behaviors stay thin and easy to swap.
 
 ---
 
@@ -199,15 +217,20 @@ resolveAudioTrack,
 resolveTextTrack,
 ```
 
-These are media-type wrappers around the same `resolveTrack` behavior:
+Like the selection behaviors, these are per-type specialized exports from `playback/behaviors/resolve-track.ts`. They share an internal helper `setupTrackResolution<K>(state, type, selectedKey)` that takes the type literal and the selected-track key as parameters; each export binds them at module load:
 
 ```ts
-const resolveVideoTrack = (deps: Deps) => resolveTrack(deps, { type: 'video' as const });
+export const resolveVideoTrack = defineBehavior({
+  stateKeys: ['presentation', 'selectedVideoTrackId'],
+  contextKeys: [],
+  setup: ({ state }: { state: ResolveTrackStateMap<'selectedVideoTrackId'> }) =>
+    setupTrackResolution(state, 'video', 'selectedVideoTrackId'),
+});
 ```
 
-`resolveTrack` watches `state.presentation` and the matching `selectedXTrackId` for its type. When both are set, it finds the partially-resolved track, fetches its media playlist, parses it into segments, and writes the now-resolved track back into `state.presentation`. (The `Presentation` type allows tracks to hold either a partially-resolved or fully-resolved shape — the URL is enough to find a track; the segments are what loadSegments needs.)
+`setupTrackResolution` watches `state.presentation` and the matching `selectedXTrackId` for its type. When both are set, it finds the partially-resolved track, fetches its media playlist, parses it into segments, and writes the now-resolved track back into `state.presentation`. The state slot map is parameterized: `presentation` is `Signal<...>` (writable — the helper writes resolved tracks back to it), the selected-track key is `ReadonlySignal<...>` (the helper only reads it).
 
-Three behaviors, one shared `resolveTrack`. Each closes over its `type` so the composition list stays flat. From outside, you'd hardly know they share an implementation.
+Three behaviors, one shared helper. From outside, you'd hardly know they share an implementation.
 
 Now `state.presentation` is fully populated for the selected tracks. Everything downstream — duration, MSE, segment loading, end-of-stream — reads from there.
 
@@ -219,10 +242,12 @@ Now `state.presentation` is fully populated for the selected tracks. Everything
 calculatePresentationDuration,
 ```
 
-`calculatePresentationDuration` reads the resolved tracks and computes the presentation's total duration (max of selected track durations). It writes the result back to `state.presentation.duration`. This is a small bookkeeping behavior — the duration is derived from data already in state — but breaking it out keeps the derivation reactive: any downstream behavior that needs to know the duration just reads `state.presentation.duration`, and re-runs when it changes.
+`calculatePresentationDuration` reads the resolved tracks and computes the presentation's total duration (max of selected track durations). It writes the result back to `state.presentation` (patching the `duration` field onto the existing presentation). This is a small bookkeeping behavior — the duration is derived from data already in state — but breaking it out keeps the derivation reactive: any downstream behavior that needs to know the duration just reads `state.presentation.duration`, and re-runs when it changes.
 
 It's separated from `resolveTrack` because the duration depends on *which* tracks are selected (the engine could change selection later, in theory, with a different duration). Keeping the derivation in its own behavior means every track-selection change automatically re-derives.
 
+This is also the simplest example of the **pipeline pattern** on `state.presentation`: multiple behaviors write the same slot, each owning a different aspect of the value. The adapter seeds `{ url }`; `resolvePresentation` parses the manifest; `resolve{Video,Audio,Text}Track` patches in per-track segments; `calculatePresentationDuration` patches in the duration. Each writer reads the current value and writes a new one with their field added — they never overwrite a field someone else owns.
+
 ---
 
 ## Stage 5 — MSE setup
@@ -237,19 +262,19 @@ setupSourceBuffers,
 
 This is where the engine first touches the media element directly. Up until now, behaviors have been operating on plain data in `state` — manifests, URLs, ids, durations. MSE is the bridge: a `MediaSource` attaches to the `<video>` element via `srcObject` (or an object URL), and `SourceBuffer`s under it accept appended segments.
 
-**`setupMediaSource`** waits for two preconditions: a `mediaElement` in owners and a `presentation.url` in state. When both arrive, it creates a `MediaSource`, attaches it to the element, and writes both back to owners (`mediaSource`) and state (`mediaSourceReadyState`). The DOM event for "MediaSource is open" is bridged onto `state.mediaSourceReadyState` via the `onMediaSourceReadyStateChange` callback primitive — once that flips to `'open'`, the `mediaSource` is published to owners so downstream behaviors can use it.
+**`setupMediaSource`** waits for two preconditions: a `mediaElement` in context and a `presentation.url` in state. When both arrive, it creates a `MediaSource`, attaches it to the element, and writes both back to context (`mediaSource`) and state (`mediaSourceReadyState`). The DOM event for "MediaSource is open" is bridged onto `state.mediaSourceReadyState` via the `onMediaSourceReadyStateChange` callback primitive — once that flips to `'open'`, the `mediaSource` is published to context so downstream behaviors can use it.
 
-The split between owners and state is deliberate. The MediaSource itself is a resource — you call `addSourceBuffer()` on it, you set its `duration` — so it lives in owners. Its readyState is data — a string that other behaviors gate decisions on — so it lives in state. The DOM events that drive readyState changes get bridged into the SPF signal graph by the small primitive in `media/dom/mse/`, keeping `setupMediaSource` clean.
+The split between context and state is deliberate. The MediaSource itself is a resource — you call `addSourceBuffer()` on it, you set its `duration` — so it lives in context. Its readyState is data — a string that other behaviors gate decisions on — so it lives in state. The DOM events that drive readyState changes get bridged into the SPF signal graph by the small primitive in `media/dom/mse/`, keeping `setupMediaSource` clean.
 
 **`updateDuration`** waits for the resolved presentation duration (from stage 4) and a MediaSource that's open with idle source buffers, then writes `mediaSource.duration = presentation.duration`. The order matters: setting duration while a SourceBuffer has `updating === true` throws `InvalidStateError`, so the behavior waits for any in-flight appends to settle before writing.
 
 This is the first place the engine has real coordination concerns: timing among multiple resources. The behavior expresses it declaratively — `effect()` re-runs when any input signal changes, and the gate function checks every precondition. There's no manual sequencing, no callbacks-on-callbacks. Each precondition becomes a signal read; the framework figures out when to fire.
 
-**`setupSourceBuffers`** does the same lifecycle dance as `setupMediaSource`, but per-track: when a video or audio track is resolved and the MediaSource is open, it calls `addSourceBuffer()` with the track's mime/codec, wraps the resulting `SourceBuffer` in a `SourceBufferActor`, and publishes both the raw buffer and the actor onto owners.
+**`setupSourceBuffers`** does the same lifecycle dance as `setupMediaSource`, but per-track: when a video or audio track is resolved and the MediaSource is open, it calls `addSourceBuffer()` with the track's mime/codec, wraps the resulting `SourceBuffer` in a `SourceBufferActor`, and publishes both the raw buffer and the actor onto context.
 
 The actor wrapping is worth pausing on. A raw `SourceBuffer` is imperative: you call `appendBuffer(data)`, you wait for the `updateend` event, you handle errors. Multiple appends can collide. An actor — a state machine that owns the buffer — gives every consumer a single point of contact. They send a message ("append this segment"); the actor serializes the work, exposes its current state via a snapshot signal, and behaves predictably even when several behaviors want to write at once.
 
-So owners ends up with both `videoBuffer` (the raw `SourceBuffer`, used by `endOfStream` to read `buffered` ranges) and `videoBufferActor` (the wrapper, used by `loadSegments` to send append messages). Same lifetime, two roles.
+So context ends up with both `videoBuffer` (the raw `SourceBuffer`, used by `endOfStream` to read `buffered` ranges) and `videoBufferActor` (the wrapper, used by `loadSegments` to send append messages). Same lifetime, two roles.
 
 ---
 
@@ -264,15 +289,17 @@ switchQuality,
 
 **`trackCurrentTime`** mirrors the media element's `currentTime` onto `state.currentTime`. Same shape as `syncPreloadAttribute` from stage 1: the DOM event becomes a signal write, and downstream behaviors gate on the reactive value rather than polling the element. `loadSegments` reads it to know how far ahead to fetch; `endOfStream` reads it to know whether the user has reached the end.
 
-**`switchQuality`** is the ABR loop. It watches `state.bandwidthState` (a running estimate, written by `loadSegments` after each successful segment fetch) and `state.selectedVideoTrackId`. When the estimate moves enough to justify a switch, it writes a different `selectedVideoTrackId`. That triggers `resolveVideoTrack` → `setupSourceBuffers` (if mime/codec changes) → `loadSegments` to start fetching from the new variant. (Like the track-selection wrappers, this is the engine's local version that closes over engine config; the underlying behavior is imported as `_switchQuality`.)
+**`switchQuality`** is the ABR loop. It watches `state.bandwidthState` (a running estimate, written by `loadVideoSegments` after each successful segment fetch) and `state.selectedVideoTrackId`. When the estimate moves enough to justify a switch, it writes a different `selectedVideoTrackId`. That triggers `resolveVideoTrack` → `setupSourceBuffers` (if mime/codec changes) → `loadVideoSegments` to start fetching from the new variant.
 
 Two patterns worth pausing on:
 
-- **State is the bus.** The bandwidth estimator doesn't push to the quality switcher. The quality switcher doesn't pull from the loader. Both read `state.bandwidthState` and respond. Adding a third behavior that needs the estimate (a buffer-health probe, a telemetry stream) is the same: another reader, no rewiring.
+- **State is the bus.** The bandwidth estimator (`loadVideoSegments`) doesn't push to the quality switcher. The quality switcher doesn't pull from the loader. Both read `state.bandwidthState` and respond. Adding a third behavior that needs the estimate (a buffer-health probe, a telemetry stream) is the same: another reader, no rewiring.
 - **Selection cascades.** Changing `selectedVideoTrackId` doesn't tell anything to "re-resolve, re-buffer, re-load." It just changes the value. The behaviors downstream were already reading it; they'll re-run because `effect()` tracked their reads. Re-resolution and re-buffering happen because the framework noticed.
 
 The engine has no orchestrator. Each behavior is a small reactor plus a cleanup. The composition is the dataflow.
 
+`switchQuality` is also the third writer to `selectedVideoTrackId` — `selectVideoTrack` does the default-pick on presentation load; `switchQuality` updates it for ABR; external code (the harness's manual rendition picker) overrides. The slot has multiple legitimate writers, disambiguated today via the `abrDisabled` flag (when true, `switchQuality` short-circuits). This is the **intent + reactive default** multi-writer pattern. A cleaner factoring exists (separate `manual` + `abr` slots, derive selected as `manual ?? abr`); see the TODO at `quality-switching.ts`.
+
 ---
 
 ## Stage 7 — Segment loading
@@ -282,15 +309,17 @@ loadVideoSegments,
 loadAudioSegments,
 ```
 
-Two media-type wrappers around `loadSegments`. This is the busiest behavior — the one that actually fetches segments, samples bandwidth, and pushes data into the source buffers.
+Two type-specialized exports from `playback/behaviors/dom/load-segments.ts`. They share an internal helper `setupSegmentLoading(state, context, type, onThroughputSample?)` — the throughput-sample callback is what makes `bandwidthState` writable for `loadVideoSegments` (passes `(next) => state.bandwidthState.set(next)`) and read-only for `loadAudioSegments` (audio doesn't sample bandwidth).
+
+This is the busiest behavior — the one that actually fetches segments, samples bandwidth, and pushes data into the source buffers.
 
 `loadSegments` watches:
 - `state.presentation` — for the resolved track of its type
 - `state.selectedVideoTrackId` (or audio) — to know which track's segments to load
 - `state.currentTime` — to know how far ahead to fetch
-- `state.bandwidthState` — to keep a running estimate after each fetch
-- `owners.videoBufferActor` (or audio) — to send append messages
-- `owners.mediaSource` — to know it's safe to operate on the buffer
+- `state.bandwidthState` — to keep a running estimate after each fetch (writable for video, read-only for audio)
+- `context.videoBufferActor` (or audio) — to send append messages
+- `context.mediaSource` — to know it's safe to operate on the buffer
 
 When the preconditions are met, the behavior:
 
@@ -315,17 +344,17 @@ A single behavior, but one that has to coordinate across the rest of the pipelin
 `endOfStream` reads:
 - `state.presentation` and `state.selected{Video,Audio}TrackId` — to know which tracks' last segments to wait for
 - `state.mediaSourceReadyState` — must be `'open'` (not `'ended'` or `'closed'`)
-- `owners.mediaElement` — to check `readyState >= HAVE_METADATA` (a precondition Chrome enforces)
-- `owners.{video,audio}Buffer` — must exist for selected tracks
-- `owners.{video,audio}BufferActor` — to know if any are still updating
-- `owners.{video,audio}BufferActor.snapshot.context.segments` — to verify the last segment of each selected track has been appended
+- `context.mediaElement` — to check `readyState >= HAVE_METADATA` (a precondition Chrome enforces)
+- `context.{video,audio}Buffer` — must exist for selected tracks
+- `context.{video,audio}BufferActor` — to know if any are still updating
+- `context.{video,audio}BufferActor.snapshot.context.segments` — to verify the last segment of each selected track has been appended
 
-Every one of those reads happens inside an `effect()`. When *any* changes, the gate function reruns. When all preconditions line up, the behavior calls `mediaSource.endOfStream()`.
+Every one of those reads happens inside an `effect()`. When *any* changes, the gate function reruns. When all preconditions line up, the behavior calls `mediaSource.endOfStream()`. Notably, `endOfStream` writes nothing — every state and context slot in its setup signature is `ReadonlySignal<T>`. The body's effect on the world is a DOM property assignment (`mediaSource.duration = ...`) and a method call (`mediaSource.endOfStream()`), not a signal write.
 
 Two things this behavior makes visible about SPF compositions:
 
-- **Coordination is just reading.** No callbacks, no publish/subscribe, no event bus. The behavior reads from state and owners; the reactive graph re-runs it whenever any read changes. A composition with N behaviors and one shared state signal has N inputs to coordinate, not N² connections.
-- **Actor snapshots are signals too.** `owners.videoBufferActor?.snapshot.get()` is a regular signal read inside the effect. When the actor transitions from `'updating'` to `'idle'`, the snapshot signal fires, the effect re-runs, and `endOfStream` re-evaluates whether the gate is now passable. Actor state and engine state are the same kind of channel from a behavior's point of view.
+- **Coordination is just reading.** No callbacks, no publish/subscribe, no event bus. The behavior reads from state and context; the reactive graph re-runs it whenever any read changes. A composition with N behaviors and one shared state signal has N inputs to coordinate, not N² connections.
+- **Actor snapshots are signals too.** `context.videoBufferActor?.snapshot.get()` is a regular signal read inside the effect. When the actor transitions from `'updating'` to `'idle'`, the snapshot signal fires, the effect re-runs, and `endOfStream` re-evaluates whether the gate is now passable. Actor state and engine state are the same kind of channel from a behavior's point of view.
 
 The behavior also handles the seek-back case: if `appendBuffer` re-opens an `'ended'` MediaSource (per the MSE spec, a fresh append on an ended buffer transitions readyState back to `'open'`), `endOfStream` re-evaluates and may call `endOfStream()` again once the new last segment lands.
 
@@ -341,46 +370,58 @@ loadTextTrackCues,
 
 Text tracks are an interesting wrinkle. They don't go through MSE — VTT cues land directly on the `<track>` elements of the media element. The shape of this stage is therefore different from the MSE pipeline above: there are no source buffers, no append serialization, no end-of-stream gate. But the SPF patterns are the same.
 
-**`syncTextTracks`** mirrors the resolved text-track list onto `<track>` elements under the media element. When a text track is selected (`state.selectedTextTrackId`), the matching `<track>` element gets `mode = 'showing'`; others go to `'disabled'`. This is reactive: changing the selection in state re-runs the effect, which flips the modes.
+**`syncTextTracks`** mirrors the resolved text-track list onto `<track>` elements under the media element. When a text track is selected (`state.selectedTextTrackId`), the matching `<track>` element gets `mode = 'showing'`; others go to `'disabled'`. The behavior also writes back to `selectedTextTrackId` when the user selects a track via the browser's native UI — making it a two-way DOM sync.
 
-**`setupTextTrackActors`** is the actor-provider for text tracks, parallel to `setupSourceBuffers` for video/audio. It creates two actors — `TextTracksActor` (owns the cue list per track) and `TextTrackSegmentLoaderActor` (orchestrates per-segment fetches via the VTT resolver) — and publishes them onto owners.
+**`setupTextTrackActors`** is the actor-provider for text tracks, parallel to `setupSourceBuffers` for video/audio. It creates two actors — `TextTracksActor` (owns the cue list per track) and `TextTrackSegmentLoaderActor` (orchestrates per-segment fetches via the VTT resolver) — and publishes them onto context.
 
-In the engine, this is a wrapper that closes over the DOM-bound VTT resolver (`resolveVttSegment`):
-
-```ts
-import { setupTextTrackActors as _setupTextTrackActors } from '../../behaviors/dom/setup-text-track-actors';
-
-const setupTextTrackActors = ({ owners }: Deps) =>
-  _setupTextTrackActors({ owners, config: { resolveTextTrackSegment: resolveVttSegment } });
-```
-
-The underlying `_setupTextTrackActors` (in `playback/behaviors/dom/`) is parser-agnostic — it accepts any `resolveTextTrackSegment` function. The DOM-specific binding (using a hidden `<video>` + `<track>` element to leverage the browser's VTT parser) happens at the engine layer. A different engine could supply a different parser without changing the behavior.
+The cue parser (`resolveTextTrackSegment`) is supplied via engine config — it defaults to the DOM-bound `resolveVttSegment` resolver, which uses an offscreen `<track>` element to leverage the browser's VTT parser. A different engine could supply a different parser (a worker-based parser, a native VTT parser if one ever ships, etc.) without changing the behavior.
 
 **`loadTextTrackCues`** is the orchestrator. It watches the resolved text track and the actors, and dispatches `load` messages to the segment loader actor whenever new segments need fetching. The actor handles per-segment fetching (and abort on track switch); the orchestrator decides *when* to ask.
 
-This is the same pattern as MSE: actor-as-resource (`setupTextTrackActors` puts it on owners), orchestrator-as-behavior (`loadTextTrackCues` decides when to send messages). Different platform, same shape.
+This is the same pattern as MSE: actor-as-resource (`setupTextTrackActors` puts it on context), orchestrator-as-behavior (`loadTextTrackCues` decides when to send messages). Different platform, same shape.
 
 ---
 
-## Two ways to call `createComposition`
-
-A note on the engine's call to `createComposition` itself.
-
-The HLS engine uses the *explicit* form — passing `<S, O, C>` type arguments to fix the engine's shape directly:
+## Stage 10 — `shareSignals`: external write surface
 
 ```ts
-return createComposition<SimpleHlsEngineState, SimpleHlsEngineOwners, SimpleHlsEngineConfig>(
-  [...behaviors],
-  { config, initialState, initialOwners }
-);
+shareSignals,
 ```
 
-The minimal/inferred form lets TypeScript intersect each behavior's deps to compute the engine's shape:
+Placed last in the composition for a reason. `shareSignals` is a generic passthrough behavior that hands the composition's writable signal refs to a consumer-supplied `config.onSignalsReady` callback at composition setup. Every other behavior has run by the time the callback fires, so initial state writes are visible to the consumer.
 
 ```ts
-const engine = createComposition([myBehavior]);
+const engine = createSimpleHlsEngine({
+  initialBandwidth: 2_000_000,
+  onSignalsReady: ({ state, context }) => {
+    // capture refs for later writes — keep the references, write through them.
+    capturedState = state;
+    capturedContext = context;
+  },
+});
 ```
 
-For engines that aggregate many wrapper-style behaviors (`(deps: Deps) => behavior(deps, {...})`) all sharing the same `Behavior<S, O, C>` type, TypeScript's distributive intersection inference can drop fields — e.g. for the HLS engine, `bandwidthState` would silently disappear from the inferred state, and `initialState: { bandwidthState: ... }` would be flagged as an unknown property. The explicit form sidesteps the inference and uses the engine's declared shapes directly.
+The captured refs are the same `Signal<T>` objects every behavior in the composition shares. Writing through them drives the engine the same way an internal behavior would.
 
-The inferred form remains the right call for small or single-behavior compositions where the per-feature state slices are the source of truth. For aggregating engines, prefer explicit.
+In `@videojs/spf/hls`, `SimpleHlsMediaMixin` is the canonical consumer. Its `attach()` / `set src` / `set preload` / `play()` methods all forward to writes on the captured refs:
+
+```ts
+attach(mediaElement: HTMLMediaElement): void {
+  this.#signals.context.mediaElement.set(mediaElement);
+}
+
+set src(value: string) {
+  // ... destroy previous engine, create new one ...
+  this.#signals.state.presentation.set({ url: value });
+}
+
+play(): Promise<void> {
+  // Signal play intent — enables loading even with preload="none"
+  this.#signals.state.playbackInitiated.set(true);
+  return this.#signals.context.mediaElement.get().play();
+}
+```
+
+`shareSignals` is generic — the same factory works for any composition, parameterized over the engine's state/context shapes. `makeShareSignals<S, C>()` returns a `Behavior<StateSignals<S>, ContextSignals<C>, ShareSignalsConfig<S, C>>`. The HLS engine instantiates it once at module load.
+
+Multi-writer slots are part of the picture here. `presentation` is written by the consumer (initial `{ url }` seed) AND by `resolvePresentation` (parsed manifest) AND by `resolve{Video,Audio,Text}Track` (per-track segments) AND by `calculatePresentationDuration` (duration). Each owns a different aspect — the pipeline pattern. `mediaElement` is written only externally — single-source, no internal writers. Per-slot read/write annotations make these patterns visible at each behavior's setup signature, not enforce a uniform "0-or-1 writer per slot" rule.
diff --git a/packages/spf/package.json b/packages/spf/package.json
index 4e641657..ddd072a9 100644
--- a/packages/spf/package.json
+++ b/packages/spf/package.json
@@ -47,7 +47,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "clean": "rimraf --glob dist types '*.tsbuildinfo'",
-    "size": "node scripts/measure-size.js --playback-engine",
+    "size": "node scripts/measure-size.js --hls",
     "size:all": "node scripts/measure-size.js --all"
   },
   "dependencies": {
diff --git a/packages/spf/scripts/measure-size.js b/packages/spf/scripts/measure-size.js
index fa81b94a..219ba031 100755
--- a/packages/spf/scripts/measure-size.js
+++ b/packages/spf/scripts/measure-size.js
@@ -4,7 +4,7 @@
  * Measure SPF bundle size
  *
  * Usage:
- *   pnpm size                    # Measure playback engine
+ *   pnpm size                    # Measure the HLS engine entry (@videojs/spf/hls)
  *   pnpm size:all                # Measure all exports (all.ts)
  */
 
@@ -13,7 +13,7 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import { gzipSync } from 'node:zlib';
 
 const measureAll = process.argv.includes('--all');
-const measureEngine = process.argv.includes('--playback-engine');
+const measureEngine = process.argv.includes('--hls');
 
 let entry, label, bundlePath;
 
@@ -22,8 +22,8 @@ if (measureAll) {
   label = 'All Exports';
   bundlePath = './dist/all.js';
 } else if (measureEngine) {
-  entry = 'dom/playback-engine/index.ts';
-  label = 'Playback Engine';
+  entry = 'playback/engines/hls/index.ts';
+  label = 'HLS Engine';
   bundlePath = './dist/index.js';
 } else {
   entry = 'index.ts';
diff --git a/packages/spf/src/all.ts b/packages/spf/src/all.ts
index 7a3060e1..225aa808 100644
--- a/packages/spf/src/all.ts
+++ b/packages/spf/src/all.ts
@@ -91,7 +91,7 @@ export { fetchResolvable, getResponseText } from './network/fetch';
 
 export type { PresentationState } from './playback/behaviors/resolve-presentation';
 export { canResolve, resolvePresentation, shouldResolve } from './playback/behaviors/resolve-presentation';
-export type { PlatformOwners } from './playback/behaviors/sync-preload-attribute';
+export type { PlatformContext } from './playback/behaviors/sync-preload-attribute';
 export { syncPreloadAttribute } from './playback/behaviors/sync-preload-attribute';
 
 // =============================================================================
diff --git a/packages/spf/src/core/composition/create-composition.ts b/packages/spf/src/core/composition/create-composition.ts
index e567b8e0..e316d472 100644
--- a/packages/spf/src/core/composition/create-composition.ts
+++ b/packages/spf/src/core/composition/create-composition.ts
@@ -1,4 +1,4 @@
-import { type Signal, signal } from '../signals/primitives';
+import { type ReadonlySignal, type Signal, signal } from '../signals/primitives';
 
 /**
  * Cleanup returned by a behavior. Behaviors may return:
@@ -9,65 +9,175 @@ import { type Signal, signal } from '../signals/primitives';
 export type BehaviorCleanup = void | (() => void | Promise<void>) | { destroy(): void | Promise<void> };
 
 /**
- * The deps object passed to each behavior by the engine.
+ * A signal map keyed by the fields of `S`. Each field is a writable signal.
  *
- * - `state` — shared reactive state signal
- * - `owners` — shared reactive owners signal (platform objects)
- * - `config` — static configuration, passed once at engine creation
+ * Optional fields on `S` map to required signal slots whose value type
+ * includes `undefined`, ensuring every key has a signal even when the
+ * underlying value is absent.
+ *
+ * Used in two roles:
+ * - Engine-side **construction**: `Composition<S, C>` exposes its public
+ *   surface as `StateSignals<S>` (everything writable) so external code
+ *   can read or write any slot.
+ * - Behavior **input convenience**: a behavior that writes to every slot
+ *   can type its setup state param as `StateSignals<{ ... }>` rather than
+ *   spelling out per-slot `Signal<T>` types.
+ *
+ * Behaviors that mix read-only and writable slots type the setup param
+ * directly as a slot map (`{ x: Signal<T>; y: ReadonlySignal<U> }`)
+ * instead of going through `StateSignals<>`.
  */
-export interface BehaviorDeps<S extends object, O extends object, C extends object> {
-  state: Signal<S>;
-  owners: Signal<O>;
-  config: C;
+export type StateSignals<S extends object> = { [K in keyof S]-?: Signal<S[K]> };
+
+/**
+ * A signal map keyed by the fields of `C`. Each field is a writable signal
+ * for a platform object or actor reference. Same dual role as
+ * `StateSignals<S>` — see its docblock.
+ */
+export type ContextSignals<C extends object> = { [K in keyof C]-?: Signal<C[K]> };
+
+/**
+ * Slot-map shape — a record where each value is at least a `ReadonlySignal`.
+ * `Signal<T>` is structurally a subtype of `ReadonlySignal<T>` (it adds
+ * `.set()`), so a writable slot satisfies this bound too.
+ *
+ * This is the bound used for behavior `state` / `context` slot maps. It
+ * lets a single behavior declare a *heterogeneous* slot map where some
+ * slots are `Signal<T>` (writable) and others are `ReadonlySignal<T>`
+ * (read-only) — making read/write intent explicit at the call site and
+ * giving body-level enforcement (TS rejects `.set()` on a read-only slot).
+ */
+export type AnySlotMap = Record<PropertyKey, ReadonlySignal<unknown>>;
+
+/**
+ * The deps object passed to each behavior by the composition.
+ *
+ * - `state` — slot map for state fields (reactive data). Per-slot read/
+ *   write intent expressed via `Signal<T>` vs `ReadonlySignal<T>`.
+ * - `context` — slot map for platform objects and actor references.
+ * - `config` — static configuration, passed once at composition creation.
+ */
+export interface BehaviorDeps<StateMap extends AnySlotMap, ContextMap extends AnySlotMap, Cfg extends object> {
+  state: StateMap;
+  context: ContextMap;
+  config: Cfg;
 }
 
 /**
- * A behavior is a function that receives deps (state, owners, config)
- * and returns an optional cleanup handle.
+ * A behavior announces the state and context keys it needs alongside a
+ * `setup` function that receives deps (state, context, config) and
+ * returns an optional cleanup handle.
  *
- * Each behavior declares its own state/owners/config shape via its
- * parameter type. The engine's types are determined by the composition.
+ * The `stateKeys` / `contextKeys` declarations are the runtime expression
+ * of the behavior's contract — the caller (e.g. `createComposition`) uses
+ * them to know which signals to provide. The setup parameter type
+ * declares the *slot map* (per-slot `Signal<T>` vs `ReadonlySignal<T>`);
+ * together they form a complete contract.
+ *
+ * Manual `Behavior<>` literals (e.g. engine wrappers that forward keys
+ * from a wrapped behavior, or pass-through behaviors like `shareSignals`)
+ * opt out of exhaustiveness — the type alias is permissive (subset).
+ * Source behaviors should use `defineBehavior` to get exhaustiveness
+ * enforcement at the call site.
  */
-export type Behavior<S extends object, O extends object, C extends object> = (
-  deps: BehaviorDeps<S, O, C>
-) => BehaviorCleanup;
+export interface Behavior<
+  StateMap extends AnySlotMap = Empty,
+  ContextMap extends AnySlotMap = Empty,
+  Cfg extends object = Empty,
+> {
+  /** State keys this behavior reads/writes. Subset of `keyof StateMap`. */
+  stateKeys: readonly (keyof StateMap)[];
+  /** Context keys this behavior reads/writes. Subset of `keyof ContextMap`. */
+  contextKeys: readonly (keyof ContextMap)[];
+  setup: (deps: BehaviorDeps<StateMap, ContextMap, Cfg>) => BehaviorCleanup;
+}
 
 // =============================================================================
 // Behavior type inference
 // =============================================================================
 
-/** A behavior function with unconstrained deps — used as a generic bound. */
-// biome-ignore lint/suspicious/noExplicitAny: required for generic behavior inference
-type AnyBehavior = (deps: any) => BehaviorCleanup;
+/** A behavior with an unconstrained setup — used as a generic bound. */
+type AnyBehavior = {
+  stateKeys: readonly PropertyKey[];
+  contextKeys: readonly PropertyKey[];
+  setup: (deps: any) => BehaviorCleanup;
+};
 
-/** Extract the first parameter (deps) type from a behavior function. */
-// biome-ignore lint/suspicious/noExplicitAny: required for conditional type inference
-type DepsOf<F> = F extends (deps: infer D, ...args: any[]) => any ? D : never;
+/** Extract the deps type from a behavior's setup function. */
+type DepsOf<B> = B extends { setup: (deps: infer D, ...args: any[]) => any } ? D : never;
 
-/** Infer the state type a behavior requires from its deps parameter. */
-export type InferBehaviorState<F> = DepsOf<F> extends { state: Signal<infer S extends object> } ? S : object;
+/**
+ * Empty-object fallback used when a behavior omits state, context, or config.
+ *
+ * Using `{}` rather than `object` is deliberate — `object & {x: T}` collapses
+ * to `{x: never}` under TS's union-to-intersection conversion in some inference
+ * contexts (likely a TS quirk around the `object` upper bound), whereas
+ * `{} & {x: T}` simplifies cleanly to `{x: T}`.
+ */
+// biome-ignore lint/complexity/noBannedTypes: see comment above
+type Empty = {};
 
-/** Infer the owners type a behavior requires from its deps parameter. */
-export type InferBehaviorOwners<F> = DepsOf<F> extends { owners: Signal<infer O extends object> } ? O : object;
+/**
+ * Unwrap a signal map back to its state/context shape.
+ *
+ * Inferring through `{ get(): infer V }` rather than `Signal<infer V>`
+ * sidesteps `Signal`'s nominal/invariance behaviour — the conditional
+ * matches structurally on the read side, and `V` is inferred covariantly.
+ */
+type UnwrapSignals<M> = M extends object ? { [K in keyof M]: M[K] extends { get(): infer V } ? V : never } : Empty;
 
-/** Infer the config type a behavior requires from its deps parameter. */
-export type InferBehaviorConfig<F> = DepsOf<F> extends { config: infer C extends object } ? C : object;
+/** Infer the state shape a behavior requires from its deps parameter. */
+export type InferBehaviorState<F> = DepsOf<F> extends { state: infer M } ? UnwrapSignals<M> : Empty;
 
-/** Convert a union to an intersection: `A | B` → `A & B`. */
-// biome-ignore lint/suspicious/noExplicitAny: required for distributive conditional type
-type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+/** Infer the context shape a behavior requires from its deps parameter. */
+export type InferBehaviorContext<F> = DepsOf<F> extends { context: infer M } ? UnwrapSignals<M> : Empty;
 
-/** Resolve the combined state type from an array of behaviors (intersection of all requirements). */
+/** Infer the config shape a behavior requires from its deps parameter. */
+export type InferBehaviorConfig<F> = DepsOf<F> extends { config: infer C extends object } ? C : Empty;
+
+/**
+ * Recursively intersect a per-behavior projection across the tuple.
+ *
+ * Iterating over the tuple directly avoids `UnionToIntersection`'s
+ * function-contravariance trick, which produces unstable intersections
+ * (collapsing concrete fields to `never` or unrelated types) when one of the
+ * union members is the empty `{}` fallback.
+ */
+type IntersectBehaviors<Behaviors extends readonly AnyBehavior[], Project extends object> = Behaviors extends readonly [
+  infer First extends AnyBehavior,
+  ...infer Rest extends readonly AnyBehavior[],
+]
+  ? Apply<Project, First> & IntersectBehaviors<Rest, Project>
+  : Empty;
+
+/**
+ * Apply a projection (one of the marker types below) to a single behavior.
+ * Encoded as a discriminated dispatch so the recursion above can stay generic
+ * and we don't have to write three near-identical recursive types.
+ */
+type Apply<Project extends object, F> = Project extends { kind: 'state' }
+  ? InferBehaviorState<F>
+  : Project extends { kind: 'context' }
+    ? InferBehaviorContext<F>
+    : Project extends { kind: 'config' }
+      ? InferBehaviorConfig<F>
+      : never;
+
+type StateProjection = { kind: 'state' };
+type ContextProjection = { kind: 'context' };
+type ConfigProjection = { kind: 'config' };
+
+/** Resolve the combined state shape from an array of behaviors (intersection of all requirements). */
 export type ResolveBehaviorState<Behaviors extends readonly AnyBehavior[]> =
-  UnionToIntersection<InferBehaviorState<Behaviors[number]>> extends infer R extends object ? R : object;
+  IntersectBehaviors<Behaviors, StateProjection> extends infer R extends object ? R : Empty;
 
-/** Resolve the combined owners type from an array of behaviors (intersection of all requirements). */
-export type ResolveBehaviorOwners<Behaviors extends readonly AnyBehavior[]> =
-  UnionToIntersection<InferBehaviorOwners<Behaviors[number]>> extends infer R extends object ? R : object;
+/** Resolve the combined context shape from an array of behaviors (intersection of all requirements). */
+export type ResolveBehaviorContext<Behaviors extends readonly AnyBehavior[]> =
+  IntersectBehaviors<Behaviors, ContextProjection> extends infer R extends object ? R : Empty;
 
-/** Resolve the combined config type from an array of behaviors (intersection of all requirements). */
+/** Resolve the combined config shape from an array of behaviors (intersection of all requirements). */
 export type ResolveBehaviorConfig<Behaviors extends readonly AnyBehavior[]> =
-  UnionToIntersection<InferBehaviorConfig<Behaviors[number]>> extends infer R extends object ? R : object;
+  IntersectBehaviors<Behaviors, ConfigProjection> extends infer R extends object ? R : Empty;
 
 /**
  * True if any property in `T` collapsed to `undefined` or `never` — indicating
@@ -82,58 +192,6 @@ type HasConflict<T extends object> = true extends {
   ? true
   : false;
 
-// =============================================================================
-// Owners compatibility (subtype-based)
-//
-// Unlike state/config (where intersection catches primitive conflicts),
-// owners hold concrete platform objects where class hierarchy matters.
-// Two behaviors sharing an owner key are compatible only if their types
-// are in a subtype relationship (one extends the other).
-// =============================================================================
-
-/** Strip `undefined` from a type so optionality doesn't affect subtype checks. */
-type NonUndefined<T> = T extends undefined ? never : T;
-
-/**
- * Check that two owners types are compatible: for each overlapping key,
- * one type must extend the other (ignoring optionality).
- *
- * - `{ el?: HTMLElement }` + `{ el?: HTMLVideoElement }` → valid (HTMLVideoElement extends HTMLElement)
- * - `{ el?: HTMLCanvasElement }` + `{ el?: HTMLVideoElement }` → invalid (neither extends the other)
- * - `{ el?: HTMLElement }` + `{ buffer?: SourceBuffer }` → valid (no overlapping keys)
- */
-type OwnersCompatible<A extends object, B extends object> = [Extract<keyof A, keyof B>] extends [never]
-  ? true
-  : false extends {
-        [K in Extract<keyof A, keyof B>]: [NonUndefined<A[K]>] extends [NonUndefined<B[K]>]
-          ? true
-          : [NonUndefined<B[K]>] extends [NonUndefined<A[K]>]
-            ? true
-            : false;
-      }[Extract<keyof A, keyof B>]
-    ? false
-    : true;
-
-/** Check one behavior's owners against all remaining behaviors. */
-type CheckOwnersAgainstRest<Owners extends object, Rest extends readonly AnyBehavior[]> = Rest extends readonly [
-  infer Next,
-  ...infer Remaining extends readonly AnyBehavior[],
-]
-  ? OwnersCompatible<Owners, InferBehaviorOwners<Next>> extends true
-    ? CheckOwnersAgainstRest<Owners, Remaining>
-    : false
-  : true;
-
-/** Check all pairs of behaviors' owners for subtype compatibility. */
-type AllOwnersCompatible<Behaviors extends readonly AnyBehavior[]> = Behaviors extends readonly [
-  infer First,
-  ...infer Rest extends readonly AnyBehavior[],
-]
-  ? CheckOwnersAgainstRest<InferBehaviorOwners<First>, Rest> extends true
-    ? AllOwnersCompatible<Rest>
-    : false
-  : true;
-
 // =============================================================================
 // Composition validation
 // =============================================================================
@@ -142,105 +200,145 @@ type AllOwnersCompatible<Behaviors extends readonly AnyBehavior[]> = Behaviors e
  * Validate that a behavior composition has no type conflicts.
  * Returns the behaviors tuple if valid, or an error message type if conflicts are detected.
  *
- * - State/config: checked via intersection — conflicting primitives produce `never`/`undefined`
- * - Owners: checked via subtype — shared keys must have types in an extends relationship
+ * State, context, and config are all checked the same way — by intersecting
+ * each behavior's requirement and looking for collapsed fields. The
+ * intersection-based check applies the same rule to context as to state, so
+ * two behaviors that disagree on a context field's type (e.g. `Surface` vs
+ * `VideoSurface`) surface a conflict at compose time. The prior subtype-based
+ * approach for owners is gone — the unified rule is simpler and catches the
+ * cases where two behaviors silently agreed on a wider supertype.
  */
 type ValidateComposition<Behaviors extends readonly AnyBehavior[]> =
   HasConflict<ResolveBehaviorState<Behaviors>> extends true
     ? 'Error: behaviors have conflicting state types'
-    : AllOwnersCompatible<Behaviors> extends false
-      ? 'Error: behaviors have incompatible owners types'
+    : HasConflict<ResolveBehaviorContext<Behaviors>> extends true
+      ? 'Error: behaviors have conflicting context types'
       : HasConflict<ResolveBehaviorConfig<Behaviors>> extends true
         ? 'Error: behaviors have conflicting config types'
         : [...Behaviors];
 
 // =============================================================================
-// Engine
+// Composition
 // =============================================================================
 
 /**
- * A composition of behaviors with shared reactive state, owners, and config.
- *
- * Generic over the state and owners shapes, which are determined by the
- * specific behaviors passed to `createComposition`.
+ * A composition of behaviors with shared state and context signal maps.
  */
-export interface Composition<S extends object, O extends object> {
-  state: Signal<S>;
-  owners: Signal<O>;
+export interface Composition<S extends object, C extends object> {
+  state: StateSignals<S>;
+  context: ContextSignals<C>;
   destroy(): Promise<void>;
 }
 
 /**
- * Options for `createComposition`. All fields are optional.
+ * Options for `createComposition`.
+ *
+ * Composition derives the state and context signal maps from each
+ * behavior's declared `stateKeys` / `contextKeys`; `initialState` and
+ * `initialContext` seed those signals at creation time. Any unseeded
+ * signal starts as `undefined`.
  */
-export interface CompositionOptions<S extends object, O extends object, C extends object> {
+export interface CompositionOptions<S extends object, C extends object, Cfg extends object> {
   /** Static configuration passed to every behavior. */
-  config?: C;
-  /** Initial value for the state signal. */
-  initialState?: S;
-  /** Initial value for the owners signal. */
-  initialOwners?: O;
+  config?: Cfg;
+  /** Initial values for state signals — any subset of `keyof S`. */
+  initialState?: Partial<S>;
+  /** Initial values for context signals — any subset of `keyof C`. */
+  initialContext?: Partial<C>;
 }
 
 /**
- * Create a composition by composing behaviors.
+ * Create a composition from a set of behaviors.
  *
- * `createComposition` is generic — it knows nothing about HLS, DASH,
- * or any specific protocol. It creates shared reactive state, wires
- * each behavior to that state, and returns the composition interface.
+ * Composition unions the behaviors' declared `stateKeys` / `contextKeys`
+ * to know which signals to create. Each signal is seeded from
+ * `initialState` / `initialContext` when supplied, defaulting to
+ * `undefined`. Behaviors are responsible for writing their own slots
+ * once their preconditions are met.
  *
- * Two ways to call:
- *
- * 1. **Inferred** — pass behaviors and let TypeScript intersect their
- *    deps to compute the engine's state, owners, and config shapes.
- *    Best when behaviors declare narrow per-feature shapes.
- * 2. **Explicit** — supply `<S, O, C>` type arguments and the engine
- *    uses those shapes directly. Best for engines that aggregate many
- *    wrapper-style behaviors all sharing the same `Behavior<S, O, C>`
- *    type — TypeScript's distributive intersection inference can drop
- *    types in that case, so explicit arguments are more reliable.
- *
- * @param behaviors - Array of behavior functions
- * @param options - Optional config, initial state, and initial owners
+ * Cross-behavior type conflicts (e.g. two behaviors disagreeing on a
+ * field's type) surface as a compose-time type error via
+ * `ValidateComposition`.
  *
  * @example
  * ```ts
- * // 1. Inferred
- * const engine = createComposition([resolvePresentation, selectVideoTrack]);
- *
- * // 2. Explicit (engine declares its full state/owners/config up front)
- * const engine = createComposition<MyState, MyOwners, MyConfig>(
- *   [behavior1, behavior2, ...],
- *   { config, initialState, initialOwners }
- * );
+ * const composition = createComposition([resolvePresentation, selectVideoTrack], {
+ *   config: { initialBandwidth: 2_000_000 },
+ *   initialState: { bandwidthState: { fastEstimate: 0, ... } },
+ * });
  * ```
  */
+/**
+ * Create a typed signal map for a given set of keys, seeded from an
+ * optional partial initial value.
+ *
+ * Pipeline: `Set` dedupes the iterable (insertion order preserved, so
+ * first occurrence wins) → `Object.fromEntries` materializes one
+ * `signal()` per unique key, seeded from `initial[key]` or `undefined`.
+ *
+ * Per-key value types live in TypeScript only — at runtime every signal
+ * is `Signal<unknown>`. The boundary cast at the return narrows the wide
+ * `Record<PropertyKey, Signal<unknown>>` shape to the caller's expected
+ * per-key types from `S`.
+ *
+ * Used by `createComposition` to derive engine state/context maps from
+ * the union of behaviors' declared `stateKeys` / `contextKeys`.
+ *
+ * @example
+ * ```ts
+ * interface State { count?: number; label?: string }
+ * const state = buildSignalMap<State>(['count', 'label'], { count: 5 });
+ * state.count.get(); // 5
+ * state.label.get(); // undefined
+ * ```
+ */
+export function buildSignalMap<S extends object>(
+  keys: Iterable<PropertyKey>,
+  initial: Partial<S>
+): { [K in keyof S]-?: Signal<S[K]> } {
+  const init = initial as Record<PropertyKey, unknown>;
+  const uniqueKeys = new Set(keys);
+  return Object.fromEntries([...uniqueKeys].map((key) => [key, signal(init[key])])) as {
+    [K in keyof S]-?: Signal<S[K]>;
+  };
+}
+
 export function createComposition<const Behaviors extends readonly AnyBehavior[]>(
   behaviors: ValidateComposition<Behaviors>,
   options?: CompositionOptions<
     ResolveBehaviorState<Behaviors>,
-    ResolveBehaviorOwners<Behaviors>,
+    ResolveBehaviorContext<Behaviors>,
     ResolveBehaviorConfig<Behaviors>
   >
-): Composition<ResolveBehaviorState<Behaviors>, ResolveBehaviorOwners<Behaviors>>;
-export function createComposition<S extends object, O extends object, C extends object>(
-  behaviors: readonly Behavior<S, O, C>[],
-  options?: CompositionOptions<S, O, C>
-): Composition<S, O>;
-export function createComposition(
-  behaviors: readonly AnyBehavior[],
-  options?: CompositionOptions<object, object, object>
-): Composition<object, object> {
-  const state = signal(options?.initialState ?? {});
-  const owners = signal(options?.initialOwners ?? {});
-  const config = options?.config ?? {};
+): Composition<ResolveBehaviorState<Behaviors>, ResolveBehaviorContext<Behaviors>> {
+  type S = ResolveBehaviorState<Behaviors>;
+  type C = ResolveBehaviorContext<Behaviors>;
+  type Cfg = ResolveBehaviorConfig<Behaviors>;
 
-  const deps: BehaviorDeps<object, object, object> = { state, owners, config };
-  const cleanups = behaviors.map((f) => f(deps));
+  // ValidateComposition<Behaviors> is `[...Behaviors]` on success, an error
+  // string on conflict. The function body only runs when the call typechecks
+  // (i.e. the success case), so iterating as the behavior tuple is sound.
+  const validBehaviors = behaviors as unknown as readonly AnyBehavior[];
+
+  const state = buildSignalMap<S>(
+    validBehaviors.flatMap((b) => b.stateKeys),
+    options?.initialState ?? {}
+  );
+  const context = buildSignalMap<C>(
+    validBehaviors.flatMap((b) => b.contextKeys),
+    options?.initialContext ?? {}
+  );
+
+  const deps: BehaviorDeps<StateSignals<S>, ContextSignals<C>, Cfg> = {
+    state,
+    context,
+    config: (options?.config ?? {}) as Cfg,
+  };
+  const cleanups = validBehaviors.map((behavior) => behavior.setup(deps));
 
   return {
     state,
-    owners,
+    context,
     async destroy() {
       const results: (void | Promise<void>)[] = [];
       for (const cleanup of cleanups) {
@@ -252,9 +350,106 @@ export function createComposition(
         }
       }
       await Promise.all(results);
-      // Clear any keys behaviors registered — or callers seeded via
-      // initialOwners — so the composition ends with an empty owners map.
-      owners.set({});
+      // Reset every signal to undefined as a final cleanup, matching the
+      // prior post-destroy `owners.set({})` semantics. A later stage will
+      // move per-signal cleanup into the behaviors that own the writes.
+      for (const sig of Object.values(state) as Signal<unknown>[]) sig.set(undefined);
+      for (const sig of Object.values(context) as Signal<unknown>[]) sig.set(undefined);
     },
   };
 }
+
+// =============================================================================
+// defineBehavior — typed factory with key/param consistency enforcement
+// =============================================================================
+
+/**
+ * Compose-time exhaustiveness check.
+ *
+ * Adds a phantom error tag to the parameter shape when `Keys` does not
+ * cover every key in `Slot`. The user's value won't satisfy the phantom
+ * field requirement, so TS surfaces the failure at the call site with a
+ * descriptive message. When exhaustive, the tag is `Empty` and adds no
+ * constraint.
+ */
+type ExhaustiveKeys<Keys extends readonly PropertyKey[], Slot extends object, Name extends string> = [
+  keyof Slot,
+] extends [Keys[number]]
+  ? Empty
+  : { [K in `Error: ${Name}Keys must list every key in the typed slice`]: Exclude<keyof Slot, Keys[number]> };
+
+/**
+ * Typed factory for behaviors that enforces single-behavior key/param
+ * consistency: declared `stateKeys` must equal `keyof S` (where `S` is
+ * inferred from the setup's `state` parameter type), and same for
+ * `contextKeys` / `C`.
+ *
+ * The `const` modifier on `SK` / `CK` captures literal tuples so e.g.
+ * `stateKeys: ['preload']` infers as `readonly ['preload']`, no `as
+ * const` needed at the call site.
+ *
+ * Cross-behavior consistency at `createComposition` is unchanged — the
+ * existing `IntersectBehaviors` machinery still runs over each
+ * behavior's setup param type.
+ *
+ * @example
+ * ```ts
+ * export const syncPreloadAttribute = defineBehavior({
+ *   stateKeys: ['preload'],
+ *   contextKeys: ['mediaElement'],
+ *   setup: ({ state, context }: {
+ *     state: StateSignals<{ preload?: 'auto' | 'metadata' | 'none' }>;
+ *     context: ContextSignals<{ mediaElement?: HTMLMediaElement | undefined }>;
+ *   }) => { ... },
+ * });
+ * ```
+ */
+/**
+ * Deps shape for a behavior whose deps slot is empty (no keys). When a
+ * slot is empty, the corresponding deps field is optional — callers
+ * (typically tests) can omit it, and it defaults to `{}` at runtime via
+ * `createComposition`.
+ *
+ * When a slot has at least one key, the behavior reads `state.foo` /
+ * `context.bar` / `config.baz` and we need the field to be required so
+ * the access is type-safe.
+ */
+type RequireIfNonEmpty<Key extends string, T extends object> = keyof T extends never
+  ? { [K in Key]?: T }
+  : { [K in Key]: T };
+
+type DepsForCfg<StateMap extends AnySlotMap, ContextMap extends AnySlotMap, Cfg extends object> = RequireIfNonEmpty<
+  'state',
+  StateMap
+> &
+  RequireIfNonEmpty<'context', ContextMap> &
+  RequireIfNonEmpty<'config', Cfg>;
+
+export function defineBehavior<
+  StateMap extends AnySlotMap = Empty,
+  ContextMap extends AnySlotMap = Empty,
+  Cfg extends object = Empty,
+  const SK extends readonly (keyof StateMap)[] = readonly [],
+  const CK extends readonly (keyof ContextMap)[] = readonly [],
+  R extends BehaviorCleanup = BehaviorCleanup,
+>(
+  behavior: {
+    stateKeys: SK;
+    contextKeys: CK;
+    setup: (deps: { state: StateMap; context: ContextMap; config: Cfg }) => R;
+  } & ExhaustiveKeys<SK, StateMap, 'state'> &
+    ExhaustiveKeys<CK, ContextMap, 'context'>
+): {
+  stateKeys: SK;
+  contextKeys: CK;
+  setup: (deps: DepsForCfg<StateMap, ContextMap, Cfg>) => R;
+} {
+  // The runtime shape is identical; the cast bridges TS's view of the
+  // parameter (config required) to the return view (config optional when
+  // Cfg has no keys).
+  return behavior as unknown as {
+    stateKeys: SK;
+    contextKeys: CK;
+    setup: (deps: DepsForCfg<StateMap, ContextMap, Cfg>) => R;
+  };
+}
diff --git a/packages/spf/src/core/composition/share-signals.ts b/packages/spf/src/core/composition/share-signals.ts
new file mode 100644
index 00000000..ed2538da
--- /dev/null
+++ b/packages/spf/src/core/composition/share-signals.ts
@@ -0,0 +1,51 @@
+import type { Behavior, ContextSignals, StateSignals } from './create-composition';
+
+/**
+ * Config consumed by the `shareSignals` behavior.
+ *
+ * The callback fires once during composition setup with the composition's
+ * state and context signal refs. Capture them to drive the composition
+ * externally (writes) or observe its state (reads).
+ *
+ * The callback runs while other behaviors are still in their setup phase —
+ * for the typical "capture refs, use later" pattern this is fine (signal
+ * refs are stable identities), but reading inside the callback may yield
+ * only initial-seed values rather than what later behaviors write.
+ */
+export interface ShareSignalsConfig<S extends object, C extends object> {
+  onSignalsReady?: (signals: { state: StateSignals<S>; context: ContextSignals<C> }) => void;
+}
+
+/**
+ * Behavior factory that hands the composition's signal refs to a
+ * consumer-supplied callback (`config.onSignalsReady`) at setup time.
+ *
+ * Generic over `S` and `C` — the caller instantiates with their own
+ * state/context types, and the callback's parameter shape is fully
+ * type-driven from those. Suitable for both reads and writes (per-slot
+ * intent can be expressed by typing captured refs as `Signal<T>` or
+ * `ReadonlySignal<T>` at the call site).
+ *
+ * Declares no keys of its own (`stateKeys: []`, `contextKeys: []`); the
+ * composition's state/context maps come from other behaviors' key
+ * declarations. This behavior just observes/forwards whatever signals
+ * the composition built.
+ *
+ * Uses a `Behavior<>` literal (not `defineBehavior`) so the empty key
+ * arrays don't trip the exhaustiveness check — the setup-param state/
+ * context shapes here describe what the consumer's callback receives,
+ * not keys this behavior needs created.
+ */
+export function makeShareSignals<S extends object, C extends object>(): Behavior<
+  StateSignals<S>,
+  ContextSignals<C>,
+  ShareSignalsConfig<S, C>
+> {
+  return {
+    stateKeys: [],
+    contextKeys: [],
+    setup: ({ state, context, config }) => {
+      config.onSignalsReady?.({ state, context });
+    },
+  };
+}
diff --git a/packages/spf/src/core/composition/tests/create-composition-types.test-d.ts b/packages/spf/src/core/composition/tests/create-composition-types.test-d.ts
index a04e74be..fb028334 100644
--- a/packages/spf/src/core/composition/tests/create-composition-types.test-d.ts
+++ b/packages/spf/src/core/composition/tests/create-composition-types.test-d.ts
@@ -1,15 +1,28 @@
-import { describe, it } from 'vitest';
-import { effect } from '../../signals/effect';
-import type { Signal } from '../../signals/primitives';
-import { update } from '../../signals/primitives';
-import { createComposition } from '../create-composition';
+import { describe, expectTypeOf, it } from 'vitest';
+import { type Signal, signal } from '../../signals/primitives';
+import {
+  type Behavior,
+  type BehaviorDeps,
+  buildSignalMap,
+  type Composition,
+  type ContextSignals,
+  createComposition,
+  defineBehavior,
+  type InferBehaviorConfig,
+  type InferBehaviorContext,
+  type InferBehaviorState,
+  type ResolveBehaviorConfig,
+  type ResolveBehaviorContext,
+  type ResolveBehaviorState,
+  type StateSignals,
+} from '../create-composition';
 
 // =============================================================================
-// Host-agnostic stand-in types
+// Stand-in types
 // -----------------------------------------------------------------------------
 // Core is DOM-free. The tests need a small, concrete type to stand in for the
-// kind of thing a user would pass as an owner — something with a writable
-// surface and clear subtype relationships for covariance / non-covariance tests.
+// kind of thing a user would pass as a context value — something with a
+// writable surface and clear subtype relationships for compatibility tests.
 // =============================================================================
 
 interface Surface {
@@ -23,166 +36,889 @@ interface CanvasSurface extends Surface {
 }
 
 // =============================================================================
-// Test behaviors
+// Test behaviors — concrete parameter types
 // =============================================================================
 
-function counter({ state, config }: { state: Signal<{ count?: number }>; config: { interval?: number } }) {
-  const interval = setInterval(() => {
-    update(state, { count: (state.get().count ?? 0) + 1 });
-  }, config.interval ?? 1000);
-  return () => clearInterval(interval);
-}
+const counter = {
+  stateKeys: ['count'] as const,
+  contextKeys: [],
+  setup({ state, config }: { state: StateSignals<{ count?: number }>; config: { interval?: number } }) {
+    state.count.set((state.count.get() ?? 0) + 1);
+    void config;
+  },
+};
 
-function render({
-  state,
-  owners,
-  config,
-}: {
-  state: Signal<{ count?: number }>;
-  owners: Signal<{ renderElement?: Surface }>;
-  config: { defaultText?: string };
-}) {
-  return effect(() => {
-    const { renderElement } = owners.get();
-    if (!renderElement) return;
-    renderElement.textContent = String(state.get().count ?? config.defaultText ?? 'N/A');
+const render = {
+  stateKeys: ['count'] as const,
+  contextKeys: ['renderElement'] as const,
+  setup({
+    state,
+    context,
+    config,
+  }: {
+    state: StateSignals<{ count?: number }>;
+    context: ContextSignals<{ renderElement?: Surface }>;
+    config: { defaultText?: string };
+  }) {
+    const el = context.renderElement.get();
+    if (!el) return;
+    el.textContent = String(state.count.get() ?? config.defaultText ?? 'N/A');
+  },
+};
+
+const persist = {
+  stateKeys: ['count'] as const,
+  contextKeys: [],
+  setup({ state, config }: { state: StateSignals<{ count?: number }>; config: { saveEvery?: number } }) {
+    const c = state.count.get();
+    if (c && c > 0 && c % (config.saveEvery ?? 5) === 0) {
+      // save logic
+    }
+  },
+};
+
+// =============================================================================
+// StateSignals / ContextSignals shape
+// =============================================================================
+
+describe('StateSignals', () => {
+  it('produces one signal per state field', () => {
+    type Map = StateSignals<{ count?: number; label?: string }>;
+    expectTypeOf<Map['count']>().toEqualTypeOf<Signal<number | undefined>>();
+    expectTypeOf<Map['label']>().toEqualTypeOf<Signal<string | undefined>>();
   });
-}
+
+  it('strips optionality on signal slots while preserving undefined in value type', () => {
+    type Map = StateSignals<{ count?: number }>;
+    expectTypeOf<Map>().toEqualTypeOf<{ count: Signal<number | undefined> }>();
+  });
+
+  it('preserves required fields without injecting undefined', () => {
+    type Map = StateSignals<{ count: number }>;
+    expectTypeOf<Map>().toEqualTypeOf<{ count: Signal<number> }>();
+  });
+});
+
+describe('ContextSignals', () => {
+  it('produces one signal per context field', () => {
+    type Map = ContextSignals<{ el?: Surface; flag?: boolean }>;
+    expectTypeOf<Map['el']>().toEqualTypeOf<Signal<Surface | undefined>>();
+    expectTypeOf<Map['flag']>().toEqualTypeOf<Signal<boolean | undefined>>();
+  });
+});
+
+describe('Composition<S, C>', () => {
+  it('exposes state and context as signal maps plus an async destroy', () => {
+    interface State {
+      count?: number;
+    }
+    interface Context {
+      el?: Surface;
+    }
+    type Comp = Composition<State, Context>;
+    expectTypeOf<Comp['state']>().toEqualTypeOf<StateSignals<State>>();
+    expectTypeOf<Comp['context']>().toEqualTypeOf<ContextSignals<Context>>();
+    expectTypeOf<Comp['destroy']>().toEqualTypeOf<() => Promise<void>>();
+  });
+});
+
+describe('BehaviorDeps<StateMap, ContextMap, Cfg>', () => {
+  it('exposes state, context, and config to behaviors', () => {
+    interface State {
+      count?: number;
+    }
+    interface Context {
+      el?: Surface;
+    }
+    interface Cfg {
+      interval?: number;
+    }
+    type Deps = BehaviorDeps<StateSignals<State>, ContextSignals<Context>, Cfg>;
+    expectTypeOf<Deps['state']>().toEqualTypeOf<StateSignals<State>>();
+    expectTypeOf<Deps['context']>().toEqualTypeOf<ContextSignals<Context>>();
+    expectTypeOf<Deps['config']>().toEqualTypeOf<Cfg>();
+  });
+});
 
 // =============================================================================
-// Type error enforcement
+// InferBehavior* — single behavior inference
+// =============================================================================
+
+describe('InferBehaviorState', () => {
+  it('extracts state shape from a behavior that uses signal-map deps', () => {
+    expectTypeOf<InferBehaviorState<typeof counter>>().toEqualTypeOf<{ count: number | undefined }>();
+  });
+
+  it('extracts state shape from a behavior that also uses context', () => {
+    expectTypeOf<InferBehaviorState<typeof render>>().toEqualTypeOf<{ count: number | undefined }>();
+  });
+
+  it('returns an empty shape for a behavior with no state in params', () => {
+    const noState = {
+      stateKeys: [],
+      contextKeys: [],
+      setup: ({ config: _config }: { config: { x: number } }) => {},
+    };
+    // biome-ignore lint/complexity/noBannedTypes: matches the Empty fallback in create-composition
+    expectTypeOf<InferBehaviorState<typeof noState>>().toEqualTypeOf<{}>();
+  });
+});
+
+describe('InferBehaviorContext', () => {
+  it('extracts context shape from a behavior that uses context', () => {
+    expectTypeOf<InferBehaviorContext<typeof render>>().toEqualTypeOf<{ renderElement: Surface | undefined }>();
+  });
+
+  it('returns an empty shape for a behavior with no context in params', () => {
+    // biome-ignore lint/complexity/noBannedTypes: matches the Empty fallback in create-composition
+    expectTypeOf<InferBehaviorContext<typeof counter>>().toEqualTypeOf<{}>();
+  });
+});
+
+describe('InferBehaviorConfig', () => {
+  it('extracts config type from a behavior', () => {
+    expectTypeOf<InferBehaviorConfig<typeof counter>>().toEqualTypeOf<{ interval?: number }>();
+  });
+
+  it('extracts different config types from different behaviors', () => {
+    expectTypeOf<InferBehaviorConfig<typeof render>>().toEqualTypeOf<{ defaultText?: string }>();
+    expectTypeOf<InferBehaviorConfig<typeof persist>>().toEqualTypeOf<{ saveEvery?: number }>();
+  });
+});
+
+// =============================================================================
+// ResolveBehavior* — multi-behavior composition inference
+// =============================================================================
+
+describe('ResolveBehaviorState', () => {
+  it('intersects state from multiple behaviors with matching shapes', () => {
+    type Behaviors = [typeof counter, typeof render, typeof persist];
+    expectTypeOf<ResolveBehaviorState<Behaviors>>().toEqualTypeOf<{ count: number | undefined }>();
+  });
+
+  it('intersects different state shapes', () => {
+    const a = {
+      stateKeys: ['count'] as const,
+      contextKeys: [],
+      setup: (_deps: { state: StateSignals<{ count?: number }> }) => {},
+    };
+    const b = {
+      stateKeys: ['label'] as const,
+      contextKeys: [],
+      setup: (_deps: { state: StateSignals<{ label?: string }> }) => {},
+    };
+    type Behaviors = [typeof a, typeof b];
+    expectTypeOf<ResolveBehaviorState<Behaviors>>().toMatchTypeOf<{
+      count: number | undefined;
+      label: string | undefined;
+    }>();
+  });
+});
+
+describe('ResolveBehaviorContext', () => {
+  it('resolves context from mixed behaviors (some without context)', () => {
+    type Behaviors = [typeof counter, typeof render];
+    expectTypeOf<ResolveBehaviorContext<Behaviors>>().toMatchTypeOf<{ renderElement: Surface | undefined }>();
+  });
+
+  it('probe: resolves conflicting context types to undefined-collapsed shape', () => {
+    interface Surf {
+      kind: 'canvas' | 'video';
+    }
+    interface CanvasS extends Surf {
+      kind: 'canvas';
+    }
+    interface VideoS extends Surf {
+      kind: 'video';
+    }
+    const a = {
+      stateKeys: [],
+      contextKeys: ['el'] as const,
+      setup: (_d: { context: ContextSignals<{ el?: CanvasS }> }) => {},
+    };
+    const b = {
+      stateKeys: [],
+      contextKeys: ['el'] as const,
+      setup: (_d: { context: ContextSignals<{ el?: VideoS }> }) => {},
+    };
+    type Resolved = ResolveBehaviorContext<[typeof a, typeof b]>;
+    // The intersection should collapse `el` because CanvasS & VideoS = never
+    // (sibling types), and `never | undefined` = `undefined` for an optional field.
+    expectTypeOf<Resolved['el']>().toEqualTypeOf<undefined>();
+  });
+});
+
+describe('ResolveBehaviorConfig', () => {
+  it('intersects config from multiple behaviors', () => {
+    type Behaviors = [typeof counter, typeof render, typeof persist];
+    expectTypeOf<ResolveBehaviorConfig<Behaviors>>().toMatchTypeOf<{
+      interval?: number;
+      defaultText?: string;
+      saveEvery?: number;
+    }>();
+  });
+});
+
+// =============================================================================
+// createComposition signatures
+// =============================================================================
+
+describe('createComposition', () => {
+  it('returns a Composition typed by the resolved behaviors', () => {
+    interface State {
+      count?: number;
+    }
+    interface Context {
+      el?: Surface;
+    }
+    interface Cfg {
+      interval?: number;
+    }
+
+    const behavior: Behavior<StateSignals<State>, ContextSignals<Context>, Cfg> = {
+      stateKeys: [],
+      contextKeys: [],
+      setup: () => {},
+    };
+
+    const composition = createComposition([behavior], { config: { interval: 250 } });
+
+    expectTypeOf(composition).toEqualTypeOf<Composition<State, Context>>();
+    expectTypeOf(composition.state.count).toEqualTypeOf<Signal<number | undefined>>();
+    expectTypeOf(composition.context.el).toEqualTypeOf<Signal<Surface | undefined>>();
+  });
+
+  it('passes through behavior deps shape', () => {
+    interface State {
+      count?: number;
+    }
+    interface Context {
+      el?: Surface;
+    }
+    interface Cfg {
+      interval?: number;
+    }
+
+    const behavior: Behavior<StateSignals<State>, ContextSignals<Context>, Cfg> = {
+      stateKeys: [],
+      contextKeys: [],
+      setup: ({ state, context, config }) => {
+        expectTypeOf(state).toEqualTypeOf<StateSignals<State>>();
+        expectTypeOf(context).toEqualTypeOf<ContextSignals<Context>>();
+        expectTypeOf(config).toEqualTypeOf<Cfg>();
+      },
+    };
+
+    createComposition([behavior], { config: { interval: 250 } });
+  });
+});
+
+// =============================================================================
+// defineBehavior — return-type inference
+// =============================================================================
+
+describe('defineBehavior', () => {
+  it('preserves stateKeys as a literal tuple via const modifier', () => {
+    const b = defineBehavior({
+      stateKeys: ['a', 'b'],
+      contextKeys: [],
+      setup: ({ state }: { state: StateSignals<{ a?: number; b?: string }> }) => {
+        void state;
+      },
+    });
+    expectTypeOf<typeof b.stateKeys>().toEqualTypeOf<readonly ['a', 'b']>();
+  });
+
+  it('preserves contextKeys as a literal tuple via const modifier', () => {
+    const b = defineBehavior({
+      stateKeys: [],
+      contextKeys: ['el'],
+      setup: ({ context }: { context: ContextSignals<{ el?: Surface }> }) => {
+        void context;
+      },
+    });
+    expectTypeOf<typeof b.contextKeys>().toEqualTypeOf<readonly ['el']>();
+  });
+
+  it('captures the setup return type narrowly via the R generic', () => {
+    const cleanup = () => {};
+    const b = defineBehavior({
+      stateKeys: [],
+      contextKeys: [],
+      setup: () => cleanup,
+    });
+    // R is captured narrowly — the result's setup returns `() => void`,
+    // not the wider `BehaviorCleanup` union. So callers can invoke the
+    // returned cleanup directly without narrowing.
+    expectTypeOf<ReturnType<typeof b.setup>>().toEqualTypeOf<() => void>();
+  });
+
+  it('flows S into InferBehaviorState<typeof behavior>', () => {
+    const b = defineBehavior({
+      stateKeys: ['count'],
+      contextKeys: [],
+      setup: ({ state }: { state: StateSignals<{ count?: number }> }) => {
+        void state;
+      },
+    });
+    expectTypeOf<InferBehaviorState<typeof b>>().toEqualTypeOf<{ count: number | undefined }>();
+  });
+
+  it('flows C into InferBehaviorContext<typeof behavior>', () => {
+    const b = defineBehavior({
+      stateKeys: [],
+      contextKeys: ['el'],
+      setup: ({ context }: { context: ContextSignals<{ el?: Surface }> }) => {
+        void context;
+      },
+    });
+    expectTypeOf<InferBehaviorContext<typeof b>>().toEqualTypeOf<{ el: Surface | undefined }>();
+  });
+
+  it('flows Cfg into InferBehaviorConfig<typeof behavior>', () => {
+    const b = defineBehavior({
+      stateKeys: [],
+      contextKeys: [],
+      setup: ({ config }: { config: { interval: number } }) => {
+        void config;
+      },
+    });
+    expectTypeOf<InferBehaviorConfig<typeof b>>().toEqualTypeOf<{ interval: number }>();
+  });
+
+  it('makes state optional in the result setup signature when S has no keys', () => {
+    const b = defineBehavior({
+      stateKeys: [],
+      contextKeys: [],
+      setup: () => {},
+    });
+    // Calling .setup({}) — no state field — typechecks.
+    b.setup({});
+  });
+
+  it('makes context optional in the result setup signature when C has no keys', () => {
+    const b = defineBehavior({
+      stateKeys: ['count'],
+      contextKeys: [],
+      setup: ({ state }: { state: StateSignals<{ count?: number }> }) => {
+        void state;
+      },
+    });
+    b.setup({ state: { count: signal<number | undefined>(undefined) } });
+  });
+
+  it('makes config optional in the result setup signature when Cfg has no keys', () => {
+    const b = defineBehavior({
+      stateKeys: ['count'],
+      contextKeys: [],
+      setup: ({ state }: { state: StateSignals<{ count?: number }> }) => {
+        void state;
+      },
+    });
+    // No config field needed at the call site — Cfg defaults to Empty.
+    b.setup({ state: { count: signal<number | undefined>(undefined) } });
+  });
+
+  it('keeps state required in the result setup signature when S has at least one key', () => {
+    const b = defineBehavior({
+      stateKeys: ['count'],
+      contextKeys: [],
+      setup: ({ state }: { state: StateSignals<{ count?: number }> }) => {
+        void state;
+      },
+    });
+    // `{}` is not assignable to the deps param when S has keys — state is required.
+    // biome-ignore lint/complexity/noBannedTypes: testing that `{}` (empty arg) doesn't satisfy deps
+    expectTypeOf<{}>().not.toMatchTypeOf<Parameters<typeof b.setup>[0]>();
+  });
+
+  it('produces an InferBehaviorState of {} for a behavior with no state in setup', () => {
+    const b = defineBehavior({
+      stateKeys: [],
+      contextKeys: [],
+      setup: () => {},
+    });
+    // biome-ignore lint/complexity/noBannedTypes: matches the Empty fallback in create-composition
+    expectTypeOf<InferBehaviorState<typeof b>>().toEqualTypeOf<{}>();
+  });
+});
+
+// =============================================================================
+// createComposition — per-signal type errors
 // =============================================================================
 
 describe('createComposition type errors', () => {
-  it('errors when update() is called with a wrong type on engine.state', () => {
-    const engine = createComposition([counter]);
-    // @ts-expect-error — count expects number, not string
-    update(engine.state, { count: 'not a number' });
+  interface State {
+    count?: number;
+  }
+  interface Context {
+    el?: Surface;
+  }
+
+  // A typed behavior that pins the inferred composition shape so the error
+  // tests below can target the expected shape without explicit type args.
+  const noopState: Behavior<StateSignals<State>, ContextSignals<Context>, object> = {
+    stateKeys: ['count'],
+    contextKeys: ['el'],
+    setup: () => {},
+  };
+
+  it('errors when set() is called on a state signal with the wrong value type', () => {
+    const composition = createComposition([noopState]);
+    // @ts-expect-error — count is Signal<number | undefined>, not a string slot
+    composition.state.count.set('not a number');
   });
 
-  it('errors when set() is called with a wrong type on engine.state', () => {
-    const engine = createComposition([counter]);
-    // @ts-expect-error — state expects { count?: number }, not { count: string }
-    engine.state.set({ count: 'not a number' });
+  it('errors when get() is treated as the wrong type', () => {
+    const composition = createComposition([noopState]);
+    // @ts-expect-error — count.get() returns number | undefined, not string
+    const _: string = composition.state.count.get();
+    void _;
   });
 
-  it('errors when update() uses a key not in the inferred state', () => {
-    const engine = createComposition([counter]);
-    // @ts-expect-error — 'unknown' is not a key of { count?: number }
-    update(engine.state, { unknown: true });
+  it('errors when a behavior writes a wrong-type value to a state signal', () => {
+    const badBehavior: Behavior<StateSignals<State>, ContextSignals<Context>, object> = {
+      stateKeys: ['count'],
+      contextKeys: [],
+      setup: ({ state }) => {
+        // @ts-expect-error — count is number | undefined
+        state.count.set('wrong');
+      },
+    };
+    void badBehavior;
   });
 
-  it('errors when initialState has wrong types', () => {
-    // @ts-expect-error — count expects number, not string
-    createComposition([counter], { initialState: { count: 'wrong' } });
+  it('errors when a behavior reads a state signal as the wrong type', () => {
+    const badBehavior: Behavior<StateSignals<State>, ContextSignals<Context>, object> = {
+      stateKeys: ['count'],
+      contextKeys: [],
+      setup: ({ state }) => {
+        // @ts-expect-error — count.get() returns number | undefined, not string
+        const _: string = state.count.get();
+        void _;
+      },
+    };
+    void badBehavior;
   });
 
-  it('errors when initialOwners has wrong types', () => {
-    // @ts-expect-error — renderElement expects Surface, not number
-    createComposition([render], { initialOwners: { renderElement: 42 } });
-  });
-
-  it('errors when config has wrong types', () => {
-    // @ts-expect-error — interval expects number, not string
-    createComposition([counter], { config: { interval: 'fast' } });
-  });
+  // ==========================================================================
+  // Composition-time conflict detection
+  //
+  // `ValidateComposition` resolves the parameter type to one of:
+  //   'Error: behaviors have conflicting state types'
+  //   'Error: behaviors have conflicting context types'
+  //   'Error: behaviors have conflicting config types'
+  //
+  // when any pair of behaviors disagrees on a field type. The resolved
+  // string then becomes the inferred parameter type, so passing the actual
+  // behaviors array fails the assignability check.
+  //
+  // Context conflicts are checked the same way as state — by intersecting
+  // each behavior's context requirement and looking for collapsed fields.
+  // The prior subtype-based owner check is gone; a behavior pair where the
+  // types are subtype-related (e.g. `Surface` and `VideoSurface`) is no
+  // longer treated as compatible — both behaviors must agree on the same
+  // type.
+  // ==========================================================================
 
   it('errors when composing behaviors with conflicting required state types', () => {
-    const expectsNumber = (_deps: { state: Signal<{ value: number }> }) => {};
-    const expectsString = (_deps: { state: Signal<{ value: string }> }) => {};
+    const expectsNumber = {
+      stateKeys: ['value'] as const,
+      contextKeys: [],
+      setup: (_deps: { state: StateSignals<{ value: number }> }) => {},
+    };
+    const expectsString = {
+      stateKeys: ['value'] as const,
+      contextKeys: [],
+      setup: (_deps: { state: StateSignals<{ value: string }> }) => {},
+    };
 
     // @ts-expect-error — behaviors have incompatible state: { value: number } vs { value: string }
     createComposition([expectsNumber, expectsString]);
   });
 
   it('errors when composing behaviors with conflicting optional state types', () => {
-    const expectsNumber = (_deps: { state: Signal<{ count?: number }> }) => {};
-    const expectsString = (_deps: { state: Signal<{ count?: string }> }) => {};
+    const expectsNumber = {
+      stateKeys: ['count'] as const,
+      contextKeys: [],
+      setup: (_deps: { state: StateSignals<{ count?: number }> }) => {},
+    };
+    const expectsString = {
+      stateKeys: ['count'] as const,
+      contextKeys: [],
+      setup: (_deps: { state: StateSignals<{ count?: string }> }) => {},
+    };
 
     // @ts-expect-error — behaviors have incompatible state: { count?: number } vs { count?: string }
     createComposition([expectsNumber, expectsString]);
   });
 
-  it('errors when composing behaviors with conflicting config types', () => {
-    const expectsNumber = (_deps: { config: { interval?: number } }) => {};
-    const expectsString = (_deps: { config: { interval?: string } }) => {};
+  it('errors when composing behaviors with conflicting context types', () => {
+    const expectsCanvas = {
+      stateKeys: [],
+      contextKeys: ['el'] as const,
+      setup: (_deps: { context: ContextSignals<{ el?: CanvasSurface }> }) => {},
+    };
+    const expectsVideo = {
+      stateKeys: [],
+      contextKeys: ['el'] as const,
+      setup: (_deps: { context: ContextSignals<{ el?: VideoSurface }> }) => {},
+    };
 
-    // @ts-expect-error — behaviors have incompatible config: { interval?: number } vs { interval?: string }
-    createComposition([expectsNumber, expectsString]);
-  });
-
-  it('errors when composing behaviors with incompatible owners class types', () => {
-    const expectsCanvas = (_deps: { owners: Signal<{ el?: CanvasSurface }> }) => {};
-    const expectsVideo = (_deps: { owners: Signal<{ el?: VideoSurface }> }) => {};
-
-    // @ts-expect-error — neither CanvasSurface nor VideoSurface extends the other
+    // @ts-expect-error — context conflict: CanvasSurface vs VideoSurface
     createComposition([expectsCanvas, expectsVideo]);
   });
 
-  // =========================================================================
-  // Non-conflicts — behaviors that omit channels should compose freely
-  // =========================================================================
+  it('allows context types in a subtype relationship to compose', () => {
+    // Under the intersection-based rule, subtype-related types compose
+    // without conflict — `Surface & VideoSurface = VideoSurface`. The prior
+    // subtype-based owner check accepted this too; the difference vs. that
+    // approach is sibling-type behavior (see the previous test).
+    const expectsSurface = {
+      stateKeys: [],
+      contextKeys: ['el'] as const,
+      setup: (_deps: { context: ContextSignals<{ el?: Surface }> }) => {},
+    };
+    const expectsVideo = {
+      stateKeys: [],
+      contextKeys: ['el'] as const,
+      setup: (_deps: { context: ContextSignals<{ el?: VideoSurface }> }) => {},
+    };
 
-  it('allows composing behaviors with owners in a subtype relationship', () => {
-    const expectsSurface = (_deps: { owners: Signal<{ el?: Surface }> }) => {};
-    const expectsVideo = (_deps: { owners: Signal<{ el?: VideoSurface }> }) => {};
-
-    // No error — VideoSurface extends Surface
+    // No error — Surface and VideoSurface intersect to VideoSurface.
     createComposition([expectsSurface, expectsVideo]);
   });
 
-  it('allows composing behaviors that omit owners', () => {
-    const stateOnly = (_deps: { state: Signal<{ count?: number }> }) => {};
-    const withOwners = (_deps: { state: Signal<{ count?: number }>; owners: Signal<{ el?: Surface }> }) => {};
+  it('errors when composing behaviors with conflicting config types', () => {
+    const expectsNumber = {
+      stateKeys: [],
+      contextKeys: [],
+      setup: (_deps: { config: { interval?: number } }) => {},
+    };
+    const expectsString = {
+      stateKeys: [],
+      contextKeys: [],
+      setup: (_deps: { config: { interval?: string } }) => {},
+    };
 
-    // No error — omitting owners is not a conflict
-    createComposition([stateOnly, withOwners]);
+    // @ts-expect-error — config conflict: { interval?: number } vs { interval?: string }
+    createComposition([expectsNumber, expectsString], { config: {} });
+  });
+
+  // ==========================================================================
+  // Non-conflicts — disjoint or matching shapes compose freely
+  // ==========================================================================
+
+  it('allows composing behaviors that omit context', () => {
+    const stateOnly = {
+      stateKeys: ['count'] as const,
+      contextKeys: [],
+      setup: (_deps: { state: StateSignals<{ count?: number }> }) => {},
+    };
+    const withContext = {
+      stateKeys: ['count'] as const,
+      contextKeys: ['el'] as const,
+      setup: (_deps: { state: StateSignals<{ count?: number }>; context: ContextSignals<{ el?: Surface }> }) => {},
+    };
+
+    // No error — omitting context is not a conflict
+    createComposition([stateOnly, withContext]);
   });
 
   it('allows composing behaviors that omit state', () => {
-    const configOnly = (_deps: { config: { interval?: number } }) => {};
-    const withState = (_deps: { state: Signal<{ count?: number }>; config: { interval?: number } }) => {};
+    const configOnly = {
+      stateKeys: [],
+      contextKeys: [],
+      setup: (_deps: { config: { interval?: number } }) => {},
+    };
+    const withState = {
+      stateKeys: ['count'] as const,
+      contextKeys: [],
+      setup: (_deps: { state: StateSignals<{ count?: number }>; config: { interval?: number } }) => {},
+    };
 
     // No error — omitting state is not a conflict
-    createComposition([configOnly, withState]);
+    createComposition([configOnly, withState], { config: { interval: 250 } });
   });
 
   it('allows composing behaviors that omit config', () => {
-    const stateOnly = (_deps: { state: Signal<{ count?: number }> }) => {};
-    const withConfig = (_deps: { state: Signal<{ count?: number }>; config: { interval?: number } }) => {};
+    const stateOnly = {
+      stateKeys: ['count'] as const,
+      contextKeys: [],
+      setup: (_deps: { state: StateSignals<{ count?: number }> }) => {},
+    };
+    const withConfig = {
+      stateKeys: ['count'] as const,
+      contextKeys: [],
+      setup: (_deps: { state: StateSignals<{ count?: number }>; config: { interval?: number } }) => {},
+    };
 
     // No error — omitting config is not a conflict
-    createComposition([stateOnly, withConfig]);
+    createComposition([stateOnly, withConfig], { config: { interval: 250 } });
   });
 
-  it('allows composing behaviors where each omits different channels', () => {
-    const onlyState = (_deps: { state: Signal<{ count?: number }> }) => {};
-    const onlyOwners = (_deps: { owners: Signal<{ el?: Surface }> }) => {};
-    const onlyConfig = (_deps: { config: { interval?: number } }) => {};
+  it('allows composing behaviors where each declares disjoint state keys', () => {
+    const a = {
+      stateKeys: ['count'] as const,
+      contextKeys: [],
+      setup: (_deps: { state: StateSignals<{ count?: number }> }) => {},
+    };
+    const b = {
+      stateKeys: ['label'] as const,
+      contextKeys: [],
+      setup: (_deps: { state: StateSignals<{ label?: string }> }) => {},
+    };
 
-    // No error — behaviors with disjoint channels don't conflict
-    createComposition([onlyState, onlyOwners, onlyConfig]);
+    // No error — disjoint keys merge cleanly
+    createComposition([a, b]);
   });
+});
 
-  // =========================================================================
-  // Resetting optional fields to undefined
-  // =========================================================================
+// =============================================================================
+// defineBehavior — single-behavior key/param consistency
+//
+// Exhaustiveness check: declared `stateKeys` must equal `keyof S` (where S
+// is inferred from the setup's state parameter type), and same for
+// `contextKeys` / C. Missing keys surface as a phantom-tag failure;
+// keys-not-in-S are caught by `const SK extends readonly (keyof S)[]`.
+// =============================================================================
 
-  it('allows resetting optional state fields to undefined', () => {
-    // Behaviors declare { count?: number } — the engine allows resetting to
-    // undefined without requiring the behavior to declare | undefined.
-    const behavior = (_deps: { state: Signal<{ count?: number }> }) => {};
-    const engine = createComposition([behavior]);
+describe('defineBehavior type errors', () => {
+  it('errors when stateKeys is missing a key declared in the typed state slice', () => {
+    // @ts-expect-error — stateKeys missing 'b' (in keyof S = {a, b})
+    defineBehavior({
+      stateKeys: ['a'],
+      contextKeys: [],
+      setup: ({ state }: { state: StateSignals<{ a?: number; b?: string }> }) => {
+        void state.a.get();
+        void state.b.get();
+      },
+    });
+  });
+
+  it('errors when stateKeys lists a key not in the typed state slice', () => {
+    defineBehavior({
+      // @ts-expect-error — 'nope' is not assignable to keyof S = 'a'
+      stateKeys: ['a', 'nope'],
+      contextKeys: [],
+      setup: ({ state }: { state: StateSignals<{ a?: number }> }) => {
+        void state.a.get();
+      },
+    });
+  });
+
+  it('errors when contextKeys is missing a key declared in the typed context slice', () => {
+    // @ts-expect-error — contextKeys missing 'b'
+    defineBehavior({
+      stateKeys: [],
+      contextKeys: ['a'],
+      setup: ({ context }: { context: ContextSignals<{ a?: number; b?: string }> }) => {
+        void context.a.get();
+        void context.b.get();
+      },
+    });
+  });
+
+  it('errors when contextKeys lists a key not in the typed context slice', () => {
+    defineBehavior({
+      stateKeys: [],
+      // @ts-expect-error — 'nope' is not assignable to keyof C = 'a'
+      contextKeys: ['nope'],
+      setup: ({ context }: { context: ContextSignals<{ a?: number }> }) => {
+        void context.a.get();
+      },
+    });
+  });
+
+  it('errors when stateKeys is empty but the typed state slice has keys', () => {
+    // @ts-expect-error — keyof S = 'a' is not in stateKeys = []
+    defineBehavior({
+      stateKeys: [],
+      contextKeys: [],
+      setup: ({ state }: { state: StateSignals<{ a?: number }> }) => {
+        void state.a.get();
+      },
+    });
+  });
+
+  it('allows a behavior with no state at all and stateKeys: []', () => {
+    // No error — keyof S is `never`, stateKeys: [] is exhaustive
+    defineBehavior({
+      stateKeys: [],
+      contextKeys: [],
+      setup: () => {},
+    });
+  });
 
-    // No error — optional fields can be reset to undefined
-    update(engine.state, { count: undefined });
+  it('errors when calling .setup() without a required config (Cfg has keys)', () => {
+    const b = defineBehavior({
+      stateKeys: [],
+      contextKeys: [],
+      setup: ({ config }: { config: { x: number } }) => {
+        void config.x;
+      },
+    });
+    // @ts-expect-error — config required because Cfg = { x: number } has keys
+    b.setup({});
   });
+
+  it('allows omitting config from .setup() when Cfg has no keys', () => {
+    const b = defineBehavior({
+      stateKeys: [],
+      contextKeys: [],
+      setup: () => {},
+    });
+    // No error — config is optional via DepsForCfg when Cfg = Empty
+    b.setup({});
+  });
+
+  it('errors when defineBehavior is called with a stateKey whose type conflicts with another behavior', () => {
+    const numberBehavior = defineBehavior({
+      stateKeys: ['v'],
+      contextKeys: [],
+      setup: ({ state }: { state: StateSignals<{ v: number }> }) => {
+        void state.v.get();
+      },
+    });
+    const stringBehavior = defineBehavior({
+      stateKeys: ['v'],
+      contextKeys: [],
+      setup: ({ state }: { state: StateSignals<{ v: string }> }) => {
+        void state.v.get();
+      },
+    });
+
+    // @ts-expect-error — cross-behavior conflict still flows through ValidateComposition
+    createComposition([numberBehavior, stringBehavior]);
+  });
+});
+
+// =============================================================================
+// initialState / initialContext — type errors
+// =============================================================================
+
+describe('createComposition initial-value type errors', () => {
+  it('errors when initialState contains a key not in S', () => {
+    const behavior = defineBehavior({
+      stateKeys: ['count'],
+      contextKeys: [],
+      setup: ({ state }: { state: StateSignals<{ count?: number }> }) => {
+        void state;
+      },
+    });
+
+    createComposition([behavior], {
+      // @ts-expect-error — 'unknownKey' is not in S = { count?: number }
+      initialState: { unknownKey: 1 },
+    });
+  });
+
+  it('errors when initialState seeds a key with the wrong type', () => {
+    const behavior = defineBehavior({
+      stateKeys: ['count'],
+      contextKeys: [],
+      setup: ({ state }: { state: StateSignals<{ count?: number }> }) => {
+        void state;
+      },
+    });
 
-  it('allows resetting optional owners fields to undefined', () => {
-    const behavior = (_deps: { owners: Signal<{ el?: Surface }> }) => {};
-    const engine = createComposition([behavior]);
+    createComposition([behavior], {
+      // @ts-expect-error — count must be number | undefined, not string
+      initialState: { count: 'wrong' },
+    });
+  });
+
+  it('errors when initialContext contains a key not in C', () => {
+    const behavior = defineBehavior({
+      stateKeys: [],
+      contextKeys: ['el'],
+      setup: ({ context }: { context: ContextSignals<{ el?: Surface }> }) => {
+        void context;
+      },
+    });
+
+    createComposition([behavior], {
+      // @ts-expect-error — 'unknownKey' is not in C = { el?: Surface }
+      initialContext: { unknownKey: {} },
+    });
+  });
+
+  it('allows partial initial values (omitted keys default to undefined)', () => {
+    const behavior = defineBehavior({
+      stateKeys: ['a', 'b'],
+      contextKeys: [],
+      setup: ({ state }: { state: StateSignals<{ a?: number; b?: string }> }) => {
+        void state;
+      },
+    });
+
+    // No error — Partial<S> allows omitting any subset of keys
+    createComposition([behavior], { initialState: { a: 1 } });
+  });
+});
+
+// =============================================================================
+// buildSignalMap — return-type inference
+// =============================================================================
+
+describe('buildSignalMap', () => {
+  it('returns one Signal slot per key in S', () => {
+    interface S {
+      a?: number;
+      b?: string;
+    }
+    const map = buildSignalMap<S>(['a', 'b'], {});
+    expectTypeOf<typeof map>().toEqualTypeOf<{ a: Signal<number | undefined>; b: Signal<string | undefined> }>();
+  });
+
+  it('strips optionality on signal slots while preserving undefined in value type', () => {
+    interface S {
+      a?: number;
+    }
+    const map = buildSignalMap<S>(['a'], {});
+    // The slot is required (`-?`) but the value type retains | undefined.
+    expectTypeOf<typeof map>().toEqualTypeOf<{ a: Signal<number | undefined> }>();
+  });
+
+  it('preserves required fields without injecting undefined', () => {
+    interface S {
+      a: number;
+    }
+    const map = buildSignalMap<S>(['a'], { a: 5 });
+    expectTypeOf<typeof map>().toEqualTypeOf<{ a: Signal<number> }>();
+  });
+
+  it('accepts Partial<S> as the initial seed (any subset of keys)', () => {
+    interface S {
+      a?: number;
+      b?: string;
+    }
+    // No errors — partial seeds welcome.
+    buildSignalMap<S>(['a', 'b'], {});
+    buildSignalMap<S>(['a', 'b'], { a: 1 });
+    buildSignalMap<S>(['a', 'b'], { a: 1, b: 'x' });
+  });
+
+  it('errors when initial seeds a key not in S', () => {
+    interface S {
+      a?: number;
+    }
+    // @ts-expect-error — 'unknown' is not a key of S
+    buildSignalMap<S>(['a'], { unknown: 1 });
+  });
+
+  it('errors when initial seeds a key with the wrong type', () => {
+    interface S {
+      a?: number;
+    }
+    // @ts-expect-error — 'a' must be number | undefined, not string
+    buildSignalMap<S>(['a'], { a: 'wrong' });
+  });
 
-    // No error — clearing an owner (e.g. on source switch)
-    update(engine.owners, { el: undefined });
+  it('produces an empty map for an empty Partial<{}>', () => {
+    // biome-ignore lint/complexity/noBannedTypes: empty interface intentional
+    const map = buildSignalMap<{}>([], {});
+    // biome-ignore lint/complexity/noBannedTypes: matches the Empty fallback
+    expectTypeOf<typeof map>().toEqualTypeOf<{}>();
   });
 });
diff --git a/packages/spf/src/core/composition/tests/create-composition-types.test.ts b/packages/spf/src/core/composition/tests/create-composition-types.test.ts
deleted file mode 100644
index c57372e7..00000000
--- a/packages/spf/src/core/composition/tests/create-composition-types.test.ts
+++ /dev/null
@@ -1,251 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest';
-import { effect } from '../../signals/effect';
-import type { Signal } from '../../signals/primitives';
-import { update } from '../../signals/primitives';
-import {
-  createComposition,
-  type InferBehaviorConfig,
-  type InferBehaviorOwners,
-  type InferBehaviorState,
-  type ResolveBehaviorOwners,
-  type ResolveBehaviorState,
-} from '../create-composition';
-
-// =============================================================================
-// Host-agnostic stand-in types
-// -----------------------------------------------------------------------------
-// Core is DOM-free. The tests need a small, concrete type to stand in for the
-// kind of thing a user would pass as an owner — something with a writable
-// surface and clear subtype relationships for covariance tests.
-// =============================================================================
-
-interface Surface {
-  textContent?: string | null;
-}
-
-// =============================================================================
-// Test behaviors — concrete parameter types
-// =============================================================================
-
-function counter({ state, config }: { state: Signal<{ count?: number }>; config: { interval?: number } }) {
-  const interval = setInterval(() => {
-    update(state, { count: (state.get().count ?? 0) + 1 });
-  }, config.interval ?? 1000);
-  return () => clearInterval(interval);
-}
-
-function render({
-  state,
-  owners,
-  config,
-}: {
-  state: Signal<{ count?: number }>;
-  owners: Signal<{ renderElement?: Surface }>;
-  config: { defaultText?: string };
-}) {
-  return effect(() => {
-    const { renderElement } = owners.get();
-    if (!renderElement) return;
-    renderElement.textContent = String(state.get().count ?? config.defaultText ?? 'N/A');
-  });
-}
-
-function persist({ state, config }: { state: Signal<{ count?: number }>; config: { saveEvery?: number } }) {
-  return effect(() => {
-    const { count } = state.get();
-    if (count && count > 0 && count % (config.saveEvery ?? 5) === 0) {
-      // save logic
-    }
-  });
-}
-
-// =============================================================================
-// Test behaviors — generic parameter types (the pattern real behaviors use)
-// =============================================================================
-
-interface TimerState {
-  elapsed?: number;
-}
-
-interface TimerConfig {
-  tickRate?: number;
-}
-
-function timer<S extends TimerState, C extends TimerConfig>({ state, config }: { state: Signal<S>; config: C }) {
-  const interval = setInterval(() => {
-    update(state, { elapsed: (state.get().elapsed ?? 0) + 1 } as Partial<S>);
-  }, config.tickRate ?? 1000);
-  return () => clearInterval(interval);
-}
-
-// =============================================================================
-// InferBehavior* — single behavior inference
-// =============================================================================
-
-describe('InferBehaviorState', () => {
-  it('extracts state type from a concrete behavior', () => {
-    expectTypeOf<InferBehaviorState<typeof counter>>().toEqualTypeOf<{ count?: number }>();
-  });
-
-  it('extracts state type from a behavior that uses owners', () => {
-    expectTypeOf<InferBehaviorState<typeof render>>().toEqualTypeOf<{ count?: number }>();
-  });
-
-  it('returns object for a behavior with no state in params', () => {
-    const noState = ({ config: _config }: { config: { x: number } }) => {};
-    expectTypeOf<InferBehaviorState<typeof noState>>().toEqualTypeOf<object>();
-  });
-});
-
-describe('InferBehaviorOwners', () => {
-  it('extracts owners type from a behavior that uses owners', () => {
-    expectTypeOf<InferBehaviorOwners<typeof render>>().toEqualTypeOf<{ renderElement?: Surface }>();
-  });
-
-  it('returns object for a behavior with no owners in params', () => {
-    expectTypeOf<InferBehaviorOwners<typeof counter>>().toEqualTypeOf<object>();
-  });
-});
-
-describe('InferBehaviorConfig', () => {
-  it('extracts config type from a concrete behavior', () => {
-    expectTypeOf<InferBehaviorConfig<typeof counter>>().toEqualTypeOf<{ interval?: number }>();
-  });
-
-  it('extracts different config types from different behaviors', () => {
-    expectTypeOf<InferBehaviorConfig<typeof render>>().toEqualTypeOf<{ defaultText?: string }>();
-    expectTypeOf<InferBehaviorConfig<typeof persist>>().toEqualTypeOf<{ saveEvery?: number }>();
-  });
-});
-
-describe('InferBehavior* with generic behaviors', () => {
-  it('infers constraint types from generic behaviors', () => {
-    expectTypeOf<InferBehaviorState<typeof timer>>().toEqualTypeOf<TimerState>();
-    expectTypeOf<InferBehaviorConfig<typeof timer>>().toEqualTypeOf<TimerConfig>();
-  });
-});
-
-// =============================================================================
-// ResolveBehavior* — multi-behavior composition inference
-// =============================================================================
-
-describe('ResolveBehaviorState', () => {
-  it('intersects state from multiple behaviors', () => {
-    type Behaviors = [typeof counter, typeof render, typeof persist];
-    // All three expect { count?: number }, intersection is the same
-    expectTypeOf<ResolveBehaviorState<Behaviors>>().toEqualTypeOf<{ count?: number }>();
-  });
-
-  it('intersects different state shapes', () => {
-    const behaviorA = (_deps: { state: Signal<{ count?: number }> }) => {};
-    const behaviorB = (_deps: { state: Signal<{ label?: string }> }) => {};
-    const engine = createComposition([behaviorA, behaviorB]);
-    expectTypeOf(engine.state.get()).toExtend<{ count?: number; label?: string }>();
-  });
-});
-
-describe('ResolveBehaviorOwners', () => {
-  it('resolves owners from mixed behaviors (some without owners)', () => {
-    // counter has no owners, render has renderElement
-    type Behaviors = [typeof counter, typeof render];
-    // object & { renderElement?: Surface } should simplify
-    expectTypeOf<ResolveBehaviorOwners<Behaviors>>().toExtend<{ renderElement?: Surface }>();
-  });
-});
-
-describe('ResolveBehaviorConfig', () => {
-  it('intersects config from multiple behaviors', () => {
-    const engine = createComposition([counter, render, persist], {
-      config: { interval: 250, defaultText: '--', saveEvery: 5 },
-    });
-    expectTypeOf(engine.state.get()).toExtend<{ count?: number }>();
-  });
-});
-
-// =============================================================================
-// createComposition — inference at the call site
-// =============================================================================
-
-describe('createComposition', () => {
-  describe('single behavior', () => {
-    it('infers state type from a single behavior', () => {
-      const engine = createComposition([counter], {
-        config: { interval: 250 },
-      });
-      expectTypeOf(engine.state.get()).toEqualTypeOf<{ count?: number }>();
-    });
-
-    it('infers types from an inline arrow behavior', () => {
-      const engine = createComposition([
-        ({ state }: { state: Signal<{ value?: string }> }) => {
-          update(state, { value: 'hello' });
-        },
-      ]);
-      expectTypeOf(engine.state.get()).toEqualTypeOf<{ value?: string }>();
-    });
-  });
-
-  describe('behavior array', () => {
-    it('infers combined state from multiple behaviors', () => {
-      const engine = createComposition([counter, render, persist], {
-        initialState: { count: 0 },
-        config: { interval: 250, defaultText: '--', saveEvery: 5 },
-        initialOwners: { renderElement: null as unknown as Surface },
-      });
-
-      expectTypeOf(engine.state.get()).toExtend<{ count?: number }>();
-      expectTypeOf(engine.owners.get()).toExtend<{ renderElement?: Surface }>();
-    });
-
-    it('infers combined state from behaviors with different state shapes', () => {
-      const behaviorA = (_deps: { state: Signal<{ count?: number }> }) => {};
-      const behaviorB = (_deps: { state: Signal<{ label?: string }> }) => {};
-
-      const engine = createComposition([behaviorA, behaviorB]);
-      expectTypeOf(engine.state.get()).toExtend<{ count?: number; label?: string }>();
-    });
-
-    it('type-checks options against inferred types', () => {
-      // Config must satisfy the combined config requirements
-      const engine = createComposition([counter, render], {
-        config: { interval: 250, defaultText: '--' },
-      });
-
-      expectTypeOf(engine.state.get()).toExtend<{ count?: number }>();
-    });
-  });
-
-  describe('generic behaviors', () => {
-    it('infers constraint types from generic behaviors', () => {
-      const engine = createComposition([timer], {
-        config: { tickRate: 500 },
-      });
-
-      expectTypeOf(engine.state.get()).toExtend<{ elapsed?: number }>();
-    });
-  });
-
-  describe('resetting optional fields to undefined', () => {
-    it('allows update() with undefined for optional state fields', () => {
-      const engine = createComposition([counter]);
-
-      // Behaviors declare { count?: number } — resetting to undefined is valid
-      // without the behavior needing to declare | undefined explicitly.
-      update(engine.state, { count: undefined });
-      expectTypeOf(engine.state.get().count).toEqualTypeOf<number | undefined>();
-    });
-
-    it('allows update() with undefined for optional owners fields', () => {
-      const engine = createComposition([render], {
-        initialOwners: { renderElement: null as unknown as Surface },
-      });
-
-      // Clearing an owner (e.g. on source switch)
-      update(engine.owners, { renderElement: undefined });
-      expectTypeOf(engine.owners.get().renderElement).toEqualTypeOf<Surface | undefined>();
-    });
-  });
-
-  // Type error enforcement tests (@ts-expect-error for wrong types, conflicting
-  // behaviors, etc.) live in engine-types.test-d.ts and run via vitest typecheck.
-});
diff --git a/packages/spf/src/core/composition/tests/create-composition.test.ts b/packages/spf/src/core/composition/tests/create-composition.test.ts
index 1cf83ff6..acb86da6 100644
--- a/packages/spf/src/core/composition/tests/create-composition.test.ts
+++ b/packages/spf/src/core/composition/tests/create-composition.test.ts
@@ -1,76 +1,159 @@
 import { describe, expect, it } from 'vitest';
-import type { Signal } from '../../signals/primitives';
-import { update } from '../../signals/primitives';
-import { createComposition } from '../create-composition';
+import {
+  type Behavior,
+  buildSignalMap,
+  type ContextSignals,
+  createComposition,
+  defineBehavior,
+  type StateSignals,
+} from '../create-composition';
 
 interface Resource {
   id: string;
 }
 
-describe('createComposition', () => {
-  describe('destroy()', () => {
-    it('clears owners populated by a behavior during setup', async () => {
-      const composition = createComposition([
-        ({ owners }: { owners: Signal<{ resource?: Resource }> }) => {
-          update(owners, { resource: { id: 'r1' } });
-        },
-      ]);
+interface State {
+  count?: number;
+}
 
-      expect(composition.owners.get().resource).toEqual({ id: 'r1' });
+interface Context {
+  resource?: Resource;
+}
+
+describe('createComposition', () => {
+  describe('signal map derivation', () => {
+    it('creates one signal per declared state key', () => {
+      const behavior: Behavior<StateSignals<State>, ContextSignals<Context>, object> = {
+        stateKeys: ['count'],
+        contextKeys: [],
+        setup: () => {},
+      };
+      const composition = createComposition([behavior]);
+
+      expect(typeof composition.state.count.get).toBe('function');
+      expect(composition.state.count.get()).toBeUndefined();
+    });
+
+    it('creates one signal per declared context key', () => {
+      const behavior: Behavior<StateSignals<State>, ContextSignals<Context>, object> = {
+        stateKeys: [],
+        contextKeys: ['resource'],
+        setup: () => {},
+      };
+      const composition = createComposition([behavior]);
+
+      expect(typeof composition.context.resource.get).toBe('function');
+      expect(composition.context.resource.get()).toBeUndefined();
+    });
+
+    it('deduplicates keys across behaviors that share them', () => {
+      const a: Behavior<StateSignals<State>, ContextSignals<Context>, object> = {
+        stateKeys: ['count'],
+        contextKeys: [],
+        setup: ({ state }) => {
+          state.count.set(1);
+        },
+      };
+      const b: Behavior<StateSignals<State>, ContextSignals<Context>, object> = {
+        stateKeys: ['count'],
+        contextKeys: [],
+        setup: ({ state }) => {
+          // Both behaviors see the same signal — b reads what a wrote.
+          expect(state.count.get()).toBe(1);
+          state.count.set((state.count.get() ?? 0) + 1);
+        },
+      };
+      const composition = createComposition([a, b]);
+
+      expect(composition.state.count.get()).toBe(2);
+    });
+
+    it('passes the same signal map references to every behavior', () => {
+      let stateA: StateSignals<State> | undefined;
+      let stateB: StateSignals<State> | undefined;
+
+      const captureA: Behavior<StateSignals<State>, ContextSignals<Context>, object> = {
+        stateKeys: ['count'],
+        contextKeys: [],
+        setup: ({ state }) => {
+          stateA = state;
+        },
+      };
+      const captureB: Behavior<StateSignals<State>, ContextSignals<Context>, object> = {
+        stateKeys: ['count'],
+        contextKeys: [],
+        setup: ({ state }) => {
+          stateB = state;
+        },
+      };
+
+      createComposition([captureA, captureB]);
+
+      expect(stateA).toBeDefined();
+      expect(stateA).toBe(stateB);
+    });
+  });
+
+  describe('destroy()', () => {
+    it('clears context signals populated by a behavior during setup', async () => {
+      const setBehavior: Behavior<StateSignals<State>, ContextSignals<Context>, object> = {
+        stateKeys: [],
+        contextKeys: ['resource'],
+        setup: ({ context }) => {
+          context.resource.set({ id: 'r1' });
+        },
+      };
+
+      const composition = createComposition([setBehavior]);
+
+      expect(composition.context.resource.get()).toEqual({ id: 'r1' });
 
       await composition.destroy();
 
-      expect(composition.owners.get()).toEqual({});
+      expect(composition.context.resource.get()).toBeUndefined();
     });
 
-    it('clears owners populated via initialOwners', async () => {
+    it('runs behavior cleanups with context still populated, then clears', async () => {
       const resource: Resource = { id: 'r1' };
-      const composition = createComposition([(_: { owners: Signal<{ resource?: Resource }> }) => {}], {
-        initialOwners: { resource },
+      let resourceSeenByCleanup: Resource | undefined;
+
+      const cleanupBehavior: Behavior<StateSignals<State>, ContextSignals<Context>, object> = {
+        stateKeys: [],
+        contextKeys: ['resource'],
+        setup: ({ context }) => {
+          return () => {
+            resourceSeenByCleanup = context.resource.get();
+          };
+        },
+      };
+
+      const composition = createComposition([cleanupBehavior], {
+        initialContext: { resource },
       });
 
-      expect(composition.owners.get().resource).toBe(resource);
-
       await composition.destroy();
 
-      expect(composition.owners.get()).toEqual({});
+      expect(resourceSeenByCleanup).toEqual(resource);
+      expect(composition.context.resource.get()).toBeUndefined();
     });
 
-    it('runs behavior cleanups with owners still populated, then clears', async () => {
-      const resource: Resource = { id: 'r1' };
-      let ownersSeenByCleanup: { resource?: Resource } | null = null;
-
-      const composition = createComposition(
-        [
-          ({ owners }: { owners: Signal<{ resource?: Resource }> }) => {
-            return () => {
-              ownersSeenByCleanup = owners.get();
-            };
-          },
-        ],
-        { initialOwners: { resource } }
-      );
-
-      await composition.destroy();
-
-      expect(ownersSeenByCleanup).toEqual({ resource });
-      expect(composition.owners.get()).toEqual({});
-    });
-
-    it('awaits async cleanups before clearing owners', async () => {
+    it('awaits async cleanups before clearing', async () => {
       let cleanupCompleted = false;
 
-      const composition = createComposition(
-        [
-          (_: { owners: Signal<{ resource?: Resource }> }) => {
-            return async () => {
-              await new Promise<void>((resolve) => setTimeout(resolve, 10));
-              cleanupCompleted = true;
-            };
+      const asyncCleanupBehavior: Behavior<StateSignals<State>, ContextSignals<Context>, object> = {
+        stateKeys: ['count'],
+        contextKeys: [],
+        setup:
+          ({ state }) =>
+          async () => {
+            await new Promise<void>((resolve) => setTimeout(resolve, 10));
+            cleanupCompleted = true;
+            // Verify state is still readable inside the cleanup.
+            void state.count.get();
           },
-        ],
-        { initialOwners: { resource: { id: 'r1' } } }
-      );
+      };
+
+      const composition = createComposition([asyncCleanupBehavior]);
 
       const destroyPromise = composition.destroy();
       expect(cleanupCompleted).toBe(false);
@@ -78,27 +161,273 @@ describe('createComposition', () => {
       await destroyPromise;
 
       expect(cleanupCompleted).toBe(true);
-      expect(composition.owners.get()).toEqual({});
+      expect(composition.state.count.get()).toBeUndefined();
     });
 
-    it('clears owners across multiple keys from multiple behaviors', async () => {
-      const composition = createComposition([
-        ({ owners }: { owners: Signal<{ a?: Resource }> }) => {
-          update(owners, { a: { id: 'a1' } });
+    it('clears across multiple keys from multiple behaviors', async () => {
+      interface MultiContext {
+        a?: Resource;
+        b?: Resource;
+      }
+      const setA: Behavior<StateSignals<State>, ContextSignals<MultiContext>, object> = {
+        stateKeys: [],
+        contextKeys: ['a'],
+        setup: ({ context }) => {
+          context.a.set({ id: 'a1' });
         },
-        ({ owners }: { owners: Signal<{ b?: Resource }> }) => {
-          update(owners, { b: { id: 'b1' } });
+      };
+      const setB: Behavior<StateSignals<State>, ContextSignals<MultiContext>, object> = {
+        stateKeys: [],
+        contextKeys: ['b'],
+        setup: ({ context }) => {
+          context.b.set({ id: 'b1' });
         },
-      ]);
+      };
 
-      expect(composition.owners.get()).toMatchObject({
-        a: { id: 'a1' },
-        b: { id: 'b1' },
-      });
+      const composition = createComposition([setA, setB]);
+
+      expect(composition.context.a.get()).toEqual({ id: 'a1' });
+      expect(composition.context.b.get()).toEqual({ id: 'b1' });
 
       await composition.destroy();
 
-      expect(composition.owners.get()).toEqual({});
+      expect(composition.context.a.get()).toBeUndefined();
+      expect(composition.context.b.get()).toBeUndefined();
+    });
+
+    it('also clears state signals on destroy', async () => {
+      const incrementCount: Behavior<StateSignals<State>, ContextSignals<Context>, object> = {
+        stateKeys: ['count'],
+        contextKeys: [],
+        setup: ({ state }) => {
+          state.count.set(5);
+        },
+      };
+
+      const composition = createComposition([incrementCount]);
+
+      expect(composition.state.count.get()).toBe(5);
+
+      await composition.destroy();
+
+      expect(composition.state.count.get()).toBeUndefined();
+    });
+  });
+
+  describe('initial values', () => {
+    it('seeds state signals from initialState', () => {
+      const behavior: Behavior<StateSignals<State>, ContextSignals<Context>, object> = {
+        stateKeys: ['count'],
+        contextKeys: [],
+        setup: () => {},
+      };
+      const composition = createComposition([behavior], {
+        initialState: { count: 42 },
+      });
+
+      expect(composition.state.count.get()).toBe(42);
+    });
+
+    it('seeds context signals from initialContext', () => {
+      const resource: Resource = { id: 'seeded' };
+      const behavior: Behavior<StateSignals<State>, ContextSignals<Context>, object> = {
+        stateKeys: [],
+        contextKeys: ['resource'],
+        setup: () => {},
+      };
+      const composition = createComposition([behavior], {
+        initialContext: { resource },
+      });
+
+      expect(composition.context.resource.get()).toBe(resource);
+    });
+
+    it('leaves unseeded keys as undefined', () => {
+      interface MultiState {
+        a?: number;
+        b?: number;
+      }
+      const behavior: Behavior<StateSignals<MultiState>, ContextSignals<Context>, object> = {
+        stateKeys: ['a', 'b'],
+        contextKeys: [],
+        setup: () => {},
+      };
+      const composition = createComposition([behavior], {
+        initialState: { a: 1 },
+      });
+
+      expect(composition.state.a.get()).toBe(1);
+      expect(composition.state.b.get()).toBeUndefined();
+    });
+
+    it('makes seeded values visible to behaviors during setup', () => {
+      let seen: number | undefined;
+      const captureBehavior: Behavior<StateSignals<State>, ContextSignals<Context>, object> = {
+        stateKeys: ['count'],
+        contextKeys: [],
+        setup: ({ state }) => {
+          seen = state.count.get();
+        },
+      };
+
+      createComposition([captureBehavior], { initialState: { count: 7 } });
+
+      expect(seen).toBe(7);
+    });
+  });
+
+  describe('config', () => {
+    it('passes config to behaviors verbatim', () => {
+      let received: { interval: number } | undefined;
+      const config = { interval: 250 };
+
+      const captureConfig: Behavior<StateSignals<State>, ContextSignals<Context>, { interval: number }> = {
+        stateKeys: [],
+        contextKeys: [],
+        setup: ({ config }) => {
+          received = config;
+        },
+      };
+
+      createComposition([captureConfig], { config });
+
+      expect(received).toBe(config);
+    });
+
+    it('defaults config to empty object when not supplied', () => {
+      let received: object | undefined;
+
+      const captureConfig: Behavior<StateSignals<State>, ContextSignals<Context>, object> = {
+        stateKeys: [],
+        contextKeys: [],
+        setup: ({ config }) => {
+          received = config;
+        },
+      };
+
+      createComposition([captureConfig]);
+
+      expect(received).toEqual({});
     });
   });
 });
+
+describe('defineBehavior', () => {
+  it('preserves stateKeys, contextKeys, and setup on the returned object', () => {
+    const setup = (): void => {};
+    const behavior = defineBehavior({
+      stateKeys: ['a'],
+      contextKeys: ['b'],
+      setup: setup as (deps: { state: StateSignals<{ a?: number }>; context: ContextSignals<{ b?: string }> }) => void,
+    });
+    expect(behavior.stateKeys).toEqual(['a']);
+    expect(behavior.contextKeys).toEqual(['b']);
+    expect(behavior.setup).toBe(setup);
+  });
+
+  it('is essentially identity at runtime — returns the same input properties', () => {
+    const stateKeys = ['count'] as const;
+    const contextKeys = [] as const;
+    const setup = ({ state }: { state: StateSignals<{ count?: number }> }) => {
+      void state;
+    };
+    const input = { stateKeys, contextKeys, setup };
+    const result = defineBehavior(input);
+
+    expect(result.stateKeys).toBe(stateKeys);
+    expect(result.contextKeys).toBe(contextKeys);
+    expect(result.setup).toBe(setup);
+  });
+
+  it('produces a behavior that composes correctly with createComposition', () => {
+    const incrementCount = defineBehavior({
+      stateKeys: ['count'],
+      contextKeys: [],
+      setup: ({ state }: { state: StateSignals<{ count?: number }> }) => {
+        state.count.set(7);
+      },
+    });
+
+    const composition = createComposition([incrementCount]);
+
+    expect(composition.state.count.get()).toBe(7);
+  });
+
+  it('produces a behavior whose returned cleanup runs on destroy', async () => {
+    let cleanupRan = false;
+    const withCleanup = defineBehavior({
+      stateKeys: [],
+      contextKeys: [],
+      setup: () => () => {
+        cleanupRan = true;
+      },
+    });
+
+    const composition = createComposition([withCleanup]);
+
+    expect(cleanupRan).toBe(false);
+    await composition.destroy();
+    expect(cleanupRan).toBe(true);
+  });
+});
+
+describe('buildSignalMap', () => {
+  it('creates one signal per key', () => {
+    const map = buildSignalMap<{ a?: number; b?: string }>(['a', 'b'], {});
+    expect(typeof map.a.get).toBe('function');
+    expect(typeof map.b.get).toBe('function');
+    expect(map.a.get()).toBeUndefined();
+    expect(map.b.get()).toBeUndefined();
+  });
+
+  it('seeds signals from initial values', () => {
+    const map = buildSignalMap<{ count?: number; label?: string }>(['count', 'label'], {
+      count: 42,
+      label: 'hello',
+    });
+    expect(map.count.get()).toBe(42);
+    expect(map.label.get()).toBe('hello');
+  });
+
+  it('leaves unseeded keys as undefined', () => {
+    const map = buildSignalMap<{ a?: number; b?: string }>(['a', 'b'], { a: 1 });
+    expect(map.a.get()).toBe(1);
+    expect(map.b.get()).toBeUndefined();
+  });
+
+  it('deduplicates duplicate keys (one signal per unique key)', () => {
+    const map = buildSignalMap<{ a?: number; b?: string }>(['a', 'b', 'a', 'b', 'a'], {});
+    expect(Object.keys(map)).toEqual(['a', 'b']);
+  });
+
+  it('returns reactive signals — set/get works', () => {
+    const map = buildSignalMap<{ count?: number }>(['count'], { count: 0 });
+    expect(map.count.get()).toBe(0);
+    map.count.set(7);
+    expect(map.count.get()).toBe(7);
+  });
+
+  it('produces an empty map for an empty key list', () => {
+    // biome-ignore lint/complexity/noBannedTypes: empty interface intentional
+    const map = buildSignalMap<{}>([], {});
+    expect(Object.keys(map)).toEqual([]);
+  });
+
+  it('accepts any Iterable<PropertyKey> — Set, generator, etc.', () => {
+    const fromSet = buildSignalMap<{ a?: number; b?: string }>(new Set(['a', 'b']), {});
+    expect(Object.keys(fromSet).sort()).toEqual(['a', 'b']);
+
+    function* keys(): Generator<PropertyKey> {
+      yield 'a';
+      yield 'b';
+    }
+    const fromGen = buildSignalMap<{ a?: number; b?: string }>(keys(), {});
+    expect(Object.keys(fromGen).sort()).toEqual(['a', 'b']);
+  });
+
+  it('preserves first-occurrence order across duplicate keys', () => {
+    const map = buildSignalMap<{ a?: number; b?: string; c?: boolean }>(['c', 'a', 'b', 'a', 'c'], {});
+    // Set keeps insertion order; first occurrence of each key wins.
+    expect(Object.keys(map)).toEqual(['c', 'a', 'b']);
+  });
+});
diff --git a/packages/spf/src/core/composition/tests/share-signals.test.ts b/packages/spf/src/core/composition/tests/share-signals.test.ts
new file mode 100644
index 00000000..1fbf14eb
--- /dev/null
+++ b/packages/spf/src/core/composition/tests/share-signals.test.ts
@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest';
+import { signal } from '../../signals/primitives';
+import type { ContextSignals, StateSignals } from '../create-composition';
+import { makeShareSignals } from '../share-signals';
+
+interface State {
+  count?: number;
+  label?: string;
+}
+interface Context {
+  element?: { id: string };
+}
+
+function makeDeps() {
+  const state: StateSignals<State> = {
+    count: signal<number | undefined>(undefined),
+    label: signal<string | undefined>(undefined),
+  };
+  const context: ContextSignals<Context> = {
+    element: signal<{ id: string } | undefined>(undefined),
+  };
+  return { state, context };
+}
+
+describe('makeShareSignals', () => {
+  it('passes the writable signal refs to the onSignalsReady callback', () => {
+    const shareSignals = makeShareSignals<State, Context>();
+    const { state, context } = makeDeps();
+    let captured: { state: StateSignals<State>; context: ContextSignals<Context> } | undefined;
+
+    shareSignals.setup({
+      state,
+      context,
+      config: {
+        onSignalsReady: (signals) => {
+          captured = signals;
+        },
+      },
+    });
+
+    expect(captured).toBeDefined();
+    expect(captured?.state.count).toBe(state.count);
+    expect(captured?.state.label).toBe(state.label);
+    expect(captured?.context.element).toBe(context.element);
+  });
+
+  it('captured refs write straight into composition state', () => {
+    const shareSignals = makeShareSignals<State, Context>();
+    const { state, context } = makeDeps();
+    let captured: { state: StateSignals<State>; context: ContextSignals<Context> } | undefined;
+
+    shareSignals.setup({
+      state,
+      context,
+      config: {
+        onSignalsReady: (signals) => {
+          captured = signals;
+        },
+      },
+    });
+
+    captured?.state.count.set(42);
+    captured?.state.label.set('hello');
+    captured?.context.element.set({ id: 'el-1' });
+
+    expect(state.count.get()).toBe(42);
+    expect(state.label.get()).toBe('hello');
+    expect(context.element.get()).toEqual({ id: 'el-1' });
+  });
+
+  it('does not require an onSignalsReady callback', () => {
+    const shareSignals = makeShareSignals<State, Context>();
+    const { state, context } = makeDeps();
+    expect(() => {
+      shareSignals.setup({ state, context, config: {} });
+    }).not.toThrow();
+  });
+
+  it('declares no stateKeys or contextKeys (passthrough behavior)', () => {
+    const shareSignals = makeShareSignals<State, Context>();
+    expect(shareSignals.stateKeys).toEqual([]);
+    expect(shareSignals.contextKeys).toEqual([]);
+  });
+});
diff --git a/packages/spf/src/core/signals/primitives.ts b/packages/spf/src/core/signals/primitives.ts
index 66b59dec..412d16cd 100644
--- a/packages/spf/src/core/signals/primitives.ts
+++ b/packages/spf/src/core/signals/primitives.ts
@@ -39,3 +39,21 @@ export function update<T extends object>(signal: Signal<T>, updater: Partial<T>
   const current = untrack(() => signal.get());
   signal.set(typeof updater === 'function' ? updater(current) : { ...current, ...updater });
 }
+
+/**
+ * Read every signal in a map and return a plain object snapshot. Each read
+ * tracks in the surrounding Computed/Effect — equivalent to calling `.get()`
+ * on a single `Signal<S>` over the merged shape.
+ *
+ * Convenience for behaviors that pass whole state/context snapshots to pure
+ * helpers; prefer per-field reads when only a few fields are needed.
+ */
+export function snapshot<M extends Record<string, ReadonlySignal<unknown>>>(
+  map: M
+): { [K in keyof M]: M[K] extends { get(): infer V } ? V : never } {
+  const out = {} as { [K in keyof M]: M[K] extends { get(): infer V } ? V : never };
+  for (const key in map) {
+    out[key] = map[key]!.get() as never;
+  }
+  return out;
+}
diff --git a/packages/spf/src/dom.ts b/packages/spf/src/dom.ts
index 4bd930c0..765bac46 100644
--- a/packages/spf/src/dom.ts
+++ b/packages/spf/src/dom.ts
@@ -9,14 +9,14 @@
 export { appendSegment } from './media/dom/mse/append-segment';
 export { flushBuffer } from './media/dom/mse/buffer-flusher';
 export { destroyVttResolver, resolveVttSegment } from './media/dom/text/resolve-vtt-segment';
-export { loadSegments } from './playback/behaviors/dom/load-segments';
+export { loadAudioSegments, loadVideoSegments } from './playback/behaviors/dom/load-segments';
 export { setupTextTrackActors } from './playback/behaviors/dom/setup-text-track-actors';
-export type { CurrentTimeOwners, CurrentTimeState } from './playback/behaviors/dom/track-current-time';
+export type { CurrentTimeContext, CurrentTimeState } from './playback/behaviors/dom/track-current-time';
 export { trackCurrentTime } from './playback/behaviors/dom/track-current-time';
 export type {
-  PlaybackInitiatedOwners,
+  PlaybackInitiatedContext,
   PlaybackInitiatedState,
 } from './playback/behaviors/dom/track-playback-initiated';
 export { trackPlaybackInitiated } from './playback/behaviors/dom/track-playback-initiated';
-export type { PlaybackRateOwners, PlaybackRateState } from './playback/behaviors/dom/track-playback-rate';
+export type { PlaybackRateContext, PlaybackRateState } from './playback/behaviors/dom/track-playback-rate';
 export { trackPlaybackRate } from './playback/behaviors/dom/track-playback-rate';
diff --git a/packages/spf/src/index.ts b/packages/spf/src/index.ts
index 48797182..c2af885a 100644
--- a/packages/spf/src/index.ts
+++ b/packages/spf/src/index.ts
@@ -20,14 +20,18 @@ export type {
   BehaviorDeps,
   Composition,
   CompositionOptions,
+  ContextSignals,
   InferBehaviorConfig,
-  InferBehaviorOwners,
+  InferBehaviorContext,
   InferBehaviorState,
   ResolveBehaviorConfig,
-  ResolveBehaviorOwners,
+  ResolveBehaviorContext,
   ResolveBehaviorState,
+  StateSignals,
 } from './core/composition/create-composition';
-export { createComposition } from './core/composition/create-composition';
+export { createComposition, defineBehavior } from './core/composition/create-composition';
+export type { ShareSignalsConfig } from './core/composition/share-signals';
+export { makeShareSignals } from './core/composition/share-signals';
 
 // =============================================================================
 // Signals
@@ -35,7 +39,7 @@ export { createComposition } from './core/composition/create-composition';
 
 export { effect } from './core/signals/effect';
 export type { Computed, ReadonlySignal, Signal, SignalOptions } from './core/signals/primitives';
-export { computed, signal, untrack, update } from './core/signals/primitives';
+export { computed, signal, snapshot, untrack, update } from './core/signals/primitives';
 
 // =============================================================================
 // Tasks
diff --git a/packages/spf/src/media/primitives/select-tracks.ts b/packages/spf/src/media/primitives/select-tracks.ts
index c895eef0..1b398672 100644
--- a/packages/spf/src/media/primitives/select-tracks.ts
+++ b/packages/spf/src/media/primitives/select-tracks.ts
@@ -25,10 +25,10 @@ export interface TrackSelectionState {
 }
 
 /**
- * Owners shape for track selection.
+ * Context shape for track selection.
  * Currently empty - reserved for future use (e.g., bandwidth estimator).
  */
-export type TrackSelectionOwners = Record<string, never>;
+export type TrackSelectionContext = Record<string, never>;
 
 /**
  * Action types for track selection.
diff --git a/packages/spf/src/playback/behaviors/calculate-presentation-duration.ts b/packages/spf/src/playback/behaviors/calculate-presentation-duration.ts
index c53c0463..2a2c92db 100644
--- a/packages/spf/src/playback/behaviors/calculate-presentation-duration.ts
+++ b/packages/spf/src/playback/behaviors/calculate-presentation-duration.ts
@@ -1,5 +1,6 @@
+import { defineBehavior } from '../../core/composition/create-composition';
 import { effect } from '../../core/signals/effect';
-import type { Signal } from '../../core/signals/primitives';
+import { type ReadonlySignal, type Signal, snapshot } from '../../core/signals/primitives';
 import type { AudioTrack, MaybeResolvedPresentation, VideoTrack } from '../../media/types';
 import { isResolvedTrack } from '../../media/types';
 import { getSelectedTrack } from '../../media/utils/track-selection';
@@ -64,24 +65,28 @@ export function getDurationFromResolvedTracks(state: PresentationDurationState):
 /**
  * Calculate and set presentation duration from resolved tracks.
  */
-export function calculatePresentationDuration<S extends PresentationDurationState>({
+function calculatePresentationDurationSetup({
   state,
 }: {
-  state: Signal<S>;
+  state: {
+    presentation: Signal<PresentationDurationState['presentation']>;
+    selectedVideoTrackId: ReadonlySignal<PresentationDurationState['selectedVideoTrackId']>;
+    selectedAudioTrackId: ReadonlySignal<PresentationDurationState['selectedAudioTrackId']>;
+  };
 }): () => void {
   return effect(() => {
-    const currentState = state.get();
+    const currentState = snapshot(state);
     if (!shouldCalculateDuration(currentState)) return;
 
     const duration = getDurationFromResolvedTracks(currentState);
     if (duration === undefined || !Number.isFinite(duration)) return;
 
-    state.set({
-      ...currentState,
-      presentation: {
-        ...currentState.presentation!,
-        duration,
-      },
-    } as S);
+    state.presentation.set({ ...currentState.presentation!, duration });
   });
 }
+
+export const calculatePresentationDuration = defineBehavior({
+  stateKeys: ['presentation', 'selectedVideoTrackId', 'selectedAudioTrackId'],
+  contextKeys: [],
+  setup: calculatePresentationDurationSetup,
+});
diff --git a/packages/spf/src/playback/behaviors/dom/end-of-stream.ts b/packages/spf/src/playback/behaviors/dom/end-of-stream.ts
index c794fcb3..c756f70f 100644
--- a/packages/spf/src/playback/behaviors/dom/end-of-stream.ts
+++ b/packages/spf/src/playback/behaviors/dom/end-of-stream.ts
@@ -1,5 +1,6 @@
+import { defineBehavior } from '../../../core/composition/create-composition';
 import { effect } from '../../../core/signals/effect';
-import { computed, type Signal } from '../../../core/signals/primitives';
+import { computed, type ReadonlySignal, snapshot } from '../../../core/signals/primitives';
 import type { MaybeResolvedPresentation } from '../../../media/types';
 import { isResolvedTrack } from '../../../media/types';
 import { getSelectedTrack, type TrackSelectionState } from '../../../media/utils/track-selection';
@@ -11,7 +12,7 @@ export interface EndOfStreamState extends TrackSelectionState {
   mediaSourceReadyState?: MediaSource['readyState'];
 }
 
-export interface EndOfStreamOwners {
+export interface EndOfStreamContext {
   mediaSource?: MediaSource;
   mediaElement?: HTMLMediaElement | undefined;
   videoBuffer?: SourceBuffer;
@@ -74,7 +75,7 @@ function isLastSegmentAppended(segments: readonly { id: string }[], actor: Sourc
  * Handles video-only, audio-only, and video+audio scenarios.
  * A track with no segments (e.g. unresolved) is considered not ready.
  */
-export function hasLastSegmentLoaded(state: EndOfStreamState, owners: EndOfStreamOwners): boolean {
+export function hasLastSegmentLoaded(state: EndOfStreamState, context: EndOfStreamContext): boolean {
   const videoTrack = state.selectedVideoTrackId ? getSelectedTrack(state, 'video') : undefined;
   const audioTrack = state.selectedAudioTrackId ? getSelectedTrack(state, 'audio') : undefined;
 
@@ -86,11 +87,11 @@ export function hasLastSegmentLoaded(state: EndOfStreamState, owners: EndOfStrea
   if (audioTrack && !isResolvedTrack(audioTrack)) return false;
 
   if (videoTrack && isResolvedTrack(videoTrack)) {
-    if (!isLastSegmentAppended(videoTrack.segments, owners.videoBufferActor)) return false;
+    if (!isLastSegmentAppended(videoTrack.segments, context.videoBufferActor)) return false;
   }
 
   if (audioTrack && isResolvedTrack(audioTrack)) {
-    if (!isLastSegmentAppended(audioTrack.segments, owners.audioBufferActor)) return false;
+    if (!isLastSegmentAppended(audioTrack.segments, context.audioBufferActor)) return false;
   }
 
   return true;
@@ -99,17 +100,17 @@ export function hasLastSegmentLoaded(state: EndOfStreamState, owners: EndOfStrea
 /**
  * Check if we can call endOfStream.
  */
-export function canEndStream(state: EndOfStreamState, owners: EndOfStreamOwners): boolean {
-  return !!(owners.mediaSource && state.presentation);
+export function canEndStream(state: EndOfStreamState, context: EndOfStreamContext): boolean {
+  return !!(context.mediaSource && state.presentation);
 }
 
 /**
  * Check if we should call endOfStream.
  */
-export function shouldEndStream(state: EndOfStreamState, owners: EndOfStreamOwners): boolean {
-  if (!canEndStream(state, owners)) return false;
+export function shouldEndStream(state: EndOfStreamState, context: EndOfStreamContext): boolean {
+  if (!canEndStream(state, context)) return false;
 
-  const { mediaElement } = owners;
+  const { mediaElement } = context;
 
   // MediaSource must be open — read from state.mediaSourceReadyState so the
   // computed re-evaluates when readyState changes (e.g. 'ended' → 'open' on seek-back).
@@ -127,17 +128,17 @@ export function shouldEndStream(state: EndOfStreamState, owners: EndOfStreamOwne
   const hasVideoTrack = !!state.selectedVideoTrackId;
   const hasAudioTrack = !!state.selectedAudioTrackId;
 
-  if (hasVideoTrack && !owners.videoBuffer) return false;
-  if (hasAudioTrack && !owners.audioBuffer) return false;
+  if (hasVideoTrack && !context.videoBuffer) return false;
+  if (hasAudioTrack && !context.audioBuffer) return false;
 
   // SourceBufferActors must be idle — setting duration while a SourceBuffer is
   // updating throws InvalidStateError. The actor subscriber in endOfStream() will
   // re-evaluate when each actor transitions back to idle.
-  if (owners.videoBufferActor?.snapshot.get().value === 'updating') return false;
-  if (owners.audioBufferActor?.snapshot.get().value === 'updating') return false;
+  if (context.videoBufferActor?.snapshot.get().value === 'updating') return false;
+  if (context.audioBufferActor?.snapshot.get().value === 'updating') return false;
 
   // Last segment must be appended for each selected track
-  if (!hasLastSegmentLoaded(state, owners)) return false;
+  if (!hasLastSegmentLoaded(state, context)) return false;
 
   // currentTime must have reached the last segment. Guards against re-ending
   // the stream when a back-buffer remove() re-opens the MediaSource while the
@@ -166,8 +167,8 @@ export function shouldEndStream(state: EndOfStreamState, owners: EndOfStreamOwne
  * Uses actor state rather than raw SourceBuffer.updating so the wait is
  * aligned with the same abstraction that owns all buffer operations.
  */
-function waitForSourceBuffersReady(owners: EndOfStreamOwners): Promise<void> {
-  const updatingActors = [owners.videoBufferActor, owners.audioBufferActor].filter(
+function waitForSourceBuffersReady(context: EndOfStreamContext): Promise<void> {
+  const updatingActors = [context.videoBufferActor, context.audioBufferActor].filter(
     (actor): actor is SourceBufferActor => actor !== undefined && actor.snapshot.get().value === 'updating'
   );
 
@@ -203,9 +204,9 @@ function waitForSourceBuffersReady(owners: EndOfStreamOwners): Promise<void> {
  * Used to set the final duration from actual container timestamps rather
  * than playlist metadata, which handles both shorter and longer cases.
  */
-function getMaxBufferedEnd(owners: EndOfStreamOwners): number {
+function getMaxBufferedEnd(context: EndOfStreamContext): number {
   let max = 0;
-  for (const buf of [owners.videoBuffer, owners.audioBuffer]) {
+  for (const buf of [context.videoBuffer, context.audioBuffer]) {
     if (buf && buf.buffered.length > 0) {
       const end = buf.buffered.end(buf.buffered.length - 1);
       if (end > max) max = end;
@@ -219,10 +220,10 @@ function getMaxBufferedEnd(owners: EndOfStreamOwners): number {
  * Sets the final duration from actual buffered end time, then calls endOfStream().
  */
 const endOfStreamTask = async (
-  { currentOwners }: { currentOwners: EndOfStreamOwners },
+  { currentContext }: { currentContext: EndOfStreamContext },
   _context: object
 ): Promise<void> => {
-  const { mediaSource } = currentOwners;
+  const { mediaSource } = currentContext;
 
   // Double-check MediaSource isn't already ended (in case of race)
   if (mediaSource!.readyState === 'ended') {
@@ -231,7 +232,7 @@ const endOfStreamTask = async (
 
   // Wait for any in-progress SourceBuffer operations to finish before calling
   // endOfStream() — the MSE spec forbids it while any buffer has updating === true.
-  await waitForSourceBuffersReady(currentOwners);
+  await waitForSourceBuffersReady(currentContext);
 
   // Re-check after the async wait
   if (mediaSource!.readyState !== 'open') return;
@@ -241,7 +242,7 @@ const endOfStreamTask = async (
   // handles both shorter (common with CMAF) and longer actual media durations.
   // Per MSE spec, endOfStream() will only *increase* duration if needed, so
   // setting it here first ensures the value from the buffer wins in all cases.
-  const bufferedEnd = getMaxBufferedEnd(currentOwners);
+  const bufferedEnd = getMaxBufferedEnd(currentContext);
   if (bufferedEnd > 0) {
     mediaSource!.duration = bufferedEnd;
   }
@@ -261,39 +262,64 @@ const endOfStreamTask = async (
  * What becomes blocked is calling endOfStream() again, addSourceBuffer(),
  * and MediaSource.duration updates.
  */
-export function endOfStream<S extends EndOfStreamState, O extends EndOfStreamOwners>({
+function endOfStreamSetup({
   state,
-  owners,
+  context,
 }: {
-  state: Signal<S>;
-  owners: Signal<O>;
+  state: {
+    presentation: ReadonlySignal<EndOfStreamState['presentation']>;
+    selectedVideoTrackId: ReadonlySignal<EndOfStreamState['selectedVideoTrackId']>;
+    selectedAudioTrackId: ReadonlySignal<EndOfStreamState['selectedAudioTrackId']>;
+    selectedTextTrackId: ReadonlySignal<EndOfStreamState['selectedTextTrackId']>;
+    mediaSourceReadyState: ReadonlySignal<EndOfStreamState['mediaSourceReadyState']>;
+  };
+  context: {
+    mediaSource: ReadonlySignal<EndOfStreamContext['mediaSource']>;
+    mediaElement: ReadonlySignal<EndOfStreamContext['mediaElement']>;
+    videoBuffer: ReadonlySignal<EndOfStreamContext['videoBuffer']>;
+    audioBuffer: ReadonlySignal<EndOfStreamContext['audioBuffer']>;
+    videoBufferActor: ReadonlySignal<EndOfStreamContext['videoBufferActor']>;
+    audioBufferActor: ReadonlySignal<EndOfStreamContext['audioBufferActor']>;
+  };
 }): () => void {
-  // Derived condition. Transitively tracks through owners into each actor's
-  // snapshot signal — when owners changes and points to a new actor, this computed
+  // Derived condition. Transitively tracks through context into each actor's
+  // snapshot signal — when context changes and points to a new actor, this computed
   // re-tracks to the new actor's signal on next evaluation.
   // shouldEndStream calls actor.snapshot.get() inside the computed body, so those
   // reads are automatically tracked by the Signal.Computed dependency graph.
-  const shouldEnd = computed(() => shouldEndStream(state.get(), owners.get()));
+  const shouldEnd = computed(() => shouldEndStream(snapshot(state), snapshot(context)));
 
   let hasEnded = false;
 
   const cleanupEffect = effect(() => {
     if (!shouldEnd.get()) return;
-    const currentOwners = owners.get();
+    const currentContext = snapshot(context);
     if (hasEnded) {
       // Per the MSE spec, calling appendBuffer() on a SourceBuffer when
       // readyState is 'ended' automatically transitions it back to 'open'.
       // This happens on seek-back after end-of-stream — allow endOfStream()
       // to be called again once the last segment is reloaded.
-      if (state.get().mediaSourceReadyState !== 'open') return;
+      if (state.mediaSourceReadyState.get() !== 'open') return;
       hasEnded = false;
     }
 
     // Set flag before awaiting to close the re-entry window between
     // endOfStream() being called and the async task completing.
     hasEnded = true;
-    endOfStreamTask({ currentOwners }, {}).catch((error) => console.error('Failed to call endOfStream:', error));
+    endOfStreamTask({ currentContext }, {}).catch((error) => console.error('Failed to call endOfStream:', error));
   });
 
   return cleanupEffect;
 }
+
+export const endOfStream = defineBehavior({
+  stateKeys: [
+    'presentation',
+    'selectedVideoTrackId',
+    'selectedAudioTrackId',
+    'selectedTextTrackId',
+    'mediaSourceReadyState',
+  ],
+  contextKeys: ['mediaSource', 'mediaElement', 'videoBuffer', 'audioBuffer', 'videoBufferActor', 'audioBufferActor'],
+  setup: endOfStreamSetup,
+});
diff --git a/packages/spf/src/playback/behaviors/dom/load-segments.ts b/packages/spf/src/playback/behaviors/dom/load-segments.ts
index d9295b67..fce85013 100644
--- a/packages/spf/src/playback/behaviors/dom/load-segments.ts
+++ b/packages/spf/src/playback/behaviors/dom/load-segments.ts
@@ -1,5 +1,6 @@
+import { defineBehavior } from '../../../core/composition/create-composition';
 import { effect } from '../../../core/signals/effect';
-import { computed, type Signal, signal } from '../../../core/signals/primitives';
+import { computed, type ReadonlySignal, type Signal, signal } from '../../../core/signals/primitives';
 import { type BandwidthState, sampleBandwidth } from '../../../media/abr/bandwidth-estimator';
 import { DEFAULT_FORWARD_BUFFER_CONFIG } from '../../../media/buffer/forward-buffer';
 import type { AddressableObject, MaybeResolvedPresentation, ResolvedTrack } from '../../../media/types';
@@ -19,7 +20,7 @@ import type { MediaTrackType } from './setup-sourcebuffer';
 // Re-export buffer state types for consumers that import them from this module.
 export type { BufferState, SourceBufferState };
 
-// Map track type to SourceBufferActor owner property key.
+// Map track type to SourceBufferActor context property key.
 const ActorKeyByType = {
   video: 'videoBufferActor',
   audio: 'audioBufferActor',
@@ -85,7 +86,7 @@ async function fetchStream(addressable: AddressableObject, options?: FetchOption
 }
 
 // ============================================================================
-// STATE & OWNERS
+// STATE & CONTEXT
 // ============================================================================
 
 /**
@@ -102,9 +103,9 @@ export interface SegmentLoadingState extends TrackSelectionState {
 }
 
 /**
- * Owners shape for segment loading.
+ * Context shape for segment loading.
  */
-export interface SegmentLoadingOwners {
+export interface SegmentLoadingContext {
   videoBuffer?: SourceBuffer;
   audioBuffer?: SourceBuffer;
   videoBufferActor?: SourceBufferActor;
@@ -206,7 +207,8 @@ function loadingInputsEq(prevState: LoadingInputs, curState: LoadingInputs): boo
 // ============================================================================
 
 /**
- * Load segments orchestration — Reactor layer.
+ * Load segments orchestration — shared body used by `loadVideoSegments`
+ * and `loadAudioSegments`.
  *
  * Sends typed load messages to a SegmentLoaderActor when relevant conditions
  * change. Uses targeted subscriptions rather than broad combineLatest so only
@@ -231,23 +233,42 @@ function loadingInputsEq(prevState: LoadingInputs, curState: LoadingInputs): boo
  *
  *   playbackInitiated
  *     resolvedTrackId changes      → trigger
- *     segmentStart(currentTime) changes → trigger (segment boundary only)
+ *     segmentStart(currentTime) changes → trigger
  *
- * @example
- * const cleanup = loadSegments({ state, owners }, { type: 'video' });
+ * Type-specific concerns (which actor, whether to track bandwidth) are
+ * resolved by the `loadVideoSegments` / `loadAudioSegments` exports —
+ * they bind `type` at definition time and pass it here.
  */
-export function loadSegments<S extends SegmentLoadingState, O extends SegmentLoadingOwners>(
-  { state, owners }: { state: Signal<S>; owners: Signal<O> },
-  config: { type: MediaTrackType }
+type SegmentLoadingStateMap = {
+  presentation: ReadonlySignal<SegmentLoadingState['presentation']>;
+  preload: ReadonlySignal<SegmentLoadingState['preload']>;
+  bandwidthState: ReadonlySignal<SegmentLoadingState['bandwidthState']>;
+  currentTime: ReadonlySignal<SegmentLoadingState['currentTime']>;
+  playbackInitiated: ReadonlySignal<SegmentLoadingState['playbackInitiated']>;
+  selectedVideoTrackId: ReadonlySignal<SegmentLoadingState['selectedVideoTrackId']>;
+  selectedAudioTrackId: ReadonlySignal<SegmentLoadingState['selectedAudioTrackId']>;
+  selectedTextTrackId: ReadonlySignal<SegmentLoadingState['selectedTextTrackId']>;
+};
+
+type SegmentLoadingContextMap = {
+  videoBuffer: ReadonlySignal<SegmentLoadingContext['videoBuffer']>;
+  audioBuffer: ReadonlySignal<SegmentLoadingContext['audioBuffer']>;
+  videoBufferActor: ReadonlySignal<SegmentLoadingContext['videoBufferActor']>;
+  audioBufferActor: ReadonlySignal<SegmentLoadingContext['audioBufferActor']>;
+};
+
+function setupSegmentLoading(
+  state: SegmentLoadingStateMap,
+  context: SegmentLoadingContextMap,
+  type: MediaTrackType,
+  onThroughputSample?: (next: BandwidthState) => void
 ): () => void {
-  const { type } = config;
   const actorKey = ActorKeyByType[type];
 
   // Local throughput signal — used by createTrackedFetch to sample bandwidth
   // per chunk and propagate back to the shared state for ABR.
-  const initialBandwidth = state.get().bandwidthState;
   const throughput = signal<BandwidthState>(
-    initialBandwidth ?? {
+    state.bandwidthState.get() ?? {
       fastEstimate: 0,
       fastTotalWeight: 0,
       slowEstimate: 0,
@@ -256,24 +277,18 @@ export function loadSegments<S extends SegmentLoadingState, O extends SegmentLoa
     }
   );
 
+  // Video tracks always sample bandwidth and bridge updates back to engine
+  // state via the supplied callback so ABR can react. Audio tracks don't
+  // track throughput.
   const fetchBytes =
-    type === 'video'
-      ? createTrackedFetch(
-          throughput,
-          initialBandwidth !== undefined
-            ? (next) => {
-                state.set(Object.assign({}, state.get(), { bandwidthState: next }) as S);
-              }
-            : undefined
-        )
-      : fetchStream;
+    type === 'video' && onThroughputSample ? createTrackedFetch(throughput, onThroughputSample) : fetchStream;
 
   // Local segment loader — signal so segmentsCanLoad can track it reactively
   const segmentLoader = signal<SegmentLoaderActor | undefined>(undefined);
 
   // Computed: isolates the specific actor key so the lifecycle effect only
-  // re-runs when that actor reference changes, not on unrelated owners updates.
-  const actorSource = computed<SourceBufferActor | undefined>(() => owners.get()[actorKey]);
+  // re-runs when that actor reference changes, not on unrelated context updates.
+  const actorSource = computed<SourceBufferActor | undefined>(() => context[actorKey].get());
 
   // Actor lifecycle — destroy and recreate SegmentLoaderActor when the
   // upstream SourceBufferActor is replaced (quality switch) or removed.
@@ -296,14 +311,32 @@ export function loadSegments<S extends SegmentLoadingState, O extends SegmentLoa
 
   // Derived: true only when we have both a resolved track and a ready loader
   const segmentsCanLoad = computed(() => {
-    const track = getSelectedTrack(state.get(), type);
+    const stateSnapshot: SegmentLoadingState = {
+      presentation: state.presentation.get(),
+      selectedVideoTrackId: state.selectedVideoTrackId.get(),
+      selectedAudioTrackId: state.selectedAudioTrackId.get(),
+      selectedTextTrackId: state.selectedTextTrackId.get(),
+    };
+    const track = getSelectedTrack(stateSnapshot, type);
     return !!track && isResolvedTrack(track) && !!segmentLoader.get();
   });
 
   // Loading inputs — selectLoadingInputs is cheap; let the effect body apply
   // loadingInputsEq rather than the computed, so the first run always fires
   // regardless of the initial state.
-  const loadingInputs = computed(() => selectLoadingInputs([segmentsCanLoad.get(), state.get()], type));
+  const loadingInputs = computed(() => {
+    const stateSnapshot: SegmentLoadingState = {
+      presentation: state.presentation.get(),
+      preload: state.preload.get(),
+      bandwidthState: state.bandwidthState.get(),
+      currentTime: state.currentTime.get(),
+      playbackInitiated: state.playbackInitiated.get(),
+      selectedVideoTrackId: state.selectedVideoTrackId.get(),
+      selectedAudioTrackId: state.selectedAudioTrackId.get(),
+      selectedTextTrackId: state.selectedTextTrackId.get(),
+    };
+    return selectLoadingInputs([segmentsCanLoad.get(), stateSnapshot], type);
+  });
 
   // Load effect — prevInputs guards against redundant messages using the same
   // equality semantics as the former combineLatest selector subscription.
@@ -344,3 +377,50 @@ export function loadSegments<S extends SegmentLoadingState, O extends SegmentLoa
     currentLoader?.destroy();
   };
 }
+
+const SEGMENT_LOADING_STATE_KEYS = [
+  'presentation',
+  'preload',
+  'bandwidthState',
+  'currentTime',
+  'playbackInitiated',
+  'selectedVideoTrackId',
+  'selectedAudioTrackId',
+  'selectedTextTrackId',
+] as const;
+
+const SEGMENT_LOADING_CONTEXT_KEYS = ['videoBuffer', 'audioBuffer', 'videoBufferActor', 'audioBufferActor'] as const;
+
+/**
+ * Load video segments — drives the video SourceBufferActor with media
+ * segments based on bandwidth/preload/currentTime/playbackInitiated.
+ * Tracks throughput per chunk and bridges samples back into
+ * `state.bandwidthState` for ABR.
+ */
+export const loadVideoSegments = defineBehavior({
+  stateKeys: SEGMENT_LOADING_STATE_KEYS,
+  contextKeys: SEGMENT_LOADING_CONTEXT_KEYS,
+  setup: ({
+    state,
+    context,
+  }: {
+    // bandwidthState is the only writable slot in this behavior — video
+    // tracks sample throughput per chunk and bridge updates back into engine
+    // state for ABR. Audio's `loadAudioSegments` keeps it readonly.
+    state: Omit<SegmentLoadingStateMap, 'bandwidthState'> & {
+      bandwidthState: Signal<SegmentLoadingState['bandwidthState']>;
+    };
+    context: SegmentLoadingContextMap;
+  }) => setupSegmentLoading(state, context, 'video', (next) => state.bandwidthState.set(next)),
+});
+
+/**
+ * Load audio segments — same orchestration shape as `loadVideoSegments`,
+ * targeting the audio SourceBufferActor. Audio doesn't sample bandwidth.
+ */
+export const loadAudioSegments = defineBehavior({
+  stateKeys: SEGMENT_LOADING_STATE_KEYS,
+  contextKeys: SEGMENT_LOADING_CONTEXT_KEYS,
+  setup: ({ state, context }: { state: SegmentLoadingStateMap; context: SegmentLoadingContextMap }) =>
+    setupSegmentLoading(state, context, 'audio'),
+});
diff --git a/packages/spf/src/playback/behaviors/dom/setup-mediasource.ts b/packages/spf/src/playback/behaviors/dom/setup-mediasource.ts
index ea133c38..a09b92c7 100644
--- a/packages/spf/src/playback/behaviors/dom/setup-mediasource.ts
+++ b/packages/spf/src/playback/behaviors/dom/setup-mediasource.ts
@@ -1,5 +1,6 @@
+import { defineBehavior } from '../../../core/composition/create-composition';
 import { effect } from '../../../core/signals/effect';
-import { computed, type Signal, update } from '../../../core/signals/primitives';
+import { computed, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';
 import {
   attachMediaSource,
   createMediaSource,
@@ -17,9 +18,9 @@ export interface MediaSourceState {
 }
 
 /**
- * Owners shape for MediaSource setup.
+ * Context shape for MediaSource setup.
  */
-export interface MediaSourceOwners {
+export interface MediaSourceContext {
   mediaElement?: HTMLMediaElement | undefined;
   mediaSource?: MediaSource;
 }
@@ -28,29 +29,35 @@ export interface MediaSourceOwners {
  * Setup MediaSource orchestration.
  *
  * Creates and attaches MediaSource when:
- * - mediaElement exists in owners
+ * - mediaElement exists in context
  * - presentation.url exists in state
  *
- * Updates owners.mediaSource after successful setup.
+ * Updates context.mediaSource after successful setup.
  */
-export function setupMediaSource<S extends MediaSourceState, O extends MediaSourceOwners>({
+function setupMediaSourceSetup({
   state,
-  owners,
+  context,
 }: {
-  state: Signal<S>;
-  owners: Signal<O>;
+  state: {
+    presentation: ReadonlySignal<MediaSourceState['presentation']>;
+    mediaSourceReadyState: Signal<MediaSourceState['mediaSourceReadyState']>;
+  };
+  context: {
+    mediaElement: ReadonlySignal<MediaSourceContext['mediaElement']>;
+    mediaSource: Signal<MediaSourceContext['mediaSource']>;
+  };
 }): () => void {
   const abortController = new AbortController();
 
   // Get the latest mediaElement (even if nullish)
-  const mediaElementSignal = computed(() => owners.get().mediaElement);
+  const mediaElementSignal = computed(() => context.mediaElement.get());
   // Get the latest presentationUrl (even if nullish)
-  const presentationUrlSignal = computed(() => state.get().presentation?.url);
+  const presentationUrlSignal = computed(() => state.presentation.get()?.url);
 
   const canSetupSignal = computed(() => !!mediaElementSignal.get() && !!presentationUrlSignal.get());
 
   const mediaElementSrcSignal = computed(() => mediaElementSignal.get()?.src);
-  const mediaSourceSignal = computed(() => owners.get().mediaSource);
+  const mediaSourceSignal = computed(() => context.mediaSource.get());
   const shouldSetupSignal = computed(() => !mediaElementSrcSignal.get());
 
   // NOTE: This should be cleaner and less brittle if/when Reactors have their own internal finite state. This is planned as followup work.
@@ -63,20 +70,20 @@ export function setupMediaSource<S extends MediaSourceState, O extends MediaSour
 
     const mediaSource = createMediaSource({ preferManaged: true });
     // NOTE: Consider making MediaSource an Actor and using this in it.
-    update(state, { mediaSourceReadyState: mediaSource.readyState } as Partial<S>);
+    state.mediaSourceReadyState.set(mediaSource.readyState);
     onMediaSourceReadyStateChange(mediaSource, abortSignal, (readyState) => {
-      update(state, { mediaSourceReadyState: readyState } as Partial<S>);
+      state.mediaSourceReadyState.set(readyState);
     });
     attachMediaSource(mediaSource, mediaElement);
 
-    const cleanupOwnersUpdateEffect = effect(() => {
-      // If we already have a MediaSource or the *internal* mediaSource is not yet fully attached, wait to add it to owners;
-      if (!!mediaSourceSignal.get() || state.get().mediaSourceReadyState !== 'open') return;
-      owners.set(Object.assign({}, owners.get(), { mediaSource }) as O);
+    const cleanupContextUpdateEffect = effect(() => {
+      // If we already have a MediaSource or the *internal* mediaSource is not yet fully attached, wait to add it to context;
+      if (!!mediaSourceSignal.get() || state.mediaSourceReadyState.get() !== 'open') return;
+      context.mediaSource.set(mediaSource);
     });
 
     return () => {
-      cleanupOwnersUpdateEffect();
+      cleanupContextUpdateEffect();
     };
   });
 
@@ -85,3 +92,9 @@ export function setupMediaSource<S extends MediaSourceState, O extends MediaSour
     cleanupEffect();
   };
 }
+
+export const setupMediaSource = defineBehavior({
+  stateKeys: ['presentation', 'mediaSourceReadyState'],
+  contextKeys: ['mediaElement', 'mediaSource'],
+  setup: setupMediaSourceSetup,
+});
diff --git a/packages/spf/src/playback/behaviors/dom/setup-sourcebuffer.ts b/packages/spf/src/playback/behaviors/dom/setup-sourcebuffer.ts
index 0d6cb03b..b1c49833 100644
--- a/packages/spf/src/playback/behaviors/dom/setup-sourcebuffer.ts
+++ b/packages/spf/src/playback/behaviors/dom/setup-sourcebuffer.ts
@@ -1,5 +1,6 @@
+import { defineBehavior } from '../../../core/composition/create-composition';
 import { effect } from '../../../core/signals/effect';
-import { computed, type Signal, update } from '../../../core/signals/primitives';
+import { computed, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';
 import { createSourceBuffer } from '../../../media/dom/mse/mediasource-setup';
 import type { MaybeResolvedPresentation, ResolvedTrack } from '../../../media/types';
 import { isResolvedTrack } from '../../../media/types';
@@ -15,7 +16,7 @@ export type MediaTrackType = 'video' | 'audio';
 const ActorKeyByType = {
   video: 'videoBufferActor',
   audio: 'audioBufferActor',
-} as const satisfies Record<MediaTrackType, keyof SourceBufferOwners>;
+} as const satisfies Record<MediaTrackType, keyof SourceBufferContext>;
 
 /**
  * State shape for SourceBuffer setup.
@@ -27,9 +28,9 @@ export interface SourceBufferState extends TrackSelectionState {
 }
 
 /**
- * Owners shape for SourceBuffer setup.
+ * Context shape for SourceBuffer setup.
  */
-export interface SourceBufferOwners {
+export interface SourceBufferContext {
   mediaSource?: MediaSource;
   videoBuffer?: SourceBuffer;
   audioBuffer?: SourceBuffer;
@@ -57,7 +58,7 @@ export function buildMimeCodec(track: ResolvedTrack): string {
  *
  * Waits until ALL media tracks in the presentation are resolved with codecs,
  * then creates every SourceBuffer in one synchronous block before setting
- * owners. This guarantees that downstream consumers (e.g. loadSegments) never
+ * context. This guarantees that downstream consumers (e.g. loadSegments) never
  * see a partial set of SourceBuffers — preventing the Firefox bug where
  * appending to a video SourceBuffer before the audio SourceBuffer exists
  * causes mozHasAudio to be permanently false.
@@ -66,18 +67,29 @@ export function buildMimeCodec(track: ResolvedTrack): string {
  * track types are derived from the presentation rather than hardcoded.
  *
  * @example
- * const cleanup = setupSourceBuffers({ state, owners });
+ * const cleanup = setupSourceBuffers.setup({ state, context });
  */
-export function setupSourceBuffers<S extends SourceBufferState, O extends SourceBufferOwners>({
+function setupSourceBuffersSetup({
   state,
-  owners,
+  context,
 }: {
-  state: Signal<S>;
-  owners: Signal<O>;
+  state: {
+    presentation: ReadonlySignal<SourceBufferState['presentation']>;
+    selectedVideoTrackId: ReadonlySignal<SourceBufferState['selectedVideoTrackId']>;
+    selectedAudioTrackId: ReadonlySignal<SourceBufferState['selectedAudioTrackId']>;
+    selectedTextTrackId: ReadonlySignal<SourceBufferState['selectedTextTrackId']>;
+  };
+  context: {
+    mediaSource: ReadonlySignal<SourceBufferContext['mediaSource']>;
+    videoBuffer: Signal<SourceBufferContext['videoBuffer']>;
+    audioBuffer: Signal<SourceBufferContext['audioBuffer']>;
+    videoBufferActor: Signal<SourceBufferContext['videoBufferActor']>;
+    audioBufferActor: Signal<SourceBufferContext['audioBufferActor']>;
+  };
 }): () => void {
   // Derive which media track types this presentation actually contains
   const presentationTypesSignal = computed((): MediaTrackType[] => {
-    const { presentation } = state.get();
+    const presentation = state.presentation.get();
     if (!presentation?.selectionSets) return [];
     return presentation.selectionSets
       .map(({ type }) => type)
@@ -87,39 +99,48 @@ export function setupSourceBuffers<S extends SourceBufferState, O extends Source
   // All presentation track types must have a selected, resolved track with codecs
   const canSetupSignal = computed(() => {
     const types = presentationTypesSignal.get();
-    if (!owners.get().mediaSource || types.length === 0) return false;
-    const s = state.get();
+    if (!context.mediaSource.get() || types.length === 0) return false;
+    const s: SourceBufferState = {
+      presentation: state.presentation.get(),
+      selectedVideoTrackId: state.selectedVideoTrackId.get(),
+      selectedAudioTrackId: state.selectedAudioTrackId.get(),
+    };
     return types.every((type) => {
       const track = getSelectedTrack(s, type);
       return track && isResolvedTrack(track) && !!track.codecs?.length;
     });
   });
 
-  // DOM-observable "already done" guard — once all presentation buffers exist in owners, setup has run
+  // DOM-observable "already done" guard — once all presentation buffers exist in context, setup has run
   const shouldSetupSignal = computed(() => {
-    const o = owners.get();
-    return presentationTypesSignal.get().every((type) => !o[BufferKeyByType[type]]);
+    return presentationTypesSignal.get().every((type) => !context[BufferKeyByType[type]].get());
   });
 
   const cleanupEffect = effect(() => {
     if (!canSetupSignal.get() || !shouldSetupSignal.get()) return;
 
-    const s = state.get();
-    const o = owners.get();
+    const s: SourceBufferState = {
+      presentation: state.presentation.get(),
+      selectedVideoTrackId: state.selectedVideoTrackId.get(),
+      selectedAudioTrackId: state.selectedAudioTrackId.get(),
+    };
+    const mediaSource = context.mediaSource.get()!;
 
     // Create all SourceBuffers synchronously — no await between addSourceBuffer
-    // calls — then set owners once so subscribers see all buffers simultaneously.
-    const patch: Partial<SourceBufferOwners> = {};
-
+    // calls — then set context once so subscribers see all buffers simultaneously.
     for (const type of presentationTypesSignal.get()) {
       const track = getSelectedTrack(s, type) as ResolvedTrack;
-      const buffer = createSourceBuffer(o.mediaSource!, buildMimeCodec(track));
-      patch[BufferKeyByType[type]] = buffer;
-      patch[ActorKeyByType[type]] = createSourceBufferActor(buffer);
+      const buffer = createSourceBuffer(mediaSource, buildMimeCodec(track));
+      context[BufferKeyByType[type]].set(buffer);
+      context[ActorKeyByType[type]].set(createSourceBufferActor(buffer));
     }
-
-    update(owners, patch);
   });
 
   return cleanupEffect;
 }
+
+export const setupSourceBuffers = defineBehavior({
+  stateKeys: ['presentation', 'selectedVideoTrackId', 'selectedAudioTrackId', 'selectedTextTrackId'],
+  contextKeys: ['mediaSource', 'videoBuffer', 'audioBuffer', 'videoBufferActor', 'audioBufferActor'],
+  setup: setupSourceBuffersSetup,
+});
diff --git a/packages/spf/src/playback/behaviors/dom/setup-text-track-actors.ts b/packages/spf/src/playback/behaviors/dom/setup-text-track-actors.ts
index cb95adeb..78dc0846 100644
--- a/packages/spf/src/playback/behaviors/dom/setup-text-track-actors.ts
+++ b/packages/spf/src/playback/behaviors/dom/setup-text-track-actors.ts
@@ -1,5 +1,6 @@
+import { defineBehavior } from '../../../core/composition/create-composition';
 import { effect } from '../../../core/signals/effect';
-import { computed, type Signal, update } from '../../../core/signals/primitives';
+import { computed, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';
 import { createTextTracksActor } from '../../actors/dom/text-tracks';
 import {
   createTextTrackSegmentLoaderActor,
@@ -9,13 +10,13 @@ import {
 import type { TextTracksActor } from '../../actors/text-tracks';
 
 /**
- * Owners shape for text-track actors setup.
+ * Context shape for text-track actors setup.
  *
  * Mirrors the shape `loadTextTrackCues` expects, but with `mediaElement`
  * typed as `HTMLMediaElement` (the concrete input the DOM factory needs)
  * and the actors parameterized over `VTTCue` (what the DOM factory produces).
  */
-export interface TextTrackActorsOwners {
+export interface TextTrackActorsContext {
   mediaElement?: HTMLMediaElement | undefined;
   textTracksActor?: TextTracksActor<VTTCue> | undefined;
   segmentLoaderActor?: TextTrackSegmentLoaderActor | undefined;
@@ -42,7 +43,7 @@ export interface TextTrackActorsConfig {
  * on change or unmount.
  *
  * Subscribes to a `computed` projection of `mediaElement` rather than the
- * full owners signal, so writing the actor slots back to `owners` from
+ * full context signal, so writing the actor slots back to `context` from
  * inside the effect does not re-trigger it.
  *
  * Pairs with the host-agnostic `loadTextTrackCues` behavior in
@@ -54,14 +55,18 @@ export interface TextTrackActorsConfig {
  *   config: { resolveTextTrackSegment: resolveVttSegment },
  * });
  */
-export function setupTextTrackActors<O extends TextTrackActorsOwners>({
-  owners,
+function setupTextTrackActorsSetup({
+  context,
   config,
 }: {
-  owners: Signal<O>;
+  context: {
+    mediaElement: ReadonlySignal<TextTrackActorsContext['mediaElement']>;
+    textTracksActor: Signal<TextTrackActorsContext['textTracksActor']>;
+    segmentLoaderActor: Signal<TextTrackActorsContext['segmentLoaderActor']>;
+  };
   config: TextTrackActorsConfig;
 }): () => void {
-  const mediaElementSignal = computed(() => owners.get().mediaElement);
+  const mediaElementSignal = computed(() => context.mediaElement.get());
 
   return effect(() => {
     const mediaElement = mediaElementSignal.get();
@@ -69,12 +74,20 @@ export function setupTextTrackActors<O extends TextTrackActorsOwners>({
 
     const textTracksActor = createTextTracksActor(mediaElement);
     const segmentLoaderActor = createTextTrackSegmentLoaderActor(textTracksActor, config.resolveTextTrackSegment);
-    update(owners, { textTracksActor, segmentLoaderActor } as Partial<O>);
+    context.textTracksActor.set(textTracksActor);
+    context.segmentLoaderActor.set(segmentLoaderActor);
 
     return () => {
       textTracksActor.destroy();
       segmentLoaderActor.destroy();
-      update(owners, { textTracksActor: undefined, segmentLoaderActor: undefined } as Partial<O>);
+      context.textTracksActor.set(undefined);
+      context.segmentLoaderActor.set(undefined);
     };
   });
 }
+
+export const setupTextTrackActors = defineBehavior({
+  stateKeys: [],
+  contextKeys: ['mediaElement', 'textTracksActor', 'segmentLoaderActor'],
+  setup: setupTextTrackActorsSetup,
+});
diff --git a/packages/spf/src/playback/behaviors/dom/sync-text-tracks.ts b/packages/spf/src/playback/behaviors/dom/sync-text-tracks.ts
index 854c7186..1662d4a5 100644
--- a/packages/spf/src/playback/behaviors/dom/sync-text-tracks.ts
+++ b/packages/spf/src/playback/behaviors/dom/sync-text-tracks.ts
@@ -1,7 +1,8 @@
 import { listen } from '@videojs/utils/dom';
+import { defineBehavior } from '../../../core/composition/create-composition';
 import type { Reactor } from '../../../core/reactors/create-machine-reactor';
 import { createMachineReactor } from '../../../core/reactors/create-machine-reactor';
-import { computed, type Signal, untrack, update } from '../../../core/signals/primitives';
+import { computed, type ReadonlySignal, type Signal, untrack } from '../../../core/signals/primitives';
 import type { MaybeResolvedPresentation, PartiallyResolvedTextTrack, TextTrack } from '../../../media/types';
 
 /**
@@ -24,9 +25,9 @@ export interface TextTrackSyncState {
 }
 
 /**
- * Owners shape for text track sync.
+ * Context shape for text track sync.
  */
-export interface TextTrackSyncOwners {
+export interface TextTrackSyncContext {
   mediaElement?: HTMLMediaElement | undefined;
 }
 
@@ -76,19 +77,22 @@ function syncModes(textTracks: TextTrackList, selectedId: string | undefined): v
  *   `selectedTextTrackId`.
  *
  * @example
- * const reactor = syncTextTracks({ state, owners });
+ * const reactor = syncTextTracks.setup({ state, context });
  * // later:
  * reactor.destroy();
  */
-export function syncTextTracks<S extends TextTrackSyncState, O extends TextTrackSyncOwners>({
+function syncTextTracksSetup({
   state,
-  owners,
+  context,
 }: {
-  state: Signal<S>;
-  owners: Signal<O>;
+  state: {
+    presentation: ReadonlySignal<TextTrackSyncState['presentation']>;
+    selectedTextTrackId: Signal<TextTrackSyncState['selectedTextTrackId']>;
+  };
+  context: { mediaElement: ReadonlySignal<TextTrackSyncContext['mediaElement']> };
 }): Reactor<'preconditions-unmet' | 'set-up' | 'destroying' | 'destroyed'> {
-  const mediaElementSignal = computed(() => owners.get().mediaElement);
-  const modelTextTracksSignal = computed(() => getModelTextTracks(state.get().presentation), {
+  const mediaElementSignal = computed(() => context.mediaElement.get());
+  const modelTextTracksSignal = computed(() => getModelTextTracks(state.presentation.get()), {
     /** @TODO Make generic and abstract away for Array<T> | undefined (CJP) */
     equals(prevTextTracks, nextTextTracks) {
       if (prevTextTracks === nextTextTracks) return true;
@@ -103,7 +107,7 @@ export function syncTextTracks<S extends TextTrackSyncState, O extends TextTrack
       );
     },
   });
-  const selectedTextTrackIdSignal = computed(() => state.get().selectedTextTrackId);
+  const selectedTextTrackIdSignal = computed(() => state.selectedTextTrackId.get());
   const preconditionsMetSignal = computed(() => !!mediaElementSignal.get() && !!modelTextTracksSignal.get()?.length);
 
   return createMachineReactor<'preconditions-unmet' | 'set-up'>({
@@ -124,7 +128,7 @@ export function syncTextTracks<S extends TextTrackSyncState, O extends TextTrack
             mediaElement
               .querySelectorAll('track[data-src-track]:is([kind="subtitles"],[kind="captions"]')
               .forEach((trackEl) => trackEl.remove());
-            update(state, { selectedTextTrackId: undefined } as Partial<S>);
+            state.selectedTextTrackId.set(undefined);
           };
         },
 
@@ -161,7 +165,7 @@ export function syncTextTracks<S extends TextTrackSyncState, O extends TextTrack
             const newId = showingTrack?.id;
             const currentModelId = untrack(() => selectedTextTrackIdSignal.get());
             if (newId === currentModelId) return;
-            update(state, { selectedTextTrackId: newId } as Partial<S>);
+            state.selectedTextTrackId.set(newId);
           };
 
           const unlisten = listen(mediaElement.textTracks, 'change', onChange);
@@ -175,3 +179,9 @@ export function syncTextTracks<S extends TextTrackSyncState, O extends TextTrack
     },
   });
 }
+
+export const syncTextTracks = defineBehavior({
+  stateKeys: ['presentation', 'selectedTextTrackId'],
+  contextKeys: ['mediaElement'],
+  setup: syncTextTracksSetup,
+});
diff --git a/packages/spf/src/playback/behaviors/dom/tests/end-of-stream-partial-resolution.test.ts b/packages/spf/src/playback/behaviors/dom/tests/end-of-stream-partial-resolution.test.ts
index 97d8fdcc..fd98d749 100644
--- a/packages/spf/src/playback/behaviors/dom/tests/end-of-stream-partial-resolution.test.ts
+++ b/packages/spf/src/playback/behaviors/dom/tests/end-of-stream-partial-resolution.test.ts
@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import type { PartiallyResolvedVideoTrack, Presentation, VideoSelectionSet } from '../../../../media/types';
 import { createSourceBufferActor } from '../../../actors/dom/source-buffer';
-import type { EndOfStreamOwners, EndOfStreamState } from '../end-of-stream';
+import type { EndOfStreamContext, EndOfStreamState } from '../end-of-stream';
 import { hasLastSegmentLoaded } from '../end-of-stream';
 
 // ============================================================================
@@ -106,10 +106,10 @@ describe('hasLastSegmentLoaded', () => {
         presentation: makeResolvedPresentation('v1'),
         selectedVideoTrackId: 'v1',
       };
-      const owners: EndOfStreamOwners = {
+      const context: EndOfStreamContext = {
         videoBufferActor: makeActorWithSegments(['seg-1', 'seg-2'], 'v1'),
       };
-      expect(hasLastSegmentLoaded(state, owners)).toBe(true);
+      expect(hasLastSegmentLoaded(state, context)).toBe(true);
     });
 
     it('returns false when last segment ID is not in actor context', () => {
@@ -118,28 +118,23 @@ describe('hasLastSegmentLoaded', () => {
         selectedVideoTrackId: 'v1',
       };
       // only seg-1 present; seg-2 (the last segment) is missing
-      const owners: EndOfStreamOwners = {
+      const context: EndOfStreamContext = {
         videoBufferActor: makeActorWithSegments(['seg-1'], 'v1'),
       };
-      expect(hasLastSegmentLoaded(state, owners)).toBe(false);
+      expect(hasLastSegmentLoaded(state, context)).toBe(false);
     });
   });
 
   describe('unresolved tracks — quality switch scenario', () => {
     it('returns false when selectedVideoTrackId points to an unresolved track', () => {
-      // Quality switch scenario: ABR switched selectedVideoTrackId to a new
-      // (unresolved) track. The old track's segments are still in the buffer, but
-      // since the new track is unresolved we cannot know if its end is covered.
       const state: EndOfStreamState = {
         presentation: makeUnresolvedPresentation('new-track'),
         selectedVideoTrackId: 'new-track',
       };
-      // Actor has old track's segments — but the track is unresolved so we
-      // return false before even checking the actor.
-      const owners: EndOfStreamOwners = {
+      const context: EndOfStreamContext = {
         videoBufferActor: makeActorWithSegments(['seg-1', 'seg-2'], 'some-track'),
       };
-      expect(hasLastSegmentLoaded(state, owners)).toBe(false);
+      expect(hasLastSegmentLoaded(state, context)).toBe(false);
     });
 
     it('returns false when selectedAudioTrackId points to an unresolved track', () => {
@@ -175,10 +170,10 @@ describe('hasLastSegmentLoaded', () => {
         } as unknown as Presentation,
         selectedAudioTrackId: 'audio-new',
       };
-      const owners: EndOfStreamOwners = {
+      const context: EndOfStreamContext = {
         audioBufferActor: makeActorWithSegments(['seg-1', 'seg-2'], 'some-track'),
       };
-      expect(hasLastSegmentLoaded(state, owners)).toBe(false);
+      expect(hasLastSegmentLoaded(state, context)).toBe(false);
     });
   });
 
diff --git a/packages/spf/src/playback/behaviors/dom/tests/end-of-stream.test.ts b/packages/spf/src/playback/behaviors/dom/tests/end-of-stream.test.ts
index dc2d51f0..ba1f8b74 100644
--- a/packages/spf/src/playback/behaviors/dom/tests/end-of-stream.test.ts
+++ b/packages/spf/src/playback/behaviors/dom/tests/end-of-stream.test.ts
@@ -1,24 +1,46 @@
 import { describe, expect, it, vi } from 'vitest';
+import type { ContextSignals, StateSignals } from '../../../../core/composition/create-composition';
 import { signal } from '../../../../core/signals/primitives';
-import type { Presentation, Segment, VideoTrack } from '../../../../media/types';
+import type { MaybeResolvedPresentation, Presentation, Segment, VideoTrack } from '../../../../media/types';
 import { createSourceBufferActor, type SourceBufferActor } from '../../../actors/dom/source-buffer';
 import {
   canEndStream,
-  type EndOfStreamOwners,
+  type EndOfStreamContext,
   type EndOfStreamState,
   endOfStream,
   hasLastSegmentLoaded,
   shouldEndStream,
 } from '../end-of-stream';
 
-function setupEndOfStream(initialState: EndOfStreamState, initialOwners: EndOfStreamOwners) {
+function makeState(initial: EndOfStreamState = {}): StateSignals<EndOfStreamState> {
+  return {
+    presentation: signal<MaybeResolvedPresentation | undefined>(initial.presentation),
+    mediaSourceReadyState: signal<MediaSource['readyState'] | undefined>(initial.mediaSourceReadyState),
+    selectedVideoTrackId: signal<string | undefined>(initial.selectedVideoTrackId),
+    selectedAudioTrackId: signal<string | undefined>(initial.selectedAudioTrackId),
+    selectedTextTrackId: signal<string | undefined>(initial.selectedTextTrackId),
+  };
+}
+
+function makeContext(initial: EndOfStreamContext = {}): ContextSignals<EndOfStreamContext> {
+  return {
+    mediaSource: signal<MediaSource | undefined>(initial.mediaSource),
+    mediaElement: signal<HTMLMediaElement | undefined>(initial.mediaElement),
+    videoBuffer: signal<SourceBuffer | undefined>(initial.videoBuffer),
+    audioBuffer: signal<SourceBuffer | undefined>(initial.audioBuffer),
+    videoBufferActor: signal<SourceBufferActor | undefined>(initial.videoBufferActor),
+    audioBufferActor: signal<SourceBufferActor | undefined>(initial.audioBufferActor),
+  };
+}
+
+function setupEndOfStream(initialState: EndOfStreamState, initialContext: EndOfStreamContext) {
   // Default mediaSourceReadyState to 'open' to mirror what setupMediaSource
   // would have written. Tests that exercise other readyState values pass it
   // explicitly.
-  const state = signal<EndOfStreamState>({ mediaSourceReadyState: 'open', ...initialState });
-  const owners = signal<EndOfStreamOwners>(initialOwners);
-  const cleanup = endOfStream({ state, owners });
-  return { state, owners, cleanup };
+  const state = makeState({ mediaSourceReadyState: 'open', ...initialState });
+  const context = makeContext(initialContext);
+  const cleanup = endOfStream.setup({ state, context });
+  return { state, context, cleanup };
 }
 
 // ============================================================================
@@ -143,10 +165,10 @@ describe('hasLastSegmentLoaded', () => {
       presentation: makePresentation(track),
     };
     // seg-3 (the last segment) is missing
-    const owners: EndOfStreamOwners = {
+    const context: EndOfStreamContext = {
       videoBufferActor: makeActorWithSegments(['seg-0', 'seg-1', 'seg-2']),
     };
-    expect(hasLastSegmentLoaded(state, owners)).toBe(false);
+    expect(hasLastSegmentLoaded(state, context)).toBe(false);
   });
 
   it('returns true when last segment ID is present (seek-back scenario)', () => {
@@ -156,10 +178,10 @@ describe('hasLastSegmentLoaded', () => {
       presentation: makePresentation(track),
     };
     // Last segment is in the SourceBuffer from a prior play-through.
-    const owners: EndOfStreamOwners = {
+    const context: EndOfStreamContext = {
       videoBufferActor: makeActorWithSegments(['seg-0', 'seg-7', 'seg-8', 'seg-9']),
     };
-    expect(hasLastSegmentLoaded(state, owners)).toBe(true);
+    expect(hasLastSegmentLoaded(state, context)).toBe(true);
   });
 
   it('returns true when last segment ID is in actor context', () => {
@@ -168,10 +190,10 @@ describe('hasLastSegmentLoaded', () => {
       selectedVideoTrackId: 'video-1',
       presentation: makePresentation(track),
     };
-    const owners: EndOfStreamOwners = {
+    const context: EndOfStreamContext = {
       videoBufferActor: makeActorWithSegments(['seg-0', 'seg-1', 'seg-2', 'seg-3']),
     };
-    expect(hasLastSegmentLoaded(state, owners)).toBe(true);
+    expect(hasLastSegmentLoaded(state, context)).toBe(true);
   });
 
   it('returns true after back-buffer flushing when last segment ID remains', () => {
@@ -181,10 +203,10 @@ describe('hasLastSegmentLoaded', () => {
       presentation: makePresentation(track),
     };
     // Early segments flushed, last segment still present
-    const owners: EndOfStreamOwners = {
+    const context: EndOfStreamContext = {
       videoBufferActor: makeActorWithSegments(['seg-7', 'seg-8', 'seg-9']),
     };
-    expect(hasLastSegmentLoaded(state, owners)).toBe(true);
+    expect(hasLastSegmentLoaded(state, context)).toBe(true);
   });
 
   it('returns true when track has no segments', () => {
@@ -193,10 +215,10 @@ describe('hasLastSegmentLoaded', () => {
       selectedVideoTrackId: 'video-1',
       presentation: makePresentation(track),
     };
-    const owners: EndOfStreamOwners = {
+    const context: EndOfStreamContext = {
       videoBufferActor: makeActorWithSegments([]),
     };
-    expect(hasLastSegmentLoaded(state, owners)).toBe(true);
+    expect(hasLastSegmentLoaded(state, context)).toBe(true);
   });
 
   it('returns false when last segment is present but marked partial', () => {
@@ -263,11 +285,11 @@ describe('hasLastSegmentLoaded', () => {
       selectedAudioTrackId: 'audio-1',
       presentation,
     };
-    const owners: EndOfStreamOwners = {
+    const context: EndOfStreamContext = {
       videoBufferActor: makeActorWithSegments(['seg-3'], 'video-1'),
       audioBufferActor: makeActorWithSegments(['audio-seg-0'], 'audio-1'),
     };
-    expect(hasLastSegmentLoaded(state, owners)).toBe(false);
+    expect(hasLastSegmentLoaded(state, context)).toBe(false);
   });
 });
 
@@ -432,7 +454,7 @@ describe('endOfStream', () => {
     });
 
     // Trigger another state change — readyState is 'ended' so must not call again
-    state.set({ ...state.get(), presentation: makePresentation(track) });
+    state.presentation.set(makePresentation(track));
     await new Promise((resolve) => setTimeout(resolve, 50));
 
     expect(mockMs.endOfStream).toHaveBeenCalledTimes(1);
@@ -477,7 +499,7 @@ describe('endOfStream', () => {
     // Simulate real MSE: endOfStream() transitions readyState to 'ended'.
     (mockMs.endOfStream as ReturnType<typeof vi.fn>).mockImplementation(() => {
       (mockMs as unknown as { readyState: string }).readyState = 'ended';
-      state.set({ ...state.get(), mediaSourceReadyState: 'ended' });
+      state.mediaSourceReadyState.set('ended');
     });
 
     // First play-through: endOfStream() is called, readyState transitions to 'ended'.
@@ -488,7 +510,7 @@ describe('endOfStream', () => {
     // Simulate seek-back: appendBuffer() re-opens the MediaSource per MSE spec.
     // The state update drives re-evaluation.
     (mockMs as unknown as { readyState: string }).readyState = 'open';
-    state.set({ ...state.get(), mediaSourceReadyState: 'open' });
+    state.mediaSourceReadyState.set('open');
 
     // endOfStream() should be called again driven purely by the state update.
     await vi.waitFor(() => {
@@ -518,7 +540,7 @@ describe('endOfStream', () => {
     (mockMs as unknown as { readyState: string }).readyState = 'ended';
 
     // Trigger a state change — should not call endOfStream() again
-    state.set({ ...state.get(), presentation: makePresentation(track) });
+    state.presentation.set(makePresentation(track));
     await new Promise((resolve) => setTimeout(resolve, 50));
 
     expect(mockMs.endOfStream).toHaveBeenCalledTimes(1);
diff --git a/packages/spf/src/playback/behaviors/dom/tests/load-segments-track-switch.test.ts b/packages/spf/src/playback/behaviors/dom/tests/load-segments-track-switch.test.ts
index 2d0b9bd4..b558e742 100644
--- a/packages/spf/src/playback/behaviors/dom/tests/load-segments-track-switch.test.ts
+++ b/packages/spf/src/playback/behaviors/dom/tests/load-segments-track-switch.test.ts
@@ -1,9 +1,11 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ContextSignals, StateSignals } from '../../../../core/composition/create-composition';
 import { signal } from '../../../../core/signals/primitives';
-import type { Presentation, VideoSelectionSet } from '../../../../media/types';
-import { createSourceBufferActor } from '../../../actors/dom/source-buffer';
-import type { SegmentLoadingOwners, SegmentLoadingState } from '../load-segments';
-import { loadSegments } from '../load-segments';
+import type { BandwidthState } from '../../../../media/abr/bandwidth-estimator';
+import type { MaybeResolvedPresentation, Presentation, VideoSelectionSet } from '../../../../media/types';
+import { createSourceBufferActor, type SourceBufferActor } from '../../../actors/dom/source-buffer';
+import type { SegmentLoadingContext, SegmentLoadingState } from '../load-segments';
+import { loadVideoSegments } from '../load-segments';
 
 // ============================================================================
 // Mocks
@@ -21,6 +23,28 @@ vi.mock('../../../../media/dom/mse/buffer-flusher', () => ({
 // Helpers
 // ============================================================================
 
+function makeState(initial: SegmentLoadingState = {}): StateSignals<SegmentLoadingState> {
+  return {
+    presentation: signal<MaybeResolvedPresentation | undefined>(initial.presentation),
+    preload: signal<string | undefined>(initial.preload),
+    bandwidthState: signal<BandwidthState | undefined>(initial.bandwidthState),
+    currentTime: signal<number | undefined>(initial.currentTime),
+    playbackInitiated: signal<boolean | undefined>(initial.playbackInitiated),
+    selectedVideoTrackId: signal<string | undefined>(initial.selectedVideoTrackId),
+    selectedAudioTrackId: signal<string | undefined>(initial.selectedAudioTrackId),
+    selectedTextTrackId: signal<string | undefined>(initial.selectedTextTrackId),
+  };
+}
+
+function makeContext(initial: SegmentLoadingContext = {}): ContextSignals<SegmentLoadingContext> {
+  return {
+    videoBuffer: signal<SourceBuffer | undefined>(initial.videoBuffer),
+    audioBuffer: signal<SourceBuffer | undefined>(initial.audioBuffer),
+    videoBufferActor: signal<SourceBufferActor | undefined>(initial.videoBufferActor),
+    audioBufferActor: signal<SourceBufferActor | undefined>(initial.audioBufferActor),
+  };
+}
+
 const seg = (id: string, startTime: number, duration = 10) => ({
   id,
   url: `https://example.com/${id}.m4s`,
@@ -69,10 +93,6 @@ const makeMockSourceBuffer = () => {
   return sb;
 };
 
-// ============================================================================
-// Helpers
-// ============================================================================
-
 function makeControllableFetch() {
   const resolvers = new Map<string, () => void>();
   const fetchedUrls: string[] = [];
@@ -100,8 +120,6 @@ describe('loadSegments — track switch', () => {
 
   beforeEach(() => {
     originalFetch = globalThis.fetch;
-    // Use mockImplementation so each call gets a fresh Response (avoiding
-    // "body stream already read" errors when multiple fetches occur).
     globalThis.fetch = vi
       .fn()
       .mockImplementation(() => Promise.resolve(new Response(new ArrayBuffer(100), { status: 200 })));
@@ -122,7 +140,6 @@ describe('loadSegments — track switch', () => {
 
     const videoBuffer = makeMockSourceBuffer();
 
-    // Pre-seed actor with track-a already loaded
     const videoBufferActor = createSourceBufferActor(videoBuffer, {
       initTrackId: 'track-a',
       segments: [
@@ -131,40 +148,32 @@ describe('loadSegments — track switch', () => {
       ],
     });
 
-    const state = signal<SegmentLoadingState>({
+    const state = makeState({
       presentation,
       selectedVideoTrackId: 'track-a',
       preload: 'auto',
-      playbackInitiated: true, // track switches are an ABR concern during playback
+      playbackInitiated: true,
       currentTime: 5,
     });
 
-    const owners = signal<SegmentLoadingOwners>({ videoBuffer, videoBufferActor });
+    const context = makeContext({ videoBuffer, videoBufferActor });
 
-    const cleanup = loadSegments({ state, owners }, { type: 'video' });
+    const cleanup = loadVideoSegments.setup({ state, context });
 
-    // Wait for initial evaluation to settle (track-a already fully loaded — no work needed)
     await new Promise((r) => setTimeout(r, 20));
 
-    // ABR switches to track B
-    state.set({ ...state.get(), selectedVideoTrackId: 'track-b' });
+    state.selectedVideoTrackId.set('track-b');
 
-    // Wait for task to process track switch
     await new Promise((r) => setTimeout(r, 50));
 
-    // No full flush: new content overwrites existing buffer ranges in-place.
     expect(flushSpy).not.toHaveBeenCalledWith(videoBuffer, 0, Infinity);
 
-    // New track-b init should be committed.
-    const ctx = owners.get().videoBufferActor?.snapshot.get().context;
+    const ctx = context.videoBufferActor.get()?.snapshot.get().context;
     expect(ctx?.initTrackId).toBe('track-b');
 
-    // Old track-a segments should be gone: time-aligned deduplication replaces
-    // each a* entry when b* is appended at the same startTime.
     const hasOldSegments = ctx?.segments.some((s) => ['a1', 'a2'].includes(s.id));
     expect(hasOldSegments).toBeFalsy();
 
-    // New track-b segments should be present.
     const hasNewSegments = ctx?.segments.some((s) => ['b1', 'b2'].includes(s.id));
     expect(hasNewSegments).toBeTruthy();
 
@@ -181,7 +190,7 @@ describe('loadSegments — track switch', () => {
     const videoBuffer = makeMockSourceBuffer();
     const videoBufferActor = createSourceBufferActor(videoBuffer);
 
-    const state = signal<SegmentLoadingState>({
+    const state = makeState({
       presentation,
       selectedVideoTrackId: 'track-a',
       preload: 'auto',
@@ -189,26 +198,22 @@ describe('loadSegments — track switch', () => {
       currentTime: 0,
     });
 
-    const owners = signal<SegmentLoadingOwners>({ videoBuffer, videoBufferActor });
-    const cleanup = loadSegments({ state, owners }, { type: 'video' });
+    const context = makeContext({ videoBuffer, videoBufferActor });
+    const cleanup = loadVideoSegments.setup({ state, context });
 
-    // Wait for track-a init fetch to start (but leave it pending)
     await vi.waitFor(() => expect(fetchedUrls).toContain('https://example.com/track-a-init.mp4'));
 
-    // Switch tracks while track-a init is still in-flight
-    state.set({ ...state.get(), selectedVideoTrackId: 'track-b' });
+    state.selectedVideoTrackId.set('track-b');
 
-    // Unblock the pending init fetch so the runner can progress
     resolve('https://example.com/track-a-init.mp4');
 
-    // track-b init should be fetched after the preempt
     await vi.waitFor(() => expect(fetchedUrls).toContain('https://example.com/track-b-init.mp4'), {
       timeout: 3000,
     });
 
     resolve('https://example.com/track-b-init.mp4');
 
-    await vi.waitFor(() => expect(owners.get().videoBufferActor?.snapshot.get().context.initTrackId).toBe('track-b'), {
+    await vi.waitFor(() => expect(context.videoBufferActor.get()?.snapshot.get().context.initTrackId).toBe('track-b'), {
       timeout: 3000,
     });
 
@@ -222,7 +227,6 @@ describe('loadSegments — track switch', () => {
     const presentation = makePresentation(trackA, trackB);
     const videoBuffer = makeMockSourceBuffer();
 
-    // Pre-seed actor: track-a fully loaded, playing at t=25
     const videoBufferActor = createSourceBufferActor(videoBuffer, {
       initTrackId: 'track-a',
       segments: [
@@ -231,7 +235,7 @@ describe('loadSegments — track switch', () => {
       ],
     });
 
-    const state = signal<SegmentLoadingState>({
+    const state = makeState({
       presentation,
       selectedVideoTrackId: 'track-a',
       preload: 'auto',
@@ -239,13 +243,12 @@ describe('loadSegments — track switch', () => {
       currentTime: 25,
     });
 
-    const owners = signal<SegmentLoadingOwners>({ videoBuffer, videoBufferActor });
-    const cleanup = loadSegments({ state, owners }, { type: 'video' });
+    const context = makeContext({ videoBuffer, videoBufferActor });
+    const cleanup = loadVideoSegments.setup({ state, context });
 
     await new Promise((r) => setTimeout(r, 20));
 
-    // Switch to track-b at currentTime=25
-    state.set({ ...state.get(), selectedVideoTrackId: 'track-b' });
+    state.selectedVideoTrackId.set('track-b');
 
     const fetchedUrls: string[] = [];
     globalThis.fetch = vi.fn().mockImplementation((input: RequestInfo | URL) => {
@@ -254,7 +257,6 @@ describe('loadSegments — track switch', () => {
       return Promise.resolve(new Response(new ArrayBuffer(100), { status: 200 }));
     });
 
-    // Segments at or past currentTime=25 should be loaded (b3@20 overlaps [25,55), b4-b6)
     await vi.waitFor(
       () => {
         expect(fetchedUrls).toContain('https://example.com/b3.m4s');
@@ -263,7 +265,6 @@ describe('loadSegments — track switch', () => {
       { timeout: 3000 }
     );
 
-    // Segments before currentTime=25 should NOT be loaded (b1@0 and b2@10 end before 25)
     expect(fetchedUrls).not.toContain('https://example.com/b1.m4s');
     expect(fetchedUrls).not.toContain('https://example.com/b2.m4s');
 
@@ -278,22 +279,20 @@ describe('loadSegments — track switch', () => {
     const presentation = makePresentation(trackA);
     const videoBuffer = makeMockSourceBuffer();
 
-    // Actor starts fresh (no prior track)
     const videoBufferActor = createSourceBufferActor(videoBuffer);
 
-    const state = signal<SegmentLoadingState>({
+    const state = makeState({
       presentation,
       selectedVideoTrackId: 'track-a',
       preload: 'auto',
       currentTime: 0,
     });
 
-    const owners = signal<SegmentLoadingOwners>({ videoBuffer, videoBufferActor });
+    const context = makeContext({ videoBuffer, videoBufferActor });
 
-    const cleanup = loadSegments({ state, owners }, { type: 'video' });
+    const cleanup = loadVideoSegments.setup({ state, context });
     await new Promise((r) => setTimeout(r, 50));
 
-    // No full flush should happen on first init load
     expect(flushSpy).not.toHaveBeenCalledWith(videoBuffer, 0, Infinity);
 
     cleanup();
diff --git a/packages/spf/src/playback/behaviors/dom/tests/load-segments.test.ts b/packages/spf/src/playback/behaviors/dom/tests/load-segments.test.ts
index 16ae1eac..98d39b5f 100644
--- a/packages/spf/src/playback/behaviors/dom/tests/load-segments.test.ts
+++ b/packages/spf/src/playback/behaviors/dom/tests/load-segments.test.ts
@@ -3,10 +3,39 @@
  */
 
 import { describe, expect, it, vi } from 'vitest';
+import type { ContextSignals, StateSignals } from '../../../../core/composition/create-composition';
 import { signal } from '../../../../core/signals/primitives';
-import type { Segment } from '../../../../media/types';
-import { createSourceBufferActor } from '../../../actors/dom/source-buffer';
-import { loadSegments, type SegmentLoadingOwners, type SegmentLoadingState } from '../load-segments';
+import type { BandwidthState } from '../../../../media/abr/bandwidth-estimator';
+import type { MaybeResolvedPresentation, Segment } from '../../../../media/types';
+import { createSourceBufferActor, type SourceBufferActor } from '../../../actors/dom/source-buffer';
+import {
+  loadAudioSegments,
+  loadVideoSegments,
+  type SegmentLoadingContext,
+  type SegmentLoadingState,
+} from '../load-segments';
+
+function makeState(initial: SegmentLoadingState = {}): StateSignals<SegmentLoadingState> {
+  return {
+    presentation: signal<MaybeResolvedPresentation | undefined>(initial.presentation),
+    preload: signal<string | undefined>(initial.preload),
+    bandwidthState: signal<BandwidthState | undefined>(initial.bandwidthState),
+    currentTime: signal<number | undefined>(initial.currentTime),
+    playbackInitiated: signal<boolean | undefined>(initial.playbackInitiated),
+    selectedVideoTrackId: signal<string | undefined>(initial.selectedVideoTrackId),
+    selectedAudioTrackId: signal<string | undefined>(initial.selectedAudioTrackId),
+    selectedTextTrackId: signal<string | undefined>(initial.selectedTextTrackId),
+  };
+}
+
+function makeContext(initial: SegmentLoadingContext = {}): ContextSignals<SegmentLoadingContext> {
+  return {
+    videoBuffer: signal<SourceBuffer | undefined>(initial.videoBuffer),
+    audioBuffer: signal<SourceBuffer | undefined>(initial.audioBuffer),
+    videoBufferActor: signal<SourceBufferActor | undefined>(initial.videoBufferActor),
+    audioBufferActor: signal<SourceBufferActor | undefined>(initial.audioBufferActor),
+  };
+}
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -123,13 +152,14 @@ function makeSourceBufferWithActor(
 
 function setupLoadSegments(
   initialState: SegmentLoadingState,
-  initialOwners: SegmentLoadingOwners,
+  initialContext: SegmentLoadingContext,
   type: 'video' | 'audio'
 ) {
-  const state = signal<SegmentLoadingState>(initialState);
-  const owners = signal<SegmentLoadingOwners>(initialOwners);
-  const cleanup = loadSegments({ state, owners }, { type });
-  return { state, owners, cleanup };
+  const state = makeState(initialState);
+  const context = makeContext(initialContext);
+  const behavior = type === 'video' ? loadVideoSegments : loadAudioSegments;
+  const cleanup = behavior.setup({ state, context });
+  return { state, context, cleanup };
 }
 
 // ---------------------------------------------------------------------------
@@ -324,7 +354,7 @@ describe('loadSegments orchestration (metadata mode)', () => {
     globalThis.fetch = vi.fn().mockImplementation(() => Promise.resolve(new Response(new ArrayBuffer(100))));
 
     const { sourceBuffer, actor } = makeSourceBufferWithActor();
-    const { owners, cleanup } = setupLoadSegments(
+    const { context, cleanup } = setupLoadSegments(
       { preload: 'metadata', selectedVideoTrackId: 'track-1', presentation: makePresentation(segments) },
       { videoBuffer: sourceBuffer, videoBufferActor: actor },
       'video'
@@ -332,12 +362,12 @@ describe('loadSegments orchestration (metadata mode)', () => {
 
     await vi.waitFor(
       () => {
-        expect(owners.get().videoBufferActor?.snapshot.get().context.initTrackId).toBe('track-1');
+        expect(context.videoBufferActor.get()?.snapshot.get().context.initTrackId).toBe('track-1');
       },
       { timeout: 2000 }
     );
 
-    expect(owners.get().videoBufferActor?.snapshot.get().context.segments.length ?? 0).toBe(0);
+    expect(context.videoBufferActor.get()?.snapshot.get().context.segments.length ?? 0).toBe(0);
 
     cleanup();
   });
@@ -353,7 +383,7 @@ describe('loadSegments orchestration (metadata mode)', () => {
     });
 
     const { sourceBuffer, actor } = makeSourceBufferWithActor();
-    const { state, owners, cleanup } = setupLoadSegments(
+    const { state, context, cleanup } = setupLoadSegments(
       { preload: 'metadata', selectedVideoTrackId: 'track-1', presentation: makePresentation(segments) },
       { videoBuffer: sourceBuffer, videoBufferActor: actor },
       'video'
@@ -361,14 +391,14 @@ describe('loadSegments orchestration (metadata mode)', () => {
 
     await vi.waitFor(
       () => {
-        expect(owners.get().videoBufferActor?.snapshot.get().context.initTrackId).toBe('track-1');
+        expect(context.videoBufferActor.get()?.snapshot.get().context.initTrackId).toBe('track-1');
       },
       { timeout: 2000 }
     );
 
     expect(fetchedUrls).not.toContain('http://example.com/s1.m4s');
 
-    state.set({ ...state.get(), playbackInitiated: true });
+    state.playbackInitiated.set(true);
 
     await vi.waitFor(
       () => {
@@ -448,7 +478,7 @@ describe('loadSegments seek handling', () => {
 
     await vi.waitFor(() => expect(fetchedUrls).toContain('http://example.com/init.mp4'));
 
-    state.set({ ...state.get(), currentTime: 60 });
+    state.currentTime.set(60);
 
     resolve('http://example.com/init.mp4');
 
@@ -483,8 +513,8 @@ describe('loadSegments seek handling', () => {
 
     await vi.waitFor(() => expect(fetchedUrls).toContain('http://example.com/init.mp4'));
 
-    state.set({ ...state.get(), currentTime: 60 });
-    state.set({ ...state.get(), currentTime: 90 });
+    state.currentTime.set(60);
+    state.currentTime.set(90);
 
     resolveAll();
 
@@ -511,7 +541,7 @@ describe('loadSegments seek handling', () => {
     });
 
     const { sourceBuffer, actor } = makeSourceBufferWithActor();
-    const { state, cleanup } = setupLoadSegments(
+    const { cleanup } = setupLoadSegments(
       {
         preload: 'auto',
         playbackInitiated: true, // currentTime advances are only tracked post-play
@@ -523,8 +553,8 @@ describe('loadSegments seek handling', () => {
       'video'
     );
 
-    state.set({ ...state.get() });
-    state.set({ ...state.get() });
+    /* no-op state update */
+    /* no-op state update */
 
     await vi.waitFor(
       () => {
@@ -630,7 +660,7 @@ describe('loadSegments back buffer flushing', () => {
       [{ id: 's1', startTime: 0, duration: 10, trackId: 'track-1' }],
       'track-1'
     );
-    const { owners, cleanup } = setupLoadSegments(
+    const { context, cleanup } = setupLoadSegments(
       {
         preload: 'auto',
         selectedVideoTrackId: 'track-1',
@@ -653,7 +683,7 @@ describe('loadSegments back buffer flushing', () => {
       'video'
     );
 
-    await vi.waitFor(() => (owners.get().videoBufferActor?.snapshot.get().context.segments.length ?? 0) > 1, {
+    await vi.waitFor(() => (context.videoBufferActor.get()?.snapshot.get().context.segments.length ?? 0) > 1, {
       timeout: 3000,
     });
 
@@ -683,7 +713,7 @@ describe('loadSegments back buffer flushing', () => {
       ],
       'track-1'
     );
-    const { owners, cleanup } = setupLoadSegments(
+    const { context, cleanup } = setupLoadSegments(
       { preload: 'auto', selectedVideoTrackId: 'track-1', currentTime: 40, presentation: makePresentationF6(segments) },
       { videoBuffer: sourceBuffer, videoBufferActor: actor },
       'video'
@@ -692,10 +722,10 @@ describe('loadSegments back buffer flushing', () => {
     await vi.waitFor(
       () => {
         const ids =
-          owners
+          context.videoBufferActor
             .get()
-            .videoBufferActor?.snapshot.get()
-            .context.segments.map((s) => s.id) ?? [];
+            ?.snapshot.get()
+            .context.segments.map((s: { id: string }) => s.id) ?? [];
         expect(ids).not.toContain('s1');
         expect(ids).not.toContain('s2');
       },
@@ -796,7 +826,7 @@ describe('loadSegments forward buffer flushing', () => {
       segments.map((s) => ({ id: s.id, startTime: s.startTime, duration: s.duration, trackId: 'track-1' })),
       'track-1'
     );
-    const { owners, cleanup } = setupLoadSegments(
+    const { context, cleanup } = setupLoadSegments(
       { preload: 'auto', selectedVideoTrackId: 'track-1', currentTime: 0, presentation: makePresentationFwd(segments) },
       { videoBuffer: sourceBuffer, videoBufferActor: actor },
       'video'
@@ -807,10 +837,10 @@ describe('loadSegments forward buffer flushing', () => {
     await vi.waitFor(
       () => {
         const ids =
-          owners
+          context.videoBufferActor
             .get()
-            .videoBufferActor?.snapshot.get()
-            .context.segments.map((s) => s.id) ?? [];
+            ?.snapshot.get()
+            .context.segments.map((s: { id: string }) => s.id) ?? [];
         expect(ids).not.toContain('s4');
         expect(ids).not.toContain('s5');
         expect(ids).toContain('s1');
@@ -892,7 +922,7 @@ describe('loadSegments byte-range segment fetching', () => {
     };
 
     const { sourceBuffer, actor } = makeSourceBufferWithActor();
-    const { owners, cleanup } = setupLoadSegments(
+    const { context, cleanup } = setupLoadSegments(
       {
         preload: 'auto',
         selectedVideoTrackId: 'track-1',
@@ -911,7 +941,7 @@ describe('loadSegments byte-range segment fetching', () => {
 
     await vi.waitFor(
       () => {
-        expect(owners.get().videoBufferActor?.snapshot.get().context.segments).toHaveLength(2);
+        expect(context.videoBufferActor.get()?.snapshot.get().context.segments).toHaveLength(2);
       },
       { timeout: 3000 }
     );
@@ -934,7 +964,7 @@ describe('loadSegments byte-range segment fetching', () => {
     });
 
     const { sourceBuffer, actor } = makeSourceBufferWithActor();
-    const { owners, cleanup } = setupLoadSegments(
+    const { context, cleanup } = setupLoadSegments(
       {
         preload: 'auto',
         selectedVideoTrackId: 'track-1',
@@ -959,7 +989,7 @@ describe('loadSegments byte-range segment fetching', () => {
 
     await vi.waitFor(
       () => {
-        expect(owners.get().videoBufferActor?.snapshot.get().context.segments).toHaveLength(1);
+        expect(context.videoBufferActor.get()?.snapshot.get().context.segments).toHaveLength(1);
       },
       { timeout: 3000 }
     );
@@ -1018,7 +1048,7 @@ describe('loadSegments bandwidth tracking', () => {
     };
 
     const { sourceBuffer, actor } = makeSourceBufferWithActor();
-    const { state, owners, cleanup } = setupLoadSegments(
+    const { state, context, cleanup } = setupLoadSegments(
       {
         preload: 'auto',
         selectedVideoTrackId: 'track-1',
@@ -1039,15 +1069,15 @@ describe('loadSegments bandwidth tracking', () => {
     // Wait for both init and segment to be appended (actor context will have 1 segment)
     await vi.waitFor(
       () => {
-        expect(owners.get().videoBufferActor?.snapshot.get().context.segments).toHaveLength(1);
+        expect(context.videoBufferActor.get()?.snapshot.get().context.segments).toHaveLength(1);
       },
       { timeout: 3000 }
     );
 
     // All bytes (init + segment) should be counted in bytesSampled
     const totalExpected = chunkSize * numChunks * 2; // init fetch + segment fetch, each 3×50KB
-    expect(state.get().bandwidthState?.bytesSampled).toBeGreaterThan(0);
-    expect(state.get().bandwidthState?.bytesSampled).toBeLessThanOrEqual(totalExpected);
+    expect(state.bandwidthState.get()?.bytesSampled).toBeGreaterThan(0);
+    expect(state.bandwidthState.get()?.bytesSampled).toBeLessThanOrEqual(totalExpected);
 
     cleanup();
   });
@@ -1082,7 +1112,7 @@ describe('loadSegments bandwidth tracking', () => {
     };
 
     const { sourceBuffer, actor } = makeSourceBufferWithActor();
-    const { owners, cleanup } = setupLoadSegments(
+    const { context, cleanup } = setupLoadSegments(
       {
         preload: 'auto',
         selectedVideoTrackId: 'track-1',
@@ -1101,7 +1131,7 @@ describe('loadSegments bandwidth tracking', () => {
 
     await vi.waitFor(
       () => {
-        expect(owners.get().videoBufferActor?.snapshot.get().context.segments).toHaveLength(1);
+        expect(context.videoBufferActor.get()?.snapshot.get().context.segments).toHaveLength(1);
       },
       { timeout: 3000 }
     );
diff --git a/packages/spf/src/playback/behaviors/dom/tests/load-text-track-cues.test.ts b/packages/spf/src/playback/behaviors/dom/tests/load-text-track-cues.test.ts
index 5dce8dfc..8c50002a 100644
--- a/packages/spf/src/playback/behaviors/dom/tests/load-text-track-cues.test.ts
+++ b/packages/spf/src/playback/behaviors/dom/tests/load-text-track-cues.test.ts
@@ -1,19 +1,29 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ContextSignals, StateSignals } from '../../../../core/composition/create-composition';
 import { signal } from '../../../../core/signals/primitives';
 import { resolveVttSegment } from '../../../../media/dom/text/resolve-vtt-segment';
-import type { Presentation, Segment, TextTrack } from '../../../../media/types';
+import type {
+  Cue,
+  MaybeResolvedPresentation,
+  MediaElementWithTextTracks,
+  Presentation,
+  Segment,
+  TextTrack,
+} from '../../../../media/types';
+import type { TextTrackSegmentLoaderActor } from '../../../actors/text-track-segment-loader';
+import type { TextTracksActor } from '../../../actors/text-tracks';
 import {
   loadTextTrackCues,
-  type TextTrackCueLoadingOwners,
+  type TextTrackCueLoadingContext,
   type TextTrackCueLoadingState,
 } from '../../load-text-track-cues';
-import { setupTextTrackActors, type TextTrackActorsOwners } from '../setup-text-track-actors';
+import { setupTextTrackActors, type TextTrackActorsContext } from '../setup-text-track-actors';
 
 // The composed behaviors (setup in dom + loader in media) intersect their
-// owner-shape contracts. The setup narrows `mediaElement` to
+// context-shape contracts. The setup narrows `mediaElement` to
 // `HTMLMediaElement`; the loader keeps the abstract actor types. The test
-// signal has to satisfy both.
-type ComposedOwners = TextTrackCueLoadingOwners & TextTrackActorsOwners;
+// signal map has to satisfy both.
+type ComposedContext = TextTrackCueLoadingContext & TextTrackActorsContext;
 
 // Mock resolveVttSegment
 vi.mock('../../../../media/dom/text/resolve-vtt-segment', () => ({
@@ -26,6 +36,26 @@ vi.mock('../../../../media/dom/text/resolve-vtt-segment', () => ({
   destroyVttResolver: vi.fn(),
 }));
 
+function makeState(initial: TextTrackCueLoadingState = {}): StateSignals<TextTrackCueLoadingState> {
+  return {
+    selectedTextTrackId: signal<string | undefined>(initial.selectedTextTrackId),
+    presentation: signal<MaybeResolvedPresentation | undefined>(initial.presentation),
+    currentTime: signal<number | undefined>(initial.currentTime),
+  };
+}
+
+function makeContext(initial: ComposedContext = {}): ContextSignals<ComposedContext> {
+  return {
+    mediaElement: signal<(MediaElementWithTextTracks & HTMLMediaElement) | undefined>(
+      initial.mediaElement as (MediaElementWithTextTracks & HTMLMediaElement) | undefined
+    ) as ContextSignals<ComposedContext>['mediaElement'],
+    textTracksActor: signal<TextTracksActor<VTTCue & Cue> | undefined>(
+      initial.textTracksActor as TextTracksActor<VTTCue & Cue> | undefined
+    ) as ContextSignals<ComposedContext>['textTracksActor'],
+    segmentLoaderActor: signal<TextTrackSegmentLoaderActor | undefined>(initial.segmentLoaderActor),
+  };
+}
+
 function createMockPresentation(tracks: Partial<TextTrack>[]): Presentation {
   return {
     url: 'https://example.com/playlist.m3u8',
@@ -63,21 +93,16 @@ function createMockSegments(count: number): Segment[] {
   }));
 }
 
-/**
- * Sets up the composition of `setupTextTrackActors` (DOM-side actor
- * setup) and `loadTextTrackCues` (host-agnostic orchestrator). Returns
- * the composed reactive channels and a combined cleanup.
- */
-function setupLoadTextTrackCues(initialState: TextTrackCueLoadingState, initialOwners: ComposedOwners) {
-  const state = signal<TextTrackCueLoadingState>(initialState);
-  const owners = signal<ComposedOwners>(initialOwners);
-  const setupCleanup = setupTextTrackActors({ owners, config: { resolveTextTrackSegment: resolveVttSegment } });
-  const reactor = loadTextTrackCues({ state, owners });
+function setupLoadTextTrackCues(initialState: TextTrackCueLoadingState, initialContext: ComposedContext) {
+  const state = makeState(initialState);
+  const context = makeContext(initialContext);
+  const setupCleanup = setupTextTrackActors.setup({ context, config: { resolveTextTrackSegment: resolveVttSegment } });
+  const reactor = loadTextTrackCues.setup({ state, context });
   const cleanup = () => {
     reactor.destroy();
     setupCleanup();
   };
-  return { state, owners, cleanup };
+  return { state, context, cleanup };
 }
 
 describe('loadTextTrackCues', () => {
@@ -85,14 +110,7 @@ describe('loadTextTrackCues', () => {
     vi.clearAllMocks();
   });
 
-  // Note: We cannot test actual cue addition in unit tests because the vitest
-  // browser environment clears manually added cues after async operations.
-  // These tests verify the orchestration logic and that resolveVttSegment is called.
-
   describe('cue deduplication', () => {
-    // Deduplication checks textTrack.cues directly. Since the vitest browser
-    // environment clears cues after async operations, we override addCue and the
-    // cues getter to maintain a persistent list across awaits for these tests.
     function makeTrackWithPersistentCues() {
       const trackElement = document.createElement('track');
       trackElement.id = 'text-1';
@@ -141,7 +159,6 @@ describe('loadTextTrackCues', () => {
 
     it('drops a duplicate cue from a subsequent segment', async () => {
       const { resolveVttSegment } = await import('../../../../media/dom/text/resolve-vtt-segment');
-      // Boundary-spanning cue appears in both adjacent segments per HLS spec
       vi.mocked(resolveVttSegment)
         .mockResolvedValueOnce([new VTTCue(8, 12, 'Boundary cue')])
         .mockResolvedValueOnce([new VTTCue(8, 12, 'Boundary cue')]);
@@ -165,7 +182,7 @@ describe('loadTextTrackCues', () => {
       const { resolveVttSegment } = await import('../../../../media/dom/text/resolve-vtt-segment');
       vi.mocked(resolveVttSegment)
         .mockResolvedValueOnce([new VTTCue(0, 5, 'Hello')])
-        .mockResolvedValueOnce([new VTTCue(0, 5, 'World')]); // same timing, different text — not a duplicate
+        .mockResolvedValueOnce([new VTTCue(0, 5, 'World')]);
 
       const { video, addCueSpy } = makeTrackWithPersistentCues();
 
@@ -199,7 +216,6 @@ describe('loadTextTrackCues', () => {
       );
       await new Promise((resolve) => setTimeout(resolve, 50));
 
-      // 3 unique cues — boundary cue added only once
       expect(addCueSpy).toHaveBeenCalledTimes(3);
       cleanup();
     });
@@ -221,7 +237,7 @@ describe('loadTextTrackCues', () => {
     trackElement.id = 'text-1';
     const video = document.createElement('video');
     video.appendChild(trackElement);
-    trackElement.track.mode = 'hidden'; // Enable cue access
+    trackElement.track.mode = 'hidden';
 
     const { cleanup } = setupLoadTextTrackCues(
       {
@@ -245,7 +261,7 @@ describe('loadTextTrackCues', () => {
     trackElement.id = 'text-1';
     const video = document.createElement('video');
     video.appendChild(trackElement);
-    trackElement.track.mode = 'hidden'; // Enable cue access
+    trackElement.track.mode = 'hidden';
 
     const { cleanup } = setupLoadTextTrackCues(
       {
@@ -266,16 +282,12 @@ describe('loadTextTrackCues', () => {
     cleanup();
   });
 
-  // Note: the "skips when cues already loaded" test was removed — with forward
-  // buffer windowing, the orchestrator now re-evaluates on each currentTime change.
-  // Re-loading is prevented by the loadedSegmentIds set in the closure, not DOM cues.
-
   it('continues on segment error (partial loading)', async () => {
     const trackElement = document.createElement('track');
     trackElement.id = 'text-1';
     const video = document.createElement('video');
     video.appendChild(trackElement);
-    trackElement.track.mode = 'hidden'; // Enable cue access
+    trackElement.track.mode = 'hidden';
 
     const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
 
@@ -299,13 +311,11 @@ describe('loadTextTrackCues', () => {
     await new Promise((resolve) => setTimeout(resolve, 50));
 
     const { resolveVttSegment } = await import('../../../../media/dom/text/resolve-vtt-segment');
-    // Verify all segments were attempted
     expect(resolveVttSegment).toHaveBeenCalledTimes(3);
     expect(resolveVttSegment).toHaveBeenNthCalledWith(1, 'https://example.com/segment-0.vtt');
     expect(resolveVttSegment).toHaveBeenNthCalledWith(2, 'https://example.com/fail.vtt');
     expect(resolveVttSegment).toHaveBeenNthCalledWith(3, 'https://example.com/segment-2.vtt');
 
-    // Verify error was logged for the failing segment
     expect(consoleErrorSpy).toHaveBeenCalledWith(
       expect.stringContaining('Failed to load text-track segment'),
       expect.any(Error)
@@ -338,9 +348,6 @@ describe('loadTextTrackCues', () => {
   });
 
   describe('forward buffer windowing', () => {
-    // 5 segments × 10s = 50s total. Default buffer window = 30s.
-    // At t=0: window [0, 30) covers seg-0..seg-2; seg-3 (start=30) and seg-4 excluded.
-    // At t=15: window [15, 45) adds seg-3 (start=30) and seg-4 (start=40).
     function makeWindowingSetup(currentTime = 0) {
       const trackElement = document.createElement('track');
       trackElement.id = 'text-1';
@@ -348,7 +355,7 @@ describe('loadTextTrackCues', () => {
       video.appendChild(trackElement);
       trackElement.track.mode = 'hidden';
 
-      const { state, owners, cleanup } = setupLoadTextTrackCues(
+      const { state, context, cleanup } = setupLoadTextTrackCues(
         {
           selectedTextTrackId: 'text-1',
           currentTime,
@@ -357,7 +364,7 @@ describe('loadTextTrackCues', () => {
         { mediaElement: video }
       );
 
-      return { state, owners, cleanup, trackElement };
+      return { state, context, cleanup, trackElement };
     }
 
     it('only fetches segments within the forward buffer window at the initial position', async () => {
@@ -366,7 +373,6 @@ describe('loadTextTrackCues', () => {
       await new Promise((resolve) => setTimeout(resolve, 50));
 
       const { resolveVttSegment } = await import('../../../../media/dom/text/resolve-vtt-segment');
-      // Window [0, 30): seg-0 (0s), seg-1 (10s), seg-2 (20s) — seg-3 starts at 30 (excluded)
       expect(resolveVttSegment).toHaveBeenCalledTimes(3);
       expect(resolveVttSegment).toHaveBeenCalledWith('https://example.com/segment-0.vtt');
       expect(resolveVttSegment).toHaveBeenCalledWith('https://example.com/segment-1.vtt');
@@ -380,14 +386,12 @@ describe('loadTextTrackCues', () => {
     it('fetches new in-window segments when currentTime advances', async () => {
       const { state, cleanup } = makeWindowingSetup(0);
 
-      // Wait for initial window load (seg-0..seg-2)
       await new Promise((resolve) => setTimeout(resolve, 50));
 
       const { resolveVttSegment } = await import('../../../../media/dom/text/resolve-vtt-segment');
       expect(resolveVttSegment).toHaveBeenCalledTimes(3);
 
-      // Advance currentTime so seg-3 and seg-4 enter the window [15, 45)
-      state.set({ ...state.get(), currentTime: 15 });
+      state.currentTime.set(15);
 
       await vi.waitFor(() => {
         expect(resolveVttSegment).toHaveBeenCalledTimes(5);
@@ -408,12 +412,11 @@ describe('loadTextTrackCues', () => {
       const callsBefore = (resolveVttSegment as ReturnType<typeof vi.fn>).mock.calls.map((c) => c[0]);
       expect(callsBefore).toContain('https://example.com/segment-0.vtt');
 
-      state.set({ ...state.get(), currentTime: 15 });
+      state.currentTime.set(15);
       await vi.waitFor(() => {
         expect(resolveVttSegment).toHaveBeenCalledTimes(5);
       });
 
-      // seg-0..seg-2 should each appear exactly once across all calls
       const allCalls = (resolveVttSegment as ReturnType<typeof vi.fn>).mock.calls.map((c) => c[0]);
       expect(allCalls.filter((u) => u === 'https://example.com/segment-0.vtt')).toHaveLength(1);
       expect(allCalls.filter((u) => u === 'https://example.com/segment-1.vtt')).toHaveLength(1);
@@ -423,8 +426,6 @@ describe('loadTextTrackCues', () => {
     });
 
     it('fetches all segments immediately when the track fits in one window', async () => {
-      // 3 segments × 10s = 30s total — all fit in the default [0, 30) window.
-      // Set up directly with 3 segments so no preemption from a prior 5-segment load.
       const trackElement = document.createElement('track');
       trackElement.id = 'text-1';
       const video = document.createElement('video');
diff --git a/packages/spf/src/playback/behaviors/dom/tests/setup-mediasource.test.ts b/packages/spf/src/playback/behaviors/dom/tests/setup-mediasource.test.ts
index 8db3ac05..e702527c 100644
--- a/packages/spf/src/playback/behaviors/dom/tests/setup-mediasource.test.ts
+++ b/packages/spf/src/playback/behaviors/dom/tests/setup-mediasource.test.ts
@@ -1,11 +1,12 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ContextSignals, StateSignals } from '../../../../core/composition/create-composition';
 import { signal } from '../../../../core/signals/primitives';
-import { type MediaSourceOwners, type MediaSourceState, setupMediaSource } from '../setup-mediasource';
+import { type MediaSourceContext, type MediaSourceState, setupMediaSource } from '../setup-mediasource';
 
 // Mock the DOM utilities.
 // onMediaSourceReadyStateChange fires `onChange('open')` immediately — simulates
 // the MediaSource having opened, which is the condition the inner effect waits
-// on before writing to owners.
+// on before writing to context.
 vi.mock('../../../../media/dom/mse/mediasource-setup', () => ({
   createMediaSource: vi.fn(() => ({
     addEventListener: vi.fn(),
@@ -22,11 +23,25 @@ vi.mock('../../../../media/dom/mse/mediasource-setup', () => ({
   ),
 }));
 
-function setupSetupMediaSource(initialState: MediaSourceState, initialOwners: MediaSourceOwners) {
-  const state = signal<MediaSourceState>(initialState);
-  const owners = signal<MediaSourceOwners>(initialOwners);
-  const cleanup = setupMediaSource({ state, owners });
-  return { state, owners, cleanup };
+function makeState(initial: MediaSourceState = {}): StateSignals<MediaSourceState> {
+  return {
+    presentation: signal<MediaSourceState['presentation']>(initial.presentation),
+    mediaSourceReadyState: signal<MediaSource['readyState'] | undefined>(initial.mediaSourceReadyState),
+  };
+}
+
+function makeContext(initial: MediaSourceContext = {}): ContextSignals<MediaSourceContext> {
+  return {
+    mediaElement: signal<HTMLMediaElement | undefined>(initial.mediaElement),
+    mediaSource: signal<MediaSource | undefined>(initial.mediaSource),
+  };
+}
+
+function setupSetupMediaSource(initialState: MediaSourceState, initialContext: MediaSourceContext) {
+  const state = makeState(initialState);
+  const context = makeContext(initialContext);
+  const cleanup = setupMediaSource.setup({ state, context });
+  return { state, context, cleanup };
 }
 
 describe('setupMediaSource', () => {
@@ -37,13 +52,10 @@ describe('setupMediaSource', () => {
   it('creates MediaSource when mediaElement and presentation.url exist', async () => {
     const { createMediaSource } = await import('../../../../media/dom/mse/mediasource-setup');
 
-    const { state, owners, cleanup } = setupSetupMediaSource({}, {});
+    const { state, context, cleanup } = setupSetupMediaSource({}, {});
 
-    owners.set({ ...owners.get(), mediaElement: {} as HTMLMediaElement });
-    state.set({
-      ...state.get(),
-      presentation: { url: 'https://example.com/video.m3u8' },
-    });
+    context.mediaElement.set({} as HTMLMediaElement);
+    state.presentation.set({ url: 'https://example.com/video.m3u8' });
 
     await vi.waitFor(() => {
       expect(createMediaSource).toHaveBeenCalledWith({ preferManaged: true });
@@ -62,14 +74,11 @@ describe('setupMediaSource', () => {
     };
     vi.mocked(createMediaSource).mockReturnValue(mockMediaSource as unknown as MediaSource);
 
-    const { state, owners, cleanup } = setupSetupMediaSource({}, {});
+    const { state, context, cleanup } = setupSetupMediaSource({}, {});
     const mediaElement = {} as HTMLMediaElement;
 
-    owners.set({ ...owners.get(), mediaElement });
-    state.set({
-      ...state.get(),
-      presentation: { url: 'https://example.com/video.m3u8' },
-    });
+    context.mediaElement.set(mediaElement);
+    state.presentation.set({ url: 'https://example.com/video.m3u8' });
 
     await vi.waitFor(() => {
       expect(attachMediaSource).toHaveBeenCalledWith(mockMediaSource, mediaElement);
@@ -78,7 +87,7 @@ describe('setupMediaSource', () => {
     cleanup();
   });
 
-  it('publishes mediaSource on owners and mediaSourceReadyState on state', async () => {
+  it('publishes mediaSource on context and mediaSourceReadyState on state', async () => {
     const { createMediaSource } = await import('../../../../media/dom/mse/mediasource-setup');
 
     const mockMediaSource = {
@@ -88,17 +97,14 @@ describe('setupMediaSource', () => {
     };
     vi.mocked(createMediaSource).mockReturnValue(mockMediaSource as unknown as MediaSource);
 
-    const { state, owners, cleanup } = setupSetupMediaSource({}, {});
+    const { state, context, cleanup } = setupSetupMediaSource({}, {});
 
-    owners.set({ ...owners.get(), mediaElement: {} as HTMLMediaElement });
-    state.set({
-      ...state.get(),
-      presentation: { url: 'https://example.com/video.m3u8' },
-    });
+    context.mediaElement.set({} as HTMLMediaElement);
+    state.presentation.set({ url: 'https://example.com/video.m3u8' });
 
     await vi.waitFor(() => {
-      expect(owners.get().mediaSource).toBe(mockMediaSource);
-      expect(state.get().mediaSourceReadyState).toBe('open');
+      expect(context.mediaSource.get()).toBe(mockMediaSource);
+      expect(state.mediaSourceReadyState.get()).toBe('open');
     });
 
     cleanup();
@@ -109,10 +115,7 @@ describe('setupMediaSource', () => {
 
     const { state, cleanup } = setupSetupMediaSource({}, {});
 
-    state.set({
-      ...state.get(),
-      presentation: { url: 'https://example.com/video.m3u8' },
-    });
+    state.presentation.set({ url: 'https://example.com/video.m3u8' });
 
     await new Promise((resolve) => setTimeout(resolve, 50));
 
@@ -124,9 +127,9 @@ describe('setupMediaSource', () => {
   it('does not create MediaSource if presentation.url is missing', async () => {
     const { createMediaSource } = await import('../../../../media/dom/mse/mediasource-setup');
 
-    const { owners, cleanup } = setupSetupMediaSource({}, {});
+    const { context, cleanup } = setupSetupMediaSource({}, {});
 
-    owners.set({ ...owners.get(), mediaElement: {} as HTMLMediaElement });
+    context.mediaElement.set({} as HTMLMediaElement);
 
     await new Promise((resolve) => setTimeout(resolve, 50));
 
@@ -138,22 +141,16 @@ describe('setupMediaSource', () => {
   it('does not create multiple MediaSources (deduplication)', async () => {
     const { createMediaSource } = await import('../../../../media/dom/mse/mediasource-setup');
 
-    const { state, owners, cleanup } = setupSetupMediaSource({}, {});
+    const { state, context, cleanup } = setupSetupMediaSource({}, {});
 
-    owners.set({ ...owners.get(), mediaElement: {} as HTMLMediaElement });
-    state.set({
-      ...state.get(),
-      presentation: { url: 'https://example.com/video.m3u8' },
-    });
+    context.mediaElement.set({} as HTMLMediaElement);
+    state.presentation.set({ url: 'https://example.com/video.m3u8' });
 
     await vi.waitFor(() => {
       expect(createMediaSource).toHaveBeenCalledTimes(1);
     });
 
-    state.set({
-      ...state.get(),
-      presentation: { url: 'https://example.com/video.m3u8' },
-    });
+    state.presentation.set({ url: 'https://example.com/video.m3u8' });
 
     await new Promise((resolve) => setTimeout(resolve, 50));
 
diff --git a/packages/spf/src/playback/behaviors/dom/tests/setup-sourcebuffer.test.ts b/packages/spf/src/playback/behaviors/dom/tests/setup-sourcebuffer.test.ts
index b80839b0..b986e224 100644
--- a/packages/spf/src/playback/behaviors/dom/tests/setup-sourcebuffer.test.ts
+++ b/packages/spf/src/playback/behaviors/dom/tests/setup-sourcebuffer.test.ts
@@ -1,9 +1,11 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ContextSignals, StateSignals } from '../../../../core/composition/create-composition';
 import { signal } from '../../../../core/signals/primitives';
-import type { AudioTrack, Presentation, VideoTrack } from '../../../../media/types';
+import type { AudioTrack, MaybeResolvedPresentation, Presentation, VideoTrack } from '../../../../media/types';
+import type { SourceBufferActor } from '../../../actors/dom/source-buffer';
 import {
   buildMimeCodec,
-  type SourceBufferOwners,
+  type SourceBufferContext,
   type SourceBufferState,
   setupSourceBuffers,
 } from '../setup-sourcebuffer';
@@ -135,11 +137,30 @@ describe('buildMimeCodec', () => {
   });
 });
 
-function setupSetupSourceBuffers(initialState: SourceBufferState = {}, initialOwners: SourceBufferOwners = {}) {
-  const state = signal<SourceBufferState>(initialState);
-  const owners = signal<SourceBufferOwners>(initialOwners);
-  const cleanup = setupSourceBuffers({ state, owners });
-  return { state, owners, cleanup };
+function makeState(initial: SourceBufferState = {}): StateSignals<SourceBufferState> {
+  return {
+    presentation: signal<MaybeResolvedPresentation | undefined>(initial.presentation),
+    selectedVideoTrackId: signal<string | undefined>(initial.selectedVideoTrackId),
+    selectedAudioTrackId: signal<string | undefined>(initial.selectedAudioTrackId),
+    selectedTextTrackId: signal<string | undefined>(initial.selectedTextTrackId),
+  };
+}
+
+function makeContext(initial: SourceBufferContext = {}): ContextSignals<SourceBufferContext> {
+  return {
+    mediaSource: signal<MediaSource | undefined>(initial.mediaSource),
+    videoBuffer: signal<SourceBuffer | undefined>(initial.videoBuffer),
+    audioBuffer: signal<SourceBuffer | undefined>(initial.audioBuffer),
+    videoBufferActor: signal<SourceBufferActor | undefined>(initial.videoBufferActor),
+    audioBufferActor: signal<SourceBufferActor | undefined>(initial.audioBufferActor),
+  };
+}
+
+function setupSetupSourceBuffers(initialState: SourceBufferState = {}, initialContext: SourceBufferContext = {}) {
+  const state = makeState(initialState);
+  const context = makeContext(initialContext);
+  const cleanup = setupSourceBuffers.setup({ state, context });
+  return { state, context, cleanup };
 }
 
 describe('setupSourceBuffers', () => {
@@ -151,20 +172,17 @@ describe('setupSourceBuffers', () => {
     const { createSourceBuffer } = await import('../../../../media/dom/mse/mediasource-setup');
 
     const videoTrack = createResolvedVideoTrack();
-    const { state, owners, cleanup } = setupSetupSourceBuffers();
+    const { state, context, cleanup } = setupSetupSourceBuffers();
 
     const mediaSource = {} as MediaSource;
-    owners.set({ ...owners.get(), mediaSource });
-    state.set({
-      ...state.get(),
-      presentation: createPresentationWithTracks({ video: videoTrack }),
-      selectedVideoTrackId: 'video-1',
-    });
+    context.mediaSource.set(mediaSource);
+    state.presentation.set(createPresentationWithTracks({ video: videoTrack }));
+    state.selectedVideoTrackId.set('video-1');
 
     await vi.waitFor(() => {
       expect(createSourceBuffer).toHaveBeenCalledWith(mediaSource, 'video/mp4; codecs="avc1.42E01E"');
-      expect(owners.get().videoBuffer).toBeDefined();
-      expect(owners.get().audioBuffer).toBeUndefined();
+      expect(context.videoBuffer.get()).toBeDefined();
+      expect(context.audioBuffer.get()).toBeUndefined();
     });
 
     cleanup();
@@ -174,20 +192,17 @@ describe('setupSourceBuffers', () => {
     const { createSourceBuffer } = await import('../../../../media/dom/mse/mediasource-setup');
 
     const audioTrack = createResolvedAudioTrack();
-    const { state, owners, cleanup } = setupSetupSourceBuffers();
+    const { state, context, cleanup } = setupSetupSourceBuffers();
 
     const mediaSource = {} as MediaSource;
-    owners.set({ ...owners.get(), mediaSource });
-    state.set({
-      ...state.get(),
-      presentation: createPresentationWithTracks({ audio: audioTrack }),
-      selectedAudioTrackId: 'audio-1',
-    });
+    context.mediaSource.set(mediaSource);
+    state.presentation.set(createPresentationWithTracks({ audio: audioTrack }));
+    state.selectedAudioTrackId.set('audio-1');
 
     await vi.waitFor(() => {
       expect(createSourceBuffer).toHaveBeenCalledWith(mediaSource, 'audio/mp4; codecs="mp4a.40.2"');
-      expect(owners.get().audioBuffer).toBeDefined();
-      expect(owners.get().videoBuffer).toBeUndefined();
+      expect(context.audioBuffer.get()).toBeDefined();
+      expect(context.videoBuffer.get()).toBeUndefined();
     });
 
     cleanup();
@@ -198,23 +213,20 @@ describe('setupSourceBuffers', () => {
 
     const videoTrack = createResolvedVideoTrack();
     const audioTrack = createResolvedAudioTrack();
-    const { state, owners, cleanup } = setupSetupSourceBuffers();
+    const { state, context, cleanup } = setupSetupSourceBuffers();
 
     const mediaSource = {} as MediaSource;
-    owners.set({ ...owners.get(), mediaSource });
-    state.set({
-      ...state.get(),
-      presentation: createPresentationWithTracks({ video: videoTrack, audio: audioTrack }),
-      selectedVideoTrackId: 'video-1',
-      selectedAudioTrackId: 'audio-1',
-    });
+    context.mediaSource.set(mediaSource);
+    state.presentation.set(createPresentationWithTracks({ video: videoTrack, audio: audioTrack }));
+    state.selectedVideoTrackId.set('video-1');
+    state.selectedAudioTrackId.set('audio-1');
 
     await vi.waitFor(() => {
       expect(createSourceBuffer).toHaveBeenCalledTimes(2);
       expect(createSourceBuffer).toHaveBeenCalledWith(mediaSource, 'video/mp4; codecs="avc1.42E01E"');
       expect(createSourceBuffer).toHaveBeenCalledWith(mediaSource, 'audio/mp4; codecs="mp4a.40.2"');
-      expect(owners.get().videoBuffer).toBeDefined();
-      expect(owners.get().audioBuffer).toBeDefined();
+      expect(context.videoBuffer.get()).toBeDefined();
+      expect(context.audioBuffer.get()).toBeDefined();
     });
 
     cleanup();
@@ -234,34 +246,30 @@ describe('setupSourceBuffers', () => {
       ...unresolvedAudioPartial
     } = unresolvedAudio;
 
-    const { state, owners, cleanup } = setupSetupSourceBuffers();
+    const { state, context, cleanup } = setupSetupSourceBuffers();
 
-    owners.set({ ...owners.get(), mediaSource: {} as MediaSource });
+    context.mediaSource.set({} as MediaSource);
     // Both track IDs selected, but audio track is not yet resolved
-    state.set({
-      ...state.get(),
-      presentation: createPresentationWithTracks({
+    state.presentation.set(
+      createPresentationWithTracks({
         video: videoTrack,
         audio: unresolvedAudioPartial as AudioTrack,
-      }),
-      selectedVideoTrackId: 'video-1',
-      selectedAudioTrackId: 'audio-1',
-    });
+      })
+    );
+    state.selectedVideoTrackId.set('video-1');
+    state.selectedAudioTrackId.set('audio-1');
 
     // Video is resolved but audio is not — neither SourceBuffer should be created yet
     await new Promise((resolve) => setTimeout(resolve, 50));
     expect(createSourceBuffer).not.toHaveBeenCalled();
 
     // Now audio resolves
-    state.set({
-      ...state.get(),
-      presentation: createPresentationWithTracks({ video: videoTrack, audio: unresolvedAudio }),
-    });
+    state.presentation.set(createPresentationWithTracks({ video: videoTrack, audio: unresolvedAudio }));
 
     await vi.waitFor(() => {
       expect(createSourceBuffer).toHaveBeenCalledTimes(2);
-      expect(owners.get().videoBuffer).toBeDefined();
-      expect(owners.get().audioBuffer).toBeDefined();
+      expect(context.videoBuffer.get()).toBeDefined();
+      expect(context.audioBuffer.get()).toBeDefined();
     });
 
     cleanup();
@@ -271,14 +279,11 @@ describe('setupSourceBuffers', () => {
     const { createSourceBuffer } = await import('../../../../media/dom/mse/mediasource-setup');
 
     const videoTrack: VideoTrack = { ...createResolvedVideoTrack(), codecs: [] };
-    const { state, owners, cleanup } = setupSetupSourceBuffers();
+    const { state, context, cleanup } = setupSetupSourceBuffers();
 
-    owners.set({ ...owners.get(), mediaSource: {} as MediaSource });
-    state.set({
-      ...state.get(),
-      presentation: createPresentationWithTracks({ video: videoTrack }),
-      selectedVideoTrackId: 'video-1',
-    });
+    context.mediaSource.set({} as MediaSource);
+    state.presentation.set(createPresentationWithTracks({ video: videoTrack }));
+    state.selectedVideoTrackId.set('video-1');
 
     await new Promise((resolve) => setTimeout(resolve, 50));
     expect(createSourceBuffer).not.toHaveBeenCalled();
@@ -290,18 +295,15 @@ describe('setupSourceBuffers', () => {
     const { createSourceBuffer } = await import('../../../../media/dom/mse/mediasource-setup');
 
     const videoTrack = createResolvedVideoTrack();
-    const { state, owners, cleanup } = setupSetupSourceBuffers();
+    const { state, context, cleanup } = setupSetupSourceBuffers();
 
-    owners.set({ ...owners.get(), mediaSource: {} as MediaSource });
-    state.set({
-      ...state.get(),
-      presentation: createPresentationWithTracks({ video: videoTrack }),
-      selectedVideoTrackId: 'video-1',
-    });
+    context.mediaSource.set({} as MediaSource);
+    state.presentation.set(createPresentationWithTracks({ video: videoTrack }));
+    state.selectedVideoTrackId.set('video-1');
 
     await vi.waitFor(() => expect(createSourceBuffer).toHaveBeenCalledTimes(1));
 
-    state.set({ ...state.get(), presentation: createPresentationWithTracks({ video: videoTrack }) });
+    state.presentation.set(createPresentationWithTracks({ video: videoTrack }));
     await new Promise((resolve) => setTimeout(resolve, 50));
     expect(createSourceBuffer).toHaveBeenCalledTimes(1);
 
@@ -314,11 +316,8 @@ describe('setupSourceBuffers', () => {
     const videoTrack = createResolvedVideoTrack();
     const { state, cleanup } = setupSetupSourceBuffers();
 
-    state.set({
-      ...state.get(),
-      presentation: createPresentationWithTracks({ video: videoTrack }),
-      selectedVideoTrackId: 'video-1',
-    });
+    state.presentation.set(createPresentationWithTracks({ video: videoTrack }));
+    state.selectedVideoTrackId.set('video-1');
 
     await new Promise((resolve) => setTimeout(resolve, 50));
     expect(createSourceBuffer).not.toHaveBeenCalled();
diff --git a/packages/spf/src/playback/behaviors/dom/tests/sync-text-tracks.test.ts b/packages/spf/src/playback/behaviors/dom/tests/sync-text-tracks.test.ts
index eaf485cd..6b1fc66e 100644
--- a/packages/spf/src/playback/behaviors/dom/tests/sync-text-tracks.test.ts
+++ b/packages/spf/src/playback/behaviors/dom/tests/sync-text-tracks.test.ts
@@ -1,6 +1,8 @@
 import { describe, expect, it } from 'vitest';
+import type { ContextSignals, StateSignals } from '../../../../core/composition/create-composition';
 import { signal } from '../../../../core/signals/primitives';
-import { syncTextTracks, type TextTrackSyncOwners, type TextTrackSyncState } from '../sync-text-tracks';
+import type { MaybeResolvedPresentation } from '../../../../media/types';
+import { syncTextTracks, type TextTrackSyncContext, type TextTrackSyncState } from '../sync-text-tracks';
 
 function makePresentation(tracks: Array<{ id: string; kind?: string; language?: string }>) {
   return {
@@ -31,11 +33,22 @@ function makePresentation(tracks: Array<{ id: string; kind?: string; language?:
   } as any;
 }
 
-function setup(initialState: TextTrackSyncState = {}, initialOwners: TextTrackSyncOwners = {}) {
-  const state = signal<TextTrackSyncState>(initialState);
-  const owners = signal<TextTrackSyncOwners>(initialOwners);
-  const reactor = syncTextTracks({ state, owners });
-  return { state, owners, reactor };
+function makeState(initial: TextTrackSyncState = {}): StateSignals<TextTrackSyncState> {
+  return {
+    presentation: signal<MaybeResolvedPresentation | undefined>(initial.presentation),
+    selectedTextTrackId: signal<string | undefined>(initial.selectedTextTrackId),
+  };
+}
+
+function makeContext(initial: TextTrackSyncContext = {}): ContextSignals<TextTrackSyncContext> {
+  return { mediaElement: signal<HTMLMediaElement | undefined>(initial.mediaElement) };
+}
+
+function setup(initialState: TextTrackSyncState = {}, initialContext: TextTrackSyncContext = {}) {
+  const state = makeState(initialState);
+  const context = makeContext(initialContext);
+  const reactor = syncTextTracks.setup({ state, context });
+  return { state, context, reactor };
 }
 
 describe('syncTextTracks', () => {
@@ -46,10 +59,10 @@ describe('syncTextTracks', () => {
       { id: 'track-es', language: 'es' },
     ]);
 
-    const { state, owners, reactor } = setup();
+    const { state, context, reactor } = setup();
 
-    owners.set({ ...owners.get(), mediaElement });
-    state.set({ ...state.get(), presentation });
+    context.mediaElement.set(mediaElement);
+    state.presentation.set(presentation);
     await new Promise((resolve) => setTimeout(resolve, 50));
 
     expect(mediaElement.children.length).toBe(2);
@@ -63,7 +76,7 @@ describe('syncTextTracks', () => {
     const presentation = makePresentation([{ id: 'track-en', language: 'en' }]);
     const { state, reactor } = setup();
 
-    state.set({ ...state.get(), presentation });
+    state.presentation.set(presentation);
     await new Promise((resolve) => setTimeout(resolve, 50));
 
     reactor.destroy();
@@ -71,17 +84,14 @@ describe('syncTextTracks', () => {
 
   it('does not create tracks when presentation has no text tracks', async () => {
     const mediaElement = document.createElement('video');
-    const { state, owners, reactor } = setup();
+    const { state, context, reactor } = setup();
 
-    owners.set({ ...owners.get(), mediaElement });
-    state.set({
-      ...state.get(),
-      presentation: {
-        id: 'pres-1',
-        url: 'http://example.com/playlist.m3u8',
-        selectionSets: [],
-      } as any,
-    });
+    context.mediaElement.set(mediaElement);
+    state.presentation.set({
+      id: 'pres-1',
+      url: 'http://example.com/playlist.m3u8',
+      selectionSets: [],
+    } as any);
     await new Promise((resolve) => setTimeout(resolve, 50));
 
     expect(mediaElement.children.length).toBe(0);
@@ -95,11 +105,11 @@ describe('syncTextTracks', () => {
       { id: 'track-es', language: 'es' },
     ]);
 
-    const { state, owners, reactor } = setup({ presentation });
-    owners.set({ ...owners.get(), mediaElement });
+    const { state, context, reactor } = setup({ presentation });
+    context.mediaElement.set(mediaElement);
     await new Promise((resolve) => setTimeout(resolve, 50));
 
-    state.set({ ...state.get(), selectedTextTrackId: 'track-en' });
+    state.selectedTextTrackId.set('track-en');
     await new Promise((resolve) => setTimeout(resolve, 50));
 
     const [enEl, esEl] = Array.from(mediaElement.children) as HTMLTrackElement[];
@@ -116,15 +126,15 @@ describe('syncTextTracks', () => {
       { id: 'track-es', language: 'es' },
     ]);
 
-    const { state, owners, reactor } = setup({ presentation, selectedTextTrackId: 'track-en' });
-    owners.set({ ...owners.get(), mediaElement });
+    const { state, context, reactor } = setup({ presentation, selectedTextTrackId: 'track-en' });
+    context.mediaElement.set(mediaElement);
     await new Promise((resolve) => setTimeout(resolve, 50));
 
     const [enEl, esEl] = Array.from(mediaElement.children) as HTMLTrackElement[];
     expect(enEl!.track.mode).toBe('showing');
     expect(esEl!.track.mode).toBe('disabled');
 
-    state.set({ ...state.get(), selectedTextTrackId: 'track-es' });
+    state.selectedTextTrackId.set('track-es');
     await new Promise((resolve) => setTimeout(resolve, 50));
 
     expect(enEl!.track.mode).toBe('disabled');
@@ -140,11 +150,11 @@ describe('syncTextTracks', () => {
       { id: 'track-es', language: 'es' },
     ]);
 
-    const { state, owners, reactor } = setup({ presentation, selectedTextTrackId: 'track-en' });
-    owners.set({ ...owners.get(), mediaElement });
+    const { state, context, reactor } = setup({ presentation, selectedTextTrackId: 'track-en' });
+    context.mediaElement.set(mediaElement);
     await new Promise((resolve) => setTimeout(resolve, 50));
 
-    state.set({ ...state.get(), selectedTextTrackId: undefined });
+    state.selectedTextTrackId.set(undefined);
     await new Promise((resolve) => setTimeout(resolve, 50));
 
     const [enEl, esEl] = Array.from(mediaElement.children) as HTMLTrackElement[];
@@ -166,8 +176,8 @@ describe('syncTextTracks', () => {
     mediaElement.appendChild(chaptersEl);
     chaptersEl.track.mode = 'hidden';
 
-    const { owners, reactor } = setup({ presentation, selectedTextTrackId: 'track-en' });
-    owners.set({ ...owners.get(), mediaElement });
+    const { context, reactor } = setup({ presentation, selectedTextTrackId: 'track-en' });
+    context.mediaElement.set(mediaElement);
     await new Promise((resolve) => setTimeout(resolve, 50));
 
     expect(chaptersEl.track.mode).toBe('hidden');
@@ -182,8 +192,8 @@ describe('syncTextTracks', () => {
       { id: 'track-es', language: 'es' },
     ]);
 
-    const { state, owners, reactor } = setup({ presentation });
-    owners.set({ ...owners.get(), mediaElement });
+    const { state, context, reactor } = setup({ presentation });
+    context.mediaElement.set(mediaElement);
     await new Promise((resolve) => setTimeout(resolve, 50));
 
     // Simulate external code (e.g. captions button) showing Spanish
@@ -195,7 +205,7 @@ describe('syncTextTracks', () => {
 
     await new Promise((resolve) => setTimeout(resolve, 50));
 
-    expect(state.get().selectedTextTrackId).toBe('track-es');
+    expect(state.selectedTextTrackId.get()).toBe('track-es');
 
     reactor.destroy();
   });
@@ -207,8 +217,8 @@ describe('syncTextTracks', () => {
       { id: 'track-es', language: 'es' },
     ]);
 
-    const { state, owners, reactor } = setup({ presentation, selectedTextTrackId: 'track-en' });
-    owners.set({ ...owners.get(), mediaElement });
+    const { state, context, reactor } = setup({ presentation, selectedTextTrackId: 'track-en' });
+    context.mediaElement.set(mediaElement);
     await new Promise((resolve) => setTimeout(resolve, 50));
 
     // Simulate external code disabling all tracks
@@ -220,7 +230,7 @@ describe('syncTextTracks', () => {
 
     await new Promise((resolve) => setTimeout(resolve, 50));
 
-    expect(state.get().selectedTextTrackId).toBeUndefined();
+    expect(state.selectedTextTrackId.get()).toBeUndefined();
 
     reactor.destroy();
   });
@@ -232,8 +242,8 @@ describe('syncTextTracks', () => {
       { id: 'track-es', language: 'es' },
     ]);
 
-    const { owners, reactor } = setup({ presentation });
-    owners.set({ ...owners.get(), mediaElement });
+    const { context, reactor } = setup({ presentation });
+    context.mediaElement.set(mediaElement);
     await new Promise((resolve) => setTimeout(resolve, 50));
 
     expect(mediaElement.children.length).toBe(2);
@@ -246,15 +256,15 @@ describe('syncTextTracks', () => {
     const mediaElement = document.createElement('video');
     const presentation = makePresentation([{ id: 'track-en', language: 'en' }]);
 
-    const { state, owners, reactor } = setup({ presentation });
-    owners.set({ ...owners.get(), mediaElement });
+    const { state, context, reactor } = setup({ presentation });
+    context.mediaElement.set(mediaElement);
     await new Promise((resolve) => setTimeout(resolve, 50));
 
     const firstChild = mediaElement.children[0];
     expect(mediaElement.children.length).toBe(1);
 
     // Trigger a re-run by changing selectedTextTrackId
-    state.set({ ...state.get(), selectedTextTrackId: 'track-en' });
+    state.selectedTextTrackId.set('track-en');
     await new Promise((resolve) => setTimeout(resolve, 50));
 
     expect(mediaElement.children.length).toBe(1);
diff --git a/packages/spf/src/playback/behaviors/dom/tests/track-current-time.test.ts b/packages/spf/src/playback/behaviors/dom/tests/track-current-time.test.ts
index 870e046d..05136eca 100644
--- a/packages/spf/src/playback/behaviors/dom/tests/track-current-time.test.ts
+++ b/packages/spf/src/playback/behaviors/dom/tests/track-current-time.test.ts
@@ -1,33 +1,46 @@
 import { describe, expect, it, vi } from 'vitest';
+import type { ContextSignals, StateSignals } from '../../../../core/composition/create-composition';
 import { signal } from '../../../../core/signals/primitives';
 import {
-  type CurrentTimeOwners,
+  type CurrentTimeContext,
   type CurrentTimeState,
   canTrackCurrentTime,
   trackCurrentTime,
 } from '../track-current-time';
 
-function setupTrackCurrentTime(initialState: CurrentTimeState, initialOwners: CurrentTimeOwners) {
-  const state = signal<CurrentTimeState>(initialState);
-  const owners = signal<CurrentTimeOwners>(initialOwners);
-  const cleanup = trackCurrentTime({ state, owners });
-  return { state, owners, cleanup };
+function makeState(initial: CurrentTimeState = {}): StateSignals<CurrentTimeState> {
+  return {
+    currentTime: signal<number | undefined>(initial.currentTime),
+  };
+}
+
+function makeContext(initial: CurrentTimeContext = {}): ContextSignals<CurrentTimeContext> {
+  return {
+    mediaElement: signal<HTMLMediaElement | undefined>(initial.mediaElement),
+  };
+}
+
+function setupTrackCurrentTime(initialState: CurrentTimeState, initialContext: CurrentTimeContext) {
+  const state = makeState(initialState);
+  const context = makeContext(initialContext);
+  const cleanup = trackCurrentTime.setup({ state, context });
+  return { state, context, cleanup };
 }
 
 describe('trackCurrentTime', () => {
   describe('canTrackCurrentTime', () => {
     it('returns false when no mediaElement', () => {
-      const owners: CurrentTimeOwners = {};
+      const context: CurrentTimeContext = {};
 
-      expect(canTrackCurrentTime(owners)).toBe(false);
+      expect(canTrackCurrentTime(context)).toBe(false);
     });
 
     it('returns true when mediaElement exists', () => {
-      const owners: CurrentTimeOwners = {
+      const context: CurrentTimeContext = {
         mediaElement: document.createElement('video'),
       };
 
-      expect(canTrackCurrentTime(owners)).toBe(true);
+      expect(canTrackCurrentTime(context)).toBe(true);
     });
   });
 
@@ -39,7 +52,7 @@ describe('trackCurrentTime', () => {
       const { state, cleanup } = setupTrackCurrentTime({}, { mediaElement });
 
       await vi.waitFor(() => {
-        expect(state.get().currentTime).toBe(5.5);
+        expect(state.currentTime.get()).toBe(5.5);
       });
 
       cleanup();
@@ -56,7 +69,7 @@ describe('trackCurrentTime', () => {
       mediaElement.dispatchEvent(new Event('timeupdate'));
 
       await vi.waitFor(() => {
-        expect(state.get().currentTime).toBe(10.0);
+        expect(state.currentTime.get()).toBe(10.0);
       });
 
       cleanup();
@@ -70,31 +83,34 @@ describe('trackCurrentTime', () => {
 
       (mediaElement as any).currentTime = 3.0;
       mediaElement.dispatchEvent(new Event('timeupdate'));
-      await vi.waitFor(() => expect(state.get().currentTime).toBe(3.0));
+      await vi.waitFor(() => expect(state.currentTime.get()).toBe(3.0));
 
       (mediaElement as any).currentTime = 7.5;
       mediaElement.dispatchEvent(new Event('timeupdate'));
-      await vi.waitFor(() => expect(state.get().currentTime).toBe(7.5));
+      await vi.waitFor(() => expect(state.currentTime.get()).toBe(7.5));
 
       cleanup();
     });
 
-    it('does not re-setup when owners updates but mediaElement is unchanged', async () => {
+    it('does not re-setup when context updates but mediaElement is unchanged', async () => {
       const mediaElement = document.createElement('video');
       Object.defineProperty(mediaElement, 'currentTime', { value: 5, writable: true });
 
       const addEventListenerSpy = vi.spyOn(mediaElement, 'addEventListener');
 
-      const state = signal<CurrentTimeState>({});
-      const owners = signal<CurrentTimeOwners & { videoBuffer?: unknown }>({ mediaElement });
-      const cleanup = trackCurrentTime({ state, owners });
+      const state = makeState();
+      const context: ContextSignals<CurrentTimeContext> & { videoBuffer: ReturnType<typeof signal<unknown>> } = {
+        mediaElement: signal<HTMLMediaElement | undefined>(mediaElement),
+        videoBuffer: signal<unknown>(undefined),
+      };
+      const cleanup = trackCurrentTime.setup({ state, context });
 
-      await vi.waitFor(() => expect(state.get().currentTime).toBe(5));
+      await vi.waitFor(() => expect(state.currentTime.get()).toBe(5));
 
       const callsBefore = addEventListenerSpy.mock.calls.length;
 
-      // Set an unrelated owner field — mediaElement is the same object
-      owners.set({ ...owners.get(), videoBuffer: {} });
+      // Set an unrelated context field — mediaElement is the same object
+      context.videoBuffer.set({});
       await new Promise((resolve) => setTimeout(resolve, 30));
 
       // No new listeners should have been added
@@ -108,23 +124,23 @@ describe('trackCurrentTime', () => {
 
       await new Promise((resolve) => setTimeout(resolve, 50));
 
-      expect(state.get().currentTime).toBeUndefined();
+      expect(state.currentTime.get()).toBeUndefined();
 
       cleanup();
     });
 
     it('starts tracking when mediaElement is added later', async () => {
-      const { state, owners, cleanup } = setupTrackCurrentTime({}, {});
+      const { state, context, cleanup } = setupTrackCurrentTime({}, {});
 
       await new Promise((resolve) => setTimeout(resolve, 20));
-      expect(state.get().currentTime).toBeUndefined();
+      expect(state.currentTime.get()).toBeUndefined();
 
       const mediaElement = document.createElement('video');
       Object.defineProperty(mediaElement, 'currentTime', { value: 2.0, writable: true });
-      owners.set({ ...owners.get(), mediaElement });
+      context.mediaElement.set(mediaElement);
 
       await vi.waitFor(() => {
-        expect(state.get().currentTime).toBe(2.0);
+        expect(state.currentTime.get()).toBe(2.0);
       });
 
       cleanup();
@@ -136,20 +152,20 @@ describe('trackCurrentTime', () => {
       const element2 = document.createElement('video');
       Object.defineProperty(element2, 'currentTime', { value: 20.0, writable: true });
 
-      const { state, owners, cleanup } = setupTrackCurrentTime({}, { mediaElement: element1 });
+      const { state, context, cleanup } = setupTrackCurrentTime({}, { mediaElement: element1 });
 
-      await vi.waitFor(() => expect(state.get().currentTime).toBe(1.0));
+      await vi.waitFor(() => expect(state.currentTime.get()).toBe(1.0));
 
       // Replace with new element
-      owners.set({ ...owners.get(), mediaElement: element2 });
-      await vi.waitFor(() => expect(state.get().currentTime).toBe(20.0));
+      context.mediaElement.set(element2);
+      await vi.waitFor(() => expect(state.currentTime.get()).toBe(20.0));
 
       // Old element timeupdate should no longer affect state
       (element1 as any).currentTime = 99.0;
       element1.dispatchEvent(new Event('timeupdate'));
       await new Promise((resolve) => setTimeout(resolve, 30));
 
-      expect(state.get().currentTime).toBe(20.0);
+      expect(state.currentTime.get()).toBe(20.0);
 
       cleanup();
     });
@@ -165,7 +181,7 @@ describe('trackCurrentTime', () => {
       mediaElement.dispatchEvent(new Event('seeking'));
 
       await vi.waitFor(() => {
-        expect(state.get().currentTime).toBe(60.0);
+        expect(state.currentTime.get()).toBe(60.0);
       });
 
       cleanup();
@@ -177,7 +193,7 @@ describe('trackCurrentTime', () => {
 
       const { state, cleanup } = setupTrackCurrentTime({}, { mediaElement });
 
-      await vi.waitFor(() => expect(state.get().currentTime).toBe(0));
+      await vi.waitFor(() => expect(state.currentTime.get()).toBe(0));
 
       cleanup();
 
@@ -186,7 +202,7 @@ describe('trackCurrentTime', () => {
       mediaElement.dispatchEvent(new Event('seeking'));
       await new Promise((resolve) => setTimeout(resolve, 30));
 
-      expect(state.get().currentTime).toBe(0);
+      expect(state.currentTime.get()).toBe(0);
     });
   });
 });
diff --git a/packages/spf/src/playback/behaviors/dom/tests/track-playback-initiated.test.ts b/packages/spf/src/playback/behaviors/dom/tests/track-playback-initiated.test.ts
index 408db8eb..0d913cf8 100644
--- a/packages/spf/src/playback/behaviors/dom/tests/track-playback-initiated.test.ts
+++ b/packages/spf/src/playback/behaviors/dom/tests/track-playback-initiated.test.ts
@@ -1,19 +1,31 @@
 import { describe, expect, it, vi } from 'vitest';
+import type { ContextSignals, StateSignals } from '../../../../core/composition/create-composition';
 import { signal } from '../../../../core/signals/primitives';
 import {
-  type PlaybackInitiatedOwners,
+  type PlaybackInitiatedContext,
   type PlaybackInitiatedState,
   trackPlaybackInitiated,
 } from '../track-playback-initiated';
 
+function makeState(initial: PlaybackInitiatedState = {}): StateSignals<PlaybackInitiatedState> {
+  return {
+    playbackInitiated: signal<boolean | undefined>(initial.playbackInitiated),
+    presentation: signal<PlaybackInitiatedState['presentation']>(initial.presentation),
+  };
+}
+
+function makeContext(initial: PlaybackInitiatedContext = {}): ContextSignals<PlaybackInitiatedContext> {
+  return { mediaElement: signal<HTMLMediaElement | undefined>(initial.mediaElement) };
+}
+
 function setupTrackPlaybackInitiated(
   initialState: PlaybackInitiatedState = {},
-  initialOwners: PlaybackInitiatedOwners = {}
+  initialContext: PlaybackInitiatedContext = {}
 ) {
-  const state = signal<PlaybackInitiatedState>(initialState);
-  const owners = signal<PlaybackInitiatedOwners>(initialOwners);
-  const reactor = trackPlaybackInitiated({ state, owners });
-  return { state, owners, reactor };
+  const state = makeState(initialState);
+  const context = makeContext(initialContext);
+  const reactor = trackPlaybackInitiated.setup({ state, context });
+  return { state, context, reactor };
 }
 
 /** Creates a video element with a controllable `paused` state. */
@@ -44,7 +56,7 @@ describe('trackPlaybackInitiated', () => {
     play();
     await new Promise((resolve) => setTimeout(resolve, 10));
 
-    expect(state.get().playbackInitiated).toBe(true);
+    expect(state.playbackInitiated.get()).toBe(true);
     reactor.destroy();
   });
 
@@ -57,7 +69,7 @@ describe('trackPlaybackInitiated', () => {
 
     await new Promise((resolve) => setTimeout(resolve, 10));
 
-    expect(state.get().playbackInitiated).toBe(true);
+    expect(state.playbackInitiated.get()).toBe(true);
     reactor.destroy();
   });
 
@@ -70,51 +82,51 @@ describe('trackPlaybackInitiated', () => {
 
     play();
     await new Promise((resolve) => setTimeout(resolve, 10));
-    expect(state.get().playbackInitiated).toBe(true);
+    expect(state.playbackInitiated.get()).toBe(true);
 
     // Simulate source change: element pauses as new media loads.
     pause();
-    state.set({ ...state.get(), presentation: { url: 'http://example.com/stream2.m3u8' } });
+    state.presentation.set({ url: 'http://example.com/stream2.m3u8' });
     await new Promise((resolve) => setTimeout(resolve, 20));
 
-    expect(state.get().playbackInitiated).toBe(false);
+    expect(state.playbackInitiated.get()).toBe(false);
     reactor.destroy();
   });
 
   it('resets playbackInitiated to false when the media element is swapped', async () => {
     const { el, play } = makeMediaElement();
-    const { state, owners, reactor } = setupTrackPlaybackInitiated(
+    const { state, context, reactor } = setupTrackPlaybackInitiated(
       { presentation: { url: 'http://example.com/stream.m3u8' } },
       { mediaElement: el }
     );
 
     play();
     await new Promise((resolve) => setTimeout(resolve, 10));
-    expect(state.get().playbackInitiated).toBe(true);
+    expect(state.playbackInitiated.get()).toBe(true);
 
     // New element starts paused.
-    owners.set({ ...owners.get(), mediaElement: document.createElement('video') });
+    context.mediaElement.set(document.createElement('video'));
     await new Promise((resolve) => setTimeout(resolve, 20));
 
-    expect(state.get().playbackInitiated).toBe(false);
+    expect(state.playbackInitiated.get()).toBe(false);
     reactor.destroy();
   });
 
   it('resets playbackInitiated to false when element is removed', async () => {
     const { el, play } = makeMediaElement();
-    const { state, owners, reactor } = setupTrackPlaybackInitiated(
+    const { state, context, reactor } = setupTrackPlaybackInitiated(
       { presentation: { url: 'http://example.com/stream.m3u8' } },
       { mediaElement: el }
     );
 
     play();
     await new Promise((resolve) => setTimeout(resolve, 10));
-    expect(state.get().playbackInitiated).toBe(true);
+    expect(state.playbackInitiated.get()).toBe(true);
 
-    owners.set({ ...owners.get(), mediaElement: undefined });
+    context.mediaElement.set(undefined);
     await new Promise((resolve) => setTimeout(resolve, 20));
 
-    expect(state.get().playbackInitiated).toBe(false);
+    expect(state.playbackInitiated.get()).toBe(false);
     reactor.destroy();
   });
 
@@ -127,12 +139,12 @@ describe('trackPlaybackInitiated', () => {
 
     play();
     await new Promise((resolve) => setTimeout(resolve, 10));
-    expect(state.get().playbackInitiated).toBe(true);
+    expect(state.playbackInitiated.get()).toBe(true);
 
-    state.set({ ...state.get(), presentation: undefined });
+    state.presentation.set(undefined);
     await new Promise((resolve) => setTimeout(resolve, 20));
 
-    expect(state.get().playbackInitiated).toBe(false);
+    expect(state.playbackInitiated.get()).toBe(false);
     reactor.destroy();
   });
 
@@ -145,28 +157,30 @@ describe('trackPlaybackInitiated', () => {
 
     play();
     await new Promise((resolve) => setTimeout(resolve, 10));
-    expect(state.get().playbackInitiated).toBe(true);
+    expect(state.playbackInitiated.get()).toBe(true);
 
-    state.set({ ...state.get(), presentation: { url: 'http://example.com/stream.m3u8' } });
+    state.presentation.set({ url: 'http://example.com/stream.m3u8' });
     await new Promise((resolve) => setTimeout(resolve, 20));
 
-    expect(state.get().playbackInitiated).toBe(true);
+    expect(state.playbackInitiated.get()).toBe(true);
     reactor.destroy();
   });
 
-  it('does not re-attach listener on unrelated owner changes', async () => {
+  it('does not re-attach listener on unrelated context changes', async () => {
     const { el } = makeMediaElement();
     const addEventListenerSpy = vi.spyOn(el, 'addEventListener');
 
-    const { owners, reactor } = setupTrackPlaybackInitiated(
-      { presentation: { url: 'http://example.com/stream.m3u8' } },
-      { mediaElement: el }
-    );
+    const state = makeState({ presentation: { url: 'http://example.com/stream.m3u8' } });
+    const context: ContextSignals<PlaybackInitiatedContext> & { videoBuffer: ReturnType<typeof signal<unknown>> } = {
+      mediaElement: signal<HTMLMediaElement | undefined>(el),
+      videoBuffer: signal<unknown>(undefined),
+    };
+    const reactor = trackPlaybackInitiated.setup({ state, context });
 
     await new Promise((resolve) => setTimeout(resolve, 10));
     const callsBefore = addEventListenerSpy.mock.calls.length;
 
-    owners.set({ ...owners.get(), videoBuffer: {} } as PlaybackInitiatedOwners & { videoBuffer?: unknown });
+    context.videoBuffer.set({});
     await new Promise((resolve) => setTimeout(resolve, 10));
 
     expect(addEventListenerSpy.mock.calls.length).toBe(callsBefore);
@@ -185,6 +199,6 @@ describe('trackPlaybackInitiated', () => {
     play();
     await new Promise((resolve) => setTimeout(resolve, 20));
 
-    expect(state.get().playbackInitiated).toBeFalsy();
+    expect(state.playbackInitiated.get()).toBeFalsy();
   });
 });
diff --git a/packages/spf/src/playback/behaviors/dom/tests/track-playback-rate.test.ts b/packages/spf/src/playback/behaviors/dom/tests/track-playback-rate.test.ts
index 23641bd3..c7ddb148 100644
--- a/packages/spf/src/playback/behaviors/dom/tests/track-playback-rate.test.ts
+++ b/packages/spf/src/playback/behaviors/dom/tests/track-playback-rate.test.ts
@@ -1,12 +1,21 @@
 import { describe, expect, it, vi } from 'vitest';
+import type { ContextSignals, StateSignals } from '../../../../core/composition/create-composition';
 import { signal } from '../../../../core/signals/primitives';
-import { type PlaybackRateOwners, type PlaybackRateState, trackPlaybackRate } from '../track-playback-rate';
+import { type PlaybackRateContext, type PlaybackRateState, trackPlaybackRate } from '../track-playback-rate';
 
-function setupTrackPlaybackRate(initialState: PlaybackRateState = {}, initialOwners: PlaybackRateOwners = {}) {
-  const state = signal<PlaybackRateState>(initialState);
-  const owners = signal<PlaybackRateOwners>(initialOwners);
-  const cleanup = trackPlaybackRate({ state, owners });
-  return { state, owners, cleanup };
+function makeState(initial: PlaybackRateState = {}): StateSignals<PlaybackRateState> {
+  return { playbackRate: signal<number | undefined>(initial.playbackRate) };
+}
+
+function makeContext(initial: PlaybackRateContext = {}): ContextSignals<PlaybackRateContext> {
+  return { mediaElement: signal<HTMLMediaElement | undefined>(initial.mediaElement) };
+}
+
+function setupTrackPlaybackRate(initialState: PlaybackRateState = {}, initialContext: PlaybackRateContext = {}) {
+  const state = makeState(initialState);
+  const context = makeContext(initialContext);
+  const cleanup = trackPlaybackRate.setup({ state, context });
+  return { state, context, cleanup };
 }
 
 describe('trackPlaybackRate', () => {
@@ -16,7 +25,7 @@ describe('trackPlaybackRate', () => {
     const { state, cleanup } = setupTrackPlaybackRate({}, { mediaElement });
 
     await vi.waitFor(() => {
-      expect(state.get().playbackRate).toBe(1);
+      expect(state.playbackRate.get()).toBe(1);
     });
 
     cleanup();
@@ -31,7 +40,7 @@ describe('trackPlaybackRate', () => {
     mediaElement.dispatchEvent(new Event('ratechange'));
 
     await vi.waitFor(() => {
-      expect(state.get().playbackRate).toBe(2);
+      expect(state.playbackRate.get()).toBe(2);
     });
 
     cleanup();
@@ -44,11 +53,11 @@ describe('trackPlaybackRate', () => {
 
     mediaElement.playbackRate = 0.5;
     mediaElement.dispatchEvent(new Event('ratechange'));
-    await vi.waitFor(() => expect(state.get().playbackRate).toBe(0.5));
+    await vi.waitFor(() => expect(state.playbackRate.get()).toBe(0.5));
 
     mediaElement.playbackRate = 1.5;
     mediaElement.dispatchEvent(new Event('ratechange'));
-    await vi.waitFor(() => expect(state.get().playbackRate).toBe(1.5));
+    await vi.waitFor(() => expect(state.playbackRate.get()).toBe(1.5));
 
     cleanup();
   });
@@ -58,44 +67,44 @@ describe('trackPlaybackRate', () => {
 
     await new Promise((resolve) => setTimeout(resolve, 50));
 
-    expect(state.get().playbackRate).toBeUndefined();
+    expect(state.playbackRate.get()).toBeUndefined();
 
     cleanup();
   });
 
-  it('continues tracking correctly after owners updates with unchanged mediaElement', async () => {
+  it('continues tracking correctly after context updates with unchanged mediaElement', async () => {
     const mediaElement = document.createElement('video');
     const ratechangeHandler = vi.fn();
     mediaElement.addEventListener('ratechange', ratechangeHandler);
 
-    const { state, owners, cleanup } = setupTrackPlaybackRate({}, { mediaElement });
+    const { state, context, cleanup } = setupTrackPlaybackRate({}, { mediaElement });
 
-    await vi.waitFor(() => expect(state.get().playbackRate).toBe(1));
+    await vi.waitFor(() => expect(state.playbackRate.get()).toBe(1));
 
-    // Spread owners without changing mediaElement — effect may re-setup but no duplicate handling
-    owners.set({ ...owners.get() });
+    // Re-set mediaElement to the same instance — effect may re-run but no duplicate handling
+    context.mediaElement.set(mediaElement);
     await new Promise((resolve) => setTimeout(resolve, 30));
 
     // ratechange should still update state exactly once
     mediaElement.playbackRate = 2;
     mediaElement.dispatchEvent(new Event('ratechange'));
 
-    await vi.waitFor(() => expect(state.get().playbackRate).toBe(2));
+    await vi.waitFor(() => expect(state.playbackRate.get()).toBe(2));
 
     cleanup();
   });
 
   it('starts tracking when mediaElement is added later', async () => {
-    const { state, owners, cleanup } = setupTrackPlaybackRate();
+    const { state, context, cleanup } = setupTrackPlaybackRate();
 
     await new Promise((resolve) => setTimeout(resolve, 20));
-    expect(state.get().playbackRate).toBeUndefined();
+    expect(state.playbackRate.get()).toBeUndefined();
 
     const mediaElement = document.createElement('video');
-    owners.set({ ...owners.get(), mediaElement });
+    context.mediaElement.set(mediaElement);
 
     await vi.waitFor(() => {
-      expect(state.get().playbackRate).toBe(1);
+      expect(state.playbackRate.get()).toBe(1);
     });
 
     cleanup();
@@ -105,19 +114,19 @@ describe('trackPlaybackRate', () => {
     const element1 = document.createElement('video');
     const element2 = document.createElement('video');
 
-    const { state, owners, cleanup } = setupTrackPlaybackRate({}, { mediaElement: element1 });
+    const { state, context, cleanup } = setupTrackPlaybackRate({}, { mediaElement: element1 });
 
-    await vi.waitFor(() => expect(state.get().playbackRate).toBe(1));
+    await vi.waitFor(() => expect(state.playbackRate.get()).toBe(1));
 
-    owners.set({ ...owners.get(), mediaElement: element2 });
-    await vi.waitFor(() => expect(state.get().playbackRate).toBe(1));
+    context.mediaElement.set(element2);
+    await vi.waitFor(() => expect(state.playbackRate.get()).toBe(1));
 
     // Old element ratechange should no longer affect state
     element1.playbackRate = 3;
     element1.dispatchEvent(new Event('ratechange'));
     await new Promise((resolve) => setTimeout(resolve, 30));
 
-    expect(state.get().playbackRate).toBe(1);
+    expect(state.playbackRate.get()).toBe(1);
 
     cleanup();
   });
@@ -127,7 +136,7 @@ describe('trackPlaybackRate', () => {
 
     const { state, cleanup } = setupTrackPlaybackRate({}, { mediaElement });
 
-    await vi.waitFor(() => expect(state.get().playbackRate).toBe(1));
+    await vi.waitFor(() => expect(state.playbackRate.get()).toBe(1));
 
     cleanup();
 
@@ -135,6 +144,6 @@ describe('trackPlaybackRate', () => {
     mediaElement.dispatchEvent(new Event('ratechange'));
     await new Promise((resolve) => setTimeout(resolve, 30));
 
-    expect(state.get().playbackRate).toBe(1);
+    expect(state.playbackRate.get()).toBe(1);
   });
 });
diff --git a/packages/spf/src/playback/behaviors/dom/tests/update-duration.test.ts b/packages/spf/src/playback/behaviors/dom/tests/update-duration.test.ts
index d37e8615..995c810e 100644
--- a/packages/spf/src/playback/behaviors/dom/tests/update-duration.test.ts
+++ b/packages/spf/src/playback/behaviors/dom/tests/update-duration.test.ts
@@ -1,22 +1,38 @@
 import { describe, expect, it, vi } from 'vitest';
+import type { ContextSignals, StateSignals } from '../../../../core/composition/create-composition';
 import { signal } from '../../../../core/signals/primitives';
-import type { Presentation } from '../../../../media/types';
+import type { MaybeResolvedPresentation, Presentation } from '../../../../media/types';
 import {
   canUpdateDuration,
-  type DurationUpdateOwners,
+  type DurationUpdateContext,
   type DurationUpdateState,
   shouldUpdateDuration,
   updateDuration,
 } from '../update-duration';
 
-function setupUpdateDuration(initialState: DurationUpdateState, initialOwners: DurationUpdateOwners) {
+function makeState(initial: DurationUpdateState = {}): StateSignals<DurationUpdateState> {
+  return {
+    presentation: signal<MaybeResolvedPresentation | undefined>(initial.presentation),
+    mediaSourceReadyState: signal<MediaSource['readyState'] | undefined>(initial.mediaSourceReadyState),
+  };
+}
+
+function makeContext(initial: DurationUpdateContext = {}): ContextSignals<DurationUpdateContext> {
+  return {
+    mediaSource: signal<MediaSource | undefined>(initial.mediaSource),
+    videoBuffer: signal<SourceBuffer | undefined>(initial.videoBuffer),
+    audioBuffer: signal<SourceBuffer | undefined>(initial.audioBuffer),
+  };
+}
+
+function setupUpdateDuration(initialState: DurationUpdateState, initialContext: DurationUpdateContext) {
   // Default mediaSourceReadyState to 'open' to mirror what setupMediaSource
   // would have written. Tests that exercise other readyState values pass it
   // explicitly.
-  const state = signal<DurationUpdateState>({ mediaSourceReadyState: 'open', ...initialState });
-  const owners = signal<DurationUpdateOwners>(initialOwners);
-  const cleanup = updateDuration({ state, owners });
-  return { state, owners, cleanup };
+  const state = makeState({ mediaSourceReadyState: 'open', ...initialState });
+  const context = makeContext(initialContext);
+  const cleanup = updateDuration.setup({ state, context });
+  return { state, context, cleanup };
 }
 
 function makeMediaSource(duration = NaN) {
@@ -51,40 +67,40 @@ describe('canUpdateDuration', () => {
     const state: DurationUpdateState = {
       presentation: { duration: 60 } as Presentation,
     };
-    const owners: DurationUpdateOwners = {
+    const context: DurationUpdateContext = {
       mediaSource: { readyState: 'open' } as MediaSource,
     };
 
-    expect(canUpdateDuration(state, owners)).toBe(true);
+    expect(canUpdateDuration(state, context)).toBe(true);
   });
 
   it('returns false when mediaSource is missing', () => {
     const state: DurationUpdateState = {
       presentation: { duration: 60 } as Presentation,
     };
-    const owners: DurationUpdateOwners = {};
+    const context: DurationUpdateContext = {};
 
-    expect(canUpdateDuration(state, owners)).toBe(false);
+    expect(canUpdateDuration(state, context)).toBe(false);
   });
 
   it('returns false when presentation is missing', () => {
     const state: DurationUpdateState = {};
-    const owners: DurationUpdateOwners = {
+    const context: DurationUpdateContext = {
       mediaSource: { readyState: 'open' } as MediaSource,
     };
 
-    expect(canUpdateDuration(state, owners)).toBe(false);
+    expect(canUpdateDuration(state, context)).toBe(false);
   });
 
   it('returns false when presentation.duration is undefined', () => {
     const state: DurationUpdateState = {
       presentation: {} as Presentation,
     };
-    const owners: DurationUpdateOwners = {
+    const context: DurationUpdateContext = {
       mediaSource: { readyState: 'open' } as MediaSource,
     };
 
-    expect(canUpdateDuration(state, owners)).toBe(false);
+    expect(canUpdateDuration(state, context)).toBe(false);
   });
 });
 
@@ -94,11 +110,11 @@ describe('shouldUpdateDuration', () => {
       presentation: { duration: 60 } as Presentation,
       mediaSourceReadyState: 'open',
     };
-    const owners: DurationUpdateOwners = {
+    const context: DurationUpdateContext = {
       mediaSource: { readyState: 'open', duration: NaN } as MediaSource,
     };
 
-    expect(shouldUpdateDuration(state, owners)).toBe(true);
+    expect(shouldUpdateDuration(state, context)).toBe(true);
   });
 
   it('returns false when MediaSource is not open', () => {
@@ -106,55 +122,55 @@ describe('shouldUpdateDuration', () => {
       presentation: { duration: 60 } as Presentation,
       mediaSourceReadyState: 'closed',
     };
-    const owners: DurationUpdateOwners = {
+    const context: DurationUpdateContext = {
       mediaSource: { readyState: 'closed', duration: 0 } as MediaSource,
     };
 
-    expect(shouldUpdateDuration(state, owners)).toBe(false);
+    expect(shouldUpdateDuration(state, context)).toBe(false);
   });
 
   it('returns false when duration is NaN', () => {
     const state: DurationUpdateState = {
       presentation: { duration: NaN } as Presentation,
     };
-    const owners: DurationUpdateOwners = {
+    const context: DurationUpdateContext = {
       mediaSource: { readyState: 'open', duration: 0 } as MediaSource,
     };
 
-    expect(shouldUpdateDuration(state, owners)).toBe(false);
+    expect(shouldUpdateDuration(state, context)).toBe(false);
   });
 
   it('returns false when duration is Infinity', () => {
     const state: DurationUpdateState = {
       presentation: { duration: Infinity } as Presentation,
     };
-    const owners: DurationUpdateOwners = {
+    const context: DurationUpdateContext = {
       mediaSource: { readyState: 'open', duration: 0 } as MediaSource,
     };
 
-    expect(shouldUpdateDuration(state, owners)).toBe(false);
+    expect(shouldUpdateDuration(state, context)).toBe(false);
   });
 
   it('returns false when duration is 0', () => {
     const state: DurationUpdateState = {
       presentation: { duration: 0 } as Presentation,
     };
-    const owners: DurationUpdateOwners = {
+    const context: DurationUpdateContext = {
       mediaSource: { readyState: 'open', duration: 0 } as MediaSource,
     };
 
-    expect(shouldUpdateDuration(state, owners)).toBe(false);
+    expect(shouldUpdateDuration(state, context)).toBe(false);
   });
 
   it('returns false when duration is negative', () => {
     const state: DurationUpdateState = {
       presentation: { duration: -10 } as Presentation,
     };
-    const owners: DurationUpdateOwners = {
+    const context: DurationUpdateContext = {
       mediaSource: { readyState: 'open', duration: 0 } as MediaSource,
     };
 
-    expect(shouldUpdateDuration(state, owners)).toBe(false);
+    expect(shouldUpdateDuration(state, context)).toBe(false);
   });
 
   it('returns false when MediaSource duration is already set (non-NaN) even if different from presentation', () => {
@@ -164,28 +180,28 @@ describe('shouldUpdateDuration', () => {
     const state: DurationUpdateState = {
       presentation: { duration: 25.317 } as Presentation,
     };
-    const owners: DurationUpdateOwners = {
+    const context: DurationUpdateContext = {
       mediaSource: { readyState: 'open', duration: 25.28 } as MediaSource,
     };
 
-    expect(shouldUpdateDuration(state, owners)).toBe(false);
+    expect(shouldUpdateDuration(state, context)).toBe(false);
   });
 
   it('returns false when duration matches current MediaSource.duration', () => {
     const state: DurationUpdateState = {
       presentation: { duration: 60 } as Presentation,
     };
-    const owners: DurationUpdateOwners = {
+    const context: DurationUpdateContext = {
       mediaSource: { readyState: 'open', duration: 60 } as MediaSource,
     };
 
-    expect(shouldUpdateDuration(state, owners)).toBe(false);
+    expect(shouldUpdateDuration(state, context)).toBe(false);
   });
 });
 
 describe('updateDuration', () => {
   it('sets MediaSource.duration when conditions met', async () => {
-    const { state, owners, cleanup } = setupUpdateDuration({}, {});
+    const { state, context, cleanup } = setupUpdateDuration({}, {});
 
     // NaN is the real initial state of a freshly opened MediaSource
     const mockMediaSource = Object.create(MediaSource.prototype, {
@@ -193,11 +209,8 @@ describe('updateDuration', () => {
       duration: { value: NaN, writable: true },
     });
 
-    owners.set({ ...owners.get(), mediaSource: mockMediaSource });
-    state.set({
-      ...state.get(),
-      presentation: { duration: 60 } as Presentation,
-    });
+    context.mediaSource.set(mockMediaSource);
+    state.presentation.set({ duration: 60 } as Presentation);
 
     await vi.waitFor(() => {
       expect(mockMediaSource.duration).toBe(60);
@@ -209,22 +222,22 @@ describe('updateDuration', () => {
   it('does not update again after initial set even if presentation duration changes', async () => {
     // Once the MediaSource duration is set (no longer NaN), subsequent presentation
     // duration changes must not trigger another set — doing so races with appendBuffer().
-    const { state, owners, cleanup } = setupUpdateDuration({}, {});
+    const { state, context, cleanup } = setupUpdateDuration({}, {});
 
     const mockMediaSource = Object.create(MediaSource.prototype, {
       readyState: { value: 'open', writable: true },
       duration: { value: NaN, writable: true },
     });
 
-    owners.set({ ...owners.get(), mediaSource: mockMediaSource });
-    state.set({ ...state.get(), presentation: { duration: 60 } as Presentation });
+    context.mediaSource.set(mockMediaSource);
+    state.presentation.set({ duration: 60 } as Presentation);
 
     await vi.waitFor(() => {
       expect(mockMediaSource.duration).toBe(60);
     });
 
     // Simulate presentation.duration changing (e.g. recalculated) — must not re-fire
-    state.set({ ...state.get(), presentation: { duration: 120 } as Presentation });
+    state.presentation.set({ duration: 120 } as Presentation);
 
     await new Promise((resolve) => setTimeout(resolve, 50));
     expect(mockMediaSource.duration).toBe(60); // unchanged
@@ -233,7 +246,7 @@ describe('updateDuration', () => {
   });
 
   it('does not update when MediaSource is not open', () => {
-    const { state, owners, cleanup } = setupUpdateDuration({}, {});
+    const { state, context, cleanup } = setupUpdateDuration({}, {});
 
     // Create mock with writable duration property
     const mockMediaSource = Object.create(MediaSource.prototype, {
@@ -241,11 +254,8 @@ describe('updateDuration', () => {
       duration: { value: 0, writable: true },
     });
 
-    owners.set({ ...owners.get(), mediaSource: mockMediaSource });
-    state.set({
-      ...state.get(),
-      presentation: { duration: 60 } as Presentation,
-    });
+    context.mediaSource.set(mockMediaSource);
+    state.presentation.set({ duration: 60 } as Presentation);
 
     expect(mockMediaSource.duration).toBe(0); // unchanged — readyState guard fired first
 
@@ -253,7 +263,7 @@ describe('updateDuration', () => {
   });
 
   it('does not update when duration is invalid', () => {
-    const { state, owners, cleanup } = setupUpdateDuration({}, {});
+    const { state, context, cleanup } = setupUpdateDuration({}, {});
 
     // Create mock with writable duration property
     const mockMediaSource = Object.create(MediaSource.prototype, {
@@ -261,34 +271,25 @@ describe('updateDuration', () => {
       duration: { value: 0, writable: true },
     });
 
-    owners.set({ ...owners.get(), mediaSource: mockMediaSource });
+    context.mediaSource.set(mockMediaSource);
 
     // Try NaN
-    state.set({
-      ...state.get(),
-      presentation: { duration: NaN } as Presentation,
-    });
+    state.presentation.set({ duration: NaN } as Presentation);
     expect(mockMediaSource.duration).toBe(0); // presentation validation guard fired
 
     // Try Infinity
-    state.set({
-      ...state.get(),
-      presentation: { duration: Infinity } as Presentation,
-    });
+    state.presentation.set({ duration: Infinity } as Presentation);
     expect(mockMediaSource.duration).toBe(0);
 
     // Try negative
-    state.set({
-      ...state.get(),
-      presentation: { duration: -10 } as Presentation,
-    });
+    state.presentation.set({ duration: -10 } as Presentation);
     expect(mockMediaSource.duration).toBe(0);
 
     cleanup();
   });
 
   it('extends duration to match buffered range if needed', async () => {
-    const { state, owners, cleanup } = setupUpdateDuration({}, {});
+    const { state, context, cleanup } = setupUpdateDuration({}, {});
 
     // Create mock SourceBuffer with buffered data that exceeds presentation duration
     const mockBuffered = {
@@ -307,17 +308,11 @@ describe('updateDuration', () => {
       duration: { value: NaN, writable: true },
     });
 
-    owners.set({
-      ...owners.get(),
-      mediaSource: mockMediaSource,
-      videoSourceBuffer: mockVideoBuffer,
-    });
+    context.mediaSource.set(mockMediaSource);
+    context.videoBuffer.set(mockVideoBuffer);
 
     // Presentation duration is 60, but buffered is 60.5
-    state.set({
-      ...state.get(),
-      presentation: { duration: 60 } as Presentation,
-    });
+    state.presentation.set({ duration: 60 } as Presentation);
 
     await vi.waitFor(() => {
       // Duration should be extended to match buffered range
@@ -327,14 +322,15 @@ describe('updateDuration', () => {
     cleanup();
   });
 
-  it('does not throw when videoSourceBuffer is updating at moment of set', async () => {
-    const { state, owners, cleanup } = setupUpdateDuration({}, {});
+  it('does not throw when videoBuffer is updating at moment of set', async () => {
+    const { state, context, cleanup } = setupUpdateDuration({}, {});
 
     const mockMediaSource = makeMediaSource();
     const { buffer: mockVideoBuffer, finishUpdating } = makeUpdatingSourceBuffer();
 
-    owners.set({ ...owners.get(), mediaSource: mockMediaSource, videoSourceBuffer: mockVideoBuffer });
-    state.set({ ...state.get(), presentation: { duration: 60 } as Presentation });
+    context.mediaSource.set(mockMediaSource);
+    context.videoBuffer.set(mockVideoBuffer);
+    state.presentation.set({ duration: 60 } as Presentation);
 
     // Buffer finishes immediately after state change — must not throw
     finishUpdating();
@@ -346,14 +342,15 @@ describe('updateDuration', () => {
     cleanup();
   });
 
-  it('defers duration set until videoSourceBuffer finishes updating', async () => {
-    const { state, owners, cleanup } = setupUpdateDuration({}, {});
+  it('defers duration set until videoBuffer finishes updating', async () => {
+    const { state, context, cleanup } = setupUpdateDuration({}, {});
 
     const mockMediaSource = makeMediaSource();
     const { buffer: mockVideoBuffer, finishUpdating } = makeUpdatingSourceBuffer();
 
-    owners.set({ ...owners.get(), mediaSource: mockMediaSource, videoSourceBuffer: mockVideoBuffer });
-    state.set({ ...state.get(), presentation: { duration: 60 } as Presentation });
+    context.mediaSource.set(mockMediaSource);
+    context.videoBuffer.set(mockVideoBuffer);
+    state.presentation.set({ duration: 60 } as Presentation);
 
     // Duration must not be set while buffer is still updating
     await new Promise((resolve) => setTimeout(resolve, 20));
@@ -370,19 +367,16 @@ describe('updateDuration', () => {
   });
 
   it('defers until both video and audio SourceBuffers finish updating', async () => {
-    const { state, owners, cleanup } = setupUpdateDuration({}, {});
+    const { state, context, cleanup } = setupUpdateDuration({}, {});
 
     const mockMediaSource = makeMediaSource();
     const { buffer: mockVideoBuffer, finishUpdating: finishVideo } = makeUpdatingSourceBuffer();
     const { buffer: mockAudioBuffer, finishUpdating: finishAudio } = makeUpdatingSourceBuffer();
 
-    owners.set({
-      ...owners.get(),
-      mediaSource: mockMediaSource,
-      videoSourceBuffer: mockVideoBuffer,
-      audioSourceBuffer: mockAudioBuffer,
-    });
-    state.set({ ...state.get(), presentation: { duration: 60 } as Presentation });
+    context.mediaSource.set(mockMediaSource);
+    context.videoBuffer.set(mockVideoBuffer);
+    context.audioBuffer.set(mockAudioBuffer);
+    state.presentation.set({ duration: 60 } as Presentation);
 
     // Neither buffer done — duration must not be set
     await new Promise((resolve) => setTimeout(resolve, 20));
@@ -404,7 +398,7 @@ describe('updateDuration', () => {
   });
 
   it('does not throw when readyState transitions to ended during the async wait', async () => {
-    const { state, owners, cleanup } = setupUpdateDuration({}, {});
+    const { state, context, cleanup } = setupUpdateDuration({}, {});
 
     const mockMediaSource = Object.create(MediaSource.prototype, {
       readyState: { value: 'open', writable: true },
@@ -413,8 +407,9 @@ describe('updateDuration', () => {
 
     // Attach an updating SourceBuffer so the task must await updateend
     const { buffer: mockVideoBuffer, finishUpdating } = makeUpdatingSourceBuffer();
-    owners.set({ ...owners.get(), mediaSource: mockMediaSource, videoSourceBuffer: mockVideoBuffer });
-    state.set({ ...state.get(), presentation: { duration: 60 } as Presentation });
+    context.mediaSource.set(mockMediaSource);
+    context.videoBuffer.set(mockVideoBuffer);
+    state.presentation.set({ duration: 60 } as Presentation);
 
     // Simulate endOfStream() being called concurrently while the task is waiting —
     // transitions readyState to 'ended' before the task can set duration
@@ -429,7 +424,7 @@ describe('updateDuration', () => {
   });
 
   it('sets duration once on initial NaN state then ignores further state changes', async () => {
-    const { state, owners, cleanup } = setupUpdateDuration({}, {});
+    const { state, context, cleanup } = setupUpdateDuration({}, {});
 
     const mockMediaSource = Object.create(MediaSource.prototype, {
       readyState: { value: 'open', writable: true },
@@ -437,18 +432,18 @@ describe('updateDuration', () => {
     });
 
     // MediaSource attached but no presentation yet — nothing happens
-    owners.set({ ...owners.get(), mediaSource: mockMediaSource });
+    context.mediaSource.set(mockMediaSource);
     expect(mockMediaSource.duration).toBeNaN();
 
     // Presentation with duration arrives — initial set fires
-    state.set({ ...state.get(), presentation: { duration: 60 } as Presentation });
+    state.presentation.set({ duration: 60 } as Presentation);
 
     await vi.waitFor(() => {
       expect(mockMediaSource.duration).toBe(60);
     });
 
     // Further state changes must not trigger another set
-    state.set({ ...state.get(), presentation: { duration: 90 } as Presentation });
+    state.presentation.set({ duration: 90 } as Presentation);
     await new Promise((resolve) => setTimeout(resolve, 50));
     expect(mockMediaSource.duration).toBe(60); // unchanged
 
diff --git a/packages/spf/src/playback/behaviors/dom/track-current-time.ts b/packages/spf/src/playback/behaviors/dom/track-current-time.ts
index 5fee712f..1ec7338c 100644
--- a/packages/spf/src/playback/behaviors/dom/track-current-time.ts
+++ b/packages/spf/src/playback/behaviors/dom/track-current-time.ts
@@ -1,6 +1,7 @@
 import { listen } from '@videojs/utils/dom';
+import { defineBehavior } from '../../../core/composition/create-composition';
 import { effect } from '../../../core/signals/effect';
-import { type Signal, update } from '../../../core/signals/primitives';
+import type { ReadonlySignal, Signal } from '../../../core/signals/primitives';
 
 /**
  * State shape for current time tracking.
@@ -10,9 +11,9 @@ export interface CurrentTimeState {
 }
 
 /**
- * Owners shape for current time tracking.
+ * Context shape for current time tracking.
  */
-export interface CurrentTimeOwners {
+export interface CurrentTimeContext {
   mediaElement?: HTMLMediaElement | undefined;
 }
 
@@ -20,10 +21,10 @@ export interface CurrentTimeOwners {
  * Check if we can track current time.
  *
  * Requires:
- * - mediaElement exists in owners
+ * - mediaElement exists in context
  */
-export function canTrackCurrentTime(owners: CurrentTimeOwners): boolean {
-  return !!owners.mediaElement;
+export function canTrackCurrentTime(context: CurrentTimeContext): boolean {
+  return !!context.mediaElement;
 }
 
 /**
@@ -39,20 +40,20 @@ export function canTrackCurrentTime(owners: CurrentTimeOwners): boolean {
  * Also syncs immediately when a media element becomes available.
  *
  * @example
- * const cleanup = trackCurrentTime({ state, owners });
+ * const cleanup = trackCurrentTime.setup({ state, context });
  */
-export function trackCurrentTime<S extends CurrentTimeState, O extends CurrentTimeOwners>({
+function trackCurrentTimeSetup({
   state,
-  owners,
+  context,
 }: {
-  state: Signal<S>;
-  owners: Signal<O>;
+  state: { currentTime: Signal<CurrentTimeState['currentTime']> };
+  context: { mediaElement: ReadonlySignal<CurrentTimeContext['mediaElement']> };
 }): () => void {
   let lastMediaElement: HTMLMediaElement | undefined;
   let removeListeners: (() => void) | null = null;
 
   const cleanupEffect = effect(() => {
-    const { mediaElement } = owners.get();
+    const mediaElement = context.mediaElement.get();
 
     if (mediaElement === lastMediaElement) return;
 
@@ -63,8 +64,7 @@ export function trackCurrentTime<S extends CurrentTimeState, O extends CurrentTi
     if (!mediaElement) return;
 
     const sync = () => {
-      const patch: Partial<CurrentTimeState> = { currentTime: mediaElement.currentTime };
-      update(state, patch);
+      state.currentTime.set(mediaElement.currentTime);
     };
 
     // Sync immediately so consumers don't wait for the first event
@@ -82,3 +82,9 @@ export function trackCurrentTime<S extends CurrentTimeState, O extends CurrentTi
     cleanupEffect();
   };
 }
+
+export const trackCurrentTime = defineBehavior({
+  stateKeys: ['currentTime'],
+  contextKeys: ['mediaElement'],
+  setup: trackCurrentTimeSetup,
+});
diff --git a/packages/spf/src/playback/behaviors/dom/track-playback-initiated.ts b/packages/spf/src/playback/behaviors/dom/track-playback-initiated.ts
index e468dc13..73015f33 100644
--- a/packages/spf/src/playback/behaviors/dom/track-playback-initiated.ts
+++ b/packages/spf/src/playback/behaviors/dom/track-playback-initiated.ts
@@ -1,7 +1,8 @@
 import { listen } from '@videojs/utils/dom';
+import { defineBehavior } from '../../../core/composition/create-composition';
 import type { Reactor } from '../../../core/reactors/create-machine-reactor';
 import { createMachineReactor } from '../../../core/reactors/create-machine-reactor';
-import { computed, type Signal, update } from '../../../core/signals/primitives';
+import { computed, type ReadonlySignal, type Signal, snapshot } from '../../../core/signals/primitives';
 import type { MaybeResolvedPresentation } from '../../../media/types';
 
 /**
@@ -15,9 +16,9 @@ export interface PlaybackInitiatedState {
 }
 
 /**
- * Owners shape for playback initiation tracking.
+ * Context shape for playback initiation tracking.
  */
-export interface PlaybackInitiatedOwners {
+export interface PlaybackInitiatedContext {
   mediaElement?: HTMLMediaElement | undefined;
 }
 
@@ -37,9 +38,9 @@ export interface PlaybackInitiatedOwners {
  */
 function deriveState(
   state: PlaybackInitiatedState,
-  owners: PlaybackInitiatedOwners
+  context: PlaybackInitiatedContext
 ): 'preconditions-unmet' | 'monitoring' | 'playback-initiated' {
-  if (!owners.mediaElement || !state.presentation?.url) return 'preconditions-unmet';
+  if (!context.mediaElement || !state.presentation?.url) return 'preconditions-unmet';
   if (state.playbackInitiated) return 'playback-initiated';
   return 'monitoring';
 }
@@ -55,20 +56,23 @@ function deriveState(
  *   `state.playbackInitiated` to `false` on any change or lost preconditions.
  *
  * @example
- * const reactor = trackPlaybackInitiated({ state, owners });
+ * const reactor = trackPlaybackInitiated.setup({ state, context });
  * // later:
  * reactor.destroy();
  */
-export function trackPlaybackInitiated<S extends PlaybackInitiatedState, O extends PlaybackInitiatedOwners>({
+function trackPlaybackInitiatedSetup({
   state,
-  owners,
+  context,
 }: {
-  state: Signal<S>;
-  owners: Signal<O>;
+  state: {
+    playbackInitiated: Signal<PlaybackInitiatedState['playbackInitiated']>;
+    presentation: ReadonlySignal<PlaybackInitiatedState['presentation']>;
+  };
+  context: { mediaElement: ReadonlySignal<PlaybackInitiatedContext['mediaElement']> };
 }): Reactor<'preconditions-unmet' | 'monitoring' | 'playback-initiated' | 'destroying' | 'destroyed'> {
-  const derivedStateSignal = computed(() => deriveState(state.get(), owners.get()));
-  const mediaElementSignal = computed(() => owners.get().mediaElement);
-  const urlSignal = computed(() => state.get().presentation?.url);
+  const derivedStateSignal = computed(() => deriveState(snapshot(state), snapshot(context)));
+  const mediaElementSignal = computed(() => context.mediaElement.get());
+  const urlSignal = computed(() => state.presentation.get()?.url);
 
   return createMachineReactor<'preconditions-unmet' | 'monitoring' | 'playback-initiated'>({
     initial: 'preconditions-unmet',
@@ -81,9 +85,9 @@ export function trackPlaybackInitiated<S extends PlaybackInitiatedState, O exten
         // The fn body is automatically untracked — el is read at entry time only.
         entry: () => {
           const el = mediaElementSignal.get()!;
-          update(state, { playbackInitiated: !el.paused } as Partial<S>);
+          state.playbackInitiated.set(!el.paused);
           return listen(el, 'play', () => {
-            update(state, { playbackInitiated: !el.paused } as Partial<S>);
+            state.playbackInitiated.set(!el.paused);
           });
         },
       },
@@ -101,9 +105,15 @@ export function trackPlaybackInitiated<S extends PlaybackInitiatedState, O exten
         effects: () => {
           mediaElementSignal.get(); // tracked — re-run on element change
           urlSignal.get(); // tracked — re-run on URL change
-          return () => update(state, { playbackInitiated: false } as Partial<S>);
+          return () => state.playbackInitiated.set(false);
         },
       },
     },
   });
 }
+
+export const trackPlaybackInitiated = defineBehavior({
+  stateKeys: ['playbackInitiated', 'presentation'],
+  contextKeys: ['mediaElement'],
+  setup: trackPlaybackInitiatedSetup,
+});
diff --git a/packages/spf/src/playback/behaviors/dom/track-playback-rate.ts b/packages/spf/src/playback/behaviors/dom/track-playback-rate.ts
index 94c5fc4d..193df05c 100644
--- a/packages/spf/src/playback/behaviors/dom/track-playback-rate.ts
+++ b/packages/spf/src/playback/behaviors/dom/track-playback-rate.ts
@@ -1,6 +1,7 @@
 import { listen } from '@videojs/utils/dom';
+import { defineBehavior } from '../../../core/composition/create-composition';
 import { effect } from '../../../core/signals/effect';
-import { computed, type Signal, update } from '../../../core/signals/primitives';
+import { computed, type ReadonlySignal, type Signal } from '../../../core/signals/primitives';
 
 /**
  * State shape for playback rate tracking.
@@ -10,9 +11,9 @@ export interface PlaybackRateState {
 }
 
 /**
- * Owners shape for playback rate tracking.
+ * Context shape for playback rate tracking.
  */
-export interface PlaybackRateOwners {
+export interface PlaybackRateContext {
   mediaElement?: HTMLMediaElement | undefined;
 }
 
@@ -23,26 +24,26 @@ export interface PlaybackRateOwners {
  * event. Also syncs immediately when a media element becomes available.
  *
  * @example
- * const cleanup = trackPlaybackRate({ state, owners });
+ * const cleanup = trackPlaybackRate.setup({ state, context });
  */
-export function trackPlaybackRate<O extends PlaybackRateOwners>({
+function trackPlaybackRateSetup({
   state,
-  owners,
+  context,
 }: {
-  state: Signal<PlaybackRateState>;
-  owners: Signal<O>;
+  state: { playbackRate: Signal<PlaybackRateState['playbackRate']> };
+  context: { mediaElement: ReadonlySignal<PlaybackRateContext['mediaElement']> };
 }): () => void {
-  const mediaElementSignal = computed(() => owners.get().mediaElement);
+  const mediaElementSignal = computed(() => context.mediaElement.get());
   const canTrackPlaybackRate = computed(() => !!mediaElementSignal.get());
 
   const cleanupEffect = effect(() => {
     if (!canTrackPlaybackRate.get()) return;
     const mediaElement = mediaElementSignal.get() as HTMLMediaElement;
 
-    update(state, { playbackRate: mediaElement.playbackRate });
+    state.playbackRate.set(mediaElement.playbackRate);
 
     return listen(mediaElement, 'ratechange', () => {
-      update(state, { playbackRate: mediaElement.playbackRate });
+      state.playbackRate.set(mediaElement.playbackRate);
     });
   });
 
@@ -50,3 +51,9 @@ export function trackPlaybackRate<O extends PlaybackRateOwners>({
     cleanupEffect();
   };
 }
+
+export const trackPlaybackRate = defineBehavior({
+  stateKeys: ['playbackRate'],
+  contextKeys: ['mediaElement'],
+  setup: trackPlaybackRateSetup,
+});
diff --git a/packages/spf/src/playback/behaviors/dom/update-duration.ts b/packages/spf/src/playback/behaviors/dom/update-duration.ts
index c3576d30..23da7d0c 100644
--- a/packages/spf/src/playback/behaviors/dom/update-duration.ts
+++ b/packages/spf/src/playback/behaviors/dom/update-duration.ts
@@ -1,5 +1,6 @@
+import { defineBehavior } from '../../../core/composition/create-composition';
 import { effect } from '../../../core/signals/effect';
-import type { Signal } from '../../../core/signals/primitives';
+import { type ReadonlySignal, snapshot } from '../../../core/signals/primitives';
 import type { MaybeResolvedPresentation } from '../../../media/types';
 import { hasPresentationDuration } from '../../../media/types';
 
@@ -9,28 +10,26 @@ export interface DurationUpdateState {
   mediaSourceReadyState?: MediaSource['readyState'];
 }
 
-export interface DurationUpdateOwners {
+export interface DurationUpdateContext {
   mediaSource?: MediaSource;
-  videoSourceBuffer?: SourceBuffer;
-  audioSourceBuffer?: SourceBuffer;
+  videoBuffer?: SourceBuffer;
+  audioBuffer?: SourceBuffer;
 }
 
 /**
  * Check if we can update MediaSource duration (have required data).
  */
-export function canUpdateDuration(state: DurationUpdateState, owners: DurationUpdateOwners): boolean {
-  return !!(owners.mediaSource && state.presentation && hasPresentationDuration(state.presentation));
+export function canUpdateDuration(state: DurationUpdateState, context: DurationUpdateContext): boolean {
+  return !!(context.mediaSource && state.presentation && hasPresentationDuration(state.presentation));
 }
 
 /**
  * Get the maximum buffered end time across all SourceBuffers.
  */
-export function getMaxBufferedEnd(owners: DurationUpdateOwners): number {
+export function getMaxBufferedEnd(context: DurationUpdateContext): number {
   let maxEnd = 0;
 
-  const buffers = [owners.videoSourceBuffer, owners.audioSourceBuffer].filter(
-    (buf): buf is SourceBuffer => buf !== undefined
-  );
+  const buffers = [context.videoBuffer, context.audioBuffer].filter((buf): buf is SourceBuffer => buf !== undefined);
 
   for (const buffer of buffers) {
     const { buffered } = buffer;
@@ -48,10 +47,10 @@ export function getMaxBufferedEnd(owners: DurationUpdateOwners): number {
 /**
  * Check if we should update MediaSource duration (conditions met).
  */
-export function shouldUpdateDuration(state: DurationUpdateState, owners: DurationUpdateOwners): boolean {
-  if (!canUpdateDuration(state, owners)) return false;
+export function shouldUpdateDuration(state: DurationUpdateState, context: DurationUpdateContext): boolean {
+  if (!canUpdateDuration(state, context)) return false;
 
-  const { mediaSource } = owners;
+  const { mediaSource } = context;
   const { presentation } = state;
 
   // MediaSource must be open — read from state.mediaSourceReadyState so the
@@ -77,8 +76,8 @@ export function shouldUpdateDuration(state: DurationUpdateState, owners: Duratio
  * The MSE spec forbids setting MediaSource.duration while any attached
  * SourceBuffer has updating === true. This defers until all are idle.
  */
-function waitForSourceBuffersReady(owners: DurationUpdateOwners): Promise<void> {
-  const updating = [owners.videoSourceBuffer, owners.audioSourceBuffer].filter(
+function waitForSourceBuffersReady(context: DurationUpdateContext): Promise<void> {
+  const updating = [context.videoBuffer, context.audioBuffer].filter(
     (buf): buf is SourceBuffer => buf?.updating === true
   );
 
@@ -94,28 +93,35 @@ function waitForSourceBuffersReady(owners: DurationUpdateOwners): Promise<void>
 /**
  * Update MediaSource duration when presentation duration becomes available.
  */
-export function updateDuration<S extends DurationUpdateState, O extends DurationUpdateOwners>({
+function updateDurationSetup({
   state,
-  owners,
+  context,
 }: {
-  state: Signal<S>;
-  owners: Signal<O>;
+  state: {
+    presentation: ReadonlySignal<DurationUpdateState['presentation']>;
+    mediaSourceReadyState: ReadonlySignal<DurationUpdateState['mediaSourceReadyState']>;
+  };
+  context: {
+    mediaSource: ReadonlySignal<DurationUpdateContext['mediaSource']>;
+    videoBuffer: ReadonlySignal<DurationUpdateContext['videoBuffer']>;
+    audioBuffer: ReadonlySignal<DurationUpdateContext['audioBuffer']>;
+  };
 }): () => void {
   let destroyed = false;
   let running = false;
 
   const cleanupEffect = effect(() => {
-    const currentState = state.get();
-    const currentOwners = owners.get();
+    const currentState = snapshot(state);
+    const currentContext = snapshot(context);
 
-    if (!shouldUpdateDuration(currentState, currentOwners) || running) return;
+    if (!shouldUpdateDuration(currentState, currentContext) || running) return;
 
-    const { mediaSource } = currentOwners;
+    const { mediaSource } = currentContext;
     running = true;
 
     // MSE spec: duration cannot be set while any SourceBuffer is updating.
     // Capture the snapshot; the async helper does not read signals.
-    waitForSourceBuffersReady(currentOwners)
+    waitForSourceBuffersReady(currentContext)
       .then(() => {
         // Re-check after async wait: destroyed, or readyState changed (e.g. endOfStream
         // already called endOfStream(), transitioning 'open' → 'ended').
@@ -125,7 +131,7 @@ export function updateDuration<S extends DurationUpdateState, O extends Duration
 
         // MSE spec: duration cannot be less than any buffered range.
         // If buffered ranges exceed calculated duration, extend to match.
-        const maxBufferedEnd = getMaxBufferedEnd(currentOwners);
+        const maxBufferedEnd = getMaxBufferedEnd(currentContext);
         if (maxBufferedEnd > duration) {
           duration = maxBufferedEnd;
         }
@@ -142,3 +148,9 @@ export function updateDuration<S extends DurationUpdateState, O extends Duration
     cleanupEffect();
   };
 }
+
+export const updateDuration = defineBehavior({
+  stateKeys: ['presentation', 'mediaSourceReadyState'],
+  contextKeys: ['mediaSource', 'videoBuffer', 'audioBuffer'],
+  setup: updateDurationSetup,
+});
diff --git a/packages/spf/src/playback/behaviors/load-text-track-cues.ts b/packages/spf/src/playback/behaviors/load-text-track-cues.ts
index ccccfe8d..7a7ca351 100644
--- a/packages/spf/src/playback/behaviors/load-text-track-cues.ts
+++ b/packages/spf/src/playback/behaviors/load-text-track-cues.ts
@@ -1,6 +1,7 @@
+import { defineBehavior } from '../../core/composition/create-composition';
 import type { Reactor } from '../../core/reactors/create-machine-reactor';
 import { createMachineReactor } from '../../core/reactors/create-machine-reactor';
-import { computed, type Signal, untrack } from '../../core/signals/primitives';
+import { computed, type ReadonlySignal, snapshot, untrack } from '../../core/signals/primitives';
 import type { Cue, MaybeResolvedPresentation, MediaElementWithTextTracks, TextTrack } from '../../media/types';
 import { isResolvedTrack } from '../../media/types';
 import type { TextTrackSegmentLoaderActor } from '../actors/text-track-segment-loader';
@@ -20,7 +21,7 @@ import type { TextTracksActor } from '../actors/text-tracks';
  * ```
  *
  * Actor lifecycle is NOT managed by this behavior — it reads
- * `textTracksActor` and `segmentLoaderActor` from owners. A host-side
+ * `textTracksActor` and `segmentLoaderActor` from context. A host-side
  * setup behavior (e.g. `setupTextTrackActors` in dom/) is
  * responsible for creating and destroying them when the media element
  * appears/disappears.
@@ -38,14 +39,14 @@ export interface TextTrackCueLoadingState {
 }
 
 /**
- * Owners shape for text-track cue loading.
+ * Context shape for text-track cue loading.
  *
  * The `mediaElement` is typed against the host-agnostic
  * `MediaElementWithTextTracks` shape; `HTMLMediaElement` satisfies it
  * structurally. Actors are expected to be supplied by a companion
  * provider behavior.
  */
-export interface TextTrackCueLoadingOwners {
+export interface TextTrackCueLoadingContext {
   mediaElement?: MediaElementWithTextTracks | undefined;
   textTracksActor?: TextTracksActor<Cue> | undefined;
   segmentLoaderActor?: TextTrackSegmentLoaderActor | undefined;
@@ -71,18 +72,18 @@ function hasMountedTrack(mediaElement: MediaElementWithTextTracks, id: string):
   return false;
 }
 
-function deriveState(state: TextTrackCueLoadingState, owners: TextTrackCueLoadingOwners): LoadTextTrackCuesState {
+function deriveState(state: TextTrackCueLoadingState, context: TextTrackCueLoadingContext): LoadTextTrackCuesState {
   if (
-    !owners.mediaElement ||
+    !context.mediaElement ||
     !getTextTracks(state.presentation)?.length ||
-    !owners.textTracksActor ||
-    !owners.segmentLoaderActor
+    !context.textTracksActor ||
+    !context.segmentLoaderActor
   ) {
     return 'preconditions-unmet';
   }
   const track = findSelectedTrack(state);
   if (!track || track.segments.length === 0) return 'pending';
-  if (!hasMountedTrack(owners.mediaElement, state.selectedTextTrackId ?? '')) {
+  if (!hasMountedTrack(context.mediaElement, state.selectedTextTrackId ?? '')) {
     return 'pending';
   }
   return 'monitoring-for-loads';
@@ -96,7 +97,7 @@ function deriveState(state: TextTrackCueLoadingState, owners: TextTrackCueLoadin
  * Text-track cue loading orchestration (host-agnostic).
  *
  * Waits for preconditions (mediaElement, presentation with text tracks,
- * actors in owners, selected track mounted), then sends `load` messages
+ * actors in context, selected track mounted), then sends `load` messages
  * to the `segmentLoaderActor` whenever `currentTime` or the selected
  * track changes.
  *
@@ -104,18 +105,26 @@ function deriveState(state: TextTrackCueLoadingState, owners: TextTrackCueLoadin
  * does not create or destroy them.
  *
  * @example
- * const reactor = loadTextTrackCues({ state, owners });
+ * const reactor = loadTextTrackCues.setup({ state, context });
  */
-export function loadTextTrackCues<S extends TextTrackCueLoadingState, O extends TextTrackCueLoadingOwners>({
+function loadTextTrackCuesSetup({
   state,
-  owners,
+  context,
 }: {
-  state: Signal<S>;
-  owners: Signal<O>;
+  state: {
+    selectedTextTrackId: ReadonlySignal<TextTrackCueLoadingState['selectedTextTrackId']>;
+    presentation: ReadonlySignal<TextTrackCueLoadingState['presentation']>;
+    currentTime: ReadonlySignal<TextTrackCueLoadingState['currentTime']>;
+  };
+  context: {
+    mediaElement: ReadonlySignal<TextTrackCueLoadingContext['mediaElement']>;
+    textTracksActor: ReadonlySignal<TextTrackCueLoadingContext['textTracksActor']>;
+    segmentLoaderActor: ReadonlySignal<TextTrackCueLoadingContext['segmentLoaderActor']>;
+  };
 }): Reactor<LoadTextTrackCuesState | 'destroying' | 'destroyed'> {
-  const derivedStateSignal = computed(() => deriveState(state.get(), owners.get()));
-  const currentTimeSignal = computed(() => state.get().currentTime ?? 0);
-  const selectedTrackSignal = computed(() => findSelectedTrack(state.get()));
+  const derivedStateSignal = computed(() => deriveState(snapshot(state), snapshot(context)));
+  const currentTimeSignal = computed(() => state.currentTime.get() ?? 0);
+  const selectedTrackSignal = computed(() => findSelectedTrack(snapshot(state)));
 
   return createMachineReactor<LoadTextTrackCuesState>({
     initial: 'preconditions-unmet',
@@ -125,17 +134,23 @@ export function loadTextTrackCues<S extends TextTrackCueLoadingState, O extends
       pending: {},
       'monitoring-for-loads': {
         // Re-runs whenever currentTime or selectedTrack changes, dispatching
-        // a load message. owners is read with untrack() since actor presence
+        // a load message. context is read with untrack() since actor presence
         // is guaranteed by deriveState when in this state. The always monitor
         // (registered before this effect) transitions us out before this
         // re-runs if either invariant stops holding.
         effects: () => {
           const currentTime = currentTimeSignal.get();
           const track = selectedTrackSignal.get()!;
-          const { segmentLoaderActor } = untrack(() => owners.get());
+          const segmentLoaderActor = untrack(() => context.segmentLoaderActor.get());
           segmentLoaderActor!.send({ type: 'load', track, currentTime });
         },
       },
     },
   });
 }
+
+export const loadTextTrackCues = defineBehavior({
+  stateKeys: ['selectedTextTrackId', 'presentation', 'currentTime'],
+  contextKeys: ['mediaElement', 'textTracksActor', 'segmentLoaderActor'],
+  setup: loadTextTrackCuesSetup,
+});
diff --git a/packages/spf/src/playback/behaviors/quality-switching.ts b/packages/spf/src/playback/behaviors/quality-switching.ts
index 0168dcaa..9d87914b 100644
--- a/packages/spf/src/playback/behaviors/quality-switching.ts
+++ b/packages/spf/src/playback/behaviors/quality-switching.ts
@@ -1,5 +1,6 @@
+import { defineBehavior } from '../../core/composition/create-composition';
 import { effect } from '../../core/signals/effect';
-import { type Signal, update } from '../../core/signals/primitives';
+import { type ReadonlySignal, type Signal, snapshot } from '../../core/signals/primitives';
 import type { BandwidthState } from '../../media/abr/bandwidth-estimator';
 import { getBandwidthEstimate } from '../../media/abr/bandwidth-estimator';
 import { selectQuality } from '../../media/abr/quality-selection';
@@ -44,7 +45,7 @@ export interface QualitySwitchingConfig {
    * Bandwidth estimate in bps to use before enough samples have been collected.
    * Default: 5_000_000 (5 Mbps).
    */
-  defaultBandwidth?: number;
+  initialBandwidth?: number;
 }
 
 /**
@@ -53,7 +54,7 @@ export interface QualitySwitchingConfig {
 export const DEFAULT_SWITCHING_CONFIG: Required<QualitySwitchingConfig> = {
   safetyMargin: 0.85,
   minUpgradeInterval: 8000,
-  defaultBandwidth: 5_000_000,
+  initialBandwidth: 5_000_000,
 };
 
 /**
@@ -81,17 +82,25 @@ function getVideoTracks(presentation: MaybeResolvedPresentation) {
  * quality. The browser's SourceBuffer replaces the overlapping buffered range.
  *
  * @example
- * const cleanup = switchQuality({ state });
+ * const cleanup = switchQuality.setup({ state });
  * // Later, when done:
  * cleanup();
  */
-export function switchQuality<S extends QualitySwitchingState>(
-  { state }: { state: Signal<S> },
-  config: QualitySwitchingConfig = {}
-): () => void {
+function switchQualitySetup({
+  state,
+  config = {},
+}: {
+  state: {
+    presentation: ReadonlySignal<QualitySwitchingState['presentation']>;
+    bandwidthState: ReadonlySignal<QualitySwitchingState['bandwidthState']>;
+    selectedVideoTrackId: Signal<QualitySwitchingState['selectedVideoTrackId']>;
+    abrDisabled: ReadonlySignal<QualitySwitchingState['abrDisabled']>;
+  };
+  config?: QualitySwitchingConfig;
+}): () => void {
   const safetyMargin = config.safetyMargin ?? DEFAULT_SWITCHING_CONFIG.safetyMargin;
   const minUpgradeInterval = config.minUpgradeInterval ?? DEFAULT_SWITCHING_CONFIG.minUpgradeInterval;
-  const defaultBandwidth = config.defaultBandwidth ?? DEFAULT_SWITCHING_CONFIG.defaultBandwidth;
+  const initialBandwidth = config.initialBandwidth ?? DEFAULT_SWITCHING_CONFIG.initialBandwidth;
 
   // Initialize to creation time so the interval starts counting immediately.
   // The first time we have enough data to make a meaningful quality decision
@@ -101,7 +110,7 @@ export function switchQuality<S extends QualitySwitchingState>(
   let firstMeaningfulFire = true;
 
   return effect(() => {
-    const currentState = state.get();
+    const currentState = snapshot(state);
     const { presentation, bandwidthState, selectedVideoTrackId, abrDisabled } = currentState;
 
     if (abrDisabled === true) return;
@@ -114,7 +123,7 @@ export function switchQuality<S extends QualitySwitchingState>(
     const isFirst = firstMeaningfulFire;
     firstMeaningfulFire = false;
 
-    const bandwidth = getBandwidthEstimate(bandwidthState, defaultBandwidth);
+    const bandwidth = getBandwidthEstimate(bandwidthState, initialBandwidth);
     const optimal = selectQuality(videoTracks as any, bandwidth, { safetyMargin });
     if (!optimal || optimal.id === selectedVideoTrackId) return;
 
@@ -130,7 +139,12 @@ export function switchQuality<S extends QualitySwitchingState>(
       lastUpgradeTime = now;
     }
 
-    const patch: Partial<QualitySwitchingState> = { selectedVideoTrackId: optimal.id };
-    update(state, patch);
+    state.selectedVideoTrackId.set(optimal.id);
   });
 }
+
+export const switchQuality = defineBehavior({
+  stateKeys: ['presentation', 'bandwidthState', 'selectedVideoTrackId', 'abrDisabled'],
+  contextKeys: [],
+  setup: switchQualitySetup,
+});
diff --git a/packages/spf/src/playback/behaviors/resolve-presentation.ts b/packages/spf/src/playback/behaviors/resolve-presentation.ts
index 259544bc..f1d4a28e 100644
--- a/packages/spf/src/playback/behaviors/resolve-presentation.ts
+++ b/packages/spf/src/playback/behaviors/resolve-presentation.ts
@@ -1,6 +1,7 @@
+import { defineBehavior } from '../../core/composition/create-composition';
 import type { Reactor } from '../../core/reactors/create-machine-reactor';
 import { createMachineReactor } from '../../core/reactors/create-machine-reactor';
-import { computed, type Signal, update } from '../../core/signals/primitives';
+import { computed, type ReadonlySignal, type Signal, snapshot } from '../../core/signals/primitives';
 import { parseMultivariantPlaylist } from '../../media/hls/parse-multivariant';
 import { isResolvedPresentation, type MaybeResolvedPresentation } from '../../media/types';
 import { fetchResolvable, getResponseText } from '../../network/fetch';
@@ -71,16 +72,20 @@ function deriveState(state: PresentationState): ResolvePresentationState {
  * task and returns an AbortController so the framework aborts it on state exit.
  *
  * @example
- * const reactor = resolvePresentation({ state });
+ * const reactor = resolvePresentation.setup({ state });
  * // later:
  * reactor.destroy();
  */
-export function resolvePresentation<S extends PresentationState>({
+function resolvePresentationSetup({
   state,
 }: {
-  state: Signal<S>;
+  state: {
+    presentation: Signal<PresentationState['presentation']>;
+    preload: ReadonlySignal<PresentationState['preload']>;
+    playbackInitiated: ReadonlySignal<PresentationState['playbackInitiated']>;
+  };
 }): Reactor<ResolvePresentationState | 'destroying' | 'destroyed'> {
-  const derivedStateSignal = computed(() => deriveState(state.get()));
+  const derivedStateSignal = computed(() => deriveState(snapshot(state)));
 
   return createMachineReactor<ResolvePresentationState>({
     initial: 'preconditions-unmet',
@@ -92,14 +97,14 @@ export function resolvePresentation<S extends PresentationState>({
         // Entry: start fetch on state entry; return AbortController so the
         // framework aborts the in-flight request on state exit.
         entry: () => {
-          const presentation = state.get().presentation!;
+          const presentation = state.presentation.get()!;
           const ac = new AbortController();
 
           fetchResolvable(presentation, { signal: ac.signal })
             .then((response) => getResponseText(response))
             .then((text) => {
               const parsed = parseMultivariantPlaylist(text, presentation);
-              update(state, { presentation: parsed } as Partial<S>);
+              state.presentation.set(parsed);
             })
             .catch((error) => {
               if (error instanceof Error && error.name === 'AbortError') return;
@@ -113,3 +118,9 @@ export function resolvePresentation<S extends PresentationState>({
     },
   });
 }
+
+export const resolvePresentation = defineBehavior({
+  stateKeys: ['presentation', 'preload', 'playbackInitiated'],
+  contextKeys: [],
+  setup: resolvePresentationSetup,
+});
diff --git a/packages/spf/src/playback/behaviors/resolve-track.ts b/packages/spf/src/playback/behaviors/resolve-track.ts
index 0c9630d1..e6d18f50 100644
--- a/packages/spf/src/playback/behaviors/resolve-track.ts
+++ b/packages/spf/src/playback/behaviors/resolve-track.ts
@@ -1,32 +1,18 @@
+import { defineBehavior } from '../../core/composition/create-composition';
 import { effect } from '../../core/signals/effect';
-import type { Signal } from '../../core/signals/primitives';
+import type { ReadonlySignal, Signal } from '../../core/signals/primitives';
 import { ConcurrentRunner, Task } from '../../core/tasks/task';
 import { parseMediaPlaylist } from '../../media/hls/parse-media-playlist';
-import type { MaybeResolvedPresentation, Presentation, ResolvedTrack, TrackType } from '../../media/types';
+import type {
+  MaybeResolvedPresentation,
+  PartiallyResolvedTrack,
+  Presentation,
+  ResolvedTrack,
+  TrackType,
+} from '../../media/types';
 import { isResolvedPresentation, isResolvedTrack } from '../../media/types';
-import { getSelectedTrack, type TrackSelectionState } from '../../media/utils/track-selection';
 import { fetchResolvable, getResponseText } from '../../network/fetch';
 
-/**
- * State shape for track resolution.
- */
-export interface TrackResolutionState extends TrackSelectionState {
-  presentation?: MaybeResolvedPresentation;
-  selectedVideoTrackId?: string | undefined;
-  selectedAudioTrackId?: string | undefined;
-  selectedTextTrackId?: string | undefined;
-}
-
-export function canResolve<T extends TrackType>(
-  state: TrackResolutionState,
-  config: TrackResolutionConfig<T>
-): boolean {
-  const track = getSelectedTrack(state, config.type);
-  if (!track) return false;
-
-  return !isResolvedTrack(track);
-}
-
 // ============================================================================
 // Public API
 // ============================================================================
@@ -53,25 +39,57 @@ export function updateTrackInPresentation<T extends ResolvedTrack>(
 }
 
 /**
- * Configuration for track resolution.
+ * Find a track of the given type and id within a presentation.
+ *
+ * Returns the matching track from the first switching set of the matching
+ * selection set, or `undefined` if either is missing. The returned track may
+ * be partially resolved (URL only) or fully resolved (with segments) — callers
+ * narrow as needed.
  */
-export interface TrackResolutionConfig<T extends TrackType = TrackType> {
-  type: T;
+function findTrack(
+  presentation: MaybeResolvedPresentation,
+  type: TrackType,
+  trackId: string
+): PartiallyResolvedTrack | ResolvedTrack | undefined {
+  return presentation.selectionSets
+    ?.find(({ type: t }) => t === type)
+    ?.switchingSets[0]?.tracks.find(({ id }) => id === trackId);
 }
 
+// ============================================================================
+// Specialization helper
+//
+// Each `resolveXTrack` export below is a thin wrapper that binds (selectedKey,
+// findTrackToResolve) at module load. The orchestration — gate on a selection,
+// short-circuit when the track is already resolved or missing, schedule the
+// fetch+parse, and patch the resolved track back into `state.presentation` —
+// is shared.
+// ============================================================================
+
 /**
- * Resolves unresolved tracks using reactive composition.
- *
- * Reacts to state changes and schedules fetch tasks via ConcurrentRunner when
- * a selected track is unresolved. The ConcurrentRunner handles deduplication,
- * parallel execution, and cleanup.
- *
- * Generic version that works for video, audio, or text tracks based on config.
- * Type parameter T is inferred from config.type (use 'as const' for inference).
+ * State shape for track resolution. Uses `MaybeResolvedPresentation` so it
+ * matches the engine's slot type; resolution narrows internally.
  */
-export function resolveTrack<S extends TrackResolutionState, T extends TrackType>(
-  { state }: { state: Signal<S> },
-  config: TrackResolutionConfig<T>
+export interface ResolveTrackState {
+  presentation?: MaybeResolvedPresentation;
+  selectedVideoTrackId?: string;
+  selectedAudioTrackId?: string;
+  selectedTextTrackId?: string;
+}
+
+type SelectedTrackKey = 'selectedVideoTrackId' | 'selectedAudioTrackId' | 'selectedTextTrackId';
+
+type ResolveTrackStateMap<K extends SelectedTrackKey> = {
+  presentation: Signal<ResolveTrackState['presentation']>;
+} & { [P in K]: ReadonlySignal<ResolveTrackState[P]> };
+
+function setupTrackResolution<K extends SelectedTrackKey>(
+  state: ResolveTrackStateMap<K>,
+  selectedKey: K,
+  findTrackToResolve: (
+    presentation: MaybeResolvedPresentation,
+    trackId: string
+  ) => PartiallyResolvedTrack | ResolvedTrack | undefined
 ): () => void {
   // NOTE: This can/maybe will be pulled into a per-use case factory (e.g. something like createTaskRunner() with args TBD),
   // likely eventually passed down via config or a new "definitions" argument. This will allow us to decide if we want our task runner/scheduler
@@ -79,33 +97,30 @@ export function resolveTrack<S extends TrackResolutionState, T extends TrackType
   const runner = new ConcurrentRunner();
 
   const cleanup = effect(() => {
-    const currentState = state.get();
-    if (!canResolve(currentState, config)) return;
+    const presentation = state.presentation.get();
+    const trackId = state[selectedKey].get();
+    if (!presentation || !trackId) return;
 
-    const track = getSelectedTrack(currentState, config.type);
-    if (!track) return;
-
-    const resolvedTrack = track;
+    const track = findTrackToResolve(presentation, trackId);
+    if (!track || isResolvedTrack(track)) return;
 
     runner.schedule(
       // NOTE: This can/maybe will be pulled into a per-use case factory (e.g. something like createResolveTrackTask(track, context, config)),
       // likely eventually passed down via config or a new "definitions" argument (CJP).
       new Task(
         async (signal) => {
-          const response = await fetchResolvable(resolvedTrack, { signal });
+          const response = await fetchResolvable(track, { signal });
           const text = await getResponseText(response);
-          const mediaTrack = parseMediaPlaylist(text, resolvedTrack);
+          const mediaTrack = parseMediaPlaylist(text, track);
 
-          // IMPORTANT: Read state.get().presentation at write time, not from the
-          // captured currentState snapshot. Multiple Tasks may be running concurrently
-          // (one per track being resolved), so the snapshot is likely already stale by
-          // the time a task completes — a sibling task may have already written the
-          // presentation with its own resolved track. Reading live state ensures each
-          // task builds on top of whatever has been committed so far.
-          const latest = state.get();
-          if (!isResolvedPresentation(latest.presentation)) return;
-          const updatedPresentation = updateTrackInPresentation(latest.presentation, mediaTrack);
-          state.set({ ...latest, presentation: updatedPresentation } as S);
+          // captured snapshot above. Multiple Tasks may be running concurrently
+          // (one per track being resolved), so the snapshot is likely already stale
+          // by the time a task completes — a sibling task may have already written
+          // the presentation with its own resolved track. Reading live state ensures
+          // each task builds on top of whatever has been committed so far.
+          const latestPresentation = state.presentation.get();
+          if (!isResolvedPresentation(latestPresentation)) return;
+          state.presentation.set(updateTrackInPresentation(latestPresentation, mediaTrack));
         },
         { id: track.id }
       )
@@ -117,3 +132,47 @@ export function resolveTrack<S extends TrackResolutionState, T extends TrackType
     cleanup();
   };
 }
+
+// ============================================================================
+// Specialized exports — one per track type
+// ============================================================================
+
+/**
+ * Resolve unresolved video tracks. Schedules a fetch task whenever the
+ * selected video track is partially resolved, parses the manifest, and
+ * writes the resolved track back into `state.presentation`.
+ */
+export const resolveVideoTrack = defineBehavior({
+  stateKeys: ['presentation', 'selectedVideoTrackId'],
+  contextKeys: [],
+  setup: ({ state }: { state: ResolveTrackStateMap<'selectedVideoTrackId'> }) =>
+    setupTrackResolution(state, 'selectedVideoTrackId', (presentation, trackId) =>
+      findTrack(presentation, 'video', trackId)
+    ),
+});
+
+/**
+ * Resolve unresolved audio tracks. Same shape as `resolveVideoTrack`,
+ * narrowed to audio.
+ */
+export const resolveAudioTrack = defineBehavior({
+  stateKeys: ['presentation', 'selectedAudioTrackId'],
+  contextKeys: [],
+  setup: ({ state }: { state: ResolveTrackStateMap<'selectedAudioTrackId'> }) =>
+    setupTrackResolution(state, 'selectedAudioTrackId', (presentation, trackId) =>
+      findTrack(presentation, 'audio', trackId)
+    ),
+});
+
+/**
+ * Resolve unresolved text tracks. Same shape as `resolveVideoTrack`,
+ * narrowed to text.
+ */
+export const resolveTextTrack = defineBehavior({
+  stateKeys: ['presentation', 'selectedTextTrackId'],
+  contextKeys: [],
+  setup: ({ state }: { state: ResolveTrackStateMap<'selectedTextTrackId'> }) =>
+    setupTrackResolution(state, 'selectedTextTrackId', (presentation, trackId) =>
+      findTrack(presentation, 'text', trackId)
+    ),
+});
diff --git a/packages/spf/src/playback/behaviors/select-tracks.ts b/packages/spf/src/playback/behaviors/select-tracks.ts
index 197dcb51..96636c42 100644
--- a/packages/spf/src/playback/behaviors/select-tracks.ts
+++ b/packages/spf/src/playback/behaviors/select-tracks.ts
@@ -1,114 +1,112 @@
+import { defineBehavior } from '../../core/composition/create-composition';
 import { effect } from '../../core/signals/effect';
-import { type Signal, update } from '../../core/signals/primitives';
+import type { ReadonlySignal, Signal } from '../../core/signals/primitives';
 import {
-  type AudioSelectionConfig,
-  canSelectTrack,
   pickTextTrack,
-  shouldSelectTrack,
   type TextSelectionConfig,
   type TrackSelectionState,
-  type VideoSelectionConfig,
 } from '../../media/primitives/select-tracks';
-import { isResolvedPresentation } from '../../media/types';
-import { SelectedTrackIdKeyByType } from '../../media/utils/track-selection';
+import { isResolvedPresentation, type MaybeResolvedPresentation, type TrackType } from '../../media/types';
 
 /**
- * Select video track orchestration.
+ * Pick the first track of the given type from a presentation.
  *
- * Selects video track when:
- * - Presentation exists
- * - No video track is selected yet
- *
- * Uses bandwidth-based quality selection algorithm.
- *
- * @example
- * const cleanup = selectVideoTrack(
- *   { state, owners, events },
- *   { initialBandwidth: 2_000_000 }
- * );
+ * Currently a POC: returns the first track in the first switching set.
+ * The full pickers (`pickVideoTrack` / `pickAudioTrack` in
+ * `media/primitives/select-tracks.ts`) honor bandwidth + language
+ * preferences and will replace this once the selection algorithm matures.
  */
-export function selectVideoTrack<S extends TrackSelectionState>(
-  { state }: { state: Signal<S> },
-  config: VideoSelectionConfig = { type: 'video' }
+function pickFirstTrackId(presentation: MaybeResolvedPresentation, type: TrackType): string | undefined {
+  return presentation.selectionSets?.find((set) => set.type === type)?.switchingSets[0]?.tracks[0]?.id;
+}
+
+// ============================================================================
+// Specialization helper
+//
+// Each `selectXTrack` export below is a thin wrapper that binds (selectedKey,
+// picker) at module load. Picker is variant-specific: video/audio use
+// `pickFirstTrackId` (works on any `MaybeResolvedPresentation`); text uses
+// `pickTextTrack` against a fully-resolved `Presentation`. The orchestration
+// — read presentation, no-op when already selected, pick, set — is shared.
+// ============================================================================
+
+type SelectedTrackKey = 'selectedVideoTrackId' | 'selectedAudioTrackId' | 'selectedTextTrackId';
+
+type SelectStateMap<K extends SelectedTrackKey> = {
+  presentation: ReadonlySignal<TrackSelectionState['presentation']>;
+} & { [P in K]: Signal<TrackSelectionState[P]> };
+
+function setupTrackSelection<K extends SelectedTrackKey>(
+  state: SelectStateMap<K>,
+  selectedKey: K,
+  picker: (presentation: MaybeResolvedPresentation) => string | undefined
 ): () => void {
   return effect(() => {
-    const currentState = state.get();
-    if (!canSelectTrack(currentState, config) || !shouldSelectTrack(currentState, config)) return;
-
-    // Just to have basic functionality/POC, simply selecting the first track
-    const selectedTrackId = currentState.presentation?.selectionSets?.find(({ type }) => type === config.type)
-      ?.switchingSets[0]?.tracks[0]?.id;
-
-    if (selectedTrackId) {
-      const selectedTrackKey = SelectedTrackIdKeyByType[config.type];
-      const patch: Partial<TrackSelectionState> = { [selectedTrackKey]: selectedTrackId };
-      update(state, patch);
-    }
+    const presentation = state.presentation.get();
+    if (!presentation || state[selectedKey].get()) return;
+    const id = picker(presentation);
+    if (id) state[selectedKey].set(id);
   });
 }
 
-/**
- * Select audio track orchestration.
- *
- * Selects audio track when:
- * - Presentation exists
- * - No audio track is selected yet
- *
- * Uses language and preference-based selection.
- *
- * @example
- * const cleanup = selectAudioTrack(
- *   { state, owners, events },
- *   { preferredAudioLanguage: 'en' }
- * );
- */
-export function selectAudioTrack<S extends TrackSelectionState>(
-  { state }: { state: Signal<S> },
-  config: AudioSelectionConfig = { type: 'audio' }
-): () => void {
-  return effect(() => {
-    const currentState = state.get();
-    if (!canSelectTrack(currentState, config) || !shouldSelectTrack(currentState, config)) return;
-
-    // Just to have basic functionality/POC, simply selecting the first track
-    const selectedTrackId = currentState.presentation?.selectionSets?.find(({ type }) => type === 'audio')
-      ?.switchingSets[0]?.tracks[0]?.id;
-
-    if (selectedTrackId) {
-      const patch: Partial<TrackSelectionState> = { selectedAudioTrackId: selectedTrackId };
-      update(state, patch);
-    }
-  });
-}
+// ============================================================================
+// Specialized exports — one per track type
+// ============================================================================
 
 /**
- * Select text track orchestration.
+ * Select the first available video track when a presentation loads.
  *
- * Selects text track when:
- * - Presentation exists
- * - No text track is selected yet
- *
- * Note: Currently does not auto-select (user opt-in).
+ * No-op once a video track is already selected.
  *
  * @example
- * const cleanup = selectTextTrack({ state, owners, events }, {});
+ * const cleanup = selectVideoTrack.setup({ state });
  */
-export function selectTextTrack<S extends TrackSelectionState>(
-  { state }: { state: Signal<S> },
-  config: TextSelectionConfig = { type: 'text' }
-): () => void {
-  return effect(() => {
-    const currentState = state.get();
-    if (!canSelectTrack(currentState, config) || !shouldSelectTrack(currentState, config)) return;
+export const selectVideoTrack = defineBehavior({
+  stateKeys: ['presentation', 'selectedVideoTrackId'],
+  contextKeys: [],
+  setup: ({ state }: { state: SelectStateMap<'selectedVideoTrackId'> }) =>
+    setupTrackSelection(state, 'selectedVideoTrackId', (presentation) => pickFirstTrackId(presentation, 'video')),
+});
 
-    if (!isResolvedPresentation(currentState.presentation)) return;
+/**
+ * Select the first available audio track when a presentation loads.
+ *
+ * No-op once an audio track is already selected.
+ *
+ * @example
+ * const cleanup = selectAudioTrack.setup({ state });
+ */
+export const selectAudioTrack = defineBehavior({
+  stateKeys: ['presentation', 'selectedAudioTrackId'],
+  contextKeys: [],
+  setup: ({ state }: { state: SelectStateMap<'selectedAudioTrackId'> }) =>
+    setupTrackSelection(state, 'selectedAudioTrackId', (presentation) => pickFirstTrackId(presentation, 'audio')),
+});
 
-    // Text tracks are user opt-in - don't auto-select
-    const selectedTextTrackId = pickTextTrack(currentState.presentation, config);
-
-    if (selectedTextTrackId) {
-      const patch: Partial<TrackSelectionState> = { selectedTextTrackId };
-      update(state, patch);
-    }
-  });
-}
+/**
+ * Select a text track based on user preferences (preferred language,
+ * default-track auto-select, forced-track filtering).
+ *
+ * Unlike video/audio selection, text-track selection is user opt-in —
+ * `pickTextTrack` returns undefined when no preference matches, and the
+ * effect leaves `selectedTextTrackId` unset. Also requires a fully-resolved
+ * presentation; partial resolutions are skipped until a media playlist is parsed.
+ *
+ * @example
+ * const cleanup = selectTextTrack.setup({ state, config: { preferredSubtitleLanguage: 'en' } });
+ */
+export const selectTextTrack = defineBehavior({
+  stateKeys: ['presentation', 'selectedTextTrackId'],
+  contextKeys: [],
+  setup: ({
+    state,
+    config,
+  }: {
+    state: SelectStateMap<'selectedTextTrackId'>;
+    config: Omit<TextSelectionConfig, 'type'>;
+  }) =>
+    setupTrackSelection(state, 'selectedTextTrackId', (presentation) => {
+      if (!isResolvedPresentation(presentation)) return undefined;
+      return pickTextTrack(presentation, { ...config, type: 'text' });
+    }),
+});
diff --git a/packages/spf/src/playback/behaviors/sync-preload-attribute.ts b/packages/spf/src/playback/behaviors/sync-preload-attribute.ts
index 9adb6497..7f27a2a0 100644
--- a/packages/spf/src/playback/behaviors/sync-preload-attribute.ts
+++ b/packages/spf/src/playback/behaviors/sync-preload-attribute.ts
@@ -1,38 +1,52 @@
+import { defineBehavior } from '../../core/composition/create-composition';
 import { effect } from '../../core/signals/effect';
-import { computed, type Signal, update } from '../../core/signals/primitives';
+import { computed, type ReadonlySignal, type Signal } from '../../core/signals/primitives';
 import type { MediaElementLike } from '../../media/types';
 import type { PresentationState } from './resolve-presentation';
 
 /**
- * Owners shape for preload attribute sync.
+ * Context shape for preload attribute sync.
  */
-export interface PlatformOwners {
+export interface PlatformContext {
   mediaElement?: MediaElementLike | undefined;
 }
 
+/**
+ * State slice this behavior reads/writes — narrowed from the broader
+ * `PresentationState` to only the keys touched by the body. The
+ * `defineBehavior` exhaustiveness check requires `stateKeys` to list
+ * every key in this typed slice.
+ */
+type State = Pick<PresentationState, 'preload'>;
+
 /**
  * Syncs preload attribute from mediaElement to state.
  *
- * Watches the owners signal for mediaElement changes and copies the
+ * Watches the context signal for mediaElement changes and copies the
  * preload attribute to state when no explicit value has been set.
  * An explicit value (set via SimpleHlsMediaElement.preload) always wins.
  *
  * @example
- * const cleanup = syncPreloadAttribute({ state, owners });
+ * const cleanup = syncPreloadAttribute.setup({ state, context, config: {} });
  */
-export function syncPreloadAttribute<S extends PresentationState, O extends PlatformOwners>({
+function syncPreloadAttributeSetup({
   state,
-  owners,
+  context,
 }: {
-  state: Signal<S>;
-  owners: Signal<O>;
+  state: { preload: Signal<State['preload']> };
+  context: { mediaElement: ReadonlySignal<PlatformContext['mediaElement']> };
 }): () => void {
-  const mediaElement = computed(() => owners.get().mediaElement);
+  const mediaElement = computed(() => context.mediaElement.get());
   return effect(() => {
-    if (state.get().preload !== undefined) return;
+    if (state.preload.get() !== undefined) return;
     const preload = mediaElement.get()?.preload || undefined;
     if (preload === undefined) return;
-    const patch: Partial<PresentationState> = { preload: preload as 'auto' | 'metadata' | 'none' };
-    update(state, patch);
+    state.preload.set(preload as 'auto' | 'metadata' | 'none');
   });
 }
+
+export const syncPreloadAttribute = defineBehavior({
+  stateKeys: ['preload'],
+  contextKeys: ['mediaElement'],
+  setup: syncPreloadAttributeSetup,
+});
diff --git a/packages/spf/src/playback/behaviors/tests/calculate-presentation-duration.test.ts b/packages/spf/src/playback/behaviors/tests/calculate-presentation-duration.test.ts
index e94b9b75..c7bd4272 100644
--- a/packages/spf/src/playback/behaviors/tests/calculate-presentation-duration.test.ts
+++ b/packages/spf/src/playback/behaviors/tests/calculate-presentation-duration.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, it, vi } from 'vitest';
+import type { StateSignals } from '../../../core/composition/create-composition';
 import { signal } from '../../../core/signals/primitives';
-import type { AudioTrack, Presentation, VideoTrack } from '../../../media/types';
+import type { AudioTrack, MaybeResolvedPresentation, Presentation, VideoTrack } from '../../../media/types';
 import {
   calculatePresentationDuration,
   canCalculateDuration,
@@ -9,6 +10,14 @@ import {
   shouldCalculateDuration,
 } from '../calculate-presentation-duration';
 
+function makeState(initial: PresentationDurationState = {}): StateSignals<PresentationDurationState> {
+  return {
+    presentation: signal<MaybeResolvedPresentation | undefined>(initial.presentation),
+    selectedVideoTrackId: signal<string | undefined>(initial.selectedVideoTrackId),
+    selectedAudioTrackId: signal<string | undefined>(initial.selectedAudioTrackId),
+  };
+}
+
 // Helper to create a minimal presentation with proper structure for getSelectedTrack
 function createPresentation(config: { video?: VideoTrack[]; audio?: AudioTrack[]; duration?: number }): Presentation {
   const selectionSets = [];
@@ -65,7 +74,6 @@ describe('canCalculateDuration', () => {
       presentation: mockPresentation(),
       selectedVideoTrackId: 'video-1',
     };
-
     expect(canCalculateDuration(state)).toBe(true);
   });
 
@@ -74,7 +82,6 @@ describe('canCalculateDuration', () => {
       presentation: mockPresentation(),
       selectedAudioTrackId: 'audio-1',
     };
-
     expect(canCalculateDuration(state)).toBe(true);
   });
 
@@ -82,7 +89,6 @@ describe('canCalculateDuration', () => {
     const state: PresentationDurationState = {
       selectedVideoTrackId: 'video-1',
     };
-
     expect(canCalculateDuration(state)).toBe(false);
   });
 
@@ -90,7 +96,6 @@ describe('canCalculateDuration', () => {
     const state: PresentationDurationState = {
       presentation: mockPresentation(),
     };
-
     expect(canCalculateDuration(state)).toBe(false);
   });
 });
@@ -101,7 +106,6 @@ describe('shouldCalculateDuration', () => {
       presentation: mockPresentation({ duration: 60 }),
       selectedVideoTrackId: 'video-1',
     };
-
     expect(shouldCalculateDuration(state)).toBe(false);
   });
 
@@ -118,7 +122,6 @@ describe('shouldCalculateDuration', () => {
       } as any,
       selectedVideoTrackId: 'video-1',
     };
-
     expect(shouldCalculateDuration(state)).toBe(false);
   });
 
@@ -142,7 +145,6 @@ describe('shouldCalculateDuration', () => {
       }),
       selectedVideoTrackId: 'video-1',
     };
-
     expect(shouldCalculateDuration(state)).toBe(true);
   });
 });
@@ -168,7 +170,6 @@ describe('getDurationFromResolvedTracks', () => {
       }),
       selectedVideoTrackId: 'video-1',
     };
-
     expect(getDurationFromResolvedTracks(state)).toBe(120.5);
   });
 
@@ -196,7 +197,6 @@ describe('getDurationFromResolvedTracks', () => {
       }),
       selectedAudioTrackId: 'audio-1',
     };
-
     expect(getDurationFromResolvedTracks(state)).toBe(90.25);
   });
 
@@ -239,7 +239,6 @@ describe('getDurationFromResolvedTracks', () => {
       selectedVideoTrackId: 'video-1',
       selectedAudioTrackId: 'audio-1',
     };
-
     expect(getDurationFromResolvedTracks(state)).toBe(120.5);
   });
 
@@ -247,20 +246,18 @@ describe('getDurationFromResolvedTracks', () => {
     const state: PresentationDurationState = {
       presentation: mockPresentation(),
     };
-
     expect(getDurationFromResolvedTracks(state)).toBeUndefined();
   });
 });
 
 describe('calculatePresentationDuration', () => {
   it('sets presentation.duration from resolved video track', async () => {
-    const state = signal<PresentationDurationState>({});
+    const state = makeState();
 
-    const cleanup = calculatePresentationDuration({ state });
+    const cleanup = calculatePresentationDuration.setup({ state });
 
-    state.set({
-      ...state.get(),
-      presentation: createPresentation({
+    state.presentation.set(
+      createPresentation({
         video: [
           {
             id: 'video-1',
@@ -275,25 +272,24 @@ describe('calculatePresentationDuration', () => {
             initialization: { id: 'init', url: 'http://example.com/init.mp4' },
           } as VideoTrack,
         ],
-      }),
-      selectedVideoTrackId: 'video-1',
-    });
+      })
+    );
+    state.selectedVideoTrackId.set('video-1');
 
     await vi.waitFor(() => {
-      expect(state.get().presentation?.duration).toBe(120.5);
+      expect(state.presentation.get()?.duration).toBe(120.5);
     });
 
     cleanup();
   });
 
   it('sets presentation.duration from resolved audio track', async () => {
-    const state = signal<PresentationDurationState>({});
+    const state = makeState();
 
-    const cleanup = calculatePresentationDuration({ state });
+    const cleanup = calculatePresentationDuration.setup({ state });
 
-    state.set({
-      ...state.get(),
-      presentation: createPresentation({
+    state.presentation.set(
+      createPresentation({
         audio: [
           {
             id: 'audio-1',
@@ -312,19 +308,19 @@ describe('calculatePresentationDuration', () => {
             initialization: { id: 'init', url: 'http://example.com/init.mp4' },
           } as AudioTrack,
         ],
-      }),
-      selectedAudioTrackId: 'audio-1',
-    });
+      })
+    );
+    state.selectedAudioTrackId.set('audio-1');
 
     await vi.waitFor(() => {
-      expect(state.get().presentation?.duration).toBe(90.75);
+      expect(state.presentation.get()?.duration).toBe(90.75);
     });
 
     cleanup();
   });
 
   it('does not recalculate when duration already set', async () => {
-    const state = signal<PresentationDurationState>({
+    const state = makeState({
       presentation: createPresentation({
         duration: 60,
         video: [
@@ -345,23 +341,22 @@ describe('calculatePresentationDuration', () => {
       selectedVideoTrackId: 'video-1',
     });
 
-    const cleanup = calculatePresentationDuration({ state });
+    const cleanup = calculatePresentationDuration.setup({ state });
 
     await new Promise((resolve) => setTimeout(resolve, 50));
 
-    expect(state.get().presentation?.duration).toBe(60);
+    expect(state.presentation.get()?.duration).toBe(60);
 
     cleanup();
   });
 
   it('does not set invalid durations', async () => {
-    const state = signal<PresentationDurationState>({});
+    const state = makeState();
 
-    const cleanup = calculatePresentationDuration({ state });
+    const cleanup = calculatePresentationDuration.setup({ state });
 
-    state.set({
-      ...state.get(),
-      presentation: createPresentation({
+    state.presentation.set(
+      createPresentation({
         video: [
           {
             id: 'video-1',
@@ -376,13 +371,13 @@ describe('calculatePresentationDuration', () => {
             initialization: { id: 'init', url: 'http://example.com/init.mp4' },
           } as VideoTrack,
         ],
-      }),
-      selectedVideoTrackId: 'video-1',
-    });
+      })
+    );
+    state.selectedVideoTrackId.set('video-1');
 
     await new Promise((resolve) => setTimeout(resolve, 50));
 
-    expect(state.get().presentation?.duration).toBeUndefined();
+    expect(state.presentation.get()?.duration).toBeUndefined();
 
     cleanup();
   });
diff --git a/packages/spf/src/playback/behaviors/tests/quality-switching.test.ts b/packages/spf/src/playback/behaviors/tests/quality-switching.test.ts
index ee1c25ae..e7322008 100644
--- a/packages/spf/src/playback/behaviors/tests/quality-switching.test.ts
+++ b/packages/spf/src/playback/behaviors/tests/quality-switching.test.ts
@@ -1,7 +1,13 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { StateSignals } from '../../../core/composition/create-composition';
 import { signal } from '../../../core/signals/primitives';
 import type { BandwidthState } from '../../../media/abr/bandwidth-estimator';
-import type { PartiallyResolvedVideoTrack, Presentation, VideoSelectionSet } from '../../../media/types';
+import type {
+  MaybeResolvedPresentation,
+  PartiallyResolvedVideoTrack,
+  Presentation,
+  VideoSelectionSet,
+} from '../../../media/types';
 import {
   DEFAULT_SWITCHING_CONFIG,
   type QualitySwitchingConfig,
@@ -13,6 +19,15 @@ import {
 // Test helpers
 // ============================================================================
 
+function makeState(initial: QualitySwitchingState = {}): StateSignals<QualitySwitchingState> {
+  return {
+    presentation: signal<MaybeResolvedPresentation | undefined>(initial.presentation),
+    bandwidthState: signal<BandwidthState | undefined>(initial.bandwidthState),
+    selectedVideoTrackId: signal<string | undefined>(initial.selectedVideoTrackId),
+    abrDisabled: signal<boolean | undefined>(initial.abrDisabled),
+  };
+}
+
 const createVideoTrack = (id: string, bandwidth: number): PartiallyResolvedVideoTrack => ({
   type: 'video',
   codecs: [],
@@ -41,25 +56,18 @@ const createPresentation = (tracks: PartiallyResolvedVideoTrack[]): Presentation
     ],
   }) as Presentation;
 
-/**
- * Creates a BandwidthState with sufficient samples for a reliable estimate.
- * fastEstimate/slowEstimate are set directly to the target bps value.
- * With totalWeight=100, the zero-factor correction is ~1.0, so getBandwidthEstimate
- * returns approximately the provided value.
- */
 const createBandwidthState = (bps: number): BandwidthState => ({
   fastEstimate: bps,
   fastTotalWeight: 100,
   slowEstimate: bps,
   slowTotalWeight: 100,
-  bytesSampled: 500_000, // Well above minTotalBytes (128 KB) — real estimate used
+  bytesSampled: 500_000,
 });
 
 // Flush two levels of microtasks: one to fire the subscriber, one to process
 // any state.patch() the subscriber itself triggers.
 const flush = () => Promise.resolve().then(() => Promise.resolve());
 
-// ABR ladder used across multiple tests
 const tracks = [
   createVideoTrack('360p', 600_000),
   createVideoTrack('720p', 2_400_000),
@@ -81,24 +89,24 @@ describe('switchQuality', () => {
 
   describe('no-op conditions', () => {
     it('does nothing without a presentation', () => {
-      const state = signal<QualitySwitchingState>({
+      const state = makeState({
         bandwidthState: createBandwidthState(3_000_000),
         selectedVideoTrackId: '720p',
       });
 
-      const cleanup = switchQuality({ state });
-      expect(state.get().selectedVideoTrackId).toBe('720p');
+      const cleanup = switchQuality.setup({ state });
+      expect(state.selectedVideoTrackId.get()).toBe('720p');
       cleanup();
     });
 
     it('does nothing without bandwidthState', () => {
-      const state = signal<QualitySwitchingState>({
+      const state = makeState({
         presentation: createPresentation(tracks),
         selectedVideoTrackId: '360p',
       });
 
-      const cleanup = switchQuality({ state });
-      expect(state.get().selectedVideoTrackId).toBe('360p');
+      const cleanup = switchQuality.setup({ state });
+      expect(state.selectedVideoTrackId.get()).toBe('360p');
       cleanup();
     });
 
@@ -108,81 +116,74 @@ describe('switchQuality', () => {
         url: 'https://example.com/playlist.m3u8',
         selectionSets: [],
       };
-      const state = signal<QualitySwitchingState>({
+      const state = makeState({
         presentation: emptyPresentation,
         bandwidthState: createBandwidthState(3_000_000),
         selectedVideoTrackId: '720p',
       });
 
-      const cleanup = switchQuality({ state });
-      expect(state.get().selectedVideoTrackId).toBe('720p');
+      const cleanup = switchQuality.setup({ state });
+      expect(state.selectedVideoTrackId.get()).toBe('720p');
       cleanup();
     });
 
     it('does nothing when already on the optimal track', () => {
-      const state = signal<QualitySwitchingState>({
+      const state = makeState({
         presentation: createPresentation(tracks),
-        // ~3 Mbps → optimal is 720p with default safety margin
         bandwidthState: createBandwidthState(3_000_000),
         selectedVideoTrackId: '720p',
       });
 
-      const cleanup = switchQuality({ state });
-      expect(state.get().selectedVideoTrackId).toBe('720p');
+      const cleanup = switchQuality.setup({ state });
+      expect(state.selectedVideoTrackId.get()).toBe('720p');
       cleanup();
     });
   });
 
   describe('initial selection', () => {
     it('selects optimal track on first bandwidth estimate when no track is selected', () => {
-      const state = signal<QualitySwitchingState>({
+      const state = makeState({
         presentation: createPresentation(tracks),
         bandwidthState: createBandwidthState(3_000_000),
-        // No selectedVideoTrackId yet
       });
 
-      const cleanup = switchQuality({ state });
-      // Initial subscriber fire is synchronous — result visible via #pending
-      // 3 Mbps → 720p fits (needs 2.4M/0.85 ≈ 2.82 Mbps), 1080p doesn't
-      expect(state.get().selectedVideoTrackId).toBe('720p');
+      const cleanup = switchQuality.setup({ state });
+      expect(state.selectedVideoTrackId.get()).toBe('720p');
       cleanup();
     });
   });
 
   describe('downgrade', () => {
     it('downgrades immediately when bandwidth drops below current quality threshold', async () => {
-      const state = signal<QualitySwitchingState>({
+      const state = makeState({
         presentation: createPresentation(tracks),
         bandwidthState: createBandwidthState(3_000_000),
         selectedVideoTrackId: '720p',
       });
 
-      const cleanup = switchQuality({ state });
-      expect(state.get().selectedVideoTrackId).toBe('720p');
+      const cleanup = switchQuality.setup({ state });
+      expect(state.selectedVideoTrackId.get()).toBe('720p');
 
-      // Bandwidth drops — 800 Kbps can only fit 360p (needs 600K/0.85 ≈ 706 Kbps)
-      state.set({ ...state.get(), bandwidthState: createBandwidthState(800_000) });
+      state.bandwidthState.set(createBandwidthState(800_000));
       await flush();
-      expect(state.get().selectedVideoTrackId).toBe('360p');
+      expect(state.selectedVideoTrackId.get()).toBe('360p');
 
       cleanup();
     });
 
     it('does not apply upgrade interval to downgrades', async () => {
-      const state = signal<QualitySwitchingState>({
+      const state = makeState({
         presentation: createPresentation(tracks),
         bandwidthState: createBandwidthState(6_000_000),
         selectedVideoTrackId: '360p',
       });
 
-      const cleanup = switchQuality({ state });
-      // First fire (synchronous): upgrade 360p → 1080p since 6 Mbps fits
-      expect(state.get().selectedVideoTrackId).toBe('1080p');
+      const cleanup = switchQuality.setup({ state });
+      expect(state.selectedVideoTrackId.get()).toBe('1080p');
 
-      // Immediately drop bandwidth (no time passes) — should still downgrade
-      state.set({ ...state.get(), bandwidthState: createBandwidthState(700_000) });
+      state.bandwidthState.set(createBandwidthState(700_000));
       await flush();
-      expect(state.get().selectedVideoTrackId).toBe('360p');
+      expect(state.selectedVideoTrackId.get()).toBe('360p');
 
       cleanup();
     });
@@ -190,66 +191,59 @@ describe('switchQuality', () => {
 
   describe('upgrade', () => {
     it('upgrades after bandwidth improves and minUpgradeInterval has passed', async () => {
-      const state = signal<QualitySwitchingState>({
+      const state = makeState({
         presentation: createPresentation(tracks),
         bandwidthState: createBandwidthState(800_000),
         selectedVideoTrackId: '360p',
       });
 
-      const cleanup = switchQuality({ state });
-      expect(state.get().selectedVideoTrackId).toBe('360p');
+      const cleanup = switchQuality.setup({ state });
+      expect(state.selectedVideoTrackId.get()).toBe('360p');
 
-      // Bandwidth improves but not enough time has passed since creation
-      state.set({ ...state.get(), bandwidthState: createBandwidthState(3_000_000) });
+      state.bandwidthState.set(createBandwidthState(3_000_000));
       await flush();
-      expect(state.get().selectedVideoTrackId).toBe('360p'); // blocked
+      expect(state.selectedVideoTrackId.get()).toBe('360p');
 
-      // Advance time past the upgrade interval
       vi.advanceTimersByTime(DEFAULT_SWITCHING_CONFIG.minUpgradeInterval + 1);
 
-      // Trigger another state change to re-evaluate
-      state.set({ ...state.get(), bandwidthState: createBandwidthState(3_000_000) });
+      state.bandwidthState.set(createBandwidthState(3_000_000));
       await flush();
-      expect(state.get().selectedVideoTrackId).toBe('720p');
+      expect(state.selectedVideoTrackId.get()).toBe('720p');
 
       cleanup();
     });
 
     it('upgrades immediately on first switch (no prior upgrade)', () => {
-      const state = signal<QualitySwitchingState>({
+      const state = makeState({
         presentation: createPresentation(tracks),
         bandwidthState: createBandwidthState(3_000_000),
         selectedVideoTrackId: '360p',
       });
 
-      const cleanup = switchQuality({ state });
-      // Initial fire is synchronous — upgrade happens in the subscribe callback
-      expect(state.get().selectedVideoTrackId).toBe('720p');
+      const cleanup = switchQuality.setup({ state });
+      expect(state.selectedVideoTrackId.get()).toBe('720p');
       cleanup();
     });
 
     it('blocks second upgrade until interval passes', async () => {
-      const state = signal<QualitySwitchingState>({
+      const state = makeState({
         presentation: createPresentation(tracks),
         bandwidthState: createBandwidthState(3_000_000),
         selectedVideoTrackId: '360p',
       });
 
-      const cleanup = switchQuality({ state });
-      // First upgrade: 360p → 720p (initial synchronous fire, no cooldown)
-      expect(state.get().selectedVideoTrackId).toBe('720p');
+      const cleanup = switchQuality.setup({ state });
+      expect(state.selectedVideoTrackId.get()).toBe('720p');
 
-      // Bandwidth jumps to 6 Mbps shortly after — 1080p desired but blocked
       vi.advanceTimersByTime(1000);
-      state.set({ ...state.get(), bandwidthState: createBandwidthState(6_000_000) });
+      state.bandwidthState.set(createBandwidthState(6_000_000));
       await flush();
-      expect(state.get().selectedVideoTrackId).toBe('720p'); // blocked
+      expect(state.selectedVideoTrackId.get()).toBe('720p');
 
-      // After interval, upgrade proceeds
       vi.advanceTimersByTime(DEFAULT_SWITCHING_CONFIG.minUpgradeInterval + 1);
-      state.set({ ...state.get(), bandwidthState: createBandwidthState(6_000_000) });
+      state.bandwidthState.set(createBandwidthState(6_000_000));
       await flush();
-      expect(state.get().selectedVideoTrackId).toBe('1080p');
+      expect(state.selectedVideoTrackId.get()).toBe('1080p');
 
       cleanup();
     });
@@ -257,84 +251,76 @@ describe('switchQuality', () => {
 
   describe('configuration', () => {
     it('uses custom safetyMargin', () => {
-      const state = signal<QualitySwitchingState>({
+      const state = makeState({
         presentation: createPresentation(tracks),
-        // With safetyMargin=1.0, requiredBandwidth == trackBandwidth (no headroom)
-        // 3 Mbps: 720p (2.4M) fits, 1080p (4.8M) does not
         bandwidthState: createBandwidthState(3_000_000),
         selectedVideoTrackId: '360p',
       });
 
       const config: QualitySwitchingConfig = { safetyMargin: 1.0 };
-      const cleanup = switchQuality({ state }, config);
-      expect(state.get().selectedVideoTrackId).toBe('720p');
+      const cleanup = switchQuality.setup({ state, config });
+      expect(state.selectedVideoTrackId.get()).toBe('720p');
       cleanup();
     });
 
     it('uses custom minUpgradeInterval', async () => {
-      const state = signal<QualitySwitchingState>({
+      const state = makeState({
         presentation: createPresentation(tracks),
         bandwidthState: createBandwidthState(800_000),
         selectedVideoTrackId: '360p',
       });
 
       const config: QualitySwitchingConfig = { minUpgradeInterval: 2000 };
-      const cleanup = switchQuality({ state }, config);
+      const cleanup = switchQuality.setup({ state, config });
 
-      // Bandwidth improves — blocked by interval
-      state.set({ ...state.get(), bandwidthState: createBandwidthState(3_000_000) });
+      state.bandwidthState.set(createBandwidthState(3_000_000));
       await flush();
-      expect(state.get().selectedVideoTrackId).toBe('360p'); // blocked
+      expect(state.selectedVideoTrackId.get()).toBe('360p');
 
-      // Advance only 2000ms (custom interval)
       vi.advanceTimersByTime(2001);
-      state.set({ ...state.get(), bandwidthState: createBandwidthState(3_000_000) });
+      state.bandwidthState.set(createBandwidthState(3_000_000));
       await flush();
-      expect(state.get().selectedVideoTrackId).toBe('720p');
+      expect(state.selectedVideoTrackId.get()).toBe('720p');
 
       cleanup();
     });
 
-    it('uses defaultBandwidth when estimate is not yet reliable (insufficient samples)', () => {
+    it('uses initialBandwidth when estimate is not yet reliable (insufficient samples)', () => {
       const unreliableState: BandwidthState = {
         fastEstimate: 0,
         fastTotalWeight: 0,
         slowEstimate: 0,
         slowTotalWeight: 0,
-        bytesSampled: 0, // No samples → hasGoodEstimate is false
+        bytesSampled: 0,
       };
 
-      const state = signal<QualitySwitchingState>({
+      const state = makeState({
         presentation: createPresentation(tracks),
         bandwidthState: unreliableState,
         selectedVideoTrackId: '360p',
       });
 
-      // With defaultBandwidth=5 Mbps: 720p (needs 2.4M/0.85 ≈ 2.82M) fits,
-      // 1080p (needs 4.8M/0.85 ≈ 5.65M) does not → selects 720p
-      const config: QualitySwitchingConfig = { defaultBandwidth: 5_000_000 };
-      const cleanup = switchQuality({ state }, config);
-      expect(state.get().selectedVideoTrackId).toBe('720p');
+      const config: QualitySwitchingConfig = { initialBandwidth: 5_000_000 };
+      const cleanup = switchQuality.setup({ state, config });
+      expect(state.selectedVideoTrackId.get()).toBe('720p');
       cleanup();
     });
   });
 
   describe('cleanup', () => {
     it('stops reacting after cleanup', () => {
-      const state = signal<QualitySwitchingState>({
+      const state = makeState({
         presentation: createPresentation(tracks),
         bandwidthState: createBandwidthState(800_000),
         selectedVideoTrackId: '360p',
       });
 
-      const cleanup = switchQuality({ state });
+      const cleanup = switchQuality.setup({ state });
       cleanup();
 
-      // After cleanup, bandwidth changes should not trigger switches
       vi.advanceTimersByTime(DEFAULT_SWITCHING_CONFIG.minUpgradeInterval + 1);
-      state.set({ ...state.get(), bandwidthState: createBandwidthState(6_000_000) });
-      // No await needed — no subscriber fires after cleanup
-      expect(state.get().selectedVideoTrackId).toBe('360p');
+      state.bandwidthState.set(createBandwidthState(6_000_000));
+      expect(state.selectedVideoTrackId.get()).toBe('360p');
     });
   });
 });
diff --git a/packages/spf/src/playback/behaviors/tests/resolve-presentation.test.ts b/packages/spf/src/playback/behaviors/tests/resolve-presentation.test.ts
index 585441db..ac030861 100644
--- a/packages/spf/src/playback/behaviors/tests/resolve-presentation.test.ts
+++ b/packages/spf/src/playback/behaviors/tests/resolve-presentation.test.ts
@@ -1,25 +1,25 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { StateSignals } from '../../../core/composition/create-composition';
 import { signal } from '../../../core/signals/primitives';
 import type { MaybeResolvedPresentation, Presentation } from '../../../media/types';
-import { resolvePresentation, shouldResolve } from '../resolve-presentation';
+import { type PresentationState, resolvePresentation, shouldResolve } from '../resolve-presentation';
+
+function makeState(initial: PresentationState = {}): StateSignals<PresentationState> {
+  return {
+    presentation: signal<MaybeResolvedPresentation | undefined>(initial.presentation),
+    preload: signal<'auto' | 'metadata' | 'none' | undefined>(initial.preload),
+    playbackInitiated: signal<boolean | undefined>(initial.playbackInitiated),
+  };
+}
 
 describe('resolvePresentation', () => {
   afterEach(() => {
     vi.restoreAllMocks();
   });
+
   it('resolves unresolved presentation', async () => {
-    // Arrange
-    interface State {
-      presentation?: MaybeResolvedPresentation;
-      preload?: 'auto' | 'metadata' | 'none' | undefined;
-    }
+    const state = makeState({ preload: 'auto' });
 
-    const state = signal<State>({
-      presentation: undefined,
-      preload: 'auto',
-    });
-
-    // Mock fetch
     vi.spyOn(globalThis, 'fetch').mockResolvedValue(
       new Response(`#EXTM3U
 #EXT-X-STREAM-INF:BANDWIDTH=1000000
@@ -28,49 +28,36 @@ variant1.m3u8
 variant2.m3u8`)
     );
 
-    // Act
-    const reactor = resolvePresentation({ state });
+    const reactor = resolvePresentation.setup({ state });
 
-    // Trigger resolution by setting unresolved presentation
-    state.set({ ...state.get(), presentation: { url: 'http://example.com/playlist.m3u8' } });
+    state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
 
-    // Wait for resolution
     await vi.waitFor(() => {
-      const current = state.get();
-      expect(current.presentation).toBeDefined();
-      expect(current.presentation).toHaveProperty('id');
-      expect(current.presentation).toHaveProperty('selectionSets');
+      const pres = state.presentation.get();
+      expect(pres).toBeDefined();
+      expect(pres).toHaveProperty('id');
+      expect(pres).toHaveProperty('selectionSets');
     });
 
-    // Assert
-    const resolved = state.get().presentation as Presentation;
+    const resolved = state.presentation.get() as Presentation;
     expect(resolved.url).toBe('http://example.com/playlist.m3u8');
     expect(resolved.selectionSets).toBeDefined();
     expect(resolved.selectionSets.length).toBeGreaterThan(0);
 
-    // Check that we have video tracks
     const videoSet = resolved.selectionSets.find((s) => s.type === 'video');
     expect(videoSet).toBeDefined();
     expect(videoSet!.switchingSets).toBeDefined();
     expect(videoSet!.switchingSets[0]?.tracks.length).toBeGreaterThan(0);
 
-    // Cleanup
     reactor.destroy();
   });
 
   it('does not trigger resolution when other state fields change', async () => {
-    // Arrange
-    interface State {
-      presentation?: MaybeResolvedPresentation;
-      preload?: 'auto' | 'metadata' | 'none' | undefined;
-      volume: number;
-    }
-
-    const state = signal<State>({
-      presentation: undefined,
-      preload: 'auto',
-      volume: 1.0,
-    });
+    // The new discrete-signals shape eliminates the "any unrelated field
+    // change re-runs the effect" footgun by construction — each derived
+    // computed only tracks the signals it reads. This test is preserved as
+    // a behavioural assertion: only `presentation` triggers fetch.
+    const state = makeState({ preload: 'auto' });
 
     const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(
       new Response(`#EXTM3U
@@ -78,86 +65,60 @@ variant2.m3u8`)
 variant1.m3u8`)
     );
 
-    // Act
-    const reactor = resolvePresentation({ state });
+    const reactor = resolvePresentation.setup({ state });
 
-    // Change volume before resolution
-    state.set({ ...state.get(), volume: 0.5 });
-
-    // Wait a bit to ensure no fetch triggered
+    // No URL yet — flipping preload shouldn't trigger fetch.
+    state.preload.set('metadata');
     await new Promise((resolve) => setTimeout(resolve, 50));
     expect(fetchSpy).not.toHaveBeenCalled();
 
-    // Now add unresolved presentation
-    state.set({ ...state.get(), presentation: { url: 'http://example.com/playlist.m3u8' } });
+    state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
 
-    // Wait for resolution
     await vi.waitFor(() => {
-      expect(state.get().presentation).toHaveProperty('id');
+      expect(state.presentation.get()).toHaveProperty('id');
     });
 
     expect(fetchSpy).toHaveBeenCalledOnce();
     fetchSpy.mockClear();
 
-    // Change volume after resolution
-    state.set({ ...state.get(), volume: 0.8 });
-
-    // Wait a bit to ensure no additional fetch
+    // Flipping preload after resolution shouldn't re-fetch.
+    state.preload.set('auto');
     await new Promise((resolve) => setTimeout(resolve, 50));
     expect(fetchSpy).not.toHaveBeenCalled();
 
-    // Cleanup
     reactor.destroy();
   });
 
   it('resolves presentation initialized as unresolved', async () => {
-    // Arrange
-    interface State {
-      presentation?: MaybeResolvedPresentation;
-      preload?: 'auto' | 'metadata' | 'none' | undefined;
-    }
-
     vi.spyOn(globalThis, 'fetch').mockResolvedValue(
       new Response(`#EXTM3U
 #EXT-X-STREAM-INF:BANDWIDTH=1000000
 variant1.m3u8`)
     );
 
-    // State starts with unresolved presentation
-    const state = signal<State>({
+    const state = makeState({
       presentation: { url: 'http://example.com/initial.m3u8' },
       preload: 'auto',
     });
 
-    // Act
-    const reactor = resolvePresentation({ state });
+    const reactor = resolvePresentation.setup({ state });
 
-    // Wait for resolution (should happen automatically)
     await vi.waitFor(() => {
-      const current = state.get();
-      expect(current.presentation).toHaveProperty('id');
-      expect(current.presentation).toHaveProperty('selectionSets');
+      const pres = state.presentation.get();
+      expect(pres).toHaveProperty('id');
+      expect(pres).toHaveProperty('selectionSets');
     });
 
-    // Assert
-    const resolved = state.get().presentation as Presentation;
+    const resolved = state.presentation.get() as Presentation;
     expect(resolved.url).toBe('http://example.com/initial.m3u8');
     expect(resolved.selectionSets).toBeDefined();
 
-    // Cleanup
     reactor.destroy();
   });
 
   it('does not re-resolve presentation initialized as resolved', async () => {
-    // Arrange
-    interface State {
-      presentation?: MaybeResolvedPresentation;
-      preload?: 'auto' | 'metadata' | 'none' | undefined;
-    }
-
     const fetchSpy = vi.spyOn(globalThis, 'fetch');
 
-    // Create a resolved presentation
     const resolvedPresentation: Presentation = {
       id: 'pres-1',
       url: 'http://example.com/resolved.m3u8',
@@ -186,40 +147,25 @@ variant1.m3u8`)
       startTime: 0,
     };
 
-    // State starts with resolved presentation
-    const state = signal<State>({
-      presentation: resolvedPresentation,
-      preload: 'auto',
-    });
+    const state = makeState({ presentation: resolvedPresentation, preload: 'auto' });
 
-    // Act
-    const reactor = resolvePresentation({ state });
+    const reactor = resolvePresentation.setup({ state });
 
-    // Wait a bit to ensure no fetch triggered
     await new Promise((resolve) => setTimeout(resolve, 50));
 
-    // Assert - should not fetch
     expect(fetchSpy).not.toHaveBeenCalled();
-    expect(state.get().presentation).toBe(resolvedPresentation);
+    expect(state.presentation.get()).toBe(resolvedPresentation);
 
-    // Cleanup
     reactor.destroy();
   });
 
   it('resolves new unresolved presentation after resolved one', async () => {
-    // Arrange
-    interface State {
-      presentation?: MaybeResolvedPresentation;
-      preload?: 'auto' | 'metadata' | 'none' | undefined;
-    }
-
     const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(
       new Response(`#EXTM3U
 #EXT-X-STREAM-INF:BANDWIDTH=2000000
 variant2.m3u8`)
     );
 
-    // Create initial resolved presentation
     const resolvedPresentation: Presentation = {
       id: 'pres-1',
       url: 'http://example.com/first.m3u8',
@@ -227,131 +173,104 @@ variant2.m3u8`)
       startTime: 0,
     };
 
-    const state = signal<State>({
-      presentation: resolvedPresentation,
-      preload: 'auto',
-    });
+    const state = makeState({ presentation: resolvedPresentation, preload: 'auto' });
 
-    // Act
-    const reactor = resolvePresentation({ state });
+    const reactor = resolvePresentation.setup({ state });
 
-    // Replace with unresolved presentation
-    state.set({ ...state.get(), presentation: { url: 'http://example.com/second.m3u8' } });
+    state.presentation.set({ url: 'http://example.com/second.m3u8' });
 
-    // Wait for resolution
     await vi.waitFor(() => {
-      const current = state.get();
-      expect(current.presentation).toHaveProperty('id');
-      expect((current.presentation as Presentation).url).toBe('http://example.com/second.m3u8');
+      const pres = state.presentation.get();
+      expect(pres).toHaveProperty('id');
+      expect((pres as Presentation).url).toBe('http://example.com/second.m3u8');
     });
 
-    // Assert - should have fetched and resolved new presentation
     expect(fetchSpy).toHaveBeenCalledOnce();
-    const resolved = state.get().presentation as Presentation;
+    const resolved = state.presentation.get() as Presentation;
     expect(resolved.url).toBe('http://example.com/second.m3u8');
     expect(resolved.selectionSets).toBeDefined();
 
-    // Cleanup
     reactor.destroy();
   });
 
   describe('preload policy', () => {
     it('resolves when preload is "auto"', async () => {
-      interface State {
-        presentation?: MaybeResolvedPresentation;
-        preload?: 'auto' | 'metadata' | 'none' | undefined;
-      }
-
       vi.spyOn(globalThis, 'fetch').mockResolvedValue(
         new Response(`#EXTM3U
 #EXT-X-STREAM-INF:BANDWIDTH=1000000
 variant1.m3u8`)
       );
 
-      const state = signal<State>({
+      const state = makeState({
         presentation: { url: 'http://example.com/playlist.m3u8' },
         preload: 'auto',
       });
 
-      const reactor = resolvePresentation({ state });
+      const reactor = resolvePresentation.setup({ state });
 
       await vi.waitFor(() => {
-        expect(state.get().presentation).toHaveProperty('id');
+        expect(state.presentation.get()).toHaveProperty('id');
       });
 
       reactor.destroy();
     });
 
     it('resolves when preload is "metadata"', async () => {
-      interface State {
-        presentation?: MaybeResolvedPresentation;
-        preload?: 'auto' | 'metadata' | 'none' | undefined;
-      }
-
       vi.spyOn(globalThis, 'fetch').mockResolvedValue(
         new Response(`#EXTM3U
 #EXT-X-STREAM-INF:BANDWIDTH=1000000
 variant1.m3u8`)
       );
 
-      const state = signal<State>({
+      const state = makeState({
         presentation: { url: 'http://example.com/playlist.m3u8' },
         preload: 'metadata',
       });
 
-      const reactor = resolvePresentation({ state });
+      const reactor = resolvePresentation.setup({ state });
 
       await vi.waitFor(() => {
-        expect(state.get().presentation).toHaveProperty('id');
+        expect(state.presentation.get()).toHaveProperty('id');
       });
 
       reactor.destroy();
     });
 
     it('does not resolve when preload is "none"', async () => {
-      interface State {
-        presentation?: MaybeResolvedPresentation;
-        preload?: 'auto' | 'metadata' | 'none' | undefined;
-      }
-
       const fetchSpy = vi.spyOn(globalThis, 'fetch');
 
-      const state = signal<State>({
+      const state = makeState({
         presentation: { url: 'http://example.com/playlist.m3u8' },
         preload: 'none',
       });
 
-      const reactor = resolvePresentation({ state });
+      const reactor = resolvePresentation.setup({ state });
 
       await new Promise((resolve) => setTimeout(resolve, 50));
 
       expect(fetchSpy).not.toHaveBeenCalled();
-      expect(state.get().presentation?.url).toBe('http://example.com/playlist.m3u8');
-      expect(state.get().presentation).not.toHaveProperty('id');
+      // Presentation slot still holds the unresolved input (URL only, no `id`).
+      expect(state.presentation.get()?.url).toBe('http://example.com/playlist.m3u8');
+      expect(state.presentation.get()).not.toHaveProperty('id');
 
       reactor.destroy();
     });
 
     it('does not resolve when preload is undefined', async () => {
-      interface State {
-        presentation?: MaybeResolvedPresentation;
-        preload?: 'auto' | 'metadata' | 'none' | undefined;
-      }
-
       const fetchSpy = vi.spyOn(globalThis, 'fetch');
 
-      const state = signal<State>({
+      const state = makeState({
         presentation: { url: 'http://example.com/playlist.m3u8' },
-        preload: undefined,
       });
 
-      const reactor = resolvePresentation({ state });
+      const reactor = resolvePresentation.setup({ state });
 
       await new Promise((resolve) => setTimeout(resolve, 50));
 
       expect(fetchSpy).not.toHaveBeenCalled();
-      expect(state.get().presentation?.url).toBe('http://example.com/playlist.m3u8');
-      expect(state.get().presentation).not.toHaveProperty('id');
+      // Presentation slot still holds the unresolved input (URL only, no `id`).
+      expect(state.presentation.get()?.url).toBe('http://example.com/playlist.m3u8');
+      expect(state.presentation.get()).not.toHaveProperty('id');
 
       reactor.destroy();
     });
@@ -359,34 +278,25 @@ variant1.m3u8`)
 
   describe('playbackInitiated resolution', () => {
     it('resolves when playbackInitiated is set to true with preload "none"', async () => {
-      interface State {
-        presentation?: MaybeResolvedPresentation;
-        preload?: 'auto' | 'metadata' | 'none' | undefined;
-        playbackInitiated?: boolean;
-      }
-
       const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(
         new Response(`#EXTM3U
 #EXT-X-STREAM-INF:BANDWIDTH=1000000
 variant1.m3u8`)
       );
 
-      const state = signal<State>({
+      const state = makeState({
         presentation: { url: 'http://example.com/playlist.m3u8' },
         preload: 'none',
       });
 
-      const reactor = resolvePresentation({ state });
+      const reactor = resolvePresentation.setup({ state });
 
-      // Initially shouldn't fetch (preload="none", not yet initiated)
       expect(fetchSpy).not.toHaveBeenCalled();
 
-      // Set playbackInitiated (replaces the old 'play' event dispatch)
-      state.set({ ...state.get(), playbackInitiated: true });
+      state.playbackInitiated.set(true);
 
-      // Wait for resolution
       await vi.waitFor(() => {
-        expect(state.get().presentation).toHaveProperty('id');
+        expect(state.presentation.get()).toHaveProperty('id');
       });
 
       expect(fetchSpy).toHaveBeenCalledOnce();
@@ -395,26 +305,21 @@ variant1.m3u8`)
     });
 
     it('does not resolve when playbackInitiated is false with preload "none"', async () => {
-      interface State {
-        presentation?: MaybeResolvedPresentation;
-        preload?: 'auto' | 'metadata' | 'none' | undefined;
-        playbackInitiated?: boolean;
-      }
-
       const fetchSpy = vi.spyOn(globalThis, 'fetch');
 
-      const state = signal<State>({
+      const state = makeState({
         presentation: { url: 'http://example.com/playlist.m3u8' },
         preload: 'none',
       });
 
-      const reactor = resolvePresentation({ state });
+      const reactor = resolvePresentation.setup({ state });
 
       await new Promise((resolve) => setTimeout(resolve, 50));
 
       expect(fetchSpy).not.toHaveBeenCalled();
-      expect(state.get().presentation?.url).toBe('http://example.com/playlist.m3u8');
-      expect(state.get().presentation).not.toHaveProperty('id');
+      // Presentation slot still holds the unresolved input (URL only, no `id`).
+      expect(state.presentation.get()?.url).toBe('http://example.com/playlist.m3u8');
+      expect(state.presentation.get()).not.toHaveProperty('id');
 
       reactor.destroy();
     });
@@ -422,45 +327,33 @@ variant1.m3u8`)
 
   describe('deduplication', () => {
     it('does not trigger multiple fetches for same presentation', async () => {
-      interface State {
-        presentation?: MaybeResolvedPresentation;
-        preload?: 'auto' | 'metadata' | 'none' | undefined;
-      }
-
       const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(
         new Response(`#EXTM3U
 #EXT-X-STREAM-INF:BANDWIDTH=1000000
 variant1.m3u8`)
       );
 
-      const state = signal<State>({
+      const state = makeState({
         presentation: { url: 'http://example.com/playlist.m3u8' },
         preload: 'auto',
       });
 
-      const reactor = resolvePresentation({ state });
+      const reactor = resolvePresentation.setup({ state });
 
-      // Rapidly trigger additional state changes while resolution is in progress
-      state.set({ ...state.get(), preload: 'auto' });
-      state.set({ ...state.get(), preload: 'auto' });
+      // Rapid no-op updates — preload doesn't change semantically.
+      state.preload.set('auto');
+      state.preload.set('auto');
 
-      // Wait for resolution
       await vi.waitFor(() => {
-        expect(state.get().presentation).toHaveProperty('id');
+        expect(state.presentation.get()).toHaveProperty('id');
       });
 
-      // Should only fetch once despite multiple state changes
       expect(fetchSpy).toHaveBeenCalledOnce();
 
       reactor.destroy();
     });
 
     it('allows resolving different presentations sequentially', async () => {
-      interface State {
-        presentation?: MaybeResolvedPresentation;
-        preload?: 'auto' | 'metadata' | 'none' | undefined;
-      }
-
       const fetchSpy = vi.spyOn(globalThis, 'fetch').mockImplementation(
         async () =>
           new Response(`#EXTM3U
@@ -468,31 +361,27 @@ variant1.m3u8`)
 variant1.m3u8`)
       );
 
-      const state = signal<State>({
+      const state = makeState({
         presentation: { url: 'http://example.com/first.m3u8' },
         preload: 'auto',
       });
 
-      const reactor = resolvePresentation({ state });
+      const reactor = resolvePresentation.setup({ state });
 
-      // Wait for first resolution
       await vi.waitFor(() => {
-        expect(state.get().presentation).toHaveProperty('id');
+        expect(state.presentation.get()).toHaveProperty('id');
       });
 
       expect(fetchSpy).toHaveBeenCalledOnce();
 
-      // Now load a different presentation (overwrites the resolved one with an unresolved one)
-      state.set({ ...state.get(), presentation: { url: 'http://example.com/second.m3u8' } });
+      state.presentation.set({ url: 'http://example.com/second.m3u8' });
 
-      // Wait for second resolution — check id to confirm the fetch actually completed
       await vi.waitFor(() => {
-        const pres = state.get().presentation as Presentation;
+        const pres = state.presentation.get() as Presentation;
         expect(pres).toHaveProperty('id');
         expect(pres.url).toBe('http://example.com/second.m3u8');
       });
 
-      // Should have fetched twice (different URLs)
       expect(fetchSpy).toHaveBeenCalledTimes(2);
 
       reactor.destroy();
@@ -502,20 +391,12 @@ variant1.m3u8`)
 
 describe('shouldResolve', () => {
   it('returns true when preload is "auto"', () => {
-    const result = shouldResolve({
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-      preload: 'auto',
-    });
-
+    const result = shouldResolve({ presentation: { url: 'http://example.com/playlist.m3u8' }, preload: 'auto' });
     expect(result).toBe(true);
   });
 
   it('returns true when preload is "metadata"', () => {
-    const result = shouldResolve({
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-      preload: 'metadata',
-    });
-
+    const result = shouldResolve({ presentation: { url: 'http://example.com/playlist.m3u8' }, preload: 'metadata' });
     expect(result).toBe(true);
   });
 
@@ -525,16 +406,11 @@ describe('shouldResolve', () => {
       preload: 'none',
       playbackInitiated: true,
     });
-
     expect(result).toBe(true);
   });
 
   it('returns false when preload is "none" and playbackInitiated is false', () => {
-    const result = shouldResolve({
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-      preload: 'none',
-    });
-
+    const result = shouldResolve({ presentation: { url: 'http://example.com/playlist.m3u8' }, preload: 'none' });
     expect(result).toBe(false);
   });
 
@@ -543,7 +419,6 @@ describe('shouldResolve', () => {
       presentation: { url: 'http://example.com/playlist.m3u8' },
       preload: undefined,
     });
-
     expect(result).toBe(false);
   });
 });
diff --git a/packages/spf/src/playback/behaviors/tests/resolve-track.test.ts b/packages/spf/src/playback/behaviors/tests/resolve-track.test.ts
index ac4769f6..cc67dd73 100644
--- a/packages/spf/src/playback/behaviors/tests/resolve-track.test.ts
+++ b/packages/spf/src/playback/behaviors/tests/resolve-track.test.ts
@@ -1,4 +1,5 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { StateSignals } from '../../../core/composition/create-composition';
 import { signal } from '../../../core/signals/primitives';
 import type {
   MaybeResolvedPresentation,
@@ -8,16 +9,23 @@ import type {
   Presentation,
 } from '../../../media/types';
 import { isResolvedTrack } from '../../../media/types';
-import type { TrackResolutionState } from '../resolve-track';
-import { resolveTrack } from '../resolve-track';
+import { type ResolveTrackState, resolveAudioTrack, resolveTextTrack, resolveVideoTrack } from '../resolve-track';
 
 afterEach(() => {
   vi.restoreAllMocks();
 });
 
-describe('resolveTrack (video)', () => {
+function makeState(initial: ResolveTrackState = {}): StateSignals<ResolveTrackState> {
+  return {
+    presentation: signal<MaybeResolvedPresentation | undefined>(initial.presentation),
+    selectedVideoTrackId: signal<string | undefined>(initial.selectedVideoTrackId),
+    selectedAudioTrackId: signal<string | undefined>(initial.selectedAudioTrackId),
+    selectedTextTrackId: signal<string | undefined>(initial.selectedTextTrackId),
+  };
+}
+
+describe('resolveVideoTrack', () => {
   it('resolves unresolved video track', async () => {
-    // Arrange
     const unresolved: PartiallyResolvedVideoTrack = {
       type: 'video',
       id: 'track-1',
@@ -46,12 +54,8 @@ describe('resolveTrack (video)', () => {
       startTime: 0,
     };
 
-    const state = signal<TrackResolutionState>({
-      presentation,
-      selectedVideoTrackId: 'track-1',
-    });
+    const state = makeState({ presentation, selectedVideoTrackId: 'track-1' });
 
-    // Mock fetch to return media playlist with absolute URLs
     vi.spyOn(globalThis, 'fetch').mockImplementation(
       async () =>
         new Response(`#EXTM3U
@@ -64,18 +68,15 @@ http://example.com/segment2.m4s
 #EXT-X-ENDLIST`)
     );
 
-    // Act
-    const cleanup = resolveTrack({ state }, { type: 'video' as const });
+    const cleanup = resolveVideoTrack.setup({ state });
 
-    // Wait for resolution
     await vi.waitFor(() => {
-      const { presentation: currentPres } = state.get();
+      const currentPres = state.presentation.get();
       const track = findTrackById(currentPres!, 'track-1');
       expect(isResolvedTrack(track!)).toBe(true);
     });
 
-    // Assert - track should now be resolved with segments
-    const resolvedPres = state.get().presentation!;
+    const resolvedPres = state.presentation.get()!;
     const resolvedTrack = findTrackById(resolvedPres, 'track-1');
 
     expect(isResolvedTrack(resolvedTrack!)).toBe(true);
@@ -90,7 +91,6 @@ http://example.com/segment2.m4s
   it('does not resolve when track is already resolved', async () => {
     const fetchSpy = vi.spyOn(globalThis, 'fetch');
 
-    // Create presentation with already-resolved track
     const presentation: Presentation = {
       id: 'pres-1',
       url: 'http://example.com/playlist.m3u8',
@@ -116,7 +116,7 @@ http://example.com/segment2.m4s
                   startTime: 0,
                   duration: 0,
                   initialization: { url: 'http://example.com/init.mp4' },
-                  segments: [], // Already resolved!
+                  segments: [],
                 },
               ],
             },
@@ -126,12 +126,9 @@ http://example.com/segment2.m4s
       startTime: 0,
     };
 
-    const state = signal<TrackResolutionState>({
-      presentation,
-      selectedVideoTrackId: 'track-1',
-    });
+    const state = makeState({ presentation, selectedVideoTrackId: 'track-1' });
 
-    const cleanup = resolveTrack({ state }, { type: 'video' as const });
+    const cleanup = resolveVideoTrack.setup({ state });
 
     await new Promise((resolve) => setTimeout(resolve, 50));
 
@@ -150,12 +147,9 @@ http://example.com/segment2.m4s
       startTime: 0,
     };
 
-    const state = signal<TrackResolutionState>({
-      presentation,
-      selectedVideoTrackId: undefined,
-    });
+    const state = makeState({ presentation });
 
-    const cleanup = resolveTrack({ state }, { type: 'video' as const });
+    const cleanup = resolveVideoTrack.setup({ state });
 
     await new Promise((resolve) => setTimeout(resolve, 50));
 
@@ -165,7 +159,7 @@ http://example.com/segment2.m4s
   });
 });
 
-describe('resolveTrack (audio)', () => {
+describe('resolveAudioTrack', () => {
   it('resolves unresolved audio track', async () => {
     const unresolved: PartiallyResolvedAudioTrack = {
       type: 'audio',
@@ -199,10 +193,7 @@ describe('resolveTrack (audio)', () => {
       startTime: 0,
     };
 
-    const state = signal<TrackResolutionState>({
-      presentation,
-      selectedAudioTrackId: 'audio-1',
-    });
+    const state = makeState({ presentation, selectedAudioTrackId: 'audio-1' });
 
     vi.spyOn(globalThis, 'fetch').mockImplementation(
       async () =>
@@ -214,15 +205,15 @@ http://example.com/segment1.m4s
 #EXT-X-ENDLIST`)
     );
 
-    const cleanup = resolveTrack({ state }, { type: 'audio' as const });
+    const cleanup = resolveAudioTrack.setup({ state });
 
     await vi.waitFor(() => {
-      const { presentation: currentPres } = state.get();
+      const currentPres = state.presentation.get();
       const track = findTrackById(currentPres!, 'audio-1');
       expect(isResolvedTrack(track!)).toBe(true);
     });
 
-    const resolvedPres = state.get().presentation!;
+    const resolvedPres = state.presentation.get()!;
     const resolvedTrack = findTrackById(resolvedPres, 'audio-1');
 
     expect(isResolvedTrack(resolvedTrack!)).toBe(true);
@@ -236,7 +227,7 @@ http://example.com/segment1.m4s
   });
 });
 
-describe('resolveTrack (text)', () => {
+describe('resolveTextTrack', () => {
   it('resolves unresolved text track', async () => {
     const unresolved: PartiallyResolvedTextTrack = {
       type: 'text',
@@ -268,10 +259,7 @@ describe('resolveTrack (text)', () => {
       startTime: 0,
     };
 
-    const state = signal<TrackResolutionState>({
-      presentation,
-      selectedTextTrackId: 'text-1',
-    });
+    const state = makeState({ presentation, selectedTextTrackId: 'text-1' });
 
     vi.spyOn(globalThis, 'fetch').mockImplementation(
       async () =>
@@ -286,15 +274,15 @@ http://example.com/subtitle1.webvtt
 #EXT-X-ENDLIST`)
     );
 
-    const cleanup = resolveTrack({ state }, { type: 'text' as const });
+    const cleanup = resolveTextTrack.setup({ state });
 
     await vi.waitFor(() => {
-      const { presentation: currentPres } = state.get();
+      const currentPres = state.presentation.get();
       const track = findTrackById(currentPres!, 'text-1');
       expect(isResolvedTrack(track!)).toBe(true);
     });
 
-    const resolvedPres = state.get().presentation!;
+    const resolvedPres = state.presentation.get()!;
     const resolvedTrack = findTrackById(resolvedPres, 'text-1');
 
     expect(isResolvedTrack(resolvedTrack!)).toBe(true);
@@ -306,11 +294,8 @@ http://example.com/subtitle1.webvtt
   });
 });
 
-describe('resolveTrack — concurrent resolution', () => {
+describe('resolveVideoTrack — concurrent resolution', () => {
   it('resolves both tracks concurrently when selectedTrackId changes mid-resolution', async () => {
-    // Verifies the concurrent Map-based model: when the selected track changes
-    // while a prior resolution is in flight, both tracks resolve independently
-    // without aborting each other. Each track ID is fetched at most once.
     const trackA: PartiallyResolvedVideoTrack = {
       type: 'video',
       id: 'track-a',
@@ -341,10 +326,7 @@ describe('resolveTrack — concurrent resolution', () => {
       startTime: 0,
     };
 
-    const state = signal<TrackResolutionState>({
-      presentation,
-      selectedVideoTrackId: 'track-a',
-    });
+    const state = makeState({ presentation, selectedVideoTrackId: 'track-a' });
 
     const makePlaylist = (segUrl: string) => `#EXTM3U
 #EXT-X-TARGETDURATION:10
@@ -352,26 +334,22 @@ describe('resolveTrack — concurrent resolution', () => {
 ${segUrl}
 #EXT-X-ENDLIST`;
 
-    // Both fetches resolve immediately — concurrent resolution, no abort.
     vi.spyOn(globalThis, 'fetch').mockImplementation((requestOrUrl: RequestInfo | URL) => {
       const url = requestOrUrl instanceof Request ? requestOrUrl.url : String(requestOrUrl);
       if (url.includes('track-a')) return Promise.resolve(new Response(makePlaylist('http://example.com/a-seg1.m4s')));
       return Promise.resolve(new Response(makePlaylist('http://example.com/b-seg1.m4s')));
     });
 
-    const cleanup = resolveTrack({ state }, { type: 'video' as const });
+    const cleanup = resolveVideoTrack.setup({ state });
 
-    // While track-a resolution is in flight, switch to track-b.
-    state.set({ ...state.get(), selectedVideoTrackId: 'track-b' });
+    state.selectedVideoTrackId.set('track-b');
 
-    // Both tracks should be resolved (concurrently, neither aborts the other).
     await vi.waitFor(() => {
-      const pres = state.get().presentation!;
+      const pres = state.presentation.get()!;
       expect(isResolvedTrack(findTrackById(pres, 'track-a')!)).toBe(true);
       expect(isResolvedTrack(findTrackById(pres, 'track-b')!)).toBe(true);
     });
 
-    // Each track URL should have been fetched exactly once.
     const fetchedUrls = vi.mocked(globalThis.fetch).mock.calls.map((call) => {
       const arg: RequestInfo | URL = call[0];
       return arg instanceof Request ? arg.url : String(arg);
@@ -405,10 +383,7 @@ ${segUrl}
       startTime: 0,
     };
 
-    const state = signal<TrackResolutionState>({
-      presentation,
-      selectedVideoTrackId: 'track-a',
-    });
+    const state = makeState({ presentation, selectedVideoTrackId: 'track-a' });
 
     const fetchSpy = vi.spyOn(globalThis, 'fetch').mockImplementation(
       async () =>
@@ -419,17 +394,16 @@ http://example.com/a-seg1.m4s
 #EXT-X-ENDLIST`)
     );
 
-    const cleanup = resolveTrack({ state }, { type: 'video' as const });
+    const cleanup = resolveVideoTrack.setup({ state });
 
     // Trigger multiple state changes while track-a is resolving.
-    state.set({ ...state.get(), selectedVideoTrackId: 'track-a' });
-    state.set({ ...state.get(), selectedVideoTrackId: 'track-a' });
+    state.selectedVideoTrackId.set('track-a');
+    state.selectedVideoTrackId.set('track-a');
 
     await vi.waitFor(() => {
-      expect(isResolvedTrack(findTrackById(state.get().presentation!, 'track-a')!)).toBe(true);
+      expect(isResolvedTrack(findTrackById(state.presentation.get()!, 'track-a')!)).toBe(true);
     });
 
-    // Should only have been fetched once despite multiple state triggers.
     expect(fetchSpy).toHaveBeenCalledTimes(1);
 
     cleanup();
diff --git a/packages/spf/src/playback/behaviors/tests/select-tracks.test.ts b/packages/spf/src/playback/behaviors/tests/select-tracks.test.ts
index b51a9205..476874a4 100644
--- a/packages/spf/src/playback/behaviors/tests/select-tracks.test.ts
+++ b/packages/spf/src/playback/behaviors/tests/select-tracks.test.ts
@@ -1,8 +1,10 @@
 import { describe, expect, it } from 'vitest';
+import type { StateSignals } from '../../../core/composition/create-composition';
 import { signal } from '../../../core/signals/primitives';
 import type { TrackSelectionState } from '../../../media/primitives/select-tracks';
 import type {
   AudioSelectionSet,
+  MaybeResolvedPresentation,
   PartiallyResolvedAudioTrack,
   PartiallyResolvedVideoTrack,
   Presentation,
@@ -11,6 +13,15 @@ import type {
 } from '../../../media/types';
 import { selectAudioTrack, selectTextTrack, selectVideoTrack } from '../select-tracks';
 
+function makeState(initial: TrackSelectionState = {}): StateSignals<TrackSelectionState> {
+  return {
+    presentation: signal<MaybeResolvedPresentation | undefined>(initial.presentation),
+    selectedVideoTrackId: signal<string | undefined>(initial.selectedVideoTrackId),
+    selectedAudioTrackId: signal<string | undefined>(initial.selectedAudioTrackId),
+    selectedTextTrackId: signal<string | undefined>(initial.selectedTextTrackId),
+  };
+}
+
 // Helper to create a minimal presentation
 function createPresentation(config: {
   video?: PartiallyResolvedVideoTrack[];
@@ -83,32 +94,27 @@ describe('selectVideoTrack', () => {
     ];
 
     const presentation = createPresentation({ video: videoTracks });
+    const state = makeState({ presentation });
 
-    const state = signal<TrackSelectionState>({ presentation });
-
-    const cleanup = selectVideoTrack({ state }, { type: 'video' });
+    const cleanup = selectVideoTrack.setup({ state });
 
     // Wait for selection
     await new Promise((resolve) => setTimeout(resolve, 50));
 
-    expect(state.get().selectedVideoTrackId).toBe('video-360p');
+    expect(state.selectedVideoTrackId.get()).toBe('video-360p');
 
     cleanup();
   });
 
   it('does not select when video track already selected', async () => {
     const presentation = createPresentation({ video: [] });
+    const state = makeState({ presentation, selectedVideoTrackId: 'existing-video' });
 
-    const state = signal<TrackSelectionState>({
-      presentation,
-      selectedVideoTrackId: 'existing-video',
-    });
-
-    const cleanup = selectVideoTrack({ state }, { type: 'video' });
+    const cleanup = selectVideoTrack.setup({ state });
 
     await new Promise((resolve) => setTimeout(resolve, 50));
 
-    expect(state.get().selectedVideoTrackId).toBe('existing-video');
+    expect(state.selectedVideoTrackId.get()).toBe('existing-video');
 
     cleanup();
   });
@@ -134,14 +140,13 @@ describe('selectVideoTrack', () => {
     ];
 
     const presentation = createPresentation({ video: videoTracks });
+    const state = makeState({ presentation });
 
-    const state = signal<TrackSelectionState>({ presentation });
-
-    const cleanup = selectVideoTrack({ state }, { initialBandwidth: 3_000_000, type: 'video' });
+    const cleanup = selectVideoTrack.setup({ state });
 
     await new Promise((resolve) => setTimeout(resolve, 50));
 
-    expect(state.get().selectedVideoTrackId).toBe('video-720p');
+    expect(state.selectedVideoTrackId.get()).toBe('video-720p');
 
     cleanup();
   });
@@ -165,31 +170,26 @@ describe('selectAudioTrack', () => {
     ];
 
     const presentation = createPresentation({ audio: audioTracks });
+    const state = makeState({ presentation });
 
-    const state = signal<TrackSelectionState>({ presentation });
-
-    const cleanup = selectAudioTrack({ state }, { type: 'audio' });
+    const cleanup = selectAudioTrack.setup({ state });
 
     await new Promise((resolve) => setTimeout(resolve, 50));
 
-    expect(state.get().selectedAudioTrackId).toBe('audio-en');
+    expect(state.selectedAudioTrackId.get()).toBe('audio-en');
 
     cleanup();
   });
 
   it('does not select when audio track already selected', async () => {
     const presentation = createPresentation({ audio: [] });
+    const state = makeState({ presentation, selectedAudioTrackId: 'existing-audio' });
 
-    const state = signal<TrackSelectionState>({
-      presentation,
-      selectedAudioTrackId: 'existing-audio',
-    });
-
-    const cleanup = selectAudioTrack({ state }, { type: 'audio' });
+    const cleanup = selectAudioTrack.setup({ state });
 
     await new Promise((resolve) => setTimeout(resolve, 50));
 
-    expect(state.get().selectedAudioTrackId).toBe('existing-audio');
+    expect(state.selectedAudioTrackId.get()).toBe('existing-audio');
 
     cleanup();
   });
@@ -225,14 +225,13 @@ describe('selectAudioTrack', () => {
     ];
 
     const presentation = createPresentation({ audio: audioTracks });
+    const state = makeState({ presentation });
 
-    const state = signal<TrackSelectionState>({ presentation });
-
-    const cleanup = selectAudioTrack({ state }, { type: 'audio', preferredAudioLanguage: 'es' });
+    const cleanup = selectAudioTrack.setup({ state });
 
     await new Promise((resolve) => setTimeout(resolve, 50));
 
-    expect(state.get().selectedAudioTrackId).toBe('audio-es');
+    expect(state.selectedAudioTrackId.get()).toBe('audio-es');
 
     cleanup();
   });
@@ -254,14 +253,13 @@ describe('selectTextTrack', () => {
     ];
 
     const presentation = createPresentation({ text: textTracks });
+    const state = makeState({ presentation });
 
-    const state = signal<TrackSelectionState>({ presentation });
-
-    const cleanup = selectTextTrack({ state }, { type: 'text' });
+    const cleanup = selectTextTrack.setup({ state, config: {} });
 
     await new Promise((resolve) => setTimeout(resolve, 50));
 
-    expect(state.get().selectedTextTrackId).toBeUndefined();
+    expect(state.selectedTextTrackId.get()).toBeUndefined();
 
     cleanup();
   });
diff --git a/packages/spf/src/playback/behaviors/tests/sync-preload-attribute.test.ts b/packages/spf/src/playback/behaviors/tests/sync-preload-attribute.test.ts
index 3112deb7..8773713a 100644
--- a/packages/spf/src/playback/behaviors/tests/sync-preload-attribute.test.ts
+++ b/packages/spf/src/playback/behaviors/tests/sync-preload-attribute.test.ts
@@ -1,136 +1,97 @@
 import { describe, expect, it, vi } from 'vitest';
+import type { ContextSignals, StateSignals } from '../../../core/composition/create-composition';
 import { signal } from '../../../core/signals/primitives';
-import type { MediaElementLike } from '../../../media/types';
+import type { MaybeResolvedPresentation, MediaElementLike } from '../../../media/types';
+import type { PresentationState } from '../resolve-presentation';
 import { syncPreloadAttribute } from '../sync-preload-attribute';
 
+interface State {
+  preload?: 'auto' | 'metadata' | 'none' | undefined;
+}
+
+interface Context {
+  mediaElement?: MediaElementLike | undefined;
+}
+
+function makeState(initial: State = {}): StateSignals<PresentationState> {
+  // syncPreloadAttribute requires a PresentationState shape — provide all keys
+  // even though only `preload` is exercised here.
+  return {
+    presentation: signal<MaybeResolvedPresentation | undefined>(undefined),
+    preload: signal<'auto' | 'metadata' | 'none' | undefined>(initial.preload),
+    playbackInitiated: signal<boolean | undefined>(undefined),
+  };
+}
+
+function makeContext(initial: Context = {}): ContextSignals<Context> {
+  return { mediaElement: signal<MediaElementLike | undefined>(initial.mediaElement) };
+}
+
 describe('syncPreloadAttribute', () => {
   it('syncs preload from mediaElement to state', async () => {
-    interface State {
-      preload?: 'auto' | 'metadata' | 'none' | undefined;
-    }
-
-    interface Owners {
-      mediaElement?: MediaElementLike | undefined;
-    }
-
-    const state = signal<State>({
-      preload: undefined,
-    });
-
-    // Start with media element already set
+    const state = makeState();
     const video = { preload: 'auto' } as MediaElementLike;
-    const owners = signal<Owners>({
-      mediaElement: video,
-    });
+    const context = makeContext({ mediaElement: video });
 
     // Sync should pick up existing mediaElement on first effect fire (synchronous)
-    const cleanup = syncPreloadAttribute({ state, owners });
+    const cleanup = syncPreloadAttribute.setup({ state, context });
 
-    expect(state.get().preload).toBe('auto');
+    expect(state.preload.get()).toBe('auto');
 
     cleanup();
   });
 
   it('does not override preload when mediaElement changes and preload is already set', async () => {
-    interface State {
-      preload?: 'auto' | 'metadata' | 'none' | undefined;
-    }
-
-    interface Owners {
-      mediaElement?: MediaElementLike | undefined;
-    }
-
-    const state = signal<State>({
-      preload: undefined,
-    });
-
+    const state = makeState();
     const video = { preload: 'auto' } as MediaElementLike;
-    const owners = signal<Owners>({
-      mediaElement: video,
-    });
+    const context = makeContext({ mediaElement: video });
 
-    // Start syncing — initial inference from element (synchronous)
-    const cleanup = syncPreloadAttribute({ state, owners });
+    const cleanup = syncPreloadAttribute.setup({ state, context });
 
-    expect(state.get().preload).toBe('auto');
+    expect(state.preload.get()).toBe('auto');
 
     // Swap to a different mediaElement with a different preload value.
-    // Since preload is already set, the new element's value is ignored.
     const updatedVideo = { preload: 'metadata' } as MediaElementLike;
-    owners.set({ ...owners.get(), mediaElement: updatedVideo });
+    context.mediaElement.set(updatedVideo);
 
     await vi.waitFor(() => {
-      // preload should remain 'auto' — new element's value is not applied once preload is set
-      expect(state.get().preload).toBe('auto');
+      expect(state.preload.get()).toBe('auto');
     });
 
     cleanup();
   });
 
   it('does not loop when mediaElement is absent and preload is unset', () => {
-    interface State {
-      preload?: 'auto' | 'metadata' | 'none' | undefined;
-    }
+    const state = makeState();
+    const context = makeContext();
 
-    interface Owners {
-      mediaElement?: MediaElementLike | undefined;
-    }
+    const cleanup = syncPreloadAttribute.setup({ state, context });
 
-    const state = signal<State>({ preload: undefined });
-    const owners = signal<Owners>({ mediaElement: undefined });
-
-    // Should not throw / hang — the effect must exit without writing when
-    // both preload and mediaElement are absent.
-    const cleanup = syncPreloadAttribute({ state, owners });
-
-    expect(state.get().preload).toBeUndefined();
+    expect(state.preload.get()).toBeUndefined();
 
     cleanup();
   });
 
   it('does not loop when mediaElement has no preload attribute and preload is unset', () => {
-    interface State {
-      preload?: 'auto' | 'metadata' | 'none' | undefined;
-    }
+    const state = makeState();
+    const context = makeContext({ mediaElement: { preload: '' } as MediaElementLike });
 
-    interface Owners {
-      mediaElement?: MediaElementLike | undefined;
-    }
+    const cleanup = syncPreloadAttribute.setup({ state, context });
 
-    const state = signal<State>({ preload: undefined });
-    // Browsers return '' when the preload attribute is absent
-    const owners = signal<Owners>({ mediaElement: { preload: '' } as MediaElementLike });
-
-    const cleanup = syncPreloadAttribute({ state, owners });
-
-    expect(state.get().preload).toBeUndefined();
+    expect(state.preload.get()).toBeUndefined();
 
     cleanup();
   });
 
   it('does not clear preload when mediaElement is removed and preload is already set', async () => {
-    interface State {
-      preload?: 'auto' | 'metadata' | 'none' | undefined;
-    }
+    const state = makeState({ preload: 'auto' });
+    const context = makeContext();
 
-    interface Owners {
-      mediaElement?: MediaElementLike | undefined;
-    }
+    const cleanup = syncPreloadAttribute.setup({ state, context });
 
-    const state = signal<State>({
-      preload: 'auto',
-    });
+    context.mediaElement.set(undefined);
 
-    const owners = signal<Owners>({
-      mediaElement: undefined,
-    });
-
-    const cleanup = syncPreloadAttribute({ state, owners });
-
-    owners.set({ ...owners.get(), mediaElement: undefined });
-
-    // Preload was already set — removing the element does not clear it.
-    expect(state.get().preload).toBe('auto');
+    expect(state.preload.get()).toBe('auto');
 
     cleanup();
   });
diff --git a/packages/spf/src/playback/engines/hls/adapter.ts b/packages/spf/src/playback/engines/hls/adapter.ts
index a4f0308b..c2e981d5 100644
--- a/packages/spf/src/playback/engines/hls/adapter.ts
+++ b/packages/spf/src/playback/engines/hls/adapter.ts
@@ -1,10 +1,10 @@
 import type { Constructor, MixinReturn } from '@videojs/utils/types';
 import type { Composition } from '../../../core/composition/create-composition';
-import { update } from '../../../core/signals/primitives';
 import {
   createSimpleHlsEngine,
   type SimpleHlsEngineConfig,
-  type SimpleHlsEngineOwners,
+  type SimpleHlsEngineContext,
+  type SimpleHlsEngineSignals,
   type SimpleHlsEngineState,
 } from './engine';
 
@@ -19,7 +19,7 @@ export const simpleHlsMediaDefaultProps: SimpleHlsMediaProps = {
 };
 
 export interface SimpleHlsMediaAPI extends SimpleHlsMediaProps {
-  readonly engine: Composition<SimpleHlsEngineState, SimpleHlsEngineOwners>;
+  readonly engine: Composition<SimpleHlsEngineState, SimpleHlsEngineContext>;
   attach(mediaElement: HTMLMediaElement): void;
   detach(): void;
   destroy(): void;
@@ -46,8 +46,9 @@ export interface SimpleHlsMediaAPI extends SimpleHlsMediaProps {
  */
 export function SimpleHlsMediaMixin<Base extends Constructor<any>>(BaseClass: Base) {
   class SimpleHlsMediaImpl extends BaseClass {
-    #engine: Composition<SimpleHlsEngineState, SimpleHlsEngineOwners>;
+    #engine: Composition<SimpleHlsEngineState, SimpleHlsEngineContext>;
     #config: SimpleHlsEngineConfig;
+    #signals!: SimpleHlsEngineSignals;
     #preload: '' | 'none' | 'metadata' | 'auto' = simpleHlsMediaDefaultProps.preload;
 
     /** Pending loadstart listener from a deferred play() retry, if any. */
@@ -58,10 +59,10 @@ export function SimpleHlsMediaMixin<Base extends Constructor<any>>(BaseClass: Ba
 
       const { config } = args?.[0] ?? {};
       this.#config = config;
-      this.#engine = createSimpleHlsEngine(config);
+      this.#engine = this.#createEngine();
     }
 
-    get engine(): Composition<SimpleHlsEngineState, SimpleHlsEngineOwners> {
+    get engine(): Composition<SimpleHlsEngineState, SimpleHlsEngineContext> {
       return this.#engine;
     }
 
@@ -71,12 +72,12 @@ export function SimpleHlsMediaMixin<Base extends Constructor<any>>(BaseClass: Ba
 
     attach(mediaElement: HTMLMediaElement): void {
       super.attach?.(mediaElement);
-      update(this.#engine.owners, { mediaElement });
+      this.#signals.context.mediaElement.set(mediaElement);
     }
 
     detach(): void {
       this.#cancelPendingPlay();
-      update(this.#engine.owners, { mediaElement: undefined });
+      this.#signals.context.mediaElement.set(undefined);
       super.detach?.();
     }
 
@@ -96,7 +97,7 @@ export function SimpleHlsMediaMixin<Base extends Constructor<any>>(BaseClass: Ba
     set preload(value: '' | 'none' | 'metadata' | 'auto') {
       this.#preload = value;
       if (value) {
-        update(this.#engine.state, { preload: value });
+        this.#signals.state.preload.set(value);
       }
       // value = '' clears #preload (so the next engine recreation won't re-apply
       // an explicit value) but does not patch current state — the existing preload
@@ -110,28 +111,28 @@ export function SimpleHlsMediaMixin<Base extends Constructor<any>>(BaseClass: Ba
     // -------------------------------------------------------------------------
 
     get src(): string {
-      return this.#engine.state.get().presentation?.url ?? '';
+      return this.#signals.state.presentation.get()?.url ?? '';
     }
 
     set src(value: string) {
-      const prevMediaElement = this.#engine.owners.get().mediaElement;
+      const prevMediaElement = this.#signals.context.mediaElement.get();
 
       this.#cancelPendingPlay();
       this.#engine.destroy();
-      this.#engine = createSimpleHlsEngine(this.#config);
+      this.#engine = this.#createEngine();
 
-      // Apply explicit preload before setting owners so syncPreloadAttribute skips
+      // Apply explicit preload before setting context so syncPreloadAttribute skips
       // element inference and the explicit value is preserved across src changes.
       if (this.#preload) {
-        update(this.#engine.state, { preload: this.#preload });
+        this.#signals.state.preload.set(this.#preload);
       }
 
       if (prevMediaElement) {
-        update(this.#engine.owners, { mediaElement: prevMediaElement });
+        this.#signals.context.mediaElement.set(prevMediaElement);
       }
 
       if (value) {
-        update(this.#engine.state, { presentation: { url: value } });
+        this.#signals.state.presentation.set({ url: value });
       }
     }
 
@@ -141,13 +142,13 @@ export function SimpleHlsMediaMixin<Base extends Constructor<any>>(BaseClass: Ba
     // -------------------------------------------------------------------------
 
     play(): Promise<void> {
-      const { mediaElement } = this.#engine.owners.get();
+      const mediaElement = this.#signals.context.mediaElement.get();
       if (!mediaElement) {
         return Promise.reject(new Error('SimpleHlsMediaElement: no media element attached'));
       }
 
       // Signal play intent — enables loading even with preload="none"
-      update(this.#engine.state, { playbackInitiated: true });
+      this.#signals.state.playbackInitiated.set(true);
 
       return mediaElement.play().catch((err: unknown) => {
         // If we have a pending HLS source, the rejection may be because MSE
@@ -171,9 +172,18 @@ export function SimpleHlsMediaMixin<Base extends Constructor<any>>(BaseClass: Ba
     // Private
     // -------------------------------------------------------------------------
 
+    #createEngine(): Composition<SimpleHlsEngineState, SimpleHlsEngineContext> {
+      return createSimpleHlsEngine({
+        ...this.#config,
+        onSignalsReady: (signals) => {
+          this.#signals = signals;
+        },
+      });
+    }
+
     #cancelPendingPlay(): void {
       if (!this.#loadstartListener) return;
-      const { mediaElement } = this.#engine.owners.get();
+      const mediaElement = this.#signals.context.mediaElement.get();
       mediaElement?.removeEventListener('loadstart', this.#loadstartListener);
       this.#loadstartListener = null;
     }
diff --git a/packages/spf/src/playback/engines/hls/engine.ts b/packages/spf/src/playback/engines/hls/engine.ts
index 2667eb6f..84797b8b 100644
--- a/packages/spf/src/playback/engines/hls/engine.ts
+++ b/packages/spf/src/playback/engines/hls/engine.ts
@@ -1,34 +1,35 @@
-import { type Composition, createComposition } from '../../../core/composition/create-composition';
-import type { Signal } from '../../../core/signals/primitives';
+import {
+  type Composition,
+  type ContextSignals,
+  createComposition,
+  type StateSignals,
+} from '../../../core/composition/create-composition';
+import { makeShareSignals, type ShareSignalsConfig } from '../../../core/composition/share-signals';
 import type { BandwidthState } from '../../../media/abr/bandwidth-estimator';
 import { resolveVttSegment } from '../../../media/dom/text/resolve-vtt-segment';
 import type { MaybeResolvedPresentation } from '../../../media/types';
 import type { SourceBufferActor } from '../../actors/dom/source-buffer';
 import type { TextTracksActor } from '../../actors/dom/text-tracks';
-import type { TextTrackSegmentLoaderActor } from '../../actors/text-track-segment-loader';
+import type { TextTrackSegmentLoaderActor, TextTrackSegmentResolver } from '../../actors/text-track-segment-loader';
 import { calculatePresentationDuration } from '../../behaviors/calculate-presentation-duration';
 import { endOfStream } from '../../behaviors/dom/end-of-stream';
-import { loadSegments } from '../../behaviors/dom/load-segments';
+import { loadAudioSegments, loadVideoSegments } from '../../behaviors/dom/load-segments';
 import { setupMediaSource } from '../../behaviors/dom/setup-mediasource';
 import { setupSourceBuffers } from '../../behaviors/dom/setup-sourcebuffer';
-import { setupTextTrackActors as _setupTextTrackActors } from '../../behaviors/dom/setup-text-track-actors';
+import { setupTextTrackActors } from '../../behaviors/dom/setup-text-track-actors';
 import { syncTextTracks } from '../../behaviors/dom/sync-text-tracks';
 import { trackCurrentTime } from '../../behaviors/dom/track-current-time';
 import { trackPlaybackInitiated } from '../../behaviors/dom/track-playback-initiated';
 import { updateDuration } from '../../behaviors/dom/update-duration';
 import { loadTextTrackCues } from '../../behaviors/load-text-track-cues';
-import { switchQuality as _switchQuality } from '../../behaviors/quality-switching';
+import { switchQuality } from '../../behaviors/quality-switching';
 import { resolvePresentation } from '../../behaviors/resolve-presentation';
-import { resolveTrack } from '../../behaviors/resolve-track';
-import {
-  selectAudioTrack as _selectAudioTrack,
-  selectTextTrack as _selectTextTrack,
-  selectVideoTrack as _selectVideoTrack,
-} from '../../behaviors/select-tracks';
+import { resolveAudioTrack, resolveTextTrack, resolveVideoTrack } from '../../behaviors/resolve-track';
+import { selectAudioTrack, selectTextTrack, selectVideoTrack } from '../../behaviors/select-tracks';
 import { syncPreloadAttribute } from '../../behaviors/sync-preload-attribute';
 
 // ============================================================================
-// HLS Engine State & Owners
+// HLS Engine State & Context
 // ============================================================================
 
 /**
@@ -56,11 +57,11 @@ export interface SimpleHlsEngineState {
 }
 
 /**
- * Owners shape for the HLS playback engine.
+ * Context shape for the HLS playback engine.
  *
  * Platform objects and actor references managed by HLS behaviors.
  */
-export interface SimpleHlsEngineOwners {
+export interface SimpleHlsEngineContext {
   mediaElement?: HTMLMediaElement | undefined;
   mediaSource?: MediaSource;
   videoBuffer?: SourceBuffer;
@@ -71,83 +72,48 @@ export interface SimpleHlsEngineOwners {
   segmentLoaderActor?: TextTrackSegmentLoaderActor;
 }
 
+/**
+ * The composition signal refs handed to `onSignalsReady` callers — the
+ * canonical way to drive the engine externally (writes) or observe its
+ * state (reads) without touching `composition.state` / `composition.context`
+ * directly.
+ */
+export type SimpleHlsEngineSignals = {
+  state: StateSignals<SimpleHlsEngineState>;
+  context: ContextSignals<SimpleHlsEngineContext>;
+};
+
 /**
  * Configuration for the HLS playback engine.
  *
  * Each option is consumed by the appropriate behavior — the engine itself
  * has no config beyond what its behaviors read.
  */
-export interface SimpleHlsEngineConfig {
+export interface SimpleHlsEngineConfig extends ShareSignalsConfig<SimpleHlsEngineState, SimpleHlsEngineContext> {
   initialBandwidth?: number;
   preferredAudioLanguage?: string;
   preferredSubtitleLanguage?: string;
   includeForcedTracks?: boolean;
   enableDefaultTrack?: boolean;
+  /**
+   * Resolver that turns a text-track segment fetch into VTT cues.
+   * Defaults to the DOM-bound `resolveVttSegment` resolver, which uses an
+   * offscreen `<track>` element to parse WebVTT.
+   */
+  resolveTextTrackSegment?: TextTrackSegmentResolver<VTTCue>;
 }
 
-/** Shorthand for the deps shape used by HLS engine behaviors. */
-type Deps = {
-  state: Signal<SimpleHlsEngineState>;
-  owners: Signal<SimpleHlsEngineOwners>;
-  config: SimpleHlsEngineConfig;
-};
-
-// ============================================================================
-// Thin media-type wrappers
-//
-// Behaviors parameterized by media type get thin wrappers that close over
-// the type value, so the engine composition reads as a flat list of
-// behaviors without inline config.
-// ============================================================================
-
-const loadVideoSegments = (deps: Deps) => loadSegments(deps, { type: 'video' });
-const loadAudioSegments = (deps: Deps) => loadSegments(deps, { type: 'audio' });
-
-const resolveVideoTrack = (deps: Deps) => resolveTrack(deps, { type: 'video' as const });
-const resolveAudioTrack = (deps: Deps) => resolveTrack(deps, { type: 'audio' as const });
-const resolveTextTrack = (deps: Deps) => resolveTrack(deps, { type: 'text' as const });
-
-const setupTextTrackActors = ({ owners }: Deps) =>
-  _setupTextTrackActors({ owners, config: { resolveTextTrackSegment: resolveVttSegment } });
-
-// ============================================================================
-// Config-aware behavior wrappers
-//
-// Behaviors that read from engine config get wrappers that thread the
-// relevant config fields into the behavior's own config parameter.
-// ============================================================================
-
-const selectVideoTrack = ({ config, ...deps }: Deps) =>
-  _selectVideoTrack(deps, {
-    type: 'video',
-    ...(config.initialBandwidth !== undefined && { initialBandwidth: config.initialBandwidth }),
-  });
-
-const selectAudioTrack = ({ config, ...deps }: Deps) =>
-  _selectAudioTrack(deps, {
-    type: 'audio',
-    ...(config.preferredAudioLanguage !== undefined && {
-      preferredAudioLanguage: config.preferredAudioLanguage,
-    }),
-  });
-
-const selectTextTrack = ({ config, ...deps }: Deps) =>
-  _selectTextTrack(deps, {
-    type: 'text',
-    ...(config.preferredSubtitleLanguage !== undefined && {
-      preferredSubtitleLanguage: config.preferredSubtitleLanguage,
-    }),
-    ...(config.includeForcedTracks !== undefined && { includeForcedTracks: config.includeForcedTracks }),
-    ...(config.enableDefaultTrack !== undefined && { enableDefaultTrack: config.enableDefaultTrack }),
-  });
-
-const switchQuality = ({ config, ...deps }: Deps) =>
-  _switchQuality(deps, config.initialBandwidth !== undefined ? { defaultBandwidth: config.initialBandwidth } : {});
-
 // ============================================================================
 // HLS Playback Engine
 // ============================================================================
 
+/**
+ * Generic `shareSignals` instantiated against the HLS engine's full state
+ * and context — captures composition signal refs into the consumer's
+ * `onSignalsReady` callback at setup time.
+ */
+const shareSignals = makeShareSignals<SimpleHlsEngineState, SimpleHlsEngineContext>();
+
 /**
  * Create an HLS playback engine.
  *
@@ -157,13 +123,17 @@ const switchQuality = ({ config, ...deps }: Deps) =>
  *
  * @example
  * ```ts
+ * let signals: SimpleHlsEngineSignals;
  * const engine = createSimpleHlsEngine({
  *   initialBandwidth: 2_000_000,
  *   preferredAudioLanguage: 'en',
+ *   onSignalsReady: (refs) => {
+ *     signals = refs;
+ *   },
  * });
  *
- * engine.owners.set({ ...engine.owners.get(), mediaElement: videoEl });
- * engine.state.set({ ...engine.state.get(), presentation: { url: 'https://example.com/stream.m3u8' } });
+ * signals.context.mediaElement.set(videoEl);
+ * signals.state.presentation.set({ url: 'https://example.com/stream.m3u8' });
  *
  * videoEl.play();
  *
@@ -172,8 +142,13 @@ const switchQuality = ({ config, ...deps }: Deps) =>
  */
 export function createSimpleHlsEngine(
   config: SimpleHlsEngineConfig = {}
-): Composition<SimpleHlsEngineState, SimpleHlsEngineOwners> {
-  return createComposition<SimpleHlsEngineState, SimpleHlsEngineOwners, SimpleHlsEngineConfig>(
+): Composition<SimpleHlsEngineState, SimpleHlsEngineContext> {
+  const finalConfig = {
+    ...config,
+    resolveTextTrackSegment: config.resolveTextTrackSegment ?? resolveVttSegment,
+  };
+
+  return createComposition(
     [
       syncPreloadAttribute,
       trackPlaybackInitiated,
@@ -212,9 +187,18 @@ export function createSimpleHlsEngine(
       syncTextTracks,
       setupTextTrackActors,
       loadTextTrackCues,
+
+      // Behavior whose sole purpose is to use a callback to allow for signal writing from the outside (e.g. an adapter)
+      // NOTE: While not required, adding at the end since behaviors are setup in order, so this increases the likelihood
+      // that initial signal setup will have occurred before shareSignals' callback is invoked. (CJP)
+      shareSignals,
     ],
     {
-      config,
+      config: finalConfig,
+      // Seed bandwidthState so switchQuality fires on initial subscribe
+      // with the `initialBandwidth` fallback rather than waiting for the
+      // first chunk. The empty sample buffer means `getBandwidthEstimate`
+      // returns the configured initial bandwidth until real samples land.
       initialState: {
         bandwidthState: {
           fastEstimate: 0,
@@ -224,7 +208,6 @@ export function createSimpleHlsEngine(
           bytesSampled: 0,
         },
       },
-      initialOwners: {},
     }
   );
 }
diff --git a/packages/spf/src/playback/engines/hls/index.ts b/packages/spf/src/playback/engines/hls/index.ts
index bd344528..d86464a6 100644
--- a/packages/spf/src/playback/engines/hls/index.ts
+++ b/packages/spf/src/playback/engines/hls/index.ts
@@ -2,7 +2,8 @@ export type { SimpleHlsMediaAPI, SimpleHlsMediaProps } from './adapter';
 export { SimpleHlsMediaElement, SimpleHlsMediaMixin, simpleHlsMediaDefaultProps } from './adapter';
 export type {
   SimpleHlsEngineConfig,
-  SimpleHlsEngineOwners,
+  SimpleHlsEngineContext,
+  SimpleHlsEngineSignals,
   SimpleHlsEngineState,
 } from './engine';
 export { createSimpleHlsEngine } from './engine';
diff --git a/packages/spf/src/playback/engines/hls/tests/adapter.test.ts b/packages/spf/src/playback/engines/hls/tests/adapter.test.ts
index 6786e58c..889cf42b 100644
--- a/packages/spf/src/playback/engines/hls/tests/adapter.test.ts
+++ b/packages/spf/src/playback/engines/hls/tests/adapter.test.ts
@@ -66,21 +66,21 @@ describe('SimpleHlsMediaElement', () => {
     it('synchronously updates engine presentation state when src is set', () => {
       const media = new SimpleHlsMediaElement();
       media.src = 'https://example.com/v.m3u8';
-      expect(media.engine.state.get().presentation?.url).toBe('https://example.com/v.m3u8');
+      expect(media.engine.state.presentation.get()?.url).toBe('https://example.com/v.m3u8');
     });
 
     it('synchronously updates engine presentation state when src changes', () => {
       const media = new SimpleHlsMediaElement();
       media.src = 'https://example.com/v1.m3u8';
       media.src = 'https://example.com/v2.m3u8';
-      expect(media.engine.state.get().presentation?.url).toBe('https://example.com/v2.m3u8');
+      expect(media.engine.state.presentation.get()?.url).toBe('https://example.com/v2.m3u8');
     });
 
     it('clears engine presentation state when src is set to empty string', () => {
       const media = new SimpleHlsMediaElement();
       media.src = 'https://example.com/v.m3u8';
       media.src = '';
-      expect(media.engine.state.get().presentation?.url).toBeFalsy();
+      expect(media.engine.state.presentation.get()?.url).toBeFalsy();
     });
   });
 
@@ -132,7 +132,7 @@ describe('SimpleHlsMediaElement', () => {
       const el = document.createElement('video');
       media.attach(el);
       media.src = 'https://example.com/v1.m3u8';
-      expect(media.engine.owners.get().mediaElement).toBe(el);
+      expect(media.engine.context.mediaElement.get()).toBe(el);
     });
 
     it('cancels pending play listener when src changes', async () => {
@@ -153,14 +153,14 @@ describe('SimpleHlsMediaElement', () => {
       const media = new SimpleHlsMediaElement();
       const el = document.createElement('video');
       media.attach(el);
-      expect(media.engine.owners.get().mediaElement).toBe(el);
+      expect(media.engine.context.mediaElement.get()).toBe(el);
     });
 
     it('clears mediaElement in owners when detached', () => {
       const media = new SimpleHlsMediaElement();
       media.attach(document.createElement('video'));
       media.detach();
-      expect(media.engine.owners.get().mediaElement).toBeUndefined();
+      expect(media.engine.context.mediaElement.get()).toBeUndefined();
     });
 
     it('updates mediaElement when re-attached to a different element', () => {
@@ -169,7 +169,7 @@ describe('SimpleHlsMediaElement', () => {
       const el2 = document.createElement('video');
       media.attach(el1);
       media.attach(el2);
-      expect(media.engine.owners.get().mediaElement).toBe(el2);
+      expect(media.engine.context.mediaElement.get()).toBe(el2);
     });
 
     it('preserves src across attach/detach cycles', () => {
@@ -184,7 +184,7 @@ describe('SimpleHlsMediaElement', () => {
       const media = new SimpleHlsMediaElement();
       media.src = 'https://example.com/v.m3u8';
       media.attach(document.createElement('video'));
-      expect(media.engine.state.get().presentation?.url).toBe('https://example.com/v.m3u8');
+      expect(media.engine.state.presentation.get()?.url).toBe('https://example.com/v.m3u8');
     });
 
     it('detach does not destroy the engine', () => {
@@ -213,7 +213,7 @@ describe('SimpleHlsMediaElement', () => {
       const media = new SimpleHlsMediaElement();
       media.attach(document.createElement('video'));
       media.play().catch(() => {});
-      expect(media.engine.state.get().playbackInitiated).toBe(true);
+      expect(media.engine.state.playbackInitiated.get()).toBe(true);
     });
 
     it('retries play() via loadstart when element has no src but adapter has one', async () => {
@@ -316,7 +316,7 @@ describe('SimpleHlsMediaElement', () => {
     it('updates engine state immediately when set', () => {
       const media = new SimpleHlsMediaElement();
       media.preload = 'none';
-      expect(media.engine.state.get().preload).toBe('none');
+      expect(media.engine.state.preload.get()).toBe('none');
     });
 
     it('setting preload to empty string resets the stored value but does not clear current engine state', () => {
@@ -325,7 +325,7 @@ describe('SimpleHlsMediaElement', () => {
       media.preload = '';
       // '' only clears #preload so the next engine recreation won't re-apply
       // an explicit value — it does not patch the current engine state.
-      expect(media.engine.state.get().preload).toBe('auto');
+      expect(media.engine.state.preload.get()).toBe('auto');
     });
 
     it('survives src reassignment — explicit preload is preserved across engine recreation', () => {
@@ -333,7 +333,7 @@ describe('SimpleHlsMediaElement', () => {
       media.preload = 'none';
       media.src = 'https://example.com/v.m3u8';
       expect(media.preload).toBe('none');
-      expect(media.engine.state.get().preload).toBe('none');
+      expect(media.engine.state.preload.get()).toBe('none');
     });
 
     it('explicit preload is re-applied before owners.patch on src change so syncPreloadAttribute skips inference', () => {
@@ -344,7 +344,7 @@ describe('SimpleHlsMediaElement', () => {
       media.src = 'https://example.com/v.m3u8';
       // syncPreloadAttribute fires when owners.patch re-attaches the element,
       // but since preload was already patched into the new engine's state, it skips.
-      expect(media.engine.state.get().preload).toBe('none');
+      expect(media.engine.state.preload.get()).toBe('none');
     });
   });
 
diff --git a/packages/spf/src/playback/engines/hls/tests/engine.test.ts b/packages/spf/src/playback/engines/hls/tests/engine.test.ts
index e08126a9..b253f765 100644
--- a/packages/spf/src/playback/engines/hls/tests/engine.test.ts
+++ b/packages/spf/src/playback/engines/hls/tests/engine.test.ts
@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { snapshot } from '../../../../core/signals/primitives';
 import { createSimpleHlsEngine } from '../engine';
 
 // Mock appendSegment to succeed without real MP4 data
@@ -22,17 +23,22 @@ describe('createSimpleHlsEngine', () => {
     const engine = createSimpleHlsEngine();
 
     expect(engine.state).toBeDefined();
-    expect(engine.owners).toBeDefined();
+    expect(engine.context).toBeDefined();
     expect(engine.destroy).toBeDefined();
     expect(typeof engine.destroy).toBe('function');
 
     engine.destroy();
   });
 
-  it('initializes with empty state and owners', () => {
+  it('initializes state with seeded bandwidthState and undefined elsewhere', () => {
     const engine = createSimpleHlsEngine();
 
-    expect(engine.state.get()).toEqual({
+    // Composition creates one signal per declared key. The engine seeds
+    // `bandwidthState` to an empty BandwidthState via `initialState` so
+    // ABR machinery has a non-nullish starting point; everything else
+    // starts as `undefined` and behaviors write their own slots.
+    expect(snapshot(engine.state)).toEqual({
+      abrDisabled: undefined,
       bandwidthState: {
         fastEstimate: 0,
         fastTotalWeight: 0,
@@ -40,8 +46,19 @@ describe('createSimpleHlsEngine', () => {
         slowTotalWeight: 0,
         bytesSampled: 0,
       },
+      currentTime: undefined,
+      mediaSourceReadyState: undefined,
+      playbackInitiated: undefined,
+      preload: undefined,
+      presentation: undefined,
+      presentationUrl: undefined,
+      selectedAudioTrackId: undefined,
+      selectedTextTrackId: undefined,
+      selectedVideoTrackId: undefined,
     });
-    expect(engine.owners.get()).toEqual({});
+
+    const contextSnapshot = snapshot(engine.context);
+    expect(Object.values(contextSnapshot).every((v) => v === undefined)).toBe(true);
 
     engine.destroy();
   });
@@ -51,18 +68,15 @@ describe('createSimpleHlsEngine', () => {
 
     const mediaElement = document.createElement('video');
     mediaElement.preload = 'auto';
-    engine.owners.set({ ...engine.owners.get(), mediaElement });
-    engine.state.set({
-      ...engine.state.get(),
-      presentation: { url: 'https://example.com/playlist.m3u8' },
-      preload: 'auto',
-    });
+    engine.context.mediaElement.set(mediaElement);
+    engine.state.presentation.set({ url: 'https://example.com/playlist.m3u8' });
+    engine.state.preload.set('auto');
 
     // Wait for microtask queue to drain (patches are batched)
     await new Promise<void>((resolve) => queueMicrotask(resolve));
 
-    expect(engine.owners.get().mediaElement).toBe(mediaElement);
-    expect(engine.state.get().presentation?.url).toBe('https://example.com/playlist.m3u8');
+    expect(engine.context.mediaElement.get()).toBe(mediaElement);
+    expect(engine.state.presentation.get()?.url).toBe('https://example.com/playlist.m3u8');
 
     engine.destroy();
   });
@@ -131,16 +145,13 @@ http://example.com/segment1.m4s
     const engine = createSimpleHlsEngine();
 
     // Patch state to trigger presentation resolution
-    engine.state.set({
-      ...engine.state.get(),
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-      preload: 'auto',
-    });
+    engine.state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
+    engine.state.preload.set('auto');
 
     // Wait for presentation to be resolved (no event needed - state-driven)
     await vi.waitFor(
       () => {
-        const { presentation } = engine.state.get();
+        const { presentation } = snapshot(engine.state);
         expect(presentation?.selectionSets).toBeDefined();
         expect(presentation?.selectionSets?.length).toBeGreaterThan(0);
       },
@@ -204,18 +215,15 @@ http://example.com/audio-seg1.m4s
     mediaElement.preload = 'auto';
 
     // Initialize: patch owners and state
-    engine.owners.set({ ...engine.owners.get(), mediaElement });
-    engine.state.set({
-      ...engine.state.get(),
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-      preload: 'auto',
-    });
+    engine.context.mediaElement.set(mediaElement);
+    engine.state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
+    engine.state.preload.set('auto');
 
     // Wait for complete orchestration pipeline
     await vi.waitFor(
       () => {
-        const state = engine.state.get();
-        const owners = engine.owners.get();
+        const state = snapshot(engine.state);
+        const owners = snapshot(engine.context);
 
         // === IMMUTABLE STATE VERIFICATION ===
 
@@ -298,17 +306,14 @@ http://example.com/video-seg1.m4s
     const mediaElement = document.createElement('video');
     mediaElement.preload = 'auto';
 
-    engine.owners.set({ ...engine.owners.get(), mediaElement });
-    engine.state.set({
-      ...engine.state.get(),
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-      preload: 'auto',
-    });
+    engine.context.mediaElement.set(mediaElement);
+    engine.state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
+    engine.state.preload.set('auto');
 
     await vi.waitFor(
       () => {
-        const state = engine.state.get();
-        const owners = engine.owners.get();
+        const state = snapshot(engine.state);
+        const owners = snapshot(engine.context);
 
         // Should create video track and buffer
         expect(state.selectedVideoTrackId).toBeDefined();
@@ -363,17 +368,14 @@ http://example.com/audio-seg1.m4s
     const mediaElement = document.createElement('video');
     mediaElement.preload = 'auto';
 
-    engine.owners.set({ ...engine.owners.get(), mediaElement });
-    engine.state.set({
-      ...engine.state.get(),
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-      preload: 'auto',
-    });
+    engine.context.mediaElement.set(mediaElement);
+    engine.state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
+    engine.state.preload.set('auto');
 
     await vi.waitFor(
       () => {
-        const state = engine.state.get();
-        const owners = engine.owners.get();
+        const state = snapshot(engine.state);
+        const owners = snapshot(engine.context);
 
         // Should create audio track and buffer
         expect(state.selectedAudioTrackId).toBeDefined();
@@ -428,16 +430,13 @@ http://example.com/video-seg1.m4s
     const mediaElement = document.createElement('video');
     mediaElement.preload = 'auto';
 
-    engine.owners.set({ ...engine.owners.get(), mediaElement });
-    engine.state.set({
-      ...engine.state.get(),
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-      preload: 'auto',
-    });
+    engine.context.mediaElement.set(mediaElement);
+    engine.state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
+    engine.state.preload.set('auto');
 
     await vi.waitFor(
       () => {
-        const state = engine.state.get();
+        const state = snapshot(engine.state);
 
         // Should have resolved presentation with text tracks
         expect(state.presentation?.selectionSets).toBeDefined();
@@ -485,16 +484,13 @@ http://example.com/video-seg1.m4s
     const engine = createSimpleHlsEngine();
 
     // Patch state but NOT owners (no mediaElement)
-    engine.state.set({
-      ...engine.state.get(),
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-      preload: 'auto',
-    });
+    engine.state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
+    engine.state.preload.set('auto');
 
     // Wait for presentation and track resolution
     await vi.waitFor(
       () => {
-        const state = engine.state.get();
+        const state = snapshot(engine.state);
         expect(state.presentation?.selectionSets).toBeDefined();
         expect(state.selectedVideoTrackId).toBeDefined();
 
@@ -510,7 +506,7 @@ http://example.com/video-seg1.m4s
     // Give time for MediaSource setup (which shouldn't happen)
     await new Promise((resolve) => setTimeout(resolve, 100));
 
-    const owners = engine.owners.get();
+    const owners = snapshot(engine.context);
 
     // Should NOT create MediaSource or SourceBuffers without mediaElement
     expect(owners.mediaElement).toBeUndefined();
@@ -566,16 +562,13 @@ http://example.com/audio-seg1.m4s
     const mediaElement = document.createElement('video');
     mediaElement.preload = 'none';
 
-    engine.owners.set({ ...engine.owners.get(), mediaElement });
-    engine.state.set({
-      ...engine.state.get(),
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-    });
+    engine.context.mediaElement.set(mediaElement);
+    engine.state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
 
     // PHASE 1: Verify nothing auto-resolves
     await new Promise((resolve) => setTimeout(resolve, 200));
 
-    let state = engine.state.get();
+    let state = snapshot(engine.state);
 
     expect(state.presentation?.selectionSets).toBeUndefined();
     expect(mockFetch).not.toHaveBeenCalled();
@@ -588,8 +581,8 @@ http://example.com/audio-seg1.m4s
     // Wait for complete orchestration
     await vi.waitFor(
       () => {
-        state = engine.state.get();
-        const owners = engine.owners.get();
+        state = snapshot(engine.state);
+        const owners = snapshot(engine.context);
 
         // Now everything should be resolved and created
         expect(state.presentation?.selectionSets).toBeDefined();
@@ -647,16 +640,13 @@ http://example.com/seg1.m4s
     const mediaElement = document.createElement('video');
     mediaElement.preload = 'metadata';
 
-    engine.owners.set({ ...engine.owners.get(), mediaElement });
-    engine.state.set({
-      ...engine.state.get(),
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-      preload: 'metadata',
-    });
+    engine.context.mediaElement.set(mediaElement);
+    engine.state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
+    engine.state.preload.set('metadata');
 
     await vi.waitFor(
       () => {
-        const state = engine.state.get();
+        const state = snapshot(engine.state);
 
         // Should resolve presentation and select/resolve track
         expect(state.presentation?.selectionSets).toBeDefined();
@@ -668,7 +658,7 @@ http://example.com/seg1.m4s
         expect(videoTrack?.segments).toBeDefined();
 
         // Init segment should be loaded (advances readyState to HAVE_METADATA)
-        expect(engine.owners.get().videoBufferActor?.snapshot.get().context.initTrackId).toBeDefined();
+        expect(engine.context.videoBufferActor.get()?.snapshot.get().context.initTrackId).toBeDefined();
       },
       { timeout: 2000 }
     );
@@ -725,16 +715,13 @@ http://example.com/seg1.m4s
     const mediaElement = document.createElement('video');
     mediaElement.preload = 'auto';
 
-    engine.owners.set({ ...engine.owners.get(), mediaElement });
-    engine.state.set({
-      ...engine.state.get(),
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-      preload: 'auto',
-    });
+    engine.context.mediaElement.set(mediaElement);
+    engine.state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
+    engine.state.preload.set('auto');
 
     await vi.waitFor(
       () => {
-        const state = engine.state.get();
+        const state = snapshot(engine.state);
         expect(state.selectedVideoTrackId).toBeDefined();
 
         // Selected track should be resolved
@@ -746,7 +733,7 @@ http://example.com/seg1.m4s
       { timeout: 2000 }
     );
 
-    const state = engine.state.get();
+    const state = snapshot(engine.state);
     const allVideoTracks = state.presentation?.selectionSets?.find((s: any) => s.type === 'video')?.switchingSets?.[0]
       ?.tracks;
 
@@ -826,17 +813,14 @@ http://example.com/text-es-seg1.vtt
     const mediaElement = document.createElement('video');
     mediaElement.preload = 'auto';
 
-    engine.owners.set({ ...engine.owners.get(), mediaElement });
-    engine.state.set({
-      ...engine.state.get(),
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-      preload: 'auto',
-    });
+    engine.context.mediaElement.set(mediaElement);
+    engine.state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
+    engine.state.preload.set('auto');
 
     // Wait for presentation to be resolved
     await vi.waitFor(
       () => {
-        const state = engine.state.get();
+        const state = snapshot(engine.state);
         expect(state.presentation?.selectionSets).toBeDefined();
         const textSet = state.presentation?.selectionSets?.find((s: any) => s.type === 'text');
         expect(textSet?.switchingSets?.[0]?.tracks.length).toBeGreaterThan(0);
@@ -845,7 +829,7 @@ http://example.com/text-es-seg1.vtt
     );
 
     // Get text track IDs
-    const textSet = engine.state.get().presentation?.selectionSets?.find((s: any) => s.type === 'text');
+    const textSet = engine.state.presentation.get()?.selectionSets?.find((s: any) => s.type === 'text');
     const textTracks = textSet?.switchingSets?.[0]?.tracks;
     expect(textTracks?.length).toBe(2);
 
@@ -853,15 +837,12 @@ http://example.com/text-es-seg1.vtt
     expect(englishTrack).toBeDefined();
 
     // Manually select English text track
-    engine.state.set({
-      ...engine.state.get(),
-      selectedTextTrackId: englishTrack!.id,
-    });
+    engine.state.selectedTextTrackId.set(englishTrack!.id);
 
     // Wait for text track to be resolved
     await vi.waitFor(
       () => {
-        const state = engine.state.get();
+        const state = snapshot(engine.state);
         expect(state.selectedTextTrackId).toBe(englishTrack!.id);
 
         // Text track should be resolved (has segments)
@@ -926,17 +907,14 @@ http://example.com/text-es-seg1.vtt
     const mediaElement = document.createElement('video');
     mediaElement.preload = 'auto';
 
-    engine.owners.set({ ...engine.owners.get(), mediaElement });
-    engine.state.set({
-      ...engine.state.get(),
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-      preload: 'auto',
-    });
+    engine.context.mediaElement.set(mediaElement);
+    engine.state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
+    engine.state.preload.set('auto');
 
     // Wait for DEFAULT text track to be auto-selected and resolved
     await vi.waitFor(
       () => {
-        const state = engine.state.get();
+        const state = snapshot(engine.state);
         expect(state.presentation?.selectionSets).toBeDefined();
 
         // Should auto-select text track with DEFAULT=YES + AUTOSELECT=YES
@@ -1005,17 +983,14 @@ http://example.com/text-fr-seg1.vtt
     const mediaElement = document.createElement('video');
     mediaElement.preload = 'auto';
 
-    engine.owners.set({ ...engine.owners.get(), mediaElement });
-    engine.state.set({
-      ...engine.state.get(),
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-      preload: 'auto',
-    });
+    engine.context.mediaElement.set(mediaElement);
+    engine.state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
+    engine.state.preload.set('auto');
 
     // Wait for preferred language text track to be auto-selected and resolved
     await vi.waitFor(
       () => {
-        const state = engine.state.get();
+        const state = snapshot(engine.state);
         expect(state.presentation?.selectionSets).toBeDefined();
 
         expect(state.selectedTextTrackId).toBeDefined();
@@ -1091,37 +1066,31 @@ http://example.com/text-es-seg1.vtt
     const mediaElement = document.createElement('video');
     mediaElement.preload = 'auto';
 
-    engine.owners.set({ ...engine.owners.get(), mediaElement });
-    engine.state.set({
-      ...engine.state.get(),
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-      preload: 'auto',
-    });
+    engine.context.mediaElement.set(mediaElement);
+    engine.state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
+    engine.state.preload.set('auto');
 
     // Wait for presentation to be resolved
     await vi.waitFor(
       () => {
-        const state = engine.state.get();
+        const state = snapshot(engine.state);
         expect(state.presentation?.selectionSets).toBeDefined();
       },
       { timeout: 2000 }
     );
 
-    const textSet = engine.state.get().presentation?.selectionSets?.find((s: any) => s.type === 'text');
+    const textSet = engine.state.presentation.get()?.selectionSets?.find((s: any) => s.type === 'text');
     const textTracks = textSet?.switchingSets?.[0]?.tracks;
 
     const englishTrack = textTracks?.find((t: any) => t.language === 'en');
     const spanishTrack = textTracks?.find((t: any) => t.language === 'es');
 
     // Select English track
-    engine.state.set({
-      ...engine.state.get(),
-      selectedTextTrackId: englishTrack!.id,
-    });
+    engine.state.selectedTextTrackId.set(englishTrack!.id);
 
     await vi.waitFor(
       () => {
-        const state = engine.state.get();
+        const state = snapshot(engine.state);
         expect(state.selectedTextTrackId).toBe(englishTrack!.id);
 
         const resolvedTrack = state.presentation?.selectionSets
@@ -1134,14 +1103,11 @@ http://example.com/text-es-seg1.vtt
     );
 
     // Switch to Spanish track
-    engine.state.set({
-      ...engine.state.get(),
-      selectedTextTrackId: spanishTrack!.id,
-    });
+    engine.state.selectedTextTrackId.set(spanishTrack!.id);
 
     await vi.waitFor(
       () => {
-        const state = engine.state.get();
+        const state = snapshot(engine.state);
         expect(state.selectedTextTrackId).toBe(spanishTrack!.id);
 
         const resolvedTrack = state.presentation?.selectionSets
@@ -1192,12 +1158,9 @@ http://example.com/video-seg1.m4s
     const mediaElement = document.createElement('video');
     mediaElement.preload = 'auto';
 
-    engine.owners.set({ ...engine.owners.get(), mediaElement });
-    engine.state.set({
-      ...engine.state.get(),
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-      preload: 'auto',
-    });
+    engine.context.mediaElement.set(mediaElement);
+    engine.state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
+    engine.state.preload.set('auto');
 
     // Wait for text tracks to be set up
     await vi.waitFor(
@@ -1289,12 +1252,9 @@ http://example.com/text-es-seg1.vtt
     const mediaElement = document.createElement('video');
     mediaElement.preload = 'auto';
 
-    engine.owners.set({ ...engine.owners.get(), mediaElement });
-    engine.state.set({
-      ...engine.state.get(),
-      presentation: { url: 'http://example.com/playlist.m3u8' },
-      preload: 'auto',
-    });
+    engine.context.mediaElement.set(mediaElement);
+    engine.state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
+    engine.state.preload.set('auto');
 
     // Wait for text tracks to be set up
     await vi.waitFor(
@@ -1316,10 +1276,7 @@ http://example.com/text-es-seg1.vtt
     expect(spanishTrack.track.mode).toBe('disabled');
 
     // Select English track
-    engine.state.set({
-      ...engine.state.get(),
-      selectedTextTrackId: englishTrack.id,
-    });
+    engine.state.selectedTextTrackId.set(englishTrack.id);
 
     await vi.waitFor(
       () => {
@@ -1330,10 +1287,7 @@ http://example.com/text-es-seg1.vtt
     );
 
     // Switch to Spanish track
-    engine.state.set({
-      ...engine.state.get(),
-      selectedTextTrackId: spanishTrack.id,
-    });
+    engine.state.selectedTextTrackId.set(spanishTrack.id);
 
     await vi.waitFor(
       () => {
@@ -1343,9 +1297,8 @@ http://example.com/text-es-seg1.vtt
       { timeout: 2000 }
     );
 
-    // Deselect (disable all) — omit selectedTextTrackId to satisfy exactOptionalPropertyTypes
-    const { selectedTextTrackId: _removed, ...deselected } = engine.state.get();
-    engine.state.set(deselected as ReturnType<typeof engine.state.get>);
+    // Deselect (disable all)
+    engine.state.selectedTextTrackId.set(undefined);
 
     await vi.waitFor(
       () => {
@@ -1398,17 +1351,14 @@ http://example.com/seg2.m4s
   const mediaElement = document.createElement('video');
   mediaElement.preload = 'auto';
 
-  engine.owners.set({ ...engine.owners.get(), mediaElement });
-  engine.state.set({
-    ...engine.state.get(),
-    presentation: { url: 'http://example.com/playlist.m3u8' },
-    preload: 'auto',
-  });
+  engine.context.mediaElement.set(mediaElement);
+  engine.state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
+  engine.state.preload.set('auto');
 
   await vi.waitFor(
     () => {
       // Buffer state now lives in the SourceBufferActor (in owners), not in state.
-      const videoCtx = engine.owners.get().videoBufferActor?.snapshot.get().context;
+      const videoCtx = engine.context.videoBufferActor.get()?.snapshot.get().context;
 
       // Should have init segment tracked (by track ID)
       expect(videoCtx?.initTrackId).toBeDefined();
@@ -1476,18 +1426,15 @@ http://example.com/audio-seg1.m4s
   const mediaElement = document.createElement('video');
   mediaElement.preload = 'auto';
 
-  engine.owners.set({ ...engine.owners.get(), mediaElement });
-  engine.state.set({
-    ...engine.state.get(),
-    presentation: { url: 'http://example.com/playlist.m3u8' },
-    preload: 'auto',
-  });
+  engine.context.mediaElement.set(mediaElement);
+  engine.state.presentation.set({ url: 'http://example.com/playlist.m3u8' });
+  engine.state.preload.set('auto');
 
   await vi.waitFor(
     () => {
       // Buffer state now lives in the SourceBufferActors (in owners), not in state.
-      const videoCtx = engine.owners.get().videoBufferActor?.snapshot.get().context;
-      const audioCtx = engine.owners.get().audioBufferActor?.snapshot.get().context;
+      const videoCtx = engine.context.videoBufferActor.get()?.snapshot.get().context;
+      const audioCtx = engine.context.audioBufferActor.get()?.snapshot.get().context;
 
       // Both video and audio actors should exist
       expect(videoCtx).toBeDefined();