@directive-run/core 0.4.2 → 0.7.0

package/dist/{plugins-cDWoL7A7.d.ts → plugins-DaglUQVX.d.ts}

@@ -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,18 +729,20 @@ 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>;
+    readonly derive: NamespacedDerivations<Modules> & DerivationsControl;
     /** Events accessor (union of all module events) */
     readonly events: NamespacedEventsAccessor<Modules>;
-    /** Runtime control for constraints (disable/enable/isDisabled) */
+    /** Runtime control for constraints (disable/enable/isDisabled + dynamic CRUD) */
     readonly constraints: ConstraintsControl;
-    /** Runtime control for effects (disable/enable/isEnabled) */
+    /** Runtime control for effects (disable/enable/isEnabled + dynamic CRUD) */
     readonly effects: EffectsControl;
-    /** Per-run changelog entries (null if debug.runHistory is not enabled) */
-    readonly runHistory: RunChangelogEntry[] | null;
+    /** Runtime control for resolvers (dynamic CRUD) */
+    readonly resolvers: ResolversControl;
+    /** 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) */
@@ -786,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").
@@ -931,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) */
@@ -954,18 +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>;
+    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;
-    /** Per-run changelog entries (null if debug.runHistory is not enabled) */
-    readonly runHistory: RunChangelogEntry[] | null;
+    readonly effects: EffectsControl<S>;
+    /** Runtime control for resolvers (register/assign/unregister/call) */
+    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) */
@@ -998,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")
@@ -1165,7 +1173,7 @@ type GetRequirementsSchema<M extends ModuleSchema> = M["requirements"] extends R
  * The derive accessor is typed from schema.derivations.
  * Supports both t.*() builders and type assertion {} as {} patterns.
  */
-type TypedDerivationFn<M extends ModuleSchema, K extends keyof GetDerivationsSchema<M>> = (facts: Facts<M["facts"]>, derive: InferDerivations<M>) => InferSchemaType<GetDerivationsSchema<M>[K]>;
+type TypedDerivationFn<M extends ModuleSchema, K extends keyof GetDerivationsSchema<M>> = (facts: Facts<M["facts"]>, derived: InferDerivations<M>) => InferSchemaType<GetDerivationsSchema<M>[K]>;
 /**
  * Typed derivations definition using the module schema.
  * Each derivation key must match schema.derivations and return the declared type.
@@ -1286,7 +1294,7 @@ type CrossModuleEffectsDef<M extends ModuleSchema, Deps extends CrossModuleDeps>
  * - `facts.self.*` for own module's facts
  * - `facts.{dep}.*` for cross-module facts (read-only)
  */
-type CrossModuleDerivationFn<M extends ModuleSchema, Deps extends CrossModuleDeps, K extends keyof GetDerivationsSchema<M>> = (facts: CrossModuleFactsWithSelf<M, Deps>, derive: InferDerivations<M>) => InferSchemaType<GetDerivationsSchema<M>[K]>;
+type CrossModuleDerivationFn<M extends ModuleSchema, Deps extends CrossModuleDeps, K extends keyof GetDerivationsSchema<M>> = (facts: CrossModuleFactsWithSelf<M, Deps>, derived: InferDerivations<M>) => InferSchemaType<GetDerivationsSchema<M>[K]>;
 /**
  * Cross-module derivations definition.
  */
@@ -1356,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}.*`.
@@ -1401,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;
@@ -1434,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;
@@ -1456,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 */
@@ -1551,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 {
@@ -1628,32 +1645,210 @@ 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 */
     enable(id: string): void;
     /** Check if a constraint is currently disabled */
     isDisabled(id: string): boolean;
+    /**
+     * Register a new constraint at runtime.
+     * @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: 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: DynamicConstraintDef<M>): void;
+    /**
+     * Remove a dynamically registered constraint.
+     * Static (module-defined) constraints cannot be unregistered — logs a dev warning and no-ops.
+     * @remarks During reconciliation, the unregistration is deferred and applied after the current cycle completes.
+     */
+    unregister(id: string): void;
+    /**
+     * Invoke a constraint's `when()` predicate. If true, evaluates its `require()` and returns the requirements
+     * (with optional props merged). The requirements are returned for inspection but NOT automatically dispatched
+     * to the resolver system.
+     * @throws If no constraint with this ID exists
+     */
+    call(id: string, props?: Record<string, unknown>): Promise<Record<string, unknown>[]>;
+    /** Check if a constraint was dynamically registered (not from a module definition) */
+    isDynamic(id: string): boolean;
+    /** List all dynamically registered constraint IDs */
+    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 */
     enable(id: string): void;
     /** Check if an effect is currently enabled */
     isEnabled(id: string): boolean;
+    /**
+     * Register a new effect at runtime.
+     * @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: 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: DynamicEffectDef<M>): void;
+    /**
+     * Remove a dynamically registered effect.
+     * Static (module-defined) effects cannot be unregistered — logs a dev warning and no-ops.
+     * @remarks During reconciliation, the unregistration is deferred and applied after the current cycle completes.
+     */
+    unregister(id: string): void;
+    /**
+     * Execute an effect's `run()` function immediately.
+     * @throws If no effect with this ID exists
+     */
+    call(id: string): Promise<void>;
+    /** Check if an effect was dynamically registered (not from a module definition) */
+    isDynamic(id: string): boolean;
+    /** List all dynamically registered effect IDs */
+    listDynamic(): string[];
+}
+/** Runtime control for derivations (dynamic registration + value access) */
+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: 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: 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.
+     * @remarks During reconciliation, the unregistration is deferred and applied after the current cycle completes.
+     */
+    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<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<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: 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: DynamicResolverDef<M>): void;
+    /**
+     * Remove a dynamically registered resolver.
+     * Static (module-defined) resolvers cannot be unregistered — logs a dev warning and no-ops.
+     * @remarks During reconciliation, the unregistration is deferred and applied after the current cycle completes.
+     */
+    unregister(id: string): void;
+    /**
+     * Execute a resolver's `resolve()` with a requirement object.
+     * @throws If no resolver with this ID exists
+     */
+    call(id: string, requirement: {
+        type: string;
+        [key: string]: unknown;
+    }): Promise<void>;
+    /** Check if a resolver was dynamically registered (not from a module definition) */
+    isDynamic(id: string): boolean;
+    /** 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>;
+    readonly history: HistoryAPI | null;
+    readonly derive: InferDerivations<M> & DerivationsControl<M>;
     readonly events: EventsAccessorFromSchema<M>;
-    readonly constraints: ConstraintsControl;
-    readonly effects: EffectsControl;
-    /** 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;
@@ -1677,13 +1872,14 @@ 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;
-    read<K extends DerivationKeys<M>>(derivationId: K): DerivationReturnType<M, K>;
-    read<T = unknown>(derivationId: string): T;
+    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;
     /**
      * Subscribe to fact or derivation changes.
      * Keys are auto-detected -- pass any mix of fact keys and derivation keys.
@@ -1724,6 +1920,17 @@ interface System<M extends ModuleSchema = ModuleSchema> {
     explain(requirementId: string): string | null;
     getSnapshot(): SystemSnapshot;
     restore(snapshot: SystemSnapshot): void;
+    /**
+     * Get the original definition that was overridden by `assign()`.
+     * Returns undefined if no original exists for this type/id.
+     */
+    getOriginal(type: "constraint" | "resolver" | "derivation" | "effect", id: string): unknown | undefined;
+    /**
+     * Restore the original definition that was overridden by `assign()`.
+     * Re-assigns the original definition and removes the override tracking.
+     * Returns true if restoration succeeded, false if no original exists.
+     */
+    restoreOriginal(type: "constraint" | "resolver" | "derivation" | "effect", id: string): boolean;
     /**
      * Get a distributable snapshot of computed derivations.
      * This creates a serializable object that can be stored in Redis, JWT, etc.
@@ -1764,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.
@@ -1953,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
@@ -1975,11 +2183,39 @@ interface Plugin<M extends ModuleSchema = ModuleSchema> {
      */
     onErrorRecovery?: (error: DirectiveError, strategy: RecoveryStrategy) => 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 definition is dynamically registered at runtime.
+     * @param type - The definition type: "constraint", "resolver", "derivation", or "effect"
+     * @param id - The definition ID
+     * @param def - The definition object
+     */
+    onDefinitionRegister?: (type: string, id: string, def: unknown) => void;
+    /**
+     * Called when a definition is assigned (overridden) at runtime.
+     * @param type - The definition type: "constraint", "resolver", "derivation", or "effect"
+     * @param id - The definition ID
+     * @param def - The new definition object
+     * @param original - The previous definition that was overridden
+     */
+    onDefinitionAssign?: (type: string, id: string, def: unknown, original: unknown) => void;
+    /**
+     * Called when a dynamically registered definition is removed.
+     * @param type - The definition type: "constraint", "resolver", "derivation", or "effect"
+     * @param id - The definition ID
+     */
+    onDefinitionUnregister?: (type: string, id: string) => void;
+    /**
+     * Called when a definition is manually invoked via `call()`.
+     * @param type - The definition type: "constraint", "resolver", "derivation", or "effect"
+     * @param id - The definition ID
+     * @param props - Optional props passed to the call
+     */
+    onDefinitionCall?: (type: string, id: string, props?: unknown) => void;
+    /**
+     * 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 CrossModuleConstraintDef as a2, type CrossModuleDerivationFn as a3, type CrossModuleEffectDef as a4, type CrossModuleFactsWithSelf as a5, type DerivationKeys as a6, type DerivationReturnType as a7, type DeriveAccessor as a8, type DispatchEventsFromSchema as a9, type RequirementsSchema as aA, type SnapshotMeta as aB, type SystemEvent as aC, type SystemInspection as aD, type SystemMode as aE, type SystemSnapshot as aF, type TimeTravelState as aG, type TypedResolverContext as aH, type TypedResolverDef as aI, type UnionEvents as aJ, isNamespacedSystem as aK, isSingleModuleSystem as aL, type DistributableSnapshot as aa, type DistributableSnapshotOptions as ab, type EffectCleanup as ac, type EventPayloadSchema as ad, type EventsAccessor as ae, type EventsAccessorFromSchema as af, type EventsDef as ag, type EventsSchema as ah, type FactKeys as ai, type FactReturnType as aj, type FlexibleEventHandler as ak, type InferDerivations as al, type InferEventPayloadFromSchema as am, type InferEvents as an, type InferRequirementPayloadFromSchema as ao, type InferRequirementTypes as ap, type InferSchema as aq, type InferSchemaType as ar, type InferSelectorState as as, type MutableNamespacedFacts as at, type NamespacedDerivations as au, type NamespacedEventsAccessor as av, type NamespacedFacts as aw, type ObservableKeys as ax, type RequirementExplanation as ay, type RequirementPayloadSchema$1 as az, type RetryPolicy as b, type ResolverContext as c, type SchemaType as d, type FactsStore as e, type TypedEventsDef as f, type TypedConstraintsDef as g, type TypedResolversDef as h, type ModuleHooks as i, type CrossModuleDerivationsDef as j, type CrossModuleEffectsDef as k, type CrossModuleConstraintsDef as l, type ModuleDef as m, type CreateSystemOptionsSingle as n, type SingleModuleSystem as o, type ModulesMap as p, type CreateSystemOptionsNamed as q, type TypedConstraintDef as r, type RequirementOutput as s, type DebugConfig as t, type ErrorBoundaryConfig as u, type InferFacts as v, type ExtractSchema as w, type RequirementWithId as x, type RequirementKeyFn 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 };