@directive-run/core 0.5.0 → 0.8.0

package/dist/{plugins-Co2_xohI.d.cts → plugins-DaglUQVX.d.cts}

@@ -680,8 +680,10 @@ interface CreateSystemOptionsNamed<Modules extends ModulesMap> {
     modules: Modules;
     /** Plugins to register */
     plugins?: Array<Plugin<ModuleSchema>>;
-    /** Debug configuration */
-    debug?: DebugConfig;
+    /** History configuration for snapshot-based state history */
+    history?: HistoryOption;
+    /** Trace: per-run reconciliation changelog */
+    trace?: TraceOption;
     /** Error boundary configuration */
     errorBoundary?: ErrorBoundaryConfig;
     /**
@@ -727,8 +729,8 @@ interface NamespacedSystem<Modules extends ModulesMap> {
     readonly _mode: "namespaced";
     /** Namespaced facts accessor: system.facts.auth.token */
     readonly facts: MutableNamespacedFacts<Modules>;
-    /** Time-travel debugging API (if enabled) */
-    readonly debug: TimeTravelAPI | null;
+    /** History API for undo/redo, rollback, audit trails (if enabled) */
+    readonly history: HistoryAPI | null;
     /** Namespaced derivations accessor: system.derive.auth.status */
     readonly derive: NamespacedDerivations<Modules> & DerivationsControl;
     /** Events accessor (union of all module events) */
@@ -739,8 +741,8 @@ interface NamespacedSystem<Modules extends ModulesMap> {
     readonly effects: EffectsControl;
     /** Runtime control for resolvers (dynamic CRUD) */
     readonly resolvers: ResolversControl;
-    /** Per-run changelog entries (null if debug.runHistory is not enabled) */
-    readonly runHistory: RunChangelogEntry[] | null;
+    /** Per-run trace entries (null if trace is not enabled) */
+    readonly trace: TraceEntry[] | null;
     /** Initialize facts and derivations without starting reconciliation. Safe for SSR. */
     initialize(): void;
     /** Start the system (initialize modules, begin reconciliation) */
@@ -788,8 +790,8 @@ interface NamespacedSystem<Modules extends ModulesMap> {
      * (resolver starts/completes, reconcile starts/ends).
      */
     onSettledChange(listener: () => void): () => void;
-    /** Subscribe to time-travel state changes (snapshot taken, navigation). */
-    onTimeTravelChange(listener: () => void): () => void;
+    /** Subscribe to history state changes (snapshot taken, navigation). */
+    onHistoryChange(listener: () => void): () => void;
     /**
      * Read a derivation value by namespaced key.
      * Accepts "namespace.key" format (e.g., "auth.status").
@@ -933,8 +935,10 @@ interface CreateSystemOptionsSingle<S extends ModuleSchema> {
     module: ModuleDef<S>;
     /** Plugins to register */
     plugins?: Array<Plugin<ModuleSchema>>;
-    /** Debug configuration */
-    debug?: DebugConfig;
+    /** History configuration for snapshot-based state history */
+    history?: HistoryOption;
+    /** Trace: per-run reconciliation changelog */
+    trace?: TraceOption;
     /** Error boundary configuration */
     errorBoundary?: ErrorBoundaryConfig;
     /** Tick interval for time-based systems (ms) */
@@ -956,20 +960,20 @@ interface SingleModuleSystem<S extends ModuleSchema> {
     readonly _mode: "single";
     /** Direct facts accessor: system.facts.count */
     readonly facts: Facts<S["facts"]>;
-    /** Time-travel debugging API (if enabled) */
-    readonly debug: TimeTravelAPI | null;
+    /** History API for undo/redo, rollback, audit trails (if enabled) */
+    readonly history: HistoryAPI | null;
     /** Direct derivations accessor: system.derive.doubled */
-    readonly derive: InferDerivations<S> & DerivationsControl;
+    readonly derive: InferDerivations<S> & DerivationsControl<S>;
     /** Direct events accessor: system.events.increment() */
     readonly events: SingleModuleEvents<S>;
     /** Runtime control for constraints (disable/enable/isDisabled) */
-    readonly constraints: ConstraintsControl;
+    readonly constraints: ConstraintsControl<S>;
     /** Runtime control for effects (disable/enable/isEnabled) */
-    readonly effects: EffectsControl;
+    readonly effects: EffectsControl<S>;
     /** Runtime control for resolvers (register/assign/unregister/call) */
-    readonly resolvers: ResolversControl;
-    /** Per-run changelog entries (null if debug.runHistory is not enabled) */
-    readonly runHistory: RunChangelogEntry[] | null;
+    readonly resolvers: ResolversControl<S>;
+    /** Per-run trace entries (null if trace is not enabled) */
+    readonly trace: TraceEntry[] | null;
     /** Initialize facts and derivations without starting reconciliation. Safe for SSR. */
     initialize(): void;
     /** Start the system (initialize modules, begin reconciliation) */
@@ -1002,8 +1006,8 @@ interface SingleModuleSystem<S extends ModuleSchema> {
      * (resolver starts/completes, reconcile starts/ends).
      */
     onSettledChange(listener: () => void): () => void;
-    /** Subscribe to time-travel state changes (snapshot taken, navigation). */
-    onTimeTravelChange(listener: () => void): () => void;
+    /** Subscribe to history state changes (snapshot taken, navigation). */
+    onHistoryChange(listener: () => void): () => void;
     /**
      * Read a derivation value by key.
      * @example system.read("doubled")
@@ -1360,11 +1364,17 @@ interface ModuleDef<M extends ModuleSchema = ModuleSchema> {
     resolvers?: TypedResolversDef<M>;
     hooks?: ModuleHooks<M>;
     /**
-     * Events that create time-travel snapshots.
-     * If omitted, ALL events create snapshots (default).
-     * If provided, only listed events create snapshots for undo/redo.
+     * History configuration for this module.
+     * Controls which events create snapshots for undo/redo.
      */
-    snapshotEvents?: Array<keyof GetEventsSchema<M> & string>;
+    history?: {
+        /**
+         * Events that create history snapshots.
+         * If omitted, ALL events create snapshots (default).
+         * If provided, only listed events create snapshots for undo/redo.
+         */
+        snapshotEvents?: Array<keyof GetEventsSchema<M> & string>;
+    };
     /**
      * Cross-module dependencies (runtime marker).
      * When present, constraints/effects receive `facts.self.*` + `facts.{dep}.*`.
@@ -1405,19 +1415,24 @@ type ObservableKeys<M extends ModuleSchema> = FactKeys<M> | DerivationKeys<M>;
  * Events accessor from module schema.
  */
 type EventsAccessor<M extends ModuleSchema> = EventsAccessorFromSchema<M>;
-/** Debug configuration */
-interface DebugConfig {
-    timeTravel?: boolean;
+/** History configuration for snapshot-based state history (undo/redo, rollback, audit trails) */
+interface HistoryConfig {
+    /** Maximum number of snapshots in the ring buffer (default 100) */
     maxSnapshots?: number;
     /** Only snapshot events from these modules. Omit to snapshot all modules. Multi-module only. */
     snapshotModules?: string[];
-    /** Enable per-run changelog (default false) */
-    runHistory?: boolean;
-    /** Ring buffer cap for run history (default 100) */
+}
+/** History option: boolean shorthand or full config (presence implies enabled) */
+type HistoryOption = boolean | HistoryConfig;
+/** Trace configuration for per-run reconciliation changelogs */
+interface TraceConfig {
+    /** Ring buffer cap for trace entries (default 100) */
     maxRuns?: number;
 }
-/** Time-travel API */
-interface TimeTravelAPI {
+/** Trace option: boolean shorthand or full config (presence implies enabled) */
+type TraceOption = boolean | TraceConfig;
+/** History API for snapshot navigation, changesets, and export/import */
+interface HistoryAPI {
     readonly snapshots: Snapshot[];
     readonly currentIndex: number;
     readonly isPaused: boolean;
@@ -1438,19 +1453,17 @@ interface SnapshotMeta {
     timestamp: number;
     trigger: string;
 }
-/** Reactive time-travel state for framework hooks */
-interface TimeTravelState {
-    canUndo: boolean;
-    canRedo: boolean;
-    undo: () => void;
-    redo: () => void;
+/** Reactive history state for framework hooks */
+interface HistoryState {
+    canGoBack: boolean;
+    canGoForward: boolean;
     currentIndex: number;
     totalSnapshots: number;
     snapshots: SnapshotMeta[];
     getSnapshotFacts: (id: number) => Record<string, unknown> | null;
     goTo: (snapshotId: number) => void;
-    goBack: (steps: number) => void;
-    goForward: (steps: number) => void;
+    goBack: (steps?: number) => void;
+    goForward: (steps?: number) => void;
     replay: () => void;
     exportSession: () => string;
     importSession: (json: string) => void;
@@ -1460,8 +1473,8 @@ interface TimeTravelState {
     pause: () => void;
     resume: () => void;
 }
-/** A structured record of one reconciliation run — from facts through resolvers and effects. */
-interface RunChangelogEntry {
+/** A structured record of one reconciliation run — fact changes, derivation recomputes, constraints hit, resolvers, effects. */
+interface TraceEntry {
     /** Monotonic run ID */
     id: number;
     /** When the reconcile started */
@@ -1555,10 +1568,10 @@ interface SystemInspection {
         id: string;
         requirement: string;
     }>;
-    /** Whether debug.runHistory is enabled on this system */
-    runHistoryEnabled: boolean;
-    /** Per-run changelog entries (only present if debug.runHistory is enabled) */
-    runHistory?: RunChangelogEntry[];
+    /** Whether trace is enabled on this system */
+    traceEnabled: boolean;
+    /** Per-run trace entries (only present if trace is enabled) */
+    trace?: TraceEntry[];
 }
 /** Explanation of why a requirement exists */
 interface RequirementExplanation {
@@ -1632,7 +1645,7 @@ interface DistributableSnapshot<T = Record<string, unknown>> {
  * Provides full type inference for facts, derivations, events, and dispatch.
  */
 /** Runtime control for constraints */
-interface ConstraintsControl {
+interface ConstraintsControl<M extends ModuleSchema = ModuleSchema> {
     /** Disable a constraint by ID — it will be excluded from evaluation */
     disable(id: string): void;
     /** Enable a previously disabled constraint — it will be re-evaluated on the next cycle */
@@ -1644,14 +1657,14 @@ interface ConstraintsControl {
      * @throws If a constraint with this ID already exists (use `assign` to override)
      * @remarks During reconciliation, the registration is deferred and applied after the current cycle completes.
      */
-    register(id: string, def: Record<string, unknown>): void;
+    register(id: string, def: DynamicConstraintDef<M>): void;
     /**
      * Override an existing constraint (static or dynamic).
      * Stores the original definition for potential inspection.
      * @throws If no constraint with this ID exists (use `register` to create)
      * @remarks During reconciliation, the assignment is deferred and applied after the current cycle completes.
      */
-    assign(id: string, def: Record<string, unknown>): void;
+    assign(id: string, def: DynamicConstraintDef<M>): void;
     /**
      * Remove a dynamically registered constraint.
      * Static (module-defined) constraints cannot be unregistered — logs a dev warning and no-ops.
@@ -1671,7 +1684,7 @@ interface ConstraintsControl {
     listDynamic(): string[];
 }
 /** Runtime control for effects */
-interface EffectsControl {
+interface EffectsControl<M extends ModuleSchema = ModuleSchema> {
     /** Disable an effect by ID — it will be skipped during reconciliation */
     disable(id: string): void;
     /** Enable a previously disabled effect */
@@ -1683,14 +1696,14 @@ interface EffectsControl {
      * @throws If an effect with this ID already exists (use `assign` to override)
      * @remarks During reconciliation, the registration is deferred and applied after the current cycle completes.
      */
-    register(id: string, def: Record<string, unknown>): void;
+    register(id: string, def: DynamicEffectDef<M>): void;
     /**
      * Override an existing effect (static or dynamic).
      * Runs cleanup of the old effect before replacing.
      * @throws If no effect with this ID exists (use `register` to create)
      * @remarks During reconciliation, the assignment is deferred and applied after the current cycle completes.
      */
-    assign(id: string, def: Record<string, unknown>): void;
+    assign(id: string, def: DynamicEffectDef<M>): void;
     /**
      * Remove a dynamically registered effect.
      * Static (module-defined) effects cannot be unregistered — logs a dev warning and no-ops.
@@ -1708,19 +1721,19 @@ interface EffectsControl {
     listDynamic(): string[];
 }
 /** Runtime control for derivations (dynamic registration + value access) */
-interface DerivationsControl {
+interface DerivationsControl<M extends ModuleSchema = ModuleSchema> {
     /**
      * Register a new derivation at runtime.
      * @throws If a derivation with this ID already exists (use `assign` to override)
      * @remarks During reconciliation, the registration is deferred and applied after the current cycle completes.
      */
-    register(id: string, fn: (facts: Record<string, unknown>, derive: Record<string, unknown>) => unknown): void;
+    register(id: string, fn: (facts: Readonly<InferSchema<M["facts"]>>, derived: Readonly<InferDerivations<M>>) => unknown): void;
     /**
      * Override an existing derivation (static or dynamic).
      * @throws If no derivation with this ID exists (use `register` to create)
      * @remarks During reconciliation, the assignment is deferred and applied after the current cycle completes.
      */
-    assign(id: string, fn: (facts: Record<string, unknown>, derive: Record<string, unknown>) => unknown): void;
+    assign(id: string, fn: (facts: Readonly<InferSchema<M["facts"]>>, derived: Readonly<InferDerivations<M>>) => unknown): void;
     /**
      * Remove a dynamically registered derivation.
      * Static (module-defined) derivations cannot be unregistered — logs a dev warning and no-ops.
@@ -1729,29 +1742,30 @@ interface DerivationsControl {
     unregister(id: string): void;
     /**
      * Recompute and return a derivation's current value.
+     * Use the type parameter to specify the return type: `call<number>("id")`.
      * @throws If no derivation with this ID exists
      */
-    call(id: string): unknown;
+    call<T = unknown>(id: string): T;
     /** Check if a derivation was dynamically registered (not from a module definition) */
     isDynamic(id: string): boolean;
     /** List all dynamically registered derivation IDs */
     listDynamic(): string[];
 }
 /** Runtime control for resolvers */
-interface ResolversControl {
+interface ResolversControl<M extends ModuleSchema = ModuleSchema> {
     /**
      * Register a new resolver at runtime.
      * @throws If a resolver with this ID already exists (use `assign` to override)
      * @remarks During reconciliation, the registration is deferred and applied after the current cycle completes.
      */
-    register(id: string, def: Record<string, unknown>): void;
+    register(id: string, def: DynamicResolverDef<M>): void;
     /**
      * Override an existing resolver (static or dynamic).
      * Clears the resolver-by-type cache.
      * @throws If no resolver with this ID exists (use `register` to create)
      * @remarks During reconciliation, the assignment is deferred and applied after the current cycle completes.
      */
-    assign(id: string, def: Record<string, unknown>): void;
+    assign(id: string, def: DynamicResolverDef<M>): void;
     /**
      * Remove a dynamically registered resolver.
      * Static (module-defined) resolvers cannot be unregistered — logs a dev warning and no-ops.
@@ -1771,16 +1785,70 @@ interface ResolversControl {
     /** List all dynamically registered resolver IDs */
     listDynamic(): string[];
 }
+/** Constraint definition for dynamic registration — typed facts, relaxed requirements */
+interface DynamicConstraintDef<M extends ModuleSchema = ModuleSchema> {
+    priority?: number;
+    async?: boolean;
+    when: (facts: Readonly<InferSchema<M["facts"]>>) => boolean | Promise<boolean>;
+    require: {
+        type: string;
+        [key: string]: unknown;
+    } | {
+        type: string;
+        [key: string]: unknown;
+    }[] | null | ((facts: Readonly<InferSchema<M["facts"]>>) => {
+        type: string;
+        [key: string]: unknown;
+    } | {
+        type: string;
+        [key: string]: unknown;
+    }[] | null);
+    timeout?: number;
+    after?: string[];
+    deps?: string[];
+}
+/** Effect definition for dynamic registration — typed facts */
+interface DynamicEffectDef<M extends ModuleSchema = ModuleSchema> {
+    run: (facts: Readonly<InferSchema<M["facts"]>>, prev: InferSchema<M["facts"]> | null) => void | (() => void) | Promise<void | (() => void)>;
+    deps?: Array<string & keyof InferSchema<M["facts"]>>;
+}
+/** Resolver definition for dynamic registration — typed context.facts, relaxed requirement */
+interface DynamicResolverDef<M extends ModuleSchema = ModuleSchema> {
+    requirement: string;
+    key?: (req: {
+        type: string;
+        [key: string]: unknown;
+    }) => string;
+    retry?: RetryPolicy;
+    timeout?: number;
+    batch?: BatchConfig;
+    resolve?: (req: {
+        type: string;
+        [key: string]: unknown;
+    }, context: {
+        facts: InferSchema<M["facts"]>;
+        signal: AbortSignal;
+        snapshot: () => InferSchema<M["facts"]>;
+    }) => Promise<void>;
+    resolveBatch?: (reqs: {
+        type: string;
+        [key: string]: unknown;
+    }[], context: {
+        facts: InferSchema<M["facts"]>;
+        signal: AbortSignal;
+        snapshot: () => InferSchema<M["facts"]>;
+    }) => Promise<void>;
+}
 interface System<M extends ModuleSchema = ModuleSchema> {
     readonly facts: Facts<M["facts"]>;
-    readonly debug: TimeTravelAPI | null;
-    readonly derive: InferDerivations<M> & DerivationsControl;
+    readonly history: HistoryAPI | null;
+    readonly derive: InferDerivations<M> & DerivationsControl<M>;
     readonly events: EventsAccessorFromSchema<M>;
-    readonly constraints: ConstraintsControl;
-    readonly effects: EffectsControl;
-    readonly resolvers: ResolversControl;
-    /** Per-run changelog entries (null if debug.runHistory is not enabled) */
-    readonly runHistory: RunChangelogEntry[] | null;
+    readonly constraints: ConstraintsControl<M>;
+    readonly effects: EffectsControl<M>;
+    readonly resolvers: ResolversControl<M>;
+    /** Per-run trace entries (null if trace is not enabled) */
+    readonly trace: TraceEntry[] | null;
     /** Initialize facts and derivations without starting reconciliation. Safe for SSR. */
     initialize(): void;
     start(): void;
@@ -1804,11 +1872,11 @@ interface System<M extends ModuleSchema = ModuleSchema> {
      */
     onSettledChange(listener: () => void): () => void;
     /**
-     * Subscribe to time-travel state changes.
-     * Called whenever a snapshot is taken or time-travel navigation occurs.
+     * Subscribe to history state changes.
+     * Called whenever a snapshot is taken or history navigation occurs.
      * Returns an unsubscribe function.
      */
-    onTimeTravelChange(listener: () => void): () => void;
+    onHistoryChange(listener: () => void): () => void;
     read<K extends DerivationKeys<M>>(id: K): DerivationReturnType<M, K>;
     read<K extends FactKeys<M>>(id: K): FactReturnType<M, K>;
     read<T = unknown>(id: string): T;
@@ -1903,7 +1971,8 @@ interface System<M extends ModuleSchema = ModuleSchema> {
 interface SystemConfig<M extends ModuleSchema = ModuleSchema> {
     modules: Array<ModuleDef<M>>;
     plugins?: Array<Plugin<any>>;
-    debug?: DebugConfig;
+    history?: HistoryOption;
+    trace?: TraceOption;
     errorBoundary?: ErrorBoundaryConfig;
     /**
      * Callback invoked after module inits but before first reconcile.
@@ -2092,16 +2161,16 @@ interface Plugin<M extends ModuleSchema = ModuleSchema> {
      */
     onEffectError?: (id: string, error: unknown) => void;
     /**
-     * Called when a time-travel snapshot is taken.
+     * Called when a history snapshot is taken.
      * @param snapshot - The snapshot that was captured
      */
     onSnapshot?: (snapshot: Snapshot) => void;
     /**
-     * Called when time-travel navigation occurs.
+     * Called when history navigation occurs (undo/redo/goTo).
      * @param from - The index we navigated from
      * @param to - The index we navigated to
      */
-    onTimeTravel?: (from: number, to: number) => void;
+    onHistoryNavigate?: (from: number, to: number) => void;
     /**
      * Called when any error occurs in the system.
      * @param error - The DirectiveError with source and context
@@ -2142,11 +2211,11 @@ interface Plugin<M extends ModuleSchema = ModuleSchema> {
      */
     onDefinitionCall?: (type: string, id: string, props?: unknown) => void;
     /**
-     * Called when a run finalizes (all resolvers settled or no resolvers started).
-     * Only fires when debug.runHistory is enabled.
-     * @param run - The complete run changelog entry
+     * Called when a trace entry finalizes (all resolvers settled or no resolvers started).
+     * Only fires when trace is enabled.
+     * @param entry - The complete trace entry
      */
-    onRunComplete?: (run: RunChangelogEntry) => void;
+    onTraceComplete?: (entry: TraceEntry) => void;
 }
 
-export { type AnySystem as $, type ConstraintState as A, type BatchConfig as B, type CrossModuleDeps as C, type DerivationsSchema as D, type EffectsDef as E, type Facts as F, type ResolversDef as G, type ResolverStatus as H, type InferRequirements as I, type System as J, type FactChange as K, type FactsSnapshot as L, type ModuleSchema as M, type NamespacedSystem as N, type ReconcileResult as O, type Plugin as P, type Snapshot as Q, type Requirement as R, type Schema as S, type TypedDerivationsDef as T, DirectiveError as U, type RecoveryStrategy as V, type RunChangelogEntry as W, type ErrorSource as X, type RetryLaterConfig as Y, type TimeTravelAPI as Z, type SystemConfig as _, type RequirementOutput$1 as a, type BatchItemResult as a0, type BatchResolveResults as a1, type ConstraintsControl as a2, type CrossModuleConstraintDef as a3, type CrossModuleDerivationFn as a4, type CrossModuleEffectDef as a5, type CrossModuleFactsWithSelf as a6, type DerivationKeys as a7, type DerivationReturnType as a8, type DerivationsControl as a9, type ObservableKeys as aA, type RequirementExplanation as aB, type RequirementPayloadSchema$1 as aC, type RequirementsSchema as aD, type ResolversControl as aE, type SnapshotMeta as aF, type SystemEvent as aG, type SystemInspection as aH, type SystemMode as aI, type SystemSnapshot as aJ, type TimeTravelState as aK, type TypedResolverContext as aL, type TypedResolverDef as aM, type UnionEvents as aN, isNamespacedSystem as aO, isSingleModuleSystem as aP, type DeriveAccessor as aa, type DispatchEventsFromSchema as ab, type DistributableSnapshot as ac, type DistributableSnapshotOptions as ad, type EffectCleanup as ae, type EffectsControl as af, type EventPayloadSchema as ag, type EventsAccessor as ah, type EventsAccessorFromSchema as ai, type EventsDef as aj, type EventsSchema as ak, type FactKeys as al, type FactReturnType as am, type FlexibleEventHandler as an, type InferDerivations as ao, type InferEventPayloadFromSchema as ap, type InferEvents as aq, type InferRequirementPayloadFromSchema as ar, type InferRequirementTypes as as, type InferSchema as at, type InferSchemaType as au, type InferSelectorState as av, type MutableNamespacedFacts as aw, type NamespacedDerivations as ax, type NamespacedEventsAccessor as ay, type NamespacedFacts as az, type RetryPolicy as b, type ResolverContext as c, type SchemaType as d, type TypedEventsDef as e, type TypedConstraintsDef as f, type TypedResolversDef as g, type ModuleHooks as h, type CrossModuleDerivationsDef as i, type CrossModuleEffectsDef as j, type CrossModuleConstraintsDef as k, type ModuleDef as l, type CreateSystemOptionsSingle as m, type SingleModuleSystem as n, type ModulesMap as o, type CreateSystemOptionsNamed as p, type TypedConstraintDef as q, type RequirementOutput as r, type DebugConfig as s, type ErrorBoundaryConfig as t, type InferFacts as u, type ExtractSchema as v, type RequirementWithId as w, type RequirementKeyFn as x, type FactsStore as y, type ConstraintsDef as z };
+export { type CrossModuleDerivationFn as $, type FactChange as A, type BatchConfig as B, type CrossModuleDeps as C, type FactsSnapshot as D, type EffectsDef as E, type Facts as F, type ReconcileResult as G, type Snapshot as H, DirectiveError as I, type RecoveryStrategy as J, type TraceEntry as K, type ErrorSource as L, type ModuleSchema as M, type NamespacedSystem as N, type RetryLaterConfig as O, type Plugin as P, type HistoryAPI as Q, type Requirement as R, type Schema as S, type TypedDerivationsDef as T, type HistoryOption as U, type SystemConfig as V, type AnySystem as W, type BatchItemResult as X, type BatchResolveResults as Y, type ConstraintsControl as Z, type CrossModuleConstraintDef as _, type RequirementOutput$1 as a, type CrossModuleEffectDef as a0, type CrossModuleFactsWithSelf as a1, type DerivationKeys as a2, type DerivationReturnType as a3, type DerivationsControl as a4, type DerivationsSchema as a5, type DeriveAccessor as a6, type DispatchEventsFromSchema as a7, type DistributableSnapshot as a8, type DistributableSnapshotOptions as a9, type NamespacedDerivations as aA, type NamespacedEventsAccessor as aB, type NamespacedFacts as aC, type ObservableKeys as aD, type RequirementExplanation as aE, type RequirementOutput as aF, type RequirementPayloadSchema$1 as aG, type RequirementsSchema as aH, type ResolversControl as aI, type SnapshotMeta as aJ, type SystemEvent as aK, type SystemInspection as aL, type SystemMode as aM, type SystemSnapshot as aN, type TraceConfig as aO, type TypedConstraintDef as aP, type TypedResolverContext as aQ, type TypedResolverDef as aR, type UnionEvents as aS, isNamespacedSystem as aT, isSingleModuleSystem as aU, type DynamicConstraintDef as aa, type DynamicEffectDef as ab, type DynamicResolverDef as ac, type EffectCleanup as ad, type EffectsControl as ae, type EventPayloadSchema as af, type EventsAccessor as ag, type EventsAccessorFromSchema as ah, type EventsDef as ai, type EventsSchema as aj, type FactKeys as ak, type FactReturnType as al, type FlexibleEventHandler as am, type HistoryConfig as an, type HistoryState as ao, type InferDerivations as ap, type InferEventPayloadFromSchema as aq, type InferEvents as ar, type InferFacts as as, type InferRequirementPayloadFromSchema as at, type InferRequirementTypes as au, type InferRequirements as av, type InferSchema as aw, type InferSchemaType as ax, type InferSelectorState as ay, type MutableNamespacedFacts as az, type RetryPolicy as b, type ResolverContext as c, type SchemaType as d, type TypedEventsDef as e, type TypedConstraintsDef as f, type TypedResolversDef as g, type ModuleHooks as h, type CrossModuleDerivationsDef as i, type CrossModuleEffectsDef as j, type CrossModuleConstraintsDef as k, type ModuleDef as l, type CreateSystemOptionsSingle as m, type SingleModuleSystem as n, type ModulesMap as o, type CreateSystemOptionsNamed as p, type TraceOption as q, type ErrorBoundaryConfig as r, type RequirementWithId as s, type RequirementKeyFn as t, type FactsStore as u, type ConstraintsDef as v, type ConstraintState as w, type ResolversDef as x, type ResolverStatus as y, type System as z };