@playfast/reform 1.1.1 → 1.2.0

package/src/remote/remoteState.test.ts

@@ -2,18 +2,17 @@ import { expect, it } from '@effect/vitest'
 import { Duration, Effect, Layer, Match, Option, Schema as S } from 'effect'
 import {
   Channel,
-  Channels,
   Engine,
   Event,
-  Procedures,
-  QueryStore,
   Procedure,
   Reducer,
-  Reducers,
   RemoteState,
   State,
   StateGroup,
 } from '../index'
+import { Channels, Procedures } from '../channel/channel'
+import { QueryStore } from '../internal/queryStore'
+import { Reducers } from '../runtime/loop'
 
 const tick = (ms = 10) => Effect.sleep(Duration.millis(ms))
 
@@ -110,7 +109,10 @@ it.live('settled dispatches after Success is committed to truth', () => {
   )
 
   return Effect.gen(function* () {
-    yield* until(() => observed, (values) => values.length === 1)
+    yield* until(
+      () => observed,
+      (values) => values.length === 1,
+    )
     expect(observed).toEqual(['Success'])
   }).pipe(Effect.provide(TestLayer))
 })
@@ -150,7 +152,10 @@ it.live('settled dispatches after Error is committed to truth', () => {
   )
 
   return Effect.gen(function* () {
-    yield* until(() => observed, (values) => values.length === 1)
+    yield* until(
+      () => observed,
+      (values) => values.length === 1,
+    )
     expect(observed).toEqual(['Error'])
   }).pipe(Effect.provide(TestLayer))
 })
@@ -179,7 +184,10 @@ it.live('an intent overlays instantly — no fetch fired, truth untouched', () =
     const store = yield* Items.store
     const truth = yield* Items.truth.store
     const queue = yield* Items.pending.store
-    yield* until(() => store.get(), (v) => v._tag === 'Success')
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
     expect(server.state.fetches).toBe(1)
 
     yield* Event.dispatch(Added, { id: 'b', name: 'beta' })
@@ -198,173 +206,215 @@ it.live('an intent overlays instantly — no fetch fired, truth untouched', () =
   }).pipe(Effect.provide(TestLayer))
 })
 
-it.live('convergence: the send acks, the refetch lands, the queue drains — and no frame ever lacked the row', () => {
-  class Page extends State.make('page', S.Number) {}
-  class Inputs extends StateGroup.make(Page) {}
-  const server = makeServer([{ id: 'a', name: 'alpha' }])
-  class Items extends RemoteState.make('Items', {
-    inputs: [StateGroup.select(Inputs, 'page')],
-    output: S.Array(Item),
-    intents: [Added, Renamed],
-    alwaysOn: true,
-  }) {}
-  const ItemsLive = RemoteState.live(Items, {
-    query: () => server.fetch(15),
-    send: (intent) => server.receive(intent, 15),
-    apply: applyIntent,
-  })
-  const TestLayer = ItemsLive.pipe(
-    Layer.provideMerge(StateGroup.live(Inputs, { page: 1 })),
-    Layer.provideMerge(Engine),
-  )
-
-  return Effect.gen(function* () {
-    const store = yield* Items.store
-    const queue = yield* Items.pending.store
-    yield* until(() => store.get(), (v) => v._tag === 'Success')
-
-    // Flicker guard: once optimistic row appears, no later Success frame may lack it
-    const frames: Array<number> = []
-    const off = store.subscribe(() => {
-      const v = store.get()
-      if (v._tag === 'Success') frames.push(v.value.length)
+it.live(
+  'convergence: the send acks, the refetch lands, the queue drains — and no frame ever lacked the row',
+  () => {
+    class Page extends State.make('page', S.Number) {}
+    class Inputs extends StateGroup.make(Page) {}
+    const server = makeServer([{ id: 'a', name: 'alpha' }])
+    class Items extends RemoteState.make('Items', {
+      inputs: [StateGroup.select(Inputs, 'page')],
+      output: S.Array(Item),
+      intents: [Added, Renamed],
+      alwaysOn: true,
+    }) {}
+    const ItemsLive = RemoteState.live(Items, {
+      query: () => server.fetch(15),
+      send: (intent) => server.receive(intent, 15),
+      apply: applyIntent,
     })
-    yield* Event.dispatch(Added, { id: 'b', name: 'beta' })
-    // Wait for queue entry to land before waiting for settle (empty would be vacuous)
-    yield* until(() => queue.get(), (q) => q.length === 1)
-    yield* until(() => queue.get(), (q) => q.length === 0)
-    off()
-    expect(frames.length).toBeGreaterThan(0)
-    expect(frames.every((n) => n === 2)).toBe(true)
-
-    const settled = yield* until(
-      () => store.get(),
-      (v) => v._tag === 'Success' && v.refetching === false,
+    const TestLayer = ItemsLive.pipe(
+      Layer.provideMerge(StateGroup.live(Inputs, { page: 1 })),
+      Layer.provideMerge(Engine),
     )
-    if (settled._tag === 'Success') {
-      expect(settled.value).toEqual([
-        { id: 'a', name: 'alpha' },
-        { id: 'b', name: 'beta' },
-      ])
-    }
-    expect(server.state.fetches).toBe(2)
-  }).pipe(Effect.provide(TestLayer))
-})
-
-it.live('THE GENERATION RULE: a refetch that started before the ack can never settle the intent', () => {
-  class Page extends State.make('page', S.Number) {}
-  class Inputs extends StateGroup.make(Page) {}
-  class Poke extends Event.make('Poke', S.Struct({})) {}
-  const server = makeServer([{ id: 'a', name: 'alpha' }])
-  class Items extends RemoteState.make('Items', {
-    inputs: [StateGroup.select(Inputs, 'page')],
-    output: S.Array(Item),
-    intents: [Added, Renamed],
-    alwaysOn: true,
-  }) {}
-  const ItemsLive = RemoteState.live(Items, {
-    query: () => server.fetch(60),
-    send: (intent) => server.receive(intent, 15),
-    apply: applyIntent,
-    invalidateOn: [Poke],
-    // Trailing lets pre-ack run land — stale Success must not settle
-    coalesce: 'trailing',
-  })
-  const TestLayer = ItemsLive.pipe(
-    Layer.provideMerge(StateGroup.live(Inputs, { page: 1 })),
-    Layer.provideMerge(Engine),
-  )
-
-  return Effect.gen(function* () {
-    const store = yield* Items.store
-    const queue = yield* Items.pending.store
-    yield* until(() => store.get(), (v) => v._tag === 'Success')
-    expect(server.state.fetches).toBe(1)
 
-    const frames: Array<number> = []
-    const off = store.subscribe(() => {
-      const v = store.get()
-      if (v._tag === 'Success') frames.push(v.value.length)
+    return Effect.gen(function* () {
+      const store = yield* Items.store
+      const queue = yield* Items.pending.store
+      yield* until(
+        () => store.get(),
+        (v) => v._tag === 'Success',
+      )
+
+      // Flicker guard: once optimistic row appears, no later Success frame may lack it
+      const frames: Array<number> = []
+      const off = store.subscribe(() => {
+        const v = store.get()
+        if (v._tag === 'Success') frames.push(v.value.length)
+      })
+      yield* Event.dispatch(Added, { id: 'b', name: 'beta' })
+      // Wait for queue entry to land before waiting for settle (empty would be vacuous)
+      yield* until(
+        () => queue.get(),
+        (q) => q.length === 1,
+      )
+      yield* until(
+        () => queue.get(),
+        (q) => q.length === 0,
+      )
+      off()
+      expect(frames.length).toBeGreaterThan(0)
+      expect(frames.every((n) => n === 2)).toBe(true)
+
+      const settled = yield* until(
+        () => store.get(),
+        (v) => v._tag === 'Success' && v.refetching === false,
+      )
+      if (settled._tag === 'Success') {
+        expect(settled.value).toEqual([
+          { id: 'a', name: 'alpha' },
+          { id: 'b', name: 'beta' },
+        ])
+      }
+      expect(server.state.fetches).toBe(2)
+    }).pipe(Effect.provide(TestLayer))
+  },
+)
+
+it.live(
+  'THE GENERATION RULE: a refetch that started before the ack can never settle the intent',
+  () => {
+    class Page extends State.make('page', S.Number) {}
+    class Inputs extends StateGroup.make(Page) {}
+    class Poke extends Event.make('Poke', S.Struct({})) {}
+    const server = makeServer([{ id: 'a', name: 'alpha' }])
+    class Items extends RemoteState.make('Items', {
+      inputs: [StateGroup.select(Inputs, 'page')],
+      output: S.Array(Item),
+      intents: [Added, Renamed],
+      alwaysOn: true,
+    }) {}
+    const ItemsLive = RemoteState.live(Items, {
+      query: () => server.fetch(60),
+      send: (intent) => server.receive(intent, 15),
+      apply: applyIntent,
+      invalidateOn: [Poke],
+      // Trailing lets pre-ack run land — stale Success must not settle
+      coalesce: 'trailing',
     })
+    const TestLayer = ItemsLive.pipe(
+      Layer.provideMerge(StateGroup.live(Inputs, { page: 1 })),
+      Layer.provideMerge(Engine),
+    )
 
-    yield* Event.dispatch(Poke, {})
-    yield* tick(5)
-    yield* Event.dispatch(Added, { id: 'b', name: 'beta' })
-
-    // Gen-2 Success settles nobody (generation rule)
-    yield* until(() => server.state.fetches, (n) => n === 2)
-    yield* tick(25)
-    expect(queue.get()).toHaveLength(1)
-    expect(queue.get()[0]).toMatchObject({ status: 'confirmed' })
-    const midflight = store.get()
-    expect(midflight).toMatchObject({ _tag: 'Success' })
-    if (midflight._tag === 'Success') expect(midflight.value).toHaveLength(2)
-
-    yield* until(() => queue.get(), (q) => q.length === 0)
-    off()
-    expect(server.state.fetches).toBe(3)
-    const firstOptimistic = frames.indexOf(2)
-    expect(firstOptimistic).toBeGreaterThanOrEqual(0)
-    expect(frames.slice(firstOptimistic).every((n) => n === 2)).toBe(true)
-    const settled = store.get()
-    if (settled._tag === 'Success') {
-      expect(settled.value).toEqual([
-        { id: 'a', name: 'alpha' },
-        { id: 'b', name: 'beta' },
-      ])
-    }
-  }).pipe(Effect.provide(TestLayer))
-})
-
-it.live('a failed send settles the intent, reverts the overlay, and Failed reaches a user reducer', () => {
-  class Page extends State.make('page', S.Number) {}
-  class Inputs extends StateGroup.make(Page) {}
-  class FailLog extends State.make('failLog', S.Array(S.String)) {}
-  const server = makeServer([{ id: 'a', name: 'alpha' }])
-  class Items extends RemoteState.make('Items', {
-    inputs: [StateGroup.select(Inputs, 'page')],
-    output: S.Array(Item),
-    intents: [Added, Renamed],
-    alwaysOn: true,
-  }) {}
-  const ItemsLive = RemoteState.live(Items, {
-    query: () => server.fetch(5),
-    send: () => Effect.fail('rejected' as const).pipe(Effect.delay(Duration.millis(15))),
-    apply: applyIntent,
-  })
-  const LogReducer = Reducer.make('failLog', { states: [FailLog], events: [Items.Failed] })
-  const TestLayer = Layer.mergeAll(
-    ItemsLive,
-    Reducer.live(LogReducer, (log, event) => [...log, `${event.intent._tag}|${String(event.error)}`]),
-  ).pipe(
-    Layer.provideMerge(State.live(FailLog, [])),
-    Layer.provideMerge(StateGroup.live(Inputs, { page: 1 })),
-    Layer.provideMerge(Engine),
-  )
-
-  return Effect.gen(function* () {
-    const store = yield* Items.store
-    const queue = yield* Items.pending.store
-    const log = yield* FailLog.store
-    yield* until(() => store.get(), (v) => v._tag === 'Success')
-
-    yield* Event.dispatch(Added, { id: 'b', name: 'beta' })
-    yield* until(() => store.get(), (v) => v._tag === 'Success' && v.value.length === 2)
-    expect(queue.get()).toHaveLength(1)
-
-    yield* until(() => queue.get(), (q) => q.length === 0)
-    const reverted = yield* until(
-      () => store.get(),
-      (v) => v._tag === 'Success' && v.value.length === 1,
+    return Effect.gen(function* () {
+      const store = yield* Items.store
+      const queue = yield* Items.pending.store
+      yield* until(
+        () => store.get(),
+        (v) => v._tag === 'Success',
+      )
+      expect(server.state.fetches).toBe(1)
+
+      const frames: Array<number> = []
+      const off = store.subscribe(() => {
+        const v = store.get()
+        if (v._tag === 'Success') frames.push(v.value.length)
+      })
+
+      yield* Event.dispatch(Poke, {})
+      yield* tick(5)
+      yield* Event.dispatch(Added, { id: 'b', name: 'beta' })
+
+      // Gen-2 Success settles nobody (generation rule)
+      yield* until(
+        () => server.state.fetches,
+        (n) => n === 2,
+      )
+      yield* tick(25)
+      expect(queue.get()).toHaveLength(1)
+      expect(queue.get()[0]).toMatchObject({ status: 'confirmed' })
+      const midflight = store.get()
+      expect(midflight).toMatchObject({ _tag: 'Success' })
+      if (midflight._tag === 'Success') expect(midflight.value).toHaveLength(2)
+
+      yield* until(
+        () => queue.get(),
+        (q) => q.length === 0,
+      )
+      off()
+      expect(server.state.fetches).toBe(3)
+      const firstOptimistic = frames.indexOf(2)
+      expect(firstOptimistic).toBeGreaterThanOrEqual(0)
+      expect(frames.slice(firstOptimistic).every((n) => n === 2)).toBe(true)
+      const settled = store.get()
+      if (settled._tag === 'Success') {
+        expect(settled.value).toEqual([
+          { id: 'a', name: 'alpha' },
+          { id: 'b', name: 'beta' },
+        ])
+      }
+    }).pipe(Effect.provide(TestLayer))
+  },
+)
+
+it.live(
+  'a failed send settles the intent, reverts the overlay, and Failed reaches a user reducer',
+  () => {
+    class Page extends State.make('page', S.Number) {}
+    class Inputs extends StateGroup.make(Page) {}
+    class FailLog extends State.make('failLog', S.Array(S.String)) {}
+    const server = makeServer([{ id: 'a', name: 'alpha' }])
+    class Items extends RemoteState.make('Items', {
+      inputs: [StateGroup.select(Inputs, 'page')],
+      output: S.Array(Item),
+      intents: [Added, Renamed],
+      alwaysOn: true,
+    }) {}
+    const ItemsLive = RemoteState.live(Items, {
+      query: () => server.fetch(5),
+      send: () => Effect.fail('rejected' as const).pipe(Effect.delay(Duration.millis(15))),
+      apply: applyIntent,
+    })
+    const LogReducer = Reducer.make('failLog', { states: [FailLog], events: [Items.Failed] })
+    const TestLayer = Layer.mergeAll(
+      ItemsLive,
+      Reducer.live(LogReducer, (log, event) => [
+        ...log,
+        `${event.intent._tag}|${String(event.error)}`,
+      ]),
+    ).pipe(
+      Layer.provideMerge(State.live(FailLog, [])),
+      Layer.provideMerge(StateGroup.live(Inputs, { page: 1 })),
+      Layer.provideMerge(Engine),
     )
-    if (reverted._tag === 'Success') {
-      expect(reverted.value).toEqual([{ id: 'a', name: 'alpha' }])
-    }
-    yield* until(() => log.get(), (l) => l.length === 1)
-    expect(log.get()).toEqual(['Added|rejected'])
-    expect(server.state.fetches).toBe(1)
-  }).pipe(Effect.provide(TestLayer))
-})
+
+    return Effect.gen(function* () {
+      const store = yield* Items.store
+      const queue = yield* Items.pending.store
+      const log = yield* FailLog.store
+      yield* until(
+        () => store.get(),
+        (v) => v._tag === 'Success',
+      )
+
+      yield* Event.dispatch(Added, { id: 'b', name: 'beta' })
+      yield* until(
+        () => store.get(),
+        (v) => v._tag === 'Success' && v.value.length === 2,
+      )
+      expect(queue.get()).toHaveLength(1)
+
+      yield* until(
+        () => queue.get(),
+        (q) => q.length === 0,
+      )
+      const reverted = yield* until(
+        () => store.get(),
+        (v) => v._tag === 'Success' && v.value.length === 1,
+      )
+      if (reverted._tag === 'Success') {
+        expect(reverted.value).toEqual([{ id: 'a', name: 'alpha' }])
+      }
+      yield* until(
+        () => log.get(),
+        (l) => l.length === 1,
+      )
+      expect(log.get()).toEqual(['Added|rejected'])
+      expect(server.state.fetches).toBe(1)
+    }).pipe(Effect.provide(TestLayer))
+  },
+)
 
 it.live('two intents apply in dispatch order and settle together on the post-ack run', () => {
   class Page extends State.make('page', S.Number) {}
@@ -389,19 +439,28 @@ it.live('two intents apply in dispatch order and settle together on the post-ack
   return Effect.gen(function* () {
     const store = yield* Items.store
     const queue = yield* Items.pending.store
-    yield* until(() => store.get(), (v) => v._tag === 'Success')
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
 
     // Apply order = dispatch order
     yield* Event.dispatch(Added, { id: 'b', name: 'beta' })
     yield* Event.dispatch(Renamed, { id: 'b', name: 'BETA' })
-    yield* until(() => queue.get(), (q) => q.length === 2)
+    yield* until(
+      () => queue.get(),
+      (q) => q.length === 2,
+    )
     const optimistic = store.get()
     expect(optimistic).toMatchObject({ _tag: 'Success' })
     if (optimistic._tag === 'Success') {
       expect(optimistic.value[1]).toEqual({ id: 'b', name: 'BETA' })
     }
 
-    yield* until(() => queue.get(), (q) => q.length === 0)
+    yield* until(
+      () => queue.get(),
+      (q) => q.length === 0,
+    )
     const settled = yield* until(
       () => store.get(),
       (v) => v._tag === 'Success' && v.refetching === false,
@@ -441,7 +500,10 @@ it.live('one intent failing leaves the other pending and converging', () => {
   return Effect.gen(function* () {
     const store = yield* Items.store
     const queue = yield* Items.pending.store
-    yield* until(() => store.get(), (v) => v._tag === 'Success')
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
 
     yield* Event.dispatch(Added, { id: 'b', name: 'beta' })
     yield* Event.dispatch(Renamed, { id: 'a', name: 'ALPHA' })
@@ -465,7 +527,10 @@ it.live('one intent failing leaves the other pending and converging', () => {
       ])
     }
 
-    yield* until(() => queue.get(), (q) => q.length === 0)
+    yield* until(
+      () => queue.get(),
+      (q) => q.length === 0,
+    )
     const settled = yield* until(
       () => store.get(),
       (v) => v._tag === 'Success' && v.refetching === false,
@@ -502,10 +567,16 @@ it.live("pending exposes the lifecycle: 'sending' -> 'confirmed' -> gone", () =>
   return Effect.gen(function* () {
     const store = yield* Items.store
     const queue = yield* Items.pending.store
-    yield* until(() => store.get(), (v) => v._tag === 'Success')
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
 
     yield* Event.dispatch(Added, { id: 'b', name: 'beta' })
-    const sending = yield* until(() => queue.get(), (q) => q.length === 1)
+    const sending = yield* until(
+      () => queue.get(),
+      (q) => q.length === 1,
+    )
     expect(sending[0]).toMatchObject({ status: 'sending', intent: { _tag: 'Added', id: 'b' } })
 
     const confirmed = yield* until(
@@ -514,7 +585,10 @@ it.live("pending exposes the lifecycle: 'sending' -> 'confirmed' -> gone", () =>
     )
     expect(confirmed[0]).toMatchObject({ status: 'confirmed' })
 
-    yield* until(() => queue.get(), (q) => q.length === 0)
+    yield* until(
+      () => queue.get(),
+      (q) => q.length === 0,
+    )
     expect(queue.get()).toEqual([])
   }).pipe(Effect.provide(TestLayer))
 })
@@ -548,14 +622,20 @@ it.live('gated: intents queue and send while Idle; re-enabling converges and set
 
     // Intents still send while gated Idle; settle waits for re-enable
     yield* Event.dispatch(Added, { id: 'b', name: 'beta' })
-    yield* until(() => server.state.items, (items) => items.length === 2)
+    yield* until(
+      () => server.state.items,
+      (items) => items.length === 2,
+    )
     yield* tick(20)
     expect(store.get()._tag).toBe('Idle')
     expect(queue.get()).toHaveLength(1)
     expect(server.state.fetches).toBe(0)
 
     source.set(1)
-    yield* until(() => queue.get(), (q) => q.length === 0)
+    yield* until(
+      () => queue.get(),
+      (q) => q.length === 0,
+    )
     const settled = yield* until(
       () => store.get(),
       (v) => v._tag === 'Success' && v.refetching === false,
@@ -596,13 +676,22 @@ it.live('reuse: untouched element identities survive the whole optimistic round-
   return Effect.gen(function* () {
     const store = yield* Items.store
     const queue = yield* Items.pending.store
-    const first = yield* until(() => store.get(), (v) => v._tag === 'Success')
+    const first = yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
     if (first._tag !== 'Success') return
     const untouched = first.value[0]
 
     yield* Event.dispatch(Renamed, { id: 'b', name: 'BETA' })
-    yield* until(() => queue.get(), (q) => q.length === 1)
-    yield* until(() => queue.get(), (q) => q.length === 0)
+    yield* until(
+      () => queue.get(),
+      (q) => q.length === 1,
+    )
+    yield* until(
+      () => queue.get(),
+      (q) => q.length === 0,
+    )
     const settled = yield* until(
       () => store.get(),
       (v) => v._tag === 'Success' && v.refetching === false,
@@ -640,15 +729,27 @@ it.live('invalidateOn + coalesce trailing compose with the mutation lifecycle',
   return Effect.gen(function* () {
     const store = yield* Items.store
     const queue = yield* Items.pending.store
-    yield* until(() => store.get(), (v) => v._tag === 'Success')
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
     expect(server.state.fetches).toBe(1)
 
     yield* Event.dispatch(BoardChanged, {})
-    yield* until(() => server.state.fetches, (n) => n === 2)
+    yield* until(
+      () => server.state.fetches,
+      (n) => n === 2,
+    )
 
     yield* Event.dispatch(Added, { id: 'b', name: 'beta' })
-    yield* until(() => queue.get(), (q) => q.length === 1)
-    yield* until(() => queue.get(), (q) => q.length === 0)
+    yield* until(
+      () => queue.get(),
+      (q) => q.length === 1,
+    )
+    yield* until(
+      () => queue.get(),
+      (q) => q.length === 0,
+    )
     const settled = yield* until(
       () => store.get(),
       (v) => v._tag === 'Success' && v.refetching === false,
@@ -687,56 +788,67 @@ it.live('a query Error passes through by reference with intents still pending',
     const store = yield* Items.store
     const truth = yield* Items.truth.store
     const queue = yield* Items.pending.store
-    yield* until(() => store.get(), (v) => v._tag === 'Error')
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Error',
+    )
 
     // Error runs settle nobody; overlay passes Error through without apply
     yield* Event.dispatch(Added, { id: 'b', name: 'beta' })
-    yield* until(() => queue.get(), (q) => q.length === 1 && q[0]?.status === 'confirmed')
-    yield* until(() => store.get(), (v) => v._tag === 'Error' && v.refetching === false)
+    yield* until(
+      () => queue.get(),
+      (q) => q.length === 1 && q[0]?.status === 'confirmed',
+    )
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Error' && v.refetching === false,
+    )
     yield* tick(20)
     expect(queue.get()).toHaveLength(1)
     expect(store.get()).toBe(truth.get())
   }).pipe(Effect.provide(TestLayer))
 })
 
-it.live('teardown: closing the scope unregisters the reducers, the procedure, and the channel', () => {
-  class Page extends State.make('page', S.Number) {}
-  class Inputs extends StateGroup.make(Page) {}
-  const server = makeServer([{ id: 'a', name: 'alpha' }])
-  class Items extends RemoteState.make('Items', {
-    inputs: [StateGroup.select(Inputs, 'page')],
-    output: S.Array(Item),
-    intents: [Added, Renamed],
-    alwaysOn: true,
-  }) {}
-  const ItemsLive = RemoteState.live(Items, {
-    query: () => server.fetch(5),
-    send: (intent) => server.receive(intent, 5),
-    apply: applyIntent,
-  }).pipe(Layer.provideMerge(StateGroup.live(Inputs, { page: 1 })))
-
-  return Effect.gen(function* () {
-    const reducers = yield* Reducers
-    const procedures = yield* Procedures
-    const channels = yield* Channels
-
-    yield* Effect.scoped(
-      Effect.gen(function* () {
-        yield* Layer.build(ItemsLive)
-        expect(reducers.entries.some((entry) => entry.name === 'Items/pending')).toBe(true)
-        expect(reducers.entries.some((entry) => entry.name === 'Items/revision')).toBe(true)
-        expect(procedures.entries.some((entry) => entry.name === 'Items/send')).toBe(true)
-        expect(channels.byName.has('Items/sends')).toBe(true)
-      }),
-    )
-
-    expect(reducers.entries.some((entry) => entry.name === 'Items/pending')).toBe(false)
-    expect(reducers.entries.some((entry) => entry.name === 'Items/revision')).toBe(false)
-    expect(procedures.entries.some((entry) => entry.name === 'Items/send')).toBe(false)
-    expect(channels.byName.has('Items/sends')).toBe(false)
-  }).pipe(Effect.provide(Engine))
-})
+it.live(
+  'teardown: closing the scope unregisters the reducers, the procedure, and the channel',
+  () => {
+    class Page extends State.make('page', S.Number) {}
+    class Inputs extends StateGroup.make(Page) {}
+    const server = makeServer([{ id: 'a', name: 'alpha' }])
+    class Items extends RemoteState.make('Items', {
+      inputs: [StateGroup.select(Inputs, 'page')],
+      output: S.Array(Item),
+      intents: [Added, Renamed],
+      alwaysOn: true,
+    }) {}
+    const ItemsLive = RemoteState.live(Items, {
+      query: () => server.fetch(5),
+      send: (intent) => server.receive(intent, 5),
+      apply: applyIntent,
+    }).pipe(Layer.provideMerge(StateGroup.live(Inputs, { page: 1 })))
+
+    return Effect.gen(function* () {
+      const reducers = yield* Reducers
+      const procedures = yield* Procedures
+      const channels = yield* Channels
+
+      yield* Effect.scoped(
+        Effect.gen(function* () {
+          yield* Layer.build(ItemsLive)
+          expect(reducers.entries.some((entry) => entry.name === 'Items/pending')).toBe(true)
+          expect(reducers.entries.some((entry) => entry.name === 'Items/revision')).toBe(true)
+          expect(procedures.entries.some((entry) => entry.name === 'Items/send')).toBe(true)
+          expect(channels.byName.has('Items/sends')).toBe(true)
+        }),
+      )
 
+      expect(reducers.entries.some((entry) => entry.name === 'Items/pending')).toBe(false)
+      expect(reducers.entries.some((entry) => entry.name === 'Items/revision')).toBe(false)
+      expect(procedures.entries.some((entry) => entry.name === 'Items/send')).toBe(false)
+      expect(channels.byName.has('Items/sends')).toBe(false)
+    }).pipe(Effect.provide(Engine))
+  },
+)
 
 it.live('persist: hydrates the seeded truth (stale) then writes the fresh truth through', () => {
   class Page extends State.make('page', S.Number) {}
@@ -765,7 +877,8 @@ it.live('persist: hydrates the seeded truth (stale) then writes the fresh truth
     const view = yield* Items.store
     const hydrated = view.get()
     expect(hydrated).toMatchObject({ _tag: 'Success', refetching: true })
-    if (hydrated._tag === 'Success') expect(hydrated.value).toEqual([{ id: 'seed', name: 'seeded' }])
+    if (hydrated._tag === 'Success')
+      expect(hydrated.value).toEqual([{ id: 'seed', name: 'seeded' }])
 
     const settled = yield* until(
       () => view.get(),
@@ -780,120 +893,183 @@ it.live('persist: hydrates the seeded truth (stale) then writes the fresh truth
   }).pipe(Effect.provide(TestLayer))
 })
 
-it.live('persist: the optimistic overlay is NEVER written — only the converged server truth is', () => {
-  class Page extends State.make('page', S.Number) {}
-  class Inputs extends StateGroup.make(Page) {}
-  const server = makeServer([{ id: 'a', name: 'alpha' }])
-  const store = fakeQueryStore()
-  class Items extends RemoteState.make('Items', {
-    inputs: [StateGroup.select(Inputs, 'page')],
-    output: S.Array(Item),
-    intents: [Added, Renamed],
-    alwaysOn: true,
-  }) {}
-  const ItemsLive = RemoteState.live(Items, {
-    query: () => server.fetch(10),
-    send: (intent) => server.receive(intent, 60),
-    apply: applyIntent,
-    persist: true,
-  })
-  const TestLayer = ItemsLive.pipe(
-    Layer.provideMerge(StateGroup.live(Inputs, { page: 1 })),
-    Layer.provideMerge(store.layer),
-    Layer.provideMerge(Engine),
-  )
-
-  return Effect.gen(function* () {
-    const view = yield* Items.store
-    const queue = yield* Items.pending.store
-    yield* until(() => view.get(), (v) => v._tag === 'Success')
-    yield* until(() => store.map.get('Items'), (v) => Array.isArray(v) && v.length === 1)
-
-    yield* Event.dispatch(Added, { id: 'b', name: 'beta' })
-    yield* until(() => view.get(), (v) => v._tag === 'Success' && v.value.length === 2)
-    yield* until(() => queue.get(), (q) => q.length === 1)
-    // Persist never captures overlay — only settled server truth
-    expect(store.map.get('Items')).toEqual([{ id: 'a', name: 'alpha' }])
-
-    yield* until(() => queue.get(), (q) => q.length === 0)
-    yield* until(
-      () => store.map.get('Items'),
-      (v) => Array.isArray(v) && v.length === 2,
+it.live(
+  'persist: the optimistic overlay is NEVER written — only the converged server truth is',
+  () => {
+    class Page extends State.make('page', S.Number) {}
+    class Inputs extends StateGroup.make(Page) {}
+    const server = makeServer([{ id: 'a', name: 'alpha' }])
+    const store = fakeQueryStore()
+    class Items extends RemoteState.make('Items', {
+      inputs: [StateGroup.select(Inputs, 'page')],
+      output: S.Array(Item),
+      intents: [Added, Renamed],
+      alwaysOn: true,
+    }) {}
+    const ItemsLive = RemoteState.live(Items, {
+      query: () => server.fetch(10),
+      send: (intent) => server.receive(intent, 60),
+      apply: applyIntent,
+      persist: true,
+    })
+    const TestLayer = ItemsLive.pipe(
+      Layer.provideMerge(StateGroup.live(Inputs, { page: 1 })),
+      Layer.provideMerge(store.layer),
+      Layer.provideMerge(Engine),
     )
-    expect(store.map.get('Items')).toEqual([
-      { id: 'a', name: 'alpha' },
-      { id: 'b', name: 'beta' },
-    ])
-  }).pipe(Effect.provide(TestLayer))
-})
 
-it.live('persist: `true` keys by name; `{ key }` overrides — two definitions keep separate slots', () => {
-  class Page extends State.make('page', S.Number) {}
-  class Inputs extends StateGroup.make(Page) {}
-  const serverA = makeServer([{ id: 'a', name: 'alpha' }])
-  const serverB = makeServer([{ id: 'b', name: 'beta' }])
-  const store = fakeQueryStore()
-  class ItemsA extends RemoteState.make('ItemsA', {
-    inputs: [StateGroup.select(Inputs, 'page')],
-    output: S.Array(Item),
-    intents: [Added, Renamed],
-    alwaysOn: true,
-  }) {}
-  class ItemsB extends RemoteState.make('ItemsB', {
-    inputs: [StateGroup.select(Inputs, 'page')],
-    output: S.Array(Item),
-    intents: [Added, Renamed],
-    alwaysOn: true,
-  }) {}
-  const TestLayer = Layer.mergeAll(
-    RemoteState.live(ItemsA, { query: () => serverA.fetch(10), send: (i) => serverA.receive(i, 10), apply: applyIntent, persist: true }),
-    RemoteState.live(ItemsB, { query: () => serverB.fetch(10), send: (i) => serverB.receive(i, 10), apply: applyIntent, persist: { key: 'custom-B' } }),
-  ).pipe(Layer.provideMerge(StateGroup.live(Inputs, { page: 1 })), Layer.provideMerge(store.layer), Layer.provideMerge(Engine))
-
-  return Effect.gen(function* () {
-    const a = yield* ItemsA.store
-    const b = yield* ItemsB.store
-    yield* until(() => a.get(), (v) => v._tag === 'Success')
-    yield* until(() => b.get(), (v) => v._tag === 'Success')
-    yield* until(() => store.map.get('ItemsA'), (v) => Array.isArray(v))
-    yield* until(() => store.map.get('custom-B'), (v) => Array.isArray(v))
-    expect(store.map.get('ItemsA')).toEqual([{ id: 'a', name: 'alpha' }])
-    expect(store.map.get('custom-B')).toEqual([{ id: 'b', name: 'beta' }])
-    expect(store.map.has('ItemsB')).toBe(false)
-  }).pipe(Effect.provide(TestLayer))
-})
+    return Effect.gen(function* () {
+      const view = yield* Items.store
+      const queue = yield* Items.pending.store
+      yield* until(
+        () => view.get(),
+        (v) => v._tag === 'Success',
+      )
+      yield* until(
+        () => store.map.get('Items'),
+        (v) => Array.isArray(v) && v.length === 1,
+      )
+
+      yield* Event.dispatch(Added, { id: 'b', name: 'beta' })
+      yield* until(
+        () => view.get(),
+        (v) => v._tag === 'Success' && v.value.length === 2,
+      )
+      yield* until(
+        () => queue.get(),
+        (q) => q.length === 1,
+      )
+      // Persist never captures overlay — only settled server truth
+      expect(store.map.get('Items')).toEqual([{ id: 'a', name: 'alpha' }])
+
+      yield* until(
+        () => queue.get(),
+        (q) => q.length === 0,
+      )
+      yield* until(
+        () => store.map.get('Items'),
+        (v) => Array.isArray(v) && v.length === 2,
+      )
+      expect(store.map.get('Items')).toEqual([
+        { id: 'a', name: 'alpha' },
+        { id: 'b', name: 'beta' },
+      ])
+    }).pipe(Effect.provide(TestLayer))
+  },
+)
+
+it.live(
+  'persist: `true` keys by name; `{ key }` overrides — two definitions keep separate slots',
+  () => {
+    class Page extends State.make('page', S.Number) {}
+    class Inputs extends StateGroup.make(Page) {}
+    const serverA = makeServer([{ id: 'a', name: 'alpha' }])
+    const serverB = makeServer([{ id: 'b', name: 'beta' }])
+    const store = fakeQueryStore()
+    class ItemsA extends RemoteState.make('ItemsA', {
+      inputs: [StateGroup.select(Inputs, 'page')],
+      output: S.Array(Item),
+      intents: [Added, Renamed],
+      alwaysOn: true,
+    }) {}
+    class ItemsB extends RemoteState.make('ItemsB', {
+      inputs: [StateGroup.select(Inputs, 'page')],
+      output: S.Array(Item),
+      intents: [Added, Renamed],
+      alwaysOn: true,
+    }) {}
+    const TestLayer = Layer.mergeAll(
+      RemoteState.live(ItemsA, {
+        query: () => serverA.fetch(10),
+        send: (i) => serverA.receive(i, 10),
+        apply: applyIntent,
+        persist: true,
+      }),
+      RemoteState.live(ItemsB, {
+        query: () => serverB.fetch(10),
+        send: (i) => serverB.receive(i, 10),
+        apply: applyIntent,
+        persist: { key: 'custom-B' },
+      }),
+    ).pipe(
+      Layer.provideMerge(StateGroup.live(Inputs, { page: 1 })),
+      Layer.provideMerge(store.layer),
+      Layer.provideMerge(Engine),
+    )
 
-it.live('persist (00c): a function key keys a family per-input — two input keys, two slots, no collision', () => {
-  class Page extends State.make('page', S.Number) {}
-  class Inputs extends StateGroup.make(Page) {}
-  const inputs = StateGroup.live(Inputs, { page: 1 })
-  const store = fakeQueryStore()
-  const fetchPage = (page: number) =>
-    Effect.as(tick(10), [{ id: `p${page}`, name: `page-${page}` }])
-  class Fam extends RemoteState.make('Fam', {
-    inputs: [StateGroup.select(Inputs, 'page')],
-    output: S.Array(Item),
-    intents: [Added, Renamed],
-    alwaysOn: true,
-  }) {}
-  const FamLive = RemoteState.live(Fam, {
-    query: ({ page }) => fetchPage(page),
-    send: (i) => Effect.sync(() => void i),
-    apply: applyIntent,
-    persist: { key: ({ page }) => `fam:${page}` },
-  })
-  const TestLayer = FamLive.pipe(Layer.provideMerge(inputs), Layer.provideMerge(store.layer), Layer.provideMerge(Engine))
+    return Effect.gen(function* () {
+      const a = yield* ItemsA.store
+      const b = yield* ItemsB.store
+      yield* until(
+        () => a.get(),
+        (v) => v._tag === 'Success',
+      )
+      yield* until(
+        () => b.get(),
+        (v) => v._tag === 'Success',
+      )
+      yield* until(
+        () => store.map.get('ItemsA'),
+        (v) => Array.isArray(v),
+      )
+      yield* until(
+        () => store.map.get('custom-B'),
+        (v) => Array.isArray(v),
+      )
+      expect(store.map.get('ItemsA')).toEqual([{ id: 'a', name: 'alpha' }])
+      expect(store.map.get('custom-B')).toEqual([{ id: 'b', name: 'beta' }])
+      expect(store.map.has('ItemsB')).toBe(false)
+    }).pipe(Effect.provide(TestLayer))
+  },
+)
+
+it.live(
+  'persist (00c): a function key keys a family per-input — two input keys, two slots, no collision',
+  () => {
+    class Page extends State.make('page', S.Number) {}
+    class Inputs extends StateGroup.make(Page) {}
+    const inputs = StateGroup.live(Inputs, { page: 1 })
+    const store = fakeQueryStore()
+    const fetchPage = (page: number) =>
+      Effect.as(tick(10), [{ id: `p${page}`, name: `page-${page}` }])
+    class Fam extends RemoteState.make('Fam', {
+      inputs: [StateGroup.select(Inputs, 'page')],
+      output: S.Array(Item),
+      intents: [Added, Renamed],
+      alwaysOn: true,
+    }) {}
+    const FamLive = RemoteState.live(Fam, {
+      query: ({ page }) => fetchPage(page),
+      send: (i) => Effect.sync(() => void i),
+      apply: applyIntent,
+      persist: { key: ({ page }) => `fam:${page}` },
+    })
+    const TestLayer = FamLive.pipe(
+      Layer.provideMerge(inputs),
+      Layer.provideMerge(store.layer),
+      Layer.provideMerge(Engine),
+    )
 
-  return Effect.gen(function* () {
-    const view = yield* Fam.store
-    const page = yield* Page.store
-    yield* until(() => store.map.get('fam:1'), (v) => Array.isArray(v))
-    expect(store.map.get('fam:1')).toEqual([{ id: 'p1', name: 'page-1' }])
-
-    page.set(2)
-    yield* until(() => view.get(), (v) => v._tag === 'Success' && v.value[0]?.id === 'p2')
-    yield* until(() => store.map.get('fam:2'), (v) => Array.isArray(v))
-    expect(store.map.get('fam:2')).toEqual([{ id: 'p2', name: 'page-2' }])
-    expect(store.map.get('fam:1')).toEqual([{ id: 'p1', name: 'page-1' }])
-  }).pipe(Effect.provide(TestLayer))
-})
+    return Effect.gen(function* () {
+      const view = yield* Fam.store
+      const page = yield* Page.store
+      yield* until(
+        () => store.map.get('fam:1'),
+        (v) => Array.isArray(v),
+      )
+      expect(store.map.get('fam:1')).toEqual([{ id: 'p1', name: 'page-1' }])
+
+      page.set(2)
+      yield* until(
+        () => view.get(),
+        (v) => v._tag === 'Success' && v.value[0]?.id === 'p2',
+      )
+      yield* until(
+        () => store.map.get('fam:2'),
+        (v) => Array.isArray(v),
+      )
+      expect(store.map.get('fam:2')).toEqual([{ id: 'p2', name: 'page-2' }])
+      expect(store.map.get('fam:1')).toEqual([{ id: 'p1', name: 'page-1' }])
+    }).pipe(Effect.provide(TestLayer))
+  },
+)