@playfast/reform 1.0.1 → 1.2.0

package/src/feature/feature.ts

@@ -1,94 +1,227 @@
-import { type Context, Effect, Layer, Option, 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 { Context, Effect, Layer, Option, Schema, type Scope } from 'effect'
+import {
+  type AnyComposition,
+  CompositionIdTypeId,
+  type CompositionClass,
+  type HasExactCompositionId,
+  type CompositionPropsReceiver,
+} 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`
- * layer's output (`runtime/loop.ts`) so it never drifts. A feature layer may name
- * 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>
-
-/**
- * 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.
- */
+import { type Manifest, definitionClass } from '../definition/definition'
+import {
+  type AnyFeatureGraphSummary,
+  type FeatureGraphSummary,
+  FeatureGraphSummaryTypeId,
+  FeatureGraphValidTypeId,
+  FeatureChildSummaryTypeId,
+  FeatureModuleGraphValidTypeId,
+  type FeatureSummaryCompositionIdentity,
+  type FeatureSummaryCompositionProps,
+  type FeatureSummaryContract,
+  type FeatureSummaryInput,
+  type FeatureSummaryName,
+  type FeatureSummaryOpenServices,
+  type FeatureSummaryStates,
+  type FeatureSummarySupportOpenServices,
+  type FeatureSummaryUsesInput,
+  type ModuleOpenServices,
+  type OpenServicesFromFeatureSlotWitnesses,
+  SlotBindingSummaryTypeId,
+  type ValidateFeatureGraphLayer,
+} from '../graph/closure'
+import { FeatureLoadFailed } from '../internal/errors'
+import { Bus, publish, type Tagged } from '../runtime/bus'
+import { type EngineServices } from '../runtime/loop'
+
+export type { EngineServices } from '../runtime/loop'
+export { FeatureGraphValidTypeId }
+
+const FeatureInputBase: Context.TagClass<FeatureInput, 'reform/FeatureInput', unknown> =
+  Context.Tag('reform/FeatureInput')<FeatureInput, unknown>()
+export class FeatureInput extends FeatureInputBase {}
+
+// Context.Tag is invariant, so erased requirements use its structural identity carrier.
+interface FeatureServiceTag<out Identifier = unknown, out Service = unknown> {
+  readonly [Context.TagTypeId]: object
+  readonly Identifier: Identifier
+  readonly Service: Service
+}
+
+interface StoredFeatureRequirement<out Identifier = unknown, out Service = unknown> {
+  readonly store: FeatureServiceTag<Identifier, Service>
+}
+
 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
- * other carrier contributes its own `store` service. This is the upper bound a
- * feature's open `RIn` is checked against. Because `Layer`'s `RIn` is covariant
- * (`Layer.d.ts` — `out RIn`), a layer that reads anything outside
- * `EngineServices | ProvidedBy<requires>` is simply not assignable, so the check
- * 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>
+  | StoredFeatureRequirement
+  | {
+      readonly members: ReadonlyArray<StoredFeatureRequirement>
+    }
+
+export type FeatureRequirement = RequireCarrier | FeatureServiceTag
+
+type TagRequirement<Tag> =
+  Tag extends FeatureServiceTag<infer Identifier, infer _Service> ? Identifier : never
+
+type StoredRequirementIdentifier<Carrier> = Carrier extends {
+  readonly store: infer Tag
+}
+  ? TagRequirement<Tag>
+  : never
+
+type RequirementIdentifier<Requirement> = Requirement extends FeatureServiceTag
+  ? TagRequirement<Requirement>
+  : Requirement extends {
+        readonly members: infer Members extends ReadonlyArray<StoredFeatureRequirement>
+      }
+    ? StoredRequirementIdentifier<Members[number]>
+    : StoredRequirementIdentifier<Requirement>
+
+export type ProvidedBy<Requires extends ReadonlyArray<FeatureRequirement>> = RequirementIdentifier<
+  Requires[number]
+>
+
+type DefaultFeatureOpenServices<ROut, DirectRequires extends ReadonlyArray<FeatureRequirement>> =
+  | ProvidedBy<DirectRequires>
+  | OpenServicesFromFeatureSlotWitnesses<ROut>
+
+type CompositionNames<ROut> = ROut extends {
+  readonly [CompositionIdTypeId]: {
+    readonly name: infer Name extends string
+  }
+}
+  ? Name
+  : never
+
+type CompositionIdentities<ROut> = ROut extends {
+  readonly [CompositionIdTypeId]: {
+    readonly identity: infer Identity
   }
-    ? 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
- * the heavy `.live` half. The bound on `layer`'s `RIn` —
- * `EngineServices | ProvidedBy<Requires>` — makes the runtime list provably equal
- * the layer's real requirement set: list too little and the layer no longer type-
- * checks here. Built by `featureModule`, which is the one sanctioned way to publish
- * 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>>
-}
-
-/**
- * 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
- * layer that reaches for any service outside `EngineServices | ProvidedBy<requires>`
- * is not assignable, so it fails to compile right here, next to the layer, with no
- * cast. Listing an unused carrier is harmless; omitting a needed one is a type error.
- *
- * The bound also forbids a feature from *providing* `EngineServices` (they may only
- * 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 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
- * is sealed here; a rejected import (missing chunk, network failure, module-eval
- * throw) surfaces as a typed `FeatureLoadFailed` the host hands to
- * `placeholder.failed`. The module's default export is its `FeatureModule`.
- */
+}
+  ? Identity
+  : never
+
+type RootCompositionName<ROut> = [CompositionNames<ROut>] extends [never]
+  ? string
+  : CompositionNames<ROut>
+
+type RootCompositionIdentity<ROut> = [CompositionIdentities<ROut>] extends [never]
+  ? unknown
+  : CompositionIdentities<ROut>
+
+// Feature layers may require the shared engine but must never provide it.
+export type FeatureModuleInput<OpenServices, UsesInput extends boolean> =
+  | EngineServices
+  | OpenServices
+  | (UsesInput extends true ? FeatureInput : never)
+
+export interface FeatureModule<
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices = DefaultFeatureOpenServices<ROut, DirectRequires>,
+  UsesInput extends boolean = false,
+  Input = never,
+> extends AnyLoadedModule {
+  readonly [FeatureModuleGraphValidTypeId]: FeatureModuleGraphValidTypeId
+  readonly requires: DirectRequires
+  readonly usesInput: UsesInput
+  readonly layer: Layer.Layer<ROut, never, FeatureModuleInput<OpenServices, UsesInput>>
+  readonly inputSchema: UsesInput extends true ? Schema.Schema.AnyNoContext : undefined
+  readonly Input: (input: Input) => void
+}
+
+export type LoadedModuleCapture<Result> = <
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices,
+  UsesInput extends boolean,
+  Input,
+>(
+  module: LoadedModule<ROut, DirectRequires, OpenServices, UsesInput, Input>,
+) => Result
+
+export interface AnyLoadedModule {
+  readonly capture: <Result>(visit: LoadedModuleCapture<Result>) => Result
+}
+
+type FeatureLayerOutput<L extends Layer.Layer.Any> = Layer.Layer.Success<L>
+
+// Reject erased contexts before graph validation can mistake them for permissive inputs.
+type ExactFeatureLayer<L extends Layer.Layer.Any, UsesInput extends boolean> = Layer.Layer<
+  FeatureLayerOutput<L>,
+  never,
+  FeatureModuleInput<ModuleOpenServices<L, UsesInput>, UsesInput>
+> &
+  (unknown extends Layer.Layer.Context<L>
+    ? {
+        readonly featureLayerContextMustBeExact: 'A feature layer context cannot be erased'
+      }
+    : object)
+
+export const featureModule = <
+  const DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  L extends Layer.Layer.Any,
+>(
+  requires: DirectRequires,
+  layer: L & ExactFeatureLayer<L, false> & ValidateFeatureGraphLayer<L, DirectRequires, false>,
+): FeatureModule<
+  FeatureLayerOutput<L>,
+  DirectRequires,
+  ModuleOpenServices<L, false>,
+  false,
+  never
+> => {
+  const module: FeatureModule<
+    FeatureLayerOutput<L>,
+    DirectRequires,
+    ModuleOpenServices<L, false>,
+    false,
+    never
+  > = {
+    [FeatureModuleGraphValidTypeId]: FeatureModuleGraphValidTypeId,
+    requires,
+    usesInput: false,
+    layer,
+    inputSchema: undefined,
+    Input: () => undefined,
+    capture: <Result>(visit: LoadedModuleCapture<Result>): Result => visit(module),
+  }
+  return module
+}
+
+export const featureModuleFromInput = <
+  const InputSchema extends Schema.Schema.AnyNoContext,
+  const DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  L extends Layer.Layer.Any,
+>(
+  input: InputSchema,
+  requires: DirectRequires,
+  layer: L & ExactFeatureLayer<L, true> & ValidateFeatureGraphLayer<L, DirectRequires, true>,
+): FeatureModule<
+  FeatureLayerOutput<L>,
+  DirectRequires,
+  ModuleOpenServices<L, true>,
+  true,
+  Schema.Schema.Type<InputSchema>
+> => {
+  const module: FeatureModule<
+    FeatureLayerOutput<L>,
+    DirectRequires,
+    ModuleOpenServices<L, true>,
+    true,
+    Schema.Schema.Type<InputSchema>
+  > = {
+    [FeatureModuleGraphValidTypeId]: FeatureModuleGraphValidTypeId,
+    requires,
+    usesInput: true,
+    layer,
+    inputSchema: input,
+    Input: () => undefined,
+    capture: <Result>(visit: LoadedModuleCapture<Result>): Result => visit(module),
+  }
+  return module
+}
+
+// Seal dynamic imports as typed Effects so chunk failures become FeatureLoadFailed.
 export const lazyImport = <M>(
   thunk: () => Promise<{ readonly default: M }>,
 ): Effect.Effect<M, FeatureLoadFailed> =>
@@ -97,18 +230,11 @@ export const lazyImport = <M>(
     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
 }
 
-/**
- * The reflectable shape of a feature: its strategy, the composition it mounts,
- * and (when lazy) its placeholder compositions — all as manifests, so the editor
- * route-map renders the whole feature graph with no chunk loaded. `boot` is
- * runtime data and lives on the `FeatureBinding`, not here.
- */
 export interface FeatureManifest extends Manifest {
   readonly kind: 'Feature'
   readonly name: string
@@ -120,201 +246,1166 @@ export interface FeatureManifest extends Manifest {
   }>
 }
 
-/**
- * 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`
- * is contravariant and `RIn` covariant, every `Layer<ROut, never, R>` is assignable
- * to `Layer<never, never, unknown>`, so any `FeatureModule<…>` is a `LoadedModule`.
- * The host re-attaches the concrete root context when it builds `layer` (one
- * documented boundary cast there, mirroring `buildRuntime`).
- */
-export interface LoadedModule {
-  readonly requires: ReadonlyArray<RequireCarrier>
-  readonly layer: Layer.Layer<never, never, unknown>
-}
+export interface LoadedModule<
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices = DefaultFeatureOpenServices<ROut, DirectRequires>,
+  UsesInput extends boolean = false,
+  Input = never,
+> extends FeatureModule<ROut, DirectRequires, OpenServices, UsesInput, Input> {}
 
-/** Nominal brand identifying the value a `provide(slot, Feature)` puts under a slot tag. */
 export const FeatureBindingTypeId: unique symbol = Symbol.for('reform/FeatureBinding')
 export type FeatureBindingTypeId = typeof FeatureBindingTypeId
+export type FeatureBindingType = FeatureBindingTypeId
+
+const FeatureTokenIdentityTypeId: unique symbol = Symbol('reform/FeatureTokenIdentity')
+const FeatureNativeTypeId: unique symbol = Symbol('reform/FeatureNative')
 
-/**
- * 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
- * strategy-uniform). For `default` the host renders `composition` directly; for
- * `lazy` it drives `load` through an `AsyncData` lifecycle, painting `placeholder`
- * around it. The `composition`/`placeholder` here are the same `CompositionClass`
- * values a normal slot fill carries, so the host's existing `Compose` path renders
- * each.
- */
-export interface FeatureBinding {
+export interface FeatureIdentityToken<out FeatureIdentity> {
+  readonly identity: symbol
+  readonly [FeatureTokenIdentityTypeId]: readonly [] | readonly [FeatureIdentity]
+}
+
+export interface FeatureToken<
+  out FeatureIdentity,
+  out NativeTree extends object,
+> extends FeatureIdentityToken<FeatureIdentity> {
+  readonly [FeatureNativeTypeId]: NativeTree
+}
+
+export interface FeatureTreeCarrier {
+  readonly token: FeatureToken<unknown, object>
+}
+
+type Native<
+  Feature extends FeatureTreeCarrier,
+  Token extends Feature['token'] = Feature['token'],
+> = Token[typeof FeatureNativeTypeId]
+
+export const tree = <
+  Feature extends FeatureTreeCarrier,
+  Token extends Feature['token'] = Feature['token'],
+>(
+  token: Token,
+): Native<Feature, Token> => token[FeatureNativeTypeId]
+
+export interface ProvideableFeature<
+  out FeatureIdentity,
+  out Summary extends AnyFeatureGraphSummary,
+> {
+  new (): {}
+  readonly manifest: FeatureManifest
+  readonly token: FeatureIdentityToken<FeatureIdentity>
+  readonly summary: Summary
+}
+
+export interface FeatureDefinition<
+  out FeatureIdentity,
+  out Summary extends AnyFeatureGraphSummary,
+  out NativeTree extends object,
+> extends ProvideableFeature<FeatureIdentity, Summary> {
+  readonly token: FeatureToken<FeatureIdentity, NativeTree>
+}
+
+export type FeatureOpenServices<Feature extends { readonly summary: AnyFeatureGraphSummary }> =
+  FeatureSummaryOpenServices<Feature['summary']>
+
+export type FeatureSupportOpenServices<
+  Feature extends { readonly summary: AnyFeatureGraphSummary },
+> = FeatureSummarySupportOpenServices<Feature['summary']>
+
+export interface AnyFeatureBindingExternalApi {
   readonly [FeatureBindingTypeId]: FeatureBindingTypeId
+  readonly [FeatureGraphValidTypeId]: FeatureGraphValidTypeId
+  readonly capture: <Result>(visit: FeatureBindingCapture<Result>) => Result
+}
+
+export type AnyFeatureBinding = AnyFeatureBindingExternalApi
+
+export interface FeatureBinding<
+  Summary extends AnyFeatureGraphSummary,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+> extends AnyFeatureBindingExternalApi {
   readonly manifest: FeatureManifest
-  readonly composition: CompositionClass<unknown>
+  readonly identity: symbol
+  readonly summary: Summary
+  readonly composition: CompositionClass<
+    FeatureSummaryCompositionProps<Summary>,
+    FeatureSummaryContract<Summary>,
+    FeatureSummaryStates<Summary>,
+    FeatureSummaryName<Summary>,
+    FeatureSummaryCompositionIdentity<Summary>
+  >
   readonly strategy: 'lazy' | 'default'
-  readonly load: Effect.Effect<LoadedModule, FeatureLoadFailed>
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- read at the react host seam via `binding.placeholder === undefined`; an Option here would force a cross-package edit (react host) owned by another agent
-  readonly placeholder?: {
-    readonly loading: CompositionClass<unknown>
-    readonly failed: CompositionClass<unknown>
-  }
+  readonly load: Effect.Effect<
+    LoadedModule<
+      ROut,
+      DirectRequires,
+      FeatureSummaryOpenServices<Summary>,
+      FeatureSummaryUsesInput<Summary>,
+      FeatureSummaryInput<Summary>
+    >,
+    FeatureLoadFailed
+  >
+  readonly placeholder: Option.Option<{
+    readonly loading: AnyComposition
+    readonly failed: AnyComposition
+  }>
+  readonly parseInput: (input: unknown) => Option.Option<unknown>
   readonly boot: ReadonlyArray<Tagged>
 }
 
-/** Whether a slot's bound child is a lazy/eager feature (vs a plain composition). */
-export const isFeatureBinding = (candidate: unknown): candidate is FeatureBinding =>
-  typeof candidate === 'object' && candidate !== null && FeatureBindingTypeId in candidate
+export type CapturedFeatureBinding<
+  Summary extends AnyFeatureGraphSummary,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+> = FeatureBinding<Summary, ROut, DirectRequires>
+
+export type FeatureBindingCapture<Result> = <
+  Summary extends AnyFeatureGraphSummary,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+>(
+  binding: FeatureBinding<Summary, ROut, DirectRequires>,
+) => Result
+
+export const isFeatureBinding = (candidate: unknown): candidate is AnyFeatureBinding =>
+  typeof candidate === 'object' &&
+  candidate !== null &&
+  FeatureBindingTypeId in candidate &&
+  FeatureGraphValidTypeId in candidate
+
+export interface FeatureNativeTree<
+  Summary extends AnyFeatureGraphSummary,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  SupportOut,
+  SupportDirectRequires extends ReadonlyArray<FeatureRequirement>,
+  Composition extends CompositionClass<
+    FeatureSummaryCompositionProps<Summary>,
+    FeatureSummaryContract<Summary>,
+    FeatureSummaryStates<Summary>,
+    FeatureSummaryName<Summary>,
+    FeatureSummaryCompositionIdentity<Summary>
+  > = CompositionClass<
+    FeatureSummaryCompositionProps<Summary>,
+    FeatureSummaryContract<Summary>,
+    FeatureSummaryStates<Summary>,
+    FeatureSummaryName<Summary>,
+    FeatureSummaryCompositionIdentity<Summary>
+  >,
+> {
+  readonly identity: symbol
+  readonly summary: Summary
+  readonly composition: Composition
+  readonly load: Effect.Effect<
+    FeatureModule<
+      ROut,
+      DirectRequires,
+      FeatureSummaryOpenServices<Summary>,
+      FeatureSummaryUsesInput<Summary>,
+      FeatureSummaryInput<Summary>
+    >,
+    FeatureLoadFailed
+  >
+  readonly binding: CapturedFeatureBinding<Summary, ROut, DirectRequires>
+  readonly eagerModule:
+    | FeatureModule<ROut, DirectRequires, FeatureSummaryOpenServices<Summary>, false, never>
+    | undefined
+  readonly supportModule:
+    | FeatureModule<
+        SupportOut,
+        SupportDirectRequires,
+        FeatureSummarySupportOpenServices<Summary>,
+        false,
+        never
+      >
+    | undefined
+}
+
+export interface EagerFeatureNativeTree<
+  Summary extends AnyFeatureGraphSummary,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  Composition extends CompositionClass<
+    FeatureSummaryCompositionProps<Summary>,
+    FeatureSummaryContract<Summary>,
+    FeatureSummaryStates<Summary>,
+    FeatureSummaryName<Summary>,
+    FeatureSummaryCompositionIdentity<Summary>
+  > = CompositionClass<
+    FeatureSummaryCompositionProps<Summary>,
+    FeatureSummaryContract<Summary>,
+    FeatureSummaryStates<Summary>,
+    FeatureSummaryName<Summary>,
+    FeatureSummaryCompositionIdentity<Summary>
+  >,
+> extends FeatureNativeTree<Summary, ROut, DirectRequires, never, readonly [], Composition> {
+  readonly eagerModule: FeatureModule<
+    ROut,
+    DirectRequires,
+    FeatureSummaryOpenServices<Summary>,
+    false,
+    never
+  >
+  readonly supportModule: undefined
+}
+
+export interface LazyFeatureNativeTree<
+  Summary extends AnyFeatureGraphSummary,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  SupportOut,
+  SupportDirectRequires extends ReadonlyArray<FeatureRequirement>,
+  Composition extends CompositionClass<
+    FeatureSummaryCompositionProps<Summary>,
+    FeatureSummaryContract<Summary>,
+    FeatureSummaryStates<Summary>,
+    FeatureSummaryName<Summary>,
+    FeatureSummaryCompositionIdentity<Summary>
+  > = CompositionClass<
+    FeatureSummaryCompositionProps<Summary>,
+    FeatureSummaryContract<Summary>,
+    FeatureSummaryStates<Summary>,
+    FeatureSummaryName<Summary>,
+    FeatureSummaryCompositionIdentity<Summary>
+  >,
+> extends FeatureNativeTree<
+  Summary,
+  ROut,
+  DirectRequires,
+  SupportOut,
+  SupportDirectRequires,
+  Composition
+> {
+  readonly eagerModule: undefined
+}
+
+type FeatureSummaryOf<
+  FeatureIdentity,
+  MountProps,
+  CompositionProps,
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  Identity,
+  OpenServices,
+  SupportOpenServices,
+  UsesInput extends boolean,
+  Input,
+> = FeatureGraphSummary<
+  FeatureIdentity,
+  MountProps,
+  CompositionProps,
+  C,
+  S,
+  N,
+  Identity,
+  OpenServices,
+  SupportOpenServices,
+  UsesInput,
+  Input
+>
 
-/**
- * A feature *definition*: a reflectable manifest (`kind: 'Feature'`) that carries
- * the eager half (composition + placeholders) and an Effect `load` for the heavy
- * `.live` half. `Props`/`Contract` flow from the composition; `Requires` is the
- * shared-carrier tuple the loaded module declares. `load` is an `Effect`, never a
- * Promise — consumers `yield* Feature.load`.
- */
 export interface FeatureClass<
+  FeatureIdentity,
   P,
   C extends UiContract,
   ROut,
-  Requires extends ReadonlyArray<RequireCarrier>,
-> {
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices = DefaultFeatureOpenServices<ROut, DirectRequires>,
+  SupportOut = never,
+  SupportDirectRequires extends ReadonlyArray<FeatureRequirement> = readonly [],
+  SupportOpenServices = DefaultFeatureOpenServices<SupportOut, SupportDirectRequires>,
+  UsesInput extends boolean = false,
+  Input = UsesInput extends true ? P : never,
+  S extends ReadonlyArray<unknown> = ReadonlyArray<unknown>,
+  N extends string = RootCompositionName<ROut>,
+  CompositionProps = P,
+  Identity = RootCompositionIdentity<ROut>,
+  Composition extends CompositionClass<CompositionProps, C, S, N, Identity> = CompositionClass<
+    CompositionProps,
+    C,
+    S,
+    N,
+    Identity
+  >,
+> extends FeatureDefinition<
+  FeatureIdentity,
+  FeatureSummaryOf<
+    FeatureIdentity,
+    P,
+    CompositionProps,
+    C,
+    S,
+    N,
+    Identity,
+    OpenServices,
+    SupportOpenServices,
+    UsesInput,
+    Input
+  >,
+  FeatureNativeTree<
+    FeatureSummaryOf<
+      FeatureIdentity,
+      P,
+      CompositionProps,
+      C,
+      S,
+      N,
+      Identity,
+      OpenServices,
+      SupportOpenServices,
+      UsesInput,
+      Input
+    >,
+    ROut,
+    DirectRequires,
+    SupportOut,
+    SupportDirectRequires,
+    Composition
+  >
+> {}
+
+export type EagerFeatureClass<
+  FeatureIdentity,
+  P,
+  C extends UiContract,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  Identity,
+  Composition extends CompositionClass<P, C, S, N, Identity> = CompositionClass<
+    P,
+    C,
+    S,
+    N,
+    Identity
+  >,
+> = FeatureDefinition<
+  FeatureIdentity,
+  FeatureSummaryOf<FeatureIdentity, P, P, C, S, N, Identity, OpenServices, never, false, never>,
+  EagerFeatureNativeTree<
+    FeatureSummaryOf<FeatureIdentity, P, P, C, S, N, Identity, OpenServices, never, false, never>,
+    ROut,
+    DirectRequires,
+    Composition
+  >
+>
+
+export type LazyFeatureClass<
+  FeatureIdentity,
+  P,
+  C extends UiContract,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices,
+  SupportOut,
+  SupportDirectRequires extends ReadonlyArray<FeatureRequirement>,
+  SupportOpenServices,
+  UsesInput extends boolean,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  CompositionProps,
+  Identity,
+  Composition extends CompositionClass<CompositionProps, C, S, N, Identity> = CompositionClass<
+    CompositionProps,
+    C,
+    S,
+    N,
+    Identity
+  >,
+> = FeatureDefinition<
+  FeatureIdentity,
+  FeatureSummaryOf<
+    FeatureIdentity,
+    P,
+    CompositionProps,
+    C,
+    S,
+    N,
+    Identity,
+    OpenServices,
+    SupportOpenServices,
+    UsesInput,
+    UsesInput extends true ? P : never
+  >,
+  LazyFeatureNativeTree<
+    FeatureSummaryOf<
+      FeatureIdentity,
+      P,
+      CompositionProps,
+      C,
+      S,
+      N,
+      Identity,
+      OpenServices,
+      SupportOpenServices,
+      UsesInput,
+      UsesInput extends true ? P : never
+    >,
+    ROut,
+    DirectRequires,
+    SupportOut,
+    SupportDirectRequires,
+    Composition
+  >
+>
+
+interface RuntimeFeatureTree {
+  readonly composition: AnyComposition
+  readonly load: Effect.Effect<AnyLoadedModule, FeatureLoadFailed>
+  readonly binding: AnyFeatureBinding
+  readonly eagerModule: AnyLoadedModule | undefined
+  readonly supportModule: AnyLoadedModule | undefined
+}
+
+interface RuntimeFeature {
   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>>
-
-/** Whether a value is a feature definition (its target shape in `provide(slot, Feature)`). */
-export const isFeature = (candidate: unknown): candidate is AnyFeature =>
+  readonly token: FeatureToken<unknown, RuntimeFeatureTree>
+  readonly summary: AnyFeatureGraphSummary
+}
+
+const isRuntimeFeatureToken = (
+  candidate: unknown,
+): candidate is FeatureToken<unknown, RuntimeFeatureTree> =>
+  typeof candidate === 'object' && candidate !== null && FeatureNativeTypeId in candidate
+
+export const isFeature = (candidate: unknown): candidate is RuntimeFeature =>
   (typeof candidate === 'function' || typeof candidate === 'object') &&
   candidate !== null &&
-  'manifest' in candidate &&
-  typeof candidate.manifest === 'object' &&
-  candidate.manifest !== null &&
-  'kind' in candidate.manifest &&
-  candidate.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
- * the feature's props; `failed` receives `{ error, retry }`. Typed loosely
- * (`CompositionClass<any>`) because the host injects these props directly — they
- * are not schema-decoded inputs.
- */
-export interface Placeholders {
-  readonly loading: CompositionClass<any, UiContract>
-  readonly failed: CompositionClass<any, UiContract>
-}
-
-type FeatureConfigExternalApi<
+  'token' in candidate &&
+  isRuntimeFeatureToken(candidate.token)
+
+type PlaceholderComposition<P> = AnyComposition & CompositionPropsReceiver<P>
+
+export interface Placeholders<P> {
+  readonly loading: PlaceholderComposition<P>
+  readonly failed: PlaceholderComposition<FailedProps>
+}
+
+export type FeatureMountProps<
+  UsesInput extends boolean,
+  CompositionProps,
+  InputSchema extends Schema.Schema.AnyNoContext,
+> = UsesInput extends true ? Schema.Schema.Type<InputSchema> : CompositionProps
+
+type FeatureUsesInput<InputSchema extends Schema.Schema.AnyNoContext> = [InputSchema] extends [
+  never,
+]
+  ? false
+  : true
+
+type FeatureInputValue<InputSchema extends Schema.Schema.AnyNoContext> = [InputSchema] extends [
+  never,
+]
+  ? never
+  : Schema.Schema.Type<InputSchema>
+
+interface FeatureConfigBaseExternalApi<
   P,
   C extends UiContract,
-  ROut,
-  Requires extends ReadonlyArray<RequireCarrier>,
-> = {
-  readonly composition: CompositionClass<P, C>
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  Identity,
+> {
+  readonly composition: CompositionClass<P, C, S, N, Identity>
   readonly boot?: ReadonlyArray<Tagged>
-} & (
+}
+
+interface ExactFeatureCompositionConfig<Composition extends AnyComposition> {
+  readonly composition: Composition
+}
+
+type IncludesComposition<ROut, N extends string, Identity> =
+  HasExactCompositionId<ROut, N, Identity> extends true
+    ? object
+    : {
+        readonly missingCompositionService: 'The feature module must provide its root composition'
+      }
+
+type EagerFeatureConfigExternalApi<
+  P,
+  C extends UiContract,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  Identity,
+> = FeatureConfigBaseExternalApi<P, C, S, N, Identity> & {
+  readonly loadingStrategy?: 'default'
+  readonly module: FeatureModule<ROut, DirectRequires, OpenServices, false, never> &
+    IncludesComposition<ROut, N, Identity>
+}
+
+type LazyFeatureConfigExternalApi<
+  CompositionProps,
+  C extends UiContract,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices,
+  SupportOut,
+  SupportDirectRequires extends ReadonlyArray<FeatureRequirement>,
+  SupportOpenServices,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  Identity,
+  InputSchema extends Schema.Schema.AnyNoContext,
+  Loading extends AnyComposition,
+  Failed extends AnyComposition,
+> = FeatureConfigBaseExternalApi<CompositionProps, C, S, N, Identity> & {
+  readonly composition: CompositionClass<CompositionProps, C, S, N, Identity> &
+    CompositionPropsReceiver<
+      NoInfer<FeatureMountProps<FeatureUsesInput<InputSchema>, CompositionProps, InputSchema>>
+    >
+  readonly loadingStrategy: 'lazy'
+  readonly input?: InputSchema
+  readonly load: Effect.Effect<
+    FeatureModule<
+      ROut,
+      DirectRequires,
+      OpenServices,
+      FeatureUsesInput<InputSchema>,
+      FeatureInputValue<InputSchema>
+    > &
+      IncludesComposition<ROut, N, Identity>,
+    FeatureLoadFailed
+  >
+  readonly placeholder: {
+    readonly loading: Loading &
+      CompositionPropsReceiver<
+        NoInfer<FeatureMountProps<FeatureUsesInput<InputSchema>, CompositionProps, InputSchema>>
+      >
+    readonly failed: Failed & CompositionPropsReceiver<FailedProps>
+  }
+  readonly eager?: FeatureModule<
+    SupportOut,
+    SupportDirectRequires,
+    SupportOpenServices,
+    false,
+    never
+  >
+} & (FeatureUsesInput<InputSchema> extends true ? { readonly input: InputSchema } : object)
+
+type MakeImplementationConfigExternalApi =
   | {
-      // EAGER: the module is statically present and merged into the runtime at
-      // boot. No load gap, so no placeholder.
+      readonly composition: AnyComposition
+      readonly boot?: ReadonlyArray<Tagged>
       readonly loadingStrategy?: 'default'
-      readonly module: FeatureModule<ROut, Requires>
+      readonly module: AnyLoadedModule
     }
   | {
-      // LAZY: the module loads on mount via an Effect. Placeholders required.
+      readonly composition: AnyComposition
+      readonly boot?: ReadonlyArray<Tagged>
       readonly loadingStrategy: 'lazy'
-      readonly load: Effect.Effect<FeatureModule<ROut, Requires>, FeatureLoadFailed>
-      readonly placeholder: Placeholders
+      readonly input?: Schema.Schema.Any
+      readonly load: Effect.Effect<AnyLoadedModule, FeatureLoadFailed>
+      readonly placeholder: {
+        readonly loading: AnyComposition
+        readonly failed: AnyComposition
+      }
+      readonly eager?: AnyLoadedModule
     }
-)
-
-/**
- * Define a feature. The whole-app shape (this manifest, the composition, the
- * placeholders) stays eager and reflectable; the `.live` layer in `module`/`load`
- * is the deferred chunk. Flip `loadingStrategy` from `'default'` to `'lazy'` and
- * the discriminated config *requires* `placeholder` — the compiler walks you to a
- * complete code-split feature.
- */
-export const make = <P, C extends UiContract, ROut, Requires extends ReadonlyArray<RequireCarrier>>(
+
+const isMakeImplementationConfig = (
+  candidate: unknown,
+): candidate is MakeImplementationConfigExternalApi =>
+  typeof candidate === 'object' &&
+  candidate !== null &&
+  'composition' in candidate &&
+  (!('input' in candidate) || Schema.isSchema(candidate.input)) &&
+  ('module' in candidate || ('load' in candidate && 'placeholder' in candidate))
+
+type RuntimePlaceholders = {
+  readonly loading: AnyComposition
+  readonly failed: AnyComposition
+}
+
+const makeFeatureManifest = (
   name: string,
-  config: FeatureConfigExternalApi<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: Option.fromNullable(placeholder).pipe(
-      Option.map((placeholders) => ({
-        loading: placeholders.loading.manifest,
-        failed: placeholders.failed.manifest,
-      })),
-    ),
-  }
+  strategy: 'lazy' | 'default',
+  composition: AnyComposition,
+  placeholder: Option.Option<RuntimePlaceholders>,
+): FeatureManifest => ({
+  kind: 'Feature',
+  name,
+  strategy,
+  composition: composition.manifest,
+  placeholder: Option.map(placeholder, (placeholders) => ({
+    loading: placeholders.loading.manifest,
+    failed: placeholders.failed.manifest,
+  })),
+})
 
-  const binding: FeatureBinding = {
+const makeFeatureInputParser =
+  (
+    composition: AnyComposition,
+    inputSchema: Schema.Schema.AnyNoContext | undefined,
+    placeholder: Option.Option<RuntimePlaceholders>,
+  ): ((input: unknown) => Option.Option<unknown>) =>
+  (input) =>
+    Option.flatMap(
+      Option.match(Option.fromNullable(inputSchema), {
+        onNone: () => Option.some(input),
+        onSome: (schema) => Schema.validateOption(schema)(input),
+      }),
+      (decoded) =>
+        Option.flatMap(composition.parseProps(decoded), () =>
+          Option.match(placeholder, {
+            onNone: () => Option.some(decoded),
+            onSome: (placeholders) =>
+              Option.map(placeholders.loading.parseProps(decoded), () => decoded),
+          }),
+        ),
+    )
+
+const makeFeatureSummary = <
+  FeatureIdentity,
+  MountProps,
+  CompositionProps,
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  Identity,
+  OpenServices,
+  SupportOpenServices,
+  UsesInput extends boolean,
+  Input,
+>(
+  composition: CompositionClass<CompositionProps, C, S, N, Identity>,
+): FeatureSummaryOf<
+  FeatureIdentity,
+  MountProps,
+  CompositionProps,
+  C,
+  S,
+  N,
+  Identity,
+  OpenServices,
+  SupportOpenServices,
+  UsesInput,
+  Input
+> => ({
+  [SlotBindingSummaryTypeId]: SlotBindingSummaryTypeId,
+  [FeatureChildSummaryTypeId]: {
+    featureIdentity: [],
+    compositionIdentity: [],
+  },
+  [FeatureGraphSummaryTypeId]: {
+    featureIdentity: [],
+    mountProps: [],
+    compositionProps: [],
+    contract: [],
+    states: [],
+    name: composition.manifest.name,
+    compositionIdentity: [],
+    openServices: [],
+    supportOpenServices: [],
+    usesInput: [],
+    input: [],
+    validated: FeatureModuleGraphValidTypeId,
+  },
+})
+
+const makeFeatureBinding = <
+  Summary extends AnyFeatureGraphSummary,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+>(
+  identity: symbol,
+  manifest: FeatureManifest,
+  summary: Summary,
+  composition: CompositionClass<
+    FeatureSummaryCompositionProps<Summary>,
+    FeatureSummaryContract<Summary>,
+    FeatureSummaryStates<Summary>,
+    FeatureSummaryName<Summary>,
+    FeatureSummaryCompositionIdentity<Summary>
+  >,
+  load: Effect.Effect<
+    LoadedModule<
+      ROut,
+      DirectRequires,
+      FeatureSummaryOpenServices<Summary>,
+      FeatureSummaryUsesInput<Summary>,
+      FeatureSummaryInput<Summary>
+    >,
+    FeatureLoadFailed
+  >,
+  placeholder: Option.Option<RuntimePlaceholders>,
+  inputSchema: Schema.Schema.AnyNoContext | undefined,
+  boot: ReadonlyArray<Tagged>,
+): FeatureBinding<Summary, ROut, DirectRequires> => {
+  const binding: FeatureBinding<Summary, ROut, DirectRequires> = {
     [FeatureBindingTypeId]: FeatureBindingTypeId,
+    [FeatureGraphValidTypeId]: FeatureGraphValidTypeId,
+    manifest,
+    identity,
+    summary,
+    composition,
+    strategy: manifest.strategy,
+    load,
+    placeholder,
+    parseInput: makeFeatureInputParser(composition, inputSchema, placeholder),
+    boot,
+    capture: <Result>(visit: FeatureBindingCapture<Result>): Result => visit(binding),
+  }
+  return binding
+}
+
+const makeEagerFeature = <
+  P,
+  C extends UiContract,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  Identity,
+  Composition extends CompositionClass<P, C, S, N, Identity>,
+>(
+  name: string,
+  config: EagerFeatureConfigExternalApi<P, C, ROut, DirectRequires, OpenServices, S, N, Identity> &
+    ExactFeatureCompositionConfig<Composition>,
+): EagerFeatureClass<
+  Identity,
+  P,
+  C,
+  ROut,
+  DirectRequires,
+  OpenServices,
+  S,
+  N,
+  Identity,
+  Composition
+> => {
+  const featureIdentity = Symbol(name)
+  const placeholder = Option.none<RuntimePlaceholders>()
+  const manifest = makeFeatureManifest(name, 'default', config.composition, placeholder)
+  const load = Effect.succeed(config.module)
+  const summary = makeFeatureSummary<
+    Identity,
+    P,
+    P,
+    C,
+    S,
+    N,
+    Identity,
+    OpenServices,
+    never,
+    false,
+    never
+  >(config.composition)
+  const binding = makeFeatureBinding<typeof summary, ROut, DirectRequires>(
+    featureIdentity,
     manifest,
+    summary,
+    config.composition,
+    load,
+    placeholder,
+    undefined,
+    Option.getOrElse(Option.fromNullable(config.boot), () => []),
+  )
+  const native: EagerFeatureNativeTree<typeof summary, ROut, DirectRequires, Composition> = {
+    identity: featureIdentity,
+    summary,
     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: Option.getOrElse(Option.fromNullable(config.boot), () => []),
+    binding,
+    eagerModule: config.module,
+    supportModule: undefined,
   }
+  const token: FeatureToken<Identity, typeof native> = {
+    identity: featureIdentity,
+    [FeatureTokenIdentityTypeId]: [],
+    [FeatureNativeTypeId]: native,
+  }
+  return definitionClass<
+    EagerFeatureClass<
+      Identity,
+      P,
+      C,
+      ROut,
+      DirectRequires,
+      OpenServices,
+      S,
+      N,
+      Identity,
+      Composition
+    >
+  >({
+    manifest,
+    summary,
+    token,
+  })
+}
 
-  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
- * = immediate), build its `.live` layer against the host's live `engineContext`
- * (so its reducers/procedures register into the SHARED registries and its fibers
- * fork onto this scope), then dispatch the feature's `boot`. Returns the merged
- * context — engine services + the feature's own services — for the host to read
- * the feature's composition and stores. Closing the scope disposes exactly this
- * feature: its fibers stop and its stores are reclaimed.
- *
- * The single boundary cast (mirroring `buildRuntime`): `module.layer` is erased to
- * `LoadedModule` so the host stays strategy- and type-uniform. The feature's real
- * `RIn` was verified cast-free at `provide(slot, Feature)` and scene wiring; here
- * we re-attach the concrete `engineContext` it builds against. `R` is the engine
- * context's service set, supplied by the host.
- */
-// oxlint-disable-next-line reform-rules/prefer-effect-fn -- generic export: Effect.fn's inferred type isn't portable under isolatedDeclarations
-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
-    // oxlint-disable-next-line reform-rules/no-type-assertion -- documented erasure boundary: re-attach the concrete engine context to the type-erased `LoadedModule` layer (mirrors `buildRuntime`); RIn was verified cast-free at `provide`/scene wiring
-    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
+const makeLazyFeature = <
+  CompositionProps,
+  C extends UiContract,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices,
+  SupportOut,
+  SupportDirectRequires extends ReadonlyArray<FeatureRequirement>,
+  SupportOpenServices,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  Identity,
+  Composition extends CompositionClass<CompositionProps, C, S, N, Identity>,
+  InputSchema extends Schema.Schema.AnyNoContext,
+  Loading extends AnyComposition,
+  Failed extends AnyComposition,
+>(
+  name: string,
+  config: LazyFeatureConfigExternalApi<
+    CompositionProps,
+    C,
+    ROut,
+    DirectRequires,
+    OpenServices,
+    SupportOut,
+    SupportDirectRequires,
+    SupportOpenServices,
+    S,
+    N,
+    Identity,
+    InputSchema,
+    Loading,
+    Failed
+  > &
+    ExactFeatureCompositionConfig<Composition>,
+): LazyFeatureClass<
+  Identity,
+  FeatureMountProps<FeatureUsesInput<InputSchema>, CompositionProps, InputSchema>,
+  C,
+  ROut,
+  DirectRequires,
+  OpenServices,
+  SupportOut,
+  SupportDirectRequires,
+  SupportOpenServices,
+  FeatureUsesInput<InputSchema>,
+  S,
+  N,
+  CompositionProps,
+  Identity,
+  Composition
+> => {
+  const featureIdentity = Symbol(name)
+  const placeholder = Option.some<RuntimePlaceholders>(config.placeholder)
+  const manifest = makeFeatureManifest(name, 'lazy', config.composition, placeholder)
+  const inputSchema = 'input' in config ? config.input : undefined
+  const summary = makeFeatureSummary<
+    Identity,
+    FeatureMountProps<FeatureUsesInput<InputSchema>, CompositionProps, InputSchema>,
+    CompositionProps,
+    C,
+    S,
+    N,
+    Identity,
+    OpenServices,
+    SupportOpenServices,
+    FeatureUsesInput<InputSchema>,
+    FeatureInputValue<InputSchema>
+  >(config.composition)
+  const binding = makeFeatureBinding<typeof summary, ROut, DirectRequires>(
+    featureIdentity,
+    manifest,
+    summary,
+    config.composition,
+    config.load,
+    placeholder,
+    inputSchema,
+    Option.getOrElse(Option.fromNullable(config.boot), () => []),
+  )
+  const native: LazyFeatureNativeTree<
+    typeof summary,
+    ROut,
+    DirectRequires,
+    SupportOut,
+    SupportDirectRequires,
+    Composition
+  > = {
+    identity: featureIdentity,
+    summary,
+    composition: config.composition,
+    load: config.load,
+    binding,
+    eagerModule: undefined,
+    supportModule: config.eager,
+  }
+  const token: FeatureToken<Identity, typeof native> = {
+    identity: featureIdentity,
+    [FeatureTokenIdentityTypeId]: [],
+    [FeatureNativeTypeId]: native,
+  }
+  return definitionClass<
+    LazyFeatureClass<
+      Identity,
+      FeatureMountProps<FeatureUsesInput<InputSchema>, CompositionProps, InputSchema>,
+      C,
+      ROut,
+      DirectRequires,
+      OpenServices,
+      SupportOut,
+      SupportDirectRequires,
+      SupportOpenServices,
+      FeatureUsesInput<InputSchema>,
+      S,
+      N,
+      CompositionProps,
+      Identity,
+      Composition
+    >
+  >({
+    manifest,
+    summary,
+    token,
   })
+}
+
+export function make<
+  P,
+  C extends UiContract,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  Identity,
+  const Composition extends CompositionClass<P, C, S, N, Identity>,
+>(
+  name: string,
+  config: EagerFeatureConfigExternalApi<
+    P,
+    C,
+    ROut,
+    DirectRequires,
+    OpenServices,
+    S,
+    N,
+    Identity
+  > & { readonly composition: Composition },
+): EagerFeatureClass<
+  Identity,
+  P,
+  C,
+  ROut,
+  DirectRequires,
+  OpenServices,
+  S,
+  N,
+  Identity,
+  Composition
+>
+export function make<
+  CompositionProps,
+  C extends UiContract,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  Identity,
+  const Composition extends CompositionClass<CompositionProps, C, S, N, Identity>,
+  const Loading extends AnyComposition,
+  const Failed extends AnyComposition,
+  const InputSchema extends Schema.Schema.AnyNoContext = never,
+  SupportOut = never,
+  SupportDirectRequires extends ReadonlyArray<FeatureRequirement> = readonly [],
+  SupportOpenServices = never,
+>(
+  name: string,
+  config: LazyFeatureConfigExternalApi<
+    CompositionProps,
+    C,
+    ROut,
+    DirectRequires,
+    OpenServices,
+    SupportOut,
+    SupportDirectRequires,
+    SupportOpenServices,
+    S,
+    N,
+    Identity,
+    InputSchema,
+    Loading,
+    Failed
+  > & { readonly composition: Composition },
+): LazyFeatureClass<
+  Identity,
+  FeatureMountProps<FeatureUsesInput<InputSchema>, CompositionProps, InputSchema>,
+  C,
+  ROut,
+  DirectRequires,
+  OpenServices,
+  SupportOut,
+  SupportDirectRequires,
+  SupportOpenServices,
+  FeatureUsesInput<InputSchema>,
+  S,
+  N,
+  CompositionProps,
+  Identity,
+  Composition
+>
+export function make<
+  CompositionProps,
+  C extends UiContract,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  Identity,
+  Composition extends CompositionClass<CompositionProps, C, S, N, Identity>,
+  Loading extends AnyComposition,
+  Failed extends AnyComposition,
+  InputSchema extends Schema.Schema.AnyNoContext = never,
+  SupportOut = never,
+  SupportDirectRequires extends ReadonlyArray<FeatureRequirement> = readonly [],
+  SupportOpenServices = never,
+>(
+  name: string,
+  config: (
+    | EagerFeatureConfigExternalApi<
+        CompositionProps,
+        C,
+        ROut,
+        DirectRequires,
+        OpenServices,
+        S,
+        N,
+        Identity
+      >
+    | LazyFeatureConfigExternalApi<
+        CompositionProps,
+        C,
+        ROut,
+        DirectRequires,
+        OpenServices,
+        SupportOut,
+        SupportDirectRequires,
+        SupportOpenServices,
+        S,
+        N,
+        Identity,
+        InputSchema,
+        Loading,
+        Failed
+      >
+  ) &
+    ExactFeatureCompositionConfig<Composition>,
+):
+  | EagerFeatureClass<
+      Identity,
+      CompositionProps,
+      C,
+      ROut,
+      DirectRequires,
+      OpenServices,
+      S,
+      N,
+      Identity,
+      Composition
+    >
+  | LazyFeatureClass<
+      Identity,
+      FeatureMountProps<FeatureUsesInput<InputSchema>, CompositionProps, InputSchema>,
+      C,
+      ROut,
+      DirectRequires,
+      OpenServices,
+      SupportOut,
+      SupportDirectRequires,
+      SupportOpenServices,
+      FeatureUsesInput<InputSchema>,
+      S,
+      N,
+      CompositionProps,
+      Identity,
+      Composition
+    > {
+  if (!isMakeImplementationConfig(config)) {
+    return Effect.runSync(Effect.dieMessage(`Invalid Feature config for ${name}`))
+  }
+  if (config.loadingStrategy === 'lazy') {
+    return makeLazyFeature<
+      CompositionProps,
+      C,
+      ROut,
+      DirectRequires,
+      OpenServices,
+      SupportOut,
+      SupportDirectRequires,
+      SupportOpenServices,
+      S,
+      N,
+      Identity,
+      Composition,
+      InputSchema,
+      Loading,
+      Failed
+    >(name, config)
+  }
+  return makeEagerFeature<
+    CompositionProps,
+    C,
+    ROut,
+    DirectRequires,
+    OpenServices,
+    S,
+    N,
+    Identity,
+    Composition
+  >(name, config)
+}
+
+type MountFeature = <
+  Summary extends AnyFeatureGraphSummary,
+  ROut,
+  const DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  HostServices,
+>(
+  binding: FeatureBinding<Summary, ROut, DirectRequires>,
+  engineContext: Context.Context<
+    HostServices | EngineServices | FeatureSummaryOpenServices<Summary>
+  >,
+  props?: FeatureSummaryInput<Summary>,
+) => Effect.Effect<
+  Context.Context<HostServices | EngineServices | FeatureSummaryOpenServices<Summary> | ROut>,
+  FeatureLoadFailed,
+  Scope.Scope
+>
+
+export const mountFeature: MountFeature = Effect.fn('mountFeature')(function* <
+  Summary extends AnyFeatureGraphSummary,
+  ROut,
+  const DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  HostServices,
+>(
+  binding: FeatureBinding<Summary, ROut, DirectRequires>,
+  engineContext: Context.Context<
+    HostServices | EngineServices | FeatureSummaryOpenServices<Summary>
+  >,
+  props: FeatureSummaryInput<Summary> | undefined = undefined,
+): Effect.fn.Return<
+  Context.Context<HostServices | EngineServices | FeatureSummaryOpenServices<Summary> | ROut>,
+  FeatureLoadFailed,
+  Scope.Scope
+> {
+  const { layer } = yield* binding.load
+  const bus = Context.get(engineContext, Bus)
+  const featureContext = Context.add(engineContext, FeatureInput, props)
+  const context = yield* Layer.build(Layer.provide(layer, Layer.succeedContext(featureContext)))
+  yield* Effect.forEach(binding.boot, (event) => publish('High', event), {
+    discard: true,
+  }).pipe(Effect.provideService(Bus, bus))
+  return Context.merge(engineContext, context)
+})