@plures/praxis 1.4.0 → 2.0.0

package/dist/node/index.js

@@ -11,21 +11,39 @@ import {
   ContractUpdated,
   ContractValidated,
   ValidateContracts,
+  analyzeDependencyGraph,
   createBehaviorLedger,
+  crossReferenceContracts,
   defineConstraint,
   defineEvent,
   defineFact,
   defineModule,
   defineRule,
+  diffLedgers,
   filterEvents,
   filterFacts,
+  findContractGaps,
+  findContradictions,
+  findDeadRules,
   findEvent,
   findFact,
+  findGaps,
+  findShadowedRules,
+  findUnreachableStates,
+  formatBuildOutput,
+  formatLedger,
   formatValidationReport,
   formatValidationReportJSON,
   formatValidationReportSARIF,
-  validateContracts
-} from "./chunk-FWOXU4MM.js";
+  generateLedger,
+  suggest,
+  suggestAll,
+  traceDerivation,
+  traceImpact,
+  validateContracts,
+  verifyContractExamples,
+  verifyInvariants
+} from "./chunk-AZLNISFI.js";
 import "./chunk-7CSWBDFL.js";
 import {
   defineContract,
@@ -55,14 +73,15 @@ import {
 import {
   ReactiveLogicEngine,
   createReactiveEngine
-} from "./chunk-7M3HV4XR.js";
+} from "./chunk-WFRHXZBP.js";
+import {
+  PraxisRegistry
+} from "./chunk-TEMFJOIH.js";
 import {
   LogicEngine,
   PRAXIS_PROTOCOL_VERSION,
-  RuleResult,
-  createPraxisEngine,
-  fact
-} from "./chunk-KMJWAFZV.js";
+  createPraxisEngine
+} from "./chunk-JZDJU2DO.js";
 import {
   TerminalAdapter,
   createMockExecutor,
@@ -85,8 +104,16 @@ import {
   validateSchema
 } from "./chunk-UATVJBNV.js";
 import {
-  PraxisRegistry
-} from "./chunk-TEMFJOIH.js";
+  createApp,
+  defineConstraint as defineConstraint2,
+  defineModule as defineModule2,
+  definePath,
+  defineRule as defineRule2
+} from "./chunk-6MVRT7CK.js";
+import {
+  RuleResult,
+  fact
+} from "./chunk-IG5BJ2MT.js";
 import "./chunk-QGM4M3NI.js";
 
 // src/core/reactive-engine.ts
@@ -1780,7 +1807,7 @@ function generateTauriConfig(config) {
 
 // src/integrations/unified.ts
 async function createUnifiedApp(config) {
-  const { createPraxisEngine: createPraxisEngine2 } = await import("./engine-FEN5IYZ5.js");
+  const { createPraxisEngine: createPraxisEngine2 } = await import("./engine-VFHCIEM4.js");
   const { createInMemoryDB: createInMemoryDB2 } = await import("./adapter-75ISSMWD.js");
   const db = config.db || createInMemoryDB2();
   const pluresdb = createPluresDBAdapter({
@@ -3193,6 +3220,509 @@ function expectationGate(config = {}) {
     onViolation: "expectations-failed"
   });
 }
+
+// src/chronos/project-chronicle.ts
+var ProjectChronicle = class {
+  events = [];
+  maxEvents;
+  now;
+  constructor(options = {}) {
+    this.maxEvents = options.maxEvents ?? 1e4;
+    this.now = options.now ?? (() => Date.now());
+  }
+  // ── Recording ───────────────────────────────────────────────────────────
+  /**
+   * Record a project event. Returns the recorded event (with timestamp filled in).
+   */
+  record(event) {
+    const full = {
+      kind: event.kind,
+      action: event.action,
+      subject: event.subject,
+      timestamp: event.timestamp ?? this.now(),
+      metadata: event.metadata,
+      diff: event.diff
+    };
+    this.events.push(full);
+    if (this.maxEvents > 0 && this.events.length > this.maxEvents) {
+      this.events = this.events.slice(this.events.length - this.maxEvents);
+    }
+    return full;
+  }
+  // ── Convenience recorders ─────────────────────────────────────────────
+  recordRuleRegistered(ruleId, meta = {}) {
+    return this.record({ kind: "rule", action: "registered", subject: ruleId, metadata: meta });
+  }
+  recordRuleModified(ruleId, diff, meta = {}) {
+    return this.record({ kind: "rule", action: "modified", subject: ruleId, metadata: meta, diff });
+  }
+  recordRuleRemoved(ruleId, meta = {}) {
+    return this.record({ kind: "rule", action: "removed", subject: ruleId, metadata: meta });
+  }
+  recordContractAdded(contractId, meta = {}) {
+    return this.record({ kind: "contract", action: "added", subject: contractId, metadata: meta });
+  }
+  recordContractModified(contractId, diff, meta = {}) {
+    return this.record({ kind: "contract", action: "modified", subject: contractId, metadata: meta, diff });
+  }
+  recordExpectationSatisfied(name, meta = {}) {
+    return this.record({ kind: "expectation", action: "satisfied", subject: name, metadata: meta });
+  }
+  recordExpectationViolated(name, meta = {}) {
+    return this.record({ kind: "expectation", action: "violated", subject: name, metadata: meta });
+  }
+  recordGateTransition(gateName, from, to, meta = {}) {
+    return this.record({
+      kind: "gate",
+      action: to,
+      subject: gateName,
+      metadata: { ...meta, from, to },
+      diff: { before: from, after: to }
+    });
+  }
+  recordBuildAudit(score, delta, meta = {}) {
+    return this.record({
+      kind: "build",
+      action: "audit-complete",
+      subject: "completeness",
+      metadata: { ...meta, score, delta }
+    });
+  }
+  recordFactIntroduced(factTag, meta = {}) {
+    return this.record({ kind: "fact", action: "introduced", subject: factTag, metadata: meta });
+  }
+  recordFactDeprecated(factTag, meta = {}) {
+    return this.record({ kind: "fact", action: "deprecated", subject: factTag, metadata: meta });
+  }
+  // ── Access ──────────────────────────────────────────────────────────────
+  /** Return a shallow copy of all events. */
+  getEvents() {
+    return [...this.events];
+  }
+  /** Total number of recorded events. */
+  get size() {
+    return this.events.length;
+  }
+  /** Clear all events (primarily for testing). */
+  clear() {
+    this.events = [];
+  }
+};
+function createProjectChronicle(options) {
+  return new ProjectChronicle(options);
+}
+
+// src/chronos/timeline.ts
+var Timeline = class {
+  constructor(chronicle) {
+    this.chronicle = chronicle;
+  }
+  // ── Queries ─────────────────────────────────────────────────────────────
+  /**
+   * Query events with optional filtering.
+   * Returns matching events sorted chronologically (oldest first).
+   */
+  getTimeline(filter) {
+    let events = this.chronicle.getEvents();
+    if (!filter) return events;
+    events = applyFilter(events, filter);
+    return events;
+  }
+  /**
+   * Get all events since a timestamp (inclusive).
+   */
+  getEventsSince(timestamp) {
+    return this.getTimeline({ since: timestamp });
+  }
+  /**
+   * Compute a behavioral delta between two timestamps.
+   */
+  getDelta(from, to) {
+    const events = this.getTimeline({ since: from, until: to });
+    return buildDelta(from, to, events);
+  }
+  /**
+   * Get full history for a specific subject (rule id, gate name, etc.).
+   * Sorted chronologically.
+   */
+  getHistory(subjectId) {
+    return this.getTimeline({ subject: subjectId });
+  }
+};
+function applyFilter(events, filter) {
+  return events.filter((e) => {
+    if (filter.kind) {
+      const kinds = Array.isArray(filter.kind) ? filter.kind : [filter.kind];
+      if (!kinds.includes(e.kind)) return false;
+    }
+    if (filter.action) {
+      const actions = Array.isArray(filter.action) ? filter.action : [filter.action];
+      if (!actions.includes(e.action)) return false;
+    }
+    if (filter.subject) {
+      const subjects = Array.isArray(filter.subject) ? filter.subject : [filter.subject];
+      if (!subjects.includes(e.subject)) return false;
+    }
+    if (filter.since != null && e.timestamp < filter.since) return false;
+    if (filter.until != null && e.timestamp > filter.until) return false;
+    return true;
+  });
+}
+var ADD_ACTIONS = /* @__PURE__ */ new Set(["registered", "added", "introduced", "opened"]);
+var REMOVE_ACTIONS = /* @__PURE__ */ new Set(["removed", "deprecated", "closed"]);
+var MODIFY_ACTIONS = /* @__PURE__ */ new Set(["modified", "updated"]);
+function buildDelta(from, to, events) {
+  const summary = {};
+  const added = /* @__PURE__ */ new Set();
+  const removed = /* @__PURE__ */ new Set();
+  const modified = /* @__PURE__ */ new Set();
+  for (const e of events) {
+    summary[e.kind] = (summary[e.kind] ?? 0) + 1;
+    if (ADD_ACTIONS.has(e.action)) {
+      added.add(e.subject);
+      removed.delete(e.subject);
+    } else if (REMOVE_ACTIONS.has(e.action)) {
+      removed.add(e.subject);
+      added.delete(e.subject);
+    } else if (MODIFY_ACTIONS.has(e.action)) {
+      modified.add(e.subject);
+    }
+  }
+  return {
+    from,
+    to,
+    events,
+    summary,
+    added: [...added],
+    removed: [...removed],
+    modified: [...modified]
+  };
+}
+function createTimeline(chronicle) {
+  return new Timeline(chronicle);
+}
+
+// src/chronos/hooks.ts
+function enableProjectChronicle(registry, engine, options = {}) {
+  const chronicle = options.chronicle ?? createProjectChronicle();
+  const recordSteps = options.recordSteps ?? true;
+  const recordConstraints = options.recordConstraints ?? true;
+  const origRegisterRule = registry.registerRule.bind(registry);
+  const origRegisterModule = registry.registerModule.bind(registry);
+  const origStep = engine.step.bind(engine);
+  const origCheckConstraints = engine.checkConstraints.bind(engine);
+  registry.registerRule = function hookedRegisterRule(descriptor) {
+    origRegisterRule(descriptor);
+    chronicle.recordRuleRegistered(descriptor.id, {
+      description: descriptor.description,
+      hasContract: !!descriptor.contract,
+      eventTypes: descriptor.eventTypes
+    });
+    if (descriptor.contract) {
+      chronicle.recordContractAdded(descriptor.id, {
+        behavior: descriptor.contract.behavior,
+        examplesCount: descriptor.contract.examples?.length ?? 0,
+        invariantsCount: descriptor.contract.invariants?.length ?? 0
+      });
+    }
+  };
+  registry.registerModule = function hookedRegisterModule(module) {
+    origRegisterModule(module);
+    for (const rule of module.rules) {
+      chronicle.recordRuleRegistered(rule.id, {
+        description: rule.description,
+        hasContract: !!rule.contract,
+        eventTypes: rule.eventTypes,
+        registeredVia: "module"
+      });
+      if (rule.contract) {
+        chronicle.recordContractAdded(rule.id, {
+          behavior: rule.contract.behavior,
+          examplesCount: rule.contract.examples?.length ?? 0,
+          invariantsCount: rule.contract.invariants?.length ?? 0
+        });
+      }
+    }
+  };
+  if (recordSteps) {
+    engine.step = function hookedStep(events) {
+      const result = origStep(events);
+      const factTags = /* @__PURE__ */ new Set();
+      for (const fact2 of result.state.facts) {
+        factTags.add(fact2.tag);
+      }
+      chronicle.record({
+        kind: "build",
+        action: "step-complete",
+        subject: "engine",
+        metadata: {
+          eventsProcessed: events.length,
+          eventTags: events.map((e) => e.tag),
+          factsAfter: result.state.facts.length,
+          diagnosticsCount: result.diagnostics.length
+        }
+      });
+      for (const diag of result.diagnostics) {
+        if (diag.kind === "constraint-violation") {
+          chronicle.record({
+            kind: "expectation",
+            action: "violated",
+            subject: extractSubjectFromDiag(diag),
+            metadata: { message: diag.message, data: diag.data }
+          });
+        }
+      }
+      return result;
+    };
+  }
+  if (recordConstraints) {
+    engine.checkConstraints = function hookedCheckConstraints() {
+      const diagnostics = origCheckConstraints();
+      chronicle.record({
+        kind: "build",
+        action: "constraints-checked",
+        subject: "engine",
+        metadata: {
+          violations: diagnostics.length
+        }
+      });
+      for (const diag of diagnostics) {
+        chronicle.record({
+          kind: "expectation",
+          action: "violated",
+          subject: extractSubjectFromDiag(diag),
+          metadata: { message: diag.message }
+        });
+      }
+      return diagnostics;
+    };
+  }
+  function disconnect() {
+    registry.registerRule = origRegisterRule;
+    registry.registerModule = origRegisterModule;
+    engine.step = origStep;
+    engine.checkConstraints = origCheckConstraints;
+  }
+  return { chronicle, disconnect };
+}
+function recordAudit(chronicle, report, previousScore) {
+  const delta = previousScore != null ? report.score - previousScore : 0;
+  chronicle.recordBuildAudit(report.score, delta, {
+    rating: report.rating,
+    rulesCovered: report.rules.covered,
+    rulesTotal: report.rules.total,
+    constraintsCovered: report.constraints.covered,
+    constraintsTotal: report.constraints.total,
+    contractsCovered: report.contracts.withContracts,
+    contractsTotal: report.contracts.total
+  });
+}
+function extractSubjectFromDiag(diag) {
+  const data = diag.data;
+  if (data?.constraintId && typeof data.constraintId === "string") return data.constraintId;
+  if (data?.ruleId && typeof data.ruleId === "string") return data.ruleId;
+  return "unknown";
+}
+
+// src/chronos/diff.ts
+function diffRegistries(before, after) {
+  const beforeRules = toIdMap(before.rules);
+  const afterRules = toIdMap(after.rules);
+  const beforeConstraints = toIdMap(before.constraints);
+  const afterConstraints = toIdMap(after.constraints);
+  return {
+    rulesAdded: setDiff(afterRules, beforeRules),
+    rulesRemoved: setDiff(beforeRules, afterRules),
+    rulesModified: findModified(beforeRules, afterRules),
+    constraintsAdded: setDiff(afterConstraints, beforeConstraints),
+    constraintsRemoved: setDiff(beforeConstraints, afterConstraints),
+    constraintsModified: findModified(beforeConstraints, afterConstraints)
+  };
+}
+function diffContracts(before, after) {
+  const beforeMap = toRecord(before.coverage);
+  const afterMap = toRecord(after.coverage);
+  const contractsAdded = [];
+  const contractsRemoved = [];
+  for (const [id, has] of Object.entries(afterMap)) {
+    if (has && !beforeMap[id]) {
+      contractsAdded.push(id);
+    }
+  }
+  for (const [id, had] of Object.entries(beforeMap)) {
+    if (had && !afterMap[id]) {
+      contractsRemoved.push(id);
+    }
+  }
+  const countTrue = (r) => Object.values(r).filter(Boolean).length;
+  const totalBefore = Object.keys(beforeMap).length;
+  const totalAfter = Object.keys(afterMap).length;
+  return {
+    contractsAdded,
+    contractsRemoved,
+    coverageBefore: totalBefore > 0 ? countTrue(beforeMap) / totalBefore : 0,
+    coverageAfter: totalAfter > 0 ? countTrue(afterMap) / totalAfter : 0
+  };
+}
+function diffExpectations(before, after) {
+  const beforeMap = toRecord(before.expectations);
+  const afterMap = toRecord(after.expectations);
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(beforeMap), ...Object.keys(afterMap)]);
+  const newlySatisfied = [];
+  const newlyViolated = [];
+  const unchanged = [];
+  for (const key of allKeys) {
+    const was = beforeMap[key] ?? false;
+    const is = afterMap[key] ?? false;
+    if (!was && is) {
+      newlySatisfied.push(key);
+    } else if (was && !is) {
+      newlyViolated.push(key);
+    } else {
+      unchanged.push(key);
+    }
+  }
+  return { newlySatisfied, newlyViolated, unchanged };
+}
+function formatDelta(diff) {
+  const lines = [];
+  if (diff.rulesAdded.length > 0)
+    lines.push(`+ Rules added: ${diff.rulesAdded.join(", ")}`);
+  if (diff.rulesRemoved.length > 0)
+    lines.push(`- Rules removed: ${diff.rulesRemoved.join(", ")}`);
+  if (diff.rulesModified.length > 0)
+    lines.push(`~ Rules modified: ${diff.rulesModified.join(", ")}`);
+  if (diff.constraintsAdded.length > 0)
+    lines.push(`+ Constraints added: ${diff.constraintsAdded.join(", ")}`);
+  if (diff.constraintsRemoved.length > 0)
+    lines.push(`- Constraints removed: ${diff.constraintsRemoved.join(", ")}`);
+  if (diff.constraintsModified.length > 0)
+    lines.push(`~ Constraints modified: ${diff.constraintsModified.join(", ")}`);
+  return lines.length > 0 ? lines.join("\n") : "No behavioral changes.";
+}
+function formatCommitMessage(diff) {
+  const praxisDiff = {
+    rulesAdded: diff.rulesAdded,
+    rulesRemoved: diff.rulesRemoved,
+    rulesModified: diff.rulesModified,
+    contractsAdded: [],
+    contractsRemoved: [],
+    expectationsAdded: diff.constraintsAdded,
+    expectationsRemoved: diff.constraintsRemoved,
+    gateChanges: []
+  };
+  return commitFromDiff(praxisDiff);
+}
+function formatReleaseNotes(diffs) {
+  const sections = [];
+  const allAdded = [];
+  const allRemoved = [];
+  const allModified = [];
+  for (const diff of diffs) {
+    allAdded.push(...diff.rulesAdded, ...diff.constraintsAdded);
+    allRemoved.push(...diff.rulesRemoved, ...diff.constraintsRemoved);
+    allModified.push(...diff.rulesModified, ...diff.constraintsModified);
+  }
+  const added = [...new Set(allAdded)];
+  const removed = [...new Set(allRemoved)];
+  const modified = [...new Set(allModified)];
+  if (added.length > 0) {
+    sections.push(`### Added
+${added.map((id) => `- ${id}`).join("\n")}`);
+  }
+  if (modified.length > 0) {
+    sections.push(`### Changed
+${modified.map((id) => `- ${id}`).join("\n")}`);
+  }
+  if (removed.length > 0) {
+    sections.push(`### Removed
+${removed.map((id) => `- ${id}`).join("\n")}`);
+  }
+  if (sections.length === 0) return "No behavioral changes in this release.";
+  return `## Release Notes
+
+${sections.join("\n\n")}`;
+}
+function toIdMap(input) {
+  if (input instanceof Map) return input;
+  const map = /* @__PURE__ */ new Map();
+  for (const item of input) map.set(item.id, item);
+  return map;
+}
+function setDiff(a, b) {
+  const result = [];
+  for (const key of a.keys()) {
+    if (!b.has(key)) result.push(key);
+  }
+  return result;
+}
+function findModified(before, after) {
+  const result = [];
+  for (const [key, beforeVal] of before) {
+    const afterVal = after.get(key);
+    if (afterVal && beforeVal.description !== afterVal.description) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+function toRecord(input) {
+  if (input instanceof Map) {
+    const result = {};
+    for (const [k, v] of input) result[k] = v;
+    return result;
+  }
+  return input;
+}
+function commitFromDiff(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;
+  if (totalAdded > 0 && totalRemoved === 0 && totalModified === 0) {
+    if (diff.rulesAdded.length > 0) {
+      const scope = inferScope2(diff.rulesAdded);
+      parts.push(`feat(${scope}): add ${fmtIds(diff.rulesAdded)}`);
+    } else if (diff.contractsAdded.length > 0) {
+      parts.push(`feat(contracts): add contracts for ${fmtIds(diff.contractsAdded)}`);
+    } else {
+      parts.push(`feat(expectations): add ${fmtIds(diff.expectationsAdded)}`);
+    }
+  } else if (totalRemoved > 0 && totalAdded === 0) {
+    if (diff.rulesRemoved.length > 0) {
+      const scope = inferScope2(diff.rulesRemoved);
+      parts.push(`refactor(${scope}): remove ${fmtIds(diff.rulesRemoved)}`);
+    } else {
+      parts.push(`refactor: remove ${totalRemoved} item(s)`);
+    }
+  } else if (totalModified > 0) {
+    const scope = inferScope2(diff.rulesModified);
+    parts.push(`refactor(${scope}): update ${fmtIds(diff.rulesModified)}`);
+  } 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(", ")}`);
+  const subject = parts[0] || "chore: update";
+  return bodyParts.length > 0 ? `${subject}
+
+${bodyParts.join("\n")}` : subject;
+}
+function inferScope2(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 fmtIds(ids) {
+  if (ids.length <= 3) return ids.join(", ");
+  return `${ids.slice(0, 2).join(", ")} (+${ids.length - 2} more)`;
+}
 export {
   AcknowledgeContractGap,
   ActorManager,
@@ -3217,12 +3747,15 @@ export {
   PraxisDBStore,
   PraxisRegistry,
   PraxisSchemaRegistry,
+  ProjectChronicle,
   ReactiveLogicEngine,
   RegistryIntrospector,
   RuleResult,
   StateDocsGenerator,
   TerminalAdapter,
+  Timeline,
   ValidateContracts,
+  analyzeDependencyGraph,
   attachAllIntegrations,
   attachTauriToEngine,
   attachToEngine,
@@ -3233,6 +3766,7 @@ export {
   canvasToSchema,
   canvasToYaml,
   commitFromState,
+  createApp,
   createBehaviorLedger,
   createCanvasEditor,
   createChronicle,
@@ -3248,16 +3782,19 @@ export {
   createPraxisDBStore,
   createPraxisEngine,
   createPraxisLocalFirst,
+  createProjectChronicle,
   createReactiveEngine,
   createSchemaRegistry,
   createSchemaTemplate,
   createStateDocsGenerator,
   createTauriPraxisAdapter,
   createTerminalAdapter,
+  createTimeline,
   createTimerActor,
   createUIModule,
   createUnifiedApp,
   createUnumAdapter,
+  crossReferenceContracts,
   dataRules,
   defineConstraint,
   defineContract,
@@ -3265,18 +3802,38 @@ export {
   defineFact,
   defineGate,
   defineModule,
+  definePath,
   defineRule,
+  defineConstraint2 as defineUnifiedConstraint,
+  defineModule2 as defineUnifiedModule,
+  defineRule2 as defineUnifiedRule,
+  diffContracts,
+  diffExpectations,
+  diffLedgers,
+  diffRegistries,
   dirtyGuardRule,
+  enableProjectChronicle,
   errorDisplayRule,
   expectBehavior,
   expectationGate,
   fact,
   filterEvents,
   filterFacts,
+  findContractGaps,
+  findContradictions,
+  findDeadRules,
   findEvent,
   findFact,
+  findGaps,
+  findShadowedRules,
+  findUnreachableStates,
   formRules,
+  formatCommitMessage as formatBehavioralCommit,
+  formatBuildOutput,
+  formatDelta,
   formatGate,
+  formatLedger,
+  formatReleaseNotes,
   formatReport,
   formatValidationReport,
   formatValidationReportJSON,
@@ -3284,6 +3841,7 @@ export {
   formatVerificationReport,
   generateDocs,
   generateId,
+  generateLedger,
   generateTauriConfig,
   getContract,
   getEventPath,
@@ -3303,12 +3861,17 @@ export {
   navigationRules,
   noInteractionWhileLoadingConstraint,
   offlineIndicatorRule,
+  recordAudit,
   registerSchema,
   resizeEvent,
   runTerminalCommand,
   schemaToCanvas,
   semverContract,
+  suggest,
+  suggestAll,
   toastRules,
+  traceDerivation,
+  traceImpact,
   uiModule,
   uiStateChanged,
   validateContracts,
@@ -3316,5 +3879,7 @@ export {
   validateSchema,
   validateWithGuardian,
   verify,
+  verifyContractExamples,
+  verifyInvariants,
   viewportRule
 };