@playfast/reform 1.1.1 → 1.2.0

package/src/calc/asyncCalc.ts

@@ -1,28 +1,32 @@
-import { Context, Effect, Layer, Match, Option } from 'effect'
+import { Context, Effect, Layer, Match, Option, Schema } from 'effect'
 import type { Effect as EffectType } from 'effect/Effect'
-import { type Manifest } from '../definition/definition'
+import { type Manifest, yieldableClass } from '../definition/definition'
 import { type AnyEvent } from '../event/event'
-import {
-  type InputsObject,
-  type InputStores,
-  type InvalidateBy,
-} from '../internal/sources'
+import { type InputsObject, type InputStores, type InvalidateBy } from '../internal/sources'
+import type { AnySchema } from '../internal/variance'
 import {
   bumpRevision,
+  type GatedOf,
+  gatedFlag,
   makeQueryDriver,
+  type QueryCodec,
   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 { Queries } from '../runtime/queries'
 import * as State from '../state/state'
-import { type AnySource } from '../state/token'
+import { type AnySource, type Source, type SourceCapture } from '../state/token'
 import { type AsyncData, narrowStore } from './asyncData'
-import type { AnySchema, AnyValue } from '../internal/variance'
-export { invalidate, make, type NamedCalc, refetch } from './asyncCalcDefinitions'
 
-export interface AsyncCalcManifest<N extends string, A, E> extends Manifest {
+export interface AsyncCalcSchemaReflection {
+  readonly ast: Schema.Schema<unknown, unknown, unknown>['ast']
+}
+
+export interface AsyncCalcManifest<N extends string, A = unknown, E = never> extends Manifest {
   readonly kind: 'AsyncCalc'
   readonly name: N
   readonly output: AnySchema<A>
@@ -31,30 +35,88 @@ export interface AsyncCalcManifest<N extends string, A, E> extends Manifest {
   readonly gated: boolean
 }
 
-export interface AsyncCalcClass<
-  out N extends string,
-  out Inputs extends ReadonlyArray<AnySource>,
+export const AsyncCalcStoreTypeId: unique symbol = Symbol.for('reform/AsyncCalcStore')
+export type AsyncCalcStoreTypeId = typeof AsyncCalcStoreTypeId
+
+interface AsyncCalcStoreCompatibilityExternalApi<
+  N extends string,
   in out A,
   in out E,
   in out Gated extends boolean,
-> extends EffectType<AsyncData<A, E, Gated>, never, Store<AsyncData<A, E, Gated>>> {
+> extends Store<AsyncData<A, E, Gated>> {
+  readonly [AsyncCalcStoreTypeId]?: N
+}
+
+export type AsyncCalcStore<
+  N extends string,
+  A,
+  E,
+  Gated extends boolean,
+> = AsyncCalcStoreCompatibilityExternalApi<N, A, E, Gated>
+
+export interface AsyncCalcClass<
+  N extends string,
+  Inputs extends ReadonlyArray<AnySource>,
+  A,
+  E,
+  Gated extends boolean,
+>
+  extends
+    EffectType<AsyncData<A, E, Gated>, never, AsyncCalcStore<N, A, E, Gated>>,
+    Source<N, AsyncData<A, E, Gated>, AsyncCalcStore<N, A, E, Gated>> {
   new (): {}
   readonly manifest: AsyncCalcManifest<N, A, E>
-  readonly store: Context.Tag<Store<AsyncData<A, E, Gated>>, Store<AsyncData<A, E, Gated>>>
+  readonly store: Context.Tag<AsyncCalcStore<N, A, E, Gated>, Store<AsyncData<A, E, Gated>>>
   readonly name: N
   readonly inputs: Inputs
   readonly gated: Gated
 }
 
-export interface AsyncCalcConfig<Inputs extends ReadonlyArray<AnySource>, A, E, AlwaysOn extends boolean> {
+export interface DefinedAsyncCalcClass<
+  N extends string,
+  Inputs extends ReadonlyArray<AnySource>,
+  A,
+  E,
+  Gated extends boolean,
+> extends AsyncCalcClass<N, Inputs, A, E, Gated> {
+  readonly codec: QueryCodec<A>
+  readonly capture: <Result>(visit: SourceCapture<Result>) => Result
+}
+
+type ConfigSchema<ValueOrSchema> = [ValueOrSchema] extends [Schema.Schema.AnyNoContext]
+  ? ValueOrSchema
+  : AnySchema<ValueOrSchema>
+
+type ConfigErrorSchema<ValueOrSchema> = [ValueOrSchema] extends [undefined]
+  ? ValueOrSchema
+  : ConfigSchema<ValueOrSchema>
+
+export interface AsyncCalcConfig<
+  Inputs extends ReadonlyArray<AnySource>,
+  OutputSchema,
+  ErrorSchema,
+  AlwaysOn extends boolean,
+> {
   readonly inputs: Inputs
-  readonly output: AnySchema<A>
+  readonly output: ConfigSchema<OutputSchema>
   // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
-  readonly error?: AnySchema<E>
+  readonly error?: ConfigErrorSchema<ErrorSchema>
   // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
   readonly alwaysOn?: AlwaysOn
 }
 
+interface AsyncCalcMakeConfigExternalApi<
+  Inputs extends ReadonlyArray<AnySource>,
+  OutputSchema extends Schema.Schema.AnyNoContext,
+  ErrorSchema extends Schema.Schema.AnyNoContext | undefined,
+  AlwaysOn extends boolean,
+> {
+  readonly inputs: Inputs
+  readonly output: OutputSchema
+  readonly error?: ErrorSchema
+  readonly alwaysOn?: AlwaysOn
+}
+
 export type AsyncCalcLive<
   Inputs extends ReadonlyArray<AnySource>,
   A,
@@ -63,7 +125,6 @@ export type AsyncCalcLive<
   R,
 > = {
   readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
   readonly invalidateBy?: InvalidateBy<Inputs>
   // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
   readonly coalesce?: 'switch' | 'trailing'
@@ -72,13 +133,10 @@ export type AsyncCalcLive<
   // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
   readonly persist?:
     | boolean
-    // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
     | { readonly key?: string | ((inputs: InputsObject<Inputs>) => string) }
 } & (Gated extends true
-  ? // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
-    { readonly disabled?: (inputs: InputsObject<Inputs>) => boolean }
-  : // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
-    { readonly disabled?: never })
+  ? { readonly disabled?: (inputs: InputsObject<Inputs>) => boolean }
+  : { readonly disabled?: never })
 
 export type AsyncCalcLiveWithInvalidateOn<
   Inputs extends ReadonlyArray<AnySource>,
@@ -87,27 +145,83 @@ export type AsyncCalcLiveWithInvalidateOn<
   Gated extends boolean,
   R,
 > = AsyncCalcLive<Inputs, A, E, Gated, R> & {
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
   readonly invalidateOn?: ReadonlyArray<AnyEvent>
 }
 
 export interface AsyncCalcLiveView<Inputs extends ReadonlyArray<AnySource>, A, E, R> {
   readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
   readonly invalidateBy?: InvalidateBy<Inputs>
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
   readonly disabled?: (inputs: InputsObject<Inputs>) => boolean
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
   readonly coalesce?: 'switch' | 'trailing'
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
   readonly reuse?: boolean
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
   readonly persist?:
     | boolean
-    // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
     | { readonly key?: string | ((inputs: InputsObject<Inputs>) => string) }
 }
 
+export function make<
+  const N extends string,
+  const Inputs extends ReadonlyArray<AnySource>,
+  OutputSchema extends Schema.Schema.AnyNoContext,
+  ErrorSchema extends Schema.Schema.AnyNoContext | undefined = undefined,
+  const AlwaysOn extends boolean = false,
+>(
+  name: N,
+  config: AsyncCalcConfig<Inputs, OutputSchema, ErrorSchema, AlwaysOn>,
+): DefinedAsyncCalcClass<
+  N,
+  Inputs,
+  Schema.Schema.Type<OutputSchema>,
+  ErrorSchema extends Schema.Schema.AnyNoContext ? Schema.Schema.Type<ErrorSchema> : never,
+  GatedOf<AlwaysOn>
+>
+export function make<
+  const N extends string,
+  const Inputs extends ReadonlyArray<AnySource>,
+  OutputSchema extends Schema.Schema.AnyNoContext,
+  ErrorSchema extends Schema.Schema.AnyNoContext | undefined = undefined,
+  const AlwaysOn extends boolean = false,
+>(
+  name: N,
+  config: AsyncCalcMakeConfigExternalApi<Inputs, OutputSchema, ErrorSchema, AlwaysOn>,
+): DefinedAsyncCalcClass<
+  N,
+  Inputs,
+  Schema.Schema.Type<OutputSchema>,
+  ErrorSchema extends Schema.Schema.AnyNoContext ? Schema.Schema.Type<ErrorSchema> : never,
+  GatedOf<AlwaysOn>
+> {
+  type A = Schema.Schema.Type<OutputSchema>
+  type E = ErrorSchema extends Schema.Schema.AnyNoContext ? Schema.Schema.Type<ErrorSchema> : never
+  const store = Context.GenericTag<
+    AsyncCalcStore<N, A, E, GatedOf<AlwaysOn>>,
+    Store<AsyncData<A, E, GatedOf<AlwaysOn>>>
+  >(`reform/asyncCalc/${name}`)
+  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 codec: QueryCodec<A> = {
+    encode: Schema.encode(config.output),
+    decode: Schema.decodeUnknown(config.output),
+  }
+  const read = Effect.flatMap(store, readTracked)
+  const calc: DefinedAsyncCalcClass<N, Inputs, A, E, GatedOf<AlwaysOn>> = yieldableClass(read, {
+    manifest,
+    codec,
+    store,
+    name,
+    inputs: config.inputs,
+    gated,
+    capture: <Result>(visit: SourceCapture<Result>): Result => visit(calc),
+  })
+  return calc
+}
+
 export function live<
   N extends string,
   Inputs extends ReadonlyArray<AnySource>,
@@ -120,7 +234,7 @@ export function live<
   config: AsyncCalcLive<Inputs, A, E, Gated, R> & {
     readonly invalidateOn: ReadonlyArray<AnyEvent>
   },
-): Layer.Layer<Store<AsyncData<A, E, Gated>>, never, InputStores<Inputs> | R | Reducers>
+): Layer.Layer<AsyncCalcStore<N, A, E, Gated>, never, InputStores<Inputs> | R | Reducers>
 export function live<
   N extends string,
   Inputs extends ReadonlyArray<AnySource>,
@@ -131,7 +245,7 @@ export function live<
 >(
   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>
+): Layer.Layer<AsyncCalcStore<N, A, E, Gated>, never, InputStores<Inputs> | R>
 export function live<
   N extends string,
   Inputs extends ReadonlyArray<AnySource>,
@@ -142,7 +256,7 @@ export function live<
 >(
   calc: AsyncCalcClass<N, Inputs, A, E, Gated>,
   config: AsyncCalcLiveWithInvalidateOn<Inputs, A, E, Gated, R>,
-): Layer.Layer<Store<AsyncData<A, E, Gated>>, never, AnyValue> {
+): Layer.Layer<AsyncCalcStore<N, A, E, Gated>, never, InputStores<Inputs> | R | Reducers> {
   const revisionState =
     config.invalidateOn === undefined
       ? undefined
@@ -151,18 +265,21 @@ export function live<
   const driver = Layer.scoped(
     calc.store,
     Effect.gen(function* () {
-      // oxlint-disable-next-line reform-rules/no-type-assertion -- loose runtime view: `disabled` is type-erased to `never` for non-gated calcs, no guard recovers it
-      const cfg = config as AsyncCalcLiveView<Inputs, A, E, R>
+      const cfg: AsyncCalcLiveView<Inputs, A, E, R> = config
 
       const persistOption = cfg.persist
       const persistKey =
         persistOption === true || persistOption === undefined || persistOption === false
           ? calc.manifest.name
-          : persistOption.key ?? calc.manifest.name
+          : (persistOption.key ?? calc.manifest.name)
+      const persistCodec: QueryCodec<A> = {
+        encode: Schema.encode(calc.manifest.output),
+        decode: Schema.decodeUnknown(calc.manifest.output),
+      }
       const persist =
         persistOption === undefined || persistOption === false
           ? undefined
-          : { key: persistKey, schema: calc.manifest.output }
+          : { key: persistKey, codec: persistCodec }
 
       const revision = yield* Match.value(revisionState).pipe(
         Match.when(undefined, () => Effect.succeed(undefined)),
@@ -204,3 +321,15 @@ export function live<
     Layer.provide(State.live(revisionState, revisionZero)),
   )
 }
+
+export interface NamedCalc {
+  readonly name: string
+}
+
+export const invalidate = (calc: NamedCalc): Effect.Effect<void, never, Queries> =>
+  Effect.flatMap(Queries, (queries) =>
+    Effect.sync(() => queries.byName.get(calc.name)?.invalidate()),
+  )
+
+export const refetch = (calc: NamedCalc): Effect.Effect<void, never, Queries> =>
+  Effect.flatMap(Queries, (queries) => Effect.sync(() => queries.byName.get(calc.name)?.refetch()))

package/src/calc/calc.test.ts

@@ -211,11 +211,9 @@ it.live('reuse: an unchanged subtree keeps its identity across recompute', () =>
     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 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* () {

package/src/calc/calc.ts

@@ -1,4 +1,4 @@
-import { Context, Effect, Layer, MutableRef } from 'effect'
+import { Context, Effect, Layer, MutableRef, type Schema } from 'effect'
 import type { Effect as EffectType } from 'effect/Effect'
 import { type Manifest, yieldableClass } from '../definition/definition'
 import {
@@ -13,8 +13,7 @@ import { resolveInstrumentation, stateUpdateHook } from '../runtime/instrumentat
 import { reuse } from '../internal/reuse'
 import { makeDerivedStore, type Store } from '../internal/store'
 import { readTracked } from '../internal/track'
-import { type AnySource } from '../state/token'
-import type { AnySchema } from '../internal/variance'
+import { type AnySource, type Source, type SourceCapture } from '../state/token'
 
 export { type InputsObject, type InputStores, type InvalidateBy } from '../internal/sources'
 
@@ -23,41 +22,68 @@ export interface CalcOptionsExternalApi<Inputs extends ReadonlyArray<AnySource>>
   readonly reuse?: boolean
 }
 
-export interface CalcManifest<N extends string, Out> extends Manifest {
+export interface CalcSchemaReflection {
+  readonly ast: Schema.Schema<unknown, unknown, unknown>['ast']
+}
+
+export interface CalcManifest<N extends string> extends Manifest {
   readonly kind: 'Calc'
   readonly name: N
-  readonly output: AnySchema<Out>
+  readonly output: CalcSchemaReflection
+}
+
+export const CalcStoreTypeId: unique symbol = Symbol.for('reform/CalcStore')
+export type CalcStoreTypeId = typeof CalcStoreTypeId
+
+export interface CalcStore<N extends string, in out Out> extends Store<Out> {
+  readonly [CalcStoreTypeId]: N
 }
 
-export interface CalcClass<out N extends string, out Inputs extends ReadonlyArray<AnySource>, in out Out>
-  extends EffectType<Out, never, Store<Out>> {
+export interface CalcClass<N extends string, Inputs extends ReadonlyArray<AnySource>, Out>
+  extends EffectType<Out, never, CalcStore<N, Out>>, Source<N, Out, CalcStore<N, Out>> {
   new (): {}
-  readonly manifest: CalcManifest<N, Out>
-  readonly store: Context.Tag<Store<Out>, Store<Out>>
+  readonly manifest: CalcManifest<N>
+  readonly store: Context.Tag<CalcStore<N, Out>, Store<Out>>
   readonly name: N
   readonly inputs: Inputs
+  readonly capture: <Result>(visit: SourceCapture<Result>) => Result
 }
 
-export interface CalcConfig<Inputs extends ReadonlyArray<AnySource>, Out> {
+export interface CalcConfig<
+  Inputs extends ReadonlyArray<AnySource>,
+  OutputSchema extends Schema.Schema.AnyNoContext,
+> {
   readonly inputs: Inputs
-  readonly output: AnySchema<Out>
+  readonly output: OutputSchema
 }
 
-export const make = <const N extends string, const Inputs extends ReadonlyArray<AnySource>, Out>(
+export const make = <
+  const N extends string,
+  const Inputs extends ReadonlyArray<AnySource>,
+  OutputSchema extends Schema.Schema.AnyNoContext,
+>(
   name: N,
-  config: CalcConfig<Inputs, Out>,
-): CalcClass<N, Inputs, Out> => {
-  const store = Context.GenericTag<Store<Out>, Store<Out>>(`reform/calc/${name}`)
-  const manifest: CalcManifest<N, Out> = { kind: 'Calc', name, output: config.output }
+  config: CalcConfig<Inputs, OutputSchema>,
+): CalcClass<N, Inputs, Schema.Schema.Type<OutputSchema>> => {
+  type Out = Schema.Schema.Type<OutputSchema>
+  const store = Context.GenericTag<CalcStore<N, Out>, Store<Out>>(`reform/calc/${name}`)
+  const manifest: CalcManifest<N> = { kind: 'Calc', name, output: config.output }
   const read = Effect.flatMap(store, readTracked)
-  return yieldableClass(read, { manifest, store, name, inputs: config.inputs })
+  const calc: CalcClass<N, Inputs, Out> = yieldableClass(read, {
+    manifest,
+    store,
+    name,
+    inputs: config.inputs,
+    capture: <Result>(visit: SourceCapture<Result>): Result => visit(calc),
+  })
+  return calc
 }
 
 export const live = <N extends string, Inputs extends ReadonlyArray<AnySource>, Out>(
   calc: CalcClass<N, Inputs, Out>,
   compute: (inputs: InputsObject<Inputs>) => Out,
   options: CalcOptionsExternalApi<Inputs> = {},
-): Layer.Layer<Store<Out>, never, InputStores<Inputs>> =>
+): Layer.Layer<CalcStore<N, Out>, never, InputStores<Inputs>> =>
   Layer.scoped(
     calc.store,
     Effect.gen(function* () {

package/src/calc/calcFamily.test.ts

@@ -64,19 +64,79 @@ it.live('a member only notifies when its own slice of the projection moves', ()
   }).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 } })),
+const reuseFixture = () => {
+  class Feed extends State.make('reuse-feed', Board) {}
+  class Revision extends State.make('reuse-revision', S.Number) {}
+  class Inputs extends StateGroup.make(Feed, Revision) {}
+  class Presentation extends CalcFamily.make('ReusePresentation', {
+    key: S.String,
+    inputs: [StateGroup.select(Inputs, 'reuse-feed'), StateGroup.select(Inputs, 'reuse-revision')],
+    output: S.Struct({ nested: S.Array(S.Struct({ value: S.Number })) }),
+  }) {}
+  const PresentationLive = CalcFamily.live(
+    Presentation,
+    (key) =>
+      ({ 'reuse-feed': feed }) => ({
+        nested: [{ value: feed[key] ?? 0 }],
+      }),
+    { reuse: true },
+  )
+  return { Inputs, Presentation, PresentationLive }
+}
+
+it.live('reuse preserves each member output when equal and replaces it when changed', () => {
+  const { Inputs, Presentation, PresentationLive } = reuseFixture()
+  const TestLayer = PresentationLive.pipe(
+    Layer.provideMerge(
+      StateGroup.live(Inputs, { 'reuse-feed': { a: 1, b: 1 }, 'reuse-revision': 0 }),
+    ),
   )
   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)
+    const feed = yield* StateGroup.select(Inputs, 'reuse-feed').store
+    const revision = yield* StateGroup.select(Inputs, 'reuse-revision').store
+    const family = yield* Presentation.store
+    const initialA = family.at('a').get()
+    const initialB = family.at('b').get()
+    const wakes = { a: 0, b: 0 }
+    family.at('a').subscribe(() => {
+      wakes.a += 1
+    })
+    family.at('b').subscribe(() => {
+      wakes.b += 1
+    })
+
+    expect(Object.is(initialA.nested, initialB.nested)).toBe(false)
+    revision.set(1)
+    yield* tick
+    expect(Object.is(family.at('a').get().nested, initialA.nested)).toBe(true)
+    expect(Object.is(family.at('b').get().nested, initialB.nested)).toBe(true)
+    expect(wakes).toEqual({ a: 0, b: 0 })
+
+    feed.set({ a: 2, b: 1 })
+    yield* tick
+    expect(family.at('a').get().nested).toEqual([{ value: 2 }])
+    expect(Object.is(family.at('a').get().nested, initialA.nested)).toBe(false)
+    expect(Object.is(family.at('b').get().nested, initialB.nested)).toBe(true)
+    expect(wakes).toEqual({ a: 1, b: 0 })
   }).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) {}
@@ -89,10 +149,11 @@ it.live('invalidateBy: shared-input churn outside the key recomputes no member',
   }) {}
   const SliceLive = CalcFamily.live(
     Slice,
-    (key) => ({ feed }) => {
-      runs.set(key, (runs.get(key) ?? 0) + 1)
-      return feed[key] ?? 0
-    },
+    (key) =>
+      ({ feed }) => {
+        runs.set(key, (runs.get(key) ?? 0) + 1)
+        return feed[key] ?? 0
+      },
     { invalidateBy: ({ feed }) => [feed] },
   )
   const TestLayer = SliceLive.pipe(
@@ -112,9 +173,7 @@ it.live('invalidateBy: shared-input churn outside the key recomputes no member',
 
 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 } })),
-  )
+  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
@@ -143,15 +202,14 @@ it.live('evictWhenUnused: an idle member is dropped on the next microtask and un
   }) {}
   const SliceLive = CalcFamily.live(
     Slice,
-    (key) => ({ feed }) => {
-      runs.set(key, (runs.get(key) ?? 0) + 1)
-      return feed[key] ?? 0
-    },
+    (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 } })),
-  )
+  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