@playfast/reform 1.1.1 → 1.2.1

package/src/feature/featureConfig.ts

@@ -0,0 +1,192 @@
+import type { Effect } from 'effect'
+import { Schema } from 'effect'
+import type {
+  AnyComposition,
+  CompositionClass,
+  CompositionPropsReceiver,
+  HasExactCompositionId,
+} from '../compose/composition'
+import type { UiContract } from '../compose/ui'
+import type { AnyFeatureGraphSummary } from '../graph/closure'
+import type { FeatureLoadFailed } from '../internal/errors'
+import type { Tagged } from '../runtime/bus'
+import {
+  type AnyFeatureBinding,
+  type FailedProps,
+  type FeatureManifest,
+  FeatureNativeTypeId,
+  type FeatureToken,
+} from './featureBinding'
+import type { AnyLoadedModule, FeatureModule } from './featureModule'
+import type { FeatureRequirement } from './featureRequirement'
+
+export interface RuntimeFeatureTree {
+  readonly composition: AnyComposition
+  readonly load: Effect.Effect<AnyLoadedModule, FeatureLoadFailed>
+  readonly binding: AnyFeatureBinding
+  readonly eagerModule: AnyLoadedModule | undefined
+  readonly supportModule: AnyLoadedModule | undefined
+}
+
+export 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)
+
+export 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
+
+export type FeatureUsesInput<InputSchema extends Schema.Schema.AnyNoContext> = [InputSchema] extends [
+  never,
+]
+  ? false
+  : true
+
+export type FeatureInputValue<InputSchema extends Schema.Schema.AnyNoContext> = [InputSchema] extends [
+  never,
+]
+  ? never
+  : Schema.Schema.Type<InputSchema>
+
+export 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>
+}
+
+export interface ExactFeatureCompositionConfig<Composition extends AnyComposition> {
+  readonly composition: Composition
+}
+
+export type IncludesComposition<ROut, N extends string, Identity> =
+  HasExactCompositionId<ROut, N, Identity> extends true
+    ? object
+    : {
+        readonly missingCompositionService: 'The feature module must provide its root composition'
+      }
+
+export 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>
+}
+
+export 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)
+
+export 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
+    }
+
+export 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))
+
+export type RuntimePlaceholders = {
+  readonly loading: AnyComposition
+  readonly failed: AnyComposition
+}

package/src/feature/featureFactory.ts

@@ -0,0 +1,163 @@
+import { type Effect, Option, Schema } from 'effect'
+import type { AnyComposition, CompositionClass } from '../compose/composition'
+import type { UiContract } from '../compose/ui'
+import {
+  type AnyFeatureGraphSummary,
+  FeatureChildSummaryTypeId,
+  FeatureGraphSummaryTypeId,
+  FeatureGraphValidTypeId,
+  FeatureModuleGraphValidTypeId,
+  type FeatureSummaryCompositionIdentity,
+  type FeatureSummaryCompositionProps,
+  type FeatureSummaryContract,
+  type FeatureSummaryInput,
+  type FeatureSummaryName,
+  type FeatureSummaryOpenServices,
+  type FeatureSummaryStates,
+  type FeatureSummaryUsesInput,
+  SlotBindingSummaryTypeId,
+} from '../graph/closure'
+import type { FeatureLoadFailed } from '../internal/errors'
+import type { Tagged } from '../runtime/bus'
+import {
+  type FeatureBinding,
+  type FeatureBindingCapture,
+  FeatureBindingTypeId,
+  type FeatureManifest,
+} from './featureBinding'
+import type { RuntimePlaceholders } from './featureConfig'
+import type { LoadedModule } from './featureModule'
+import type { FeatureSummaryOf } from './featureNativeTree'
+import type { FeatureRequirement } from './featureRequirement'
+
+export 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),
+          }),
+        ),
+    )
+
+export 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,
+  },
+})
+
+export 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
+}

package/src/feature/featureModule.ts

@@ -0,0 +1,136 @@
+import { Effect, type Layer, type Schema } from 'effect'
+import {
+  FeatureModuleGraphValidTypeId,
+  type ModuleOpenServices,
+  type ValidateFeatureGraphLayer,
+} from '../graph/closure'
+import { FeatureLoadFailed } from '../internal/errors'
+import type {
+  DefaultFeatureOpenServices,
+  FeatureModuleInput,
+  FeatureRequirement,
+} from './featureRequirement'
+
+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
+}
+
+export type FeatureLayerOutput<L extends Layer.Layer.Any> = Layer.Layer.Success<L>
+
+// Reject erased contexts before graph validation can mistake them for permissive inputs.
+export 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 LoadedModule<
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices = DefaultFeatureOpenServices<ROut, DirectRequires>,
+  UsesInput extends boolean = false,
+  Input = never,
+> extends FeatureModule<ROut, DirectRequires, OpenServices, UsesInput, Input> {}

package/src/feature/featureModule.typecheck.ts

@@ -0,0 +1,63 @@
+import { Context, Layer, Schema as S } from 'effect'
+import * as State from '../state/state'
+import * as StateGroup from '../state/stateGroup'
+import { type EngineServices, type FeatureModule, featureModule } from './feature'
+
+const FeedStateBase: State.StateClass<'feed', string> = State.make('feed', S.String)
+class FeedState extends FeedStateBase {}
+const FilterStateBase: State.StateClass<'filter', string> = State.make('filter', S.String)
+class FilterState extends FilterStateBase {}
+const TodosStatesBase: StateGroup.StateGroupClass<readonly [typeof FeedState, typeof FilterState]> =
+  StateGroup.make(FeedState, FilterState)
+class TodosStates extends TodosStatesBase {}
+
+interface ClockService {
+  readonly now: () => number
+}
+const ClockBase: Context.TagClass<Clock, 'feature.typecheck.Clock', ClockService> = Context.Tag(
+  'feature.typecheck.Clock',
+)<Clock, ClockService>()
+export class Clock extends ClockBase {}
+
+declare const readsFeed: Layer.Layer<
+  { readonly _out: true },
+  never,
+  State.StateStore<'feed', string> | EngineServices
+>
+
+declare const readsTodos: Layer.Layer<
+  { readonly _out: true },
+  never,
+  State.StateStore<'feed', string> | State.StateStore<'filter', string> | EngineServices
+>
+
+const okState: FeatureModule<{ readonly _out: true }, readonly [typeof FeedState]> = featureModule(
+  [FeedState],
+  readsFeed,
+)
+
+const okGroup: FeatureModule<{ readonly _out: true }, readonly [typeof TodosStates]> =
+  featureModule([TodosStates], readsTodos)
+
+const badEmpty =
+  // @ts-expect-error feature layer reads a store it does not declare in `requires`
+  featureModule([], readsFeed)
+
+declare const readsClock: Layer.Layer<{ readonly _clock: true }, never, Clock | EngineServices>
+
+export const okService: FeatureModule<{ readonly _clock: true }, readonly [typeof Clock]> =
+  featureModule([Clock], readsClock)
+
+const badService =
+  // @ts-expect-error feature layer reads an ordinary Context service it did not declare
+  featureModule([], readsClock)
+
+declare const privateEngine: Layer.Layer<EngineServices, never, EngineServices>
+// @ts-expect-error a Feature module cannot provide its own Engine services
+const invalidPrivateEngine = featureModule([], privateEngine)
+
+void okState
+void okGroup
+void badEmpty
+void badService
+void invalidPrivateEngine

package/src/feature/featureNativeTree.ts

@@ -0,0 +1,152 @@
+import type { Effect } from 'effect'
+import type { CompositionClass } from '../compose/composition'
+import type { UiContract } from '../compose/ui'
+import type {
+  AnyFeatureGraphSummary,
+  FeatureGraphSummary,
+  FeatureSummaryCompositionIdentity,
+  FeatureSummaryCompositionProps,
+  FeatureSummaryContract,
+  FeatureSummaryInput,
+  FeatureSummaryName,
+  FeatureSummaryOpenServices,
+  FeatureSummaryStates,
+  FeatureSummarySupportOpenServices,
+  FeatureSummaryUsesInput,
+} from '../graph/closure'
+import type { FeatureLoadFailed } from '../internal/errors'
+import type { CapturedFeatureBinding } from './featureBinding'
+import type { FeatureModule } from './featureModule'
+import type { FeatureRequirement } from './featureRequirement'
+
+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
+}
+
+export 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
+>