@plures/praxis 1.2.41 → 1.4.0

package/dist/node/index.cjs

@@ -39,6 +39,99 @@ var init_protocol = __esm({
   }
 });
 
+// src/core/rule-result.ts
+function fact(tag, payload) {
+  return { tag, payload };
+}
+var RuleResult;
+var init_rule_result = __esm({
+  "src/core/rule-result.ts"() {
+    "use strict";
+    RuleResult = class _RuleResult {
+      /** The kind of result */
+      kind;
+      /** Facts produced (only for 'emit') */
+      facts;
+      /** Fact tags to retract (only for 'retract') */
+      retractTags;
+      /** Optional reason (for noop/skip/retract — useful for debugging) */
+      reason;
+      /** The rule ID that produced this result (set by engine) */
+      ruleId;
+      constructor(kind, facts, retractTags, reason) {
+        this.kind = kind;
+        this.facts = facts;
+        this.retractTags = retractTags;
+        this.reason = reason;
+      }
+      /**
+       * Rule produced facts.
+       *
+       * @example
+       * return RuleResult.emit([
+       *   { tag: 'sprint.behind', payload: { deficit: 5 } }
+       * ]);
+       */
+      static emit(facts) {
+        if (facts.length === 0) {
+          throw new Error(
+            "RuleResult.emit() requires at least one fact. Use RuleResult.noop() or RuleResult.skip() when a rule has nothing to say."
+          );
+        }
+        return new _RuleResult("emit", facts, []);
+      }
+      /**
+       * 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) {
+        return new _RuleResult("noop", [], [], reason);
+      }
+      /**
+       * 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) {
+        return new _RuleResult("skip", [], [], reason);
+      }
+      /**
+       * 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, reason) {
+        if (tags.length === 0) {
+          throw new Error("RuleResult.retract() requires at least one tag.");
+        }
+        return new _RuleResult("retract", [], tags, reason);
+      }
+      /** Whether this result produced facts */
+      get hasFacts() {
+        return this.facts.length > 0;
+      }
+      /** Whether this result retracts facts */
+      get hasRetractions() {
+        return this.retractTags.length > 0;
+      }
+    };
+  }
+});
+
 // src/core/engine.ts
 var engine_exports = {};
 __export(engine_exports, {
@@ -68,6 +161,7 @@ var init_engine = __esm({
   "src/core/engine.ts"() {
     "use strict";
     init_protocol();
+    init_rule_result();
     LogicEngine = class {
       state;
       registry;
@@ -131,7 +225,13 @@ var init_engine = __esm({
       stepWithConfig(events, config) {
         const diagnostics = [];
         let newState = { ...this.state };
+        const stateWithEvents = {
+          ...newState,
+          events
+          // current batch — rules can read state.events
+        };
         const newFacts = [];
+        const retractions = [];
         const eventTags = new Set(events.map((e) => e.tag));
         for (const ruleId of config.ruleIds) {
           const rule = this.registry.getRule(ruleId);
@@ -150,8 +250,31 @@ var init_engine = __esm({
             }
           }
           try {
-            const ruleFacts = rule.impl(newState, events);
-            newFacts.push(...ruleFacts);
+            const rawResult = rule.impl(stateWithEvents, events);
+            if (rawResult instanceof RuleResult) {
+              rawResult.ruleId = ruleId;
+              switch (rawResult.kind) {
+                case "emit":
+                  newFacts.push(...rawResult.facts);
+                  break;
+                case "retract":
+                  retractions.push(...rawResult.retractTags);
+                  break;
+                case "noop":
+                case "skip":
+                  if (rawResult.reason) {
+                    diagnostics.push({
+                      kind: "rule-error",
+                      // reused kind — could add 'rule-trace' in protocol v2
+                      message: `[${rawResult.kind}] ${ruleId}: ${rawResult.reason}`,
+                      data: { ruleId, resultKind: rawResult.kind, reason: rawResult.reason }
+                    });
+                  }
+                  break;
+              }
+            } else if (Array.isArray(rawResult)) {
+              newFacts.push(...rawResult);
+            }
           } catch (error) {
             diagnostics.push({
               kind: "rule-error",
@@ -160,21 +283,26 @@ var init_engine = __esm({
             });
           }
         }
+        let existingFacts = newState.facts;
+        if (retractions.length > 0) {
+          const retractSet = new Set(retractions);
+          existingFacts = existingFacts.filter((f) => !retractSet.has(f.tag));
+        }
         let mergedFacts;
         switch (this.factDedup) {
           case "last-write-wins": {
             const factMap = /* @__PURE__ */ new Map();
-            for (const f of newState.facts) factMap.set(f.tag, f);
+            for (const f of existingFacts) factMap.set(f.tag, f);
             for (const f of newFacts) factMap.set(f.tag, f);
             mergedFacts = Array.from(factMap.values());
             break;
           }
           case "append":
-            mergedFacts = [...newState.facts, ...newFacts];
+            mergedFacts = [...existingFacts, ...newFacts];
             break;
           case "none":
           default:
-            mergedFacts = [...newState.facts, ...newFacts];
+            mergedFacts = [...existingFacts, ...newFacts];
             break;
         }
         if (this.maxFacts > 0 && mergedFacts.length > this.maxFacts) {
@@ -481,6 +609,8 @@ __export(src_exports, {
   ContractMissing: () => ContractMissing,
   ContractUpdated: () => ContractUpdated,
   ContractValidated: () => ContractValidated,
+  Expectation: () => Expectation,
+  ExpectationSet: () => ExpectationSet,
   FrameworkAgnosticReactiveEngine: () => ReactiveLogicEngine2,
   InMemoryPraxisDB: () => InMemoryPraxisDB,
   LogicEngine: () => LogicEngine,
@@ -494,6 +624,7 @@ __export(src_exports, {
   PraxisSchemaRegistry: () => PraxisSchemaRegistry,
   ReactiveLogicEngine: () => ReactiveLogicEngine,
   RegistryIntrospector: () => RegistryIntrospector,
+  RuleResult: () => RuleResult,
   StateDocsGenerator: () => StateDocsGenerator,
   TerminalAdapter: () => TerminalAdapter,
   ValidateContracts: () => ValidateContracts,
@@ -501,9 +632,12 @@ __export(src_exports, {
   attachTauriToEngine: () => attachTauriToEngine,
   attachToEngine: () => attachToEngine,
   attachUnumToEngine: () => attachUnumToEngine,
+  auditCompleteness: () => auditCompleteness,
+  branchRules: () => branchRules,
   canvasToMermaid: () => canvasToMermaid,
   canvasToSchema: () => canvasToSchema,
   canvasToYaml: () => canvasToYaml,
+  commitFromState: () => commitFromState,
   createBehaviorLedger: () => createBehaviorLedger,
   createCanvasEditor: () => createCanvasEditor,
   createChronicle: () => createChronicle,
@@ -526,21 +660,33 @@ __export(src_exports, {
   createTauriPraxisAdapter: () => createTauriPraxisAdapter,
   createTerminalAdapter: () => createTerminalAdapter,
   createTimerActor: () => createTimerActor,
+  createUIModule: () => createUIModule,
   createUnifiedApp: () => createUnifiedApp,
   createUnumAdapter: () => createUnumAdapter,
+  dataRules: () => dataRules,
   defineConstraint: () => defineConstraint,
   defineContract: () => defineContract,
   defineEvent: () => defineEvent,
   defineFact: () => defineFact,
+  defineGate: () => defineGate,
   defineModule: () => defineModule,
   defineRule: () => defineRule,
+  dirtyGuardRule: () => dirtyGuardRule,
+  errorDisplayRule: () => errorDisplayRule,
+  expectBehavior: () => expectBehavior,
+  expectationGate: () => expectationGate,
+  fact: () => fact,
   filterEvents: () => filterEvents,
   filterFacts: () => filterFacts,
   findEvent: () => findEvent,
   findFact: () => findFact,
+  formRules: () => formRules,
+  formatGate: () => formatGate,
+  formatReport: () => formatReport,
   formatValidationReport: () => formatValidationReport,
   formatValidationReportJSON: () => formatValidationReportJSON,
   formatValidationReportSARIF: () => formatValidationReportSARIF,
+  formatVerificationReport: () => formatVerificationReport,
   generateDocs: () => generateDocs,
   generateId: () => generateId,
   generateTauriConfig: () => generateTauriConfig,
@@ -548,18 +694,34 @@ __export(src_exports, {
   getEventPath: () => getEventPath,
   getFactPath: () => getFactPath,
   getSchemaPath: () => getSchemaPath,
+  initGateRule: () => initGateRule,
+  inputRules: () => inputRules,
   isContract: () => isContract,
+  lintGate: () => lintGate,
   loadSchema: () => loadSchema,
   loadSchemaFromFile: () => loadSchemaFromFile,
   loadSchemaFromJson: () => loadSchemaFromJson,
   loadSchemaFromYaml: () => loadSchemaFromYaml,
+  loadingGateRule: () => loadingGateRule,
+  mustBeInitializedConstraint: () => mustBeInitializedConstraint,
+  navigationRequest: () => navigationRequest,
+  navigationRules: () => navigationRules,
+  noInteractionWhileLoadingConstraint: () => noInteractionWhileLoadingConstraint,
+  offlineIndicatorRule: () => offlineIndicatorRule,
   registerSchema: () => registerSchema,
+  resizeEvent: () => resizeEvent,
   runTerminalCommand: () => runTerminalCommand,
   schemaToCanvas: () => schemaToCanvas,
+  semverContract: () => semverContract,
+  toastRules: () => toastRules,
+  uiModule: () => uiModule,
+  uiStateChanged: () => uiStateChanged,
   validateContracts: () => validateContracts,
   validateForGeneration: () => validateForGeneration,
   validateSchema: () => validateSchema,
-  validateWithGuardian: () => validateWithGuardian
+  validateWithGuardian: () => validateWithGuardian,
+  verify: () => verify,
+  viewportRule: () => viewportRule
 });
 module.exports = __toCommonJS(src_exports);
 init_protocol();
@@ -1336,8 +1498,8 @@ function defineFact(tag) {
     create(payload) {
       return { tag, payload };
     },
-    is(fact) {
-      return fact.tag === tag;
+    is(fact2) {
+      return fact2.tag === tag;
     }
   };
 }
@@ -2090,16 +2252,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.`
             });
           }
         });
@@ -2484,37 +2646,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
@@ -2526,28 +2688,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 {
         }
@@ -2559,11 +2721,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 path3 = getFactPath(fact.tag, id);
-    await this.db.set(path3, fact);
+    const path3 = getFactPath(fact2.tag, id);
+    await this.db.set(path3, fact2);
   }
   /**
    * Get a fact by tag and id
@@ -2700,8 +2862,8 @@ var PraxisDBStore = class {
     if (watchers) {
       watchers.add(callback);
     }
-    const unsubscribe = this.db.watch(path3, (fact) => {
-      callback([fact]);
+    const unsubscribe = this.db.watch(path3, (fact2) => {
+      callback([fact2]);
     });
     this.subscriptions.push(unsubscribe);
     return () => {
@@ -2759,13 +2921,18 @@ var PraxisDBStore = class {
     const state2 = {
       context: this.context,
       facts: [],
+      events,
       meta: {}
     };
     const derivedFacts = [];
     for (const rule of rules) {
       try {
-        const facts = rule.impl(state2, events);
-        derivedFacts.push(...facts);
+        const result = rule.impl(state2, events);
+        if (Array.isArray(result)) {
+          derivedFacts.push(...result);
+        } else if (result && "kind" in result && result.kind === "emit") {
+          derivedFacts.push(...result.facts);
+        }
       } catch (error) {
         this.onRuleError(rule.id, error);
       }
@@ -2773,19 +2940,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 {
             }
@@ -3398,7 +3565,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}`);
@@ -3406,7 +3573,7 @@ async function createUnumAdapter(config) {
     await channel.publish({
       id: generateId2(),
       sender: currentIdentity || { id: "anonymous", createdAt: Date.now() },
-      content: fact,
+      content: fact2,
       type: "fact"
     });
   }
@@ -3549,17 +3716,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"
@@ -4014,8 +4181,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("");
         }
@@ -4147,9 +4314,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("");
     }
@@ -4201,8 +4368,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 {
@@ -4653,6 +4820,1379 @@ async function attachAllIntegrations(engine, registry, options = {}) {
     }
   };
 }
+
+// src/index.ts
+init_rule_result();
+
+// src/core/ui-rules.ts
+init_rule_result();
+var loadingGateRule = {
+  id: "ui/loading-gate",
+  description: "Signals when the app is in a loading state",
+  eventTypes: ["ui.state-change", "app.init"],
+  impl: (state2) => {
+    const ctx = state2.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: (state2) => {
+    const ctx = state2.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: (state2) => {
+    if (state2.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: (state2) => {
+    if (state2.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: (state2) => {
+    if (!state2.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: (state2) => {
+    const vp = state2.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: (state2) => {
+    if (state2.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: (state2) => {
+    if (!state2.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) + "%";
+}
+
+// src/expectations/expectations.ts
+var Expectation = class {
+  name;
+  _conditions = [];
+  constructor(name) {
+    this.name = name;
+  }
+  /**
+   * Declare that this behavior should ONLY occur when a condition is true.
+   * If the condition is false, the behavior should NOT occur.
+   */
+  onlyWhen(condition) {
+    this._conditions.push({ description: condition, type: "onlyWhen" });
+    return this;
+  }
+  /**
+   * Declare that this behavior should NEVER occur under a given condition.
+   */
+  never(condition) {
+    this._conditions.push({ description: condition, type: "never" });
+    return this;
+  }
+  /**
+   * Declare that this behavior should ALWAYS have a certain property.
+   */
+  always(condition) {
+    this._conditions.push({ description: condition, type: "always" });
+    return this;
+  }
+  /** Get all declared conditions. */
+  get conditions() {
+    return this._conditions;
+  }
+};
+var ExpectationSet = class {
+  name;
+  description;
+  _expectations = [];
+  constructor(options) {
+    this.name = options.name;
+    this.description = options.description ?? "";
+  }
+  /** Add an expectation to the set. */
+  add(expectation) {
+    this._expectations.push(expectation);
+    return this;
+  }
+  /** Get all expectations in this set. */
+  get expectations() {
+    return this._expectations;
+  }
+  /** Number of expectations. */
+  get size() {
+    return this._expectations.length;
+  }
+};
+function expectBehavior(name) {
+  return new Expectation(name);
+}
+function verify(registry, expectations) {
+  const rules = registry.getAllRules();
+  const constraints = registry.getAllConstraints();
+  const ruleIds = registry.getRuleIds();
+  const constraintIds = registry.getConstraintIds();
+  const allDescriptors = [...rules, ...constraints];
+  const expectationResults = [];
+  for (const exp of expectations.expectations) {
+    const result = verifyExpectation(exp, allDescriptors, ruleIds, constraintIds);
+    expectationResults.push(result);
+  }
+  const satisfied = expectationResults.filter((r) => r.status === "satisfied").length;
+  const violated = expectationResults.filter((r) => r.status === "violated").length;
+  const partial = expectationResults.filter((r) => r.status === "partial").length;
+  const allEdgeCases = expectationResults.flatMap((r) => r.edgeCases);
+  const allMitigations = expectationResults.flatMap((r) => r.mitigations);
+  return {
+    setName: expectations.name,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    status: violated > 0 ? "violated" : partial > 0 ? "partial" : "satisfied",
+    expectations: expectationResults,
+    summary: {
+      total: expectationResults.length,
+      satisfied,
+      violated,
+      partial
+    },
+    allEdgeCases,
+    allMitigations
+  };
+}
+function verifyExpectation(expectation, descriptors, ruleIds, _constraintIds) {
+  const conditionResults = [];
+  const edgeCases = [];
+  const mitigations = [];
+  const related = findRelatedDescriptors(expectation.name, descriptors);
+  for (const condition of expectation.conditions) {
+    const result = verifyCondition(condition, expectation.name, related, ruleIds);
+    conditionResults.push(result);
+    if (result.status === "unverifiable") {
+      edgeCases.push(`Cannot verify "${condition.description}" for "${expectation.name}" \u2014 no covering rule/contract found`);
+      mitigations.push(`Add a rule or constraint that explicitly covers: ${condition.description}`);
+    } else if (result.status === "violated") {
+      edgeCases.push(`"${expectation.name}" may fire incorrectly: ${condition.description}`);
+      mitigations.push(`Review rule logic for "${expectation.name}" regarding: ${condition.description}`);
+    }
+  }
+  const satisfiedCount = conditionResults.filter((r) => r.status === "satisfied").length;
+  const violatedCount = conditionResults.filter((r) => r.status === "violated").length;
+  const total = conditionResults.length;
+  let status;
+  if (total === 0) {
+    status = "satisfied";
+  } else if (violatedCount > 0) {
+    status = "violated";
+  } else if (satisfiedCount === total) {
+    status = "satisfied";
+  } else {
+    status = "partial";
+  }
+  return {
+    name: expectation.name,
+    status,
+    conditions: conditionResults,
+    edgeCases,
+    mitigations
+  };
+}
+function textOverlaps(a, b) {
+  const stopWords = /* @__PURE__ */ new Set([
+    "the",
+    "a",
+    "an",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "shall",
+    "can",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "as",
+    "into",
+    "through",
+    "during",
+    "before",
+    "after",
+    "when",
+    "that",
+    "this",
+    "it",
+    "its",
+    "and",
+    "or",
+    "but",
+    "not",
+    "no",
+    "if",
+    "then",
+    "than",
+    "so",
+    "up",
+    "out",
+    "about",
+    "just",
+    "must"
+  ]);
+  const wordsA = a.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+  const wordsB = b.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+  if (wordsA.length === 0 || wordsB.length === 0) return false;
+  const matches = wordsA.filter(
+    (wa) => wordsB.some((wb) => wa.startsWith(wb.slice(0, 4)) || wb.startsWith(wa.slice(0, 4)))
+  );
+  const minWords = Math.min(wordsA.length, wordsB.length);
+  return matches.length >= Math.max(1, Math.ceil(minWords * 0.5));
+}
+function verifyCondition(condition, expectationName, relatedDescriptors, _ruleIds) {
+  if (relatedDescriptors.length === 0) {
+    return {
+      condition,
+      status: "unverifiable",
+      explanation: `No rules or constraints found related to "${expectationName}"`,
+      relatedRules: []
+    };
+  }
+  const relatedIds = relatedDescriptors.map((d) => d.id);
+  const condLower = condition.description.toLowerCase();
+  const matches = (target) => target.toLowerCase().includes(condLower) || condLower.includes(target.toLowerCase()) || textOverlaps(condLower, target);
+  switch (condition.type) {
+    case "onlyWhen": {
+      const coveringRule = relatedDescriptors.find(
+        (d) => d.contract?.examples.some(
+          (ex) => matches(ex.given) || matches(ex.when)
+        ) || d.contract?.invariants.some((inv) => matches(inv))
+      );
+      if (coveringRule) {
+        return {
+          condition,
+          status: "satisfied",
+          explanation: `Rule "${coveringRule.id}" contract covers precondition: ${condition.description}`,
+          relatedRules: relatedIds
+        };
+      }
+      const descMatch = relatedDescriptors.find((d) => matches(d.description));
+      if (descMatch) {
+        return {
+          condition,
+          status: "satisfied",
+          explanation: `Rule "${descMatch.id}" description addresses: ${condition.description}`,
+          relatedRules: relatedIds
+        };
+      }
+      return {
+        condition,
+        status: "unverifiable",
+        explanation: `No rule contract explicitly covers the precondition: ${condition.description}`,
+        relatedRules: relatedIds
+      };
+    }
+    case "never": {
+      const preventingDescriptor = relatedDescriptors.find(
+        (d) => d.contract?.invariants.some((inv) => matches(inv)) || d.contract?.examples.some(
+          (ex) => (matches(ex.given) || matches(ex.when)) && (ex.then.toLowerCase().includes("retract") || ex.then.toLowerCase().includes("fail") || ex.then.toLowerCase().includes("violation") || ex.then.toLowerCase().includes("skip") || ex.then.toLowerCase().includes("block") || ex.then.toLowerCase().includes("no "))
+        ) || d.contract?.behavior.toLowerCase().includes("block") || d.contract?.behavior.toLowerCase().includes("prevent")
+      );
+      if (preventingDescriptor) {
+        return {
+          condition,
+          status: "satisfied",
+          explanation: `Constraint/rule "${preventingDescriptor.id}" prevents: ${condition.description}`,
+          relatedRules: relatedIds
+        };
+      }
+      return {
+        condition,
+        status: "unverifiable",
+        explanation: `No rule or constraint explicitly prevents: ${condition.description}`,
+        relatedRules: relatedIds
+      };
+    }
+    case "always": {
+      const guaranteeing = relatedDescriptors.find(
+        (d) => d.contract?.invariants.some((inv) => matches(inv)) || d.contract?.behavior && matches(d.contract.behavior)
+      );
+      if (guaranteeing) {
+        return {
+          condition,
+          status: "satisfied",
+          explanation: `Rule "${guaranteeing.id}" guarantees: ${condition.description}`,
+          relatedRules: relatedIds
+        };
+      }
+      const exampleMatch = relatedDescriptors.find(
+        (d) => d.contract?.examples.some((ex) => matches(ex.then))
+      );
+      if (exampleMatch) {
+        return {
+          condition,
+          status: "satisfied",
+          explanation: `Rule "${exampleMatch.id}" example demonstrates: ${condition.description}`,
+          relatedRules: relatedIds
+        };
+      }
+      return {
+        condition,
+        status: "unverifiable",
+        explanation: `No rule contract guarantees: ${condition.description}`,
+        relatedRules: relatedIds
+      };
+    }
+  }
+}
+function findRelatedDescriptors(expectationName, descriptors) {
+  const nameLower = expectationName.toLowerCase();
+  const nameParts = nameLower.split(/[-_./\s]+/);
+  return descriptors.filter((d) => {
+    const idLower = d.id.toLowerCase();
+    const descLower = d.description.toLowerCase();
+    const behaviorLower = d.contract?.behavior?.toLowerCase() ?? "";
+    if (idLower.includes(nameLower) || nameLower.includes(idLower)) return true;
+    if (descLower.includes(nameLower)) return true;
+    if (behaviorLower.includes(nameLower)) return true;
+    const minParts = Math.min(2, nameParts.length);
+    const matchingParts = nameParts.filter(
+      (part) => part.length > 2 && (idLower.includes(part) || descLower.includes(part) || behaviorLower.includes(part))
+    );
+    if (matchingParts.length >= minParts) return true;
+    if (d.eventTypes) {
+      const eventStr = Array.isArray(d.eventTypes) ? d.eventTypes.join(" ") : d.eventTypes;
+      if (eventStr.toLowerCase().includes(nameLower)) return true;
+    }
+    return false;
+  });
+}
+function formatVerificationReport(report) {
+  const lines = [];
+  const icon = report.status === "satisfied" ? "\u2705" : report.status === "partial" ? "\u{1F7E1}" : "\u{1F534}";
+  lines.push(`${icon} Expectations: ${report.setName} \u2014 ${report.status.toUpperCase()}`);
+  lines.push(`   ${report.summary.satisfied}/${report.summary.total} satisfied, ${report.summary.violated} violated, ${report.summary.partial} partial`);
+  lines.push("");
+  for (const exp of report.expectations) {
+    const expIcon = exp.status === "satisfied" ? "\u2705" : exp.status === "partial" ? "\u{1F7E1}" : "\u{1F534}";
+    lines.push(`${expIcon} ${exp.name}`);
+    for (const cond of exp.conditions) {
+      const condIcon = cond.status === "satisfied" ? "  \u2713" : cond.status === "violated" ? "  \u2717" : "  ?";
+      lines.push(`${condIcon} [${cond.condition.type}] ${cond.condition.description}`);
+      lines.push(`      ${cond.explanation}`);
+    }
+    if (exp.edgeCases.length > 0) {
+      lines.push("  Edge cases:");
+      for (const ec of exp.edgeCases) {
+        lines.push(`    \u26A0\uFE0F ${ec}`);
+      }
+    }
+    lines.push("");
+  }
+  if (report.allMitigations.length > 0) {
+    lines.push("Suggested mitigations:");
+    for (const m of report.allMitigations) {
+      lines.push(`  \u{1F4A1} ${m}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/factory/factory.ts
+init_rule_result();
+var SANITIZE_PATTERNS = {
+  "sql-injection": /('|"|;|--|\/\*|\*\/|xp_|exec\s|union\s+select|drop\s+table|insert\s+into|delete\s+from)/i,
+  "xss": /(<script|javascript:|on\w+\s*=|<iframe|<object|<embed|<img[^>]+onerror)/i,
+  "path-traversal": /(\.\.[/\\]|~\/|\/etc\/|\/proc\/)/i,
+  "command-injection": /([;&|`$]|\$\(|>\s*\/)/i
+};
+function inputRules(config = {}) {
+  const {
+    sanitize = [],
+    maxLength = 0,
+    required = false,
+    fieldName = "input"
+  } = config;
+  const rules = [];
+  const constraints = [];
+  if (sanitize.length > 0) {
+    rules.push({
+      id: `factory/input.sanitize-${fieldName}`,
+      description: `Validates ${fieldName} against ${sanitize.join(", ")} patterns`,
+      eventTypes: [`${fieldName}.submit`, `${fieldName}.change`],
+      contract: {
+        ruleId: `factory/input.sanitize-${fieldName}`,
+        behavior: `Checks ${fieldName} for dangerous patterns: ${sanitize.join(", ")}`,
+        examples: [
+          { given: `${fieldName} contains safe text`, when: "input submitted", then: "input.valid emitted" },
+          { given: `${fieldName} contains <script> tag`, when: "input submitted", then: "input.violation emitted" }
+        ],
+        invariants: [
+          `Dangerous ${fieldName} patterns must never pass validation`,
+          "All violations must include the violation type"
+        ]
+      },
+      impl: (state2, events) => {
+        const inputEvent = events.find(
+          (e) => e.tag === `${fieldName}.submit` || e.tag === `${fieldName}.change`
+        );
+        if (!inputEvent) return RuleResult.skip("No input event");
+        const value = inputEvent.payload?.value ?? state2.context.input?.value ?? "";
+        const violations = [];
+        for (const type of sanitize) {
+          const pattern = SANITIZE_PATTERNS[type];
+          if (pattern && pattern.test(value)) {
+            violations.push(type);
+          }
+        }
+        if (violations.length > 0) {
+          return RuleResult.emit([
+            fact(`${fieldName}.violation`, {
+              field: fieldName,
+              violations,
+              message: `Input failed sanitization: ${violations.join(", ")}`
+            })
+          ]);
+        }
+        return RuleResult.emit([
+          fact(`${fieldName}.valid`, { field: fieldName, sanitized: true })
+        ]);
+      }
+    });
+  }
+  if (maxLength > 0) {
+    constraints.push({
+      id: `factory/input.max-length-${fieldName}`,
+      description: `${fieldName} must not exceed ${maxLength} characters`,
+      contract: {
+        ruleId: `factory/input.max-length-${fieldName}`,
+        behavior: `Enforces max length of ${maxLength} for ${fieldName}`,
+        examples: [
+          { given: `${fieldName} is 10 chars`, when: `maxLength is ${maxLength}`, then: maxLength >= 10 ? "passes" : "violation" }
+        ],
+        invariants: [`${fieldName} length must never exceed ${maxLength}`]
+      },
+      impl: (state2) => {
+        const value = state2.context.input?.value ?? "";
+        if (value.length > maxLength) {
+          return `${fieldName} exceeds maximum length of ${maxLength} (got ${value.length})`;
+        }
+        return true;
+      }
+    });
+  }
+  if (required) {
+    constraints.push({
+      id: `factory/input.required-${fieldName}`,
+      description: `${fieldName} is required and must not be empty`,
+      contract: {
+        ruleId: `factory/input.required-${fieldName}`,
+        behavior: `Enforces that ${fieldName} is non-empty`,
+        examples: [
+          { given: `${fieldName} is "hello"`, when: "checked", then: "passes" },
+          { given: `${fieldName} is empty`, when: "checked", then: "violation" }
+        ],
+        invariants: [`${fieldName} must never be empty when required`]
+      },
+      impl: (state2) => {
+        const value = state2.context.input?.value ?? "";
+        if (value.trim().length === 0) {
+          return `${fieldName} is required but empty`;
+        }
+        return true;
+      }
+    });
+  }
+  return { rules, constraints };
+}
+function toastRules(config = {}) {
+  const {
+    requireDiff = false,
+    autoDismissMs = 0,
+    deduplicate = false
+  } = config;
+  const rules = [];
+  const constraints = [];
+  rules.push({
+    id: "factory/toast.show",
+    description: "Emits toast notification with content and config",
+    eventTypes: ["toast.request"],
+    contract: {
+      ruleId: "factory/toast.show",
+      behavior: "Shows toast when requested, respecting diff requirement and auto-dismiss",
+      examples: [
+        { given: "toast requested with message", when: "toast.request fires", then: "toast.show emitted" },
+        ...requireDiff ? [{ given: "no diff present", when: "toast.request fires", then: "toast skipped" }] : []
+      ],
+      invariants: [
+        "Toast message must be non-empty",
+        ...requireDiff ? ["Toast must not appear when diff is empty"] : []
+      ]
+    },
+    impl: (state2, events) => {
+      const toastEvent = events.find((e) => e.tag === "toast.request");
+      if (!toastEvent) return RuleResult.skip("No toast request");
+      const payload = toastEvent.payload;
+      const message = payload.message ?? "";
+      if (!message) return RuleResult.skip("Empty toast message");
+      if (requireDiff) {
+        const diff = state2.context.diff;
+        if (!diff || Object.keys(diff).length === 0) {
+          return RuleResult.skip("No diff \u2014 toast suppressed");
+        }
+      }
+      return RuleResult.emit([
+        fact("toast.show", {
+          message,
+          type: payload.type ?? "info",
+          autoDismissMs: autoDismissMs > 0 ? autoDismissMs : void 0,
+          timestamp: Date.now()
+        })
+      ]);
+    }
+  });
+  if (deduplicate) {
+    constraints.push({
+      id: "factory/toast.no-duplicates",
+      description: "Prevents duplicate toast messages",
+      contract: {
+        ruleId: "factory/toast.no-duplicates",
+        behavior: "Rejects toast if identical message is already showing",
+        examples: [
+          { given: "same toast already visible", when: "duplicate toast requested", then: "violation" }
+        ],
+        invariants: ["No two toasts may have the same message simultaneously"]
+      },
+      impl: (state2) => {
+        const toasts = state2.context.toasts ?? [];
+        const messages = toasts.map((t) => t.message);
+        const uniqueMessages = new Set(messages);
+        if (uniqueMessages.size < messages.length) {
+          return "Duplicate toast detected";
+        }
+        return true;
+      }
+    });
+  }
+  return { rules, constraints };
+}
+function formRules(config = {}) {
+  const {
+    validateOnBlur = false,
+    submitGate = false,
+    formName = "form"
+  } = config;
+  const rules = [];
+  const constraints = [];
+  if (validateOnBlur) {
+    rules.push({
+      id: `factory/${formName}.validate-on-blur`,
+      description: `Triggers field validation when a ${formName} field loses focus`,
+      eventTypes: [`${formName}.blur`],
+      contract: {
+        ruleId: `factory/${formName}.validate-on-blur`,
+        behavior: `Validates the blurred field and emits validation result`,
+        examples: [
+          { given: `${formName} field has value`, when: "field loses focus", then: "validation result emitted" }
+        ],
+        invariants: ["Validation must run for every blur event on a registered field"]
+      },
+      impl: (_state, events) => {
+        const blurEvent = events.find((e) => e.tag === `${formName}.blur`);
+        if (!blurEvent) return RuleResult.skip("No blur event");
+        const payload = blurEvent.payload;
+        const field = payload.field ?? "unknown";
+        const value = payload.value;
+        const valid = value !== null && value !== void 0 && value !== "";
+        return RuleResult.emit([
+          fact(`${formName}.field-validated`, {
+            field,
+            valid,
+            error: valid ? null : `${field} is required`
+          })
+        ]);
+      }
+    });
+  }
+  if (submitGate) {
+    constraints.push({
+      id: `factory/${formName}.submit-gate`,
+      description: `Prevents ${formName} submission when validation has not passed`,
+      contract: {
+        ruleId: `factory/${formName}.submit-gate`,
+        behavior: `Blocks form submission until all fields are valid`,
+        examples: [
+          { given: `${formName} is invalid`, when: "submit attempted", then: "violation \u2014 submission blocked" },
+          { given: `${formName} is valid`, when: "submit attempted", then: "passes" }
+        ],
+        invariants: ["Form must not submit while any field has errors"]
+      },
+      impl: (state2) => {
+        const form = state2.context.form;
+        if (!form) return true;
+        if (form.submitting && !form.valid) {
+          return `${formName} cannot submit: validation has not passed`;
+        }
+        return true;
+      }
+    });
+  }
+  rules.push({
+    id: `factory/${formName}.dirty-tracking`,
+    description: `Tracks whether ${formName} has unsaved changes`,
+    eventTypes: [`${formName}.change`, `${formName}.reset`],
+    contract: {
+      ruleId: `factory/${formName}.dirty-tracking`,
+      behavior: "Emits dirty state when form fields change, clears on reset",
+      examples: [
+        { given: "field value changed", when: "form.change fires", then: "form.dirty emitted" },
+        { given: "form reset", when: "form.reset fires", then: "form.dirty retracted" }
+      ],
+      invariants: ["Dirty state must reflect actual field changes"]
+    },
+    impl: (_state, events) => {
+      const resetEvent = events.find((e) => e.tag === `${formName}.reset`);
+      if (resetEvent) {
+        return RuleResult.retract([`${formName}.dirty`], "Form reset");
+      }
+      const changeEvent = events.find((e) => e.tag === `${formName}.change`);
+      if (changeEvent) {
+        return RuleResult.emit([
+          fact(`${formName}.dirty`, { dirty: true })
+        ]);
+      }
+      return RuleResult.skip("No form event");
+    }
+  });
+  return { rules, constraints };
+}
+function navigationRules(config = {}) {
+  const {
+    dirtyGuard = false,
+    authRequired = false
+  } = config;
+  const rules = [];
+  const constraints = [];
+  rules.push({
+    id: "factory/navigation.handle",
+    description: "Processes navigation requests and emits navigation facts",
+    eventTypes: ["navigation.request"],
+    contract: {
+      ruleId: "factory/navigation.handle",
+      behavior: "Emits navigation.allowed or navigation.blocked based on guards",
+      examples: [
+        { given: "no guards active", when: "navigation requested", then: "navigation.allowed emitted" },
+        ...dirtyGuard ? [{ given: "form is dirty", when: "navigation requested", then: "navigation.blocked emitted" }] : [],
+        ...authRequired ? [{ given: "user not authenticated", when: "navigation requested", then: "navigation.blocked emitted" }] : []
+      ],
+      invariants: [
+        "Every navigation request must result in either allowed or blocked",
+        ...dirtyGuard ? ["Navigation must be blocked when dirty data exists"] : [],
+        ...authRequired ? ["Navigation must be blocked when not authenticated"] : []
+      ]
+    },
+    impl: (state2, events) => {
+      const navEvent = events.find((e) => e.tag === "navigation.request");
+      if (!navEvent) return RuleResult.skip("No navigation request");
+      const target = navEvent.payload?.target ?? "/";
+      const reasons = [];
+      if (dirtyGuard && state2.context.dirty) {
+        reasons.push("Unsaved changes will be lost");
+      }
+      if (authRequired && !state2.context.authenticated) {
+        reasons.push("Authentication required");
+      }
+      if (reasons.length > 0) {
+        return RuleResult.emit([
+          fact("navigation.blocked", { target, reasons })
+        ]);
+      }
+      return RuleResult.emit([
+        fact("navigation.allowed", { target })
+      ]);
+    }
+  });
+  if (dirtyGuard) {
+    constraints.push({
+      id: "factory/navigation.dirty-guard",
+      description: "Prevents silent navigation when unsaved changes exist",
+      contract: {
+        ruleId: "factory/navigation.dirty-guard",
+        behavior: "Blocks navigation when dirty state is true",
+        examples: [
+          { given: "dirty is true", when: "navigation attempted", then: "violation" },
+          { given: "dirty is false", when: "navigation attempted", then: "passes" }
+        ],
+        invariants: ["Must never silently lose unsaved changes"]
+      },
+      impl: (state2) => {
+        if (state2.context.dirty && state2.facts.some((f) => f.tag === "navigation.allowed")) {
+          return "Navigation allowed while dirty \u2014 unsaved changes may be lost";
+        }
+        return true;
+      }
+    });
+  }
+  return { rules, constraints };
+}
+function dataRules(config = {}) {
+  const {
+    optimisticUpdate = false,
+    rollbackOnError = false,
+    cacheInvalidation = false,
+    entityName = "data"
+  } = config;
+  const rules = [];
+  const constraints = [];
+  if (optimisticUpdate) {
+    rules.push({
+      id: `factory/${entityName}.optimistic-update`,
+      description: `Applies optimistic update for ${entityName} while request is pending`,
+      eventTypes: [`${entityName}.mutate`],
+      contract: {
+        ruleId: `factory/${entityName}.optimistic-update`,
+        behavior: `Immediately emits updated ${entityName} state before server confirmation`,
+        examples: [
+          { given: `${entityName} mutation requested`, when: "mutate event fires", then: "optimistic state emitted" }
+        ],
+        invariants: [
+          "Optimistic state must store original for rollback",
+          "Optimistic update must be distinguishable from confirmed state"
+        ]
+      },
+      impl: (_state, events) => {
+        const mutateEvent = events.find((e) => e.tag === `${entityName}.mutate`);
+        if (!mutateEvent) return RuleResult.skip("No mutation event");
+        const payload = mutateEvent.payload;
+        return RuleResult.emit([
+          fact(`${entityName}.optimistic`, {
+            id: payload.id,
+            data: payload.data,
+            pending: true,
+            timestamp: Date.now()
+          })
+        ]);
+      }
+    });
+  }
+  if (rollbackOnError) {
+    rules.push({
+      id: `factory/${entityName}.rollback`,
+      description: `Rolls back optimistic ${entityName} update on error`,
+      eventTypes: [`${entityName}.error`],
+      contract: {
+        ruleId: `factory/${entityName}.rollback`,
+        behavior: `Reverts to original ${entityName} state when mutation fails`,
+        examples: [
+          { given: "optimistic update was applied", when: "server returns error", then: "rollback emitted, optimistic retracted" }
+        ],
+        invariants: [
+          "Rollback must restore original state exactly",
+          "Optimistic facts must be retracted on rollback"
+        ]
+      },
+      impl: (_state, events) => {
+        const errorEvent = events.find((e) => e.tag === `${entityName}.error`);
+        if (!errorEvent) return RuleResult.skip("No error event");
+        const payload = errorEvent.payload;
+        const result = RuleResult.emit([
+          fact(`${entityName}.rollback`, {
+            id: payload.id,
+            error: payload.error,
+            timestamp: Date.now()
+          })
+        ]);
+        return result;
+      }
+    });
+  }
+  if (cacheInvalidation) {
+    rules.push({
+      id: `factory/${entityName}.cache-invalidate`,
+      description: `Invalidates ${entityName} cache when data changes are confirmed`,
+      eventTypes: [`${entityName}.confirmed`, `${entityName}.deleted`],
+      contract: {
+        ruleId: `factory/${entityName}.cache-invalidate`,
+        behavior: `Emits cache invalidation signal when ${entityName} is confirmed or deleted`,
+        examples: [
+          { given: `${entityName} mutation confirmed`, when: "confirmed event fires", then: "cache.invalidate emitted" }
+        ],
+        invariants: ["Stale cache entries must be invalidated after confirmed mutations"]
+      },
+      impl: (_state, events) => {
+        const confirmEvent = events.find(
+          (e) => e.tag === `${entityName}.confirmed` || e.tag === `${entityName}.deleted`
+        );
+        if (!confirmEvent) return RuleResult.skip("No confirmation event");
+        const payload = confirmEvent.payload;
+        return RuleResult.emit([
+          fact(`${entityName}.cache-invalidate`, {
+            id: payload.id,
+            timestamp: Date.now()
+          })
+        ]);
+      }
+    });
+  }
+  constraints.push({
+    id: `factory/${entityName}.integrity`,
+    description: `Ensures ${entityName} state integrity \u2014 no orphaned optimistic updates`,
+    contract: {
+      ruleId: `factory/${entityName}.integrity`,
+      behavior: "Detects orphaned optimistic updates without pending confirmation",
+      examples: [
+        { given: "optimistic update exists without pending request", when: "checked", then: "violation" }
+      ],
+      invariants: [`Every optimistic ${entityName} update must have a corresponding pending request`]
+    },
+    impl: (state2) => {
+      const pending = state2.context.pending ?? {};
+      const optimisticFacts = state2.facts.filter((f) => f.tag === `${entityName}.optimistic`);
+      for (const optFact of optimisticFacts) {
+        const id = optFact.payload?.id;
+        if (id && !pending[id]) {
+          return `Orphaned optimistic update for ${entityName} id=${id} \u2014 no pending request`;
+        }
+      }
+      return true;
+    }
+  });
+  return { rules, constraints };
+}
+
+// src/project/project.ts
+init_rule_result();
+function defineGate(name, config) {
+  const { expects, onSatisfied, onViolation } = config;
+  const rule = {
+    id: `gate/${name}`,
+    description: `Feature gate: ${name} \u2014 requires: ${expects.join(", ")}`,
+    eventTypes: ["gate.check", `gate.${name}.check`],
+    contract: {
+      ruleId: `gate/${name}`,
+      behavior: `Opens gate "${name}" when all expectations are met: ${expects.join(", ")}`,
+      examples: [
+        {
+          given: `all expectations satisfied: ${expects.join(", ")}`,
+          when: "gate checked",
+          then: `gate.${name}.open emitted${onSatisfied ? ` \u2192 ${onSatisfied}` : ""}`
+        },
+        {
+          given: "one or more expectations unsatisfied",
+          when: "gate checked",
+          then: `gate.${name}.blocked emitted${onViolation ? ` \u2192 ${onViolation}` : ""}`
+        }
+      ],
+      invariants: [
+        `Gate "${name}" must never open with unsatisfied expectations`,
+        "Gate status must reflect current expectation state exactly"
+      ]
+    },
+    impl: (state2, events) => {
+      const gateEvent = events.find(
+        (e) => e.tag === "gate.check" || e.tag === `gate.${name}.check`
+      );
+      if (!gateEvent) return RuleResult.skip("No gate check event");
+      const expectationState = state2.context.expectations ?? {};
+      const satisfied = [];
+      const unsatisfied = [];
+      for (const exp of expects) {
+        if (expectationState[exp]) {
+          satisfied.push(exp);
+        } else {
+          unsatisfied.push(exp);
+        }
+      }
+      const status = unsatisfied.length === 0 ? "open" : "blocked";
+      const gateState = {
+        name,
+        status,
+        satisfied,
+        unsatisfied,
+        lastChanged: Date.now()
+      };
+      const facts = [fact(`gate.${name}.status`, gateState)];
+      if (status === "open" && onSatisfied) {
+        facts.push(fact(`gate.${name}.action`, { action: onSatisfied }));
+      } else if (status === "blocked" && onViolation) {
+        facts.push(fact(`gate.${name}.action`, { action: onViolation }));
+      }
+      return RuleResult.emit(facts);
+    }
+  };
+  const constraint = {
+    id: `gate/${name}/integrity`,
+    description: `Ensures gate "${name}" status matches expectation reality`,
+    contract: {
+      ruleId: `gate/${name}/integrity`,
+      behavior: `Validates that gate "${name}" is not open when expectations are unmet`,
+      examples: [
+        {
+          given: `gate ${name} is open but expectations unmet`,
+          when: "constraint checked",
+          then: "violation"
+        }
+      ],
+      invariants: [`Gate "${name}" must never report open when expectations are unsatisfied`]
+    },
+    impl: (state2) => {
+      const gateState = state2.context.gates?.[name];
+      if (!gateState) return true;
+      if (gateState.status === "open" && gateState.unsatisfied.length > 0) {
+        return `Gate "${name}" is open but has unsatisfied expectations: ${gateState.unsatisfied.join(", ")}`;
+      }
+      return true;
+    }
+  };
+  return { rules: [rule], constraints: [constraint] };
+}
+function semverContract(config) {
+  const { sources, invariants } = config;
+  const rule = {
+    id: "project/semver-check",
+    description: `Checks version consistency across: ${sources.join(", ")}`,
+    eventTypes: ["project.version-check"],
+    contract: {
+      ruleId: "project/semver-check",
+      behavior: `Verifies version consistency across ${sources.length} sources`,
+      examples: [
+        {
+          given: "all sources have version 1.2.3",
+          when: "version check runs",
+          then: "semver.consistent emitted"
+        },
+        {
+          given: "package.json has 1.2.3 but README has 1.2.2",
+          when: "version check runs",
+          then: "semver.inconsistent emitted with diff"
+        }
+      ],
+      invariants: invariants.length > 0 ? invariants : ["All version sources must report the same semver string"]
+    },
+    impl: (_state, events) => {
+      const checkEvent = events.find((e) => e.tag === "project.version-check");
+      if (!checkEvent) return RuleResult.skip("No version check event");
+      const versions = checkEvent.payload?.versions ?? {};
+      const versionValues = Object.values(versions);
+      const unique = new Set(versionValues);
+      if (unique.size <= 1) {
+        return RuleResult.emit([
+          fact("semver.consistent", {
+            version: versionValues[0] ?? "unknown",
+            sources: Object.keys(versions)
+          })
+        ]);
+      }
+      const report = {
+        consistent: false,
+        versions,
+        violations: [`Version mismatch: ${JSON.stringify(versions)}`]
+      };
+      return RuleResult.emit([fact("semver.inconsistent", report)]);
+    }
+  };
+  return { rules: [rule], constraints: [] };
+}
+function commitFromState(diff) {
+  const parts = [];
+  const bodyParts = [];
+  const totalAdded = diff.rulesAdded.length + diff.contractsAdded.length + diff.expectationsAdded.length;
+  const totalRemoved = diff.rulesRemoved.length + diff.contractsRemoved.length + diff.expectationsRemoved.length;
+  const totalModified = diff.rulesModified.length;
+  const hasGateChanges = diff.gateChanges.length > 0;
+  if (totalAdded > 0 && totalRemoved === 0 && totalModified === 0) {
+    if (diff.rulesAdded.length > 0) {
+      const scope = inferScope(diff.rulesAdded);
+      parts.push(`feat(${scope}): add ${formatIds(diff.rulesAdded)}`);
+    } else if (diff.contractsAdded.length > 0) {
+      parts.push(`feat(contracts): add contracts for ${formatIds(diff.contractsAdded)}`);
+    } else {
+      parts.push(`feat(expectations): add ${formatIds(diff.expectationsAdded)}`);
+    }
+  } else if (totalRemoved > 0 && totalAdded === 0) {
+    if (diff.rulesRemoved.length > 0) {
+      const scope = inferScope(diff.rulesRemoved);
+      parts.push(`refactor(${scope}): remove ${formatIds(diff.rulesRemoved)}`);
+    } else {
+      parts.push(`refactor: remove ${totalRemoved} item(s)`);
+    }
+  } else if (totalModified > 0) {
+    const scope = inferScope(diff.rulesModified);
+    parts.push(`refactor(${scope}): update ${formatIds(diff.rulesModified)}`);
+  } else if (hasGateChanges) {
+    const gateNames = diff.gateChanges.map((g) => g.gate);
+    parts.push(`chore(gates): ${formatIds(gateNames)} state changed`);
+  } else {
+    parts.push("chore: behavioral state update");
+  }
+  if (diff.rulesAdded.length > 0) bodyParts.push(`Rules added: ${diff.rulesAdded.join(", ")}`);
+  if (diff.rulesRemoved.length > 0) bodyParts.push(`Rules removed: ${diff.rulesRemoved.join(", ")}`);
+  if (diff.rulesModified.length > 0) bodyParts.push(`Rules modified: ${diff.rulesModified.join(", ")}`);
+  if (diff.contractsAdded.length > 0) bodyParts.push(`Contracts added: ${diff.contractsAdded.join(", ")}`);
+  if (diff.contractsRemoved.length > 0) bodyParts.push(`Contracts removed: ${diff.contractsRemoved.join(", ")}`);
+  if (diff.expectationsAdded.length > 0) bodyParts.push(`Expectations added: ${diff.expectationsAdded.join(", ")}`);
+  if (diff.expectationsRemoved.length > 0) bodyParts.push(`Expectations removed: ${diff.expectationsRemoved.join(", ")}`);
+  for (const gc of diff.gateChanges) {
+    bodyParts.push(`Gate "${gc.gate}": ${gc.from} \u2192 ${gc.to}`);
+  }
+  const subject = parts[0] || "chore: update";
+  return bodyParts.length > 0 ? `${subject}
+
+${bodyParts.join("\n")}` : subject;
+}
+function inferScope(ids) {
+  if (ids.length === 0) return "rules";
+  const prefixes = ids.map((id) => {
+    const slash = id.indexOf("/");
+    return slash > 0 ? id.slice(0, slash) : id;
+  });
+  const unique = new Set(prefixes);
+  return unique.size === 1 ? prefixes[0] : "rules";
+}
+function formatIds(ids) {
+  if (ids.length <= 3) return ids.join(", ");
+  return `${ids.slice(0, 2).join(", ")} (+${ids.length - 2} more)`;
+}
+function branchRules(config) {
+  const { naming, mergeConditions } = config;
+  const namePattern = naming.replace("{name}", "(.+)").replace("{issue}", "(\\d+)");
+  const nameRegex = new RegExp(`^${namePattern}$`);
+  const rule = {
+    id: "project/branch-check",
+    description: `Validates branch naming (${naming}) and merge conditions`,
+    eventTypes: ["project.branch-check"],
+    contract: {
+      ruleId: "project/branch-check",
+      behavior: `Ensures branch follows "${naming}" pattern and merge conditions are met`,
+      examples: [
+        {
+          given: `branch named "${naming.replace("{name}", "my-feature")}"`,
+          when: "branch checked",
+          then: "branch.valid emitted"
+        },
+        {
+          given: 'branch named "random-name"',
+          when: "branch checked",
+          then: "branch.invalid emitted"
+        }
+      ],
+      invariants: [
+        `Branch names must follow pattern: ${naming}`,
+        `Merge requires: ${mergeConditions.join(", ")}`
+      ]
+    },
+    impl: (_state, events) => {
+      const checkEvent = events.find((e) => e.tag === "project.branch-check");
+      if (!checkEvent) return RuleResult.skip("No branch check event");
+      const payload = checkEvent.payload;
+      const branch = payload.branch ?? "";
+      const conditions = payload.conditions ?? {};
+      const validName = nameRegex.test(branch);
+      const unmetConditions = mergeConditions.filter((c) => !conditions[c]);
+      if (validName && unmetConditions.length === 0) {
+        return RuleResult.emit([
+          fact("branch.valid", { branch, mergeReady: true })
+        ]);
+      }
+      const reasons = [];
+      if (!validName) reasons.push(`Branch name "${branch}" doesn't match pattern "${naming}"`);
+      if (unmetConditions.length > 0) reasons.push(`Unmet merge conditions: ${unmetConditions.join(", ")}`);
+      return RuleResult.emit([
+        fact("branch.invalid", { branch, reasons, mergeReady: false })
+      ]);
+    }
+  };
+  return { rules: [rule], constraints: [] };
+}
+function lintGate(config = {}) {
+  const expects = ["lint-passes", ...config.additionalExpects ?? []];
+  return defineGate("lint", {
+    expects,
+    onSatisfied: "lint-passed",
+    onViolation: "lint-failed"
+  });
+}
+function formatGate(config = {}) {
+  const expects = ["format-passes", ...config.additionalExpects ?? []];
+  return defineGate("format", {
+    expects,
+    onSatisfied: "format-passed",
+    onViolation: "format-failed"
+  });
+}
+function expectationGate(config = {}) {
+  const expects = ["expectations-verified", ...config.additionalExpects ?? []];
+  return defineGate("expectations", {
+    expects,
+    onSatisfied: "expectations-passed",
+    onViolation: "expectations-failed"
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AcknowledgeContractGap,
@@ -4665,6 +6205,8 @@ async function attachAllIntegrations(engine, registry, options = {}) {
   ContractMissing,
   ContractUpdated,
   ContractValidated,
+  Expectation,
+  ExpectationSet,
   FrameworkAgnosticReactiveEngine,
   InMemoryPraxisDB,
   LogicEngine,
@@ -4678,6 +6220,7 @@ async function attachAllIntegrations(engine, registry, options = {}) {
   PraxisSchemaRegistry,
   ReactiveLogicEngine,
   RegistryIntrospector,
+  RuleResult,
   StateDocsGenerator,
   TerminalAdapter,
   ValidateContracts,
@@ -4685,9 +6228,12 @@ async function attachAllIntegrations(engine, registry, options = {}) {
   attachTauriToEngine,
   attachToEngine,
   attachUnumToEngine,
+  auditCompleteness,
+  branchRules,
   canvasToMermaid,
   canvasToSchema,
   canvasToYaml,
+  commitFromState,
   createBehaviorLedger,
   createCanvasEditor,
   createChronicle,
@@ -4710,21 +6256,33 @@ async function attachAllIntegrations(engine, registry, options = {}) {
   createTauriPraxisAdapter,
   createTerminalAdapter,
   createTimerActor,
+  createUIModule,
   createUnifiedApp,
   createUnumAdapter,
+  dataRules,
   defineConstraint,
   defineContract,
   defineEvent,
   defineFact,
+  defineGate,
   defineModule,
   defineRule,
+  dirtyGuardRule,
+  errorDisplayRule,
+  expectBehavior,
+  expectationGate,
+  fact,
   filterEvents,
   filterFacts,
   findEvent,
   findFact,
+  formRules,
+  formatGate,
+  formatReport,
   formatValidationReport,
   formatValidationReportJSON,
   formatValidationReportSARIF,
+  formatVerificationReport,
   generateDocs,
   generateId,
   generateTauriConfig,
@@ -4732,16 +6290,32 @@ async function attachAllIntegrations(engine, registry, options = {}) {
   getEventPath,
   getFactPath,
   getSchemaPath,
+  initGateRule,
+  inputRules,
   isContract,
+  lintGate,
   loadSchema,
   loadSchemaFromFile,
   loadSchemaFromJson,
   loadSchemaFromYaml,
+  loadingGateRule,
+  mustBeInitializedConstraint,
+  navigationRequest,
+  navigationRules,
+  noInteractionWhileLoadingConstraint,
+  offlineIndicatorRule,
   registerSchema,
+  resizeEvent,
   runTerminalCommand,
   schemaToCanvas,
+  semverContract,
+  toastRules,
+  uiModule,
+  uiStateChanged,
   validateContracts,
   validateForGeneration,
   validateSchema,
-  validateWithGuardian
+  validateWithGuardian,
+  verify,
+  viewportRule
 });