@plures/praxis 1.4.4 → 2.0.3

package/dist/browser/chunk-IUEKGHQN.js

@@ -0,0 +1,373 @@
+// src/unified/core.ts
+var _idCounter = 0;
+function nextId() {
+  return `px:${Date.now()}-${++_idCounter}`;
+}
+function createApp(config) {
+  const paths = /* @__PURE__ */ new Map();
+  for (const schema of config.schema) {
+    paths.set(schema.path, {
+      schema,
+      value: schema.initial,
+      subscribers: /* @__PURE__ */ new Set(),
+      lastUpdated: 0,
+      updateCount: 0
+    });
+  }
+  let facts = [];
+  const factMap = /* @__PURE__ */ new Map();
+  const timeline = [];
+  const maxTimeline = 1e4;
+  function recordTimeline(path, kind, data) {
+    const entry = {
+      id: nextId(),
+      timestamp: Date.now(),
+      path,
+      kind,
+      data
+    };
+    timeline.push(entry);
+    if (timeline.length > maxTimeline) {
+      timeline.splice(0, timeline.length - maxTimeline);
+    }
+  }
+  const ruleStates = (config.rules ?? []).map((rule) => ({
+    rule,
+    lastResult: null,
+    emittedTags: /* @__PURE__ */ new Set()
+  }));
+  const constraints = config.constraints ?? [];
+  const livenessConfig = config.liveness;
+  const initTime = Date.now();
+  let livenessTimer = null;
+  if (livenessConfig) {
+    const timeout = livenessConfig.timeoutMs ?? 5e3;
+    livenessTimer = setTimeout(() => {
+      for (const expectedPath of livenessConfig.expect) {
+        const state = paths.get(expectedPath);
+        if (!state || state.updateCount === 0) {
+          const elapsed = Date.now() - initTime;
+          recordTimeline(expectedPath, "liveness", {
+            stale: true,
+            elapsed,
+            message: `Path "${expectedPath}" never updated after ${elapsed}ms`
+          });
+          livenessConfig.onStale?.(expectedPath, elapsed);
+        }
+      }
+    }, timeout);
+  }
+  function getPathValues(watchPaths) {
+    const values = {};
+    for (const p of watchPaths) {
+      const state = paths.get(p);
+      values[p] = state ? state.value : void 0;
+    }
+    return values;
+  }
+  function notify(path, value) {
+    const state = paths.get(path);
+    if (!state) return;
+    for (const cb of state.subscribers) {
+      try {
+        cb(value);
+      } catch (err) {
+        console.error(`[praxis] Subscriber error for "${path}":`, err);
+      }
+    }
+  }
+  function checkConstraints(path, value) {
+    const violations = [];
+    for (const c of constraints) {
+      if (!c.watch.includes(path)) continue;
+      const values = getPathValues(c.watch);
+      values[path] = value;
+      try {
+        const result = c.validate(values);
+        if (result !== true) {
+          violations.push({
+            kind: "constraint-violation",
+            message: result,
+            data: { constraintId: c.id, path, description: c.description }
+          });
+          recordTimeline(path, "constraint-check", {
+            constraintId: c.id,
+            violated: true,
+            message: result
+          });
+        }
+      } catch (err) {
+        violations.push({
+          kind: "constraint-violation",
+          message: `Constraint "${c.id}" threw: ${err instanceof Error ? err.message : String(err)}`,
+          data: { constraintId: c.id, error: err }
+        });
+      }
+    }
+    return violations;
+  }
+  function evaluateRules() {
+    const newFacts = [];
+    const retractions = [];
+    for (const rs of ruleStates) {
+      const values = getPathValues(rs.rule.watch);
+      try {
+        const result = rs.rule.evaluate(values, [...facts]);
+        rs.lastResult = result;
+        recordTimeline(rs.rule.watch[0] ?? "*", "rule-eval", {
+          ruleId: rs.rule.id,
+          kind: result.kind,
+          reason: result.reason
+        });
+        switch (result.kind) {
+          case "emit":
+            newFacts.push(...result.facts);
+            for (const f of result.facts) {
+              rs.emittedTags.add(f.tag);
+            }
+            break;
+          case "retract":
+            retractions.push(...result.retractTags);
+            for (const tag of result.retractTags) {
+              rs.emittedTags.delete(tag);
+            }
+            break;
+          case "noop":
+          case "skip":
+            if (rs.emittedTags.size > 0) {
+              retractions.push(...rs.emittedTags);
+              rs.emittedTags.clear();
+            }
+            break;
+        }
+      } catch (err) {
+        console.error(`[praxis] Rule "${rs.rule.id}" error:`, err);
+      }
+    }
+    if (retractions.length > 0) {
+      const retractSet = new Set(retractions);
+      for (const tag of retractSet) {
+        factMap.delete(tag);
+      }
+    }
+    for (const f of newFacts) {
+      factMap.set(f.tag, f);
+    }
+    facts = Array.from(factMap.values());
+  }
+  function query(path, opts) {
+    let state = paths.get(path);
+    if (!state) {
+      state = {
+        schema: { path, initial: void 0 },
+        value: void 0,
+        subscribers: /* @__PURE__ */ new Set(),
+        lastUpdated: 0,
+        updateCount: 0
+      };
+      paths.set(path, state);
+    }
+    const ref = {
+      get current() {
+        const s = paths.get(path);
+        return applyQueryOpts(s?.value ?? state.schema.initial, opts);
+      },
+      subscribe(cb) {
+        const wrappedCb = (rawValue) => {
+          const processed = applyQueryOpts(rawValue, opts);
+          cb(processed);
+        };
+        const s = paths.get(path);
+        s.subscribers.add(wrappedCb);
+        try {
+          cb(ref.current);
+        } catch (err) {
+          console.error(`[praxis] query("${path}") subscriber init error:`, err);
+        }
+        return () => {
+          s.subscribers.delete(wrappedCb);
+        };
+      }
+    };
+    return ref;
+  }
+  function applyQueryOpts(value, opts) {
+    if (!opts || !Array.isArray(value)) return value;
+    let result = [...value];
+    if (opts.where) result = result.filter(opts.where);
+    if (opts.sort) result.sort(opts.sort);
+    if (opts.select) result = result.map(opts.select);
+    if (opts.limit) result = result.slice(0, opts.limit);
+    return result;
+  }
+  function mutateInternal(path, value) {
+    const violations = checkConstraints(path, value);
+    if (violations.length > 0) {
+      return { violations, emittedFacts: [] };
+    }
+    const state = paths.get(path);
+    if (!state) {
+      paths.set(path, {
+        schema: { path, initial: value },
+        value,
+        subscribers: /* @__PURE__ */ new Set(),
+        lastUpdated: Date.now(),
+        updateCount: 1
+      });
+    } else {
+      const before = state.value;
+      state.value = value;
+      state.lastUpdated = Date.now();
+      state.updateCount++;
+      recordTimeline(path, "mutation", {
+        before: summarize(before),
+        after: summarize(value)
+      });
+    }
+    notify(path, value);
+    const factsBefore = facts.length;
+    evaluateRules();
+    const emittedFacts = facts.slice(factsBefore);
+    return { violations: [], emittedFacts };
+  }
+  function mutate(path, value) {
+    const { violations, emittedFacts } = mutateInternal(path, value);
+    return {
+      accepted: violations.length === 0,
+      violations,
+      facts: emittedFacts
+    };
+  }
+  function batchMutate(fn) {
+    const allViolations = [];
+    const pendingWrites = [];
+    fn((path, value) => {
+      const violations = checkConstraints(path, value);
+      if (violations.length > 0) {
+        allViolations.push(...violations);
+      } else {
+        pendingWrites.push({ path, value });
+      }
+    });
+    if (allViolations.length > 0) {
+      return { accepted: false, violations: allViolations, facts: [] };
+    }
+    for (const { path, value } of pendingWrites) {
+      const state = paths.get(path);
+      if (state) {
+        const before = state.value;
+        state.value = value;
+        state.lastUpdated = Date.now();
+        state.updateCount++;
+        recordTimeline(path, "mutation", {
+          before: summarize(before),
+          after: summarize(value)
+        });
+      } else {
+        paths.set(path, {
+          schema: { path, initial: value },
+          value,
+          subscribers: /* @__PURE__ */ new Set(),
+          lastUpdated: Date.now(),
+          updateCount: 1
+        });
+      }
+    }
+    for (const { path, value } of pendingWrites) {
+      notify(path, value);
+    }
+    const factsBefore = facts.length;
+    evaluateRules();
+    return {
+      accepted: true,
+      violations: [],
+      facts: facts.slice(factsBefore)
+    };
+  }
+  function getLiveness() {
+    const result = {};
+    const now = Date.now();
+    const watchPaths = livenessConfig?.expect ?? [];
+    for (const p of watchPaths) {
+      const state = paths.get(p);
+      const lastUpdated = state?.lastUpdated ?? 0;
+      const elapsed = lastUpdated > 0 ? now - lastUpdated : now - initTime;
+      result[p] = {
+        stale: !state || state.updateCount === 0,
+        lastUpdated,
+        elapsed
+      };
+    }
+    return result;
+  }
+  function destroy() {
+    if (livenessTimer) clearTimeout(livenessTimer);
+    for (const state of paths.values()) {
+      state.subscribers.clear();
+    }
+    paths.clear();
+    facts = [];
+    factMap.clear();
+    timeline.length = 0;
+  }
+  return {
+    query,
+    mutate,
+    batch: batchMutate,
+    facts: () => [...facts],
+    violations: () => {
+      const allViolations = [];
+      for (const c of constraints) {
+        const values = getPathValues(c.watch);
+        try {
+          const result = c.validate(values);
+          if (result !== true) {
+            allViolations.push({
+              kind: "constraint-violation",
+              message: result,
+              data: { constraintId: c.id }
+            });
+          }
+        } catch {
+        }
+      }
+      return allViolations;
+    },
+    timeline: () => [...timeline],
+    evaluate: evaluateRules,
+    destroy,
+    liveness: getLiveness
+  };
+}
+function summarize(value) {
+  if (value === null || value === void 0) return value;
+  if (typeof value !== "object") return value;
+  if (Array.isArray(value)) return `[Array(${value.length})]`;
+  const keys = Object.keys(value);
+  if (keys.length > 10) return `{Object(${keys.length} keys)}`;
+  return value;
+}
+
+// src/unified/types.ts
+function definePath(path, initial, opts) {
+  return { path, initial, ...opts };
+}
+
+// src/unified/rules.ts
+function defineRule(rule) {
+  return rule;
+}
+function defineConstraint(constraint) {
+  return constraint;
+}
+function defineModule(name, rules) {
+  return { name, rules };
+}
+
+export {
+  createApp,
+  definePath,
+  defineRule,
+  defineConstraint,
+  defineModule
+};

package/dist/browser/factory/index.d.ts

@@ -1,4 +1,5 @@
-import { j as PraxisModule } from '../rules-i1LHpnGd.js';
+import { d as PraxisModule } from '../rules-BaWMqxuG.js';
+import '../rule-result-DcXWe9tn.js';
 
 /**
  * Praxis Rules Factory — Types

package/dist/browser/index.d.ts

@@ -1,11 +1,14 @@
-import { P as PraxisState, a as PraxisEvent, b as PraxisRegistry, R as RuleDescriptor, C as ConstraintDescriptor, g as ConstraintFn, h as Contract, i as RuleFn, c as PraxisFact, j as PraxisModule } from './rules-i1LHpnGd.js';
-export { k as ConstraintId, l as PRAXIS_PROTOCOL_VERSION, f as PraxisDiagnostics, e as PraxisStepConfig, m as PraxisStepFn, d as PraxisStepResult, n as RuleId, o as RuleResult, T as TypedRuleFn, p as fact } from './rules-i1LHpnGd.js';
-import { L as LogicEngine } from './reactive-engine.svelte-DgVTqHLc.js';
-export { P as PraxisEngineOptions, R as ReactiveEngineOptions, a as ReactiveLogicEngine, b as createPraxisEngine, c as createReactiveEngine } from './reactive-engine.svelte-DgVTqHLc.js';
+import { P as PraxisState, a as PraxisEvent, b as PraxisFact } from './rule-result-DcXWe9tn.js';
+export { f as PRAXIS_PROTOCOL_VERSION, e as PraxisDiagnostics, d as PraxisStepConfig, g as PraxisStepFn, c as PraxisStepResult, R as RuleResult, T as TypedRuleFn, h as fact } from './rule-result-DcXWe9tn.js';
+import { P as PraxisRegistry, R as RuleDescriptor, C as ConstraintDescriptor, a as ConstraintFn, b as Contract, c as RuleFn, d as PraxisModule } from './rules-BaWMqxuG.js';
+export { e as ConstraintId, f as RuleId } from './rules-BaWMqxuG.js';
+import { L as LogicEngine } from './reactive-engine.svelte-BwWadvAW.js';
+export { P as PraxisEngineOptions, R as ReactiveEngineOptions, a as ReactiveLogicEngine, b as createPraxisEngine, c as createReactiveEngine } from './reactive-engine.svelte-BwWadvAW.js';
 import { LocalFirstOptions } from '@plures/pluresdb/local-first';
 export { ConditionResult, ConditionStatus, Expectation, ExpectationCondition, ExpectationResult, ExpectationSet, ExpectationSetOptions, VerifiableDescriptor, VerifiableRegistry, VerificationReport, expectBehavior, formatVerificationReport, verify } from './expectations/index.js';
 export { DataRulesConfig, FormRulesConfig, InputRulesConfig, NavigationRulesConfig, SanitizationType, ToastRulesConfig, dataRules, formRules, inputRules, navigationRules, toastRules } from './factory/index.js';
 export { BranchRulesConfig, GateConfig, GateState, GateStatus, PraxisDiff, PredefinedGateConfig, SemverContractConfig, SemverReport, branchRules, commitFromState, defineGate, expectationGate, formatGate, lintGate, semverContract } from './project/index.js';
+export { LivenessConfig, MutationResult, PathSchema, PraxisApp, PraxisAppConfig, QueryOptions, ReactiveRef, UnifiedConstraint, UnifiedRule, createApp, definePath, defineConstraint as defineUnifiedConstraint, defineModule as defineUnifiedModule, defineRule as defineUnifiedRule } from './unified/index.js';
 
 /**
  * Praxis Reactive Logic Engine

package/dist/browser/index.js

@@ -26,6 +26,13 @@ import {
   lintGate,
   semverContract
 } from "./chunk-BQOYZBWA.js";
+import {
+  createApp,
+  defineConstraint,
+  defineModule,
+  definePath,
+  defineRule
+} from "./chunk-IUEKGHQN.js";
 import {
   LogicEngine,
   PRAXIS_PROTOCOL_VERSION,
@@ -606,7 +613,7 @@ function defineEvent(tag) {
     }
   };
 }
-function defineRule(options) {
+function defineRule2(options) {
   const contract = options.contract ?? options.meta?.contract;
   const meta = contract ? { ...options.meta ?? {}, contract } : options.meta;
   return {
@@ -618,7 +625,7 @@ function defineRule(options) {
     meta
   };
 }
-function defineConstraint(options) {
+function defineConstraint2(options) {
   const contract = options.contract ?? options.meta?.contract;
   const meta = contract ? { ...options.meta ?? {}, contract } : options.meta;
   return {
@@ -629,7 +636,7 @@ function defineConstraint(options) {
     meta
   };
 }
-function defineModule(options) {
+function defineModule2(options) {
   return {
     rules: options.rules ?? [],
     constraints: options.constraints ?? [],
@@ -3370,6 +3377,7 @@ export {
   canvasToSchema,
   canvasToYaml,
   commitFromState,
+  createApp,
   createCanvasEditor,
   createReactiveEngine2 as createFrameworkAgnosticReactiveEngine,
   createInMemoryDB,
@@ -3392,12 +3400,16 @@ export {
   createUnifiedApp,
   createUnumAdapter,
   dataRules,
-  defineConstraint,
+  defineConstraint2 as defineConstraint,
   defineEvent,
   defineFact,
   defineGate,
-  defineModule,
-  defineRule,
+  defineModule2 as defineModule,
+  definePath,
+  defineRule2 as defineRule,
+  defineConstraint as defineUnifiedConstraint,
+  defineModule as defineUnifiedModule,
+  defineRule as defineUnifiedRule,
   dirtyGuardRule,
   errorDisplayRule,
   expectBehavior,

package/dist/browser/integrations/svelte.d.ts

@@ -1,6 +1,7 @@
-import { L as LogicEngine } from '../reactive-engine.svelte-DgVTqHLc.js';
-export { R as ReactiveEngineOptions, a as ReactiveLogicEngine, c as createReactiveEngine } from '../reactive-engine.svelte-DgVTqHLc.js';
-import { P as PraxisState, a as PraxisEvent } from '../rules-i1LHpnGd.js';
+import { L as LogicEngine } from '../reactive-engine.svelte-BwWadvAW.js';
+export { R as ReactiveEngineOptions, a as ReactiveLogicEngine, c as createReactiveEngine } from '../reactive-engine.svelte-BwWadvAW.js';
+import { P as PraxisState, a as PraxisEvent } from '../rule-result-DcXWe9tn.js';
+import '../rules-BaWMqxuG.js';
 
 /**
  * Svelte v5 Integration

package/dist/browser/project/index.d.ts

@@ -1,4 +1,5 @@
-import { j as PraxisModule } from '../rules-i1LHpnGd.js';
+import { d as PraxisModule } from '../rules-BaWMqxuG.js';
+import '../rule-result-DcXWe9tn.js';
 
 /**
  * Praxis Project Logic — Types

package/dist/browser/{reactive-engine.svelte-DgVTqHLc.d.ts → reactive-engine.svelte-BwWadvAW.d.ts}

@@ -1,4 +1,5 @@
-import { b as PraxisRegistry, c as PraxisFact, P as PraxisState, a as PraxisEvent, d as PraxisStepResult, e as PraxisStepConfig, f as PraxisDiagnostics } from './rules-i1LHpnGd.js';
+import { b as PraxisFact, P as PraxisState, a as PraxisEvent, c as PraxisStepResult, d as PraxisStepConfig, e as PraxisDiagnostics } from './rule-result-DcXWe9tn.js';
+import { P as PraxisRegistry } from './rules-BaWMqxuG.js';
 
 /**
  * Praxis Logic Engine

package/dist/browser/rule-result-DcXWe9tn.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Core Praxis Protocol
+ *
+ * Language-neutral, JSON-friendly protocol that forms the foundation of Praxis.
+ * This protocol is designed to be stable and portable across languages (TypeScript, C#, PowerShell, etc.)
+ *
+ * The protocol defines the conceptual core of the engine:
+ * - Pure, deterministic, data in → data out
+ * - No side effects, no global state
+ * - All higher-level TypeScript APIs are built on top of this protocol
+ *
+ * ## Protocol Versioning
+ *
+ * The Praxis protocol follows semantic versioning (MAJOR.MINOR.PATCH):
+ * - MAJOR: Breaking changes to core protocol types or semantics
+ * - MINOR: Backward-compatible additions to protocol (new optional fields)
+ * - PATCH: Clarifications, documentation updates, no functional changes
+ *
+ * Current version: 1.0.0
+ *
+ * ### Stability Guarantees
+ *
+ * 1. **Core Types Stability**: The following types are considered stable and will not
+ *    change in backward-incompatible ways within the same major version:
+ *    - PraxisFact (tag, payload structure)
+ *    - PraxisEvent (tag, payload structure)
+ *    - PraxisState (context, facts, meta structure)
+ *    - PraxisStepFn signature
+ *
+ * 2. **JSON Compatibility**: All protocol types will remain JSON-serializable.
+ *    No non-JSON-safe types (functions, symbols, etc.) will be added to the protocol.
+ *
+ * 3. **Cross-Language Compatibility**: Protocol changes will be coordinated across
+ *    all official language implementations (TypeScript, C#, PowerShell) to ensure
+ *    interoperability.
+ *
+ * 4. **Migration Path**: Major version changes will be accompanied by:
+ *    - Migration guide
+ *    - Deprecation warnings in previous version
+ *    - Compatibility shims where possible
+ */
+/**
+ * Protocol version following semantic versioning
+ */
+declare const PRAXIS_PROTOCOL_VERSION: "1.0.0";
+/**
+ * A fact is a typed proposition about the domain.
+ * Examples: UserLoggedIn, CartItem, NetworkOnline
+ */
+interface PraxisFact {
+    /** Tag identifying the fact type */
+    tag: string;
+    /** Payload containing the fact data */
+    payload: unknown;
+}
+/**
+ * An event is a temporally ordered fact meant to drive change.
+ * Examples: LOGIN, LOGOUT, ADD_TO_CART
+ */
+interface PraxisEvent {
+    /** Tag identifying the event type */
+    tag: string;
+    /** Payload containing the event data */
+    payload: unknown;
+}
+/**
+ * The state of the Praxis engine at a point in time.
+ */
+interface PraxisState {
+    /** Application context (domain-specific data) */
+    context: unknown;
+    /** Current facts about the domain */
+    facts: PraxisFact[];
+    /**
+     * Events currently being processed in this step.
+     * Available to rules during execution — guaranteed to contain the exact
+     * events passed to step()/stepWithContext().
+     * Empty outside of step execution.
+     */
+    events?: PraxisEvent[];
+    /** Optional metadata (timestamps, version, etc.) */
+    meta?: Record<string, unknown>;
+    /** Protocol version (for cross-language compatibility) */
+    protocolVersion?: string;
+}
+/**
+ * Diagnostic information about constraint violations or rule errors.
+ */
+interface PraxisDiagnostics {
+    /** Kind of diagnostic */
+    kind: 'constraint-violation' | 'rule-error';
+    /** Human-readable message */
+    message: string;
+    /** Additional diagnostic data */
+    data?: unknown;
+}
+/**
+ * Configuration for a step execution.
+ * Specifies which rules and constraints to apply.
+ */
+interface PraxisStepConfig {
+    /** IDs of rules to apply during this step */
+    ruleIds: string[];
+    /** IDs of constraints to check during this step */
+    constraintIds: string[];
+}
+/**
+ * Result of a step execution.
+ */
+interface PraxisStepResult {
+    /** New state after applying rules and checking constraints */
+    state: PraxisState;
+    /** Diagnostics from rule execution and constraint checking */
+    diagnostics: PraxisDiagnostics[];
+}
+/**
+ * The core step function of the Praxis engine.
+ *
+ * This is the conceptual heart of the engine:
+ * - Takes current state, events, and configuration
+ * - Applies rules and checks constraints
+ * - Returns new state and diagnostics
+ *
+ * Pure, deterministic, data in → data out.
+ * No side effects, no global state.
+ */
+type PraxisStepFn = (state: PraxisState, events: PraxisEvent[], config: PraxisStepConfig) => PraxisStepResult;
+
+/**
+ * The result of evaluating a rule. Every rule MUST return one of:
+ * - `RuleResult.emit(facts)` — rule produced facts
+ * - `RuleResult.noop(reason?)` — rule evaluated but had nothing to say
+ * - `RuleResult.skip(reason?)` — rule decided to skip (preconditions not met)
+ * - `RuleResult.retract(tags)` — rule retracts previously emitted facts
+ */
+declare class RuleResult {
+    /** The kind of result */
+    readonly kind: 'emit' | 'noop' | 'skip' | 'retract';
+    /** Facts produced (only for 'emit') */
+    readonly facts: PraxisFact[];
+    /** Fact tags to retract (only for 'retract') */
+    readonly retractTags: string[];
+    /** Optional reason (for noop/skip/retract — useful for debugging) */
+    readonly reason?: string;
+    /** The rule ID that produced this result (set by engine) */
+    ruleId?: string;
+    private constructor();
+    /**
+     * Rule produced facts.
+     *
+     * @example
+     * return RuleResult.emit([
+     *   { tag: 'sprint.behind', payload: { deficit: 5 } }
+     * ]);
+     */
+    static emit(facts: PraxisFact[]): RuleResult;
+    /**
+     * Rule evaluated but had nothing to report.
+     * Unlike returning [], this is explicit and traceable.
+     *
+     * @example
+     * if (ctx.completedHours >= expectedHours) {
+     *   return RuleResult.noop('Sprint is on pace');
+     * }
+     */
+    static noop(reason?: string): RuleResult;
+    /**
+     * Rule decided to skip because preconditions were not met.
+     * Distinct from noop: skip means "I can't evaluate", noop means "I evaluated and found nothing".
+     *
+     * @example
+     * if (!ctx.sprintName) {
+     *   return RuleResult.skip('No active sprint');
+     * }
+     */
+    static skip(reason?: string): RuleResult;
+    /**
+     * Rule retracts previously emitted facts by tag.
+     * Used when a condition that previously produced facts is no longer true.
+     *
+     * @example
+     * // Sprint was behind, but caught up
+     * if (ctx.completedHours >= expectedHours) {
+     *   return RuleResult.retract(['sprint.behind'], 'Sprint caught up');
+     * }
+     */
+    static retract(tags: string[], reason?: string): RuleResult;
+    /** Whether this result produced facts */
+    get hasFacts(): boolean;
+    /** Whether this result retracts facts */
+    get hasRetractions(): boolean;
+}
+/**
+ * A rule function that returns a typed RuleResult.
+ * New API — replaces the old PraxisFact[] return type.
+ */
+type TypedRuleFn<TContext = unknown> = (state: PraxisState & {
+    context: TContext;
+    events: PraxisEvent[];
+}, events: PraxisEvent[]) => RuleResult;
+/**
+ * Convenience: create a fact object (just a shorthand)
+ */
+declare function fact(tag: string, payload: unknown): PraxisFact;
+
+export { type PraxisState as P, RuleResult as R, type TypedRuleFn as T, type PraxisEvent as a, type PraxisFact as b, type PraxisStepResult as c, type PraxisStepConfig as d, type PraxisDiagnostics as e, PRAXIS_PROTOCOL_VERSION as f, type PraxisStepFn as g, fact as h };