@neuroverseos/nv-sim 0.1.0

package/dist/engine/worldBridge.js

@@ -0,0 +1,481 @@
+"use strict";
+/**
+ * World Bridge — Converts between Echelon scenario types and NeuroverseOS WorldDefinition
+ *
+ * NeuroverseOS/Neuroverseos-governance (Apache 2.0) provides:
+ *   - WorldDefinition: the full reasoning model (state, rules, gates, guards, roles, kernel)
+ *   - evaluateGuard(): deterministic governance evaluation
+ *   - simulateWorld(): deterministic state evolution through rules
+ *   - validateWorld(): static analysis of world health
+ *
+ * This bridge:
+ *   1. Builds WorldDefinition from scenario capsules (for inline evaluation)
+ *   2. Converts NeuroverseOS simulation results into Echelon swarm format
+ *   3. Maps NeuroverseOS guard verdicts into Echelon governance traces
+ *
+ * IMPORTANT: NeuroverseOS uses dynamic imports to avoid pulling Node.js APIs
+ * (fs, path, os) into the browser bundle. The pure governance functions
+ * (evaluateGuard, simulateWorld, validateWorld) don't need fs — but the
+ * package bundles everything. Dynamic import solves this cleanly.
+ *
+ * The relationship:
+ *   NeuroverseOS provides deterministic rails (what CAN'T happen)
+ *   Echelon provides LLM reasoning within those rails (what SHOULD happen)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initNeuroverseModule = initNeuroverseModule;
+exports.buildWorldFromScenario = buildWorldFromScenario;
+exports.evaluateScenarioGuard = evaluateScenarioGuard;
+exports.runWorldSimulation = runWorldSimulation;
+exports.validateScenarioWorld = validateScenarioWorld;
+exports.verdictToConstitutionalChecks = verdictToConstitutionalChecks;
+exports.simulationToGovernanceSignals = simulationToGovernanceSignals;
+exports.validationToEnforcedConstraints = validationToEnforcedConstraints;
+// ============================================
+// LAZY MODULE LOADER
+// ============================================
+/**
+ * Lazy-load @neuroverseos/governance at runtime.
+ * Returns null in browser environments where Node modules aren't available.
+ */
+let _nvModule;
+async function getNVModule() {
+    if (_nvModule !== undefined)
+        return _nvModule;
+    try {
+        const mod = await Promise.resolve().then(() => __importStar(require("@neuroverseos/governance")));
+        _nvModule = {
+            evaluateGuard: mod.evaluateGuard,
+            simulateWorld: mod.simulateWorld,
+            validateWorld: mod.validateWorld,
+        };
+        return _nvModule;
+    }
+    catch {
+        _nvModule = null;
+        return null;
+    }
+}
+/**
+ * Synchronous access to NeuroverseOS module.
+ * Must call initNeuroverseModule() first (or it returns null).
+ */
+function getNVModuleSync() {
+    return _nvModule ?? null;
+}
+/**
+ * Initialize NeuroverseOS module. Call once at startup.
+ */
+async function initNeuroverseModule() {
+    const mod = await getNVModule();
+    return mod !== null;
+}
+// ============================================
+// WORLD BUILDER — Scenario → WorldDefinition
+// ============================================
+/**
+ * Build a minimal NeuroverseOS WorldDefinition from an Echelon scenario.
+ */
+function buildWorldFromScenario(request, worldLite) {
+    const scenarioId = request.scenario.slice(0, 40).replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
+    const stateVariables = {};
+    if (request.assumptions?.severity) {
+        stateVariables["severity"] = {
+            type: "enum",
+            options: ["low", "moderate", "high", "critical"],
+            default: request.assumptions.severity,
+            mutable: true,
+            label: "Severity",
+            description: "Severity of the situation",
+        };
+    }
+    if (request.assumptions?.environmental_hostility) {
+        stateVariables["environmental_hostility"] = {
+            type: "enum",
+            options: ["low", "moderate", "high"],
+            default: request.assumptions.environmental_hostility,
+            mutable: true,
+            label: "Environmental Hostility",
+            description: "External environment hostility",
+        };
+    }
+    if (request.assumptions?.time_pressure) {
+        stateVariables["time_pressure"] = {
+            type: "enum",
+            options: ["none", "low", "moderate", "urgent", "immediate"],
+            default: request.assumptions.time_pressure,
+            mutable: true,
+            label: "Time Pressure",
+            description: "Time pressure on decision",
+        };
+    }
+    if (request.assumptions?.regulatory_climate) {
+        stateVariables["regulatory_climate"] = {
+            type: "enum",
+            options: ["permissive", "neutral", "strict", "adversarial"],
+            default: request.assumptions.regulatory_climate,
+            mutable: true,
+            label: "Regulatory Climate",
+            description: "Regulatory environment",
+        };
+    }
+    if (worldLite?.state_variables) {
+        for (const sv of worldLite.state_variables) {
+            stateVariables[sv.id] = {
+                type: sv.type,
+                options: sv.enum_values ? [...sv.enum_values] : undefined,
+                min: sv.range?.min,
+                max: sv.range?.max,
+                default: sv.default_value,
+                mutable: true,
+                label: sv.label,
+                description: sv.label,
+            };
+        }
+    }
+    const invariants = (worldLite?.invariants ?? []).map((inv) => ({
+        id: inv.id,
+        label: inv.description,
+        enforcement: (inv.enforceable ? "structural" : "prompt"),
+        mutable: false,
+    }));
+    const viabilityClassification = (worldLite?.gates ?? []).map((gate) => ({
+        status: mapGateSeverityToViability(gate.severity),
+        field: gate.id,
+        operator: "==",
+        value: 1,
+        color: gate.severity === "critical" ? "#ef4444" : gate.severity === "warning" ? "#f59e0b" : "#22c55e",
+        icon: gate.severity === "critical" ? "alert-triangle" : gate.severity === "warning" ? "alert-circle" : "info",
+    }));
+    return {
+        world: {
+            world_id: `echelon_${scenarioId}`,
+            name: request.scenario.slice(0, 60),
+            thesis: worldLite?.thesis ?? `Reasoning world for: ${request.scenario.slice(0, 100)}`,
+            version: "1.0.0",
+            runtime_mode: "SIMULATION",
+            default_assumption_profile: "baseline",
+            default_alternative_profile: "stressed",
+            modules: [],
+            players: {
+                thinking_space: true,
+                experience_space: false,
+                action_space: false,
+            },
+        },
+        invariants,
+        assumptions: {
+            profiles: {
+                baseline: {
+                    name: "Baseline",
+                    description: "Default assumptions from the scenario",
+                    is_default_baseline: true,
+                    parameters: buildAssumptionParameters(request),
+                },
+                stressed: {
+                    name: "Stressed",
+                    description: "Worst-case assumption profile",
+                    is_default_alternative: true,
+                    parameters: buildStressedParameters(),
+                },
+            },
+            parameter_definitions: {},
+        },
+        stateSchema: {
+            variables: stateVariables,
+            presets: {},
+        },
+        rules: [],
+        gates: {
+            viability_classification: viabilityClassification.length > 0
+                ? viabilityClassification
+                : [{
+                        status: "STABLE",
+                        field: "severity",
+                        operator: "==",
+                        value: 1,
+                        color: "#22c55e",
+                        icon: "check-circle",
+                    }],
+            structural_override: {
+                description: "Echelon governance enforcement",
+                enforcement: "mandatory",
+            },
+            sustainability_threshold: 30,
+            collapse_visual: {
+                background: "#1a0000",
+                text: "#ef4444",
+                border: "#7f1d1d",
+                label: "SCENARIO COLLAPSES",
+            },
+        },
+        outcomes: {
+            computed_outcomes: [],
+            comparison_layout: {
+                primary_card: "viability",
+                status_badge: "severity",
+                structural_indicators: [],
+            },
+        },
+        metadata: {
+            format_version: "1.0",
+            created_at: new Date().toISOString(),
+            last_modified: new Date().toISOString(),
+            authoring_method: "manual-authoring",
+        },
+    };
+}
+function mapGateSeverityToViability(severity) {
+    switch (severity) {
+        case "info": return "STABLE";
+        case "warning": return "COMPRESSED";
+        case "critical": return "CRITICAL";
+    }
+}
+function buildAssumptionParameters(request) {
+    const params = {};
+    if (request.assumptions?.severity)
+        params["severity"] = request.assumptions.severity;
+    if (request.assumptions?.environmental_hostility)
+        params["environmental_hostility"] = request.assumptions.environmental_hostility;
+    if (request.assumptions?.time_pressure)
+        params["time_pressure"] = request.assumptions.time_pressure;
+    if (request.assumptions?.regulatory_climate)
+        params["regulatory_climate"] = request.assumptions.regulatory_climate;
+    return params;
+}
+function buildStressedParameters() {
+    return {
+        severity: "critical",
+        environmental_hostility: "high",
+        time_pressure: "immediate",
+        regulatory_climate: "adversarial",
+    };
+}
+// ============================================
+// GUARD EVALUATION — Scenario → GuardVerdict
+// ============================================
+/**
+ * Run NeuroverseOS guard evaluation on a reason request.
+ * Falls back to ALLOW verdict if NeuroverseOS is not available (browser).
+ */
+function evaluateScenarioGuard(request, world, options) {
+    const nv = getNVModuleSync();
+    if (!nv) {
+        // NeuroverseOS not available — return permissive verdict
+        return {
+            status: "ALLOW",
+            reason: "NeuroverseOS guard not loaded — permissive fallback",
+        };
+    }
+    const event = {
+        intent: request.scenario,
+        tool: "reason",
+        scope: "echelon-reasoning",
+        actionCategory: "read",
+        direction: "input",
+        args: {
+            depth: request.depth ?? "standard",
+            mode: request.mode ?? "explore",
+            stakeholder_count: request.stakeholders?.length ?? 0,
+            has_goal: !!request.goal,
+        },
+    };
+    return nv.evaluateGuard(event, world, {
+        trace: options?.trace ?? true,
+        level: options?.level ?? "standard",
+    });
+}
+// ============================================
+// SIMULATION — World state evolution
+// ============================================
+/**
+ * Run NeuroverseOS deterministic simulation.
+ * Falls back to empty result if NeuroverseOS is not available.
+ */
+function runWorldSimulation(world, options) {
+    const nv = getNVModuleSync();
+    if (!nv) {
+        return {
+            worldId: world.world.world_id,
+            worldName: world.world.name,
+            profile: "baseline",
+            initialState: {},
+            steps: [],
+            finalState: {},
+            finalViability: "STABLE",
+            collapsed: false,
+        };
+    }
+    return nv.simulateWorld(world, {
+        steps: options?.steps ?? 5,
+        stateOverrides: options?.stateOverrides,
+        profile: options?.profile,
+    });
+}
+// ============================================
+// VALIDATION — World health check
+// ============================================
+/**
+ * Validate a NeuroverseOS world definition.
+ * Falls back to a healthy report if NeuroverseOS is not available.
+ */
+function validateScenarioWorld(world, mode) {
+    const nv = getNVModuleSync();
+    if (!nv) {
+        return {
+            worldId: world.world.world_id,
+            worldName: world.world.name,
+            worldVersion: world.world.version,
+            validatedAt: Date.now(),
+            durationMs: 0,
+            summary: {
+                errors: 0,
+                warnings: 0,
+                info: 0,
+                completenessScore: 100,
+                invariantCoverage: 100,
+                canRun: true,
+                isHealthy: true,
+            },
+            validationMode: mode ?? "standard",
+            findings: [],
+        };
+    }
+    return nv.validateWorld(world, mode);
+}
+// ============================================
+// VERDICT → GOVERNANCE TRACE MAPPING
+// ============================================
+/**
+ * Convert NeuroverseOS guard verdicts into Echelon ConstitutionalCheck format.
+ */
+function verdictToConstitutionalChecks(verdict) {
+    const checks = [];
+    checks.push({
+        rule_id: verdict.ruleId ?? "NV-GUARD",
+        rule: `NeuroverseOS guard evaluation: ${verdict.status}`,
+        passed: verdict.status === "ALLOW",
+        detail: verdict.reason ?? "Guard evaluation completed",
+    });
+    if (verdict.evidence) {
+        const evidence = verdict.evidence;
+        if (evidence.safetyChecks) {
+            for (const sc of evidence.safetyChecks) {
+                checks.push({
+                    rule_id: `NV-SAFETY-${sc.check}`,
+                    rule: `Safety: ${sc.check}`,
+                    passed: !sc.triggered,
+                    detail: sc.triggered ? `Triggered: ${sc.evidence ?? "pattern match"}` : "Passed",
+                });
+            }
+        }
+        if (evidence.guardChecks) {
+            for (const gc of evidence.guardChecks) {
+                checks.push({
+                    rule_id: `NV-GUARD-${gc.guardId}`,
+                    rule: gc.label ?? `Guard ${gc.guardId}`,
+                    passed: !gc.triggered,
+                    detail: gc.triggered ? `Triggered: ${gc.enforcement ?? "block"}` : "Passed",
+                });
+            }
+        }
+        if (evidence.invariantChecks) {
+            for (const ic of evidence.invariantChecks) {
+                checks.push({
+                    rule_id: `NV-INV-${ic.invariantId}`,
+                    rule: ic.label ?? `Invariant ${ic.invariantId}`,
+                    passed: ic.satisfied,
+                    detail: ic.satisfied ? "Satisfied" : "Violated",
+                });
+            }
+        }
+        if (evidence.kernelCheck) {
+            const kc = evidence.kernelCheck;
+            checks.push({
+                rule_id: "NV-KERNEL",
+                rule: "Kernel boundary enforcement",
+                passed: !kc.triggered,
+                detail: kc.triggered ? `Kernel violation: ${kc.patternId ?? "forbidden pattern"}` : "Passed",
+            });
+        }
+    }
+    return checks;
+}
+/**
+ * Convert NeuroverseOS simulation result into governance-relevant signals.
+ */
+function simulationToGovernanceSignals(sim) {
+    const totalRulesFired = sim.steps.reduce((sum, s) => sum + s.rulesFired, 0);
+    let collapseRisk = "none";
+    if (sim.collapsed) {
+        collapseRisk = "high";
+    }
+    else if (sim.finalViability === "CRITICAL") {
+        collapseRisk = "high";
+    }
+    else if (sim.finalViability === "COMPRESSED") {
+        collapseRisk = "moderate";
+    }
+    else if (totalRulesFired > sim.steps.length * 3) {
+        collapseRisk = "low";
+    }
+    return {
+        viability: sim.finalViability,
+        collapsed: sim.collapsed,
+        rulesFired: totalRulesFired,
+        collapseRisk,
+        stateTrajectory: sim.steps.map((s) => s.stateAfter),
+    };
+}
+/**
+ * Convert NeuroverseOS validate report into governance enforced constraints.
+ */
+function validationToEnforcedConstraints(report) {
+    const constraints = [];
+    constraints.push(`WORLD_HEALTH: ${report.summary.isHealthy ? "HEALTHY" : "DEGRADED"} (${report.summary.completenessScore}% complete)`);
+    if (report.summary.invariantCoverage < 100) {
+        constraints.push(`INVARIANT_COVERAGE: ${report.summary.invariantCoverage}% — ${100 - report.summary.invariantCoverage}% of invariants lack guard backing`);
+    }
+    if (report.summary.governanceHealth) {
+        const gh = report.summary.governanceHealth;
+        constraints.push(`GOVERNANCE_RISK: ${gh.riskLevel} (${gh.surfacesCovered}/${gh.surfacesTotal} surfaces governed)`);
+    }
+    if (report.summary.errors > 0) {
+        constraints.push(`WORLD_ERRORS: ${report.summary.errors} structural issues detected`);
+    }
+    return constraints;
+}

package/dist/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "@neuroverseos/nv-sim",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "Apache-2.0",
+  "files": [
+  "dist",
+  "README.md",
+  "LICENSE"
+],
+
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NeuroverseOS/neuroverse-simulations"
+  },
+  "homepage": "https://github.com/NeuroverseOS/neuroverse-simulations",
+  "bugs": {
+    "url": "https://github.com/NeuroverseOS/neuroverse-simulations/issues"
+  },
+  "bin": {
+    "nv-sim": "dist/engine/cli.js"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "build:cli": "tsc -p tsconfig.cli.json && echo '{\"type\":\"commonjs\"}' > dist/package.json",
+    "build:dev": "vite build --mode development",
+    "build:all": "vite build && tsc -p tsconfig.cli.json",
+    "lint": "eslint .",
+    "preview": "vite preview",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@hookform/resolvers": "^3.10.0",
+    "@neuroverseos/governance": "^0.3.0",
+    "@radix-ui/react-accordion": "^1.2.11",
+    "@radix-ui/react-alert-dialog": "^1.1.14",
+    "@radix-ui/react-aspect-ratio": "^1.1.7",
+    "@radix-ui/react-avatar": "^1.1.10",
+    "@radix-ui/react-checkbox": "^1.3.2",
+    "@radix-ui/react-collapsible": "^1.1.11",
+    "@radix-ui/react-context-menu": "^2.2.15",
+    "@radix-ui/react-dialog": "^1.1.14",
+    "@radix-ui/react-dropdown-menu": "^2.1.15",
+    "@radix-ui/react-hover-card": "^1.1.14",
+    "@radix-ui/react-label": "^2.1.7",
+    "@radix-ui/react-menubar": "^1.1.15",
+    "@radix-ui/react-navigation-menu": "^1.2.13",
+    "@radix-ui/react-popover": "^1.1.14",
+    "@radix-ui/react-progress": "^1.1.7",
+    "@radix-ui/react-radio-group": "^1.3.7",
+    "@radix-ui/react-scroll-area": "^1.2.9",
+    "@radix-ui/react-select": "^2.2.5",
+    "@radix-ui/react-separator": "^1.1.7",
+    "@radix-ui/react-slider": "^1.3.5",
+    "@radix-ui/react-slot": "^1.2.3",
+    "@radix-ui/react-switch": "^1.2.5",
+    "@radix-ui/react-tabs": "^1.1.12",
+    "@radix-ui/react-toast": "^1.2.14",
+    "@radix-ui/react-toggle": "^1.1.9",
+    "@radix-ui/react-toggle-group": "^1.1.10",
+    "@radix-ui/react-tooltip": "^1.2.7",
+    "@tanstack/react-query": "^5.83.0",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cmdk": "^1.1.1",
+    "date-fns": "^3.6.0",
+    "embla-carousel-react": "^8.6.0",
+    "input-otp": "^1.4.2",
+    "lucide-react": "^0.462.0",
+    "next-themes": "^0.3.0",
+    "react": "^18.3.1",
+    "react-day-picker": "^8.10.1",
+    "react-dom": "^18.3.1",
+    "react-hook-form": "^7.61.1",
+    "react-resizable-panels": "^2.1.9",
+    "react-router-dom": "^6.30.1",
+    "recharts": "^2.15.4",
+    "sonner": "^1.7.4",
+    "tailwind-merge": "^2.6.0",
+    "tailwindcss-animate": "^1.0.7",
+    "vaul": "^0.9.9",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.32.0",
+    "@playwright/test": "^1.57.0",
+    "@tailwindcss/typography": "^0.5.16",
+    "@testing-library/jest-dom": "^6.6.0",
+    "@testing-library/react": "^16.0.0",
+    "@types/node": "^22.16.5",
+    "@types/react": "^18.3.23",
+    "@types/react-dom": "^18.3.7",
+    "@vitejs/plugin-react-swc": "^3.11.0",
+    "autoprefixer": "^10.4.21",
+    "eslint": "^9.32.0",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-refresh": "^0.4.20",
+    "globals": "^15.15.0",
+    "jsdom": "^20.0.3",
+    "lovable-tagger": "^1.1.13",
+    "postcss": "^8.5.6",
+    "tailwindcss": "^3.4.17",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.38.0",
+    "vite": "^5.4.19",
+    "vitest": "^3.2.4"
+  }
+}