@playfast/reform 1.2.0 → 1.3.0

package/src/calc/asyncCalc.ts

@@ -1,9 +1,7 @@
 import { Context, Effect, Layer, Match, Option, Schema } from 'effect'
-import type { Effect as EffectType } from 'effect/Effect'
-import { type Manifest, yieldableClass } from '../definition/definition'
+import { yieldableClass } from '../definition/definition'
 import { type AnyEvent } from '../event/event'
-import { type InputsObject, type InputStores, type InvalidateBy } from '../internal/sources'
-import type { AnySchema } from '../internal/variance'
+import { type InputStores } from '../internal/sources'
 import {
   bumpRevision,
   type GatedOf,
@@ -19,145 +17,33 @@ import * as Reducer from '../reducer/reducer'
 import { Reducers } from '../runtime/loop'
 import { Queries } from '../runtime/queries'
 import * as State from '../state/state'
-import { type AnySource, type Source, type SourceCapture } from '../state/token'
+import { type AnySource, type SourceCapture } from '../state/token'
 import { type AsyncData, narrowStore } from './asyncData'
+import type {
+  AsyncCalcClass,
+  AsyncCalcConfig,
+  AsyncCalcLive,
+  AsyncCalcLiveView,
+  AsyncCalcLiveWithInvalidateOn,
+  AsyncCalcMakeConfigExternalApi,
+  AsyncCalcManifest,
+  AsyncCalcStore,
+  DefinedAsyncCalcClass,
+} from './asyncCalcTypes'
+
+export { AsyncCalcStoreTypeId } from './asyncCalcTypes'
+export type {
+  AsyncCalcClass,
+  AsyncCalcConfig,
+  AsyncCalcLive,
+  AsyncCalcLiveView,
+  AsyncCalcLiveWithInvalidateOn,
+  AsyncCalcManifest,
+  AsyncCalcSchemaReflection,
+  AsyncCalcStore,
+  DefinedAsyncCalcClass,
+} from './asyncCalcTypes'
 
-export interface AsyncCalcSchemaReflection {
-  readonly ast: Schema.Schema<unknown, unknown, unknown>['ast']
-}
-
-export interface AsyncCalcManifest<N extends string, A = unknown, E = never> extends Manifest {
-  readonly kind: 'AsyncCalc'
-  readonly name: N
-  readonly output: AnySchema<A>
-  // 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 error?: AnySchema<E>
-  readonly gated: boolean
-}
-
-export const AsyncCalcStoreTypeId: unique symbol = Symbol.for('reform/AsyncCalcStore')
-export type AsyncCalcStoreTypeId = typeof AsyncCalcStoreTypeId
-
-interface AsyncCalcStoreCompatibilityExternalApi<
-  N extends string,
-  in out A,
-  in out E,
-  in out Gated extends boolean,
-> extends Store<AsyncData<A, E, Gated>> {
-  readonly [AsyncCalcStoreTypeId]?: N
-}
-
-export type AsyncCalcStore<
-  N extends string,
-  A,
-  E,
-  Gated extends boolean,
-> = AsyncCalcStoreCompatibilityExternalApi<N, A, E, Gated>
-
-export interface AsyncCalcClass<
-  N extends string,
-  Inputs extends ReadonlyArray<AnySource>,
-  A,
-  E,
-  Gated extends boolean,
->
-  extends
-    EffectType<AsyncData<A, E, Gated>, never, AsyncCalcStore<N, A, E, Gated>>,
-    Source<N, AsyncData<A, E, Gated>, AsyncCalcStore<N, A, E, Gated>> {
-  new (): {}
-  readonly manifest: AsyncCalcManifest<N, A, E>
-  readonly store: Context.Tag<AsyncCalcStore<N, A, E, Gated>, Store<AsyncData<A, E, Gated>>>
-  readonly name: N
-  readonly inputs: Inputs
-  readonly gated: Gated
-}
-
-export interface DefinedAsyncCalcClass<
-  N extends string,
-  Inputs extends ReadonlyArray<AnySource>,
-  A,
-  E,
-  Gated extends boolean,
-> extends AsyncCalcClass<N, Inputs, A, E, Gated> {
-  readonly codec: QueryCodec<A>
-  readonly capture: <Result>(visit: SourceCapture<Result>) => Result
-}
-
-type ConfigSchema<ValueOrSchema> = [ValueOrSchema] extends [Schema.Schema.AnyNoContext]
-  ? ValueOrSchema
-  : AnySchema<ValueOrSchema>
-
-type ConfigErrorSchema<ValueOrSchema> = [ValueOrSchema] extends [undefined]
-  ? ValueOrSchema
-  : ConfigSchema<ValueOrSchema>
-
-export interface AsyncCalcConfig<
-  Inputs extends ReadonlyArray<AnySource>,
-  OutputSchema,
-  ErrorSchema,
-  AlwaysOn extends boolean,
-> {
-  readonly inputs: Inputs
-  readonly output: ConfigSchema<OutputSchema>
-  // 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 error?: ConfigErrorSchema<ErrorSchema>
-  // 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 alwaysOn?: AlwaysOn
-}
-
-interface AsyncCalcMakeConfigExternalApi<
-  Inputs extends ReadonlyArray<AnySource>,
-  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
-}
-
-export type AsyncCalcLive<
-  Inputs extends ReadonlyArray<AnySource>,
-  A,
-  E,
-  Gated extends boolean,
-  R,
-> = {
-  readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
-  readonly invalidateBy?: InvalidateBy<Inputs>
-  // 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'
-  // 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
-  // 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?:
-    | boolean
-    | { readonly key?: string | ((inputs: InputsObject<Inputs>) => string) }
-} & (Gated extends true
-  ? { readonly disabled?: (inputs: InputsObject<Inputs>) => boolean }
-  : { readonly disabled?: never })
-
-export type AsyncCalcLiveWithInvalidateOn<
-  Inputs extends ReadonlyArray<AnySource>,
-  A,
-  E,
-  Gated extends boolean,
-  R,
-> = AsyncCalcLive<Inputs, A, E, Gated, R> & {
-  readonly invalidateOn?: ReadonlyArray<AnyEvent>
-}
-
-export interface AsyncCalcLiveView<Inputs extends ReadonlyArray<AnySource>, A, E, R> {
-  readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
-  readonly invalidateBy?: InvalidateBy<Inputs>
-  readonly disabled?: (inputs: InputsObject<Inputs>) => boolean
-  readonly coalesce?: 'switch' | 'trailing'
-  readonly reuse?: boolean
-  readonly persist?:
-    | boolean
-    | { readonly key?: string | ((inputs: InputsObject<Inputs>) => string) }
-}
 
 export function make<
   const N extends string,

package/src/calc/asyncCalcTypes.test.ts

@@ -0,0 +1,64 @@
+import { expect, it } from '@effect/vitest'
+import type { Effect } from 'effect'
+import { Schema as S } from 'effect'
+import { AsyncCalc, Namespace, State, StateGroup } from '../index'
+import type { AsyncData } from './asyncData'
+
+// Pins the config -> value-type contract: a named schema in `output`/`error` must survive
+// inference. The package publishes source, so consumers compile these signatures under their
+// own tsconfig — keep `output`/`error` bare inference sites rather than wrapped in anything
+// deferred. `Namespace.make` is the exposed path here because `AsyncCalc.make` can fall back
+// to its second overload, which would mask a regression in `AsyncCalcConfig` itself.
+type Equals<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true
+  : false
+const expectTypeEquality = <_Proof extends true>(): void => {}
+
+const ns = Namespace.make('apps')
+
+it('infers output and error schema types from named schemas', () => {
+  const Result = S.Struct({ id: S.String, count: S.Number })
+
+  class Count extends State.make('count', S.Number) {}
+  class Inputs extends StateGroup.make(Count) {}
+  class MyApps extends ns.AsyncCalc('MyApps', {
+    inputs: [StateGroup.select(Inputs, 'count')],
+    output: Result,
+    error: S.String,
+    alwaysOn: true,
+  }) {}
+
+  type Data = Effect.Effect.Success<typeof MyApps>
+  expectTypeEquality<
+    Equals<Data, AsyncData<{ readonly id: string; readonly count: number }, string, false>>
+  >()
+
+  // `MyApps.name` is the JS class binding's own name, which shadows the prefixed one.
+  expect(MyApps.manifest.name).toBe('apps.MyApps')
+  expect(MyApps.gated).toBe(false)
+})
+
+it('defaults the error type to never when `error` is omitted', () => {
+  class Loaded extends ns.AsyncCalc('Loaded', {
+    inputs: [],
+    output: S.Number,
+  }) {}
+
+  type Data = Effect.Effect.Success<typeof Loaded>
+  expectTypeEquality<Equals<Data, AsyncData<number, never, true>>>()
+
+  expect(Loaded.gated).toBe(true)
+})
+
+it('keeps `AsyncCalc.make` inference intact through its overloads', () => {
+  class Doubled extends AsyncCalc.make('Doubled', {
+    inputs: [],
+    output: S.Number,
+    error: S.String,
+    alwaysOn: true,
+  }) {}
+
+  type Data = Effect.Effect.Success<typeof Doubled>
+  expectTypeEquality<Equals<Data, AsyncData<number, string, false>>>()
+
+  expect(Doubled.gated).toBe(false)
+})

package/src/calc/asyncCalcTypes.ts

@@ -0,0 +1,139 @@
+import type { Context, Effect, Schema } from 'effect'
+import type { Effect as EffectType } from 'effect/Effect'
+import type { Manifest } from '../definition/definition'
+import type { AnyEvent } from '../event/event'
+import type { InputsObject, InvalidateBy } from '../internal/sources'
+import type { QueryCodec } from '../internal/queryDriver'
+import type { Store } from '../internal/store'
+import type { AnySchema } from '../internal/variance'
+import type { AnySource, Source, SourceCapture } from '../state/token'
+import type { AsyncData } from './asyncData'
+
+export interface AsyncCalcSchemaReflection {
+  readonly ast: Schema.Schema<unknown, unknown, unknown>['ast']
+}
+
+export interface AsyncCalcManifest<N extends string, A = unknown, E = never> extends Manifest {
+  readonly kind: 'AsyncCalc'
+  readonly name: N
+  readonly output: AnySchema<A>
+  // 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 error?: AnySchema<E>
+  readonly gated: boolean
+}
+
+export const AsyncCalcStoreTypeId: unique symbol = Symbol.for('reform/AsyncCalcStore')
+export type AsyncCalcStoreTypeId = typeof AsyncCalcStoreTypeId
+
+interface AsyncCalcStoreCompatibilityExternalApi<
+  N extends string,
+  in out A,
+  in out E,
+  in out Gated extends boolean,
+> extends Store<AsyncData<A, E, Gated>> {
+  readonly [AsyncCalcStoreTypeId]?: N
+}
+
+export type AsyncCalcStore<
+  N extends string,
+  A,
+  E,
+  Gated extends boolean,
+> = AsyncCalcStoreCompatibilityExternalApi<N, A, E, Gated>
+
+export interface AsyncCalcClass<
+  N extends string,
+  Inputs extends ReadonlyArray<AnySource>,
+  A,
+  E,
+  Gated extends boolean,
+>
+  extends
+    EffectType<AsyncData<A, E, Gated>, never, AsyncCalcStore<N, A, E, Gated>>,
+    Source<N, AsyncData<A, E, Gated>, AsyncCalcStore<N, A, E, Gated>> {
+  new (): {}
+  readonly manifest: AsyncCalcManifest<N, A, E>
+  readonly store: Context.Tag<AsyncCalcStore<N, A, E, Gated>, Store<AsyncData<A, E, Gated>>>
+  readonly name: N
+  readonly inputs: Inputs
+  readonly gated: Gated
+}
+
+export interface DefinedAsyncCalcClass<
+  N extends string,
+  Inputs extends ReadonlyArray<AnySource>,
+  A,
+  E,
+  Gated extends boolean,
+> extends AsyncCalcClass<N, Inputs, A, E, Gated> {
+  readonly codec: QueryCodec<A>
+  readonly capture: <Result>(visit: SourceCapture<Result>) => Result
+}
+
+export interface AsyncCalcConfig<
+  Inputs extends ReadonlyArray<AnySource>,
+  OutputSchema,
+  ErrorSchema,
+  AlwaysOn extends boolean,
+> {
+  readonly inputs: Inputs
+  readonly output: OutputSchema
+  // 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 error?: ErrorSchema
+  // 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 alwaysOn?: AlwaysOn
+}
+
+export interface AsyncCalcMakeConfigExternalApi<
+  Inputs extends ReadonlyArray<AnySource>,
+  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
+}
+
+export type AsyncCalcLive<
+  Inputs extends ReadonlyArray<AnySource>,
+  A,
+  E,
+  Gated extends boolean,
+  R,
+> = {
+  readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
+  readonly invalidateBy?: InvalidateBy<Inputs>
+  // 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'
+  // 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
+  // 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?:
+    | boolean
+    | { readonly key?: string | ((inputs: InputsObject<Inputs>) => string) }
+} & (Gated extends true
+  ? { readonly disabled?: (inputs: InputsObject<Inputs>) => boolean }
+  : { readonly disabled?: never })
+
+export type AsyncCalcLiveWithInvalidateOn<
+  Inputs extends ReadonlyArray<AnySource>,
+  A,
+  E,
+  Gated extends boolean,
+  R,
+> = AsyncCalcLive<Inputs, A, E, Gated, R> & {
+  readonly invalidateOn?: ReadonlyArray<AnyEvent>
+}
+
+export interface AsyncCalcLiveView<Inputs extends ReadonlyArray<AnySource>, A, E, R> {
+  readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
+  readonly invalidateBy?: InvalidateBy<Inputs>
+  readonly disabled?: (inputs: InputsObject<Inputs>) => boolean
+  readonly coalesce?: 'switch' | 'trailing'
+  readonly reuse?: boolean
+  readonly persist?:
+    | boolean
+    | { readonly key?: string | ((inputs: InputsObject<Inputs>) => string) }
+}

package/src/calc/calc.test.ts

@@ -1,8 +1,7 @@
 import { expect, it } from '@effect/vitest'
-import { Duration, Effect, Layer, Schema as S } from 'effect'
+import { Effect, Layer, Schema as S } from 'effect'
 import { Calc, State, StateGroup } from '../index'
-
-const tick = Effect.sleep(Duration.millis(1))
+import { flush } from '../testkit/flight.testkit'
 
 it.live('a source change that does not move the output notifies no subscriber', () => {
   class Count extends State.make('count', S.Number) {}
@@ -30,12 +29,12 @@ it.live('a source change that does not move the output notifies no subscriber',
     expect(derived.get()).toBe(true)
 
     source.set(2)
-    yield* tick
+    yield* flush()
     expect(notifications.n).toBe(0)
     expect(derived.get()).toBe(true)
 
     source.set(-1)
-    yield* tick
+    yield* flush()
     expect(notifications.n).toBe(1)
     expect(derived.get()).toBe(false)
   }).pipe(Effect.provide(TestLayer))
@@ -89,7 +88,7 @@ it.live('a calc can depend on another calc as an input source', () => {
     const derived = yield* PlusDoubled.store
     expect(derived.get()).toBe(15)
     source.set(3)
-    yield* tick
+    yield* flush()
     expect(derived.get()).toBe(9)
   }).pipe(Effect.provide(TestLayer))
 })
@@ -125,7 +124,7 @@ it.live('a diamond dependency resolves in one flush with a single leaf notificat
     expect(c.get()).toBe(11)
 
     source.set(5)
-    yield* tick
+    yield* flush()
     expect(c.get()).toBe(21)
     expect(wakes.n).toBe(1)
   }).pipe(Effect.provide(TestLayer))
@@ -158,12 +157,12 @@ it.live('invalidateBy: a calc recomputes only when the projected key moves', ()
     expect(sum.get()).toBe(2)
 
     sb.set(100)
-    yield* tick
+    yield* flush()
     expect(runs.n).toBe(base)
     expect(sum.get()).toBe(2)
 
     sa.set(5)
-    yield* tick
+    yield* flush()
     expect(sum.get()).toBe(105)
   }).pipe(Effect.provide(TestLayer))
 })
@@ -222,7 +221,7 @@ it.live('reuse: an unchanged subtree keeps its identity across recompute', () =>
     const before = derived.get()
 
     b.set(2)
-    yield* tick
+    yield* flush()
     const after = derived.get()
     expect(after).not.toBe(before)
     expect(after.left).toBe(before.left)
@@ -254,7 +253,7 @@ it.live('reuse: a value-equal recompute keeps the previous reference and wakes n
     const before = derived.get()
 
     source.set(2)
-    yield* tick
+    yield* flush()
     expect(derived.get()).toBe(before)
     expect(notifications.n).toBe(0)
   }).pipe(Effect.provide(TestLayer))

package/src/calc/calcFamily.test.ts

@@ -1,8 +1,8 @@
 import { expect, it } from '@effect/vitest'
-import { Context, Duration, Effect, Exit, Layer, Schema as S, Scope } from 'effect'
+import { Context, Effect, Exit, Layer, Schema as S, Scope } from 'effect'
 import { CalcFamily, State, StateGroup } from '../index'
+import { flush } from '../testkit/flight.testkit'
 
-const tick = Effect.sleep(Duration.millis(1))
 
 const Board = S.Record({ key: S.String, value: S.Number })
 
@@ -33,7 +33,7 @@ it.live('a member derives from the shared inputs and recomputes when they change
     expect(yield* CalcFamily.read(Slice, 'b')).toBe(10)
 
     feed.set({ a: 2, b: 10 })
-    yield* tick
+    yield* flush()
     expect(yield* CalcFamily.read(Slice, 'a')).toBe(2)
   }).pipe(Effect.provide(TestLayer))
 })
@@ -55,11 +55,11 @@ it.live('a member only notifies when its own slice of the projection moves', ()
     })
 
     feed.set({ a: 2, b: 10 })
-    yield* tick
+    yield* flush()
     expect(wakes).toEqual({ a: 1, b: 0 })
 
     feed.set({ a: 2, b: 11 })
-    yield* tick
+    yield* flush()
     expect(wakes).toEqual({ a: 1, b: 1 })
   }).pipe(Effect.provide(TestLayer))
 })
@@ -107,13 +107,13 @@ it.live('reuse preserves each member output when equal and replaces it when chan
 
     expect(Object.is(initialA.nested, initialB.nested)).toBe(false)
     revision.set(1)
-    yield* tick
+    yield* flush()
     expect(Object.is(family.at('a').get().nested, initialA.nested)).toBe(true)
     expect(Object.is(family.at('b').get().nested, initialB.nested)).toBe(true)
     expect(wakes).toEqual({ a: 0, b: 0 })
 
     feed.set({ a: 2, b: 1 })
-    yield* tick
+    yield* flush()
     expect(family.at('a').get().nested).toEqual([{ value: 2 }])
     expect(Object.is(family.at('a').get().nested, initialA.nested)).toBe(false)
     expect(Object.is(family.at('b').get().nested, initialB.nested)).toBe(true)
@@ -165,7 +165,7 @@ it.live('invalidateBy: shared-input churn outside the key recomputes no member',
     expect(runs.get('a')).toBe(1)
 
     noise.set(99)
-    yield* tick
+    yield* flush()
     expect(yield* CalcFamily.read(Slice, 'a')).toBe(1)
     expect(runs.get('a')).toBe(1)
   }).pipe(Effect.provide(TestLayer))
@@ -184,7 +184,7 @@ it.live('forget releases the member and its upstream subscription', () => {
     expect(family.size()).toBe(0)
     const before = runs.get('a') ?? 0
     feed.set({ a: 2 })
-    yield* tick
+    yield* flush()
     expect(runs.get('a') ?? 0).toBe(before)
 
     expect(family.at('a').get()).toBe(2)
@@ -217,11 +217,11 @@ it.live('evictWhenUnused: an idle member is dropped on the next microtask and un
     expect(family.size()).toBe(1)
 
     off()
-    yield* tick
+    yield* flush()
     expect(family.size()).toBe(0)
     const before = runs.get('a') ?? 0
     feed.set({ a: 2 })
-    yield* tick
+    yield* flush()
     expect(runs.get('a') ?? 0).toBe(before)
   }).pipe(Effect.provide(TestLayer))
 })
@@ -245,7 +245,7 @@ it.live('the layer finalizer clears every member (no live subscriptions leak)',
       expect(family.size()).toBe(0)
       const before = [runs.get('a') ?? 0, runs.get('b') ?? 0]
       feed.set({ a: 9, b: 9 })
-      yield* tick
+      yield* flush()
       expect([runs.get('a') ?? 0, runs.get('b') ?? 0]).toEqual(before)
     }),
   )

package/src/channel/channel.ts

@@ -12,9 +12,16 @@ import {
   Stream,
 } from 'effect'
 import { type Manifest, definitionClass } from '../definition/definition'
-import { makeBucketCache } from '../internal/bucketCache'
 import type { Tagged } from '../runtime/bus'
 import { resolveInstrumentation } from '../runtime/instrumentation'
+import { type ProcedureEntry, Procedures } from './procedures'
+
+export {
+  type ProcedureEntry,
+  type ProcedureRegistry,
+  Procedures,
+  proceduresLayer,
+} from './procedures'
 
 export type ChannelPolicy =
   | { readonly _tag: 'merge' }
@@ -44,111 +51,6 @@ export interface ChannelConfig {
   readonly policy: ChannelPolicy
 }
 
-export interface ProcedureEntry {
-  readonly name: string
-  readonly channelName: string
-  readonly handles: ReadonlySet<string>
-  readonly run: (event: Tagged) => Effect.Effect<unknown, unknown, never>
-}
-
-export interface ProcedureRegistry {
-  readonly entries: Array<ProcedureEntry>
-  readonly byName: Map<string, Set<ProcedureEntry>>
-  readonly byTag: Map<string, Set<ProcedureEntry>>
-  readonly channelsByTag: Map<string, Set<string>>
-  readonly channelsFor: (tag: string) => ReadonlyArray<string>
-  readonly byChannelTag: Map<string, Map<string, Set<ProcedureEntry>>>
-  readonly register: (entry: ProcedureEntry) => void
-  readonly unregister: (entry: ProcedureEntry) => void
-}
-
-const ProceduresBase: Context.TagClass<Procedures, 'reform/Procedures', ProcedureRegistry> =
-  Context.Tag('reform/Procedures')<Procedures, ProcedureRegistry>()
-export class Procedures extends ProceduresBase {}
-
-const getOrCreate = <K, V>(map: Map<K, V>, key: K, make: () => V): V => {
-  const existing = map.get(key)
-  if (existing !== undefined) {
-    return existing
-  }
-  const created = make()
-  map.set(key, created)
-  return created
-}
-
-const dropFrom = <K, T>(map: Map<K, Set<T>>, key: K, target: T): void => {
-  const bucket = map.get(key)
-  if (bucket === undefined) {
-    return
-  }
-  bucket.delete(target)
-  if (bucket.size === 0) {
-    map.delete(key)
-  }
-}
-
-const makeProcedureRegistry = (): ProcedureRegistry => {
-  const entries = new Set<ProcedureEntry>()
-  const byName = new Map<string, Set<ProcedureEntry>>()
-  const byTag = new Map<string, Set<ProcedureEntry>>()
-  const channelsByTag = new Map<string, Set<string>>()
-  const channelsFor = makeBucketCache(channelsByTag)
-  const byChannelTag = new Map<string, Map<string, Set<ProcedureEntry>>>()
-  const snapshot: { value: Option.Option<Array<ProcedureEntry>> } = {
-    value: Option.some([]),
-  }
-  return {
-    get entries() {
-      return Option.getOrElse(snapshot.value, () => {
-        const current = Array.from(entries)
-        snapshot.value = Option.some(current)
-        return current
-      })
-    },
-    byName,
-    byTag,
-    channelsByTag,
-    channelsFor: channelsFor.read,
-    byChannelTag,
-    register: (entry) => {
-      entries.add(entry)
-      snapshot.value = Option.none()
-      getOrCreate(byName, entry.name, () => new Set()).add(entry)
-      entry.handles.forEach((tag) => {
-        getOrCreate(byTag, tag, () => new Set()).add(entry)
-        getOrCreate(channelsByTag, tag, () => new Set()).add(entry.channelName)
-        channelsFor.invalidate(tag)
-        const channelMap = getOrCreate(byChannelTag, entry.channelName, () => new Map())
-        getOrCreate(channelMap, tag, () => new Set()).add(entry)
-      })
-    },
-    unregister: (entry) => {
-      entries.delete(entry)
-      snapshot.value = Option.none()
-      dropFrom(byName, entry.name, entry)
-      entry.handles.forEach((tag) => {
-        dropFrom(byTag, tag, entry)
-        const channelMap = byChannelTag.get(entry.channelName)
-        if (channelMap !== undefined) {
-          dropFrom(channelMap, tag, entry)
-          if (channelMap.get(tag) === undefined) {
-            dropFrom(channelsByTag, tag, entry.channelName)
-            channelsFor.invalidate(tag)
-          }
-          if (channelMap.size === 0) {
-            byChannelTag.delete(entry.channelName)
-          }
-        }
-      })
-    },
-  }
-}
-
-export const proceduresLayer: Layer.Layer<Procedures> = Layer.sync(
-  Procedures,
-  makeProcedureRegistry,
-)
-
 export interface ChannelRuntime {
   readonly name: string
   readonly policy: ChannelPolicy