@neuroverseos/governance 0.3.1 → 0.3.3

package/dist/browser.global.js

@@ -0,0 +1,941 @@
+"use strict";
+var NeuroVerse = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/browser.ts
+  var browser_exports = {};
+  __export(browser_exports, {
+    emitWorldDefinition: () => emitWorldDefinition,
+    parseAndEmitWorld: () => parseAndEmitWorld,
+    parseWorldMarkdown: () => parseWorldMarkdown,
+    simulateWorld: () => simulateWorld
+  });
+
+  // src/engine/simulate-engine.ts
+  function simulateWorld(world, options = {}) {
+    if (!world || !world.world) {
+      throw new Error(
+        'World definition required. simulateWorld() cannot run without a world.\nLoad one with: loadWorld("./world/") or parseWorldMarkdown(markdown)'
+      );
+    }
+    const steps = Math.max(1, Math.min(options.steps ?? 1, 50));
+    const profileName = options.profile ?? world.world.default_assumption_profile;
+    const state = buildInitialState(world.stateSchema, options.stateOverrides);
+    for (const outcome of world.outcomes?.computed_outcomes ?? []) {
+      if (!(outcome.id in state)) {
+        state[outcome.id] = outcome.primary ? 100 : 0;
+      }
+    }
+    const assumptions = resolveAssumptions(world.assumptions, profileName);
+    const initialState = { ...state };
+    const simulationSteps = [];
+    let collapsed = false;
+    let collapseStep;
+    let collapseRule;
+    const sortedRules = [...world.rules].sort((a, b) => a.order - b.order);
+    for (let stepNum = 1; stepNum <= steps; stepNum++) {
+      if (collapsed) break;
+      const stepResult = evaluateStep(
+        stepNum,
+        sortedRules,
+        state,
+        assumptions,
+        world
+      );
+      simulationSteps.push(stepResult);
+      if (stepResult.collapsed) {
+        collapsed = true;
+        collapseStep = stepNum;
+        collapseRule = stepResult.rulesEvaluated.find((r) => r.collapsed)?.ruleId;
+      }
+    }
+    const finalViability = classifyViability(state, world);
+    return {
+      worldId: world.world.world_id,
+      worldName: world.world.name,
+      profile: profileName,
+      initialState,
+      steps: simulationSteps,
+      finalState: { ...state },
+      finalViability,
+      collapsed,
+      collapseStep,
+      collapseRule
+    };
+  }
+  function evaluateStep(stepNum, rules, state, assumptions, world) {
+    const evaluations = [];
+    let rulesFired = 0;
+    let collapsed = false;
+    const firedRuleIds = /* @__PURE__ */ new Set();
+    for (const rule of rules) {
+      if (collapsed) {
+        evaluations.push({
+          ruleId: rule.id,
+          label: rule.label,
+          triggered: false,
+          excluded: true,
+          effects: [],
+          collapsed: false
+        });
+        continue;
+      }
+      const excluded = rule.exclusive_with ? firedRuleIds.has(rule.exclusive_with) : false;
+      if (excluded) {
+        evaluations.push({
+          ruleId: rule.id,
+          label: rule.label,
+          triggered: false,
+          excluded: true,
+          effects: [],
+          collapsed: false
+        });
+        continue;
+      }
+      const triggered = evaluateTriggers(rule.triggers, state, assumptions);
+      if (!triggered) {
+        evaluations.push({
+          ruleId: rule.id,
+          label: rule.label,
+          triggered: false,
+          excluded: false,
+          effects: [],
+          collapsed: false
+        });
+        continue;
+      }
+      firedRuleIds.add(rule.id);
+      rulesFired++;
+      const appliedEffects = [];
+      for (const effect of rule.effects ?? []) {
+        const applied = applyEffect(effect, state);
+        if (applied) appliedEffects.push(applied);
+      }
+      for (const ce of rule.effects_conditional ?? []) {
+        const conditionMet = evaluateSingleTrigger(ce.condition, state, assumptions);
+        const andMet = ce.and ? evaluateSingleTrigger(ce.and, state, assumptions) : true;
+        const orMet = ce.or ? evaluateSingleTrigger(ce.or, state, assumptions) : false;
+        const anyMet = ce.condition_any ? ce.condition_any.some((c) => evaluateSingleTrigger(c, state, assumptions)) : false;
+        const shouldApply = conditionMet && andMet || ce.or && orMet || ce.condition_any && anyMet;
+        if (shouldApply) {
+          for (const effect of ce.effects) {
+            const applied = applyEffect(effect, state);
+            if (applied) appliedEffects.push(applied);
+          }
+        }
+      }
+      let ruleCollapsed = false;
+      if (rule.collapse_check) {
+        const fieldVal = typeof state[rule.collapse_check.field] === "number" ? state[rule.collapse_check.field] : 0;
+        if (evaluateOperator(fieldVal, rule.collapse_check.operator, rule.collapse_check.value)) {
+          ruleCollapsed = true;
+          collapsed = true;
+        }
+      }
+      if (!ruleCollapsed && rule.secondary_check) {
+        const fieldVal = typeof state[rule.secondary_check.field] === "number" ? state[rule.secondary_check.field] : 0;
+        if (evaluateOperator(fieldVal, rule.secondary_check.operator, rule.secondary_check.value)) {
+          ruleCollapsed = true;
+          collapsed = true;
+        }
+      }
+      evaluations.push({
+        ruleId: rule.id,
+        label: rule.label,
+        triggered: true,
+        excluded: false,
+        effects: appliedEffects,
+        collapsed: ruleCollapsed,
+        collapseField: ruleCollapsed ? rule.collapse_check?.field ?? rule.secondary_check?.field : void 0
+      });
+    }
+    const viability = classifyViability(state, world);
+    return {
+      step: stepNum,
+      rulesEvaluated: evaluations,
+      rulesFired,
+      stateAfter: { ...state },
+      viability,
+      collapsed
+    };
+  }
+  function evaluateTriggers(triggers, state, assumptions) {
+    if (!triggers || triggers.length === 0) return true;
+    return triggers.every((t) => evaluateSingleTrigger(t, state, assumptions));
+  }
+  function evaluateSingleTrigger(trigger, state, assumptions) {
+    const source = trigger.source === "assumption" ? assumptions : state;
+    const fieldValue = source[trigger.field];
+    if (fieldValue === void 0) return false;
+    return evaluateOperator(fieldValue, trigger.operator, trigger.value);
+  }
+  function evaluateOperator(fieldValue, operator, conditionValue) {
+    switch (operator) {
+      case "==":
+        return fieldValue === conditionValue;
+      case "!=":
+        return fieldValue !== conditionValue;
+      case ">":
+        return typeof fieldValue === "number" && typeof conditionValue === "number" && fieldValue > conditionValue;
+      case "<":
+        return typeof fieldValue === "number" && typeof conditionValue === "number" && fieldValue < conditionValue;
+      case ">=":
+        return typeof fieldValue === "number" && typeof conditionValue === "number" && fieldValue >= conditionValue;
+      case "<=":
+        return typeof fieldValue === "number" && typeof conditionValue === "number" && fieldValue <= conditionValue;
+      case "in":
+        return Array.isArray(conditionValue) && conditionValue.includes(String(fieldValue));
+      default:
+        return false;
+    }
+  }
+  function applyEffect(effect, state) {
+    const before = state[effect.target];
+    let after;
+    switch (effect.operation) {
+      case "multiply":
+      case "multiply_dynamic": {
+        const current = typeof before === "number" ? before : 0;
+        const factor = typeof effect.value === "number" ? effect.value : 1;
+        after = current * factor;
+        break;
+      }
+      case "add":
+      case "add_dynamic": {
+        const current = typeof before === "number" ? before : 0;
+        const addend = typeof effect.value === "number" ? effect.value : 0;
+        after = current + addend;
+        break;
+      }
+      case "subtract":
+      case "subtract_dynamic": {
+        const current = typeof before === "number" ? before : 0;
+        const subtrahend = typeof effect.value === "number" ? effect.value : 0;
+        after = current - subtrahend;
+        break;
+      }
+      case "set":
+      case "set_dynamic":
+        after = effect.value;
+        break;
+      case "set_boolean":
+        after = !!effect.value;
+        break;
+      default:
+        return null;
+    }
+    state[effect.target] = after;
+    return {
+      target: effect.target,
+      operation: effect.operation,
+      value: effect.value,
+      before: before ?? 0,
+      after
+    };
+  }
+  function buildInitialState(schema, overrides) {
+    const state = {};
+    for (const [name, variable] of Object.entries(schema.variables ?? {})) {
+      state[name] = variable.default;
+    }
+    if (overrides) {
+      for (const [key, value] of Object.entries(overrides)) {
+        state[key] = value;
+      }
+    }
+    return state;
+  }
+  function resolveAssumptions(config, profileName) {
+    const profile = config.profiles?.[profileName];
+    return profile?.parameters ?? {};
+  }
+  function classifyViability(state, world) {
+    const gates = world.gates?.viability_classification ?? [];
+    for (const gate of gates) {
+      const fieldValue = state[gate.field];
+      if (typeof fieldValue !== "number") continue;
+      if (evaluateOperator(fieldValue, gate.operator, gate.value)) {
+        return gate.status;
+      }
+    }
+    return "MODEL_COLLAPSES";
+  }
+
+  // src/engine/bootstrap-parser.ts
+  function splitSections(markdown) {
+    const lines = markdown.split("\n");
+    let frontmatter = "";
+    let bodyStart = 0;
+    if (lines[0]?.trim() === "---") {
+      const endIdx = lines.indexOf("---", 1);
+      if (endIdx > 0) {
+        frontmatter = lines.slice(1, endIdx).join("\n");
+        bodyStart = endIdx + 1;
+      }
+    }
+    const sections = [];
+    let currentSection = null;
+    const contentLines = [];
+    for (let i = bodyStart; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.startsWith("# ")) {
+        if (currentSection) {
+          currentSection.content = contentLines.join("\n").trim();
+          sections.push(currentSection);
+          contentLines.length = 0;
+        }
+        currentSection = {
+          name: line.replace(/^#\s+/, "").trim(),
+          content: "",
+          startLine: i + 1
+          // 1-based
+        };
+      } else if (currentSection) {
+        contentLines.push(line);
+      }
+    }
+    if (currentSection) {
+      currentSection.content = contentLines.join("\n").trim();
+      sections.push(currentSection);
+    }
+    return { frontmatter, sections };
+  }
+  function parseFrontmatter(yaml, issues) {
+    const result = {};
+    for (const line of yaml.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const colonIdx = trimmed.indexOf(":");
+      if (colonIdx === -1) continue;
+      const key = trimmed.slice(0, colonIdx).trim();
+      const value = trimmed.slice(colonIdx + 1).trim();
+      result[key] = value;
+    }
+    if (!result.world_id) {
+      issues.push({ line: 1, section: "frontmatter", message: "Missing world_id in frontmatter", severity: "error" });
+    }
+    if (!result.name) {
+      issues.push({ line: 1, section: "frontmatter", message: "Missing name in frontmatter", severity: "error" });
+    }
+    return {
+      world_id: result.world_id ?? "",
+      name: result.name ?? "",
+      version: result.version,
+      runtime_mode: result.runtime_mode,
+      default_profile: result.default_profile,
+      alternative_profile: result.alternative_profile
+    };
+  }
+  function parseThesis(content, startLine, issues) {
+    const thesis = content.trim();
+    if (!thesis) {
+      issues.push({ line: startLine, section: "Thesis", message: "Thesis section is empty", severity: "error" });
+    }
+    return thesis;
+  }
+  function parseInvariants(content, startLine, issues) {
+    const invariants = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (!line.startsWith("- ")) continue;
+      const lineNum = startLine + i + 1;
+      const match = line.match(
+        /^-\s+`([^`]+)`\s*[—–-]\s*(.+?)(?:\s*\(([^)]+)\))?\s*$/
+      );
+      if (match) {
+        const id = match[1];
+        const label = match[2].trim();
+        const parens = match[3] ?? "structural, immutable";
+        const enforcement = parens.includes("prompt") ? "prompt" : parens.includes("operational") ? "operational" : "structural";
+        const mutable = parens.includes("mutable") && !parens.includes("immutable");
+        invariants.push({ id, label, enforcement, mutable, line: lineNum });
+      } else {
+        const fallback = line.match(/^-\s+\*\*([^*]+)\*\*\s*[—–-]\s*(.+)/);
+        if (fallback) {
+          const id = fallback[1].toLowerCase().replace(/\s+/g, "_");
+          const label = fallback[2].trim();
+          invariants.push({ id, label, enforcement: "structural", mutable: false, line: lineNum });
+        } else {
+          issues.push({ line: lineNum, section: "Invariants", message: `Could not parse invariant: "${line}"`, severity: "warning" });
+        }
+      }
+    }
+    if (invariants.length === 0) {
+      issues.push({ line: startLine, section: "Invariants", message: "No invariants found", severity: "error" });
+    }
+    return invariants;
+  }
+  function parseStateVariables(content, startLine, issues) {
+    const variables = [];
+    const subSections = splitH2Sections(content, startLine);
+    for (const sub of subSections) {
+      const props = parseKeyValueBullets(sub.content);
+      const lineNum = sub.startLine;
+      const type = props.type;
+      if (!type) {
+        issues.push({ line: lineNum, section: "State", message: `Variable "${sub.name}" missing type`, severity: "error" });
+        continue;
+      }
+      let defaultVal = props.default ?? "";
+      if (type === "number") {
+        defaultVal = parseFloat(String(defaultVal)) || 0;
+      } else if (type === "boolean") {
+        defaultVal = String(defaultVal).toLowerCase() === "true";
+      }
+      const variable = {
+        id: sub.name,
+        type,
+        default: defaultVal,
+        label: props.label ?? sub.name,
+        description: props.description ?? "",
+        line: lineNum
+      };
+      if (type === "number") {
+        if (props.min !== void 0) variable.min = parseFloat(props.min);
+        if (props.max !== void 0) variable.max = parseFloat(props.max);
+        if (props.step !== void 0) variable.step = parseFloat(props.step);
+      }
+      if (type === "enum" && props.options) {
+        variable.options = props.options.split(",").map((s) => s.trim());
+      }
+      variables.push(variable);
+    }
+    return variables;
+  }
+  function parseAssumptions(content, startLine, issues) {
+    const profiles = [];
+    const subSections = splitH2Sections(content, startLine);
+    for (const sub of subSections) {
+      const props = parseKeyValueBullets(sub.content);
+      const name = props.name ?? sub.name;
+      const description = props.description ?? "";
+      const parameters = {};
+      for (const [key, val] of Object.entries(props)) {
+        if (key === "name" || key === "description") continue;
+        if (val === "true") parameters[key] = true;
+        else if (val === "false") parameters[key] = false;
+        else if (!isNaN(Number(val)) && val.trim() !== "") parameters[key] = Number(val);
+        else parameters[key] = val;
+      }
+      profiles.push({
+        id: sub.name,
+        name,
+        description,
+        parameters,
+        line: sub.startLine
+      });
+    }
+    return profiles;
+  }
+  function parseRules(content, startLine, issues) {
+    const rules = [];
+    const subSections = splitH2Sections(content, startLine);
+    for (let ruleIdx = 0; ruleIdx < subSections.length; ruleIdx++) {
+      const sub = subSections[ruleIdx];
+      const lineNum = sub.startLine;
+      const headingMatch = sub.name.match(/^([^:]+):\s*(.+?)(?:\s*\(([^)]+)\))?\s*$/);
+      const id = headingMatch ? headingMatch[1].trim() : `rule-${String(ruleIdx + 1).padStart(3, "0")}`;
+      const label = headingMatch ? headingMatch[2].trim() : sub.name;
+      const severity = headingMatch?.[3]?.trim() ?? "degradation";
+      const lines = sub.content.split("\n");
+      let description = "";
+      const triggers = [];
+      const effects = [];
+      let collapseCheck;
+      const causalParts = {};
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith("When ")) {
+          const triggerStr = line.slice(5);
+          const parts = triggerStr.split(/\s+AND\s+/i);
+          for (const part of parts) {
+            const trigger = parseTriggerExpression(part.trim());
+            if (trigger) triggers.push(trigger);
+            else issues.push({ line: lineNum + i, section: "Rules", message: `Could not parse trigger: "${part}"`, severity: "warning" });
+          }
+        } else if (line.startsWith("Then ")) {
+          const effectStr = line.slice(5);
+          const parts = effectStr.split(",");
+          for (const part of parts) {
+            const effect = parseEffectExpression(part.trim());
+            if (effect) effects.push(effect);
+            else issues.push({ line: lineNum + i, section: "Rules", message: `Could not parse effect: "${part}"`, severity: "warning" });
+          }
+        } else if (line.startsWith("Collapse:")) {
+          const collapseStr = line.slice(9).trim();
+          const collapse = parseCollapseExpression(collapseStr);
+          if (collapse) collapseCheck = collapse;
+          else issues.push({ line: lineNum + i, section: "Rules", message: `Could not parse collapse: "${collapseStr}"`, severity: "warning" });
+        } else if (line.startsWith("> ")) {
+          const causalMatch = line.match(/^>\s*(trigger|rule|shift|effect):\s*(.+)/i);
+          if (causalMatch) {
+            causalParts[causalMatch[1].toLowerCase()] = causalMatch[2].trim();
+          }
+        } else if (line && !line.startsWith("-") && !line.startsWith("#")) {
+          if (!description) description = line;
+          else description += " " + line;
+        }
+      }
+      if (triggers.length === 0) {
+        issues.push({ line: lineNum, section: "Rules", message: `Rule "${id}" has no triggers (missing "When" line)`, severity: "warning" });
+      }
+      if (effects.length === 0) {
+        issues.push({ line: lineNum, section: "Rules", message: `Rule "${id}" has no effects (missing "Then" line)`, severity: "warning" });
+      }
+      const causal_translation = Object.keys(causalParts).length > 0 ? {
+        trigger_text: causalParts.trigger ?? "",
+        rule_text: causalParts.rule ?? "",
+        shift_text: causalParts.shift ?? "",
+        effect_text: causalParts.effect ?? ""
+      } : void 0;
+      rules.push({
+        id,
+        label,
+        severity,
+        description: description || void 0,
+        order: ruleIdx + 1,
+        triggers,
+        effects,
+        collapse_check: collapseCheck,
+        causal_translation,
+        line: lineNum
+      });
+    }
+    return rules;
+  }
+  function parseTriggerExpression(expr) {
+    const match = expr.match(
+      /^(\w+)\s*(==|!=|>=|<=|>|<|in)\s*(.+?)\s*\[(state|assumption)\]\s*$/
+    );
+    if (!match) return null;
+    const field = match[1];
+    const operator = match[2];
+    let value = match[3].trim();
+    const source = match[4];
+    value = parseValueLiteral(value);
+    return { field, operator, value, source };
+  }
+  function parseEffectExpression(expr) {
+    const compound = expr.match(/^(\w+)\s*(\*=|\+=|-=)\s*(.+)$/);
+    if (compound) {
+      const target = compound[1];
+      const op = compound[2];
+      const value = parseValueLiteral(compound[3].trim());
+      const operationMap = {
+        "*=": "multiply",
+        "+=": "add",
+        "-=": "subtract"
+      };
+      return { target, operation: operationMap[op], value };
+    }
+    const assignment = expr.match(/^(\w+)\s*=\s*(.+)$/);
+    if (assignment) {
+      const target = assignment[1];
+      const value = parseValueLiteral(assignment[2].trim());
+      const operation = typeof value === "boolean" ? "set_boolean" : "set";
+      return { target, operation, value };
+    }
+    return null;
+  }
+  function parseCollapseExpression(expr) {
+    const cleaned = expr.replace(/\s*→.*$/, "").trim();
+    const match = cleaned.match(/^(\w+)\s*(==|!=|>=|<=|>|<)\s*([\d.]+)$/);
+    if (!match) return null;
+    return {
+      field: match[1],
+      operator: match[2],
+      value: parseFloat(match[3])
+    };
+  }
+  function parseGates(content, startLine, issues) {
+    const gates = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (!line.startsWith("- ")) continue;
+      const lineNum = startLine + i + 1;
+      const match = line.match(/^-\s+(\w+):\s*(\w+)\s*(==|!=|>=|<=|>|<)\s*([\d.]+)/);
+      if (match) {
+        gates.push({
+          status: match[1],
+          field: match[2],
+          operator: match[3],
+          value: parseFloat(match[4]),
+          line: lineNum
+        });
+      } else {
+        issues.push({ line: lineNum, section: "Gates", message: `Could not parse gate: "${line}"`, severity: "warning" });
+      }
+    }
+    if (gates.length === 0) {
+      issues.push({ line: startLine, section: "Gates", message: "No gates found", severity: "error" });
+    }
+    return gates;
+  }
+  function parseOutcomes(content, startLine, issues) {
+    const outcomes = [];
+    const subSections = splitH2Sections(content, startLine);
+    for (const sub of subSections) {
+      const props = parseKeyValueBullets(sub.content);
+      const outcome = {
+        id: sub.name,
+        type: props.type ?? "number",
+        label: props.label ?? sub.name,
+        line: sub.startLine
+      };
+      if (props.range) {
+        const rangeParts = props.range.split("-").map(Number);
+        if (rangeParts.length === 2 && !isNaN(rangeParts[0]) && !isNaN(rangeParts[1])) {
+          outcome.range = [rangeParts[0], rangeParts[1]];
+        }
+      }
+      if (props.display) outcome.display = props.display;
+      if (props.primary) outcome.primary = props.primary === "true";
+      if (props.assignment) outcome.assignment = props.assignment;
+      outcomes.push(outcome);
+    }
+    return outcomes;
+  }
+  function splitH2Sections(content, baseStartLine) {
+    const lines = content.split("\n");
+    const sections = [];
+    let current = null;
+    const contentLines = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.startsWith("## ")) {
+        if (current) {
+          current.content = contentLines.join("\n").trim();
+          sections.push(current);
+          contentLines.length = 0;
+        }
+        current = {
+          name: line.replace(/^##\s+/, "").trim(),
+          content: "",
+          startLine: baseStartLine + i + 1
+        };
+      } else if (current) {
+        contentLines.push(line);
+      }
+    }
+    if (current) {
+      current.content = contentLines.join("\n").trim();
+      sections.push(current);
+    }
+    return sections;
+  }
+  function parseKeyValueBullets(content) {
+    const result = {};
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      const match = trimmed.match(/^-\s+(\w[\w\s]*?):\s*(.+)$/);
+      if (match) {
+        result[match[1].trim().toLowerCase().replace(/\s+/g, "_")] = match[2].trim();
+      }
+    }
+    return result;
+  }
+  function parseValueLiteral(raw) {
+    if (raw === "true") return true;
+    if (raw === "false") return false;
+    if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+      return raw.slice(1, -1);
+    }
+    const num = Number(raw);
+    if (!isNaN(num) && raw.trim() !== "") return num;
+    return raw;
+  }
+  function parseWorldMarkdown(markdown) {
+    const issues = [];
+    const { frontmatter: fmRaw, sections } = splitSections(markdown);
+    const frontmatter = parseFrontmatter(fmRaw, issues);
+    const findSection = (name) => sections.find((s) => s.name.toLowerCase() === name.toLowerCase());
+    const thesisSection = findSection("Thesis");
+    const thesis = thesisSection ? parseThesis(thesisSection.content, thesisSection.startLine, issues) : "";
+    if (!thesisSection) {
+      issues.push({ line: 0, section: "Thesis", message: "Missing # Thesis section", severity: "error" });
+    }
+    const invariantsSection = findSection("Invariants");
+    const invariants = invariantsSection ? parseInvariants(invariantsSection.content, invariantsSection.startLine, issues) : [];
+    if (!invariantsSection) {
+      issues.push({ line: 0, section: "Invariants", message: "Missing # Invariants section", severity: "error" });
+    }
+    const stateSection = findSection("State");
+    const stateVariables = stateSection ? parseStateVariables(stateSection.content, stateSection.startLine, issues) : [];
+    if (!stateSection) {
+      issues.push({ line: 0, section: "State", message: "Missing # State section", severity: "warning" });
+    }
+    const assumptionsSection = findSection("Assumptions");
+    const assumptions = assumptionsSection ? parseAssumptions(assumptionsSection.content, assumptionsSection.startLine, issues) : [];
+    if (!assumptionsSection) {
+      issues.push({ line: 0, section: "Assumptions", message: "Missing # Assumptions section", severity: "warning" });
+    }
+    const rulesSection = findSection("Rules");
+    const rules = rulesSection ? parseRules(rulesSection.content, rulesSection.startLine, issues) : [];
+    if (!rulesSection) {
+      issues.push({ line: 0, section: "Rules", message: "Missing # Rules section", severity: "warning" });
+    }
+    const gatesSection = findSection("Gates");
+    const gates = gatesSection ? parseGates(gatesSection.content, gatesSection.startLine, issues) : [];
+    if (!gatesSection) {
+      issues.push({ line: 0, section: "Gates", message: "Missing # Gates section", severity: "warning" });
+    }
+    const outcomesSection = findSection("Outcomes");
+    const outcomes = outcomesSection ? parseOutcomes(outcomesSection.content, outcomesSection.startLine, issues) : [];
+    const parsedSections = sections.map((s) => s.name);
+    const knownSections = /* @__PURE__ */ new Set(["thesis", "invariants", "state", "assumptions", "rules", "gates", "outcomes"]);
+    for (const section of sections) {
+      if (!knownSections.has(section.name.toLowerCase())) {
+        issues.push({
+          line: section.startLine,
+          section: section.name,
+          message: `Unrecognized section "${section.name}" \u2014 will be ignored`,
+          severity: "info"
+        });
+      }
+    }
+    const hasErrors = issues.some((i) => i.severity === "error");
+    if (!frontmatter.world_id || !thesis) {
+      if (hasErrors) {
+        return { world: null, issues };
+      }
+    }
+    return {
+      world: {
+        frontmatter,
+        thesis,
+        invariants,
+        stateVariables,
+        assumptions,
+        rules,
+        gates,
+        outcomes
+      },
+      issues
+    };
+  }
+
+  // src/engine/bootstrap-emitter.ts
+  var GATE_DEFAULTS = {
+    THRIVING: { color: "#0f6b3a", icon: "\u2726" },
+    STABLE: { color: "#1856b8", icon: "\u25CF" },
+    COMPRESSED: { color: "#a16207", icon: "\u25B2" },
+    CRITICAL: { color: "#b91c1c", icon: "\u26A0" },
+    MODEL_COLLAPSES: { color: "#7f1d1d", icon: "\u2715" }
+  };
+  function emitWorldDefinition(parsed) {
+    const issues = [];
+    const fm = parsed.frontmatter;
+    const defaultProfile = fm.default_profile ?? parsed.assumptions[0]?.id ?? "baseline";
+    const altProfile = fm.alternative_profile ?? parsed.assumptions[1]?.id ?? "alternative";
+    const world = {
+      world_id: fm.world_id,
+      name: fm.name,
+      thesis: parsed.thesis,
+      version: fm.version ?? "1.0.0",
+      runtime_mode: fm.runtime_mode ?? "SIMULATION",
+      default_assumption_profile: defaultProfile,
+      default_alternative_profile: altProfile,
+      modules: parsed.rules.map((r) => r.id),
+      players: {
+        thinking_space: true,
+        experience_space: true,
+        action_space: true
+      }
+    };
+    const invariants = parsed.invariants.map((inv) => ({
+      id: inv.id,
+      label: inv.label,
+      enforcement: inv.enforcement === "prompt" ? "prompt" : "structural",
+      mutable: false
+    }));
+    const profiles = {};
+    const parameterDefinitions = {};
+    for (let i = 0; i < parsed.assumptions.length; i++) {
+      const profile = parsed.assumptions[i];
+      const params = {};
+      for (const [key, val] of Object.entries(profile.parameters)) {
+        params[key] = String(val);
+        if (!parameterDefinitions[key]) {
+          parameterDefinitions[key] = {
+            type: typeof val === "boolean" ? "boolean" : typeof val === "number" ? "number" : "enum",
+            label: key.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+            description: `Parameter: ${key}`
+          };
+        }
+      }
+      profiles[profile.id] = {
+        name: profile.name,
+        description: profile.description,
+        is_default_baseline: i === 0 || profile.id === defaultProfile,
+        is_default_alternative: i === 1 || profile.id === altProfile,
+        parameters: params
+      };
+    }
+    const assumptions = { profiles, parameter_definitions: parameterDefinitions };
+    const variables = {};
+    for (const v of parsed.stateVariables) {
+      const stateVar = {
+        type: v.type,
+        default: v.default,
+        mutable: true,
+        label: v.label,
+        description: v.description
+      };
+      if (v.type === "number") {
+        if (v.min !== void 0) stateVar.min = v.min;
+        if (v.max !== void 0) stateVar.max = v.max;
+        if (v.step !== void 0) stateVar.step = v.step;
+      }
+      if (v.type === "enum" && v.options) {
+        stateVar.options = v.options;
+      }
+      variables[v.id] = stateVar;
+    }
+    const stateSchema = { variables, presets: {} };
+    const rules = parsed.rules.map((r) => {
+      const triggers = r.triggers.map((t) => ({
+        field: t.field,
+        operator: t.operator,
+        value: t.value,
+        source: t.source
+      }));
+      const effects = r.effects.map((e) => ({
+        target: e.target,
+        operation: e.operation,
+        value: e.value
+      }));
+      let collapse_check;
+      if (r.collapse_check) {
+        collapse_check = {
+          field: r.collapse_check.field,
+          operator: r.collapse_check.operator,
+          value: r.collapse_check.value,
+          result: "MODEL_COLLAPSES"
+        };
+      }
+      const causal_translation = r.causal_translation ?? {
+        trigger_text: "",
+        rule_text: "",
+        shift_text: "",
+        effect_text: ""
+      };
+      const rule = {
+        id: r.id,
+        severity: r.severity,
+        label: r.label,
+        description: r.description ?? r.label,
+        order: r.order,
+        triggers,
+        effects: effects.length > 0 ? effects : void 0,
+        collapse_check,
+        causal_translation
+      };
+      return rule;
+    });
+    const viabilityClassification = parsed.gates.map((g) => {
+      const defaults = GATE_DEFAULTS[g.status] ?? { color: "#5c5a52", icon: "\u25CF" };
+      return {
+        status: g.status,
+        field: g.field,
+        operator: g.operator,
+        value: g.value,
+        color: defaults.color,
+        icon: defaults.icon
+      };
+    });
+    const gates = {
+      viability_classification: viabilityClassification,
+      structural_override: {
+        description: "Rules with severity=structural and triggered collapse_check force MODEL_COLLAPSES regardless of final margin.",
+        enforcement: "mandatory"
+      },
+      sustainability_threshold: 0.1,
+      collapse_visual: {
+        background: "#1c1917",
+        text: "#fef2f2",
+        border: "#b91c1c",
+        label: "Structural Failure"
+      }
+    };
+    const computedOutcomes = parsed.outcomes.map((o) => {
+      const outcome = {
+        id: o.id,
+        type: o.type,
+        label: o.label,
+        show_in_comparison: true
+      };
+      if (o.range) outcome.range = o.range;
+      if (o.display) outcome.display_as = o.display;
+      if (o.primary) outcome.primary = o.primary;
+      if (o.assignment) outcome.assignment = o.assignment;
+      return outcome;
+    });
+    const outcomes = {
+      computed_outcomes: computedOutcomes,
+      comparison_layout: {
+        primary_card: computedOutcomes.find((o) => o.primary)?.id ?? computedOutcomes[0]?.id ?? "",
+        status_badge: "viability_status",
+        structural_indicators: rules.filter((r) => r.severity === "structural").map((r) => r.id)
+      }
+    };
+    const metadata = {
+      format_version: "1.0.0",
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      last_modified: (/* @__PURE__ */ new Date()).toISOString(),
+      authoring_method: "manual-authoring"
+    };
+    const worldDefinition = {
+      world,
+      invariants,
+      assumptions,
+      stateSchema,
+      rules,
+      gates,
+      outcomes,
+      metadata
+    };
+    return { world: worldDefinition, issues };
+  }
+
+  // src/browser.ts
+  function parseAndEmitWorld(markdown) {
+    const parseResult = parseWorldMarkdown(markdown);
+    if (!parseResult.world) {
+      throw new Error("Failed to parse world markdown");
+    }
+    const { world, issues } = emitWorldDefinition(parseResult.world);
+    for (const issue of issues) {
+      if (issue.severity === "error") {
+        console.warn(`[NeuroVerse] Parse issue: ${issue.message}`);
+      }
+    }
+    return world;
+  }
+  var NeuroVerse = {
+    simulateWorld,
+    parseWorldMarkdown: parseAndEmitWorld,
+    // Also expose raw pipeline for advanced use
+    _parseWorldMarkdownRaw: parseWorldMarkdown,
+    _emitWorldDefinition: emitWorldDefinition
+  };
+  globalThis.NeuroVerse = NeuroVerse;
+  return __toCommonJS(browser_exports);
+})();