@playfast/reform 1.1.1 → 1.2.0

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' ||

package/src/internal/errors.ts

@@ -4,7 +4,9 @@ type TaggedErrorClass<Tag extends string, A extends Record<string, unknown>> = n
   args: A,
 ) => Cause.YieldableError & { readonly _tag: Tag } & Readonly<A>
 
-type EmptyTaggedErrorClass<Tag extends string> = new () => Cause.YieldableError & { readonly _tag: Tag }
+type EmptyTaggedErrorClass<Tag extends string> = new () => Cause.YieldableError & {
+  readonly _tag: Tag
+}
 
 const InvalidProvideTargetBase: EmptyTaggedErrorClass<'reform/InvalidProvideTarget'> =
   Data.TaggedError('reform/InvalidProvideTarget')<{}>
@@ -15,8 +17,10 @@ export class InvalidProvideTarget extends InvalidProvideTargetBase {
   }
 }
 
-const UnknownGroupStateBase: TaggedErrorClass<'reform/UnknownGroupState', { readonly name: string }> =
-  Data.TaggedError('reform/UnknownGroupState')<{ readonly name: string }>
+const UnknownGroupStateBase: TaggedErrorClass<
+  'reform/UnknownGroupState',
+  { readonly name: string }
+> = Data.TaggedError('reform/UnknownGroupState')<{ readonly name: string }>
 
 export class UnknownGroupState extends UnknownGroupStateBase {
   override get message(): string {
@@ -24,8 +28,10 @@ export class UnknownGroupState extends UnknownGroupStateBase {
   }
 }
 
-const FeatureLoadFailedBase: TaggedErrorClass<'reform/FeatureLoadFailed', { readonly cause: unknown }> =
-  Data.TaggedError('reform/FeatureLoadFailed')<{ readonly cause: unknown }>
+const FeatureLoadFailedBase: TaggedErrorClass<
+  'reform/FeatureLoadFailed',
+  { readonly cause: unknown }
+> = Data.TaggedError('reform/FeatureLoadFailed')<{ readonly cause: unknown }>
 
 export class FeatureLoadFailed extends FeatureLoadFailedBase {
   override get message(): string {
@@ -33,8 +39,9 @@ export class FeatureLoadFailed extends FeatureLoadFailedBase {
   }
 }
 
-const AsyncReducerBase: EmptyTaggedErrorClass<'reform/AsyncReducer'> =
-  Data.TaggedError('reform/AsyncReducer')<{}>
+const AsyncReducerBase: EmptyTaggedErrorClass<'reform/AsyncReducer'> = Data.TaggedError(
+  'reform/AsyncReducer',
+)<{}>
 
 export class AsyncReducer extends AsyncReducerBase {
   override get message(): string {
@@ -42,8 +49,9 @@ export class AsyncReducer extends AsyncReducerBase {
   }
 }
 
-const AsyncSceneLayerBase: EmptyTaggedErrorClass<'reform/AsyncSceneLayer'> =
-  Data.TaggedError('reform/AsyncSceneLayer')<{}>
+const AsyncSceneLayerBase: EmptyTaggedErrorClass<'reform/AsyncSceneLayer'> = Data.TaggedError(
+  'reform/AsyncSceneLayer',
+)<{}>
 
 export class AsyncSceneLayer extends AsyncSceneLayerBase {
   override get message(): string {
@@ -81,7 +89,10 @@ export const forceSync = <A>(thunk: () => A): A => {
 const DuplicateRegistrationBase: TaggedErrorClass<
   'reform/DuplicateRegistration',
   { readonly kind: string; readonly name: string }
-> = Data.TaggedError('reform/DuplicateRegistration')<{ readonly kind: string; readonly name: string }>
+> = Data.TaggedError('reform/DuplicateRegistration')<{
+  readonly kind: string
+  readonly name: string
+}>
 
 export class DuplicateRegistration extends DuplicateRegistrationBase {
   override get message(): string {