@playfast/reform 1.2.0 → 1.2.1

package/src/feature/feature.ts

@@ -1,1174 +1,57 @@
-import { Context, Effect, Layer, Option, Schema, type Scope } from 'effect'
+import { Effect, type Schema } from 'effect'
+import type { AnyComposition, CompositionClass } from '../compose/composition'
+import type { UiContract } from '../compose/ui'
+import { FeatureGraphValidTypeId } from '../graph/closure'
+import type { EagerFeatureClass, LazyFeatureClass } from './featureClass'
 import {
-  type AnyComposition,
-  CompositionIdTypeId,
-  type CompositionClass,
-  type HasExactCompositionId,
-  type CompositionPropsReceiver,
-} from '../compose/composition'
-import { type UiContract } from '../compose/ui'
-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'
+  type EagerFeatureConfigExternalApi,
+  type ExactFeatureCompositionConfig,
+  type FeatureMountProps,
+  type FeatureUsesInput,
+  isMakeImplementationConfig,
+  type LazyFeatureConfigExternalApi,
+} from './featureConfig'
+import type { FeatureRequirement } from './featureRequirement'
+import { makeEagerFeature, makeLazyFeature } from './featureVariants'
 
 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 =
-  | 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
-  }
-}
-  ? 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> =>
-  Effect.tryPromise({
-    try: thunk,
-    catch: (cause) => new FeatureLoadFailed({ cause }),
-  }).pipe(Effect.map((module) => module.default))
-
-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,
-  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 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 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,
-  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
->
-
-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
-  >
->
-
-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 &&
-  '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,
-  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 =
-  | {
-      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
-}
-
-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,
-  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,
-    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,
-  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 { FeatureInput } from './featureRequirement'
+export type {
+  FeatureModuleInput,
+  FeatureRequirement,
+  ProvidedBy,
+  RequireCarrier,
+} from './featureRequirement'
+export { featureModule, featureModuleFromInput, lazyImport } from './featureModule'
+export type { AnyLoadedModule, FeatureModule, LoadedModule, LoadedModuleCapture } from './featureModule'
+export { FeatureBindingTypeId, isFeatureBinding, tree } from './featureBinding'
+export type {
+  AnyFeatureBinding,
+  AnyFeatureBindingExternalApi,
+  CapturedFeatureBinding,
+  FailedProps,
+  FeatureBinding,
+  FeatureBindingCapture,
+  FeatureBindingType,
+  FeatureDefinition,
+  FeatureIdentityToken,
+  FeatureManifest,
+  FeatureOpenServices,
+  FeatureSupportOpenServices,
+  FeatureToken,
+  FeatureTreeCarrier,
+  ProvideableFeature,
+} from './featureBinding'
+export type {
+  EagerFeatureNativeTree,
+  FeatureNativeTree,
+  LazyFeatureNativeTree,
+} from './featureNativeTree'
+export type { EagerFeatureClass, FeatureClass, LazyFeatureClass } from './featureClass'
+export { isFeature } from './featureConfig'
+export type { FeatureMountProps, Placeholders } from './featureConfig'
+export { mountFeature } from './mountFeature'
 
 export function make<
   P,
@@ -1366,46 +249,3 @@ export function make<
     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)
-})