@playfast/reform 0.1.0 → 1.1.1

package/src/scene/featureScene.test.ts

@@ -0,0 +1,59 @@
+import { Context, Effect, Layer, Schema as S } from 'effect'
+import { expect, test } from 'vitest'
+import * as Composition from '../compose/composition'
+import { mount } from '../compose/structure'
+import { ui } from '../compose/ui'
+import * as Event from '../event/event'
+import * as Feature from '../feature/feature'
+import { featureModule } from '../feature/feature'
+import { makeAppRuntime } from '../runtime/appRuntime'
+import { Engine } from '../runtime/loop'
+import { featureScene } from './scene'
+
+interface GreetingService {
+  readonly value: string
+}
+
+const GreetingBase: Context.TagClass<Greeting, 'featureScene.Greeting', GreetingService> =
+  Context.Tag('featureScene.Greeting')<Greeting, GreetingService>()
+class Greeting extends GreetingBase {}
+
+class Started extends Event.make('featureScene.Started', S.Struct({})) {}
+class RootUi extends ui('featureScene.RootUi')<{ props: { readonly greeting: string } }>() {}
+class RootComp extends Composition.make('featureScene.RootComp', {
+  title: 'Feature root',
+  ui: RootUi,
+}) {}
+
+const RootLive = Composition.live(RootComp, function* () {
+  const greeting = yield* Greeting
+  return mount({ props: { greeting: greeting.value }, slots: {} })
+})
+
+class RootFeature extends Feature.make('featureScene.root', {
+  composition: RootComp,
+  module: featureModule([Greeting], RootLive),
+  boot: [Event.construct(Started, {})],
+}) {}
+
+test('featureScene closes an eager root Feature with its typed requirements and boot', () => {
+  const root = featureScene(RootFeature, {
+    provide: Layer.mergeAll(Engine, Layer.succeed(Greeting, { value: 'hello' })),
+  })
+  const app = makeAppRuntime(root)
+
+  try {
+    const rendered = Effect.runSync(
+      Composition.render(app.read(RootComp.tag), {
+        props: {},
+        tracker: { add: () => {} },
+      }),
+    )
+
+    expect(root.composition).toBe(RootComp)
+    expect(root.boot).toEqual([Event.construct(Started, {})])
+    expect(rendered.props).toEqual({ greeting: 'hello' })
+  } finally {
+    app.dispose()
+  }
+})

package/src/scene/scene.ts

@@ -2,33 +2,23 @@ import { Layer, Struct } from 'effect'
 import type { CompositionClass, CompositionService } from '../compose/composition'
 import type { UiContract } from '../compose/ui'
 import type { EventOf } from '../event/event'
+import type {
+  EagerFeatureClass,
+  EngineServices,
+  FeatureRequirement,
+  ProvidedBy,
+} from '../feature/feature'
 import { CurrentSeedOverrides } from '../internal/seeds'
 import type { SeedsOf } from '../state/stateGroup'
 import type { Bus } from '../runtime/bus'
+import {
+  CurrentInstrumentation,
+  type Instrumentation,
+  noopInstrumentation,
+} from '../runtime/instrumentation'
 
-// A scene is a VALUE — a composition plus the closed wiring that runs it: the
-// layers that supply its logic/views (each seeding its own live state) and the
-// boot events to dispatch once the runtime is live. Nothing self-registers on
-// import. A scene is the single handle every consumer takes instead of a bare
-// composition: the react host renders it, a proof runs against it, and the dev
-// tool previews it — all from the same closed `provide`.
-//
-// There is no seeded-`state` dict: variation (Default/Empty/Errored) comes from
-// providing different closed layers, exactly as production wiring does. The
-// composition's contract `C` is preserved (not erased to `unknown`) so a proof's
-// facade stays fully typed from `scene.composition`.
-
-/**
- * The services a built reform runtime exposes to its host: every composition's
- * logic and the event `Bus`. A scene's `provide` must close to these (a fully
- * wired app layer provides far more; this is the subset hosts read directly).
- */
 export type MountedServices = CompositionService | Bus
 
-// A scene's boot list holds CONSTRUCTED events (`Event.construct(E, payload)`),
-// not bare tagged objects — a lightweight nudge toward the real builder. It is
-// not a guarantee the event is handled by the wiring (reform carries no
-// type-level union of handled tags), only that it came from an event definition.
 type BootEvent = EventOf<string, unknown>
 
 export interface Scene<
@@ -36,27 +26,21 @@ export interface Scene<
   S extends ReadonlyArray<unknown> = ReadonlyArray<unknown>,
 > {
   readonly kind: 'Scene'
-  /** The composition to run, with its contract + states preserved for typed consumers. */
   readonly composition: CompositionClass<unknown, C, S>
-  /** Closed wiring (logic + views), each layer seeding its own live state. */
   readonly provide: ReadonlyArray<Layer.Layer<MountedServices, never, never>>
-  /** Events dispatched once the runtime is live (e.g. `RequestedTodos`). */
   // oxlint-disable-next-line reform-rules/no-optional-fields -- presence-optional boot read as `scene.boot ?? []` across non-batch hosts (drive/proof/remote/react/editor); Option would break them
   readonly boot?: ReadonlyArray<BootEvent>
+  // instrumentation on the scene (not only layers): host render spans live outside layer context
+  // oxlint-disable-next-line reform-rules/no-optional-fields -- presence-optional carrier like `boot`; absent on every unprofiled scene, so Option would tax all authoring call sites
+  readonly instrumentation?: Instrumentation
 }
 
-/** Closed wiring + optional boot events handed to {@link scene}. */
 export interface SceneConfig {
   readonly provide: ReadonlyArray<Layer.Layer<MountedServices, never, never>>
   // oxlint-disable-next-line reform-rules/no-optional-fields -- mirrors Scene.boot; presence-optional to keep the authoring call site terse and back-compatible
   readonly boot?: ReadonlyArray<BootEvent>
 }
 
-/**
- * Define a scene — `scene(TodoApp, { provide: [makeTestApp(client, seeds)] })`.
- * The composition's contract `C` and state tuple `S` flow through, so consumers
- * (the facade, `seedScene`) stay typed.
- */
 export const scene = <C extends UiContract, S extends ReadonlyArray<unknown>>(
   composition: CompositionClass<unknown, C, S>,
   config: SceneConfig,
@@ -67,19 +51,31 @@ export const scene = <C extends UiContract, S extends ReadonlyArray<unknown>>(
   ...(config.boot !== undefined ? { boot: config.boot } : {}),
 })
 
-/**
- * Overlay seed values onto a CLOSED scene — the tooling/test seam (dev-tool
- * inspector overrides, proofs). Scenes stay closed for authors: this does not
- * reopen `provide`, it wraps each layer with `Layer.locally(CurrentSeedOverrides,
- * seeds)` so `State.live` boots matching stores from the override instead of
- * the authored seed.
- *
- * Keys are state MEMBER NAMES as reflected in `manifest.states` (e.g. `count`),
- * not group names. If two groups in one scene share a member name, both receive
- * the override (documented limitation). Values are schema-validated at build:
- * an invalid value silently falls back to the authored seed. `StateFamily`
- * entries are not covered.
- */
+export interface FeatureSceneConfig<
+  Requires extends ReadonlyArray<FeatureRequirement>,
+> {
+  readonly provide: Layer.Layer<EngineServices | ProvidedBy<Requires>, never, never>
+}
+
+export const featureScene = <
+  P,
+  C extends UiContract,
+  ROut,
+  Requires extends ReadonlyArray<FeatureRequirement>,
+>(
+  feature: EagerFeatureClass<P, C, ROut, Requires>,
+  config: FeatureSceneConfig<Requires>,
+): Scene<C> => {
+  const app = feature.eagerModule.layer.pipe(Layer.provideMerge(config.provide))
+  // oxlint-disable-next-line reform-rules/no-type-assertion -- close the generic root module's erased output to the host-readable Scene subset
+  const closed = app as Layer.Layer<MountedServices, never, never>
+  return scene(feature.composition, {
+    provide: [closed],
+    boot: feature.binding.boot,
+  })
+}
+
+// Tooling seam: wrap closed layers with seed overrides; keys are member names (not group names)
 export const seedScene = <C extends UiContract, S extends ReadonlyArray<unknown>>(
   base: Scene<C, S>,
   seeds: SeedsOf<S>,
@@ -88,7 +84,18 @@ export const seedScene = <C extends UiContract, S extends ReadonlyArray<unknown>
     ? base
     : { ...base, provide: base.provide.map(Layer.locally(CurrentSeedOverrides, seeds)) }
 
-/** Reflection guard: is this exported value a scene? */
+export const profiledScene = <C extends UiContract, S extends ReadonlyArray<unknown>>(
+  base: Scene<C, S>,
+  instrumentation: Instrumentation,
+): Scene<C, S> => ({
+  ...base,
+  instrumentation,
+  provide: base.provide.map(Layer.locally(CurrentInstrumentation, instrumentation)),
+})
+
+export const sceneInstrumentation = (candidate: Scene): Instrumentation =>
+  candidate.instrumentation ?? noopInstrumentation
+
 export const isScene = (candidate: unknown): candidate is Scene =>
   typeof candidate === 'object' &&
   candidate !== null &&

package/src/scene/seedScene.test.ts

@@ -1,5 +1,5 @@
-import { Effect, Layer, ManagedRuntime, Schema as S } from 'effect'
-import { expect, test } from 'vitest'
+import { Effect, Layer, Schema as S } from "effect";
+import { expect, it } from "@effect/vitest";
 import {
   Composition,
   Engine,
@@ -17,93 +17,84 @@ import {
   StateGroup,
   Ui,
   ui,
-} from '../index'
-import { CurrentSeedOverrides } from '../internal/seeds'
+} from "../index";
+import { CurrentSeedOverrides } from "../internal/seeds";
 
-// `seedScene` is the tooling seam over CLOSED scenes: the app bundle below seeds
-// `count: 1` itself (no open store), and the overlay must reach the nested
-// `State.live` through `Layer.locally(CurrentSeedOverrides, …)` on the scene's
-// pre-composed layers. The harness mirrors the dev-tool preview: merge the
-// scene's `provide`, mount it in a ManagedRuntime, and read the root
-// composition's rendered props through the headless Structure.
-
-class CountState extends State.make('count', S.Number) {}
+class CountState extends State.make("count", S.Number) {}
 class MiniStates extends StateGroup.make(CountState) {}
 
-class Bumped extends Event.make('Bumped', S.Struct({})) {}
+class Bumped extends Event.make("Bumped", S.Struct({})) {}
 
-class BumpReducer extends Reducer.make('BumpReducer', {
+class BumpReducer extends Reducer.make("BumpReducer", {
   states: [CountState],
   events: [Bumped],
 }) {}
-const BumpReducerLive = Reducer.live(BumpReducer, (n) => n + 1)
+const BumpReducerLive = Reducer.live(BumpReducer, (n) => n + 1);
 
-class CounterUi extends ui('Counter')<{ props: { count: number } }>() {}
-class Counter extends Composition.make('Counter', {
-  title: 'Counter',
+class CounterUi extends ui("Counter")<{ props: { count: number } }>() {}
+class Counter extends Composition.make("Counter", {
+  title: "Counter",
   states: [MiniStates],
   events: [Bumped],
   ui: CounterUi,
 }) {}
 const CounterLive = Composition.live(Counter, function* () {
-  const count = yield* StateGroup.select(MiniStates, 'count')
-  return mount({ props: { count }, slots: {} })
-})
-
-// The closed app layer a scene provides: views + logic + Engine, with the state
-// group seeding its AUTHORED value `count: 1` itself.
-const presentations = provide(CounterUi, Ui.make(CounterUi, () => null))
-const Views = CounterLive.pipe(Layer.provideMerge(presentations))
+  const count = yield* StateGroup.select(MiniStates, "count");
+  return mount({ props: { count }, slots: {} });
+});
+
+const presentations = provide(
+  CounterUi,
+  Ui.make(CounterUi, () => null),
+);
+const Views = CounterLive.pipe(Layer.provideMerge(presentations));
 const Logic = Layer.mergeAll(BumpReducerLive).pipe(
-  Layer.provideMerge(Layer.mergeAll(Engine, StateGroup.live(MiniStates, { count: 1 }))),
-)
-const MiniApp = Views.pipe(Layer.provideMerge(Logic))
-
-const CounterScene = scene(Counter, { provide: [MiniApp] })
-
-// The dev-tool inspector overlays raw, user-typed seeds (`Record<string, unknown>`)
-// — the untyped seam that `seedScene` wraps once a composition's state tuple is
-// known. These two cases (absent key / schema-invalid value) are compile errors
-// through the now-typed `seedScene`, so they're exercised here at the raw overlay
-// to prove `resolveSeed`'s runtime defensiveness still falls back to the seed.
-const overlayRawSeeds = (base: Scene, seeds: Readonly<Record<string, unknown>>): Scene => ({
+  Layer.provideMerge(
+    Layer.mergeAll(Engine, StateGroup.live(MiniStates, { count: 1 })),
+  ),
+);
+const MiniApp = Views.pipe(Layer.provideMerge(Logic));
+
+const CounterScene = scene(Counter, { provide: [MiniApp] });
+
+const overlayRawSeeds = (
+  base: Scene,
+  seeds: Readonly<Record<string, unknown>>,
+): Scene => ({
   ...base,
   provide: base.provide.map(Layer.locally(CurrentSeedOverrides, seeds)),
-})
+});
 
 const headlessEnv: RenderEnv = {
   props: {},
   tracker: { add: () => {} },
-}
+};
 
 const isCountProps = (props: unknown): props is { readonly count: number } =>
-  typeof props === 'object' &&
+  typeof props === "object" &&
   props !== null &&
-  'count' in props &&
-  typeof props.count === 'number'
+  "count" in props &&
+  typeof props.count === "number";
 
-// One ManagedRuntime per scene under test. Each `read` re-renders the root
-// composition and reads the Structure built from the stores that runtime actually
-// constructed.
 const makeHarness = (s: Scene) => {
-  const layer = s.provide.reduce((a, b) => Layer.merge(a, b))
-  const runtime = ManagedRuntime.make(layer)
+  const layer = s.provide.reduce((a, b) => Layer.merge(a, b));
   const read = Effect.flatMap(Counter.tag, (c) =>
     Composition.render(c, headlessEnv).pipe(
       Effect.flatMap((frame) => {
         if (!isStructure(frame)) {
-          return Effect.dieMessage('Counter must render a Structure')
+          return Effect.dieMessage("Counter must render a Structure");
         }
         return isCountProps(frame.props)
           ? Effect.succeed(frame.props.count)
-          : Effect.dieMessage('Counter Structure props must include numeric count')
+          : Effect.dieMessage(
+              "Counter Structure props must include numeric count",
+            );
       }),
     ),
-  )
-  return { runtime, read }
-}
+  );
+  return { layer, read };
+};
 
-// Drive a read until a predicate holds, handing forked fibers the scheduler.
 const waitUntil = <A, R>(
   read: Effect.Effect<A, never, R>,
   pred: (a: A) => boolean,
@@ -112,65 +103,54 @@ const waitUntil = <A, R>(
   Effect.flatMap(read, (a) =>
     pred(a) || rounds <= 0
       ? Effect.succeed(a)
-      : Effect.flatMap(Effect.yieldNow(), () => waitUntil(read, pred, rounds - 1)),
-  )
-
-test('a seeded scene boots its store from the override', async () => {
-  const { runtime, read } = makeHarness(seedScene(CounterScene, { count: 5 }))
-  try {
-    expect(await runtime.runPromise(read)).toBe(5)
-  } finally {
-    await runtime.dispose()
-  }
-})
-
-test('the live reducer drives the SAME overridden store', async () => {
-  const { runtime, read } = makeHarness(seedScene(CounterScene, { count: 5 }))
-  try {
-    const next = await runtime.runPromise(
-      Effect.gen(function* () {
-        expect(yield* read).toBe(5)
-        yield* publish('High', Event.construct(Bumped, {}))
-        return yield* waitUntil(read, (n) => n === 6)
-      }),
-    )
-    expect(next).toBe(6)
-  } finally {
-    await runtime.dispose()
-  }
-})
-
-test('an absent key leaves the authored seed in place', async () => {
-  const { runtime, read } = makeHarness(overlayRawSeeds(CounterScene, { other: 1 }))
-  try {
-    expect(await runtime.runPromise(read)).toBe(1)
-  } finally {
-    await runtime.dispose()
-  }
-})
-
-test('a schema-invalid override falls back to the authored seed', async () => {
-  const { runtime, read } = makeHarness(overlayRawSeeds(CounterScene, { count: 'not-a-number' }))
-  try {
-    expect(await runtime.runPromise(read)).toBe(1)
-  } finally {
-    await runtime.dispose()
-  }
-})
-
-test('seeding does not leak into the original scene', async () => {
-  const seeded = makeHarness(seedScene(CounterScene, { count: 5 }))
-  try {
-    expect(await seeded.runtime.runPromise(seeded.read)).toBe(5)
-  } finally {
-    await seeded.runtime.dispose()
-  }
-  // Building the ORIGINAL scene's layers again boots from the authored seed —
-  // the overlay lives only on the seeded variant's wrapped layers.
-  const original = makeHarness(CounterScene)
-  try {
-    expect(await original.runtime.runPromise(original.read)).toBe(1)
-  } finally {
-    await original.runtime.dispose()
-  }
-})
+      : Effect.flatMap(Effect.yieldNow(), () =>
+          waitUntil(read, pred, rounds - 1),
+        ),
+  );
+
+it.scopedLive("a seeded scene boots its store from the override", () => {
+  const { layer, read } = makeHarness(seedScene(CounterScene, { count: 5 }));
+  return Effect.gen(function* () {
+    expect(yield* read).toBe(5);
+  }).pipe(Effect.provide(layer));
+});
+
+it.scopedLive("the live reducer drives the SAME overridden store", () => {
+  const { layer, read } = makeHarness(seedScene(CounterScene, { count: 5 }));
+  return Effect.gen(function* () {
+    expect(yield* read).toBe(5);
+    yield* publish("High", Event.construct(Bumped, {}));
+    const next = yield* waitUntil(read, (n) => n === 6);
+    expect(next).toBe(6);
+  }).pipe(Effect.provide(layer));
+});
+
+it.scopedLive("an absent key leaves the authored seed in place", () => {
+  const { layer, read } = makeHarness(
+    overlayRawSeeds(CounterScene, { other: 1 }),
+  );
+  return Effect.gen(function* () {
+    expect(yield* read).toBe(1);
+  }).pipe(Effect.provide(layer));
+});
+
+it.scopedLive(
+  "a schema-invalid override falls back to the authored seed",
+  () => {
+    const { layer, read } = makeHarness(
+      overlayRawSeeds(CounterScene, { count: "not-a-number" }),
+    );
+    return Effect.gen(function* () {
+      expect(yield* read).toBe(1);
+    }).pipe(Effect.provide(layer));
+  },
+);
+
+it.scopedLive("seeding does not leak into the original scene", () => {
+  const seeded = makeHarness(seedScene(CounterScene, { count: 5 }));
+  const original = makeHarness(CounterScene);
+  return Effect.gen(function* () {
+    expect(yield* seeded.read.pipe(Effect.provide(seeded.layer))).toBe(5);
+    expect(yield* original.read.pipe(Effect.provide(original.layer))).toBe(1);
+  });
+});

package/src/state/state.ts

@@ -1,10 +1,13 @@
 import { Context, Effect, FiberRef, Layer, Option, Schema } from 'effect'
+import type { Effect as EffectType } from 'effect/Effect'
 import { type Manifest, yieldableClass } from '../definition/definition'
 import { resolveScheduler } from '../internal/scheduler'
 import { CurrentSeedOverrides } from '../internal/seeds'
+import { resolveInstrumentation, stateUpdateHook } from '../runtime/instrumentation'
 import { claimStateTag } from '../internal/stateRegistry'
 import { makeStore, type Store } from '../internal/store'
 import { readTracked } from '../internal/track'
+import type { AnySchema, AnyValue } from '../internal/variance'
 
 export interface StateOptionsExternalApi {
   readonly title?: string
@@ -15,32 +18,25 @@ export type StateOptions = StateOptionsExternalApi
 export interface StateManifestExternalApi<N extends string, A> extends Manifest {
   readonly kind: 'State'
   readonly name: N
-  readonly schema: Schema.Schema<A, any>
+  readonly schema: AnySchema<A>
   readonly title?: string
   readonly description?: string
 }
 export type StateManifest<N extends string, A> = StateManifestExternalApi<N, A>
 
-export interface StateClass<out N extends string, in out A> extends Effect.Effect<A, never, Store<A>> {
+export interface StateClass<out N extends string, in out A> extends EffectType<A, never, Store<A>> {
   new (): {}
   readonly manifest: StateManifest<N, A>
-  /** Internal DI tag holding the live store. The loop reads/writes through it. */
   readonly store: Context.Tag<Store<A>, Store<A>>
 }
 
-export type AnyState = StateClass<string, any>
+export type AnyState = StateClass<string, AnyValue>
 export type StateValue<S> = S extends StateClass<string, infer A> ? A : never
-export type StateName<S> = S extends StateClass<infer N, any> ? N : never
+export type StateName<S> = S extends StateClass<infer N, AnyValue> ? N : never
 
-/**
- * Atomic reactive state. `State.make` is the *definition* (a reflectable
- * manifest + an internal store tag); it carries no starting value — the seed is
- * an implementation detail supplied at create-time by `State.live(state, seed)`.
- * Composed into a `StateGroup` exactly as `@effect/rpc` composes rpcs.
- */
 export const make = <const N extends string, A>(
   name: N,
-  schema: Schema.Schema<A, any>,
+  schema: AnySchema<A>,
   options: StateOptions = {},
 ): StateClass<N, A> => {
   const identifier = `reform/state/${name}`
@@ -57,15 +53,6 @@ export const make = <const N extends string, A>(
   return yieldableClass(read, { manifest, store })
 }
 
-/**
- * Resolve the value a store should boot from: the ambient seed override when
- * one is present (and valid) for this state's member name, else the authored
- * `initial`. Reads `CurrentSeedOverrides` — empty outside the tooling seam
- * (`Scene.seedScene`), so production wiring always boots from `initial`. An
- * override is decoded against the state's schema; an invalid value silently
- * falls back to `initial` — a half-typed override from the dev tool must never
- * crash a preview.
- */
 const resolveSeed = <S extends AnyState>(
   state: S,
   initial: StateValue<S>,
@@ -78,18 +65,15 @@ const resolveSeed = <S extends AnyState>(
     return Option.getOrElse(override, () => initial)
   })
 
-/**
- * Allocate a state's store, seeded with `initial` — `State.live(Feed, seed)`.
- * The seed lives here (implementation), not on the definition, so the same
- * definition can boot from different values in app vs. test wiring.
- */
 export const live = <S extends AnyState>(
   state: S,
   initial: StateValue<S>,
 ): Layer.Layer<Store<StateValue<S>>> =>
   Layer.effect(
     state.store,
-    Effect.zipWith(resolveScheduler, resolveSeed(state, initial), (scheduler, seed) =>
-      makeStore(seed, scheduler),
+    Effect.all([resolveScheduler, resolveSeed(state, initial), resolveInstrumentation]).pipe(
+      Effect.map(([scheduler, seed, instrumentation]) =>
+        makeStore(seed, scheduler, stateUpdateHook(instrumentation, state.manifest.name)),
+      ),
     ),
   )

package/src/state/stateFamily.test.ts

@@ -2,9 +2,6 @@ import { expect, it } from '@effect/vitest'
 import { Duration, Effect, Layer, Schema as S } from 'effect'
 import { Engine, Event, publish, Reducer, StateFamily } from '../index'
 
-// A family is normalized keyed state: one logical slice per key, so a write to
-// one key must wake only that key's subscribers (the point of the primitive).
-
 const tick = Effect.sleep(Duration.millis(1))
 
 it.live("writing one key does not notify another key's subscribers", () => {
@@ -53,7 +50,6 @@ it.live('forget(key) drops the store; re-reading the key reseeds it', () => {
     expect(family.at('k').get()).toBe(42)
 
     family.forget('k')
-    // A fresh store, reseeded to the family's initial value — not the old 42.
     const reseeded = family.at('k')
     expect(reseeded).not.toBe(first)
     expect(reseeded.get()).toBe(0)
@@ -71,16 +67,13 @@ it.live('evictWhenUnused drops a key once its last subscriber leaves', () => {
     const offB = store.subscribe(() => {})
     expect(family.size()).toBe(1)
 
-    // One subscriber leaving keeps the key (another still reads it).
     offA()
     yield* tick
     expect(family.size()).toBe(1)
 
-    // The last subscriber leaving evicts the key on the next microtask.
     offB()
     yield* tick
     expect(family.size()).toBe(0)
-    // Re-reading reseeds a fresh store.
     expect(family.at('k').get()).toBe(0)
   }).pipe(Effect.provide(TestLayer))
 })
@@ -94,10 +87,9 @@ it.live('evictWhenUnused: a same-tick re-subscribe cancels eviction', () => {
     const store = family.at('k')
     store.set(7)
     const off = store.subscribe(() => {})
-    off() // count → 0, eviction scheduled for the next microtask
-    store.subscribe(() => {}) // re-subscribe in the same tick → count back to 1
+    off()
+    store.subscribe(() => {})
     yield* tick
-    // Not evicted: the value survives and `at` returns the same live store.
     expect(family.size()).toBe(1)
     expect(family.at('k').get()).toBe(7)
   }).pipe(Effect.provide(TestLayer))
@@ -128,7 +120,6 @@ it.live('a family reducer fold returning Tombstone evicts the key', () => {
     const before = family.at('a')
     expect(before.get()).toBe(1)
 
-    // The fold returns the eviction sentinel: the key's store is dropped.
     yield* publish('High', Event.construct(Removed, { id: 'a' }))
     yield* Effect.sleep(Duration.millis(5))
     const after = family.at('a')