@plures/praxis 1.4.4 → 2.0.0

package/dist/node/index.cjs

@@ -641,6 +641,7 @@ __export(src_exports, {
   canvasToSchema: () => canvasToSchema,
   canvasToYaml: () => canvasToYaml,
   commitFromState: () => commitFromState,
+  createApp: () => createApp,
   createBehaviorLedger: () => createBehaviorLedger,
   createCanvasEditor: () => createCanvasEditor,
   createChronicle: () => createChronicle,
@@ -676,7 +677,11 @@ __export(src_exports, {
   defineFact: () => defineFact,
   defineGate: () => defineGate,
   defineModule: () => defineModule,
+  definePath: () => definePath,
   defineRule: () => defineRule,
+  defineUnifiedConstraint: () => defineConstraint2,
+  defineUnifiedModule: () => defineModule2,
+  defineUnifiedRule: () => defineRule2,
   diffContracts: () => diffContracts,
   diffExpectations: () => diffExpectations,
   diffLedgers: () => diffLedgers,
@@ -7910,6 +7915,363 @@ function fmtIds(ids) {
   if (ids.length <= 3) return ids.join(", ");
   return `${ids.slice(0, 2).join(", ")} (+${ids.length - 2} more)`;
 }
+
+// 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(path3, kind, data) {
+    const entry = {
+      id: nextId(),
+      timestamp: Date.now(),
+      path: path3,
+      kind,
+      data
+    };
+    timeline.push(entry);
+    if (timeline.length > maxTimeline) {
+      timeline.splice(0, timeline.length - maxTimeline);
+    }
+  }
+  const ruleStates = (config.rules ?? []).map((rule) => ({
+    rule,
+    lastResult: null
+  }));
+  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 state2 = paths.get(expectedPath);
+        if (!state2 || state2.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 state2 = paths.get(p);
+      values[p] = state2 ? state2.value : void 0;
+    }
+    return values;
+  }
+  function notify(path3, value) {
+    const state2 = paths.get(path3);
+    if (!state2) return;
+    for (const cb of state2.subscribers) {
+      try {
+        cb(value);
+      } catch (err) {
+        console.error(`[praxis] Subscriber error for "${path3}":`, err);
+      }
+    }
+  }
+  function checkConstraints(path3, value) {
+    const violations = [];
+    for (const c of constraints) {
+      if (!c.watch.includes(path3)) continue;
+      const values = getPathValues(c.watch);
+      values[path3] = value;
+      try {
+        const result = c.validate(values);
+        if (result !== true) {
+          violations.push({
+            kind: "constraint-violation",
+            message: result,
+            data: { constraintId: c.id, path: path3, description: c.description }
+          });
+          recordTimeline(path3, "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);
+            break;
+          case "retract":
+            retractions.push(...result.retractTags);
+            break;
+          case "noop":
+          case "skip":
+            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(path3, opts) {
+    let state2 = paths.get(path3);
+    if (!state2) {
+      state2 = {
+        schema: { path: path3, initial: void 0 },
+        value: void 0,
+        subscribers: /* @__PURE__ */ new Set(),
+        lastUpdated: 0,
+        updateCount: 0
+      };
+      paths.set(path3, state2);
+    }
+    const ref = {
+      get current() {
+        const s = paths.get(path3);
+        return applyQueryOpts(s?.value ?? state2.schema.initial, opts);
+      },
+      subscribe(cb) {
+        const wrappedCb = (rawValue) => {
+          const processed = applyQueryOpts(rawValue, opts);
+          cb(processed);
+        };
+        const s = paths.get(path3);
+        s.subscribers.add(wrappedCb);
+        try {
+          cb(ref.current);
+        } catch (err) {
+          console.error(`[praxis] query("${path3}") 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(path3, value) {
+    const violations = checkConstraints(path3, value);
+    if (violations.length > 0) {
+      return { violations, emittedFacts: [] };
+    }
+    const state2 = paths.get(path3);
+    if (!state2) {
+      paths.set(path3, {
+        schema: { path: path3, initial: value },
+        value,
+        subscribers: /* @__PURE__ */ new Set(),
+        lastUpdated: Date.now(),
+        updateCount: 1
+      });
+    } else {
+      const before = state2.value;
+      state2.value = value;
+      state2.lastUpdated = Date.now();
+      state2.updateCount++;
+      recordTimeline(path3, "mutation", {
+        before: summarize(before),
+        after: summarize(value)
+      });
+    }
+    notify(path3, value);
+    const factsBefore = facts.length;
+    evaluateRules();
+    const emittedFacts = facts.slice(factsBefore);
+    return { violations: [], emittedFacts };
+  }
+  function mutate(path3, value) {
+    const { violations, emittedFacts } = mutateInternal(path3, value);
+    return {
+      accepted: violations.length === 0,
+      violations,
+      facts: emittedFacts
+    };
+  }
+  function batchMutate(fn) {
+    const allViolations = [];
+    const pendingWrites = [];
+    fn((path3, value) => {
+      const violations = checkConstraints(path3, value);
+      if (violations.length > 0) {
+        allViolations.push(...violations);
+      } else {
+        pendingWrites.push({ path: path3, value });
+      }
+    });
+    if (allViolations.length > 0) {
+      return { accepted: false, violations: allViolations, facts: [] };
+    }
+    for (const { path: path3, value } of pendingWrites) {
+      const state2 = paths.get(path3);
+      if (state2) {
+        const before = state2.value;
+        state2.value = value;
+        state2.lastUpdated = Date.now();
+        state2.updateCount++;
+        recordTimeline(path3, "mutation", {
+          before: summarize(before),
+          after: summarize(value)
+        });
+      } else {
+        paths.set(path3, {
+          schema: { path: path3, initial: value },
+          value,
+          subscribers: /* @__PURE__ */ new Set(),
+          lastUpdated: Date.now(),
+          updateCount: 1
+        });
+      }
+    }
+    for (const { path: path3, value } of pendingWrites) {
+      notify(path3, 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 state2 = paths.get(p);
+      const lastUpdated = state2?.lastUpdated ?? 0;
+      const elapsed = lastUpdated > 0 ? now - lastUpdated : now - initTime;
+      const timeout = livenessConfig?.timeoutMs ?? 5e3;
+      result[p] = {
+        stale: state2?.updateCount === 0 || elapsed > timeout,
+        lastUpdated,
+        elapsed
+      };
+    }
+    return result;
+  }
+  function destroy() {
+    if (livenessTimer) clearTimeout(livenessTimer);
+    for (const state2 of paths.values()) {
+      state2.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(path3, initial, opts) {
+  return { path: path3, initial, ...opts };
+}
+
+// src/unified/rules.ts
+init_rule_result();
+function defineRule2(rule) {
+  return rule;
+}
+function defineConstraint2(constraint) {
+  return constraint;
+}
+function defineModule2(name, rules) {
+  return { name, rules };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AcknowledgeContractGap,
@@ -7954,6 +8316,7 @@ function fmtIds(ids) {
   canvasToSchema,
   canvasToYaml,
   commitFromState,
+  createApp,
   createBehaviorLedger,
   createCanvasEditor,
   createChronicle,
@@ -7989,7 +8352,11 @@ function fmtIds(ids) {
   defineFact,
   defineGate,
   defineModule,
+  definePath,
   defineRule,
+  defineUnifiedConstraint,
+  defineUnifiedModule,
+  defineUnifiedRule,
   diffContracts,
   diffExpectations,
   diffLedgers,

package/dist/node/index.d.cts

@@ -1,11 +1,13 @@
 import { P as PraxisState, a as PraxisEvent, b as PraxisFact } from './protocol-DcyGMmWY.cjs';
 export { f as PRAXIS_PROTOCOL_VERSION, e as PraxisDiagnostics, d as PraxisStepConfig, g as PraxisStepFn, c as PraxisStepResult } from './protocol-DcyGMmWY.cjs';
-import { L as LogicEngine, P as PraxisRegistry, b as RuleDescriptor, C as ConstraintDescriptor, d as ConstraintFn, e as Contract, f as RuleFn, g as PraxisModule, M as MissingArtifact, S as Severity, V as ValidationReport, A as Assumption } from './reactive-engine.svelte-Cg0Yc2Hs.cjs';
-export { h as ConstraintId, i as ContractGap, D as DefineContractOptions, E as Example, j as PraxisEngineOptions, R as ReactiveEngineOptions, a as ReactiveLogicEngine, k as Reference, l as RuleId, m as RuleResult, T as TypedRuleFn, n as createPraxisEngine, c as createReactiveEngine, o as defineContract, p as fact, q as getContract, r as isContract } from './reactive-engine.svelte-Cg0Yc2Hs.cjs';
+import { L as LogicEngine, P as PraxisRegistry, b as RuleDescriptor, C as ConstraintDescriptor, d as ConstraintFn, e as Contract, f as RuleFn, g as PraxisModule, M as MissingArtifact, S as Severity, V as ValidationReport, A as Assumption } from './reactive-engine.svelte-Cbq_V20o.cjs';
+export { h as ConstraintId, i as ContractGap, D as DefineContractOptions, E as Example, j as PraxisEngineOptions, R as ReactiveEngineOptions, a as ReactiveLogicEngine, k as Reference, l as RuleId, m as createPraxisEngine, c as createReactiveEngine, n as defineContract, o as getContract, p as isContract } from './reactive-engine.svelte-Cbq_V20o.cjs';
 import { P as PraxisDB, U as UnsubscribeFn$1 } from './terminal-adapter-Db-snPJ3.cjs';
 export { C as CommandExecutor, I as InMemoryPraxisDB, a as PluresDBAdapterConfig, b as PluresDBInstance, d as PluresDBPraxisAdapter, e as PraxisLocalFirstOptions, T as TerminalAdapter, f as TerminalAdapterOptions, g as TerminalExecutionResult, h as TerminalNodeState, i as createInMemoryDB, j as createMockExecutor, k as createPluresDB, l as createPraxisLocalFirst, c as createTerminalAdapter, r as runTerminalCommand } from './terminal-adapter-Db-snPJ3.cjs';
 import { PraxisSchema, ValidationResult, ModelDefinition, FieldDefinition, ComponentDefinition, LogicDefinition } from './schema.cjs';
 export { NodeBindings, NodeDefinition, OrchestrationDefinition, TerminalNodeProps, ValidationError, createSchemaTemplate, validateSchema } from './schema.cjs';
+export { R as RuleResult, T as TypedRuleFn, f as fact } from './rule-result-B9GMivAn.cjs';
+export { LivenessConfig, MutationResult, PathSchema, PraxisApp, PraxisAppConfig, QueryOptions, ReactiveRef, UnifiedConstraint, UnifiedRule, createApp, definePath, defineConstraint as defineUnifiedConstraint, defineModule as defineUnifiedModule, defineRule as defineUnifiedRule } from './unified/index.cjs';
 import '@plures/pluresdb/local-first';
 
 /**

package/dist/node/index.d.ts

@@ -1,11 +1,13 @@
 import { P as PraxisState, a as PraxisEvent, b as PraxisFact } from './protocol-DcyGMmWY.js';
 export { f as PRAXIS_PROTOCOL_VERSION, e as PraxisDiagnostics, d as PraxisStepConfig, g as PraxisStepFn, c as PraxisStepResult } from './protocol-DcyGMmWY.js';
-import { L as LogicEngine, P as PraxisRegistry, b as RuleDescriptor, C as ConstraintDescriptor, d as ConstraintFn, e as Contract, f as RuleFn, g as PraxisModule, M as MissingArtifact, S as Severity, V as ValidationReport, A as Assumption } from './reactive-engine.svelte-DekxqFu0.js';
-export { h as ConstraintId, i as ContractGap, D as DefineContractOptions, E as Example, j as PraxisEngineOptions, R as ReactiveEngineOptions, a as ReactiveLogicEngine, k as Reference, l as RuleId, m as RuleResult, T as TypedRuleFn, n as createPraxisEngine, c as createReactiveEngine, o as defineContract, p as fact, q as getContract, r as isContract } from './reactive-engine.svelte-DekxqFu0.js';
+import { L as LogicEngine, P as PraxisRegistry, b as RuleDescriptor, C as ConstraintDescriptor, d as ConstraintFn, e as Contract, f as RuleFn, g as PraxisModule, M as MissingArtifact, S as Severity, V as ValidationReport, A as Assumption } from './reactive-engine.svelte-BBZLMzus.js';
+export { h as ConstraintId, i as ContractGap, D as DefineContractOptions, E as Example, j as PraxisEngineOptions, R as ReactiveEngineOptions, a as ReactiveLogicEngine, k as Reference, l as RuleId, m as createPraxisEngine, c as createReactiveEngine, n as defineContract, o as getContract, p as isContract } from './reactive-engine.svelte-BBZLMzus.js';
 import { P as PraxisDB, U as UnsubscribeFn$1 } from './terminal-adapter-CvIvgTo4.js';
 export { C as CommandExecutor, I as InMemoryPraxisDB, a as PluresDBAdapterConfig, b as PluresDBInstance, d as PluresDBPraxisAdapter, e as PraxisLocalFirstOptions, T as TerminalAdapter, f as TerminalAdapterOptions, g as TerminalExecutionResult, h as TerminalNodeState, i as createInMemoryDB, j as createMockExecutor, k as createPluresDB, l as createPraxisLocalFirst, c as createTerminalAdapter, r as runTerminalCommand } from './terminal-adapter-CvIvgTo4.js';
 import { PraxisSchema, ValidationResult, ModelDefinition, FieldDefinition, ComponentDefinition, LogicDefinition } from './schema.js';
 export { NodeBindings, NodeDefinition, OrchestrationDefinition, TerminalNodeProps, ValidationError, createSchemaTemplate, validateSchema } from './schema.js';
+export { R as RuleResult, T as TypedRuleFn, f as fact } from './rule-result-Bo3sFMmN.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';
 import '@plures/pluresdb/local-first';
 
 /**

package/dist/node/index.js

@@ -73,16 +73,15 @@ import {
 import {
   ReactiveLogicEngine,
   createReactiveEngine
-} from "./chunk-ZO2LU4G4.js";
+} from "./chunk-WFRHXZBP.js";
+import {
+  PraxisRegistry
+} from "./chunk-TEMFJOIH.js";
 import {
   LogicEngine,
   PRAXIS_PROTOCOL_VERSION,
   createPraxisEngine
 } from "./chunk-JZDJU2DO.js";
-import {
-  RuleResult,
-  fact
-} from "./chunk-IG5BJ2MT.js";
 import {
   TerminalAdapter,
   createMockExecutor,
@@ -105,8 +104,16 @@ import {
   validateSchema
 } from "./chunk-UATVJBNV.js";
 import {
-  PraxisRegistry
-} from "./chunk-TEMFJOIH.js";
+  createApp,
+  defineConstraint as defineConstraint2,
+  defineModule as defineModule2,
+  definePath,
+  defineRule as defineRule2
+} from "./chunk-6MVRT7CK.js";
+import {
+  RuleResult,
+  fact
+} from "./chunk-IG5BJ2MT.js";
 import "./chunk-QGM4M3NI.js";
 
 // src/core/reactive-engine.ts
@@ -3759,6 +3766,7 @@ export {
   canvasToSchema,
   canvasToYaml,
   commitFromState,
+  createApp,
   createBehaviorLedger,
   createCanvasEditor,
   createChronicle,
@@ -3794,7 +3802,11 @@ export {
   defineFact,
   defineGate,
   defineModule,
+  definePath,
   defineRule,
+  defineConstraint2 as defineUnifiedConstraint,
+  defineModule2 as defineUnifiedModule,
+  defineRule2 as defineUnifiedRule,
   diffContracts,
   diffExpectations,
   diffLedgers,

package/dist/node/integrations/svelte.d.cts

@@ -1,6 +1,7 @@
-import { L as LogicEngine } from '../reactive-engine.svelte-Cg0Yc2Hs.cjs';
-export { R as ReactiveEngineOptions, a as ReactiveLogicEngine, c as createReactiveEngine } from '../reactive-engine.svelte-Cg0Yc2Hs.cjs';
+import { L as LogicEngine } from '../reactive-engine.svelte-Cbq_V20o.cjs';
+export { R as ReactiveEngineOptions, a as ReactiveLogicEngine, c as createReactiveEngine } from '../reactive-engine.svelte-Cbq_V20o.cjs';
 import { P as PraxisState, a as PraxisEvent } from '../protocol-DcyGMmWY.cjs';
+import '../rule-result-B9GMivAn.cjs';
 
 /**
  * Svelte v5 Integration

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

@@ -1,6 +1,7 @@
-import { L as LogicEngine } from '../reactive-engine.svelte-DekxqFu0.js';
-export { R as ReactiveEngineOptions, a as ReactiveLogicEngine, c as createReactiveEngine } from '../reactive-engine.svelte-DekxqFu0.js';
+import { L as LogicEngine } from '../reactive-engine.svelte-BBZLMzus.js';
+export { R as ReactiveEngineOptions, a as ReactiveLogicEngine, c as createReactiveEngine } from '../reactive-engine.svelte-BBZLMzus.js';
 import { P as PraxisState, a as PraxisEvent } from '../protocol-DcyGMmWY.js';
+import '../rule-result-Bo3sFMmN.js';
 
 /**
  * Svelte v5 Integration

package/dist/node/integrations/svelte.js

@@ -1,10 +1,10 @@
 import {
   ReactiveLogicEngine,
   createReactiveEngine
-} from "../chunk-ZO2LU4G4.js";
+} from "../chunk-WFRHXZBP.js";
+import "../chunk-TEMFJOIH.js";
 import "../chunk-JZDJU2DO.js";
 import "../chunk-IG5BJ2MT.js";
-import "../chunk-TEMFJOIH.js";
 import "../chunk-QGM4M3NI.js";
 
 // src/integrations/svelte.ts

package/dist/node/{reactive-engine.svelte-DekxqFu0.d.ts → reactive-engine.svelte-BBZLMzus.d.ts}

@@ -1,4 +1,5 @@
-import { b as PraxisFact, P as PraxisState, a as PraxisEvent, c as PraxisStepResult, d as PraxisStepConfig, e as PraxisDiagnostics } from './protocol-DcyGMmWY.js';
+import { P as PraxisState, a as PraxisEvent, b as PraxisFact, c as PraxisStepResult, d as PraxisStepConfig, e as PraxisDiagnostics } from './protocol-DcyGMmWY.js';
+import { R as RuleResult } from './rule-result-Bo3sFMmN.js';
 
 /**
  * Decision Ledger - Contract Types
@@ -162,83 +163,6 @@ interface ValidationReport {
     timestamp: string;
 }
 
-/**
- * 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;
-
 /**
  * Rules and Constraints System
  *
@@ -634,4 +558,4 @@ declare class ReactiveLogicEngine<TContext extends object> {
  */
 declare function createReactiveEngine<TContext extends object>(options: ReactiveEngineOptions<TContext>): ReactiveLogicEngine<TContext>;
 
-export { type Assumption as A, type ConstraintDescriptor as C, type DefineContractOptions as D, type Example as E, LogicEngine as L, type MissingArtifact as M, PraxisRegistry as P, type ReactiveEngineOptions as R, type Severity as S, type TypedRuleFn as T, type ValidationReport as V, ReactiveLogicEngine as a, type RuleDescriptor as b, createReactiveEngine as c, type ConstraintFn as d, type Contract as e, type RuleFn as f, type PraxisModule as g, type ConstraintId as h, type ContractGap as i, type PraxisEngineOptions as j, type Reference as k, type RuleId as l, RuleResult as m, createPraxisEngine as n, defineContract as o, fact as p, getContract as q, isContract as r };
+export { type Assumption as A, type ConstraintDescriptor as C, type DefineContractOptions as D, type Example as E, LogicEngine as L, type MissingArtifact as M, PraxisRegistry as P, type ReactiveEngineOptions as R, type Severity as S, type ValidationReport as V, ReactiveLogicEngine as a, type RuleDescriptor as b, createReactiveEngine as c, type ConstraintFn as d, type Contract as e, type RuleFn as f, type PraxisModule as g, type ConstraintId as h, type ContractGap as i, type PraxisEngineOptions as j, type Reference as k, type RuleId as l, createPraxisEngine as m, defineContract as n, getContract as o, isContract as p };