@playfast/reform 1.1.1 → 1.2.1

package/src/graph/summary.ts

@@ -0,0 +1,134 @@
+import type { UiContract } from '../compose/ui'
+
+export const FeatureGraphValidTypeId: unique symbol = Symbol.for('reform/FeatureGraphValid')
+export type FeatureGraphValidTypeId = typeof FeatureGraphValidTypeId
+
+export const FeatureModuleGraphValidTypeId: unique symbol = Symbol.for(
+  'reform/FeatureModuleGraphValid',
+)
+export type FeatureModuleGraphValidTypeId = typeof FeatureModuleGraphValidTypeId
+
+export const FeatureChildSummaryTypeId: unique symbol = Symbol.for('reform/FeatureChildSummary')
+export type FeatureChildSummaryTypeId = typeof FeatureChildSummaryTypeId
+
+export const FeatureGraphSummaryTypeId: unique symbol = Symbol.for('reform/FeatureGraphSummary')
+export type FeatureGraphSummaryTypeId = typeof FeatureGraphSummaryTypeId
+
+export const SlotBindingSummaryTypeId: unique symbol = Symbol.for('reform/SlotBindingSummary')
+export type SlotBindingSummaryTypeId = typeof SlotBindingSummaryTypeId
+
+export interface SlotBindingSummary {
+  readonly [SlotBindingSummaryTypeId]: SlotBindingSummaryTypeId
+}
+
+/**
+ * The constant-size proof published after a Feature's current module has passed
+ * graph validation. Type-only facts use empty-or-singleton tuples so the runtime
+ * summary stays compact while direct indexed access recovers their exact types.
+ */
+export interface FeatureGraphSummary<
+  out FeatureIdentity,
+  out MountProps,
+  out CompositionProps,
+  out C extends UiContract,
+  out S extends ReadonlyArray<unknown>,
+  out N extends string,
+  out CompositionIdentity,
+  out OpenServices,
+  out SupportOpenServices,
+  out UsesInput extends boolean,
+  out Input,
+> extends SlotBindingSummary {
+  readonly [FeatureGraphSummaryTypeId]: {
+    readonly featureIdentity: readonly [] | readonly [FeatureIdentity]
+    readonly mountProps: readonly [] | readonly [MountProps]
+    readonly compositionProps: readonly [] | readonly [CompositionProps]
+    readonly contract: readonly [] | readonly [C]
+    readonly states: readonly [] | readonly [S]
+    readonly name: N
+    readonly compositionIdentity: readonly [] | readonly [CompositionIdentity]
+    readonly openServices: readonly [] | readonly [OpenServices]
+    readonly supportOpenServices: readonly [] | readonly [SupportOpenServices]
+    readonly usesInput: readonly [] | readonly [UsesInput]
+    readonly input: readonly [] | readonly [Input]
+    readonly validated: FeatureModuleGraphValidTypeId
+  }
+  readonly [FeatureChildSummaryTypeId]: {
+    readonly featureIdentity: readonly [] | readonly [FeatureIdentity]
+    readonly compositionIdentity: readonly [] | readonly [CompositionIdentity]
+  }
+}
+
+export type FeatureChildSummary<
+  FeatureIdentity,
+  MountProps,
+  CompositionProps,
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  CompositionIdentity,
+  OpenServices,
+  SupportOpenServices,
+  UsesInput extends boolean,
+  Input,
+> = FeatureGraphSummary<
+  FeatureIdentity,
+  MountProps,
+  CompositionProps,
+  C,
+  S,
+  N,
+  CompositionIdentity,
+  OpenServices,
+  SupportOpenServices,
+  UsesInput,
+  Input
+>
+
+export type AnyFeatureGraphSummary = FeatureGraphSummary<
+  unknown,
+  unknown,
+  unknown,
+  UiContract,
+  ReadonlyArray<unknown>,
+  string,
+  unknown,
+  unknown,
+  unknown,
+  boolean,
+  unknown
+>
+
+export type FeatureSummaryIdentity<Summary extends AnyFeatureGraphSummary> =
+  Summary[FeatureGraphSummaryTypeId]['featureIdentity'][number]
+export type FeatureSummaryMountProps<Summary extends AnyFeatureGraphSummary> =
+  Summary[FeatureGraphSummaryTypeId]['mountProps'][number]
+export type FeatureSummaryCompositionProps<Summary extends AnyFeatureGraphSummary> =
+  Summary[FeatureGraphSummaryTypeId]['compositionProps'][number]
+export type FeatureSummaryContract<Summary extends AnyFeatureGraphSummary> =
+  Summary[FeatureGraphSummaryTypeId]['contract'][number]
+export type FeatureSummaryStates<Summary extends AnyFeatureGraphSummary> =
+  Summary[FeatureGraphSummaryTypeId]['states'][number]
+export type FeatureSummaryName<Summary extends AnyFeatureGraphSummary> =
+  Summary[FeatureGraphSummaryTypeId]['name']
+export type FeatureSummaryCompositionIdentity<Summary extends AnyFeatureGraphSummary> =
+  Summary[FeatureGraphSummaryTypeId]['compositionIdentity'][number]
+export type FeatureSummaryOpenServices<Summary extends AnyFeatureGraphSummary> =
+  Summary[FeatureGraphSummaryTypeId]['openServices'][number]
+export type FeatureSummarySupportOpenServices<Summary extends AnyFeatureGraphSummary> =
+  Summary[FeatureGraphSummaryTypeId]['supportOpenServices'][number]
+export type FeatureSummaryUsesInput<Summary extends AnyFeatureGraphSummary> =
+  Summary[FeatureGraphSummaryTypeId]['usesInput'][number]
+export type FeatureSummaryInput<Summary extends AnyFeatureGraphSummary> =
+  Summary[FeatureGraphSummaryTypeId]['input'][number]
+
+export const CompositionChildSummaryTypeId: unique symbol = Symbol.for(
+  'reform/CompositionChildSummary',
+)
+export type CompositionChildSummaryTypeId = typeof CompositionChildSummaryTypeId
+
+export interface CompositionChildSummary<out CompositionIdentity> extends SlotBindingSummary {
+  readonly [CompositionChildSummaryTypeId]: {
+    readonly compositionIdentity: CompositionIdentity
+  }
+}

package/src/index.ts

@@ -1,255 +1,181 @@
-export * as State from "./state/state";
-export * as StateGroup from "./state/stateGroup";
-export * as StateFamily from "./state/stateFamily";
-export { StateToken } from "./state/token";
-export type { AnySource, Source } from "./state/token";
-
-export * as Event from "./event/event";
-// TS2742: plain type export so declaration emit can name EventOf
-export type { EventOf } from "./event/event";
-export * as EventGroup from "./event/eventGroup";
+export * as State from './state/state'
+export type { StateClass, StateStore, StateValue } from './state/state'
+export * as StateGroup from './state/stateGroup'
+export type { SeedsOf } from './state/stateGroup'
+export * as StateFamily from './state/stateFamily'
+export type {
+  FamilyKey,
+  FamilyValue,
+  StateFamilyClass,
+  StateFamilyStore,
+} from './state/stateFamily'
 
-export * as Reducer from "./reducer/reducer";
-export * as Calc from "./calc/calc";
-export * as CalcFamily from "./calc/calcFamily";
-export * as AsyncCalc from "./calc/asyncCalc";
-export { composeCalcs } from "./calc/compose";
+export * as Event from './event/event'
+// TS2742: direct type exports allow declaration emit to name event-derived types.
 export type {
-	InputsObject,
-	InputStores,
-	InvalidateBy,
-} from "./internal/sources";
-export {
-	AsyncData,
-	type AsyncError,
-	type AsyncIdle,
-	type AsyncLoading,
-	type AsyncSuccess,
-} from "./calc/asyncData";
-export { isLoading, type QueryState, toAsyncData } from "./calc/queryState";
-export {
-	noopQueryStore,
-	QueryStore,
-	type QueryStoreApi,
-	resolveQueryStore,
-} from "./internal/queryStore";
-export {
-	noopQueryEvents,
-	QueryEvents,
-	type QueryEventsApi,
-	resolveQueryEvents,
-} from "./internal/queryEvents";
-export * as RemoteState from "./remote/remoteState";
-// TS2742: plain type exports so declaration emit can name pending/failed types
+  EventClass,
+  EventOf,
+  EventPayload,
+  SourceChange,
+  SourceEventConfig,
+  SourceEventConfigExternalApi,
+} from './event/event'
+export * as EventGroup from './event/eventGroup'
+
+export * as Reducer from './reducer/reducer'
+export * as Calc from './calc/calc'
+export type { CalcClass, CalcStore } from './calc/calc'
+export * as CalcFamily from './calc/calcFamily'
+export type { CalcFamilyClass, CalcFamilyStore } from './calc/calcFamily'
+export * as AsyncCalc from './calc/asyncCalc'
+export type { AsyncCalcClass, AsyncCalcStore } from './calc/asyncCalc'
+export { composeCalcs } from './calc/compose'
+export type { InputsObject, InputStores, InvalidateBy } from './internal/sources'
+export {
+  AsyncData,
+  type AsyncError,
+  type AsyncIdle,
+  type AsyncLoading,
+  type AsyncSuccess,
+} from './calc/asyncData'
+export { isLoading, type QueryState, toAsyncData } from './calc/queryState'
+
+export * as RemoteState from './remote/remoteState'
+// TS2742: direct exports keep pending and failed state types nameable.
 export type {
-	FailedIntent,
-	PendingIntent,
-	RemoteStateClass,
-	RemoteStateSettled,
-} from "./remote/remoteState";
-export * as SyncedStore from "./synced/syncedStore";
-// TS2742: plain type export for SyncedSource nameability
-export type { SyncedSource, SyncedStoreClass } from "./synced/syncedStore";
-export * as Boundary from "./boundary/boundary";
-// TS2742: plain type exports for Boundary* nameability
+  FailedIntent,
+  PendingIntent,
+  RemoteStateClass,
+  RemoteStatePendingStore,
+  RemoteStateSettled,
+  RemoteStateTruthStore,
+  RemoteStateVisibleStore,
+} from './remote/remoteState'
+export * as SyncedStore from './synced/syncedStore'
+// TS2742: adapters need a directly nameable synchronized source type.
+export type { SyncedSource, SyncedStoreClass, SyncedStoreIdentifier } from './synced/syncedStore'
+export * as Boundary from './boundary/boundary'
+// TS2742: direct exports keep boundary state types nameable.
 export type {
-	BoundaryErrored,
-	BoundaryPending,
-	BoundaryReady,
-	BoundaryState,
-} from "./boundary/boundary";
-export * as Procedure from "./procedure/procedure";
-export * as Channel from "./channel/channel";
-export * as Namespace from "./namespace/namespace";
-export type { FeatureNamespace } from "./namespace/namespace";
+  BoundaryErrored,
+  BoundaryPending,
+  BoundaryReady,
+  BoundaryState,
+  BoundaryStore,
+} from './boundary/boundary'
 
-export * as Composition from "./compose/composition";
-export type {
-	CompositionClass,
-	CompositionService,
-	Frame,
-	RenderEnv,
-} from "./compose/composition";
-export {
-	absent,
-	each,
-	type EachFill,
-	isStructure,
-	mount,
-	one,
-	type OneFill,
-	type AbsentFill,
-	type SlotFill,
-	type Structure,
-	structureEquals,
-	type StructureSlots,
-	StructureTypeId,
-	when,
-} from "./compose/structure";
-export { Props } from "./compose/props";
-export {
-	isSlot,
-	type Node,
-	slot,
-	type SlotClass,
-	type SlotInstance,
-	type SlotProps,
-	SlotTypeId,
-} from "./compose/slot";
-export { type SlotRenderer } from "./compose/host";
-export * as Ui from "./compose/ui";
-export {
-	type DerivedContract,
-	isUi,
-	type MadeView,
-	ui,
-	type UiClass,
-	type UiContract,
-	type UiManifest,
-	UiTypeId,
-	UiViewContract,
-	type ViewImpl,
-	type WireSchemas,
-	type WiredUi,
-	type WiredUiManifest,
-} from "./compose/ui";
-export { provide } from "./compose/provide";
-export type { Trigger } from "./ui/trigger";
+export * as Procedure from './procedure/procedure'
+export type { ProcedureClass, ProcedureConfig } from './procedure/procedure'
+export * as Channel from './channel/channel'
+export type { ChannelClass, ChannelPolicy } from './channel/channel'
+export * as Namespace from './namespace/namespace'
+export type { FeatureNamespace } from './namespace/namespace'
 
-export * as Wire from "./wire/tree";
-export type { WireNode, WirePatch, WireProp, WireTree } from "./wire/tree";
+export * as Composition from './compose/composition'
+export { liveScoped } from './compose/composition'
+export type {
+  CompositionActivation,
+  CompositionClass,
+  CompositionId,
+  CompositionService,
+  Frame,
+  RenderEnv,
+  ScopedCompositionLiveConfig,
+} from './compose/composition'
+export {
+  absent,
+  type AbsentFill,
+  each,
+  type EachFill,
+  isStructure,
+  mount,
+  one,
+  type OneFill,
+  type SlotFill,
+  type Structure,
+  structureEquals,
+  type StructureSlots,
+  when,
+} from './compose/structure'
+export { Props } from './compose/props'
+export {
+  type CompositionOfSlotTarget,
+  type ContractOfSlotTarget,
+  type FeatureSlotTarget,
+  isSlot,
+  type Node,
+  type PropsOfSlotTarget,
+  slot,
+  type SlotClass,
+  type SlotComposition,
+  type SlotContract,
+  type SlotInstance,
+  type SlotProps,
+  type SlotService,
+  type SlotTarget,
+  type TargetOfSlot,
+} from './compose/slot'
+export * as Ui from './compose/ui'
+export {
+  type CallableView,
+  type DerivedContract,
+  isUi,
+  type MadeView,
+  ui,
+  type UiClass,
+  type UiContract,
+  type UiService,
+  UiViewContract,
+  type ViewImpl,
+} from './compose/ui'
+export { provide, provideExisting, provideMergeExact } from './compose/provide'
+export type { Trigger } from './ui/trigger'
 
-export * as Triggers from "./wire/triggers";
-export {
-	TriggerRegistry,
-	type TriggerHandle,
-	type TriggerRegistryApi,
-	UnknownTrigger,
-} from "./wire/triggers";
+export * as Feature from './feature/feature'
+export {
+  type EagerFeatureClass,
+  type FailedProps,
+  type FeatureClass,
+  featureModule,
+  type FeatureModule,
+  type FeatureModuleInput,
+  isFeature,
+  isFeatureBinding,
+  lazyImport,
+  type LazyFeatureClass,
+  type Placeholders,
+} from './feature/feature'
 
-export * as Feature from "./feature/feature";
 export {
-	type EngineServices,
-	type FailedProps,
-	type FeatureBinding,
-	FeatureBindingTypeId,
-	type FeatureClass,
-	type FeatureRequirement,
-	type FeatureManifest,
-	featureModule,
-	featureModuleFromInput,
-	FeatureInput,
-	type FeatureModule,
-	type EagerFeatureClass,
-	isFeature,
-	isFeatureBinding,
-	lazyImport,
-	type LazyFeatureClass,
-	type LoadedModule,
-	mountFeature,
-	type Placeholders,
-	type ProvidedBy,
-	type RequireCarrier,
-} from "./feature/feature";
-export { type SlotChild } from "./compose/slot";
+  type CapturedScene,
+  featureScene,
+  type FeatureSceneConfig,
+  isScene,
+  type MountedServices,
+  profiledScene,
+  type Scene,
+  scene,
+  sceneInstrumentation,
+  seedScene,
+} from './scene/scene'
 
-export {
-	isScene,
-	type MountedServices,
-	profiledScene,
-	type Scene,
-	type FeatureSceneConfig,
-	featureScene,
-	scene,
-	sceneInstrumentation,
-	seedScene,
-} from "./scene/scene";
-export type { SeedsOf } from "./state/stateGroup";
-
-export {
-	Bus,
-	busLayer,
-	type Envelope,
-	type Priority,
-	publish,
-	type Tagged,
-} from "./runtime/bus";
-export {
-	type AppRuntime,
-	type FeatureMountHandlers,
-	makeAppRuntime,
-	type RuntimeHandle,
-} from "./runtime/appRuntime";
-export {
-	Engine,
-	type ReducerEntry,
-	Reducers,
-	reducersLayer,
-} from "./runtime/loop";
-export {
-	CurrentEventBudget,
-	defaultEventBudget,
-	type EventBudget,
-	type ReformOptions,
-	resolveEventBudget,
-} from "./runtime/eventBudget";
-export {
-	CurrentInstrumentation,
-	type Instrumentation,
-	noopInstrumentation,
-	resolveInstrumentation,
-	type SpanEnd,
-} from "./runtime/instrumentation";
-export {
-	Queries,
-	queriesLayer,
-	type QueryHandle,
-	type QueryRegistry,
-} from "./runtime/queries";
-export {
-	type ChannelClass,
-	type ChannelPolicy,
-	type ChannelRuntime,
-	Channels,
-	channelsLayer,
-	type ProcedureEntry,
-	Procedures,
-	proceduresLayer,
-} from "./channel/channel";
-export {
-	CurrentTracker,
-	type Subscribable,
-	type Tracker,
-} from "./internal/track";
-export {
-	CaptureSink,
-	type CaptureSinkApi,
-	type UiCapture,
-} from "./internal/capture";
-export {
-	AsyncReducer,
-	AsyncSceneLayer,
-	DuplicateRegistration,
-	EventLoopOverflow,
-	FeatureLoadFailed,
-	forceSync,
-	InvalidProvideTarget,
-	UnknownGroupState,
-} from "./internal/errors";
-export {
-	defaultScheduler,
-	makeScheduler,
-	Notifications,
-	notificationsLayer,
-	resolveScheduler,
-	type Scheduler,
-} from "./internal/scheduler";
-export { makeStore, type Store } from "./internal/store";
-export type { FamilyStore } from "./state/stateFamily";
-export {
-	type Kind,
-	type Manifest,
-	yieldableClass,
-} from "./definition/definition";
-export { readTracked } from "./internal/track";
-export { sameKey, wireSources, type WiredSources } from "./internal/sources";
+export { type Priority, publish } from './runtime/bus'
+export {
+  type AppRuntime,
+  type FeatureMountHandlers,
+  makeAppRuntime,
+  type RuntimeFeatureAvailability,
+  type RuntimeHandle,
+} from './runtime/appRuntime'
+export { Engine } from './runtime/loop'
+export type { EventBudget, ReformOptions } from './runtime/eventBudget'
+export {
+  AsyncReducer,
+  AsyncSceneLayer,
+  DuplicateRegistration,
+  EventLoopOverflow,
+  FeatureLoadFailed,
+  forceSync,
+  InvalidProvideTarget,
+  UnknownGroupState,
+} from './internal/errors'

package/src/internal/bucketCache.ts

@@ -0,0 +1,39 @@
+import { Option } from 'effect'
+
+/**
+ * A read-through snapshot cache over a tag-indexed `Map<string, Set<T>>`.
+ *
+ * The registries keep mutable `Set` buckets so register/unregister stay O(1),
+ * but the dispatch loop must iterate a *snapshot*: an entry registered while a
+ * frame is folding must not join the fold already in flight (`Set` iteration is
+ * live, an array copy is not). Copying per event would pay that snapshot on
+ * every dispatch, so the copy is cached and dropped only when the bucket
+ * actually changes — registration is rare, dispatch is not.
+ *
+ * A tag with no bucket returns a shared empty array and is never cached, so
+ * events nothing handles allocate nothing and cannot grow the cache.
+ */
+export interface BucketCache<T> {
+  readonly read: (tag: string) => ReadonlyArray<T>
+  readonly invalidate: (tag: string) => void
+}
+
+export const makeBucketCache = <T>(source: Map<string, Set<T>>): BucketCache<T> => {
+  const empty: ReadonlyArray<T> = []
+  const cache = new Map<string, ReadonlyArray<T>>()
+  const build = (tag: string): ReadonlyArray<T> =>
+    Option.match(Option.fromNullable(source.get(tag)), {
+      onNone: (): ReadonlyArray<T> => empty,
+      onSome: (bucket) => {
+        const current: ReadonlyArray<T> = Array.from(bucket)
+        cache.set(tag, current)
+        return current
+      },
+    })
+  return {
+    read: (tag) => Option.getOrElse(Option.fromNullable(cache.get(tag)), () => build(tag)),
+    invalidate: (tag) => {
+      cache.delete(tag)
+    },
+  }
+}

package/src/internal/capture.ts

@@ -1,7 +1,7 @@
 import { Context } from 'effect'
 import type { Trigger } from '../ui/trigger'
 
-export interface UiCapture {
+export interface CapturedRender {
   readonly name: string
   readonly props: unknown
   readonly events: Record<string, Trigger<unknown>>
@@ -9,11 +9,16 @@ export interface UiCapture {
   readonly key?: string
 }
 
+export type UiCapture = CapturedRender
+
 export interface CaptureSinkApi {
-  record(capture: UiCapture): void
+  record(capture: CapturedRender): void
 }
 
-const CaptureSinkBase: Context.TagClass<CaptureSink, 'reform/internal/CaptureSink', CaptureSinkApi> =
-  Context.Tag('reform/internal/CaptureSink')<CaptureSink, CaptureSinkApi>()
+const CaptureSinkBase: Context.TagClass<
+  CaptureSink,
+  'reform/internal/CaptureSink',
+  CaptureSinkApi
+> = Context.Tag('reform/internal/CaptureSink')<CaptureSink, CaptureSinkApi>()
 
 export class CaptureSink extends CaptureSinkBase {}

package/src/internal/env.ts

@@ -1,6 +1,4 @@
-declare const process:
-  | { readonly env: { readonly NODE_ENV: string | undefined } }
-  | undefined
+declare const process: { readonly env: { readonly NODE_ENV: string | undefined } } | undefined
 
 export const isDev: boolean =
   typeof process === 'undefined' ||