@directive-run/core 1.4.0 → 1.6.0

package/dist/index.d.cts

@@ -1,8 +1,408 @@
-import { S as SchemaType, D as DefinitionMeta, M as ModuleSchema, F as Facts, T as TypedDerivationsDef, a as TypedEventsDef, E as EffectsDef, b as TypedConstraintsDef, c as TypedResolversDef, d as ModuleHooks, C as CrossModuleDeps, e as CrossModuleDerivationsDef, f as CrossModuleEffectsDef, g as CrossModuleConstraintsDef, h as ModuleDef, i as CreateSystemOptionsSingle, j as SingleModuleSystem, k as ModulesMap, l as CreateSystemOptionsNamed, N as NamespacedSystem, P as Plugin, m as TraceOption, n as ErrorBoundaryConfig, R as RequirementWithId, o as Requirement, p as RequirementKeyFn } from './plugins-Dy1C8GtT.cjs';
-export { A as AnySystem, B as BatchConfig, q as DirectiveError, r as DistributableSnapshot, s as DistributableSnapshotOptions, t as DynamicConstraintDef, u as DynamicEffectDef, v as DynamicResolverDef, w as FactsSnapshot, H as HistoryAPI, x as HistoryOption, y as HistoryState, I as InferDerivations, z as InferEvents, G as InferFacts, J as InferRequirementTypes, K as InferRequirements, L as InferSchemaType, O as InferSelectorState, Q as MetaAccessor, U as MetaMatch, V as ObservationEvent, W as RetryPolicy, X as Schema, Y as Snapshot, Z as System, _ as SystemConfig, $ as SystemInspection, a0 as SystemMode, a1 as SystemSnapshot, a2 as TraceEntry, a3 as isNamespacedSystem, a4 as isSingleModuleSystem } from './plugins-Dy1C8GtT.cjs';
-export { D as DerivationDefWithMeta, t as typedConstraint, a as typedResolver } from './helpers-BUY1lYCX.cjs';
+import { P as PatchSpec, C as ClauseResult, F as FactTemplate, a as FactPredicate, S as SchemaType, D as DefinitionMeta, M as ModuleSchema, b as Facts, T as TypedDerivationsDef, c as TypedEventsDef, E as EffectsDef, d as TypedConstraintsDef, e as TypedResolversDef, f as ModuleHooks, g as CrossModuleDeps, h as CrossModuleDerivationsDef, i as CrossModuleEffectsDef, j as CrossModuleConstraintsDef, k as ModuleDef, l as CreateSystemOptionsSingle, m as SingleModuleSystem, n as ModulesMap, o as CreateSystemOptionsNamed, N as NamespacedSystem, p as Plugin, q as TraceOption, r as ErrorBoundaryConfig, R as RequirementWithId, s as Requirement, t as RequirementKeyFn } from './plugins-DvrsPhzx.cjs';
+export { A as AnySystem, B as BatchConfig, u as DirectiveError, v as DistributableSnapshot, w as DistributableSnapshotOptions, x as DynamicConstraintDef, y as DynamicEffectDef, z as DynamicResolverDef, G as FactsSnapshot, H as HistoryAPI, I as HistoryOption, J as HistoryState, K as InferDerivations, L as InferEvents, O as InferFacts, Q as InferRequirementTypes, U as InferRequirements, V as InferSchemaType, W as InferSelectorState, X as KeySelector, Y as MetaAccessor, Z as MetaMatch, _ as ObservationEvent, $ as OperatorObject, a0 as PatchValue, a1 as PayloadRef, a2 as PredicateClause, a3 as PredicateCombinator, a4 as PredicateCombinatorKey, a5 as PredicateObject, a6 as PredicateOp, a7 as RetryPolicy, a8 as Schema, a9 as Snapshot, aa as System, ab as SystemConfig, ac as SystemInspection, ad as SystemMode, ae as SystemSnapshot, af as TraceEntry, ag as isNamespacedSystem, ah as isSingleModuleSystem } from './plugins-DvrsPhzx.cjs';
+export { D as DerivationDefWithMeta, t as typedConstraint, a as typedResolver } from './helpers-CG27mEGG.cjs';
 export { D as DistributableSnapshotLike, S as SignedSnapshot, a as SnapshotDiff, b as SnapshotDiffEntry, d as diffSnapshots, i as isSignedSnapshot, c as isSnapshotExpired, s as shallowEqual, e as signSnapshot, v as validateSnapshot, f as verifySnapshotSignature } from './utils-BnQajqPu.cjs';
 
+/**
+ * Runtime for data-configuration predicates and templates.
+ *
+ * Pure module — imports only its own types. Reads facts through whatever
+ * object it is handed (the reactive `Facts` proxy in production, a plain
+ * snapshot in tests), so it never depends on the engine, store, or tracking.
+ */
+
+/** A readable scope — the `Facts` proxy and a plain snapshot both satisfy it. */
+type Scope = Record<string, unknown>;
+/**
+ * True when `v` is a data-form spec (predicate object/array) rather than a
+ * function. Excludes class instances (Date, RegExp, Map, Set, Promise, etc.)
+ * — only plain `{}` literals and arrays of plain clause shapes qualify.
+ *
+ * @example
+ * ```ts
+ * isPredicate({ phase: "red" }); // true
+ * isPredicate((f) => f.phase === "red"); // false
+ * isPredicate([{ fact: "phase", op: "$eq", value: "red" }]); // true
+ * ```
+ */
+declare function isPredicate(v: unknown): boolean;
+/**
+ * True when `v` is a {@link FactTemplate} (`{ $template: string }`).
+ *
+ * @example
+ * ```ts
+ * isTemplate({ $template: "Hi ${name}" }); // true
+ * isTemplate({ $set: { name: "x" } }); // false
+ * ```
+ */
+declare function isTemplate(v: unknown): v is FactTemplate;
+/**
+ * Throw when a predicate spec contains an operand that cannot survive a
+ * JSON round-trip — i.e. that would silently mis-evaluate if the spec was
+ * loaded from `JSON.parse`.
+ *
+ * Three failure classes are detected:
+ *
+ * - **Lost `RegExp` operand.** A `$matches` operand that is not a
+ *   `RegExp` instance. `JSON.parse` reconstructs a serialized regex as
+ *   `{}`, so a `$matches` clause with an empty-object operand is the
+ *   signature of a regex that did not survive serialization. Reify it
+ *   with `new RegExp(pattern, flags)` before installing the predicate.
+ * - **`bigint` operand.** `JSON.stringify` throws on `bigint`, so a
+ *   `bigint` operand cannot have been produced by a JSON pipeline and
+ *   cannot be persisted by one either.
+ * - **`Set` / `Map` operand.** Both serialize to `{}` and lose all
+ *   members; a predicate carrying one is not JSON-safe.
+ *
+ * This is an opt-in helper — the engine does not call it automatically.
+ * Users who load predicates from JSON should call it after `JSON.parse`
+ * to fail loud rather than silently mis-evaluate. See the
+ * "Serialization" section of RFC-0004.
+ *
+ * @example
+ * ```ts
+ * validatePredicate({ phase: { $matches: {} } });
+ * // throws — empty object where a RegExp is required
+ *
+ * validatePredicate({ phase: "red", elapsed: { $gte: 30 } });
+ * // ok — JSON-clean operands
+ * ```
+ */
+declare function validatePredicate(spec: unknown, path?: string): void;
+/**
+ * Evaluate a {@link FactPredicate} against a fact scope. `prev` (a previous
+ * snapshot) is consulted only by the `$changed` operator.
+ *
+ * @example
+ * ```ts
+ * evaluatePredicate({ phase: "red", elapsed: { $gte: 30 } }, { phase: "red", elapsed: 45 });
+ * // → true
+ * evaluatePredicate({ $any: [{ phase: "red" }, { phase: "yellow" }] }, { phase: "green" });
+ * // → false
+ * ```
+ */
+declare function evaluatePredicate(spec: unknown, facts: Scope, prev?: Scope, depth?: number): boolean;
+/**
+ * Evaluate a predicate and return a per-clause breakdown — the data feed for
+ * devtools, `system.explain()`, and `directive explain`.
+ *
+ * @example
+ * ```ts
+ * evaluatePredicateExplained(
+ *   { phase: "red", elapsed: { $gte: 30 } },
+ *   { phase: "red", elapsed: 20 },
+ * );
+ * // → [
+ * //   { path: "phase",   op: "$eq",  expected: "red", actual: "red", pass: true  },
+ * //   { path: "elapsed", op: "$gte", expected: 30,    actual: 20,    pass: false },
+ * // ]
+ * ```
+ */
+declare function evaluatePredicateExplained(spec: unknown, facts: Scope, prev?: Scope, pathPrefix?: string): ClauseResult[];
+/**
+ * Memoize a predicate as a reusable evaluation closure.
+ *
+ * The returned function accepts any `facts` scope (the reactive proxy in
+ * production, a plain object in tests) plus an optional `prev` snapshot for
+ * `$changed`. The closure is cached **by predicate identity** in a
+ * `WeakMap`, so passing the same `predicate` reference repeatedly is
+ * allocation-free; cleanup is automatic once the predicate is no longer
+ * reachable.
+ *
+ * Note: no actual compilation happens — the returned closure re-walks the
+ * spec on every call via `evaluatePredicate`. The name reflects what the
+ * function does (closure memoization keyed by predicate identity), not a
+ * bytecode/AST compile step.
+ *
+ * Intended for advanced users who want a stable function reference per
+ * predicate (custom devtools, batched analyses). Regular module code does
+ * not need to call this — the engine wraps data-form `when` / `on` specs
+ * automatically at registration.
+ *
+ * @example
+ * ```ts
+ * const predicate = { phase: "red", elapsed: { $gte: 30 } };
+ * const check = memoizePredicate(predicate);
+ * check({ phase: "red", elapsed: 45 }); // → true
+ * check({ phase: "red", elapsed: 5  }); // → false
+ * ```
+ */
+declare function memoizePredicate(predicate: object): (facts: Scope, prev?: Scope) => boolean;
+/**
+ * Collect the fact keys a predicate references. Used for static analysis,
+ * devtools, and effect `on` dependency wiring. Nested predicates contribute
+ * dotted keys (`auth.token`).
+ *
+ * @example
+ * ```ts
+ * extractDeps({ phase: "red", elapsed: { $gte: 30 } });
+ * // → Set { "phase", "elapsed" }
+ * extractDeps({ self: { phase: "red" }, auth: { token: { $exists: true } } });
+ * // → Set { "self.phase", "auth.token" }
+ * ```
+ */
+declare function extractDeps(spec: unknown, prefix?: string): Set<string>;
+/**
+ * Interpolate a {@link FactTemplate} against a scope. Single-pass character
+ * scanner: `${ident}` interpolates `scope[ident]`; `$${` emits a literal
+ * `${`; unknown keys dev-warn and yield an empty string.
+ *
+ * @example
+ * ```ts
+ * evaluateTemplate({ $template: "Hi ${name}!" }, { name: "Ada" });
+ * // → "Hi Ada!"
+ * evaluateTemplate({ $template: "$${price}" }, {});
+ * // → "${price}"
+ * ```
+ */
+declare function evaluateTemplate(spec: FactTemplate, scope: Scope): string;
+/**
+ * Collect the placeholder keys referenced by a template. The static-analysis
+ * counterpart to {@link extractDeps} — useful for devtools, codegen, and
+ * "which facts does this template read" inspections. Only valid identifier
+ * placeholders are collected; malformed ones are ignored.
+ *
+ * @example
+ * ```ts
+ * extractTemplateKeys({ $template: "${firstName} ${lastName}" });
+ * // → Set { "firstName", "lastName" }
+ * extractTemplateKeys({ $template: "$${literal}" });
+ * // → Set {} (escaped — not a placeholder)
+ * ```
+ */
+declare function extractTemplateKeys(spec: FactTemplate): Set<string>;
+/**
+ * Build a stable dedup key by selecting fields from a requirement payload.
+ * Order-as-declared; values are stable-stringified (keys sorted recursively)
+ * so two payloads with the same fields in different orders dedupe to the
+ * same key.
+ *
+ * @example
+ * ```ts
+ * evaluateKeySelector(["url", "method"], { url: "/a", method: "GET" });
+ * // → '"/a"|"GET"'
+ * evaluateKeySelector(["id"], { id: 42 });
+ * // → '42'
+ * ```
+ */
+declare function evaluateKeySelector(selector: readonly string[], source: Record<string, unknown>): string;
+/**
+ * Apply a {@link PatchSpec} — assign facts from literals, payload copies
+ * (`$ref`), or interpolated strings (`$template`). Mutates through the passed
+ * `facts` proxy so change-tracking and downstream invalidation fire.
+ *
+ * @example
+ * ```ts
+ * const spec = {
+ *   $set: {
+ *     active: true,
+ *     userId: { $ref: "id" },
+ *     label: { $template: "user ${name}" },
+ *   },
+ * };
+ * applyPatch(spec, facts, { id: "u_1", name: "Ada" });
+ * // facts.active = true; facts.userId = "u_1"; facts.label = "user Ada"
+ * ```
+ */
+declare function applyPatch(spec: PatchSpec<Record<string, unknown>, Record<string, unknown>>, facts: Record<string, unknown>, payload: Record<string, unknown>): void;
+
+/**
+ * Predicate backtest — rule-change impact.
+ *
+ * Given a recorded sequence of fact-state frames and a proposed replacement
+ * for a constraint's `when` predicate, re-score the frames against BOTH the
+ * original and the proposed predicate and produce a backtest report: how
+ * many frames each matched, plus the per-frame diff (frames that newly
+ * match / no longer match). It answers "how many recorded frames would the
+ * proposed rule have matched differently" against real recorded history.
+ *
+ * This is a *static* backtest, not a behavioral simulation — the engine is
+ * not re-run. Recorded frames are re-scored against a new predicate; the
+ * resulting requirements, resolvers, and downstream fact changes are NOT
+ * modeled. Treat the numbers as a divergence scan, not a forecast.
+ *
+ * Pure module — imports only the predicate runtime. No engine, store, or
+ * tracking dependency. Replay walks frames in order; for `$changed`-style
+ * predicates each frame is evaluated against the previous frame's facts.
+ */
+
+/**
+ * Upper bound on the number of frames a single {@link replayUnder} call will
+ * process. A history file is held entirely in memory; an unbounded array is a
+ * denial-of-service surface. A history larger than this should be split or
+ * down-sampled before replay.
+ */
+declare const MAX_REPLAY_FRAMES = 1000000;
+/** One recorded fact-state frame. */
+interface ReplayFrame<F = Record<string, unknown>> {
+    /** Stable identifier — a snapshot id, an index, a session key. */
+    id: string | number;
+    /** Optional wall-clock time (ms epoch). */
+    timestamp?: number;
+    /** The fact state at this frame. */
+    facts: F;
+}
+interface ReplayUnderOptions<F = Record<string, unknown>> {
+    /** Recorded frames, chronological order. */
+    frames: readonly ReplayFrame<F>[];
+    /** The constraint's current `when` predicate (the baseline). */
+    original: FactPredicate<F>;
+    /** The proposed replacement `when` predicate. */
+    proposed: FactPredicate<F>;
+    /** Max diff samples to attach per bucket (default 20). */
+    maxSamples?: number;
+    /**
+     * A fact key identifying the entity a frame belongs to (e.g. `"userId"`,
+     * `"sessionId"`). When set, the report also reports distinct-entity counts
+     * — how many unique entities matched, not just how many frames. Without it
+     * the unit is frames: one fact snapshot, not one user or session.
+     */
+    entityKey?: string;
+}
+/** A frame where the original and proposed predicate disagree. */
+interface ReplayDiffSample {
+    frameId: string | number;
+    timestamp?: number;
+    /** The fact state at this frame. */
+    facts: Record<string, unknown>;
+    /** Per-clause breakdown under the original predicate. */
+    originalExplain: ClauseResult[];
+    /** Per-clause breakdown under the proposed predicate. */
+    proposedExplain: ClauseResult[];
+}
+/**
+ * The outcome of replaying a recorded history under two predicates — a
+ * static backtest of a proposed rule change, not a behavioral simulation.
+ */
+interface PredicateBacktestReport {
+    /** Total frames evaluated. */
+    framesEvaluated: number;
+    /**
+     * Frames where the original predicate matched (was true). `matchedEntities`
+     * is the count of distinct `entityKey` values among matched frames — only
+     * populated when {@link ReplayUnderOptions.entityKey} was supplied.
+     */
+    original: {
+        matched: number;
+        matchedEntities?: number;
+    };
+    /** Frames where the proposed predicate matched. */
+    proposed: {
+        matched: number;
+        matchedEntities?: number;
+    };
+    /** proposed.matched - original.matched. */
+    delta: number;
+    /** Total count of frames that newly match (original false -> proposed true). */
+    newMatchCount: number;
+    /** Total count of frames that no longer match (original true -> proposed false). */
+    lostMatchCount: number;
+    /** Frames where original and proposed agree. */
+    unchanged: number;
+    /** Sampled new-match frames (capped at maxSamples), with clause explain. */
+    newMatches: ReplayDiffSample[];
+    /** Sampled lost-match frames (capped at maxSamples), with clause explain. */
+    lostMatches: ReplayDiffSample[];
+}
+/**
+ * Normalize a parsed-from-JSON history value into a `ReplayFrame[]`.
+ *
+ * Accepts the three documented history shapes:
+ *
+ *  1. A bare array of frames:        `[{ id, timestamp?, facts }, ...]`
+ *  2. An object wrapping them:       `{ frames: [{ id, ..., facts }, ...] }`
+ *  3. A bare array of fact objects:  `[{ phase: "red", ... }, ...]`
+ *     — each element is wrapped as a frame.
+ *
+ * Frame ids are kept unambiguous: a frame that supplies its own `id` keeps
+ * it; a frame missing an `id` (and every bare-fact frame) gets an
+ * **index-derived** id prefixed with `#` (`"#0"`, `"#1"`, …) so a fallback
+ * id can never collide with an explicit numeric or string id in a mixed
+ * history. This is a pure helper — it **throws** a clear `Error` on bad
+ * input and never calls `process.exit`, so library users can catch it.
+ *
+ * @example
+ * ```ts
+ * toReplayFrames([{ id: "s1", facts: { phase: "red" } }]);
+ * // → [{ id: "s1", facts: { phase: "red" } }]
+ * toReplayFrames([{ phase: "red" }, { phase: "green" }]);
+ * // → [{ id: "#0", facts: { phase: "red" } }, { id: "#1", facts: { phase: "green" } }]
+ * ```
+ */
+declare function toReplayFrames(raw: unknown): ReplayFrame[];
+/**
+ * Convert a history-manager export (the JSON produced by
+ * `system.history.export()`) into a `ReplayFrame[]` ready for
+ * {@link replayUnder}.
+ *
+ * The history manager records a ring buffer of `{ id, timestamp, facts,
+ * trigger }` snapshots; `export()` wraps them as `{ version, snapshots,
+ * currentIndex }`. Each snapshot's `facts` is the fact state at that point,
+ * so the snapshot sequence is exactly a frame stream.
+ *
+ * Accepts either the parsed export object, the raw JSON string, or a bare
+ * array of snapshots. Throws a clear `Error` on bad input.
+ *
+ * @example
+ * ```ts
+ * const frames = framesFromHistory(system.history.export());
+ * const report = replayUnder({ frames, original, proposed });
+ * ```
+ */
+declare function framesFromHistory(historyExport: unknown): ReplayFrame[];
+/**
+ * Convert an array of `{ id, timestamp?, facts }` snapshots — e.g. the
+ * `snapshots` field of a history export, or an array assembled by pushing
+ * `system.getSnapshot()` on each reconcile — into a `ReplayFrame[]`.
+ *
+ * Throws a clear `Error` if the argument is not an array. Each snapshot is
+ * normalized through the same {@link toReplayFrames} id logic.
+ *
+ * @example
+ * ```ts
+ * const snapshots: typeof history[] = [];
+ * system.observe(() => snapshots.push(system.getSnapshot()));
+ * // ...later
+ * const frames = framesFromSnapshots(snapshots);
+ * ```
+ */
+declare function framesFromSnapshots(snapshots: unknown): ReplayFrame[];
+/**
+ * Replay a recorded fact-frame history through two predicates — the
+ * constraint's current `when` and a proposed replacement — and report how
+ * their match sets differ.
+ *
+ * This is a **predicate backtest**: the engine is not re-run. Each recorded
+ * frame is statically re-scored against both specs; the previous frame's
+ * facts are threaded as `prev` so a replayed effect-`on` predicate using
+ * `$changed` still works (for a constraint `when` it is harmless). The
+ * report counts matches under each spec and buckets the disagreements into
+ * new matches (original false, proposed true) and lost matches (original
+ * true, proposed false). Up to `maxSamples` diff frames per bucket carry a
+ * per-clause `evaluatePredicateExplained` breakdown for inspection.
+ *
+ * Both specs are validated up front — a malformed spec throws a clear
+ * `[Directive] replayUnder:` error identifying which spec failed, rather
+ * than letting a raw `evaluatePredicate` error escape mid-loop.
+ *
+ * @example
+ * ```ts
+ * const report = replayUnder({
+ *   frames: [
+ *     { id: 0, facts: { phase: "red", elapsed: 10 } },
+ *     { id: 1, facts: { phase: "red", elapsed: 35 } },
+ *   ],
+ *   original: { phase: "red" },
+ *   proposed: { phase: "red", elapsed: { $gte: 30 } },
+ * });
+ * // report.original.matched  === 2
+ * // report.proposed.matched  === 1
+ * // report.delta             === -1
+ * // report.lostMatchCount    === 1
+ * ```
+ */
+declare function replayUnder<F = Record<string, unknown>>(options: ReplayUnderOptions<F>): PredicateBacktestReport;
+
 /** Brand symbol for branded types */
 declare const Brand: unique symbol;
 /** Branded type - adds a unique brand to a base type */
@@ -793,6 +1193,14 @@ declare function createSystemWithStatus<M extends ModuleSchema>(options: CreateS
  * - Requirement comparison and hashing
  */
 
+/**
+ * Computes a stable identifier for a requirement, used for coalescing
+ * duplicate fetches across the constraint graph.
+ *
+ * @param req - the requirement to identify
+ * @param keyFn - optional custom key function; if omitted, a stableStringify-based default is used (memoized via WeakMap)
+ * @returns the requirement's stable string ID
+ */
 declare function generateRequirementId(req: Requirement, keyFn?: RequirementKeyFn): string;
 /**
  * Create a typed requirement factory for a given requirement type string.
@@ -1141,7 +1549,7 @@ declare function resumeTimer(state: TimerFactState, nowMs: number): TimerFactSta
 declare function resetTimer(): TimerFactState;
 /**
  * Transition: mark the timer completed. For countdown mode when
- * elapsed >= ms; for repeat mode when consumer wants to halt.
+ * elapsed reaches `ms`; for repeat mode when consumer wants to halt.
  */
 declare function completeTimer(state: TimerFactState): TimerFactState;
 /**
@@ -1255,4 +1663,4 @@ declare const Backoff: {
     readonly Exponential: "exponential";
 };
 
-export { Backoff, type Branded, type ChainableSchemaType, CreateSystemOptionsNamed, CreateSystemOptionsSingle, CrossModuleDeps, DefinitionMeta, ErrorBoundaryConfig, type ExtendedSchemaType, Facts, type ModuleConfig, type ModuleConfigWithDeps, ModuleDef, ModuleHooks, ModuleSchema, ModulesMap, NamespacedSystem, Plugin, Requirement, RequirementSet, type RequirementTypeStatus, RequirementWithId, SchemaType, type SignalClock, SingleModuleSystem, type TimerFactOpts, type TimerFactState, TraceOption, completeTimer, createModule, createModuleFactory, createRequirementStatusPlugin, createStatusHook, createSystem, createSystemWithStatus, defaultClock, elapsedMs, forType, generateRequirementId, initialTimerState, isRequirementType, pauseTimer, realClock, registerRepeat, remainingMs, req, resetTimer, resumeTimer, startTimer, t, tickTimer, timerOps, virtualClock };
+export { Backoff, type Branded, type ChainableSchemaType, ClauseResult, CreateSystemOptionsNamed, CreateSystemOptionsSingle, CrossModuleDeps, DefinitionMeta, ErrorBoundaryConfig, type ExtendedSchemaType, FactPredicate, FactTemplate, Facts, MAX_REPLAY_FRAMES, type ModuleConfig, type ModuleConfigWithDeps, ModuleDef, ModuleHooks, ModuleSchema, ModulesMap, NamespacedSystem, PatchSpec, Plugin, type PredicateBacktestReport, type ReplayDiffSample, type ReplayFrame, type ReplayUnderOptions, Requirement, RequirementSet, type RequirementTypeStatus, RequirementWithId, SchemaType, type SignalClock, SingleModuleSystem, type TimerFactOpts, type TimerFactState, TraceOption, applyPatch, completeTimer, createModule, createModuleFactory, createRequirementStatusPlugin, createStatusHook, createSystem, createSystemWithStatus, defaultClock, elapsedMs, evaluateKeySelector, evaluatePredicate, evaluatePredicateExplained, evaluateTemplate, extractDeps, extractTemplateKeys, forType, framesFromHistory, framesFromSnapshots, generateRequirementId, initialTimerState, isPredicate, isRequirementType, isTemplate, memoizePredicate, pauseTimer, realClock, registerRepeat, remainingMs, replayUnder, req, resetTimer, resumeTimer, startTimer, t, tickTimer, timerOps, toReplayFrames, validatePredicate, virtualClock };