@coreason-ai/sensory-core 1.0.3

package/dist/components/SensoryUnfolder.js

@@ -0,0 +1,77 @@
+// Copyright (c) 2026 CoReason, Inc
+//
+// This software is proprietary and dual-licensed
+// Licensed under the Prosperity Public License 3.0 (the "License")
+// A copy of the license is available at <https://prosperitylicense.com/versions/3.0.0>
+// For details, see the LICENSE file
+// Commercial use beyond a 30-day trial requires a separate license
+//
+// Source Code: <https://github.com/CoReason-AI/coreason-sensory-core>
+import React from 'react';
+import { TopologicalCanvas } from './TopologicalCanvas';
+import { GlassBox } from './GlassBox';
+import { StatusPulse } from './StatusPulse';
+import { VFEIndicator } from './VFEIndicator';
+import { HolographicAuditTrail } from './HolographicAuditTrail';
+import { KnowledgeTree } from './KnowledgeTree';
+import { ConstrainedDecodingInspector } from './ConstrainedDecodingInspector';
+import { ThermodynamicGovernor } from './ThermodynamicGovernor';
+import { QuorumAdjudicator } from './QuorumAdjudicator';
+class SensoryErrorBoundary extends React.Component {
+    constructor(props) {
+        super(props);
+        this.state = { hasError: false, error: null };
+    }
+    static getDerivedStateFromError(error) {
+        return { hasError: true, error };
+    }
+    componentDidCatch(error, errorInfo) {
+        console.error('SensoryUnfolder error boundary caught an execution bleed:', error, errorInfo);
+    }
+    render() {
+        if (this.state.hasError) {
+            return this.props.fallback;
+        }
+        return this.props.children;
+    }
+}
+const SensoryPrimitive = ({ urn, data }) => {
+    switch (urn) {
+        case 'urn:coreason:actionspace:sensory:topological_canvas:v1':
+            return React.createElement(TopologicalCanvas, Object.assign({}, data));
+        case 'urn:coreason:actionspace:sensory:glass_box:v1':
+            return React.createElement(GlassBox, Object.assign({}, data), data.children);
+        case 'urn:coreason:actionspace:sensory:status_pulse:v1':
+            return React.createElement(StatusPulse, Object.assign({}, data));
+        case 'urn:coreason:actionspace:sensory:vfe_indicator:v1':
+            return React.createElement(VFEIndicator, Object.assign({}, data));
+        case 'urn:coreason:actionspace:sensory:audit_trail:v1':
+            return React.createElement(HolographicAuditTrail, Object.assign({}, data));
+        case 'urn:coreason:actionspace:sensory:knowledge_tree:v1':
+            return React.createElement(KnowledgeTree, Object.assign({}, data));
+        case 'urn:coreason:actionspace:sensory:decoding_inspector:v1':
+            return React.createElement(ConstrainedDecodingInspector, Object.assign({}, data));
+        case 'urn:coreason:actionspace:sensory:thermodynamic_governor:v1':
+            return React.createElement(ThermodynamicGovernor, Object.assign({}, data));
+        case 'urn:coreason:actionspace:sensory:quorum_adjudicator:v1':
+            return React.createElement(QuorumAdjudicator, Object.assign({}, data));
+        default:
+            throw new Error(`URN '${urn}' is not supported in the active layout registry.`);
+    }
+};
+/**
+ * AGENT INSTRUCTION: This core component performs the recursive JIT unfolding of nested URN visual geometries.
+ * CAUSAL AFFORDANCE: Dynamically maps standard URN strings to their corresponding React/WebGL visual enclaves.
+ * EPISTEMIC BOUNDS: Gracefully handles missing URN mappings via a localized error boundary and fallback mechanism.
+ * MCP ROUTING TRIGGERS: Sensory, Unfolding, JIT, Hot-Swap, URN Registry.
+ */
+export const SensoryUnfolder = ({ urn, data, fallback }) => {
+    const defaultFallback = (React.createElement("div", { className: "p-4 rounded-xl border border-dashed border-[var(--cr-accent-orange)] bg-[rgba(255,100,0,0.05)] text-[var(--cr-accent-orange)] font-mono text-xs max-w-md" },
+        React.createElement("div", { className: "font-bold mb-1" }, "\u26A0\uFE0F EPISTEMIC DEFICIT GAVE UNRESOLVED BOUNDARY"),
+        React.createElement("div", null,
+            "Requested URN ",
+            React.createElement("span", { className: "underline" }, urn),
+            " could not be unfolded by the active sensory manifold.")));
+    return (React.createElement(SensoryErrorBoundary, { fallback: fallback || defaultFallback },
+        React.createElement(SensoryPrimitive, { urn: urn, data: data })));
+};

package/dist/components/StatusPulse.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface StatusPulseProps {
+    status: 'executing' | 'suspended_vfe_breach' | 'completed' | 'idle';
+    vfeValue?: number;
+    label?: string;
+    className?: string;
+}
+export declare const StatusPulse: React.FC<StatusPulseProps>;

package/dist/components/StatusPulse.js

@@ -0,0 +1,56 @@
+// Copyright (c) 2026 CoReason, Inc
+//
+// This software is proprietary and dual-licensed
+// Licensed under the Prosperity Public License 3.0 (the "License")
+// A copy of the license is available at <https://prosperitylicense.com/versions/3.0.0>
+// For details, see the LICENSE file
+// Commercial use beyond a 30-day trial requires a separate license
+//
+// Source Code: <https://github.com/CoReason-AI/coreason-runtime>
+import React from 'react';
+import { motion } from 'framer-motion';
+import { cn } from './GlassBox';
+export const StatusPulse = ({ status, vfeValue, label, className }) => {
+    const isError = status === 'suspended_vfe_breach';
+    const isExecuting = status === 'executing';
+    const isCompleted = status === 'completed';
+    const baseColor = isError
+        ? 'var(--cr-accent-orange)'
+        : isExecuting
+            ? 'var(--cr-accent-cyan)'
+            : isCompleted
+                ? '#00cc44'
+                : '#666';
+    // Compute dynamic pulse duration based on VFE stress
+    const pulseDuration = vfeValue !== undefined && vfeValue > 0
+        ? Math.max(0.3, 1.5 - (vfeValue * 0.8)) // breathing rate speeds up as VFE increases
+        : isError
+            ? 0.5 // Rapid flashing on error
+            : 1.8; // Calmer breathing under normal load
+    return (React.createElement("div", { className: cn("flex items-center gap-2", className) },
+        React.createElement(motion.div, { animate: isExecuting || isError
+                ? {
+                    scale: [1, 1.25, 1],
+                    opacity: [0.6, 1, 0.6],
+                    boxShadow: [
+                        `0 0 4px ${baseColor}`,
+                        `0 0 16px ${baseColor}`,
+                        `0 0 4px ${baseColor}`,
+                    ],
+                }
+                : {
+                    scale: 1,
+                    opacity: 1,
+                    boxShadow: `0 0 2px ${baseColor}`,
+                }, transition: {
+                repeat: isExecuting || isError ? Infinity : 0,
+                duration: pulseDuration,
+                ease: 'easeInOut',
+            }, className: cn('w-3 h-3 rounded-full'), style: {
+                backgroundColor: baseColor,
+            } }),
+        React.createElement("span", { className: "font-mono text-xs font-semibold", style: { color: baseColor } },
+            label || status.toUpperCase(),
+            " ",
+            vfeValue !== undefined && `(VFE: ${vfeValue.toFixed(2)})`)));
+};

package/dist/components/TemporalScrubber.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+export interface TemporalFork {
+    id: string;
+    branchPoint: number;
+    name: string;
+}
+export interface TemporalScrubberProps {
+    timestamp: number;
+    minRange: number;
+    maxRange: number;
+    forks?: TemporalFork[];
+    onScrub: (newTime: number) => void;
+    onForkSelect?: (forkId: string) => void;
+    className?: string;
+}
+export declare const TemporalScrubber: React.FC<TemporalScrubberProps>;

package/dist/components/TemporalScrubber.js

@@ -0,0 +1,36 @@
+// Copyright (c) 2026 CoReason, Inc
+//
+// This software is proprietary and dual-licensed
+// Licensed under the Prosperity Public License 3.0 (the "License")
+// A copy of the license is available at <https://prosperitylicense.com/versions/3.0.0>
+// For details, see the LICENSE file
+// Commercial use beyond a 30-day trial requires a separate license
+//
+// Source Code: <https://github.com/CoReason-AI/coreason-runtime>
+import React from 'react';
+import { motion } from 'framer-motion';
+import { cn } from './GlassBox';
+export const TemporalScrubber = ({ timestamp, minRange, maxRange, forks = [], onScrub, onForkSelect, className }) => {
+    const getPercentage = (val) => ((val - minRange) / (maxRange - minRange)) * 100;
+    return (React.createElement("div", { className: cn('flex flex-col items-stretch gap-4 p-4 bg-[var(--cr-glass-box-black)] rounded-xl border border-gray-800', className) },
+        React.createElement("div", { className: "flex justify-between items-center mb-2" },
+            React.createElement("span", { className: "text-white uppercase tracking-widest text-xs font-bold" }, "Temporal Navigation"),
+            React.createElement("span", { className: "text-[var(--cr-accent-cyan)] font-mono text-xs" },
+                "T - ",
+                Math.floor((Date.now() - timestamp) / 1000),
+                "s")),
+        React.createElement("div", { className: "relative h-16 w-full" },
+            React.createElement("div", { className: "absolute top-8 left-0 right-0 h-1 bg-gray-700 rounded-full" }),
+            React.createElement("div", { className: "absolute top-8 left-0 h-1 bg-[var(--cr-accent-cyan)] rounded-full transition-all", style: { width: `${getPercentage(timestamp)}%` } }),
+            forks.map((fork, idx) => {
+                const startPct = getPercentage(fork.branchPoint);
+                const topOffset = idx % 2 === 0 ? 0 : 16;
+                return (React.createElement(motion.div, { key: fork.id, initial: { opacity: 0 }, animate: { opacity: 1 }, className: "absolute h-1 bg-[var(--cr-accent-orange)] cursor-pointer group", style: { left: `${startPct}%`, top: topOffset, width: `calc(100% - ${startPct}%)` }, onClick: () => onForkSelect === null || onForkSelect === void 0 ? void 0 : onForkSelect(fork.id) },
+                    React.createElement("div", { className: "absolute -left-1 -top-1 w-3 h-3 rounded-full bg-[var(--cr-accent-orange)]" }),
+                    React.createElement("div", { className: "absolute -top-6 left-0 opacity-0 group-hover:opacity-100 transition-opacity bg-black text-[var(--cr-accent-orange)] text-[10px] font-mono px-2 py-1 rounded" },
+                        "\u2443 ",
+                        fork.name)));
+            }),
+            React.createElement("input", { type: "range", min: minRange, max: maxRange, value: timestamp, onChange: (e) => onScrub(Number(e.target.value)), className: "absolute top-[26px] w-full cursor-ew-resize opacity-0 z-10" }),
+            React.createElement(motion.div, { className: "absolute top-6 w-5 h-5 rounded-full bg-white border-2 border-[var(--cr-accent-cyan)] shadow-[0_0_10px_var(--cr-accent-cyan)] pointer-events-none", style: { left: `calc(${getPercentage(timestamp)}% - 10px)` }, layout: true }))));
+};

package/dist/components/ThermodynamicGovernor.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+export interface ThermodynamicGovernorProps {
+    vramAllocationMb: number;
+    tokenBurnRateSec: number;
+    maxBudgetTokens: number;
+    consumedTokens: number;
+    spiffeStatus: 'VERIFIED' | 'REVOKED' | 'PENDING';
+}
+/**
+ * ThermodynamicGovernor
+ *
+ * Target Persona: System Administrator
+ * Concept: Resource Governance & Sovereign Computing
+ * Translates abstract AI usage into physical thermodynamic costs (VRAM, Token Burn)
+ * and cryptographic identity (SPIFFE/SPIRE).
+ */
+export declare const ThermodynamicGovernor: React.FC<ThermodynamicGovernorProps>;

package/dist/components/ThermodynamicGovernor.js

@@ -0,0 +1,50 @@
+// Copyright (c) 2026 CoReason, Inc
+//
+// This software is proprietary and dual-licensed
+// Licensed under the Prosperity Public License 3.0 (the "License")
+// A copy of the license is available at <https://prosperitylicense.com/versions/3.0.0>
+// For details, see the LICENSE file
+// Commercial use beyond a 30-day trial requires a separate license
+//
+// Source Code: <https://github.com/CoReason-AI/coreason-sensory-core>
+import React from 'react';
+import { GlassBox } from './GlassBox';
+/**
+ * ThermodynamicGovernor
+ *
+ * Target Persona: System Administrator
+ * Concept: Resource Governance & Sovereign Computing
+ * Translates abstract AI usage into physical thermodynamic costs (VRAM, Token Burn)
+ * and cryptographic identity (SPIFFE/SPIRE).
+ */
+export const ThermodynamicGovernor = ({ vramAllocationMb, tokenBurnRateSec, maxBudgetTokens, consumedTokens, spiffeStatus }) => {
+    const budgetPercent = Math.min((consumedTokens / maxBudgetTokens) * 100, 100);
+    const isCritical = budgetPercent > 90;
+    return (React.createElement(GlassBox, { density: "dense" },
+        React.createElement("div", { className: "flex flex-col space-y-3" },
+            React.createElement("div", { className: "flex justify-between items-center border-b border-gray-700 pb-2" },
+                React.createElement("h3", { className: "text-sm font-semibold text-white tracking-widest uppercase" }, "Thermodynamic Governor"),
+                React.createElement("span", { className: `text-xs px-2 py-1 rounded-full ${spiffeStatus === 'VERIFIED' ? 'bg-green-900 text-green-300' : 'bg-red-900 text-red-300'}` },
+                    "SPIFFE: ",
+                    spiffeStatus)),
+            React.createElement("div", { className: "grid grid-cols-2 gap-4" },
+                React.createElement("div", { className: "flex flex-col" },
+                    React.createElement("span", { className: "text-xs text-gray-400" }, "VRAM Allocation"),
+                    React.createElement("span", { className: "text-lg font-mono text-white" },
+                        vramAllocationMb.toLocaleString(),
+                        " MB")),
+                React.createElement("div", { className: "flex flex-col" },
+                    React.createElement("span", { className: "text-xs text-gray-400" }, "Token Velocity"),
+                    React.createElement("span", { className: "text-lg font-mono text-[var(--cr-accent-orange)]" },
+                        tokenBurnRateSec,
+                        " T/s"))),
+            React.createElement("div", { className: "flex flex-col space-y-1 pt-2" },
+                React.createElement("div", { className: "flex justify-between text-xs" },
+                    React.createElement("span", { className: "text-gray-400" }, "Compute Budget"),
+                    React.createElement("span", { className: isCritical ? 'text-red-400' : 'text-gray-400' },
+                        consumedTokens.toLocaleString(),
+                        " / ",
+                        maxBudgetTokens.toLocaleString())),
+                React.createElement("div", { className: "w-full bg-gray-800 rounded-full h-1.5 overflow-hidden" },
+                    React.createElement("div", { className: `h-1.5 rounded-full ${isCritical ? 'bg-red-500' : 'bg-[var(--cr-accent-orange)]'}`, style: { width: `${budgetPercent}%`, transition: 'width 0.5s ease-out' } }))))));
+};

package/dist/components/TopologicalCanvas.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { Node, Edge } from '@xyflow/react';
+import '@xyflow/react/dist/style.css';
+export interface CapabilityRegistryItem {
+    urn: string;
+    typeLabel: string;
+}
+export interface TopologicalCanvasProps {
+    nodes: Node[];
+    edges: Edge[];
+    availableCapabilities?: CapabilityRegistryItem[];
+    onNodeClick?: (event: React.MouseEvent, node: Node) => void;
+    onNodesChange?: (changes: any) => void;
+    onEdgesChange?: (changes: any) => void;
+    onConnect?: (connection: any) => void;
+    onDropCapability?: (capability: CapabilityRegistryItem, position: {
+        x: number;
+        y: number;
+    }) => void;
+}
+/**
+ * TopologicalCanvas
+ *
+ * Concept: Visualizes the Macro-Swarm Architecture
+ * Uses ReactFlow to map mathematical DAGs to the UI.
+ */
+export declare const TopologicalCanvas: React.FC<TopologicalCanvasProps>;

package/dist/components/TopologicalCanvas.js

@@ -0,0 +1,183 @@
+// Copyright (c) 2026 CoReason, Inc
+//
+// This software is proprietary and dual-licensed
+// Licensed under the Prosperity Public License 3.0 (the "License")
+// A copy of the license is available at <https://prosperitylicense.com/versions/3.0.0>
+// For details, see the LICENSE file
+// Commercial use beyond a 30-day trial requires a separate license
+//
+// Source Code: <https://github.com/CoReason-AI/coreason-sensory-core>
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import React from 'react';
+import { ReactFlow, Background, Controls, getBezierPath, EdgeLabelRenderer, Panel } from '@xyflow/react';
+import '@xyflow/react/dist/style.css';
+import { GlassBox } from './GlassBox';
+import { StatusPulse } from './StatusPulse';
+// Custom Node: SwarmNode
+const SwarmNode = ({ data }) => {
+    var _a;
+    return (React.createElement(GlassBox, { density: "dense", className: `border ${data.isAnomalous ? 'border-[var(--cr-accent-orange)]' : 'border-gray-800'} min-w-[150px]` },
+        React.createElement("div", { className: "flex flex-col" },
+            React.createElement("div", { className: "flex justify-between items-center mb-2" },
+                React.createElement("span", { className: "text-[10px] uppercase tracking-widest text-gray-500" }, data.typeLabel || 'AGENT'),
+                React.createElement(StatusPulse, { status: data.status || 'idle' })),
+            React.createElement("span", { className: "text-sm font-mono text-white truncate max-w-[120px]", title: data.urn }, ((_a = data.urn) === null || _a === void 0 ? void 0 : _a.split(':').slice(-2).join(':')) || 'urn:unknown'))));
+};
+// Custom Node: SandboxNode (For Fractal Infrastructure)
+const SandboxNode = ({ id, data }) => {
+    const fuelPercentage = data.cpuFuel && data.maxFuel ? (data.cpuFuel / data.maxFuel) * 100 : 100;
+    const memoryPercentage = data.memoryUsage && data.maxMemory ? (data.memoryUsage / data.maxMemory) * 100 : 0;
+    return (React.createElement("div", { className: "bg-[rgba(20,20,20,0.8)] border border-[var(--cr-accent-orange)] rounded-lg p-4 min-w-[300px] min-h-[200px] relative shadow-[0_0_15px_rgba(255,100,0,0.2)]" },
+        React.createElement("div", { className: "absolute top-0 left-0 right-0 bg-[var(--cr-accent-orange)] text-black text-[10px] font-bold uppercase tracking-wider px-2 py-1 rounded-t-sm flex justify-between items-center" },
+            React.createElement("span", null,
+                "\u26CA ",
+                data.sandboxType || 'WASM ENCLAVE',
+                " ISOLATION BOUNDARY"),
+            React.createElement("span", { className: "font-mono" }, data.id || id)),
+        React.createElement("div", { className: "mt-6 mb-2 flex flex-col gap-2" },
+            React.createElement("div", { className: "flex items-center justify-between text-[10px] font-mono text-gray-400" },
+                React.createElement("span", null, "CPU FUEL"),
+                React.createElement("span", null,
+                    data.cpuFuel || 0,
+                    " / ",
+                    data.maxFuel || 0)),
+            React.createElement("div", { className: "h-1 bg-gray-800 rounded-full overflow-hidden" },
+                React.createElement("div", { className: "h-full bg-[var(--cr-accent-orange)] transition-all", style: { width: `${fuelPercentage}%` } })),
+            React.createElement("div", { className: "flex items-center justify-between text-[10px] font-mono text-gray-400 mt-2" },
+                React.createElement("span", null, "VOLUMETRIC RAM"),
+                React.createElement("span", null,
+                    data.memoryUsage || 0,
+                    "MB / ",
+                    data.maxMemory || 10,
+                    "MB")),
+            React.createElement("div", { className: "h-1 bg-gray-800 rounded-full overflow-hidden" },
+                React.createElement("div", { className: "h-full bg-blue-400 transition-all", style: { width: `${memoryPercentage}%` } })))));
+};
+// Custom Edge: TelemetryEdge
+const TelemetryEdge = ({ id, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, style = {}, markerEnd, data }) => {
+    const [edgePath, labelX, labelY] = getBezierPath({
+        sourceX,
+        sourceY,
+        sourcePosition,
+        targetX,
+        targetY,
+        targetPosition,
+    });
+    return (React.createElement("g", null,
+        React.createElement("path", { id: id, style: Object.assign(Object.assign({}, style), { strokeWidth: 2, stroke: (data === null || data === void 0 ? void 0 : data.isStreaming) ? 'var(--cr-accent-orange)' : '#4B5563', strokeDasharray: (data === null || data === void 0 ? void 0 : data.isStreaming) ? '5,5' : 'none', animation: (data === null || data === void 0 ? void 0 : data.isStreaming) ? 'dashdraw 1s linear infinite' : 'none' }), className: "react-flow__edge-path", d: edgePath, markerEnd: markerEnd }),
+        (data === null || data === void 0 ? void 0 : data.label) && (React.createElement(EdgeLabelRenderer, null,
+            React.createElement("div", { style: {
+                    position: 'absolute',
+                    transform: `translate(-50%, -50%) translate(${labelX}px,${labelY}px)`,
+                    pointerEvents: 'all',
+                }, className: "bg-black border border-gray-800 text-[10px] text-gray-400 font-mono px-2 py-0.5 rounded uppercase tracking-wider" }, data.label)))));
+};
+const nodeTypes = {
+    swarmNode: SwarmNode,
+    sandboxNode: SandboxNode,
+};
+const edgeTypes = {
+    telemetryEdge: TelemetryEdge,
+};
+/**
+ * TopologicalCanvas
+ *
+ * Concept: Visualizes the Macro-Swarm Architecture
+ * Uses ReactFlow to map mathematical DAGs to the UI.
+ */
+export const TopologicalCanvas = ({ nodes, edges, availableCapabilities = [], onNodeClick, onNodesChange, onEdgesChange, onConnect, onDropCapability }) => {
+    const [isLayouting, setIsLayouting] = React.useState(false);
+    const onDragStart = (event, capability) => {
+        event.dataTransfer.setData('application/reactflow', JSON.stringify(capability));
+        event.dataTransfer.effectAllowed = 'move';
+    };
+    const onDragOver = (event) => {
+        event.preventDefault();
+        event.dataTransfer.dropEffect = 'move';
+    };
+    const onDrop = (event) => {
+        event.preventDefault();
+        const reactFlowBounds = event.currentTarget.getBoundingClientRect();
+        const capabilityData = event.dataTransfer.getData('application/reactflow');
+        if (capabilityData && onDropCapability) {
+            const capability = JSON.parse(capabilityData);
+            const position = {
+                x: event.clientX - reactFlowBounds.left,
+                y: event.clientY - reactFlowBounds.top,
+            };
+            onDropCapability(capability, position);
+        }
+    };
+    const handleAutoLayout = () => __awaiter(void 0, void 0, void 0, function* () {
+        if (nodes.length === 0)
+            return;
+        setIsLayouting(true);
+        try {
+            const ELK = (yield import('elkjs/lib/elk.bundled.js')).default;
+            const elk = new ELK();
+            const graph = {
+                id: 'root',
+                layoutOptions: {
+                    'elk.algorithm': 'layered',
+                    'elk.direction': 'RIGHT',
+                    'elk.spacing.nodeNode': '75',
+                    'elk.layered.spacing.nodeNodeBetweenLayers': '100',
+                },
+                children: nodes.map((node) => (Object.assign({ id: node.id, width: node.width || 250, height: node.height || 100 }, node))),
+                edges: edges.map((edge) => (Object.assign({ id: edge.id, sources: [edge.source], targets: [edge.target] }, edge))),
+            };
+            const layoutedGraph = yield elk.layout(graph);
+            if (onNodesChange && layoutedGraph.children) {
+                const changes = nodes.map((node) => {
+                    var _a;
+                    const elkNode = (_a = layoutedGraph.children) === null || _a === void 0 ? void 0 : _a.find((n) => n.id === node.id);
+                    if (elkNode) {
+                        return {
+                            id: node.id,
+                            type: 'position',
+                            position: { x: elkNode.x, y: elkNode.y },
+                            dragging: false,
+                        };
+                    }
+                    return null;
+                }).filter(Boolean);
+                onNodesChange(changes);
+            }
+        }
+        catch (error) {
+            console.error('ELK Layout error:', error);
+        }
+        finally {
+            setIsLayouting(false);
+        }
+    });
+    return (React.createElement("div", { className: "flex h-full w-full rounded-xl overflow-hidden border border-gray-800 bg-black" },
+        availableCapabilities.length > 0 && (React.createElement("div", { className: "w-64 border-r border-gray-800 bg-[var(--cr-glass-box-black)] p-4 overflow-y-auto" },
+            React.createElement("div", { className: "text-white uppercase tracking-widest text-xs font-bold mb-4 border-b border-gray-800 pb-2" }, "URN Registry"),
+            React.createElement("div", { className: "flex flex-col gap-3" }, availableCapabilities.map((cap) => (React.createElement("div", { key: cap.urn, className: "bg-[rgba(20,20,20,0.8)] border border-gray-700 p-2 rounded cursor-grab hover:border-[var(--cr-accent-cyan)] transition-colors", onDragStart: (event) => onDragStart(event, cap), draggable: true },
+                React.createElement("div", { className: "text-[10px] text-gray-500 font-mono mb-1" }, cap.typeLabel),
+                React.createElement("div", { className: "text-[11px] text-white font-mono break-all" }, cap.urn))))))),
+        React.createElement("div", { className: "flex-1 relative w-full h-full min-h-0", onDragOver: onDragOver, onDrop: onDrop },
+            React.createElement("style", null, `
+            @keyframes dashdraw {
+              from { stroke-dashoffset: 10; }
+              to { stroke-dashoffset: 0; }
+            }
+            .react-flow__background {
+              background-color: #000;
+            }
+          `),
+            React.createElement(ReactFlow, { nodes: nodes, edges: edges, nodeTypes: nodeTypes, edgeTypes: edgeTypes, onNodeClick: onNodeClick, onNodesChange: onNodesChange, onEdgesChange: onEdgesChange, onConnect: onConnect, fitView: true, proOptions: { hideAttribution: true } },
+                React.createElement(Background, { color: "#1f2937", gap: 20 }),
+                React.createElement(Controls, { className: "bg-[var(--cr-glass-box-black)] border border-gray-800 fill-white" }),
+                React.createElement(Panel, { position: "top-right", className: "m-4" },
+                    React.createElement("button", { onClick: handleAutoLayout, disabled: isLayouting, className: `bg-[var(--cr-accent-orange)] text-black font-bold uppercase tracking-wider text-[10px] px-4 py-2 rounded shadow-lg transition-opacity ${isLayouting ? 'opacity-50 cursor-not-allowed' : 'hover:opacity-90'}` }, isLayouting ? 'Computing Topology...' : 'Orthogonal Layout'))))));
+};

package/dist/components/VFEIndicator.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+export interface VFEIndicatorProps {
+    currentVfe?: number;
+    vfeValue?: number;
+    threshold: number;
+    tokenBurnRate?: number;
+    maxTokenBurnRate?: number;
+}
+/**
+ * AGENT INSTRUCTION: This hollow component visually projects backend token burn and Variational Free Energy (VFE) spikes without requiring explicit user interaction.
+ * CAUSAL AFFORDANCE: Renders the divergence between structural prior and the agent's generative trajectory via an animated ring.
+ * EPISTEMIC BOUNDS: Bounded by `currentVfe` (or `vfeValue`) and `threshold`. If VFE > `threshold`, the component transitions into a suspended state.
+ * MCP ROUTING TRIGGERS: VFE, Token Burn, Threshold Breach, System 1, System 2.
+ */
+export declare const VFEIndicator: React.FC<VFEIndicatorProps>;

package/dist/components/VFEIndicator.js

@@ -0,0 +1,52 @@
+// Copyright (c) 2026 CoReason, Inc
+//
+// This software is proprietary and dual-licensed
+// Licensed under the Prosperity Public License 3.0 (the "License")
+// A copy of the license is available at <https://prosperitylicense.com/versions/3.0.0>
+// For details, see the LICENSE file
+// Commercial use beyond a 30-day trial requires a separate license
+//
+// Source Code: <https://github.com/CoReason-AI/coreason-sensory-core>
+import React from 'react';
+import { motion } from 'framer-motion';
+/**
+ * AGENT INSTRUCTION: This hollow component visually projects backend token burn and Variational Free Energy (VFE) spikes without requiring explicit user interaction.
+ * CAUSAL AFFORDANCE: Renders the divergence between structural prior and the agent's generative trajectory via an animated ring.
+ * EPISTEMIC BOUNDS: Bounded by `currentVfe` (or `vfeValue`) and `threshold`. If VFE > `threshold`, the component transitions into a suspended state.
+ * MCP ROUTING TRIGGERS: VFE, Token Burn, Threshold Breach, System 1, System 2.
+ */
+export const VFEIndicator = ({ currentVfe, vfeValue, threshold = 1, tokenBurnRate = 0, maxTokenBurnRate = 1000 }) => {
+    const vfe = currentVfe !== undefined ? currentVfe : (vfeValue !== undefined ? vfeValue : 0);
+    const isBreached = vfe >= threshold;
+    const percentage = Math.min((vfe / threshold) * 100, 100);
+    const ringColor = isBreached ? 'var(--cr-accent-orange)' : 'var(--cr-accent-cyan)';
+    // Compute burn rate percentage
+    const burnPercentage = Math.min((tokenBurnRate / maxTokenBurnRate) * 100, 100);
+    return (React.createElement("div", { className: "flex flex-col items-center justify-center p-6 rounded-xl bg-[var(--cr-glass-box-black)] border border-[#333] w-full max-w-[240px]" },
+        React.createElement("div", { className: "relative w-28 h-28" },
+            React.createElement("svg", { className: "w-full h-full transform -rotate-90" },
+                React.createElement("circle", { cx: "56", cy: "56", r: "48", stroke: "currentColor", strokeWidth: "8", fill: "transparent", className: "text-gray-800" }),
+                React.createElement(motion.circle, { cx: "56", cy: "56", r: "48", stroke: ringColor, strokeWidth: "8", fill: "transparent", strokeDasharray: "301.6" /* 2 * PI * 48 */, initial: { strokeDashoffset: 301.6 }, animate: { strokeDashoffset: 301.6 - (301.6 * percentage) / 100 }, transition: { type: 'spring', stiffness: 50, damping: 12 } })),
+            React.createElement("div", { className: "absolute inset-0 flex flex-col items-center justify-center" },
+                React.createElement("span", { className: "text-white font-mono text-base font-bold" }, vfe.toFixed(2)),
+                React.createElement("span", { className: "text-[10px] text-gray-500 font-mono" },
+                    "LIMIT: ",
+                    threshold.toFixed(1)))),
+        React.createElement("div", { className: "mt-4 text-xs font-mono text-gray-300 font-bold uppercase tracking-wider" },
+            "VFE ",
+            isBreached ? 'BREACHED' : 'NOMINAL'),
+        React.createElement("div", { className: "mt-4 w-full flex flex-col gap-1.5 border-t border-gray-800 pt-3" },
+            React.createElement("div", { className: "flex justify-between items-center text-[10px] font-mono text-gray-400" },
+                React.createElement("span", null, "TOKEN BURN RATE"),
+                React.createElement("span", { className: "text-white font-semibold" },
+                    tokenBurnRate.toFixed(0),
+                    " T/S")),
+            React.createElement("div", { className: "h-2 w-full bg-gray-900 rounded-full overflow-hidden border border-gray-800 relative" },
+                React.createElement(motion.div, { initial: { width: 0 }, animate: { width: `${burnPercentage}%` }, transition: { type: 'spring', stiffness: 60, damping: 15 }, className: "h-full bg-gradient-to-r from-blue-500 to-[var(--cr-accent-cyan)] rounded-full relative" }, tokenBurnRate > 0 && (React.createElement(motion.div, { animate: {
+                        x: ['-100%', '100%']
+                    }, transition: {
+                        repeat: Infinity,
+                        duration: Math.max(0.5, 2 - (tokenBurnRate / 500)), // faster shimmer at higher rates
+                        ease: 'linear'
+                    }, className: "absolute inset-0 bg-gradient-to-r from-transparent via-[rgba(255,255,255,0.4)] to-transparent" })))))));
+};

package/dist/components/VerifiedCapabilityReceipt.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+export interface VerifiedCapabilityReceiptProps {
+    urn: string;
+    ociUri: string;
+    signerDid: string;
+    verifiedAt: number;
+    className?: string;
+}
+/**
+ * AGENT INSTRUCTION: This component visualizes the cryptographic provenance of a capability,
+ * bridging the coreason-urn-authority ledger with the sensory manifold.
+ *
+ * CAUSAL AFFORDANCE: Renders the OCI Trust Anchor verification receipt for any URN-addressable capability.
+ *
+ * EPISTEMIC BOUNDS: Strictly read-only projection of cryptographic signatures; does not issue credentials.
+ *
+ * MCP ROUTING TRIGGERS: Ledger, Provenance, Cosign Verification, Zero-Trust
+ */
+export declare const VerifiedCapabilityReceipt: React.FC<VerifiedCapabilityReceiptProps>;

package/dist/components/VerifiedCapabilityReceipt.js

@@ -0,0 +1,37 @@
+// Copyright (c) 2026 CoReason, Inc
+//
+// This software is proprietary and dual-licensed
+// Licensed under the Prosperity Public License 3.0 (the "License")
+// A copy of the license is available at <https://prosperitylicense.com/versions/3.0.0>
+// For details, see the LICENSE file
+// Commercial use beyond a 30-day trial requires a separate license
+//
+// Source Code: <https://github.com/CoReason-AI/coreason-sensory-core>
+import React from 'react';
+import { GlassBox, cn } from './GlassBox';
+/**
+ * AGENT INSTRUCTION: This component visualizes the cryptographic provenance of a capability,
+ * bridging the coreason-urn-authority ledger with the sensory manifold.
+ *
+ * CAUSAL AFFORDANCE: Renders the OCI Trust Anchor verification receipt for any URN-addressable capability.
+ *
+ * EPISTEMIC BOUNDS: Strictly read-only projection of cryptographic signatures; does not issue credentials.
+ *
+ * MCP ROUTING TRIGGERS: Ledger, Provenance, Cosign Verification, Zero-Trust
+ */
+export const VerifiedCapabilityReceipt = ({ urn, ociUri, signerDid, verifiedAt, className }) => {
+    return (React.createElement(GlassBox, { density: "dense", className: cn('flex flex-col gap-2 min-w-[300px] border border-green-800 bg-[rgba(10,30,10,0.8)]', className) },
+        React.createElement("div", { className: "flex justify-between items-center mb-1" },
+            React.createElement("span", { className: "text-[10px] uppercase tracking-widest text-green-400 font-bold" }, "\u26BF VERIFIED CAPABILITY"),
+            React.createElement("span", { className: "text-[10px] text-gray-500 font-mono" }, verifiedAt ? new Date(verifiedAt).toISOString() : 'UNKNOWN')),
+        React.createElement("div", { className: "flex flex-col gap-1 text-[11px] font-mono" },
+            React.createElement("div", { className: "flex flex-col" },
+                React.createElement("span", { className: "text-gray-500 uppercase text-[9px]" }, "URN"),
+                React.createElement("span", { className: "text-white truncate", title: urn }, urn)),
+            React.createElement("div", { className: "flex flex-col" },
+                React.createElement("span", { className: "text-gray-500 uppercase text-[9px]" }, "OCI Artifact"),
+                React.createElement("span", { className: "text-blue-300 truncate", title: ociUri }, ociUri)),
+            React.createElement("div", { className: "flex flex-col" },
+                React.createElement("span", { className: "text-gray-500 uppercase text-[9px]" }, "Signer DID"),
+                React.createElement("span", { className: "text-purple-400 truncate", title: signerDid }, signerDid)))));
+};

package/dist/components/nodes/AgentNode.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export interface AgentNodeData {
+    label: string;
+    status: string;
+    tokens?: string;
+    vfe?: number;
+    memoryAllocatedMb?: number;
+    cpuFuelRemaining?: number;
+    persona?: string;
+}
+export interface AgentNodeProps {
+    data: AgentNodeData;
+}
+export declare const AgentNode: React.FC<AgentNodeProps>;