@directive-run/core 0.4.1 → 0.5.0

package/dist/index.d.cts

@@ -1,7 +1,6 @@
-import { S as Schema, F as Facts, R as Requirement, a as RequirementOutput, b as RetryPolicy, B as BatchConfig, c as ResolverContext, d as SchemaType, e as FactsStore, M as ModuleSchema, T as TypedDerivationsDef, f as TypedEventsDef, E as EffectsDef, g as TypedConstraintsDef, h as TypedResolversDef, i as ModuleHooks, C as CrossModuleDeps, j as CrossModuleDerivationsDef, k as CrossModuleEffectsDef, l as CrossModuleConstraintsDef, m as ModuleDef, n as CreateSystemOptionsSingle, o as SingleModuleSystem, p as ModulesMap, q as CreateSystemOptionsNamed, N as NamespacedSystem, D as DerivationsSchema, r as TypedConstraintDef, s as RequirementOutput$1, I as InferRequirements, P as Plugin, t as DebugConfig, u as ErrorBoundaryConfig, v as InferFacts, w as ExtractSchema, x as RequirementWithId, y as RequirementKeyFn, z as ConstraintsDef, A as ConstraintState, G as ResolversDef, H as ResolverStatus, J as System, K as FactChange, L as FactsSnapshot, O as ReconcileResult, Q as Snapshot, U as DirectiveError, V as RecoveryStrategy, W as RunChangelogEntry, X as ErrorSource, Y as RetryLaterConfig, Z as TimeTravelAPI, _ as SystemConfig } from './plugins-cDWoL7A7.cjs';
-export { $ as AnySystem, a0 as BatchItemResult, a1 as BatchResolveResults, a2 as CrossModuleConstraintDef, a3 as CrossModuleDerivationFn, a4 as CrossModuleEffectDef, a5 as CrossModuleFactsWithSelf, a6 as DerivationKeys, a7 as DerivationReturnType, a8 as DeriveAccessor, a9 as DispatchEventsFromSchema, aa as DistributableSnapshot, ab as DistributableSnapshotOptions, ac as EffectCleanup, ad as EventPayloadSchema, ae as EventsAccessor, af as EventsAccessorFromSchema, ag as EventsDef, ah as EventsSchema, ai as FactKeys, aj as FactReturnType, ak as FlexibleEventHandler, al as InferDerivations, am as InferEventPayloadFromSchema, an as InferEvents, ao as InferRequirementPayloadFromSchema, ap as InferRequirementTypes, aq as InferSchema, ar as InferSchemaType, as as InferSelectorState, at as MutableNamespacedFacts, au as NamespacedDerivations, av as NamespacedEventsAccessor, aw as NamespacedFacts, ax as ObservableKeys, ay as RequirementExplanation, az as RequirementPayloadSchema, aA as RequirementsSchema, aB as SnapshotMeta, aC as SystemEvent, aD as SystemInspection, aE as SystemMode, aF as SystemSnapshot, aG as TimeTravelState, aH as TypedResolverContext, aI as TypedResolverDef, aJ as UnionEvents, aK as isNamespacedSystem, aL as isSingleModuleSystem } from './plugins-cDWoL7A7.cjs';
+import { S as Schema, F as Facts, R as Requirement, a as RequirementOutput, b as RetryPolicy, B as BatchConfig, c as ResolverContext, d as SchemaType, M as ModuleSchema, T as TypedDerivationsDef, e as TypedEventsDef, E as EffectsDef, f as TypedConstraintsDef, g as TypedResolversDef, h as ModuleHooks, C as CrossModuleDeps, i as CrossModuleDerivationsDef, j as CrossModuleEffectsDef, k as CrossModuleConstraintsDef, l as ModuleDef, m as CreateSystemOptionsSingle, n as SingleModuleSystem, o as ModulesMap, p as CreateSystemOptionsNamed, N as NamespacedSystem, D as DerivationsSchema, q as TypedConstraintDef, r as RequirementOutput$1, I as InferRequirements, P as Plugin, s as DebugConfig, t as ErrorBoundaryConfig, u as InferFacts, v as ExtractSchema, w as RequirementWithId, x as RequirementKeyFn, y as FactsStore, z as ConstraintsDef, A as ConstraintState, G as ResolversDef, H as ResolverStatus, J as System, K as FactChange, L as FactsSnapshot, O as ReconcileResult, Q as Snapshot, U as DirectiveError, V as RecoveryStrategy, W as RunChangelogEntry, X as ErrorSource, Y as RetryLaterConfig, Z as TimeTravelAPI, _ as SystemConfig } from './plugins-Co2_xohI.cjs';
+export { $ as AnySystem, a0 as BatchItemResult, a1 as BatchResolveResults, a2 as ConstraintsControl, a3 as CrossModuleConstraintDef, a4 as CrossModuleDerivationFn, a5 as CrossModuleEffectDef, a6 as CrossModuleFactsWithSelf, a7 as DerivationKeys, a8 as DerivationReturnType, a9 as DerivationsControl, aa as DeriveAccessor, ab as DispatchEventsFromSchema, ac as DistributableSnapshot, ad as DistributableSnapshotOptions, ae as EffectCleanup, af as EffectsControl, ag as EventPayloadSchema, ah as EventsAccessor, ai as EventsAccessorFromSchema, aj as EventsDef, ak as EventsSchema, al as FactKeys, am as FactReturnType, an as FlexibleEventHandler, ao as InferDerivations, ap as InferEventPayloadFromSchema, aq as InferEvents, ar as InferRequirementPayloadFromSchema, as as InferRequirementTypes, at as InferSchema, au as InferSchemaType, av as InferSelectorState, aw as MutableNamespacedFacts, ax as NamespacedDerivations, ay as NamespacedEventsAccessor, az as NamespacedFacts, aA as ObservableKeys, aB as RequirementExplanation, aC as RequirementPayloadSchema, aD as RequirementsSchema, aE as ResolversControl, aF as SnapshotMeta, aG as SystemEvent, aH as SystemInspection, aI as SystemMode, aJ as SystemSnapshot, aK as TimeTravelState, aL as TypedResolverContext, aM as TypedResolverDef, aN as UnionEvents, aO as isNamespacedSystem, aP as isSingleModuleSystem } from './plugins-Co2_xohI.cjs';
 export { D as DistributableSnapshotLike, S as SignedSnapshot, a as SnapshotDiff, b as SnapshotDiffEntry, d as diffSnapshots, i as isSignedSnapshot, c as isSnapshotExpired, s as shallowEqual, e as signSnapshot, v as validateSnapshot, f as verifySnapshotSignature } from './utils-4JrY5fk9.cjs';
-export { DirectiveModuleStructure, ReduxSliceConfig, XStateMachineConfig, ZustandStoreConfig, analyzeReduxSlice, analyzeXStateMachine, analyzeZustandStore, generateMigrationChecklist, generateModuleCode } from './migration.cjs';
 
 /**
  * Derivation Types - Type definitions for derivations
@@ -15,7 +14,7 @@ interface TrackingContext {
 }
 /** Derivation definition function signature. */
 interface DerivationDef<S extends Schema, T, D extends DerivationsDef<S>> {
-    (facts: Facts<S>, derive: DerivedValues<S, D>): T;
+    (facts: Facts<S>, derived: DerivedValues<S, D>): T;
 }
 /** Map of derivation definitions. */
 type DerivationsDef<S extends Schema> = Record<string, DerivationDef<S, unknown, DerivationsDef<S>>>;
@@ -143,7 +142,7 @@ interface TypedResolver<S extends Schema, R extends Requirement = Requirement> {
  * @example
  * ```typescript
  * const schema = { count: t.number(), threshold: t.number() };
- * const factory = constraintFactory<typeof schema>();
+ * const factory = createConstraintFactory<typeof schema>();
  *
  * const maxCountConstraint = factory.create({
  *   when: (facts) => facts.count > facts.threshold,
@@ -151,7 +150,7 @@ interface TypedResolver<S extends Schema, R extends Requirement = Requirement> {
  * });
  * ```
  */
-declare function constraintFactory<S extends Schema>(): {
+declare function createConstraintFactory<S extends Schema>(): {
     /**
      * Create a typed constraint
      */
@@ -164,7 +163,7 @@ declare function constraintFactory<S extends Schema>(): {
  * @example
  * ```typescript
  * const schema = { user: t.object<User>() };
- * const factory = resolverFactory<typeof schema>();
+ * const factory = createResolverFactory<typeof schema>();
  *
  * const fetchUserResolver = factory.create<FetchUserReq>({
  *   requirement: (req): req is FetchUserReq => req.type === "FETCH_USER",
@@ -174,7 +173,7 @@ declare function constraintFactory<S extends Schema>(): {
  * });
  * ```
  */
-declare function resolverFactory<S extends Schema>(): {
+declare function createResolverFactory<S extends Schema>(): {
     /**
      * Create a typed resolver
      */
@@ -182,7 +181,7 @@ declare function resolverFactory<S extends Schema>(): {
 };
 /**
  * Type-safe constraint creator.
- * Simpler alternative to constraintFactory when you don't need a factory pattern.
+ * Simpler alternative to createConstraintFactory when you don't need a factory pattern.
  *
  * @example
  * ```typescript
@@ -195,7 +194,7 @@ declare function resolverFactory<S extends Schema>(): {
 declare function typedConstraint<S extends Schema, R extends Requirement = Requirement>(constraint: TypedConstraint<S, R>): TypedConstraint<S, R>;
 /**
  * Type-safe resolver creator.
- * Simpler alternative to resolverFactory when you don't need a factory pattern.
+ * Simpler alternative to createResolverFactory when you don't need a factory pattern.
  *
  * @example
  * ```typescript
@@ -210,14 +209,12 @@ declare function typedConstraint<S extends Schema, R extends Requirement = Requi
 declare function typedResolver<S extends Schema, R extends Requirement = Requirement>(resolver: TypedResolver<S, R>): TypedResolver<S, R>;
 
 /**
- * Facts Store - Proxy-based reactive state with auto-tracking
+ * Schema Type Builders
  *
- * Features:
- * - Proxy-based access (facts.phase instead of facts.get("phase"))
- * - Automatic dependency tracking via tracking context
- * - Batched updates with coalesced notifications
- * - Granular subscriptions by key
- * - Schema validation in development mode
+ * Provides type-safe schema definitions with optional runtime validation.
+ * Used to define fact types, derivation types, event payload types, etc.
+ *
+ * This module has no dependency on the facts store or tracking system.
  */
 
 /** Brand symbol for branded types */
@@ -346,12 +343,14 @@ declare const t: {
         _lastFailedIndex?: number;
     };
     /**
-     * Create an object schema type.
+     * Create an object schema type for any complex value.
      * Can be used with or without shape validation:
      * - `t.object<User>()` - Type-only, no property validation
      * - `t.object<User>().shape({ name: t.string(), age: t.number() })` - With property validation
+     *
+     * For arrays, prefer `t.array<T>()` which adds `Array.isArray` validation.
      */
-    object<T extends Record<string, unknown>>(): ChainableSchemaType<T> & {
+    object<T>(): ChainableSchemaType<T> & {
         shape(schema: { [K in keyof T]?: SchemaType<T[K]>; }): ChainableSchemaType<T> & /*elided*/ any;
         nonNull(): ChainableSchemaType<T> & /*elided*/ any;
         hasKeys(...keys: string[]): ChainableSchemaType<T> & /*elided*/ any;
@@ -495,108 +494,6 @@ declare const t: {
      */
     bigint(): ChainableSchemaType<bigint>;
 };
-/** Options for creating a facts store */
-interface CreateFactsStoreOptions<S extends Schema> {
-    schema: S;
-    /** Validate values against schema (default: process.env.NODE_ENV !== 'production') */
-    validate?: boolean;
-    /** Throw on unknown schema keys (default: true in dev mode) */
-    strictKeys?: boolean;
-    /** Redact sensitive values in error messages */
-    redactErrors?: boolean;
-    /** Callback when facts change (for plugin hooks) */
-    onChange?: (key: string, value: unknown, prev: unknown) => void;
-    /** Callback for batch changes */
-    onBatch?: (changes: Array<{
-        key: string;
-        value: unknown;
-        prev: unknown;
-        type: "set" | "delete";
-    }>) => void;
-}
-/**
- * Create a reactive facts store backed by a Map with schema validation,
- * batched mutations, and granular key-level subscriptions.
- *
- * @remarks
- * The store is the low-level primitive that powers the `facts` proxy.
- * Most users should use {@link createFacts} or `createModule` instead.
- *
- * @param options - Store configuration including schema, validation settings, and change callbacks
- * @returns A {@link FactsStore} with get/set/batch/subscribe methods and automatic schema validation
- *
- * @example
- * ```ts
- * const store = createFactsStore({
- *   schema: { count: t.number(), name: t.string() },
- * });
- *
- * store.set("count", 1);
- * store.get("count"); // 1
- *
- * store.batch(() => {
- *   store.set("count", 2);
- *   store.set("name", "hello");
- * }); // listeners fire once after batch completes
- * ```
- *
- * @internal
- */
-declare function createFactsStore<S extends Schema>(options: CreateFactsStoreOptions<S>): FactsStore<S>;
-/**
- * Create a Proxy wrapper around a {@link FactsStore} for clean property-style
- * access (`facts.phase`) with automatic dependency tracking.
- *
- * @remarks
- * Reading a property calls `store.get()` (which tracks the access for
- * auto-tracked derivations). Writing a property calls `store.set()` (which
- * validates against the schema). The proxy also exposes `$store` for direct
- * store access and `$snapshot()` for untracked reads.
- *
- * @param store - The underlying facts store to wrap
- * @param schema - The schema definition used for `ownKeys` enumeration
- * @returns A {@link Facts} proxy with property-style get/set and prototype pollution guards
- *
- * @example
- * ```ts
- * const store = createFactsStore({ schema: { phase: t.string() } });
- * const facts = createFactsProxy(store, { phase: t.string() });
- *
- * facts.phase = "red";
- * console.log(facts.phase); // "red"
- * ```
- *
- * @internal
- */
-declare function createFactsProxy<S extends Schema>(store: FactsStore<S>, schema: S): Facts<S>;
-/**
- * Convenience factory that creates both a {@link FactsStore} and its
- * {@link createFactsProxy | proxy wrapper} in a single call.
- *
- * @remarks
- * This is the recommended entry point when you need low-level store access
- * outside of `createModule` / `createSystem`.
- *
- * @param options - Same options as {@link createFactsStore}
- * @returns An object with `store` (the reactive Map-backed store) and `facts` (the Proxy accessor)
- *
- * @example
- * ```ts
- * const { store, facts } = createFacts({
- *   schema: { phase: t.string<"red" | "green">() },
- * });
- *
- * facts.phase = "red";
- * console.log(facts.phase); // "red"
- * store.subscribe(["phase"], () => console.log("phase changed"));
- * ```
- *
- * @internal
- */
-declare function createFacts<S extends Schema>(options: CreateFactsStoreOptions<S>): {
-    store: FactsStore<S>;
-    facts: Facts<S>;
-};
 
 /**
  * Module - The declarative API for defining Directive modules
@@ -696,7 +593,7 @@ interface ModuleConfigWithDeps<M extends ModuleSchema, Deps extends CrossModuleD
  * Create a module definition with full type inference.
  *
  * The consolidated schema provides:
- * - Derivation composition (`derive.otherDerivation` is typed)
+ * - Derivation composition (`derived.otherDerivation` is typed)
  * - Event dispatch (`system.dispatch({ type: "..." })` has autocomplete)
  * - Resolver requirements (`req.payload` is typed based on requirement type)
  *
@@ -730,9 +627,9 @@ interface ModuleConfigWithDeps<M extends ModuleSchema, Deps extends CrossModuleD
  *   },
  *   derive: {
  *     isRed: (facts) => facts.phase === "red",
- *     timeRemaining: (facts, derive) => {
- *       // derive.isRed is typed as boolean!
- *       return derive.isRed ? 30 - facts.elapsed : 0;
+ *     timeRemaining: (facts, derived) => {
+ *       // derived.isRed is typed as boolean!
+ *       return derived.isRed ? 30 - facts.elapsed : 0;
  *     },
  *   },
  *   events: {
@@ -933,7 +830,7 @@ interface ModuleBuilder<M extends ModuleSchema = ModuleSchema> {
      * Define derivation implementations for this module.
      * Keys must match those declared in schema.derivations.
      */
-    derive<D extends Record<string, (facts: Facts<M["facts"]>, derive: DeriveAccessor<M>) => unknown>>(derivations: D): ModuleBuilder<M>;
+    derive<D extends Record<string, (facts: Facts<M["facts"]>, derived: DeriveAccessor<M>) => unknown>>(derivations: D): ModuleBuilder<M>;
     /**
      * Define event handler implementations for this module.
      * Keys must match those declared in schema.events.
@@ -1448,20 +1345,6 @@ declare function createSystemWithStatus<M extends ModuleSchema>(options: CreateS
  * - Requirement comparison and hashing
  */
 
-/**
- * Generate a stable identity string for a requirement.
- *
- * When no custom key function is provided, the ID is formed from the
- * requirement's `type` plus a deterministic JSON serialization of its
- * remaining properties. A custom {@link RequirementKeyFn} can override
- * this to control deduplication granularity.
- *
- * @param req - The requirement to generate an ID for.
- * @param keyFn - Optional custom key function that overrides the default identity logic.
- * @returns A stable string that uniquely identifies this requirement for deduplication.
- *
- * @public
- */
 declare function generateRequirementId(req: Requirement, keyFn?: RequirementKeyFn): string;
 /**
  * Create a typed requirement factory for a given requirement type string.
@@ -1637,6 +1520,120 @@ declare class RequirementSet {
     };
 }
 
+/**
+ * Facts Store - Proxy-based reactive state with auto-tracking
+ *
+ * Features:
+ * - Proxy-based access (facts.phase instead of facts.get("phase"))
+ * - Automatic dependency tracking via tracking context
+ * - Batched updates with coalesced notifications
+ * - Granular subscriptions by key
+ * - Schema validation in development mode
+ */
+
+/** Options for creating a facts store */
+interface CreateFactsStoreOptions<S extends Schema> {
+    schema: S;
+    /** Validate values against schema (default: process.env.NODE_ENV !== 'production') */
+    validate?: boolean;
+    /** Throw on unknown schema keys (default: true in dev mode) */
+    strictKeys?: boolean;
+    /** Redact sensitive values in error messages */
+    redactErrors?: boolean;
+    /** Callback when facts change (for plugin hooks) */
+    onChange?: (key: string, value: unknown, prev: unknown) => void;
+    /** Callback for batch changes */
+    onBatch?: (changes: Array<{
+        key: string;
+        value: unknown;
+        prev: unknown;
+        type: "set" | "delete";
+    }>) => void;
+}
+/**
+ * Create a reactive facts store backed by a Map with schema validation,
+ * batched mutations, and granular key-level subscriptions.
+ *
+ * @remarks
+ * The store is the low-level primitive that powers the `facts` proxy.
+ * Most users should use {@link createFacts} or `createModule` instead.
+ *
+ * @param options - Store configuration including schema, validation settings, and change callbacks
+ * @returns A {@link FactsStore} with get/set/batch/subscribe methods and automatic schema validation
+ *
+ * @example
+ * ```ts
+ * const store = createFactsStore({
+ *   schema: { count: t.number(), name: t.string() },
+ * });
+ *
+ * store.set("count", 1);
+ * store.get("count"); // 1
+ *
+ * store.batch(() => {
+ *   store.set("count", 2);
+ *   store.set("name", "hello");
+ * }); // listeners fire once after batch completes
+ * ```
+ *
+ * @internal
+ */
+declare function createFactsStore<S extends Schema>(options: CreateFactsStoreOptions<S>): FactsStore<S>;
+/**
+ * Create a Proxy wrapper around a {@link FactsStore} for clean property-style
+ * access (`facts.phase`) with automatic dependency tracking.
+ *
+ * @remarks
+ * Reading a property calls `store.get()` (which tracks the access for
+ * auto-tracked derivations). Writing a property calls `store.set()` (which
+ * validates against the schema). The proxy also exposes `$store` for direct
+ * store access and `$snapshot()` for untracked reads.
+ *
+ * @param store - The underlying facts store to wrap
+ * @param schema - The schema definition used for `ownKeys` enumeration
+ * @returns A {@link Facts} proxy with property-style get/set and prototype pollution guards
+ *
+ * @example
+ * ```ts
+ * const store = createFactsStore({ schema: { phase: t.string() } });
+ * const facts = createFactsProxy(store, { phase: t.string() });
+ *
+ * facts.phase = "red";
+ * console.log(facts.phase); // "red"
+ * ```
+ *
+ * @internal
+ */
+declare function createFactsProxy<S extends Schema>(store: FactsStore<S>, schema: S): Facts<S>;
+/**
+ * Convenience factory that creates both a {@link FactsStore} and its
+ * {@link createFactsProxy | proxy wrapper} in a single call.
+ *
+ * @remarks
+ * This is the recommended entry point when you need low-level store access
+ * outside of `createModule` / `createSystem`.
+ *
+ * @param options - Same options as {@link createFactsStore}
+ * @returns An object with `store` (the reactive Map-backed store) and `facts` (the Proxy accessor)
+ *
+ * @example
+ * ```ts
+ * const { store, facts } = createFacts({
+ *   schema: { phase: t.string<"red" | "green">() },
+ * });
+ *
+ * facts.phase = "red";
+ * console.log(facts.phase); // "red"
+ * store.subscribe(["phase"], () => console.log("phase changed"));
+ * ```
+ *
+ * @internal
+ */
+declare function createFacts<S extends Schema>(options: CreateFactsStoreOptions<S>): {
+    store: FactsStore<S>;
+    facts: Facts<S>;
+};
+
 /**
  * Derivations - Auto-tracked computed values with composition
  *
@@ -1667,6 +1664,12 @@ interface DerivationsManager<S extends Schema, D extends DerivationsDef<S>> {
     getDependencies(id: keyof D): Set<string>;
     /** Register new derivation definitions (for dynamic module registration) */
     registerDefinitions(newDefs: DerivationsDef<S>): void;
+    /** Override an existing derivation function */
+    assignDefinition(id: string, fn: DerivationsDef<S>[keyof DerivationsDef<S>]): void;
+    /** Remove a derivation and clean up its state */
+    unregisterDefinition(id: string): void;
+    /** Compute a derivation immediately (ignores cache) */
+    callOne(id: string): unknown;
 }
 /** Options for creating a derivations manager */
 interface CreateDerivationsOptions<S extends Schema, D extends DerivationsDef<S>> {
@@ -1790,6 +1793,26 @@ interface EffectsManager<_S extends Schema = Schema> {
      * @param newDefs - New effect definitions to merge into the manager.
      */
     registerDefinitions(newDefs: EffectsDef<Schema>): void;
+    /**
+     * Override an existing effect definition. Runs cleanup of the old effect first.
+     *
+     * @param id - The effect definition ID to override.
+     * @param def - The new effect definition.
+     * @throws If no effect with this ID exists.
+     */
+    assignDefinition(id: string, def: EffectsDef<Schema>[string]): void;
+    /**
+     * Remove an effect definition. Runs cleanup (try-catch) and removes from state.
+     *
+     * @param id - The effect definition ID to remove.
+     */
+    unregisterDefinition(id: string): void;
+    /**
+     * Execute an effect's `run()` function immediately.
+     *
+     * @param id - The effect definition ID.
+     */
+    callOne(id: string): Promise<void>;
 }
 /**
  * Configuration options accepted by {@link createEffectsManager}.
@@ -1961,6 +1984,30 @@ interface ConstraintsManager<_S extends Schema> {
      * @param newDefs - New constraint definitions to merge into the manager.
      */
     registerDefinitions(newDefs: ConstraintsDef<Schema>): void;
+    /**
+     * Override an existing constraint definition.
+     * Stores the original in an internal map for inspection.
+     *
+     * @param id - The constraint definition ID to override.
+     * @param def - The new constraint definition.
+     * @throws If no constraint with this ID exists.
+     */
+    assignDefinition(id: string, def: ConstraintsDef<Schema>[string]): void;
+    /**
+     * Remove a constraint definition and all its internal state.
+     *
+     * @param id - The constraint definition ID to remove.
+     */
+    unregisterDefinition(id: string): void;
+    /**
+     * Evaluate a single constraint and emit its requirement if active.
+     * Props are merged into the requirement object.
+     *
+     * @param id - The constraint definition ID.
+     * @param props - Optional properties to merge into the requirement.
+     * @returns The emitted requirements (if any).
+     */
+    callOne(id: string, props?: Record<string, unknown>): Promise<RequirementWithId[]>;
 }
 /**
  * Configuration options accepted by {@link createConstraintsManager}.
@@ -2122,6 +2169,31 @@ interface ResolversManager<_S extends Schema> {
      * @param newDefs - New resolver definitions to merge into the manager.
      */
     registerDefinitions(newDefs: ResolversDef<Schema>): void;
+    /**
+     * Override an existing resolver definition.
+     *
+     * @param id - The resolver definition ID to override.
+     * @param def - The new resolver definition.
+     * @throws If no resolver with this ID exists.
+     */
+    assignDefinition(id: string, def: ResolversDef<Schema>[string]): void;
+    /**
+     * Remove a resolver definition. Cancels any inflight resolution.
+     *
+     * @param id - The resolver definition ID to remove.
+     */
+    unregisterDefinition(id: string): void;
+    /**
+     * Execute a resolver with a given requirement object.
+     *
+     * @param id - The resolver definition ID.
+     * @param requirement - The requirement to resolve.
+     */
+    callOne(id: string, requirement: Requirement): Promise<void>;
+    /**
+     * Clean up all internal state. Called on system destroy.
+     */
+    destroy(): void;
 }
 /**
  * Configuration options accepted by {@link createResolversManager}.
@@ -2270,6 +2342,10 @@ interface PluginManager<_S extends Schema = any> {
     emitTimeTravel(from: number, to: number): void;
     emitError(error: DirectiveError): void;
     emitErrorRecovery(error: DirectiveError, strategy: RecoveryStrategy): void;
+    emitDefinitionRegister(type: string, id: string, def: unknown): void;
+    emitDefinitionAssign(type: string, id: string, def: unknown, original: unknown): void;
+    emitDefinitionUnregister(type: string, id: string): void;
+    emitDefinitionCall(type: string, id: string, props?: unknown): void;
     emitRunComplete(run: RunChangelogEntry): void;
 }
 /**
@@ -2638,4 +2714,4 @@ declare const Backoff: {
     readonly Exponential: "exponential";
 };
 
-export { Backoff, BatchConfig, type Branded, type ChainableSchemaType, type ConstraintBuilderComplete, type ConstraintBuilderStart, type ConstraintBuilderWithWhen, ConstraintState, ConstraintsDef, CreateSystemOptionsNamed, CreateSystemOptionsSingle, CrossModuleConstraintsDef, CrossModuleDeps, CrossModuleDerivationsDef, CrossModuleEffectsDef, DebugConfig, type DerivationState, type DerivationsDef, DerivationsSchema, type DerivedValues, DirectiveError, EffectsDef, ErrorBoundaryConfig, ErrorSource, type ExtendedSchemaType, FactChange, Facts, FactsSnapshot, FactsStore, InferFacts, InferRequirements, type InflightInfo, type ModuleBuilder, type ModuleConfig, type ModuleConfigWithDeps, ModuleDef, ModuleHooks, ModuleSchema, ModulesMap, NamespacedSystem, type NamespacedSystemBuilder, type PendingRetry, Plugin, ReconcileResult, RecoveryStrategy, Requirement, RequirementKeyFn, RequirementOutput$1 as RequirementOutput, RequirementSet, type RequirementTypeStatus, RequirementWithId, ResolverContext, ResolverStatus, ResolversDef, RetryLaterConfig, RetryPolicy, RunChangelogEntry, Schema, SchemaType, SingleModuleSystem, type SingleModuleSystemBuilder, Snapshot, System, type SystemBuilderStart, SystemConfig, TimeTravelAPI, type TypedConstraint, TypedConstraintDef, TypedConstraintsDef, TypedDerivationsDef, TypedEventsDef, type TypedResolver, TypedResolversDef, type WhenBuilder, type WhenConstraint, constraint, constraintFactory, createConstraintsManager, createDerivationsManager, createDisabledTimeTravel, createEffectsManager, createEngine, createErrorBoundaryManager, createFacts, createFactsProxy, createFactsStore, createModule, createModuleFactory, createPluginManager, createRequirementStatusPlugin, createResolversManager, createRetryLaterManager, createStatusHook, createSystem, createSystemWithStatus, createTimeTravelManager, forType, generateRequirementId, getCurrentTracker, isRequirementType, isTracking, module$1 as module, req, resolverFactory, system, t, trackAccess, typedConstraint, typedResolver, when, withTracking, withoutTracking };
+export { Backoff, BatchConfig, type Branded, type ChainableSchemaType, ConstraintState, ConstraintsDef, CreateSystemOptionsNamed, CreateSystemOptionsSingle, CrossModuleConstraintsDef, CrossModuleDeps, CrossModuleDerivationsDef, CrossModuleEffectsDef, DebugConfig, type DerivationState, type DerivationsDef, DerivationsSchema, type DerivedValues, DirectiveError, EffectsDef, ErrorBoundaryConfig, ErrorSource, type ExtendedSchemaType, FactChange, Facts, FactsSnapshot, FactsStore, InferFacts, InferRequirements, type InflightInfo, type ModuleBuilder, type ModuleConfig, type ModuleConfigWithDeps, ModuleDef, ModuleHooks, ModuleSchema, ModulesMap, NamespacedSystem, type PendingRetry, Plugin, ReconcileResult, RecoveryStrategy, Requirement, RequirementKeyFn, RequirementOutput$1 as RequirementOutput, RequirementSet, type RequirementTypeStatus, RequirementWithId, ResolverContext, ResolverStatus, ResolversDef, RetryLaterConfig, RetryPolicy, RunChangelogEntry, Schema, SchemaType, SingleModuleSystem, Snapshot, System, SystemConfig, TimeTravelAPI, type TypedConstraint, TypedConstraintDef, TypedConstraintsDef, TypedDerivationsDef, TypedEventsDef, type TypedResolver, TypedResolversDef, type WhenConstraint, constraint, createConstraintFactory, createConstraintsManager, createDerivationsManager, createDisabledTimeTravel, createEffectsManager, createEngine, createErrorBoundaryManager, createFacts, createFactsProxy, createFactsStore, createModule, createModuleFactory, createPluginManager, createRequirementStatusPlugin, createResolverFactory, createResolversManager, createRetryLaterManager, createStatusHook, createSystem, createSystemWithStatus, createTimeTravelManager, forType, generateRequirementId, getCurrentTracker, isRequirementType, isTracking, module$1 as module, req, system, t, trackAccess, typedConstraint, typedResolver, when, withTracking, withoutTracking };