@playfast/reform 0.0.1 → 0.0.3

package/{dist/dts/feature/feature.d.ts → src/feature/feature.ts}

@@ -1,11 +1,19 @@
-import { type Context, Effect, Layer, type Scope } from 'effect';
-import { type Engine } from '../runtime/loop.js';
-import { type StoresOf } from '../internal/sources.js';
-import { FeatureLoadFailed } from '../internal/errors.js';
-import { type Manifest } from '../definition/definition.js';
-import { type CompositionClass } from '../compose/composition.js';
-import { type UiContract } from '../compose/ui.js';
-import { type Tagged } from '../runtime/bus.js';
+import { type Context, Effect, Layer, type Scope } from 'effect'
+import { type Engine } from '../runtime/loop'
+import { type StoresOf } from '../internal/sources'
+import { FeatureLoadFailed } from '../internal/errors'
+import { type Manifest, definitionClass } from '../definition/definition'
+import { type CompositionClass } from '../compose/composition'
+import { type UiContract } from '../compose/ui'
+import { publish, type Tagged } from '../runtime/bus'
+
+// A `Feature` is the unit of lazy code-split, ownership, reflection, and proof.
+// It splits on the seam Reform already has: definitions (manifests, schemas, the
+// composition class, placeholders) stay eager and reflectable; the heavy `.live`
+// layer loads on demand. The whole-app *shape* stays inspectable with no chunk
+// loaded. Everything here is additive — `provide(slot, Composition)` and eager
+// scenes are unchanged. See `LAZY.md` for the design rationale and variance proof.
+
 /**
  * The always-on engine services a feature builds against: the shared event `Bus`
  * plus the reducer/channel/procedure registries. Derived from the `Engine`
@@ -13,20 +21,18 @@ import { type Tagged } from '../runtime/bus.js';
  * these only as OPEN requirements (its `RIn`) and must never *provide* them — that
  * is what keeps the engine single and shared across every lazily-mounted feature.
  */
-export type EngineServices = Layer.Layer.Success<typeof Engine>;
+export type EngineServices = Layer.Layer.Success<typeof Engine>
+
 /**
  * A shared-state carrier a feature may declare in `requires`: a `State`,
  * `StateFamily`, `Calc`, or `AsyncCalc` (each carrying a `store` tag), or a
  * `StateGroup` (carrying `members`, each with its own `store`). Per the design,
  * a feature depends on shared state/calc only — never on another feature.
  */
-export type RequireCarrier = {
-    readonly store: Context.Tag<any, any>;
-} | {
-    readonly members: ReadonlyArray<{
-        readonly store: Context.Tag<any, any>;
-    }>;
-};
+export type RequireCarrier =
+  | { readonly store: Context.Tag<any, any> }
+  | { readonly members: ReadonlyArray<{ readonly store: Context.Tag<any, any> }> }
+
 /**
  * The Context services a `requires` tuple makes available to a feature layer: a
  * `StateGroup` contributes its members' stores (the shared `StoresOf`); every
@@ -37,12 +43,15 @@ export type RequireCarrier = {
  * is ordinary assignability — no `as`, no `infer` gymnastics in user code.
  */
 export type ProvidedBy<Requires extends ReadonlyArray<RequireCarrier>> = {
-    [I in keyof Requires]: Requires[I] extends {
-        readonly members: infer M extends ReadonlyArray<unknown>;
-    } ? StoresOf<M> : Requires[I] extends {
-        readonly store: Context.Tag<infer Svc, any>;
-    } ? Svc : never;
-}[number];
+  [I in keyof Requires]: Requires[I] extends {
+    readonly members: infer M extends ReadonlyArray<unknown>
+  }
+    ? StoresOf<M>
+    : Requires[I] extends { readonly store: Context.Tag<infer Svc, any> }
+      ? Svc
+      : never
+}[number]
+
 /**
  * A loaded feature's two artifacts. `requires` is the runtime-enumerable list the
  * editor reads (types are erased, so the carriers are kept as values); `layer` is
@@ -53,9 +62,10 @@ export type ProvidedBy<Requires extends ReadonlyArray<RequireCarrier>> = {
  * a feature's lazy half.
  */
 export interface FeatureModule<ROut, Requires extends ReadonlyArray<RequireCarrier>> {
-    readonly requires: Requires;
-    readonly layer: Layer.Layer<ROut, never, EngineServices | ProvidedBy<Requires>>;
+  readonly requires: Requires
+  readonly layer: Layer.Layer<ROut, never, EngineServices | ProvidedBy<Requires>>
 }
+
 /**
  * Publish a feature's lazy half: pair its `requires` (a runtime tuple of shared
  * carriers) with its `layer`. The covariant `RIn` bound does the checking — a
@@ -67,7 +77,11 @@ export interface FeatureModule<ROut, Requires extends ReadonlyArray<RequireCarri
  * be open `RIn`), structurally enforcing the liveness rule: a feature can never
  * bundle its own engine — it always shares the root's bus and registries.
  */
-export declare const featureModule: <const Requires extends ReadonlyArray<RequireCarrier>, ROut>(requires: Requires, layer: Layer.Layer<ROut, never, EngineServices | ProvidedBy<Requires>>) => FeatureModule<ROut, Requires>;
+export const featureModule = <const Requires extends ReadonlyArray<RequireCarrier>, ROut>(
+  requires: Requires,
+  layer: Layer.Layer<ROut, never, EngineServices | ProvidedBy<Requires>>,
+): FeatureModule<ROut, Requires> => ({ requires, layer })
+
 /**
  * Wrap a dynamic `import()` of a feature's `.live` module as an `Effect` — Reform
  * never exposes a Promise/`await` on the feature surface. The unavoidable thenable
@@ -75,14 +89,20 @@ export declare const featureModule: <const Requires extends ReadonlyArray<Requir
  * throw) surfaces as a typed `FeatureLoadFailed` the host hands to
  * `placeholder.failed`. The module's default export is its `FeatureModule`.
  */
-export declare const lazyImport: <M>(thunk: () => Promise<{
-    readonly default: M;
-}>) => Effect.Effect<M, FeatureLoadFailed>;
+export const lazyImport = <M>(
+  thunk: () => Promise<{ readonly default: M }>,
+): Effect.Effect<M, FeatureLoadFailed> =>
+  Effect.tryPromise({
+    try: thunk,
+    catch: (cause) => new FeatureLoadFailed({ cause }),
+  }).pipe(Effect.map((module) => module.default))
+
 /** The props the host injects into a lazy feature's `failed` placeholder. */
 export interface FailedProps {
-    readonly error: FeatureLoadFailed;
-    readonly retry: () => void;
+  readonly error: FeatureLoadFailed
+  readonly retry: () => void
 }
+
 /**
  * The reflectable shape of a feature: its strategy, the composition it mounts,
  * and (when lazy) its placeholder compositions — all as manifests, so the editor
@@ -90,21 +110,16 @@ export interface FailedProps {
  * runtime data and lives on the `FeatureBinding`, not here.
  */
 export interface FeatureManifest extends Manifest {
-    readonly kind: 'Feature';
-    readonly name: string;
-    readonly strategy: 'lazy' | 'default';
-    readonly composition: Manifest & {
-        readonly kind: 'Composition';
-    };
-    readonly placeholder?: {
-        readonly loading: Manifest & {
-            readonly kind: 'Composition';
-        };
-        readonly failed: Manifest & {
-            readonly kind: 'Composition';
-        };
-    };
+  readonly kind: 'Feature'
+  readonly name: string
+  readonly strategy: 'lazy' | 'default'
+  readonly composition: Manifest & { readonly kind: 'Composition' }
+  readonly placeholder?: {
+    readonly loading: Manifest & { readonly kind: 'Composition' }
+    readonly failed: Manifest & { readonly kind: 'Composition' }
+  }
 }
+
 /**
  * A feature's loaded artifacts with type params erased, for the renderer-neutral,
  * strategy-uniform host. The erasure is cast-free *into*: because `Layer`'s `ROut`
@@ -114,12 +129,14 @@ export interface FeatureManifest extends Manifest {
  * documented boundary cast there, mirroring `buildRuntime`).
  */
 export interface LoadedModule {
-    readonly requires: ReadonlyArray<RequireCarrier>;
-    readonly layer: Layer.Layer<never, never, unknown>;
+  readonly requires: ReadonlyArray<RequireCarrier>
+  readonly layer: Layer.Layer<never, never, unknown>
 }
+
 /** Nominal brand identifying the value a `provide(slot, Feature)` puts under a slot tag. */
-export declare const FeatureBindingTypeId: unique symbol;
-export type FeatureBindingTypeId = typeof FeatureBindingTypeId;
+export const FeatureBindingTypeId: unique symbol = Symbol.for('reform/FeatureBinding')
+export type FeatureBindingTypeId = typeof FeatureBindingTypeId
+
 /**
  * What `provide(slot, Feature)` binds under the slot tag — everything the host
  * needs to mount the feature, with types erased (the host is renderer-neutral and
@@ -130,19 +147,22 @@ export type FeatureBindingTypeId = typeof FeatureBindingTypeId;
  * each.
  */
 export interface FeatureBinding {
-    readonly [FeatureBindingTypeId]: FeatureBindingTypeId;
-    readonly manifest: FeatureManifest;
-    readonly composition: CompositionClass<unknown>;
-    readonly strategy: 'lazy' | 'default';
-    readonly load: Effect.Effect<LoadedModule, FeatureLoadFailed>;
-    readonly placeholder?: {
-        readonly loading: CompositionClass<unknown>;
-        readonly failed: CompositionClass<unknown>;
-    };
-    readonly boot: ReadonlyArray<Tagged>;
+  readonly [FeatureBindingTypeId]: FeatureBindingTypeId
+  readonly manifest: FeatureManifest
+  readonly composition: CompositionClass<unknown>
+  readonly strategy: 'lazy' | 'default'
+  readonly load: Effect.Effect<LoadedModule, FeatureLoadFailed>
+  readonly placeholder?: {
+    readonly loading: CompositionClass<unknown>
+    readonly failed: CompositionClass<unknown>
+  }
+  readonly boot: ReadonlyArray<Tagged>
 }
+
 /** Whether a slot's bound child is a lazy/eager feature (vs a plain composition). */
-export declare const isFeatureBinding: (u: unknown) => u is FeatureBinding;
+export const isFeatureBinding = (u: unknown): u is FeatureBinding =>
+  typeof u === 'object' && u !== null && FeatureBindingTypeId in u
+
 /**
  * A feature *definition*: a reflectable manifest (`kind: 'Feature'`) that carries
  * the eager half (composition + placeholders) and an Effect `load` for the heavy
@@ -150,25 +170,37 @@ export declare const isFeatureBinding: (u: unknown) => u is FeatureBinding;
  * shared-carrier tuple the loaded module declares. `load` is an `Effect`, never a
  * Promise — consumers `yield* Feature.load`.
  */
-export interface FeatureClass<P, C extends UiContract, ROut, Requires extends ReadonlyArray<RequireCarrier>> {
-    new (): {};
-    readonly manifest: FeatureManifest;
-    /** Phantom carrying the mounted composition's props type (for `provide` checks). */
-    readonly Props: P;
-    /** Phantom carrying the composition's UI contract (for typed reflection consumers). */
-    readonly Contract: C;
-    /** Phantom carrying the declared shared-carrier tuple. */
-    readonly Requires: Requires;
-    /** Load the feature's module — `yield* Feature.load` → its `FeatureModule`, or `FeatureLoadFailed`. */
-    readonly load: Effect.Effect<FeatureModule<ROut, Requires>, FeatureLoadFailed>;
-    /** The value `provide(slot, Feature)` binds under the slot tag. */
-    readonly binding: FeatureBinding;
-    /** The eagerly-available module — present only for `loadingStrategy: 'default'`. */
-    readonly eagerModule: FeatureModule<ROut, Requires> | undefined;
+export interface FeatureClass<
+  P,
+  C extends UiContract,
+  ROut,
+  Requires extends ReadonlyArray<RequireCarrier>,
+> {
+  new (): {}
+  readonly manifest: FeatureManifest
+  /** Phantom carrying the mounted composition's props type (for `provide` checks). */
+  readonly Props: P
+  /** Phantom carrying the composition's UI contract (for typed reflection consumers). */
+  readonly Contract: C
+  /** Phantom carrying the declared shared-carrier tuple. */
+  readonly Requires: Requires
+  /** Load the feature's module — `yield* Feature.load` → its `FeatureModule`, or `FeatureLoadFailed`. */
+  readonly load: Effect.Effect<FeatureModule<ROut, Requires>, FeatureLoadFailed>
+  /** The value `provide(slot, Feature)` binds under the slot tag. */
+  readonly binding: FeatureBinding
+  /** The eagerly-available module — present only for `loadingStrategy: 'default'`. */
+  readonly eagerModule: FeatureModule<ROut, Requires> | undefined
 }
-export type AnyFeature = FeatureClass<any, any, any, ReadonlyArray<RequireCarrier>>;
+
+export type AnyFeature = FeatureClass<any, any, any, ReadonlyArray<RequireCarrier>>
+
 /** Whether a value is a feature definition (its target shape in `provide(slot, Feature)`). */
-export declare const isFeature: (u: unknown) => u is AnyFeature;
+export const isFeature = (u: unknown): u is AnyFeature =>
+  (typeof u === 'function' || typeof u === 'object') &&
+  u !== null &&
+  'manifest' in u &&
+  (u as { readonly manifest: { readonly kind?: unknown } }).manifest?.kind === 'Feature'
+
 /**
  * The placeholders a lazy feature must ship — both eager compositions (their
  * `.live` is in the eager bundle, so they paint the load gap). `loading` receives
@@ -177,20 +209,28 @@ export declare const isFeature: (u: unknown) => u is AnyFeature;
  * are not schema-decoded inputs.
  */
 export interface Placeholders {
-    readonly loading: CompositionClass<any, UiContract>;
-    readonly failed: CompositionClass<any, UiContract>;
+  readonly loading: CompositionClass<any, UiContract>
+  readonly failed: CompositionClass<any, UiContract>
 }
+
 type FeatureConfig<P, C extends UiContract, ROut, Requires extends ReadonlyArray<RequireCarrier>> = {
-    readonly composition: CompositionClass<P, C>;
-    readonly boot?: ReadonlyArray<Tagged>;
-} & ({
-    readonly loadingStrategy?: 'default';
-    readonly module: FeatureModule<ROut, Requires>;
-} | {
-    readonly loadingStrategy: 'lazy';
-    readonly load: Effect.Effect<FeatureModule<ROut, Requires>, FeatureLoadFailed>;
-    readonly placeholder: Placeholders;
-});
+  readonly composition: CompositionClass<P, C>
+  readonly boot?: ReadonlyArray<Tagged>
+} & (
+  | {
+      // EAGER: the module is statically present and merged into the runtime at
+      // boot. No load gap, so no placeholder.
+      readonly loadingStrategy?: 'default'
+      readonly module: FeatureModule<ROut, Requires>
+    }
+  | {
+      // LAZY: the module loads on mount via an Effect. Placeholders required.
+      readonly loadingStrategy: 'lazy'
+      readonly load: Effect.Effect<FeatureModule<ROut, Requires>, FeatureLoadFailed>
+      readonly placeholder: Placeholders
+    }
+)
+
 /**
  * Define a feature. The whole-app shape (this manifest, the composition, the
  * placeholders) stays eager and reflectable; the `.live` layer in `module`/`load`
@@ -198,7 +238,41 @@ type FeatureConfig<P, C extends UiContract, ROut, Requires extends ReadonlyArray
  * the discriminated config *requires* `placeholder` — the compiler walks you to a
  * complete code-split feature.
  */
-export declare const make: <P, C extends UiContract, ROut, Requires extends ReadonlyArray<RequireCarrier>>(name: string, config: FeatureConfig<P, C, ROut, Requires>) => FeatureClass<P, C, ROut, Requires>;
+export const make = <P, C extends UiContract, ROut, Requires extends ReadonlyArray<RequireCarrier>>(
+  name: string,
+  config: FeatureConfig<P, C, ROut, Requires>,
+): FeatureClass<P, C, ROut, Requires> => {
+  const strategy: 'lazy' | 'default' = config.loadingStrategy ?? 'default'
+  const load: Effect.Effect<FeatureModule<ROut, Requires>, FeatureLoadFailed> =
+    'load' in config ? config.load : Effect.succeed(config.module)
+  const eagerModule = 'module' in config ? config.module : undefined
+  const placeholder = 'placeholder' in config ? config.placeholder : undefined
+
+  const manifest: FeatureManifest = {
+    kind: 'Feature',
+    name,
+    strategy,
+    composition: config.composition.manifest,
+    ...(placeholder
+      ? { placeholder: { loading: placeholder.loading.manifest, failed: placeholder.failed.manifest } }
+      : {}),
+  }
+
+  const binding: FeatureBinding = {
+    [FeatureBindingTypeId]: FeatureBindingTypeId,
+    manifest,
+    composition: config.composition,
+    strategy,
+    // The host is strategy-uniform: `default`'s `load` resolves immediately. The
+    // assignment to the erased `LoadedModule` needs no cast — see `LoadedModule`.
+    load,
+    ...(placeholder ? { placeholder: { loading: placeholder.loading, failed: placeholder.failed } } : {}),
+    boot: config.boot ?? [],
+  }
+
+  return definitionClass<FeatureClass<P, C, ROut, Requires>>({ manifest, load, binding, eagerModule })
+}
+
 /**
  * Mount a feature against a live engine. The renderer-neutral lifecycle, run on a
  * per-feature `Scope`: load the module (an Effect — lazy = dynamic import; default
@@ -215,6 +289,18 @@ export declare const make: <P, C extends UiContract, ROut, Requires extends Read
  * we re-attach the concrete `engineContext` it builds against. `R` is the engine
  * context's service set, supplied by the host.
  */
-export declare const mountFeature: <R>(binding: FeatureBinding, engineContext: Context.Context<R>) => Effect.Effect<Context.Context<unknown>, FeatureLoadFailed, Scope.Scope>;
-export {};
-//# sourceMappingURL=feature.d.ts.map
+export const mountFeature = <R>(
+  binding: FeatureBinding,
+  engineContext: Context.Context<R>,
+): Effect.Effect<Context.Context<unknown>, FeatureLoadFailed, Scope.Scope> =>
+  Effect.gen(function* () {
+    const { layer } = yield* binding.load
+    const featureLayer = layer as Layer.Layer<unknown, never, R>
+    const context = yield* Layer.build(
+      Layer.provideMerge(featureLayer, Layer.succeedContext(engineContext)),
+    )
+    yield* Effect.forEach(binding.boot, (event) => publish('High', event), { discard: true }).pipe(
+      Effect.provide(context),
+    )
+    return context
+  })

package/src/index.ts

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

package/{dist/dts/internal/capture.d.ts → src/internal/capture.ts}

@@ -1,20 +1,22 @@
-import { Context } from 'effect';
-import type { Trigger } from '../ui/trigger.js';
+import { Context } from 'effect'
+import type { Trigger } from '../ui/trigger'
+
 /**
  * A single rendered UI node's observable surface: which contract rendered, the
  * props it received, and the event triggers it was handed. This is exactly what
  * a headless inspector (the proof facade, the dev tool) needs — no DOM, no JSX.
  */
 export interface UiCapture {
-    readonly name: string;
-    readonly props: unknown;
-    readonly events: Record<string, Trigger<unknown>>;
+  readonly name: string
+  readonly props: unknown
+  readonly events: Record<string, Trigger<unknown>>
 }
+
 /** Where captured renders are reported, when a capturing host is present. */
 export interface CaptureSinkApi {
-    record(capture: UiCapture): void;
+  record(capture: UiCapture): void
 }
-declare const CaptureSink_base: Context.TagClass<CaptureSink, "reform/internal/CaptureSink", CaptureSinkApi>;
+
 /**
  * An OPTIONAL service. Core's `ui` read consults it via `serviceOption`: when a
  * capturing host provides it (proofs, the dev tool), every resolved view reports
@@ -22,7 +24,7 @@ declare const CaptureSink_base: Context.TagClass<CaptureSink, "reform/internal/C
  * replacing any presentation. Production never provides it, so nothing is
  * recorded and there is no cost beyond one `serviceOption` lookup per render.
  */
-export declare class CaptureSink extends CaptureSink_base {
-}
-export {};
-//# sourceMappingURL=capture.d.ts.map
+export class CaptureSink extends Context.Tag('reform/internal/CaptureSink')<
+  CaptureSink,
+  CaptureSinkApi
+>() {}

package/{dist/dts/internal/ctx.d.ts → src/internal/ctx.ts}

@@ -1,5 +1,6 @@
-import type { Effect } from 'effect';
-import type { YieldWrap } from 'effect/Utils';
+import type { Effect } from 'effect'
+import type { YieldWrap } from 'effect/Utils'
+
 /**
  * The context (`R`) a generator body requires, recovered from the effects it
  * yields. Shared by `Composition.live` and `Procedure.live`, whose bodies are
@@ -8,5 +9,8 @@ import type { YieldWrap } from 'effect/Utils';
  * A body that never yields (`Eff = never`) requires nothing — guard that case
  * first, or `infer R` resolves to `unknown` and leaks into the layer's `RIn`.
  */
-export type Ctx<Eff> = [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Effect.Effect<any, any, infer R>>] ? R : never;
-//# sourceMappingURL=ctx.d.ts.map
+export type Ctx<Eff> = [Eff] extends [never]
+  ? never
+  : [Eff] extends [YieldWrap<Effect.Effect<any, any, infer R>>]
+    ? R
+    : never