@playfast/reform 1.1.1 → 1.2.0

package/src/internal/queryDriver.ts

@@ -4,20 +4,20 @@ import {
   Effect,
   MutableRef,
   Option,
+  type ParseResult,
   Queue,
+  Runtime,
   type Scope,
   Stream,
 } from 'effect'
+import { type AnyAsyncData } from '../calc/asyncData'
 import { empty, type QueryState } from '../calc/queryState'
 import { Queries, type QueryHandle } from '../runtime/queries'
 import { reuse } from './reuse'
 import { resolveInstrumentation } from '../runtime/instrumentation'
 import { resolveQueryStore } from './queryStore'
-import type { QueryDriver, QueryDriverOptions } from './queryDriverTypes'
 import {
-  hydrateQuery,
   incrementGeneration,
-  makePersistWriter,
   makeQueryProjection,
   subscribeQuerySources,
   settleQueryError,
@@ -27,23 +27,58 @@ import { resolveScheduler } from './scheduler'
 import {
   type InputsObject,
   type InputStores,
+  type InvalidateBy,
   sameKey,
   wireSources,
 } from './sources'
-import { makeStore } from './store'
+import { makeStore, type Store } from './store'
 import { type AnySource } from '../state/token'
 
 export {
   bumpRevision,
   gatedFlag,
   type GatedOf,
-  type QueryDriver,
-  type QueryDriverOptions,
   Revision,
   RevisionSchema,
   revisionZero,
 } from './queryDriverTypes'
 
+// Keep schema invariance behind a covariant persistence boundary.
+export interface QueryCodec<A> {
+  readonly encode: (value: A) => Effect.Effect<unknown, ParseResult.ParseError, never>
+  readonly decode: (input: unknown) => Effect.Effect<A, ParseResult.ParseError, never>
+}
+
+export interface QueryDriverOptions<Inputs extends ReadonlyArray<AnySource>, A, E, R> {
+  readonly name: string
+  readonly label: string
+  readonly gated: boolean
+  readonly inputs: Inputs
+  readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
+  readonly invalidateBy?: InvalidateBy<Inputs> | undefined
+  readonly disabled?: ((inputs: InputsObject<Inputs>) => boolean) | undefined
+  readonly coalesce?: 'switch' | 'trailing' | undefined
+  readonly reuse?: boolean | undefined
+  readonly extraKey?:
+    | {
+        readonly read: () => unknown
+        readonly subscribe: (listener: () => void) => () => void
+      }
+    | undefined
+  readonly persist?:
+    | {
+        readonly key: string | ((inputs: InputsObject<Inputs>) => string)
+        readonly codec: QueryCodec<A>
+      }
+    | undefined
+  readonly onSettled?: ((generation: number) => void) | undefined
+}
+
+export interface QueryDriver<A, E> {
+  readonly store: Store<AnyAsyncData<A, E>>
+  readonly requested: () => number
+}
+
 // oxlint-disable-next-line reform-rules/prefer-effect-fn -- generic export: Effect.fn's inferred type isn't portable under isolatedDeclarations
 export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R>(
   options: QueryDriverOptions<Inputs, A, E, R>,
@@ -58,6 +93,10 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
 
     const keyOf = (args: InputsObject<Inputs>): ReadonlyArray<unknown> =>
       extraKey === undefined ? sources.keyOf(args) : [...sources.keyOf(args), extraKey.read()]
+    const persistKey = (
+      key: string | ((inputs: InputsObject<Inputs>) => string),
+      args: InputsObject<Inputs>,
+    ): string => (typeof key === 'function' ? key(args) : key)
     const disabledNow = (args: InputsObject<Inputs> = sources.snapshot()): boolean =>
       options.gated && options.disabled !== undefined ? options.disabled(args) : false
 
@@ -67,8 +106,17 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
     const readers = MutableRef.make(0)
 
     const lastKey = MutableRef.make<ReadonlyArray<unknown> | undefined>(undefined)
+    // Monotonic source epoch for the one startup hydration attempt. Comparing
+    // only the current key is insufficient: A → B → A would otherwise let the
+    // original A cache land over the later A request. Same-key refetches do not
+    // move this epoch, so cache may still paint during an in-flight revalidation.
+    const sourceEpoch = MutableRef.make(0)
     const generation = MutableRef.make(0)
     const nextGeneration = (): number => incrementGeneration(generation)
+    // A stale cause needs a strictly newer requested generation. Hydration
+    // captures this before the startup kick, while invalidation captures it when
+    // the value is marked stale.
+    const staleAtGeneration = MutableRef.make(0)
     const markFetching = () => {
       const state = stateStore.get()
       if (!state.isFetching) {
@@ -89,7 +137,24 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
       })
       return shared
     }
-    const persistWrite = makePersistWriter<Inputs, A>({ persist, queryStore })
+    const settleError = (error: E, failedGeneration: number) => {
+      // Preserve the stale cause after failure without duplicating a newer request.
+      MutableRef.update(staleAtGeneration, (current) => Math.max(current, failedGeneration))
+      settleQueryError(stateStore, error)
+    }
+
+    const persistWriteTo = (
+      target: NonNullable<typeof persist>,
+      produced: A,
+      args: InputsObject<Inputs>,
+    ): Effect.Effect<void> =>
+      target.codec.encode(produced).pipe(
+        Effect.flatMap((encoded) => queryStore.set(persistKey(target.key, args), encoded)),
+        // Persistence is best-effort and must not block the visible write.
+        Effect.ignore,
+      )
+    const persistWrite = (produced: A, args: InputsObject<Inputs>): Effect.Effect<void> =>
+      persist === undefined ? Effect.void : persistWriteTo(persist, produced, args)
 
     const derived = makeQueryProjection({ gated: options.gated, scheduler, stateStore })
     yield* Effect.addFinalizer(() => Effect.sync(derived.unsubscribe))
@@ -123,7 +188,7 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
           onFailure: (cause): Option.Option<A> => {
             const failure = Cause.failureOption(cause)
             if (Option.isSome(failure) && !disabledNow()) {
-              settleQueryError(stateStore, failure.value)
+              settleError(failure.value, request.generation)
             }
             return Option.none()
           },
@@ -161,6 +226,9 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
     const enqueue = (force: boolean) => {
       const args = sources.snapshot()
       if (disabledNow(args)) {
+        if (MutableRef.get(lastKey) !== undefined) {
+          MutableRef.update(sourceEpoch, (current) => current + 1)
+        }
         MutableRef.set(lastKey, undefined)
         stateStore.set(idle)
         return
@@ -170,6 +238,9 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
       if (!force && previous !== undefined && sameKey(key, previous)) {
         return
       }
+      if (previous !== undefined && !sameKey(key, previous)) {
+        MutableRef.update(sourceEpoch, (current) => current + 1)
+      }
       MutableRef.set(lastKey, key)
       markFetching()
       Queue.unsafeOffer(requests, { args, generation: nextGeneration() })
@@ -178,7 +249,8 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
     const refetch = () => enqueue(true)
 
     const maybeAutoRefetch = () => {
-      if (stateStore.get().isStale && MutableRef.get(readers) > 0) {
+      const hasCoveringRequest = MutableRef.get(generation) > MutableRef.get(staleAtGeneration)
+      if (stateStore.get().isStale && MutableRef.get(readers) > 0 && !hasCoveringRequest) {
         refetch()
       }
     }
@@ -187,6 +259,7 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
       if (state.isStale) {
         return
       }
+      MutableRef.set(staleAtGeneration, MutableRef.get(generation))
       stateStore.set({ ...state, isStale: true })
       maybeAutoRefetch()
     }
@@ -194,14 +267,46 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
     const unsubscribe = subscribeQuerySources(sources, extraKey, trigger)
     yield* Effect.addFinalizer(() => Effect.sync(unsubscribe))
 
+    // Fork hydration so an asynchronous store never blocks layer acquisition.
+    // Epoch, key, and settled-state guards prevent a late cache from replacing newer truth.
     if (persist !== undefined && !disabledNow()) {
       const hydrateArgs = sources.snapshot()
-      yield* hydrateQuery({
-        cacheKey: typeof persist.key === 'function' ? persist.key(hydrateArgs) : persist.key,
-        queryStore,
-        schema: persist.schema,
-        stateStore,
-      })
+      const hydrateSourceKey = keyOf(hydrateArgs)
+      const hydrateSourceEpoch = MutableRef.get(sourceEpoch)
+      const hydrateStaleAtGeneration = MutableRef.get(generation)
+      const hydrate = queryStore.get(persistKey(persist.key, hydrateArgs)).pipe(
+        Effect.flatMap((cached) =>
+          Option.match(cached, {
+            onNone: () => Effect.void,
+            onSome: (raw) =>
+              persist.codec.decode(raw).pipe(
+                Effect.tap((decoded) =>
+                  Effect.sync(() => {
+                    const state = stateStore.get()
+                    if (
+                      disabledNow() ||
+                      hydrateSourceEpoch !== MutableRef.get(sourceEpoch) ||
+                      !sameKey(hydrateSourceKey, keyOf(sources.snapshot())) ||
+                      Option.isSome(state.data) ||
+                      Option.isSome(state.error)
+                    ) {
+                      return
+                    }
+                    MutableRef.update(staleAtGeneration, (current) =>
+                      Math.max(current, hydrateStaleAtGeneration),
+                    )
+                    stateStore.set({ ...state, data: Option.some(decoded), isStale: true })
+                  }),
+                ),
+              ),
+          }),
+        ),
+        // Corrupt/incompatible cache: ignore and fetch fresh.
+        Effect.ignore,
+      )
+      const runtime = yield* Effect.runtime<never>()
+      const scope = yield* Effect.scope
+      Runtime.runFork(runtime)(hydrate, { immediate: true, scope })
     }
 
     const initial = sources.snapshot()

package/src/internal/queryDriverStore.ts

@@ -15,9 +15,7 @@ interface HydrateQueryOptions<A, E> {
   readonly stateStore: Store<QueryState<A, E>>
 }
 
-export const hydrateQuery = <A, E>(
-  options: HydrateQueryOptions<A, E>,
-): Effect.Effect<void> =>
+export const hydrateQuery = <A, E>(options: HydrateQueryOptions<A, E>): Effect.Effect<void> =>
   Effect.flatMap(options.queryStore.get(options.cacheKey), (cached) =>
     Option.match(cached, {
       onNone: () => Effect.void,
@@ -52,7 +50,10 @@ export const persistQueryValue = <A>(options: PersistQueryValueOptions<A>): Effe
 
 interface PersistWriterOptions<Inputs extends ReadonlyArray<AnySource>, A> {
   readonly persist:
-    | { readonly key: string | ((inputs: InputsObject<Inputs>) => string); readonly schema: AnySchema<A> }
+    | {
+        readonly key: string | ((inputs: InputsObject<Inputs>) => string)
+        readonly schema: AnySchema<A>
+      }
     | undefined
   readonly queryStore: QueryStoreApi
 }
@@ -136,7 +137,9 @@ interface ReaderStoreOptions<A, E> {
   readonly onFirstReader: () => void
 }
 
-export const withReaderTracking = <A, E>(options: ReaderStoreOptions<A, E>): Store<AnyAsyncData<A, E>> => ({
+export const withReaderTracking = <A, E>(
+  options: ReaderStoreOptions<A, E>,
+): Store<AnyAsyncData<A, E>> => ({
   ...options.store,
   subscribe: (listener) => {
     const before = MutableRef.get(options.readers)

package/src/internal/queryDriverTypes.ts

@@ -7,7 +7,9 @@ import type { AnySchema } from './variance'
 
 export type GatedOf<AlwaysOn extends boolean> = AlwaysOn extends true ? false : true
 
-export const gatedFlag = <AlwaysOn extends boolean>(alwaysOn: AlwaysOn | undefined): GatedOf<AlwaysOn> =>
+export const gatedFlag = <AlwaysOn extends boolean>(
+  alwaysOn: AlwaysOn | undefined,
+): GatedOf<AlwaysOn> =>
   // oxlint-disable-next-line reform-rules/no-type-assertion -- restate the runtime boolean as its conditional `GatedOf` literal; no guard maps a boolean to a conditional type
   (alwaysOn !== true) as GatedOf<AlwaysOn>
 

package/src/internal/reuse.test.ts

@@ -13,7 +13,10 @@ describe('reuse', () => {
     const e0 = { id: 1, name: 'a' }
     const e1 = { id: 2, name: 'b' }
     const prev = [e0, e1]
-    const next = [{ id: 1, name: 'a' }, { id: 2, name: 'B' }]
+    const next = [
+      { id: 1, name: 'a' },
+      { id: 2, name: 'B' },
+    ]
     const out = reuse(prev, next)
     expect(out).not.toBe(prev)
     expect(out[0]).toBe(e0)
@@ -49,7 +52,10 @@ describe('reuse', () => {
     class View extends S.Class<View>('View')({ title: S.String, rows: S.Array(Row) }) {}
     const keep = new Row({ id: 1, name: 'a' })
     const prev = new View({ title: 't', rows: [keep, new Row({ id: 2, name: 'b' })] })
-    const next = new View({ title: 't', rows: [new Row({ id: 1, name: 'a' }), new Row({ id: 2, name: 'B' })] })
+    const next = new View({
+      title: 't',
+      rows: [new Row({ id: 1, name: 'a' }), new Row({ id: 2, name: 'B' })],
+    })
     const out = reuse(prev, next)
     expect(out).not.toBe(prev)
     expect(out).toBeInstanceOf(View)
@@ -77,7 +83,8 @@ describe('reuse', () => {
 
   it('returns next below the depth bound', () => {
     type Nest = { readonly n?: Nest; readonly v: number }
-    const deep = (depth: number): Nest => (depth === 0 ? { v: 0 } : { v: depth, n: deep(depth - 1) })
+    const deep = (depth: number): Nest =>
+      depth === 0 ? { v: 0 } : { v: depth, n: deep(depth - 1) }
     const prev = deep(20)
     const next = deep(20)
     const out = reuse(prev, next)

package/src/internal/reuse.ts

@@ -54,10 +54,13 @@ const reconcile = ({ prev, next, depth }: ReconcileArgs): unknown => {
   }
   if (Array.isArray(prev) && Array.isArray(next)) {
     const reconciled = next.map((element, index) =>
-      index < prev.length ? reconcile({ prev: prev[index], next: element, depth: depth - 1 }) : element,
+      index < prev.length
+        ? reconcile({ prev: prev[index], next: element, depth: depth - 1 })
+        : element,
     )
     const unchanged =
-      prev.length === next.length && reconciled.every((entry, index) => Object.is(entry, prev[index]))
+      prev.length === next.length &&
+      reconciled.every((entry, index) => Object.is(entry, prev[index]))
     return unchanged ? prev : reconciled
   }
   if (isPlainRecord(prev) && isPlainRecord(next)) {

package/src/internal/scheduler.ts

@@ -54,7 +54,10 @@ const NotificationsBase: Context.TagClass<Notifications, 'reform/Notifications',
   Context.Tag('reform/Notifications')<Notifications, Scheduler>()
 export class Notifications extends NotificationsBase {}
 
-export const notificationsLayer: Layer.Layer<Notifications> = Layer.sync(Notifications, makeScheduler)
+export const notificationsLayer: Layer.Layer<Notifications> = Layer.sync(
+  Notifications,
+  makeScheduler,
+)
 
 export const resolveScheduler: Effect.Effect<Scheduler> = Effect.map(
   Effect.serviceOption(Notifications),

package/src/internal/sources.ts

@@ -1,15 +1,20 @@
-import { type Context, Effect, Equal, Predicate } from 'effect'
-import { type AnySource, type SourceName, type SourceValue } from '../state/token'
-import { type Store } from './store'
-import type { AnyValue } from './variance'
+import { Context, Effect, Equal, Predicate } from 'effect'
+import {
+  type AnySource,
+  type SourceIdentifier,
+  type SourceName,
+  type SourceValue,
+} from '../state/token'
 
 export type InputsObject<Inputs extends ReadonlyArray<AnySource>> = {
   readonly [S in Inputs[number] as SourceName<S>]: SourceValue<S>
 }
 
 export type StoresOf<Items extends ReadonlyArray<unknown>> = {
-  [I in keyof Items]: Items[I] extends { readonly store: Context.Tag<infer Svc, AnyValue> }
-    ? Svc
+  [I in keyof Items]: Items[I] extends {
+    readonly store: Context.Tag<infer Service, infer _Store>
+  }
+    ? Service
     : never
 }[number]
 
@@ -26,8 +31,20 @@ const inputKey = (input: AnySource): string =>
     ? input.manifest['name']
     : input.name
 
+// Capture an invariant source tag through a covariant read-only surface.
+interface ReadableStore<out A> {
+  readonly getSnapshot: () => A
+  readonly subscribe: (listener: () => void) => () => void
+}
+
+const readStore = <Source extends AnySource>(
+  source: Source,
+): Effect.Effect<ReadableStore<SourceValue<Source>>, never, SourceIdentifier<Source>> =>
+  Context.GenericTag<SourceIdentifier<Source>, ReadableStore<SourceValue<Source>>>(source.store.key)
+
 export const sameKey = (left: ReadonlyArray<unknown>, right: ReadonlyArray<unknown>): boolean =>
-  left.length === right.length && left.every((element, index) => Equal.equals(element, right[index]))
+  left.length === right.length &&
+  left.every((element, index) => Equal.equals(element, right[index]))
 
 export interface WiredSources<Inputs extends ReadonlyArray<AnySource>> {
   readonly snapshot: () => InputsObject<Inputs>
@@ -41,10 +58,7 @@ export const wireSources = <Inputs extends ReadonlyArray<AnySource>>(
 ): Effect.Effect<WiredSources<Inputs>, never, InputStores<Inputs>> =>
   // oxlint-disable-next-line reform-rules/no-type-assertion -- restate the precise InputStores<Inputs> union the signature promises; Effect.forEach over a heterogeneous tuple widens R (the single seam this cast lives at)
   Effect.gen(function* () {
-    const sources: ReadonlyArray<Store<unknown>> = yield* Effect.forEach(
-      inputs,
-      (input) => input.store,
-    )
+    const sources = yield* Effect.forEach(inputs, readStore)
 
     const snapshot = (): InputsObject<Inputs> => {
       const args: Record<string, unknown> = {}

package/src/internal/track.ts

@@ -10,8 +10,9 @@ export interface Tracker {
   add(source: Subscribable): void
 }
 
-const CurrentTrackerBase: Context.TagClass<CurrentTracker, 'reform/Tracker', Tracker> =
-  Context.Tag('reform/Tracker')<CurrentTracker, Tracker>()
+const CurrentTrackerBase: Context.TagClass<CurrentTracker, 'reform/Tracker', Tracker> = Context.Tag(
+  'reform/Tracker',
+)<CurrentTracker, Tracker>()
 export class CurrentTracker extends CurrentTrackerBase {}
 
 export const readTracked = <A>(store: Store<A>): Effect.Effect<A> =>

package/src/internal.ts

@@ -0,0 +1,222 @@
+// Quarantined surface for first-party hosts and companion packages
+// (`@playfast/reform-*`): reflection/manifest types, TypeIds, erased `Any*`
+// forms, capture callbacks, and runtime seams. Importable as
+// `@playfast/reform/internal`; not part of the app-facing API and not covered
+// by its stability expectations.
+
+export {
+  type AnyState,
+  type StateCapture,
+  type StateDefinition,
+  type StateManifest,
+  type StateName,
+  type StateSchemaReflection,
+  StateStoreTypeId,
+} from './state/state'
+export {
+  type AnyFamily,
+  type FamilyName,
+  type FamilySchemaReflection,
+  type FamilyStore,
+  type StateFamilyCapture,
+  type StateFamilyManifest,
+  StateFamilyStoreTypeId,
+} from './state/stateFamily'
+export { StateToken } from './state/token'
+export type {
+  AnySource,
+  Source,
+  SourceCapture,
+  SourceIdentifier,
+  SourceName,
+  SourceValue,
+} from './state/token'
+export type {
+  AnyEvent,
+  EventCapture,
+  EventManifest,
+  EventName,
+  EventReflection,
+  EventSchemaReflection,
+  EventType,
+} from './event/event'
+export { CalcStoreTypeId } from './calc/calc'
+export { CalcFamilyStoreTypeId } from './calc/calcFamily'
+export { AsyncCalcStoreTypeId } from './calc/asyncCalc'
+export { sameKey, type WiredSources, wireSources } from './internal/sources'
+// Optional host seams an `AsyncCalc` consults — persistence and lifecycle signals.
+// Concrete implementations live in edge packages (e.g. `@playfast/reform-query-browser`).
+export {
+  noopQueryStore,
+  QueryStore,
+  type QueryStoreApi,
+  resolveQueryStore,
+} from './internal/queryStore'
+export {
+  noopQueryEvents,
+  QueryEvents,
+  type QueryEventsApi,
+  resolveQueryEvents,
+} from './internal/queryEvents'
+export {
+  RemoteStatePendingStoreTypeId,
+  RemoteStateTruthStoreTypeId,
+  RemoteStateVisibleStoreTypeId,
+} from './remote/remoteState'
+export { SyncedStoreIdentifierTypeId } from './synced/syncedStore'
+export { BoundaryStoreTypeId } from './boundary/boundary'
+export type {
+  AnyProcedure,
+  ProcedureCapture,
+  ProcedureManifest,
+  ProcedureReflection,
+} from './procedure/procedure'
+export {
+  type ChannelRuntime,
+  Channels,
+  channelsLayer,
+  type ProcedureEntry,
+  Procedures,
+  proceduresLayer,
+} from './channel/channel'
+export { CompositionIdTypeId } from './compose/composition'
+export type {
+  AnyComposition,
+  CompositionCapture,
+  CompositionManifest,
+  CompositionPropsReceiver,
+  CompositionReflection,
+  CompositionTag,
+  HasExactCompositionId,
+  RequiredSlotIdentities,
+  SlotClassesOf,
+} from './compose/composition'
+export { StructureTypeId } from './compose/structure'
+export { type PropsId, PropsIdTypeId, type PropsTag, propsTag } from './compose/props'
+export {
+  type AnySlot,
+  type AnySlotChild,
+  type AnySlotInstance,
+  type SlotCapture,
+  type SlotChild,
+  type SlotManifest,
+  SlotServiceTypeId,
+  SlotTypeId,
+} from './compose/slot'
+export type { SlotRenderer } from './compose/host'
+export {
+  type AnyMadeView,
+  type AnyUi,
+  type MadeViewCapture,
+  type UiCapture,
+  type UiManifest,
+  type UiName,
+  type UiReflection,
+  type UiSchemaReflection,
+  UiServiceTypeId,
+  UiTypeId,
+  type WiredUi,
+  type WiredUiManifest,
+  type WireSchemas,
+} from './compose/ui'
+
+// Wire: the serializable rendered-tree model + pure diff/apply the remote
+// transport sends over the wire and the client folds back. See REMOTE_UI.md §3.
+export * as Wire from './wire/tree'
+export type { WireNode, WirePatch, WireProp, WireTree } from './wire/tree'
+// Triggers: the server-side handle registry bridging client trigger invocations
+// back to live triggers, decoding payloads via the event schema. See REMOTE_UI.md §4.
+export * as Triggers from './wire/triggers'
+export {
+  type TriggerHandle,
+  TriggerRegistry,
+  type TriggerRegistryApi,
+  UnknownTrigger,
+} from './wire/triggers'
+
+export {
+  type AnyFeatureBinding,
+  type AnyLoadedModule,
+  type CapturedFeatureBinding,
+  type FeatureBinding,
+  type FeatureBindingCapture,
+  FeatureBindingTypeId,
+  type FeatureDefinition,
+  FeatureGraphValidTypeId,
+  type FeatureIdentityToken,
+  FeatureInput,
+  type FeatureManifest,
+  featureModuleFromInput,
+  type FeatureMountProps,
+  type FeatureOpenServices,
+  type FeatureRequirement,
+  type FeatureSupportOpenServices,
+  type FeatureToken,
+  type FeatureTreeCarrier,
+  type LoadedModule,
+  type LoadedModuleCapture,
+  mountFeature,
+  type ProvideableFeature,
+  type ProvidedBy,
+  type RequireCarrier,
+} from './feature/feature'
+export {
+  type CompositionChildSummary,
+  CompositionChildSummaryTypeId,
+  type DescendantOpenServices,
+  type FeatureChildSummary,
+  FeatureChildSummaryTypeId,
+  type ModuleOpenServices,
+  type OpenServicesFromFeatureSlotWitnesses,
+  type SlotBindingSummary,
+  SlotBindingSummaryTypeId,
+  type ValidateFeatureGraphLayer,
+} from './graph/closure'
+export { type AnyScene, type AnySceneCapture, type SceneCapture, seedAnyScene } from './scene/scene'
+export { Bus, busLayer, type Envelope, type Tagged } from './runtime/bus'
+export {
+  type AnyFeatureMountHandlers,
+  type CapturedFeatureMountHandlers,
+  type FeatureMountHandlersExternalApi,
+  type UnspecifiedRuntimeServices,
+  UnspecifiedRuntimeServicesTypeId,
+} from './runtime/appRuntime'
+export {
+  EngineRequirements,
+  type EngineServices,
+  type ReducerEntry,
+  Reducers,
+  reducersLayer,
+} from './runtime/loop'
+export { CurrentEventBudget, defaultEventBudget, resolveEventBudget } from './runtime/eventBudget'
+// The profiler SPI: synchronous hooks the engine calls on its hot paths, plus
+// the FiberRef seam `@playfast/reform-profiler` writes through (`profiledScene`).
+export {
+  CurrentInstrumentation,
+  type Instrumentation,
+  noopInstrumentation,
+  resolveInstrumentation,
+  type SpanEnd,
+} from './runtime/instrumentation'
+// The runtime-wide registry of live query handles. `AsyncCalc.invalidate` /
+// `AsyncCalc.refetch` and provider layers act on a query by name through it.
+export { Queries, queriesLayer, type QueryHandle, type QueryRegistry } from './runtime/queries'
+export { CurrentTracker, readTracked, type Subscribable, type Tracker } from './internal/track'
+export { type CapturedRender, CaptureSink, type CaptureSinkApi } from './internal/capture'
+// Notification scheduler: hosts that need per-runtime isolation (concurrent SSR,
+// multiple mounted roots) provide `Notifications` upstream of their state layers;
+// everything else coalesces on the process-wide default.
+export {
+  defaultScheduler,
+  makeScheduler,
+  Notifications,
+  notificationsLayer,
+  resolveScheduler,
+  type Scheduler,
+} from './internal/scheduler'
+export { makeStore, type Store } from './internal/store'
+// Primitive-authoring toolkit — for first-party companion packages
+// (e.g. `@playfast/reform-db`, `@playfast/reform-resource`) that build their own
+// first-class `Source`s which must participate in dependency tracking and
+// reflection exactly like a `Calc`.
+export { type Kind, type Manifest, yieldableClass } from './definition/definition'