@playfast/reform 0.0.5 → 0.0.7

package/src/calc/asyncCalc.ts

@@ -1,267 +0,0 @@
-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/calc.ts

@@ -1,120 +0,0 @@
-import { Context, Effect, Layer, MutableRef, type Schema } from 'effect'
-import { type Manifest, yieldableClass } from '../definition/definition'
-import {
-  type InputsObject,
-  type InputStores,
-  type InvalidateBy,
-  sameKey,
-  wireSources,
-} from '../internal/sources'
-import { resolveScheduler } from '../internal/scheduler'
-import { reuse } from '../internal/reuse'
-import { makeDerivedStore, type Store } from '../internal/store'
-import { readTracked } from '../internal/track'
-import { type AnySource } from '../state/token'
-
-// Re-exported so `Calc.InputsObject` / `Calc.InvalidateBy` keep their home here
-// even though the reactive plumbing now lives in `internal/sources`.
-export { type InputsObject, type InputStores, type InvalidateBy } from '../internal/sources'
-
-export interface CalcOptions<Inputs extends ReadonlyArray<AnySource>> {
-  /**
-   * Custom invalidation: recompute only when the projected key changes by value
-   * equality (React-Query's `queryKey`). Omitted ⇒ recompute when any input
-   * value changes. Shared with `AsyncCalc`.
-   */
-  readonly invalidateBy?: InvalidateBy<Inputs>
-  /**
-   * Structural sharing: reconcile each recomputed output against the previous
-   * one, substituting previous nodes wherever value equality holds — so
-   * identities only move where values moved and downstream memo boundaries
-   * (React subtrees) skip unchanged regions. Referentially transparent (the
-   * result is value-equal to the fresh output); costs one O(output) walk per
-   * recompute, so opt in for large projections.
-   */
-  readonly reuse?: boolean
-}
-
-export interface CalcManifest<N extends string, Out> extends Manifest {
-  readonly kind: 'Calc'
-  readonly name: N
-  readonly output: Schema.Schema<Out, any>
-}
-
-export interface CalcClass<out N extends string, out Inputs extends ReadonlyArray<AnySource>, in out Out>
-  extends Effect.Effect<Out, never, Store<Out>> {
-  new (): {}
-  readonly manifest: CalcManifest<N, Out>
-  readonly store: Context.Tag<Store<Out>, Store<Out>>
-  /** The calc's name, so it doubles as a `Source` input to another calc. */
-  readonly name: N
-  /** Marker data read by `Calc.live`. */
-  readonly inputs: Inputs
-}
-
-export interface CalcConfig<Inputs extends ReadonlyArray<AnySource>, Out> {
-  readonly inputs: Inputs
-  readonly output: Schema.Schema<Out, any>
-}
-
-/**
- * A derived, memoized value over explicit inputs (state members, other calcs, or
- * async calcs). The *definition* fixes the inputs and the output schema; the
- * *implementation* is the pure projection. Recomputes only when an input changes;
- * `yield* Calc` reads the memoized value.
- */
-export const make = <const N extends string, const Inputs extends ReadonlyArray<AnySource>, Out>(
-  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 }
-  const read = Effect.flatMap(store, readTracked)
-  return yieldableClass(read, { manifest, store, name, inputs: config.inputs })
-}
-
-/**
- * Wire the pure projection for a calc. Recomputes only when its invalidation key
- * changes (by default every input value; override with `invalidateBy`), memoized
- * on that key; `yield* Calc` reads the memoized value. The derived store reuses
- * the shared coalescing scheduler, so a recompute that yields an equal value
- * wakes no subscriber.
- */
-export const live = <N extends string, Inputs extends ReadonlyArray<AnySource>, Out>(
-  calc: CalcClass<N, Inputs, Out>,
-  compute: (inputs: InputsObject<Inputs>) => Out,
-  options: CalcOptions<Inputs> = {},
-): Layer.Layer<Store<Out>, never, InputStores<Inputs>> =>
-  // Scoped so the source subscriptions are released when the layer's scope
-  // closes (each proof/test builds and disposes its own runtime).
-  Layer.scoped(
-    calc.store,
-    Effect.gen(function* () {
-      const scheduler = yield* resolveScheduler
-      const sources = yield* wireSources(calc.inputs, options.invalidateBy)
-
-      // Memo cell: key and output captured together so reads are always
-      // consistent (no separate output that could lag the key it was computed for).
-      const memo = MutableRef.make<
-        { readonly key: ReadonlyArray<unknown>; readonly output: Out } | undefined
-      >(undefined)
-      const recompute = (): Out => {
-        const args = sources.snapshot()
-        const key = sources.keyOf(args)
-        const prev = MutableRef.get(memo)
-        if (prev !== undefined && sameKey(key, prev.key)) return prev.output
-        const fresh = compute(args)
-        // With `reuse`, a recompute that lands value-equal to the previous
-        // output returns the previous reference — the derived store's Equal
-        // gate then wakes no subscriber at all.
-        const output =
-          options.reuse === true && prev !== undefined ? reuse(prev.output, fresh) : fresh
-        MutableRef.set(memo, { key, output })
-        return output
-      }
-
-      const derived = makeDerivedStore(recompute, sources.subscribe, scheduler)
-      yield* Effect.addFinalizer(() => Effect.sync(derived.unsubscribe))
-      return derived.store
-    }),
-  )

package/src/calc/calcFamily.ts

@@ -1,194 +0,0 @@
-import { Context, Effect, Layer, MutableRef, type Schema } from 'effect'
-import { type Manifest, definitionClass } from '../definition/definition'
-import {
-  type InputsObject,
-  type InputStores,
-  type InvalidateBy,
-  sameKey,
-  wireSources,
-} from '../internal/sources'
-import { resolveScheduler } from '../internal/scheduler'
-import { makeDerivedStore, type Store } from '../internal/store'
-import { readTracked } from '../internal/track'
-import { type FamilyOptions, type FamilyStore } from '../state/stateFamily'
-import { type AnySource } from '../state/token'
-
-// `CalcFamily` is `Calc`'s keyed sibling, modeled on `StateFamily`: one derived,
-// memoized store per key over a SHARED set of inputs. Where a monolithic calc
-// rebuilds its whole output on any change (waking every consumer), a family
-// member recomputes lazily and notifies only when ITS slice of the projection
-// moves (the derived store's Equal gate) — per-row/per-group UI subscribes per
-// key and unrelated changes never wake it. Members are pure projections; a
-// Reducer cannot target a CalcFamily (its config requires a `StateFamily`
-// manifest), so calc purity holds structurally.
-
-export interface CalcFamilyManifest<N extends string, K, Out> extends Manifest {
-  readonly kind: 'CalcFamily'
-  readonly name: N
-  readonly key: Schema.Schema<K, any>
-  readonly output: Schema.Schema<Out, any>
-}
-
-export interface CalcFamilyClass<
-  out N extends string,
-  out Inputs extends ReadonlyArray<AnySource>,
-  in out K,
-  in out Out,
-> {
-  /** Instance carries the key phantom so `Family['Key']` resolves in key types. */
-  new (): { readonly Key: K }
-  readonly manifest: CalcFamilyManifest<N, K, Out>
-  readonly store: Context.Tag<FamilyStore<K, Out>, FamilyStore<K, Out>>
-  /** Marker data read by `CalcFamily.live` and the editor's graph builder. */
-  readonly inputs: Inputs
-}
-
-export interface CalcFamilyConfig<Inputs extends ReadonlyArray<AnySource>, K, Out> {
-  readonly key: Schema.Schema<K, any>
-  readonly inputs: Inputs
-  readonly output: Schema.Schema<Out, any>
-}
-
-/**
- * Define a keyed derived value: per-key memoized projections over shared
- * inputs. The *definition* fixes the key/output schemas and the inputs; the
- * *implementation* (the per-key projection) is supplied by `CalcFamily.live`.
- */
-export const make = <const N extends string, const Inputs extends ReadonlyArray<AnySource>, K, Out>(
-  name: N,
-  config: CalcFamilyConfig<Inputs, K, Out>,
-): CalcFamilyClass<N, Inputs, K, Out> => {
-  const store = Context.GenericTag<FamilyStore<K, Out>, FamilyStore<K, Out>>(
-    `reform/calcFamily/${name}`,
-  )
-  const manifest: CalcFamilyManifest<N, K, Out> = {
-    kind: 'CalcFamily',
-    name,
-    key: config.key,
-    output: config.output,
-  }
-  return definitionClass<CalcFamilyClass<N, Inputs, K, Out>>({
-    manifest,
-    store,
-    inputs: config.inputs,
-  })
-}
-
-/**
- * Read one member by key — `CalcFamily.read(GroupProjection, id)`. Inside a
- * render it subscribes exactly that member's store (unrelated members never
- * wake the subtree); elsewhere it just snapshots — the same one-read-API
- * contract as `StateFamily.read`.
- */
-export const read = <N extends string, Inputs extends ReadonlyArray<AnySource>, K, Out>(
-  family: CalcFamilyClass<N, Inputs, K, Out>,
-  key: K,
-): Effect.Effect<Out, never, FamilyStore<K, Out>> =>
-  Effect.flatMap(family.store, (fs) => readTracked(fs.at(key)))
-
-export interface CalcFamilyLiveOptions<Inputs extends ReadonlyArray<AnySource>>
-  extends FamilyOptions {
-  /**
-   * Family-wide invalidation key over the SHARED inputs (the member key plays
-   * no part — it is fixed per member). Same contract as `Calc`'s.
-   */
-  readonly invalidateBy?: InvalidateBy<Inputs>
-}
-
-/**
- * Wire the per-key projection. `compute` is curried — `(key) => (inputs) =>
- * Out` — so per-key construction (closing over key-derived constants) runs once
- * per member while the inner projection runs per recompute. Each member is a
- * lazy derived store over the shared wired sources: memoized on the family's
- * invalidation key, notifying only when its own output moves. Unlike a
- * `StateFamily` entry, a member holds an upstream subscription, so every
- * removal path (forget / clear / eviction / the layer finalizer) releases it.
- */
-export const live = <N extends string, Inputs extends ReadonlyArray<AnySource>, K, Out>(
-  family: CalcFamilyClass<N, Inputs, K, Out>,
-  compute: (key: K) => (inputs: InputsObject<Inputs>) => Out,
-  options: CalcFamilyLiveOptions<Inputs> = {},
-): Layer.Layer<FamilyStore<K, Out>, never, InputStores<Inputs>> =>
-  Layer.scoped(
-    family.store,
-    Effect.gen(function* () {
-      const scheduler = yield* resolveScheduler
-      // Wired ONCE for the whole family — members share the sensing surface.
-      const sources = yield* wireSources(family.inputs, options.invalidateBy)
-      const entries = new Map<K, { readonly store: Store<Out>; readonly unsubscribe: () => void }>()
-      const evictWhenUnused = options.evictWhenUnused === true
-      // Live subscriber count per key — maintained only when eviction is on.
-      const subscribers = new Map<K, number>()
-
-      const dropEntry = (key: K): void => {
-        const entry = entries.get(key)
-        if (entry !== undefined) entry.unsubscribe()
-        entries.delete(key)
-        subscribers.delete(key)
-      }
-
-      // One member: the same memo block as `Calc.live`, with the key closed over.
-      const createMember = (key: K): { readonly store: Store<Out>; readonly unsubscribe: () => void } => {
-        const body = compute(key)
-        const memo = MutableRef.make<
-          { readonly key: ReadonlyArray<unknown>; readonly output: Out } | undefined
-        >(undefined)
-        const recompute = (): Out => {
-          const args = sources.snapshot()
-          const memoKey = sources.keyOf(args)
-          const prev = MutableRef.get(memo)
-          if (prev !== undefined && sameKey(memoKey, prev.key)) return prev.output
-          const output = body(args)
-          MutableRef.set(memo, { key: memoKey, output })
-          return output
-        }
-        return makeDerivedStore(recompute, sources.subscribe, scheduler)
-      }
-
-      // The `StateFamily` ref-count idiom: evict on the next microtask once a
-      // key falls idle (a same-commit re-subscribe cancels it) — here eviction
-      // also releases the member's upstream subscription via `dropEntry`.
-      const refCounted = (key: K, store: Store<Out>): Store<Out> => ({
-        ...store,
-        subscribe: (listener) => {
-          subscribers.set(key, (subscribers.get(key) ?? 0) + 1)
-          const off = store.subscribe(listener)
-          const released = { done: false }
-          return () => {
-            if (released.done) return
-            released.done = true
-            off()
-            const remaining = (subscribers.get(key) ?? 1) - 1
-            if (remaining > 0) {
-              subscribers.set(key, remaining)
-              return
-            }
-            subscribers.delete(key)
-            queueMicrotask(() => {
-              if ((subscribers.get(key) ?? 0) === 0) dropEntry(key)
-            })
-          }
-        },
-      })
-
-      const familyStore: FamilyStore<K, Out> = {
-        at: (key) => {
-          const existing = entries.get(key)
-          if (existing !== undefined) return existing.store
-          const member = createMember(key)
-          const created = evictWhenUnused
-            ? { store: refCounted(key, member.store), unsubscribe: member.unsubscribe }
-            : member
-          entries.set(key, created)
-          return created.store
-        },
-        forget: dropEntry,
-        clear: () => {
-          for (const key of [...entries.keys()]) dropEntry(key)
-        },
-        size: () => entries.size,
-      }
-      yield* Effect.addFinalizer(() => Effect.sync(() => familyStore.clear()))
-      return familyStore
-    }),
-  )

package/src/calc/compose.ts

@@ -1,69 +0,0 @@
-import { Layer } from 'effect'
-
-// Wiring a calc-on-calc chain (`FilteredAgents` ← `AllAgents` ← `AgentsQuery`)
-// is the one calc-graph shape that trips people up: each upstream calc's store
-// must be *provided into* the downstream live, in dependency order. A flat
-// `Layer.mergeAll(FilteredLive, AllLive, QueryLive)` does NOT do this — `mergeAll`
-// merges outputs but never provides members to one another, so the upstream
-// calc stores stay as unmet `Store<…>` requirements (the TS2322 the migration
-// hit). The correct shape is `leaf.pipe(provideMerge(u1), provideMerge(u2), …)`;
-// `composeCalcs` is that fold under one name so the right thing is the easy thing.
-
-/**
- * Compose a calc-dependency chain: provide each upstream calc's `.live` layer
- * into the downstream one, nearest dependency first. The result exposes every
- * calc store in the chain and requires only the chain's *external* inputs (the
- * base state stores) — never the intermediate calc stores.
- *
- * Order is leaf-first, then its upstreams in dependency order:
- * `composeCalcs(FilteredLive, AllLive, QueryLive)` ≡
- * `FilteredLive.pipe(Layer.provideMerge(AllLive), Layer.provideMerge(QueryLive))`.
- * For chains deeper than three upstreams, nest `composeCalcs`.
- */
-export function composeCalcs<LOut, LErr, LIn, AOut, AErr, AIn>(
-  leaf: Layer.Layer<LOut, LErr, LIn>,
-  upstream: Layer.Layer<AOut, AErr, AIn>,
-): Layer.Layer<LOut | AOut, LErr | AErr, AIn | Exclude<LIn, AOut>>
-export function composeCalcs<LOut, LErr, LIn, AOut, AErr, AIn, BOut, BErr, BIn>(
-  leaf: Layer.Layer<LOut, LErr, LIn>,
-  upstream1: Layer.Layer<AOut, AErr, AIn>,
-  upstream2: Layer.Layer<BOut, BErr, BIn>,
-): Layer.Layer<
-  LOut | AOut | BOut,
-  LErr | AErr | BErr,
-  BIn | Exclude<AIn | Exclude<LIn, AOut>, BOut>
->
-export function composeCalcs<
-  LOut,
-  LErr,
-  LIn,
-  AOut,
-  AErr,
-  AIn,
-  BOut,
-  BErr,
-  BIn,
-  COut,
-  CErr,
-  CIn,
->(
-  leaf: Layer.Layer<LOut, LErr, LIn>,
-  upstream1: Layer.Layer<AOut, AErr, AIn>,
-  upstream2: Layer.Layer<BOut, BErr, BIn>,
-  upstream3: Layer.Layer<COut, CErr, CIn>,
-): Layer.Layer<
-  LOut | AOut | BOut | COut,
-  LErr | AErr | BErr | CErr,
-  CIn | Exclude<BIn | Exclude<AIn | Exclude<LIn, AOut>, BOut>, COut>
->
-export function composeCalcs(
-  leaf: Layer.Layer<unknown, unknown, unknown>,
-  ...upstream: ReadonlyArray<Layer.Layer<unknown, unknown, unknown>>
-): Layer.Layer<unknown, unknown, unknown> {
-  // Fold leaf-first: each upstream is provided into the accumulated downstream,
-  // so dependency order is exactly the argument order.
-  return upstream.reduce<Layer.Layer<unknown, unknown, unknown>>(
-    (downstream, up) => Layer.provideMerge(downstream, up),
-    leaf,
-  )
-}