@neuroverseos/governance 0.1.0 → 0.1.2

package/dist/chunk-M3TZFGHO.js

@@ -0,0 +1,79 @@
+// src/loader/world-loader.ts
+async function loadWorldFromDirectory(dirPath) {
+  const { readFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const { readdirSync } = await import("fs");
+  async function readJson(filename) {
+    try {
+      const content = await readFile(join(dirPath, filename), "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return void 0;
+    }
+  }
+  const worldJson = await readJson("world.json");
+  if (!worldJson) {
+    throw new Error(`Cannot read world.json in ${dirPath}`);
+  }
+  const invariantsJson = await readJson("invariants.json");
+  const assumptionsJson = await readJson("assumptions.json");
+  const stateSchemaJson = await readJson("state-schema.json");
+  const gatesJson = await readJson("gates.json");
+  const outcomesJson = await readJson("outcomes.json");
+  const guardsJson = await readJson("guards.json");
+  const rolesJson = await readJson("roles.json");
+  const kernelJson = await readJson("kernel.json");
+  const metadataJson = await readJson("metadata.json");
+  const rules = [];
+  try {
+    const rulesDir = join(dirPath, "rules");
+    const ruleFiles = readdirSync(rulesDir).filter((f) => f.endsWith(".json")).sort();
+    for (const file of ruleFiles) {
+      const content = await readFile(join(rulesDir, file), "utf-8");
+      rules.push(JSON.parse(content));
+    }
+  } catch {
+  }
+  return {
+    world: worldJson,
+    invariants: invariantsJson?.invariants ?? [],
+    assumptions: assumptionsJson ?? { profiles: {}, parameter_definitions: {} },
+    stateSchema: stateSchemaJson ?? { variables: {}, presets: {} },
+    rules,
+    gates: gatesJson ?? {
+      viability_classification: [],
+      structural_override: { description: "", enforcement: "mandatory" },
+      sustainability_threshold: 0,
+      collapse_visual: { background: "", text: "", border: "", label: "" }
+    },
+    outcomes: outcomesJson ?? {
+      computed_outcomes: [],
+      comparison_layout: { primary_card: "", status_badge: "", structural_indicators: [] }
+    },
+    guards: guardsJson,
+    roles: rolesJson,
+    kernel: kernelJson,
+    metadata: metadataJson ?? {
+      format_version: "1.0.0",
+      created_at: "",
+      last_modified: "",
+      authoring_method: "manual-authoring"
+    }
+  };
+}
+async function loadWorld(worldPath) {
+  const { stat } = await import("fs/promises");
+  const info = await stat(worldPath);
+  if (info.isDirectory()) {
+    return loadWorldFromDirectory(worldPath);
+  }
+  if (worldPath.endsWith(".nv-world.zip")) {
+    throw new Error(".nv-world.zip loading not yet implemented \u2014 use a world directory");
+  }
+  throw new Error(`Cannot load world from: ${worldPath} \u2014 expected a directory or .nv-world.zip`);
+}
+
+export {
+  loadWorldFromDirectory,
+  loadWorld
+};

package/dist/chunk-MWDQ4MJB.js

@@ -0,0 +1,11 @@
+// src/contracts/guard-contract.ts
+var GUARD_EXIT_CODES = {
+  ALLOW: 0,
+  BLOCK: 1,
+  PAUSE: 2,
+  ERROR: 3
+};
+
+export {
+  GUARD_EXIT_CODES
+};

package/dist/chunk-O5OMJMIE.js

@@ -0,0 +1,590 @@
+// src/engine/validate-engine.ts
+function validateWorld(world) {
+  const startTime = performance.now();
+  const findings = [];
+  checkCompleteness(world, findings);
+  checkReferentialIntegrity(world, findings);
+  checkGuardCoverage(world, findings);
+  checkContradictions(world, findings);
+  checkOrphans(world, findings);
+  checkSchemaViolations(world, findings);
+  const severityOrder = { error: 0, warning: 1, info: 2 };
+  findings.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
+  const errors = findings.filter((f) => f.severity === "error").length;
+  const warnings = findings.filter((f) => f.severity === "warning").length;
+  const info = findings.filter((f) => f.severity === "info").length;
+  const completenessScore = computeCompletenessScore(world);
+  const invariantCoverage = computeInvariantCoverage(world);
+  const summary = {
+    errors,
+    warnings,
+    info,
+    completenessScore,
+    invariantCoverage,
+    canRun: errors === 0,
+    isHealthy: errors === 0 && warnings === 0
+  };
+  return {
+    worldId: world.world.world_id,
+    worldName: world.world.name,
+    worldVersion: world.world.version,
+    validatedAt: Date.now(),
+    durationMs: performance.now() - startTime,
+    summary,
+    findings
+  };
+}
+function checkCompleteness(world, findings) {
+  if (!world.world?.world_id) {
+    findings.push(finding("missing-world-id", "World identity is missing world_id", "error", "completeness", ["world.json"]));
+  }
+  if (!world.world?.name) {
+    findings.push(finding("missing-world-name", "World identity is missing name", "error", "completeness", ["world.json"]));
+  }
+  if (!world.world?.thesis) {
+    findings.push(finding("missing-thesis", "World has no thesis \u2014 there is nothing to simulate", "error", "completeness", ["world.json"]));
+  }
+  if (!world.invariants || world.invariants.length === 0) {
+    findings.push(finding("missing-invariants", "No invariants declared \u2014 world has no structural constraints", "error", "completeness", ["invariants.json"]));
+  }
+  if (!world.stateSchema?.variables || Object.keys(world.stateSchema.variables).length === 0) {
+    findings.push(finding("missing-state-schema", "No state variables declared \u2014 nothing to simulate", "error", "completeness", ["state-schema.json"]));
+  }
+  if (!world.rules || world.rules.length === 0) {
+    findings.push(finding("missing-rules", "No rules declared \u2014 world has no causal mechanics", "error", "completeness", ["rules/"]));
+  }
+  if (!world.gates?.viability_classification || world.gates.viability_classification.length === 0) {
+    findings.push(finding("missing-gates", "No viability gates declared \u2014 cannot classify outcomes", "error", "completeness", ["gates.json"]));
+  }
+  if (!world.outcomes?.computed_outcomes || world.outcomes.computed_outcomes.length === 0) {
+    findings.push(finding("missing-outcomes", "No computed outcomes declared \u2014 nothing to display", "warning", "completeness", ["outcomes.json"]));
+  }
+  if (!world.assumptions?.profiles || Object.keys(world.assumptions.profiles).length === 0) {
+    findings.push(finding("missing-assumptions", "No assumption profiles declared \u2014 cannot compare scenarios", "warning", "completeness", ["assumptions.json"]));
+  }
+  if (!world.metadata) {
+    findings.push(finding("missing-metadata", "No metadata block \u2014 world has no version history", "warning", "completeness", ["metadata.json"]));
+  }
+  if (!world.guards) {
+    findings.push(finding("no-guards", "No guards declared \u2014 Action Space enforcement unavailable", "info", "completeness", ["guards.json"]));
+  }
+  if (!world.roles) {
+    findings.push(finding("no-roles", "No roles declared \u2014 multi-agent governance unavailable", "info", "completeness", ["roles.json"]));
+  }
+  if (!world.kernel) {
+    findings.push(finding("no-kernel", "No kernel config \u2014 Thinking Space governance unavailable", "info", "completeness", ["kernel.json"]));
+  }
+}
+function checkReferentialIntegrity(world, findings) {
+  if (!world.rules || !world.stateSchema?.variables) return;
+  const declaredVars = new Set(Object.keys(world.stateSchema.variables));
+  const declaredOutcomes = new Set(
+    (world.outcomes?.computed_outcomes ?? []).map((o) => o.id)
+  );
+  const declaredAssumptionParams = new Set(
+    Object.keys(world.assumptions?.parameter_definitions ?? {})
+  );
+  const allDeclared = /* @__PURE__ */ new Set([...declaredVars, ...declaredOutcomes]);
+  for (const rule of world.rules) {
+    for (const trigger of rule.triggers) {
+      if (trigger.source === "state" && !allDeclared.has(trigger.field)) {
+        findings.push(finding(
+          `undeclared-trigger-${rule.id}-${trigger.field}`,
+          `Rule "${rule.id}" trigger references undeclared state variable "${trigger.field}"`,
+          "error",
+          "referential-integrity",
+          ["rules/", "state-schema.json"],
+          rule.id,
+          `Add "${trigger.field}" to state-schema.json variables`
+        ));
+      }
+      if (trigger.source === "assumption" && !declaredAssumptionParams.has(trigger.field)) {
+        findings.push(finding(
+          `undeclared-assumption-trigger-${rule.id}-${trigger.field}`,
+          `Rule "${rule.id}" trigger references undeclared assumption parameter "${trigger.field}"`,
+          "error",
+          "referential-integrity",
+          ["rules/", "assumptions.json"],
+          rule.id,
+          `Add "${trigger.field}" to assumptions.json parameter_definitions`
+        ));
+      }
+    }
+    for (const effect of rule.effects ?? []) {
+      if (!allDeclared.has(effect.target)) {
+        findings.push(finding(
+          `undeclared-effect-${rule.id}-${effect.target}`,
+          `Rule "${rule.id}" effect targets undeclared variable "${effect.target}"`,
+          "error",
+          "referential-integrity",
+          ["rules/", "state-schema.json", "outcomes.json"],
+          rule.id,
+          `Add "${effect.target}" to state-schema.json or outcomes.json`
+        ));
+      }
+    }
+    if (rule.exclusive_with) {
+      const refExists = world.rules.some((r) => r.id === rule.exclusive_with);
+      if (!refExists) {
+        findings.push(finding(
+          `broken-exclusive-${rule.id}`,
+          `Rule "${rule.id}" has exclusive_with="${rule.exclusive_with}" but that rule does not exist`,
+          "error",
+          "referential-integrity",
+          ["rules/"],
+          rule.id
+        ));
+      }
+    }
+    if (rule.collapse_check && !allDeclared.has(rule.collapse_check.field)) {
+      findings.push(finding(
+        `undeclared-collapse-${rule.id}`,
+        `Rule "${rule.id}" collapse_check references undeclared field "${rule.collapse_check.field}"`,
+        "error",
+        "referential-integrity",
+        ["rules/", "state-schema.json"],
+        rule.id
+      ));
+    }
+  }
+  for (const gate of world.gates?.viability_classification ?? []) {
+    if (!allDeclared.has(gate.field)) {
+      findings.push(finding(
+        `undeclared-gate-field-${gate.status}`,
+        `Gate "${gate.status}" references undeclared field "${gate.field}"`,
+        "error",
+        "referential-integrity",
+        ["gates.json", "state-schema.json", "outcomes.json"]
+      ));
+    }
+  }
+}
+function checkGuardCoverage(world, findings) {
+  if (!world.invariants || world.invariants.length === 0) return;
+  const guards = world.guards?.guards ?? [];
+  for (const invariant of world.invariants) {
+    if (invariant.enforcement === "prompt") continue;
+    const coveringGuard = guards.find(
+      (g) => g.invariant_ref === invariant.id && g.immutable
+    );
+    if (!coveringGuard) {
+      findings.push(finding(
+        `uncovered-invariant-${invariant.id}`,
+        `Invariant "${invariant.id}" has no backing structural guard \u2014 it is declared but not enforced at runtime`,
+        "warning",
+        "guard-coverage",
+        ["invariants.json", "guards.json"],
+        invariant.id,
+        `Add a structural guard with invariant_ref="${invariant.id}" to guards.json`
+      ));
+    }
+  }
+  for (const guard of guards) {
+    if (guard.invariant_ref) {
+      const invariantExists = world.invariants.some((i) => i.id === guard.invariant_ref);
+      if (!invariantExists) {
+        findings.push(finding(
+          `broken-guard-invariant-ref-${guard.id}`,
+          `Guard "${guard.id}" references invariant "${guard.invariant_ref}" which does not exist`,
+          "error",
+          "referential-integrity",
+          ["guards.json", "invariants.json"],
+          guard.id
+        ));
+      }
+    }
+  }
+  if (world.guards) {
+    const vocabKeys = new Set(Object.keys(world.guards.intent_vocabulary));
+    for (const guard of guards) {
+      for (const patternKey of guard.intent_patterns) {
+        if (!vocabKeys.has(patternKey)) {
+          findings.push(finding(
+            `broken-guard-pattern-${guard.id}-${patternKey}`,
+            `Guard "${guard.id}" references intent pattern "${patternKey}" which is not in intent_vocabulary`,
+            "error",
+            "referential-integrity",
+            ["guards.json"],
+            guard.id
+          ));
+        }
+      }
+    }
+  }
+}
+function checkContradictions(world, findings) {
+  if (!world.rules || world.rules.length < 2) return;
+  checkCircularExclusiveWith(world.rules, findings);
+  const tensions = detectSemanticTensions(world.rules);
+  for (let i = 0; i < tensions.length; i++) {
+    const tension = tensions[i];
+    findings.push(finding(
+      `semantic-tension-${i}`,
+      tension.message,
+      tension.severity,
+      "semantic-tension",
+      tension.affectedBlocks
+    ));
+  }
+}
+function checkCircularExclusiveWith(rules, findings) {
+  const exclusiveMap = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    if (rule.exclusive_with) {
+      exclusiveMap.set(rule.id, rule.exclusive_with);
+    }
+  }
+  const reportedPairs = /* @__PURE__ */ new Set();
+  for (const [ruleA, ruleB] of exclusiveMap) {
+    if (exclusiveMap.get(ruleB) === ruleA) {
+      const pairKey = [ruleA, ruleB].sort().join("::");
+      if (!reportedPairs.has(pairKey)) {
+        reportedPairs.add(pairKey);
+        findings.push(finding(
+          `mutual-exclusion-${pairKey.replace("::", "-")}`,
+          `Rules "${ruleA}" and "${ruleB}" are mutually exclusive \u2014 only one can fire per evaluation`,
+          "info",
+          "semantic-tension",
+          ["rules/"],
+          `${ruleA}, ${ruleB}`
+        ));
+      }
+    }
+  }
+  const reportedChains = /* @__PURE__ */ new Set();
+  for (const startRule of exclusiveMap.keys()) {
+    let current = startRule;
+    const visited = /* @__PURE__ */ new Set();
+    const chain = [];
+    while (current && !visited.has(current)) {
+      visited.add(current);
+      chain.push(current);
+      current = exclusiveMap.get(current);
+    }
+    if (current === startRule && visited.size > 2) {
+      const chainKey = [...chain].sort().join("::");
+      if (!reportedChains.has(chainKey)) {
+        reportedChains.add(chainKey);
+        findings.push(finding(
+          `circular-exclusive-chain-${startRule}`,
+          `Circular exclusive_with chain: ${chain.join(" \u2192 ")} \u2192 ${startRule} (${chain.length} rules)`,
+          "warning",
+          "contradiction",
+          ["rules/"],
+          chain.join(", ")
+        ));
+      }
+    }
+  }
+}
+function detectSemanticTensions(rules) {
+  const results = [];
+  if (rules.length < 2) return results;
+  const exclusivePairs = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    if (rule.exclusive_with) {
+      exclusivePairs.add(`${rule.id}:${rule.exclusive_with}`);
+      exclusivePairs.add(`${rule.exclusive_with}:${rule.id}`);
+    }
+  }
+  const isExclusive = (a, b) => exclusivePairs.has(`${a}:${b}`);
+  const targetEffects = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    const allEffects = [
+      ...rule.effects || [],
+      ...(rule.effects_conditional || []).flatMap((c) => c.effects)
+    ];
+    for (const effect of allEffects) {
+      const direction = classifyEffectDirection(effect);
+      if (direction === "neutral") continue;
+      const entries = targetEffects.get(effect.target) ?? [];
+      entries.push({ ruleId: rule.id, ruleLabel: rule.label, direction, effect });
+      targetEffects.set(effect.target, entries);
+    }
+  }
+  for (const [target, effects] of targetEffects) {
+    const increasing = effects.filter((e) => e.direction === "increase");
+    const decreasing = effects.filter((e) => e.direction === "decrease");
+    if (increasing.length === 0 || decreasing.length === 0) continue;
+    const incRuleIds = /* @__PURE__ */ new Set();
+    const decRuleIds = /* @__PURE__ */ new Set();
+    for (const inc of increasing) {
+      for (const dec of decreasing) {
+        if (inc.ruleId === dec.ruleId) continue;
+        if (isExclusive(inc.ruleId, dec.ruleId)) continue;
+        incRuleIds.add(inc.ruleId);
+        decRuleIds.add(dec.ruleId);
+      }
+    }
+    if (incRuleIds.size === 0 || decRuleIds.size === 0) continue;
+    const incLabels = [...incRuleIds].map((id) => {
+      const e = increasing.find((e2) => e2.ruleId === id);
+      return `"${e.ruleLabel}" (${describeEffect(e.effect)})`;
+    });
+    const decLabels = [...decRuleIds].map((id) => {
+      const e = decreasing.find((e2) => e2.ruleId === id);
+      return `"${e.ruleLabel}" (${describeEffect(e.effect)})`;
+    });
+    results.push({
+      type: "semantic_tension",
+      severity: "warning",
+      message: `Opposing effects on "${target}": ${incLabels.join(", ")} increase it while ${decLabels.join(", ")} decrease it`,
+      affectedBlocks: ["rules"]
+    });
+  }
+  const setEffects = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    const allEffects = [
+      ...rule.effects || [],
+      ...(rule.effects_conditional || []).flatMap((c) => c.effects)
+    ];
+    for (const effect of allEffects) {
+      if (effect.operation !== "set" && effect.operation !== "set_boolean" && effect.operation !== "set_dynamic") continue;
+      const entries = setEffects.get(effect.target) ?? [];
+      entries.push({ ruleId: rule.id, ruleLabel: rule.label, value: effect.value });
+      setEffects.set(effect.target, entries);
+    }
+  }
+  for (const [target, effects] of setEffects) {
+    if (effects.length < 2) continue;
+    const byValue = /* @__PURE__ */ new Map();
+    for (const e of effects) {
+      const key = String(e.value);
+      const existing = byValue.get(key) ?? [];
+      existing.push(e);
+      byValue.set(key, existing);
+    }
+    if (byValue.size < 2) continue;
+    const valueGroups = [...byValue.entries()];
+    const involvedRules = [];
+    for (let i = 0; i < valueGroups.length; i++) {
+      for (let j = i + 1; j < valueGroups.length; j++) {
+        for (const a of valueGroups[i][1]) {
+          for (const b of valueGroups[j][1]) {
+            if (a.ruleId === b.ruleId) continue;
+            if (isExclusive(a.ruleId, b.ruleId)) continue;
+            if (!involvedRules.includes(a.ruleId)) involvedRules.push(a.ruleId);
+            if (!involvedRules.includes(b.ruleId)) involvedRules.push(b.ruleId);
+          }
+        }
+      }
+    }
+    if (involvedRules.length === 0) continue;
+    const descriptions = involvedRules.map((id) => {
+      const e = effects.find((e2) => e2.ruleId === id);
+      return `"${e.ruleLabel}" sets to ${e.value}`;
+    });
+    results.push({
+      type: "semantic_tension",
+      severity: "warning",
+      message: `Conflicting set operations on "${target}": ${descriptions.join(", ")}`,
+      affectedBlocks: ["rules"]
+    });
+  }
+  return results;
+}
+function classifyEffectDirection(effect) {
+  if (effect.operation === "multiply" || effect.operation === "multiply_dynamic") {
+    const val = typeof effect.value === "number" ? effect.value : 1;
+    return val > 1 ? "increase" : val < 1 ? "decrease" : "neutral";
+  }
+  if (effect.operation === "add" || effect.operation === "add_dynamic") {
+    const val = typeof effect.value === "number" ? effect.value : 0;
+    return val > 0 ? "increase" : val < 0 ? "decrease" : "neutral";
+  }
+  if (effect.operation === "subtract" || effect.operation === "subtract_dynamic") {
+    const val = typeof effect.value === "number" ? effect.value : 0;
+    return val > 0 ? "decrease" : val < 0 ? "increase" : "neutral";
+  }
+  return "neutral";
+}
+function describeEffect(effect) {
+  switch (effect.operation) {
+    case "multiply":
+    case "multiply_dynamic":
+      return `multiplies by ${effect.value}`;
+    case "add":
+    case "add_dynamic":
+      return `adds ${effect.value}`;
+    case "subtract":
+    case "subtract_dynamic":
+      return `subtracts ${effect.value}`;
+    case "set":
+    case "set_dynamic":
+    case "set_boolean":
+      return `sets to ${effect.value}`;
+    default:
+      return `${effect.operation} ${effect.value}`;
+  }
+}
+function checkOrphans(world, findings) {
+  if (!world.stateSchema?.variables || !world.rules) return;
+  const referencedVars = /* @__PURE__ */ new Set();
+  for (const rule of world.rules) {
+    for (const trigger of rule.triggers) {
+      referencedVars.add(trigger.field);
+    }
+    for (const effect of rule.effects ?? []) {
+      referencedVars.add(effect.target);
+    }
+    if (rule.collapse_check) {
+      referencedVars.add(rule.collapse_check.field);
+    }
+  }
+  for (const gate of world.gates?.viability_classification ?? []) {
+    referencedVars.add(gate.field);
+  }
+  for (const varId of Object.keys(world.stateSchema.variables)) {
+    if (!referencedVars.has(varId)) {
+      findings.push(finding(
+        `orphan-variable-${varId}`,
+        `State variable "${varId}" is declared but never referenced by any rule or gate`,
+        "warning",
+        "orphan",
+        ["state-schema.json"],
+        varId,
+        "Remove this variable or add rules that reference it"
+      ));
+    }
+  }
+  const effectTargets = /* @__PURE__ */ new Set();
+  for (const rule of world.rules) {
+    for (const effect of rule.effects ?? []) {
+      effectTargets.add(effect.target);
+    }
+  }
+  for (const outcome of world.outcomes?.computed_outcomes ?? []) {
+    if (outcome.assignment === "external") continue;
+    if (!effectTargets.has(outcome.id) && !outcome.derived_from) {
+      findings.push(finding(
+        `orphan-outcome-${outcome.id}`,
+        `Outcome "${outcome.id}" is declared but no rule produces it`,
+        "warning",
+        "orphan",
+        ["outcomes.json", "rules/"],
+        outcome.id
+      ));
+    }
+  }
+}
+function checkSchemaViolations(world, findings) {
+  if (!world.stateSchema?.variables) return;
+  for (const [varId, variable] of Object.entries(world.stateSchema.variables)) {
+    if (variable.type === "number") {
+      const def = variable.default;
+      if (variable.min !== void 0 && def < variable.min) {
+        findings.push(finding(
+          `default-below-min-${varId}`,
+          `Variable "${varId}" default (${def}) is below declared min (${variable.min})`,
+          "error",
+          "schema-violation",
+          ["state-schema.json"],
+          varId
+        ));
+      }
+      if (variable.max !== void 0 && def > variable.max) {
+        findings.push(finding(
+          `default-above-max-${varId}`,
+          `Variable "${varId}" default (${def}) is above declared max (${variable.max})`,
+          "error",
+          "schema-violation",
+          ["state-schema.json"],
+          varId
+        ));
+      }
+    }
+    if (variable.type === "enum") {
+      if (!variable.options || variable.options.length === 0) {
+        findings.push(finding(
+          `enum-no-options-${varId}`,
+          `Enum variable "${varId}" has no options declared`,
+          "error",
+          "schema-violation",
+          ["state-schema.json"],
+          varId
+        ));
+      } else if (!variable.options.includes(variable.default)) {
+        findings.push(finding(
+          `enum-default-invalid-${varId}`,
+          `Enum variable "${varId}" default "${variable.default}" is not in declared options`,
+          "error",
+          "schema-violation",
+          ["state-schema.json"],
+          varId
+        ));
+      }
+    }
+  }
+  for (const [presetName, preset] of Object.entries(world.stateSchema.presets ?? {})) {
+    for (const [varId, value] of Object.entries(preset.values)) {
+      const variable = world.stateSchema.variables[varId];
+      if (!variable) {
+        findings.push(finding(
+          `preset-undeclared-var-${presetName}-${varId}`,
+          `Preset "${presetName}" sets undeclared variable "${varId}"`,
+          "error",
+          "referential-integrity",
+          ["state-schema.json"],
+          presetName
+        ));
+        continue;
+      }
+      if (variable.type === "number" && typeof value === "number") {
+        if (variable.min !== void 0 && value < variable.min) {
+          findings.push(finding(
+            `preset-below-min-${presetName}-${varId}`,
+            `Preset "${presetName}" sets "${varId}" to ${value}, below min ${variable.min}`,
+            "warning",
+            "schema-violation",
+            ["state-schema.json"],
+            presetName
+          ));
+        }
+        if (variable.max !== void 0 && value > variable.max) {
+          findings.push(finding(
+            `preset-above-max-${presetName}-${varId}`,
+            `Preset "${presetName}" sets "${varId}" to ${value}, above max ${variable.max}`,
+            "warning",
+            "schema-violation",
+            ["state-schema.json"],
+            presetName
+          ));
+        }
+      }
+    }
+  }
+}
+function computeCompletenessScore(world) {
+  let score = 0;
+  const total = 9;
+  if (world.world?.world_id && world.world?.name && world.world?.thesis) score++;
+  if (world.invariants && world.invariants.length > 0) score++;
+  if (world.assumptions?.profiles && Object.keys(world.assumptions.profiles).length > 0) score++;
+  if (world.stateSchema?.variables && Object.keys(world.stateSchema.variables).length > 0) score++;
+  if (world.rules && world.rules.length > 0) score++;
+  if (world.gates?.viability_classification && world.gates.viability_classification.length > 0) score++;
+  if (world.outcomes?.computed_outcomes && world.outcomes.computed_outcomes.length > 0) score++;
+  if (world.guards?.guards && world.guards.guards.length > 0) score++;
+  if (world.metadata) score++;
+  return Math.round(score / total * 100);
+}
+function computeInvariantCoverage(world) {
+  if (!world.invariants || world.invariants.length === 0) return 0;
+  const guards = world.guards?.guards ?? [];
+  let covered = 0;
+  for (const invariant of world.invariants) {
+    const hasGuard = guards.some((g) => g.invariant_ref === invariant.id && g.immutable);
+    if (hasGuard) covered++;
+  }
+  return Math.round(covered / world.invariants.length * 100);
+}
+function finding(id, message, severity, category, affectedBlocks, source, suggestion) {
+  const f = { id, message, severity, category, affectedBlocks };
+  if (source) f.source = source;
+  if (suggestion) f.suggestion = suggestion;
+  return f;
+}
+
+export {
+  validateWorld
+};