fix(network-map): убрать тяжёлую классификацию из poll карты

Не сканировать RIPE и каталог по каждой строке окна; сервисы по уникальным dst и кэшу ASN. Порог доли на карте настраиваемый и отключаемый.

Co-authored-by: Cursor <[email protected]>

app/(main)/network-map/page.tsx

@@ -17,11 +17,14 @@ import {
   buildServerResourceMap,
   buildWanJhEdges,
   computeNetworkMapLayout,
+  NETWORK_MAP_H,
   NETWORK_MAP_LAYOUT_REVISION,
   NETWORK_MAP_PIPELINE_Y,
+  NETWORK_MAP_W,
   findServerByGreRemote,
   greSourceWanIndexOnMap,
   greTunnelProbe,
+  placeServiceNodes,
   type GreMapEdge,
   type WanJhEdge,
 } from "@/lib/network-map-layout"
@@ -41,6 +44,16 @@ import {
   wanJhEdgeMapKey,
   type GreSpeedProbeSnapshot,
 } from "@/lib/map-gre-speed-probe"
+import {
+  formatNetflowDir,
+  formatNetflowRate,
+  hopHasRate,
+  matchNetflowForGreEdge,
+  matchNetflowForWan,
+  type MatchedNetflowHop,
+} from "@/lib/map-netflow-hops"
+import type { FlowMapHop, FlowMapHopsDto, FlowMapService, FlowMapServiceEdge } from "@mmapp/contracts/traffic-flow"
+import { ServiceBrandIcon } from "@/components/network-map/service-brand-icon"
 import { Button } from "@/components/ui/button"
 import { StatusBadge } from "@/components/status-badge"
 import { StatusDot } from "@/components/status-dot"
@@ -226,8 +239,8 @@ function Sparkline({ history }: { history: number[] }) {
 
 // ─── Canvas dimensions ────────────────────────────────────────────────────────
 
-const W = 1060
-const H = 580
+const W = NETWORK_MAP_W
+const H = NETWORK_MAP_H
 const ZOOM_MIN = 0.2
 const ZOOM_MAX = 6
 
@@ -262,6 +275,24 @@ const TYPE_LABELS: Record<ServerType, string> = {
   "home-router": "Home Router",
 }
 
+const MOCK_MAP_SERVICES: FlowMapService[] = [
+  { id: "svc:google", label: "Google", category: "Веб", bytes: 22_000_000, bps: 8_800_000, share: 0.22 },
+  { id: "svc:cloudflare", label: "Cloudflare", category: "CDN", bytes: 14_000_000, bps: 5_600_000, share: 0.14 },
+  { id: "svc:aws", label: "AWS", category: "CDN", bytes: 9_000_000, bps: 3_600_000, share: 0.09 },
+]
+
+const MOCK_MAP_SERVICE_EDGES: FlowMapServiceEdge[] = [
+  { fromId: "srv2", toId: "svc:google", bytes: 14_000_000, bps: 5_600_000, bpsFwd: 4_200_000, bpsRev: 1_400_000 },
+  { fromId: "srv3", toId: "svc:google", bytes: 8_000_000, bps: 3_200_000, bpsFwd: 2_400_000, bpsRev: 800_000 },
+  { fromId: "srv2", toId: "svc:cloudflare", bytes: 9_000_000, bps: 3_600_000, bpsFwd: 2_800_000, bpsRev: 800_000 },
+  { fromId: "srv3", toId: "svc:cloudflare", bytes: 5_000_000, bps: 2_000_000, bpsFwd: 1_500_000, bpsRev: 500_000 },
+  { fromId: "srv3", toId: "svc:aws", bytes: 9_000_000, bps: 3_600_000, bpsFwd: 2_700_000, bpsRev: 900_000 },
+]
+
+function serviceSharePct(share: number): string {
+  return `${Math.round(share * 100)}%`
+}
+
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
 function pingColor(ms: number | null) {
@@ -420,6 +451,53 @@ function GreEdgeMetricBadge({
   )
 }
 
+/** Живой поток NetFlow (не ёмкость канала / не BT). */
+function NetflowRateBadge({
+  mx,
+  my,
+  hop,
+  onOpen,
+}: {
+  mx: number
+  my: number
+  hop: MatchedNetflowHop
+  onOpen?: (e: React.MouseEvent<SVGElement>) => void
+}) {
+  const showDir = hop.bpsFwd > 0 && hop.bpsRev > 0
+  const bw = showDir ? 86 : 72
+  const bh = showDir ? 32 : 20
+  return (
+    <g
+      transform={`translate(${mx},${my})`}
+      style={{ cursor: onOpen ? "pointer" : "default" }}
+      onPointerDown={(e) => { e.stopPropagation() }}
+      onClick={(e) => { e.stopPropagation(); onOpen?.(e) }}
+    >
+      <title>
+        Поток NetFlow между узлами (как в «Трафик»: 5 мин, без overlay/mesh). Скорость канала — отдельно.
+      </title>
+      <rect
+        x={-bw / 2}
+        y={-bh / 2}
+        width={bw}
+        height={bh}
+        rx="6"
+        fill="rgba(6,13,26,0.94)"
+        stroke="#34d399"
+        strokeWidth="1.15"
+      />
+      <text textAnchor="middle" y={showDir ? "-4" : "4"} fontFamily="ui-monospace,monospace">
+        <tspan fill="#6ee7b7" fontSize="8" fontWeight="700">{formatNetflowRate(hop)}</tspan>
+      </text>
+      {showDir && (
+        <text textAnchor="middle" y="10" fontFamily="ui-monospace,monospace">
+          <tspan fill="#34d399" fontSize="6.5" fontWeight="600">{formatNetflowDir(hop)}</tspan>
+        </text>
+      )}
+    </g>
+  )
+}
+
 function SvgTooltip({ n }: { n: Server & { x: number; y: number } }) {
   const ss = STATUS_STYLE[n.status]
   const ts = TYPE_STYLE[n.type]
@@ -552,6 +630,74 @@ function ServerNode({ n, isSel, isVis, isDragged, hideCatalogLatency, onClick, o
   )
 }
 
+function ServiceNode({
+  label,
+  share,
+  x,
+  y,
+  isSel,
+  isVis,
+  onClick,
+}: {
+  label: string
+  share: number
+  x: number
+  y: number
+  isSel: boolean
+  isVis: boolean
+  onClick: () => void
+}) {
+  const bw = 86
+  const bh = 58
+  return (
+    <g
+      transform={`translate(${x},${y})`}
+      style={{ cursor: "pointer", transition: "opacity 0.25s" }}
+      opacity={isVis ? 1 : 0.08}
+      onClick={(e) => { e.stopPropagation(); onClick() }}
+    >
+      <title>{`${label} · ${serviceSharePct(share)} трафика окна`}</title>
+      {isSel && (
+        <rect
+          x={-bw / 2 - 6}
+          y={-bh / 2 - 6}
+          width={bw + 12}
+          height={bh + 12}
+          rx="12"
+          fill="none"
+          stroke="rgba(56,189,248,0.55)"
+          strokeWidth="1.5"
+          strokeDasharray="4 3"
+        />
+      )}
+      <rect
+        x={-bw / 2}
+        y={-bh / 2}
+        width={bw}
+        height={bh}
+        rx="10"
+        fill="#08202c"
+        stroke="#22d3ee"
+        strokeWidth={isSel ? 2.2 : 1.4}
+      />
+      <foreignObject x={-14} y={-24} width={28} height={28} style={{ overflow: "visible", pointerEvents: "none" }}>
+        <div
+          style={{ display: "flex", alignItems: "center", justifyContent: "center", width: 28, height: 28 }}
+          {...({ xmlns: "http://www.w3.org/1999/xhtml" } as Record<string, string>)}
+        >
+          <ServiceBrandIcon label={label} size={22} />
+        </div>
+      </foreignObject>
+      <text textAnchor="middle" y="14" fontSize="8.5" fontWeight="700" fill="#e0f2fe" fontFamily="ui-monospace,monospace">
+        {label}
+      </text>
+      <text textAnchor="middle" y="25" fontSize="7.5" fill="#67e8f9" fontFamily="ui-monospace,monospace">
+        {serviceSharePct(share)}
+      </text>
+    </g>
+  )
+}
+
 function WanSatNode({ x, y, wan, color, active, isSel, isDragged, onSelect, onMouseDown }: {
   x: number; y: number
   wan: { name: string; isp: string; maxDl: number; maxUl: number }
@@ -667,13 +813,14 @@ function ContextMenu({ menu, onClose }: { menu: CtxMenu; onClose: () => void })
 
 const MM_W = 172, MM_H = 94
 
-function Minimap({ pan, zoom, nodes, greEdges, satPos, wanJhEdges, homeRouters, onClose, onPan }: {
+function Minimap({ pan, zoom, nodes, greEdges, satPos, wanJhEdges, homeRouters, servicePos, onClose, onPan }: {
   pan: { x: number; y: number }; zoom: number
   nodes: (Server & { x: number; y: number })[]
   greEdges: GreMapEdge[]
   satPos: Record<string, { x: number; y: number }[]>
   wanJhEdges: WanJhEdge[]
   homeRouters: Server[]
+  servicePos: Record<string, { x: number; y: number }>
   onClose: () => void
   onPan: (x: number, y: number) => void
 }) {
@@ -726,6 +873,10 @@ function Minimap({ pan, zoom, nodes, greEdges, satPos, wanJhEdges, homeRouters,
               fill={WAN_COLORS[i] + "33"} stroke={WAN_COLORS[i]} strokeWidth="3" opacity="0.7" />
           ))
         )}
+        {Object.entries(servicePos).map(([id, p]) => (
+          <rect key={id} x={p.x - 14} y={p.y - 10} width="28" height="20" rx="4"
+            fill="#08202c" stroke="#22d3ee" strokeWidth="3" opacity="0.85" />
+        ))}
         {/* viewport rect */}
         <rect x={pan.x} y={pan.y} width={W / zoom} height={H / zoom}
           fill="rgba(255,255,255,0.04)" stroke="rgba(255,255,255,0.6)" strokeWidth="6" rx="6" />
@@ -784,6 +935,10 @@ export default function NetworkMapPage() {
   const [mapServers, setMapServers] = useState<Server[]>([])
   const [mapGreTunnels, setMapGreTunnels] = useState<GreTunnel[]>([])
   const [speedProbes, setSpeedProbes] = useState<GreSpeedProbeSnapshot[]>([])
+  const [mapHops, setMapHops] = useState<FlowMapHop[]>([])
+  const [mapServices, setMapServices] = useState<FlowMapService[]>([])
+  const [mapServiceEdges, setMapServiceEdges] = useState<FlowMapServiceEdge[]>([])
+  const [mapSharePct, setMapSharePct] = useState(5)
   /** FQDN из GRE outer → IPv4 (ответ POST /api/network/resolve-hosts), для матчинга с WAN. */
   const [greResolvedIpv4ByHost, setGreResolvedIpv4ByHost] = useState<Record<string, string>>({})
   const [dataError, setDataError] = useState<string | null>(null)
@@ -875,6 +1030,10 @@ export default function NetworkMapPage() {
         setMapGreTunnels(mockGreTunnels)
         setSpeedProbes([])
         setGreResolvedIpv4ByHost({})
+        setMapHops([])
+        setMapServices(MOCK_MAP_SERVICES)
+        setMapServiceEdges(MOCK_MAP_SERVICE_EDGES)
+        setMapSharePct(5)
         setDataError(null)
       })
       return
@@ -902,6 +1061,7 @@ export default function NetworkMapPage() {
 
   // ── Interaction ─────────────────────────────────────────────────────────────
   const [selected,   setSelected]   = useState<Server | null>(null)
+  const [selectedService, setSelectedService] = useState<FlowMapService | null>(null)
   const [selWanIdx,  setSelWanIdx]  = useState<number | null>(null)
   const [hoveredId,  setHoveredId]  = useState<string | null>(null)
 
@@ -935,11 +1095,59 @@ export default function NetworkMapPage() {
   const [filter,         setFilter]         = useState<FilterKey>("all")
   const [search,         setSearch]         = useState("")
   const [showPingBadges, setShowPingBadges] = useState(true)
+  const [showNetflow,     setShowNetflow]     = useState(true)
+  const [showServices,    setShowServices]    = useState(true)
   const [showAnimDots,   setShowAnimDots]   = useState(true)
   const [showMinimap,    setShowMinimap]    = useState(true)
   const [showHints,      setShowHints]      = useState(false)
   const [showLayers,     setShowLayers]     = useState(false)
 
+  useEffect(() => {
+    if (!useLiveData) {
+      queueMicrotask(() => {
+        setMapHops([])
+        setMapServices(MOCK_MAP_SERVICES)
+        setMapServiceEdges(MOCK_MAP_SERVICE_EDGES)
+        setMapSharePct(5)
+      })
+      return
+    }
+    if (!showNetflow && !showServices) {
+      queueMicrotask(() => {
+        setMapHops([])
+        setMapServices([])
+        setMapServiceEdges([])
+      })
+      return
+    }
+    let cancelled = false
+    let ac: AbortController | null = null
+    const tick = () => {
+      ac?.abort()
+      ac = new AbortController()
+      apiFetch<FlowMapHopsDto>("/api/traffic/flow/map-hops?range=5m", { signal: ac.signal })
+        .then((res) => {
+          if (cancelled) return
+          setMapHops(res.hops ?? [])
+          setMapServices(res.services ?? [])
+          setMapServiceEdges(res.serviceEdges ?? [])
+          if (res.mapServiceMinSharePct != null) setMapSharePct(res.mapServiceMinSharePct)
+        })
+        .catch((err: unknown) => {
+          if (cancelled) return
+          const name = err instanceof Error ? err.name : ""
+          if (name === "AbortError") return
+        })
+    }
+    tick()
+    const id = window.setInterval(tick, 4000)
+    return () => {
+      cancelled = true
+      ac?.abort()
+      window.clearInterval(id)
+    }
+  }, [useLiveData, showNetflow, showServices, apiFetch])
+
   const effectiveSatPos = useMemo(() => {
     const out: Record<string, { x: number; y: number }[]> = {}
     mapServers
@@ -1100,6 +1308,37 @@ export default function NetworkMapPage() {
     return out
   }, [greEdges])
 
+  const netflowByGreKey = useMemo(() => {
+    const m = new Map<string, MatchedNetflowHop>()
+    if (!showNetflow) return m
+    for (const e of greEdges) {
+      const hop = matchNetflowForGreEdge(e, mapHops)
+      if (hopHasRate(hop)) m.set(greEdgeKey(e), hop)
+    }
+    return m
+  }, [greEdges, mapHops, showNetflow])
+
+  const netflowByWanKey = useMemo(() => {
+    const m = new Map<string, MatchedNetflowHop>()
+    if (!showNetflow) return m
+    for (const home of homeRouters) {
+      for (const [wIdx, wan] of (home.wanUplinks ?? []).entries()) {
+        const hop = matchNetflowForWan(home.id, wan.iface, mapHops)
+        if (!hopHasRate(hop)) continue
+        m.set(`${home.id}\t${wIdx}`, hop)
+        for (const e of wanJhEdges) {
+          if (e.homeId === home.id && e.wanIdx === wIdx) m.set(wanJhEdgeMapKey(e), hop)
+        }
+      }
+    }
+    return m
+  }, [homeRouters, wanJhEdges, mapHops, showNetflow])
+
+  const visibleMapServices = showServices ? mapServices : []
+  const visibleServiceEdges = showServices ? mapServiceEdges.filter((e) =>
+    visibleMapServices.some((s) => s.id === e.toId),
+  ) : []
+
   const nodes = mapServers
     .map((s) => ({ ...s, ...nodePosById[s.id]! }))
     // Визуальный приоритет: HR поверх JH, JH поверх EN.
@@ -1112,6 +1351,14 @@ export default function NetworkMapPage() {
     })
   const nodeById = Object.fromEntries(nodes.map((n) => [n.id, n]))
 
+  const servicePosById = placeServiceNodes(
+    visibleMapServices.map((s) => s.id),
+    mapServers
+      .filter((s) => s.type === "exit-node")
+      .map((s) => nodePosById[s.id])
+      .filter((p): p is { x: number; y: number } => Boolean(p)),
+  )
+
   // ── Refs ─────────────────────────────────────────────────────────────────────
   const svgRef  = useRef<SVGSVGElement>(null)
 
@@ -1186,7 +1433,7 @@ export default function NetworkMapPage() {
   useEffect(() => {
     function onKey(e: KeyboardEvent) {
       if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) return
-      if (e.key === "Escape") { setSelected(null); setSelWanIdx(null); setSelectedGreEdge(null) }
+      if (e.key === "Escape") { setSelected(null); setSelWanIdx(null); setSelectedGreEdge(null); setSelectedService(null) }
       if (e.key === "=" || e.key === "+") applyZoomCenter(1.25)
       if (e.key === "-")                  applyZoomCenter(1 / 1.25)
       if (e.key === "0" || e.key.toLowerCase() === "f") fitView()
@@ -1274,7 +1521,7 @@ export default function NetworkMapPage() {
     const moved = dragRef.current?.moved ?? false
     dragRef.current = null
     setIsDragging(false)
-    if (!moved) { setSelected(null); setSelWanIdx(null); setSelectedGreEdge(null) }
+    if (!moved) { setSelected(null); setSelWanIdx(null); setSelectedGreEdge(null); setSelectedService(null) }
   }
 
   // ── Node drag start ──────────────────────────────────────────────────────
@@ -1306,12 +1553,20 @@ export default function NetworkMapPage() {
   // ── Side panel ────────────────────────────────────────────────────────────
   function selectServer(s: Server) {
     setSelectedGreEdge(null)
+    setSelectedService(null)
     setSelected(prev => prev?.id === s.id ? null : s)
     setSelWanIdx(null)
     setHoveredId(null)
   }
+  function selectService(svc: FlowMapService) {
+    setSelectedGreEdge(null)
+    setSelected(null)
+    setSelWanIdx(null)
+    setSelectedService((prev: FlowMapService | null) => prev?.id === svc.id ? null : svc)
+  }
   function selectWan(s: Server, wanIdx: number) {
     setSelectedGreEdge(null)
+    setSelectedService(null)
     setSelected(s)
     setSelWanIdx(prev => prev === wanIdx && selected?.id === s.id ? null : wanIdx)
   }
@@ -1321,6 +1576,7 @@ export default function NetworkMapPage() {
     const home = mapServers.find((s) => s.id === edge.homeId)
     if (!home) return
     setSelectedGreEdge(null)
+    setSelectedService(null)
     setSelected(home)
     setSelWanIdx(edge.wanIdx)
     setHoveredId(null)
@@ -1461,6 +1717,8 @@ export default function NetworkMapPage() {
               onMouseLeave={() => setShowLayers(false)}>
               {([
                 { key: "showPingBadges", label: "Ping-значки",      val: showPingBadges, set: setShowPingBadges, hint: "P" },
+                { key: "showNetflow",    label: "NetFlow",          val: showNetflow,    set: setShowNetflow,    hint: "" },
+                { key: "showServices",   label: "Сервисы",          val: showServices,   set: setShowServices,   hint: "" },
                 { key: "showAnimDots",   label: "Анимация трафика", val: showAnimDots,   set: setShowAnimDots,   hint: "" },
                 { key: "showMinimap",    label: "Минимап",          val: showMinimap,    set: setShowMinimap,    hint: "M" },
                 { key: "showHints", label: "Горячие клавиши", val: showHints, set: setShowHints, hint: "" },
@@ -1485,6 +1743,11 @@ export default function NetworkMapPage() {
                   </span>
                 </button>
               ))}
+              <p className="px-3 pt-1.5 pb-1 text-[10px] text-muted-foreground leading-snug">
+                {mapSharePct > 0
+                  ? `Порог доли сервиса ≥ ${mapSharePct}% · Настройки → NetFlow`
+                  : "Порог доли выключен (все бренды, макс. 20) · Настройки → NetFlow"}
+              </p>
               {(Object.keys(nodePositions).length > 0 || Object.keys(satPositions).length > 0) && (
                 <div className="border-t border-border/50 mt-1 pt-1">
                   <button
@@ -1588,17 +1851,27 @@ export default function NetworkMapPage() {
                 tBadge,
                 normalPx,
               )
+              const flowHop = netflowByGreKey.get(edgeId)
+              const flowPos = edgeBadgePosition(
+                e.from.x,
+                e.from.y,
+                e.to.x,
+                e.to.y,
+                tBadge,
+                -normalPx - (normalPx === 0 ? 22 : 0),
+              )
               function openGreDetail(ev: React.MouseEvent<SVGElement>) {
                 ev.stopPropagation()
                 setSelectedGreEdge(e)
                 setSelected(null)
+                setSelectedService(null)
                 setSelWanIdx(null)
               }
               return (
                 <g key={edgeId} opacity={dimmed ? 0.05 : 1} style={{ transition: "opacity 0.3s" }}>
                   <line
                     x1={e.from.x} y1={e.from.y} x2={e.to.x} y2={e.to.y}
-                    stroke={ts.stroke} strokeWidth="1.5"
+                    stroke={ts.stroke} strokeWidth={hopHasRate(flowHop) ? 2.6 : 1.5}
                     strokeDasharray={e.tunnel.ipsec ? "7 4" : "none"}
                     opacity={ts.opacity}
                   />
@@ -1632,6 +1905,14 @@ export default function NetworkMapPage() {
                       outerSummary={greOuterSummaryLine(e.tunnel, fromN, toN, greResolvedMap)}
                     />
                   )}
+                  {showNetflow && hopHasRate(flowHop) && (
+                    <NetflowRateBadge
+                      mx={flowPos.mx}
+                      my={flowPos.my}
+                      hop={flowHop}
+                      onOpen={openGreDetail}
+                    />
+                  )}
                 </g>
               )
             })}
@@ -1663,14 +1944,16 @@ export default function NetworkMapPage() {
               const color = WAN_COLORS[edge.wanIdx] ?? "#888"
               const vis   = filter === "all" || filter === "home-router" || filter === "jump-host" || filter === "online"
               const { mx, my } = edgeBadgePosition(satPos.x, satPos.y, jh.x, jh.y, 0.62, -17)
+              const flowPos = edgeBadgePosition(satPos.x, satPos.y, jh.x, jh.y, 0.38, 18)
               const isHL  = selected?.id === edge.homeId && (selWanIdx === null || selWanIdx === edge.wanIdx)
+              const wanFlow = netflowByWanKey.get(wanJhEdgeMapKey(edge))
               return (
                 <g key={edgeKey} opacity={vis ? (isHL ? 1 : 0.45) : 0.05}
                   style={{ transition: "opacity 0.3s" }}>
                   <line
                     x1={satPos.x} y1={satPos.y} x2={jh.x} y2={jh.y}
                     stroke={color}
-                    strokeWidth={edge.active ? 2 : 1.2}
+                    strokeWidth={edge.active ? (hopHasRate(wanFlow) ? 2.8 : 2) : 1.2}
                     strokeDasharray={edge.active ? "none" : "5 4"}
                     opacity={edge.active ? 0.7 : 0.4}
                     filter={isHL ? `url(#glow-wan-${edge.wanIdx})` : undefined}
@@ -1710,6 +1993,58 @@ export default function NetworkMapPage() {
                     }
                     return <PingBadge mx={mx} my={my} ping={edge.pingMs} color={pingColor(edge.pingMs)} />
                   })()}
+                  {showNetflow && hopHasRate(wanFlow) && (
+                    <NetflowRateBadge
+                      mx={flowPos.mx}
+                      my={flowPos.my}
+                      hop={wanFlow}
+                      onOpen={(ev) => openWanJhSpeedDetail(ev, edge)}
+                    />
+                  )}
+                </g>
+              )
+            })}
+
+            {/* ── EN/JH → destination services ── */}
+            {visibleServiceEdges.map((edge) => {
+              const from = nodeById[edge.fromId] ?? nodePosById[edge.fromId]
+              const to = servicePosById[edge.toId]
+              if (!from || !to) return null
+              const hop: MatchedNetflowHop = {
+                bytes: edge.bytes,
+                bps: edge.bps,
+                bpsFwd: edge.bpsFwd,
+                bpsRev: edge.bpsRev,
+              }
+              const { mx, my } = edgeBadgePosition(from.x, from.y, to.x, to.y, 0.55, 16)
+              const hl = selectedService?.id === edge.toId || selected?.id === edge.fromId
+              return (
+                <g key={`${edge.fromId}|${edge.toId}`} opacity={hl ? 1 : 0.72} style={{ transition: "opacity 0.3s" }}>
+                  <line
+                    x1={from.x} y1={from.y} x2={to.x} y2={to.y}
+                    stroke="#22d3ee"
+                    strokeWidth={hopHasRate(hop) ? 2.2 : 1.3}
+                    strokeDasharray="5 5"
+                    opacity="0.7"
+                  />
+                  {showAnimDots && hopHasRate(hop) && (
+                    <circle r="3" fill="#67e8f9" opacity="0.85" pointerEvents="none">
+                      <animateMotion dur="2.6s" repeatCount="indefinite"
+                        path={`M ${from.x} ${from.y} L ${to.x} ${to.y}`} />
+                    </circle>
+                  )}
+                  {hopHasRate(hop) && (
+                    <NetflowRateBadge
+                      mx={mx}
+                      my={my}
+                      hop={hop}
+                      onOpen={(ev) => {
+                        ev.stopPropagation()
+                        const svc = visibleMapServices.find((s) => s.id === edge.toId)
+                        if (svc) selectService(svc)
+                      }}
+                    />
+                  )}
                 </g>
               )
             })}
@@ -1760,6 +2095,26 @@ export default function NetworkMapPage() {
               }).filter(Boolean)
             })}
 
+            {visibleMapServices.map((svc) => {
+              const pos = servicePosById[svc.id]
+              if (!pos) return null
+              return (
+                <ServiceNode
+                  key={svc.id}
+                  label={svc.label}
+                  share={svc.share}
+                  x={pos.x}
+                  y={pos.y}
+                  isSel={selectedService?.id === svc.id}
+                  isVis
+                  onClick={() => {
+                    if (suppressClickRef.current) { suppressClickRef.current = false; return }
+                    selectService(svc)
+                  }}
+                />
+              )
+            })}
+
             {/* ── Hover tooltip ── */}
             {hoveredNode && !isDragging && (
               <SvgTooltip n={hoveredNode} />
@@ -1767,7 +2122,7 @@ export default function NetworkMapPage() {
 
             {/* ── Legend (viewport-fixed) ── */}
             <g transform={`translate(${pan.x + 14}, ${pan.y + 14})`}>
-              <rect width="140" height="224" rx="8"
+              <rect width="140" height="250" rx="8"
                 fill="rgba(6,13,26,0.88)" stroke="rgba(255,255,255,0.07)" strokeWidth="1" />
               <text x="10" y="22" fontSize="8" fontWeight="700" fill="#64748b"
                 fontFamily="system-ui" letterSpacing="0.08em">ЛЕГЕНДА</text>
@@ -1796,12 +2151,17 @@ export default function NetworkMapPage() {
                 </g>
               ))}
 
-              <line x1="10" y1="166" x2="130" y2="166" stroke="rgba(255,255,255,0.07)" strokeWidth="1" />
+              <g transform="translate(10, 164)">
+                <rect width="14" height="14" rx="4" fill="#08202c" stroke="#22d3ee" strokeWidth="1.2" />
+                <text x="22" y="11" fontSize="8.5" fill="#cbd5e1" fontFamily="system-ui">Сервис</text>
+              </g>
 
-              <text x="10" y="180" fontSize="7.5" fontWeight="700" fill="#475569"
+              <line x1="10" y1="186" x2="130" y2="186" stroke="rgba(255,255,255,0.07)" strokeWidth="1" />
+
+              <text x="10" y="200" fontSize="7.5" fontWeight="700" fill="#475569"
                 fontFamily="system-ui" letterSpacing="0.05em">WAN АПЛИНКИ</text>
               {WAN_COLORS.slice(0, 2).map((c, i) => (
-                <g key={i} transform={`translate(10, ${190 + i * 14})`}>
+                <g key={i} transform={`translate(10, ${210 + i * 14})`}>
                   <circle cx="5" cy="4" r="4" fill={c} opacity="0.9" />
                   <text x="16" y="8" fontSize="8" fill="#94a3b8" fontFamily="ui-monospace,monospace">
                     WAN{i + 1}
@@ -1857,6 +2217,7 @@ export default function NetworkMapPage() {
               satPos={effectiveSatPos}
               wanJhEdges={visibleWanJhEdges}
               homeRouters={homeRouters}
+              servicePos={servicePosById}
               onClose={() => setShowMinimap(false)}
               onPan={(x, y) => setPan({ x, y })}
             />
@@ -1885,7 +2246,7 @@ export default function NetworkMapPage() {
         </div>
 
         {/* ── Side panel (узел или выбранное GRE-ребро) ── */}
-        {(selectedGreEdge || selected) && (
+        {(selectedGreEdge || selected || selectedService) && (
           <div className="border-l flex flex-col overflow-hidden shrink-0 bg-background" style={{ width: 300 }}>
             {selectedGreEdge ? (
               <>
@@ -1976,7 +2337,7 @@ export default function NetworkMapPage() {
                             </div>
                             <div className="flex items-center justify-between py-2 border-b border-border/50">
                               <span className="text-xs text-muted-foreground">
-                                {bwMon ? "TX / RX (BT)" : "Скорость (модель)"}
+                                {bwMon ? "TX / RX (BT)" : "Скорость канала (модель)"}
                               </span>
                               <span className="text-xs font-mono font-semibold text-sky-400">
                                 {merged.dlMbps != null && merged.ulMbps != null
@@ -1984,10 +2345,23 @@ export default function NetworkMapPage() {
                                   : "—"}
                               </span>
                             </div>
+                            <div className="flex items-center justify-between py-2 border-b border-border/50">
+                              <span className="text-xs text-muted-foreground">Поток (NetFlow)</span>
+                              <span className="text-xs font-mono font-semibold text-emerald-400">
+                                {(() => {
+                                  const hop = netflowByGreKey.get(selectedEdgeId)
+                                  if (!hopHasRate(hop)) return "—"
+                                  return hop.bpsFwd > 0 && hop.bpsRev > 0
+                                    ? formatNetflowDir(hop)
+                                    : formatNetflowRate(hop)
+                                })()}
+                              </span>
+                            </div>
                             <p className="text-[10px] text-muted-foreground pt-2 leading-snug">
                               {merged.hasSpeedMonitor
-                                ? "Ping и/или TX/RX — с последнего прогона speed-пробы; проба сопоставляется с этим GRE по WAN и интерфейсам."
-                                : "«Модель RTT» и «скорость» — демо до появления подходящей speed-пробы в «Мониторинг → скорость»."}
+                                ? "Ping и/или TX/RX — с последнего прогона speed-пробы; проба сопоставляется с этим GRE по WAN и интерфейсам. "
+                                : "«Модель RTT» и «скорость канала» — демо до появления подходящей speed-пробы в «Мониторинг → скорость». "}
+                              Поток — живой NetFlow за 5 мин (как в «Трафик»: без overlay/mesh), не ёмкость канала.
                             </p>
                           </div>
                         </div>
@@ -2078,6 +2452,62 @@ export default function NetworkMapPage() {
                   })()}
                 </div>
               </>
+            ) : selectedService ? (
+              <>
+                <div className="flex items-start gap-2 px-4 py-3 border-b">
+                  <div className="mt-0.5">
+                    <ServiceBrandIcon label={selectedService.label} size={22} />
+                  </div>
+                  <div className="flex-1 min-w-0">
+                    <p className="font-mono font-semibold text-sm truncate">{selectedService.label}</p>
+                    <p className="text-xs text-muted-foreground mt-0.5">
+                      Конечный сервис · {selectedService.category}
+                    </p>
+                  </div>
+                  <button
+                    type="button"
+                    onClick={() => setSelectedService(null)}
+                    className="text-muted-foreground hover:text-foreground transition-colors"
+                  >
+                    <XIcon className="size-4" />
+                  </button>
+                </div>
+                <div className="flex-1 overflow-y-auto px-4 py-4 flex flex-col gap-4">
+                  <div className="flex flex-col gap-0">
+                    <div className="flex items-center justify-between py-2 border-b border-border/50">
+                      <span className="text-xs text-muted-foreground">Доля окна</span>
+                      <span className="text-xs font-mono font-medium text-cyan-400">{serviceSharePct(selectedService.share)}</span>
+                    </div>
+                    <div className="flex items-center justify-between py-2 border-b border-border/50">
+                      <span className="text-xs text-muted-foreground">Скорость</span>
+                      <span className="text-xs font-mono font-medium">
+                        {formatNetflowRate({
+                          bytes: selectedService.bytes,
+                          bps: selectedService.bps,
+                          bpsFwd: selectedService.bps,
+                          bpsRev: 0,
+                        })}
+                      </span>
+                    </div>
+                  </div>
+                  <div>
+                    <p className="text-xs font-semibold text-muted-foreground uppercase tracking-wider mb-2">С узлов</p>
+                    <div className="flex flex-col gap-1.5">
+                      {visibleServiceEdges.filter((e) => e.toId === selectedService.id).map((e) => {
+                        const src = mapServers.find((s) => s.id === e.fromId)
+                        return (
+                          <div key={`${e.fromId}|${e.toId}`} className="flex items-center justify-between text-xs">
+                            <span className="font-mono truncate">{src?.name ?? e.fromId}</span>
+                            <span className="font-mono text-emerald-400 tabular-nums">
+                              {formatNetflowRate({ bytes: e.bytes, bps: e.bps, bpsFwd: e.bpsFwd, bpsRev: e.bpsRev })}
+                            </span>
+                          </div>
+                        )
+                      })}
+                    </div>
+                  </div>
+                </div>
+              </>
             ) : selected ? (
               <>
             <div className="flex items-start gap-2 px-4 py-3 border-b">
@@ -2168,12 +2598,26 @@ export default function NetworkMapPage() {
                           </div>
                           <div className="flex flex-col gap-1">
                             {[["ISP", wan.isp], ["Iface", wan.iface], ["IP", wan.ip],
-                              ["BW", `↓${wan.maxDl} ↑${wan.maxUl} Мбит`]].map(([k, v]) => (
+                              ["Канал", `↓${wan.maxDl} ↑${wan.maxUl} Мбит`]].map(([k, v]) => (
                               <div key={k} className="flex items-center justify-between">
                                 <span className="text-[10px] text-muted-foreground">{k}</span>
                                 <span className="text-[10px] font-mono">{v}</span>
                               </div>
                             ))}
+                            {(() => {
+                              const hop = netflowByWanKey.get(`${selected.id}\t${wIdx}`)
+                              if (!hopHasRate(hop)) return null
+                              return (
+                                <div className="flex items-center justify-between">
+                                  <span className="text-[10px] text-muted-foreground">Поток</span>
+                                  <span className="text-[10px] font-mono text-emerald-400">
+                                    {hop.bpsFwd > 0 && hop.bpsRev > 0
+                                      ? formatNetflowDir(hop)
+                                      : formatNetflowRate(hop)}
+                                  </span>
+                                </div>
+                              )
+                            })()}
                           </div>
                           {myEdges.length > 0 && (
                             <div className="mt-2 pt-2 border-t border-border/40">
@@ -2230,9 +2674,11 @@ export default function NetworkMapPage() {
                         fromServer && toServer ? speedProbeByTunnelId.get(tunnelPanelKey) : undefined
                       const merged = mergeGreMetricsWithSpeedProbe(spGre, baseProbe)
                       const pc     = pingColor(merged.pingMs)
+                      const greFlow = netflowByGreKey.get(tunnelPanelKey)
                       const showMetrics =
                         merged.pingMs != null ||
-                        (merged.dlMbps != null && merged.ulMbps != null)
+                        (merged.dlMbps != null && merged.ulMbps != null) ||
+                        hopHasRate(greFlow)
                       return (
                         <div key={tunnelPanelKey} className="rounded-md border border-border/60 px-3 py-2 bg-muted/20">
                           <div className="flex items-center justify-between mb-1">
@@ -2272,6 +2718,11 @@ export default function NetworkMapPage() {
                                     ↓{merged.dlMbps} ↑{merged.ulMbps}
                                   </span>
                                 )}
+                                {hopHasRate(greFlow) && (
+                                  <span className="text-[9px] ml-1.5 text-emerald-400">
+                                    {formatNetflowRate(greFlow)}
+                                  </span>
+                                )}
                               </span>
                             </div>
                           )}

backend/package.json

@@ -14,7 +14,7 @@
     "test:auth": "tsx src/lib/permissions.test.ts && tsx src/plugins/auth.smoke.test.ts",
     "test:wireguard": "npx tsx src/services/wireguard-config.test.ts",
     "test:traffic-rate": "tsx src/services/traffic-rate.test.ts",
-    "test:traffic-flow": "tsx src/services/traffic-flow-parse.test.ts && tsx src/services/traffic-flow-map-exporter.test.ts && tsx src/services/traffic-flow-ifaces.test.ts && tsx src/services/traffic-flow-dedup.test.ts && tsx src/services/traffic-flow-planes.test.ts && tsx src/services/traffic-flow-classify.test.ts && tsx src/services/traffic-flow-ripe.test.ts && tsx src/services/traffic-flow-brands.test.ts && tsx src/services/traffic-flow-ingest.test.ts && tsx src/services/traffic-flow-analytics.test.ts && tsx src/services/traffic-flow-hardening.test.ts && tsx src/services/traffic-flow-purge.test.ts",
+    "test:traffic-flow": "tsx src/services/traffic-flow-parse.test.ts && tsx src/services/traffic-flow-map-exporter.test.ts && tsx src/services/traffic-flow-ifaces.test.ts && tsx src/services/traffic-flow-dedup.test.ts && tsx src/services/traffic-flow-planes.test.ts && tsx src/services/traffic-flow-classify.test.ts && tsx src/services/traffic-flow-ripe.test.ts && tsx src/services/traffic-flow-brands.test.ts && tsx src/services/traffic-flow-ingest.test.ts && tsx src/services/traffic-flow-analytics.test.ts && tsx src/services/traffic-flow-map-hops.test.ts && tsx src/services/traffic-flow-hardening.test.ts && tsx src/services/traffic-flow-purge.test.ts",
     "test:users": "tsx src/modules/users/iface-type.test.ts && tsx src/modules/users/bindings.test.ts"
   },
   "dependencies": {

backend/src/db/index.ts

@@ -146,6 +146,7 @@ CREATE TABLE IF NOT EXISTS traffic_flow_settings (
   hub_server_id INTEGER,
   retention_hours INTEGER NOT NULL DEFAULT 24,
   top_n INTEGER NOT NULL DEFAULT 200,
+  map_service_min_share_pct REAL NOT NULL DEFAULT 5,
   last_datagram_at TEXT,
   last_exporter_ip TEXT,
   last_error TEXT,
@@ -834,6 +835,13 @@ SELECT 1, 0, '10.255.254.1', 4739, 51821, '10.255.254.0/24'
 WHERE NOT EXISTS (SELECT 1 FROM traffic_flow_settings WHERE id = 1);
 `)
 
+{
+  const flowSettingsCols = sqlite.prepare(`PRAGMA table_info('traffic_flow_settings')`).all() as Array<{ name?: string }>
+  if (!flowSettingsCols.some((c) => c.name === "map_service_min_share_pct")) {
+    sqlite.exec(`ALTER TABLE traffic_flow_settings ADD COLUMN map_service_min_share_pct REAL NOT NULL DEFAULT 5`)
+  }
+}
+
 sqlite.exec(`
 INSERT INTO uptime_settings (id, enabled, interval_sec, retention_days)
 SELECT 1, 1, 15, 14

backend/src/db/schema.ts

@@ -173,6 +173,7 @@ export const trafficFlowSettings = sqliteTable("traffic_flow_settings", {
   hubServerId:     integer("hub_server_id"),
   retentionHours:  integer("retention_hours").notNull().default(24),
   topN:            integer("top_n").notNull().default(200),
+  mapServiceMinSharePct: real("map_service_min_share_pct").notNull().default(5),
   lastDatagramAt:  text("last_datagram_at"),
   lastExporterIp:  text("last_exporter_ip"),
   lastError:       text("last_error"),

backend/src/routes/traffic-flow.ts

@@ -24,6 +24,7 @@ import {
   listFlowExporters,
   safeBuildLiveFlowSample,
 } from "../services/traffic-flow-analytics.js"
+import { buildFlowMapHops } from "../services/traffic-flow-map-hops.js"
 import { applyFlowOverlay } from "../services/traffic-flow-overlay.js"
 import { listTrafficFlowHostFiles } from "../services/traffic-flow-host-files.js"
 import { appendEvent } from "../modules/events/service/events-service.js"
@@ -222,6 +223,10 @@ const trafficFlowRoutes: FastifyPluginAsyncZod = async (app) => {
     return reply.send(buildFlowAnalytics(analyticsQuery(req)))
   })
 
+  app.get("/traffic/flow/map-hops", async (req, reply) => {
+    return reply.send(buildFlowMapHops(analyticsQuery(req)))
+  })
+
   app.get("/traffic/flow/monthly", async (req, reply) => {
     const q = req.query as { month?: string; serverId?: string }
     const now = new Date()

backend/src/services/traffic-flow-brands.test.ts

@@ -4,6 +4,8 @@ import {
   countryFromHolder,
   lookupBrand,
   OTHER_SERVICE,
+  isNamedInternetService,
+  mapServiceNodeId,
   resolveRipeCountry,
 } from "./traffic-flow-brands.js"
 
@@ -21,9 +23,17 @@ assert.equal(brandByAsn(15169)?.category, "Веб")
 assert.equal(lookupBrand("208.65.153.1", 0)?.service, "YouTube")
 assert.equal(brandByAsn(32590)?.service, "Steam")
 assert.equal(brandByAsn(32590)?.category, "Игры")
+assert.equal(brandByAsn(16509)?.service, "AWS")
+assert.equal(brandByAsn(57976)?.service, "Blizzard")
 assert.equal(brandByAsn(401115)?.service, "ChatGPT")
 assert.equal(lookupBrand("1.1.1.1", 13335)?.service, "Cloudflare")
 assert.equal(lookupBrand("203.0.113.9", 64500), null)
 assert.equal(OTHER_SERVICE, "Прочее")
+assert.equal(isNamedInternetService("Google", "Веб"), true)
+assert.equal(isNamedInternetService("Прочее", "Прочее"), false)
+assert.equal(isNamedInternetService("GRE", "Туннель"), false)
+assert.equal(isNamedInternetService("DNS", "DNS"), false)
+assert.equal(mapServiceNodeId("AWS"), "svc:aws")
+assert.equal(mapServiceNodeId("Cloudflare"), "svc:cloudflare")
 
 console.log("traffic-flow-brands.test.ts: ok")

backend/src/services/traffic-flow-brands.ts

@@ -12,11 +12,12 @@ const ASN_BRANDS = new Map<number, BrandHit>([
   [209242, { service: "Cloudflare", category: "CDN" }],
   [54113, { service: "Fastly", category: "CDN" }],
   [20940, { service: "Akamai", category: "CDN" }],
-  [16509, { service: "Amazon", category: "CDN" }],
-  [14618, { service: "Amazon", category: "CDN" }],
+  [16509, { service: "AWS", category: "CDN" }],
+  [14618, { service: "AWS", category: "CDN" }],
   [8075, { service: "Microsoft", category: "CDN" }],
   [13238, { service: "Yandex", category: "CDN" }],
   [32590, { service: "Steam", category: "Игры" }],
+  [57976, { service: "Blizzard", category: "Игры" }],
   [2906, { service: "Netflix", category: "Видео / стриминг" }],
   [40027, { service: "Netflix", category: "Видео / стриминг" }],
   [15169, { service: "Google", category: "Веб" }],
@@ -41,6 +42,7 @@ const ASN_HQ_COUNTRY = new Map<number, string>([
   [8075, "US"],
   [15169, "US"],
   [32590, "US"],
+  [57976, "US"],
   [2906, "US"],
   [40027, "US"],
   [36040, "US"],
@@ -105,3 +107,32 @@ export function brandByCidr(ip: string): BrandHit | null {
 export function lookupBrand(ip: string, asn: number): BrandHit | null {
   return brandByCidr(ip) || brandByAsn(asn)
 }
+
+const SKIP_MAP_SERVICES = new Set([
+  OTHER_SERVICE,
+  "GRE",
+  "ESP",
+  "WireGuard",
+  "DNS",
+  "SSH",
+  "BGP",
+])
+
+const SKIP_MAP_CATEGORIES = new Set(["Туннель", "DNS", "SSH", "BGP"])
+
+/** Именованный интернет-сервис для карты (не туннель и не «Прочее»). */
+export function isNamedInternetService(service: string, category: string): boolean {
+  const s = service.trim()
+  const c = category.trim()
+  if (!s || SKIP_MAP_SERVICES.has(s) || SKIP_MAP_CATEGORIES.has(c)) return false
+  return true
+}
+
+export function mapServiceNodeId(label: string): string {
+  const slug = label
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+  return `svc:${slug || "unknown"}`
+}

backend/src/services/traffic-flow-map-hops.test.ts

@@ -0,0 +1,281 @@
+import assert from "node:assert/strict"
+import { rememberServerIfaces, resetIfaceCacheForTests } from "./traffic-flow-ifindex.js"
+import {
+  ingestParsedFlowsForServerForTests,
+  resetFlowRingsForTests,
+} from "./traffic-flow-ingest.js"
+import { buildFlowMapHops, resetFlowMapHopsCacheForTests } from "./traffic-flow-map-hops.js"
+import { seedFlowTopologyForTests, type FlowTopology } from "./traffic-flow-topology.js"
+import { disableCatalogFetchForTests, resetFlowCatalogForTests } from "./traffic-flow-classify.js"
+import {
+  disableRipeEnqueueForTests,
+  disableRipePersistForTests,
+  resetRipeCacheForTests,
+  seedRipeCacheForTests,
+} from "./traffic-flow-ripe.js"
+
+disableCatalogFetchForTests()
+resetFlowCatalogForTests()
+disableRipePersistForTests()
+resetRipeCacheForTests()
+disableRipeEnqueueForTests()
+
+const topo: FlowTopology = {
+  clientIfaces: new Map([[7, new Set(["gre-client"])]]),
+  clientByIface: new Map([["7|gre-client", {
+    userId: "u1",
+    login: "alice",
+    name: "Alice",
+    serverId: 7,
+    interfaceName: "gre-client",
+  }]]),
+  enNodes: [{ id: 9, name: "NSK-EN", hosts: ["198.51.100.1"] }],
+  enHosts: new Set(["198.51.100.1"]),
+  jhHosts: new Set(["203.0.113.10"]),
+  wanIfaces: new Map([[3, new Set(["ether1-rt"])]]),
+  plane: {
+    clientIfaceNames: new Set(["gre-client"]),
+    enHosts: new Set(["198.51.100.1"]),
+    jhHosts: new Set(["203.0.113.10"]),
+  },
+}
+
+resetFlowRingsForTests()
+resetIfaceCacheForTests()
+seedFlowTopologyForTests(topo)
+rememberServerIfaces(7, [
+  { ".id": "*2", name: "gre-client" },
+  { ".id": "*3", name: "gre-jh-en" },
+  { ".id": "*A", name: "wg-flow" },
+])
+rememberServerIfaces(3, [
+  { ".id": "*1", name: "ether1-rt" },
+])
+
+ingestParsedFlowsForServerForTests(7, [
+  {
+    src: "10.100.1.17",
+    dst: "8.8.8.8",
+    proto: 6,
+    srcPort: 51234,
+    dstPort: 443,
+    bytes: 12_000,
+    packets: 10,
+    inIface: "2",
+    outIface: "3",
+    nextHop: "198.51.100.1",
+  },
+  {
+    src: "203.0.113.10",
+    dst: "198.51.100.1",
+    proto: 47,
+    srcPort: 0,
+    dstPort: 0,
+    bytes: 5_000_000,
+    packets: 4000,
+    inIface: "3",
+    outIface: "3",
+  },
+  {
+    src: "10.100.1.17",
+    dst: "10.100.1.18",
+    proto: 6,
+    srcPort: 50000,
+    dstPort: 443,
+    bytes: 8000,
+    packets: 8,
+    inIface: "2",
+    outIface: "2",
+  },
+  {
+    src: "10.255.254.1",
+    dst: "10.255.254.2",
+    proto: 17,
+    srcPort: 4739,
+    dstPort: 2055,
+    bytes: 400,
+    packets: 2,
+    inIface: "10",
+    outIface: "",
+  },
+])
+ingestParsedFlowsForServerForTests(3, [
+  {
+    src: "192.168.1.10",
+    dst: "8.8.4.4",
+    proto: 6,
+    srcPort: 40000,
+    dstPort: 443,
+    bytes: 3000,
+    packets: 4,
+    inIface: "1",
+    outIface: "1",
+  },
+])
+
+try {
+  resetFlowMapHopsCacheForTests()
+  const def = buildFlowMapHops({ minutes: 5 })
+  assert.equal(def.excludeOverlayApplied, true)
+  assert.equal(def.excludeMeshApplied, true)
+  assert.equal(def.dedupApplied, true)
+  assert.equal(def.windowSec, 300)
+
+  const payloadGre = def.hops.find((h) => h.kind === "gre" && h.fromId === "7" && h.toId === "9")
+  assert.ok(payloadGre, "payload JH→EN hop")
+  assert.equal(payloadGre.bytes, 12_000)
+  assert.equal(payloadGre.bps, (12_000 * 8) / 300)
+  assert.equal(payloadGre.bpsFwd, (12_000 * 8) / 300)
+  assert.equal(payloadGre.iface, "gre-jh-en")
+
+  const greIface = def.hops.find((h) => h.kind === "iface" && h.iface === "gre-jh-en" && h.fromId === "7")
+  assert.ok(greIface)
+  assert.equal(greIface.bytes, 12_000)
+  assert.equal(greIface.bpsFwd, (12_000 * 8) / 300)
+
+  assert.ok(!def.hops.some((h) => h.bytes >= 5_000_000), "overlay GRE proto 47 excluded")
+  assert.ok(!def.hops.some((h) => h.iface === "wg-flow"), "mgmt wg-flow excluded")
+  const clientIngress = def.hops.find((h) => h.iface === "gre-client" && h.fromId === "7" && h.kind === "iface")
+  assert.ok(clientIngress, "payload ingress on client iface")
+  assert.equal(clientIngress.bytes, 12_000)
+
+  const wan = def.hops.find((h) => h.kind === "wan" && h.fromId === "3" && h.iface === "ether1-rt")
+  assert.ok(wan, "WAN hop from home-router")
+  assert.equal(wan.bytes, 3000)
+
+  resetFlowMapHopsCacheForTests()
+  const withAll = buildFlowMapHops({ minutes: 5, excludeOverlay: false, excludeMesh: false })
+  const overlayIface = withAll.hops.find((h) => h.iface === "gre-jh-en" && h.fromId === "7")
+  assert.ok(overlayIface && overlayIface.bytes >= 5_000_000)
+  const meshIface = withAll.hops.find((h) => h.iface === "gre-client" && h.fromId === "7" && h.kind === "iface")
+  assert.ok(meshIface && meshIface.bytes >= 20_000)
+} finally {
+  seedFlowTopologyForTests(null)
+  resetFlowRingsForTests()
+  resetIfaceCacheForTests()
+  resetRipeCacheForTests()
+  resetFlowCatalogForTests()
+}
+
+console.log("traffic-flow-map-hops.test.ts: hops ok")
+
+function googleRipe() {
+  seedRipeCacheForTests({
+    prefix: "8.8.8.0/24",
+    asn: 15169,
+    country: "US",
+    lat: 37.4,
+    lng: -122.1,
+    holder: "GOOGLE",
+    ok: true,
+    fetchedAt: Date.now(),
+  })
+}
+
+function payloadFlow(dst: string, bytes: number) {
+  return {
+    src: "10.100.1.17",
+    dst,
+    proto: 6,
+    srcPort: 51234,
+    dstPort: 443,
+    bytes,
+    packets: Math.max(1, Math.round(bytes / 1200)),
+    inIface: "2",
+    outIface: "3",
+    nextHop: "198.51.100.1",
+  }
+}
+
+resetFlowRingsForTests()
+resetIfaceCacheForTests()
+resetRipeCacheForTests()
+disableRipeEnqueueForTests()
+seedFlowTopologyForTests(topo)
+rememberServerIfaces(7, [
+  { ".id": "*2", name: "gre-client" },
+  { ".id": "*3", name: "gre-jh-en" },
+])
+googleRipe()
+ingestParsedFlowsForServerForTests(7, [
+  payloadFlow("8.8.8.8", 600),
+  payloadFlow("203.0.113.50", 9400),
+])
+try {
+  resetFlowMapHopsCacheForTests()
+  const six = buildFlowMapHops({ minutes: 5, minSharePct: 5 })
+  assert.equal(six.totalBytes, 10_000)
+  const google = six.services?.find((s) => s.id === "svc:google")
+  assert.ok(google, "Google ≥ 5%")
+  assert.ok(google.share >= 0.05)
+  assert.ok(six.serviceEdges?.some((e) => e.toId === "svc:google" && e.fromId === "9"))
+} finally {
+  resetFlowRingsForTests()
+  resetIfaceCacheForTests()
+  resetRipeCacheForTests()
+}
+
+resetFlowRingsForTests()
+resetIfaceCacheForTests()
+resetRipeCacheForTests()
+disableRipeEnqueueForTests()
+seedFlowTopologyForTests(topo)
+rememberServerIfaces(7, [
+  { ".id": "*2", name: "gre-client" },
+  { ".id": "*3", name: "gre-jh-en" },
+])
+googleRipe()
+ingestParsedFlowsForServerForTests(7, [
+  payloadFlow("8.8.8.8", 400),
+  payloadFlow("203.0.113.50", 9600),
+])
+try {
+  resetFlowMapHopsCacheForTests()
+  const four = buildFlowMapHops({ minutes: 5, minSharePct: 5 })
+  assert.equal(four.totalBytes, 10_000)
+  assert.ok(!(four.services ?? []).some((s) => s.id === "svc:google"), "Google < 5% hidden")
+  resetFlowMapHopsCacheForTests()
+  const off = buildFlowMapHops({ minutes: 5, minSharePct: 0 })
+  assert.ok(off.services?.some((s) => s.id === "svc:google"), "порог 0 показывает Google 4%")
+} finally {
+  resetFlowRingsForTests()
+  resetIfaceCacheForTests()
+  resetRipeCacheForTests()
+}
+
+resetFlowRingsForTests()
+resetIfaceCacheForTests()
+resetRipeCacheForTests()
+disableRipeEnqueueForTests()
+seedFlowTopologyForTests(topo)
+rememberServerIfaces(7, [
+  { ".id": "*2", name: "gre-client" },
+  { ".id": "*3", name: "gre-jh-en" },
+])
+ingestParsedFlowsForServerForTests(7, [
+  {
+    src: "203.0.113.10",
+    dst: "198.51.100.1",
+    proto: 47,
+    srcPort: 0,
+    dstPort: 0,
+    bytes: 9_000,
+    packets: 90,
+    inIface: "3",
+    outIface: "3",
+  },
+  payloadFlow("203.0.113.50", 1000),
+])
+try {
+  resetFlowMapHopsCacheForTests()
+  const greOnly = buildFlowMapHops({ minutes: 5, excludeOverlay: false, minSharePct: 0 })
+  assert.ok(!(greOnly.services ?? []).some((s) => s.label === "GRE"), "GRE is not a destination service")
+} finally {
+  seedFlowTopologyForTests(null)
+  resetFlowRingsForTests()
+  resetIfaceCacheForTests()
+  resetRipeCacheForTests()
+  resetFlowCatalogForTests()
+}
+
+console.log("traffic-flow-map-hops.test.ts: ok")

backend/src/services/traffic-flow-map-hops.ts

@@ -0,0 +1,382 @@
+import { eq } from "drizzle-orm"
+import type { FlowMapHop, FlowMapHopsDto, FlowMapService, FlowMapServiceEdge } from "@mmapp/contracts/traffic-flow"
+import { db } from "../db/index.js"
+import { servers, userInterfaceBindings } from "../db/schema.js"
+import { applicationName, flowRowMatchesFilter } from "./traffic-flow-apps.js"
+import {
+  isNamedInternetService,
+  lookupBrand,
+  mapServiceNodeId,
+} from "./traffic-flow-brands.js"
+import { dedupFlowRowsMaxBytes } from "./traffic-flow-dedup.js"
+import { getFlowListenerState, listFlowRowsForWindow } from "./traffic-flow-ingest.js"
+import { resolveIfaceName } from "./traffic-flow-ifaces.js"
+import { classifyFlowPlane, shouldKeepPlane } from "./traffic-flow-planes.js"
+import { lookupRipeCached, type FlowIpMeta } from "./traffic-flow-ripe.js"
+import { getTrafficFlowSettingsRow } from "./traffic-flow-settings.js"
+import { loadFlowTopology, resolveEn } from "./traffic-flow-topology.js"
+
+export const DEFAULT_MAP_SERVICE_MIN_SHARE_PCT = 5
+export const MAP_SERVICE_NODE_CAP = 20
+const HOPS_CACHE_TTL_MS = 2000
+
+export interface FlowMapHopsQuery {
+  minutes: number
+  serverId?: number
+  userId?: string
+  iface?: string
+  dedup?: boolean
+  excludeMesh?: boolean
+  excludeOverlay?: boolean
+  /** Переопределение порога (тесты). Иначе из настроек NetFlow. */
+  minSharePct?: number
+}
+
+interface HopAcc {
+  fromId: string
+  fromLabel: string
+  toId: string
+  toLabel: string
+  kind: FlowMapHop["kind"]
+  iface?: string
+  bytes: number
+  bytesFwd: number
+  bytesRev: number
+}
+
+interface DstAcc {
+  bytes: number
+  proto: number
+  dstPort: number
+  srcPort: number
+  fromBytes: Map<string, number>
+}
+
+let hopsCache: { key: string; at: number; dto: FlowMapHopsDto } | null = null
+
+export function resetFlowMapHopsCacheForTests(): void {
+  hopsCache = null
+}
+
+export function clampMapServiceMinSharePct(n: unknown): number {
+  const v = typeof n === "number" ? n : Number(n)
+  if (!Number.isFinite(v)) return DEFAULT_MAP_SERVICE_MIN_SHARE_PCT
+  return Math.min(100, Math.max(0, v))
+}
+
+function hopsQueryKey(q: FlowMapHopsQuery, minSharePct: number): string {
+  return JSON.stringify({
+    minutes: q.minutes,
+    serverId: q.serverId ?? null,
+    userId: q.userId ?? null,
+    iface: q.iface ?? null,
+    dedup: q.dedup !== false,
+    excludeMesh: q.excludeMesh !== false,
+    excludeOverlay: q.excludeOverlay !== false,
+    minSharePct,
+  })
+}
+
+function userIfaceAllow(userId: string): Map<number, Set<string>> | null {
+  if (!userId) return null
+  const binds = db.select().from(userInterfaceBindings).where(eq(userInterfaceBindings.userId, userId)).all()
+  const allow = new Map<number, Set<string>>()
+  for (const b of binds) {
+    const set = allow.get(b.serverId) ?? new Set<string>()
+    set.add(b.interfaceName)
+    allow.set(b.serverId, set)
+  }
+  return allow
+}
+
+function ifaceUsable(name: string): boolean {
+  return Boolean(name) && name !== "—"
+}
+
+function bump(acc: Map<string, HopAcc>, key: string, seed: Omit<HopAcc, "bytes" | "bytesFwd" | "bytesRev">, bytes: number, dir: "fwd" | "rev" | "both"): void {
+  const prev = acc.get(key)
+  const addFwd = dir === "fwd" || dir === "both" ? bytes : 0
+  const addRev = dir === "rev" || dir === "both" ? bytes : 0
+  if (prev) {
+    prev.bytes += bytes
+    prev.bytesFwd += addFwd
+    prev.bytesRev += addRev
+    if (seed.iface && !prev.iface) prev.iface = seed.iface
+    return
+  }
+  acc.set(key, {
+    ...seed,
+    bytes,
+    bytesFwd: addFwd,
+    bytesRev: addRev,
+  })
+}
+
+function toHop(a: HopAcc, windowSec: number): FlowMapHop {
+  return {
+    fromId: a.fromId,
+    fromLabel: a.fromLabel,
+    toId: a.toId,
+    toLabel: a.toLabel,
+    kind: a.kind,
+    ...(a.iface ? { iface: a.iface } : {}),
+    bytes: a.bytes,
+    bps: (a.bytes * 8) / windowSec,
+    bpsFwd: (a.bytesFwd * 8) / windowSec,
+    bpsRev: (a.bytesRev * 8) / windowSec,
+  }
+}
+
+/** Имя бренда без каталога EvoBGP — только ASN/CIDR кэш + proto. */
+function classifyMapDstLite(
+  dst: string,
+  proto: number,
+  dstPort: number,
+  srcPort: number,
+  ripe: FlowIpMeta | null,
+): { service: string; category: string } | null {
+  if (proto === 47 || proto === 50) return null
+  const app = applicationName(proto, dstPort, srcPort)
+  if (app === "WireGuard" || app === "DNS" || app === "SSH" || app === "BGP") return null
+  if (/youtube/i.test(ripe?.holder ?? "")) {
+    return { service: "YouTube", category: "Видео / стриминг" }
+  }
+  const brand = lookupBrand(dst, ripe?.asn ?? 0)
+  if (!brand || !isNamedInternetService(brand.service, brand.category)) return null
+  return brand
+}
+
+function resolveMinSharePct(q: FlowMapHopsQuery): number {
+  if (q.minSharePct != null) return clampMapServiceMinSharePct(q.minSharePct)
+  try {
+    const row = getTrafficFlowSettingsRow() as { mapServiceMinSharePct?: number }
+    return clampMapServiceMinSharePct(row.mapServiceMinSharePct ?? DEFAULT_MAP_SERVICE_MIN_SHARE_PCT)
+  } catch {
+    return DEFAULT_MAP_SERVICE_MIN_SHARE_PCT
+  }
+}
+
+function buildFlowMapHopsUncached(q: FlowMapHopsQuery, minSharePct: number): FlowMapHopsDto {
+  const windowSec = Math.max(60, q.minutes * 60)
+  const raw = listFlowRowsForWindow(q.minutes)
+  const allow = q.userId ? userIfaceAllow(q.userId) : null
+  const serverRows = db.select().from(servers).all()
+  const nameById = new Map(serverRows.map((s) => [s.id, s.name || s.host]))
+  const ifaceFilter = q.iface && q.iface !== "__all__" ? q.iface : ""
+  const wantDedup = q.dedup !== false && !ifaceFilter
+  const excludeMesh = q.excludeMesh !== false
+  const excludeOverlay = q.excludeOverlay !== false
+  const topo = loadFlowTopology()
+
+  const matched = []
+  for (const r of raw) {
+    const resolved = resolveIfaceName(r.serverId, r.inIface)
+    const outResolved = resolveIfaceName(r.serverId, r.outIface)
+    if (!flowRowMatchesFilter(r, resolved.name, q, allow)) continue
+    const plane = classifyFlowPlane({
+      src: r.src,
+      dst: r.dst,
+      proto: r.proto,
+      srcPort: r.srcPort,
+      dstPort: r.dstPort,
+      inIface: resolved.name,
+      outIface: outResolved.name,
+    }, topo.plane)
+    if (!shouldKeepPlane(plane, { excludeMesh, excludeOverlay })) continue
+    matched.push(r)
+  }
+
+  const working = wantDedup ? dedupFlowRowsMaxBytes(matched) : matched
+  const hops = new Map<string, HopAcc>()
+  const dstAcc = new Map<string, DstAcc>()
+  let totalBytes = 0
+
+  for (const r of working) {
+    const inRes = resolveIfaceName(r.serverId, r.inIface)
+    const outRes = resolveIfaceName(r.serverId, r.outIface)
+    const inName = inRes.name
+    const outName = outRes.name
+    const fromId = String(r.serverId)
+    const fromLabel = nameById.get(r.serverId) ?? fromId
+    const wanSet = topo.wanIfaces.get(r.serverId)
+
+    const inOk = ifaceUsable(inName)
+    const outOk = ifaceUsable(outName)
+    const sameIface = inOk && outOk && inName.toLowerCase() === outName.toLowerCase()
+    if (sameIface) {
+      bump(hops, `iface|${fromId}|${inName.toLowerCase()}`, {
+        fromId,
+        fromLabel,
+        toId: "",
+        toLabel: "",
+        kind: "iface",
+        iface: inName,
+      }, r.bytes, "fwd")
+    } else {
+      if (inOk) {
+        bump(hops, `iface|${fromId}|${inName.toLowerCase()}`, {
+          fromId,
+          fromLabel,
+          toId: "",
+          toLabel: "",
+          kind: "iface",
+          iface: inName,
+        }, r.bytes, "rev")
+      }
+      if (outOk) {
+        bump(hops, `iface|${fromId}|${outName.toLowerCase()}`, {
+          fromId,
+          fromLabel,
+          toId: "",
+          toLabel: "",
+          kind: "iface",
+          iface: outName,
+        }, r.bytes, "fwd")
+      }
+    }
+
+    const enOut = ifaceUsable(outName) ? resolveEn(topo, r.nextHop, outName) : null
+    const enIn = ifaceUsable(inName) ? resolveEn(topo, "", inName) : null
+    const en = (enOut && enOut.id !== r.serverId ? enOut : null)
+      ?? (enIn && enIn.id !== r.serverId ? enIn : null)
+    if (en) {
+      const toId = String(en.id)
+      const dir: "fwd" | "rev" = enOut && enOut.id === en.id ? "fwd" : "rev"
+      const greIface = dir === "fwd" && ifaceUsable(outName) ? outName : (ifaceUsable(inName) ? inName : undefined)
+      bump(hops, `gre|${fromId}|${toId}`, {
+        fromId,
+        fromLabel,
+        toId,
+        toLabel: en.name,
+        kind: "gre",
+        iface: greIface,
+      }, r.bytes, dir)
+    }
+
+    if (wanSet?.size) {
+      if (ifaceUsable(inName) && wanSet.has(inName)) {
+        bump(hops, `wan|${fromId}|${inName.toLowerCase()}`, {
+          fromId,
+          fromLabel,
+          toId: "",
+          toLabel: "",
+          kind: "wan",
+          iface: inName,
+        }, r.bytes, "rev")
+      }
+      if (ifaceUsable(outName) && wanSet.has(outName) && outName.toLowerCase() !== inName.toLowerCase()) {
+        bump(hops, `wan|${fromId}|${outName.toLowerCase()}`, {
+          fromId,
+          fromLabel,
+          toId: "",
+          toLabel: "",
+          kind: "wan",
+          iface: outName,
+        }, r.bytes, "fwd")
+      }
+    }
+
+    totalBytes += r.bytes
+    const svcFromId = String((enOut ?? enIn)?.id ?? r.serverId)
+    const prevDst = dstAcc.get(r.dst)
+    if (prevDst) {
+      prevDst.bytes += r.bytes
+      prevDst.fromBytes.set(svcFromId, (prevDst.fromBytes.get(svcFromId) ?? 0) + r.bytes)
+    } else {
+      dstAcc.set(r.dst, {
+        bytes: r.bytes,
+        proto: r.proto,
+        dstPort: r.dstPort,
+        srcPort: r.srcPort,
+        fromBytes: new Map([[svcFromId, r.bytes]]),
+      })
+    }
+  }
+
+  const svcTotals = new Map<string, { label: string; category: string; bytes: number }>()
+  const svcEdges = new Map<string, { fromId: string; toId: string; bytes: number; bytesFwd: number; bytesRev: number }>()
+
+  for (const [dst, acc] of dstAcc) {
+    const ripe = lookupRipeCached(dst)
+    const classified = classifyMapDstLite(dst, acc.proto, acc.dstPort, acc.srcPort, ripe)
+    if (!classified) continue
+    const toId = mapServiceNodeId(classified.service)
+    const prevSvc = svcTotals.get(toId)
+    if (prevSvc) prevSvc.bytes += acc.bytes
+    else svcTotals.set(toId, { label: classified.service, category: classified.category, bytes: acc.bytes })
+    for (const [fromId, bytes] of acc.fromBytes) {
+      const edgeKey = `${fromId}|${toId}`
+      const prevEdge = svcEdges.get(edgeKey)
+      if (prevEdge) {
+        prevEdge.bytes += bytes
+        prevEdge.bytesFwd += bytes
+      } else {
+        svcEdges.set(edgeKey, {
+          fromId,
+          toId,
+          bytes,
+          bytesFwd: bytes,
+          bytesRev: 0,
+        })
+      }
+    }
+  }
+
+  const minShare = minSharePct / 100
+  let services: FlowMapService[] = [...svcTotals.entries()]
+    .map(([id, s]) => ({
+      id,
+      label: s.label,
+      category: s.category,
+      bytes: s.bytes,
+      bps: (s.bytes * 8) / windowSec,
+      share: totalBytes > 0 ? s.bytes / totalBytes : 0,
+    }))
+    .sort((a, b) => b.bytes - a.bytes)
+  if (minSharePct > 0) {
+    services = services.filter((s) => s.share >= minShare)
+  }
+  services = services.slice(0, MAP_SERVICE_NODE_CAP)
+  const keepSvc = new Set(services.map((s) => s.id))
+  const serviceEdges: FlowMapServiceEdge[] = [...svcEdges.values()]
+    .filter((e) => keepSvc.has(e.toId))
+    .map((e) => ({
+      fromId: e.fromId,
+      toId: e.toId,
+      bytes: e.bytes,
+      bps: (e.bytes * 8) / windowSec,
+      bpsFwd: (e.bytesFwd * 8) / windowSec,
+      bpsRev: (e.bytesRev * 8) / windowSec,
+    }))
+    .sort((a, b) => b.bytes - a.bytes)
+
+  const listener = getFlowListenerState()
+  return {
+    hops: [...hops.values()]
+      .map((a) => toHop(a, windowSec))
+      .sort((a, b) => a.bytes === b.bytes ? 0 : b.bytes - a.bytes),
+    live: listener.bound,
+    rangeMinutes: q.minutes,
+    windowSec,
+    totalBytes,
+    services,
+    serviceEdges,
+    mapServiceMinSharePct: minSharePct,
+    dedupApplied: wantDedup,
+    excludeMeshApplied: excludeMesh,
+    excludeOverlayApplied: excludeOverlay,
+  }
+}
+
+/** Hop-rates для карты сети: те же фильтры, что у общего NetFlow (dedup / mesh / overlay). */
+export function buildFlowMapHops(q: FlowMapHopsQuery): FlowMapHopsDto {
+  const minSharePct = resolveMinSharePct(q)
+  const key = hopsQueryKey(q, minSharePct)
+  const now = Date.now()
+  if (hopsCache && hopsCache.key === key && now - hopsCache.at < HOPS_CACHE_TTL_MS) {
+    return hopsCache.dto
+  }
+  const dto = buildFlowMapHopsUncached(q, minSharePct)
+  hopsCache = { key, at: now, dto }
+  return dto
+}

backend/src/services/traffic-flow-ripe.test.ts

@@ -7,6 +7,7 @@ import {
   lookupRipeCached,
   resetRipeCacheForTests,
   ripeFetchCountForTests,
+  ripeLastCandidateCountForTests,
   seedRipeCacheForTests,
   setRipeFetchForTests,
 } from "./traffic-flow-ripe.js"
@@ -100,4 +101,36 @@ await flushRipeQueueForTests()
 assert.equal(lookupRipeCached("1.0.0.1")?.country, "US")
 assert.equal(lookupRipeCached("1.0.0.1")?.asn, 13335)
 
+resetRipeCacheForTests()
+disableRipePersistForTests()
+for (let i = 0; i < 3000; i++) {
+  const o2 = Math.floor(i / 256)
+  const o3 = i % 256
+  seedRipeCacheForTests({
+    prefix: `203.${o2}.${o3}.0/24`,
+    asn: 64500,
+    country: "NL",
+    lat: null,
+    lng: null,
+    holder: "NOISE",
+    ok: true,
+    fetchedAt: Date.now(),
+  })
+}
+seedRipeCacheForTests({
+  prefix: "8.8.8.0/24",
+  asn: 15169,
+  country: "US",
+  lat: null,
+  lng: null,
+  holder: "GOOGLE",
+  ok: true,
+  fetchedAt: Date.now(),
+})
+assert.equal(lookupRipeCached("8.8.8.8")?.asn, 15169)
+assert.ok(
+  ripeLastCandidateCountForTests() < 8,
+  `index should not scan all prefixes, got ${ripeLastCandidateCountForTests()}`,
+)
+
 console.log("traffic-flow-ripe.test.ts: ok")

backend/src/services/traffic-flow-ripe.ts

@@ -1,5 +1,5 @@
 import { sqliteDatabase } from "../db/index.js"
-import { ipInCidrV4, ipv4ToInt, isNonPublicIp, parseCidrV4 } from "./traffic-flow-ip.js"
+import { ipv4ToInt, isNonPublicIp, parseCidrV4 } from "./traffic-flow-ip.js"
 import { resolveRipeCountry } from "./traffic-flow-brands.js"
 
 export interface FlowIpMeta {
@@ -28,6 +28,18 @@ const queue: string[] = []
 const queued = new Set<string>()
 const recentFetches: number[] = []
 
+interface RipeIndexed {
+  entry: FlowIpMeta
+  net: number
+  mask: number
+  prefixLen: number
+}
+
+/** /24 → кандидаты с prefixLen ≥ 24. Более широкие префиксы — в `wideIndex`. */
+const v24Index = new Map<number, RipeIndexed[]>()
+const wideIndex: RipeIndexed[] = []
+let lastCandidateCount = 0
+
 let persistEnabled = true
 let enqueueEnabled = true
 let loaded = false
@@ -50,6 +62,9 @@ export function resetRipeCacheForTests(): void {
   queue.length = 0
   queued.clear()
   recentFetches.length = 0
+  v24Index.clear()
+  wideIndex.length = 0
+  lastCandidateCount = 0
   loaded = persistEnabled ? false : true
   workerRunning = false
   fetchCount = 0
@@ -58,10 +73,15 @@ export function resetRipeCacheForTests(): void {
 }
 
 export function seedRipeCacheForTests(entry: FlowIpMeta): void {
-  mem.set(entry.prefix, { ...entry })
+  remember(entry)
   loaded = true
 }
 
+/** Сколько CIDR смотрели в последнем lookup (для теста индекса /24). */
+export function ripeLastCandidateCountForTests(): number {
+  return lastCandidateCount
+}
+
 export function setRipeFetchForTests(fn: typeof fetch): void {
   fetchImpl = fn
   fetchCount = 0
@@ -87,6 +107,48 @@ function isFresh(entry: FlowIpMeta): boolean {
   return Date.now() - entry.fetchedAt < ttlMs(entry.ok)
 }
 
+function unindexPrefix(prefix: string): void {
+  const parsed = parseCidrV4(prefix)
+  if (!parsed) return
+  if (parsed.prefixLen >= 24) {
+    const key = parsed.net >>> 8
+    const list = v24Index.get(key)
+    if (!list) return
+    const next = list.filter((row) => row.entry.prefix !== prefix)
+    if (next.length) v24Index.set(key, next)
+    else v24Index.delete(key)
+    return
+  }
+  const idx = wideIndex.findIndex((row) => row.entry.prefix === prefix)
+  if (idx >= 0) wideIndex.splice(idx, 1)
+}
+
+function indexEntry(entry: FlowIpMeta): void {
+  const parsed = parseCidrV4(entry.prefix)
+  if (!parsed) return
+  const row: RipeIndexed = {
+    entry,
+    net: parsed.net,
+    mask: parsed.mask,
+    prefixLen: parsed.prefixLen,
+  }
+  if (parsed.prefixLen >= 24) {
+    const key = parsed.net >>> 8
+    const list = v24Index.get(key)
+    if (list) list.push(row)
+    else v24Index.set(key, [row])
+    return
+  }
+  wideIndex.push(row)
+}
+
+function remember(entry: FlowIpMeta): void {
+  const prev = mem.get(entry.prefix)
+  if (prev) unindexPrefix(prev.prefix)
+  mem.set(entry.prefix, entry)
+  indexEntry(entry)
+}
+
 function loadSqlite(): void {
   if (loaded || !persistEnabled) {
     loaded = true
@@ -111,7 +173,7 @@ function loadSqlite(): void {
       const fetchedAt = Date.parse(r.fetched_at)
       const asn = Number(r.asn ?? 0) || 0
       const holder = r.holder || ""
-      mem.set(r.prefix, {
+      remember({
         prefix: r.prefix,
         asn,
         country: resolveRipeCountry(r.country || "", asn, holder) || "—",
@@ -193,20 +255,24 @@ function negative(prefix: string): FlowIpMeta {
 export function lookupRipeCached(ip: string): FlowIpMeta | null {
   loadSqlite()
   const trimmed = String(ip ?? "").trim()
+  lastCandidateCount = 0
   if (!trimmed) return null
   if (isNonPublicIp(trimmed)) {
     return negative(`${trimmed.includes(":") ? trimmed : trimmed}/32`)
   }
+  const addr = ipv4ToInt(trimmed)
+  if (addr == null) return null
+  const bucket = v24Index.get(addr >>> 8)
+  const candidates = bucket ? bucket.concat(wideIndex) : wideIndex
+  lastCandidateCount = candidates.length
   let best: FlowIpMeta | null = null
   let bestLen = -1
-  for (const entry of mem.values()) {
-    if (!isFresh(entry)) continue
-    const parsed = parseCidrV4(entry.prefix)
-    if (!parsed) continue
-    if (!ipInCidrV4(trimmed, entry.prefix)) continue
-    if (parsed.prefixLen > bestLen) {
-      best = entry
-      bestLen = parsed.prefixLen
+  for (const row of candidates) {
+    if (!isFresh(row.entry)) continue
+    if (((addr & row.mask) >>> 0) !== row.net) continue
+    if (row.prefixLen > bestLen) {
+      best = row.entry
+      bestLen = row.prefixLen
     }
   }
   return best
@@ -316,13 +382,13 @@ async function resolveIp(ip: string): Promise<FlowIpMeta | null> {
         ok: Boolean(asn || country),
         fetchedAt: Date.now(),
       }
-      mem.set(prefix, entry)
+      remember(entry)
       persist(entry)
       return entry
     } catch {
       const prefix = `${ip}/32`
       const entry = negative(prefix)
-      mem.set(prefix, entry)
+      remember(entry)
       persist(entry)
       return entry
     } finally {

backend/src/services/traffic-flow-settings.ts

@@ -53,6 +53,7 @@ export function toTrafficFlowSettingsDto(
     hubServerId: row.hubServerId ?? null,
     retentionHours: row.retentionHours,
     topN: row.topN,
+    mapServiceMinSharePct: Number(row.mapServiceMinSharePct ?? 5),
     lastDatagramAt: row.lastDatagramAt ?? null,
     lastExporterIp: row.lastExporterIp ?? null,
     lastError: row.lastError || null,
@@ -75,6 +76,9 @@ export function updateTrafficFlowSettings(patch: TrafficFlowSettingsPatch) {
     hubServerId: patch.hubServerId === undefined ? row.hubServerId : patch.hubServerId,
     retentionHours: patch.retentionHours ?? row.retentionHours,
     topN: patch.topN ?? row.topN,
+    mapServiceMinSharePct: patch.mapServiceMinSharePct == null
+      ? row.mapServiceMinSharePct
+      : Math.min(100, Math.max(0, patch.mapServiceMinSharePct)),
     updatedAt: nowIso(),
   }).where(eq(trafficFlowSettings.id, 1)).run()
   return getTrafficFlowSettingsRow()

components/network-map/service-brand-icon.tsx

@@ -0,0 +1,131 @@
+"use client"
+
+import type { ReactNode } from "react"
+
+function slug(label: string): string {
+  return label.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "")
+}
+
+function GenericCloud({ size }: { size: number }) {
+  return (
+    <svg width={size} height={size} viewBox="0 0 24 24" aria-hidden>
+      <path
+        d="M7.5 18h9.2A4.3 4.3 0 0 0 21 13.8a4.2 4.2 0 0 0-3.7-4.2A6.1 6.1 0 0 0 6.2 11 3.8 3.8 0 0 0 3 14.7 3.7 3.7 0 0 0 6.8 18Z"
+        fill="#38bdf8"
+        opacity="0.92"
+      />
+    </svg>
+  )
+}
+
+function BrandSvg({ children, size }: { children: ReactNode; size: number }) {
+  return (
+    <svg width={size} height={size} viewBox="0 0 24 24" aria-hidden>
+      {children}
+    </svg>
+  )
+}
+
+export function ServiceBrandIcon({ label, size = 22 }: { label: string; size?: number }) {
+  switch (slug(label)) {
+    case "cloudflare":
+      return (
+        <BrandSvg size={size}>
+          <path d="M6.2 15.4h12.4c1.6 0 2.6-1.1 2.4-2.4-.2-1.4-1.4-2.1-2.8-2.1-.3-2.4-2.3-4.1-4.8-4.1-1.9 0-3.5 1-4.4 2.5-.4-.2-.9-.3-1.4-.3-1.7 0-3.1 1.3-3.2 3-.1 1.8 1.3 3.4 3.2 3.4Z" fill="#F38020" />
+        </BrandSvg>
+      )
+    case "google":
+      return (
+        <BrandSvg size={size}>
+          <path d="M12 11.2h10.2A10 10 0 1 0 12 22a9.6 9.6 0 0 0 6.6-2.6l-2.7-2.1A5.8 5.8 0 1 1 12 6.2c1.5 0 2.8.5 3.8 1.5l2.6-2.6A9.8 9.8 0 0 0 12 2Z" fill="#4285F4" />
+          <path d="M3.2 7.2 6.6 9.7A5.8 5.8 0 0 1 16 8.2l2.7-2.6A9.8 9.8 0 0 0 3.2 7.2Z" fill="#EA4335" />
+          <path d="M12 22a9.6 9.6 0 0 0 6.6-2.6l-2.7-2.1A5.8 5.8 0 0 1 6.5 14.4L3 17A9.8 9.8 0 0 0 12 22Z" fill="#34A853" />
+          <path d="M21.8 12.2H12v3.6h5.6A5.5 5.5 0 0 1 15.9 17.3l2.7 2.1A9.4 9.4 0 0 0 22 12.2Z" fill="#FBBC05" />
+        </BrandSvg>
+      )
+    case "aws":
+    case "amazon":
+      return (
+        <BrandSvg size={size}>
+          <path d="M6.2 8.2 12 5.4l5.8 2.8v3.4L12 14.6 6.2 11.6Z" fill="#232F3E" />
+          <path d="M5.2 15.6c3.6 2.6 9.8 2.7 13.6 0" fill="none" stroke="#FF9900" strokeWidth="1.8" strokeLinecap="round" />
+        </BrandSvg>
+      )
+    case "steam":
+      return (
+        <BrandSvg size={size}>
+          <circle cx="12" cy="12" r="10" fill="#1b2838" />
+          <circle cx="8.2" cy="14.4" r="3.1" fill="#66c0f4" />
+          <circle cx="15.4" cy="9.2" r="3.6" fill="#c7d5e0" />
+          <circle cx="15.4" cy="9.2" r="1.5" fill="#1b2838" />
+        </BrandSvg>
+      )
+    case "blizzard":
+      return (
+        <BrandSvg size={size}>
+          <path d="M6 5h7.4c3 0 4.8 1.6 4.8 4.1 0 1.8-1 3.1-2.6 3.7 2 .5 3.2 2 3.2 4.1 0 2.8-2.1 4.6-5.6 4.6H6Z" fill="#00AEFF" />
+          <path d="M9.2 8.2h3.4c1.2 0 1.8.6 1.8 1.5s-.6 1.5-1.8 1.5H9.2Zm0 5.2h3.8c1.3 0 2 .6 2 1.6s-.7 1.6-2 1.6H9.2Z" fill="#06121f" />
+        </BrandSvg>
+      )
+    case "youtube":
+      return (
+        <BrandSvg size={size}>
+          <rect x="2" y="6" width="20" height="12" rx="3" fill="#FF0000" />
+          <path d="M10.2 9.2v5.6L15.6 12Z" fill="#fff" />
+        </BrandSvg>
+      )
+    case "netflix":
+      return (
+        <BrandSvg size={size}>
+          <path d="M6 3h3.2l5.6 18H11.6Z" fill="#E50914" />
+          <path d="M14.8 3H18v18h-3.2Z" fill="#B81D24" />
+        </BrandSvg>
+      )
+    case "microsoft":
+      return (
+        <BrandSvg size={size}>
+          <rect x="3" y="3" width="8" height="8" fill="#F25022" />
+          <rect x="13" y="3" width="8" height="8" fill="#7FBA00" />
+          <rect x="3" y="13" width="8" height="8" fill="#00A4EF" />
+          <rect x="13" y="13" width="8" height="8" fill="#FFB900" />
+        </BrandSvg>
+      )
+    case "meta":
+      return (
+        <BrandSvg size={size}>
+          <path d="M4 14.5c1.8-4.2 4-7.5 6.4-7.5 1.6 0 2.5 1.3 4.6 6.3 1.4 3.4 2.2 4.7 3.4 4.7 1.8 0 3.6-2.6 4.6-5" fill="none" stroke="#0081FB" strokeWidth="2.2" strokeLinecap="round" />
+        </BrandSvg>
+      )
+    case "telegram":
+      return (
+        <BrandSvg size={size}>
+          <circle cx="12" cy="12" r="10" fill="#229ED9" />
+          <path d="M7.2 12.1 16.8 8.4 15 16.2l-3.1-1.8-1.6 1.6-.2-2.6Z" fill="#fff" />
+        </BrandSvg>
+      )
+    case "discord":
+      return (
+        <BrandSvg size={size}>
+          <path d="M7.2 5.8 8.6 4.6c2.1.8 4.2 1.2 6.4 1.2h.8L17 5.8c1.8 2.4 2.6 5.4 2.4 8.6-1.6 1.2-3.3 2.1-5.2 2.6L13 15.2c.7-.2 1.3-.6 1.8-1.1-2 .9-4.2.9-6.2 0 .5.5 1.1.9 1.8 1.1L8.8 17c-1.9-.5-3.6-1.4-5.2-2.6C3.4 11.2 4.2 8.2 6 5.8Z" fill="#5865F2" />
+          <circle cx="9.2" cy="11.2" r="1.2" fill="#fff" />
+          <circle cx="14.8" cy="11.2" r="1.2" fill="#fff" />
+        </BrandSvg>
+      )
+    case "twitch":
+      return (
+        <BrandSvg size={size}>
+          <path d="M5 4h14v10.2l-4 4H11l-2.2 2.2H7.2V18.2H5Z" fill="#9146FF" />
+          <path d="M7.4 6.4h1.8v5.2H7.4Zm4 0h1.8v5.2H11.4Z" fill="#fff" />
+        </BrandSvg>
+      )
+    case "tiktok":
+      return (
+        <BrandSvg size={size}>
+          <path d="M14.2 4v9.1a3.3 3.3 0 1 1-2.8-3.3V7.2c1.6.9 3.2 1.4 5 1.5V5.4c-1.4-.1-2.7-.6-3.8-1.4H14.2Z" fill="#25F4EE" />
+          <path d="M13.4 4v9.1a3.3 3.3 0 1 1-2.8-3.3V7.2c1.6.9 3.2 1.4 5 1.5V5.4c-1.4-.1-2.7-.6-3.8-1.4H13.4Z" fill="#FE2C55" transform="translate(1.2 1)" />
+        </BrandSvg>
+      )
+    default:
+      return <GenericCloud size={size} />
+  }
+}

components/traffic/netflow-settings-panel.tsx

@@ -47,6 +47,8 @@ function NetflowSettingsPanel({
   const [endpoint, setEndpoint] = useState("")
   const [retention, setRetention] = useState("24")
   const [topN, setTopN] = useState("200")
+  const [shareOn, setShareOn] = useState(true)
+  const [sharePct, setSharePct] = useState("5")
   const [ingestOn, setIngestOn] = useState(false)
   const [purgeOpen, setPurgeOpen] = useState(false)
   const [purgeBusy, setPurgeBusy] = useState(false)
@@ -62,6 +64,9 @@ function NetflowSettingsPanel({
     setEndpoint(s.publicEndpoint)
     setRetention(String(s.retentionHours))
     setTopN(String(s.topN))
+    const pct = Number(s.mapServiceMinSharePct ?? 5)
+    setShareOn(pct > 0)
+    setSharePct(String(pct > 0 ? pct : 5))
     setIngestOn(s.enabled)
   }, [backendUrl, enabled])
 
@@ -83,6 +88,9 @@ function NetflowSettingsPanel({
         publicEndpoint: endpoint,
         retentionHours: Number.parseInt(retention, 10) || 24,
         topN: Number.parseInt(topN, 10) || 200,
+        mapServiceMinSharePct: shareOn
+          ? Math.min(100, Math.max(1, Number.parseFloat(sharePct) || 5))
+          : 0,
       })
       setSettings(res.settings)
       toast.success("Настройки NetFlow сохранены")
@@ -193,6 +201,29 @@ function NetflowSettingsPanel({
           <FormField label="Top-N разговоров">
             <Input value={topN} onChange={(e) => setTopN(e.target.value)} inputMode="numeric" />
           </FormField>
+          <div className="sm:col-span-2 flex flex-col gap-2">
+            <div className="flex items-center gap-3">
+              <FormToggle
+                checked={shareOn}
+                onChange={(on) => {
+                  setShareOn(on)
+                  if (on && (!sharePct || sharePct === "0")) setSharePct("5")
+                }}
+              />
+              <span className="text-sm">Порог доли на карте</span>
+            </div>
+            <FormField
+              label="Минимум % окна"
+              hint="Узел сервиса, если доля байт окна ≥ N%. Выключить — показать все распознанные бренды (макс. 20)"
+            >
+              <Input
+                value={sharePct}
+                onChange={(e) => setSharePct(e.target.value)}
+                inputMode="decimal"
+                disabled={!shareOn}
+              />
+            </FormField>
+          </div>
         </div>
 
         <p className="text-xs text-muted-foreground">

lib/map-netflow-hops.ts

@@ -0,0 +1,103 @@
+import type { FlowMapHop } from "@mmapp/contracts/traffic-flow"
+import { fmtRate } from "@/lib/fmt-rate"
+
+export interface MatchedNetflowHop {
+  bps: number
+  bpsFwd: number
+  bpsRev: number
+  bytes: number
+}
+
+function ifaceNorm(s: string | undefined): string {
+  return (s ?? "").trim().toLowerCase()
+}
+
+function pairKey(a: string, b: string): string {
+  const x = String(a)
+  const y = String(b)
+  return x <= y ? `${x}\t${y}` : `${y}\t${x}`
+}
+
+function mergeDirected(hops: FlowMapHop[], mapFromId: string): MatchedNetflowHop {
+  let bytes = 0
+  let bpsFwd = 0
+  let bpsRev = 0
+  const from = String(mapFromId)
+  for (const h of hops) {
+    bytes += h.bytes
+    if (h.fromId === from) {
+      bpsFwd += h.bpsFwd
+      bpsRev += h.bpsRev
+    } else {
+      bpsFwd += h.bpsRev
+      bpsRev += h.bpsFwd
+    }
+  }
+  return { bytes, bpsFwd, bpsRev, bps: bpsFwd + bpsRev }
+}
+
+export function hopHasRate(h: MatchedNetflowHop | undefined): h is MatchedNetflowHop {
+  return h != null && Number.isFinite(h.bps) && h.bps > 0
+}
+
+export function formatNetflowRate(hop: MatchedNetflowHop): string {
+  return fmtRate(hop.bps / 1_000_000)
+}
+
+export function formatNetflowDir(hop: MatchedNetflowHop): string {
+  return `↓${fmtRate(hop.bpsFwd / 1_000_000)} ↑${fmtRate(hop.bpsRev / 1_000_000)}`
+}
+
+/** GRE: сначала имя интерфейса туннеля на любом конце, иначе пара узлов. */
+export function matchNetflowForGreEdge(
+  edge: {
+    tunnel: { name: string }
+    fromServer: { id: string }
+    toServer: { id: string }
+  },
+  hops: FlowMapHop[],
+): MatchedNetflowHop | undefined {
+  const name = ifaceNorm(edge.tunnel.name)
+  const fromId = String(edge.fromServer.id)
+  const toId = String(edge.toServer.id)
+  if (name) {
+    const ifaceHits = hops.filter((h) =>
+      h.kind === "iface"
+      && ifaceNorm(h.iface) === name
+      && (h.fromId === fromId || h.fromId === toId),
+    )
+    if (ifaceHits.length) return mergeDirected(ifaceHits, fromId)
+    const greNamed = hops.filter((h) =>
+      h.kind === "gre"
+      && ifaceNorm(h.iface) === name
+      && (h.fromId === fromId || h.fromId === toId || h.toId === fromId || h.toId === toId),
+    )
+    if (greNamed.length) return mergeDirected(greNamed, fromId)
+  }
+  const want = pairKey(fromId, toId)
+  const pairHits = hops.filter((h) =>
+    h.kind === "gre" && Boolean(h.toId) && pairKey(h.fromId, h.toId) === want,
+  )
+  if (pairHits.length) return mergeDirected(pairHits, fromId)
+  return undefined
+}
+
+/** WAN-аплинк HR: kind wan, иначе iface с тем же именем на homeId. */
+export function matchNetflowForWan(
+  homeId: string,
+  wanIface: string,
+  hops: FlowMapHop[],
+): MatchedNetflowHop | undefined {
+  const id = String(homeId)
+  const iface = ifaceNorm(wanIface)
+  if (!iface) return undefined
+  const wanHits = hops.filter((h) =>
+    h.kind === "wan" && h.fromId === id && ifaceNorm(h.iface) === iface,
+  )
+  if (wanHits.length) return mergeDirected(wanHits, id)
+  const ifaceHits = hops.filter((h) =>
+    h.kind === "iface" && h.fromId === id && ifaceNorm(h.iface) === iface,
+  )
+  if (ifaceHits.length) return mergeDirected(ifaceHits, id)
+  return undefined
+}

lib/network-map-layout.ts

@@ -35,9 +35,10 @@ export function greTunnelProbe(t: GreTunnel): TunnelProbe {
   }
 }
 
-const W = 1060
+const W = 1240
 const H = 580
 const MARGIN = 72
+const SERVICE_COL_W = 150
 
 /** Одна горизонтальная «полка» на карте: Home → JH → Exit слева направо. */
 export const NETWORK_MAP_PIPELINE_Y = 300
@@ -68,7 +69,9 @@ function layerOfServer(s: Server): number | null {
  * Увеличивать при изменении алгоритма раскладки спутников/узлов.
  * Страница карты сбрасывает сохранённые перетаскивания при смене значения (в т.ч. после hot reload).
  */
-export const NETWORK_MAP_LAYOUT_REVISION = 6
+export const NETWORK_MAP_W = W
+export const NETWORK_MAP_H = H
+export const NETWORK_MAP_LAYOUT_REVISION = 7
 
 export interface WanJhEdge {
   homeId: string
@@ -254,7 +257,7 @@ export function computeNetworkMapLayout(
   const nodePos: Record<string, { x: number; y: number }> = {}
   const wanSatPos: Record<string, { x: number; y: number }[]> = {}
 
-  const span = W - 2 * MARGIN
+  const span = W - 2 * MARGIN - SERVICE_COL_W
   const laneGap = Math.min(44, span * 0.04)
   const laneW = (span - 2 * laneGap) / 3
 
@@ -425,6 +428,28 @@ export function computeNetworkMapLayout(
   return { nodePos, wanSatPos }
 }
 
+/** Колонка конечных сервисов справа от EN. */
+export function placeServiceNodes(
+  serviceIds: string[],
+  enPositions: Array<{ x: number; y: number }>,
+): Record<string, { x: number; y: number }> {
+  const out: Record<string, { x: number; y: number }> = {}
+  if (serviceIds.length === 0) return out
+  const minY = MARGIN + 70
+  const maxY = H - 72
+  const x = W - MARGIN - SERVICE_COL_W / 2
+  const enYs = enPositions.map((p) => p.y).filter((y) => Number.isFinite(y))
+  const centerY = enYs.length ? enYs.reduce((a, b) => a + b, 0) / enYs.length : (minY + maxY) / 2
+  const n = serviceIds.length
+  const gap = Math.min(96, (maxY - minY) / Math.max(1, n))
+  const span = gap * (n - 1)
+  const start = clamp(centerY - span / 2, minY, maxY - span)
+  serviceIds.forEach((id, i) => {
+    out[id] = { x, y: n === 1 ? clamp(centerY, minY, maxY) : start + i * gap }
+  })
+  return out
+}
+
 /**
  * Суммарная задержка «дом → JH» в миллисекундах: те же поля `Server.latency`, что показываются в разделе Серверы.
  * Отдельного ICMP по ребру нет — это не замер линии, а сумма каталожных latency концов.

packages/contracts/src/traffic-flow.ts

@@ -21,6 +21,7 @@ export const trafficFlowSettingsDtoSchema = z.object({
   hubServerId: z.number().int().positive().nullable(),
   retentionHours: z.number().int().positive(),
   topN: z.number().int().positive(),
+  mapServiceMinSharePct: z.number().min(0).max(100),
   lastDatagramAt: z.string().nullable(),
   lastExporterIp: z.string().nullable(),
   lastError: z.string().nullable(),
@@ -40,6 +41,7 @@ export const trafficFlowSettingsPatchSchema = z.object({
   hubServerId: z.number().int().positive().nullable().optional(),
   retentionHours: z.number().int().positive().optional(),
   topN: z.number().int().positive().max(1000).optional(),
+  mapServiceMinSharePct: z.number().min(0).max(100).optional(),
 })
 
 export const trafficFlowOverlayRequestSchema = z.object({
@@ -248,6 +250,53 @@ export const flowPurgeDtoSchema = z.object({
   vacuumed: z.boolean(),
 })
 
+export const flowMapHopKindSchema = z.enum(["gre", "wan", "iface"])
+
+export const flowMapHopDtoSchema = z.object({
+  fromId: z.string(),
+  fromLabel: z.string(),
+  toId: z.string(),
+  toLabel: z.string(),
+  kind: flowMapHopKindSchema,
+  iface: z.string().optional(),
+  bytes: z.number().nonnegative(),
+  bps: z.number().nonnegative(),
+  bpsFwd: z.number().nonnegative(),
+  bpsRev: z.number().nonnegative(),
+})
+
+export const flowMapServiceDtoSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  category: z.string(),
+  bytes: z.number().nonnegative(),
+  bps: z.number().nonnegative(),
+  share: z.number().min(0).max(1),
+})
+
+export const flowMapServiceEdgeDtoSchema = z.object({
+  fromId: z.string(),
+  toId: z.string(),
+  bytes: z.number().nonnegative(),
+  bps: z.number().nonnegative(),
+  bpsFwd: z.number().nonnegative(),
+  bpsRev: z.number().nonnegative(),
+})
+
+export const flowMapHopsDtoSchema = z.object({
+  hops: z.array(flowMapHopDtoSchema),
+  live: z.boolean(),
+  rangeMinutes: z.number().int().positive(),
+  windowSec: z.number().positive(),
+  totalBytes: z.number().nonnegative().optional(),
+  services: z.array(flowMapServiceDtoSchema).optional(),
+  serviceEdges: z.array(flowMapServiceEdgeDtoSchema).optional(),
+  mapServiceMinSharePct: z.number().min(0).max(100).optional(),
+  dedupApplied: z.boolean(),
+  excludeMeshApplied: z.boolean(),
+  excludeOverlayApplied: z.boolean(),
+})
+
 export type FlowTalkerDto = z.infer<typeof flowTalkerDtoSchema>
 export type FlowStatsDto = z.infer<typeof flowStatsDtoSchema>
 export type FlowBreakdownRow = z.infer<typeof flowBreakdownRowSchema>
@@ -260,3 +309,8 @@ export type FlowExportersDto = z.infer<typeof flowExportersDtoSchema>
 export type FlowClientsDto = z.infer<typeof flowClientsDtoSchema>
 export type FlowMonthlyDto = z.infer<typeof flowMonthlyDtoSchema>
 export type FlowPurgeDto = z.infer<typeof flowPurgeDtoSchema>
+export type FlowMapHopKind = z.infer<typeof flowMapHopKindSchema>
+export type FlowMapHop = z.infer<typeof flowMapHopDtoSchema>
+export type FlowMapService = z.infer<typeof flowMapServiceDtoSchema>
+export type FlowMapServiceEdge = z.infer<typeof flowMapServiceEdgeDtoSchema>
+export type FlowMapHopsDto = z.infer<typeof flowMapHopsDtoSchema>

shared/api/traffic-flow.ts

@@ -2,6 +2,7 @@ import type {
   FlowAnalyticsDto,
   FlowClientsDto,
   FlowExportersDto,
+  FlowMapHopsDto,
   FlowMonthlyDto,
   FlowPurgeDto,
   FlowStatsDto,
@@ -88,6 +89,29 @@ export async function getFlowClients(baseUrl: string, range = "5m"): Promise<Flo
   return requestJson<FlowClientsDto>(baseUrl, `/api/traffic/flow/clients?range=${encodeURIComponent(range)}`)
 }
 
+export async function getFlowMapHops(
+  baseUrl: string,
+  params: {
+    range?: string
+    serverId?: string
+    userId?: string
+    iface?: string
+    dedup?: boolean
+    excludeMesh?: boolean
+    excludeOverlay?: boolean
+  } = {},
+): Promise<FlowMapHopsDto> {
+  return requestJson<FlowMapHopsDto>(baseUrl, `/api/traffic/flow/map-hops${flowQuery({
+    range: params.range ?? "5m",
+    serverId: params.serverId,
+    userId: params.userId,
+    iface: params.iface,
+    dedup: params.dedup,
+    excludeMesh: params.excludeMesh,
+    excludeOverlay: params.excludeOverlay,
+  })}`)
+}
+
 export async function getFlowAnalytics(
   baseUrl: string,
   params: {