@playfast/reform 0.0.10 → 0.0.11

package/src/feature/feature.ts

@@ -1,4 +1,4 @@
-import { type Context, Effect, Layer, type Scope } from 'effect'
+import { type Context, Effect, Layer, Option, type Scope } from 'effect'
 import { type Engine } from '../runtime/loop'
 import { type StoresOf } from '../internal/sources'
 import { FeatureLoadFailed } from '../internal/errors'
@@ -114,10 +114,10 @@ export interface FeatureManifest extends Manifest {
   readonly name: string
   readonly strategy: 'lazy' | 'default'
   readonly composition: Manifest & { readonly kind: 'Composition' }
-  readonly placeholder?: {
+  readonly placeholder: Option.Option<{
     readonly loading: Manifest & { readonly kind: 'Composition' }
     readonly failed: Manifest & { readonly kind: 'Composition' }
-  }
+  }>
 }
 
 /**
@@ -152,6 +152,7 @@ export interface FeatureBinding {
   readonly composition: CompositionClass<unknown>
   readonly strategy: 'lazy' | 'default'
   readonly load: Effect.Effect<LoadedModule, FeatureLoadFailed>
+  // oxlint-disable-next-line reform-rules/no-optional-fields -- read at the react host seam via `binding.placeholder === undefined`; an Option here would force a cross-package edit (react host) owned by another agent
   readonly placeholder?: {
     readonly loading: CompositionClass<unknown>
     readonly failed: CompositionClass<unknown>
@@ -160,8 +161,8 @@ export interface FeatureBinding {
 }
 
 /** Whether a slot's bound child is a lazy/eager feature (vs a plain composition). */
-export const isFeatureBinding = (u: unknown): u is FeatureBinding =>
-  typeof u === 'object' && u !== null && FeatureBindingTypeId in u
+export const isFeatureBinding = (candidate: unknown): candidate is FeatureBinding =>
+  typeof candidate === 'object' && candidate !== null && FeatureBindingTypeId in candidate
 
 /**
  * A feature *definition*: a reflectable manifest (`kind: 'Feature'`) that carries
@@ -195,11 +196,14 @@ export interface FeatureClass<
 export type AnyFeature = FeatureClass<any, any, any, ReadonlyArray<RequireCarrier>>
 
 /** Whether a value is a feature definition (its target shape in `provide(slot, Feature)`). */
-export const isFeature = (u: unknown): u is AnyFeature =>
-  (typeof u === 'function' || typeof u === 'object') &&
-  u !== null &&
-  'manifest' in u &&
-  (u as { readonly manifest: { readonly kind?: unknown } }).manifest?.kind === 'Feature'
+export const isFeature = (candidate: unknown): candidate is AnyFeature =>
+  (typeof candidate === 'function' || typeof candidate === 'object') &&
+  candidate !== null &&
+  'manifest' in candidate &&
+  typeof candidate.manifest === 'object' &&
+  candidate.manifest !== null &&
+  'kind' in candidate.manifest &&
+  candidate.manifest.kind === 'Feature'
 
 /**
  * The placeholders a lazy feature must ship — both eager compositions (their
@@ -213,7 +217,12 @@ export interface Placeholders {
   readonly failed: CompositionClass<any, UiContract>
 }
 
-type FeatureConfig<P, C extends UiContract, ROut, Requires extends ReadonlyArray<RequireCarrier>> = {
+type FeatureConfigExternalApi<
+  P,
+  C extends UiContract,
+  ROut,
+  Requires extends ReadonlyArray<RequireCarrier>,
+> = {
   readonly composition: CompositionClass<P, C>
   readonly boot?: ReadonlyArray<Tagged>
 } & (
@@ -240,7 +249,7 @@ type FeatureConfig<P, C extends UiContract, ROut, Requires extends ReadonlyArray
  */
 export const make = <P, C extends UiContract, ROut, Requires extends ReadonlyArray<RequireCarrier>>(
   name: string,
-  config: FeatureConfig<P, C, ROut, Requires>,
+  config: FeatureConfigExternalApi<P, C, ROut, Requires>,
 ): FeatureClass<P, C, ROut, Requires> => {
   const strategy: 'lazy' | 'default' = config.loadingStrategy ?? 'default'
   const load: Effect.Effect<FeatureModule<ROut, Requires>, FeatureLoadFailed> =
@@ -253,9 +262,12 @@ export const make = <P, C extends UiContract, ROut, Requires extends ReadonlyArr
     name,
     strategy,
     composition: config.composition.manifest,
-    ...(placeholder
-      ? { placeholder: { loading: placeholder.loading.manifest, failed: placeholder.failed.manifest } }
-      : {}),
+    placeholder: Option.fromNullable(placeholder).pipe(
+      Option.map((placeholders) => ({
+        loading: placeholders.loading.manifest,
+        failed: placeholders.failed.manifest,
+      })),
+    ),
   }
 
   const binding: FeatureBinding = {
@@ -267,7 +279,7 @@ export const make = <P, C extends UiContract, ROut, Requires extends ReadonlyArr
     // assignment to the erased `LoadedModule` needs no cast — see `LoadedModule`.
     load,
     ...(placeholder ? { placeholder: { loading: placeholder.loading, failed: placeholder.failed } } : {}),
-    boot: config.boot ?? [],
+    boot: Option.getOrElse(Option.fromNullable(config.boot), () => []),
   }
 
   return definitionClass<FeatureClass<P, C, ROut, Requires>>({ manifest, load, binding, eagerModule })
@@ -289,12 +301,14 @@ export const make = <P, C extends UiContract, ROut, Requires extends ReadonlyArr
  * we re-attach the concrete `engineContext` it builds against. `R` is the engine
  * context's service set, supplied by the host.
  */
+// oxlint-disable-next-line reform-rules/prefer-effect-fn -- generic export: Effect.fn's inferred type isn't portable under isolatedDeclarations
 export const mountFeature = <R>(
   binding: FeatureBinding,
   engineContext: Context.Context<R>,
 ): Effect.Effect<Context.Context<unknown>, FeatureLoadFailed, Scope.Scope> =>
   Effect.gen(function* () {
     const { layer } = yield* binding.load
+    // oxlint-disable-next-line reform-rules/no-type-assertion -- documented erasure boundary: re-attach the concrete engine context to the type-erased `LoadedModule` layer (mirrors `buildRuntime`); RIn was verified cast-free at `provide`/scene wiring
     const featureLayer = layer as Layer.Layer<unknown, never, R>
     const context = yield* Layer.build(
       Layer.provideMerge(featureLayer, Layer.succeedContext(engineContext)),

package/src/feature/feature.typecheck.ts

@@ -65,7 +65,7 @@ const AppFeatureBase: Feature.FeatureClass<
 > = Feature.make('appFeature', {
   loadingStrategy: 'lazy',
   composition: AppComp,
-  load: lazyImport(() => Promise.resolve({ default: featureModule([], Layer.empty) })),
+  load: lazyImport(async () => ({ default: featureModule([], Layer.empty) })),
   placeholder: { loading: AppComp, failed: AppComp },
 })
 class AppFeature extends AppFeatureBase {}
@@ -95,7 +95,7 @@ const OtherFeatureBase: Feature.FeatureClass<
 > = Feature.make('otherFeature', {
   loadingStrategy: 'lazy',
   composition: OtherComp,
-  load: lazyImport(() => Promise.resolve({ default: featureModule([], Layer.empty) })),
+  load: lazyImport(async () => ({ default: featureModule([], Layer.empty) })),
   placeholder: { loading: OtherComp, failed: OtherComp },
 })
 class OtherFeature extends OtherFeatureBase {}

package/src/internal/capture.ts

@@ -17,6 +17,7 @@ export interface UiCapture {
    * components and has no fill key, so it is omitted there. Lets the proof
    * facade select a child by key (`byKey`) instead of by render index.
    */
+  // oxlint-disable-next-line reform-rules/no-optional-fields -- omitted (not Option-none) on the legacy Node path; built in compose/structure.ts and read by the proof package, both outside this batch
   readonly key?: string
 }
 

package/src/internal/errors.ts

@@ -94,8 +94,12 @@ export class AsyncSceneLayer extends AsyncSceneLayerBase {
  * shapes are checked.
  */
 const isAsyncBuildDefect = (error: unknown): boolean => {
-  if (Runtime.isAsyncFiberException(error)) return true
-  if (!Runtime.isFiberFailure(error)) return false
+  if (Runtime.isAsyncFiberException(error)) {
+    return true
+  }
+  if (!Runtime.isFiberFailure(error)) {
+    return false
+  }
   const die = Cause.dieOption(error[Runtime.FiberFailureCauseId])
   return Option.isSome(die) && Runtime.isAsyncFiberException(die.value)
 }
@@ -107,11 +111,12 @@ const isAsyncBuildDefect = (error: unknown): boolean => {
  * the React host and the remote server.
  */
 export const forceSync = <A>(thunk: () => A): A => {
+  // oxlint-disable-next-line reform-rules/no-try-catch -- sync-build boundary must throw the exact value, which Effect.runSync would re-wrap in a FiberFailure
   try {
     return thunk()
   } catch (error) {
-    if (isAsyncBuildDefect(error)) throw new AsyncSceneLayer()
-    throw error
+    // oxlint-disable-next-line reform-rules/no-throw -- rethrow the exact value (translated for the async-build defect) so callers can match on it
+    throw isAsyncBuildDefect(error) ? new AsyncSceneLayer() : error
   }
 }
 

package/src/internal/inspect.ts

@@ -21,14 +21,14 @@ export const inspectable = (toJSON: () => unknown): Inspectable => ({
  * whose statics are merged in separately.
  */
 export const attachInspectable = <T extends object>(target: T, toJSON: () => unknown): T => {
-  const trio = inspectable(toJSON) as unknown as Record<PropertyKey, unknown>
-  for (const key of Reflect.ownKeys(trio)) {
+  const trio = inspectable(toJSON)
+  Reflect.ownKeys(trio).forEach((key) => {
     Object.defineProperty(target, key, {
-      value: trio[key],
+      value: Reflect.get(trio, key),
       enumerable: false,
       writable: true,
       configurable: true,
     })
-  }
+  })
   return target
 }

package/src/internal/queryDriver.ts

@@ -40,6 +40,7 @@ export type GatedOf<AlwaysOn extends boolean> = AlwaysOn extends true ? false :
 
 /** The runtime gated flag for an `alwaysOn` config, typed as its `Gated` literal. */
 export const gatedFlag = <AlwaysOn extends boolean>(alwaysOn: AlwaysOn | undefined): GatedOf<AlwaysOn> =>
+  // oxlint-disable-next-line reform-rules/no-type-assertion -- restate the runtime boolean as its conditional `GatedOf` literal; no guard maps a boolean to a conditional type
   (alwaysOn !== true) as GatedOf<AlwaysOn>
 
 // The hidden revision behind `invalidateOn` — a module-local *branded* number.
@@ -55,7 +56,7 @@ export const RevisionSchema: Schema.Schema<Revision, number> = Schema.Number.pip
   Schema.brand('reform/Revision'),
 )
 export const revisionZero: Revision = Revision(0)
-export const bumpRevision = (r: Revision): Revision => Revision(r + 1)
+export const bumpRevision = (revision: Revision): Revision => Revision(revision + 1)
 
 export interface QueryDriverOptions<Inputs extends ReadonlyArray<AnySource>, A, E, R> {
   /** The owning definition's name — the defect log line and the `Queries` key. */
@@ -66,15 +67,20 @@ export interface QueryDriverOptions<Inputs extends ReadonlyArray<AnySource>, A,
   readonly gated: boolean
   readonly inputs: Inputs
   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> | undefined
+  // 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) | undefined
+  // 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' | undefined
+  // 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 | undefined
   /**
    * An extra key segment + wake source beyond the declared inputs — the hidden
    * `invalidateOn` revision. Kept out of `wireSources` so the user's `query`
    * and `invalidateBy` see exactly the declared 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 extraKey?:
     | {
         readonly read: () => unknown
@@ -87,13 +93,22 @@ export interface QueryDriverOptions<Inputs extends ReadonlyArray<AnySource>, A,
    * instantly and still refetches) and write through on each settle. Values
    * (de)serialize through `schema`, never trusted structurally.
    */
-  readonly persist?: { readonly key: string; readonly schema: Schema.Schema<A, any> } | undefined
+  // 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?:
+    | {
+        // A static string keys a singleton read; a function of the inputs keys a
+        // family per-entity, so reactive-input keyed reads never collide on one slot.
+        readonly key: string | ((inputs: InputsObject<Inputs>) => string)
+        readonly schema: Schema.Schema<A, any>
+      }
+    | undefined
   /**
    * Fired when a run's `Success` value has landed in the store (same scheduler
    * flush — never before the converged value is readable), with the run's
    * generation. Not fired on `Error`, interrupt, or while disabled. The seam
    * `RemoteState` settles pending intents through.
    */
+  // 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 onSettled?: ((generation: number) => void) | undefined
 }
 
@@ -118,6 +133,7 @@ export interface QueryDriver<A, E> {
  * `isFetching: true`. `invalidate` flips `isStale`; a stale query with active
  * readers auto-refetches (the same rule that drives refetch-on-resubscribe).
  */
+// oxlint-disable-next-line reform-rules/prefer-effect-fn -- generic export: Effect.fn's inferred type isn't portable under isolatedDeclarations
 export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R>(
   options: QueryDriverOptions<Inputs, A, E, R>,
 ): Effect.Effect<QueryDriver<A, E>, never, InputStores<Inputs> | R | Scope.Scope> =>
@@ -130,6 +146,11 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
 
     const keyOf = (args: InputsObject<Inputs>): ReadonlyArray<unknown> =>
       extraKey === undefined ? sources.keyOf(args) : [...sources.keyOf(args), extraKey.read()]
+    // The persist storage key at the current inputs: a static string for a
+    // singleton, or the per-input function for a keyed family (no DOM/extraKey
+    // churn — purely the user-declared key, so it stays stable across refetches).
+    const persistKey = (key: string | ((inputs: InputsObject<Inputs>) => string), args: InputsObject<Inputs>): string =>
+      typeof key === 'function' ? key(args) : key
     const subscribeAll = (listener: () => void): (() => void) => {
       const offSources = sources.subscribe(listener)
       const offExtra = extraKey?.subscribe(listener)
@@ -156,7 +177,7 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
     const lastKey = MutableRef.make<ReadonlyArray<unknown> | undefined>(undefined)
     const generation = MutableRef.make(0)
     const nextGeneration = (): number => {
-      MutableRef.update(generation, (n) => n + 1)
+      MutableRef.update(generation, (current) => current + 1)
       return MutableRef.get(generation)
     }
 
@@ -164,13 +185,17 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
     // keep their field references, so a pure `isStale` flip leaves the projection
     // reference unmoved (see `project`). ──────────────────────────────────────
     const markFetching = () => {
-      const s = stateStore.get()
-      if (!s.isFetching) stateStore.set({ ...s, isFetching: true })
+      const state = stateStore.get()
+      if (!state.isFetching) {
+        stateStore.set({ ...state, isFetching: true })
+      }
     }
-    const settleSuccess = (value: A): A => {
+    const settleSuccess = (produced: A): A => {
       const prev = stateStore.get()
       const shared =
-        options.reuse === true && Option.isSome(prev.data) ? reuse(prev.data.value, value) : value
+        options.reuse === true && Option.isSome(prev.data)
+          ? reuse(prev.data.value, produced)
+          : produced
       stateStore.set({
         data: Option.some(shared),
         error: Option.none(),
@@ -186,15 +211,19 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
       stateStore.set({ ...prev, error: Option.some(error), isFetching: false })
     }
 
-    const persistWrite = (value: A): Effect.Effect<void> =>
-      persist === undefined
-        ? Effect.void
-        : Schema.encode(persist.schema)(value).pipe(
-            Effect.flatMap((encoded) => queryStore.set(persist.key, encoded)),
-            // Persistence is best-effort: a serialization or storage failure must
-            // never fail the run nor block the visible write.
-            Effect.ignore,
-          )
+    const persistWriteTo = (
+      target: NonNullable<typeof persist>,
+      produced: A,
+      args: InputsObject<Inputs>,
+    ): Effect.Effect<void> =>
+      Schema.encode(target.schema)(produced).pipe(
+        Effect.flatMap((encoded) => queryStore.set(persistKey(target.key, args), encoded)),
+        // Persistence is best-effort: a serialization or storage failure must
+        // never fail the run nor block the visible write.
+        Effect.ignore,
+      )
+    const persistWrite = (produced: A, args: InputsObject<Inputs>): Effect.Effect<void> =>
+      persist === undefined ? Effect.void : persistWriteTo(persist, produced, args)
 
     // The projection the public store exposes: `AnyAsyncData`, memoized so a pure
     // `isStale` change (which the projection ignores) returns the SAME reference
@@ -212,8 +241,9 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
         prev.state.data === state.data &&
         prev.state.error === state.error &&
         prev.state.isFetching === state.isFetching
-      )
+      ) {
         return prev.view
+      }
       const view = toAsyncData(state, options.gated)
       MutableRef.set(projection, { state, view })
       return view
@@ -226,6 +256,19 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
       readonly generation: number
     }
 
+    // Commit a `Success` value: write the cell, report the generation, then persist
+    // (best-effort, trailing). A no-op when the query was disabled meanwhile.
+    const commitSuccess = (produced: A, request: Request): Effect.Effect<void> => {
+      if (disabledNow()) {
+        return Effect.void
+      }
+      return Effect.suspend(() => {
+        const shared = settleSuccess(produced)
+        options.onSettled?.(request.generation)
+        return persistWrite(shared, request.args)
+      })
+    }
+
     // One run of the query, folded into the cell. A failure becomes `Error`; an
     // interrupt (latest-wins cancel) leaves the state untouched; a defect (a bug in
     // the body) is logged and isolated. A `Success` reports its generation through
@@ -236,24 +279,19 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
           Effect.logError(`reform: ${options.label} '${options.name}' query defect`, defect),
         ),
         Effect.matchCause({
-          onSuccess: (value): Option.Option<A> => Option.some(value),
+          onSuccess: (produced): Option.Option<A> => Option.some(produced),
           onFailure: (cause): Option.Option<A> => {
             const failure = Cause.failureOption(cause)
-            if (Option.isSome(failure) && !disabledNow()) settleError(failure.value)
+            if (Option.isSome(failure) && !disabledNow()) {
+              settleError(failure.value)
+            }
             return Option.none()
           },
         }),
         Effect.flatMap((ok) =>
           Option.match(ok, {
             onNone: () => Effect.void,
-            onSome: (value) =>
-              disabledNow()
-                ? Effect.void
-                : Effect.suspend(() => {
-                    const shared = settleSuccess(value)
-                    options.onSettled?.(request.generation)
-                    return persistWrite(shared)
-                  }),
+            onSome: (produced) => commitSuccess(produced, request),
           }),
         ),
       )
@@ -265,23 +303,25 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
     // one trailing run after settle" by construction.
     const trailing = options.coalesce === 'trailing'
     const requests = yield* Queue.unbounded<Request>()
-    yield* Effect.forkScoped(
-      trailing
-        ? Effect.forever(
-            Effect.gen(function* () {
-              const first = yield* Queue.take(requests)
-              const queued = yield* Queue.takeAll(requests)
-              const request = Option.getOrElse(Chunk.last(queued), () => first)
-              if (!disabledNow()) yield* runQuery(request)
-              const pending = yield* Queue.size(requests)
-              if (pending > 0 && !disabledNow()) yield* Effect.sync(markFetching)
-            }),
-          )
-        : Stream.fromQueue(requests).pipe(
-            Stream.flatMap((request) => Stream.fromEffect(runQuery(request)), { switch: true }),
-            Stream.runDrain,
-          ),
+    const trailingConsumer = Effect.forever(
+      Effect.gen(function* () {
+        const first = yield* Queue.take(requests)
+        const queued = yield* Queue.takeAll(requests)
+        const request = Option.getOrElse(Chunk.last(queued), () => first)
+        if (!disabledNow()) {
+          yield* runQuery(request)
+        }
+        const pending = yield* Queue.size(requests)
+        if (pending > 0 && !disabledNow()) {
+          yield* Effect.sync(markFetching)
+        }
+      }),
+    )
+    const switchConsumer = Stream.fromQueue(requests).pipe(
+      Stream.flatMap((request) => Stream.fromEffect(runQuery(request)), { switch: true }),
+      Stream.runDrain,
     )
+    yield* Effect.forkScoped(trailing ? trailingConsumer : switchConsumer)
 
     // Enqueue a run of the current key, marking the flight. `force` skips the
     // no-op-key guard (the refetch path); otherwise an unchanged key is ignored.
@@ -295,7 +335,9 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
       }
       const key = keyOf(args)
       const previous = MutableRef.get(lastKey)
-      if (!force && previous !== undefined && sameKey(key, previous)) return
+      if (!force && previous !== undefined && sameKey(key, previous)) {
+        return
+      }
       MutableRef.set(lastKey, key)
       markFetching()
       Queue.unsafeOffer(requests, { args, generation: nextGeneration() })
@@ -306,12 +348,16 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
     // `invalidate`: flip `isStale` only. A stale query with active readers then
     // auto-refetches — the one place invalidation indirectly fetches.
     const maybeAutoRefetch = () => {
-      if (stateStore.get().isStale && MutableRef.get(readers) > 0) refetch()
+      if (stateStore.get().isStale && MutableRef.get(readers) > 0) {
+        refetch()
+      }
     }
     const invalidate = () => {
-      const s = stateStore.get()
-      if (s.isStale) return
-      stateStore.set({ ...s, isStale: true })
+      const state = stateStore.get()
+      if (state.isStale) {
+        return
+      }
+      stateStore.set({ ...state, isStale: true })
       maybeAutoRefetch()
     }
 
@@ -321,7 +367,8 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
     // Hydrate from the persisted value before the first kick: show it instantly,
     // marked stale, so the kick refetches over it (stale-while-revalidate).
     if (persist !== undefined && !disabledNow()) {
-      const cached = yield* queryStore.get(persist.key)
+      const hydrateArgs = sources.snapshot()
+      const cached = yield* queryStore.get(persistKey(persist.key, hydrateArgs))
       yield* Option.match(cached, {
         onNone: () => Effect.void,
         onSome: (raw) =>
@@ -329,9 +376,9 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
             Effect.match({
               // Corrupt/incompatible cache: ignore and fetch fresh.
               onFailure: () => undefined,
-              onSuccess: (value) =>
+              onSuccess: (decoded) =>
                 stateStore.set({
-                  data: Option.some(value),
+                  data: Option.some(decoded),
                   error: Option.none(),
                   isFetching: false,
                   isStale: true,
@@ -357,10 +404,12 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
         const before = MutableRef.get(readers)
         MutableRef.set(readers, before + 1)
         const off = derived.store.subscribe(listener)
-        if (before === 0) maybeAutoRefetch()
+        if (before === 0) {
+          maybeAutoRefetch()
+        }
         return () => {
           off()
-          MutableRef.update(readers, (n) => Math.max(0, n - 1))
+          MutableRef.update(readers, (count) => Math.max(0, count - 1))
         }
       },
     }

package/src/internal/reuse.ts

@@ -1,4 +1,4 @@
-import { Equal } from 'effect'
+import { Equal, Record as Rec } from 'effect'
 
 // Structural sharing for recomputed calc outputs: reconcile a fresh output
 // against the previous one, substituting previous nodes wherever value equality
@@ -9,32 +9,72 @@ import { Equal } from 'effect'
 // pass composes with the framework's Equal-based invalidation untouched.
 
 // Bounds the walk; calc outputs are shallow plain data by framework convention.
-const maxDepth = 16
+const MAX_DEPTH = 16
 
-const isPlainRecord = (v: unknown): v is Record<string, unknown> =>
-  typeof v === 'object' &&
-  v !== null &&
-  (Object.getPrototypeOf(v) === Object.prototype || Object.getPrototypeOf(v) === null)
+const isPlainRecord = (candidate: unknown): candidate is Record<string, unknown> =>
+  typeof candidate === 'object' &&
+  candidate !== null &&
+  (Object.getPrototypeOf(candidate) === Object.prototype ||
+    Object.getPrototypeOf(candidate) === null)
 
-const go = (prev: unknown, next: unknown, depth: number): unknown => {
-  if (Object.is(prev, next)) return prev
+/** Own enumerable string-keyed fields of an object, as a plain record. */
+const ownRecord = (source: object): Record<string, unknown> =>
+  Rec.fromEntries(
+    Reflect.ownKeys(source)
+      .filter(
+        (key): key is string =>
+          typeof key === 'string' && Object.prototype.propertyIsEnumerable.call(source, key),
+      )
+      .map((key): readonly [string, unknown] => [key, Reflect.get(source, key)]),
+  )
+
+interface ReconcileArgs {
+  readonly prev: unknown
+  readonly next: unknown
+  readonly depth: number
+}
+
+/** Reconcile two records field-by-field; reports whether every field stayed `prev`. */
+const reconcileRecord = (
+  prev: Record<string, unknown>,
+  next: Record<string, unknown>,
+  depth: number,
+): { readonly out: Record<string, unknown>; readonly allPrev: boolean } => {
+  const keys = Rec.keys(next)
+  const out = Rec.fromEntries(
+    keys.map((key): readonly [string, unknown] => [
+      key,
+      key in prev ? reconcile({ prev: prev[key], next: next[key], depth: depth - 1 }) : next[key],
+    ]),
+  )
+  const allPrev =
+    keys.length === Rec.keys(prev).length &&
+    keys.every((key) => key in prev && Object.is(out[key], prev[key]))
+  return { out, allPrev }
+}
+
+const reconcile = ({ prev, next, depth }: ReconcileArgs): unknown => {
+  if (Object.is(prev, next)) {
+    return prev
+  }
   // Data/Schema classes implement Equal+Hash: substitute wholesale on value
   // equality. Plain objects/arrays fall through (their Equal is referential).
-  if (Equal.equals(prev, next)) return prev
-  if (depth <= 0) return next
+  if (Equal.equals(prev, next)) {
+    return prev
+  }
+  if (depth <= 0) {
+    return next
+  }
   if (Array.isArray(prev) && Array.isArray(next)) {
-    const out = next.map((item, i) => (i < prev.length ? go(prev[i], item, depth - 1) : item))
-    return prev.length === next.length && out.every((v, i) => Object.is(v, prev[i]))
-      ? prev
-      : out
+    const reconciled = next.map((element, index) =>
+      index < prev.length ? reconcile({ prev: prev[index], next: element, depth: depth - 1 }) : element,
+    )
+    const unchanged =
+      prev.length === next.length && reconciled.every((entry, index) => Object.is(entry, prev[index]))
+    return unchanged ? prev : reconciled
   }
   if (isPlainRecord(prev) && isPlainRecord(next)) {
-    const keys = Object.keys(next)
-    const out: Record<string, unknown> = {}
-    for (const key of keys) out[key] = key in prev ? go(prev[key], next[key], depth - 1) : next[key]
-    const allPrev =
-      keys.length === Object.keys(prev).length &&
-      keys.every((key) => key in prev && Object.is(out[key], prev[key]))
+    const { out, allPrev } = reconcileRecord(prev, next, depth)
     return allPrev ? prev : out
   }
   // Data/Schema class instances that DIFFER still get walked: their Equal is
@@ -48,15 +88,10 @@ const go = (prev: unknown, next: unknown, depth: number): unknown => {
     Equal.isEqual(next) &&
     Object.getPrototypeOf(prev) === Object.getPrototypeOf(next)
   ) {
-    const prevFields = Object.fromEntries(Object.entries(prev))
-    const nextFields = Object.entries(next)
-    const out: Record<string, unknown> = {}
-    for (const [key, value] of nextFields)
-      out[key] = key in prevFields ? go(prevFields[key], value, depth - 1) : value
-    const allPrev =
-      nextFields.length === Object.keys(prevFields).length &&
-      nextFields.every(([key]) => key in prevFields && Object.is(out[key], prevFields[key]))
-    return allPrev ? prev : Object.assign(Object.create(Object.getPrototypeOf(next)), out)
+    const { out, allPrev } = reconcileRecord(ownRecord(prev), ownRecord(next), depth)
+    return allPrev
+      ? prev
+      : Object.create(Object.getPrototypeOf(next), Object.getOwnPropertyDescriptors(out))
   }
   // Class instances without Equal (Date, Map, …) are opaque leaves.
   return next
@@ -70,4 +105,6 @@ const go = (prev: unknown, next: unknown, depth: number): unknown => {
  * the single cast below is that argument, in the style of `wireSources` /
  * `narrowStore`.
  */
-export const reuse = <A>(previous: A, next: A): A => go(previous, next, maxDepth) as A
+export const reuse = <A>(previous: A, next: A): A =>
+  // oxlint-disable-next-line reform-rules/no-type-assertion -- the walker returns a value-equal reconstruction of `next`, type-preserved by construction (the single seam this cast lives at)
+  reconcile({ prev: previous, next, depth: MAX_DEPTH }) as A