@playfast/reform 1.1.1 → 1.2.1

package/src/feature/feature.typecheck.ts

@@ -1,121 +1,254 @@
-import { Context, Layer, Schema as S } from 'effect'
-import type { Store } from '../internal/store'
+import { Layer, Schema as S } from 'effect'
 import * as Composition from '../compose/composition'
 import { provide } from '../compose/provide'
-import { type SlotChild, type SlotClass, slot } from '../compose/slot'
+import {
+  type ContractOfSlotTarget,
+  type FeatureSlotTarget,
+  type PropsOfSlotTarget,
+  type SlotChild,
+  type SlotService,
+  slot,
+} from '../compose/slot'
+import { mount } from '../compose/structure'
 import { type Contract, type UiClass, ui } from '../compose/ui'
-import * as State from '../state/state'
-import * as StateGroup from '../state/stateGroup'
+import { scene } from '../scene/scene'
 import { type EngineServices, type FeatureModule, featureModule, lazyImport } from './feature'
 import * as Feature from './feature'
+import { Clock, okService } from './featureModule.typecheck'
 
-const FeedStateBase: State.StateClass<'feed', string> = State.make('feed', S.String)
-class FeedState extends FeedStateBase {}
-const FilterStateBase: State.StateClass<'filter', string> = State.make('filter', S.String)
-class FilterState extends FilterStateBase {}
-const TodosStatesBase: StateGroup.StateGroupClass<readonly [typeof FeedState, typeof FilterState]> =
-  StateGroup.make(FeedState, FilterState)
-class TodosStates extends TodosStatesBase {}
 
-interface ClockService {
-  readonly now: () => number
-}
-const ClockBase: Context.TagClass<Clock, 'feature.typecheck.Clock', ClockService> = Context.Tag(
-  'feature.typecheck.Clock',
-)<Clock, ClockService>()
-class Clock extends ClockBase {}
-
-declare const readsFeed: Layer.Layer<{ readonly _out: true }, never, Store<string> | EngineServices>
+const AppUiBase: UiClass<{ props: { readonly a: string }; events: {} }, 'AppUi'> = ui('AppUi')<{
+  props: { readonly a: string }
+  events: {}
+}>()
+class AppUi extends AppUiBase {}
+class AppComp extends Composition.make('AppComp', {
+  title: 'App',
+  props: S.Struct({ a: S.String }),
+  ui: AppUi,
+})<AppComp>() {}
+const AppLive = Composition.live(AppComp, function* () {
+  const props = yield* AppComp.props
+  return mount({ props: { a: props.a }, slots: {} })
+})
+declare const FailedPlaceholder: Composition.AnyComposition &
+  Composition.CompositionPropsReceiver<Feature.FailedProps>
 
-export const okState: FeatureModule<{ readonly _out: true }, readonly [typeof FeedState]> =
-  featureModule([FeedState], readsFeed)
+class AppFeature extends Feature.make('appFeature', {
+  loadingStrategy: 'lazy',
+  composition: AppComp,
+  load: lazyImport(async () => ({ default: featureModule([], AppLive) })),
+  placeholder: { loading: AppComp, failed: FailedPlaceholder },
+}) {}
+type AppFeatureTarget = FeatureSlotTarget<typeof AppFeature>
+class AppFeatureSlot extends slot('AppFeature')<AppFeatureSlot, AppFeatureTarget>() {}
 
-export const okGroup: FeatureModule<{ readonly _out: true }, readonly [typeof TodosStates]> =
-  featureModule([TodosStates], readsFeed)
+class EmptyAppFeature extends Feature.make('emptyAppFeature', {
+  composition: AppComp,
+  // @ts-expect-error Layer.empty does not provide CompositionId<'AppComp'>
+  module: featureModule([], Layer.empty),
+}) {}
 
-export const badEmpty: FeatureModule<{ readonly _out: true }, readonly []> =
-  // @ts-expect-error feature layer reads a store it does not declare in `requires`
-  featureModule([], readsFeed)
+declare const exactUnionModule: FeatureModule<
+  Composition.CompositionId<'AppComp', AppComp> | Clock,
+  readonly []
+>
 
-declare const readsClock: Layer.Layer<{ readonly _clock: true }, never, Clock | EngineServices>
+class ExactUnionAppFeature extends Feature.make('exactUnionAppFeature', {
+  composition: AppComp,
+  module: exactUnionModule,
+}) {}
 
-export const okService: FeatureModule<{ readonly _clock: true }, readonly [typeof Clock]> =
-  featureModule([Clock], readsClock)
+declare const unknownRootModule: FeatureModule<unknown, readonly []>
+class UnknownRootAppFeature extends Feature.make('unknownRootAppFeature', {
+  composition: AppComp,
+  // @ts-expect-error unknown output does not prove the exact root composition service
+  module: unknownRootModule,
+}) {}
 
-export const badService: FeatureModule<{ readonly _clock: true }, readonly []> =
-  // @ts-expect-error feature layer reads an ordinary Context service it did not declare
-  featureModule([], readsClock)
+declare const broadRootModule: FeatureModule<
+  Composition.CompositionId<string, unknown>,
+  readonly []
+>
+class BroadRootAppFeature extends Feature.make('broadRootAppFeature', {
+  composition: AppComp,
+  // @ts-expect-error a broad identifier does not prove the exact root identity
+  module: broadRootModule,
+}) {}
 
-const AppUiBase: UiClass<{ props: { readonly a: string }; events: {} }> = ui('AppUi')<{
-  props: { readonly a: string }
-  events: {}
-}>()
-class AppUi extends AppUiBase {}
-const AppCompBase: Composition.CompositionClass<{ readonly a: string }, Contract<typeof AppUi>> =
-  Composition.make('AppComp', {
-    title: 'App',
-    props: S.Struct({ a: S.String }),
-    ui: AppUi,
-  })
-class AppComp extends AppCompBase {}
-const AppSlotBase: SlotClass<typeof AppComp> = slot('App')<typeof AppComp>()
-class AppSlot extends AppSlotBase {}
-
-const AppFeatureBase: Feature.FeatureClass<
-  { readonly a: string },
-  Contract<typeof AppUi>,
+declare const exactUnionLayer: Layer.Layer<
+  Composition.CompositionId<'AppComp', AppComp> | Clock,
   never,
-  readonly []
-> = Feature.make('appFeature', {
+  never
+>
+
+const exactUnionScene = scene(AppComp, { provide: [exactUnionLayer] })
+
+declare const unknownRootLayer: Layer.Layer<unknown, never, never>
+// @ts-expect-error unknown services do not prove the exact scene root
+const unknownRootScene = scene(AppComp, { provide: [unknownRootLayer] })
+
+declare const broadRootLayer: Layer.Layer<Composition.CompositionId<string, unknown>, never, never>
+// @ts-expect-error a broad composition identifier does not prove the exact scene root
+const broadRootScene = scene(AppComp, { provide: [broadRootLayer] })
+
+
+const wired = provide(AppFeatureSlot, AppFeature)
+
+type Equal<Left, Right> =
+  (<Value>() => Value extends Left ? 1 : 2) extends <Value>() => Value extends Right ? 1 : 2
+    ? true
+    : false
+type Assert<Condition extends true> = Condition
+type WiredRequirementsAreExact = Assert<Equal<Layer.Layer.Context<typeof wired>, EngineServices>>
+type WiredOutputIsOnlySummary = Assert<
+  Equal<
+    Layer.Layer.Success<typeof wired>,
+    SlotService<'AppFeature', AppFeatureSlot, typeof AppFeature.summary>
+  >
+>
+type FeatureTargetSummaryIsExact = Assert<
+  Equal<AppFeatureTarget['summary'], typeof AppFeature.summary>
+>
+type FeatureTargetPropsAreExact = Assert<
+  Equal<PropsOfSlotTarget<AppFeatureTarget>, { readonly a: string }>
+>
+type FeatureTargetContractIsExact = Assert<
+  Equal<ContractOfSlotTarget<AppFeatureTarget>, Contract<typeof AppUi>>
+>
+type FeatureTargetCannotOpenTree = Assert<
+  Equal<AppFeatureTarget extends Feature.FeatureTreeCarrier ? true : false, false>
+>
+const appNative = Feature.tree<typeof AppFeature>(AppFeature.token)
+type AppNative = typeof appNative
+type ExactTreeComposition = Assert<Equal<AppNative['composition'], typeof AppComp>>
+type NoDirectNativeFields = Assert<
+  Equal<
+    Extract<
+      'composition' | 'binding' | 'load' | 'eagerModule' | 'supportModule' | 'tree',
+      keyof typeof AppFeature
+    >,
+    never
+  >
+>
+
+class AppFeatureTwin extends Feature.make('appFeature', {
   loadingStrategy: 'lazy',
   composition: AppComp,
-  load: lazyImport(async () => ({ default: featureModule([], Layer.empty) })),
-  placeholder: { loading: AppComp, failed: AppComp },
-})
-class AppFeature extends AppFeatureBase {}
-
-export const wired: Layer.Layer<SlotChild, never, EngineServices> = provide(AppSlot, AppFeature)
+  load: lazyImport(async () => ({ default: featureModule([], AppLive) })),
+  placeholder: { loading: AppComp, failed: FailedPlaceholder },
+}) {}
+type SameCompositionTokenIsInterchangeable = Assert<
+  Equal<typeof AppFeatureTwin.token extends typeof AppFeature.token ? true : false, true>
+>
+type BroadFeatureIdentityIsRejected = Assert<
+  Equal<
+    Feature.FeatureIdentityToken<unknown> extends Feature.FeatureIdentityToken<AppComp>
+      ? true
+      : false,
+    false
+  >
+>
+
+class AppCompositionSlot extends slot('AppComposition')<AppCompositionSlot, typeof AppComp>() {}
+
+// @ts-expect-error composition slots accept the Composition value, not a Feature
+provide(AppCompositionSlot, AppFeature)
 
 class SupportedAppFeature extends Feature.make('supportedAppFeature', {
   loadingStrategy: 'lazy',
   composition: AppComp,
-  load: lazyImport(async () => ({ default: featureModule([], Layer.empty) })),
+  load: lazyImport(async () => ({ default: featureModule([], AppLive) })),
   eager: okService,
-  placeholder: { loading: AppComp, failed: AppComp },
+  placeholder: { loading: AppComp, failed: FailedPlaceholder },
 }) {}
-
-export const wiredWithSupport: Layer.Layer<SlotChild, never, EngineServices | Clock> = provide(
-  AppSlot,
-  SupportedAppFeature,
-)
-
-const OtherUiBase: UiClass<{ props: { readonly n: number }; events: {} }> = ui('OtherUi')<{
+type SupportedAppFeatureTarget = FeatureSlotTarget<typeof SupportedAppFeature>
+class SupportedAppFeatureSlot extends slot('SupportedAppFeature')<
+  SupportedAppFeatureSlot,
+  SupportedAppFeatureTarget
+>() {}
+
+const wiredWithSupport = provide(SupportedAppFeatureSlot, SupportedAppFeature)
+type SupportedRequirementsAreExact = Assert<
+  Equal<Layer.Layer.Context<typeof wiredWithSupport>, EngineServices | Clock>
+>
+type SupportedOutputIsOnlySummary = Assert<
+  Equal<
+    Layer.Layer.Success<typeof wiredWithSupport>,
+    SlotService<'SupportedAppFeature', SupportedAppFeatureSlot, typeof SupportedAppFeature.summary>
+  >
+>
+
+const OtherUiBase: UiClass<{ props: { readonly n: number }; events: {} }, 'OtherUi'> = ui(
+  'OtherUi',
+)<{
   props: { readonly n: number }
   events: {}
 }>()
 class OtherUi extends OtherUiBase {}
-const OtherCompBase: Composition.CompositionClass<{ readonly n: number }, Contract<typeof OtherUi>> =
-  Composition.make('OtherComp', {
-    title: 'Other',
-    props: S.Struct({ n: S.Number }),
-    ui: OtherUi,
-  })
-class OtherComp extends OtherCompBase {}
-const OtherFeatureBase: Feature.FeatureClass<
-  { readonly n: number },
-  Contract<typeof OtherUi>,
-  never,
-  readonly []
-> = Feature.make('otherFeature', {
+class OtherComp extends Composition.make('OtherComp', {
+  title: 'Other',
+  props: S.Struct({ n: S.Number }),
+  ui: OtherUi,
+})<OtherComp>() {}
+const OtherLive = Composition.live(OtherComp, function* () {
+  const props = yield* OtherComp.props
+  return mount({ props, slots: {} })
+})
+class OtherFeature extends Feature.make('otherFeature', {
   loadingStrategy: 'lazy',
   composition: OtherComp,
-  load: lazyImport(async () => ({ default: featureModule([], Layer.empty) })),
-  placeholder: { loading: OtherComp, failed: OtherComp },
-})
-class OtherFeature extends OtherFeatureBase {}
+  load: lazyImport(async () => ({ default: featureModule([], OtherLive) })),
+  placeholder: { loading: OtherComp, failed: FailedPlaceholder },
+}) {}
 
-// @ts-expect-error feature composition does not match the slot's child type
-export const mismatched: Layer.Layer<SlotChild, never, EngineServices> = provide(
-  AppSlot,
-  OtherFeature,
-)
+type OtherFeatureIsRejectedByAppTarget = Assert<
+  Equal<typeof OtherFeature extends AppFeatureTarget ? true : false, false>
+>
+type DifferentCompositionTokenIsRejected = Assert<
+  Equal<typeof OtherFeature.token extends typeof AppFeature.token ? true : false, false>
+>
+const otherNative = Feature.tree<typeof OtherFeature>(OtherFeature.token)
+type OtherNative = typeof otherNative
+type DifferentCompositionBindingIsRejected = Assert<
+  Equal<OtherNative['binding'] extends SlotChild<AppFeatureTarget> ? true : false, false>
+>
+
+// @ts-expect-error OtherFeature.token does not belong to AppFeature
+Feature.tree<typeof AppFeature>(OtherFeature.token)
+
+// @ts-expect-error AppFeatureSlot accepts only features over AppComp
+provide(AppFeatureSlot, OtherFeature)
+
+type FeatureTypeProofs = [
+  WiredRequirementsAreExact,
+  WiredOutputIsOnlySummary,
+  FeatureTargetSummaryIsExact,
+  FeatureTargetPropsAreExact,
+  FeatureTargetContractIsExact,
+  FeatureTargetCannotOpenTree,
+  ExactTreeComposition,
+  NoDirectNativeFields,
+  SameCompositionTokenIsInterchangeable,
+  BroadFeatureIdentityIsRejected,
+  DifferentCompositionTokenIsRejected,
+  DifferentCompositionBindingIsRejected,
+  SupportedRequirementsAreExact,
+  SupportedOutputIsOnlySummary,
+  OtherFeatureIsRejectedByAppTarget,
+]
+declare const featureTypeProofs: FeatureTypeProofs
+
+void featureTypeProofs
+void appNative
+void otherNative
+void AppFeatureTwin
+void EmptyAppFeature
+void ExactUnionAppFeature
+void UnknownRootAppFeature
+void BroadRootAppFeature
+void exactUnionScene
+void unknownRootScene
+void broadRootScene
+
+export {}

package/src/feature/featureBinding.ts

@@ -1,9 +1,23 @@
-import { Effect, Layer, Option } from 'effect'
+import type { Effect, Option } from 'effect'
+import type { AnyComposition, CompositionClass } from '../compose/composition'
 import type { Manifest } from '../definition/definition'
-import type { CompositionClass } from '../compose/composition'
-import type { Tagged } from '../runtime/bus'
+import {
+  type AnyFeatureGraphSummary,
+  FeatureGraphValidTypeId,
+  type FeatureSummaryCompositionIdentity,
+  type FeatureSummaryCompositionProps,
+  type FeatureSummaryContract,
+  type FeatureSummaryInput,
+  type FeatureSummaryName,
+  type FeatureSummaryOpenServices,
+  type FeatureSummaryStates,
+  type FeatureSummarySupportOpenServices,
+  type FeatureSummaryUsesInput,
+} from '../graph/closure'
 import type { FeatureLoadFailed } from '../internal/errors'
-import type { FeatureRequirement } from './feature'
+import type { Tagged } from '../runtime/bus'
+import type { LoadedModule } from './featureModule'
+import type { FeatureRequirement } from './featureRequirement'
 
 export interface FailedProps {
   readonly error: FeatureLoadFailed
@@ -21,28 +35,124 @@ export interface FeatureManifest extends Manifest {
   }>
 }
 
-export interface LoadedModule {
-  readonly requires: ReadonlyArray<FeatureRequirement>
-  readonly usesInput: boolean
-  readonly layer: Layer.Layer<never, never, unknown>
-}
-
 export const FeatureBindingTypeId: unique symbol = Symbol.for('reform/FeatureBinding')
 export type FeatureBindingTypeId = typeof FeatureBindingTypeId
+export type FeatureBindingType = FeatureBindingTypeId
+
+export const FeatureTokenIdentityTypeId: unique symbol = Symbol('reform/FeatureTokenIdentity')
+export const FeatureNativeTypeId: unique symbol = Symbol('reform/FeatureNative')
+
+export interface FeatureIdentityToken<out FeatureIdentity> {
+  readonly identity: symbol
+  readonly [FeatureTokenIdentityTypeId]: readonly [] | readonly [FeatureIdentity]
+}
 
-export interface FeatureBindingExternalApi {
+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>
-  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>
 }
-export type FeatureBinding = FeatureBindingExternalApi
 
-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

package/src/feature/featureClass.ts

@@ -0,0 +1,162 @@
+import type { CompositionClass } from '../compose/composition'
+import type { UiContract } from '../compose/ui'
+import type { FeatureDefinition } from './featureBinding'
+import type {
+  EagerFeatureNativeTree,
+  FeatureNativeTree,
+  FeatureSummaryOf,
+  LazyFeatureNativeTree,
+} from './featureNativeTree'
+import type {
+  DefaultFeatureOpenServices,
+  FeatureRequirement,
+  RootCompositionIdentity,
+  RootCompositionName,
+} from './featureRequirement'
+
+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
+  >
+>