@playfast/reform 1.2.0 → 1.2.1

package/src/remote/remoteState.test.ts

@@ -13,17 +13,7 @@ import {
 import { Channels, Procedures } from '../channel/channel'
 import { QueryStore } from '../internal/queryStore'
 import { Reducers } from '../runtime/loop'
-
-const tick = (ms = 10) => Effect.sleep(Duration.millis(ms))
-
-// Bounded poll — fixed tick budgets flake under parallel-suite host load
-const until = <A>(read: () => A, pred: (a: A) => boolean, rounds = 200): Effect.Effect<A> =>
-  Effect.suspend(() => {
-    const a = read()
-    return pred(a) || rounds <= 0
-      ? Effect.succeed(a)
-      : Effect.flatMap(tick(10), () => until(read, pred, rounds - 1))
-  })
+import { makeFlightGate, tick, until } from '../testkit/flight.testkit'
 
 const Item = S.Struct({ id: S.String, name: S.String })
 type Item = typeof Item.Type
@@ -284,9 +274,10 @@ it.live(
       intents: [Added, Renamed],
       alwaysOn: true,
     }) {}
+    const gate = makeFlightGate()
     const ItemsLive = RemoteState.live(Items, {
-      query: () => server.fetch(60),
-      send: (intent) => server.receive(intent, 15),
+      query: () => gate.through(server.fetch(0)),
+      send: (intent) => server.receive(intent, 0),
       apply: applyIntent,
       invalidateOn: [Poke],
       // Trailing lets pre-ack run land — stale Success must not settle
@@ -312,22 +303,25 @@ it.live(
         if (v._tag === 'Success') frames.push(v.value.length)
       })
 
+      // The gen-2 fetch is pinned open, so the intent dispatched after it can only be
+      // settled by a later run — the stale snapshot is structurally denied the chance.
+      yield* gate.hold
       yield* Event.dispatch(Poke, {})
-      yield* tick(5)
+      yield* gate.awaitEntry(2)
+      expect(server.state.fetches).toBe(2)
       yield* Event.dispatch(Added, { id: 'b', name: 'beta' })
 
-      // Gen-2 Success settles nobody (generation rule)
       yield* until(
-        () => server.state.fetches,
-        (n) => n === 2,
+        () => queue.get(),
+        (q) => q[0]?.status === 'confirmed',
       )
-      yield* tick(25)
       expect(queue.get()).toHaveLength(1)
       expect(queue.get()[0]).toMatchObject({ status: 'confirmed' })
       const midflight = store.get()
       expect(midflight).toMatchObject({ _tag: 'Success' })
       if (midflight._tag === 'Success') expect(midflight.value).toHaveLength(2)
 
+      yield* gate.release
       yield* until(
         () => queue.get(),
         (q) => q.length === 0,
@@ -617,7 +611,6 @@ it.live('gated: intents queue and send while Idle; re-enabling converges and set
     const source = yield* StateGroup.select(Inputs, 'page').store
     const store = yield* Items.store
     const queue = yield* Items.pending.store
-    yield* tick()
     expect(store.get()._tag).toBe('Idle')
 
     // Intents still send while gated Idle; settle waits for re-enable
@@ -626,7 +619,11 @@ it.live('gated: intents queue and send while Idle; re-enabling converges and set
       () => server.state.items,
       (items) => items.length === 2,
     )
-    yield* tick(20)
+    // The ack is the only thing that could settle the intent — assert the instant it lands.
+    yield* until(
+      () => queue.get(),
+      (q) => q[0]?.status === 'confirmed',
+    )
     expect(store.get()._tag).toBe('Idle')
     expect(queue.get()).toHaveLength(1)
     expect(server.state.fetches).toBe(0)
@@ -774,8 +771,13 @@ it.live('a query Error passes through by reference with intents still pending',
     intents: [Added, Renamed],
     alwaysOn: true,
   }) {}
+  const attempts = { n: 0 }
   const ItemsLive = RemoteState.live(Items, {
-    query: () => Effect.fail('boom').pipe(Effect.delay(Duration.millis(5))),
+    query: () =>
+      Effect.suspend(() => {
+        attempts.n += 1
+        return Effect.fail('boom')
+      }),
     send: (intent) => server.receive(intent, 10),
     apply: applyIntent,
   })
@@ -799,11 +801,15 @@ it.live('a query Error passes through by reference with intents still pending',
       () => queue.get(),
       (q) => q.length === 1 && q[0]?.status === 'confirmed',
     )
+    // Only a completed run could settle the intent — wait for the post-ack one to land.
+    yield* until(
+      () => attempts.n,
+      (n) => n >= 2,
+    )
     yield* until(
       () => store.get(),
       (v) => v._tag === 'Error' && v.refetching === false,
     )
-    yield* tick(20)
     expect(queue.get()).toHaveLength(1)
     expect(store.get()).toBe(truth.get())
   }).pipe(Effect.provide(TestLayer))

package/src/remote/remoteState.ts

@@ -1,417 +1,55 @@
-import {
-  Context,
-  Effect,
-  Either,
-  Equal,
-  Iterable,
-  Layer,
-  MutableRef,
-  Option,
-  Runtime,
-  Schema,
-} from 'effect'
-import type { Effect as EffectType } from 'effect/Effect'
-import {
-  type AnyAsyncData,
-  AsyncData,
-  type AsyncError,
-  type AsyncSuccess,
-  narrowStore,
-  widenStore,
-} from '../calc/asyncData'
+import { Context, Effect, Iterable, Layer, MutableRef, Option, Runtime, Schema } from 'effect'
+import { type AnyAsyncData, AsyncData, 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 { 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 { resolveScheduler } from '../internal/scheduler'
+import { type InputStores, sameKey } from '../internal/sources'
+import { makeDerivedStore } from '../internal/store'
 import * as Reducer from '../reducer/reducer'
-import { Bus, narrowHandled, publish } from '../runtime/bus'
-import { type ReducerEntry, Reducers } from '../runtime/loop'
+import { Bus, publish } from '../runtime/bus'
+import { Reducers } from '../runtime/loop'
 import * as State from '../state/state'
-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,
-  }
-}
+import { type AnySource } from '../state/token'
+import { makePendingQueue, type PendingQueue } from './pendingQueue'
+import { looseSchema } from './remoteStateMake'
+import { queueReducerLayer, sendProcedureLayer } from './remoteStateSend'
+import type {
+  RemoteStateClass,
+  RemoteStateLiveExternalApi,
+  RemoteStatePendingStore,
+  RemoteStateSettled,
+  RemoteStateTruthStore,
+  RemoteStateVisibleStore,
+  SettleLink,
+  WaiterRegistration,
+} from './remoteStateTypes'
+
+export { make } from './remoteStateMake'
+export {
+  RemoteStatePendingStoreTypeId,
+  RemoteStateTruthStoreTypeId,
+  RemoteStateVisibleStoreTypeId,
+} from './remoteStateTypes'
+export type {
+  FailedIntent,
+  PendingIntent,
+  RemoteStateClass,
+  RemoteStateConfigExternalApi,
+  RemoteStateLiveExternalApi,
+  RemoteStateManifestExternalApi,
+  RemoteStatePendingStore,
+  RemoteStateSchemaReflection,
+  RemoteStateSettled,
+  RemoteStateTruthStore,
+  RemoteStateVisibleStore,
+} from './remoteStateTypes'
 
 export const live = <
   N extends string,
@@ -604,91 +242,27 @@ export const live = <
     }),
   )
 
-  // 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 = 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 intentEvents = {
+    queued: Queued,
+    acked: Acked,
+    settled: Settled,
+    invalidated: Invalidated,
+  }
+  const pendingReducer = queueReducerLayer({
+    name: `${name}/pending`,
+    queueTag: pendingQueueTag,
+    events: intentEvents,
+  })
+  const sendProcedure = sendProcedureLayer({
+    name: `${name}/send`,
+    channel,
+    handles: new Set(remote.intents.map((event) => event.tag)),
+    linkTag,
+    failed: remote.Failed,
+    send: config.send,
+    events: intentEvents,
+  })
 
   const pendingStoreLayer = Layer.scopedContext(
     Effect.map(resolveScheduler, (scheduler) => {
@@ -698,9 +272,9 @@ export const live = <
   )
   return Layer.mergeAll(
     overlayLayer,
-    queueReducerLayer,
+    pendingReducer,
     Reducer.live(revisionReducer, bumpRevision),
-    sendProcedureLayer,
+    sendProcedure,
     Channel.live(channel),
   ).pipe(
     Layer.provideMerge(driverLayer),