@backbay/glia 0.2.0-alpha.1

package/dist/primitives/three/Sentinel/useThrowPhysics.js

@@ -0,0 +1,167 @@
+/**
+ * useThrowPhysics Hook
+ *
+ * Provides physics simulation for throwing the Sentinel orb
+ * and calculating edge docking positions.
+ */
+import { useCallback, useRef, useState } from 'react';
+const PHYSICS = {
+    friction: 0.98,
+    bounceDamping: 0.6,
+    gravity: 0.15,
+    minVelocity: 0.5,
+    edgePadding: 16,
+};
+export function useThrowPhysics(options) {
+    const { onPositionUpdate, onSettle, edgePadding = PHYSICS.edgePadding } = options;
+    const [isDragging, setIsDragging] = useState(false);
+    const velocityHistory = useRef([]);
+    const currentPosition = useRef({ x: 0, y: 0 });
+    const animationFrameId = useRef(null);
+    const calculateVelocity = useCallback(() => {
+        const history = velocityHistory.current;
+        if (history.length < 2)
+            return { vx: 0, vy: 0 };
+        const now = performance.now();
+        const recentPoints = history.filter((p) => now - p.time < 100);
+        if (recentPoints.length < 2) {
+            const last = history[history.length - 1];
+            const prev = history[history.length - 2];
+            const dt = Math.max(last.time - prev.time, 1);
+            return {
+                vx: ((last.x - prev.x) / dt) * 16,
+                vy: ((last.y - prev.y) / dt) * 16,
+            };
+        }
+        const first = recentPoints[0];
+        const last = recentPoints[recentPoints.length - 1];
+        const dt = Math.max(last.time - first.time, 1);
+        return {
+            vx: ((last.x - first.x) / dt) * 16,
+            vy: ((last.y - first.y) / dt) * 16,
+        };
+    }, []);
+    const determineEdge = useCallback((x, y) => {
+        const width = typeof window !== 'undefined' ? window.innerWidth : 800;
+        const height = typeof window !== 'undefined' ? window.innerHeight : 600;
+        const distToTop = y;
+        const distToLeft = x;
+        const distToRight = width - x;
+        const minDist = Math.min(distToTop, distToLeft, distToRight);
+        if (minDist === distToTop) {
+            const percent = Math.max(0, Math.min(1, x / width));
+            return { edge: 'top', percent };
+        }
+        else if (minDist === distToLeft) {
+            const percent = Math.max(0, Math.min(1, y / height));
+            return { edge: 'left', percent };
+        }
+        else {
+            const percent = Math.max(0, Math.min(1, y / height));
+            return { edge: 'right', percent };
+        }
+    }, []);
+    const runPhysicsLoop = useCallback((initialVx, initialVy) => {
+        let vx = initialVx;
+        let vy = initialVy;
+        let x = currentPosition.current.x;
+        let y = currentPosition.current.y;
+        const width = typeof window !== 'undefined' ? window.innerWidth : 800;
+        const height = typeof window !== 'undefined' ? window.innerHeight : 600;
+        const step = () => {
+            vx *= PHYSICS.friction;
+            vy *= PHYSICS.friction;
+            vy += PHYSICS.gravity;
+            x += vx;
+            y += vy;
+            let hitEdge = false;
+            if (x < edgePadding) {
+                x = edgePadding;
+                vx = -vx * PHYSICS.bounceDamping;
+                hitEdge = true;
+            }
+            else if (x > width - edgePadding) {
+                x = width - edgePadding;
+                vx = -vx * PHYSICS.bounceDamping;
+                hitEdge = true;
+            }
+            if (y < edgePadding) {
+                y = edgePadding;
+                vy = -vy * PHYSICS.bounceDamping;
+                hitEdge = true;
+            }
+            else if (y > height - edgePadding) {
+                y = height - edgePadding;
+                vy = -vy * PHYSICS.bounceDamping;
+                hitEdge = true;
+            }
+            currentPosition.current = { x, y };
+            onPositionUpdate({ x, y });
+            const speed = Math.sqrt(vx * vx + vy * vy);
+            if (speed < PHYSICS.minVelocity && hitEdge) {
+                animationFrameId.current = null;
+                const settlePosition = determineEdge(x, y);
+                onSettle(settlePosition);
+                return;
+            }
+            if (speed < PHYSICS.minVelocity * 0.1) {
+                animationFrameId.current = null;
+                const settlePosition = determineEdge(x, y);
+                onSettle(settlePosition);
+                return;
+            }
+            animationFrameId.current = requestAnimationFrame(step);
+        };
+        animationFrameId.current = requestAnimationFrame(step);
+    }, [edgePadding, onPositionUpdate, onSettle, determineEdge]);
+    const startDrag = useCallback((e) => {
+        if (animationFrameId.current) {
+            cancelAnimationFrame(animationFrameId.current);
+            animationFrameId.current = null;
+        }
+        setIsDragging(true);
+        velocityHistory.current = [];
+        const point = {
+            x: e.clientX,
+            y: e.clientY,
+            time: performance.now(),
+        };
+        velocityHistory.current.push(point);
+        currentPosition.current = { x: e.clientX, y: e.clientY };
+        e.target.setPointerCapture(e.pointerId);
+    }, []);
+    const onPointerMove = useCallback((e) => {
+        if (!isDragging)
+            return;
+        const point = {
+            x: e.clientX,
+            y: e.clientY,
+            time: performance.now(),
+        };
+        velocityHistory.current.push(point);
+        if (velocityHistory.current.length > 5) {
+            velocityHistory.current.shift();
+        }
+        currentPosition.current = { x: e.clientX, y: e.clientY };
+        onPositionUpdate({ x: e.clientX, y: e.clientY });
+    }, [isDragging, onPositionUpdate]);
+    const endDrag = useCallback((e) => {
+        if (!isDragging)
+            return;
+        setIsDragging(false);
+        e.target.releasePointerCapture(e.pointerId);
+        const { vx, vy } = calculateVelocity();
+        if (Math.abs(vx) < PHYSICS.minVelocity && Math.abs(vy) < PHYSICS.minVelocity) {
+            const settlePosition = determineEdge(currentPosition.current.x, currentPosition.current.y);
+            onSettle(settlePosition);
+            return;
+        }
+        runPhysicsLoop(vx, vy);
+    }, [isDragging, calculateVelocity, determineEdge, onSettle, runPhysicsLoop]);
+    return {
+        isDragging,
+        startDrag,
+        onPointerMove,
+        endDrag,
+    };
+}

package/dist/primitives/three/SpatialWorkspace/CyntraWorkspace.d.ts

@@ -0,0 +1,8 @@
+import { type CyntraKernelStatus } from "./adapters";
+export interface CyntraWorkspaceProps {
+    status: CyntraKernelStatus;
+    selectedIds?: string[];
+    onSelectionChange?: (ids: string[]) => void;
+}
+export declare function CyntraWorkspace({ status, selectedIds, onSelectionChange, }: CyntraWorkspaceProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=CyntraWorkspace.d.ts.map

package/dist/primitives/three/SpatialWorkspace/CyntraWorkspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CyntraWorkspace.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/SpatialWorkspace/CyntraWorkspace.tsx"],"names":[],"mappings":"AAYA,OAAO,EAAyB,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE5E,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,iBAAiB,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;CAC7C;AAED,wBAAgB,eAAe,CAAC,EAC9B,MAAM,EACN,WAAgB,EAChB,iBAAiB,GAClB,EAAE,oBAAoB,2CA2DtB"}

package/dist/primitives/three/SpatialWorkspace/CyntraWorkspace.js

@@ -0,0 +1,54 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * CyntraWorkspace - 3D visualization of Cyntra kernel status
+ *
+ * Renders kernel, workcells, and active runs as CrystallineOrganisms
+ * using the OrganismLattice layout system.
+ */
+import * as React from "react";
+import { OrganismLattice } from "../CrystallineOrganism";
+import { cyntraWorkcellAdapter } from "./adapters";
+export function CyntraWorkspace({ status, selectedIds = [], onSelectionChange, }) {
+    // Build organism tree: kernel at root, workcells as children
+    const { organisms, edges } = React.useMemo(() => {
+        const workcellOrganisms = status.workcells.map((wc) => cyntraWorkcellAdapter.toOrganism(wc));
+        // Kernel is the root organism with workcells as children
+        const kernelOrganism = {
+            id: "kernel",
+            type: "kernel",
+            label: `Kernel`,
+            state: status.active_runs > 0 ? "busy" : "idle",
+            power: status.active_runs > 2 ? "elevated" : "standard",
+            children: workcellOrganisms,
+        };
+        // Create hierarchy edges from kernel to each workcell
+        const hierarchyEdges = status.workcells.map((wc) => ({
+            id: `kernel-${wc.id}`,
+            source: "kernel",
+            target: wc.id,
+            type: "hierarchy",
+            strength: 0.5,
+            bidirectional: false,
+        }));
+        // Create data-flow edges between active workcells
+        const activeWorkcells = status.workcells.filter((wc) => wc.state === "running");
+        const dataFlowEdges = [];
+        for (let i = 0; i < activeWorkcells.length - 1; i++) {
+            dataFlowEdges.push({
+                id: `flow-${activeWorkcells[i].id}-${activeWorkcells[i + 1].id}`,
+                source: activeWorkcells[i].id,
+                target: activeWorkcells[i + 1].id,
+                type: "data-flow",
+                strength: 0.3,
+                bidirectional: true,
+            });
+        }
+        return {
+            organisms: [kernelOrganism],
+            edges: [...hierarchyEdges, ...dataFlowEdges],
+        };
+    }, [status]);
+    const [sprawlStack, setSprawlStack] = React.useState([]);
+    return (_jsx(OrganismLattice, { organisms: organisms, edges: edges, layout: "hex-grid", sprawlStack: sprawlStack, onSprawlChange: setSprawlStack, onSelectionChange: onSelectionChange }));
+}

package/dist/primitives/three/SpatialWorkspace/JobCluster.d.ts

@@ -0,0 +1,3 @@
+import type { JobClusterProps } from "./types";
+export declare function JobCluster({ jobs, selectedIds, hoveredId, onJobClick, onJobHover, position, onTopologyChange, }: JobClusterProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=JobCluster.d.ts.map

package/dist/primitives/three/SpatialWorkspace/JobCluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JobCluster.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/SpatialWorkspace/JobCluster.tsx"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAqG/C,wBAAgB,UAAU,CAAC,EACzB,IAAI,EACJ,WAAgB,EAChB,SAAgB,EAChB,UAAU,EACV,UAAU,EACV,QAAoB,EACpB,gBAAgB,GACjB,EAAE,eAAe,2CA4JjB"}

package/dist/primitives/three/SpatialWorkspace/JobCluster.js

@@ -0,0 +1,126 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * JobCluster - 3D visualization of jobs grouped by status
+ *
+ * Jobs are displayed as CrystallineOrganism primitives (tetrahedrons) in orbital
+ * clusters around a central point, with running jobs at the center and other
+ * statuses orbiting around them.
+ */
+import * as React from "react";
+import { useFrame } from "@react-three/fiber";
+import * as THREE from "three";
+import { JOB_VISUALS } from "./types";
+import { CrystallineOrganism } from "../CrystallineOrganism";
+import { jobAdapter } from "./adapters";
+function JobNode({ job, position, isSelected, isHovered, onClick, onHover }) {
+    // Convert job to organism props using the adapter
+    const organismProps = jobAdapter.toOrganism(job);
+    return (_jsx(CrystallineOrganism, { ...organismProps, position: [position.x, position.y, position.z], selected: isSelected, hovered: isHovered, onSelect: () => onClick(), onHover: (id) => onHover(id !== null) }));
+}
+function StatusCluster({ jobs, status, centerPosition, orbitRadius, selectedIds, hoveredId, onJobClick, onJobHover, }) {
+    const groupRef = React.useRef(null);
+    // Slowly rotate non-running clusters
+    useFrame((state) => {
+        if (groupRef.current && status !== "running") {
+            groupRef.current.rotation.y = state.clock.elapsedTime * 0.1;
+        }
+    });
+    // Calculate positions in a circular arrangement
+    const positions = React.useMemo(() => {
+        return jobs.map((_, index) => {
+            const angle = (index / Math.max(jobs.length, 1)) * Math.PI * 2;
+            const radius = jobs.length === 1 ? 0 : orbitRadius * 0.3;
+            return new THREE.Vector3(Math.cos(angle) * radius, 0, Math.sin(angle) * radius);
+        });
+    }, [jobs.length, orbitRadius]);
+    return (_jsx("group", { ref: groupRef, position: centerPosition, children: jobs.map((job, index) => (_jsx(JobNode, { job: job, position: positions[index], isSelected: selectedIds.includes(job.id), isHovered: hoveredId === job.id, onClick: () => onJobClick(job), onHover: (hovered) => onJobHover(hovered ? job : null) }, job.id))) }));
+}
+// -----------------------------------------------------------------------------
+// Job Cluster Container
+// -----------------------------------------------------------------------------
+export function JobCluster({ jobs, selectedIds = [], hoveredId = null, onJobClick, onJobHover, position = [0, 0, 0], onTopologyChange, }) {
+    // Group jobs by status
+    const jobsByStatus = React.useMemo(() => {
+        const grouped = {
+            queued: [],
+            running: [],
+            completed: [],
+            blocked: [],
+            quarantine: [],
+        };
+        jobs.forEach((job) => {
+            if (grouped[job.status]) {
+                grouped[job.status].push(job);
+            }
+        });
+        return grouped;
+    }, [jobs]);
+    const clusterConfig = React.useMemo(() => ({
+        running: { angle: 0, distance: 0, height: 0 }, // Center
+        queued: { angle: -Math.PI / 4, distance: 2.5, height: 0.5 },
+        completed: { angle: Math.PI / 4, distance: 2.5, height: 0.5 },
+        blocked: { angle: -3 * Math.PI / 4, distance: 2.5, height: -0.5 },
+        quarantine: { angle: 3 * Math.PI / 4, distance: 2.5, height: -0.5 },
+    }), []);
+    const topologySlice = React.useMemo(() => {
+        const nodes = Object.entries(jobsByStatus).flatMap(([status, statusJobs]) => {
+            if (statusJobs.length === 0)
+                return [];
+            const config = clusterConfig[status];
+            const centerPos = new THREE.Vector3(Math.cos(config.angle) * config.distance, config.height, Math.sin(config.angle) * config.distance);
+            const orbitRadius = 1.5;
+            const radiusScale = statusJobs.length === 1 ? 0 : orbitRadius * 0.3;
+            return statusJobs.map((job, index) => {
+                const angle = (index / Math.max(statusJobs.length, 1)) * Math.PI * 2;
+                const localPos = new THREE.Vector3(Math.cos(angle) * radiusScale, 0, Math.sin(angle) * radiusScale);
+                const worldPos = new THREE.Vector3(position[0], position[1], position[2])
+                    .add(centerPos)
+                    .add(localPos);
+                const visual = JOB_VISUALS[job.status];
+                return {
+                    id: job.id,
+                    type: "job",
+                    label: job.type,
+                    position: [worldPos.x, worldPos.y, worldPos.z],
+                    radius: visual.size ?? 0.3,
+                    color: visual.color,
+                    meta: { status: job.status, jobType: job.type },
+                };
+            });
+        });
+        return { nodes };
+    }, [jobsByStatus, clusterConfig, position]);
+    React.useEffect(() => {
+        if (!onTopologyChange)
+            return;
+        onTopologyChange(topologySlice);
+    }, [onTopologyChange, topologySlice]);
+    // Memoize connection geometries to avoid creating new BufferGeometry on every render
+    const connectionGeometries = React.useMemo(() => {
+        const geometries = new Map();
+        if (jobsByStatus.running.length === 0)
+            return geometries;
+        ["queued", "completed", "blocked", "quarantine"].forEach((status) => {
+            if (jobsByStatus[status].length === 0)
+                return;
+            const config = clusterConfig[status];
+            const endPos = new THREE.Vector3(Math.cos(config.angle) * config.distance * 0.8, config.height * 0.8, Math.sin(config.angle) * config.distance * 0.8);
+            const points = [new THREE.Vector3(0, 0, 0), endPos];
+            geometries.set(status, new THREE.BufferGeometry().setFromPoints(points));
+        });
+        return geometries;
+    }, [jobsByStatus, clusterConfig]);
+    return (_jsxs("group", { position: position, children: [Object.entries(jobsByStatus).map(([status, statusJobs]) => {
+                if (statusJobs.length === 0)
+                    return null;
+                const config = clusterConfig[status];
+                const centerPos = new THREE.Vector3(Math.cos(config.angle) * config.distance, config.height, Math.sin(config.angle) * config.distance);
+                return (_jsx(StatusCluster, { jobs: statusJobs, status: status, centerPosition: centerPos, orbitRadius: 1.5, selectedIds: selectedIds, hoveredId: hoveredId, onJobClick: onJobClick || (() => { }), onJobHover: onJobHover || (() => { }) }, status));
+            }), jobsByStatus.running.length > 0 && (_jsx("group", { children: ["queued", "completed", "blocked", "quarantine"].map((status) => {
+                    const lineGeometry = connectionGeometries.get(status);
+                    if (!lineGeometry)
+                        return null;
+                    return (_jsxs("line", { children: [_jsx("primitive", { object: lineGeometry, attach: "geometry" }), _jsx("lineBasicMaterial", { color: JOB_VISUALS[status].color, transparent: true, opacity: 0.2 })] }, `line-${status}`));
+                }) }))] }));
+}

package/dist/primitives/three/SpatialWorkspace/NodeGraph.d.ts

@@ -0,0 +1,3 @@
+import type { NodeGraphProps } from "./types";
+export declare function NodeGraph({ nodes, selectedIds, hoveredId, onNodeClick, onNodeHover, showConnections, position, onTopologyChange, }: NodeGraphProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=NodeGraph.d.ts.map

package/dist/primitives/three/SpatialWorkspace/NodeGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeGraph.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/SpatialWorkspace/NodeGraph.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AA+C9C,wBAAgB,SAAS,CAAC,EACxB,KAAK,EACL,WAAgB,EAChB,SAAgB,EAChB,WAAW,EACX,WAAW,EACX,eAAsB,EACtB,QAAoB,EACpB,gBAAgB,GACjB,EAAE,cAAc,2CAsKhB"}

package/dist/primitives/three/SpatialWorkspace/NodeGraph.js

@@ -0,0 +1,154 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * NodeGraph - 3D visualization of network nodes
+ *
+ * Operator, fab, verifier, and relay nodes displayed as CrystallineOrganisms
+ * with emotion-driven visuals based on node status and trust tier.
+ */
+import * as React from "react";
+import * as THREE from "three";
+import { NODE_VISUALS } from "./types";
+import { CrystallineOrganism } from "../CrystallineOrganism";
+import { nodeAdapter } from "./adapters";
+// Deterministic hash function for stable positioning
+function hashCode(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        hash = ((hash << 5) - hash) + str.charCodeAt(i);
+        hash |= 0; // Convert to 32bit integer
+    }
+    return hash;
+}
+function NetworkNode({ node, position, isSelected, isHovered, onClick, onHover }) {
+    // Convert node to CrystallineOrganism props via adapter
+    const organismProps = nodeAdapter.toOrganism(node);
+    return (_jsx(CrystallineOrganism, { ...organismProps, position: [position.x, position.y, position.z], selected: isSelected, hovered: isHovered, onSelect: () => onClick(), onHover: (id) => onHover(id !== null) }));
+}
+// -----------------------------------------------------------------------------
+// Node Graph Container
+// -----------------------------------------------------------------------------
+export function NodeGraph({ nodes, selectedIds = [], hoveredId = null, onNodeClick, onNodeHover, showConnections = true, position = [0, 0, 0], onTopologyChange, }) {
+    // Calculate node positions based on type clusters
+    const nodePositions = React.useMemo(() => {
+        const positions = new Map();
+        // Group by type
+        const byType = {
+            operator: [],
+            fab: [],
+            verifier: [],
+            relay: [],
+        };
+        nodes.forEach((node) => {
+            if (byType[node.type]) {
+                byType[node.type].push(node);
+            }
+        });
+        // Position each type cluster
+        const typeConfig = {
+            operator: { angle: 0, distance: 2 },
+            fab: { angle: Math.PI / 2, distance: 2 },
+            verifier: { angle: Math.PI, distance: 2 },
+            relay: { angle: -Math.PI / 2, distance: 2 },
+        };
+        Object.entries(byType).forEach(([type, typeNodes]) => {
+            const config = typeConfig[type];
+            const baseX = Math.cos(config.angle) * config.distance;
+            const baseZ = Math.sin(config.angle) * config.distance;
+            typeNodes.forEach((node, index) => {
+                // Spread nodes within cluster
+                const clusterAngle = (index / Math.max(typeNodes.length, 1)) * Math.PI * 2;
+                const clusterRadius = typeNodes.length > 1 ? 0.8 : 0;
+                const x = baseX + Math.cos(clusterAngle) * clusterRadius;
+                const z = baseZ + Math.sin(clusterAngle) * clusterRadius;
+                const y = ((hashCode(node.id) % 100) / 100 - 0.5) * 0.5;
+                positions.set(node.id, new THREE.Vector3(x, y, z));
+            });
+        });
+        return positions;
+    }, [nodes]);
+    // Generate connection lines between nodes that share capabilities
+    const connections = React.useMemo(() => {
+        if (!showConnections)
+            return [];
+        const lines = [];
+        // Create connections between operators and their associated nodes
+        nodes.forEach((node) => {
+            if (node.type === "operator") {
+                // Connect to verifiers and fab nodes
+                nodes.forEach((other) => {
+                    if (other.id !== node.id && (other.type === "verifier" || other.type === "fab")) {
+                        // Check if they share capabilities
+                        const sharedCaps = node.capabilities.filter((cap) => other.capabilities.includes(cap));
+                        if (sharedCaps.length > 0) {
+                            lines.push({
+                                from: node.id,
+                                to: other.id,
+                                color: NODE_VISUALS[other.type].color,
+                            });
+                        }
+                    }
+                });
+            }
+        });
+        return lines;
+    }, [nodes, showConnections]);
+    // Memoize connection geometries to avoid creating new BufferGeometry on every render
+    const connectionGeometries = React.useMemo(() => {
+        const geometries = new Map();
+        connections.forEach((conn, index) => {
+            const fromPos = nodePositions.get(conn.from);
+            const toPos = nodePositions.get(conn.to);
+            if (!fromPos || !toPos)
+                return;
+            const points = [fromPos, toPos];
+            geometries.set(`conn-${index}`, new THREE.BufferGeometry().setFromPoints(points));
+        });
+        return geometries;
+    }, [connections, nodePositions]);
+    const topologySlice = React.useMemo(() => {
+        const base = new THREE.Vector3(position[0], position[1], position[2]);
+        const topologyNodes = nodes.map((node) => {
+            const pos = nodePositions.get(node.id) ?? new THREE.Vector3();
+            const worldPos = base.clone().add(pos);
+            const visual = NODE_VISUALS[node.type];
+            return {
+                id: node.id,
+                type: "node",
+                label: node.type,
+                position: [worldPos.x, worldPos.y, worldPos.z],
+                radius: visual.size ?? 0.3,
+                color: visual.color,
+                meta: {
+                    nodeType: node.type,
+                    status: node.status,
+                    trustTier: node.trust_tier,
+                },
+            };
+        });
+        const topologyEdges = connections.map((conn, index) => ({
+            id: `node-conn-${index}`,
+            from: conn.from,
+            to: conn.to,
+            type: "capability-link",
+            color: conn.color,
+        }));
+        return { nodes: topologyNodes, edges: topologyEdges };
+    }, [nodes, nodePositions, connections, position]);
+    React.useEffect(() => {
+        if (!onTopologyChange)
+            return;
+        onTopologyChange(topologySlice);
+    }, [onTopologyChange, topologySlice]);
+    return (_jsxs("group", { position: position, children: [connections.map((conn, index) => {
+                const lineGeometry = connectionGeometries.get(`conn-${index}`);
+                if (!lineGeometry)
+                    return null;
+                return (_jsxs("line", { children: [_jsx("primitive", { object: lineGeometry, attach: "geometry" }), _jsx("lineBasicMaterial", { color: conn.color, transparent: true, opacity: 0.15 })] }, `conn-${index}`));
+            }), nodes.map((node) => {
+                const pos = nodePositions.get(node.id);
+                if (!pos)
+                    return null;
+                return (_jsx(NetworkNode, { node: node, position: pos, isSelected: selectedIds.includes(node.id), isHovered: hoveredId === node.id, onClick: () => onNodeClick?.(node), onHover: (hovered) => onNodeHover?.(hovered ? node : null) }, node.id));
+            })] }));
+}

package/dist/primitives/three/SpatialWorkspace/ReceiptOrbit.d.ts

@@ -0,0 +1,3 @@
+import type { ReceiptOrbitProps } from "./types";
+export declare function ReceiptOrbit({ receipts, parentPosition, orbitRadius, selectedIds, hoveredId, onReceiptClick, onReceiptHover, onTopologyChange, origin, }: ReceiptOrbitProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=ReceiptOrbit.d.ts.map

package/dist/primitives/three/SpatialWorkspace/ReceiptOrbit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReceiptOrbit.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/SpatialWorkspace/ReceiptOrbit.tsx"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,SAAS,CAAC;AAyMhE,wBAAgB,YAAY,CAAC,EAC3B,QAAQ,EACR,cAAc,EACd,WAAiB,EACjB,WAAgB,EAChB,SAAgB,EAChB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,MAAkB,GACnB,EAAE,iBAAiB,kDA0InB"}