@directive-run/core 0.1.1

package/dist/index.d.cts

@@ -0,0 +1,2016 @@
+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 ErrorSource, X as RetryLaterConfig, Y as TimeTravelAPI, Z as SystemConfig } from './plugins-CcwEXXMS.cjs';
+export { _ as AnySystem, $ as BatchItemResult, a0 as BatchResolveResults, a1 as CircuitBreakerConfig, a2 as CircuitBreakerState, a3 as CrossModuleConstraintDef, a4 as CrossModuleDerivationFn, a5 as CrossModuleEffectDef, a6 as CrossModuleFactsWithSelf, a7 as DerivationKeys, a8 as DerivationReturnType, a9 as DeriveAccessor, aa as DispatchEventsFromSchema, ab as DistributableSnapshot, ac as DistributableSnapshotOptions, ad as EffectCleanup, ae as EventPayloadSchema, af as EventsAccessor, ag as EventsAccessorFromSchema, ah as EventsDef, ai as EventsSchema, aj as FactKeys, ak as FactReturnType, al as FlexibleEventHandler, am as InferDerivations, an as InferEventPayloadFromSchema, ao as InferEvents, ap as InferRequirementPayloadFromSchema, aq as InferRequirementTypes, ar as InferSchema, as as InferSchemaType, at as InferSelectorState, au as MutableNamespacedFacts, av as NamespacedDerivations, aw as NamespacedEventsAccessor, ax as NamespacedFacts, ay as ObservableKeys, az as RequirementExplanation, aA as RequirementPayloadSchema, aB as RequirementsSchema, aC as SnapshotMeta, aD as SystemEvent, aE as SystemInspection, aF as SystemMode, aG as SystemSnapshot, aH as TimeTravelState, aI as TypedResolverContext, aJ as TypedResolverDef, aK as UnionEvents, aL as isNamespacedSystem, aM as isSingleModuleSystem } from './plugins-CcwEXXMS.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
+ */
+
+/** Tracking context for auto-dependency detection */
+interface TrackingContext {
+    readonly isTracking: boolean;
+    track(key: string): void;
+    getDependencies(): Set<string>;
+}
+/**
+ * Legacy derivation definition function signature.
+ * Used internally by the engine.
+ *
+ * @deprecated For typed derivations, use TypedDerivationsDef from module.ts
+ */
+interface DerivationDef<S extends Schema, T, D extends DerivationsDef<S>> {
+    (facts: Facts<S>, derive: DerivedValues<S, D>): T;
+}
+/**
+ * Legacy map of derivation definitions.
+ * Used internally by the engine.
+ *
+ * @deprecated For typed derivations, use TypedDerivationsDef from module.ts
+ */
+type DerivationsDef<S extends Schema> = Record<string, DerivationDef<S, unknown, DerivationsDef<S>>>;
+/**
+ * Legacy computed derived values.
+ * Used internally by the engine.
+ *
+ * @deprecated For typed derivations, use InferDerivations from schema.ts
+ */
+type DerivedValues<S extends Schema, D extends DerivationsDef<S>> = {
+    readonly [K in keyof D]: ReturnType<D[K]>;
+};
+/** Internal derivation state */
+interface DerivationState<T> {
+    id: string;
+    compute: () => T;
+    cachedValue: T | undefined;
+    dependencies: Set<string>;
+    isStale: boolean;
+    isComputing: boolean;
+}
+
+/**
+ * Type Helpers - External typed constraint and resolver definitions
+ *
+ * These types enable defining constraints and resolvers with full type safety
+ * outside of module definitions, while maintaining proper type inference.
+ */
+
+/**
+ * External constraint definition with full typing.
+ * Use this when defining constraints outside of createModule().
+ *
+ * @typeParam S - The schema type
+ * @typeParam R - The requirement type (defaults to Requirement)
+ *
+ * @example
+ * ```typescript
+ * // Define a typed constraint factory
+ * const createMaxCountConstraint = <S extends Schema>(
+ *   maxCount: number
+ * ): TypedConstraint<S, { type: "RESET_COUNT" }> => ({
+ *   priority: 10,
+ *   when: (facts) => (facts as { count: number }).count > maxCount,
+ *   require: { type: "RESET_COUNT" },
+ * });
+ *
+ * // Use in module
+ * const module = createModule("counter", {
+ *   schema: { count: t.number() },
+ *   constraints: {
+ *     maxCount: createMaxCountConstraint(100),
+ *   },
+ * });
+ * ```
+ */
+interface TypedConstraint<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.
+     */
+    require: RequirementOutput<R> | ((facts: Facts<S>) => RequirementOutput<R>);
+    /** Timeout for async constraints (ms) */
+    timeout?: number;
+    /**
+     * Constraint IDs whose resolvers must complete before this constraint is evaluated.
+     * - If dependency's `when()` returns false, this constraint proceeds (nothing to wait for)
+     * - If dependency's resolver fails, this constraint remains blocked until it succeeds
+     * - Cross-module: use the constraint ID as it appears in the merged system
+     */
+    after?: string[];
+}
+/**
+ * External resolver definition with full typing.
+ * Use this when defining resolvers outside of createModule().
+ *
+ * @typeParam S - The schema type
+ * @typeParam R - The requirement type (defaults to Requirement)
+ *
+ * @example
+ * ```typescript
+ * // Define a typed resolver factory
+ * interface FetchUserReq extends Requirement {
+ *   type: "FETCH_USER";
+ *   userId: string;
+ * }
+ *
+ * const createFetchUserResolver = <S extends Schema>(
+ *   fetchFn: (userId: string) => Promise<User>
+ * ): TypedResolver<S, FetchUserReq> => ({
+ *   requirement: (req): req is FetchUserReq => req.type === "FETCH_USER",
+ *   key: (req) => `fetch-user-${req.userId}`,
+ *   retry: { attempts: 3, backoff: "exponential" },
+ *   resolve: async (req, ctx) => {
+ *     const user = await fetchFn(req.userId);
+ *     (ctx.facts as { user: User }).user = user;
+ *   },
+ * });
+ * ```
+ */
+interface TypedResolver<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: R["type"] | ((req: Requirement) => req is R);
+    /** Custom key function for deduplication */
+    key?: (req: R) => string;
+    /** Retry policy */
+    retry?: RetryPolicy;
+    /** Timeout for resolver execution (ms) */
+    timeout?: number;
+    /** Batch configuration */
+    batch?: BatchConfig;
+    /** Resolve function for single requirement */
+    resolve?: (req: R, ctx: ResolverContext<S>) => Promise<void>;
+    /** Resolve function for batched requirements */
+    resolveBatch?: (reqs: R[], ctx: ResolverContext<S>) => Promise<void>;
+}
+/**
+ * Create a typed constraint factory for a specific schema.
+ * This enables creating reusable constraint definitions with proper typing.
+ *
+ * @example
+ * ```typescript
+ * const schema = { count: t.number(), threshold: t.number() };
+ * const factory = constraintFactory<typeof schema>();
+ *
+ * const maxCountConstraint = factory.create({
+ *   when: (facts) => facts.count > facts.threshold,
+ *   require: { type: "RESET" },
+ * });
+ * ```
+ */
+declare function constraintFactory<S extends Schema>(): {
+    /**
+     * Create a typed constraint
+     */
+    create<R extends Requirement = Requirement>(constraint: TypedConstraint<S, R>): TypedConstraint<S, R>;
+};
+/**
+ * Create a typed resolver factory for a specific schema.
+ * This enables creating reusable resolver definitions with proper typing.
+ *
+ * @example
+ * ```typescript
+ * const schema = { user: t.object<User>() };
+ * const factory = resolverFactory<typeof schema>();
+ *
+ * const fetchUserResolver = factory.create<FetchUserReq>({
+ *   requirement: (req): req is FetchUserReq => req.type === "FETCH_USER",
+ *   resolve: async (req, ctx) => {
+ *     ctx.facts.user = await fetchUser(req.userId);
+ *   },
+ * });
+ * ```
+ */
+declare function resolverFactory<S extends Schema>(): {
+    /**
+     * Create a typed resolver
+     */
+    create<R extends Requirement = Requirement>(resolver: TypedResolver<S, R>): TypedResolver<S, R>;
+};
+/**
+ * Type-safe constraint creator.
+ * Simpler alternative to constraintFactory when you don't need a factory pattern.
+ *
+ * @example
+ * ```typescript
+ * const constraint = typedConstraint<typeof schema, { type: "RESET" }>({
+ *   when: (facts) => facts.count > 100,
+ *   require: { type: "RESET" },
+ * });
+ * ```
+ */
+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.
+ *
+ * @example
+ * ```typescript
+ * const resolver = typedResolver<typeof schema, FetchUserReq>({
+ *   requirement: (req): req is FetchUserReq => req.type === "FETCH_USER",
+ *   resolve: async (req, ctx) => {
+ *     ctx.facts.user = await fetchUser(req.userId);
+ *   },
+ * });
+ * ```
+ */
+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
+ *
+ * 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
+ */
+
+/** Brand symbol for branded types */
+declare const Brand: unique symbol;
+/** Branded type - adds a unique brand to a base type */
+type Branded<T, B extends string> = T & {
+    readonly [Brand]: B;
+};
+/** Extended SchemaType with type name for better error messages */
+interface ExtendedSchemaType<T> extends SchemaType<T> {
+    readonly _typeName?: string;
+    readonly _default?: T | (() => T);
+    readonly _transform?: (value: unknown) => T;
+    readonly _description?: string;
+    readonly _refinements?: Array<{
+        predicate: (value: T) => boolean;
+        message: string;
+    }>;
+    /** Mutable - set by array validators to indicate which element failed */
+    _lastFailedIndex?: number;
+}
+/** Chainable schema type with all common methods */
+interface ChainableSchemaType<T> extends ExtendedSchemaType<T> {
+    default(value: T | (() => T)): ChainableSchemaType<T>;
+    transform<U>(fn: (value: T) => U): ChainableSchemaType<U>;
+    brand<B extends string>(): ChainableSchemaType<Branded<T, B>>;
+    describe(description: string): ChainableSchemaType<T>;
+    refine(predicate: (value: T) => boolean, message: string): ChainableSchemaType<T>;
+    nullable(): ChainableSchemaType<T | null>;
+    optional(): ChainableSchemaType<T | undefined>;
+}
+/**
+ * Schema type builders for defining fact types.
+ *
+ * @example
+ * ```typescript
+ * const module = createModule("example", {
+ *   schema: {
+ *     name: t.string(),
+ *     age: t.number().min(0).max(150),
+ *     active: t.boolean(),
+ *     tags: t.array<string>().of(t.string()),
+ *     user: t.object<{ id: string; email: string }>(),
+ *   },
+ * });
+ * ```
+ */
+declare const t: {
+    /**
+     * Create a string schema type.
+     *
+     * @example
+     * ```typescript
+     * // Basic string
+     * schema: { name: t.string() }
+     *
+     * // String literal union (for type safety)
+     * schema: { phase: t.string<"red" | "green" | "yellow">() }
+     *
+     * // With custom validation
+     * schema: { email: t.string().validate(s => s.includes("@")) }
+     *
+     * // With transform
+     * schema: { trimmed: t.string().transform(s => s.trim()) }
+     *
+     * // With brand
+     * schema: { userId: t.string().brand<"UserId">() }
+     * ```
+     */
+    string<T extends string = string>(): ChainableSchemaType<T>;
+    /**
+     * Create a number schema type with optional min/max constraints.
+     *
+     * @example
+     * ```typescript
+     * // Basic number
+     * schema: { count: t.number() }
+     *
+     * // With range constraints
+     * schema: { age: t.number().min(0).max(150) }
+     *
+     * // With custom validation
+     * schema: { even: t.number().validate(n => n % 2 === 0) }
+     *
+     * // With default
+     * schema: { count: t.number().default(0) }
+     *
+     * // With transform (from string)
+     * schema: { age: t.number().transform(v => parseInt(String(v), 10)) }
+     * ```
+     */
+    number(): ChainableSchemaType<number> & {
+        min(n: number): ChainableSchemaType<number> & /*elided*/ any;
+        max(n: number): ChainableSchemaType<number> & /*elided*/ any;
+    };
+    /**
+     * Create a boolean schema type.
+     *
+     * @example
+     * ```typescript
+     * schema: {
+     *   active: t.boolean(),
+     *   verified: t.boolean().default(false),
+     * }
+     * ```
+     */
+    boolean(): ChainableSchemaType<boolean>;
+    /**
+     * Create an array schema type.
+     * Can be used with or without element validation:
+     * - `t.array<string>()` - Type-only, no element validation
+     * - `t.array<string>().of(t.string())` - With element validation
+     */
+    array<T>(): ChainableSchemaType<T[]> & {
+        of(elementType: SchemaType<T>): ChainableSchemaType<T[]> & /*elided*/ any;
+        nonEmpty(): ChainableSchemaType<T[]> & /*elided*/ any;
+        maxLength(n: number): ChainableSchemaType<T[]> & /*elided*/ any;
+        minLength(n: number): ChainableSchemaType<T[]> & /*elided*/ any;
+        _lastFailedIndex?: number;
+    };
+    /**
+     * Create an object schema type.
+     * 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
+     */
+    object<T extends Record<string, unknown>>(): 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;
+    };
+    /**
+     * Create an any-typed schema (bypasses all validation).
+     *
+     * @deprecated Use specific types (`t.string()`, `t.object()`, `t.union()`) for type safety.
+     * This bypasses all runtime validation.
+     *
+     * @example
+     * ```typescript
+     * // Use when type is complex or external
+     * schema: {
+     *   externalApiResponse: t.any<ExternalAPIResponse>(),
+     * }
+     * ```
+     */
+    any<T>(): ExtendedSchemaType<T>;
+    /**
+     * Create an enum schema type for string literal unions.
+     *
+     * @example
+     * ```typescript
+     * // Define allowed values
+     * schema: { status: t.enum("idle", "loading", "success", "error") }
+     *
+     * // Type is inferred as "idle" | "loading" | "success" | "error"
+     * ```
+     */
+    enum<T extends string>(...values: T[]): ChainableSchemaType<T>;
+    /**
+     * Create a literal schema type for exact value matching.
+     *
+     * @example
+     * ```typescript
+     * // Exact string match
+     * schema: { type: t.literal("user") }
+     *
+     * // Exact number match
+     * schema: { version: t.literal(1) }
+     *
+     * // Exact boolean
+     * schema: { enabled: t.literal(true) }
+     * ```
+     */
+    literal<T extends string | number | boolean>(value: T): ChainableSchemaType<T>;
+    /**
+     * Create a nullable schema type (T | null).
+     *
+     * @example
+     * ```typescript
+     * // Nullable string
+     * schema: { name: t.nullable(t.string()) }
+     *
+     * // Nullable object
+     * schema: { user: t.nullable(t.object<User>()) }
+     * ```
+     */
+    nullable<T>(innerType: SchemaType<T>): SchemaType<T | null>;
+    /**
+     * Create an optional schema type (T | undefined).
+     *
+     * @example
+     * ```typescript
+     * // Optional string
+     * schema: { nickname: t.optional(t.string()) }
+     *
+     * // Optional number
+     * schema: { age: t.optional(t.number()) }
+     * ```
+     */
+    optional<T>(innerType: SchemaType<T>): SchemaType<T | undefined>;
+    /**
+     * Create a union schema type.
+     *
+     * @example
+     * ```typescript
+     * // String or number
+     * schema: { value: t.union(t.string(), t.number()) }
+     *
+     * // Multiple types
+     * schema: { data: t.union(t.string(), t.number(), t.boolean()) }
+     * ```
+     */
+    union<T extends SchemaType<unknown>[]>(...types: T): ChainableSchemaType<T[number] extends SchemaType<infer U> ? U : never>;
+    /**
+     * Create a record schema type for dynamic key-value maps.
+     *
+     * @example
+     * ```typescript
+     * // Record with string values
+     * schema: { metadata: t.record(t.string()) }
+     *
+     * // Record with number values
+     * schema: { scores: t.record(t.number()) }
+     * ```
+     */
+    record<V>(valueType: SchemaType<V>): ChainableSchemaType<Record<string, V>>;
+    /**
+     * Create a tuple schema type for fixed-length arrays with specific types.
+     *
+     * @example
+     * ```typescript
+     * // [string, number] tuple
+     * schema: { coord: t.tuple(t.string(), t.number()) }
+     *
+     * // [x, y, z] coordinates
+     * schema: { position: t.tuple(t.number(), t.number(), t.number()) }
+     * ```
+     */
+    tuple<T extends SchemaType<unknown>[]>(...types: T): ChainableSchemaType<{ [K in keyof T]: T[K] extends SchemaType<infer U> ? U : never; }>;
+    /**
+     * Create a date schema type.
+     *
+     * @example
+     * ```typescript
+     * schema: { createdAt: t.date() }
+     * ```
+     */
+    date(): ChainableSchemaType<Date>;
+    /**
+     * Create a UUID schema type.
+     *
+     * @example
+     * ```typescript
+     * schema: { id: t.uuid() }
+     * ```
+     */
+    uuid(): ChainableSchemaType<string>;
+    /**
+     * Create an email schema type.
+     *
+     * @example
+     * ```typescript
+     * schema: { email: t.email() }
+     * ```
+     */
+    email(): ChainableSchemaType<string>;
+    /**
+     * Create a URL schema type.
+     *
+     * @example
+     * ```typescript
+     * schema: { website: t.url() }
+     * ```
+     */
+    url(): ChainableSchemaType<string>;
+    /**
+     * Create a bigint schema type.
+     *
+     * @example
+     * ```typescript
+     * schema: { largeNumber: t.bigint() }
+     * ```
+     */
+    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.
+ *
+ * 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 `FactsStore<S>` 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
+ * ```
+ */
+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.
+ *
+ * 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 `Facts<S>` proxy with property-style get/set and prototype pollution guards
+ */
+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.
+ *
+ * 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"));
+ * ```
+ */
+declare function createFacts<S extends Schema>(options: CreateFactsStoreOptions<S>): {
+    store: FactsStore<S>;
+    facts: Facts<S>;
+};
+
+/**
+ * Module - The declarative API for defining Directive modules
+ *
+ * Modules group related facts, constraints, resolvers, effects, and derivations.
+ */
+
+/**
+ * Module configuration with consolidated schema.
+ *
+ * derive and events are optional - omit them if your schema has empty derivations/events.
+ */
+interface ModuleConfig<M extends ModuleSchema> {
+    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>;
+}
+/**
+ * Module configuration with cross-module dependencies for type-safe access
+ * to other modules' facts in effects and constraints.
+ *
+ * When crossModuleDeps is provided:
+ * - Own module facts: `facts.self.*`
+ * - Cross-module facts: `facts.{dep}.*`
+ *
+ * @example
+ * ```typescript
+ * import { authSchema } from './auth';
+ * import { dataSchema } from './data';
+ *
+ * const uiModule = createModule("ui", {
+ *   schema: uiSchema,
+ *   crossModuleDeps: { auth: authSchema, data: dataSchema },
+ *   effects: {
+ *     onAuthChange: {
+ *       run: (facts) => {
+ *         facts.self.notifications   // ✅ own module via "self"
+ *         facts.auth.isAuthenticated // ✅ cross-module (namespaced)
+ *         facts.data.users           // ✅ cross-module (namespaced)
+ *       }
+ *     }
+ *   },
+ *   constraints: {
+ *     fetchWhenAuth: {
+ *       when: (facts) => facts.auth.isAuthenticated && facts.self.users.length === 0,
+ *       require: { type: "FETCH_USERS" },
+ *     }
+ *   }
+ * });
+ * ```
+ */
+interface ModuleConfigWithDeps<M extends ModuleSchema, Deps extends CrossModuleDeps> {
+    schema: M;
+    /**
+     * Cross-module dependencies for type-safe access in derive/effects/constraints.
+     *
+     * **Access patterns by context:**
+     * - `derive`, `effects`, `constraints`: Use `facts.self.*` for own module, `facts.{dep}.*` for cross-module
+     * - `init`, `events`, `resolvers`: Use flat access (`facts.myFact`) - no cross-module access
+     *
+     * This separation ensures initialization and event handling stay scoped to own module,
+     * while observers (derive/effects/constraints) can see across modules.
+     *
+     * @example
+     * ```typescript
+     * crossModuleDeps: { auth: authSchema },
+     * init: (facts) => { facts.users = []; },              // flat access
+     * derive: { count: (facts) => facts.self.users.length }, // facts.self.*
+     * effects: { log: { run: (facts) => console.log(facts.auth.token) } }, // facts.{dep}.*
+     * ```
+     */
+    crossModuleDeps: Deps;
+    /** Initialize module facts. Uses flat access (`facts.myFact`) to ensure modules initialize independently. */
+    init?: (facts: Facts<M["facts"]>) => void;
+    /** Derivations with cross-module facts access (`facts.self.*` + `facts.{dep}.*`) */
+    derive?: CrossModuleDerivationsDef<M, Deps>;
+    /** Event handlers. Uses flat access (`facts.myFact`) to keep mutations scoped to own module. */
+    events?: TypedEventsDef<M>;
+    /** Effects with cross-module facts access (`facts.self.*` + `facts.{dep}.*`) */
+    effects?: CrossModuleEffectsDef<M, Deps>;
+    /** Constraints with cross-module facts access (`facts.self.*` + `facts.{dep}.*`) */
+    constraints?: CrossModuleConstraintsDef<M, Deps>;
+    /** Resolvers. Uses flat access (`ctx.facts.myFact`) to keep async mutations scoped to own module. */
+    resolvers?: TypedResolversDef<M>;
+    hooks?: ModuleHooks<M>;
+}
+/**
+ * Create a module definition with full type inference.
+ *
+ * The consolidated schema provides:
+ * - Derivation composition (`derive.otherDerivation` is typed)
+ * - Event dispatch (`system.dispatch({ type: "..." })` has autocomplete)
+ * - Resolver requirements (`req.payload` is typed based on requirement type)
+ *
+ * @example
+ * ```ts
+ * const trafficLight = createModule("traffic-light", {
+ *   schema: {
+ *     facts: {
+ *       phase: t.string<"red" | "green" | "yellow">(),
+ *       elapsed: t.number(),
+ *     },
+ *     derivations: {
+ *       isRed: t.boolean(),
+ *       timeRemaining: t.number(),
+ *     },
+ *     events: {
+ *       tick: {},
+ *       setPhase: { phase: t.string<"red" | "green" | "yellow">() },
+ *     },
+ *     requirements: {
+ *       TRANSITION: { to: t.string<"red" | "green" | "yellow">() },
+ *     },
+ *   },
+ *   init: (facts) => {
+ *     facts.phase = "red";
+ *     facts.elapsed = 0;
+ *   },
+ *   derive: {
+ *     isRed: (facts) => facts.phase === "red",
+ *     timeRemaining: (facts, derive) => {
+ *       // derive.isRed is typed as boolean!
+ *       return derive.isRed ? 30 - facts.elapsed : 0;
+ *     },
+ *   },
+ *   events: {
+ *     tick: (facts) => { facts.elapsed += 1; },
+ *     setPhase: (facts, { phase }) => { facts.phase = phase; }, // phase is typed!
+ *   },
+ *   constraints: {
+ *     shouldTransition: {
+ *       when: (facts) => facts.phase === "red" && facts.elapsed > 30,
+ *       require: { type: "TRANSITION", to: "green" },
+ *     },
+ *   },
+ *   resolvers: {
+ *     transition: {
+ *       requirement: "TRANSITION",
+ *       resolve: async (req, ctx) => {
+ *         ctx.facts.phase = req.to; // req.to is typed!
+ *         ctx.facts.elapsed = 0;
+ *       },
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * @example With cross-module dependencies
+ * ```ts
+ * import { authSchema } from './auth';
+ *
+ * const dataModule = createModule("data", {
+ *   schema: dataSchema,
+ *   crossModuleDeps: { auth: authSchema },
+ *   constraints: {
+ *     fetchWhenAuth: {
+ *       when: (facts) => {
+ *         // facts.self.* for own module, facts.auth.* for cross-module
+ *         return facts.auth.isAuthenticated && facts.self.users.length === 0;
+ *       },
+ *       require: { type: "FETCH_USERS" },
+ *     },
+ *   },
+ *   derive: {
+ *     canFetch: (facts) => facts.auth.isAuthenticated && facts.self.users.length === 0,
+ *   },
+ * });
+ * ```
+ */
+declare function createModule<const M extends ModuleSchema, const Deps extends CrossModuleDeps>(id: string, config: ModuleConfigWithDeps<M, Deps>): ModuleDef<M>;
+declare function createModule<const M extends ModuleSchema>(id: string, config: ModuleConfig<M>): ModuleDef<M>;
+declare function createModule<const M extends ModuleSchema>(id: string, config: ModuleConfigWithDeps<M, CrossModuleDeps> | ModuleConfig<M>): ModuleDef<M>;
+/**
+ * Create a module factory that produces named instances from a single definition.
+ * Useful for multi-instance UIs (tabs, panels, multi-tenant) where you need
+ * isolated state from the same schema.
+ *
+ * @example
+ * ```typescript
+ * const chatRoom = createModuleFactory({
+ *   schema: {
+ *     facts: { messages: t.array<string>(), users: t.array<string>() },
+ *     derivations: { count: t.number() },
+ *   },
+ *   init: (facts) => { facts.messages = []; facts.users = []; },
+ *   derive: { count: (facts) => facts.messages.length },
+ * });
+ *
+ * const system = createSystem({
+ *   modules: {
+ *     lobby: chatRoom("lobby"),
+ *     support: chatRoom("support"),
+ *   },
+ * });
+ * ```
+ */
+declare function createModuleFactory<const M extends ModuleSchema>(config: ModuleConfig<M>): (name: string) => ModuleDef<M>;
+declare function createModuleFactory<const M extends ModuleSchema, const Deps extends CrossModuleDeps>(config: ModuleConfigWithDeps<M, Deps>): (name: string) => ModuleDef<M>;
+
+/**
+ * System - The top-level API for creating a Directive runtime
+ *
+ * A system combines modules with plugins and configuration.
+ * Modules are passed as an object with namespaced access:
+ *
+ * @example
+ * ```typescript
+ * const system = createSystem({
+ *   modules: { auth: authModule, data: dataModule },
+ * });
+ *
+ * system.facts.auth.token       // Namespaced facts
+ * system.derive.data.userCount  // Namespaced derivations
+ * system.events.auth.login()    // Namespaced events
+ * ```
+ */
+
+/**
+ * Create a Directive system.
+ *
+ * Supports two modes:
+ * - **Single module**: Use `module` prop for direct access without namespace
+ * - **Multiple modules**: Use `modules` prop for namespaced access
+ *
+ * @example Single module (direct access)
+ * ```ts
+ * const system = createSystem({ module: counterModule });
+ * system.facts.count           // Direct access
+ * system.events.increment()    // Direct events
+ * ```
+ *
+ * @example Multiple modules (namespaced access)
+ * ```ts
+ * const system = createSystem({
+ *   modules: { auth: authModule, data: dataModule },
+ * });
+ * system.facts.auth.token      // Namespaced access
+ * system.events.auth.login()   // Namespaced events
+ * ```
+ */
+declare function createSystem<S extends ModuleSchema>(options: CreateSystemOptionsSingle<S>): SingleModuleSystem<S>;
+declare function createSystem<const Modules extends ModulesMap>(options: CreateSystemOptionsNamed<Modules>): NamespacedSystem<Modules>;
+
+/**
+ * Builder Pattern API for Directive Modules
+ *
+ * An alternative, fluent API for creating modules that provides
+ * a more declarative style for module definition.
+ *
+ * @example
+ * ```typescript
+ * import { module, t } from '@directive-run/core';
+ *
+ * const counter = module("counter")
+ *   .schema({
+ *     facts: { count: t.number(), lastAction: t.string() },
+ *     derivations: { doubled: t.number(), isPositive: t.boolean() },
+ *     events: { increment: {}, decrement: {} },
+ *     requirements: {},
+ *   })
+ *   .init((facts) => {
+ *     facts.count = 0;
+ *     facts.lastAction = "";
+ *   })
+ *   .derive({
+ *     doubled: (facts) => facts.count * 2,
+ *     isPositive: (facts) => facts.count > 0,
+ *   })
+ *   .events({
+ *     increment: (facts) => {
+ *       facts.count += 1;
+ *       facts.lastAction = "increment";
+ *     },
+ *     decrement: (facts) => {
+ *       facts.count -= 1;
+ *       facts.lastAction = "decrement";
+ *     },
+ *   })
+ *   .build();
+ * ```
+ */
+
+/**
+ * Module builder interface - provides fluent API for building modules.
+ *
+ * @typeParam M - The module schema type (set after calling `.schema()`)
+ */
+interface ModuleBuilder<M extends ModuleSchema = ModuleSchema> {
+    /**
+     * Define the schema for this module (facts, derivations, events, requirements).
+     */
+    schema<NewM extends ModuleSchema>(schema: NewM): ModuleBuilder<NewM>;
+    /**
+     * Define the initialization function for this module.
+     */
+    init(initFn: (facts: Facts<M["facts"]>) => void): ModuleBuilder<M>;
+    /**
+     * 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>;
+    /**
+     * Define event handler implementations for this module.
+     * Keys must match those declared in schema.events.
+     */
+    events<E extends Record<string, (facts: Facts<M["facts"]>, payload: unknown) => void>>(events: E): ModuleBuilder<M>;
+    /**
+     * Define effects (side effects) for this module.
+     */
+    effects(effects: EffectsDef<M["facts"]>): ModuleBuilder<M>;
+    /**
+     * Define constraints for this module.
+     */
+    constraints<C extends Record<string, ConstraintDef<M>>>(constraints: C): ModuleBuilder<M>;
+    /**
+     * Define resolvers for this module.
+     */
+    resolvers<R extends Record<string, ResolverDef<M>>>(resolvers: R): ModuleBuilder<M>;
+    /**
+     * Define lifecycle hooks for this module.
+     */
+    hooks(hooks: ModuleHooks<M>): ModuleBuilder<M>;
+    /**
+     * Build the module definition.
+     */
+    build(): ModuleDef<M>;
+}
+/**
+ * Accessor for reading other derivations within a derivation function.
+ */
+type DeriveAccessor<M extends ModuleSchema> = M["derivations"] extends DerivationsSchema ? {
+    readonly [K in keyof M["derivations"]]: InferSchemaType<M["derivations"][K]>;
+} : Record<string, never>;
+/**
+ * Infer the TypeScript type from a schema type definition.
+ */
+type InferSchemaType<T> = T extends {
+    _type: infer U;
+} ? U : any;
+/**
+ * Constraint definition for the builder.
+ */
+interface ConstraintDef<M extends ModuleSchema> {
+    when: (facts: Facts<M["facts"]>) => boolean;
+    require: {
+        type: string;
+        [key: string]: unknown;
+    } | ((facts: Facts<M["facts"]>) => {
+        type: string;
+        [key: string]: unknown;
+    } | null);
+    priority?: number;
+}
+/**
+ * Resolver definition for the builder.
+ */
+interface ResolverDef<M extends ModuleSchema> {
+    requirement: string | ((req: {
+        type: string;
+        [key: string]: unknown;
+    }) => boolean);
+    resolve: (req: {
+        type: string;
+        [key: string]: unknown;
+    }, ctx: {
+        facts: Facts<M["facts"]>;
+        signal?: AbortSignal;
+    }) => void | Promise<void>;
+    retry?: {
+        attempts?: number;
+        backoff?: "linear" | "exponential";
+        delay?: number;
+    };
+    timeout?: number;
+    key?: (req: {
+        type: string;
+        [key: string]: unknown;
+    }) => string;
+}
+/**
+ * Create a new module builder.
+ *
+ * @param id - The unique identifier for this module
+ * @returns A module builder
+ */
+declare function module$1(id: string): ModuleBuilder<ModuleSchema>;
+
+/**
+ * Constraint Builder API
+ *
+ * Fluent builders for creating typed constraint definitions.
+ *
+ * @example Full builder
+ * ```typescript
+ * import { constraint } from '@directive-run/core';
+ *
+ * const escalate = constraint<typeof schema>()
+ *   .when(f => f.confidence < 0.7)
+ *   .require({ type: 'ESCALATE' })
+ *   .priority(50)
+ *   .build();
+ * ```
+ *
+ * @example Quick shorthand
+ * ```typescript
+ * import { when } from '@directive-run/core';
+ *
+ * const pause = when<typeof schema>(f => f.errors > 3)
+ *   .require({ type: 'PAUSE' });
+ * ```
+ */
+
+type WhenFn<M extends ModuleSchema> = (facts: Facts<M["facts"]>) => boolean | Promise<boolean>;
+type RequireValue<M extends ModuleSchema> = RequirementOutput$1<InferRequirements<M>> | ((facts: Facts<M["facts"]>) => RequirementOutput$1<InferRequirements<M>>);
+/** Builder after constraint() — must call .when() first */
+interface ConstraintBuilderStart<M extends ModuleSchema> {
+    when(condition: WhenFn<M>): ConstraintBuilderWithWhen<M>;
+}
+/** Builder after .when() — must call .require() next */
+interface ConstraintBuilderWithWhen<M extends ModuleSchema> {
+    require(req: RequireValue<M>): ConstraintBuilderComplete<M>;
+}
+/** Builder after .require() — optional chaining + .build() */
+interface ConstraintBuilderComplete<M extends ModuleSchema> {
+    priority(n: number): ConstraintBuilderComplete<M>;
+    after(...ids: string[]): ConstraintBuilderComplete<M>;
+    deps(...keys: string[]): ConstraintBuilderComplete<M>;
+    timeout(ms: number): ConstraintBuilderComplete<M>;
+    async(value: boolean): ConstraintBuilderComplete<M>;
+    build(): TypedConstraintDef<M>;
+}
+/** Result from when().require() — a valid constraint with optional immutable chaining */
+type WhenConstraint<M extends ModuleSchema> = TypedConstraintDef<M> & {
+    withPriority(n: number): WhenConstraint<M>;
+    withAfter(...ids: string[]): WhenConstraint<M>;
+    withDeps(...keys: string[]): WhenConstraint<M>;
+    withTimeout(ms: number): WhenConstraint<M>;
+    withAsync(value: boolean): WhenConstraint<M>;
+};
+/** Result from when() — must call .require() */
+interface WhenBuilder<M extends ModuleSchema> {
+    require(req: RequireValue<M>): WhenConstraint<M>;
+}
+/**
+ * Create a constraint using the full builder pattern.
+ * Requires `.when()`, `.require()`, and `.build()`.
+ *
+ * @example
+ * ```typescript
+ * const c = constraint<typeof schema>()
+ *   .when(f => f.phase === "red")
+ *   .require({ type: "TRANSITION", to: "green" })
+ *   .priority(50)
+ *   .after("healthCheck")
+ *   .build();
+ * ```
+ */
+declare function constraint<M extends ModuleSchema>(): ConstraintBuilderStart<M>;
+/**
+ * Quick shorthand for creating constraints.
+ * Returns a valid constraint directly (no `.build()` needed).
+ *
+ * @example
+ * ```typescript
+ * const pause = when<typeof schema>(f => f.errors > 3)
+ *   .require({ type: 'PAUSE' });
+ *
+ * // With optional chaining (immutable — returns new constraint)
+ * const halt = when<typeof schema>(f => f.errors > 10)
+ *   .require({ type: 'HALT' })
+ *   .withPriority(100)
+ *   .withAfter('healthCheck');
+ * ```
+ */
+declare function when<M extends ModuleSchema>(condition: WhenFn<M>): WhenBuilder<M>;
+
+/**
+ * System Builder API
+ *
+ * Fluent builder for creating Directive systems.
+ *
+ * @example Single module
+ * ```typescript
+ * import { system } from '@directive-run/core';
+ *
+ * const sys = system()
+ *   .module(counterModule)
+ *   .plugins([loggingPlugin()])
+ *   .debug({ timeTravel: true })
+ *   .build();
+ * ```
+ *
+ * @example Multiple modules
+ * ```typescript
+ * const sys = system()
+ *   .modules({ auth: authModule, cart: cartModule })
+ *   .plugins([loggingPlugin()])
+ *   .build();
+ * ```
+ */
+
+/** Initial builder — must choose .module() or .modules() */
+interface SystemBuilderStart {
+    module<S extends ModuleSchema>(mod: ModuleDef<S>): SingleModuleSystemBuilder<S>;
+    modules<const Modules extends ModulesMap>(mods: Modules): NamespacedSystemBuilder<Modules>;
+}
+/** Builder for single-module system */
+interface SingleModuleSystemBuilder<S extends ModuleSchema> {
+    plugins(plugins: Array<Plugin<ModuleSchema>>): SingleModuleSystemBuilder<S>;
+    debug(config: DebugConfig): SingleModuleSystemBuilder<S>;
+    errorBoundary(config: ErrorBoundaryConfig): SingleModuleSystemBuilder<S>;
+    tickMs(ms: number): SingleModuleSystemBuilder<S>;
+    zeroConfig(enabled?: boolean): SingleModuleSystemBuilder<S>;
+    initialFacts(facts: Partial<InferFacts<S>>): SingleModuleSystemBuilder<S>;
+    build(): SingleModuleSystem<S>;
+}
+/** Builder for namespaced multi-module system */
+interface NamespacedSystemBuilder<Modules extends ModulesMap> {
+    plugins(plugins: Array<Plugin<ModuleSchema>>): NamespacedSystemBuilder<Modules>;
+    debug(config: DebugConfig): NamespacedSystemBuilder<Modules>;
+    errorBoundary(config: ErrorBoundaryConfig): NamespacedSystemBuilder<Modules>;
+    tickMs(ms: number): NamespacedSystemBuilder<Modules>;
+    zeroConfig(enabled?: boolean): NamespacedSystemBuilder<Modules>;
+    initialFacts(facts: Partial<{
+        [K in keyof Modules]: Partial<InferFacts<ExtractSchema<Modules[K]>>>;
+    }>): NamespacedSystemBuilder<Modules>;
+    initOrder(order: "auto" | "declaration" | Array<keyof Modules & string>): NamespacedSystemBuilder<Modules>;
+    build(): NamespacedSystem<Modules>;
+}
+/**
+ * Create a system using the fluent builder pattern.
+ * Choose `.module()` for single-module or `.modules()` for namespaced.
+ *
+ * @example
+ * ```typescript
+ * const sys = system()
+ *   .module(counterModule)
+ *   .plugins([loggingPlugin()])
+ *   .build();
+ * ```
+ */
+declare function system(): SystemBuilderStart;
+
+/**
+ * Requirement Status Utilities
+ *
+ * Provides reactive tracking of requirement status for UI feedback.
+ */
+
+/** Status of a requirement type */
+interface RequirementTypeStatus {
+    /** Number of pending (unmet) requirements of this type */
+    pending: number;
+    /** Number of inflight (being resolved) requirements of this type */
+    inflight: number;
+    /** Number of failed requirements of this type */
+    failed: number;
+    /** Whether any requirements of this type are loading (pending or inflight) */
+    isLoading: boolean;
+    /** Whether any requirements of this type have failed */
+    hasError: boolean;
+    /** Last error for this type (if any) */
+    lastError: Error | null;
+}
+/**
+ * Create a plugin that tracks requirement status for reactive UI updates.
+ *
+ * @example
+ * ```typescript
+ * import { createRequirementStatusPlugin } from '@directive-run/core';
+ *
+ * const statusPlugin = createRequirementStatusPlugin();
+ *
+ * const system = createSystem({
+ *   modules: [myModule],
+ *   plugins: [statusPlugin.plugin],
+ * });
+ *
+ * // Get status for a requirement type
+ * const status = statusPlugin.getStatus("FETCH_USER");
+ * console.log(status.isLoading, status.hasError);
+ *
+ * // Subscribe to status changes
+ * const unsubscribe = statusPlugin.subscribe(() => {
+ *   console.log("Status changed:", statusPlugin.getStatus("FETCH_USER"));
+ * });
+ * ```
+ */
+declare function createRequirementStatusPlugin(): {
+    plugin: Plugin<never>;
+    getStatus: (type: string) => RequirementTypeStatus;
+    getAllStatus: () => Map<string, RequirementTypeStatus>;
+    subscribe: (listener: () => void) => () => void;
+    reset: () => void;
+};
+/**
+ * Create a hook factory for requirement status.
+ * This is designed to be used with React's useSyncExternalStore.
+ *
+ * @example
+ * ```typescript
+ * import { useSyncExternalStore } from 'react';
+ * import { createRequirementStatusPlugin, createStatusHook } from '@directive-run/core';
+ *
+ * const statusPlugin = createRequirementStatusPlugin();
+ * const useRequirementStatus = createStatusHook(statusPlugin);
+ *
+ * function MyComponent() {
+ *   const status = useRequirementStatus("FETCH_USER");
+ *   if (status.isLoading) return <Spinner />;
+ *   if (status.hasError) return <Error error={status.lastError} />;
+ *   return <Content />;
+ * }
+ * ```
+ */
+declare function createStatusHook(statusPlugin: ReturnType<typeof createRequirementStatusPlugin>): (type: string) => RequirementTypeStatus;
+
+/**
+ * System with Status Plugin Helper
+ *
+ * Convenience function for creating a system with status tracking enabled.
+ */
+
+/** Options for createSystemWithStatus */
+interface CreateSystemWithStatusOptions<M extends ModuleSchema> {
+    /** The module to use for the system */
+    module: ModuleDef<M>;
+    /** Additional plugins to include alongside the status plugin */
+    plugins?: Plugin<any>[];
+    /** Debug configuration */
+    debug?: DebugConfig;
+    /** Error boundary configuration */
+    errorBoundary?: ErrorBoundaryConfig;
+    /** Tick interval in milliseconds */
+    tickMs?: number;
+    /** Enable zero-config mode */
+    zeroConfig?: boolean;
+    /** Initial facts to set on the system */
+    initialFacts?: Record<string, any>;
+}
+/** Return type for createSystemWithStatus */
+interface SystemWithStatus<M extends ModuleSchema> {
+    /**
+     * The Directive system instance.
+     * This is a SingleModuleSystem - use system.facts, system.dispatch(), etc.
+     */
+    system: SingleModuleSystem<M>;
+    /** The status plugin for use with useRequirementStatus hooks */
+    statusPlugin: ReturnType<typeof createRequirementStatusPlugin>;
+}
+/**
+ * Create a Directive system with a status plugin pre-configured.
+ *
+ * This is a convenience wrapper around `createSystem` and `createRequirementStatusPlugin`
+ * that handles the wiring automatically. The status plugin is added to the system's
+ * plugins array so it receives lifecycle events.
+ *
+ * @param options - System configuration options
+ * @returns An object containing both the system and the statusPlugin
+ *
+ * @example
+ * ```tsx
+ * import { createSystemWithStatus } from '@directive-run/core';
+ * import { useRequirementStatus, useFact } from '@directive-run/react';
+ *
+ * // Simple setup - no provider needed
+ * const { system, statusPlugin } = createSystemWithStatus({
+ *   module: myModule,
+ * });
+ * system.start();
+ *
+ * function App() {
+ *   const data = useFact(system, "data");
+ *   return <LoadingIndicator />;
+ * }
+ *
+ * function LoadingIndicator() {
+ *   const status = useRequirementStatus(statusPlugin, "FETCH_DATA");
+ *   if (status.isLoading) return <Spinner />;
+ *   if (status.hasError) return <Error message={status.lastError?.message} />;
+ *   return <Content />;
+ * }
+ * ```
+ */
+declare function createSystemWithStatus<M extends ModuleSchema>(options: CreateSystemWithStatusOptions<M>): SystemWithStatus<M>;
+
+/**
+ * Requirements - Typed requirement identity with custom dedupe keys
+ *
+ * Features:
+ * - Type-safe requirement definitions
+ * - Stable identity generation
+ * - Custom key functions for deduplication control
+ * - Requirement comparison and hashing
+ */
+
+/**
+ * Generate a stable ID for a requirement.
+ * Uses type + sorted properties by default.
+ */
+declare function generateRequirementId(req: Requirement, keyFn?: RequirementKeyFn): string;
+/**
+ * Helper to create typed requirements with a fluent API.
+ *
+ * Creates a factory function that produces requirements with a specific type.
+ * Useful for creating requirements in constraint definitions.
+ *
+ * @param type - The requirement type string
+ * @returns A factory function that creates requirements with the given type
+ *
+ * @example
+ * ```typescript
+ * // Create a requirement factory
+ * const fetchUser = req("FETCH_USER");
+ *
+ * // Use in constraint definition
+ * constraints: {
+ *   needsUser: {
+ *     when: (facts) => facts.userId && !facts.user,
+ *     require: fetchUser({ userId: 123, priority: "high" }),
+ *   },
+ * }
+ *
+ * // Results in: { type: "FETCH_USER", userId: 123, priority: "high" }
+ * ```
+ */
+declare function req<T extends string>(type: T): <P extends Record<string, unknown>>(props: P) => Requirement & {
+    type: T;
+} & P;
+/**
+ * Check if a requirement matches a type.
+ */
+declare function isRequirementType<T extends string>(req: Requirement, type: T): req is Requirement & {
+    type: T;
+};
+/**
+ * Create a type guard for resolver `requirement` predicate.
+ * Cleaner alternative to writing verbose type guards.
+ *
+ * @example
+ * ```typescript
+ * // With explicit requirement type (recommended for complex types)
+ * interface FetchUserRequirement { type: "FETCH_USER"; userId: string }
+ * requirement: forType<FetchUserRequirement>("FETCH_USER"),
+ * key: (req) => req.userId,  // req is FetchUserRequirement
+ *
+ * // Or simple string literal (for basic types)
+ * requirement: forType("FETCH_USER"),
+ * key: (req) => req.type,  // req is Requirement & { type: "FETCH_USER" }
+ * ```
+ */
+declare function forType<R extends Requirement>(type: R["type"]): (req: Requirement) => req is R;
+declare function forType<T extends string>(type: T): (req: Requirement) => req is Requirement & {
+    type: T;
+};
+/**
+ * A set of requirements with automatic deduplication by ID.
+ *
+ * Requirements are uniquely identified by their ID (generated from type + properties).
+ * When adding a requirement with a duplicate ID, the first one wins.
+ *
+ * @example
+ * ```typescript
+ * const set = new RequirementSet();
+ *
+ * // Add requirements
+ * set.add(createRequirementWithId({ type: "FETCH_USER", userId: 1 }, "constraint1"));
+ * set.add(createRequirementWithId({ type: "FETCH_USER", userId: 1 }, "constraint2")); // Ignored (duplicate)
+ *
+ * // Check and retrieve
+ * console.log(set.size); // 1
+ * console.log(set.has("FETCH_USER:{\"userId\":1}")); // true
+ *
+ * // Diff with another set
+ * const newSet = new RequirementSet();
+ * newSet.add(createRequirementWithId({ type: "FETCH_USER", userId: 2 }, "constraint1"));
+ * const { added, removed } = newSet.diff(set);
+ * // added: [{ type: "FETCH_USER", userId: 2 }]
+ * // removed: [{ type: "FETCH_USER", userId: 1 }]
+ * ```
+ */
+declare class RequirementSet {
+    private map;
+    /**
+     * Add a requirement to the set.
+     * If a requirement with the same ID already exists, it is ignored (first wins).
+     * @param req - The requirement with its computed ID
+     */
+    add(req: RequirementWithId): void;
+    /** Remove a requirement by ID */
+    remove(id: string): boolean;
+    /** Check if a requirement exists */
+    has(id: string): boolean;
+    /** Get a requirement by ID */
+    get(id: string): RequirementWithId | undefined;
+    /** Get all requirements */
+    all(): RequirementWithId[];
+    /** Get all requirement IDs */
+    ids(): string[];
+    /** Get the count of requirements */
+    get size(): number;
+    /** Clear all requirements */
+    clear(): void;
+    /** Create a copy */
+    clone(): RequirementSet;
+    /** Diff with another set - returns added and removed */
+    diff(other: RequirementSet): {
+        added: RequirementWithId[];
+        removed: RequirementWithId[];
+        unchanged: RequirementWithId[];
+    };
+}
+
+/**
+ * Derivations - Auto-tracked computed values with composition
+ *
+ * Features:
+ * - Automatic dependency tracking (no manual deps arrays)
+ * - Memoization with smart invalidation
+ * - Derivation composition (derivations can depend on other derivations)
+ * - Circular dependency detection
+ * - Lazy evaluation
+ */
+
+interface DerivationsManager<S extends Schema, D extends DerivationsDef<S>> {
+    /** Get a derived value (computes if stale) */
+    get<K extends keyof D>(id: K): ReturnType<D[K]>;
+    /** Check if a derivation is stale */
+    isStale(id: keyof D): boolean;
+    /** Invalidate derivations that depend on a fact key */
+    invalidate(factKey: string): void;
+    /** Invalidate derivations for multiple fact keys, notifying listeners once at the end */
+    invalidateMany(factKeys: Iterable<string>): void;
+    /** Invalidate all derivations */
+    invalidateAll(): void;
+    /** Subscribe to derivation changes */
+    subscribe(ids: Array<keyof D>, listener: () => void): () => void;
+    /** Get the proxy for composition */
+    getProxy(): DerivedValues<S, D>;
+    /** Get dependencies for a derivation */
+    getDependencies(id: keyof D): Set<string>;
+    /** Register new derivation definitions (for dynamic module registration) */
+    registerDefinitions(newDefs: DerivationsDef<S>): void;
+}
+/** Options for creating a derivations manager */
+interface CreateDerivationsOptions<S extends Schema, D extends DerivationsDef<S>> {
+    definitions: D;
+    facts: Facts<S>;
+    store: FactsStore<S>;
+    /** Callback when a derivation is computed */
+    onCompute?: (id: string, value: unknown, deps: string[]) => void;
+    /** Callback when a derivation is invalidated */
+    onInvalidate?: (id: string) => void;
+    /** Callback when a derivation errors */
+    onError?: (id: string, error: unknown) => void;
+}
+/**
+ * Create a manager for lazily-evaluated, auto-tracked derived values.
+ *
+ * Derivations are memoized computations that automatically track which facts
+ * they read. When a tracked fact changes, the derivation is invalidated and
+ * recomputed on next access. Derivations can depend on other derivations
+ * (composition), and circular dependencies are detected at compute time.
+ *
+ * Notifications are deferred during invalidation so listeners always see
+ * consistent state across multiple simultaneous fact changes.
+ *
+ * @param options - Derivation definitions, facts proxy, store, and optional lifecycle callbacks
+ * @returns A `DerivationsManager` with get/invalidate/subscribe/getProxy methods
+ */
+declare function createDerivationsManager<S extends Schema, D extends DerivationsDef<S>>(options: CreateDerivationsOptions<S, D>): DerivationsManager<S, D>;
+
+/**
+ * Effects - Fire-and-forget side effects
+ *
+ * Features:
+ * - Separate from requirement resolution
+ * - Error isolation (never breaks reconciliation)
+ * - Optional explicit dependencies for optimization
+ * - Runs after facts stabilize
+ *
+ * IMPORTANT: Auto-tracking limitations
+ * ------------------------------------
+ * When using auto-tracking (no explicit `deps`), only SYNCHRONOUS fact accesses
+ * are tracked. If your effect reads facts after an `await`, those reads are NOT
+ * tracked and won't trigger the effect on future changes.
+ *
+ * For async effects, always use explicit `deps`:
+ * @example
+ * ```typescript
+ * effects: {
+ *   // BAD: fetchData is async, facts.userId read after await won't be tracked
+ *   badEffect: {
+ *     run: async (facts) => {
+ *       await someAsyncOp();
+ *       console.log(facts.userId); // NOT tracked!
+ *     },
+ *   },
+ *   // GOOD: explicit deps for async effects
+ *   goodEffect: {
+ *     deps: ["userId"],
+ *     run: async (facts) => {
+ *       await someAsyncOp();
+ *       console.log(facts.userId); // Works because we declared the dep
+ *     },
+ *   },
+ * }
+ * ```
+ */
+
+interface EffectsManager<_S extends Schema = Schema> {
+    /** Run all effects that should trigger based on changes */
+    runEffects(changedKeys: Set<string>): Promise<void>;
+    /** Run all effects unconditionally */
+    runAll(): Promise<void>;
+    /** Disable an effect */
+    disable(id: string): void;
+    /** Enable an effect */
+    enable(id: string): void;
+    /** Check if an effect is enabled */
+    isEnabled(id: string): boolean;
+    /** Run all stored cleanup functions (called on system stop/destroy) */
+    cleanupAll(): void;
+    /** Register new effect definitions (for dynamic module registration) */
+    registerDefinitions(newDefs: EffectsDef<Schema>): void;
+}
+/** Options for creating an effects manager */
+interface CreateEffectsOptions<S extends Schema> {
+    definitions: EffectsDef<S>;
+    facts: Facts<S>;
+    store: FactsStore<S>;
+    /** Callback when an effect runs */
+    onRun?: (id: string) => void;
+    /** Callback when an effect errors */
+    onError?: (id: string, error: unknown) => void;
+}
+/**
+ * Create a manager for fire-and-forget side effects that run after facts
+ * stabilize.
+ *
+ * Effects support auto-tracked dependencies (re-tracked on every run to
+ * capture conditional reads) or explicit `deps` arrays. Each effect can
+ * return a cleanup function that runs before the next execution or on
+ * system stop. Errors in effects are isolated and never break the
+ * reconciliation loop.
+ *
+ * @param options - Effect definitions, facts proxy, store, and optional lifecycle callbacks
+ * @returns An `EffectsManager` with runEffects/runAll/enable/disable/cleanupAll methods
+ */
+declare function createEffectsManager<S extends Schema>(options: CreateEffectsOptions<S>): EffectsManager<S>;
+
+/**
+ * Constraints - Rules that produce requirements when conditions aren't met
+ *
+ * Features:
+ * - Sync and async constraint evaluation
+ * - Priority ordering (higher runs first)
+ * - Timeout handling for async constraints
+ * - Error isolation
+ */
+
+interface ConstraintsManager<_S extends Schema> {
+    /** Evaluate all constraints and return unmet requirements */
+    evaluate(changedKeys?: Set<string>): Promise<RequirementWithId[]>;
+    /** Get the current state of a constraint */
+    getState(id: string): ConstraintState | undefined;
+    /** Get all constraint states */
+    getAllStates(): ConstraintState[];
+    /** Disable a constraint */
+    disable(id: string): void;
+    /** Enable a constraint */
+    enable(id: string): void;
+    /** Invalidate constraints that depend on the given fact key */
+    invalidate(factKey: string): void;
+    /** Mark a constraint's resolver as completed (for `after` ordering) */
+    markResolved(constraintId: string): void;
+    /** Check if a constraint has been resolved (for `after` ordering) */
+    isResolved(constraintId: string): boolean;
+    /** Register new constraint definitions (for dynamic module registration) */
+    registerDefinitions(newDefs: ConstraintsDef<Schema>): void;
+}
+/** Options for creating a constraints manager */
+interface CreateConstraintsOptions<S extends Schema> {
+    definitions: ConstraintsDef<S>;
+    facts: Facts<S>;
+    /** Custom key functions for requirements (by constraint ID) */
+    requirementKeys?: Record<string, RequirementKeyFn>;
+    /** Default timeout for async constraints (ms) */
+    defaultTimeout?: number;
+    /** Callback when a constraint is evaluated */
+    onEvaluate?: (id: string, active: boolean) => void;
+    /** Callback when a constraint errors */
+    onError?: (id: string, error: unknown) => void;
+}
+/**
+ * Create a manager that evaluates constraint rules and produces unmet
+ * requirements.
+ *
+ * Constraints are evaluated in priority order (higher first), with
+ * topological ordering for same-priority constraints connected by `after`
+ * dependencies. Supports sync and async `when()` predicates, incremental
+ * evaluation based on changed fact keys, and per-constraint enable/disable.
+ *
+ * @param options - Constraint definitions, facts proxy, custom requirement key functions, and lifecycle callbacks
+ * @returns A `ConstraintsManager` with evaluate/invalidate/enable/disable/markResolved methods
+ */
+declare function createConstraintsManager<S extends Schema>(options: CreateConstraintsOptions<S>): ConstraintsManager<S>;
+
+/**
+ * Resolvers - Capability-based handlers for requirements
+ *
+ * Features:
+ * - Capability matching (handles predicate)
+ * - Custom dedupe keys
+ * - Retry policies with exponential backoff
+ * - Batched resolution for similar requirements
+ * - Cancellation via AbortController
+ */
+
+/** Inflight resolver info */
+interface InflightInfo {
+    id: string;
+    resolverId: string;
+    startedAt: number;
+}
+interface ResolversManager<_S extends Schema> {
+    /** Start resolving a requirement */
+    resolve(req: RequirementWithId): void;
+    /** Cancel a resolver by requirement ID */
+    cancel(requirementId: string): void;
+    /** Cancel all inflight resolvers */
+    cancelAll(): void;
+    /** Get status of a resolver by requirement ID */
+    getStatus(requirementId: string): ResolverStatus;
+    /** Get all inflight requirement IDs */
+    getInflight(): string[];
+    /** Get full info for all inflight resolvers */
+    getInflightInfo(): InflightInfo[];
+    /** Check if a requirement is being resolved */
+    isResolving(requirementId: string): boolean;
+    /** Process batched requirements (called periodically) */
+    processBatches(): void;
+    /** Register new resolver definitions (for dynamic module registration) */
+    registerDefinitions(newDefs: ResolversDef<Schema>): void;
+}
+/** Options for creating a resolvers manager */
+interface CreateResolversOptions<S extends Schema> {
+    definitions: ResolversDef<S>;
+    facts: Facts<S>;
+    store: FactsStore<S>;
+    /** Callback when a resolver starts */
+    onStart?: (resolver: string, req: RequirementWithId) => void;
+    /** Callback when a resolver completes */
+    onComplete?: (resolver: string, req: RequirementWithId, duration: number) => void;
+    /** Callback when a resolver errors */
+    onError?: (resolver: string, req: RequirementWithId, error: unknown) => void;
+    /** Callback when a resolver retries */
+    onRetry?: (resolver: string, req: RequirementWithId, attempt: number) => void;
+    /** Callback when a resolver is canceled */
+    onCancel?: (resolver: string, req: RequirementWithId) => void;
+    /** Callback when resolution cycle completes (for reconciliation) */
+    onResolutionComplete?: () => void;
+}
+/**
+ * Create a manager that fulfills requirements by matching them to resolver
+ * handlers.
+ *
+ * Resolvers are matched by requirement type (string or predicate). Each
+ * resolution runs with an `AbortController` for cancellation, configurable
+ * retry policies (none/linear/exponential backoff), and optional batching
+ * for grouping similar requirements. Duplicate in-flight requirements are
+ * automatically deduplicated.
+ *
+ * @param options - Resolver definitions, facts proxy, store, and lifecycle callbacks (onStart/onComplete/onError/onRetry/onCancel/onResolutionComplete)
+ * @returns A `ResolversManager` with resolve/cancel/cancelAll/getStatus/processBatches methods
+ */
+declare function createResolversManager<S extends Schema>(options: CreateResolversOptions<S>): ResolversManager<S>;
+
+/**
+ * Plugin Architecture - Extensible middleware for Directive
+ *
+ * Features:
+ * - Lifecycle hooks for all engine events
+ * - Multiple plugins can be composed
+ * - Plugins execute in registration order
+ */
+
+interface PluginManager<_S extends Schema = any> {
+    /** Register a plugin */
+    register(plugin: Plugin<any>): void;
+    /** Unregister a plugin by name */
+    unregister(name: string): void;
+    /** Get all registered plugins */
+    getPlugins(): Plugin<any>[];
+    emitInit(system: System<any>): Promise<void>;
+    emitStart(system: System<any>): void;
+    emitStop(system: System<any>): void;
+    emitDestroy(system: System<any>): void;
+    emitFactSet(key: string, value: unknown, prev: unknown): void;
+    emitFactDelete(key: string, prev: unknown): void;
+    emitFactsBatch(changes: FactChange[]): void;
+    emitDerivationCompute(id: string, value: unknown, deps: string[]): void;
+    emitDerivationInvalidate(id: string): void;
+    emitReconcileStart(snapshot: FactsSnapshot<any>): void;
+    emitReconcileEnd(result: ReconcileResult): void;
+    emitConstraintEvaluate(id: string, active: boolean): void;
+    emitConstraintError(id: string, error: unknown): void;
+    emitRequirementCreated(req: RequirementWithId): void;
+    emitRequirementMet(req: RequirementWithId, byResolver: string): void;
+    emitRequirementCanceled(req: RequirementWithId): void;
+    emitResolverStart(resolver: string, req: RequirementWithId): void;
+    emitResolverComplete(resolver: string, req: RequirementWithId, duration: number): void;
+    emitResolverError(resolver: string, req: RequirementWithId, error: unknown): void;
+    emitResolverRetry(resolver: string, req: RequirementWithId, attempt: number): void;
+    emitResolverCancel(resolver: string, req: RequirementWithId): void;
+    emitEffectRun(id: string): void;
+    emitEffectError(id: string, error: unknown): void;
+    emitSnapshot(snapshot: Snapshot): void;
+    emitTimeTravel(from: number, to: number): void;
+    emitError(error: DirectiveError): void;
+    emitErrorRecovery(error: DirectiveError, strategy: RecoveryStrategy): void;
+}
+/**
+ * Create a manager that broadcasts lifecycle events to registered plugins.
+ *
+ * Plugins are called in registration order. All hook invocations are
+ * wrapped in try-catch so a misbehaving plugin never breaks the engine.
+ * Duplicate plugin names are detected and the older registration is
+ * replaced with a warning.
+ *
+ * @returns A `PluginManager` with register/unregister/getPlugins and emit* methods for every lifecycle event
+ */
+declare function createPluginManager<S extends Schema = any>(): PluginManager<S>;
+
+/**
+ * Error Boundaries - Configurable error handling and recovery
+ *
+ * Features:
+ * - Catch errors in constraints/resolvers/effects/derivations
+ * - Configurable recovery strategies (skip, retry, retry-later, disable, throw)
+ * - Circuit breaker pattern for automatic failure protection
+ * - Error reporting to plugins
+ */
+
+/**
+ * Pending retry entry.
+ */
+interface PendingRetry {
+    source: ErrorSource;
+    sourceId: string;
+    context: unknown;
+    attempt: number;
+    nextRetryTime: number;
+    callback?: () => void;
+}
+/**
+ * Create a manager for deferred retry scheduling with exponential backoff.
+ *
+ * Retries are stored in a Map keyed by source ID. Each retry tracks its
+ * attempt number and next retry time. When `processDueRetries()` is called
+ * (typically during reconciliation), entries whose time has elapsed are
+ * returned and removed from the queue.
+ *
+ * @param config - Backoff configuration: `delayMs`, `maxRetries`, `backoffMultiplier`, `maxDelayMs`
+ * @returns A manager with `scheduleRetry`, `getPendingRetries`, `processDueRetries`, `cancelRetry`, and `clearAll` methods
+ */
+declare function createRetryLaterManager(config?: RetryLaterConfig): {
+    /** Schedule a retry */
+    scheduleRetry: (source: ErrorSource, sourceId: string, context: unknown, attempt: number, callback?: () => void) => PendingRetry | null;
+    /** Get pending retries */
+    getPendingRetries: () => PendingRetry[];
+    /** Process due retries */
+    processDueRetries: () => PendingRetry[];
+    /** Cancel a retry */
+    cancelRetry: (sourceId: string) => void;
+    /** Clear all pending retries */
+    clearAll: () => void;
+};
+interface ErrorBoundaryManager {
+    /** Handle an error from a specific source */
+    handleError(source: ErrorSource, sourceId: string, error: unknown, context?: unknown): RecoveryStrategy;
+    /** Get the last error */
+    getLastError(): DirectiveError | null;
+    /** Get all errors */
+    getAllErrors(): DirectiveError[];
+    /** Clear all errors */
+    clearErrors(): void;
+    /** Get retry-later manager */
+    getRetryLaterManager(): ReturnType<typeof createRetryLaterManager>;
+    /** Process due retries (call periodically or on reconcile) */
+    processDueRetries(): PendingRetry[];
+    /** Clear retry attempts for a source ID (call on success) */
+    clearRetryAttempts(sourceId: string): void;
+}
+/** Options for creating an error boundary manager */
+interface CreateErrorBoundaryOptions {
+    config?: ErrorBoundaryConfig;
+    /** Callback when an error occurs */
+    onError?: (error: DirectiveError) => void;
+    /** Callback when recovery is attempted */
+    onRecovery?: (error: DirectiveError, strategy: RecoveryStrategy) => void;
+}
+/**
+ * Create a manager that handles errors from constraints, resolvers, effects,
+ * and derivations with configurable per-source recovery strategies.
+ *
+ * Supported strategies: `"skip"` (ignore), `"retry"` (immediate),
+ * `"retry-later"` (deferred with backoff), `"disable"` (turn off source),
+ * and `"throw"` (re-throw). Recent errors are kept in a ring buffer
+ * (last 100) for inspection. The retry-later strategy delegates to an
+ * internal {@link createRetryLaterManager}.
+ *
+ * @param options - Error boundary configuration, plus `onError` and `onRecovery` callbacks for plugin integration
+ * @returns An `ErrorBoundaryManager` with handleError/getLastError/getAllErrors/clearErrors/processDueRetries methods
+ *
+ * @example
+ * ```ts
+ * const boundary = createErrorBoundaryManager({
+ *   config: {
+ *     onResolverError: "retry-later",
+ *     onEffectError: "skip",
+ *     retryLater: { maxRetries: 5, delayMs: 500 },
+ *   },
+ *   onError: (err) => console.error(err.source, err.message),
+ * });
+ *
+ * const strategy = boundary.handleError("resolver", "fetchUser", new Error("timeout"));
+ * // strategy === "retry-later"
+ * ```
+ */
+declare function createErrorBoundaryManager(options?: CreateErrorBoundaryOptions): ErrorBoundaryManager;
+
+/**
+ * Time-Travel Debugging - Snapshot-based state history
+ *
+ * Features:
+ * - Ring buffer of state snapshots
+ * - Go back/forward through history
+ * - Replay from any snapshot
+ * - Export/import state history
+ */
+
+interface TimeTravelManager<_S extends Schema> extends TimeTravelAPI {
+    /** Take a snapshot of current state */
+    takeSnapshot(trigger: string): Snapshot;
+    /** Restore facts from a snapshot */
+    restore(snapshot: Snapshot): void;
+    /** Check if time-travel is enabled */
+    readonly isEnabled: boolean;
+    /** True while restoring a snapshot (engine should skip reconciliation) */
+    readonly isRestoring: boolean;
+    /** Pause snapshot taking */
+    pause(): void;
+    /** Resume snapshot taking */
+    resume(): void;
+}
+/** Options for creating a time-travel manager */
+interface CreateTimeTravelOptions<S extends Schema> {
+    config: DebugConfig;
+    facts: Facts<S>;
+    store: FactsStore<S>;
+    /** Callback when a snapshot is taken */
+    onSnapshot?: (snapshot: Snapshot) => void;
+    /** Callback when time-travel occurs */
+    onTimeTravel?: (from: number, to: number) => void;
+}
+/**
+ * Create a snapshot-based time-travel debugger with a ring buffer of state
+ * history.
+ *
+ * Snapshots are taken automatically after fact changes (during
+ * reconciliation) and can be navigated with `goBack`/`goForward`/`goTo`.
+ * Changesets group multiple snapshots into a single undo/redo unit.
+ * The entire history can be exported to JSON and re-imported for
+ * cross-session debugging.
+ *
+ * @param options - Debug config (maxSnapshots, timeTravel flag), facts proxy, store, and snapshot/time-travel callbacks
+ * @returns A `TimeTravelManager` with takeSnapshot/restore/goBack/goForward/goTo/replay/export/import and changeset methods
+ */
+declare function createTimeTravelManager<S extends Schema>(options: CreateTimeTravelOptions<S>): TimeTravelManager<S>;
+/**
+ * Create a no-op time-travel manager used when `debug.timeTravel` is
+ * disabled. All methods are safe to call but perform no work.
+ *
+ * @returns A `TimeTravelManager` where every method is a no-op and `isEnabled` is `false`
+ */
+declare function createDisabledTimeTravel<S extends Schema>(): TimeTravelManager<S>;
+
+/**
+ * Engine - The core reconciliation loop
+ *
+ * The engine orchestrates:
+ * 1. Fact changes trigger reconciliation
+ * 2. Constraints produce requirements
+ * 3. Resolvers fulfill requirements
+ * 4. Effects run after stabilization
+ * 5. Derivations are invalidated and recomputed
+ */
+
+/**
+ * Create the core Directive reconciliation engine that wires facts, derivations,
+ * effects, constraints, resolvers, plugins, error boundaries, and time-travel
+ * into a single reactive system.
+ *
+ * This is the internal factory used by `createSystem`. Most users should call
+ * `createSystem` instead, which provides a friendlier API and handles module
+ * composition.
+ *
+ * @param config - Full system configuration: modules, plugins, error boundary settings, and debug options
+ * @returns A `System` instance with facts, derive, events, dispatch, subscribe, watch, settle, and lifecycle methods
+ *
+ * @example
+ * ```ts
+ * // Prefer createSystem for most use cases:
+ * import { createSystem, createModule, t } from "@directive-run/core";
+ *
+ * const counter = createModule("counter", {
+ *   schema: { count: t.number() },
+ *   init: (facts) => { facts.count = 0; },
+ * });
+ *
+ * const system = createSystem({ module: counter });
+ * system.start();
+ * system.facts.count = 42;
+ * ```
+ */
+declare function createEngine<S extends Schema>(config: SystemConfig<any>): System<any>;
+
+/**
+ * Dependency tracking context for auto-tracking derivations
+ *
+ * Uses a stack-based approach to handle nested derivation computations.
+ * When a derivation accesses a fact, the tracking context records it.
+ */
+
+/**
+ * Get the current tracking context.
+ * Returns null context if no tracking is active.
+ */
+declare function getCurrentTracker(): TrackingContext;
+/**
+ * Check if we're currently tracking dependencies.
+ */
+declare function isTracking(): boolean;
+/**
+ * Run a function with dependency tracking.
+ * Returns the computed value and the set of dependencies accessed.
+ */
+declare function withTracking<T>(fn: () => T): {
+    value: T;
+    deps: Set<string>;
+};
+/**
+ * Run a function without tracking.
+ * Useful for reading facts without creating dependencies.
+ */
+declare function withoutTracking<T>(fn: () => T): T;
+/**
+ * Track a specific key in the current context.
+ * No-op if not currently tracking.
+ */
+declare function trackAccess(key: string): void;
+
+/**
+ * @directive-run/core
+ *
+ * Constraint-driven runtime for TypeScript.
+ *
+ * Also available:
+ * - `@directive-run/core/plugins` – Logging, devtools, persistence, observability, circuit breaker
+ * - `@directive-run/core/testing` – Mock resolvers, fake timers, assertion helpers
+ * - `@directive-run/core/migration` – Redux/Zustand/XState migration codemods
+ * - `@directive-run/core/adapter-utils` – Shared framework adapter utilities
+ * - `@directive-run/core/worker` – Web Worker support
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Backoff strategy constants for retry policies.
+ * Use for autocomplete when configuring resolver retry policies.
+ *
+ * @example
+ * ```ts
+ * import { Backoff } from '@directive-run/core';
+ *
+ * const resolver = {
+ *   requirement: "FETCH_DATA",
+ *   retry: {
+ *     attempts: 3,
+ *     backoff: Backoff.Exponential, // Autocomplete-friendly!
+ *     initialDelay: 100,
+ *   },
+ *   resolve: async (req, ctx) => { ... },
+ * };
+ * ```
+ */
+declare const Backoff: {
+    /** No delay between retries */
+    readonly None: "none";
+    /** Linear delay increase (initialDelay * attempt) */
+    readonly Linear: "linear";
+    /** Exponential delay increase (initialDelay * 2^attempt) */
+    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, 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 };