@playfast/reform 1.1.1 → 1.2.0

package/src/remote/remoteState.ts

@@ -1,57 +1,417 @@
 import {
   Context,
   Effect,
+  Either,
+  Equal,
+  Iterable,
   Layer,
   MutableRef,
   Option,
   Runtime,
   Schema,
 } from 'effect'
-import { type AsyncData, narrowStore, widenStore } from '../calc/asyncData'
+import type { Effect as EffectType } from 'effect/Effect'
+import {
+  type AnyAsyncData,
+  AsyncData,
+  type AsyncError,
+  type AsyncSuccess,
+  narrowStore,
+  widenStore,
+} from '../calc/asyncData'
 import * as Channel from '../channel/channel'
+import { type Manifest, yieldableClass } from '../definition/definition'
 import * as Event from '../event/event'
 import {
   bumpRevision,
+  type GatedOf,
+  gatedFlag,
   makeQueryDriver,
+  type QueryCodec,
   RevisionSchema,
   revisionZero,
 } from '../internal/queryDriver'
-import { resolveScheduler } from '../internal/scheduler'
-import { type InputStores } from '../internal/sources'
-import { makeStore, type Store } from '../internal/store'
+import { inspectable } from '../internal/inspect'
+import { reuse as shareStructure } from '../internal/reuse'
+import { resolveScheduler, type Scheduler } from '../internal/scheduler'
+import {
+  type InputsObject,
+  type InputStores,
+  type InvalidateBy,
+  sameKey,
+} from '../internal/sources'
+import { makeDerivedStore, type Store } from '../internal/store'
+import { readTracked } from '../internal/track'
 import * as Reducer from '../reducer/reducer'
-import { Bus, publish } from '../runtime/bus'
-import { Reducers } from '../runtime/loop'
+import { Bus, narrowHandled, publish } from '../runtime/bus'
+import { type ReducerEntry, Reducers } from '../runtime/loop'
 import * as State from '../state/state'
-import { type AnySource } from '../state/token'
-import {
-  looseSchema,
-  type PendingIntent,
-  type RemoteStateClass,
-  type RemoteStateSettled,
-} from './remoteStateDefinition'
-import type {
-  RemoteStateLiveExternalApi,
-  RemoteStateLiveRuntimeExternalApi,
-  SettleLink,
-} from './remoteStateLiveTypes'
-import { makeOverlayLayer, makeQueueReducerLayer } from './remoteStateLayers'
-import { makeSendProcedureLayer } from './remoteStateSend'
-
-// Generation rule: intent acked at gen g settles only on Success with gen > g (no flicker).
-// apply must be idempotent: between refetch landing and settle, intent is applied over truth that already has it.
-
-export {
-  type FailedIntent,
-  make,
-  type PendingIntent,
-  type RemoteStateClass,
-  type RemoteStateConfigExternalApi,
-  type RemoteStateManifestExternalApi,
-  type RemoteStateSettled,
-} from './remoteStateDefinition'
-
-export type { RemoteStateLiveExternalApi } from './remoteStateLiveTypes'
+import { type AnySource, type SourceCapture, StateToken } from '../state/token'
+
+// An intent acked at generation g settles only on Success with generation > g.
+// `apply` must be idempotent while refetched truth and the pending intent overlap.
+
+export interface PendingIntent<I> {
+  readonly opId: string
+  readonly intent: I
+  readonly status: 'sending' | 'confirmed'
+}
+
+export interface FailedIntent<I> {
+  readonly intent: I
+  readonly error: unknown
+}
+
+export type RemoteStateSettled<A, E> = AsyncSuccess<A> | AsyncError<E>
+
+export const RemoteStateVisibleStoreTypeId: unique symbol = Symbol.for(
+  'reform/RemoteStateVisibleStore',
+)
+export type RemoteStateVisibleStoreTypeId = typeof RemoteStateVisibleStoreTypeId
+
+export interface RemoteStateVisibleStore<N extends string> {
+  readonly [RemoteStateVisibleStoreTypeId]: N
+}
+
+export const RemoteStateTruthStoreTypeId: unique symbol = Symbol.for('reform/RemoteStateTruthStore')
+export type RemoteStateTruthStoreTypeId = typeof RemoteStateTruthStoreTypeId
+
+export interface RemoteStateTruthStore<N extends string> {
+  readonly [RemoteStateTruthStoreTypeId]: N
+}
+
+export const RemoteStatePendingStoreTypeId: unique symbol = Symbol.for(
+  'reform/RemoteStatePendingStore',
+)
+export type RemoteStatePendingStoreTypeId = typeof RemoteStatePendingStoreTypeId
+
+export interface RemoteStatePendingStore<N extends string> {
+  readonly [RemoteStatePendingStoreTypeId]: N
+}
+
+type EventPayload<Ev extends Event.AnyEvent> =
+  Ev extends Event.EventClass<string, infer P> ? P : never
+
+// ExternalApi: optional `intent` only on Queued envelopes.
+interface QueueFoldEventExternalApi<I> {
+  readonly _tag: string
+  readonly opId: string
+  readonly intent?: I
+}
+
+export interface RemoteStateSchemaReflection {
+  readonly ast: Schema.Schema<unknown, unknown, unknown>['ast']
+}
+
+export interface RemoteStateManifestExternalApi<N extends string> extends Manifest {
+  readonly kind: 'RemoteState'
+  readonly name: N
+  readonly output: RemoteStateSchemaReflection
+  readonly error?: RemoteStateSchemaReflection
+  readonly gated: boolean
+  readonly intents: ReadonlyArray<string>
+}
+
+export interface RemoteStateClass<
+  N extends string,
+  out Inputs extends ReadonlyArray<AnySource>,
+  in out Intents extends ReadonlyArray<Event.AnyEvent>,
+  in out A,
+  in out E,
+  in out Gated extends boolean,
+> extends EffectType<AsyncData<A, E, Gated>, never, RemoteStateVisibleStore<N>> {
+  new (): {}
+  readonly manifest: RemoteStateManifestExternalApi<N>
+  readonly codec: QueryCodec<A>
+  readonly store: Context.Tag<RemoteStateVisibleStore<N>, Store<AsyncData<A, E, Gated>>>
+  readonly name: N
+  readonly inputs: Inputs
+  readonly intents: Intents
+  readonly gated: Gated
+  readonly capture: <Result>(visit: SourceCapture<Result>) => Result
+  readonly truth: StateToken<`${N}/truth`, AsyncData<A, E, Gated>, RemoteStateTruthStore<N>>
+  // pending is a Source, not a StateClass, so user reducers cannot target it.
+  readonly pending: StateToken<
+    `${N}/pending`,
+    ReadonlyArray<PendingIntent<Event.EventType<Intents[number]>>>,
+    RemoteStatePendingStore<N>
+  >
+  readonly Failed: Event.EventClass<`${N}/Failed`, FailedIntent<Event.EventType<Intents[number]>>>
+}
+
+export interface RemoteStateConfigExternalApi<
+  Inputs extends ReadonlyArray<AnySource>,
+  Intents extends ReadonlyArray<Event.AnyEvent>,
+  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
+  readonly intents: Intents
+}
+
+// Schema.Unknown is structural because Intents is open at make-time; the declaration preserves its authored payload type.
+const looseSchema = <P>(schema: Schema.Schema.AnyNoContext): Schema.Schema<P, P, never> =>
+  Schema.declare((input): input is P => Schema.is(schema)(input))
+
+export const make = <
+  const N extends string,
+  const Inputs extends ReadonlyArray<AnySource>,
+  const Intents extends ReadonlyArray<Event.AnyEvent>,
+  OutputSchema extends Schema.Schema.AnyNoContext,
+  ErrorSchema extends Schema.Schema.AnyNoContext | undefined = undefined,
+  const AlwaysOn extends boolean = false,
+>(
+  name: N,
+  config: RemoteStateConfigExternalApi<Inputs, Intents, OutputSchema, ErrorSchema, AlwaysOn>,
+): RemoteStateClass<
+  N,
+  Inputs,
+  Intents,
+  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
+  type I = Event.EventType<Intents[number]>
+  const store = Context.GenericTag<
+    RemoteStateVisibleStore<N>,
+    Store<AsyncData<A, E, GatedOf<AlwaysOn>>>
+  >(`reform/remoteState/${name}`)
+  const truthTag = Context.GenericTag<
+    RemoteStateTruthStore<N>,
+    Store<AsyncData<A, E, GatedOf<AlwaysOn>>>
+  >(`reform/remoteState/${name}/truth`)
+  const pendingTag = Context.GenericTag<
+    RemoteStatePendingStore<N>,
+    Store<ReadonlyArray<PendingIntent<I>>>
+  >(`reform/remoteState/${name}/pending`)
+  const gated = gatedFlag(config.alwaysOn)
+  const manifest: RemoteStateManifestExternalApi<N> = {
+    kind: 'RemoteState',
+    name,
+    output: config.output,
+    gated,
+    intents: config.intents.map((event) => event.tag),
+    ...(config.error !== undefined ? { error: config.error } : {}),
+  }
+  const codec: QueryCodec<A> = {
+    encode: Schema.encode(config.output),
+    decode: Schema.decodeUnknown(config.output),
+  }
+  // Annotations preserve template-literal types for the public statics.
+  const truthName: `${N}/truth` = `${name}/truth`
+  const pendingName: `${N}/pending` = `${name}/pending`
+  const failedName: `${N}/Failed` = `${name}/Failed`
+  const read = Effect.flatMap(store, readTracked)
+  const remote: RemoteStateClass<N, Inputs, Intents, A, E, GatedOf<AlwaysOn>> = yieldableClass(
+    read,
+    {
+      manifest,
+      codec,
+      store,
+      name,
+      inputs: config.inputs,
+      intents: config.intents,
+      gated,
+      capture: <Result>(visit: SourceCapture<Result>): Result => visit(remote),
+      truth: new StateToken(truthName, truthTag),
+      pending: new StateToken(pendingName, pendingTag),
+      Failed: Event.make(
+        failedName,
+        looseSchema<FailedIntent<I>>(
+          Schema.Struct({ intent: Schema.Unknown, error: Schema.Unknown }),
+        ),
+      ),
+    },
+  )
+  return remote
+}
+
+export type RemoteStateLiveExternalApi<
+  Inputs extends ReadonlyArray<AnySource>,
+  Intents extends ReadonlyArray<Event.AnyEvent>,
+  A,
+  E,
+  Gated extends boolean,
+  R,
+  R2,
+  SettledEvent extends Event.AnyEvent,
+> = {
+  readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
+  // Any failure settles and emits Failed; truth comes only from the invalidated query.
+  readonly send: (intent: Event.EventType<Intents[number]>) => Effect.Effect<unknown, unknown, R2>
+  readonly apply: (value: A, intent: Event.EventType<Intents[number]>) => A
+  readonly channel?: Channel.ChannelClass
+  readonly invalidateBy?: InvalidateBy<Inputs>
+  readonly invalidateOn?: ReadonlyArray<Event.AnyEvent>
+  readonly coalesce?: 'switch' | 'trailing'
+  readonly reuse?: boolean
+  readonly settled?: {
+    readonly event: SettledEvent
+    readonly payload: (result: RemoteStateSettled<A, E>) => EventPayload<SettledEvent>
+  }
+  // Only settled server truth is persisted; the optimistic overlay is a separate store.
+  readonly persist?:
+    | boolean
+    | { readonly key?: string | ((inputs: InputsObject<Inputs>) => string) }
+} & (Gated extends true
+  ? { readonly disabled?: (inputs: InputsObject<Inputs>) => boolean }
+  : { readonly disabled?: never })
+
+interface SettleLink {
+  readonly requested: () => number
+  readonly register: (opId: string, waitFor: number) => void
+}
+
+interface WaiterRegistration {
+  readonly opId: string
+  readonly waitFor: number
+}
+
+interface PendingNode<I> {
+  readonly entry: MutableRef.MutableRef<PendingIntent<I>>
+}
+
+// Duplicate opIds retain every node so indexed updates preserve the old map semantics.
+interface PendingOpEntry<I> {
+  readonly nodes: Set<PendingNode<I>>
+}
+
+interface PendingQueue<I> {
+  readonly store: Store<ReadonlyArray<PendingIntent<I>>>
+  readonly revision: () => number
+  readonly fold: <B>(initial: B, combine: (accumulator: B, entry: PendingIntent<I>) => B) => B
+  readonly append: (entry: PendingIntent<I>) => void
+  readonly ack: (opId: string) => void
+  readonly settle: (opId: string) => void
+}
+
+const makePendingQueue = <I>(scheduler: Scheduler): PendingQueue<I> => {
+  // Set insertion order preserves dispatch/apply order while allowing O(1) updates.
+  const ordered = new Set<PendingNode<I>>()
+  const byOpId = new Map<string, PendingOpEntry<I>>()
+  const listeners = new Set<() => void>()
+  const revision = MutableRef.make(0)
+  const initial: ReadonlyArray<PendingIntent<I>> = []
+  const snapshot = MutableRef.make<Option.Option<ReadonlyArray<PendingIntent<I>>>>(
+    Option.some(initial),
+  )
+
+  const materialize = (): ReadonlyArray<PendingIntent<I>> => {
+    const cached = MutableRef.get(snapshot)
+    if (Option.isSome(cached)) {
+      return cached.value
+    }
+    const current = Array.from(ordered, (node) => MutableRef.get(node.entry))
+    MutableRef.set(snapshot, Option.some(current))
+    return current
+  }
+
+  const announce = (next: Option.Option<ReadonlyArray<PendingIntent<I>>>): void => {
+    MutableRef.set(snapshot, next)
+    MutableRef.update(revision, (current) => current + 1)
+    scheduler.schedule(listeners)
+  }
+
+  const link = (entry: PendingIntent<I>): void => {
+    const node: PendingNode<I> = {
+      entry: MutableRef.make(entry),
+    }
+    ordered.add(node)
+    const indexed = byOpId.get(entry.opId)
+    if (indexed === undefined) {
+      byOpId.set(entry.opId, { nodes: new Set([node]) })
+    } else {
+      indexed.nodes.add(node)
+    }
+  }
+
+  const clear = (): void => {
+    ordered.clear()
+    byOpId.clear()
+  }
+
+  const fold = <B>(initialValue: B, combine: (accumulator: B, entry: PendingIntent<I>) => B): B => {
+    const folded = MutableRef.make(initialValue)
+    ordered.forEach((node) => {
+      MutableRef.update(folded, (accumulator) => combine(accumulator, MutableRef.get(node.entry)))
+    })
+    return MutableRef.get(folded)
+  }
+
+  const append = (entry: PendingIntent<I>): void => {
+    link(entry)
+    announce(Option.none())
+  }
+
+  const ack = (opId: string): void => {
+    const indexed = byOpId.get(opId)
+    if (indexed === undefined) {
+      return
+    }
+    const stillSending = MutableRef.make(false)
+    indexed.nodes.forEach((node) => {
+      if (MutableRef.get(node.entry).status === 'sending') {
+        MutableRef.set(stillSending, true)
+      }
+    })
+    if (!MutableRef.get(stillSending)) {
+      return
+    }
+    // Rebuild every duplicate once one is sending, matching the former array map.
+    indexed.nodes.forEach((node) => {
+      MutableRef.update(node.entry, (entry) => ({ ...entry, status: 'confirmed' as const }))
+    })
+    announce(Option.none())
+  }
+
+  const settle = (opId: string): void => {
+    const indexed = byOpId.get(opId)
+    if (indexed === undefined) {
+      return
+    }
+    indexed.nodes.forEach((node) => {
+      ordered.delete(node)
+    })
+    byOpId.delete(opId)
+    announce(Option.none())
+  }
+
+  const store: Store<ReadonlyArray<PendingIntent<I>>> = {
+    get: materialize,
+    getSnapshot: materialize,
+    getVersion: () => MutableRef.get(revision),
+    set: (next) => {
+      if (Equal.equals(materialize(), next)) {
+        return
+      }
+      clear()
+      next.forEach(link)
+      announce(Option.some(next))
+    },
+    subscribe: (listener) => {
+      listeners.add(listener)
+      return () => {
+        listeners.delete(listener)
+      }
+    },
+    ...inspectable(() => ({ _id: 'reform/Store', value: materialize() })),
+  }
+
+  return {
+    store,
+    revision: () => MutableRef.get(revision),
+    fold,
+    append,
+    ack,
+    settle,
+  }
+}
 
 export const live = <
   N extends string,
@@ -67,21 +427,17 @@ export const live = <
   remote: RemoteStateClass<N, Inputs, Intents, A, E, Gated>,
   config: RemoteStateLiveExternalApi<Inputs, Intents, A, E, Gated, R, R2, SettledEvent>,
 ): Layer.Layer<
-  | Store<AsyncData<A, E, Gated>>
-  | Store<ReadonlyArray<PendingIntent<Event.EventType<Intents[number]>>>>,
+  RemoteStateVisibleStore<N> | RemoteStateTruthStore<N> | RemoteStatePendingStore<N>,
   never,
-  | InputStores<Inputs>
-  | R
-  | R2
-  | Reducers
-  | Channel.Procedures
-  | Channel.Channels
-  | Bus
+  InputStores<Inputs> | R | R2 | Reducers | Channel.Procedures | Channel.Channels | Bus
 > => {
   type I = Event.EventType<Intents[number]>
   const name = remote.manifest.name
   const truthTag = remote.truth.store
   const pendingTag = remote.pending.store
+  const pendingQueueTag = Context.GenericTag<PendingQueue<I>>(
+    `reform/remoteState/${name}/pendingQueue`,
+  )
 
   const Queued = Event.make(
     `${name}/Queued`,
@@ -107,53 +463,57 @@ export const live = <
 
   const driverLayer = Layer.scopedContext(
     Effect.gen(function* () {
-      // oxlint-disable-next-line reform-rules/no-type-assertion -- type-level erasure seam: `disabled` is `never` for non-gated definitions; read it back through the runtime view
-      const cfg = config as RemoteStateLiveRuntimeExternalApi<Inputs, A, E, R>
       const revision = Option.getOrUndefined(yield* Effect.serviceOption(revisionState.store))
       const runtime = yield* Effect.runtime<Bus>()
 
-      // Registry (not per-intent fibers): latest/exclusive cancel must not orphan waiters
-      const waiters = MutableRef.make<
-        ReadonlyArray<{ readonly opId: string; readonly waitFor: number }>
-      >([])
+      // Buckets, not cancellable fibers, keep waiters alive under latest/exclusive policies.
+      // Monotonic waitFor values make insertion order match generation order.
+      const waiters = new Map<number, Set<{ readonly opId: string }>>()
       const onSettled = (generation: number) => {
-        const due = MutableRef.get(waiters).filter((waiter) => waiter.waitFor <= generation)
-        if (due.length === 0) {
-          return
-        }
-        MutableRef.update(waiters, (all) => all.filter((waiter) => waiter.waitFor > generation))
-        // runSync: settle enqueued in same flush as converged value write
-        due.forEach((waiter) =>
-          Runtime.runSync(runtime)(
-            publish('Normal', Event.construct(Settled, { opId: waiter.opId })),
-          ),
+        Iterable.forEach(
+          Iterable.takeWhile(waiters, ([waitFor]) => waitFor <= generation),
+          ([waitFor, generationWaiters]) => {
+            waiters.delete(waitFor)
+            // runSync enqueues settles in the same flush as converged truth.
+            generationWaiters.forEach(({ opId }) =>
+              Runtime.runSync(runtime)(publish('Normal', Event.construct(Settled, { opId }))),
+            )
+          },
         )
       }
+      const registerWaiter = ({ opId, waitFor }: WaiterRegistration): void => {
+        const generationWaiters = waiters.get(waitFor)
+        if (generationWaiters === undefined) {
+          waiters.set(waitFor, new Set([{ opId }]))
+        } else {
+          generationWaiters.add({ opId })
+        }
+      }
 
-      // Persist only settled server truth (overlay is a separate store the driver never sees)
-      const persistOption = cfg.persist
+      const persistOption = config.persist
       const persistKey =
         persistOption === true || persistOption === undefined || persistOption === false
           ? name
-          : persistOption.key ?? name
+          : (persistOption.key ?? name)
       const persist =
         persistOption === undefined || persistOption === false
           ? undefined
-          : { key: persistKey, schema: remote.manifest.output }
-      const extraKey =
-        revision === undefined
-          ? undefined
-          : { read: () => revision.getSnapshot(), subscribe: (listener: () => void) => revision.subscribe(listener) }
+          : { key: persistKey, codec: remote.codec }
+      const revisionKey = (source: NonNullable<typeof revision>) => ({
+        read: () => source.getSnapshot(),
+        subscribe: (listener: () => void) => source.subscribe(listener),
+      })
+      const extraKey = revision === undefined ? undefined : revisionKey(revision)
       const driver = yield* makeQueryDriver({
         name,
         label: 'RemoteState',
         gated: remote.gated,
         inputs: remote.inputs,
-        query: cfg.query,
-        invalidateBy: cfg.invalidateBy,
-        disabled: cfg.disabled,
-        coalesce: cfg.coalesce,
-        reuse: cfg.reuse,
+        query: config.query,
+        invalidateBy: config.invalidateBy,
+        disabled: config.disabled,
+        coalesce: config.coalesce,
+        reuse: config.reuse,
         persist,
         extraKey,
         onSettled,
@@ -173,7 +533,7 @@ export const live = <
             Runtime.runSync(runtime)(
               publish(
                 'Normal',
-                Event.construct(settledConfig.event, settledConfig.payload(settledTruth)),
+                settledConfig.event.buildUnknown(settledConfig.payload(settledTruth)),
               ),
             )
           }
@@ -185,8 +545,7 @@ export const live = <
       }
       const link: SettleLink = {
         requested: driver.requested,
-        register: (opId, waitFor) =>
-          MutableRef.update(waiters, (all) => [...all, { opId, waitFor }]),
+        register: (opId, waitFor) => registerWaiter({ opId, waitFor }),
       }
       return Context.make(truthTag, narrowStore<A, E, Gated>(driver.store)).pipe(
         Context.add(linkTag, link),
@@ -194,42 +553,148 @@ export const live = <
     }),
   )
 
-  const overlayLayer = makeOverlayLayer<I, A, E, Gated>({
-    apply: config.apply,
-    pendingTag,
-    reuse: config.reuse,
-    storeTag: remote.store,
-    truthTag,
-  })
+  const overlayLayer = Layer.scoped(
+    remote.store,
+    Effect.gen(function* () {
+      const scheduler = yield* resolveScheduler
+      const feedStore = widenStore<A, E, Gated>(yield* truthTag)
+      const queue = yield* pendingQueueTag
+      const memo = MutableRef.make<
+        { readonly key: ReadonlyArray<unknown>; readonly output: AnyAsyncData<A, E> } | undefined
+      >(undefined)
+      const recompute = (): AnyAsyncData<A, E> => {
+        const feed = feedStore.getSnapshot()
+        const key = [feed, queue.revision()]
+        const prev = MutableRef.get(memo)
+        if (prev !== undefined && sameKey(key, prev.key)) {
+          return prev.output
+        }
+        // Full replay preserves observable value identity when apply allocates and reuse is off.
+        const applyPending = (base: A): A =>
+          queue.fold(base, (applied, entry) => config.apply(applied, entry.intent))
+        const overlaid: AnyAsyncData<A, E> =
+          feed._tag === 'Success'
+            ? AsyncData.success(applyPending(feed.value), feed.refetching)
+            : feed
+        const reusable =
+          config.reuse === true &&
+          prev !== undefined &&
+          prev.output._tag === 'Success' &&
+          overlaid._tag === 'Success'
+            ? shareStructure(prev.output.value, overlaid.value)
+            : undefined
+        const output: AnyAsyncData<A, E> =
+          reusable === undefined || overlaid._tag !== 'Success'
+            ? overlaid
+            : AsyncData.success(reusable, overlaid.refetching)
+        MutableRef.set(memo, { key, output })
+        return output
+      }
+      const subscribe = (listener: () => void): (() => void) => {
+        const offFeed = feedStore.subscribe(listener)
+        const offQueue = queue.store.subscribe(listener)
+        return () => {
+          offFeed()
+          offQueue()
+        }
+      }
+      const derived = makeDerivedStore(recompute, subscribe, scheduler)
+      yield* Effect.addFinalizer(() => Effect.sync(derived.unsubscribe))
+      return narrowStore<A, E, Gated>(derived.store)
+    }),
+  )
 
-  const queueReducerLayer = makeQueueReducerLayer<I>({
-    ackedTag: Acked.tag,
-    name: `${name}/pending`,
-    pendingTag,
-    queuedTag: Queued.tag,
-    settledTag: Settled.tag,
-  })
+  // Direct registry assembly avoids deferred conditional parameters while Intents is generic.
+  const queueReducerName = `${name}/pending`
+  const queueHandles: ReadonlySet<string> = new Set([Queued.tag, Acked.tag, Settled.tag])
+  const queueReducerLayer = Layer.scopedDiscard(
+    Effect.gen(function* () {
+      const reducers = yield* Reducers
+      if (reducers.entries.some((entry) => entry.name === queueReducerName)) {
+        yield* Effect.logWarning(`reform: duplicate reducer name '${queueReducerName}' registered`)
+      }
+      const queue = yield* pendingQueueTag
+      const entry: ReducerEntry = {
+        name: queueReducerName,
+        handles: queueHandles,
+        apply: (event) => {
+          const handled = narrowHandled<QueueFoldEventExternalApi<I>>(event)
+          if (handled._tag === Queued.tag) {
+            if (handled.intent !== undefined) {
+              queue.append({
+                opId: handled.opId,
+                intent: handled.intent,
+                status: 'sending',
+              })
+            }
+            return
+          }
+          if (handled._tag === Acked.tag) {
+            queue.ack(handled.opId)
+            return
+          }
+          queue.settle(handled.opId)
+        },
+      }
+      yield* Effect.acquireRelease(
+        Effect.sync(() => reducers.register(entry)),
+        () => Effect.sync(() => reducers.unregister(entry)),
+      )
+    }),
+  )
   const channel = config.channel ?? Channel.make(`${name}/sends`, { policy: { _tag: 'merge' } })
   const procedureName = `${name}/send`
   const sendHandles: ReadonlySet<string> = new Set(remote.intents.map((event) => event.tag))
-  const sendProcedureLayer = makeSendProcedureLayer<I, R2>({
-    acked: Acked,
-    channel,
-    failed: remote.Failed,
-    handles: sendHandles,
-    invalidated: Invalidated,
-    linkTag,
-    name: procedureName,
-    queued: Queued,
-    send: config.send,
-    settled: Settled,
-  })
+  const sendProcedureLayer = Layer.scopedDiscard(
+    Effect.gen(function* () {
+      const procedures = yield* Channel.Procedures
+      if (procedures.entries.some((entry) => entry.name === procedureName)) {
+        yield* Effect.logWarning(`reform: duplicate procedure name '${procedureName}' registered`)
+      }
+      const link = yield* linkTag
+      const runtime = yield* Effect.runtime<Bus | R2>()
+      const deliver = Effect.fn('deliver')(function* (
+        intent: I,
+      ): Effect.fn.Return<void, never, Bus | R2> {
+        const opId = yield* Effect.sync(() => crypto.randomUUID())
+        yield* Event.dispatch(Queued, { opId, intent })
+        const outcome = yield* config.send(intent).pipe(
+          Effect.catchAllDefect((defect) => Effect.fail(defect)),
+          Effect.either,
+          Effect.onInterrupt(() => Event.dispatch(Settled, { opId })),
+        )
+        yield* Either.match(outcome, {
+          onLeft: (error) =>
+            Effect.zipRight(
+              Event.dispatch(remote.Failed, { intent, error }),
+              Event.dispatch(Settled, { opId }),
+            ),
+          onRight: () =>
+            // Register before invalidation so a pre-ack refetch cannot settle this intent.
+            Effect.sync(() => link.register(opId, link.requested() + 1)).pipe(
+              Effect.zipRight(Event.dispatch(Acked, { opId })),
+              Effect.zipRight(Event.dispatch(Invalidated, {})),
+            ),
+        })
+      })
+      const entry: Channel.ProcedureEntry = {
+        name: procedureName,
+        channelName: channel.manifest.name,
+        handles: sendHandles,
+        run: (event) => Effect.provide(deliver(narrowHandled<I>(event)), runtime),
+      }
+      yield* Effect.acquireRelease(
+        Effect.sync(() => procedures.register(entry)),
+        () => Effect.sync(() => procedures.unregister(entry)),
+      )
+    }),
+  )
 
-  const pendingStoreLayer = Layer.effect(
-    pendingTag,
-    Effect.map(resolveScheduler, (scheduler) =>
-      makeStore<ReadonlyArray<PendingIntent<I>>>([], scheduler),
-    ),
+  const pendingStoreLayer = Layer.scopedContext(
+    Effect.map(resolveScheduler, (scheduler) => {
+      const queue = makePendingQueue<I>(scheduler)
+      return Context.make(pendingTag, queue.store).pipe(Context.add(pendingQueueTag, queue))
+    }),
   )
   return Layer.mergeAll(
     overlayLayer,