@neuroverseos/governance 0.2.3 → 0.3.1

package/dist/chunk-FYS2CBUW.js

@@ -1,304 +0,0 @@
-// src/engine/simulate-engine.ts
-function simulateWorld(world, options = {}) {
-  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);
-  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";
-}
-function renderSimulateText(result) {
-  const lines = [];
-  lines.push(`SIMULATION: ${result.worldName}`);
-  lines.push(`Profile: ${result.profile}`);
-  lines.push(`Steps: ${result.steps.length}`);
-  lines.push("");
-  lines.push("INITIAL STATE");
-  for (const [key, value] of Object.entries(result.initialState)) {
-    lines.push(`  ${key}: ${value}`);
-  }
-  lines.push("");
-  for (const step of result.steps) {
-    lines.push(`STEP ${step.step}`);
-    const fired = step.rulesEvaluated.filter((r) => r.triggered);
-    const skipped = step.rulesEvaluated.filter((r) => !r.triggered && !r.excluded);
-    const excluded = step.rulesEvaluated.filter((r) => r.excluded);
-    if (fired.length === 0) {
-      lines.push("  No rules fired (state unchanged)");
-    } else {
-      for (const rule of fired) {
-        lines.push(`  FIRED: ${rule.label}`);
-        for (const effect of rule.effects) {
-          const beforeStr = formatValue(effect.before);
-          const afterStr = formatValue(effect.after);
-          lines.push(`    ${effect.target}: ${beforeStr} -> ${afterStr}`);
-        }
-        if (rule.collapsed) {
-          lines.push(`    COLLAPSE on ${rule.collapseField}`);
-        }
-      }
-    }
-    if (excluded.length > 0) {
-      lines.push(`  Excluded: ${excluded.map((r) => r.label).join(", ")}`);
-    }
-    lines.push(`  Viability: ${step.viability}`);
-    if (step.collapsed) {
-      lines.push("  ** MODEL COLLAPSED **");
-    }
-    lines.push("");
-  }
-  lines.push("FINAL STATE");
-  for (const [key, value] of Object.entries(result.finalState)) {
-    const initial = result.initialState[key];
-    const changed = initial !== value;
-    const marker = changed ? " (changed)" : "";
-    lines.push(`  ${key}: ${formatValue(value)}${marker}`);
-  }
-  lines.push("");
-  lines.push(`VIABILITY: ${result.finalViability}`);
-  if (result.collapsed) {
-    lines.push(`COLLAPSED at step ${result.collapseStep} (rule: ${result.collapseRule})`);
-  }
-  return lines.join("\n");
-}
-function formatValue(v) {
-  if (typeof v === "number") {
-    return Number.isInteger(v) ? String(v) : v.toFixed(2);
-  }
-  return String(v);
-}
-
-export {
-  simulateWorld,
-  renderSimulateText
-};

package/dist/chunk-I3RRAYK2.js

@@ -1,11 +0,0 @@
-// src/contracts/validate-contract.ts
-var VALIDATE_EXIT_CODES = {
-  PASS: 0,
-  FAIL: 1,
-  WARN: 2,
-  ERROR: 3
-};
-
-export {
-  VALIDATE_EXIT_CODES
-};