@plures/praxis 1.2.13 → 1.3.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,11 +161,16 @@ var init_engine = __esm({
   "src/core/engine.ts"() {
     "use strict";
     init_protocol();
+    init_rule_result();
     LogicEngine = class {
       state;
       registry;
+      factDedup;
+      maxFacts;
       constructor(options) {
         this.registry = options.registry;
+        this.factDedup = options.factDedup ?? "last-write-wins";
+        this.maxFacts = options.maxFacts ?? 1e3;
         this.state = {
           context: options.initialContext,
           facts: options.initialFacts ?? [],
@@ -127,7 +225,14 @@ 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);
           if (!rule) {
@@ -138,9 +243,38 @@ var init_engine = __esm({
             });
             continue;
           }
+          if (rule.eventTypes) {
+            const filterTags = Array.isArray(rule.eventTypes) ? rule.eventTypes : [rule.eventTypes];
+            if (!filterTags.some((t) => eventTags.has(t))) {
+              continue;
+            }
+          }
           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",
@@ -149,9 +283,34 @@ 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 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 = [...existingFacts, ...newFacts];
+            break;
+          case "none":
+          default:
+            mergedFacts = [...existingFacts, ...newFacts];
+            break;
+        }
+        if (this.maxFacts > 0 && mergedFacts.length > this.maxFacts) {
+          mergedFacts = mergedFacts.slice(mergedFacts.length - this.maxFacts);
+        }
         newState = {
           ...newState,
-          facts: [...newState.facts, ...newFacts]
+          facts: mergedFacts
         };
         for (const constraintId of config.constraintIds) {
           const constraint = this.registry.getConstraint(constraintId);
@@ -204,6 +363,29 @@ var init_engine = __esm({
           context: updater(this.state.context)
         };
       }
+      /**
+       * Atomically update context AND process events in a single call.
+       *
+       * This avoids the fragile pattern of calling updateContext() then step()
+       * separately, where rules could see stale context if the ordering is wrong.
+       *
+       * @param updater Function that produces new context from old context
+       * @param events Events to process after context is updated
+       * @returns Result with new state and diagnostics
+       *
+       * @example
+       * engine.stepWithContext(
+       *   ctx => ({ ...ctx, sprintName: sprint.name, items: sprint.items }),
+       *   [{ tag: 'sprint.update', payload: { name: sprint.name } }]
+       * );
+       */
+      stepWithContext(updater, events) {
+        this.state = {
+          ...this.state,
+          context: updater(this.state.context)
+        };
+        return this.step(events);
+      }
       /**
        * Add facts directly (for exceptional cases).
        * Generally, facts should be added through rules.
@@ -216,6 +398,21 @@ var init_engine = __esm({
           facts: [...this.state.facts, ...facts]
         };
       }
+      /**
+       * Check all constraints without processing any events.
+       *
+       * Useful for validation-only scenarios (e.g., form validation,
+       * pre-save checks) where you want constraint diagnostics without
+       * triggering any rules.
+       *
+       * @returns Array of constraint violation diagnostics (empty = all passing)
+       */
+      checkConstraints() {
+        return this.stepWithConfig([], {
+          ruleIds: [],
+          constraintIds: this.registry.getConstraintIds()
+        }).diagnostics;
+      }
       /**
        * Clear all facts
        */
@@ -405,6 +602,8 @@ __export(src_exports, {
   AcknowledgeContractGap: () => AcknowledgeContractGap,
   ActorManager: () => ActorManager,
   BehaviorLedger: () => BehaviorLedger,
+  CHRONICLE_PATHS: () => CHRONICLE_PATHS,
+  ChronicleContext: () => ChronicleContext,
   ContractAdded: () => ContractAdded,
   ContractGapAcknowledged: () => ContractGapAcknowledged,
   ContractMissing: () => ContractMissing,
@@ -417,11 +616,13 @@ __export(src_exports, {
   PRAXIS_PROTOCOL_VERSION: () => PRAXIS_PROTOCOL_VERSION,
   PluresDBGenerator: () => PluresDBGenerator,
   PluresDBPraxisAdapter: () => PluresDBPraxisAdapter,
+  PluresDbChronicle: () => PluresDbChronicle,
   PraxisDBStore: () => PraxisDBStore,
   PraxisRegistry: () => PraxisRegistry,
   PraxisSchemaRegistry: () => PraxisSchemaRegistry,
   ReactiveLogicEngine: () => ReactiveLogicEngine,
   RegistryIntrospector: () => RegistryIntrospector,
+  RuleResult: () => RuleResult,
   StateDocsGenerator: () => StateDocsGenerator,
   TerminalAdapter: () => TerminalAdapter,
   ValidateContracts: () => ValidateContracts,
@@ -429,11 +630,14 @@ __export(src_exports, {
   attachTauriToEngine: () => attachTauriToEngine,
   attachToEngine: () => attachToEngine,
   attachUnumToEngine: () => attachUnumToEngine,
+  auditCompleteness: () => auditCompleteness,
   canvasToMermaid: () => canvasToMermaid,
   canvasToSchema: () => canvasToSchema,
   canvasToYaml: () => canvasToYaml,
   createBehaviorLedger: () => createBehaviorLedger,
   createCanvasEditor: () => createCanvasEditor,
+  createChronicle: () => createChronicle,
+  createChronosMcpTools: () => createChronosMcpTools,
   createFrameworkAgnosticReactiveEngine: () => createReactiveEngine2,
   createInMemoryDB: () => createInMemoryDB,
   createIntrospector: () => createIntrospector,
@@ -452,6 +656,7 @@ __export(src_exports, {
   createTauriPraxisAdapter: () => createTauriPraxisAdapter,
   createTerminalAdapter: () => createTerminalAdapter,
   createTimerActor: () => createTimerActor,
+  createUIModule: () => createUIModule,
   createUnifiedApp: () => createUnifiedApp,
   createUnumAdapter: () => createUnumAdapter,
   defineConstraint: () => defineConstraint,
@@ -460,10 +665,14 @@ __export(src_exports, {
   defineFact: () => defineFact,
   defineModule: () => defineModule,
   defineRule: () => defineRule,
+  dirtyGuardRule: () => dirtyGuardRule,
+  errorDisplayRule: () => errorDisplayRule,
+  fact: () => fact,
   filterEvents: () => filterEvents,
   filterFacts: () => filterFacts,
   findEvent: () => findEvent,
   findFact: () => findFact,
+  formatReport: () => formatReport,
   formatValidationReport: () => formatValidationReport,
   formatValidationReportJSON: () => formatValidationReportJSON,
   formatValidationReportSARIF: () => formatValidationReportSARIF,
@@ -474,18 +683,28 @@ __export(src_exports, {
   getEventPath: () => getEventPath,
   getFactPath: () => getFactPath,
   getSchemaPath: () => getSchemaPath,
+  initGateRule: () => initGateRule,
   isContract: () => isContract,
   loadSchema: () => loadSchema,
   loadSchemaFromFile: () => loadSchemaFromFile,
   loadSchemaFromJson: () => loadSchemaFromJson,
   loadSchemaFromYaml: () => loadSchemaFromYaml,
+  loadingGateRule: () => loadingGateRule,
+  mustBeInitializedConstraint: () => mustBeInitializedConstraint,
+  navigationRequest: () => navigationRequest,
+  noInteractionWhileLoadingConstraint: () => noInteractionWhileLoadingConstraint,
+  offlineIndicatorRule: () => offlineIndicatorRule,
   registerSchema: () => registerSchema,
+  resizeEvent: () => resizeEvent,
   runTerminalCommand: () => runTerminalCommand,
   schemaToCanvas: () => schemaToCanvas,
+  uiModule: () => uiModule,
+  uiStateChanged: () => uiStateChanged,
   validateContracts: () => validateContracts,
   validateForGeneration: () => validateForGeneration,
   validateSchema: () => validateSchema,
-  validateWithGuardian: () => validateWithGuardian
+  validateWithGuardian: () => validateWithGuardian,
+  viewportRule: () => viewportRule
 });
 module.exports = __toCommonJS(src_exports);
 init_protocol();
@@ -1262,8 +1481,8 @@ function defineFact(tag) {
     create(payload) {
       return { tag, payload };
     },
-    is(fact) {
-      return fact.tag === tag;
+    is(fact2) {
+      return fact2.tag === tag;
     }
   };
 }
@@ -1285,6 +1504,7 @@ function defineRule(options) {
     id: options.id,
     description: options.description,
     impl: options.impl,
+    eventTypes: options.eventTypes,
     contract,
     meta
   };
@@ -2015,16 +2235,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.`
             });
           }
         });
@@ -2292,6 +2512,53 @@ async function loadSchemaFromFile(filePath, options = {}) {
   }
 }
 
+// src/core/chronicle/context.ts
+var ChronicleContext = class {
+  static _stack = [];
+  /**
+   * Get the current active span, if any.
+   */
+  static get current() {
+    return this._stack[this._stack.length - 1];
+  }
+  /**
+   * Run a synchronous function within a causal span.
+   * The span is automatically popped when the function returns.
+   */
+  static run(span, fn) {
+    this._stack.push(span);
+    try {
+      return fn();
+    } finally {
+      this._stack.pop();
+    }
+  }
+  /**
+   * Run an async function within a causal span.
+   * The span is popped after the promise settles.
+   */
+  static async runAsync(span, fn) {
+    this._stack.push(span);
+    try {
+      return await fn();
+    } finally {
+      this._stack.pop();
+    }
+  }
+  /**
+   * Create a child span that inherits the current contextId.
+   *
+   * @param spanId ID for the new span
+   * @returns A new ChronicleSpan with the current contextId
+   */
+  static childSpan(spanId) {
+    return {
+      spanId,
+      contextId: this.current?.contextId
+    };
+  }
+};
+
 // src/core/pluresdb/store.ts
 var PRAXIS_PATHS = {
   /** Base path for all Praxis data */
@@ -2327,12 +2594,32 @@ var PraxisDBStore = class {
   subscriptions = [];
   factWatchers = /* @__PURE__ */ new Map();
   onRuleError;
+  chronicle;
   constructor(options) {
     this.db = options.db;
     this.registry = options.registry;
     this.context = options.initialContext ?? {};
     this.onRuleError = options.onRuleError ?? defaultErrorHandler;
   }
+  /**
+   * Attach a Chronicle observer to this store.
+   *
+   * Every subsequent `storeFact` and `appendEvent` call will be recorded as a
+   * causal graph node in PluresDB, enabling full observability for free.
+   *
+   * @param chronicle Chronicle implementation to attach
+   * @returns `this` for fluent chaining
+   *
+   * @example
+   * ```typescript
+   * const store = createPraxisDBStore(db, registry)
+   *   .withChronicle(createChronicle(db));
+   * ```
+   */
+  withChronicle(chronicle) {
+    this.chronicle = chronicle;
+    return this;
+  }
   /**
    * Store a fact in PluresDB
    *
@@ -2342,13 +2629,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(", ")}`);
     }
-    await this.persistFact(fact);
-    await this.triggerRules([fact]);
+    let before;
+    if (this.chronicle) {
+      const payload = fact2.payload;
+      const id = payload?.id;
+      if (id) {
+        before = await this.getFact(fact2.tag, id);
+      }
+    }
+    await this.persistFact(fact2);
+    if (this.chronicle) {
+      const payload = fact2.payload;
+      const id = payload?.id ?? "";
+      const span = ChronicleContext.current;
+      try {
+        await this.chronicle.record({
+          path: getFactPath(fact2.tag, id),
+          before,
+          after: fact2,
+          cause: span?.spanId,
+          context: span?.contextId,
+          metadata: { factTag: fact2.tag, operation: "storeFact" }
+        });
+      } catch {
+      }
+    }
+    await this.triggerRules([fact2]);
   }
   /**
    * Store multiple facts in PluresDB
@@ -2360,8 +2671,32 @@ var PraxisDBStore = class {
     if (!constraintResult.valid) {
       throw new Error(`Constraint violation: ${constraintResult.errors.join(", ")}`);
     }
-    for (const fact of facts) {
-      await this.persistFact(fact);
+    for (const fact2 of facts) {
+      let before;
+      if (this.chronicle) {
+        const payload = fact2.payload;
+        const id = payload?.id;
+        if (id) {
+          before = await this.getFact(fact2.tag, id);
+        }
+      }
+      await this.persistFact(fact2);
+      if (this.chronicle) {
+        const payload = fact2.payload;
+        const id = payload?.id ?? "";
+        const span = ChronicleContext.current;
+        try {
+          await this.chronicle.record({
+            path: getFactPath(fact2.tag, id),
+            before,
+            after: fact2,
+            cause: span?.spanId,
+            context: span?.contextId,
+            metadata: { factTag: fact2.tag, operation: "storeFacts" }
+          });
+        } catch {
+        }
+      }
     }
     await this.triggerRules(facts);
   }
@@ -2369,11 +2704,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
@@ -2403,7 +2738,29 @@ var PraxisDBStore = class {
     };
     const newEvents = [...existingEvents, entry];
     await this.db.set(path3, newEvents);
-    await this.triggerRulesForEvents([event]);
+    let eventNodeId;
+    if (this.chronicle) {
+      const span = ChronicleContext.current;
+      try {
+        const node = await this.chronicle.record({
+          path: path3,
+          before: existingEvents.length > 0 ? existingEvents[existingEvents.length - 1] : void 0,
+          after: entry,
+          cause: span?.spanId,
+          context: span?.contextId,
+          metadata: { eventTag: event.tag, sequence: String(entry.sequence), operation: "appendEvent" }
+        });
+        eventNodeId = node.id;
+      } catch {
+      }
+    }
+    const outerSpan = ChronicleContext.current;
+    const ruleSpan = eventNodeId ? { spanId: eventNodeId, contextId: outerSpan?.contextId } : outerSpan;
+    if (ruleSpan && this.chronicle) {
+      await ChronicleContext.runAsync(ruleSpan, () => this.triggerRulesForEvents([event]));
+    } else {
+      await this.triggerRulesForEvents([event]);
+    }
   }
   /**
    * Append multiple events to their respective streams
@@ -2416,6 +2773,7 @@ var PraxisDBStore = class {
       const existing = eventsByTag.get(event.tag) ?? [];
       eventsByTag.set(event.tag, [...existing, event]);
     }
+    let lastEventNodeId;
     for (const [tag, tagEvents] of eventsByTag) {
       const path3 = getEventPath(tag);
       const existingEvents = await this.db.get(path3) ?? [];
@@ -2426,8 +2784,30 @@ var PraxisDBStore = class {
         sequence: sequence++
       }));
       await this.db.set(path3, [...existingEvents, ...newEntries]);
+      if (this.chronicle) {
+        const span = ChronicleContext.current;
+        for (const entry of newEntries) {
+          try {
+            const node = await this.chronicle.record({
+              path: path3,
+              after: entry,
+              cause: span?.spanId,
+              context: span?.contextId,
+              metadata: { eventTag: tag, sequence: String(entry.sequence), operation: "appendEvents" }
+            });
+            lastEventNodeId = node.id;
+          } catch {
+          }
+        }
+      }
+    }
+    const outerSpan = ChronicleContext.current;
+    const ruleSpan = lastEventNodeId ? { spanId: lastEventNodeId, contextId: outerSpan?.contextId } : outerSpan;
+    if (ruleSpan && this.chronicle) {
+      await ChronicleContext.runAsync(ruleSpan, () => this.triggerRulesForEvents(events));
+    } else {
+      await this.triggerRulesForEvents(events);
     }
-    await this.triggerRulesForEvents(events);
   }
   /**
    * Get events from a stream
@@ -2465,8 +2845,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 () => {
@@ -2524,13 +2904,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);
       }
@@ -2538,8 +2923,23 @@ 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 = fact2.payload;
+            const id = payload?.id ?? "";
+            const span = ChronicleContext.current;
+            try {
+              await this.chronicle.record({
+                path: getFactPath(fact2.tag, id),
+                after: fact2,
+                cause: span?.spanId,
+                context: span?.contextId,
+                metadata: { factTag: fact2.tag, operation: "derivedFact" }
+              });
+            } catch {
+            }
+          }
         }
       }
     }
@@ -2833,6 +3233,156 @@ function createPluresDBGenerator(outputDir, options) {
   });
 }
 
+// src/core/chronicle/chronicle.ts
+var CHRONICLE_PATHS = {
+  BASE: "/_praxis/chronos",
+  NODES: "/_praxis/chronos/nodes",
+  EDGES_OUT: "/_praxis/chronos/edges/out",
+  EDGES_IN: "/_praxis/chronos/edges/in",
+  CONTEXT: "/_praxis/chronos/context",
+  INDEX: "/_praxis/chronos/index"
+};
+var _nodeCounter = 0;
+var PluresDbChronicle = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async record(event) {
+    const timestamp = Date.now();
+    const id = `chronos:${timestamp}-${++_nodeCounter}`;
+    const node = { id, timestamp, event };
+    await this.db.set(`${CHRONICLE_PATHS.NODES}/${id}`, node);
+    const index = await this.db.get(CHRONICLE_PATHS.INDEX) ?? [];
+    await this.db.set(CHRONICLE_PATHS.INDEX, [...index, id]);
+    if (event.cause) {
+      await this.addEdge(event.cause, id, "causes");
+    }
+    if (event.context) {
+      const contextPath = `${CHRONICLE_PATHS.CONTEXT}/${event.context}`;
+      const contextNodes = await this.db.get(contextPath) ?? [];
+      if (contextNodes.length > 0) {
+        const prevId = contextNodes[contextNodes.length - 1];
+        await this.addEdge(prevId, id, "follows");
+      }
+      await this.db.set(contextPath, [...contextNodes, id]);
+    }
+    return node;
+  }
+  async trace(nodeId, direction, maxDepth) {
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    await this._traceRecursive(nodeId, direction, maxDepth, 0, visited, result);
+    return result;
+  }
+  async range(start, end) {
+    const index = await this.db.get(CHRONICLE_PATHS.INDEX) ?? [];
+    const result = [];
+    for (const id of index) {
+      const node = await this.db.get(`${CHRONICLE_PATHS.NODES}/${id}`);
+      if (node && node.timestamp >= start && node.timestamp <= end) {
+        result.push(node);
+      }
+    }
+    return result;
+  }
+  async subgraph(contextId) {
+    const contextPath = `${CHRONICLE_PATHS.CONTEXT}/${contextId}`;
+    const nodeIds = await this.db.get(contextPath) ?? [];
+    const result = [];
+    for (const id of nodeIds) {
+      const node = await this.db.get(`${CHRONICLE_PATHS.NODES}/${id}`);
+      if (node) {
+        result.push(node);
+      }
+    }
+    return result;
+  }
+  // ── Internal helpers ──────────────────────────────────────────────────────
+  async addEdge(from, to, type) {
+    const edge = { from, to, type };
+    const outPath = `${CHRONICLE_PATHS.EDGES_OUT}/${from}`;
+    const outEdges = await this.db.get(outPath) ?? [];
+    await this.db.set(outPath, [...outEdges, edge]);
+    const inPath = `${CHRONICLE_PATHS.EDGES_IN}/${to}`;
+    const inEdges = await this.db.get(inPath) ?? [];
+    await this.db.set(inPath, [...inEdges, edge]);
+  }
+  async _traceRecursive(nodeId, direction, maxDepth, depth, visited, result) {
+    if (depth > maxDepth || visited.has(nodeId)) {
+      return;
+    }
+    visited.add(nodeId);
+    const node = await this.db.get(`${CHRONICLE_PATHS.NODES}/${nodeId}`);
+    if (node) {
+      result.push(node);
+    }
+    if (direction === "backward" || direction === "both") {
+      const inEdges = await this.db.get(`${CHRONICLE_PATHS.EDGES_IN}/${nodeId}`) ?? [];
+      for (const edge of inEdges) {
+        await this._traceRecursive(edge.from, direction, maxDepth, depth + 1, visited, result);
+      }
+    }
+    if (direction === "forward" || direction === "both") {
+      const outEdges = await this.db.get(`${CHRONICLE_PATHS.EDGES_OUT}/${nodeId}`) ?? [];
+      for (const edge of outEdges) {
+        await this._traceRecursive(edge.to, direction, maxDepth, depth + 1, visited, result);
+      }
+    }
+  }
+};
+function createChronicle(db) {
+  return new PluresDbChronicle(db);
+}
+
+// src/core/chronicle/mcp.ts
+function createChronosMcpTools(chronicle) {
+  return {
+    async trace(params) {
+      try {
+        const nodes = await chronicle.trace(
+          params.nodeId,
+          params.direction ?? "backward",
+          params.maxDepth ?? 10
+        );
+        return { success: true, data: nodes };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    },
+    async search(params) {
+      try {
+        const query = params.query.toLowerCase();
+        let candidates;
+        if (params.contextId) {
+          candidates = await chronicle.subgraph(params.contextId);
+        } else {
+          candidates = await chronicle.range(params.since ?? 0, params.until ?? Date.now());
+        }
+        const filtered = candidates.filter((node) => {
+          const inPath = node.event.path.toLowerCase().includes(query);
+          const inMeta = Object.values(node.event.metadata).some(
+            (v) => v.toLowerCase().includes(query)
+          );
+          const inAfter = JSON.stringify(node.event.after ?? "").toLowerCase().includes(query);
+          const inBefore = JSON.stringify(node.event.before ?? "").toLowerCase().includes(query);
+          return inPath || inMeta || inAfter || inBefore;
+        });
+        const limited = params.limit !== void 0 ? filtered.slice(0, params.limit) : filtered;
+        return { success: true, data: limited };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    }
+  };
+}
+
 // src/integrations/pluresdb.ts
 function createPluresDBAdapter(options) {
   const store = createPraxisDBStore(options.db, options.registry, options.initialContext);
@@ -2998,7 +3548,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}`);
@@ -3006,7 +3556,7 @@ async function createUnumAdapter(config) {
     await channel.publish({
       id: generateId2(),
       sender: currentIdentity || { id: "anonymous", createdAt: Date.now() },
-      content: fact,
+      content: fact2,
       type: "fact"
     });
   }
@@ -3149,17 +3699,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"
@@ -3614,8 +4164,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("");
         }
@@ -3747,9 +4297,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("");
     }
@@ -3801,8 +4351,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 {
@@ -4253,11 +4803,309 @@ 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) + "%";
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AcknowledgeContractGap,
   ActorManager,
   BehaviorLedger,
+  CHRONICLE_PATHS,
+  ChronicleContext,
   ContractAdded,
   ContractGapAcknowledged,
   ContractMissing,
@@ -4270,11 +5118,13 @@ async function attachAllIntegrations(engine, registry, options = {}) {
   PRAXIS_PROTOCOL_VERSION,
   PluresDBGenerator,
   PluresDBPraxisAdapter,
+  PluresDbChronicle,
   PraxisDBStore,
   PraxisRegistry,
   PraxisSchemaRegistry,
   ReactiveLogicEngine,
   RegistryIntrospector,
+  RuleResult,
   StateDocsGenerator,
   TerminalAdapter,
   ValidateContracts,
@@ -4282,11 +5132,14 @@ async function attachAllIntegrations(engine, registry, options = {}) {
   attachTauriToEngine,
   attachToEngine,
   attachUnumToEngine,
+  auditCompleteness,
   canvasToMermaid,
   canvasToSchema,
   canvasToYaml,
   createBehaviorLedger,
   createCanvasEditor,
+  createChronicle,
+  createChronosMcpTools,
   createFrameworkAgnosticReactiveEngine,
   createInMemoryDB,
   createIntrospector,
@@ -4305,6 +5158,7 @@ async function attachAllIntegrations(engine, registry, options = {}) {
   createTauriPraxisAdapter,
   createTerminalAdapter,
   createTimerActor,
+  createUIModule,
   createUnifiedApp,
   createUnumAdapter,
   defineConstraint,
@@ -4313,10 +5167,14 @@ async function attachAllIntegrations(engine, registry, options = {}) {
   defineFact,
   defineModule,
   defineRule,
+  dirtyGuardRule,
+  errorDisplayRule,
+  fact,
   filterEvents,
   filterFacts,
   findEvent,
   findFact,
+  formatReport,
   formatValidationReport,
   formatValidationReportJSON,
   formatValidationReportSARIF,
@@ -4327,16 +5185,26 @@ async function attachAllIntegrations(engine, registry, options = {}) {
   getEventPath,
   getFactPath,
   getSchemaPath,
+  initGateRule,
   isContract,
   loadSchema,
   loadSchemaFromFile,
   loadSchemaFromJson,
   loadSchemaFromYaml,
+  loadingGateRule,
+  mustBeInitializedConstraint,
+  navigationRequest,
+  noInteractionWhileLoadingConstraint,
+  offlineIndicatorRule,
   registerSchema,
+  resizeEvent,
   runTerminalCommand,
   schemaToCanvas,
+  uiModule,
+  uiStateChanged,
   validateContracts,
   validateForGeneration,
   validateSchema,
-  validateWithGuardian
+  validateWithGuardian,
+  viewportRule
 });