@playfast/reform 0.1.0 → 1.1.1

package/src/channel/channel.ts

@@ -1,18 +1,15 @@
-import { Chunk, Context, type Duration, Effect, Layer, Match, Option, Queue, Stream } from 'effect'
+import { Chunk, Context, Duration, Effect, Exit, Layer, Match, Option, Queue, Scope, Stream } from 'effect'
 import { type Manifest, definitionClass } from '../definition/definition'
 import type { Tagged } from '../runtime/bus'
+import { resolveInstrumentation } from '../runtime/instrumentation'
+import { type ProcedureEntry, Procedures } from './procedureRegistry'
+export {
+  type ProcedureEntry,
+  type ProcedureRegistry,
+  Procedures,
+  proceduresLayer,
+} from './procedureRegistry'
 
-/**
- * How a channel schedules the procedure work routed to it. Channels generalize
- * the old per-procedure `concurrency`: a named lane with one policy, shared by
- * every procedure that declares it.
- *
- * - `merge`     run every routed event concurrently (the default).
- * - `latest`    a new event cancels the in-flight run (switch).
- * - `debounce`  collapse a burst, run only after `duration` of quiet.
- * - `throttle`  rate-limit to `units` per `duration` (shape or enforce).
- * - `exclusive` one run at a time across the whole channel (mutual exclusion).
- */
 export type ChannelPolicy =
   | { readonly _tag: 'merge' }
   | { readonly _tag: 'latest' }
@@ -27,7 +24,6 @@ export type ChannelPolicy =
     }
   | { readonly _tag: 'exclusive' }
 
-/** The reflectable descriptor a channel carries. */
 export interface ChannelManifest extends Manifest {
   readonly kind: 'Channel'
 }
@@ -42,134 +38,14 @@ export interface ChannelConfig {
   readonly policy: ChannelPolicy
 }
 
-/**
- * A registered procedure body, with its trigger events and the channel it runs
- * on. `run`'s context (RPC clients, etc.) is already provided at registration
- * (see `Procedure.live`), so the channel fiber can run it with no R.
- */
-export interface ProcedureEntry {
-  /** The procedure's name — used only to warn on duplicate registration. */
-  readonly name: string
-  readonly channelName: string
-  readonly handles: ReadonlySet<string>
-  readonly run: (event: Tagged) => Effect.Effect<unknown, unknown, never>
-}
-
-/**
- * Mutable collector procedures register into; channels read it to find their
- * bodies. `byTag` indexes entries by trigger tag, so a channel routes an event
- * to O(procedures handling it) rather than scanning every registered procedure.
- */
-export interface ProcedureRegistry {
-  readonly entries: Array<ProcedureEntry>
-  readonly byTag: Map<string, Array<ProcedureEntry>>
-  /**
-   * Distinct channel names per event tag. The drain loop routes through this so
-   * it offers each event to each channel exactly once — not once per matching
-   * procedure, which would re-run every procedure on a shared channel per offer.
-   */
-  readonly channelsByTag: Map<string, Array<string>>
-  /**
-   * Procedures keyed by (channel, tag), so a channel's `runMatching` is a direct
-   * lookup instead of scanning `byTag` and re-filtering by channel per event.
-   */
-  readonly byChannelTag: Map<string, Map<string, Array<ProcedureEntry>>>
-  readonly register: (entry: ProcedureEntry) => void
-  /**
-   * Remove a previously-registered entry — the inverse of `register`, used when a
-   * lazy feature unmounts (scope close) so its procedures stop running and their
-   * index entries are reclaimed. Eager procedures (root scope) never call it.
-   */
-  readonly unregister: (entry: ProcedureEntry) => void
-}
-
-const ProceduresBase: Context.TagClass<Procedures, 'reform/Procedures', ProcedureRegistry> =
-  Context.Tag('reform/Procedures')<Procedures, ProcedureRegistry>()
-export class Procedures extends ProceduresBase {}
-
-/** Get a map entry, creating and inserting it on first access (avoids `let`). */
-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
-}
-
-/** Drop an item from a `Map<K, Array>` bucket, pruning the key when it empties. */
-const dropFrom = <K, T>(map: Map<K, Array<T>>, key: K, target: T): void => {
-  const bucket = map.get(key)
-  if (bucket === undefined) {
-    return
-  }
-  const next = bucket.filter((candidate) => candidate !== target)
-  if (next.length === 0) {
-    map.delete(key)
-  } else {
-    map.set(key, next)
-  }
-}
-
-const makeProcedureRegistry = (): ProcedureRegistry => {
-  // `entries` is reassigned immutably (new array per change) rather than mutated
-  // in place, so the holder keeps a stable reference the getter reads through.
-  const state: { entries: Array<ProcedureEntry> } = { entries: [] }
-  const byTag = new Map<string, Array<ProcedureEntry>>()
-  const channelsByTag = new Map<string, Array<string>>()
-  const byChannelTag = new Map<string, Map<string, Array<ProcedureEntry>>>()
-  return {
-    get entries() {
-      return state.entries
-    },
-    byTag,
-    channelsByTag,
-    byChannelTag,
-    register: (entry) => {
-      state.entries = [...state.entries, entry]
-      entry.handles.forEach((tag) => {
-        byTag.set(tag, [...getOrCreate(byTag, tag, () => []), entry])
-        const channels = getOrCreate(channelsByTag, tag, () => [])
-        if (!channels.includes(entry.channelName)) {
-          channelsByTag.set(tag, [...channels, entry.channelName])
-        }
-        const channelMap = getOrCreate(byChannelTag, entry.channelName, () => new Map())
-        channelMap.set(tag, [...getOrCreate(channelMap, tag, () => []), entry])
-      })
-    },
-    unregister: (entry) => {
-      state.entries = state.entries.filter((existing) => existing !== entry)
-      entry.handles.forEach((tag) => {
-        dropFrom(byTag, tag, entry)
-        const channelMap = byChannelTag.get(entry.channelName)
-        if (channelMap !== undefined) {
-          dropFrom(channelMap, tag, entry)
-          // If no procedure on this channel still handles the tag, drop the
-          // channel from `channelsByTag[tag]` so the loop stops offering to it.
-          if (channelMap.get(tag) === undefined) {
-            dropFrom(channelsByTag, tag, entry.channelName)
-          }
-          if (channelMap.size === 0) {
-            byChannelTag.delete(entry.channelName)
-          }
-        }
-      })
-    },
-  }
-}
-
-export const proceduresLayer: Layer.Layer<Procedures> = Layer.sync(Procedures, makeProcedureRegistry)
-
-/** A live channel: the single loop offers events here; the channel drives them. */
 export interface ChannelRuntime {
   readonly name: string
-  /** The policy this channel was built with — used to reject a name clash. */
   readonly policy: ChannelPolicy
   readonly offer: (event: Tagged) => void
+  readonly leases: { count: number }
+  readonly close: Effect.Effect<void>
 }
 
-/** Registry of live channels, keyed by name. The single loop routes through it. */
 const ChannelsBase: Context.TagClass<
   Channels,
   'reform/Channels',
@@ -179,23 +55,62 @@ export class Channels extends ChannelsBase {}
 
 export const channelsLayer: Layer.Layer<Channels> = Layer.sync(Channels, () => ({ byName: new Map() }))
 
-/**
- * A scheduling lane for procedures. The *definition* (`Channel.make`) is a
- * reflectable name + policy; the *implementation* (`Channel.live`) builds the
- * queue + fiber that applies the policy. Procedures reference a channel by value
- * and register into it; `Channel.live` is merged into the app once per channel.
- */
 export const make = (name: string, config: ChannelConfig): ChannelClass =>
   definitionClass<ChannelClass>({
     manifest: { kind: 'Channel' as const, name } satisfies ChannelManifest,
     policy: config.policy,
   })
 
-/**
- * Build and register the live machinery for a channel. Idempotent by name, so
- * procedures sharing an `exclusive`/`latest` channel share one queue + fiber +
- * semaphore (and therefore truly serialize / cancel across each other).
- */
+const durationMillis = (duration: Duration.DurationInput): number =>
+  Duration.toMillis(Duration.decode(duration))
+
+const sameOptionValue = <A>(left: Option.Option<A>, right: Option.Option<A>): boolean =>
+  Option.match(left, {
+    onNone: () => Option.isNone(right),
+    onSome: (leftValue) =>
+      Option.match(right, {
+        onNone: () => false,
+        onSome: (rightValue) => Object.is(leftValue, rightValue),
+      }),
+  })
+
+const samePolicy = (left: ChannelPolicy, right: ChannelPolicy): boolean =>
+  Match.value(left).pipe(
+    Match.tag('merge', () => right._tag === 'merge'),
+    Match.tag('latest', () => right._tag === 'latest'),
+    Match.tag(
+      'debounce',
+      (policy) =>
+        right._tag === 'debounce' &&
+        durationMillis(policy.duration) === durationMillis(right.duration),
+    ),
+    Match.tag(
+      'throttle',
+      (policy) =>
+        right._tag === 'throttle' &&
+        policy.units === right.units &&
+        durationMillis(policy.duration) === durationMillis(right.duration) &&
+        sameOptionValue(policy.cost, right.cost) &&
+        sameOptionValue(policy.burst, right.burst) &&
+        sameOptionValue(policy.strategy, right.strategy),
+    ),
+    Match.tag('exclusive', () => right._tag === 'exclusive'),
+    Match.exhaustive,
+  )
+
+const release = Effect.fn('release')(function* (
+  byName: Map<string, ChannelRuntime>,
+  registration: ChannelRuntime,
+): Effect.fn.Return<void> {
+  registration.leases.count -= 1
+  if (registration.leases.count === 0) {
+    if (byName.get(registration.name) === registration) {
+      byName.delete(registration.name)
+    }
+    yield* registration.close
+  }
+})
+
 export const live = (channel: ChannelClass): Layer.Layer<never, never, Channels | Procedures> =>
   Layer.scopedDiscard(
     Effect.gen(function* () {
@@ -203,27 +118,20 @@ export const live = (channel: ChannelClass): Layer.Layer<never, never, Channels
       const channels = yield* Channels
       const existing = channels.byName.get(name)
       if (existing !== undefined) {
-        // Idempotent for the *same* channel `.live`'d through several sub-layers
-        // (shared `exclusive`/`latest` lane). A *different* channel reusing the
-        // name is a silent footgun — the second policy would be dropped — so
-        // reject it loudly instead.
-        if (existing.policy !== channel.policy) {
-          // A different channel reusing a live name is a programmer footgun, not a
-          // recoverable failure — surface it as a defect to keep the layer E = never.
+        if (!samePolicy(existing.policy, channel.policy)) {
           yield* Effect.dieMessage(
-            `reform: channel '${name}' is already live with a different policy`,
+            `reform: channel '${name}' is already live with a different policy (existing: ${existing.policy._tag}, incoming: ${channel.policy._tag})`,
           )
         }
+        existing.leases.count += 1
+        yield* Effect.addFinalizer(() => release(channels.byName, existing))
         return
       }
       const procedures = yield* Procedures
+      const instrumentation = yield* resolveInstrumentation
+      const machineryScope = yield* Scope.make()
       const queue = yield* Queue.unbounded<Tagged>()
 
-      // Run every procedure on THIS channel that handles the event. Read the live
-      // index each time so procedures registered later are still seen.
-      // A procedure is expected to model expected failures as events; a leaked
-      // defect (a bug in the body) is logged before being isolated, so one
-      // procedure's crash never tears down the channel fiber — but is observable.
       const runMatching = (event: Tagged): Effect.Effect<void> => {
         const matching = Option.fromNullable(procedures.byChannelTag.get(name)).pipe(
           Option.flatMapNullable((byTag) => byTag.get(event._tag)),
@@ -232,7 +140,10 @@ export const live = (channel: ChannelClass): Layer.Layer<never, never, Channels
         return Effect.forEach(
           matching,
           (procedure) =>
-            procedure.run(event).pipe(
+            Effect.sync(() => instrumentation.procedureRun(procedure.name, name, event._tag)).pipe(
+              Effect.flatMap((endSpan) =>
+                procedure.run(event).pipe(Effect.ensuring(Effect.sync(endSpan))),
+              ),
               Effect.tapErrorCause((cause) =>
                 Effect.logError(`reform: procedure on channel '${name}' failed`, cause),
               ),
@@ -242,8 +153,6 @@ export const live = (channel: ChannelClass): Layer.Layer<never, never, Channels
         )
       }
 
-      // Map the policy to its scheduling stream. `Match.exhaustive` makes a new
-      // policy variant a compile error, and each arm is a self-contained const.
       const events = Stream.fromQueue(queue)
       const driven: Stream.Stream<unknown> = Match.value(channel.policy).pipe(
         Match.tag('merge', () => Stream.mapEffect(events, runMatching, { concurrency: 'unbounded' })),
@@ -271,25 +180,21 @@ export const live = (channel: ChannelClass): Layer.Layer<never, never, Channels
             Stream.mapEffect(runMatching, { concurrency: 'unbounded' }),
           ),
         ),
-        // `concurrency: 1` runs one event at a time AND in offer order — a true
-        // serialized lane. (An unbounded fork racing for a single semaphore permit
-        // would serialize but could reorder under contention.)
         Match.tag('exclusive', () => Stream.mapEffect(events, runMatching, { concurrency: 1 })),
         Match.exhaustive,
       )
 
-      yield* Effect.forkScoped(Stream.runDrain(driven))
-      channels.byName.set(name, {
+      yield* Stream.runDrain(driven).pipe(Effect.forkIn(machineryScope))
+      const registration: ChannelRuntime = {
         name,
         policy: channel.policy,
         offer: (event) => {
           Queue.unsafeOffer(queue, event)
         },
-      })
-      // On scope close (a lazy feature unmounting) remove the live channel so the
-      // loop stops routing to it; the drain fiber is already torn down by
-      // `forkScoped`. Eager channels live on the root scope, so this is a no-op
-      // until app dispose.
-      yield* Effect.addFinalizer(() => Effect.sync(() => channels.byName.delete(name)))
+        leases: { count: 1 },
+        close: Scope.close(machineryScope, Exit.void),
+      }
+      channels.byName.set(name, registration)
+      yield* Effect.addFinalizer(() => release(channels.byName, registration))
     }),
   )

package/src/channel/procedureRegistry.ts

@@ -0,0 +1,90 @@
+import { Context, Effect, Layer } from 'effect'
+import type { Tagged } from '../runtime/bus'
+
+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 byTag: Map<string, Array<ProcedureEntry>>
+  readonly channelsByTag: Map<string, Array<string>>
+  readonly byChannelTag: Map<string, Map<string, Array<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, Array<T>>, key: K, target: T): void => {
+  const bucket = map.get(key)
+  if (bucket === undefined) {
+    return
+  }
+  const next = bucket.filter((candidate) => candidate !== target)
+  if (next.length === 0) {
+    map.delete(key)
+  } else {
+    map.set(key, next)
+  }
+}
+
+const makeProcedureRegistry = (): ProcedureRegistry => {
+  const state: { entries: Array<ProcedureEntry> } = { entries: [] }
+  const byTag = new Map<string, Array<ProcedureEntry>>()
+  const channelsByTag = new Map<string, Array<string>>()
+  const byChannelTag = new Map<string, Map<string, Array<ProcedureEntry>>>()
+  return {
+    get entries() {
+      return state.entries
+    },
+    byTag,
+    channelsByTag,
+    byChannelTag,
+    register: (entry) => {
+      state.entries = [...state.entries, entry]
+      entry.handles.forEach((tag) => {
+        byTag.set(tag, [...getOrCreate(byTag, tag, () => []), entry])
+        const channels = getOrCreate(channelsByTag, tag, () => [])
+        if (!channels.includes(entry.channelName)) {
+          channelsByTag.set(tag, [...channels, entry.channelName])
+        }
+        const channelMap = getOrCreate(byChannelTag, entry.channelName, () => new Map())
+        channelMap.set(tag, [...getOrCreate(channelMap, tag, () => []), entry])
+      })
+    },
+    unregister: (entry) => {
+      state.entries = state.entries.filter((existing) => existing !== 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)
+          }
+          if (channelMap.size === 0) {
+            byChannelTag.delete(entry.channelName)
+          }
+        }
+      })
+    },
+  }
+}
+
+export const proceduresLayer: Layer.Layer<Procedures> = Layer.sync(Procedures, makeProcedureRegistry)

package/src/compose/composition.ts

@@ -8,41 +8,27 @@ import type { SlotClass } from './slot'
 import type { Structure } from './structure'
 import type { UiClass, UiContract } from './ui'
 import { Props } from './props'
+import type { AnyValue } from '../internal/variance'
 
-/**
- * What a composition's logic returns for one frame: a serializable {@link Structure}
- * value — its computed props, per-slot fills, and event triggers, all as DATA. A body
- * never returns (nor evaluates) a React node, so the engine, the wire server, and the
- * proof harness consume the frame without React; presentation resolves the contract's
- * view separately, by name, on a host.
- */
 export type Frame<C extends UiContract = UiContract> = Structure<C>
 
-/** Everything the host injects per render: the instance props and the dependency tracker. */
 export interface RenderEnv {
   readonly props: unknown
   readonly tracker: Tracker
 }
 
-/** A mounted composition: given a render environment, produces the current frame —
- *  a {@link Structure} value (see `Frame`). */
 export interface CompositionService {
   readonly render: (env: RenderEnv) => Effect.Effect<Frame, never, never>
 }
 
-// Reflectable manifest/config carrier: only `title` + `ui` are required, and the
-// optional members drive `Config extends { props: … }` / `{ states: … }` inference
-// (PropsOf/StatesOf) plus the ergonomic `Composition.make({ title, ui })` form, so
-// they cannot become `Option<T>` (would break inference and every call site) or be
-// renamed `ExternalApi` (would break external importers of `CompositionConfig`).
+// Optional fields drive Config extends { props/states: … } inference — cannot be Option
 export interface CompositionConfig {
   readonly title: string
   // oxlint-disable-next-line reform-rules/no-optional-fields -- optional config field on a reflectable manifest carrier (see note above)
   readonly description?: string
-  // `any` in the encoded/context slots is required by Schema's variance for
-  // branded/Class schemas (e.g. `Todo`); only the decoded type `P` is used.
+  // Schema variance needs any in encoded/context; only decoded P is used
   // oxlint-disable-next-line reform-rules/no-optional-fields -- drives `Config extends { props: … }` inference (PropsOf)
-  readonly props?: Schema.Schema<any, any>
+  readonly props?: Schema.Schema.AnyNoContext
   // oxlint-disable-next-line reform-rules/no-optional-fields -- drives `Config extends { states: … }` inference (StatesOf)
   readonly states?: ReadonlyArray<unknown>
   // oxlint-disable-next-line reform-rules/no-optional-fields -- optional config field on a reflectable manifest carrier (see note above)
@@ -51,19 +37,12 @@ export interface CompositionConfig {
   readonly events?: ReadonlyArray<unknown>
   // oxlint-disable-next-line reform-rules/no-optional-fields -- optional config field on a reflectable manifest carrier (see note above)
   readonly slots?: Record<string, SlotClass>
-  // The UI contract this composition resolves. Typed as a manifest carrier (not
-  // the full `UiClass`, whose invariant `impl` tag would force the contract type
-  // to leak here) so reflection — the dev tool, proofs — can read `ui.manifest`.
+  // Manifest carrier only — full UiClass's invariant impl tag would leak C
   readonly ui: { readonly manifest: Manifest & { readonly kind: 'Ui' } }
 }
 
-type PropsOf<Config> = Config extends { props: Schema.Schema<infer P, any> } ? P : unknown
+type PropsOf<Config> = Config extends { props: Schema.Schema<infer P, AnyValue> } ? P : unknown
 
-/**
- * The composition's state-group tuple, recovered from the `const`-inferred config
- * so consumers can type its seeds. Erased to `readonly []` when no `states` are
- * declared; entries that are not state groups contribute no seed keys (`SeedsOf`).
- */
 type StatesOf<Config> = Config extends { states: infer S extends ReadonlyArray<unknown> }
   ? S
   : readonly []
@@ -75,41 +54,19 @@ export interface CompositionClass<
 > {
   new (): {}
   readonly manifest: Manifest & { readonly kind: 'Composition' } & CompositionConfig
-  /** Phantom carrying the props type for `provide(slot, composition)` checks. */
   readonly Props: P
-  /**
-   * Phantom carrying the resolved UI contract (props + events + slots). It lets
-   * reflection consumers — proofs, the dev tool — recover the full contract from
-   * a composition value and stay fully typed. Covariant (output only); the
-   * invariant `impl` tag is never stored here, so no variance regression.
-   */
   readonly Contract: C
-  /**
-   * Phantom carrying the state-group tuple, so `seedScene` can type a scene's
-   * seeds against the actual state members. Same erasure trick as `Contract`.
-   */
   readonly States: S
   readonly tag: Context.Tag<CompositionService, CompositionService>
 }
 
-/**
- * A component's logic. The *definition* (`Composition.make`) is a reflectable
- * manifest that doubles as a requirement/tag; the *implementation*
- * (`Composition.live`) is the synchronous body, provided separately and
- * checked against it.
- */
-/** The contract-carrying overlay on a composition config — keeps `C` inferable at
- *  the `Composition.make` call site while the stored manifest sees only the erased
- *  `{ manifest }` carrier. */
 interface UiCarrier<C extends UiContract> {
   readonly ui: UiClass<C>
 }
 
 export const make = <const Config extends CompositionConfig, C extends UiContract>(
   name: string,
-  // Constrain `ui` to the full `UiClass<C>` so `C` is inferred here; the stored
-  // manifest still sees only the erased `{ manifest }` carrier (CompositionConfig),
-  // so the manifest type — and its variance — is unchanged.
+  // Constrain ui to full UiClass<C> for inference; stored manifest keeps erased carrier
   config: Config & UiCarrier<C>,
 ): CompositionClass<PropsOf<Config>, C, StatesOf<Config>> => {
   const tag = Context.GenericTag<CompositionService, CompositionService>(
@@ -119,19 +76,11 @@ export const make = <const Config extends CompositionConfig, C extends UiContrac
   return definitionClass<CompositionClass<PropsOf<Config>, C, StatesOf<Config>>>({ manifest, tag })
 }
 
-/**
- * Wire a composition's synchronous logic (D2): read state, acquire triggers,
- * resolve the UI, return the view. Its requirements (minus `Props`, which the
- * host injects per render) surface as the Layer's `RIn`; the runtime runs the
- * body per render within the captured context.
- */
 export const live = <
   P,
   C extends UiContract,
   Eff extends YieldWrap<Effect.Effect<unknown, never, unknown>>,
 >(
-  // The contract `C` is captured (not erased to `any`) so the body's returned
-  // `Structure` is checked against the composition's contract.
   composition: CompositionClass<P, C>,
   body: () => Generator<Eff, Frame<C>, never>,
 ): Layer.Layer<CompositionService, never, Exclude<Ctx<Eff>, Props>> => {
@@ -139,16 +88,8 @@ export const live = <
   return Layer.effect(
     composition.tag,
     Effect.gen(function* () {
-      // Capture the build-time context (state stores, calc, ui, bus). `Props` and
-      // the tracker are injected per render below.
       const context = yield* Effect.context<Exclude<Ctx<Eff>, Props>>()
       const render = (env: RenderEnv): Effect.Effect<Frame, never, never> =>
-        // The per-render erasure seam: the body is total once fully provided (it is
-        // synchronous, reads can't fail, every requirement is now satisfied — D2) and
-        // its `Structure<C>` erases to the service's contract-agnostic `Frame`. `gen`
-        // widens the error channel to the body's inferred `E` for a generic body, so
-        // narrowing it (and the contract) back to the erased service type needs the
-        // `unknown` bridge — the one cast this render boundary has always required.
         // oxlint-disable-next-line reform-rules/no-type-assertion -- the one documented render-boundary erasure: a fully-provided generic body's Structure<C> narrowed back to the contract-agnostic Frame service type
         logic.pipe(
           Effect.provideService(Props, env.props),
@@ -160,6 +101,5 @@ export const live = <
   )
 }
 
-/** Run a mounted composition for one frame, producing its `Frame` (a `Structure`). */
 export const render = (service: CompositionService, env: RenderEnv): Effect.Effect<Frame, never, never> =>
   service.render(env)

package/src/compose/host.ts

@@ -1,11 +1,5 @@
 import type { Node } from './slot'
 
-/**
- * A slot handle the host hands a presentation: BOTH renderable (call it / use as a
- * component to place the keyed children) AND inspectable (`.props` — the array of
- * per-child fill props the structure carried, one entry per mounted child). The
- * structure host (`renderStructure`) populates `.props` from the fills. Plan 06.
- */
 export interface SlotRenderer {
   (props: unknown): Node
   readonly props: ReadonlyArray<unknown>

package/src/compose/props.ts

@@ -1,14 +1,8 @@
 import { Context } from 'effect'
+import type { AnyValue } from '../internal/variance'
 
-/**
- * The current composition instance's props. Bound per render by the runtime; a
- * composition body reads them with `const { todo } = yield* Props`.
- *
- * (Per-instance typing of Props is DESIGN #26 — for now the value is opaque and
- * narrowed at the use site against the composition's declared props schema.)
- */
-const PropsBase: Context.TagClass<Props, 'reform/Props', any> = Context.Tag('reform/Props')<
+const PropsBase: Context.TagClass<Props, 'reform/Props', AnyValue> = Context.Tag('reform/Props')<
   Props,
-  any
+  AnyValue
 >()
 export class Props extends PropsBase {}