@playfast/reform 1.1.1 → 1.2.0

package/src/feature/feature.ts

@@ -1,84 +1,227 @@
-import { 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 { 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'
-import type { AnyValue } from '../internal/variance'
+import { type Manifest, definitionClass } from '../definition/definition'
 import {
-  type FeatureBinding,
-  FeatureBindingTypeId,
-  type FeatureManifest,
-} from './featureBinding'
-export {
-  type FailedProps,
-  type FeatureBinding,
-  FeatureBindingTypeId,
-  type FeatureManifest,
-  isFeatureBinding,
-  type LoadedModule,
-} from './featureBinding'
-export type { FeatureBindingTypeId as FeatureBindingType } from './featureBinding'
-
-// Features must only name EngineServices as open RIn — never provide them (shared engine)
-export type EngineServices = Layer.Layer.Success<typeof Engine>
-
-const FeatureInputBase: Context.TagClass<FeatureInput, 'reform/FeatureInput', unknown> = Context.Tag(
-  'reform/FeatureInput',
-)<FeatureInput, unknown>()
+  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<AnyValue, AnyValue> }
-  | { readonly members: ReadonlyArray<{ readonly store: Context.Tag<AnyValue, AnyValue> }> }
+  | 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]
+>
 
-export type FeatureRequirement = RequireCarrier | Context.Tag<AnyValue, AnyValue>
+type DefaultFeatureOpenServices<ROut, DirectRequires extends ReadonlyArray<FeatureRequirement>> =
+  | ProvidedBy<DirectRequires>
+  | OpenServicesFromFeatureSlotWitnesses<ROut>
 
-// Covariant RIn: layer reading outside EngineServices | ProvidedBy is unassignable
-export type ProvidedBy<Requires extends ReadonlyArray<FeatureRequirement>> = {
-  [I in keyof Requires]: Requires[I] extends Context.Tag<infer Identifier, AnyValue>
-    ? Identifier
-    : Requires[I] extends {
-    readonly members: infer M extends ReadonlyArray<unknown>
+type CompositionNames<ROut> = ROut extends {
+  readonly [CompositionIdTypeId]: {
+    readonly name: infer Name extends string
   }
-    ? StoresOf<M>
-    : Requires[I] extends { readonly store: Context.Tag<infer Svc, AnyValue> }
-      ? Svc
-      : never
-}[number]
+}
+  ? Name
+  : never
+
+type CompositionIdentities<ROut> = ROut extends {
+  readonly [CompositionIdTypeId]: {
+    readonly identity: infer Identity
+  }
+}
+  ? 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,
-  Requires extends ReadonlyArray<FeatureRequirement>,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices = DefaultFeatureOpenServices<ROut, DirectRequires>,
   UsesInput extends boolean = false,
-> {
-  readonly requires: Requires
+  Input = never,
+> extends AnyLoadedModule {
+  readonly [FeatureModuleGraphValidTypeId]: FeatureModuleGraphValidTypeId
+  readonly requires: DirectRequires
   readonly usesInput: UsesInput
-  readonly layer: Layer.Layer<
-    ROut,
-    never,
-    | EngineServices
-    | ProvidedBy<Requires>
-    | (UsesInput extends true ? FeatureInput : never)
-  >
+  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
 }
 
-export const featureModule = <const Requires extends ReadonlyArray<FeatureRequirement>, ROut>(
-  requires: Requires,
-  layer: Layer.Layer<ROut, never, EngineServices | ProvidedBy<Requires>>,
-): FeatureModule<ROut, Requires, false> => ({ requires, usesInput: false, layer })
+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 Requires extends ReadonlyArray<FeatureRequirement>,
-  ROut,
+  const InputSchema extends Schema.Schema.AnyNoContext,
+  const DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  L extends Layer.Layer.Any,
 >(
-  requires: Requires,
-  layer: Layer.Layer<ROut, never, EngineServices | ProvidedBy<Requires> | FeatureInput>,
-): FeatureModule<ROut, Requires, true> => ({ requires, usesInput: true, layer })
+  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
+}
 
-// Seals Promise import as Effect; rejection → FeatureLoadFailed
+// Seal dynamic imports as typed Effects so chunk failures become FeatureLoadFailed.
 export const lazyImport = <M>(
   thunk: () => Promise<{ readonly default: M }>,
 ): Effect.Effect<M, FeatureLoadFailed> =>
@@ -87,205 +230,1182 @@ export const lazyImport = <M>(
     catch: (cause) => new FeatureLoadFailed({ cause }),
   }).pipe(Effect.map((module) => module.default))
 
-export interface FeatureClass<
-  P,
-  C extends UiContract,
+export interface FailedProps {
+  readonly error: FeatureLoadFailed
+  readonly retry: () => void
+}
+
+export interface FeatureManifest extends Manifest {
+  readonly kind: 'Feature'
+  readonly name: string
+  readonly strategy: 'lazy' | 'default'
+  readonly composition: Manifest & { readonly kind: 'Composition' }
+  readonly placeholder: Option.Option<{
+    readonly loading: Manifest & { readonly kind: 'Composition' }
+    readonly failed: Manifest & { readonly kind: 'Composition' }
+  }>
+}
+
+export interface LoadedModule<
   ROut,
-  Requires extends ReadonlyArray<FeatureRequirement>,
-  SupportRequires extends ReadonlyArray<FeatureRequirement> = readonly [],
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices = DefaultFeatureOpenServices<ROut, DirectRequires>,
+  UsesInput extends boolean = false,
+  Input = never,
+> extends FeatureModule<ROut, DirectRequires, OpenServices, UsesInput, Input> {}
+
+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')
+
+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 Props: P
-  readonly Contract: C
-  readonly composition: CompositionClass<P, C>
-  readonly Requires: Requires
-  readonly load: Effect.Effect<FeatureModule<ROut, Requires, boolean>, FeatureLoadFailed>
-  readonly binding: FeatureBinding
-  readonly eagerModule: FeatureModule<ROut, Requires, false> | undefined
-  readonly supportModule: FeatureModule<never, SupportRequires, false> | undefined
+  readonly token: FeatureIdentityToken<FeatureIdentity>
+  readonly summary: Summary
 }
 
-export interface EagerFeatureClass<
-  P,
-  C extends UiContract,
+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 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<
+      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>
+}
+
+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,
-  Requires extends ReadonlyArray<FeatureRequirement>,
-> extends FeatureClass<P, C, ROut, Requires> {
-  readonly eagerModule: FeatureModule<ROut, Requires, false>
+  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 LazyFeatureClass<
-  P,
-  C extends UiContract,
+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,
-  Requires extends ReadonlyArray<FeatureRequirement>,
-  SupportRequires extends ReadonlyArray<FeatureRequirement> = readonly [],
-> extends FeatureClass<P, C, ROut, Requires, SupportRequires> {
+  DirectRequires,
+  SupportOut,
+  SupportDirectRequires,
+  Composition
+> {
   readonly eagerModule: undefined
 }
 
-export type AnyFeature = FeatureClass<
-  AnyValue,
-  AnyValue,
-  AnyValue,
-  ReadonlyArray<FeatureRequirement>,
-  ReadonlyArray<FeatureRequirement>
+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
+>
+
+export interface FeatureClass<
+  FeatureIdentity,
+  P,
+  C extends UiContract,
+  ROut,
+  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
+  >
 >
 
-export const isFeature = (candidate: unknown): candidate is AnyFeature =>
+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
+  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'
+  'token' in candidate &&
+  isRuntimeFeatureToken(candidate.token)
 
-export interface Placeholders {
-  readonly loading: CompositionClass<AnyValue, UiContract>
-  readonly failed: CompositionClass<AnyValue, UiContract>
+type PlaceholderComposition<P> = AnyComposition & CompositionPropsReceiver<P>
+
+export interface Placeholders<P> {
+  readonly loading: PlaceholderComposition<P>
+  readonly failed: PlaceholderComposition<FailedProps>
 }
 
-interface FeatureConfigBaseExternalApi<P, C extends UiContract> {
-  readonly composition: CompositionClass<P, C>
+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,
+  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,
-  Requires extends ReadonlyArray<FeatureRequirement>,
-> = FeatureConfigBaseExternalApi<P, C> & {
+  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, Requires, false>
+  readonly module: FeatureModule<ROut, DirectRequires, OpenServices, false, never> &
+    IncludesComposition<ROut, N, Identity>
 }
 
 type LazyFeatureConfigExternalApi<
-  P,
+  CompositionProps,
   C extends UiContract,
   ROut,
-  Requires extends ReadonlyArray<FeatureRequirement>,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices,
   SupportOut,
-  SupportRequires extends ReadonlyArray<FeatureRequirement>,
-> = FeatureConfigBaseExternalApi<P, C> & {
+  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 load: Effect.Effect<FeatureModule<ROut, Requires, boolean>, FeatureLoadFailed>
-  readonly placeholder: Placeholders
-  readonly eager?: FeatureModule<SupportOut, SupportRequires, false>
+  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 =
+  | {
+      readonly composition: AnyComposition
+      readonly boot?: ReadonlyArray<Tagged>
+      readonly loadingStrategy?: 'default'
+      readonly module: AnyLoadedModule
+    }
+  | {
+      readonly composition: AnyComposition
+      readonly boot?: ReadonlyArray<Tagged>
+      readonly loadingStrategy: 'lazy'
+      readonly input?: Schema.Schema.Any
+      readonly load: Effect.Effect<AnyLoadedModule, FeatureLoadFailed>
+      readonly placeholder: {
+        readonly loading: AnyComposition
+        readonly failed: AnyComposition
+      }
+      readonly eager?: AnyLoadedModule
+    }
+
+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
 }
 
-export function make<
+const makeFeatureManifest = (
+  name: string,
+  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 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,
-  Requires extends ReadonlyArray<FeatureRequirement>,
+  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, Requires>,
-): EagerFeatureClass<P, C, ROut, Requires>
-export function make<
+  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,
+    load,
+    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,
+  })
+}
+
+const makeLazyFeature = <
+  CompositionProps,
   C extends UiContract,
   ROut,
-  Requires extends ReadonlyArray<FeatureRequirement>,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices,
   SupportOut,
-  SupportRequires extends ReadonlyArray<FeatureRequirement>,
+  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<
-    P,
+    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,
-    Requires,
+    DirectRequires,
     SupportOut,
-    SupportRequires
-  > & { readonly eager: FeatureModule<SupportOut, SupportRequires, false> },
-): LazyFeatureClass<P, C, ROut, Requires, SupportRequires>
+    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,
-  Requires extends ReadonlyArray<FeatureRequirement>,
+  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: LazyFeatureConfigExternalApi<P, C, ROut, Requires, never, readonly []>,
-): LazyFeatureClass<P, C, ROut, Requires>
-export function make(
+  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:
+  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<
-        AnyValue,
-        UiContract,
-        never,
-        ReadonlyArray<FeatureRequirement>
+        CompositionProps,
+        C,
+        ROut,
+        DirectRequires,
+        OpenServices,
+        S,
+        N,
+        Identity
       >
     | LazyFeatureConfigExternalApi<
-        AnyValue,
-        UiContract,
-        never,
-        ReadonlyArray<FeatureRequirement>,
-        never,
-        ReadonlyArray<FeatureRequirement>
-      >,
-): AnyFeature {
-  const strategy: 'lazy' | 'default' = config.loadingStrategy ?? 'default'
-  const load = 'load' in config ? config.load : Effect.succeed(config.module)
-  const eagerModule = 'module' in config ? config.module : undefined
-  const supportModule = 'eager' in config ? config.eager : 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,
-      })),
-    ),
+        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}`))
   }
-
-  const binding: FeatureBinding = {
-    [FeatureBindingTypeId]: FeatureBindingTypeId,
-    manifest,
-    composition: config.composition,
-    strategy,
-    load,
-    ...(placeholder ? { placeholder: { loading: placeholder.loading, failed: placeholder.failed } } : {}),
-    boot: Option.getOrElse(Option.fromNullable(config.boot), () => []),
+  if (config.loadingStrategy === 'lazy') {
+    return makeLazyFeature<
+      CompositionProps,
+      C,
+      ROut,
+      DirectRequires,
+      OpenServices,
+      SupportOut,
+      SupportDirectRequires,
+      SupportOpenServices,
+      S,
+      N,
+      Identity,
+      Composition,
+      InputSchema,
+      Loading,
+      Failed
+    >(name, config)
   }
-
-  return definitionClass<AnyFeature>({
-    manifest,
-    load,
-    binding,
-    eagerModule,
-    supportModule,
-    composition: config.composition,
-  })
+  return makeEagerFeature<
+    CompositionProps,
+    C,
+    ROut,
+    DirectRequires,
+    OpenServices,
+    S,
+    N,
+    Identity,
+    Composition
+  >(name, config)
 }
 
-// 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>,
-  props?: unknown,
-): Effect.Effect<Context.Context<unknown>, FeatureLoadFailed, Scope.Scope> =>
-  Effect.gen(function* () {
-    const module = 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 = module.layer as Layer.Layer<unknown, never, R | FeatureInput>
-    const featureContext = Context.add(engineContext, FeatureInput, props)
-    const context = yield* Layer.build(
-      Layer.provideMerge(featureLayer, Layer.succeedContext(featureContext)),
-    )
-    yield* Effect.forEach(binding.boot, (event) => publish('High', event), { discard: true }).pipe(
-      Effect.provide(context),
-    )
-    return context
-  })
+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)
+})