@playfast/reform 0.0.7 → 0.0.9

package/src/calc/asyncCalc.ts

@@ -0,0 +1,267 @@
+import { Context, Effect, Layer, Option, Schema } from 'effect'
+import { type Manifest, yieldableClass } from '../definition/definition'
+import { type AnyEvent } from '../event/event'
+import {
+  type InputsObject,
+  type InputStores,
+  type InvalidateBy,
+} from '../internal/sources'
+import {
+  bumpRevision,
+  type GatedOf,
+  gatedFlag,
+  makeQueryDriver,
+  RevisionSchema,
+  revisionZero,
+} from '../internal/queryDriver'
+import { type Store } from '../internal/store'
+import { readTracked } from '../internal/track'
+import * as Reducer from '../reducer/reducer'
+import { Reducers } from '../runtime/loop'
+import * as State from '../state/state'
+import { type AnySource } from '../state/token'
+import { type AsyncData, narrowStore } from './asyncData'
+
+// `AsyncCalc` is `Calc`'s async sibling: a derived store whose value is the
+// lifecycle of an Effect (a query), recomputed reactively from its inputs — the
+// React-Query model, but inside the reform graph and without dispatching events.
+// Definition (`make`) is reflectable data; implementation (`live`) is the effect.
+// The reactive machinery lives in `internal/queryDriver` (shared with
+// `RemoteState`); this module owns the definition shape and the `invalidateOn`
+// sugar.
+
+export interface AsyncCalcManifest<N extends string, A, E> extends Manifest {
+  readonly kind: 'AsyncCalc'
+  readonly name: N
+  readonly output: Schema.Schema<A, any>
+  readonly error?: Schema.Schema<E, any>
+  /** Whether the query can be disabled (drives the `Idle` arm). */
+  readonly gated: boolean
+}
+
+export interface AsyncCalcClass<
+  out N extends string,
+  out Inputs extends ReadonlyArray<AnySource>,
+  in out A,
+  in out E,
+  in out Gated extends boolean,
+> extends Effect.Effect<AsyncData<A, E, Gated>, never, Store<AsyncData<A, E, Gated>>> {
+  new (): {}
+  readonly manifest: AsyncCalcManifest<N, A, E>
+  readonly store: Context.Tag<Store<AsyncData<A, E, Gated>>, Store<AsyncData<A, E, Gated>>>
+  /** The calc's name, so it doubles as a `Source` input to another (async) calc. */
+  readonly name: N
+  /** Marker data read by `AsyncCalc.live`. */
+  readonly inputs: Inputs
+  /** Runtime mirror of `Gated`: whether `disabled` is honored / `Idle` can occur. */
+  readonly gated: Gated
+}
+
+export interface AsyncCalcConfig<Inputs extends ReadonlyArray<AnySource>, A, E, AlwaysOn extends boolean> {
+  readonly inputs: Inputs
+  /** Schema of the `Success` value. */
+  readonly output: Schema.Schema<A, any>
+  /** Schema of the failure. Omitted ⇒ the query is infallible and there is no `Error` arm. */
+  readonly error?: Schema.Schema<E, any>
+  /** `true` ⇒ the query is always on: no `Idle` arm and `disabled` is rejected on `.live`. */
+  readonly alwaysOn?: AlwaysOn
+}
+
+/**
+ * The `.live` config: the effect plus the reactive logic. `disabled` is only
+ * accepted for a gateable query (no `alwaysOn`); `invalidateBy` is the same
+ * `queryKey` projection `Calc` uses.
+ */
+export type AsyncCalcLive<
+  Inputs extends ReadonlyArray<AnySource>,
+  A,
+  E,
+  Gated extends boolean,
+  R,
+> = {
+  readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
+  readonly invalidateBy?: InvalidateBy<Inputs>
+  /**
+   * Refetch conciliation. `'switch'` (default): a new key cancels the in-flight
+   * run (latest-wins). `'trailing'`: the in-flight run completes; key changes
+   * that arrive meanwhile conflate to the latest, and exactly ONE trailing
+   * refetch runs after it settles — a burst of N invalidations during one
+   * flight costs 2 fetches, not N cancel-restarts.
+   */
+  readonly coalesce?: 'switch' | 'trailing'
+  /**
+   * Structural sharing for `Success` values: reconcile each refetch result
+   * against the previous one, substituting previous nodes wherever value
+   * equality holds — refetches returning mostly-identical data keep unchanged
+   * subtree identities, so downstream memo boundaries skip them. Same pass as
+   * `Calc`'s `reuse`; opt-in (one O(result) walk per settle).
+   */
+  readonly reuse?: boolean
+} & (Gated extends true
+  ? { readonly disabled?: (inputs: InputsObject<Inputs>) => boolean }
+  : { readonly disabled?: never })
+
+/**
+ * Define an async derived value. `output`/`error` schemas and `alwaysOn` shape
+ * the value type, so `yield* MyQuery` is typed to exactly the arms that can
+ * occur. The query effect itself is supplied by `AsyncCalc.live`.
+ */
+export const make = <
+  const N extends string,
+  const Inputs extends ReadonlyArray<AnySource>,
+  A,
+  E = never,
+  const AlwaysOn extends boolean = false,
+>(
+  name: N,
+  config: AsyncCalcConfig<Inputs, A, E, AlwaysOn>,
+): AsyncCalcClass<N, Inputs, A, E, GatedOf<AlwaysOn>> => {
+  const store = Context.GenericTag<Store<AsyncData<A, E, GatedOf<AlwaysOn>>>>(
+    `reform/asyncCalc/${name}`,
+  )
+  // Runtime mirror of the type-level `Gated`, typed as its literal in one place.
+  const gated = gatedFlag(config.alwaysOn)
+  const manifest: AsyncCalcManifest<N, A, E> = {
+    kind: 'AsyncCalc',
+    name,
+    output: config.output,
+    gated,
+    ...(config.error !== undefined ? { error: config.error } : {}),
+  }
+  const read = Effect.flatMap(store, readTracked)
+  return yieldableClass(read, {
+    manifest,
+    store,
+    name,
+    inputs: config.inputs,
+    gated,
+  })
+}
+
+/**
+ * Wire the query and its reactive logic. The query runs on the runtime (its `R`
+ * — RPC clients, etc. — is captured from the layer context). A change to an
+ * input re-runs it latest-wins (a new run cancels the in-flight one; or, with
+ * `coalesce: 'trailing'`, lets it finish and runs one trailing refetch); while a
+ * re-run is in flight the last `Success`/`Error` is kept with `refetching: true`.
+ * Re-runs are driven by inputs / `invalidateBy` / `disabled` — and, with
+ * `invalidateOn`, by listed events: pure sugar that generates a hidden revision
+ * state + reducer (the sole writer) and appends the revision to the calc's key,
+ * so an event-driven refetch is still just key movement under `Equal.equals`.
+ * The hidden pair stays internal — the user's `query`/`invalidateBy` see exactly
+ * the declared inputs — and costs the layer one extra requirement: the
+ * `Reducers` registry (the `Engine`).
+ */
+export function live<
+  N extends string,
+  Inputs extends ReadonlyArray<AnySource>,
+  A,
+  E,
+  Gated extends boolean,
+  R,
+>(
+  calc: AsyncCalcClass<N, Inputs, A, E, Gated>,
+  config: AsyncCalcLive<Inputs, A, E, Gated, R> & {
+    readonly invalidateOn: ReadonlyArray<AnyEvent>
+  },
+): Layer.Layer<Store<AsyncData<A, E, Gated>>, never, InputStores<Inputs> | R | Reducers>
+export function live<
+  N extends string,
+  Inputs extends ReadonlyArray<AnySource>,
+  A,
+  E,
+  Gated extends boolean,
+  R,
+>(
+  calc: AsyncCalcClass<N, Inputs, A, E, Gated>,
+  config: AsyncCalcLive<Inputs, A, E, Gated, R>,
+): Layer.Layer<Store<AsyncData<A, E, Gated>>, never, InputStores<Inputs> | R>
+export function live<
+  N extends string,
+  Inputs extends ReadonlyArray<AnySource>,
+  A,
+  E,
+  Gated extends boolean,
+  R,
+>(
+  calc: AsyncCalcClass<N, Inputs, A, E, Gated>,
+  config: AsyncCalcLive<Inputs, A, E, Gated, R> & {
+    readonly invalidateOn?: ReadonlyArray<AnyEvent>
+  },
+  // The wide-R implementation signature behind precise overloads — the same
+  // seam `Reducer.live` uses; both overload returns are assignable (RIn is
+  // covariant), so no value is ever cast.
+): Layer.Layer<Store<AsyncData<A, E, Gated>>, never, any> {
+  // The hidden revision pair, built once per `live` call. Namespacing the state
+  // by the calc's name (`reform/state/${calcName}/invalidateOn`) keeps the tag
+  // out of any plausible user namespace; the duplicate-reducer check is
+  // warning-only and calc names are unique by convention.
+  const revisionState =
+    config.invalidateOn === undefined
+      ? undefined
+      : State.make(`${calc.manifest.name}/invalidateOn`, RevisionSchema)
+
+  // Scoped so the source subscriptions and the driver fiber are released when
+  // the layer's scope closes (each proof/test builds and disposes its runtime).
+  const driver = Layer.scoped(
+    calc.store,
+    Effect.gen(function* () {
+      // `disabled` is rejected at the type level for non-gated calcs (erased to
+      // `never` there); read it through a loose view for the runtime.
+      const cfg = config as {
+        readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
+        readonly invalidateBy?: InvalidateBy<Inputs>
+        readonly disabled?: (inputs: InputsObject<Inputs>) => boolean
+        readonly coalesce?: 'switch' | 'trailing'
+        readonly reuse?: boolean
+      }
+
+      // The hidden revision store, read requirement-free (`serviceOption`): the
+      // assembly below always provides it alongside this driver, and feeding it
+      // through `extraKey` (not `wireSources`) keeps it out of the snapshot —
+      // the user's `query` and `invalidateBy` receive exactly
+      // `InputsObject<Inputs>`, with no hidden property to leak into
+      // spread-into-RPC payloads.
+      const revision =
+        revisionState === undefined
+          ? undefined
+          : Option.getOrUndefined(yield* Effect.serviceOption(revisionState.store))
+      const driver = yield* makeQueryDriver({
+        name: calc.manifest.name,
+        label: 'AsyncCalc',
+        gated: calc.gated,
+        inputs: calc.inputs,
+        query: cfg.query,
+        invalidateBy: cfg.invalidateBy,
+        disabled: cfg.disabled,
+        coalesce: cfg.coalesce,
+        reuse: cfg.reuse,
+        extraKey:
+          revision === undefined
+            ? undefined
+            : {
+                read: () => revision.getSnapshot(),
+                subscribe: (listener) => revision.subscribe(listener),
+              },
+      })
+
+      // The internal store is the full union; narrow to the definition's arms.
+      return narrowStore<A, E, Gated>(driver.store)
+    }),
+  )
+
+  if (config.invalidateOn === undefined || revisionState === undefined) return driver
+  // The hidden reducer: an ordinary `Reducer` folding every listed event to
+  // n + 1 — the revision's sole writer, registered/unregistered with this
+  // layer's scope like any user reducer. `Layer.provide` builds the hidden
+  // state once and feeds the same store to both the driver and the reducer,
+  // while the outer context (user inputs, the `Reducers` registry) passes
+  // through untouched.
+  const revisionReducer = Reducer.make(`${calc.manifest.name}/invalidateOn`, {
+    states: [revisionState],
+    events: config.invalidateOn,
+  })
+  return Layer.merge(driver, Reducer.live(revisionReducer, bumpRevision)).pipe(
+    Layer.provide(State.live(revisionState, revisionZero)),
+  )
+}

package/src/calc/asyncData.ts

@@ -0,0 +1,96 @@
+import { type Store } from '../internal/store'
+
+// The value an `AsyncCalc` holds: a tagged union of the query's lifecycle,
+// consumed with `effect`'s `Match` (`Match.value(data).pipe(Match.tag('Success', …))`).
+//
+// The shape is narrowed by the definition, so you only handle arms that can
+// occur: `Idle` exists only for a gateable query (no `alwaysOn`), and `Error`
+// exists only when the query declares an `error` schema. There is no separate
+// "refreshing" arm — a re-fetch keeps the last `Success`/`Error` and flips its
+// `refetching` flag (stale-while-revalidate), so the UI never flashes empty.
+
+/** A gated query that is currently switched off (only when not `alwaysOn`). */
+export interface AsyncIdle {
+  readonly _tag: 'Idle'
+}
+
+/** The first fetch, before any value exists. */
+export interface AsyncLoading {
+  readonly _tag: 'Loading'
+}
+
+/** A resolved value; `refetching` is true while a background re-fetch runs. */
+export interface AsyncSuccess<A> {
+  readonly _tag: 'Success'
+  readonly value: A
+  readonly refetching: boolean
+}
+
+/** A failed query; `refetching` is true while a background re-fetch runs. */
+export interface AsyncError<E> {
+  readonly _tag: 'Error'
+  readonly error: E
+  readonly refetching: boolean
+}
+
+/**
+ * The query lifecycle. `Gated` adds the `Idle` arm (a disable-able query); a
+ * non-`never` `E` adds the `Error` arm. Both are decided at `AsyncCalc.make`, so
+ * `yield* MyQuery` is typed to exactly the arms that can occur.
+ */
+export type AsyncData<A, E = never, Gated extends boolean = false> =
+  | (Gated extends true ? AsyncIdle : never)
+  | AsyncLoading
+  | AsyncSuccess<A>
+  | ([E] extends [never] ? never : AsyncError<E>)
+
+/** The full (un-narrowed) union — used internally by the live store. */
+export type AnyAsyncData<A, E> = AsyncIdle | AsyncLoading | AsyncSuccess<A> | AsyncError<E>
+
+const idle: AsyncIdle = { _tag: 'Idle' }
+const loading: AsyncLoading = { _tag: 'Loading' }
+const success = <A>(value: A, refetching = false): AsyncSuccess<A> => ({
+  _tag: 'Success',
+  value,
+  refetching,
+})
+const error = <E>(err: E, refetching = false): AsyncError<E> => ({
+  _tag: 'Error',
+  error: err,
+  refetching,
+})
+
+/** The arm-constructor namespace exposed as `AsyncData`. */
+export interface AsyncDataConstructors {
+  readonly idle: AsyncIdle
+  readonly loading: AsyncLoading
+  readonly success: <A>(value: A, refetching?: boolean) => AsyncSuccess<A>
+  readonly error: <E>(err: E, refetching?: boolean) => AsyncError<E>
+}
+
+/**
+ * Constructors for the arms, namespaced under the same name as the type so call
+ * sites read `AsyncData.success(v)` / `AsyncData.error(e)` — no `error` import
+ * shadowing the keyword and one obvious home for every arm.
+ */
+export const AsyncData: AsyncDataConstructors = { idle, loading, success, error }
+
+/**
+ * Narrow the live store (which holds the full `AnyAsyncData` union) to the arms
+ * the definition actually permits (`Gated`/`E`). The single documented home for
+ * that narrowing, so `AsyncCalc.live` returns it without an inline cast.
+ */
+export const narrowStore = <A, E, Gated extends boolean>(
+  store: Store<AnyAsyncData<A, E>>,
+): Store<AsyncData<A, E, Gated>> => store as unknown as Store<AsyncData<A, E, Gated>>
+
+/**
+ * The read-only inverse of `narrowStore`: widen a definition-narrowed store back
+ * to the full union, so a consumer (the `RemoteState` overlay) can dispatch on the
+ * lifecycle arms without carrying the definition's `Gated`/`E` conditionals.
+ * Sound for reads only — every narrowed value IS an `AnyAsyncData` — so callers
+ * must never `set` through the widened view (derived stores ignore `set` anyway).
+ */
+export const widenStore = <A, E, Gated extends boolean>(
+  store: Store<AsyncData<A, E, Gated>>,
+): Store<AnyAsyncData<A, E>> => store as unknown as Store<AnyAsyncData<A, E>>

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))
+})