sysgraph 0.0.12__tar.gz → 0.0.14__tar.gz

{sysgraph-0.0.12/src/sysgraph.egg-info → sysgraph-0.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysgraph
-Version: 0.0.12
+Version: 0.0.14
 Summary: Visualizer for processes and their interconnections
 Home-page: https://github.com/gubenkoved/sysgraph
 Author: Eugene Gubenkov

sysgraph-0.0.14/src/sysgraph/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.14"

{sysgraph-0.0.12 → sysgraph-0.0.14}/src/sysgraph/app.py

@@ -71,39 +71,16 @@ def health():
 
 
 @app.get("/api/graph", response_model=GraphSchema)
-def get_graph() -> GraphSchema:
+def get_graph() -> dict:
     graph = build_graph()
-    graph_dict = graph.as_dict()
-
-    LOGGER.debug(graph_dict)
-
-    return GraphSchema(
-        nodes=[
-            GraphNodeSchema(
-                id=node["id"], type=node["type"], properties=node["properties"]
-            )
-            for node in graph_dict["nodes"]
-        ],
-        edges=[
-            GraphEdgeSchema(
-                id=edge["id"],
-                source_id=edge["source_id"],
-                target_id=edge["target_id"],
-                type=edge["type"],
-                properties=edge["properties"],
-            )
-            for edge in graph_dict["edges"]
-        ],
-    )
+    return graph.as_dict()
 
 
 # Serve built assets (JS/CSS bundles, Shoelace icons, etc.) from the same
 # directory that provides index.html.  This catch-all mount MUST come after
 # all explicit routes so that /api/* and / are matched first.
 if _dist_dir.is_dir():
-    app.mount(
-        "/", StaticFiles(directory=str(_dist_dir)), name="static"
-    )
+    app.mount("/", StaticFiles(directory=str(_dist_dir)), name="static")
 
 
 def main():

sysgraph-0.0.14/src/sysgraph/constants.py

@@ -0,0 +1,36 @@
+# -- Node types --
+NODE_PROCESS = "process"
+NODE_PIPE = "pipe"
+NODE_SOCKET = "socket"
+NODE_UDS = "uds"
+NODE_EXTERNAL_IP = "external_ip"
+
+# -- Edge types --
+EDGE_CHILD_PROCESS = "child_process"
+EDGE_UDS = "uds"
+EDGE_UDS_CONNECTION = "uds_connection"
+EDGE_PIPE = "pipe"
+EDGE_SOCKET = "socket"
+EDGE_SOCKET_CONNECTION = "socket_connection"
+EDGE_EXTERNAL_SOCKET = "external_socket"
+
+
+# -- Node ID helpers --
+def process_node_id(pid: int) -> str:
+    return f"{NODE_PROCESS}::{pid}"
+
+
+def uds_node_id(inode: int) -> str:
+    return f"{NODE_UDS}::{inode}"
+
+
+def pipe_node_id(inode: str) -> str:
+    return f"{NODE_PIPE}::{inode}"
+
+
+def socket_node_id(address: str, socket_type: str) -> str:
+    return f"{NODE_SOCKET}::{address}::{socket_type}"
+
+
+def external_ip_node_id(ip: str) -> str:
+    return f"{NODE_EXTERNAL_IP}::{ip}"

{sysgraph-0.0.12 → sysgraph-0.0.14}/src/sysgraph/discovery.py

@@ -5,10 +5,28 @@ import subprocess
 from collections import defaultdict
 from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
-from socket import AddressFamily
 
 import psutil
 
+from sysgraph.constants import (
+    EDGE_CHILD_PROCESS,
+    EDGE_EXTERNAL_SOCKET,
+    EDGE_PIPE,
+    EDGE_SOCKET,
+    EDGE_SOCKET_CONNECTION,
+    EDGE_UDS,
+    EDGE_UDS_CONNECTION,
+    NODE_EXTERNAL_IP,
+    NODE_PIPE,
+    NODE_PROCESS,
+    NODE_SOCKET,
+    NODE_UDS,
+    external_ip_node_id,
+    pipe_node_id,
+    process_node_id,
+    socket_node_id,
+    uds_node_id,
+)
 from sysgraph.graph import Graph, Node
 from sysgraph.model import (
     NetConnection,
@@ -37,6 +55,7 @@ def discover_processes() -> list[Process]:
     ]
     for proc in psutil.process_iter(attrs):
         info = proc.info
+
         p = Process(pid=info["pid"])
         p.parent_pid = info["ppid"]
         p.user = info["username"]
@@ -48,6 +67,12 @@ def discover_processes() -> list[Process]:
             p.cpu_user = cpu_times.user
             p.cpu_system = cpu_times.system
 
+        mem_info = proc.memory_info()
+        if mem_info:
+            p.memory_rss = mem_info.rss
+            p.memory_vms = mem_info.vms
+            p.memory_shared = mem_info.shared
+
         p.environment = info.get("environ")
 
         processes.append(p)
@@ -200,26 +225,6 @@ def get_processes_open_files() -> dict[int, list[ProcessOpenFile]]:
     return result_map
 
 
-def get_net_connections(pid: int) -> list[NetConnection]:
-    proc = psutil.Process(pid)
-    connections: list[NetConnection] = []
-    for pcon in proc.net_connections(kind="all"):
-        if pcon.family not in (AddressFamily.AF_INET, AddressFamily.AF_INET6):
-            continue
-        connections.append(
-            NetConnection(
-                pid=pid,
-                local_address=SocketAddress(pcon.laddr.ip, pcon.laddr.port),
-                remote_address=SocketAddress(pcon.raddr.ip, pcon.raddr.port)
-                if pcon.raddr
-                else None,
-                socket_type=pcon.type.name,
-                state=pcon.status,
-            )
-        )
-    return connections
-
-
 def get_all_net_connections() -> dict[int, list[NetConnection]]:
     """Fetch all network connections system-wide in a single call."""
     result: dict[int, list[NetConnection]] = defaultdict(list)
@@ -240,28 +245,17 @@ def get_all_net_connections() -> dict[int, list[NetConnection]]:
     return result
 
 
-def build_graph(discover_uds_connectivity: bool = True) -> Graph:
-    graph = Graph()
-
+def _add_process_nodes(
+    graph: Graph,
+    processes: list[Process],
+) -> dict[int, Node]:
+    """Create process nodes and parent-child edges."""
     pid_to_node: dict[int, Node] = {}
 
-    # run independent discovery steps in parallel (all I/O-bound)
-    with ThreadPoolExecutor() as executor:
-        processes_future = executor.submit(discover_processes)
-        uds_future = executor.submit(discover_unix_sockets)
-        open_files_future = executor.submit(get_processes_open_files)
-        net_connections_future = executor.submit(get_all_net_connections)
-
-        processes = processes_future.result()
-        uds = uds_future.result()
-        open_files_map = open_files_future.result()
-        all_net_connections = net_connections_future.result()
-
     for proc in processes:
-        proc_node_id = f"process::{proc.pid}"
         node = graph.add_node(
-            proc_node_id,
-            "process",
+            process_node_id(proc.pid),
+            NODE_PROCESS,
             properties={
                 "pid": proc.pid,
                 "command": proc.command,
@@ -269,48 +263,50 @@ def build_graph(discover_uds_connectivity: bool = True) -> Graph:
                 "name": proc.name,
                 "cpu_user": proc.cpu_user,
                 "cpu_system": proc.cpu_system,
+                "memory_rss": proc.memory_rss,
+                "memory_vms": proc.memory_vms,
+                "memory_shared": proc.memory_shared,
                 "environment": proc.environment,
             },
         )
         pid_to_node[proc.pid] = node
 
-    # add parent-child relationships
     for proc in processes:
-        proc_node = pid_to_node[proc.pid]
-        parent_proc_node = None
-        if proc.parent_pid is not None:
-            parent_proc_node = pid_to_node.get(proc.parent_pid)
-        if parent_proc_node is not None:
-            _ = graph.add_edge(
-                source_id=parent_proc_node.id,
-                target_id=proc_node.id,
-                rel_type="child_process",
+        if proc.parent_pid is None:
+            continue
+        parent_node = pid_to_node.get(proc.parent_pid)
+        if parent_node is not None:
+            graph.add_edge(
+                source_id=parent_node.id,
+                target_id=pid_to_node[proc.pid].id,
+                rel_type=EDGE_CHILD_PROCESS,
             )
 
+    return pid_to_node
+
+
+def _add_uds_nodes(
+    graph: Graph,
+    uds_sockets: list[UnixDomainSocket],
+    pid_to_node: dict[int, Node],
+    discover_connectivity: bool,
+) -> None:
+    """Create UDS nodes, process→UDS edges, and UDS connection edges."""
     uds_node_map: dict[int, Node] = {}
 
     def ensure_uds_node(uds_socket: UnixDomainSocket) -> Node:
         inode = uds_socket.local_inode
-
         if inode in uds_node_map:
             return uds_node_map[inode]
 
-        node_id = f"uds::{inode}"
-
-        if uds_socket.local_path:
-            if uds_socket.local_path == "*":
-                label = f"uds:[{inode}]"
-            else:
-                label = uds_socket.local_path
-
-            # strip trailing @ if present (abstract unix socket)
-            label = label.rstrip("@")
-        else:  # no local path
+        if uds_socket.local_path and uds_socket.local_path != "*":
+            label = uds_socket.local_path.rstrip("@")
+        else:
             label = f"uds:[{inode}]"
 
         node = graph.add_node(
-            node_id,
-            "uds",
+            uds_node_id(inode),
+            NODE_UDS,
             properties={
                 "label": label,
                 "local_inode": uds_socket.local_inode,
@@ -324,12 +320,9 @@ def build_graph(discover_uds_connectivity: bool = True) -> Graph:
         uds_node_map[inode] = node
         return node
 
-    # track which process→uds edges have been added to avoid duplicates
     uds_process_edges: set[tuple[int, int]] = set()
 
-    # create UDS nodes for ALL discovered sockets and connect them
-    # to their processes
-    for uds_socket in uds:
+    for uds_socket in uds_sockets:
         uds_node = ensure_uds_node(uds_socket)
         for p_ref in uds_socket.processes:
             edge_key = (p_ref.pid, uds_socket.local_inode)
@@ -338,125 +331,129 @@ def build_graph(discover_uds_connectivity: bool = True) -> Graph:
                 graph.add_edge(
                     source_id=pid_to_node[p_ref.pid].id,
                     target_id=uds_node.id,
-                    rel_type="uds",
+                    rel_type=EDGE_UDS,
                     properties={
                         "label": f"uds (fd={p_ref.fd})",
                         "fd": p_ref.fd,
                     },
                 )
 
-    # optionally discover connected UDS pairs and add connection edges
-    if discover_uds_connectivity:
-        for con in discover_connected_uds(uds):
+    if discover_connectivity:
+        for con in discover_connected_uds(uds_sockets):
             uds_node1 = ensure_uds_node(con.socket1)
             uds_node2 = ensure_uds_node(con.socket2)
-
             graph.add_edge(
                 uds_node1.id,
                 uds_node2.id,
-                "uds_connection",
+                EDGE_UDS_CONNECTION,
                 properties={
                     "directional": False,
                     "dashed": True,
                 },
             )
 
-    pipe_node_to_node = {}
 
-    def ensure_pipe_node(file_node):
-        if file_node not in pipe_node_to_node:
-            pipe_node_to_node[file_node] = graph.add_node(
-                f"pipe::{file_node}",
-                "pipe",
-                properties={
-                    "label": f"pipe:[{file_node}]",
-                },
+def _add_pipe_nodes(
+    graph: Graph,
+    open_files_map: dict[int, list[ProcessOpenFile]],
+    pid_to_node: dict[int, Node],
+) -> None:
+    """Create pipe nodes and directional pipe edges."""
+    pipe_nodes: dict[str, Node] = {}
+
+    def ensure_pipe_node(file_node: str) -> Node:
+        if file_node not in pipe_nodes:
+            pipe_nodes[file_node] = graph.add_node(
+                pipe_node_id(file_node),
+                NODE_PIPE,
+                properties={"label": f"pipe:[{file_node}]"},
             )
-        return pipe_node_to_node[file_node]
+        return pipe_nodes[file_node]
 
     for pid, files in open_files_map.items():
         if pid not in pid_to_node:
             continue
         process_node = pid_to_node[pid]
         for file in files:
-            # so far just show the pipes
             if file.file_type != "FIFO":
                 continue
             node = ensure_pipe_node(file.node)
-
+            props = {
+                "label": f"pipe (fd={file.fd})",
+                "fd": file.fd,
+                "mode": file.mode,
+            }
             if file.mode == "r":
-                _ = graph.add_edge(
+                graph.add_edge(
                     source_id=node.id,
                     target_id=process_node.id,
-                    rel_type="pipe",
-                    properties={
-                        "label": f"pipe (fd={file.fd})",
-                        "fd": file.fd,
-                        "mode": file.mode,
-                    },
+                    rel_type=EDGE_PIPE,
+                    properties=props,
                 )
             else:
-                _ = graph.add_edge(
+                graph.add_edge(
                     source_id=process_node.id,
                     target_id=node.id,
-                    rel_type="pipe",
-                    properties={
-                        "label": f"pipe (fd={file.fd})",
-                        "fd": file.fd,
-                        "mode": file.mode,
-                    },
+                    rel_type=EDGE_PIPE,
+                    properties=props,
                 )
 
-    socket_to_pids: dict[tuple[SocketAddress, str], list[int]] = {}
-    socket_to_node: dict[tuple[SocketAddress, str], Node] = {}
 
-    def is_ipv6(address: str) -> bool:
-        return ":" in address
+_SIMPLE_SOCKET_TYPE = {
+    "SOCK_DGRAM": "UDP",
+    "SOCK_STREAM": "TCP",
+}
 
-    def ensure_socket(address: SocketAddress, socket_type, state: str):
-        key = (address, socket_type)
-        if key in socket_to_node:
-            return socket_to_node[key]
-        socket_node_id = f"socket::{address}::{socket_type}"
-        socket_node = graph.add_node(socket_node_id, "socket")
 
-        simple_socket_type = {
-            "SOCK_DGRAM": "UDP",
-            "SOCK_STREAM": "TCP",
-        }
+def _add_network_nodes(
+    graph: Graph,
+    processes: list[Process],
+    all_net_connections: dict[int, list[NetConnection]],
+    pid_to_node: dict[int, Node],
+) -> None:
+    """Create socket/external-IP nodes and their edges."""
+    sock_to_pids: dict[tuple[SocketAddress, str], list[int]] = {}
+    sock_to_node: dict[tuple[SocketAddress, str], Node] = {}
+    connected_sockets: set[tuple[str, ...]] = set()
 
-        simple_type = simple_socket_type.get(socket_type, socket_type)
+    def is_ipv6(address: str) -> bool:
+        return ":" in address
 
+    def ensure_socket(
+        address: SocketAddress, sock_type: str, state: str
+    ) -> Node:
+        key = (address, sock_type)
+        if key in sock_to_node:
+            return sock_to_node[key]
+
+        node = graph.add_node(
+            socket_node_id(str(address), sock_type),
+            NODE_SOCKET,
+        )
+        simple = _SIMPLE_SOCKET_TYPE.get(sock_type, sock_type)
         if is_ipv6(address.ip):
-            socket_node.properties["label"] = (
-                f"[{address.ip}]:{address.port} ({simple_type})"
+            node.properties["label"] = (
+                f"[{address.ip}]:{address.port} ({simple})"
             )
         else:
-            socket_node.properties["label"] = (
-                f"{address.ip}:{address.port} ({simple_type})"
+            node.properties["label"] = (
+                f"{address.ip}:{address.port} ({simple})"
             )
+        node.properties["state"] = state
+        node.properties["socket_type"] = sock_type
+        sock_to_node[key] = node
+        return node
 
-        socket_node.properties["state"] = state
-        socket_node.properties["socket_type"] = socket_type
-
-        socket_to_node[key] = socket_node
-        return socket_node
-
-    connected_sockets = set()
-
-    def ensure_sockets_connected(socket1: Node, socket2: Node):
-        key = tuple(sorted([socket1.id, socket2.id]))
+    def ensure_sockets_connected(s1: Node, s2: Node) -> None:
+        key = tuple(sorted([s1.id, s2.id]))
         if key in connected_sockets:
             return
         connected_sockets.add(key)
-        _ = graph.add_edge(
-            socket1.id,
-            socket2.id,
-            "socket_connection",
-            {
-                "directional": False,
-                "dashed": True,
-            },
+        graph.add_edge(
+            s1.id,
+            s2.id,
+            EDGE_SOCKET_CONNECTION,
+            {"directional": False, "dashed": True},
         )
 
     for proc in processes:
@@ -468,26 +465,25 @@ def build_graph(discover_uds_connectivity: bool = True) -> Graph:
             continue
 
         for net_con in net_connections:
-            socket_id = (net_con.local_address, net_con.socket_type)
-
-            # ensure socket in graph
+            sock_key = (
+                net_con.local_address,
+                net_con.socket_type,
+            )
             local_socket = ensure_socket(
                 net_con.local_address,
                 net_con.socket_type,
                 net_con.state,
             )
 
-            # process connection
-            if proc.pid not in socket_to_pids.get(socket_id, []):
-                socket_to_pids[socket_id] = socket_to_pids.get(
-                    socket_id, []
-                ) + [proc.pid]
+            if proc.pid not in sock_to_pids.get(sock_key, []):
+                sock_to_pids[sock_key] = sock_to_pids.get(sock_key, []) + [
+                    proc.pid
+                ]
                 graph.add_edge(
                     source_id=proc_node.id,
                     target_id=local_socket.id,
-                    rel_type="socket",
+                    rel_type=EDGE_SOCKET,
                 )
-
                 if net_con.remote_address:
                     remote_socket = ensure_socket(
                         net_con.remote_address,
@@ -496,35 +492,44 @@ def build_graph(discover_uds_connectivity: bool = True) -> Graph:
                     )
                     ensure_sockets_connected(local_socket, remote_socket)
 
-    # post-process all sockets which are NOT connected to any process -- these
-    # are remote endpoints, group the by IP address
-    external_ip_to_node = {}
-
-    def ensure_external_ip(address):
-        if address not in external_ip_to_node:
-            external_ip_to_node[address] = graph.add_node(
-                f"external_ip::{address}",
-                "external_ip",
-                {
-                    "label": address,
-                },
+    # sockets not connected to any process are remote endpoints
+    external_ip_nodes: dict[str, Node] = {}
+
+    for sock_key, sock_node in sock_to_node.items():
+        if sock_to_pids.get(sock_key):
+            continue
+        ip = sock_key[0].ip
+        if ip not in external_ip_nodes:
+            external_ip_nodes[ip] = graph.add_node(
+                external_ip_node_id(ip),
+                NODE_EXTERNAL_IP,
+                {"label": ip},
             )
-        return external_ip_to_node[address]
+        graph.add_edge(
+            external_ip_nodes[ip].id,
+            sock_node.id,
+            EDGE_EXTERNAL_SOCKET,
+        )
 
-    for socket, socket_node in socket_to_node.items():
-        pids = socket_to_pids.get(socket)
 
-        if pids:
-            continue
+def build_graph(discover_uds_connectivity: bool = True) -> Graph:
+    graph = Graph()
+
+    # run independent discovery steps in parallel (all I/O-bound)
+    with ThreadPoolExecutor() as executor:
+        processes_future = executor.submit(discover_processes)
+        uds_future = executor.submit(discover_unix_sockets)
+        open_files_future = executor.submit(get_processes_open_files)
+        net_connections_future = executor.submit(get_all_net_connections)
 
-        external_ip = socket[0].ip
-        external_ip_node = ensure_external_ip(external_ip)
+        processes = processes_future.result()
+        uds = uds_future.result()
+        open_files_map = open_files_future.result()
+        all_net_connections = net_connections_future.result()
 
-        # add connection
-        graph.add_edge(
-            external_ip_node.id,
-            socket_node.id,
-            "external_socket",
-        )
+    pid_to_node = _add_process_nodes(graph, processes)
+    _add_uds_nodes(graph, uds, pid_to_node, discover_uds_connectivity)
+    _add_pipe_nodes(graph, open_files_map, pid_to_node)
+    _add_network_nodes(graph, processes, all_net_connections, pid_to_node)
 
     return graph

sysgraph-0.0.14/src/sysgraph/dist/assets/index-Ba1ztXgb.css

@@ -0,0 +1 @@
+:root{--z-toolbar: 100;--z-search-help: 150;--z-context-menu: 200;--z-details-panel: 50;--z-selection-overlay: 10;--z-version-badge: 10;--bg-toolbar: rgba(255, 255, 255, .95);--bg-panel: rgba(255, 255, 255, .97);--border-subtle: rgba(0, 0, 0, .08);--border-light: rgba(0, 0, 0, .1);--border-medium: rgba(0, 0, 0, .12);--shadow-xs: rgba(0, 0, 0, .08);--shadow-sm: rgba(0, 0, 0, .14);--shadow-md: rgba(0, 0, 0, .15);--accent-primary: #1a56db;--accent-info: #1a73e8;--accent-danger: #dc2626;--toolbar-height: 48px;--spacing-xs: 4px;--spacing-sm: 6px;--spacing-md: 8px;--spacing-lg: 16px;--font-family: "Ubuntu", "Segoe UI", "Arial", sans-serif;--font-size-xs: 11px;--font-size-sm: 12px;--font-size-md: 13px;--radius-sm: 4px;--radius-md: 8px;--radius-lg: 12px;--button-height: 28px;--icon-button-size: 24px;--tp-base-background-color: hsla(230, 5%, 90%, 1);--tp-base-shadow-color: hsla(0, 0%, 0%, .1);--tp-button-background-color: hsla(230, 7%, 75%, 1);--tp-button-background-color-active: hsla(230, 7%, 60%, 1);--tp-button-background-color-focus: hsla(230, 7%, 65%, 1);--tp-button-background-color-hover: hsla(230, 7%, 70%, 1);--tp-button-foreground-color: hsla(230, 10%, 30%, 1);--tp-container-background-color: hsla(230, 15%, 30%, .2);--tp-container-background-color-active: hsla(230, 15%, 30%, .32);--tp-container-background-color-focus: hsla(230, 15%, 30%, .28);--tp-container-background-color-hover: hsla(230, 15%, 30%, .24);--tp-container-foreground-color: hsla(230, 10%, 30%, 1);--tp-groove-foreground-color: hsla(230, 15%, 30%, .1);--tp-input-background-color: hsla(230, 15%, 30%, .1);--tp-input-background-color-active: hsla(230, 15%, 30%, .22);--tp-input-background-color-focus: hsla(230, 15%, 30%, .18);--tp-input-background-color-hover: hsla(230, 15%, 30%, .14);--tp-input-foreground-color: hsla(230, 10%, 30%, 1);--tp-label-foreground-color: hsla(230, 10%, 30%, .7);--tp-monitor-background-color: hsla(230, 15%, 30%, .1);--tp-monitor-foreground-color: hsla(230, 10%, 30%, .5)}html,body{height:100%;margin:0;overflow:hidden;font-family:var(--font-family)}#toolbar{position:fixed;top:0;left:0;right:0;height:var(--toolbar-height);z-index:var(--z-toolbar);background:var(--bg-toolbar);border-bottom:1px solid var(--border-light);display:flex;align-items:center;padding:0 var(--spacing-lg);gap:var(--spacing-sm);box-shadow:0 1px 3px var(--shadow-xs)}#toolbar md-outlined-button{--md-outlined-button-container-height: var(--button-height);--md-outlined-button-label-text-size: var(--font-size-sm);--md-outlined-button-label-text-weight: 500;--md-outlined-button-icon-size: 16px;--md-outlined-button-leading-space: 10px;--md-outlined-button-trailing-space: 12px;--md-outlined-button-icon-offset: -2px;--md-outlined-button-container-shape: var(--radius-sm)}md-outlined-button.active{--md-outlined-button-container-color: #d0e1ff;--md-outlined-button-label-text-color: var(--accent-primary);--md-outlined-button-outline-color: var(--accent-primary);--md-outlined-button-icon-color: var(--accent-primary)}md-outlined-button.danger{--md-outlined-button-label-text-color: var(--accent-danger);--md-outlined-button-outline-color: var(--accent-danger);--md-outlined-button-icon-color: var(--accent-danger)}.toolbar-separator{width:1px;height:var(--icon-button-size);background:var(--border-light)}#searchInput{width:240px;height:var(--button-height);--md-outlined-text-field-container-shape: var(--radius-sm);--md-outlined-text-field-top-space: var(--spacing-xs);--md-outlined-text-field-bottom-space: var(--spacing-xs);--md-outlined-text-field-input-text-size: var(--font-size-sm);--md-outlined-text-field-label-text-size: var(--font-size-sm)}#searchHelpTrigger{--md-icon-button-icon-size: 18px;--md-icon-button-state-layer-height: var(--button-height);--md-icon-button-state-layer-width: var(--button-height);height:var(--button-height);width:var(--button-height)}.search-help-anchor{position:relative;display:inline-flex}#searchHelp{display:none;position:absolute;top:100%;left:0;margin-top:var(--spacing-xs);z-index:var(--z-search-help);border:1px solid var(--border-medium);border-radius:var(--radius-md);padding:10px 14px;box-shadow:0 4px 12px var(--shadow-md);font-size:var(--font-size-sm);line-height:1.5;background:#1e293b;color:#fff}#searchHelp.open{display:block}#searchHelp code{background:#ffffff1f;padding:1px var(--spacing-xs);border-radius:3px}#content{position:fixed;top:var(--toolbar-height);left:0;right:0;bottom:0}#graph{width:100%;height:100%;position:relative}.details-panel{position:absolute;top:var(--spacing-md);left:var(--spacing-md);width:420px;height:350px;min-width:200px;min-height:120px;max-height:calc(100% - var(--spacing-lg));z-index:var(--z-details-panel);background:var(--bg-panel);box-shadow:0 2px 12px var(--shadow-sm);border:1px solid var(--border-subtle);border-radius:var(--radius-lg);display:none;flex-direction:column;overflow:hidden;resize:both}.details-panel.open{display:flex}.details-panel .panel-header{display:flex;align-items:center;height:var(--button-height);padding:0 2px 0 10px;border-bottom:1px solid var(--border-subtle);flex-shrink:0;cursor:grab;-webkit-user-select:none;user-select:none}.details-panel .panel-header:active{cursor:grabbing}.details-panel .panel-title{font-size:var(--font-size-sm);font-weight:500;color:#333;flex:1}.details-panel md-icon-button{--md-icon-button-icon-size: 16px;--md-icon-button-state-layer-height: var(--icon-button-size);--md-icon-button-state-layer-width: var(--icon-button-size);height:var(--icon-button-size);width:var(--icon-button-size)}.details-panel .panel-body{flex:1;overflow-y:auto;padding:var(--spacing-md);font-family:var(--font-family)}#detailsPanel{border-left:3px solid var(--accent-info)}#detailsPanel .panel-header{background:#1a73e80f}#contextMenu{display:none;position:fixed;z-index:var(--z-context-menu);background:var(--bg-panel);border:1px solid var(--border-medium);border-radius:var(--spacing-sm);padding:var(--spacing-xs) 0;box-shadow:0 4px 12px var(--shadow-md);min-width:160px;font-size:var(--font-size-md)}.context-menu-item{padding:var(--spacing-sm) 14px;cursor:pointer;-webkit-user-select:none;user-select:none}.context-menu-item:hover{background:#0000000f}.context-menu-divider{height:1px;margin:var(--spacing-xs) 0;background:var(--border-medium)}.tp-rotv{font-family:var(--font-family)!important;opacity:.9}#settingsPane{max-height:calc(100% - 20px);position:absolute;overflow-y:auto;right:10px;top:10px}#version-badge{position:fixed;bottom:var(--spacing-sm);left:var(--spacing-md);font-size:var(--font-size-xs);color:#0000004d;pointer-events:none;z-index:var(--z-version-badge);font-family:var(--font-family)}.muted{color:#666}hr{border:none;border-top:1px solid var(--border-subtle);margin:var(--spacing-sm) 0}