@plures/praxis 1.3.0 → 1.4.0

package/dist/node/index.js

@@ -1,3 +1,7 @@
+import {
+  auditCompleteness,
+  formatReport
+} from "./chunk-2IUFZBH3.js";
 import {
   AcknowledgeContractGap,
   BehaviorLedger,
@@ -21,12 +25,13 @@ import {
   formatValidationReportJSON,
   formatValidationReportSARIF,
   validateContracts
-} from "./chunk-PTH6MD6P.js";
+} from "./chunk-FWOXU4MM.js";
+import "./chunk-7CSWBDFL.js";
 import {
   defineContract,
   getContract,
   isContract
-} from "./chunk-WZ6B3LZ6.js";
+} from "./chunk-PGVSB6NR.js";
 import {
   InMemoryPraxisDB,
   PluresDBPraxisAdapter,
@@ -50,10 +55,14 @@ import {
 import {
   ReactiveLogicEngine,
   createReactiveEngine
-} from "./chunk-5JQJZADT.js";
+} from "./chunk-7M3HV4XR.js";
 import {
-  PraxisRegistry
-} from "./chunk-R2PSBPKQ.js";
+  LogicEngine,
+  PRAXIS_PROTOCOL_VERSION,
+  RuleResult,
+  createPraxisEngine,
+  fact
+} from "./chunk-KMJWAFZV.js";
 import {
   TerminalAdapter,
   createMockExecutor,
@@ -76,12 +85,8 @@ import {
   validateSchema
 } from "./chunk-UATVJBNV.js";
 import {
-  LogicEngine,
-  PRAXIS_PROTOCOL_VERSION,
-  RuleResult,
-  createPraxisEngine,
-  fact
-} from "./chunk-KMJWAFZV.js";
+  PraxisRegistry
+} from "./chunk-TEMFJOIH.js";
 import "./chunk-QGM4M3NI.js";
 
 // src/core/reactive-engine.ts
@@ -2114,87 +2119,1079 @@ 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 }
+// 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
   };
-  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.`);
+}
+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 report;
+  return {
+    name: expectation.name,
+    status,
+    conditions: conditionResults,
+    edgeCases,
+    mitigations
+  };
 }
-function formatReport(report) {
+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.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})`);
+  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("");
-  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}` : ""}`);
+  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}`);
+      }
     }
-  }
-  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.allMitigations.length > 0) {
+    lines.push("Suggested mitigations:");
+    for (const m of report.allMitigations) {
+      lines.push(`  \u{1F4A1} ${m}`);
     }
   }
-  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}`);
+  return lines.join("\n");
+}
+
+// src/factory/factory.ts
+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: (state, 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 ?? state.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: (state) => {
+        const value = state.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: (state) => {
+        const value = state.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: (state, 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 = state.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: (state) => {
+        const toasts = state.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;
+      }
+    });
   }
-  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 { 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: (state) => {
+        const form = state.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: (state, 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 && state.context.dirty) {
+        reasons.push("Unsaved changes will be lost");
+      }
+      if (authRequired && !state.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: (state) => {
+        if (state.context.dirty && state.facts.some((f) => f.tag === "navigation.allowed")) {
+          return "Navigation allowed while dirty \u2014 unsaved changes may be lost";
+        }
+        return true;
+      }
+    });
   }
-  return lines.join("\n");
+  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: (state) => {
+      const pending = state.context.pending ?? {};
+      const optimisticFacts = state.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
+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: (state, 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 = state.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: (state) => {
+      const gateState = state.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 pct(a, b) {
-  if (b === 0) return "100%";
-  return Math.round(a / b * 100) + "%";
+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"
+  });
 }
 export {
   AcknowledgeContractGap,
@@ -2207,6 +3204,8 @@ export {
   ContractMissing,
   ContractUpdated,
   ContractValidated,
+  Expectation,
+  ExpectationSet,
   ReactiveLogicEngine2 as FrameworkAgnosticReactiveEngine,
   InMemoryPraxisDB,
   LogicEngine,
@@ -2229,9 +3228,11 @@ export {
   attachToEngine,
   attachUnumToEngine,
   auditCompleteness,
+  branchRules,
   canvasToMermaid,
   canvasToSchema,
   canvasToYaml,
+  commitFromState,
   createBehaviorLedger,
   createCanvasEditor,
   createChronicle,
@@ -2257,23 +3258,30 @@ export {
   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,
@@ -2282,7 +3290,9 @@ export {
   getFactPath,
   getSchemaPath,
   initGateRule,
+  inputRules,
   isContract,
+  lintGate,
   loadSchema,
   loadSchemaFromFile,
   loadSchemaFromJson,
@@ -2290,17 +3300,21 @@ export {
   loadingGateRule,
   mustBeInitializedConstraint,
   navigationRequest,
+  navigationRules,
   noInteractionWhileLoadingConstraint,
   offlineIndicatorRule,
   registerSchema,
   resizeEvent,
   runTerminalCommand,
   schemaToCanvas,
+  semverContract,
+  toastRules,
   uiModule,
   uiStateChanged,
   validateContracts,
   validateForGeneration,
   validateSchema,
   validateWithGuardian,
+  verify,
   viewportRule
 };