@plures/praxis 1.4.0 → 1.4.4

package/dist/browser/index.js

@@ -2,12 +2,39 @@ import {
   PraxisRegistry,
   ReactiveLogicEngine,
   createReactiveEngine
-} from "./chunk-N63K4KWS.js";
+} from "./chunk-4IRUGWR3.js";
+import {
+  Expectation,
+  ExpectationSet,
+  expectBehavior,
+  formatVerificationReport,
+  verify
+} from "./chunk-ZEW4LJAJ.js";
+import {
+  dataRules,
+  formRules,
+  inputRules,
+  navigationRules,
+  toastRules
+} from "./chunk-6SJ44Q64.js";
+import {
+  branchRules,
+  commitFromState,
+  defineGate,
+  expectationGate,
+  formatGate,
+  lintGate,
+  semverContract
+} from "./chunk-BQOYZBWA.js";
 import {
   LogicEngine,
   PRAXIS_PROTOCOL_VERSION,
   createPraxisEngine
-} from "./chunk-MJK3IYTJ.js";
+} from "./chunk-JZDJU2DO.js";
+import {
+  RuleResult,
+  fact
+} from "./chunk-IG5BJ2MT.js";
 import {
   InMemoryPraxisDB,
   PluresDBPraxisAdapter,
@@ -563,8 +590,8 @@ function defineFact(tag) {
     create(payload) {
       return { tag, payload };
     },
-    is(fact) {
-      return fact.tag === tag;
+    is(fact2) {
+      return fact2.tag === tag;
     }
   };
 }
@@ -666,16 +693,16 @@ function validateSchema(schema) {
   if (schema.logic) {
     schema.logic.forEach((logic, logicIndex) => {
       if (logic.facts) {
-        logic.facts.forEach((fact, factIndex) => {
-          if (!fact.tag) {
+        logic.facts.forEach((fact2, factIndex) => {
+          if (!fact2.tag) {
             errors.push({
               path: `logic[${logicIndex}].facts[${factIndex}].tag`,
               message: "Fact tag is required"
             });
-          } else if (!isValidIdentifier(fact.tag)) {
+          } else if (!isValidIdentifier(fact2.tag)) {
             errors.push({
               path: `logic[${logicIndex}].facts[${factIndex}].tag`,
-              message: `Fact tag "${fact.tag}" is not a valid JavaScript identifier. Use only letters, numbers, underscores, and dollar signs, and do not start with a number.`
+              message: `Fact tag "${fact2.tag}" is not a valid JavaScript identifier. Use only letters, numbers, underscores, and dollar signs, and do not start with a number.`
             });
           }
         });
@@ -1002,37 +1029,37 @@ var PraxisDBStore = class {
    * @param fact The fact to store
    * @returns Promise that resolves when the fact is stored
    */
-  async storeFact(fact) {
-    const constraintResult = await this.checkConstraints([fact]);
+  async storeFact(fact2) {
+    const constraintResult = await this.checkConstraints([fact2]);
     if (!constraintResult.valid) {
       throw new Error(`Constraint violation: ${constraintResult.errors.join(", ")}`);
     }
     let before;
     if (this.chronicle) {
-      const payload = fact.payload;
+      const payload = fact2.payload;
       const id = payload?.id;
       if (id) {
-        before = await this.getFact(fact.tag, id);
+        before = await this.getFact(fact2.tag, id);
       }
     }
-    await this.persistFact(fact);
+    await this.persistFact(fact2);
     if (this.chronicle) {
-      const payload = fact.payload;
+      const payload = fact2.payload;
       const id = payload?.id ?? "";
       const span = ChronicleContext.current;
       try {
         await this.chronicle.record({
-          path: getFactPath(fact.tag, id),
+          path: getFactPath(fact2.tag, id),
           before,
-          after: fact,
+          after: fact2,
           cause: span?.spanId,
           context: span?.contextId,
-          metadata: { factTag: fact.tag, operation: "storeFact" }
+          metadata: { factTag: fact2.tag, operation: "storeFact" }
         });
       } catch {
       }
     }
-    await this.triggerRules([fact]);
+    await this.triggerRules([fact2]);
   }
   /**
    * Store multiple facts in PluresDB
@@ -1044,28 +1071,28 @@ var PraxisDBStore = class {
     if (!constraintResult.valid) {
       throw new Error(`Constraint violation: ${constraintResult.errors.join(", ")}`);
     }
-    for (const fact of facts) {
+    for (const fact2 of facts) {
       let before;
       if (this.chronicle) {
-        const payload = fact.payload;
+        const payload = fact2.payload;
         const id = payload?.id;
         if (id) {
-          before = await this.getFact(fact.tag, id);
+          before = await this.getFact(fact2.tag, id);
         }
       }
-      await this.persistFact(fact);
+      await this.persistFact(fact2);
       if (this.chronicle) {
-        const payload = fact.payload;
+        const payload = fact2.payload;
         const id = payload?.id ?? "";
         const span = ChronicleContext.current;
         try {
           await this.chronicle.record({
-            path: getFactPath(fact.tag, id),
+            path: getFactPath(fact2.tag, id),
             before,
-            after: fact,
+            after: fact2,
             cause: span?.spanId,
             context: span?.contextId,
-            metadata: { factTag: fact.tag, operation: "storeFacts" }
+            metadata: { factTag: fact2.tag, operation: "storeFacts" }
           });
         } catch {
         }
@@ -1077,11 +1104,11 @@ var PraxisDBStore = class {
    * Internal method to persist a fact without constraint checking
    * Used by both storeFact and derived fact storage
    */
-  async persistFact(fact) {
-    const payload = fact.payload;
+  async persistFact(fact2) {
+    const payload = fact2.payload;
     const id = payload?.id ?? generateId();
-    const path = getFactPath(fact.tag, id);
-    await this.db.set(path, fact);
+    const path = getFactPath(fact2.tag, id);
+    await this.db.set(path, fact2);
   }
   /**
    * Get a fact by tag and id
@@ -1218,8 +1245,8 @@ var PraxisDBStore = class {
     if (watchers) {
       watchers.add(callback);
     }
-    const unsubscribe = this.db.watch(path, (fact) => {
-      callback([fact]);
+    const unsubscribe = this.db.watch(path, (fact2) => {
+      callback([fact2]);
     });
     this.subscriptions.push(unsubscribe);
     return () => {
@@ -1296,19 +1323,19 @@ var PraxisDBStore = class {
     if (derivedFacts.length > 0) {
       const constraintResult = await this.checkConstraints(derivedFacts);
       if (constraintResult.valid) {
-        for (const fact of derivedFacts) {
-          await this.persistFact(fact);
+        for (const fact2 of derivedFacts) {
+          await this.persistFact(fact2);
           if (this.chronicle) {
-            const payload = fact.payload;
+            const payload = fact2.payload;
             const id = payload?.id ?? "";
             const span = ChronicleContext.current;
             try {
               await this.chronicle.record({
-                path: getFactPath(fact.tag, id),
-                after: fact,
+                path: getFactPath(fact2.tag, id),
+                after: fact2,
                 cause: span?.spanId,
                 context: span?.contextId,
-                metadata: { factTag: fact.tag, operation: "derivedFact" }
+                metadata: { factTag: fact2.tag, operation: "derivedFact" }
               });
             } catch {
             }
@@ -1768,7 +1795,7 @@ async function createUnumAdapter(config) {
       type: "event"
     });
   }
-  async function broadcastFact(channelId, fact) {
+  async function broadcastFact(channelId, fact2) {
     const channel = channels.get(channelId);
     if (!channel) {
       throw new Error(`Not joined to channel ${channelId}`);
@@ -1776,7 +1803,7 @@ async function createUnumAdapter(config) {
     await channel.publish({
       id: generateId2(),
       sender: currentIdentity || { id: "anonymous", createdAt: Date.now() },
-      content: fact,
+      content: fact2,
       type: "fact"
     });
   }
@@ -1919,17 +1946,17 @@ function schemaToCanvas(schema, _options = {}) {
     yOffset += schema.events.length * ySpacing + 30;
   }
   if (schema.facts) {
-    schema.facts.forEach((fact, index) => {
-      const pos = fact.position && (fact.position.x !== 0 || fact.position.y !== 0) ? fact.position : { x: 50 + xSpacing * 3, y: yOffset + index * ySpacing };
+    schema.facts.forEach((fact2, index) => {
+      const pos = fact2.position && (fact2.position.x !== 0 || fact2.position.y !== 0) ? fact2.position : { x: 50 + xSpacing * 3, y: yOffset + index * ySpacing };
       const node = {
-        id: fact.id || `fact-${nodeId++}`,
+        id: fact2.id || `fact-${nodeId++}`,
         type: "fact",
-        label: fact.tag,
+        label: fact2.tag,
         x: pos.x,
         y: pos.y,
         width: 150,
         height: 50,
-        data: fact,
+        data: fact2,
         style: {
           backgroundColor: "#fce4ec",
           borderColor: "#c2185b"
@@ -2384,8 +2411,8 @@ var StateDocsGenerator = class {
         if (logic.facts && logic.facts.length > 0) {
           lines.push("**Facts:**");
           lines.push("");
-          for (const fact of logic.facts) {
-            lines.push(`- \`${fact.tag}\`: ${fact.description || ""}`);
+          for (const fact2 of logic.facts) {
+            lines.push(`- \`${fact2.tag}\`: ${fact2.description || ""}`);
           }
           lines.push("");
         }
@@ -2517,9 +2544,9 @@ var StateDocsGenerator = class {
       lines.push("");
       lines.push("| Fact | Description | Payload |");
       lines.push("|------|-------------|---------|");
-      for (const fact of logic.facts) {
-        const payload = fact.payload ? Object.entries(fact.payload).map(([k, v]) => `${k}: ${v}`).join(", ") : "-";
-        lines.push(`| \`${fact.tag}\` | ${fact.description || "-"} | ${payload} |`);
+      for (const fact2 of logic.facts) {
+        const payload = fact2.payload ? Object.entries(fact2.payload).map(([k, v]) => `${k}: ${v}`).join(", ") : "-";
+        lines.push(`| \`${fact2.tag}\` | ${fact2.description || "-"} | ${payload} |`);
       }
       lines.push("");
     }
@@ -2571,8 +2598,8 @@ var StateDocsGenerator = class {
       for (const event of logic.events) {
         lines.push(`    Processing --> ${event.tag.replace(/[^a-zA-Z0-9]/g, "")}: ${event.tag}`);
       }
-      for (const fact of logic.facts) {
-        lines.push(`    ${fact.tag.replace(/[^a-zA-Z0-9]/g, "")} --> [*]`);
+      for (const fact2 of logic.facts) {
+        lines.push(`    ${fact2.tag.replace(/[^a-zA-Z0-9]/g, "")} --> [*]`);
       }
     }
     return {
@@ -2894,7 +2921,7 @@ function generateTauriConfig(config) {
 
 // src/integrations/unified.ts
 async function createUnifiedApp(config) {
-  const { createPraxisEngine: createPraxisEngine2 } = await import("./engine-YIEGSX7U.js");
+  const { createPraxisEngine: createPraxisEngine2 } = await import("./engine-3B5WJPGT.js");
   const { createInMemoryDB: createInMemoryDB2 } = await import("./adapter-CIMBGDC7.js");
   const db = config.db || createInMemoryDB2();
   const pluresdb = createPluresDBAdapter({
@@ -3023,8 +3050,302 @@ async function attachAllIntegrations(engine, registry, options = {}) {
     }
   };
 }
+
+// src/core/ui-rules.ts
+var loadingGateRule = {
+  id: "ui/loading-gate",
+  description: "Signals when the app is in a loading state",
+  eventTypes: ["ui.state-change", "app.init"],
+  impl: (state) => {
+    const ctx = state.context;
+    if (ctx.loading) {
+      return RuleResult.emit([fact("ui.loading-gate", { active: true })]);
+    }
+    return RuleResult.retract(["ui.loading-gate"], "Not loading");
+  },
+  contract: {
+    ruleId: "RULE_ID_PLACEHOLDER",
+    behavior: "Emits ui.loading-gate when context.loading is true, retracts when false",
+    examples: [
+      { given: "loading is true", when: "ui state changes", then: "ui.loading-gate emitted" },
+      { given: "loading is false", when: "ui state changes", then: "ui.loading-gate retracted" }
+    ],
+    invariants: ["Loading gate must reflect context.loading exactly"]
+  }
+};
+var errorDisplayRule = {
+  id: "ui/error-display",
+  description: "Signals when an error should be displayed to the user",
+  eventTypes: ["ui.state-change", "app.error"],
+  impl: (state) => {
+    const ctx = state.context;
+    if (ctx.error) {
+      return RuleResult.emit([fact("ui.error-display", { message: ctx.error, severity: "error" })]);
+    }
+    return RuleResult.retract(["ui.error-display"], "Error cleared");
+  },
+  contract: {
+    ruleId: "RULE_ID_PLACEHOLDER",
+    behavior: "Emits ui.error-display when context.error is non-null, retracts when cleared",
+    examples: [
+      { given: "error is set", when: "ui state changes", then: "ui.error-display emitted with message" },
+      { given: "error is null", when: "ui state changes", then: "ui.error-display retracted" }
+    ],
+    invariants: ["Error display must clear when error is null"]
+  }
+};
+var offlineIndicatorRule = {
+  id: "ui/offline-indicator",
+  description: "Signals when the app is offline",
+  eventTypes: ["ui.state-change", "network.change"],
+  impl: (state) => {
+    if (state.context.offline) {
+      return RuleResult.emit([fact("ui.offline", { message: "You are offline. Changes will sync when reconnected." })]);
+    }
+    return RuleResult.retract(["ui.offline"], "Back online");
+  },
+  contract: {
+    ruleId: "RULE_ID_PLACEHOLDER",
+    behavior: "Emits ui.offline when context.offline is true, retracts when back online",
+    examples: [
+      { given: "offline is true", when: "network changes", then: "ui.offline emitted" },
+      { given: "offline is false", when: "network changes", then: "ui.offline retracted" }
+    ],
+    invariants: ["Offline indicator must match actual connectivity"]
+  }
+};
+var dirtyGuardRule = {
+  id: "ui/dirty-guard",
+  description: "Warns when there are unsaved changes",
+  eventTypes: ["ui.state-change", "navigation.request"],
+  impl: (state) => {
+    if (state.context.dirty) {
+      return RuleResult.emit([fact("ui.unsaved-warning", {
+        message: "You have unsaved changes",
+        blocking: true
+      })]);
+    }
+    return RuleResult.retract(["ui.unsaved-warning"], "No unsaved changes");
+  },
+  contract: {
+    ruleId: "RULE_ID_PLACEHOLDER",
+    behavior: "Emits ui.unsaved-warning when context.dirty is true, retracts when saved",
+    examples: [
+      { given: "dirty is true", when: "ui state changes", then: "ui.unsaved-warning emitted with blocking=true" },
+      { given: "dirty is false", when: "ui state changes", then: "ui.unsaved-warning retracted" }
+    ],
+    invariants: ["Dirty guard must clear after save"]
+  }
+};
+var initGateRule = {
+  id: "ui/init-gate",
+  description: "Signals whether the app has completed initialization",
+  eventTypes: ["ui.state-change", "app.init"],
+  impl: (state) => {
+    if (!state.context.initialized) {
+      return RuleResult.emit([fact("ui.init-pending", {
+        message: "App is initializing..."
+      })]);
+    }
+    return RuleResult.retract(["ui.init-pending"], "App initialized");
+  },
+  contract: {
+    ruleId: "RULE_ID_PLACEHOLDER",
+    behavior: "Emits ui.init-pending until context.initialized is true",
+    examples: [
+      { given: "initialized is false", when: "app starts", then: "ui.init-pending emitted" },
+      { given: "initialized is true", when: "init completes", then: "ui.init-pending retracted" }
+    ],
+    invariants: ["Init gate must clear exactly once, when initialization completes"]
+  }
+};
+var viewportRule = {
+  id: "ui/viewport-class",
+  description: "Classifies viewport size for responsive layout decisions",
+  eventTypes: ["ui.state-change", "ui.resize"],
+  impl: (state) => {
+    const vp = state.context.viewport;
+    if (!vp) return RuleResult.skip("No viewport data");
+    return RuleResult.emit([fact("ui.viewport-class", {
+      viewport: vp,
+      compact: vp === "mobile",
+      showSidebar: vp !== "mobile"
+    })]);
+  },
+  contract: {
+    ruleId: "RULE_ID_PLACEHOLDER",
+    behavior: "Classifies viewport into responsive layout hints",
+    examples: [
+      { given: "viewport is mobile", when: "resize event", then: "compact=true, showSidebar=false" },
+      { given: "viewport is desktop", when: "resize event", then: "compact=false, showSidebar=true" }
+    ],
+    invariants: ["Viewport class must update on every resize event"]
+  }
+};
+var noInteractionWhileLoadingConstraint = {
+  id: "ui/no-interaction-while-loading",
+  description: "Prevents data mutations while a load operation is in progress",
+  impl: (state) => {
+    if (state.context.loading) {
+      return "Cannot perform action while data is loading";
+    }
+    return true;
+  },
+  contract: {
+    ruleId: "RULE_ID_PLACEHOLDER",
+    behavior: "Fails when context.loading is true",
+    examples: [
+      { given: "loading is true", when: "action attempted", then: "violation" },
+      { given: "loading is false", when: "action attempted", then: "pass" }
+    ],
+    invariants: ["Must always fail during loading"]
+  }
+};
+var mustBeInitializedConstraint = {
+  id: "ui/must-be-initialized",
+  description: "Requires app initialization before user interactions",
+  impl: (state) => {
+    if (!state.context.initialized) {
+      return "App must be initialized before performing this action";
+    }
+    return true;
+  },
+  contract: {
+    ruleId: "RULE_ID_PLACEHOLDER",
+    behavior: "Fails when context.initialized is false",
+    examples: [
+      { given: "initialized is false", when: "action attempted", then: "violation" },
+      { given: "initialized is true", when: "action attempted", then: "pass" }
+    ],
+    invariants: ["Must always fail before init completes"]
+  }
+};
+var uiModule = {
+  rules: [
+    loadingGateRule,
+    errorDisplayRule,
+    offlineIndicatorRule,
+    dirtyGuardRule,
+    initGateRule,
+    viewportRule
+  ],
+  constraints: [
+    noInteractionWhileLoadingConstraint,
+    mustBeInitializedConstraint
+  ],
+  meta: {
+    name: "praxis-ui",
+    version: "1.0.0",
+    description: "Predefined UI rules and constraints \u2014 separate from business logic"
+  }
+};
+function createUIModule(options) {
+  const allRules = uiModule.rules;
+  const allConstraints = uiModule.constraints;
+  const selectedRules = options.rules ? allRules.filter((r) => options.rules.includes(r.id)) : allRules;
+  const selectedConstraints = options.constraints ? allConstraints.filter((c) => options.constraints.includes(c.id)) : allConstraints;
+  return {
+    rules: [...selectedRules, ...options.extraRules ?? []],
+    constraints: [...selectedConstraints, ...options.extraConstraints ?? []],
+    meta: { ...uiModule.meta, customized: true }
+  };
+}
+function uiStateChanged(changes) {
+  return { tag: "ui.state-change", payload: changes ?? {} };
+}
+function navigationRequest(to) {
+  return { tag: "navigation.request", payload: { to } };
+}
+function resizeEvent(width, height) {
+  return { tag: "ui.resize", payload: { width, height } };
+}
+
+// src/core/completeness.ts
+function auditCompleteness(manifest, registryRuleIds, registryConstraintIds, rulesWithContracts, config) {
+  const threshold = config?.threshold ?? 90;
+  const domainBranches = manifest.branches.filter((b) => b.kind === "domain");
+  const coveredDomain = domainBranches.filter((b) => b.coveredBy && registryRuleIds.includes(b.coveredBy));
+  const uncoveredDomain = domainBranches.filter((b) => !b.coveredBy || !registryRuleIds.includes(b.coveredBy));
+  const invariantBranches = manifest.branches.filter((b) => b.kind === "invariant");
+  const coveredInvariants = invariantBranches.filter((b) => b.coveredBy && registryConstraintIds.includes(b.coveredBy));
+  const uncoveredInvariants = invariantBranches.filter((b) => !b.coveredBy || !registryConstraintIds.includes(b.coveredBy));
+  const needContracts = manifest.rulesNeedingContracts;
+  const haveContracts = needContracts.filter((id) => rulesWithContracts.includes(id));
+  const missingContracts = needContracts.filter((id) => !rulesWithContracts.includes(id));
+  const neededFields = manifest.stateFields.filter((f) => f.usedByRule);
+  const coveredFields = neededFields.filter((f) => f.inContext);
+  const missingFields = neededFields.filter((f) => !f.inContext);
+  const coveredTransitions = manifest.transitions.filter((t) => t.eventTag);
+  const missingTransitions = manifest.transitions.filter((t) => !t.eventTag);
+  const ruleScore = domainBranches.length > 0 ? coveredDomain.length / domainBranches.length * 40 : 40;
+  const constraintScore = invariantBranches.length > 0 ? coveredInvariants.length / invariantBranches.length * 20 : 20;
+  const contractScore = needContracts.length > 0 ? haveContracts.length / needContracts.length * 15 : 15;
+  const contextScore = neededFields.length > 0 ? coveredFields.length / neededFields.length * 15 : 15;
+  const eventScore = manifest.transitions.length > 0 ? coveredTransitions.length / manifest.transitions.length * 10 : 10;
+  const score = Math.round(ruleScore + constraintScore + contractScore + contextScore + eventScore);
+  const rating = score >= 90 ? "complete" : score >= 70 ? "good" : score >= 50 ? "partial" : "incomplete";
+  const report = {
+    score,
+    rating,
+    rules: { total: domainBranches.length, covered: coveredDomain.length, uncovered: uncoveredDomain },
+    constraints: { total: invariantBranches.length, covered: coveredInvariants.length, uncovered: uncoveredInvariants },
+    contracts: { total: needContracts.length, withContracts: haveContracts.length, missing: missingContracts },
+    context: { total: neededFields.length, covered: coveredFields.length, missing: missingFields },
+    events: { total: manifest.transitions.length, covered: coveredTransitions.length, missing: missingTransitions }
+  };
+  if (config?.strict && score < threshold) {
+    throw new Error(`Praxis completeness ${score}/100 (${rating}) \u2014 below threshold ${threshold}. ${uncoveredDomain.length} uncovered rules, ${uncoveredInvariants.length} uncovered invariants, ${missingContracts.length} missing contracts.`);
+  }
+  return report;
+}
+function formatReport(report) {
+  const lines = [];
+  const icon = report.rating === "complete" ? "\u2705" : report.rating === "good" ? "\u{1F7E2}" : report.rating === "partial" ? "\u{1F7E1}" : "\u{1F534}";
+  lines.push(`${icon} Praxis Completeness: ${report.score}/100 (${report.rating})`);
+  lines.push("");
+  lines.push(`Rules:       ${report.rules.covered}/${report.rules.total} domain branches covered (${pct(report.rules.covered, report.rules.total)})`);
+  lines.push(`Constraints: ${report.constraints.covered}/${report.constraints.total} invariants covered (${pct(report.constraints.covered, report.constraints.total)})`);
+  lines.push(`Contracts:   ${report.contracts.withContracts}/${report.contracts.total} rules have contracts (${pct(report.contracts.withContracts, report.contracts.total)})`);
+  lines.push(`Context:     ${report.context.covered}/${report.context.total} state fields in context (${pct(report.context.covered, report.context.total)})`);
+  lines.push(`Events:      ${report.events.covered}/${report.events.total} transitions have events (${pct(report.events.covered, report.events.total)})`);
+  if (report.rules.uncovered.length > 0) {
+    lines.push("");
+    lines.push("Uncovered domain logic:");
+    for (const b of report.rules.uncovered) {
+      lines.push(`  \u274C ${b.location}: ${b.condition}${b.note ? ` \u2014 ${b.note}` : ""}`);
+    }
+  }
+  if (report.constraints.uncovered.length > 0) {
+    lines.push("");
+    lines.push("Uncovered invariants:");
+    for (const b of report.constraints.uncovered) {
+      lines.push(`  \u274C ${b.location}: ${b.condition}${b.note ? ` \u2014 ${b.note}` : ""}`);
+    }
+  }
+  if (report.contracts.missing.length > 0) {
+    lines.push("");
+    lines.push("Rules missing contracts:");
+    for (const id of report.contracts.missing) {
+      lines.push(`  \u{1F4DD} ${id}`);
+    }
+  }
+  if (report.events.missing.length > 0) {
+    lines.push("");
+    lines.push("State transitions without events:");
+    for (const t of report.events.missing) {
+      lines.push(`  \u26A1 ${t.location}: ${t.description}`);
+    }
+  }
+  return lines.join("\n");
+}
+function pct(a, b) {
+  if (b === 0) return "100%";
+  return Math.round(a / b * 100) + "%";
+}
 export {
   ActorManager,
+  Expectation,
+  ExpectationSet,
   ReactiveLogicEngine2 as FrameworkAgnosticReactiveEngine,
   InMemoryPraxisDB,
   LogicEngine,
@@ -3037,14 +3358,18 @@ export {
   PraxisSchemaRegistry,
   ReactiveLogicEngine,
   RegistryIntrospector,
+  RuleResult,
   StateDocsGenerator,
   attachAllIntegrations,
   attachTauriToEngine,
   attachToEngine,
   attachUnumToEngine,
+  auditCompleteness,
+  branchRules,
   canvasToMermaid,
   canvasToSchema,
   canvasToYaml,
+  commitFromState,
   createCanvasEditor,
   createReactiveEngine2 as createFrameworkAgnosticReactiveEngine,
   createInMemoryDB,
@@ -3063,28 +3388,56 @@ export {
   createStateDocsGenerator,
   createTauriPraxisAdapter,
   createTimerActor,
+  createUIModule,
   createUnifiedApp,
   createUnumAdapter,
+  dataRules,
   defineConstraint,
   defineEvent,
   defineFact,
+  defineGate,
   defineModule,
   defineRule,
+  dirtyGuardRule,
+  errorDisplayRule,
+  expectBehavior,
+  expectationGate,
+  fact,
   filterEvents,
   filterFacts,
   findEvent,
   findFact,
+  formRules,
+  formatGate,
+  formatReport,
+  formatVerificationReport,
   generateDocs,
   generateId,
   generateTauriConfig,
   getEventPath,
   getFactPath,
   getSchemaPath,
+  initGateRule,
+  inputRules,
+  lintGate,
   loadSchemaFromJson,
   loadSchemaFromYaml,
+  loadingGateRule,
+  mustBeInitializedConstraint,
+  navigationRequest,
+  navigationRules,
+  noInteractionWhileLoadingConstraint,
+  offlineIndicatorRule,
   registerSchema,
+  resizeEvent,
   schemaToCanvas,
+  semverContract,
+  toastRules,
+  uiModule,
+  uiStateChanged,
   validateForGeneration,
   validateSchema,
-  validateWithGuardian
+  validateWithGuardian,
+  verify,
+  viewportRule
 };

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

@@ -1,5 +1,6 @@
-import { P as PraxisState, a as PraxisEvent, L as LogicEngine } from '../reactive-engine.svelte-DjynI82A.js';
-export { o as ReactiveEngineOptions, p as ReactiveLogicEngine, s as createReactiveEngine } from '../reactive-engine.svelte-DjynI82A.js';
+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';
 
 /**
  * Svelte v5 Integration