@directive-run/core 0.8.7 → 0.8.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (36) hide show
  1. package/dist/adapter-utils.cjs +1 -1
  2. package/dist/adapter-utils.js +1 -1
  3. package/dist/{chunk-W4VP6SVP.cjs → chunk-CFSW3RP5.cjs} +3 -3
  4. package/dist/{chunk-W4VP6SVP.cjs.map → chunk-CFSW3RP5.cjs.map} +1 -1
  5. package/dist/{chunk-O75OISQ2.js → chunk-EFBBEXDA.js} +2 -2
  6. package/dist/{chunk-O75OISQ2.js.map → chunk-EFBBEXDA.js.map} +1 -1
  7. package/dist/chunk-ER6QUYTL.cjs +2 -0
  8. package/dist/{chunk-PK2EH26L.cjs.map → chunk-ER6QUYTL.cjs.map} +1 -1
  9. package/dist/chunk-ISYFVEHR.js +3 -0
  10. package/dist/chunk-ISYFVEHR.js.map +1 -0
  11. package/dist/chunk-L3SUAAPM.cjs +3 -0
  12. package/dist/chunk-L3SUAAPM.cjs.map +1 -0
  13. package/dist/{chunk-KXIHB2EB.js → chunk-LB6PNML4.js} +3 -3
  14. package/dist/{chunk-KXIHB2EB.js.map → chunk-LB6PNML4.js.map} +1 -1
  15. package/dist/index.cjs +1 -1
  16. package/dist/index.js +1 -1
  17. package/dist/internals.cjs +1 -1
  18. package/dist/internals.d.cts +4 -0
  19. package/dist/internals.d.ts +4 -0
  20. package/dist/internals.js +1 -1
  21. package/dist/system-3H5V4HJZ.js +2 -0
  22. package/dist/{system-QNIJLXKW.js.map → system-3H5V4HJZ.js.map} +1 -1
  23. package/dist/system-IJKVTF3C.cjs +2 -0
  24. package/dist/{system-HQCNSUY5.cjs.map → system-IJKVTF3C.cjs.map} +1 -1
  25. package/dist/testing.cjs +1 -1
  26. package/dist/testing.js +1 -1
  27. package/dist/worker.cjs +1 -1
  28. package/dist/worker.js +1 -1
  29. package/package.json +1 -1
  30. package/dist/chunk-FVPJU5F3.js +0 -3
  31. package/dist/chunk-FVPJU5F3.js.map +0 -1
  32. package/dist/chunk-PK2EH26L.cjs +0 -2
  33. package/dist/chunk-SGMWAVHO.cjs +0 -3
  34. package/dist/chunk-SGMWAVHO.cjs.map +0 -1
  35. package/dist/system-HQCNSUY5.cjs +0 -2
  36. package/dist/system-QNIJLXKW.js +0 -2
package/dist/chunk-SGMWAVHO.cjs.map DELETED
@@ -1 +0,0 @@
1
- {"version":3,"sources":["../src/core/types/errors.ts","../src/core/types/helpers.ts","../src/core/types/composition.ts","../src/utils/history.ts","../src/core/requirements.ts","../src/core/constraints.ts","../src/core/derivations.ts","../src/core/effects.ts","../src/core/errors.ts","../src/core/facts.ts","../src/core/plugins.ts","../src/core/resolvers.ts","../src/core/engine-accessors.ts","../src/core/engine-definitions.ts","../src/core/engine-trace.ts","../src/core/engine.ts"],"names":["DirectiveError","message","source","sourceId","context","recoverable","createConstraintFactory","constraint","createResolverFactory","resolver","typedConstraint","typedResolver","isSingleModuleSystem","system","isNamespacedSystem","resolveHistoryOption","option","createHistoryManager","options","historyOption","facts","store","onSnapshot","onHistoryChange","isEnabled","maxSnapshots","snapshots","currentIndex","nextId","paused","restoring","changesets","pendingChangesetLabel","pendingChangesetStart","getCurrentFacts","serializeFacts","factsObj","deserializeFacts","serialized","isPrototypeSafe","key","value","trigger","snapshot","steps","fromIndex","toIndex","cs","c","earlierCs","snapshotId","index","s","json","data","snap","error","label","createDisabledHistory","noopSnapshot","reqIdCache","generateRequirementId","req","keyFn","cached","type","rest","sortedRest","stableStringify","id","createRequirementWithId","requirement","fromConstraint","props","isRequirementType","forType","RequirementSet","_RequirementSet","copy","other","added","removed","unchanged","DEFAULT_TIMEOUT","createConstraintsManager","definitions","requirementKeys","defaultTimeout","onEvaluate","onError","states","disabled","asyncConstraintIds","constraintDeps","factToConstraints","dirtyConstraints","latestWhenDeps","lastRequirements","hasEvaluated","resolvedConstraints","noFireConstraints","dependsOnMe","topologicalOrder","topologicalIndex","addReverseDep","depId","dependentId","buildReverseDependencyMap","def","topoVisit","path","visited","visiting","postOrder","cycleStart","cycle","detectCyclesAndComputeTopoOrder","warnUnknownAfterRefs","isAsyncConstraint","initState","isAsync","state","getState","depsEqual","a","b","dep","removeFromFactMap","deps","constraints","addToFactMap","clearConstraintDeps","clearReverseDeps","depSet","updateDependencies","newDeps","oldDeps","evaluateWhenPredicate","tracked","withTracking","recordConstraintResult","result","recordConstraintError","handleRuntimeAsyncResult","promise","asyncResult","evaluateSync","evaluateAsync","timeout","depsSet","resultPromise","withTimeout","MAX_REQUIREMENTS_WARNING_THRESHOLD","normalizeRequirements","output","constraintId","filtered","r","getRequirements","requireDef","mergeDependencies","additionalDeps","existingDeps","sortedConstraintIds","getSortedConstraintIds","stateA","priorityDiff","topoA","topoB","warnAsyncWithoutDeps","defs","isAfterDepSatisfied","areAfterDependenciesSatisfied","handleInactiveConstraint","whenDeps","updateConstraintDeps","requireDeps","combinedDeps","emitConstraintRequirements","reqs","requirements","reqsWithId","reqWithId","addCachedRequirements","processConstraintResult","active","partitionByReadiness","constraintIds","blocked","ready","lastReqs","evaluateSyncBatch","syncIds","unexpectedAsync","awaitAndProcess","pairs","results","evaluateConstraintBatch","syncConstraints","asyncConstraints","asyncPairs","collectAffectedByKeys","changedKeys","into","collectDirtyConstraints","computeAffectedConstraints","affected","carryForwardRequirements","allIds","allConstraintIds","constraintsToEvaluate","remainingToEvaluate","maxPasses","previousRemaining","factKey","dependentConstraints","dependents","newDefs","hasAfterDeps","merged","requirementType","createDerivationsManager","onCompute","onInvalidate","listeners","factToDerivedDeps","derivedToDerivedDeps","invalidationDepth","pendingNotifications","isFlushing","MAX_FLUSH_ITERATIONS","derivedProxy","removeDepLink","map","addDepLink","removeOwnDepLinks","invalidateDependentsOf","dependent","invalidateDerivation","purgeFromMaps","computeDerivation","oldValue","setsEqual","notifyListeners","ids","fns","listener","flushNotifications","iterations","remaining","enqueueDependents","queue","startId","_","prop","BLOCKED_PROPS","trackAccess","factKeys","idStr","listenerSet","fn","STABLE_THRESHOLD","createEffectsManager","onRun","previousSnapshot","stopped","createSnapshot","resetStability","hasOverlap","shouldRun","runCleanup","storeCleanup","runBatchedEffect","effectPromise","areDepsEqual","updateDepStability","trackedDeps","runAutoTrackedEffect","trackingResult","runEffect","effectsToRun","effectIds","createRetryLaterManager","config","delayMs","maxRetries","backoffMultiplier","maxDelayMs","pendingRetries","calculateDelay","attempt","delay","callback","entry","now","dueRetries","DEFAULT_STRATEGIES","createErrorBoundaryManager","onRecovery","errors","maxErrors","retryLaterManager","retryAttempts","MAX_RETRY_SOURCES","toDirectiveError","getStrategy","handler","e","recordAndNotifyError","directiveError","processRetryLater","oldest","strategy","safeStringify","maxLength","createFactsStore","schema","onChange","onBatch","isTypeAssertionSchema","validate","strictKeys","redactErrors","knownKeys","keyListeners","allListeners","batching","batchChanges","dirtyKeys","isNotifying","pendingNonBatchedChanges","MAX_NOTIFY_ITERATIONS","isZodSchema","getExpectedType","schemaType","st","formatValueForError","describeValueType","validateZod","valueType","valuePreview","errorMessage","expectedType","getIndexHint","hint","validateSchemaType","validators","i","validator","indexHint","validatorHint","validateUnknownKey","validateValue","notifyKey","notifyAll","notifyNonBatched","prev","drainDeferredNotifications","deferred","change","flush","keys","keyStr","set","newSchema","nestedProxyCache","wrapWithNestedWarning","obj","rootKey","target","wrapped","newValue","createFactsProxy","withoutTracking","createFacts","createPluginManager","plugins","safeCall","safeCallAsync","broadcast","hook","args","plugin","p","name","DEFAULT_RETRY","DEFAULT_BATCH","policy","backoff","initialDelay","maxDelay","validateDefinitions","createResolversManager","onStart","onComplete","onRetry","onCancel","onResolutionComplete","inflight","statuses","MAX_STATUSES","batches","resolversByType","MAX_RESOLVER_CACHE","cleanupStatuses","entriesToRemove","iterator","hasStringRequirement","hasFunctionRequirement","resolverHandles","findResolverInCache","reqType","cacheResolverForType","resolverId","findResolver","createContext","signal","handleRetryError","retryPolicy","controller","normalizedError","resolve","timeoutId","abortHandler","invokeResolve","resolvePromise","recordSuccess","startedAt","duration","recordError","attempts","updateInflightAttempt","reqId","processRetryError","notifyRetry","executeResolve","lastError","outcome","next","awaitWithTimeout","timeoutMessage","executeWithResults","reqPayloads","ctx","hasFailures","executeAllOrNothing","recordBatchErrors","executeBatchFallback","executeBatchAttempt","notifyBatchRetry","nextAttempt","runBatchRetryLoop","executeBatch","DEFAULT_MAX_QUEUE_SIZE","clearBatchTimer","batch","ensureBatch","addToBatch","batchConfig","effectiveMax","processBatch","requirementId","idx","status","createDeriveAccessor","mergedDerive","getDerivation","deriveMethods","createEventsAccessor","mergedEvents","dispatchEvent","payload","RESERVED_DERIVE_NAMES","createDefinitionsRegistry","mergedConstraints","mergedResolvers","mergedEffects","constraintsManager","resolversManager","derivationsManager","effectsManager","pluginManager","scheduleReconcile","maxDeferredRegistrations","dynamicIds","originals","deferredRegistrations","validateDerivationId","typeDescriptors","validateDefId","applyRegister","desc","applyAssign","original","applyUnregister","flushDeferred","ops","op","guardedOp","isDestroyed","isReconciling","createTraceManager","traceConfig","maxRuns","traceEntries","traceById","traceIdCounter","currentTrace","pendingFactChanges","resolverTraceMap","traceInflightCount","traceStartMs","traceCache","traceCacheVersion","currentCacheVersion","traceStats","finalizeTrace","traceId","startMs","buildCausalChain","updateTraceStats","decrementTraceInflightInternal","evictOldestTrace","evicted","rId","parts","fc","d","rs","resolverCount","factChangeCount","anomalies","pushTraceEntry","hasTraceActivity","reconcileStartMs","inflightCount","createEngine","mergedSchema","schemaOwners","definitionOwners","module","validateKeys","section","existingOwner","checkCollisions","owner","snapshotEventNames","m","mod","eventName","dispatchDepth","shouldTakeSnapshot","derivationNames","errorBoundary","retryLaterTimer","invalidateManyDerivations","historyRef","traceManager","traceEnabled","changes","syncResolverKeys","notifySettlementChange","historyListeners","notifyHistoryChange","historyManager","from","to","settlementListeners","MAX_RECONCILE_DEPTH","MAX_DEFERRED_REGISTRATIONS","reconcileDepth","reconcile","keysForConstraints","currentRequirements","currentSet","hitConstraintIds","cId","cState","cDeps","inflightNow","inflightById","info","inflightInfo","inflightMap","dispatchEventByName","deriveAccessor","eventsAccessor","intervalMs","event","derivationId","derivationIds","unsubs","u","isEqual","previousValue","old","predicate","reject","unsub","timer","cleanup","current","constraintState","resolverStatus","relevantFacts","lines","reqDetails","k","v","factEntries","prefix","valueStr","maxWait","isSettled","done","unsubscribe","details","unmet","includeDerivations","excludeDerivations","includeFacts","ttlSeconds","metadata","includeVersion","allDerivationKeys","allDerivationSet","derivationKeys","unknown","excludeSet","factsSnapshot","allFactKeys","createdAt","hashObject","previousVersion","registerModule","existingFactKeys"],"mappings":"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","file":"chunk-SGMWAVHO.cjs","sourcesContent":["/**\n * Error Types - Type definitions for error handling\n */\n\n// ============================================================================\n// Error Types\n// ============================================================================\n\n/** Error source types */\nexport type ErrorSource =\n | \"constraint\"\n | \"resolver\"\n | \"effect\"\n | \"derivation\"\n | \"system\";\n\n/**\n * Extended Error class with source tracking, recovery metadata, and\n * arbitrary context for structured error handling within Directive.\n *\n * Thrown or returned by the error boundary manager. The `source` and\n * `sourceId` fields identify where the error originated, and `recoverable`\n * indicates whether the engine can apply a recovery strategy.\n *\n * @param message - Human-readable error description\n * @param source - Which subsystem produced the error (`\"constraint\"`, `\"resolver\"`, `\"effect\"`, `\"derivation\"`, or `\"system\"`)\n * @param sourceId - The ID of the specific constraint, resolver, effect, or derivation that failed\n * @param context - Optional arbitrary data for debugging (e.g., the requirement that triggered a resolver error)\n * @param recoverable - Whether the error boundary can apply a recovery strategy (default `true`; `false` for system errors)\n *\n * @example\n * ```ts\n * try {\n * await system.settle();\n * } catch (err) {\n * if (err instanceof DirectiveError) {\n * console.log(err.source); // \"resolver\"\n * console.log(err.sourceId); // \"fetchUser\"\n * console.log(err.recoverable); // true\n * }\n * }\n * ```\n */\nexport class DirectiveError extends Error {\n constructor(\n message: string,\n public readonly source: ErrorSource,\n public readonly sourceId: string,\n public readonly context?: unknown,\n public readonly recoverable: boolean = true,\n ) {\n super(message);\n this.name = \"DirectiveError\";\n }\n}\n\n/** Recovery strategy for errors */\nexport type RecoveryStrategy =\n | \"skip\"\n | \"retry\"\n | \"retry-later\"\n | \"disable\"\n | \"throw\";\n\n/**\n * Configuration for retry-later strategy.\n * When an error occurs, the system will wait for `delayMs` before retrying.\n */\nexport interface RetryLaterConfig {\n /** Delay in milliseconds before retrying (default: 1000) */\n delayMs?: number;\n /** Maximum retries before giving up (default: 3) */\n maxRetries?: number;\n /** Backoff multiplier for each retry (default: 2) */\n backoffMultiplier?: number;\n /** Maximum delay in milliseconds (default: 30000) */\n maxDelayMs?: number;\n}\n\n/** Error boundary configuration */\nexport interface ErrorBoundaryConfig {\n onConstraintError?:\n | RecoveryStrategy\n // biome-ignore lint/suspicious/noConfusingVoidType: void semantics needed for implicit no-return\n | ((error: Error, constraint: string) => RecoveryStrategy | void);\n onResolverError?:\n | RecoveryStrategy\n // biome-ignore lint/suspicious/noConfusingVoidType: void semantics needed for implicit no-return\n | ((error: Error, resolver: string) => RecoveryStrategy | void);\n onEffectError?:\n | RecoveryStrategy\n // biome-ignore lint/suspicious/noConfusingVoidType: void semantics needed for implicit no-return\n | ((error: Error, effect: string) => RecoveryStrategy | void);\n onDerivationError?:\n | RecoveryStrategy\n // biome-ignore lint/suspicious/noConfusingVoidType: void semantics needed for implicit no-return\n | ((error: Error, derivation: string) => RecoveryStrategy | void);\n onError?: (error: DirectiveError) => void;\n\n /** Configuration for retry-later strategy */\n retryLater?: RetryLaterConfig;\n}\n","/**\n * Type Helpers - External typed constraint and resolver definitions\n *\n * These types enable defining constraints and resolvers with full type safety\n * outside of module definitions, while maintaining proper type inference.\n */\n\nimport type { Facts } from \"./facts.js\";\nimport type { Requirement, RequirementOutput } from \"./requirements.js\";\nimport type { BatchConfig, ResolverContext, RetryPolicy } from \"./resolvers.js\";\nimport type { Schema } from \"./schema.js\";\n\n// ============================================================================\n// Typed Constraint Definition\n// ============================================================================\n\n/**\n * External constraint definition with full typing.\n * Use this when defining constraints outside of createModule().\n *\n * @typeParam S - The schema type\n * @typeParam R - The requirement type (defaults to Requirement)\n *\n * @example\n * ```typescript\n * // Define a typed constraint factory\n * const createMaxCountConstraint = <S extends Schema>(\n * maxCount: number\n * ): TypedConstraint<S, { type: \"RESET_COUNT\" }> => ({\n * priority: 10,\n * when: (facts) => (facts as { count: number }).count > maxCount,\n * require: { type: \"RESET_COUNT\" },\n * });\n *\n * // Use in module\n * const module = createModule(\"counter\", {\n * schema: { count: t.number() },\n * constraints: {\n * maxCount: createMaxCountConstraint(100),\n * },\n * });\n * ```\n */\nexport interface TypedConstraint<\n S extends Schema,\n R extends Requirement = Requirement,\n> {\n /** Priority for ordering (higher runs first) */\n priority?: number;\n /** Mark this constraint as async (avoids runtime detection) */\n async?: boolean;\n /** Condition function (sync or async) */\n when: (facts: Facts<S>) => boolean | Promise<boolean>;\n /**\n * Requirement(s) to produce when condition is met.\n */\n require: RequirementOutput<R> | ((facts: Facts<S>) => RequirementOutput<R>);\n /** Timeout for async constraints (ms) */\n timeout?: number;\n /**\n * Constraint IDs whose resolvers must complete before this constraint is evaluated.\n * - If dependency's `when()` returns false, this constraint proceeds (nothing to wait for)\n * - If dependency's resolver fails, this constraint remains blocked until it succeeds\n * - Cross-module: use the constraint ID as it appears in the merged system\n */\n after?: string[];\n}\n\n// ============================================================================\n// Typed Resolver Definition\n// ============================================================================\n\n/**\n * External resolver definition with full typing.\n * Use this when defining resolvers outside of createModule().\n *\n * @typeParam S - The schema type\n * @typeParam R - The requirement type (defaults to Requirement)\n *\n * @example\n * ```typescript\n * // Define a typed resolver factory\n * interface FetchUserReq extends Requirement {\n * type: \"FETCH_USER\";\n * userId: string;\n * }\n *\n * const createFetchUserResolver = <S extends Schema>(\n * fetchFn: (userId: string) => Promise<User>\n * ): TypedResolver<S, FetchUserReq> => ({\n * requirement: (req): req is FetchUserReq => req.type === \"FETCH_USER\",\n * key: (req) => `fetch-user-${req.userId}`,\n * retry: { attempts: 3, backoff: \"exponential\" },\n * resolve: async (req, ctx) => {\n * const user = await fetchFn(req.userId);\n * (ctx.facts as { user: User }).user = user;\n * },\n * });\n * ```\n */\nexport interface TypedResolver<\n S extends Schema,\n R extends Requirement = Requirement,\n> {\n /**\n * Requirement type to handle.\n * - String: matches `req.type` directly (e.g., `requirement: \"FETCH_USER\"`)\n * - Function: type guard predicate (e.g., `requirement: (req) => req.type === \"FETCH_USER\"`)\n */\n requirement: R[\"type\"] | ((req: Requirement) => req is R);\n /** Custom key function for deduplication */\n key?: (req: R) => string;\n /** Retry policy */\n retry?: RetryPolicy;\n /** Timeout for resolver execution (ms) */\n timeout?: number;\n /** Batch configuration */\n batch?: BatchConfig;\n /** Resolve function for single requirement */\n resolve?: (req: R, ctx: ResolverContext<S>) => Promise<void>;\n /** Resolve function for batched requirements */\n resolveBatch?: (reqs: R[], ctx: ResolverContext<S>) => Promise<void>;\n}\n\n// ============================================================================\n// Factory Functions\n// ============================================================================\n\n/**\n * Create a typed constraint factory for a specific schema.\n * This enables creating reusable constraint definitions with proper typing.\n *\n * @example\n * ```typescript\n * const schema = { count: t.number(), threshold: t.number() };\n * const factory = createConstraintFactory<typeof schema>();\n *\n * const maxCountConstraint = factory.create({\n * when: (facts) => facts.count > facts.threshold,\n * require: { type: \"RESET\" },\n * });\n * ```\n */\nexport function createConstraintFactory<S extends Schema>() {\n return {\n /**\n * Create a typed constraint\n */\n create<R extends Requirement = Requirement>(\n constraint: TypedConstraint<S, R>,\n ): TypedConstraint<S, R> {\n return constraint;\n },\n };\n}\n\n/**\n * Create a typed resolver factory for a specific schema.\n * This enables creating reusable resolver definitions with proper typing.\n *\n * @example\n * ```typescript\n * const schema = { user: t.object<User>() };\n * const factory = createResolverFactory<typeof schema>();\n *\n * const fetchUserResolver = factory.create<FetchUserReq>({\n * requirement: (req): req is FetchUserReq => req.type === \"FETCH_USER\",\n * resolve: async (req, ctx) => {\n * ctx.facts.user = await fetchUser(req.userId);\n * },\n * });\n * ```\n */\nexport function createResolverFactory<S extends Schema>() {\n return {\n /**\n * Create a typed resolver\n */\n create<R extends Requirement = Requirement>(\n resolver: TypedResolver<S, R>,\n ): TypedResolver<S, R> {\n return resolver;\n },\n };\n}\n\n// ============================================================================\n// Simple Helper Functions\n// ============================================================================\n\n/**\n * Type-safe constraint creator.\n * Simpler alternative to createConstraintFactory when you don't need a factory pattern.\n *\n * @example\n * ```typescript\n * const constraint = typedConstraint<typeof schema, { type: \"RESET\" }>({\n * when: (facts) => facts.count > 100,\n * require: { type: \"RESET\" },\n * });\n * ```\n */\nexport function typedConstraint<\n S extends Schema,\n R extends Requirement = Requirement,\n>(constraint: TypedConstraint<S, R>): TypedConstraint<S, R> {\n return constraint;\n}\n\n/**\n * Type-safe resolver creator.\n * Simpler alternative to createResolverFactory when you don't need a factory pattern.\n *\n * @example\n * ```typescript\n * const resolver = typedResolver<typeof schema, FetchUserReq>({\n * requirement: (req): req is FetchUserReq => req.type === \"FETCH_USER\",\n * resolve: async (req, ctx) => {\n * ctx.facts.user = await fetchUser(req.userId);\n * },\n * });\n * ```\n */\nexport function typedResolver<\n S extends Schema,\n R extends Requirement = Requirement,\n>(resolver: TypedResolver<S, R>): TypedResolver<S, R> {\n return resolver;\n}\n","/**\n * Composition Types - Type definitions for single and multi-module systems\n *\n * Single module = direct access (no namespace):\n * @example\n * ```typescript\n * const system = createSystem({ modules: counterModule });\n * system.facts.count // Direct access\n * system.events.increment() // Direct events\n * ```\n *\n * Multiple modules = namespaced access:\n * @example\n * ```typescript\n * const system = createSystem({\n * modules: { auth: authModule, data: dataModule },\n * });\n * system.facts.auth.token // Namespaced access\n * system.derive.data.userCount // Namespaced derivations\n * system.events.auth.login() // Namespaced events\n * ```\n */\n\nimport type { ErrorBoundaryConfig } from \"./errors.js\";\nimport type { Facts } from \"./facts.js\";\nimport type { ModuleDef } from \"./module.js\";\nimport type { Plugin } from \"./plugins.js\";\nimport type {\n InferDerivations,\n InferEvents,\n InferFacts,\n ModuleSchema,\n} from \"./schema.js\";\nimport type {\n ConstraintsControl,\n DerivationsControl,\n DistributableSnapshot,\n DistributableSnapshotOptions,\n EffectsControl,\n HistoryAPI,\n HistoryOption,\n ResolversControl,\n SystemInspection,\n SystemSnapshot,\n TraceEntry,\n TraceOption,\n} from \"./system.js\";\n\n// ============================================================================\n// Module Map Types\n// ============================================================================\n\n/**\n * Extract the schema type from a module definition.\n */\nexport type ExtractSchema<M> = M extends ModuleDef<infer S> ? S : never;\n\n/**\n * Map of module name to module definition (object form).\n *\n * Uses `ModuleDef<any>` instead of `ModuleDef<ModuleSchema>` to preserve\n * specific schema types during inference. The actual schema types are\n * extracted via `ExtractSchema<M>` where needed.\n */\n// biome-ignore lint/suspicious/noExplicitAny: Required for TypeScript to preserve specific module schema types during inference\nexport type ModulesMap = Record<string, ModuleDef<any>>;\n\n// ============================================================================\n// Cross-Module Facts Types (for module-level type hints)\n// ============================================================================\n\n/**\n * Map of module name to schema (for cross-module typing).\n */\nexport type SchemasMap = Record<string, ModuleSchema>;\n\n/**\n * Create namespaced facts type from a map of schemas.\n * Use this to type cross-module effects and constraints within modules.\n *\n * @example\n * ```typescript\n * // types.ts - Create the combined type from schemas\n * import { authSchema } from './modules/auth';\n * import { dataSchema } from './modules/data';\n * import { uiSchema } from './modules/ui';\n * import type { CrossModuleFacts } from '@directive-run/core';\n *\n * export type AllFacts = CrossModuleFacts<{\n * auth: typeof authSchema;\n * data: typeof dataSchema;\n * ui: typeof uiSchema;\n * }>;\n *\n * // modules/ui.ts - Use the combined type in effects\n * import type { AllFacts } from '../types';\n *\n * effects: {\n * onAuthChange: {\n * run: (facts: AllFacts, prev: AllFacts | undefined) => {\n * facts.auth.isAuthenticated // ✅ typed!\n * facts.data.users // ✅ typed!\n * }\n * }\n * }\n * ```\n */\nexport type CrossModuleFacts<Schemas extends SchemasMap> = {\n [K in keyof Schemas]: InferFacts<Schemas[K]>;\n};\n\n/**\n * Create namespaced derivations type from a map of schemas.\n * Use this to type cross-module effects that read derivations.\n *\n * @example\n * ```typescript\n * import type { CrossModuleDerivations } from '@directive-run/core';\n *\n * export type AllDerivations = CrossModuleDerivations<{\n * auth: typeof authSchema;\n * data: typeof dataSchema;\n * }>;\n * ```\n */\nexport type CrossModuleDerivations<Schemas extends SchemasMap> = {\n readonly [K in keyof Schemas]: InferDerivations<Schemas[K]>;\n};\n\n// ============================================================================\n// Cross-Module Dependencies Types (for module-level crossModuleDeps)\n// ============================================================================\n\n/**\n * Map of namespace to schema for cross-module dependencies.\n * Used in module config to declare type-safe access to other modules' facts.\n */\nexport type CrossModuleDeps = Record<string, ModuleSchema>;\n\n/**\n * Cross-module facts type using \"self\" for own module.\n * Own module accessed via `facts.self.*`, dependencies via `facts.{dep}.*`.\n *\n * @example\n * ```typescript\n * // For a \"data\" module with crossModuleDeps: { auth: authSchema }\n * facts.self.users // ✅ own module via \"self\"\n * facts.auth.isAuthenticated // ✅ cross-module via namespace\n * ```\n */\nexport type CrossModuleFactsWithSelf<\n OwnSchema extends ModuleSchema,\n Deps extends CrossModuleDeps,\n> = { self: InferFacts<OwnSchema> } & {\n [K in keyof Deps]: InferFacts<Deps[K]>;\n};\n\n// ============================================================================\n// Namespaced Facts Types\n// ============================================================================\n\n/**\n * Namespace facts under module keys.\n * `facts.auth.token` instead of `facts.auth_token`\n */\nexport type NamespacedFacts<Modules extends ModulesMap> = {\n readonly [K in keyof Modules]: InferFacts<ExtractSchema<Modules[K]>>;\n};\n\n/**\n * Mutable version for constraint/resolver callbacks.\n */\nexport type MutableNamespacedFacts<Modules extends ModulesMap> = {\n [K in keyof Modules]: InferFacts<ExtractSchema<Modules[K]>>;\n};\n\n// ============================================================================\n// Namespaced Derivations Types\n// ============================================================================\n\n/**\n * Namespace derivations under module keys.\n * `derive.auth.status` instead of `derive.auth_status`\n */\nexport type NamespacedDerivations<Modules extends ModulesMap> = {\n readonly [K in keyof Modules]: InferDerivations<ExtractSchema<Modules[K]>>;\n};\n\n// ============================================================================\n// Union Event Types\n// ============================================================================\n\n/**\n * Union of all module events (not namespaced).\n * Events stay as discriminated union for dispatch.\n */\nexport type UnionEvents<Modules extends ModulesMap> = {\n [K in keyof Modules]: InferEvents<ExtractSchema<Modules[K]>>;\n}[keyof Modules];\n\n// ============================================================================\n// Namespaced System Options\n// ============================================================================\n\n/**\n * Options for createSystem with object modules (namespaced mode).\n */\nexport interface CreateSystemOptionsNamed<Modules extends ModulesMap> {\n /** Modules as object = namespaced access */\n modules: Modules;\n /** Plugins to register */\n plugins?: Array<Plugin<ModuleSchema>>;\n /** History configuration for snapshot-based state history */\n history?: HistoryOption;\n /** Trace: per-run reconciliation changelog */\n trace?: TraceOption;\n /** Error boundary configuration */\n errorBoundary?: ErrorBoundaryConfig;\n /**\n * Tick interval for time-based systems (ms).\n */\n tickMs?: number;\n /**\n * Enable zero-config mode with sensible defaults.\n */\n zeroConfig?: boolean;\n /**\n * Connect to Directive Cloud for remote traces, dashboards, and team collaboration.\n *\n * @see https://directive.run/pricing\n */\n cloud?: boolean | string;\n /**\n * Initial facts to set after module init (namespaced format).\n * Applied after all module `init()` functions but before reconciliation.\n *\n * @example\n * ```typescript\n * createSystem({\n * modules: { auth, data },\n * initialFacts: {\n * auth: { token: \"restored-token\", user: cachedUser },\n * data: { users: preloadedUsers },\n * },\n * });\n * ```\n */\n initialFacts?: Partial<{\n [K in keyof Modules]: Partial<InferFacts<ExtractSchema<Modules[K]>>>;\n }>;\n /**\n * Init order strategy:\n * - \"auto\" (default): Sort by crossModuleDeps topology\n * - \"declaration\": Use object key order (current behavior)\n * - string[]: Explicit order by namespace\n */\n initOrder?: \"auto\" | \"declaration\" | Array<keyof Modules & string>;\n}\n\n// ============================================================================\n// Namespaced System Interface\n// ============================================================================\n\n/**\n * System interface for namespaced modules.\n * Facts and derivations are accessed via module namespaces.\n */\nexport interface NamespacedSystem<Modules extends ModulesMap> {\n /** System mode discriminator for type guards */\n readonly _mode: \"namespaced\";\n /** Namespaced facts accessor: system.facts.auth.token */\n readonly facts: MutableNamespacedFacts<Modules>;\n /** History API for undo/redo, rollback, audit trails (if enabled) */\n readonly history: HistoryAPI | null;\n /** Namespaced derivations accessor: system.derive.auth.status */\n readonly derive: NamespacedDerivations<Modules> & DerivationsControl;\n /** Events accessor (union of all module events) */\n readonly events: NamespacedEventsAccessor<Modules>;\n /** Runtime control for constraints (disable/enable/isDisabled + dynamic CRUD) */\n readonly constraints: ConstraintsControl;\n /** Runtime control for effects (disable/enable/isEnabled + dynamic CRUD) */\n readonly effects: EffectsControl;\n /** Runtime control for resolvers (dynamic CRUD) */\n readonly resolvers: ResolversControl;\n /** Per-run trace entries (null if trace is not enabled) */\n readonly trace: TraceEntry[] | null;\n\n /** Initialize facts and derivations without starting reconciliation. Safe for SSR. */\n initialize(): void;\n /** Start the system (initialize modules, begin reconciliation) */\n start(): void;\n /** Stop the system (cancel resolvers, stop reconciliation) */\n stop(): void;\n /** Destroy the system (stop and cleanup) */\n destroy(): void;\n\n /** Whether the system is currently running */\n readonly isRunning: boolean;\n /** Whether all resolvers have completed */\n readonly isSettled: boolean;\n /** Whether all modules have completed initialization */\n readonly isInitialized: boolean;\n /** Whether system has completed first reconciliation */\n readonly isReady: boolean;\n\n /** Wait for system to be fully ready (after first reconciliation) */\n whenReady(): Promise<void>;\n\n /**\n * Hydrate facts from async source (call before start).\n * Useful for restoring state from localStorage, API, etc.\n *\n * @example\n * ```typescript\n * const system = createSystem({ modules: { auth, data } });\n * await system.hydrate(async () => {\n * const stored = localStorage.getItem(\"app-state\");\n * return stored ? JSON.parse(stored) : {};\n * });\n * system.start();\n * ```\n */\n hydrate(\n loader: () =>\n | Promise<\n Partial<{\n [K in keyof Modules]: Partial<\n InferFacts<ExtractSchema<Modules[K]>>\n >;\n }>\n >\n | Partial<{\n [K in keyof Modules]: Partial<InferFacts<ExtractSchema<Modules[K]>>>;\n }>,\n ): Promise<void>;\n\n /** Dispatch an event (union of all module events) */\n dispatch(event: UnionEvents<Modules>): void;\n\n /** Batch multiple fact changes */\n batch(fn: () => void): void;\n\n /**\n * Subscribe to settlement state changes.\n * Called whenever the system's settled state may have changed\n * (resolver starts/completes, reconcile starts/ends).\n */\n onSettledChange(listener: () => void): () => void;\n\n /** Subscribe to history state changes (snapshot taken, navigation). */\n onHistoryChange(listener: () => void): () => void;\n\n /**\n * Read a derivation value by namespaced key.\n * Accepts \"namespace.key\" format (e.g., \"auth.status\").\n *\n * @example\n * system.read(\"auth.status\") // → \"authenticated\"\n * system.read(\"data.count\") // → 5\n */\n read<T = unknown>(derivationId: string): T;\n\n /**\n * Subscribe to fact or derivation changes using namespaced keys.\n * Keys are auto-detected — pass any mix of fact keys and derivation keys.\n * Accepts \"namespace.key\" format (e.g., \"auth.status\", \"auth.token\").\n * Supports wildcard \"namespace.*\" to subscribe to all keys in a module.\n *\n * @example\n * system.subscribe([\"auth.token\", \"data.count\"], () => {\n * console.log(\"Auth or data changed\");\n * });\n *\n * @example Wildcard\n * system.subscribe([\"game.*\"], () => render());\n */\n subscribe(ids: string[], listener: () => void): () => void;\n\n /**\n * Subscribe to ALL fact and derivation changes in a module namespace.\n * Shorthand for subscribing to every key in a module.\n *\n * @example\n * system.subscribeModule(\"game\", () => render());\n * system.subscribeModule(\"chat\", () => render());\n */\n subscribeModule(\n namespace: keyof Modules & string,\n listener: () => void,\n ): () => void;\n\n /**\n * Watch a fact or derivation for changes using namespaced key.\n * The key is auto-detected -- works with both fact keys and derivation keys.\n * Accepts \"namespace.key\" format (e.g., \"auth.status\", \"auth.token\").\n * Pass `options.equalityFn` for custom comparison (e.g., shallow equality for objects).\n *\n * @example\n * system.watch(\"auth.token\", (newVal, oldVal) => {\n * console.log(`Token changed from ${oldVal} to ${newVal}`);\n * });\n */\n watch<T = unknown>(\n id: string,\n callback: (newValue: T, previousValue: T | undefined) => void,\n options?: { equalityFn?: (a: T, b: T | undefined) => boolean },\n ): () => void;\n\n /**\n * Returns a promise that resolves when the predicate becomes true.\n * The predicate is evaluated against current facts and re-evaluated on every change.\n * Uses namespaced facts: `facts.auth.token`, `facts.data.count`, etc.\n * Optionally pass a timeout in ms -- rejects with an error if exceeded.\n *\n * @example\n * await system.when((facts) => facts.auth.token !== null);\n * await system.when((facts) => facts.auth.token !== null, { timeout: 5000 });\n */\n when(\n predicate: (facts: Readonly<MutableNamespacedFacts<Modules>>) => boolean,\n options?: { timeout?: number },\n ): Promise<void>;\n\n /** Inspect system state */\n inspect(): SystemInspection;\n /** Wait for system to settle (all resolvers complete) */\n settle(maxWait?: number): Promise<void>;\n /** Explain why a requirement exists */\n explain(requirementId: string): string | null;\n /** Get serializable snapshot of system state */\n getSnapshot(): SystemSnapshot;\n /** Restore system state from snapshot */\n restore(snapshot: SystemSnapshot): void;\n\n /**\n * Register a new module into a running system.\n * The module is initialized, wired into constraint/resolver/derivation graphs,\n * and reconciliation is triggered.\n *\n * @example\n * ```typescript\n * // Lazy-load a module\n * const chatModule = await import('./modules/chat');\n * system.registerModule(\"chat\", chatModule.default);\n * ```\n */\n registerModule<S extends ModuleSchema>(\n namespace: string,\n moduleDef: ModuleDef<S>,\n ): void;\n\n /**\n * Get a distributable snapshot of computed derivations.\n * Use \"namespace.key\" format for derivation keys.\n *\n * @example\n * ```typescript\n * const snapshot = system.getDistributableSnapshot({\n * includeDerivations: ['auth.effectivePlan', 'auth.canUseFeature'],\n * ttlSeconds: 3600,\n * });\n * await redis.setex(`entitlements:${userId}`, 3600, JSON.stringify(snapshot));\n * ```\n */\n getDistributableSnapshot<T = Record<string, unknown>>(\n options?: DistributableSnapshotOptions,\n ): DistributableSnapshot<T>;\n\n /**\n * Watch for changes to distributable snapshot derivations.\n * Calls the callback whenever any of the included derivations change.\n * Use \"namespace.key\" format for derivation keys.\n * Returns an unsubscribe function.\n *\n * @example\n * ```typescript\n * const unsubscribe = system.watchDistributableSnapshot(\n * { includeDerivations: ['auth.effectivePlan', 'auth.canUseFeature'] },\n * (snapshot) => {\n * await redis.setex(`entitlements:${userId}`, 3600, JSON.stringify(snapshot));\n * }\n * );\n * ```\n */\n watchDistributableSnapshot<T = Record<string, unknown>>(\n options: DistributableSnapshotOptions,\n callback: (snapshot: DistributableSnapshot<T>) => void,\n ): () => void;\n}\n\n/**\n * Events accessor that groups event dispatchers by module namespace.\n */\nexport type NamespacedEventsAccessor<Modules extends ModulesMap> = {\n readonly [K in keyof Modules]: EventsDispatcherForModule<Modules[K]>;\n};\n\n/**\n * Event dispatcher functions for a single module.\n */\ntype EventsDispatcherForModule<M> = M extends ModuleDef<infer S>\n ? S extends ModuleSchema\n ? S[\"events\"] extends Record<string, unknown>\n ? {\n [E in keyof S[\"events\"]]: S[\"events\"][E] extends Record<\n string,\n unknown\n >\n ? keyof S[\"events\"][E] extends never\n ? () => void\n : (payload: InferEventPayload<S[\"events\"][E]>) => void\n : () => void;\n }\n : Record<string, never>\n : Record<string, never>\n : Record<string, never>;\n\n/**\n * Infer event payload from event schema.\n */\ntype InferEventPayload<E> = E extends Record<string, unknown>\n ? { [K in keyof E]: E[K] extends { _type: infer T } ? T : E[K] }\n : never;\n\n// ============================================================================\n// Merged Schema Type (for internal use)\n// ============================================================================\n\n/**\n * Merge multiple module schemas into a single flat schema.\n * Used internally by the engine for storage.\n *\n * @example\n * ```typescript\n * // auth: { facts: { token: string } }\n * // data: { facts: { users: User[] } }\n * // Merged: { auth_token: string, data_users: User[] }\n * ```\n */\nexport type MergedModuleSchema<Modules extends ModulesMap> = {\n facts: MergeFactsWithPrefix<Modules>;\n derivations: MergeDerivationsWithPrefix<Modules>;\n events: MergeEventsWithPrefix<Modules>;\n requirements: MergeRequirementsWithPrefix<Modules>;\n};\n\ntype MergeFactsWithPrefix<Modules extends ModulesMap> = {\n [K in keyof Modules as `${K & string}::${keyof ExtractSchema<Modules[K]>[\"facts\"] & string}`]: ExtractSchema<\n Modules[K]\n >[\"facts\"][keyof ExtractSchema<Modules[K]>[\"facts\"]];\n};\n\ntype MergeDerivationsWithPrefix<Modules extends ModulesMap> = {\n [K in keyof Modules as ExtractSchema<\n Modules[K]\n >[\"derivations\"] extends Record<string, unknown>\n ? `${K & string}::${keyof ExtractSchema<Modules[K]>[\"derivations\"] & string}`\n : never]: ExtractSchema<Modules[K]>[\"derivations\"] extends Record<\n string,\n unknown\n >\n ? ExtractSchema<Modules[K]>[\"derivations\"][keyof ExtractSchema<\n Modules[K]\n >[\"derivations\"]]\n : never;\n};\n\ntype MergeEventsWithPrefix<Modules extends ModulesMap> = {\n [K in keyof Modules as ExtractSchema<Modules[K]>[\"events\"] extends Record<\n string,\n unknown\n >\n ? `${K & string}::${keyof ExtractSchema<Modules[K]>[\"events\"] & string}`\n : never]: ExtractSchema<Modules[K]>[\"events\"] extends Record<\n string,\n unknown\n >\n ? ExtractSchema<Modules[K]>[\"events\"][keyof ExtractSchema<\n Modules[K]\n >[\"events\"]]\n : never;\n};\n\ntype MergeRequirementsWithPrefix<Modules extends ModulesMap> = {\n [K in keyof Modules as ExtractSchema<\n Modules[K]\n >[\"requirements\"] extends Record<string, unknown>\n ? keyof ExtractSchema<Modules[K]>[\"requirements\"] & string\n : never]: ExtractSchema<Modules[K]>[\"requirements\"] extends Record<\n string,\n unknown\n >\n ? ExtractSchema<Modules[K]>[\"requirements\"][keyof ExtractSchema<\n Modules[K]\n >[\"requirements\"]]\n : never;\n};\n\n// ============================================================================\n// Single Module Types (no namespace)\n// ============================================================================\n\n/**\n * Options for createSystem with a single module (no namespacing).\n */\nexport interface CreateSystemOptionsSingle<S extends ModuleSchema> {\n /** Single module = direct access (use `modules` for multiple) */\n module: ModuleDef<S>;\n /** Plugins to register */\n plugins?: Array<Plugin<ModuleSchema>>;\n /** History configuration for snapshot-based state history */\n history?: HistoryOption;\n /** Trace: per-run reconciliation changelog */\n trace?: TraceOption;\n /** Error boundary configuration */\n errorBoundary?: ErrorBoundaryConfig;\n /** Tick interval for time-based systems (ms) */\n tickMs?: number;\n /** Enable zero-config mode with sensible defaults */\n zeroConfig?: boolean;\n /**\n * Connect to Directive Cloud for remote traces, dashboards, and team collaboration.\n *\n * @see https://directive.run/pricing\n */\n cloud?: boolean | string;\n /**\n * Initial facts to set after module init.\n * Applied after module `init()` but before reconciliation.\n */\n initialFacts?: Partial<InferFacts<S>>;\n}\n\n/**\n * System interface for a single module (no namespace).\n * Facts, derivations, and events are accessed directly.\n */\nexport interface SingleModuleSystem<S extends ModuleSchema> {\n /** System mode discriminator for type guards */\n readonly _mode: \"single\";\n /** Direct facts accessor: system.facts.count */\n readonly facts: Facts<S[\"facts\"]>;\n /** History API for undo/redo, rollback, audit trails (if enabled) */\n readonly history: HistoryAPI | null;\n /** Direct derivations accessor: system.derive.doubled */\n readonly derive: InferDerivations<S> & DerivationsControl<S>;\n /** Direct events accessor: system.events.increment() */\n readonly events: SingleModuleEvents<S>;\n /** Runtime control for constraints (disable/enable/isDisabled) */\n readonly constraints: ConstraintsControl<S>;\n /** Runtime control for effects (disable/enable/isEnabled) */\n readonly effects: EffectsControl<S>;\n /** Runtime control for resolvers (register/assign/unregister/call) */\n readonly resolvers: ResolversControl<S>;\n /** Per-run trace entries (null if trace is not enabled) */\n readonly trace: TraceEntry[] | null;\n\n /** Initialize facts and derivations without starting reconciliation. Safe for SSR. */\n initialize(): void;\n /** Start the system (initialize modules, begin reconciliation) */\n start(): void;\n /** Stop the system (cancel resolvers, stop reconciliation) */\n stop(): void;\n /** Destroy the system (stop and cleanup) */\n destroy(): void;\n\n /** Whether the system is currently running */\n readonly isRunning: boolean;\n /** Whether all resolvers have completed */\n readonly isSettled: boolean;\n /** Whether module has completed initialization */\n readonly isInitialized: boolean;\n /** Whether system has completed first reconciliation */\n readonly isReady: boolean;\n\n /** Wait for system to be fully ready (after first reconciliation) */\n whenReady(): Promise<void>;\n\n /**\n * Hydrate facts from async source (call before start).\n */\n hydrate(\n loader: () => Promise<Partial<InferFacts<S>>> | Partial<InferFacts<S>>,\n ): Promise<void>;\n\n /** Dispatch an event */\n dispatch(event: InferEvents<S>): void;\n\n /** Batch multiple fact changes */\n batch(fn: () => void): void;\n\n /**\n * Subscribe to settlement state changes.\n * Called whenever the system's settled state may have changed\n * (resolver starts/completes, reconcile starts/ends).\n */\n onSettledChange(listener: () => void): () => void;\n\n /** Subscribe to history state changes (snapshot taken, navigation). */\n onHistoryChange(listener: () => void): () => void;\n\n /**\n * Read a derivation value by key.\n * @example system.read(\"doubled\")\n */\n read<T = unknown>(derivationId: string): T;\n\n /**\n * Subscribe to fact or derivation changes.\n * Keys are auto-detected -- pass any mix of fact keys and derivation keys.\n * @example system.subscribe([\"count\", \"doubled\"], () => { ... })\n */\n subscribe(ids: string[], listener: () => void): () => void;\n\n /**\n * Watch a fact or derivation for value changes.\n * The key is auto-detected -- works with both fact keys and derivation keys.\n * Pass `options.equalityFn` for custom comparison (e.g., shallow equality for objects).\n * @example system.watch(\"count\", (newVal, oldVal) => { ... })\n * @example system.watch(\"derived\", cb, { equalityFn: shallowEqual })\n */\n watch<T = unknown>(\n id: string,\n callback: (newValue: T, previousValue: T | undefined) => void,\n options?: { equalityFn?: (a: T, b: T | undefined) => boolean },\n ): () => void;\n\n /**\n * Returns a promise that resolves when the predicate becomes true.\n * The predicate is evaluated against current facts and re-evaluated on every change.\n * Optionally pass a timeout in ms -- rejects with an error if exceeded.\n *\n * @example\n * await system.when((facts) => facts.count > 10);\n * await system.when((facts) => facts.count > 10, { timeout: 5000 });\n */\n when(\n predicate: (facts: Readonly<InferFacts<S>>) => boolean,\n options?: { timeout?: number },\n ): Promise<void>;\n\n /** Inspect system state */\n inspect(): SystemInspection;\n /** Wait for system to settle (all resolvers complete) */\n settle(maxWait?: number): Promise<void>;\n /** Explain why a requirement exists */\n explain(requirementId: string): string | null;\n /** Get serializable snapshot of system state */\n getSnapshot(): SystemSnapshot;\n /** Restore system state from snapshot */\n restore(snapshot: SystemSnapshot): void;\n\n /**\n * Register a new module into a running system.\n * Module facts, derivations, effects, constraints, and resolvers are merged\n * into the existing engine and reconciliation is triggered.\n *\n * @example\n * ```typescript\n * const analyticsModule = await import('./modules/analytics');\n * system.registerModule(analyticsModule.default);\n * ```\n */\n registerModule<S2 extends ModuleSchema>(moduleDef: ModuleDef<S2>): void;\n\n /**\n * Get a distributable snapshot of computed derivations.\n *\n * @example\n * ```typescript\n * const snapshot = system.getDistributableSnapshot({\n * includeDerivations: ['effectivePlan', 'canUseFeature'],\n * ttlSeconds: 3600,\n * });\n * await redis.setex(`entitlements:${userId}`, 3600, JSON.stringify(snapshot));\n * ```\n */\n getDistributableSnapshot<T = Record<string, unknown>>(\n options?: DistributableSnapshotOptions,\n ): DistributableSnapshot<T>;\n\n /**\n * Watch for changes to distributable snapshot derivations.\n * Calls the callback whenever any of the included derivations change.\n * Returns an unsubscribe function.\n *\n * @example\n * ```typescript\n * const unsubscribe = system.watchDistributableSnapshot(\n * { includeDerivations: ['effectivePlan', 'canUseFeature'] },\n * (snapshot) => {\n * await redis.setex(`entitlements:${userId}`, 3600, JSON.stringify(snapshot));\n * }\n * );\n * ```\n */\n watchDistributableSnapshot<T = Record<string, unknown>>(\n options: DistributableSnapshotOptions,\n callback: (snapshot: DistributableSnapshot<T>) => void,\n ): () => void;\n}\n\n/**\n * Events dispatcher for a single module (direct access).\n */\ntype SingleModuleEvents<S extends ModuleSchema> = S[\"events\"] extends Record<\n string,\n unknown\n>\n ? {\n [E in keyof S[\"events\"]]: S[\"events\"][E] extends Record<string, unknown>\n ? keyof S[\"events\"][E] extends never\n ? () => void\n : (payload: InferEventPayload<S[\"events\"][E]>) => void\n : () => void;\n }\n : Record<string, never>;\n\n// ============================================================================\n// Type Guards\n// ============================================================================\n\n/**\n * System mode discriminator.\n * - \"single\": Single module with direct access (`system.facts.count`)\n * - \"namespaced\": Multiple modules with namespaced access (`system.facts.auth.token`)\n */\nexport type SystemMode = \"single\" | \"namespaced\";\n\n/**\n * Base system type for type guards.\n * Use this for functions that accept either system type.\n */\nexport interface AnySystem {\n readonly _mode: SystemMode;\n readonly isRunning: boolean;\n readonly isSettled: boolean;\n readonly isInitialized: boolean;\n readonly isReady: boolean;\n initialize(): void;\n start(): void;\n stop(): void;\n destroy(): void;\n}\n\n/**\n * Check if a system is a single module system.\n * Returns true if the system was created with `module:` (singular).\n *\n * @example\n * ```typescript\n * const system = createSystem({ module: counterModule });\n *\n * if (isSingleModuleSystem(system)) {\n * // system._mode === \"single\"\n * console.log(system.facts.count);\n * }\n * ```\n */\nexport function isSingleModuleSystem(system: AnySystem): boolean {\n return system._mode === \"single\";\n}\n\n/**\n * Check if a system is a namespaced (multi-module) system.\n * Returns true if the system was created with `modules:` (plural, object).\n *\n * @example\n * ```typescript\n * const system = createSystem({ modules: { auth, data } });\n *\n * if (isNamespacedSystem(system)) {\n * // system._mode === \"namespaced\"\n * console.log(system.facts.auth.token);\n * }\n * ```\n */\nexport function isNamespacedSystem(system: AnySystem): boolean {\n return system._mode === \"namespaced\";\n}\n","/**\n * History — Snapshot-based state history\n *\n * Features:\n * - Ring buffer of state snapshots\n * - Go back/forward through history\n * - Replay from any snapshot\n * - Export/import state history\n */\n\nimport type {\n Facts,\n FactsStore,\n HistoryAPI,\n HistoryOption,\n Schema,\n Snapshot,\n} from \"../core/types.js\";\nimport { isPrototypeSafe } from \"./utils.js\";\n\n// ============================================================================\n// History Manager\n// ============================================================================\n\n/**\n * A changeset groups multiple snapshots into a single undo/redo unit.\n *\n * @remarks\n * Use {@link HistoryManager.beginChangeset} and\n * {@link HistoryManager.endChangeset} to create changesets. When navigating\n * with `goBack`/`goForward`, the entire changeset is traversed as one step.\n *\n * @internal\n */\nexport interface Changeset {\n label: string;\n startIndex: number;\n endIndex: number;\n}\n\n/**\n * Internal history manager that extends the public {@link HistoryAPI}\n * with snapshot capture, restoration, and pause/resume controls.\n *\n * @remarks\n * - `takeSnapshot(trigger)` records the current facts into the ring buffer.\n * - `restore(snapshot)` deserializes a snapshot back into the facts store,\n * setting `isRestoring = true` so the engine skips reconciliation.\n * - `pause()` / `resume()` temporarily suspend snapshot recording (e.g.,\n * during bulk imports or programmatic state resets).\n * - `beginChangeset(label)` / `endChangeset()` group consecutive snapshots\n * so `goBack`/`goForward` treat them as a single undo/redo unit.\n *\n * @typeParam _S - The schema type (unused at runtime but preserved for type safety).\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport interface HistoryManager<_S extends Schema> extends HistoryAPI {\n /** Take a snapshot of current state */\n takeSnapshot(trigger: string): Snapshot;\n /** Restore facts from a snapshot */\n restore(snapshot: Snapshot): void;\n /** Check if history is enabled */\n readonly isEnabled: boolean;\n /** True while restoring a snapshot (engine should skip reconciliation) */\n readonly isRestoring: boolean;\n /** Pause snapshot taking */\n pause(): void;\n /** Resume snapshot taking */\n resume(): void;\n}\n\n/**\n * Options for creating a history manager via {@link createHistoryManager}.\n *\n * @typeParam S - The facts schema type.\n *\n * @internal\n */\nexport interface CreateHistoryOptions<S extends Schema> {\n historyOption: HistoryOption;\n facts: Facts<S>;\n store: FactsStore<S>;\n /** Callback when a snapshot is taken */\n onSnapshot?: (snapshot: Snapshot) => void;\n /** Callback when history navigation occurs */\n onHistoryChange?: (from: number, to: number) => void;\n}\n\n/**\n * Resolve a HistoryOption (boolean | HistoryConfig) into concrete values.\n * @internal\n */\nfunction resolveHistoryOption(option: HistoryOption): {\n enabled: boolean;\n maxSnapshots: number;\n} {\n if (typeof option === \"boolean\") {\n return { enabled: option, maxSnapshots: 100 };\n }\n\n // Object config — presence implies enabled\n return {\n enabled: true,\n maxSnapshots: option.maxSnapshots ?? 100,\n };\n}\n\n/**\n * Create a snapshot-based history manager backed by a ring buffer.\n *\n * @remarks\n * Snapshots are taken automatically after fact changes (during reconciliation)\n * and can be navigated with `goBack`/`goForward`/`goTo`. Use\n * `beginChangeset(label)` and `endChangeset()` to group multiple snapshots\n * into a single undo/redo unit. The entire history can be exported to JSON\n * via `export()` and re-imported with `import()` for cross-session debugging.\n *\n * Call `pause()` to temporarily stop recording snapshots (e.g., during bulk\n * fact imports) and `resume()` to re-enable recording.\n *\n * @param options - History config, facts proxy, store, and optional snapshot/history callbacks.\n * @returns A {@link HistoryManager} with snapshot capture, navigation, changeset, and export/import methods.\n *\n * @internal\n */\nexport function createHistoryManager<S extends Schema>(\n options: CreateHistoryOptions<S>,\n): HistoryManager<S> {\n const { historyOption, facts, store, onSnapshot, onHistoryChange } = options;\n\n const { enabled: isEnabled, maxSnapshots } =\n resolveHistoryOption(historyOption);\n\n // Ring buffer of snapshots\n const snapshots: Snapshot[] = [];\n let currentIndex = -1;\n let nextId = 1;\n let paused = false;\n let restoring = false;\n\n // Changeset tracking\n const changesets: Changeset[] = [];\n let pendingChangesetLabel: string | null = null;\n let pendingChangesetStart = -1;\n\n /** Get current facts as a plain object */\n function getCurrentFacts(): Record<string, unknown> {\n return store.toObject();\n }\n\n /** Serialize facts to a snapshot-friendly format */\n function serializeFacts(): Record<string, unknown> {\n const factsObj = getCurrentFacts();\n\n // Deep clone to prevent mutation\n try {\n return structuredClone(factsObj);\n } catch {\n // Fallback for non-cloneable values (functions, DOM nodes, etc.)\n try {\n return JSON.parse(JSON.stringify(factsObj));\n } catch {\n return { ...factsObj };\n }\n }\n }\n\n /** Deserialize and restore facts from a snapshot */\n function deserializeFacts(serialized: Record<string, unknown>): void {\n // Validate entire object tree for prototype pollution\n if (!isPrototypeSafe(serialized)) {\n console.error(\n \"[Directive] Potential prototype pollution detected in snapshot data, skipping restore\",\n );\n return;\n }\n\n store.batch(() => {\n for (const [key, value] of Object.entries(serialized)) {\n // Prototype pollution protection (redundant but defensive)\n if (\n key === \"__proto__\" ||\n key === \"constructor\" ||\n key === \"prototype\"\n ) {\n console.warn(\n `[Directive] Skipping dangerous key \"${key}\" during fact restoration`,\n );\n continue;\n }\n // @ts-expect-error - dynamic key access\n facts[key] = value;\n }\n });\n }\n\n const manager: HistoryManager<S> = {\n get isEnabled() {\n return isEnabled;\n },\n\n get isRestoring() {\n return restoring;\n },\n\n get isPaused() {\n return paused;\n },\n\n get snapshots() {\n return [...snapshots];\n },\n\n get currentIndex() {\n return currentIndex;\n },\n\n takeSnapshot(trigger: string): Snapshot {\n if (!isEnabled || paused) {\n return { id: -1, timestamp: Date.now(), facts: {}, trigger };\n }\n\n const snapshot: Snapshot = {\n id: nextId++,\n timestamp: Date.now(),\n facts: serializeFacts(),\n trigger,\n };\n\n // If we're not at the end, truncate future snapshots\n if (currentIndex < snapshots.length - 1) {\n snapshots.splice(currentIndex + 1);\n }\n\n // Add new snapshot\n snapshots.push(snapshot);\n currentIndex = snapshots.length - 1;\n\n // Enforce max size (ring buffer)\n while (snapshots.length > maxSnapshots) {\n snapshots.shift();\n currentIndex--;\n }\n\n onSnapshot?.(snapshot);\n return snapshot;\n },\n\n restore(snapshot: Snapshot): void {\n if (!isEnabled) return;\n\n // Set restoring flag so the engine skips reconciliation scheduling.\n // The restored state is already \"reconciled\" — it was captured after\n // a complete reconcile cycle. Re-reconciling would create spurious\n // snapshots that break undo/redo navigation.\n paused = true;\n restoring = true;\n\n try {\n deserializeFacts(snapshot.facts);\n } finally {\n paused = false;\n restoring = false;\n }\n },\n\n goBack(steps = 1): void {\n if (!isEnabled || snapshots.length === 0) return;\n\n const fromIndex = currentIndex;\n\n // Check if we're inside a changeset — jump to its start\n let toIndex = currentIndex;\n const cs = changesets.find(\n (c) => currentIndex > c.startIndex && currentIndex <= c.endIndex,\n );\n if (cs) {\n toIndex = cs.startIndex;\n } else {\n // Check if we're at the end of a changeset — jump past its start\n const prevCs = changesets.find((c) => currentIndex === c.startIndex);\n if (prevCs) {\n // We're at the boundary. Look for the changeset before this one.\n const earlierCs = changesets.find(\n (c) =>\n c.endIndex < currentIndex && currentIndex - c.endIndex <= steps,\n );\n toIndex = earlierCs\n ? earlierCs.startIndex\n : Math.max(0, currentIndex - steps);\n } else {\n toIndex = Math.max(0, currentIndex - steps);\n }\n }\n\n if (fromIndex === toIndex) return;\n\n currentIndex = toIndex;\n const snapshot = snapshots[currentIndex];\n if (snapshot) {\n this.restore(snapshot);\n onHistoryChange?.(fromIndex, toIndex);\n }\n },\n\n goForward(steps = 1): void {\n if (!isEnabled || snapshots.length === 0) return;\n\n const fromIndex = currentIndex;\n\n // Check if we're inside or at the start of a changeset — jump to its end\n let toIndex = currentIndex;\n const cs = changesets.find(\n (c) => currentIndex >= c.startIndex && currentIndex < c.endIndex,\n );\n if (cs) {\n toIndex = cs.endIndex;\n } else {\n toIndex = Math.min(snapshots.length - 1, currentIndex + steps);\n }\n\n if (fromIndex === toIndex) return;\n\n currentIndex = toIndex;\n const snapshot = snapshots[currentIndex];\n if (snapshot) {\n this.restore(snapshot);\n onHistoryChange?.(fromIndex, toIndex);\n }\n },\n\n goTo(snapshotId: number): void {\n if (!isEnabled) return;\n\n const index = snapshots.findIndex((s) => s.id === snapshotId);\n if (index === -1) {\n console.warn(`[Directive] Snapshot ${snapshotId} not found`);\n return;\n }\n\n const fromIndex = currentIndex;\n currentIndex = index;\n const snapshot = snapshots[currentIndex];\n if (snapshot) {\n this.restore(snapshot);\n onHistoryChange?.(fromIndex, index);\n }\n },\n\n replay(): void {\n if (!isEnabled || snapshots.length === 0) return;\n\n // Start from the beginning\n currentIndex = 0;\n const snapshot = snapshots[0];\n if (snapshot) {\n this.restore(snapshot);\n }\n },\n\n export(): string {\n return JSON.stringify({\n version: 1,\n snapshots,\n currentIndex,\n });\n },\n\n import(json: string): void {\n if (!isEnabled) return;\n\n try {\n const data = JSON.parse(json);\n\n // Validate import data structure to prevent prototype pollution\n if (typeof data !== \"object\" || data === null) {\n throw new Error(\"[Directive] Invalid history data: expected object\");\n }\n if (data.version !== 1) {\n throw new Error(\n `[Directive] Unsupported history export version: ${data.version}`,\n );\n }\n if (!Array.isArray(data.snapshots)) {\n throw new Error(\"[Directive] Invalid history data: snapshots must be an array\");\n }\n if (typeof data.currentIndex !== \"number\") {\n throw new Error(\n \"Invalid history data: currentIndex must be a number\",\n );\n }\n\n // Validate each snapshot has required properties\n for (const snap of data.snapshots) {\n if (typeof snap !== \"object\" || snap === null) {\n throw new Error(\"[Directive] Invalid snapshot: expected object\");\n }\n if (\n typeof snap.id !== \"number\" ||\n typeof snap.timestamp !== \"number\" ||\n typeof snap.trigger !== \"string\" ||\n typeof snap.facts !== \"object\"\n ) {\n throw new Error(\"Invalid snapshot structure\");\n }\n // Deep check for prototype pollution attacks (including nested objects)\n if (!isPrototypeSafe(snap.facts)) {\n throw new Error(\n \"[Directive] Invalid fact data: potential prototype pollution detected in nested objects\",\n );\n }\n }\n\n snapshots.length = 0;\n snapshots.push(...data.snapshots);\n currentIndex = data.currentIndex;\n\n // Restore current state\n const snapshot = snapshots[currentIndex];\n if (snapshot) {\n this.restore(snapshot);\n }\n } catch (error) {\n console.error(\"[Directive] Failed to import history data:\", error);\n }\n },\n\n beginChangeset(label: string): void {\n if (!isEnabled) return;\n pendingChangesetLabel = label;\n pendingChangesetStart = currentIndex;\n },\n\n endChangeset(): void {\n if (!isEnabled || pendingChangesetLabel === null) return;\n if (currentIndex > pendingChangesetStart) {\n changesets.push({\n label: pendingChangesetLabel,\n startIndex: pendingChangesetStart,\n endIndex: currentIndex,\n });\n }\n pendingChangesetLabel = null;\n pendingChangesetStart = -1;\n },\n\n pause(): void {\n paused = true;\n },\n\n resume(): void {\n paused = false;\n },\n };\n\n return manager;\n}\n\n/**\n * Create a no-op history manager for use when history is disabled.\n *\n * @remarks\n * All methods are safe to call but perform no work. This avoids null-checks\n * throughout the engine -- callers can use the same {@link HistoryManager}\n * interface regardless of whether history is enabled.\n *\n * @returns A {@link HistoryManager} where every method is a no-op and `isEnabled` is `false`.\n *\n * @internal\n */\nexport function createDisabledHistory<S extends Schema>(): HistoryManager<S> {\n const noopSnapshot: Snapshot = {\n id: -1,\n timestamp: 0,\n facts: {},\n trigger: \"\",\n };\n\n return {\n isEnabled: false,\n isRestoring: false,\n isPaused: false,\n snapshots: [],\n currentIndex: -1,\n takeSnapshot: () => noopSnapshot,\n restore: () => {},\n goBack: () => {},\n goForward: () => {},\n goTo: () => {},\n replay: () => {},\n export: () => \"{}\",\n import: () => {},\n beginChangeset: () => {},\n endChangeset: () => {},\n pause: () => {},\n resume: () => {},\n };\n}\n","/**\n * Requirements - Typed requirement identity with custom dedupe keys\n *\n * Features:\n * - Type-safe requirement definitions\n * - Stable identity generation\n * - Custom key functions for deduplication control\n * - Requirement comparison and hashing\n */\n\nimport { stableStringify } from \"../utils/utils.js\";\nimport type {\n Requirement,\n RequirementKeyFn,\n RequirementWithId,\n} from \"./types.js\";\n\n// ============================================================================\n// Requirement Identity\n// ============================================================================\n\n/**\n * Generate a stable identity string for a requirement.\n *\n * When no custom key function is provided, the ID is formed from the\n * requirement's `type` plus a deterministic JSON serialization of its\n * remaining properties. A custom {@link RequirementKeyFn} can override\n * this to control deduplication granularity.\n *\n * @param req - The requirement to generate an ID for.\n * @param keyFn - Optional custom key function that overrides the default identity logic.\n * @returns A stable string that uniquely identifies this requirement for deduplication.\n *\n * @public\n */\n/** Cache for default requirement IDs (no custom keyFn) to avoid repeated stableStringify */\nconst reqIdCache = new WeakMap<Requirement, string>();\n\nexport function generateRequirementId(\n req: Requirement,\n keyFn?: RequirementKeyFn,\n): string {\n // Use custom key function if provided\n if (keyFn) {\n return keyFn(req);\n }\n\n // Check cache first\n const cached = reqIdCache.get(req);\n if (cached !== undefined) {\n return cached;\n }\n\n // Default: type + stable JSON of other properties\n const { type, ...rest } = req;\n const sortedRest = stableStringify(rest);\n const id = `${type}:${sortedRest}`;\n\n reqIdCache.set(req, id);\n\n return id;\n}\n\n/**\n * Create a {@link RequirementWithId} by pairing a requirement with its\n * computed identity string and the constraint that produced it.\n *\n * @param requirement - The raw requirement object.\n * @param fromConstraint - Name of the constraint that emitted this requirement.\n * @param keyFn - Optional custom key function forwarded to {@link generateRequirementId}.\n * @returns A requirement bundled with its stable ID and originating constraint name.\n *\n * @public\n */\nexport function createRequirementWithId(\n requirement: Requirement,\n fromConstraint: string,\n keyFn?: RequirementKeyFn,\n): RequirementWithId {\n return {\n requirement,\n id: generateRequirementId(requirement, keyFn),\n fromConstraint,\n };\n}\n\n// ============================================================================\n// Requirement Helpers\n// ============================================================================\n\n/**\n * Create a typed requirement factory for a given requirement type string.\n *\n * Returns a function that, when called with a properties object, produces a\n * fully-typed {@link Requirement} whose `type` field is the literal `T`.\n * This is the recommended way to build requirements inside constraint\n * definitions because it keeps the type string in one place and gives you\n * full TypeScript inference on the payload.\n *\n * @param type - The requirement type string (e.g. `\"FETCH_USER\"`).\n * @returns A factory that merges `type` with arbitrary properties into a typed requirement.\n *\n * @example\n * ```typescript\n * const fetchUser = req(\"FETCH_USER\");\n *\n * // Use inside a module's constraint definition\n * constraints: {\n * needsUser: {\n * when: (facts) => facts.userId && !facts.user,\n * require: fetchUser({ userId: 123, priority: \"high\" }),\n * },\n * }\n *\n * // Produces: { type: \"FETCH_USER\", userId: 123, priority: \"high\" }\n * ```\n *\n * @public\n */\nexport function req<T extends string>(type: T) {\n return <P extends Record<string, unknown>>(props: P) =>\n ({\n type,\n ...props,\n }) as Requirement & { type: T } & P;\n}\n\n/**\n * Type-narrowing guard that checks whether a requirement's `type` matches the\n * given string literal.\n *\n * After this guard returns `true`, TypeScript narrows `req` to\n * `Requirement & { type: T }`, giving you access to type-specific fields.\n *\n * @param req - The requirement to test.\n * @param type - The expected type string to match against.\n * @returns `true` when `req.type === type`.\n *\n * @public\n */\nexport function isRequirementType<T extends string>(\n req: Requirement,\n type: T,\n): req is Requirement & { type: T } {\n return req.type === type;\n}\n\n/**\n * Create a type-guard function suitable for a resolver's `requirement`\n * predicate field.\n *\n * @remarks\n * The returned predicate narrows any {@link Requirement} to the concrete\n * type `R` (or `Requirement & { type: T }` when no explicit generic is\n * provided). This is a cleaner alternative to writing verbose inline type\n * guards in every resolver definition.\n *\n * @param type - The requirement type string to match.\n * @returns A predicate that returns `true` for requirements whose `type` matches, narrowing the value for downstream callbacks like `key` and `resolve`.\n *\n * @example\n * ```typescript\n * // With an explicit requirement interface (recommended for complex payloads)\n * interface FetchUserReq { type: \"FETCH_USER\"; userId: string }\n * requirement: forType<FetchUserReq>(\"FETCH_USER\"),\n * key: (req) => req.userId, // req is FetchUserReq\n *\n * // With a simple string literal\n * requirement: forType(\"FETCH_USER\"),\n * key: (req) => req.type, // req is Requirement & { type: \"FETCH_USER\" }\n * ```\n *\n * @public\n */\nexport function forType<R extends Requirement>(\n type: R[\"type\"],\n): (req: Requirement) => req is R;\nexport function forType<T extends string>(\n type: T,\n): (req: Requirement) => req is Requirement & { type: T };\n/** @internal Implementation overload — see public overloads above. */\nexport function forType<T extends string>(\n type: T,\n): (req: Requirement) => req is Requirement & { type: T } {\n return (req): req is Requirement & { type: T } => req.type === type;\n}\n\n// ============================================================================\n// Requirement Set Management\n// ============================================================================\n\n/**\n * A deduplicated collection of {@link RequirementWithId} entries keyed by\n * their identity string.\n *\n * @remarks\n * Requirements are uniquely identified by their ID (generated from type +\n * properties via {@link generateRequirementId}). When adding a requirement\n * whose ID already exists, the first entry wins and the duplicate is\n * silently ignored. The {@link RequirementSet.diff | diff} method computes\n * added, removed, and unchanged entries relative to another set, which the\n * engine uses during reconciliation.\n *\n * @example\n * ```typescript\n * const set = new RequirementSet();\n * set.add(createRequirementWithId({ type: \"FETCH_USER\", userId: 1 }, \"c1\"));\n * set.add(createRequirementWithId({ type: \"FETCH_USER\", userId: 1 }, \"c2\")); // ignored\n * console.log(set.size); // 1\n *\n * const next = new RequirementSet();\n * next.add(createRequirementWithId({ type: \"FETCH_USER\", userId: 2 }, \"c1\"));\n * const { added, removed } = next.diff(set);\n * // added has userId: 2, removed has userId: 1\n * ```\n *\n * @public\n */\nexport class RequirementSet {\n private map = new Map<string, RequirementWithId>();\n\n /**\n * Add a requirement to the set (first-wins deduplication).\n *\n * @param req - The requirement with its computed ID to insert.\n */\n add(req: RequirementWithId): void {\n // If already exists, keep the existing one (first wins)\n if (!this.map.has(req.id)) {\n this.map.set(req.id, req);\n }\n }\n\n /**\n * Remove a requirement by its identity string.\n *\n * @param id - The requirement identity string to remove.\n * @returns `true` if the requirement existed and was removed.\n */\n remove(id: string): boolean {\n return this.map.delete(id);\n }\n\n /**\n * Check whether a requirement with the given ID is in the set.\n *\n * @param id - The requirement identity string to look up.\n * @returns `true` if the set contains a requirement with this ID.\n */\n has(id: string): boolean {\n return this.map.has(id);\n }\n\n /**\n * Retrieve a requirement by its identity string.\n *\n * @param id - The requirement identity string to look up.\n * @returns The matching requirement, or `undefined` if not found.\n */\n get(id: string): RequirementWithId | undefined {\n return this.map.get(id);\n }\n\n /**\n * Return a snapshot array of all requirements in the set.\n *\n * @returns A new array containing every {@link RequirementWithId} in insertion order.\n */\n all(): RequirementWithId[] {\n return [...this.map.values()];\n }\n\n /**\n * Return a snapshot array of all requirement identity strings.\n *\n * @returns A new array of ID strings in insertion order.\n */\n ids(): string[] {\n return [...this.map.keys()];\n }\n\n /**\n * The number of requirements currently in the set.\n */\n get size(): number {\n return this.map.size;\n }\n\n /**\n * Remove all requirements from the set.\n */\n clear(): void {\n this.map.clear();\n }\n\n /**\n * Create a shallow copy of this set.\n *\n * @returns A new {@link RequirementSet} containing the same entries.\n */\n clone(): RequirementSet {\n const copy = new RequirementSet();\n for (const req of this.map.values()) {\n copy.add(req);\n }\n return copy;\n }\n\n /**\n * Compute the difference between this set and another.\n *\n * @param other - The previous set to compare against.\n * @returns An object with `added` (in this but not other), `removed` (in other but not this), and `unchanged` arrays.\n */\n diff(other: RequirementSet): {\n added: RequirementWithId[];\n removed: RequirementWithId[];\n unchanged: RequirementWithId[];\n } {\n const added: RequirementWithId[] = [];\n const removed: RequirementWithId[] = [];\n const unchanged: RequirementWithId[] = [];\n\n // Find added (in this but not in other)\n for (const req of this.map.values()) {\n if (!other.has(req.id)) {\n added.push(req);\n } else {\n unchanged.push(req);\n }\n }\n\n // Find removed (in other but not in this)\n for (const req of other.map.values()) {\n if (!this.map.has(req.id)) {\n removed.push(req);\n }\n }\n\n return { added, removed, unchanged };\n }\n}\n","/**\n * Constraints - Rules that produce requirements when conditions aren't met\n *\n * Features:\n * - Sync and async constraint evaluation\n * - Priority ordering (higher runs first)\n * - Timeout handling for async constraints\n * - Error isolation\n */\n\nimport { withTimeout } from \"../utils/utils.js\";\nimport { RequirementSet, createRequirementWithId } from \"./requirements.js\";\nimport { withTracking } from \"./tracking.js\";\nimport type {\n ConstraintState,\n ConstraintsDef,\n Facts,\n Requirement,\n RequirementKeyFn,\n RequirementWithId,\n Schema,\n} from \"./types.js\";\n\n// Local type alias for requirement output (avoid type arg issues)\ntype RequirementOutput = Requirement | Requirement[] | null;\n\n// ============================================================================\n// Constraints Manager\n// ============================================================================\n\n/**\n * Manager returned by {@link createConstraintsManager} that evaluates\n * constraint rules against the current facts and produces unmet\n * {@link RequirementWithId | requirements}.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport interface ConstraintsManager<_S extends Schema> {\n /**\n * Evaluate all enabled constraints and return unmet requirements.\n *\n * @remarks\n * On the first call (or when `changedKeys` is empty), every enabled\n * constraint is evaluated. On subsequent calls, only constraints whose\n * tracked dependencies overlap with `changedKeys` are re-evaluated.\n * Sync constraints run first, async constraints run in parallel, and\n * `after` ordering is respected across multiple passes.\n *\n * @param changedKeys - Fact keys that changed since the last evaluation.\n * When omitted or empty, all constraints are evaluated.\n * @returns An array of {@link RequirementWithId} representing unmet requirements.\n */\n evaluate(changedKeys?: Set<string>): Promise<RequirementWithId[]>;\n /**\n * Get the current state of a constraint by its definition ID.\n *\n * @param id - The constraint definition ID.\n * @returns The {@link ConstraintState}, or `undefined` if the ID is unknown.\n */\n getState(id: string): ConstraintState | undefined;\n /**\n * Get the state of every registered constraint.\n *\n * @returns An array of all {@link ConstraintState} objects.\n */\n getAllStates(): ConstraintState[];\n /**\n * Disable a constraint so it is skipped during evaluation.\n *\n * @param id - The constraint definition ID.\n */\n disable(id: string): void;\n /**\n * Re-enable a previously disabled constraint.\n *\n * @param id - The constraint definition ID.\n */\n enable(id: string): void;\n /**\n * Mark all constraints that depend on `factKey` as dirty so they are\n * re-evaluated on the next {@link ConstraintsManager.evaluate | evaluate} call.\n *\n * @param factKey - The fact store key that changed.\n */\n invalidate(factKey: string): void;\n /**\n * Get the auto-tracked or explicit dependency set for a constraint.\n *\n * @param id - The constraint definition ID.\n * @returns A `Set` of fact keys, or `undefined` if no dependencies have been recorded.\n */\n getDependencies(id: string): Set<string> | undefined;\n /**\n * Record that a constraint's resolver completed successfully, unblocking\n * any constraints that list it in their `after` array.\n *\n * @param constraintId - The constraint definition ID whose resolver finished.\n */\n markResolved(constraintId: string): void;\n /**\n * Check whether a constraint is currently disabled.\n *\n * @param id - The constraint definition ID.\n * @returns `true` if the constraint has been disabled via {@link ConstraintsManager.disable | disable}.\n */\n isDisabled(id: string): boolean;\n /**\n * Check whether a constraint has been marked as resolved.\n *\n * @param constraintId - The constraint definition ID.\n * @returns `true` if {@link ConstraintsManager.markResolved | markResolved} was called for this constraint.\n */\n isResolved(constraintId: string): boolean;\n /**\n * Register additional constraint definitions at runtime (used for dynamic\n * module registration).\n *\n * @remarks\n * Rebuilds the topological order and reverse dependency map so new `after`\n * dependencies are validated for cycles and indexed.\n *\n * @param newDefs - New constraint definitions to merge into the manager.\n */\n registerDefinitions(newDefs: ConstraintsDef<Schema>): void;\n /**\n * Override an existing constraint definition.\n * Stores the original in an internal map for inspection.\n *\n * @param id - The constraint definition ID to override.\n * @param def - The new constraint definition.\n * @throws If no constraint with this ID exists.\n */\n assignDefinition(id: string, def: ConstraintsDef<Schema>[string]): void;\n /**\n * Remove a constraint definition and all its internal state.\n *\n * @param id - The constraint definition ID to remove.\n */\n unregisterDefinition(id: string): void;\n /**\n * Evaluate a single constraint and emit its requirement if active.\n * Props are merged into the requirement object.\n *\n * @param id - The constraint definition ID.\n * @param props - Optional properties to merge into the requirement.\n * @returns The emitted requirements (if any).\n */\n callOne(\n id: string,\n props?: Record<string, unknown>,\n ): Promise<RequirementWithId[]>;\n /**\n * Register a custom key function for a requirement type.\n * Used by the engine to forward resolver `key` functions to the\n * constraint manager for requirement deduplication.\n *\n * @param requirementType - The requirement type string (e.g. `\"FETCH_USER\"`).\n * @param keyFn - The key function that produces a deduplication string.\n */\n setRequirementKey(requirementType: string, keyFn: RequirementKeyFn): void;\n /**\n * Remove a previously registered requirement key function.\n *\n * @param requirementType - The requirement type string to remove.\n */\n removeRequirementKey(requirementType: string): void;\n}\n\n/**\n * Configuration options accepted by {@link createConstraintsManager}.\n *\n * @internal\n */\nexport interface CreateConstraintsOptions<S extends Schema> {\n /** Constraint definitions keyed by ID. */\n definitions: ConstraintsDef<S>;\n /** Proxy-based facts object used to evaluate `when()` predicates. */\n facts: Facts<S>;\n /** Custom key functions for requirement deduplication, keyed by requirement type. */\n requirementKeys?: Record<string, RequirementKeyFn>;\n /** Default timeout in milliseconds for async constraint evaluation (defaults to 5 000). */\n defaultTimeout?: number;\n /** Called after each constraint evaluation with the constraint ID and whether `when()` was active. */\n onEvaluate?: (id: string, active: boolean) => void;\n /** Called when a constraint's `when()` or `require()` throws. */\n onError?: (id: string, error: unknown) => void;\n}\n\n/** Default async constraint timeout (5 seconds) */\nconst DEFAULT_TIMEOUT = 5000;\n\n/**\n * Create a manager that evaluates constraint rules and produces unmet\n * requirements.\n *\n * @remarks\n * Constraints are evaluated in priority order (higher priority first), with\n * topological ordering for same-priority constraints connected by `after`\n * dependencies. The manager supports sync and async `when()` predicates,\n * incremental evaluation based on changed fact keys, and per-constraint\n * enable/disable toggling. Cycle detection runs eagerly at construction time\n * to prevent deadlocks in production.\n *\n * @param options - Configuration including constraint definitions, facts proxy,\n * custom requirement key functions, and lifecycle callbacks.\n * @returns A {@link ConstraintsManager} for evaluating, invalidating, and\n * managing constraint lifecycle.\n *\n * @example\n * ```typescript\n * const constraints = createConstraintsManager({\n * definitions: {\n * mustTransition: {\n * priority: 50,\n * when: (facts) => facts.phase === \"red\" && facts.elapsed > 30,\n * require: { type: \"TRANSITION\", to: \"green\" },\n * },\n * },\n * facts: factsProxy,\n * onEvaluate: (id, active) => console.log(id, active),\n * });\n *\n * const unmet = await constraints.evaluate();\n * ```\n *\n * @internal\n */\nexport function createConstraintsManager<S extends Schema>(\n options: CreateConstraintsOptions<S>,\n): ConstraintsManager<S> {\n const {\n definitions,\n facts,\n requirementKeys = {},\n defaultTimeout = DEFAULT_TIMEOUT,\n onEvaluate,\n onError,\n } = options;\n\n // Internal state for each constraint\n const states = new Map<string, ConstraintState>();\n const disabled = new Set<string>();\n\n // Track which constraints are async\n const asyncConstraintIds = new Set<string>();\n\n // Dependency tracking: which facts each constraint depends on\n const constraintDeps = new Map<string, Set<string>>();\n // Reverse mapping: which constraints depend on each fact\n const factToConstraints = new Map<string, Set<string>>();\n // Track which constraints need re-evaluation\n const dirtyConstraints = new Set<string>();\n // Cache latest when() deps so they can be combined with require() deps atomically\n const latestWhenDeps = new Map<string, Set<string>>();\n // Track last requirements for each constraint (for incremental updates)\n const lastRequirements = new Map<string, RequirementWithId[]>();\n // First evaluation flag\n let hasEvaluated = false;\n // Track resolved constraints (for `after` ordering)\n const resolvedConstraints = new Set<string>();\n // Track constraints that didn't fire (when() returned false) - they don't block\n const noFireConstraints = new Set<string>();\n // Reverse dependency map: which constraints depend on this one (for O(1) markResolved)\n const dependsOnMe = new Map<string, Set<string>>();\n // Topological order of constraints (dependencies before dependents)\n let topologicalOrder: string[] = [];\n // Cached topological index map for O(1) lookups during sorting\n let topologicalIndex: Map<string, number> = new Map();\n\n /** Register a single `after` dependency in the reverse map */\n function addReverseDep(depId: string, dependentId: string): void {\n if (!definitions[depId]) {\n return;\n }\n if (!dependsOnMe.has(depId)) {\n dependsOnMe.set(depId, new Set());\n }\n dependsOnMe.get(depId)!.add(dependentId);\n }\n\n /**\n * Build reverse dependency map for O(1) lookups in markResolved.\n * Maps each constraint ID to the set of constraints that depend on it via `after`.\n */\n function buildReverseDependencyMap(): void {\n dependsOnMe.clear();\n for (const [id, def] of Object.entries(definitions)) {\n if (!def.after) {\n continue;\n }\n for (const depId of def.after) {\n addReverseDep(depId, id);\n }\n }\n }\n\n /**\n * DFS visitor for cycle detection and topological ordering.\n * Throws on back edges (cycles). Appends to `postOrder` in post-order.\n */\n function topoVisit(\n id: string,\n path: string[],\n visited: Set<string>,\n visiting: Set<string>,\n postOrder: string[],\n ): void {\n if (visited.has(id)) {\n return;\n }\n\n if (visiting.has(id)) {\n const cycleStart = path.indexOf(id);\n const cycle = [...path.slice(cycleStart), id].join(\" \\u2192 \");\n throw new Error(\n `[Directive] Constraint cycle detected: ${cycle}. Remove one of the \\`after\\` dependencies to break the cycle.`,\n );\n }\n\n visiting.add(id);\n path.push(id);\n\n const def = definitions[id];\n if (def?.after) {\n for (const depId of def.after) {\n if (definitions[depId]) {\n topoVisit(depId, path, visited, visiting, postOrder);\n }\n }\n }\n\n path.pop();\n visiting.delete(id);\n visited.add(id);\n postOrder.push(id);\n }\n\n /**\n * Detect cycles in the constraint dependency graph and compute topological order.\n * Uses DFS to find back edges and post-order for topological sort.\n */\n function detectCyclesAndComputeTopoOrder(): void {\n const visited = new Set<string>();\n const visiting = new Set<string>();\n const postOrder: string[] = [];\n\n for (const id of Object.keys(definitions)) {\n topoVisit(id, [], visited, visiting, postOrder);\n }\n\n // Post-order with dependency-first traversal gives us topological order\n topologicalOrder = postOrder;\n\n // Build index map for O(1) lookups during sorting\n topologicalIndex = new Map(\n topologicalOrder.map((id, index) => [id, index]),\n );\n }\n\n // Validate constraint graph (always run - cycle in production would cause deadlock)\n // Also computes topological order for O(n) evaluation\n detectCyclesAndComputeTopoOrder();\n\n // Build reverse dependency map for O(1) markResolved lookups\n buildReverseDependencyMap();\n\n /** Warn about `after` references to non-existent constraints */\n function warnUnknownAfterRefs(): void {\n for (const [id, def] of Object.entries(definitions)) {\n if (!def.after) {\n continue;\n }\n for (const depId of def.after) {\n if (!definitions[depId]) {\n console.warn(\n `[Directive] Constraint \"${id}\" references unknown constraint \"${depId}\" in \\`after\\`. This dependency will be ignored. Check for typos or ensure the constraint exists.`,\n );\n }\n }\n }\n }\n\n // Validate `after` references in dev mode (catch typos early)\n if (process.env.NODE_ENV !== \"production\") {\n warnUnknownAfterRefs();\n }\n\n /**\n * Determine if a constraint is async.\n * Uses the explicit `async` flag if provided, otherwise falls back to runtime detection.\n * Runtime detection is only used on first evaluation and logs a dev warning.\n */\n function isAsyncConstraint(\n id: string,\n def: ConstraintsDef<S>[string],\n ): boolean {\n // Prefer explicit flag to avoid runtime detection side effects\n if (def.async !== undefined) {\n return def.async;\n }\n\n // Check if we've already detected this constraint as async\n if (asyncConstraintIds.has(id)) {\n return true;\n }\n\n // Runtime detection is deferred to first evaluation\n // We'll detect it in evaluateSync if it returns a Promise\n return false;\n }\n\n /** Initialize state for a constraint */\n function initState(id: string): ConstraintState {\n const def = definitions[id];\n if (!def) {\n throw new Error(`[Directive] Unknown constraint: ${id}`);\n }\n\n const isAsync = isAsyncConstraint(id, def);\n if (isAsync) {\n asyncConstraintIds.add(id);\n }\n\n const state: ConstraintState = {\n id,\n priority: def.priority ?? 0,\n isAsync,\n lastResult: null,\n isEvaluating: false,\n error: null,\n lastResolvedAt: null,\n after: def.after ?? [],\n hitCount: 0,\n lastActiveAt: null,\n };\n\n states.set(id, state);\n return state;\n }\n\n /** Get or create state for a constraint */\n function getState(id: string): ConstraintState {\n return states.get(id) ?? initState(id);\n }\n\n /** Check if two dependency sets are equal (returns false for empty sets) */\n function depsEqual(a: Set<string>, b: Set<string>): boolean {\n if (a.size !== b.size || a.size === 0) {\n return false;\n }\n for (const dep of b) {\n if (!a.has(dep)) {\n return false;\n }\n }\n\n return true;\n }\n\n /** Remove a constraint from the reverse fact-to-constraint map */\n function removeFromFactMap(id: string, deps: Set<string>): void {\n for (const dep of deps) {\n const constraints = factToConstraints.get(dep);\n if (!constraints) {\n continue;\n }\n constraints.delete(id);\n if (constraints.size === 0) {\n factToConstraints.delete(dep);\n }\n }\n }\n\n /** Add a constraint to the reverse fact-to-constraint map */\n function addToFactMap(id: string, deps: Set<string>): void {\n for (const dep of deps) {\n if (!factToConstraints.has(dep)) {\n factToConstraints.set(dep, new Set());\n }\n factToConstraints.get(dep)!.add(id);\n }\n }\n\n /** Remove a constraint from all dependency maps */\n function clearConstraintDeps(id: string): void {\n const deps = constraintDeps.get(id);\n if (deps) {\n removeFromFactMap(id, deps);\n constraintDeps.delete(id);\n }\n }\n\n /** Remove a constraint from the reverse dependency map (dependsOnMe) */\n function clearReverseDeps(id: string): void {\n dependsOnMe.delete(id);\n for (const depSet of dependsOnMe.values()) {\n depSet.delete(id);\n }\n }\n\n /** Update dependency tracking for a constraint */\n function updateDependencies(id: string, newDeps: Set<string>): void {\n const oldDeps = constraintDeps.get(id) ?? new Set();\n\n if (depsEqual(oldDeps, newDeps)) {\n return;\n }\n\n removeFromFactMap(id, oldDeps);\n addToFactMap(id, newDeps);\n constraintDeps.set(id, newDeps);\n }\n\n /** Track or evaluate the `when()` predicate, returning the result and recording deps */\n function evaluateWhenPredicate(\n id: string,\n def: ConstraintsDef<S>[string],\n ): boolean | Promise<boolean> {\n if (def.deps) {\n latestWhenDeps.set(id, new Set(def.deps));\n\n return def.when(facts);\n }\n\n // Track dependencies during evaluation\n const tracked = withTracking(() => def.when(facts));\n latestWhenDeps.set(id, tracked.deps);\n\n return tracked.value;\n }\n\n /** Update constraint state after a successful when() evaluation */\n function recordConstraintResult(\n id: string,\n state: ConstraintState,\n result: boolean,\n ): void {\n state.lastResult = result;\n if (result) {\n state.hitCount++;\n state.lastActiveAt = Date.now();\n }\n state.isEvaluating = false;\n onEvaluate?.(id, result);\n }\n\n /** Record a constraint evaluation error */\n function recordConstraintError(\n id: string,\n state: ConstraintState,\n error: unknown,\n ): void {\n state.error = error instanceof Error ? error : new Error(String(error));\n state.lastResult = false;\n state.isEvaluating = false;\n onError?.(id, error);\n }\n\n /** Handle runtime-detected async constraint: mark as async and return wrapped promise */\n function handleRuntimeAsyncResult(\n id: string,\n state: ConstraintState,\n promise: Promise<boolean>,\n ): Promise<boolean> {\n asyncConstraintIds.add(id);\n state.isAsync = true;\n\n if (process.env.NODE_ENV !== \"production\") {\n console.warn(\n `[Directive] Constraint \"${id}\" returned a Promise but was not marked as async. Add \\`async: true\\` to the constraint definition to avoid this warning and improve performance.`,\n );\n }\n\n return promise\n .then((asyncResult) => {\n recordConstraintResult(id, state, asyncResult);\n\n return asyncResult;\n })\n .catch((error) => {\n recordConstraintError(id, state, error);\n\n return false;\n });\n }\n\n /** Evaluate a single sync constraint */\n function evaluateSync(id: string): boolean | Promise<boolean> {\n const def = definitions[id];\n if (!def) {\n return false;\n }\n\n const state = getState(id);\n state.isEvaluating = true;\n state.error = null;\n\n try {\n const result = evaluateWhenPredicate(id, def);\n\n // Runtime async detection: if this was thought to be sync but returns a Promise\n if (result instanceof Promise) {\n return handleRuntimeAsyncResult(id, state, result);\n }\n\n recordConstraintResult(id, state, result);\n\n return result;\n } catch (error) {\n recordConstraintError(id, state, error);\n\n return false;\n }\n }\n\n /** Evaluate a single async constraint with timeout */\n async function evaluateAsync(id: string): Promise<boolean> {\n const def = definitions[id];\n if (!def) {\n return false;\n }\n\n const state = getState(id);\n const timeout = def.timeout ?? defaultTimeout;\n\n state.isEvaluating = true;\n state.error = null;\n\n // Register explicit deps before await (auto-tracking can't work across async boundaries)\n if (def.deps?.length) {\n const depsSet = new Set(def.deps);\n updateDependencies(id, depsSet);\n latestWhenDeps.set(id, depsSet);\n }\n\n try {\n const resultPromise = def.when(facts) as Promise<boolean>;\n\n // Race against timeout (with proper cleanup)\n const result = await withTimeout(\n resultPromise,\n timeout,\n `Constraint \"${id}\" timed out after ${timeout}ms`,\n );\n\n state.lastResult = result;\n if (result) {\n state.hitCount++;\n state.lastActiveAt = Date.now();\n }\n state.isEvaluating = false;\n onEvaluate?.(id, result);\n return result;\n } catch (error) {\n state.error = error instanceof Error ? error : new Error(String(error));\n state.lastResult = false;\n state.isEvaluating = false;\n onError?.(id, error);\n return false;\n }\n }\n\n /** Max requirements per constraint before warning in dev mode */\n const MAX_REQUIREMENTS_WARNING_THRESHOLD = 10;\n\n /**\n * Normalize a requirement output to an array of requirements.\n * - null/undefined → []\n * - single requirement → [requirement]\n * - array → filtered to remove null/undefined\n */\n function normalizeRequirements(\n output: RequirementOutput,\n constraintId?: string,\n ): Requirement[] {\n if (output === null || output === undefined) {\n return [];\n }\n if (Array.isArray(output)) {\n // Filter out null/undefined from arrays\n const filtered = output.filter(\n (r): r is Requirement => r !== null && r !== undefined,\n );\n\n // Warn in dev mode if constraint produces many requirements\n if (\n process.env.NODE_ENV !== \"production\" &&\n filtered.length > MAX_REQUIREMENTS_WARNING_THRESHOLD &&\n constraintId\n ) {\n console.warn(\n `[Directive] Constraint \"${constraintId}\" produced ${filtered.length} requirements. Consider splitting into multiple constraints for better performance.`,\n );\n }\n\n return filtered;\n }\n return [output];\n }\n\n /** Get the requirements for a constraint, tracking dependencies if require is a function */\n function getRequirements(id: string): {\n requirements: Requirement[];\n deps: Set<string>;\n } {\n const def = definitions[id];\n if (!def) {\n return { requirements: [], deps: new Set() };\n }\n\n const requireDef = def.require;\n if (typeof requireDef === \"function\") {\n // Track dependencies when require is a function\n const { value: output, deps } = withTracking(() => requireDef(facts));\n const requirements = normalizeRequirements(\n output as RequirementOutput,\n id,\n );\n return { requirements, deps };\n }\n\n const requirements = normalizeRequirements(\n requireDef as RequirementOutput,\n id,\n );\n return { requirements, deps: new Set() };\n }\n\n /** Merge additional dependencies into existing constraint deps */\n function mergeDependencies(id: string, additionalDeps: Set<string>): void {\n if (additionalDeps.size === 0) {\n return;\n }\n\n const existingDeps = constraintDeps.get(id) ?? new Set();\n for (const dep of additionalDeps) {\n existingDeps.add(dep);\n }\n addToFactMap(id, additionalDeps);\n constraintDeps.set(id, existingDeps);\n }\n\n // Initialize all constraint states and cache sorted order\n let sortedConstraintIds: string[] | null = null;\n\n /**\n * Get constraint IDs sorted by:\n * 1. Priority (higher first)\n * 2. Topological order (dependencies before dependents) for same priority\n * This enables O(n) evaluation in the best case when priorities align with dependencies.\n *\n * Uses cached topologicalIndex for O(1) lookups during comparison.\n */\n function getSortedConstraintIds(): string[] {\n if (!sortedConstraintIds) {\n sortedConstraintIds = Object.keys(definitions).sort((a, b) => {\n const stateA = getState(a);\n const stateB = getState(b);\n\n // Primary sort: priority (higher first)\n const priorityDiff = stateB.priority - stateA.priority;\n if (priorityDiff !== 0) {\n return priorityDiff;\n }\n\n // Secondary sort: topological order (dependencies first)\n // Uses cached topologicalIndex for O(1) lookups\n const topoA = topologicalIndex.get(a) ?? 0;\n const topoB = topologicalIndex.get(b) ?? 0;\n return topoA - topoB;\n });\n }\n return sortedConstraintIds;\n }\n\n for (const id of Object.keys(definitions)) {\n initState(id);\n }\n\n /** Warn about async constraints without explicit deps (dev mode only) */\n function warnAsyncWithoutDeps(defs: ConstraintsDef<S>): void {\n for (const [id, def] of Object.entries(defs)) {\n if (def.async && !def.deps) {\n console.warn(\n `[Directive] Async constraint \"${id}\" has no \\`deps\\` declared. Auto-tracking cannot work across async boundaries. Add \\`deps: [\"key1\", \"key2\"]\\` to enable dependency tracking.`,\n );\n }\n }\n }\n\n // Dev-mode: warn about async constraints without explicit deps\n if (process.env.NODE_ENV !== \"production\") {\n warnAsyncWithoutDeps(definitions);\n }\n\n /**\n * Check if a single `after` dependency is satisfied (resolved, no-fire, disabled, or external).\n */\n function isAfterDepSatisfied(depId: string): boolean {\n // External deps (cross-module) are handled externally\n if (!definitions[depId]) {\n return true;\n }\n // Disabled deps can't fire\n if (disabled.has(depId)) {\n return true;\n }\n // Deps that didn't fire (when returned false) don't block\n if (noFireConstraints.has(depId)) {\n return true;\n }\n\n return resolvedConstraints.has(depId);\n }\n\n /**\n * Check if a constraint's `after` dependencies are satisfied.\n */\n function areAfterDependenciesSatisfied(id: string): boolean {\n const state = states.get(id);\n if (!state || state.after.length === 0) {\n return true;\n }\n\n for (const depId of state.after) {\n if (!isAfterDepSatisfied(depId)) {\n return false;\n }\n }\n\n return true;\n }\n\n /** Handle an inactive constraint: update deps and mark as no-fire */\n function handleInactiveConstraint(id: string): void {\n const whenDeps = latestWhenDeps.get(id);\n if (whenDeps !== undefined) {\n updateDependencies(id, whenDeps);\n }\n noFireConstraints.add(id);\n lastRequirements.set(id, []);\n }\n\n /** Update constraint deps atomically from when + require deps */\n function updateConstraintDeps(\n id: string,\n whenDeps: Set<string> | undefined,\n requireDeps: Set<string>,\n ): void {\n if (whenDeps !== undefined) {\n // Combine when() + require() deps atomically to prevent\n // require deps from being temporarily lost between updates\n const combinedDeps = new Set(whenDeps);\n for (const dep of requireDeps) {\n combinedDeps.add(dep);\n }\n updateDependencies(id, combinedDeps);\n } else {\n // Async constraint (no when deps tracked) — merge additively\n mergeDependencies(id, requireDeps);\n }\n }\n\n /** Emit requirements for an active constraint into the requirement set */\n function emitConstraintRequirements(\n id: string,\n reqs: Requirement[],\n requirements: RequirementSet,\n ): void {\n if (reqs.length === 0) {\n lastRequirements.set(id, []);\n\n return;\n }\n const reqsWithId = reqs.map((req) =>\n createRequirementWithId(req, id, requirementKeys[req.type]),\n );\n for (const reqWithId of reqsWithId) {\n requirements.add(reqWithId);\n }\n lastRequirements.set(id, reqsWithId);\n }\n\n /** Add cached requirements into the requirement set */\n function addCachedRequirements(\n reqs: RequirementWithId[],\n requirements: RequirementSet,\n ): void {\n for (const req of reqs) {\n requirements.add(req);\n }\n }\n\n /**\n * Process a constraint result: handle requirements and track no-fire state.\n * Extracted from evaluate() to reduce nesting-based cognitive complexity.\n */\n function processConstraintResult(\n id: string,\n active: boolean,\n requirements: RequirementSet,\n ): void {\n if (disabled.has(id)) {\n return;\n }\n\n if (!active) {\n handleInactiveConstraint(id);\n\n return;\n }\n\n // Remove from no-fire tracking since it fired\n noFireConstraints.delete(id);\n\n const whenDeps = latestWhenDeps.get(id);\n let reqs: Requirement[];\n let requireDeps: Set<string>;\n try {\n const result = getRequirements(id);\n reqs = result.requirements;\n requireDeps = result.deps;\n } catch (error) {\n onError?.(id, error);\n handleInactiveConstraint(id);\n\n return;\n }\n\n updateConstraintDeps(id, whenDeps, requireDeps);\n emitConstraintRequirements(id, reqs, requirements);\n }\n\n /** Partition constraint IDs into blocked and ready based on `after` deps */\n function partitionByReadiness(\n constraintIds: string[],\n requirements: RequirementSet,\n ): { blocked: string[]; ready: string[] } {\n const blocked: string[] = [];\n const ready: string[] = [];\n\n for (const id of constraintIds) {\n if (areAfterDependenciesSatisfied(id)) {\n ready.push(id);\n continue;\n }\n blocked.push(id);\n const lastReqs = lastRequirements.get(id);\n if (lastReqs) {\n addCachedRequirements(lastReqs, requirements);\n }\n }\n\n return { blocked, ready };\n }\n\n /** Evaluate sync constraints, returning any that turned out to be async at runtime */\n function evaluateSyncBatch(\n syncIds: string[],\n requirements: RequirementSet,\n ): Array<{ id: string; promise: Promise<boolean> }> {\n const unexpectedAsync: Array<{ id: string; promise: Promise<boolean> }> =\n [];\n\n for (const id of syncIds) {\n const result = evaluateSync(id);\n\n if (result instanceof Promise) {\n unexpectedAsync.push({ id, promise: result });\n continue;\n }\n\n processConstraintResult(id, result, requirements);\n }\n\n return unexpectedAsync;\n }\n\n /** Await an array of {id, promise} pairs and process each result */\n async function awaitAndProcess(\n pairs: Array<{ id: string; promise: Promise<boolean> }>,\n requirements: RequirementSet,\n ): Promise<void> {\n const results = await Promise.all(\n pairs.map(async ({ id, promise }) => ({\n id,\n active: await promise,\n })),\n );\n for (const { id, active } of results) {\n processConstraintResult(id, active, requirements);\n }\n }\n\n /**\n * Evaluate constraints, respecting `after` dependencies.\n * Returns list of constraints that are still blocked after this pass.\n */\n async function evaluateConstraintBatch(\n constraintIds: string[],\n requirements: RequirementSet,\n ): Promise<string[]> {\n const { blocked, ready } = partitionByReadiness(\n constraintIds,\n requirements,\n );\n\n if (ready.length === 0) {\n return blocked;\n }\n\n // Separate sync and async constraints from ready-to-evaluate\n const syncConstraints: string[] = [];\n const asyncConstraints: string[] = [];\n\n for (const id of ready) {\n if (getState(id).isAsync) {\n asyncConstraints.push(id);\n } else {\n syncConstraints.push(id);\n }\n }\n\n // Evaluate sync constraints first (some may turn out async at runtime)\n const unexpectedAsync = evaluateSyncBatch(syncConstraints, requirements);\n\n // Handle sync constraints that turned out to be async\n if (unexpectedAsync.length > 0) {\n await awaitAndProcess(unexpectedAsync, requirements);\n }\n\n // Evaluate async constraints in parallel\n if (asyncConstraints.length > 0) {\n const asyncPairs = asyncConstraints.map((id) => ({\n id,\n promise: evaluateAsync(id),\n }));\n await awaitAndProcess(asyncPairs, requirements);\n }\n\n return blocked;\n }\n\n /** Collect enabled constraint IDs affected by a set of changed fact keys */\n function collectAffectedByKeys(\n changedKeys: Set<string>,\n into: Set<string>,\n ): void {\n for (const key of changedKeys) {\n const deps = factToConstraints.get(key);\n if (!deps) {\n continue;\n }\n for (const id of deps) {\n if (!disabled.has(id)) {\n into.add(id);\n }\n }\n }\n }\n\n /** Collect enabled dirty constraints into a set */\n function collectDirtyConstraints(into: Set<string>): void {\n for (const id of dirtyConstraints) {\n if (!disabled.has(id)) {\n into.add(id);\n }\n }\n dirtyConstraints.clear();\n }\n\n /** Compute the set of affected constraint IDs from changed keys + dirty set */\n function computeAffectedConstraints(changedKeys: Set<string>): Set<string> {\n const affected = new Set<string>();\n collectAffectedByKeys(changedKeys, affected);\n collectDirtyConstraints(affected);\n\n return affected;\n }\n\n /** Carry forward cached requirements for constraints not being re-evaluated */\n function carryForwardRequirements(\n allIds: string[],\n affected: Set<string>,\n requirements: RequirementSet,\n ): void {\n for (const id of allIds) {\n if (affected.has(id)) {\n continue;\n }\n const lastReqs = lastRequirements.get(id);\n if (lastReqs) {\n addCachedRequirements(lastReqs, requirements);\n }\n }\n }\n\n const manager: ConstraintsManager<S> = {\n async evaluate(changedKeys?: Set<string>): Promise<RequirementWithId[]> {\n const requirements = new RequirementSet();\n\n // Note: resolvedConstraints persists across reconcile cycles intentionally.\n // `after` ordering means \"wait until dependency's resolver has completed\",\n // and that completion happens in a different cycle than the evaluation.\n // noFireConstraints is re-populated during each evaluation pass.\n noFireConstraints.clear();\n\n // Get all enabled constraints (use cached sort order)\n const allConstraintIds = getSortedConstraintIds().filter(\n (id) => !disabled.has(id),\n );\n\n // Determine which constraints to evaluate\n let constraintsToEvaluate: string[];\n\n if (!hasEvaluated || !changedKeys || changedKeys.size === 0) {\n // First evaluation or no specific changes: evaluate all\n constraintsToEvaluate = allConstraintIds;\n hasEvaluated = true;\n } else {\n const affected = computeAffectedConstraints(changedKeys);\n constraintsToEvaluate = [...affected];\n carryForwardRequirements(allConstraintIds, affected, requirements);\n }\n\n // Evaluate constraints in passes until no blocked constraints become unblocked\n let remainingToEvaluate = constraintsToEvaluate;\n let maxPasses = constraintsToEvaluate.length + 1; // Prevent infinite loops\n\n while (remainingToEvaluate.length > 0 && maxPasses > 0) {\n const previousRemaining = remainingToEvaluate.length;\n remainingToEvaluate = await evaluateConstraintBatch(\n remainingToEvaluate,\n requirements,\n );\n\n // If no progress was made (all still blocked), break\n if (remainingToEvaluate.length === previousRemaining) {\n break;\n }\n maxPasses--;\n }\n\n return requirements.all();\n },\n\n getState(id: string): ConstraintState | undefined {\n return states.get(id);\n },\n\n getDependencies(id: string): Set<string> | undefined {\n return constraintDeps.get(id);\n },\n\n getAllStates(): ConstraintState[] {\n return [...states.values()];\n },\n\n disable(id: string): void {\n if (!states.has(id)) {\n console.warn(\n `[Directive] constraints.disable(\"${id}\") — no such constraint`,\n );\n\n return;\n }\n disabled.add(id);\n // Invalidate cache when constraints change\n sortedConstraintIds = null;\n // Mark as dirty so it gets removed from requirements on next evaluate\n lastRequirements.delete(id);\n // Clean up dependency maps for disabled constraint\n clearConstraintDeps(id);\n latestWhenDeps.delete(id);\n },\n\n enable(id: string): void {\n if (!states.has(id)) {\n console.warn(\n `[Directive] constraints.enable(\"${id}\") — no such constraint`,\n );\n\n return;\n }\n disabled.delete(id);\n // Invalidate cache when constraints change\n sortedConstraintIds = null;\n // Mark as dirty so it gets evaluated on next cycle\n dirtyConstraints.add(id);\n },\n\n isDisabled(id: string): boolean {\n return disabled.has(id);\n },\n\n invalidate(factKey: string): void {\n // Mark all constraints that depend on this fact as dirty\n const dependentConstraints = factToConstraints.get(factKey);\n if (dependentConstraints) {\n for (const id of dependentConstraints) {\n dirtyConstraints.add(id);\n }\n }\n },\n\n markResolved(constraintId: string): void {\n resolvedConstraints.add(constraintId);\n const state = states.get(constraintId);\n if (state) {\n state.lastResolvedAt = Date.now();\n }\n\n // Mark all constraints that depend on this one (via `after`) as dirty\n // so they get re-evaluated on the next reconcile\n // Uses reverse dependency map for O(1) lookup instead of O(n*m) iteration\n const dependents = dependsOnMe.get(constraintId);\n if (dependents) {\n for (const id of dependents) {\n dirtyConstraints.add(id);\n }\n }\n },\n\n isResolved(constraintId: string): boolean {\n return resolvedConstraints.has(constraintId);\n },\n\n registerDefinitions(newDefs: ConstraintsDef<Schema>): void {\n let hasAfterDeps = false;\n for (const [key, def] of Object.entries(newDefs)) {\n (definitions as Record<string, unknown>)[key] = def;\n initState(key);\n dirtyConstraints.add(key);\n if (def.after?.length) {\n hasAfterDeps = true;\n }\n }\n // Invalidate cached sort order\n sortedConstraintIds = null;\n // Only rebuild topo order when new constraints have `after` dependencies\n if (hasAfterDeps) {\n detectCyclesAndComputeTopoOrder();\n }\n // Always rebuild reverse deps — existing constraints may reference\n // newly-added IDs in their `after` arrays (forward references)\n buildReverseDependencyMap();\n },\n\n assignDefinition(id: string, def: ConstraintsDef<Schema>[string]): void {\n if (!definitions[id]) {\n throw new Error(\n `[Directive] Cannot assign constraint \"${id}\" — it does not exist. Use register() to create it.`,\n );\n }\n\n // Replace definition\n (definitions as Record<string, unknown>)[id] = def;\n // Re-init state for the new definition\n initState(id);\n dirtyConstraints.add(id);\n // Invalidate cached sort order (priority may have changed)\n sortedConstraintIds = null;\n // Rebuild topo order + reverse deps in case `after` changed\n detectCyclesAndComputeTopoOrder();\n buildReverseDependencyMap();\n },\n\n unregisterDefinition(id: string): void {\n if (!definitions[id]) {\n return;\n }\n\n // Remove from all internal maps\n delete (definitions as Record<string, unknown>)[id];\n states.delete(id);\n disabled.delete(id);\n asyncConstraintIds.delete(id);\n dirtyConstraints.delete(id);\n noFireConstraints.delete(id);\n resolvedConstraints.delete(id);\n lastRequirements.delete(id);\n latestWhenDeps.delete(id);\n\n // Clean dependency and reverse dependency maps\n clearConstraintDeps(id);\n clearReverseDeps(id);\n\n // Invalidate cached sort order\n sortedConstraintIds = null;\n // Rebuild topo order\n detectCyclesAndComputeTopoOrder();\n buildReverseDependencyMap();\n },\n\n async callOne(\n id: string,\n props?: Record<string, unknown>,\n ): Promise<RequirementWithId[]> {\n const def = definitions[id];\n if (!def) {\n throw new Error(\n `[Directive] Cannot call constraint \"${id}\" — it does not exist.`,\n );\n }\n\n // Respect disabled state\n if (disabled.has(id)) {\n return [];\n }\n\n const state = getState(id);\n let active: boolean;\n\n if (state.isAsync) {\n active = await evaluateAsync(id);\n } else {\n const result = evaluateSync(id);\n active = result instanceof Promise ? await result : result;\n }\n\n if (!active) {\n return [];\n }\n\n // Get requirements and merge props if provided\n const { requirements: reqs } = getRequirements(id);\n if (reqs.length === 0) {\n return [];\n }\n\n const result: RequirementWithId[] = [];\n for (const req of reqs) {\n const merged = props ? { ...req, ...props } : req;\n result.push(\n createRequirementWithId(merged, id, requirementKeys[merged.type]),\n );\n }\n\n return result;\n },\n\n setRequirementKey(requirementType: string, keyFn: RequirementKeyFn): void {\n requirementKeys[requirementType] = keyFn;\n },\n\n removeRequirementKey(requirementType: string): void {\n delete requirementKeys[requirementType];\n },\n };\n\n return manager;\n}\n","/**\n * Derivations - Auto-tracked computed values with composition\n *\n * Features:\n * - Automatic dependency tracking (no manual deps arrays)\n * - Memoization with smart invalidation\n * - Derivation composition (derivations can depend on other derivations)\n * - Circular dependency detection\n * - Lazy evaluation\n */\n\nimport { BLOCKED_PROPS, trackAccess, withTracking } from \"./tracking.js\";\nimport type {\n DerivationState,\n DerivationsDef,\n DerivedValues,\n Facts,\n Schema,\n} from \"./types.js\";\n\n// ============================================================================\n// Derivations Manager\n// ============================================================================\n\nexport interface DerivationsManager<\n S extends Schema,\n D extends DerivationsDef<S>,\n> {\n /** Get a derived value (computes if stale) */\n get<K extends keyof D>(id: K): ReturnType<D[K]>;\n /** Check if a derivation is stale */\n isStale(id: keyof D): boolean;\n /** Invalidate derivations that depend on a fact key */\n invalidate(factKey: string): void;\n /** Invalidate derivations for multiple fact keys, notifying listeners once at the end */\n invalidateMany(factKeys: Iterable<string>): void;\n /** Invalidate all derivations */\n invalidateAll(): void;\n /** Subscribe to derivation changes */\n subscribe(ids: Array<keyof D>, listener: () => void): () => void;\n /** Get the proxy for composition */\n getProxy(): DerivedValues<S, D>;\n /** Get dependencies for a derivation */\n getDependencies(id: keyof D): Set<string>;\n /** Register new derivation definitions (for dynamic module registration) */\n registerDefinitions(newDefs: DerivationsDef<S>): void;\n /** Override an existing derivation function */\n assignDefinition(\n id: string,\n fn: DerivationsDef<S>[keyof DerivationsDef<S>],\n ): void;\n /** Remove a derivation and clean up its state */\n unregisterDefinition(id: string): void;\n /** Compute a derivation immediately (ignores cache) */\n callOne(id: string): unknown;\n}\n\n/** Options for creating a derivations manager */\nexport interface CreateDerivationsOptions<\n S extends Schema,\n D extends DerivationsDef<S>,\n> {\n definitions: D;\n facts: Facts<S>;\n /** Callback when a derivation is computed */\n onCompute?: (\n id: string,\n value: unknown,\n oldValue: unknown,\n deps: string[],\n ) => void;\n /** Callback when a derivation is invalidated */\n onInvalidate?: (id: string) => void;\n /** Callback when a derivation errors */\n onError?: (id: string, error: unknown) => void;\n}\n\n/**\n * Create a manager for lazily-evaluated, auto-tracked derived values.\n *\n * Derivations are memoized computations that automatically track which facts\n * they read. When a tracked fact changes, the derivation is invalidated and\n * recomputed on next access. Derivations can depend on other derivations\n * (composition), and circular dependencies are detected at compute time.\n *\n * Notifications are deferred during invalidation so listeners always see\n * consistent state across multiple simultaneous fact changes.\n *\n * @param options - Derivation definitions, facts proxy, store, and optional\n * lifecycle callbacks.\n * @returns A {@link DerivationsManager} for accessing, invalidating, and\n * subscribing to derived values.\n *\n * @internal\n */\nexport function createDerivationsManager<\n S extends Schema,\n D extends DerivationsDef<S>,\n>(options: CreateDerivationsOptions<S, D>): DerivationsManager<S, D> {\n const { definitions, facts, onCompute, onInvalidate, onError } = options;\n\n // Internal state for each derivation\n const states = new Map<string, DerivationState<unknown>>();\n const listeners = new Map<string, Set<() => void>>();\n\n // Track which derivations depend on which fact keys\n const factToDerivedDeps = new Map<string, Set<string>>();\n // Track which derivations depend on which other derivations\n const derivedToDerivedDeps = new Map<string, Set<string>>();\n\n // Deferred notification: during invalidation, collect IDs to notify.\n // Listeners fire AFTER all invalidations complete so they see consistent state.\n let invalidationDepth = 0;\n const pendingNotifications = new Set<string>();\n let isFlushing = false;\n const MAX_FLUSH_ITERATIONS = 100;\n\n // The proxy for composition (derivations accessing other derivations)\n // biome-ignore lint/style/useConst: Reassigned later in createDerivedProxy()\n let derivedProxy: DerivedValues<S, D>;\n\n // ---- Shared dependency-map helpers ----\n\n /**\n * Remove `id` from the dep-set keyed by `dep`. Deletes empty sets.\n * Uses `states.has(dep)` (not `definitions`) because during unregister\n * the definition may already be deleted while state still exists.\n */\n function removeDepLink(dep: string, id: string): void {\n const map = states.has(dep) ? derivedToDerivedDeps : factToDerivedDeps;\n const depSet = map.get(dep);\n depSet?.delete(id);\n if (depSet && depSet.size === 0) {\n map.delete(dep);\n }\n }\n\n /**\n * Add `id` to the dep-set keyed by `dep`, creating the set if needed.\n * Uses `definitions[dep]` (not `states`) because when adding a new link\n * the definition must exist — this is the forward path during recomputation.\n */\n function addDepLink(dep: string, id: string): void {\n const map = definitions[dep as keyof D]\n ? derivedToDerivedDeps\n : factToDerivedDeps;\n let depSet = map.get(dep);\n if (!depSet) {\n depSet = new Set();\n map.set(dep, depSet);\n }\n depSet.add(id);\n }\n\n /** Remove `id` from all dependency maps it participates in */\n function removeOwnDepLinks(id: string): void {\n const state = states.get(id);\n if (!state) {\n return;\n }\n for (const dep of state.dependencies) {\n removeDepLink(dep, id);\n }\n }\n\n /** Invalidate derivations that depend on `id`, then clean up its entry */\n function invalidateDependentsOf(id: string): void {\n const dependents = derivedToDerivedDeps.get(id);\n if (!dependents) {\n return;\n }\n\n invalidationDepth++;\n try {\n for (const dependent of dependents) {\n invalidateDerivation(dependent);\n }\n } finally {\n invalidationDepth--;\n }\n derivedToDerivedDeps.delete(id);\n }\n\n /** Remove a derivation from all internal maps */\n function purgeFromMaps(id: string): void {\n delete (definitions as Record<string, unknown>)[id];\n states.delete(id);\n listeners.delete(id);\n pendingNotifications.delete(id);\n }\n\n /** Initialize state for a derivation */\n function initState(id: string): DerivationState<unknown> {\n const def = definitions[id as keyof D];\n if (!def) {\n throw new Error(`[Directive] Unknown derivation: ${id}`);\n }\n\n const state: DerivationState<unknown> = {\n id,\n compute: () => computeDerivation(id),\n cachedValue: undefined,\n dependencies: new Set(),\n isStale: true,\n isComputing: false,\n };\n\n states.set(id, state);\n return state;\n }\n\n /** Get or create state for a derivation */\n function getState(id: string): DerivationState<unknown> {\n return states.get(id) ?? initState(id);\n }\n\n /** Compute a derivation and track its dependencies */\n function computeDerivation(id: string): unknown {\n const state = getState(id);\n const def = definitions[id as keyof D];\n\n if (!def) {\n throw new Error(`[Directive] Unknown derivation: ${id}`);\n }\n\n // Circular dependency detection\n if (state.isComputing) {\n throw new Error(\n `[Directive] Circular dependency detected in derivation: ${id}`,\n );\n }\n\n state.isComputing = true;\n\n try {\n // Capture old value before recomputation\n const oldValue = state.cachedValue;\n\n // Compute with tracking\n const { value, deps } = withTracking(() => def(facts, derivedProxy));\n\n // Update state\n state.cachedValue = value;\n state.isStale = false;\n\n // Update dependency tracking\n updateDependencies(id, deps);\n\n // Notify callback\n onCompute?.(id, value, oldValue, [...deps]);\n\n return value;\n } catch (error) {\n onError?.(id, error);\n throw error;\n } finally {\n state.isComputing = false;\n }\n }\n\n /** Check whether two Sets contain the same elements */\n function setsEqual(a: Set<string>, b: Set<string>): boolean {\n if (a.size !== b.size) {\n return false;\n }\n for (const dep of b) {\n if (!a.has(dep)) {\n return false;\n }\n }\n\n return true;\n }\n\n /** Update dependency tracking for a derivation */\n function updateDependencies(id: string, newDeps: Set<string>): void {\n const state = getState(id);\n const oldDeps = state.dependencies;\n\n if (setsEqual(oldDeps, newDeps)) {\n return;\n }\n\n for (const dep of oldDeps) {\n removeDepLink(dep, id);\n }\n for (const dep of newDeps) {\n addDepLink(dep, id);\n }\n\n state.dependencies = newDeps;\n }\n\n /** Notify all listeners for the given derivation ids */\n function notifyListeners(ids: string[]): void {\n for (const id of ids) {\n const fns = listeners.get(id);\n if (fns) {\n for (const listener of fns) {\n listener();\n }\n }\n }\n }\n\n /** Flush deferred notifications after all invalidations complete */\n function flushNotifications(): void {\n if (invalidationDepth > 0 || isFlushing) {\n return;\n }\n\n isFlushing = true;\n try {\n // Loop until no more pending — listeners may trigger new invalidations\n // that add to pendingNotifications via re-entrant invalidate() calls.\n let iterations = 0;\n while (pendingNotifications.size > 0) {\n if (++iterations > MAX_FLUSH_ITERATIONS) {\n const remaining = [...pendingNotifications];\n pendingNotifications.clear();\n throw new Error(\n `[Directive] Infinite derivation notification loop detected after ${MAX_FLUSH_ITERATIONS} iterations. Remaining: ${remaining.join(\", \")}. This usually means a derivation listener is mutating facts that re-trigger the same derivation.`,\n );\n }\n\n const ids = [...pendingNotifications];\n pendingNotifications.clear();\n notifyListeners(ids);\n }\n } finally {\n isFlushing = false;\n }\n }\n\n /** Enqueue transitive dependents of `id` into the work queue */\n function enqueueDependents(id: string, queue: string[]): void {\n const dependents = derivedToDerivedDeps.get(id);\n if (!dependents) {\n return;\n }\n for (const dependent of dependents) {\n queue.push(dependent);\n }\n }\n\n /**\n * Invalidate a derivation and its transitive dependents using iterative\n * traversal (work queue) to avoid stack overflow on deep chains.\n *\n * Accepts an optional shared `visited` Set so that `invalidateMany` can\n * coalesce multiple root invalidations into a single traversal.\n */\n function invalidateDerivation(\n startId: string,\n visited = new Set<string>(),\n ): void {\n const queue = [startId];\n\n while (queue.length > 0) {\n const id = queue.pop()!;\n if (visited.has(id)) {\n continue;\n }\n visited.add(id);\n\n const state = states.get(id);\n if (!state || state.isStale) {\n continue;\n }\n\n state.isStale = true;\n onInvalidate?.(id);\n\n // Defer listener notification until all invalidations complete.\n // This prevents listeners from observing partially-stale state and\n // avoids infinite loops from Set mutation during iteration (listeners\n // recompute derivations → updateDependencies → modify dep Sets).\n pendingNotifications.add(id);\n\n enqueueDependents(id, queue);\n }\n }\n\n // Create the proxy for composition\n derivedProxy = new Proxy({} as DerivedValues<S, D>, {\n get(_, prop: string | symbol) {\n if (typeof prop === \"symbol\") {\n return undefined;\n }\n if (BLOCKED_PROPS.has(prop)) {\n return undefined;\n }\n\n // Return undefined for unknown derivation keys instead of throwing.\n // React 19 dev-mode traverses objects accessing $$typeof, toJSON, then, etc.\n if (!definitions[prop as keyof D]) {\n return undefined;\n }\n\n // Track this derivation access so the consuming derivation\n // records a dependency on it (enables composition invalidation)\n trackAccess(prop);\n\n const state = getState(prop);\n\n // Recompute if stale\n if (state.isStale) {\n computeDerivation(prop);\n }\n\n return state.cachedValue;\n },\n\n set() {\n return false;\n },\n\n deleteProperty() {\n return false;\n },\n\n defineProperty() {\n return false;\n },\n\n getPrototypeOf() {\n return null;\n },\n\n setPrototypeOf() {\n return false;\n },\n });\n\n // Note: Fact change invalidation is handled by the engine calling invalidate()\n\n const manager: DerivationsManager<S, D> = {\n get<K extends keyof D>(id: K): ReturnType<D[K]> {\n const state = getState(id as string);\n\n if (state.isStale) {\n computeDerivation(id as string);\n }\n\n return state.cachedValue as ReturnType<D[K]>;\n },\n\n isStale(id: keyof D): boolean {\n const state = states.get(id as string);\n return state?.isStale ?? true;\n },\n\n invalidate(factKey: string): void {\n const dependents = factToDerivedDeps.get(factKey);\n if (!dependents) return;\n\n invalidationDepth++;\n const visited = new Set<string>();\n try {\n for (const id of dependents) {\n invalidateDerivation(id, visited);\n }\n } finally {\n invalidationDepth--;\n flushNotifications();\n }\n },\n\n invalidateMany(factKeys: Iterable<string>): void {\n invalidationDepth++;\n // Share a single visited Set across all root invalidations so\n // transitive dependents are only processed once.\n const visited = new Set<string>();\n try {\n for (const factKey of factKeys) {\n const dependents = factToDerivedDeps.get(factKey);\n if (!dependents) continue;\n for (const id of dependents) {\n invalidateDerivation(id, visited);\n }\n }\n } finally {\n invalidationDepth--;\n flushNotifications();\n }\n },\n\n invalidateAll(): void {\n invalidationDepth++;\n try {\n for (const state of states.values()) {\n if (!state.isStale) {\n state.isStale = true;\n pendingNotifications.add(state.id);\n }\n }\n } finally {\n invalidationDepth--;\n flushNotifications();\n }\n },\n\n subscribe(ids: Array<keyof D>, listener: () => void): () => void {\n for (const id of ids) {\n const idStr = id as string;\n if (!listeners.has(idStr)) {\n listeners.set(idStr, new Set());\n }\n listeners.get(idStr)!.add(listener);\n }\n\n return () => {\n for (const id of ids) {\n const idStr = id as string;\n const listenerSet = listeners.get(idStr);\n listenerSet?.delete(listener);\n // Clean up empty Sets to prevent memory leaks\n if (listenerSet && listenerSet.size === 0) {\n listeners.delete(idStr);\n }\n }\n };\n },\n\n getProxy(): DerivedValues<S, D> {\n return derivedProxy;\n },\n\n getDependencies(id: keyof D): Set<string> {\n return getState(id as string).dependencies;\n },\n\n registerDefinitions(newDefs: DerivationsDef<S>): void {\n for (const [key, fn] of Object.entries(newDefs)) {\n (definitions as Record<string, unknown>)[key] = fn;\n initState(key);\n }\n },\n\n assignDefinition(\n id: string,\n fn: DerivationsDef<S>[keyof DerivationsDef<S>],\n ): void {\n if (!definitions[id as keyof D]) {\n throw new Error(\n `[Directive] Cannot assign derivation \"${id}\" — it does not exist. Use register() to create it.`,\n );\n }\n\n // Replace definition\n (definitions as Record<string, unknown>)[id] = fn;\n\n // Mark stale so it recomputes with the new function\n const state = states.get(id);\n if (state) {\n state.isStale = true;\n pendingNotifications.add(id);\n }\n\n flushNotifications();\n },\n\n unregisterDefinition(id: string): void {\n if (!definitions[id as keyof D]) {\n return;\n }\n\n removeOwnDepLinks(id);\n invalidateDependentsOf(id);\n purgeFromMaps(id);\n\n flushNotifications();\n },\n\n callOne(id: string): unknown {\n const def = definitions[id as keyof D];\n if (!def) {\n throw new Error(\n `[Directive] Cannot call derivation \"${id}\" — it does not exist.`,\n );\n }\n\n // Always recompute (call ignores cache)\n return computeDerivation(id);\n },\n };\n\n return manager;\n}\n","/**\n * Effects - Fire-and-forget side effects\n *\n * Features:\n * - Separate from requirement resolution\n * - Error isolation (never breaks reconciliation)\n * - Optional explicit dependencies for optimization\n * - Runs after facts stabilize\n *\n * IMPORTANT: Auto-tracking limitations\n * ------------------------------------\n * When using auto-tracking (no explicit `deps`), only SYNCHRONOUS fact accesses\n * are tracked. If your effect reads facts after an `await`, those reads are NOT\n * tracked and won't trigger the effect on future changes.\n *\n * For async effects, always use explicit `deps`:\n * @example\n * ```typescript\n * effects: {\n * // BAD: fetchData is async, facts.userId read after await won't be tracked\n * badEffect: {\n * run: async (facts) => {\n * await someAsyncOp();\n * console.log(facts.userId); // NOT tracked!\n * },\n * },\n * // GOOD: explicit deps for async effects\n * goodEffect: {\n * deps: [\"userId\"],\n * run: async (facts) => {\n * await someAsyncOp();\n * console.log(facts.userId); // Works because we declared the dep\n * },\n * },\n * }\n * ```\n */\n\nimport { withTracking } from \"./tracking.js\";\nimport type {\n EffectsDef,\n Facts,\n FactsStore,\n InferSchema,\n Schema,\n} from \"./types.js\";\n\n// ============================================================================\n// Effects Manager\n// ============================================================================\n\n/**\n * Manager returned by {@link createEffectsManager} that runs fire-and-forget\n * side effects after facts stabilize.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport interface EffectsManager<_S extends Schema = Schema> {\n /**\n * Run all effects whose tracked dependencies overlap with `changedKeys`.\n *\n * @remarks\n * Effects with no recorded dependencies (first run or auto-tracked with no\n * reads) run on any change. After execution, a snapshot of current facts is\n * stored for the `prev` parameter on the next invocation.\n *\n * @param changedKeys - Fact keys that changed since the last run.\n */\n runEffects(changedKeys: Set<string>): Promise<void>;\n /**\n * Run every enabled effect unconditionally, regardless of dependencies.\n */\n runAll(): Promise<void>;\n /**\n * Disable an effect so it is skipped during subsequent runs.\n *\n * @param id - The effect definition ID.\n */\n disable(id: string): void;\n /**\n * Re-enable a previously disabled effect.\n *\n * @param id - The effect definition ID.\n */\n enable(id: string): void;\n /**\n * Check whether an effect is currently enabled.\n *\n * @param id - The effect definition ID.\n * @returns `true` if the effect has not been disabled.\n */\n isEnabled(id: string): boolean;\n /**\n * Invoke every stored cleanup function and mark the manager as stopped.\n *\n * @remarks\n * After this call, any cleanup functions returned by in-flight async effects\n * will be invoked immediately rather than stored.\n */\n cleanupAll(): void;\n /**\n * Register additional effect definitions at runtime (used for dynamic\n * module registration).\n *\n * @param newDefs - New effect definitions to merge into the manager.\n */\n registerDefinitions(newDefs: EffectsDef<Schema>): void;\n /**\n * Override an existing effect definition. Runs cleanup of the old effect first.\n *\n * @param id - The effect definition ID to override.\n * @param def - The new effect definition.\n * @throws If no effect with this ID exists.\n */\n assignDefinition(id: string, def: EffectsDef<Schema>[string]): void;\n /**\n * Remove an effect definition. Runs cleanup (try-catch) and removes from state.\n *\n * @param id - The effect definition ID to remove.\n */\n unregisterDefinition(id: string): void;\n /**\n * Execute an effect's `run()` function immediately.\n *\n * @param id - The effect definition ID.\n */\n callOne(id: string): Promise<void>;\n}\n\n/** Number of consecutive identical dep sets before skipping re-tracking */\nconst STABLE_THRESHOLD = 3;\n\n/** Internal effect state */\ninterface EffectState {\n id: string;\n enabled: boolean;\n hasExplicitDeps: boolean; // true = user-provided deps (fixed), false = auto-tracked (re-track every run)\n dependencies: Set<string> | null; // null = not yet tracked\n cleanup: (() => void) | null; // cleanup function returned by last run()\n /** How many consecutive runs produced the same deps (auto-tracked only) */\n stableRunCount: number;\n /** Once true, skip withTracking() overhead until a tracked fact mutates */\n depsStable: boolean;\n}\n\n/**\n * Configuration options accepted by {@link createEffectsManager}.\n *\n * @internal\n */\nexport interface CreateEffectsOptions<S extends Schema> {\n /** Effect definitions keyed by ID. */\n definitions: EffectsDef<S>;\n /** Proxy-based facts object passed to effect `run()` functions. */\n facts: Facts<S>;\n /** Underlying fact store used for `batch()` coalescing of mutations. */\n store: FactsStore<S>;\n /** Called when an effect executes, with the fact keys that triggered it. */\n onRun?: (id: string, deps: string[]) => void;\n /** Called when an effect's `run()` or cleanup function throws. */\n onError?: (id: string, error: unknown) => void;\n}\n\n/**\n * Create a manager for fire-and-forget side effects that run after facts\n * stabilize.\n *\n * @remarks\n * Effects support two dependency modes:\n *\n * - **Auto-tracked** (no `deps`): Dependencies are re-tracked on every run\n * via {@link withTracking}, so conditional fact reads are always captured.\n * Only synchronous reads are tracked; reads after an `await` are invisible.\n *\n * - **Explicit `deps`**: A fixed array of fact keys declared on the definition.\n * Preferred for async effects where auto-tracking cannot cross `await`\n * boundaries.\n *\n * Each effect can return a cleanup function that runs before the next\n * execution or when {@link EffectsManager.cleanupAll | cleanupAll} is called.\n * Errors in effects are isolated via try-catch and never break the\n * reconciliation loop. Synchronous fact mutations inside effects are\n * coalesced with `store.batch()`.\n *\n * @param options - Configuration including effect definitions, facts proxy,\n * store, and lifecycle callbacks.\n * @returns An {@link EffectsManager} for running, enabling/disabling, and\n * cleaning up effects.\n *\n * @example\n * ```typescript\n * const effects = createEffectsManager({\n * definitions: {\n * logPhase: {\n * run: (facts, prev) => {\n * if (prev?.phase !== facts.phase) {\n * console.log(`Phase changed to ${facts.phase}`);\n * }\n * },\n * },\n * },\n * facts: factsProxy,\n * store: factsStore,\n * });\n *\n * await effects.runEffects(new Set([\"phase\"]));\n * ```\n *\n * @internal\n */\nexport function createEffectsManager<S extends Schema>(\n options: CreateEffectsOptions<S>,\n): EffectsManager<S> {\n const { definitions, facts, store, onRun, onError } = options;\n\n // Internal state for each effect\n const states = new Map<string, EffectState>();\n\n // Previous facts snapshot for comparison (plain object for bracket-style proxy access)\n let previousSnapshot: Record<string, unknown> | null = null;\n\n // Track whether cleanupAll has been called (system stopped/destroyed).\n // If an async effect resolves after stop, its cleanup is invoked immediately.\n let stopped = false;\n\n /** Initialize state for an effect */\n function initState(id: string): EffectState {\n const def = definitions[id];\n if (!def) {\n throw new Error(`[Directive] Unknown effect: ${id}`);\n }\n\n const state: EffectState = {\n id,\n enabled: true,\n hasExplicitDeps: !!def.deps,\n dependencies: def.deps ? new Set(def.deps as string[]) : null,\n cleanup: null,\n stableRunCount: 0,\n depsStable: false,\n };\n\n states.set(id, state);\n return state;\n }\n\n /** Get or create state for an effect */\n function getState(id: string): EffectState {\n return states.get(id) ?? initState(id);\n }\n\n /** Create a plain-object snapshot of current facts.\n * Effects receive `prev` through module-scoped proxies (system.ts) that use\n * bracket-style property access, so the snapshot must be a plain object —\n * NOT a FactsSnapshot (which only exposes .get()/.has()). */\n function createSnapshot(): Record<string, unknown> {\n return store.toObject();\n }\n\n /** Reset dep stability so the next run re-tracks via withTracking() */\n function resetStability(state: EffectState): void {\n state.depsStable = false;\n state.stableRunCount = 0;\n }\n\n /** Check whether any dependency overlaps with the changed keys */\n function hasOverlap(deps: Set<string>, changedKeys: Set<string>): boolean {\n for (const dep of deps) {\n if (changedKeys.has(dep)) {\n return true;\n }\n }\n\n return false;\n }\n\n /** Check if an effect should run based on changed keys */\n function shouldRun(id: string, changedKeys: Set<string>): boolean {\n const state = getState(id);\n if (!state.enabled) {\n return false;\n }\n\n // If effect has tracked deps (explicit or auto-tracked), check if any changed\n if (state.dependencies) {\n if (!hasOverlap(state.dependencies, changedKeys)) {\n return false;\n }\n\n // Reset dep stability when a tracked fact changes so the next run\n // re-tracks via withTracking() and can discover new conditional reads.\n if (state.depsStable) {\n resetStability(state);\n }\n\n return true;\n }\n\n // No deps yet (first run or auto-tracked with no reads) = run on any change\n return true;\n }\n\n /** Run cleanup for a single effect (safe — catches errors) */\n function runCleanup(state: EffectState): void {\n if (state.cleanup) {\n try {\n state.cleanup();\n } catch (error) {\n onError?.(state.id, error);\n console.error(\n `[Directive] Effect \"${state.id}\" cleanup threw an error:`,\n error,\n );\n }\n state.cleanup = null;\n }\n }\n\n /** Store a cleanup function if the effect returned one */\n function storeCleanup(state: EffectState, result: unknown): void {\n if (typeof result === \"function\") {\n if (stopped) {\n // System already stopped — invoke cleanup immediately so it's not lost\n try {\n (result as () => void)();\n } catch (error) {\n onError?.(state.id, error);\n console.error(\n `[Directive] Effect \"${state.id}\" cleanup threw an error:`,\n error,\n );\n }\n } else {\n state.cleanup = result as () => void;\n }\n }\n }\n\n /** Run the effect's `run()` inside a store.batch(), await if needed, and store cleanup */\n async function runBatchedEffect(\n state: EffectState,\n def: EffectsDef<S>[string],\n ): Promise<void> {\n let effectPromise: unknown;\n store.batch(() => {\n effectPromise = def.run(facts, previousSnapshot as InferSchema<S> | null);\n });\n if (effectPromise instanceof Promise) {\n const result = await effectPromise;\n storeCleanup(state, result);\n } else {\n storeCleanup(state, effectPromise);\n }\n }\n\n /** Check whether two dep sets are identical */\n function areDepsEqual(a: Set<string>, b: Set<string>): boolean {\n if (a.size !== b.size) {\n return false;\n }\n for (const dep of b) {\n if (!a.has(dep)) {\n return false;\n }\n }\n\n return true;\n }\n\n /** Check whether tracked deps match current deps and update stability counters */\n function updateDepStability(\n state: EffectState,\n trackedDeps: Set<string>,\n ): void {\n const same =\n state.dependencies && areDepsEqual(state.dependencies, trackedDeps);\n\n if (!same) {\n resetStability(state);\n\n return;\n }\n\n state.stableRunCount++;\n if (state.stableRunCount >= STABLE_THRESHOLD) {\n state.depsStable = true;\n }\n }\n\n /** Run an auto-tracked effect, re-tracking dependencies each time */\n async function runAutoTrackedEffect(\n state: EffectState,\n def: EffectsDef<S>[string],\n ): Promise<void> {\n // Deps have been stable — skip withTracking() overhead\n if (state.depsStable && state.dependencies) {\n await runBatchedEffect(state, def);\n\n return;\n }\n\n // Re-track dependencies so conditional reads are picked up\n let effectPromise: unknown;\n const trackingResult = withTracking(() => {\n store.batch(() => {\n effectPromise = def.run(\n facts,\n previousSnapshot as InferSchema<S> | null,\n );\n });\n return effectPromise;\n });\n const trackedDeps = trackingResult.deps;\n\n // If the effect is async, wait for it and capture cleanup\n let result = trackingResult.value;\n if (result instanceof Promise) {\n result = await result;\n }\n storeCleanup(state, result);\n\n updateDepStability(state, trackedDeps);\n\n // Update tracked dependencies\n state.dependencies = trackedDeps.size > 0 ? trackedDeps : null;\n }\n\n /** Run a single effect */\n async function runEffect(id: string): Promise<void> {\n const state = getState(id);\n const def = definitions[id];\n\n if (!state.enabled || !def) return;\n\n // Run previous cleanup before re-running\n runCleanup(state);\n\n onRun?.(id, state.dependencies ? [...state.dependencies] : []);\n\n try {\n if (!state.hasExplicitDeps) {\n await runAutoTrackedEffect(state, def);\n } else {\n await runBatchedEffect(state, def);\n }\n } catch (error) {\n // Effects are fire-and-forget - errors are reported but don't propagate\n onError?.(id, error);\n console.error(`[Directive] Effect \"${id}\" threw an error:`, error);\n // Reset dep stability — we don't know what the effect would have read\n if (!state.hasExplicitDeps) {\n resetStability(state);\n }\n }\n }\n\n // Initialize all effect states\n for (const id of Object.keys(definitions)) {\n initState(id);\n }\n\n const manager: EffectsManager<S> = {\n async runEffects(changedKeys: Set<string>): Promise<void> {\n const effectsToRun: string[] = [];\n\n for (const id of Object.keys(definitions)) {\n if (shouldRun(id, changedKeys)) {\n effectsToRun.push(id);\n }\n }\n\n // Run effects in parallel (they're independent)\n await Promise.all(effectsToRun.map(runEffect));\n\n // Update previous snapshot\n previousSnapshot = createSnapshot();\n },\n\n async runAll(): Promise<void> {\n const effectIds = Object.keys(definitions);\n await Promise.all(\n effectIds.map((id) => {\n const state = getState(id);\n if (state.enabled) {\n // Reset stability so runEffect re-tracks deps\n // (runAll bypasses shouldRun where the normal reset lives)\n resetStability(state);\n\n return runEffect(id);\n }\n return Promise.resolve();\n }),\n );\n\n // Update previous snapshot\n previousSnapshot = createSnapshot();\n },\n\n disable(id: string): void {\n const state = getState(id);\n state.enabled = false;\n },\n\n enable(id: string): void {\n const state = getState(id);\n state.enabled = true;\n },\n\n isEnabled(id: string): boolean {\n return getState(id).enabled;\n },\n\n cleanupAll(): void {\n stopped = true;\n for (const state of states.values()) {\n runCleanup(state);\n }\n },\n\n registerDefinitions(newDefs: EffectsDef<S>): void {\n for (const [key, def] of Object.entries(newDefs)) {\n (definitions as Record<string, unknown>)[key] = def;\n initState(key);\n }\n },\n\n assignDefinition(id: string, def: EffectsDef<S>[string]): void {\n if (!definitions[id]) {\n throw new Error(\n `[Directive] Cannot assign effect \"${id}\" — it does not exist. Use register() to create it.`,\n );\n }\n\n // Run cleanup of old effect before replacing\n const state = states.get(id);\n if (state) {\n runCleanup(state);\n }\n\n // Replace definition and re-init state\n (definitions as Record<string, unknown>)[id] = def;\n initState(id);\n },\n\n unregisterDefinition(id: string): void {\n if (!definitions[id]) {\n return;\n }\n\n // Run cleanup (try-catch inside runCleanup)\n const state = states.get(id);\n if (state) {\n runCleanup(state);\n }\n\n // Remove from all maps\n delete (definitions as Record<string, unknown>)[id];\n states.delete(id);\n },\n\n async callOne(id: string): Promise<void> {\n const def = definitions[id];\n if (!def) {\n throw new Error(\n `[Directive] Cannot call effect \"${id}\" — it does not exist.`,\n );\n }\n\n const state = getState(id);\n if (!state.enabled) {\n return;\n }\n\n // Run cleanup of previous run\n runCleanup(state);\n\n onRun?.(id, state.dependencies ? [...state.dependencies] : []);\n\n try {\n let effectPromise: unknown;\n store.batch(() => {\n effectPromise = def.run(\n facts,\n previousSnapshot as InferSchema<S> | null,\n );\n });\n if (effectPromise instanceof Promise) {\n const result = await effectPromise;\n storeCleanup(state, result);\n } else {\n storeCleanup(state, effectPromise);\n }\n } catch (error) {\n onError?.(id, error);\n console.error(`[Directive] Effect \"${id}\" threw an error:`, error);\n }\n },\n };\n\n return manager;\n}\n","/**\n * Error Boundaries - Configurable error handling and recovery\n *\n * Features:\n * - Catch errors in constraints/resolvers/effects/derivations\n * - Configurable recovery strategies (skip, retry, retry-later, disable, throw)\n * - Circuit breaker pattern for automatic failure protection\n * - Error reporting to plugins\n */\n\nimport {\n DirectiveError,\n type ErrorBoundaryConfig,\n type ErrorSource,\n type RecoveryStrategy,\n type RetryLaterConfig,\n} from \"./types.js\";\n\n// ============================================================================\n// Retry-Later Queue\n// ============================================================================\n\n/**\n * A queued retry entry tracking its source, attempt count, and scheduled time.\n *\n * @internal\n */\nexport interface PendingRetry {\n source: ErrorSource;\n sourceId: string;\n context: unknown;\n attempt: number;\n nextRetryTime: number;\n callback?: () => void;\n}\n\n/**\n * Create a manager for deferred retry scheduling with exponential backoff.\n *\n * @remarks\n * Retries are stored in a Map keyed by source ID. Each entry tracks its\n * attempt number and the timestamp of the next eligible retry. When\n * {@link createRetryLaterManager | processDueRetries} is called (typically\n * during reconciliation), entries whose scheduled time has elapsed are\n * returned and removed from the queue. The delay grows exponentially:\n * `delayMs * backoffMultiplier^(attempt - 1)`, capped at `maxDelayMs`.\n *\n * @param config - Backoff configuration including `delayMs`, `maxRetries`, `backoffMultiplier`, and `maxDelayMs`.\n * @returns A manager exposing `scheduleRetry`, `getPendingRetries`, `processDueRetries`, `cancelRetry`, and `clearAll` methods.\n *\n * @internal\n */\nexport function createRetryLaterManager(config: RetryLaterConfig = {}): {\n /** Schedule a retry */\n scheduleRetry: (\n source: ErrorSource,\n sourceId: string,\n context: unknown,\n attempt: number,\n callback?: () => void,\n ) => PendingRetry | null;\n /** Get pending retries */\n getPendingRetries: () => PendingRetry[];\n /** Process due retries */\n processDueRetries: () => PendingRetry[];\n /** Cancel a retry */\n cancelRetry: (sourceId: string) => void;\n /** Clear all pending retries */\n clearAll: () => void;\n} {\n const {\n delayMs = 1000,\n maxRetries = 3,\n backoffMultiplier = 2,\n maxDelayMs = 30000,\n } = config;\n\n const pendingRetries: Map<string, PendingRetry> = new Map();\n\n function calculateDelay(attempt: number): number {\n const delay = delayMs * backoffMultiplier ** (attempt - 1);\n return Math.min(delay, maxDelayMs);\n }\n\n return {\n scheduleRetry(\n source: ErrorSource,\n sourceId: string,\n context: unknown,\n attempt: number,\n callback?: () => void,\n ): PendingRetry | null {\n // Check if max retries exceeded\n if (attempt > maxRetries) {\n return null;\n }\n\n const delay = calculateDelay(attempt);\n const entry: PendingRetry = {\n source,\n sourceId,\n context,\n attempt,\n nextRetryTime: Date.now() + delay,\n callback,\n };\n\n pendingRetries.set(sourceId, entry);\n return entry;\n },\n\n getPendingRetries(): PendingRetry[] {\n return Array.from(pendingRetries.values());\n },\n\n processDueRetries(): PendingRetry[] {\n const now = Date.now();\n const dueRetries: PendingRetry[] = [];\n\n for (const [sourceId, entry] of pendingRetries) {\n if (entry.nextRetryTime <= now) {\n dueRetries.push(entry);\n pendingRetries.delete(sourceId);\n }\n }\n\n return dueRetries;\n },\n\n cancelRetry(sourceId: string): void {\n pendingRetries.delete(sourceId);\n },\n\n clearAll(): void {\n pendingRetries.clear();\n },\n };\n}\n\n// ============================================================================\n// Error Boundary Manager\n// ============================================================================\n\n/**\n * Handle returned by {@link createErrorBoundaryManager} for routing errors\n * through configurable recovery strategies.\n *\n * @internal\n */\nexport interface ErrorBoundaryManager {\n /**\n * Route an error through the configured recovery strategy for its source.\n *\n * @param source - The subsystem that produced the error.\n * @param sourceId - Identifier of the specific constraint, resolver, effect, or derivation.\n * @param error - The thrown value (coerced to {@link DirectiveError} internally).\n * @param context - Optional context forwarded to callbacks and retry entries.\n * @returns The {@link RecoveryStrategy} that was applied.\n */\n handleError(\n source: ErrorSource,\n sourceId: string,\n error: unknown,\n context?: unknown,\n ): RecoveryStrategy;\n /**\n * Return the most recently recorded error, or `null` if none exist.\n *\n * @returns The last {@link DirectiveError}, or `null`.\n */\n getLastError(): DirectiveError | null;\n /**\n * Return a snapshot array of all recorded errors (up to the last 100).\n *\n * @returns A shallow copy of the internal error ring buffer.\n */\n getAllErrors(): DirectiveError[];\n /** Clear all recorded errors. */\n clearErrors(): void;\n /**\n * Access the underlying retry-later manager for advanced scheduling.\n *\n * @returns The {@link createRetryLaterManager} instance used internally.\n */\n getRetryLaterManager(): ReturnType<typeof createRetryLaterManager>;\n /**\n * Drain and return retry entries whose scheduled time has elapsed.\n *\n * @returns An array of {@link PendingRetry} entries that are now due.\n */\n processDueRetries(): PendingRetry[];\n /**\n * Reset retry attempt tracking for a source, typically after a successful resolution.\n *\n * @param sourceId - The source identifier whose retry counter should be cleared.\n */\n clearRetryAttempts(sourceId: string): void;\n}\n\n/**\n * Options accepted by {@link createErrorBoundaryManager}.\n *\n * @internal\n */\nexport interface CreateErrorBoundaryOptions {\n /** Per-source recovery strategies and retry-later tuning. */\n config?: ErrorBoundaryConfig;\n /** Invoked every time an error is recorded, before the recovery strategy runs. */\n onError?: (error: DirectiveError) => void;\n /** Invoked after a recovery strategy has been selected for an error. */\n onRecovery?: (error: DirectiveError, strategy: RecoveryStrategy) => void;\n}\n\n/** Default recovery strategies by source */\nconst DEFAULT_STRATEGIES: Record<ErrorSource, RecoveryStrategy> = {\n constraint: \"skip\",\n resolver: \"skip\",\n effect: \"skip\",\n derivation: \"skip\",\n system: \"throw\",\n};\n\n/**\n * Create a manager that handles errors from constraints, resolvers, effects,\n * and derivations with configurable per-source recovery strategies.\n *\n * @remarks\n * Five recovery strategies are available:\n *\n * - `\"skip\"` -- Swallow the error and continue.\n * - `\"retry\"` -- Signal the caller to retry immediately.\n * - `\"retry-later\"` -- Enqueue a deferred retry with exponential backoff\n * (delegated to an internal {@link createRetryLaterManager}).\n * - `\"disable\"` -- Permanently disable the failing source.\n * - `\"throw\"` -- Re-throw the error as a {@link DirectiveError}.\n *\n * Recent errors are kept in a ring buffer (last 100) for inspection via\n * {@link ErrorBoundaryManager.getAllErrors | getAllErrors}. Each strategy\n * can be configured per source type (`onConstraintError`, `onResolverError`,\n * etc.) or as a callback that dynamically selects a strategy.\n *\n * @param options - Error boundary configuration, plus `onError` and `onRecovery` callbacks for plugin integration.\n * @returns An {@link ErrorBoundaryManager} for routing errors through the configured strategies.\n *\n * @internal\n */\nexport function createErrorBoundaryManager(\n options: CreateErrorBoundaryOptions = {},\n): ErrorBoundaryManager {\n const { config = {}, onError, onRecovery } = options;\n\n // Store errors for inspection\n const errors: DirectiveError[] = [];\n const maxErrors = 100; // Keep last 100 errors\n\n // Retry-later manager\n const retryLaterManager = createRetryLaterManager(config.retryLater);\n\n // Track retry attempts per source ID (capped to prevent unbounded growth)\n const retryAttempts = new Map<string, number>();\n const MAX_RETRY_SOURCES = 1000;\n\n /** Convert unknown error to DirectiveError */\n function toDirectiveError(\n source: ErrorSource,\n sourceId: string,\n error: unknown,\n context?: unknown,\n ): DirectiveError {\n if (error instanceof DirectiveError) {\n return error;\n }\n\n const message = error instanceof Error ? error.message : String(error);\n const recoverable = source !== \"system\";\n\n return new DirectiveError(message, source, sourceId, context, recoverable);\n }\n\n /** Get recovery strategy for a source */\n function getStrategy(\n source: ErrorSource,\n sourceId: string,\n error: Error,\n ): RecoveryStrategy {\n // Get configured handler\n const handler = (() => {\n switch (source) {\n case \"constraint\":\n return config.onConstraintError;\n case \"resolver\":\n return config.onResolverError;\n case \"effect\":\n return config.onEffectError;\n case \"derivation\":\n return config.onDerivationError;\n default:\n return undefined;\n }\n })();\n\n // If handler is a function, call it — use returned strategy if provided, else \"skip\"\n if (typeof handler === \"function\") {\n try {\n const result = handler(error, sourceId);\n\n if (typeof result === \"string\") {\n return result as RecoveryStrategy;\n }\n } catch (e) {\n console.error(\"[Directive] Error in error handler callback:\", e);\n }\n\n return \"skip\";\n }\n\n // If handler is a strategy string, return it\n if (typeof handler === \"string\") {\n return handler;\n }\n\n // Return default strategy\n return DEFAULT_STRATEGIES[source];\n }\n\n /** Store error in ring buffer and notify error callbacks */\n function recordAndNotifyError(directiveError: DirectiveError): void {\n errors.push(directiveError);\n if (errors.length > maxErrors) {\n errors.shift();\n }\n\n try {\n onError?.(directiveError);\n } catch (e) {\n console.error(\"[Directive] Error in onError callback:\", e);\n }\n try {\n config.onError?.(directiveError);\n } catch (e) {\n console.error(\"[Directive] Error in config.onError callback:\", e);\n }\n }\n\n /** Process retry-later strategy: schedule retry or fall back to skip */\n function processRetryLater(\n source: ErrorSource,\n sourceId: string,\n context: unknown,\n ): RecoveryStrategy {\n const attempt = (retryAttempts.get(sourceId) ?? 0) + 1;\n retryAttempts.set(sourceId, attempt);\n\n // FIFO eviction to prevent unbounded growth\n if (retryAttempts.size > MAX_RETRY_SOURCES) {\n const oldest = retryAttempts.keys().next().value;\n if (oldest !== undefined) {\n retryAttempts.delete(oldest);\n }\n }\n\n const scheduled = retryLaterManager.scheduleRetry(\n source,\n sourceId,\n context,\n attempt,\n );\n\n if (scheduled) {\n return \"retry-later\";\n }\n\n // Max retries exceeded, fall back to skip\n retryAttempts.delete(sourceId);\n if (\n typeof process !== \"undefined\" &&\n process.env?.NODE_ENV !== \"production\"\n ) {\n console.warn(\n `[Directive] ${source} \"${sourceId}\" exceeded max retry-later attempts. Skipping.`,\n );\n }\n\n return \"skip\";\n }\n\n const manager: ErrorBoundaryManager = {\n handleError(\n source: ErrorSource,\n sourceId: string,\n error: unknown,\n context?: unknown,\n ): RecoveryStrategy {\n const directiveError = toDirectiveError(source, sourceId, error, context);\n\n recordAndNotifyError(directiveError);\n\n // Get recovery strategy\n let strategy = getStrategy(\n source,\n sourceId,\n error instanceof Error ? error : new Error(String(error)),\n );\n\n // Handle retry-later strategy\n if (strategy === \"retry-later\") {\n strategy = processRetryLater(source, sourceId, context);\n }\n\n // Notify recovery callback\n try {\n onRecovery?.(directiveError, strategy);\n } catch (e) {\n console.error(\"[Directive] Error in onRecovery callback:\", e);\n }\n\n // If strategy is throw, re-throw the error\n if (strategy === \"throw\") {\n throw directiveError;\n }\n\n return strategy;\n },\n\n getLastError(): DirectiveError | null {\n return errors[errors.length - 1] ?? null;\n },\n\n getAllErrors(): DirectiveError[] {\n return [...errors];\n },\n\n clearErrors(): void {\n errors.length = 0;\n },\n\n getRetryLaterManager() {\n return retryLaterManager;\n },\n\n processDueRetries(): PendingRetry[] {\n return retryLaterManager.processDueRetries();\n },\n\n clearRetryAttempts(sourceId: string): void {\n retryAttempts.delete(sourceId);\n retryLaterManager.cancelRetry(sourceId);\n },\n };\n\n return manager;\n}\n","/**\n * Facts Store - Proxy-based reactive state with auto-tracking\n *\n * Features:\n * - Proxy-based access (facts.phase instead of facts.get(\"phase\"))\n * - Automatic dependency tracking via tracking context\n * - Batched updates with coalesced notifications\n * - Granular subscriptions by key\n * - Schema validation in development mode\n */\n\nimport { BLOCKED_PROPS, trackAccess, withoutTracking } from \"./tracking.js\";\nimport type {\n Facts,\n FactsSnapshot,\n FactsStore,\n InferSchema,\n Schema,\n} from \"./types.js\";\n\n/** Safely stringify a value for error messages */\nfunction safeStringify(value: unknown, maxLength = 100): string {\n try {\n return JSON.stringify(value)?.slice(0, maxLength) ?? String(value);\n } catch {\n return \"[circular or non-serializable]\";\n }\n}\n\n// ============================================================================\n// Facts Store Implementation\n// ============================================================================\n\n/** Options for creating a facts store */\nexport interface CreateFactsStoreOptions<S extends Schema> {\n schema: S;\n /** Validate values against schema (default: process.env.NODE_ENV !== 'production') */\n validate?: boolean;\n /** Throw on unknown schema keys (default: true in dev mode) */\n strictKeys?: boolean;\n /** Redact sensitive values in error messages */\n redactErrors?: boolean;\n /** Callback when facts change (for plugin hooks) */\n onChange?: (key: string, value: unknown, prev: unknown) => void;\n /** Callback for batch changes */\n onBatch?: (\n changes: Array<{\n key: string;\n value: unknown;\n prev: unknown;\n type: \"set\" | \"delete\";\n }>,\n ) => void;\n}\n\n/**\n * Create a reactive facts store backed by a Map with schema validation,\n * batched mutations, and granular key-level subscriptions.\n *\n * @remarks\n * The store is the low-level primitive that powers the `facts` proxy.\n * Most users should use {@link createFacts} or `createModule` instead.\n *\n * @param options - Store configuration including schema, validation settings, and change callbacks\n * @returns A {@link FactsStore} with get/set/batch/subscribe methods and automatic schema validation\n *\n * @example\n * ```ts\n * const store = createFactsStore({\n * schema: { count: t.number(), name: t.string() },\n * });\n *\n * store.set(\"count\", 1);\n * store.get(\"count\"); // 1\n *\n * store.batch(() => {\n * store.set(\"count\", 2);\n * store.set(\"name\", \"hello\");\n * }); // listeners fire once after batch completes\n * ```\n *\n * @internal\n */\nexport function createFactsStore<S extends Schema>(\n options: CreateFactsStoreOptions<S>,\n): FactsStore<S> {\n const { schema, onChange, onBatch } = options;\n\n // Detect if this is a type assertion schema (empty object with no keys)\n const schemaKeys = Object.keys(schema);\n const isTypeAssertionSchema = schemaKeys.length === 0;\n\n // Default strictKeys to false for type assertion schemas (they have no runtime keys)\n const validate = options.validate ?? process.env.NODE_ENV !== \"production\";\n const strictKeys =\n options.strictKeys ??\n (process.env.NODE_ENV !== \"production\" && !isTypeAssertionSchema);\n const redactErrors = options.redactErrors ?? false;\n\n const map = new Map<string, unknown>();\n const knownKeys = new Set<string>(); // Track all keys that have been set\n const keyListeners = new Map<string, Set<() => void>>();\n const allListeners = new Set<() => void>();\n\n let batching = 0;\n const batchChanges: Array<{\n key: string;\n value: unknown;\n prev: unknown;\n type: \"set\" | \"delete\";\n }> = [];\n const dirtyKeys = new Set<string>();\n\n // Notification coalescing: when notifyKey/notifyAll fires a listener that\n // calls store.set(), defer the new notification until the current cycle completes.\n let isNotifying = false;\n const pendingNonBatchedChanges: Array<{\n key: string;\n value: unknown;\n prev: unknown;\n }> = [];\n const MAX_NOTIFY_ITERATIONS = 100;\n\n /** Check if a value is a Zod schema (robust detection) */\n function isZodSchema(v: unknown): v is {\n safeParse: (v: unknown) => {\n success: boolean;\n error?: { message?: string; issues?: Array<{ message: string }> };\n };\n _def: unknown;\n parse: unknown;\n } {\n return (\n v !== null &&\n typeof v === \"object\" &&\n \"safeParse\" in v &&\n typeof (v as Record<string, unknown>).safeParse === \"function\" &&\n \"_def\" in v &&\n \"parse\" in v &&\n typeof (v as Record<string, unknown>).parse === \"function\"\n );\n }\n\n /** Get expected type name from schema */\n function getExpectedType(schemaType: unknown): string {\n // Check for our SchemaType with _typeName\n const st = schemaType as { _typeName?: string };\n if (st._typeName) {\n return st._typeName;\n }\n\n // Check for Zod schema\n if (isZodSchema(schemaType)) {\n const def = (schemaType as { _def?: { typeName?: string } })._def;\n if (def?.typeName) {\n // Convert ZodString -> string, ZodNumber -> number, etc.\n return def.typeName.replace(/^Zod/, \"\").toLowerCase();\n }\n }\n\n return \"unknown\";\n }\n\n /** Format value for error message, respecting redactErrors option */\n function formatValueForError(value: unknown): string {\n if (redactErrors) {\n return \"[redacted]\";\n }\n return safeStringify(value);\n }\n\n /** Get a human-readable type label for a value */\n function describeValueType(value: unknown): string {\n if (value === null) {\n return \"null\";\n }\n if (Array.isArray(value)) {\n return \"array\";\n }\n\n return typeof value;\n }\n\n /** Validate a value against a Zod schema */\n function validateZod(\n key: string,\n value: unknown,\n schemaType: ReturnType<\n typeof isZodSchema extends (v: unknown) => v is infer R ? () => R : never\n >,\n ): void {\n const result = (\n schemaType as {\n safeParse: (v: unknown) => {\n success: boolean;\n error?: { message?: string; issues?: Array<{ message: string }> };\n };\n }\n ).safeParse(value);\n if (result.success) {\n return;\n }\n\n const valueType = describeValueType(value);\n const valuePreview = formatValueForError(value);\n const errorMessage =\n result.error?.message ??\n result.error?.issues?.[0]?.message ??\n \"Validation failed\";\n const expectedType = getExpectedType(schemaType);\n throw new Error(\n `[Directive] Validation failed for \"${key}\": expected ${expectedType}, got ${valueType} ${valuePreview}. ${errorMessage}`,\n );\n }\n\n /** Build the index hint string for array validation failures */\n function getIndexHint(st: { _lastFailedIndex?: number }): string {\n if (typeof st._lastFailedIndex === \"number\" && st._lastFailedIndex >= 0) {\n const hint = ` (element at index ${st._lastFailedIndex} failed)`;\n st._lastFailedIndex = -1; // Reset for next validation\n return hint;\n }\n\n return \"\";\n }\n\n /** Validate a value against our SchemaType validators */\n function validateSchemaType(\n key: string,\n value: unknown,\n st: {\n _validators?: unknown;\n _typeName?: string;\n _lastFailedIndex?: number;\n },\n ): void {\n const validators = st._validators;\n\n // Ensure validators is an array before iterating\n if (!validators || !Array.isArray(validators) || validators.length === 0) {\n return; // type assertion or empty validators - no validation\n }\n\n const expectedType = st._typeName ?? \"unknown\";\n\n for (let i = 0; i < validators.length; i++) {\n const validator = validators[i];\n if (typeof validator !== \"function\") continue;\n if (validator(value as never)) continue;\n\n const valueType = describeValueType(value);\n const valuePreview = formatValueForError(value);\n const indexHint = getIndexHint(st);\n const validatorHint = i === 0 ? \"\" : ` (validator ${i + 1} failed)`;\n throw new Error(\n `[Directive] Validation failed for \"${key}\": expected ${expectedType}, got ${valueType} ${valuePreview}${validatorHint}${indexHint}`,\n );\n }\n }\n\n /** Validate unknown schema key */\n function validateUnknownKey(key: string): void {\n if (strictKeys) {\n throw new Error(\n `[Directive] Unknown fact key: \"${key}\". Key not defined in schema.`,\n );\n }\n console.warn(`[Directive] Unknown fact key: \"${key}\"`);\n }\n\n /** Validate a value against the schema */\n function validateValue(key: string, value: unknown): void {\n if (!validate) {\n return;\n }\n\n const schemaType = schema[key];\n if (!schemaType) {\n validateUnknownKey(key);\n return;\n }\n\n if (isZodSchema(schemaType)) {\n validateZod(key, value, schemaType);\n return;\n }\n\n validateSchemaType(\n key,\n value,\n schemaType as {\n _validators?: unknown;\n _typeName?: string;\n _lastFailedIndex?: number;\n },\n );\n }\n\n /** Notify listeners for a specific key */\n function notifyKey(key: string): void {\n keyListeners.get(key)?.forEach((listener) => listener());\n }\n\n /** Notify all listeners */\n function notifyAll(): void {\n allListeners.forEach((listener) => listener());\n }\n\n /**\n * Run non-batched notifications with coalescing.\n * If a listener calls store.set(), the change is deferred and processed\n * after the current notification cycle completes.\n */\n function notifyNonBatched(key: string, value: unknown, prev: unknown): void {\n if (isNotifying) {\n // Re-entrant: defer to after current notification cycle\n pendingNonBatchedChanges.push({ key, value, prev });\n return;\n }\n\n isNotifying = true;\n try {\n // Fire onChange, notifyKey, notifyAll for the initial change\n onChange?.(key, value, prev);\n notifyKey(key);\n notifyAll();\n\n // Process any changes that were deferred during notification\n drainDeferredNotifications(\n \". A listener is repeatedly mutating facts that re-trigger notifications\",\n );\n } finally {\n isNotifying = false;\n }\n }\n\n /**\n * Drain deferred notifications that accumulated during a notification cycle.\n * Must be called while isNotifying is true.\n */\n function drainDeferredNotifications(context: string): void {\n let iterations = 0;\n while (pendingNonBatchedChanges.length > 0) {\n if (++iterations > MAX_NOTIFY_ITERATIONS) {\n pendingNonBatchedChanges.length = 0;\n throw new Error(\n `[Directive] Infinite notification loop detected after ${MAX_NOTIFY_ITERATIONS} iterations${context}.`,\n );\n }\n\n const deferred = [...pendingNonBatchedChanges];\n pendingNonBatchedChanges.length = 0;\n\n for (const change of deferred) {\n onChange?.(change.key, change.value, change.prev);\n notifyKey(change.key);\n }\n notifyAll();\n }\n }\n\n /** Flush batched changes and notify */\n function flush(): void {\n if (batching > 0) {\n return;\n }\n\n // Notify batch callback\n if (onBatch && batchChanges.length > 0) {\n onBatch([...batchChanges]);\n }\n\n // Notify key-specific listeners (within coalescing guard)\n if (dirtyKeys.size > 0) {\n isNotifying = true;\n try {\n for (const key of dirtyKeys) {\n notifyKey(key);\n }\n notifyAll();\n drainDeferredNotifications(\" during flush\");\n } finally {\n isNotifying = false;\n }\n }\n\n // Clear batch state\n batchChanges.length = 0;\n dirtyKeys.clear();\n }\n\n const store: FactsStore<S> = {\n get<K extends keyof InferSchema<S>>(key: K): InferSchema<S>[K] | undefined {\n // Track access for auto-tracking\n trackAccess(key as string);\n return map.get(key as string) as InferSchema<S>[K] | undefined;\n },\n\n has(key: keyof InferSchema<S>): boolean {\n // Track access for auto-tracking\n trackAccess(key as string);\n return map.has(key as string);\n },\n\n set<K extends keyof InferSchema<S>>(\n key: K,\n value: InferSchema<S>[K],\n ): void {\n validateValue(key as string, value);\n\n const prev = map.get(key as string);\n\n // Skip if value hasn't changed (prevents unnecessary cascade)\n if (Object.is(prev, value)) return;\n\n map.set(key as string, value);\n knownKeys.add(key as string); // Track known keys for serialization\n\n // Record change\n if (batching > 0) {\n batchChanges.push({ key: key as string, value, prev, type: \"set\" });\n dirtyKeys.add(key as string);\n } else {\n notifyNonBatched(key as string, value, prev);\n }\n },\n\n delete(key: keyof InferSchema<S>): void {\n const prev = map.get(key as string);\n map.delete(key as string);\n knownKeys.delete(key as string); // Remove from known keys\n\n // Record change\n if (batching > 0) {\n batchChanges.push({\n key: key as string,\n value: undefined,\n prev,\n type: \"delete\",\n });\n dirtyKeys.add(key as string);\n } else {\n notifyNonBatched(key as string, undefined, prev);\n }\n },\n\n batch(fn: () => void): void {\n batching++;\n try {\n fn();\n } finally {\n batching--;\n flush();\n }\n },\n\n subscribe(\n keys: Array<keyof InferSchema<S>>,\n listener: () => void,\n ): () => void {\n for (const key of keys) {\n const keyStr = key as string;\n if (!keyListeners.has(keyStr)) {\n keyListeners.set(keyStr, new Set());\n }\n keyListeners.get(keyStr)!.add(listener);\n }\n\n return () => {\n for (const key of keys) {\n const set = keyListeners.get(key as string);\n if (set) {\n set.delete(listener);\n if (set.size === 0) {\n keyListeners.delete(key as string);\n }\n }\n }\n };\n },\n\n subscribeAll(listener: () => void): () => void {\n allListeners.add(listener);\n return () => allListeners.delete(listener);\n },\n\n toObject(): Record<string, unknown> {\n const result: Record<string, unknown> = {};\n for (const key of knownKeys) {\n if (map.has(key)) {\n result[key] = map.get(key);\n }\n }\n return result;\n },\n };\n\n // Internal: clear all listeners on destroy to release resources immediately.\n // Not part of the public FactsStore interface — called by engine.destroy().\n (store as unknown as Record<string, unknown>).destroy = () => {\n keyListeners.clear();\n allListeners.clear();\n };\n\n // Internal: register new schema keys for dynamic module registration.\n // Not part of the public FactsStore interface — used by engine.registerModule().\n (store as unknown as Record<string, unknown>).registerKeys = (\n newSchema: Record<string, unknown>,\n ) => {\n for (const key of Object.keys(newSchema)) {\n // Defense-in-depth: skip prototype pollution keys\n if (BLOCKED_PROPS.has(key)) continue;\n // Add to schema for validation\n (schema as Record<string, unknown>)[key] = newSchema[key];\n knownKeys.add(key);\n }\n };\n\n return store;\n}\n\n// ============================================================================\n// Dev-mode nested mutation warning\n// ============================================================================\n\nconst nestedProxyCache = new WeakMap<object, object>();\n\n/**\n * Wrap an object in a Proxy that warns when properties are set.\n * Catches `facts.user.name = \"John\"` which silently skips reactivity.\n * Only used in dev mode — tree-shaken in production builds.\n */\nfunction wrapWithNestedWarning(\n obj: object,\n rootKey: string,\n path = rootKey,\n): object {\n return new Proxy(obj, {\n get(target, prop) {\n if (typeof prop === \"string\" && BLOCKED_PROPS.has(prop)) {\n return undefined;\n }\n const value = Reflect.get(target, prop);\n if (\n typeof prop === \"symbol\" ||\n typeof value !== \"object\" ||\n value === null\n ) {\n return value;\n }\n\n if (nestedProxyCache.has(value as object)) {\n return nestedProxyCache.get(value as object);\n }\n\n const wrapped = wrapWithNestedWarning(\n value as object,\n rootKey,\n `${path}.${String(prop)}`,\n );\n nestedProxyCache.set(value as object, wrapped);\n\n return wrapped;\n },\n set(target, prop, newValue) {\n if (typeof prop !== \"symbol\") {\n console.warn(\n `[Directive] Nested mutation on \"facts.${path}.${String(prop)}\" will not trigger reactivity. ` +\n `Use: facts.${rootKey} = { ...facts.${rootKey}, ... }`,\n );\n }\n\n return Reflect.set(target, prop, newValue);\n },\n });\n}\n\n// ============================================================================\n// Proxy-based Facts Accessor\n// ============================================================================\n\n/**\n * Create a Proxy wrapper around a {@link FactsStore} for clean property-style\n * access (`facts.phase`) with automatic dependency tracking.\n *\n * @remarks\n * Reading a property calls `store.get()` (which tracks the access for\n * auto-tracked derivations). Writing a property calls `store.set()` (which\n * validates against the schema). The proxy also exposes `$store` for direct\n * store access and `$snapshot()` for untracked reads.\n *\n * @param store - The underlying facts store to wrap\n * @param schema - The schema definition used for `ownKeys` enumeration\n * @returns A {@link Facts} proxy with property-style get/set and prototype pollution guards\n *\n * @example\n * ```ts\n * const store = createFactsStore({ schema: { phase: t.string() } });\n * const facts = createFactsProxy(store, { phase: t.string() });\n *\n * facts.phase = \"red\";\n * console.log(facts.phase); // \"red\"\n * ```\n *\n * @internal\n */\nexport function createFactsProxy<S extends Schema>(\n store: FactsStore<S>,\n schema: S,\n): Facts<S> {\n const snapshot = (): FactsSnapshot<S> => ({\n get: <K extends keyof InferSchema<S>>(key: K) =>\n withoutTracking(() => store.get(key)),\n has: (key: keyof InferSchema<S>) => withoutTracking(() => store.has(key)),\n });\n\n const proxy = new Proxy({} as Facts<S>, {\n get(_, prop: string | symbol) {\n if (prop === \"$store\") {\n return store;\n }\n if (prop === \"$snapshot\") {\n return snapshot;\n }\n\n // Special properties\n if (typeof prop === \"symbol\") {\n return undefined;\n }\n\n // Prototype pollution protection\n if (BLOCKED_PROPS.has(prop)) {\n return undefined;\n }\n\n const value = store.get(prop as keyof InferSchema<S>);\n\n // Dev-mode: warn when users mutate nested objects (won't trigger reactivity)\n if (\n process.env.NODE_ENV !== \"production\" &&\n value !== null &&\n typeof value === \"object\"\n ) {\n return wrapWithNestedWarning(value as object, prop);\n }\n\n return value;\n },\n\n set(_, prop: string | symbol, value: unknown) {\n if (typeof prop === \"symbol\") {\n return false;\n }\n if (prop === \"$store\" || prop === \"$snapshot\") {\n return false;\n }\n // Prototype pollution protection\n if (BLOCKED_PROPS.has(prop)) {\n return false;\n }\n\n // Validation is handled by store.set() when validate option is enabled\n store.set(\n prop as keyof InferSchema<S>,\n value as InferSchema<S>[keyof InferSchema<S>],\n );\n return true;\n },\n\n deleteProperty(_, prop: string | symbol) {\n if (typeof prop === \"symbol\") {\n return false;\n }\n if (prop === \"$store\" || prop === \"$snapshot\") {\n return false;\n }\n // Prototype pollution protection\n if (BLOCKED_PROPS.has(prop)) {\n return false;\n }\n\n store.delete(prop as keyof InferSchema<S>);\n return true;\n },\n\n has(_, prop: string | symbol) {\n if (prop === \"$store\" || prop === \"$snapshot\") {\n return true;\n }\n if (typeof prop === \"symbol\") {\n return false;\n }\n // Prototype pollution protection\n if (BLOCKED_PROPS.has(prop)) {\n return false;\n }\n\n return store.has(prop as keyof InferSchema<S>);\n },\n\n ownKeys() {\n // Return schema keys dynamically so Object.keys(facts) reflects\n // keys added via registerKeys (dynamic module registration)\n return Object.keys(schema);\n },\n\n getOwnPropertyDescriptor(_, prop: string | symbol) {\n if (prop === \"$store\" || prop === \"$snapshot\") {\n return { configurable: true, enumerable: false, writable: false };\n }\n return { configurable: true, enumerable: true, writable: true };\n },\n\n defineProperty() {\n return false;\n },\n\n getPrototypeOf() {\n return null;\n },\n\n setPrototypeOf() {\n return false;\n },\n });\n\n return proxy;\n}\n\n// ============================================================================\n// Combined Factory\n// ============================================================================\n\n/**\n * Convenience factory that creates both a {@link FactsStore} and its\n * {@link createFactsProxy | proxy wrapper} in a single call.\n *\n * @remarks\n * This is the recommended entry point when you need low-level store access\n * outside of `createModule` / `createSystem`.\n *\n * @param options - Same options as {@link createFactsStore}\n * @returns An object with `store` (the reactive Map-backed store) and `facts` (the Proxy accessor)\n *\n * @example\n * ```ts\n * const { store, facts } = createFacts({\n * schema: { phase: t.string<\"red\" | \"green\">() },\n * });\n *\n * facts.phase = \"red\";\n * console.log(facts.phase); // \"red\"\n * store.subscribe([\"phase\"], () => console.log(\"phase changed\"));\n * ```\n *\n * @internal\n */\nexport function createFacts<S extends Schema>(\n options: CreateFactsStoreOptions<S>,\n): { store: FactsStore<S>; facts: Facts<S> } {\n const store = createFactsStore(options);\n const facts = createFactsProxy(store, options.schema);\n return { store, facts };\n}\n","/**\n * Plugin Architecture - Extensible middleware for Directive\n *\n * Features:\n * - Lifecycle hooks for all engine events\n * - Multiple plugins can be composed\n * - Plugins execute in registration order\n */\n\nimport type {\n FactChange,\n FactsSnapshot,\n Plugin,\n ReconcileResult,\n RecoveryStrategy,\n RequirementWithId,\n Schema,\n Snapshot,\n System,\n TraceEntry,\n} from \"./types.js\";\nimport type { DirectiveError } from \"./types.js\";\n\n// ============================================================================\n// Plugin Manager\n// ============================================================================\n\n/**\n * Internal manager that broadcasts lifecycle events to registered {@link Plugin} instances.\n *\n * @remarks\n * PluginManager uses `Schema` (flat) internally because the engine works with\n * flat schemas. The public API uses `ModuleSchema` (consolidated), and the\n * conversion happens in `createSystem`.\n *\n * Plugins execute in registration order. All hook invocations are wrapped in\n * try-catch so a misbehaving plugin never breaks the engine. Duplicate plugin\n * names are detected and the older registration is replaced with a warning.\n *\n * Lifecycle hook categories:\n * - **System lifecycle:** `emitInit`, `emitStart`, `emitStop`, `emitDestroy`\n * - **Facts:** `emitFactSet`, `emitFactDelete`, `emitFactsBatch`\n * - **Derivations:** `emitDerivationCompute`, `emitDerivationInvalidate`\n * - **Reconciliation:** `emitReconcileStart`, `emitReconcileEnd`\n * - **Constraints:** `emitConstraintEvaluate`, `emitConstraintError`\n * - **Requirements:** `emitRequirementCreated`, `emitRequirementMet`, `emitRequirementCanceled`\n * - **Resolvers:** `emitResolverStart`, `emitResolverComplete`, `emitResolverError`, `emitResolverRetry`, `emitResolverCancel`\n * - **Effects:** `emitEffectRun`, `emitEffectError`\n * - **History:** `emitSnapshot`, `emitHistoryNavigate`\n * - **Errors:** `emitError`, `emitErrorRecovery`\n * - **Trace:** `emitTraceComplete`\n *\n * @typeParam _S - The flat schema type (unused at runtime).\n *\n * @internal\n */\n// Note: PluginManager uses Schema (flat) internally because the engine works with flat schemas.\n// The public API uses ModuleSchema (consolidated), and the conversion happens in createSystem.\n// biome-ignore lint/suspicious/noExplicitAny: Internal type - plugins are schema-agnostic at runtime\nexport interface PluginManager<_S extends Schema = any> {\n /** Register a plugin */\n // biome-ignore lint/suspicious/noExplicitAny: Plugins work with any schema\n register(plugin: Plugin<any>): void;\n /** Unregister a plugin by name */\n unregister(name: string): void;\n /** Get all registered plugins */\n // biome-ignore lint/suspicious/noExplicitAny: Plugins work with any schema\n getPlugins(): Plugin<any>[];\n\n // Lifecycle hooks\n // biome-ignore lint/suspicious/noExplicitAny: System type varies between internal/public API\n emitInit(system: System<any>): Promise<void>;\n // biome-ignore lint/suspicious/noExplicitAny: System type varies between internal/public API\n emitStart(system: System<any>): void;\n // biome-ignore lint/suspicious/noExplicitAny: System type varies between internal/public API\n emitStop(system: System<any>): void;\n // biome-ignore lint/suspicious/noExplicitAny: System type varies between internal/public API\n emitDestroy(system: System<any>): void;\n\n // Fact hooks\n emitFactSet(key: string, value: unknown, prev: unknown): void;\n emitFactDelete(key: string, prev: unknown): void;\n emitFactsBatch(changes: FactChange[]): void;\n\n // Derivation hooks\n emitDerivationCompute(id: string, value: unknown, deps: string[]): void;\n emitDerivationInvalidate(id: string): void;\n\n // Reconciliation hooks\n // biome-ignore lint/suspicious/noExplicitAny: Schema type varies\n emitReconcileStart(snapshot: FactsSnapshot<any>): void;\n emitReconcileEnd(result: ReconcileResult): void;\n\n // Constraint hooks\n emitConstraintEvaluate(id: string, active: boolean): void;\n emitConstraintError(id: string, error: unknown): void;\n\n // Requirement hooks\n emitRequirementCreated(req: RequirementWithId): void;\n emitRequirementMet(req: RequirementWithId, byResolver: string): void;\n emitRequirementCanceled(req: RequirementWithId): void;\n\n // Resolver hooks\n emitResolverStart(resolver: string, req: RequirementWithId): void;\n emitResolverComplete(\n resolver: string,\n req: RequirementWithId,\n duration: number,\n ): void;\n emitResolverError(\n resolver: string,\n req: RequirementWithId,\n error: unknown,\n ): void;\n emitResolverRetry(\n resolver: string,\n req: RequirementWithId,\n attempt: number,\n ): void;\n emitResolverCancel(resolver: string, req: RequirementWithId): void;\n\n // Effect hooks\n emitEffectRun(id: string): void;\n emitEffectError(id: string, error: unknown): void;\n\n // History hooks\n emitSnapshot(snapshot: Snapshot): void;\n emitHistoryNavigate(from: number, to: number): void;\n\n // Error boundary hooks\n emitError(error: DirectiveError): void;\n emitErrorRecovery(error: DirectiveError, strategy: RecoveryStrategy): void;\n\n // Dynamic definition hooks\n emitDefinitionRegister(type: string, id: string, def: unknown): void;\n emitDefinitionAssign(\n type: string,\n id: string,\n def: unknown,\n original: unknown,\n ): void;\n emitDefinitionUnregister(type: string, id: string): void;\n emitDefinitionCall(type: string, id: string, props?: unknown): void;\n\n // Trace hooks\n emitTraceComplete(run: TraceEntry): void;\n}\n\n/**\n * Create a {@link PluginManager} that broadcasts lifecycle events to registered plugins.\n *\n * @remarks\n * Plugins are called in registration order. All hook invocations are wrapped\n * in try-catch so a misbehaving plugin never breaks the engine. Duplicate\n * plugin names are detected and the older registration is replaced with a\n * console warning.\n *\n * @returns A {@link PluginManager} with `register`/`unregister`/`getPlugins` and `emit*` methods for every lifecycle event.\n *\n * @internal\n */\nexport function createPluginManager<\n // biome-ignore lint/suspicious/noExplicitAny: Internal - schema type varies\n S extends Schema = any,\n>(): PluginManager<S> {\n // biome-ignore lint/suspicious/noExplicitAny: Plugins work with any schema\n const plugins: Plugin<any>[] = [];\n\n /** Safe call - wraps plugin hook calls to prevent errors from breaking the system */\n function safeCall<T>(fn: (() => T) | undefined): T | undefined {\n if (!fn) {\n return undefined;\n }\n try {\n return fn();\n } catch (error) {\n console.error(\"[Directive] Plugin error:\", error);\n return undefined;\n }\n }\n\n /** Safe async call */\n async function safeCallAsync<T>(\n fn: (() => Promise<T>) | undefined,\n ): Promise<T | undefined> {\n if (!fn) {\n return undefined;\n }\n try {\n return await fn();\n } catch (error) {\n console.error(\"[Directive] Plugin error:\", error);\n return undefined;\n }\n }\n\n /** Create a sync broadcast function for a given plugin hook name */\n // biome-ignore lint/suspicious/noExplicitAny: Plugin hook signatures vary\n function broadcast<K extends keyof Plugin<any>>(hook: K) {\n return (...args: unknown[]) => {\n for (const plugin of plugins) {\n // biome-ignore lint/suspicious/noExplicitAny: Dynamic hook dispatch\n safeCall(() => (plugin as any)[hook]?.(...args));\n }\n };\n }\n\n const manager: PluginManager<S> = {\n // biome-ignore lint/suspicious/noExplicitAny: Plugins work with any schema\n register(plugin: Plugin<any>): void {\n // Check for duplicate names\n if (plugins.some((p) => p.name === plugin.name)) {\n console.warn(\n `[Directive] Plugin \"${plugin.name}\" is already registered, replacing...`,\n );\n this.unregister(plugin.name);\n }\n plugins.push(plugin);\n },\n\n unregister(name: string): void {\n const index = plugins.findIndex((p) => p.name === name);\n if (index !== -1) {\n plugins.splice(index, 1);\n }\n },\n\n // biome-ignore lint/suspicious/noExplicitAny: Plugins work with any schema\n getPlugins(): Plugin<any>[] {\n return [...plugins];\n },\n\n // Lifecycle hooks (emitInit is async, handled separately)\n // biome-ignore lint/suspicious/noExplicitAny: System type varies\n async emitInit(system: System<any>): Promise<void> {\n for (const plugin of plugins) {\n await safeCallAsync(() => plugin.onInit?.(system) as Promise<void>);\n }\n },\n emitStart: broadcast(\"onStart\"),\n emitStop: broadcast(\"onStop\"),\n emitDestroy: broadcast(\"onDestroy\"),\n\n // Fact hooks\n emitFactSet: broadcast(\"onFactSet\"),\n emitFactDelete: broadcast(\"onFactDelete\"),\n emitFactsBatch: broadcast(\"onFactsBatch\"),\n\n // Derivation hooks\n emitDerivationCompute: broadcast(\"onDerivationCompute\"),\n emitDerivationInvalidate: broadcast(\"onDerivationInvalidate\"),\n\n // Reconciliation hooks\n emitReconcileStart: broadcast(\"onReconcileStart\"),\n emitReconcileEnd: broadcast(\"onReconcileEnd\"),\n\n // Constraint hooks\n emitConstraintEvaluate: broadcast(\"onConstraintEvaluate\"),\n emitConstraintError: broadcast(\"onConstraintError\"),\n\n // Requirement hooks\n emitRequirementCreated: broadcast(\"onRequirementCreated\"),\n emitRequirementMet: broadcast(\"onRequirementMet\"),\n emitRequirementCanceled: broadcast(\"onRequirementCanceled\"),\n\n // Resolver hooks\n emitResolverStart: broadcast(\"onResolverStart\"),\n emitResolverComplete: broadcast(\"onResolverComplete\"),\n emitResolverError: broadcast(\"onResolverError\"),\n emitResolverRetry: broadcast(\"onResolverRetry\"),\n emitResolverCancel: broadcast(\"onResolverCancel\"),\n\n // Effect hooks\n emitEffectRun: broadcast(\"onEffectRun\"),\n emitEffectError: broadcast(\"onEffectError\"),\n\n // History hooks\n emitSnapshot: broadcast(\"onSnapshot\"),\n emitHistoryNavigate: broadcast(\"onHistoryNavigate\"),\n\n // Error boundary hooks\n emitError: broadcast(\"onError\"),\n emitErrorRecovery: broadcast(\"onErrorRecovery\"),\n\n // Dynamic definition hooks\n emitDefinitionRegister: broadcast(\"onDefinitionRegister\"),\n emitDefinitionAssign: broadcast(\"onDefinitionAssign\"),\n emitDefinitionUnregister: broadcast(\"onDefinitionUnregister\"),\n emitDefinitionCall: broadcast(\"onDefinitionCall\"),\n\n // Trace hooks\n emitTraceComplete: broadcast(\"onTraceComplete\"),\n } as PluginManager<S>;\n\n return manager;\n}\n","/**\n * Resolvers - Capability-based handlers for requirements\n *\n * Features:\n * - Capability matching (handles predicate)\n * - Custom dedupe keys\n * - Retry policies with exponential backoff\n * - Batched resolution for similar requirements\n * - Cancellation via AbortController\n */\n\nimport { withTimeout } from \"../utils/utils.js\";\nimport type {\n BatchConfig,\n BatchResolveResults,\n Facts,\n FactsSnapshot,\n FactsStore,\n Requirement,\n RequirementWithId,\n ResolverContext,\n ResolverStatus,\n ResolversDef,\n RetryPolicy,\n Schema,\n} from \"./types.js\";\n\n// ============================================================================\n// Resolvers Manager\n// ============================================================================\n\n/**\n * Summary of a resolver that is currently in flight.\n *\n * @internal\n */\nexport interface InflightInfo {\n /** The unique requirement ID being resolved. */\n id: string;\n /** The definition ID of the resolver handling this requirement. */\n resolverId: string;\n /** Epoch timestamp (ms) when resolution started. */\n startedAt: number;\n}\n\n/**\n * Manager returned by {@link createResolversManager} that matches\n * requirements to resolver handlers and manages their execution lifecycle.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport interface ResolversManager<_S extends Schema> {\n /**\n * Start resolving a requirement by matching it to a resolver handler.\n *\n * @remarks\n * Duplicate in-flight requirements (same `req.id`) are silently ignored.\n * If the matched resolver has `batch.enabled`, the requirement is queued\n * for batch processing instead of being resolved immediately.\n *\n * @param req - The requirement (with a stable identity ID) to resolve.\n */\n resolve(req: RequirementWithId): void;\n /**\n * Cancel an in-flight or batch-queued resolver by requirement ID.\n *\n * @remarks\n * Aborts the `AbortController` for in-flight resolvers. For batch-queued\n * requirements, removes the requirement from the pending batch.\n *\n * @param requirementId - The unique requirement ID to cancel.\n */\n cancel(requirementId: string): void;\n /**\n * Cancel every in-flight resolver and flush all pending batch queues.\n */\n cancelAll(): void;\n /**\n * Get the current status of a resolver by requirement ID.\n *\n * @param requirementId - The unique requirement ID to look up.\n * @returns The {@link ResolverStatus} (idle, pending, running, success, error, or canceled).\n */\n getStatus(requirementId: string): ResolverStatus;\n /**\n * Get the requirement IDs of all currently in-flight resolvers.\n *\n * @returns An array of requirement ID strings.\n */\n getInflight(): string[];\n /**\n * Get detailed info for every in-flight resolver.\n *\n * @returns An array of {@link InflightInfo} objects.\n */\n getInflightInfo(): InflightInfo[];\n /**\n * Get the number of currently in-flight resolvers without allocating an array.\n *\n * @returns The count of in-flight resolvers.\n */\n getInflightCount(): number;\n /**\n * Check whether a requirement is currently being resolved.\n *\n * @param requirementId - The unique requirement ID to check.\n * @returns `true` if the requirement has an active in-flight resolver.\n */\n isResolving(requirementId: string): boolean;\n /**\n * Immediately flush all pending batch queues, executing their resolvers.\n */\n processBatches(): void;\n /**\n * Check whether any batch queues have requirements waiting to be processed.\n *\n * @returns `true` if at least one batch queue is non-empty.\n */\n hasPendingBatches(): boolean;\n /**\n * Register additional resolver definitions at runtime (used for dynamic\n * module registration).\n *\n * @remarks\n * Clears the resolver-by-type cache so newly registered resolvers are\n * discoverable on the next {@link ResolversManager.resolve | resolve} call.\n *\n * @param newDefs - New resolver definitions to merge into the manager.\n */\n registerDefinitions(newDefs: ResolversDef<Schema>): void;\n /**\n * Override an existing resolver definition.\n *\n * @param id - The resolver definition ID to override.\n * @param def - The new resolver definition.\n * @throws If no resolver with this ID exists.\n */\n assignDefinition(id: string, def: ResolversDef<Schema>[string]): void;\n /**\n * Remove a resolver definition. Cancels any inflight resolution.\n *\n * @param id - The resolver definition ID to remove.\n */\n unregisterDefinition(id: string): void;\n /**\n * Execute a resolver with a given requirement object.\n *\n * @param id - The resolver definition ID.\n * @param requirement - The requirement to resolve.\n */\n callOne(id: string, requirement: Requirement): Promise<void>;\n /**\n * Clean up all internal state. Called on system destroy.\n */\n destroy(): void;\n}\n\n/** Internal resolver state */\ninterface ResolverState {\n requirementId: string;\n resolverId: string;\n controller: AbortController;\n startedAt: number;\n attempt: number;\n status: ResolverStatus;\n /** Original requirement for proper cancel callback */\n originalRequirement: RequirementWithId;\n}\n\n/** Batch state for batched resolvers */\ninterface BatchState {\n resolverId: string;\n requirements: RequirementWithId[];\n timer: ReturnType<typeof setTimeout> | null;\n}\n\n/**\n * Configuration options accepted by {@link createResolversManager}.\n *\n * @internal\n */\nexport interface CreateResolversOptions<S extends Schema> {\n /** Resolver definitions keyed by ID. */\n definitions: ResolversDef<S>;\n /** Proxy-based facts object passed to resolver contexts. */\n facts: Facts<S>;\n /** Underlying fact store used for `batch()` coalescing of mutations. */\n store: FactsStore<S>;\n /** Called when a resolver begins execution. */\n onStart?: (resolver: string, req: RequirementWithId) => void;\n /** Called when a resolver completes successfully, with the wall-clock duration in ms. */\n onComplete?: (\n resolver: string,\n req: RequirementWithId,\n duration: number,\n ) => void;\n /** Called when a resolver exhausts all retry attempts. */\n onError?: (resolver: string, req: RequirementWithId, error: unknown) => void;\n /** Called before each retry attempt with the upcoming attempt number. */\n onRetry?: (resolver: string, req: RequirementWithId, attempt: number) => void;\n /** Called when a resolver is canceled via {@link ResolversManager.cancel | cancel}. */\n onCancel?: (resolver: string, req: RequirementWithId) => void;\n /** Called after any resolver finishes (success, error, or batch completion) to trigger reconciliation. */\n onResolutionComplete?: () => void;\n}\n\n/** Default retry policy */\nconst DEFAULT_RETRY: RetryPolicy = {\n attempts: 1,\n backoff: \"none\",\n initialDelay: 100,\n maxDelay: 30000,\n};\n\n/** Default batch config */\nconst DEFAULT_BATCH: BatchConfig = {\n enabled: false,\n windowMs: 50,\n};\n\n/**\n * Calculate delay for a retry attempt based on backoff policy.\n *\n * @param policy - Retry policy with backoff strategy and delay bounds\n * @param attempt - Current attempt number (1-based)\n * @returns Delay in milliseconds, clamped to maxDelay\n */\nfunction calculateDelay(policy: RetryPolicy, attempt: number): number {\n const { backoff, initialDelay = 100, maxDelay = 30000 } = policy;\n\n let delay: number;\n\n switch (backoff) {\n case \"none\":\n delay = initialDelay;\n break;\n case \"linear\":\n delay = initialDelay * attempt;\n break;\n case \"exponential\":\n delay = initialDelay * 2 ** (attempt - 1);\n break;\n default:\n delay = initialDelay;\n }\n\n // Ensure delay is at least 1ms to prevent busy loops\n return Math.max(1, Math.min(delay, maxDelay));\n}\n\n/**\n * Create a manager that fulfills requirements by matching them to resolver\n * handlers.\n *\n * @remarks\n * Resolvers are matched by requirement type (string equality) or a predicate\n * function. Each resolution runs with an `AbortController` for cancellation\n * and configurable retry policies (none, linear, or exponential backoff).\n *\n * **Batching:** When a resolver sets `batch.enabled`, incoming requirements\n * are queued and flushed either when `batch.maxSize` is reached or after\n * `batch.windowMs` elapses, whichever comes first. Batch resolvers can use\n * `resolveBatch` (all-or-nothing) or `resolveBatchWithResults` (per-item\n * success/failure). If only `resolve` is provided with batching enabled, the\n * manager falls back to individual resolution calls.\n *\n * Duplicate in-flight requirements (same requirement ID) are automatically\n * deduplicated. Resolver-by-type lookups are cached with FIFO eviction at\n * 1 000 entries to handle dynamic requirement types.\n *\n * @param options - Configuration including resolver definitions, facts proxy,\n * store, and lifecycle callbacks.\n * @returns A {@link ResolversManager} for dispatching, canceling, and\n * inspecting requirement resolution.\n *\n * @example\n * ```typescript\n * const resolvers = createResolversManager({\n * definitions: {\n * transition: {\n * requirement: \"TRANSITION\",\n * retry: { attempts: 3, backoff: \"exponential\" },\n * resolve: async (req, context) => {\n * context.facts.phase = req.to;\n * context.facts.elapsed = 0;\n * },\n * },\n * },\n * facts: factsProxy,\n * store: factsStore,\n * onComplete: (id, req, ms) => console.log(`${id} resolved in ${ms}ms`),\n * });\n *\n * resolvers.resolve(requirementWithId);\n * ```\n *\n * @internal\n */\n/**\n * Validate resolver definitions in dev mode.\n * Ensures each resolver has resolve() or resolveBatch(), and warns\n * when batch.enabled is set without a batch handler.\n */\nfunction validateDefinitions<S extends Schema>(\n definitions: ResolversDef<S>,\n): void {\n if (process.env.NODE_ENV === \"production\") {\n return;\n }\n\n for (const [id, def] of Object.entries(definitions)) {\n if (!def.resolve && !def.resolveBatch && !def.resolveBatchWithResults) {\n throw new Error(\n `[Directive] Resolver \"${id}\" must define either resolve() or resolveBatch(). Add one of these methods to handle requirements.`,\n );\n }\n\n if (\n !def.batch?.enabled ||\n def.resolveBatch ||\n def.resolveBatchWithResults\n ) {\n continue;\n }\n\n if (def.resolve) {\n console.warn(\n `[Directive] Resolver \"${id}\" has batch.enabled but no resolveBatch(). Falling back to individual resolve() calls. Add resolveBatch() for true bulk operations.`,\n );\n } else {\n throw new Error(\n `[Directive] Resolver \"${id}\" has batch.enabled=true but no resolve(), resolveBatch(), or resolveBatchWithResults() method.`,\n );\n }\n }\n}\n\nexport function createResolversManager<S extends Schema>(\n options: CreateResolversOptions<S>,\n): ResolversManager<S> {\n const {\n definitions,\n facts,\n store,\n onStart,\n onComplete,\n onError,\n onRetry,\n onCancel,\n onResolutionComplete,\n } = options;\n\n validateDefinitions(definitions);\n\n // Active resolver states by requirement ID\n const inflight = new Map<string, ResolverState>();\n\n // Completed/failed statuses (kept for inspection) - LRU cleanup\n const statuses = new Map<string, ResolverStatus>();\n const MAX_STATUSES = 1000; // Limit to prevent memory leak\n\n // Batch states by resolver ID\n const batches = new Map<string, BatchState>();\n\n // Resolver index by requirement type for O(1) lookup (populated lazily)\n // Capped to prevent unbounded growth with dynamic requirement types (e.g., FETCH_USER_${id})\n const resolversByType = new Map<string, Set<string>>();\n const MAX_RESOLVER_CACHE = 1000;\n\n /** Cleanup old statuses to prevent memory leak */\n function cleanupStatuses(): void {\n if (statuses.size > MAX_STATUSES) {\n // Remove oldest entries (first inserted = first in iteration)\n const entriesToRemove = statuses.size - MAX_STATUSES;\n const iterator = statuses.keys();\n for (let i = 0; i < entriesToRemove; i++) {\n const key = iterator.next().value;\n if (key) statuses.delete(key);\n }\n }\n }\n\n /** Type guard for resolver with string `requirement` property */\n function hasStringRequirement(def: unknown): def is { requirement: string } {\n return (\n typeof def === \"object\" &&\n def !== null &&\n \"requirement\" in def &&\n typeof (def as { requirement: unknown }).requirement === \"string\"\n );\n }\n\n /** Type guard for resolver with function `requirement` property */\n function hasFunctionRequirement(\n def: unknown,\n ): def is { requirement: (req: Requirement) => boolean } {\n return (\n typeof def === \"object\" &&\n def !== null &&\n \"requirement\" in def &&\n typeof (def as { requirement: unknown }).requirement === \"function\"\n );\n }\n\n /**\n * Check if a resolver handles a requirement.\n * Supports:\n * - `requirement: \"TYPE\"` - string matching\n * - `requirement: (req) => req is T` - function type guard\n */\n function resolverHandles(\n def: ResolversDef<S>[string],\n req: Requirement,\n ): boolean {\n // Check string-based `requirement`\n if (hasStringRequirement(def)) {\n return req.type === def.requirement;\n }\n\n // Check function-based `requirement` (type guard)\n if (hasFunctionRequirement(def)) {\n return def.requirement(req);\n }\n\n return false;\n }\n\n /** Try to find a resolver from the LRU cache */\n function findResolverInCache(\n reqType: string,\n req: Requirement,\n ): string | null {\n const cached = resolversByType.get(reqType);\n if (!cached) {\n return null;\n }\n\n // Move to end of Map iteration order (LRU: least recently used is first)\n resolversByType.delete(reqType);\n resolversByType.set(reqType, cached);\n\n for (const id of cached) {\n const def = definitions[id];\n if (def && resolverHandles(def, req)) {\n return id;\n }\n }\n\n return null;\n }\n\n /** Add a resolver ID to the type cache, evicting if full */\n function cacheResolverForType(reqType: string, resolverId: string): void {\n if (!resolversByType.has(reqType)) {\n if (resolversByType.size >= MAX_RESOLVER_CACHE) {\n const oldest = resolversByType.keys().next().value;\n if (oldest !== undefined) {\n resolversByType.delete(oldest);\n }\n }\n resolversByType.set(reqType, new Set());\n }\n resolversByType.get(reqType)!.add(resolverId);\n }\n\n /** Find a resolver that handles a requirement */\n function findResolver(req: Requirement): string | null {\n const reqType = req.type;\n\n // Check cache first\n const cached = findResolverInCache(reqType, req);\n if (cached) {\n return cached;\n }\n\n // Fallback to full search and cache the result\n for (const [id, def] of Object.entries(definitions)) {\n if (resolverHandles(def, req)) {\n cacheResolverForType(reqType, id);\n\n return id;\n }\n }\n\n return null;\n }\n\n /** Create resolver context */\n function createContext(signal: AbortSignal): ResolverContext<S> {\n return {\n facts,\n signal,\n snapshot: () => facts.$snapshot() as FactsSnapshot<S>,\n };\n }\n\n /**\n * Shared retry catch-block logic: normalize error, check abort, check shouldRetry,\n * sleep with abort awareness. Returns \"abort\" if canceled, \"break\" if shouldRetry\n * returned false, or \"continue\" if the next attempt should proceed.\n */\n async function handleRetryError(\n error: unknown,\n attempt: number,\n retryPolicy: RetryPolicy & { attempts: number; backoff: string },\n controller: AbortController,\n ): Promise<{ action: \"abort\" | \"break\" | \"continue\"; error: Error }> {\n const normalizedError =\n error instanceof Error ? error : new Error(String(error));\n\n if (controller.signal.aborted) {\n return { action: \"abort\", error: normalizedError };\n }\n\n if (\n retryPolicy.shouldRetry &&\n !retryPolicy.shouldRetry(normalizedError, attempt)\n ) {\n return { action: \"break\", error: normalizedError };\n }\n\n if (attempt < retryPolicy.attempts) {\n if (controller.signal.aborted) {\n return { action: \"abort\", error: normalizedError };\n }\n\n const delay = calculateDelay(retryPolicy, attempt);\n\n await new Promise<void>((resolve) => {\n const timeoutId = setTimeout(resolve, delay);\n const abortHandler = () => {\n clearTimeout(timeoutId);\n resolve();\n };\n controller.signal.addEventListener(\"abort\", abortHandler, {\n once: true,\n });\n });\n\n if (controller.signal.aborted) {\n return { action: \"abort\", error: normalizedError };\n }\n }\n\n return { action: \"continue\", error: normalizedError };\n }\n\n /**\n * Invoke a resolver's resolve() function with optional timeout.\n *\n * The `store.batch()` here intentionally wraps only the synchronous start of\n * the async resolver — it coalesces all fact mutations that happen before the\n * first `await` into a single notification (one `onBatch` callback, one\n * `scheduleReconcile()`). After the first `await`, the batch has ended and\n * each subsequent fact mutation triggers its own `onChange` → reconcile cycle.\n *\n * This is correct: pre-await mutations typically set up transient state (e.g.\n * \"pending\" / \"fetching\" flags) and should be seen as one atomic change, while\n * post-await mutations represent real state transitions (e.g. \"success\" with\n * fetched data) that the constraint engine must evaluate independently.\n */\n async function invokeResolve(\n def: ResolversDef<S>[string],\n resolverId: string,\n req: RequirementWithId,\n signal: AbortSignal,\n ): Promise<void> {\n if (!def.resolve) {\n return;\n }\n\n // Batch wraps only the synchronous start — see JSDoc above.\n let resolvePromise!: Promise<void>;\n store.batch(() => {\n resolvePromise = def.resolve!(\n req.requirement as Parameters<NonNullable<typeof def.resolve>>[0],\n createContext(signal),\n ) as Promise<void>;\n });\n\n const timeout = def.timeout;\n if (timeout && timeout > 0) {\n await withTimeout(\n resolvePromise,\n timeout,\n `Resolver \"${resolverId}\" timed out after ${timeout}ms`,\n );\n\n return;\n }\n\n await resolvePromise;\n }\n\n /** Record a successful resolution */\n function recordSuccess(\n resolverId: string,\n req: RequirementWithId,\n startedAt: number,\n ): void {\n const duration = Date.now() - startedAt;\n statuses.set(req.id, {\n state: \"success\",\n requirementId: req.id,\n completedAt: Date.now(),\n duration,\n });\n cleanupStatuses();\n onComplete?.(resolverId, req, duration);\n }\n\n /** Record a failed resolution */\n function recordError(\n resolverId: string,\n req: RequirementWithId,\n error: Error,\n attempts: number,\n ): void {\n statuses.set(req.id, {\n state: \"error\",\n requirementId: req.id,\n error,\n failedAt: Date.now(),\n attempts,\n });\n cleanupStatuses();\n onError?.(resolverId, req, error);\n }\n\n /** Update inflight state for a new attempt */\n function updateInflightAttempt(\n reqId: string,\n attempt: number,\n startedAt: number,\n ): void {\n const state = inflight.get(reqId);\n if (state) {\n state.attempt = attempt;\n state.status = {\n state: \"running\",\n requirementId: reqId,\n startedAt,\n attempt,\n };\n }\n }\n\n /**\n * Handle the catch block of a retry attempt. Returns true if the loop\n * should continue to the next attempt, false if it should stop.\n */\n async function processRetryError(\n error: unknown,\n attempt: number,\n retryPolicy: RetryPolicy & { attempts: number; backoff: string },\n controller: AbortController,\n notifyRetry: (nextAttempt: number) => void,\n ): Promise<{ lastError: Error; shouldContinue: boolean }> {\n const result = await handleRetryError(\n error,\n attempt,\n retryPolicy,\n controller,\n );\n\n if (result.action === \"continue\" && attempt < retryPolicy.attempts) {\n notifyRetry(attempt + 1);\n }\n\n return {\n lastError: result.error,\n shouldContinue: result.action === \"continue\",\n };\n }\n\n /** Execute a single requirement resolution with retry */\n async function executeResolve(\n resolverId: string,\n req: RequirementWithId,\n controller: AbortController,\n ): Promise<void> {\n const def = definitions[resolverId];\n if (!def) {\n return;\n }\n\n const retryPolicy = { ...DEFAULT_RETRY, ...def.retry };\n let lastError: Error | null = null;\n const startedAt = inflight.get(req.id)?.startedAt ?? Date.now();\n\n for (let attempt = 1; attempt <= retryPolicy.attempts; attempt++) {\n if (controller.signal.aborted) {\n return;\n }\n\n updateInflightAttempt(req.id, attempt, startedAt);\n\n try {\n await invokeResolve(def, resolverId, req, controller.signal);\n recordSuccess(resolverId, req, startedAt);\n\n return;\n } catch (error) {\n const outcome = await processRetryError(\n error,\n attempt,\n retryPolicy,\n controller,\n (next) => onRetry?.(resolverId, req, next),\n );\n lastError = outcome.lastError;\n\n if (!outcome.shouldContinue) {\n break;\n }\n }\n }\n\n recordError(resolverId, req, lastError!, retryPolicy.attempts);\n }\n\n /** Await a promise with optional timeout */\n async function awaitWithTimeout<T>(\n promise: Promise<T>,\n timeout: number | undefined,\n timeoutMessage: string,\n ): Promise<T> {\n if (timeout && timeout > 0) {\n return withTimeout(promise, timeout, timeoutMessage);\n }\n\n return promise;\n }\n\n /**\n * Execute resolveBatchWithResults and process per-item results.\n * Returns \"done\" if no retry needed, or \"retry\" if all items failed.\n */\n async function executeWithResults(\n def: ResolversDef<S>[string],\n resolverId: string,\n requirements: RequirementWithId[],\n reqPayloads: Requirement[],\n ctx: ResolverContext<S>,\n timeout: number | undefined,\n startedAt: number,\n attempt: number,\n ): Promise<\"done\" | \"retry\"> {\n let resolvePromise!: Promise<BatchResolveResults>;\n store.batch(() => {\n // biome-ignore lint/suspicious/noExplicitAny: Requirement type varies\n resolvePromise = def.resolveBatchWithResults!(reqPayloads as any, ctx);\n });\n\n const results = await awaitWithTimeout(\n resolvePromise,\n timeout,\n `Batch resolver \"${resolverId}\" timed out after ${timeout}ms`,\n );\n\n if (results.length !== requirements.length) {\n throw new Error(\n `[Directive] Batch resolver \"${resolverId}\" returned ${results.length} results ` +\n `but expected ${requirements.length}. Results array must match input order.`,\n );\n }\n\n let hasFailures = false;\n\n for (let i = 0; i < requirements.length; i++) {\n const req = requirements[i]!;\n const result = results[i]!;\n\n if (result.success) {\n recordSuccess(resolverId, req, startedAt);\n continue;\n }\n\n hasFailures = true;\n const error = result.error ?? new Error(\"Batch item failed\");\n statuses.set(req.id, {\n state: \"error\",\n requirementId: req.id,\n error,\n failedAt: Date.now(),\n attempts: attempt,\n });\n onError?.(resolverId, req, error);\n }\n\n // No failures or partial success: done (don't retry partial)\n if (!hasFailures || requirements.some((_, i) => results[i]?.success)) {\n return \"done\";\n }\n\n // ALL failed: caller should retry\n return \"retry\";\n }\n\n /** Execute all-or-nothing resolveBatch and mark all as success */\n async function executeAllOrNothing(\n def: ResolversDef<S>[string],\n resolverId: string,\n requirements: RequirementWithId[],\n reqPayloads: Requirement[],\n ctx: ResolverContext<S>,\n timeout: number | undefined,\n startedAt: number,\n ): Promise<void> {\n let resolvePromise!: Promise<void>;\n store.batch(() => {\n resolvePromise = def.resolveBatch!(\n // biome-ignore lint/suspicious/noExplicitAny: Requirement type varies\n reqPayloads as any,\n ctx,\n ) as Promise<void>;\n });\n\n await awaitWithTimeout(\n resolvePromise,\n timeout,\n `Batch resolver \"${resolverId}\" timed out after ${timeout}ms`,\n );\n\n for (const req of requirements) {\n recordSuccess(resolverId, req, startedAt);\n }\n }\n\n /** Record errors for all requirements in a batch */\n function recordBatchErrors(\n resolverId: string,\n requirements: RequirementWithId[],\n error: Error,\n attempts: number,\n ): void {\n for (const req of requirements) {\n recordError(resolverId, req, error, attempts);\n }\n }\n\n /** Fall back to individual resolution when no batch handler is defined */\n async function executeBatchFallback(\n resolverId: string,\n requirements: RequirementWithId[],\n ): Promise<void> {\n await Promise.all(\n requirements.map((req) => {\n const controller = new AbortController();\n\n return executeResolve(resolverId, req, controller);\n }),\n );\n }\n\n /** Execute one attempt of a batch (with-results or all-or-nothing) */\n async function executeBatchAttempt(\n def: ResolversDef<S>[string],\n resolverId: string,\n requirements: RequirementWithId[],\n signal: AbortSignal,\n timeout: number | undefined,\n startedAt: number,\n attempt: number,\n ): Promise<\"done\" | \"retry\"> {\n const ctx = createContext(signal);\n const reqPayloads = requirements.map((r) => r.requirement);\n\n if (def.resolveBatchWithResults) {\n return executeWithResults(\n def,\n resolverId,\n requirements,\n reqPayloads,\n ctx,\n timeout,\n startedAt,\n attempt,\n );\n }\n\n await executeAllOrNothing(\n def,\n resolverId,\n requirements,\n reqPayloads,\n ctx,\n timeout,\n startedAt,\n );\n\n return \"done\";\n }\n\n /** Notify retry for all requirements in a batch */\n function notifyBatchRetry(\n resolverId: string,\n requirements: RequirementWithId[],\n nextAttempt: number,\n ): void {\n for (const req of requirements) {\n onRetry?.(resolverId, req, nextAttempt);\n }\n }\n\n /** Run the retry loop for a batch, returning the last error if all attempts fail */\n async function runBatchRetryLoop(\n def: ResolversDef<S>[string],\n resolverId: string,\n requirements: RequirementWithId[],\n retryPolicy: RetryPolicy & { attempts: number; backoff: string },\n timeout: number | undefined,\n ): Promise<Error | null> {\n const controller = new AbortController();\n const startedAt = Date.now();\n let lastError: Error | null = null;\n\n for (let attempt = 1; attempt <= retryPolicy.attempts; attempt++) {\n if (controller.signal.aborted) {\n return null;\n }\n\n try {\n const outcome = await executeBatchAttempt(\n def,\n resolverId,\n requirements,\n controller.signal,\n timeout,\n startedAt,\n attempt,\n );\n if (outcome === \"done\") {\n return null;\n }\n } catch (error) {\n const outcome = await processRetryError(\n error,\n attempt,\n retryPolicy,\n controller,\n (next) => notifyBatchRetry(resolverId, requirements, next),\n );\n lastError = outcome.lastError;\n\n if (!outcome.shouldContinue) {\n break;\n }\n }\n }\n\n return lastError;\n }\n\n /** Execute a batch of requirements with retry, timeout, and partial failure support */\n async function executeBatch(\n resolverId: string,\n requirements: RequirementWithId[],\n ): Promise<void> {\n const def = definitions[resolverId];\n if (!def) {\n return;\n }\n\n if (!def.resolveBatch && !def.resolveBatchWithResults) {\n await executeBatchFallback(resolverId, requirements);\n\n return;\n }\n\n const retryPolicy = { ...DEFAULT_RETRY, ...def.retry };\n const batchConfig = { ...DEFAULT_BATCH, ...def.batch };\n const timeout = batchConfig.timeoutMs ?? def.timeout;\n\n const lastError = await runBatchRetryLoop(\n def,\n resolverId,\n requirements,\n retryPolicy,\n timeout,\n );\n\n if (lastError) {\n recordBatchErrors(\n resolverId,\n requirements,\n lastError,\n retryPolicy.attempts,\n );\n }\n }\n\n /** Hard cap for batch queues without explicit maxSize — prevents OOM */\n const DEFAULT_MAX_QUEUE_SIZE = 10_000;\n\n /** Cancel a batch timer if active */\n function clearBatchTimer(batch: BatchState): void {\n if (batch.timer) {\n clearTimeout(batch.timer);\n batch.timer = null;\n }\n }\n\n /** Ensure a batch entry exists for a resolver */\n function ensureBatch(resolverId: string): BatchState {\n if (!batches.has(resolverId)) {\n batches.set(resolverId, {\n resolverId,\n requirements: [],\n timer: null,\n });\n }\n\n return batches.get(resolverId)!;\n }\n\n /** Add a requirement to a batch */\n function addToBatch(resolverId: string, req: RequirementWithId): void {\n const def = definitions[resolverId];\n if (!def) {\n return;\n }\n\n const batchConfig = { ...DEFAULT_BATCH, ...def.batch };\n const batch = ensureBatch(resolverId);\n\n // Enforce hard cap to prevent OOM from unbounded accumulation\n const effectiveMax = batchConfig.maxSize || DEFAULT_MAX_QUEUE_SIZE;\n if (batch.requirements.length >= effectiveMax) {\n clearBatchTimer(batch);\n processBatch(resolverId);\n }\n\n batch.requirements.push(req);\n\n // Flush immediately if maxSize reached\n if (\n batchConfig.maxSize &&\n batch.requirements.length >= batchConfig.maxSize\n ) {\n clearBatchTimer(batch);\n processBatch(resolverId);\n\n return;\n }\n\n // Start or reset timer\n clearBatchTimer(batch);\n batch.timer = setTimeout(() => {\n processBatch(resolverId);\n }, batchConfig.windowMs);\n }\n\n /** Process a single batch */\n function processBatch(resolverId: string): void {\n const batch = batches.get(resolverId);\n if (!batch || batch.requirements.length === 0) return;\n\n const requirements = [...batch.requirements];\n batch.requirements = [];\n batch.timer = null;\n\n // Execute batch\n executeBatch(resolverId, requirements).then(() => {\n onResolutionComplete?.();\n });\n }\n\n const manager: ResolversManager<S> = {\n resolve(req: RequirementWithId): void {\n // Already resolving?\n if (inflight.has(req.id)) {\n return;\n }\n\n // Find resolver\n const resolverId = findResolver(req.requirement);\n if (!resolverId) {\n if (process.env.NODE_ENV !== \"production\") {\n console.warn(\n `[Directive] No resolver found for requirement type \"${req.requirement.type}\" (id: ${req.id})`,\n );\n }\n return;\n }\n\n const def = definitions[resolverId];\n if (!def) return;\n\n // Check if this is a batched resolver\n if (def.batch?.enabled) {\n addToBatch(resolverId, req);\n return;\n }\n\n // Start resolution\n const controller = new AbortController();\n const startedAt = Date.now();\n\n const state: ResolverState = {\n requirementId: req.id,\n resolverId,\n controller,\n startedAt,\n attempt: 1,\n status: {\n state: \"pending\",\n requirementId: req.id,\n startedAt,\n },\n originalRequirement: req,\n };\n\n inflight.set(req.id, state);\n onStart?.(resolverId, req);\n\n // Execute asynchronously\n executeResolve(resolverId, req, controller).finally(() => {\n // Only fire onResolutionComplete if we're the first to clean up.\n // If cancel() already removed us from inflight, skip to avoid\n // spurious double-notifications.\n const wasInflight = inflight.delete(req.id);\n if (wasInflight) {\n onResolutionComplete?.();\n }\n });\n },\n\n cancel(requirementId: string): void {\n // Check inflight resolvers first\n const state = inflight.get(requirementId);\n if (state) {\n state.controller.abort();\n inflight.delete(requirementId);\n\n statuses.set(requirementId, {\n state: \"canceled\",\n requirementId,\n canceledAt: Date.now(),\n });\n cleanupStatuses();\n\n onCancel?.(state.resolverId, state.originalRequirement);\n\n return;\n }\n\n // Check pending batch queues\n for (const batch of batches.values()) {\n const idx = batch.requirements.findIndex((r) => r.id === requirementId);\n if (idx !== -1) {\n const [removed] = batch.requirements.splice(idx, 1);\n\n statuses.set(requirementId, {\n state: \"canceled\",\n requirementId,\n canceledAt: Date.now(),\n });\n cleanupStatuses();\n\n if (removed) {\n onCancel?.(batch.resolverId, removed);\n }\n\n return;\n }\n }\n },\n\n cancelAll(): void {\n const ids = [...inflight.keys()];\n for (const id of ids) {\n this.cancel(id);\n }\n\n // Cancel queued batch requirements\n for (const batch of batches.values()) {\n if (batch.timer) {\n clearTimeout(batch.timer);\n }\n for (const req of batch.requirements) {\n statuses.set(req.id, {\n state: \"canceled\",\n requirementId: req.id,\n canceledAt: Date.now(),\n });\n onCancel?.(batch.resolverId, req);\n }\n }\n batches.clear();\n cleanupStatuses();\n },\n\n getStatus(requirementId: string): ResolverStatus {\n // Check inflight first\n const state = inflight.get(requirementId);\n if (state) {\n return state.status;\n }\n\n // Check completed statuses\n const status = statuses.get(requirementId);\n if (status) {\n return status;\n }\n\n return { state: \"idle\" };\n },\n\n getInflight(): string[] {\n return [...inflight.keys()];\n },\n\n getInflightInfo(): InflightInfo[] {\n return [...inflight.values()].map((state) => ({\n id: state.requirementId,\n resolverId: state.resolverId,\n startedAt: state.startedAt,\n }));\n },\n\n getInflightCount(): number {\n return inflight.size;\n },\n\n isResolving(requirementId: string): boolean {\n return inflight.has(requirementId);\n },\n\n processBatches(): void {\n for (const resolverId of batches.keys()) {\n processBatch(resolverId);\n }\n },\n\n hasPendingBatches(): boolean {\n for (const batch of batches.values()) {\n if (batch.requirements.length > 0) {\n return true;\n }\n }\n\n return false;\n },\n\n registerDefinitions(newDefs: ResolversDef<Schema>): void {\n for (const [key, def] of Object.entries(newDefs)) {\n (definitions as Record<string, unknown>)[key] = def;\n }\n // Clear the resolver-by-type cache so new resolvers are discovered\n resolversByType.clear();\n },\n\n assignDefinition(id: string, def: ResolversDef<Schema>[string]): void {\n if (!definitions[id]) {\n throw new Error(\n `[Directive] Cannot assign resolver \"${id}\" — it does not exist. Use register() to create it.`,\n );\n }\n\n // Replace definition\n (definitions as Record<string, unknown>)[id] = def;\n // Clear cache so the new definition is discoverable\n resolversByType.clear();\n },\n\n unregisterDefinition(id: string): void {\n if (!definitions[id]) {\n return;\n }\n\n // Cancel any inflight resolutions using this resolver\n for (const [reqId, state] of inflight) {\n if (state.resolverId === id) {\n state.controller.abort();\n inflight.delete(reqId);\n statuses.set(reqId, {\n state: \"canceled\",\n requirementId: reqId,\n canceledAt: Date.now(),\n });\n onCancel?.(id, state.originalRequirement);\n }\n }\n\n // Remove from batch queues\n const batch = batches.get(id);\n if (batch) {\n if (batch.timer) {\n clearTimeout(batch.timer);\n }\n for (const req of batch.requirements) {\n statuses.set(req.id, {\n state: \"canceled\",\n requirementId: req.id,\n canceledAt: Date.now(),\n });\n onCancel?.(id, req);\n }\n batches.delete(id);\n }\n\n delete (definitions as Record<string, unknown>)[id];\n resolversByType.clear();\n cleanupStatuses();\n },\n\n async callOne(id: string, requirement: Requirement): Promise<void> {\n const def = definitions[id];\n if (!def) {\n throw new Error(\n `[Directive] Cannot call resolver \"${id}\" — it does not exist.`,\n );\n }\n\n const controller = new AbortController();\n const ctx = createContext(controller.signal);\n\n if (def.resolve) {\n // Batch wraps only the synchronous start — see invokeResolve JSDoc.\n let resolvePromise!: Promise<void>;\n store.batch(() => {\n resolvePromise = def.resolve!(\n requirement as Parameters<NonNullable<typeof def.resolve>>[0],\n ctx,\n ) as Promise<void>;\n });\n\n await resolvePromise;\n }\n },\n\n destroy(): void {\n this.cancelAll();\n statuses.clear();\n resolversByType.clear();\n },\n };\n\n return manager;\n}\n","/**\n * Proxy-based accessors for the engine's derive and events surfaces.\n *\n * Extracted from engine.ts to reduce file size. Pure proxy creation —\n * all state mutation is delegated to callbacks.\n *\n * @internal\n */\n\nimport type { DefinitionsRegistry } from \"./engine-definitions.js\";\nimport { BLOCKED_PROPS } from \"./tracking.js\";\n\n// ============================================================================\n// Derive Accessor\n// ============================================================================\n\n/**\n * Options for creating the derive accessor proxy.\n *\n * @internal\n */\nexport interface CreateDeriveAccessorOptions {\n /** Merged derivation definitions (mutable reference, checked for key existence) */\n mergedDerive: Record<string, unknown>;\n /** Retrieve a computed derivation value by key */\n getDerivation: (key: string) => unknown;\n /** Definitions registry for dynamic definition methods */\n definitions: DefinitionsRegistry;\n}\n\n/**\n * Create a proxy that provides `system.derive.key` access to derivation values\n * plus dynamic definition methods (register, assign, unregister, etc.).\n *\n * @param options - Derivation definitions, getter, and dynamic registry\n * @returns A proxy combining derivation value access with definition management\n *\n * @internal\n */\nexport function createDeriveAccessor(\n options: CreateDeriveAccessorOptions,\n): Record<string, unknown> {\n const { mergedDerive, getDerivation, definitions } = options;\n\n // Method properties for derive accessor (dynamic definitions API)\n const deriveMethods: Record<string, unknown> = {\n register: (id: string, fn: unknown) =>\n definitions.register(\"derivation\", id, fn),\n assign: (id: string, fn: unknown) =>\n definitions.assign(\"derivation\", id, fn),\n unregister: (id: string) => definitions.unregister(\"derivation\", id),\n call: (id: string) => definitions.call(\"derivation\", id),\n isDynamic: (id: string) => definitions.isDynamic(\"derivation\", id),\n listDynamic: () => definitions.listDynamic(\"derivation\"),\n };\n\n return new Proxy({} as Record<string, unknown>, {\n get(_, prop: string | symbol) {\n if (typeof prop === \"symbol\") {\n return undefined;\n }\n // Prototype pollution protection\n if (BLOCKED_PROPS.has(prop)) {\n return undefined;\n }\n // Check for method properties first (register, assign, etc.)\n if (prop in deriveMethods) {\n return deriveMethods[prop];\n }\n // Return undefined for unknown derivation keys instead of throwing.\n // React 19 dev-mode traverses objects accessing $$typeof, toJSON, then, etc.\n if (!(prop in mergedDerive)) {\n return undefined;\n }\n return getDerivation(prop);\n },\n has(_, prop: string | symbol) {\n if (typeof prop === \"symbol\") {\n return false;\n }\n // Prototype pollution protection\n if (BLOCKED_PROPS.has(prop)) {\n return false;\n }\n return prop in mergedDerive || prop in deriveMethods;\n },\n ownKeys() {\n return Object.keys(mergedDerive);\n },\n getOwnPropertyDescriptor(_, prop: string | symbol) {\n if (typeof prop === \"symbol\") {\n return undefined;\n }\n // Prototype pollution protection\n if (BLOCKED_PROPS.has(prop)) {\n return undefined;\n }\n if (prop in mergedDerive || prop in deriveMethods) {\n return { configurable: true, enumerable: true };\n }\n return undefined;\n },\n set() {\n return false;\n },\n defineProperty() {\n return false;\n },\n getPrototypeOf() {\n return null;\n },\n setPrototypeOf() {\n return false;\n },\n });\n}\n\n// ============================================================================\n// Events Accessor\n// ============================================================================\n\n/**\n * Options for creating the events accessor proxy.\n *\n * @internal\n */\nexport interface CreateEventsAccessorOptions {\n /** Merged event definitions (mutable reference, checked for key existence) */\n mergedEvents: Record<string, unknown>;\n /** Dispatch an event by name with optional payload */\n dispatchEvent: (eventName: string, payload?: Record<string, unknown>) => void;\n}\n\n/**\n * Create a proxy that provides `system.events.eventName(payload)` syntax.\n * Dispatching is delegated to the provided callback.\n *\n * @param options - Event definitions and dispatch callback\n * @returns A proxy that returns dispatch functions per event name\n *\n * @internal\n */\nexport function createEventsAccessor(\n options: CreateEventsAccessorOptions,\n): Record<string, (payload?: Record<string, unknown>) => void> {\n const { mergedEvents, dispatchEvent } = options;\n\n return new Proxy(\n {} as Record<string, (payload?: Record<string, unknown>) => void>,\n {\n get(_, prop: string | symbol) {\n if (typeof prop === \"symbol\") {\n return undefined;\n }\n // Prototype pollution protection\n if (BLOCKED_PROPS.has(prop)) {\n return undefined;\n }\n // Return a function that dispatches the event\n return (payload?: Record<string, unknown>) => {\n dispatchEvent(prop, payload);\n };\n },\n has(_, prop: string | symbol) {\n if (typeof prop === \"symbol\") {\n return false;\n }\n // Prototype pollution protection\n if (BLOCKED_PROPS.has(prop)) {\n return false;\n }\n return prop in mergedEvents;\n },\n ownKeys() {\n return Object.keys(mergedEvents);\n },\n getOwnPropertyDescriptor(_, prop: string | symbol) {\n if (typeof prop === \"symbol\") {\n return undefined;\n }\n // Prototype pollution protection\n if (BLOCKED_PROPS.has(prop)) {\n return undefined;\n }\n if (prop in mergedEvents) {\n return { configurable: true, enumerable: true };\n }\n return undefined;\n },\n set() {\n return false;\n },\n defineProperty() {\n return false;\n },\n getPrototypeOf() {\n return null;\n },\n setPrototypeOf() {\n return false;\n },\n },\n );\n}\n","/**\n * Dynamic definition registry for the engine.\n *\n * Extracted from engine.ts to reduce file size. Handles register, assign,\n * unregister, call, getOriginal, restoreOriginal, isDynamic, and listDynamic\n * for constraints, resolvers, derivations, and effects.\n *\n * @internal\n */\n\nimport type { ConstraintsManager } from \"./constraints.js\";\nimport type { DerivationsManager } from \"./derivations.js\";\nimport type { EffectsManager } from \"./effects.js\";\nimport type { PluginManager } from \"./plugins.js\";\nimport type { ResolversManager } from \"./resolvers.js\";\nimport { BLOCKED_PROPS } from \"./tracking.js\";\nimport type {\n ConstraintsDef,\n DerivationsDef,\n EffectsDef,\n ResolversDef,\n Schema,\n} from \"./types.js\";\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/** Definition type for dynamic registration */\nexport type DefType = \"constraint\" | \"resolver\" | \"derivation\" | \"effect\";\n\ntype DeferredOp =\n | { op: \"register\"; type: DefType; id: string; def: unknown }\n | { op: \"assign\"; type: DefType; id: string; def: unknown }\n | { op: \"unregister\"; type: DefType; id: string };\n\n// ============================================================================\n// DefinitionsRegistry Interface\n// ============================================================================\n\n/**\n * Registry for dynamic definition management (register, assign, unregister, call).\n *\n * @remarks\n * Handles deferral during reconciliation — operations queued while reconciling\n * are applied atomically after the cycle completes. Tracks which definitions\n * were dynamically registered vs. statically defined from module configs.\n *\n * @internal\n */\nexport interface DefinitionsRegistry {\n /**\n * Register a new definition. Deferred if called during reconciliation.\n *\n * @param type - The definition type\n * @param id - Unique definition identifier\n * @param def - The definition object\n * @throws If the definition already exists, or the ID is invalid\n */\n register(type: DefType, id: string, def: unknown): void;\n\n /**\n * Override an existing definition. Deferred if called during reconciliation.\n * Stores the original for later restoration.\n *\n * @param type - The definition type\n * @param id - Definition identifier to override\n * @param def - The replacement definition\n * @throws If the definition does not exist, or the ID is invalid\n */\n assign(type: DefType, id: string, def: unknown): void;\n\n /**\n * Remove a dynamically registered definition. Deferred if called during reconciliation.\n * Static (module-defined) definitions cannot be unregistered.\n *\n * @param type - The definition type\n * @param id - Definition identifier to remove\n */\n unregister(type: DefType, id: string): void;\n\n /**\n * Invoke a definition directly (evaluate constraint, run resolver, etc.).\n *\n * @param type - The definition type\n * @param id - Definition identifier to invoke\n * @param props - Optional properties/payload\n * @returns The invocation result\n */\n call(type: DefType, id: string, props?: unknown): unknown;\n\n /**\n * Check if a definition was dynamically registered.\n *\n * @param type - The definition type\n * @param id - Definition identifier\n */\n isDynamic(type: DefType, id: string): boolean;\n\n /**\n * List all dynamically registered definition IDs for a type.\n *\n * @param type - The definition type\n */\n listDynamic(type: DefType): string[];\n\n /**\n * Flush deferred registrations queued during reconciliation.\n */\n flushDeferred(): void;\n\n /**\n * Get the original definition before it was assigned/overridden.\n *\n * @param type - The definition type\n * @param id - Definition identifier\n * @returns The original definition, or undefined if not overridden\n */\n getOriginal(type: DefType, id: string): unknown | undefined;\n\n /**\n * Restore a definition to its original value (before assign).\n *\n * @param type - The definition type\n * @param id - Definition identifier\n * @returns true if restored, false if no original was found\n */\n restoreOriginal(type: DefType, id: string): boolean;\n\n /**\n * Clean up all dynamic definition state.\n */\n destroy(): void;\n}\n\n// ============================================================================\n// Factory Options\n// ============================================================================\n\n/**\n * Options for creating a definitions registry.\n *\n * @internal\n */\nexport interface CreateDefinitionsRegistryOptions<S extends Schema> {\n /** Merged constraint definitions (mutable reference) */\n mergedConstraints: ConstraintsDef<S>;\n /** Merged resolver definitions (mutable reference) */\n mergedResolvers: ResolversDef<S>;\n /** Merged derivation definitions (mutable reference) */\n mergedDerive: DerivationsDef<S>;\n /** Merged effect definitions (mutable reference) */\n mergedEffects: EffectsDef<S>;\n /** Constraints manager */\n constraintsManager: ConstraintsManager<S>;\n /** Resolvers manager */\n resolversManager: ResolversManager<S>;\n /** Derivations manager */\n derivationsManager: DerivationsManager<S, DerivationsDef<S>>;\n /** Effects manager */\n effectsManager: EffectsManager<S>;\n /** Plugin manager */\n pluginManager: PluginManager<S>;\n /** Getter for engine state flags */\n getState: () => { isDestroyed: boolean; isReconciling: boolean };\n /** Trigger reconciliation */\n scheduleReconcile: () => void;\n /** Max deferred registrations */\n maxDeferredRegistrations: number;\n}\n\n// ============================================================================\n// Implementation\n// ============================================================================\n\n/** Reserved derive method names — derivation IDs cannot use these */\nconst RESERVED_DERIVE_NAMES = new Set([\n \"register\",\n \"assign\",\n \"unregister\",\n \"call\",\n \"isDynamic\",\n \"listDynamic\",\n]);\n\n/**\n * Per-type descriptor used by the dispatch map to collapse the switch\n * statements in applyRegister, applyAssign, and applyUnregister.\n */\ninterface TypeDescriptor {\n /** Human-readable label for error messages */\n label: string;\n /** The mutable merged definitions map for this type */\n mergedMap: Record<string, unknown>;\n /** The manager instance for this type */\n manager: {\n registerDefinitions(defs: Record<string, unknown>): void;\n assignDefinition(id: string, def: unknown): void;\n unregisterDefinition(id: string): void;\n };\n /** Set of dynamically registered IDs */\n dynamicSet: Set<string>;\n /** Map of originals for assigned definitions */\n originalsMap: Map<string, unknown>;\n /** Whether to call scheduleReconcile after register/assign/unregister */\n reconciles: boolean;\n /** Optional extra validation on the ID (e.g. reserved name check) */\n validateId?: (id: string) => void;\n}\n\n/**\n * Create a definitions registry for dynamic definition management.\n *\n * @remarks\n * Receives mutable references to the merged definition maps and manager\n * instances. Operations modify these references directly to maintain\n * atomicity with the engine's state.\n *\n * @param options - Managers, merged maps, and engine state accessors\n * @returns A {@link DefinitionsRegistry} instance\n *\n * @internal\n */\nexport function createDefinitionsRegistry<S extends Schema>(\n options: CreateDefinitionsRegistryOptions<S>,\n): DefinitionsRegistry {\n const {\n mergedConstraints,\n mergedResolvers,\n mergedDerive,\n mergedEffects,\n constraintsManager,\n resolversManager,\n derivationsManager,\n effectsManager,\n pluginManager,\n getState,\n scheduleReconcile,\n maxDeferredRegistrations,\n } = options;\n\n /** Track which definitions were dynamically registered */\n const dynamicIds = {\n constraints: new Set<string>(),\n resolvers: new Set<string>(),\n derivations: new Set<string>(),\n effects: new Set<string>(),\n };\n\n /** Originals map for assigned definitions */\n const originals = {\n constraints: new Map<string, unknown>(),\n resolvers: new Map<string, unknown>(),\n derivations: new Map<string, unknown>(),\n effects: new Map<string, unknown>(),\n };\n\n /** Deferred registrations queue */\n const deferredRegistrations: DeferredOp[] = [];\n\n /** Validate derivation ID is not a reserved derive method name */\n function validateDerivationId(id: string): void {\n if (RESERVED_DERIVE_NAMES.has(id)) {\n throw new Error(\n `[Directive] Derivation ID \"${id}\" conflicts with a reserved derive method name.`,\n );\n }\n }\n\n /** Per-type dispatch map — eliminates switch statements in apply* functions */\n const typeDescriptors: Record<DefType, TypeDescriptor> = {\n constraint: {\n label: \"Constraint\",\n mergedMap: mergedConstraints as Record<string, unknown>,\n // biome-ignore lint/suspicious/noExplicitAny: Manager type erasure for dispatch map\n manager: constraintsManager as any,\n dynamicSet: dynamicIds.constraints,\n originalsMap: originals.constraints,\n reconciles: true,\n },\n resolver: {\n label: \"Resolver\",\n mergedMap: mergedResolvers as Record<string, unknown>,\n // biome-ignore lint/suspicious/noExplicitAny: Manager type erasure for dispatch map\n manager: resolversManager as any,\n dynamicSet: dynamicIds.resolvers,\n originalsMap: originals.resolvers,\n reconciles: true,\n },\n derivation: {\n label: \"Derivation\",\n mergedMap: mergedDerive as Record<string, unknown>,\n // biome-ignore lint/suspicious/noExplicitAny: Manager type erasure for dispatch map\n manager: derivationsManager as any,\n dynamicSet: dynamicIds.derivations,\n originalsMap: originals.derivations,\n reconciles: false,\n validateId: validateDerivationId,\n },\n effect: {\n label: \"Effect\",\n mergedMap: mergedEffects as Record<string, unknown>,\n // biome-ignore lint/suspicious/noExplicitAny: Manager type erasure for dispatch map\n manager: effectsManager as any,\n dynamicSet: dynamicIds.effects,\n originalsMap: originals.effects,\n reconciles: false,\n },\n };\n\n /** Validate a definition ID for safety */\n function validateDefId(id: string): void {\n if (typeof id !== \"string\" || id.length === 0) {\n throw new Error(\n `[Directive] Definition ID must be a non-empty string. Received: ${String(id)}`,\n );\n }\n if (BLOCKED_PROPS.has(id)) {\n throw new Error(\n `[Directive] Security: Definition ID \"${id}\" is a blocked property.`,\n );\n }\n if (id.includes(\"::\")) {\n throw new Error(\n `[Directive] Definition ID \"${id}\" cannot contain \"::\". This separator is reserved for namespacing.`,\n );\n }\n }\n\n /** Apply a register operation immediately */\n function applyRegister(type: DefType, id: string, def: unknown): void {\n const desc = typeDescriptors[type];\n desc.validateId?.(id);\n\n if (id in desc.mergedMap) {\n throw new Error(\n `[Directive] ${desc.label} \"${id}\" already exists. Use assign() to override.`,\n );\n }\n\n desc.mergedMap[id] = def;\n desc.manager.registerDefinitions({ [id]: def });\n desc.dynamicSet.add(id);\n pluginManager.emitDefinitionRegister(type, id, def);\n\n if (desc.reconciles) {\n scheduleReconcile();\n }\n }\n\n /**\n * Apply an assign operation immediately.\n * Manager's assignDefinition() is called first (may validate/throw).\n * Only on success do we commit the original and update the merged map.\n */\n function applyAssign(type: DefType, id: string, def: unknown): void {\n const desc = typeDescriptors[type];\n desc.validateId?.(id);\n\n if (!(id in desc.mergedMap)) {\n throw new Error(\n `[Directive] ${desc.label} \"${id}\" does not exist. Use register() to create it.`,\n );\n }\n\n const original = desc.mergedMap[id];\n desc.manager.assignDefinition(id, def);\n desc.originalsMap.set(id, original);\n desc.mergedMap[id] = def;\n pluginManager.emitDefinitionAssign(type, id, def, original);\n\n if (desc.reconciles) {\n scheduleReconcile();\n }\n }\n\n /** Apply an unregister operation immediately */\n function applyUnregister(type: DefType, id: string): void {\n const desc = typeDescriptors[type];\n\n if (!desc.dynamicSet.has(id)) {\n if (process.env.NODE_ENV !== \"production\") {\n console.warn(\n `[Directive] Cannot unregister static ${type} \"${id}\". Only dynamically registered ${type}s can be removed.`,\n );\n }\n\n return;\n }\n\n desc.manager.unregisterDefinition(id);\n delete desc.mergedMap[id];\n desc.dynamicSet.delete(id);\n desc.originalsMap.delete(id);\n pluginManager.emitDefinitionUnregister(type, id);\n\n if (desc.reconciles) {\n scheduleReconcile();\n }\n }\n\n /** Flush deferred registrations after reconcile settles */\n function flushDeferred(): void {\n if (deferredRegistrations.length === 0) {\n return;\n }\n\n const ops = deferredRegistrations.splice(0);\n for (const op of ops) {\n try {\n switch (op.op) {\n case \"register\":\n applyRegister(op.type, op.id, op.def);\n break;\n case \"assign\":\n applyAssign(op.type, op.id, op.def);\n break;\n case \"unregister\":\n applyUnregister(op.type, op.id);\n break;\n }\n } catch (error) {\n if (process.env.NODE_ENV !== \"production\") {\n console.error(\n `[Directive] Error in deferred ${op.op} for ${op.type} \"${op.id}\":`,\n error,\n );\n }\n }\n }\n }\n\n /** Enforce deferral or destroyed guards, then delegate */\n function guardedOp(\n op: \"register\" | \"assign\" | \"unregister\",\n type: DefType,\n id: string,\n def?: unknown,\n ): void {\n const { isDestroyed, isReconciling } = getState();\n\n if (isDestroyed) {\n throw new Error(\n `[Directive] Cannot ${op} ${type} \"${id}\" on a destroyed system.`,\n );\n }\n\n validateDefId(id);\n\n if (isReconciling) {\n if (deferredRegistrations.length >= maxDeferredRegistrations) {\n throw new Error(\n `[Directive] Too many deferred registrations (max ${maxDeferredRegistrations}). Avoid calling register/assign/unregister in resolver or effect callbacks during reconciliation.`,\n );\n }\n if (op === \"unregister\") {\n deferredRegistrations.push({ op, type, id });\n } else {\n deferredRegistrations.push({ op, type, id, def: def! });\n }\n\n return;\n }\n\n switch (op) {\n case \"register\":\n applyRegister(type, id, def!);\n break;\n case \"assign\":\n applyAssign(type, id, def!);\n break;\n case \"unregister\":\n applyUnregister(type, id);\n break;\n }\n }\n\n return {\n register(type: DefType, id: string, def: unknown) {\n guardedOp(\"register\", type, id, def);\n },\n\n assign(type: DefType, id: string, def: unknown) {\n guardedOp(\"assign\", type, id, def);\n },\n\n unregister(type: DefType, id: string) {\n guardedOp(\"unregister\", type, id);\n },\n\n call(type: DefType, id: string, props?: unknown): unknown {\n const { isDestroyed } = getState();\n if (isDestroyed) {\n throw new Error(\n `[Directive] Cannot call ${type} \"${id}\" on a destroyed system.`,\n );\n }\n\n validateDefId(id);\n pluginManager.emitDefinitionCall(type, id, props);\n\n switch (type) {\n case \"constraint\":\n return constraintsManager.callOne(\n id,\n props as Record<string, unknown> | undefined,\n );\n case \"resolver\":\n return resolversManager.callOne(\n id,\n props as { type: string; [key: string]: unknown },\n );\n case \"derivation\":\n return derivationsManager.callOne(id);\n case \"effect\":\n return effectsManager.callOne(id);\n }\n },\n\n isDynamic(type: DefType, id: string): boolean {\n switch (type) {\n case \"constraint\":\n return dynamicIds.constraints.has(id);\n case \"resolver\":\n return dynamicIds.resolvers.has(id);\n case \"derivation\":\n return dynamicIds.derivations.has(id);\n case \"effect\":\n return dynamicIds.effects.has(id);\n }\n },\n\n listDynamic(type: DefType): string[] {\n switch (type) {\n case \"constraint\":\n return [...dynamicIds.constraints];\n case \"resolver\":\n return [...dynamicIds.resolvers];\n case \"derivation\":\n return [...dynamicIds.derivations];\n case \"effect\":\n return [...dynamicIds.effects];\n }\n },\n\n flushDeferred,\n\n getOriginal(type: DefType, id: string): unknown | undefined {\n const typeMap: Record<string, Map<string, unknown>> = {\n constraint: originals.constraints,\n resolver: originals.resolvers,\n derivation: originals.derivations,\n effect: originals.effects,\n };\n const map = typeMap[type];\n\n if (!map) {\n return undefined;\n }\n\n return map.get(id);\n },\n\n restoreOriginal(type: DefType, id: string): boolean {\n const typeMap: Record<string, Map<string, unknown>> = {\n constraint: originals.constraints,\n resolver: originals.resolvers,\n derivation: originals.derivations,\n effect: originals.effects,\n };\n const map = typeMap[type];\n\n if (!map || !map.has(id)) {\n return false;\n }\n\n const original = map.get(id);\n guardedOp(\"assign\", type, id, original);\n map.delete(id);\n\n return true;\n },\n\n destroy() {\n deferredRegistrations.length = 0;\n dynamicIds.constraints.clear();\n dynamicIds.resolvers.clear();\n dynamicIds.derivations.clear();\n dynamicIds.effects.clear();\n originals.constraints.clear();\n originals.resolvers.clear();\n originals.derivations.clear();\n originals.effects.clear();\n },\n };\n}\n","/**\n * Trace management for the engine reconciliation loop.\n *\n * Extracted from engine.ts to reduce file size. Owns all trace state:\n * ring buffer, per-run entries, resolver attribution maps, anomaly stats,\n * and the cached snapshot array.\n *\n * @internal\n */\n\nimport type { PluginManager } from \"./plugins.js\";\nimport type { Schema, TraceEntry } from \"./types.js\";\n\n// ============================================================================\n// TraceManager Interface\n// ============================================================================\n\n/**\n * Manages per-run reconciliation traces for the engine.\n *\n * @remarks\n * Each reconcile cycle starts a new trace entry that accumulates fact changes,\n * derivation recomputations, constraint hits, requirement diffs, resolver\n * starts/completions/errors, and effect runs. Entries stay \"pending\" while\n * resolvers are inflight and finalize to \"settled\" when all complete.\n *\n * The ring buffer caps at `maxRuns` entries with FIFO eviction. A cached\n * snapshot array avoids re-spreading on every `system.trace` read.\n *\n * @internal\n */\nexport interface TraceManager {\n /** Whether tracing is enabled */\n readonly enabled: boolean;\n\n /**\n * Record a fact change (queued until the next reconcile starts).\n *\n * @param key - The fact key that changed\n * @param oldValue - Previous value\n * @param newValue - New value\n */\n recordFactChange(key: string, oldValue: unknown, newValue: unknown): void;\n\n /**\n * Start a new trace entry for the current reconcile run.\n * Drains pending fact changes into the new entry.\n *\n * @returns The start timestamp (performance.now()) for duration calculation\n */\n startRun(): number;\n\n /** The current in-progress trace entry, or null between reconcile runs */\n currentTrace: TraceEntry | null;\n\n /**\n * Get the cached trace entries array (returns null when tracing is disabled).\n * Re-builds the cache only when the version counter has changed.\n */\n getEntries(): TraceEntry[] | null;\n\n /**\n * Attribute a resolver start to the current trace entry.\n *\n * @param requirementId - The requirement being resolved\n */\n attributeResolverStart(requirementId: string): void;\n\n /**\n * Record a resolver completion on its originating trace entry.\n *\n * @param requirementId - The requirement that was resolved\n * @param resolver - The resolver ID\n * @param duration - Resolution time in ms\n */\n recordResolverComplete(\n requirementId: string,\n resolver: string,\n duration: number,\n ): void;\n\n /**\n * Record a resolver error on its originating trace entry.\n *\n * @param requirementId - The requirement that errored\n * @param resolver - The resolver ID\n * @param error - The error (stringified)\n */\n recordResolverError(\n requirementId: string,\n resolver: string,\n error: string,\n ): void;\n\n /**\n * Decrement inflight count for the trace associated with a requirement.\n * Finalizes the trace entry when all resolvers have settled.\n *\n * @param requirementId - The requirement whose resolver settled\n */\n decrementInflight(requirementId: string): void;\n\n /**\n * Finalize the current trace entry at the end of a reconcile cycle.\n * Determines whether the entry has activity, pushes it to the ring buffer,\n * and either settles immediately or leaves it pending for inflight resolvers.\n *\n * @param reconcileStartMs - The performance.now() timestamp from startRun()\n */\n finalizeCurrentRun(reconcileStartMs: number): void;\n\n /**\n * Drain any pending fact changes (e.g., on reconcile depth overflow).\n */\n drainPendingChanges(): void;\n\n /**\n * Clean up all trace state.\n */\n destroy(): void;\n}\n\n// ============================================================================\n// TraceManager Implementation\n// ============================================================================\n\n/**\n * Options for creating a trace manager.\n *\n * @internal\n */\nexport interface CreateTraceManagerOptions<S extends Schema> {\n /** Trace config from system options (true, object, or falsy) */\n traceConfig: boolean | { maxRuns?: number } | undefined;\n /** Plugin manager for emitting trace lifecycle events */\n pluginManager: PluginManager<S>;\n}\n\n/**\n * Create a trace manager that handles reconciliation trace lifecycle.\n *\n * @remarks\n * When tracing is disabled, returns a no-op manager with zero overhead.\n * When enabled, maintains a ring buffer of trace entries with FIFO eviction,\n * resolver attribution maps, anomaly detection statistics, and a cached\n * snapshot array.\n *\n * @param options - Trace configuration and plugin manager\n * @returns A {@link TraceManager} instance\n *\n * @internal\n */\nexport function createTraceManager<S extends Schema>(\n options: CreateTraceManagerOptions<S>,\n): TraceManager {\n const { traceConfig, pluginManager } = options;\n const enabled =\n traceConfig === true ||\n (typeof traceConfig === \"object\" && traceConfig !== null);\n\n if (!enabled) {\n // Return a no-op manager\n return {\n enabled: false,\n recordFactChange() {},\n startRun() {\n return 0;\n },\n currentTrace: null,\n getEntries() {\n return null;\n },\n attributeResolverStart() {},\n recordResolverComplete() {},\n recordResolverError() {},\n decrementInflight() {},\n finalizeCurrentRun() {},\n drainPendingChanges() {},\n destroy() {},\n };\n }\n\n const maxRuns =\n (typeof traceConfig === \"object\" && traceConfig !== null\n ? traceConfig.maxRuns\n : undefined) ?? 100;\n\n const traceEntries: TraceEntry[] = [];\n const traceById = new Map<number, TraceEntry>();\n let traceIdCounter = 0;\n let currentTrace: TraceEntry | null = null;\n const pendingFactChanges: Array<{\n key: string;\n oldValue: unknown;\n newValue: unknown;\n }> = [];\n\n // Async resolver attribution: requirementId → traceId\n const resolverTraceMap = new Map<string, number>();\n // Track inflight resolvers per trace: traceId → count of pending resolvers\n const traceInflightCount = new Map<number, number>();\n // Consistent duration: track start time per trace (performance.now() based)\n const traceStartMs = new Map<number, number>();\n\n // Cached trace getter: avoid spread on every access\n let traceCache: TraceEntry[] | null = null;\n let traceCacheVersion = 0;\n let currentCacheVersion = 0;\n\n // Anomaly detection statistics\n const traceStats = {\n count: 0,\n totalDuration: 0,\n avgDuration: 0,\n maxDuration: 0,\n avgResolverCount: 0,\n totalResolverCount: 0,\n avgFactChangeCount: 0,\n totalFactChangeCount: 0,\n };\n\n /** Finalize a trace entry when all its resolvers have settled */\n function finalizeTrace(traceId: number): void {\n const entry = traceById.get(traceId);\n if (entry && entry.status === \"pending\") {\n entry.status = \"settled\";\n // Consistent duration: use performance.now() when available\n const startMs = traceStartMs.get(traceId);\n entry.duration =\n startMs !== undefined\n ? performance.now() - startMs\n : Date.now() - entry.timestamp;\n traceStartMs.delete(traceId);\n traceInflightCount.delete(traceId);\n // Build causal chain on settlement\n entry.causalChain = buildCausalChain(entry);\n // Anomaly detection\n updateTraceStats(entry);\n currentCacheVersion++;\n pluginManager.emitTraceComplete(entry);\n }\n }\n\n /** Decrement inflight count for a trace entry and finalize if settled */\n function decrementTraceInflightInternal(requirementId: string): void {\n const traceId = resolverTraceMap.get(requirementId);\n resolverTraceMap.delete(requirementId);\n if (traceId !== undefined) {\n const remaining = (traceInflightCount.get(traceId) ?? 1) - 1;\n if (remaining <= 0) {\n finalizeTrace(traceId);\n } else {\n traceInflightCount.set(traceId, remaining);\n }\n }\n }\n\n /** Evict the oldest trace entry from the ring buffer */\n function evictOldestTrace(): void {\n const evicted = traceEntries.shift();\n if (evicted) {\n traceById.delete(evicted.id);\n traceStartMs.delete(evicted.id);\n if (evicted.status === \"pending\") {\n traceInflightCount.delete(evicted.id);\n for (const [reqId, rId] of resolverTraceMap) {\n if (rId === evicted.id) {\n resolverTraceMap.delete(reqId);\n }\n }\n }\n }\n }\n\n /** Build a human-readable causal chain summary from a trace entry */\n function buildCausalChain(entry: TraceEntry): string {\n const parts: string[] = [];\n\n for (const fc of entry.factChanges) {\n parts.push(`${fc.key} changed`);\n }\n\n for (const d of entry.derivationsRecomputed) {\n parts.push(`${d.id} recomputed`);\n }\n\n for (const c of entry.constraintsHit) {\n parts.push(`${c.id} constraint hit`);\n }\n\n for (const r of entry.requirementsAdded) {\n parts.push(`${r.type} requirement added`);\n }\n\n for (const rs of entry.resolversCompleted) {\n parts.push(`${rs.resolver} resolved (${rs.duration.toFixed(0)}ms)`);\n }\n\n for (const rs of entry.resolversErrored) {\n parts.push(`${rs.resolver} errored`);\n }\n\n for (const e of entry.effectsRun) {\n parts.push(`${e.id} effect ran`);\n }\n\n return parts.join(\" → \");\n }\n\n /** Update running statistics and flag anomalies on a finalized trace entry */\n function updateTraceStats(entry: TraceEntry): void {\n traceStats.count++;\n traceStats.totalDuration += entry.duration;\n traceStats.avgDuration = traceStats.totalDuration / traceStats.count;\n if (entry.duration > traceStats.maxDuration) {\n traceStats.maxDuration = entry.duration;\n }\n\n const resolverCount = entry.resolversStarted.length;\n traceStats.totalResolverCount += resolverCount;\n traceStats.avgResolverCount =\n traceStats.totalResolverCount / traceStats.count;\n\n const factChangeCount = entry.factChanges.length;\n traceStats.totalFactChangeCount += factChangeCount;\n traceStats.avgFactChangeCount =\n traceStats.totalFactChangeCount / traceStats.count;\n\n // Flag anomalies (only after enough data)\n const anomalies: string[] = [];\n if (traceStats.count > 3 && entry.duration > traceStats.avgDuration * 5) {\n anomalies.push(\n `Duration ${entry.duration.toFixed(0)}ms is 5x+ above average (${traceStats.avgDuration.toFixed(0)}ms)`,\n );\n }\n\n if (entry.resolversErrored.length > 0) {\n anomalies.push(`${entry.resolversErrored.length} resolver(s) errored`);\n }\n\n if (anomalies.length > 0) {\n entry.anomalies = anomalies;\n }\n }\n\n /** Push a trace entry to the ring buffer with FIFO eviction */\n function pushTraceEntry(entry: TraceEntry): void {\n traceEntries.push(entry);\n traceById.set(entry.id, entry);\n if (traceEntries.length > maxRuns) {\n evictOldestTrace();\n }\n currentCacheVersion++;\n }\n\n /** Check if a trace entry has any recorded activity */\n function hasTraceActivity(entry: TraceEntry): boolean {\n return (\n entry.factChanges.length > 0 ||\n entry.constraintsHit.length > 0 ||\n entry.requirementsAdded.length > 0 ||\n entry.effectsRun.length > 0\n );\n }\n\n const manager: TraceManager = {\n enabled: true,\n\n get currentTrace() {\n return currentTrace;\n },\n set currentTrace(value: TraceEntry | null) {\n currentTrace = value;\n },\n\n recordFactChange(key: string, oldValue: unknown, newValue: unknown) {\n pendingFactChanges.push({ key, oldValue, newValue });\n },\n\n startRun(): number {\n const startMs = performance.now();\n const traceId = ++traceIdCounter;\n traceStartMs.set(traceId, startMs);\n currentTrace = {\n id: traceId,\n timestamp: Date.now(),\n duration: 0,\n status: \"pending\",\n factChanges: pendingFactChanges.splice(0), // move + clear\n derivationsRecomputed: [],\n constraintsHit: [],\n requirementsAdded: [],\n requirementsRemoved: [],\n resolversStarted: [],\n resolversCompleted: [],\n resolversErrored: [],\n effectsRun: [],\n effectErrors: [],\n };\n\n return startMs;\n },\n\n getEntries(): TraceEntry[] | null {\n if (!traceCache || traceCacheVersion !== currentCacheVersion) {\n traceCache = [...traceEntries];\n traceCacheVersion = currentCacheVersion;\n }\n\n return traceCache;\n },\n\n attributeResolverStart(requirementId: string) {\n if (currentTrace) {\n resolverTraceMap.set(requirementId, currentTrace.id);\n }\n },\n\n recordResolverComplete(\n requirementId: string,\n resolver: string,\n duration: number,\n ) {\n const traceId = resolverTraceMap.get(requirementId);\n if (traceId !== undefined) {\n const entry = traceById.get(traceId);\n if (entry) {\n entry.resolversCompleted.push({\n resolver,\n requirementId,\n duration,\n });\n }\n }\n },\n\n recordResolverError(\n requirementId: string,\n resolver: string,\n error: string,\n ) {\n const traceId = resolverTraceMap.get(requirementId);\n if (traceId !== undefined) {\n const entry = traceById.get(traceId);\n if (entry) {\n entry.resolversErrored.push({\n resolver,\n requirementId,\n error,\n });\n }\n }\n },\n\n decrementInflight(requirementId: string) {\n decrementTraceInflightInternal(requirementId);\n },\n\n finalizeCurrentRun(reconcileStartMs: number) {\n if (!currentTrace) {\n return;\n }\n\n currentTrace.duration = performance.now() - reconcileStartMs;\n\n if (!hasTraceActivity(currentTrace)) {\n // Empty trace entry — clean up start time\n traceStartMs.delete(currentTrace.id);\n currentTrace = null;\n\n return;\n }\n\n const inflightCount = currentTrace.resolversStarted.length;\n if (inflightCount === 0) {\n // No resolvers — finalize immediately\n currentTrace.status = \"settled\";\n currentTrace.causalChain = buildCausalChain(currentTrace);\n updateTraceStats(currentTrace);\n pushTraceEntry(currentTrace);\n pluginManager.emitTraceComplete(currentTrace);\n } else {\n // Has resolvers — stays pending until they settle\n currentTrace.status = \"pending\";\n pushTraceEntry(currentTrace);\n traceInflightCount.set(currentTrace.id, inflightCount);\n }\n\n currentTrace = null;\n },\n\n drainPendingChanges() {\n pendingFactChanges.length = 0;\n },\n\n destroy() {\n traceEntries.length = 0;\n traceById.clear();\n resolverTraceMap.clear();\n traceInflightCount.clear();\n traceStartMs.clear();\n pendingFactChanges.length = 0;\n currentTrace = null;\n traceCache = null;\n },\n };\n\n return manager;\n}\n","/**\n * Engine - The core reconciliation loop\n *\n * The engine orchestrates:\n * 1. Fact changes trigger reconciliation\n * 2. Constraints produce requirements\n * 3. Resolvers fulfill requirements\n * 4. Effects run after stabilization\n * 5. Derivations are invalidated and recomputed\n */\n\nimport {\n type HistoryManager,\n createDisabledHistory,\n createHistoryManager,\n} from \"../utils/history.js\";\nimport { hashObject, isPrototypeSafe } from \"../utils/utils.js\";\nimport {\n type ConstraintsManager,\n createConstraintsManager,\n} from \"./constraints.js\";\nimport {\n type DerivationsManager,\n createDerivationsManager,\n} from \"./derivations.js\";\nimport { type EffectsManager, createEffectsManager } from \"./effects.js\";\nimport {\n createDeriveAccessor,\n createEventsAccessor,\n} from \"./engine-accessors.js\";\nimport { createDefinitionsRegistry } from \"./engine-definitions.js\";\nimport { createTraceManager } from \"./engine-trace.js\";\nimport {\n type ErrorBoundaryManager,\n createErrorBoundaryManager,\n} from \"./errors.js\";\nimport { createFacts } from \"./facts.js\";\nimport { type PluginManager, createPluginManager } from \"./plugins.js\";\nimport { RequirementSet } from \"./requirements.js\";\nimport { type ResolversManager, createResolversManager } from \"./resolvers.js\";\nimport { BLOCKED_PROPS } from \"./tracking.js\";\nimport type {\n ConstraintsDef,\n DerivationsDef,\n EffectsDef,\n EventsDef,\n FactsSnapshot,\n InferSchema,\n ReconcileResult,\n RequirementKeyFn,\n ResolversDef,\n Schema,\n System,\n SystemConfig,\n SystemEvent,\n SystemInspection,\n TraceEntry,\n} from \"./types.js\";\n\n// ============================================================================\n// Engine Implementation\n// ============================================================================\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ninterface EngineState<_S extends Schema> {\n isRunning: boolean;\n isReconciling: boolean;\n reconcileScheduled: boolean;\n isInitializing: boolean;\n isInitialized: boolean;\n isReady: boolean;\n isDestroyed: boolean;\n changedKeys: Set<string>;\n previousRequirements: RequirementSet;\n readyPromise: Promise<void> | null;\n readyResolve: (() => void) | null;\n}\n\n/**\n * Create the core Directive reconciliation engine that wires facts, derivations,\n * effects, constraints, resolvers, plugins, error boundaries, and history\n * into a single reactive system.\n *\n * @remarks\n * This is the internal factory used by {@link createSystem}. Most users should\n * call `createSystem` instead, which provides a friendlier API and handles\n * module composition.\n *\n * @param config - Full system configuration including modules, plugins, error boundary settings, and debug options\n * @returns A {@link System} instance with facts, derive, events, dispatch, subscribe, watch, settle, and lifecycle methods\n *\n * @example\n * ```ts\n * // Prefer createSystem for most use cases:\n * import { createSystem, createModule, t } from \"@directive-run/core\";\n *\n * const counter = createModule(\"counter\", {\n * schema: { count: t.number() },\n * init: (facts) => { facts.count = 0; },\n * });\n *\n * const system = createSystem({ module: counter });\n * system.start();\n * system.facts.count = 42;\n * ```\n *\n * @internal\n */\n// biome-ignore lint/suspicious/noExplicitAny: Engine uses flat schema internally, public API uses ModuleSchema\nexport function createEngine<S extends Schema>(\n config: SystemConfig<any>,\n): System<any> {\n // Merge all module definitions with collision detection\n // Use Object.create(null) to prevent prototype chain traversal (e.g., \"toString\" in mergedEvents)\n const mergedSchema = Object.create(null) as S;\n const mergedEvents: EventsDef<S> = Object.create(null);\n const mergedDerive: DerivationsDef<S> = Object.create(null);\n const mergedEffects: EffectsDef<S> = Object.create(null);\n const mergedConstraints: ConstraintsDef<S> = Object.create(null);\n const mergedResolvers: ResolversDef<S> = Object.create(null);\n\n // Track which module defined each key for collision detection\n const schemaOwners = new Map<string, string>();\n const definitionOwners = new Map<string, string>();\n\n for (const module of config.modules) {\n // Security: Validate module definitions for dangerous keys\n // Always run in all environments — this is a security boundary, not a dev convenience\n const validateKeys = (obj: object | undefined, section: string) => {\n if (!obj) return;\n for (const key of Object.keys(obj)) {\n if (BLOCKED_PROPS.has(key)) {\n throw new Error(\n `[Directive] Security: Module \"${module.id}\" has dangerous key \"${key}\" in ${section}. ` +\n \"This could indicate a prototype pollution attempt.\",\n );\n }\n if (section === \"schema\" && key.startsWith(\"$\")) {\n throw new Error(\n `[Directive] Module \"${module.id}\" has schema key \"${key}\" starting with \"$\". ` +\n \"Keys starting with $ are reserved for internal accessors ($store, $snapshot).\",\n );\n }\n }\n };\n validateKeys(module.schema, \"schema\");\n validateKeys(module.events, \"events\");\n validateKeys(module.derive, \"derive\");\n validateKeys(module.effects, \"effects\");\n validateKeys(module.constraints, \"constraints\");\n validateKeys(module.resolvers, \"resolvers\");\n\n // Check for schema collisions (unconditional — data integrity, not dev convenience)\n for (const key of Object.keys(module.schema)) {\n const existingOwner = schemaOwners.get(key);\n if (existingOwner) {\n throw new Error(\n `[Directive] Schema collision: Fact \"${key}\" is defined in both module \"${existingOwner}\" and \"${module.id}\". ` +\n `Use namespacing (e.g., \"${module.id}::${key}\") or merge into one module.`,\n );\n }\n schemaOwners.set(key, module.id);\n }\n\n // Check for definition collisions across modules (derive, effects, constraints, resolvers)\n const checkCollisions = (obj: object | undefined, section: string) => {\n if (!obj) {\n return;\n }\n for (const key of Object.keys(obj)) {\n const owner = definitionOwners.get(key);\n if (owner && owner !== module.id) {\n throw new Error(\n `[Directive] Definition collision: ${section} \"${key}\" is defined in both module \"${owner}\" and \"${module.id}\". ` +\n \"Use namespacing or rename to avoid conflicts.\",\n );\n }\n definitionOwners.set(key, module.id);\n }\n };\n checkCollisions(module.derive, \"derivation\");\n checkCollisions(module.effects, \"effect\");\n checkCollisions(module.constraints, \"constraint\");\n checkCollisions(module.resolvers, \"resolver\");\n checkCollisions(module.events, \"event\");\n\n Object.assign(mergedSchema, module.schema);\n if (module.events) Object.assign(mergedEvents, module.events);\n if (module.derive) Object.assign(mergedDerive, module.derive);\n if (module.effects) Object.assign(mergedEffects, module.effects);\n if (module.constraints)\n Object.assign(mergedConstraints, module.constraints);\n if (module.resolvers) Object.assign(mergedResolvers, module.resolvers);\n }\n\n // Build snapshotEventNames: Set<string> | null\n // If any module declares history.snapshotEvents, build the filter set.\n // Modules WITHOUT history.snapshotEvents have all their events added (they still snapshot).\n let snapshotEventNames: Set<string> | null = null;\n // biome-ignore lint/suspicious/noExplicitAny: Module may have history.snapshotEvents at runtime\n const hasAnySnapshotEvents = config.modules.some(\n (m: any) => m.history?.snapshotEvents,\n );\n if (hasAnySnapshotEvents) {\n snapshotEventNames = new Set<string>();\n for (const module of config.modules) {\n // biome-ignore lint/suspicious/noExplicitAny: Module may have history.snapshotEvents at runtime\n const mod = module as any;\n if (mod.history?.snapshotEvents) {\n for (const eventName of mod.history.snapshotEvents) {\n snapshotEventNames.add(eventName);\n }\n } else if (mod.events) {\n // No filter — all events from this module create snapshots\n for (const eventName of Object.keys(mod.events)) {\n snapshotEventNames.add(eventName);\n }\n }\n }\n }\n\n // Snapshot intent flags — track whether the current change batch should create a snapshot\n let dispatchDepth = 0;\n let shouldTakeSnapshot = false;\n\n // Dev-mode: Warn if a fact and derivation share the same name\n if (process.env.NODE_ENV !== \"production\") {\n const derivationNames = new Set(Object.keys(mergedDerive));\n for (const key of Object.keys(mergedSchema)) {\n if (derivationNames.has(key)) {\n console.warn(\n `[Directive] \"${key}\" exists as both a fact and a derivation. ` +\n \"This may cause unexpected dependency tracking behavior.\",\n );\n }\n }\n }\n\n // Create plugin manager\n const pluginManager: PluginManager<S> = createPluginManager();\n for (const plugin of config.plugins ?? []) {\n pluginManager.register(plugin);\n }\n\n // Create error boundary\n const errorBoundary: ErrorBoundaryManager = createErrorBoundaryManager({\n config: config.errorBoundary,\n onError: (error) => pluginManager.emitError(error),\n onRecovery: (error, strategy) =>\n pluginManager.emitErrorRecovery(error, strategy),\n });\n\n // Retry-later polling timer\n let retryLaterTimer: ReturnType<typeof setInterval> | null = null;\n\n // Create facts store and proxy\n // Note: We need to create a local invalidate function that will be set after derivationsManager is created\n let invalidateDerivation: (key: string) => void = () => {};\n let invalidateManyDerivations: (keys: string[]) => void = () => {};\n\n // Forward-declared so onChange/onBatch closures can check isRestoring.\n // Assigned after createHistoryManager() below.\n let historyRef: HistoryManager<S> | null = null;\n\n // Trace management (per-run reconciliation changelog, gated by config.trace)\n const traceManager = createTraceManager({\n traceConfig: config.trace,\n pluginManager,\n });\n const traceEnabled = traceManager.enabled;\n\n const { store, facts } = createFacts<S>({\n schema: mergedSchema,\n onChange: (key, value, prev) => {\n pluginManager.emitFactSet(key, value, prev);\n // Invalidate derivations so they recompute on read\n invalidateDerivation(key);\n // Track fact changes for trace\n if (traceEnabled) {\n traceManager.recordFactChange(String(key), prev, value);\n }\n // During history restore, skip change tracking and reconciliation.\n // The restored state is already reconciled; re-reconciling would create\n // spurious snapshots that break undo/redo.\n if (historyRef?.isRestoring) return;\n // Direct fact mutations (outside event dispatch) always create snapshots\n if (dispatchDepth === 0) {\n shouldTakeSnapshot = true;\n }\n state.changedKeys.add(key);\n scheduleReconcile();\n },\n onBatch: (changes) => {\n pluginManager.emitFactsBatch(changes);\n const keys: string[] = [];\n for (const change of changes) {\n keys.push(change.key);\n }\n // Track fact changes for trace\n if (traceEnabled) {\n for (const change of changes) {\n traceManager.recordFactChange(\n change.key,\n change.prev,\n change.type === \"delete\" ? undefined : change.value,\n );\n }\n }\n // Invalidate all affected derivations at once — listeners fire only\n // after ALL keys are invalidated, so they see consistent state.\n invalidateManyDerivations(keys);\n // During history restore, skip change tracking and reconciliation.\n if (historyRef?.isRestoring) return;\n // Resolver/effect batches (outside event dispatch) always create snapshots\n if (dispatchDepth === 0) {\n shouldTakeSnapshot = true;\n }\n for (const change of changes) {\n state.changedKeys.add(change.key);\n }\n scheduleReconcile();\n },\n });\n\n // Create derivations manager\n const derivationsManager: DerivationsManager<\n S,\n DerivationsDef<S>\n > = createDerivationsManager({\n definitions: mergedDerive,\n facts,\n onCompute: (id, value, oldValue, deps) => {\n pluginManager.emitDerivationCompute(id, value, deps);\n if (traceManager.currentTrace) {\n traceManager.currentTrace.derivationsRecomputed.push({\n id,\n deps: deps ? [...deps] : [],\n oldValue,\n newValue: value,\n });\n }\n },\n onInvalidate: (id) => pluginManager.emitDerivationInvalidate(id),\n onError: (id, error) => {\n const strategy = errorBoundary.handleError(\"derivation\", id, error);\n\n if (strategy === \"retry\") {\n derivationsManager.invalidate(id);\n }\n },\n });\n\n // Now wire up derivation invalidation\n invalidateDerivation = (key: string) => derivationsManager.invalidate(key);\n invalidateManyDerivations = (keys: string[]) =>\n derivationsManager.invalidateMany(keys);\n\n // Create effects manager\n const effectsManager: EffectsManager<S> = createEffectsManager({\n definitions: mergedEffects,\n facts,\n store,\n onRun: (id, deps) => {\n pluginManager.emitEffectRun(id);\n if (traceManager.currentTrace) {\n traceManager.currentTrace.effectsRun.push({\n id,\n triggeredBy: deps,\n });\n }\n },\n onError: (id, error) => {\n const strategy = errorBoundary.handleError(\"effect\", id, error);\n pluginManager.emitEffectError(id, error);\n\n if (traceManager.currentTrace) {\n traceManager.currentTrace.effectErrors.push({\n id,\n error: String(error),\n });\n }\n\n if (strategy === \"disable\") {\n effectsManager.disable(id);\n }\n\n if (strategy === \"retry\") {\n state.changedKeys.add(\"*\");\n scheduleReconcile();\n }\n },\n });\n\n // Extract resolver key functions keyed by requirement type.\n // Resolvers with a string `requirement` and a `key` function contribute\n // to requirement deduplication inside the constraints manager.\n const requirementKeys: Record<string, RequirementKeyFn> = Object.create(null);\n for (const def of Object.values(mergedResolvers)) {\n if (\n def.key &&\n typeof def.requirement === \"string\"\n ) {\n requirementKeys[def.requirement] = def.key;\n }\n }\n\n // Create constraints manager\n const constraintsManager: ConstraintsManager<S> = createConstraintsManager({\n definitions: mergedConstraints,\n facts,\n requirementKeys,\n onEvaluate: (id, active) =>\n pluginManager.emitConstraintEvaluate(id, active),\n onError: (id, error) => {\n const strategy = errorBoundary.handleError(\"constraint\", id, error);\n pluginManager.emitConstraintError(id, error);\n\n if (strategy === \"disable\") {\n constraintsManager.disable(id);\n }\n },\n });\n\n /** Sync resolver key functions into the constraints manager */\n function syncResolverKeys(defs: ResolversDef<S>): void {\n for (const def of Object.values(defs)) {\n if (def.key && typeof def.requirement === \"string\") {\n constraintsManager.setRequirementKey(def.requirement, def.key);\n }\n }\n }\n\n // Create resolvers manager\n const resolversManager: ResolversManager<S> = createResolversManager({\n definitions: mergedResolvers,\n facts,\n store,\n onStart: (resolver, req) => pluginManager.emitResolverStart(resolver, req),\n onComplete: (resolver, req, duration) => {\n errorBoundary.clearRetryAttempts(resolver);\n pluginManager.emitResolverComplete(resolver, req, duration);\n pluginManager.emitRequirementMet(req, resolver);\n // Mark the constraint as resolved for `after` ordering\n constraintsManager.markResolved(req.fromConstraint);\n // Attribute to the trace entry that started this resolver\n if (traceEnabled) {\n traceManager.recordResolverComplete(req.id, resolver, duration);\n traceManager.decrementInflight(req.id);\n }\n },\n onError: (resolver, req, error) => {\n const strategy = errorBoundary.handleError(\n \"resolver\",\n resolver,\n error,\n req,\n );\n pluginManager.emitResolverError(resolver, req, error);\n\n if (strategy === \"disable\") {\n constraintsManager.disable(req.fromConstraint);\n }\n\n if (strategy === \"retry\") {\n // Remove from previousRequirements so the diff sees it as \"added\" again\n state.previousRequirements.remove(req.id);\n scheduleReconcile();\n }\n\n if (strategy === \"retry-later\") {\n const pending = errorBoundary\n .getRetryLaterManager()\n .getPendingRetries();\n const entry = pending.find((p) => p.sourceId === resolver);\n\n if (entry && !entry.callback) {\n entry.callback = () => {\n scheduleReconcile();\n };\n }\n }\n\n // Attribute error to the trace entry that started this resolver\n if (traceEnabled) {\n traceManager.recordResolverError(req.id, resolver, String(error));\n traceManager.decrementInflight(req.id);\n }\n },\n onRetry: (resolver, req, attempt) =>\n pluginManager.emitResolverRetry(resolver, req, attempt),\n onCancel: (resolver, req) => {\n pluginManager.emitResolverCancel(resolver, req);\n pluginManager.emitRequirementCanceled(req);\n // Decrement inflight for the trace entry\n if (traceEnabled) {\n traceManager.decrementInflight(req.id);\n }\n },\n onResolutionComplete: () => {\n // After a resolver completes, schedule another reconcile\n notifySettlementChange();\n scheduleReconcile();\n },\n });\n\n // History listeners — notified when snapshot state changes\n const historyListeners = new Set<() => void>();\n\n function notifyHistoryChange(): void {\n for (const listener of historyListeners) {\n listener();\n }\n }\n\n // Create history manager\n const historyManager: HistoryManager<S> = config.history\n ? createHistoryManager({\n historyOption: config.history,\n facts,\n store,\n onSnapshot: (snapshot) => {\n pluginManager.emitSnapshot(snapshot);\n notifyHistoryChange();\n },\n onHistoryChange: (from, to) => {\n pluginManager.emitHistoryNavigate(from, to);\n notifyHistoryChange();\n },\n })\n : createDisabledHistory();\n historyRef = historyManager;\n\n // Settlement listeners — notified when isSettled may have changed\n const settlementListeners = new Set<() => void>();\n\n function notifySettlementChange(): void {\n for (const listener of settlementListeners) {\n listener();\n }\n }\n\n // Reconcile depth guard — prevents runaway reconcile → scheduleReconcile chains\n const MAX_RECONCILE_DEPTH = 50;\n const MAX_DEFERRED_REGISTRATIONS = 100;\n let reconcileDepth = 0;\n\n // Engine state\n const state: EngineState<S> = {\n isRunning: false,\n isReconciling: false,\n reconcileScheduled: false,\n isInitializing: false,\n isInitialized: false,\n isReady: false,\n isDestroyed: false,\n changedKeys: new Set(),\n previousRequirements: new RequirementSet(),\n readyPromise: null,\n readyResolve: null,\n };\n\n // Dynamic definition registry (register, assign, unregister, call)\n const definitions = createDefinitionsRegistry({\n mergedConstraints,\n mergedResolvers,\n mergedDerive,\n mergedEffects,\n constraintsManager,\n resolversManager,\n derivationsManager,\n effectsManager,\n pluginManager,\n getState: () => state,\n scheduleReconcile,\n maxDeferredRegistrations: MAX_DEFERRED_REGISTRATIONS,\n });\n\n /** Schedule a reconciliation on the next microtask */\n function scheduleReconcile(): void {\n // Suppress reconciliation during initialization phase\n if (!state.isRunning || state.reconcileScheduled || state.isInitializing)\n return;\n\n state.reconcileScheduled = true;\n notifySettlementChange();\n queueMicrotask(() => {\n state.reconcileScheduled = false;\n if (state.isRunning && !state.isInitializing) {\n // Await reconcile to prevent race conditions\n // Error is caught inside reconcile, so no need to handle here\n reconcile().catch((error) => {\n // Only log unexpected errors (reconcile handles its own errors)\n if (process.env.NODE_ENV !== \"production\") {\n console.error(\"[Directive] Unexpected error in reconcile:\", error);\n }\n });\n }\n });\n }\n\n /** The main reconciliation loop */\n async function reconcile(): Promise<void> {\n if (state.isReconciling) return;\n\n reconcileDepth++;\n if (reconcileDepth > MAX_RECONCILE_DEPTH) {\n if (process.env.NODE_ENV !== \"production\") {\n console.warn(\n `[Directive] Reconcile loop exceeded ${MAX_RECONCILE_DEPTH} iterations. ` +\n \"This usually means resolvers are creating circular requirement chains. \" +\n `Check that resolvers aren't mutating facts that re-trigger their own constraints.`,\n );\n }\n // Drain pending fact changes so they don't leak into the next trace entry (M4)\n if (traceEnabled) {\n traceManager.drainPendingChanges();\n }\n // Clear previous requirements so the next reconcile treats all\n // requirements as \"added\" and re-dispatches them to resolvers.\n // This recovers from situations where reconcile crashed (e.g.,\n // structuredClone failure) and left requirements stuck.\n state.previousRequirements = new RequirementSet();\n reconcileDepth = 0;\n return;\n }\n\n state.isReconciling = true;\n notifySettlementChange();\n\n const reconcileStartMs = traceEnabled ? traceManager.startRun() : 0;\n const currentTrace = traceManager.currentTrace;\n\n try {\n // Take snapshot before reconciliation (respects snapshotEvents filtering)\n if (state.changedKeys.size > 0) {\n if (snapshotEventNames === null || shouldTakeSnapshot) {\n const keys = state.changedKeys;\n const label =\n keys.size <= 5\n ? `facts-changed:${[...keys].join(\",\")}`\n : `facts-changed:${[...keys].slice(0, 5).join(\",\")}+${keys.size - 5}more`;\n historyManager.takeSnapshot(label);\n }\n shouldTakeSnapshot = false;\n }\n\n // Get snapshot for plugins\n const snapshot = facts.$snapshot() as FactsSnapshot<S>;\n pluginManager.emitReconcileStart(snapshot);\n\n // Note: Derivations are already invalidated immediately when facts change\n // (in the onChange/onBatch callbacks), so we don't need to do it here\n\n // Run effects for changed keys\n await effectsManager.runEffects(state.changedKeys);\n\n // Copy changed keys for constraint evaluation before clearing\n const keysForConstraints = new Set(state.changedKeys);\n\n // Clear changed keys\n state.changedKeys.clear();\n\n // Evaluate constraints (pass changed keys for incremental evaluation)\n const currentRequirements =\n await constraintsManager.evaluate(keysForConstraints);\n const currentSet = new RequirementSet();\n for (const req of currentRequirements) {\n currentSet.add(req);\n pluginManager.emitRequirementCreated(req);\n }\n\n // Capture which constraints produced requirements for trace\n if (currentTrace) {\n const hitConstraintIds = new Set(\n currentRequirements.map((r) => r.fromConstraint),\n );\n for (const cId of hitConstraintIds) {\n const cState = constraintsManager.getState(cId);\n if (cState) {\n const cDeps = constraintsManager.getDependencies(cId);\n currentTrace.constraintsHit.push({\n id: cId,\n priority: cState.priority,\n deps: cDeps ? [...cDeps] : [],\n });\n }\n }\n }\n\n // Diff with previous requirements\n const { added, removed } = currentSet.diff(state.previousRequirements);\n\n // Capture requirement diff for trace\n if (currentTrace) {\n for (const req of added) {\n currentTrace.requirementsAdded.push({\n id: req.id,\n type: req.requirement.type,\n fromConstraint: req.fromConstraint,\n });\n }\n for (const req of removed) {\n currentTrace.requirementsRemoved.push({\n id: req.id,\n type: req.requirement.type,\n fromConstraint: req.fromConstraint,\n });\n }\n }\n\n // Cancel resolvers for removed requirements\n for (const req of removed) {\n resolversManager.cancel(req.id);\n }\n\n // Start resolvers for new requirements\n for (const req of added) {\n resolversManager.resolve(req);\n }\n\n // Capture resolver starts for trace\n if (currentTrace) {\n const inflightNow = resolversManager.getInflightInfo();\n // Build Map for O(1) lookups instead of O(n) find per requirement\n const inflightById = new Map(inflightNow.map((i) => [i.id, i]));\n for (const req of added) {\n const info = inflightById.get(req.id);\n currentTrace.resolversStarted.push({\n resolver: info?.resolverId ?? \"unknown\",\n requirementId: req.id,\n });\n // Track attribution for async completion\n traceManager.attributeResolverStart(req.id);\n }\n }\n\n // Update previous requirements\n state.previousRequirements = currentSet;\n\n // Build reconcile result (only if plugins are listening)\n const inflightInfo = resolversManager.getInflightInfo();\n if (config.plugins && config.plugins.length > 0) {\n // Build Map for O(1) lookups on canceled requirements\n const inflightMap =\n removed.length > 0\n ? new Map(inflightInfo.map((i) => [i.id, i.resolverId]))\n : undefined;\n const result: ReconcileResult = {\n unmet: currentRequirements.filter(\n (r) => !resolversManager.isResolving(r.id),\n ),\n inflight: inflightInfo,\n completed: [], // Completed resolvers are tracked separately via onComplete callback\n canceled: removed.map((r) => ({\n id: r.id,\n resolverId: inflightMap?.get(r.id) ?? \"unknown\",\n })),\n };\n pluginManager.emitReconcileEnd(result);\n }\n\n // Mark system as ready after first successful reconcile\n if (!state.isReady) {\n state.isReady = true;\n if (state.readyResolve) {\n state.readyResolve();\n state.readyResolve = null;\n }\n }\n } finally {\n // Finalize the current trace entry\n if (traceEnabled) {\n traceManager.finalizeCurrentRun(reconcileStartMs);\n }\n\n state.isReconciling = false;\n\n // Flush any deferred dynamic definition operations that were queued\n // during this reconciliation cycle\n definitions.flushDeferred();\n\n // Schedule next reconcile BEFORE notifying settlement change,\n // so listeners never see a brief isSettled=true flash when\n // more changes are pending.\n // Reset depth counter at the end of each top-level reconcile.\n // Previously only reset on full settlement, which allowed depth\n // to climb toward MAX in long-running systems with continuous changes.\n reconcileDepth = 0;\n\n if (state.changedKeys.size > 0) {\n scheduleReconcile();\n }\n\n notifySettlementChange();\n }\n }\n\n /** Dispatch an event by name, handling snapshot flags and batching */\n function dispatchEventByName(\n eventName: string,\n payload?: Record<string, unknown>,\n ): void {\n const handler = mergedEvents[eventName];\n if (handler) {\n dispatchDepth++;\n if (snapshotEventNames === null || snapshotEventNames.has(eventName)) {\n shouldTakeSnapshot = true;\n }\n try {\n store.batch(() => {\n handler(facts, { type: eventName, ...payload });\n });\n } finally {\n dispatchDepth--;\n }\n } else if (process.env.NODE_ENV !== \"production\") {\n console.warn(\n `[Directive] Unknown event type \"${eventName}\". ` +\n \"No handler is registered for this event. \" +\n `Available events: ${Object.keys(mergedEvents).join(\", \") || \"(none)\"}`,\n );\n }\n }\n\n // Create typed derive accessor using a Proxy\n const deriveAccessor = createDeriveAccessor({\n mergedDerive: mergedDerive as Record<string, unknown>,\n getDerivation: (key) =>\n derivationsManager.get(key as keyof DerivationsDef<S>),\n definitions,\n });\n\n // Create typed events accessor using a Proxy\n const eventsAccessor = createEventsAccessor({\n mergedEvents: mergedEvents as Record<string, unknown>,\n dispatchEvent: dispatchEventByName,\n });\n\n // Create the system interface\n // biome-ignore lint/suspicious/noExplicitAny: Engine uses flat schema internally, public API uses ModuleSchema\n const system: System<any> = {\n facts,\n history: historyManager.isEnabled ? historyManager : null,\n // biome-ignore lint/suspicious/noExplicitAny: Proxy provides both derivation values and control methods at runtime\n derive: deriveAccessor as any,\n events: eventsAccessor,\n constraints: {\n disable: (id: string) => constraintsManager.disable(id),\n enable: (id: string) => constraintsManager.enable(id),\n isDisabled: (id: string) => constraintsManager.isDisabled(id),\n // biome-ignore lint/suspicious/noExplicitAny: Runtime accepts any constraint def shape\n register: (id: string, def: any) => {\n definitions.register(\"constraint\", id, def);\n },\n // biome-ignore lint/suspicious/noExplicitAny: Runtime accepts any constraint def shape\n assign: (id: string, def: any) => {\n definitions.assign(\"constraint\", id, def);\n },\n unregister: (id: string) => {\n definitions.unregister(\"constraint\", id);\n },\n call: (id: string, props?: Record<string, unknown>) =>\n definitions.call(\"constraint\", id, props) as Promise<\n Record<string, unknown>[]\n >,\n isDynamic: (id: string) => definitions.isDynamic(\"constraint\", id),\n listDynamic: () => definitions.listDynamic(\"constraint\"),\n },\n effects: {\n disable: (id: string) => effectsManager.disable(id),\n enable: (id: string) => effectsManager.enable(id),\n isEnabled: (id: string) => effectsManager.isEnabled(id),\n // biome-ignore lint/suspicious/noExplicitAny: Runtime accepts any effect def shape\n register: (id: string, def: any) => {\n definitions.register(\"effect\", id, def);\n },\n // biome-ignore lint/suspicious/noExplicitAny: Runtime accepts any effect def shape\n assign: (id: string, def: any) => {\n definitions.assign(\"effect\", id, def);\n },\n unregister: (id: string) => {\n definitions.unregister(\"effect\", id);\n },\n call: (id: string) => definitions.call(\"effect\", id) as Promise<void>,\n isDynamic: (id: string) => definitions.isDynamic(\"effect\", id),\n listDynamic: () => definitions.listDynamic(\"effect\"),\n },\n resolvers: {\n // biome-ignore lint/suspicious/noExplicitAny: Runtime accepts any resolver def shape\n register: (id: string, def: any) => {\n definitions.register(\"resolver\", id, def);\n syncResolverKeys({ [id]: def } as ResolversDef<S>);\n },\n // biome-ignore lint/suspicious/noExplicitAny: Runtime accepts any resolver def shape\n assign: (id: string, def: any) => {\n definitions.assign(\"resolver\", id, def);\n syncResolverKeys({ [id]: def } as ResolversDef<S>);\n },\n unregister: (id: string) => {\n // Remove the key function before unregistering\n const def = mergedResolvers[id];\n if (def?.key && typeof def.requirement === \"string\") {\n constraintsManager.removeRequirementKey(def.requirement);\n }\n definitions.unregister(\"resolver\", id);\n },\n call: (\n id: string,\n requirement: { type: string; [key: string]: unknown },\n ) => definitions.call(\"resolver\", id, requirement) as Promise<void>,\n isDynamic: (id: string) => definitions.isDynamic(\"resolver\", id),\n listDynamic: () => definitions.listDynamic(\"resolver\"),\n },\n\n get trace(): TraceEntry[] | null {\n return traceManager.getEntries();\n },\n\n initialize(): void {\n if (state.isInitialized) return;\n state.isInitializing = true;\n\n // Run module init functions (sets initial fact values)\n for (const module of config.modules) {\n if (module.init) {\n store.batch(() => {\n // biome-ignore lint/suspicious/noExplicitAny: Engine internal type coercion\n module.init!(facts as any);\n });\n }\n }\n\n // Apply initialFacts/hydrate via callback\n // This ensures initialFacts are applied AFTER module init but BEFORE reconcile\n if (config.onAfterModuleInit) {\n store.batch(() => {\n config.onAfterModuleInit!();\n });\n }\n\n state.isInitializing = false;\n state.isInitialized = true;\n\n // Eagerly compute all derivations so they're cached before any\n // external read (e.g. React's useSyncExternalStore). Without this,\n // derivations can evaluate against uninitialized facts.\n for (const id of Object.keys(mergedDerive)) {\n derivationsManager.get(id as keyof DerivationsDef<S>);\n }\n },\n\n start(): void {\n if (state.isRunning) return;\n\n // Ensure facts are initialized (no-op if already called)\n if (!state.isInitialized) {\n this.initialize();\n }\n\n state.isRunning = true;\n\n // Module onStart hooks (may access browser APIs — only in start())\n for (const module of config.modules) {\n // biome-ignore lint/suspicious/noExplicitAny: Engine internal type coercion\n module.hooks?.onStart?.(system as any);\n }\n\n // Emit start event\n pluginManager.emitStart(system);\n\n // Start retry-later polling timer if configured\n if (config.errorBoundary?.retryLater && !retryLaterTimer) {\n const intervalMs = Math.max(\n config.errorBoundary.retryLater.delayMs ?? 1000,\n 250,\n );\n\n retryLaterTimer = setInterval(\n () => {\n const dueRetries = errorBoundary.processDueRetries();\n\n for (const entry of dueRetries) {\n if (entry.callback) {\n entry.callback();\n } else {\n scheduleReconcile();\n }\n }\n },\n Math.min(intervalMs, 500),\n );\n }\n\n // Initial reconcile (now that all modules are initialized)\n scheduleReconcile();\n },\n\n stop(): void {\n if (!state.isRunning) return;\n state.isRunning = false;\n\n // Stop retry-later timer\n if (retryLaterTimer !== null) {\n clearInterval(retryLaterTimer);\n retryLaterTimer = null;\n }\n errorBoundary.getRetryLaterManager().clearAll();\n\n // Cancel all resolvers\n resolversManager.cancelAll();\n\n // Run all effect cleanups\n effectsManager.cleanupAll();\n\n // Call module hooks\n for (const module of config.modules) {\n module.hooks?.onStop?.(system);\n }\n\n // Emit stop event\n pluginManager.emitStop(system);\n },\n\n destroy(): void {\n if (state.isDestroyed) return;\n this.stop();\n state.isDestroyed = true;\n // Clean up store listeners\n (store as unknown as Record<string, () => void>).destroy?.();\n // Clean up resolvers (statuses, caches)\n resolversManager.destroy();\n // Clean up error boundary\n errorBoundary.clearErrors();\n settlementListeners.clear();\n historyListeners.clear();\n // Clean up trace state (C1)\n traceManager.destroy();\n // Clean up dynamic definition state\n definitions.destroy();\n pluginManager.emitDestroy(system);\n },\n\n dispatch(event: SystemEvent): void {\n if (BLOCKED_PROPS.has(event.type)) return;\n dispatchEventByName(event.type, event as Record<string, unknown>);\n },\n\n read<T = unknown>(derivationId: string): T {\n return derivationsManager.get(\n derivationId as keyof DerivationsDef<S>,\n ) as T;\n },\n\n subscribe(ids: string[], listener: () => void): () => void {\n const derivationIds: string[] = [];\n const factKeys: string[] = [];\n\n for (const id of ids) {\n if (id in mergedDerive) {\n derivationIds.push(id);\n } else if (id in mergedSchema) {\n factKeys.push(id);\n } else if (process.env.NODE_ENV !== \"production\") {\n console.warn(`[Directive] subscribe: unknown key \"${id}\"`);\n }\n }\n\n const unsubs: Array<() => void> = [];\n if (derivationIds.length > 0) {\n unsubs.push(\n derivationsManager.subscribe(\n derivationIds as Array<keyof DerivationsDef<S>>,\n listener,\n ),\n );\n }\n if (factKeys.length > 0) {\n unsubs.push(\n store.subscribe(factKeys as Array<keyof InferSchema<S>>, listener),\n );\n }\n\n return () => {\n for (const u of unsubs) u();\n };\n },\n\n watch<T = unknown>(\n id: string,\n callback: (newValue: T, previousValue: T | undefined) => void,\n options?: { equalityFn?: (a: T, b: T | undefined) => boolean },\n ): () => void {\n const isEqual = options?.equalityFn\n ? (a: T, b: T | undefined) => options.equalityFn!(a, b)\n : (a: T, b: T | undefined) => Object.is(a, b);\n\n if (id in mergedDerive) {\n // Derivation path\n let previousValue: T | undefined = derivationsManager.get(\n id as keyof DerivationsDef<S>,\n ) as T | undefined;\n\n return derivationsManager.subscribe(\n [id as keyof DerivationsDef<S>],\n () => {\n const newValue = derivationsManager.get(\n id as keyof DerivationsDef<S>,\n ) as T;\n if (!isEqual(newValue, previousValue)) {\n const oldValue = previousValue;\n previousValue = newValue;\n callback(newValue, oldValue);\n }\n },\n );\n }\n\n // Fact path\n if (process.env.NODE_ENV !== \"production\") {\n if (!(id in mergedSchema)) {\n console.warn(`[Directive] watch: unknown key \"${id}\"`);\n }\n }\n let prev = store.get(id as keyof InferSchema<S>) as T | undefined;\n return store.subscribe([id as keyof InferSchema<S>], () => {\n const next = store.get(id as keyof InferSchema<S>) as T;\n if (!isEqual(next, prev)) {\n const old = prev;\n prev = next;\n callback(next, old);\n }\n });\n },\n\n when(\n predicate: (facts: Record<string, unknown>) => boolean,\n options?: { timeout?: number },\n ): Promise<void> {\n return new Promise<void>((resolve, reject) => {\n // Check immediately\n const factsObj = store.toObject();\n if (predicate(factsObj)) {\n resolve();\n return;\n }\n\n let unsub: (() => void) | undefined;\n let timer: ReturnType<typeof setTimeout> | undefined;\n\n const cleanup = () => {\n unsub?.();\n if (timer !== undefined) clearTimeout(timer);\n };\n\n // Subscribe to all fact changes\n unsub = store.subscribeAll(() => {\n const current = store.toObject();\n if (predicate(current)) {\n cleanup();\n resolve();\n }\n });\n\n // Timeout\n if (options?.timeout !== undefined && options.timeout > 0) {\n timer = setTimeout(() => {\n cleanup();\n reject(\n new Error(\n `[Directive] when: timed out after ${options.timeout}ms`,\n ),\n );\n }, options.timeout);\n }\n });\n },\n\n inspect(): SystemInspection {\n return {\n unmet: state.previousRequirements.all(),\n inflight: resolversManager.getInflightInfo(),\n constraints: constraintsManager.getAllStates().map((s) => ({\n id: s.id,\n active: s.lastResult ?? false,\n disabled: constraintsManager.isDisabled(s.id),\n priority: s.priority,\n hitCount: s.hitCount,\n lastActiveAt: s.lastActiveAt,\n })),\n resolvers: Object.fromEntries(\n resolversManager\n .getInflight()\n .map((id) => [id, resolversManager.getStatus(id)]),\n ),\n resolverDefs: Object.entries(mergedResolvers).map(([id, def]) => ({\n id,\n requirement:\n typeof def.requirement === \"string\"\n ? def.requirement\n : \"(predicate)\",\n })),\n traceEnabled,\n ...(traceEnabled\n ? { trace: structuredClone(traceManager.getEntries() ?? []) }\n : {}),\n };\n },\n\n explain(requirementId: string): string | null {\n // Find the requirement in current unmet requirements\n const requirements = state.previousRequirements.all();\n const req = requirements.find((r) => r.id === requirementId);\n\n if (!req) {\n return null;\n }\n\n const constraintState = constraintsManager.getState(req.fromConstraint);\n const resolverStatus = resolversManager.getStatus(requirementId);\n\n // Get relevant facts from the constraint's tracked dependencies\n const relevantFacts: Record<string, unknown> = {};\n const constraintDeps = constraintsManager.getDependencies(\n req.fromConstraint,\n );\n if (constraintDeps) {\n for (const key of constraintDeps) {\n relevantFacts[key] = store.get(key);\n }\n } else {\n // Fallback: include all facts if deps not tracked\n for (const [key, value] of Object.entries(store.toObject())) {\n relevantFacts[key] = value;\n }\n }\n\n const lines: string[] = [\n `Requirement \"${req.requirement.type}\" (id: ${req.id})`,\n `├─ Produced by constraint: ${req.fromConstraint}`,\n `├─ Constraint priority: ${constraintState?.priority ?? 0}`,\n `├─ Constraint active: ${constraintState?.lastResult ?? \"unknown\"}`,\n `├─ Resolver status: ${resolverStatus.state}`,\n ];\n\n // Add requirement details\n const reqDetails = Object.entries(req.requirement)\n .filter(([k]) => k !== \"type\")\n .map(([k, v]) => `${k}=${JSON.stringify(v)}`)\n .join(\", \");\n if (reqDetails) {\n lines.push(`├─ Requirement payload: { ${reqDetails} }`);\n }\n\n // Add relevant facts (limit to prevent huge output)\n const factEntries = Object.entries(relevantFacts).slice(0, 10);\n if (factEntries.length > 0) {\n lines.push(\"└─ Relevant facts:\");\n factEntries.forEach(([k, v], i) => {\n const prefix = i === factEntries.length - 1 ? \" └─\" : \" ├─\";\n const valueStr =\n typeof v === \"object\" ? JSON.stringify(v) : String(v);\n lines.push(\n `${prefix} ${k} = ${valueStr.slice(0, 50)}${valueStr.length > 50 ? \"...\" : \"\"}`,\n );\n });\n }\n\n return lines.join(\"\\n\");\n },\n\n getOriginal(\n type: \"constraint\" | \"resolver\" | \"derivation\" | \"effect\",\n id: string,\n ): unknown | undefined {\n return definitions.getOriginal(type, id);\n },\n\n restoreOriginal(\n type: \"constraint\" | \"resolver\" | \"derivation\" | \"effect\",\n id: string,\n ): boolean {\n return definitions.restoreOriginal(type, id);\n },\n\n async settle(maxWait = 5000): Promise<void> {\n /** Check if the system is fully settled */\n const isSettled = (): boolean =>\n resolversManager.getInflightCount() === 0 &&\n !state.isReconciling &&\n !state.reconcileScheduled &&\n !resolversManager.hasPendingBatches();\n\n // Flush pending batches and yield once for microtasks\n if (resolversManager.hasPendingBatches()) {\n resolversManager.processBatches();\n }\n await new Promise((resolve) => setTimeout(resolve, 0));\n\n if (isSettled()) {\n return;\n }\n\n // Event-driven: resolve when settlement state changes\n return new Promise<void>((resolve, reject) => {\n let done = false;\n\n const cleanup = () => {\n if (done) {\n return;\n }\n done = true;\n clearTimeout(timeout);\n unsubscribe();\n };\n\n const timeout = setTimeout(() => {\n cleanup();\n const details: string[] = [];\n const inflight = resolversManager.getInflightInfo();\n if (inflight.length > 0) {\n details.push(\n `${inflight.length} resolvers inflight: ${inflight.map((r) => r.resolverId).join(\", \")}`,\n );\n }\n if (state.isReconciling) {\n details.push(\"reconciliation in progress\");\n }\n if (state.reconcileScheduled) {\n details.push(\"reconcile scheduled\");\n }\n const unmet = state.previousRequirements.all();\n if (unmet.length > 0) {\n details.push(\n `${unmet.length} unmet requirements: ${unmet.map((r) => r.requirement.type).join(\", \")}`,\n );\n }\n reject(\n new Error(\n `[Directive] settle() timed out after ${maxWait}ms. ${details.join(\"; \")}`,\n ),\n );\n }, maxWait);\n\n const unsubscribe = this.onSettledChange(() => {\n if (resolversManager.hasPendingBatches()) {\n resolversManager.processBatches();\n }\n // Yield a microtask to let pending reconciles complete\n setTimeout(() => {\n if (!done && isSettled()) {\n cleanup();\n resolve();\n }\n }, 0);\n });\n });\n },\n\n getSnapshot() {\n return {\n facts: store.toObject(),\n version: 1,\n };\n },\n\n getDistributableSnapshot<T = Record<string, unknown>>(\n options: {\n includeDerivations?: string[];\n excludeDerivations?: string[];\n includeFacts?: string[];\n ttlSeconds?: number;\n metadata?: Record<string, unknown>;\n includeVersion?: boolean;\n } = {},\n ): {\n data: T;\n createdAt: number;\n expiresAt?: number;\n version?: string;\n metadata?: Record<string, unknown>;\n } {\n const {\n includeDerivations,\n excludeDerivations,\n includeFacts,\n ttlSeconds,\n metadata,\n includeVersion,\n } = options;\n\n const data: Record<string, unknown> = {};\n\n // Collect derivation keys to include\n const allDerivationKeys = Object.keys(mergedDerive);\n const allDerivationSet = new Set(allDerivationKeys);\n let derivationKeys: string[];\n\n if (includeDerivations) {\n // Only include specified derivations (Set lookup: O(1) per key)\n derivationKeys = includeDerivations.filter((k) =>\n allDerivationSet.has(k),\n );\n\n // Warn about unknown derivation keys in dev mode\n if (process.env.NODE_ENV !== \"production\") {\n const unknown = includeDerivations.filter(\n (k) => !allDerivationSet.has(k),\n );\n if (unknown.length > 0) {\n console.warn(\n `[Directive] getDistributableSnapshot: Unknown derivation keys ignored: ${unknown.join(\", \")}. ` +\n `Available: ${allDerivationKeys.join(\", \") || \"(none)\"}`,\n );\n }\n }\n } else {\n // Include all derivations by default\n derivationKeys = allDerivationKeys;\n }\n\n // Apply exclusions\n if (excludeDerivations) {\n const excludeSet = new Set(excludeDerivations);\n derivationKeys = derivationKeys.filter((k) => !excludeSet.has(k));\n }\n\n // Read derivation values\n for (const key of derivationKeys) {\n try {\n data[key] = derivationsManager.get(key as keyof DerivationsDef<S>);\n } catch (error) {\n // Skip derivations that error during computation\n if (process.env.NODE_ENV !== \"production\") {\n console.warn(\n `[Directive] getDistributableSnapshot: Skipping derivation \"${key}\" due to error:`,\n error,\n );\n }\n }\n }\n\n // Include specified facts\n if (includeFacts && includeFacts.length > 0) {\n const factsSnapshot = store.toObject();\n const allFactKeys = Object.keys(factsSnapshot);\n\n // Warn about unknown fact keys in dev mode\n if (process.env.NODE_ENV !== \"production\") {\n const unknown = includeFacts.filter((k) => !(k in factsSnapshot));\n if (unknown.length > 0) {\n console.warn(\n `[Directive] getDistributableSnapshot: Unknown fact keys ignored: ${unknown.join(\", \")}. ` +\n `Available: ${allFactKeys.join(\", \") || \"(none)\"}`,\n );\n }\n }\n\n for (const key of includeFacts) {\n if (key in factsSnapshot) {\n data[key] = factsSnapshot[key];\n }\n }\n }\n\n // Build the snapshot\n const createdAt = Date.now();\n const snapshot: {\n data: T;\n createdAt: number;\n expiresAt?: number;\n version?: string;\n metadata?: Record<string, unknown>;\n } = {\n data: data as T,\n createdAt,\n };\n\n // Add TTL\n if (ttlSeconds !== undefined && ttlSeconds > 0) {\n snapshot.expiresAt = createdAt + ttlSeconds * 1000;\n }\n\n // Add version hash\n if (includeVersion) {\n // Simple version hash based on data content\n snapshot.version = hashObject(data);\n }\n\n // Add metadata\n if (metadata) {\n snapshot.metadata = metadata;\n }\n\n return snapshot;\n },\n\n watchDistributableSnapshot<T = Record<string, unknown>>(\n options: {\n includeDerivations?: string[];\n excludeDerivations?: string[];\n includeFacts?: string[];\n ttlSeconds?: number;\n metadata?: Record<string, unknown>;\n includeVersion?: boolean;\n },\n callback: (snapshot: {\n data: T;\n createdAt: number;\n expiresAt?: number;\n version?: string;\n metadata?: Record<string, unknown>;\n }) => void,\n ): () => void {\n const { includeDerivations, excludeDerivations } = options;\n\n // Determine which derivations to watch\n const allDerivationKeys = Object.keys(mergedDerive);\n let derivationKeys: string[];\n\n if (includeDerivations) {\n derivationKeys = includeDerivations.filter((k) =>\n allDerivationKeys.includes(k),\n );\n } else {\n derivationKeys = allDerivationKeys;\n }\n\n if (excludeDerivations) {\n const excludeSet = new Set(excludeDerivations);\n derivationKeys = derivationKeys.filter((k) => !excludeSet.has(k));\n }\n\n if (derivationKeys.length === 0) {\n // Nothing to watch, return no-op unsubscribe\n if (process.env.NODE_ENV !== \"production\") {\n console.warn(\n \"[Directive] watchDistributableSnapshot: No derivations to watch. \" +\n \"Callback will never be called.\",\n );\n }\n return () => {};\n }\n\n // Get initial snapshot to seed version and ensure derivations are computed\n // (derivations must be computed before subscribing so listeners are called on invalidation)\n const initialSnapshot = this.getDistributableSnapshot<T>({\n ...options,\n includeVersion: true,\n });\n let previousVersion = initialSnapshot.version;\n\n // Subscribe to all watched derivations\n return derivationsManager.subscribe(\n derivationKeys as Array<keyof DerivationsDef<S>>,\n () => {\n // Generate a new snapshot\n const snapshot = this.getDistributableSnapshot<T>({\n ...options,\n // Always include version for change detection\n includeVersion: true,\n });\n\n // Only call callback if snapshot actually changed\n if (snapshot.version !== previousVersion) {\n previousVersion = snapshot.version;\n callback(snapshot);\n }\n },\n );\n },\n\n restore(snapshot) {\n if (!snapshot || typeof snapshot !== \"object\") {\n throw new Error(\n \"[Directive] restore() requires a valid snapshot object\",\n );\n }\n if (!snapshot.facts || typeof snapshot.facts !== \"object\") {\n throw new Error(\n \"[Directive] restore() snapshot must have a facts object\",\n );\n }\n\n // Security: Validate snapshot for prototype pollution\n if (!isPrototypeSafe(snapshot)) {\n throw new Error(\n \"[Directive] restore() rejected: snapshot contains potentially dangerous keys \" +\n \"(__proto__, constructor, or prototype). This may indicate a prototype pollution attack.\",\n );\n }\n\n store.batch(() => {\n for (const [key, value] of Object.entries(snapshot.facts)) {\n // Skip dangerous keys (defense in depth)\n if (BLOCKED_PROPS.has(key)) continue;\n store.set(\n key as keyof InferSchema<S>,\n value as InferSchema<S>[keyof InferSchema<S>],\n );\n }\n });\n },\n\n onSettledChange(listener: () => void): () => void {\n settlementListeners.add(listener);\n return () => {\n settlementListeners.delete(listener);\n };\n },\n\n onHistoryChange(listener: () => void): () => void {\n historyListeners.add(listener);\n return () => {\n historyListeners.delete(listener);\n };\n },\n\n batch(fn: () => void): void {\n store.batch(fn);\n },\n\n get isSettled(): boolean {\n return (\n resolversManager.getInflightCount() === 0 &&\n !resolversManager.hasPendingBatches() &&\n !state.isReconciling &&\n !state.reconcileScheduled\n );\n },\n\n get isRunning(): boolean {\n return state.isRunning;\n },\n\n get isInitialized(): boolean {\n return state.isInitialized;\n },\n\n get isReady(): boolean {\n return state.isReady;\n },\n\n whenReady(): Promise<void> {\n // If already ready, resolve immediately\n if (state.isReady) {\n return Promise.resolve();\n }\n\n // If not running, the promise would never resolve\n if (!state.isRunning) {\n return Promise.reject(\n new Error(\n \"[Directive] whenReady() called before start(). \" +\n \"Call system.start() first, then await system.whenReady().\",\n ),\n );\n }\n\n // Create promise if not exists\n if (!state.readyPromise) {\n state.readyPromise = new Promise<void>((resolve) => {\n state.readyResolve = resolve;\n });\n }\n\n return state.readyPromise;\n },\n };\n\n /**\n * Register a new module into a running (or stopped) engine.\n * Merges the module's schema, events, derive, effects, constraints, and resolvers\n * into the existing engine state, runs init, and triggers reconciliation.\n */\n function registerModule(module: {\n id: string;\n schema: Record<string, unknown>;\n requirements?: Record<string, unknown>;\n init?: (facts: unknown) => void;\n derive?: Record<string, (facts: unknown, derived: unknown) => unknown>;\n events?: Record<string, (facts: unknown, event: unknown) => void>;\n effects?: Record<string, unknown>;\n constraints?: Record<string, unknown>;\n resolvers?: Record<string, unknown>;\n hooks?: {\n onInit?: (s: unknown) => void;\n onStart?: (s: unknown) => void;\n onStop?: (s: unknown) => void;\n onError?: (e: unknown, ctx: unknown) => void;\n };\n history?: { snapshotEvents?: string[] };\n }): void {\n // Guard: cannot register during reconciliation (would corrupt iteration state)\n if (state.isReconciling) {\n throw new Error(\n `[Directive] Cannot register module \"${module.id}\" during reconciliation. ` +\n \"Wait for the current reconciliation cycle to complete.\",\n );\n }\n\n // Guard: cannot register on a destroyed system\n if (state.isDestroyed) {\n throw new Error(\n `[Directive] Cannot register module \"${module.id}\" on a destroyed system.`,\n );\n }\n\n // Security: validate keys\n const validateKeys = (obj: object | undefined, section: string) => {\n if (!obj) return;\n for (const key of Object.keys(obj)) {\n if (BLOCKED_PROPS.has(key)) {\n throw new Error(\n `[Directive] Security: Module \"${module.id}\" has dangerous key \"${key}\" in ${section}.`,\n );\n }\n if (section === \"schema\" && key.startsWith(\"$\")) {\n throw new Error(\n `[Directive] Module \"${module.id}\" has schema key \"${key}\" starting with \"$\". ` +\n \"Keys starting with $ are reserved for internal accessors ($store, $snapshot).\",\n );\n }\n }\n };\n validateKeys(module.schema, \"schema\");\n validateKeys(module.events, \"events\");\n validateKeys(module.derive, \"derive\");\n validateKeys(module.effects, \"effects\");\n validateKeys(module.constraints, \"constraints\");\n validateKeys(module.resolvers, \"resolvers\");\n\n // Schema collision detection (unconditional — production collision would cause data corruption)\n for (const key of Object.keys(module.schema)) {\n if (key in mergedSchema) {\n throw new Error(\n `[Directive] Schema collision: Fact \"${key}\" already exists. Cannot register module \"${module.id}\".`,\n );\n }\n }\n // Fact/derivation name collision check (dev-only warning)\n if (process.env.NODE_ENV !== \"production\" && module.derive) {\n const existingFactKeys = new Set(Object.keys(mergedSchema));\n for (const key of Object.keys(module.derive)) {\n if (existingFactKeys.has(key)) {\n console.warn(\n `[Directive] \"${key}\" exists as both a fact and a derivation after registering module \"${module.id}\".`,\n );\n }\n }\n }\n\n // Update snapshotEventNames BEFORE merging events so we capture pre-merge state\n if (module.history?.snapshotEvents) {\n if (snapshotEventNames === null) {\n // First module with history.snapshotEvents — initialize the set with all existing event names\n snapshotEventNames = new Set<string>(Object.keys(mergedEvents));\n }\n for (const eventName of module.history.snapshotEvents) {\n snapshotEventNames.add(eventName);\n }\n } else if (snapshotEventNames !== null && module.events) {\n // Filtering is active and this module has no filter — add all its events\n for (const eventName of Object.keys(module.events)) {\n snapshotEventNames.add(eventName);\n }\n }\n\n // Merge into existing engine state\n Object.assign(mergedSchema, module.schema);\n if (module.events) Object.assign(mergedEvents, module.events);\n if (module.derive) {\n Object.assign(mergedDerive, module.derive);\n // Register new derivations with the derivations manager\n derivationsManager.registerDefinitions(\n module.derive as DerivationsDef<S>,\n );\n }\n if (module.effects) {\n Object.assign(mergedEffects, module.effects);\n // biome-ignore lint/suspicious/noExplicitAny: Dynamic module registration\n effectsManager.registerDefinitions(module.effects as any);\n }\n if (module.constraints) {\n Object.assign(mergedConstraints, module.constraints);\n // biome-ignore lint/suspicious/noExplicitAny: Dynamic module registration\n constraintsManager.registerDefinitions(module.constraints as any);\n }\n if (module.resolvers) {\n Object.assign(mergedResolvers, module.resolvers);\n // biome-ignore lint/suspicious/noExplicitAny: Dynamic module registration\n resolversManager.registerDefinitions(module.resolvers as any);\n // Sync resolver key functions to the constraints manager\n syncResolverKeys(module.resolvers as ResolversDef<S>);\n }\n\n // Register new schema keys with the facts store\n // biome-ignore lint/suspicious/noExplicitAny: Internal dynamic method\n (store as any).registerKeys(module.schema as Record<string, unknown>);\n\n // Track the new module in config.modules for hooks\n config.modules.push(module as (typeof config.modules)[number]);\n\n // Run init within a batch\n if (module.init) {\n store.batch(() => {\n // biome-ignore lint/suspicious/noExplicitAny: Dynamic module init\n module.init!(facts as any);\n });\n }\n\n // Call lifecycle hooks\n module.hooks?.onInit?.(system);\n if (state.isRunning) {\n module.hooks?.onStart?.(system);\n // Trigger reconciliation to evaluate new constraints\n scheduleReconcile();\n }\n }\n\n // Attach registerModule to system\n (system as unknown as Record<string, unknown>).registerModule =\n registerModule;\n\n // Initialize plugins\n pluginManager.emitInit(system);\n\n // Call module init hooks\n for (const module of config.modules) {\n module.hooks?.onInit?.(system);\n }\n\n return system;\n}\n"]}