@playfast/reform 0.0.7 → 0.0.8

package/{dist/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';
-import { type StoresOf } from '../internal/sources';
-import { FeatureLoadFailed } from '../internal/errors';
-import { type Manifest } from '../definition/definition';
-import { type CompositionClass } from '../compose/composition';
-import { type UiContract } from '../compose/ui';
-import { type Tagged } from '../runtime/bus';
+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';
  * 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/feature/feature.typecheck.ts

@@ -0,0 +1,108 @@
+// Type-level proofs enforced by `tsc --noEmit` over `src` (not a vitest file).
+// These guard the cast-free seam: if a guarantee regresses, a `@ts-expect-error`
+// goes unused or an assignment fails, and `tsc` breaks.
+
+import { Layer, Schema as S } from 'effect'
+import type { Store } from '../internal/store'
+import * as Composition from '../compose/composition'
+import { provide } from '../compose/provide'
+import { type SlotChild, type SlotClass, slot } from '../compose/slot'
+import { type Contract, type UiClass, ui } from '../compose/ui'
+import * as State from '../state/state'
+import * as StateGroup from '../state/stateGroup'
+import { type EngineServices, type FeatureModule, featureModule, lazyImport } from './feature'
+import * as Feature from './feature'
+
+const FeedStateBase: State.StateClass<'feed', string> = State.make('feed', S.String)
+class FeedState extends FeedStateBase {}
+const FilterStateBase: State.StateClass<'filter', string> = State.make('filter', S.String)
+class FilterState extends FilterStateBase {}
+const TodosStatesBase: StateGroup.StateGroupClass<readonly [typeof FeedState, typeof FilterState]> =
+  StateGroup.make(FeedState, FilterState)
+class TodosStates extends TodosStatesBase {}
+
+// --- featureModule: the covariant-RIn bound (cast-free requirement honesty) ---
+
+// A feature layer that reads FeedState's store and the shared engine — nothing else.
+declare const readsFeed: Layer.Layer<{ readonly _out: true }, never, Store<string> | EngineServices>
+
+// POSITIVE: declaring the State it reads in `requires` covers the read — compiles.
+export const okState: FeatureModule<{ readonly _out: true }, readonly [typeof FeedState]> =
+  featureModule([FeedState], readsFeed)
+
+// POSITIVE: a StateGroup contributes its members' stores via `ProvidedBy` — compiles.
+export const okGroup: FeatureModule<{ readonly _out: true }, readonly [typeof TodosStates]> =
+  featureModule([TodosStates], readsFeed)
+
+// NEGATIVE: empty `requires` provides only the engine, not Store<string>; covariant
+// `RIn` makes the layer unassignable to the declared bound.
+export const badEmpty: FeatureModule<{ readonly _out: true }, readonly []> =
+  // @ts-expect-error feature layer reads a store it does not declare in `requires`
+  featureModule([], readsFeed)
+
+// --- provide(slot, Feature): RIn surfacing + composition match ---
+
+const AppUiBase: UiClass<{ props: { readonly a: string }; events: {} }> = ui('AppUi')<{
+  props: { readonly a: string }
+  events: {}
+}>()
+class AppUi extends AppUiBase {}
+const AppCompBase: Composition.CompositionClass<{ readonly a: string }, Contract<typeof AppUi>> =
+  Composition.make('AppComp', {
+    title: 'App',
+    props: S.Struct({ a: S.String }),
+    ui: AppUi,
+  })
+class AppComp extends AppCompBase {}
+const AppSlotBase: SlotClass<typeof AppComp> = slot('App')<typeof AppComp>()
+class AppSlot extends AppSlotBase {}
+
+const AppFeatureBase: Feature.FeatureClass<
+  { readonly a: string },
+  Contract<typeof AppUi>,
+  never,
+  readonly []
+> = Feature.make('appFeature', {
+  loadingStrategy: 'lazy',
+  composition: AppComp,
+  load: lazyImport(() => Promise.resolve({ default: featureModule([], Layer.empty) })),
+  placeholder: { loading: AppComp, failed: AppComp },
+})
+class AppFeature extends AppFeatureBase {}
+
+// POSITIVE: the wired layer's open `RIn` is exactly `EngineServices` (requires=[]),
+// so a scene must provide `Core` — surfaced cast-free by the overload.
+export const wired: Layer.Layer<SlotChild, never, EngineServices> = provide(AppSlot, AppFeature)
+
+// A feature over a DIFFERENT contract must not fill `AppSlot`.
+const OtherUiBase: UiClass<{ props: { readonly n: number }; events: {} }> = ui('OtherUi')<{
+  props: { readonly n: number }
+  events: {}
+}>()
+class OtherUi extends OtherUiBase {}
+const OtherCompBase: Composition.CompositionClass<{ readonly n: number }, Contract<typeof OtherUi>> =
+  Composition.make('OtherComp', {
+    title: 'Other',
+    props: S.Struct({ n: S.Number }),
+    ui: OtherUi,
+  })
+class OtherComp extends OtherCompBase {}
+const OtherFeatureBase: Feature.FeatureClass<
+  { readonly n: number },
+  Contract<typeof OtherUi>,
+  never,
+  readonly []
+> = Feature.make('otherFeature', {
+  loadingStrategy: 'lazy',
+  composition: OtherComp,
+  load: lazyImport(() => Promise.resolve({ default: featureModule([], Layer.empty) })),
+  placeholder: { loading: OtherComp, failed: OtherComp },
+})
+class OtherFeature extends OtherFeatureBase {}
+
+// NEGATIVE: OtherFeature's composition props don't match AppSlot's child composition.
+// @ts-expect-error feature composition does not match the slot's child type
+export const mismatched: Layer.Layer<SlotChild, never, EngineServices> = provide(
+  AppSlot,
+  OtherFeature,
+)

package/src/index.ts

@@ -0,0 +1,176 @@
+// 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 {
+  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 SyncedStore from './synced/syncedStore'
+// Direct type re-export alongside the namespace (TS2742 nameability): adapters
+// (e.g. `@playfast/reform-db`) annotate the source handed to `SyncedStore.live`.
+export type { SyncedSource, SyncedStoreClass } from './synced/syncedStore'
+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 {
+  type DerivedContract,
+  isUi,
+  type LogicView,
+  type MadeView,
+  ui,
+  type UiClass,
+  type UiContract,
+  type UiManifest,
+  UiTypeId,
+  UiViewContract,
+  type ViewImpl,
+  type WireSchemas,
+  type WiredUi,
+  type WiredUiManifest,
+} from './compose/ui'
+export { provide } from './compose/provide'
+export type { Trigger } from './ui/trigger'
+
+// Wire: the serializable rendered-tree model + pure diff/apply the remote
+// transport sends over the wire and the client folds back. See REMOTE_UI.md §3.
+export * as Wire from './wire/tree'
+export type { WireNode, WirePatch, WireProp, WireTree } from './wire/tree'
+
+// Triggers: the server-side handle registry bridging client trigger invocations
+// back to live triggers, decoding payloads via the event schema. See REMOTE_UI.md §4.
+export * as Triggers from './wire/triggers'
+export {
+  TriggerRegistry,
+  type TriggerHandle,
+  type TriggerRegistryApi,
+  UnknownTrigger,
+} from './wire/triggers'
+
+// 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,
+  AsyncSceneLayer,
+  DuplicateRegistration,
+  FeatureLoadFailed,
+  forceSync,
+  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,
+  resolveScheduler,
+  type Scheduler,
+} from './internal/scheduler'
+export { makeStore, type Store } from './internal/store'
+export type { FamilyStore } from './state/stateFamily'
+// Primitive-authoring toolkit — exported for first-party companion packages
+// (e.g. `@playfast/reform-db`, `@playfast/reform-resource`) that build their own
+// first-class `Source`s which must participate in dependency tracking and
+// reflection exactly like a `Calc`.
+export { type Kind, type Manifest, yieldableClass } from './definition/definition'
+export { readTracked } from './internal/track'
+export { sameKey, wireSources, type WiredSources } from './internal/sources'