diff --git a/VERSION.properties b/VERSION.properties
index 5f66ce5..985cb9b 100644
--- a/VERSION.properties
+++ b/VERSION.properties
@@ -1,2 +1,2 @@
-client.version=1.2.135
-server.version=1.2.127
+client.version=1.2.158
+server.version=1.2.142
diff --git a/shine-UI/Dev_Docs/features/interactive-network-graph.md b/shine-UI/Dev_Docs/features/interactive-network-graph.md
new file mode 100644
index 0000000..41d2717
--- /dev/null
+++ b/shine-UI/Dev_Docs/features/interactive-network-graph.md
@@ -0,0 +1,183 @@
+# Интерактивная карта связей (force-directed graph)
+
+Экран **«Связи»** (`network-view`) — интерактивная нод-граф карта вместо статичного списка:
+фокусный пользователь в центре, связи на орбите, навигация тапом/свайпом, премиальные
+переходы в духе нативного iOS.
+
+## Где код
+- `js/pages/network/force-graph.js` — **движок** (физика, рендер, жизненный цикл узлов, жесты).
+- `js/pages/network/adapter.js` — реальные данные → нейтральная модель движка.
+- `js/pages/network/node-menu.js` — общее контекстное меню узла.
+- `js/pages/network/lab.js` — лаборатория (`network-view/lab`) на мок-данных, без бэкенда.
+- `js/pages/network-view.js` — страница: шапка, поиск, фильтры, история, склейка с движком.
+- `js/mock-data.js` — `networkGraphUsers` (связанный мульти-граф из 10 человек для лаборатории).
+- `styles/network-graph.css` — все стили `.fg-*`.
+
+## Данные (read-only, сервер не трогаем)
+Единый источник — `authService.getUserConnectionsGraph(login)` (один запрос: логин → прямые связи).
+`network-view.js` → `buildGraphModel()` нормализует роли (parent/child/sibling/spouse/friend/contact),
+направление и метки; `adapter.engineModelFromGraphModel()` превращает это в модель движка:
+`{ focusId, nodes:[{ id, login, name, avatar, relationType, strength, shining, tier }] }`.
+
+## Модель движка и API
+`createForceGraph({ stage, model, onNodeTap, onCenterTap, onNodeLongPress })` →
+`{ setModel(model), setFilter(pred), recenter(id), getFocusNode(), destroy() }`.
+
+## Ключевые механики
+- **Diffing-переходы (непрерывность состояний):** при смене фокуса общие узлы (тот же `id`) не
+  пересоздаются, а перелетают на новые места; новые «расцветают» (bloom) каскадом из центра;
+  исчезнувшие уходят в Ghost-слой.
+- **CSS-bloom (разлёт без тряски):** разлёт/перелёт узлов делают нативные CSS-переходы на
+  `transform` (компоновщик, `cubic-bezier(0.16,1,0.3,1)`, `BLOOM_MS` со ступенчатой задержкой
+  `order × 40мс`), а НЕ JS-физика. Работает даже при троттлинге rAF; цикл лишь ведёт лучи за узлами
+  (`syncPositionsFromDOM`). Завершение — гарантированно по таймеру (`endCssBloom`).
+- **Ghost-слой:** снимок только **аватарок** старого графа (без линий — иначе старые связи висят
+  «ошмётками»). Полноэкранный overlay, застывает на месте, `scale 1→0.7` + `opacity 0.5→0` за
+  **1000мс**, затем удаляется (мягкий породистый шлейф истории).
+- **Прорастание линий (Edge Growth):** новая линия тянется к ФИНАЛЬНОЙ точке узла и раскрывается
+  `stroke-dasharray`(=длина пути) + `stroke-dashoffset`(длина→0), синхронно с разлётом узла
+  (`growP = текущая дистанция / финальная`) → кончик «вытягивается» из центра вслед за аватаркой.
+  Старые линии при этом исчезают мгновенно. Только для новых узлов; переезжающие — линия следует за ними.
+- **Физика (только до-settle):** после CSS-разлёта — лёгкая радиальная пружина + отталкивание для
+  органичного покачивания; после фильтра физика НЕ включается (фиксация на равномерных углах).
+- **Жёсткая заморозка (kill-switch):** когда сумма |vx|+|vy| < 0.03 — скорости обнуляются, координаты
+  округляются, `cancelAnimationFrame` (sleep). Нет «треска», батарея не страдает.
+- **Обычные линии:** SVG `<path> Q` (квадратичные Безье) — тонкие матовые дуги (`stroke-width ~1.0–1.2`),
+  градиент с глубоким уходом в прозрачность: неон-центр `0.42` → цвет роли `0.07` у аватарки (растворяются
+  в фоне, не спорят с сияющими). Изгиб реагирует на скорость.
+- **Сияющие связи (двухслойный «световод», Neon Layering):** два пути на одну связь — широкий размытый
+  GLOW (`stroke-width 4`, неон, `filter: blur(2px)`, `opacity 0.4`) + тонкий чёткий CORE (`1.5px`,
+  `#e0f7fc`). Линия остаётся изящной, но обретает объёмное OLED-свечение; растут оба синхронно (общий
+  dashoffset). Никаких бегущих импульсов.
+- **Жесты:** свайп-pan с инерцией (новое касание прерывает); короткий тап — центрирование + нижний
+  сниппет; долгий тап — контекстное меню (в `#modal-root`, позиция по `getBoundingClientRect`); тап
+  по центру — профиль. Нажатия на чипы фильтров гасят `pointerdown` (stopPropagation), чтобы сцена не
+  перехватила указатель (`setPointerCapture`) и не «съела» click кнопки.
+- **Фильтры слоёв (Все / Семья / Друзья / Сияющие):** CSS-переходы 300мс — несоответствующие узлы и их
+  линии гаснут НА МЕСТЕ (`opacity 0` + `scale 0.8`), оставшиеся плавно переплывают на равномерные углы,
+  затем жёсткая фиксация без физики (ноль тряски, мгновенный sleep).
+- **Живой фон (Nebula):** под центром — глубокое размытое сине-голубое облако (`.fg-stage::before`,
+  `blur 80→96px`), бесконечная анимация 7с: «дышит» радиусом/яркостью и переливается индиго↔ультрамарин
+  (`hue-rotate`). На компоновщике (GPU), не будит rAF; подписи имён остаются контрастными.
+- **Стеклянные чипы фильтров (frosted glass):** `background: rgba(255,255,255,0.03)`,
+  `backdrop-filter: blur(12px)`, граница `0.5px solid rgba(255,255,255,0.1)`; активный — подсвечен сине-голубым.
+- **Поллиш:** «дыхание» фокуса (бесконечная CSS-анимация
+  размера, GPU, не будит rAF); свечение «сияющих» узлов — мягкая медленная пульсация (3.6с) многослойной
+  `box-shadow` + размытый ореол через SVG-фильтр `#fg-shine-glow`; тестовые фото-аватарки (`NETWORK_PHOTOS`);
+  хард-лимит ~90 DOM-аватарок (остальное — SVG-точки).
+
+## Параметры тюнинга (константы в начале `force-graph.js`)
+| Константа | Значение | Назначение |
+|---|---|---|
+| `ORBIT_MIN / ORBIT_MAX` | 150 / 240 | радиус орбиты (защитный отступ от центра — подписи не наезжают) |
+| `K_RADIAL` | 0.035 | жёсткость орбитальной пружины (мягко) |
+| `K_FOCUS` | 0.12 | жёсткость пружины фокуса к центру |
+| `CHARGE` / `CHARGE_START_FACTOR` | 1400 / 0.45 | отталкивание (на старте ослаблено) |
+| `FRICTION` / `FRICTION_BOOST` / `BOOST_FRAMES` | 0.80 / 0.94 / 42 | базовое трение / стартовая вязкость / длительность (~700мс) |
+| `BLOOM_MS` / `BLOOM_STAGGER` | 900 / 40 | длительность CSS-разлёта / задержка между узлами (каскад) |
+| `SLEEP_V` | 0.03 | порог суммарной |v| для заморозки |
+| `FOCUS_SCALE` | 1.5 | базовый масштаб фокуса |
+| `MAX_FULL_NODES` | 90 | хард-лимит полных аватарок (далее — точки) |
+
+Прочее (вшито в код): Ghost-слой — 1000мс; CSS-переход фильтра — 300мс; пульсация сияния — 3.6с;
+прорастание линий привязано к прогрессу разлёта узла (а не к отдельному таймеру).
+
+## Локальный запуск / проверка
+- Dev-сервер: `.claude/shine-ui-dev-server.cjs` (Node, порт 7321, SPA-fallback + инжект `<base href="/">`).
+- Лаборатория (без бэкенда): `http://localhost:7321/network-view/lab` — мок `networkGraphUsers`,
+  тап по узлам переключает сети.
+- Реальный путь (`/network-view`) требует живого `wss://shineup.me/ws` (локально — `ws_open_error`, это норма).
+
+## Режим «Интерактивная паутина» (ветка `pixel-web`, эксперимент, только лаборатория)
+Включается чипом «🌌 Вселенная». Дальние уровни (2-3) по умолчанию скрыты и раскрываются локально:
+- **Hover-превью (наведение):** навёл мышь/палец на узел — его ветка временно выплывает; убрал —
+  втягивается. Реализация: `pointerover/out` (мышь) и `pointerdown/up` (палец) → `onNodeHover` →
+  `graph.setHover(node|null)`; узел получает флаг `hovered`.
+- **Фиксация кликом (pin):** тап/клик по узлу → `graph.toggleExpand` ставит флаг `pinned` — ветка
+  остаётся раскрытой и после ухода курсора. Повторный клик по раскрытому узлу **сворачивает** его
+  (надёжный toggle: `isOpen = pinned || expandP>0.5` → сброс `pinned`+`hovered`).
+- Эффективное раскрытие = `pinned || hovered` (см. `expandTargetOf`), прогресс `expandP` (~400мс).
+- **Spotlight-затемнение:** пока есть закреплённая ветка, остальные тускнеют до `SPOTLIGHT_DIM=0.25`
+  (узлы и их линии), фокус и закреплённая/наведённая ветка — 100%. Плавно через `spotCur` (lerp).
+- **Узлы 2-го уровня — полноценные аватарки:** фото-лицо (pravatar) + имя, `DEEP2_SCALE=0.62`
+  (≈radius 16px), `DEEP2_OPACITY=0.85`. Не «пустые кружки», а видимые друзья друзей.
+- **Глобальный сброс:** тап по корню (Иван) → `collapseAll()` снимает `pinned`/`hovered` → 100% яркость.
+- **Адаптивное расталкивание (collision):** раскрытая ветка усиливает отталкивание соседних узлов
+  1-го уровня пропорционально `expandP` (`EXPAND_REPULSION=2.4`) — кластеры разъезжаются, не накладываясь.
+- **Камера-доводчик:** при фиксации ветки, если её «веер» упирается в край экрана, камера мягко
+  дотягивается (`glideCameraTo` → `camTargetX/Y`, lerp `CAM_GLIDE_K` в tick). Любой жест отменяет доводчик.
+- **Свободный зум:** колесо мыши (`onWheel`) и щипок двумя пальцами (`activePointers`/`pinching`) —
+  масштаб `zoom` (0.55–2.6), «к точке» под курсором/центром щипка; мир масштабируется CSS-`scale`,
+  линии (отдельный SVG) пересчитываются в экранных координатах (× `zoom`).
+- **Синхро-пульс линий:** сияющие/трековые «световоды» (`.fg-edge-glow`/`.fg-edge-core`) «дышат»
+  толщиной/размытием 3.6с — в такт ободку сияющего узла (в покое SVG не перерисовывается → синхронно).
+- Мерцающие микрозвёзды 3-го уровня (`fg-star-twinkle`), хаптика (`navigator.vibrate`) на нажатие/раскрытие/натяжение.
+
+### Умный фокус (Smart Zoom / «аквариум») — ветка `pixel-aquarium`
+**Наведение** (hover/палец) на узел — лёгкое превью ветки (раскрытие на месте, без камеры).
+**Клик/тап по ЛЮБОМУ узлу** — **погружение (dive)** с кинематографичным наездом:
+- **Камера-полёт + зум** (`diveTo` → `diveTargetId`/`diveZoom=1.7`, лёт в `tick` с `DIVE_FLY_K` ≈600мс):
+  узел плавно центрируется (offset ~0) и **вырастает до единого видимого размера** `HERO_VISUAL=1.4`
+  независимо от уровня (`depthScale = HERO_VISUAL / baseScaleOf`); его прямые дети — до `DIVE_CHILD_VISUAL`.
+- **Адаптивный радиус орбиты (фикс слипания):** дети раскладываются на кольце
+  `ringR = max(baseR + радиус_родителя, число_детей × 13)` — НЕ лезут на (увеличенный зумом) родитель
+  и друг на друга (проверено: мин. дистанция 125px, 0 наложений). Радиус растёт вместе с зумом родителя.
+- **Глубина «аквариума»** (`contextTargetOf` → `depthScale`/`depthBlur`/`spotCur`, лерп): Иван и боковые
+  ветки **уменьшаются** (root ×0.55, фон ×0.55) + уходят в **blur 3px** + тускнеют до 0.25 → задний план.
+- **Железный Spotlight (единый активный путь):** `diveTo` сначала гасит ВСЕ прежние pin/hover, затем
+  раскрывает только путь к новой цели. Открыто → путь Иван→…→узел = 1.0, остальное = 0.25; переключение
+  веток сбрасывает прежнюю; **выход/`exitDive`/тап по Ивану → ВСЕ узлы гарантированно 1.0 + камера отъезжает**.
+- **Нить-крошка**: путь (`divePathSet`/`onPath`) горит ярким «световодом» — виден путь назад к Ивану.
+- **Pinch-to-Zoom + LOD**: щипок/колесо меняют `zoom`; при `zoom ≥ LOD_ZOOM (1.55)` видимые точки 3-го
+  уровня **дорисовываются как аватарки** (`updateLod`/`setNodeLod`), при отдалении — обратно в точки.
+- Глубина — фейк-3D через масштаб + CSS-`blur` (GPU), без WebGL.
+
+**Полиш (партия 1):** веер детей раскрывается **полукругом «наружу»** (от пути назад, `DEEP_FAN`,
+по `sibIndex`) — не перекрывает нить-крошку; **LOD с гистерезисом** (`LOD_ZOOM_UP=1.6`/`DOWN=1.4` — без
+мигания у порога); **двойной тап по фону** и **сильный pinch-out на мин. зуме** = быстрый выход;
+**префетч аватарок** детей при наведении/нырке.
+
+**Фишки (партия 2, лаборатория):**
+- **Поиск + телепорт** — строка `.fg-search`; Enter → `graph.findNode(имя)` → камера летит к узлу (dive в
+  «Вселенной», иначе перецентр).
+- **Хлебные крошки** — `.fg-breadcrumb` «Иван › Нина › Ада» (движок шлёт `onDiveChange(path)`,
+  API `getDivePath()`); клик по корню — полный сброс, по предку — навигация на тот уровень.
+- **Бейдж числа связей** — `.fg-node-badge` (число из `degreeById`, обновляется в `updateBadges`).
+- **Цветовые кластеры** — мягкая аура узла по типу связи (CSS `is-family/friend/business/contact`).
+
+**Линии-«жгуты» (партия 4, по референсу — плазменный композитинг):**
+- **Сияющие** — ОДИН центральный S-путь (cubic Bézier) + ТРИ наложенных слоя с ОДИНАКОВЫМ `d` (объём
+  из толщины+размытия, НЕ из геометрии — никаких расходящихся линий):
+  Настоящий НЕОН (видимый ореол вокруг яркого ядра; поле/трубка в `mix-blend-mode: screen` — свет
+  складывается аддитивно с тёмным фоном, а в пересечениях у центра ярче — энергохаб):
+  - `.fg-plasma-flare` — плазменное облако: 16px, `#00bfff`, opacity 0.42, **`feGaussianBlur` stdDev=6**, screen (+ «дыхание» 3.6с);
+  - `.fg-plasma-tube` — направляющий свет: 6px, `#00e5ff`, opacity 0.85, **`feGaussianBlur` stdDev=2**, screen;
+  - `.fg-plasma-core` — ядро: 2px, `#dffaff` (светло-голубо-белое), opacity 1, без размытия.
+  Толщина/насыщенность подогнаны под референс (толстая яркая голубая плазма, гладкие края).
+  S-волна спокойная/изящная (amp до 13px). Размытие — именно SVG-фильтры (`#fg-plasma-blur6/2`), т.к.
+  CSS-`filter` на `<path>` в части мобильных WebView не применяется (отсюда был «плоский»/«канатный» вид).
+  ⚠️ Это НЕ Canvas-движок (не библиотека force-graph): связи — реальные SVG `<path>`, фильтры применяются.
+  Прозрачность слоёв inline (× spotlight/глубину). Тяжёлый blur только у сияющих (их мало) — перф.
+- **Не-сияущие** — мягкое свечение **в цвете связи** (семья/друзья/бизнес/контакт): широкая
+  полупрозрачная подложка + тонкое ядро, без SVG-blur (дёшево). «Похоже, но тише».
+
+**Фишки (партия 3, лаборатория):**
+- **Общие связи** — среди друзей человека один помечен как «общий» (он и твой друг тоже): золотой
+  ободок + ★ (CSS `is-common`; в лаб-генерации `addDeepLevels` подставляет узнаваемого друга Ивана).
+- **Доступность** — визуально скрытый (`sr-only`) текстовый список графа `.fg-a11y` (центр + связи
+  1-го уровня) для скринридеров; обновляется в `updateA11y` при перестроении. Полезно и для реального пути.
+
+**Автопроверки (`?fgtest`):** `js/pages/network/selftest.js` автозапускается в лаборатории при `?fgtest`,
+прогоняет 17 ассертов (центровка/collision/полукруг/spotlight/переключение/LOD/поиск/крошки/бейдж/выход) через
+детерминированные dev-хелперы движка `graph.debugState()` и `graph.pumpForTest()` (синхронно докручивают кадры
+до покоя — не зависят от троттлинга rAF). Результат → консоль и `window.__fgTestResults`. В обычной работе не активны.
+
+> ⚠️ Эксперименты на ветках `pixel-web` (паутина) и `pixel-aquarium` (Smart Zoom) — для отката.
+> Реальный путь `/network-view` не затронут: deep-код под `tier ≥ 2` / `hasDeep`, dive — только tier≥2
+> (в реальном пути их нет), depthScale/Blur по умолчанию нейтральны, `updateLod` выходит при `!hasDeep`.
+
+## Ограничения / на будущее
+- Многоуровневая глубина (друзья друзей мельче, 3-й уровень — точки), кластеры, «общие связи»
+  упираются в API (отдаёт только прямые связи) — требуют доработки сервера.
+- Превью в простое троттлит `requestAnimationFrame` (физика не идёт между вызовами) — для замеров
+  прокачивать кадры; в активном табе всё работает на 60 FPS.
diff --git a/shine-UI/index.html b/shine-UI/index.html
index 5d1a017..9c7f792 100644
--- a/shine-UI/index.html
+++ b/shine-UI/index.html
@@ -12,7 +12,7 @@
     <script>
       (function attachStylesWithBuildHash() {
         const v = encodeURIComponent(window.__SHINE_BUILD_HASH__ || 'dev');
-        const cssFiles = ['./styles/main.css', './styles/layout.css', './styles/components.css'];
+        const cssFiles = ['./styles/main.css', './styles/layout.css', './styles/components.css', './styles/network-graph.css'];
         cssFiles.forEach((file) => {
           const link = document.createElement('link');
           link.rel = 'stylesheet';
diff --git a/shine-UI/js/mock-data.js b/shine-UI/js/mock-data.js
index 3ce0540..b44879b 100644
--- a/shine-UI/js/mock-data.js
+++ b/shine-UI/js/mock-data.js
@@ -280,3 +280,127 @@ export const networkGraph = {
     { id: 'p4', name: 'Никита', initials: 'НО', x: 82, y: 76 },
   ],
 };
+
+// Мок интерактивной карты связей в форме ТЗ (focusUser + connections[]).
+// Используется лабораторным режимом `network-view/lab` для проверки физики/центрирования.
+// relationType: family | friend | business | contact; connectionStrength: 0..1 (сильнее → ближе к центру);
+// status: 'shining' даёт эффект свечения; hasOwnConnections — есть ли у узла свои связи (для глубины).
+export const networkGraphMock = {
+  focusUser: { id: 'u_100', login: 'ivan', name: 'Иван', avatar: 'url_to_image', status: 'shining' },
+  connections: [
+    { id: 'u_101', login: 'alisa', name: 'Алиса', avatar: 'url_to_image', relationType: 'family', connectionStrength: 0.95, hasOwnConnections: true, status: 'shining' },
+    { id: 'u_102', login: 'pavel', name: 'Павел', avatar: 'url_to_image', relationType: 'business', connectionStrength: 0.45, hasOwnConnections: false },
+    { id: 'u_103', login: 'marina', name: 'Марина', avatar: 'url_to_image', relationType: 'friend', connectionStrength: 0.8, hasOwnConnections: true },
+    { id: 'u_104', login: 'ilya', name: 'Илья', avatar: 'url_to_image', relationType: 'friend', connectionStrength: 0.6, hasOwnConnections: true },
+    { id: 'u_105', login: 'elena', name: 'Елена', avatar: 'url_to_image', relationType: 'family', connectionStrength: 0.88, hasOwnConnections: false },
+    { id: 'u_106', login: 'nikita', name: 'Никита', avatar: 'url_to_image', relationType: 'contact', connectionStrength: 0.3, hasOwnConnections: false },
+    { id: 'u_107', login: 'oleg', name: 'Олег', avatar: 'url_to_image', relationType: 'business', connectionStrength: 0.55, hasOwnConnections: true, status: 'shining' },
+    { id: 'u_108', login: 'sveta', name: 'Света', avatar: 'url_to_image', relationType: 'friend', connectionStrength: 0.7, hasOwnConnections: false },
+    { id: 'u_109', login: 'dmitry', name: 'Дмитрий', avatar: 'url_to_image', relationType: 'contact', connectionStrength: 0.4, hasOwnConnections: true },
+    { id: 'u_110', login: 'anna', name: 'Анна', avatar: 'url_to_image', relationType: 'family', connectionStrength: 0.92, hasOwnConnections: false },
+  ],
+};
+
+// Связанный мульти-пользовательский граф для лаборатории (network-view/lab):
+// у каждого пользователя свой набор связей, тап по узлу переключает карту на его сеть.
+// Сияющими считаем ivan/alisa/oleg — у них статус подсвечивается и в их карточках у других.
+const NETWORK_NAMES = {
+  ivan: 'Иван', alisa: 'Алиса', pavel: 'Павел', elena: 'Елена', dmitry: 'Дмитрий',
+  oleg: 'Олег', nina: 'Нина', marina: 'Марина', sveta: 'Света', kirill: 'Кирилл',
+};
+const NETWORK_SHINING = new Set(['ivan', 'alisa', 'oleg', 'marina', 'nina']);
+// Тестовые аватарки-фото (реальные лица по сид-номеру pravatar) — только для лаборатории.
+// Если сети нет — узлы мягко падают на инициалы (img.onerror).
+const NETWORK_PHOTOS = {
+  ivan: 'https://i.pravatar.cc/150?img=12', alisa: 'https://i.pravatar.cc/150?img=5',
+  pavel: 'https://i.pravatar.cc/150?img=13', elena: 'https://i.pravatar.cc/150?img=9',
+  dmitry: 'https://i.pravatar.cc/150?img=33', oleg: 'https://i.pravatar.cc/150?img=52',
+  nina: 'https://i.pravatar.cc/150?img=47', marina: 'https://i.pravatar.cc/150?img=44',
+  sveta: 'https://i.pravatar.cc/150?img=24', kirill: 'https://i.pravatar.cc/150?img=60',
+};
+
+function networkConn(login, relationType, connectionStrength) {
+  return {
+    id: login,
+    login,
+    name: NETWORK_NAMES[login] || login,
+    avatar: null,
+    photo: NETWORK_PHOTOS[login] || null,
+    relationType,
+    connectionStrength,
+    hasOwnConnections: true,
+    status: NETWORK_SHINING.has(login) ? 'shining' : '',
+  };
+}
+
+function networkPerson(login, connections) {
+  return {
+    focusUser: {
+      id: login,
+      login,
+      name: NETWORK_NAMES[login] || login,
+      avatar: null,
+      photo: NETWORK_PHOTOS[login] || null,
+      status: NETWORK_SHINING.has(login) ? 'shining' : '',
+    },
+    connections,
+  };
+}
+
+export const networkGraphUsers = {
+  ivan: networkPerson('ivan', [
+    networkConn('alisa', 'friend', 0.9),
+    networkConn('pavel', 'friend', 0.7),
+    networkConn('elena', 'family', 0.95),
+    networkConn('dmitry', 'family', 0.95),
+    networkConn('oleg', 'business', 0.5),
+    networkConn('nina', 'contact', 0.35),
+    networkConn('kirill', 'friend', 0.6),
+  ]),
+  alisa: networkPerson('alisa', [
+    networkConn('ivan', 'friend', 0.9),
+    networkConn('marina', 'friend', 0.8),
+    networkConn('sveta', 'contact', 0.4),
+    networkConn('elena', 'contact', 0.3),
+  ]),
+  pavel: networkPerson('pavel', [
+    networkConn('ivan', 'friend', 0.7),
+    networkConn('oleg', 'business', 0.6),
+    networkConn('kirill', 'friend', 0.5),
+  ]),
+  elena: networkPerson('elena', [
+    networkConn('ivan', 'family', 0.95),
+    networkConn('dmitry', 'family', 0.9),
+    networkConn('alisa', 'contact', 0.3),
+  ]),
+  dmitry: networkPerson('dmitry', [
+    networkConn('ivan', 'family', 0.95),
+    networkConn('elena', 'family', 0.9),
+    networkConn('pavel', 'business', 0.4),
+  ]),
+  oleg: networkPerson('oleg', [
+    networkConn('pavel', 'business', 0.6),
+    networkConn('ivan', 'business', 0.5),
+    networkConn('nina', 'contact', 0.45),
+  ]),
+  nina: networkPerson('nina', [
+    networkConn('ivan', 'contact', 0.35),
+    networkConn('oleg', 'contact', 0.45),
+    networkConn('sveta', 'friend', 0.5),
+  ]),
+  marina: networkPerson('marina', [
+    networkConn('alisa', 'friend', 0.8),
+    networkConn('sveta', 'friend', 0.7),
+    networkConn('kirill', 'contact', 0.4),
+  ]),
+  sveta: networkPerson('sveta', [
+    networkConn('marina', 'friend', 0.7),
+    networkConn('alisa', 'contact', 0.4),
+    networkConn('nina', 'friend', 0.5),
+  ]),
+  kirill: networkPerson('kirill', [
+    networkConn('ivan', 'friend', 0.6),
+    networkConn('pavel', 'friend', 0.5),
+    networkConn('marina', 'contact', 0.4),
+  ]),
+};
diff --git a/shine-UI/js/pages/network-view.js b/shine-UI/js/pages/network-view.js
index 2d82933..595f53c 100644
--- a/shine-UI/js/pages/network-view.js
+++ b/shine-UI/js/pages/network-view.js
@@ -1,16 +1,17 @@
 import { renderHeader } from '../components/header.js';
 import { authService, state } from '../state.js';
-import { renderUserAvatar } from '../components/avatar-image.js';
-import { loadUserProfileCard } from '../services/user-connections.js';
 import { makeProfileRoute } from '../services/shine-routes.js';
 import { makeProfileLinksRoute } from '../services/shine-routes.js';
+import { renderNetworkLab } from './network/lab.js';
+import { createForceGraph } from './network/force-graph.js';
+import { engineModelFromGraphModel } from './network/adapter.js';
+import { openNodeMenu, relationLabelRu } from './network/node-menu.js';
 
 export const pageMeta = { id: 'network-view', title: 'Связи' };
 
 const GENDER_MALE = 'male';
 const GENDER_FEMALE = 'female';
 const GENDER_UNKNOWN = 'unknown';
-const CENTER_NODE_ID = '__center__';
 
 function normalizeLogin(value) {
   return String(value || '').trim();
@@ -111,147 +112,6 @@ function getRelativeGenderMap(graph) {
   return map;
 }
 
-function relativeRoleLabel(role, gender) {
-  const cleanGender = normalizeGender(gender);
-  if (role === 'parent') {
-    if (cleanGender === GENDER_MALE) return 'отец';
-    if (cleanGender === GENDER_FEMALE) return 'мать';
-    return 'родитель';
-  }
-  if (role === 'child') {
-    if (cleanGender === GENDER_MALE) return 'сын';
-    if (cleanGender === GENDER_FEMALE) return 'дочь';
-    return 'потомок';
-  }
-  if (role === 'sibling') {
-    if (cleanGender === GENDER_MALE) return 'брат';
-    if (cleanGender === GENDER_FEMALE) return 'сестра';
-    return 'брат/сестра';
-  }
-  if (role === 'spouse') {
-    if (cleanGender === GENDER_MALE) return 'муж';
-    if (cleanGender === GENDER_FEMALE) return 'жена';
-    return 'жена/муж';
-  }
-  return '';
-}
-
-function buildNameLines(firstName, lastName) {
-  const first = String(firstName || '').trim();
-  const last = String(lastName || '').trim();
-  if (first && last) {
-    const full = `${first} ${last}`.trim();
-    if (full.length <= 20) return [full];
-    return [first, last];
-  }
-  if (first) return [first];
-  if (last) return [last];
-  return [];
-}
-
-function applyNodeText(node, {
-  login,
-  firstName = '',
-  lastName = '',
-  role = 'friend',
-  gender = GENDER_UNKNOWN,
-  mark = null,
-} = {}) {
-  const loginText = normalizeLogin(login);
-  const labelsWrap = node.querySelector('.node-label');
-  const nameEl = node.querySelector('.node-name');
-  const loginEl = node.querySelector('.node-login');
-  const relationEl = node.querySelector('.node-relation');
-  if (!(labelsWrap instanceof HTMLElement) || !(nameEl instanceof HTMLElement) || !(loginEl instanceof HTMLElement)) {
-    return;
-  }
-
-  const nameLines = buildNameLines(firstName, lastName);
-  nameEl.innerHTML = '';
-  if (nameLines.length) {
-    nameLines.forEach((line) => {
-      const lineEl = document.createElement('span');
-      lineEl.className = 'node-name-line';
-      lineEl.textContent = line;
-      nameEl.append(lineEl);
-    });
-    labelsWrap.classList.remove('is-login-only');
-  } else {
-    labelsWrap.classList.add('is-login-only');
-  }
-  loginEl.textContent = loginText;
-
-  const relLabel = relativeRoleLabel(role, gender);
-  if (relationEl instanceof HTMLElement) {
-    relationEl.textContent = relLabel;
-    relationEl.hidden = !relLabel;
-  }
-
-  const metaParts = [];
-  if (mark?.officialLabel) metaParts.push(mark.officialLabel);
-  if (mark?.shineLabel) metaParts.push(mark.shineLabel);
-  if (relLabel) metaParts.push(`роль: ${relLabel}`);
-  const titleMain = nameLines.length ? `${nameLines.join(' ')} (${loginText})` : loginText;
-  node.title = metaParts.length ? `${titleMain}\n${metaParts.join(', ')}` : titleMain;
-}
-
-function spread(count, start, end) {
-  if (count <= 0) return [];
-  if (count === 1) return [(start + end) / 2];
-  const out = [];
-  const step = (end - start) / (count - 1);
-  for (let i = 0; i < count; i += 1) out.push(start + step * i);
-  return out;
-}
-
-function buildNodeElement({
-  login,
-  kind = 'friend',
-  isCenter = false,
-  mark = null,
-  role = 'friend',
-  gender = GENDER_UNKNOWN,
-  firstName = '',
-  lastName = '',
-}) {
-  const node = document.createElement('button');
-  node.type = 'button';
-  const classes = [
-    'node',
-    isCenter ? 'center' : '',
-    kind === 'relative' ? 'is-relative' : 'is-friend',
-    mark?.shine ? 'is-shine' : '',
-    mark?.official ? 'is-official' : '',
-  ].filter(Boolean);
-  node.className = classes.join(' ');
-  node.dataset.nodeLogin = login;
-
-  if (mark?.official) {
-    const officialBadge = document.createElement('span');
-    officialBadge.className = 'node-badge-official';
-    officialBadge.setAttribute('aria-hidden', 'true');
-    officialBadge.textContent = 'ОФ';
-    node.append(officialBadge);
-  }
-  node.append(renderUserAvatar({
-    login,
-    avatar: mark?.avatar || null,
-    size: 'node',
-    title: login,
-  }));
-
-  const label = document.createElement('span');
-  label.className = 'node-label';
-  label.innerHTML = `
-    <span class="node-name"></span>
-    <span class="node-login"></span>
-    <span class="node-relation" hidden></span>
-  `;
-  node.append(label);
-  applyNodeText(node, { login, firstName, lastName, role, gender, mark });
-  return node;
-}
-
 function buildGraphModel(graph, centerLogin) {
   const login = normalizeLogin(graph?.login || centerLogin || state.session.login);
   const outFriends = toSet(graph?.outFriends);
@@ -264,6 +124,13 @@ function buildGraphModel(graph, centerLogin) {
   const inSiblings = toSet(graph?.inSiblings);
   const outSpouses = toSet(graph?.outSpouses);
   const inSpouses = toSet(graph?.inSpouses);
+  // контакты/подписки/знакомые — для слоя «Все контакты» (Фаза 3)
+  const outContacts = toSet(graph?.outContacts);
+  const inContacts = toSet(graph?.inContacts);
+  const outFollows = toSet(graph?.outFollows);
+  const inFollows = toSet(graph?.inFollows);
+  const outKnown = toSet(graph?.outKnownPersons);
+  const inKnown = toSet(graph?.inKnownPersons);
 
   const relativesGender = getRelativeGenderMap(graph);
   const allMarks = getMarkByLogin(graph?.allUsers);
@@ -279,6 +146,12 @@ function buildGraphModel(graph, centerLogin) {
     ...(graph?.inSiblings || []),
     ...(graph?.outSpouses || []),
     ...(graph?.inSpouses || []),
+    ...(graph?.outContacts || []),
+    ...(graph?.inContacts || []),
+    ...(graph?.outFollows || []),
+    ...(graph?.inFollows || []),
+    ...(graph?.outKnownPersons || []),
+    ...(graph?.inKnownPersons || []),
   ]).filter((entry) => normKey(entry) !== normKey(login));
 
   const relations = allLogins.map((targetLogin) => {
@@ -292,12 +165,15 @@ function buildGraphModel(graph, centerLogin) {
     const spouseIn = hasLogin(inSpouses, targetLogin);
     const friendOut = hasLogin(outFriends, targetLogin);
     const friendIn = hasLogin(inFriends, targetLogin);
+    const contactOut = hasLogin(outContacts, targetLogin) || hasLogin(outFollows, targetLogin) || hasLogin(outKnown, targetLogin);
+    const contactIn = hasLogin(inContacts, targetLogin) || hasLogin(inFollows, targetLogin) || hasLogin(inKnown, targetLogin);
 
-    let role = 'friend';
+    let role = 'contact';
     if (parentOut || parentIn) role = 'parent';
     else if (childOut || childIn) role = 'child';
     else if (spouseOut || spouseIn) role = 'spouse';
     else if (siblingOut || siblingIn) role = 'sibling';
+    else if (friendOut || friendIn) role = 'friend';
 
     let forward = friendOut;
     let backward = friendIn;
@@ -313,13 +189,16 @@ function buildGraphModel(graph, centerLogin) {
     } else if (role === 'sibling') {
       forward = siblingOut;
       backward = siblingIn;
+    } else if (role === 'contact') {
+      forward = contactOut;
+      backward = contactIn;
     }
 
     return {
       login: targetLogin,
       key: normKey(targetLogin),
       role,
-      isRelative: role !== 'friend',
+      isRelative: role === 'parent' || role === 'child' || role === 'spouse' || role === 'sibling',
       gender: normalizeGender(relativesGender.get(normKey(targetLogin))),
       forward: Boolean(forward),
       backward: Boolean(backward),
@@ -334,188 +213,14 @@ function buildGraphModel(graph, centerLogin) {
   };
 }
 
-function splitByGender(list) {
-  const left = [];
-  const right = [];
-  const center = [];
-  list.forEach((item) => {
-    if (item.gender === GENDER_FEMALE) left.push(item);
-    else if (item.gender === GENDER_MALE) right.push(item);
-    else center.push(item);
-  });
-  return { left, right, center };
-}
-
-function sortByLogin(items) {
-  return [...items].sort((a, b) => a.login.localeCompare(b.login, 'ru', { sensitivity: 'base' }));
-}
-
-function positionRows(nodes, x, yStart, yEnd) {
-  const ys = spread(nodes.length, yStart, yEnd);
-  return nodes.map((node, index) => ({ ...node, x, y: ys[index] }));
-}
-
-function layoutNodes(model) {
-  const centerNode = {
-    id: CENTER_NODE_ID,
-    login: model.centerLogin,
-    x: 50,
-    y: 50,
-    isCenter: true,
-    kind: 'center',
-    relation: null,
-    gender: GENDER_UNKNOWN,
-    mark: model.centerMark,
-  };
-
-  const parents = sortByLogin(model.relations.filter((item) => item.role === 'parent'));
-  const children = sortByLogin(model.relations.filter((item) => item.role === 'child'));
-  const spouses = sortByLogin(model.relations.filter((item) => item.role === 'spouse'));
-  const siblings = sortByLogin(model.relations.filter((item) => item.role === 'sibling'));
-  const friends = sortByLogin(model.relations.filter((item) => item.role === 'friend'));
-
-  const parentSplit = splitByGender(parents);
-  const childSplit = splitByGender(children);
-  const spouseSplit = splitByGender(spouses);
-  const siblingSplit = splitByGender(siblings);
-
-  const friendLeft = [];
-  const friendRight = [];
-  friends.forEach((item, index) => {
-    if (index % 2 === 0) friendLeft.push(item);
-    else friendRight.push(item);
-  });
-
-  const positioned = [
-    ...positionRows(parentSplit.left, 28, 16, 28),
-    ...positionRows(parentSplit.right, 72, 16, 28),
-    ...positionRows(parentSplit.center, 50, 10, 22),
-    ...positionRows(friendLeft, 12, 30, 70),
-    ...positionRows(friendRight, 88, 30, 70),
-    ...positionRows(spouseSplit.left, 36, 38, 58),
-    ...positionRows(spouseSplit.right, 64, 38, 58),
-    ...positionRows(spouseSplit.center, 50, 40, 56),
-    ...positionRows(siblingSplit.left, 30, 46, 66),
-    ...positionRows(siblingSplit.right, 70, 46, 66),
-    ...positionRows(siblingSplit.center, 50, 54, 70),
-    ...positionRows(childSplit.left, 28, 68, 84),
-    ...positionRows(childSplit.right, 72, 68, 84),
-    ...positionRows(childSplit.center, 50, 78, 88),
-  ];
-
-  const nodes = [centerNode];
-  const edges = [];
-
-  positioned.forEach((item) => {
-    const nodeId = item.key;
-    nodes.push({
-      id: nodeId,
-      login: item.login,
-      x: item.x,
-      y: item.y,
-      isCenter: false,
-      kind: item.isRelative ? 'relative' : 'friend',
-      relation: item.role,
-      gender: item.gender,
-      mark: item.mark,
-    });
-    edges.push({
-      from: item.forward ? CENTER_NODE_ID : nodeId,
-      to: item.forward ? nodeId : CENTER_NODE_ID,
-      mutual: item.forward && item.backward,
-      isRelative: item.isRelative,
-      exists: item.forward || item.backward,
-    });
-  });
-
-  return { nodes, edges };
-}
-
-function marker(svg, id, color) {
-  const el = document.createElementNS('http://www.w3.org/2000/svg', 'marker');
-  el.setAttribute('id', id);
-  el.setAttribute('viewBox', '0 0 10 10');
-  el.setAttribute('refX', '9');
-  el.setAttribute('refY', '5');
-  el.setAttribute('markerUnits', 'strokeWidth');
-  el.setAttribute('markerWidth', '6');
-  el.setAttribute('markerHeight', '6');
-  el.setAttribute('orient', 'auto');
-
-  const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
-  path.setAttribute('d', 'M 0 0 L 10 5 L 0 10 z');
-  path.setAttribute('fill', color);
-  el.append(path);
-  svg.append(el);
-}
-
-function getNodeCenter(boardRect, node) {
-  const dot = node.querySelector('.node-dot');
-  if (!(dot instanceof HTMLElement)) return null;
-  const rect = dot.getBoundingClientRect();
-  return {
-    x: rect.left - boardRect.left + (rect.width / 2),
-    y: rect.top - boardRect.top + (rect.height / 2),
-    radius: rect.width / 2,
-  };
-}
-
-function shortenLine(fromPoint, toPoint, fromOffset, toOffset) {
-  const dx = toPoint.x - fromPoint.x;
-  const dy = toPoint.y - fromPoint.y;
-  const len = Math.hypot(dx, dy);
-  if (len < 1) return null;
-  const ux = dx / len;
-  const uy = dy / len;
-  return {
-    x1: fromPoint.x + (ux * fromOffset),
-    y1: fromPoint.y + (uy * fromOffset),
-    x2: toPoint.x - (ux * toOffset),
-    y2: toPoint.y - (uy * toOffset),
-  };
-}
-
-function renderEdges(svg, board, nodeElements, edges) {
-  svg.innerHTML = '';
-  const defs = document.createElementNS('http://www.w3.org/2000/svg', 'defs');
-  marker(defs, 'network-arrow-friend', 'rgba(120, 179, 255, 0.95)');
-  marker(defs, 'network-arrow-relative', 'rgba(255, 159, 94, 0.95)');
-  svg.append(defs);
-
-  const boardRect = board.getBoundingClientRect();
-  const centers = new Map();
-  nodeElements.forEach((value, key) => {
-    const pt = getNodeCenter(boardRect, value);
-    if (pt) centers.set(key, pt);
-  });
-
-  edges.forEach((edge) => {
-    if (!edge.exists) return;
-    const from = centers.get(edge.from);
-    const to = centers.get(edge.to);
-    if (!from || !to) return;
-
-    const cut = shortenLine(from, to, from.radius + 3, to.radius + 3);
-    if (!cut) return;
-
-    const line = document.createElementNS('http://www.w3.org/2000/svg', 'line');
-    line.setAttribute('x1', String(cut.x1));
-    line.setAttribute('y1', String(cut.y1));
-    line.setAttribute('x2', String(cut.x2));
-    line.setAttribute('y2', String(cut.y2));
-    line.setAttribute('class', `network-link ${edge.isRelative ? 'is-relative' : 'is-friend'}`);
-
-    if (!edge.mutual) {
-      line.setAttribute('marker-end', `url(#${edge.isRelative ? 'network-arrow-relative' : 'network-arrow-friend'})`);
-    }
-    svg.append(line);
-  });
-}
-
 let persistedCenterLogin = '';
 let persistedCenterHistory = [];
 
 export function render({ navigate, route }) {
+  // Лабораторный режим force-графа (Фаза 1): рендерится из мока, не трогая реальный путь ниже.
+  if (String(route?.params?.mode || '').trim().toLowerCase() === 'lab') {
+    return renderNetworkLab({ navigate });
+  }
   const keepHistory = String(route?.params?.mode || '').trim().toLowerCase() === 'keep-history';
   const routeLogin = normalizeLogin(route?.params?.login || '');
   if (!keepHistory) {
@@ -532,14 +237,35 @@ export function render({ navigate, route }) {
   stage.className = 'network-stage';
 
   const board = document.createElement('div');
-  board.className = 'network-board network-board--full';
+  board.className = 'network-board network-board--full fg-stage';
 
-  const profileCardCache = new Map();
   let centerLogin = normalizeLogin(persistedCenterLogin || state.session.login || '');
   let centerHistory = Array.isArray(persistedCenterHistory) ? [...persistedCenterHistory] : [];
-  let redrawEdges = () => {};
+  let engine = null;
+  let sheetEl = null;
   let loadSeq = 0;
 
+  // Фильтры слоёв (Фаза 3). Фокус всегда виден; предикат применяется к периферийным узлам.
+  const FILTERS = {
+    all: { label: 'Все', pred: () => true },
+    family: { label: 'Семья', pred: (n) => n.relationType === 'family' },
+    friends: { label: 'Друзья', pred: (n) => n.relationType === 'friend' },
+    shining: { label: 'Сияющие', pred: (n) => Boolean(n.shining) },
+  };
+  const FILTER_ORDER = ['all', 'family', 'friends', 'shining'];
+  let activeFilter = 'all';
+  const filterChips = {};
+
+  function applyFilter(key) {
+    if (!FILTERS[key]) return;
+    activeFilter = key;
+    FILTER_ORDER.forEach((k) => {
+      const el = filterChips[k];
+      if (el) el.classList.toggle('is-active', k === activeFilter);
+    });
+    if (engine) engine.setFilter(FILTERS[key].pred);
+  }
+
   function profileInfoRoute(login) {
     const cleanLogin = normalizeLogin(login);
     if (!cleanLogin) return '';
@@ -692,62 +418,69 @@ export function render({ navigate, route }) {
     window.setTimeout(() => inputEl.focus(), 0);
   }
 
-  function getProfileCardCached(login) {
-    const cleanLogin = normalizeLogin(login);
-    const key = normKey(cleanLogin);
-    if (!cleanLogin) return Promise.resolve(null);
-    if (!profileCardCache.has(key)) {
-      profileCardCache.set(key, loadUserProfileCard(cleanLogin).catch(() => null));
+  // Нижний сниппет (bottom sheet) с краткой сводкой об узле; не блокирует карту.
+  function showNodeSheet(node) {
+    if (!sheetEl) {
+      sheetEl = document.createElement('div');
+      sheetEl.className = 'fg-sheet';
+      stage.append(sheetEl);
     }
-    return profileCardCache.get(key);
+    const login = normalizeLogin(node.login);
+    const shineBadge = node.shining ? '<span class="fg-sheet-badge">сияющий</span>' : '';
+    sheetEl.innerHTML = `
+      <button class="fg-sheet-close" type="button" data-act="close" aria-label="Закрыть">✕</button>
+      <div class="fg-sheet-body">
+        <div class="fg-sheet-title">${escapeHtml(login)} ${shineBadge}</div>
+        <div class="fg-sheet-rel">${escapeHtml(relationLabelRu(node.relationType))}</div>
+      </div>
+      <div class="fg-sheet-actions">
+        <button class="ghost-btn" type="button" data-act="profile">Профиль</button>
+        <button class="primary-btn" type="button" data-act="write">Написать</button>
+      </div>
+    `;
+    sheetEl.classList.add('is-open');
+    sheetEl.onclick = (e) => {
+      const btn = e.target instanceof HTMLElement ? e.target.closest('[data-act]') : null;
+      if (!(btn instanceof HTMLElement)) return;
+      const act = btn.dataset.act;
+      if (act === 'close') hideNodeSheet();
+      else if (act === 'profile') { const r = profileInfoRoute(login); if (r) navigate(r); }
+      else if (act === 'write') navigate(`chat-view/${encodeURIComponent(login)}`);
+    };
   }
 
-  async function hydrateNodeProfiles(layout, nodeElements, requestId) {
-    const uniqueNodes = [];
-    const seen = new Set();
-    layout.nodes.forEach((nodeModel) => {
-      const key = normKey(nodeModel.login);
-      if (!key || seen.has(key)) return;
-      seen.add(key);
-      uniqueNodes.push(nodeModel);
-    });
-
-    const cards = await Promise.all(uniqueNodes.map((nodeModel) => getProfileCardCached(nodeModel.login)));
-    if (requestId !== loadSeq) return;
-
-    const cardByKey = new Map();
-    cards.forEach((card) => {
-      const login = normalizeLogin(card?.login);
-      if (!login) return;
-      cardByKey.set(normKey(login), card);
-    });
-
-    layout.nodes.forEach((nodeModel) => {
-      const node = nodeElements.get(nodeModel.id);
-      if (!(node instanceof HTMLElement)) return;
-      const card = cardByKey.get(normKey(nodeModel.login));
-      const cardGender = normalizeGender(card?.gender);
-      applyNodeText(node, {
-        login: nodeModel.login,
-        firstName: card?.firstName || '',
-        lastName: card?.lastName || '',
-        role: nodeModel.relation || 'friend',
-        gender: nodeModel.gender === GENDER_UNKNOWN ? cardGender : nodeModel.gender,
-        mark: nodeModel.mark || null,
-      });
-    });
-
-    requestAnimationFrame(() => redrawEdges());
+  function hideNodeSheet() {
+    if (sheetEl) sheetEl.classList.remove('is-open');
   }
 
-  function bindNodeInteraction(node, nodeModel) {
-    node.addEventListener('click', () => {
-      if (nodeModel.isCenter) {
-        const routeTo = profileInfoRoute(nodeModel.login);
+  function ensureEngine(model) {
+    if (engine) {
+      engine.setModel(model);
+      return;
+    }
+    engine = createForceGraph({
+      stage: board,
+      model,
+      // тап по периферийному узлу — центрируем (грузим его граф) и показываем нижний сниппет
+      onNodeTap: (node) => { showNodeSheet(node); void load(node.login, { pushHistory: true }); },
+      // тап по центру — полноценный профиль
+      onCenterTap: (node) => {
+        const routeTo = profileInfoRoute(node.login);
         if (routeTo) navigate(routeTo);
-        return;
-      }
-      void load(nodeModel.login, { pushHistory: true });
+      },
+      // долгое нажатие — контекстное меню (вне масштабируемого холста)
+      onNodeLongPress: (node, point) => {
+        const login = normalizeLogin(node.login);
+        openNodeMenu({
+          login,
+          relationType: node.relationType,
+          point,
+          actions: [
+            { label: 'Профиль', onClick: () => { const r = profileInfoRoute(login); if (r) navigate(r); } },
+            { label: 'Написать', onClick: () => navigate(`chat-view/${encodeURIComponent(login)}`) },
+          ],
+        });
+      },
     });
   }
 
@@ -765,34 +498,12 @@ export function render({ navigate, route }) {
       }
       syncLinksUrl(targetCenter, { push: pushHistory });
 
-      const model = buildGraphModel(graph, targetCenter);
-      const layout = layoutNodes(model);
+      const graphModel = buildGraphModel(graph, targetCenter);
+      const engineModel = engineModelFromGraphModel(graphModel);
+      ensureEngine(engineModel);
+      // сохраняем выбранный фильтр при перестроении графа (центрирование/переход)
+      if (engine && activeFilter !== 'all') engine.setFilter(FILTERS[activeFilter].pred);
 
-      board.innerHTML = '';
-      const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-      svg.setAttribute('class', 'network-svg');
-      board.append(svg);
-
-      const nodeElements = new Map();
-      layout.nodes.forEach((nodeModel) => {
-        const node = buildNodeElement({
-          login: nodeModel.login,
-          kind: nodeModel.kind,
-          isCenter: nodeModel.isCenter,
-          role: nodeModel.relation || 'friend',
-          gender: nodeModel.gender,
-          mark: nodeModel.mark,
-        });
-        node.style.left = `${nodeModel.x}%`;
-        node.style.top = `${nodeModel.y}%`;
-        board.append(node);
-        nodeElements.set(nodeModel.id, node);
-        bindNodeInteraction(node, nodeModel);
-      });
-
-      redrawEdges = () => renderEdges(svg, board, nodeElements, layout.edges);
-      requestAnimationFrame(() => redrawEdges());
-      void hydrateNodeProfiles(layout, nodeElements, requestId);
       persistHistory();
       setBackButtonState(backBtnEl);
     } catch (error) {
@@ -823,18 +534,10 @@ export function render({ navigate, route }) {
   const backBtnEl = header.querySelector('.header-left .icon-btn');
   setBackButtonState(backBtnEl);
 
-  const onResize = () => redrawEdges();
-  window.addEventListener('resize', onResize);
-
-  let observer = null;
-  if (typeof ResizeObserver !== 'undefined') {
-    observer = new ResizeObserver(() => redrawEdges());
-    observer.observe(board);
-  }
-
+  // Ресайз и перерисовку рёбер движок обрабатывает сам (window resize + ResizeObserver внутри).
   screen.cleanup = () => {
-    window.removeEventListener('resize', onResize);
-    if (observer) observer.disconnect();
+    if (engine) engine.destroy();
+    engine = null;
     appScreenEl?.classList.remove('network-scroll-lock');
   };
 
@@ -857,8 +560,24 @@ export function render({ navigate, route }) {
   }
   setBackButtonState(backBtnEl);
 
+  // Панель фильтров слоёв (оверлей под шапкой)
+  const filterBar = document.createElement('div');
+  filterBar.className = 'fg-filter-bar';
+  // Не даём нажатию на чип «провалиться» в сцену: иначе движок делает setPointerCapture на stage,
+  // а захват указателя перенаправляет нативный click со сцены — и кнопка фильтра не срабатывает.
+  filterBar.addEventListener('pointerdown', (e) => e.stopPropagation());
+  FILTER_ORDER.forEach((key) => {
+    const chip = document.createElement('button');
+    chip.type = 'button';
+    chip.className = `fg-filter-chip${key === activeFilter ? ' is-active' : ''}`;
+    chip.textContent = FILTERS[key].label;
+    chip.addEventListener('click', () => applyFilter(key));
+    filterChips[key] = chip;
+    filterBar.append(chip);
+  });
+
   header.classList.add('network-header-overlay');
-  stage.append(board, header);
+  stage.append(board, header, filterBar);
   screen.append(stage);
   return screen;
 }
diff --git a/shine-UI/js/pages/network/adapter.js b/shine-UI/js/pages/network/adapter.js
new file mode 100644
index 0000000..2ea11e2
--- /dev/null
+++ b/shine-UI/js/pages/network/adapter.js
@@ -0,0 +1,72 @@
+// Адаптер реальных данных → нейтральная модель движка force-графа.
+//
+// Источник — результат buildGraphModel() из network-view.js (он уже нормализует ответ
+// authService.getUserConnectionsGraph в роли/направления/метки). Здесь только конвертация
+// в форму, которую понимает движок ({ focusId, nodes[] }). Сервер не трогаем — это чтение.
+
+function normLogin(value) {
+  return String(value || '').trim();
+}
+
+const FAMILY_ROLES = ['parent', 'child', 'spouse', 'sibling'];
+
+function relationTypeFromRole(role) {
+  if (FAMILY_ROLES.includes(role)) return 'family';
+  if (role === 'friend') return 'friend';
+  return 'contact';
+}
+
+// Сила связи (0..1) → радиус орбиты в движке. Реальный API пока не отдаёт численную силу,
+// поэтому выводим её эвристически из роли и направления связи:
+//  - родственники держим ближе всего, контакты — дальше всего;
+//  - взаимные дружеские связи ближе односторонних.
+function deriveStrength(relation) {
+  if (relation.isRelative) return 0.9;
+  if (relation.role === 'contact') return 0.4;
+  if (relation.forward && relation.backward) return 0.8;
+  return 0.55;
+}
+
+/**
+ * @param {{centerLogin:string, centerMark:object|null, relations:Array}} graphModel
+ * @returns {{focusId:string, nodes:Array}}
+ */
+export function engineModelFromGraphModel(graphModel) {
+  const focusLogin = normLogin(graphModel?.centerLogin);
+  const centerMark = graphModel?.centerMark || null;
+
+  const focusNode = {
+    id: focusLogin,
+    login: focusLogin,
+    name: '',
+    avatar: centerMark?.avatar || null,
+    relationType: 'self',
+    strength: 1,
+    shining: Boolean(centerMark?.shine),
+    tier: 1,
+  };
+
+  const relations = Array.isArray(graphModel?.relations) ? graphModel.relations : [];
+  const seen = new Set();
+  const nodes = relations
+    .map((r) => {
+      const login = normLogin(r?.login);
+      const key = login.toLowerCase();
+      // исключаем сам фокус (не должно быть линии на собственный ник) и дубли
+      if (!login || key === focusLogin.toLowerCase() || seen.has(key)) return null;
+      seen.add(key);
+      return {
+        id: login,
+        login,
+        name: '',
+        avatar: r?.mark?.avatar || null,
+        relationType: relationTypeFromRole(r?.role),
+        strength: deriveStrength(r || {}),
+        shining: Boolean(r?.mark?.shine),
+        tier: 1,
+      };
+    })
+    .filter(Boolean);
+
+  return { focusId: focusLogin, nodes: [focusNode, ...nodes] };
+}
diff --git a/shine-UI/js/pages/network/force-graph.js b/shine-UI/js/pages/network/force-graph.js
new file mode 100644
index 0000000..0f4dada
--- /dev/null
+++ b/shine-UI/js/pages/network/force-graph.js
@@ -0,0 +1,1688 @@
+// Движок интерактивной карты связей (force-directed graph).
+//
+// Что делает:
+// - держит «мир» (бесконечный холст), по которому можно панорамировать свайпом;
+// - раскладывает фокусный узел в центре, остальные — по орбите (радиус зависит от силы связи);
+// - по тапу на периферийный узел плавно стягивает его в центр (новый фокус), старый уходит на орбиту;
+// - рисует рёбра аналитически (без чтения DOM в цикле) — дёшево для 60 FPS.
+//
+// Критичные требования (см. план):
+// 1) Kill-switch физики: цикл rAF останавливается, когда кинетическая энергия падает ниже порога;
+//    просыпается только при взаимодействии (pan / tap / recenter). Батарея не «выжирается».
+// 2) Конфликт жестов: любой pan мгновенно прерывает твин центрирования и отдаёт управление пальцу.
+//
+// Движок работает с нейтральной моделью (ниже buildModelFromTz конвертирует форму ТЗ в неё):
+//   model = { focusId, nodes: [{ id, login, name, avatar, relationType, strength, shining, tier }] }
+
+import { renderUserAvatar, buildAvatarInitials } from '../../components/avatar-image.js';
+
+const SVGNS = 'http://www.w3.org/2000/svg';
+
+// --- Параметры физики и анимации ---------------------------------------------
+const ORBIT_MIN = 150;          // минимальный радиус орбиты (защитный отступ от центра), px
+const ORBIT_MAX = 240;          // максимальный радиус орбиты (слабая связь — дальше), px
+const K_RADIAL = 0.035;         // очень мягкая пружина пера к орбите — узлы выходят «как резина»
+const K_FOCUS = 0.12;           // мягкая пружина фокуса к центру
+const CHARGE = 1400;            // базовое отталкивание (на старте перестроения временно ослабляется)
+const CHARGE_START_FACTOR = 0.45; // доля отталкивания в момент «рождения» из центра (без паники)
+const MIN_DIST = 40;            // минимальная дистанция для расчёта отталкивания
+const FRICTION = 0.80;          // базовое затухание (после транзита — лёгкое упругое покачивание)
+const FRICTION_BOOST = 0.94;    // «гелевая» вязкость в первые ~700мс после перестроения (гасит «взрыв»)
+const BOOST_FRAMES = 42;        // длительность затухающего boost'а вязкости (~700мс @60fps)
+const SLEEP_V = 0.03;           // порог суммарной |vx|+|vy| для жёсткой заморозки графа
+const INTRO_FACTOR = 0.22;      // стартовый радиус пера (доля от целевого) — узлы «вылетают» из центра
+const PAN_FRICTION = 0.93;      // трение инерционного скролла карты
+const TWEEN_MS = 560;           // длительность анимации центрирования (фильтр/фолбэк)
+const BLOOM_MS = 900;           // длительность разлёта узлов из центра (физика выключена → ноль тряски)
+const BLOOM_STAGGER = 40;       // задержка между «выстреливанием» соседних узлов (волна), мс
+const FOCUS_SCALE = 1.5;        // базовый масштаб фокуса (CSS-дыхание колеблет ±~1.3% → 1.48–1.52x)
+const PRIMARY_SCALE = 1.0;      // масштаб обычного узла 1-го уровня
+const SECONDARY_SCALE = 0.72;   // масштаб узлов 2-го уровня (друзья друзей)
+const PAN_THRESHOLD = 8;        // порог смещения (px), после которого жест считается pan, а не tap
+const LONGPRESS_MS = 480;       // порог долгого нажатия
+const MAX_FULL_NODES = 90;      // хард-лимит полных DOM-аватарок; остальное — лёгкие SVG-подобные точки
+
+// «Мегамасштаб» — глубина 2-3 уровней (только лаборатория, фейковые данные). Узлы tier≥2 не
+// участвуют в физике: позиционируются детерминированно вокруг своего родителя (layoutDeep).
+const DEEP2_SCALE = 0.62;       // узел 2-го уровня — ~вдвое меньше (radius ~16px), но с читаемым лицом/именем
+const DEEP2_OPACITY = 0.85;     // почти непрозрачный — это полноценная аватарка, а не «дырка»
+const DEEP3_OPACITY = 0.9;      // 3-й уровень — светящаяся микрозвезда (точка)
+const DEEP_R2 = 70;             // радиус орбиты 2-го уровня вокруг родителя 1-го уровня, px
+const DEEP_R3 = 38;             // радиус орбиты 3-го уровня вокруг родителя 2-го уровня, px
+
+// Зум камеры (свободное масштабирование колесом мыши / щипком двумя пальцами): мир целиком
+// масштабируется CSS-scale (GPU), линии (отдельный SVG-слой) пересчитываются в экранных координатах.
+const ZOOM_MIN = 0.55;          // максимальное отдаление
+const ZOOM_MAX = 2.6;           // максимальное приближение
+const ZOOM_WHEEL = 0.0016;      // чувствительность колеса мыши
+// Адаптивное расталкивание раскрытых веток (collision): пока ветка раскрыта (expandP→1), её узел
+// сильнее отталкивает соседей — кластеры «разъезжаются», как магниты, и не накладываются (паутина).
+const EXPAND_REPULSION = 2.4;   // во сколько раз усиливается charge у полностью раскрытого узла
+const SPOTLIGHT_DIM = 0.25;     // прозрачность «затемнённых» веток, когда какая-то ветка закреплена кликом
+// Камера-доводчик: мягкая дотяжка камеры, чтобы раскрытый кластер целиком попал в кадр (без рывков).
+const CAM_GLIDE_K = 0.12;       // скорость дотяжки (lerp за кадр)
+const CAM_GLIDE_MARGIN = 18;    // зазор от края экрана при дотяжке, px
+
+// Умный фокус (Smart Zoom / «аквариум»): клик по узлу 2-го уровня — камера летит и зумит к нему,
+// он вырастает в центр; Иван и боковые ветки уменьшаются + расфокус (blur) на задний план;
+// нить-крошка обратно к Ивану остаётся яркой. При сильном зуме точки 3-го уровня → аватарки (LOD).
+const DIVE_ZOOM = 1.7;          // зум камеры при погружении (наезд ~600мс)
+const DIVE_FLY_K = 0.13;        // скорость «полёта» камеры/зума к узлу (lerp за кадр) ≈ 600мс до цели
+const HERO_VISUAL = 1.4;        // желаемый ВИДИМЫЙ масштаб нырнутого узла — одинаков для tier-1/2/3 (читаемо)
+const DIVE_CHILD_VISUAL = 0.95; // желаемый видимый масштаб его прямых детей (крупно/читаемо)
+const DIVE_PATH_MUL = 0.72;     // предки на пути назад — чуть мельче (видимая «цепочка крошек»)
+const DIVE_ROOT_MUL = 0.55;     // корень (Иван) уходит вглубь сильнее всех
+const DIVE_OFFPATH_MUL = 0.55;  // боковые ветки (вне пути) — уменьшаются на задний план
+const DIVE_BLUR = 3;            // размытие фоновых (вне пути) узлов — эффект расфокуса/глубины, px
+// LOD с гистерезисом (без «мигания» у порога): апгрейд точка→аватарка на UP, откат на DOWN (зазор).
+const LOD_ZOOM_UP = 1.6;        // зум, на котором точки 3-го уровня превращаются в аватарки
+const LOD_ZOOM_DOWN = 1.4;      // зум, ниже которого аватарки сворачиваются обратно в точки
+const DEEP_FAN = Math.PI * 1.1; // ширина веера детей: полукруг «наружу» от пути назад (~198°)
+const DOUBLE_TAP_MS = 320;      // окно двойного тапа по фону (быстрый сброс погружения)
+
+const RELATION_COLORS = {
+  family: 'rgba(255, 159, 94, 0.92)',
+  friend: 'rgba(120, 179, 255, 0.9)',
+  business: 'rgba(190, 150, 255, 0.9)',
+  contact: 'rgba(170, 190, 220, 0.7)',
+};
+
+// Неоновый цвет центра — из него «вытекает» градиент каждой связи к цвету периферийного узла.
+const FOCUS_NEON = 'rgba(140, 240, 255, 0.95)';
+
+
+function easeOutCubic(t) {
+  const x = 1 - t;
+  return 1 - x * x * x;
+}
+
+function relationColor(relationType) {
+  return RELATION_COLORS[relationType] || RELATION_COLORS.contact;
+}
+
+// Однократно внедряем скрытый SVG-фильтр свечения «сияющих» узлов (мягкое гауссово размытие).
+// Применяется к псевдо-ореолу ::before, а НЕ к самой аватарке — поэтому фото не размывается.
+function ensureShineFilter() {
+  if (typeof document === 'undefined' || document.getElementById('fg-shine-glow')) return;
+  const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+  svg.setAttribute('aria-hidden', 'true');
+  svg.setAttribute('width', '0');
+  svg.setAttribute('height', '0');
+  svg.style.position = 'absolute';
+  // + SVG-фильтры размытия для плазменных линий (feGaussianBlur надёжнее CSS-filter на <path> в WebView).
+  // Широкий регион фильтра (userSpaceOnUse-подобный запас в %), чтобы размытие не срезалось по bbox пути.
+  svg.innerHTML = '<defs>'
+    + '<filter id="fg-shine-glow" x="-120%" y="-120%" width="340%" height="340%" color-interpolation-filters="sRGB"><feGaussianBlur stdDeviation="3.4"/></filter>'
+    + '<filter id="fg-plasma-blur6" x="-100%" y="-200%" width="300%" height="500%" color-interpolation-filters="sRGB"><feGaussianBlur stdDeviation="6"/></filter>'
+    + '<filter id="fg-plasma-blur2" x="-60%" y="-120%" width="220%" height="340%" color-interpolation-filters="sRGB"><feGaussianBlur stdDeviation="2"/></filter>'
+    + '</defs>';
+  document.body.appendChild(svg);
+}
+
+// Равномерный угол по кругу — гарантирует отсутствие угловых наложений при любом N.
+// Небольшой постоянный сдвиг, чтобы первый узел не «прилипал» к горизонтали.
+function spreadAngle(index, total) {
+  if (total <= 0) return 0;
+  return ((index / total) * Math.PI * 2 + 0.52) % (Math.PI * 2);
+}
+
+// Детерминированный «джиттер» по id (0..1) — чтобы орбита была органически неровной,
+// а не идеальным кругом. Без Math.random: одинаковый узел всегда смещён одинаково.
+function hash01(str) {
+  let h = 2166136261;
+  const s = String(str || '');
+  for (let i = 0; i < s.length; i += 1) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return ((h >>> 0) % 1000) / 1000;
+}
+
+/**
+ * Создаёт движок графа внутри переданного контейнера-сцены.
+ * @param {Object} opts
+ * @param {HTMLElement} opts.stage - контейнер сцены (position: relative/absolute, overflow hidden)
+ * @param {Object} opts.model - нормализованная модель { focusId, nodes[] }
+ * @param {Function} [opts.onCenterTap] - тап по центральному узлу (node) => void
+ * @param {Function} [opts.onNodeTap] - тап по периферийному узлу (node) => void (вызывается ДО центрирования)
+ * @param {Function} [opts.onNodeLongPress] - долгое нажатие (node, screenPoint) => void
+ * @returns {{ destroy: Function, recenter: Function, setModel: Function, getFocusNode: Function }}
+ */
+export function createForceGraph({ stage, model, onCenterTap, onNodeTap, onNodeLongPress, onNodeHover, onDiveChange } = {}) {
+  // Слои DOM
+  const edgesSvg = document.createElementNS(SVGNS, 'svg');
+  edgesSvg.setAttribute('class', 'fg-edges');
+  const world = document.createElement('div');
+  world.className = 'fg-world';
+  // Доступность: визуально скрытый текстовый список графа для скринридеров (граф сам по себе им не читается).
+  const a11y = document.createElement('div');
+  a11y.className = 'fg-a11y';
+  a11y.setAttribute('role', 'region');
+  a11y.setAttribute('aria-label', 'Карта связей — список');
+  stage.append(edgesSvg, world, a11y);
+  ensureShineFilter(); // SVG-фильтр свечения «сияющих» (нужен до первой отрисовки узлов)
+
+  // Состояние камеры (панорамирование + зум)
+  let camX = 0;
+  let camY = 0;
+  let zoom = 1;                 // масштаб камеры (1 = базовый); меняется колесом мыши / щипком
+  let camTargetX = null;        // цель дотяжки камеры-доводчика (null = доводчик выключен)
+  let camTargetY = null;
+  let viewW = stage.clientWidth || window.innerWidth;
+  let viewH = stage.clientHeight || window.innerHeight;
+  let centerX = viewW / 2;
+  let centerY = viewH / 2;
+
+  // Узлы движка: { id, login, name, ..., x, y, vx, vy, targetR, angle, scale, scaleFrom, scaleTo, el, dotRadius }
+  let nodes = [];
+  let focusId = '';
+  let nodeById = new Map();   // id → node (для поиска родителя у глубоких уровней)
+  let hasDeep = false;        // есть ли в графе узлы tier≥2 (включает deep-ветки рендера/раскладки)
+  let spotActive = false;     // активен ли «spotlight» (есть закреплённая ветка → остальные тускнеют)
+  let diveTargetId = null;    // id «нырнутого» узла (Smart Zoom); null — мы на верхнем уровне (Иван)
+  let diveZoom = 1;           // целевой зум активного погружения
+  let surfacing = false;      // идёт «всплытие» назад (камера/зум возвращаются к корню)
+  let childCountByParent = new Map(); // parentId → число детей (для адаптивного радиуса орбиты, без слипания)
+  let degreeById = new Map();         // id → число связей узла (для бейджа-счётчика на аватарке)
+  const rebuildIndex = () => {
+    nodeById = new Map(nodes.map((n) => [String(n.id), n]));
+    hasDeep = nodes.some((n) => n.tier >= 2);
+    // число детей у родителя + порядковый индекс ребёнка среди братьев (для веера «полукругом наружу»)
+    childCountByParent = new Map();
+    degreeById = new Map();
+    let tier1count = 0;
+    for (const n of nodes) {
+      if (n.tier >= 2 && n.parentId) {
+        const i = childCountByParent.get(n.parentId) || 0;
+        n.sibIndex = i;
+        childCountByParent.set(n.parentId, i + 1);
+        degreeById.set(n.parentId, (degreeById.get(n.parentId) || 0) + 1); // у родителя +1 связь
+      } else if (n.tier === 1 && String(n.id) !== focusId) {
+        tier1count += 1;
+      }
+    }
+    degreeById.set(focusId, tier1count); // у центра — число связей 1-го уровня
+  };
+
+  // Spotlight: при закреплённой кликом ветке остальной граф тускнеет до SPOTLIGHT_DIM (0.25), чтобы
+  // взгляд держался на раскрытом кластере. Узел «в свете», если он фокус, либо его корневая ветка
+  // 1-го уровня закреплена (pinned) или временно наведена (hovered). Возвращает множитель прозрачности.
+  function rootTier1(n) {
+    let r = n; let guard = 0;
+    while (r && r.tier >= 2 && guard++ < 8) r = nodeById.get(r.parentId) || null;
+    return r;
+  }
+  function spotTargetOf(n) {
+    if (!spotActive || n.isFocus) return 1;
+    const r = rootTier1(n);
+    if (!r) return SPOTLIGHT_DIM;
+    return (r.pinned || r.hovered) ? 1 : SPOTLIGHT_DIM;
+  }
+
+  // Путь-«крошки» от корня (Иван) до нырнутого узла включительно — для подсветки нити назад и глубины.
+  function divePathSet() {
+    const set = new Set();
+    if (!diveTargetId) return set;
+    let cur = nodeById.get(diveTargetId); let guard = 0;
+    while (cur && guard++ < 16) { set.add(String(cur.id)); if (cur.isFocus) break; const p = nodeById.get(cur.parentId); if (!p) break; cur = p; }
+    set.add(String(focusId));
+    return set;
+  }
+  let _pathSet = new Set();
+  let _pathSetKey = '';
+  function ensurePathSet() {
+    const k = diveTargetId || '';
+    if (k !== _pathSetKey) { _pathSetKey = k; _pathSet = divePathSet(); }
+    return _pathSet;
+  }
+  // Хлебные крошки: упорядоченный путь focus → … → нырнутый узел (для UI-навигации). Пусто = верхний уровень.
+  function divePathNodes() {
+    const out = [];
+    if (!diveTargetId) return out;
+    let cur = nodeById.get(diveTargetId); let guard = 0;
+    while (cur && guard++ < 16) { out.push(cur); if (cur.isFocus) break; const p = nodeById.get(cur.parentId); if (!p) break; cur = p; }
+    const f = nodeById.get(focusId);
+    if (f && out[out.length - 1] !== f) out.push(f);
+    return out.reverse(); // от корня (Иван) к цели
+  }
+  function emitDiveChange() {
+    if (typeof onDiveChange !== 'function') return;
+    onDiveChange(divePathNodes().map((n) => ({ id: String(n.id), name: n.name || n.login || String(n.id), isFocus: !!n.isFocus })));
+  }
+  // Поиск узла по имени/логину (строка поиска): точное совпадение приоритетнее подстроки.
+  function findNode(query) {
+    const q = String(query || '').trim().toLowerCase();
+    if (!q) return null;
+    let hit = nodes.find((n) => String(n.name || '').toLowerCase() === q || String(n.login || '').toLowerCase() === q);
+    if (!hit) hit = nodes.find((n) => String(n.name || '').toLowerCase().includes(q) || String(n.login || '').toLowerCase().includes(q));
+    return hit ? { id: String(hit.id), name: hit.name || hit.login || String(hit.id), tier: hit.tier } : null;
+  }
+  // Базовый масштаб узла по его роли/уровню (как в makeNodeState) — чтобы привести героя и его детей
+  // к ОДИНАКОВОМУ видимому размеру независимо от tier (depthScale = желаемый_видимый / базовый).
+  function baseScaleOf(n) {
+    if (n.isFocus) return FOCUS_SCALE;
+    if (n.tier >= 3) return n.lod === 'full' ? 0.42 : 1;
+    if (n.tier === 2) return DEEP2_SCALE;
+    return PRIMARY_SCALE;
+  }
+  // Контекст узла: целевые { прозрачность, множитель масштаба, размытие } для эффекта «аквариума»/spotlight.
+  // Погружение (dive) имеет приоритет: нырнутый узел крупный/чёткий, путь назад — чёткий, фон — мелкий/blur.
+  function contextTargetOf(n) {
+    if (diveTargetId) {
+      const ps = ensurePathSet();
+      const id = String(n.id);
+      // герой и его прямые дети — до фиксированного ВИДИМОГО масштаба (множитель = желаемый/базовый)
+      if (id === diveTargetId) return { op: 1, scale: Math.max(0.8, Math.min(3.8, HERO_VISUAL / baseScaleOf(n))), blur: 0 };
+      if (String(n.parentId) === diveTargetId) return { op: 1, scale: Math.max(0.8, Math.min(3.2, DIVE_CHILD_VISUAL / baseScaleOf(n))), blur: 0 };
+      if (ps.has(id)) return { op: 1, scale: n.isFocus ? DIVE_ROOT_MUL : DIVE_PATH_MUL, blur: 0 }; // путь назад
+      return { op: SPOTLIGHT_DIM, scale: DIVE_OFFPATH_MUL, blur: DIVE_BLUR };            // фон (расфокус)
+    }
+    return { op: spotTargetOf(n), scale: 1, blur: 0 }; // без погружения — обычный spotlight
+  }
+
+  // Управление циклом rAF
+  let rafId = 0;
+  let dragging = false;
+
+  // Твин центрирования
+  let tween = null; // { startTs, from: Map(id->{x,y,scale}), to: Map(id->{x,y,scale}), camFrom, camTo }
+
+  // Точка, из которой новый фокус «влетает» в центр (мировые координаты кликнутого узла)
+  let pendingFocusOrigin = null;
+
+  // Затухающий «boost» вязкости после перестроения (1→0): гасит энергию «взрыва» из центра.
+  let boost = 0;
+  let frictionNow = FRICTION;
+  let chargeNow = CHARGE;
+
+  // Режим CSS-bloom: узлы разлетаются нативными CSS-переходами (компоновщик, без JS-физики),
+  // цикл только перерисовывает лучи вслед за узлами. Завершается по таймеру.
+  let cssBloom = false;
+  let cssBloomTimer = 0;
+  let cssBloomKind = 'bloom'; // 'bloom' (каскадный разлёт) | 'filter' (фиксация на равномерных углах)
+
+  // Инерция панорамирования (kinematic panning)
+  let panVelX = 0;
+  let panVelY = 0;
+
+  // Упругий «изгиб от свайпа»: сглаженный вектор, который догоняет скорость пальца и плавно
+  // возвращается к нулю при отпускании (lerp). Им смещаем контрольные точки Безье — нити тянутся.
+  let panBendX = 0;
+  let panBendY = 0;
+  let panTwang = false; // флаг «гитарной струны»: один вибро-щелчок при сильном натяжении нитей
+  function advancePanBend() {
+    panBendX += (panVelX - panBendX) * 0.3;
+    panBendY += (panVelY - panBendY) * 0.3;
+  }
+
+  // --- Построение модели -----------------------------------------------------
+  // Вычисляем «спецификации» узлов нового графа (без создания DOM) — для диффинга:
+  // фокус + периферия, отсортированная по силе связи; сверх лимита — лёгкие точки.
+  function computeSpecs(srcModel) {
+    const list = Array.isArray(srcModel?.nodes) ? srcModel.nodes : [];
+    const fId = String(srcModel?.focusId || (list[0] && list[0].id) || '');
+    // 1-й уровень держит орбиту вокруг центра (сортируем по силе, как раньше); узлы 2/3 уровня
+    // («друзья друзей» и микрозвёзды) орбиту не используют — их раскладывает layoutDeep вокруг родителя.
+    const tier1 = list
+      .filter((n) => String(n.id) !== fId && (Number(n.tier) || 1) === 1)
+      .sort((a, b) => (Number(b.strength) || 0) - (Number(a.strength) || 0));
+    const deep = list.filter((n) => String(n.id) !== fId && (Number(n.tier) || 1) >= 2);
+    const dotCount = Math.max(0, tier1.length - MAX_FULL_NODES);
+    if (dotCount > 0) {
+      console.info(`[force-graph] связей ${tier1.length}: полных аватарок ${MAX_FULL_NODES}, точек ${dotCount}`);
+    }
+    const specs = [];
+    const focusSrc = list.find((n) => String(n.id) === fId) || list[0];
+    if (focusSrc) specs.push({ src: focusSrc, id: String(focusSrc.id), isFocus: true, index: 0, total: 1, dotOnly: false });
+    tier1.forEach((p, i) => specs.push({ src: p, id: String(p.id), isFocus: false, index: i, total: tier1.length, dotOnly: i >= MAX_FULL_NODES }));
+    // 3-й уровень рисуем точками (микрозвёзды), 2-й — маленькими аватарками
+    deep.forEach((p) => specs.push({ src: p, id: String(p.id), isFocus: false, index: 0, total: 1, dotOnly: (Number(p.tier) || 2) >= 3 }));
+    return { focusId: fId, specs };
+  }
+
+  function buildNodes(srcModel) {
+    const { focusId: fId, specs } = computeSpecs(srcModel);
+    focusId = fId;
+    return specs.map((s) => makeNodeState(s.src, s.isFocus, s.index, s.total, s.dotOnly));
+  }
+
+  function makeNodeState(src, isFocus, index, total, dotOnly = false) {
+    const strength = Math.max(0, Math.min(1, Number(src.strength) || 0.5));
+    const tier = Number(src.tier) || 1;
+    // органическая неровность: детерминированный джиттер радиуса (±9px) и угла (±0.2 рад)
+    const jr = (hash01(src.id) - 0.5) * 18;
+    const ja = (hash01(`${src.id}~a`) - 0.5) * 0.4;
+    const targetR = isFocus ? 0 : ORBIT_MIN + (1 - strength) * (ORBIT_MAX - ORBIT_MIN) + jr;
+    const angle = isFocus ? 0 : spreadAngle(index, total) + ja;
+    // масштаб/прозрачность по уровню глубины: 2-й — вдвое меньше и полупрозрачный, 3-й — микрозвезда.
+    const scale = isFocus ? FOCUS_SCALE : (tier === 2 ? DEEP2_SCALE : (tier >= 3 ? 1 : PRIMARY_SCALE));
+    const op = tier === 2 ? DEEP2_OPACITY : (tier >= 3 ? DEEP3_OPACITY : 1);
+    // целевая точка на орбите (равномерно по углу) и стартовая позиция ближе к центру —
+    // узлы «выезжают» наружу при появлении (демонстрация физики), потом пружина их фиксирует.
+    const tx = isFocus ? 0 : Math.cos(angle) * targetR;
+    const ty = isFocus ? 0 : Math.sin(angle) * targetR;
+    const el = buildNodeElement(src, isFocus, tier, dotOnly);
+    world.append(el);
+    return {
+      ...src,
+      isFocus,
+      tier,
+      parentId: String(src.parentId || ''),       // у tier≥2 — id родителя; пусто → центр (фокус)
+      deepAngle: Number(src.deepAngle) || hash01(`${src.id}~d`) * Math.PI * 2,
+      track: Boolean(src.track),                   // «трек прохождения» — линия к этому узлу горит ярко
+      pinned: false,                               // зафиксировано кликом/тапом — ветка раскрыта «намертво»
+      hovered: false,                              // временно раскрыто наведением (мышь/палец) — пропадёт при уходе
+      expandP: 0,                                  // текущий прогресс раскрытия (0 скрыто → 1 выплыло), 400мс
+      dotOnly,
+      strength,
+      targetR,
+      angle,
+      tx,
+      ty,
+      x: tx * INTRO_FACTOR,
+      y: ty * INTRO_FACTOR,
+      vx: 0,
+      vy: 0,
+      scale,
+      targetScale: scale,
+      hidden: false,
+      opacity: tier >= 2 ? op : 1,
+      targetOpacity: op,
+      spotCur: 1,                                  // текущий множитель spotlight-затемнения (1 = полный свет)
+      depthScale: 1,                               // множитель масштаба «глубины» (dive: цель крупно, фон мелко)
+      depthBlur: 0,                                // размытие «глубины» (dive: фон уходит в расфокус), px
+      lod: (dotOnly && tier >= 3) ? 'dot' : 'full', // уровень детализации tier-3: точка ↔ аватарка (по зуму)
+      bloom: false,
+      edgeGrow: 1, // прогресс «вырастания» линии этого узла 0→1 (для нового узла стартует с 0)
+      el,
+      dotRadius: isFocus ? 32 : (tier >= 3 ? 5 : (tier === 2 ? 16 : (dotOnly ? 7 : 26))),
+    };
+  }
+
+  // Аватар из прямого URL-фото (тестовые данные лаборатории). Структура — как у renderUserAvatar
+  // (переиспользуем CSS .avatar/.node-dot), фолбэк на инициалы при ошибке загрузки (офлайн).
+  function buildPhotoAvatar(src) {
+    const wrap = document.createElement('div');
+    wrap.className = 'avatar avatar-image node-dot';
+    const fb = document.createElement('span');
+    fb.className = 'avatar-fallback';
+    fb.textContent = buildAvatarInitials({ login: src.login || String(src.id), firstName: src.name || '' });
+    wrap.append(fb);
+    const img = document.createElement('img');
+    img.alt = '';
+    img.loading = 'lazy';
+    img.decoding = 'async';
+    img.onload = () => wrap.classList.add('has-image');
+    img.onerror = () => { img.remove(); }; // нет сети — остаются инициалы
+    img.src = src.photo;
+    wrap.append(img);
+    return wrap;
+  }
+
+  function buildNodeElement(src, isFocus, tier, dotOnly = false) {
+    const el = document.createElement('button');
+    el.type = 'button';
+    // лёгкая точка для узлов сверх лимита: без аватара и подписи (производительность)
+    if (dotOnly) {
+      el.className = [
+        'fg-node', 'fg-dot',
+        tier >= 3 ? 'is-tier3' : '',     // микрозвезда 3-го уровня (светящаяся мерцающая точка)
+        src.shining ? 'is-shine' : '',
+        `is-${src.relationType || 'contact'}`,
+      ].filter(Boolean).join(' ');
+      el.dataset.nodeId = String(src.id);
+      el.title = src.name || src.login || '';
+      // десинхронизируем мерцание звёзд (отрицательная задержка) → живое «созвездие», не «моргание в такт»
+      if (tier >= 3) el.style.animationDelay = `${(-hash01(`${src.id}~t`) * 3.4).toFixed(2)}s`;
+      return el;
+    }
+    el.className = [
+      'fg-node',
+      isFocus ? 'is-focus' : '',
+      src.shining ? 'is-shine' : '',
+      `is-${src.relationType || 'contact'}`,
+      tier === 2 ? 'is-tier2' : '',      // друг друзей (вдвое меньше, полупрозрачный)
+      tier >= 2 ? 'is-secondary' : '',
+      src.common ? 'is-common' : '',     // «общая связь» — этот человек и твой друг тоже (золотой ободок ★)
+    ].filter(Boolean).join(' ');
+    el.dataset.nodeId = String(src.id);
+
+    // тестовое фото (лаборатория) — прямой URL; иначе штатный аватар (Arweave/инициалы)
+    const avatar = src.photo
+      ? buildPhotoAvatar(src)
+      : renderUserAvatar({
+        login: src.login || src.name || String(src.id),
+        firstName: src.name || '',
+        avatar: src.avatar || null,
+        size: 'node',
+        title: src.name || src.login || '',
+      });
+    el.append(avatar);
+
+    // Бейдж-счётчик числа связей (заполняется в updateBadges по degreeById). Скрыт, пока 0.
+    const badge = document.createElement('span');
+    badge.className = 'fg-node-badge';
+    badge.hidden = true;
+    el.append(badge);
+
+    const label = document.createElement('span');
+    label.className = 'fg-node-label';
+    label.textContent = src.name || src.login || '';
+    el.append(label);
+    return el;
+  }
+
+  // Заполняет бейджи-счётчики связей (число детей/связей узла). Вызывается после rebuildIndex.
+  function updateBadges() {
+    for (const n of nodes) {
+      const badge = n.el.querySelector('.fg-node-badge');
+      if (!badge) continue; // у точек (dotOnly) бейджа нет
+      const deg = degreeById.get(String(n.id)) || 0;
+      if (deg > 0) { badge.textContent = deg > 99 ? '99+' : String(deg); badge.hidden = false; }
+      else { badge.hidden = true; }
+    }
+  }
+
+  // Доступность: текстовое представление графа для скринридеров (центр + связи 1-го уровня списком).
+  function updateA11y() {
+    const focus = nodes.find((n) => n.isFocus);
+    const tier1 = nodes.filter((n) => n.tier === 1 && !n.isFocus);
+    const rel = { family: 'семья', friend: 'друг', business: 'бизнес', contact: 'контакт' };
+    const items = tier1.map((n) => `<li>${escapeHtml(n.name || n.login || String(n.id))}${n.shining ? ' — сияющий' : ''} (${rel[n.relationType] || 'связь'})</li>`).join('');
+    a11y.innerHTML = `<p>Центр: ${escapeHtml(focus ? (focus.name || focus.login || '') : '')}. Связей 1-го уровня: ${tier1.length}.</p><ul>${items}</ul>`;
+  }
+  function escapeHtml(s) { return String(s).replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c])); }
+
+  // Переиспользование узла при диффинге: сохраняем x/y/скорость, задаём новую роль и цель.
+  function updateNodeRole(node, spec) {
+    const src = spec.src;
+    const strength = Math.max(0, Math.min(1, Number(src.strength) || 0.5));
+    const tier = Number(src.tier) || 1;
+    node.isFocus = spec.isFocus;
+    node.tier = tier;
+    node.parentId = String(src.parentId || '');
+    node.deepAngle = Number(src.deepAngle) || node.deepAngle || hash01(`${src.id}~d`) * Math.PI * 2;
+    node.track = Boolean(src.track);
+    node.pinned = false; node.hovered = false; node.expandP = 0; node.spotCur = 1; // при перестроении глубина схлопывается
+    node.depthScale = 1; node.depthBlur = 0; node.lod = (spec.dotOnly && tier >= 3) ? 'dot' : 'full';
+    node.dotOnly = spec.dotOnly;
+    node.strength = strength;
+    node.relationType = src.relationType;
+    node.shining = Boolean(src.shining);
+    const jr = (hash01(src.id) - 0.5) * 18;
+    const ja = (hash01(`${src.id}~a`) - 0.5) * 0.4;
+    node.targetR = spec.isFocus ? 0 : ORBIT_MIN + (1 - strength) * (ORBIT_MAX - ORBIT_MIN) + jr;
+    node.angle = spec.isFocus ? 0 : spreadAngle(spec.index, spec.total) + ja;
+    node.tx = Math.cos(node.angle) * node.targetR;
+    node.ty = Math.sin(node.angle) * node.targetR;
+    node.targetScale = spec.isFocus ? FOCUS_SCALE : (tier === 2 ? DEEP2_SCALE : (tier >= 3 ? 1 : PRIMARY_SCALE));
+    node.targetOpacity = tier === 2 ? DEEP2_OPACITY : (tier >= 3 ? DEEP3_OPACITY : 1);
+    node.hidden = false;
+    node.bloom = false;
+    node.dotRadius = spec.isFocus ? 32 : (tier >= 3 ? 5 : (tier === 2 ? 16 : (spec.dotOnly ? 7 : 26)));
+    // обновляем классы элемента (роль/тип/свечение/уровень) — без пересоздания DOM
+    node.el.className = spec.dotOnly
+      ? ['fg-node', 'fg-dot', tier >= 3 ? 'is-tier3' : '', src.shining ? 'is-shine' : '', `is-${src.relationType || 'contact'}`].filter(Boolean).join(' ')
+      : ['fg-node', spec.isFocus ? 'is-focus' : '', src.shining ? 'is-shine' : '', `is-${src.relationType || 'contact'}`, tier === 2 ? 'is-tier2' : '', tier >= 2 ? 'is-secondary' : '', src.common ? 'is-common' : ''].filter(Boolean).join(' ');
+  }
+
+  // --- Рендер ----------------------------------------------------------------
+  function applyWorldTransform() {
+    world.style.transform = `translate3d(${camX}px, ${camY}px, 0) scale(${zoom})`;
+  }
+
+  // Камера-доводчик: мягко подвести раскрываемый кластер целиком в кадр, НЕ теряя центр (Иван остаётся
+  // в графе, просто сдвигается). Считаем экранную позицию узла и его «веера» (DEEP_R2) и, если он
+  // упирается в край, задаём цель дотяжки (плавный lerp в tick). Любой жест пользователя её отменяет.
+  function glideCameraTo(n) {
+    if (!n) return;
+    const ring = (DEEP_R2 + 64) * zoom;            // радиус раскрытого веера + запас (экранные px)
+    const sx = centerX + camX + n.x * zoom;
+    const sy = centerY + camY + n.y * zoom;
+    let tx = camX;
+    let ty = camY;
+    const m = CAM_GLIDE_MARGIN;
+    if (sx - ring < m) tx += (m - (sx - ring));
+    else if (sx + ring > viewW - m) tx -= ((sx + ring) - (viewW - m));
+    if (sy - ring < m) ty += (m - (sy - ring));
+    else if (sy + ring > viewH - m) ty -= ((sy + ring) - (viewH - m));
+    if (Math.abs(tx - camX) > 1 || Math.abs(ty - camY) > 1) { camTargetX = tx; camTargetY = ty; }
+  }
+
+  // --- Зум камеры (колесо мыши / щипок двумя пальцами) -----------------------
+  // Масштабируем «к точке» (sx,sy): мировая точка под курсором/центром щипка остаётся на месте.
+  function setZoom(nextZoom, sx, sy) {
+    const z0 = zoom;
+    const z1 = Math.max(ZOOM_MIN, Math.min(ZOOM_MAX, nextZoom));
+    if (Math.abs(z1 - z0) < 0.0001) return;
+    const wx = (sx - centerX - camX) / z0;
+    const wy = (sy - centerY - camY) / z0;
+    zoom = z1;
+    camX = sx - centerX - wx * z1;
+    camY = sy - centerY - wy * z1;
+    camTargetX = null; camTargetY = null;          // ручной зум отменяет доводчик
+    applyWorldTransform();
+    renderEdges();
+  }
+  function onWheel(ev) {
+    ev.preventDefault();
+    const rect = stage.getBoundingClientRect();
+    setZoom(zoom * Math.exp(-ev.deltaY * ZOOM_WHEEL), ev.clientX - rect.left, ev.clientY - rect.top);
+    wake();
+  }
+
+  function renderNodes() {
+    for (const n of nodes) {
+      const ds = n.depthScale ?? 1;
+      n.el.style.transform =
+        `translate(calc(${n.x}px - 50%), calc(${n.y}px - 50%)) scale(${n.scale * ds})`;
+      n.el.style.opacity = String(n.opacity * (n.spotCur ?? 1)); // spotlight/глубина: затемнённые тусклее
+      // расфокус глубины (dive): фоновые узлы уходят в blur; чёткие — без фильтра (дёшево)
+      n.el.style.filter = (n.depthBlur > 0.15 && n.opacity > 0.02) ? `blur(${n.depthBlur.toFixed(1)}px)` : '';
+      n.el.style.pointerEvents = n.hidden && n.opacity <= 0.01 ? 'none' : '';
+    }
+  }
+
+  // Глубина 2-3 уровней (только лаборатория): узлы tier≥2 не участвуют в физике. По умолчанию
+  // СКРЫТЫ (схлопнуты в родителя, opacity 0) — и «выплывают» вокруг родителя по мере его раскрытия
+  // (parent.expandP: 0 скрыто → 1 выплыло). Так нет «каши»: видно только то, с чем взаимодействуешь.
+  function layoutDeep() {
+    if (!hasDeep) return;
+    for (const tier of [2, 3]) {
+      for (const n of nodes) {
+        if (n.tier !== tier) continue;
+        const p = nodeById.get(n.parentId);
+        if (!p) { n.opacity = 0; continue; }
+        const e = p.expandP || 0;                      // насколько раскрыт родитель
+        // АДАПТИВНЫЙ радиус орбиты (фикс слипания): дети не лезут на (возможно увеличенный зумом) родитель
+        // и не накладываются друг на друга. Клиренс = радиус родителя + базовый отступ; место = по числу детей.
+        const baseR = tier === 2 ? DEEP_R2 : DEEP_R3;
+        const pr = 26 * (p.scale || 1) * (p.depthScale || 1); // визуальный радиус родителя (world-единицы)
+        const cnt = childCountByParent.get(n.parentId) || 1;
+        const ringR = Math.max(baseR + pr, cnt * 13);  // расталкивание: дети без наложений (клиренс + место)
+        const r = ringR * e;                            // при e=0 — в центре родителя, при 1 — на полной орбите
+        // ВЕЕР «полукругом наружу»: раскрываем детей в сторону ОТ пути назад (от деда к родителю),
+        // чтобы они не перекрывали нить-крошку и родителя. Равномерно по индексу среди братьев.
+        const gp = nodeById.get(p.parentId);
+        const ox = p.x - (gp ? gp.x : 0);
+        const oy = p.y - (gp ? gp.y : 0);
+        const outward = (ox || oy) ? Math.atan2(oy, ox) : n.deepAngle; // направление наружу (фолбэк — старый угол)
+        const t = cnt > 1 ? ((n.sibIndex || 0) / (cnt - 1) - 0.5) : 0;  // -0.5..0.5 по веера
+        const ang = outward + t * DEEP_FAN;
+        n.x = p.x + Math.cos(ang) * r;
+        n.y = p.y + Math.sin(ang) * r;
+        const baseOp = tier === 2 ? DEEP2_OPACITY : DEEP3_OPACITY;
+        // tier-3: точка-звезда (scale ~1, CSS фиксирует 9px) ИЛИ аватарка при LOD-апгрейде (мельче, 52px*0.42)
+        const baseSc = tier === 2 ? DEEP2_SCALE : (n.lod === 'full' ? 0.42 : 1);
+        // вложенность: tier-3 виден только когда виден его tier-2 родитель (он сам — глубокий)
+        const parentVis = p.tier >= 2 ? ((p.opacity || 0) > 0.04 ? 1 : 0) : 1;
+        n.opacity = baseOp * e * parentVis;
+        n.scale = baseSc * (0.3 + 0.7 * e);            // лёгкий «поп» при выплывании
+        n.targetOpacity = n.opacity; n.targetScale = n.scale;
+      }
+    }
+  }
+
+  // Плавная анимация раскрытия (expandP → expandTarget, ~400мс). Возвращает true, пока что-то едет.
+  // Эффективная цель раскрытия узла: раскрыт, если зафиксирован кликом (pinned) ИЛИ временно наведён (hovered).
+  function expandTargetOf(n) { return (n.pinned || n.hovered) ? 1 : 0; }
+
+  function advanceExpand() {
+    let moving = false;
+    for (const n of nodes) {
+      const t = expandTargetOf(n);
+      const cur = n.expandP || 0;
+      if (Math.abs(cur - t) > 0.001) {
+        let next = cur + (t - cur) * 0.18;
+        if (Math.abs(next - t) < 0.012) next = t; else moving = true;
+        n.expandP = next;
+      }
+    }
+    return moving;
+  }
+
+  // Во время CSS-bloom (когда renderNodes не вызывается — узлы 1-го уровня анимирует компоновщик)
+  // отдельно позиционируем глубокие узлы из JS, чтобы они следовали за родителями.
+  function renderDeepNodes() {
+    if (!hasDeep) return;
+    for (const n of nodes) {
+      if (n.tier < 2) continue;
+      const ds = n.depthScale ?? 1;
+      n.el.style.transform = `translate(calc(${n.x}px - 50%), calc(${n.y}px - 50%)) scale(${n.scale * ds})`;
+      n.el.style.opacity = String(n.opacity * (n.spotCur ?? 1)); // spotlight/глубина: затемнённые тусклее
+      n.el.style.filter = (n.depthBlur > 0.15 && n.opacity > 0.02) ? `blur(${n.depthBlur.toFixed(1)}px)` : '';
+    }
+  }
+
+  // LOD (level-of-detail): при сильном зуме (pinch/dive) видимые точки 3-го уровня дорисовываются как
+  // маленькие аватарки (лицо+имя), при отдалении — сворачиваются обратно в светящиеся точки.
+  // Пере-рендер DOM только при пересечении порога (редкое событие); ежекадровая проверка дешёвая.
+  function updateLod() {
+    if (!hasDeep) return;
+    for (const n of nodes) {
+      if (n.tier < 3) continue;                          // LOD касается только микрозвёзд 3-го уровня
+      const isFull = n.lod === 'full';
+      // гистерезис: апгрейд на UP, откат на DOWN — у промежуточного зума состояние «залипает» (без мигания)
+      const threshold = isFull ? LOD_ZOOM_DOWN : LOD_ZOOM_UP;
+      const wantFull = zoom >= threshold && (n.opacity > 0.04); // апгрейдим только видимые
+      if (wantFull === isFull) continue;
+      setNodeLod(n, wantFull);
+    }
+  }
+  function setNodeLod(n, full) {
+    const newEl = buildNodeElement(n, false, n.tier, !full); // n несёт src-поля (photo/name/...) через spread
+    newEl.style.transform = n.el.style.transform;          // без скачка к (0,0) на один кадр
+    newEl.style.opacity = n.el.style.opacity;
+    world.replaceChild(newEl, n.el);
+    n.el = newEl;
+    n.lod = full ? 'full' : 'dot';
+    n.dotOnly = !full;
+    n.dotRadius = full ? 12 : 5;                           // радиус для расчёта концов линий связей
+    if (full) { const b = newEl.querySelector('.fg-node-badge'); const deg = degreeById.get(String(n.id)) || 0; if (b && deg > 0) { b.textContent = deg > 99 ? '99+' : String(deg); b.hidden = false; } }
+  }
+
+  function renderEdges() {
+    const focus = nodes.find((n) => n.id === focusId);
+    if (!focus) {
+      edgesSvg.innerHTML = '';
+      return;
+    }
+    // концы линий — строго по центрам узлов (намертво привязаны), изгиб даёт скорость.
+    // Z — зум камеры: SVG-слой отдельный (не масштабируется), поэтому координаты узлов умножаем на zoom.
+    const Z = zoom;
+    const tx = (n) => centerX + camX + n.x * Z;
+    const ty = (n) => centerY + camY + n.y * Z;
+
+    const focusLogin = String(focus.login || '').toLowerCase();
+    const parts = [];
+    const defs = [];
+    let gi = 0;
+    for (const n of nodes) {
+      if (n === focus) continue;
+      // скрытый фильтром узел: рисуем луч пока он гаснет (живая прозрачность > 0), затем пропускаем
+      const nodeOpacity = (typeof n.opacity === 'number') ? n.opacity : 1;
+      if (n.hidden && nodeOpacity <= 0.02) continue;
+      if (focusLogin && String(n.login || '').toLowerCase() === focusLogin) continue;
+      // начало связи = РОДИТЕЛЬ узла: tier-1 → фокус (поведение как раньше), tier-2/3 → их узел-родитель
+      const parent = (n.parentId && nodeById.get(n.parentId)) || focus;
+      const fx = centerX + camX + parent.x * Z;
+      const fy = centerY + camY + parent.y * Z;
+      const fr = parent.dotRadius * parent.scale * (parent.depthScale ?? 1) * Z + 4;
+      const nx = tx(n);
+      const ny = ty(n);
+      if ((nx < -80 && fx < -80) || (nx > viewW + 80 && fx > viewW + 80)) continue;
+      if ((ny < -80 && fy < -80) || (ny > viewH + 80 && fy > viewH + 80)) continue;
+
+      // Эффект ПРОРАСТАНИЯ: новый узел во время разлёта (bloom) — линию тянем к его ФИНАЛЬНОЙ точке
+      // и раскрываем dashoffset'ом синхронно с разлётом (кончик трекает аватарку). Переезжающие/
+      // общие узлы и покой — линия идёт к ТЕКУЩЕЙ точке (просто следует за узлом, без dash).
+      const growing = cssBloom && cssBloomKind === 'bloom' && !n.isFocus && n.edgeGrow < 1;
+      const ex = growing ? (centerX + camX + n.bfx * Z) : nx;
+      const ey = growing ? (centerY + camY + n.bfy * Z) : ny;
+      const dx = ex - fx;
+      const dy = ey - fy;
+      const len = Math.hypot(dx, dy) || 1;
+      const ux = dx / len;
+      const uy = dy / len;
+      const nr = n.dotRadius * n.scale * (n.depthScale ?? 1) * Z + 4;
+      // концы линии — у краёв кружков
+      const x1 = fx + ux * fr;
+      const y1 = fy + uy * fr;
+      const x2 = ex - ux * nr;
+      const y2 = ey - uy * nr;
+      // контрольная точка кривой Безье: постоянная изящная дуга (перпендикуляр) +
+      // прогиб НАЗАД против вектора скорости узла (резиновый жгут); в покое — идеальная дуга
+      const mx = (x1 + x2) / 2;
+      const my = (y1 + y2) / 2;
+      const segLen0 = Math.hypot(x2 - x1, y2 - y1);
+      const baseBow = Math.max(7, Math.min(20, segLen0 * 0.12));   // постоянная дуга
+      const speed = Math.hypot(n.vx, n.vy);
+      const lag = Math.min(30, speed * 1.8);                       // отставание ∝ скорости
+      const invX = speed > 0.01 ? -n.vx / speed : 0;               // направление против движения
+      const invY = speed > 0.01 ? -n.vy / speed : 0;
+      // ПАН-СТРЕТЧ (резиновые нити): при свайпе контрольную точку тянем ПРОТИВ направления пальца,
+      // сильнее у дальних узлов (инерция периферии). panBend сглажен и сам затухает → нить пружинит назад.
+      const farK = Math.min(1.3, Math.max(0.35, segLen0 / 200));
+      let panBx = -panBendX * 0.55 * farK;
+      let panBy = -panBendY * 0.55 * farK;
+      const panBmag = Math.hypot(panBx, panBy);
+      if (panBmag > 40) { panBx = (panBx / panBmag) * 40; panBy = (panBy / panBmag) * 40; }
+      // желаемая середина кривой = M + перпендикулярная дуга + прогиб против скорости узла + пан-стретч
+      const desX = mx + (-uy) * baseBow + invX * lag + panBx;
+      const desY = my + ux * baseBow + invY * lag + panBy;
+      const cpx = 2 * desX - mx; // CP так, чтобы середина Q-кривой попала в desired
+      const cpy = 2 * desY - my;
+      // Связь рисуем по статусу узла:
+      //  • обычная — одна тонкая (1.0–1.2px) матовая дуга, градиент с ГЛУБОКИМ уходом в прозрачность;
+      //  • СИЯЮЩАЯ — двухслойный неоновый «световод»: широкий размытый glow (под) + тонкий чёткий
+      //    core 1.5px (над) → изящно, но с объёмным OLED-свечением (см. .fg-edge-glow / .fg-edge-core).
+      const shine = Boolean(n.shining) && !n.hidden;
+      const sp = (n.spotCur ?? 1); // spotlight/глубина: линия тускнеет вместе со своим узлом
+      const onPath = Boolean(diveTargetId) && ensurePathSet().has(String(n.id)) && !n.isFocus; // нить-крошка пути
+      const d = `M${x1.toFixed(1)} ${y1.toFixed(1)} Q${cpx.toFixed(1)} ${cpy.toFixed(1)} ${x2.toFixed(1)} ${y2.toFixed(1)}`;
+      // ПРОРАСТАНИЕ из центра: dasharray = длина пути, dashoffset от длины к 0 по мере разлёта узла
+      // (growP = доля пройденного узлом пути центр→орбита) → линия «вытягивается» из центра.
+      let dashAttr = '';
+      if (growing) {
+        const finalD = Math.hypot(n.bfx, n.bfy) || 1;
+        const curD = Math.hypot(n.x, n.y);
+        const growP = Math.max(0, Math.min(1, curD / finalD));
+        const L = (Math.hypot(cpx - x1, cpy - y1) + Math.hypot(x2 - cpx, y2 - cpy) + Math.hypot(x2 - x1, y2 - y1)) / 2;
+        dashAttr = ` stroke-dasharray="${L.toFixed(1)}" stroke-dashoffset="${(L * (1 - growP)).toFixed(1)}"`;
+      }
+      const pe = parent.expandP || 0; // насколько раскрыт родитель (глубокие лучи видны вместе с детьми)
+      if (n.tier >= 3) {
+        // 3-й уровень: микрозвезда — еле заметная космическая ниточка, видна только при раскрытии
+        if (pe > 0.02) parts.push(`<path d="${d}" fill="none" stroke="rgba(150, 205, 255, 0.7)" stroke-width="0.6" opacity="${(0.1 * pe * sp).toFixed(2)}" />`);
+      } else if (n.tier === 2) {
+        // 2-й уровень: матовая паутинка, проявляется по мере раскрытия родителя (локальный bloom)
+        if (pe > 0.02) parts.push(`<path d="${d}" fill="none" stroke="rgba(175, 200, 235, 0.9)" stroke-width="0.8" stroke-linecap="round" opacity="${(0.14 * pe * sp).toFixed(2)}" />`);
+      } else if (shine || n.track || onPath) {
+        // СИЯЮЩАЯ связь — плазменный композитинг: ОДИН центральный S-путь (cubic) + ТРИ наложенных слоя
+        // с ОДИНАКОВЫМ d (объём из толщины+blur, не из геометрии). Слои: широкое поле / трубка / ядро.
+        const pnx = -uy;
+        const pny = ux;                                   // перпендикуляр к хорде
+        const amp = Math.min(13, 5 + segLen0 * 0.05);     // амплитуда S — спокойная изящная волна (∝ длине)
+        const bowX = desX - mx;
+        const bowY = desY - my;                           // вектор изящной дуги + пан-стретч — сохраняем
+        // единственная S-кривая: контрольная точка на 1/3 смещена +amp, на 2/3 — −amp (плавная волна)
+        const c1x = x1 + (x2 - x1) / 3 + bowX + pnx * amp; const c1y = y1 + (y2 - y1) / 3 + bowY + pny * amp;
+        const c2x = x1 + 2 * (x2 - x1) / 3 + bowX - pnx * amp; const c2y = y1 + 2 * (y2 - y1) / 3 + bowY - pny * amp;
+        const dS = `M${x1.toFixed(1)} ${y1.toFixed(1)} C${c1x.toFixed(1)} ${c1y.toFixed(1)} ${c2x.toFixed(1)} ${c2y.toFixed(1)} ${x2.toFixed(1)} ${y2.toFixed(1)}`;
+        const base = nodeOpacity * sp;                    // затемнение от spotlight/глубины
+        // 3 слоя на ОДНОМ пути dS. Видимый НЕОН: яркое ядро + чёткий голубой ореол (поле+трубка в режиме
+        // screen — свет складывается аддитивно с фоном). Прозрачности подняты, чтобы не было «белого каната».
+        parts.push(`<path class="fg-plasma-flare" d="${dS}"${dashAttr} opacity="${(0.42 * base).toFixed(3)}" />`);
+        parts.push(`<path class="fg-plasma-tube" d="${dS}"${dashAttr} opacity="${(0.85 * base).toFixed(3)}" />`);
+        parts.push(`<path class="fg-plasma-core" d="${dS}"${dashAttr} opacity="${(1 * base).toFixed(3)}" />`);
+      } else {
+        // ОБЫЧНАЯ связь — мягкий светящийся жгут В ЦВЕТЕ СВЯЗИ (семья тёплый / друзья синий /
+        // бизнес фиолет): тоньше и тише сияющих. Без SVG-blur (дёшево): широкая подложка + тонкое ядро.
+        const col = relationColor(n.relationType);
+        const opVal = nodeOpacity * sp;
+        const haloOp = (0.22 * opVal).toFixed(2);
+        const coreOp = (0.7 * opVal).toFixed(2);
+        const sw = (2.6 + n.strength * 1.4).toFixed(2);   // мягкая подложка-«свечение» в цвете связи
+        parts.push(`<path d="${d}" fill="none" stroke="${col}" stroke-width="${sw}" stroke-linecap="round" opacity="${haloOp}"${dashAttr} />`);
+        parts.push(`<path d="${d}" fill="none" stroke="${col}" stroke-width="1.2" stroke-linecap="round" opacity="${coreOp}"${dashAttr} />`);
+      }
+    }
+    edgesSvg.innerHTML = `<defs>${defs.join('')}</defs>${parts.join('')}`;
+  }
+
+  function renderAll() {
+    renderNodes();
+    renderEdges();
+  }
+
+  // --- Физика (пружины + отталкивание) ---------------------------------------
+  // Фокус не «пинится» жёстко, а влетает к центру пружиной (упругая стабилизация).
+  // Периферия держится радиальной пружиной на орбите и расталкивается силой charge —
+  // получается органичная плавающая структура, а не жёсткий круг.
+  function stepPhysics() {
+    let totalV = 0;
+    for (const n of nodes) {
+      if (n.hidden) { n.vx = 0; n.vy = 0; continue; } // скрытые фильтром узлы физика не двигает
+      if (n.tier >= 2) { n.vx = 0; n.vy = 0; continue; } // глубокие уровни — раскладывает layoutDeep
+      let ax = 0;
+      let ay = 0;
+
+      if (n.isFocus) {
+        // пружина к центру: быстрый влёт + лёгкий отскок (фокус сам не отталкивается)
+        ax += K_FOCUS * (0 - n.x);
+        ay += K_FOCUS * (0 - n.y);
+      } else {
+        // радиальная пружина к целевому радиусу орбиты
+        const d = Math.hypot(n.x, n.y) || 0.001;
+        const ux = n.x / d;
+        const uy = n.y / d;
+        const fr = K_RADIAL * (n.targetR - d);
+        ax += fr * ux;
+        ay += fr * uy;
+        // отталкивание от всех остальных видимых узлов (включая фокус — чтобы не залипали в центре);
+        // глубокие уровни (tier≥2) в отталкивании не участвуют (их много — берегём перф)
+        for (const m of nodes) {
+          if (m === n || m.hidden || m.tier >= 2) continue;
+          const dx = n.x - m.x;
+          const dy = n.y - m.y;
+          let dist2 = dx * dx + dy * dy;
+          if (dist2 < MIN_DIST * MIN_DIST) dist2 = MIN_DIST * MIN_DIST;
+          const dist = Math.sqrt(dist2);
+          // адаптивное расталкивание (collision): раскрытая ветка «толще» — усиливаем отталкивание
+          // пропорционально прогрессу раскрытия любого из пары, чтобы кластеры разъезжались как магниты.
+          const ex = Math.max(n.expandP || 0, m.expandP || 0);
+          const f = chargeNow * (1 + (EXPAND_REPULSION - 1) * ex) / dist2;
+          ax += (dx / dist) * f;
+          ay += (dy / dist) * f;
+        }
+      }
+
+      n.vx = (n.vx + ax) * frictionNow;
+      n.vy = (n.vy + ay) * frictionNow;
+      n.x += n.vx;
+      n.y += n.vy;
+      totalV += Math.abs(n.vx) + Math.abs(n.vy);
+    }
+    return totalV;
+  }
+
+  // Плавное приближение масштаба/прозрачности к целям + рост линии + spotlight + глубина (dive).
+  function advanceVisual() {
+    spotActive = nodes.some((n) => n.pinned); // есть закреплённая ветка → остальные тускнеют
+    for (const n of nodes) {
+      n.scale += (n.targetScale - n.scale) * 0.2;
+      n.opacity += (n.targetOpacity - n.opacity) * 0.2;
+      const c = contextTargetOf(n);                    // {op, scale, blur} — spotlight или глубина dive
+      n.spotCur += (c.op - n.spotCur) * 0.2;           // затемнение/прояснение
+      n.depthScale += (c.scale - n.depthScale) * 0.2;  // dive: цель крупно / фон мелко
+      n.depthBlur += (c.blur - n.depthBlur) * 0.2;     // dive: фон уходит в расфокус
+      // линия растёт только когда узел уже «выпущен» из центра (не скрыт) — догоняет его как нить
+      if (!n.hidden && n.edgeGrow < 1) n.edgeGrow = Math.min(1, n.edgeGrow + 0.08);
+    }
+  }
+
+  // Не «успокоились» ли ещё визуальные параметры/рост линий/глубина (для условия заморозки).
+  function visualSettling() {
+    for (const n of nodes) {
+      const c = contextTargetOf(n);
+      if (Math.abs(n.scale - n.targetScale) > 0.01 || Math.abs(n.opacity - n.targetOpacity) > 0.01
+        || Math.abs(n.spotCur - c.op) > 0.01 || Math.abs(n.depthScale - c.scale) > 0.01
+        || Math.abs(n.depthBlur - c.blur) > 0.4 || n.edgeGrow < 1) return true;
+    }
+    return false;
+  }
+
+  // --- Твин центрирования -----------------------------------------------------
+  function startRecenterTween(newFocusId) {
+    const target = nodes.find((n) => String(n.id) === String(newFocusId));
+    if (!target || target.isFocus) return;
+
+    focusId = String(newFocusId);
+    // пересчёт ролей: новый фокус — в центр, остальные — на орбиту (включая старый фокус)
+    const peers = nodes.filter((n) => String(n.id) !== focusId);
+    const from = new Map();
+    const to = new Map();
+    nodes.forEach((n) => from.set(n.id, { x: n.x, y: n.y, scale: n.scale }));
+
+    nodes.forEach((n) => {
+      n.isFocus = String(n.id) === focusId;
+      n.el.classList.toggle('is-focus', n.isFocus);
+    });
+
+    target.targetR = 0;
+    target.tx = 0;
+    target.ty = 0;
+    target.vx = 0;
+    target.vy = 0;
+    to.set(target.id, { x: 0, y: 0, scale: FOCUS_SCALE });
+
+    peers.forEach((n, i) => {
+      n.targetR = ORBIT_MIN + (1 - n.strength) * (ORBIT_MAX - ORBIT_MIN);
+      n.angle = spreadAngle(i, peers.length);
+      n.vx = 0;
+      n.vy = 0;
+      const tx = Math.cos(n.angle) * n.targetR;
+      const ty = Math.sin(n.angle) * n.targetR;
+      n.tx = tx;             // обновляем целевую точку, иначе физика после твина утянет узел назад
+      n.ty = ty;
+      const sc = n.tier >= 2 ? SECONDARY_SCALE : PRIMARY_SCALE;
+      to.set(n.id, { x: tx, y: ty, scale: sc });
+    });
+
+    tween = {
+      startTs: 0,
+      from,
+      to,
+      camFrom: { x: camX, y: camY },
+      camTo: { x: 0, y: 0 },
+    };
+    wake();
+  }
+
+  // Универсальный твин (физика выключена → ноль тряски). Поддерживает длительность, кривую и
+  // поканальную задержку (каскад) + рост линий. Используется для bloom-разлёта, фильтра, центрирования.
+  function stepTween(ts) {
+    if (!tween.startTs) tween.startTs = ts;
+    const dur = tween.dur || TWEEN_MS;
+    const ease = tween.ease || easeOutCubic;
+    const elapsed = ts - tween.startTs;
+    let allDone = true;
+    for (const n of nodes) {
+      const a = tween.from.get(n.id);
+      const b = tween.to.get(n.id);
+      if (!a || !b) continue;
+      let raw = (elapsed - (a.delay || 0)) / dur;
+      if (raw < 0) raw = 0;        // узел ещё не «выпущен» — держим в стартовой точке
+      if (raw < 1) allDone = false;
+      raw = Math.min(1, raw);
+      const t = ease(raw);
+      n.x = a.x + (b.x - a.x) * t;
+      n.y = a.y + (b.y - a.y) * t;
+      n.scale = a.scale + (b.scale - a.scale) * t;
+      const ao = a.opacity ?? 1;
+      const bo = b.opacity ?? 1;
+      n.opacity = ao + (bo - ao) * t;
+      if (b.grow) n.edgeGrow = raw; // линия «вытекает» по прогрессу своего узла
+    }
+    const camT = ease(Math.min(1, elapsed / dur));
+    camX = tween.camFrom.x + (tween.camTo.x - tween.camFrom.x) * camT;
+    camY = tween.camFrom.y + (tween.camTo.y - tween.camFrom.y) * camT;
+    applyWorldTransform();
+    if (allDone) {
+      const wasBloom = tween.idleBoost;
+      tween = null; // твин завершён
+      for (const n of nodes) { n.targetScale = n.scale; n.targetOpacity = n.opacity; n.edgeGrow = 1; }
+      if (wasBloom) boost = 1; // в покое — лёгкое «гель»-демпфированное упругое покачивание
+    }
+  }
+
+  // Прерывание твина жестом (требование «конфликт жестов»): фиксируем текущие позиции и отдаём пальцу.
+  function cancelTween() {
+    if (!tween) return;
+    tween = null;
+    for (const n of nodes) { n.vx = 0; n.vy = 0; }
+  }
+
+  // Фильтр слоёв: pred(node) → показывать ли узел. Фокус всегда виден.
+  // Перестроение идёт нативными CSS-переходами (компоновщик): работает даже когда rAF-цикл
+  // троттлится в простое (иначе граф «не перестраивался» бы). Скрытые узлы плавно гаснут НА МЕСТЕ
+  // (scale 0.8 + opacity 0 за 300мс), видимые плавно переплывают на равномерные углы орбиты;
+  // лучи скрываемых гаснут вместе с ними (renderEdges читает живую прозрачность из DOM).
+  // По завершении — жёсткая фиксация на этих углах БЕЗ физики (ноль тряски, идеальный sleep).
+  function setFilter(predicate) {
+    const pred = typeof predicate === 'function' ? predicate : () => true;
+    if (cssBloomTimer) { window.clearTimeout(cssBloomTimer); cssBloomTimer = 0; }
+    cancelTween(); // на случай активного JS-твина центрирования — отдаём управление CSS-переходу
+
+    const visiblePeers = [];
+    nodes.forEach((n) => {
+      if (n.isFocus) { n.hidden = false; return; }
+      n.hidden = !pred(n);
+      n.vx = 0;
+      n.vy = 0;
+      if (!n.hidden) visiblePeers.push(n);
+    });
+
+    const FILTER_MS = 300;
+    const tf = (x, y, s) => `translate(calc(${x.toFixed(1)}px - 50%), calc(${y.toFixed(1)}px - 50%)) scale(${s})`;
+    // применяем целевое состояние как CSS-переход; финал кэшируем в bfx/bfy/bfs/bfo для endCssBloom
+    const apply = (n, x, y, s, o) => {
+      n.bfx = x; n.bfy = y; n.bfs = s; n.bfo = o;
+      n.el.style.transition = `transform ${FILTER_MS}ms cubic-bezier(0.22, 1, 0.36, 1), opacity ${FILTER_MS}ms ease`;
+      n.el.style.transform = tf(x, y, s);
+      n.el.style.opacity = String(o);
+      n.el.style.pointerEvents = o <= 0.01 ? 'none' : '';
+    };
+
+    const focus = nodes.find((n) => n.isFocus);
+    if (focus) apply(focus, 0, 0, FOCUS_SCALE, 1);
+
+    visiblePeers.forEach((n, i) => {
+      n.targetR = ORBIT_MIN + (1 - n.strength) * (ORBIT_MAX - ORBIT_MIN);
+      n.angle = spreadAngle(i, visiblePeers.length);
+      n.tx = Math.cos(n.angle) * n.targetR;
+      n.ty = Math.sin(n.angle) * n.targetR;
+      const sc = n.tier >= 2 ? SECONDARY_SCALE : PRIMARY_SCALE;
+      apply(n, n.tx, n.ty, sc, 1);
+    });
+
+    nodes.forEach((n) => {
+      if (n.isFocus || !n.hidden) return;
+      // скрытые: растворяются ПРЯМО НА МЕСТЕ (scale 0.8 + opacity 0 за 300мс) — мягкий фейд, без «вылетов»
+      apply(n, n.x, n.y, 0.8, 0);
+    });
+
+    // режим CSS-перехода: цикл лишь ведёт лучи за узлами; по таймеру — фиксация без физики
+    cssBloom = true;
+    cssBloomKind = 'filter';
+    renderEdges();
+    cssBloomTimer = window.setTimeout(endCssBloom, FILTER_MS + 60);
+    wake();
+  }
+
+  // Жёсткая заморозка: гасим скорости, округляем координаты до целых пикселей,
+  // НЕ перезапускаем цикл — граф замирает намертво (без «треска»).
+  function freezeGraph() {
+    for (const n of nodes) {
+      n.vx = 0;
+      n.vy = 0;
+      n.x = Math.round(n.x);
+      n.y = Math.round(n.y);
+      n.scale = n.targetScale;
+      n.opacity = n.targetOpacity;
+    }
+    panBendX = 0; panBendY = 0; // нити в покое — ровные базовые дуги
+    layoutDeep(); // глубокие уровни — на орбитах родителей перед финальным кадром
+    renderAll(); // финальный кадр на целых координатах
+  }
+
+  // --- Цикл с kill-switch + инерция + заморозка ------------------------------
+  function tick(ts) {
+    rafId = 0;
+
+    // режим CSS-bloom: узлы 1-го уровня анимирует компоновщик — мы лишь ведём лучи за ними (без физики);
+    // глубокие уровни (tier≥2) не в CSS-bloom — позиционируем их из JS, чтобы следовали за родителями
+    if (cssBloom) {
+      syncPositionsFromDOM();
+      advanceExpand();
+      layoutDeep();
+      renderDeepNodes();
+      renderEdges();
+      schedule();
+      return;
+    }
+
+    // инерция панорамирования (kinematic): камера докатывается с трением
+    const panActive = !dragging && (Math.abs(panVelX) > 0.15 || Math.abs(panVelY) > 0.15);
+    if (panActive) {
+      camX += panVelX;
+      camY += panVelY;
+      panVelX *= PAN_FRICTION;
+      panVelY *= PAN_FRICTION;
+      applyWorldTransform();
+    } else if (dragging) {
+      // палец удерживается без движения → скорость (и изгиб нитей) мягко расслабляется,
+      // но onPointerMove перезапишет её свежим дельтой при следующем движении
+      panVelX *= 0.7;
+      panVelY *= 0.7;
+    } else {
+      panVelX = 0;
+      panVelY = 0;
+    }
+    advancePanBend(); // сглаженный изгиб нитей догоняет скорость пальца и пружинит к нулю
+    // «гитарная струна»: один короткий вибро-щелчок при сильном натяжении нитей свайпом
+    const pbMag = Math.abs(panBendX) + Math.abs(panBendY);
+    if (pbMag > 26 && !panTwang) { panTwang = true; haptic(4); }
+    else if (pbMag < 12) panTwang = false;
+
+    // камера-доводчик: плавно дотягиваем камеру к цели (после раскрытия ветки). Жест уже обнулил цель.
+    let camGliding = false;
+    if (camTargetX !== null && !dragging && !panActive) {
+      camX += (camTargetX - camX) * CAM_GLIDE_K;
+      camY += (camTargetY - camY) * CAM_GLIDE_K;
+      if (Math.abs(camTargetX - camX) < 0.5 && Math.abs(camTargetY - camY) < 0.5) {
+        camX = camTargetX; camY = camTargetY; camTargetX = null; camTargetY = null;
+      } else { camGliding = true; }
+      applyWorldTransform();
+    }
+
+    // Smart Zoom: dive-камера летит и зумит к нырнутому узлу (аквариумный наезд), центрируя его;
+    // всплытие (surfacing) — плавный возврат камеры/зума к корню. Любой жест (drag/pan/pinch) приостанавливает.
+    let diveCamActive = false;
+    if (!dragging && !panActive && !pinching) {
+      if (diveTargetId) {
+        const t = nodeById.get(diveTargetId);
+        if (t) {
+          zoom += (diveZoom - zoom) * DIVE_FLY_K;
+          const desX = -t.x * zoom; // узел → центр экрана (screen = center + cam + x*zoom = center)
+          const desY = -t.y * zoom;
+          camX += (desX - camX) * DIVE_FLY_K;
+          camY += (desY - camY) * DIVE_FLY_K;
+          applyWorldTransform();
+          if (Math.abs(zoom - diveZoom) > 0.004 || Math.abs(desX - camX) > 0.4 || Math.abs(desY - camY) > 0.4) diveCamActive = true;
+        }
+      } else if (surfacing) {
+        zoom += (1 - zoom) * DIVE_FLY_K;
+        camX += (0 - camX) * DIVE_FLY_K;
+        camY += (0 - camY) * DIVE_FLY_K;
+        applyWorldTransform();
+        if (Math.abs(zoom - 1) < 0.004 && Math.abs(camX) < 0.4 && Math.abs(camY) < 0.4) { zoom = 1; camX = 0; camY = 0; surfacing = false; }
+        else diveCamActive = true;
+      }
+    }
+    updateLod(); // LOD: точки 3-го уровня ↔ аватарки по текущему зуму
+
+    // динамическая вязкость: первые ~700мс после перестроения трение завышено (0.94→0.80),
+    // отталкивание ослаблено — гасим «взрыв» из центра, узлы выходят на орбиту в «геле»
+    frictionNow = FRICTION + boost * (FRICTION_BOOST - FRICTION);
+    chargeNow = CHARGE * (1 - (1 - CHARGE_START_FACTOR) * boost);
+    if (boost > 0) boost = Math.max(0, boost - 1 / BOOST_FRAMES);
+
+    let totalV = 0;
+    if (tween) {
+      stepTween(ts);
+    } else {
+      totalV = stepPhysics();
+      advanceVisual(); // bloom/смена роли вне твина — через целевые scale/opacity
+    }
+
+    const expanding = advanceExpand(); // раскрытие/схлопывание глубоких уровней (по клику/ховеру)
+    layoutDeep(); // глубокие уровни следуют за родителями (после шага физики 1-го уровня)
+    renderAll();
+
+    const bendSettling = Math.abs(panBendX) + Math.abs(panBendY) > 0.2; // ждём, пока нити спружинят назад
+    if (tween || dragging || panActive || camGliding || diveCamActive || boost > 0 || totalV > SLEEP_V || bendSettling || expanding || visualSettling()) {
+      schedule();
+    } else {
+      freezeGraph(); // система успокоилась — замираем
+    }
+  }
+
+  function schedule() {
+    if (!rafId) rafId = requestAnimationFrame(tick);
+  }
+
+  function wake() {
+    schedule();
+  }
+
+  // --- Жесты (pan / tap / longpress) -----------------------------------------
+  let pointerId = null;
+  let downX = 0;
+  let downY = 0;
+  let camStartX = 0;
+  let camStartY = 0;
+  let moved = false;
+  let downNodeEl = null;
+  let longTimer = 0;
+  let longFired = false;
+  const activePointers = new Map(); // id → {x, y}: для щипкового зума двумя пальцами
+  let pinching = false;             // активен щипок (pan/tap на это время заморожены)
+  let pinchDist0 = 0;               // базовая дистанция между пальцами (px) для расчёта масштаба
+  let hoverNode = null;             // узел под курсором мыши (для ховер-раскрытия ветки)
+  let lastBgTapTs = 0;              // время последнего тапа по пустому фону (для двойного тапа = сброс)
+  // Виброотклик (мобильные): не критичен — на десктопе navigator.vibrate просто отсутствует.
+  const haptic = (pattern) => { try { if (navigator.vibrate) navigator.vibrate(pattern); } catch { /* нет API */ } };
+
+  // Префетч аватарок детей при наведении/нырке — чтобы при раскрытии лица уже были в кэше браузера.
+  const prefetched = new Set();
+  function prefetchChildren(node) {
+    if (!node) return;
+    const pid = String(node.id);
+    for (const m of nodes) {
+      if (String(m.parentId) === pid && m.photo && !prefetched.has(m.photo)) {
+        prefetched.add(m.photo);
+        try { const im = new Image(); im.decoding = 'async'; im.src = m.photo; } catch { /* нет Image — не критично */ }
+      }
+    }
+  }
+
+  // Режим «Интерактивная паутина» (раскрытие веток НА МЕСТЕ, без смены центра; анимация expandP, см.
+  // advanceExpand/layoutDeep). Состояние раскрытия = pinned (клик) ИЛИ hovered (наведение).
+  // Тап/клик по узлу — ФИКСИРУЕТ раскрытие ветки (pinned). Повторный тап снимает фиксацию. Ветка остаётся
+  // раскрытой, даже когда убрали палец/мышь (в отличие от ховера). + камера-доводчик подводит кластер в кадр.
+  function toggleExpand(node) {
+    const n = node && (nodeById.get(String(node.id)) || node);
+    if (!n) return;
+    // надёжный toggle: клик по УЖЕ раскрытому узлу сворачивает его (даже если он был раскрыт ховером).
+    const isOpen = n.pinned || (n.expandP || 0) > 0.5;
+    if (isOpen) {
+      n.pinned = false; n.hovered = false;       // свернуть полностью
+      haptic(8);
+    } else {
+      n.pinned = true; haptic([10, 25, 6, 35, 3]); glideCameraTo(n); // раскрыть + дотяжка камеры
+    }
+    wake();
+  }
+  // Ховер (наведение мышью / касание пальцем) — ВРЕМЕННОЕ раскрытие: ветка выплывает, пока курсор/палец
+  // над узлом, и втягивается при уходе (если узел не закреплён кликом). node=null — снять ховер со всех.
+  function setHover(node) {
+    const target = node && (nodeById.get(String(node.id)) || node);
+    let changed = false;
+    for (const n of nodes) {
+      const want = n === target;
+      if (Boolean(n.hovered) !== want) { n.hovered = want; changed = true; }
+    }
+    if (target) prefetchChildren(target); // подгружаем лица детей заранее (до клика)
+    if (changed) wake();
+  }
+  // Глобальный сброс: снимаем фиксацию И ховер со ВСЕХ веток + всплываем из погружения (тап по Ивану).
+  function collapseAll() {
+    let any = false;
+    for (const n of nodes) { if (n.pinned || n.hovered) { n.pinned = false; n.hovered = false; any = true; } }
+    if (diveTargetId) { diveTargetId = null; surfacing = true; any = true; } // всплыть наверх
+    if (any) haptic(14);
+    emitDiveChange(); // крошки → верхний уровень
+    wake();
+  }
+
+  // Умный фокус (Smart Zoom): погружение в узел 2-го+ уровня. Камера летит/зумит к нему (в tick),
+  // узел вырастает в центр, путь назад к Ивану остаётся ярким, фон уходит в расфокус (см. contextTargetOf).
+  function diveTo(node) {
+    const n = node && (nodeById.get(String(node.id)) || node);
+    if (!n || n.isFocus) return;                          // в сам фокус (Иван) не ныряем
+    if (diveTargetId === String(n.id)) { exitDive(); return; } // повтор по цели — всплыть назад (полный сброс)
+    // ЕДИНЫЙ активный путь (железный spotlight): гасим ВСЕ прежние фиксации/ховеры, затем раскрываем
+    // только путь к новой цели (предки до Ивана) — чтобы цель и её дети были видимы, прочее не «копилось».
+    for (const m of nodes) { m.pinned = false; m.hovered = false; }
+    let cur = n; let guard = 0;
+    while (cur && guard++ < 16) { if (!cur.isFocus) cur.pinned = true; if (cur.isFocus) break; const p = nodeById.get(cur.parentId); if (!p) break; cur = p; }
+    diveTargetId = String(n.id);
+    diveZoom = DIVE_ZOOM;
+    surfacing = false;
+    camTargetX = null; camTargetY = null;                 // dive-камера центрирует сама
+    prefetchChildren(n);                                  // подгружаем лица детей заранее
+    haptic([12, 30, 8, 40]);                              // «погружение» — нарастающий импульс
+    emitDiveChange();                                     // обновляем хлебные крошки (Иван › … › цель)
+    wake();
+  }
+  // Всплытие/закрытие ветки: ПОЛНЫЙ сброс — снимаем все фиксации/ховеры (дети втягиваются),
+  // камера и зум плавно возвращаются на весь граф, ВСЕ узлы гарантированно вернут opacity 1.
+  function exitDive() {
+    for (const m of nodes) { m.pinned = false; m.hovered = false; }
+    diveTargetId = null;
+    surfacing = true;
+    haptic(10);
+    emitDiveChange();                                     // крошки → верхний уровень
+    wake();
+  }
+
+  function nodeFromEvent(ev) {
+    const el = ev.target instanceof Element ? ev.target.closest('.fg-node') : null;
+    if (!el) return null;
+    const id = el.dataset.nodeId;
+    return nodes.find((n) => String(n.id) === String(id)) || null;
+  }
+
+  function onPointerDown(ev) {
+    activePointers.set(ev.pointerId, { x: ev.clientX, y: ev.clientY });
+    // второй палец → режим щипкового зума: прерываем pan/tap/longpress, фиксируем базовую дистанцию
+    if (activePointers.size === 2) {
+      pinching = true;
+      camTargetX = null; camTargetY = null;
+      if (longTimer) { window.clearTimeout(longTimer); longTimer = 0; }
+      if (downNodeEl) { downNodeEl.classList.remove('is-pressed'); }
+      dragging = false;
+      const pts = [...activePointers.values()];
+      pinchDist0 = Math.hypot(pts[0].x - pts[1].x, pts[0].y - pts[1].y) || 1;
+      return;
+    }
+    if (pointerId !== null) return;
+    pointerId = ev.pointerId;
+    panVelX = 0; // новое касание мгновенно прерывает инерцию
+    panVelY = 0;
+    camTargetX = null; camTargetY = null; // касание отменяет доводчик камеры
+    try { stage.setPointerCapture(ev.pointerId); } catch { /* pointer уже неактивен — не критично */ }
+    downX = ev.clientX;
+    downY = ev.clientY;
+    camStartX = camX;
+    camStartY = camY;
+    moved = false;
+    longFired = false;
+    downNodeEl = ev.target instanceof Element ? ev.target.closest('.fg-node') : null;
+    if (downNodeEl) { downNodeEl.classList.add('is-pressed'); haptic(6); } // тактильный «клик» вдавливания
+    const downNode = nodeFromEvent(ev);
+    // касание пальцем по узлу = «наведение» (превью ветки), как ховер мышью; мышь обслуживают over/out
+    if (downNode && ev.pointerType !== 'mouse' && typeof onNodeHover === 'function') onNodeHover(downNode, true);
+    if (downNode && typeof onNodeLongPress === 'function') {
+      longTimer = window.setTimeout(() => {
+        if (moved) return;
+        longFired = true;
+        const rect = downNode.el.getBoundingClientRect();
+        // координаты для меню берём из экранного rect узла (меню рендерится вне масштабируемого мира)
+        onNodeLongPress(downNode, { x: rect.left + rect.width / 2, y: rect.top, rect });
+      }, LONGPRESS_MS);
+    }
+  }
+
+  // Ховер мышью: наведение на узел → превью ветки; уход с узла → сворачивание (если не закреплён кликом).
+  function onPointerOver(ev) {
+    if (ev.pointerType !== 'mouse' || typeof onNodeHover !== 'function') return;
+    const el = ev.target instanceof Element ? ev.target.closest('.fg-node') : null;
+    const node = el ? nodes.find((n) => String(n.id) === String(el.dataset.nodeId)) : null;
+    if (node && node !== hoverNode) { hoverNode = node; onNodeHover(node, true); }
+  }
+  function onPointerOut(ev) {
+    if (ev.pointerType !== 'mouse' || typeof onNodeHover !== 'function') return;
+    const toEl = ev.relatedTarget instanceof Element ? ev.relatedTarget.closest('.fg-node') : null;
+    if (toEl && hoverNode && String(toEl.dataset.nodeId) === String(hoverNode.id)) return; // ещё внутри узла
+    if (hoverNode) { hoverNode = null; onNodeHover(null, false); }
+  }
+
+  function onPointerMove(ev) {
+    if (activePointers.has(ev.pointerId)) activePointers.set(ev.pointerId, { x: ev.clientX, y: ev.clientY });
+    // щипок двумя пальцами: масштабируем относительно центра между пальцами (зум «к точке»)
+    if (pinching && activePointers.size >= 2) {
+      const pts = [...activePointers.values()];
+      const dist = Math.hypot(pts[0].x - pts[1].x, pts[0].y - pts[1].y) || 1;
+      const rect = stage.getBoundingClientRect();
+      const mx = (pts[0].x + pts[1].x) / 2 - rect.left;
+      const my = (pts[0].y + pts[1].y) / 2 - rect.top;
+      const prevDist = pinchDist0;
+      setZoom(zoom * (dist / pinchDist0), mx, my);
+      pinchDist0 = dist;
+      // сильный pinch-out (пальцы сходятся) на минимальном зуме во время погружения = всплыть назад
+      if (diveTargetId && dist < prevDist && zoom <= ZOOM_MIN + 0.02) exitDive();
+      wake();
+      return;
+    }
+    if (ev.pointerId !== pointerId) return;
+    const dx = ev.clientX - downX;
+    const dy = ev.clientY - downY;
+    if (!moved && Math.hypot(dx, dy) > PAN_THRESHOLD) {
+      moved = true;
+      if (longTimer) { window.clearTimeout(longTimer); longTimer = 0; }
+      if (downNodeEl) downNodeEl.classList.remove('is-pressed'); // это свайп, а не нажатие
+      // палец «съехал» с узла — снимаем временный ховер-превью (касанием), если он был
+      if (ev.pointerType !== 'mouse' && typeof onNodeHover === 'function') onNodeHover(null, false);
+      camTargetX = null; camTargetY = null; // свайп отменяет доводчик камеры (приоритет жеста)
+      cancelTween();          // жест прерывает анимацию центрирования
+      dragging = true;
+    }
+    if (moved) {
+      const newCamX = camStartX + dx;
+      const newCamY = camStartY + dy;
+      panVelX = newCamX - camX;  // мгновенная скорость свайпа (для инерции после отпускания)
+      panVelY = newCamY - camY;
+      camX = newCamX;
+      camY = newCamY;
+      applyWorldTransform();
+      advancePanBend();       // упругий изгиб нитей догоняет палец во время свайпа
+      renderEdges();          // рёбра следуют за камерой синхронно (дёшево)
+    }
+  }
+
+  function onPointerUp(ev) {
+    activePointers.delete(ev.pointerId);
+    // выход из щипка: пока пальцев <2 — щипок завершён; остаток НЕ превращаем в pan/tap (избегаем рывка)
+    if (pinching) {
+      if (activePointers.size < 2) { pinching = false; pinchDist0 = 0; }
+      if (ev.pointerId === pointerId) { pointerId = null; dragging = false; }
+      return;
+    }
+    if (ev.pointerId !== pointerId) return;
+    if (longTimer) { window.clearTimeout(longTimer); longTimer = 0; }
+    if (downNodeEl) downNodeEl.classList.remove('is-pressed'); // отпустили — «кнопка» возвращается
+    try { stage.releasePointerCapture(ev.pointerId); } catch { /* не было захвата — ок */ }
+    const wasMoved = moved;
+    const wasLong = longFired;
+    pointerId = null;
+    dragging = false;
+    // касание: убрали палец — снимаем временный ховер-превью (фиксацию ниже делает тап через onNodeTap)
+    if (ev.pointerType !== 'mouse' && typeof onNodeHover === 'function') onNodeHover(null, false);
+
+    if (wasMoved || wasLong) {
+      // после pan даём физике чуть устаканиться и уснуть
+      if (wasMoved) wake();
+      return;
+    }
+    // это был тап
+    const tapNode = downNodeEl
+      ? nodes.find((n) => String(n.id) === String(downNodeEl.dataset.nodeId))
+      : null;
+    if (!tapNode) {
+      // тап по пустому фону: двойной быстрый тап = сброс погружения/раскрытия (всплыть на весь граф)
+      const now = (typeof performance !== 'undefined' && performance.now) ? performance.now() : 0;
+      if (now && now - lastBgTapTs < DOUBLE_TAP_MS) { lastBgTapTs = 0; if (diveTargetId || spotActive) collapseAll(); }
+      else lastBgTapTs = now;
+      return;
+    }
+    if (tapNode.isFocus) {
+      if (typeof onCenterTap === 'function') onCenterTap(tapNode);
+      return;
+    }
+    if (typeof onNodeTap === 'function') {
+      // запоминаем точку, из которой новый фокус влетит в центр; перестройку делает onNodeTap (setModel)
+      pendingFocusOrigin = { id: String(tapNode.id), x: tapNode.x, y: tapNode.y };
+      onNodeTap(tapNode);
+    } else {
+      // нет внешнего обработчика — внутреннее перецентрирование (фолбэк)
+      startRecenterTween(tapNode.id);
+    }
+  }
+
+  function onResize() {
+    viewW = stage.clientWidth || window.innerWidth;
+    viewH = stage.clientHeight || window.innerHeight;
+    centerX = viewW / 2;
+    centerY = viewH / 2;
+    renderEdges();
+  }
+
+  // --- Жизненный цикл узлов (diffing) ----------------------------------------
+  // Ghost-слой = СНИМОК старых АВАТАРОК (без линий!) на полноэкранном слое. Линии в шлейф НЕ
+  // копируем намеренно: старые связи должны исчезать мгновенно вместе с перерисовкой графа, а не
+  // висеть «ошмётками» секунду. Клон застывает на месте и лениво тает (scale 1→0.7 + opacity→0)
+  // за 1000мс — мягкий породистый шлейф истории, — затем удаляется из DOM (строго через 1000мс).
+  function spawnGhost() {
+    if (!world.childElementCount) return;
+    const ghost = document.createElement('div');
+    ghost.className = 'fg-ghost-layer';
+    const worldClone = world.cloneNode(true);      // .fg-world (центр) → только узлы на своих местах
+    worldClone.style.transform = world.style.transform || '';
+    ghost.append(worldClone);
+    stage.insertBefore(ghost, edgesSvg);           // позади живых слоёв
+    void ghost.offsetWidth;                        // рефлоу для запуска CSS-перехода
+    ghost.style.transform = 'scale(0.7)';
+    ghost.style.opacity = '0';
+    window.setTimeout(() => ghost.remove(), 1000); // удаление строго через 1000мс
+  }
+
+  // Во время CSS-bloom узлы двигает компоновщик — читаем их фактические позиции из DOM,
+  // чтобы лучи (рисуются в JS) точно следовали за анимируемыми аватарками.
+  function syncPositionsFromDOM() {
+    const sr = stage.getBoundingClientRect();
+    for (const n of nodes) {
+      const dot = n.el.querySelector('.node-dot') || n.el;
+      const r = dot.getBoundingClientRect();
+      n.x = ((r.left + r.width / 2) - sr.left - centerX - camX) / zoom;
+      n.y = ((r.top + r.height / 2) - sr.top - centerY - camY) / zoom;
+      // живая прозрачность из CSS-перехода — чтобы лучи гасли/проявлялись вместе с аватаркой
+      const o = parseFloat(getComputedStyle(n.el).opacity);
+      if (Number.isFinite(o)) n.opacity = o;
+    }
+  }
+
+  // Завершение CSS-bloom (по таймеру — гарантированно, даже при троттлинге rAF):
+  // снимаем переходы, ставим узлы в финал и включаем лёгкую физику покачивания в покое.
+  function endCssBloom() {
+    cssBloomTimer = 0;
+    if (!cssBloom) return;
+    cssBloom = false;
+    for (const n of nodes) {
+      n.el.style.transition = '';
+      const fo = (typeof n.bfo === 'number') ? n.bfo : 1; // финальная прозрачность (0 — скрыт фильтром)
+      n.x = n.bfx; n.y = n.bfy;
+      n.scale = n.bfs; n.targetScale = n.bfs; n.opacity = fo; n.targetOpacity = fo;
+      n.vx = 0; n.vy = 0; n.edgeGrow = 1;
+    }
+    layoutDeep(); // глубокие уровни ставим на орбиты родителей (их bfx — орбита центра, не годится)
+    if (cssBloomKind === 'filter') {
+      // ФИЛЬТР: узлы уже стоят на равномерных углах (их поставил CSS-переход) — фиксируемся
+      // строго на этих позициях БЕЗ физики: ноль тряски и идеальный мгновенный sleep.
+      if (rafId) { cancelAnimationFrame(rafId); rafId = 0; }
+      freezeGraph();
+      return;
+    }
+    boost = 1;          // BLOOM: мягкое «гель»-демпфированное упругое покачивание в покое (0.94→0.80)
+    renderNodes();
+    renderEdges();
+    wake();
+  }
+
+  // Перестроение графа с НЕПРЕРЫВНОСТЬЮ состояний:
+  //  • общий узел (тот же id) — не пересоздаём, плавно перелетает на новое место (роль/орбита);
+  //  • новый узел — «расцветает» (bloom) из позиции нового фокуса (scale 0→1, opacity 0→1);
+  //  • исчезнувший — уходит призраком в глубину и удаляется.
+  function setModel(nextModel) {
+    const { focusId: newFocusId, specs } = computeSpecs(nextModel);
+    const newIds = new Set(specs.map((s) => s.id));
+    const oldById = new Map(nodes.map((n) => [String(n.id), n]));
+
+    // старый узел нового фокуса (если был) — фокус глайдит из его позиции
+    const focusOld = oldById.get(String(newFocusId));
+
+    // снимок всего старого графа → красивый шлейф; затем убираем «ушедшие» узлы из живого мира
+    spawnGhost();
+    nodes.forEach((n) => { if (!newIds.has(String(n.id))) n.el.remove(); });
+
+    focusId = String(newFocusId);
+    if (cssBloomTimer) { window.clearTimeout(cssBloomTimer); cssBloomTimer = 0; }
+
+    const tf = (x, y, s) => `translate(calc(${x.toFixed(1)}px - 50%), calc(${y.toFixed(1)}px - 50%)) scale(${s})`;
+    let order = 0;
+    let maxDelay = 0;
+    const blooms = [];
+
+    nodes = specs.map((spec) => {
+      const oldNode = oldById.get(spec.id);
+      let node;
+      let isNew;
+      if (oldNode && oldNode.dotOnly === spec.dotOnly) {
+        updateNodeRole(oldNode, spec); // непрерывность: тот же DOM, новая роль/орбита
+        node = oldNode; isNew = false;
+      } else {
+        if (oldNode) oldNode.el.remove(); // сменился тип (точка↔аватар) — заменяем элемент
+        node = makeNodeState(spec.src, spec.isFocus, spec.index, spec.total, spec.dotOnly);
+        isNew = true;
+      }
+
+      // финальные координаты разлёта (детерминированная орбита с джиттером — в node.tx/ty)
+      const finalX = node.isFocus ? 0 : node.tx;
+      const finalY = node.isFocus ? 0 : node.ty;
+      const finalScale = node.targetScale; // масштаб уже по уровню (focus / tier-1 / tier-2 0.5 / tier-3 точка)
+      const finalOp = node.targetOpacity;  // прозрачность по уровню (tier-2 ~0.4, tier-3 ~0.9, иначе 1)
+
+      // стартовая точка разлёта
+      let fx; let fy; let fs; let fo; let delay = 0;
+      if (node.isFocus) {
+        if (focusOld) { fx = focusOld.x; fy = focusOld.y; fs = focusOld.scale; fo = 1; }            // глайд из старой позиции
+        else if (pendingFocusOrigin && String(pendingFocusOrigin.id) === focusId) {
+          fx = pendingFocusOrigin.x; fy = pendingFocusOrigin.y; fs = 0.6; fo = 1;                    // влёт из точки клика
+        } else { fx = 0; fy = 0; fs = 0.3; fo = 0; }                                                // первичная инициализация
+      } else if (isNew) {
+        fx = Math.cos(node.angle) * 12; fy = Math.sin(node.angle) * 12; fs = 0.2; fo = 0;           // из центрального круга
+        order += 1; delay = order * BLOOM_STAGGER;                                                  // каскад (волна)
+      } else {
+        fx = node.x; fy = node.y; fs = node.scale; fo = node.opacity;                               // непрерывность: с текущего места
+      }
+
+      // финал запоминаем для покоя; стартовое состояние держим в n.x/n.y (для первой отрисовки лучей)
+      node.bfx = finalX; node.bfy = finalY; node.bfs = finalScale; node.bfo = finalOp;
+      node.x = fx; node.y = fy;
+      node.scale = finalScale; node.opacity = finalOp; node.targetScale = finalScale; node.targetOpacity = finalOp;
+      node.hidden = false;
+      // НОВЫЙ узел (разлетается из центра) — помечаем для эффекта прорастания линии (edgeGrow=0);
+      // переезжающий/общий узел — линия просто следует за ним (edgeGrow=1, без dash-раскрытия).
+      node.edgeGrow = (isNew && !node.isFocus) ? 0 : 1;
+
+      // глубокие уровни (tier≥2) НЕ участвуют в CSS-bloom — их позиционирует layoutDeep/renderDeepNodes
+      if (node.tier < 2) {
+        maxDelay = Math.max(maxDelay, delay);
+        blooms.push({ el: node.el, start: tf(fx, fy, fs), final: tf(finalX, finalY, finalScale), fo, delay });
+      }
+      return node;
+    });
+    pendingFocusOrigin = null;
+    diveTargetId = null; surfacing = false; zoom = 1; // перестроение графа сбрасывает погружение и зум
+    rebuildIndex();      // обновляем nodeById/hasDeep под новый набор узлов
+    updateBadges();      // бейджи-счётчики связей под новый набор
+    updateA11y();        // текстовый список графа для скринридеров
+    layoutDeep();        // сразу ставим глубокие уровни на орбиты вокруг родителей
+    renderDeepNodes();   // и показываем их (CSS-bloom их элементы не трогает)
+    emitDiveChange();    // сбрасываем хлебные крошки (новый граф = верхний уровень)
+
+    camX = 0; camY = 0; applyWorldTransform();
+
+    // ПАСС 1: стартовое состояние без перехода
+    for (const b of blooms) { b.el.style.transition = 'none'; b.el.style.transform = b.start; b.el.style.opacity = String(b.fo); }
+    void world.offsetWidth; // один форс-рефлоу, чтобы старт «зафиксировался»
+    // ПАСС 2: включаем CSS-переход и ставим финал → компоновщик плавно «по маслу»
+    // (работает даже когда JS-rAF троттлится; премиальная вязкая кривая Apple-уровня)
+    for (const b of blooms) {
+      b.el.style.transition = `transform ${BLOOM_MS}ms cubic-bezier(0.16, 1, 0.3, 1) ${b.delay}ms, opacity 700ms ease ${b.delay}ms`;
+      b.el.style.transform = b.final;
+      b.el.style.opacity = '1';
+    }
+
+    cssBloom = true;            // физика выключена; цикл лишь ведёт лучи за CSS-узлами
+    cssBloomKind = 'bloom';     // после каскада — лёгкое упругое до-покачивание (boost)
+    renderEdges();
+    cssBloomTimer = window.setTimeout(endCssBloom, BLOOM_MS + maxDelay + 80); // завершение гарантировано
+    wake();
+  }
+
+  stage.addEventListener('pointerdown', onPointerDown);
+  stage.addEventListener('pointermove', onPointerMove);
+  stage.addEventListener('pointerup', onPointerUp);
+  stage.addEventListener('pointercancel', onPointerUp);
+  stage.addEventListener('pointerover', onPointerOver);   // ховер мышью → превью ветки
+  stage.addEventListener('pointerout', onPointerOut);
+  stage.addEventListener('wheel', onWheel, { passive: false }); // зум колесом мыши
+  window.addEventListener('resize', onResize);
+
+  let ro = null;
+  if (typeof ResizeObserver !== 'undefined') {
+    ro = new ResizeObserver(() => onResize());
+    ro.observe(stage);
+  }
+
+  setModel(model);
+
+  return {
+    recenter: (id) => startRecenterTween(id),
+    setModel,
+    setFilter,
+    toggleExpand,   // mind-map: ЗАФИКСИРОВАТЬ/снять раскрытие ветки кликом (pinned)
+    setHover,       // mind-map: ВРЕМЕННОЕ раскрытие ветки наведением (node | null)
+    diveTo,         // Smart Zoom: погрузиться в узел 2-го+ уровня (наезд камеры, «аквариум»)
+    exitDive,       // Smart Zoom: всплыть из погружения на уровень назад
+    collapseAll,    // mind-map: свернуть всё + всплыть наверх (тап по корню)
+    findNode,       // поиск узла по имени/логину → { id, name, tier } | null (для строки поиска)
+    getDivePath: () => divePathNodes().map((n) => ({ id: String(n.id), name: n.name || n.login || String(n.id), isFocus: !!n.isFocus })), // хлебные крошки
+    getFocusNode: () => nodes.find((n) => n.isFocus) || null,
+    // --- Dev/тест-хелперы (для автопроверок; не вызываются в обычной работе) -------------------
+    // Снимок состояния (только чтение): позиции/масштаб/прозрачность/уровень узлов + камера.
+    debugState: () => ({
+      zoom: +zoom.toFixed(3), camX: Math.round(camX), camY: Math.round(camY), diveTargetId, surfacing, spotActive, focusId,
+      nodes: nodes.map((n) => ({ id: String(n.id), tier: n.tier, lod: n.lod, pinned: !!n.pinned, hovered: !!n.hovered, sibIndex: n.sibIndex, expandP: +(n.expandP || 0).toFixed(3), x: Math.round(n.x), y: Math.round(n.y), scale: +(n.scale || 0).toFixed(3), depthScale: +(n.depthScale || 1).toFixed(3), depthBlur: +(n.depthBlur || 0).toFixed(2), opacity: +(n.opacity || 0).toFixed(3), spotCur: +(n.spotCur || 1).toFixed(3) })),
+    }),
+    // Детерминированно докрутить анимацию до покоя (обходит троттлинг rAF в фоновых вкладках/тестах).
+    pumpForTest: (maxFrames = 1200) => {
+      let ts = (typeof performance !== 'undefined' && performance.now) ? performance.now() : 0;
+      let i = 0;
+      for (; i < maxFrames; i += 1) { ts += 16; tick(ts); if (!rafId) break; } // tick заморозился → rafId=0
+      if (rafId) { cancelAnimationFrame(rafId); rafId = 0; }
+      return i + 1;
+    },
+    destroy() {
+      if (rafId) cancelAnimationFrame(rafId);
+      rafId = 0;
+      if (longTimer) window.clearTimeout(longTimer);
+      stage.removeEventListener('pointerdown', onPointerDown);
+      stage.removeEventListener('pointermove', onPointerMove);
+      stage.removeEventListener('pointerup', onPointerUp);
+      stage.removeEventListener('pointercancel', onPointerUp);
+      stage.removeEventListener('pointerover', onPointerOver);
+      stage.removeEventListener('pointerout', onPointerOut);
+      stage.removeEventListener('wheel', onWheel);
+      window.removeEventListener('resize', onResize);
+      if (ro) ro.disconnect();
+      edgesSvg.remove();
+      world.remove();
+      a11y.remove();
+    },
+  };
+}
+
+/**
+ * Конвертирует данные формы ТЗ (focusUser + connections[]) в нейтральную модель движка.
+ * Используется на этапе мок-прототипа (Фаза 1).
+ */
+export function buildModelFromTz(tz) {
+  const focus = tz?.focusUser || {};
+  const focusNode = {
+    id: String(focus.id || 'focus'),
+    login: focus.login || focus.id || '',
+    name: focus.name || '',
+    avatar: focus.avatar && focus.avatar !== 'url_to_image' ? focus.avatar : null,
+    photo: focus.photo || null,
+    relationType: 'self',
+    strength: 1,
+    shining: String(focus.status || '').toLowerCase() === 'shining',
+    tier: 1,
+  };
+  const connections = Array.isArray(tz?.connections) ? tz.connections : [];
+  const peerNodes = connections.map((c) => ({
+    id: String(c.id),
+    login: c.login || c.id || '',
+    name: c.name || '',
+    avatar: c.avatar && c.avatar !== 'url_to_image' ? c.avatar : null,
+    photo: c.photo || null,
+    relationType: c.relationType || 'contact',
+    strength: typeof c.connectionStrength === 'number' ? c.connectionStrength : 0.5,
+    shining: String(c.status || '').toLowerCase() === 'shining',
+    tier: c.hasOwnConnections === false ? 1 : (c.tier || 1),
+  }));
+  return { focusId: focusNode.id, nodes: [focusNode, ...peerNodes] };
+}
diff --git a/shine-UI/js/pages/network/lab.js b/shine-UI/js/pages/network/lab.js
new file mode 100644
index 0000000..c7cc6d6
--- /dev/null
+++ b/shine-UI/js/pages/network/lab.js
@@ -0,0 +1,341 @@
+// Лабораторный режим карты связей (network-view/lab).
+//
+// Назначение: на мок-данных (без бэкенда) щупать физику force-графа, панорамирование,
+// центрирование и навигацию между пользователями. Используется связанный мульти-граф
+// networkGraphUsers: у каждого пользователя свой набор связей, тап по узлу переключает
+// карту на сеть этого человека (как реальный путь, но локально).
+//
+// + Прототип «Мегамасштаб»: переключатель «Вселенная» процедурно достраивает связи
+//   2-го и 3-го уровней НА ФРОНТЕНДЕ (API отдаёт только прямые связи — его не трогаем).
+//   Это чисто визуальный лабораторный эксперимент на мок-данных.
+
+import { renderHeader } from '../../components/header.js';
+import { networkGraphUsers } from '../../mock-data.js';
+import { createForceGraph, buildModelFromTz } from './force-graph.js';
+import { openNodeMenu } from './node-menu.js';
+
+const START_LOGIN = 'ivan';
+
+// Фильтры слоёв — те же, что в реальном пути network-view (предикат по периферийным узлам;
+// фокус виден всегда). Позволяют пощупать в лаборатории в т.ч. слой «Сияющие».
+const FILTERS = {
+  all: { label: 'Все', pred: () => true },
+  family: { label: 'Семья', pred: (n) => n.relationType === 'family' },
+  friends: { label: 'Друзья', pred: (n) => n.relationType === 'friend' },
+  shining: { label: 'Сияющие', pred: (n) => Boolean(n.shining) },
+};
+const FILTER_ORDER = ['all', 'family', 'friends', 'shining'];
+
+// Пул имён для процедурных «дальних» узлов 2-го уровня (3-й уровень — без подписей, точки).
+const DEEP_NAMES = ['Лео', 'Майя', 'Тео', 'Ева', 'Ник', 'Зоя', 'Ян', 'Ада', 'Рик', 'Уна',
+  'Гор', 'Лия', 'Сэм', 'Иня', 'Ким', 'Эль', 'Юта', 'Бьорн', 'Мила', 'Орт'];
+
+// Детерминированный сид 0..1 по строке (без Math.random: одинаковый узел всегда одинаков).
+function seed01(str) {
+  let h = 2166136261;
+  const s = String(str || '');
+  for (let i = 0; i < s.length; i += 1) { h ^= s.charCodeAt(i); h = Math.imul(h, 16777619); }
+  return ((h >>> 0) % 100000) / 100000;
+}
+
+function helpText() {
+  return [
+    'Лаборатория карты связей (мок-данные, без сервера).',
+    '• Тащите по экрану — карта свободно перемещается (pan).',
+    '• Тап по узлу — он стягивается в центр и карта перестраивается под его сеть.',
+    '• Тап по центральному узлу — здесь открылся бы профиль.',
+    '• Долгое нажатие — контекстное меню (в реальном пути «Связи»).',
+    '• Чипы под шапкой — фильтры слоёв: Все / Семья / Друзья / Сияющие.',
+    '• Чип «Вселенная» — режим «Интерактивная паутина» (глубина 2-3 уровней, фейковые связи).',
+    '  Наведи мышь/палец на узел — его связи временно выплывают (превью). КЛИК по узлу — «умный',
+    '  наезд»: камера летит и центрирует его, он вырастает, друзья раскрываются крупно вокруг,',
+    '  путь назад к Ивану горит нитью, остальное затемняется. Клик по нему ещё раз — всплыть.',
+    '  Тап по центру (Ивану) — полный сброс (всё на 100%, камера отъезжает).',
+    '  Колесо мыши / щипок двумя пальцами — зум; при сильном приближении точки 3-го уровня',
+    '  превращаются в аватарки. Свайп — pan.',
+    '',
+    'Доступные люди: Иван, Алиса, Павел, Елена, Дмитрий, Олег, Нина, Марина, Света, Кирилл.',
+  ].join('\n');
+}
+
+// Граф пользователя по логину; если такого нет в датасете — одинокий узел (без связей).
+function graphForLogin(login) {
+  const key = String(login || '').trim().toLowerCase();
+  if (networkGraphUsers[key]) return networkGraphUsers[key];
+  return { focusUser: { id: key, login: key, name: key, avatar: null, status: '' }, connections: [] };
+}
+
+// Если у фокуса нет прямых связей (например, тапнули по фейковому дальнему узлу) —
+// синтезируем 4-6 связей 1-го уровня, чтобы «вселенная» вокруг него не была пустой.
+function synthTier1(focusId) {
+  const k = 4 + Math.floor(seed01(focusId + ':n') * 3); // 4-6
+  const out = [];
+  for (let i = 0; i < k; i += 1) {
+    const id = `${focusId}__t1_${i}`;
+    const s = seed01(id);
+    out.push({
+      id, login: id, name: DEEP_NAMES[Math.floor(seed01(id + 'n') * DEEP_NAMES.length)],
+      avatar: null, photo: null,
+      relationType: ['family', 'friend', 'business', 'contact'][i % 4],
+      connectionStrength: 0.5 + s * 0.4,
+      status: s > 0.78 ? 'shining' : '',
+      hasOwnConnections: true, tier: 1,
+    });
+  }
+  return out;
+}
+
+// Процедурно достраиваем дальние орбиты: для каждого узла 1-го уровня — 3-5 узлов 2-го уровня,
+// для каждого узла 2-го уровня — 3-5 «микрозвёзд» 3-го уровня. Всё детерминировано по id.
+function addDeepLevels(model) {
+  const focusId = model.focusId;
+  const tier1 = model.nodes.filter((n) => String(n.id) !== String(focusId));
+  const extra = [];
+  tier1.forEach((p) => {
+    const k2 = 3 + Math.floor(seed01(p.id + ':2') * 3); // 3-5
+    // «общий друг»: детерминированно берём ДРУГОГО друга Ивана — он окажется и в сети p (общая связь).
+    const others = tier1.filter((o) => String(o.id) !== String(p.id));
+    const common = others.length ? others[Math.floor(seed01(p.id + ':common') * others.length)] : null;
+    for (let i = 0; i < k2; i += 1) {
+      const id2 = `${p.id}__d2_${i}`;
+      const ang2 = (i / k2) * Math.PI * 2 + seed01(p.id) * 0.6;
+      // i===0 + есть общий → подставляем узнаваемого друга Ивана как ОБЩУЮ связь (золотой ободок ★)
+      if (i === 0 && common) {
+        extra.push({
+          id: id2, login: id2, name: common.name || common.login,
+          avatar: null, photo: common.photo || null, relationType: common.relationType || 'friend',
+          strength: 0.5, shining: false, tier: 2, parentId: String(p.id), deepAngle: ang2, common: true,
+        });
+        continue;
+      }
+      // узлы 2-го уровня — полноценные (видимые) аватарки: детерминированное фото-лицо (pravatar) + имя
+      const face2 = `https://i.pravatar.cc/120?img=${1 + Math.floor(seed01(id2 + 'p') * 70)}`;
+      extra.push({
+        id: id2, login: id2, name: DEEP_NAMES[Math.floor(seed01(id2) * DEEP_NAMES.length)],
+        avatar: null, photo: face2, relationType: p.relationType || 'contact',
+        strength: 0.4, shining: false, tier: 2, parentId: String(p.id), deepAngle: ang2,
+      });
+      const k3 = 3 + Math.floor(seed01(id2 + ':3') * 3); // 3-5
+      for (let j = 0; j < k3; j += 1) {
+        const id3 = `${id2}_d3_${j}`;
+        const ang3 = (j / k3) * Math.PI * 2 + seed01(id2) * 0.9;
+        // фото-лицо + имя для LOD: точка-звезда дорисуется в читаемую аватарку при сильном зуме
+        const face3 = `https://i.pravatar.cc/100?img=${1 + Math.floor(seed01(id3 + 'p') * 70)}`;
+        extra.push({
+          id: id3, login: id3, name: DEEP_NAMES[Math.floor(seed01(id3 + 'n') * DEEP_NAMES.length)],
+          avatar: null, photo: face3, relationType: 'contact',
+          strength: 0.2, shining: seed01(id3) > 0.82, tier: 3, parentId: id2, deepAngle: ang3,
+        });
+      }
+    }
+  });
+  return { focusId, nodes: [...model.nodes, ...extra] };
+}
+
+// Полная модель лаборатории для логина: реальные мок-связи (или синтетика для фейковых
+// логинов) + опционально дальние уровни, когда включён режим «Вселенная».
+// fromLogin — предыдущий фокус: остаётся на орбите ярким «треком прохождения» (Иван → Олег → …).
+function buildLabModel(login, deep, fromLogin) {
+  const tz = graphForLogin(login);
+  if (!Array.isArray(tz.connections) || tz.connections.length === 0) {
+    if (deep) tz.connections = synthTier1(String(tz.focusUser?.id || login));
+    else tz.connections = [];
+  }
+  const base = buildModelFromTz(tz);
+
+  // «Трек прохождения»: предыдущий фокус — на орбите, линия к нему горит ярко (не уходит в ghost).
+  if (fromLogin && String(fromLogin).toLowerCase() !== String(login).toLowerCase()) {
+    const fid = String(fromLogin);
+    const found = base.nodes.find((n) => String(n.id).toLowerCase() === fid.toLowerCase()
+      || String(n.login || '').toLowerCase() === fid.toLowerCase());
+    if (found) {
+      found.track = true; // уже среди связей — просто подсветим трек
+    } else {
+      const f = graphForLogin(fromLogin).focusUser || {};
+      base.nodes.push({
+        id: fid, login: f.login || fromLogin, name: f.name || fromLogin,
+        avatar: f.avatar && f.avatar !== 'url_to_image' ? f.avatar : null,
+        photo: f.photo || null, relationType: 'friend', strength: 0.97,
+        shining: false, tier: 1, track: true,
+      });
+    }
+  }
+  return deep ? addDeepLevels(base) : base;
+}
+
+export function renderNetworkLab({ navigate }) {
+  const screen = document.createElement('section');
+  screen.className = 'network-screen';
+
+  const appScreenEl = document.getElementById('app-screen');
+  appScreenEl?.classList.add('network-scroll-lock');
+
+  const stage = document.createElement('div');
+  stage.className = 'network-stage fg-stage';
+
+  const header = renderHeader({
+    title: 'Связи · лаборатория',
+    leftAction: { label: '←', onClick: () => navigate('network-view') },
+    rightActions: [{ label: '?', onClick: () => window.alert(helpText()) }],
+  });
+  header.classList.add('network-header-overlay');
+
+  let centerLogin = START_LOGIN;
+  let deepMode = false;
+
+  // Состояние активного слоя (как в network-view): фокус всегда виден.
+  let activeFilter = 'all';
+  const filterChips = {};
+  function applyFilter(key) {
+    if (!FILTERS[key]) return;
+    activeFilter = key;
+    FILTER_ORDER.forEach((k) => {
+      const el = filterChips[k];
+      if (el) el.classList.toggle('is-active', k === activeFilter);
+    });
+    graph.setFilter(FILTERS[key].pred);
+  }
+
+  stage.append(header);
+  screen.append(stage);
+
+  const model = buildLabModel(centerLogin, deepMode);
+
+  // Объявлено заранее: onDiveChange (вызывается уже при монтировании) ссылается на эти элементы.
+  let breadcrumbEl = null; // панель хлебных крошек (создаётся ниже)
+
+  // Монтируем движок синхронно (не через rAF): размеры сцены движок берёт с запасом
+  // (window.innerWidth) и корректирует через ResizeObserver, когда сцена попадёт в DOM.
+  const graph = createForceGraph({
+    stage,
+    model,
+    // тап по узлу — переключаем карту на сеть выбранного человека (или фейкового дальнего узла);
+    // в режиме «Вселенная» вокруг нового центра процедурно генерится дальняя орбита.
+    onNodeTap: (node) => {
+      if (deepMode) {
+        // Умный фокус: клик по ЛЮБОМУ узлу (Нина/её друг) — камера наезжает и центрирует его, ветка
+        // раскрывается, путь назад к Ивану горит, остальное затемняется (0.25). Повтор по нему — всплыть.
+        graph.diveTo(node);
+        return;
+      }
+      // обычный режим: перецентрирование на выбранного человека (+ трек прохождения)
+      const from = centerLogin;
+      centerLogin = node.login || node.id;
+      graph.setModel(buildLabModel(centerLogin, deepMode, from));
+      if (activeFilter !== 'all') graph.setFilter(FILTERS[activeFilter].pred);
+    },
+    // Наведение мышью / касание пальцем — ВРЕМЕННОЕ раскрытие ветки (превью): выплывает под курсором,
+    // втягивается при уходе (если узел не закреплён кликом). Только в режиме «Вселенная».
+    onNodeHover: (node, over) => { if (deepMode) graph.setHover(over ? node : null); },
+    // Изменение пути погружения → перерисовываем хлебные крошки (Иван › Нина › Ада).
+    onDiveChange: (path) => renderBreadcrumb(path),
+    onCenterTap: (node) => {
+      // в паутине тап по корню (Ивану) — глобальный сброс: свернуть все раскрытые ветки
+      if (deepMode) { graph.collapseAll(); return; }
+      window.alert(`Профиль: ${node.name || node.login || node.id}`);
+    },
+    onNodeLongPress: (node, point) => openNodeMenu({
+      login: node.name || node.login || node.id,
+      relationType: node.relationType,
+      point,
+      actions: [
+        { label: 'Профиль', onClick: () => window.alert(`Профиль: ${node.name || node.login}`) },
+        { label: 'Написать', onClick: () => window.alert(`Написать: ${node.name || node.login}`) },
+      ],
+    }),
+  });
+
+  // Панель фильтров слоёв — тот же оверлей-стиль (.fg-filter-bar), что и в network-view.
+  const filterBar = document.createElement('div');
+  filterBar.className = 'fg-filter-bar';
+  // Не даём нажатию на чип «провалиться» в сцену (иначе сцена перехватит указатель и «съест» click).
+  filterBar.addEventListener('pointerdown', (e) => e.stopPropagation());
+  FILTER_ORDER.forEach((key) => {
+    const chip = document.createElement('button');
+    chip.type = 'button';
+    chip.className = `fg-filter-chip${key === activeFilter ? ' is-active' : ''}`;
+    chip.textContent = FILTERS[key].label;
+    chip.addEventListener('click', () => applyFilter(key));
+    filterChips[key] = chip;
+    filterBar.append(chip);
+  });
+  // Переключатель прототипа «Вселенная» (глубина 2-3 уровней) — отдельный чип.
+  const deepChip = document.createElement('button');
+  deepChip.type = 'button';
+  deepChip.className = 'fg-filter-chip fg-deep-chip';
+  deepChip.textContent = '🌌 Вселенная';
+  deepChip.addEventListener('click', () => {
+    deepMode = !deepMode;
+    deepChip.classList.toggle('is-active', deepMode);
+    graph.setModel(buildLabModel(centerLogin, deepMode));
+    if (activeFilter !== 'all') graph.setFilter(FILTERS[activeFilter].pred);
+  });
+  filterBar.append(deepChip);
+  stage.append(filterBar);
+
+  // --- Поиск + телепорт камеры: ввёл имя → камера летит к узлу (dive в «Вселенной», иначе перецентр) ---
+  const searchWrap = document.createElement('div');
+  searchWrap.className = 'fg-search';
+  searchWrap.addEventListener('pointerdown', (e) => e.stopPropagation());
+  const searchIco = document.createElement('span');
+  searchIco.className = 'fg-search-ico';
+  searchIco.textContent = '🔍';
+  const searchInput = document.createElement('input');
+  searchInput.type = 'search';
+  searchInput.placeholder = 'Найти человека…';
+  searchInput.setAttribute('aria-label', 'Поиск по имени');
+  function doSearch() {
+    const hit = graph.findNode(searchInput.value);
+    if (!hit) return;
+    if (deepMode) {
+      graph.diveTo({ id: hit.id });             // камера летит и центрирует найденного
+    } else {
+      const from = centerLogin;
+      centerLogin = hit.id;
+      graph.setModel(buildLabModel(centerLogin, deepMode, from));
+      if (activeFilter !== 'all') graph.setFilter(FILTERS[activeFilter].pred);
+    }
+    searchInput.blur();
+  }
+  searchInput.addEventListener('keydown', (e) => { if (e.key === 'Enter') doSearch(); });
+  searchWrap.append(searchIco, searchInput);
+  stage.append(searchWrap);
+
+  // --- Хлебные крошки: стек погружений (Иван › Нина › Ада); клик по крошке — навигация назад ---
+  breadcrumbEl = document.createElement('div');
+  breadcrumbEl.className = 'fg-breadcrumb';
+  breadcrumbEl.addEventListener('pointerdown', (e) => e.stopPropagation());
+  stage.append(breadcrumbEl);
+  // hoisted-функция: на неё ссылается onDiveChange (вызывается уже после монтирования UI)
+  function renderBreadcrumb(path) {
+    if (!breadcrumbEl) return;
+    breadcrumbEl.innerHTML = '';
+    const open = Array.isArray(path) && path.length > 1; // показываем только при активном погружении
+    breadcrumbEl.classList.toggle('is-open', open);
+    if (!open) return;
+    path.forEach((p, i) => {
+      if (i) { const sep = document.createElement('span'); sep.className = 'fg-crumb-sep'; sep.textContent = '›'; breadcrumbEl.append(sep); }
+      const c = document.createElement('button');
+      c.type = 'button';
+      c.className = `fg-crumb${i === path.length - 1 ? ' is-last' : ''}`;
+      c.textContent = p.name;
+      if (i < path.length - 1) {
+        c.addEventListener('click', () => { if (i === 0 || p.isFocus) graph.collapseAll(); else graph.diveTo({ id: p.id }); });
+      }
+      breadcrumbEl.append(c);
+    });
+  }
+
+  // Автопроверки: ТОЛЬКО при ?fgtest — экспонируем граф и прогоняем self-test (результат в консоль).
+  if (typeof window !== 'undefined' && String(location.search).includes('fgtest')) {
+    window.__fg = graph;
+    import('./selftest.js').then((m) => m.runNetworkSelfTest(graph, deepChip)).catch((e) => console.error('[fg-selftest] не загрузился', e));
+  }
+
+  screen.cleanup = () => {
+    graph.destroy();
+    appScreenEl?.classList.remove('network-scroll-lock');
+  };
+
+  return screen;
+}
diff --git a/shine-UI/js/pages/network/node-menu.js b/shine-UI/js/pages/network/node-menu.js
new file mode 100644
index 0000000..ed38d6c
--- /dev/null
+++ b/shine-UI/js/pages/network/node-menu.js
@@ -0,0 +1,84 @@
+// Общее контекстное меню узла (долгое нажатие) для карты связей.
+// Рендерится в #modal-root (вне масштабируемого холста), позиционируется по экранному rect узла.
+// Используется и реальным путём (network-view.js), и лабораторией (lab.js).
+
+const REL_RU = {
+  family: 'Семья',
+  friend: 'Друг',
+  business: 'Бизнес',
+  contact: 'Контакт',
+  self: 'Вы',
+};
+
+function escapeHtml(text) {
+  return String(text || '')
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;');
+}
+
+export function relationLabelRu(relationType) {
+  return REL_RU[relationType] || 'Контакт';
+}
+
+/**
+ * Открывает контекстное меню узла.
+ * @param {Object} opts
+ * @param {string} opts.login - логин/идентификатор для заголовка
+ * @param {string} opts.relationType - тип связи (для подписи)
+ * @param {{x:number,y:number,rect?:DOMRect}} opts.point - экранная точка/rect узла
+ * @param {Array<{label:string, onClick:Function, disabled?:boolean}>} opts.actions - пункты меню
+ */
+export function openNodeMenu({ login, relationType, point, actions = [] } = {}) {
+  const root = document.getElementById('modal-root');
+  if (!(root instanceof HTMLElement)) return;
+
+  const itemsHtml = actions
+    .map((a, i) => `<button class="fg-menu-item${a.disabled ? ' is-stub' : ''}" type="button" data-i="${i}" role="menuitem"${a.disabled ? ' disabled' : ''}>${escapeHtml(a.label)}</button>`)
+    .join('');
+
+  root.innerHTML = `
+    <div class="fg-menu-overlay" id="fg-menu-overlay">
+      <div class="fg-menu" id="fg-menu" role="menu">
+        <div class="fg-menu-head">
+          <span class="fg-menu-login">${escapeHtml(login)}</span>
+          <span class="fg-menu-rel">${escapeHtml(relationLabelRu(relationType))}</span>
+        </div>
+        ${itemsHtml}
+      </div>
+    </div>
+  `;
+
+  const overlay = root.querySelector('#fg-menu-overlay');
+  const menu = root.querySelector('#fg-menu');
+  if (!(overlay instanceof HTMLElement) || !(menu instanceof HTMLElement)) { root.innerHTML = ''; return; }
+
+  // позиционируем рядом с узлом по его экранному rect (синхронно, без rAF — он может троттлиться)
+  const rect = point?.rect;
+  const px = point?.x ?? (rect ? rect.left + rect.width / 2 : window.innerWidth / 2);
+  const belowY = rect ? rect.bottom + 8 : (point?.y ?? 80);
+  const mw = menu.offsetWidth;
+  const mh = menu.offsetHeight;
+  let left = px - mw / 2;
+  left = Math.max(8, Math.min(left, window.innerWidth - mw - 8));
+  let top = belowY;
+  if (top + mh > window.innerHeight - 8) top = Math.max(8, (rect ? rect.top : belowY) - mh - 8);
+  menu.style.left = `${left}px`;
+  menu.style.top = `${top}px`;
+
+  const close = () => { root.innerHTML = ''; };
+  overlay.addEventListener('click', (e) => { if (e.target === overlay) close(); });
+  menu.addEventListener('click', (e) => {
+    const btn = e.target instanceof HTMLElement ? e.target.closest('[data-i]') : null;
+    if (!(btn instanceof HTMLElement)) return;
+    const idx = Number(btn.dataset.i);
+    const action = actions[idx];
+    if (!action || action.disabled) return;
+    close();
+    if (typeof action.onClick === 'function') action.onClick();
+  });
+
+  return close;
+}
diff --git a/shine-UI/js/pages/network/selftest.js b/shine-UI/js/pages/network/selftest.js
new file mode 100644
index 0000000..4c0dd22
--- /dev/null
+++ b/shine-UI/js/pages/network/selftest.js
@@ -0,0 +1,150 @@
+// Автопроверки интерактивного графа связей (dev-only).
+//
+// Запускаются ТОЛЬКО в лаборатории при наличии ?fgtest в URL (см. lab.js). Используют детерминированные
+// dev-хелперы движка (graph.debugState / graph.pumpForTest) — поэтому проходят стабильно даже когда
+// requestAnimationFrame троттлится в фоновой вкладке (pumpForTest синхронно докручивает кадры до покоя).
+//
+// Результат печатается в консоль и кладётся в window.__fgTestResults = { pass, total, results[] }.
+
+const DEEP_FAN_HALF_DEG = 110; // допустимое отклонение детей от направления «наружу» (полукруг ~±99° + запас)
+
+export async function runNetworkSelfTest(graph, deepChipEl) {
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  const results = [];
+  const check = (name, pass, detail) => { results.push({ name, pass: !!pass, detail }); };
+  const st = () => graph.debugState();
+
+  // 1) Включаем режим «Вселенная» и ждём, пока завершится bloom-перестроение (его закрывает setTimeout).
+  if (deepChipEl && !deepChipEl.classList.contains('is-active')) deepChipEl.click();
+  await wait(1700);
+
+  let s = st();
+  const focusId = s.focusId;
+  const tier1 = s.nodes.filter((n) => n.tier === 1 && n.id !== focusId);
+  const parent = tier1.find((n) => n.id === 'nina') || tier1[0];
+  if (!parent) { check('есть узлы 1-го уровня', false, 'tier-1 не найдены'); return finish(results); }
+
+  // === Тест A: погружение в узел 1-го уровня (камера-наезд + расталкивание + полукруг) ===
+  graph.diveTo({ id: parent.id });
+  const framesA = graph.pumpForTest();
+  s = st();
+  const p = s.nodes.find((n) => n.id === parent.id);
+  const kids = s.nodes.filter((n) => n.tier === 2 && String(n.id).startsWith(parent.id + '__d2_'));
+
+  check('A1 анимация погружения завершается (freeze)', framesA < 1190, `кадров: ${framesA}`);
+  check('A2 камера зумит (zoom≈DIVE)', s.zoom >= 1.5, `zoom=${s.zoom}`);
+  check('A3 узел центрируется камерой', Math.abs(s.camX + p.x * s.zoom) < 36 && Math.abs(s.camY + p.y * s.zoom) < 36,
+    `offset=(${Math.round(s.camX + p.x * s.zoom)},${Math.round(s.camY + p.y * s.zoom)})`);
+  check('A4 узел вырос (герой)', p.depthScale > 1.2, `depthScale=${p.depthScale}`);
+
+  // расталкивание: дети не слипаются
+  let minD = Infinity;
+  for (let i = 0; i < kids.length; i += 1) for (let j = i + 1; j < kids.length; j += 1) {
+    minD = Math.min(minD, Math.hypot(kids[i].x - kids[j].x, kids[i].y - kids[j].y));
+  }
+  check('A5 дети не слипаются (collision)', kids.length >= 2 ? minD > 40 : true, `мин.дистанция=${Math.round(minD)}px`);
+
+  // полукруг наружу: все дети в секторе вокруг направления от центра к родителю
+  const outward = Math.atan2(p.y, p.x);
+  const maxDev = kids.reduce((mx, k) => {
+    let d = Math.abs(Math.atan2(k.y - p.y, k.x - p.x) - outward);
+    if (d > Math.PI) d = 2 * Math.PI - d;
+    return Math.max(mx, d * 180 / Math.PI);
+  }, 0);
+  check('A6 веер полукругом наружу', kids.length ? maxDev <= DEEP_FAN_HALF_DEG : true, `maxDev=${Math.round(maxDev)}°`);
+
+  // === Тест B: Spotlight открыт — путь горит, остальное тускнеет ===
+  const offPath = tier1.filter((n) => n.id !== parent.id);
+  const offDim = offPath.every((n) => { const x = s.nodes.find((m) => m.id === n.id); return x && x.spotCur < 0.4; });
+  const pathLit = (s.nodes.find((n) => n.id === parent.id).spotCur > 0.9) && (s.nodes.find((n) => n.id === focusId).spotCur > 0.9);
+  check('B1 путь горит на 100%', pathLit, 'фокус+цель spotCur>0.9');
+  check('B2 остальные ветки затемнены (~0.25)', offDim, 'все вне пути spotCur<0.4');
+
+  // === Тест C: переключение веток сбрасывает прежнюю (нет накопления) ===
+  if (offPath.length) {
+    graph.diveTo({ id: offPath[0].id });
+    graph.pumpForTest();
+    s = st();
+    const prev = s.nodes.find((n) => n.id === parent.id);
+    check('C1 прежняя ветка сброшена при переключении', prev.spotCur < 0.4, `прежняя spotCur=${prev.spotCur}`);
+    check('C2 новая цель — активна', s.diveTargetId === offPath[0].id, `dive=${s.diveTargetId}`);
+  }
+
+  // === Тест D: LOD — дети 3-го уровня становятся аватарками при сильном зуме ===
+  const t2withKids = st().nodes.find((n) => n.tier === 2);
+  if (t2withKids) {
+    graph.diveTo({ id: t2withKids.id });
+    graph.pumpForTest();
+    s = st();
+    const t3 = s.nodes.filter((n) => n.tier === 3 && String(n.id).startsWith(t2withKids.id + '_d3_'));
+    const allFull = t3.length ? t3.every((n) => n.lod === 'full') : true;
+    check('D1 точки 3-го уровня → аватарки (LOD)', allFull, `full: ${t3.filter((n) => n.lod === 'full').length}/${t3.length}`);
+  }
+
+  // === Тест F: поиск по имени находит узел (для строки поиска + телепорта) ===
+  const named = st().nodes.find((n) => n.tier === 1 && n.id !== st().focusId);
+  if (named && typeof graph.findNode === 'function') {
+    const byId = graph.findNode(named.id);
+    check('F1 поиск находит узел по логину', byId && byId.id === named.id, `найдено: ${byId && byId.id}`);
+  }
+
+  // === Тест G: хлебные крошки — путь focus → … → цель (мы сейчас в t2withKids) ===
+  if (typeof graph.getDivePath === 'function' && t2withKids) {
+    const path = graph.getDivePath();
+    const okPath = path.length >= 2 && path[0].isFocus && path[path.length - 1].id === t2withKids.id;
+    check('G1 хлебные крошки строят путь к цели', okPath, `путь: ${path.map((p) => p.name).join(' › ')}`);
+  }
+
+  // === Тест H: бейдж числа связей виден и числовой (DOM) ===
+  if (typeof document !== 'undefined') {
+    const fb = document.querySelector('.fg-node.is-focus .fg-node-badge');
+    const fbOk = fb && !fb.hidden && Number(fb.textContent) > 0;
+    check('H1 бейдж числа связей на центре', !!fbOk, `центр: ${fb ? fb.textContent : 'нет'}`);
+  }
+
+  // === Тест I: общие связи — есть узлы с золотым ободком ★ (общий друг) ===
+  if (typeof document !== 'undefined') {
+    const commonCount = document.querySelectorAll('.fg-node.is-common').length;
+    check('I1 общие связи помечены (★)', commonCount >= 1, `узлов «общая связь»: ${commonCount}`);
+  }
+
+  // === Тест J: доступность — текстовый список графа для скринридеров ===
+  if (typeof document !== 'undefined') {
+    const a11y = document.querySelector('.fg-a11y');
+    const liCount = a11y ? a11y.querySelectorAll('li').length : 0;
+    check('J1 sr-only список графа заполнен', !!a11y && liCount >= 1, `пунктов списка: ${liCount}`);
+  }
+
+  // === Тест E: выход — ВСЕ узлы возвращают 100% яркости, зум отъезжает ===
+  graph.exitDive();
+  graph.pumpForTest();
+  s = st();
+  const allBright = s.nodes.filter((n) => n.tier === 1).every((n) => n.spotCur > 0.95);
+  check('E1 выход: все узлы 100% яркости', allBright, 'tier-1 spotCur>0.95');
+  check('E2 выход: зум вернулся (~1)', Math.abs(s.zoom - 1) < 0.05, `zoom=${s.zoom}`);
+  check('E3 выход: погружение снято', s.diveTargetId === null, `dive=${s.diveTargetId}`);
+
+  // === Тест K: сияющие линии — плазма из 3 слоёв на ОДНОМ S-пути (одинаковый d) ===
+  if (typeof document !== 'undefined') {
+    const flare = document.querySelectorAll('.fg-plasma-flare');
+    const tube = document.querySelectorAll('.fg-plasma-tube');
+    const core = document.querySelectorAll('.fg-plasma-core');
+    const equalLayers = flare.length >= 1 && flare.length === tube.length && tube.length === core.length;
+    const sameD = flare[0] && flare[0].getAttribute('d') === tube[0].getAttribute('d')
+      && tube[0].getAttribute('d') === core[0].getAttribute('d');
+    check('K1 плазма: 3 слоя на ОДНОМ S-пути', equalLayers && !!sameD, `поле:${flare.length} трубка:${tube.length} ядро:${core.length} sameD:${!!sameD}`);
+  }
+
+  return finish(results);
+}
+
+function finish(results) {
+  const pass = results.filter((r) => r.pass).length;
+  const out = { pass, total: results.length, results };
+  if (typeof window !== 'undefined') window.__fgTestResults = out;
+  const tag = pass === results.length ? '✅ PASS' : '❌ FAIL';
+  // eslint-disable-next-line no-console
+  console.log(`[fg-selftest] ${tag} ${pass}/${results.length}`);
+  results.forEach((r) => console.log(`  ${r.pass ? '✓' : '✗'} ${r.name} — ${r.detail}`));
+  return out;
+}
diff --git a/shine-UI/styles/network-graph.css b/shine-UI/styles/network-graph.css
new file mode 100644
index 0000000..5350608
--- /dev/null
+++ b/shine-UI/styles/network-graph.css
@@ -0,0 +1,678 @@
+/* ============================================================================
+   Force-directed карта связей (.fg-*) — интерактивный граф на странице «Связи».
+   Узлы позиционируются трансформами (GPU), рёбра — отдельный SVG-слой.
+   Отдельный модуль, чтобы не раздувать components.css.
+   ========================================================================== */
+
+.fg-stage {
+  touch-action: none;            /* перехватываем жесты сами (pan), без скролла страницы */
+  user-select: none;
+  -webkit-user-select: none;
+  cursor: grab;
+  background: radial-gradient(circle at 50% 42%, rgba(83, 216, 251, 0.07), rgba(255, 255, 255, 0.01) 60%);
+}
+
+.fg-stage:active {
+  cursor: grabbing;
+}
+
+/* Живой фон-«небула»: глубокое размытое сине-голубое облако света строго под центральным узлом.
+   Медленно «дышит» (радиус/яркость) и переливается индиго↔ультрамарин (hue-rotate) за 7с.
+   Чистый CSS на компоновщике — создаёт ощущение живой светящейся среды, не будит rAF-цикл. */
+.fg-stage::before {
+  content: '';
+  position: absolute;
+  inset: 0;
+  background: radial-gradient(circle 320px at 50% 47%, rgba(80, 150, 255, 0.30) 0%, rgba(60, 100, 220, 0.15) 42%, rgba(40, 70, 170, 0) 72%);
+  filter: blur(80px);
+  pointer-events: none;
+  z-index: 0;                /* строго под линиями (z:0, но раньше по порядку) и узлами (z:1) */
+  animation: fg-nebula 7s ease-in-out infinite;
+}
+
+@keyframes fg-nebula {
+  0%, 100% { opacity: 0.70; filter: blur(80px) hue-rotate(-12deg); }
+  50%      { opacity: 1.00; filter: blur(96px) hue-rotate(16deg); }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .fg-stage::before { animation: none; }
+}
+
+.fg-world {
+  position: absolute;
+  left: 50%;
+  top: 50%;
+  width: 0;
+  height: 0;
+  will-change: transform;
+  z-index: 1;            /* узлы и подписи строго над линиями связей */
+}
+
+.fg-edges {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  pointer-events: none;
+  overflow: visible;
+  z-index: 0;            /* линии связей — под узлами */
+  transition: opacity 420ms ease;  /* плавное появление линий при перестройке */
+}
+
+/* Сияющая связь = плазменный композитинг (3 слоя на ОДНОМ S-пути, см. renderEdges).
+   Настоящий НЕОН: яркое светлое ядро + ВИДИМЫЙ голубой ореол вокруг. Слои поля/трубки идут в режиме
+   mix-blend-mode: screen → свет складывается аддитивно с тёмным фоном (как реальное свечение), а в точках
+   пересечения нитей у центра — ярче (энергетический хаб). Прозрачность слоёв — inline (×spotlight/глубину). */
+.fg-plasma-flare {            /* нижний: широкое насыщенное голубое плазменное свечение (по референсу) */
+  fill: none;
+  stroke: #00bfff;            /* глубокий голубой */
+  stroke-width: 16;
+  stroke-linecap: round;
+  filter: url(#fg-plasma-blur6); /* мягкое объёмное свечение (гладкие края — как на референсе) */
+  mix-blend-mode: screen;     /* аддитивное свечение поверх тёмного фона */
+  /* синхро-«дыхание» поля толщиной в такт ободку сияющего узла (3.6с); прозрачность не трогаем (inline) */
+  animation: fg-plasma-breath 3.6s ease-in-out infinite;
+}
+.fg-plasma-tube {             /* средний: яркая толстая неоновая трубка */
+  fill: none;
+  stroke: #00e5ff;            /* яркий циан */
+  stroke-width: 6;
+  stroke-linecap: round;
+  filter: url(#fg-plasma-blur2); /* SVG feGaussianBlur stdDeviation=2 */
+  mix-blend-mode: screen;     /* аддитивное свечение */
+}
+.fg-plasma-core {             /* верхний: яркое чёткое ядро (светло-голубо-белое) */
+  fill: none;
+  stroke: #dffaff;            /* светло-голубо-белое — «жидкое» ядро */
+  stroke-width: 2;
+  stroke-linecap: round;
+}
+
+/* мягкое «дыхание» плазменного облака толщиной, синхронно с пульсом сияющего ободка (3.6с) */
+@keyframes fg-plasma-breath {
+  0%, 100% { stroke-width: 14; }
+  50%      { stroke-width: 19; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .fg-plasma-flare { animation: none; }
+}
+
+.fg-node {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 52px;
+  height: 52px;
+  border: 0;
+  padding: 0;
+  background: transparent;
+  color: inherit;
+  cursor: pointer;
+  transform-origin: center center;
+  will-change: transform;
+  touch-action: none;
+  user-select: none;
+  -webkit-user-select: none;
+  -webkit-touch-callout: none; /* iOS: не показывать системное меню по долгому тапу */
+  z-index: 1;
+}
+
+/* круглая аватарка узла (переиспользуем существующий .node-dot из renderUserAvatar) */
+.fg-node .node-dot {
+  width: 52px;
+  height: 52px;
+  margin: 0;
+  font-size: 16px;
+  transition: transform 160ms ease, box-shadow 160ms ease, border-color 160ms ease;
+}
+
+.fg-node.is-family .node-dot {
+  background: linear-gradient(165deg, #785038, #5f3e2c);
+  border-color: rgba(255, 194, 143, 0.6);
+}
+
+.fg-node.is-friend .node-dot {
+  background: linear-gradient(165deg, #2f4f80, #2a3f62);
+  border-color: rgba(150, 190, 255, 0.5);
+}
+
+.fg-node.is-business .node-dot {
+  background: linear-gradient(165deg, #4a3b7a, #2f2750);
+  border-color: rgba(196, 165, 255, 0.55);
+}
+
+.fg-node.is-contact .node-dot {
+  background: linear-gradient(165deg, #36435c, #283142);
+  border-color: rgba(180, 200, 226, 0.4);
+}
+
+.fg-node.is-focus .node-dot {
+  background: linear-gradient(130deg, #3a5f8e, #3dc4df);
+  color: #061119;
+  border-color: rgba(180, 230, 255, 0.85);
+  box-shadow: 0 0 0 2px rgba(143, 231, 255, 0.45), 0 10px 22px rgba(4, 8, 15, 0.45);
+}
+
+/* Тактильный отклик «нажатия вглубь»: аватарка слегка вдавливается (scale 0.92), а неоновое кольцо
+   вспыхивает заметно ярче (~1.5×). Срабатывает при наведении, фокусе и зажатии (.is-pressed). */
+.fg-node:focus-visible .node-dot,
+.fg-node:hover .node-dot,
+.fg-node.is-pressed .node-dot {
+  transform: scale(0.92);
+  border-color: rgba(160, 240, 255, 0.95);
+  box-shadow: 0 0 0 2px rgba(150, 238, 255, 0.6), 0 0 22px rgba(120, 230, 255, 0.85);
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .fg-node.is-pressed .node-dot { transform: none; }
+}
+
+/* «Сияние» — мягкое живое свечение НА УЗЛЕ (аватарке), а не на линии связи.
+   Многослойная анимированная box-shadow + размытый радиальный ореол (через внешний SVG-фильтр).
+   Пульсация очень медленная и плавная (3.6с): радиус и прозрачность «дышат» 0.5 ↔ 1.0 —
+   как мягкое свечение живого организма в темноте, а не «жирный маркер». */
+.fg-node.is-shine .node-dot {
+  border-color: rgba(150, 240, 255, 0.62);
+  animation: fg-shine-glow 3.6s ease-in-out infinite;
+}
+
+/* размытый радиальный ореол позади аватарки; внешний SVG-фильтр даёт мягкое гауссово размытие */
+.fg-node.is-shine .node-dot::before {
+  content: '';
+  position: absolute;
+  inset: -12px;
+  border-radius: 50%;
+  background: radial-gradient(circle, rgba(140, 240, 255, 0.5) 0%, rgba(130, 235, 255, 0.18) 46%, rgba(130, 235, 255, 0) 72%);
+  filter: url(#fg-shine-glow);
+  z-index: -1;
+  pointer-events: none;
+  animation: fg-shine-halo 3.6s ease-in-out infinite;
+}
+
+/* пульсация многослойной тени: компактное приглушённое → широкое мягкое свечение */
+@keyframes fg-shine-glow {
+  0%, 100% {
+    box-shadow:
+      0 0 5px rgba(125, 232, 255, 0.30),
+      0 0 11px rgba(112, 226, 255, 0.18),
+      0 0 20px rgba(100, 220, 255, 0.10);
+  }
+  50% {
+    box-shadow:
+      0 0 9px rgba(150, 245, 255, 0.62),
+      0 0 20px rgba(122, 236, 255, 0.42),
+      0 0 36px rgba(100, 220, 255, 0.26);
+  }
+}
+
+/* ореол дышит размером и прозрачностью синхронно с тенью (мягко, без рывков) */
+@keyframes fg-shine-halo {
+  0%, 100% { transform: scale(0.9); opacity: 0.5; }
+  50% { transform: scale(1.12); opacity: 1; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .fg-node.is-shine .node-dot { animation: none; }
+  .fg-node.is-shine .node-dot::before { animation: none; }
+}
+
+/* мягкое свечение вокруг фокуса (статичное; «дышит» вместе с размером узла ниже) */
+.fg-node.is-focus .node-dot::after {
+  content: '';
+  position: absolute;
+  inset: -12px;
+  border-radius: 50%;
+  background: radial-gradient(circle, rgba(130, 235, 255, 0.32) 0%, rgba(130, 235, 255, 0) 70%);
+  z-index: -1;
+  pointer-events: none;
+}
+
+/* «Дыхание» фокуса — бесконечная очень мягкая пульсация РАЗМЕРА (база 1.5x → 1.48–1.52x),
+   период 4с. CSS-анимация на transform (GPU) — НЕ будит rAF-цикл физики; интерфейс «живой». */
+.fg-node.is-focus .node-dot {
+  animation: fg-focus-breath 4s ease-in-out infinite;
+}
+
+@keyframes fg-focus-breath {
+  0%, 100% { transform: scale(0.987); }
+  50% { transform: scale(1.013); }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .fg-node.is-focus .node-dot { animation: none; }
+}
+
+/* подпись под узлом — абсолютная, чтобы не влиять на размер бокса (центрирование по трансформу) */
+.fg-node-label {
+  position: absolute;
+  top: 100%;
+  left: 50%;
+  transform: translateX(-50%);
+  margin-top: 5px;
+  max-width: 110px;
+  font-size: 10px;
+  line-height: 1.1;
+  color: #d6e2ff;
+  text-align: center;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  text-shadow: 0 1px 6px rgba(0, 0, 0, 0.55);
+  pointer-events: none;
+}
+
+.fg-node.is-secondary .fg-node-label {
+  opacity: 0.75;
+}
+
+/* Имя центрального узла — на подложке, чтобы линии связей не просвечивали сквозь текст */
+.fg-node.is-focus .fg-node-label {
+  margin-top: 7px;
+  padding: 3px 10px;
+  border-radius: 9px;
+  background: rgba(8, 14, 24, 0.74);
+  backdrop-filter: blur(2px);
+  -webkit-backdrop-filter: blur(2px);
+  color: #f4f8ff;
+  font-weight: 600;
+  text-shadow: none;
+}
+
+/* Лёгкая точка (узлы сверх хард-лимита DOM) — без аватара/подписи */
+.fg-dot {
+  width: 15px;
+  height: 15px;
+  border-radius: 50%;
+  border: 1px solid rgba(255, 255, 255, 0.25);
+  background: #36435c;
+  box-shadow: 0 2px 6px rgba(4, 8, 15, 0.4);
+}
+
+.fg-dot.is-family { background: #6f4a34; border-color: rgba(255, 194, 143, 0.5); }
+.fg-dot.is-friend { background: #2f4f80; border-color: rgba(150, 190, 255, 0.45); }
+.fg-dot.is-business { background: #4a3b7a; border-color: rgba(196, 165, 255, 0.5); }
+.fg-dot.is-contact { background: #36435c; }
+.fg-dot.is-shine { box-shadow: 0 0 9px rgba(130, 235, 255, 0.75); }
+
+/* === Глубина 2-3 уровней (прототип «Вселенная», только лаборатория) ============== */
+/* 2-й уровень — «друзья друзей»: полноценная аватарка (лицо + имя), просто мельче основных.
+   Масштаб/прозрачность задаёт движок; здесь — читаемый ободок и подпись (не «дырка»). */
+.fg-node.is-tier2 .node-dot {
+  border-color: rgba(170, 200, 240, 0.65);
+  box-shadow: 0 2px 8px rgba(4, 8, 15, 0.4);
+}
+.fg-node.is-tier2 .fg-node-label {
+  font-size: 9px;
+  opacity: 0.9;
+  top: calc(100% + 1px);
+}
+
+/* 3-й уровень — микрозвезда: светящаяся точка без картинки (эффект далёкого созвездия). */
+.fg-dot.is-tier3 {
+  width: 9px;
+  height: 9px;
+  border: 0;
+  background: radial-gradient(circle, #e6f6ff 0%, rgba(150, 215, 255, 0.95) 38%, rgba(120, 200, 255, 0) 75%);
+  box-shadow: 0 0 6px rgba(150, 220, 255, 0.9), 0 0 13px rgba(115, 200, 255, 0.5);
+  /* медленное мерцание «звезды» — по box-shadow/яркости (НЕ opacity/scale: ими управляет движок при
+     раскрытии). У каждой звезды своя задержка (inline animation-delay) → живое созвездие. */
+  animation: fg-star-twinkle 3.4s ease-in-out infinite;
+}
+.fg-dot.is-tier3.is-shine {
+  background: radial-gradient(circle, #ffffff 0%, rgba(160, 240, 255, 1) 38%, rgba(120, 230, 255, 0) 75%);
+  box-shadow: 0 0 8px rgba(160, 240, 255, 1), 0 0 16px rgba(115, 220, 255, 0.7);
+}
+
+@keyframes fg-star-twinkle {
+  0%, 100% { box-shadow: 0 0 3px rgba(150, 220, 255, 0.45), 0 0 7px rgba(115, 200, 255, 0.25); filter: brightness(0.78); }
+  50%      { box-shadow: 0 0 7px rgba(165, 235, 255, 0.95), 0 0 15px rgba(120, 210, 255, 0.6); filter: brightness(1.3); }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .fg-dot.is-tier3 { animation: none; }
+}
+
+/* Чип-переключатель «Вселенная» — активное состояние наследует стиль .fg-filter-chip.is-active */
+.fg-deep-chip.is-active {
+  background: rgba(150, 130, 255, 0.18);
+  border-color: rgba(190, 170, 255, 0.6);
+  box-shadow: inset 0 0.5px 0 rgba(255, 255, 255, 0.12), 0 0 14px rgba(150, 120, 255, 0.3);
+  color: #efeaff;
+}
+
+/* «Призрак» старой карты при Z-переходе (эффект погружения) */
+.fg-ghost-layer {
+  position: absolute;
+  inset: 0;                /* полноэкранный overlay → клон линий/узлов совпадает по координатам */
+  pointer-events: none;
+  z-index: 0;
+  opacity: 0.5;            /* стартовая прозрачность шлейфа выше → дольше читается (JS уводит в 0) */
+  transform-origin: 50% 50%;
+  /* лениво и породисто тает на месте за 1000мс — медленный дорогой шлейф истории перехода */
+  transition: transform 1000ms cubic-bezier(0.16, 1, 0.3, 1), opacity 1000ms ease;
+}
+
+/* Панель фильтров слоёв (оверлей под шапкой) */
+.fg-filter-bar {
+  position: absolute;
+  top: max(54px, calc(env(safe-area-inset-top) + 50px));
+  left: 0;
+  right: 0;
+  z-index: 11;
+  display: flex;
+  justify-content: center;
+  flex-wrap: wrap;
+  gap: 8px;
+  padding: 0 12px;
+  pointer-events: none;
+}
+
+/* Стеклянные табы — тонкие пластины матового стекла (frosted glass) */
+.fg-filter-chip {
+  pointer-events: auto;
+  border: 0.5px solid rgba(255, 255, 255, 0.1);
+  background: rgba(255, 255, 255, 0.03);
+  backdrop-filter: blur(12px);
+  -webkit-backdrop-filter: blur(12px);
+  color: #cfe0ff;
+  font-size: 12px;
+  font-weight: 600;
+  line-height: 1;
+  padding: 7px 14px;
+  border-radius: 999px;
+  cursor: pointer;
+  box-shadow: inset 0 0.5px 0 rgba(255, 255, 255, 0.08); /* лёгкий стеклянный блик сверху */
+  transition: background 160ms ease, border-color 160ms ease, color 160ms ease, box-shadow 160ms ease;
+}
+
+/* Активный таб — то же стекло, но подсвеченное сине-голубым (в тон неону графа) */
+.fg-filter-chip.is-active {
+  background: rgba(125, 215, 255, 0.16);
+  border-color: rgba(160, 230, 255, 0.55);
+  color: #eaf7ff;
+  box-shadow: inset 0 0.5px 0 rgba(255, 255, 255, 0.12), 0 0 14px rgba(110, 210, 255, 0.28);
+}
+
+/* Контекстное меню узла (долгое нажатие) — в #modal-root, поверх всего, не масштабируется */
+.fg-menu-overlay {
+  position: fixed;
+  inset: 0;
+  z-index: 50;
+}
+
+.fg-menu {
+  position: fixed;
+  min-width: 210px;
+  padding: 8px;
+  display: grid;
+  gap: 3px;
+  background: rgba(16, 24, 40, 0.97);
+  border: 1px solid rgba(166, 196, 245, 0.28);
+  border-radius: 14px;
+  box-shadow: 0 16px 44px rgba(0, 0, 0, 0.55);
+  backdrop-filter: blur(14px);
+  -webkit-backdrop-filter: blur(14px);
+  z-index: 51;
+}
+
+.fg-menu-head {
+  display: flex;
+  justify-content: space-between;
+  align-items: baseline;
+  gap: 10px;
+  padding: 4px 8px 8px;
+  border-bottom: 1px solid rgba(255, 255, 255, 0.08);
+  margin-bottom: 3px;
+}
+
+.fg-menu-login {
+  font-weight: 700;
+  color: #eaf1ff;
+  font-size: 14px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.fg-menu-rel {
+  font-size: 11px;
+  color: #9fb6e0;
+  flex: 0 0 auto;
+}
+
+.fg-menu-item {
+  text-align: left;
+  background: transparent;
+  border: 0;
+  color: #dfe9ff;
+  font-size: 14px;
+  padding: 9px 10px;
+  border-radius: 9px;
+  cursor: pointer;
+}
+
+.fg-menu-item:hover {
+  background: rgba(77, 160, 255, 0.16);
+}
+
+.fg-menu-item.is-stub {
+  color: #7f8aa3;
+  cursor: default;
+}
+
+.fg-menu-item.is-stub:hover {
+  background: transparent;
+}
+
+/* Нижний сниппет (bottom sheet) */
+.fg-sheet {
+  position: absolute;
+  left: 12px;
+  right: 12px;
+  bottom: calc(12px + env(safe-area-inset-bottom));
+  z-index: 13;
+  display: none;
+  padding: 12px 14px 14px;
+  background: rgba(16, 24, 40, 0.95);
+  border: 1px solid rgba(166, 196, 245, 0.26);
+  border-radius: 16px;
+  box-shadow: 0 12px 32px rgba(0, 0, 0, 0.45);
+  backdrop-filter: blur(14px);
+  -webkit-backdrop-filter: blur(14px);
+}
+
+.fg-sheet.is-open {
+  display: block;
+  animation: fg-sheet-in 200ms ease;
+}
+
+@keyframes fg-sheet-in {
+  from { transform: translateY(16px); opacity: 0; }
+  to { transform: translateY(0); opacity: 1; }
+}
+
+.fg-sheet-close {
+  position: absolute;
+  top: 8px;
+  right: 10px;
+  background: transparent;
+  border: 0;
+  color: #9fb6e0;
+  font-size: 16px;
+  cursor: pointer;
+  line-height: 1;
+}
+
+.fg-sheet-title {
+  font-weight: 700;
+  font-size: 15px;
+  color: #eaf1ff;
+  display: flex;
+  gap: 8px;
+  align-items: center;
+}
+
+.fg-sheet-badge {
+  font-size: 10px;
+  background: rgba(130, 235, 255, 0.2);
+  color: #bff0ff;
+  padding: 2px 8px;
+  border-radius: 999px;
+  font-weight: 600;
+}
+
+.fg-sheet-rel {
+  font-size: 12px;
+  color: #9fb6e0;
+  margin-top: 3px;
+}
+
+.fg-sheet-actions {
+  display: flex;
+  gap: 8px;
+  margin-top: 12px;
+}
+
+.fg-sheet-actions > button {
+  flex: 1;
+}
+
+/* === Партия 2: бейдж-счётчик связей, поиск, хлебные крошки, цветовые кластеры ============ */
+
+/* Бейдж числа связей — маленькая пилюля в правом-верхнем углу аватарки */
+.fg-node-badge {
+  position: absolute;
+  top: -2px;
+  right: -2px;
+  min-width: 16px;
+  height: 16px;
+  padding: 0 4px;
+  border-radius: 999px;
+  background: rgba(16, 24, 40, 0.92);
+  border: 1px solid rgba(150, 200, 255, 0.5);
+  color: #d9ecff;
+  font-size: 9px;
+  font-weight: 700;
+  line-height: 14px;
+  text-align: center;
+  pointer-events: none;
+  box-shadow: 0 1px 4px rgba(0, 0, 0, 0.5);
+}
+.fg-node.is-focus .fg-node-badge {
+  background: rgba(61, 196, 223, 0.95);
+  border-color: rgba(220, 245, 255, 0.8);
+  color: #06131c;
+}
+.fg-node.is-tier2 .fg-node-badge { transform: scale(0.85); }
+
+/* Цветовые кластеры: мягкая аура узла по типу связи (визуально группирует «семью/друзей/бизнес») */
+.fg-node.is-family .node-dot { box-shadow: 0 0 16px rgba(255, 159, 94, 0.20); }
+.fg-node.is-friend .node-dot { box-shadow: 0 0 16px rgba(120, 179, 255, 0.20); }
+.fg-node.is-business .node-dot { box-shadow: 0 0 16px rgba(190, 150, 255, 0.20); }
+.fg-node.is-contact .node-dot { box-shadow: 0 0 16px rgba(170, 190, 220, 0.16); }
+/* сияющие/фокус — свой эффект свечения (см. выше), ауру кластера не навязываем */
+.fg-node.is-shine .node-dot, .fg-node.is-focus .node-dot { box-shadow: none; }
+
+/* Строка поиска (оверлей вверху, под панелью фильтров) */
+.fg-search {
+  position: absolute;
+  top: max(92px, calc(env(safe-area-inset-top) + 88px));
+  left: 50%;
+  transform: translateX(-50%);
+  z-index: 12;
+  width: min(280px, 70vw);
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 6px 12px;
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.04);
+  border: 0.5px solid rgba(255, 255, 255, 0.12);
+  backdrop-filter: blur(12px);
+  -webkit-backdrop-filter: blur(12px);
+  box-shadow: inset 0 0.5px 0 rgba(255, 255, 255, 0.08);
+}
+.fg-search input {
+  flex: 1;
+  border: 0;
+  background: transparent;
+  color: #eaf2ff;
+  font-size: 13px;
+  outline: none;
+}
+.fg-search input::placeholder { color: #7d8aa6; }
+.fg-search .fg-search-ico { color: #9fc0ff; font-size: 13px; }
+
+/* Хлебные крошки навигации (стек погружений: Иван › Нина › Ада) */
+.fg-breadcrumb {
+  position: absolute;
+  top: max(132px, calc(env(safe-area-inset-top) + 128px));
+  left: 0;
+  right: 0;
+  z-index: 12;
+  display: none;
+  justify-content: center;
+  flex-wrap: wrap;
+  gap: 4px;
+  padding: 0 12px;
+  pointer-events: none;
+}
+.fg-breadcrumb.is-open { display: flex; }
+.fg-crumb {
+  pointer-events: auto;
+  border: 0;
+  background: rgba(16, 24, 40, 0.7);
+  backdrop-filter: blur(8px);
+  -webkit-backdrop-filter: blur(8px);
+  color: #cfe0ff;
+  font-size: 11px;
+  font-weight: 600;
+  line-height: 1;
+  padding: 5px 10px;
+  border-radius: 999px;
+  cursor: pointer;
+  max-width: 110px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.fg-crumb.is-last {
+  background: rgba(125, 215, 255, 0.18);
+  color: #eaf7ff;
+  cursor: default;
+}
+.fg-crumb-sep { color: #5f7196; font-size: 11px; align-self: center; pointer-events: none; }
+
+/* Доступность: визуально скрытый список графа для скринридеров (sr-only, читается ассистивными технологиями) */
+.fg-a11y {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  margin: -1px;
+  padding: 0;
+  overflow: hidden;
+  clip: rect(0 0 0 0);
+  clip-path: inset(50%);
+  white-space: nowrap;
+  border: 0;
+}
+
+/* «Общая связь» (этот человек — и твой друг тоже): золотой ободок + ★ под аватаркой */
+.fg-node.is-common .node-dot {
+  border-color: rgba(255, 214, 120, 0.95);
+  box-shadow: 0 0 14px rgba(255, 200, 90, 0.4);
+}
+.fg-node.is-common .node-dot::after {
+  content: '★';
+  position: absolute;
+  bottom: -5px;
+  left: 50%;
+  transform: translateX(-50%);
+  font-size: 10px;
+  line-height: 1;
+  color: #ffd678;
+  text-shadow: 0 1px 3px rgba(0, 0, 0, 0.7);
+  pointer-events: none;
+}