@directive-run/core 1.9.0 → 1.11.0

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/core/replay-under.ts","../src/core/sweep-under.ts","../src/core/rules-diff.ts","../src/core/predicate-to-sql.ts","../src/core/predicate-to-mongo.ts","../src/core/predicate-to-pgrest.ts","../src/core/schema-builders.ts","../src/core/module.ts","../src/utils/requirement-status.ts","../src/utils/system-with-status.ts","../src/core/clock.ts","../src/core/timer.ts","../src/index.ts"],"names":["MAX_REPLAY_FRAMES","validateReplaySpec","spec","which","validatePredicate","err","message","isPredicate","preview","unknownOp","walkPredicate","_factPath","op","PREDICATE_OPERATORS","key","PREDICATE_COMBINATORS","toReplayFrames","raw","framesFromHistory","list","entry","index","frame","out","historyExport","parsed","framesFromSnapshots","exportObj","snapshots","i","s","replayUnder","options","frames","original","proposed","entityKey","requested","maxSamples","originalMatched","proposedMatched","newMatchCount","lostMatchCount","unchanged","newMatches","lostMatches","originalEntities","proposedEntities","prevFacts","facts","originalBit","evaluatePredicate","proposedBit","buildSample","report","sample","evaluatePredicateExplained","MAX_SWEEP_POINTS","MAX_SWEEP_EVALUATIONS","isHole","v","substitute","template","values","path","depth","MAX_PREDICATE_DEPTH","name","k","cartesian","keys","sweep","head","rest","headValues","tail","gridSize","size","arr","sweepUnder","objective","r","total","evaluations","warnedObjective","safeObjective","baselineReport","baseline","points","bestIndex","bestScore","score","best","toRulesMap","inner","e","KNOWN_OPS","COMBINATORS","isPlainObject","isOperatorObject","sawKnown","flattenPredicate","pathPrefix","clause","c","child","value","operand","isNumeric","directionFor","before","after","widthBefore","widthAfter","diffRules","sortedIds","constraints","summary","id","b","a","hasB","hasA","clauses","changes","sortChanges","diffClauses","stableStringify","flatB","flatA","keyOf","mapB","mapA","allKeys","direction","x","y","p","xo","yo","IDENT_RE","assertIdentifier","kind","assertAllowed","allowed","validateSelect","select","col","nextParam","ctx","renderOp","column","escapeLike","operator","assertNoSiblingKeys","combinator","sibs","buildWhere","parts","DEFAULT_PLACEHOLDER","predicateToSQL","predicate","table","allowedKeys","placeholder","projection","where","predicateToWhere","escapeRegex","FIELD_RE","FIELD_DOTTED_RE","assertFieldName","opts","field","translateOp","buildQuery","obj","conflicts","translated","existing","andClauses","merged","predicateToMongo","assertColumn","encodeValue","encodeList","escapeLikeOperand","colClause","opAndValue","groupClause","logical","renderColumnOps","atTop","lo","hi","build","encodeClause","eq","predicateToPostgrest","mode","createSchemaType","validators","typeName","defaultValue","transform","description","refinements","meta","fn","createChainableType","fieldMeta","intermediate","desc","newRefinements","m","unionImpl","types","typeNames","schemaType","t","createChainableString","fm","n","regex","createChainableNumber","createChainableArray","elementType","indexRef","chainable","ref","et","newRef","validator","createChainableObject","shapeSchema","schemaT","dev_true_default","valueSet","innerType","innerTypeName","valueType","valueTypeName","val","uuidRegex","emailRegex","validateModuleId","validateKeyAlignment","implKeys","schemaKeys","implLabel","schemaLabel","missingImplMessage","validateSnapshotEvents","snapshotEvents","schemaEvents","schemaEventKeys","eventName","validateResolverRequirements","resolvers","requirements","requirementTypes","resolverName","resolver","resolverDef","validatePivotNameConflicts","config","factKeys","reserved","deps","depName","validateOwnsKeys","cid","constraint","owns","BLOCKED_PROPS","validateModuleConfig","createModule","crossModuleDeps","createModuleFactory","createRequirementStatusPlugin","state","notify","listener","getOrCreateSet","map","type","set","getStatus","pendingSet","inflightSet","failedSet","lastError","getAllStatus","allTypes","result","subscribe","reset","req","_resolver","error","createStatusHook","statusPlugin","createSystemWithStatus","allPlugins","createSystem","realClock","cb","ms","handle","virtualClock","initialMs","nowMs","nextId","queue","targetMs","ready","next","defaultClock","initialTimerState","elapsedMs","remainingMs","totalMs","startTimer","pauseTimer","resumeTimer","pausedFor","resetTimer","completeTimer","registerRepeat","tickTimer","elapsed","timerOps","Backoff"],"mappings":"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","file":"index.cjs","sourcesContent":["/**\n * Predicate backtest — rule-change impact.\n *\n * Given a recorded sequence of fact-state frames and a proposed replacement\n * for a constraint's `when` predicate, re-score the frames against BOTH the\n * original and the proposed predicate and produce a backtest report: how\n * many frames each matched, plus the per-frame diff (frames that newly\n * match / no longer match). It answers \"how many recorded frames would the\n * proposed rule have matched differently\" against real recorded history.\n *\n * This is a *static* backtest, not a behavioral simulation — the engine is\n * not re-run. Recorded frames are re-scored against a new predicate; the\n * resulting requirements, resolvers, and downstream fact changes are NOT\n * modeled. Treat the numbers as a divergence scan, not a forecast.\n *\n * Pure module — imports only the predicate runtime. No engine, store, or\n * tracking dependency. Replay walks frames in order; for `$changed`-style\n * predicates each frame is evaluated against the previous frame's facts.\n */\n\nimport {\n  evaluatePredicate,\n  evaluatePredicateExplained,\n  isPredicate,\n  validatePredicate,\n  walkPredicate,\n} from \"./predicate.js\";\nimport type { ClauseResult, FactPredicate } from \"./types/predicate.js\";\nimport { PREDICATE_COMBINATORS, PREDICATE_OPERATORS } from \"./types/predicate.js\";\n\n/**\n * Upper bound on the number of frames a single {@link replayUnder} call will\n * process. A history file is held entirely in memory; an unbounded array is a\n * denial-of-service surface. A history larger than this should be split or\n * down-sampled before replay.\n */\nexport const MAX_REPLAY_FRAMES = 1_000_000;\n\n/** One recorded fact-state frame. */\nexport interface ReplayFrame<F = Record<string, unknown>> {\n  /** Stable identifier — a snapshot id, an index, a session key. */\n  id: string | number;\n  /** Optional wall-clock time (ms epoch). */\n  timestamp?: number;\n  /** The fact state at this frame. */\n  facts: F;\n}\n\nexport interface ReplayUnderOptions<F = Record<string, unknown>> {\n  /** Recorded frames, chronological order. */\n  frames: readonly ReplayFrame<F>[];\n  /** The constraint's current `when` predicate (the baseline). */\n  original: FactPredicate<F>;\n  /** The proposed replacement `when` predicate. */\n  proposed: FactPredicate<F>;\n  /** Max diff samples to attach per bucket (default 20). */\n  maxSamples?: number;\n  /**\n   * A fact key identifying the entity a frame belongs to (e.g. `\"userId\"`,\n   * `\"sessionId\"`). When set, the report also reports distinct-entity counts\n   * — how many unique entities matched, not just how many frames. Without it\n   * the unit is frames: one fact snapshot, not one user or session.\n   */\n  entityKey?: string;\n}\n\n/** A frame where the original and proposed predicate disagree. */\nexport interface ReplayDiffSample {\n  frameId: string | number;\n  timestamp?: number;\n  /** The fact state at this frame. */\n  facts: Record<string, unknown>;\n  /** Per-clause breakdown under the original predicate. */\n  originalExplain: ClauseResult[];\n  /** Per-clause breakdown under the proposed predicate. */\n  proposedExplain: ClauseResult[];\n}\n\n/**\n * The outcome of replaying a recorded history under two predicates — a\n * static backtest of a proposed rule change, not a behavioral simulation.\n */\nexport interface PredicateBacktestReport {\n  /** Total frames evaluated. */\n  framesEvaluated: number;\n  /**\n   * Frames where the original predicate matched (was true). `matchedEntities`\n   * is the count of distinct `entityKey` values among matched frames — only\n   * populated when {@link ReplayUnderOptions.entityKey} was supplied.\n   */\n  original: { matched: number; matchedEntities?: number };\n  /** Frames where the proposed predicate matched. */\n  proposed: { matched: number; matchedEntities?: number };\n  /** proposed.matched - original.matched. */\n  delta: number;\n  /** Total count of frames that newly match (original false -> proposed true). */\n  newMatchCount: number;\n  /** Total count of frames that no longer match (original true -> proposed false). */\n  lostMatchCount: number;\n  /** Frames where original and proposed agree. */\n  unchanged: number;\n  /** Sampled new-match frames (capped at maxSamples), with clause explain. */\n  newMatches: ReplayDiffSample[];\n  /** Sampled lost-match frames (capped at maxSamples), with clause explain. */\n  lostMatches: ReplayDiffSample[];\n}\n\n/**\n * Validate one predicate spec for {@link replayUnder}, re-throwing any failure\n * with a message that names which spec (`original` / `proposed`) was bad.\n *\n * Three checks run, all up front so a malformed spec never reaches the\n * per-frame loop (where {@link evaluatePredicate} would throw a raw error on,\n * say, a `$matches` operand that is not a RegExp):\n *\n *  1. {@link validatePredicate} — JSON-unrehydratable operands (a `$matches`\n *     operand that is not a RegExp, a `bigint`, a `Set`/`Map`).\n *  2. {@link isPredicate} — the spec is structurally a FactPredicate. An\n *     empty object `{}` is a valid (always-true) predicate and is allowed.\n *  3. Unknown `$`-operators — a single walk surfaces any `$frobnicate`-style\n *     typo as one clear error instead of a per-call dev-warn.\n */\nfunction validateReplaySpec(\n  spec: unknown,\n  which: \"original\" | \"proposed\",\n): void {\n  try {\n    validatePredicate(spec);\n  } catch (err) {\n    const message = err instanceof Error ? err.message : String(err);\n\n    throw new Error(\n      `[Directive] replayUnder: the ${which} predicate is invalid — ${message}`,\n    );\n  }\n\n  if (!isPredicate(spec)) {\n    const preview =\n      spec === null || typeof spec !== \"object\"\n        ? `${typeof spec} — ${JSON.stringify(spec)}`\n        : JSON.stringify(spec).slice(0, 80);\n\n    throw new Error(\n      `[Directive] replayUnder: the ${which} predicate is not a valid FactPredicate (got ${preview})`,\n    );\n  }\n\n  // Surface an unknown `$`-operator (`$frobnicate`) as one clear error.\n  // `walkPredicate` reports a `$`-key at fact position via `strayOperatorKey`\n  // and an operator clause via `operator`; check both against the known sets.\n  let unknownOp: string | undefined;\n  walkPredicate(spec, {\n    operator(_factPath, op) {\n      if (\n        unknownOp === undefined &&\n        op.startsWith(\"$\") &&\n        !PREDICATE_OPERATORS.has(op)\n      ) {\n        unknownOp = op;\n      }\n    },\n    strayOperatorKey(key) {\n      if (\n        unknownOp === undefined &&\n        !PREDICATE_OPERATORS.has(key) &&\n        !PREDICATE_COMBINATORS.has(key)\n      ) {\n        unknownOp = key;\n      }\n    },\n  });\n\n  if (unknownOp !== undefined) {\n    throw new Error(\n      `[Directive] replayUnder: the ${which} predicate uses an unknown operator \"${unknownOp}\" — known operators: ${[...PREDICATE_OPERATORS].join(\", \")}`,\n    );\n  }\n}\n\n/**\n * Normalize a parsed-from-JSON history value into a `ReplayFrame[]`.\n *\n * Accepts the three documented history shapes:\n *\n *  1. A bare array of frames:        `[{ id, timestamp?, facts }, ...]`\n *  2. An object wrapping them:       `{ frames: [{ id, ..., facts }, ...] }`\n *  3. A bare array of fact objects:  `[{ phase: \"red\", ... }, ...]`\n *     — each element is wrapped as a frame.\n *\n * Frame ids are kept unambiguous: a frame that supplies its own `id` keeps\n * it; a frame missing an `id` (and every bare-fact frame) gets an\n * **index-derived** id prefixed with `#` (`\"#0\"`, `\"#1\"`, …) so a fallback\n * id can never collide with an explicit numeric or string id in a mixed\n * history. This is a pure helper — it **throws** a clear `Error` on bad\n * input and never calls `process.exit`, so library users can catch it.\n *\n * @example\n * ```ts\n * toReplayFrames([{ id: \"s1\", facts: { phase: \"red\" } }]);\n * // → [{ id: \"s1\", facts: { phase: \"red\" } }]\n * toReplayFrames([{ phase: \"red\" }, { phase: \"green\" }]);\n * // → [{ id: \"#0\", facts: { phase: \"red\" } }, { id: \"#1\", facts: { phase: \"green\" } }]\n * ```\n */\nexport function toReplayFrames(raw: unknown): ReplayFrame[] {\n  // A history-manager export ({ version, snapshots, currentIndex }) is a\n  // valid input shape — route it through framesFromHistory so the CLI and\n  // the library accept the same files.\n  if (\n    raw &&\n    typeof raw === \"object\" &&\n    !Array.isArray(raw) &&\n    Array.isArray((raw as { snapshots?: unknown }).snapshots)\n  ) {\n    return framesFromHistory(raw);\n  }\n\n  const list: unknown[] | null = Array.isArray(raw)\n    ? raw\n    : raw &&\n        typeof raw === \"object\" &&\n        Array.isArray((raw as { frames?: unknown }).frames)\n      ? (raw as { frames: unknown[] }).frames\n      : null;\n\n  if (!list) {\n    throw new Error(\n      \"[Directive] toReplayFrames: history must be a JSON array of frames, an object with a `frames` array, or a history export with a `snapshots` array\",\n    );\n  }\n\n  // Enforce the frame cap on `length` before `.map()` materializes a second\n  // array — the cap must bound memory, not just the evaluation loop.\n  if (list.length > MAX_REPLAY_FRAMES) {\n    throw new Error(\n      `[Directive] toReplayFrames: history has ${list.length} frames, exceeds the MAX_REPLAY_FRAMES limit (${MAX_REPLAY_FRAMES}) — split or down-sample the history`,\n    );\n  }\n\n  return list.map((entry, index) => {\n    if (entry && typeof entry === \"object\" && \"facts\" in entry) {\n      const frame = entry as {\n        id?: string | number;\n        timestamp?: number;\n        facts: unknown;\n      };\n      // An explicit id is used verbatim; a missing id falls back to a\n      // `#`-prefixed index so it cannot collide with an explicit id.\n      const out: ReplayFrame = {\n        id: frame.id ?? `#${index}`,\n        facts: (frame.facts ?? {}) as Record<string, unknown>,\n      };\n      if (typeof frame.timestamp === \"number\") {\n        out.timestamp = frame.timestamp;\n      }\n\n      return out;\n    }\n\n    // A bare fact object — wrap it, keyed by `#`-prefixed index.\n    return { id: `#${index}`, facts: (entry ?? {}) as Record<string, unknown> };\n  });\n}\n\n/**\n * Convert a history-manager export (the JSON produced by\n * `system.history.export()`) into a `ReplayFrame[]` ready for\n * {@link replayUnder}.\n *\n * The history manager records a ring buffer of `{ id, timestamp, facts,\n * trigger }` snapshots; `export()` wraps them as `{ version, snapshots,\n * currentIndex }`. Each snapshot's `facts` is the fact state at that point,\n * so the snapshot sequence is exactly a frame stream.\n *\n * Accepts either the parsed export object, the raw JSON string, or a bare\n * array of snapshots. Throws a clear `Error` on bad input.\n *\n * @example\n * ```ts\n * const frames = framesFromHistory(system.history.export());\n * const report = replayUnder({ frames, original, proposed });\n * ```\n */\nexport function framesFromHistory(historyExport: unknown): ReplayFrame[] {\n  const parsed =\n    typeof historyExport === \"string\"\n      ? (JSON.parse(historyExport) as unknown)\n      : historyExport;\n\n  // A bare snapshot array is accepted directly.\n  if (Array.isArray(parsed)) {\n    return framesFromSnapshots(parsed);\n  }\n\n  if (!parsed || typeof parsed !== \"object\") {\n    throw new Error(\n      \"[Directive] framesFromHistory: expected a history export object with a `snapshots` array (from system.history.export())\",\n    );\n  }\n\n  const exportObj = parsed as { version?: unknown; snapshots?: unknown };\n\n  // Mirror history.ts import(): only version 1 is understood. A bump in the\n  // export format must fail loud here, not silently yield wrong frames.\n  if (exportObj.version !== undefined && exportObj.version !== 1) {\n    throw new Error(\n      `[Directive] framesFromHistory: unsupported history export version ${JSON.stringify(exportObj.version)} — expected 1`,\n    );\n  }\n\n  if (!Array.isArray(exportObj.snapshots)) {\n    throw new Error(\n      \"[Directive] framesFromHistory: expected a history export object with a `snapshots` array (from system.history.export())\",\n    );\n  }\n\n  return framesFromSnapshots(exportObj.snapshots);\n}\n\n/**\n * Convert an array of `{ id, timestamp?, facts }` snapshots — e.g. the\n * `snapshots` field of a history export, or an array assembled by pushing\n * `system.getSnapshot()` on each reconcile — into a `ReplayFrame[]`.\n *\n * Throws a clear `Error` if the argument is not an array. Each snapshot is\n * normalized through the same {@link toReplayFrames} id logic.\n *\n * @example\n * ```ts\n * const snapshots: typeof history[] = [];\n * system.observe(() => snapshots.push(system.getSnapshot()));\n * // ...later\n * const frames = framesFromSnapshots(snapshots);\n * ```\n */\nexport function framesFromSnapshots(snapshots: unknown): ReplayFrame[] {\n  if (!Array.isArray(snapshots)) {\n    throw new Error(\n      \"[Directive] framesFromSnapshots: expected an array of fact-state snapshots\",\n    );\n  }\n\n  if (snapshots.length > MAX_REPLAY_FRAMES) {\n    throw new Error(\n      `[Directive] framesFromSnapshots: history has ${snapshots.length} snapshots, exceeds the MAX_REPLAY_FRAMES limit (${MAX_REPLAY_FRAMES}) — split or down-sample the history`,\n    );\n  }\n\n  // A snapshot is always a { facts, ... } object — reject a garbage array\n  // before it is silently wrapped into empty-fact frames.\n  for (let i = 0; i < snapshots.length; i++) {\n    const s = snapshots[i];\n    if (!s || typeof s !== \"object\" || !(\"facts\" in s)) {\n      throw new Error(\n        `[Directive] framesFromSnapshots: snapshot at index ${i} is not a { facts, ... } object`,\n      );\n    }\n  }\n\n  return toReplayFrames(snapshots);\n}\n\n/**\n * Replay a recorded fact-frame history through two predicates — the\n * constraint's current `when` and a proposed replacement — and report how\n * their match sets differ.\n *\n * This is a **predicate backtest**: the engine is not re-run. Each recorded\n * frame is statically re-scored against both specs; the previous frame's\n * facts are threaded as `prev` so a replayed effect-`on` predicate using\n * `$changed` still works (for a constraint `when` it is harmless). The\n * report counts matches under each spec and buckets the disagreements into\n * new matches (original false, proposed true) and lost matches (original\n * true, proposed false). Up to `maxSamples` diff frames per bucket carry a\n * per-clause `evaluatePredicateExplained` breakdown for inspection.\n *\n * Both specs are validated up front — a malformed spec throws a clear\n * `[Directive] replayUnder:` error identifying which spec failed, rather\n * than letting a raw `evaluatePredicate` error escape mid-loop.\n *\n * @example\n * ```ts\n * const report = replayUnder({\n *   frames: [\n *     { id: 0, facts: { phase: \"red\", elapsed: 10 } },\n *     { id: 1, facts: { phase: \"red\", elapsed: 35 } },\n *   ],\n *   original: { phase: \"red\" },\n *   proposed: { phase: \"red\", elapsed: { $gte: 30 } },\n * });\n * // report.original.matched  === 2\n * // report.proposed.matched  === 1\n * // report.delta             === -1\n * // report.lostMatchCount    === 1\n * ```\n */\nexport function replayUnder<F = Record<string, unknown>>(\n  options: ReplayUnderOptions<F>,\n): PredicateBacktestReport {\n  const { frames, original, proposed, entityKey } = options;\n  const requested = options.maxSamples ?? 20;\n  const maxSamples = requested > 0 ? requested : 0;\n\n  if (frames.length > MAX_REPLAY_FRAMES) {\n    throw new Error(\n      `[Directive] replayUnder: history has ${frames.length} frames, exceeds the MAX_REPLAY_FRAMES limit (${MAX_REPLAY_FRAMES}) — split or down-sample the history`,\n    );\n  }\n\n  // Validate both specs before the frame loop — fail loud and clear here\n  // rather than at frame 0 with a raw evaluatePredicate stack trace.\n  validateReplaySpec(original, \"original\");\n  validateReplaySpec(proposed, \"proposed\");\n\n  let originalMatched = 0;\n  let proposedMatched = 0;\n  let newMatchCount = 0;\n  let lostMatchCount = 0;\n  let unchanged = 0;\n  const newMatches: ReplayDiffSample[] = [];\n  const lostMatches: ReplayDiffSample[] = [];\n\n  // Distinct-entity tracking — only allocated when `entityKey` was supplied.\n  const originalEntities = entityKey ? new Set<unknown>() : undefined;\n  const proposedEntities = entityKey ? new Set<unknown>() : undefined;\n\n  let prevFacts: Record<string, unknown> | undefined;\n\n  for (const frame of frames) {\n    const facts = frame.facts as Record<string, unknown>;\n    const originalBit = evaluatePredicate(original, facts, prevFacts);\n    const proposedBit = evaluatePredicate(proposed, facts, prevFacts);\n\n    if (originalBit) {\n      originalMatched++;\n      originalEntities?.add(facts[entityKey as string]);\n    }\n    if (proposedBit) {\n      proposedMatched++;\n      proposedEntities?.add(facts[entityKey as string]);\n    }\n\n    if (originalBit === proposedBit) {\n      unchanged++;\n    } else if (!originalBit && proposedBit) {\n      newMatchCount++;\n      if (newMatches.length < maxSamples) {\n        newMatches.push(buildSample(frame, original, proposed, prevFacts));\n      }\n    } else {\n      lostMatchCount++;\n      if (lostMatches.length < maxSamples) {\n        lostMatches.push(buildSample(frame, original, proposed, prevFacts));\n      }\n    }\n\n    prevFacts = facts;\n  }\n\n  const report: PredicateBacktestReport = {\n    framesEvaluated: frames.length,\n    original: { matched: originalMatched },\n    proposed: { matched: proposedMatched },\n    delta: proposedMatched - originalMatched,\n    newMatchCount,\n    lostMatchCount,\n    unchanged,\n    newMatches,\n    lostMatches,\n  };\n\n  if (originalEntities && proposedEntities) {\n    report.original.matchedEntities = originalEntities.size;\n    report.proposed.matchedEntities = proposedEntities.size;\n  }\n\n  return report;\n}\n\n/**\n * Build a {@link ReplayDiffSample} for a frame the two predicates disagree\n * on — the per-clause explain is computed only here, never for non-diff\n * frames, so the common (mostly-agreeing) case stays cheap.\n */\nfunction buildSample<F>(\n  frame: ReplayFrame<F>,\n  original: unknown,\n  proposed: unknown,\n  prevFacts: Record<string, unknown> | undefined,\n): ReplayDiffSample {\n  const facts = frame.facts as Record<string, unknown>;\n  const sample: ReplayDiffSample = {\n    frameId: frame.id,\n    facts,\n    originalExplain: evaluatePredicateExplained(original, facts, prevFacts),\n    proposedExplain: evaluatePredicateExplained(proposed, facts, prevFacts),\n  };\n\n  if (frame.timestamp !== undefined) {\n    sample.timestamp = frame.timestamp;\n  }\n\n  return sample;\n}\n","/**\n * Parameter sweep over a predicate template — the grid-search counterpart\n * to `replayUnder`.\n *\n * `replayUnder` diffs ONE proposed predicate against the original.\n * `sweepUnder` takes a **template** with one or more `{ $hole: \"name\" }`\n * markers and a set of candidate values, then replays the history once\n * per (cartesian-product) combination. The result is a response curve\n * over the parameter space plus the argmax under a user-supplied\n * objective — turning rule-tuning from guess-and-check into a one-call\n * optimization against recorded traffic.\n *\n * Pure module — imports only the predicate runtime and replay engine.\n * No engine / store / tracking dependency.\n */\n\nimport { MAX_PREDICATE_DEPTH } from \"./predicate.js\";\nimport { type PredicateBacktestReport, type ReplayFrame, replayUnder } from \"./replay-under.js\";\nimport type { FactPredicate } from \"./types/predicate.js\";\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/** A placeholder inside a predicate template — substituted from `sweep` values. */\nexport interface SweepHole {\n  readonly $hole: string;\n}\n\nexport interface SweepUnderOptions<F = Record<string, unknown>> {\n  /** Recorded fact-state frames, in chronological order. */\n  frames: readonly ReplayFrame<F>[];\n  /** The constraint's current `when` predicate (baseline). */\n  original: FactPredicate<F>;\n  /**\n   * Predicate template containing one or more `{ $hole: \"name\" }` markers.\n   * Each marker is substituted by the corresponding value from `sweep` on\n   * every point in the curve.\n   *\n   * @example\n   * ```ts\n   * { cartTotal: { $gte: { $hole: \"threshold\" } } }\n   * ```\n   */\n  template: unknown;\n  /**\n   * Map of hole name → candidate values. Multiple holes produce the\n   * cartesian product (grid search).\n   *\n   * @example\n   * ```ts\n   * { threshold: [25, 50, 100, 200] }\n   * { riskScore: [0.5, 0.7, 0.9], minAge: [13, 18, 21] } // 3*3 = 9 points\n   * ```\n   */\n  sweep: Readonly<Record<string, readonly unknown[]>>;\n  /**\n   * Score function for ranking. Higher is better. Default:\n   * `(report) => report.proposed.matched` (maximize matched frames).\n   */\n  objective?: (report: PredicateBacktestReport) => number;\n  /** Optional fact key to additionally report distinct-entity counts. */\n  entityKey?: string;\n  /**\n   * Diff frames sampled per replay (default 0 — count-only for speed).\n   * Set higher to inspect specific frames in the report.\n   */\n  maxSamples?: number;\n}\n\n/** One point on the sweep curve — one candidate value tuple. */\nexport interface SweepPoint {\n  /** Hole name → value used at this point. */\n  values: Readonly<Record<string, unknown>>;\n  /** Full backtest report against this candidate. */\n  report: PredicateBacktestReport;\n  /** Computed objective score (higher is better). */\n  score: number;\n}\n\nexport interface SweepReport {\n  /** All points, in sweep order (cartesian-product traversal of sweep keys). */\n  points: readonly SweepPoint[];\n  /** Index of the highest-scoring point in `points`. */\n  bestIndex: number;\n  /** Convenience accessor: `points[bestIndex]`. */\n  best: SweepPoint;\n  /** The original predicate replayed against itself — score baseline for comparison. */\n  baseline: SweepPoint;\n}\n\n/** Hard cap on points evaluated in a single sweep — protects against runaway grids. */\nexport const MAX_SWEEP_POINTS = 10_000;\n\n/**\n * Aggregate compute cap: `points × frames` per call. `MAX_SWEEP_POINTS`\n * (10k) and `MAX_REPLAY_FRAMES` (1M) bound each axis individually, but\n * their product would be 10B per-frame evaluations — minutes-to-hours of\n * compute. This caps the realistic upper bound at ~50M evaluations\n * (e.g. 50k frames × 1k points, or 5k frames × 10k points).\n */\nexport const MAX_SWEEP_EVALUATIONS = 50_000_000;\n\n// ============================================================================\n// Hole substitution\n// ============================================================================\n\nfunction isHole(v: unknown): v is SweepHole {\n  return (\n    v !== null &&\n    typeof v === \"object\" &&\n    !Array.isArray(v) &&\n    Object.keys(v as object).length === 1 &&\n    typeof (v as SweepHole).$hole === \"string\"\n  );\n}\n\n/**\n * Walk `template`, replacing every `{ $hole: name }` marker with the value\n * looked up in `values`. Returns a new tree — does not mutate `template`.\n * Cycle-guarded; depth-capped at `MAX_PREDICATE_DEPTH`.\n *\n * Throws if a hole's name is not present in `values` — surfaces a typo'd\n * hole name up front rather than letting it land as `undefined` in the\n * evaluator.\n */\nfunction substitute(\n  template: unknown,\n  values: Record<string, unknown>,\n  path: Set<object> = new Set(),\n  depth = 0,\n): unknown {\n  if (depth > MAX_PREDICATE_DEPTH) {\n    throw new Error(\n      `[Directive] sweepUnder: template exceeds MAX_PREDICATE_DEPTH (${MAX_PREDICATE_DEPTH}) — flatten the template or split the sweep`,\n    );\n  }\n\n  if (isHole(template)) {\n    const name = template.$hole;\n    if (!(name in values)) {\n      throw new Error(\n        `[Directive] sweepUnder: template references hole \"${name}\" but sweep has no values for it`,\n      );\n    }\n\n    // Don't recurse into the substituted value — sweep values are opaque\n    // payloads, not templates. A value that itself looks like `{$hole:...}`\n    // lands literally in the proposed predicate.\n    return values[name];\n  }\n\n  if (template === null || typeof template !== \"object\") {\n    return template;\n  }\n\n  // Cycle guard via DFS path Set — entries are removed on unwind so that\n  // shared (non-cyclic) sub-trees still get substituted on every occurrence.\n  if (path.has(template)) {\n    throw new Error(\n      \"[Directive] sweepUnder: template contains a cycle — predicate templates must be a tree\",\n    );\n  }\n  path.add(template);\n\n  try {\n    if (Array.isArray(template)) {\n      return template.map((entry) => substitute(entry, values, path, depth + 1));\n    }\n\n    const out: Record<string, unknown> = {};\n    for (const [k, v] of Object.entries(template)) {\n      out[k] = substitute(v, values, path, depth + 1);\n    }\n\n    return out;\n  } finally {\n    path.delete(template);\n  }\n}\n\n// ============================================================================\n// Cartesian product\n// ============================================================================\n\n/**\n * Iterate the cartesian product of the sweep map's value arrays, in\n * declaration order. Generator avoids materializing the whole grid for\n * large multi-hole sweeps.\n */\nfunction* cartesian(\n  keys: readonly string[],\n  sweep: Readonly<Record<string, readonly unknown[]>>,\n): Generator<Record<string, unknown>> {\n  if (keys.length === 0) {\n    yield {};\n\n    return;\n  }\n\n  const head = keys[0] as string;\n  const rest = keys.slice(1);\n  const headValues = sweep[head] ?? [];\n  for (const v of headValues) {\n    for (const tail of cartesian(rest, sweep)) {\n      yield { [head]: v, ...tail };\n    }\n  }\n}\n\nfunction gridSize(sweep: Readonly<Record<string, readonly unknown[]>>): number {\n  let size = 1;\n  for (const arr of Object.values(sweep)) {\n    size *= arr.length;\n  }\n\n  return size;\n}\n\n// ============================================================================\n// Public API\n// ============================================================================\n\n/**\n * Sweep a predicate template's hole(s) across candidate values and replay\n * the recorded history through each one. Returns the full response curve\n * plus the argmax under a user-supplied objective.\n *\n * The mechanism is a tight loop over `replayUnder`: walk the cartesian\n * product of sweep values, substitute each combination into the template,\n * and run a backtest. Same caveats as `replayUnder` apply (no cascade\n * modeling, survivorship bias) — see {@link replayUnder} docs.\n *\n * @example\n * ```ts\n * const report = sweepUnder({\n *   frames: recordedSessions,\n *   original: { cartTotal: { $gte: 100 } },\n *   template: { cartTotal: { $gte: { $hole: \"threshold\" } } },\n *   sweep: { threshold: [25, 50, 100, 200] },\n * });\n *\n * report.best.values;          // { threshold: 25 }  (assuming higher matched is better)\n * report.best.report.proposed.matched;  // 9210\n * report.baseline.score;       // 4217 — the original spec's matched count\n * report.points.length;        // 4\n * ```\n *\n * Multi-hole sweeps grid-search:\n *\n * ```ts\n * sweepUnder({\n *   frames,\n *   original,\n *   template: {\n *     risk: { $gte: { $hole: \"minRisk\" } },\n *     age:  { $gte: { $hole: \"minAge\"  } },\n *   },\n *   sweep: { minRisk: [0.5, 0.7, 0.9], minAge: [13, 18, 21] },\n * });\n * // → 9 points (3 × 3)\n * ```\n */\nexport function sweepUnder<F = Record<string, unknown>>(\n  options: SweepUnderOptions<F>,\n): SweepReport {\n  const {\n    frames,\n    original,\n    template,\n    sweep,\n    objective = (r) => r.proposed.matched,\n    entityKey,\n    maxSamples = 0,\n  } = options;\n\n  const keys = Object.keys(sweep);\n  if (keys.length === 0) {\n    throw new Error(\n      \"[Directive] sweepUnder: `sweep` must contain at least one hole name\",\n    );\n  }\n\n  const total = gridSize(sweep);\n  if (total > MAX_SWEEP_POINTS) {\n    throw new Error(\n      `[Directive] sweepUnder: grid has ${total} points, exceeds the MAX_SWEEP_POINTS limit (${MAX_SWEEP_POINTS}) — narrow the sweep ranges or split the run`,\n    );\n  }\n  if (total === 0) {\n    throw new Error(\n      \"[Directive] sweepUnder: at least one hole has zero candidate values\",\n    );\n  }\n  const evaluations = total * frames.length;\n  if (evaluations > MAX_SWEEP_EVALUATIONS) {\n    throw new Error(\n      `[Directive] sweepUnder: ${total} points × ${frames.length} frames = ${evaluations} per-frame evaluations, exceeds the MAX_SWEEP_EVALUATIONS limit (${MAX_SWEEP_EVALUATIONS}) — narrow the sweep, down-sample the history, or split the run`,\n    );\n  }\n\n  // Invoke the user's objective with a catch + finite-number guard.\n  // A throw or non-finite return becomes -Infinity so the point sinks in\n  // the ranking instead of corrupting it (and stays out of the argmax).\n  let warnedObjective = false;\n  const safeObjective = (report: PredicateBacktestReport): number => {\n    let raw: unknown;\n    try {\n      raw = objective(report);\n    } catch (err) {\n      if (!warnedObjective) {\n        warnedObjective = true;\n        console.warn(\n          `[Directive] sweepUnder: objective threw — point will not rank (${(err as Error).message})`,\n        );\n      }\n\n      return Number.NEGATIVE_INFINITY;\n    }\n    if (typeof raw !== \"number\" || !Number.isFinite(raw)) {\n      if (!warnedObjective) {\n        warnedObjective = true;\n        console.warn(\n          `[Directive] sweepUnder: objective returned a non-finite number (${String(raw)}) — point will not rank`,\n        );\n      }\n\n      return Number.NEGATIVE_INFINITY;\n    }\n\n    return raw;\n  };\n\n  // Baseline: replay original against itself so the caller has a\n  // comparable score under the same objective. This is one extra\n  // replayUnder() call regardless of grid size — cheap, useful.\n  const baselineReport = replayUnder({\n    frames,\n    original,\n    proposed: original,\n    entityKey,\n    maxSamples,\n  });\n  const baseline: SweepPoint = {\n    values: {},\n    report: baselineReport,\n    score: safeObjective(baselineReport),\n  };\n\n  const points: SweepPoint[] = [];\n  let bestIndex = 0;\n  let bestScore = Number.NEGATIVE_INFINITY;\n\n  for (const values of cartesian(keys, sweep)) {\n    const proposed = substitute(template, values) as FactPredicate<F>;\n    const report = replayUnder({\n      frames,\n      original,\n      proposed,\n      entityKey,\n      maxSamples,\n    });\n    const score = safeObjective(report);\n    if (score > bestScore) {\n      bestScore = score;\n      bestIndex = points.length;\n    }\n    points.push({ values, report, score });\n  }\n\n  // points is guaranteed non-empty here because total > 0 and the loop ran.\n  const best = points[bestIndex] as SweepPoint;\n\n  return {\n    points,\n    bestIndex,\n    best,\n    baseline,\n  };\n}\n","/**\n * Structural diff between two snapshots of a system's constraint `whenSpec`\n * map. The \"git diff for business rules\" — operates on the predicate AST\n * instead of source-text lines.\n *\n * A predicate is a tree of leaf clauses (`{ fact: operator(value) }`) and\n * combinators (`$all` / `$any` / `$not`). `diffRules` flattens both trees\n * into path-keyed leaf lists and compares: missing path → added/removed,\n * same path with different operand → changed (with relaxed/tightened\n * classification for numeric thresholds).\n *\n * Pure module — imports only utils. No engine / store / predicate-runtime\n * dependency: predicates are walked as plain JSON.\n */\n\nimport { stableStringify } from \"../utils/utils.js\";\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/** A leaf clause extracted from a predicate tree, keyed by its dotted path. */\nexport interface LeafClause {\n  /** Dotted path through the predicate. E.g. `phase`, `$all[0].elapsed`, `$not.paused`. */\n  path: string;\n  /** Operator name. `$eq` is implied for bare-value equality. */\n  op: string;\n  /** Operand. */\n  value: unknown;\n}\n\n/** Kind of change observed for a single clause. */\nexport type ChangeKind =\n  | \"added\"\n  | \"removed\"\n  | \"changed\"\n  | \"relaxed\"\n  | \"tightened\";\n\n/** A single change between two predicates at a specific path. */\nexport interface Change {\n  path: string;\n  kind: ChangeKind;\n  before?: { op: string; value: unknown };\n  after?: { op: string; value: unknown };\n}\n\n/** Status of a single constraint across the two snapshots. */\nexport type ConstraintStatus = \"added\" | \"removed\" | \"changed\" | \"unchanged\";\n\nexport interface ConstraintDiff {\n  id: string;\n  status: ConstraintStatus;\n  /** Empty for `unchanged`. For `added` / `removed`, every leaf is listed once. */\n  changes: Change[];\n}\n\nexport interface RulesDiffReport {\n  constraints: ConstraintDiff[];\n  summary: {\n    added: number;\n    removed: number;\n    changed: number;\n    unchanged: number;\n    totalClauseChanges: number;\n  };\n}\n\nexport interface DiffRulesOptions {\n  before: RulesMapInput;\n  after: RulesMapInput;\n}\n\n/**\n * Accepted shapes for the `before` / `after` predicate maps:\n *   - A plain map `{ [constraintId]: whenSpec }`\n *   - The `system.inspect().constraints` array form `Array<{ id, whenSpec? }>`\n *   - Either wrapped as `{ constraints: <one-of-the-above> }`\n *\n * Anything else throws at `toRulesMap` so a bad input fails loud.\n */\nexport type RulesMapInput = unknown;\n\n// ============================================================================\n// Input normalization\n// ============================================================================\n\n/**\n * Coerce supported input shapes into a flat `Record<constraintId, whenSpec>`.\n * Constraints without a `whenSpec` (function-form `when`) are dropped with\n * an undefined entry so callers can distinguish them from absent constraints\n * if they care; the diff treats `undefined` as \"no data\" and skips clause\n * walking.\n */\nexport function toRulesMap(raw: RulesMapInput): Record<string, unknown> {\n  const inner =\n    raw && typeof raw === \"object\" && !Array.isArray(raw) && \"constraints\" in raw\n      ? (raw as { constraints: unknown }).constraints\n      : raw;\n\n  if (Array.isArray(inner)) {\n    const out: Record<string, unknown> = {};\n    for (const entry of inner) {\n      if (!entry || typeof entry !== \"object\" || !(\"id\" in entry)) {\n        throw new Error(\n          \"[Directive] diffRules: array entries must be `{ id, whenSpec }` objects\",\n        );\n      }\n      const e = entry as { id: unknown; whenSpec?: unknown };\n      if (typeof e.id !== \"string\") {\n        throw new Error(\"[Directive] diffRules: constraint `id` must be a string\");\n      }\n      out[e.id] = e.whenSpec;\n    }\n\n    return out;\n  }\n\n  if (inner && typeof inner === \"object\") {\n    return inner as Record<string, unknown>;\n  }\n\n  throw new Error(\n    \"[Directive] diffRules: expected a `{ id: whenSpec }` map, an array of `{ id, whenSpec }`, or `{ constraints: ... }`\",\n  );\n}\n\n// ============================================================================\n// Predicate flattening\n// ============================================================================\n\nconst KNOWN_OPS = new Set([\n  \"$eq\",\n  \"$ne\",\n  \"$in\",\n  \"$nin\",\n  \"$exists\",\n  \"$gt\",\n  \"$gte\",\n  \"$lt\",\n  \"$lte\",\n  \"$between\",\n  \"$matches\",\n  \"$startsWith\",\n  \"$endsWith\",\n  \"$contains\",\n  \"$changed\",\n]);\n\nconst COMBINATORS = new Set([\"$all\", \"$any\", \"$not\"]);\n\nfunction isPlainObject(v: unknown): v is Record<string, unknown> {\n  return v !== null && typeof v === \"object\" && !Array.isArray(v);\n}\n\n/**\n * Treat a value as an operator object iff it is a plain object whose keys\n * are ALL `$`-prefixed AND at least one is a known predicate operator.\n * Mirrors the runtime's `isOperatorObject` shape — diffRules walks the same\n * \"operator object\" boundary as `evaluatePredicate`.\n */\nfunction isOperatorObject(v: unknown): v is Record<string, unknown> {\n  if (!isPlainObject(v)) {\n    return false;\n  }\n  const keys = Object.keys(v);\n  if (keys.length === 0) {\n    return false;\n  }\n  let sawKnown = false;\n  for (const k of keys) {\n    if (!k.startsWith(\"$\")) {\n      return false;\n    }\n    if (KNOWN_OPS.has(k)) {\n      sawKnown = true;\n    }\n  }\n\n  return sawKnown;\n}\n\n/**\n * Walk a predicate tree and emit every leaf clause with its dotted path.\n * Combinators (`$all` / `$any` / `$not`) become indexed path segments.\n * Bare-value equality (`{ phase: \"red\" }`) emits as `op: \"$eq\"`.\n *\n * Array-form predicates (`[{ fact, op, value }, ...]`) are also accepted —\n * each clause's `fact` becomes the path, the operator is `op`, and the\n * value is `value`.\n *\n * **What gets dropped:** non-object combinator children (e.g. `$not: \"red\"`\n * with a string operand instead of a predicate object), function-form\n * predicates (the engine accepts a function for `when`; this walker only\n * sees data), and bare primitive predicates (a top-level `true` or `\"x\"`).\n * The walker is a tree visitor — anything not shaped like a predicate node\n * is silently skipped, never thrown on.\n */\nexport function flattenPredicate(\n  spec: unknown,\n  pathPrefix = \"\",\n  out: LeafClause[] = [],\n): LeafClause[] {\n  if (spec === null || typeof spec !== \"object\") {\n    // A leaf that isn't an object — odd as a predicate. Skip.\n    return out;\n  }\n\n  // Array-form (PredicateClause[])\n  if (Array.isArray(spec)) {\n    for (const clause of spec) {\n      if (\n        clause &&\n        typeof clause === \"object\" &&\n        \"fact\" in clause &&\n        \"op\" in clause\n      ) {\n        const c = clause as { fact: unknown; op: unknown; value: unknown };\n        out.push({\n          path: pathPrefix\n            ? `${pathPrefix}.${String(c.fact)}`\n            : String(c.fact),\n          op: String(c.op),\n          value: c.value,\n        });\n      }\n    }\n\n    return out;\n  }\n\n  // Combinator nodes\n  if (\"$all\" in spec && Array.isArray((spec as { $all: unknown }).$all)) {\n    const arr = (spec as { $all: unknown[] }).$all;\n    arr.forEach((child, i) => {\n      flattenPredicate(child, `${pathPrefix}$all[${i}]`, out);\n    });\n\n    return out;\n  }\n  if (\"$any\" in spec && Array.isArray((spec as { $any: unknown }).$any)) {\n    const arr = (spec as { $any: unknown[] }).$any;\n    arr.forEach((child, i) => {\n      flattenPredicate(child, `${pathPrefix}$any[${i}]`, out);\n    });\n\n    return out;\n  }\n  if (\"$not\" in spec) {\n    flattenPredicate(\n      (spec as { $not: unknown }).$not,\n      `${pathPrefix}$not`,\n      out,\n    );\n\n    return out;\n  }\n\n  // Object form — walk each key\n  for (const [key, value] of Object.entries(spec as Record<string, unknown>)) {\n    const path = pathPrefix ? `${pathPrefix}.${key}` : key;\n\n    if (isOperatorObject(value)) {\n      for (const [op, operand] of Object.entries(value)) {\n        out.push({ path, op, value: operand });\n      }\n    } else if (isPlainObject(value) && !COMBINATORS.has(key)) {\n      // Nested predicate (cross-module pivot or partial-match object).\n      flattenPredicate(value, path, out);\n    } else {\n      // Bare literal — equality.\n      out.push({ path, op: \"$eq\", value });\n    }\n  }\n\n  return out;\n}\n\n// ============================================================================\n// Direction analysis (relaxed / tightened for numeric thresholds)\n// ============================================================================\n\nfunction isNumeric(v: unknown): v is number {\n  return typeof v === \"number\" && Number.isFinite(v);\n}\n\n/**\n * For numeric-threshold operators, decide whether the new value matches\n * MORE (`relaxed`) or FEWER (`tightened`) fact configurations than the\n * old one. Returns `null` when the operator/operand isn't numeric — the\n * caller falls back to `\"changed\"`.\n */\nfunction directionFor(\n  op: string,\n  before: unknown,\n  after: unknown,\n): \"relaxed\" | \"tightened\" | null {\n  switch (op) {\n    case \"$gte\":\n    case \"$gt\":\n      // Lower bound. Lower = matches more.\n      if (isNumeric(before) && isNumeric(after)) {\n        if (after < before) return \"relaxed\";\n        if (after > before) return \"tightened\";\n      }\n      return null;\n    case \"$lte\":\n    case \"$lt\":\n      // Upper bound. Higher = matches more.\n      if (isNumeric(before) && isNumeric(after)) {\n        if (after > before) return \"relaxed\";\n        if (after < before) return \"tightened\";\n      }\n      return null;\n    case \"$between\": {\n      // [low, high] tuple — width compared.\n      if (\n        Array.isArray(before) &&\n        Array.isArray(after) &&\n        before.length === 2 &&\n        after.length === 2 &&\n        isNumeric(before[0]) &&\n        isNumeric(before[1]) &&\n        isNumeric(after[0]) &&\n        isNumeric(after[1])\n      ) {\n        const widthBefore = before[1] - before[0];\n        const widthAfter = after[1] - after[0];\n        if (widthAfter > widthBefore) return \"relaxed\";\n        if (widthAfter < widthBefore) return \"tightened\";\n      }\n      return null;\n    }\n    case \"$in\":\n    case \"$nin\": {\n      // Set membership. Wider set = relaxed for $in, tightened for $nin.\n      if (Array.isArray(before) && Array.isArray(after)) {\n        if (op === \"$in\") {\n          if (after.length > before.length) return \"relaxed\";\n          if (after.length < before.length) return \"tightened\";\n        } else {\n          if (after.length > before.length) return \"tightened\";\n          if (after.length < before.length) return \"relaxed\";\n        }\n      }\n      return null;\n    }\n    case \"$contains\": {\n      // For array operands, more allowed elements = relaxed (matches more\n      // facts). For string operands the direction is ambiguous (a longer\n      // substring narrows the match set; a shorter substring widens it),\n      // so we leave the call to the caller — returns null → \"changed\".\n      if (Array.isArray(before) && Array.isArray(after)) {\n        if (after.length > before.length) return \"relaxed\";\n        if (after.length < before.length) return \"tightened\";\n      }\n      return null;\n    }\n    default:\n      return null;\n  }\n}\n\n// ============================================================================\n// Public API\n// ============================================================================\n\n/**\n * Diff two snapshots of a system's constraint whenSpec map.\n *\n * @example\n * ```ts\n * const report = diffRules({\n *   before: { blockCheckout: { cartTotal: { $gte: 100 } } },\n *   after:  { blockCheckout: { cartTotal: { $gte: 50 } } },\n * });\n *\n * report.constraints[0].status;          // \"changed\"\n * report.constraints[0].changes[0].kind; // \"relaxed\"\n * report.summary.totalClauseChanges;     // 1\n * ```\n *\n * The input shape is forgiving — either a flat `{ id: whenSpec }` map, the\n * `system.inspect().constraints` array form, or either wrapped as\n * `{ constraints: ... }`. Constraints whose `when` is a function (no\n * `whenSpec`) are tracked as added/removed but cannot be clause-diffed\n * (the function form is opaque).\n */\nexport function diffRules(options: DiffRulesOptions): RulesDiffReport {\n  const before = toRulesMap(options.before);\n  const after = toRulesMap(options.after);\n\n  const allIds = new Set([...Object.keys(before), ...Object.keys(after)]);\n  const sortedIds = [...allIds].sort();\n\n  const constraints: ConstraintDiff[] = [];\n  const summary = {\n    added: 0,\n    removed: 0,\n    changed: 0,\n    unchanged: 0,\n    totalClauseChanges: 0,\n  };\n\n  for (const id of sortedIds) {\n    const b = before[id];\n    const a = after[id];\n    const hasB = id in before;\n    const hasA = id in after;\n\n    if (hasB && !hasA) {\n      const clauses = flattenPredicate(b);\n      const changes: Change[] =\n        clauses.length === 0\n          ? // Function-form / opaque whenSpec — flatten yields nothing.\n            // Emit one placeholder so renderers can show *something* and\n            // the summary's totalClauseChanges stays non-zero for the\n            // removed constraint.\n            [{ path: \"(function-form predicate)\", kind: \"removed\" }]\n          : clauses.map((c) => ({\n              path: c.path,\n              kind: \"removed\",\n              before: { op: c.op, value: c.value },\n            }));\n      sortChanges(changes);\n      constraints.push({ id, status: \"removed\", changes });\n      summary.removed++;\n      summary.totalClauseChanges += changes.length;\n      continue;\n    }\n\n    if (!hasB && hasA) {\n      const clauses = flattenPredicate(a);\n      const changes: Change[] =\n        clauses.length === 0\n          ? [{ path: \"(function-form predicate)\", kind: \"added\" }]\n          : clauses.map((c) => ({\n              path: c.path,\n              kind: \"added\",\n              after: { op: c.op, value: c.value },\n            }));\n      sortChanges(changes);\n      constraints.push({ id, status: \"added\", changes });\n      summary.added++;\n      summary.totalClauseChanges += changes.length;\n      continue;\n    }\n\n    // Both sides have it — clause-level diff.\n    const changes = diffClauses(b, a);\n    if (changes.length === 0) {\n      constraints.push({ id, status: \"unchanged\", changes: [] });\n      summary.unchanged++;\n    } else {\n      constraints.push({ id, status: \"changed\", changes });\n      summary.changed++;\n      summary.totalClauseChanges += changes.length;\n    }\n  }\n\n  return { constraints, summary };\n}\n\n/**\n * Diff two predicate trees and return the list of leaf-level changes.\n * Exported for reuse beyond the full per-constraint report.\n */\nexport function diffClauses(before: unknown, after: unknown): Change[] {\n  // Function-form predicates (anything not walkable) → skip clause walk,\n  // but report a single \"changed\" placeholder so callers see something\n  // happened at this constraint.\n  if (\n    before !== undefined &&\n    after !== undefined &&\n    (before === null ||\n      after === null ||\n      typeof before !== \"object\" ||\n      typeof after !== \"object\")\n  ) {\n    return stableStringify(before) === stableStringify(after)\n      ? []\n      : [\n          {\n            path: \"\",\n            kind: \"changed\",\n            before: { op: \"$eq\", value: before },\n            after: { op: \"$eq\", value: after },\n          },\n        ];\n  }\n\n  const flatB = before === undefined ? [] : flattenPredicate(before);\n  const flatA = after === undefined ? [] : flattenPredicate(after);\n\n  // Key by `path + op` so two different operators on the same path (rare\n  // but possible in the array form) are tracked independently.\n  const keyOf = (c: LeafClause) => `${c.path}::${c.op}`;\n\n  const mapB = new Map<string, LeafClause>(flatB.map((c) => [keyOf(c), c]));\n  const mapA = new Map<string, LeafClause>(flatA.map((c) => [keyOf(c), c]));\n\n  const allKeys = new Set([...mapB.keys(), ...mapA.keys()]);\n  const changes: Change[] = [];\n\n  for (const key of allKeys) {\n    const b = mapB.get(key);\n    const a = mapA.get(key);\n\n    if (b && !a) {\n      changes.push({\n        path: b.path,\n        kind: \"removed\",\n        before: { op: b.op, value: b.value },\n      });\n      continue;\n    }\n    if (!b && a) {\n      changes.push({\n        path: a.path,\n        kind: \"added\",\n        after: { op: a.op, value: a.value },\n      });\n      continue;\n    }\n    if (b && a) {\n      if (stableStringify(b.value) === stableStringify(a.value)) {\n        continue;\n      }\n      const direction = directionFor(b.op, b.value, a.value);\n      changes.push({\n        path: b.path,\n        kind: direction ?? \"changed\",\n        before: { op: b.op, value: b.value },\n        after: { op: a.op, value: a.value },\n      });\n    }\n  }\n\n  sortChanges(changes);\n\n  return changes;\n}\n\n/**\n * Deterministic ordering for change lists: primary key is path, secondary\n * is operator (so two clauses sharing a path — possible in the array form\n * with multiple operators on one fact — order stably). Two byte-identical\n * inputs always produce byte-identical outputs.\n */\nfunction sortChanges(changes: Change[]): void {\n  changes.sort((x, y) => {\n    const p = x.path.localeCompare(y.path);\n    if (p !== 0) return p;\n    const xo = x.before?.op ?? x.after?.op ?? \"\";\n    const yo = y.before?.op ?? y.after?.op ?? \"\";\n\n    return xo.localeCompare(yo);\n  });\n}\n","/**\n * Compile a `FactPredicate` to a parameterized Postgres-style SQL WHERE\n * clause. The same predicate that gates a constraint on the client can\n * filter rows on the server — *one source of truth, two execution sites*.\n *\n * Pure transformation. No engine, no driver, no string concatenation of\n * user values (all operands flow through the parameter array → safe\n * against SQL injection by construction).\n */\n\nimport { MAX_PREDICATE_DEPTH } from \"./predicate.js\";\nimport {\n  PREDICATE_OPERATORS,\n  type FactPredicate,\n} from \"./types/predicate.js\";\n\n// ============================================================================\n// Types\n// ============================================================================\n\nexport interface PredicateToSqlOptions {\n  /** Table to query. Validated against the same identifier rule as columns. */\n  table: string;\n  /**\n   * Allowlist of fact / column keys the predicate may reference. STRONGLY\n   * RECOMMENDED for any predicate that crosses a trust boundary (AI\n   * generation, user input, JSON-over-the-wire). Without an allowlist, a\n   * predicate may reference any column the table has.\n   */\n  allowedKeys?: readonly string[];\n  /**\n   * Customize the `SELECT` projection. Default `\"*\"`. Accepts:\n   *   - `\"*\"`\n   *   - a column identifier (`\"id\"` or `\"users.id\"`)\n   *   - an array of column identifiers (`[\"id\", \"name\"]`) — joined with `,`\n   * Free-form strings (e.g. `\"COUNT(*)\"`) are rejected — build the wrapper\n   * SQL manually with {@link predicateToWhere} for those cases.\n   */\n  select?: string | readonly string[];\n  /**\n   * Parameter placeholder generator. Default is Postgres-style `$1`, `$2`.\n   * Pass `() => \"?\"` for MySQL/SQLite, or supply your own scheme.\n   */\n  placeholder?: (oneBasedIndex: number) => string;\n}\n\nexport interface PredicateToSqlResult {\n  /** Full `SELECT … FROM table WHERE …` statement. */\n  sql: string;\n  /** Just the `WHERE` clause body (without the literal `WHERE`). */\n  where: string;\n  /** Parameters, in `$1`-then-`$2`-then-… order. */\n  params: unknown[];\n}\n\n// ============================================================================\n// Identifier safety\n// ============================================================================\n\n/**\n * Strict identifier check: alpha, digits, underscore, optional dot for\n * qualified names (`table.column`). No whitespace, no quotes, no\n * semicolons — anything not matching is rejected with a clear error.\n *\n * Identifiers are interpolated *literally* into the SQL string (the only\n * safe alternative is double-quoting, which changes case sensitivity).\n * This regex is the only thing standing between a column-name typo and a\n * SQL injection — keep it strict.\n */\nconst IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)?$/;\n\nfunction assertIdentifier(name: string, kind: \"table\" | \"column\"): void {\n  if (typeof name !== \"string\" || !IDENT_RE.test(name)) {\n    throw new Error(\n      `[Directive] predicateToSQL: invalid ${kind} identifier \"${name}\" — must match /^[A-Za-z_][A-Za-z0-9_]*(\\\\.[A-Za-z_][A-Za-z0-9_]*)?$/`,\n    );\n  }\n}\n\nfunction assertAllowed(\n  name: string,\n  allowed: readonly string[] | undefined,\n): void {\n  if (allowed && !allowed.includes(name)) {\n    throw new Error(\n      `[Directive] predicateToSQL: column \"${name}\" is not in the allowedKeys list — add it to options.allowedKeys or remove it from the predicate`,\n    );\n  }\n}\n\nfunction validateSelect(select: string | readonly string[]): string {\n  if (Array.isArray(select)) {\n    if (select.length === 0) {\n      throw new Error(`[Directive] predicateToSQL: select must not be empty`);\n    }\n    for (const col of select) {\n      assertIdentifier(col, \"column\");\n    }\n\n    return select.join(\", \");\n  }\n  const s = select as string;\n  if (s === \"*\") return \"*\";\n  assertIdentifier(s, \"column\");\n\n  return s;\n}\n\n// ============================================================================\n// Operator translation\n// ============================================================================\n\ninterface BuildContext {\n  params: unknown[];\n  placeholder: (i: number) => string;\n  allowed?: readonly string[];\n}\n\nfunction nextParam(ctx: BuildContext, value: unknown): string {\n  ctx.params.push(value);\n\n  return ctx.placeholder(ctx.params.length);\n}\n\n/**\n * Render one operator on one column. `column` is already\n * identifier-validated; the operand goes through `nextParam` so it lands\n * in `params`, never in the SQL string.\n */\nfunction renderOp(\n  column: string,\n  op: string,\n  operand: unknown,\n  ctx: BuildContext,\n): string {\n  switch (op) {\n    case \"$eq\":\n      return `${column} = ${nextParam(ctx, operand)}`;\n    case \"$ne\":\n      return `${column} <> ${nextParam(ctx, operand)}`;\n    case \"$gt\":\n      return `${column} > ${nextParam(ctx, operand)}`;\n    case \"$gte\":\n      return `${column} >= ${nextParam(ctx, operand)}`;\n    case \"$lt\":\n      return `${column} < ${nextParam(ctx, operand)}`;\n    case \"$lte\":\n      return `${column} <= ${nextParam(ctx, operand)}`;\n    case \"$in\":\n      if (!Array.isArray(operand)) {\n        throw new Error(`[Directive] predicateToSQL: $in operand must be an array`);\n      }\n      return `${column} = ANY(${nextParam(ctx, operand)})`;\n    case \"$nin\":\n      if (!Array.isArray(operand)) {\n        throw new Error(`[Directive] predicateToSQL: $nin operand must be an array`);\n      }\n      return `NOT (${column} = ANY(${nextParam(ctx, operand)}))`;\n    case \"$exists\":\n      return operand === true ? `${column} IS NOT NULL` : `${column} IS NULL`;\n    case \"$between\": {\n      if (!Array.isArray(operand) || operand.length !== 2) {\n        throw new Error(\n          `[Directive] predicateToSQL: $between operand must be a [low, high] tuple`,\n        );\n      }\n      return `${column} BETWEEN ${nextParam(ctx, operand[0])} AND ${nextParam(ctx, operand[1])}`;\n    }\n    case \"$startsWith\":\n      if (typeof operand !== \"string\") {\n        throw new Error(\n          `[Directive] predicateToSQL: $startsWith operand must be a string`,\n        );\n      }\n      // ESCAPE '\\' makes the escape character deterministic regardless of\n      // the server's standard_conforming_strings setting or MySQL's\n      // NO_BACKSLASH_ESCAPES mode.\n      return `${column} LIKE ${nextParam(ctx, escapeLike(operand))} || '%' ESCAPE '\\\\'`;\n    case \"$endsWith\":\n      if (typeof operand !== \"string\") {\n        throw new Error(\n          `[Directive] predicateToSQL: $endsWith operand must be a string`,\n        );\n      }\n      return `${column} LIKE '%' || ${nextParam(ctx, escapeLike(operand))} ESCAPE '\\\\'`;\n    case \"$contains\":\n      if (typeof operand !== \"string\") {\n        throw new Error(\n          `[Directive] predicateToSQL: $contains only supports string operands — array containment requires a JOIN, not a predicate`,\n        );\n      }\n      return `${column} LIKE '%' || ${nextParam(ctx, escapeLike(operand))} || '%' ESCAPE '\\\\'`;\n    case \"$matches\": {\n      if (!(operand instanceof RegExp)) {\n        throw new Error(\n          `[Directive] predicateToSQL: $matches operand must be a RegExp`,\n        );\n      }\n      // Postgres uses ~ (case-sensitive) and ~* (case-insensitive). The\n      // RegExp's `i` flag picks the operator; other flags are silently\n      // dropped because their semantics differ between JS and Postgres.\n      const operator = operand.flags.includes(\"i\") ? \"~*\" : \"~\";\n\n      return `${column} ${operator} ${nextParam(ctx, operand.source)}`;\n    }\n    case \"$changed\":\n      throw new Error(\n        `[Directive] predicateToSQL: $changed is an effects-only operator — no server-side translation (a database row has no \"prev\" snapshot)`,\n      );\n    default:\n      throw new Error(\n        `[Directive] predicateToSQL: unknown operator \"${op}\" — known: ${[...PREDICATE_OPERATORS].join(\", \")}`,\n      );\n  }\n}\n\n/**\n * Escape `%`, `_`, and `\\` in a LIKE operand. Paired with an explicit\n * `ESCAPE '\\'` clause for cross-database determinism.\n */\nfunction escapeLike(s: string): string {\n  return s.replace(/[\\\\%_]/g, \"\\\\$&\");\n}\n\n// ============================================================================\n// Recursive walk\n// ============================================================================\n\nfunction isPlainObject(v: unknown): v is Record<string, unknown> {\n  return v !== null && typeof v === \"object\" && !Array.isArray(v);\n}\n\nfunction isOperatorObject(v: unknown): v is Record<string, unknown> {\n  if (!isPlainObject(v)) return false;\n  const keys = Object.keys(v);\n  if (keys.length === 0) return false;\n  for (const k of keys) {\n    if (!k.startsWith(\"$\")) return false;\n  }\n\n  return true;\n}\n\nfunction assertNoSiblingKeys(spec: Record<string, unknown>, combinator: string): void {\n  const sibs = Object.keys(spec).filter((k) => k !== combinator);\n  if (sibs.length > 0) {\n    throw new Error(\n      `[Directive] predicateToSQL: ${combinator} cannot coexist with sibling keys (${sibs.join(\", \")}) — wrap them in $all together, or move them inside the ${combinator} children`,\n    );\n  }\n}\n\nfunction buildWhere(spec: unknown, ctx: BuildContext, depth: number): string {\n  if (depth > MAX_PREDICATE_DEPTH) {\n    throw new Error(\n      `[Directive] predicateToSQL: predicate depth limit (${MAX_PREDICATE_DEPTH}) exceeded — flatten the predicate or check for a cyclic spec object`,\n    );\n  }\n  if (spec === null || typeof spec !== \"object\") {\n    throw new Error(\n      `[Directive] predicateToSQL: predicate must be an object or array, got ${typeof spec}`,\n    );\n  }\n\n  // Array-form predicate ([{fact, op, value}, ...]) — implicit AND.\n  if (Array.isArray(spec)) {\n    if (spec.length === 0) return \"TRUE\";\n    const parts = spec.map((clause) => {\n      if (\n        !clause ||\n        typeof clause !== \"object\" ||\n        !(\"fact\" in clause) ||\n        !(\"op\" in clause)\n      ) {\n        throw new Error(\n          `[Directive] predicateToSQL: array-form clause must be { fact, op, value }`,\n        );\n      }\n      const c = clause as { fact: string; op: string; value: unknown };\n      assertIdentifier(c.fact, \"column\");\n      assertAllowed(c.fact, ctx.allowed);\n\n      return renderOp(c.fact, c.op, c.value, ctx);\n    });\n\n    return parts.length === 1 ? parts[0]! : `(${parts.join(\" AND \")})`;\n  }\n\n  // Combinators — must be the *only* key on the object.\n  if (\"$all\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$all\");\n    const arr = (spec as { $all: unknown[] }).$all;\n    if (!Array.isArray(arr)) {\n      throw new Error(`[Directive] predicateToSQL: $all must be an array`);\n    }\n    if (arr.length === 0) return \"TRUE\";\n    const parts = arr.map((p) => buildWhere(p, ctx, depth + 1));\n\n    return parts.length === 1 ? parts[0]! : `(${parts.join(\" AND \")})`;\n  }\n  if (\"$any\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$any\");\n    const arr = (spec as { $any: unknown[] }).$any;\n    if (!Array.isArray(arr)) {\n      throw new Error(`[Directive] predicateToSQL: $any must be an array`);\n    }\n    if (arr.length === 0) return \"FALSE\";\n    const parts = arr.map((p) => buildWhere(p, ctx, depth + 1));\n\n    return parts.length === 1 ? parts[0]! : `(${parts.join(\" OR \")})`;\n  }\n  if (\"$not\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$not\");\n    const inner = (spec as { $not: unknown }).$not;\n\n    return `NOT (${buildWhere(inner, ctx, depth + 1)})`;\n  }\n\n  // Object form — every key is a column, every value either a literal\n  // (equality) or an operator object.\n  const parts: string[] = [];\n  for (const [key, value] of Object.entries(spec as Record<string, unknown>)) {\n    assertIdentifier(key, \"column\");\n    assertAllowed(key, ctx.allowed);\n\n    if (isOperatorObject(value)) {\n      for (const [op, operand] of Object.entries(value)) {\n        if (!PREDICATE_OPERATORS.has(op)) {\n          throw new Error(\n            `[Directive] predicateToSQL: unknown operator \"${op}\" on column \"${key}\" — known: ${[...PREDICATE_OPERATORS].join(\", \")}`,\n          );\n        }\n        parts.push(renderOp(key, op, operand, ctx));\n      }\n    } else if (isPlainObject(value)) {\n      throw new Error(\n        `[Directive] predicateToSQL: nested predicate at \"${key}\" — cross-module / partial-match predicates have no SQL equivalent (single-table queries only in v1; pass a flat predicate or build JOIN by hand with predicateToWhere)`,\n      );\n    } else {\n      parts.push(renderOp(key, \"$eq\", value, ctx));\n    }\n  }\n\n  if (parts.length === 0) return \"TRUE\";\n  if (parts.length === 1) return parts[0]!;\n\n  return `(${parts.join(\" AND \")})`;\n}\n\n// ============================================================================\n// Public API\n// ============================================================================\n\nconst DEFAULT_PLACEHOLDER = (i: number) => `$${i}`;\n\n/**\n * Compile a {@link FactPredicate} to a parameterized SQL statement.\n *\n * Operand values **never** appear in the SQL string — they flow through\n * the `params` array. Table and column identifiers are regex-validated.\n *\n * @example\n * ```ts\n * const where = { age: { $gte: 18 }, status: { $in: [\"active\", \"pending\"] } };\n *\n * predicateToSQL(where, { table: \"users\" });\n * // → { sql: \"SELECT * FROM users WHERE (age >= $1 AND status = ANY($2))\",\n * //     where: \"(age >= $1 AND status = ANY($2))\",\n * //     params: [18, [\"active\", \"pending\"]] }\n *\n * // MySQL/SQLite placeholder:\n * predicateToSQL(where, { table: \"users\", placeholder: () => \"?\" });\n *\n * // Recommended for AI/user-supplied predicates:\n * predicateToSQL(where, { table: \"users\", allowedKeys: [\"age\", \"status\"] });\n * ```\n */\nexport function predicateToSQL<F = Record<string, unknown>>(\n  predicate: FactPredicate<F>,\n  options: PredicateToSqlOptions,\n): PredicateToSqlResult {\n  const { table, allowedKeys } = options;\n  const placeholder = options.placeholder ?? DEFAULT_PLACEHOLDER;\n  const select = options.select ?? \"*\";\n\n  assertIdentifier(table, \"table\");\n  const projection = validateSelect(select);\n\n  const ctx: BuildContext = { params: [], placeholder, allowed: allowedKeys };\n  const where = buildWhere(predicate, ctx, 0);\n  const sql = `SELECT ${projection} FROM ${table} WHERE ${where}`;\n\n  return { sql, where, params: ctx.params };\n}\n\n/**\n * Lower-level variant — returns just the `WHERE` clause body and the\n * `params` array, no `SELECT ... FROM` wrapper. Use this when you need\n * to embed the WHERE in a larger query (JOIN, UPDATE, DELETE, COUNT).\n *\n * @example\n * ```ts\n * const { where, params } = predicateToWhere({ age: { $gte: 18 } });\n * await db.query(`UPDATE users SET tier = 'adult' WHERE ${where}`, params);\n * ```\n */\nexport function predicateToWhere<F = Record<string, unknown>>(\n  predicate: FactPredicate<F>,\n  options: Omit<PredicateToSqlOptions, \"table\" | \"select\"> = {},\n): { where: string; params: unknown[] } {\n  const placeholder = options.placeholder ?? DEFAULT_PLACEHOLDER;\n  const ctx: BuildContext = {\n    params: [],\n    placeholder,\n    allowed: options.allowedKeys,\n  };\n\n  return { where: buildWhere(predicate, ctx, 0), params: ctx.params };\n}\n","/**\n * Compile a `FactPredicate` to a MongoDB query document. Most of\n * Directive's predicate operator set is already Mongo-compatible by\n * design — this translator handles the few ops that need rewriting\n * (`$startsWith`/`$endsWith`/`$contains` → `$regex`, `$between` →\n * `$gte`+`$lte`, `$matches` → `$regex`/`$options`).\n *\n * Combinators map cleanly: `$all` → `$and`, `$any` → `$or`, `$not` → `$nor`.\n *\n * Pure transformation. No driver dependency.\n */\n\nimport { MAX_PREDICATE_DEPTH } from \"./predicate.js\";\nimport {\n  PREDICATE_OPERATORS,\n  type FactPredicate,\n} from \"./types/predicate.js\";\n\nexport interface PredicateToMongoOptions {\n  /**\n   * Allowlist of fact / field keys the predicate may reference. STRONGLY\n   * RECOMMENDED for any predicate that crosses a trust boundary.\n   */\n  allowedKeys?: readonly string[];\n  /**\n   * Allow `.` in field names (for sub-document traversal: `\"user.role\"`).\n   * Default is `false` — `.` is rejected so the predicate cannot\n   * accidentally read sub-document fields the developer did not anticipate.\n   */\n  allowDottedPaths?: boolean;\n}\n\nfunction escapeRegex(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\nfunction isPlainObject(v: unknown): v is Record<string, unknown> {\n  return v !== null && typeof v === \"object\" && !Array.isArray(v);\n}\n\nfunction isOperatorObject(v: unknown): v is Record<string, unknown> {\n  if (!isPlainObject(v)) return false;\n  const keys = Object.keys(v);\n  if (keys.length === 0) return false;\n  for (const k of keys) {\n    if (!k.startsWith(\"$\")) return false;\n  }\n\n  return true;\n}\n\nconst FIELD_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;\nconst FIELD_DOTTED_RE = /^[A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)*$/;\n\n/**\n * Reject any field that starts with `$` — that's how Mongo's `$where`\n * JavaScript-evaluation injection lands a predicate-as-RCE. Also reject\n * non-identifier characters (`.`, ` `, etc.) unless dotted paths are\n * explicitly enabled.\n */\nfunction assertFieldName(name: string, opts: PredicateToMongoOptions): void {\n  if (typeof name !== \"string\" || name.length === 0) {\n    throw new Error(\n      `[Directive] predicateToMongo: field name must be a non-empty string, got ${typeof name}`,\n    );\n  }\n  if (name.startsWith(\"$\")) {\n    throw new Error(\n      `[Directive] predicateToMongo: field name \"${name}\" starts with \"$\" — reserved for Mongo operators (a top-level $where would be an injection vector)`,\n    );\n  }\n  const re = opts.allowDottedPaths ? FIELD_DOTTED_RE : FIELD_RE;\n  if (!re.test(name)) {\n    throw new Error(\n      `[Directive] predicateToMongo: invalid field name \"${name}\"${opts.allowDottedPaths ? \"\" : ' — pass options.allowDottedPaths=true to permit sub-document paths like \"user.role\"'}`,\n    );\n  }\n}\n\nfunction assertAllowed(\n  field: string,\n  allowed: readonly string[] | undefined,\n): void {\n  if (allowed && !allowed.includes(field)) {\n    throw new Error(\n      `[Directive] predicateToMongo: field \"${field}\" is not in the allowedKeys list — add it to options.allowedKeys or remove it from the predicate`,\n    );\n  }\n}\n\nfunction assertNoSiblingKeys(spec: Record<string, unknown>, combinator: string): void {\n  const sibs = Object.keys(spec).filter((k) => k !== combinator);\n  if (sibs.length > 0) {\n    throw new Error(\n      `[Directive] predicateToMongo: ${combinator} cannot coexist with sibling keys (${sibs.join(\", \")}) — wrap them in $all together, or move them inside the ${combinator} children`,\n    );\n  }\n}\n\n/**\n * Translate a single operator/operand pair into the Mongo equivalent.\n * Returns the value side of `{ field: <here> }`.\n */\nfunction translateOp(op: string, operand: unknown): Record<string, unknown> {\n  switch (op) {\n    case \"$eq\":\n    case \"$ne\":\n    case \"$gt\":\n    case \"$gte\":\n    case \"$lt\":\n    case \"$lte\":\n    case \"$in\":\n    case \"$nin\":\n    case \"$exists\":\n      return { [op]: operand };\n    case \"$between\": {\n      if (!Array.isArray(operand) || operand.length !== 2) {\n        throw new Error(\n          `[Directive] predicateToMongo: $between operand must be a [low, high] tuple`,\n        );\n      }\n      return { $gte: operand[0], $lte: operand[1] };\n    }\n    case \"$startsWith\":\n      if (typeof operand !== \"string\") {\n        throw new Error(\n          `[Directive] predicateToMongo: $startsWith operand must be a string`,\n        );\n      }\n      return { $regex: `^${escapeRegex(operand)}` };\n    case \"$endsWith\":\n      if (typeof operand !== \"string\") {\n        throw new Error(\n          `[Directive] predicateToMongo: $endsWith operand must be a string`,\n        );\n      }\n      return { $regex: `${escapeRegex(operand)}$` };\n    case \"$contains\":\n      if (typeof operand === \"string\") {\n        return { $regex: escapeRegex(operand) };\n      }\n      throw new Error(\n        `[Directive] predicateToMongo: $contains in Mongo expects a string operand — for array element membership use $elemMatch or $in directly`,\n      );\n    case \"$matches\": {\n      if (operand instanceof RegExp) {\n        return operand.flags\n          ? { $regex: operand.source, $options: operand.flags }\n          : { $regex: operand.source };\n      }\n      if (typeof operand === \"string\") {\n        return { $regex: operand };\n      }\n      throw new Error(\n        `[Directive] predicateToMongo: $matches operand must be a RegExp or string`,\n      );\n    }\n    case \"$changed\":\n      throw new Error(\n        `[Directive] predicateToMongo: $changed is an effects-only operator — no MongoDB query equivalent`,\n      );\n    default:\n      throw new Error(\n        `[Directive] predicateToMongo: unknown operator \"${op}\" — known: ${[...PREDICATE_OPERATORS].join(\", \")}`,\n      );\n  }\n}\n\nfunction buildQuery(\n  spec: unknown,\n  opts: PredicateToMongoOptions,\n  depth: number,\n): Record<string, unknown> {\n  if (depth > MAX_PREDICATE_DEPTH) {\n    throw new Error(\n      `[Directive] predicateToMongo: predicate depth limit (${MAX_PREDICATE_DEPTH}) exceeded — flatten the predicate or check for a cyclic spec object`,\n    );\n  }\n  if (spec === null || typeof spec !== \"object\") {\n    throw new Error(\n      `[Directive] predicateToMongo: predicate must be an object or array, got ${typeof spec}`,\n    );\n  }\n\n  // Array form → implicit AND.\n  if (Array.isArray(spec)) {\n    if (spec.length === 0) return {};\n    const obj: Record<string, unknown> = {};\n    const conflicts: Array<Record<string, unknown>> = [];\n    for (const clause of spec) {\n      if (\n        !clause ||\n        typeof clause !== \"object\" ||\n        !(\"fact\" in clause) ||\n        !(\"op\" in clause)\n      ) {\n        throw new Error(\n          `[Directive] predicateToMongo: array-form clause must be { fact, op, value }`,\n        );\n      }\n      const c = clause as { fact: string; op: string; value: unknown };\n      assertFieldName(c.fact, opts);\n      assertAllowed(c.fact, opts.allowedKeys);\n      const translated = translateOp(c.op, c.value);\n\n      if (c.fact in obj && isPlainObject(obj[c.fact])) {\n        const existing = obj[c.fact] as Record<string, unknown>;\n        const overlap = Object.keys(translated).some((k) => k in existing);\n        if (overlap) {\n          conflicts.push({ [c.fact]: translated });\n        } else {\n          obj[c.fact] = { ...existing, ...translated };\n        }\n      } else if (c.fact in obj) {\n        conflicts.push({ [c.fact]: translated });\n      } else {\n        obj[c.fact] = translated;\n      }\n    }\n    if (conflicts.length > 0) {\n      const andClauses: Array<Record<string, unknown>> = [];\n      for (const [k, v] of Object.entries(obj)) {\n        andClauses.push({ [k]: v });\n      }\n      andClauses.push(...conflicts);\n\n      return { $and: andClauses };\n    }\n\n    return obj;\n  }\n\n  // Combinators\n  if (\"$all\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$all\");\n    const arr = (spec as { $all: unknown[] }).$all;\n    if (!Array.isArray(arr)) {\n      throw new Error(`[Directive] predicateToMongo: $all must be an array`);\n    }\n    if (arr.length === 0) return {};\n    if (arr.length === 1) return buildQuery(arr[0], opts, depth + 1);\n\n    return { $and: arr.map((p) => buildQuery(p, opts, depth + 1)) };\n  }\n  if (\"$any\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$any\");\n    const arr = (spec as { $any: unknown[] }).$any;\n    if (!Array.isArray(arr)) {\n      throw new Error(`[Directive] predicateToMongo: $any must be an array`);\n    }\n    // Tautological-false — stable across Mongo versions, no _id assumption.\n    if (arr.length === 0) return { $expr: { $eq: [1, 0] } };\n    if (arr.length === 1) return buildQuery(arr[0], opts, depth + 1);\n\n    return { $or: arr.map((p) => buildQuery(p, opts, depth + 1)) };\n  }\n  if (\"$not\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$not\");\n    const inner = (spec as { $not: unknown }).$not;\n    // Mongo's top-level $not is restricted to per-field; $nor: [...]\n    // is the portable equivalent.\n    return { $nor: [buildQuery(inner, opts, depth + 1)] };\n  }\n\n  // Object form — every key is a field name (validated to NOT start with $).\n  const out: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(spec as Record<string, unknown>)) {\n    assertFieldName(key, opts);\n    assertAllowed(key, opts.allowedKeys);\n\n    if (isOperatorObject(value)) {\n      const merged: Record<string, unknown> = {};\n      for (const [op, operand] of Object.entries(value)) {\n        if (!PREDICATE_OPERATORS.has(op)) {\n          throw new Error(\n            `[Directive] predicateToMongo: unknown operator \"${op}\" on field \"${key}\" — known: ${[...PREDICATE_OPERATORS].join(\", \")}`,\n          );\n        }\n        Object.assign(merged, translateOp(op, operand));\n      }\n      out[key] = merged;\n    } else if (isPlainObject(value)) {\n      out[key] = value;\n    } else {\n      out[key] = value;\n    }\n  }\n\n  return out;\n}\n\n/**\n * Compile a {@link FactPredicate} to a MongoDB query document.\n *\n * Field names are validated to NOT start with `$` (which would land\n * `$where` and other server-side JS evaluation operators directly in the\n * query — an injection vector for AI/user-generated predicates).\n *\n * @example\n * ```ts\n * predicateToMongo({ age: { $gte: 18 }, status: { $in: [\"active\", \"pending\"] } })\n * // → { age: { $gte: 18 }, status: { $in: [\"active\", \"pending\"] } }\n *\n * predicateToMongo({ name: { $startsWith: \"Al\" } })\n * // → { name: { $regex: \"^Al\" } }\n *\n * predicateToMongo({ $any: [{ tier: \"gold\" }, { score: { $gte: 100 } }] })\n * // → { $or: [{ tier: \"gold\" }, { score: { $gte: 100 } }] }\n * ```\n */\nexport function predicateToMongo<F = Record<string, unknown>>(\n  predicate: FactPredicate<F>,\n  options: PredicateToMongoOptions = {},\n): Record<string, unknown> {\n  return buildQuery(predicate, options, 0);\n}\n","/**\n * Compile a `FactPredicate` to a PostgREST querystring.\n *\n * PostgREST's filter grammar is column-scoped: `?age=gte.18&status=in.(active,pending)`.\n * Logical groups use `and=(...)` / `or=(...)` / `not.and=(...)`.\n *\n * Reference: https://postgrest.org/en/stable/api.html#operators\n */\n\nimport { MAX_PREDICATE_DEPTH } from \"./predicate.js\";\nimport {\n  PREDICATE_OPERATORS,\n  type FactPredicate,\n} from \"./types/predicate.js\";\n\nexport interface PredicateToPostgrestOptions {\n  /** Allowlist of column keys the predicate may reference. */\n  allowedKeys?: readonly string[];\n  /**\n   * Encoding mode for the returned string.\n   *  - `\"querystring\"` (default): a full querystring without a leading `?`,\n   *    with each clause value URL-encoded — drops straight into `fetch`.\n   *  - `\"raw\"`: the same content, leaving `(`, `)`, `,` unencoded for\n   *    readability. Use this only when you'll encode the result yourself.\n   */\n  mode?: \"querystring\" | \"raw\";\n}\n\nconst IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;\n\nfunction assertColumn(name: string, allowed?: readonly string[]): void {\n  if (typeof name !== \"string\" || !IDENT_RE.test(name)) {\n    throw new Error(\n      `[Directive] predicateToPostgrest: invalid column identifier \"${name}\"`,\n    );\n  }\n  if (allowed && !allowed.includes(name)) {\n    throw new Error(\n      `[Directive] predicateToPostgrest: column \"${name}\" is not in the allowedKeys list — add it to options.allowedKeys or remove it from the predicate`,\n    );\n  }\n}\n\nfunction assertNoSiblingKeys(spec: Record<string, unknown>, combinator: string): void {\n  const sibs = Object.keys(spec).filter((k) => k !== combinator);\n  if (sibs.length > 0) {\n    throw new Error(\n      `[Directive] predicateToPostgrest: ${combinator} cannot coexist with sibling keys (${sibs.join(\", \")}) — wrap them in $all together, or move them inside the ${combinator} children`,\n    );\n  }\n}\n\n/** Encode a single PostgREST value. Strings with reserved chars get quoted. */\nfunction encodeValue(v: unknown): string {\n  if (v === null || v === undefined) return \"null\";\n  if (typeof v === \"boolean\") return v ? \"true\" : \"false\";\n  if (typeof v === \"number\" || typeof v === \"bigint\") return String(v);\n  if (v instanceof Date) return v.toISOString();\n  if (typeof v === \"string\") {\n    // PostgREST treats `,` `.` `(` `)` and `:` as syntax; quote any\n    // string containing them. Inside quotes, `\"` → `\\\"` and `\\` → `\\\\`.\n    if (/[,.():\"\\\\\\s]/.test(v)) {\n      return `\"${v.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"')}\"`;\n    }\n\n    return v;\n  }\n  throw new Error(\n    `[Directive] predicateToPostgrest: cannot encode value of type ${typeof v}`,\n  );\n}\n\nfunction encodeList(arr: readonly unknown[]): string {\n  return `(${arr.map(encodeValue).join(\",\")})`;\n}\n\n/** Escape `\\`, `%`, `_`, `*` so they match literally instead of as wildcards. */\nfunction escapeLikeOperand(s: string): string {\n  return s.replace(/[\\\\%_*]/g, \"\\\\$&\");\n}\n\n/**\n * Render the value side of one operator. Returns a string like\n * `gte.18` or `in.(a,b)` — without the column name.\n */\nfunction renderOp(op: string, operand: unknown): string {\n  switch (op) {\n    case \"$eq\":\n      return `eq.${encodeValue(operand)}`;\n    case \"$ne\":\n      return `neq.${encodeValue(operand)}`;\n    case \"$gt\":\n      return `gt.${encodeValue(operand)}`;\n    case \"$gte\":\n      return `gte.${encodeValue(operand)}`;\n    case \"$lt\":\n      return `lt.${encodeValue(operand)}`;\n    case \"$lte\":\n      return `lte.${encodeValue(operand)}`;\n    case \"$in\":\n      if (!Array.isArray(operand)) {\n        throw new Error(`[Directive] predicateToPostgrest: $in operand must be an array`);\n      }\n      return `in.${encodeList(operand)}`;\n    case \"$nin\":\n      if (!Array.isArray(operand)) {\n        throw new Error(`[Directive] predicateToPostgrest: $nin operand must be an array`);\n      }\n      return `not.in.${encodeList(operand)}`;\n    case \"$exists\":\n      return operand === true ? \"not.is.null\" : \"is.null\";\n    case \"$startsWith\":\n      if (typeof operand !== \"string\") {\n        throw new Error(\n          `[Directive] predicateToPostgrest: $startsWith operand must be a string`,\n        );\n      }\n      return `like.${encodeValue(escapeLikeOperand(operand) + \"*\")}`;\n    case \"$endsWith\":\n      if (typeof operand !== \"string\") {\n        throw new Error(\n          `[Directive] predicateToPostgrest: $endsWith operand must be a string`,\n        );\n      }\n      return `like.${encodeValue(\"*\" + escapeLikeOperand(operand))}`;\n    case \"$contains\":\n      if (typeof operand !== \"string\") {\n        throw new Error(\n          `[Directive] predicateToPostgrest: $contains expects a string operand (array containment is the cs operator with a different shape — out of scope for v1)`,\n        );\n      }\n      return `like.${encodeValue(\"*\" + escapeLikeOperand(operand) + \"*\")}`;\n    case \"$matches\":\n      if (operand instanceof RegExp) {\n        const o = operand.flags.includes(\"i\") ? \"imatch\" : \"match\";\n\n        return `${o}.${encodeValue(operand.source)}`;\n      }\n      if (typeof operand === \"string\") {\n        return `match.${encodeValue(operand)}`;\n      }\n      throw new Error(\n        `[Directive] predicateToPostgrest: $matches operand must be a RegExp or string`,\n      );\n    // $between is handled at the build() level by decomposing into $gte + $lte.\n    case \"$changed\":\n      throw new Error(\n        `[Directive] predicateToPostgrest: $changed is an effects-only operator — no server query equivalent`,\n      );\n    default:\n      throw new Error(\n        `[Directive] predicateToPostgrest: unknown operator \"${op}\" — known: ${[...PREDICATE_OPERATORS].join(\", \")}`,\n      );\n  }\n}\n\nfunction isPlainObject(v: unknown): v is Record<string, unknown> {\n  return v !== null && typeof v === \"object\" && !Array.isArray(v);\n}\n\nfunction isOperatorObject(v: unknown): v is Record<string, unknown> {\n  if (!isPlainObject(v)) return false;\n  const keys = Object.keys(v);\n  if (keys.length === 0) return false;\n  for (const k of keys) {\n    if (!k.startsWith(\"$\")) return false;\n  }\n\n  return true;\n}\n\nfunction colClause(column: string, opAndValue: string): string {\n  return `${column}=${opAndValue}`;\n}\n\nfunction groupClause(\n  logical: \"and\" | \"or\" | \"not.and\" | \"not.or\",\n  parts: string[],\n): string {\n  return `${logical}=(${parts.join(\",\")})`;\n}\n\n/**\n * Render one operator inside one column. For `$between`, decomposes into\n * two clauses ($gte + $lte) so the predicate's portability promise holds.\n */\nfunction renderColumnOps(\n  column: string,\n  op: string,\n  operand: unknown,\n  atTop: boolean,\n): string[] {\n  if (op === \"$between\") {\n    if (!Array.isArray(operand) || operand.length !== 2) {\n      throw new Error(\n        `[Directive] predicateToPostgrest: $between operand must be a [low, high] tuple`,\n      );\n    }\n    const lo = atTop\n      ? colClause(column, renderOp(\"$gte\", operand[0]))\n      : `${column}.${renderOp(\"$gte\", operand[0])}`;\n    const hi = atTop\n      ? colClause(column, renderOp(\"$lte\", operand[1]))\n      : `${column}.${renderOp(\"$lte\", operand[1])}`;\n\n    return [lo, hi];\n  }\n\n  return [\n    atTop\n      ? colClause(column, renderOp(op, operand))\n      : `${column}.${renderOp(op, operand)}`,\n  ];\n}\n\n/**\n * Convert a predicate into PostgREST clause strings. Top-level returns a\n * list of `column=value` pairs (joined by `&`); nested returns\n * grouped/clause-list strings depending on the parent combinator.\n *\n * @param atTop  When true, clauses are top-level (& separator).\n *               When false, clauses are inside `and=(...)`/`or=(...)`\n *               and must use `,` separator and `column.op.val` syntax.\n */\nfunction build(\n  spec: unknown,\n  allowed: readonly string[] | undefined,\n  atTop: boolean,\n  depth: number,\n): string[] {\n  if (depth > MAX_PREDICATE_DEPTH) {\n    throw new Error(\n      `[Directive] predicateToPostgrest: predicate depth limit (${MAX_PREDICATE_DEPTH}) exceeded — flatten the predicate or check for a cyclic spec object`,\n    );\n  }\n  if (spec === null || typeof spec !== \"object\") {\n    throw new Error(\n      `[Directive] predicateToPostgrest: predicate must be an object or array`,\n    );\n  }\n\n  if (Array.isArray(spec)) {\n    const out: string[] = [];\n    for (const clause of spec) {\n      if (\n        !clause ||\n        typeof clause !== \"object\" ||\n        !(\"fact\" in clause) ||\n        !(\"op\" in clause)\n      ) {\n        throw new Error(\n          `[Directive] predicateToPostgrest: array-form clause must be { fact, op, value }`,\n        );\n      }\n      const c = clause as { fact: string; op: string; value: unknown };\n      assertColumn(c.fact, allowed);\n      out.push(...renderColumnOps(c.fact, c.op, c.value, atTop));\n    }\n\n    return out;\n  }\n\n  if (\"$all\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$all\");\n    const arr = (spec as { $all: unknown[] }).$all;\n    if (!Array.isArray(arr)) {\n      throw new Error(`[Directive] predicateToPostgrest: $all must be an array`);\n    }\n    if (atTop) {\n      const out: string[] = [];\n      for (const child of arr) {\n        out.push(...build(child, allowed, true, depth + 1));\n      }\n\n      return out;\n    }\n    const parts: string[] = [];\n    for (const child of arr) {\n      parts.push(...build(child, allowed, false, depth + 1));\n    }\n\n    return [groupClause(\"and\", parts)];\n  }\n  if (\"$any\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$any\");\n    const arr = (spec as { $any: unknown[] }).$any;\n    if (!Array.isArray(arr)) {\n      throw new Error(`[Directive] predicateToPostgrest: $any must be an array`);\n    }\n    // Empty $any is tautological-false. PostgREST has no clean way to\n    // express \"match nothing\"; pick a stable contradiction.\n    if (arr.length === 0) {\n      // pg's `id` exists on every base table — match a value no row can have.\n      return atTop\n        ? [\"id=is.null\", \"id=not.is.null\"]\n        : [groupClause(\"and\", [\"id.is.null\", \"id.not.is.null\"])];\n    }\n    const parts: string[] = [];\n    for (const child of arr) {\n      parts.push(...build(child, allowed, false, depth + 1));\n    }\n\n    return [groupClause(\"or\", parts)];\n  }\n  if (\"$not\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$not\");\n    const inner = (spec as { $not: unknown }).$not;\n    const parts = build(inner, allowed, false, depth + 1);\n\n    return [groupClause(\"not.and\", parts)];\n  }\n\n  // Object form\n  const out: string[] = [];\n  for (const [key, value] of Object.entries(spec as Record<string, unknown>)) {\n    assertColumn(key, allowed);\n    if (isOperatorObject(value)) {\n      for (const [op, operand] of Object.entries(value)) {\n        if (!PREDICATE_OPERATORS.has(op)) {\n          throw new Error(\n            `[Directive] predicateToPostgrest: unknown operator \"${op}\" on column \"${key}\" — known: ${[...PREDICATE_OPERATORS].join(\", \")}`,\n          );\n        }\n        out.push(...renderColumnOps(key, op, operand, atTop));\n      }\n    } else if (isPlainObject(value)) {\n      throw new Error(\n        `[Directive] predicateToPostgrest: nested predicate at \"${key}\" — single-table queries only`,\n      );\n    } else {\n      out.push(...renderColumnOps(key, \"$eq\", value, atTop));\n    }\n  }\n\n  return out;\n}\n\n/**\n * Encode a clause string per PostgREST URL conventions.\n *\n * Splits on first `=` so the column/logical name is preserved verbatim\n * (it's identifier-validated) and only the value side is URL-encoded.\n */\nfunction encodeClause(c: string): string {\n  const eq = c.indexOf(\"=\");\n  if (eq < 0) return encodeURIComponent(c);\n  const key = c.slice(0, eq);\n  const value = c.slice(eq + 1);\n\n  return `${key}=${encodeURIComponent(value)}`;\n}\n\n/**\n * Compile a {@link FactPredicate} to a PostgREST querystring.\n *\n * @example\n * ```ts\n * predicateToPostgrest({ age: { $gte: 18 }, status: { $in: [\"active\", \"pending\"] } })\n * // → \"age=gte.18&status=in.%28active%2Cpending%29\"\n *\n * // Raw mode for debugging / building URLs by hand:\n * predicateToPostgrest({ age: { $gte: 18 } }, { mode: \"raw\" })\n * // → \"age=gte.18\"\n *\n * predicateToPostgrest({ $any: [{ tier: \"gold\" }, { score: { $gte: 100 } }] }, { mode: \"raw\" })\n * // → \"or=(tier.eq.gold,score.gte.100)\"\n * ```\n */\nexport function predicateToPostgrest<F = Record<string, unknown>>(\n  predicate: FactPredicate<F>,\n  options: PredicateToPostgrestOptions = {},\n): string {\n  const mode = options.mode ?? \"querystring\";\n  const clauses = build(predicate, options.allowedKeys, true, 0);\n  if (clauses.length === 0) return \"\";\n\n  return mode === \"raw\" ? clauses.join(\"&\") : clauses.map(encodeClause).join(\"&\");\n}\n","/**\n * Schema Type Builders\n *\n * Provides type-safe schema definitions with optional runtime validation.\n * Used to define fact types, derivation types, event payload types, etc.\n *\n * This module has no dependency on the facts store or tracking system.\n */\n\nimport isDevelopment from \"#is-development\";\nimport type { SchemaType } from \"./types.js\";\n\n// ============================================================================\n// Schema Type Builders\n// ============================================================================\n\n/** Brand symbol for branded types */\ndeclare const Brand: unique symbol;\n\n/** Branded type - adds a unique brand to a base type */\nexport type Branded<T, B extends string> = T & { readonly [Brand]: B };\n\n/** Extended SchemaType with type name for better error messages */\nexport interface ExtendedSchemaType<T> extends SchemaType<T> {\n  readonly _typeName?: string;\n  readonly _default?: T | (() => T);\n  readonly _transform?: (value: unknown) => T;\n  readonly _description?: string;\n  readonly _refinements?: Array<{\n    predicate: (value: T) => boolean;\n    message: string;\n  }>;\n  /** Mutable - set by array validators to indicate which element failed */\n  _lastFailedIndex?: number;\n  /** Optional metadata for debugging and devtools (never read on hot path). */\n  readonly _meta?: import(\"./types/meta.js\").DefinitionMeta;\n}\n\n/** Create a schema type builder with optional type name */\nfunction createSchemaType<T>(\n  validators: Array<(v: T) => boolean> = [],\n  typeName?: string,\n  defaultValue?: T | (() => T),\n  transform?: (value: unknown) => T,\n  description?: string,\n  refinements?: Array<{ predicate: (value: T) => boolean; message: string }>,\n  meta?: import(\"./types/meta.js\").DefinitionMeta,\n): ExtendedSchemaType<T> {\n  return {\n    _type: undefined as unknown as T,\n    _validators: validators,\n    _typeName: typeName,\n    _default: defaultValue,\n    _transform: transform,\n    _description: description,\n    _refinements: refinements,\n    _meta: meta,\n    validate(fn: (value: T) => boolean) {\n      return createSchemaType(\n        [...validators, fn],\n        typeName,\n        defaultValue,\n        transform,\n        description,\n        refinements,\n        meta,\n      );\n    },\n  };\n}\n\n/** Chainable schema type with all common methods */\nexport interface ChainableSchemaType<T> extends ExtendedSchemaType<T> {\n  default(value: T | (() => T)): ChainableSchemaType<T>;\n  transform<U>(fn: (value: T) => U): ChainableSchemaType<U>;\n  brand<B extends string>(): ChainableSchemaType<Branded<T, B>>;\n  describe(description: string): ChainableSchemaType<T>;\n  refine(\n    predicate: (value: T) => boolean,\n    message: string,\n  ): ChainableSchemaType<T>;\n  nullable(): ChainableSchemaType<T | null>;\n  optional(): ChainableSchemaType<T | undefined>;\n  /** Attach metadata for debugging and devtools. */\n  meta(meta: import(\"./types/meta.js\").DefinitionMeta): ChainableSchemaType<T>;\n}\n\n/** Create a chainable schema type with common methods */\nfunction createChainableType<T>(\n  validators: Array<(v: T) => boolean>,\n  typeName: string,\n  defaultValue?: T | (() => T),\n  transform?: (value: unknown) => T,\n  description?: string,\n  refinements?: Array<{ predicate: (value: T) => boolean; message: string }>,\n  fieldMeta?: import(\"./types/meta.js\").DefinitionMeta,\n): ChainableSchemaType<T> {\n  const base = createSchemaType<T>(\n    validators,\n    typeName,\n    defaultValue,\n    transform,\n    description,\n    refinements,\n    fieldMeta,\n  );\n  return {\n    ...base,\n    default(value: T | (() => T)) {\n      return createChainableType(\n        validators,\n        typeName,\n        value,\n        transform,\n        description,\n        refinements,\n        fieldMeta,\n      );\n    },\n    transform<U>(fn: (value: T) => U) {\n      const newTransform = (v: unknown) => {\n        const intermediate = transform ? transform(v) : (v as T);\n        return fn(intermediate);\n      };\n      return createChainableType<U>(\n        [],\n        typeName,\n        undefined,\n        newTransform as (v: unknown) => U,\n        description,\n        undefined,\n        fieldMeta,\n      );\n    },\n    brand<B extends string>() {\n      return createChainableType<Branded<T, B>>(\n        validators as Array<(v: Branded<T, B>) => boolean>,\n        `Branded<${typeName}>`,\n        defaultValue as Branded<T, B> | (() => Branded<T, B>),\n        transform as (value: unknown) => Branded<T, B>,\n        description,\n        refinements as Array<{\n          predicate: (value: Branded<T, B>) => boolean;\n          message: string;\n        }>,\n        fieldMeta,\n      );\n    },\n    describe(desc: string) {\n      return createChainableType(\n        validators,\n        typeName,\n        defaultValue,\n        transform,\n        desc,\n        refinements,\n        fieldMeta,\n      );\n    },\n    refine(predicate: (value: T) => boolean, message: string) {\n      const newRefinements = [...(refinements ?? []), { predicate, message }];\n      return createChainableType(\n        [...validators, predicate],\n        typeName,\n        defaultValue,\n        transform,\n        description,\n        newRefinements,\n        fieldMeta,\n      );\n    },\n    nullable() {\n      return createChainableType<T | null>(\n        [\n          (v): v is T | null =>\n            v === null || validators.every((fn) => fn(v as T)),\n        ],\n        `${typeName} | null`,\n        defaultValue as (T | null) | (() => T | null),\n        transform as (value: unknown) => T | null,\n        description,\n        undefined,\n        fieldMeta,\n      );\n    },\n    optional() {\n      return createChainableType<T | undefined>(\n        [\n          (v): v is T | undefined =>\n            v === undefined || validators.every((fn) => fn(v as T)),\n        ],\n        `${typeName} | undefined`,\n        defaultValue as (T | undefined) | (() => T | undefined),\n        transform as (value: unknown) => T | undefined,\n        description,\n        undefined,\n        fieldMeta,\n      );\n    },\n    meta(m: import(\"./types/meta.js\").DefinitionMeta) {\n      return createChainableType(\n        validators,\n        typeName,\n        defaultValue,\n        transform,\n        description,\n        refinements,\n        m,\n      );\n    },\n  };\n}\n\n/**\n * Two-form union schema constructor.\n *\n * Hoisted out of the `t` object literal because the overload-cast pattern\n * (`(impl) as { ovl1; ovl2 }`) inside an object literal triggers a TS\n * declaration-emit \"implicitly has type any\" cycle. Annotating the const\n * with the explicit overload type breaks the cycle so DTS can emit `t`'s\n * shape without recursing through the runtime expression.\n *\n * @internal\n */\ntype UnionFn = {\n  <T = unknown>(): ChainableSchemaType<T>;\n  <T extends SchemaType<unknown>[]>(\n    ...types: T\n  ): ChainableSchemaType<T[number] extends SchemaType<infer U> ? U : never>;\n};\n\nconst unionImpl: UnionFn = (<T extends SchemaType<unknown>[]>(...types: T) => {\n  if (types.length === 0) {\n    return createChainableType<unknown>([], \"union\");\n  }\n  type UnionType = T[number] extends SchemaType<infer U> ? U : never;\n  const typeNames = types.map(\n    (schemaType) =>\n      (schemaType as ExtendedSchemaType<unknown>)._typeName ?? \"unknown\",\n  );\n  return createChainableType<UnionType>(\n    [\n      (v): v is UnionType =>\n        types.some((schemaType) => schemaType._validators.every((fn) => fn(v))),\n    ],\n    typeNames.join(\" | \"),\n  );\n}) as UnionFn;\n\n/**\n * Schema type builders for defining fact types.\n *\n * @remarks\n * Each builder returns a chainable {@link ExtendedSchemaType} with validation\n * methods (`.min()`, `.max()`, `.pattern()`, etc.) and dev-mode runtime\n * type checking. Validators are tree-shaken in production builds.\n *\n * @example\n * ```typescript\n * const module = createModule(\"example\", {\n *   schema: {\n *     name: t.string(),\n *     age: t.number().min(0).max(150),\n *     active: t.boolean(),\n *     tags: t.array<string>().of(t.string()),\n *     user: t.object<{ id: string; email: string }>(),\n *   },\n * });\n * ```\n *\n * @public\n */\nexport const t = {\n  /**\n   * Create a string schema type.\n   *\n   * @example\n   * ```typescript\n   * // Basic string\n   * schema: { name: t.string() }\n   *\n   * // String literal union (for type safety)\n   * schema: { phase: t.string<\"red\" | \"green\" | \"yellow\">() }\n   *\n   * // With custom validation\n   * schema: { email: t.string().validate(s => s.includes(\"@\")) }\n   *\n   * // With transform\n   * schema: { trimmed: t.string().transform(s => s.trim()) }\n   *\n   * // With brand\n   * schema: { userId: t.string().brand<\"UserId\">() }\n   * ```\n   */\n  string<T extends string = string>() {\n    type ChainableString = ChainableSchemaType<T> & {\n      minLength(n: number): ChainableString;\n      maxLength(n: number): ChainableString;\n      pattern(regex: RegExp): ChainableString;\n      meta(m: import(\"./types/meta.js\").DefinitionMeta): ChainableString;\n    };\n\n    const createChainableString = (\n      validators: Array<(v: T) => boolean>,\n      defaultValue?: T | (() => T),\n      transform?: (value: unknown) => T,\n      description?: string,\n      refinements?: Array<{\n        predicate: (value: T) => boolean;\n        message: string;\n      }>,\n      fm?: import(\"./types/meta.js\").DefinitionMeta,\n    ): ChainableString => {\n      const chainable = createChainableType<T>(\n        validators,\n        \"string\",\n        defaultValue,\n        transform,\n        description,\n        refinements,\n        fm,\n      );\n      return {\n        ...chainable,\n        minLength(n: number) {\n          return createChainableString(\n            [...validators, (v) => (v as string).length >= n],\n            defaultValue,\n            transform,\n            description,\n            refinements,\n            fm,\n          );\n        },\n        maxLength(n: number) {\n          return createChainableString(\n            [...validators, (v) => (v as string).length <= n],\n            defaultValue,\n            transform,\n            description,\n            refinements,\n            fm,\n          );\n        },\n        pattern(regex: RegExp) {\n          return createChainableString(\n            [...validators, (v) => regex.test(v as string)],\n            defaultValue,\n            transform,\n            description,\n            refinements,\n            fm,\n          );\n        },\n        default(value: T | (() => T)) {\n          return createChainableString(\n            validators,\n            value,\n            transform,\n            description,\n            refinements,\n            fm,\n          );\n        },\n        describe(desc: string) {\n          return createChainableString(\n            validators,\n            defaultValue,\n            transform,\n            desc,\n            refinements,\n            fm,\n          );\n        },\n        refine(predicate: (value: T) => boolean, message: string) {\n          const newRefinements = [\n            ...(refinements ?? []),\n            { predicate, message },\n          ];\n          return createChainableString(\n            [...validators, predicate],\n            defaultValue,\n            transform,\n            description,\n            newRefinements,\n            fm,\n          );\n        },\n        meta(m: import(\"./types/meta.js\").DefinitionMeta) {\n          return createChainableString(\n            validators,\n            defaultValue,\n            transform,\n            description,\n            refinements,\n            m,\n          );\n        },\n      };\n    };\n\n    return createChainableString([(v): v is T => typeof v === \"string\"]);\n  },\n\n  /**\n   * Create a number schema type with optional min/max constraints.\n   *\n   * @example\n   * ```typescript\n   * // Basic number\n   * schema: { count: t.number() }\n   *\n   * // With range constraints\n   * schema: { age: t.number().min(0).max(150) }\n   *\n   * // With custom validation\n   * schema: { even: t.number().validate(n => n % 2 === 0) }\n   *\n   * // With default\n   * schema: { count: t.number().default(0) }\n   *\n   * // With transform (from string)\n   * schema: { age: t.number().transform(v => parseInt(String(v), 10)) }\n   * ```\n   */\n  number() {\n    type ChainableNumber = ChainableSchemaType<number> & {\n      min(n: number): ChainableNumber;\n      max(n: number): ChainableNumber;\n      meta(m: import(\"./types/meta.js\").DefinitionMeta): ChainableNumber;\n    };\n\n    const createChainableNumber = (\n      validators: Array<(v: number) => boolean>,\n      defaultValue?: number | (() => number),\n      transform?: (value: unknown) => number,\n      description?: string,\n      refinements?: Array<{\n        predicate: (value: number) => boolean;\n        message: string;\n      }>,\n      fm?: import(\"./types/meta.js\").DefinitionMeta,\n    ): ChainableNumber => {\n      const chainable = createChainableType<number>(\n        validators,\n        \"number\",\n        defaultValue,\n        transform,\n        description,\n        refinements,\n        fm,\n      );\n      return {\n        ...chainable,\n        min(n: number) {\n          return createChainableNumber(\n            [...validators, (v) => v >= n],\n            defaultValue,\n            transform,\n            description,\n            refinements,\n            fm,\n          );\n        },\n        max(n: number) {\n          return createChainableNumber(\n            [...validators, (v) => v <= n],\n            defaultValue,\n            transform,\n            description,\n            refinements,\n            fm,\n          );\n        },\n        default(value: number | (() => number)) {\n          return createChainableNumber(\n            validators,\n            value,\n            transform,\n            description,\n            refinements,\n            fm,\n          );\n        },\n        describe(desc: string) {\n          return createChainableNumber(\n            validators,\n            defaultValue,\n            transform,\n            desc,\n            refinements,\n            fm,\n          );\n        },\n        refine(predicate: (value: number) => boolean, message: string) {\n          const newRefinements = [\n            ...(refinements ?? []),\n            { predicate, message },\n          ];\n          return createChainableNumber(\n            [...validators, predicate],\n            defaultValue,\n            transform,\n            description,\n            newRefinements,\n            fm,\n          );\n        },\n        meta(m: import(\"./types/meta.js\").DefinitionMeta) {\n          return createChainableNumber(\n            validators,\n            defaultValue,\n            transform,\n            description,\n            refinements,\n            m,\n          );\n        },\n      };\n    };\n    return createChainableNumber([(v) => typeof v === \"number\"]);\n  },\n\n  /**\n   * Create a boolean schema type.\n   *\n   * @example\n   * ```typescript\n   * schema: {\n   *   active: t.boolean(),\n   *   verified: t.boolean().default(false),\n   * }\n   * ```\n   */\n  boolean() {\n    return createChainableType<boolean>(\n      [(v) => typeof v === \"boolean\"],\n      \"boolean\",\n    );\n  },\n\n  /**\n   * Create an array schema type.\n   * Can be used with or without element validation:\n   * - `t.array<string>()` - Type-only, no element validation\n   * - `t.array<string>().of(t.string())` - With element validation\n   */\n  array<T>() {\n    type ChainableArray = ChainableSchemaType<T[]> & {\n      of(elementType: SchemaType<T>): ChainableArray;\n      nonEmpty(): ChainableArray;\n      maxLength(n: number): ChainableArray;\n      minLength(n: number): ChainableArray;\n      meta(m: import(\"./types/meta.js\").DefinitionMeta): ChainableArray;\n      _lastFailedIndex?: number;\n    };\n\n    const createChainableArray = (\n      validators: Array<(v: T[]) => boolean>,\n      elementType?: SchemaType<T>,\n      defaultValue?: T[] | (() => T[]),\n      description?: string,\n      indexRef?: { value: number },\n      fm?: import(\"./types/meta.js\").DefinitionMeta,\n    ): ChainableArray => {\n      const chainable = createChainableType<T[]>(\n        validators,\n        \"array\",\n        defaultValue,\n        undefined,\n        description,\n        undefined,\n        fm,\n      );\n      // Use ref for storing failed index (shared with validator closure)\n      const ref = indexRef ?? { value: -1 };\n      const result: ChainableArray = {\n        ...chainable,\n        get _lastFailedIndex() {\n          return ref.value;\n        },\n        set _lastFailedIndex(v: number) {\n          ref.value = v;\n        },\n        of(et: SchemaType<T>) {\n          const newRef = { value: -1 };\n          return createChainableArray(\n            [\n              ...validators,\n              (v) => {\n                for (let i = 0; i < v.length; i++) {\n                  if (!et._validators.every((validator) => validator(v[i]))) {\n                    newRef.value = i;\n                    return false;\n                  }\n                }\n                return true;\n              },\n            ],\n            et,\n            defaultValue,\n            description,\n            newRef,\n            fm,\n          );\n        },\n        nonEmpty() {\n          return createChainableArray(\n            [...validators, (v) => v.length > 0],\n            elementType,\n            defaultValue,\n            description,\n            ref,\n            fm,\n          );\n        },\n        maxLength(n: number) {\n          return createChainableArray(\n            [...validators, (v) => v.length <= n],\n            elementType,\n            defaultValue,\n            description,\n            ref,\n            fm,\n          );\n        },\n        minLength(n: number) {\n          return createChainableArray(\n            [...validators, (v) => v.length >= n],\n            elementType,\n            defaultValue,\n            description,\n            ref,\n            fm,\n          );\n        },\n        default(value: T[] | (() => T[])) {\n          return createChainableArray(\n            validators,\n            elementType,\n            value,\n            description,\n            ref,\n            fm,\n          );\n        },\n        describe(desc: string) {\n          return createChainableArray(\n            validators,\n            elementType,\n            defaultValue,\n            desc,\n            ref,\n            fm,\n          );\n        },\n        meta(m: import(\"./types/meta.js\").DefinitionMeta) {\n          return createChainableArray(\n            validators,\n            elementType,\n            defaultValue,\n            description,\n            ref,\n            m,\n          );\n        },\n      };\n      return result;\n    };\n    return createChainableArray([(v) => Array.isArray(v)]);\n  },\n\n  /**\n   * Create an object schema type for any complex value.\n   * Can be used with or without shape validation:\n   * - `t.object<User>()` - Type-only, no property validation\n   * - `t.object<User>().shape({ name: t.string(), age: t.number() })` - With property validation\n   *\n   * For arrays, prefer `t.array<T>()` which adds `Array.isArray` validation.\n   */\n  object<T>() {\n    type ChainableObject = ChainableSchemaType<T> & {\n      shape(schema: { [K in keyof T]?: SchemaType<T[K]> }): ChainableObject;\n      nonNull(): ChainableObject;\n      hasKeys(...keys: string[]): ChainableObject;\n      meta(m: import(\"./types/meta.js\").DefinitionMeta): ChainableObject;\n    };\n\n    const createChainableObject = (\n      validators: Array<(v: T) => boolean>,\n      defaultValue?: T | (() => T),\n      description?: string,\n      fm?: import(\"./types/meta.js\").DefinitionMeta,\n    ): ChainableObject => {\n      const chainable = createChainableType<T>(\n        validators,\n        \"object\",\n        defaultValue,\n        undefined,\n        description,\n        undefined,\n        fm,\n      );\n      return {\n        ...chainable,\n        shape(shapeSchema: { [K in keyof T]?: SchemaType<T[K]> }) {\n          return createChainableObject(\n            [\n              ...validators,\n              (v) => {\n                for (const [key, schemaType] of Object.entries(shapeSchema)) {\n                  const value = (v as Record<string, unknown>)[key];\n                  const schemaT = schemaType as SchemaType<unknown>;\n                  if (\n                    schemaT &&\n                    !schemaT._validators.every((validator) => validator(value))\n                  ) {\n                    return false;\n                  }\n                }\n                return true;\n              },\n            ],\n            defaultValue,\n            description,\n            fm,\n          );\n        },\n        nonNull() {\n          return createChainableObject(\n            [...validators, (v) => v !== null && v !== undefined],\n            defaultValue,\n            description,\n            fm,\n          );\n        },\n        hasKeys(...keys: string[]) {\n          return createChainableObject(\n            [\n              ...validators,\n              (v) => keys.every((k) => k in (v as Record<string, unknown>)),\n            ],\n            defaultValue,\n            description,\n            fm,\n          );\n        },\n        default(value: T | (() => T)) {\n          return createChainableObject(validators, value, description, fm);\n        },\n        describe(desc: string) {\n          return createChainableObject(validators, defaultValue, desc, fm);\n        },\n        meta(m: import(\"./types/meta.js\").DefinitionMeta) {\n          return createChainableObject(\n            validators,\n            defaultValue,\n            description,\n            m,\n          );\n        },\n      };\n    };\n    return createChainableObject([\n      (v) => typeof v === \"object\" && v !== null && !Array.isArray(v),\n    ]);\n  },\n\n  /**\n   * Create an enum schema type for string literal unions.\n   *\n   * @example\n   * ```typescript\n   * // Define allowed values\n   * schema: { status: t.enum(\"idle\", \"loading\", \"success\", \"error\") }\n   *\n   * // Type is inferred as \"idle\" | \"loading\" | \"success\" | \"error\"\n   * ```\n   */\n  enum<T extends string>(...values: T[]) {\n    if (isDevelopment && values.length === 0) {\n      console.warn(\n        \"[Directive] t.enum() called with no values - this will reject all strings\",\n      );\n    }\n    const valueSet = new Set(values);\n    return createChainableType<T>(\n      [(v): v is T => typeof v === \"string\" && valueSet.has(v as T)],\n      `enum(${values.join(\"|\")})`,\n    );\n  },\n\n  /**\n   * Create a literal schema type for exact value matching.\n   *\n   * @example\n   * ```typescript\n   * // Exact string match\n   * schema: { type: t.literal(\"user\") }\n   *\n   * // Exact number match\n   * schema: { version: t.literal(1) }\n   *\n   * // Exact boolean\n   * schema: { enabled: t.literal(true) }\n   * ```\n   */\n  literal<T extends string | number | boolean>(value: T) {\n    return createChainableType<T>(\n      [(v): v is T => v === value],\n      `literal(${String(value)})`,\n    );\n  },\n\n  /**\n   * Create a nullable schema type (T | null).\n   *\n   * @example\n   * ```typescript\n   * // Nullable string\n   * schema: { name: t.nullable(t.string()) }\n   *\n   * // Nullable object\n   * schema: { user: t.nullable(t.object<User>()) }\n   * ```\n   */\n  nullable<T>(innerType: SchemaType<T>) {\n    const innerTypeName =\n      (innerType as ExtendedSchemaType<T>)._typeName ?? \"unknown\";\n    return createSchemaType<T | null>(\n      [\n        (v): v is T | null => {\n          if (v === null) {\n            return true;\n          }\n          return innerType._validators.every((validator) => validator(v as T));\n        },\n      ],\n      `${innerTypeName} | null`,\n    ) as SchemaType<T | null>;\n  },\n\n  /**\n   * Create an optional schema type (T | undefined).\n   *\n   * @example\n   * ```typescript\n   * // Optional string\n   * schema: { nickname: t.optional(t.string()) }\n   *\n   * // Optional number\n   * schema: { age: t.optional(t.number()) }\n   * ```\n   */\n  optional<T>(innerType: SchemaType<T>) {\n    const innerTypeName =\n      (innerType as ExtendedSchemaType<T>)._typeName ?? \"unknown\";\n    return createSchemaType<T | undefined>(\n      [\n        (v): v is T | undefined => {\n          if (v === undefined) {\n            return true;\n          }\n          return innerType._validators.every((validator) => validator(v as T));\n        },\n      ],\n      `${innerTypeName} | undefined`,\n    ) as SchemaType<T | undefined>;\n  },\n\n  /**\n   * Create a union schema type.\n   *\n   * **Two forms:**\n   * - `t.union(t.string(), t.number())` — variadic schema args; the runtime\n   *   validator checks that the value matches at least one inner schema.\n   * - `t.union<string | number | boolean>()` — generic-only form with no\n   *   schema args; the runtime validator accepts ANY value (mirrors\n   *   {@link unknown} plus generic narrowing). Use this for polymorphic\n   *   payloads where the union is too dynamic to enumerate as inner schemas\n   *   (e.g. an `UPDATE_FIELD` event whose `value` may be `string | number |\n   *   boolean | Date`).\n   *\n   * Chainable methods (`.validate`, `.transform`, `.default`, `.describe`,\n   * `.refine`, `.optional`, `.nullable`) work the same for both forms.\n   *\n   * @example\n   * ```typescript\n   * // Variadic — runtime validation against inner schemas\n   * schema: { value: t.union(t.string(), t.number()) }\n   *\n   * // Generic-only — type-only narrowing, runtime accepts any value\n   * schema: {\n   *   payload: t.union<string | number | boolean>(),\n   * }\n   *\n   * // Add a custom predicate via .validate when you still want a runtime check\n   * schema: {\n   *   strict: t.union<string | number>().validate(\n   *     (v) => typeof v === \"string\" || typeof v === \"number\",\n   *   ),\n   * }\n   * ```\n   */\n  union: unionImpl,\n\n  /**\n   * Create a record schema type for dynamic key-value maps.\n   *\n   * @example\n   * ```typescript\n   * // Record with string values\n   * schema: { metadata: t.record(t.string()) }\n   *\n   * // Record with number values\n   * schema: { scores: t.record(t.number()) }\n   * ```\n   */\n  record<V>(valueType: SchemaType<V>) {\n    const valueTypeName =\n      (valueType as ExtendedSchemaType<V>)._typeName ?? \"unknown\";\n    return createChainableType<Record<string, V>>(\n      [\n        (v): v is Record<string, V> => {\n          if (typeof v !== \"object\" || v === null || Array.isArray(v))\n            return false;\n          return Object.values(v).every((val) =>\n            valueType._validators.every((validator) => validator(val)),\n          );\n        },\n      ],\n      `Record<string, ${valueTypeName}>`,\n    );\n  },\n\n  /**\n   * Create a tuple schema type for fixed-length arrays with specific types.\n   *\n   * @example\n   * ```typescript\n   * // [string, number] tuple\n   * schema: { coord: t.tuple(t.string(), t.number()) }\n   *\n   * // [x, y, z] coordinates\n   * schema: { position: t.tuple(t.number(), t.number(), t.number()) }\n   * ```\n   */\n  tuple<T extends SchemaType<unknown>[]>(...types: T) {\n    if (isDevelopment && types.length === 0) {\n      console.warn(\n        \"[Directive] t.tuple() called with no types - this will only accept empty arrays\",\n      );\n    }\n    type TupleType = {\n      [K in keyof T]: T[K] extends SchemaType<infer U> ? U : never;\n    };\n    const typeNames = types.map(\n      (schemaType) =>\n        (schemaType as ExtendedSchemaType<unknown>)._typeName ?? \"unknown\",\n    );\n    return createChainableType<TupleType>(\n      [\n        (v): v is TupleType => {\n          if (!Array.isArray(v) || v.length !== types.length) {\n            return false;\n          }\n          return types.every((schemaType, i) =>\n            schemaType._validators.every((validator) => validator(v[i])),\n          );\n        },\n      ],\n      `[${typeNames.join(\", \")}]`,\n    );\n  },\n\n  /**\n   * Create a date schema type.\n   *\n   * @example\n   * ```typescript\n   * schema: { createdAt: t.date() }\n   * ```\n   */\n  date() {\n    return createChainableType<Date>(\n      [(v): v is Date => v instanceof Date && !Number.isNaN(v.getTime())],\n      \"Date\",\n    );\n  },\n\n  /**\n   * Create a UUID schema type.\n   *\n   * @example\n   * ```typescript\n   * schema: { id: t.uuid() }\n   * ```\n   */\n  uuid() {\n    const uuidRegex =\n      /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;\n    return createChainableType<string>(\n      [(v): v is string => typeof v === \"string\" && uuidRegex.test(v)],\n      \"uuid\",\n    );\n  },\n\n  /**\n   * Create an email schema type.\n   *\n   * @example\n   * ```typescript\n   * schema: { email: t.email() }\n   * ```\n   */\n  email() {\n    // Simple email regex - for comprehensive validation use Zod\n    const emailRegex = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/;\n    return createChainableType<string>(\n      [(v): v is string => typeof v === \"string\" && emailRegex.test(v)],\n      \"email\",\n    );\n  },\n\n  /**\n   * Create a URL schema type.\n   *\n   * @example\n   * ```typescript\n   * schema: { website: t.url() }\n   * ```\n   */\n  url() {\n    return createChainableType<string>(\n      [\n        (v): v is string => {\n          if (typeof v !== \"string\") {\n            return false;\n          }\n          try {\n            new URL(v);\n            return true;\n          } catch {\n            return false;\n          }\n        },\n      ],\n      \"url\",\n    );\n  },\n\n  /**\n   * Create a bigint schema type.\n   *\n   * @example\n   * ```typescript\n   * schema: { largeNumber: t.bigint() }\n   * ```\n   */\n  bigint() {\n    return createChainableType<bigint>(\n      [(v): v is bigint => typeof v === \"bigint\"],\n      \"bigint\",\n    );\n  },\n\n  /**\n   * Create an `any` schema type that accepts all values without validation.\n   *\n   * @example\n   * ```typescript\n   * schema: { payload: t.any() }\n   * ```\n   */\n  // biome-ignore lint/suspicious/noExplicitAny: Intentional any type for schema builder\n  any() {\n    return createChainableType<any>([], \"any\");\n  },\n\n  /**\n   * Create an `unknown` schema type that accepts all values without validation.\n   * Prefer `t.unknown()` over `t.any()` for stricter downstream type checking.\n   *\n   * @example\n   * ```typescript\n   * schema: { data: t.unknown() }\n   * ```\n   */\n  unknown() {\n    return createChainableType<unknown>([], \"unknown\");\n  },\n};\n","/**\n * Module - The declarative API for defining Directive modules\n *\n * Modules group related facts, constraints, resolvers, effects, and derivations.\n */\n\nimport isDevelopment from \"#is-development\";\nimport { BLOCKED_PROPS } from \"./tracking.js\";\nimport type {\n  CrossModuleConstraintsDef,\n  CrossModuleDeps,\n  CrossModuleDerivationsDef,\n  CrossModuleEffectsDef,\n  DefinitionMeta,\n  EffectsDef,\n  Facts,\n  ModuleDef,\n  ModuleHooks,\n  ModuleSchema,\n  TypedConstraintsDef,\n  TypedDerivationsDef,\n  TypedEventsDef,\n  TypedResolversDef,\n} from \"./types.js\";\n\n// ============================================================================\n// Module Configuration\n// ============================================================================\n\n/**\n * Module configuration with consolidated schema.\n *\n * derive and events are optional - omit them if your schema has empty derivations/events.\n */\nexport interface ModuleConfig<M extends ModuleSchema> {\n  schema: M;\n  init?: (facts: Facts<M[\"facts\"]>) => void;\n  derive?: TypedDerivationsDef<M>;\n  events?: TypedEventsDef<M>;\n  effects?: EffectsDef<M[\"facts\"]>;\n  constraints?: TypedConstraintsDef<M>;\n  resolvers?: TypedResolversDef<M>;\n  hooks?: ModuleHooks<M>;\n  /** Optional metadata for debugging and devtools (never read on hot path). */\n  meta?: DefinitionMeta;\n  /** History configuration — controls which events create snapshots for undo/redo. */\n  history?: {\n    /** Events that create history snapshots. Omit to snapshot all events. */\n    snapshotEvents?: Array<\n      keyof (M[\"events\"] extends Record<string, unknown>\n        ? M[\"events\"]\n        : Record<string, never>) &\n        string\n    >;\n  };\n}\n\n/**\n * Module configuration with cross-module dependencies for type-safe access\n * to other modules' facts in effects and constraints.\n *\n * When crossModuleDeps is provided:\n * - Own module facts: `facts.self.*`\n * - Cross-module facts: `facts.{dep}.*`\n *\n * @example\n * ```typescript\n * import { authSchema } from './auth';\n * import { dataSchema } from './data';\n *\n * const uiModule = createModule(\"ui\", {\n *   schema: uiSchema,\n *   crossModuleDeps: { auth: authSchema, data: dataSchema },\n *   effects: {\n *     onAuthChange: {\n *       run: (facts) => {\n *         facts.self.notifications   // ✅ own module via \"self\"\n *         facts.auth.isAuthenticated // ✅ cross-module (namespaced)\n *         facts.data.users           // ✅ cross-module (namespaced)\n *       }\n *     }\n *   },\n *   constraints: {\n *     fetchWhenAuth: {\n *       when: (facts) => facts.auth.isAuthenticated && facts.self.users.length === 0,\n *       require: { type: \"FETCH_USERS\" },\n *     }\n *   }\n * });\n * ```\n */\nexport interface ModuleConfigWithDeps<\n  M extends ModuleSchema,\n  Deps extends CrossModuleDeps,\n> {\n  schema: M;\n  /**\n   * Cross-module dependencies for type-safe access in derive/effects/constraints.\n   *\n   * **Access patterns by context:**\n   * - `derive`, `effects`, `constraints`: Use `facts.self.*` for own module, `facts.{dep}.*` for cross-module\n   * - `init`, `events`, `resolvers`: Use flat access (`facts.myFact`) - no cross-module access\n   *\n   * This separation ensures initialization and event handling stay scoped to own module,\n   * while observers (derive/effects/constraints) can see across modules.\n   *\n   * @example\n   * ```typescript\n   * crossModuleDeps: { auth: authSchema },\n   * init: (facts) => { facts.users = []; },              // flat access\n   * derive: { count: (facts) => facts.self.users.length }, // facts.self.*\n   * effects: { log: { run: (facts) => console.log(facts.auth.token) } }, // facts.{dep}.*\n   * ```\n   */\n  crossModuleDeps: Deps;\n  /** Initialize module facts. Uses flat access (`facts.myFact`) to ensure modules initialize independently. */\n  init?: (facts: Facts<M[\"facts\"]>) => void;\n  /** Derivations with cross-module facts access (`facts.self.*` + `facts.{dep}.*`) */\n  derive?: CrossModuleDerivationsDef<M, Deps>;\n  /** Event handlers. Uses flat access (`facts.myFact`) to keep mutations scoped to own module. */\n  events?: TypedEventsDef<M>;\n  /** Effects with cross-module facts access (`facts.self.*` + `facts.{dep}.*`) */\n  effects?: CrossModuleEffectsDef<M, Deps>;\n  /** Constraints with cross-module facts access (`facts.self.*` + `facts.{dep}.*`) */\n  constraints?: CrossModuleConstraintsDef<M, Deps>;\n  /** Resolvers. Uses flat access (`ctx.facts.myFact`) to keep async mutations scoped to own module. */\n  resolvers?: TypedResolversDef<M>;\n  hooks?: ModuleHooks<M>;\n  /** Optional metadata for debugging and devtools (never read on hot path). */\n  meta?: DefinitionMeta;\n  /** History configuration — controls which events create snapshots for undo/redo. */\n  history?: {\n    /** Events that create history snapshots. Omit to snapshot all events. */\n    snapshotEvents?: Array<\n      keyof (M[\"events\"] extends Record<string, unknown>\n        ? M[\"events\"]\n        : Record<string, never>) &\n        string\n    >;\n  };\n}\n\n// ============================================================================\n// Module Validation Helpers (dev-mode only)\n// ============================================================================\n\n/** Validate module ID follows naming conventions */\nfunction validateModuleId(id: string): void {\n  if (!id || typeof id !== \"string\") {\n    console.warn(\"[Directive] Module ID must be a non-empty string\");\n\n    return;\n  }\n  if (!/^(__[a-z][a-z0-9_-]*|[a-z][a-z0-9-]*)$/i.test(id)) {\n    console.warn(\n      `[Directive] Module ID \"${id}\" should follow kebab-case convention (e.g., \"my-module\")`,\n    );\n  }\n}\n\n/** Warn when keys in `implKeys` are missing from `schemaKeys` and vice versa */\nfunction validateKeyAlignment(\n  implKeys: Set<string>,\n  schemaKeys: Set<string>,\n  implLabel: string,\n  schemaLabel: string,\n  missingImplMessage: string,\n): void {\n  for (const key of implKeys) {\n    if (!schemaKeys.has(key)) {\n      console.warn(\n        `[Directive] ${implLabel} \"${key}\" not declared in ${schemaLabel}`,\n      );\n    }\n  }\n  for (const key of schemaKeys) {\n    if (!implKeys.has(key)) {\n      console.warn(\n        `[Directive] ${schemaLabel}[\"${key}\"] ${missingImplMessage}`,\n      );\n    }\n  }\n}\n\n/** Validate history.snapshotEvents reference valid event names */\nfunction validateSnapshotEvents(\n  snapshotEvents: string[],\n  schemaEvents: Record<string, unknown>,\n): void {\n  if (snapshotEvents.length === 0) {\n    console.warn(\n      \"[Directive] history.snapshotEvents is an empty array — no events will create history snapshots. \" +\n        \"Omit history.snapshotEvents entirely to snapshot all events, or list specific events.\",\n    );\n  }\n  const schemaEventKeys = new Set(Object.keys(schemaEvents));\n  for (const eventName of snapshotEvents) {\n    if (!schemaEventKeys.has(eventName)) {\n      console.warn(\n        `[Directive] history.snapshotEvents entry \"${eventName}\" not declared in schema.events. ` +\n          `Available events: ${[...schemaEventKeys].join(\", \") || \"(none)\"}`,\n      );\n    }\n  }\n}\n\n/** Validate resolvers reference valid requirement types */\nfunction validateResolverRequirements(\n  resolvers: Record<string, unknown>,\n  requirements: Record<string, unknown>,\n): void {\n  const requirementTypes = new Set(Object.keys(requirements));\n  for (const [resolverName, resolver] of Object.entries(resolvers)) {\n    const resolverDef = resolver as { requirement?: string };\n    if (\n      typeof resolverDef.requirement === \"string\" &&\n      !requirementTypes.has(resolverDef.requirement)\n    ) {\n      console.warn(\n        `[Directive] Resolver \"${resolverName}\" references unknown requirement type \"${resolverDef.requirement}\". ` +\n          `Available types: ${[...requirementTypes].join(\", \") || \"(none)\"}`,\n      );\n    }\n  }\n}\n\n/**\n * Throw when a module's fact key conflicts with a reserved namespace pivot\n * or evaluation alias used by the data-form predicate runtime. Two classes:\n *\n * - The cross-module namespace pivots — `self` and every declared\n *   `crossModuleDeps` namespace. A fact named after a pivot would make\n *   `prefixPredicateSpec` mis-route the pivot's nested predicate against\n *   the pivot's namespace instead of treating it as a literal fact lookup.\n * - The evaluation aliases `prev` and `current` — reserved for the\n *   previous/live snapshot scopes (`$changed`, clobber baselines). A fact\n *   with one of these names would shadow the alias in those scopes.\n *\n * Thrown unconditionally — this is a structural integrity check, not a dev\n * convenience. Production users running into this would otherwise see silent\n * mis-routing.\n */\nfunction validatePivotNameConflicts<M extends ModuleSchema>(\n  id: string,\n  config: ModuleConfig<M> | ModuleConfigWithDeps<M, CrossModuleDeps>,\n): void {\n  const facts = (config.schema?.facts ?? {}) as Record<string, unknown>;\n  const factKeys = Object.keys(facts);\n  if (factKeys.length === 0) {\n    return;\n  }\n  const reserved = new Set<string>([\"self\", \"prev\", \"current\"]);\n  const deps =\n    \"crossModuleDeps\" in config && config.crossModuleDeps\n      ? Object.keys(\n          config.crossModuleDeps as Record<string, unknown>,\n        )\n      : [];\n  for (const depName of deps) {\n    reserved.add(depName);\n  }\n  for (const key of factKeys) {\n    if (reserved.has(key)) {\n      throw new Error(\n        `[Directive] module '${id}': fact key '${key}' conflicts with a reserved namespace pivot or evaluation alias (self / prev / current / a crossModuleDep namespace). Three fixes:\\n` +\n          `  1. Rename the fact (e.g. ${key}_)\\n` +\n          `  2. Remove '${key}' from this module's crossModuleDeps if it's not actually needed\\n` +\n          `  3. Move the fact under a wrapping namespace (t.object({ inner: ... }))`,\n      );\n    }\n  }\n}\n\n/**\n * Reject constraint `owns` entries that name a reserved property — a\n * `BLOCKED_PROPS` key (`__proto__`, `constructor`, `prototype`) or a\n * `$`-prefixed key. Such names can never be owned fact slots, so the\n * clobber-detection binding would silently no-op. A structural integrity\n * check — runs unconditionally, not just in dev.\n */\nfunction validateOwnsKeys<M extends ModuleSchema>(\n  id: string,\n  config: ModuleConfig<M> | ModuleConfigWithDeps<M, CrossModuleDeps>,\n): void {\n  const constraints = config.constraints as\n    | Record<string, { owns?: readonly string[] }>\n    | undefined;\n  if (!constraints) {\n    return;\n  }\n  for (const [cid, constraint] of Object.entries(constraints)) {\n    const owns = constraint?.owns;\n    if (!owns) {\n      continue;\n    }\n    for (const key of owns) {\n      if (BLOCKED_PROPS.has(key) || key.startsWith(\"$\")) {\n        throw new Error(\n          `[Directive] module '${id}' constraint '${cid}': owns key '${key}' is reserved (BLOCKED_PROPS or $-prefixed)`,\n        );\n      }\n    }\n  }\n}\n\n/** Run all dev-mode validations for a module config */\nfunction validateModuleConfig<M extends ModuleSchema>(\n  id: string,\n  config: ModuleConfig<M> | ModuleConfigWithDeps<M, CrossModuleDeps>,\n): void {\n  validateModuleId(id);\n\n  if (!config.schema) {\n    console.warn(\"[Directive] Module schema is required\");\n  } else if (!config.schema.facts) {\n    console.warn(\"[Directive] Module schema.facts is required\");\n  }\n\n  validateKeyAlignment(\n    new Set(Object.keys(config.derive ?? {})),\n    new Set(Object.keys(config.schema?.derivations ?? {})),\n    \"Derivation\",\n    \"schema.derivations\",\n    \"has no matching implementation in derive\",\n  );\n\n  validateKeyAlignment(\n    new Set(Object.keys(config.events ?? {})),\n    new Set(Object.keys(config.schema?.events ?? {})),\n    \"Event\",\n    \"schema.events\",\n    \"has no matching handler in events\",\n  );\n\n  if (config.history?.snapshotEvents) {\n    validateSnapshotEvents(\n      config.history.snapshotEvents as string[],\n      config.schema?.events ?? {},\n    );\n  }\n\n  if (config.resolvers && config.schema?.requirements) {\n    validateResolverRequirements(\n      config.resolvers as Record<string, unknown>,\n      config.schema.requirements,\n    );\n  }\n}\n\n// ============================================================================\n// createModule\n// ============================================================================\n\n/**\n * Create a module definition with full type inference.\n *\n * The consolidated schema provides:\n * - Derivation composition (`derived.otherDerivation` is typed)\n * - Event dispatch (`system.dispatch({ type: \"...\" })` has autocomplete)\n * - Resolver requirements (`req.payload` is typed based on requirement type)\n *\n * @param id - Unique module identifier (kebab-case recommended)\n * @param config - Module configuration including schema, init, derive, constraints, resolvers, etc.\n * @returns A frozen module definition ready for use with `createSystem`\n *\n * @example\n * ```ts\n * const trafficLight = createModule(\"traffic-light\", {\n *   schema: {\n *     facts: {\n *       phase: t.string<\"red\" | \"green\" | \"yellow\">(),\n *       elapsed: t.number(),\n *     },\n *     derivations: {\n *       isRed: t.boolean(),\n *       timeRemaining: t.number(),\n *     },\n *     events: {\n *       tick: {},\n *       setPhase: { phase: t.string<\"red\" | \"green\" | \"yellow\">() },\n *     },\n *     requirements: {\n *       TRANSITION: { to: t.string<\"red\" | \"green\" | \"yellow\">() },\n *     },\n *   },\n *   init: (facts) => {\n *     facts.phase = \"red\";\n *     facts.elapsed = 0;\n *   },\n *   derive: {\n *     isRed: (facts) => facts.phase === \"red\",\n *     timeRemaining: (facts, derived) => {\n *       // derived.isRed is typed as boolean!\n *       return derived.isRed ? 30 - facts.elapsed : 0;\n *     },\n *   },\n *   events: {\n *     tick: (facts) => { facts.elapsed += 1; },\n *     setPhase: (facts, { phase }) => { facts.phase = phase; }, // phase is typed!\n *   },\n *   constraints: {\n *     shouldTransition: {\n *       when: (facts) => facts.phase === \"red\" && facts.elapsed > 30,\n *       require: { type: \"TRANSITION\", to: \"green\" },\n *     },\n *   },\n *   resolvers: {\n *     transition: {\n *       requirement: \"TRANSITION\",\n *       resolve: async (req, ctx) => {\n *         ctx.facts.phase = req.to; // req.to is typed!\n *         ctx.facts.elapsed = 0;\n *       },\n *     },\n *   },\n *   hooks: {\n *     // Optional: observe resolver failures owned by this module.\n *     // Fires AFTER retries are exhausted and the engine has handled the error\n *     // (error boundary, plugin emit, retry decision). Use it as a side-channel\n *     // observer for module-local logging/telemetry — not for recovery.\n *     onResolverError: (error, requirement, ctx) => {\n *       console.warn(`[traffic-light] resolver failed for ${requirement.type}`, error);\n *     },\n *   },\n * });\n * ```\n *\n * @example With cross-module dependencies\n * ```ts\n * import { authSchema } from './auth';\n *\n * const dataModule = createModule(\"data\", {\n *   schema: dataSchema,\n *   crossModuleDeps: { auth: authSchema },\n *   constraints: {\n *     fetchWhenAuth: {\n *       when: (facts) => {\n *         // facts.self.* for own module, facts.auth.* for cross-module\n *         return facts.auth.isAuthenticated && facts.self.users.length === 0;\n *       },\n *       require: { type: \"FETCH_USERS\" },\n *     },\n *   },\n *   derive: {\n *     canFetch: (facts) => facts.auth.isAuthenticated && facts.self.users.length === 0,\n *   },\n * });\n * ```\n *\n * @public\n */\n// Overload 1: With crossModuleDeps\nexport function createModule<\n  const M extends ModuleSchema,\n  const Deps extends CrossModuleDeps,\n>(id: string, config: ModuleConfigWithDeps<M, Deps>): ModuleDef<M>;\n\n// Overload 2: Without crossModuleDeps (original signature)\nexport function createModule<const M extends ModuleSchema>(\n  id: string,\n  config: ModuleConfig<M>,\n): ModuleDef<M>;\n\n// Overload 3: Union (used by createModuleFactory)\nexport function createModule<const M extends ModuleSchema>(\n  id: string,\n  config: ModuleConfigWithDeps<M, CrossModuleDeps> | ModuleConfig<M>,\n): ModuleDef<M>;\n\n/** @internal Implementation overload — see public overloads above. */\nexport function createModule<const M extends ModuleSchema>(\n  id: string,\n  config: ModuleConfig<M> | ModuleConfigWithDeps<M, CrossModuleDeps>,\n): ModuleDef<M> {\n  // Pivot-name conflicts are a structural integrity check, not a dev\n  // convenience — run unconditionally.\n  validatePivotNameConflicts(id, config);\n\n  // Reserved `owns` keys would silently disable clobber-detection — a\n  // structural integrity check, run unconditionally.\n  validateOwnsKeys(id, config);\n\n  if (isDevelopment) {\n    validateModuleConfig(id, config);\n  }\n\n  // Extract crossModuleDeps if present (for runtime proxy creation)\n  const crossModuleDeps =\n    \"crossModuleDeps\" in config ? config.crossModuleDeps : undefined;\n\n  return {\n    id,\n    schema: config.schema,\n    init: config.init,\n    // Cast to TypedDerivationsDef for ModuleDef compatibility (runtime handles both types)\n    derive: (config.derive ?? {}) as TypedDerivationsDef<M>,\n    events: config.events ?? ({} as TypedEventsDef<M>),\n    effects: config.effects as EffectsDef<M[\"facts\"]> | undefined,\n    constraints: config.constraints as TypedConstraintsDef<M> | undefined,\n    resolvers: config.resolvers,\n    hooks: config.hooks,\n    meta: config.meta,\n    history: config.history,\n    // Store crossModuleDeps for runtime proxy creation\n    crossModuleDeps: crossModuleDeps as CrossModuleDeps | undefined,\n  };\n}\n\n/**\n * Create a module factory that produces named instances from a single definition.\n * Useful for multi-instance UIs (tabs, panels, multi-tenant) where you need\n * isolated state from the same schema.\n *\n * @param config - Module configuration (same shape as `createModule` minus the `id`)\n * @returns A factory function that accepts a name and returns a `ModuleDef`\n *\n * @example\n * ```typescript\n * const chatRoom = createModuleFactory({\n *   schema: {\n *     facts: { messages: t.array<string>(), users: t.array<string>() },\n *     derivations: { count: t.number() },\n *   },\n *   init: (facts) => { facts.messages = []; facts.users = []; },\n *   derive: { count: (facts) => facts.messages.length },\n * });\n *\n * const system = createSystem({\n *   modules: {\n *     lobby: chatRoom(\"lobby\"),\n *     support: chatRoom(\"support\"),\n *   },\n * });\n * ```\n *\n * @public\n */\nexport function createModuleFactory<const M extends ModuleSchema>(\n  config: ModuleConfig<M>,\n): (name: string) => ModuleDef<M>;\nexport function createModuleFactory<\n  const M extends ModuleSchema,\n  const Deps extends CrossModuleDeps,\n>(config: ModuleConfigWithDeps<M, Deps>): (name: string) => ModuleDef<M>;\n/** @internal Implementation overload — see public overloads above. */\nexport function createModuleFactory<const M extends ModuleSchema>(\n  config: ModuleConfig<M> | ModuleConfigWithDeps<M, CrossModuleDeps>,\n): (name: string) => ModuleDef<M> {\n  // Pass config directly — createModule's implementation overload handles both types.\n  // Do NOT cast to ModuleConfig<M> which would strip crossModuleDeps.\n  return (name: string) => createModule(name, config);\n}\n","/**\n * Requirement Status Utilities\n *\n * Provides reactive tracking of requirement status for UI feedback.\n */\n\nimport type { Plugin, RequirementWithId } from \"../core/types.js\";\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/** Status of a requirement type */\nexport interface RequirementTypeStatus {\n  /** Number of pending (unmet) requirements of this type */\n  pending: number;\n  /** Number of inflight (being resolved) requirements of this type */\n  inflight: number;\n  /** Number of failed requirements of this type */\n  failed: number;\n  /** Whether any requirements of this type are loading (pending or inflight) */\n  isLoading: boolean;\n  /** Whether any requirements of this type have failed */\n  hasError: boolean;\n  /** Last error for this type (if any) */\n  lastError: Error | null;\n}\n\n/** Status tracking state */\ninterface StatusState {\n  pending: Map<string, Set<string>>; // type -> set of requirement IDs\n  inflight: Map<string, Set<string>>; // type -> set of requirement IDs\n  failed: Map<string, Set<string>>; // type -> set of requirement IDs\n  errors: Map<string, Error>; // type -> last error\n  listeners: Set<() => void>;\n}\n\n// ============================================================================\n// Requirement Status Plugin\n// ============================================================================\n\n/**\n * Create a plugin that tracks requirement status for reactive UI updates.\n *\n * @example\n * ```typescript\n * import { createRequirementStatusPlugin } from '@directive-run/core';\n *\n * const statusPlugin = createRequirementStatusPlugin();\n *\n * const system = createSystem({\n *   modules: [myModule],\n *   plugins: [statusPlugin.plugin],\n * });\n *\n * // Get status for a requirement type\n * const status = statusPlugin.getStatus(\"FETCH_USER\");\n * console.log(status.isLoading, status.hasError);\n *\n * // Subscribe to status changes\n * const unsubscribe = statusPlugin.subscribe(() => {\n *   console.log(\"Status changed:\", statusPlugin.getStatus(\"FETCH_USER\"));\n * });\n * ```\n */\nexport function createRequirementStatusPlugin(): {\n  plugin: Plugin<never>;\n  getStatus: (type: string) => RequirementTypeStatus;\n  getAllStatus: () => Map<string, RequirementTypeStatus>;\n  subscribe: (listener: () => void) => () => void;\n  reset: () => void;\n} {\n  const state: StatusState = {\n    pending: new Map(),\n    inflight: new Map(),\n    failed: new Map(),\n    errors: new Map(),\n    listeners: new Set(),\n  };\n\n  /** Notify all listeners */\n  function notify(): void {\n    for (const listener of state.listeners) {\n      listener();\n    }\n  }\n\n  /** Get or create a set for a type in a map */\n  function getOrCreateSet(\n    map: Map<string, Set<string>>,\n    type: string,\n  ): Set<string> {\n    let set = map.get(type);\n    if (!set) {\n      set = new Set();\n      map.set(type, set);\n    }\n    return set;\n  }\n\n  /** Get status for a requirement type */\n  function getStatus(type: string): RequirementTypeStatus {\n    const pendingSet = state.pending.get(type) ?? new Set();\n    const inflightSet = state.inflight.get(type) ?? new Set();\n    const failedSet = state.failed.get(type) ?? new Set();\n    const lastError = state.errors.get(type) ?? null;\n\n    return {\n      pending: pendingSet.size,\n      inflight: inflightSet.size,\n      failed: failedSet.size,\n      isLoading: pendingSet.size > 0 || inflightSet.size > 0,\n      hasError: failedSet.size > 0,\n      lastError,\n    };\n  }\n\n  /** Get status for all tracked types */\n  function getAllStatus(): Map<string, RequirementTypeStatus> {\n    const allTypes = new Set([\n      ...state.pending.keys(),\n      ...state.inflight.keys(),\n      ...state.failed.keys(),\n    ]);\n\n    const result = new Map<string, RequirementTypeStatus>();\n    for (const type of allTypes) {\n      result.set(type, getStatus(type));\n    }\n    return result;\n  }\n\n  /** Subscribe to status changes */\n  function subscribe(listener: () => void): () => void {\n    state.listeners.add(listener);\n    return () => state.listeners.delete(listener);\n  }\n\n  /** Reset all status */\n  function reset(): void {\n    state.pending.clear();\n    state.inflight.clear();\n    state.failed.clear();\n    state.errors.clear();\n    notify();\n  }\n\n  const plugin: Plugin<never> = {\n    name: \"requirement-status\",\n\n    onRequirementCreated(req: RequirementWithId) {\n      const type = req.requirement.type;\n      getOrCreateSet(state.pending, type).add(req.id);\n      // Clear from failed when a new requirement is created\n      state.failed.get(type)?.delete(req.id);\n      notify();\n    },\n\n    onResolverStart(_resolver: string, req: RequirementWithId) {\n      const type = req.requirement.type;\n      // Move from pending to inflight\n      state.pending.get(type)?.delete(req.id);\n      getOrCreateSet(state.inflight, type).add(req.id);\n      notify();\n    },\n\n    onResolverComplete(_resolver: string, req: RequirementWithId) {\n      const type = req.requirement.type;\n      // Remove from inflight\n      state.inflight.get(type)?.delete(req.id);\n      state.pending.get(type)?.delete(req.id);\n      notify();\n    },\n\n    onResolverError(_resolver: string, req: RequirementWithId, error: unknown) {\n      const type = req.requirement.type;\n      // Move from inflight to failed\n      state.inflight.get(type)?.delete(req.id);\n      getOrCreateSet(state.failed, type).add(req.id);\n      state.errors.set(\n        type,\n        error instanceof Error ? error : new Error(String(error)),\n      );\n      notify();\n    },\n\n    onResolverCancel(_resolver: string, req: RequirementWithId) {\n      const type = req.requirement.type;\n      // Remove from all tracking\n      state.pending.get(type)?.delete(req.id);\n      state.inflight.get(type)?.delete(req.id);\n      notify();\n    },\n\n    onRequirementMet(req: RequirementWithId) {\n      const type = req.requirement.type;\n      // Clean up when requirement is met\n      state.pending.get(type)?.delete(req.id);\n      state.inflight.get(type)?.delete(req.id);\n      notify();\n    },\n  };\n\n  return {\n    plugin,\n    getStatus,\n    getAllStatus,\n    subscribe,\n    reset,\n  };\n}\n\n// ============================================================================\n// React Hook Helper (for use with React adapter)\n// ============================================================================\n\n/**\n * Create a hook factory for requirement status.\n * This is designed to be used with React's useSyncExternalStore.\n *\n * @example\n * ```typescript\n * import { useSyncExternalStore } from 'react';\n * import { createRequirementStatusPlugin, createStatusHook } from '@directive-run/core';\n *\n * const statusPlugin = createRequirementStatusPlugin();\n * const useRequirementStatus = createStatusHook(statusPlugin);\n *\n * function MyComponent() {\n *   const status = useRequirementStatus(\"FETCH_USER\");\n *   if (status.isLoading) return <Spinner />;\n *   if (status.hasError) return <Error error={status.lastError} />;\n *   return <Content />;\n * }\n * ```\n */\nexport function createStatusHook(\n  statusPlugin: ReturnType<typeof createRequirementStatusPlugin>,\n): (type: string) => RequirementTypeStatus {\n  // This returns a function that can be used with useSyncExternalStore\n  // The actual hook implementation would be in the React adapter\n  return (type: string) => statusPlugin.getStatus(type);\n}\n","/**\n * System with Status Plugin Helper\n *\n * Convenience function for creating a system with status tracking enabled.\n */\n\nimport { createSystem } from \"../core/system.js\";\nimport type {\n  ErrorBoundaryConfig,\n  ModuleDef,\n  ModuleSchema,\n  Plugin,\n  SingleModuleSystem,\n  TraceOption,\n} from \"../core/types.js\";\nimport { createRequirementStatusPlugin } from \"./requirement-status.js\";\n\n/** Options for createSystemWithStatus */\nexport interface CreateSystemWithStatusOptions<M extends ModuleSchema> {\n  /** The module to use for the system */\n  module: ModuleDef<M>;\n  /** Additional plugins to include alongside the status plugin */\n  // biome-ignore lint/suspicious/noExplicitAny: Plugin generic contravariance issues\n  plugins?: Plugin<any>[];\n  /** Trace: per-run reconciliation changelog */\n  trace?: TraceOption;\n  /** Error boundary configuration */\n  errorBoundary?: ErrorBoundaryConfig;\n  /** Tick interval in milliseconds */\n  tickMs?: number;\n  /** Enable zero-config mode */\n  zeroConfig?: boolean;\n  /** Initial facts to set on the system */\n  // biome-ignore lint/suspicious/noExplicitAny: Facts type varies by module\n  initialFacts?: Record<string, any>;\n}\n\n/** Return type for createSystemWithStatus */\nexport interface SystemWithStatus<M extends ModuleSchema> {\n  /**\n   * The Directive system instance.\n   * This is a SingleModuleSystem - use system.facts, system.dispatch(), etc.\n   */\n  system: SingleModuleSystem<M>;\n  /** The status plugin for use with useRequirementStatus hooks */\n  statusPlugin: ReturnType<typeof createRequirementStatusPlugin>;\n}\n\n/**\n * Create a Directive system with a status plugin pre-configured.\n *\n * This is a convenience wrapper around `createSystem` and `createRequirementStatusPlugin`\n * that handles the wiring automatically. The status plugin is added to the system's\n * plugins array so it receives lifecycle events.\n *\n * @param options - System configuration options\n * @returns An object containing both the system and the statusPlugin\n *\n * @example\n * ```tsx\n * import { createSystemWithStatus } from '@directive-run/core';\n * import { useRequirementStatus, useFact } from '@directive-run/react';\n *\n * // Simple setup - no provider needed\n * const { system, statusPlugin } = createSystemWithStatus({\n *   module: myModule,\n * });\n * system.start();\n *\n * function App() {\n *   const data = useFact(system, \"data\");\n *   return <LoadingIndicator />;\n * }\n *\n * function LoadingIndicator() {\n *   const status = useRequirementStatus(statusPlugin, \"FETCH_DATA\");\n *   if (status.isLoading) return <Spinner />;\n *   if (status.hasError) return <Error message={status.lastError?.message} />;\n *   return <Content />;\n * }\n * ```\n */\nexport function createSystemWithStatus<M extends ModuleSchema>(\n  options: CreateSystemWithStatusOptions<M>,\n): SystemWithStatus<M> {\n  // Create the status plugin\n  const statusPlugin = createRequirementStatusPlugin();\n\n  // Add the plugin to the options\n  const existingPlugins = options.plugins ?? [];\n\n  // Create the system with the status plugin included\n  // Use type assertion to bypass overload resolution issues\n  // biome-ignore lint/suspicious/noExplicitAny: Required for overload compatibility\n  const allPlugins = [...existingPlugins, statusPlugin.plugin] as Plugin<any>[];\n  // biome-ignore lint/suspicious/noExplicitAny: Required for overload compatibility\n  const system = createSystem({\n    module: options.module,\n    plugins: allPlugins,\n    trace: options.trace,\n    errorBoundary: options.errorBoundary,\n    tickMs: options.tickMs,\n    zeroConfig: options.zeroConfig,\n    initialFacts: options.initialFacts,\n    // biome-ignore lint/suspicious/noExplicitAny: Required for overload compatibility\n  } as any);\n\n  return {\n    // The system returned by createSystem with a single module is a SingleModuleSystem\n    system: system as SingleModuleSystem<M>,\n    statusPlugin,\n  };\n}\n","/**\n * SignalClock — injectable clock source for declarative timers (RFC 0001).\n *\n * The clock interface decouples Directive's timer primitives from any\n * single time source. Production uses `realClock()`. Tests use\n * `virtualClock()` which advances synchronously via `clock.advanceBy()`.\n * Replay / dehydrate scenarios use a clock seeded from the recorded\n * stream.\n *\n * Auto-detection: `defaultClock()` returns `virtualClock()` when running\n * under Vitest (process.env.VITEST === 'true'), otherwise `realClock()`.\n * Consumers can pass an explicit clock to `createSystem({ clock })` to\n * override.\n *\n * @see ../../docs/rfcs/0001-t-timer.md\n */\n\n/**\n * Stable interface for any time source.\n */\nexport interface SignalClock {\n  /** Current time, in milliseconds since the Unix epoch. */\n  now(): number;\n  /**\n   * Schedule a callback to fire after `ms` milliseconds. Returns a\n   * cancellation function. Implementations may queue callbacks or fire\n   * them on a tick boundary; the only contract is \"fires no earlier\n   * than `ms` from now.\"\n   */\n  setTimeout(cb: () => void, ms: number): () => void;\n  /**\n   * (Test-only.) Synchronously advance the clock by `ms` milliseconds,\n   * firing all scheduled callbacks whose deadlines fall within the\n   * advanced window. Real clocks throw if called.\n   */\n  advanceBy?(ms: number): void;\n}\n\n/**\n * Production clock — wraps `Date.now()` and `globalThis.setTimeout`.\n * No mocking, no virtualization.\n */\nexport function realClock(): SignalClock {\n  return {\n    now: () => Date.now(),\n    setTimeout: (cb, ms) => {\n      const handle = globalThis.setTimeout(cb, ms);\n      return () => globalThis.clearTimeout(handle);\n    },\n  };\n}\n\n/**\n * Virtual clock — advances only when `advanceBy(ms)` is called. All\n * scheduled callbacks fire synchronously in order of their deadlines.\n *\n * Two scheduled callbacks at the same deadline fire in registration order.\n * Cancellation is O(1).\n */\nexport function virtualClock(initialMs = 0): SignalClock {\n  let nowMs = initialMs;\n  let nextId = 0;\n  interface Scheduled {\n    id: number;\n    deadlineMs: number;\n    cb: () => void;\n    canceled: boolean;\n  }\n  const queue: Scheduled[] = [];\n\n  return {\n    now: () => nowMs,\n    setTimeout: (cb, ms) => {\n      const entry: Scheduled = {\n        id: nextId++,\n        deadlineMs: nowMs + ms,\n        cb,\n        canceled: false,\n      };\n      queue.push(entry);\n      return () => {\n        entry.canceled = true;\n      };\n    },\n    advanceBy: (ms) => {\n      const targetMs = nowMs + ms;\n      // Fire all callbacks whose deadlines fall in [nowMs, targetMs].\n      // Sort live entries by deadline + registration order so ties\n      // resolve deterministically.\n      while (true) {\n        const ready = queue\n          .filter((e) => !e.canceled && e.deadlineMs <= targetMs)\n          .sort((a, b) =>\n            a.deadlineMs !== b.deadlineMs\n              ? a.deadlineMs - b.deadlineMs\n              : a.id - b.id,\n          );\n        if (ready.length === 0) break;\n        const next = ready[0]!;\n        // Advance \"now\" monotonically — never let a callback that\n        // schedules another callback in the past pull `nowMs`\n        // backward. Without this clamp, `setTimeout(cb2, -5)` from\n        // inside a callback would make `clock.now()` return a smaller\n        // value mid-advance, breaking elapsedMs (negative results)\n        // and replay determinism. (R1 sec C3.)\n        nowMs = Math.max(nowMs, next.deadlineMs);\n        next.canceled = true;\n        next.cb();\n      }\n      // Final advance — even if no callbacks fired in [nowMs, targetMs],\n      // wall clock still moves forward.\n      nowMs = Math.max(nowMs, targetMs);\n    },\n  };\n}\n\n/**\n * Returns `realClock()` always.\n *\n * Earlier drafts auto-detected vitest (`process.env.VITEST === 'true'`)\n * and returned a `virtualClock()` in that environment. AE review\n * flagged this as a footgun: tests that legitimately need real time\n * (sleep-based debounce checks, real-`setTimeout`-bound integration\n * fixtures) silently received a virtual clock that never advanced\n * unless the test author called `advanceBy()`, producing apparent\n * deadlocks indistinguishable from genuine bugs. Auto-detection is\n * therefore opt-in.\n *\n * Use {@link virtualClock} explicitly in tests:\n *\n * ```ts\n * const clock = virtualClock(0);\n * const sys = createSystem({ module, clock });\n * clock.advanceBy(1_000);\n * ```\n */\nexport function defaultClock(): SignalClock {\n  return realClock();\n}\n","/**\n * Timer fact — a runtime container that advances over time on a\n * SignalClock (RFC 0001 v0.1).\n *\n * Produced by `createTimerFact(clock, opts)`. Holds the durable state\n * (startedAtMs, pausedDurationMs, status) and exposes a control surface\n * (start, pause, resume, reset) plus reactive reads (elapsedMs,\n * remainingMs, status).\n *\n * v0.1 SCOPE: timer is a \"thick fact\" — a single object you store in a\n * regular Directive fact (e.g. `t.object<TimerFactState>()`). The\n * engine doesn't auto-tick it; the consumer is responsible for calling\n * `timer.tick()` when they want elapsedMs / remainingMs to update.\n * Typical wiring: a setInterval in the consumer that calls `timer.tick()`\n * and dispatches an event when status changes.\n *\n * v0.2 (deferred): true `t.timer({ms})` schema integration where the\n * engine subscribes to the clock and writes the fact deltas itself,\n * eliminating the consumer-side tick wiring.\n *\n * @see ../../docs/rfcs/0001-t-timer.md\n */\n\n// SignalClock is the canonical time source for timer ops; consumers\n// pass `clock.now()` into the helpers below. Re-exported by index.ts\n// alongside this module so they can `import { realClock, timerOps,\n// initialTimerState } from \"@directive-run/core\"` together.\n\n/**\n * Persistent timer state — JSON-roundtrippable, suitable for storing\n * inside a Directive fact.\n */\nexport interface TimerFactState {\n  /** Unix-ms when the timer last started or resumed. null = not running. */\n  startedAtMs: number | null;\n  /** Total ms accumulated while paused. */\n  pausedDurationMs: number;\n  /** ms when the timer was paused, if currently paused. null otherwise. */\n  pausedAtMs: number | null;\n  /**\n   * - 'idle': not yet started, or reset.\n   * - 'running': currently counting.\n   * - 'paused': paused; pausedAtMs is set.\n   * - 'completed': hit the deadline (countdown mode only).\n   */\n  status: \"idle\" | \"running\" | \"paused\" | \"completed\";\n  /** Number of times the timer has fired (repeat mode only). */\n  repeats: number;\n}\n\nexport interface TimerFactOpts {\n  /** Duration in ms. Countdown mode counts this down; up mode counts up to ∞. */\n  ms: number;\n  /**\n   * - 'down' (default): counts down from `ms` to 0; status → 'completed' at 0.\n   * - 'up': counts elapsed time; never completes.\n   * - 'repeat': fires every `ms`; increments `repeats`; status stays 'running'.\n   */\n  mode?: \"down\" | \"up\" | \"repeat\";\n}\n\n/**\n * Initial state for a newly-created timer. Pass this to your Directive\n * `init()` to seed the fact.\n */\nexport function initialTimerState(): TimerFactState {\n  return {\n    startedAtMs: null,\n    pausedDurationMs: 0,\n    pausedAtMs: null,\n    status: \"idle\",\n    repeats: 0,\n  };\n}\n\n/**\n * Compute elapsed ms for a given timer state at a given clock-now.\n * Pure function — no side effects, no reads beyond its inputs.\n *\n * @example\n * ```ts\n * const elapsed = elapsedMs(facts.countdown, clock.now());\n * if (elapsed >= 60_000) {\n *   facts.countdown = { ...facts.countdown, status: 'completed' };\n * }\n * ```\n */\nexport function elapsedMs(state: TimerFactState, nowMs: number): number {\n  if (state.startedAtMs === null) return 0;\n  // Clamp at 0 — a clock step-back (NTP correction, virtual-clock\n  // re-entrancy, replay seeded from older snapshot) would otherwise\n  // produce negative elapsed values that:\n  //   - make tickTimer never report 'complete' (because `elapsed >= ms`\n  //     stays false past the deadline)\n  //   - make remainingMs report values > the configured ms total\n  //   - silently wrap into pausedDurationMs accumulation downstream\n  // (R1 sec C4.)\n  if (state.status === \"paused\" && state.pausedAtMs !== null) {\n    return Math.max(\n      0,\n      state.pausedAtMs - state.startedAtMs - state.pausedDurationMs,\n    );\n  }\n  return Math.max(0, nowMs - state.startedAtMs - state.pausedDurationMs);\n}\n\n/**\n * Compute remaining ms for a countdown timer at a given clock-now.\n * Returns 0 if the timer has hit zero or hasn't started.\n */\nexport function remainingMs(\n  state: TimerFactState,\n  nowMs: number,\n  totalMs: number,\n): number {\n  return Math.max(0, totalMs - elapsedMs(state, nowMs));\n}\n\n/**\n * Transition: start an idle (or reset) timer.\n *\n * No-op if already running, paused, or completed (use `reset()` first).\n */\nexport function startTimer(\n  state: TimerFactState,\n  nowMs: number,\n): TimerFactState {\n  if (state.status === \"running\") return state;\n  if (state.status === \"paused\") return state;\n  return {\n    ...state,\n    startedAtMs: nowMs,\n    pausedDurationMs: 0,\n    pausedAtMs: null,\n    status: \"running\",\n    repeats: 0,\n  };\n}\n\n/**\n * Transition: pause a running timer. Records the pause moment so a\n * later `resumeTimer()` can correctly extend pausedDurationMs.\n *\n * No-op if not running.\n */\nexport function pauseTimer(\n  state: TimerFactState,\n  nowMs: number,\n): TimerFactState {\n  if (state.status !== \"running\") return state;\n  return { ...state, pausedAtMs: nowMs, status: \"paused\" };\n}\n\n/**\n * Transition: resume a paused timer. Adds the time spent paused into\n * `pausedDurationMs` so elapsed/remaining math stays correct.\n *\n * No-op if not paused.\n */\nexport function resumeTimer(\n  state: TimerFactState,\n  nowMs: number,\n): TimerFactState {\n  if (state.status !== \"paused\") return state;\n  if (state.pausedAtMs === null) return state;\n  // Clamp pausedFor at 0 — clock step-back between pause and resume\n  // would otherwise produce a negative pausedDurationMs accumulation,\n  // which propagates into elapsedMs (returns inflated values), which\n  // prematurely completes countdowns. (R1 sec M1.)\n  const pausedFor = Math.max(0, nowMs - state.pausedAtMs);\n  return {\n    ...state,\n    pausedDurationMs: state.pausedDurationMs + pausedFor,\n    pausedAtMs: null,\n    status: \"running\",\n  };\n}\n\n/**\n * Transition: reset a timer to idle. Loses all elapsed time + repeat\n * count. Equivalent to `initialTimerState()`.\n */\nexport function resetTimer(): TimerFactState {\n  return initialTimerState();\n}\n\n/**\n * Transition: mark the timer completed. For countdown mode when\n * elapsed reaches `ms`; for repeat mode when consumer wants to halt.\n */\nexport function completeTimer(state: TimerFactState): TimerFactState {\n  return { ...state, status: \"completed\" };\n}\n\n/**\n * Transition: register a repeat firing. Increments `repeats` and\n * advances `startedAtMs` by `ms` so the next interval lands at the\n * intended boundary (drift-free).\n */\nexport function registerRepeat(\n  state: TimerFactState,\n  ms: number,\n): TimerFactState {\n  if (state.startedAtMs === null) return state;\n  // Defensible-illegal: registerRepeat from a paused state would\n  // otherwise advance startedAtMs while leaving status === 'paused',\n  // producing an inconsistent state (logically running by clock math\n  // but reads as paused). No-op instead. (R2 sec m-R2-2.)\n  if (state.status === \"paused\") return state;\n  // Reset pausedDurationMs on each repeat so accumulated pause time\n  // from prior intervals does not double-count into the next\n  // interval's elapsed math. Without this reset, every repeat after a\n  // pause would arithmetic-drift the next deadline by the cumulative\n  // pause window. (R1 sec M9.)\n  return {\n    ...state,\n    startedAtMs: state.startedAtMs + ms,\n    pausedDurationMs: 0,\n    pausedAtMs: null,\n    repeats: state.repeats + 1,\n  };\n}\n\n/**\n * Higher-level helper: given a timer state, total ms, and the current\n * clock, return whether the timer should transition to 'completed' (for\n * countdown mode) or fire a repeat (for repeat mode).\n *\n * Pure — does not mutate state. Returns a structured signal the consumer\n * applies via `completeTimer` / `registerRepeat`.\n */\nexport function tickTimer(\n  state: TimerFactState,\n  nowMs: number,\n  opts: TimerFactOpts,\n): { kind: \"no-op\" } | { kind: \"complete\" } | { kind: \"repeat\" } {\n  if (state.status !== \"running\") return { kind: \"no-op\" };\n  const elapsed = elapsedMs(state, nowMs);\n\n  if (opts.mode === \"up\") {\n    // 'up' never completes; consumer reads elapsedMs directly.\n    return { kind: \"no-op\" };\n  }\n\n  if (opts.mode === \"repeat\") {\n    if (elapsed >= opts.ms) return { kind: \"repeat\" };\n    return { kind: \"no-op\" };\n  }\n\n  // 'down' (default)\n  if (elapsed >= opts.ms) return { kind: \"complete\" };\n  return { kind: \"no-op\" };\n}\n\n/**\n * Bundle of helpers for one timer in one module — convenience for\n * callers who want a single import. Each method takes the current\n * state and clock-now, returns the next state. No mutation.\n *\n * @example\n * ```ts\n * import {\n *   createSystem,\n *   t,\n *   realClock,\n *   timerOps,\n *   initialTimerState,\n *   type TimerFactState,\n * } from '@directive-run/core';\n *\n * const clock = realClock();\n * const ops = timerOps({ ms: 60_000, mode: 'down' });\n *\n * createModule('countdown', {\n *   schema: { facts: { state: t.object<TimerFactState>() }, events: { START: {} } },\n *   init: (f) => { f.state = initialTimerState(); },\n *   events: {\n *     START: (f) => { f.state = ops.start(f.state, clock.now()); },\n *   },\n * });\n *\n * // In the consumer (React, Node, edge), tick periodically:\n * setInterval(() => {\n *   const signal = ops.tick(f.state, clock.now());\n *   if (signal.kind === 'complete') {\n *     sys.dispatch({ type: 'TIMEOUT' });\n *   }\n * }, 100);\n * ```\n */\nexport function timerOps(opts: TimerFactOpts) {\n  return {\n    initial: initialTimerState,\n    start: startTimer,\n    pause: pauseTimer,\n    resume: resumeTimer,\n    reset: resetTimer,\n    complete: completeTimer,\n    registerRepeat: (state: TimerFactState) => registerRepeat(state, opts.ms),\n    tick: (state: TimerFactState, nowMs: number) =>\n      tickTimer(state, nowMs, opts),\n    elapsedMs,\n    remainingMs: (state: TimerFactState, nowMs: number) =>\n      remainingMs(state, nowMs, opts.ms),\n  };\n}\n","/**\n * @directive-run/core\n *\n * Constraint-driven runtime for TypeScript.\n *\n * Also available:\n * - `@directive-run/core/internals` – Manager factories, engine, tracking, and internal types\n * - `@directive-run/core/plugins` – Logging, devtools, persistence, observability, circuit breaker\n * - `@directive-run/core/testing` – Mock resolvers, fake timers, assertion helpers\n * - `@directive-run/core/migration` – Redux/Zustand/XState migration scaffolding\n * - `@directive-run/core/adapter-utils` – Shared framework adapter utilities\n * - `@directive-run/core/worker` – Web Worker support\n *\n * @packageDocumentation\n */\n\n// ============================================================================\n// Core Types — what 90% of users need\n// ============================================================================\n\nexport type {\n  // Schema\n  Schema,\n  SchemaType,\n  InferSchemaType,\n  // Module Schema (consolidated)\n  ModuleSchema,\n  InferFacts,\n  InferDerivations,\n  InferSelectorState,\n  InferEvents,\n  InferRequirements,\n  InferRequirementTypes,\n  // Facts\n  Facts,\n  FactsSnapshot,\n  // Requirements\n  Requirement,\n  RequirementWithId,\n  // Constraints + Resolvers (config types)\n  RetryPolicy,\n  BatchConfig,\n  // Plugins\n  Plugin,\n  Snapshot,\n  // Errors\n  ErrorBoundaryConfig,\n  // Module\n  ModuleDef,\n  ModuleHooks,\n  // System\n  System,\n  SystemConfig,\n  SystemInspection,\n  SystemSnapshot,\n  MetaAccessor,\n  MetaMatch,\n  ObservationEvent,\n  // Trace\n  TraceEntry,\n  TraceOption,\n  // History\n  HistoryOption,\n  HistoryAPI,\n  HistoryState,\n  // Composition (Namespaced Multi-Module)\n  ModulesMap,\n  NamespacedSystem,\n  CreateSystemOptionsNamed,\n  // Single Module\n  CreateSystemOptionsSingle,\n  SingleModuleSystem,\n  // Type Guards\n  SystemMode,\n  AnySystem,\n  // Cross-Module Dependencies\n  CrossModuleDeps,\n  // Dynamic Definitions\n  DynamicConstraintDef,\n  DynamicEffectDef,\n  DynamicResolverDef,\n  // Definition Meta\n  DefinitionMeta,\n  DerivationDefWithMeta,\n  // Data-configuration predicates and templates\n  FactPredicate,\n  FactTemplate,\n  KeySelector,\n  PatchSpec,\n  PayloadRef,\n  PatchValue,\n  OperatorObject,\n  PredicateObject,\n  PredicateClause,\n  PredicateCombinator,\n  PredicateCombinatorKey,\n  PredicateOp,\n  ClauseResult,\n  // Distributable Snapshots\n  DistributableSnapshot,\n  DistributableSnapshotOptions,\n} from \"./core/types.js\";\n\n// Predicate / template runtime\nexport {\n  applyPatch,\n  memoizePredicate,\n  evaluateKeySelector,\n  evaluatePredicate,\n  evaluatePredicateExplained,\n  evaluateTemplate,\n  extractDeps,\n  extractTemplateKeys,\n  isPredicate,\n  isTemplate,\n  validatePredicate,\n} from \"./core/predicate.js\";\n\n// Predicate backtest — rule-change impact replay\nexport {\n  MAX_REPLAY_FRAMES,\n  framesFromHistory,\n  framesFromSnapshots,\n  replayUnder,\n  toReplayFrames,\n} from \"./core/replay-under.js\";\nexport type {\n  PredicateBacktestReport,\n  ReplayDiffSample,\n  ReplayFrame,\n  ReplayUnderOptions,\n} from \"./core/replay-under.js\";\n\n// Parameter sweep — grid-search predicate templates against recorded history\nexport { MAX_SWEEP_POINTS, sweepUnder } from \"./core/sweep-under.js\";\nexport type {\n  SweepHole,\n  SweepPoint,\n  SweepReport,\n  SweepUnderOptions,\n} from \"./core/sweep-under.js\";\n\n// Rules diff — structural diff of constraint whenSpec across two snapshots\nexport { diffClauses, diffRules, flattenPredicate, toRulesMap } from \"./core/rules-diff.js\";\nexport type {\n  Change,\n  ChangeKind,\n  ConstraintDiff,\n  ConstraintStatus,\n  DiffRulesOptions,\n  LeafClause,\n  RulesDiffReport,\n  RulesMapInput,\n} from \"./core/rules-diff.js\";\n\n// Predicate codegen — one predicate, run on client AND server\nexport { predicateToSQL, predicateToWhere } from \"./core/predicate-to-sql.js\";\nexport type {\n  PredicateToSqlOptions,\n  PredicateToSqlResult,\n} from \"./core/predicate-to-sql.js\";\nexport { predicateToMongo } from \"./core/predicate-to-mongo.js\";\nexport type { PredicateToMongoOptions } from \"./core/predicate-to-mongo.js\";\nexport { predicateToPostgrest } from \"./core/predicate-to-pgrest.js\";\nexport type { PredicateToPostgrestOptions } from \"./core/predicate-to-pgrest.js\";\n\n// ============================================================================\n// Core Classes\n// ============================================================================\n\nexport { DirectiveError } from \"./core/types.js\";\n\n// ============================================================================\n// Schema Type Builders\n// ============================================================================\n\n/**\n * Schema type builders for defining fact types.\n *\n * @example\n * ```ts\n * import { t } from '@directive-run/core';\n *\n * const schema = {\n *   facts: {\n *     count: t.number().min(0).default(0),\n *     name: t.string(),\n *     status: t.enum(\"idle\", \"loading\", \"error\"),\n *     user: t.object<User>().nullable(),\n *   },\n *   derivations: { doubled: t.number() },\n *   events: { increment: {} },\n *   requirements: { FETCH_USER: {} },\n * };\n * ```\n */\nexport {\n  t,\n  type Branded,\n  type ExtendedSchemaType,\n  type ChainableSchemaType,\n} from \"./core/schema-builders.js\";\n\n// ============================================================================\n// Module & System\n// ============================================================================\n\nexport {\n  createModule,\n  createModuleFactory,\n  type ModuleConfig,\n  type ModuleConfigWithDeps,\n} from \"./core/module.js\";\nexport { createSystem } from \"./core/system.js\";\nexport { createSystemWithStatus } from \"./utils/system-with-status.js\";\n\n// Helper factory functions for typed constraint/resolver definitions\nexport {\n  typedConstraint,\n  typedResolver,\n} from \"./core/types.js\";\n\n// ============================================================================\n// Requirements Helpers\n// ============================================================================\n\nexport {\n  req,\n  forType,\n  isRequirementType,\n  generateRequirementId,\n  RequirementSet,\n} from \"./core/requirements.js\";\n\n// ============================================================================\n// Type Guards\n// ============================================================================\n\nexport {\n  isSingleModuleSystem,\n  isNamespacedSystem,\n} from \"./core/types/composition.js\";\n\n// ============================================================================\n// Constants\n// ============================================================================\n\n/**\n * Backoff strategy constants for retry policies.\n *\n * @example\n * ```ts\n * import { Backoff } from '@directive-run/core';\n *\n * retry: { attempts: 3, backoff: Backoff.Exponential, initialDelay: 100 }\n * ```\n */\nexport const Backoff = {\n  /** No delay between retries */\n  None: \"none\",\n  /** Linear delay increase (initialDelay * attempt) */\n  Linear: \"linear\",\n  /** Exponential delay increase (initialDelay * 2^attempt) */\n  Exponential: \"exponential\",\n} as const;\n\n// ============================================================================\n// Requirement Status Utilities\n// ============================================================================\n\nexport {\n  createRequirementStatusPlugin,\n  createStatusHook,\n  type RequirementTypeStatus,\n} from \"./utils/requirement-status.js\";\n\n// ============================================================================\n// Snapshot Utilities\n// ============================================================================\n\nexport {\n  shallowEqual,\n  isSnapshotExpired,\n  validateSnapshot,\n  diffSnapshots,\n  signSnapshot,\n  verifySnapshotSignature,\n  isSignedSnapshot,\n  type DistributableSnapshotLike,\n  type SnapshotDiff,\n  type SnapshotDiffEntry,\n  type SignedSnapshot,\n} from \"./utils/utils.js\";\n\n// ============================================================================\n// Clock + Timer (RFC 0001 v0.1)\n// ============================================================================\n\nexport {\n  type SignalClock,\n  realClock,\n  virtualClock,\n  defaultClock,\n} from \"./core/clock.js\";\n\nexport {\n  type TimerFactState,\n  type TimerFactOpts,\n  initialTimerState,\n  elapsedMs,\n  remainingMs,\n  startTimer,\n  pauseTimer,\n  resumeTimer,\n  resetTimer,\n  completeTimer,\n  registerRepeat,\n  tickTimer,\n  timerOps,\n} from \"./core/timer.js\";\n\n// ============================================================================\n// Lower-level APIs — use \"@directive-run/core/internals\" for these\n// ============================================================================\n// Manager factories, engine, tracking, and internal types are available at:\n//   import { createEngine, createFacts, withTracking } from \"@directive-run/core/internals\"\n//\n// Internal types (FactsStore, FactChange, DerivationState, ConstraintState,\n// DerivationsDef, ConstraintsDef, ResolversDef, EventsDef, ReconcileResult,\n// RecoveryStrategy, ErrorSource, etc.) are also in internals.\n\n// Migration utilities available via \"@directive-run/core/migration\" subpath export.\n"]}
+{"version":3,"sources":["../src/core/replay-under.ts","../src/core/sweep-under.ts","../src/core/rules-diff.ts","../src/core/predict.ts","../src/core/doctor.ts","../src/core/predicate-to-sql.ts","../src/core/predicate-to-mongo.ts","../src/core/predicate-to-pgrest.ts","../src/core/schema-builders.ts","../src/core/module.ts","../src/utils/requirement-status.ts","../src/utils/system-with-status.ts","../src/core/clock.ts","../src/core/timer.ts","../src/index.ts"],"names":["MAX_REPLAY_FRAMES","validateReplaySpec","spec","which","validatePredicate","err","message","isPredicate","preview","unknownOp","walkPredicate","_factPath","op","PREDICATE_OPERATORS","key","PREDICATE_COMBINATORS","toReplayFrames","raw","framesFromHistory","list","entry","index","frame","out","historyExport","parsed","framesFromSnapshots","exportObj","snapshots","i","s","replayUnder","options","frames","original","proposed","entityKey","requested","maxSamples","originalMatched","proposedMatched","newMatchCount","lostMatchCount","unchanged","newMatches","lostMatches","originalEntities","proposedEntities","prevFacts","facts","originalBit","evaluatePredicate","proposedBit","buildSample","report","sample","evaluatePredicateExplained","MAX_SWEEP_POINTS","MAX_SWEEP_EVALUATIONS","isHole","v","substitute","template","values","path","depth","MAX_PREDICATE_DEPTH","name","k","cartesian","keys","sweep","head","rest","headValues","tail","gridSize","size","arr","sweepUnder","objective","r","total","evaluations","warnedObjective","safeObjective","baselineReport","baseline","points","bestIndex","bestScore","score","best","toRulesMap","inner","e","KNOWN_OPS","COMBINATORS","isPlainObject","isOperatorObject","sawKnown","flattenPredicate","pathPrefix","clause","c","child","value","operand","isNumeric","directionFor","before","after","widthBefore","widthAfter","diffRules","sortedIds","constraints","summary","id","b","a","hasB","hasA","clauses","changes","sortChanges","diffClauses","stableStringify","flatB","flatA","keyOf","mapB","mapA","allKeys","direction","x","y","p","xo","yo","fmt","suggestionFor","expected","actual","collectFailedLeaves","predict","predicate","prev","whenExplain","wouldFire","missingChanges","COMPARABLE_OPS","compareValues","da","db","deepEqual","ka","kb","compareClauses","cand","exi","candSet","exiSet","inter","candLow","candHi","exiLow","exiHi","cmp","isExistingConstraint","doctor","candidate","existing","candidateLeaves","candidateByPath","leaf","existingList","contradictions","warnings","exiLeaves","candLeaves","verdict","finding","IDENT_RE","assertIdentifier","kind","assertAllowed","allowed","validateSelect","select","col","nextParam","ctx","renderOp","column","escapeLike","operator","assertNoSiblingKeys","combinator","sibs","buildWhere","parts","DEFAULT_PLACEHOLDER","predicateToSQL","table","allowedKeys","placeholder","projection","where","predicateToWhere","escapeRegex","FIELD_RE","FIELD_DOTTED_RE","assertFieldName","opts","field","translateOp","buildQuery","obj","conflicts","translated","andClauses","merged","predicateToMongo","assertColumn","encodeValue","encodeList","escapeLikeOperand","colClause","opAndValue","groupClause","logical","renderColumnOps","atTop","lo","hi","build","encodeClause","eq","predicateToPostgrest","mode","createSchemaType","validators","typeName","defaultValue","transform","description","refinements","meta","fn","createChainableType","fieldMeta","intermediate","desc","newRefinements","m","unionImpl","types","typeNames","schemaType","t","createChainableString","fm","n","regex","createChainableNumber","createChainableArray","elementType","indexRef","chainable","ref","et","newRef","validator","createChainableObject","shapeSchema","schemaT","dev_true_default","valueSet","innerType","innerTypeName","valueType","valueTypeName","val","uuidRegex","emailRegex","validateModuleId","validateKeyAlignment","implKeys","schemaKeys","implLabel","schemaLabel","missingImplMessage","validateSnapshotEvents","snapshotEvents","schemaEvents","schemaEventKeys","eventName","validateResolverRequirements","resolvers","requirements","requirementTypes","resolverName","resolver","resolverDef","validatePivotNameConflicts","config","factKeys","reserved","deps","depName","validateOwnsKeys","cid","constraint","owns","BLOCKED_PROPS","validateModuleConfig","createModule","crossModuleDeps","createModuleFactory","createRequirementStatusPlugin","state","notify","listener","getOrCreateSet","map","type","set","getStatus","pendingSet","inflightSet","failedSet","lastError","getAllStatus","allTypes","result","subscribe","reset","req","_resolver","error","createStatusHook","statusPlugin","createSystemWithStatus","allPlugins","createSystem","realClock","cb","ms","handle","virtualClock","initialMs","nowMs","nextId","queue","targetMs","ready","next","defaultClock","initialTimerState","elapsedMs","remainingMs","totalMs","startTimer","pauseTimer","resumeTimer","pausedFor","resetTimer","completeTimer","registerRepeat","tickTimer","elapsed","timerOps","Backoff"],"mappings":"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","file":"index.cjs","sourcesContent":["/**\n * Predicate backtest — rule-change impact.\n *\n * Given a recorded sequence of fact-state frames and a proposed replacement\n * for a constraint's `when` predicate, re-score the frames against BOTH the\n * original and the proposed predicate and produce a backtest report: how\n * many frames each matched, plus the per-frame diff (frames that newly\n * match / no longer match). It answers \"how many recorded frames would the\n * proposed rule have matched differently\" against real recorded history.\n *\n * This is a *static* backtest, not a behavioral simulation — the engine is\n * not re-run. Recorded frames are re-scored against a new predicate; the\n * resulting requirements, resolvers, and downstream fact changes are NOT\n * modeled. Treat the numbers as a divergence scan, not a forecast.\n *\n * Pure module — imports only the predicate runtime. No engine, store, or\n * tracking dependency. Replay walks frames in order; for `$changed`-style\n * predicates each frame is evaluated against the previous frame's facts.\n */\n\nimport {\n  evaluatePredicate,\n  evaluatePredicateExplained,\n  isPredicate,\n  validatePredicate,\n  walkPredicate,\n} from \"./predicate.js\";\nimport type { ClauseResult, FactPredicate } from \"./types/predicate.js\";\nimport { PREDICATE_COMBINATORS, PREDICATE_OPERATORS } from \"./types/predicate.js\";\n\n/**\n * Upper bound on the number of frames a single {@link replayUnder} call will\n * process. A history file is held entirely in memory; an unbounded array is a\n * denial-of-service surface. A history larger than this should be split or\n * down-sampled before replay.\n */\nexport const MAX_REPLAY_FRAMES = 1_000_000;\n\n/** One recorded fact-state frame. */\nexport interface ReplayFrame<F = Record<string, unknown>> {\n  /** Stable identifier — a snapshot id, an index, a session key. */\n  id: string | number;\n  /** Optional wall-clock time (ms epoch). */\n  timestamp?: number;\n  /** The fact state at this frame. */\n  facts: F;\n}\n\nexport interface ReplayUnderOptions<F = Record<string, unknown>> {\n  /** Recorded frames, chronological order. */\n  frames: readonly ReplayFrame<F>[];\n  /** The constraint's current `when` predicate (the baseline). */\n  original: FactPredicate<F>;\n  /** The proposed replacement `when` predicate. */\n  proposed: FactPredicate<F>;\n  /** Max diff samples to attach per bucket (default 20). */\n  maxSamples?: number;\n  /**\n   * A fact key identifying the entity a frame belongs to (e.g. `\"userId\"`,\n   * `\"sessionId\"`). When set, the report also reports distinct-entity counts\n   * — how many unique entities matched, not just how many frames. Without it\n   * the unit is frames: one fact snapshot, not one user or session.\n   */\n  entityKey?: string;\n}\n\n/** A frame where the original and proposed predicate disagree. */\nexport interface ReplayDiffSample {\n  frameId: string | number;\n  timestamp?: number;\n  /** The fact state at this frame. */\n  facts: Record<string, unknown>;\n  /** Per-clause breakdown under the original predicate. */\n  originalExplain: ClauseResult[];\n  /** Per-clause breakdown under the proposed predicate. */\n  proposedExplain: ClauseResult[];\n}\n\n/**\n * The outcome of replaying a recorded history under two predicates — a\n * static backtest of a proposed rule change, not a behavioral simulation.\n */\nexport interface PredicateBacktestReport {\n  /** Total frames evaluated. */\n  framesEvaluated: number;\n  /**\n   * Frames where the original predicate matched (was true). `matchedEntities`\n   * is the count of distinct `entityKey` values among matched frames — only\n   * populated when {@link ReplayUnderOptions.entityKey} was supplied.\n   */\n  original: { matched: number; matchedEntities?: number };\n  /** Frames where the proposed predicate matched. */\n  proposed: { matched: number; matchedEntities?: number };\n  /** proposed.matched - original.matched. */\n  delta: number;\n  /** Total count of frames that newly match (original false -> proposed true). */\n  newMatchCount: number;\n  /** Total count of frames that no longer match (original true -> proposed false). */\n  lostMatchCount: number;\n  /** Frames where original and proposed agree. */\n  unchanged: number;\n  /** Sampled new-match frames (capped at maxSamples), with clause explain. */\n  newMatches: ReplayDiffSample[];\n  /** Sampled lost-match frames (capped at maxSamples), with clause explain. */\n  lostMatches: ReplayDiffSample[];\n}\n\n/**\n * Validate one predicate spec for {@link replayUnder}, re-throwing any failure\n * with a message that names which spec (`original` / `proposed`) was bad.\n *\n * Three checks run, all up front so a malformed spec never reaches the\n * per-frame loop (where {@link evaluatePredicate} would throw a raw error on,\n * say, a `$matches` operand that is not a RegExp):\n *\n *  1. {@link validatePredicate} — JSON-unrehydratable operands (a `$matches`\n *     operand that is not a RegExp, a `bigint`, a `Set`/`Map`).\n *  2. {@link isPredicate} — the spec is structurally a FactPredicate. An\n *     empty object `{}` is a valid (always-true) predicate and is allowed.\n *  3. Unknown `$`-operators — a single walk surfaces any `$frobnicate`-style\n *     typo as one clear error instead of a per-call dev-warn.\n */\nfunction validateReplaySpec(\n  spec: unknown,\n  which: \"original\" | \"proposed\",\n): void {\n  try {\n    validatePredicate(spec);\n  } catch (err) {\n    const message = err instanceof Error ? err.message : String(err);\n\n    throw new Error(\n      `[Directive] replayUnder: the ${which} predicate is invalid — ${message}`,\n    );\n  }\n\n  if (!isPredicate(spec)) {\n    const preview =\n      spec === null || typeof spec !== \"object\"\n        ? `${typeof spec} — ${JSON.stringify(spec)}`\n        : JSON.stringify(spec).slice(0, 80);\n\n    throw new Error(\n      `[Directive] replayUnder: the ${which} predicate is not a valid FactPredicate (got ${preview})`,\n    );\n  }\n\n  // Surface an unknown `$`-operator (`$frobnicate`) as one clear error.\n  // `walkPredicate` reports a `$`-key at fact position via `strayOperatorKey`\n  // and an operator clause via `operator`; check both against the known sets.\n  let unknownOp: string | undefined;\n  walkPredicate(spec, {\n    operator(_factPath, op) {\n      if (\n        unknownOp === undefined &&\n        op.startsWith(\"$\") &&\n        !PREDICATE_OPERATORS.has(op)\n      ) {\n        unknownOp = op;\n      }\n    },\n    strayOperatorKey(key) {\n      if (\n        unknownOp === undefined &&\n        !PREDICATE_OPERATORS.has(key) &&\n        !PREDICATE_COMBINATORS.has(key)\n      ) {\n        unknownOp = key;\n      }\n    },\n  });\n\n  if (unknownOp !== undefined) {\n    throw new Error(\n      `[Directive] replayUnder: the ${which} predicate uses an unknown operator \"${unknownOp}\" — known operators: ${[...PREDICATE_OPERATORS].join(\", \")}`,\n    );\n  }\n}\n\n/**\n * Normalize a parsed-from-JSON history value into a `ReplayFrame[]`.\n *\n * Accepts the three documented history shapes:\n *\n *  1. A bare array of frames:        `[{ id, timestamp?, facts }, ...]`\n *  2. An object wrapping them:       `{ frames: [{ id, ..., facts }, ...] }`\n *  3. A bare array of fact objects:  `[{ phase: \"red\", ... }, ...]`\n *     — each element is wrapped as a frame.\n *\n * Frame ids are kept unambiguous: a frame that supplies its own `id` keeps\n * it; a frame missing an `id` (and every bare-fact frame) gets an\n * **index-derived** id prefixed with `#` (`\"#0\"`, `\"#1\"`, …) so a fallback\n * id can never collide with an explicit numeric or string id in a mixed\n * history. This is a pure helper — it **throws** a clear `Error` on bad\n * input and never calls `process.exit`, so library users can catch it.\n *\n * @example\n * ```ts\n * toReplayFrames([{ id: \"s1\", facts: { phase: \"red\" } }]);\n * // → [{ id: \"s1\", facts: { phase: \"red\" } }]\n * toReplayFrames([{ phase: \"red\" }, { phase: \"green\" }]);\n * // → [{ id: \"#0\", facts: { phase: \"red\" } }, { id: \"#1\", facts: { phase: \"green\" } }]\n * ```\n */\nexport function toReplayFrames(raw: unknown): ReplayFrame[] {\n  // A history-manager export ({ version, snapshots, currentIndex }) is a\n  // valid input shape — route it through framesFromHistory so the CLI and\n  // the library accept the same files.\n  if (\n    raw &&\n    typeof raw === \"object\" &&\n    !Array.isArray(raw) &&\n    Array.isArray((raw as { snapshots?: unknown }).snapshots)\n  ) {\n    return framesFromHistory(raw);\n  }\n\n  const list: unknown[] | null = Array.isArray(raw)\n    ? raw\n    : raw &&\n        typeof raw === \"object\" &&\n        Array.isArray((raw as { frames?: unknown }).frames)\n      ? (raw as { frames: unknown[] }).frames\n      : null;\n\n  if (!list) {\n    throw new Error(\n      \"[Directive] toReplayFrames: history must be a JSON array of frames, an object with a `frames` array, or a history export with a `snapshots` array\",\n    );\n  }\n\n  // Enforce the frame cap on `length` before `.map()` materializes a second\n  // array — the cap must bound memory, not just the evaluation loop.\n  if (list.length > MAX_REPLAY_FRAMES) {\n    throw new Error(\n      `[Directive] toReplayFrames: history has ${list.length} frames, exceeds the MAX_REPLAY_FRAMES limit (${MAX_REPLAY_FRAMES}) — split or down-sample the history`,\n    );\n  }\n\n  return list.map((entry, index) => {\n    if (entry && typeof entry === \"object\" && \"facts\" in entry) {\n      const frame = entry as {\n        id?: string | number;\n        timestamp?: number;\n        facts: unknown;\n      };\n      // An explicit id is used verbatim; a missing id falls back to a\n      // `#`-prefixed index so it cannot collide with an explicit id.\n      const out: ReplayFrame = {\n        id: frame.id ?? `#${index}`,\n        facts: (frame.facts ?? {}) as Record<string, unknown>,\n      };\n      if (typeof frame.timestamp === \"number\") {\n        out.timestamp = frame.timestamp;\n      }\n\n      return out;\n    }\n\n    // A bare fact object — wrap it, keyed by `#`-prefixed index.\n    return { id: `#${index}`, facts: (entry ?? {}) as Record<string, unknown> };\n  });\n}\n\n/**\n * Convert a history-manager export (the JSON produced by\n * `system.history.export()`) into a `ReplayFrame[]` ready for\n * {@link replayUnder}.\n *\n * The history manager records a ring buffer of `{ id, timestamp, facts,\n * trigger }` snapshots; `export()` wraps them as `{ version, snapshots,\n * currentIndex }`. Each snapshot's `facts` is the fact state at that point,\n * so the snapshot sequence is exactly a frame stream.\n *\n * Accepts either the parsed export object, the raw JSON string, or a bare\n * array of snapshots. Throws a clear `Error` on bad input.\n *\n * @example\n * ```ts\n * const frames = framesFromHistory(system.history.export());\n * const report = replayUnder({ frames, original, proposed });\n * ```\n */\nexport function framesFromHistory(historyExport: unknown): ReplayFrame[] {\n  const parsed =\n    typeof historyExport === \"string\"\n      ? (JSON.parse(historyExport) as unknown)\n      : historyExport;\n\n  // A bare snapshot array is accepted directly.\n  if (Array.isArray(parsed)) {\n    return framesFromSnapshots(parsed);\n  }\n\n  if (!parsed || typeof parsed !== \"object\") {\n    throw new Error(\n      \"[Directive] framesFromHistory: expected a history export object with a `snapshots` array (from system.history.export())\",\n    );\n  }\n\n  const exportObj = parsed as { version?: unknown; snapshots?: unknown };\n\n  // Mirror history.ts import(): only version 1 is understood. A bump in the\n  // export format must fail loud here, not silently yield wrong frames.\n  if (exportObj.version !== undefined && exportObj.version !== 1) {\n    throw new Error(\n      `[Directive] framesFromHistory: unsupported history export version ${JSON.stringify(exportObj.version)} — expected 1`,\n    );\n  }\n\n  if (!Array.isArray(exportObj.snapshots)) {\n    throw new Error(\n      \"[Directive] framesFromHistory: expected a history export object with a `snapshots` array (from system.history.export())\",\n    );\n  }\n\n  return framesFromSnapshots(exportObj.snapshots);\n}\n\n/**\n * Convert an array of `{ id, timestamp?, facts }` snapshots — e.g. the\n * `snapshots` field of a history export, or an array assembled by pushing\n * `system.getSnapshot()` on each reconcile — into a `ReplayFrame[]`.\n *\n * Throws a clear `Error` if the argument is not an array. Each snapshot is\n * normalized through the same {@link toReplayFrames} id logic.\n *\n * @example\n * ```ts\n * const snapshots: typeof history[] = [];\n * system.observe(() => snapshots.push(system.getSnapshot()));\n * // ...later\n * const frames = framesFromSnapshots(snapshots);\n * ```\n */\nexport function framesFromSnapshots(snapshots: unknown): ReplayFrame[] {\n  if (!Array.isArray(snapshots)) {\n    throw new Error(\n      \"[Directive] framesFromSnapshots: expected an array of fact-state snapshots\",\n    );\n  }\n\n  if (snapshots.length > MAX_REPLAY_FRAMES) {\n    throw new Error(\n      `[Directive] framesFromSnapshots: history has ${snapshots.length} snapshots, exceeds the MAX_REPLAY_FRAMES limit (${MAX_REPLAY_FRAMES}) — split or down-sample the history`,\n    );\n  }\n\n  // A snapshot is always a { facts, ... } object — reject a garbage array\n  // before it is silently wrapped into empty-fact frames.\n  for (let i = 0; i < snapshots.length; i++) {\n    const s = snapshots[i];\n    if (!s || typeof s !== \"object\" || !(\"facts\" in s)) {\n      throw new Error(\n        `[Directive] framesFromSnapshots: snapshot at index ${i} is not a { facts, ... } object`,\n      );\n    }\n  }\n\n  return toReplayFrames(snapshots);\n}\n\n/**\n * Replay a recorded fact-frame history through two predicates — the\n * constraint's current `when` and a proposed replacement — and report how\n * their match sets differ.\n *\n * This is a **predicate backtest**: the engine is not re-run. Each recorded\n * frame is statically re-scored against both specs; the previous frame's\n * facts are threaded as `prev` so a replayed effect-`on` predicate using\n * `$changed` still works (for a constraint `when` it is harmless). The\n * report counts matches under each spec and buckets the disagreements into\n * new matches (original false, proposed true) and lost matches (original\n * true, proposed false). Up to `maxSamples` diff frames per bucket carry a\n * per-clause `evaluatePredicateExplained` breakdown for inspection.\n *\n * Both specs are validated up front — a malformed spec throws a clear\n * `[Directive] replayUnder:` error identifying which spec failed, rather\n * than letting a raw `evaluatePredicate` error escape mid-loop.\n *\n * @example\n * ```ts\n * const report = replayUnder({\n *   frames: [\n *     { id: 0, facts: { phase: \"red\", elapsed: 10 } },\n *     { id: 1, facts: { phase: \"red\", elapsed: 35 } },\n *   ],\n *   original: { phase: \"red\" },\n *   proposed: { phase: \"red\", elapsed: { $gte: 30 } },\n * });\n * // report.original.matched  === 2\n * // report.proposed.matched  === 1\n * // report.delta             === -1\n * // report.lostMatchCount    === 1\n * ```\n */\nexport function replayUnder<F = Record<string, unknown>>(\n  options: ReplayUnderOptions<F>,\n): PredicateBacktestReport {\n  const { frames, original, proposed, entityKey } = options;\n  const requested = options.maxSamples ?? 20;\n  const maxSamples = requested > 0 ? requested : 0;\n\n  if (frames.length > MAX_REPLAY_FRAMES) {\n    throw new Error(\n      `[Directive] replayUnder: history has ${frames.length} frames, exceeds the MAX_REPLAY_FRAMES limit (${MAX_REPLAY_FRAMES}) — split or down-sample the history`,\n    );\n  }\n\n  // Validate both specs before the frame loop — fail loud and clear here\n  // rather than at frame 0 with a raw evaluatePredicate stack trace.\n  validateReplaySpec(original, \"original\");\n  validateReplaySpec(proposed, \"proposed\");\n\n  let originalMatched = 0;\n  let proposedMatched = 0;\n  let newMatchCount = 0;\n  let lostMatchCount = 0;\n  let unchanged = 0;\n  const newMatches: ReplayDiffSample[] = [];\n  const lostMatches: ReplayDiffSample[] = [];\n\n  // Distinct-entity tracking — only allocated when `entityKey` was supplied.\n  const originalEntities = entityKey ? new Set<unknown>() : undefined;\n  const proposedEntities = entityKey ? new Set<unknown>() : undefined;\n\n  let prevFacts: Record<string, unknown> | undefined;\n\n  for (const frame of frames) {\n    const facts = frame.facts as Record<string, unknown>;\n    const originalBit = evaluatePredicate(original, facts, prevFacts);\n    const proposedBit = evaluatePredicate(proposed, facts, prevFacts);\n\n    if (originalBit) {\n      originalMatched++;\n      originalEntities?.add(facts[entityKey as string]);\n    }\n    if (proposedBit) {\n      proposedMatched++;\n      proposedEntities?.add(facts[entityKey as string]);\n    }\n\n    if (originalBit === proposedBit) {\n      unchanged++;\n    } else if (!originalBit && proposedBit) {\n      newMatchCount++;\n      if (newMatches.length < maxSamples) {\n        newMatches.push(buildSample(frame, original, proposed, prevFacts));\n      }\n    } else {\n      lostMatchCount++;\n      if (lostMatches.length < maxSamples) {\n        lostMatches.push(buildSample(frame, original, proposed, prevFacts));\n      }\n    }\n\n    prevFacts = facts;\n  }\n\n  const report: PredicateBacktestReport = {\n    framesEvaluated: frames.length,\n    original: { matched: originalMatched },\n    proposed: { matched: proposedMatched },\n    delta: proposedMatched - originalMatched,\n    newMatchCount,\n    lostMatchCount,\n    unchanged,\n    newMatches,\n    lostMatches,\n  };\n\n  if (originalEntities && proposedEntities) {\n    report.original.matchedEntities = originalEntities.size;\n    report.proposed.matchedEntities = proposedEntities.size;\n  }\n\n  return report;\n}\n\n/**\n * Build a {@link ReplayDiffSample} for a frame the two predicates disagree\n * on — the per-clause explain is computed only here, never for non-diff\n * frames, so the common (mostly-agreeing) case stays cheap.\n */\nfunction buildSample<F>(\n  frame: ReplayFrame<F>,\n  original: unknown,\n  proposed: unknown,\n  prevFacts: Record<string, unknown> | undefined,\n): ReplayDiffSample {\n  const facts = frame.facts as Record<string, unknown>;\n  const sample: ReplayDiffSample = {\n    frameId: frame.id,\n    facts,\n    originalExplain: evaluatePredicateExplained(original, facts, prevFacts),\n    proposedExplain: evaluatePredicateExplained(proposed, facts, prevFacts),\n  };\n\n  if (frame.timestamp !== undefined) {\n    sample.timestamp = frame.timestamp;\n  }\n\n  return sample;\n}\n","/**\n * Parameter sweep over a predicate template — the grid-search counterpart\n * to `replayUnder`.\n *\n * `replayUnder` diffs ONE proposed predicate against the original.\n * `sweepUnder` takes a **template** with one or more `{ $hole: \"name\" }`\n * markers and a set of candidate values, then replays the history once\n * per (cartesian-product) combination. The result is a response curve\n * over the parameter space plus the argmax under a user-supplied\n * objective — turning rule-tuning from guess-and-check into a one-call\n * optimization against recorded traffic.\n *\n * Pure module — imports only the predicate runtime and replay engine.\n * No engine / store / tracking dependency.\n */\n\nimport { MAX_PREDICATE_DEPTH } from \"./predicate.js\";\nimport { type PredicateBacktestReport, type ReplayFrame, replayUnder } from \"./replay-under.js\";\nimport type { FactPredicate } from \"./types/predicate.js\";\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/** A placeholder inside a predicate template — substituted from `sweep` values. */\nexport interface SweepHole {\n  readonly $hole: string;\n}\n\nexport interface SweepUnderOptions<F = Record<string, unknown>> {\n  /** Recorded fact-state frames, in chronological order. */\n  frames: readonly ReplayFrame<F>[];\n  /** The constraint's current `when` predicate (baseline). */\n  original: FactPredicate<F>;\n  /**\n   * Predicate template containing one or more `{ $hole: \"name\" }` markers.\n   * Each marker is substituted by the corresponding value from `sweep` on\n   * every point in the curve.\n   *\n   * @example\n   * ```ts\n   * { cartTotal: { $gte: { $hole: \"threshold\" } } }\n   * ```\n   */\n  template: unknown;\n  /**\n   * Map of hole name → candidate values. Multiple holes produce the\n   * cartesian product (grid search).\n   *\n   * @example\n   * ```ts\n   * { threshold: [25, 50, 100, 200] }\n   * { riskScore: [0.5, 0.7, 0.9], minAge: [13, 18, 21] } // 3*3 = 9 points\n   * ```\n   */\n  sweep: Readonly<Record<string, readonly unknown[]>>;\n  /**\n   * Score function for ranking. Higher is better. Default:\n   * `(report) => report.proposed.matched` (maximize matched frames).\n   */\n  objective?: (report: PredicateBacktestReport) => number;\n  /** Optional fact key to additionally report distinct-entity counts. */\n  entityKey?: string;\n  /**\n   * Diff frames sampled per replay (default 0 — count-only for speed).\n   * Set higher to inspect specific frames in the report.\n   */\n  maxSamples?: number;\n}\n\n/** One point on the sweep curve — one candidate value tuple. */\nexport interface SweepPoint {\n  /** Hole name → value used at this point. */\n  values: Readonly<Record<string, unknown>>;\n  /** Full backtest report against this candidate. */\n  report: PredicateBacktestReport;\n  /** Computed objective score (higher is better). */\n  score: number;\n}\n\nexport interface SweepReport {\n  /** All points, in sweep order (cartesian-product traversal of sweep keys). */\n  points: readonly SweepPoint[];\n  /** Index of the highest-scoring point in `points`. */\n  bestIndex: number;\n  /** Convenience accessor: `points[bestIndex]`. */\n  best: SweepPoint;\n  /** The original predicate replayed against itself — score baseline for comparison. */\n  baseline: SweepPoint;\n}\n\n/** Hard cap on points evaluated in a single sweep — protects against runaway grids. */\nexport const MAX_SWEEP_POINTS = 10_000;\n\n/**\n * Aggregate compute cap: `points × frames` per call. `MAX_SWEEP_POINTS`\n * (10k) and `MAX_REPLAY_FRAMES` (1M) bound each axis individually, but\n * their product would be 10B per-frame evaluations — minutes-to-hours of\n * compute. This caps the realistic upper bound at ~50M evaluations\n * (e.g. 50k frames × 1k points, or 5k frames × 10k points).\n */\nexport const MAX_SWEEP_EVALUATIONS = 50_000_000;\n\n// ============================================================================\n// Hole substitution\n// ============================================================================\n\nfunction isHole(v: unknown): v is SweepHole {\n  return (\n    v !== null &&\n    typeof v === \"object\" &&\n    !Array.isArray(v) &&\n    Object.keys(v as object).length === 1 &&\n    typeof (v as SweepHole).$hole === \"string\"\n  );\n}\n\n/**\n * Walk `template`, replacing every `{ $hole: name }` marker with the value\n * looked up in `values`. Returns a new tree — does not mutate `template`.\n * Cycle-guarded; depth-capped at `MAX_PREDICATE_DEPTH`.\n *\n * Throws if a hole's name is not present in `values` — surfaces a typo'd\n * hole name up front rather than letting it land as `undefined` in the\n * evaluator.\n */\nfunction substitute(\n  template: unknown,\n  values: Record<string, unknown>,\n  path: Set<object> = new Set(),\n  depth = 0,\n): unknown {\n  if (depth > MAX_PREDICATE_DEPTH) {\n    throw new Error(\n      `[Directive] sweepUnder: template exceeds MAX_PREDICATE_DEPTH (${MAX_PREDICATE_DEPTH}) — flatten the template or split the sweep`,\n    );\n  }\n\n  if (isHole(template)) {\n    const name = template.$hole;\n    if (!(name in values)) {\n      throw new Error(\n        `[Directive] sweepUnder: template references hole \"${name}\" but sweep has no values for it`,\n      );\n    }\n\n    // Don't recurse into the substituted value — sweep values are opaque\n    // payloads, not templates. A value that itself looks like `{$hole:...}`\n    // lands literally in the proposed predicate.\n    return values[name];\n  }\n\n  if (template === null || typeof template !== \"object\") {\n    return template;\n  }\n\n  // Cycle guard via DFS path Set — entries are removed on unwind so that\n  // shared (non-cyclic) sub-trees still get substituted on every occurrence.\n  if (path.has(template)) {\n    throw new Error(\n      \"[Directive] sweepUnder: template contains a cycle — predicate templates must be a tree\",\n    );\n  }\n  path.add(template);\n\n  try {\n    if (Array.isArray(template)) {\n      return template.map((entry) => substitute(entry, values, path, depth + 1));\n    }\n\n    const out: Record<string, unknown> = {};\n    for (const [k, v] of Object.entries(template)) {\n      out[k] = substitute(v, values, path, depth + 1);\n    }\n\n    return out;\n  } finally {\n    path.delete(template);\n  }\n}\n\n// ============================================================================\n// Cartesian product\n// ============================================================================\n\n/**\n * Iterate the cartesian product of the sweep map's value arrays, in\n * declaration order. Generator avoids materializing the whole grid for\n * large multi-hole sweeps.\n */\nfunction* cartesian(\n  keys: readonly string[],\n  sweep: Readonly<Record<string, readonly unknown[]>>,\n): Generator<Record<string, unknown>> {\n  if (keys.length === 0) {\n    yield {};\n\n    return;\n  }\n\n  const head = keys[0] as string;\n  const rest = keys.slice(1);\n  const headValues = sweep[head] ?? [];\n  for (const v of headValues) {\n    for (const tail of cartesian(rest, sweep)) {\n      yield { [head]: v, ...tail };\n    }\n  }\n}\n\nfunction gridSize(sweep: Readonly<Record<string, readonly unknown[]>>): number {\n  let size = 1;\n  for (const arr of Object.values(sweep)) {\n    size *= arr.length;\n  }\n\n  return size;\n}\n\n// ============================================================================\n// Public API\n// ============================================================================\n\n/**\n * Sweep a predicate template's hole(s) across candidate values and replay\n * the recorded history through each one. Returns the full response curve\n * plus the argmax under a user-supplied objective.\n *\n * The mechanism is a tight loop over `replayUnder`: walk the cartesian\n * product of sweep values, substitute each combination into the template,\n * and run a backtest. Same caveats as `replayUnder` apply (no cascade\n * modeling, survivorship bias) — see {@link replayUnder} docs.\n *\n * @example\n * ```ts\n * const report = sweepUnder({\n *   frames: recordedSessions,\n *   original: { cartTotal: { $gte: 100 } },\n *   template: { cartTotal: { $gte: { $hole: \"threshold\" } } },\n *   sweep: { threshold: [25, 50, 100, 200] },\n * });\n *\n * report.best.values;          // { threshold: 25 }  (assuming higher matched is better)\n * report.best.report.proposed.matched;  // 9210\n * report.baseline.score;       // 4217 — the original spec's matched count\n * report.points.length;        // 4\n * ```\n *\n * Multi-hole sweeps grid-search:\n *\n * ```ts\n * sweepUnder({\n *   frames,\n *   original,\n *   template: {\n *     risk: { $gte: { $hole: \"minRisk\" } },\n *     age:  { $gte: { $hole: \"minAge\"  } },\n *   },\n *   sweep: { minRisk: [0.5, 0.7, 0.9], minAge: [13, 18, 21] },\n * });\n * // → 9 points (3 × 3)\n * ```\n */\nexport function sweepUnder<F = Record<string, unknown>>(\n  options: SweepUnderOptions<F>,\n): SweepReport {\n  const {\n    frames,\n    original,\n    template,\n    sweep,\n    objective = (r) => r.proposed.matched,\n    entityKey,\n    maxSamples = 0,\n  } = options;\n\n  const keys = Object.keys(sweep);\n  if (keys.length === 0) {\n    throw new Error(\n      \"[Directive] sweepUnder: `sweep` must contain at least one hole name\",\n    );\n  }\n\n  const total = gridSize(sweep);\n  if (total > MAX_SWEEP_POINTS) {\n    throw new Error(\n      `[Directive] sweepUnder: grid has ${total} points, exceeds the MAX_SWEEP_POINTS limit (${MAX_SWEEP_POINTS}) — narrow the sweep ranges or split the run`,\n    );\n  }\n  if (total === 0) {\n    throw new Error(\n      \"[Directive] sweepUnder: at least one hole has zero candidate values\",\n    );\n  }\n  const evaluations = total * frames.length;\n  if (evaluations > MAX_SWEEP_EVALUATIONS) {\n    throw new Error(\n      `[Directive] sweepUnder: ${total} points × ${frames.length} frames = ${evaluations} per-frame evaluations, exceeds the MAX_SWEEP_EVALUATIONS limit (${MAX_SWEEP_EVALUATIONS}) — narrow the sweep, down-sample the history, or split the run`,\n    );\n  }\n\n  // Invoke the user's objective with a catch + finite-number guard.\n  // A throw or non-finite return becomes -Infinity so the point sinks in\n  // the ranking instead of corrupting it (and stays out of the argmax).\n  let warnedObjective = false;\n  const safeObjective = (report: PredicateBacktestReport): number => {\n    let raw: unknown;\n    try {\n      raw = objective(report);\n    } catch (err) {\n      if (!warnedObjective) {\n        warnedObjective = true;\n        console.warn(\n          `[Directive] sweepUnder: objective threw — point will not rank (${(err as Error).message})`,\n        );\n      }\n\n      return Number.NEGATIVE_INFINITY;\n    }\n    if (typeof raw !== \"number\" || !Number.isFinite(raw)) {\n      if (!warnedObjective) {\n        warnedObjective = true;\n        console.warn(\n          `[Directive] sweepUnder: objective returned a non-finite number (${String(raw)}) — point will not rank`,\n        );\n      }\n\n      return Number.NEGATIVE_INFINITY;\n    }\n\n    return raw;\n  };\n\n  // Baseline: replay original against itself so the caller has a\n  // comparable score under the same objective. This is one extra\n  // replayUnder() call regardless of grid size — cheap, useful.\n  const baselineReport = replayUnder({\n    frames,\n    original,\n    proposed: original,\n    entityKey,\n    maxSamples,\n  });\n  const baseline: SweepPoint = {\n    values: {},\n    report: baselineReport,\n    score: safeObjective(baselineReport),\n  };\n\n  const points: SweepPoint[] = [];\n  let bestIndex = 0;\n  let bestScore = Number.NEGATIVE_INFINITY;\n\n  for (const values of cartesian(keys, sweep)) {\n    const proposed = substitute(template, values) as FactPredicate<F>;\n    const report = replayUnder({\n      frames,\n      original,\n      proposed,\n      entityKey,\n      maxSamples,\n    });\n    const score = safeObjective(report);\n    if (score > bestScore) {\n      bestScore = score;\n      bestIndex = points.length;\n    }\n    points.push({ values, report, score });\n  }\n\n  // points is guaranteed non-empty here because total > 0 and the loop ran.\n  const best = points[bestIndex] as SweepPoint;\n\n  return {\n    points,\n    bestIndex,\n    best,\n    baseline,\n  };\n}\n","/**\n * Structural diff between two snapshots of a system's constraint `whenSpec`\n * map. The \"git diff for business rules\" — operates on the predicate AST\n * instead of source-text lines.\n *\n * A predicate is a tree of leaf clauses (`{ fact: operator(value) }`) and\n * combinators (`$all` / `$any` / `$not`). `diffRules` flattens both trees\n * into path-keyed leaf lists and compares: missing path → added/removed,\n * same path with different operand → changed (with relaxed/tightened\n * classification for numeric thresholds).\n *\n * Pure module — imports only utils. No engine / store / predicate-runtime\n * dependency: predicates are walked as plain JSON.\n */\n\nimport { stableStringify } from \"../utils/utils.js\";\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/** A leaf clause extracted from a predicate tree, keyed by its dotted path. */\nexport interface LeafClause {\n  /** Dotted path through the predicate. E.g. `phase`, `$all[0].elapsed`, `$not.paused`. */\n  path: string;\n  /** Operator name. `$eq` is implied for bare-value equality. */\n  op: string;\n  /** Operand. */\n  value: unknown;\n}\n\n/** Kind of change observed for a single clause. */\nexport type ChangeKind =\n  | \"added\"\n  | \"removed\"\n  | \"changed\"\n  | \"relaxed\"\n  | \"tightened\";\n\n/** A single change between two predicates at a specific path. */\nexport interface Change {\n  path: string;\n  kind: ChangeKind;\n  before?: { op: string; value: unknown };\n  after?: { op: string; value: unknown };\n}\n\n/** Status of a single constraint across the two snapshots. */\nexport type ConstraintStatus = \"added\" | \"removed\" | \"changed\" | \"unchanged\";\n\nexport interface ConstraintDiff {\n  id: string;\n  status: ConstraintStatus;\n  /** Empty for `unchanged`. For `added` / `removed`, every leaf is listed once. */\n  changes: Change[];\n}\n\nexport interface RulesDiffReport {\n  constraints: ConstraintDiff[];\n  summary: {\n    added: number;\n    removed: number;\n    changed: number;\n    unchanged: number;\n    totalClauseChanges: number;\n  };\n}\n\nexport interface DiffRulesOptions {\n  before: RulesMapInput;\n  after: RulesMapInput;\n}\n\n/**\n * Accepted shapes for the `before` / `after` predicate maps:\n *   - A plain map `{ [constraintId]: whenSpec }`\n *   - The `system.inspect().constraints` array form `Array<{ id, whenSpec? }>`\n *   - Either wrapped as `{ constraints: <one-of-the-above> }`\n *\n * Anything else throws at `toRulesMap` so a bad input fails loud.\n */\nexport type RulesMapInput = unknown;\n\n// ============================================================================\n// Input normalization\n// ============================================================================\n\n/**\n * Coerce supported input shapes into a flat `Record<constraintId, whenSpec>`.\n * Constraints without a `whenSpec` (function-form `when`) are dropped with\n * an undefined entry so callers can distinguish them from absent constraints\n * if they care; the diff treats `undefined` as \"no data\" and skips clause\n * walking.\n */\nexport function toRulesMap(raw: RulesMapInput): Record<string, unknown> {\n  const inner =\n    raw && typeof raw === \"object\" && !Array.isArray(raw) && \"constraints\" in raw\n      ? (raw as { constraints: unknown }).constraints\n      : raw;\n\n  if (Array.isArray(inner)) {\n    const out: Record<string, unknown> = {};\n    for (const entry of inner) {\n      if (!entry || typeof entry !== \"object\" || !(\"id\" in entry)) {\n        throw new Error(\n          \"[Directive] diffRules: array entries must be `{ id, whenSpec }` objects\",\n        );\n      }\n      const e = entry as { id: unknown; whenSpec?: unknown };\n      if (typeof e.id !== \"string\") {\n        throw new Error(\"[Directive] diffRules: constraint `id` must be a string\");\n      }\n      out[e.id] = e.whenSpec;\n    }\n\n    return out;\n  }\n\n  if (inner && typeof inner === \"object\") {\n    return inner as Record<string, unknown>;\n  }\n\n  throw new Error(\n    \"[Directive] diffRules: expected a `{ id: whenSpec }` map, an array of `{ id, whenSpec }`, or `{ constraints: ... }`\",\n  );\n}\n\n// ============================================================================\n// Predicate flattening\n// ============================================================================\n\nconst KNOWN_OPS = new Set([\n  \"$eq\",\n  \"$ne\",\n  \"$in\",\n  \"$nin\",\n  \"$exists\",\n  \"$gt\",\n  \"$gte\",\n  \"$lt\",\n  \"$lte\",\n  \"$between\",\n  \"$matches\",\n  \"$startsWith\",\n  \"$endsWith\",\n  \"$contains\",\n  \"$changed\",\n]);\n\nconst COMBINATORS = new Set([\"$all\", \"$any\", \"$not\"]);\n\nfunction isPlainObject(v: unknown): v is Record<string, unknown> {\n  return v !== null && typeof v === \"object\" && !Array.isArray(v);\n}\n\n/**\n * Treat a value as an operator object iff it is a plain object whose keys\n * are ALL `$`-prefixed AND at least one is a known predicate operator.\n * Mirrors the runtime's `isOperatorObject` shape — diffRules walks the same\n * \"operator object\" boundary as `evaluatePredicate`.\n */\nfunction isOperatorObject(v: unknown): v is Record<string, unknown> {\n  if (!isPlainObject(v)) {\n    return false;\n  }\n  const keys = Object.keys(v);\n  if (keys.length === 0) {\n    return false;\n  }\n  let sawKnown = false;\n  for (const k of keys) {\n    if (!k.startsWith(\"$\")) {\n      return false;\n    }\n    if (KNOWN_OPS.has(k)) {\n      sawKnown = true;\n    }\n  }\n\n  return sawKnown;\n}\n\n/**\n * Walk a predicate tree and emit every leaf clause with its dotted path.\n * Combinators (`$all` / `$any` / `$not`) become indexed path segments.\n * Bare-value equality (`{ phase: \"red\" }`) emits as `op: \"$eq\"`.\n *\n * Array-form predicates (`[{ fact, op, value }, ...]`) are also accepted —\n * each clause's `fact` becomes the path, the operator is `op`, and the\n * value is `value`.\n *\n * **What gets dropped:** non-object combinator children (e.g. `$not: \"red\"`\n * with a string operand instead of a predicate object), function-form\n * predicates (the engine accepts a function for `when`; this walker only\n * sees data), and bare primitive predicates (a top-level `true` or `\"x\"`).\n * The walker is a tree visitor — anything not shaped like a predicate node\n * is silently skipped, never thrown on.\n */\nexport function flattenPredicate(\n  spec: unknown,\n  pathPrefix = \"\",\n  out: LeafClause[] = [],\n): LeafClause[] {\n  if (spec === null || typeof spec !== \"object\") {\n    // A leaf that isn't an object — odd as a predicate. Skip.\n    return out;\n  }\n\n  // Array-form (PredicateClause[])\n  if (Array.isArray(spec)) {\n    for (const clause of spec) {\n      if (\n        clause &&\n        typeof clause === \"object\" &&\n        \"fact\" in clause &&\n        \"op\" in clause\n      ) {\n        const c = clause as { fact: unknown; op: unknown; value: unknown };\n        out.push({\n          path: pathPrefix\n            ? `${pathPrefix}.${String(c.fact)}`\n            : String(c.fact),\n          op: String(c.op),\n          value: c.value,\n        });\n      }\n    }\n\n    return out;\n  }\n\n  // Combinator nodes\n  if (\"$all\" in spec && Array.isArray((spec as { $all: unknown }).$all)) {\n    const arr = (spec as { $all: unknown[] }).$all;\n    arr.forEach((child, i) => {\n      flattenPredicate(child, `${pathPrefix}$all[${i}]`, out);\n    });\n\n    return out;\n  }\n  if (\"$any\" in spec && Array.isArray((spec as { $any: unknown }).$any)) {\n    const arr = (spec as { $any: unknown[] }).$any;\n    arr.forEach((child, i) => {\n      flattenPredicate(child, `${pathPrefix}$any[${i}]`, out);\n    });\n\n    return out;\n  }\n  if (\"$not\" in spec) {\n    flattenPredicate(\n      (spec as { $not: unknown }).$not,\n      `${pathPrefix}$not`,\n      out,\n    );\n\n    return out;\n  }\n\n  // Object form — walk each key\n  for (const [key, value] of Object.entries(spec as Record<string, unknown>)) {\n    const path = pathPrefix ? `${pathPrefix}.${key}` : key;\n\n    if (isOperatorObject(value)) {\n      for (const [op, operand] of Object.entries(value)) {\n        out.push({ path, op, value: operand });\n      }\n    } else if (isPlainObject(value) && !COMBINATORS.has(key)) {\n      // Nested predicate (cross-module pivot or partial-match object).\n      flattenPredicate(value, path, out);\n    } else {\n      // Bare literal — equality.\n      out.push({ path, op: \"$eq\", value });\n    }\n  }\n\n  return out;\n}\n\n// ============================================================================\n// Direction analysis (relaxed / tightened for numeric thresholds)\n// ============================================================================\n\nfunction isNumeric(v: unknown): v is number {\n  return typeof v === \"number\" && Number.isFinite(v);\n}\n\n/**\n * For numeric-threshold operators, decide whether the new value matches\n * MORE (`relaxed`) or FEWER (`tightened`) fact configurations than the\n * old one. Returns `null` when the operator/operand isn't numeric — the\n * caller falls back to `\"changed\"`.\n */\nfunction directionFor(\n  op: string,\n  before: unknown,\n  after: unknown,\n): \"relaxed\" | \"tightened\" | null {\n  switch (op) {\n    case \"$gte\":\n    case \"$gt\":\n      // Lower bound. Lower = matches more.\n      if (isNumeric(before) && isNumeric(after)) {\n        if (after < before) return \"relaxed\";\n        if (after > before) return \"tightened\";\n      }\n      return null;\n    case \"$lte\":\n    case \"$lt\":\n      // Upper bound. Higher = matches more.\n      if (isNumeric(before) && isNumeric(after)) {\n        if (after > before) return \"relaxed\";\n        if (after < before) return \"tightened\";\n      }\n      return null;\n    case \"$between\": {\n      // [low, high] tuple — width compared.\n      if (\n        Array.isArray(before) &&\n        Array.isArray(after) &&\n        before.length === 2 &&\n        after.length === 2 &&\n        isNumeric(before[0]) &&\n        isNumeric(before[1]) &&\n        isNumeric(after[0]) &&\n        isNumeric(after[1])\n      ) {\n        const widthBefore = before[1] - before[0];\n        const widthAfter = after[1] - after[0];\n        if (widthAfter > widthBefore) return \"relaxed\";\n        if (widthAfter < widthBefore) return \"tightened\";\n      }\n      return null;\n    }\n    case \"$in\":\n    case \"$nin\": {\n      // Set membership. Wider set = relaxed for $in, tightened for $nin.\n      if (Array.isArray(before) && Array.isArray(after)) {\n        if (op === \"$in\") {\n          if (after.length > before.length) return \"relaxed\";\n          if (after.length < before.length) return \"tightened\";\n        } else {\n          if (after.length > before.length) return \"tightened\";\n          if (after.length < before.length) return \"relaxed\";\n        }\n      }\n      return null;\n    }\n    case \"$contains\": {\n      // For array operands, more allowed elements = relaxed (matches more\n      // facts). For string operands the direction is ambiguous (a longer\n      // substring narrows the match set; a shorter substring widens it),\n      // so we leave the call to the caller — returns null → \"changed\".\n      if (Array.isArray(before) && Array.isArray(after)) {\n        if (after.length > before.length) return \"relaxed\";\n        if (after.length < before.length) return \"tightened\";\n      }\n      return null;\n    }\n    default:\n      return null;\n  }\n}\n\n// ============================================================================\n// Public API\n// ============================================================================\n\n/**\n * Diff two snapshots of a system's constraint whenSpec map.\n *\n * @example\n * ```ts\n * const report = diffRules({\n *   before: { blockCheckout: { cartTotal: { $gte: 100 } } },\n *   after:  { blockCheckout: { cartTotal: { $gte: 50 } } },\n * });\n *\n * report.constraints[0].status;          // \"changed\"\n * report.constraints[0].changes[0].kind; // \"relaxed\"\n * report.summary.totalClauseChanges;     // 1\n * ```\n *\n * The input shape is forgiving — either a flat `{ id: whenSpec }` map, the\n * `system.inspect().constraints` array form, or either wrapped as\n * `{ constraints: ... }`. Constraints whose `when` is a function (no\n * `whenSpec`) are tracked as added/removed but cannot be clause-diffed\n * (the function form is opaque).\n */\nexport function diffRules(options: DiffRulesOptions): RulesDiffReport {\n  const before = toRulesMap(options.before);\n  const after = toRulesMap(options.after);\n\n  const allIds = new Set([...Object.keys(before), ...Object.keys(after)]);\n  const sortedIds = [...allIds].sort();\n\n  const constraints: ConstraintDiff[] = [];\n  const summary = {\n    added: 0,\n    removed: 0,\n    changed: 0,\n    unchanged: 0,\n    totalClauseChanges: 0,\n  };\n\n  for (const id of sortedIds) {\n    const b = before[id];\n    const a = after[id];\n    const hasB = id in before;\n    const hasA = id in after;\n\n    if (hasB && !hasA) {\n      const clauses = flattenPredicate(b);\n      const changes: Change[] =\n        clauses.length === 0\n          ? // Function-form / opaque whenSpec — flatten yields nothing.\n            // Emit one placeholder so renderers can show *something* and\n            // the summary's totalClauseChanges stays non-zero for the\n            // removed constraint.\n            [{ path: \"(function-form predicate)\", kind: \"removed\" }]\n          : clauses.map((c) => ({\n              path: c.path,\n              kind: \"removed\",\n              before: { op: c.op, value: c.value },\n            }));\n      sortChanges(changes);\n      constraints.push({ id, status: \"removed\", changes });\n      summary.removed++;\n      summary.totalClauseChanges += changes.length;\n      continue;\n    }\n\n    if (!hasB && hasA) {\n      const clauses = flattenPredicate(a);\n      const changes: Change[] =\n        clauses.length === 0\n          ? [{ path: \"(function-form predicate)\", kind: \"added\" }]\n          : clauses.map((c) => ({\n              path: c.path,\n              kind: \"added\",\n              after: { op: c.op, value: c.value },\n            }));\n      sortChanges(changes);\n      constraints.push({ id, status: \"added\", changes });\n      summary.added++;\n      summary.totalClauseChanges += changes.length;\n      continue;\n    }\n\n    // Both sides have it — clause-level diff.\n    const changes = diffClauses(b, a);\n    if (changes.length === 0) {\n      constraints.push({ id, status: \"unchanged\", changes: [] });\n      summary.unchanged++;\n    } else {\n      constraints.push({ id, status: \"changed\", changes });\n      summary.changed++;\n      summary.totalClauseChanges += changes.length;\n    }\n  }\n\n  return { constraints, summary };\n}\n\n/**\n * Diff two predicate trees and return the list of leaf-level changes.\n * Exported for reuse beyond the full per-constraint report.\n */\nexport function diffClauses(before: unknown, after: unknown): Change[] {\n  // Function-form predicates (anything not walkable) → skip clause walk,\n  // but report a single \"changed\" placeholder so callers see something\n  // happened at this constraint.\n  if (\n    before !== undefined &&\n    after !== undefined &&\n    (before === null ||\n      after === null ||\n      typeof before !== \"object\" ||\n      typeof after !== \"object\")\n  ) {\n    return stableStringify(before) === stableStringify(after)\n      ? []\n      : [\n          {\n            path: \"\",\n            kind: \"changed\",\n            before: { op: \"$eq\", value: before },\n            after: { op: \"$eq\", value: after },\n          },\n        ];\n  }\n\n  const flatB = before === undefined ? [] : flattenPredicate(before);\n  const flatA = after === undefined ? [] : flattenPredicate(after);\n\n  // Key by `path + op` so two different operators on the same path (rare\n  // but possible in the array form) are tracked independently.\n  const keyOf = (c: LeafClause) => `${c.path}::${c.op}`;\n\n  const mapB = new Map<string, LeafClause>(flatB.map((c) => [keyOf(c), c]));\n  const mapA = new Map<string, LeafClause>(flatA.map((c) => [keyOf(c), c]));\n\n  const allKeys = new Set([...mapB.keys(), ...mapA.keys()]);\n  const changes: Change[] = [];\n\n  for (const key of allKeys) {\n    const b = mapB.get(key);\n    const a = mapA.get(key);\n\n    if (b && !a) {\n      changes.push({\n        path: b.path,\n        kind: \"removed\",\n        before: { op: b.op, value: b.value },\n      });\n      continue;\n    }\n    if (!b && a) {\n      changes.push({\n        path: a.path,\n        kind: \"added\",\n        after: { op: a.op, value: a.value },\n      });\n      continue;\n    }\n    if (b && a) {\n      if (stableStringify(b.value) === stableStringify(a.value)) {\n        continue;\n      }\n      const direction = directionFor(b.op, b.value, a.value);\n      changes.push({\n        path: b.path,\n        kind: direction ?? \"changed\",\n        before: { op: b.op, value: b.value },\n        after: { op: a.op, value: a.value },\n      });\n    }\n  }\n\n  sortChanges(changes);\n\n  return changes;\n}\n\n/**\n * Deterministic ordering for change lists: primary key is path, secondary\n * is operator (so two clauses sharing a path — possible in the array form\n * with multiple operators on one fact — order stably). Two byte-identical\n * inputs always produce byte-identical outputs.\n */\nfunction sortChanges(changes: Change[]): void {\n  changes.sort((x, y) => {\n    const p = x.path.localeCompare(y.path);\n    if (p !== 0) return p;\n    const xo = x.before?.op ?? x.after?.op ?? \"\";\n    const yo = y.before?.op ?? y.after?.op ?? \"\";\n\n    return xo.localeCompare(yo);\n  });\n}\n","/**\n * predict() — \"would this predicate fire against these facts, and if\n * not, what facts must change to make it fire?\"\n *\n * Closes the LLM-emit iteration loop: the model writes a rule,\n * `predict()` says \"this rule needs cartTotal ≥ 50 to fire; current\n * value is 30,\" and the model rewrites accordingly. A predicate-aware\n * preview that costs one walk of the predicate tree.\n *\n * Pure, sync, no engine dependency. Reuses `evaluatePredicateExplained`.\n */\n\nimport {\n  evaluatePredicateExplained,\n} from \"./predicate.js\";\nimport type { ClauseResult, FactPredicate } from \"./types/predicate.js\";\n\n// ============================================================================\n// Types\n// ============================================================================\n\nexport interface PredictMissingChange {\n  /** Dotted path to the fact. */\n  readonly path: string;\n  /** The operator that failed. */\n  readonly op: string;\n  /** What the predicate expected. */\n  readonly expected: unknown;\n  /** What the fact currently is. */\n  readonly actual: unknown;\n  /** Human-readable hint suitable for feeding back to an LLM or showing to a user. */\n  readonly suggestion: string;\n}\n\nexport interface PredictResult<F> {\n  /** True iff the predicate would fire against `facts`. */\n  readonly wouldFire: boolean;\n  /** Full clause-by-clause result (reuses the whenExplain payload). */\n  readonly whenExplain: readonly ClauseResult[];\n  /**\n   * List of failing clauses, each with a `suggestion` describing the\n   * smallest concrete change to `facts` that would make that clause pass.\n   * Empty when `wouldFire === true`.\n   */\n  readonly missingChanges: readonly PredictMissingChange[];\n  /** Reference to the predicate evaluated, for telemetry. */\n  readonly predicate: FactPredicate<F>;\n}\n\n// ============================================================================\n// Suggestion synthesis\n// ============================================================================\n\nfunction fmt(v: unknown): string {\n  if (v === null) return \"null\";\n  if (v === undefined) return \"undefined\";\n  if (v instanceof Date) return v.toISOString();\n  if (typeof v === \"string\") return JSON.stringify(v);\n  if (typeof v === \"object\") return JSON.stringify(v);\n\n  return String(v);\n}\n\n/**\n * Per-operator suggestion templates. Each returns a short, imperative\n * line aimed at a developer or LLM consumer:\n *\n *   \"set cartTotal to at least 50 (currently 30)\"\n *   \"set status to one of [active, pending] (currently inactive)\"\n *   \"remove tags so it's empty (currently has 3 items)\"\n */\nfunction suggestionFor(clause: ClauseResult): string {\n  const path = clause.path;\n  const expected = fmt(clause.expected);\n  const actual = fmt(clause.actual);\n\n  switch (clause.op) {\n    case \"$eq\":\n      return `set ${path} to ${expected} (currently ${actual})`;\n    case \"$ne\":\n      return `change ${path} to anything other than ${expected} (currently ${actual})`;\n    case \"$gt\":\n      return `set ${path} above ${expected} (currently ${actual})`;\n    case \"$gte\":\n      return `set ${path} to at least ${expected} (currently ${actual})`;\n    case \"$lt\":\n      return `set ${path} below ${expected} (currently ${actual})`;\n    case \"$lte\":\n      return `set ${path} to at most ${expected} (currently ${actual})`;\n    case \"$in\":\n      return `set ${path} to one of ${expected} (currently ${actual})`;\n    case \"$nin\":\n      return `set ${path} to something other than ${expected} (currently ${actual})`;\n    case \"$exists\":\n      return clause.expected === true\n        ? `set ${path} to a non-null value (currently null/missing)`\n        : `unset ${path} (currently ${actual})`;\n    case \"$between\": {\n      if (Array.isArray(clause.expected) && clause.expected.length === 2) {\n        return `set ${path} between ${fmt(clause.expected[0])} and ${fmt(clause.expected[1])} (currently ${actual})`;\n      }\n\n      return `set ${path} within range ${expected} (currently ${actual})`;\n    }\n    case \"$startsWith\":\n      return `set ${path} to start with ${expected} (currently ${actual})`;\n    case \"$endsWith\":\n      return `set ${path} to end with ${expected} (currently ${actual})`;\n    case \"$contains\":\n      return `set ${path} to contain ${expected} (currently ${actual})`;\n    case \"$matches\":\n      return `set ${path} to match the pattern ${expected} (currently ${actual})`;\n    case \"$changed\":\n      return `the previous-vs-current change of ${path} is required to differ (currently they match: ${actual})`;\n    case \"$all\":\n    case \"$any\":\n    case \"$not\":\n      // Combinators fail when their children's pattern fails — surface a generic suggestion.\n      return `the ${clause.op} group at \"${path}\" did not pass — see its child clauses`;\n    default:\n      return `clause at ${path} (${clause.op}) failed: expected ${expected}, got ${actual}`;\n  }\n}\n\n// ============================================================================\n// Collect failed leaves\n// ============================================================================\n\nfunction collectFailedLeaves(\n  clauses: readonly ClauseResult[],\n  out: PredictMissingChange[],\n): void {\n  for (const c of clauses) {\n    if (c.pass) continue;\n\n    // Combinators: recurse into children — surface the leaves that actually failed.\n    if ((c.op === \"$all\" || c.op === \"$any\" || c.op === \"$not\") && c.children) {\n      // For $any: only one child needs to pass — emit the \"cheapest\" suggestion\n      // (typically the first failed leaf) plus a hint about alternatives.\n      // For $all and $not: every failing child is a required change.\n      collectFailedLeaves(c.children, out);\n      continue;\n    }\n\n    out.push({\n      path: c.path,\n      op: c.op,\n      expected: c.expected,\n      actual: c.actual,\n      suggestion: suggestionFor(c),\n    });\n  }\n}\n\n// ============================================================================\n// Public API\n// ============================================================================\n\n/**\n * Run a predicate against the current fact state and report whether it\n * would fire — *and if not, which facts must change*.\n *\n * Designed for the LLM-iteration loop and for \"preview the impact of this\n * rule\" UIs.\n *\n * @example\n * ```ts\n * const predicate = { cartTotal: { $gte: 50 }, region: { $in: [\"US\", \"EU\"] } };\n * const facts = { cartTotal: 30, region: \"US\" };\n *\n * predict(predicate, facts);\n * // → {\n * //     wouldFire: false,\n * //     whenExplain: [ {path: \"cartTotal\", op: \"$gte\", pass: false, ...}, ... ],\n * //     missingChanges: [\n * //       { path: \"cartTotal\", op: \"$gte\", expected: 50, actual: 30,\n * //         suggestion: \"set cartTotal to at least 50 (currently 30)\" },\n * //     ],\n * //     predicate: { cartTotal: { $gte: 50 }, region: { $in: [\"US\", \"EU\"] } },\n * //   }\n * ```\n */\nexport function predict<F = Record<string, unknown>>(\n  predicate: FactPredicate<F>,\n  facts: F,\n  prev?: F,\n): PredictResult<F> {\n  const whenExplain = evaluatePredicateExplained(\n    predicate as unknown,\n    facts as unknown as Record<string, unknown>,\n    prev as unknown as Record<string, unknown> | undefined,\n  );\n  const wouldFire = whenExplain.every((c) => c.pass);\n\n  const missingChanges: PredictMissingChange[] = [];\n  if (!wouldFire) {\n    collectFailedLeaves(whenExplain, missingChanges);\n  }\n\n  return {\n    wouldFire,\n    whenExplain,\n    missingChanges,\n    predicate,\n  };\n}\n","/**\n * doctor — \"this rule contradicts an existing rule\" gate (v1 stub).\n *\n * Walks a candidate FactPredicate against an existing system's\n * constraint set (via `system.inspect().constraints`), flagging:\n *\n *   - **direct contradiction:** same fact path, opposite-direction\n *     comparison (`$gte 50` vs `$lt 50` — they cannot both fire).\n *   - **subset:** candidate's range is a strict subset of an existing\n *     constraint's range (candidate `$gte 100` when existing already\n *     has `$gte 50`; the new rule never fires independently of the old).\n *   - **overlap:** shares ≥1 fact path with non-trivial intersection —\n *     a warning, not a hard error.\n *\n * Pairs with `predicateFromIntent`: an LLM-emitted predicate can be\n * doctor-checked before assignment, and contradictions fed back into\n * the LLM's retry prompt.\n *\n * This is a **structural** v1. Full SMT-lite (Z3.wasm) is deferred to\n * a dedicated R4.B sprint; the primitive of \"doctor says no\" is what\n * this slice ships. False negatives are acceptable (no contradiction\n * reported when one exists in semantics that the structural checker\n * can't see). False positives (contradiction reported where none\n * exists) are NOT acceptable — every reported contradiction must be\n * defensible.\n *\n * Pure, sync, no engine dependency.\n */\n\nimport { flattenPredicate, type LeafClause } from \"./rules-diff.js\";\nimport type { FactPredicate } from \"./types/predicate.js\";\n\n// ============================================================================\n// Types\n// ============================================================================\n\nexport type ContradictionType = \"direct\" | \"subset\" | \"overlap\";\n\nexport interface Contradiction {\n  /** ID of the existing constraint that conflicts with the candidate. */\n  readonly constraintId: string;\n  /** Type of contradiction detected. */\n  readonly type: ContradictionType;\n  /** Human-readable explanation, suitable for showing to a user or LLM. */\n  readonly reason: string;\n  /** Path on the candidate predicate that triggered the finding. */\n  readonly candidatePath?: string;\n  /** Operator + value on the candidate side. */\n  readonly candidate?: { op: string; value: unknown };\n  /** Operator + value on the existing side. */\n  readonly existing?: { op: string; value: unknown };\n}\n\nexport interface CheckAgainstResult {\n  /** Hard contradictions — candidate never co-fires with existing rule. */\n  readonly contradictions: readonly Contradiction[];\n  /** Soft overlaps — shared facts with non-trivial intersection. */\n  readonly warnings: readonly Contradiction[];\n}\n\n/** Shape of `system.inspect().constraints[N]` we care about — accepts any superset. */\nexport interface ExistingConstraint {\n  readonly id: string;\n  readonly whenSpec?: unknown;\n}\n\n// ============================================================================\n// Operator polarity (for direct-contradiction detection)\n// ============================================================================\n\nconst COMPARABLE_OPS = new Set([\n  \"$eq\",\n  \"$ne\",\n  \"$gt\",\n  \"$gte\",\n  \"$lt\",\n  \"$lte\",\n  \"$in\",\n  \"$nin\",\n]);\n\n/**\n * Numeric comparison: returns -1 if a < b, 0 if equal, 1 if a > b, NaN\n * if not comparable. Compares numbers, bigints, dates, strings lex.\n */\nfunction compareValues(a: unknown, b: unknown): number {\n  if (a === b) return 0;\n  if (typeof a === \"number\" && typeof b === \"number\") {\n    return a < b ? -1 : a > b ? 1 : 0;\n  }\n  if (typeof a === \"bigint\" && typeof b === \"bigint\") {\n    return a < b ? -1 : a > b ? 1 : 0;\n  }\n  if (a instanceof Date && b instanceof Date) {\n    const da = a.getTime();\n    const db = b.getTime();\n\n    return da < db ? -1 : da > db ? 1 : 0;\n  }\n  if (typeof a === \"string\" && typeof b === \"string\") {\n    return a < b ? -1 : a > b ? 1 : 0;\n  }\n\n  return Number.NaN;\n}\n\nfunction deepEqual(a: unknown, b: unknown): boolean {\n  if (a === b) return true;\n  if (typeof a !== typeof b) return false;\n  if (a === null || b === null) return false;\n  if (typeof a !== \"object\") return false;\n  if (Array.isArray(a) !== Array.isArray(b)) return false;\n  if (Array.isArray(a) && Array.isArray(b)) {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!deepEqual(a[i], b[i])) return false;\n    }\n\n    return true;\n  }\n  const ka = Object.keys(a as object);\n  const kb = Object.keys(b as object);\n  if (ka.length !== kb.length) return false;\n  for (const k of ka) {\n    if (!deepEqual((a as Record<string, unknown>)[k], (b as Record<string, unknown>)[k])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n// ============================================================================\n// Per-path contradiction check\n// ============================================================================\n\n/**\n * Given two clauses on the same fact path, return the contradiction\n * type (or null when they don't contradict / overlap).\n *\n * @example\n *   candidate `$gte 100` vs existing `$lt 50` → \"direct\"\n *   candidate `$gte 100` vs existing `$gte 50` → \"subset\"\n *   candidate `$gte 50`  vs existing `$lt 100` → \"overlap\"\n *   candidate `$eq \"a\"`  vs existing `$ne \"a\"` → \"direct\"\n */\nfunction compareClauses(\n  cand: LeafClause,\n  exi: LeafClause,\n): { type: ContradictionType; reason: string } | null {\n  // Only structurally-comparable operators are decidable here.\n  if (!COMPARABLE_OPS.has(cand.op) || !COMPARABLE_OPS.has(exi.op)) {\n    // Shared path with non-comparable operators → soft overlap.\n    return { type: \"overlap\", reason: `Both rules touch \"${cand.path}\".` };\n  }\n\n  // ---- $eq / $ne pairs ----\n  if (cand.op === \"$eq\" && exi.op === \"$eq\") {\n    if (deepEqual(cand.value, exi.value)) {\n      return { type: \"subset\", reason: `Both rules require ${cand.path} = ${JSON.stringify(cand.value)} — candidate is redundant.` };\n    }\n\n    return {\n      type: \"direct\",\n      reason: `Candidate requires ${cand.path} = ${JSON.stringify(cand.value)} but an existing rule requires ${cand.path} = ${JSON.stringify(exi.value)} — they cannot both fire.`,\n    };\n  }\n  if (cand.op === \"$eq\" && exi.op === \"$ne\") {\n    if (deepEqual(cand.value, exi.value)) {\n      return {\n        type: \"direct\",\n        reason: `Candidate requires ${cand.path} = ${JSON.stringify(cand.value)} but an existing rule excludes that value.`,\n      };\n    }\n\n    return null;\n  }\n  if (cand.op === \"$ne\" && exi.op === \"$eq\") {\n    if (deepEqual(cand.value, exi.value)) {\n      return {\n        type: \"direct\",\n        reason: `Candidate excludes ${cand.path} = ${JSON.stringify(cand.value)} but an existing rule requires that exact value.`,\n      };\n    }\n\n    return null;\n  }\n\n  // ---- $in / $nin pairs ----\n  if (cand.op === \"$in\" && exi.op === \"$in\") {\n    const candSet = new Set(Array.isArray(cand.value) ? cand.value : []);\n    const exiSet = new Set(Array.isArray(exi.value) ? exi.value : []);\n    const inter = [...candSet].filter((v) => exiSet.has(v));\n    if (inter.length === 0) {\n      return {\n        type: \"direct\",\n        reason: `Candidate $in set for ${cand.path} (${JSON.stringify([...candSet])}) and existing $in set (${JSON.stringify([...exiSet])}) have no values in common — the candidate can never fire while the existing rule holds.`,\n      };\n    }\n    if (inter.length === candSet.size && inter.length < exiSet.size) {\n      return {\n        type: \"subset\",\n        reason: `Candidate $in set for ${cand.path} is a strict subset of the existing rule's $in set.`,\n      };\n    }\n\n    return null;\n  }\n\n  // ---- Order comparisons: $gt / $gte / $lt / $lte ----\n  // Two range comparisons over the same fact; check for empty intersection.\n  const candLow = cand.op === \"$gt\" || cand.op === \"$gte\" ? cand.value : undefined;\n  const candHi = cand.op === \"$lt\" || cand.op === \"$lte\" ? cand.value : undefined;\n  const exiLow = exi.op === \"$gt\" || exi.op === \"$gte\" ? exi.value : undefined;\n  const exiHi = exi.op === \"$lt\" || exi.op === \"$lte\" ? exi.value : undefined;\n\n  // candidate lower bound vs existing upper bound — disjoint?\n  if (candLow !== undefined && exiHi !== undefined) {\n    const cmp = compareValues(candLow, exiHi);\n    if (!Number.isNaN(cmp)) {\n      if (cmp > 0 || (cmp === 0 && (cand.op === \"$gt\" || exi.op === \"$lt\"))) {\n        return {\n          type: \"direct\",\n          reason: `Candidate requires ${cand.path} ${cand.op === \"$gt\" ? \">\" : \"≥\"} ${JSON.stringify(candLow)} but an existing rule caps it at ${exi.op === \"$lt\" ? \"<\" : \"≤\"} ${JSON.stringify(exiHi)}.`,\n        };\n      }\n    }\n  }\n\n  // existing lower bound vs candidate upper bound — disjoint?\n  if (exiLow !== undefined && candHi !== undefined) {\n    const cmp = compareValues(exiLow, candHi);\n    if (!Number.isNaN(cmp)) {\n      if (cmp > 0 || (cmp === 0 && (exi.op === \"$gt\" || cand.op === \"$lt\"))) {\n        return {\n          type: \"direct\",\n          reason: `Candidate caps ${cand.path} at ${cand.op === \"$lt\" ? \"<\" : \"≤\"} ${JSON.stringify(candHi)} but an existing rule requires it ${exi.op === \"$gt\" ? \">\" : \"≥\"} ${JSON.stringify(exiLow)}.`,\n        };\n      }\n    }\n  }\n\n  // Same direction → check subset.\n  if (candLow !== undefined && exiLow !== undefined) {\n    const cmp = compareValues(candLow, exiLow);\n    if (!Number.isNaN(cmp) && cmp > 0) {\n      return {\n        type: \"subset\",\n        reason: `Candidate's lower bound on ${cand.path} (${JSON.stringify(candLow)}) is stricter than the existing rule's lower bound (${JSON.stringify(exiLow)}) — candidate is a subset.`,\n      };\n    }\n  }\n  if (candHi !== undefined && exiHi !== undefined) {\n    const cmp = compareValues(candHi, exiHi);\n    if (!Number.isNaN(cmp) && cmp < 0) {\n      return {\n        type: \"subset\",\n        reason: `Candidate's upper bound on ${cand.path} (${JSON.stringify(candHi)}) is stricter than the existing rule's upper bound (${JSON.stringify(exiHi)}) — candidate is a subset.`,\n      };\n    }\n  }\n\n  // Fall through — overlap.\n  return { type: \"overlap\", reason: `Both rules constrain \"${cand.path}\".` };\n}\n\n// ============================================================================\n// Public API\n// ============================================================================\n\nfunction isExistingConstraint(v: unknown): v is ExistingConstraint {\n  return (\n    typeof v === \"object\" &&\n    v !== null &&\n    typeof (v as ExistingConstraint).id === \"string\"\n  );\n}\n\nexport const doctor = {\n  /**\n   * Check a candidate predicate against existing constraints. Returns\n   * contradictions (hard) + warnings (soft overlaps).\n   *\n   * @param candidate - The proposed predicate (typically LLM-emitted).\n   * @param existing  - Either `system.inspect().constraints` directly,\n   *                    or any array of `{ id, whenSpec? }` shapes.\n   *                    Constraints without `whenSpec` (function-form\n   *                    `when:`) are skipped — they're opaque to us.\n   *\n   * @example\n   * ```ts\n   * const candidate = { cartTotal: { $gte: 100 } };\n   * const report = doctor.checkAgainst(\n   *   candidate,\n   *   system.inspect().constraints,\n   * );\n   * // → {\n   * //     contradictions: [\n   * //       { constraintId: \"freeShipping\", type: \"subset\",\n   * //         reason: \"Candidate's lower bound on cartTotal...\" }\n   * //     ],\n   * //     warnings: []\n   * //   }\n   * ```\n   */\n  checkAgainst<F = Record<string, unknown>>(\n    candidate: FactPredicate<F>,\n    existing: readonly ExistingConstraint[] | { constraints: readonly ExistingConstraint[] },\n  ): CheckAgainstResult {\n    const constraints: readonly ExistingConstraint[] = Array.isArray(existing)\n      ? existing\n      : \"constraints\" in existing && Array.isArray(existing.constraints)\n        ? existing.constraints\n        : [];\n\n    const candidateLeaves = flattenPredicate(candidate);\n    if (candidateLeaves.length === 0) {\n      return { contradictions: [], warnings: [] };\n    }\n\n    const candidateByPath = new Map<string, LeafClause[]>();\n    for (const leaf of candidateLeaves) {\n      const existingList = candidateByPath.get(leaf.path) ?? [];\n      existingList.push(leaf);\n      candidateByPath.set(leaf.path, existingList);\n    }\n\n    const contradictions: Contradiction[] = [];\n    const warnings: Contradiction[] = [];\n\n    for (const c of constraints) {\n      if (!isExistingConstraint(c)) continue;\n      if (c.whenSpec === undefined) continue; // function-form `when:` — opaque\n\n      const exiLeaves = flattenPredicate(c.whenSpec);\n      for (const exi of exiLeaves) {\n        const candLeaves = candidateByPath.get(exi.path);\n        if (!candLeaves) continue;\n        for (const cand of candLeaves) {\n          const verdict = compareClauses(cand, exi);\n          if (!verdict) continue;\n          const finding: Contradiction = {\n            constraintId: c.id,\n            type: verdict.type,\n            reason: verdict.reason,\n            candidatePath: cand.path,\n            candidate: { op: cand.op, value: cand.value },\n            existing: { op: exi.op, value: exi.value },\n          };\n          if (verdict.type === \"overlap\") {\n            warnings.push(finding);\n          } else {\n            contradictions.push(finding);\n          }\n        }\n      }\n    }\n\n    return { contradictions, warnings };\n  },\n};\n","/**\n * Compile a `FactPredicate` to a parameterized Postgres-style SQL WHERE\n * clause. The same predicate that gates a constraint on the client can\n * filter rows on the server — *one source of truth, two execution sites*.\n *\n * Pure transformation. No engine, no driver, no string concatenation of\n * user values (all operands flow through the parameter array → safe\n * against SQL injection by construction).\n */\n\nimport { MAX_PREDICATE_DEPTH } from \"./predicate.js\";\nimport {\n  PREDICATE_OPERATORS,\n  type FactPredicate,\n} from \"./types/predicate.js\";\n\n// ============================================================================\n// Types\n// ============================================================================\n\nexport interface PredicateToSqlOptions {\n  /** Table to query. Validated against the same identifier rule as columns. */\n  table: string;\n  /**\n   * Allowlist of fact / column keys the predicate may reference. STRONGLY\n   * RECOMMENDED for any predicate that crosses a trust boundary (AI\n   * generation, user input, JSON-over-the-wire). Without an allowlist, a\n   * predicate may reference any column the table has.\n   */\n  allowedKeys?: readonly string[];\n  /**\n   * Customize the `SELECT` projection. Default `\"*\"`. Accepts:\n   *   - `\"*\"`\n   *   - a column identifier (`\"id\"` or `\"users.id\"`)\n   *   - an array of column identifiers (`[\"id\", \"name\"]`) — joined with `,`\n   * Free-form strings (e.g. `\"COUNT(*)\"`) are rejected — build the wrapper\n   * SQL manually with {@link predicateToWhere} for those cases.\n   */\n  select?: string | readonly string[];\n  /**\n   * Parameter placeholder generator. Default is Postgres-style `$1`, `$2`.\n   * Pass `() => \"?\"` for MySQL/SQLite, or supply your own scheme.\n   */\n  placeholder?: (oneBasedIndex: number) => string;\n}\n\nexport interface PredicateToSqlResult {\n  /** Full `SELECT … FROM table WHERE …` statement. */\n  sql: string;\n  /** Just the `WHERE` clause body (without the literal `WHERE`). */\n  where: string;\n  /** Parameters, in `$1`-then-`$2`-then-… order. */\n  params: unknown[];\n}\n\n// ============================================================================\n// Identifier safety\n// ============================================================================\n\n/**\n * Strict identifier check: alpha, digits, underscore, optional dot for\n * qualified names (`table.column`). No whitespace, no quotes, no\n * semicolons — anything not matching is rejected with a clear error.\n *\n * Identifiers are interpolated *literally* into the SQL string (the only\n * safe alternative is double-quoting, which changes case sensitivity).\n * This regex is the only thing standing between a column-name typo and a\n * SQL injection — keep it strict.\n */\nconst IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)?$/;\n\nfunction assertIdentifier(name: string, kind: \"table\" | \"column\"): void {\n  if (typeof name !== \"string\" || !IDENT_RE.test(name)) {\n    throw new Error(\n      `[Directive] predicateToSQL: invalid ${kind} identifier \"${name}\" — must match /^[A-Za-z_][A-Za-z0-9_]*(\\\\.[A-Za-z_][A-Za-z0-9_]*)?$/`,\n    );\n  }\n}\n\nfunction assertAllowed(\n  name: string,\n  allowed: readonly string[] | undefined,\n): void {\n  if (allowed && !allowed.includes(name)) {\n    throw new Error(\n      `[Directive] predicateToSQL: column \"${name}\" is not in the allowedKeys list — add it to options.allowedKeys or remove it from the predicate`,\n    );\n  }\n}\n\nfunction validateSelect(select: string | readonly string[]): string {\n  if (Array.isArray(select)) {\n    if (select.length === 0) {\n      throw new Error(`[Directive] predicateToSQL: select must not be empty`);\n    }\n    for (const col of select) {\n      assertIdentifier(col, \"column\");\n    }\n\n    return select.join(\", \");\n  }\n  const s = select as string;\n  if (s === \"*\") return \"*\";\n  assertIdentifier(s, \"column\");\n\n  return s;\n}\n\n// ============================================================================\n// Operator translation\n// ============================================================================\n\ninterface BuildContext {\n  params: unknown[];\n  placeholder: (i: number) => string;\n  allowed?: readonly string[];\n}\n\nfunction nextParam(ctx: BuildContext, value: unknown): string {\n  ctx.params.push(value);\n\n  return ctx.placeholder(ctx.params.length);\n}\n\n/**\n * Render one operator on one column. `column` is already\n * identifier-validated; the operand goes through `nextParam` so it lands\n * in `params`, never in the SQL string.\n */\nfunction renderOp(\n  column: string,\n  op: string,\n  operand: unknown,\n  ctx: BuildContext,\n): string {\n  switch (op) {\n    case \"$eq\":\n      return `${column} = ${nextParam(ctx, operand)}`;\n    case \"$ne\":\n      return `${column} <> ${nextParam(ctx, operand)}`;\n    case \"$gt\":\n      return `${column} > ${nextParam(ctx, operand)}`;\n    case \"$gte\":\n      return `${column} >= ${nextParam(ctx, operand)}`;\n    case \"$lt\":\n      return `${column} < ${nextParam(ctx, operand)}`;\n    case \"$lte\":\n      return `${column} <= ${nextParam(ctx, operand)}`;\n    case \"$in\":\n      if (!Array.isArray(operand)) {\n        throw new Error(`[Directive] predicateToSQL: $in operand must be an array`);\n      }\n      return `${column} = ANY(${nextParam(ctx, operand)})`;\n    case \"$nin\":\n      if (!Array.isArray(operand)) {\n        throw new Error(`[Directive] predicateToSQL: $nin operand must be an array`);\n      }\n      return `NOT (${column} = ANY(${nextParam(ctx, operand)}))`;\n    case \"$exists\":\n      return operand === true ? `${column} IS NOT NULL` : `${column} IS NULL`;\n    case \"$between\": {\n      if (!Array.isArray(operand) || operand.length !== 2) {\n        throw new Error(\n          `[Directive] predicateToSQL: $between operand must be a [low, high] tuple`,\n        );\n      }\n      return `${column} BETWEEN ${nextParam(ctx, operand[0])} AND ${nextParam(ctx, operand[1])}`;\n    }\n    case \"$startsWith\":\n      if (typeof operand !== \"string\") {\n        throw new Error(\n          `[Directive] predicateToSQL: $startsWith operand must be a string`,\n        );\n      }\n      // ESCAPE '\\' makes the escape character deterministic regardless of\n      // the server's standard_conforming_strings setting or MySQL's\n      // NO_BACKSLASH_ESCAPES mode.\n      return `${column} LIKE ${nextParam(ctx, escapeLike(operand))} || '%' ESCAPE '\\\\'`;\n    case \"$endsWith\":\n      if (typeof operand !== \"string\") {\n        throw new Error(\n          `[Directive] predicateToSQL: $endsWith operand must be a string`,\n        );\n      }\n      return `${column} LIKE '%' || ${nextParam(ctx, escapeLike(operand))} ESCAPE '\\\\'`;\n    case \"$contains\":\n      if (typeof operand !== \"string\") {\n        throw new Error(\n          `[Directive] predicateToSQL: $contains only supports string operands — array containment requires a JOIN, not a predicate`,\n        );\n      }\n      return `${column} LIKE '%' || ${nextParam(ctx, escapeLike(operand))} || '%' ESCAPE '\\\\'`;\n    case \"$matches\": {\n      if (!(operand instanceof RegExp)) {\n        throw new Error(\n          `[Directive] predicateToSQL: $matches operand must be a RegExp`,\n        );\n      }\n      // Postgres uses ~ (case-sensitive) and ~* (case-insensitive). The\n      // RegExp's `i` flag picks the operator; other flags are silently\n      // dropped because their semantics differ between JS and Postgres.\n      const operator = operand.flags.includes(\"i\") ? \"~*\" : \"~\";\n\n      return `${column} ${operator} ${nextParam(ctx, operand.source)}`;\n    }\n    case \"$changed\":\n      throw new Error(\n        `[Directive] predicateToSQL: $changed is an effects-only operator — no server-side translation (a database row has no \"prev\" snapshot)`,\n      );\n    default:\n      throw new Error(\n        `[Directive] predicateToSQL: unknown operator \"${op}\" — known: ${[...PREDICATE_OPERATORS].join(\", \")}`,\n      );\n  }\n}\n\n/**\n * Escape `%`, `_`, and `\\` in a LIKE operand. Paired with an explicit\n * `ESCAPE '\\'` clause for cross-database determinism.\n */\nfunction escapeLike(s: string): string {\n  return s.replace(/[\\\\%_]/g, \"\\\\$&\");\n}\n\n// ============================================================================\n// Recursive walk\n// ============================================================================\n\nfunction isPlainObject(v: unknown): v is Record<string, unknown> {\n  return v !== null && typeof v === \"object\" && !Array.isArray(v);\n}\n\nfunction isOperatorObject(v: unknown): v is Record<string, unknown> {\n  if (!isPlainObject(v)) return false;\n  const keys = Object.keys(v);\n  if (keys.length === 0) return false;\n  for (const k of keys) {\n    if (!k.startsWith(\"$\")) return false;\n  }\n\n  return true;\n}\n\nfunction assertNoSiblingKeys(spec: Record<string, unknown>, combinator: string): void {\n  const sibs = Object.keys(spec).filter((k) => k !== combinator);\n  if (sibs.length > 0) {\n    throw new Error(\n      `[Directive] predicateToSQL: ${combinator} cannot coexist with sibling keys (${sibs.join(\", \")}) — wrap them in $all together, or move them inside the ${combinator} children`,\n    );\n  }\n}\n\nfunction buildWhere(spec: unknown, ctx: BuildContext, depth: number): string {\n  if (depth > MAX_PREDICATE_DEPTH) {\n    throw new Error(\n      `[Directive] predicateToSQL: predicate depth limit (${MAX_PREDICATE_DEPTH}) exceeded — flatten the predicate or check for a cyclic spec object`,\n    );\n  }\n  if (spec === null || typeof spec !== \"object\") {\n    throw new Error(\n      `[Directive] predicateToSQL: predicate must be an object or array, got ${typeof spec}`,\n    );\n  }\n\n  // Array-form predicate ([{fact, op, value}, ...]) — implicit AND.\n  if (Array.isArray(spec)) {\n    if (spec.length === 0) return \"TRUE\";\n    const parts = spec.map((clause) => {\n      if (\n        !clause ||\n        typeof clause !== \"object\" ||\n        !(\"fact\" in clause) ||\n        !(\"op\" in clause)\n      ) {\n        throw new Error(\n          `[Directive] predicateToSQL: array-form clause must be { fact, op, value }`,\n        );\n      }\n      const c = clause as { fact: string; op: string; value: unknown };\n      assertIdentifier(c.fact, \"column\");\n      assertAllowed(c.fact, ctx.allowed);\n\n      return renderOp(c.fact, c.op, c.value, ctx);\n    });\n\n    return parts.length === 1 ? parts[0]! : `(${parts.join(\" AND \")})`;\n  }\n\n  // Combinators — must be the *only* key on the object.\n  if (\"$all\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$all\");\n    const arr = (spec as { $all: unknown[] }).$all;\n    if (!Array.isArray(arr)) {\n      throw new Error(`[Directive] predicateToSQL: $all must be an array`);\n    }\n    if (arr.length === 0) return \"TRUE\";\n    const parts = arr.map((p) => buildWhere(p, ctx, depth + 1));\n\n    return parts.length === 1 ? parts[0]! : `(${parts.join(\" AND \")})`;\n  }\n  if (\"$any\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$any\");\n    const arr = (spec as { $any: unknown[] }).$any;\n    if (!Array.isArray(arr)) {\n      throw new Error(`[Directive] predicateToSQL: $any must be an array`);\n    }\n    if (arr.length === 0) return \"FALSE\";\n    const parts = arr.map((p) => buildWhere(p, ctx, depth + 1));\n\n    return parts.length === 1 ? parts[0]! : `(${parts.join(\" OR \")})`;\n  }\n  if (\"$not\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$not\");\n    const inner = (spec as { $not: unknown }).$not;\n\n    return `NOT (${buildWhere(inner, ctx, depth + 1)})`;\n  }\n\n  // Object form — every key is a column, every value either a literal\n  // (equality) or an operator object.\n  const parts: string[] = [];\n  for (const [key, value] of Object.entries(spec as Record<string, unknown>)) {\n    assertIdentifier(key, \"column\");\n    assertAllowed(key, ctx.allowed);\n\n    if (isOperatorObject(value)) {\n      for (const [op, operand] of Object.entries(value)) {\n        if (!PREDICATE_OPERATORS.has(op)) {\n          throw new Error(\n            `[Directive] predicateToSQL: unknown operator \"${op}\" on column \"${key}\" — known: ${[...PREDICATE_OPERATORS].join(\", \")}`,\n          );\n        }\n        parts.push(renderOp(key, op, operand, ctx));\n      }\n    } else if (isPlainObject(value)) {\n      throw new Error(\n        `[Directive] predicateToSQL: nested predicate at \"${key}\" — cross-module / partial-match predicates have no SQL equivalent (single-table queries only in v1; pass a flat predicate or build JOIN by hand with predicateToWhere)`,\n      );\n    } else {\n      parts.push(renderOp(key, \"$eq\", value, ctx));\n    }\n  }\n\n  if (parts.length === 0) return \"TRUE\";\n  if (parts.length === 1) return parts[0]!;\n\n  return `(${parts.join(\" AND \")})`;\n}\n\n// ============================================================================\n// Public API\n// ============================================================================\n\nconst DEFAULT_PLACEHOLDER = (i: number) => `$${i}`;\n\n/**\n * Compile a {@link FactPredicate} to a parameterized SQL statement.\n *\n * Operand values **never** appear in the SQL string — they flow through\n * the `params` array. Table and column identifiers are regex-validated.\n *\n * @example\n * ```ts\n * const where = { age: { $gte: 18 }, status: { $in: [\"active\", \"pending\"] } };\n *\n * predicateToSQL(where, { table: \"users\" });\n * // → { sql: \"SELECT * FROM users WHERE (age >= $1 AND status = ANY($2))\",\n * //     where: \"(age >= $1 AND status = ANY($2))\",\n * //     params: [18, [\"active\", \"pending\"]] }\n *\n * // MySQL/SQLite placeholder:\n * predicateToSQL(where, { table: \"users\", placeholder: () => \"?\" });\n *\n * // Recommended for AI/user-supplied predicates:\n * predicateToSQL(where, { table: \"users\", allowedKeys: [\"age\", \"status\"] });\n * ```\n */\nexport function predicateToSQL<F = Record<string, unknown>>(\n  predicate: FactPredicate<F>,\n  options: PredicateToSqlOptions,\n): PredicateToSqlResult {\n  const { table, allowedKeys } = options;\n  const placeholder = options.placeholder ?? DEFAULT_PLACEHOLDER;\n  const select = options.select ?? \"*\";\n\n  assertIdentifier(table, \"table\");\n  const projection = validateSelect(select);\n\n  const ctx: BuildContext = { params: [], placeholder, allowed: allowedKeys };\n  const where = buildWhere(predicate, ctx, 0);\n  const sql = `SELECT ${projection} FROM ${table} WHERE ${where}`;\n\n  return { sql, where, params: ctx.params };\n}\n\n/**\n * Lower-level variant — returns just the `WHERE` clause body and the\n * `params` array, no `SELECT ... FROM` wrapper. Use this when you need\n * to embed the WHERE in a larger query (JOIN, UPDATE, DELETE, COUNT).\n *\n * @example\n * ```ts\n * const { where, params } = predicateToWhere({ age: { $gte: 18 } });\n * await db.query(`UPDATE users SET tier = 'adult' WHERE ${where}`, params);\n * ```\n */\nexport function predicateToWhere<F = Record<string, unknown>>(\n  predicate: FactPredicate<F>,\n  options: Omit<PredicateToSqlOptions, \"table\" | \"select\"> = {},\n): { where: string; params: unknown[] } {\n  const placeholder = options.placeholder ?? DEFAULT_PLACEHOLDER;\n  const ctx: BuildContext = {\n    params: [],\n    placeholder,\n    allowed: options.allowedKeys,\n  };\n\n  return { where: buildWhere(predicate, ctx, 0), params: ctx.params };\n}\n","/**\n * Compile a `FactPredicate` to a MongoDB query document. Most of\n * Directive's predicate operator set is already Mongo-compatible by\n * design — this translator handles the few ops that need rewriting\n * (`$startsWith`/`$endsWith`/`$contains` → `$regex`, `$between` →\n * `$gte`+`$lte`, `$matches` → `$regex`/`$options`).\n *\n * Combinators map cleanly: `$all` → `$and`, `$any` → `$or`, `$not` → `$nor`.\n *\n * Pure transformation. No driver dependency.\n */\n\nimport { MAX_PREDICATE_DEPTH } from \"./predicate.js\";\nimport {\n  PREDICATE_OPERATORS,\n  type FactPredicate,\n} from \"./types/predicate.js\";\n\nexport interface PredicateToMongoOptions {\n  /**\n   * Allowlist of fact / field keys the predicate may reference. STRONGLY\n   * RECOMMENDED for any predicate that crosses a trust boundary.\n   */\n  allowedKeys?: readonly string[];\n  /**\n   * Allow `.` in field names (for sub-document traversal: `\"user.role\"`).\n   * Default is `false` — `.` is rejected so the predicate cannot\n   * accidentally read sub-document fields the developer did not anticipate.\n   */\n  allowDottedPaths?: boolean;\n}\n\nfunction escapeRegex(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\nfunction isPlainObject(v: unknown): v is Record<string, unknown> {\n  return v !== null && typeof v === \"object\" && !Array.isArray(v);\n}\n\nfunction isOperatorObject(v: unknown): v is Record<string, unknown> {\n  if (!isPlainObject(v)) return false;\n  const keys = Object.keys(v);\n  if (keys.length === 0) return false;\n  for (const k of keys) {\n    if (!k.startsWith(\"$\")) return false;\n  }\n\n  return true;\n}\n\nconst FIELD_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;\nconst FIELD_DOTTED_RE = /^[A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)*$/;\n\n/**\n * Reject any field that starts with `$` — that's how Mongo's `$where`\n * JavaScript-evaluation injection lands a predicate-as-RCE. Also reject\n * non-identifier characters (`.`, ` `, etc.) unless dotted paths are\n * explicitly enabled.\n */\nfunction assertFieldName(name: string, opts: PredicateToMongoOptions): void {\n  if (typeof name !== \"string\" || name.length === 0) {\n    throw new Error(\n      `[Directive] predicateToMongo: field name must be a non-empty string, got ${typeof name}`,\n    );\n  }\n  if (name.startsWith(\"$\")) {\n    throw new Error(\n      `[Directive] predicateToMongo: field name \"${name}\" starts with \"$\" — reserved for Mongo operators (a top-level $where would be an injection vector)`,\n    );\n  }\n  const re = opts.allowDottedPaths ? FIELD_DOTTED_RE : FIELD_RE;\n  if (!re.test(name)) {\n    throw new Error(\n      `[Directive] predicateToMongo: invalid field name \"${name}\"${opts.allowDottedPaths ? \"\" : ' — pass options.allowDottedPaths=true to permit sub-document paths like \"user.role\"'}`,\n    );\n  }\n}\n\nfunction assertAllowed(\n  field: string,\n  allowed: readonly string[] | undefined,\n): void {\n  if (allowed && !allowed.includes(field)) {\n    throw new Error(\n      `[Directive] predicateToMongo: field \"${field}\" is not in the allowedKeys list — add it to options.allowedKeys or remove it from the predicate`,\n    );\n  }\n}\n\nfunction assertNoSiblingKeys(spec: Record<string, unknown>, combinator: string): void {\n  const sibs = Object.keys(spec).filter((k) => k !== combinator);\n  if (sibs.length > 0) {\n    throw new Error(\n      `[Directive] predicateToMongo: ${combinator} cannot coexist with sibling keys (${sibs.join(\", \")}) — wrap them in $all together, or move them inside the ${combinator} children`,\n    );\n  }\n}\n\n/**\n * Translate a single operator/operand pair into the Mongo equivalent.\n * Returns the value side of `{ field: <here> }`.\n */\nfunction translateOp(op: string, operand: unknown): Record<string, unknown> {\n  switch (op) {\n    case \"$eq\":\n    case \"$ne\":\n    case \"$gt\":\n    case \"$gte\":\n    case \"$lt\":\n    case \"$lte\":\n    case \"$in\":\n    case \"$nin\":\n    case \"$exists\":\n      return { [op]: operand };\n    case \"$between\": {\n      if (!Array.isArray(operand) || operand.length !== 2) {\n        throw new Error(\n          `[Directive] predicateToMongo: $between operand must be a [low, high] tuple`,\n        );\n      }\n      return { $gte: operand[0], $lte: operand[1] };\n    }\n    case \"$startsWith\":\n      if (typeof operand !== \"string\") {\n        throw new Error(\n          `[Directive] predicateToMongo: $startsWith operand must be a string`,\n        );\n      }\n      return { $regex: `^${escapeRegex(operand)}` };\n    case \"$endsWith\":\n      if (typeof operand !== \"string\") {\n        throw new Error(\n          `[Directive] predicateToMongo: $endsWith operand must be a string`,\n        );\n      }\n      return { $regex: `${escapeRegex(operand)}$` };\n    case \"$contains\":\n      if (typeof operand === \"string\") {\n        return { $regex: escapeRegex(operand) };\n      }\n      throw new Error(\n        `[Directive] predicateToMongo: $contains in Mongo expects a string operand — for array element membership use $elemMatch or $in directly`,\n      );\n    case \"$matches\": {\n      if (operand instanceof RegExp) {\n        return operand.flags\n          ? { $regex: operand.source, $options: operand.flags }\n          : { $regex: operand.source };\n      }\n      if (typeof operand === \"string\") {\n        return { $regex: operand };\n      }\n      throw new Error(\n        `[Directive] predicateToMongo: $matches operand must be a RegExp or string`,\n      );\n    }\n    case \"$changed\":\n      throw new Error(\n        `[Directive] predicateToMongo: $changed is an effects-only operator — no MongoDB query equivalent`,\n      );\n    default:\n      throw new Error(\n        `[Directive] predicateToMongo: unknown operator \"${op}\" — known: ${[...PREDICATE_OPERATORS].join(\", \")}`,\n      );\n  }\n}\n\nfunction buildQuery(\n  spec: unknown,\n  opts: PredicateToMongoOptions,\n  depth: number,\n): Record<string, unknown> {\n  if (depth > MAX_PREDICATE_DEPTH) {\n    throw new Error(\n      `[Directive] predicateToMongo: predicate depth limit (${MAX_PREDICATE_DEPTH}) exceeded — flatten the predicate or check for a cyclic spec object`,\n    );\n  }\n  if (spec === null || typeof spec !== \"object\") {\n    throw new Error(\n      `[Directive] predicateToMongo: predicate must be an object or array, got ${typeof spec}`,\n    );\n  }\n\n  // Array form → implicit AND.\n  if (Array.isArray(spec)) {\n    if (spec.length === 0) return {};\n    const obj: Record<string, unknown> = {};\n    const conflicts: Array<Record<string, unknown>> = [];\n    for (const clause of spec) {\n      if (\n        !clause ||\n        typeof clause !== \"object\" ||\n        !(\"fact\" in clause) ||\n        !(\"op\" in clause)\n      ) {\n        throw new Error(\n          `[Directive] predicateToMongo: array-form clause must be { fact, op, value }`,\n        );\n      }\n      const c = clause as { fact: string; op: string; value: unknown };\n      assertFieldName(c.fact, opts);\n      assertAllowed(c.fact, opts.allowedKeys);\n      const translated = translateOp(c.op, c.value);\n\n      if (c.fact in obj && isPlainObject(obj[c.fact])) {\n        const existing = obj[c.fact] as Record<string, unknown>;\n        const overlap = Object.keys(translated).some((k) => k in existing);\n        if (overlap) {\n          conflicts.push({ [c.fact]: translated });\n        } else {\n          obj[c.fact] = { ...existing, ...translated };\n        }\n      } else if (c.fact in obj) {\n        conflicts.push({ [c.fact]: translated });\n      } else {\n        obj[c.fact] = translated;\n      }\n    }\n    if (conflicts.length > 0) {\n      const andClauses: Array<Record<string, unknown>> = [];\n      for (const [k, v] of Object.entries(obj)) {\n        andClauses.push({ [k]: v });\n      }\n      andClauses.push(...conflicts);\n\n      return { $and: andClauses };\n    }\n\n    return obj;\n  }\n\n  // Combinators\n  if (\"$all\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$all\");\n    const arr = (spec as { $all: unknown[] }).$all;\n    if (!Array.isArray(arr)) {\n      throw new Error(`[Directive] predicateToMongo: $all must be an array`);\n    }\n    if (arr.length === 0) return {};\n    if (arr.length === 1) return buildQuery(arr[0], opts, depth + 1);\n\n    return { $and: arr.map((p) => buildQuery(p, opts, depth + 1)) };\n  }\n  if (\"$any\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$any\");\n    const arr = (spec as { $any: unknown[] }).$any;\n    if (!Array.isArray(arr)) {\n      throw new Error(`[Directive] predicateToMongo: $any must be an array`);\n    }\n    // Tautological-false — stable across Mongo versions, no _id assumption.\n    if (arr.length === 0) return { $expr: { $eq: [1, 0] } };\n    if (arr.length === 1) return buildQuery(arr[0], opts, depth + 1);\n\n    return { $or: arr.map((p) => buildQuery(p, opts, depth + 1)) };\n  }\n  if (\"$not\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$not\");\n    const inner = (spec as { $not: unknown }).$not;\n    // Mongo's top-level $not is restricted to per-field; $nor: [...]\n    // is the portable equivalent.\n    return { $nor: [buildQuery(inner, opts, depth + 1)] };\n  }\n\n  // Object form — every key is a field name (validated to NOT start with $).\n  const out: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(spec as Record<string, unknown>)) {\n    assertFieldName(key, opts);\n    assertAllowed(key, opts.allowedKeys);\n\n    if (isOperatorObject(value)) {\n      const merged: Record<string, unknown> = {};\n      for (const [op, operand] of Object.entries(value)) {\n        if (!PREDICATE_OPERATORS.has(op)) {\n          throw new Error(\n            `[Directive] predicateToMongo: unknown operator \"${op}\" on field \"${key}\" — known: ${[...PREDICATE_OPERATORS].join(\", \")}`,\n          );\n        }\n        Object.assign(merged, translateOp(op, operand));\n      }\n      out[key] = merged;\n    } else if (isPlainObject(value)) {\n      out[key] = value;\n    } else {\n      out[key] = value;\n    }\n  }\n\n  return out;\n}\n\n/**\n * Compile a {@link FactPredicate} to a MongoDB query document.\n *\n * Field names are validated to NOT start with `$` (which would land\n * `$where` and other server-side JS evaluation operators directly in the\n * query — an injection vector for AI/user-generated predicates).\n *\n * @example\n * ```ts\n * predicateToMongo({ age: { $gte: 18 }, status: { $in: [\"active\", \"pending\"] } })\n * // → { age: { $gte: 18 }, status: { $in: [\"active\", \"pending\"] } }\n *\n * predicateToMongo({ name: { $startsWith: \"Al\" } })\n * // → { name: { $regex: \"^Al\" } }\n *\n * predicateToMongo({ $any: [{ tier: \"gold\" }, { score: { $gte: 100 } }] })\n * // → { $or: [{ tier: \"gold\" }, { score: { $gte: 100 } }] }\n * ```\n */\nexport function predicateToMongo<F = Record<string, unknown>>(\n  predicate: FactPredicate<F>,\n  options: PredicateToMongoOptions = {},\n): Record<string, unknown> {\n  return buildQuery(predicate, options, 0);\n}\n","/**\n * Compile a `FactPredicate` to a PostgREST querystring.\n *\n * PostgREST's filter grammar is column-scoped: `?age=gte.18&status=in.(active,pending)`.\n * Logical groups use `and=(...)` / `or=(...)` / `not.and=(...)`.\n *\n * Reference: https://postgrest.org/en/stable/api.html#operators\n */\n\nimport { MAX_PREDICATE_DEPTH } from \"./predicate.js\";\nimport {\n  PREDICATE_OPERATORS,\n  type FactPredicate,\n} from \"./types/predicate.js\";\n\nexport interface PredicateToPostgrestOptions {\n  /** Allowlist of column keys the predicate may reference. */\n  allowedKeys?: readonly string[];\n  /**\n   * Encoding mode for the returned string.\n   *  - `\"querystring\"` (default): a full querystring without a leading `?`,\n   *    with each clause value URL-encoded — drops straight into `fetch`.\n   *  - `\"raw\"`: the same content, leaving `(`, `)`, `,` unencoded for\n   *    readability. Use this only when you'll encode the result yourself.\n   */\n  mode?: \"querystring\" | \"raw\";\n}\n\nconst IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;\n\nfunction assertColumn(name: string, allowed?: readonly string[]): void {\n  if (typeof name !== \"string\" || !IDENT_RE.test(name)) {\n    throw new Error(\n      `[Directive] predicateToPostgrest: invalid column identifier \"${name}\"`,\n    );\n  }\n  if (allowed && !allowed.includes(name)) {\n    throw new Error(\n      `[Directive] predicateToPostgrest: column \"${name}\" is not in the allowedKeys list — add it to options.allowedKeys or remove it from the predicate`,\n    );\n  }\n}\n\nfunction assertNoSiblingKeys(spec: Record<string, unknown>, combinator: string): void {\n  const sibs = Object.keys(spec).filter((k) => k !== combinator);\n  if (sibs.length > 0) {\n    throw new Error(\n      `[Directive] predicateToPostgrest: ${combinator} cannot coexist with sibling keys (${sibs.join(\", \")}) — wrap them in $all together, or move them inside the ${combinator} children`,\n    );\n  }\n}\n\n/** Encode a single PostgREST value. Strings with reserved chars get quoted. */\nfunction encodeValue(v: unknown): string {\n  if (v === null || v === undefined) return \"null\";\n  if (typeof v === \"boolean\") return v ? \"true\" : \"false\";\n  if (typeof v === \"number\" || typeof v === \"bigint\") return String(v);\n  if (v instanceof Date) return v.toISOString();\n  if (typeof v === \"string\") {\n    // PostgREST treats `,` `.` `(` `)` and `:` as syntax; quote any\n    // string containing them. Inside quotes, `\"` → `\\\"` and `\\` → `\\\\`.\n    if (/[,.():\"\\\\\\s]/.test(v)) {\n      return `\"${v.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"')}\"`;\n    }\n\n    return v;\n  }\n  throw new Error(\n    `[Directive] predicateToPostgrest: cannot encode value of type ${typeof v}`,\n  );\n}\n\nfunction encodeList(arr: readonly unknown[]): string {\n  return `(${arr.map(encodeValue).join(\",\")})`;\n}\n\n/** Escape `\\`, `%`, `_`, `*` so they match literally instead of as wildcards. */\nfunction escapeLikeOperand(s: string): string {\n  return s.replace(/[\\\\%_*]/g, \"\\\\$&\");\n}\n\n/**\n * Render the value side of one operator. Returns a string like\n * `gte.18` or `in.(a,b)` — without the column name.\n */\nfunction renderOp(op: string, operand: unknown): string {\n  switch (op) {\n    case \"$eq\":\n      return `eq.${encodeValue(operand)}`;\n    case \"$ne\":\n      return `neq.${encodeValue(operand)}`;\n    case \"$gt\":\n      return `gt.${encodeValue(operand)}`;\n    case \"$gte\":\n      return `gte.${encodeValue(operand)}`;\n    case \"$lt\":\n      return `lt.${encodeValue(operand)}`;\n    case \"$lte\":\n      return `lte.${encodeValue(operand)}`;\n    case \"$in\":\n      if (!Array.isArray(operand)) {\n        throw new Error(`[Directive] predicateToPostgrest: $in operand must be an array`);\n      }\n      return `in.${encodeList(operand)}`;\n    case \"$nin\":\n      if (!Array.isArray(operand)) {\n        throw new Error(`[Directive] predicateToPostgrest: $nin operand must be an array`);\n      }\n      return `not.in.${encodeList(operand)}`;\n    case \"$exists\":\n      return operand === true ? \"not.is.null\" : \"is.null\";\n    case \"$startsWith\":\n      if (typeof operand !== \"string\") {\n        throw new Error(\n          `[Directive] predicateToPostgrest: $startsWith operand must be a string`,\n        );\n      }\n      return `like.${encodeValue(escapeLikeOperand(operand) + \"*\")}`;\n    case \"$endsWith\":\n      if (typeof operand !== \"string\") {\n        throw new Error(\n          `[Directive] predicateToPostgrest: $endsWith operand must be a string`,\n        );\n      }\n      return `like.${encodeValue(\"*\" + escapeLikeOperand(operand))}`;\n    case \"$contains\":\n      if (typeof operand !== \"string\") {\n        throw new Error(\n          `[Directive] predicateToPostgrest: $contains expects a string operand (array containment is the cs operator with a different shape — out of scope for v1)`,\n        );\n      }\n      return `like.${encodeValue(\"*\" + escapeLikeOperand(operand) + \"*\")}`;\n    case \"$matches\":\n      if (operand instanceof RegExp) {\n        const o = operand.flags.includes(\"i\") ? \"imatch\" : \"match\";\n\n        return `${o}.${encodeValue(operand.source)}`;\n      }\n      if (typeof operand === \"string\") {\n        return `match.${encodeValue(operand)}`;\n      }\n      throw new Error(\n        `[Directive] predicateToPostgrest: $matches operand must be a RegExp or string`,\n      );\n    // $between is handled at the build() level by decomposing into $gte + $lte.\n    case \"$changed\":\n      throw new Error(\n        `[Directive] predicateToPostgrest: $changed is an effects-only operator — no server query equivalent`,\n      );\n    default:\n      throw new Error(\n        `[Directive] predicateToPostgrest: unknown operator \"${op}\" — known: ${[...PREDICATE_OPERATORS].join(\", \")}`,\n      );\n  }\n}\n\nfunction isPlainObject(v: unknown): v is Record<string, unknown> {\n  return v !== null && typeof v === \"object\" && !Array.isArray(v);\n}\n\nfunction isOperatorObject(v: unknown): v is Record<string, unknown> {\n  if (!isPlainObject(v)) return false;\n  const keys = Object.keys(v);\n  if (keys.length === 0) return false;\n  for (const k of keys) {\n    if (!k.startsWith(\"$\")) return false;\n  }\n\n  return true;\n}\n\nfunction colClause(column: string, opAndValue: string): string {\n  return `${column}=${opAndValue}`;\n}\n\nfunction groupClause(\n  logical: \"and\" | \"or\" | \"not.and\" | \"not.or\",\n  parts: string[],\n): string {\n  return `${logical}=(${parts.join(\",\")})`;\n}\n\n/**\n * Render one operator inside one column. For `$between`, decomposes into\n * two clauses ($gte + $lte) so the predicate's portability promise holds.\n */\nfunction renderColumnOps(\n  column: string,\n  op: string,\n  operand: unknown,\n  atTop: boolean,\n): string[] {\n  if (op === \"$between\") {\n    if (!Array.isArray(operand) || operand.length !== 2) {\n      throw new Error(\n        `[Directive] predicateToPostgrest: $between operand must be a [low, high] tuple`,\n      );\n    }\n    const lo = atTop\n      ? colClause(column, renderOp(\"$gte\", operand[0]))\n      : `${column}.${renderOp(\"$gte\", operand[0])}`;\n    const hi = atTop\n      ? colClause(column, renderOp(\"$lte\", operand[1]))\n      : `${column}.${renderOp(\"$lte\", operand[1])}`;\n\n    return [lo, hi];\n  }\n\n  return [\n    atTop\n      ? colClause(column, renderOp(op, operand))\n      : `${column}.${renderOp(op, operand)}`,\n  ];\n}\n\n/**\n * Convert a predicate into PostgREST clause strings. Top-level returns a\n * list of `column=value` pairs (joined by `&`); nested returns\n * grouped/clause-list strings depending on the parent combinator.\n *\n * @param atTop  When true, clauses are top-level (& separator).\n *               When false, clauses are inside `and=(...)`/`or=(...)`\n *               and must use `,` separator and `column.op.val` syntax.\n */\nfunction build(\n  spec: unknown,\n  allowed: readonly string[] | undefined,\n  atTop: boolean,\n  depth: number,\n): string[] {\n  if (depth > MAX_PREDICATE_DEPTH) {\n    throw new Error(\n      `[Directive] predicateToPostgrest: predicate depth limit (${MAX_PREDICATE_DEPTH}) exceeded — flatten the predicate or check for a cyclic spec object`,\n    );\n  }\n  if (spec === null || typeof spec !== \"object\") {\n    throw new Error(\n      `[Directive] predicateToPostgrest: predicate must be an object or array`,\n    );\n  }\n\n  if (Array.isArray(spec)) {\n    const out: string[] = [];\n    for (const clause of spec) {\n      if (\n        !clause ||\n        typeof clause !== \"object\" ||\n        !(\"fact\" in clause) ||\n        !(\"op\" in clause)\n      ) {\n        throw new Error(\n          `[Directive] predicateToPostgrest: array-form clause must be { fact, op, value }`,\n        );\n      }\n      const c = clause as { fact: string; op: string; value: unknown };\n      assertColumn(c.fact, allowed);\n      out.push(...renderColumnOps(c.fact, c.op, c.value, atTop));\n    }\n\n    return out;\n  }\n\n  if (\"$all\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$all\");\n    const arr = (spec as { $all: unknown[] }).$all;\n    if (!Array.isArray(arr)) {\n      throw new Error(`[Directive] predicateToPostgrest: $all must be an array`);\n    }\n    if (atTop) {\n      const out: string[] = [];\n      for (const child of arr) {\n        out.push(...build(child, allowed, true, depth + 1));\n      }\n\n      return out;\n    }\n    const parts: string[] = [];\n    for (const child of arr) {\n      parts.push(...build(child, allowed, false, depth + 1));\n    }\n\n    return [groupClause(\"and\", parts)];\n  }\n  if (\"$any\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$any\");\n    const arr = (spec as { $any: unknown[] }).$any;\n    if (!Array.isArray(arr)) {\n      throw new Error(`[Directive] predicateToPostgrest: $any must be an array`);\n    }\n    // Empty $any is tautological-false. PostgREST has no clean way to\n    // express \"match nothing\"; pick a stable contradiction.\n    if (arr.length === 0) {\n      // pg's `id` exists on every base table — match a value no row can have.\n      return atTop\n        ? [\"id=is.null\", \"id=not.is.null\"]\n        : [groupClause(\"and\", [\"id.is.null\", \"id.not.is.null\"])];\n    }\n    const parts: string[] = [];\n    for (const child of arr) {\n      parts.push(...build(child, allowed, false, depth + 1));\n    }\n\n    return [groupClause(\"or\", parts)];\n  }\n  if (\"$not\" in spec) {\n    assertNoSiblingKeys(spec as Record<string, unknown>, \"$not\");\n    const inner = (spec as { $not: unknown }).$not;\n    const parts = build(inner, allowed, false, depth + 1);\n\n    return [groupClause(\"not.and\", parts)];\n  }\n\n  // Object form\n  const out: string[] = [];\n  for (const [key, value] of Object.entries(spec as Record<string, unknown>)) {\n    assertColumn(key, allowed);\n    if (isOperatorObject(value)) {\n      for (const [op, operand] of Object.entries(value)) {\n        if (!PREDICATE_OPERATORS.has(op)) {\n          throw new Error(\n            `[Directive] predicateToPostgrest: unknown operator \"${op}\" on column \"${key}\" — known: ${[...PREDICATE_OPERATORS].join(\", \")}`,\n          );\n        }\n        out.push(...renderColumnOps(key, op, operand, atTop));\n      }\n    } else if (isPlainObject(value)) {\n      throw new Error(\n        `[Directive] predicateToPostgrest: nested predicate at \"${key}\" — single-table queries only`,\n      );\n    } else {\n      out.push(...renderColumnOps(key, \"$eq\", value, atTop));\n    }\n  }\n\n  return out;\n}\n\n/**\n * Encode a clause string per PostgREST URL conventions.\n *\n * Splits on first `=` so the column/logical name is preserved verbatim\n * (it's identifier-validated) and only the value side is URL-encoded.\n */\nfunction encodeClause(c: string): string {\n  const eq = c.indexOf(\"=\");\n  if (eq < 0) return encodeURIComponent(c);\n  const key = c.slice(0, eq);\n  const value = c.slice(eq + 1);\n\n  return `${key}=${encodeURIComponent(value)}`;\n}\n\n/**\n * Compile a {@link FactPredicate} to a PostgREST querystring.\n *\n * @example\n * ```ts\n * predicateToPostgrest({ age: { $gte: 18 }, status: { $in: [\"active\", \"pending\"] } })\n * // → \"age=gte.18&status=in.%28active%2Cpending%29\"\n *\n * // Raw mode for debugging / building URLs by hand:\n * predicateToPostgrest({ age: { $gte: 18 } }, { mode: \"raw\" })\n * // → \"age=gte.18\"\n *\n * predicateToPostgrest({ $any: [{ tier: \"gold\" }, { score: { $gte: 100 } }] }, { mode: \"raw\" })\n * // → \"or=(tier.eq.gold,score.gte.100)\"\n * ```\n */\nexport function predicateToPostgrest<F = Record<string, unknown>>(\n  predicate: FactPredicate<F>,\n  options: PredicateToPostgrestOptions = {},\n): string {\n  const mode = options.mode ?? \"querystring\";\n  const clauses = build(predicate, options.allowedKeys, true, 0);\n  if (clauses.length === 0) return \"\";\n\n  return mode === \"raw\" ? clauses.join(\"&\") : clauses.map(encodeClause).join(\"&\");\n}\n","/**\n * Schema Type Builders\n *\n * Provides type-safe schema definitions with optional runtime validation.\n * Used to define fact types, derivation types, event payload types, etc.\n *\n * This module has no dependency on the facts store or tracking system.\n */\n\nimport isDevelopment from \"#is-development\";\nimport type { SchemaKindNode } from \"./schema-introspection.js\";\nimport type { SchemaType } from \"./types.js\";\n\n// ============================================================================\n// Schema Type Builders\n// ============================================================================\n\n/** Brand symbol for branded types */\ndeclare const Brand: unique symbol;\n\n/** Branded type - adds a unique brand to a base type */\nexport type Branded<T, B extends string> = T & { readonly [Brand]: B };\n\n/** Extended SchemaType with type name for better error messages */\nexport interface ExtendedSchemaType<T> extends SchemaType<T> {\n  readonly _typeName?: string;\n  readonly _default?: T | (() => T);\n  readonly _transform?: (value: unknown) => T;\n  readonly _description?: string;\n  readonly _refinements?: Array<{\n    predicate: (value: T) => boolean;\n    message: string;\n  }>;\n  /** Mutable - set by array validators to indicate which element failed */\n  _lastFailedIndex?: number;\n  /** Optional metadata for debugging and devtools (never read on hot path). */\n  readonly _meta?: import(\"./types/meta.js\").DefinitionMeta;\n  /**\n   * Structured kind discriminant used by introspection-time consumers\n   * (`predicateFromIntent`, `doctor`, `predicateToZod`). Optional for\n   * back-compat with legacy / third-party builders; when absent, the\n   * introspection layer parses `_typeName` instead.\n   */\n  readonly _kind?: SchemaKindNode;\n}\n\n/** Create a schema type builder with optional type name */\nfunction createSchemaType<T>(\n  validators: Array<(v: T) => boolean> = [],\n  typeName?: string,\n  defaultValue?: T | (() => T),\n  transform?: (value: unknown) => T,\n  description?: string,\n  refinements?: Array<{ predicate: (value: T) => boolean; message: string }>,\n  meta?: import(\"./types/meta.js\").DefinitionMeta,\n): ExtendedSchemaType<T> {\n  return {\n    _type: undefined as unknown as T,\n    _validators: validators,\n    _typeName: typeName,\n    _default: defaultValue,\n    _transform: transform,\n    _description: description,\n    _refinements: refinements,\n    _meta: meta,\n    validate(fn: (value: T) => boolean) {\n      return createSchemaType(\n        [...validators, fn],\n        typeName,\n        defaultValue,\n        transform,\n        description,\n        refinements,\n        meta,\n      );\n    },\n  };\n}\n\n/** Chainable schema type with all common methods */\nexport interface ChainableSchemaType<T> extends ExtendedSchemaType<T> {\n  default(value: T | (() => T)): ChainableSchemaType<T>;\n  transform<U>(fn: (value: T) => U): ChainableSchemaType<U>;\n  brand<B extends string>(): ChainableSchemaType<Branded<T, B>>;\n  describe(description: string): ChainableSchemaType<T>;\n  refine(\n    predicate: (value: T) => boolean,\n    message: string,\n  ): ChainableSchemaType<T>;\n  nullable(): ChainableSchemaType<T | null>;\n  optional(): ChainableSchemaType<T | undefined>;\n  /** Attach metadata for debugging and devtools. */\n  meta(meta: import(\"./types/meta.js\").DefinitionMeta): ChainableSchemaType<T>;\n}\n\n/** Create a chainable schema type with common methods */\nfunction createChainableType<T>(\n  validators: Array<(v: T) => boolean>,\n  typeName: string,\n  defaultValue?: T | (() => T),\n  transform?: (value: unknown) => T,\n  description?: string,\n  refinements?: Array<{ predicate: (value: T) => boolean; message: string }>,\n  fieldMeta?: import(\"./types/meta.js\").DefinitionMeta,\n): ChainableSchemaType<T> {\n  const base = createSchemaType<T>(\n    validators,\n    typeName,\n    defaultValue,\n    transform,\n    description,\n    refinements,\n    fieldMeta,\n  );\n  return {\n    ...base,\n    default(value: T | (() => T)) {\n      return createChainableType(\n        validators,\n        typeName,\n        value,\n        transform,\n        description,\n        refinements,\n        fieldMeta,\n      );\n    },\n    transform<U>(fn: (value: T) => U) {\n      const newTransform = (v: unknown) => {\n        const intermediate = transform ? transform(v) : (v as T);\n        return fn(intermediate);\n      };\n      return createChainableType<U>(\n        [],\n        typeName,\n        undefined,\n        newTransform as (v: unknown) => U,\n        description,\n        undefined,\n        fieldMeta,\n      );\n    },\n    brand<B extends string>() {\n      return createChainableType<Branded<T, B>>(\n        validators as Array<(v: Branded<T, B>) => boolean>,\n        `Branded<${typeName}>`,\n        defaultValue as Branded<T, B> | (() => Branded<T, B>),\n        transform as (value: unknown) => Branded<T, B>,\n        description,\n        refinements as Array<{\n          predicate: (value: Branded<T, B>) => boolean;\n          message: string;\n        }>,\n        fieldMeta,\n      );\n    },\n    describe(desc: string) {\n      return createChainableType(\n        validators,\n        typeName,\n        defaultValue,\n        transform,\n        desc,\n        refinements,\n        fieldMeta,\n      );\n    },\n    refine(predicate: (value: T) => boolean, message: string) {\n      const newRefinements = [...(refinements ?? []), { predicate, message }];\n      return createChainableType(\n        [...validators, predicate],\n        typeName,\n        defaultValue,\n        transform,\n        description,\n        newRefinements,\n        fieldMeta,\n      );\n    },\n    nullable() {\n      return createChainableType<T | null>(\n        [\n          (v): v is T | null =>\n            v === null || validators.every((fn) => fn(v as T)),\n        ],\n        `${typeName} | null`,\n        defaultValue as (T | null) | (() => T | null),\n        transform as (value: unknown) => T | null,\n        description,\n        undefined,\n        fieldMeta,\n      );\n    },\n    optional() {\n      return createChainableType<T | undefined>(\n        [\n          (v): v is T | undefined =>\n            v === undefined || validators.every((fn) => fn(v as T)),\n        ],\n        `${typeName} | undefined`,\n        defaultValue as (T | undefined) | (() => T | undefined),\n        transform as (value: unknown) => T | undefined,\n        description,\n        undefined,\n        fieldMeta,\n      );\n    },\n    meta(m: import(\"./types/meta.js\").DefinitionMeta) {\n      return createChainableType(\n        validators,\n        typeName,\n        defaultValue,\n        transform,\n        description,\n        refinements,\n        m,\n      );\n    },\n  };\n}\n\n/**\n * Two-form union schema constructor.\n *\n * Hoisted out of the `t` object literal because the overload-cast pattern\n * (`(impl) as { ovl1; ovl2 }`) inside an object literal triggers a TS\n * declaration-emit \"implicitly has type any\" cycle. Annotating the const\n * with the explicit overload type breaks the cycle so DTS can emit `t`'s\n * shape without recursing through the runtime expression.\n *\n * @internal\n */\ntype UnionFn = {\n  <T = unknown>(): ChainableSchemaType<T>;\n  <T extends SchemaType<unknown>[]>(\n    ...types: T\n  ): ChainableSchemaType<T[number] extends SchemaType<infer U> ? U : never>;\n};\n\nconst unionImpl: UnionFn = (<T extends SchemaType<unknown>[]>(...types: T) => {\n  if (types.length === 0) {\n    return createChainableType<unknown>([], \"union\");\n  }\n  type UnionType = T[number] extends SchemaType<infer U> ? U : never;\n  const typeNames = types.map(\n    (schemaType) =>\n      (schemaType as ExtendedSchemaType<unknown>)._typeName ?? \"unknown\",\n  );\n  return createChainableType<UnionType>(\n    [\n      (v): v is UnionType =>\n        types.some((schemaType) => schemaType._validators.every((fn) => fn(v))),\n    ],\n    typeNames.join(\" | \"),\n  );\n}) as UnionFn;\n\n/**\n * Schema type builders for defining fact types.\n *\n * @remarks\n * Each builder returns a chainable {@link ExtendedSchemaType} with validation\n * methods (`.min()`, `.max()`, `.pattern()`, etc.) and dev-mode runtime\n * type checking. Validators are tree-shaken in production builds.\n *\n * @example\n * ```typescript\n * const module = createModule(\"example\", {\n *   schema: {\n *     name: t.string(),\n *     age: t.number().min(0).max(150),\n *     active: t.boolean(),\n *     tags: t.array<string>().of(t.string()),\n *     user: t.object<{ id: string; email: string }>(),\n *   },\n * });\n * ```\n *\n * @public\n */\nexport const t = {\n  /**\n   * Create a string schema type.\n   *\n   * @example\n   * ```typescript\n   * // Basic string\n   * schema: { name: t.string() }\n   *\n   * // String literal union (for type safety)\n   * schema: { phase: t.string<\"red\" | \"green\" | \"yellow\">() }\n   *\n   * // With custom validation\n   * schema: { email: t.string().validate(s => s.includes(\"@\")) }\n   *\n   * // With transform\n   * schema: { trimmed: t.string().transform(s => s.trim()) }\n   *\n   * // With brand\n   * schema: { userId: t.string().brand<\"UserId\">() }\n   * ```\n   */\n  string<T extends string = string>() {\n    type ChainableString = ChainableSchemaType<T> & {\n      minLength(n: number): ChainableString;\n      maxLength(n: number): ChainableString;\n      pattern(regex: RegExp): ChainableString;\n      meta(m: import(\"./types/meta.js\").DefinitionMeta): ChainableString;\n    };\n\n    const createChainableString = (\n      validators: Array<(v: T) => boolean>,\n      defaultValue?: T | (() => T),\n      transform?: (value: unknown) => T,\n      description?: string,\n      refinements?: Array<{\n        predicate: (value: T) => boolean;\n        message: string;\n      }>,\n      fm?: import(\"./types/meta.js\").DefinitionMeta,\n    ): ChainableString => {\n      const chainable = createChainableType<T>(\n        validators,\n        \"string\",\n        defaultValue,\n        transform,\n        description,\n        refinements,\n        fm,\n      );\n      return {\n        ...chainable,\n        minLength(n: number) {\n          return createChainableString(\n            [...validators, (v) => (v as string).length >= n],\n            defaultValue,\n            transform,\n            description,\n            refinements,\n            fm,\n          );\n        },\n        maxLength(n: number) {\n          return createChainableString(\n            [...validators, (v) => (v as string).length <= n],\n            defaultValue,\n            transform,\n            description,\n            refinements,\n            fm,\n          );\n        },\n        pattern(regex: RegExp) {\n          return createChainableString(\n            [...validators, (v) => regex.test(v as string)],\n            defaultValue,\n            transform,\n            description,\n            refinements,\n            fm,\n          );\n        },\n        default(value: T | (() => T)) {\n          return createChainableString(\n            validators,\n            value,\n            transform,\n            description,\n            refinements,\n            fm,\n          );\n        },\n        describe(desc: string) {\n          return createChainableString(\n            validators,\n            defaultValue,\n            transform,\n            desc,\n            refinements,\n            fm,\n          );\n        },\n        refine(predicate: (value: T) => boolean, message: string) {\n          const newRefinements = [\n            ...(refinements ?? []),\n            { predicate, message },\n          ];\n          return createChainableString(\n            [...validators, predicate],\n            defaultValue,\n            transform,\n            description,\n            newRefinements,\n            fm,\n          );\n        },\n        meta(m: import(\"./types/meta.js\").DefinitionMeta) {\n          return createChainableString(\n            validators,\n            defaultValue,\n            transform,\n            description,\n            refinements,\n            m,\n          );\n        },\n      };\n    };\n\n    return createChainableString([(v): v is T => typeof v === \"string\"]);\n  },\n\n  /**\n   * Create a number schema type with optional min/max constraints.\n   *\n   * @example\n   * ```typescript\n   * // Basic number\n   * schema: { count: t.number() }\n   *\n   * // With range constraints\n   * schema: { age: t.number().min(0).max(150) }\n   *\n   * // With custom validation\n   * schema: { even: t.number().validate(n => n % 2 === 0) }\n   *\n   * // With default\n   * schema: { count: t.number().default(0) }\n   *\n   * // With transform (from string)\n   * schema: { age: t.number().transform(v => parseInt(String(v), 10)) }\n   * ```\n   */\n  number() {\n    type ChainableNumber = ChainableSchemaType<number> & {\n      min(n: number): ChainableNumber;\n      max(n: number): ChainableNumber;\n      meta(m: import(\"./types/meta.js\").DefinitionMeta): ChainableNumber;\n    };\n\n    const createChainableNumber = (\n      validators: Array<(v: number) => boolean>,\n      defaultValue?: number | (() => number),\n      transform?: (value: unknown) => number,\n      description?: string,\n      refinements?: Array<{\n        predicate: (value: number) => boolean;\n        message: string;\n      }>,\n      fm?: import(\"./types/meta.js\").DefinitionMeta,\n    ): ChainableNumber => {\n      const chainable = createChainableType<number>(\n        validators,\n        \"number\",\n        defaultValue,\n        transform,\n        description,\n        refinements,\n        fm,\n      );\n      return {\n        ...chainable,\n        min(n: number) {\n          return createChainableNumber(\n            [...validators, (v) => v >= n],\n            defaultValue,\n            transform,\n            description,\n            refinements,\n            fm,\n          );\n        },\n        max(n: number) {\n          return createChainableNumber(\n            [...validators, (v) => v <= n],\n            defaultValue,\n            transform,\n            description,\n            refinements,\n            fm,\n          );\n        },\n        default(value: number | (() => number)) {\n          return createChainableNumber(\n            validators,\n            value,\n            transform,\n            description,\n            refinements,\n            fm,\n          );\n        },\n        describe(desc: string) {\n          return createChainableNumber(\n            validators,\n            defaultValue,\n            transform,\n            desc,\n            refinements,\n            fm,\n          );\n        },\n        refine(predicate: (value: number) => boolean, message: string) {\n          const newRefinements = [\n            ...(refinements ?? []),\n            { predicate, message },\n          ];\n          return createChainableNumber(\n            [...validators, predicate],\n            defaultValue,\n            transform,\n            description,\n            newRefinements,\n            fm,\n          );\n        },\n        meta(m: import(\"./types/meta.js\").DefinitionMeta) {\n          return createChainableNumber(\n            validators,\n            defaultValue,\n            transform,\n            description,\n            refinements,\n            m,\n          );\n        },\n      };\n    };\n    return createChainableNumber([(v) => typeof v === \"number\"]);\n  },\n\n  /**\n   * Create a boolean schema type.\n   *\n   * @example\n   * ```typescript\n   * schema: {\n   *   active: t.boolean(),\n   *   verified: t.boolean().default(false),\n   * }\n   * ```\n   */\n  boolean() {\n    return createChainableType<boolean>(\n      [(v) => typeof v === \"boolean\"],\n      \"boolean\",\n    );\n  },\n\n  /**\n   * Create an array schema type.\n   * Can be used with or without element validation:\n   * - `t.array<string>()` - Type-only, no element validation\n   * - `t.array<string>().of(t.string())` - With element validation\n   */\n  array<T>() {\n    type ChainableArray = ChainableSchemaType<T[]> & {\n      of(elementType: SchemaType<T>): ChainableArray;\n      nonEmpty(): ChainableArray;\n      maxLength(n: number): ChainableArray;\n      minLength(n: number): ChainableArray;\n      meta(m: import(\"./types/meta.js\").DefinitionMeta): ChainableArray;\n      _lastFailedIndex?: number;\n    };\n\n    const createChainableArray = (\n      validators: Array<(v: T[]) => boolean>,\n      elementType?: SchemaType<T>,\n      defaultValue?: T[] | (() => T[]),\n      description?: string,\n      indexRef?: { value: number },\n      fm?: import(\"./types/meta.js\").DefinitionMeta,\n    ): ChainableArray => {\n      const chainable = createChainableType<T[]>(\n        validators,\n        \"array\",\n        defaultValue,\n        undefined,\n        description,\n        undefined,\n        fm,\n      );\n      // Use ref for storing failed index (shared with validator closure)\n      const ref = indexRef ?? { value: -1 };\n      const result: ChainableArray = {\n        ...chainable,\n        get _lastFailedIndex() {\n          return ref.value;\n        },\n        set _lastFailedIndex(v: number) {\n          ref.value = v;\n        },\n        of(et: SchemaType<T>) {\n          const newRef = { value: -1 };\n          return createChainableArray(\n            [\n              ...validators,\n              (v) => {\n                for (let i = 0; i < v.length; i++) {\n                  if (!et._validators.every((validator) => validator(v[i]))) {\n                    newRef.value = i;\n                    return false;\n                  }\n                }\n                return true;\n              },\n            ],\n            et,\n            defaultValue,\n            description,\n            newRef,\n            fm,\n          );\n        },\n        nonEmpty() {\n          return createChainableArray(\n            [...validators, (v) => v.length > 0],\n            elementType,\n            defaultValue,\n            description,\n            ref,\n            fm,\n          );\n        },\n        maxLength(n: number) {\n          return createChainableArray(\n            [...validators, (v) => v.length <= n],\n            elementType,\n            defaultValue,\n            description,\n            ref,\n            fm,\n          );\n        },\n        minLength(n: number) {\n          return createChainableArray(\n            [...validators, (v) => v.length >= n],\n            elementType,\n            defaultValue,\n            description,\n            ref,\n            fm,\n          );\n        },\n        default(value: T[] | (() => T[])) {\n          return createChainableArray(\n            validators,\n            elementType,\n            value,\n            description,\n            ref,\n            fm,\n          );\n        },\n        describe(desc: string) {\n          return createChainableArray(\n            validators,\n            elementType,\n            defaultValue,\n            desc,\n            ref,\n            fm,\n          );\n        },\n        meta(m: import(\"./types/meta.js\").DefinitionMeta) {\n          return createChainableArray(\n            validators,\n            elementType,\n            defaultValue,\n            description,\n            ref,\n            m,\n          );\n        },\n      };\n      return result;\n    };\n    return createChainableArray([(v) => Array.isArray(v)]);\n  },\n\n  /**\n   * Create an object schema type for any complex value.\n   * Can be used with or without shape validation:\n   * - `t.object<User>()` - Type-only, no property validation\n   * - `t.object<User>().shape({ name: t.string(), age: t.number() })` - With property validation\n   *\n   * For arrays, prefer `t.array<T>()` which adds `Array.isArray` validation.\n   */\n  object<T>() {\n    type ChainableObject = ChainableSchemaType<T> & {\n      shape(schema: { [K in keyof T]?: SchemaType<T[K]> }): ChainableObject;\n      nonNull(): ChainableObject;\n      hasKeys(...keys: string[]): ChainableObject;\n      meta(m: import(\"./types/meta.js\").DefinitionMeta): ChainableObject;\n    };\n\n    const createChainableObject = (\n      validators: Array<(v: T) => boolean>,\n      defaultValue?: T | (() => T),\n      description?: string,\n      fm?: import(\"./types/meta.js\").DefinitionMeta,\n    ): ChainableObject => {\n      const chainable = createChainableType<T>(\n        validators,\n        \"object\",\n        defaultValue,\n        undefined,\n        description,\n        undefined,\n        fm,\n      );\n      return {\n        ...chainable,\n        shape(shapeSchema: { [K in keyof T]?: SchemaType<T[K]> }) {\n          return createChainableObject(\n            [\n              ...validators,\n              (v) => {\n                for (const [key, schemaType] of Object.entries(shapeSchema)) {\n                  const value = (v as Record<string, unknown>)[key];\n                  const schemaT = schemaType as SchemaType<unknown>;\n                  if (\n                    schemaT &&\n                    !schemaT._validators.every((validator) => validator(value))\n                  ) {\n                    return false;\n                  }\n                }\n                return true;\n              },\n            ],\n            defaultValue,\n            description,\n            fm,\n          );\n        },\n        nonNull() {\n          return createChainableObject(\n            [...validators, (v) => v !== null && v !== undefined],\n            defaultValue,\n            description,\n            fm,\n          );\n        },\n        hasKeys(...keys: string[]) {\n          return createChainableObject(\n            [\n              ...validators,\n              (v) => keys.every((k) => k in (v as Record<string, unknown>)),\n            ],\n            defaultValue,\n            description,\n            fm,\n          );\n        },\n        default(value: T | (() => T)) {\n          return createChainableObject(validators, value, description, fm);\n        },\n        describe(desc: string) {\n          return createChainableObject(validators, defaultValue, desc, fm);\n        },\n        meta(m: import(\"./types/meta.js\").DefinitionMeta) {\n          return createChainableObject(\n            validators,\n            defaultValue,\n            description,\n            m,\n          );\n        },\n      };\n    };\n    return createChainableObject([\n      (v) => typeof v === \"object\" && v !== null && !Array.isArray(v),\n    ]);\n  },\n\n  /**\n   * Create an enum schema type for string literal unions.\n   *\n   * @example\n   * ```typescript\n   * // Define allowed values\n   * schema: { status: t.enum(\"idle\", \"loading\", \"success\", \"error\") }\n   *\n   * // Type is inferred as \"idle\" | \"loading\" | \"success\" | \"error\"\n   * ```\n   */\n  enum<T extends string>(...values: T[]) {\n    if (isDevelopment && values.length === 0) {\n      console.warn(\n        \"[Directive] t.enum() called with no values - this will reject all strings\",\n      );\n    }\n    const valueSet = new Set(values);\n    return createChainableType<T>(\n      [(v): v is T => typeof v === \"string\" && valueSet.has(v as T)],\n      `enum(${values.join(\"|\")})`,\n    );\n  },\n\n  /**\n   * Create a literal schema type for exact value matching.\n   *\n   * @example\n   * ```typescript\n   * // Exact string match\n   * schema: { type: t.literal(\"user\") }\n   *\n   * // Exact number match\n   * schema: { version: t.literal(1) }\n   *\n   * // Exact boolean\n   * schema: { enabled: t.literal(true) }\n   * ```\n   */\n  literal<T extends string | number | boolean>(value: T) {\n    return createChainableType<T>(\n      [(v): v is T => v === value],\n      `literal(${String(value)})`,\n    );\n  },\n\n  /**\n   * Create a nullable schema type (T | null).\n   *\n   * @example\n   * ```typescript\n   * // Nullable string\n   * schema: { name: t.nullable(t.string()) }\n   *\n   * // Nullable object\n   * schema: { user: t.nullable(t.object<User>()) }\n   * ```\n   */\n  nullable<T>(innerType: SchemaType<T>) {\n    const innerTypeName =\n      (innerType as ExtendedSchemaType<T>)._typeName ?? \"unknown\";\n    return createSchemaType<T | null>(\n      [\n        (v): v is T | null => {\n          if (v === null) {\n            return true;\n          }\n          return innerType._validators.every((validator) => validator(v as T));\n        },\n      ],\n      `${innerTypeName} | null`,\n    ) as SchemaType<T | null>;\n  },\n\n  /**\n   * Create an optional schema type (T | undefined).\n   *\n   * @example\n   * ```typescript\n   * // Optional string\n   * schema: { nickname: t.optional(t.string()) }\n   *\n   * // Optional number\n   * schema: { age: t.optional(t.number()) }\n   * ```\n   */\n  optional<T>(innerType: SchemaType<T>) {\n    const innerTypeName =\n      (innerType as ExtendedSchemaType<T>)._typeName ?? \"unknown\";\n    return createSchemaType<T | undefined>(\n      [\n        (v): v is T | undefined => {\n          if (v === undefined) {\n            return true;\n          }\n          return innerType._validators.every((validator) => validator(v as T));\n        },\n      ],\n      `${innerTypeName} | undefined`,\n    ) as SchemaType<T | undefined>;\n  },\n\n  /**\n   * Create a union schema type.\n   *\n   * **Two forms:**\n   * - `t.union(t.string(), t.number())` — variadic schema args; the runtime\n   *   validator checks that the value matches at least one inner schema.\n   * - `t.union<string | number | boolean>()` — generic-only form with no\n   *   schema args; the runtime validator accepts ANY value (mirrors\n   *   {@link unknown} plus generic narrowing). Use this for polymorphic\n   *   payloads where the union is too dynamic to enumerate as inner schemas\n   *   (e.g. an `UPDATE_FIELD` event whose `value` may be `string | number |\n   *   boolean | Date`).\n   *\n   * Chainable methods (`.validate`, `.transform`, `.default`, `.describe`,\n   * `.refine`, `.optional`, `.nullable`) work the same for both forms.\n   *\n   * @example\n   * ```typescript\n   * // Variadic — runtime validation against inner schemas\n   * schema: { value: t.union(t.string(), t.number()) }\n   *\n   * // Generic-only — type-only narrowing, runtime accepts any value\n   * schema: {\n   *   payload: t.union<string | number | boolean>(),\n   * }\n   *\n   * // Add a custom predicate via .validate when you still want a runtime check\n   * schema: {\n   *   strict: t.union<string | number>().validate(\n   *     (v) => typeof v === \"string\" || typeof v === \"number\",\n   *   ),\n   * }\n   * ```\n   */\n  union: unionImpl,\n\n  /**\n   * Create a record schema type for dynamic key-value maps.\n   *\n   * @example\n   * ```typescript\n   * // Record with string values\n   * schema: { metadata: t.record(t.string()) }\n   *\n   * // Record with number values\n   * schema: { scores: t.record(t.number()) }\n   * ```\n   */\n  record<V>(valueType: SchemaType<V>) {\n    const valueTypeName =\n      (valueType as ExtendedSchemaType<V>)._typeName ?? \"unknown\";\n    return createChainableType<Record<string, V>>(\n      [\n        (v): v is Record<string, V> => {\n          if (typeof v !== \"object\" || v === null || Array.isArray(v))\n            return false;\n          return Object.values(v).every((val) =>\n            valueType._validators.every((validator) => validator(val)),\n          );\n        },\n      ],\n      `Record<string, ${valueTypeName}>`,\n    );\n  },\n\n  /**\n   * Create a tuple schema type for fixed-length arrays with specific types.\n   *\n   * @example\n   * ```typescript\n   * // [string, number] tuple\n   * schema: { coord: t.tuple(t.string(), t.number()) }\n   *\n   * // [x, y, z] coordinates\n   * schema: { position: t.tuple(t.number(), t.number(), t.number()) }\n   * ```\n   */\n  tuple<T extends SchemaType<unknown>[]>(...types: T) {\n    if (isDevelopment && types.length === 0) {\n      console.warn(\n        \"[Directive] t.tuple() called with no types - this will only accept empty arrays\",\n      );\n    }\n    type TupleType = {\n      [K in keyof T]: T[K] extends SchemaType<infer U> ? U : never;\n    };\n    const typeNames = types.map(\n      (schemaType) =>\n        (schemaType as ExtendedSchemaType<unknown>)._typeName ?? \"unknown\",\n    );\n    return createChainableType<TupleType>(\n      [\n        (v): v is TupleType => {\n          if (!Array.isArray(v) || v.length !== types.length) {\n            return false;\n          }\n          return types.every((schemaType, i) =>\n            schemaType._validators.every((validator) => validator(v[i])),\n          );\n        },\n      ],\n      `[${typeNames.join(\", \")}]`,\n    );\n  },\n\n  /**\n   * Create a date schema type.\n   *\n   * @example\n   * ```typescript\n   * schema: { createdAt: t.date() }\n   * ```\n   */\n  date() {\n    return createChainableType<Date>(\n      [(v): v is Date => v instanceof Date && !Number.isNaN(v.getTime())],\n      \"Date\",\n    );\n  },\n\n  /**\n   * Create a UUID schema type.\n   *\n   * @example\n   * ```typescript\n   * schema: { id: t.uuid() }\n   * ```\n   */\n  uuid() {\n    const uuidRegex =\n      /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;\n    return createChainableType<string>(\n      [(v): v is string => typeof v === \"string\" && uuidRegex.test(v)],\n      \"uuid\",\n    );\n  },\n\n  /**\n   * Create an email schema type.\n   *\n   * @example\n   * ```typescript\n   * schema: { email: t.email() }\n   * ```\n   */\n  email() {\n    // Simple email regex - for comprehensive validation use Zod\n    const emailRegex = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/;\n    return createChainableType<string>(\n      [(v): v is string => typeof v === \"string\" && emailRegex.test(v)],\n      \"email\",\n    );\n  },\n\n  /**\n   * Create a URL schema type.\n   *\n   * @example\n   * ```typescript\n   * schema: { website: t.url() }\n   * ```\n   */\n  url() {\n    return createChainableType<string>(\n      [\n        (v): v is string => {\n          if (typeof v !== \"string\") {\n            return false;\n          }\n          try {\n            new URL(v);\n            return true;\n          } catch {\n            return false;\n          }\n        },\n      ],\n      \"url\",\n    );\n  },\n\n  /**\n   * Create a bigint schema type.\n   *\n   * @example\n   * ```typescript\n   * schema: { largeNumber: t.bigint() }\n   * ```\n   */\n  bigint() {\n    return createChainableType<bigint>(\n      [(v): v is bigint => typeof v === \"bigint\"],\n      \"bigint\",\n    );\n  },\n\n  /**\n   * Create an `any` schema type that accepts all values without validation.\n   *\n   * @example\n   * ```typescript\n   * schema: { payload: t.any() }\n   * ```\n   */\n  // biome-ignore lint/suspicious/noExplicitAny: Intentional any type for schema builder\n  any() {\n    return createChainableType<any>([], \"any\");\n  },\n\n  /**\n   * Create an `unknown` schema type that accepts all values without validation.\n   * Prefer `t.unknown()` over `t.any()` for stricter downstream type checking.\n   *\n   * @example\n   * ```typescript\n   * schema: { data: t.unknown() }\n   * ```\n   */\n  unknown() {\n    return createChainableType<unknown>([], \"unknown\");\n  },\n};\n","/**\n * Module - The declarative API for defining Directive modules\n *\n * Modules group related facts, constraints, resolvers, effects, and derivations.\n */\n\nimport isDevelopment from \"#is-development\";\nimport { BLOCKED_PROPS } from \"./tracking.js\";\nimport type {\n  CrossModuleConstraintsDef,\n  CrossModuleDeps,\n  CrossModuleDerivationsDef,\n  CrossModuleEffectsDef,\n  DefinitionMeta,\n  EffectsDef,\n  Facts,\n  ModuleDef,\n  ModuleHooks,\n  ModuleSchema,\n  TypedConstraintsDef,\n  TypedDerivationsDef,\n  TypedEventsDef,\n  TypedResolversDef,\n} from \"./types.js\";\n\n// ============================================================================\n// Module Configuration\n// ============================================================================\n\n/**\n * Module configuration with consolidated schema.\n *\n * derive and events are optional - omit them if your schema has empty derivations/events.\n */\nexport interface ModuleConfig<M extends ModuleSchema> {\n  schema: M;\n  init?: (facts: Facts<M[\"facts\"]>) => void;\n  derive?: TypedDerivationsDef<M>;\n  events?: TypedEventsDef<M>;\n  effects?: EffectsDef<M[\"facts\"]>;\n  constraints?: TypedConstraintsDef<M>;\n  resolvers?: TypedResolversDef<M>;\n  hooks?: ModuleHooks<M>;\n  /** Optional metadata for debugging and devtools (never read on hot path). */\n  meta?: DefinitionMeta;\n  /** History configuration — controls which events create snapshots for undo/redo. */\n  history?: {\n    /** Events that create history snapshots. Omit to snapshot all events. */\n    snapshotEvents?: Array<\n      keyof (M[\"events\"] extends Record<string, unknown>\n        ? M[\"events\"]\n        : Record<string, never>) &\n        string\n    >;\n  };\n}\n\n/**\n * Module configuration with cross-module dependencies for type-safe access\n * to other modules' facts in effects and constraints.\n *\n * When crossModuleDeps is provided:\n * - Own module facts: `facts.self.*`\n * - Cross-module facts: `facts.{dep}.*`\n *\n * @example\n * ```typescript\n * import { authSchema } from './auth';\n * import { dataSchema } from './data';\n *\n * const uiModule = createModule(\"ui\", {\n *   schema: uiSchema,\n *   crossModuleDeps: { auth: authSchema, data: dataSchema },\n *   effects: {\n *     onAuthChange: {\n *       run: (facts) => {\n *         facts.self.notifications   // ✅ own module via \"self\"\n *         facts.auth.isAuthenticated // ✅ cross-module (namespaced)\n *         facts.data.users           // ✅ cross-module (namespaced)\n *       }\n *     }\n *   },\n *   constraints: {\n *     fetchWhenAuth: {\n *       when: (facts) => facts.auth.isAuthenticated && facts.self.users.length === 0,\n *       require: { type: \"FETCH_USERS\" },\n *     }\n *   }\n * });\n * ```\n */\nexport interface ModuleConfigWithDeps<\n  M extends ModuleSchema,\n  Deps extends CrossModuleDeps,\n> {\n  schema: M;\n  /**\n   * Cross-module dependencies for type-safe access in derive/effects/constraints.\n   *\n   * **Access patterns by context:**\n   * - `derive`, `effects`, `constraints`: Use `facts.self.*` for own module, `facts.{dep}.*` for cross-module\n   * - `init`, `events`, `resolvers`: Use flat access (`facts.myFact`) - no cross-module access\n   *\n   * This separation ensures initialization and event handling stay scoped to own module,\n   * while observers (derive/effects/constraints) can see across modules.\n   *\n   * @example\n   * ```typescript\n   * crossModuleDeps: { auth: authSchema },\n   * init: (facts) => { facts.users = []; },              // flat access\n   * derive: { count: (facts) => facts.self.users.length }, // facts.self.*\n   * effects: { log: { run: (facts) => console.log(facts.auth.token) } }, // facts.{dep}.*\n   * ```\n   */\n  crossModuleDeps: Deps;\n  /** Initialize module facts. Uses flat access (`facts.myFact`) to ensure modules initialize independently. */\n  init?: (facts: Facts<M[\"facts\"]>) => void;\n  /** Derivations with cross-module facts access (`facts.self.*` + `facts.{dep}.*`) */\n  derive?: CrossModuleDerivationsDef<M, Deps>;\n  /** Event handlers. Uses flat access (`facts.myFact`) to keep mutations scoped to own module. */\n  events?: TypedEventsDef<M>;\n  /** Effects with cross-module facts access (`facts.self.*` + `facts.{dep}.*`) */\n  effects?: CrossModuleEffectsDef<M, Deps>;\n  /** Constraints with cross-module facts access (`facts.self.*` + `facts.{dep}.*`) */\n  constraints?: CrossModuleConstraintsDef<M, Deps>;\n  /** Resolvers. Uses flat access (`ctx.facts.myFact`) to keep async mutations scoped to own module. */\n  resolvers?: TypedResolversDef<M>;\n  hooks?: ModuleHooks<M>;\n  /** Optional metadata for debugging and devtools (never read on hot path). */\n  meta?: DefinitionMeta;\n  /** History configuration — controls which events create snapshots for undo/redo. */\n  history?: {\n    /** Events that create history snapshots. Omit to snapshot all events. */\n    snapshotEvents?: Array<\n      keyof (M[\"events\"] extends Record<string, unknown>\n        ? M[\"events\"]\n        : Record<string, never>) &\n        string\n    >;\n  };\n}\n\n// ============================================================================\n// Module Validation Helpers (dev-mode only)\n// ============================================================================\n\n/** Validate module ID follows naming conventions */\nfunction validateModuleId(id: string): void {\n  if (!id || typeof id !== \"string\") {\n    console.warn(\"[Directive] Module ID must be a non-empty string\");\n\n    return;\n  }\n  if (!/^(__[a-z][a-z0-9_-]*|[a-z][a-z0-9-]*)$/i.test(id)) {\n    console.warn(\n      `[Directive] Module ID \"${id}\" should follow kebab-case convention (e.g., \"my-module\")`,\n    );\n  }\n}\n\n/** Warn when keys in `implKeys` are missing from `schemaKeys` and vice versa */\nfunction validateKeyAlignment(\n  implKeys: Set<string>,\n  schemaKeys: Set<string>,\n  implLabel: string,\n  schemaLabel: string,\n  missingImplMessage: string,\n): void {\n  for (const key of implKeys) {\n    if (!schemaKeys.has(key)) {\n      console.warn(\n        `[Directive] ${implLabel} \"${key}\" not declared in ${schemaLabel}`,\n      );\n    }\n  }\n  for (const key of schemaKeys) {\n    if (!implKeys.has(key)) {\n      console.warn(\n        `[Directive] ${schemaLabel}[\"${key}\"] ${missingImplMessage}`,\n      );\n    }\n  }\n}\n\n/** Validate history.snapshotEvents reference valid event names */\nfunction validateSnapshotEvents(\n  snapshotEvents: string[],\n  schemaEvents: Record<string, unknown>,\n): void {\n  if (snapshotEvents.length === 0) {\n    console.warn(\n      \"[Directive] history.snapshotEvents is an empty array — no events will create history snapshots. \" +\n        \"Omit history.snapshotEvents entirely to snapshot all events, or list specific events.\",\n    );\n  }\n  const schemaEventKeys = new Set(Object.keys(schemaEvents));\n  for (const eventName of snapshotEvents) {\n    if (!schemaEventKeys.has(eventName)) {\n      console.warn(\n        `[Directive] history.snapshotEvents entry \"${eventName}\" not declared in schema.events. ` +\n          `Available events: ${[...schemaEventKeys].join(\", \") || \"(none)\"}`,\n      );\n    }\n  }\n}\n\n/** Validate resolvers reference valid requirement types */\nfunction validateResolverRequirements(\n  resolvers: Record<string, unknown>,\n  requirements: Record<string, unknown>,\n): void {\n  const requirementTypes = new Set(Object.keys(requirements));\n  for (const [resolverName, resolver] of Object.entries(resolvers)) {\n    const resolverDef = resolver as { requirement?: string };\n    if (\n      typeof resolverDef.requirement === \"string\" &&\n      !requirementTypes.has(resolverDef.requirement)\n    ) {\n      console.warn(\n        `[Directive] Resolver \"${resolverName}\" references unknown requirement type \"${resolverDef.requirement}\". ` +\n          `Available types: ${[...requirementTypes].join(\", \") || \"(none)\"}`,\n      );\n    }\n  }\n}\n\n/**\n * Throw when a module's fact key conflicts with a reserved namespace pivot\n * or evaluation alias used by the data-form predicate runtime. Two classes:\n *\n * - The cross-module namespace pivots — `self` and every declared\n *   `crossModuleDeps` namespace. A fact named after a pivot would make\n *   `prefixPredicateSpec` mis-route the pivot's nested predicate against\n *   the pivot's namespace instead of treating it as a literal fact lookup.\n * - The evaluation aliases `prev` and `current` — reserved for the\n *   previous/live snapshot scopes (`$changed`, clobber baselines). A fact\n *   with one of these names would shadow the alias in those scopes.\n *\n * Thrown unconditionally — this is a structural integrity check, not a dev\n * convenience. Production users running into this would otherwise see silent\n * mis-routing.\n */\nfunction validatePivotNameConflicts<M extends ModuleSchema>(\n  id: string,\n  config: ModuleConfig<M> | ModuleConfigWithDeps<M, CrossModuleDeps>,\n): void {\n  const facts = (config.schema?.facts ?? {}) as Record<string, unknown>;\n  const factKeys = Object.keys(facts);\n  if (factKeys.length === 0) {\n    return;\n  }\n  const reserved = new Set<string>([\"self\", \"prev\", \"current\"]);\n  const deps =\n    \"crossModuleDeps\" in config && config.crossModuleDeps\n      ? Object.keys(\n          config.crossModuleDeps as Record<string, unknown>,\n        )\n      : [];\n  for (const depName of deps) {\n    reserved.add(depName);\n  }\n  for (const key of factKeys) {\n    if (reserved.has(key)) {\n      throw new Error(\n        `[Directive] module '${id}': fact key '${key}' conflicts with a reserved namespace pivot or evaluation alias (self / prev / current / a crossModuleDep namespace). Three fixes:\\n` +\n          `  1. Rename the fact (e.g. ${key}_)\\n` +\n          `  2. Remove '${key}' from this module's crossModuleDeps if it's not actually needed\\n` +\n          `  3. Move the fact under a wrapping namespace (t.object({ inner: ... }))`,\n      );\n    }\n  }\n}\n\n/**\n * Reject constraint `owns` entries that name a reserved property — a\n * `BLOCKED_PROPS` key (`__proto__`, `constructor`, `prototype`) or a\n * `$`-prefixed key. Such names can never be owned fact slots, so the\n * clobber-detection binding would silently no-op. A structural integrity\n * check — runs unconditionally, not just in dev.\n */\nfunction validateOwnsKeys<M extends ModuleSchema>(\n  id: string,\n  config: ModuleConfig<M> | ModuleConfigWithDeps<M, CrossModuleDeps>,\n): void {\n  const constraints = config.constraints as\n    | Record<string, { owns?: readonly string[] }>\n    | undefined;\n  if (!constraints) {\n    return;\n  }\n  for (const [cid, constraint] of Object.entries(constraints)) {\n    const owns = constraint?.owns;\n    if (!owns) {\n      continue;\n    }\n    for (const key of owns) {\n      if (BLOCKED_PROPS.has(key) || key.startsWith(\"$\")) {\n        throw new Error(\n          `[Directive] module '${id}' constraint '${cid}': owns key '${key}' is reserved (BLOCKED_PROPS or $-prefixed)`,\n        );\n      }\n    }\n  }\n}\n\n/** Run all dev-mode validations for a module config */\nfunction validateModuleConfig<M extends ModuleSchema>(\n  id: string,\n  config: ModuleConfig<M> | ModuleConfigWithDeps<M, CrossModuleDeps>,\n): void {\n  validateModuleId(id);\n\n  if (!config.schema) {\n    console.warn(\"[Directive] Module schema is required\");\n  } else if (!config.schema.facts) {\n    console.warn(\"[Directive] Module schema.facts is required\");\n  }\n\n  validateKeyAlignment(\n    new Set(Object.keys(config.derive ?? {})),\n    new Set(Object.keys(config.schema?.derivations ?? {})),\n    \"Derivation\",\n    \"schema.derivations\",\n    \"has no matching implementation in derive\",\n  );\n\n  validateKeyAlignment(\n    new Set(Object.keys(config.events ?? {})),\n    new Set(Object.keys(config.schema?.events ?? {})),\n    \"Event\",\n    \"schema.events\",\n    \"has no matching handler in events\",\n  );\n\n  if (config.history?.snapshotEvents) {\n    validateSnapshotEvents(\n      config.history.snapshotEvents as string[],\n      config.schema?.events ?? {},\n    );\n  }\n\n  if (config.resolvers && config.schema?.requirements) {\n    validateResolverRequirements(\n      config.resolvers as Record<string, unknown>,\n      config.schema.requirements,\n    );\n  }\n}\n\n// ============================================================================\n// createModule\n// ============================================================================\n\n/**\n * Create a module definition with full type inference.\n *\n * The consolidated schema provides:\n * - Derivation composition (`derived.otherDerivation` is typed)\n * - Event dispatch (`system.dispatch({ type: \"...\" })` has autocomplete)\n * - Resolver requirements (`req.payload` is typed based on requirement type)\n *\n * @param id - Unique module identifier (kebab-case recommended)\n * @param config - Module configuration including schema, init, derive, constraints, resolvers, etc.\n * @returns A frozen module definition ready for use with `createSystem`\n *\n * @example\n * ```ts\n * const trafficLight = createModule(\"traffic-light\", {\n *   schema: {\n *     facts: {\n *       phase: t.string<\"red\" | \"green\" | \"yellow\">(),\n *       elapsed: t.number(),\n *     },\n *     derivations: {\n *       isRed: t.boolean(),\n *       timeRemaining: t.number(),\n *     },\n *     events: {\n *       tick: {},\n *       setPhase: { phase: t.string<\"red\" | \"green\" | \"yellow\">() },\n *     },\n *     requirements: {\n *       TRANSITION: { to: t.string<\"red\" | \"green\" | \"yellow\">() },\n *     },\n *   },\n *   init: (facts) => {\n *     facts.phase = \"red\";\n *     facts.elapsed = 0;\n *   },\n *   derive: {\n *     isRed: (facts) => facts.phase === \"red\",\n *     timeRemaining: (facts, derived) => {\n *       // derived.isRed is typed as boolean!\n *       return derived.isRed ? 30 - facts.elapsed : 0;\n *     },\n *   },\n *   events: {\n *     tick: (facts) => { facts.elapsed += 1; },\n *     setPhase: (facts, { phase }) => { facts.phase = phase; }, // phase is typed!\n *   },\n *   constraints: {\n *     shouldTransition: {\n *       when: (facts) => facts.phase === \"red\" && facts.elapsed > 30,\n *       require: { type: \"TRANSITION\", to: \"green\" },\n *     },\n *   },\n *   resolvers: {\n *     transition: {\n *       requirement: \"TRANSITION\",\n *       resolve: async (req, ctx) => {\n *         ctx.facts.phase = req.to; // req.to is typed!\n *         ctx.facts.elapsed = 0;\n *       },\n *     },\n *   },\n *   hooks: {\n *     // Optional: observe resolver failures owned by this module.\n *     // Fires AFTER retries are exhausted and the engine has handled the error\n *     // (error boundary, plugin emit, retry decision). Use it as a side-channel\n *     // observer for module-local logging/telemetry — not for recovery.\n *     onResolverError: (error, requirement, ctx) => {\n *       console.warn(`[traffic-light] resolver failed for ${requirement.type}`, error);\n *     },\n *   },\n * });\n * ```\n *\n * @example With cross-module dependencies\n * ```ts\n * import { authSchema } from './auth';\n *\n * const dataModule = createModule(\"data\", {\n *   schema: dataSchema,\n *   crossModuleDeps: { auth: authSchema },\n *   constraints: {\n *     fetchWhenAuth: {\n *       when: (facts) => {\n *         // facts.self.* for own module, facts.auth.* for cross-module\n *         return facts.auth.isAuthenticated && facts.self.users.length === 0;\n *       },\n *       require: { type: \"FETCH_USERS\" },\n *     },\n *   },\n *   derive: {\n *     canFetch: (facts) => facts.auth.isAuthenticated && facts.self.users.length === 0,\n *   },\n * });\n * ```\n *\n * @public\n */\n// Overload 1: With crossModuleDeps\nexport function createModule<\n  const M extends ModuleSchema,\n  const Deps extends CrossModuleDeps,\n>(id: string, config: ModuleConfigWithDeps<M, Deps>): ModuleDef<M>;\n\n// Overload 2: Without crossModuleDeps (original signature)\nexport function createModule<const M extends ModuleSchema>(\n  id: string,\n  config: ModuleConfig<M>,\n): ModuleDef<M>;\n\n// Overload 3: Union (used by createModuleFactory)\nexport function createModule<const M extends ModuleSchema>(\n  id: string,\n  config: ModuleConfigWithDeps<M, CrossModuleDeps> | ModuleConfig<M>,\n): ModuleDef<M>;\n\n/** @internal Implementation overload — see public overloads above. */\nexport function createModule<const M extends ModuleSchema>(\n  id: string,\n  config: ModuleConfig<M> | ModuleConfigWithDeps<M, CrossModuleDeps>,\n): ModuleDef<M> {\n  // Pivot-name conflicts are a structural integrity check, not a dev\n  // convenience — run unconditionally.\n  validatePivotNameConflicts(id, config);\n\n  // Reserved `owns` keys would silently disable clobber-detection — a\n  // structural integrity check, run unconditionally.\n  validateOwnsKeys(id, config);\n\n  if (isDevelopment) {\n    validateModuleConfig(id, config);\n  }\n\n  // Extract crossModuleDeps if present (for runtime proxy creation)\n  const crossModuleDeps =\n    \"crossModuleDeps\" in config ? config.crossModuleDeps : undefined;\n\n  return {\n    id,\n    schema: config.schema,\n    init: config.init,\n    // Cast to TypedDerivationsDef for ModuleDef compatibility (runtime handles both types)\n    derive: (config.derive ?? {}) as TypedDerivationsDef<M>,\n    events: config.events ?? ({} as TypedEventsDef<M>),\n    effects: config.effects as EffectsDef<M[\"facts\"]> | undefined,\n    constraints: config.constraints as TypedConstraintsDef<M> | undefined,\n    resolvers: config.resolvers,\n    hooks: config.hooks,\n    meta: config.meta,\n    history: config.history,\n    // Store crossModuleDeps for runtime proxy creation\n    crossModuleDeps: crossModuleDeps as CrossModuleDeps | undefined,\n  };\n}\n\n/**\n * Create a module factory that produces named instances from a single definition.\n * Useful for multi-instance UIs (tabs, panels, multi-tenant) where you need\n * isolated state from the same schema.\n *\n * @param config - Module configuration (same shape as `createModule` minus the `id`)\n * @returns A factory function that accepts a name and returns a `ModuleDef`\n *\n * @example\n * ```typescript\n * const chatRoom = createModuleFactory({\n *   schema: {\n *     facts: { messages: t.array<string>(), users: t.array<string>() },\n *     derivations: { count: t.number() },\n *   },\n *   init: (facts) => { facts.messages = []; facts.users = []; },\n *   derive: { count: (facts) => facts.messages.length },\n * });\n *\n * const system = createSystem({\n *   modules: {\n *     lobby: chatRoom(\"lobby\"),\n *     support: chatRoom(\"support\"),\n *   },\n * });\n * ```\n *\n * @public\n */\nexport function createModuleFactory<const M extends ModuleSchema>(\n  config: ModuleConfig<M>,\n): (name: string) => ModuleDef<M>;\nexport function createModuleFactory<\n  const M extends ModuleSchema,\n  const Deps extends CrossModuleDeps,\n>(config: ModuleConfigWithDeps<M, Deps>): (name: string) => ModuleDef<M>;\n/** @internal Implementation overload — see public overloads above. */\nexport function createModuleFactory<const M extends ModuleSchema>(\n  config: ModuleConfig<M> | ModuleConfigWithDeps<M, CrossModuleDeps>,\n): (name: string) => ModuleDef<M> {\n  // Pass config directly — createModule's implementation overload handles both types.\n  // Do NOT cast to ModuleConfig<M> which would strip crossModuleDeps.\n  return (name: string) => createModule(name, config);\n}\n","/**\n * Requirement Status Utilities\n *\n * Provides reactive tracking of requirement status for UI feedback.\n */\n\nimport type { Plugin, RequirementWithId } from \"../core/types.js\";\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/** Status of a requirement type */\nexport interface RequirementTypeStatus {\n  /** Number of pending (unmet) requirements of this type */\n  pending: number;\n  /** Number of inflight (being resolved) requirements of this type */\n  inflight: number;\n  /** Number of failed requirements of this type */\n  failed: number;\n  /** Whether any requirements of this type are loading (pending or inflight) */\n  isLoading: boolean;\n  /** Whether any requirements of this type have failed */\n  hasError: boolean;\n  /** Last error for this type (if any) */\n  lastError: Error | null;\n}\n\n/** Status tracking state */\ninterface StatusState {\n  pending: Map<string, Set<string>>; // type -> set of requirement IDs\n  inflight: Map<string, Set<string>>; // type -> set of requirement IDs\n  failed: Map<string, Set<string>>; // type -> set of requirement IDs\n  errors: Map<string, Error>; // type -> last error\n  listeners: Set<() => void>;\n}\n\n// ============================================================================\n// Requirement Status Plugin\n// ============================================================================\n\n/**\n * Create a plugin that tracks requirement status for reactive UI updates.\n *\n * @example\n * ```typescript\n * import { createRequirementStatusPlugin } from '@directive-run/core';\n *\n * const statusPlugin = createRequirementStatusPlugin();\n *\n * const system = createSystem({\n *   modules: [myModule],\n *   plugins: [statusPlugin.plugin],\n * });\n *\n * // Get status for a requirement type\n * const status = statusPlugin.getStatus(\"FETCH_USER\");\n * console.log(status.isLoading, status.hasError);\n *\n * // Subscribe to status changes\n * const unsubscribe = statusPlugin.subscribe(() => {\n *   console.log(\"Status changed:\", statusPlugin.getStatus(\"FETCH_USER\"));\n * });\n * ```\n */\nexport function createRequirementStatusPlugin(): {\n  plugin: Plugin<never>;\n  getStatus: (type: string) => RequirementTypeStatus;\n  getAllStatus: () => Map<string, RequirementTypeStatus>;\n  subscribe: (listener: () => void) => () => void;\n  reset: () => void;\n} {\n  const state: StatusState = {\n    pending: new Map(),\n    inflight: new Map(),\n    failed: new Map(),\n    errors: new Map(),\n    listeners: new Set(),\n  };\n\n  /** Notify all listeners */\n  function notify(): void {\n    for (const listener of state.listeners) {\n      listener();\n    }\n  }\n\n  /** Get or create a set for a type in a map */\n  function getOrCreateSet(\n    map: Map<string, Set<string>>,\n    type: string,\n  ): Set<string> {\n    let set = map.get(type);\n    if (!set) {\n      set = new Set();\n      map.set(type, set);\n    }\n    return set;\n  }\n\n  /** Get status for a requirement type */\n  function getStatus(type: string): RequirementTypeStatus {\n    const pendingSet = state.pending.get(type) ?? new Set();\n    const inflightSet = state.inflight.get(type) ?? new Set();\n    const failedSet = state.failed.get(type) ?? new Set();\n    const lastError = state.errors.get(type) ?? null;\n\n    return {\n      pending: pendingSet.size,\n      inflight: inflightSet.size,\n      failed: failedSet.size,\n      isLoading: pendingSet.size > 0 || inflightSet.size > 0,\n      hasError: failedSet.size > 0,\n      lastError,\n    };\n  }\n\n  /** Get status for all tracked types */\n  function getAllStatus(): Map<string, RequirementTypeStatus> {\n    const allTypes = new Set([\n      ...state.pending.keys(),\n      ...state.inflight.keys(),\n      ...state.failed.keys(),\n    ]);\n\n    const result = new Map<string, RequirementTypeStatus>();\n    for (const type of allTypes) {\n      result.set(type, getStatus(type));\n    }\n    return result;\n  }\n\n  /** Subscribe to status changes */\n  function subscribe(listener: () => void): () => void {\n    state.listeners.add(listener);\n    return () => state.listeners.delete(listener);\n  }\n\n  /** Reset all status */\n  function reset(): void {\n    state.pending.clear();\n    state.inflight.clear();\n    state.failed.clear();\n    state.errors.clear();\n    notify();\n  }\n\n  const plugin: Plugin<never> = {\n    name: \"requirement-status\",\n\n    onRequirementCreated(req: RequirementWithId) {\n      const type = req.requirement.type;\n      getOrCreateSet(state.pending, type).add(req.id);\n      // Clear from failed when a new requirement is created\n      state.failed.get(type)?.delete(req.id);\n      notify();\n    },\n\n    onResolverStart(_resolver: string, req: RequirementWithId) {\n      const type = req.requirement.type;\n      // Move from pending to inflight\n      state.pending.get(type)?.delete(req.id);\n      getOrCreateSet(state.inflight, type).add(req.id);\n      notify();\n    },\n\n    onResolverComplete(_resolver: string, req: RequirementWithId) {\n      const type = req.requirement.type;\n      // Remove from inflight\n      state.inflight.get(type)?.delete(req.id);\n      state.pending.get(type)?.delete(req.id);\n      notify();\n    },\n\n    onResolverError(_resolver: string, req: RequirementWithId, error: unknown) {\n      const type = req.requirement.type;\n      // Move from inflight to failed\n      state.inflight.get(type)?.delete(req.id);\n      getOrCreateSet(state.failed, type).add(req.id);\n      state.errors.set(\n        type,\n        error instanceof Error ? error : new Error(String(error)),\n      );\n      notify();\n    },\n\n    onResolverCancel(_resolver: string, req: RequirementWithId) {\n      const type = req.requirement.type;\n      // Remove from all tracking\n      state.pending.get(type)?.delete(req.id);\n      state.inflight.get(type)?.delete(req.id);\n      notify();\n    },\n\n    onRequirementMet(req: RequirementWithId) {\n      const type = req.requirement.type;\n      // Clean up when requirement is met\n      state.pending.get(type)?.delete(req.id);\n      state.inflight.get(type)?.delete(req.id);\n      notify();\n    },\n  };\n\n  return {\n    plugin,\n    getStatus,\n    getAllStatus,\n    subscribe,\n    reset,\n  };\n}\n\n// ============================================================================\n// React Hook Helper (for use with React adapter)\n// ============================================================================\n\n/**\n * Create a hook factory for requirement status.\n * This is designed to be used with React's useSyncExternalStore.\n *\n * @example\n * ```typescript\n * import { useSyncExternalStore } from 'react';\n * import { createRequirementStatusPlugin, createStatusHook } from '@directive-run/core';\n *\n * const statusPlugin = createRequirementStatusPlugin();\n * const useRequirementStatus = createStatusHook(statusPlugin);\n *\n * function MyComponent() {\n *   const status = useRequirementStatus(\"FETCH_USER\");\n *   if (status.isLoading) return <Spinner />;\n *   if (status.hasError) return <Error error={status.lastError} />;\n *   return <Content />;\n * }\n * ```\n */\nexport function createStatusHook(\n  statusPlugin: ReturnType<typeof createRequirementStatusPlugin>,\n): (type: string) => RequirementTypeStatus {\n  // This returns a function that can be used with useSyncExternalStore\n  // The actual hook implementation would be in the React adapter\n  return (type: string) => statusPlugin.getStatus(type);\n}\n","/**\n * System with Status Plugin Helper\n *\n * Convenience function for creating a system with status tracking enabled.\n */\n\nimport { createSystem } from \"../core/system.js\";\nimport type {\n  ErrorBoundaryConfig,\n  ModuleDef,\n  ModuleSchema,\n  Plugin,\n  SingleModuleSystem,\n  TraceOption,\n} from \"../core/types.js\";\nimport { createRequirementStatusPlugin } from \"./requirement-status.js\";\n\n/** Options for createSystemWithStatus */\nexport interface CreateSystemWithStatusOptions<M extends ModuleSchema> {\n  /** The module to use for the system */\n  module: ModuleDef<M>;\n  /** Additional plugins to include alongside the status plugin */\n  // biome-ignore lint/suspicious/noExplicitAny: Plugin generic contravariance issues\n  plugins?: Plugin<any>[];\n  /** Trace: per-run reconciliation changelog */\n  trace?: TraceOption;\n  /** Error boundary configuration */\n  errorBoundary?: ErrorBoundaryConfig;\n  /** Tick interval in milliseconds */\n  tickMs?: number;\n  /** Enable zero-config mode */\n  zeroConfig?: boolean;\n  /** Initial facts to set on the system */\n  // biome-ignore lint/suspicious/noExplicitAny: Facts type varies by module\n  initialFacts?: Record<string, any>;\n}\n\n/** Return type for createSystemWithStatus */\nexport interface SystemWithStatus<M extends ModuleSchema> {\n  /**\n   * The Directive system instance.\n   * This is a SingleModuleSystem - use system.facts, system.dispatch(), etc.\n   */\n  system: SingleModuleSystem<M>;\n  /** The status plugin for use with useRequirementStatus hooks */\n  statusPlugin: ReturnType<typeof createRequirementStatusPlugin>;\n}\n\n/**\n * Create a Directive system with a status plugin pre-configured.\n *\n * This is a convenience wrapper around `createSystem` and `createRequirementStatusPlugin`\n * that handles the wiring automatically. The status plugin is added to the system's\n * plugins array so it receives lifecycle events.\n *\n * @param options - System configuration options\n * @returns An object containing both the system and the statusPlugin\n *\n * @example\n * ```tsx\n * import { createSystemWithStatus } from '@directive-run/core';\n * import { useRequirementStatus, useFact } from '@directive-run/react';\n *\n * // Simple setup - no provider needed\n * const { system, statusPlugin } = createSystemWithStatus({\n *   module: myModule,\n * });\n * system.start();\n *\n * function App() {\n *   const data = useFact(system, \"data\");\n *   return <LoadingIndicator />;\n * }\n *\n * function LoadingIndicator() {\n *   const status = useRequirementStatus(statusPlugin, \"FETCH_DATA\");\n *   if (status.isLoading) return <Spinner />;\n *   if (status.hasError) return <Error message={status.lastError?.message} />;\n *   return <Content />;\n * }\n * ```\n */\nexport function createSystemWithStatus<M extends ModuleSchema>(\n  options: CreateSystemWithStatusOptions<M>,\n): SystemWithStatus<M> {\n  // Create the status plugin\n  const statusPlugin = createRequirementStatusPlugin();\n\n  // Add the plugin to the options\n  const existingPlugins = options.plugins ?? [];\n\n  // Create the system with the status plugin included\n  // Use type assertion to bypass overload resolution issues\n  // biome-ignore lint/suspicious/noExplicitAny: Required for overload compatibility\n  const allPlugins = [...existingPlugins, statusPlugin.plugin] as Plugin<any>[];\n  // biome-ignore lint/suspicious/noExplicitAny: Required for overload compatibility\n  const system = createSystem({\n    module: options.module,\n    plugins: allPlugins,\n    trace: options.trace,\n    errorBoundary: options.errorBoundary,\n    tickMs: options.tickMs,\n    zeroConfig: options.zeroConfig,\n    initialFacts: options.initialFacts,\n    // biome-ignore lint/suspicious/noExplicitAny: Required for overload compatibility\n  } as any);\n\n  return {\n    // The system returned by createSystem with a single module is a SingleModuleSystem\n    system: system as SingleModuleSystem<M>,\n    statusPlugin,\n  };\n}\n","/**\n * SignalClock — injectable clock source for declarative timers (RFC 0001).\n *\n * The clock interface decouples Directive's timer primitives from any\n * single time source. Production uses `realClock()`. Tests use\n * `virtualClock()` which advances synchronously via `clock.advanceBy()`.\n * Replay / dehydrate scenarios use a clock seeded from the recorded\n * stream.\n *\n * Auto-detection: `defaultClock()` returns `virtualClock()` when running\n * under Vitest (process.env.VITEST === 'true'), otherwise `realClock()`.\n * Consumers can pass an explicit clock to `createSystem({ clock })` to\n * override.\n *\n * @see ../../docs/rfcs/0001-t-timer.md\n */\n\n/**\n * Stable interface for any time source.\n */\nexport interface SignalClock {\n  /** Current time, in milliseconds since the Unix epoch. */\n  now(): number;\n  /**\n   * Schedule a callback to fire after `ms` milliseconds. Returns a\n   * cancellation function. Implementations may queue callbacks or fire\n   * them on a tick boundary; the only contract is \"fires no earlier\n   * than `ms` from now.\"\n   */\n  setTimeout(cb: () => void, ms: number): () => void;\n  /**\n   * (Test-only.) Synchronously advance the clock by `ms` milliseconds,\n   * firing all scheduled callbacks whose deadlines fall within the\n   * advanced window. Real clocks throw if called.\n   */\n  advanceBy?(ms: number): void;\n}\n\n/**\n * Production clock — wraps `Date.now()` and `globalThis.setTimeout`.\n * No mocking, no virtualization.\n */\nexport function realClock(): SignalClock {\n  return {\n    now: () => Date.now(),\n    setTimeout: (cb, ms) => {\n      const handle = globalThis.setTimeout(cb, ms);\n      return () => globalThis.clearTimeout(handle);\n    },\n  };\n}\n\n/**\n * Virtual clock — advances only when `advanceBy(ms)` is called. All\n * scheduled callbacks fire synchronously in order of their deadlines.\n *\n * Two scheduled callbacks at the same deadline fire in registration order.\n * Cancellation is O(1).\n */\nexport function virtualClock(initialMs = 0): SignalClock {\n  let nowMs = initialMs;\n  let nextId = 0;\n  interface Scheduled {\n    id: number;\n    deadlineMs: number;\n    cb: () => void;\n    canceled: boolean;\n  }\n  const queue: Scheduled[] = [];\n\n  return {\n    now: () => nowMs,\n    setTimeout: (cb, ms) => {\n      const entry: Scheduled = {\n        id: nextId++,\n        deadlineMs: nowMs + ms,\n        cb,\n        canceled: false,\n      };\n      queue.push(entry);\n      return () => {\n        entry.canceled = true;\n      };\n    },\n    advanceBy: (ms) => {\n      const targetMs = nowMs + ms;\n      // Fire all callbacks whose deadlines fall in [nowMs, targetMs].\n      // Sort live entries by deadline + registration order so ties\n      // resolve deterministically.\n      while (true) {\n        const ready = queue\n          .filter((e) => !e.canceled && e.deadlineMs <= targetMs)\n          .sort((a, b) =>\n            a.deadlineMs !== b.deadlineMs\n              ? a.deadlineMs - b.deadlineMs\n              : a.id - b.id,\n          );\n        if (ready.length === 0) break;\n        const next = ready[0]!;\n        // Advance \"now\" monotonically — never let a callback that\n        // schedules another callback in the past pull `nowMs`\n        // backward. Without this clamp, `setTimeout(cb2, -5)` from\n        // inside a callback would make `clock.now()` return a smaller\n        // value mid-advance, breaking elapsedMs (negative results)\n        // and replay determinism. (R1 sec C3.)\n        nowMs = Math.max(nowMs, next.deadlineMs);\n        next.canceled = true;\n        next.cb();\n      }\n      // Final advance — even if no callbacks fired in [nowMs, targetMs],\n      // wall clock still moves forward.\n      nowMs = Math.max(nowMs, targetMs);\n    },\n  };\n}\n\n/**\n * Returns `realClock()` always.\n *\n * Earlier drafts auto-detected vitest (`process.env.VITEST === 'true'`)\n * and returned a `virtualClock()` in that environment. AE review\n * flagged this as a footgun: tests that legitimately need real time\n * (sleep-based debounce checks, real-`setTimeout`-bound integration\n * fixtures) silently received a virtual clock that never advanced\n * unless the test author called `advanceBy()`, producing apparent\n * deadlocks indistinguishable from genuine bugs. Auto-detection is\n * therefore opt-in.\n *\n * Use {@link virtualClock} explicitly in tests:\n *\n * ```ts\n * const clock = virtualClock(0);\n * const sys = createSystem({ module, clock });\n * clock.advanceBy(1_000);\n * ```\n */\nexport function defaultClock(): SignalClock {\n  return realClock();\n}\n","/**\n * Timer fact — a runtime container that advances over time on a\n * SignalClock (RFC 0001 v0.1).\n *\n * Produced by `createTimerFact(clock, opts)`. Holds the durable state\n * (startedAtMs, pausedDurationMs, status) and exposes a control surface\n * (start, pause, resume, reset) plus reactive reads (elapsedMs,\n * remainingMs, status).\n *\n * v0.1 SCOPE: timer is a \"thick fact\" — a single object you store in a\n * regular Directive fact (e.g. `t.object<TimerFactState>()`). The\n * engine doesn't auto-tick it; the consumer is responsible for calling\n * `timer.tick()` when they want elapsedMs / remainingMs to update.\n * Typical wiring: a setInterval in the consumer that calls `timer.tick()`\n * and dispatches an event when status changes.\n *\n * v0.2 (deferred): true `t.timer({ms})` schema integration where the\n * engine subscribes to the clock and writes the fact deltas itself,\n * eliminating the consumer-side tick wiring.\n *\n * @see ../../docs/rfcs/0001-t-timer.md\n */\n\n// SignalClock is the canonical time source for timer ops; consumers\n// pass `clock.now()` into the helpers below. Re-exported by index.ts\n// alongside this module so they can `import { realClock, timerOps,\n// initialTimerState } from \"@directive-run/core\"` together.\n\n/**\n * Persistent timer state — JSON-roundtrippable, suitable for storing\n * inside a Directive fact.\n */\nexport interface TimerFactState {\n  /** Unix-ms when the timer last started or resumed. null = not running. */\n  startedAtMs: number | null;\n  /** Total ms accumulated while paused. */\n  pausedDurationMs: number;\n  /** ms when the timer was paused, if currently paused. null otherwise. */\n  pausedAtMs: number | null;\n  /**\n   * - 'idle': not yet started, or reset.\n   * - 'running': currently counting.\n   * - 'paused': paused; pausedAtMs is set.\n   * - 'completed': hit the deadline (countdown mode only).\n   */\n  status: \"idle\" | \"running\" | \"paused\" | \"completed\";\n  /** Number of times the timer has fired (repeat mode only). */\n  repeats: number;\n}\n\nexport interface TimerFactOpts {\n  /** Duration in ms. Countdown mode counts this down; up mode counts up to ∞. */\n  ms: number;\n  /**\n   * - 'down' (default): counts down from `ms` to 0; status → 'completed' at 0.\n   * - 'up': counts elapsed time; never completes.\n   * - 'repeat': fires every `ms`; increments `repeats`; status stays 'running'.\n   */\n  mode?: \"down\" | \"up\" | \"repeat\";\n}\n\n/**\n * Initial state for a newly-created timer. Pass this to your Directive\n * `init()` to seed the fact.\n */\nexport function initialTimerState(): TimerFactState {\n  return {\n    startedAtMs: null,\n    pausedDurationMs: 0,\n    pausedAtMs: null,\n    status: \"idle\",\n    repeats: 0,\n  };\n}\n\n/**\n * Compute elapsed ms for a given timer state at a given clock-now.\n * Pure function — no side effects, no reads beyond its inputs.\n *\n * @example\n * ```ts\n * const elapsed = elapsedMs(facts.countdown, clock.now());\n * if (elapsed >= 60_000) {\n *   facts.countdown = { ...facts.countdown, status: 'completed' };\n * }\n * ```\n */\nexport function elapsedMs(state: TimerFactState, nowMs: number): number {\n  if (state.startedAtMs === null) return 0;\n  // Clamp at 0 — a clock step-back (NTP correction, virtual-clock\n  // re-entrancy, replay seeded from older snapshot) would otherwise\n  // produce negative elapsed values that:\n  //   - make tickTimer never report 'complete' (because `elapsed >= ms`\n  //     stays false past the deadline)\n  //   - make remainingMs report values > the configured ms total\n  //   - silently wrap into pausedDurationMs accumulation downstream\n  // (R1 sec C4.)\n  if (state.status === \"paused\" && state.pausedAtMs !== null) {\n    return Math.max(\n      0,\n      state.pausedAtMs - state.startedAtMs - state.pausedDurationMs,\n    );\n  }\n  return Math.max(0, nowMs - state.startedAtMs - state.pausedDurationMs);\n}\n\n/**\n * Compute remaining ms for a countdown timer at a given clock-now.\n * Returns 0 if the timer has hit zero or hasn't started.\n */\nexport function remainingMs(\n  state: TimerFactState,\n  nowMs: number,\n  totalMs: number,\n): number {\n  return Math.max(0, totalMs - elapsedMs(state, nowMs));\n}\n\n/**\n * Transition: start an idle (or reset) timer.\n *\n * No-op if already running, paused, or completed (use `reset()` first).\n */\nexport function startTimer(\n  state: TimerFactState,\n  nowMs: number,\n): TimerFactState {\n  if (state.status === \"running\") return state;\n  if (state.status === \"paused\") return state;\n  return {\n    ...state,\n    startedAtMs: nowMs,\n    pausedDurationMs: 0,\n    pausedAtMs: null,\n    status: \"running\",\n    repeats: 0,\n  };\n}\n\n/**\n * Transition: pause a running timer. Records the pause moment so a\n * later `resumeTimer()` can correctly extend pausedDurationMs.\n *\n * No-op if not running.\n */\nexport function pauseTimer(\n  state: TimerFactState,\n  nowMs: number,\n): TimerFactState {\n  if (state.status !== \"running\") return state;\n  return { ...state, pausedAtMs: nowMs, status: \"paused\" };\n}\n\n/**\n * Transition: resume a paused timer. Adds the time spent paused into\n * `pausedDurationMs` so elapsed/remaining math stays correct.\n *\n * No-op if not paused.\n */\nexport function resumeTimer(\n  state: TimerFactState,\n  nowMs: number,\n): TimerFactState {\n  if (state.status !== \"paused\") return state;\n  if (state.pausedAtMs === null) return state;\n  // Clamp pausedFor at 0 — clock step-back between pause and resume\n  // would otherwise produce a negative pausedDurationMs accumulation,\n  // which propagates into elapsedMs (returns inflated values), which\n  // prematurely completes countdowns. (R1 sec M1.)\n  const pausedFor = Math.max(0, nowMs - state.pausedAtMs);\n  return {\n    ...state,\n    pausedDurationMs: state.pausedDurationMs + pausedFor,\n    pausedAtMs: null,\n    status: \"running\",\n  };\n}\n\n/**\n * Transition: reset a timer to idle. Loses all elapsed time + repeat\n * count. Equivalent to `initialTimerState()`.\n */\nexport function resetTimer(): TimerFactState {\n  return initialTimerState();\n}\n\n/**\n * Transition: mark the timer completed. For countdown mode when\n * elapsed reaches `ms`; for repeat mode when consumer wants to halt.\n */\nexport function completeTimer(state: TimerFactState): TimerFactState {\n  return { ...state, status: \"completed\" };\n}\n\n/**\n * Transition: register a repeat firing. Increments `repeats` and\n * advances `startedAtMs` by `ms` so the next interval lands at the\n * intended boundary (drift-free).\n */\nexport function registerRepeat(\n  state: TimerFactState,\n  ms: number,\n): TimerFactState {\n  if (state.startedAtMs === null) return state;\n  // Defensible-illegal: registerRepeat from a paused state would\n  // otherwise advance startedAtMs while leaving status === 'paused',\n  // producing an inconsistent state (logically running by clock math\n  // but reads as paused). No-op instead. (R2 sec m-R2-2.)\n  if (state.status === \"paused\") return state;\n  // Reset pausedDurationMs on each repeat so accumulated pause time\n  // from prior intervals does not double-count into the next\n  // interval's elapsed math. Without this reset, every repeat after a\n  // pause would arithmetic-drift the next deadline by the cumulative\n  // pause window. (R1 sec M9.)\n  return {\n    ...state,\n    startedAtMs: state.startedAtMs + ms,\n    pausedDurationMs: 0,\n    pausedAtMs: null,\n    repeats: state.repeats + 1,\n  };\n}\n\n/**\n * Higher-level helper: given a timer state, total ms, and the current\n * clock, return whether the timer should transition to 'completed' (for\n * countdown mode) or fire a repeat (for repeat mode).\n *\n * Pure — does not mutate state. Returns a structured signal the consumer\n * applies via `completeTimer` / `registerRepeat`.\n */\nexport function tickTimer(\n  state: TimerFactState,\n  nowMs: number,\n  opts: TimerFactOpts,\n): { kind: \"no-op\" } | { kind: \"complete\" } | { kind: \"repeat\" } {\n  if (state.status !== \"running\") return { kind: \"no-op\" };\n  const elapsed = elapsedMs(state, nowMs);\n\n  if (opts.mode === \"up\") {\n    // 'up' never completes; consumer reads elapsedMs directly.\n    return { kind: \"no-op\" };\n  }\n\n  if (opts.mode === \"repeat\") {\n    if (elapsed >= opts.ms) return { kind: \"repeat\" };\n    return { kind: \"no-op\" };\n  }\n\n  // 'down' (default)\n  if (elapsed >= opts.ms) return { kind: \"complete\" };\n  return { kind: \"no-op\" };\n}\n\n/**\n * Bundle of helpers for one timer in one module — convenience for\n * callers who want a single import. Each method takes the current\n * state and clock-now, returns the next state. No mutation.\n *\n * @example\n * ```ts\n * import {\n *   createSystem,\n *   t,\n *   realClock,\n *   timerOps,\n *   initialTimerState,\n *   type TimerFactState,\n * } from '@directive-run/core';\n *\n * const clock = realClock();\n * const ops = timerOps({ ms: 60_000, mode: 'down' });\n *\n * createModule('countdown', {\n *   schema: { facts: { state: t.object<TimerFactState>() }, events: { START: {} } },\n *   init: (f) => { f.state = initialTimerState(); },\n *   events: {\n *     START: (f) => { f.state = ops.start(f.state, clock.now()); },\n *   },\n * });\n *\n * // In the consumer (React, Node, edge), tick periodically:\n * setInterval(() => {\n *   const signal = ops.tick(f.state, clock.now());\n *   if (signal.kind === 'complete') {\n *     sys.dispatch({ type: 'TIMEOUT' });\n *   }\n * }, 100);\n * ```\n */\nexport function timerOps(opts: TimerFactOpts) {\n  return {\n    initial: initialTimerState,\n    start: startTimer,\n    pause: pauseTimer,\n    resume: resumeTimer,\n    reset: resetTimer,\n    complete: completeTimer,\n    registerRepeat: (state: TimerFactState) => registerRepeat(state, opts.ms),\n    tick: (state: TimerFactState, nowMs: number) =>\n      tickTimer(state, nowMs, opts),\n    elapsedMs,\n    remainingMs: (state: TimerFactState, nowMs: number) =>\n      remainingMs(state, nowMs, opts.ms),\n  };\n}\n","/**\n * @directive-run/core\n *\n * Constraint-driven runtime for TypeScript.\n *\n * Also available:\n * - `@directive-run/core/internals` – Manager factories, engine, tracking, and internal types\n * - `@directive-run/core/plugins` – Logging, devtools, persistence, observability, circuit breaker\n * - `@directive-run/core/testing` – Mock resolvers, fake timers, assertion helpers\n * - `@directive-run/core/migration` – Redux/Zustand/XState migration scaffolding\n * - `@directive-run/core/adapter-utils` – Shared framework adapter utilities\n * - `@directive-run/core/worker` – Web Worker support\n *\n * @packageDocumentation\n */\n\n// ============================================================================\n// Core Types — what 90% of users need\n// ============================================================================\n\nexport type {\n  // Schema\n  Schema,\n  SchemaType,\n  InferSchemaType,\n  // Module Schema (consolidated)\n  ModuleSchema,\n  InferFacts,\n  InferDerivations,\n  InferSelectorState,\n  InferEvents,\n  InferRequirements,\n  InferRequirementTypes,\n  // Facts\n  Facts,\n  FactsSnapshot,\n  // Requirements\n  Requirement,\n  RequirementWithId,\n  // Constraints + Resolvers (config types)\n  RetryPolicy,\n  BatchConfig,\n  // Plugins\n  Plugin,\n  Snapshot,\n  // Errors\n  ErrorBoundaryConfig,\n  // Module\n  ModuleDef,\n  ModuleHooks,\n  // System\n  System,\n  SystemConfig,\n  SystemInspection,\n  SystemSnapshot,\n  MetaAccessor,\n  MetaMatch,\n  ObservationEvent,\n  // Trace\n  TraceEntry,\n  TraceOption,\n  // History\n  HistoryOption,\n  HistoryAPI,\n  HistoryState,\n  // Composition (Namespaced Multi-Module)\n  ModulesMap,\n  NamespacedSystem,\n  CreateSystemOptionsNamed,\n  // Single Module\n  CreateSystemOptionsSingle,\n  SingleModuleSystem,\n  // Type Guards\n  SystemMode,\n  AnySystem,\n  // Cross-Module Dependencies\n  CrossModuleDeps,\n  // Dynamic Definitions\n  DynamicConstraintDef,\n  DynamicEffectDef,\n  DynamicResolverDef,\n  // Definition Meta\n  DefinitionMeta,\n  DerivationDefWithMeta,\n  // Data-configuration predicates and templates\n  FactPredicate,\n  FactTemplate,\n  KeySelector,\n  PatchSpec,\n  PayloadRef,\n  PatchValue,\n  OperatorObject,\n  PredicateObject,\n  PredicateClause,\n  PredicateCombinator,\n  PredicateCombinatorKey,\n  PredicateOp,\n  ClauseResult,\n  // Distributable Snapshots\n  DistributableSnapshot,\n  DistributableSnapshotOptions,\n} from \"./core/types.js\";\n\n// Predicate / template runtime\nexport {\n  applyPatch,\n  memoizePredicate,\n  evaluateKeySelector,\n  evaluatePredicate,\n  evaluatePredicateExplained,\n  evaluateTemplate,\n  extractDeps,\n  extractTemplateKeys,\n  isPredicate,\n  isTemplate,\n  validatePredicate,\n} from \"./core/predicate.js\";\n\n// Predicate backtest — rule-change impact replay\nexport {\n  MAX_REPLAY_FRAMES,\n  framesFromHistory,\n  framesFromSnapshots,\n  replayUnder,\n  toReplayFrames,\n} from \"./core/replay-under.js\";\nexport type {\n  PredicateBacktestReport,\n  ReplayDiffSample,\n  ReplayFrame,\n  ReplayUnderOptions,\n} from \"./core/replay-under.js\";\n\n// Parameter sweep — grid-search predicate templates against recorded history\nexport { MAX_SWEEP_POINTS, sweepUnder } from \"./core/sweep-under.js\";\nexport type {\n  SweepHole,\n  SweepPoint,\n  SweepReport,\n  SweepUnderOptions,\n} from \"./core/sweep-under.js\";\n\n// Rules diff — structural diff of constraint whenSpec across two snapshots\nexport { diffClauses, diffRules, flattenPredicate, toRulesMap } from \"./core/rules-diff.js\";\nexport type {\n  Change,\n  ChangeKind,\n  ConstraintDiff,\n  ConstraintStatus,\n  DiffRulesOptions,\n  LeafClause,\n  RulesDiffReport,\n  RulesMapInput,\n} from \"./core/rules-diff.js\";\n\n// Schema introspection — runtime kind discriminant + operator matrix\nexport {\n  getKind,\n  getOperatorsForKind,\n  getSchemaFieldKinds,\n  listAllPredicateOperators,\n} from \"./core/schema-introspection.js\";\nexport type { SchemaKind, SchemaKindNode } from \"./core/schema-introspection.js\";\nexport { validatePredicateAgainstSchema } from \"./core/predicate.js\";\nexport type {\n  SchemaValidationError,\n  SchemaValidationOptions,\n  SchemaValidationResult,\n} from \"./core/predicate.js\";\n\n// predict — \"would this predicate fire, and if not, which facts must change?\"\nexport { predict } from \"./core/predict.js\";\nexport type { PredictMissingChange, PredictResult } from \"./core/predict.js\";\n\n// doctor — structural contradiction detection between a candidate predicate and existing constraints\nexport { doctor } from \"./core/doctor.js\";\nexport type {\n  CheckAgainstResult,\n  Contradiction,\n  ContradictionType,\n  ExistingConstraint,\n} from \"./core/doctor.js\";\n\n// createAuditLedger — append-only, queryable, cryptographically-chained audit log\nexport {\n  createAuditLedger,\n  memorySink,\n} from \"./plugins/audit-ledger.js\";\nexport type {\n  AuditEntry,\n  AuditEntryKind,\n  AuditLedger,\n  AuditLedgerOptions,\n  AuditLedgerSink,\n  QueryFilter,\n} from \"./plugins/audit-ledger.js\";\n\n// Predicate codegen — one predicate, run on client AND server\nexport { predicateToSQL, predicateToWhere } from \"./core/predicate-to-sql.js\";\nexport type {\n  PredicateToSqlOptions,\n  PredicateToSqlResult,\n} from \"./core/predicate-to-sql.js\";\nexport { predicateToMongo } from \"./core/predicate-to-mongo.js\";\nexport type { PredicateToMongoOptions } from \"./core/predicate-to-mongo.js\";\nexport { predicateToPostgrest } from \"./core/predicate-to-pgrest.js\";\nexport type { PredicateToPostgrestOptions } from \"./core/predicate-to-pgrest.js\";\n\n// ============================================================================\n// Core Classes\n// ============================================================================\n\nexport { DirectiveError } from \"./core/types.js\";\n\n// ============================================================================\n// Schema Type Builders\n// ============================================================================\n\n/**\n * Schema type builders for defining fact types.\n *\n * @example\n * ```ts\n * import { t } from '@directive-run/core';\n *\n * const schema = {\n *   facts: {\n *     count: t.number().min(0).default(0),\n *     name: t.string(),\n *     status: t.enum(\"idle\", \"loading\", \"error\"),\n *     user: t.object<User>().nullable(),\n *   },\n *   derivations: { doubled: t.number() },\n *   events: { increment: {} },\n *   requirements: { FETCH_USER: {} },\n * };\n * ```\n */\nexport {\n  t,\n  type Branded,\n  type ExtendedSchemaType,\n  type ChainableSchemaType,\n} from \"./core/schema-builders.js\";\n\n// ============================================================================\n// Module & System\n// ============================================================================\n\nexport {\n  createModule,\n  createModuleFactory,\n  type ModuleConfig,\n  type ModuleConfigWithDeps,\n} from \"./core/module.js\";\nexport { createSystem } from \"./core/system.js\";\nexport { createSystemWithStatus } from \"./utils/system-with-status.js\";\n\n// Helper factory functions for typed constraint/resolver definitions\nexport {\n  typedConstraint,\n  typedResolver,\n} from \"./core/types.js\";\n\n// ============================================================================\n// Requirements Helpers\n// ============================================================================\n\nexport {\n  req,\n  forType,\n  isRequirementType,\n  generateRequirementId,\n  RequirementSet,\n} from \"./core/requirements.js\";\n\n// ============================================================================\n// Type Guards\n// ============================================================================\n\nexport {\n  isSingleModuleSystem,\n  isNamespacedSystem,\n} from \"./core/types/composition.js\";\n\n// ============================================================================\n// Constants\n// ============================================================================\n\n/**\n * Backoff strategy constants for retry policies.\n *\n * @example\n * ```ts\n * import { Backoff } from '@directive-run/core';\n *\n * retry: { attempts: 3, backoff: Backoff.Exponential, initialDelay: 100 }\n * ```\n */\nexport const Backoff = {\n  /** No delay between retries */\n  None: \"none\",\n  /** Linear delay increase (initialDelay * attempt) */\n  Linear: \"linear\",\n  /** Exponential delay increase (initialDelay * 2^attempt) */\n  Exponential: \"exponential\",\n} as const;\n\n// ============================================================================\n// Requirement Status Utilities\n// ============================================================================\n\nexport {\n  createRequirementStatusPlugin,\n  createStatusHook,\n  type RequirementTypeStatus,\n} from \"./utils/requirement-status.js\";\n\n// ============================================================================\n// Snapshot Utilities\n// ============================================================================\n\nexport {\n  shallowEqual,\n  isSnapshotExpired,\n  validateSnapshot,\n  diffSnapshots,\n  signSnapshot,\n  verifySnapshotSignature,\n  isSignedSnapshot,\n  type DistributableSnapshotLike,\n  type SnapshotDiff,\n  type SnapshotDiffEntry,\n  type SignedSnapshot,\n} from \"./utils/utils.js\";\n\n// ============================================================================\n// Clock + Timer (RFC 0001 v0.1)\n// ============================================================================\n\nexport {\n  type SignalClock,\n  realClock,\n  virtualClock,\n  defaultClock,\n} from \"./core/clock.js\";\n\nexport {\n  type TimerFactState,\n  type TimerFactOpts,\n  initialTimerState,\n  elapsedMs,\n  remainingMs,\n  startTimer,\n  pauseTimer,\n  resumeTimer,\n  resetTimer,\n  completeTimer,\n  registerRepeat,\n  tickTimer,\n  timerOps,\n} from \"./core/timer.js\";\n\n// ============================================================================\n// Lower-level APIs — use \"@directive-run/core/internals\" for these\n// ============================================================================\n// Manager factories, engine, tracking, and internal types are available at:\n//   import { createEngine, createFacts, withTracking } from \"@directive-run/core/internals\"\n//\n// Internal types (FactsStore, FactChange, DerivationState, ConstraintState,\n// DerivationsDef, ConstraintsDef, ResolversDef, EventsDef, ReconcileResult,\n// RecoveryStrategy, ErrorSource, etc.) are also in internals.\n\n// Migration utilities available via \"@directive-run/core/migration\" subpath export.\n"]}