@playfast/reform 0.0.4 → 0.0.7

package/src/event/event.ts

@@ -1,65 +0,0 @@
-import { Effect, PubSub, Runtime, type Schema } from 'effect'
-import { type Manifest, definitionClass } from '../definition/definition'
-import { Bus, publish, type Tagged } from '../runtime/bus'
-import type { Trigger } from '../ui/trigger'
-
-/** The dispatched value of an event: `{ _tag, ...payload }`, matched with `Match.tags`. */
-export type EventOf<N extends string, P> = Tagged & { readonly _tag: N } & P
-
-export interface EventManifest<N extends string, P> extends Manifest {
-  readonly kind: 'Event'
-  readonly name: N
-  readonly schema: Schema.Schema<P, any>
-}
-
-export interface EventClass<out N extends string, in out P> {
-  new (): {}
-  readonly manifest: EventManifest<N, P>
-  readonly tag: N
-  /** Carrier for `Event.construct` — builds the tagged value `{ _tag, ...payload }`. */
-  readonly build: (payload: P) => EventOf<N, P>
-  /** Carrier for `Event.trigger` — the UI callback effect (High priority). */
-  readonly trigger: Effect.Effect<Trigger<P>, never, Bus>
-}
-
-export type AnyEvent = EventClass<string, any>
-export type EventType<E> = E extends EventClass<infer N, infer P> ? EventOf<N, P> : never
-
-/** A pure data fact. Events depend on nothing — only reducers tie them to state. */
-export const make = <const N extends string, P>(
-  name: N,
-  schema: Schema.Schema<P, any>,
-): EventClass<N, P> => {
-  const build = (payload: P): EventOf<N, P> => ({ _tag: name, ...payload })
-  const trigger = Effect.gen(function* () {
-    const bus = yield* Bus
-    const runtime = yield* Effect.runtime<never>()
-    // Dispatch synchronously: on the unbounded bus `publish` only enqueues and
-    // returns, so `runSync` never suspends and no fiber is forked per UI event.
-    // The drain loop still folds reducers on its own fiber — publish is pure offer.
-    return (payload: P) => {
-      Runtime.runSync(runtime)(PubSub.publish(bus, { priority: 'High', event: build(payload) }))
-    }
-  })
-  return definitionClass<EventClass<N, P>>({
-    manifest: { kind: 'Event' as const, name, schema },
-    tag: name,
-    build,
-    trigger,
-  })
-}
-
-/** Construct the tagged value for an event (used for `boot` events). */
-export const construct = <N extends string, P>(event: EventClass<N, P>, payload: P): EventOf<N, P> =>
-  event.build(payload)
-
-/** Dispatch as a follow-up (Normal priority) from a procedure/effect. */
-export const dispatch = <N extends string, P>(
-  event: EventClass<N, P>,
-  payload: P,
-): Effect.Effect<void, never, Bus> => publish('Normal', event.build(payload))
-
-/** A callback for the UI that dispatches at High priority via the runtime. */
-export const trigger = <N extends string, P>(
-  event: EventClass<N, P>,
-): Effect.Effect<Trigger<P>, never, Bus> => event.trigger

package/src/event/eventGroup.ts

@@ -1,14 +0,0 @@
-import { definitionClass } from '../definition/definition'
-import type { AnyEvent } from './event'
-
-export interface EventGroupClass<Members extends ReadonlyArray<AnyEvent>> {
-  new (): {}
-  readonly kind: 'EventGroup'
-  readonly members: Members
-}
-
-/** Compose events into a group, the same variadic shape as `StateGroup`/`RpcGroup`. */
-export const make = <const Members extends ReadonlyArray<AnyEvent>>(
-  ...members: Members
-): EventGroupClass<Members> =>
-  definitionClass<EventGroupClass<Members>>({ kind: 'EventGroup' as const, members })

package/src/index.ts

@@ -1,140 +0,0 @@
-// Reform core — the renderer-neutral primitives and runtime.
-// Definitions (`X.make`) are separate from implementations (`.live`)
-// throughout, and nothing self-registers on import (principle #1, #6).
-
-export * as State from './state/state'
-export * as StateGroup from './state/stateGroup'
-export * as StateFamily from './state/stateFamily'
-export { StateToken } from './state/token'
-export type { AnySource, Source } from './state/token'
-
-export * as Event from './event/event'
-// Direct type re-export alongside the namespace (TS2742 nameability): inferred
-// types of layers built over intent/event unions reference `EventOf`, and the
-// declaration emitter can only name it through a plain export.
-export type { EventOf } from './event/event'
-export * as EventGroup from './event/eventGroup'
-
-export * as Reducer from './reducer/reducer'
-export * as Calc from './calc/calc'
-export * as CalcFamily from './calc/calcFamily'
-export * as AsyncCalc from './calc/asyncCalc'
-export { composeCalcs } from './calc/compose'
-// The inputs-object/key/store types appearing in `AsyncCalc.live` /
-// `RemoteState.live` signatures, exported so app code can annotate
-// query-swapping helpers and layer types without re-spelling them.
-export type { InputsObject, InputStores, InvalidateBy } from './internal/sources'
-export {
-  type AsyncData,
-  type AsyncError,
-  type AsyncIdle,
-  type AsyncLoading,
-  type AsyncSuccess,
-} from './calc/asyncData'
-export * as RemoteState from './remote/remoteState'
-// Direct type re-exports alongside the namespace (TS2742 nameability): an app
-// layer's inferred type references these (`Store<ReadonlyArray<PendingIntent<…>>>`),
-// and the declaration emitter can only name them through a plain export.
-export type { FailedIntent, PendingIntent, RemoteStateClass } from './remote/remoteState'
-export * as Boundary from './boundary/boundary'
-// Direct type re-exports alongside the namespace (same TS2742 nameability
-// reason as the RemoteState types above): app code annotates props with these.
-export type {
-  BoundaryErrored,
-  BoundaryPending,
-  BoundaryReady,
-  BoundaryState,
-} from './boundary/boundary'
-export * as Procedure from './procedure/procedure'
-export * as Channel from './channel/channel'
-
-export * as Composition from './compose/composition'
-export type {
-  CompositionClass,
-  CompositionService,
-  RenderEnv,
-} from './compose/composition'
-export { Props } from './compose/props'
-export {
-  isSlot,
-  type Node,
-  slot,
-  type SlotClass,
-  type SlotInstance,
-  type SlotProps,
-  SlotTypeId,
-} from './compose/slot'
-export { CurrentSlots, type SlotHost } from './compose/host'
-export * as Ui from './compose/ui'
-export {
-  isUi,
-  type LogicView,
-  ui,
-  type UiClass,
-  type UiContract,
-  UiTypeId,
-  type ViewImpl,
-} from './compose/ui'
-export { provide } from './compose/provide'
-export type { Trigger } from './ui/trigger'
-
-// Feature: the lazy/eager code-split unit. Definitions stay eager and reflectable;
-// the heavy `.live` layer loads on demand (an Effect, never a Promise). See LAZY.md.
-export * as Feature from './feature/feature'
-export {
-  type EngineServices,
-  type FailedProps,
-  type FeatureBinding,
-  FeatureBindingTypeId,
-  type FeatureClass,
-  type FeatureManifest,
-  featureModule,
-  type FeatureModule,
-  isFeature,
-  isFeatureBinding,
-  lazyImport,
-  type LoadedModule,
-  mountFeature,
-  type Placeholders,
-  type ProvidedBy,
-  type RequireCarrier,
-} from './feature/feature'
-export { type SlotChild } from './compose/slot'
-
-// A scene bundles a composition with the closed wiring that runs it — the single
-// handle the react host, proofs, and the dev tool all consume.
-export { isScene, type MountedServices, type Scene, scene, seedScene } from './scene/scene'
-
-// Runtime surface for hosts (`@reform/react`) and headless tests.
-export { Bus, type Envelope, type Priority, publish, type Tagged } from './runtime/bus'
-export { Engine, type ReducerEntry, Reducers } from './runtime/loop'
-export {
-  type ChannelClass,
-  type ChannelPolicy,
-  type ChannelRuntime,
-  Channels,
-  type ProcedureEntry,
-  Procedures,
-} from './channel/channel'
-export { CurrentTracker, type Subscribable, type Tracker } from './internal/track'
-export { CaptureSink, type CaptureSinkApi, type UiCapture } from './internal/capture'
-export {
-  AsyncReducer,
-  DuplicateRegistration,
-  FeatureLoadFailed,
-  InvalidProvideTarget,
-  SlotRenderingUnavailable,
-  UnknownGroupState,
-} from './internal/errors'
-// Notification scheduler: hosts that need per-runtime isolation (concurrent SSR,
-// multiple mounted roots) provide `Notifications` upstream of their state layers;
-// everything else coalesces on the process-wide default.
-export {
-  defaultScheduler,
-  makeScheduler,
-  Notifications,
-  notificationsLayer,
-  type Scheduler,
-} from './internal/scheduler'
-export type { Store } from './internal/store'
-export type { FamilyStore } from './state/stateFamily'

package/src/internal/errors.ts

@@ -1,69 +0,0 @@
-import { Data } from 'effect'
-
-/**
- * Tagged errors for the framework's synchronous boundaries. Even when thrown
- * (React render, layer build, reflection), an error carries a `_tag` and its
- * structured fields — never a bare `Error` — so callers and tooling can match on
- * it. `Data.TaggedError` subclasses are real `Error`s, so `throw` still works.
- */
-
-/** A `<slots.X/>` was rendered without a render-target host to realize it. */
-export class SlotRenderingUnavailable extends Data.TaggedError('reform/SlotRenderingUnavailable')<{
-  readonly slot: string
-}> {
-  override get message(): string {
-    return `reform: rendering slot '${this.slot}' requires @reform/react`
-  }
-}
-
-/** `provide(target, …)` was handed something that is neither a ui contract nor a slot. */
-export class InvalidProvideTarget extends Data.TaggedError('reform/InvalidProvideTarget')<{}> {
-  override get message(): string {
-    return 'reform: provide target is neither a ui contract nor a slot'
-  }
-}
-
-/** `StateGroup.select(group, name)` named a state the group does not contain. */
-export class UnknownGroupState extends Data.TaggedError('reform/UnknownGroupState')<{
-  readonly name: string
-}> {
-  override get message(): string {
-    return `reform: unknown state '${this.name}' in group`
-  }
-}
-
-/**
- * A lazy `Feature`'s `load` Effect failed — the dynamic `import()` rejected (a
- * missing chunk, a network failure, a module-eval throw). Surfaced as a typed
- * failure the host hands to the feature's `placeholder.failed`, never a bare
- * rejection. `cause` is the original rejection value.
- */
-export class FeatureLoadFailed extends Data.TaggedError('reform/FeatureLoadFailed')<{
-  readonly cause: unknown
-}> {
-  override get message(): string {
-    return `reform: a feature failed to load (${String(this.cause)})`
-  }
-}
-
-/** A reducer fold returned a thenable — folds must be pure synchronous writes. */
-export class AsyncReducer extends Data.TaggedError('reform/AsyncReducer')<{}> {
-  override get message(): string {
-    return 'reform: a reducer fold must be synchronous (it returned a Promise)'
-  }
-}
-
-/**
- * Two distinct primitives were registered under one name into the same runtime —
- * a silent footgun, since names key DI tags and channel lanes. Thrown for a
- * channel name reused with a different policy (the second would otherwise be
- * dropped). Reducer/procedure name clashes are warned (logged), not thrown.
- */
-export class DuplicateRegistration extends Data.TaggedError('reform/DuplicateRegistration')<{
-  readonly kind: string
-  readonly name: string
-}> {
-  override get message(): string {
-    return `reform: duplicate ${this.kind} registered under name '${this.name}'`
-  }
-}

package/src/internal/inspect.ts

@@ -1,34 +0,0 @@
-import { format, type Inspectable, NodeInspectSymbol } from 'effect/Inspectable'
-
-export { type Inspectable, NodeInspectSymbol }
-
-/**
- * The `Inspectable` trio built around a `toJSON`, so every reform value prints
- * like an Effect value — `_id`-tagged JSON under `console.log`, Node's
- * inspector, `JSON.stringify`, and `String(...)` — instead of `[object Object]`.
- * Mirrors Effect's `BaseProto` / `Inspectable.Class` (`Inspectable.ts:170`).
- */
-export const inspectable = (toJSON: () => unknown): Inspectable => ({
-  toJSON,
-  toString: () => format(toJSON()),
-  [NodeInspectSymbol]: () => toJSON(),
-})
-
-/**
- * Attach the `Inspectable` trio to an existing object as *non-enumerable* own
- * properties (so they don't show up in `Object.keys`/`for…in` over a definition
- * class). Used where the value is built by other means — the definition classes,
- * 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)) {
-    Object.defineProperty(target, key, {
-      value: trio[key],
-      enumerable: false,
-      writable: true,
-      configurable: true,
-    })
-  }
-  return target
-}

package/src/internal/queryDriver.ts

@@ -1,247 +0,0 @@
-import {
-  Brand,
-  Cause,
-  Chunk,
-  Effect,
-  MutableRef,
-  Option,
-  Queue,
-  Schema,
-  type Scope,
-  Stream,
-} from 'effect'
-import { type AnyAsyncData, AsyncData } from '../calc/asyncData'
-import { reuse } from './reuse'
-import { resolveScheduler } from './scheduler'
-import {
-  type InputsObject,
-  type InputStores,
-  type InvalidateBy,
-  sameKey,
-  wireSources,
-} from './sources'
-import { makeStore, type Store } from './store'
-import { type AnySource } from '../state/token'
-
-// The query-lifecycle driver shared by `AsyncCalc.live` and `RemoteState.live`:
-// sense the inputs, run the query latest-wins (or trailing-conflated), fold the
-// result into an `AnyAsyncData` store with stale-while-revalidate semantics.
-// Extracted so both primitives run the exact same machinery — the asyncCalc
-// test suite is the driver's regression suite.
-
-/** `Gated` (whether the `Idle` arm exists) is the inverse of `alwaysOn`. */
-export type GatedOf<AlwaysOn extends boolean> = AlwaysOn extends true ? false : true
-
-/** The runtime gated flag for an `alwaysOn` config, typed as its `Gated` literal. */
-export const gatedFlag = <AlwaysOn extends boolean>(alwaysOn: AlwaysOn | undefined): GatedOf<AlwaysOn> =>
-  (alwaysOn !== true) as GatedOf<AlwaysOn>
-
-// The hidden revision behind `invalidateOn` — a module-local *branded* number.
-// Reform store services are type-identified (`Context.GenericTag<Store<A>>`), so
-// the hidden state's value type must be un-collidable: `Layer.provide` erases
-// exactly `Store<Revision>` from the returned layer and can never type-level
-// erase a user input that happens to be a number state. Never exported from the
-// package index, so the editor catalog (which only indexes module exports)
-// never sees it.
-export type Revision = number & Brand.Brand<'reform/Revision'>
-export const Revision = Brand.nominal<Revision>()
-export const RevisionSchema: Schema.Schema<Revision, number> = Schema.Number.pipe(
-  Schema.brand('reform/Revision'),
-)
-export const revisionZero: Revision = Revision(0)
-export const bumpRevision = (r: Revision): Revision => Revision(r + 1)
-
-export interface QueryDriverOptions<Inputs extends ReadonlyArray<AnySource>, A, E, R> {
-  /** The owning definition's name — only for the defect log line. */
-  readonly name: string
-  /** The owning primitive's kind label — only for the defect log line. */
-  readonly label: string
-  /** Whether `disabled` is honored / the `Idle` arm can occur. */
-  readonly gated: boolean
-  readonly inputs: Inputs
-  readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
-  readonly invalidateBy?: InvalidateBy<Inputs> | undefined
-  readonly disabled?: ((inputs: InputsObject<Inputs>) => boolean) | undefined
-  readonly coalesce?: 'switch' | 'trailing' | undefined
-  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.
-   */
-  readonly extraKey?:
-    | {
-        readonly read: () => unknown
-        readonly subscribe: (listener: () => void) => () => void
-      }
-    | 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.
-   */
-  readonly onSettled?: ((generation: number) => void) | undefined
-}
-
-export interface QueryDriver<A, E> {
-  /** The lifecycle store (the full union — callers narrow to their arms). */
-  readonly store: Store<AnyAsyncData<A, E>>
-  /**
-   * The highest generation requested so far (0 before the first kick).
-   * Generations are assigned when a run is REQUESTED (enqueued), so a waiter
-   * registered as `requested() + 1` is satisfied only by a run that began
-   * after registration — the settle-ordering rule `RemoteState` builds on.
-   */
-  readonly requested: () => number
-}
-
-/**
- * Build the driver: store + subscription + request queue + run fiber, all owned
- * by the ambient scope (callers run this under `Layer.scoped`). A change to an
- * input re-runs the query 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`.
- */
-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> =>
-  Effect.gen(function* () {
-    const scheduler = yield* resolveScheduler
-    const sources = yield* wireSources(options.inputs, options.invalidateBy)
-    const extraKey = options.extraKey
-
-    const keyOf = (args: InputsObject<Inputs>): ReadonlyArray<unknown> =>
-      extraKey === undefined ? sources.keyOf(args) : [...sources.keyOf(args), extraKey.read()]
-    const subscribeAll = (listener: () => void): (() => void) => {
-      const offSources = sources.subscribe(listener)
-      const offExtra = extraKey?.subscribe(listener)
-      return () => {
-        offSources()
-        offExtra?.()
-      }
-    }
-    const disabledNow = (args: InputsObject<Inputs> = sources.snapshot()): boolean =>
-      options.gated && options.disabled !== undefined ? options.disabled(args) : false
-
-    const store = makeStore<AnyAsyncData<A, E>>(
-      disabledNow() ? AsyncData.idle : AsyncData.loading,
-      scheduler,
-    )
-    // The last requested key, so a change that doesn't move it (or only churns
-    // an input `invalidateBy` ignores) doesn't re-fetch.
-    const lastKey = MutableRef.make<ReadonlyArray<unknown> | undefined>(undefined)
-    // The run-generation counter: bumped when a run is REQUESTED (enqueued), so
-    // `requested()` names the newest run that could possibly be in flight.
-    const generation = MutableRef.make(0)
-    const nextGeneration = (): number => {
-      MutableRef.update(generation, (n) => n + 1)
-      return MutableRef.get(generation)
-    }
-
-    // Mark a re-fetch in flight without dropping the visible value (SWR).
-    const markRefetching = () => {
-      const prev = store.get()
-      if (prev._tag === 'Success') store.set(AsyncData.success(prev.value, true))
-      else if (prev._tag === 'Error') store.set(AsyncData.error(prev.error, true))
-      else store.set(AsyncData.loading)
-    }
-
-    // One run of the query, folded into the store. A failure becomes `Error`; an
-    // interrupt (latest-wins cancel) leaves the state untouched; a defect (a bug
-    // in the body) is logged and isolated — the driver keeps running. A `Success`
-    // additionally reports its generation through `onSettled`, after the write,
-    // so settle-driven consequences observe the converged value.
-    const runQuery = (request: Request): Effect.Effect<void, never, R> =>
-      options.query(request.args).pipe(
-        Effect.tapDefect((defect) =>
-          Effect.logError(`reform: ${options.label} '${options.name}' query defect`, defect),
-        ),
-        Effect.matchCause({
-          onSuccess: (value) => {
-            if (!disabledNow()) {
-              // `reuse`: share unchanged subtrees with the previous Success
-              // value, so a refetch that barely moved keeps identities stable.
-              const prev = store.get()
-              const shared =
-                options.reuse === true && prev._tag === 'Success'
-                  ? reuse(prev.value, value)
-                  : value
-              store.set(AsyncData.success(shared, false))
-              options.onSettled?.(request.generation)
-            }
-          },
-          onFailure: (cause) => {
-            const failure = Cause.failureOption(cause)
-            if (Option.isSome(failure) && !disabledNow()) {
-              store.set(AsyncData.error(failure.value, false))
-            }
-          },
-        }),
-      )
-
-    interface Request {
-      readonly args: InputsObject<Inputs>
-      readonly generation: number
-    }
-
-    // The driver. `'switch'` (default): each new request cancels the in-flight
-    // run — the same latest-wins semantics a `latest` channel gives procedures.
-    // `'trailing'`: a strictly sequential consumer that, on wake, drains every
-    // request that piled up during the flight and runs the LATEST one —
-    // "exactly one trailing run after settle" by construction. The trailing
-    // run's generation is the max drained (the latest request's), so it
-    // vouches for every request it conflated.
-    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)
-              // A disable that landed while the request waited: skip the run.
-              if (!disabledNow()) yield* runQuery(request)
-              // The settle may have written a stale-key result with
-              // `refetching: false`; if a newer request is already waiting,
-              // restore the syncing flag before the next take — both writes
-              // coalesce into one scheduler flush for subscribers.
-              const pending = yield* Queue.size(requests)
-              if (pending > 0 && !disabledNow()) yield* Effect.sync(markRefetching)
-            }),
-          )
-        : Stream.fromQueue(requests).pipe(
-            Stream.flatMap((request) => Stream.fromEffect(runQuery(request)), { switch: true }),
-            Stream.runDrain,
-          ),
-    )
-
-    const trigger = () => {
-      const args = sources.snapshot()
-      if (disabledNow(args)) {
-        // Switched off: show Idle and forget the key so re-enabling always re-runs.
-        MutableRef.set(lastKey, undefined)
-        store.set(AsyncData.idle)
-        return
-      }
-      const key = keyOf(args)
-      const previous = MutableRef.get(lastKey)
-      if (previous !== undefined && sameKey(key, previous)) return
-      MutableRef.set(lastKey, key)
-      markRefetching()
-      Queue.unsafeOffer(requests, { args, generation: nextGeneration() })
-    }
-    const unsubscribe = subscribeAll(trigger)
-    yield* Effect.addFinalizer(() => Effect.sync(unsubscribe))
-
-    // Kick off the first fetch unless the query starts disabled.
-    const initial = sources.snapshot()
-    if (!disabledNow(initial)) {
-      MutableRef.set(lastKey, keyOf(initial))
-      Queue.unsafeOffer(requests, { args: initial, generation: nextGeneration() })
-    }
-
-    return { store, requested: () => MutableRef.get(generation) }
-  })

package/src/internal/reuse.ts

@@ -1,73 +0,0 @@
-import { Equal } from 'effect'
-
-// Structural sharing for recomputed calc outputs: reconcile a fresh output
-// against the previous one, substituting previous nodes wherever value equality
-// holds, so identities only move where values moved. Downstream memo boundaries
-// (React subtrees keyed on object identity) then skip everything that didn't
-// change. Referentially transparent: the result is value-equal to `next` — only
-// identities shift toward `previous` — and neither argument is mutated, so the
-// 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 isPlainRecord = (v: unknown): v is Record<string, unknown> =>
-  typeof v === 'object' &&
-  v !== null &&
-  (Object.getPrototypeOf(v) === Object.prototype || Object.getPrototypeOf(v) === null)
-
-const go = (prev: unknown, next: unknown, depth: number): 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 (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
-  }
-  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]))
-    return allPrev ? prev : out
-  }
-  // Data/Schema class instances that DIFFER still get walked: their Equal is
-  // fieldwise over own enumerable fields, so a reconstruction over reconciled
-  // fields (same prototype; the constructor is bypassed, but every leaf is a
-  // validated value out of `prev` or `next`) stays value-equal to `next` while
-  // unchanged children — e.g. one untouched element inside a class-typed
-  // container — keep their `prev` identity.
-  if (
-    Equal.isEqual(prev) &&
-    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)
-  }
-  // Class instances without Equal (Date, Map, …) are opaque leaves.
-  return next
-}
-
-/**
- * Substitute `previous` nodes into `next` wherever they are value-equal. The
- * walker only ever returns `previous`, `next`, or a key/index-wise
- * reconstruction of `next` whose every leaf came from one of them, so the
- * result is value-equal to `next` and the type is preserved by construction —
- * 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