@backbay/glia 0.2.0-alpha.1

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

@@ -0,0 +1,170 @@
+/**
+ * SpatialWorkspace Types
+ *
+ * Types for the 3D spatial visualization of Backbay entities.
+ */
+/** Visual mapping for job statuses */
+export const JOB_VISUALS = {
+    queued: {
+        color: "#00f0ff",
+        opacity: 0.4,
+        pulse: false,
+        icon: "circle-dashed",
+        shape: "sphere",
+        size: 0.3,
+    },
+    running: {
+        color: "#00f0ff",
+        opacity: 1.0,
+        pulse: true,
+        icon: "loader",
+        shape: "sphere",
+        size: 0.4,
+        emissive: "#00f0ff",
+        emissiveIntensity: 0.3,
+    },
+    completed: {
+        color: "#00ff88",
+        opacity: 0.8,
+        pulse: false,
+        icon: "check",
+        shape: "sphere",
+        size: 0.35,
+    },
+    blocked: {
+        color: "#ffaa00",
+        opacity: 0.9,
+        pulse: true,
+        icon: "alert-triangle",
+        shape: "sphere",
+        size: 0.35,
+        emissive: "#ffaa00",
+        emissiveIntensity: 0.2,
+    },
+    quarantine: {
+        color: "#ff0055",
+        opacity: 1.0,
+        pulse: true,
+        icon: "shield-x",
+        shape: "sphere",
+        size: 0.35,
+        emissive: "#ff0055",
+        emissiveIntensity: 0.4,
+    },
+};
+/** Visual mapping for node types */
+export const NODE_VISUALS = {
+    operator: {
+        color: "#00f0ff",
+        opacity: 1.0,
+        pulse: false,
+        icon: "cpu",
+        shape: "octahedron",
+        size: 0.4,
+    },
+    fab: {
+        color: "#ff00aa",
+        opacity: 1.0,
+        pulse: false,
+        icon: "box",
+        shape: "box",
+        size: 0.35,
+    },
+    verifier: {
+        color: "#00ff88",
+        opacity: 1.0,
+        pulse: false,
+        icon: "shield-check",
+        shape: "icosahedron",
+        size: 0.3,
+    },
+    relay: {
+        color: "#ffaa00",
+        opacity: 1.0,
+        pulse: false,
+        icon: "radio",
+        shape: "torus",
+        size: 0.25,
+    },
+};
+/** Status-based opacity modifiers */
+export const NODE_STATUS_MODIFIERS = {
+    online: { opacity: 1.0, pulse: false },
+    degraded: { opacity: 0.7, pulse: true },
+    offline: { opacity: 0.3, pulse: false },
+};
+/** Visual mapping for receipt statuses */
+export const RECEIPT_VISUALS = {
+    pending: {
+        color: "#00f0ff",
+        opacity: 0.3,
+        pulse: false,
+        icon: "clock",
+        shape: "ring",
+        size: 0.15,
+    },
+    passed: {
+        color: "#00ff88",
+        opacity: 1.0,
+        pulse: false,
+        icon: "check-circle",
+        shape: "ring",
+        size: 0.18,
+        emissive: "#00ff88",
+        emissiveIntensity: 0.2,
+    },
+    failed: {
+        color: "#ff0055",
+        opacity: 1.0,
+        pulse: true,
+        icon: "x-circle",
+        shape: "ring",
+        size: 0.18,
+        emissive: "#ff0055",
+        emissiveIntensity: 0.3,
+    },
+};
+/** Trust tier ring configuration */
+export const TRUST_RING_CONFIG = {
+    bronze: { radius: 2.0, color: "#cd7f32", metalness: 0.6, roughness: 0.4 },
+    silver: { radius: 3.5, color: "#c0c0c0", metalness: 0.8, roughness: 0.2 },
+    gold: { radius: 5.0, color: "#ffd700", metalness: 0.9, roughness: 0.1 },
+};
+export function getDisputeSeverity(dispute) {
+    const ageMs = Date.now() - new Date(dispute.opened_at).getTime();
+    const ageHours = ageMs / (1000 * 60 * 60);
+    if (ageHours < 24)
+        return "low";
+    if (ageHours < 72)
+        return "medium";
+    return "high";
+}
+/** Visual mapping for dispute severity */
+export const DISPUTE_SEVERITY_VISUALS = {
+    low: { color: "#ffaa00", pulseSpeed: 1.0, size: 0.2 },
+    medium: { color: "#ff5500", pulseSpeed: 1.5, size: 0.25 },
+    high: { color: "#ff0055", pulseSpeed: 2.0, size: 0.3 },
+};
+// -----------------------------------------------------------------------------
+// Default Configuration
+// -----------------------------------------------------------------------------
+export const DEFAULT_WORKSPACE_CONFIG = {
+    layout: "clustered",
+    autoRotate: true,
+    enableZoom: true,
+    enablePan: true,
+    layoutOptions: {
+        animate: true,
+        animationDuration: 500,
+        forceStrength: 0.5,
+        repulsion: 100,
+        gravity: 0.1,
+    },
+    filters: {
+        showJobs: true,
+        showNodes: true,
+        showReceipts: true,
+        showDisputes: true,
+        showTrustRings: true,
+    },
+};

package/dist/primitives/three/ThreatRadar/ThreatRadar.d.ts

@@ -0,0 +1,12 @@
+import { ThreatRadarProps } from "./types";
+/**
+ * ThreatRadar - A 3D radar visualization for security threat monitoring
+ *
+ * Displays threats as pulsing dots on a rotating radar dish with a sweep line
+ * that illuminates threats as it passes over them.
+ */
+export declare function ThreatRadar({ threats, scanSpeed, radius, position, showLabels, onThreatClick, onThreatHover, sweepColor, gridColor, showStats, enableGlow, rotation, }: ThreatRadarProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ThreatRadar {
+    var displayName: string;
+}
+//# sourceMappingURL=ThreatRadar.d.ts.map

package/dist/primitives/three/ThreatRadar/ThreatRadar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreatRadar.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/ThreatRadar/ThreatRadar.tsx"],"names":[],"mappings":"AAMA,OAAO,EAGL,gBAAgB,EAGjB,MAAM,SAAS,CAAC;AA2LjB;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,EAC1B,OAAO,EACP,SAAe,EACf,MAAU,EACV,QAAoB,EACpB,UAAkB,EAClB,aAAa,EACb,aAAa,EACb,UAAsB,EACtB,SAAqB,EACrB,SAAgB,EAChB,UAAiB,EACjB,QAAoB,GACrB,EAAE,gBAAgB,2CAiUlB;yBA9Ue,WAAW"}

package/dist/primitives/three/ThreatRadar/ThreatRadar.js

@@ -0,0 +1,223 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { useFrame } from "@react-three/fiber";
+import { Html, Line } from "@react-three/drei";
+import * as THREE from "three";
+import { THREAT_TYPE_COLORS, THREAT_TYPE_LABELS, } from "./types";
+/**
+ * Calculates the glow intensity based on whether the sweep recently passed
+ */
+function getSweepGlowIntensity(threatAngle, sweepAngle, falloffRange = Math.PI / 3) {
+    // Normalize angles to 0-2π
+    const normalizedThreat = ((threatAngle % (Math.PI * 2)) + Math.PI * 2) % (Math.PI * 2);
+    const normalizedSweep = ((sweepAngle % (Math.PI * 2)) + Math.PI * 2) % (Math.PI * 2);
+    // Calculate angular distance (accounting for wrap-around)
+    let diff = normalizedSweep - normalizedThreat;
+    if (diff < 0)
+        diff += Math.PI * 2;
+    // Glow fades as sweep moves away
+    if (diff < falloffRange) {
+        return 1 - diff / falloffRange;
+    }
+    return 0;
+}
+/**
+ * Individual threat indicator dot
+ */
+function ThreatDot({ threat, radarRadius, showLabel, sweepAngle, onThreatClick, onThreatHover, }) {
+    const meshRef = React.useRef(null);
+    const ringRef = React.useRef(null);
+    const [isHovered, setIsHovered] = React.useState(false);
+    // Position from polar coordinates
+    const x = Math.cos(threat.angle) * threat.distance * radarRadius;
+    const z = Math.sin(threat.angle) * threat.distance * radarRadius;
+    // Base color from threat type
+    const typeColor = new THREE.Color(THREAT_TYPE_COLORS[threat.type]);
+    // Lerp toward red based on severity
+    const finalColor = new THREE.Color().lerpColors(new THREE.Color("#22ff44"), typeColor, threat.severity);
+    // Size scales with severity
+    const baseSize = 0.04 + threat.severity * 0.08;
+    const size = isHovered ? baseSize * 1.3 : baseSize;
+    // Sweep glow effect
+    const sweepGlow = getSweepGlowIntensity(threat.angle, sweepAngle);
+    useFrame((state) => {
+        if (!meshRef.current)
+            return;
+        const t = state.clock.elapsedTime;
+        const pulseSpeed = threat.active ? 6 : 1.5;
+        const pulseAmount = threat.active ? 0.25 : 0.1;
+        // Pulsing scale
+        const scale = 1 + Math.sin(t * pulseSpeed) * pulseAmount;
+        meshRef.current.scale.setScalar(scale);
+        // Update emissive based on sweep proximity
+        const material = meshRef.current.material;
+        if (material) {
+            const baseEmissive = threat.active ? 0.8 : 0.4;
+            material.emissiveIntensity = baseEmissive + sweepGlow * 0.6;
+        }
+        // Animate warning ring for active threats
+        if (ringRef.current && threat.active) {
+            const ringScale = 1.5 + Math.sin(t * 3) * 0.3;
+            ringRef.current.scale.setScalar(ringScale);
+            const ringMat = ringRef.current.material;
+            if (ringMat) {
+                ringMat.opacity = 0.15 + Math.sin(t * 3) * 0.1;
+            }
+        }
+    });
+    const handlePointerEnter = React.useCallback((e) => {
+        e.stopPropagation();
+        setIsHovered(true);
+        onThreatHover?.(threat);
+        document.body.style.cursor = "pointer";
+    }, [threat, onThreatHover]);
+    const handlePointerLeave = React.useCallback(() => {
+        setIsHovered(false);
+        onThreatHover?.(null);
+        document.body.style.cursor = "auto";
+    }, [onThreatHover]);
+    const handleClick = React.useCallback((e) => {
+        e.stopPropagation();
+        onThreatClick?.(threat);
+    }, [threat, onThreatClick]);
+    return (_jsxs("group", { position: [x, 0.08, z], children: [_jsxs("mesh", { ref: meshRef, onPointerEnter: handlePointerEnter, onPointerLeave: handlePointerLeave, onClick: handleClick, children: [_jsx("sphereGeometry", { args: [size, 16, 16] }), _jsx("meshStandardMaterial", { color: finalColor, emissive: finalColor, emissiveIntensity: threat.active ? 0.8 : 0.4, transparent: true, opacity: 0.9 })] }), _jsxs("mesh", { scale: 1.8, children: [_jsx("sphereGeometry", { args: [size, 12, 12] }), _jsx("meshBasicMaterial", { color: finalColor, transparent: true, opacity: 0.15 + sweepGlow * 0.2 })] }), threat.active && (_jsxs("mesh", { ref: ringRef, rotation: [Math.PI / 2, 0, 0], children: [_jsx("ringGeometry", { args: [size * 1.8, size * 2.5, 24] }), _jsx("meshBasicMaterial", { color: finalColor, transparent: true, opacity: 0.2, side: THREE.DoubleSide })] })), (showLabel || isHovered) && (_jsx(Html, { position: [0, 0.25, 0], center: true, style: { pointerEvents: "none" }, children: _jsxs("div", { className: "whitespace-nowrap select-none", style: {
+                        background: "rgba(0, 0, 0, 0.85)",
+                        border: `1px solid ${finalColor.getStyle()}`,
+                        color: finalColor.getStyle(),
+                        fontSize: "10px",
+                        fontFamily: "monospace",
+                        fontWeight: 600,
+                        padding: "2px 6px",
+                        borderRadius: "3px",
+                        textShadow: `0 0 4px ${finalColor.getStyle()}`,
+                        boxShadow: `0 0 8px ${finalColor.getStyle()}40`,
+                    }, children: [THREAT_TYPE_LABELS[threat.type], threat.active && " [ACTIVE]"] }) }))] }));
+}
+/**
+ * ThreatRadar - A 3D radar visualization for security threat monitoring
+ *
+ * Displays threats as pulsing dots on a rotating radar dish with a sweep line
+ * that illuminates threats as it passes over them.
+ */
+export function ThreatRadar({ threats, scanSpeed = 0.5, radius = 3, position = [0, 0, 0], showLabels = false, onThreatClick, onThreatHover, sweepColor = "#00ff66", gridColor = "#00ff44", showStats = true, enableGlow = true, rotation = [0, 0, 0], }) {
+    const sweepRef = React.useRef(null);
+    const sweepAngleRef = React.useRef(0);
+    const [, forceUpdate] = React.useReducer((x) => x + 1, 0);
+    // Track sweep angle for threat glow effect
+    useFrame((_, delta) => {
+        if (!sweepRef.current)
+            return;
+        sweepAngleRef.current =
+            (sweepAngleRef.current + delta * scanSpeed * Math.PI * 2) % (Math.PI * 2);
+        sweepRef.current.rotation.y = -sweepAngleRef.current;
+        // Force re-render periodically for sweep glow updates
+        // This is throttled by React's batching
+        forceUpdate();
+    });
+    // Generate range ring points
+    const rangeRings = React.useMemo(() => {
+        return [0.25, 0.5, 0.75, 1.0].map((r) => {
+            const points = [];
+            const segments = 64;
+            for (let i = 0; i <= segments; i++) {
+                const a = (i / segments) * Math.PI * 2;
+                points.push([
+                    Math.cos(a) * r * radius,
+                    0,
+                    Math.sin(a) * r * radius,
+                ]);
+            }
+            return points;
+        });
+    }, [radius]);
+    // Generate polar grid lines
+    const gridLines = React.useMemo(() => {
+        return [0, 1, 2, 3, 4, 5].map((i) => {
+            const angle = (i / 6) * Math.PI;
+            return {
+                start: [-Math.cos(angle) * radius, 0, -Math.sin(angle) * radius],
+                end: [Math.cos(angle) * radius, 0, Math.sin(angle) * radius],
+            };
+        });
+    }, [radius]);
+    // Sweep trail geometry (pie slice)
+    const sweepTrailPoints = React.useMemo(() => {
+        const points = [];
+        const trailAngle = Math.PI / 4; // 45 degree trail
+        const segments = 32;
+        points.push(new THREE.Vector3(0, 0, 0));
+        for (let i = 0; i <= segments; i++) {
+            const a = (i / segments) * trailAngle;
+            points.push(new THREE.Vector3(Math.cos(a) * radius, 0, Math.sin(a) * radius));
+        }
+        return points;
+    }, [radius]);
+    const sweepTrailGeometry = React.useMemo(() => {
+        const shape = new THREE.Shape();
+        shape.moveTo(0, 0);
+        const trailAngle = Math.PI / 4;
+        const segments = 32;
+        for (let i = 0; i <= segments; i++) {
+            const a = (i / segments) * trailAngle;
+            shape.lineTo(Math.cos(a) * radius, Math.sin(a) * radius);
+        }
+        shape.closePath();
+        return new THREE.ShapeGeometry(shape);
+    }, [radius]);
+    // Count active threats
+    const activeCount = threats.filter((t) => t.active).length;
+    const criticalCount = threats.filter((t) => t.severity > 0.7).length;
+    return (_jsxs("group", { position: position, rotation: rotation, children: [_jsxs("mesh", { rotation: [Math.PI / 2, 0, 0], position: [0, -0.02, 0], children: [_jsx("circleGeometry", { args: [radius + 0.05, 64] }), _jsx("meshStandardMaterial", { color: "#0a0f0a", metalness: 0.3, roughness: 0.8 })] }), _jsxs("mesh", { rotation: [Math.PI / 2, 0, 0], position: [0, 0, 0], children: [_jsx("circleGeometry", { args: [radius, 64] }), _jsx("meshStandardMaterial", { color: "#061208", transparent: true, opacity: 0.95, metalness: 0.2, roughness: 0.9 })] }), rangeRings.map((points, i) => (_jsx(Line, { points: points, color: gridColor, lineWidth: 1, transparent: true, opacity: 0.25 + i * 0.05 }, `ring-${i}`))), gridLines.map((line, i) => (_jsx(Line, { points: [line.start, line.end], color: gridColor, lineWidth: 1, transparent: true, opacity: 0.15 }, `grid-${i}`))), _jsxs("group", { ref: sweepRef, children: [_jsx(Line, { points: [
+                            [0, 0.03, 0],
+                            [radius, 0.03, 0],
+                        ], color: sweepColor, lineWidth: 2.5 }), _jsxs("mesh", { rotation: [Math.PI / 2, 0, 0], position: [0, 0.015, 0], children: [_jsx("primitive", { object: sweepTrailGeometry, attach: "geometry" }), _jsx("meshBasicMaterial", { color: sweepColor, transparent: true, opacity: 0.12, side: THREE.DoubleSide })] }), enableGlow && (_jsxs("mesh", { rotation: [Math.PI / 2, 0, 0], position: [0, 0.01, 0], children: [_jsx("primitive", { object: sweepTrailGeometry.clone(), attach: "geometry" }), _jsx("meshBasicMaterial", { color: sweepColor, transparent: true, opacity: 0.06, side: THREE.DoubleSide })] }))] }), threats.map((threat) => (_jsx(ThreatDot, { threat: threat, radarRadius: radius, showLabel: showLabels, sweepAngle: sweepAngleRef.current, onThreatClick: onThreatClick, onThreatHover: onThreatHover }, threat.id))), _jsxs("group", { position: [0, 0.05, 0], children: [_jsxs("mesh", { children: [_jsx("sphereGeometry", { args: [0.06, 16, 16] }), _jsx("meshStandardMaterial", { color: sweepColor, emissive: sweepColor, emissiveIntensity: 0.6 })] }), enableGlow && (_jsxs("mesh", { scale: 2, children: [_jsx("sphereGeometry", { args: [0.06, 12, 12] }), _jsx("meshBasicMaterial", { color: sweepColor, transparent: true, opacity: 0.15 })] }))] }), ["N", "E", "S", "W"].map((dir, i) => {
+                const angle = (i * Math.PI) / 2;
+                const markerRadius = radius + 0.2;
+                return (_jsx(Html, { position: [
+                        Math.sin(angle) * markerRadius,
+                        0,
+                        -Math.cos(angle) * markerRadius,
+                    ], center: true, style: { pointerEvents: "none" }, children: _jsx("div", { style: {
+                            color: gridColor,
+                            fontSize: "10px",
+                            fontFamily: "monospace",
+                            fontWeight: 700,
+                            opacity: 0.5,
+                            textShadow: `0 0 4px ${gridColor}`,
+                        }, children: dir }) }, dir));
+            }), showStats && (_jsx(Html, { position: [0, 0.95, 0], center: true, style: { pointerEvents: "none" }, children: _jsxs("div", { style: {
+                        background: "rgba(2, 8, 6, 0.85)",
+                        border: `1px solid ${gridColor}50`,
+                        color: gridColor,
+                        fontSize: "10px",
+                        fontFamily: "'JetBrains Mono', 'SF Mono', monospace",
+                        lineHeight: "1.5",
+                        padding: "10px 16px",
+                        borderRadius: "6px",
+                        boxShadow: `0 0 16px ${gridColor}18, inset 0 0 14px ${gridColor}0f`,
+                        minWidth: "156px",
+                        backdropFilter: "blur(6px)",
+                    }, children: [_jsx("div", { style: {
+                                fontWeight: 700,
+                                fontSize: "11px",
+                                marginBottom: "8px",
+                                letterSpacing: "2px",
+                                borderBottom: `1px solid ${gridColor}40`,
+                                paddingBottom: "4px",
+                            }, children: "THREAT RADAR" }), _jsxs("div", { style: {
+                                display: "grid",
+                                gridTemplateColumns: "1fr auto",
+                                rowGap: "6px",
+                                columnGap: "10px",
+                            }, children: [_jsx("span", { style: { opacity: 0.55, textTransform: "uppercase", fontSize: "9px" }, children: "Contacts" }), _jsx("span", { style: { fontWeight: 700, fontSize: "11px" }, children: threats.length }), _jsx("span", { style: { opacity: 0.55, textTransform: "uppercase", fontSize: "9px" }, children: "Active" }), _jsx("span", { style: {
+                                        fontWeight: 700,
+                                        fontSize: "11px",
+                                        color: activeCount > 0 ? "#ff6644" : gridColor,
+                                    }, children: activeCount }), _jsx("span", { style: { opacity: 0.55, textTransform: "uppercase", fontSize: "9px" }, children: "Critical" }), _jsx("span", { style: {
+                                        fontWeight: 700,
+                                        fontSize: "11px",
+                                        color: criticalCount > 0 ? "#ff3344" : gridColor,
+                                    }, children: criticalCount })] })] }) })), enableGlow && (_jsxs("mesh", { rotation: [Math.PI / 2, 0, 0], position: [0, -0.01, 0], children: [_jsx("ringGeometry", { args: [radius - 0.02, radius + 0.04, 64] }), _jsx("meshBasicMaterial", { color: gridColor, transparent: true, opacity: 0.2, side: THREE.DoubleSide })] }))] }));
+}
+ThreatRadar.displayName = "ThreatRadar";

package/dist/primitives/three/ThreatRadar/index.d.ts

@@ -0,0 +1,4 @@
+export { ThreatRadar } from "./ThreatRadar";
+export type { Threat, ThreatType, ThreatRadarProps, ThreatDotProps, } from "./types";
+export { THREAT_TYPE_COLORS, THREAT_TYPE_LABELS } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/primitives/three/ThreatRadar/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/ThreatRadar/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EACV,MAAM,EACN,UAAU,EACV,gBAAgB,EAChB,cAAc,GACf,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC"}

package/dist/primitives/three/ThreatRadar/index.js

@@ -0,0 +1,2 @@
+export { ThreatRadar } from "./ThreatRadar";
+export { THREAT_TYPE_COLORS, THREAT_TYPE_LABELS } from "./types";

package/dist/primitives/three/ThreatRadar/types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Threat types detected by the radar system
+ */
+export type ThreatType = 'malware' | 'intrusion' | 'anomaly' | 'ddos' | 'phishing';
+/**
+ * Represents a single threat detected by the radar
+ */
+export interface Threat {
+    /** Unique identifier for the threat */
+    id: string;
+    /** Angle in radians (0-2π) - position around the radar */
+    angle: number;
+    /** Distance from center 0-1 (0=center, 1=edge) */
+    distance: number;
+    /** Severity level 0-1 (0=low, 1=critical) */
+    severity: number;
+    /** Classification of the threat */
+    type: ThreatType;
+    /** Whether the threat is actively attacking */
+    active: boolean;
+    /** Optional label for the threat */
+    label?: string;
+    /** Timestamp when threat was first detected */
+    detectedAt?: number;
+}
+/**
+ * Props for the ThreatRadar component
+ */
+export interface ThreatRadarProps {
+    /** List of detected threats to display */
+    threats: Threat[];
+    /** Radar scan speed in rotations per second (default: 0.5) */
+    scanSpeed?: number;
+    /** Radar radius in world units (default: 3) */
+    radius?: number;
+    /** Position of the radar in 3D space */
+    position?: [number, number, number];
+    /** Whether to show threat type labels (default: false) */
+    showLabels?: boolean;
+    /** Callback when a threat is clicked */
+    onThreatClick?: (threat: Threat) => void;
+    /** Callback when a threat is hovered */
+    onThreatHover?: (threat: Threat | null) => void;
+    /** Color of the radar sweep line and trail */
+    sweepColor?: string;
+    /** Color scheme for the radar grid */
+    gridColor?: string;
+    /** Whether to show the stats HUD (default: true) */
+    showStats?: boolean;
+    /** Enable ambient glow effects (default: true) */
+    enableGlow?: boolean;
+    /** Rotation offset for the entire radar */
+    rotation?: [number, number, number];
+}
+/**
+ * Internal props for the ThreatDot sub-component
+ */
+export interface ThreatDotProps {
+    threat: Threat;
+    radarRadius: number;
+    showLabel: boolean;
+    sweepAngle: number;
+    onThreatClick?: (threat: Threat) => void;
+    onThreatHover?: (threat: Threat | null) => void;
+}
+/**
+ * Color mapping for different threat types
+ */
+export declare const THREAT_TYPE_COLORS: Record<ThreatType, string>;
+/**
+ * Icons/labels for threat types
+ */
+export declare const THREAT_TYPE_LABELS: Record<ThreatType, string>;
+//# sourceMappingURL=types.d.ts.map

package/dist/primitives/three/ThreatRadar/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/ThreatRadar/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,GAAG,MAAM,GAAG,UAAU,CAAC;AAEnF;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,uCAAuC;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,mCAAmC;IACnC,IAAI,EAAE,UAAU,CAAC;IACjB,+CAA+C;IAC/C,MAAM,EAAE,OAAO,CAAC;IAChB,oCAAoC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,0CAA0C;IAC1C,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,8DAA8D;IAC9D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+CAA+C;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,0DAA0D;IAC1D,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,wCAAwC;IACxC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,wCAAwC;IACxC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IAChD,8CAA8C;IAC9C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oDAAoD;IACpD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,kDAAkD;IAClD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;CACjD;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAMzD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAMzD,CAAC"}

package/dist/primitives/three/ThreatRadar/types.js

@@ -0,0 +1,20 @@
+/**
+ * Color mapping for different threat types
+ */
+export const THREAT_TYPE_COLORS = {
+    malware: '#ff3344',
+    intrusion: '#ff6622',
+    anomaly: '#ffcc11',
+    ddos: '#ff0088',
+    phishing: '#aa44ff',
+};
+/**
+ * Icons/labels for threat types
+ */
+export const THREAT_TYPE_LABELS = {
+    malware: 'MALWARE',
+    intrusion: 'INTRUSION',
+    anomaly: 'ANOMALY',
+    ddos: 'DDoS',
+    phishing: 'PHISH',
+};

package/dist/primitives/three/index.d.ts

@@ -0,0 +1,22 @@
+export * from "./Graph3D/Graph3D";
+export * from "./Graph3D/types";
+export * from "./Graph3D/utils";
+export * from "./ParticleField";
+export * from "./AmbientField";
+export * from "./SpatialWorkspace";
+export * from "./AgentConsole";
+export * as Glyph from "./Glyph";
+export * as QuantumField from "./QuantumField";
+export * from "./Sentinel";
+export * from "./PermissionMatrix";
+export * from "./ThreatRadar";
+export * from "./NetworkTopology";
+export * from "./AttackGraph";
+export * from "./FirewallBarrier";
+export * from "./IntelFeed";
+export * from "./SOCCommandCenter";
+export * from "./SecurityShield";
+export * from "./AuditTrail";
+export * from "./SecurityDashboard";
+export * as CrystallineOrganism from "./CrystallineOrganism";
+//# sourceMappingURL=index.d.ts.map

package/dist/primitives/three/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/primitives/three/index.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AAIjC,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC;AAG/C,cAAc,YAAY,CAAC;AAG3B,cAAc,oBAAoB,CAAC;AAGnC,cAAc,eAAe,CAAC;AAG9B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,eAAe,CAAC;AAG9B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,aAAa,CAAC;AAG5B,cAAc,oBAAoB,CAAC;AAGnC,cAAc,kBAAkB,CAAC;AAGjC,cAAc,cAAc,CAAC;AAG7B,cAAc,qBAAqB,CAAC;AAIpC,OAAO,KAAK,mBAAmB,MAAM,uBAAuB,CAAC"}

package/dist/primitives/three/index.js

@@ -0,0 +1,37 @@
+// Three.js components
+export * from "./Graph3D/Graph3D";
+export * from "./Graph3D/types";
+export * from "./Graph3D/utils";
+export * from "./ParticleField";
+export * from "./AmbientField";
+export * from "./SpatialWorkspace";
+export * from "./AgentConsole";
+export * as Glyph from "./Glyph";
+// QuantumField - exported as namespace to avoid conflicts with AmbientField
+// (both have similar field primitives like FieldProvider, FieldConfig, etc.)
+export * as QuantumField from "./QuantumField";
+// Sentinel - floating orb UI component system
+export * from "./Sentinel";
+// PermissionMatrix - 3D permission grid visualization
+export * from "./PermissionMatrix";
+// ThreatRadar - 3D security threat radar visualization
+export * from "./ThreatRadar";
+// NetworkTopology - 3D network infrastructure visualization
+export * from "./NetworkTopology";
+// AttackGraph - MITRE ATT&CK chain visualization
+export * from "./AttackGraph";
+// FirewallBarrier - Firewall rule barrier visualization
+export * from "./FirewallBarrier";
+// IntelFeed - Real-time intelligence feed visualization
+export * from "./IntelFeed";
+// SOCCommandCenter - Composite SOC scene
+export * from "./SOCCommandCenter";
+// SecurityShield - 3D hexagonal force-field visualization
+export * from "./SecurityShield";
+// AuditTrail - 3D audit event timeline visualization
+export * from "./AuditTrail";
+// SecurityDashboard - Composite security monitoring dashboard
+export * from "./SecurityDashboard";
+// CrystallineOrganism - unified unit-of-work visualization
+// Export as namespace to avoid STATUS_COLORS conflict with SecurityShield
+export * as CrystallineOrganism from "./CrystallineOrganism";

package/dist/primitives/ui/alert-dialog.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+declare function AlertDialog({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogTrigger({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogPortal({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogOverlay({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Overlay>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogContent({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogFooter({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogTitle({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogDescription({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogAction({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Action>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogCancel({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Cancel>): import("react/jsx-runtime").JSX.Element;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };
+//# sourceMappingURL=alert-dialog.d.ts.map

package/dist/primitives/ui/alert-dialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alert-dialog.d.ts","sourceRoot":"","sources":["../../../src/primitives/ui/alert-dialog.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,oBAAoB,MAAM,8BAA8B,CAAC;AAKrE,iBAAS,WAAW,CAAC,EAAE,GAAG,KAAK,EAAE,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,IAAI,CAAC,2CAExF;AAED,iBAAS,kBAAkB,CAAC,EAC1B,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,OAAO,CAAC,2CAE3D;AAED,iBAAS,iBAAiB,CAAC,EAAE,GAAG,KAAK,EAAE,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,MAAM,CAAC,2CAEhG;AAED,iBAAS,kBAAkB,CAAC,EAC1B,SAAS,EACT,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,OAAO,CAAC,2CAW3D;AAED,iBAAS,kBAAkB,CAAC,EAC1B,SAAS,EACT,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,OAAO,CAAC,2CAc3D;AAED,iBAAS,iBAAiB,CAAC,EAAE,SAAS,EAAE,GAAG,KAAK,EAAE,EAAE,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC,2CAQ9E;AAED,iBAAS,iBAAiB,CAAC,EAAE,SAAS,EAAE,GAAG,KAAK,EAAE,EAAE,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC,2CAQ9E;AAED,iBAAS,gBAAgB,CAAC,EACxB,SAAS,EACT,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,KAAK,CAAC,2CAQzD;AAED,iBAAS,sBAAsB,CAAC,EAC9B,SAAS,EACT,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,WAAW,CAAC,2CAQ/D;AAED,iBAAS,iBAAiB,CAAC,EACzB,SAAS,EACT,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,MAAM,CAAC,2CAE1D;AAED,iBAAS,iBAAiB,CAAC,EACzB,SAAS,EACT,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,MAAM,CAAC,2CAO1D;AAED,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,sBAAsB,EACtB,iBAAiB,EACjB,iBAAiB,GAClB,CAAC"}

package/dist/primitives/ui/alert-dialog.js

@@ -0,0 +1,39 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+import { cn } from "../../lib/utils";
+import { buttonVariants } from "./button";
+function AlertDialog({ ...props }) {
+    return _jsx(AlertDialogPrimitive.Root, { "data-slot": "alert-dialog", ...props });
+}
+function AlertDialogTrigger({ ...props }) {
+    return _jsx(AlertDialogPrimitive.Trigger, { "data-slot": "alert-dialog-trigger", ...props });
+}
+function AlertDialogPortal({ ...props }) {
+    return _jsx(AlertDialogPrimitive.Portal, { "data-slot": "alert-dialog-portal", ...props });
+}
+function AlertDialogOverlay({ className, ...props }) {
+    return (_jsx(AlertDialogPrimitive.Overlay, { "data-slot": "alert-dialog-overlay", className: cn("data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50", className), ...props }));
+}
+function AlertDialogContent({ className, ...props }) {
+    return (_jsxs(AlertDialogPortal, { children: [_jsx(AlertDialogOverlay, {}), _jsx(AlertDialogPrimitive.Content, { "data-slot": "alert-dialog-content", className: cn("bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-50 grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border p-6 shadow-lg duration-200 sm:max-w-lg", className), ...props })] }));
+}
+function AlertDialogHeader({ className, ...props }) {
+    return (_jsx("div", { "data-slot": "alert-dialog-header", className: cn("flex flex-col gap-2 text-center sm:text-left", className), ...props }));
+}
+function AlertDialogFooter({ className, ...props }) {
+    return (_jsx("div", { "data-slot": "alert-dialog-footer", className: cn("flex flex-col-reverse gap-2 sm:flex-row sm:justify-end", className), ...props }));
+}
+function AlertDialogTitle({ className, ...props }) {
+    return (_jsx(AlertDialogPrimitive.Title, { "data-slot": "alert-dialog-title", className: cn("text-lg font-semibold", className), ...props }));
+}
+function AlertDialogDescription({ className, ...props }) {
+    return (_jsx(AlertDialogPrimitive.Description, { "data-slot": "alert-dialog-description", className: cn("text-muted-foreground text-sm", className), ...props }));
+}
+function AlertDialogAction({ className, ...props }) {
+    return _jsx(AlertDialogPrimitive.Action, { className: cn(buttonVariants(), className), ...props });
+}
+function AlertDialogCancel({ className, ...props }) {
+    return (_jsx(AlertDialogPrimitive.Cancel, { className: cn(buttonVariants({ variant: "outline" }), className), ...props }));
+}
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };