@directive-run/core 1.21.0 → 1.23.0

package/dist/{plugins-4IfhJV32.d.cts → plugins-CaPMTICa.d.cts}

@@ -568,26 +568,29 @@ interface ConstraintDef<S extends Schema, R extends Requirement = Requirement> {
     /** Timeout for async constraints (ms) */
     timeout?: number;
     /**
-     * Fact keys whose **value the resolver compare-and-swaps**. Writes to
-     * these facts land only if they still hold the snapshot value taken at
-     * resolver dispatch; otherwise the write is dropped and the resolver
-     * aborted.
+     * Fact keys this resolver **aborts on** when they change mid-flight.
+     * The engine snapshots their values at resolver dispatch; if any of
+     * them changes before the resolver writes, the resolver's writes are
+     * dropped and the resolver aborted.
      *
-     * This is value-based per-fact compare-and-swap with one-shot
-     * fact-level poisoning — not a lock, not document versioning. Writes
-     * to facts not listed always land; `when()` is not consulted. Omit for
-     * no binding (default). Ignored on async constraints.
+     * Reads aloud as "abort on changes to these facts." This is the
+     * opposite shape of a lock — the resolver yields to whoever wrote
+     * first; it does NOT prevent other writers. Value-based per-fact
+     * compare-and-swap with one-shot fact-level poisoning, not document
+     * versioning. Writes to facts not listed always land; `when()` is not
+     * consulted. Omit for no binding (default). Ignored on async
+     * constraints.
      *
      * @example
      * ```ts
      * executeAction: {
      *   when: (f) => f.status === 'mutating',
      *   require: { type: 'EXECUTE_ACTION' },
-     *   owns: ['status'], // the resolver owns `status`
+     *   abortOn: ['status'], // abort if `status` changes mid-flight
      * }
      * ```
      */
-    owns?: readonly string[];
+    abortOn?: readonly string[];
     /**
      * Constraint IDs whose resolvers must complete before this constraint is evaluated.
      * If a dependency's `when()` returns false (no requirements), this constraint proceeds.
@@ -1072,6 +1075,60 @@ type EventsDef<S extends Schema> = Record<string, FlexibleEventHandler<S>>;
 type JitterStrategy = "none" | "full" | "equal" | {
     maxMs: number;
 };
+/**
+ * Why a resolver attempt was aborted, surfaced to {@link RetryPolicy.shouldRetry}
+ * so the policy can distinguish "retry on race-loss" from "fail loud on bug."
+ *
+ * - `"clobbered"` — an `abortOn`-listed fact was written by something
+ *   outside the resolver between the resolver's baseline read and its
+ *   next write (RFC 0003 optimistic-concurrency check). The retry is
+ *   typically safe — the resolver re-reads the current value and tries
+ *   again with fresh context.
+ * - `"timeout"` — the resolver's `timeout` ms elapsed. Retrying may
+ *   succeed if the underlying I/O was just slow; may fail again if the
+ *   timeout is set too tight for the workload.
+ * - `"cancelled"` — `system.stop()` was called, or external code aborted
+ *   the resolver's `ctx.signal`. Retrying is almost always wrong — the
+ *   cancellation was the caller's explicit intent.
+ * - `"error"` — the resolver threw. Default for back-compat: any abort
+ *   without a more specific reason maps here.
+ *
+ * Core has no supersession concept today; if a future package wants to
+ * surface supersession, it can widen the union additively without
+ * breaking back-compat.
+ *
+ * @public
+ */
+type ResolverAbortReason = "clobbered" | "timeout" | "cancelled" | "error";
+/**
+ * Context object passed as the optional third argument to
+ * {@link RetryPolicy.shouldRetry}. Lets the policy decide based on WHY
+ * the attempt failed — not just the thrown error.
+ *
+ * Two-argument `shouldRetry(error, attempt)` continues to work; the
+ * context argument is additive. Existing callers see no behavior change.
+ *
+ * @public
+ */
+interface ShouldRetryContext {
+    /**
+     * Why the attempt was aborted. Undefined when the engine couldn't
+     * classify the cause (very rare — defaults to `"error"` in practice).
+     */
+    reason?: ResolverAbortReason;
+    /**
+     * Populated only when `reason === "clobbered"`. Names the `abortOn`
+     * fact whose mid-flight change tripped the binding, plus the expected
+     * baseline value and the actual current value. Useful for
+     * `shouldRetry: (_, _, ctx) => ctx?.clobber?.fact === "cart.discount"`
+     * patterns that only retry contention on specific facts.
+     */
+    clobber?: {
+        fact: string;
+        expected: unknown;
+        actual: unknown;
+    };
+}
 /** Retry policy configuration */
 interface RetryPolicy {
     /** Maximum number of attempts */
@@ -1098,10 +1155,24 @@ interface RetryPolicy {
      * Return `true` to retry, `false` to stop immediately.
      * If omitted, all errors are retried (up to `attempts`).
      *
+     * The optional third `context` argument carries the abort reason and,
+     * for clobbers, the fact + expected/actual values. Existing two-arg
+     * callers continue to work — the third arg is undefined when omitted.
+     *
+     * @example Retry on contention, fail loud on bug
+     * ```ts
+     * shouldRetry: (err, attempt, ctx) => {
+     *   if (ctx?.reason === "clobbered") return attempt < 5;
+     *   if (ctx?.reason === "timeout") return attempt < 2;
+     *   return false; // "error" / "cancelled" → don't retry
+     * }
+     * ```
+     *
      * @param error - The error that occurred
      * @param attempt - The attempt number that just failed (1-based)
+     * @param context - Optional abort context (added v1.23.0); undefined for callers that don't pass it
      */
-    shouldRetry?: (error: Error, attempt: number) => boolean;
+    shouldRetry?: (error: Error, attempt: number, context?: ShouldRetryContext) => boolean;
 }
 /** Batch configuration */
 interface BatchConfig {
@@ -1312,6 +1383,128 @@ type ResolverStatus = {
     canceledAt: number;
 };
 
+/**
+ * Structural diff between two snapshots of a system's constraint `whenSpec`
+ * map. The "git diff for business rules" — operates on the predicate AST
+ * instead of source-text lines.
+ *
+ * A predicate is a tree of leaf clauses (`{ fact: operator(value) }`) and
+ * combinators (`$all` / `$any` / `$not`). `diffRules` flattens both trees
+ * into path-keyed leaf lists and compares: missing path → added/removed,
+ * same path with different operand → changed (with relaxed/tightened
+ * classification for numeric thresholds).
+ *
+ * Pure module — imports only utils. No engine / store / predicate-runtime
+ * dependency: predicates are walked as plain JSON.
+ */
+/** A leaf clause extracted from a predicate tree, keyed by its dotted path. */
+interface LeafClause {
+    /** Dotted path through the predicate. E.g. `phase`, `$all[0].elapsed`, `$not.paused`. */
+    path: string;
+    /** Operator name. `$eq` is implied for bare-value equality. */
+    op: string;
+    /** Operand. */
+    value: unknown;
+}
+/** Kind of change observed for a single clause. */
+type ChangeKind = "added" | "removed" | "changed" | "relaxed" | "tightened";
+/** A single change between two predicates at a specific path. */
+interface Change {
+    path: string;
+    kind: ChangeKind;
+    before?: {
+        op: string;
+        value: unknown;
+    };
+    after?: {
+        op: string;
+        value: unknown;
+    };
+}
+/** Status of a single constraint across the two snapshots. */
+type ConstraintStatus = "added" | "removed" | "changed" | "unchanged";
+interface ConstraintDiff {
+    id: string;
+    status: ConstraintStatus;
+    /** Empty for `unchanged`. For `added` / `removed`, every leaf is listed once. */
+    changes: Change[];
+}
+interface RulesDiffReport {
+    constraints: ConstraintDiff[];
+    summary: {
+        added: number;
+        removed: number;
+        changed: number;
+        unchanged: number;
+        totalClauseChanges: number;
+    };
+}
+interface DiffRulesOptions {
+    before: RulesMapInput;
+    after: RulesMapInput;
+}
+/**
+ * Accepted shapes for the `before` / `after` predicate maps:
+ *   - A plain map `{ [constraintId]: whenSpec }`
+ *   - The `system.inspect().constraints` array form `Array<{ id, whenSpec? }>`
+ *   - Either wrapped as `{ constraints: <one-of-the-above> }`
+ *
+ * Anything else throws at `toRulesMap` so a bad input fails loud.
+ */
+type RulesMapInput = unknown;
+/**
+ * Coerce supported input shapes into a flat `Record<constraintId, whenSpec>`.
+ * Constraints without a `whenSpec` (function-form `when`) are dropped with
+ * an undefined entry so callers can distinguish them from absent constraints
+ * if they care; the diff treats `undefined` as "no data" and skips clause
+ * walking.
+ */
+declare function toRulesMap(raw: RulesMapInput): Record<string, unknown>;
+/**
+ * Walk a predicate tree and emit every leaf clause with its dotted path.
+ * Combinators (`$all` / `$any` / `$not`) become indexed path segments.
+ * Bare-value equality (`{ phase: "red" }`) emits as `op: "$eq"`.
+ *
+ * Array-form predicates (`[{ fact, op, value }, ...]`) are also accepted —
+ * each clause's `fact` becomes the path, the operator is `op`, and the
+ * value is `value`.
+ *
+ * **What gets dropped:** non-object combinator children (e.g. `$not: "red"`
+ * with a string operand instead of a predicate object), function-form
+ * predicates (the engine accepts a function for `when`; this walker only
+ * sees data), and bare primitive predicates (a top-level `true` or `"x"`).
+ * The walker is a tree visitor — anything not shaped like a predicate node
+ * is silently skipped, never thrown on.
+ */
+declare function flattenPredicate(spec: unknown, pathPrefix?: string, out?: LeafClause[]): LeafClause[];
+/**
+ * Diff two snapshots of a system's constraint whenSpec map.
+ *
+ * @example
+ * ```ts
+ * const report = diffRules({
+ *   before: { blockCheckout: { cartTotal: { $gte: 100 } } },
+ *   after:  { blockCheckout: { cartTotal: { $gte: 50 } } },
+ * });
+ *
+ * report.constraints[0].status;          // "changed"
+ * report.constraints[0].changes[0].kind; // "relaxed"
+ * report.summary.totalClauseChanges;     // 1
+ * ```
+ *
+ * The input shape is forgiving — either a flat `{ id: whenSpec }` map, the
+ * `system.inspect().constraints` array form, or either wrapped as
+ * `{ constraints: ... }`. Constraints whose `when` is a function (no
+ * `whenSpec`) are tracked as added/removed but cannot be clause-diffed
+ * (the function form is opaque).
+ */
+declare function diffRules(options: DiffRulesOptions): RulesDiffReport;
+/**
+ * Diff two predicate trees and return the list of leaf-level changes.
+ * Exported for reuse beyond the full per-constraint report.
+ */
+declare function diffClauses(before: unknown, after: unknown): Change[];
+
 /**
  * Error Types - Type definitions for error handling
  */
@@ -2172,12 +2365,13 @@ interface TypedConstraintDef<M extends ModuleSchema> {
     /** Timeout for async constraints (ms) */
     timeout?: number;
     /**
-     * Fact keys whose **value the resolver compare-and-swaps**. Writes to
-     * these facts land only if they still hold the snapshot value taken at
-     * resolver dispatch; otherwise the write is dropped and the resolver
-     * aborted. Omit for no binding (default). Ignored on async constraints.
+     * Fact keys this resolver aborts on when they change mid-flight. The
+     * engine snapshots their values at resolver dispatch; if any of them
+     * changes before the resolver writes, the resolver's writes are
+     * dropped and the resolver aborted. Omit for no binding (default).
+     * Ignored on async constraints.
      */
-    owns?: readonly string[];
+    abortOn?: readonly string[];
     /**
      * Constraint IDs whose resolvers must complete before this constraint is evaluated.
      * If a dependency's `when()` returns false (no requirements), this constraint proceeds.
@@ -2223,12 +2417,13 @@ interface CrossModuleConstraintDef<M extends ModuleSchema, Deps extends CrossMod
     /** Timeout for async constraints (ms) */
     timeout?: number;
     /**
-     * Fact keys whose **value the resolver compare-and-swaps**. Writes to
-     * these facts land only if they still hold the snapshot value taken at
-     * resolver dispatch; otherwise the write is dropped and the resolver
-     * aborted. Omit for no binding (default). Ignored on async constraints.
+     * Fact keys this resolver aborts on when they change mid-flight. The
+     * engine snapshots their values at resolver dispatch; if any of them
+     * changes before the resolver writes, the resolver's writes are
+     * dropped and the resolver aborted. Omit for no binding (default).
+     * Ignored on async constraints.
      */
-    owns?: readonly string[];
+    abortOn?: readonly string[];
     /**
      * Constraint IDs whose resolvers must complete before this constraint is evaluated.
      * If a dependency's `when()` returns false (no requirements), this constraint proceeds.
@@ -2644,16 +2839,17 @@ interface SystemInspection {
          */
         whenSpec?: FactPredicate<Record<string, unknown>>;
         /**
-         * Owned-fact list for RFC-0003 binding. Populated from the
-         * constraint definition's `owns:` field. Exposed for `doctor.checkOwns()`
-         * so it can flag candidates that would race or shadow these writes.
-         * Absent when the constraint declares no `owns`.
+         * Abort-binding fact list for RFC-0003 constraint binding. Populated
+         * from the constraint definition's `abortOn:` field. Exposed for
+         * `doctor.checkAbortOn()` so it can flag candidates that would race
+         * or shadow these writes. Absent when the constraint declares no
+         * `abortOn`.
          */
-        readonly owns?: readonly string[];
+        readonly abortOn?: readonly string[];
         /**
          * Fact paths the constraint `bind:`s to. v2 promise — the runtime
          * does not yet emit a `bind` field on inspect snapshots, but the
-         * type slot is reserved so `doctor.checkOwns()` is stable across
+         * type slot is reserved so `doctor.checkAbortOn()` is stable across
          * the rollout. (F1)
          */
         readonly bind?: readonly string[];
@@ -3071,6 +3267,46 @@ interface MetaAccessor {
     /** Find all definitions matching a tag across all types. */
     byTag(tag: string): MetaMatch[];
 }
+/**
+ * Discriminated proof of why two resolvers' `when:` predicates fire on
+ * the same state — attached to `resolver.clobber.loop.detected` events
+ * so the warning can point at the specific clauses that co-fire instead
+ * of stopping at "these resolvers fight."
+ *
+ * - `matched` — both predicates have identical structural clauses.
+ *   The strongest verdict; the rules are syntactic duplicates.
+ * - `overlap` — clauses share at least one path and at least one
+ *   pairwise comparison says they co-fire (with no direct
+ *   contradictions). Strong verdict, slightly weaker than `matched`.
+ * - `indeterminate` — a non-COMPARABLE operator (`$regex`, `$elemMatch`,
+ *   `$matches`, custom) appeared. The proof builder declines to assert
+ *   overlap; the message says so explicitly rather than falsely
+ *   reporting a contradiction.
+ * - `function-form-opaque` — at least one constraint uses a function
+ *   `when:` (`(facts) => ...`), so structural comparison is impossible.
+ *   The warning text disclaims; if audit-ledger is mounted and its
+ *   `whenSourceCache` is available, identifying hashes of the function
+ *   source are included for cross-version diffing.
+ *
+ * @public
+ */
+type PredicateOverlapProof = {
+    verdict: "matched";
+    coFireClauses: readonly LeafClause[];
+    conflictingClauses: readonly never[];
+} | {
+    verdict: "overlap";
+    coFireClauses: readonly LeafClause[];
+    conflictingClauses: readonly LeafClause[];
+} | {
+    verdict: "indeterminate";
+    reason: "non-comparable-operator";
+    coFireClauses: readonly LeafClause[];
+} | {
+    verdict: "function-form-opaque";
+    reason: "one-or-both-when-is-a-function";
+    whenSourceHashes?: readonly string[];
+};
 /** Typed events emitted by system.observe(). */
 type ObservationEvent = {
     type: "fact.change";
@@ -3090,6 +3326,26 @@ type ObservationEvent = {
     type: "constraint.error";
     id: string;
     error: unknown;
+}
+/**
+ * Fired when the engine silently disables a constraint's `abortOn:`
+ * binding because the constraint is async (declared `async: true` OR
+ * runtime-promoted because its `when()` returned a Promise). The
+ * dev-mode `console.warn` is the human-facing signal; this event is
+ * the SIEM-facing one. Without it, a production constraint loses its
+ * clobber-protection with no plugin / observer trail.
+ *
+ * - `reason: "async-declared"` — the constraint def has `async: true`.
+ *   The author opted in; the warning + event are advisory.
+ * - `reason: "async-promoted"` — the constraint's `when()` returned
+ *   a Promise at runtime. The author probably did not realize. This
+ *   is the more dangerous case — the binding silently disables and
+ *   the clobber check no-ops.
+ */
+ | {
+    type: "constraint.binding.disabled";
+    id: string;
+    reason: "async-declared" | "async-promoted";
 } | {
     type: "requirement.created";
     id: string;
@@ -3117,7 +3373,7 @@ type ObservationEvent = {
     error: unknown;
 } | {
     /**
-     * A real per-write rejection. A bound resolver's owned-fact write was
+     * A real per-write rejection. A bound resolver's abort-bound write was
      * dropped because the fact was changed by something outside the
      * resolver between the resolver's baseline and its next write (RFC-0003
      * optimistic-concurrency check). `reason` keeps the observation protocol
@@ -3162,6 +3418,52 @@ type ObservationEvent = {
     requirementId: string;
     reason: "clobbered";
     dropped: number;
+}
+/**
+ * v1.23.0 — fires when `clobberLoopPlugin` detects a sustained pattern
+ * of clobbers on a fact involving the same set of resolvers above
+ * threshold within a time window. A single clobber is fine; the
+ * binding catches the race and the audit ledger records it. A *loop*
+ * is two or more resolvers whose `when:` predicates both satisfy a
+ * shared state and rewrite the fact every reconcile tick.
+ *
+ * `participants` is the unordered, distinct set of resolver IDs
+ * contributing to the loop. `predicateOverlap` (when both sides use a
+ * data-form `when:`) explains WHY the loop occurs — which clauses
+ * co-fire — so the suggested fix (add `priority:`, narrow `when:`,
+ * merge) is grounded in the actual rules, not a guess.
+ */
+ | {
+    type: "resolver.clobber.loop.detected";
+    systemId: string;
+    fact: string;
+    participants: readonly string[];
+    participantModules: readonly string[];
+    count: number;
+    windowMs: number;
+    firstAt: number;
+    lastAt: number;
+    predicateOverlap?: PredicateOverlapProof;
+    severity: "warn" | "error";
+    factTags: readonly string[];
+    suppressedSinceLastEmit: number;
+    rejectionSeqs: readonly number[];
+}
+/**
+ * v1.23.0 — fires when a previously-detected clobber loop closes
+ * cleanly, so dashboards can show "5 active loops" not "47
+ * historical loops". A loop is considered resolved when the
+ * `(fact, participantSet)` goes a quiet window without further
+ * `resolver.write.rejected` events, OR a participant is unregistered,
+ * OR a constraint re-registration changes a participant's `whenSpec`.
+ */
+ | {
+    type: "resolver.clobber.loop.resolved";
+    systemId: string;
+    fact: string;
+    participants: readonly string[];
+    durationMs: number;
+    resolution: "no-recurrence-in-window" | "participant-disabled" | "predicate-narrowed";
 } | {
     type: "effect.run";
     id: string;
@@ -3349,6 +3651,31 @@ interface System<M extends ModuleSchema = ModuleSchema> {
      */
     readonly notify: {
         guardrailBlocked(plugin: string, key: string, kind: "redact" | "alert" | "detect", count: number, category?: string): void;
+        /**
+         * v1.23.0 — plugin authoring surface for emitting the
+         * `"resolver.clobber.loop.detected"` ObservationEvent. Used by
+         * `clobberLoopPlugin` (and any compatible third-party detector). The
+         * call fans out to all registered plugins' `onClobberLoopDetected`
+         * hooks (including the synthetic plugins that back `system.observe()`)
+         * so audit-ledger, devtools, and OTel exporters capture the event
+         * without taking a dependency on the originating detector.
+         *
+         * Application code should never call this directly — use
+         * `system.observe()` to subscribe.
+         */
+        clobberLoopDetected(event: ObservationEvent & {
+            type: "resolver.clobber.loop.detected";
+        }): void;
+        /**
+         * v1.23.0 — companion to {@link clobberLoopDetected}. Fires when a
+         * previously-detected loop is considered resolved (quiet window
+         * elapsed, participant unregistered, or predicate narrowed). Lets
+         * monitoring dashboards show "active loops" rather than
+         * "historical loops."
+         */
+        clobberLoopResolved(event: ObservationEvent & {
+            type: "resolver.clobber.loop.resolved";
+        }): void;
     };
     /** Per-run trace entries (null if trace is not enabled) */
     readonly trace: TraceEntry[] | null;
@@ -3639,6 +3966,27 @@ interface Plugin<M extends ModuleSchema = ModuleSchema> {
      * @param error - The error that was thrown
      */
     onConstraintError?: (id: string, error: unknown) => void;
+    /**
+     * Called when the engine silently disables a constraint's `abortOn:`
+     * binding because the constraint is async. Pairs with the dev-mode
+     * `console.warn` for SIEM-side visibility — without this signal, a
+     * production constraint loses its clobber-protection with no
+     * plugin / observer trail.
+     *
+     * - `"async-declared"` — the constraint def has `async: true`. The
+     *   author opted in; treat as advisory.
+     * - `"async-promoted"` — the constraint's `when()` returned a Promise
+     *   at runtime, even though `async: true` was not set. The author
+     *   probably did not realize. This is the dangerous case — escalate.
+     *
+     * Fired at most once per `getConstraintBinding` lookup; deduping
+     * across reconcile ticks is the consumer's responsibility (the
+     * audit-ledger plugin does this with a per-id sticky bit).
+     *
+     * @param id - The constraint ID whose binding was disabled
+     * @param reason - Whether the async state was author-declared or runtime-promoted
+     */
+    onConstraintBindingDisabled?: (id: string, reason: "async-declared" | "async-promoted") => void;
     /**
      * Called when a new requirement is created by a constraint.
      * @param req - The requirement with its computed ID
@@ -3691,8 +4039,9 @@ interface Plugin<M extends ModuleSchema = ModuleSchema> {
     /**
      * Called when a resolver's write is rejected by the runtime. The only
      * `reason` today is `"clobbered"`: a bound resolver (RFC-0003) dropped a
-     * write to an owned fact because the fact was changed by something outside
-     * the resolver between the resolver's baseline and its next write — the
+     * write to an abort-bound fact (one listed in the constraint's
+     * `abortOn:`) because the fact was changed by something outside the
+     * resolver between the resolver's baseline and its next write — the
      * resolver's `AbortController` is aborted in the same step. See
      * {@link createBoundFacts} for the per-fact optimistic-concurrency model.
      * `reason` keeps the hook backend-neutral.
@@ -3826,6 +4175,26 @@ interface Plugin<M extends ModuleSchema = ModuleSchema> {
      *   payloads.
      */
     onGuardrailBlocked?: (plugin: string, key: string, kind: "redact" | "alert" | "detect", count: number, category?: string) => void;
+    /**
+     * Called when `clobberLoopPlugin` (or any equivalent detector) publishes
+     * a structured loop event through `system.notify.clobberLoopDetected(...)`.
+     * Surfaces as the `"resolver.clobber.loop.detected"` `ObservationEvent`
+     * for `system.observe()` subscribers + audit-ledger + devtools, so
+     * downstream backends can capture loops without taking a direct
+     * dependency on `clobberLoopPlugin`.
+     */
+    onClobberLoopDetected?: (event: ObservationEvent & {
+        type: "resolver.clobber.loop.detected";
+    }) => void;
+    /**
+     * Called when a previously-detected loop is considered resolved (quiet
+     * window elapsed, participant unregistered, or predicate narrowed).
+     * Pairs with `onClobberLoopDetected` so dashboards can show "active
+     * loops" rather than "historical loops."
+     */
+    onClobberLoopResolved?: (event: ObservationEvent & {
+        type: "resolver.clobber.loop.resolved";
+    }) => void;
     /**
      * Called when a history snapshot is taken.
      * @param snapshot - The snapshot that was captured
@@ -3884,4 +4253,4 @@ interface Plugin<M extends ModuleSchema = ModuleSchema> {
     onTraceComplete?: (entry: TraceEntry) => void;
 }
 
-export { type InferSchemaType as $, type AnySystem as A, type BatchConfig as B, type ClauseResult as C, type DefinitionMeta as D, type EffectsDef as E, type FactPredicate as F, type DynamicConstraintDef as G, type DynamicEffectDef as H, type DynamicResolverDef as I, type EffectDef as J, type EventsDef as K, type FactTemplate as L, type ModuleSchema as M, type NamespacedSystem as N, type FactsSnapshot as O, type Plugin as P, type HistoryAPI as Q, type RequirementWithId as R, type SchemaType as S, type TypedDerivationsDef as T, type HistoryOption as U, type HistoryState as V, type InferDerivations as W, type InferEvents as X, type InferFacts as Y, type InferRequirementTypes as Z, type InferRequirements as _, type Facts as a, type FactReturnType as a$, type InferSelectorState as a0, type KeySelector as a1, type MetaAccessor as a2, type MetaMatch as a3, type ObservationEvent as a4, type OperatorObject as a5, type PatchSpec as a6, type PatchValue as a7, type PayloadRef as a8, type PredicateClause as a9, isSingleModuleSystem as aA, type FactsStore as aB, type ConstraintState as aC, type ResolverStatus as aD, type FactChange as aE, type ReconcileResult as aF, type RecoveryStrategy as aG, type ErrorSource as aH, type RetryLaterConfig as aI, type BatchItemResult as aJ, type BatchResolveResults as aK, type ConstraintsControl as aL, type CrossModuleDerivationFn as aM, type CrossModuleFactsWithSelf as aN, type DerivationKeys as aO, type DerivationReturnType as aP, type DerivationsControl as aQ, type DerivationsSchema as aR, type DeriveAccessor as aS, type DispatchEventsFromSchema as aT, type EffectCleanup as aU, type EffectsControl as aV, type EventPayloadSchema as aW, type EventsAccessor as aX, type EventsAccessorFromSchema as aY, type EventsSchema as aZ, type FactKeys as a_, type PredicateCombinator as aa, type PredicateCombinatorKey as ab, type PredicateObject as ac, type PredicateOp as ad, type ResolverDef as ae, type ResolversDef as af, type RetryPolicy as ag, type Schema as ah, type SchemaTypedResolversDef as ai, type Snapshot as aj, type SourceDef as ak, type SourceDropReason as al, type SourcePublish as am, type SourceReportError as an, type SourceUnsubscribe as ao, type System as ap, type SystemConfig as aq, type SystemDerived as ar, type SystemFacts as as, type SystemInspection as at, type SystemMode as au, type SystemSnapshot as av, type TraceEntry as aw, type TypedConstraintDef as ax, type TypedResolverDef as ay, isNamespacedSystem as az, type TypedEventsDef as b, type FlexibleEventHandler as b0, type HistoryConfig as b1, type InferEventPayloadFromSchema as b2, type InferRequirementPayloadFromSchema as b3, type InferSchema as b4, type MutableNamespacedFacts as b5, type NamespacedDerivations as b6, type NamespacedEventsAccessor as b7, type NamespacedFacts as b8, type ObservableKeys as b9, type RequirementExplanation as ba, type RequirementOutput as bb, type RequirementPayloadSchema$1 as bc, type RequirementsSchema as bd, type ResolverContext as be, type ResolversControl as bf, type SnapshotMeta as bg, type SystemEvent as bh, type TraceConfig as bi, type TypedResolverContext as bj, type UnionEvents as bk, type RequirementOutput$1 as bl, type SourcesDef as c, type TypedConstraintsDef as d, type TypedResolversDef as e, type ModuleHooks as f, type CrossModuleDeps as g, type CrossModuleDerivationsDef as h, type CrossModuleEffectsDef as i, type CrossModuleConstraintsDef as j, type ModuleDef as k, type CreateSystemOptionsSingle as l, type SingleModuleSystem as m, type ModulesMap as n, type CreateSystemOptionsNamed as o, type TraceOption as p, type ErrorBoundaryConfig as q, type Requirement as r, type RequirementKeyFn as s, type ConstraintDef as t, type ConstraintsDef as u, type CrossModuleConstraintDef as v, type CrossModuleEffectDef as w, DirectiveError as x, type DistributableSnapshot as y, type DistributableSnapshotOptions as z };
+export { type InferDerivations as $, type AnySystem as A, type BatchConfig as B, type ClauseResult as C, type DefinitionMeta as D, type EffectsDef as E, type FactPredicate as F, type CrossModuleEffectDef as G, type DiffRulesOptions as H, DirectiveError as I, type DistributableSnapshot as J, type DistributableSnapshotOptions as K, type DynamicConstraintDef as L, type ModuleSchema as M, type NamespacedSystem as N, type DynamicEffectDef as O, type Plugin as P, type DynamicResolverDef as Q, type RequirementWithId as R, type SchemaType as S, type TypedDerivationsDef as T, type EffectDef as U, type EventsDef as V, type FactTemplate as W, type FactsSnapshot as X, type HistoryAPI as Y, type HistoryOption as Z, type HistoryState as _, type Facts as a, type CrossModuleDerivationFn as a$, type InferEvents as a0, type InferFacts as a1, type InferRequirementTypes as a2, type InferRequirements as a3, type InferSchemaType as a4, type InferSelectorState as a5, type KeySelector as a6, type LeafClause as a7, type MetaAccessor as a8, type MetaMatch as a9, type System as aA, type SystemConfig as aB, type SystemDerived as aC, type SystemFacts as aD, type SystemInspection as aE, type SystemMode as aF, type SystemSnapshot as aG, type TraceEntry as aH, type TypedConstraintDef as aI, type TypedResolverDef as aJ, diffClauses as aK, diffRules as aL, flattenPredicate as aM, isNamespacedSystem as aN, isSingleModuleSystem as aO, toRulesMap as aP, type FactsStore as aQ, type ConstraintState as aR, type ResolverStatus as aS, type FactChange as aT, type ReconcileResult as aU, type RecoveryStrategy as aV, type ErrorSource as aW, type RetryLaterConfig as aX, type BatchItemResult as aY, type BatchResolveResults as aZ, type ConstraintsControl as a_, type ObservationEvent as aa, type OperatorObject as ab, type PatchSpec as ac, type PatchValue as ad, type PayloadRef as ae, type PredicateClause as af, type PredicateCombinator as ag, type PredicateCombinatorKey as ah, type PredicateObject as ai, type PredicateOp as aj, type PredicateOverlapProof as ak, type ResolverAbortReason as al, type ResolverDef as am, type ResolversDef as an, type RetryPolicy as ao, type RulesDiffReport as ap, type RulesMapInput as aq, type Schema as ar, type SchemaTypedResolversDef as as, type ShouldRetryContext as at, type Snapshot as au, type SourceDef as av, type SourceDropReason as aw, type SourcePublish as ax, type SourceReportError as ay, type SourceUnsubscribe as az, type TypedEventsDef as b, type CrossModuleFactsWithSelf as b0, type DerivationKeys as b1, type DerivationReturnType as b2, type DerivationsControl as b3, type DerivationsSchema as b4, type DeriveAccessor as b5, type DispatchEventsFromSchema as b6, type EffectCleanup as b7, type EffectsControl as b8, type EventPayloadSchema as b9, type RequirementOutput$1 as bA, type EventsAccessor as ba, type EventsAccessorFromSchema as bb, type EventsSchema as bc, type FactKeys as bd, type FactReturnType as be, type FlexibleEventHandler as bf, type HistoryConfig as bg, type InferEventPayloadFromSchema as bh, type InferRequirementPayloadFromSchema as bi, type InferSchema as bj, type MutableNamespacedFacts as bk, type NamespacedDerivations as bl, type NamespacedEventsAccessor as bm, type NamespacedFacts as bn, type ObservableKeys as bo, type RequirementExplanation as bp, type RequirementOutput as bq, type RequirementPayloadSchema$1 as br, type RequirementsSchema as bs, type ResolverContext as bt, type ResolversControl as bu, type SnapshotMeta as bv, type SystemEvent as bw, type TraceConfig as bx, type TypedResolverContext as by, type UnionEvents as bz, type SourcesDef as c, type TypedConstraintsDef as d, type TypedResolversDef as e, type ModuleHooks as f, type CrossModuleDeps as g, type CrossModuleDerivationsDef as h, type CrossModuleEffectsDef as i, type CrossModuleConstraintsDef as j, type ModuleDef as k, type CreateSystemOptionsSingle as l, type SingleModuleSystem as m, type ModulesMap as n, type CreateSystemOptionsNamed as o, type TraceOption as p, type ErrorBoundaryConfig as q, type Requirement as r, type RequirementKeyFn as s, type Change as t, type ChangeKind as u, type ConstraintDef as v, type ConstraintDiff as w, type ConstraintStatus as x, type ConstraintsDef as y, type CrossModuleConstraintDef as z };