@directive-run/core 0.1.1

package/dist/plugins-CcwEXXMS.d.ts

@@ -0,0 +1,1876 @@
+/**
+ * Schema Types - Type definitions for fact schemas and consolidated module schemas
+ */
+/** Primitive type definitions for schema */
+interface SchemaType<T> {
+    readonly _type: T;
+    readonly _validators: Array<(value: any) => boolean>;
+    validate(fn: (value: T) => boolean): SchemaType<T>;
+}
+/**
+ * Schema definition mapping keys to types.
+ * Supports both:
+ * - Schema builders: `{ count: t.number() }`
+ * - Type assertions: `{} as { count: number }`
+ */
+type Schema = Record<string, SchemaType<unknown> | unknown>;
+/**
+ * Infer a single type from a SchemaType, Zod schema, or plain type.
+ * - If it has `_type` (our SchemaType), extract it
+ * - If it has `_output` (Zod schema), extract it
+ * - Otherwise use the type directly (type assertion)
+ */
+type InferSchemaType<T> = T extends SchemaType<infer U> ? U : T extends {
+    _output: infer Z;
+} ? Z : T;
+/** Extract the TypeScript type from a schema (removes readonly from const type params) */
+type InferSchema<S extends Schema> = {
+    -readonly [K in keyof S]: InferSchemaType<S[K]>;
+};
+/**
+ * Event payload schema - maps property names to their types.
+ * Empty object `{}` means no payload.
+ * Supports both `t.*()` builders and plain types.
+ */
+type EventPayloadSchema = Record<string, SchemaType<unknown> | unknown>;
+/**
+ * Events schema - maps event names to their payload schemas.
+ * Supports type assertion: `{} as { eventName: { prop: Type } }`
+ */
+type EventsSchema = Record<string, EventPayloadSchema>;
+/**
+ * Derivations schema - maps derivation names to their return types.
+ * Supports both:
+ * - `{ doubled: t.number() }`
+ * - `{} as { doubled: number }`
+ */
+type DerivationsSchema = Record<string, SchemaType<unknown> | unknown>;
+/**
+ * Requirement payload schema - maps property names to their types.
+ * Supports both `t.*()` builders and plain types.
+ */
+type RequirementPayloadSchema$1 = Record<string, SchemaType<unknown> | unknown>;
+/**
+ * Requirements schema - maps requirement type names to their payload schemas.
+ * Supports type assertion: `{} as { REQ_NAME: { prop: Type } }`
+ */
+type RequirementsSchema$1 = Record<string, RequirementPayloadSchema$1>;
+/**
+ * Consolidated module schema - single source of truth for all types.
+ *
+ * Only `facts` is required. Other sections default to empty:
+ * - `derivations` - Omit if no computed values
+ * - `events` - Omit if no event handlers
+ * - `requirements` - Omit if no constraints/resolvers
+ *
+ * Supports two patterns for defining types:
+ *
+ * @example
+ * ```typescript
+ * // Pattern 1: Schema builders (with optional runtime validation)
+ * createModule("counter", {
+ *   schema: {
+ *     facts: { count: t.number(), phase: t.string<"a" | "b">() },
+ *     derivations: { doubled: t.number() },
+ *     events: { increment: {}, setPhase: { phase: t.string<"a" | "b">() } },
+ *     requirements: { FETCH: { id: t.string() } },
+ *   },
+ *   // ...
+ * });
+ *
+ * // Pattern 2: Type assertions (type-only, no validation)
+ * createModule("counter", {
+ *   schema: {
+ *     facts: {} as { count: number; phase: "a" | "b" },
+ *     derivations: {} as { doubled: number },
+ *     events: {} as { increment: {}; setPhase: { phase: "a" | "b" } },
+ *     requirements: {} as { FETCH: { id: string } },
+ *   },
+ *   // ...
+ * });
+ * ```
+ */
+interface ModuleSchema {
+    /** Facts (state) schema - required */
+    facts: Schema;
+    /** Derivation return types - optional, defaults to {} */
+    derivations?: DerivationsSchema;
+    /** Event payload schemas - optional, defaults to {} */
+    events?: EventsSchema;
+    /** Requirement payload schemas - optional, defaults to {} */
+    requirements?: RequirementsSchema$1;
+}
+/** Helper to get derivations, defaulting to empty */
+type GetDerivations<M extends ModuleSchema> = M["derivations"] extends DerivationsSchema ? M["derivations"] : Record<string, never>;
+/** Helper to get events, defaulting to empty */
+type GetEvents<M extends ModuleSchema> = M["events"] extends EventsSchema ? M["events"] : Record<string, never>;
+/** Helper to get requirements, defaulting to empty */
+type GetRequirements<M extends ModuleSchema> = M["requirements"] extends RequirementsSchema$1 ? M["requirements"] : Record<string, never>;
+/**
+ * Infer the facts type from a module schema.
+ */
+type InferFacts<M extends ModuleSchema> = InferSchema<M["facts"]>;
+/**
+ * Infer derivation values from a module schema.
+ * Each key maps to the return type declared in schema.derivations.
+ */
+type InferDerivations<M extends ModuleSchema> = {
+    readonly [K in keyof GetDerivations<M>]: InferSchemaType<GetDerivations<M>[K]>;
+};
+/** Combined facts + derivations — matches the useSelector proxy at runtime. */
+type InferSelectorState<M extends ModuleSchema> = InferFacts<M> & InferDerivations<M>;
+/**
+ * Infer event payload type from an event payload schema.
+ */
+type InferEventPayloadFromSchema<P extends EventPayloadSchema> = {
+    [K in keyof P]: InferSchemaType<P[K]>;
+};
+/**
+ * Infer all events from a module schema as a discriminated union.
+ */
+type InferEvents<M extends ModuleSchema> = {
+    [K in keyof GetEvents<M>]: keyof GetEvents<M>[K] extends never ? {
+        type: K;
+    } : {
+        type: K;
+    } & InferEventPayloadFromSchema<GetEvents<M>[K]>;
+}[keyof GetEvents<M>];
+/**
+ * Infer requirement payload type from a requirement payload schema.
+ */
+type InferRequirementPayloadFromSchema<P extends RequirementPayloadSchema$1> = {
+    [K in keyof P]: InferSchemaType<P[K]>;
+};
+/**
+ * Infer all requirements from a module schema as a discriminated union.
+ */
+type InferRequirements<M extends ModuleSchema> = {
+    [K in keyof GetRequirements<M>]: {
+        type: K;
+    } & InferRequirementPayloadFromSchema<GetRequirements<M>[K]>;
+}[keyof GetRequirements<M>];
+/**
+ * Infer requirement type names from a module schema.
+ */
+type InferRequirementTypes<M extends ModuleSchema> = keyof GetRequirements<M> & string;
+
+/**
+ * Facts Types - Type definitions for facts store and accessor
+ */
+
+/** Read-only snapshot of facts */
+interface FactsSnapshot<S extends Schema = Schema> {
+    get<K extends keyof InferSchema<S>>(key: K): InferSchema<S>[K] | undefined;
+    has(key: keyof InferSchema<S>): boolean;
+}
+/** Mutable facts store */
+interface FactsStore<S extends Schema = Schema> extends FactsSnapshot<S> {
+    set<K extends keyof InferSchema<S>>(key: K, value: InferSchema<S>[K]): void;
+    delete(key: keyof InferSchema<S>): void;
+    batch(fn: () => void): void;
+    subscribe(keys: Array<keyof InferSchema<S>>, listener: () => void): () => void;
+    subscribeAll(listener: () => void): () => void;
+    /** Get all facts as a plain object (for serialization/time-travel) */
+    toObject(): Record<string, unknown>;
+}
+/** Proxy-based facts accessor (cleaner API) */
+type Facts<S extends Schema = Schema> = InferSchema<S> & {
+    readonly $store: FactsStore<S>;
+    readonly $snapshot: () => FactsSnapshot<S>;
+};
+/** Fact change record */
+interface FactChange {
+    key: string;
+    value: unknown;
+    prev: unknown;
+    type: "set" | "delete";
+}
+
+/**
+ * Requirement Types - Type definitions for requirements and constraints
+ */
+
+/** Base requirement structure */
+interface Requirement {
+    readonly type: string;
+    readonly [key: string]: unknown;
+}
+/** Requirement with computed identity */
+interface RequirementWithId {
+    readonly requirement: Requirement;
+    readonly id: string;
+    readonly fromConstraint: string;
+}
+/** Requirement key function for custom deduplication */
+type RequirementKeyFn<R extends Requirement = Requirement> = (req: R) => string;
+/**
+ * Requirement payload schema - maps property names to their types.
+ */
+type RequirementPayloadSchema = Record<string, SchemaType<unknown>>;
+/**
+ * Requirements schema definition - maps requirement type names to their payload schemas.
+ *
+ * @example
+ * ```typescript
+ * const module = createModule("inventory", {
+ *   requirements: {
+ *     RESTOCK: { sku: t.string(), quantity: t.number() },
+ *     ALERT: { message: t.string() },
+ *   },
+ * });
+ * ```
+ */
+type RequirementsSchema = Record<string, RequirementPayloadSchema>;
+/**
+ * Requirement output from a constraint - can be single, array, or null.
+ * - Single requirement: `{ type: "RESTOCK", sku: "ABC" }`
+ * - Multiple requirements: `[{ type: "RESTOCK", sku: "ABC" }, { type: "NOTIFY", message: "Low stock" }]`
+ * - No requirements: `null` or `[]`
+ */
+type RequirementOutput$1<R extends Requirement = Requirement> = R | R[] | null;
+/** Constraint definition */
+interface ConstraintDef<S extends Schema, R extends Requirement = Requirement> {
+    /** Priority for ordering (higher runs first) */
+    priority?: number;
+    /** Mark this constraint as async (avoids runtime detection) */
+    async?: boolean;
+    /** Condition function (sync or async) */
+    when: (facts: Facts<S>) => boolean | Promise<boolean>;
+    /**
+     * Requirement(s) to produce when condition is met.
+     * - Single requirement: `{ type: "RESTOCK", sku: "ABC" }`
+     * - Multiple requirements: `[{ type: "RESTOCK", sku: "ABC" }, { type: "NOTIFY", message: "Low" }]`
+     * - Function returning requirements: `(facts) => ({ type: "RESTOCK", sku: facts.sku })`
+     * - Function returning null/empty array for conditional no-op: `(facts) => facts.critical ? [...] : null`
+     */
+    require: RequirementOutput$1<R> | ((facts: Facts<S>) => RequirementOutput$1<R>);
+    /** Timeout for async constraints (ms) */
+    timeout?: number;
+    /**
+     * Constraint IDs whose resolvers must complete before this constraint is evaluated.
+     * If a dependency's `when()` returns false (no requirements), this constraint proceeds.
+     * If a dependency's resolver fails, this constraint remains blocked.
+     * Cross-module: use "moduleName.constraintName" format.
+     */
+    after?: string[];
+    /**
+     * Explicit fact dependencies for this constraint.
+     * Required for async constraints to enable dependency tracking (auto-tracking
+     * cannot work across async boundaries). Also works for sync constraints to
+     * bypass auto-tracking overhead.
+     */
+    deps?: string[];
+}
+/** Map of constraint definitions (generic) */
+type ConstraintsDef<S extends Schema> = Record<string, ConstraintDef<S, Requirement>>;
+/** Internal constraint state */
+interface ConstraintState {
+    id: string;
+    priority: number;
+    isAsync: boolean;
+    lastResult: boolean | null;
+    isEvaluating: boolean;
+    error: Error | null;
+    /** Timestamp when this constraint's resolver(s) last completed successfully */
+    lastResolvedAt: number | null;
+    /** Constraint IDs this constraint is waiting on (from `after` property) */
+    after: string[];
+}
+
+/**
+ * Effect Types - Type definitions for effects
+ */
+
+/**
+ * A cleanup function returned by an effect's `run()`.
+ * Called before the effect re-runs (when deps change) or when the system stops/destroys.
+ * Use for teardown: closing WebSocket connections, clearing intervals, removing DOM listeners, etc.
+ */
+type EffectCleanup = () => void;
+/**
+ * Effect definition - side effects with optional cleanup.
+ *
+ * ## Effects vs Constraints
+ *
+ * Use **Effects** for:
+ * - Logging and analytics
+ * - DOM manipulation (scrolling, focus)
+ * - External notifications (toasts, alerts)
+ * - Syncing to localStorage/sessionStorage
+ * - WebSocket connections, intervals, DOM listeners (return cleanup)
+ * - Any side effect that doesn't need tracking or retry
+ *
+ * Use **Constraints** for:
+ * - Data fetching (API calls)
+ * - Async operations that may fail and need retry
+ * - Operations that produce requirements to be resolved
+ * - Anything that needs cancellation support
+ * - Operations where you need to know completion status
+ *
+ * Key differences:
+ * - Effects run and are forgotten - no retry, no cancellation, no status tracking
+ * - Constraints produce requirements that resolvers fulfill with full lifecycle management
+ * - Effects are synchronous in the reconciliation loop
+ * - Constraints/resolvers can be async with timeout, retry, and batching
+ *
+ * ## Cleanup
+ *
+ * Return a cleanup function from `run()` to tear down resources:
+ *
+ * @example
+ * ```typescript
+ * effects: {
+ *   websocket: {
+ *     deps: ["userId"],
+ *     run: (facts) => {
+ *       const ws = new WebSocket(`/ws/${facts.userId}`);
+ *       return () => ws.close(); // Cleanup when userId changes or system stops
+ *     },
+ *   },
+ *   interval: {
+ *     run: (facts) => {
+ *       const id = setInterval(() => sync(facts), 5000);
+ *       return () => clearInterval(id);
+ *     },
+ *   },
+ * }
+ * ```
+ */
+interface EffectDef<S extends Schema> {
+    run(facts: Facts<S>, prev: FactsSnapshot<S> | null): void | EffectCleanup | Promise<void | EffectCleanup>;
+    /** Optional explicit dependencies for optimization */
+    deps?: Array<keyof InferSchema<S>>;
+}
+/** Map of effect definitions */
+type EffectsDef<S extends Schema> = Record<string, EffectDef<S>>;
+
+/**
+ * Event Types - Type definitions for events and event handlers
+ */
+
+/** Helper to get events schema, defaulting to empty */
+type GetEventsSchema$1<M extends ModuleSchema> = M["events"] extends EventsSchema ? M["events"] : Record<string, never>;
+/**
+ * Events accessor type from a module schema.
+ * Provides typed dispatch functions for each event.
+ *
+ * @example
+ * ```typescript
+ * type Accessor = EventsAccessorFromSchema<MySchema>;
+ * // {
+ * //   increment: () => void;
+ * //   setPhase: (payload: { phase: "red" | "green" }) => void;
+ * // }
+ * ```
+ */
+type EventsAccessorFromSchema<M extends ModuleSchema> = {
+    readonly [K in keyof GetEventsSchema$1<M>]: keyof GetEventsSchema$1<M>[K] extends never ? () => void : (payload: InferEventPayloadFromSchema<GetEventsSchema$1<M>[K]>) => void;
+};
+/**
+ * Dispatch events union type from a module schema.
+ * Used for system.dispatch() type.
+ */
+type DispatchEventsFromSchema<M extends ModuleSchema> = InferEvents<M>;
+/** System event */
+interface SystemEvent {
+    type: string;
+    [key: string]: unknown;
+}
+/**
+ * Flexible event handler that accepts either:
+ * - Simple handler: `(facts) => void`
+ * - Typed payload handler: `(facts, { field }: { field: Type }) => void`
+ * - Generic handler: `(facts, event: SystemEvent) => void`
+ */
+type FlexibleEventHandler<S extends Schema> = (facts: Facts<S>, event?: any) => void;
+/** Events definition - accepts any event handler signature */
+type EventsDef<S extends Schema> = Record<string, FlexibleEventHandler<S>>;
+
+/**
+ * Resolver Types - Type definitions for resolvers
+ */
+
+/** Retry policy configuration */
+interface RetryPolicy$1 {
+    /** Maximum number of attempts */
+    attempts: number;
+    /** Backoff strategy */
+    backoff: "none" | "linear" | "exponential";
+    /** Initial delay in ms */
+    initialDelay?: number;
+    /** Maximum delay in ms */
+    maxDelay?: number;
+    /**
+     * Optional predicate to decide whether to retry after an error.
+     * Return `true` to retry, `false` to stop immediately.
+     * If omitted, all errors are retried (up to `attempts`).
+     *
+     * @param error - The error that occurred
+     * @param attempt - The attempt number that just failed (1-based)
+     */
+    shouldRetry?: (error: Error, attempt: number) => boolean;
+}
+/** Batch configuration */
+interface BatchConfig {
+    /** Enable batching */
+    enabled: boolean;
+    /** Time window to collect requirements (ms) */
+    windowMs: number;
+    /** Maximum batch size (default: unlimited) */
+    maxSize?: number;
+    /** Per-batch timeout in ms (overrides resolver timeout for batches) */
+    timeoutMs?: number;
+    /**
+     * Failure strategy for partial batch failures:
+     * - "all-or-nothing" (default): If resolveBatch throws, all requirements fail
+     * - "per-item": Use resolveBatchWithResults to get per-item results
+     */
+    failureStrategy?: "all-or-nothing" | "per-item";
+}
+/**
+ * Result for a single item in a batch resolution.
+ */
+interface BatchItemResult<T = unknown> {
+    /** Whether this item succeeded */
+    success: boolean;
+    /** Error if the item failed */
+    error?: Error;
+    /** Optional result value if the item succeeded */
+    value?: T;
+}
+/**
+ * Results from batch resolution with per-item status.
+ * The array order must match the order of requirements passed in.
+ */
+type BatchResolveResults<T = unknown> = Array<BatchItemResult<T>>;
+/** Resolver context passed to resolve function */
+interface ResolverContext<S extends Schema = Schema> {
+    readonly facts: Facts<S>;
+    readonly signal: AbortSignal;
+    readonly snapshot: () => FactsSnapshot<S>;
+}
+/** Single resolver definition (untyped - use TypedResolversDef for type safety) */
+interface ResolverDef<S extends Schema, R extends Requirement = Requirement> {
+    /**
+     * Requirement type to handle.
+     * - String: matches `req.type` directly (e.g., `requirement: "FETCH_USER"`)
+     * - Function: type guard predicate (e.g., `requirement: (req) => req.type === "FETCH_USER"`)
+     */
+    requirement: string | ((req: Requirement) => req is R);
+    /** Custom key function for deduplication */
+    key?: RequirementKeyFn<R>;
+    /** Retry policy */
+    retry?: RetryPolicy$1;
+    /** Timeout for resolver execution (ms) */
+    timeout?: number;
+    /** Batch configuration (mutually exclusive with regular resolve) */
+    batch?: BatchConfig;
+    /** Resolve function for single requirement */
+    resolve?: (req: R, ctx: ResolverContext<S>) => Promise<void>;
+    /**
+     * Resolve function for batched requirements (all-or-nothing).
+     * If this throws, all requirements in the batch fail.
+     */
+    resolveBatch?: (reqs: R[], ctx: ResolverContext<S>) => Promise<void>;
+    /**
+     * Resolve function for batched requirements with per-item results.
+     * Use this when you need to handle partial failures.
+     * The returned array must match the order of input requirements.
+     *
+     * @example
+     * ```typescript
+     * resolveBatchWithResults: async (reqs, ctx) => {
+     *   return Promise.all(reqs.map(async (req) => {
+     *     try {
+     *       await processItem(req);
+     *       return { success: true };
+     *     } catch (error) {
+     *       return { success: false, error };
+     *     }
+     *   }));
+     * }
+     * ```
+     */
+    resolveBatchWithResults?: (reqs: R[], ctx: ResolverContext<S>) => Promise<BatchResolveResults>;
+}
+/** Map of resolver definitions */
+type ResolversDef<S extends Schema> = Record<string, ResolverDef<S, Requirement>>;
+/** Resolver status */
+type ResolverStatus = {
+    state: "idle";
+} | {
+    state: "pending";
+    requirementId: string;
+    startedAt: number;
+} | {
+    state: "running";
+    requirementId: string;
+    startedAt: number;
+    attempt: number;
+} | {
+    state: "success";
+    requirementId: string;
+    completedAt: number;
+    duration: number;
+} | {
+    state: "error";
+    requirementId: string;
+    error: Error;
+    failedAt: number;
+    attempts: number;
+} | {
+    state: "canceled";
+    requirementId: string;
+    canceledAt: number;
+};
+
+/**
+ * Error Types - Type definitions for error handling
+ */
+/** Error source types */
+type ErrorSource = "constraint" | "resolver" | "effect" | "derivation" | "system";
+/**
+ * Extended Error class with source tracking, recovery metadata, and
+ * arbitrary context for structured error handling within Directive.
+ *
+ * Thrown or returned by the error boundary manager. The `source` and
+ * `sourceId` fields identify where the error originated, and `recoverable`
+ * indicates whether the engine can apply a recovery strategy.
+ *
+ * @param message - Human-readable error description
+ * @param source - Which subsystem produced the error (`"constraint"`, `"resolver"`, `"effect"`, `"derivation"`, or `"system"`)
+ * @param sourceId - The ID of the specific constraint, resolver, effect, or derivation that failed
+ * @param context - Optional arbitrary data for debugging (e.g., the requirement that triggered a resolver error)
+ * @param recoverable - Whether the error boundary can apply a recovery strategy (default `true`; `false` for system errors)
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await system.settle();
+ * } catch (err) {
+ *   if (err instanceof DirectiveError) {
+ *     console.log(err.source);      // "resolver"
+ *     console.log(err.sourceId);    // "fetchUser"
+ *     console.log(err.recoverable); // true
+ *   }
+ * }
+ * ```
+ */
+declare class DirectiveError extends Error {
+    readonly source: ErrorSource;
+    readonly sourceId: string;
+    readonly context?: unknown | undefined;
+    readonly recoverable: boolean;
+    constructor(message: string, source: ErrorSource, sourceId: string, context?: unknown | undefined, recoverable?: boolean);
+}
+/** Recovery strategy for errors */
+type RecoveryStrategy = "skip" | "retry" | "retry-later" | "disable" | "throw";
+/**
+ * Configuration for retry-later strategy.
+ * When an error occurs, the system will wait for `delayMs` before retrying.
+ */
+interface RetryLaterConfig {
+    /** Delay in milliseconds before retrying (default: 1000) */
+    delayMs?: number;
+    /** Maximum retries before giving up (default: 3) */
+    maxRetries?: number;
+    /** Backoff multiplier for each retry (default: 2) */
+    backoffMultiplier?: number;
+    /** Maximum delay in milliseconds (default: 30000) */
+    maxDelayMs?: number;
+}
+/**
+ * Circuit breaker configuration for automatic failure protection.
+ * After `failureThreshold` consecutive failures, the circuit opens
+ * and all requests fail fast for `resetTimeoutMs`.
+ */
+interface CircuitBreakerConfig {
+    /** Number of consecutive failures before opening the circuit (default: 5) */
+    failureThreshold?: number;
+    /** Time in milliseconds before attempting to close the circuit (default: 60000) */
+    resetTimeoutMs?: number;
+    /** Number of successful requests needed to close a half-open circuit (default: 1) */
+    successThreshold?: number;
+}
+/** Circuit breaker state */
+type CircuitBreakerState = "closed" | "open" | "half-open";
+/** Error boundary configuration */
+interface ErrorBoundaryConfig {
+    onConstraintError?: RecoveryStrategy | ((error: Error, constraint: string) => void);
+    onResolverError?: RecoveryStrategy | ((error: Error, resolver: string) => void);
+    onEffectError?: RecoveryStrategy | ((error: Error, effect: string) => void);
+    onDerivationError?: RecoveryStrategy | ((error: Error, derivation: string) => void);
+    onError?: (error: DirectiveError) => void;
+    /** Configuration for retry-later strategy */
+    retryLater?: RetryLaterConfig;
+    /** Circuit breaker configuration (applies to resolvers only) */
+    circuitBreaker?: CircuitBreakerConfig;
+}
+
+/**
+ * Composition Types - Type definitions for single and multi-module systems
+ *
+ * Single module = direct access (no namespace):
+ * @example
+ * ```typescript
+ * const system = createSystem({ modules: counterModule });
+ * system.facts.count           // Direct access
+ * system.events.increment()    // Direct events
+ * ```
+ *
+ * Multiple modules = namespaced access:
+ * @example
+ * ```typescript
+ * const system = createSystem({
+ *   modules: { auth: authModule, data: dataModule },
+ * });
+ * system.facts.auth.token       // Namespaced access
+ * system.derive.data.userCount  // Namespaced derivations
+ * system.events.auth.login()    // Namespaced events
+ * ```
+ */
+
+/**
+ * Extract the schema type from a module definition.
+ */
+type ExtractSchema<M> = M extends ModuleDef<infer S> ? S : never;
+/**
+ * Map of module name to module definition (object form).
+ *
+ * Uses `ModuleDef<any>` instead of `ModuleDef<ModuleSchema>` to preserve
+ * specific schema types during inference. The actual schema types are
+ * extracted via `ExtractSchema<M>` where needed.
+ */
+type ModulesMap = Record<string, ModuleDef<any>>;
+/**
+ * Map of namespace to schema for cross-module dependencies.
+ * Used in module config to declare type-safe access to other modules' facts.
+ */
+type CrossModuleDeps = Record<string, ModuleSchema>;
+/**
+ * Cross-module facts type using "self" for own module.
+ * Own module accessed via `facts.self.*`, dependencies via `facts.{dep}.*`.
+ *
+ * @example
+ * ```typescript
+ * // For a "data" module with crossModuleDeps: { auth: authSchema }
+ * facts.self.users           // ✅ own module via "self"
+ * facts.auth.isAuthenticated // ✅ cross-module via namespace
+ * ```
+ */
+type CrossModuleFactsWithSelf<OwnSchema extends ModuleSchema, Deps extends CrossModuleDeps> = {
+    self: InferFacts<OwnSchema>;
+} & {
+    [K in keyof Deps]: InferFacts<Deps[K]>;
+};
+/**
+ * Namespace facts under module keys.
+ * `facts.auth.token` instead of `facts.auth_token`
+ */
+type NamespacedFacts<Modules extends ModulesMap> = {
+    readonly [K in keyof Modules]: InferFacts<ExtractSchema<Modules[K]>>;
+};
+/**
+ * Mutable version for constraint/resolver callbacks.
+ */
+type MutableNamespacedFacts<Modules extends ModulesMap> = {
+    [K in keyof Modules]: InferFacts<ExtractSchema<Modules[K]>>;
+};
+/**
+ * Namespace derivations under module keys.
+ * `derive.auth.status` instead of `derive.auth_status`
+ */
+type NamespacedDerivations<Modules extends ModulesMap> = {
+    readonly [K in keyof Modules]: InferDerivations<ExtractSchema<Modules[K]>>;
+};
+/**
+ * Union of all module events (not namespaced).
+ * Events stay as discriminated union for dispatch.
+ */
+type UnionEvents<Modules extends ModulesMap> = {
+    [K in keyof Modules]: InferEvents<ExtractSchema<Modules[K]>>;
+}[keyof Modules];
+/**
+ * Options for createSystem with object modules (namespaced mode).
+ */
+interface CreateSystemOptionsNamed<Modules extends ModulesMap> {
+    /** Modules as object = namespaced access */
+    modules: Modules;
+    /** Plugins to register */
+    plugins?: Array<Plugin<ModuleSchema>>;
+    /** Debug configuration */
+    debug?: DebugConfig;
+    /** Error boundary configuration */
+    errorBoundary?: ErrorBoundaryConfig;
+    /**
+     * Tick interval for time-based systems (ms).
+     */
+    tickMs?: number;
+    /**
+     * Enable zero-config mode with sensible defaults.
+     */
+    zeroConfig?: boolean;
+    /**
+     * Initial facts to set after module init (namespaced format).
+     * Applied after all module `init()` functions but before reconciliation.
+     *
+     * @example
+     * ```typescript
+     * createSystem({
+     *   modules: { auth, data },
+     *   initialFacts: {
+     *     auth: { token: "restored-token", user: cachedUser },
+     *     data: { users: preloadedUsers },
+     *   },
+     * });
+     * ```
+     */
+    initialFacts?: Partial<{
+        [K in keyof Modules]: Partial<InferFacts<ExtractSchema<Modules[K]>>>;
+    }>;
+    /**
+     * Init order strategy:
+     * - "auto" (default): Sort by crossModuleDeps topology
+     * - "declaration": Use object key order (current behavior)
+     * - string[]: Explicit order by namespace
+     */
+    initOrder?: "auto" | "declaration" | Array<keyof Modules & string>;
+}
+/**
+ * System interface for namespaced modules.
+ * Facts and derivations are accessed via module namespaces.
+ */
+interface NamespacedSystem<Modules extends ModulesMap> {
+    /** System mode discriminator for type guards */
+    readonly _mode: "namespaced";
+    /** Namespaced facts accessor: system.facts.auth.token */
+    readonly facts: MutableNamespacedFacts<Modules>;
+    /** Time-travel debugging API (if enabled) */
+    readonly debug: TimeTravelAPI | null;
+    /** Namespaced derivations accessor: system.derive.auth.status */
+    readonly derive: NamespacedDerivations<Modules>;
+    /** Events accessor (union of all module events) */
+    readonly events: NamespacedEventsAccessor<Modules>;
+    /** Start the system (initialize modules, begin reconciliation) */
+    start(): void;
+    /** Stop the system (cancel resolvers, stop reconciliation) */
+    stop(): void;
+    /** Destroy the system (stop and cleanup) */
+    destroy(): void;
+    /** Whether the system is currently running */
+    readonly isRunning: boolean;
+    /** Whether all resolvers have completed */
+    readonly isSettled: boolean;
+    /** Whether all modules have completed initialization */
+    readonly isInitialized: boolean;
+    /** Whether system has completed first reconciliation */
+    readonly isReady: boolean;
+    /** Wait for system to be fully ready (after first reconciliation) */
+    whenReady(): Promise<void>;
+    /**
+     * Hydrate facts from async source (call before start).
+     * Useful for restoring state from localStorage, API, etc.
+     *
+     * @example
+     * ```typescript
+     * const system = createSystem({ modules: { auth, data } });
+     * await system.hydrate(async () => {
+     *   const stored = localStorage.getItem("app-state");
+     *   return stored ? JSON.parse(stored) : {};
+     * });
+     * system.start();
+     * ```
+     */
+    hydrate(loader: () => Promise<Partial<{
+        [K in keyof Modules]: Partial<InferFacts<ExtractSchema<Modules[K]>>>;
+    }>> | Partial<{
+        [K in keyof Modules]: Partial<InferFacts<ExtractSchema<Modules[K]>>>;
+    }>): Promise<void>;
+    /** Dispatch an event (union of all module events) */
+    dispatch(event: UnionEvents<Modules>): void;
+    /** Batch multiple fact changes */
+    batch(fn: () => void): void;
+    /**
+     * Subscribe to settlement state changes.
+     * Called whenever the system's settled state may have changed
+     * (resolver starts/completes, reconcile starts/ends).
+     */
+    onSettledChange(listener: () => void): () => void;
+    /** Subscribe to time-travel state changes (snapshot taken, navigation). */
+    onTimeTravelChange(listener: () => void): () => void;
+    /**
+     * Read a derivation value by namespaced key.
+     * Accepts "namespace.key" format (e.g., "auth.status").
+     *
+     * @example
+     * system.read("auth.status")  // → "authenticated"
+     * system.read("data.count")   // → 5
+     */
+    read<T = unknown>(derivationId: string): T;
+    /**
+     * Subscribe to fact or derivation changes using namespaced keys.
+     * Keys are auto-detected — pass any mix of fact keys and derivation keys.
+     * Accepts "namespace.key" format (e.g., "auth.status", "auth.token").
+     * Supports wildcard "namespace.*" to subscribe to all keys in a module.
+     *
+     * @example
+     * system.subscribe(["auth.token", "data.count"], () => {
+     *   console.log("Auth or data changed");
+     * });
+     *
+     * @example Wildcard
+     * system.subscribe(["game.*"], () => render());
+     */
+    subscribe(ids: string[], listener: () => void): () => void;
+    /**
+     * Subscribe to ALL fact and derivation changes in a module namespace.
+     * Shorthand for subscribing to every key in a module.
+     *
+     * @example
+     * system.subscribeModule("game", () => render());
+     * system.subscribeModule("chat", () => render());
+     */
+    subscribeModule(namespace: keyof Modules & string, listener: () => void): () => void;
+    /**
+     * Watch a fact or derivation for changes using namespaced key.
+     * The key is auto-detected -- works with both fact keys and derivation keys.
+     * Accepts "namespace.key" format (e.g., "auth.status", "auth.token").
+     * Pass `options.equalityFn` for custom comparison (e.g., shallow equality for objects).
+     *
+     * @example
+     * system.watch("auth.token", (newVal, oldVal) => {
+     *   console.log(`Token changed from ${oldVal} to ${newVal}`);
+     * });
+     */
+    watch<T = unknown>(id: string, callback: (newValue: T, previousValue: T | undefined) => void, options?: {
+        equalityFn?: (a: T, b: T | undefined) => boolean;
+    }): () => void;
+    /**
+     * Returns a promise that resolves when the predicate becomes true.
+     * The predicate is evaluated against current facts and re-evaluated on every change.
+     * Uses namespaced facts: `facts.auth.token`, `facts.data.count`, etc.
+     * Optionally pass a timeout in ms -- rejects with an error if exceeded.
+     *
+     * @example
+     * await system.when((facts) => facts.auth.token !== null);
+     * await system.when((facts) => facts.auth.token !== null, { timeout: 5000 });
+     */
+    when(predicate: (facts: Readonly<MutableNamespacedFacts<Modules>>) => boolean, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    /** Inspect system state */
+    inspect(): SystemInspection;
+    /** Wait for system to settle (all resolvers complete) */
+    settle(maxWait?: number): Promise<void>;
+    /** Explain why a requirement exists */
+    explain(requirementId: string): string | null;
+    /** Get serializable snapshot of system state */
+    getSnapshot(): SystemSnapshot;
+    /** Restore system state from snapshot */
+    restore(snapshot: SystemSnapshot): void;
+    /**
+     * Register a new module into a running system.
+     * The module is initialized, wired into constraint/resolver/derivation graphs,
+     * and reconciliation is triggered.
+     *
+     * @example
+     * ```typescript
+     * // Lazy-load a module
+     * const chatModule = await import('./modules/chat');
+     * system.registerModule("chat", chatModule.default);
+     * ```
+     */
+    registerModule<S extends ModuleSchema>(namespace: string, moduleDef: ModuleDef<S>): void;
+    /**
+     * Get a distributable snapshot of computed derivations.
+     * Use "namespace.key" format for derivation keys.
+     *
+     * @example
+     * ```typescript
+     * const snapshot = system.getDistributableSnapshot({
+     *   includeDerivations: ['auth.effectivePlan', 'auth.canUseFeature'],
+     *   ttlSeconds: 3600,
+     * });
+     * await redis.setex(`entitlements:${userId}`, 3600, JSON.stringify(snapshot));
+     * ```
+     */
+    getDistributableSnapshot<T = Record<string, unknown>>(options?: DistributableSnapshotOptions): DistributableSnapshot<T>;
+    /**
+     * Watch for changes to distributable snapshot derivations.
+     * Calls the callback whenever any of the included derivations change.
+     * Use "namespace.key" format for derivation keys.
+     * Returns an unsubscribe function.
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = system.watchDistributableSnapshot(
+     *   { includeDerivations: ['auth.effectivePlan', 'auth.canUseFeature'] },
+     *   (snapshot) => {
+     *     await redis.setex(`entitlements:${userId}`, 3600, JSON.stringify(snapshot));
+     *   }
+     * );
+     * ```
+     */
+    watchDistributableSnapshot<T = Record<string, unknown>>(options: DistributableSnapshotOptions, callback: (snapshot: DistributableSnapshot<T>) => void): () => void;
+}
+/**
+ * Events accessor that groups event dispatchers by module namespace.
+ */
+type NamespacedEventsAccessor<Modules extends ModulesMap> = {
+    readonly [K in keyof Modules]: EventsDispatcherForModule<Modules[K]>;
+};
+/**
+ * Event dispatcher functions for a single module.
+ */
+type EventsDispatcherForModule<M> = M extends ModuleDef<infer S> ? S extends ModuleSchema ? S["events"] extends Record<string, unknown> ? {
+    [E in keyof S["events"]]: S["events"][E] extends Record<string, unknown> ? keyof S["events"][E] extends never ? () => void : (payload: InferEventPayload<S["events"][E]>) => void : () => void;
+} : Record<string, never> : Record<string, never> : Record<string, never>;
+/**
+ * Infer event payload from event schema.
+ */
+type InferEventPayload<E> = E extends Record<string, unknown> ? {
+    [K in keyof E]: E[K] extends {
+        _type: infer T;
+    } ? T : E[K];
+} : never;
+/**
+ * Options for createSystem with a single module (no namespacing).
+ */
+interface CreateSystemOptionsSingle<S extends ModuleSchema> {
+    /** Single module = direct access (use `modules` for multiple) */
+    module: ModuleDef<S>;
+    /** Plugins to register */
+    plugins?: Array<Plugin<ModuleSchema>>;
+    /** Debug configuration */
+    debug?: DebugConfig;
+    /** Error boundary configuration */
+    errorBoundary?: ErrorBoundaryConfig;
+    /** Tick interval for time-based systems (ms) */
+    tickMs?: number;
+    /** Enable zero-config mode with sensible defaults */
+    zeroConfig?: boolean;
+    /**
+     * Initial facts to set after module init.
+     * Applied after module `init()` but before reconciliation.
+     */
+    initialFacts?: Partial<InferFacts<S>>;
+}
+/**
+ * System interface for a single module (no namespace).
+ * Facts, derivations, and events are accessed directly.
+ */
+interface SingleModuleSystem<S extends ModuleSchema> {
+    /** System mode discriminator for type guards */
+    readonly _mode: "single";
+    /** Direct facts accessor: system.facts.count */
+    readonly facts: Facts<S["facts"]>;
+    /** Time-travel debugging API (if enabled) */
+    readonly debug: TimeTravelAPI | null;
+    /** Direct derivations accessor: system.derive.doubled */
+    readonly derive: InferDerivations<S>;
+    /** Direct events accessor: system.events.increment() */
+    readonly events: SingleModuleEvents<S>;
+    /** Start the system (initialize modules, begin reconciliation) */
+    start(): void;
+    /** Stop the system (cancel resolvers, stop reconciliation) */
+    stop(): void;
+    /** Destroy the system (stop and cleanup) */
+    destroy(): void;
+    /** Whether the system is currently running */
+    readonly isRunning: boolean;
+    /** Whether all resolvers have completed */
+    readonly isSettled: boolean;
+    /** Whether module has completed initialization */
+    readonly isInitialized: boolean;
+    /** Whether system has completed first reconciliation */
+    readonly isReady: boolean;
+    /** Wait for system to be fully ready (after first reconciliation) */
+    whenReady(): Promise<void>;
+    /**
+     * Hydrate facts from async source (call before start).
+     */
+    hydrate(loader: () => Promise<Partial<InferFacts<S>>> | Partial<InferFacts<S>>): Promise<void>;
+    /** Dispatch an event */
+    dispatch(event: InferEvents<S>): void;
+    /** Batch multiple fact changes */
+    batch(fn: () => void): void;
+    /**
+     * Subscribe to settlement state changes.
+     * Called whenever the system's settled state may have changed
+     * (resolver starts/completes, reconcile starts/ends).
+     */
+    onSettledChange(listener: () => void): () => void;
+    /** Subscribe to time-travel state changes (snapshot taken, navigation). */
+    onTimeTravelChange(listener: () => void): () => void;
+    /**
+     * Read a derivation value by key.
+     * @example system.read("doubled")
+     */
+    read<T = unknown>(derivationId: string): T;
+    /**
+     * Subscribe to fact or derivation changes.
+     * Keys are auto-detected -- pass any mix of fact keys and derivation keys.
+     * @example system.subscribe(["count", "doubled"], () => { ... })
+     */
+    subscribe(ids: string[], listener: () => void): () => void;
+    /**
+     * Watch a fact or derivation for value changes.
+     * The key is auto-detected -- works with both fact keys and derivation keys.
+     * Pass `options.equalityFn` for custom comparison (e.g., shallow equality for objects).
+     * @example system.watch("count", (newVal, oldVal) => { ... })
+     * @example system.watch("derived", cb, { equalityFn: shallowEqual })
+     */
+    watch<T = unknown>(id: string, callback: (newValue: T, previousValue: T | undefined) => void, options?: {
+        equalityFn?: (a: T, b: T | undefined) => boolean;
+    }): () => void;
+    /**
+     * Returns a promise that resolves when the predicate becomes true.
+     * The predicate is evaluated against current facts and re-evaluated on every change.
+     * Optionally pass a timeout in ms -- rejects with an error if exceeded.
+     *
+     * @example
+     * await system.when((facts) => facts.count > 10);
+     * await system.when((facts) => facts.count > 10, { timeout: 5000 });
+     */
+    when(predicate: (facts: Readonly<InferFacts<S>>) => boolean, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    /** Inspect system state */
+    inspect(): SystemInspection;
+    /** Wait for system to settle (all resolvers complete) */
+    settle(maxWait?: number): Promise<void>;
+    /** Explain why a requirement exists */
+    explain(requirementId: string): string | null;
+    /** Get serializable snapshot of system state */
+    getSnapshot(): SystemSnapshot;
+    /** Restore system state from snapshot */
+    restore(snapshot: SystemSnapshot): void;
+    /**
+     * Register a new module into a running system.
+     * Module facts, derivations, effects, constraints, and resolvers are merged
+     * into the existing engine and reconciliation is triggered.
+     *
+     * @example
+     * ```typescript
+     * const analyticsModule = await import('./modules/analytics');
+     * system.registerModule(analyticsModule.default);
+     * ```
+     */
+    registerModule<S2 extends ModuleSchema>(moduleDef: ModuleDef<S2>): void;
+    /**
+     * Get a distributable snapshot of computed derivations.
+     *
+     * @example
+     * ```typescript
+     * const snapshot = system.getDistributableSnapshot({
+     *   includeDerivations: ['effectivePlan', 'canUseFeature'],
+     *   ttlSeconds: 3600,
+     * });
+     * await redis.setex(`entitlements:${userId}`, 3600, JSON.stringify(snapshot));
+     * ```
+     */
+    getDistributableSnapshot<T = Record<string, unknown>>(options?: DistributableSnapshotOptions): DistributableSnapshot<T>;
+    /**
+     * Watch for changes to distributable snapshot derivations.
+     * Calls the callback whenever any of the included derivations change.
+     * Returns an unsubscribe function.
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = system.watchDistributableSnapshot(
+     *   { includeDerivations: ['effectivePlan', 'canUseFeature'] },
+     *   (snapshot) => {
+     *     await redis.setex(`entitlements:${userId}`, 3600, JSON.stringify(snapshot));
+     *   }
+     * );
+     * ```
+     */
+    watchDistributableSnapshot<T = Record<string, unknown>>(options: DistributableSnapshotOptions, callback: (snapshot: DistributableSnapshot<T>) => void): () => void;
+}
+/**
+ * Events dispatcher for a single module (direct access).
+ */
+type SingleModuleEvents<S extends ModuleSchema> = S["events"] extends Record<string, unknown> ? {
+    [E in keyof S["events"]]: S["events"][E] extends Record<string, unknown> ? keyof S["events"][E] extends never ? () => void : (payload: InferEventPayload<S["events"][E]>) => void : () => void;
+} : Record<string, never>;
+/**
+ * System mode discriminator.
+ * - "single": Single module with direct access (`system.facts.count`)
+ * - "namespaced": Multiple modules with namespaced access (`system.facts.auth.token`)
+ */
+type SystemMode = "single" | "namespaced";
+/**
+ * Base system type for type guards.
+ * Use this for functions that accept either system type.
+ */
+interface AnySystem {
+    readonly _mode: SystemMode;
+    readonly isRunning: boolean;
+    readonly isSettled: boolean;
+    readonly isInitialized: boolean;
+    readonly isReady: boolean;
+    start(): void;
+    stop(): void;
+    destroy(): void;
+}
+/**
+ * Check if a system is a single module system.
+ * Returns true if the system was created with `module:` (singular).
+ *
+ * @example
+ * ```typescript
+ * const system = createSystem({ module: counterModule });
+ *
+ * if (isSingleModuleSystem(system)) {
+ *   // system._mode === "single"
+ *   console.log(system.facts.count);
+ * }
+ * ```
+ */
+declare function isSingleModuleSystem(system: AnySystem): boolean;
+/**
+ * Check if a system is a namespaced (multi-module) system.
+ * Returns true if the system was created with `modules:` (plural, object).
+ *
+ * @example
+ * ```typescript
+ * const system = createSystem({ modules: { auth, data } });
+ *
+ * if (isNamespacedSystem(system)) {
+ *   // system._mode === "namespaced"
+ *   console.log(system.facts.auth.token);
+ * }
+ * ```
+ */
+declare function isNamespacedSystem(system: AnySystem): boolean;
+
+/**
+ * Module Types - Type definitions for modules with consolidated schema
+ */
+
+/** Lifecycle hooks for modules */
+interface ModuleHooks<_M extends ModuleSchema> {
+    onInit?: (system: System<any>) => void;
+    onStart?: (system: System<any>) => void;
+    onStop?: (system: System<any>) => void;
+    onError?: (error: DirectiveError, context: unknown) => void;
+}
+/** Helper to get derivations schema, defaulting to empty */
+type GetDerivationsSchema<M extends ModuleSchema> = M["derivations"] extends DerivationsSchema ? M["derivations"] : Record<string, never>;
+/** Helper to get events schema, defaulting to empty */
+type GetEventsSchema<M extends ModuleSchema> = M["events"] extends EventsSchema ? M["events"] : Record<string, never>;
+/** Helper to get requirements schema, defaulting to empty */
+type GetRequirementsSchema<M extends ModuleSchema> = M["requirements"] extends RequirementsSchema$1 ? M["requirements"] : Record<string, never>;
+/**
+ * Derivation function with typed facts and derive accessor.
+ * 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]>;
+/**
+ * Typed derivations definition using the module schema.
+ * Each derivation key must match schema.derivations and return the declared type.
+ */
+type TypedDerivationsDef<M extends ModuleSchema> = {
+    [K in keyof GetDerivationsSchema<M>]: TypedDerivationFn<M, K>;
+};
+/**
+ * Event handler function with typed facts and payload.
+ * Payload is typed from schema.events[K].
+ */
+type TypedEventHandlerFn<M extends ModuleSchema, K extends keyof GetEventsSchema<M>> = keyof GetEventsSchema<M>[K] extends never ? (facts: Facts<M["facts"]>) => void : (facts: Facts<M["facts"]>, payload: InferEventPayloadFromSchema<GetEventsSchema<M>[K]>) => void;
+/**
+ * Typed events definition using the module schema.
+ * Each event key must match schema.events with the correct payload type.
+ */
+type TypedEventsDef<M extends ModuleSchema> = {
+    [K in keyof GetEventsSchema<M>]: TypedEventHandlerFn<M, K>;
+};
+/**
+ * Requirement output from a constraint.
+ */
+type RequirementOutput<R> = R | R[] | null;
+/**
+ * Constraint definition with typed requirements.
+ */
+interface TypedConstraintDef<M extends ModuleSchema> {
+    /** Priority for ordering (higher runs first) */
+    priority?: number;
+    /** Mark this constraint as async */
+    async?: boolean;
+    /** Condition function */
+    when: (facts: Facts<M["facts"]>) => boolean | Promise<boolean>;
+    /**
+     * Requirement(s) to produce when condition is met.
+     */
+    require: RequirementOutput<InferRequirements<M>> | ((facts: Facts<M["facts"]>) => RequirementOutput<InferRequirements<M>>);
+    /** Timeout for async constraints (ms) */
+    timeout?: number;
+    /**
+     * Constraint IDs whose resolvers must complete before this constraint is evaluated.
+     * If a dependency's `when()` returns false (no requirements), this constraint proceeds.
+     * If a dependency's resolver fails, this constraint remains blocked.
+     * Cross-module: use "moduleName.constraintName" format.
+     */
+    after?: string[];
+    /**
+     * Explicit fact dependencies for this constraint.
+     * Required for async constraints to enable dependency tracking.
+     */
+    deps?: string[];
+}
+/**
+ * Typed constraints definition using the module schema.
+ */
+type TypedConstraintsDef<M extends ModuleSchema> = Record<string, TypedConstraintDef<M>>;
+/**
+ * Constraint definition with cross-module typed facts.
+ * Used when a module declares crossModuleDeps for type-safe access to other modules.
+ *
+ * At runtime, constraints receive facts with:
+ * - `facts.self.*` for own module's facts
+ * - `facts.{dep}.*` for cross-module facts
+ */
+interface CrossModuleConstraintDef<M extends ModuleSchema, Deps extends CrossModuleDeps> {
+    /** Priority for ordering (higher runs first) */
+    priority?: number;
+    /** Mark this constraint as async */
+    async?: boolean;
+    /** Condition function with cross-module facts access */
+    when: (facts: CrossModuleFactsWithSelf<M, Deps>) => boolean | Promise<boolean>;
+    /**
+     * Requirement(s) to produce when condition is met.
+     */
+    require: RequirementOutput<InferRequirements<M>> | ((facts: CrossModuleFactsWithSelf<M, Deps>) => RequirementOutput<InferRequirements<M>>);
+    /** Timeout for async constraints (ms) */
+    timeout?: number;
+    /**
+     * Constraint IDs whose resolvers must complete before this constraint is evaluated.
+     * If a dependency's `when()` returns false (no requirements), this constraint proceeds.
+     * If a dependency's resolver fails, this constraint remains blocked.
+     * Cross-module: use "moduleName.constraintName" format.
+     */
+    after?: string[];
+    /**
+     * Explicit fact dependencies for this constraint.
+     * Required for async constraints to enable dependency tracking.
+     */
+    deps?: string[];
+}
+/**
+ * Cross-module constraints definition.
+ */
+type CrossModuleConstraintsDef<M extends ModuleSchema, Deps extends CrossModuleDeps> = Record<string, CrossModuleConstraintDef<M, Deps>>;
+/**
+ * Effect definition with cross-module typed facts.
+ * Used when a module declares crossModuleDeps for type-safe access to other modules.
+ *
+ * At runtime, effects receive facts with:
+ * - `facts.self.*` for own module's facts
+ * - `facts.{dep}.*` for cross-module facts
+ */
+interface CrossModuleEffectDef<M extends ModuleSchema, Deps extends CrossModuleDeps> {
+    /** Effect function with cross-module facts access. Return a cleanup function for teardown. */
+    run: (facts: CrossModuleFactsWithSelf<M, Deps>, prev: CrossModuleFactsWithSelf<M, Deps> | undefined) => void | EffectCleanup | Promise<void | EffectCleanup>;
+    /** Optional dependency keys to filter when effect runs */
+    deps?: string[];
+}
+/**
+ * Cross-module effects definition.
+ */
+type CrossModuleEffectsDef<M extends ModuleSchema, Deps extends CrossModuleDeps> = Record<string, CrossModuleEffectDef<M, Deps>>;
+/**
+ * Derivation function with cross-module typed facts.
+ * Used when a module declares crossModuleDeps for type-safe access to other modules' facts.
+ *
+ * At runtime, derivations receive facts with:
+ * - `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]>;
+/**
+ * Cross-module derivations definition.
+ */
+type CrossModuleDerivationsDef<M extends ModuleSchema, Deps extends CrossModuleDeps> = {
+    [K in keyof GetDerivationsSchema<M>]: CrossModuleDerivationFn<M, Deps, K>;
+};
+/**
+ * Retry policy configuration.
+ */
+interface RetryPolicy {
+    attempts: number;
+    backoff: "none" | "linear" | "exponential";
+    initialDelay?: number;
+    maxDelay?: number;
+}
+/**
+ * Resolver context with typed facts.
+ */
+interface TypedResolverContext<M extends ModuleSchema> {
+    readonly facts: Facts<M["facts"]>;
+    readonly signal: AbortSignal;
+}
+/**
+ * Helper to extract a specific requirement type from the schema.
+ */
+type ExtractRequirement<M extends ModuleSchema, T extends keyof GetRequirementsSchema<M>> = {
+    type: T;
+} & InferRequirementPayloadFromSchema<GetRequirementsSchema<M>[T]>;
+/**
+ * Typed resolver definition for a specific requirement type.
+ */
+interface TypedResolverDef<M extends ModuleSchema, T extends keyof GetRequirementsSchema<M> & string> {
+    /** Requirement type to handle */
+    requirement: T;
+    /** Custom key function for deduplication */
+    key?: (req: ExtractRequirement<M, T>) => string;
+    /** Retry policy */
+    retry?: RetryPolicy;
+    /** Timeout for resolver execution (ms) */
+    timeout?: number;
+    /** Resolve function */
+    resolve: (req: ExtractRequirement<M, T>, ctx: TypedResolverContext<M>) => Promise<void>;
+}
+/**
+ * Union of all typed resolver definitions for all requirement types.
+ */
+type AnyTypedResolverDef<M extends ModuleSchema> = {
+    [T in keyof GetRequirementsSchema<M> & string]: TypedResolverDef<M, T>;
+}[keyof GetRequirementsSchema<M> & string];
+/**
+ * Typed resolvers definition using the module schema.
+ */
+type TypedResolversDef<M extends ModuleSchema> = Record<string, AnyTypedResolverDef<M>>;
+/**
+ * Module definition using consolidated schema.
+ * This provides full type inference for all module components.
+ *
+ * derive and events are optional when the schema has no derivations/events.
+ */
+interface ModuleDef<M extends ModuleSchema = ModuleSchema> {
+    id: string;
+    schema: M;
+    init?: (facts: Facts<M["facts"]>) => void;
+    derive?: TypedDerivationsDef<M>;
+    events?: TypedEventsDef<M>;
+    effects?: EffectsDef<M["facts"]>;
+    constraints?: TypedConstraintsDef<M>;
+    resolvers?: TypedResolversDef<M>;
+    hooks?: ModuleHooks<M>;
+    /**
+     * Cross-module dependencies (runtime marker).
+     * When present, constraints/effects receive `facts.self.*` + `facts.{dep}.*`.
+     * @internal
+     */
+    crossModuleDeps?: CrossModuleDeps;
+}
+
+/**
+ * System Types - Type definitions for the system
+ */
+
+/**
+ * Derive accessor from module schema.
+ */
+type DeriveAccessor<M extends ModuleSchema> = InferDerivations<M>;
+/**
+ * Fact keys from module schema.
+ */
+type FactKeys<M extends ModuleSchema> = keyof M["facts"] & string;
+/**
+ * Get fact return type from module schema.
+ */
+type FactReturnType<M extends ModuleSchema, K extends keyof M["facts"]> = InferSchemaType<M["facts"][K]>;
+/**
+ * Derivation keys from module schema.
+ */
+type DerivationKeys<M extends ModuleSchema> = keyof M["derivations"] & string;
+/**
+ * Get derivation return type from module schema.
+ */
+type DerivationReturnType<M extends ModuleSchema, K extends keyof M["derivations"]> = InferSchemaType<M["derivations"][K]>;
+/**
+ * All observable keys (facts + derivations) from module schema.
+ */
+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;
+    maxSnapshots?: number;
+}
+/** Time-travel API */
+interface TimeTravelAPI {
+    readonly snapshots: Snapshot[];
+    readonly currentIndex: number;
+    readonly isPaused: boolean;
+    goBack(steps?: number): void;
+    goForward(steps?: number): void;
+    goTo(snapshotId: number): void;
+    replay(): void;
+    export(): string;
+    import(json: string): void;
+    beginChangeset(label: string): void;
+    endChangeset(): void;
+    pause(): void;
+    resume(): void;
+}
+/** Lightweight snapshot metadata (no facts data — keeps re-renders cheap) */
+interface SnapshotMeta {
+    id: number;
+    timestamp: number;
+    trigger: string;
+}
+/** Reactive time-travel state for framework hooks */
+interface TimeTravelState {
+    canUndo: boolean;
+    canRedo: boolean;
+    undo: () => void;
+    redo: () => void;
+    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;
+    replay: () => void;
+    exportSession: () => string;
+    importSession: (json: string) => void;
+    beginChangeset: (label: string) => void;
+    endChangeset: () => void;
+    isPaused: boolean;
+    pause: () => void;
+    resume: () => void;
+}
+/** System inspection result */
+interface SystemInspection {
+    unmet: RequirementWithId[];
+    inflight: Array<{
+        id: string;
+        resolverId: string;
+        startedAt: number;
+    }>;
+    constraints: Array<{
+        id: string;
+        active: boolean;
+        priority: number;
+    }>;
+    resolvers: Record<string, ResolverStatus>;
+}
+/** Explanation of why a requirement exists */
+interface RequirementExplanation {
+    requirementId: string;
+    requirementType: string;
+    constraintId: string;
+    constraintPriority: number;
+    relevantFacts: Record<string, unknown>;
+    resolverStatus: ResolverStatus;
+}
+/** Serializable system snapshot for SSR/persistence */
+interface SystemSnapshot {
+    facts: Record<string, unknown>;
+    version?: number;
+}
+/**
+ * Options for creating a distributable snapshot.
+ * Distributable snapshots contain computed derivation values that can be
+ * serialized and distributed (JWT, Redis, edge KV) for use outside the runtime.
+ */
+interface DistributableSnapshotOptions {
+    /** Derivation keys to include (default: all) */
+    includeDerivations?: string[];
+    /** Derivation keys to exclude */
+    excludeDerivations?: string[];
+    /** Fact keys to include (default: none) */
+    includeFacts?: string[];
+    /** TTL in seconds */
+    ttlSeconds?: number;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+    /** Include version hash for cache invalidation */
+    includeVersion?: boolean;
+}
+/**
+ * A distributable snapshot containing computed state.
+ * This is a serializable object that can be stored in Redis, JWT, etc.
+ *
+ * @example
+ * ```typescript
+ * const snapshot = system.getDistributableSnapshot({
+ *   includeDerivations: ['effectivePlan', 'canUseFeature', 'limits'],
+ *   ttlSeconds: 3600,
+ * });
+ * // { data: { effectivePlan: "pro", canUseFeature: {...} }, createdAt: ..., expiresAt: ... }
+ *
+ * // Store in Redis
+ * await redis.setex(`entitlements:${userId}`, 3600, JSON.stringify(snapshot));
+ *
+ * // Later, in an API route (no Directive runtime needed)
+ * const cached = JSON.parse(await redis.get(`entitlements:${userId}`));
+ * if (!cached.data.canUseFeature.api) throw new ForbiddenError();
+ * ```
+ */
+interface DistributableSnapshot<T = Record<string, unknown>> {
+    /** The computed derivation values and optionally included facts */
+    data: T;
+    /** Timestamp when this snapshot was created (ms since epoch) */
+    createdAt: number;
+    /** Timestamp when this snapshot expires (ms since epoch), if TTL was specified */
+    expiresAt?: number;
+    /** Version hash for cache invalidation, if includeVersion was true */
+    version?: string;
+    /** Custom metadata passed in options */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * System interface using consolidated module schema.
+ * Provides full type inference for facts, derivations, events, and dispatch.
+ */
+/** Runtime control for constraints */
+interface ConstraintsControl {
+    /** 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;
+}
+/** Runtime control for effects */
+interface EffectsControl {
+    /** 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;
+}
+interface System<M extends ModuleSchema = ModuleSchema> {
+    readonly facts: Facts<M["facts"]>;
+    readonly debug: TimeTravelAPI | null;
+    readonly derive: InferDerivations<M>;
+    readonly events: EventsAccessorFromSchema<M>;
+    readonly constraints: ConstraintsControl;
+    readonly effects: EffectsControl;
+    start(): void;
+    stop(): void;
+    destroy(): void;
+    readonly isRunning: boolean;
+    readonly isSettled: boolean;
+    /** Whether all modules have completed initialization */
+    readonly isInitialized: boolean;
+    /** Whether system has completed first reconciliation */
+    readonly isReady: boolean;
+    /** Wait for system to be fully ready (after first reconciliation) */
+    whenReady(): Promise<void>;
+    dispatch(event: InferEvents<M>): void;
+    dispatch(event: SystemEvent): void;
+    batch(fn: () => void): void;
+    /**
+     * Subscribe to settlement state changes.
+     * Called whenever the system's settled state may have changed
+     * (resolver starts/completes, reconcile starts/ends).
+     */
+    onSettledChange(listener: () => void): () => void;
+    /**
+     * Subscribe to time-travel state changes.
+     * Called whenever a snapshot is taken or time-travel 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;
+    /**
+     * Subscribe to fact or derivation changes.
+     * Keys are auto-detected -- pass any mix of fact keys and derivation keys.
+     * @example system.subscribe(["count", "doubled"], () => { ... })
+     */
+    subscribe(ids: Array<ObservableKeys<M>>, listener: () => void): () => void;
+    /**
+     * Watch a fact or derivation for value changes.
+     * The key is auto-detected -- works with both fact keys and derivation keys.
+     * Pass `options.equalityFn` for custom comparison (e.g., shallow equality for objects).
+     * @example system.watch("count", (newVal, oldVal) => { ... })
+     * @example system.watch("derived", cb, { equalityFn: shallowEqual })
+     */
+    watch<K extends DerivationKeys<M>>(id: K, callback: (newValue: DerivationReturnType<M, K>, previousValue: DerivationReturnType<M, K> | undefined) => void, options?: {
+        equalityFn?: (a: DerivationReturnType<M, K>, b: DerivationReturnType<M, K> | undefined) => boolean;
+    }): () => void;
+    watch<K extends FactKeys<M>>(id: K, callback: (newValue: FactReturnType<M, K>, previousValue: FactReturnType<M, K> | undefined) => void, options?: {
+        equalityFn?: (a: FactReturnType<M, K>, b: FactReturnType<M, K> | undefined) => boolean;
+    }): () => void;
+    watch<T = unknown>(id: string, callback: (newValue: T, previousValue: T | undefined) => void, options?: {
+        equalityFn?: (a: T, b: T | undefined) => boolean;
+    }): () => void;
+    /**
+     * Returns a promise that resolves when the predicate becomes true.
+     * The predicate is evaluated against current facts and re-evaluated on every change.
+     * Optionally pass a timeout in ms -- rejects with an error if exceeded.
+     *
+     * @example
+     * await system.when((facts) => facts.phase === "ready");
+     * @example
+     * await system.when((facts) => facts.count > 10, { timeout: 5000 });
+     */
+    when(predicate: (facts: Readonly<InferFacts<M>>) => boolean, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    inspect(): SystemInspection;
+    settle(maxWait?: number): Promise<void>;
+    explain(requirementId: string): string | null;
+    getSnapshot(): SystemSnapshot;
+    restore(snapshot: SystemSnapshot): void;
+    /**
+     * Get a distributable snapshot of computed derivations.
+     * This creates a serializable object that can be stored in Redis, JWT, etc.
+     * for use outside the Directive runtime.
+     *
+     * @example
+     * ```typescript
+     * const snapshot = system.getDistributableSnapshot({
+     *   includeDerivations: ['effectivePlan', 'canUseFeature'],
+     *   ttlSeconds: 3600,
+     * });
+     * await redis.setex(`entitlements:${userId}`, 3600, JSON.stringify(snapshot));
+     * ```
+     */
+    getDistributableSnapshot<T = Record<string, unknown>>(options?: DistributableSnapshotOptions): DistributableSnapshot<T>;
+    /**
+     * Watch for changes to distributable snapshot derivations.
+     * Calls the callback whenever any of the included derivations change.
+     * Returns an unsubscribe function.
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = system.watchDistributableSnapshot(
+     *   { includeDerivations: ['effectivePlan', 'canUseFeature'] },
+     *   (snapshot) => {
+     *     // Snapshot changed - push to Redis/edge cache
+     *     await redis.setex(`entitlements:${userId}`, 3600, JSON.stringify(snapshot));
+     *   }
+     * );
+     *
+     * // Later, cleanup
+     * unsubscribe();
+     * ```
+     */
+    watchDistributableSnapshot<T = Record<string, unknown>>(options: DistributableSnapshotOptions, callback: (snapshot: DistributableSnapshot<T>) => void): () => void;
+}
+/** System configuration */
+interface SystemConfig<M extends ModuleSchema = ModuleSchema> {
+    modules: Array<ModuleDef<M>>;
+    plugins?: Array<Plugin<any>>;
+    debug?: DebugConfig;
+    errorBoundary?: ErrorBoundaryConfig;
+    /**
+     * Callback invoked after module inits but before first reconcile.
+     * Used by system wrapper to apply initialFacts/hydrate at the right time.
+     * @internal
+     */
+    onAfterModuleInit?: () => void;
+    tickMs?: number;
+}
+
+/**
+ * Plugin Types - Type definitions for plugins
+ */
+
+/** Reconcile result */
+interface ReconcileResult {
+    unmet: RequirementWithId[];
+    inflight: Array<{
+        id: string;
+        resolverId: string;
+        startedAt: number;
+    }>;
+    completed: Array<{
+        id: string;
+        resolverId: string;
+        duration: number;
+    }>;
+    canceled: Array<{
+        id: string;
+        resolverId: string;
+    }>;
+}
+/** Snapshot for time-travel */
+interface Snapshot {
+    id: number;
+    timestamp: number;
+    facts: Record<string, unknown>;
+    trigger: string;
+}
+/**
+ * Plugin interface for extending Directive functionality.
+ *
+ * Plugins receive lifecycle hooks at every stage of the system's operation.
+ * All hooks except `onInit` are synchronous - use them for logging, metrics,
+ * or triggering external effects, not for async operations that should block.
+ */
+interface Plugin<M extends ModuleSchema = ModuleSchema> {
+    /** Unique name for this plugin (used in error messages and debugging) */
+    name: string;
+    /**
+     * Called once when the system is created, before start().
+     * This is the only async hook - use it for async initialization.
+     * @param system - The system instance
+     */
+    onInit?: (system: System<M>) => void | Promise<void>;
+    /**
+     * Called when system.start() is invoked.
+     * Module init functions have already run at this point.
+     * @param system - The system instance
+     */
+    onStart?: (system: System<M>) => void;
+    /**
+     * Called when system.stop() is invoked.
+     * All resolvers have been canceled at this point.
+     * @param system - The system instance
+     */
+    onStop?: (system: System<M>) => void;
+    /**
+     * Called when system.destroy() is invoked.
+     * Use for final cleanup (closing connections, etc.).
+     * @param system - The system instance
+     */
+    onDestroy?: (system: System<M>) => void;
+    /**
+     * Called when a single fact is set (not during batch).
+     * @param key - The fact key that changed
+     * @param value - The new value
+     * @param prev - The previous value (undefined if new)
+     */
+    onFactSet?: (key: string, value: unknown, prev: unknown) => void;
+    /**
+     * Called when a fact is deleted.
+     * @param key - The fact key that was deleted
+     * @param prev - The previous value
+     */
+    onFactDelete?: (key: string, prev: unknown) => void;
+    /**
+     * Called after a batch of fact changes completes.
+     * Use this instead of onFactSet for batched operations.
+     * @param changes - Array of all changes in the batch
+     */
+    onFactsBatch?: (changes: FactChange[]) => void;
+    /**
+     * Called when a derivation is computed (or recomputed).
+     * @param id - The derivation ID
+     * @param value - The computed value
+     * @param deps - Array of fact keys this derivation depends on
+     */
+    onDerivationCompute?: (id: string, value: unknown, deps: string[]) => void;
+    /**
+     * Called when a derivation is invalidated (marked stale).
+     * The derivation will be recomputed on next access.
+     * @param id - The derivation ID
+     */
+    onDerivationInvalidate?: (id: string) => void;
+    /**
+     * Called at the start of each reconciliation loop.
+     * @param snapshot - Read-only snapshot of current facts
+     */
+    onReconcileStart?: (snapshot: FactsSnapshot<M["facts"]>) => void;
+    /**
+     * Called at the end of each reconciliation loop.
+     * @param result - Summary of what happened (unmet, inflight, completed, canceled)
+     */
+    onReconcileEnd?: (result: ReconcileResult) => void;
+    /**
+     * Called after a constraint's `when` function is evaluated.
+     * @param id - The constraint ID
+     * @param active - Whether the constraint is active (when returned true)
+     */
+    onConstraintEvaluate?: (id: string, active: boolean) => void;
+    /**
+     * Called when a constraint's `when` function throws an error.
+     * @param id - The constraint ID
+     * @param error - The error that was thrown
+     */
+    onConstraintError?: (id: string, error: unknown) => void;
+    /**
+     * Called when a new requirement is created by a constraint.
+     * @param req - The requirement with its computed ID
+     */
+    onRequirementCreated?: (req: RequirementWithId) => void;
+    /**
+     * Called when a requirement is fulfilled by a resolver.
+     * @param req - The requirement that was met
+     * @param byResolver - The ID of the resolver that fulfilled it
+     */
+    onRequirementMet?: (req: RequirementWithId, byResolver: string) => void;
+    /**
+     * Called when a requirement is canceled (constraint no longer active).
+     * @param req - The requirement that was canceled
+     */
+    onRequirementCanceled?: (req: RequirementWithId) => void;
+    /**
+     * Called when a resolver starts processing a requirement.
+     * @param resolver - The resolver ID
+     * @param req - The requirement being resolved
+     */
+    onResolverStart?: (resolver: string, req: RequirementWithId) => void;
+    /**
+     * Called when a resolver successfully completes.
+     * @param resolver - The resolver ID
+     * @param req - The requirement that was resolved
+     * @param duration - Time in ms to complete
+     */
+    onResolverComplete?: (resolver: string, req: RequirementWithId, duration: number) => void;
+    /**
+     * Called when a resolver fails (after all retries exhausted).
+     * @param resolver - The resolver ID
+     * @param req - The requirement that failed
+     * @param error - The final error
+     */
+    onResolverError?: (resolver: string, req: RequirementWithId, error: unknown) => void;
+    /**
+     * Called when a resolver is about to retry after failure.
+     * @param resolver - The resolver ID
+     * @param req - The requirement being retried
+     * @param attempt - The attempt number (2 for first retry, etc.)
+     */
+    onResolverRetry?: (resolver: string, req: RequirementWithId, attempt: number) => void;
+    /**
+     * Called when a resolver is canceled (requirement no longer needed).
+     * @param resolver - The resolver ID
+     * @param req - The requirement that was canceled
+     */
+    onResolverCancel?: (resolver: string, req: RequirementWithId) => void;
+    /**
+     * Called when an effect runs.
+     * @param id - The effect ID
+     */
+    onEffectRun?: (id: string) => void;
+    /**
+     * Called when an effect throws an error.
+     * @param id - The effect ID
+     * @param error - The error that was thrown
+     */
+    onEffectError?: (id: string, error: unknown) => void;
+    /**
+     * Called when a time-travel snapshot is taken.
+     * @param snapshot - The snapshot that was captured
+     */
+    onSnapshot?: (snapshot: Snapshot) => void;
+    /**
+     * Called when time-travel navigation occurs.
+     * @param from - The index we navigated from
+     * @param to - The index we navigated to
+     */
+    onTimeTravel?: (from: number, to: number) => void;
+    /**
+     * Called when any error occurs in the system.
+     * @param error - The DirectiveError with source and context
+     */
+    onError?: (error: DirectiveError) => void;
+    /**
+     * Called when error recovery is attempted.
+     * @param error - The error that triggered recovery
+     * @param strategy - The recovery strategy used
+     */
+    onErrorRecovery?: (error: DirectiveError, strategy: RecoveryStrategy) => void;
+}
+
+export { type BatchItemResult 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 ErrorSource as W, type RetryLaterConfig as X, type TimeTravelAPI as Y, type SystemConfig as Z, type AnySystem as _, type RequirementOutput$1 as a, type BatchResolveResults as a0, type CircuitBreakerConfig as a1, type CircuitBreakerState 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 DeriveAccessor as a9, type RequirementPayloadSchema$1 as aA, type RequirementsSchema as aB, type SnapshotMeta as aC, type SystemEvent as aD, type SystemInspection as aE, type SystemMode as aF, type SystemSnapshot as aG, type TimeTravelState as aH, type TypedResolverContext as aI, type TypedResolverDef as aJ, type UnionEvents as aK, isNamespacedSystem as aL, isSingleModuleSystem as aM, type DispatchEventsFromSchema as aa, type DistributableSnapshot as ab, type DistributableSnapshotOptions as ac, type EffectCleanup as ad, type EventPayloadSchema as ae, type EventsAccessor as af, type EventsAccessorFromSchema as ag, type EventsDef as ah, type EventsSchema as ai, type FactKeys as aj, type FactReturnType as ak, type FlexibleEventHandler as al, type InferDerivations as am, type InferEventPayloadFromSchema as an, type InferEvents as ao, type InferRequirementPayloadFromSchema as ap, type InferRequirementTypes as aq, type InferSchema as ar, type InferSchemaType as as, type InferSelectorState as at, type MutableNamespacedFacts as au, type NamespacedDerivations as av, type NamespacedEventsAccessor as aw, type NamespacedFacts as ax, type ObservableKeys as ay, type RequirementExplanation as az, type RetryPolicy$1 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 };