@backbay/glia 0.2.0-alpha.1

package/dist/primitives/three/IntelFeed/IntelFeed.js

@@ -0,0 +1,130 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { Html, RoundedBox } from "@react-three/drei";
+import { useFrame } from "@react-three/fiber";
+import { INTEL_SEVERITY_COLORS, INTEL_TYPE_LABELS, } from "./types";
+const SEVERITY_ORDER = {
+    info: 0,
+    low: 1,
+    medium: 2,
+    high: 3,
+    critical: 4,
+};
+const CARD_SIZE = [2.1, 0.85, 0.08];
+const CARD_WIDTH = CARD_SIZE[0];
+const CARD_HEIGHT = CARD_SIZE[1];
+function IntelCard({ item, position, onClick, autoScroll, scrollSpan, scrollSpeed, layout, index, }) {
+    const groupRef = React.useRef(null);
+    const [hovered, setHovered] = React.useState(false);
+    const showSummary = hovered || item.actionRequired;
+    const baseColor = INTEL_SEVERITY_COLORS[item.severity];
+    useFrame(({ clock }) => {
+        if (!groupRef.current || !autoScroll || layout !== "waterfall")
+            return;
+        const t = clock.elapsedTime * scrollSpeed + index * 0.3;
+        const offset = t % scrollSpan;
+        let nextY = position[1] - offset;
+        if (nextY < -scrollSpan / 2) {
+            nextY += scrollSpan;
+        }
+        groupRef.current.position.set(position[0], nextY, position[2]);
+    });
+    return (_jsxs("group", { ref: groupRef, position: position, children: [_jsx(RoundedBox, { args: CARD_SIZE, radius: 0.08, smoothness: 4, onClick: (event) => {
+                    event.stopPropagation();
+                    onClick?.(item);
+                }, onPointerOver: (event) => {
+                    event.stopPropagation();
+                    setHovered(true);
+                    document.body.style.cursor = "pointer";
+                }, onPointerOut: () => {
+                    setHovered(false);
+                    document.body.style.cursor = "auto";
+                }, children: _jsx("meshStandardMaterial", { color: "#0b1220", emissive: baseColor, emissiveIntensity: hovered ? 0.45 : 0.22, transparent: true, opacity: 0.82, roughness: 0.4, metalness: 0.3 }) }), _jsxs("mesh", { position: [0, 0, 0.05], children: [_jsx("planeGeometry", { args: [2.05, 0.78] }), _jsx("meshBasicMaterial", { color: baseColor, transparent: true, opacity: 0.12 })] }), _jsx(Html, { distanceFactor: 10, position: [-0.95, 0.22, 0.1], children: _jsxs("div", { className: "w-[150px] text-[9px] text-white/80", style: {
+                        fontFamily: "'JetBrains Mono', 'SF Mono', monospace",
+                        lineHeight: 1.5,
+                        letterSpacing: "0.02em",
+                    }, children: [_jsxs("div", { className: "flex items-center justify-between gap-2 uppercase", children: [_jsx("span", { className: "rounded bg-slate-900/80 px-1 py-0.5 text-[7px] font-semibold text-white/70", children: INTEL_TYPE_LABELS[item.type] }), _jsx("span", { className: "text-[7px] opacity-60", children: item.source })] }), _jsx("div", { className: "mt-1 text-[10px] font-semibold", children: item.title }), item.summary && showSummary && (_jsx("div", { className: "mt-0.5 text-[8px] opacity-60", children: item.summary }))] }) }), item.actionRequired && (_jsx(Html, { distanceFactor: 12, position: [0.92, 0.28, 0.12], children: _jsx("div", { className: "rounded bg-red-500/75 px-1.5 py-0.5 text-[7px] font-semibold text-white/90 uppercase tracking-[0.08em]", children: "ACTION" }) }))] }));
+}
+function filterItems(items, filterSeverity, filterSources, maxItems) {
+    let filtered = items.slice();
+    if (filterSeverity && filterSeverity.length > 0) {
+        filtered = filtered.filter((item) => filterSeverity.includes(item.severity));
+    }
+    if (filterSources && filterSources.length > 0) {
+        filtered = filtered.filter((item) => filterSources.includes(item.source));
+    }
+    filtered.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    if (maxItems) {
+        filtered = filtered.slice(0, maxItems);
+    }
+    return filtered;
+}
+export function IntelFeed({ items, sources, maxItems = 12, filterSeverity, filterSources, onItemClick, layout = "waterfall", autoScroll = true, bounds, position = [0, 0, 0], rotation = [0, 0, 0], }) {
+    const filteredItems = React.useMemo(() => filterItems(items, filterSeverity, filterSources, maxItems), [items, filterSeverity, filterSources, maxItems]);
+    const layoutPositions = React.useMemo(() => {
+        const safeWidth = Math.max(bounds?.width ?? 9.5, CARD_WIDTH + 0.6);
+        const safeHeight = Math.max(bounds?.height ?? 5.5, CARD_HEIGHT + 0.6);
+        if (layout === "grid") {
+            const maxColumns = Math.max(1, Math.floor(safeWidth / (CARD_WIDTH + 0.4)));
+            const columns = Math.max(1, Math.min(maxColumns, Math.ceil(Math.sqrt(filteredItems.length))));
+            const rows = Math.ceil(filteredItems.length / columns);
+            const spacingX = safeWidth / columns;
+            const spacingY = safeHeight / Math.max(1, rows);
+            return filteredItems.map((item, index) => {
+                const row = Math.floor(index / columns);
+                const col = index % columns;
+                return {
+                    item,
+                    position: [
+                        -safeWidth / 2 + spacingX / 2 + col * spacingX,
+                        safeHeight / 2 - spacingY / 2 - row * spacingY,
+                        0,
+                    ],
+                };
+            });
+        }
+        if (layout === "timeline") {
+            const timestamps = filteredItems.map((item) => item.timestamp.getTime());
+            const minTime = timestamps.length ? Math.min(...timestamps) : 0;
+            const maxTime = timestamps.length ? Math.max(...timestamps) : 1;
+            const range = Math.max(1, maxTime - minTime);
+            const width = safeWidth * 0.85;
+            const laneSpacing = safeHeight / 6;
+            return filteredItems.map((item, index) => {
+                const x = ((item.timestamp.getTime() - minTime) / range - 0.5) * width;
+                const y = (SEVERITY_ORDER[item.severity] - 2) * laneSpacing;
+                const z = (index % 3) * 0.3;
+                return { item, position: [x, y, z] };
+            });
+        }
+        const sourcesByName = Array.from(new Set(filteredItems.map((item) => item.source)));
+        const laneCount = Math.max(1, sourcesByName.length);
+        const spacingX = safeWidth / laneCount;
+        const spacingY = filteredItems.length > 1
+            ? Math.min(CARD_HEIGHT + 0.2, safeHeight / (filteredItems.length - 1))
+            : 0;
+        return filteredItems.map((item, index) => {
+            const lane = sourcesByName.indexOf(item.source);
+            const x = -safeWidth / 2 + spacingX / 2 + lane * spacingX;
+            const y = safeHeight / 2 - index * spacingY;
+            return { item, position: [x, y, 0] };
+        });
+    }, [filteredItems, layout, bounds]);
+    const scrollSpan = Math.max(3, (bounds?.height ?? layoutPositions.length * 1.0) + CARD_HEIGHT);
+    const scrollSpeed = 0.35;
+    const sourceLabels = React.useMemo(() => {
+        const labelItems = sources.map((source) => ({
+            ...source,
+            count: filteredItems.filter((item) => item.source === source.name).length,
+        }));
+        return labelItems.filter((source) => source.count > 0);
+    }, [sources, filteredItems]);
+    const labelSpan = Math.max(bounds?.width ?? 9.5, CARD_WIDTH + 0.6);
+    const labelSpacing = labelSpan / Math.max(1, sourceLabels.length);
+    return (_jsxs("group", { position: position, rotation: rotation, children: [layout === "waterfall" && (_jsx("group", { children: sourceLabels.map((source, index) => (_jsx(Html, { position: [
+                        -labelSpan / 2 + labelSpacing / 2 + index * labelSpacing,
+                        (bounds?.height ?? 5.5) / 2 - 0.2,
+                        0,
+                    ], children: _jsxs("div", { className: "rounded bg-slate-950/70 px-2 py-1 text-[8px] uppercase tracking-[0.18em] text-white/55", children: [source.name, " \u2022 ", Math.round(source.reliability * 100), "%"] }) }, source.id))) })), layoutPositions.map(({ item, position: itemPosition }, index) => (_jsx(IntelCard, { item: item, position: itemPosition, onClick: onItemClick, autoScroll: autoScroll, scrollSpan: scrollSpan, scrollSpeed: scrollSpeed, layout: layout, index: index }, item.id)))] }));
+}

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

@@ -0,0 +1,14 @@
+/**
+ * IntelFeed - Real-time threat intelligence visualization
+ *
+ * @example
+ * ```tsx
+ * import { IntelFeed } from "@backbay/glia/primitives/three/IntelFeed";
+ *
+ * <IntelFeed items={items} sources={sources} layout="waterfall" />
+ * ```
+ */
+export { IntelFeed } from "./IntelFeed";
+export type { IntelFeedProps, IntelItem, IntelSource } from "./types";
+export { INTEL_SEVERITY_COLORS, INTEL_TYPE_LABELS } from "./types";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/IntelFeed/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACtE,OAAO,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC"}

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

@@ -0,0 +1,12 @@
+/**
+ * IntelFeed - Real-time threat intelligence visualization
+ *
+ * @example
+ * ```tsx
+ * import { IntelFeed } from "@backbay/glia/primitives/three/IntelFeed";
+ *
+ * <IntelFeed items={items} sources={sources} layout="waterfall" />
+ * ```
+ */
+export { IntelFeed } from "./IntelFeed";
+export { INTEL_SEVERITY_COLORS, INTEL_TYPE_LABELS } from "./types";

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

@@ -0,0 +1,42 @@
+/**
+ * IntelFeed Types
+ *
+ * Type definitions for threat intelligence feed visualization.
+ */
+export interface IntelItem {
+    id: string;
+    source: string;
+    type: "ioc" | "vulnerability" | "campaign" | "actor" | "tool" | "report";
+    severity: "info" | "low" | "medium" | "high" | "critical";
+    title: string;
+    summary?: string;
+    timestamp: Date;
+    relevance?: number;
+    actionRequired?: boolean;
+}
+export interface IntelSource {
+    id: string;
+    name: string;
+    type: "commercial" | "osint" | "isac" | "government" | "internal";
+    reliability: number;
+    logo?: string;
+}
+export interface IntelFeedProps {
+    items: IntelItem[];
+    sources: IntelSource[];
+    maxItems?: number;
+    filterSeverity?: string[];
+    filterSources?: string[];
+    onItemClick?: (item: IntelItem) => void;
+    layout?: "waterfall" | "timeline" | "grid";
+    autoScroll?: boolean;
+    bounds?: {
+        width: number;
+        height: number;
+    };
+    position?: [number, number, number];
+    rotation?: [number, number, number];
+}
+export declare const INTEL_SEVERITY_COLORS: Record<IntelItem["severity"], string>;
+export declare const INTEL_TYPE_LABELS: Record<IntelItem["type"], string>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/IntelFeed/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,KAAK,GAAG,eAAe,GAAG,UAAU,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;IACzE,QAAQ,EAAE,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;IAC1D,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,YAAY,GAAG,UAAU,CAAC;IAClE,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;IACxC,MAAM,CAAC,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,CAAC;IAC3C,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC;AAED,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,CAMvE,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAO/D,CAAC"}

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

@@ -0,0 +1,20 @@
+/**
+ * IntelFeed Types
+ *
+ * Type definitions for threat intelligence feed visualization.
+ */
+export const INTEL_SEVERITY_COLORS = {
+    info: "#5eead4",
+    low: "#60a5fa",
+    medium: "#fbbf24",
+    high: "#f97316",
+    critical: "#ef4444",
+};
+export const INTEL_TYPE_LABELS = {
+    ioc: "IOC",
+    vulnerability: "Vuln",
+    campaign: "Campaign",
+    actor: "Actor",
+    tool: "Tool",
+    report: "Report",
+};

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

@@ -0,0 +1,3 @@
+import { type NetworkTopologyProps } from "./types";
+export declare function NetworkTopology({ nodes, edges, layout, highlightPath, selectedNode, onNodeClick, onEdgeClick, showTraffic, showLabels, theme, position, rotation, }: NetworkTopologyProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=NetworkTopology.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkTopology.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/NetworkTopology/NetworkTopology.tsx"],"names":[],"mappings":"AAQA,OAAO,EASL,KAAK,oBAAoB,EAC1B,MAAM,SAAS,CAAC;AA2TjB,wBAAgB,eAAe,CAAC,EAC9B,KAAK,EACL,KAAK,EACL,MAAgB,EAChB,aAAkB,EAClB,YAAY,EACZ,WAAW,EACX,WAAW,EACX,WAAkB,EAClB,UAAiB,EACjB,KAAe,EACf,QAAoB,EACpB,QAAoB,GACrB,EAAE,oBAAoB,2CA0EtB"}

package/dist/primitives/three/NetworkTopology/NetworkTopology.js

@@ -0,0 +1,208 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { Html, Line } from "@react-three/drei";
+import { useFrame } from "@react-three/fiber";
+import * as THREE from "three";
+import { layoutForce, layoutRing } from "../Graph3D/utils";
+import { NETWORK_EDGE_STATUS_COLORS, NETWORK_NODE_LABELS, NETWORK_NODE_STATUS_COLORS, NETWORK_PROTOCOL_COLORS, NETWORK_THEME_COLORS, } from "./types";
+const NODE_SIZE_BY_TYPE = {
+    server: 0.45,
+    workstation: 0.35,
+    router: 0.4,
+    firewall: 0.48,
+    cloud: 0.5,
+    iot: 0.28,
+    mobile: 0.32,
+};
+function getNodeGeometry(type) {
+    switch (type) {
+        case "server":
+            return _jsx("boxGeometry", { args: [1.1, 1.4, 0.9] });
+        case "workstation":
+            return _jsx("boxGeometry", { args: [1.1, 0.7, 0.9] });
+        case "router":
+            return _jsx("cylinderGeometry", { args: [0.7, 0.7, 0.5, 12] });
+        case "firewall":
+            return _jsx("cylinderGeometry", { args: [0.8, 0.8, 0.35, 6] });
+        case "cloud":
+            return _jsx("sphereGeometry", { args: [0.7, 20, 20] });
+        case "iot":
+            return _jsx("icosahedronGeometry", { args: [0.5, 0] });
+        case "mobile":
+            return _jsx("boxGeometry", { args: [0.55, 1.2, 0.2] });
+        default:
+            return _jsx("sphereGeometry", { args: [0.5, 16, 16] });
+    }
+}
+function layoutHierarchical(nodes) {
+    const layerMap = {
+        router: 2.4,
+        firewall: 2.0,
+        cloud: 1.6,
+        server: 0.6,
+        workstation: -0.6,
+        mobile: -1.4,
+        iot: -1.8,
+    };
+    const grouped = new Map();
+    nodes.forEach((node) => {
+        const layer = layerMap[node.type] ?? 0;
+        const list = grouped.get(layer) ?? [];
+        list.push(node);
+        grouped.set(layer, list);
+    });
+    const positions = new Map();
+    const spacing = 1.2;
+    Array.from(grouped.entries()).forEach(([layer, layerNodes]) => {
+        const columns = Math.max(1, Math.ceil(Math.sqrt(layerNodes.length)));
+        const rows = Math.ceil(layerNodes.length / columns);
+        layerNodes.forEach((node, index) => {
+            const row = Math.floor(index / columns);
+            const col = index % columns;
+            const x = (col - (columns - 1) / 2) * spacing;
+            const z = (row - (rows - 1) / 2) * spacing;
+            positions.set(node.id, new THREE.Vector3(x, layer, z));
+        });
+    });
+    return positions;
+}
+function resolvePositions(nodes, edges, layout) {
+    const layoutNodes = nodes.map((node) => ({
+        id: node.id,
+        label: node.hostname,
+        category: node.type,
+        positionHint: node.position,
+    }));
+    const layoutEdges = edges.map((edge) => ({
+        id: edge.id,
+        source: edge.source,
+        target: edge.target,
+    }));
+    let positions;
+    switch (layout) {
+        case "hierarchical":
+            positions = layoutHierarchical(nodes);
+            break;
+        case "radial":
+            positions = layoutRing(layoutNodes, { radius: 4.2 });
+            break;
+        case "geographic":
+            positions = layoutRing(layoutNodes, { radius: 4 });
+            break;
+        case "force":
+        default:
+            positions = layoutForce(layoutNodes, layoutEdges, {
+                radius: 4,
+                spacing: 1.4,
+                iterations: 80,
+                repelStrength: 7,
+            });
+            break;
+    }
+    nodes.forEach((node) => {
+        if (node.position) {
+            positions.set(node.id, new THREE.Vector3(...node.position));
+        }
+    });
+    return positions;
+}
+function NodeMesh({ node, position, isSelected, isHighlighted, showLabels, theme, onClick, }) {
+    const meshRef = React.useRef(null);
+    const haloRef = React.useRef(null);
+    const baseSize = NODE_SIZE_BY_TYPE[node.type] ?? 0.4;
+    const statusColors = NETWORK_NODE_STATUS_COLORS[node.status];
+    const themeColors = NETWORK_THEME_COLORS[theme];
+    useFrame(({ clock }) => {
+        if (!meshRef.current)
+            return;
+        const t = clock.elapsedTime;
+        let pulse = 1;
+        if (node.status === "compromised") {
+            pulse = 1 + Math.sin(t * 4) * 0.15;
+        }
+        else if (node.status === "warning") {
+            pulse = 1 + Math.sin(t * 2.2) * 0.08;
+        }
+        else if (node.status === "healthy") {
+            pulse = 1 + Math.sin(t * 0.8) * 0.02;
+        }
+        meshRef.current.scale.setScalar(baseSize * pulse);
+        if (haloRef.current) {
+            const haloPulse = 1 + Math.sin(t * 2.5) * 0.08;
+            haloRef.current.scale.setScalar(haloPulse);
+        }
+    });
+    return (_jsxs("group", { position: position, children: [_jsxs("mesh", { ref: meshRef, onClick: (event) => {
+                    event.stopPropagation();
+                    onClick?.(node);
+                }, onPointerOver: (event) => {
+                    event.stopPropagation();
+                    document.body.style.cursor = "pointer";
+                }, onPointerOut: () => {
+                    document.body.style.cursor = "auto";
+                }, scale: [baseSize, baseSize, baseSize], children: [getNodeGeometry(node.type), _jsx("meshStandardMaterial", { color: statusColors.base, emissive: statusColors.glow, emissiveIntensity: node.status === "offline" ? 0.1 : 0.6, roughness: 0.3, metalness: 0.6, transparent: true, opacity: node.status === "offline" ? 0.35 : 0.9 })] }), (isSelected || isHighlighted || node.status === "compromised") && (_jsxs("mesh", { ref: haloRef, children: [_jsx("sphereGeometry", { args: [baseSize * 1.8, 24, 24] }), _jsx("meshBasicMaterial", { color: statusColors.glow, transparent: true, opacity: isSelected ? 0.2 : 0.12, side: THREE.BackSide, depthWrite: false })] })), showLabels && (_jsx(Html, { distanceFactor: 10, position: [0, baseSize * 1.4, 0], children: _jsxs("div", { className: "rounded-md border bg-slate-950/80 px-2 py-1 text-[10px] uppercase text-white/80 shadow-lg", style: {
+                        color: statusColors.text,
+                        borderColor: `${themeColors.glow}55`,
+                        boxShadow: `0 0 12px ${themeColors.glow}22`,
+                    }, children: [_jsx("div", { className: "font-semibold", children: node.hostname }), _jsxs("div", { className: "text-[9px] opacity-70", children: [NETWORK_NODE_LABELS[node.type], " \u2022 ", node.ip] })] }) })), node.vulnerabilities && node.vulnerabilities > 0 && (_jsx(Html, { distanceFactor: 12, position: [0.5, baseSize * 1.2, 0], children: _jsx("div", { className: "rounded-full bg-red-500/80 px-2 py-0.5 text-[9px] font-semibold text-white", children: node.vulnerabilities }) })), node.status === "compromised" && (_jsxs("mesh", { rotation: [Math.PI / 2, 0, 0], children: [_jsx("ringGeometry", { args: [baseSize * 1.3, baseSize * 1.45, 32] }), _jsx("meshBasicMaterial", { color: statusColors.glow, transparent: true, opacity: 0.6, side: THREE.DoubleSide, depthWrite: false })] }))] }));
+}
+function TrafficStream({ start, end, color, speed, count }) {
+    const meshRefs = React.useRef([]);
+    const offsets = React.useMemo(() => new Array(count).fill(0).map(() => Math.random()), [count]);
+    const lineData = React.useMemo(() => {
+        const direction = new THREE.Vector3().subVectors(end, start);
+        const length = direction.length();
+        if (length > 0) {
+            direction.normalize();
+        }
+        return { direction, length };
+    }, [start, end]);
+    useFrame(({ clock }) => {
+        if (lineData.length <= 0)
+            return;
+        const t = clock.elapsedTime * speed;
+        offsets.forEach((offset, index) => {
+            const mesh = meshRefs.current[index];
+            if (!mesh)
+                return;
+            const progress = (t + offset) % 1;
+            const pos = lineData.direction
+                .clone()
+                .multiplyScalar(lineData.length * progress)
+                .add(start);
+            mesh.position.copy(pos);
+        });
+    });
+    return (_jsx("group", { children: offsets.map((offset, index) => (_jsxs("mesh", { ref: (mesh) => {
+                meshRefs.current[index] = mesh;
+            }, children: [_jsx("sphereGeometry", { args: [0.05, 10, 10] }), _jsx("meshStandardMaterial", { color: color, emissive: color, emissiveIntensity: 0.9, transparent: true, opacity: 0.9 })] }, `${offset}-${index}`))) }));
+}
+export function NetworkTopology({ nodes, edges, layout = "force", highlightPath = [], selectedNode, onNodeClick, onEdgeClick, showTraffic = true, showLabels = true, theme = "cyber", position = [0, 0, 0], rotation = [0, 0, 0], }) {
+    const positions = React.useMemo(() => resolvePositions(nodes, edges, layout), [nodes, edges, layout]);
+    const highlightSet = React.useMemo(() => new Set(highlightPath), [highlightPath]);
+    return (_jsxs("group", { position: position, rotation: rotation, children: [edges.map((edge) => {
+                const start = positions.get(edge.source);
+                const end = positions.get(edge.target);
+                if (!start || !end)
+                    return null;
+                const isHighlighted = highlightSet.has(edge.source) && highlightSet.has(edge.target);
+                const statusColor = NETWORK_EDGE_STATUS_COLORS[edge.status];
+                const protocolColor = NETWORK_PROTOCOL_COLORS[edge.protocol];
+                const baseColor = edge.status === "active" ? protocolColor : statusColor;
+                const lineColor = isHighlighted ? "#ff3344" : baseColor;
+                const isBlocked = edge.status === "blocked";
+                const isSuspicious = edge.status === "suspicious";
+                const shouldDashed = !edge.encrypted || isBlocked || isSuspicious;
+                return (_jsxs("group", { children: [_jsx(Line, { points: [start, end], color: lineColor, transparent: true, opacity: isHighlighted ? 0.9 : edge.status === "idle" ? 0.2 : 0.65, lineWidth: isHighlighted ? 2.5 : 1.5, dashed: shouldDashed, dashScale: isSuspicious ? 2.2 : 1.4, dashSize: 0.2, gapSize: 0.16, onClick: (event) => {
+                                event.stopPropagation();
+                                onEdgeClick?.(edge);
+                            } }), showTraffic && edge.status !== "blocked" && (_jsx(TrafficStream, { start: start, end: end, color: lineColor, speed: edge.bandwidth ? Math.min(2.5, edge.bandwidth / 4000) : 0.8, count: edge.bandwidth ? Math.min(6, 2 + Math.floor(edge.bandwidth / 2000)) : 3 }))] }, edge.id));
+            }), nodes.map((node) => {
+                const positionVector = positions.get(node.id);
+                if (!positionVector)
+                    return null;
+                const isHighlighted = highlightSet.has(node.id);
+                return (_jsx(NodeMesh, { node: node, position: positionVector, isSelected: selectedNode === node.id, isHighlighted: isHighlighted, showLabels: showLabels, theme: theme, onClick: onNodeClick }, node.id));
+            })] }));
+}

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

@@ -0,0 +1,20 @@
+/**
+ * NetworkTopology - 3D network infrastructure visualization
+ *
+ * @example
+ * ```tsx
+ * import { NetworkTopology } from "@backbay/glia/primitives/three/NetworkTopology";
+ *
+ * <NetworkTopology
+ *   nodes={nodes}
+ *   edges={edges}
+ *   layout="force"
+ *   showTraffic
+ *   showLabels
+ * />
+ * ```
+ */
+export { NetworkTopology } from "./NetworkTopology";
+export type { NetworkTopologyProps, NetworkNode, NetworkNodeType, NetworkNodeStatus, NetworkEdge, NetworkEdgeProtocol, NetworkEdgeStatus, } from "./types";
+export { NETWORK_NODE_STATUS_COLORS, NETWORK_EDGE_STATUS_COLORS, NETWORK_PROTOCOL_COLORS, NETWORK_THEME_COLORS, NETWORK_NODE_LABELS, } from "./types";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/NetworkTopology/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,YAAY,EACV,oBAAoB,EACpB,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,0BAA0B,EAC1B,0BAA0B,EAC1B,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,SAAS,CAAC"}

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

@@ -0,0 +1,18 @@
+/**
+ * NetworkTopology - 3D network infrastructure visualization
+ *
+ * @example
+ * ```tsx
+ * import { NetworkTopology } from "@backbay/glia/primitives/three/NetworkTopology";
+ *
+ * <NetworkTopology
+ *   nodes={nodes}
+ *   edges={edges}
+ *   layout="force"
+ *   showTraffic
+ *   showLabels
+ * />
+ * ```
+ */
+export { NetworkTopology } from "./NetworkTopology";
+export { NETWORK_NODE_STATUS_COLORS, NETWORK_EDGE_STATUS_COLORS, NETWORK_PROTOCOL_COLORS, NETWORK_THEME_COLORS, NETWORK_NODE_LABELS, } from "./types";

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

@@ -0,0 +1,59 @@
+/**
+ * NetworkTopology Types
+ *
+ * Type definitions for the 3D network topology visualization component.
+ */
+export type NetworkNodeType = "server" | "workstation" | "router" | "firewall" | "cloud" | "iot" | "mobile";
+export type NetworkNodeStatus = "healthy" | "warning" | "compromised" | "offline";
+export interface NetworkNode {
+    id: string;
+    type: NetworkNodeType;
+    hostname: string;
+    ip: string;
+    status: NetworkNodeStatus;
+    os?: string;
+    services: string[];
+    vulnerabilities?: number;
+    position?: [number, number, number];
+}
+export type NetworkEdgeProtocol = "tcp" | "udp" | "icmp" | "http" | "https" | "ssh" | "rdp" | "smb";
+export type NetworkEdgeStatus = "active" | "idle" | "blocked" | "suspicious";
+export interface NetworkEdge {
+    id: string;
+    source: string;
+    target: string;
+    protocol: NetworkEdgeProtocol;
+    port?: number;
+    bandwidth?: number;
+    encrypted: boolean;
+    status: NetworkEdgeStatus;
+}
+export interface NetworkTopologyProps {
+    nodes: NetworkNode[];
+    edges: NetworkEdge[];
+    layout?: "force" | "hierarchical" | "radial" | "geographic";
+    highlightPath?: string[];
+    selectedNode?: string;
+    onNodeClick?: (node: NetworkNode) => void;
+    onEdgeClick?: (edge: NetworkEdge) => void;
+    showTraffic?: boolean;
+    showLabels?: boolean;
+    theme?: "cyber" | "matrix" | "blueprint";
+    position?: [number, number, number];
+    rotation?: [number, number, number];
+}
+export declare const NETWORK_NODE_STATUS_COLORS: Record<NetworkNodeStatus, {
+    base: string;
+    glow: string;
+    text: string;
+}>;
+export declare const NETWORK_EDGE_STATUS_COLORS: Record<NetworkEdgeStatus, string>;
+export declare const NETWORK_PROTOCOL_COLORS: Record<NetworkEdgeProtocol, string>;
+export declare const NETWORK_THEME_COLORS: Record<NonNullable<NetworkTopologyProps["theme"]>, {
+    grid: string;
+    labels: string;
+    ambient: string;
+    glow: string;
+}>;
+export declare const NETWORK_NODE_LABELS: Record<NetworkNodeType, string>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/NetworkTopology/types.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,56 @@
+/**
+ * NetworkTopology Types
+ *
+ * Type definitions for the 3D network topology visualization component.
+ */
+export const NETWORK_NODE_STATUS_COLORS = {
+    healthy: { base: "#17f7a2", glow: "#33ffb2", text: "#aaf7d2" },
+    warning: { base: "#ffb347", glow: "#ffd08a", text: "#ffe0b8" },
+    compromised: { base: "#ff4455", glow: "#ff2233", text: "#ffd0d5" },
+    offline: { base: "#4c5b6b", glow: "#2a3440", text: "#9aa7b5" },
+};
+export const NETWORK_EDGE_STATUS_COLORS = {
+    active: "#22e7ff",
+    idle: "#4c6b8a",
+    blocked: "#ff3344",
+    suspicious: "#ff8a2a",
+};
+export const NETWORK_PROTOCOL_COLORS = {
+    tcp: "#6ee7ff",
+    udp: "#9dff6e",
+    icmp: "#ffcc66",
+    http: "#6aa2ff",
+    https: "#3b82f6",
+    ssh: "#ffb84d",
+    rdp: "#ff6b6b",
+    smb: "#c084fc",
+};
+export const NETWORK_THEME_COLORS = {
+    cyber: {
+        grid: "#0b1b2e",
+        labels: "#d4f2ff",
+        ambient: "#0a0f1e",
+        glow: "#21e6ff",
+    },
+    matrix: {
+        grid: "#0a1a10",
+        labels: "#c4ffd7",
+        ambient: "#07130b",
+        glow: "#2bff77",
+    },
+    blueprint: {
+        grid: "#0a1220",
+        labels: "#b9d4ff",
+        ambient: "#08101d",
+        glow: "#4aa3ff",
+    },
+};
+export const NETWORK_NODE_LABELS = {
+    server: "Server",
+    workstation: "Workstation",
+    router: "Router",
+    firewall: "Firewall",
+    cloud: "Cloud",
+    iot: "IoT",
+    mobile: "Mobile",
+};

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

@@ -0,0 +1,8 @@
+interface ParticleFieldProps {
+    count?: number;
+    range?: number;
+    color?: string;
+}
+export declare const ParticleField: ({ count, range, color, }: ParticleFieldProps) => import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=ParticleField.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleField.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/ParticleField/ParticleField.tsx"],"names":[],"mappings":"AAKA,UAAU,kBAAkB;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AA0CD,eAAO,MAAM,aAAa,GAAI,0BAI3B,kBAAkB,4CAyBpB,CAAC"}