@neuroverseos/nv-sim 0.1.4 → 0.1.5

package/dist/engine/worldComparison.js

@@ -15,9 +15,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveWorld = resolveWorld;
 exports.runWorldComparison = runWorldComparison;
+exports.getAvailableWorlds = getAvailableWorlds;
+exports.explainWorldGovernance = explainWorldGovernance;
+exports.generateComparisonImpact = generateComparisonImpact;
 const scenarioCapsule_1 = require("./scenarioCapsule");
 const governedSimulation_1 = require("./governedSimulation");
+const worldStorage_1 = require("./worldStorage");
 function resolveWorld(presetId) {
+    // Check saved worlds first (browser localStorage)
+    const saved = resolveSavedWorld(presetId);
+    if (saved)
+        return saved;
     if (presetId === "trading" || presetId === "flash_crash") {
         return {
             id: "trading-flash-crash",
@@ -75,6 +83,63 @@ function resolveWorld(presetId) {
         ],
     };
 }
+/**
+ * Resolve a saved world (from localStorage) into a ResolvedWorld.
+ * Saved worlds get merged with the base preset's scenario/stakeholders
+ * so they work in the comparison engine.
+ */
+function resolveSavedWorld(id) {
+    try {
+        const saved = (0, worldStorage_1.loadWorldFromStorage)(id);
+        if (!saved)
+            return null;
+        // Try to get scenario context from the base preset
+        let baseScenario = `Simulation with custom world: ${saved.world.thesis}`;
+        let baseStakeholders = [
+            { id: "System", disposition: "neutral", priorities: ["stability"] },
+            { id: "Agents", disposition: "unknown", priorities: ["execution"] },
+        ];
+        let baseAssumptions = { severity: "high" };
+        let baseConstraints = {};
+        try {
+            const base = resolveWorld(saved.basePreset);
+            baseScenario = base.scenario;
+            baseStakeholders = base.stakeholders;
+            baseAssumptions = base.assumptions;
+            baseConstraints = base.constraints;
+        }
+        catch {
+            // Base preset not found — use defaults
+        }
+        return {
+            id: saved.id,
+            title: saved.name,
+            scenario: baseScenario,
+            stakeholders: baseStakeholders,
+            assumptions: baseAssumptions,
+            constraints: baseConstraints,
+            swarm: { enabled: true, rounds: 5, reaction_model: "mixed" },
+            depth: "full",
+            world: saved.world,
+            paths: [
+                {
+                    id: "path_primary",
+                    label: "Primary Response",
+                    description: "Most likely course of action",
+                    projected_outcome: "Moderate disruption with cascading effects",
+                    probability: 0.6,
+                    risk: "high",
+                    tradeoffs: ["Speed vs. thoroughness", "Short-term vs. long-term"],
+                    benefits_stakeholders: baseStakeholders.filter(s => s.disposition === "supportive").map(s => s.id),
+                    harms_stakeholders: baseStakeholders.filter(s => s.disposition === "hostile").map(s => s.id),
+                },
+            ],
+        };
+    }
+    catch {
+        return null;
+    }
+}
 async function runWorldComparison(worldAId, worldBId, options) {
     const worldADef = resolveWorld(worldAId);
     const worldBDef = resolveWorld(worldBId);
@@ -192,3 +257,102 @@ function buildWorldNarrative(worldA, worldB, metricsA, metricsB, moreStable) {
     parts.push("Same agents, different rules — the world shapes the outcome.");
     return parts.join(" ");
 }
+/**
+ * Get all available world presets for the comparison picker.
+ */
+function getAvailableWorlds() {
+    const worlds = [
+        {
+            id: "trading",
+            title: "Flash Crash — Algorithmic Cascade",
+            thesis: governedSimulation_1.TRADING_DEMO.world.thesis,
+            invariantCount: governedSimulation_1.TRADING_DEMO.world.invariants.length,
+            gateCount: (governedSimulation_1.TRADING_DEMO.world.gates ?? []).length,
+        },
+    ];
+    for (const [key, template] of Object.entries(scenarioCapsule_1.SCENARIO_TEMPLATES)) {
+        if (template.world?.inline_definition) {
+            worlds.push({
+                id: key,
+                title: template.title,
+                thesis: template.world.inline_definition.thesis,
+                invariantCount: template.world.inline_definition.invariants.length,
+                gateCount: (template.world.inline_definition.gates ?? []).length,
+            });
+        }
+    }
+    return worlds;
+}
+/**
+ * Generate a plain-English explanation of a world's governance posture.
+ * Uses the governance engine's own data — no LLM needed.
+ */
+function explainWorldGovernance(presetId) {
+    const world = resolveWorld(presetId);
+    const invariants = world.world.invariants;
+    const gates = world.world.gates ?? [];
+    const enforceableCount = invariants.filter(i => i.enforceable).length;
+    const advisoryCount = invariants.length - enforceableCount;
+    const invariantSummary = invariants.length === 0
+        ? "No invariants defined — ungoverned."
+        : `${invariants.length} rules (${enforceableCount} enforced, ${advisoryCount} advisory): ${invariants.map(i => i.description).join("; ")}`;
+    const criticalGates = gates.filter(g => g.severity === "critical");
+    const warningGates = gates.filter(g => g.severity === "warning");
+    const gateSummary = gates.length === 0
+        ? "No viability gates — no collapse detection."
+        : `${gates.length} gates (${criticalGates.length} critical, ${warningGates.length} warning): ${gates.map(g => `${g.label} [${g.severity}]`).join(", ")}`;
+    const riskProfile = criticalGates.length >= 2 ? "high"
+        : criticalGates.length >= 1 || warningGates.length >= 2 ? "moderate"
+            : "low";
+    return {
+        worldId: presetId,
+        title: world.title,
+        thesis: world.world.thesis,
+        invariantSummary,
+        gateSummary,
+        riskProfile,
+    };
+}
+/**
+ * Generate a counterfactual impact summary from comparison results.
+ * "What would have happened without these rules?"
+ *
+ * Powered by @neuroverseos/governance engine data.
+ */
+function generateComparisonImpact(result) {
+    const { worldA, worldB, delta } = result;
+    const winner = delta.moreStable;
+    const winnerSide = winner === "A" ? worldA : winner === "B" ? worldB : worldA;
+    const loserSide = winner === "A" ? worldB : winner === "B" ? worldA : worldB;
+    const interventionDiff = winnerSide.governanceStats.totalEvaluations - loserSide.governanceStats.totalEvaluations;
+    const blockDiff = winnerSide.governanceStats.verdicts.block - loserSide.governanceStats.verdicts.block;
+    const keyFindings = [];
+    if (Math.abs(delta.stabilityDiff) >= 5) {
+        keyFindings.push(`${Math.abs(delta.stabilityDiff).toFixed(0)}% stability ${delta.stabilityDiff > 0 ? "advantage for World A" : "advantage for World B"}`);
+    }
+    if (Math.abs(delta.collapseDiff) >= 5) {
+        keyFindings.push(`${Math.abs(delta.collapseDiff).toFixed(0)}% ${delta.collapseDiff > 0 ? "higher" : "lower"} cascade risk in World A`);
+    }
+    if (blockDiff !== 0) {
+        keyFindings.push(`${Math.abs(blockDiff)} more governance interventions in ${blockDiff > 0 ? "World A" : "World B"}`);
+    }
+    if (Math.abs(delta.volatilityDiff) >= 5) {
+        keyFindings.push(`${Math.abs(delta.volatilityDiff).toFixed(0)}% volatility ${delta.volatilityDiff > 0 ? "higher in A" : "higher in B"}`);
+    }
+    if (keyFindings.length === 0) {
+        keyFindings.push("Both worlds produced similar outcomes — rules had minimal differential effect.");
+    }
+    return {
+        winner,
+        stabilityDelta: `${delta.stabilityDiff > 0 ? "+" : ""}${delta.stabilityDiff.toFixed(1)}%`,
+        cascadeRiskDelta: `${delta.collapseDiff > 0 ? "+" : ""}${delta.collapseDiff.toFixed(1)}%`,
+        volatilityDelta: `${delta.volatilityDiff > 0 ? "+" : ""}${delta.volatilityDiff.toFixed(1)}%`,
+        totalInterventionsA: worldA.governanceStats.totalEvaluations,
+        totalInterventionsB: worldB.governanceStats.totalEvaluations,
+        blockedActionsA: worldA.governanceStats.verdicts.block,
+        blockedActionsB: worldB.governanceStats.verdicts.block,
+        keyFindings,
+        verdict: delta.narrative,
+        poweredBy: "@neuroverseos/governance — simulateWorld() + evaluateGuard()",
+    };
+}

package/dist/engine/worldStorage.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * World Storage — Decision Memory
+ *
+ * Save and load custom worlds as JSON. No cloud, no accounts.
+ * The world IS the data — portable, shareable, testable.
+ *
+ * Storage layers:
+ *   Browser: localStorage (for UI)
+ *   CLI: JSON files on disk (for dev workflows)
+ *
+ * A saved world captures:
+ *   - The base world it was built from (preset ID)
+ *   - Custom rules the user added
+ *   - Metadata (name, description, timestamp)
+ *
+ * This turns transient experiments into reusable decision artifacts.
+ *
+ * Powered by @neuroverseos/governance world format.
+ */
+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.saveWorldToStorage = saveWorldToStorage;
+exports.listWorldsFromStorage = listWorldsFromStorage;
+exports.loadWorldFromStorage = loadWorldFromStorage;
+exports.deleteWorldFromStorage = deleteWorldFromStorage;
+exports.exportWorldToJSON = exportWorldToJSON;
+exports.importWorldFromJSON = importWorldFromJSON;
+exports.createSavedWorld = createSavedWorld;
+exports.forkWorld = forkWorld;
+exports.saveWorldToFile = saveWorldToFile;
+exports.loadWorldFromFile = loadWorldFromFile;
+// ============================================
+// BROWSER STORAGE (localStorage)
+// ============================================
+const STORAGE_KEY = "nv-sim-saved-worlds";
+/**
+ * Runtime registry for worlds loaded from files (CLI context).
+ * Falls back to this when localStorage is unavailable.
+ */
+const runtimeRegistry = [];
+function hasLocalStorage() {
+    try {
+        return typeof localStorage !== "undefined" && localStorage !== null;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Save a world to browser localStorage (or runtime registry in CLI).
+ */
+function saveWorldToStorage(world) {
+    if (!hasLocalStorage()) {
+        const idx = runtimeRegistry.findIndex(w => w.id === world.id);
+        if (idx >= 0)
+            runtimeRegistry[idx] = world;
+        else
+            runtimeRegistry.push(world);
+        return;
+    }
+    const existing = listWorldsFromStorage();
+    const idx = existing.findIndex(w => w.id === world.id);
+    if (idx >= 0) {
+        existing[idx] = { ...world, modifiedAt: new Date().toISOString() };
+    }
+    else {
+        existing.push(world);
+    }
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(existing));
+}
+/**
+ * List all saved worlds from browser localStorage (or runtime registry).
+ */
+function listWorldsFromStorage() {
+    if (!hasLocalStorage()) {
+        return [...runtimeRegistry];
+    }
+    try {
+        const raw = localStorage.getItem(STORAGE_KEY);
+        if (!raw)
+            return [];
+        return JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Load a specific saved world by ID from localStorage (or runtime registry).
+ */
+function loadWorldFromStorage(id) {
+    const worlds = listWorldsFromStorage();
+    return worlds.find(w => w.id === id) ?? null;
+}
+/**
+ * Delete a saved world from localStorage (or runtime registry).
+ */
+function deleteWorldFromStorage(id) {
+    if (!hasLocalStorage()) {
+        const idx = runtimeRegistry.findIndex(w => w.id === id);
+        if (idx < 0)
+            return false;
+        runtimeRegistry.splice(idx, 1);
+        return true;
+    }
+    const worlds = listWorldsFromStorage();
+    const filtered = worlds.filter(w => w.id !== id);
+    if (filtered.length === worlds.length)
+        return false;
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(filtered));
+    return true;
+}
+// ============================================
+// JSON EXPORT / IMPORT
+// ============================================
+/**
+ * Export a saved world to a JSON string (for file download or CLI).
+ */
+function exportWorldToJSON(world) {
+    return JSON.stringify(world, null, 2);
+}
+/**
+ * Import a saved world from a JSON string.
+ * Validates the structure before returning.
+ */
+function importWorldFromJSON(json) {
+    const parsed = JSON.parse(json);
+    if (!parsed.version || !parsed.id || !parsed.name || !parsed.world) {
+        throw new Error("Invalid world format: missing required fields (version, id, name, world)");
+    }
+    if (!parsed.world.thesis || !Array.isArray(parsed.world.invariants)) {
+        throw new Error("Invalid world definition: missing thesis or invariants");
+    }
+    return parsed;
+}
+// ============================================
+// WORLD CREATION HELPERS
+// ============================================
+/**
+ * Create a new SavedWorld from a world definition.
+ */
+function createSavedWorld(name, world, basePreset, options) {
+    const id = `world_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const now = new Date().toISOString();
+    return {
+        version: "1.0",
+        id,
+        name,
+        description: options?.description,
+        basePreset,
+        world,
+        createdAt: now,
+        modifiedAt: now,
+        tags: options?.tags,
+    };
+}
+/**
+ * Fork an existing world with modifications.
+ */
+function forkWorld(source, name, modifications) {
+    const invariants = [
+        ...source.world.invariants.filter(i => !modifications.removeInvariantIds?.includes(i.id)),
+        ...(modifications.addInvariants ?? []),
+    ];
+    const gates = [
+        ...(source.world.gates ?? []).filter(g => !modifications.removeGateIds?.includes(g.id)),
+        ...(modifications.addGates ?? []),
+    ];
+    const world = {
+        ...source.world,
+        thesis: modifications.thesis ?? source.world.thesis,
+        invariants,
+        gates,
+    };
+    return createSavedWorld(name, world, source.id, {
+        description: `Forked from "${source.name}"`,
+        tags: [...(source.tags ?? []), "forked"],
+    });
+}
+// ============================================
+// FILE I/O (Node.js only — for CLI)
+// ============================================
+/**
+ * Save a world to a JSON file on disk.
+ * Only works in Node.js (CLI context).
+ */
+async function saveWorldToFile(world, filePath) {
+    const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+    fs.writeFileSync(filePath, exportWorldToJSON(world), "utf-8");
+}
+/**
+ * Load a world from a JSON file on disk.
+ * Only works in Node.js (CLI context).
+ */
+async function loadWorldFromFile(filePath) {
+    const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+    const content = fs.readFileSync(filePath, "utf-8");
+    return importWorldFromJSON(content);
+}

package/dist/index.html

@@ -14,8 +14,8 @@
     <meta name="twitter:title" content="NV-SIM — NeuroVerse Simulation">
     <meta name="twitter:description" content="Governed agent simulation — compare emergent outcomes with and without governance constraints.">
     <link rel="icon" type="image/x-icon" href="/favicon.ico">
-    <script type="module" crossorigin src="/assets/index-DHKd4rcV.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-SyyA3z3U.css">
+    <script type="module" crossorigin src="/assets/index-DbzSnYxr.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-B64NuIXu.css">
   </head>
   <body>
     <div id="root"></div>