@playfast/reform 0.0.5 → 0.0.8

package/src/calc/calc.test.ts

@@ -0,0 +1,287 @@
+import { expect, it } from '@effect/vitest'
+import { Duration, Effect, Layer, Schema as S } from 'effect'
+import { Calc, State, StateGroup } from '../index'
+
+// The calc store memoizes on input identity and — the behaviour under test —
+// only wakes its subscribers when a source change actually moves the output.
+
+const tick = Effect.sleep(Duration.millis(1))
+
+it.live('a source change that does not move the output notifies no subscriber', () => {
+  class Count extends State.make('count', S.Number) {}
+  class Inputs extends StateGroup.make(Count) {}
+  // `isPositive` is stable across 1 -> 2 (still true) but flips on 2 -> -1.
+  class IsPositive extends Calc.make('IsPositive', {
+    inputs: [StateGroup.select(Inputs, 'count')],
+    output: S.Boolean,
+  }) {}
+  const runs = { n: 0 }
+  const IsPositiveLive = Calc.live(IsPositive, ({ count }) => {
+    runs.n += 1
+    return count > 0
+  })
+
+  const TestLayer = IsPositiveLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 1 })))
+
+  return Effect.gen(function* () {
+    const source = yield* StateGroup.select(Inputs, 'count').store
+    const derived = yield* IsPositive.store
+    const notifications = { n: 0 }
+    derived.subscribe(() => {
+      notifications.n += 1
+    })
+
+    expect(derived.get()).toBe(true)
+
+    // 1 -> 2: inputs changed, recompute runs, but the output (true) is unchanged.
+    source.set(2)
+    yield* tick
+    expect(notifications.n).toBe(0)
+    expect(derived.get()).toBe(true)
+
+    // 2 -> -1: output flips to false — exactly one notification.
+    source.set(-1)
+    yield* tick
+    expect(notifications.n).toBe(1)
+    expect(derived.get()).toBe(false)
+  }).pipe(Effect.provide(TestLayer))
+})
+
+it.live('reading does not recompute while inputs are unchanged (memoized)', () => {
+  class Count extends State.make('count', S.Number) {}
+  class Inputs extends StateGroup.make(Count) {}
+  class Doubled extends Calc.make('Doubled', {
+    inputs: [StateGroup.select(Inputs, 'count')],
+    output: S.Number,
+  }) {}
+  const runs = { n: 0 }
+  const DoubledLive = Calc.live(Doubled, ({ count }) => {
+    runs.n += 1
+    return count * 2
+  })
+
+  const TestLayer = DoubledLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 5 })))
+
+  return Effect.gen(function* () {
+    const derived = yield* Doubled.store
+    const before = runs.n
+    // Repeated reads with no input change hit the memo — no extra compute.
+    expect(derived.get()).toBe(10)
+    expect(derived.get()).toBe(10)
+    expect(runs.n).toBe(before)
+  }).pipe(Effect.provide(TestLayer))
+})
+
+it.live('a calc can depend on another calc as an input source', () => {
+  class Count extends State.make('count', S.Number) {}
+  class Inputs extends StateGroup.make(Count) {}
+  class Doubled extends Calc.make('Doubled', {
+    inputs: [StateGroup.select(Inputs, 'count')],
+    output: S.Number,
+  }) {}
+  const DoubledLive = Calc.live(Doubled, ({ count }) => count * 2)
+  // `Doubled` (a Calc) is used directly as an input source; its name is the key.
+  class PlusDoubled extends Calc.make('PlusDoubled', {
+    inputs: [StateGroup.select(Inputs, 'count'), Doubled],
+    output: S.Number,
+  }) {}
+  const PlusDoubledLive = Calc.live(PlusDoubled, ({ count, Doubled }) => count + Doubled)
+
+  const TestLayer = PlusDoubledLive.pipe(
+    Layer.provideMerge(DoubledLive),
+    Layer.provideMerge(StateGroup.live(Inputs, { count: 5 })),
+  )
+
+  return Effect.gen(function* () {
+    const source = yield* StateGroup.select(Inputs, 'count').store
+    const derived = yield* PlusDoubled.store
+    expect(derived.get()).toBe(15) // 5 + (5*2)
+    source.set(3)
+    yield* tick
+    expect(derived.get()).toBe(9) // 3 + (3*2)
+  }).pipe(Effect.provide(TestLayer))
+})
+
+it.live('a diamond dependency resolves in one flush with a single leaf notification', () => {
+  // count ─┬─► A (count+1) ─┐
+  //        └─► B (count+10)─┴─► C (A+B).  A change to `count` moves both A and B;
+  // C must converge to the new value and wake its subscriber exactly once.
+  class Count extends State.make('count', S.Number) {}
+  class Inputs extends StateGroup.make(Count) {}
+  class A extends Calc.make('A', {
+    inputs: [StateGroup.select(Inputs, 'count')],
+    output: S.Number,
+  }) {}
+  const ALive = Calc.live(A, ({ count }) => count + 1)
+  class B extends Calc.make('B', {
+    inputs: [StateGroup.select(Inputs, 'count')],
+    output: S.Number,
+  }) {}
+  const BLive = Calc.live(B, ({ count }) => count + 10)
+  class C extends Calc.make('C', { inputs: [A, B], output: S.Number }) {}
+  const CLive = Calc.live(C, ({ A, B }) => A + B)
+
+  const TestLayer = CLive.pipe(
+    Layer.provideMerge(Layer.mergeAll(ALive, BLive)),
+    Layer.provideMerge(StateGroup.live(Inputs, { count: 0 })),
+  )
+
+  return Effect.gen(function* () {
+    const source = yield* StateGroup.select(Inputs, 'count').store
+    const c = yield* C.store
+    const wakes = { n: 0 }
+    c.subscribe(() => {
+      wakes.n += 1
+    })
+    expect(c.get()).toBe(11) // (0+1) + (0+10)
+
+    source.set(5)
+    yield* tick
+    expect(c.get()).toBe(21) // (5+1) + (5+10)
+    expect(wakes.n).toBe(1)
+  }).pipe(Effect.provide(TestLayer))
+})
+
+it.live('invalidateBy: a calc recomputes only when the projected key moves', () => {
+  class A extends State.make('a', S.Number) {}
+  class B extends State.make('b', S.Number) {}
+  class Inputs extends StateGroup.make(A, B) {}
+  const runs = { n: 0 }
+  class Sum extends Calc.make('Sum', {
+    inputs: [StateGroup.select(Inputs, 'a'), StateGroup.select(Inputs, 'b')],
+    output: S.Number,
+  }) {}
+  const SumLive = Calc.live(
+    Sum,
+    ({ a, b }) => {
+      runs.n += 1
+      return a + b
+    },
+    { invalidateBy: ({ a }) => [a] }, // only `a` is in the key
+  )
+  const TestLayer = SumLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { a: 1, b: 1 })))
+
+  return Effect.gen(function* () {
+    const sa = yield* StateGroup.select(Inputs, 'a').store
+    const sb = yield* StateGroup.select(Inputs, 'b').store
+    const sum = yield* Sum.store
+    const base = runs.n
+    expect(sum.get()).toBe(2)
+
+    // `b` moves but the key (just `a`) is unchanged — no recompute, value retained.
+    sb.set(100)
+    yield* tick
+    expect(runs.n).toBe(base)
+    expect(sum.get()).toBe(2)
+
+    // `a` moves — recompute, now seeing the current `b`.
+    sa.set(5)
+    yield* tick
+    expect(sum.get()).toBe(105)
+  }).pipe(Effect.provide(TestLayer))
+})
+
+it.live('inputs are keyed by the make() name even when the subclass binding differs', () => {
+  class Count extends State.make('count', S.Number) {}
+  class Inputs extends StateGroup.make(Count) {}
+  // The binding name ('Renamed…') deliberately differs from the make() name
+  // ('feed') — a class declaration defines its OWN static `name` from the
+  // binding, shadowing the explicit one. Minifiers rename bindings, so keying
+  // the snapshot off the static would make this input undefined in production
+  // builds; the inputs object must key by the manifest's make() name.
+  class RenamedByTheMinifier extends Calc.make('feed', {
+    inputs: [StateGroup.select(Inputs, 'count')],
+    output: S.Number,
+  }) {}
+  class Downstream extends Calc.make('Downstream', {
+    inputs: [RenamedByTheMinifier],
+    output: S.Number,
+  }) {}
+  const seen: Array<unknown> = []
+  const FeedLive = Calc.live(RenamedByTheMinifier, ({ count }) => count * 2)
+  const DownstreamLive = Calc.live(Downstream, ({ feed }) => {
+    seen.push(feed)
+    return feed + 1
+  })
+
+  const TestLayer = DownstreamLive.pipe(
+    Layer.provideMerge(FeedLive),
+    Layer.provideMerge(StateGroup.live(Inputs, { count: 3 })),
+  )
+
+  return Effect.gen(function* () {
+    // The subclass's own static name is the (would-be-minified) binding name…
+    expect(RenamedByTheMinifier.name).toBe('RenamedByTheMinifier')
+    // …but the snapshot keys by the make() name, so `feed` is defined.
+    const downstream = yield* Downstream.store
+    expect(downstream.get()).toBe(7)
+    expect(seen.every((v) => v !== undefined)).toBe(true)
+  }).pipe(Effect.provide(TestLayer))
+})
+
+it.live('reuse: an unchanged subtree keeps its identity across recompute', () => {
+  class A extends State.make('a', S.Number) {}
+  class B extends State.make('b', S.Number) {}
+  class Inputs extends StateGroup.make(A, B) {}
+  const Pair = S.Struct({
+    left: S.Struct({ value: S.Number }),
+    right: S.Struct({ value: S.Number }),
+  })
+  class Split extends Calc.make('Split', {
+    inputs: [StateGroup.select(Inputs, 'a'), StateGroup.select(Inputs, 'b')],
+    output: Pair,
+  }) {}
+  const SplitLive = Calc.live(
+    Split,
+    ({ a, b }) => ({ left: { value: a }, right: { value: b } }),
+    { reuse: true },
+  )
+  const TestLayer = SplitLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { a: 1, b: 1 })))
+
+  return Effect.gen(function* () {
+    const b = yield* StateGroup.select(Inputs, 'b').store
+    const derived = yield* Split.store
+    const before = derived.get()
+
+    // Only `b` moves: the root and `right` are fresh, `left` keeps its identity.
+    b.set(2)
+    yield* tick
+    const after = derived.get()
+    expect(after).not.toBe(before)
+    expect(after.left).toBe(before.left)
+    expect(after.right).not.toBe(before.right)
+    expect(after.right.value).toBe(2)
+  }).pipe(Effect.provide(TestLayer))
+})
+
+it.live('reuse: a value-equal recompute keeps the previous reference and wakes nobody', () => {
+  class Count extends State.make('count', S.Number) {}
+  class Inputs extends StateGroup.make(Count) {}
+  const Box = S.Struct({ positive: S.Boolean })
+  class IsPositive extends Calc.make('IsPositive', {
+    inputs: [StateGroup.select(Inputs, 'count')],
+    output: Box,
+  }) {}
+  // A plain-object output: WITHOUT reuse every recompute is a fresh identity
+  // (and would notify); with it, a value-equal recompute returns the previous
+  // reference and the Equal gate stays silent.
+  const IsPositiveLive = Calc.live(IsPositive, ({ count }) => ({ positive: count > 0 }), {
+    reuse: true,
+  })
+  const TestLayer = IsPositiveLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 1 })))
+
+  return Effect.gen(function* () {
+    const source = yield* StateGroup.select(Inputs, 'count').store
+    const derived = yield* IsPositive.store
+    const notifications = { n: 0 }
+    derived.subscribe(() => {
+      notifications.n += 1
+    })
+    const before = derived.get()
+
+    source.set(2)
+    yield* tick
+    expect(derived.get()).toBe(before)
+    expect(notifications.n).toBe(0)
+  }).pipe(Effect.provide(TestLayer))
+})

package/src/calc/calcFamily.test.ts

@@ -0,0 +1,206 @@
+import { expect, it } from '@effect/vitest'
+import { Context, Duration, Effect, Exit, Layer, Schema as S, Scope } from 'effect'
+import { CalcFamily, State, StateGroup } from '../index'
+
+// CalcFamily: per-key derived stores over shared inputs. The behaviours under
+// test: members derive + memoize independently, a member only notifies when ITS
+// output moves, and every removal path releases the member's upstream
+// subscription (a derived member holds one; a StateFamily entry doesn't).
+
+const tick = Effect.sleep(Duration.millis(1))
+
+// Shared fixture shape: a record of named counters; each member projects one.
+const Board = S.Record({ key: S.String, value: S.Number })
+
+const fixture = () => {
+  class Feed extends State.make('feed', Board) {}
+  class Inputs extends StateGroup.make(Feed) {}
+  const runs = new Map<string, number>()
+  class Slice extends CalcFamily.make('Slice', {
+    key: S.String,
+    inputs: [StateGroup.select(Inputs, 'feed')],
+    output: S.Number,
+  }) {}
+  const SliceLive = CalcFamily.live(Slice, (key) => ({ feed }) => {
+    runs.set(key, (runs.get(key) ?? 0) + 1)
+    return feed[key] ?? 0
+  })
+  return { Inputs, Slice, SliceLive, runs }
+}
+
+it.live('a member derives from the shared inputs and recomputes when they change', () => {
+  const { Inputs, Slice, SliceLive } = fixture()
+  const TestLayer = SliceLive.pipe(
+    Layer.provideMerge(StateGroup.live(Inputs, { feed: { a: 1, b: 10 } })),
+  )
+  return Effect.gen(function* () {
+    const feed = yield* StateGroup.select(Inputs, 'feed').store
+    expect(yield* CalcFamily.read(Slice, 'a')).toBe(1)
+    expect(yield* CalcFamily.read(Slice, 'b')).toBe(10)
+
+    feed.set({ a: 2, b: 10 })
+    yield* tick
+    expect(yield* CalcFamily.read(Slice, 'a')).toBe(2)
+  }).pipe(Effect.provide(TestLayer))
+})
+
+it.live('a member only notifies when its own slice of the projection moves', () => {
+  const { Inputs, Slice, SliceLive } = fixture()
+  const TestLayer = SliceLive.pipe(
+    Layer.provideMerge(StateGroup.live(Inputs, { feed: { a: 1, b: 10 } })),
+  )
+  return Effect.gen(function* () {
+    const feed = yield* StateGroup.select(Inputs, 'feed').store
+    const family = yield* Slice.store
+    const wakes = { a: 0, b: 0 }
+    family.at('a').subscribe(() => {
+      wakes.a += 1
+    })
+    family.at('b').subscribe(() => {
+      wakes.b += 1
+    })
+
+    // Only `a` moves: b's member recomputes but its output is Equal — silent.
+    feed.set({ a: 2, b: 10 })
+    yield* tick
+    expect(wakes).toEqual({ a: 1, b: 0 })
+
+    feed.set({ a: 2, b: 11 })
+    yield* tick
+    expect(wakes).toEqual({ a: 1, b: 1 })
+  }).pipe(Effect.provide(TestLayer))
+})
+
+it.live('reading does not recompute while the shared inputs are unchanged (memoized per member)', () => {
+  const { Inputs, Slice, SliceLive, runs } = fixture()
+  const TestLayer = SliceLive.pipe(
+    Layer.provideMerge(StateGroup.live(Inputs, { feed: { a: 1 } })),
+  )
+  return Effect.gen(function* () {
+    yield* CalcFamily.read(Slice, 'a')
+    yield* CalcFamily.read(Slice, 'a')
+    yield* CalcFamily.read(Slice, 'a')
+    expect(runs.get('a')).toBe(1)
+  }).pipe(Effect.provide(TestLayer))
+})
+
+it.live('invalidateBy: shared-input churn outside the key recomputes no member', () => {
+  class Feed extends State.make('feed', Board) {}
+  class Noise extends State.make('noise', S.Number) {}
+  class Inputs extends StateGroup.make(Feed, Noise) {}
+  const runs = new Map<string, number>()
+  class Slice extends CalcFamily.make('Slice', {
+    key: S.String,
+    inputs: [StateGroup.select(Inputs, 'feed'), StateGroup.select(Inputs, 'noise')],
+    output: S.Number,
+  }) {}
+  const SliceLive = CalcFamily.live(
+    Slice,
+    (key) => ({ feed }) => {
+      runs.set(key, (runs.get(key) ?? 0) + 1)
+      return feed[key] ?? 0
+    },
+    { invalidateBy: ({ feed }) => [feed] },
+  )
+  const TestLayer = SliceLive.pipe(
+    Layer.provideMerge(StateGroup.live(Inputs, { feed: { a: 1 }, noise: 0 })),
+  )
+  return Effect.gen(function* () {
+    const noise = yield* StateGroup.select(Inputs, 'noise').store
+    expect(yield* CalcFamily.read(Slice, 'a')).toBe(1)
+    expect(runs.get('a')).toBe(1)
+
+    noise.set(99)
+    yield* tick
+    expect(yield* CalcFamily.read(Slice, 'a')).toBe(1)
+    expect(runs.get('a')).toBe(1)
+  }).pipe(Effect.provide(TestLayer))
+})
+
+it.live('forget releases the member and its upstream subscription', () => {
+  const { Inputs, Slice, SliceLive, runs } = fixture()
+  const TestLayer = SliceLive.pipe(
+    Layer.provideMerge(StateGroup.live(Inputs, { feed: { a: 1 } })),
+  )
+  return Effect.gen(function* () {
+    const feed = yield* StateGroup.select(Inputs, 'feed').store
+    const family = yield* Slice.store
+    family.at('a')
+    expect(family.size()).toBe(1)
+
+    family.forget('a')
+    expect(family.size()).toBe(0)
+    // The dropped member no longer recomputes on upstream churn.
+    const before = runs.get('a') ?? 0
+    feed.set({ a: 2 })
+    yield* tick
+    expect(runs.get('a') ?? 0).toBe(before)
+
+    // Re-`at`-ing allocates a fresh member over the current snapshot.
+    expect(family.at('a').get()).toBe(2)
+  }).pipe(Effect.provide(TestLayer))
+})
+
+it.live('evictWhenUnused: an idle member is dropped on the next microtask and unsubscribes', () => {
+  class Feed extends State.make('feed', Board) {}
+  class Inputs extends StateGroup.make(Feed) {}
+  const runs = new Map<string, number>()
+  class Slice extends CalcFamily.make('Slice', {
+    key: S.String,
+    inputs: [StateGroup.select(Inputs, 'feed')],
+    output: S.Number,
+  }) {}
+  const SliceLive = CalcFamily.live(
+    Slice,
+    (key) => ({ feed }) => {
+      runs.set(key, (runs.get(key) ?? 0) + 1)
+      return feed[key] ?? 0
+    },
+    { evictWhenUnused: true },
+  )
+  const TestLayer = SliceLive.pipe(
+    Layer.provideMerge(StateGroup.live(Inputs, { feed: { a: 1 } })),
+  )
+  return Effect.gen(function* () {
+    const feed = yield* StateGroup.select(Inputs, 'feed').store
+    const family = yield* Slice.store
+    const off = family.at('a').subscribe(() => {})
+    expect(family.size()).toBe(1)
+
+    off()
+    yield* tick
+    expect(family.size()).toBe(0)
+    const before = runs.get('a') ?? 0
+    feed.set({ a: 2 })
+    yield* tick
+    expect(runs.get('a') ?? 0).toBe(before)
+  }).pipe(Effect.provide(TestLayer))
+})
+
+it.live('the layer finalizer clears every member (no live subscriptions leak)', () => {
+  const { Inputs, Slice, SliceLive, runs } = fixture()
+  return Effect.scoped(
+    Effect.gen(function* () {
+      // Build the input stores once, then the family in its OWN scope over that
+      // exact context — so the stores outlive the family and we can prove the
+      // members' upstream subscriptions died with it.
+      const storesCtx = yield* Layer.build(StateGroup.live(Inputs, { feed: { a: 1, b: 2 } }))
+      const feed = Context.get(storesCtx, StateGroup.select(Inputs, 'feed').store)
+      const scope = yield* Scope.make()
+      const familyCtx = yield* Layer.buildWithScope(SliceLive, scope).pipe(
+        Effect.provide(storesCtx),
+      )
+      const family = Context.get(familyCtx, Slice.store)
+      family.at('a')
+      family.at('b')
+      expect(family.size()).toBe(2)
+
+      yield* Scope.close(scope, Exit.void)
+      expect(family.size()).toBe(0)
+      const before = [runs.get('a') ?? 0, runs.get('b') ?? 0]
+      feed.set({ a: 9, b: 9 })
+      yield* tick
+      expect([runs.get('a') ?? 0, runs.get('b') ?? 0]).toEqual(before)
+    }),
+  )
+})

package/src/calc/compose.test.ts

@@ -0,0 +1,68 @@
+import { expect, it } from '@effect/vitest'
+import { Effect, Layer, Schema as S } from 'effect'
+import { Calc, composeCalcs, State, StateGroup } from '../index'
+
+// `composeCalcs` wires a calc-on-calc chain in dependency order. The shape under
+// test is the one that defeats a flat `Layer.mergeAll`: a linear chain where each
+// calc's only input is the previous calc — count → Doubled → PlusOne → Tripled.
+
+it.live('composeCalcs wires a linear calc chain; the result needs only the base state', () => {
+  class Count extends State.make('count', S.Number) {}
+  class Inputs extends StateGroup.make(Count) {}
+
+  class Doubled extends Calc.make('Doubled', {
+    inputs: [StateGroup.select(Inputs, 'count')],
+    output: S.Number,
+  }) {}
+  const DoubledLive = Calc.live(Doubled, ({ count }) => count * 2)
+
+  class PlusOne extends Calc.make('PlusOne', { inputs: [Doubled], output: S.Number }) {}
+  const PlusOneLive = Calc.live(PlusOne, ({ Doubled }) => Doubled + 1)
+
+  class Tripled extends Calc.make('Tripled', { inputs: [PlusOne], output: S.Number }) {}
+  const TripledLive = Calc.live(Tripled, ({ PlusOne }) => PlusOne * 3)
+
+  // Leaf-first, then upstreams in dependency order. The composed layer's only
+  // remaining requirement is the base `count` store — which the type system
+  // proves by letting us provide *only* the state group below.
+  // The chain's only remaining requirement is the base `count` store — provide
+  // (and expose, via provideMerge) just the state group and everything builds.
+  const Chain = composeCalcs(TripledLive, PlusOneLive, DoubledLive)
+  const TestLayer = Chain.pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 5 })))
+
+  return Effect.gen(function* () {
+    const source = yield* StateGroup.select(Inputs, 'count').store
+    const tripled = yield* Tripled.store
+    // count 5 → Doubled 10 → PlusOne 11 → Tripled 33
+    expect(tripled.get()).toBe(33)
+
+    source.set(2)
+    yield* Effect.yieldNow()
+    // count 2 → Doubled 4 → PlusOne 5 → Tripled 15
+    expect(tripled.get()).toBe(15)
+  }).pipe(Effect.provide(TestLayer))
+})
+
+it.live('composeCalcs(leaf, upstream) matches the hand-written provideMerge chain', () => {
+  class Count extends State.make('count', S.Number) {}
+  class Inputs extends StateGroup.make(Count) {}
+  class Doubled extends Calc.make('Doubled', {
+    inputs: [StateGroup.select(Inputs, 'count')],
+    output: S.Number,
+  }) {}
+  const DoubledLive = Calc.live(Doubled, ({ count }) => count * 2)
+  class PlusDoubled extends Calc.make('PlusDoubled', {
+    inputs: [StateGroup.select(Inputs, 'count'), Doubled],
+    output: S.Number,
+  }) {}
+  const PlusDoubledLive = Calc.live(PlusDoubled, ({ count, Doubled }) => count + Doubled)
+
+  const TestLayer = composeCalcs(PlusDoubledLive, DoubledLive).pipe(
+    Layer.provideMerge(StateGroup.live(Inputs, { count: 5 })),
+  )
+
+  return Effect.gen(function* () {
+    const derived = yield* PlusDoubled.store
+    expect(derived.get()).toBe(15) // 5 + (5*2), same as the manual-pipe test
+  }).pipe(Effect.provide(TestLayer))
+})

package/src/channel/channel.ts

@@ -84,7 +84,9 @@ export interface ProcedureRegistry {
   readonly unregister: (entry: ProcedureEntry) => void
 }
 
-export class Procedures extends Context.Tag('reform/Procedures')<Procedures, ProcedureRegistry>() {}
+const ProceduresBase: Context.TagClass<Procedures, 'reform/Procedures', ProcedureRegistry> =
+  Context.Tag('reform/Procedures')<Procedures, ProcedureRegistry>()
+export class Procedures extends ProceduresBase {}
 
 /** Get a map entry, creating and inserting it on first access (avoids `let`). */
 const getOrCreate = <K, V>(map: Map<K, V>, key: K, make: () => V): V => {
@@ -143,7 +145,7 @@ const makeProcedureRegistry = (): ProcedureRegistry => {
   }
 }
 
-export const proceduresLayer = Layer.sync(Procedures, makeProcedureRegistry)
+export const proceduresLayer: Layer.Layer<Procedures> = Layer.sync(Procedures, makeProcedureRegistry)
 
 /** A live channel: the single loop offers events here; the channel drives them. */
 export interface ChannelRuntime {
@@ -154,12 +156,14 @@ export interface ChannelRuntime {
 }
 
 /** Registry of live channels, keyed by name. The single loop routes through it. */
-export class Channels extends Context.Tag('reform/Channels')<
+const ChannelsBase: Context.TagClass<
   Channels,
+  'reform/Channels',
   { readonly byName: Map<string, ChannelRuntime> }
->() {}
+> = Context.Tag('reform/Channels')<Channels, { readonly byName: Map<string, ChannelRuntime> }>()
+export class Channels extends ChannelsBase {}
 
-export const channelsLayer = Layer.sync(Channels, () => ({ byName: new Map() }))
+export const channelsLayer: Layer.Layer<Channels> = Layer.sync(Channels, () => ({ byName: new Map() }))
 
 /**
  * A scheduling lane for procedures. The *definition* (`Channel.make`) is a

package/src/compose/host.ts

@@ -11,5 +11,8 @@ export interface SlotHost {
   slot(name: string): (props: unknown) => Node
 }
 
+const CurrentSlotsBase: Context.TagClass<CurrentSlots, 'reform/Slots', SlotHost> =
+  Context.Tag('reform/Slots')<CurrentSlots, SlotHost>()
+
 /** The active composition's slot bindings, provided per render by the host. */
-export class CurrentSlots extends Context.Tag('reform/Slots')<CurrentSlots, SlotHost>() {}
+export class CurrentSlots extends CurrentSlotsBase {}

package/src/compose/props.ts

@@ -7,4 +7,8 @@ import { Context } from 'effect'
  * (Per-instance typing of Props is DESIGN #26 — for now the value is opaque and
  * narrowed at the use site against the composition's declared props schema.)
  */
-export class Props extends Context.Tag('reform/Props')<Props, any>() {}
+const PropsBase: Context.TagClass<Props, 'reform/Props', any> = Context.Tag('reform/Props')<
+  Props,
+  any
+>()
+export class Props extends PropsBase {}

package/src/compose/ui.test.ts

@@ -0,0 +1,62 @@
+import { expect, test } from 'vitest'
+import { Effect, Schema as S } from 'effect'
+import { Ui, isUi, ui } from '../index'
+import { CaptureSink, type UiCapture } from '../internal/capture'
+import type { Trigger } from '../ui/trigger'
+
+// `ui` has two authoring forms with one source of truth each: the type-only form
+// (local, no schema) and the schema form (wired, the type is *derived*). Both are
+// the same contract at runtime; only the wired form carries reflectable schemas.
+
+test('type-only `ui` carries no wire schema', () => {
+  class CounterUi extends ui('Counter')<{ props: { count: number } }>() {}
+  expect(CounterUi.manifest.kind).toBe('Ui')
+  expect(CounterUi.manifest.name).toBe('Counter')
+  expect(CounterUi.manifest.props).toBeUndefined()
+  expect(CounterUi.manifest.events).toBeUndefined()
+  expect(isUi(CounterUi)).toBe(true)
+})
+
+test('schema `ui` carries props and per-event wire schemas', () => {
+  class CounterUi extends ui('Counter', {
+    props: S.Struct({ count: S.Number }),
+    events: { bump: S.Struct({ by: S.Number }) },
+  }) {}
+  expect(CounterUi.manifest.kind).toBe('Ui')
+  expect(CounterUi.manifest.name).toBe('Counter')
+  expect(S.isSchema(CounterUi.manifest.props)).toBe(true)
+  expect(S.isSchema(CounterUi.manifest.events?.['bump'])).toBe(true)
+  expect(isUi(CounterUi)).toBe(true)
+})
+
+test('schema `ui` with no events omits the events schema', () => {
+  class TitleUi extends ui('Title', { props: S.Struct({ text: S.String }) }) {}
+  expect(S.isSchema(TitleUi.manifest.props)).toBe(true)
+  expect(TitleUi.manifest.events).toBeUndefined()
+})
+
+test('a contract resolves its presentation and reports to a capturing sink', () => {
+  class CounterUi extends ui('Counter', {
+    props: S.Struct({ count: S.Number }),
+    events: { bump: S.Struct({ by: S.Number }) },
+  }) {}
+
+  const view = Ui.make(CounterUi, ({ count }) => `count:${count}`)
+  const records: UiCapture[] = []
+  const sink = { record: (capture: UiCapture): void => void records.push(capture) }
+
+  const logicView = Effect.runSync(
+    CounterUi.pipe(
+      Effect.provideService(CounterUi.impl, view),
+      Effect.provideService(CaptureSink, sink),
+    ),
+  )
+
+  const bump: Trigger<{ by: number }> = () => {}
+  const node = logicView({ count: 3 }, { bump })
+
+  expect(node).toBe('count:3')
+  expect(records).toHaveLength(1)
+  expect(records[0]?.name).toBe('Counter')
+  expect(records[0]?.props).toEqual({ count: 3 })
+})