@neuroverseos/nv-sim 0.1.4 → 0.1.5

package/dist/runtime/govern.js

@@ -0,0 +1,473 @@
+"use strict";
+/**
+ * NeuroVerse Governance Runtime — Core Engine
+ *
+ * The ONE function that makes NeuroVerse real:
+ *
+ *   agent decides → govern() evaluates → action proceeds (or doesn't)
+ *
+ * This is NOT a simulator. This is a governance layer that sits
+ * between agent decisions and execution in ANY agent system.
+ *
+ * Usage:
+ *   import { govern, createGovernor } from "@neuroverseos/runtime"
+ *
+ *   // One-shot:
+ *   const verdict = govern(action, worldState, "Block large trades during volatility")
+ *
+ *   // Reusable governor:
+ *   const gov = createGovernor({ policyText: myPolicy })
+ *   const verdict = gov.evaluate(action)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXAMPLE_WORLD_STATES = exports.EXAMPLE_ACTIONS = void 0;
+exports.govern = govern;
+exports.createGovernor = createGovernor;
+const policyEngine_1 = require("../engine/policyEngine");
+// ============================================
+// CORE: govern() — evaluate a single action
+// ============================================
+/**
+ * Evaluate a single agent action against a policy.
+ *
+ * This is the simplest way to use NeuroVerse governance.
+ * For repeated evaluations, use createGovernor() instead.
+ *
+ * @example
+ * const verdict = govern(
+ *   { agentId: "fund-A", type: "trade", description: "Sell $15M in equities", magnitude: 0.8 },
+ *   { volatility: 85, liquidity: 12 },
+ *   "Block all large trades during extreme volatility\nHalt trading when volatility exceeds 80"
+ * )
+ *
+ * if (verdict.status === "ALLOW") execute(verdict.action)
+ */
+function govern(action, worldState, policyText) {
+    const governor = createGovernor({ policyText, worldState });
+    return governor.evaluate(action, worldState);
+}
+// ============================================
+// FACTORY: createGovernor() — reusable instance
+// ============================================
+/**
+ * Create a reusable governor instance.
+ *
+ * Parse the policy once, evaluate many actions.
+ * This is the recommended way to use NeuroVerse in a simulation loop.
+ *
+ * @example
+ * const gov = createGovernor({ policyText: myPolicy })
+ *
+ * for (const agent of agents) {
+ *   const action = agent.decide()
+ *   const verdict = gov.evaluate(action, currentWorldState)
+ *   if (verdict.action) execute(verdict.action)
+ * }
+ *
+ * console.log(gov.stats) // { totalEvaluations: 50, blocked: 12, ... }
+ */
+function createGovernor(config) {
+    let parsed = (0, policyEngine_1.parseRulesFromText)(config.policyText);
+    let health = (0, policyEngine_1.validatePolicy)(parsed);
+    let world = (0, policyEngine_1.policyToWorld)(parsed);
+    const sensitivity = config.sensitivity ?? 0.5;
+    const audit = config.auditTrail ?? null;
+    // Running stats
+    const stats = {
+        totalEvaluations: 0,
+        allowed: 0,
+        blocked: 0,
+        modified: 0,
+        paused: 0,
+        rulesFired: 0,
+    };
+    function evaluate(action, worldState) {
+        stats.totalEvaluations++;
+        const rulesFired = [];
+        let currentMagnitude = action.magnitude;
+        let wasModified = false;
+        // --- Evaluate action against each invariant ---
+        for (const inv of world.invariants) {
+            if (!inv.enforceable) {
+                // Advisory: log but don't block
+                rulesFired.push({
+                    id: inv.id,
+                    description: inv.description,
+                    effect: "monitored",
+                    impactReduction: 0,
+                });
+                continue;
+            }
+            const result = evaluateInvariant(inv, action, currentMagnitude, worldState, sensitivity);
+            if (result) {
+                rulesFired.push(result);
+                currentMagnitude = action.magnitude * (1 - result.impactReduction);
+                wasModified = true;
+            }
+        }
+        // --- Evaluate action against gates ---
+        for (const gate of world.gates ?? []) {
+            const result = evaluateGate(gate, action, currentMagnitude, worldState);
+            if (result) {
+                rulesFired.push(result);
+                currentMagnitude = currentMagnitude * (1 - result.impactReduction);
+                wasModified = true;
+            }
+        }
+        // --- Determine final verdict ---
+        stats.rulesFired += rulesFired.filter((r) => r.effect !== "monitored").length;
+        const totalReduction = 1 - (currentMagnitude / Math.max(action.magnitude, 0.001));
+        let status;
+        let reason;
+        let outputAction;
+        if (totalReduction > 0.85) {
+            // Action is essentially killed
+            status = "BLOCK";
+            reason = buildReason("blocked", action, rulesFired);
+            outputAction = null;
+            stats.blocked++;
+        }
+        else if (totalReduction > 0.5) {
+            // Action is significantly reduced — pause for review
+            status = "PAUSE";
+            reason = buildReason("paused", action, rulesFired);
+            outputAction = { ...action, magnitude: Number(currentMagnitude.toFixed(3)) };
+            stats.paused++;
+        }
+        else if (wasModified && totalReduction > 0.05) {
+            // Action was modified but still largely allowed
+            status = "MODIFY";
+            reason = buildReason("modified", action, rulesFired);
+            outputAction = { ...action, magnitude: Number(currentMagnitude.toFixed(3)) };
+            stats.modified++;
+        }
+        else {
+            // Clean pass
+            status = "ALLOW";
+            reason = rulesFired.length > 0
+                ? `Allowed — ${rulesFired.filter((r) => r.effect === "monitored").length} advisory rule(s) noted`
+                : "Allowed — no rules apply to this action";
+            outputAction = action;
+            stats.allowed++;
+        }
+        const verdict = {
+            status,
+            action: outputAction,
+            reason,
+            rulesFired,
+            confidence: computeConfidence(rulesFired, totalReduction),
+            timestamp: Date.now(),
+        };
+        // Persist to audit trail if configured
+        if (audit) {
+            audit.logVerdict({
+                agent: action.agentId,
+                action: action.description,
+                actionType: action.type,
+                verdict: status === "MODIFY" ? "MODIFY" : status,
+                reason,
+                confidence: verdict.confidence,
+                rulesFired: rulesFired.map((r) => ({
+                    id: r.id,
+                    description: r.description,
+                    effect: r.effect,
+                    impactReduction: r.impactReduction,
+                })),
+            });
+        }
+        return verdict;
+    }
+    function evaluateBatch(actions, worldState) {
+        return actions.map((a) => evaluate(a, worldState));
+    }
+    function updatePolicy(policyText) {
+        parsed = (0, policyEngine_1.parseRulesFromText)(policyText);
+        health = (0, policyEngine_1.validatePolicy)(parsed);
+        world = (0, policyEngine_1.policyToWorld)(parsed);
+    }
+    return {
+        evaluate,
+        evaluateBatch,
+        updatePolicy,
+        get policy() {
+            return {
+                ruleCount: parsed.summary.total,
+                enforcedCount: parsed.summary.enforced,
+                advisoryCount: parsed.summary.advisory,
+                healthScore: health.healthScore,
+            };
+        },
+        get stats() {
+            return { ...stats };
+        },
+    };
+}
+// ============================================
+// INVARIANT EVALUATION (single rule vs action)
+// ============================================
+function evaluateInvariant(inv, action, currentMagnitude, worldState, sensitivity) {
+    const desc = inv.description.toLowerCase();
+    const actionDesc = action.description.toLowerCase();
+    const actionType = action.type.toLowerCase();
+    // Sensitivity adjusts thresholds: 0 = lenient, 1 = strict
+    const threshold = 0.6 - sensitivity * 0.3; // Range: 0.3 (strict) to 0.6 (lenient)
+    // --- BLOCK/PROHIBIT patterns ---
+    if (matchesPattern(desc, ["block", "prohibit", "prevent", "forbid", "ban", "stop", "halt"])) {
+        const actionTerms = extractActionTerms(desc, ["block", "prohibit", "prevent", "forbid", "ban", "stop", "halt"]);
+        const matches = actionTerms.some((term) => actionDesc.includes(term) || actionType.includes(term));
+        const isExtreme = action.magnitude > threshold;
+        if (matches || isExtreme) {
+            return {
+                id: inv.id,
+                description: inv.description,
+                effect: "blocked",
+                impactReduction: 0.85 + sensitivity * 0.1, // 85–95% reduction
+            };
+        }
+    }
+    // --- CIRCUIT BREAKER / PANIC patterns ---
+    if (matchesPattern(desc, ["panic", "cascade", "contagion", "crash", "circuit", "emergency", "runaway"])) {
+        // Check if world state indicates crisis conditions
+        const inCrisis = worldState
+            ? isWorldInCrisis(worldState)
+            : action.magnitude > 0.6;
+        if (inCrisis && action.magnitude > threshold * 0.8) {
+            return {
+                id: inv.id,
+                description: inv.description,
+                effect: "blocked",
+                impactReduction: 0.7 + sensitivity * 0.2, // 70–90% reduction
+            };
+        }
+    }
+    // --- SLOW/DAMPEN patterns ---
+    if (matchesPattern(desc, ["slow", "cool", "gradual", "dampen", "reduce volatility", "moderate"])) {
+        if (action.magnitude > threshold) {
+            return {
+                id: inv.id,
+                description: inv.description,
+                effect: "dampened",
+                impactReduction: 0.35 + sensitivity * 0.15, // 35–50% reduction
+            };
+        }
+    }
+    // --- FLOOR/MINIMUM patterns ---
+    if (matchesPattern(desc, ["floor", "maintain", "minimum", "at least", "no less"])) {
+        // Check if action would violate a floor
+        const wouldViolateFloor = action.magnitude > 0.4 && actionMatchesVariable(desc, actionDesc);
+        if (wouldViolateFloor) {
+            return {
+                id: inv.id,
+                description: inv.description,
+                effect: "capped",
+                impactReduction: Math.min(0.5, action.magnitude - 0.3), // Cap to safe level
+            };
+        }
+    }
+    // --- LIMIT/CAP/LEVERAGE patterns ---
+    if (matchesPattern(desc, ["leverage", "limit", "cap", "restrict", "maximum", "no more", "ceiling"])) {
+        if (action.magnitude > threshold + 0.1) {
+            return {
+                id: inv.id,
+                description: inv.description,
+                effect: "capped",
+                impactReduction: Math.min(0.4, action.magnitude - threshold), // Reduce excess above threshold
+            };
+        }
+    }
+    // --- REBALANCE/EQUILIBRIUM patterns ---
+    if (matchesPattern(desc, ["rebalance", "equilibrium", "balance", "correlat", "diversif"])) {
+        if (action.magnitude > 0.5) {
+            return {
+                id: inv.id,
+                description: inv.description,
+                effect: "rebalanced",
+                impactReduction: 0.3 * sensitivity, // Gentle pull toward center
+            };
+        }
+    }
+    // --- TRANSPARENCY/REPORTING patterns ---
+    if (matchesPattern(desc, ["transparency", "report", "monitor", "audit", "disclose", "accountab"])) {
+        // Transparency rules don't block — they just observe
+        if (action.magnitude > 0.3) {
+            return {
+                id: inv.id,
+                description: inv.description,
+                effect: "monitored",
+                impactReduction: 0, // No reduction, just logging
+            };
+        }
+    }
+    return null;
+}
+// ============================================
+// GATE EVALUATION (threshold checks)
+// ============================================
+function evaluateGate(gate, action, currentMagnitude, worldState) {
+    if (gate.severity === "critical") {
+        // Critical gates act as hard circuit breakers
+        const inDanger = worldState
+            ? isWorldInCrisis(worldState)
+            : currentMagnitude > 0.5;
+        if (inDanger && action.magnitude > 0.3) {
+            return {
+                id: gate.id,
+                description: gate.label,
+                effect: "blocked",
+                impactReduction: 0.4, // Flatten all actions during crisis
+            };
+        }
+    }
+    if (gate.severity === "warning") {
+        // Warning gates add caution
+        if (action.magnitude > 0.5) {
+            return {
+                id: gate.id,
+                description: gate.label,
+                effect: "dampened",
+                impactReduction: 0.2, // Mild reduction
+            };
+        }
+    }
+    return null;
+}
+// ============================================
+// HELPERS
+// ============================================
+function matchesPattern(text, patterns) {
+    return patterns.some((p) => text.includes(p));
+}
+function extractActionTerms(ruleDesc, removePatterns) {
+    let cleaned = ruleDesc;
+    for (const p of removePatterns) {
+        cleaned = cleaned.replace(new RegExp(`\\b${p}\\b`, "g"), "");
+    }
+    return cleaned
+        .split(/\s+/)
+        .filter((t) => t.length > 2)
+        .map((t) => t.replace(/[^a-z]/g, ""))
+        .filter((t) => t.length > 2);
+}
+function actionMatchesVariable(ruleDesc, actionDesc) {
+    const ruleTerms = ruleDesc.split(/\s+/).filter((t) => t.length > 3);
+    return ruleTerms.some((t) => actionDesc.includes(t));
+}
+function isWorldInCrisis(ws) {
+    const vol = ws["volatility"] ?? ws["volatility_index"];
+    const liq = ws["liquidity"] ?? ws["liquidity_index"];
+    if (typeof vol === "number" && vol > 70)
+        return true;
+    if (typeof liq === "number" && liq < 20)
+        return true;
+    if (ws["sentiment"] === "panic" || ws["contagion_spread"] === "systemic")
+        return true;
+    return false;
+}
+function computeConfidence(rulesFired, totalReduction) {
+    if (rulesFired.length === 0)
+        return 0.95; // High confidence in "no rules apply"
+    const enforcedCount = rulesFired.filter((r) => r.effect !== "monitored").length;
+    // More rules firing = higher confidence in verdict
+    return Math.min(0.99, 0.6 + enforcedCount * 0.1 + totalReduction * 0.2);
+}
+function buildReason(type, action, rulesFired) {
+    const enforced = rulesFired.filter((r) => r.effect !== "monitored");
+    if (enforced.length === 0) {
+        return `${capitalize(type)} due to aggregate policy thresholds`;
+    }
+    const primary = enforced[0];
+    const others = enforced.length > 1 ? ` (+${enforced.length - 1} more)` : "";
+    switch (type) {
+        case "blocked":
+            return `Blocked by "${primary.description}"${others} — action "${action.description}" violates governance constraints`;
+        case "paused":
+            return `Paused by "${primary.description}"${others} — action "${action.description}" requires review`;
+        case "modified":
+            return `Modified by "${primary.description}"${others} — magnitude reduced from ${action.magnitude.toFixed(2)} to stay within policy limits`;
+    }
+}
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+// ============================================
+// EXAMPLE ACTIONS — for playground / demo
+// ============================================
+/**
+ * Pre-built example actions for testing governance.
+ * These map to common scenarios users would simulate.
+ */
+exports.EXAMPLE_ACTIONS = [
+    {
+        agentId: "hedge-fund-alpha",
+        type: "trade",
+        description: "Sell $20M in equities during market downturn",
+        magnitude: 0.85,
+        context: { asset: "equities", amount: 20_000_000, direction: "sell" },
+    },
+    {
+        agentId: "algo-trader-7",
+        type: "trade",
+        description: "Execute high-frequency arbitrage strategy",
+        magnitude: 0.6,
+        context: { strategy: "arbitrage", automated: true },
+    },
+    {
+        agentId: "pension-fund",
+        type: "trade",
+        description: "Buy $5M in government bonds",
+        magnitude: 0.25,
+        context: { asset: "bonds", amount: 5_000_000, direction: "buy" },
+    },
+    {
+        agentId: "market-maker-3",
+        type: "withdrawal",
+        description: "Withdraw liquidity from the market",
+        magnitude: 0.7,
+        context: { type: "liquidity_withdrawal" },
+    },
+    {
+        agentId: "retail-coalition",
+        type: "trade",
+        description: "Coordinated buy of meme stock",
+        magnitude: 0.55,
+        context: { coordinated: true, participants: 1200 },
+    },
+    {
+        agentId: "quant-fund-beta",
+        type: "leverage",
+        description: "Increase leverage to 8x on volatile positions",
+        magnitude: 0.9,
+        context: { leverage: 8, current_leverage: 3 },
+    },
+    {
+        agentId: "central-bank",
+        type: "intervention",
+        description: "Inject emergency liquidity into the system",
+        magnitude: 0.4,
+        context: { type: "liquidity_injection" },
+    },
+    {
+        agentId: "insurance-pool",
+        type: "trade",
+        description: "Rebalance portfolio under normal conditions",
+        magnitude: 0.15,
+        context: { type: "rebalance", routine: true },
+    },
+];
+/**
+ * Pre-built world state snapshots for testing.
+ */
+exports.EXAMPLE_WORLD_STATES = {
+    calm: {
+        label: "Calm Market",
+        state: { volatility: 25, liquidity: 70, leverage: 2, sentiment: "stable", contagion_spread: "contained" },
+    },
+    stressed: {
+        label: "Stressed Market",
+        state: { volatility: 55, liquidity: 35, leverage: 5, sentiment: "anxious", contagion_spread: "spreading" },
+    },
+    crisis: {
+        label: "Full Crisis",
+        state: { volatility: 88, liquidity: 8, leverage: 12, sentiment: "panic", contagion_spread: "systemic" },
+    },
+};

package/dist/runtime/index.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * @neuroverseos/runtime — Governance Layer for Agent Systems
+ *
+ * NeuroVerse plugs into any agent system and enforces what
+ * actions are allowed before they execute.
+ *
+ * Quick start:
+ *   import { govern } from "@neuroverseos/runtime"
+ *
+ *   const verdict = govern(action, worldState, policyText)
+ *   if (verdict.status === "ALLOW") execute(verdict.action)
+ *
+ * Reusable governor:
+ *   import { createGovernor } from "@neuroverseos/runtime"
+ *
+ *   const gov = createGovernor({ policyText: myPolicy })
+ *   for (const agent of agents) {
+ *     const verdict = gov.evaluate(agent.decide(), worldState)
+ *     if (verdict.action) execute(verdict.action)
+ *   }
+ *
+ * Dynamics governance (system-level, per-round):
+ *   import { governDynamics, createDynamicsGovernor } from "@neuroverseos/runtime"
+ *
+ *   const dynamics = createDynamicsGovernor(policyText)
+ *   for (const round of simulation) {
+ *     // ... agents act, govern() filters actions ...
+ *     const result = dynamics.governRound(reactions, systemState, round)
+ *   }
+ *
+ * Prime Radiant (unified platform):
+ *   import { createPrimeRadiant } from "@neuroverseos/runtime"
+ *
+ *   const radiant = createPrimeRadiant({ scenario, policyText })
+ *   const world = radiant.buildWorld()
+ *   const sim = await radiant.runGovernedSimulation()
+ *   const decision = await radiant.compareOptions(options)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMiroFishWrapper = exports.generateDemoInvestigation = exports.createScienceClawAdapter = exports.interpretScienceState = exports.SCIENCE_INITIAL_STATE = exports.SCIENCE_POLICY_TEXT = exports.SCIENCE_METRICS = exports.PRIME_RADIANT_PRESETS = exports.createPrimeRadiant = exports.DEFAULT_METRICS = exports.runScenarioMatrix = exports.runFullGovernedSimulation = exports.createDynamicsGovernor = exports.governDynamics = exports.EXAMPLE_WORLD_STATES = exports.EXAMPLE_ACTIONS = exports.createGovernor = exports.govern = void 0;
+// Core runtime — Layer A: action governance
+var govern_1 = require("./govern");
+Object.defineProperty(exports, "govern", { enumerable: true, get: function () { return govern_1.govern; } });
+Object.defineProperty(exports, "createGovernor", { enumerable: true, get: function () { return govern_1.createGovernor; } });
+Object.defineProperty(exports, "EXAMPLE_ACTIONS", { enumerable: true, get: function () { return govern_1.EXAMPLE_ACTIONS; } });
+Object.defineProperty(exports, "EXAMPLE_WORLD_STATES", { enumerable: true, get: function () { return govern_1.EXAMPLE_WORLD_STATES; } });
+// Layer B: dynamics governance
+var dynamicsGovernance_1 = require("../engine/dynamicsGovernance");
+Object.defineProperty(exports, "governDynamics", { enumerable: true, get: function () { return dynamicsGovernance_1.governDynamics; } });
+Object.defineProperty(exports, "createDynamicsGovernor", { enumerable: true, get: function () { return dynamicsGovernance_1.createDynamicsGovernor; } });
+// Full governed simulation loop
+var fullGovernedLoop_1 = require("../engine/fullGovernedLoop");
+Object.defineProperty(exports, "runFullGovernedSimulation", { enumerable: true, get: function () { return fullGovernedLoop_1.runFullGovernedSimulation; } });
+// Multi-scenario comparison & decision intelligence
+var scenarioComparison_1 = require("../engine/scenarioComparison");
+Object.defineProperty(exports, "runScenarioMatrix", { enumerable: true, get: function () { return scenarioComparison_1.runScenarioMatrix; } });
+Object.defineProperty(exports, "DEFAULT_METRICS", { enumerable: true, get: function () { return scenarioComparison_1.DEFAULT_METRICS; } });
+// Prime Radiant — unified platform
+var primeRadiant_1 = require("../engine/primeRadiant");
+Object.defineProperty(exports, "createPrimeRadiant", { enumerable: true, get: function () { return primeRadiant_1.createPrimeRadiant; } });
+Object.defineProperty(exports, "PRIME_RADIANT_PRESETS", { enumerable: true, get: function () { return primeRadiant_1.PRIME_RADIANT_PRESETS; } });
+// Science metrics — evaluation metrics for autonomous discovery
+var science_metrics_1 = require("../engine/metrics/science.metrics");
+Object.defineProperty(exports, "SCIENCE_METRICS", { enumerable: true, get: function () { return science_metrics_1.SCIENCE_METRICS; } });
+Object.defineProperty(exports, "SCIENCE_POLICY_TEXT", { enumerable: true, get: function () { return science_metrics_1.SCIENCE_POLICY_TEXT; } });
+Object.defineProperty(exports, "SCIENCE_INITIAL_STATE", { enumerable: true, get: function () { return science_metrics_1.SCIENCE_INITIAL_STATE; } });
+Object.defineProperty(exports, "interpretScienceState", { enumerable: true, get: function () { return science_metrics_1.interpretScienceState; } });
+// ScienceClaw adapter — governance for autonomous scientific discovery
+var scienceclaw_1 = require("../adapters/scienceclaw");
+Object.defineProperty(exports, "createScienceClawAdapter", { enumerable: true, get: function () { return scienceclaw_1.createScienceClawAdapter; } });
+Object.defineProperty(exports, "generateDemoInvestigation", { enumerable: true, get: function () { return scienceclaw_1.generateDemoInvestigation; } });
+// MiroFish adapter — governance wrapper for external simulators
+var mirofish_1 = require("../adapters/mirofish");
+Object.defineProperty(exports, "createMiroFishWrapper", { enumerable: true, get: function () { return mirofish_1.createMiroFishWrapper; } });

package/dist/runtime/types.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * NeuroVerse Governance Runtime — Types
+ *
+ * These types define the interface between ANY agent system
+ * and the NeuroVerse governance layer.
+ *
+ * Usage:
+ *   import { type AgentAction, type GovernanceVerdict } from "@neuroverseos/runtime"
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuroverseos/nv-sim",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "license": "Apache-2.0",
   "description": "CLI for running governed vs baseline agent simulations to explore how world rules shape emergent system behavior.",
@@ -33,6 +33,9 @@
     "test:watch": "vitest",
     "prepublishOnly": "npm run build"
   },
+  "optionalDependencies": {
+    "@anthropic-ai/sdk": "^0.39.0"
+  },
   "dependencies": {
     "@hookform/resolvers": "^3.10.0",
     "@neuroverseos/governance": "^0.3.0",
@@ -91,7 +94,7 @@
     "@tailwindcss/typography": "^0.5.16",
     "@testing-library/jest-dom": "^6.6.0",
     "@testing-library/react": "^16.0.0",
-    "@types/node": "^22.16.5",
+    "@types/node": "^22.19.15",
     "@types/react": "^18.3.23",
     "@types/react-dom": "^18.3.7",
     "@vitejs/plugin-react-swc": "^3.11.0",