@directive-run/core 1.10.0 → 1.12.0

package/dist/index.d.cts

@@ -1,8 +1,133 @@
-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';
+import { P as PredicateOp, a as PatchSpec, C as ClauseResult, F as FactTemplate, b as FactPredicate, S as SchemaType, D as DefinitionMeta, M as ModuleSchema, c as Facts, T as TypedDerivationsDef, d as TypedEventsDef, E as EffectsDef, e as TypedConstraintsDef, f as TypedResolversDef, g as ModuleHooks, h as CrossModuleDeps, i as CrossModuleDerivationsDef, j as CrossModuleEffectsDef, k as CrossModuleConstraintsDef, l as ModuleDef, m as CreateSystemOptionsSingle, n as SingleModuleSystem, o as ModulesMap, p as CreateSystemOptionsNamed, N as NamespacedSystem, q as Plugin, r as TraceOption, s as ErrorBoundaryConfig, R as RequirementWithId, t as Requirement, u as RequirementKeyFn } from './plugins-Ykl_sAPE.cjs';
+export { A as AnySystem, B as BatchConfig, v as DirectiveError, w as DistributableSnapshot, x as DistributableSnapshotOptions, y as DynamicConstraintDef, z as DynamicEffectDef, G as DynamicResolverDef, H as FactsSnapshot, I as HistoryAPI, J as HistoryOption, K as HistoryState, L as InferDerivations, O as InferEvents, Q as InferFacts, U as InferRequirementTypes, V as InferRequirements, W as InferSchemaType, X as InferSelectorState, Y as KeySelector, Z as MetaAccessor, _ as MetaMatch, $ as ObservationEvent, a0 as OperatorObject, a1 as PatchValue, a2 as PayloadRef, a3 as PredicateClause, a4 as PredicateCombinator, a5 as PredicateCombinatorKey, a6 as PredicateObject, 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-Ykl_sAPE.cjs';
+export { D as DerivationDefWithMeta, t as typedConstraint, a as typedResolver } from './helpers-hh6UanB1.cjs';
+export { A as AuditEntry, a as AuditEntryKind, b as AuditLedger, c as AuditLedgerOptions, d as AuditLedgerSink, Q as QueryFilter, e as createAuditLedger, m as memorySink } from './audit-ledger-qMjEBqiP.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';
 
+/**
+ * Schema Introspection
+ *
+ * A runtime discriminant for every `t.*()` builder result, so downstream
+ * consumers (`predicateFromIntent`, `doctor`, future `predicateToZod`)
+ * can ask "what kind is this fact?" without grepping the source.
+ *
+ * The discriminant lives at `_kind?: SchemaKindNode` on `ExtendedSchemaType`.
+ * Base builders set it; chain mutators (`.nullable()`, `.brand()`, etc.)
+ * preserve / decorate it. When `_kind` is absent (legacy or third-party
+ * builder), the parser falls back to reading the freeform `_typeName`
+ * string. When even that fails: `{ kind: "unknown" }` — graceful close.
+ *
+ * This module has zero hot-path cost; it is only invoked when an
+ * introspecting caller asks for it.
+ */
+
+/**
+ * The closed set of kinds a Directive schema field can be.
+ *
+ * Drives operator availability via {@link getOperatorsForKind}: e.g.
+ * `"number"` gets the orderable operators (`$gte`, `$lte`); `"boolean"`
+ * does not.
+ */
+type SchemaKind = "number" | "string" | "boolean" | "bigint" | "date" | "array" | "object" | "record" | "tuple" | "enum" | "literal" | "union" | "branded" | "unknown";
+/**
+ * A tree-shaped discriminator for a schema field. Composite kinds
+ * (array, object, tuple, etc.) carry their element / shape information
+ * so an LLM-prompt builder can show "cartTotal is a number" AND
+ * "items is an array of { sku: string, qty: number }".
+ *
+ * `nullable` / `hasDefault` flags appear on the inner node (NOT a
+ * wrapping kind) so operator-lookup on `t.number().nullable()` returns
+ * the number's operators unchanged — `$gte` works on the non-null arm.
+ */
+type SchemaKindNode = ({
+    kind: "number" | "string" | "boolean" | "bigint" | "date" | "unknown";
+} | {
+    kind: "literal";
+    value: string | number | boolean | null;
+    primitive: "string" | "number" | "boolean" | "null";
+} | {
+    kind: "enum";
+    values: readonly (string | number)[];
+    primitive: "string" | "number";
+} | {
+    kind: "array";
+    element: SchemaKindNode;
+} | {
+    kind: "tuple";
+    elements: readonly SchemaKindNode[];
+} | {
+    kind: "object";
+    shape: Record<string, SchemaKindNode>;
+} | {
+    kind: "record";
+    value: SchemaKindNode;
+} | {
+    kind: "union";
+    members: readonly SchemaKindNode[];
+} | {
+    kind: "branded";
+    inner: SchemaKindNode;
+}) & {
+    /** True if the schema accepts `null` (from `.nullable()` / `.optional()`). */
+    nullable?: boolean;
+    /** True if the schema has a `.default()`. */
+    hasDefault?: boolean;
+};
+/**
+ * Return the {@link SchemaKindNode} for a schema field. Prefers the
+ * explicit `_kind` discriminant set by the builder; falls back to
+ * parsing the freeform `_typeName` string for legacy / third-party
+ * builders that don't set `_kind`.
+ *
+ * @example
+ * ```ts
+ * getKind(t.number())              // → { kind: "number" }
+ * getKind(t.string().nullable())   // → { kind: "string", nullable: true }
+ * getKind(t.array(t.number()))     // → { kind: "array", element: { kind: "number" } }
+ * ```
+ */
+declare function getKind(schema: unknown): SchemaKindNode;
+/**
+ * Walk the `facts` block of a module schema and emit a flat map from
+ * dotted path → kind node. Nested `t.object()` shapes flatten using
+ * `.` as the separator, matching the convention used by
+ * `OperatorObject<V>`'s nested-path support.
+ *
+ * Passing a top-level schema directly (without the `facts:` wrapper)
+ * also works — anything iterable as `Record<string, ExtendedSchemaType>`
+ * is acceptable.
+ */
+declare function getSchemaFieldKinds(schema: unknown): Map<string, SchemaKindNode>;
+/**
+ * Return the set of `PredicateOp` strings that are valid against a
+ * given {@link SchemaKindNode}.
+ *
+ * Mirrors the type-level matrix encoded in `OperatorObject<V>` in
+ * `types/predicate.ts` — drift between the two is enforced by the
+ * compile-time conformance test
+ * (`schema-introspection-conformance.test-d.ts`).
+ *
+ * - **Common to all kinds:** `$eq`, `$ne`, `$in`, `$nin`, `$exists`
+ * - **Orderable (`number`/`string`/`bigint`/`date`):** + `$gt`, `$gte`,
+ *   `$lt`, `$lte`, `$between`
+ * - **String-specific:** + `$matches`, `$startsWith`, `$endsWith`, `$contains`
+ * - **Array:** + `$contains` (over the element type)
+ * - **Union:** *intersection* across members (the operand must be valid
+ *   for every branch).
+ * - **Branded:** delegates to the inner kind.
+ * - **Literal / Enum:** operators of the primitive, with `$eq` / `$in`
+ *   operand restricted at the LLM-prompt layer (not enforced here).
+ *
+ * `nullable` does not change operator availability — `$gte` on a
+ * nullable number is fine on the non-null arm; `$exists` handles null.
+ */
+declare function getOperatorsForKind(node: SchemaKindNode): readonly PredicateOp[];
+/**
+ * Return all known predicate operators — convenience for prompt builders
+ * that need to show the LLM the full set.
+ */
+declare function listAllPredicateOperators(): readonly PredicateOp[];
+
 /**
  * Runtime for data-configuration predicates and templates.
  *
@@ -69,6 +194,57 @@ declare function isTemplate(v: unknown): v is FactTemplate;
  * ```
  */
 declare function validatePredicate(spec: unknown, path?: string): void;
+
+interface SchemaValidationError {
+    /** Dotted path to the failing clause (e.g. `cartTotal`, `auth.token.$gte`). */
+    readonly path: string;
+    /** The operator that failed (or the literal-equality marker `$eq`). */
+    readonly op: string;
+    /** The kind of the fact at this path, or `undefined` when the fact wasn't in the kind map. */
+    readonly kind?: SchemaKindNode;
+    /** The operators that ARE allowed for this fact's kind. */
+    readonly allowedOps?: readonly string[];
+    /** Human-readable failure reason (suitable for feeding back to an LLM). */
+    readonly reason: string;
+}
+interface SchemaValidationOptions {
+    /** Reject predicates with more than this many operator clauses (DoS guard). Default unbounded. */
+    readonly maxOperatorCount?: number;
+}
+type SchemaValidationResult = {
+    ok: true;
+    operatorCount: number;
+} | {
+    ok: false;
+    errors: readonly SchemaValidationError[];
+    operatorCount: number;
+};
+/**
+ * Cross-check an LLM-emitted (or otherwise externally-sourced) predicate
+ * against a schema's runtime kind map. Catches errors that
+ * {@link validatePredicate} cannot — operator-on-wrong-kind (`$gte` on a
+ * boolean fact), unknown fact paths, and (optionally) operator-count
+ * exhaustion DoS attempts.
+ *
+ * Pair with {@link validatePredicate} (structural / JSON safety) for full
+ * coverage. Use {@link getSchemaFieldKinds} to derive `kindMap` from a
+ * module schema.
+ *
+ * Designed for the LLM-emit retry loop: returns a list of errors with
+ * structured `{path, op, kind, allowedOps, reason}` rather than throwing,
+ * so the caller can feed the errors back to the model.
+ *
+ * @example
+ * ```ts
+ * const kindMap = getSchemaFieldKinds({ facts: { cartTotal: t.number(), active: t.boolean() } });
+ * const result = validatePredicateAgainstSchema(
+ *   { cartTotal: { $gte: 50 }, active: { $gte: true } },
+ *   kindMap,
+ * );
+ * // → { ok: false, errors: [{ path: "active", op: "$gte", reason: "..." }], operatorCount: 2 }
+ * ```
+ */
+declare function validatePredicateAgainstSchema(spec: unknown, kindMap: Map<string, SchemaKindNode>, opts?: SchemaValidationOptions): SchemaValidationResult;
 /**
  * Evaluate a {@link FactPredicate} against a fact scope. `prev` (a previous
  * snapshot) is consulted only by the `$changed` operator.
@@ -648,6 +824,163 @@ declare function diffRules(options: DiffRulesOptions): RulesDiffReport;
  */
 declare function diffClauses(before: unknown, after: unknown): Change[];
 
+/**
+ * predict() — "would this predicate fire against these facts, and if
+ * not, what facts must change to make it fire?"
+ *
+ * Closes the LLM-emit iteration loop: the model writes a rule,
+ * `predict()` says "this rule needs cartTotal ≥ 50 to fire; current
+ * value is 30," and the model rewrites accordingly. A predicate-aware
+ * preview that costs one walk of the predicate tree.
+ *
+ * Pure, sync, no engine dependency. Reuses `evaluatePredicateExplained`.
+ */
+
+interface PredictMissingChange {
+    /** Dotted path to the fact. */
+    readonly path: string;
+    /** The operator that failed. */
+    readonly op: string;
+    /** What the predicate expected. */
+    readonly expected: unknown;
+    /** What the fact currently is. */
+    readonly actual: unknown;
+    /** Human-readable hint suitable for feeding back to an LLM or showing to a user. */
+    readonly suggestion: string;
+}
+interface PredictResult<F> {
+    /** True iff the predicate would fire against `facts`. */
+    readonly wouldFire: boolean;
+    /** Full clause-by-clause result (reuses the whenExplain payload). */
+    readonly whenExplain: readonly ClauseResult[];
+    /**
+     * List of failing clauses, each with a `suggestion` describing the
+     * smallest concrete change to `facts` that would make that clause pass.
+     * Empty when `wouldFire === true`.
+     */
+    readonly missingChanges: readonly PredictMissingChange[];
+    /** Reference to the predicate evaluated, for telemetry. */
+    readonly predicate: FactPredicate<F>;
+}
+/**
+ * Run a predicate against the current fact state and report whether it
+ * would fire — *and if not, which facts must change*.
+ *
+ * Designed for the LLM-iteration loop and for "preview the impact of this
+ * rule" UIs.
+ *
+ * @example
+ * ```ts
+ * const predicate = { cartTotal: { $gte: 50 }, region: { $in: ["US", "EU"] } };
+ * const facts = { cartTotal: 30, region: "US" };
+ *
+ * predict(predicate, facts);
+ * // → {
+ * //     wouldFire: false,
+ * //     whenExplain: [ {path: "cartTotal", op: "$gte", pass: false, ...}, ... ],
+ * //     missingChanges: [
+ * //       { path: "cartTotal", op: "$gte", expected: 50, actual: 30,
+ * //         suggestion: "set cartTotal to at least 50 (currently 30)" },
+ * //     ],
+ * //     predicate: { cartTotal: { $gte: 50 }, region: { $in: ["US", "EU"] } },
+ * //   }
+ * ```
+ */
+declare function predict<F = Record<string, unknown>>(predicate: FactPredicate<F>, facts: F, prev?: F): PredictResult<F>;
+
+/**
+ * doctor — "this rule contradicts an existing rule" gate (v1 stub).
+ *
+ * Walks a candidate FactPredicate against an existing system's
+ * constraint set (via `system.inspect().constraints`), flagging:
+ *
+ *   - **direct contradiction:** same fact path, opposite-direction
+ *     comparison (`$gte 50` vs `$lt 50` — they cannot both fire).
+ *   - **subset:** candidate's range is a strict subset of an existing
+ *     constraint's range (candidate `$gte 100` when existing already
+ *     has `$gte 50`; the new rule never fires independently of the old).
+ *   - **overlap:** shares ≥1 fact path with non-trivial intersection —
+ *     a warning, not a hard error.
+ *
+ * Pairs with `predicateFromIntent`: an LLM-emitted predicate can be
+ * doctor-checked before assignment, and contradictions fed back into
+ * the LLM's retry prompt.
+ *
+ * This is a **structural** v1. Full SMT-lite (Z3.wasm) is deferred to
+ * a dedicated R4.B sprint; the primitive of "doctor says no" is what
+ * this slice ships. False negatives are acceptable (no contradiction
+ * reported when one exists in semantics that the structural checker
+ * can't see). False positives (contradiction reported where none
+ * exists) are NOT acceptable — every reported contradiction must be
+ * defensible.
+ *
+ * Pure, sync, no engine dependency.
+ */
+
+type ContradictionType = "direct" | "subset" | "overlap";
+interface Contradiction {
+    /** ID of the existing constraint that conflicts with the candidate. */
+    readonly constraintId: string;
+    /** Type of contradiction detected. */
+    readonly type: ContradictionType;
+    /** Human-readable explanation, suitable for showing to a user or LLM. */
+    readonly reason: string;
+    /** Path on the candidate predicate that triggered the finding. */
+    readonly candidatePath?: string;
+    /** Operator + value on the candidate side. */
+    readonly candidate?: {
+        op: string;
+        value: unknown;
+    };
+    /** Operator + value on the existing side. */
+    readonly existing?: {
+        op: string;
+        value: unknown;
+    };
+}
+interface CheckAgainstResult {
+    /** Hard contradictions — candidate never co-fires with existing rule. */
+    readonly contradictions: readonly Contradiction[];
+    /** Soft overlaps — shared facts with non-trivial intersection. */
+    readonly warnings: readonly Contradiction[];
+}
+/** Shape of `system.inspect().constraints[N]` we care about — accepts any superset. */
+interface ExistingConstraint {
+    readonly id: string;
+    readonly whenSpec?: unknown;
+}
+declare const doctor: {
+    /**
+     * Check a candidate predicate against existing constraints. Returns
+     * contradictions (hard) + warnings (soft overlaps).
+     *
+     * @param candidate - The proposed predicate (typically LLM-emitted).
+     * @param existing  - Either `system.inspect().constraints` directly,
+     *                    or any array of `{ id, whenSpec? }` shapes.
+     *                    Constraints without `whenSpec` (function-form
+     *                    `when:`) are skipped — they're opaque to us.
+     *
+     * @example
+     * ```ts
+     * const candidate = { cartTotal: { $gte: 100 } };
+     * const report = doctor.checkAgainst(
+     *   candidate,
+     *   system.inspect().constraints,
+     * );
+     * // → {
+     * //     contradictions: [
+     * //       { constraintId: "freeShipping", type: "subset",
+     * //         reason: "Candidate's lower bound on cartTotal..." }
+     * //     ],
+     * //     warnings: []
+     * //   }
+     * ```
+     */
+    checkAgainst<F = Record<string, unknown>>(candidate: FactPredicate<F>, existing: readonly ExistingConstraint[] | {
+        constraints: readonly ExistingConstraint[];
+    }): CheckAgainstResult;
+};
+
 /**
  * Compile a `FactPredicate` to a parameterized Postgres-style SQL WHERE
  * clause. The same predicate that gates a constraint on the client can
@@ -835,6 +1168,13 @@ interface ExtendedSchemaType<T> extends SchemaType<T> {
     _lastFailedIndex?: number;
     /** Optional metadata for debugging and devtools (never read on hot path). */
     readonly _meta?: DefinitionMeta;
+    /**
+     * Structured kind discriminant used by introspection-time consumers
+     * (`predicateFromIntent`, `doctor`, `predicateToZod`). Optional for
+     * back-compat with legacy / third-party builders; when absent, the
+     * introspection layer parses `_typeName` instead.
+     */
+    readonly _kind?: SchemaKindNode;
 }
 /** Chainable schema type with all common methods */
 interface ChainableSchemaType<T> extends ExtendedSchemaType<T> {
@@ -2075,4 +2415,4 @@ declare const Backoff: {
     readonly Exponential: "exponential";
 };
 
-export { Backoff, type Branded, type ChainableSchemaType, type Change, type ChangeKind, ClauseResult, type ConstraintDiff, type ConstraintStatus, CreateSystemOptionsNamed, CreateSystemOptionsSingle, CrossModuleDeps, DefinitionMeta, type DiffRulesOptions, ErrorBoundaryConfig, type ExtendedSchemaType, FactPredicate, FactTemplate, Facts, type LeafClause, MAX_REPLAY_FRAMES, MAX_SWEEP_POINTS, type ModuleConfig, type ModuleConfigWithDeps, ModuleDef, ModuleHooks, ModuleSchema, ModulesMap, NamespacedSystem, PatchSpec, Plugin, type PredicateBacktestReport, type PredicateToMongoOptions, type PredicateToPostgrestOptions, type PredicateToSqlOptions, type PredicateToSqlResult, type ReplayDiffSample, type ReplayFrame, type ReplayUnderOptions, Requirement, RequirementSet, type RequirementTypeStatus, RequirementWithId, type RulesDiffReport, type RulesMapInput, SchemaType, type SignalClock, SingleModuleSystem, type SweepHole, type SweepPoint, type SweepReport, type SweepUnderOptions, type TimerFactOpts, type TimerFactState, TraceOption, applyPatch, completeTimer, createModule, createModuleFactory, createRequirementStatusPlugin, createStatusHook, createSystem, createSystemWithStatus, defaultClock, diffClauses, diffRules, elapsedMs, evaluateKeySelector, evaluatePredicate, evaluatePredicateExplained, evaluateTemplate, extractDeps, extractTemplateKeys, flattenPredicate, forType, framesFromHistory, framesFromSnapshots, generateRequirementId, initialTimerState, isPredicate, isRequirementType, isTemplate, memoizePredicate, pauseTimer, predicateToMongo, predicateToPostgrest, predicateToSQL, predicateToWhere, realClock, registerRepeat, remainingMs, replayUnder, req, resetTimer, resumeTimer, startTimer, sweepUnder, t, tickTimer, timerOps, toReplayFrames, toRulesMap, validatePredicate, virtualClock };
+export { Backoff, type Branded, type ChainableSchemaType, type Change, type ChangeKind, type CheckAgainstResult, ClauseResult, type ConstraintDiff, type ConstraintStatus, type Contradiction, type ContradictionType, CreateSystemOptionsNamed, CreateSystemOptionsSingle, CrossModuleDeps, DefinitionMeta, type DiffRulesOptions, ErrorBoundaryConfig, type ExistingConstraint, type ExtendedSchemaType, FactPredicate, FactTemplate, Facts, type LeafClause, MAX_REPLAY_FRAMES, MAX_SWEEP_POINTS, type ModuleConfig, type ModuleConfigWithDeps, ModuleDef, ModuleHooks, ModuleSchema, ModulesMap, NamespacedSystem, PatchSpec, Plugin, type PredicateBacktestReport, PredicateOp, type PredicateToMongoOptions, type PredicateToPostgrestOptions, type PredicateToSqlOptions, type PredicateToSqlResult, type PredictMissingChange, type PredictResult, type ReplayDiffSample, type ReplayFrame, type ReplayUnderOptions, Requirement, RequirementSet, type RequirementTypeStatus, RequirementWithId, type RulesDiffReport, type RulesMapInput, type SchemaKind, type SchemaKindNode, SchemaType, type SchemaValidationError, type SchemaValidationOptions, type SchemaValidationResult, type SignalClock, SingleModuleSystem, type SweepHole, type SweepPoint, type SweepReport, type SweepUnderOptions, type TimerFactOpts, type TimerFactState, TraceOption, applyPatch, completeTimer, createModule, createModuleFactory, createRequirementStatusPlugin, createStatusHook, createSystem, createSystemWithStatus, defaultClock, diffClauses, diffRules, doctor, elapsedMs, evaluateKeySelector, evaluatePredicate, evaluatePredicateExplained, evaluateTemplate, extractDeps, extractTemplateKeys, flattenPredicate, forType, framesFromHistory, framesFromSnapshots, generateRequirementId, getKind, getOperatorsForKind, getSchemaFieldKinds, initialTimerState, isPredicate, isRequirementType, isTemplate, listAllPredicateOperators, memoizePredicate, pauseTimer, predicateToMongo, predicateToPostgrest, predicateToSQL, predicateToWhere, predict, realClock, registerRepeat, remainingMs, replayUnder, req, resetTimer, resumeTimer, startTimer, sweepUnder, t, tickTimer, timerOps, toReplayFrames, toRulesMap, validatePredicate, validatePredicateAgainstSchema, virtualClock };