feat(simulation): auto-build source mesh collision

feat(simulation): add Gaussian UGV runtime pipeline
2026-08-28 13:48:44 +03:00 · 2026-08-28 11:51:48 +03:00
1013 changed files with 7314 additions and 204824 deletions
@@ -62,40 +62,6 @@ and the boundary between Mission Core and vendor-specific integration code.
 - Synthetic or explicitly redacted fixtures may be committed under
  `tests/fixtures/`.

-## Insta360 and clean-host installation — owner requirement, 2026-09-08
-
- The current X4 starting point is USB enumeration only. SDK installation,
-  camera initialization and live video have not been accepted.
- Every Ubuntu change needed for Insta360 must execute through the shipped
-  installer or the application's versioned device-preparation workflow from
-  the first board experiment. Do not repair the board with an ad-hoc apt/pip
-  install, copied library, chmod, environment override, service edit or root
-  invocation and promise to package it later. Fix the product artifact first,
-  then rerun that artifact. Read-only engineering inspection remains allowed.
- Document every relevant action and its before/after evidence in
-  `docs/node/07_INSTA360_X4_INSTALLATION_LEDGER.md`; record the artifact version,
-  owning installer step, dependencies, idempotency, failure behavior and rollback.
-  Keep private logs/identifiers/media out of Git and redact their public summary.
- A working prepared Mini is not clean-Ubuntu acceptance. Qualify dependency
-  closure on the declared clean OS image and actual USB operation separately;
-  installer, preparation and GUI acceptance must use the same shipped code.
- X4 is operator live video and camera control (settings, photo, recording
-  start/stop and file access), per the owner’s subsequent scope expansion.
-  Preview and recording are separate operations. No stitching, AI, navigation
-  or vehicle-control integration is admitted. Model support and physical device instances are separate: several
-  cameras of the same model must retain independent identity and lifecycle.
- Follow the scoped implementation plan in
-  `docs/node/06_INSTA360_X4_AND_MULTI_CAMERA_PLAN.md`. It is a proposed plan,
-  not evidence that SDK compatibility, hardware capacity or installation passed.
- Subsequent owner direction: the existing Ubuntu Mini is the available build
-  and qualification machine; do not depend on Worker 006 or another host for
-  this X4 work. Its existing GCC may compile through a versioned build artifact
-  in bounded temporary staging. This is a build step, not runtime installation:
-  no system changes, SDK execution or camera access during compilation. The
-  final installer must carry the compiled payload so a clean operator Ubuntu
-  does not inherit an undeclared compiler/build-cache prerequisite. All board
-  staging/build/install/test actions remain documented and artifact-owned.
-
 ## Implementation order

 Follow the gates in `docs/01_IMPLEMENTATION_PLAN.md`. Do not build heavy
@@ -7,6 +7,7 @@
    "": {
      "name": "@nodedc/mission-core-control-station",
      "version": "0.1.0",
+      "hasInstallScript": true,
      "dependencies": {
        "@noble/hashes": "^2.2.0",
        "@nodedc/map-cesium-react": "file:../../../NODEDC_DESIGN_GUIDELINE/packages/map-cesium-react",
@@ -14,7 +15,7 @@
        "@nodedc/tokens": "file:../../../NODEDC_DESIGN_GUIDELINE/packages/tokens",
        "@nodedc/ui-core": "file:../../../NODEDC_DESIGN_GUIDELINE/packages/ui-core",
        "@nodedc/ui-react": "file:../../../NODEDC_DESIGN_GUIDELINE/packages/ui-react",
-        "@rerun-io/web-viewer": "0.36.3",
+        "@rerun-io/web-viewer": "0.34.1",
        "meshoptimizer": "1.1.1",
        "playcanvas": "2.21.4",
        "react": "^19.1.0",
@@ -899,9 +900,9 @@
      "link": true
    },
    "node_modules/@rerun-io/web-viewer": {
-      "version": "0.36.3",
-      "resolved": "https://registry.npmjs.org/@rerun-io/web-viewer/-/web-viewer-0.36.3.tgz",
-      "integrity": "sha512-LMGnsxRmY5UwiGras2dZrMnEYkow5Xr4v+1hAUSspXWPPiilMqoz9G77jo8Ps/deAaX81TnOq123DFO8iX/Ulw==",
+      "version": "0.34.1",
+      "resolved": "https://registry.npmjs.org/@rerun-io/web-viewer/-/web-viewer-0.34.1.tgz",
+      "integrity": "sha512-2Oq9Mw3qOs765XArGq4e/0pAIksPFKlAqkgo+PDsRkPd77/KdnQhb835suRmYQ6tuqlbPeVCFhlNIXT0+TjmTg==",
      "license": "MIT"
    },
    "node_modules/@rolldown/pluginutils": {
@@ -4,6 +4,7 @@
  "private": true,
  "type": "module",
  "scripts": {
+    "postinstall": "node scripts/patch-rerun-web-viewer.mjs",
    "dev": "vite",
    "build": "tsc -b && vite build",
    "preview": "vite preview",
@@ -17,7 +18,7 @@
    "@nodedc/tokens": "file:../../../NODEDC_DESIGN_GUIDELINE/packages/tokens",
    "@nodedc/ui-core": "file:../../../NODEDC_DESIGN_GUIDELINE/packages/ui-core",
    "@nodedc/ui-react": "file:../../../NODEDC_DESIGN_GUIDELINE/packages/ui-react",
-    "@rerun-io/web-viewer": "0.36.3",
+    "@rerun-io/web-viewer": "0.34.1",
    "meshoptimizer": "1.1.1",
    "playcanvas": "2.21.4",
    "react": "^19.1.0",
@@ -1,16 +0,0 @@
-<!doctype html>
-<html lang="ru">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Синхронизированная запись</title>
-    <style>
-      html, body, #viewer { width: 100%; height: 100%; margin: 0; overflow: hidden; }
-      canvas { display: block; }
-    </style>
-  </head>
-  <body>
-    <div id="viewer"></div>
-    <script type="module" src="/src/components/rerun/isolatedRerunEntry.ts"></script>
-  </body>
-</html>
@@ -1,5 +1,3 @@
-import {SceneDisplayControls} from "../../../packages/spatial-ui/src/SceneDisplayControls";
-import {SceneLayerControls} from "../../../packages/spatial-ui/src/SceneLayerControls";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
  AdminNavigationPanel,
@@ -7,11 +5,16 @@ import {
  ApplicationPanel,
  ApplicationShell,
  Button,
+  Checker,
+  ColorField,
  ControlRow,
  HeaderNavigation,
  HeaderProfile,
+  HeaderWorkspace,
  Icon,
  Inspector,
+  RangeControl,
+  Select,
  StatusBadge,
  TextField,
  UserProfileMenu,
@@ -64,6 +67,8 @@ import {
 import { backendLabel, localConnectionPhaseLabel, phaseTone } from "./presentation";
 import {
  defaultSceneSettings,
+  type PointColorMode,
+  type PointPalette,
  type SceneSettings,
 } from "./sceneSettings";
 import { DeviceWorkspace } from "./workspaces/DeviceWorkspace";
@@ -73,6 +78,22 @@ import "./styles/scene-windows.css";
 type SceneToolWindowId = "sources" | "display" | "layers";
 const viewerSettingsQuietPeriodMs = 750;

+const colorModeOptions: Array<{ value: PointColorMode; label: string; description: string }> = [
+  { value: "intensity", label: "Интенсивность", description: "Значение отражённого сигнала" },
+  { value: "height", label: "Высота Z", description: "Градиент по вертикальной координате" },
+  { value: "distance", label: "Расстояние", description: "Дальность точки от сенсора" },
+  { value: "rgb", label: "RGB", description: "Цвет, если он присутствует в данных" },
+  { value: "class", label: "Класс", description: "Категория внешнего модуля восприятия" },
+];
+
+const paletteOptions: Array<{ value: PointPalette; label: string; description: string }> = [
+  { value: "turbo", label: "Turbo", description: "Контрастный спектральный градиент" },
+  { value: "viridis", label: "Viridis", description: "Равномерный перцептивный градиент" },
+  { value: "plasma", label: "Plasma", description: "Тёплый контрастный градиент" },
+  { value: "grayscale", label: "Серый", description: "Монохромное отображение" },
+  { value: "custom", label: "Свой цвет", description: "Один назначенный цвет" },
+];
+
 interface LivePerceptionLayers {
  detections2d: boolean;
  segmentation: boolean;
@@ -608,10 +629,7 @@ export default function App() {
    return () => window.clearTimeout(timer);
  }, [layoutSaveNotice]);

-  const [fleetCreateRequest, setFleetCreateRequest] = useState(0);
-  const onAddVehicle = useCallback(() => setFleetCreateRequest(value => value + 1), []);
  const contentActions = useApplicationPanelActions({
-    onAddVehicle,
    definition: activeDefinition,
    refreshRuntime: runtime.refresh,
    resetConnectionScenario: runtime.resetConnectionScenario,
@@ -627,6 +645,8 @@ export default function App() {
      brandHref="/"
      brandLabel="NODEDC MISSION CORE"
      center={
+        <>
+          <HeaderWorkspace kind="mark" label="Mission Core" imageUrl="/nodedc-mark.svg" />
          <HeaderNavigation
            label="Архитектурные блоки пункта управления"
            value={activeRoot ?? undefined}
@@ -636,6 +656,7 @@ export default function App() {
            }))}
            onChange={selectRoot}
          />
+        </>
      }
      right={
        <HeaderProfile>
@@ -781,12 +802,10 @@ export default function App() {
                    settleRecordedReplaySwitch(outcome)}
                  onDeleteBegin={releaseRecordedReplayForDelete}
                />
-              ) : activeDefinition.kind === "vehicles" ? null : activeDefinition.kind === "datasets" ? (
+              ) : activeDefinition.kind === "datasets" ? (
                <StatusBadge tone="neutral">Offline evaluation</StatusBadge>
              ) : activeDefinition.kind === "lab-archive" ? (
                laboratoryAnnotation.control
-              ) : activeDefinition.kind === "observatory" ? (
-                <StatusBadge tone="neutral">Только наблюдение</StatusBadge>
              ) : activeDefinition.root === "system" ? (
                <SystemWorkspaceSelector
                  value={activeDefinition.id}
@@ -807,7 +826,6 @@ export default function App() {
            ) : (
              <WorkspaceRenderer
                definition={activeDefinition}
-                fleetCreateRequest={fleetCreateRequest}
                state={activeRuntimeState}
                backendStatus={runtime.backendStatus}
                sourceUrl={effectiveSourceUrl}
@@ -1009,8 +1027,132 @@ export default function App() {
        onPointerDown={() => activateSceneWindow("display")}
        onClose={() => closeSceneWindow("display")}
      >
-        <SceneDisplayControls displayDraft={displayDraft} stageDisplayPatch={stageDisplayPatch}
-          commitDisplayPatch={commitDisplayPatch} flushDisplaySettings={flushDisplaySettings} replayPresented={replayPresented}/>
+        <Inspector
+          defaultOpen={["points"]}
+          singleOpen
+          sections={[
+            {
+              id: "points",
+              label: "Облако точек",
+              description: "Размер и способ окрашивания",
+              content: (
+                <div className="inspector-control-stack">
+                  <div
+                    className="scene-settings-commit-field"
+                    onPointerUp={flushDisplaySettings}
+                    onKeyUp={flushDisplaySettings}
+                    onBlur={flushDisplaySettings}
+                  >
+                    <RangeControl
+                      label="Размер точки"
+                      value={displayDraft.pointSize}
+                      min={0.5}
+                      max={12}
+                      step={0.5}
+                      formatValue={(value) => `${value.toFixed(1)} пкс`}
+                      onChange={(pointSize) => stageDisplayPatch({ pointSize })}
+                    />
+                  </div>
+                  <div className="scene-settings-commit-field" onBlur={flushDisplaySettings}>
+                    <ControlRow label="Атрибут цвета">
+                      <Select
+                        variant="split"
+                        label="Атрибут цвета"
+                        value={displayDraft.colorMode}
+                        options={colorModeOptions}
+                        onChange={(colorMode) => stageDisplayPatch({ colorMode })}
+                      />
+                    </ControlRow>
+                  </div>
+                  <div className="scene-settings-commit-field" onBlur={flushDisplaySettings}>
+                    <ControlRow label="Палитра">
+                      <Select
+                        variant="split"
+                        label="Палитра"
+                        value={displayDraft.palette}
+                        options={paletteOptions}
+                        onChange={(palette) => stageDisplayPatch({ palette })}
+                      />
+                    </ControlRow>
+                  </div>
+                  {displayDraft.palette === "custom" || displayDraft.colorMode === "class" ? (
+                    <div
+                      className="scene-settings-commit-field"
+                      onPointerUp={flushDisplaySettings}
+                      onKeyUp={flushDisplaySettings}
+                      onBlur={flushDisplaySettings}
+                    >
+                      <ControlRow label="Цвет точек">
+                        <ColorField
+                          label="Цвет точек"
+                          value={displayDraft.customColor}
+                          onChange={(customColor) => stageDisplayPatch({ customColor })}
+                        />
+                      </ControlRow>
+                    </div>
+                  ) : null}
+                  {replayPresented ? (
+                    <p className="scene-window-note">
+                      Первый новый режим читает индекс архивных точек. Следующие палитры
+                      переключаются из подготовленного цветового кэша без переэкспорта геометрии.
+                    </p>
+                  ) : null}
+                </div>
+              ),
+            },
+            {
+              id: "history",
+              label: "Накопление и время",
+              description: "История облака и траектория",
+              content: (
+                <div className="inspector-control-stack">
+                  <div
+                    className="scene-settings-commit-field"
+                    onPointerUp={flushDisplaySettings}
+                    onKeyUp={flushDisplaySettings}
+                    onBlur={flushDisplaySettings}
+                  >
+                    <RangeControl
+                      label="Окно накопления"
+                      value={displayDraft.accumulationSeconds}
+                      min={0}
+                      max={120}
+                      step={1}
+                      formatValue={(value) => (value === 0 ? "Только кадр" : `${value} с`)}
+                      onChange={(accumulationSeconds) => stageDisplayPatch({ accumulationSeconds })}
+                    />
+                  </div>
+                  <div className="nodedc-field">
+                    <span className="nodedc-field__description">Линия пути устройства в координатах сцены</span>
+                    <Checker
+                      checked={displayDraft.showTrajectory}
+                      label="Показывать траекторию"
+                      onChange={(showTrajectory) => commitDisplayPatch({ showTrajectory })}
+                    />
+                  </div>
+                </div>
+              ),
+            },
+            {
+              id: "scene",
+              label: "Окружение сцены",
+              description: "Сетка, подписи и камеры",
+              content: (
+                <div className="inspector-control-stack">
+                  <Checker checked={displayDraft.showGrid} label="Сетка и оси" onChange={(showGrid) => commitDisplayPatch({ showGrid })} />
+                  <div className="nodedc-field">
+                    <span className="nodedc-field__description">Появятся после подключения семантических сущностей</span>
+                    <Checker checked={false} disabled label="Подписи сущностей" onChange={() => undefined} />
+                  </div>
+                  <div className="nodedc-field">
+                    <span className="nodedc-field__description">Камерный канал пока не подключён</span>
+                    <Checker checked={false} disabled label="Области обзора камер" onChange={() => undefined} />
+                  </div>
+                </div>
+              ),
+            },
+          ]}
+        />
      </Window>

      <Window
@@ -1036,7 +1178,64 @@ export default function App() {
          </span>
          <p>Структура повторяет продуктовые сущности, а не внутренние панели визуального движка.</p>
        </div>
-        <SceneLayerControls sceneSettings={sceneSettings} pending={runtime.pendingAction === "viewer"} applyScenePatch={applyScenePatch}/>
+        <Inspector
+          defaultOpen={["geometry"]}
+          singleOpen
+          sections={[
+            {
+              id: "geometry",
+              label: "Геометрия",
+              description: "Облако точек и путь",
+              content: (
+                <div className="inspector-control-stack">
+                  <div className="nodedc-field">
+                    <span className="nodedc-field__description">Основной поток геометрии лидара</span>
+                    <Checker disabled={runtime.pendingAction === "viewer"} checked={sceneSettings.showPoints} label="Облако точек" onChange={(showPoints) => void applyScenePatch({ showPoints })} />
+                  </div>
+                  <div className="nodedc-field">
+                    <span className="nodedc-field__description">Положение и ориентация устройства во времени</span>
+                    <Checker disabled={runtime.pendingAction === "viewer"} checked={sceneSettings.showTrajectory} label="Траектория" onChange={(showTrajectory) => void applyScenePatch({ showTrajectory })} />
+                  </div>
+                </div>
+              ),
+            },
+            {
+              id: "frames",
+              label: "Координаты и камеры",
+              description: "Преобразования и области обзора",
+              content: (
+                <div className="inspector-control-stack">
+                  <Checker disabled={runtime.pendingAction === "viewer"} checked={sceneSettings.showGrid} label="Сетка и оси" onChange={(showGrid) => void applyScenePatch({ showGrid })} />
+                  <div className="nodedc-field">
+                    <span className="nodedc-field__description">Камерный канал пока не подключён</span>
+                    <Checker checked={false} disabled label="Области обзора камер" onChange={() => undefined} />
+                  </div>
+                </div>
+              ),
+            },
+            {
+              id: "perception",
+              label: "Объекты и маски",
+              description: "Ожидают внешние обработчики",
+              content: (
+                <div className="inspector-control-stack">
+                  <div className="nodedc-field">
+                    <span className="nodedc-field__description">Внешний обработчик не подключён</span>
+                    <Checker checked={false} disabled label="Рамки 2D и 3D" onChange={() => undefined} />
+                  </div>
+                  <div className="nodedc-field">
+                    <span className="nodedc-field__description">Внешний обработчик не подключён</span>
+                    <Checker checked={false} disabled label="Маски сегментации" onChange={() => undefined} />
+                  </div>
+                  <div className="nodedc-field">
+                    <span className="nodedc-field__description">Внешний обработчик не подключён</span>
+                    <Checker checked={false} disabled label="Ключевые точки и треки" onChange={() => undefined} />
+                  </div>
+                </div>
+              ),
+            },
+          ]}
+        />
      </Window>
    </>
  );
@@ -1 +1,92 @@
-export { EnvironmentBackgroundMedia } from "@nodedc/ui-react";
+import { useEffect, useMemo, useState } from "react";
+
+import type {
+  EnvironmentBackground,
+  EnvironmentMediaItem,
+} from "../core/environment/environmentSettings";
+
+type ReadyEnvironmentMediaItem = EnvironmentMediaItem & {
+  url: string;
+  mediaKind: "image" | "video";
+};
+
+function isReadyMediaItem(
+  item: EnvironmentMediaItem,
+): item is ReadyEnvironmentMediaItem {
+  return Boolean(item.url && item.mediaKind);
+}
+
+export function EnvironmentBackgroundMedia({
+  background,
+}: {
+  background: EnvironmentBackground;
+}) {
+  const items = useMemo(
+    () => background.items.filter(isReadyMediaItem),
+    [background.items],
+  );
+  const playlistIdentity = items.map((item) => `${item.id}:${item.url}`).join("|");
+  const [activeIndex, setActiveIndex] = useState(0);
+  const [failedIds, setFailedIds] = useState<Set<string>>(new Set());
+  const playableItems = items.filter((item) => !failedIds.has(item.id));
+  const activeItem = playableItems[activeIndex] ?? playableItems[0] ?? null;
+
+  useEffect(() => {
+    setActiveIndex(0);
+    setFailedIds(new Set());
+  }, [playlistIdentity]);
+
+  useEffect(() => {
+    if (
+      !background.enabled
+      || !activeItem
+      || activeItem.mediaKind !== "image"
+      || playableItems.length < 2
+    ) {
+      return;
+    }
+    const timer = window.setTimeout(() => {
+      setActiveIndex((current) => (current + 1) % playableItems.length);
+    }, background.imageDurationSeconds * 1_000);
+    return () => window.clearTimeout(timer);
+  }, [
+    activeItem,
+    background.enabled,
+    background.imageDurationSeconds,
+    playableItems.length,
+  ]);
+
+  if (!background.enabled || !activeItem) return null;
+
+  return (
+    <div className="landing-stage__media" aria-hidden="true">
+      {activeItem.mediaKind === "video" ? (
+        <video
+          key={activeItem.url}
+          src={activeItem.url}
+          autoPlay
+          muted
+          loop={playableItems.length === 1}
+          playsInline
+          onEnded={() => setActiveIndex((current) => (
+            (current + 1) % playableItems.length
+          ))}
+          onError={() => {
+            setFailedIds((current) => new Set(current).add(activeItem.id));
+            setActiveIndex(0);
+          }}
+        />
+      ) : (
+        <img
+          key={activeItem.url}
+          src={activeItem.url}
+          alt=""
+          onError={() => {
+            setFailedIds((current) => new Set(current).add(activeItem.id));
+            setActiveIndex(0);
+          }}
+        />
+      )}
+    </div>
+  );
+}
@@ -1 +1,248 @@
-export { EnvironmentMediaPlaylistEditor } from "@nodedc/ui-react";
+import { useEffect, useMemo, useRef, useState } from "react";
+import {
+  Icon,
+  IconButton,
+  MediaSourceField,
+  RangeControl,
+  SortableList,
+} from "@nodedc/ui-react";
+
+import {
+  appendEnvironmentMediaItem,
+  inferEnvironmentMediaKind,
+  maxEnvironmentMediaItems,
+  removeEnvironmentMediaItem,
+  type EnvironmentBackground,
+  type EnvironmentMediaItem,
+  type EnvironmentSurfaceId,
+  type UploadedEnvironmentMedia,
+} from "../core/environment/environmentSettings";
+
+interface EnvironmentMediaPlaylistEditorProps {
+  surfaceId: EnvironmentSurfaceId;
+  background: EnvironmentBackground;
+  disabled: boolean;
+  error: string | null;
+  onChange: (background: EnvironmentBackground) => void;
+  onBusyChange: (busy: boolean) => void;
+  onUpload: (
+    surfaceId: EnvironmentSurfaceId,
+    itemId: string,
+    file: File,
+  ) => Promise<UploadedEnvironmentMedia>;
+}
+
+const acceptedEnvironmentMedia = [
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp",
+  "image/avif",
+  "video/mp4",
+  "video/webm",
+  "video/quicktime",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".avif",
+  ".mp4",
+  ".webm",
+  ".mov",
+].join(",");
+
+function patchItem(
+  background: EnvironmentBackground,
+  itemId: string,
+  patch: Partial<EnvironmentMediaItem>,
+): EnvironmentBackground {
+  return {
+    ...background,
+    items: background.items.map((item) => (
+      item.id === itemId ? { ...item, ...patch } : item
+    )),
+  };
+}
+
+export function EnvironmentMediaPlaylistEditor({
+  surfaceId,
+  background,
+  disabled,
+  error,
+  onChange,
+  onBusyChange,
+  onUpload,
+}: EnvironmentMediaPlaylistEditorProps) {
+  const [uploadingIds, setUploadingIds] = useState<Set<string>>(new Set());
+  const [itemErrors, setItemErrors] = useState<Record<string, string>>({});
+  const backgroundRef = useRef(background);
+  backgroundRef.current = background;
+  const displayedItems = useMemo(
+    () => [...background.items].reverse(),
+    [background.items],
+  );
+
+  useEffect(() => {
+    onBusyChange(uploadingIds.size > 0);
+  }, [onBusyChange, uploadingIds.size]);
+
+  useEffect(() => () => onBusyChange(false), [onBusyChange]);
+
+  const setItemError = (itemId: string, message?: string) => {
+    setItemErrors((current) => {
+      const next = { ...current };
+      if (message) next[itemId] = message;
+      else delete next[itemId];
+      return next;
+    });
+  };
+
+  const uploadFile = async (itemId: string, file?: File) => {
+    if (!file) return;
+    setUploadingIds((current) => new Set(current).add(itemId));
+    setItemError(itemId);
+    try {
+      const uploaded = await onUpload(surfaceId, itemId, file);
+      onChange(patchItem(backgroundRef.current, itemId, {
+        source: "file",
+        url: uploaded.url,
+        mediaKind: uploaded.mediaKind,
+        fileName: uploaded.fileName,
+      }));
+    } catch (reason) {
+      setItemError(
+        itemId,
+        reason instanceof Error
+          ? reason.message
+          : "Не удалось загрузить медиаконтент.",
+      );
+    } finally {
+      setUploadingIds((current) => {
+        const next = new Set(current);
+        next.delete(itemId);
+        return next;
+      });
+    }
+  };
+
+  return (
+    <div className="environment-media-playlist">
+      <div className="environment-media-playlist__head">
+        <div>
+          <span>Видео / картинка</span>
+          <p>MP4, WebM, MOV, PNG, JPEG, GIF, WebP или AVIF · до 256 МБ.</p>
+        </div>
+        <IconButton
+          label="Добавить медиаконтент"
+          disabled={disabled || background.items.length >= maxEnvironmentMediaItems}
+          onClick={() => onChange(appendEnvironmentMediaItem(background))}
+        >
+          <Icon name="plus" />
+        </IconButton>
+      </div>
+
+      {displayedItems.length ? (
+        <SortableList
+          items={displayedItems}
+          getId={(item) => item.id}
+          className="environment-media-playlist__items"
+          onReorder={(items) => onChange({
+            ...background,
+            items: [...items].reverse(),
+          })}
+        >
+          {(item, { handle }) => {
+            const playbackIndex = background.items.findIndex(
+              (candidate) => candidate.id === item.id,
+            );
+            return (
+              <div className="environment-media-playlist__item">
+                <MediaSourceField
+                  label={`Медиаконтент ${String(playbackIndex + 1).padStart(2, "0")}`}
+                  kindLabel={item.mediaKind ?? "media"}
+                  source={item.source}
+                  url={item.url ?? ""}
+                  fileName={item.fileName}
+                  uploading={uploadingIds.has(item.id)}
+                  previewSrc={item.url}
+                  previewKind={item.mediaKind}
+                  accept={acceptedEnvironmentMedia}
+                  path={`${surfaceId}.background.items[${playbackIndex}] → server environment media`}
+                  hint="Файл сохраняется в Mission Core data root. URL должен вести прямо на media по HTTP(S)."
+                  error={itemErrors[item.id] ?? (
+                    playbackIndex === background.items.length - 1 ? error : null
+                  )}
+                  onSourceChange={(source) => {
+                    if (source === item.source) return;
+                    setItemError(item.id);
+                    onChange(patchItem(background, item.id, {
+                      source,
+                      url: null,
+                      mediaKind: null,
+                      fileName: null,
+                    }));
+                  }}
+                  onUrlChange={(url) => {
+                    setItemError(item.id);
+                    onChange(patchItem(background, item.id, {
+                      source: "url",
+                      url: url || null,
+                      mediaKind: url ? inferEnvironmentMediaKind(url) : null,
+                      fileName: null,
+                    }));
+                  }}
+                  onFileChange={(file) => void uploadFile(item.id, file)}
+                />
+                <div className="environment-media-playlist__item-actions">
+                  <IconButton
+                    label={`Удалить медиаконтент ${playbackIndex + 1}`}
+                    disabled={disabled || uploadingIds.has(item.id)}
+                    onClick={() => {
+                      setItemError(item.id);
+                      onChange(removeEnvironmentMediaItem(background, item.id));
+                    }}
+                  >
+                    <Icon name="trash" />
+                  </IconButton>
+                  {handle}
+                </div>
+              </div>
+            );
+          }}
+        </SortableList>
+      ) : (
+        <>
+          <p className="environment-media-playlist__empty">
+            Добавьте первый файл или прямую ссылку на медиаконтент.
+          </p>
+          {error ? (
+            <p className="environment-media-playlist__error" role="alert">
+              {error}
+            </p>
+          ) : null}
+        </>
+      )}
+
+      <div className="environment-media-playlist__timing">
+        <RangeControl
+          label="Показывать изображение"
+          value={background.imageDurationSeconds}
+          min={1}
+          max={60}
+          step={1}
+          disabled={disabled}
+          formatValue={(value) => `${value} с`}
+          onChange={(imageDurationSeconds) => onChange({
+            ...background,
+            imageDurationSeconds,
+          })}
+        />
+        <span>
+          Новые элементы появляются сверху. Воспроизведение начинается снизу;
+          перетаскивание меняет порядок.
+        </span>
+      </div>
+    </div>
+  );
+}
@@ -1,25 +1,358 @@
-import { EnvironmentSettingsWindow as SharedEnvironmentSettingsWindow } from "@nodedc/ui-react";
-import { environmentSurfaceIds, type EnvironmentSettings, type EnvironmentSurfaceId, type UploadedEnvironmentMedia } from "../core/environment/environmentSettings";
-import { roots, workspaces, workspacesForRoot } from "../productModel";
+import { useEffect, useMemo, useState } from "react";
+import {
+  Button,
+  FeatureSettingsWindow,
+  Select,
+  SettingsCard,
+  Switch,
+  TextAreaField,
+  TextField,
+  WindowFooterActions,
+} from "@nodedc/ui-react";

-interface Props {
+import {
+  cloneEnvironmentSettings,
+  type EnvironmentBackground,
+  type EnvironmentPage,
+  type EnvironmentSettings,
+  type EnvironmentSurfaceId,
+  type UploadedEnvironmentMedia,
+} from "../core/environment/environmentSettings";
+import { EnvironmentMediaPlaylistEditor } from "./EnvironmentMediaPlaylistEditor";
+import {
+  roots,
+  workspaces,
+  workspacesForRoot,
+} from "../productModel";
+
+interface EnvironmentSettingsWindowProps {
  open: boolean;
  settings: EnvironmentSettings;
  state: "loading" | "ready" | "saving" | "error";
  error: string | null;
  onClose: () => void;
  onSave: (settings: EnvironmentSettings) => Promise<EnvironmentSettings>;
-  onUpload: (surfaceId: EnvironmentSurfaceId, itemId: string, file: File) => Promise<UploadedEnvironmentMedia>;
+  onUpload: (
+    surfaceId: EnvironmentSurfaceId,
+    itemId: string,
+    file: File,
+  ) => Promise<UploadedEnvironmentMedia>;
 }
-const surfaces = environmentSurfaceIds.map(id => ({
-  id, home: id === "home", description: id === "home" ? "Главная страница продукта" : `Стартовая страница раздела «${roots.find(root => root.id === id)?.label}»`,
-  actions: id === "home" ? workspaces.filter(item => !item.internalOnly) : workspacesForRoot(id),
-}));
-export function EnvironmentSettingsWindow(props: Props) {
-  return <SharedEnvironmentSettingsWindow {...props} productName="Mission Core" surfaces={surfaces} initialSurfaceId="fleet"
-    onSave={draft => props.onSave({ ...draft, pages: Object.fromEntries(environmentSurfaceIds.map(id => [id, draft.pages[id]])) as EnvironmentSettings["pages"] })}
-    onUpload={(id, itemId, file) => {
-      if (!environmentSurfaceIds.includes(id as EnvironmentSurfaceId)) throw new Error("Страница окружения недоступна.");
-      return props.onUpload(id as EnvironmentSurfaceId, itemId, file);
-    }} />;
+
+function patchPage(
+  draft: EnvironmentSettings,
+  surfaceId: EnvironmentSurfaceId,
+  patch: Partial<EnvironmentPage>,
+): EnvironmentSettings {
+  return {
+    ...draft,
+    pages: {
+      ...draft.pages,
+      [surfaceId]: {
+        ...draft.pages[surfaceId],
+        ...patch,
+      },
+    },
+  };
+}
+
+function patchBackground(
+  draft: EnvironmentSettings,
+  surfaceId: EnvironmentSurfaceId,
+  patch: Partial<EnvironmentBackground>,
+): EnvironmentSettings {
+  const page = draft.pages[surfaceId];
+  return patchPage(draft, surfaceId, {
+    background: {
+      ...page.background,
+      ...patch,
+    },
+  });
+}
+
+export function EnvironmentSettingsWindow({
+  open,
+  settings,
+  state,
+  error,
+  onClose,
+  onSave,
+  onUpload,
+}: EnvironmentSettingsWindowProps) {
+  const [draft, setDraft] = useState(() => cloneEnvironmentSettings(settings));
+  const [surfaceId, setSurfaceId] = useState<EnvironmentSurfaceId>("fleet");
+  const [uploading, setUploading] = useState(false);
+  const [localError, setLocalError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!open) return;
+    setDraft(cloneEnvironmentSettings(settings));
+    setLocalError(null);
+  }, [open, settings]);
+
+  const selectedPage = draft.pages[surfaceId];
+  const selectedBackground = selectedPage.background;
+  const pageOptions = useMemo(() => [
+    {
+      value: "home" as const,
+      label: draft.pages.home.headerLabel,
+      description: "Главная страница продукта",
+    },
+    ...roots.map((root) => ({
+      value: root.id,
+      label: draft.pages[root.id].headerLabel,
+      description: `Стартовая страница раздела «${draft.pages[root.id].title}»`,
+    })),
+  ], [draft.pages]);
+  const quickActionWorkspaces = useMemo(
+    () => surfaceId === "home"
+      ? workspaces.filter((workspace) => !workspace.internalOnly)
+      : workspacesForRoot(surfaceId),
+    [surfaceId],
+  );
+  const quickActionOptions = useMemo(() => [
+    {
+      value: "none",
+      label: "Не показывать",
+      description: "Кнопка скрыта на стартовом экране",
+    },
+    ...quickActionWorkspaces.map((workspace) => ({
+      value: workspace.id,
+      label: workspace.label,
+      description: workspace.description,
+    })),
+  ], [quickActionWorkspaces]);
+  const dirty = useMemo(
+    () => JSON.stringify(draft) !== JSON.stringify(settings),
+    [draft, settings],
+  );
+  const busy = state === "saving" || uploading;
+
+  const updatePage = (patch: Partial<EnvironmentPage>) => {
+    setDraft((current) => patchPage(current, surfaceId, patch));
+  };
+
+  const save = async () => {
+    const invalid = Object.entries(draft.pages).find(([, page]) => (
+      !page.headerLabel.trim()
+      || !page.eyebrow.trim()
+      || !page.title.trim()
+      || !page.description.trim()
+    ));
+    if (invalid) {
+      setLocalError("Название, надзаголовок, заголовок и описание не могут быть пустыми.");
+      return;
+    }
+    if (
+      selectedPage.primaryWorkspaceId
+      && selectedPage.primaryWorkspaceId === selectedPage.secondaryWorkspaceId
+    ) {
+      setLocalError("Быстрые кнопки должны вести на разные рабочие поверхности.");
+      return;
+    }
+    const invalidMedia = Object.entries(draft.pages).find(([, page]) => (
+      (page.background.enabled && !page.background.items.length)
+      || page.background.items.some((item) => {
+        if (!item.url || !item.mediaKind) return true;
+        if (item.source !== "url") return false;
+        try {
+          const parsed = new URL(item.url);
+          return !["http:", "https:"].includes(parsed.protocol);
+        } catch {
+          return true;
+        }
+      })
+    ));
+    if (invalidMedia) {
+      setSurfaceId(invalidMedia[0] as EnvironmentSurfaceId);
+      setLocalError(
+        "Каждый элемент фона должен содержать загруженный файл или прямой HTTP(S) URL.",
+      );
+      return;
+    }
+    setLocalError(null);
+    try {
+      await onSave({
+        ...draft,
+        pages: Object.fromEntries(
+          Object.entries(draft.pages).map(([id, page]) => [id, {
+            ...page,
+            headerLabel: page.headerLabel.trim(),
+            eyebrow: page.eyebrow.trim(),
+            title: page.title.trim(),
+            description: page.description.trim(),
+          }]),
+        ) as EnvironmentSettings["pages"],
+      });
+      onClose();
+    } catch (reason) {
+      setLocalError(reason instanceof Error
+        ? reason.message
+        : "Не удалось сохранить настройки окружения.");
+    }
+  };
+
+  return (
+    <FeatureSettingsWindow
+      open={open}
+      title="Настройки Mission Core"
+      subtitle="Локальное операторское окружение"
+      identity={{
+        title: "DC",
+        subtitle: "Mission Core",
+        avatarLabel: "DC",
+      }}
+      sections={[
+        {
+          id: "environment",
+          label: "Окружение",
+          group: "MISSION CORE",
+          icon: "settings",
+        },
+      ]}
+      activeSection="environment"
+      onSectionChange={() => undefined}
+      onClose={onClose}
+      footer={(
+        <WindowFooterActions>
+          <Button
+            variant="secondary"
+            disabled={!dirty || busy}
+            onClick={() => {
+              setDraft(cloneEnvironmentSettings(settings));
+              setLocalError(null);
+            }}
+          >
+            Сбросить изменения
+          </Button>
+          <Button
+            variant="primary"
+            disabled={!dirty || busy}
+            onClick={() => void save()}
+          >
+            {state === "saving" ? "Сохраняем…" : "Сохранить"}
+          </Button>
+        </WindowFooterActions>
+      )}
+    >
+      <div className="environment-settings">
+        <SettingsCard
+          eyebrow="ОКРУЖЕНИЕ"
+          title="Основные элементы управления"
+          description="Выберите страницу и настройте её название в шапке, содержание стартового экрана, подложку и быстрые переходы."
+          actions={(
+            <Switch
+              checked={selectedBackground.enabled}
+              label="Показывать фон"
+              onChange={(enabled) => {
+                if (enabled && !selectedBackground.items.length) {
+                  setLocalError("Сначала добавьте медиаконтент.");
+                  return;
+                }
+                setLocalError(null);
+                setDraft((current) =>
+                  patchBackground(current, surfaceId, { enabled }));
+              }}
+            />
+          )}
+        >
+          <div className="environment-settings__editor">
+            <div className="environment-settings__surface">
+              <span>Страница</span>
+              <Select
+                label="Выбрать страницу окружения"
+                value={surfaceId}
+                options={pageOptions}
+                variant="split"
+                menuWidth="anchor"
+                onChange={(value) => {
+                  setSurfaceId(value);
+                  setLocalError(null);
+                }}
+              />
+            </div>
+
+            <div className="environment-settings__copy">
+              <TextField
+                label={surfaceId === "home" ? "Название продукта" : "Название в шапке"}
+                value={selectedPage.headerLabel}
+                maxLength={40}
+                onChange={(event) => updatePage({
+                  headerLabel: event.currentTarget.value,
+                })}
+              />
+              <TextField
+                label="Надзаголовок"
+                value={selectedPage.eyebrow}
+                maxLength={80}
+                onChange={(event) => updatePage({
+                  eyebrow: event.currentTarget.value,
+                })}
+              />
+              <TextField
+                label="Основной заголовок"
+                value={selectedPage.title}
+                maxLength={120}
+                onChange={(event) => updatePage({
+                  title: event.currentTarget.value,
+                })}
+              />
+              <TextAreaField
+                label="Описание"
+                value={selectedPage.description}
+                maxLength={500}
+                rows={3}
+                onChange={(event) => updatePage({
+                  description: event.currentTarget.value,
+                })}
+              />
+            </div>
+
+            <div className="environment-settings__quick-actions">
+              <div>
+                <span>Кнопка 1</span>
+                <Select
+                  label="Выбрать первую быструю кнопку"
+                  value={selectedPage.primaryWorkspaceId ?? "none"}
+                  options={quickActionOptions}
+                  variant="split"
+                  menuWidth="anchor"
+                  onChange={(value) => updatePage({
+                    primaryWorkspaceId: value === "none" ? null : value,
+                  })}
+                />
+              </div>
+              <div>
+                <span>Кнопка 2</span>
+                <Select
+                  label="Выбрать вторую быструю кнопку"
+                  value={selectedPage.secondaryWorkspaceId ?? "none"}
+                  options={quickActionOptions}
+                  variant="split"
+                  menuWidth="anchor"
+                  onChange={(value) => updatePage({
+                    secondaryWorkspaceId: value === "none" ? null : value,
+                  })}
+                />
+              </div>
+            </div>
+
+            <EnvironmentMediaPlaylistEditor
+              surfaceId={surfaceId}
+              background={selectedBackground}
+              disabled={busy}
+              error={localError ?? error}
+              onBusyChange={setUploading}
+              onChange={(background) => {
+                setLocalError(null);
+                setDraft((current) =>
+                  patchBackground(current, surfaceId, background));
+              }}
+              onUpload={onUpload}
+            />
+          </div>
+        </SettingsCard>
+      </div>
+    </FeatureSettingsWindow>
+  );
 }
@@ -1,6 +1,5 @@
-import type {RefObject} from "react";
-import {FloatingMediaWindow} from "../../../../packages/spatial-ui/src/FloatingMediaWindow";
-export {initialObservationWindowRect,shouldCaptureWorkspacePointer} from "../../../../packages/spatial-ui/src/FloatingMediaWindow";
+import { useLayoutEffect, useState, type RefObject } from "react";
+import { WorkspaceWindow } from "@nodedc/ui-react";

 import type { ObservationWindowRect } from "../core/observation/useObservationLayout";
 import type { ObservationSourceDescriptor } from "../core/runtime/contracts";
@@ -11,6 +10,60 @@ import type {
  RecordedCameraAdmissionState,
 } from "../core/observation/recordedSessionAdmission";

+const WINDOW_WIDTH = 336;
+const WINDOW_HEIGHT = 210;
+const WINDOW_GAP = 16;
+const WINDOW_INSET = 18;
+const TIMELINE_CLEARANCE = 64;
+
+type ClosestTarget = { closest: (selectors: string) => unknown };
+
+export function shouldCaptureWorkspacePointer(
+  button: number,
+  target: ClosestTarget | null,
+): boolean {
+  if (button !== 0 || !target) return false;
+  if (target.closest(".nodedc-workspace-window__resize")) return true;
+  if (!target.closest(".nodedc-workspace-window__head")) return false;
+  return !target.closest("button, input, select, textarea, a");
+}
+
+export function initialObservationWindowRect(
+  index: number,
+  count = 1,
+  bounds: { width: number; height: number } = { width: 1280, height: 720 },
+): ObservationWindowRect {
+  const availableWidth = Math.max(0, bounds.width - WINDOW_INSET * 2);
+  const width = Math.max(1, Math.min(WINDOW_WIDTH, availableWidth || WINDOW_WIDTH));
+  const availableHeight = Math.max(0, bounds.height - WINDOW_INSET - TIMELINE_CLEARANCE);
+  const maxColumns = Math.max(
+    1,
+    Math.floor((availableWidth + WINDOW_GAP) / (width + WINDOW_GAP)),
+  );
+  const columns = Math.max(1, Math.min(Math.max(1, count), maxColumns));
+  const rows = Math.max(1, Math.ceil(Math.max(1, count) / columns));
+  const rowHeight = Math.max(
+    1,
+    (availableHeight - Math.max(0, rows - 1) * WINDOW_GAP) / rows,
+  );
+  const height = Math.max(1, Math.min(WINDOW_HEIGHT, rowHeight));
+  const row = Math.floor(index / columns);
+  const column = index % columns;
+  const rowItemCount = Math.min(columns, Math.max(1, count - row * columns));
+  const rowWidth = rowItemCount * width + Math.max(0, rowItemCount - 1) * WINDOW_GAP;
+  const rowStart = Math.max(0, bounds.width - WINDOW_INSET - rowWidth);
+
+  return {
+    x: rowStart + Math.min(column, rowItemCount - 1) * (width + WINDOW_GAP),
+    y: Math.max(
+      0,
+      bounds.height - TIMELINE_CLEARANCE - height - row * (height + WINDOW_GAP),
+    ),
+    width,
+    height,
+  };
+}
+
 export function FloatingObservationWindow({
  source,
  index,
@@ -51,12 +104,76 @@ export function FloatingObservationWindow({
    state: RecordedCameraAdmissionState,
  ) => void;
 }) {
-  return <FloatingMediaWindow title={source.label} subtitle={source.description}
-    index={index} count={count} boundsRef={boundsRef} rect={rect} maximized={maximized}
-    active={active} hidden={hidden} onRectChange={onRectChange} onMaximizedChange={onMaximizedChange}
-    onActivate={onActivate} onClose={onClose} resizable={source.capabilities.resizable}
-    status={<span className="floating-observation-window__status"><i data-availability={source.availability} aria-hidden="true"/>{observationSourceStatusLabel(source)}</span>}
-    footer={<span className="floating-observation-window__footer"><span>{source.endpointLabel || source.transport}</span><span>{source.capabilities.timelineMode === "live-only" ? "Эфир без буфера" : "Временная шкала"}</span></span>}>
+  const [bounds, setBounds] = useState<{ width: number; height: number } | null>(null);
+
+  useLayoutEffect(() => {
+    const element = boundsRef.current;
+    if (!element) return;
+
+    const measure = () => {
+      const next = { width: element.clientWidth, height: element.clientHeight };
+      setBounds((current) => (
+        current?.width === next.width && current.height === next.height ? current : next
+      ));
+    };
+
+    measure();
+    const observer = new ResizeObserver(measure);
+    observer.observe(element);
+    return () => observer.disconnect();
+  }, [boundsRef]);
+
+  // Camera media admission must not wait for the viewport observer. A source
+  // can arrive in the same commit as a workspace transition; mounting it with
+  // the canonical fallback geometry keeps the browser transport alive until
+  // the real bounds are measured immediately afterward.
+  const initialRect = initialObservationWindowRect(index, count, bounds ?? undefined);
+  const windowRect = rect ?? initialRect;
+
+  return (
+    <WorkspaceWindow
+      boundsRef={boundsRef}
+      rect={windowRect}
+      onRectChange={onRectChange}
+      maximized={maximized}
+      onMaximizedChange={onMaximizedChange}
+      onActivate={onActivate}
+      onClose={onClose}
+      title={source.label}
+      subtitle={source.description}
+      status={(
+        <span className="floating-observation-window__status">
+          <i data-availability={source.availability} aria-hidden="true" />
+          {observationSourceStatusLabel(source)}
+        </span>
+      )}
+      footer={(
+        <span className="floating-observation-window__footer">
+          <span>{source.endpointLabel || source.transport}</span>
+          <span>{source.capabilities.timelineMode === "live-only" ? "Эфир без буфера" : "Временная шкала"}</span>
+        </span>
+      )}
+      minWidth={Math.min(280, windowRect.width)}
+      minHeight={Math.min(190, windowRect.height)}
+      resizable={source.capabilities.resizable}
+      active={active}
+      zIndex={maximized ? 15 : active ? 9 : 7}
+      className={`floating-observation-window${hidden ? " floating-observation-window--hidden" : ""}`}
+      onPointerDownCapture={(event) => {
+        if (!shouldCaptureWorkspacePointer(event.button, event.target as HTMLElement)) return;
+        try {
+          event.currentTarget.setPointerCapture(event.pointerId);
+        } catch {
+          // Pointer capture can fail if the browser ended the pointer between
+          // dispatch and capture. The donor's window listeners remain fallback.
+        }
+      }}
+      closeLabel={`Закрыть ${source.label}`}
+      maximizeLabel={`Развернуть ${source.label}`}
+      restoreLabel={`Восстановить ${source.label}`}
+      moveLabel={`Переместить ${source.label}`}
+      resizeLabel={`Изменить размер ${source.label}`}
+    >
      <ObservationMedia
        source={source}
        playback={playback}
@@ -65,5 +182,6 @@ export function FloatingObservationWindow({
        recordedAdmissionKey={recordedAdmissionKey}
        onRecordedAdmissionChange={onRecordedAdmissionChange}
      />
-  </FloatingMediaWindow>;
+    </WorkspaceWindow>
+  );
 }
@@ -1,9 +1,10 @@
-import { LandingStage as SharedLandingStage, StatusBadge } from "@nodedc/ui-react";
+import { Button, Icon, StatusBadge } from "@nodedc/ui-react";

 import type { BackendStatus, RuntimePhase } from "../core/runtime/contracts";
 import type { EnvironmentPage } from "../core/environment/environmentSettings";
 import type { RootDefinition, WorkspaceDefinition } from "../productModel";
 import { backendLabel, backendTone, phaseLabel, phaseTone } from "../presentation";
+import { EnvironmentBackgroundMedia } from "./EnvironmentBackgroundMedia";

 export interface LandingStageProps {
  root: RootDefinition | null;
@@ -24,10 +25,40 @@ export function LandingStage({
  quickActions,
  onOpenWorkspace,
 }: LandingStageProps) {
-  return <SharedLandingStage page={page} pageId={root?.id ?? "home"}
-    actions={quickActions.map(workspace => ({ id: workspace.id, label: workspace.label, icon: workspace.icon, onSelect: () => onOpenWorkspace(workspace.id) }))}
-    status={<>
-<div>
+  const { background } = page;
+  const hasMedia = background.enabled && background.items.some(
+    (item) => item.url && item.mediaKind,
+  );
+  return (
+    <section
+      className="landing-stage"
+      data-root={root?.id ?? "home"}
+      data-has-media={hasMedia ? "true" : undefined}
+    >
+      <EnvironmentBackgroundMedia background={background} />
+      <div className="landing-stage__shade" aria-hidden="true" />
+      <div className="landing-stage__copy">
+        <span className="section-eyebrow">{page.eyebrow}</span>
+        <h1>{page.title}</h1>
+        <p>{page.description}</p>
+        {quickActions.length ? (
+          <div className="landing-stage__actions">
+            {quickActions.map((workspace, index) => (
+              <Button
+                key={workspace.id}
+                variant={index === 0 ? "primary" : "secondary"}
+                icon={<Icon name={workspace.icon} />}
+                onClick={() => onOpenWorkspace(workspace.id)}
+              >
+                {workspace.label}
+              </Button>
+            ))}
+          </div>
+        ) : null}
+      </div>
+
+      <div className="landing-stage__status">
+        <div>
          <span className="section-eyebrow">ЛОКАЛЬНЫЙ КОНТУР</span>
          <StatusBadge tone={backendTone(backendStatus)}>{backendLabel(backendStatus)}</StatusBadge>
        </div>
@@ -36,9 +67,12 @@ export function LandingStage({
          <StatusBadge tone={phaseTone(phase)}>{phaseLabel(phase)}</StatusBadge>
        </div>
        <p>{message || "Выберите архитектурный блок в верхней навигации."}</p>
-    </>}
-    footer={<>
-<span>{root?.accent ?? "НАБЛЮДЕНИЕ · МИССИИ · ДАННЫЕ"}</span>
+      </div>
+
+      <footer className="landing-stage__footer">
+        <span>{root?.accent ?? "НАБЛЮДЕНИЕ · МИССИИ · ДАННЫЕ"}</span>
        <span>01 / ЛОКАЛЬНЫЙ СТЕНД</span>
-    </>} />;
+      </footer>
+    </section>
+  );
 }
@@ -1,9 +1,9 @@
-import {sourceIcon,observationSourceStatusLabel} from "../../../../packages/spatial-ui/src/ObservationSourcePicker";
-export {ObservationSourcePicker,observationSourceStatusLabel} from "../../../../packages/spatial-ui/src/ObservationSourcePicker";
-import { Icon } from "@nodedc/ui-react";
+import { Dropdown, Icon, type IconName } from "@nodedc/ui-react";

 import type {
+  ObservationSourceAvailability,
  ObservationSourceDescriptor,
+  ObservationSourceModality,
 } from "../core/runtime/contracts";
 import { MseFmp4WebSocketPlayer } from "./MseFmp4WebSocketPlayer";
 import {
@@ -16,6 +16,28 @@ import type {
 } from "../core/observation/recordedSessionAdmission";
 import { liveCameraPlaybackAuthorityIdentity } from "../core/observation/liveCameraRecovery";

+const sourceIcon: Record<ObservationSourceModality, IconName> = {
+  "point-cloud": "globe",
+  video: "video",
+  image: "image",
+  depth: "image",
+};
+
+const availabilityCopy: Record<ObservationSourceAvailability, string> = {
+  unverified: "Не подтверждён",
+  declared: "Канал объявлен",
+  available: "Доступен",
+  connecting: "Подключение",
+  streaming: "Эфир",
+  degraded: "Нестабильно",
+  unavailable: "Недоступен",
+  error: "Ошибка",
+};
+
+export function observationSourceStatusLabel(source: ObservationSourceDescriptor): string {
+  return availabilityCopy[source.availability];
+}
+
 export function ObservationMedia({
  source,
  playback,
@@ -137,3 +159,105 @@ export function ObservationMedia({
    </div>
  );
 }
+
+export function ObservationSourcePicker({
+  sources,
+  visibleSourceIds,
+  pendingSourceIds,
+  onToggle,
+}: {
+  sources: readonly ObservationSourceDescriptor[];
+  visibleSourceIds: ReadonlySet<string>;
+  pendingSourceIds?: ReadonlySet<string>;
+  onToggle: (sourceId: string) => void | Promise<boolean>;
+}) {
+  const visibleCount = sources.filter((source) => visibleSourceIds.has(source.id)).length;
+
+  return (
+    <Dropdown
+      className="scene-source-picker"
+      placement="bottom-start"
+      width={340}
+      offset={10}
+      surfaceRole="dialog"
+      surfaceClassName="observation-source-menu"
+      trigger={({ open, toggle, setAnchorRef, setTriggerRef, surfaceId }) => (
+        <button
+          ref={(node) => {
+            setAnchorRef(node);
+            setTriggerRef(node);
+          }}
+          type="button"
+          className="scene-source-picker__trigger"
+          data-active={open || visibleCount > 0 ? "true" : undefined}
+          aria-label="Источники данных сцены"
+          aria-haspopup="dialog"
+          aria-expanded={open}
+          aria-controls={surfaceId}
+          onClick={toggle}
+        >
+          <Icon name="database" size={17} />
+          {sources.length > 0 ? <span>{visibleCount}</span> : null}
+        </button>
+      )}
+    >
+      <header className="observation-source-menu__head">
+        <div>
+          <span className="section-eyebrow">НАБЛЮДЕНИЕ</span>
+          <strong>Источники данных</strong>
+        </div>
+        <small>{sources.length ? `${visibleCount} из ${sources.length}` : "нет источников"}</small>
+      </header>
+      {sources.length ? (
+        <div className="observation-source-menu__list">
+          {sources.map((source) => {
+            const selected = visibleSourceIds.has(source.id);
+            const pending = pendingSourceIds?.has(source.id) ?? false;
+            const canOpen = Boolean(
+              selected ||
+              source.modality === "point-cloud" ||
+              source.previewUrl ||
+              source.delivery ||
+              source.activation?.controllable,
+            );
+            return (
+              <button
+                key={source.id}
+                type="button"
+                className="nodedc-dropdown-option observation-source-option"
+                data-selected={selected ? "true" : undefined}
+                aria-pressed={selected}
+                disabled={pending || !canOpen}
+                onClick={() => void onToggle(source.id)}
+              >
+                <span className="nodedc-dropdown-option__icon">
+                  <Icon name={sourceIcon[source.modality]} size={16} />
+                </span>
+                <span className="nodedc-dropdown-option__body">
+                  <span className="nodedc-dropdown-option__label">{source.label}</span>
+                  <span className="nodedc-dropdown-option__description">
+                    <i data-availability={source.availability} aria-hidden="true" />
+                    {pending ? "Переключение" : observationSourceStatusLabel(source)} · {source.endpointLabel || source.transport}
+                  </span>
+                </span>
+                <span className="nodedc-dropdown-option__check">
+                  {selected ? <Icon name="check" size={15} /> : null}
+                </span>
+              </button>
+            );
+          })}
+        </div>
+      ) : (
+        <div className="observation-source-menu__empty">
+          <Icon name="database" size={18} />
+          <strong>Каталог пока пуст</strong>
+          <span>Выберите профиль устройства — его плагин опубликует доступные каналы.</span>
+        </div>
+      )}
+      <footer className="observation-source-menu__foot">
+        Каналы приходят из активного контура или выбранной сохранённой сессии; сцена не знает
+        модель оборудования.
+      </footer>
+    </Dropdown>
+  );
+}
@@ -1 +1,197 @@
-export * from "../../../../packages/spatial-ui/src/ObservationTimeline";
+import { Button, Icon, Select } from "@nodedc/ui-react";
+
+import type { ObservationTimelineMode } from "../core/runtime/contracts";
+
+export function ObservationTimeline({
+  active,
+  sourceCount,
+  mode = "live-only",
+  seekable = false,
+  synchronization = "host-arrival-best-effort",
+  rangeNs = null,
+  currentNs = null,
+  playing = false,
+  onSeek,
+  onPlayingChange,
+  onJumpToEnd,
+  showJumpToEnd = true,
+  playbackRate,
+  onPlaybackRateChange,
+  accumulationSeconds,
+  onAccumulationChange,
+  onAccumulationCommit,
+  className = "",
+}: {
+  active: boolean;
+  sourceCount: number;
+  mode?: ObservationTimelineMode;
+  seekable?: boolean;
+  synchronization?: "host-arrival-best-effort" | "shared-clock" | "frame-accurate";
+  rangeNs?: { min: number; max: number } | null;
+  currentNs?: number | null;
+  playing?: boolean;
+  onSeek?: (timeNs: number) => void;
+  onPlayingChange?: (playing: boolean) => void;
+  onJumpToEnd?: () => void;
+  showJumpToEnd?: boolean;
+  playbackRate?: number;
+  onPlaybackRateChange?: (rate: number) => void;
+  accumulationSeconds?: number;
+  onAccumulationChange?: (value: number) => void;
+  onAccumulationCommit?: () => void;
+  className?: string;
+}) {
+  const playbackRange = normalizeTimelineRange(rangeNs);
+  const buffered = Boolean(
+    seekable &&
+    (mode === "buffered" || mode === "recorded") &&
+    playbackRange,
+  );
+  const elapsedSeconds = playbackRange
+    ? timelineOffsetSeconds(playbackRange, currentNs ?? playbackRange.min)
+    : 0;
+  const durationSeconds = playbackRange
+    ? Math.max(0, (playbackRange.max - playbackRange.min) / 1_000_000_000)
+    : 0;
+  const synchronizationLabel = {
+    "host-arrival-best-effort": "Синхронизация по приходу",
+    "shared-clock": "Общие часы",
+    "frame-accurate": "Покадровая синхронизация",
+  }[synchronization];
+  const accumulationValue = accumulationSeconds === undefined
+    ? null
+    : normalizeAccumulationSeconds(accumulationSeconds);
+  return (
+    <div
+      className={`observation-timeline ${className}`.trim()}
+      data-active={active ? "true" : undefined}
+      data-mode={mode}
+      data-accumulation={accumulationValue !== null ? "true" : undefined}
+    >
+      {accumulationValue !== null ? (
+        <div className="observation-timeline__accumulation">
+          <span>Накопление</span>
+          <input
+            className="observation-timeline__track"
+            type="range"
+            min={0}
+            max={120}
+            step={1}
+            value={accumulationValue}
+            aria-label="Окно накопления облака точек"
+            aria-valuetext={formatAccumulationDuration(accumulationValue)}
+            onChange={(event) =>
+              onAccumulationChange?.(normalizeAccumulationSeconds(Number(event.target.value)))}
+            onPointerUp={onAccumulationCommit}
+            onTouchEnd={onAccumulationCommit}
+            onKeyUp={onAccumulationCommit}
+            onBlur={onAccumulationCommit}
+          />
+          <code>{formatAccumulationDuration(accumulationValue)}</code>
+        </div>
+      ) : null}
+      <div className="observation-timeline__playback">
+        <Button
+          size="compact"
+          variant="ghost"
+          disabled={!buffered || !onSeek}
+          aria-label="Перейти к началу"
+          onClick={() => playbackRange && onSeek?.(playbackRange.min)}
+        >
+          <Icon name="chevron-left" />
+        </Button>
+        <Button
+          className="observation-timeline__transport"
+          size="compact"
+          variant="ghost"
+          disabled={!buffered || !onPlayingChange}
+          aria-label={buffered ? (playing ? "Пауза" : "Воспроизвести") : "Только эфир"}
+          icon={<Icon name={playing ? "stop" : "play"} />}
+          onClick={() => onPlayingChange?.(!playing)}
+        />
+        {buffered && playbackRate !== undefined && onPlaybackRateChange ? (
+          <Select
+            label="Скорость воспроизведения"
+            value={String(playbackRate)}
+            options={[
+              { value: "0.5", label: "0,5×" },
+              { value: "1", label: "1×" },
+              { value: "2", label: "2×" },
+            ]}
+            variant="inline"
+            menuWidth="anchor"
+            onChange={(value) => onPlaybackRateChange(Number(value))}
+          />
+        ) : null}
+        <input
+          className="observation-timeline__track"
+          type="range"
+          min={0}
+          max={Math.max(durationSeconds, 0.001)}
+          step={0.01}
+          value={Math.min(elapsedSeconds, durationSeconds)}
+          disabled={!buffered || !onSeek}
+          aria-label="Позиция воспроизведения"
+          onChange={(event) => {
+            if (!playbackRange) return;
+            onSeek?.(playbackRange.min + Number(event.target.value) * 1_000_000_000);
+          }}
+        />
+        <div className="observation-timeline__meta">
+          <code>
+            {buffered
+              ? `${formatTimelineDuration(elapsedSeconds)} / ${formatTimelineDuration(durationSeconds)}`
+              : active ? "LIVE" : "—:—:—.———"}
+          </code>
+          <small>
+            {buffered ? `${sourceCount} каналов` : `${synchronizationLabel} · буфер не включён`}
+          </small>
+        </div>
+        {showJumpToEnd ? (
+          <button
+            type="button"
+            className="observation-timeline__follow"
+            data-active={!buffered && active ? "true" : undefined}
+            disabled={buffered ? !onJumpToEnd : true}
+            onClick={onJumpToEnd}
+          >
+            {buffered ? "К КОНЦУ" : "ЭФИР"}
+          </button>
+        ) : null}
+      </div>
+    </div>
+  );
+}
+
+export function normalizeAccumulationSeconds(value: number): number {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(120, Math.max(0, Math.round(value)));
+}
+
+export function formatAccumulationDuration(value: number): string {
+  const seconds = normalizeAccumulationSeconds(value);
+  return seconds === 0 ? "Кадр" : `${seconds} с`;
+}
+
+export function normalizeTimelineRange(
+  range: { min: number; max: number } | null | undefined,
+): { min: number; max: number } | null {
+  if (!range || !Number.isFinite(range.min) || !Number.isFinite(range.max)) return null;
+  if (range.max <= range.min) return null;
+  return range;
+}
+
+export function timelineOffsetSeconds(
+  range: { min: number; max: number },
+  currentNs: number,
+): number {
+  const clamped = Math.min(Math.max(currentNs, range.min), range.max);
+  return Math.max(0, (clamped - range.min) / 1_000_000_000);
+}
+
+export function formatTimelineDuration(seconds: number): string {
+  if (!Number.isFinite(seconds) || seconds < 0) return "00:00.000";
+  const wholeMinutes = Math.floor(seconds / 60);
+  const remaining = seconds - wholeMinutes * 60;
+  return `${String(wholeMinutes).padStart(2, "0")}:${remaining.toFixed(3).padStart(6, "0")}`;
+}
@@ -29,9 +29,7 @@ export type RecordedMediaPresentationState = "loading" | "ready" | "waiting" | "

 export const RECORDED_MEDIA_DURATION_TOLERANCE_SECONDS = 1;
 const RECORDED_MEDIA_SOURCE_OPEN_TIMEOUT_MS = 10_000;
-// A valid local fragment becomes decoder-ready well below one second. Keeping
-// a damaged GOP on screen for ten seconds only delays the keyframe recovery.
-const RECORDED_MEDIA_TARGET_TIMEOUT_MS = 2_500;
+const RECORDED_MEDIA_TARGET_TIMEOUT_MS = 10_000;
 const RECORDED_MEDIA_FRAGMENT_TIMEOUT_MS = 15_000;
 const RECORDED_MEDIA_REQUIRED_AHEAD_SEGMENTS = 12;
 const RECORDED_MEDIA_SEGMENTS_AHEAD = 36;
@@ -74,39 +72,6 @@ export function recordedMediaDecodeStartSequence(
  return selected;
 }

-export function nextRecordedMediaRandomAccessSequence(
-  randomAccessSequences: readonly number[],
-  failedSequence: number,
-): number | null {
-  if (!Number.isInteger(failedSequence) || failedSequence < 1) return null;
-  for (const sequence of randomAccessSequences) {
-    if (!Number.isInteger(sequence) || sequence < 1) return null;
-    if (sequence > failedSequence) return sequence;
-  }
-  return null;
-}
-
-export function recordedMediaRecoveryTargetSequence(
-  requestedSequence: number | null,
-  failedSequence: number | null,
-  recoverySequence: number | null,
-): number | null {
-  if (requestedSequence === null) return null;
-  if (
-    !Number.isInteger(requestedSequence)
-    || requestedSequence < 1
-    || failedSequence === null
-    || recoverySequence === null
-    || !Number.isInteger(failedSequence)
-    || !Number.isInteger(recoverySequence)
-    || failedSequence < 1
-    || recoverySequence <= failedSequence
-  ) return requestedSequence;
-  return requestedSequence >= failedSequence && requestedSequence < recoverySequence
-    ? recoverySequence
-    : requestedSequence;
-}
-
 export function recordedMediaSegmentAppendOrder(
  appended: ReadonlySet<number>,
  decodeStartSequence: number,
@@ -125,32 +90,6 @@ export function recordedMediaSegmentAppendOrder(
  return missing;
 }

-/** Resolve a source-clock timestamp to the first fMP4 fragment covering it. */
-export function recordedMediaSegmentSequenceAtTime(
-  segmentEndTimesSeconds: readonly number[],
-  epochStartSeconds: number,
-  currentSeconds: number,
-): number | null {
-  if (
-    !segmentEndTimesSeconds.length ||
-    !Number.isFinite(epochStartSeconds) ||
-    !Number.isFinite(currentSeconds)
-  ) return null;
-  const localSeconds = Math.max(0, currentSeconds - epochStartSeconds);
-  let left = 0;
-  let right = segmentEndTimesSeconds.length - 1;
-  while (left < right) {
-    const middle = Math.floor((left + right) / 2);
-    const endSeconds = segmentEndTimesSeconds[middle];
-    if (!Number.isFinite(endSeconds) || endSeconds <= 0) return null;
-    if (endSeconds + 0.001 >= localSeconds) right = middle;
-    else left = middle + 1;
-  }
-  const finalEndSeconds = segmentEndTimesSeconds[left];
-  if (!Number.isFinite(finalEndSeconds) || finalEndSeconds + 0.001 < localSeconds) return null;
-  return left + 1;
-}
-
 export function recordedMediaCanRollTarget(
  previousSequence: number,
  nextSequence: number,
@@ -182,27 +121,6 @@ function recordedMediaTimeRangesContain(
  return false;
 }

-export function recordedMediaTimestampStallRecoveryTarget(
-  currentSeconds: number,
-  bufferedRanges: readonly (readonly [number, number])[],
-  skipSeconds = 0.18,
-): number | null {
-  if (!Number.isFinite(currentSeconds) || !Number.isFinite(skipSeconds) || skipSeconds <= 0) {
-    return null;
-  }
-  for (const [startSeconds, endSeconds] of bufferedRanges) {
-    if (
-      !Number.isFinite(startSeconds)
-      || !Number.isFinite(endSeconds)
-      || currentSeconds < startSeconds - 0.05
-      || currentSeconds > endSeconds
-    ) continue;
-    const targetSeconds = Math.min(currentSeconds + skipSeconds, endSeconds - 0.05);
-    return targetSeconds >= currentSeconds + 0.04 ? targetSeconds : null;
-  }
-  return null;
-}
-
 export function recordedMediaPresentationState(
  state: "loading" | "ready" | "error",
  readyGeneration: string | null,
@@ -233,24 +151,6 @@ export function selectRecordedMediaEpoch(
  return selected && currentSeconds <= selected.timelineEndSeconds ? selected : null;
 }

-/**
- * Keep admission bounded even when the shared Rerun clock is currently before,
- * between, or after camera epochs. Presentation still reports `waiting`; this
- * selector only chooses the nearest epoch whose first/last fragment can prove
- * that the camera transport is usable without downloading the whole MP4.
- */
-export function selectRecordedMediaPreparationEpoch(
-  epochs: readonly ObservationRecordedMediaEpoch[],
-  currentSeconds: number,
-): ObservationRecordedMediaEpoch | null {
-  if (!epochs.length || !Number.isFinite(currentSeconds)) return null;
-  const active = selectRecordedMediaEpoch(epochs, currentSeconds);
-  if (active) return active;
-  return epochs.find((epoch) => epoch.timelineStartSeconds > currentSeconds)
-    ?? epochs.at(-1)
-    ?? null;
-}
-
 export function recordedMediaSeekableCoverage(
  durationSeconds: number,
  seekableEndSeconds: number,
@@ -331,14 +231,29 @@ export async function fetchRecordedMediaArchive(
  return { manifest, byteLength: totalBytes };
 }

-function waitForRecordedVideoInitialFrame(
+function videoHasSeekableArchive(
  video: HTMLVideoElement,
+  declaredDurationSeconds: number,
+): boolean {
+  if (video.readyState < 1 || video.seekable.length < 1) return false;
+  return recordedMediaSeekableCoverage(
+    video.duration,
+    video.seekable.end(video.seekable.length - 1),
+    declaredDurationSeconds,
+    RECORDED_MEDIA_DURATION_TOLERANCE_SECONDS,
+    video.seekable.start(0),
+  );
+}
+
+function waitForSeekableArchive(
+  video: HTMLVideoElement,
+  declaredDurationSeconds: number,
  signal: AbortSignal,
 ): Promise<void> {
  if (signal.aborted) return Promise.reject(new DOMException("Aborted", "AbortError"));
-  if (video.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA) return Promise.resolve();
+  if (videoHasSeekableArchive(video, declaredDurationSeconds)) return Promise.resolve();
  return new Promise((resolve, reject) => {
-    const events = ["loadeddata", "canplay", "progress"] as const;
+    const events = ["loadedmetadata", "durationchange", "progress", "canplay"] as const;
    let stallTimer: ReturnType<typeof globalThis.setTimeout> | undefined;
    const armStallTimer = () => {
      if (stallTimer !== undefined) globalThis.clearTimeout(stallTimer);
@@ -355,7 +270,7 @@ function waitForRecordedVideoInitialFrame(
    };
    const onProgress = () => {
      armStallTimer();
-      if (video.readyState < HTMLMediaElement.HAVE_CURRENT_DATA) return;
+      if (!videoHasSeekableArchive(video, declaredDurationSeconds)) return;
      cleanup();
      resolve();
    };
@@ -398,7 +313,11 @@ async function mountRecordedEpochStream(
  };
  video.load();
  try {
-    await waitForRecordedVideoInitialFrame(video, signal);
+    await waitForSeekableArchive(
+      video,
+      descriptor.timelineEndSeconds - descriptor.timelineStartSeconds,
+      signal,
+    );
    return cleanup;
  } catch (error) {
    cleanup();
@@ -417,11 +336,6 @@ interface RecordedSegmentTarget {
  resetAttempts: number;
 }

-interface RecordedSegmentRecovery {
-  readonly failedSequence: number;
-  readonly recoverySequence: number;
-}
-
 interface RecordedSegmentStreamRuntime {
  readonly generation: string;
  readonly mediaSource: MediaSource;
@@ -802,9 +716,6 @@ export function RecordedFmp4Player({
  onAdmissionChange,
  onPlaybackChange,
  onPlayingRejected,
-  playbackAuthority = "media",
-  playbackTransport = "segmented",
-  recoverTimestampStalls = false,
 }: {
  source: ObservationSourceDescriptor;
  playback?: RecordedObservationPlayback | null;
@@ -817,9 +728,6 @@ export function RecordedFmp4Player({
  onAdmissionChange?: (state: RecordedCameraAdmissionState) => void;
  onPlaybackChange?: (playback: RecordedObservationPlayback) => void;
  onPlayingRejected?: () => void;
-  playbackAuthority?: "media" | "host";
-  playbackTransport?: "segmented" | "epoch-stream";
-  recoverTimestampStalls?: boolean;
 }) {
  const videoRef = useRef<HTMLVideoElement>(null);
  const onAdmissionChangeRef = useRef(onAdmissionChange);
@@ -860,16 +768,12 @@ export function RecordedFmp4Player({
  );
  const [archive, setArchive] = useState<RecordedMediaArchive | null>(null);
  const [state, setState] = useState<"loading" | "ready" | "error">("loading");
-  const [errorMessage, setErrorMessage] = useState<string | null>(null);
  const [readyGeneration, setReadyGeneration] = useState<string | null>(null);
  const [bufferRevision, setBufferRevision] = useState(0);
-  const [segmentRecoveryGeneration, setSegmentRecoveryGeneration] = useState(0);
-  const [segmentRecovery, setSegmentRecovery] = useState<RecordedSegmentRecovery | null>(null);
  const segmentedRuntimeRef = useRef<RecordedSegmentStreamRuntime | null>(null);
  const [segmentedRuntimeGeneration, setSegmentedRuntimeGeneration] = useState<string | null>(null);
  const targetRevisionRef = useRef(0);
  const targetReadyAbortRef = useRef<AbortController | null>(null);
-  const lastSegmentRecoveryRef = useRef<string | null>(null);
  const playAttemptRevisionRef = useRef(0);
  const currentSeconds = playback?.currentSeconds ?? contract?.timelineStartSeconds ?? 0;
  const playbackPlayingRef = useRef(Boolean(playback?.playing));
@@ -877,63 +781,25 @@ export function RecordedFmp4Player({
  const playbackRate = playback?.rate && Number.isFinite(playback.rate)
    ? Math.min(4, Math.max(0.25, playback.rate))
    : 1;
-  const playbackRateRef = useRef(playbackRate);
-  playbackRateRef.current = playbackRate;
-  const presentationEpoch = useMemo(
+  const epoch = useMemo(
    () => selectRecordedMediaEpoch(archive?.manifest.epochs ?? [], currentSeconds),
    [archive?.manifest.epochs, currentSeconds],
  );
-  const epoch = useMemo(
-    () => selectRecordedMediaPreparationEpoch(
-      archive?.manifest.epochs ?? [],
-      currentSeconds,
-    ),
-    [archive?.manifest.epochs, currentSeconds],
-  );
-  const segmentClockSeconds = epoch
-    ? Math.min(
-        Math.max(currentSeconds, epoch.timelineStartSeconds),
-        epoch.timelineEndSeconds,
-      )
-    : currentSeconds;
-  const effectiveSegmentCount = segmentCount ?? epoch?.segmentCount ?? null;
-  const requestedSegmentSequence = segmentSequence ?? (epoch
-    ? recordedMediaSegmentSequenceAtTime(
-        epoch.segmentEndTimesSeconds,
-        epoch.timelineStartSeconds,
-        segmentClockSeconds,
-      )
-    : null);
-  const effectiveSegmentSequence = recordedMediaRecoveryTargetSequence(
-    requestedSegmentSequence,
-    segmentRecovery?.failedSequence ?? null,
-    segmentRecovery?.recoverySequence ?? null,
-  );
-  const holdingForSegmentRecovery = Boolean(
-    segmentRecovery
-    && requestedSegmentSequence !== null
-    && effectiveSegmentSequence !== requestedSegmentSequence,
-  );
  const segmented = Boolean(
-    playbackTransport === "segmented"
-    && requestedSegmentSequence !== null
-    && Number.isInteger(requestedSegmentSequence)
-    && requestedSegmentSequence >= 1
-    &&
-    effectiveSegmentCount !== null
-    && Number.isInteger(effectiveSegmentCount)
-    && effectiveSegmentCount >= 1
+    segmentCount !== null
+    && Number.isInteger(segmentCount)
+    && segmentCount >= 1
    && typeof MediaSource !== "undefined"
    && epoch
-    && epoch.segmentCount === effectiveSegmentCount
+    && epoch.segmentCount === segmentCount
    && epoch.randomAccessSequences.length > 0
-    && epoch.segmentEndTimesSeconds.length === effectiveSegmentCount
+    && epoch.segmentEndTimesSeconds.length === segmentCount
    && MediaSource.isTypeSupported(epoch.mediaType),
  );
  const directPlaybackSeconds = segmented ? null : currentSeconds;
-  const waitingForEpoch = Boolean(archive && !presentationEpoch);
-  const selectedGeneration = contract && presentationEpoch
-    ? `${contract.manifestGenerationSha256}:${presentationEpoch.ordinal}:${presentationEpoch.timelineStartSeconds}:${presentationEpoch.timelineEndSeconds}`
+  const waitingForEpoch = Boolean(archive && !epoch);
+  const selectedGeneration = contract && epoch
+    ? `${contract.manifestGenerationSha256}:${epoch.ordinal}:${epoch.timelineStartSeconds}:${epoch.timelineEndSeconds}`
    : null;
  const visualState = recordedMediaPresentationState(
    state,
@@ -947,7 +813,6 @@ export function RecordedFmp4Player({
    if (!contract) {
      setArchive(null);
      setReadyGeneration(null);
-      setErrorMessage("Некорректный descriptor записанной камеры.");
      setState("error");
      reportAdmission({
        phase: "error",
@@ -960,9 +825,6 @@ export function RecordedFmp4Player({
    const abort = new AbortController();
    setArchive(null);
    setReadyGeneration(null);
-    setSegmentRecovery(null);
-    lastSegmentRecoveryRef.current = null;
-    setErrorMessage(null);
    setState("loading");
    reportAdmission({
      phase: "loading",
@@ -980,7 +842,6 @@ export function RecordedFmp4Player({
        }
        setArchive(null);
        setReadyGeneration(null);
-        setErrorMessage("Архив записанной камеры не прошёл проверку.");
        setState("error");
        reportAdmission({
          phase: "error",
@@ -992,14 +853,43 @@ export function RecordedFmp4Player({
  }, [admissionKey, contract, prepare]);

  useEffect(() => {
-    if (!segmentRecovery || requestedSegmentSequence === null) return;
-    if (
-      requestedSegmentSequence >= segmentRecovery.failedSequence
-      && requestedSegmentSequence < segmentRecovery.recoverySequence
-    ) return;
-    lastSegmentRecoveryRef.current = null;
-    setSegmentRecovery(null);
-  }, [requestedSegmentSequence, segmentRecovery]);
+    if (!archive || !contract || !prepare || segmented) return;
+    const abort = new AbortController();
+    let disposed = false;
+    void (async () => {
+      for (const candidate of archive.manifest.epochs) {
+        const probe = document.createElement("video");
+        probe.muted = true;
+        probe.playsInline = true;
+        const cleanup = await mountRecordedEpochStream(probe, candidate, abort.signal);
+        cleanup();
+        if (disposed || abort.signal.aborted) return;
+      }
+      if (disposed || abort.signal.aborted) return;
+      reportAdmission({
+        phase: "ready",
+        byteLength: archive.byteLength,
+        message: null,
+      });
+    })().catch((error: unknown) => {
+      if (
+        disposed ||
+        abort.signal.aborted ||
+        (error instanceof DOMException && error.name === "AbortError")
+      ) return;
+      setReadyGeneration(null);
+      setState("error");
+      reportAdmission({
+        phase: "error",
+        byteLength: archive.byteLength,
+        message: "Не все codec epoch записанной камеры декодируются и доступны для seek.",
+      });
+    });
+    return () => {
+      disposed = true;
+      abort.abort();
+    };
+  }, [admissionKey, archive, contract, prepare, segmented]);

  useEffect(() => {
    const video = videoRef.current;
@@ -1020,7 +910,6 @@ export function RecordedFmp4Player({

    setReadyGeneration(null);
    setSegmentedRuntimeGeneration(null);
-    setErrorMessage(null);
    setState("loading");
    video.pause();
    const sourceOpened = waitForMediaSourceOpen(mediaSource, abort.signal);
@@ -1068,7 +957,6 @@ export function RecordedFmp4Player({
        return;
      }
      setReadyGeneration(null);
-      setErrorMessage("Покадровый буфер записанной камеры не открылся.");
      setState("error");
      reportAdmission({
        phase: "error",
@@ -1094,14 +982,7 @@ export function RecordedFmp4Player({
      }
      URL.revokeObjectURL(objectUrl);
    };
-  }, [
-    archive,
-    contract,
-    effectiveSegmentCount,
-    epoch,
-    segmented,
-    segmentRecoveryGeneration,
-  ]);
+  }, [archive, contract, epoch, segmentCount, segmented]);

  useEffect(() => {
    const runtime = segmentedRuntimeRef.current;
@@ -1112,19 +993,18 @@ export function RecordedFmp4Player({
      || !archive
      || !segmented
      || segmentedRuntimeGeneration !== runtime.generation
-      || effectiveSegmentSequence === null
-      || !Number.isInteger(effectiveSegmentSequence)
-      || effectiveSegmentSequence < 1
-      || effectiveSegmentSequence > runtime.segmentCount
+      || segmentSequence === null
+      || !Number.isInteger(segmentSequence)
+      || segmentSequence < 1
+      || segmentSequence > runtime.segmentCount
    ) return;
    const archiveByteLength = archive.byteLength;
    const decodeStart = recordedMediaDecodeStartSequence(
      runtime.randomAccessSequences,
-      effectiveSegmentSequence,
+      segmentSequence,
    );
    if (decodeStart === null) {
      setReadyGeneration(null);
-      setErrorMessage("Для кадра записанной камеры нет random-access фрагмента.");
      setState("error");
      reportAdmission({
        phase: "error",
@@ -1135,11 +1015,10 @@ export function RecordedFmp4Player({
    }
    const targetSeconds = recordedSegmentStartSeconds(
      runtime.segmentEndTimesSeconds,
-      effectiveSegmentSequence,
+      segmentSequence,
    );
    if (targetSeconds === null) {
      setReadyGeneration(null);
-      setErrorMessage("Для кадра записанной камеры нет точной media timestamp.");
      setState("error");
      reportAdmission({
        phase: "error",
@@ -1151,15 +1030,15 @@ export function RecordedFmp4Player({
    const previousTarget = runtime.target;
    const readyEnd = Math.min(
      runtime.segmentCount,
-      effectiveSegmentSequence + RECORDED_MEDIA_REQUIRED_AHEAD_SEGMENTS,
+      segmentSequence + RECORDED_MEDIA_REQUIRED_AHEAD_SEGMENTS,
    );
    const desiredEnd = Math.min(
      runtime.segmentCount,
-      effectiveSegmentSequence + RECORDED_MEDIA_SEGMENTS_AHEAD,
+      segmentSequence + RECORDED_MEDIA_SEGMENTS_AHEAD,
    );
    const candidateTarget: RecordedSegmentTarget = {
      revision: previousTarget?.revision ?? 0,
-      sequence: effectiveSegmentSequence,
+      sequence: segmentSequence,
      decodeStart,
      readyEnd,
      desiredEnd,
@@ -1167,24 +1046,6 @@ export function RecordedFmp4Player({
      forceReset: false,
      resetAttempts: 0,
    };
-    const recoverFromSegmentFailure = (failedSequence: number): boolean => {
-      const recoverySequence = nextRecordedMediaRandomAccessSequence(
-        runtime.randomAccessSequences,
-        failedSequence,
-      );
-      if (recoverySequence === null) return false;
-      const recoveryToken = `${runtime.generation}:${failedSequence}:${recoverySequence}`;
-      if (lastSegmentRecoveryRef.current === recoveryToken) return true;
-      lastSegmentRecoveryRef.current = recoveryToken;
-      setReadyGeneration(null);
-      setSegmentRecovery({ failedSequence, recoverySequence });
-      setErrorMessage(
-        `Восстанавливаем камеру с ключевого кадра ${recoverySequence}.`,
-      );
-      setState("loading");
-      setSegmentRecoveryGeneration((generation) => generation + 1);
-      return true;
-    };
    const rollingTarget = Boolean(previousTarget && recordedMediaCanRollTarget(
      previousTarget.sequence,
      candidateTarget.sequence,
@@ -1198,62 +1059,21 @@ export function RecordedFmp4Player({
        || runtime.abort.signal.aborted
        || (error instanceof DOMException && error.name === "AbortError")
      ) return;
-      const failedSequence = runtime.target?.sequence ?? effectiveSegmentSequence;
-      if (failedSequence !== null && recoverFromSegmentFailure(failedSequence)) return;
-      const detail = error instanceof Error && error.message
-        ? `: ${error.message}`
-        : ".";
-      const message = `Покадровый фрагмент записанной камеры недоступен${detail}`;
      setReadyGeneration(null);
-      setErrorMessage(message);
      setState("error");
      reportAdmission({
        phase: "error",
        byteLength: archiveByteLength,
-        message,
+        message: "Покадровый фрагмент записанной камеры недоступен.",
      });
    };
-    const resumePlaybackIfRequested = async (revision: number) => {
-      if (
-        runtime.disposed
-        || segmentedRuntimeRef.current !== runtime
-        || runtime.target?.revision !== revision
-        || !playbackPlayingRef.current
-      ) return;
-      video.playbackRate = playbackRateRef.current;
-      try {
-        await video.play();
-      } catch {
-        if (
-          runtime.disposed
-          || segmentedRuntimeRef.current !== runtime
-          || runtime.target?.revision !== revision
-        ) return;
-        // Canonical recorded LABs run one host-owned clock for camera and
-        // spatial evidence. A transient MSE play() rejection (commonly a
-        // pause/reset race while the next fragment is admitted) must stay a
-        // decoder concern: the rolling target will retry and catch up.
-        if (playbackAuthority === "host") return;
-        onPlayingRejectedRef.current?.();
-        setReadyGeneration(null);
-        setErrorMessage("Запуск записанной камеры отклонён браузером.");
-        setState("error");
-        reportAdmission({
-          phase: "error",
-          byteLength: archiveByteLength,
-          message: "Запуск записанной камеры отклонён браузером.",
-        });
-      }
-    };
    if (rollingTarget && previousTarget) {
      runtime.target = {
        ...candidateTarget,
        revision: previousTarget.revision,
      };
      runtime.onTargetBuffered = null;
-      void pumpRecordedSegmentWindow(runtime)
-        .then(() => resumePlaybackIfRequested(previousTarget.revision))
-        .catch(reportPumpError);
+      void pumpRecordedSegmentWindow(runtime).catch(reportPumpError);
      return;
    }

@@ -1308,22 +1128,18 @@ export function RecordedFmp4Player({
          setBufferRevision((revision) => revision + 1);
          runtime.hasPresentedFrame = true;
          setReadyGeneration(runtime.generation);
-          setErrorMessage(null);
          setState("ready");
          reportAdmission({
            phase: "ready",
            byteLength: archiveByteLength,
            message: null,
          });
-          await resumePlaybackIfRequested(bufferedTarget.revision);
        } catch (error) {
          if (
            targetReadyAbort.signal.aborted
            || (error instanceof DOMException && error.name === "AbortError")
          ) return;
-          if (recoverFromSegmentFailure(bufferedTarget.sequence)) return;
          setReadyGeneration(null);
-          setErrorMessage("Кадр записанной камеры не стал decoder-ready.");
          setState("error");
          reportAdmission({
            phase: "error",
@@ -1344,13 +1160,7 @@ export function RecordedFmp4Player({
      if (targetReadyAbortRef.current === targetReadyAbort) targetReadyAbortRef.current = null;
      if (runtime.onTargetBuffered === markBuffered) runtime.onTargetBuffered = null;
    };
-  }, [
-    archive?.byteLength,
-    effectiveSegmentSequence,
-    playbackAuthority,
-    segmented,
-    segmentedRuntimeGeneration,
-  ]);
+  }, [archive?.byteLength, segmentSequence, segmented, segmentedRuntimeGeneration]);

  useEffect(() => {
    const video = videoRef.current;
@@ -1360,7 +1170,6 @@ export function RecordedFmp4Player({
      ? `${contract.manifestGenerationSha256}:${epochDescriptor.ordinal}:${epochDescriptor.timelineStartSeconds}:${epochDescriptor.timelineEndSeconds}`
      : null;
    setReadyGeneration(null);
-    setErrorMessage(null);
    setState("loading");
    const abort = new AbortController();
    let disposed = false;
@@ -1376,13 +1185,7 @@ export function RecordedFmp4Player({
        }
        setBufferRevision((revision) => revision + 1);
        setReadyGeneration(generation);
-        setErrorMessage(null);
        setState("ready");
-        reportAdmission({
-          phase: "ready",
-          byteLength: archive?.byteLength ?? null,
-          message: null,
-        });
      } catch (error) {
        if (
          disposed ||
@@ -1392,12 +1195,11 @@ export function RecordedFmp4Player({
          return;
        }
        setReadyGeneration(null);
-        setErrorMessage("Записанная камера не открыла первый декодируемый кадр.");
        setState("error");
        reportAdmission({
          phase: "error",
          byteLength: archive?.byteLength ?? null,
-          message: "Записанная камера не открыла первый декодируемый кадр.",
+          message: "Записанная камера не стала seekable.",
        });
      }
    };
@@ -1432,7 +1234,6 @@ export function RecordedFmp4Player({
        video.currentTime = target;
      } catch {
        setReadyGeneration(null);
-        setErrorMessage("Seek записанной камеры завершился ошибкой.");
        setState("error");
        reportAdmission({
          phase: "error",
@@ -1443,13 +1244,11 @@ export function RecordedFmp4Player({
      }
    }
    video.playbackRate = playbackRate;
-    if (playback?.playing && !holdingForSegmentRecovery) {
+    if (playback?.playing) {
      void video.play().catch(() => {
        if (playAttemptRevisionRef.current !== playAttemptRevision) return;
-        if (playbackAuthority === "host") return;
        onPlayingRejectedRef.current?.();
        setReadyGeneration(null);
-        setErrorMessage("Запуск записанной камеры отклонён браузером.");
        setState("error");
        reportAdmission({
          phase: "error",
@@ -1465,95 +1264,12 @@ export function RecordedFmp4Player({
    bufferRevision,
    directPlaybackSeconds,
    epoch,
-    holdingForSegmentRecovery,
    playback?.playing,
-    playbackAuthority,
    playbackRate,
    segmented,
    visualState,
  ]);

-  useEffect(() => {
-    const video = videoRef.current;
-    if (!video || !recoverTimestampStalls || !playback?.playing || visualState !== "ready") {
-      return;
-    }
-    let lastSeconds = video.currentTime;
-    let lastProgressAtMs = performance.now();
-    const interval = window.setInterval(() => {
-      if (
-        !playbackPlayingRef.current
-        || video.paused
-        || video.ended
-        || video.seeking
-        || video.readyState < HTMLMediaElement.HAVE_CURRENT_DATA
-      ) {
-        lastSeconds = video.currentTime;
-        lastProgressAtMs = performance.now();
-        return;
-      }
-      const nowMs = performance.now();
-      if (video.currentTime >= lastSeconds + 0.02) {
-        lastSeconds = video.currentTime;
-        lastProgressAtMs = nowMs;
-        return;
-      }
-      if (nowMs - lastProgressAtMs < 1_250) return;
-      const bufferedRanges = Array.from(
-        { length: video.buffered.length },
-        (_, index) => [video.buffered.start(index), video.buffered.end(index)] as const,
-      );
-      const targetSeconds = recordedMediaTimestampStallRecoveryTarget(
-        video.currentTime,
-        bufferedRanges,
-      );
-      lastProgressAtMs = nowMs;
-      if (targetSeconds === null) return;
-      // Field recordings can contain non-monotonic or corrupt H.264 timestamps.
-      // If decoded time is frozen despite proven buffered media ahead, skip only
-      // the broken timestamp interval and return authority to the media clock.
-      video.currentTime = targetSeconds;
-      lastSeconds = targetSeconds;
-    }, 250);
-    return () => window.clearInterval(interval);
-  }, [playback?.playing, recoverTimestampStalls, visualState]);
-
-  useEffect(() => {
-    const video = videoRef.current;
-    if (!video || !segmented || !playback?.playing || visualState !== "ready") return;
-    let cancelled = false;
-    const resumeIfDecoderReady = () => {
-      if (cancelled || !playbackPlayingRef.current || !video.paused) return;
-      const runtime = segmentedRuntimeRef.current;
-      const target = runtime?.target;
-      if (
-        !runtime
-        || !target
-        || runtime.disposed
-        || video.seeking
-        || video.readyState < HTMLMediaElement.HAVE_CURRENT_DATA
-        || Math.abs(video.currentTime - target.targetSeconds) > 0.25
-        || !recordedMediaTimeRangesContain(video.buffered, target.targetSeconds)
-      ) return;
-      playAttemptRevisionRef.current += 1;
-      const playAttemptRevision = playAttemptRevisionRef.current;
-      video.playbackRate = playbackRateRef.current;
-      void video.play().catch(() => {
-        if (cancelled || playAttemptRevisionRef.current !== playAttemptRevision) return;
-        if (playbackAuthority === "host") return;
-        onPlayingRejectedRef.current?.();
-      });
-    };
-    const queueResume = () => window.queueMicrotask(resumeIfDecoderReady);
-    const events = ["pause", "canplay", "seeked"] as const;
-    for (const event of events) video.addEventListener(event, queueResume);
-    resumeIfDecoderReady();
-    return () => {
-      cancelled = true;
-      for (const event of events) video.removeEventListener(event, queueResume);
-    };
-  }, [bufferRevision, playback?.playing, playbackAuthority, segmented, visualState]);
-
  useEffect(() => {
    const video = videoRef.current;
    if ((!interactive && onPlaybackChange === undefined) || !video || !epoch || visualState !== "ready") return;
@@ -1611,9 +1327,7 @@ export function RecordedFmp4Player({
          {visualState === "waiting"
            ? "Камера на этой позиции ещё не записывалась"
            : visualState === "error"
-              ? errorMessage ?? "Записанное видео недоступно"
-              : errorMessage
-                ? errorMessage
+              ? "Записанное видео недоступно"
              : archive
                ? "Проверяем seek и codec записанного видео…"
                : "Читаем manifest записанного видео…"}
@@ -1,33 +0,0 @@
-import { CanonicalResultRerunReplay } from "./CanonicalResultRerunReplay";
-import { resolveAICompositionReplay } from "../../core/laboratory/canonicalLabReplay";
-import type { ObservationSessionReplayLaunch } from "../../core/observation/sessionArchive";
-import type { AICompositionRun } from "../../core/observatory/aiComposition";
-
-function resolveComposition(
-  runId: string,
-  launch: ObservationSessionReplayLaunch,
-  options: { signal: AbortSignal },
-) {
-  return resolveAICompositionReplay(runId, launch, options);
-}
-
-export function AICompositionReplay({ run }: { run: AICompositionRun }) {
-  const semantics = run.moduleIds.includes("ddrnet") || run.moduleIds.includes("eomt");
-  const detections = run.moduleIds.includes("rf-detr")
-    || run.moduleIds.includes("object-distance");
-  const costmap = run.moduleIds.includes("tgs");
-  return (
-    <CanonicalResultRerunReplay
-      key={run.runId}
-      resultId={run.runId}
-      sessionId={run.sourceSessionId}
-      resolveReplay={resolveComposition}
-      semantics={semantics}
-      detections={detections}
-      costmap={costmap}
-      moduleIds={run.moduleIds}
-      viewerLayers={run.presentation.viewerLayers}
-      label={run.configurationLabel}
-    />
-  );
-}
@@ -1,265 +0,0 @@
-import { useCallback, useEffect, useState, type ReactNode } from "react";
-import { SegmentedControl, SplitPane, type SplitPaneOrientation } from "@nodedc/ui-react";
-
-import { LaboratoryEvidenceViewer } from "./LaboratoryEvidenceViewer";
-
-export const CANONICAL_RECORDED_LAB_REPLAY_CONTRACT =
-  "missioncore.canonical-recorded-lab-replay/v1";
-
-export interface CanonicalRecordedLabMode<T extends string> {
-  value: T;
-  label: string;
-  disabled?: boolean;
-}
-
-/**
- * The interaction contract from the accepted recorded-LAB instrument.
- *
- * Keeping pane selection, collapse semantics, responsive split orientation,
- * expansion and splitter state here prevents individual experiments from
- * quietly growing their own replay behaviour.  Experiments provide evidence
- * layers; they do not reimplement the laboratory shell.
- */
-export function useCanonicalRecordedLabReplayState<
-  TMedia extends string,
-  TSpatial extends string,
->({
-  initialMediaMode,
-  initialSpatialMode,
-}: {
-  initialMediaMode: TMedia;
-  initialSpatialMode: TSpatial | null;
-}) {
-  const [mediaMode, setMediaMode] = useState<TMedia | null>(initialMediaMode);
-  const [spatialMode, setSpatialMode] = useState<TSpatial | null>(initialSpatialMode);
-  const [splitPrimarySize, setSplitPrimarySize] = useState(50);
-  const [splitOrientation, setSplitOrientation] = useState<SplitPaneOrientation>(() => (
-    typeof window !== "undefined" && window.matchMedia("(max-width: 900px)").matches
-      ? "horizontal"
-      : "vertical"
-  ));
-  const [expanded, setExpanded] = useState(false);
-
-  useEffect(() => {
-    const query = window.matchMedia("(max-width: 900px)");
-    const update = () => setSplitOrientation(query.matches ? "horizontal" : "vertical");
-    update();
-    query.addEventListener("change", update);
-    return () => query.removeEventListener("change", update);
-  }, []);
-
-  const onMediaModeChange = useCallback((next: TMedia | "none") => {
-    if (next === "none") return;
-    setMediaMode((current) => current === next ? null : next);
-  }, []);
-  const onSpatialModeChange = useCallback((next: TSpatial | "none") => {
-    if (next === "none") return;
-    setSpatialMode((current) => current === next ? null : next);
-  }, []);
-
-  return {
-    mediaMode,
-    spatialMode,
-    splitView: mediaMode !== null && spatialMode !== null,
-    splitPrimarySize,
-    splitOrientation,
-    expanded,
-    onMediaModeChange,
-    onSpatialModeChange,
-    onSplitPrimarySizeChange: setSplitPrimarySize,
-    onExpandedChange: setExpanded,
-  };
-}
-
-export function CanonicalRecordedLabReplay<
-  TMedia extends string,
-  TSpatial extends string,
->({
-  label,
-  mediaMode,
-  mediaModes,
-  spatialMode,
-  spatialModes,
-  expanded,
-  splitPrimarySize,
-  splitOrientation,
-  mediaAriaLabel,
-  spatialAriaLabel,
-  mediaLayerControls,
-  spatialLayerControls,
-  spatialLeadingControl,
-  spatialTrailingControl,
-  mediaModeControlsVisible = true,
-  paneToolbarsAlwaysVisible = false,
-  mediaMultiLayer = false,
-  mediaContent,
-  spatialContent,
-  unifiedContent,
-  emptyMessage,
-  deckOverlays,
-  actions,
-  overlay,
-  transport,
-  trailingActions,
-  onMediaModeChange,
-  onSpatialModeChange,
-  onExpandedChange,
-  onSplitPrimarySizeChange,
-}: {
-  label: string;
-  mediaMode: TMedia;
-  mediaModes: readonly CanonicalRecordedLabMode<TMedia>[];
-  spatialMode: TSpatial;
-  spatialModes: readonly CanonicalRecordedLabMode<TSpatial>[];
-  expanded: boolean;
-  splitPrimarySize: number;
-  splitOrientation: SplitPaneOrientation;
-  mediaAriaLabel: string;
-  spatialAriaLabel: string;
-  mediaLayerControls?: ReactNode;
-  spatialLayerControls?: ReactNode;
-  spatialLeadingControl?: ReactNode;
-  spatialTrailingControl?: ReactNode;
-  mediaModeControlsVisible?: boolean;
-  /** Keeps renderer-local controls inside their viewport when only one pane is present. */
-  paneToolbarsAlwaysVisible?: boolean;
-  mediaMultiLayer?: boolean;
-  mediaContent?: ReactNode;
-  spatialContent?: ReactNode;
-  /** One upstream Rerun viewer owns both panes; this controlled split owns their shared geometry. */
-  unifiedContent?: ReactNode;
-  emptyMessage: string;
-  deckOverlays?: ReactNode;
-  actions?: ReactNode;
-  overlay?: ReactNode;
-  transport?: ReactNode;
-  trailingActions?: ReactNode;
-  onMediaModeChange: (mode: TMedia) => void;
-  onSpatialModeChange: (mode: TSpatial) => void;
-  onExpandedChange: (expanded: boolean) => void;
-  onSplitPrimarySizeChange: (size: number) => void;
-}) {
-  const splitView = mediaMode !== "none" && spatialMode !== "none";
-  const mediaModeControls = (
-    <div className="m4-replay-threat-visual__pane-mode-controls" data-pane-mode="media">
-      <SegmentedControl
-        value={mediaMode}
-        items={[...mediaModes]}
-        label="Видео и камера"
-        size="dense"
-        onChange={onMediaModeChange}
-      />
-    </div>
-  );
-  const spatialModeControls = (
-    <div className="m4-replay-threat-visual__pane-mode-controls" data-pane-mode="spatial">
-      <SegmentedControl
-        value={spatialMode}
-        items={[...spatialModes]}
-        label="3D и план"
-        size="dense"
-        onChange={onSpatialModeChange}
-      />
-    </div>
-  );
-  const mediaPane = (
-    <section
-      className="m4-replay-threat-visual__pane"
-      data-pane="media"
-      aria-label={mediaAriaLabel}
-      hidden={mediaMode === "none"}
-    >
-      {splitView || paneToolbarsAlwaysVisible ? (
-        <div
-          className="m4-replay-threat-visual__pane-toolbar"
-          data-pane-toolbar="media"
-          data-multi-semantic={mediaMultiLayer ? "true" : undefined}
-        >
-          {mediaLayerControls}
-          {mediaModeControlsVisible ? mediaModeControls : null}
-        </div>
-      ) : null}
-      {mediaContent}
-    </section>
-  );
-  const spatialPane = spatialMode !== "none" ? (
-    <section
-      className="m4-replay-threat-visual__pane"
-      data-pane="spatial"
-      aria-label={spatialAriaLabel}
-    >
-      {splitView || paneToolbarsAlwaysVisible ? (
-        <div
-          className="m4-replay-threat-visual__pane-toolbar"
-          data-pane-toolbar="spatial"
-        >
-          {spatialLeadingControl}
-          <div className="m4-replay-threat-visual__spatial-toolbar-end">
-            {spatialLayerControls}
-            {spatialModeControls}
-            {spatialTrailingControl}
-          </div>
-        </div>
-      ) : null}
-      {spatialContent}
-    </section>
-  ) : null;
-
-  return (
-    <div
-      className="l3-visual-audit m4-replay-threat-visual"
-      data-contract={CANONICAL_RECORDED_LAB_REPLAY_CONTRACT}
-    >
-      <LaboratoryEvidenceViewer
-        label={label}
-        className="m4-replay-threat-evidence-viewer"
-        mode={mediaMode}
-        modes={[...mediaModes]}
-        secondaryMode={{
-          value: spatialMode,
-          modes: [...spatialModes],
-          label: "3D и план",
-          onChange: onSpatialModeChange,
-        }}
-        expanded={expanded}
-        onModeChange={onMediaModeChange}
-        onExpandedChange={onExpandedChange}
-        modeControlsVisible={!splitView && !paneToolbarsAlwaysVisible}
-        actions={actions}
-        overlay={overlay}
-        transport={transport}
-        trailingActions={trailingActions}
-      >
-        <div
-          className="m4-replay-threat-visual__deck"
-          data-split={splitView ? "true" : undefined}
-          data-empty={mediaMode === "none" && spatialMode === "none" ? "true" : undefined}
-          data-native-rerun={unifiedContent ? "true" : undefined}
-        >
-          {unifiedContent ? (
-            <div className="m4-replay-threat-visual__unified-content">
-              {unifiedContent}
-            </div>
-          ) : null}
-          <SplitPane
-            primary={mediaPane}
-            secondary={spatialPane ?? <div />}
-            primarySize={splitView ? splitPrimarySize : mediaMode !== "none" ? 100 : 0}
-            onPrimarySizeChange={onSplitPrimarySizeChange}
-            orientation={splitOrientation}
-            minPrimarySize={splitView ? 24 : 0}
-            minSecondarySize={splitView ? 24 : 0}
-            resizable={splitView}
-            separatorLabel="Изменить размер видео/камеры и 3D/плана"
-          />
-          {mediaMode === "none" && spatialMode === "none" ? (
-            <div className="l3-visual-audit__state" role="status">
-              {emptyMessage}
-            </div>
-          ) : null}
-          {deckOverlays}
-        </div>
-      </LaboratoryEvidenceViewer>
-    </div>
-  );
-}
@@ -1,525 +0,0 @@
-import {
-  useCallback,
-  useEffect,
-  useMemo,
-  useRef,
-  useState,
-} from "react";
-import {
-  ActivityIndicator,
-  Button,
-  Checker,
-  ControlRow,
-  Icon,
-  IconButton,
-  Inspector,
-  InspectorSelectField,
-  RangeControl,
-  ToastStack,
-  Window,
-  type ToastItem,
-} from "@nodedc/ui-react";
-
-import { ObservationTimeline } from "../ObservationTimeline";
-import {
-  RerunViewport,
-  isRecordedPlaybackPresentationReady,
-  type RerunPlaybackController,
-  type RerunPlaybackState,
-  type RerunViewportStatus,
-} from "../RerunViewport";
-import {
-  CanonicalRecordedLabReplay,
-  useCanonicalRecordedLabReplayState,
-} from "../laboratory/CanonicalRecordedLabReplay";
-import type { CanonicalLabReplayDescriptor } from "../../core/laboratory/canonicalLabReplay";
-import type { ObservationSessionReplayLaunch } from "../../core/observation/sessionArchive";
-import { laboratoryResultRerunProfile } from "../../core/observation/viewerProfile";
-import { resolveObservationSessionReplay } from "../../core/observation/useObservationSessions";
-import type { AIViewerLayer } from "../../core/observatory/aiComposition";
-import {
-  fetchLabViewProfile,
-  saveLabViewProfile,
-} from "../../core/observatory/labViewProfile";
-import {
-  defaultSceneSettings,
-  type PointColorMode,
-  type PointPalette,
-  type SceneSettings,
-} from "../../sceneSettings";
-
-type MediaMode = "camera";
-type SpatialMode = "3d" | "plan";
-
-interface CanonicalReplayLaunch {
-  base: ObservationSessionReplayLaunch;
-  replay: CanonicalLabReplayDescriptor;
-}
-
-const RERUN_UNIFIED_CAMERA_SHARE_PERCENT = 46;
-const LAB_SCENE_SETTINGS_STORAGE_PREFIX = "missioncore.observatory.lab-scene-settings.v1:";
-const LAB_VIEW_PROFILE_ERROR_TOAST = "observatory-lab-view-profile-error";
-
-const COLOR_OPTIONS: readonly { value: PointColorMode; label: string }[] = [
-  { value: "intensity", label: "Интенсивность" },
-  { value: "height", label: "Высота Z" },
-  { value: "distance", label: "Дистанция" },
-  { value: "rgb", label: "RGB" },
-  { value: "class", label: "Класс" },
-];
-
-const PALETTE_OPTIONS: readonly { value: PointPalette; label: string }[] = [
-  { value: "turbo", label: "Turbo" },
-  { value: "viridis", label: "Viridis" },
-  { value: "plasma", label: "Plasma" },
-  { value: "grayscale", label: "Серый" },
-];
-
-const LAB_SCENE_DEFAULTS: SceneSettings = {
-  ...defaultSceneSettings,
-  pointSize: 3.8,
-  accumulationSeconds: 5,
-};
-
-export function normalizeLabSceneSettings(settings: SceneSettings): SceneSettings {
-  const pointSize = Number.isFinite(settings.pointSize) ? settings.pointSize : LAB_SCENE_DEFAULTS.pointSize;
-  const accumulationSeconds = Number.isFinite(settings.accumulationSeconds)
-    ? settings.accumulationSeconds : LAB_SCENE_DEFAULTS.accumulationSeconds;
-  return {
-    ...settings,
-    pointSize: Math.round(Math.max(0.1, pointSize) * 10) / 10,
-    accumulationSeconds: Math.round(Math.max(0, accumulationSeconds)),
-  };
-}
-
-function loadLabSceneSettings(resultId: string): SceneSettings {
-  if (typeof window === "undefined") return LAB_SCENE_DEFAULTS;
-  try {
-    const raw = window.localStorage.getItem(`${LAB_SCENE_SETTINGS_STORAGE_PREFIX}${resultId}`);
-    if (raw === null) return LAB_SCENE_DEFAULTS;
-    const value: unknown = JSON.parse(raw);
-    if (typeof value !== "object" || value === null || Array.isArray(value)) return LAB_SCENE_DEFAULTS;
-    const row = value as Record<string, unknown>;
-    const pointSize = row.pointSize;
-    const accumulationSeconds = row.accumulationSeconds;
-    const colorMode = row.colorMode;
-    const palette = row.palette;
-    const showGrid = row.showGrid;
-    const showLabels = row.showLabels;
-    const showCameraFrustums = row.showCameraFrustums;
-    if (
-      typeof pointSize !== "number" || !Number.isFinite(pointSize) || pointSize < 0.1
-      || typeof accumulationSeconds !== "number" || !Number.isFinite(accumulationSeconds)
-      || accumulationSeconds < 0
-      || !COLOR_OPTIONS.some((option) => option.value === colorMode)
-      || !PALETTE_OPTIONS.some((option) => option.value === palette)
-      || typeof showGrid !== "boolean"
-      || typeof showLabels !== "boolean"
-      || typeof showCameraFrustums !== "boolean"
-    ) return LAB_SCENE_DEFAULTS;
-    return {
-      ...LAB_SCENE_DEFAULTS,
-      pointSize,
-      accumulationSeconds,
-      colorMode: colorMode as PointColorMode,
-      palette: palette as PointPalette,
-      showGrid,
-      showLabels,
-      showCameraFrustums,
-    };
-  } catch {
-    return LAB_SCENE_DEFAULTS;
-  }
-}
-
-export function CanonicalResultRerunReplay({
-  resultId,
-  sessionId,
-  initialPlaybackStartSeconds,
-  resolveReplay,
-  semantics = false,
-  detections = false,
-  costmap = false,
-  moduleIds = [],
-  viewerLayers = [],
-  label = "Сохранённый результат",
-}: {
-  resultId: string;
-  sessionId: string;
-  initialPlaybackStartSeconds?: number;
-  resolveReplay: (resultId: string, launch: ObservationSessionReplayLaunch, options: { signal: AbortSignal }) => Promise<CanonicalLabReplayDescriptor>;
-  semantics?: boolean;
-  detections?: boolean;
-  costmap?: boolean;
-  portable?: boolean;
-  moduleIds?: readonly string[];
-  viewerLayers?: readonly AIViewerLayer[];
-  label?: string;
-}) {
-  const {
-    mediaMode,
-    spatialMode,
-    splitPrimarySize,
-    splitOrientation,
-    expanded,
-    onMediaModeChange,
-    onSpatialModeChange,
-    onSplitPrimarySizeChange,
-    onExpandedChange,
-  } = useCanonicalRecordedLabReplayState<MediaMode, SpatialMode>({
-    initialMediaMode: "camera",
-    initialSpatialMode: "3d",
-  });
-  const layerIds = useMemo(
-    () => new Set(viewerLayers.map((layer) => layer.layerId)),
-    [viewerLayers],
-  );
-  const hasProjectedLayers = viewerLayers.length > 0;
-  const hasDDRNet = layerIds.has("camera.ddrnet")
-    || (!hasProjectedLayers && semantics && moduleIds.includes("ddrnet"));
-  const hasEoMT = layerIds.has("camera.eomt")
-    || (!hasProjectedLayers && semantics && moduleIds.includes("eomt"));
-  const hasFallbackSemantics = semantics && !hasDDRNet && !hasEoMT;
-  const hasDetections = layerIds.has("camera.detections") || (!hasProjectedLayers && detections);
-  const hasTgs = layerIds.has("spatial.tgs") || (!hasProjectedLayers && costmap);
-  const legacyUnclassified = !hasProjectedLayers
-    && moduleIds.length === 0
-    && !semantics
-    && !detections
-    && !costmap;
-  const hasCameraPane = layerIds.has("camera.source")
-    || (!hasProjectedLayers && (legacyUnclassified || semantics || detections));
-  const hasSourcePoints = layerIds.has("spatial.source-points")
-    || (!hasProjectedLayers && (legacyUnclassified || costmap || moduleIds.includes("object-distance")));
-  const hasLocalSlam = layerIds.has("spatial.local-slam")
-    || (!hasProjectedLayers && (legacyUnclassified || costmap || moduleIds.includes("object-distance")));
-  const hasSpatialPane = hasSourcePoints || hasLocalSlam || hasTgs;
-  const splitView = hasCameraPane && hasSpatialPane;
-
-  const [showCamera, setShowCamera] = useState(true);
-  const [showDDRNet, setShowDDRNet] = useState(hasDDRNet || hasFallbackSemantics);
-  const [showEoMT, setShowEoMT] = useState(hasEoMT);
-  const [showDetections, setShowDetections] = useState(hasDetections);
-  const [showSourcePoints, setShowSourcePoints] = useState(hasSourcePoints);
-  const [showLocalSlam, setShowLocalSlam] = useState(hasLocalSlam);
-  const [showTgs, setShowTgs] = useState(hasTgs);
-  const [followTarget, setFollowTarget] = useState(false);
-  const [settingsOpen, setSettingsOpen] = useState(false);
-  const [sceneDraft, setSceneDraft] = useState<SceneSettings>(() => loadLabSceneSettings(resultId));
-  const [blueprintSplitPrimarySize, setBlueprintSplitPrimarySize] = useState(
-    RERUN_UNIFIED_CAMERA_SHARE_PERCENT,
-  );
-  const [toasts, setToasts] = useState<ToastItem[]>([]);
-  const [viewResetGeneration, setViewResetGeneration] = useState<0 | 1>(hasTgs ? 1 : 0);
-  const [playback, setPlayback] = useState<RerunPlaybackState | null>(null);
-  const [playbackController, setPlaybackController] = useState<RerunPlaybackController | null>(null);
-  const [viewerStatus, setViewerStatus] = useState<RerunViewportStatus>("idle");
-  const [launch, setLaunch] = useState<CanonicalReplayLaunch | null>(null);
-  const [launchError, setLaunchError] = useState<string | null>(null);
-  const sceneDraftRef = useRef(sceneDraft);
-  const previousSplitViewRef = useRef(splitView);
-  const trackedLaunchSha256Ref = useRef<string | null>(null);
-
-  useEffect(() => {
-    const launchSha256 = launch?.replay.sha256 ?? null;
-    if (trackedLaunchSha256Ref.current !== launchSha256 || (splitView && !previousSplitViewRef.current)) {
-      onSplitPrimarySizeChange(RERUN_UNIFIED_CAMERA_SHARE_PERCENT);
-      setBlueprintSplitPrimarySize(RERUN_UNIFIED_CAMERA_SHARE_PERCENT);
-    }
-    trackedLaunchSha256Ref.current = launchSha256;
-    previousSplitViewRef.current = splitView;
-  }, [launch?.replay.sha256, onSplitPrimarySizeChange, splitView]);
-
-  useEffect(() => {
-    if (!splitView) return;
-    const timer = window.setTimeout(() => setBlueprintSplitPrimarySize(splitPrimarySize), 75);
-    return () => window.clearTimeout(timer);
-  }, [splitPrimarySize, splitView]);
-
-  useEffect(() => {
-    try {
-      window.localStorage.setItem(
-        `${LAB_SCENE_SETTINGS_STORAGE_PREFIX}${resultId}`,
-        JSON.stringify({
-          pointSize: sceneDraft.pointSize,
-          accumulationSeconds: sceneDraft.accumulationSeconds,
-          colorMode: sceneDraft.colorMode,
-          palette: sceneDraft.palette,
-          showGrid: sceneDraft.showGrid,
-          showLabels: sceneDraft.showLabels,
-          showCameraFrustums: sceneDraft.showCameraFrustums,
-        }),
-      );
-    } catch {
-      // The visual remains usable when the browser refuses local persistence.
-    }
-  }, [resultId, sceneDraft]);
-
-  useEffect(() => {
-    const controller = new AbortController();
-    void fetchLabViewProfile(resultId, controller.signal).then((settings) => {
-      if (!controller.signal.aborted && settings) {
-        sceneDraftRef.current = settings;
-        setSceneDraft(settings);
-      }
-    }).catch(() => {
-      // The per-browser copy remains a usable fallback while the local service recovers.
-    });
-    return () => controller.abort();
-  }, [resultId]);
-
-  useEffect(() => {
-    const controller = new AbortController();
-    setLaunch(null);
-    setLaunchError(null);
-    setPlayback(null);
-    setPlaybackController(null);
-    setViewerStatus("idle");
-    void resolveObservationSessionReplay(sessionId, {
-      signal: controller.signal,
-      maximumWaitMs: 30 * 60 * 1000,
-      onUpdate: () => undefined,
-    }).then(async (value) => ({
-      base: value,
-      replay: await resolveReplay(resultId, value, { signal: controller.signal }),
-    })).then((value) => {
-      if (!controller.signal.aborted) setLaunch(value);
-    }).catch((caught: unknown) => {
-      if (!controller.signal.aborted) {
-        setLaunchError(caught instanceof Error ? caught.message : "Сохранённая запись недоступна.");
-      }
-    });
-    return () => controller.abort();
-  }, [resultId, sessionId, resolveReplay]);
-
-  const presentationReady = playbackController !== null
-    && isRecordedPlaybackPresentationReady(viewerStatus, playback);
-  const presentationState = launchError || viewerStatus === "error"
-    ? "error"
-    : presentationReady ? "ready" : "loading";
-  const sceneSettings = useMemo<SceneSettings>(() => ({
-    ...sceneDraft,
-    projection: spatialMode === "plan" ? "2d" : "3d",
-    showPoints: spatialMode !== null && (showSourcePoints || showLocalSlam),
-    showTrajectory: spatialMode !== null && showLocalSlam,
-    accumulationSeconds: showLocalSlam ? sceneDraft.accumulationSeconds : 0,
-  }), [sceneDraft, showLocalSlam, showSourcePoints, spatialMode]);
-  const semanticVisible = showDDRNet || showEoMT;
-  const profile = launch ? laboratoryResultRerunProfile({
-    resultId,
-    sourceUrl: launch.replay.sourceUrl,
-    artifact: {
-      sourceUrl: launch.replay.sourceUrl,
-      viewerSourceUrl: launch.replay.viewerSourceUrl,
-      byteLength: launch.replay.byteLength,
-      sha256: launch.replay.sha256,
-    },
-    blueprintSourceUrl: launch.replay.blueprintSourceUrl,
-    autoplayWhenReady: false,
-    presentationGate: "ready",
-    expectedTimelineStartSeconds: launch.base.timelineStartSeconds,
-    expectedTimelineEndSeconds: launch.base.timelineEndSeconds,
-    initialPlaybackStartSeconds: initialPlaybackStartSeconds
-      ?? ((launch.base.mediaSources[0]?.timelineStartSeconds ?? launch.base.timelineStartSeconds)
-        + (hasTgs ? 0.000001 : 0)),
-    view: hasCameraPane && !hasSpatialPane ? "perception" : "spatial",
-    viewResetGeneration,
-    followTrajectory: followTarget,
-    semanticLayer: showEoMT ? "city" : "vegetation",
-    unifiedPerception: splitView,
-    unifiedCameraShare: blueprintSplitPrimarySize / 100,
-    planView: spatialMode === "plan",
-    perceptionLayers: {
-      enabled: true,
-      cameraImage: showCamera,
-      detections2d: hasDetections && showDetections,
-      segmentation: semantics && semanticVisible,
-      cuboids3d: false,
-      costmap: hasTgs && showTgs,
-    },
-    perceptionRetryGeneration: 0,
-    lockPerceptionCameraInteraction: false,
-  }) : null;
-
-  const toggle = (caption: string, active: boolean, onClick: () => void) => (
-    <Button key={caption} size="dense" shape="pill" variant={active ? "primary" : "secondary"}
-      aria-pressed={active} onClick={onClick}>
-      {caption}
-    </Button>
-  );
-  const openSlamSettings = useCallback(() => {
-    if (expanded) onExpandedChange(false);
-    setSettingsOpen(true);
-  }, [expanded, onExpandedChange]);
-  const patchSceneDraft = useCallback((patch: Partial<SceneSettings>) => {
-    const next = { ...sceneDraftRef.current, ...patch };
-    sceneDraftRef.current = next;
-    setSceneDraft(next);
-  }, []);
-  const closeSlamSettings = useCallback(() => {
-    const next = normalizeLabSceneSettings(sceneDraftRef.current);
-    sceneDraftRef.current = next;
-    setSceneDraft(next);
-    setSettingsOpen(false);
-    void saveLabViewProfile(resultId, next).then((settings) => {
-      sceneDraftRef.current = settings;
-      setSceneDraft(settings);
-      setToasts((current) => current.filter(({ id }) => id !== LAB_VIEW_PROFILE_ERROR_TOAST));
-    }).catch(() => {
-      setToasts((current) => [
-        ...current.filter(({ id }) => id !== LAB_VIEW_PROFILE_ERROR_TOAST),
-        {
-          id: LAB_VIEW_PROFILE_ERROR_TOAST,
-          tone: "error",
-          title: "Настройки LAB не сохранились",
-          description: "Изменения остались в текущем просмотре. Откройте настройки и повторите.",
-        },
-      ]);
-    });
-  }, [resultId]);
-  const mediaLayerControls = (
-    <div className="m4-replay-threat-visual__pane-layer-controls" role="group" aria-label="Слои камеры">
-      {toggle("КАМЕРА", showCamera, () => setShowCamera((value) => !value))}
-      {hasEoMT ? toggle("EOMT", showEoMT, () => setShowEoMT((value) => !value)) : null}
-      {hasDDRNet || hasFallbackSemantics
-        ? toggle("DDRNET", showDDRNet, () => setShowDDRNet((value) => !value)) : null}
-      {hasDetections
-        ? toggle("РАМКИ", showDetections, () => setShowDetections((value) => !value)) : null}
-    </div>
-  );
-  const spatialLayerControls = (
-    <div className="m4-replay-threat-visual__pane-layer-controls" role="group" aria-label="Слои облака точек">
-      {hasSourcePoints
-        ? toggle("ИСХ. ТОЧКИ", showSourcePoints, () => setShowSourcePoints((value) => !value)) : null}
-      {hasLocalSlam ? (
-        <div className="m4-replay-threat-visual__layer-with-settings">
-          {toggle("ЛОК. SLAM", showLocalSlam, () => setShowLocalSlam((value) => !value))}
-          <IconButton label="Настройки облака SLAM" onClick={openSlamSettings}>
-            <Icon name="settings" size={14} />
-          </IconButton>
-        </div>
-      ) : null}
-      {hasTgs ? toggle("TGS", showTgs, () => setShowTgs((value) => !value)) : null}
-    </div>
-  );
-  const followTargetControl = toggle(
-    "СЛЕДОВАТЬ",
-    followTarget,
-    () => setFollowTarget((value) => !value),
-  );
-  const resetSpatialView = (
-    <IconButton label="Сбросить положение видов"
-      onClick={() => setViewResetGeneration((value) => value === 0 ? 1 : 0)}>
-      <Icon name="refresh" size={16} />
-    </IconButton>
-  );
-
-  const transport = presentationReady && playback && playbackController ? (
-    <ObservationTimeline
-      className="m4-replay-threat-visual__timeline canonical-vegetation-rerun-replay__timeline"
-      active
-      sourceCount={3}
-      mode="recorded"
-      seekable
-      synchronization="shared-clock"
-      rangeNs={playback.rangeNs}
-      currentNs={playback.currentNs}
-      playing={playback.playing}
-      onSeek={playbackController.seek}
-      onPlayingChange={playbackController.setPlaying}
-      showJumpToEnd={false}
-    />
-  ) : undefined;
-
-  return (
-    <div className="canonical-vegetation-rerun-replay" data-presentation-state={presentationState}
-      aria-busy={presentationState === "loading"}>
-      <CanonicalRecordedLabReplay
-        label={label}
-        mediaMode={hasCameraPane ? mediaMode ?? "camera" : "none"}
-        mediaModes={[{ value: "camera", label: "КАМЕРА" }]}
-        spatialMode={hasSpatialPane ? spatialMode ?? "3d" : "none"}
-        spatialModes={[{ value: "3d", label: "3D" }, { value: "plan", label: "ПЛАН" }]}
-        expanded={expanded}
-        splitPrimarySize={splitPrimarySize}
-        splitOrientation={splitView ? "vertical" : splitOrientation}
-        mediaAriaLabel="Камера и рассчитанные слои"
-        spatialAriaLabel={spatialMode === "plan" ? "Вид сверху" : "Трёхмерная сцена"}
-        mediaLayerControls={mediaLayerControls}
-        spatialLayerControls={spatialLayerControls}
-        spatialTrailingControl={followTargetControl}
-        mediaModeControlsVisible={false}
-        paneToolbarsAlwaysVisible
-        mediaMultiLayer
-        actions={resetSpatialView}
-        unifiedContent={profile ? (
-          <div className="canonical-vegetation-rerun-replay__viewport-lock"
-            data-split-view={splitView ? "true" : undefined}>
-            <RerunViewport profile={profile} sceneSettings={sceneSettings}
-              onStatusChange={setViewerStatus} onPlaybackChange={setPlayback}
-              onPlaybackControllerChange={setPlaybackController} />
-          </div>
-        ) : launchError ? (
-          <div className="l3-visual-audit__state" role="alert">{launchError}</div>
-        ) : <div aria-hidden="true" />}
-        emptyMessage="Слои результата недоступны."
-        deckOverlays={presentationState === "loading" ? (
-          <div className="canonical-vegetation-rerun-replay__loading">
-            <ActivityIndicator label="Загружаем синхронизированную запись" />
-          </div>
-        ) : undefined}
-        transport={transport}
-        onMediaModeChange={onMediaModeChange}
-        onSpatialModeChange={onSpatialModeChange}
-        onExpandedChange={onExpandedChange}
-        onSplitPrimarySizeChange={onSplitPrimarySizeChange}
-      />
-      <Window open={settingsOpen} title="Отображение" subtitle="Параметры облака SLAM"
-        placement="end" size="sm" onClose={closeSlamSettings}>
-        <Inspector defaultOpen={["points"]} sections={[
-          {
-            id: "points",
-            label: "Облако точек",
-            description: "Размер и способ окрашивания",
-            content: <>
-              <RangeControl label="Размер точки" min={0.1} max={10} step={0.1}
-                exactValueBounds={{ min: 0.1 }}
-                value={sceneDraft.pointSize} formatValue={(value) => `${value.toFixed(1)} пкс`}
-                onChange={(pointSize) => patchSceneDraft({ pointSize })} />
-              <InspectorSelectField label="Атрибут цвета" value={sceneDraft.colorMode}
-                options={[...COLOR_OPTIONS]}
-                onChange={(colorMode) => patchSceneDraft({ colorMode })} />
-              <InspectorSelectField label="Палитра" value={sceneDraft.palette}
-                options={[...PALETTE_OPTIONS]}
-                onChange={(palette) => patchSceneDraft({ palette })} />
-            </>,
-          },
-          {
-            id: "history",
-            label: "Накопление и время",
-            description: "История облака и траектория",
-            content: <RangeControl label="Накопление" min={0} max={500} step={1}
-              exactValueBounds={{ min: 0 }}
-              value={sceneDraft.accumulationSeconds} formatValue={(value) => `${value} с`}
-              onChange={(accumulationSeconds) => patchSceneDraft({ accumulationSeconds })} />,
-          },
-          {
-            id: "environment",
-            label: "Окружение сцены",
-            description: "Сетка, подписи и камеры",
-            content: <>
-              <ControlRow label="Сетка"><Checker checked={sceneDraft.showGrid} label="Показывать"
-                onChange={(showGrid) => patchSceneDraft({ showGrid })} /></ControlRow>
-              <ControlRow label="Подписи"><Checker checked={sceneDraft.showLabels} label="Показывать"
-                onChange={(showLabels) => patchSceneDraft({ showLabels })} /></ControlRow>
-              <ControlRow label="Камеры"><Checker checked={sceneDraft.showCameraFrustums} label="Показывать"
-                onChange={(showCameraFrustums) => patchSceneDraft({ showCameraFrustums })} /></ControlRow>
-            </>,
-          },
-        ]} />
-      </Window>
-      <ToastStack items={toasts}
-        onDismiss={(id) => setToasts((current) => current.filter((item) => item.id !== id))} />
-    </div>
-  );
-}
@@ -1,12 +0,0 @@
-import { CanonicalResultRerunReplay } from "./CanonicalResultRerunReplay";
-import { resolveCanonicalLabReplay } from "../../core/laboratory/canonicalLabReplay";
-import type { VegetationFullRouteReview } from "../../core/laboratory/vegetationShadow";
-
-export function CanonicalVegetationRerunReplay({ resultId, review }: {
-  resultId: string;
-  review: VegetationFullRouteReview;
-}) {
-  return <CanonicalResultRerunReplay resultId={resultId} sessionId={review.sessionId}
-    initialPlaybackStartSeconds={review.timelineStartSeconds} semantics
-    resolveReplay={resolveCanonicalLabReplay} label="RAVNOVES004TREE · канонический повтор Rerun" />;
-}
@@ -53,7 +53,7 @@ export const LABORATORY_REPORT_TEMPLATE_VERSION =

 const EXECUTION_LABELS: Record<LaboratoryExecutionClass, string> = {
  deterministic: "Детерминированный",
-  "ai-inference": "AI Inference",
+  "ai-inference": "AI inference",
  hybrid: "Гибридный",
 };

@@ -59,16 +59,6 @@ export function laboratoryRecordedClipEndExclusiveNs(
  return last.sourceTimeNs + typicalDelta;
 }

-export function laboratoryRecordedClipClockGate(
-  pendingSequence: number | null,
-  observedSequence: number,
-): { accept: boolean; pendingSequence: number | null } {
-  if (pendingSequence !== null && pendingSequence !== observedSequence) {
-    return { accept: false, pendingSequence };
-  }
-  return { accept: true, pendingSequence: null };
-}
-
 export function LaboratoryRecordedClipPlayer({
  source,
  segmentCount,
@@ -104,8 +94,7 @@ export function LaboratoryRecordedClipPlayer({
 }) {
  const [companionSpatialSize, setCompanionSpatialSize] = useState(69);
  const lastEmittedSequenceRef = useRef(sequence);
-  const lastObservedSequenceRef = useRef<number | null>(sequence);
-  const pendingSequenceRef = useRef<number | null>(null);
+  lastEmittedSequenceRef.current = sequence;
  const frame = useMemo(
    () => frames.find((candidate) => candidate.sequence === sequence) ?? frames[0] ?? null,
    [frames, sequence],
@@ -124,42 +113,23 @@ export function LaboratoryRecordedClipPlayer({
    if (!continuousPlayback && playing) onPlayingChange(false);
  }, [continuousPlayback, onPlayingChange, playing]);

-  useEffect(() => {
-    if (lastObservedSequenceRef.current !== sequence) {
-      pendingSequenceRef.current = sequence;
-    }
-    lastEmittedSequenceRef.current = sequence;
-  }, [sequence]);
-
  const emitSequence = useCallback((nextSequence: number) => {
    if (lastEmittedSequenceRef.current === nextSequence) return;
    lastEmittedSequenceRef.current = nextSequence;
    onSequenceChange(nextSequence);
  }, [onSequenceChange]);

-  const requestSequence = useCallback((nextSequence: number) => {
-    pendingSequenceRef.current = nextSequence;
-    emitSequence(nextSequence);
-  }, [emitSequence]);
-
  const handlePlaybackChange = useCallback((next: RecordedObservationPlayback) => {
    const sourceTimeNs = Math.round(next.currentSeconds * 1_000_000_000);
    const first = frames[0];
    if (!first || endExclusiveNs === null) return;
    if (sourceTimeNs >= endExclusiveNs) {
-      requestSequence(first.sequence);
+      emitSequence(first.sequence);
      return;
    }
    const nearest = nearestLaboratoryRecordedClipFrame(frames, sourceTimeNs);
-    if (!nearest) return;
-    lastObservedSequenceRef.current = nearest.sequence;
-    const gate = laboratoryRecordedClipClockGate(
-      pendingSequenceRef.current,
-      nearest.sequence,
-    );
-    pendingSequenceRef.current = gate.pendingSequence;
-    if (gate.accept) emitSequence(nearest.sequence);
-  }, [emitSequence, endExclusiveNs, frames, requestSequence]);
+    if (nearest) emitSequence(nearest.sequence);
+  }, [emitSequence, endExclusiveNs, frames]);

  const timelineStart = frames[0]?.sourceTimeNs ?? 0;
  const timelineEnd = frames.at(-1)?.sourceTimeNs ?? timelineStart + 1;
@@ -172,7 +142,7 @@ export function LaboratoryRecordedClipPlayer({
      className="laboratory-recorded-clip-player__spatial"
      aria-hidden={cameraPresentation === "primary"}
    >
-      {alternativeScene}
+      {cameraPresentation !== "primary" ? alternativeScene : null}
    </div>
  );
  const cameraPane = (
@@ -232,7 +202,7 @@ export function LaboratoryRecordedClipPlayer({
        onPlayingChange={continuousPlayback ? onPlayingChange : undefined}
        onSeek={(timeNs) => {
          const nearest = nearestLaboratoryRecordedClipFrame(frames, timeNs);
-          if (nearest) requestSequence(nearest.sequence);
+          if (nearest) emitSequence(nearest.sequence);
        }}
        showJumpToEnd={false}
      />
@@ -1,51 +0,0 @@
-import { GlassSurface } from "@nodedc/ui-react";
-import { CanonicalResultRerunReplay } from "./CanonicalResultRerunReplay";
-import { resolveCanonicalLabReplay } from "../../core/laboratory/canonicalLabReplay";
-import type { ObservatoryPortableResultReview } from "../../core/observatory/recordedRun";
-import type { ObservationSessionReplayLaunch } from "../../core/observation/sessionArchive";
-
-function resolvePortableTgsReplay(resultId: string, launch: ObservationSessionReplayLaunch,
-  options: { signal: AbortSignal }) {
-  return resolveCanonicalLabReplay(resultId, launch, { ...options, sourceKind: "portable-tgs" });
-}
-
-function resolvePortableSemanticReplay(resultId: string, launch: ObservationSessionReplayLaunch,
-  options: { signal: AbortSignal }) {
-  return resolveCanonicalLabReplay(resultId, launch, { ...options, sourceKind: "portable-semantic" });
-}
-
-function resolvePortableObjectReplay(resultId: string, launch: ObservationSessionReplayLaunch,
-  options: { signal: AbortSignal }) {
-  return resolveCanonicalLabReplay(resultId, launch, { ...options, sourceKind: "portable-objects" });
-}
-
-export function PortableResultReplay({
-  review,
-  label,
-}: {
-  review: ObservatoryPortableResultReview;
-  label?: string;
-}) {
-  const schema = review.resultDocument.schema_version;
-  const tgs = schema === "missioncore.recorded-tgs-costmap-review/v2";
-  const module = review.resultDocument.module;
-  const moduleId = module && typeof module === "object" && "module_id" in module
-    ? module.module_id : undefined;
-  const semantics = schema === "missioncore.recorded-eomt-ddrnet-review/v2"
-    || (schema === "missioncore.recorded-ai-layer-review/v1"
-      && (moduleId === "ddrnet" || moduleId === "eomt"));
-  const objects = schema === "missioncore.recorded-ai-layer-review/v1"
-    && (moduleId === "rf-detr" || moduleId === "object-distance");
-  if (!tgs && !semantics && !objects) return (
-    <GlassSurface className="observatory-replay-state" padding="lg">
-      <p role="alert">Сохранённый результат этого профиля пока не поддерживает визуальный разбор.</p>
-    </GlassSurface>
-  );
-  return <CanonicalResultRerunReplay key={review.resultId} resultId={review.resultId}
-      sessionId={review.sourceSessionId} portable costmap={tgs} semantics={semantics}
-      detections={objects}
-      moduleIds={typeof moduleId === "string" ? [moduleId] : []}
-      label={label}
-      resolveReplay={tgs ? resolvePortableTgsReplay
-        : objects ? resolvePortableObjectReplay : resolvePortableSemanticReplay} />;
-}
@@ -1,11 +1,8 @@
-import { useEffect, useState } from "react";
-
 import {
  RecordedFmp4Player,
  type RecordedObservationPlayback,
 } from "../RecordedFmp4Player";
 import type { ObservationSourceDescriptor } from "../../core/runtime/contracts";
-import type { RecordedCameraAdmissionState } from "../../core/observation/recordedSessionAdmission";
 import {
  RecordedEvidenceBoxOverlay,
  type RecordedEvidenceBox,
@@ -28,7 +25,6 @@ export function RecordedEvidenceVideoScene({
  imageWidth,
  imageHeight,
  boxes,
-  overlaySeconds,
  semanticOverlay,
  pointCloudOverlay,
  ariaLabel,
@@ -37,17 +33,12 @@ export function RecordedEvidenceVideoScene({
  segmentCount,
  onPlaybackChange,
  onPlayingRejected,
-  onAdmissionChange,
-  playbackAuthority = "media",
-  playbackTransport = "segmented",
-  recoverTimestampStalls = false,
 }: {
  source: ObservationSourceDescriptor;
  playback: RecordedObservationPlayback;
  imageWidth: number;
  imageHeight: number;
  boxes: readonly RecordedEvidenceBox[];
-  overlaySeconds?: number;
  semanticOverlay?: RecordedEvidenceSemanticOverlay;
  pointCloudOverlay?: RecordedEvidencePointCloudOverlayData;
  ariaLabel: string;
@@ -56,41 +47,7 @@ export function RecordedEvidenceVideoScene({
  segmentCount?: number;
  onPlaybackChange?: (playback: RecordedObservationPlayback) => void;
  onPlayingRejected?: () => void;
-  onAdmissionChange?: (state: RecordedCameraAdmissionState) => void;
-  playbackAuthority?: "media" | "host";
-  playbackTransport?: "segmented" | "epoch-stream";
-  recoverTimestampStalls?: boolean;
 }) {
-  const generation = source.delivery?.kind === "recorded-fmp4-manifest"
-    ? source.delivery.manifestGenerationSha256
-    : "invalid";
-  const [admissionPhase, setAdmissionPhase] = useState<RecordedCameraAdmissionState["phase"]>(
-    "loading",
-  );
-  const [presentedSeconds, setPresentedSeconds] = useState<number | null>(null);
-  useEffect(() => {
-    setAdmissionPhase("loading");
-    setPresentedSeconds(null);
-  }, [generation, source.id]);
-  const handleAdmissionChange = (next: RecordedCameraAdmissionState) => {
-    setAdmissionPhase(next.phase);
-    onAdmissionChange?.(next);
-  };
-  const sourceReady = admissionPhase === "ready";
-  const overlaysPresented = sourceReady
-    && presentedSeconds !== null
-    && Math.abs(presentedSeconds - playback.currentSeconds) <= 0.25
-    && (overlaySeconds === undefined || Math.abs(presentedSeconds - overlaySeconds) <= 0.25);
-  const handlePlaybackChange = (next: RecordedObservationPlayback) => {
-    setPresentedSeconds(next.currentSeconds);
-    // During a paused operator seek the existing media element can emit its old
-    // timestamp while the requested MSE window is being rebuilt. That stale
-    // callback must not undo the host target before the decoder reaches it.
-    if (!playback.playing && Math.abs(next.currentSeconds - playback.currentSeconds) > 0.35) {
-      return;
-    }
-    onPlaybackChange?.(next);
-  };
  return (
    <div className="recorded-evidence-video-scene">
      <RecordedFmp4Player
@@ -100,35 +57,29 @@ export function RecordedEvidenceVideoScene({
        prepare
        segmentSequence={segmentSequence}
        segmentCount={segmentCount}
-        onPlaybackChange={handlePlaybackChange}
+        onPlaybackChange={onPlaybackChange}
        onPlayingRejected={onPlayingRejected}
-        onAdmissionChange={handleAdmissionChange}
-        playbackAuthority={playbackAuthority}
-        playbackTransport={playbackTransport}
-        recoverTimestampStalls={recoverTimestampStalls}
      />
-      {overlaysPresented && semanticOverlay ? (
+      {semanticOverlay ? (
        <RecordedEvidenceSemanticMaskOverlay
          {...semanticOverlay}
          imageWidth={imageWidth}
          imageHeight={imageHeight}
        />
      ) : null}
-      {overlaysPresented && pointCloudOverlay ? (
+      {pointCloudOverlay ? (
        <RecordedEvidencePointCloudOverlay
          imageWidth={imageWidth}
          imageHeight={imageHeight}
          overlay={pointCloudOverlay}
        />
      ) : null}
-      {overlaysPresented ? (
-        <RecordedEvidenceBoxOverlay
-          imageWidth={imageWidth}
-          imageHeight={imageHeight}
-          boxes={boxes}
-          ariaLabel={ariaLabel}
-        />
-      ) : null}
+      <RecordedEvidenceBoxOverlay
+        imageWidth={imageWidth}
+        imageHeight={imageHeight}
+        boxes={boxes}
+        ariaLabel={ariaLabel}
+      />
    </div>
  );
 }
@@ -1,116 +0,0 @@
-import { useEffect, useRef, useState } from "react";
-
-import {
-  fetchCanonicalRecordedLabSpatialFrame,
-  type CanonicalRecordedLabSpatialFrame,
-} from "../../core/laboratory/canonicalRecordedLabSpatial";
-
-const FRAME_CACHE_LIMIT = 12;
-
-/**
- * Shared latest-request-wins scheduler for recorded LAB spatial evidence.
- *
- * A feature supplies only the sealed session identity and host-clock time.
- * Cache ownership, identity fencing and stale-response suppression remain in
- * the canonical instrument instead of being reimplemented per experiment.
- */
-export function useCanonicalRecordedLabSpatialFrame({
-  sessionId,
-  generationSha256,
-  targetTimeNs,
-}: {
-  sessionId: string;
-  generationSha256: string | null;
-  targetTimeNs: number;
-}) {
-  const [frame, setFrame] = useState<CanonicalRecordedLabSpatialFrame | null>(null);
-  const [error, setError] = useState<string | null>(null);
-  const desiredRef = useRef<number | null>(null);
-  const runningRef = useRef(false);
-  const mountedRef = useRef(true);
-  const identityRef = useRef("");
-  const cacheRef = useRef(new Map<number, CanonicalRecordedLabSpatialFrame>());
-  const pumpRef = useRef<() => void>(() => undefined);
-  const identity = `${sessionId}:${generationSha256 ?? "unavailable"}`;
-  identityRef.current = identity;
-
-  pumpRef.current = () => {
-    if (runningRef.current || desiredRef.current === null || !generationSha256) return;
-    runningRef.current = true;
-    const requestIdentity = identity;
-    let settledTimeNs: number | null = null;
-    void (async () => {
-      while (
-        mountedRef.current
-        && identityRef.current === requestIdentity
-        && desiredRef.current !== null
-      ) {
-        const requestedTimeNs = desiredRef.current;
-        const cached = cacheRef.current.get(requestedTimeNs);
-        try {
-          const next = cached ?? await fetchCanonicalRecordedLabSpatialFrame(
-            sessionId,
-            generationSha256,
-            requestedTimeNs,
-          );
-          if (!mountedRef.current || identityRef.current !== requestIdentity) break;
-          if (!cached) {
-            cacheRef.current.set(requestedTimeNs, next);
-            while (cacheRef.current.size > FRAME_CACHE_LIMIT) {
-              const oldest = cacheRef.current.keys().next().value as number | undefined;
-              if (oldest === undefined) break;
-              cacheRef.current.delete(oldest);
-            }
-          }
-          setFrame(next);
-          setError(null);
-        } catch (caught: unknown) {
-          if (!mountedRef.current || identityRef.current !== requestIdentity) break;
-          setError(caught instanceof Error
-            ? caught.message
-            : "Spatial-слои записанной LAB недоступны.");
-        }
-        settledTimeNs = requestedTimeNs;
-        if (desiredRef.current === requestedTimeNs) break;
-      }
-    })().finally(() => {
-      runningRef.current = false;
-      if (
-        mountedRef.current
-        && desiredRef.current !== null
-        && (identityRef.current !== requestIdentity || desiredRef.current !== settledTimeNs)
-      ) {
-        pumpRef.current();
-      }
-    });
-  };
-
-  useEffect(() => {
-    mountedRef.current = true;
-    return () => {
-      mountedRef.current = false;
-      desiredRef.current = null;
-    };
-  }, []);
-
-  useEffect(() => {
-    cacheRef.current.clear();
-    desiredRef.current = null;
-    setFrame(null);
-    setError(null);
-  }, [identity]);
-
-  useEffect(() => {
-    if (!generationSha256) return;
-    desiredRef.current = targetTimeNs;
-    const cached = cacheRef.current.get(targetTimeNs);
-    if (cached) {
-      setFrame(cached);
-      setError(null);
-      return;
-    }
-    pumpRef.current();
-  }, [generationSha256, identity, targetTimeNs]);
-
-  return { frame, error, loading: Boolean(generationSha256) && !frame && !error };
-}
@@ -130,12 +130,8 @@ export function useRecordedEvidencePlayback(

  const synchronize = useCallback((next: RecordedObservationPlayback) => {
    if (!validRange(range) || !Number.isFinite(next.currentSeconds)) return;
-    // Animation-clock mode is retained only for non-media diagnostics. A
-    // recorded LAB with video uses the external media clock so spatial and
-    // overlays never advance past the frame the decoder actually presented.
-    if (clock === "animation") return;
    setPlayback((current) => synchronizeRecordedEvidencePlayback(current, next, range));
-  }, [clock, range]);
+  }, [range]);

  return useMemo(() => ({
    playback,
@@ -1,59 +0,0 @@
-import type {MapVisualSettings} from '../../core/map/mapView';
-import type {CesiumMapRendererProps} from '@nodedc/map-cesium-react';
-
-export function mapPresentation(settings:MapVisualSettings):CesiumMapRendererProps['settings'] {
- return {
-atmosphere_enabled: settings.atmosphereEnabled,
-              atmosphere_hue: settings.atmosphereHue,
-              atmosphere_saturation:
-                settings.atmosphereSaturation,
-              atmosphere_brightness:
-                settings.atmosphereBrightness,
-              fog_enabled: settings.fogEnabled,
-              fog_density: settings.fogDensity,
-              sun_enabled: settings.sunEnabled,
-              sun_hour: settings.sunHour,
-              sun_intensity: settings.sunIntensity,
-              shadows_enabled: settings.shadowsEnabled,
-              monochrome_enabled: settings.monochromeEnabled,
-              monochrome_color: settings.monochromeColor,
-              imagery_brightness: settings.imageryBrightness,
-              imagery_contrast: settings.imageryContrast,
-              imagery_saturation: settings.imagerySaturation,
-              imagery_gamma: settings.imageryGamma,
-              imagery_hue: settings.imageryHue,
-              imagery_alpha: settings.imageryAlpha,
-              globe_color: settings.globeColor,
-              background_color: settings.backgroundColor,
-              terrain_exaggeration:
-                settings.terrainExaggeration,
-              buildings_color: settings.buildingsColor,
-              buildings_opacity: settings.buildingsOpacity,
-              buildings_maximum_screen_space_error:
-                settings.buildingsMaximumScreenSpaceError,
-              grid_lod_enabled: settings.gridLodEnabled,
-              grid_height_meters: settings.gridHeightMeters,
-              grid_lod_1_max_height_km:
-                settings.gridLod1MaxHeightKm,
-              grid_lod_1_step_km:
-                settings.gridLod1StepKm,
-              grid_lod_2_max_height_km:
-                settings.gridLod2MaxHeightKm,
-              grid_lod_2_step_km:
-                settings.gridLod2StepKm,
-              grid_lod_3_step_km:
-                settings.gridLod3StepKm,
-              grid_radius_km: settings.gridRadiusKm,
-              grid_line_width: settings.gridLineWidth,
-              grid_color: settings.gridColor,
-              grid_opacity: settings.gridOpacity,
-              grid_dots_enabled:
-                settings.gridDotsEnabled,
-              grid_dots_size: settings.gridDotsSize,
-              grid_dots_color: settings.gridDotsColor,
-              grid_dots_opacity:
-                settings.gridDotsOpacity,
-              camera_animation_enabled:
-                settings.cameraAnimationEnabled,
- };
-}
@@ -1,261 +0,0 @@
-import { useEffect, useMemo, useState } from "react";
-import {
-  ActivityIndicator,
-  Button,
-  FieldFrame,
-  Select,
-  StatusBadge,
-  Window,
-  WindowFooterActions,
-} from "@nodedc/ui-react";
-
-import {
-  aiModuleIdForSetup,
-  fetchAIModuleCatalog,
-  fetchAICompositionRuns,
-  fetchAICompositionJobs,
-  saveAIComposition,
-  type AICompositionReceipt,
-  type AICompositionRun,
-  type AIGroupId,
-  type AIModuleCatalog,
-} from "../../core/observatory/aiComposition";
-import type { ObservatoryRecordedJob } from "../../core/observatory/recordedJobs";
-
-const groups: readonly { id: AIGroupId; label: string; description: string }[] = [
-  { id: "segmentation", label: "Сегментация", description: "Пиксельные маски сцены" },
-  { id: "detection", label: "Объекты", description: "Рамки и классы объектов" },
-  { id: "geometry", label: "Облако точек / TGS", description: "Опорная поверхность и карта проходимости" },
-  { id: "range", label: "Дистанция", description: "Расстояния до объектов" },
-  { id: "motion", label: "Движение", description: "Треки и динамика объектов" },
-  { id: "policy", label: "Политика", description: "Теневые правила интерпретации" },
-];
-
-export function AIConfigurationWindow({
-  open, sourceSessionId, sourceLabel, onClose, onCalculated,
-}: {
-  readonly open: boolean;
-  readonly sourceSessionId: string;
-  readonly sourceLabel: string;
-  readonly onClose: () => void;
-  readonly onCalculated: (receipt: AICompositionReceipt) => void;
-}) {
-  const [catalog, setCatalog] = useState<AIModuleCatalog | null>(null);
-  const [existingJobs, setExistingJobs] = useState<readonly ObservatoryRecordedJob[]>([]);
-  const [existingRuns, setExistingRuns] = useState<readonly AICompositionRun[]>([]);
-  const [selected, setSelected] = useState<Partial<Record<AIGroupId, string>>>({});
-  const [state, setState] = useState<"idle" | "loading" | "ready" | "saving" | "error">("idle");
-  const [message, setMessage] = useState<string | null>(null);
-
-  useEffect(() => {
-    if (!open) return;
-    const request = new AbortController();
-    setState("loading");
-    setMessage(null);
-    void Promise.all([
-      fetchAIModuleCatalog(request.signal),
-      fetchAICompositionJobs(sourceSessionId, request.signal),
-      fetchAICompositionRuns(sourceSessionId, request.signal),
-    ]).then(([value, jobs, runs]) => {
-      if (request.signal.aborted) return;
-      setCatalog(value);
-      setExistingJobs(jobs);
-      setExistingRuns(runs);
-      setSelected({});
-      setState("ready");
-    }).catch((error: unknown) => {
-      if (request.signal.aborted) return;
-      setMessage(error instanceof Error ? error.message : "Каталог AI-модулей недоступен.");
-      setState("error");
-    });
-    return () => request.abort();
-  }, [open, sourceSessionId]);
-
-  const existingByModule = useMemo(() => {
-    const result = new Map<string, ObservatoryRecordedJob>();
-    for (const job of existingJobs) {
-      if (job.state === "failed" || job.publication.state === "failed") continue;
-      const moduleId = aiModuleIdForSetup(job.setupId);
-      if (moduleId && !result.has(moduleId)) result.set(moduleId, job);
-    }
-    return result;
-  }, [existingJobs]);
-
-  const selections = useMemo(() => groups.flatMap(({ id }) => {
-    const moduleId = selected[id];
-    const module = catalog?.groups.find((item) => item.group === id)?.modules.find(
-      (item) => item.moduleId === moduleId,
-    );
-    return module ? [{ group: id, module }] : [];
-  }), [catalog, selected]);
-
-  const selectedModuleIds = useMemo(
-    () => selections.map(({ module }) => module.moduleId).sort(),
-    [selections],
-  );
-  const matchingRun = useMemo(() => existingRuns.find((run) => (
-    run.state !== "failed"
-    && [...run.moduleIds].sort().join("\0") === selectedModuleIds.join("\0")
-  )), [existingRuns, selectedModuleIds]);
-  const configurationAlreadyExists = selections.length > 0 && matchingRun !== undefined;
-  const configurationIsRunning = matchingRun?.state === "running";
-
-  function selectModule(group: AIGroupId, moduleId: string): void {
-    if (!catalog) return;
-    setSelected((current) => {
-      const next = { ...current, [group]: moduleId === "none" ? undefined : moduleId };
-      const modules = catalog.groups.flatMap((item) => item.modules);
-      const selectedIds = new Set(Object.values(next).filter((value): value is string => Boolean(value)));
-      if (moduleId !== "none") {
-        const module = modules.find((item) => item.moduleId === moduleId);
-        for (const requirement of module?.requires ?? []) {
-          if (requirement.startsWith("source.")) continue;
-          if (modules.some((item) => selectedIds.has(item.moduleId) && item.provides.includes(requirement))) {
-            continue;
-          }
-          const providers = modules.filter((item) => item.provides.includes(requirement));
-          if (providers.length === 1) {
-            const providerGroup = catalog.groups.find((item) => item.modules.some(
-              (candidate) => candidate.moduleId === providers[0]?.moduleId,
-            ))?.group;
-            if (providerGroup) {
-              next[providerGroup] = providers[0]?.moduleId;
-              selectedIds.add(providers[0]?.moduleId ?? "");
-            }
-          }
-        }
-      } else {
-        let changed = true;
-        while (changed) {
-          changed = false;
-          const capabilities = new Set(modules.filter((item) => Object.values(next).includes(item.moduleId))
-            .flatMap((item) => item.provides));
-          for (const item of modules.filter((candidate) => Object.values(next).includes(candidate.moduleId))) {
-            if (item.requires.some((requirement) => !requirement.startsWith("source.") && !capabilities.has(requirement))) {
-              const dependentGroup = catalog.groups.find((candidate) => candidate.modules.some(
-                (module) => module.moduleId === item.moduleId,
-              ))?.group;
-              if (dependentGroup) {
-                next[dependentGroup] = undefined;
-                changed = true;
-              }
-            }
-          }
-        }
-      }
-      return next;
-    });
-    setMessage(null);
-    if (state === "error") setState("ready");
-  }
-
-  async function calculate(): Promise<void> {
-    if (selections.length === 0 || state === "saving") return;
-    if (configurationAlreadyExists) {
-      setMessage("Эта конфигурация уже рассчитана. Выберите другую конфигурацию.");
-      return;
-    }
-    setState("saving");
-    setMessage(null);
-    try {
-      const receipt = await saveAIComposition(sourceSessionId, selections);
-      onCalculated(receipt);
-      onClose();
-    } catch (error) {
-      setMessage(error instanceof Error ? error.message : "Не удалось запустить расчёт.");
-      setState("error");
-    }
-  }
-
-  return <Window
-    open={open}
-    className="observatory-ai-config-window"
-    title="Сконфигурировать AI-слой"
-    subtitle={sourceLabel}
-    size="lg"
-    closeOnBackdrop={state !== "saving"}
-    closeOnEscape={state !== "saving"}
-    onClose={onClose}
-    footer={<WindowFooterActions>
-      {configurationAlreadyExists ? (
-        <span className="observatory-ai-config__duplicate" role="status">
-          {configurationIsRunning
-            ? "Текущая конфигурация уже рассчитывается."
-            : "Текущая конфигурация уже рассчитана."}
-        </span>
-      ) : null}
-      <Button
-        variant="primary"
-        className={state === "saving" ? "observatory-ai-config__calculate--saving" : undefined}
-        disabled={state !== "ready" || selections.length === 0 || configurationAlreadyExists}
-        aria-busy={state === "saving"}
-        onClick={() => void calculate()}
-      >
-        {state === "saving" ? "Отправляем на Worker…" : "Рассчитать"}
-      </Button>
-    </WindowFooterActions>}
-  >
-    <div className="observatory-ai-config" aria-busy={state === "loading" || state === "saving"}>
-      <p className="observatory-ai-config__lead">
-        Выберите модуль в каждом нужном слое. Зависимые блоки подключаются явно в этой конфигурации.
-      </p>
-      {state === "loading" ? <ActivityIndicator label="Загружаем AI-модули" /> : null}
-      {catalog ? groups.map(({ id, label, description }) => {
-        const modules = catalog.groups.find((item) => item.group === id)?.modules ?? [];
-        const selectedModule = modules.find((item) => item.moduleId === selected[id]);
-        const selectedExisting = selectedModule
-          ? existingByModule.get(selectedModule.moduleId)
-          : undefined;
-        const allCalculated = modules.length > 0 && modules.every(
-          (module) => existingByModule.has(module.moduleId),
-        );
-        return <section className="observatory-ai-module-group" key={id}>
-          <header>
-            <div>
-              <strong>{label}</strong>
-              <span>{description}</span>
-            </div>
-            <StatusBadge tone={selectedModule ? "accent" : "neutral"}>
-              {selectedExisting
-                ? selectedExisting.state === "succeeded" ? "Уже рассчитано" : "В расчёте"
-                : selectedModule?.label ?? (allCalculated
-                ? "Результат доступен"
-                : modules.length ? "Не используется" : "Не установлен")}
-            </StatusBadge>
-          </header>
-          <div className="observatory-ai-module-group__body">
-            <FieldFrame
-              label={`Модуль: ${label}`}
-              description={modules.length
-                ? allCalculated
-                  ? "Готовый результат можно включить в новую конфигурацию без повторного расчёта."
-                  : id === "segmentation"
-                  ? "DDRNet и EoMT — независимые альтернативы; выберите одну модель."
-                  : id === "range"
-                    ? "Дистанция использует рамки детектора и синхронное облако точек."
-                    : id === "geometry"
-                      ? "TGS обрабатывает LiDAR независимо от сегментации и детектора."
-                      : "Связи с другими блоками определяются входами выбранного модуля."
-                : "Для этого слоя на Worker 006 пока нет установленного модуля."}
-            >
-              <Select
-                label={`Выбрать модуль: ${label}`}
-                value={selected[id] ?? "none"}
-                options={[{ value: "none", label: "Не использовать" }, ...modules.map((module) => ({
-                  value: module.moduleId,
-                  label: module.label,
-                  description: existingByModule.has(module.moduleId)
-                    ? "Готовый результат будет использован без повторного расчёта"
-                    : module.dockerName,
-                }))]}
-                disabled={modules.length === 0 || state === "saving"}
-                onChange={(value) => selectModule(id, value)}
-              />
-            </FieldFrame>
-          </div>
-        </section>;
-      }) : null}
-      {message ? <p className="observatory-ai-config__error" role="alert">{message}</p> : null}
-    </div>
-  </Window>;
-}
@@ -1,10 +0,0 @@
-import { WebViewer } from "@rerun-io/web-viewer";
-
-import type { RerunFrameWindow } from "./recordedRerunProtocol";
-import { createRecordedRerunOwner } from "./recordedRerunOwner";
-
-// This entry is loaded only in the owned iframe. Upstream code is unmodified;
-// destroying the frame also ends its timers, WASM, video and WebGPU lifetime.
-const mount = document.getElementById("viewer");
-if (!mount) throw new Error("Recorded viewer mount is missing");
-(window as RerunFrameWindow).missionCoreRerun = createRecordedRerunOwner(() => new WebViewer(), mount);
@@ -1,77 +0,0 @@
-import { createRecordedRerunFacade, type RecordedRerunViewer } from "./recordedRerunFacade";
-import type { RerunFrameWindow } from "./recordedRerunProtocol";
-import { relayIsolatedRerunInput } from "./isolatedRerunInput";
-
-/** Own the complete recorded-viewer realm, not just its canvas or SDK handle. */
-export function createIsolatedRerunHost(host: HTMLElement) {
-  let frame: HTMLIFrameElement | null = host.ownerDocument.createElement("iframe");
-  frame.title = "Синхронизированная запись";
-  frame.className = "rerun-viewport__runtime";
-  frame.src = "/rerun-runtime.html";
-  let disposed = false;
-  let releaseFacade: (() => void) | null = null;
-  let releaseInput: (() => void) | null = null;
-  let frameWindow: RerunFrameWindow | null = null;
-  let rejectReady: ((reason: Error) => void) | null = null;
-  let timer: ReturnType<typeof setTimeout> | undefined;
-
-  const dispose = () => {
-    if (disposed) return;
-    disposed = true;
-    clearTimeout(timer);
-    frame!.onload = null;
-    frame!.onerror = null;
-    releaseInput?.();
-    releaseInput = null;
-    try {
-      releaseFacade?.();
-    } catch {
-      // Realm teardown is required even if a partial native start failed.
-    } finally {
-      releaseFacade = null;
-      frameWindow = null;
-      frame!.remove();
-      frame = null;
-      rejectReady?.(new Error("Recorded viewer was disposed"));
-      rejectReady = null;
-    }
-  };
-
-  const ready = new Promise<{ viewer: RecordedRerunViewer; mount: HTMLElement }>((resolve, reject) => {
-    rejectReady = reject;
-    frame!.onload = () => {
-      if (disposed) return;
-      try {
-        frameWindow = frame!.contentWindow as RerunFrameWindow | null;
-        const api = frameWindow?.missionCoreRerun;
-        if (!api || api.version !== 2) throw new Error("Recorded viewer host is unavailable");
-        const owner = createRecordedRerunFacade((request, bytes) => {
-          const current = frameWindow?.missionCoreRerun;
-          if (!current) throw new Error("Recorded viewer was disposed");
-          return current.invoke(request, bytes);
-        });
-        releaseFacade = owner.dispose;
-        api.connect(owner.notify);
-        releaseInput = relayIsolatedRerunInput(host, frameWindow, frame);
-        clearTimeout(timer);
-        rejectReady = null;
-        frame!.onload = null;
-        frame!.onerror = null;
-        resolve({ viewer: owner.facade, mount: host });
-      } catch (error) {
-        reject(new Error(String(error)));
-        dispose();
-      }
-    };
-    frame!.onerror = () => {
-      reject(new Error("Recorded viewer host failed to load"));
-      dispose();
-    };
-    timer = setTimeout(() => {
-      reject(new Error("Recorded viewer host timed out"));
-      dispose();
-    }, 30_000);
-  });
-  host.append(frame);
-  return { ready, dispose };
-}
@@ -1,17 +0,0 @@
-/** Relay Escape from the isolated viewer realm to the owning application. */
-export function relayIsolatedRerunInput(
-  host: HTMLElement,
-  frameWindow: Window | null,
-  _frame: HTMLIFrameElement | null,
-) {
-  const parent = host.ownerDocument.defaultView;
-  const escape = (event: KeyboardEvent) => {
-    if (event.key !== "Escape" || event.defaultPrevented || !parent) return;
-    host.dispatchEvent(new parent.KeyboardEvent("keydown", { key: "Escape", bubbles: true }));
-  };
-  frameWindow?.addEventListener("keydown", escape);
-  return () => {
-    frameWindow?.removeEventListener("keydown", escape);
-    frameWindow = null;
-  };
-}
@@ -1,244 +0,0 @@
-export type RecordedRerunCameraEye = {
-  readonly position: readonly [number, number, number];
-  readonly lookTarget: readonly [number, number, number];
-  readonly eyeUp: readonly [number, number, number];
-};
-
-type Vector3 = [number, number, number];
-type DragMode = "rotate" | "pan" | "roll";
-
-const ROTATION_RADIANS_PER_POINT = 0.004;
-const RERUN_WEB_LINE_SCROLL_POINTS = 8;
-const RERUN_ORBITAL_SCROLL_DIVISOR = 200;
-const RERUN_WEB_PINCH_SCROLL_DIVISOR = 100;
-const RERUN_MIN_ORBIT_DISTANCE = 0.02;
-const DOM_WHEEL_DELTA_LINE = 1;
-const DOM_WHEEL_DELTA_PAGE = 2;
-
-export const RECORDED_RERUN_ORBITAL_EYE: RecordedRerunCameraEye = {
-  position: [16, -16, 18],
-  lookTarget: [0, 0, 0],
-  eyeUp: [0, 0, 1],
-};
-
-export const RECORDED_RERUN_PLAN_EYE: RecordedRerunCameraEye = {
-  position: [0, 0, 30],
-  lookTarget: [0, 0, 0],
-  eyeUp: [0, 1, 0],
-};
-
-const vector = (value: readonly [number, number, number]): Vector3 => [...value];
-const add = (a: Vector3, b: Vector3): Vector3 => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
-const subtract = (a: Vector3, b: Vector3): Vector3 => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-const scale = (value: Vector3, factor: number): Vector3 => [value[0] * factor, value[1] * factor, value[2] * factor];
-const dot = (a: Vector3, b: Vector3) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-const cross = (a: Vector3, b: Vector3): Vector3 => [
-  a[1] * b[2] - a[2] * b[1],
-  a[2] * b[0] - a[0] * b[2],
-  a[0] * b[1] - a[1] * b[0],
-];
-const length = (value: Vector3) => Math.hypot(...value);
-const normalize = (value: Vector3, fallback: Vector3): Vector3 => {
-  const magnitude = length(value);
-  return magnitude > Number.EPSILON ? scale(value, 1 / magnitude) : fallback;
-};
-const clamp = (value: number, minimum: number, maximum: number) => Math.max(minimum, Math.min(maximum, value));
-const rotateAroundAxis = (value: Vector3, rawAxis: Vector3, angle: number): Vector3 => {
-  const axis = normalize(rawAxis, [0, 0, 1]);
-  const cosine = Math.cos(angle);
-  const sine = Math.sin(angle);
-  return add(
-    add(scale(value, cosine), scale(cross(axis, value), sine)),
-    scale(axis, dot(axis, value) * (1 - cosine)),
-  );
-};
-
-function cloneEye(value: RecordedRerunCameraEye): {
-  position: Vector3;
-  lookTarget: Vector3;
-  eyeUp: Vector3;
-} {
-  return {
-    position: vector(value.position),
-    lookTarget: vector(value.lookTarget),
-    eyeUp: vector(value.eyeUp),
-  };
-}
-
-/**
- * Mirrors Rerun 0.36.3's orbital eye math while the native viewer remains the
- * renderer. Rerun writes operator navigation into its active blueprint clone;
- * the WebViewer API cannot read that clone. Keeping the same three eye vectors
- * here lets a later layer blueprint activate with the exact operator pose.
- */
-export function createRecordedRerunCameraJournal(
-  canvas: HTMLCanvasElement,
-  scope: Window & typeof globalThis,
-) {
-  let eye = cloneEye(RECORDED_RERUN_ORBITAL_EYE);
-  let spatialViewportStart = 0;
-  let pointerId: number | null = null;
-  let dragMode: DragMode | null = null;
-  let previousPointer: readonly [number, number] | null = null;
-  let latestPointer: readonly [number, number] | null = null;
-  let maxOrbitalRadius = 1.0e17;
-
-  const isSpatialPoint = (event: MouseEvent) => {
-    const rect = canvas.getBoundingClientRect();
-    return rect.width > 0 && (event.clientX - rect.left) / rect.width >= spatialViewportStart;
-  };
-  const forward = () => normalize(subtract(eye.lookTarget, eye.position), [0, 1, 0]);
-  const usableUp = () => {
-    const fwd = forward();
-    const fallbackRight: Vector3 = Math.abs(dot(fwd, [0, 0, 1])) > 0.9999
-      ? [1, 0, 0]
-      : cross(fwd, [0, 0, 1]);
-    const fallback = normalize(cross(fwd, fallbackRight), [0, 0, 1]);
-    const candidate = normalize(eye.eyeUp, fallback);
-    return Math.abs(dot(candidate, fwd)) > 0.9999 ? fallback : candidate;
-  };
-  const orbitRadius = () => length(subtract(eye.position, eye.lookTarget));
-
-  const rotate = (deltaX: number, deltaY: number) => {
-    const radius = orbitRadius();
-    const up = usableUp();
-    let fwd = forward();
-    const oldPitch = Math.asin(clamp(dot(fwd, up), -1, 1));
-    fwd = normalize(
-      rotateAroundAxis(fwd, up, -ROTATION_RADIANS_PER_POINT * deltaX),
-      fwd,
-    );
-    const right = normalize(cross(fwd, up), [1, 0, 0]);
-    const maxPitch = 0.99 * Math.PI / 2;
-    const nextPitch = clamp(
-      oldPitch - ROTATION_RADIANS_PER_POINT * deltaY,
-      -maxPitch,
-      maxPitch,
-    );
-    fwd = normalize(rotateAroundAxis(fwd, right, nextPitch - oldPitch), fwd);
-    eye.position = subtract(eye.lookTarget, scale(fwd, radius));
-  };
-
-  const pan = (deltaX: number, deltaY: number) => {
-    const fwd = forward();
-    const right = normalize(cross(fwd, usableUp()), [1, 0, 0]);
-    const screenUp = normalize(cross(right, fwd), [0, 0, 1]);
-    const speed = 0.001 * orbitRadius();
-    const translation = add(scale(right, -deltaX * speed), scale(screenUp, deltaY * speed));
-    eye.position = add(eye.position, translation);
-    eye.lookTarget = add(eye.lookTarget, translation);
-  };
-
-  const roll = (event: PointerEvent, deltaX: number, deltaY: number) => {
-    const rect = canvas.getBoundingClientRect();
-    const left = rect.left + rect.width * spatialViewportStart;
-    const centerX = left + (rect.right - left) / 2;
-    const centerY = rect.top + rect.height / 2;
-    const relativeX = event.clientX - centerX;
-    const relativeY = event.clientY - centerY;
-    const divisor = relativeX * relativeX + relativeY * relativeY;
-    if (divisor <= Number.EPSILON) return;
-    const angle = (-deltaY * relativeX + deltaX * relativeY) / divisor;
-    eye.eyeUp = normalize(rotateAroundAxis(eye.eyeUp, scale(forward(), -1), angle), eye.eyeUp);
-  };
-
-  const pointerDown = (event: PointerEvent) => {
-    latestPointer = [event.clientX, event.clientY];
-    if (!isSpatialPoint(event)) return;
-    pointerId = event.pointerId;
-    previousPointer = [event.clientX, event.clientY];
-    dragMode = event.button === 2 ? "pan" : event.button === 1 || event.altKey ? "roll" : "rotate";
-  };
-  const pointerMove = (event: PointerEvent) => {
-    latestPointer = [event.clientX, event.clientY];
-    if (event.pointerId !== pointerId || !previousPointer || !dragMode) return;
-    const deltaX = event.clientX - previousPointer[0];
-    const deltaY = event.clientY - previousPointer[1];
-    previousPointer = [event.clientX, event.clientY];
-    if (dragMode === "rotate") rotate(deltaX, deltaY);
-    else if (dragMode === "pan") pan(deltaX, deltaY);
-    else roll(event, deltaX, deltaY);
-  };
-  const pointerEnd = (event: PointerEvent) => {
-    if (event.pointerId !== pointerId) return;
-    pointerMove(event);
-    pointerId = null;
-    previousPointer = null;
-    dragMode = null;
-  };
-  const wheel = (event: WheelEvent) => {
-    const rect = canvas.getBoundingClientRect();
-    const wheelX = event.clientX >= rect.left && event.clientX <= rect.right
-      ? event.clientX
-      : latestPointer?.[0];
-    if (wheelX === undefined || rect.width <= 0) return;
-    if ((wheelX - rect.left) / rect.width < spatialViewportStart) return;
-    const unitMultiplier = event.deltaMode === DOM_WHEEL_DELTA_LINE
-      ? RERUN_WEB_LINE_SCROLL_POINTS
-      : event.deltaMode === DOM_WHEEL_DELTA_PAGE
-        ? rect.height
-        : 1;
-    const scrollPoints = (event.deltaX + event.deltaY) * unitMultiplier;
-    // eframe negates the DOM delta before Rerun applies
-    // radius / exp(smooth_scroll_delta / 200). Over a smoothed gesture the
-    // exponent products collapse to the raw accumulated DOM delta below.
-    const divisor = event.ctrlKey
-      ? RERUN_WEB_PINCH_SCROLL_DIVISOR
-      : RERUN_ORBITAL_SCROLL_DIVISOR;
-    const radiusFactor = Math.exp(scrollPoints / divisor);
-    const offset = subtract(eye.position, eye.lookTarget);
-    const radius = length(offset);
-    // Keep the same orbital bounds as Rerun 0.36.3. An eye already outside
-    // the scene-derived cap is allowed to stay there and is never snapped in.
-    const nextRadius = clamp(
-      radius * radiusFactor,
-      RERUN_MIN_ORBIT_DISTANCE,
-      Math.max(radius, maxOrbitalRadius),
-    );
-    eye.position = add(
-      eye.lookTarget,
-      scale(offset, nextRadius / Math.max(radius, Number.EPSILON)),
-    );
-  };
-
-  canvas.addEventListener("pointerdown", pointerDown, true);
-  scope.addEventListener("pointermove", pointerMove, true);
-  scope.addEventListener("pointerup", pointerEnd, true);
-  scope.addEventListener("pointercancel", pointerEnd, true);
-  scope.addEventListener("wheel", wheel, { capture: true, passive: true });
-
-  return {
-    current(): RecordedRerunCameraEye {
-      return {
-        position: [...eye.position],
-        lookTarget: [...eye.lookTarget],
-        eyeUp: [...eye.eyeUp],
-      };
-    },
-    configure(nextEye: RecordedRerunCameraEye, nextSpatialViewportStart: number) {
-      eye = cloneEye(nextEye);
-      spatialViewportStart = clamp(nextSpatialViewportStart, 0, 0.9);
-      pointerId = null;
-      dragMode = null;
-      previousPointer = null;
-    },
-    setSpatialViewportStart(nextSpatialViewportStart: number) {
-      spatialViewportStart = clamp(nextSpatialViewportStart, 0, 0.9);
-    },
-    setMaxOrbitalRadius(nextMaxOrbitalRadius: number) {
-      if (
-        Number.isFinite(nextMaxOrbitalRadius) &&
-        nextMaxOrbitalRadius >= RERUN_MIN_ORBIT_DISTANCE
-      ) {
-        maxOrbitalRadius = nextMaxOrbitalRadius;
-      }
-    },
-    dispose() {
-      canvas.removeEventListener("pointerdown", pointerDown, true);
-      scope.removeEventListener("pointermove", pointerMove, true);
-      scope.removeEventListener("pointerup", pointerEnd, true);
-      scope.removeEventListener("pointercancel", pointerEnd, true);
-      scope.removeEventListener("wheel", wheel, true);
-    },
-  };
-}
@@ -1,105 +0,0 @@
-import type { WebViewer } from "@rerun-io/web-viewer";
-import type { RerunInvoke } from "./recordedRerunProtocol";
-import type { RecordedRerunCameraEye } from "./recordedRerunCameraJournal";
-
-type NativeChannel = ReturnType<WebViewer["open_channel"]>;
-type Channel = Pick<NativeChannel, "ready" | "send_rrd" | "close">;
-export type RecordedRerunViewer = Pick<WebViewer,
-  "start" | "stop" | "ready" | "on" | "open" | "close" | "override_panel_state" |
-  "get_active_recording_id" | "get_active_timeline" | "get_current_time" |
-  "get_playing" | "get_time_range" | "set_active_timeline" |
-  "set_current_time" | "set_playing"
-> & {
-  open_channel: (name?: string) => Channel;
-  configure_camera_journal: (eye: RecordedRerunCameraEye, spatialViewportStart: number) => void;
-  get_camera_eye: () => RecordedRerunCameraEye;
-  set_camera_viewport_start: (spatialViewportStart: number) => void;
-  set_camera_max_orbital_radius: (maxOrbitalRadius: number) => void;
-};
-
-/** Parent-owned values only. No SDK Promise or foreign prototype escapes. */
-export function createRecordedRerunFacade(invoke: RerunInvoke | null) {
-  let nextId = 0;
-  const callbacks = new Map<number, (...args: unknown[]) => void>();
-  const starts = new Map<number, { resolve: () => void; reject: (error: Error) => void }>();
-  const command = (method: string, args: unknown[] = [], id?: number, bytes?: Uint8Array) => {
-    if (!invoke) throw new Error("Recorded viewer was disposed");
-    const response = JSON.parse(invoke(JSON.stringify({ method, args, id }), bytes));
-    if (response.error) throw new Error(response.error);
-    return response.result;
-  };
-  const dispose = () => {
-    callbacks.clear();
-    for (const pending of starts.values()) pending.reject(new Error("Recorded viewer was disposed"));
-    starts.clear();
-    try { if (invoke) command("stop"); } finally { invoke = null; }
-  };
-  const notify = (message: string) => {
-    if (!invoke) return;
-    const event = JSON.parse(message);
-    if (event.type === "event") callbacks.get(event.id)?.(...event.values);
-    else {
-      const pending = starts.get(event.id);
-      starts.delete(event.id);
-      if (event.type === "started") pending?.resolve();
-      else pending?.reject(new Error(event.message));
-    }
-  };
-  const facade: RecordedRerunViewer = {
-    get ready() { return invoke ? command("ready") : false; },
-    start(source, _parent, options) {
-      return new Promise<void>((resolve, reject) => {
-        const id = ++nextId;
-        starts.set(id, { resolve, reject });
-        try { command("start", [source, options], id); }
-        catch (error) { starts.delete(id); reject(error); }
-      });
-    },
-    stop: dispose,
-    on: ((event: string, callback: (...args: unknown[]) => void) => {
-      const id = ++nextId;
-      callbacks.set(id, callback);
-      try { command("on", [event], id); }
-      catch (error) { callbacks.delete(id); throw error; }
-      return () => {
-        if (callbacks.delete(id) && invoke) command("off", [], id);
-      };
-    }) as WebViewer["on"],
-    open_channel(name) {
-      const id = ++nextId;
-      command("channel-open", name === undefined ? [] : [name], id);
-      let closed = false;
-      return {
-        get ready() { return !closed && invoke ? command("channel-ready", [], id) : false; },
-        send_rrd(bytes) { if (!closed && invoke) command("channel-send", [], id, bytes); },
-        close() {
-          if (closed) return;
-          closed = true;
-          if (invoke) command("channel-close", [], id);
-        },
-      };
-    },
-    open: (...args) => command("open", args),
-    close: (...args) => { if (invoke) command("close", args); },
-    override_panel_state: (...args) => command("override_panel_state", args),
-    get_active_recording_id: () => command("get_active_recording_id"),
-    get_active_timeline: (...args) => command("get_active_timeline", args),
-    get_current_time: (...args) => command("get_current_time", args),
-    get_playing: (...args) => command("get_playing", args),
-    get_time_range: (...args) => command("get_time_range", args),
-    set_active_timeline: (...args) => command("set_active_timeline", args),
-    set_current_time: (...args) => command("set_current_time", args),
-    set_playing: (...args) => command("set_playing", args),
-    configure_camera_journal: (eye, spatialViewportStart) => command(
-      "configure-camera-journal", [eye, spatialViewportStart],
-    ),
-    get_camera_eye: () => command("get-camera-eye"),
-    set_camera_viewport_start: (spatialViewportStart) => command(
-      "set-camera-viewport-start", [spatialViewportStart],
-    ),
-    set_camera_max_orbital_radius: (maxOrbitalRadius) => command(
-      "set-camera-max-orbital-radius", [maxOrbitalRadius],
-    ),
-  };
-  return { facade, dispose, notify };
-}
@@ -1,115 +0,0 @@
-import type { WebViewer } from "@rerun-io/web-viewer";
-import type { RerunFrameApi, RerunNotify } from "./recordedRerunProtocol";
-import { createRecordedRerunCameraJournal } from "./recordedRerunCameraJournal";
-
-/** Lives entirely inside the disposable iframe, including pending SDK starts. */
-export function createRecordedRerunOwner(create: () => WebViewer, mount: HTMLElement): RerunFrameApi {
-  let native: WebViewer | null = null;
-  let notify: RerunNotify | null = null;
-  const subscriptions = new Map<number, () => void>();
-  const channels = new Map<number, ReturnType<WebViewer["open_channel"]>>();
-  let cameraJournal: ReturnType<typeof createRecordedRerunCameraJournal> | null = null;
-  const send = (message: object) => notify?.(JSON.stringify(message));
-  const stop = () => {
-    notify = null;
-    for (const unsubscribe of subscriptions.values()) {
-      try { unsubscribe(); } catch { /* Continue partial-start cleanup. */ }
-    }
-    subscriptions.clear();
-    for (const channel of channels.values()) {
-      try { channel.close(); } catch { /* Other channels must still close. */ }
-    }
-    channels.clear();
-    cameraJournal?.dispose();
-    cameraJournal = null;
-    const current = native;
-    native = null;
-    try { current?.stop(); } catch { /* Realm teardown remains authoritative. */ }
-  };
-  const required = () => {
-    if (!native) throw new Error("Recorded viewer was disposed");
-    return native;
-  };
-  const start = async (id: number, args: [string | string[] | null, Parameters<WebViewer["start"]>[2]]) => {
-    const starting = required();
-    try {
-      await starting.start(args[0], mount, args[1]);
-      if (native === starting && starting.canvas) {
-        cameraJournal?.dispose();
-        cameraJournal = createRecordedRerunCameraJournal(
-          starting.canvas,
-          window as Window & typeof globalThis,
-        );
-      }
-      if (native === starting) send({ type: "started", id });
-    } catch (error) {
-      if (native === starting) send({ type: "start-failed", id, message: String(error) });
-    } finally {
-      if (native !== starting) {
-        try { starting.stop(); } catch { /* Late completion after disposal. */ }
-      }
-    }
-  };
-  return {
-    version: 2,
-    connect(callback) {
-      if (native) throw new Error("Recorded viewer already has an owner");
-      native = create();
-      notify = callback;
-    },
-    invoke(request, bytes) {
-      try {
-        const { method, args = [], id } = JSON.parse(request);
-        let result: unknown;
-        switch (method) {
-          case "stop": stop(); break;
-          case "start": required(); void start(id, args); break;
-          case "ready": result = native?.ready ?? false; break;
-          case "on": {
-            const subscribe = required().on as (event: string, callback: (...values: unknown[]) => void) => () => void;
-            subscriptions.set(id, subscribe.call(required(), args[0], (...values) => send({ type: "event", id, values })));
-            break;
-          }
-          case "off":
-            try { subscriptions.get(id)?.(); } finally { subscriptions.delete(id); }
-            break;
-          case "channel-open": {
-            const name = args[0] as string | undefined;
-            channels.set(id, required().open_channel(name));
-            break;
-          }
-          case "channel-ready": result = channels.get(id)?.ready ?? false; break;
-          case "channel-send": if (bytes) {
-            channels.get(id)?.send_rrd(bytes);
-          } break;
-          case "channel-close":
-            try { channels.get(id)?.close(); } finally {
-              channels.delete(id);
-            }
-            break;
-          case "configure-camera-journal": cameraJournal?.configure(args[0], args[1]); break;
-          case "get-camera-eye": result = cameraJournal?.current(); break;
-          case "set-camera-viewport-start": cameraJournal?.setSpatialViewportStart(args[0]); break;
-          case "set-camera-max-orbital-radius": cameraJournal?.setMaxOrbitalRadius(args[0]); break;
-          case "open": required().open(args[0]); break;
-          case "close": required().close(args[0]); break;
-          case "override_panel_state": required().override_panel_state(args[0], args[1]); break;
-          case "get_active_recording_id": result = required().get_active_recording_id(); break;
-          case "get_active_timeline": result = required().get_active_timeline(args[0]); break;
-          case "get_current_time": result = required().get_current_time(args[0], args[1]); break;
-          case "get_playing": result = required().get_playing(args[0]); break;
-          case "get_time_range": result = required().get_time_range(args[0], args[1]); break;
-          case "set_active_timeline": required().set_active_timeline(args[0], args[1]); break;
-          case "set_current_time": required().set_current_time(args[0], args[1], args[2]); break;
-          case "set_playing": required().set_playing(args[0], args[1]); break;
-          default: throw new Error("Unsupported recorded viewer command");
-        }
-        return JSON.stringify({ result });
-      } catch (error) {
-        // A native Error also has a foreign prototype. Return text, never throw
-        // that object into a parent Promise/callback retained after disposal.
-        return JSON.stringify({ error: String(error) });
-      }
-    },
-  };
-}
@@ -1,12 +0,0 @@
-/** Only parent-owned inputs and primitive strings cross the recorded realm.
- * An SDK instance, Promise, DOM node or native callback never becomes a value
- * retained by React. This is not a second playback clock.
- */
-export type RerunInvoke = (request: string, bytes?: Uint8Array) => string;
-export type RerunNotify = (message: string) => void;
-export interface RerunFrameApi {
-  version: 2;
-  connect: (notify: RerunNotify) => void;
-  invoke: RerunInvoke;
-}
-export type RerunFrameWindow = Window & { missionCoreRerun?: RerunFrameApi };
@@ -118,9 +118,6 @@ export class PlayCanvasRuntime implements SimulationRuntime {
  private renderIntervalMs = 1000 / 60;
  private renderAccumulatorMs = 0;
  private disposed = false;
-  private requestGsplatFrame = (): void => {
-    this.requestRender();
-  };
  private updateFrame = (deltaSeconds: number): void => {
    if (!this.app || !this.camera || this.disposed) return;
    this.ugvController?.update(deltaSeconds);
@@ -161,7 +158,6 @@ export class PlayCanvasRuntime implements SimulationRuntime {
    this.app = app;
    app.autoRender = false;
    app.on("update", this.updateFrame);
-    app.systems.gsplat?.on("frame:request", this.requestGsplatFrame);
    app.setCanvasFillMode(FILLMODE_NONE, 1, 1);
    app.setCanvasResolution(RESOLUTION_AUTO);
    app.scene.ambientLight = new Color(0.35, 0.37, 0.42);
@@ -383,7 +379,6 @@ export class PlayCanvasRuntime implements SimulationRuntime {
    if (this.app) {
      this.app.autoRender = false;
      this.app.renderNextFrame = false;
-      this.app.systems.gsplat?.off("frame:request", this.requestGsplatFrame);
      this.app.off("update", this.updateFrame);
      this.app.destroy();
    }
@@ -24,14 +24,7 @@ const PHYSICS_PROXY_ERROR = 0.0003;
 const PHYSICS_PROXY_MAX_TRIANGLES = 240_000;
 const SERVICE_BRAKE_DECELERATION_MPS2 = 1.8;
 const COAST_DECELERATION_MPS2 = 0.18;
-const PARKING_BRAKE_HOLD_DECELERATION_MPS2 = 6;
-const PARKING_BRAKE_ENGAGE_SPEED_MPS = 0.08;
-const TYRE_FRICTION_SLIP = 8.5;
-const TYRE_STATIC_FRICTION_COEFFICIENT = 0.95;
-const TYRE_KINETIC_FRICTION_COEFFICIENT = 0.78;
-const TYRE_CONTACT_VELOCITY_RESPONSE_PER_SECOND = 10;
-const GRAVITY_METERS_PER_SECOND_SQUARED = 9.81;
-const MIN_TYRE_NORMAL_FORCE_NEWTONS = 1;
+const BRAKE_ATTITUDE_DAMPING = 6;
 const DEFAULT_ORBIT_PITCH = 0.48;
 const CAMERA_RETURN_DELAY_SECONDS = 1.2;
 const CAMERA_RETURN_DURATION_SECONDS = 2;
@@ -86,20 +79,12 @@ interface NativeTransform extends NativeObject {
  getRotation(): NativeQuaternion;
 }

-interface NativeRaycastInfo extends NativeObject {
-  get_m_contactNormalWS(): NativeVector3;
-  get_m_contactPointWS(): NativeVector3;
-  get_m_wheelAxleWS(): NativeVector3;
-}
-
 interface NativeWheelInfo extends NativeObject {
  set_m_suspensionStiffness(value: number): void;
  set_m_wheelsDampingRelaxation(value: number): void;
  set_m_wheelsDampingCompression(value: number): void;
  set_m_frictionSlip(value: number): void;
  set_m_rollInfluence(value: number): void;
-  get_m_wheelsSuspensionForce(): number;
-  get_m_raycastInfo(): NativeRaycastInfo;
 }

 interface NativeRaycastVehicle extends NativeObject {
@@ -117,7 +102,6 @@ interface NativeRaycastVehicle extends NativeObject {
  setBrake(force: number, wheel: number): void;
  setSteeringValue(value: number, wheel: number): void;
  getNumWheels(): number;
-  getWheelInfo(wheel: number): NativeWheelInfo;
  updateWheelTransform(wheel: number, interpolated: boolean): void;
  getWheelTransformWS(wheel: number): NativeTransform;
  getForwardVector(): NativeVector3;
@@ -142,11 +126,6 @@ interface NativeDynamicsWorld extends NativeObject {
  removeAction(action: NativeObject): void;
 }

-interface NativeRigidBody extends NativeObject {
-  applyImpulse(impulse: NativeVector3, relativePosition: NativeVector3): void;
-  setActivationState(state: number): void;
-}
-
 interface PhysicsSystemAccess {
  systems: {
    rigidbody: {
@@ -158,7 +137,7 @@ interface PhysicsSystemAccess {

 interface NativeRigidBodyAccess {
  rigidbody?: {
-    body: NativeRigidBody | null;
+    body: NativeObject | null;
    linearVelocity: Vec3;
    angularVelocity: Vec3;
    teleport(position: Vec3, rotation?: Vec3 | Quat): void;
@@ -213,13 +192,6 @@ export class SimulationUgvController {
  private readonly smoothedCamera = new Vec3();
  private readonly limitedLinearVelocity = new Vec3();
  private readonly limitedAngularVelocity = new Vec3();
-  private readonly tyreContactNormal = new Vec3();
-  private readonly tyreLateralDirection = new Vec3();
-  private readonly tyreLongitudinalDirection = new Vec3();
-  private readonly tyreContactPoint = new Vec3();
-  private readonly tyreRelativePosition = new Vec3();
-  private readonly tyreAngularContactVelocity = new Vec3();
-  private readonly tyreContactVelocity = new Vec3();
  private readonly spawnPosition = UGV_SPAWN_POSITION.clone();
  private orbitPointerId: number | null = null;
  private orbitPointerX = 0;
@@ -232,9 +204,8 @@ export class SimulationUgvController {
  private active = false;
  private vehicleEntity: Entity | null = null;
  private vehicle: NativeRaycastVehicle | null = null;
+  private vehicleTuning: NativeObject | null = null;
  private vehicleRaycaster: NativeObject | null = null;
-  private tyreImpulseNative: NativeVector3 | null = null;
-  private tyreRelativePositionNative: NativeVector3 | null = null;
  private dynamicsWorld: NativeDynamicsWorld | null = null;
  private chassisMaterial: StandardMaterial | null = null;
  private wheelMaterial: StandardMaterial | null = null;
@@ -337,27 +308,9 @@ export class SimulationUgvController {
    const braking = this.pressed.has("Space");
    const rigidbody = (this.vehicleEntity as Entity & NativeRigidBodyAccess).rigidbody;
    const speedMetersPerSecond = this.vehicle.getCurrentSpeedKmHour() / 3.6;
-    const nativeForward = this.vehicle.getForwardVector();
-    const nativeForwardLength = Math.hypot(
-      nativeForward.x(),
-      nativeForward.y(),
-      nativeForward.z(),
-    );
-    const longitudinalSpeedMetersPerSecond = rigidbody && nativeForwardLength > 0.001
-      ? Math.abs(
-        (
-          rigidbody.linearVelocity.x * nativeForward.x()
-          + rigidbody.linearVelocity.y * nativeForward.y()
-          + rigidbody.linearVelocity.z * nativeForward.z()
-        ) / nativeForwardLength,
-      )
-      : Math.abs(speedMetersPerSecond);
    const maxSpeed = this.settings.maxSpeedMetersPerSecond;
    const maxTurnRate = this.settings.maxTurnRateDegrees * Math.PI / 180;
    const pureTurn = !braking && forwardInput === 0 && turnInput !== 0;
-    const holding = !braking && forwardInput === 0 && turnInput === 0;
-    const parkingBrakeEngaged = holding
-      && longitudinalSpeedMetersPerSecond <= PARKING_BRAKE_ENGAGE_SPEED_MPS;
    const desiredSpeed = forwardInput * maxSpeed;
    const speedError = desiredSpeed - speedMetersPerSecond;
    const speedResponseRange = Math.max(0.35, maxSpeed * 0.2);
@@ -372,27 +325,13 @@ export class SimulationUgvController {
    const leftCommand = clamp(forwardCommand - turnCommand, -1, 1);
    const rightCommand = clamp(forwardCommand + turnCommand, -1, 1);
    const engineForce = pureTurn ? pivotForcePerWheel : driveForcePerWheel;
-    const brakeDeceleration = braking
-      ? SERVICE_BRAKE_DECELERATION_MPS2
-      : holding
-        ? parkingBrakeEngaged
-          ? PARKING_BRAKE_HOLD_DECELERATION_MPS2
-          : COAST_DECELERATION_MPS2
-        : 0;
-    const wheelBrakeForce = this.settings.massKg * brakeDeceleration
-      / Math.max(1, this.wheelDefinitions.length);

    for (let index = 0; index < this.wheelDefinitions.length; index += 1) {
      const definition = this.wheelDefinitions[index];
      const command = definition.left ? leftCommand : rightCommand;
-      // Parking contact is solved below with one 2D Coulomb limit; disable the
-      // raycast vehicle's parallel friction impulse so grip is not counted twice.
-      this.vehicle.getWheelInfo(index).set_m_frictionSlip(
-        parkingBrakeEngaged ? 0 : TYRE_FRICTION_SLIP,
-      );
      this.vehicle.setSteeringValue(0, index);
      this.vehicle.applyEngineForce(command * engineForce, index);
-      this.vehicle.setBrake(wheelBrakeForce, index);
+      this.vehicle.setBrake(0, index);
      this.vehicle.updateWheelTransform(index, true);
      const transform = this.vehicle.getWheelTransformWS(index);
      const position = transform.getOrigin();
@@ -401,21 +340,22 @@ export class SimulationUgvController {
      definition.anchor.setRotation(rotation.x(), rotation.y(), rotation.z(), rotation.w());
    }

-    const body = rigidbody?.body ?? null;
-    if (rigidbody && body) {
-      this.applyParkingTyreContact(
-        deltaSeconds,
-        rigidbody,
-        body,
-        parkingBrakeEngaged,
-      );
-    }
-
    if (rigidbody) {
      const linearVelocity = rigidbody.linearVelocity;
      let nextLinearX = linearVelocity.x;
      let nextLinearZ = linearVelocity.z;
      let horizontalSpeed = Math.hypot(nextLinearX, nextLinearZ);
+      const coasting = !braking && forwardInput === 0 && turnInput === 0;
+      if ((braking || coasting) && horizontalSpeed > 0.001) {
+        const deceleration = braking
+          ? SERVICE_BRAKE_DECELERATION_MPS2
+          : COAST_DECELERATION_MPS2;
+        const nextSpeed = Math.max(0, horizontalSpeed - deceleration * Math.max(0, deltaSeconds));
+        const scale = nextSpeed / horizontalSpeed;
+        nextLinearX *= scale;
+        nextLinearZ *= scale;
+        horizontalSpeed = nextSpeed;
+      }
      if (pureTurn && horizontalSpeed > 0.001) {
        const pivotDamping = Math.exp(-Math.max(0, deltaSeconds) * 8);
        nextLinearX *= pivotDamping;
@@ -432,6 +372,9 @@ export class SimulationUgvController {
        rigidbody.linearVelocity = this.limitedLinearVelocity;
      }
      const angularVelocity = rigidbody.angularVelocity;
+      const attitudeDamping = braking
+        ? Math.exp(-Math.max(0, deltaSeconds) * BRAKE_ATTITUDE_DAMPING)
+        : 1;
      let nextAngularY = angularVelocity.y;
      if (pureTurn) {
        const desiredYawRate = -turnInput * maxTurnRate;
@@ -444,137 +387,24 @@ export class SimulationUgvController {
      } else if (Math.abs(angularVelocity.y) > maxTurnRate) {
        nextAngularY = Math.sign(angularVelocity.y) * maxTurnRate;
      }
-      if (nextAngularY !== angularVelocity.y) {
+      if (attitudeDamping !== 1 || nextAngularY !== angularVelocity.y) {
        this.limitedAngularVelocity.set(
-          angularVelocity.x,
+          angularVelocity.x * attitudeDamping,
          nextAngularY,
-          angularVelocity.z,
+          angularVelocity.z * attitudeDamping,
        );
        rigidbody.angularVelocity = this.limitedAngularVelocity;
      }
    }

-    body?.setActivationState(DISABLE_DEACTIVATION);
+    const body = (this.vehicleEntity as Entity & NativeRigidBodyAccess).rigidbody?.body as {
+      setActivationState?: (state: number) => void;
+    } | null;
+    body?.setActivationState?.(DISABLE_DEACTIVATION);
    if (this.vehicleEntity.getPosition().y < -8) this.reset();
    this.updateCamera(deltaSeconds);
  }

-  private applyParkingTyreContact(
-    deltaSeconds: number,
-    rigidbody: NonNullable<NativeRigidBodyAccess["rigidbody"]>,
-    body: NativeRigidBody,
-    parkingBrakeEngaged: boolean,
-  ): void {
-    if (!this.vehicle || !this.vehicleEntity || !this.tyreImpulseNative
-      || !this.tyreRelativePositionNative) return;
-
-    if (!parkingBrakeEngaged) return;
-
-    const timeStep = Math.min(Math.max(0, deltaSeconds), 1 / 30);
-    if (timeStep === 0) return;
-    const wheelEffectiveMass = this.settings.massKg
-      / Math.max(1, this.wheelDefinitions.length);
-    const chassisPosition = this.vehicleEntity.getPosition();
-
-    for (let index = 0; index < this.wheelDefinitions.length; index += 1) {
-      const wheel = this.vehicle.getWheelInfo(index);
-      const raycast = wheel.get_m_raycastInfo();
-      const normalForce = wheel.get_m_wheelsSuspensionForce();
-      if (!Number.isFinite(normalForce) || normalForce < MIN_TYRE_NORMAL_FORCE_NEWTONS) {
-        continue;
-      }
-
-      const nativeNormal = raycast.get_m_contactNormalWS();
-      this.tyreContactNormal.set(nativeNormal.x(), nativeNormal.y(), nativeNormal.z());
-      if (this.tyreContactNormal.lengthSq() < 0.001) continue;
-      this.tyreContactNormal.normalize();
-
-      const nativeAxle = raycast.get_m_wheelAxleWS();
-      this.tyreLateralDirection.set(nativeAxle.x(), nativeAxle.y(), nativeAxle.z());
-      this.tyreLateralDirection.addScaled(
-        this.tyreContactNormal,
-        -this.tyreLateralDirection.dot(this.tyreContactNormal),
-      );
-      if (this.tyreLateralDirection.lengthSq() < 0.001) continue;
-      this.tyreLateralDirection.normalize();
-      this.tyreLongitudinalDirection.cross(
-        this.tyreContactNormal,
-        this.tyreLateralDirection,
-      ).normalize();
-
-      const nativeContactPoint = raycast.get_m_contactPointWS();
-      this.tyreContactPoint.set(
-        nativeContactPoint.x(),
-        nativeContactPoint.y(),
-        nativeContactPoint.z(),
-      );
-      this.tyreRelativePosition.sub2(this.tyreContactPoint, chassisPosition);
-      this.tyreAngularContactVelocity.cross(
-        rigidbody.angularVelocity,
-        this.tyreRelativePosition,
-      );
-      this.tyreContactVelocity.add2(
-        rigidbody.linearVelocity,
-        this.tyreAngularContactVelocity,
-      );
-
-      const lateralSlipSpeed = this.tyreContactVelocity.dot(this.tyreLateralDirection);
-      const longitudinalSlipSpeed = this.tyreContactVelocity.dot(
-        this.tyreLongitudinalDirection,
-      );
-      // Static tyre friction is a contact constraint: it balances the component
-      // of gravity along the surface and damps slip at the contact patch. The
-      // force still passes through a Coulomb circle and is applied at the wheel,
-      // so the chassis remains a fully dynamic rigid body.
-      const lateralGravityAcceleration = -GRAVITY_METERS_PER_SECOND_SQUARED
-        * this.tyreLateralDirection.y;
-      const longitudinalGravityAcceleration = -GRAVITY_METERS_PER_SECOND_SQUARED
-        * this.tyreLongitudinalDirection.y;
-      const trialLateralForce = -wheelEffectiveMass * (
-        lateralGravityAcceleration
-        + TYRE_CONTACT_VELOCITY_RESPONSE_PER_SECOND * lateralSlipSpeed
-      );
-      const trialLongitudinalForce = -wheelEffectiveMass * (
-        longitudinalGravityAcceleration
-        + TYRE_CONTACT_VELOCITY_RESPONSE_PER_SECOND * longitudinalSlipSpeed
-      );
-      const staticFrictionLimit = TYRE_STATIC_FRICTION_COEFFICIENT * normalForce;
-      let lateralForce = trialLateralForce;
-      let longitudinalForce = trialLongitudinalForce;
-
-      if (Math.hypot(trialLateralForce, trialLongitudinalForce) > staticFrictionLimit) {
-        const slipSpeed = Math.hypot(lateralSlipSpeed, longitudinalSlipSpeed);
-        const kineticFrictionLimit = TYRE_KINETIC_FRICTION_COEFFICIENT * normalForce;
-        if (slipSpeed > 0.0001) {
-          lateralForce = -(lateralSlipSpeed / slipSpeed) * kineticFrictionLimit;
-          longitudinalForce = -(longitudinalSlipSpeed / slipSpeed) * kineticFrictionLimit;
-        } else {
-          const forceScale = staticFrictionLimit
-            / Math.hypot(trialLateralForce, trialLongitudinalForce);
-          lateralForce = trialLateralForce * forceScale;
-          longitudinalForce = trialLongitudinalForce * forceScale;
-        }
-      }
-
-      const lateralImpulse = lateralForce * timeStep;
-      const longitudinalImpulse = longitudinalForce * timeStep;
-      this.tyreImpulseNative.setValue(
-        this.tyreLateralDirection.x * lateralImpulse
-          + this.tyreLongitudinalDirection.x * longitudinalImpulse,
-        this.tyreLateralDirection.y * lateralImpulse
-          + this.tyreLongitudinalDirection.y * longitudinalImpulse,
-        this.tyreLateralDirection.z * lateralImpulse
-          + this.tyreLongitudinalDirection.z * longitudinalImpulse,
-      );
-      this.tyreRelativePositionNative.setValue(
-        this.tyreRelativePosition.x,
-        this.tyreRelativePosition.y,
-        this.tyreRelativePosition.z,
-      );
-      body.applyImpulse(this.tyreImpulseNative, this.tyreRelativePositionNative);
-    }
-  }
-
  private async createStaticCollisionBodies(collisionWorld: Entity): Promise<void> {
    const models = collisionWorld.findComponents("model") as ModelComponent[];
    if (models.length === 0) throw new Error("В слое коллизий нет геометрии для физики UGV.");
@@ -598,12 +428,7 @@ export class SimulationUgvController {
        this.app,
        meshInstance.mesh,
        new Mat4().mul2(rootInverse, meshInstance.node.getWorldTransform()),
-        Math.max(
-          1,
-          Math.floor(
-            Math.floor((meshInstance.mesh.primitive[0]?.count ?? 0) / 3) * targetRatio,
-          ),
-        ),
+        targetRatio,
      );
      if (!physicsMesh) continue;
      const entity = new Entity(`UGV physics proxy ${index + 1}`);
@@ -639,9 +464,8 @@ export class SimulationUgvController {
      type: "dynamic",
      mass: this.settings.massKg,
      friction: 0.85,
-      rollingFriction: 0.12,
-      linearDamping: 0.12,
-      angularDamping: 0.6,
+      linearDamping: 0.08,
+      angularDamping: 0.45,
    });

    this.chassisMaterial = createMaterial(readThemeAccent(), new Color(0.03, 0.04, 0.05));
@@ -701,10 +525,7 @@ export class SimulationUgvController {
      applyMaterial(wheelMesh, this.wheelMaterial);
      anchor.addChild(wheelMesh);
      vehicle.addChild(anchor);
-      this.wheelDefinitions.push({
-        ...definition,
-        anchor,
-      });
+      this.wheelDefinitions.push({ ...definition, anchor });
    }

    vehicle.setLocalPosition(this.spawnPosition);
@@ -738,17 +559,16 @@ export class SimulationUgvController {
      wheel.set_m_suspensionStiffness(24);
      wheel.set_m_wheelsDampingRelaxation(3.2);
      wheel.set_m_wheelsDampingCompression(4.8);
-      wheel.set_m_frictionSlip(TYRE_FRICTION_SLIP);
+      wheel.set_m_frictionSlip(5.5);
      wheel.set_m_rollInfluence(0.08);
    }
    this.ammo.destroy(axle);
    this.ammo.destroy(direction);
    this.ammo.destroy(connection);
-    this.tyreImpulseNative = new this.ammo.btVector3(0, 0, 0);
-    this.tyreRelativePositionNative = new this.ammo.btVector3(0, 0, 0);

    dynamicsWorld.addAction(nativeVehicle);
    this.vehicleEntity = vehicle;
+    this.vehicleTuning = tuning;
    this.vehicleRaycaster = raycaster;
    this.vehicle = nativeVehicle;
    this.dynamicsWorld = dynamicsWorld;
@@ -864,12 +684,10 @@ export class SimulationUgvController {
    }
    if (this.vehicle) runCleanup("destroy vehicle", () => this.ammo.destroy(this.vehicle as NativeObject));
    if (this.vehicleRaycaster) runCleanup("destroy vehicle raycaster", () => this.ammo.destroy(this.vehicleRaycaster as NativeObject));
-    if (this.tyreImpulseNative) runCleanup("destroy tyre impulse vector", () => this.ammo.destroy(this.tyreImpulseNative as NativeObject));
-    if (this.tyreRelativePositionNative) runCleanup("destroy tyre relative-position vector", () => this.ammo.destroy(this.tyreRelativePositionNative as NativeObject));
+    if (this.vehicleTuning) runCleanup("destroy vehicle tuning", () => this.ammo.destroy(this.vehicleTuning as NativeObject));
    this.vehicle = null;
    this.vehicleRaycaster = null;
-    this.tyreImpulseNative = null;
-    this.tyreRelativePositionNative = null;
+    this.vehicleTuning = null;
    this.dynamicsWorld = null;

    if (this.vehicleEntity) runCleanup("destroy vehicle entity", () => this.vehicleEntity?.destroy());
@@ -1006,7 +824,7 @@ function createPhysicsProxyMesh(
  app: Application,
  source: Mesh,
  localTransform: Mat4,
-  targetTriangleCount: number,
+  targetRatio: number,
 ): Mesh | null {
  const primitive = source.primitive[0];
  const sourceVertexCount = source.vertexBuffer?.numVertices ?? 0;
@@ -1040,11 +858,8 @@ function createPhysicsProxyMesh(
  if (triangleIndexCount < 3) return null;
  if (triangleIndexCount !== indices.length) indices = indices.slice(0, triangleIndexCount);

-  const targetIndexCount = Math.max(
-    3,
-    Math.min(indices.length, Math.floor(targetTriangleCount) * 3),
-  );
-  if (indices.length > targetIndexCount) {
+  if (targetRatio < 1) {
+    const targetIndexCount = Math.max(3, Math.floor(indices.length * targetRatio / 3) * 3);
    const [simplifiedIndices] = MeshoptSimplifier.simplify(
      indices,
      transformed,
@@ -1053,26 +868,6 @@ function createPhysicsProxyMesh(
      PHYSICS_PROXY_ERROR,
    );
    indices = new Uint32Array(simplifiedIndices);
-    if (indices.length > targetIndexCount) {
-      // Topologically noisy scanner meshes can make the quality simplifier stop
-      // above its requested target. Ammo must never receive that unbounded result:
-      // the spatial fallback preserves the surface envelope while enforcing the
-      // same deterministic physics budget for every imported location.
-      const [boundedIndices] = MeshoptSimplifier.simplifySloppy(
-        indices,
-        transformed,
-        3,
-        null,
-        targetIndexCount,
-        1,
-      );
-      indices = new Uint32Array(boundedIndices);
-    }
-    if (indices.length > targetIndexCount) {
-      throw new Error(
-        `Physics proxy превысил лимит: ${Math.floor(indices.length / 3)} > ${Math.floor(targetIndexCount / 3)} треугольников.`,
-      );
-    }
  }

  const compactedIndices = new Uint32Array(indices);
@@ -6,18 +6,19 @@ interface TelemetrySeriesProps {
  ceiling?: number;
 }

-export function lineSegments(values: Array<number | null>, ceiling?: number): string[] {
-  const finite = values.filter((value): value is number => value !== null && Number.isFinite(value));
-  if (!finite.length) return [];
-  const maximum = Math.max(ceiling ?? 0, ...finite, 1), denominator = Math.max(1, values.length - 1);
-  const minimum = Math.min(0, ...finite), span = maximum - minimum;
-  const segments:string[]=[];let segment:string[]=[];
-  values.forEach((value,index)=>{
-    if(value===null||!Number.isFinite(value)){if(segment.length)segments.push(segment.join(' '));segment=[];return;}
-    segment.push(`${(index/denominator*100).toFixed(2)},${(36-(Math.min(maximum,value)-minimum)/span*34).toFixed(2)}`);
-  });
-  if(segment.length)segments.push(segment.join(' '));
-  return segments;
+function linePoints(values: Array<number | null>, ceiling?: number): string {
+  const finite = values.filter((value): value is number =>
+    value !== null && Number.isFinite(value),
+  );
+  if (finite.length === 0) return "";
+  const maximum = Math.max(ceiling ?? 0, ...finite, 1);
+  const denominator = Math.max(1, values.length - 1);
+  return values.map((value, index) => {
+    const x = index / denominator * 100;
+    const normalized = value === null ? 0 : Math.max(0, Math.min(maximum, value));
+    const y = 36 - normalized / maximum * 34;
+    return `${x.toFixed(2)},${y.toFixed(2)}`;
+  }).join(" ");
 }

 export function TelemetrySeries({
@@ -27,7 +28,7 @@ export function TelemetrySeries({
  resource,
  ceiling,
 }: TelemetrySeriesProps) {
-  const segments = lineSegments(values, ceiling);
+  const points = linePoints(values, ceiling);
  return (
    <div className="system-telemetry-series">
      <div>
@@ -44,7 +45,7 @@ export function TelemetrySeries({
        aria-label={`${label}: ${value}`}
      >
        <path d="M0 37 H100" />
-        {segments.map((points,index)=><polyline key={index} points={points} />)}
+        {points ? <polyline points={points} /> : null}
      </svg>
    </div>
  );
@@ -5,7 +5,6 @@ import type { WorkspaceDefinition } from "../productModel";

 interface ApplicationPanelActionsOptions {
  definition: WorkspaceDefinition | null;
-  onAddVehicle?: () => void;
  refreshRuntime: () => void;
  resetConnectionScenario?: () => Promise<boolean>;
  connectionScenarioResetting: boolean;
@@ -44,7 +43,6 @@ export function deviceRuntimeUtilityAction({

 export function useApplicationPanelActions({
  definition,
-  onAddVehicle,
  refreshRuntime,
  resetConnectionScenario,
  connectionScenarioResetting,
@@ -54,7 +52,6 @@ export function useApplicationPanelActions({
 }: ApplicationPanelActionsOptions): ApplicationPanelUtilityAction[] {
  return useMemo(() => {
    const actions: ApplicationPanelUtilityAction[] = [];
-    if (definition?.kind === "vehicles" && onAddVehicle) actions.push({ label: "Добавить аппарат", icon: "plus", onClick: onAddVehicle });
    if (definition?.kind === "device") {
      actions.push(deviceRuntimeUtilityAction({
        refreshRuntime,
@@ -74,7 +71,6 @@ export function useApplicationPanelActions({
    return actions;
  }, [
    definition,
-    onAddVehicle,
    refreshRuntime,
    resetConnectionScenario,
    connectionScenarioResetting,
@@ -1,13 +1,8 @@
 import type { DeviceUiPlugin } from "../core/device-plugins/contracts";
 import { xgridsK1Plugin } from "@xgrids-k1/frontend/plugin";
-import {insta360X4SensorUi} from '../../../../plugins/insta360-x4/frontend/src/plugin';

 // Composition root: this is the only place where Mission Core chooses which
 // statically reviewed device plugins are shipped in the current build.
 export const installedDevicePlugins: readonly DeviceUiPlugin[] = Object.freeze([
  xgridsK1Plugin,
 ]);
-
-// Node-executed camera controls use the existing sensor contribution contract;
-// they do not register a desktop capture/AI runtime or a new product workspace.
-export const installedNodeSensorContributions = Object.freeze([insta360X4SensorUi]);
@@ -11,8 +11,6 @@ import {
 import { IdleMissionRuntimeProvider } from "../runtime/MissionRuntimeContext";
 import type { DeviceUiPlugin, RegisteredDeviceModel } from "./contracts";
 import { createDevicePluginRegistry, type DevicePluginRegistry } from "./registry";
-import type {SensorUiContribution} from '../../../../../packages/sensor-ui/src/extensions';
-const NO_NODE_SENSORS: readonly SensorUiContribution[] = Object.freeze([]);

 interface DevicePluginHostValue {
  registry: DevicePluginRegistry;
@@ -85,14 +83,12 @@ export function commitPersistedDeviceModelId(

 export function DevicePluginHostProvider({
  plugins,
-  nodeSensorContributions = NO_NODE_SENSORS,
  children,
 }: {
  plugins: readonly DeviceUiPlugin[];
-  nodeSensorContributions?: readonly SensorUiContribution[];
  children: ReactNode;
 }) {
-  const registry = useMemo(() => createDevicePluginRegistry(plugins, nodeSensorContributions), [plugins, nodeSensorContributions]);
+  const registry = useMemo(() => createDevicePluginRegistry(plugins), [plugins]);
  const selectionStorage = useMemo(browserDeviceModelSelectionStorage, []);
  const [selectedModelId, setSelectedModelId] = useState<string | null>(() =>
    restorePersistedDeviceModelId(registry, selectionStorage)
@@ -103,9 +103,6 @@ export interface DevicePluginConnectionProps {
 }

 export interface DeviceUiPlugin {
-  sensorUi?: {
-    contributions: readonly import('../../../../../packages/sensor-ui/src/extensions').SensorUiContribution[];
-  };
  manifest: DevicePluginManifest;
  RuntimeProvider: ComponentType<{
    activeModel: DeviceModelDefinition | null;
@@ -6,10 +6,8 @@ import {
  type DeviceUiPlugin,
  type RegisteredDeviceModel,
 } from "./contracts";
-import type {SensorUiContribution} from '../../../../../packages/sensor-ui/src/extensions';

 export interface DevicePluginRegistry {
-  readonly sensorContributions: readonly SensorUiContribution[];
  readonly plugins: readonly DeviceUiPlugin[];
  readonly models: readonly RegisteredDeviceModel[];
  resolveModel: (modelId: string) => RegisteredDeviceModel | null;
@@ -17,7 +15,6 @@ export interface DevicePluginRegistry {

 export function createDevicePluginRegistry(
  installedPlugins: readonly DeviceUiPlugin[],
-  nodeSensorContributions: readonly SensorUiContribution[] = [],
 ): DevicePluginRegistry {
  const pluginIds = new Set<string>();
  const modelIds = new Set<string>();
@@ -136,15 +133,7 @@ export function createDevicePluginRegistry(
  }

  const modelById = new Map(models.map((registered) => [registered.model.id, registered]));
-  const sensorContributions = [
-    ...installedPlugins.flatMap(plugin => plugin.sensorUi?.contributions ?? []),
-    ...nodeSensorContributions,
-  ];
-  if (new Set(sensorContributions.map(value => value.kind)).size !== sensorContributions.length) {
-    throw new Error('Плагины повторяют модель устройства БК.');
-  }
  return {
-    sensorContributions: Object.freeze(sensorContributions),
    plugins: Object.freeze([...installedPlugins]),
    models: Object.freeze(models),
    resolveModel: (modelId) => modelById.get(modelId) ?? null,
@@ -1,9 +1,32 @@
 import { roots, type RootId } from "../../productModel";

 export type EnvironmentSurfaceId = "home" | RootId;
-import { defaultEnvironmentImageDurationSeconds, maxEnvironmentMediaItems, type EnvironmentBackground, type EnvironmentMediaItem, type EnvironmentMediaKind, type EnvironmentMediaSource, type EnvironmentPage } from "@nodedc/ui-core";
-export { createEnvironmentMediaItem, appendEnvironmentMediaItem, removeEnvironmentMediaItem, inferEnvironmentMediaKind, defaultEnvironmentImageDurationSeconds, maxEnvironmentMediaItems } from "@nodedc/ui-core";
-export type { EnvironmentBackground, EnvironmentMediaItem, EnvironmentMediaKind, EnvironmentMediaSource, EnvironmentPage } from "@nodedc/ui-core";
+export type EnvironmentMediaKind = "image" | "video";
+export type EnvironmentMediaSource = "file" | "url";
+
+export interface EnvironmentMediaItem {
+  id: string;
+  source: EnvironmentMediaSource;
+  url: string | null;
+  mediaKind: EnvironmentMediaKind | null;
+  fileName: string | null;
+}
+
+export interface EnvironmentBackground {
+  enabled: boolean;
+  imageDurationSeconds: number;
+  items: EnvironmentMediaItem[];
+}
+
+export interface EnvironmentPage {
+  headerLabel: string;
+  eyebrow: string;
+  title: string;
+  description: string;
+  primaryWorkspaceId: string | null;
+  secondaryWorkspaceId: string | null;
+  background: EnvironmentBackground;
+}

 export interface EnvironmentSettings {
  revision: number;
@@ -31,19 +54,72 @@ const surfaceIds: readonly EnvironmentSurfaceId[] = [
  "polygon",
 ];

-function emptyBackground(): EnvironmentBackground { return { enabled: false, imageDurationSeconds: defaultEnvironmentImageDurationSeconds, items: [] }; }
+export const defaultEnvironmentImageDurationSeconds = 10;
+export const maxEnvironmentMediaItems = 24;
+
+function emptyBackground(): EnvironmentBackground {
+  return {
+    enabled: false,
+    imageDurationSeconds: defaultEnvironmentImageDurationSeconds,
+    items: [],
+  };
+}
+
+export function createEnvironmentMediaItem(): EnvironmentMediaItem {
+  return {
+    id: `media-${crypto.randomUUID()}`,
+    source: "file",
+    url: null,
+    mediaKind: null,
+    fileName: null,
+  };
+}
+
+export function appendEnvironmentMediaItem(
+  background: EnvironmentBackground,
+  item: EnvironmentMediaItem = createEnvironmentMediaItem(),
+): EnvironmentBackground {
+  if (
+    background.items.length >= maxEnvironmentMediaItems
+    || background.items.some((candidate) => candidate.id === item.id)
+  ) {
+    return background;
+  }
+  return {
+    ...background,
+    enabled: background.items.length === 0 ? true : background.enabled,
+    items: [...background.items, item],
+  };
+}
+
+export function removeEnvironmentMediaItem(
+  background: EnvironmentBackground,
+  itemId: string,
+): EnvironmentBackground {
+  const items = background.items.filter((item) => item.id !== itemId);
+  if (items.length === background.items.length) return background;
+  return {
+    ...background,
+    enabled: items.length > 0 && background.enabled,
+    items,
+  };
+}
+
+export function inferEnvironmentMediaKind(url: string): EnvironmentMediaKind {
+  return /\.(mp4|webm|mov)(?:[?#].*)?$/i.test(url) ? "video" : "image";
+}

 const defaultQuickActions: Record<
  EnvironmentSurfaceId,
  readonly [string | null, string | null]
 > = {
-  home: ["spatial-scene", "vehicles"],
-  fleet: ["vehicles", "contour-health"],
-  observation: ["cameras", "world-map"],
+  home: ["spatial-scene", "local-device"],
+  fleet: ["contour-health", "local-device"],
+  observation: ["spatial-scene", "cameras"],
  missions: ["mission-planner", null],
  data: ["recordings", "datasets"],
  system: ["modules", "integrations"],
-  polygon: ["lab-archive", "local-device"],
+  polygon: ["lab-archive", null],
 };

 export function defaultEnvironmentSettings(): EnvironmentSettings {
@@ -1,49 +0,0 @@
-import {useEffect,useState} from 'react';
-
-export interface MetricDefinition {label:string;group:string;resource:string;unit:string;reason:string|null}
-export interface BoardMonitor {
- available:boolean;fresh:boolean;storage:string;source_id:string;
- latest:{seq:number;at:number;boot_id:string;values:Record<string,number|null>}|null;
- definitions:Record<string,MetricDefinition>;received_at:number;backlog:number;
- database_bytes:number|null;database_budget_bytes:number;archive_since:number|null;
- start:number;end:number;bucket_seconds:number;
- series:{at:number;min:number|null;max:number|null;mean:number|null;count:number}[];
- events:{at:number;code:string;kind:string;locations:string[]}[];
-}
-export function useBoardMonitor(vehicle:string,metric:string,window:number,end:number|null){
- const [value,setValue]=useState<BoardMonitor|null>(null),[error,setError]=useState('');
- useEffect(()=>{
-  let active=true;let pending:AbortController|undefined;let timer:ReturnType<typeof setTimeout>|undefined;
-  setValue(null);setError('');
-  const read=async()=>{
-   const controller=new AbortController();pending=controller;
-   const deadline=setTimeout(()=>controller.abort(),12000);
-   try {
-    const query=new URLSearchParams({metric,window:String(window),...(end===null?{}:{end:String(end)})});
-    const response=await fetch(`/api/v1/fleet/${encodeURIComponent(vehicle)}/monitor?${query}`,{credentials:'same-origin',cache:'no-store',signal:controller.signal});
-    if(!response.ok)throw new Error('Мониторинг БК недоступен.');
-    const next=await response.json() as BoardMonitor;
-    if(active){setValue(next);setError('');}
-   }catch {if(active)setError('Не удалось обновить мониторинг БК.');}
-   finally {clearTimeout(deadline);if(active)timer=setTimeout(()=>void read(),5000);}
-  };
-  void read();return()=>{active=false;pending?.abort();clearTimeout(timer);};
- },[vehicle,metric,window,end]);
- return {value,error,dismissError:()=>setError('')};
-}
-export function monitorSeries(value:BoardMonitor,mode:'min'|'max'|'mean') {
- const count=Math.ceil((value.end-value.start)/value.bucket_seconds)+1;
- const values:Array<number|null>=Array(Math.min(count,302)).fill(null);
- const first=Math.floor(value.start/value.bucket_seconds)*value.bucket_seconds;
- for(const point of value.series){const index=Math.round((point.at-first)/value.bucket_seconds);if(index>=0&&index<values.length)values[index]=point[mode];}
- return values;
-}
-export function monitorValue(value:number|null|undefined,unit=''){
- if(value==null||!Number.isFinite(value))return 'Нет измерения';
- if(unit==='bytes'||unit==='bytes/s'){
-  const labels=unit==='bytes'?['Б','КиБ','МиБ','ГиБ']:['Б/с','КиБ/с','МиБ/с','ГиБ/с'];let index=0;
-  while(value>=1024&&index<3){value/=1024;index++;}
-  return `${value.toLocaleString('ru-RU',{maximumFractionDigits:1})} ${labels[index]}`;
- }
- return `${value.toLocaleString('ru-RU',{maximumFractionDigits:1})}${unit?' '+unit:''}`;
-}
@@ -1,23 +0,0 @@
-export interface ObservationLayout {
- version:1; order:string[]; hidden:string[]; layers:Record<string,string>;
- splits:Record<string,number>; arrangement:'auto'|'columns'|'rows';
-}
-export const emptyObservationLayout=():ObservationLayout=>({version:1,order:[],hidden:[],layers:{},splits:{},arrangement:'auto'});
-const record=(value:unknown):Record<string,unknown>=>value!==null&&typeof value==='object'&&!Array.isArray(value)?value as Record<string,unknown>:{};
-export function decodeObservationLayout(value:unknown):ObservationLayout {
- const source=record(value),result=emptyObservationLayout();if(source.version!==1)return result;
- const ids=(value:unknown)=>Array.isArray(value)?[...new Set(value.filter((v):v is string=>typeof v==='string'&&v.length<512))].slice(0,128):[];
- result.order=ids(source.order);result.hidden=ids(source.hidden);
- result.layers=Object.fromEntries(Object.entries(record(source.layers)).filter(([k,v])=>k.length<512&&typeof v==='string'&&v.length<128).slice(0,128)) as Record<string,string>;
- result.splits=Object.fromEntries(Object.entries(record(source.splits)).filter(([k,v])=>k.length<4096&&typeof v==='number'&&Number.isFinite(v)).slice(0,256).map(([k,v])=>[k,Math.min(80,Math.max(20,v as number))]));
- if(source.arrangement==='rows'||source.arrangement==='columns')result.arrangement=source.arrangement;
- return result;
-}
-export function orderedObservationIDs(layout:ObservationLayout,available:string[]):string[]{
- const present=new Set(available);return [...layout.order.filter(id=>present.has(id)),...available.filter(id=>!layout.order.includes(id))];
-}
-export function moveObservation(layout:ObservationLayout,available:string[],from:string,to:string):ObservationLayout {
- const order=orderedObservationIDs(layout,available);const source=order.indexOf(from),target=order.indexOf(to);
- if(source<0||target<0||source===target)return layout;
- order.splice(source,1);order.splice(target,0,from);return {...layout,order};
-}
@@ -1,18 +0,0 @@
-import type {SensorInventory, SensorTransport} from '../../../../../packages/sensor-ui/src/contracts';
-import {fleetRequest} from './useFleet';
-
-export function createFleetSensorTransport(vehicleID:string):SensorTransport {
- const path=`/${encodeURIComponent(vehicleID)}/devices`;
- const inventory=(fleet:{items:{id:string;connectivity:string;enrollment:string;sensor_state:SensorInventory}[]})=>{
-  const value=fleet.items.find(v=>v.id===vehicleID);
-  if(!value)throw new Error('Аппарат не найден.');
-  return {...value.sensor_state,fresh:value.connectivity==='online'&&value.enrollment==='paired'};
- };
- return {
-  enrollment:{state:()=>fleetRequest(`${path}/enrollment`),submit:value=>fleetRequest(`${path}/enrollment/operations`,'POST',value),operation:id=>fleetRequest(`${path}/enrollment/operations/${encodeURIComponent(id)}`)},
-  inventory:async()=>inventory(await fleetRequest()),
-  subscribe:(receive,unavailable)=>{const events=new EventSource('/api/v1/fleet/events');events.onmessage=e=>{try{receive(inventory(JSON.parse(e.data)));}catch{unavailable();}};events.onerror=unavailable;return()=>events.close();},
-  submit:value=>fleetRequest(`${path}/operations`,'POST',value),
-  operation:id=>fleetRequest(`${path}/operations/${encodeURIComponent(id)}`),
- };
-}
@@ -1,61 +0,0 @@
-import { useCallback, useEffect, useState } from "react";
-
-export interface BoardHost {
-  hostname: string; os: string; architecture: string; cpus: number;
-  memory_kib: number | null; collected_at: string;
-  networks: { name: string; up: boolean; addresses: string[] }[];
-  usb: { port: string; product: string }[];
-}
-export interface Vehicle {
-  id: string; node_id: string; name: string; platform: string;
-  enrollment: "pending" | "paired" | "revoked" | "failed";
-  connectivity: "online" | "offline"; last_seen: number | null;
-  host: BoardHost | null; notice: string; revision: number;
-}
-export interface FleetPreview {
-  preview_id: string; node_id: string; name: string; host: BoardHost;
-  endpoint: string; expires_at: number;
-}
-export async function fleetRequest<T>(path = "", method = "GET", body?: unknown): Promise<T> {
-  const response = await fetch(`/api/v1/fleet${path}`, {
-    method, credentials: "same-origin", cache: "no-store",
-    headers: body === undefined ? {} : { "Content-Type": "application/json" },
-    body: body === undefined ? undefined : JSON.stringify(body), signal: AbortSignal.timeout(12000),
-  });
-  if (!response.ok) {
-    const data = await response.json().catch(() => ({}));
-    throw new Error(typeof data.detail === "string" ? data.detail : "Не удалось выполнить действие с аппаратом.");
-  }
-  return response.json();
-}
-export function useFleet() {
-  const [items, setItems] = useState<Vehicle[] | null>(null);
-  const [error, setError] = useState("");
-  const refresh = useCallback(async () => {
-    const value = await fleetRequest<{ items: Vehicle[] }>();
-    setItems(value.items); setError(""); return value.items;
-  }, []);
-  useEffect(() => {
-    let active = true;
-    let fallback: ReturnType<typeof setInterval> | undefined;
-    const read = async () => {
-      try { const value = await fleetRequest<{ items: Vehicle[] }>(); if (active) { setItems(value.items); setError(""); } }
-      catch { if (active) setError("Реестр недоступен. Показаны последние полученные сведения; связь сейчас не подтверждена."); }
-    };
-    void read();
-    const events = new EventSource("/api/v1/fleet/events");
-    events.onmessage = event => {
-      if (!active) return;
-      try { const value = JSON.parse(event.data); setItems(value.items); setError(""); if (fallback) { clearInterval(fallback); fallback = undefined; } }
-      catch { unavailable(); }
-    };
-    const unavailable = () => {
-      if (!active) return;
-      setError("Связь обновляется. Показаны последние полученные сведения.");
-      if (!fallback) fallback = setInterval(() => void read(), 5000);
-    };
-    events.onerror = unavailable;
-    return () => { active = false; events.close(); if (fallback) clearInterval(fallback); };
-  }, []);
-  return { items, error, refresh };
-}
@@ -48,13 +48,9 @@ import { fetchM48SFixedClassDetectorResult } from "./m48sFixedClassDetector";
 import { fetchM48TRiskQualityResult } from "./m48tRiskQuality";
 import { fetchM49TgsFailClosedResult } from "./m49TgsFailClosed";
 import { fetchM49TgsFullShadowResult } from "./m49TgsFullShadow";
-import {
-  fetchVegetationBenchmarkResult,
-  fetchVegetationShadowResult,
-} from "./vegetationShadow";
+import { fetchVegetationShadowResult } from "./vegetationShadow";

 export type AdvancedLaboratoryWorkId =
-  | "lab-v1-vegetation-benchmark"
  | "lab-v1-vegetation-shadow"
  | "m48-object-centric-quality"
  | "m48-small-static-passage-regression"
@@ -106,7 +102,6 @@ export interface AdvancedLaboratoryIndexItem {
 }

 const WORK_IDS: readonly AdvancedLaboratoryWorkId[] = [
-  "lab-v1-vegetation-benchmark",
  "lab-v1-vegetation-shadow",
  "m48-object-centric-quality",
  "m48-small-static-passage-regression",
@@ -153,7 +148,6 @@ const WORK_IDS: readonly AdvancedLaboratoryWorkId[] = [
 ];

 const RESULT_PREFIX: Readonly<Record<AdvancedLaboratoryWorkId, string>> = {
-  "lab-v1-vegetation-benchmark": "lab-v1-vegetation-benchmark",
  "lab-v1-vegetation-shadow": "lab-v1-vegetation-shadow",
  "m48-object-centric-quality": "m48-object-quality-(?:pack|result)",
  "m48-small-static-passage-regression": "m48-small-static-passage-regression",
@@ -207,7 +201,6 @@ export function isAdvancedLaboratoryWorkId(

 export function emptyAdvancedLaboratoryResults(): AdvancedLaboratoryResults {
  return {
-    vegetationBenchmark: null,
    vegetationShadow: null,
    m47Graph: null,
    m48: null,
@@ -342,8 +335,7 @@ export function advancedLaboratoryResultAvailable(
  workId: AdvancedLaboratoryWorkId,
  results: AdvancedLaboratoryResults,
 ): boolean {
-  return workId === "lab-v1-vegetation-benchmark" ? results.vegetationBenchmark !== null
-    : workId === "lab-v1-vegetation-shadow" ? results.vegetationShadow !== null
+  return workId === "lab-v1-vegetation-shadow" ? results.vegetationShadow !== null
    : workId === "m48-object-centric-quality" ? results.m48 !== null
    : workId === "m48-small-static-passage-regression" ? results.m48SmallStatic !== null
    : workId === "m48-static-occupancy-qualification" ? results.m48StaticOccupancy !== null
@@ -401,10 +393,7 @@ export async function fetchAdvancedLaboratoryResult(
  } = {},
 ): Promise<AdvancedLaboratoryResults> {
  const results = emptyAdvancedLaboratoryResults();
-  if (workId === "lab-v1-vegetation-benchmark") {
-    if (!resultId) throw new AdvancedLaboratoryContractError("Vegetation benchmark identity не выбрана.");
-    results.vegetationBenchmark = await fetchVegetationBenchmarkResult(resultId, { fetcher, signal });
-  } else if (workId === "lab-v1-vegetation-shadow") {
+  if (workId === "lab-v1-vegetation-shadow") {
    if (!resultId) throw new AdvancedLaboratoryContractError("Vegetation LAB identity не выбрана.");
    results.vegetationShadow = await fetchVegetationShadowResult(resultId, { fetcher, signal });
  } else if (workId === "m48-object-centric-quality") {
@@ -45,7 +45,6 @@ import type { M49TgsFullShadowResult } from "./m49TgsFullShadow";
 import type { VegetationShadowResult } from "./vegetationShadow";

 export interface AdvancedLaboratoryResults {
-  vegetationBenchmark: VegetationShadowResult | null;
  vegetationShadow: VegetationShadowResult | null;
  m47Graph: M47ReferenceGraphLabResult | null;
  m48: M48AdvancedResult | null;
@@ -29,6 +29,7 @@ export interface E31LaboratoryResult {
  limitations: readonly string[];
  access: "read-only";
 }
+
 export interface E32LaboratoryResult {
  resultId: string;
  createdAtUtc: string | null;
@@ -52,6 +53,7 @@ export interface E32LaboratoryResult {
  };
  access: "read-only";
 }
+
 export interface E33LaboratoryResult {
  resultId: string;
  createdAtUtc: string | null;
@@ -965,7 +967,6 @@ export async function fetchAdvancedLaboratoryResults({
  const e39 = settledCatalogValue(settled[7]);
  const e40 = settledCatalogValue(settled[8]);
  return {
-    vegetationBenchmark: null,
    vegetationShadow: null,
    m47Graph: null, m48: null, m48SmallStatic: null, m48StaticOccupancy: null,
    m48r3StaticOccupancy: null,
@@ -1,134 +0,0 @@
-import type { ObservationSessionReplayLaunch } from "../observation/sessionArchive";
-import type { RecordedRrdArtifactDescriptor } from "../observation/viewerProfile";
-
-const SAFE_RESULT_ID = /^lab-v1-vegetation-shadow-[a-f0-9]{64}$/;
-const SAFE_SESSION_SOURCE = /^\/api\/v1\/observation-sessions\/[A-Za-z0-9][A-Za-z0-9._:-]{0,127}\/recording\.rrd$/;
-const MAX_CANONICAL_REPLAY_BYTES = 1024 * 1024 * 1024;
-
-export interface CanonicalLabReplayDescriptor extends RecordedRrdArtifactDescriptor {
-  blueprintSourceUrl: string;
-}
-
-/**
- * Resolve the one immutable RRD used by the canonical recorded LAB.
- *
- * The server caches the merge of the sealed spatial recording and the LAB AI
- * evidence. Rerun therefore opens one source and cannot present the base store
- * before a second receiver has finished decoding the semantic layer.
- */
-export async function resolveCanonicalLabReplay(
-  resultId: string,
-  launch: ObservationSessionReplayLaunch,
-  {
-    origin = window.location.origin,
-    signal,
-    fetcher = globalThis.fetch,
-    sourceKind = "legacy-vegetation",
-  }: {
-    origin?: string;
-    signal?: AbortSignal;
-    fetcher?: typeof globalThis.fetch;
-    sourceKind?: "legacy-vegetation" | "portable-tgs" | "portable-semantic" | "portable-objects";
-  } = {},
-): Promise<CanonicalLabReplayDescriptor> {
-  const base = new URL(origin);
-  if (
-    !(sourceKind === "portable-tgs"
-      ? /^m49-tgs-portable-review-[a-f0-9]{64}$/.test(resultId)
-      : sourceKind === "portable-semantic"
-        ? /^(?:lab-v1-eomt-ddrnet|ai-layer-(?:ddrnet|eomt))-[a-f0-9]{64}$/.test(resultId)
-        : sourceKind === "portable-objects"
-          ? /^ai-layer-(?:rf-detr|object-distance)-[a-f0-9]{64}$/.test(resultId)
-        : SAFE_RESULT_ID.test(resultId))
-    || !SAFE_SESSION_SOURCE.test(launch.sourceUrl)
-    || launch.viewerSourceUrl !== `${launch.sourceUrl}?generation=${launch.sha256}`
-    || !/^[a-f0-9]{64}$/.test(launch.sha256)
-  ) {
-    throw new Error("Канонический replay LAB имеет небезопасный descriptor.");
-  }
-  const sourceUrl = sourceKind !== "legacy-vegetation"
-    ? `/api/v1/observatory/portable-results/${resultId}/replays/${launch.sha256}/recording.rrd`
-    : `/api/v1/laboratory/vegetation-shadow/${encodeURIComponent(resultId)}/canonical-replay.rrd`;
-  const descriptorUrl = new URL(sourceUrl, `${base.origin}/`);
-  if (sourceKind === "legacy-vegetation") descriptorUrl.searchParams.set("base_generation", launch.sha256);
-  if (descriptorUrl.origin !== base.origin) {
-    throw new Error("Канонический replay LAB должен быть same-origin.");
-  }
-  const response = await fetcher(descriptorUrl.href, {
-    method: "HEAD",
-    credentials: "same-origin",
-    headers: { Accept: "application/vnd.rerun.rrd" },
-    signal,
-  });
-  const contentType = response.headers.get("Content-Type")?.split(";", 1)[0].trim();
-  const byteLength = Number(response.headers.get("Content-Length"));
-  const sha256 = response.headers.get("ETag")?.match(/^"([a-f0-9]{64})"$/)?.[1];
-  if (
-    response.status !== 200
-    || contentType !== "application/vnd.rerun.rrd"
-    || response.headers.get("X-Rerun-Format") !== "RRF2"
-    || !sha256
-    || !Number.isSafeInteger(byteLength)
-    || byteLength < 4
-    || byteLength > MAX_CANONICAL_REPLAY_BYTES
-  ) {
-    throw new Error("Единый replay LAB не прошёл проверку.");
-  }
-  return {
-    sourceUrl,
-    viewerSourceUrl: `${sourceUrl}?generation=${sha256}`,
-    byteLength,
-    sha256,
-    blueprintSourceUrl: launch.sourceUrl.replace(/\/recording\.rrd$/, "/blueprint.rrd"),
-  };
-}
-
-export async function resolveAICompositionReplay(
-  runId: string,
-  launch: ObservationSessionReplayLaunch,
-  {
-    origin = window.location.origin,
-    signal,
-    fetcher = globalThis.fetch,
-  }: {
-    origin?: string;
-    signal?: AbortSignal;
-    fetcher?: typeof globalThis.fetch;
-  } = {},
-): Promise<CanonicalLabReplayDescriptor> {
-  const base = new URL(origin);
-  if (
-    !/^ai-composition-[a-f0-9]{64}$/.test(runId)
-    || !SAFE_SESSION_SOURCE.test(launch.sourceUrl)
-    || launch.viewerSourceUrl !== `${launch.sourceUrl}?generation=${launch.sha256}`
-    || !/^[a-f0-9]{64}$/.test(launch.sha256)
-  ) {
-    throw new Error("Составной replay LAB имеет небезопасный descriptor.");
-  }
-  const sourceUrl = `/api/v1/observatory/ai-composition-runs/${runId}/replays/${launch.sha256}/recording.rrd`;
-  const descriptorUrl = new URL(sourceUrl, `${base.origin}/`);
-  const response = await fetcher(descriptorUrl.href, {
-    method: "HEAD",
-    credentials: "same-origin",
-    headers: { Accept: "application/vnd.rerun.rrd" },
-    signal,
-  });
-  const contentType = response.headers.get("Content-Type")?.split(";", 1)[0].trim();
-  const byteLength = Number(response.headers.get("Content-Length"));
-  const sha256 = response.headers.get("ETag")?.match(/^"([a-f0-9]{64})"$/)?.[1];
-  if (
-    response.status !== 200 || contentType !== "application/vnd.rerun.rrd"
-    || response.headers.get("X-Rerun-Format") !== "RRF2" || !sha256
-    || !Number.isSafeInteger(byteLength) || byteLength < 4
-    || byteLength > MAX_CANONICAL_REPLAY_BYTES
-  ) {
-    throw new Error("Составной replay LAB не прошёл проверку.");
-  }
-  return {
-    sourceUrl,
-    viewerSourceUrl: `${sourceUrl}?generation=${sha256}`,
-    byteLength,
-    sha256,
-    blueprintSourceUrl: launch.sourceUrl.replace(/\/recording\.rrd$/, "/blueprint.rrd"),
-  };
-}
@@ -1,99 +0,0 @@
-export const CANONICAL_RECORDED_LAB_TGS_HISTORY_SECONDS = 1;
-export const CANONICAL_RECORDED_LAB_SPATIAL_PROFILE = "source-paced-ground-v3";
-
-export interface CanonicalRecordedLabPackedCellEvidence {
-  centersBodyXyM: Float32Array;
-  zBoundsM: Float32Array;
-  stateCodes: Uint8Array;
-}
-
-export interface CanonicalRecordedLabBodyGroundFrame {
-  originMapXyzM: readonly [number, number, number];
-  sensorOriginMapXyzM: readonly [number, number, number];
-  basisMapFromBody: readonly [
-    readonly [number, number, number],
-    readonly [number, number, number],
-    readonly [number, number, number],
-  ];
-}
-
-export interface CanonicalRecordedLabTgsCostmap {
-  centersXyM: readonly (readonly [number, number])[];
-  stateCodes: readonly number[];
-  zBoundsM: readonly (readonly [number | null, number | null])[];
-}
-
-export function canonicalRecordedLabTgsIsCurrent(
-  currentTimeNs: number,
-  anchorTimeNs: number,
-  historySeconds = CANONICAL_RECORDED_LAB_TGS_HISTORY_SECONDS,
-): boolean {
-  if (
-    !Number.isSafeInteger(currentTimeNs)
-    || !Number.isSafeInteger(anchorTimeNs)
-    || !Number.isFinite(historySeconds)
-    || historySeconds <= 0
-  ) return false;
-  const ageNs = currentTimeNs - anchorTimeNs;
-  return ageNs >= 0 && ageNs <= Math.round(historySeconds * 1_000_000_000);
-}
-
-export function canonicalMapGravityLocalPointToBodyGround(
-  point: readonly [number, number, number],
-  anchor: CanonicalRecordedLabBodyGroundFrame,
-  current: CanonicalRecordedLabBodyGroundFrame,
-): readonly [number, number, number] {
-  // TGS is translation-only map-gravity-local: its axes are map axes and its
-  // origin is the LiDAR at the source frame. It is not an anchor body frame.
-  const map: readonly [number, number, number] = [
-    anchor.sensorOriginMapXyzM[0] + point[0],
-    anchor.sensorOriginMapXyzM[1] + point[1],
-    anchor.sensorOriginMapXyzM[2] + point[2],
-  ];
-  const delta: readonly [number, number, number] = [
-    map[0] - current.originMapXyzM[0],
-    map[1] - current.originMapXyzM[1],
-    map[2] - current.originMapXyzM[2],
-  ];
-  return [
-    current.basisMapFromBody[0][0] * delta[0]
-      + current.basisMapFromBody[1][0] * delta[1]
-      + current.basisMapFromBody[2][0] * delta[2],
-    current.basisMapFromBody[0][1] * delta[0]
-      + current.basisMapFromBody[1][1] * delta[1]
-      + current.basisMapFromBody[2][1] * delta[2],
-    current.basisMapFromBody[0][2] * delta[0]
-      + current.basisMapFromBody[1][2] * delta[1]
-      + current.basisMapFromBody[2][2] * delta[2],
-  ];
-}
-
-export function canonicalRecordedLabPackedTgsCells(
-  costmap: CanonicalRecordedLabTgsCostmap,
-  anchor: CanonicalRecordedLabBodyGroundFrame,
-  current: CanonicalRecordedLabBodyGroundFrame,
-): CanonicalRecordedLabPackedCellEvidence {
-  if (
-    costmap.centersXyM.length !== costmap.stateCodes.length
-    || costmap.centersXyM.length !== costmap.zBoundsM.length
-  ) throw new Error("Canonical recorded LAB TGS accounting changed");
-  const centers: number[] = [];
-  const zBounds: number[] = [];
-  costmap.centersXyM.forEach(([x, y], index) => {
-    const bounds = costmap.zBoundsM[index] ?? [null, null];
-    const center = canonicalMapGravityLocalPointToBodyGround([x, y, 0], anchor, current);
-    centers.push(center[0], center[1]);
-    if (bounds[0] === null || bounds[1] === null) {
-      zBounds.push(Number.NaN, Number.NaN);
-      return;
-    }
-    const bottom = canonicalMapGravityLocalPointToBodyGround([x, y, bounds[0]], anchor, current);
-    const top = canonicalMapGravityLocalPointToBodyGround([x, y, bounds[1]], anchor, current);
-    zBounds.push(Math.min(bottom[2], top[2]), Math.max(bottom[2], top[2]));
-  });
-  return {
-    centersBodyXyM: Float32Array.from(centers),
-    zBoundsM: Float32Array.from(zBounds),
-    stateCodes: Uint8Array.from(costmap.stateCodes),
-  };
-}
@@ -1,259 +0,0 @@
-import type { LaboratoryFetch } from "./advancedResults";
-import { CANONICAL_RECORDED_LAB_SPATIAL_PROFILE } from "./canonicalRecordedLab";
-
-const SAFE_SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
-const SHA256 = /^[a-f0-9]{64}$/;
-
-export class CanonicalRecordedLabSpatialContractError extends Error {}
-
-export interface CanonicalRecordedLabSpatialFrame {
-  targetTimeNs: number;
-  sourceTimeNs: number;
-  poseTimeNs: number;
-  trajectoryTimeNs: number;
-  sourcePointCount: number;
-  coordinateFrame: "body-ground";
-  sensorHeight: {
-    meters: number;
-    source: "local-source-cloud-ground-quantile-median" | "session-source-cloud-fallback";
-    sampleCount: number;
-    madM: number;
-    authority: "visual-derived";
-  };
-  spatialProfile: {
-    profileId: typeof CANONICAL_RECORDED_LAB_SPATIAL_PROFILE;
-    localSlamHistorySeconds: number;
-    localSlamRadiusM: number;
-    localSlamVoxelSizeM: number;
-    localSlamPointLimit: number;
-  };
-  bodyFrame: {
-    originMapXyzM: readonly [number, number, number];
-    sensorOriginMapXyzM: readonly [number, number, number];
-    basisMapFromBody: readonly [
-      readonly [number, number, number],
-      readonly [number, number, number],
-      readonly [number, number, number],
-    ];
-  };
-  sourcePointsBodyXyzM: readonly (readonly [number, number, number])[];
-  localSlamSourceFrameCount: number;
-  localSlamSourcePointCount: number;
-  localSlamBodyXyzM: readonly (readonly [number, number, number])[];
-}
-
-function objectValue(value: unknown, label: string): Record<string, unknown> {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new CanonicalRecordedLabSpatialContractError(`${label}: ожидался объект.`);
-  }
-  return value as Record<string, unknown>;
-}
-
-function arrayValue(value: unknown, label: string): unknown[] {
-  if (!Array.isArray(value)) {
-    throw new CanonicalRecordedLabSpatialContractError(`${label}: ожидался массив.`);
-  }
-  return value;
-}
-
-function exact(value: unknown, expected: unknown, label: string): void {
-  if (value !== expected) {
-    throw new CanonicalRecordedLabSpatialContractError(`${label}: контракт изменён.`);
-  }
-}
-
-function numberValue(value: unknown, label: string): number {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new CanonicalRecordedLabSpatialContractError(`${label}: ожидалось число.`);
-  }
-  return value;
-}
-
-function integerValue(value: unknown, label: string): number {
-  const parsed = numberValue(value, label);
-  if (!Number.isSafeInteger(parsed) || parsed < 0) {
-    throw new CanonicalRecordedLabSpatialContractError(`${label}: ожидалось целое значение.`);
-  }
-  return parsed;
-}
-
-function pointList(
-  value: unknown,
-  label: string,
-): readonly (readonly [number, number, number])[] {
-  return arrayValue(value, label).map((entry, index) => {
-    const point = arrayValue(entry, `${label}[${index}]`).map(
-      (channel, channelIndex) => numberValue(channel, `${label}[${index}][${channelIndex}]`),
-    );
-    if (point.length !== 3) {
-      throw new CanonicalRecordedLabSpatialContractError(`${label}[${index}]: размер изменён.`);
-    }
-    return [point[0]!, point[1]!, point[2]!] as const;
-  });
-}
-
-export async function fetchCanonicalRecordedLabSpatialFrame(
-  sessionId: string,
-  generationSha256: string,
-  targetTimeNs: number,
-  {
-    fetcher = fetch,
-    signal,
-  }: { fetcher?: LaboratoryFetch; signal?: AbortSignal } = {},
-): Promise<CanonicalRecordedLabSpatialFrame> {
-  if (
-    !SAFE_SESSION_ID.test(sessionId)
-    || !SHA256.test(generationSha256)
-    || !Number.isSafeInteger(targetTimeNs)
-    || targetTimeNs < 0
-  ) {
-    throw new CanonicalRecordedLabSpatialContractError(
-      "Canonical LAB spatial identity недопустима.",
-    );
-  }
-  const query = new URLSearchParams({
-    generation: generationSha256,
-    time_ns: String(targetTimeNs),
-    profile: CANONICAL_RECORDED_LAB_SPATIAL_PROFILE,
-  });
-  const response = await fetcher(
-    `/api/v1/observation-sessions/${encodeURIComponent(sessionId)}`
-      + `/canonical-lab/spatial-frame?${query.toString()}`,
-    { method: "GET", headers: { Accept: "application/json" }, signal },
-  );
-  if (!response.ok) {
-    throw new CanonicalRecordedLabSpatialContractError(
-      `Canonical LAB spatial frame недоступен: HTTP ${response.status}.`,
-    );
-  }
-  const payload = objectValue(await response.json(), "canonical_lab.spatial_frame");
-  exact(
-    payload.schema_version,
-    "missioncore.canonical-recorded-lab-spatial-frame/v3",
-    "canonical_lab.spatial_frame.schema_version",
-  );
-  exact(payload.coordinate_frame, "body-ground", "canonical_lab.spatial_frame.coordinate_frame");
-  exact(payload.target_time_ns, targetTimeNs, "canonical_lab.spatial_frame.target_time_ns");
-  const sourcePoints = pointList(
-    payload.source_points_body_xyz_m,
-    "canonical_lab.spatial_frame.source_points",
-  );
-  const localSlam = pointList(
-    payload.local_slam_body_xyz_m,
-    "canonical_lab.spatial_frame.local_slam",
-  );
-  const sourcePointCount = integerValue(
-    payload.source_point_count,
-    "canonical_lab.spatial_frame.source_point_count",
-  );
-  const localSlamPointCount = integerValue(
-    payload.local_slam_point_count,
-    "canonical_lab.spatial_frame.local_slam_point_count",
-  );
-  if (
-    sourcePointCount !== sourcePoints.length
-    || sourcePointCount > 100_000
-    || localSlamPointCount !== localSlam.length
-    || localSlam.length > 27_000
-  ) {
-    throw new CanonicalRecordedLabSpatialContractError(
-      "Canonical LAB spatial accounting изменён.",
-    );
-  }
-  const bodyFrame = objectValue(payload.body_frame, "canonical_lab.spatial_frame.body_frame");
-  const origin = pointList(
-    [bodyFrame.origin_map_xyz_m],
-    "canonical_lab.spatial_frame.body_frame.origin",
-  )[0]!;
-  const sensorOrigin = pointList(
-    [bodyFrame.sensor_origin_map_xyz_m],
-    "canonical_lab.spatial_frame.body_frame.sensor_origin",
-  )[0]!;
-  const basisRows = pointList(
-    bodyFrame.basis_map_from_body,
-    "canonical_lab.spatial_frame.body_frame.basis",
-  );
-  if (basisRows.length !== 3) {
-    throw new CanonicalRecordedLabSpatialContractError(
-      "Canonical LAB spatial basis изменён.",
-    );
-  }
-  const sensorHeight = objectValue(payload.sensor_height, "canonical_lab.spatial_frame.sensor_height");
-  if (
-    sensorHeight.source !== "local-source-cloud-ground-quantile-median"
-    && sensorHeight.source !== "session-source-cloud-fallback"
-  ) {
-    throw new CanonicalRecordedLabSpatialContractError(
-      "canonical_lab.spatial_frame.sensor_height.source: контракт изменён.",
-    );
-  }
-  exact(
-    sensorHeight.authority,
-    "visual-derived",
-    "canonical_lab.spatial_frame.sensor_height.authority",
-  );
-  const spatialProfile = objectValue(
-    payload.spatial_profile,
-    "canonical_lab.spatial_frame.spatial_profile",
-  );
-  exact(
-    spatialProfile.profile_id,
-    CANONICAL_RECORDED_LAB_SPATIAL_PROFILE,
-    "canonical_lab.spatial_frame.spatial_profile.profile_id",
-  );
-  return {
-    targetTimeNs,
-    sourceTimeNs: integerValue(payload.source_time_ns, "canonical_lab.spatial_frame.source_time_ns"),
-    poseTimeNs: integerValue(payload.pose_time_ns, "canonical_lab.spatial_frame.pose_time_ns"),
-    trajectoryTimeNs: integerValue(
-      payload.trajectory_time_ns,
-      "canonical_lab.spatial_frame.trajectory_time_ns",
-    ),
-    sourcePointCount,
-    coordinateFrame: "body-ground",
-    sensorHeight: {
-      meters: numberValue(sensorHeight.meters, "canonical_lab.spatial_frame.sensor_height.meters"),
-      source: sensorHeight.source,
-      sampleCount: integerValue(
-        sensorHeight.sample_count,
-        "canonical_lab.spatial_frame.sensor_height.sample_count",
-      ),
-      madM: numberValue(sensorHeight.mad_m, "canonical_lab.spatial_frame.sensor_height.mad_m"),
-      authority: "visual-derived",
-    },
-    spatialProfile: {
-      profileId: CANONICAL_RECORDED_LAB_SPATIAL_PROFILE,
-      localSlamHistorySeconds: numberValue(
-        spatialProfile.local_slam_history_seconds,
-        "canonical_lab.spatial_frame.spatial_profile.history",
-      ),
-      localSlamRadiusM: numberValue(
-        spatialProfile.local_slam_radius_m,
-        "canonical_lab.spatial_frame.spatial_profile.radius",
-      ),
-      localSlamVoxelSizeM: numberValue(
-        spatialProfile.local_slam_voxel_size_m,
-        "canonical_lab.spatial_frame.spatial_profile.voxel",
-      ),
-      localSlamPointLimit: integerValue(
-        spatialProfile.local_slam_point_limit,
-        "canonical_lab.spatial_frame.spatial_profile.limit",
-      ),
-    },
-    bodyFrame: {
-      originMapXyzM: origin,
-      sensorOriginMapXyzM: sensorOrigin,
-      basisMapFromBody: [basisRows[0]!, basisRows[1]!, basisRows[2]!],
-    },
-    sourcePointsBodyXyzM: sourcePoints,
-    localSlamSourceFrameCount: integerValue(
-      payload.local_slam_source_frame_count,
-      "canonical_lab.spatial_frame.local_slam_source_frames",
-    ),
-    localSlamSourcePointCount: integerValue(
-      payload.local_slam_source_point_count,
-      "canonical_lab.spatial_frame.local_slam_source_points",
-    ),
-    localSlamBodyXyzM: localSlam,
-  };
-}
@@ -154,9 +154,6 @@ export interface M4ThreatTimelineFrame {
  pointCloudSourceCount: number;
  pointCloudSampleCount: number;
  pointCloudLayer: "current-increment";
-  localSlamBodyXyzM?: readonly M4Point3[];
-  localSlamSourceFrameCount?: number;
-  localSlamSourcePointCount?: number;
  cameraProjectedPointsXyd: readonly (readonly [number, number, number])[];
  cameraProjectedSourceCount: number;
  cameraProjectedPointCount: number;
@@ -171,11 +168,10 @@ export interface M4ThreatTimelineFrame {

 export interface M4ThreatTimeline {
  resultId: string;
-  recordedSourceSessionId: string;
-  recordedSourceId: string;
+  recordedSourceSessionId: "20260720T065719Z_viewer_live";
  imageWidth: 800;
  imageHeight: 600;
-  frameCount: number;
+  frameCount: 4489;
  frameTimesNs: readonly number[];
  timelineStartSeconds: number;
  timelineEndSeconds: number;
@@ -238,7 +234,7 @@ export interface M4ThreatPlaybackProgress {

 export interface M4ThreatPlaybackPointPack {
  resultId: string;
-  frameCount: number;
+  frameCount: 4489;
  pointCount: number;
  pointOffsets: Uint32Array;
  pointsMapXyzM: Float32Array;
@@ -261,7 +257,7 @@ export interface M4ThreatPlaybackChunkDescriptor {

 export interface M4ThreatPlaybackManifest {
  resultId: string;
-  frameCount: number;
+  frameCount: 4489;
  pointCount: number;
  pointOffsets: Uint32Array;
  chunkFrameCount: 24;
@@ -341,7 +337,7 @@ const motion = (value: unknown): M4ThreatMotion => {
 };
 const resultId = (value: unknown): string => {
  const parsed = text(value, "M4.6 result id");
-  if (!/^[a-z0-9][a-z0-9-]{0,127}-[a-f0-9]{64}$/.test(parsed)) {
+  if (!/^m4-threat-replay-[a-f0-9]{64}$/.test(parsed)) {
    throw new M4ThreatContractError("M4.6 result id: нарушена идентичность.");
  }
  return parsed;
@@ -708,8 +704,12 @@ export async function fetchM4ThreatTimeline(
  exact(payload.result_id, result, "M4.6 timeline result");
  exact(payload.authority, "replay-simulated", "M4.6 timeline authority");
  const recorded = object(payload.recorded_source, "M4.6 recorded source");
-  const recordedSessionId = text(recorded.session_id, "M4.6 recorded session");
-  const recordedSourceId = text(recorded.source_id, "M4.6 recorded source id");
+  exact(
+    recorded.session_id,
+    "20260720T065719Z_viewer_live",
+    "M4.6 recorded session",
+  );
+  exact(recorded.source_id, "RAVNOVES00", "M4.6 recorded source id");
  exact(
    recorded.representation_id,
    "registered-map-increment-v1",
@@ -720,10 +720,7 @@ export async function fetchM4ThreatTimeline(
    "host-arrival-best-effort",
    "M4.6 recorded synchronization",
  );
-  const frameCount = integer(payload.frame_count, "M4.6 timeline frame count");
-  if (frameCount < 1) {
-    throw new M4ThreatContractError("M4.6 timeline frame count: пустой timeline.");
-  }
+  const frameCount = exact(payload.frame_count, 4489, "M4.6 timeline frame count");
  const frameTimesNs = array(payload.frame_times_ns, "M4.6 timeline index").map(
    (value) => integer(value, "M4.6 timeline time"),
  );
@@ -741,8 +738,7 @@ export async function fetchM4ThreatTimeline(
  );
  return {
    resultId: result,
-    recordedSourceSessionId: recordedSessionId,
-    recordedSourceId,
+    recordedSourceSessionId: "20260720T065719Z_viewer_live",
    imageWidth: exact(payload.image_width, 800, "M4.6 image width"),
    imageHeight: exact(payload.image_height, 600, "M4.6 image height"),
    frameCount,
@@ -853,14 +849,12 @@ export async function fetchM4ThreatTimelineChunk(
    endpointRoot = M4_THREAT_TIMELINE_ENDPOINT_ROOT,
    cameraObstacleProjectionDelivery = null,
    playbackPointPack,
-    includePoints = true,
  }: {
    fetcher?: LaboratoryFetch;
    signal?: AbortSignal;
    endpointRoot?: string;
    cameraObstacleProjectionDelivery?: M4ThreatTimeline["cameraObstacleProjectionDelivery"];
    playbackPointPack?: M4ThreatPlaybackPointPack;
-    includePoints?: boolean;
  } = {},
 ): Promise<M4ThreatTimelineChunk> {
  const params = new URLSearchParams({
@@ -870,7 +864,7 @@ export async function fetchM4ThreatTimelineChunk(
  if (cameraObstacleProjectionDelivery !== null) {
    params.set("obstacle_projection", cameraObstacleProjectionDelivery);
  }
-  if (playbackPointPack || !includePoints) params.set("include_points", "false");
+  if (playbackPointPack) params.set("include_points", "false");
  const response = await fetcher(
    `${endpointRoot}/${result}/timeline/chunk?${params}`,
    { headers: { Accept: "application/json" }, signal },
@@ -1001,10 +995,7 @@ export async function fetchM4ThreatPlaybackManifest(
  exact(manifest.result_id, result, "M4.6 playback result");
  exact(manifest.coordinate_frame, "map", "M4.6 playback coordinate frame");
  exact(manifest.access, "read-only-sealed-binary-playback", "M4.6 playback access");
-  const frameCount = integer(manifest.frame_count, "M4.6 playback frames");
-  if (frameCount < 1) {
-    throw new M4ThreatContractError("M4.6 playback frames: пустой playback недопустим.");
-  }
+  const frameCount = exact(integer(manifest.frame_count, "M4.6 playback frames"), 4489, "M4.6 playback frames");
  const pointCount = integer(manifest.point_count, "M4.6 playback points");
  const offsetsRaw = array(manifest.point_offsets, "M4.6 playback offsets");
  if (offsetsRaw.length !== frameCount + 1) {
@@ -1341,17 +1332,6 @@ function parseTimelineFrame(
      "current-increment",
      "M4.6 timeline point layer",
    ),
-    localSlamBodyXyzM: item.local_slam_body_xyz_m === undefined
-      ? []
-      : array(item.local_slam_body_xyz_m, "M4.6 local SLAM points").map(
-          (point) => vector(point, 3, "M4.6 local SLAM point") as [number, number, number],
-        ),
-    localSlamSourceFrameCount: item.local_slam_source_frame_count === undefined
-      ? undefined
-      : integer(item.local_slam_source_frame_count, "M4.6 local SLAM source frames"),
-    localSlamSourcePointCount: item.local_slam_source_point_count === undefined
-      ? undefined
-      : integer(item.local_slam_source_point_count, "M4.6 local SLAM source points"),
    cameraProjectedPointsXyd: item.camera_projected_points_xyd === undefined
      ? []
      : array(item.camera_projected_points_xyd, "M4.6 camera points").map(
@@ -1,57 +0,0 @@
-import {
-  LABORATORY_RECORDED_EVIDENCE_VIEWER_PROFILE,
-  type LaboratoryRecordedEvidenceViewerProfile,
-} from "../observation/viewerProfile";
-
-export type LaboratoryRecordedMediaMode = "video" | "camera" | null;
-export type LaboratoryRecordedSpatialMode = "3d" | "plan" | null;
-export type LaboratoryClassifiedSpatialMode = "none" | "overlay" | "replace-source";
-
-export interface LaboratoryRecordedEvidenceVisibility {
-  mediaMode: LaboratoryRecordedMediaMode;
-  spatialMode: LaboratoryRecordedSpatialMode;
-  showMediaSemantic: boolean;
-  showSpatialSemantic: boolean;
-  showMediaPoints: boolean;
-  classifiedSpatialMode: LaboratoryClassifiedSpatialMode;
-}
-
-export interface LaboratoryRecordedEvidenceDemand {
-  sourceTimelineMetadata: true;
-  recordedVideo: boolean;
-  exactCameraFrame: boolean;
-  sourceSpatialPoints: boolean;
-  cameraPointOverlay: boolean;
-  selectedSemanticMask: boolean;
-  selectedSemanticPoints: boolean;
-  classifiedSpatial: boolean;
-}
-
-/**
- * Translate the already-visible M4 evidence composition into explicit data
- * demand. The profile never starts a hidden point, semantic or camera channel
- * merely because the selected LAB happens to publish that artifact.
- */
-export function laboratoryRecordedEvidenceDemand(
-  visibility: LaboratoryRecordedEvidenceVisibility,
-  profile: LaboratoryRecordedEvidenceViewerProfile =
-    LABORATORY_RECORDED_EVIDENCE_VIEWER_PROFILE,
-): LaboratoryRecordedEvidenceDemand {
-  if (profile.loadPolicy !== "explicit-legacy-comparison-only") {
-    throw new Error("Unsupported LAB recorded evidence load policy");
-  }
-  const mediaVisible = visibility.mediaMode !== null;
-  const spatialVisible = visibility.spatialMode !== null;
-  return {
-    sourceTimelineMetadata: true,
-    recordedVideo: visibility.mediaMode === "video",
-    exactCameraFrame: visibility.mediaMode === "camera",
-    sourceSpatialPoints:
-      spatialVisible && visibility.classifiedSpatialMode !== "replace-source",
-    cameraPointOverlay: mediaVisible && visibility.showMediaPoints,
-    selectedSemanticMask: mediaVisible && visibility.showMediaSemantic,
-    selectedSemanticPoints: spatialVisible && visibility.showSpatialSemantic,
-    classifiedSpatial:
-      spatialVisible && visibility.classifiedSpatialMode !== "none",
-  };
-}
@@ -1,7 +1,6 @@
 import type { LaboratoryFetch } from "./advancedResults";

 const RESULT_ID = /^lab-v1-vegetation-shadow-[a-f0-9]{64}$/;
-const BENCHMARK_RESULT_ID = /^lab-v1-vegetation-benchmark-[a-f0-9]{64}$/;
 const SHA256 = /^[a-f0-9]{64}$/;
 const CANDIDATES = ["ddrnet", "ppliteseg"] as const;
 const ROUTE_MODES = ["source", "ddrnet", "ppliteseg", "urban", "rural", "offroad"] as const;
@@ -56,9 +55,7 @@ export interface VegetationVideoSemanticClass {
  classId: number;
  label: string;
  colorRgb: readonly [number, number, number];
-  disposition: "labeled" | "ambiguous" | "prediction" | "undefined";
-  materialClass: string | null;
-  evidenceState: string | null;
+  disposition: "prediction" | "undefined";
 }

 export interface VegetationRouteVideo {
@@ -70,90 +67,8 @@ export interface VegetationRouteVideo {
  height: 600;
  centerCropXyxy: readonly [100, 0, 700, 600];
  outsideCropState: "undefined";
-  viewKind: "fine-semantic-prediction" | "coarse-material-policy-review";
-  linkedTgsResultId: string | null;
  taxonomy: readonly VegetationVideoSemanticClass[];
  aggregatePredictionPixels: readonly number[];
-  policyPresets: Readonly<Record<string, Readonly<Record<string, string>>>> | null;
-  fusionMode: "synchronised-multilayer-review" | null;
-  validFovMaskSha256: string | null;
-}
-
-export interface VegetationMixedRouteCase {
-  caseId: string;
-  phase: "rural" | "transition" | "urban";
-  sourceSequence: number;
-  sessionSeconds: number;
-  assets: Readonly<Record<"source" | "city" | "vegetation" | "tgs", string>>;
-  tgs: {
-    groundCells: number;
-    occupiedCells: number;
-    rejectedCells: number;
-    unobservedCells: number;
-  };
-}
-
-export interface VegetationMixedRouteReview {
-  sourceId: "RAVNOVES004TREE";
-  sessionId: string;
-  packId: string;
-  frameCount: 10;
-  models: {
-    city: { name: string; inferenceFps: number; endToEndP95Ms: number };
-    vegetation: { name: string; latencyP95Ms: number };
-    tgs: { name: string; latencyP95Ms: number; cellSizeM: number; radiusM: number };
-  };
-  cases: readonly VegetationMixedRouteCase[];
-}
-
-export interface VegetationRouteTgsAnchor {
-  sourceSequence: number;
-  slot: number;
-  currentPointsXyzM: readonly (readonly [number, number, number])[];
-  costmap: {
-    cellSizeM: 0.45;
-    centersXyM: readonly (readonly [number, number])[];
-    stateCodes: readonly number[];
-    zBoundsM: readonly (readonly [number | null, number | null])[];
-  };
-}
-
-export interface VegetationFullRouteLayer {
-  name: string;
-  resultId: string;
-  frameCount: 6830;
-  taxonomy: readonly VegetationVideoSemanticClass[];
-  inferenceFps: number;
-  latencyP95Ms: number;
-  peakReservedVramBytes: number;
-}
-
-export interface VegetationFullRouteReview {
-  sourceId: "RAVNOVES004TREE";
-  sessionId: "20260828T130511Z_viewer_live";
-  linkedRouteReviewResultId: string;
-  sourceJobId: "recorded-camera-eb2783c5480d56bda07c8af0";
-  sourceJobInputSha256: string;
-  sourceStreamSha256: string;
-  recordedMediaSourceId: "recorded.camera.6a3945242828a038";
-  recordedMediaGenerationSha256: string;
-  frameCount: 6830;
-  width: 800;
-  height: 600;
-  timelineStartSeconds: number;
-  timelineEndSeconds: number;
-  timelineArtifact: {
-    sha256: string;
-    byteLength: number;
-  };
-  frameSourceTimesNs: readonly number[];
-  decodeRepair: {
-    repairedFrameCount: 1;
-    sequence: 6092;
-    method: "duplicate-previous-decoded-frame";
-  };
-  city: VegetationFullRouteLayer;
-  vegetation: VegetationFullRouteLayer;
 }

 export interface VegetationShadowResult {
@@ -165,8 +80,6 @@ export interface VegetationShadowResult {
  routeCases: readonly VegetationVisualCase[];
  validationCases: readonly VegetationVisualCase[];
  routeVideo: VegetationRouteVideo | null;
-  routeReview: VegetationMixedRouteReview | null;
-  routeFullReview: VegetationFullRouteReview | null;
  limitations: readonly string[];
  visualShadowReady: true;
  missionPolicyReadyForConfiguration: true;
@@ -273,7 +186,6 @@ function visualCaseValue(
  value: unknown,
  resultId: string,
  expectedKind: "goose" | "ravnoves",
-  endpointRoot: string,
 ): VegetationVisualCase {
  const row = objectValue(value, `vegetation.${expectedKind}.case`);
  exact(row.source_kind, expectedKind, "vegetation.case.source_kind");
@@ -292,7 +204,7 @@ function visualCaseValue(
    if (!SHA256.test(sha256) || !path.startsWith(`visual/${expectedKind}/${caseId}/`)) {
      throw new VegetationShadowContractError(`vegetation.case.assets.${key}: proof invalid.`);
    }
-    projected[key] = `${endpointRoot}/${encodeURIComponent(resultId)}/assets/${path
+    projected[key] = `/api/v1/laboratory/vegetation-shadow/${encodeURIComponent(resultId)}/assets/${path
      .split("/")
      .map(encodeURIComponent)
      .join("/")}`;
@@ -345,9 +257,6 @@ function routeVideoValue(value: unknown): VegetationRouteVideo | null {
    "vegetation.route_video.m47_reference_graph_result_id",
  );
  const baseM4ResultId = textValue(row.base_m4_result_id, "vegetation.route_video.base_m4_result_id");
-  const viewKind = row.view_kind === undefined
-    ? "fine-semantic-prediction"
-    : textValue(row.view_kind, "vegetation.route_video.view_kind");
  if (
    !/^lab-v1-ravnoves-video-ddrnet-[a-f0-9]{64}$/.test(workerResultId)
    || !/^m47-reference-graph-lab-[a-f0-9]{64}$/.test(m47ReferenceGraphResultId)
@@ -355,15 +264,6 @@ function routeVideoValue(value: unknown): VegetationRouteVideo | null {
  ) {
    throw new VegetationShadowContractError("vegetation.route_video: identity invalid.");
  }
-  if (viewKind !== "fine-semantic-prediction" && viewKind !== "coarse-material-policy-review") {
-    throw new VegetationShadowContractError("vegetation.route_video: view kind invalid.");
-  }
-  const linkedTgsResultId = viewKind === "coarse-material-policy-review"
-    ? textValue(row.linked_tgs_result_id, "vegetation.route_video.linked_tgs_result_id")
-    : null;
-  if (linkedTgsResultId && !/^m49-tgs-full-shadow-[a-f0-9]{64}$/.test(linkedTgsResultId)) {
-    throw new VegetationShadowContractError("vegetation.route_video: TGS identity invalid.");
-  }
  exact(row.frame_count, 4489, "vegetation.route_video.frame_count");
  exact(row.width, 800, "vegetation.route_video.width");
  exact(row.height, 600, "vegetation.route_video.height");
@@ -379,9 +279,11 @@ function routeVideoValue(value: unknown): VegetationRouteVideo | null {
    throw new VegetationShadowContractError("vegetation.route_video: crop contract changed.");
  }
  const taxonomy = objectValue(row.taxonomy, "vegetation.route_video.taxonomy");
-  exact(taxonomy.schema_version, viewKind === "coarse-material-policy-review"
-    ? "missioncore.lab-v1-terrain-policy-taxonomy/v1"
-    : "missioncore.lab-v1-vegetation-taxonomy/v1", "vegetation.route_video.taxonomy.schema");
+  exact(
+    taxonomy.schema_version,
+    "missioncore.lab-v1-vegetation-taxonomy/v1",
+    "vegetation.route_video.taxonomy.schema",
+  );
  const classes = arrayValue(taxonomy.classes, "vegetation.route_video.taxonomy.classes")
    .map((value, expectedId): VegetationVideoSemanticClass => {
      const item = objectValue(value, `vegetation.route_video.taxonomy[${expectedId}]`);
@@ -394,95 +296,36 @@ function routeVideoValue(value: unknown): VegetationRouteVideo | null {
      if (color.length !== 3 || color.some((channel) => channel > 255)) {
        throw new VegetationShadowContractError("vegetation.route_video: taxonomy color invalid.");
      }
-      const disposition = item.disposition;
-      if (
-        disposition !== "labeled"
-        && disposition !== "ambiguous"
-        && disposition !== "prediction"
-        && disposition !== "undefined"
-      ) {
+      const disposition: VegetationVideoSemanticClass["disposition"] = expectedId === 0
+        ? "undefined"
+        : "prediction";
+      if (item.disposition !== disposition) {
        throw new VegetationShadowContractError("vegetation.route_video: taxonomy disposition changed.");
      }
-      if (
-        viewKind === "fine-semantic-prediction"
-        && disposition !== (expectedId === 0 ? "undefined" : "prediction")
-      ) {
-        throw new VegetationShadowContractError("vegetation.route_video: fine taxonomy disposition changed.");
-      }
-      const materialClass = item.material_class === null || item.material_class === undefined
-        ? null
-        : textValue(item.material_class, `vegetation.route_video.material[${expectedId}]`);
-      const evidenceState = item.evidence_state === null || item.evidence_state === undefined
-        ? null
-        : textValue(item.evidence_state, `vegetation.route_video.evidence[${expectedId}]`);
      return {
        classId,
        label: textValue(item.label, `vegetation.route_video.label[${expectedId}]`),
        colorRgb: color as unknown as readonly [number, number, number],
        disposition,
-        materialClass,
-        evidenceState,
      };
    });
-  const expectedClassCount = viewKind === "coarse-material-policy-review" ? 10 : 64;
-  if (classes.length !== expectedClassCount) {
-    throw new VegetationShadowContractError("vegetation.route_video: taxonomy size changed.");
-  }
-  if (
-    viewKind === "coarse-material-policy-review"
-    && (classes[9]?.disposition !== "undefined" || classes[9]?.evidenceState !== "UNOBSERVED")
-  ) {
-    throw new VegetationShadowContractError("vegetation.route_video: valid-FOV class changed.");
+  if (classes.length !== 64) {
+    throw new VegetationShadowContractError("vegetation.route_video: taxonomy must contain 64 classes.");
  }
  const aggregatePredictionPixels = arrayValue(
    row.aggregate_prediction_pixels,
    "vegetation.route_video.aggregate_prediction_pixels",
  ).map((value, index) => integerValue(value, `vegetation.route_video.pixels[${index}]`));
-  if (aggregatePredictionPixels.length !== expectedClassCount) {
+  if (aggregatePredictionPixels.length !== 64) {
    throw new VegetationShadowContractError("vegetation.route_video: class accounting changed.");
  }
  const maskArchive = objectValue(row.mask_archive, "vegetation.route_video.mask_archive");
-  exact(maskArchive.path, viewKind === "coarse-material-policy-review"
-    ? "video/coarse-material-policy-masks.zip"
-    : "video/ddrnet-semantic-masks.zip", "vegetation.route_video.mask_archive.path");
+  exact(maskArchive.path, "video/ddrnet-semantic-masks.zip", "vegetation.route_video.mask_archive.path");
  const archiveSha256 = textValue(maskArchive.sha256, "vegetation.route_video.mask_archive.sha256");
  if (!SHA256.test(archiveSha256)) {
    throw new VegetationShadowContractError("vegetation.route_video: archive digest invalid.");
  }
  integerValue(maskArchive.byte_length, "vegetation.route_video.mask_archive.byte_length");
-  let policyPresets: VegetationRouteVideo["policyPresets"] = null;
-  let fusionMode: VegetationRouteVideo["fusionMode"] = null;
-  let validFovMaskSha256: string | null = null;
-  if (viewKind === "coarse-material-policy-review") {
-    const validFov = objectValue(row.valid_fov, "vegetation.route_video.valid_fov");
-    exact(validFov.mask_path, "video/valid-fov-mask.png", "vegetation.route_video.valid_fov.path");
-    validFovMaskSha256 = textValue(
-      validFov.mask_sha256,
-      "vegetation.route_video.valid_fov.sha256",
-    );
-    if (!SHA256.test(validFovMaskSha256)) {
-      throw new VegetationShadowContractError("vegetation.route_video: valid-FOV digest invalid.");
-    }
-    exact(validFov.outside_valid_fov_class_id, 9, "vegetation.route_video.valid_fov.class_id");
-    const policy = objectValue(row.policy, "vegetation.route_video.policy");
-    const presets = objectValue(policy.presets, "vegetation.route_video.policy.presets");
-    policyPresets = Object.fromEntries(Object.entries(presets).map(([presetId, rawRules]) => {
-      const rules = objectValue(rawRules, `vegetation.route_video.policy.${presetId}`);
-      return [presetId, Object.fromEntries(Object.entries(rules).map(([material, action]) => [
-        material,
-        textValue(action, `vegetation.route_video.policy.${presetId}.${material}`),
-      ]))];
-    }));
-    const fusion = objectValue(row.fusion, "vegetation.route_video.fusion");
-    exact(fusion.pixel_raster_fusion, false, "vegetation.route_video.fusion.pixel_raster_fusion");
-    exact(fusion.camera_semantic_temporal_filter, "none", "vegetation.route_video.fusion.camera_filter");
-    exact(
-      fusion.mode,
-      "synchronised-multilayer-review",
-      "vegetation.route_video.fusion.mode",
-    );
-    fusionMode = "synchronised-multilayer-review";
-  }
  return {
    workerResultId,
    m47ReferenceGraphResultId,
@@ -492,374 +335,12 @@ function routeVideoValue(value: unknown): VegetationRouteVideo | null {
    height: 600,
    centerCropXyxy: [100, 0, 700, 600],
    outsideCropState: "undefined",
-    viewKind,
-    linkedTgsResultId,
    taxonomy: classes,
    aggregatePredictionPixels,
-    policyPresets,
-    fusionMode,
-    validFovMaskSha256,
  };
 }

-function mixedRouteReviewValue(
-  value: unknown,
-  resultId: string,
-  endpointRoot: string,
-): VegetationMixedRouteReview | null {
-  if (value === null || value === undefined) return null;
-  const row = objectValue(value, "vegetation.route_review");
-  exact(row.source_id, "RAVNOVES004TREE", "vegetation.route_review.source_id");
-  exact(row.frame_count, 10, "vegetation.route_review.frame_count");
-  exact(row.ground_truth, false, "vegetation.route_review.ground_truth");
-  exact(
-    row.selection_policy,
-    "same-scene-camera-lidar-aligned-review-islands/v1",
-    "vegetation.route_review.selection_policy",
-  );
-  const packId = textValue(row.pack_id, "vegetation.route_review.pack_id");
-  if (!/^mixed-route-review-pack-[a-f0-9]{64}$/.test(packId)) {
-    throw new VegetationShadowContractError("vegetation.route_review.pack_id: identity invalid.");
-  }
-  const models = objectValue(row.models, "vegetation.route_review.models");
-  const city = objectValue(models.city, "vegetation.route_review.models.city");
-  const vegetation = objectValue(models.vegetation, "vegetation.route_review.models.vegetation");
-  const tgsModel = objectValue(models.tgs, "vegetation.route_review.models.tgs");
-  exact(city.frames, 10, "vegetation.route_review.models.city.frames");
-  exact(vegetation.frames, 10, "vegetation.route_review.models.vegetation.frames");
-  exact(tgsModel.frames, 10, "vegetation.route_review.models.tgs.frames");
-  const cases = arrayValue(row.cases, "vegetation.route_review.cases").map((raw, index) => {
-    const item = objectValue(raw, `vegetation.route_review.cases[${index}]`);
-    const caseId = textValue(item.case_id, `vegetation.route_review.cases[${index}].case_id`);
-    if (caseId !== `route-${String(index + 1).padStart(2, "0")}`) {
-      throw new VegetationShadowContractError("vegetation.route_review.case order changed.");
-    }
-    const phaseValue = item.phase;
-    if (phaseValue !== "rural" && phaseValue !== "transition" && phaseValue !== "urban") {
-      throw new VegetationShadowContractError("vegetation.route_review.phase changed.");
-    }
-    const phase: VegetationMixedRouteCase["phase"] = phaseValue;
-    const assets = objectValue(item.assets, `vegetation.route_review.cases[${index}].assets`);
-    const projected = Object.fromEntries(["source", "city", "vegetation", "tgs"].map((key) => {
-      const descriptor = objectValue(assets[key], `vegetation.route_review.assets.${key}`);
-      const path = textValue(descriptor.path, `vegetation.route_review.assets.${key}.path`);
-      const digest = textValue(descriptor.sha256, `vegetation.route_review.assets.${key}.sha256`);
-      if (!SHA256.test(digest) || !path.startsWith(`route-review/${caseId}/`)) {
-        throw new VegetationShadowContractError(`vegetation.route_review.assets.${key}: proof invalid.`);
-      }
-      return [key, `${endpointRoot}/${encodeURIComponent(resultId)}/assets/${path
-        .split("/").map(encodeURIComponent).join("/")}`];
-    })) as Record<"source" | "city" | "vegetation" | "tgs", string>;
-    const tgs = objectValue(item.tgs, `vegetation.route_review.cases[${index}].tgs`);
-    const groundCells = integerValue(tgs.ground_cells, "vegetation.route_review.tgs.ground");
-    const occupiedCells = integerValue(tgs.occupied_cells, "vegetation.route_review.tgs.occupied");
-    const rejectedCells = integerValue(tgs.rejected_cells, "vegetation.route_review.tgs.rejected");
-    const unobservedCells = integerValue(tgs.unobserved_cells, "vegetation.route_review.tgs.unobserved");
-    if (groundCells + occupiedCells + rejectedCells + unobservedCells !== 2244) {
-      throw new VegetationShadowContractError("vegetation.route_review.tgs cell accounting changed.");
-    }
-    return {
-      caseId,
-      phase,
-      sourceSequence: integerValue(item.source_sequence, "vegetation.route_review.source_sequence"),
-      sessionSeconds: numberValue(item.session_seconds, "vegetation.route_review.session_seconds"),
-      assets: projected,
-      tgs: { groundCells, occupiedCells, rejectedCells, unobservedCells },
-    };
-  });
-  if (cases.length !== 10) {
-    throw new VegetationShadowContractError("vegetation.route_review.cases: expected 10 aligned islands.");
-  }
-  return {
-    sourceId: "RAVNOVES004TREE",
-    sessionId: textValue(row.session_id, "vegetation.route_review.session_id"),
-    packId,
-    frameCount: 10,
-    models: {
-      city: {
-        name: textValue(city.name, "vegetation.route_review.models.city.name"),
-        inferenceFps: numberValue(city.inference_fps, "vegetation.route_review.models.city.fps"),
-        endToEndP95Ms: numberValue(city.end_to_end_p95_ms, "vegetation.route_review.models.city.p95"),
-      },
-      vegetation: {
-        name: textValue(vegetation.name, "vegetation.route_review.models.vegetation.name"),
-        latencyP95Ms: numberValue(vegetation.latency_p95_ms, "vegetation.route_review.models.vegetation.p95"),
-      },
-      tgs: {
-        name: textValue(tgsModel.name, "vegetation.route_review.models.tgs.name"),
-        latencyP95Ms: numberValue(tgsModel.latency_p95_ms, "vegetation.route_review.models.tgs.p95"),
-        cellSizeM: numberValue(tgsModel.cell_size_m, "vegetation.route_review.models.tgs.cell"),
-        radiusM: numberValue(tgsModel.radius_m, "vegetation.route_review.models.tgs.radius"),
-      },
-    },
-    cases,
-  };
-}
-
-function fullRouteTaxonomyValue(
-  value: unknown,
-  label: string,
-  schema: string,
-  classCount: number,
-): readonly VegetationVideoSemanticClass[] {
-  const taxonomy = objectValue(value, `${label}.taxonomy`);
-  exact(taxonomy.schema_version, schema, `${label}.taxonomy.schema`);
-  const classes = arrayValue(taxonomy.classes, `${label}.taxonomy.classes`).map(
-    (raw, expectedId): VegetationVideoSemanticClass => {
-      const item = objectValue(raw, `${label}.taxonomy[${expectedId}]`);
-      const classId = integerValue(item.class_id, `${label}.class_id[${expectedId}]`);
-      if (classId !== expectedId) {
-        throw new VegetationShadowContractError(`${label}: taxonomy order changed.`);
-      }
-      const color = arrayValue(item.color_rgb, `${label}.color[${expectedId}]`)
-        .map((channel, index) => integerValue(channel, `${label}.color[${expectedId}][${index}]`));
-      if (color.length !== 3 || color.some((channel) => channel > 255)) {
-        throw new VegetationShadowContractError(`${label}: taxonomy color invalid.`);
-      }
-      const disposition = item.disposition;
-      if (
-        disposition !== "labeled"
-        && disposition !== "ambiguous"
-        && disposition !== "prediction"
-        && disposition !== "undefined"
-      ) {
-        throw new VegetationShadowContractError(`${label}: taxonomy disposition changed.`);
-      }
-      return {
-        classId,
-        label: textValue(item.label, `${label}.label[${expectedId}]`),
-        colorRgb: color as unknown as readonly [number, number, number],
-        disposition,
-        materialClass: item.material_class === null || item.material_class === undefined
-          ? null
-          : textValue(item.material_class, `${label}.material[${expectedId}]`),
-        evidenceState: item.evidence_state === null || item.evidence_state === undefined
-          ? null
-          : textValue(item.evidence_state, `${label}.evidence[${expectedId}]`),
-      };
-    },
-  );
-  if (classes.length !== classCount) {
-    throw new VegetationShadowContractError(`${label}: taxonomy size changed.`);
-  }
-  return classes;
-}
-
-function fullRouteLayerValue(
-  value: unknown,
-  layer: "city" | "vegetation",
-): VegetationFullRouteLayer {
-  const label = `vegetation.route_full_review.layers.${layer}`;
-  const row = objectValue(value, label);
-  const resultId = textValue(row.result_id, `${label}.result_id`);
-  const identity = layer === "city"
-    ? /^result-[a-f0-9]{64}$/
-    : /^lab-v1-ravnoves-video-ddrnet-[a-f0-9]{64}$/;
-  if (!identity.test(resultId)) {
-    throw new VegetationShadowContractError(`${label}: identity invalid.`);
-  }
-  exact(row.frame_count, 6830, `${label}.frame_count`);
-  const archive = objectValue(row.mask_archive, `${label}.mask_archive`);
-  exact(
-    archive.path,
-    layer === "city" ? "video/eomt-semantic-masks.zip" : "video/ddrnet-semantic-masks.zip",
-    `${label}.mask_archive.path`,
-  );
-  const digest = textValue(archive.sha256, `${label}.mask_archive.sha256`);
-  if (!SHA256.test(digest)) {
-    throw new VegetationShadowContractError(`${label}: archive digest invalid.`);
-  }
-  integerValue(archive.byte_length, `${label}.mask_archive.byte_length`);
-  return {
-    name: textValue(row.name, `${label}.name`),
-    resultId,
-    frameCount: 6830,
-    taxonomy: fullRouteTaxonomyValue(
-      row.taxonomy,
-      label,
-      layer === "city"
-        ? "missioncore.recorded-eomt-taxonomy/v1"
-        : "missioncore.lab-v1-vegetation-taxonomy/v1",
-      layer === "city" ? 16 : 64,
-    ),
-    inferenceFps: numberValue(row.inference_fps, `${label}.inference_fps`),
-    latencyP95Ms: numberValue(row.latency_p95_ms, `${label}.latency_p95_ms`),
-    peakReservedVramBytes: integerValue(
-      row.peak_reserved_vram_bytes,
-      `${label}.peak_reserved_vram_bytes`,
-    ),
-  };
-}
-
-function fullRouteReviewValue(value: unknown): VegetationFullRouteReview | null {
-  if (value === null || value === undefined) return null;
-  const row = objectValue(value, "vegetation.route_full_review");
-  exact(row.source_id, "RAVNOVES004TREE", "vegetation.route_full_review.source_id");
-  exact(
-    row.session_id,
-    "20260828T130511Z_viewer_live",
-    "vegetation.route_full_review.session_id",
-  );
-  exact(
-    row.source_job_id,
-    "recorded-camera-eb2783c5480d56bda07c8af0",
-    "vegetation.route_full_review.source_job_id",
-  );
-  const linkedRouteReviewResultId = textValue(
-    row.linked_route_review_result_id,
-    "vegetation.route_full_review.linked_route_review_result_id",
-  );
-  if (!RESULT_ID.test(linkedRouteReviewResultId)) {
-    throw new VegetationShadowContractError(
-      "vegetation.route_full_review: linked route review identity invalid.",
-    );
-  }
-  exact(row.frame_count, 6830, "vegetation.route_full_review.frame_count");
-  exact(row.width, 800, "vegetation.route_full_review.width");
-  exact(row.height, 600, "vegetation.route_full_review.height");
-  exact(row.ground_truth, false, "vegetation.route_full_review.ground_truth");
-  const sourceJobInputSha256 = textValue(
-    row.source_job_input_sha256,
-    "vegetation.route_full_review.source_job_input_sha256",
-  );
-  const sourceStreamSha256 = textValue(
-    row.source_stream_sha256,
-    "vegetation.route_full_review.source_stream_sha256",
-  );
-  exact(
-    sourceJobInputSha256,
-    "eb2783c5480d56bda07c8af008dff5344d19dc550ef70fe2075d6f098f7cc715",
-    "vegetation.route_full_review.source_job_input_sha256",
-  );
-  exact(
-    sourceStreamSha256,
-    "e5eb017e2cc0f546736eda5235ca157b501913093cb64af5e548e335417e1bac",
-    "vegetation.route_full_review.source_stream_sha256",
-  );
-  exact(
-    row.recorded_media_source_id,
-    "recorded.camera.6a3945242828a038",
-    "vegetation.route_full_review.recorded_media_source_id",
-  );
-  const recordedMediaGenerationSha256 = textValue(
-    row.recorded_media_generation_sha256,
-    "vegetation.route_full_review.recorded_media_generation_sha256",
-  );
-  exact(
-    recordedMediaGenerationSha256,
-    "b073ea1e7babf1c77a664e1a5b95e3702d0e05b0e34c1e85a7c67a6f8b392ded",
-    "vegetation.route_full_review.recorded_media_generation_sha256",
-  );
-  if (
-    !SHA256.test(sourceJobInputSha256)
-    || !SHA256.test(sourceStreamSha256)
-    || !SHA256.test(recordedMediaGenerationSha256)
-  ) {
-    throw new VegetationShadowContractError("vegetation.route_full_review: source digest invalid.");
-  }
-  const timelineStartSeconds = numberValue(
-    row.timeline_start_seconds,
-    "vegetation.route_full_review.timeline_start_seconds",
-  );
-  const timelineEndSeconds = numberValue(
-    row.timeline_end_seconds,
-    "vegetation.route_full_review.timeline_end_seconds",
-  );
-  if (timelineEndSeconds <= timelineStartSeconds) {
-    throw new VegetationShadowContractError("vegetation.route_full_review: timeline invalid.");
-  }
-  const timeline = objectValue(row.timeline, "vegetation.route_full_review.timeline");
-  exact(
-    timeline.path,
-    "video/frame-source-times-ns.bin",
-    "vegetation.route_full_review.timeline.path",
-  );
-  exact(
-    timeline.encoding,
-    "uint64-le-nanoseconds",
-    "vegetation.route_full_review.timeline.encoding",
-  );
-  exact(timeline.frame_count, 6830, "vegetation.route_full_review.timeline.frame_count");
-  const timelineSha256 = textValue(
-    timeline.sha256,
-    "vegetation.route_full_review.timeline.sha256",
-  );
-  if (!SHA256.test(timelineSha256)) {
-    throw new VegetationShadowContractError("vegetation.route_full_review: timeline digest invalid.");
-  }
-  const timelineByteLength = integerValue(
-    timeline.byte_length,
-    "vegetation.route_full_review.timeline.byte_length",
-  );
-  exact(timelineByteLength, 6830 * 8, "vegetation.route_full_review.timeline.byte_length");
-  const decodeRepair = objectValue(
-    row.decode_repair,
-    "vegetation.route_full_review.decode_repair",
-  );
-  exact(decodeRepair.repaired_frame_count, 1, "vegetation.route_full_review.decode_repair.count");
-  exact(decodeRepair.sequence, 6092, "vegetation.route_full_review.decode_repair.sequence");
-  exact(
-    decodeRepair.method,
-    "duplicate-previous-decoded-frame",
-    "vegetation.route_full_review.decode_repair.method",
-  );
-  const repairProofs = objectValue(
-    decodeRepair.proofs,
-    "vegetation.route_full_review.decode_repair.proofs",
-  );
-  for (const [key, expectedPath] of Object.entries({
-    eomt: "proofs/decode_repair.json",
-    ddrnet: "proofs/ddrnet_decode_repair.json",
-  })) {
-    const proof = objectValue(
-      repairProofs[key],
-      `vegetation.route_full_review.decode_repair.proofs.${key}`,
-    );
-    exact(
-      proof.path,
-      expectedPath,
-      `vegetation.route_full_review.decode_repair.proofs.${key}.path`,
-    );
-    const digest = textValue(
-      proof.sha256,
-      `vegetation.route_full_review.decode_repair.proofs.${key}.sha256`,
-    );
-    if (!SHA256.test(digest)) {
-      throw new VegetationShadowContractError("vegetation.route_full_review: repair proof invalid.");
-    }
-  }
-  const layers = objectValue(row.layers, "vegetation.route_full_review.layers");
-  return {
-    sourceId: "RAVNOVES004TREE",
-    sessionId: "20260828T130511Z_viewer_live",
-    linkedRouteReviewResultId,
-    sourceJobId: "recorded-camera-eb2783c5480d56bda07c8af0",
-    sourceJobInputSha256,
-    sourceStreamSha256,
-    recordedMediaSourceId: "recorded.camera.6a3945242828a038",
-    recordedMediaGenerationSha256,
-    frameCount: 6830,
-    width: 800,
-    height: 600,
-    timelineStartSeconds,
-    timelineEndSeconds,
-    timelineArtifact: { sha256: timelineSha256, byteLength: timelineByteLength },
-    frameSourceTimesNs: [],
-    decodeRepair: {
-      repairedFrameCount: 1,
-      sequence: 6092,
-      method: "duplicate-previous-decoded-frame",
-    },
-    city: fullRouteLayerValue(layers.city, "city"),
-    vegetation: fullRouteLayerValue(layers.vegetation, "vegetation"),
-  };
-}
-
-function parseResult(
-  value: unknown,
-  resultId: string,
-  endpointRoot: string,
-): VegetationShadowResult {
+function parseResult(value: unknown, resultId: string): VegetationShadowResult {
  const payload = objectValue(value, "Vegetation LAB");
  exact(payload.schema_version, "missioncore.lab-v1-vegetation-shadow/v1", "vegetation.schema");
  exact(payload.result_id, resultId, "vegetation.result_id");
@@ -895,15 +376,10 @@ function parseResult(
    "vegetation.authority.camera_semantics_can_clear_rigid_geometry",
  );
  const routeCases = arrayValue(catalogs.ravnoves, "vegetation.catalogs.ravnoves")
-    .map((item) => visualCaseValue(item, resultId, "ravnoves", endpointRoot));
+    .map((item) => visualCaseValue(item, resultId, "ravnoves"));
  const validationCases = arrayValue(catalogs.goose, "vegetation.catalogs.goose")
-    .map((item) => visualCaseValue(item, resultId, "goose", endpointRoot));
-  const routeReview = mixedRouteReviewValue(payload.route_review, resultId, endpointRoot);
-  const routeFullReview = fullRouteReviewValue(payload.route_full_review);
-  if (
-    routeCases.length !== 0
-    || (routeReview || routeFullReview ? validationCases.length !== 0 : validationCases.length !== 12)
-  ) {
+    .map((item) => visualCaseValue(item, resultId, "goose"));
+  if (routeCases.length !== 0 || validationCases.length !== 12) {
    throw new VegetationShadowContractError("vegetation.catalogs: ожидалось 12 truth-backed GOOSE случаев без route viewer.");
  }
  return {
@@ -915,8 +391,6 @@ function parseResult(
    routeCases,
    validationCases,
    routeVideo: routeVideoValue(payload.route_video),
-    routeReview,
-    routeFullReview,
    limitations: arrayValue(payload.limitations, "vegetation.limitations")
      .map((item, index) => textValue(item, `vegetation.limitations[${index}]`)),
    visualShadowReady: true,
@@ -937,96 +411,7 @@ export function vegetationVideoMaskUrl(resultId: string, sequence: number): stri
  return `/api/v1/laboratory/vegetation-shadow/${encodeURIComponent(resultId)}/masks/${sequence}`;
 }

-export function vegetationFullRouteMaskUrl(
-  resultId: string,
-  layer: "city" | "vegetation",
-  sequence: number,
-): string {
-  if (
-    !RESULT_ID.test(resultId)
-    || (layer !== "city" && layer !== "vegetation")
-    || !Number.isInteger(sequence)
-    || sequence < 0
-    || sequence >= 6830
-  ) {
-    throw new VegetationShadowContractError("Vegetation full-route mask identity недопустима.");
-  }
-  return `/api/v1/laboratory/vegetation-shadow/${encodeURIComponent(resultId)}/route-masks/${layer}/${sequence}`;
-}
-
-export async function fetchVegetationRouteTgsAnchor(
-  resultId: string,
-  sourceSequence: number,
-  {
-    fetcher = fetch,
-    signal,
-  }: { fetcher?: LaboratoryFetch; signal?: AbortSignal } = {},
-): Promise<VegetationRouteTgsAnchor> {
-  if (!RESULT_ID.test(resultId) || !Number.isInteger(sourceSequence) || sourceSequence < 1) {
-    throw new VegetationShadowContractError("Vegetation TGS anchor identity недопустима.");
-  }
-  const response = await fetcher(
-    `/api/v1/laboratory/vegetation-shadow/${encodeURIComponent(resultId)}`
-      + `/route-tgs-anchor/${sourceSequence}`,
-    { method: "GET", headers: { Accept: "application/json" }, signal },
-  );
-  if (!response.ok) {
-    throw new VegetationShadowContractError(`Vegetation TGS anchor недоступен: HTTP ${response.status}.`);
-  }
-  const payload = objectValue(await response.json(), "vegetation.route_tgs_anchor");
-  exact(
-    payload.schema_version,
-    "missioncore.lab-v1-route-tgs-anchor/v1",
-    "vegetation.route_tgs_anchor.schema_version",
-  );
-  exact(payload.source_sequence, sourceSequence, "vegetation.route_tgs_anchor.source_sequence");
-  const pointValue = (value: unknown, label: string): readonly number[] => {
-    const point = arrayValue(value, label).map((item, index) => numberValue(item, `${label}[${index}]`));
-    if (point.length !== 2 && point.length !== 3) {
-      throw new VegetationShadowContractError(`${label}: размер изменён.`);
-    }
-    return point;
-  };
-  const points = arrayValue(payload.current_points_xyz_m, "vegetation.route_tgs_anchor.points")
-    .map((value, index) => pointValue(value, `vegetation.route_tgs_anchor.points[${index}]`));
-  const costmap = objectValue(payload.costmap, "vegetation.route_tgs_anchor.costmap");
-  exact(costmap.cell_size_m, 0.45, "vegetation.route_tgs_anchor.costmap.cell_size_m");
-  const centers = arrayValue(costmap.centers_xy_m, "vegetation.route_tgs_anchor.costmap.centers")
-    .map((value, index) => pointValue(value, `vegetation.route_tgs_anchor.costmap.centers[${index}]`));
-  const stateCodes = arrayValue(costmap.state_codes, "vegetation.route_tgs_anchor.costmap.states")
-    .map((value, index) => integerValue(value, `vegetation.route_tgs_anchor.costmap.states[${index}]`));
-  const zBounds = arrayValue(costmap.z_bounds_m, "vegetation.route_tgs_anchor.costmap.z_bounds")
-    .map((value, index) => {
-      const row = arrayValue(value, `vegetation.route_tgs_anchor.costmap.z_bounds[${index}]`);
-      if (row.length !== 2 || row.some((item) => item !== null && (typeof item !== "number" || !Number.isFinite(item)))) {
-        throw new VegetationShadowContractError("vegetation.route_tgs_anchor.costmap.z_bounds: контракт изменён.");
-      }
-      return row as readonly [number | null, number | null];
-    });
-  if (
-    centers.length !== 2244
-    || stateCodes.length !== 2244
-    || zBounds.length !== 2244
-    || stateCodes.some((value) => value > 3)
-    || points.some((point) => point.length !== 3)
-    || centers.some((point) => point.length !== 2)
-  ) {
-    throw new VegetationShadowContractError("Vegetation TGS anchor shape изменён.");
-  }
-  return {
-    sourceSequence,
-    slot: integerValue(payload.slot, "vegetation.route_tgs_anchor.slot"),
-    currentPointsXyzM: points.map((point) => [point[0]!, point[1]!, point[2]!] as const),
-    costmap: {
-      cellSizeM: 0.45,
-      centersXyM: centers.map((point) => [point[0]!, point[1]!] as const),
-      stateCodes,
-      zBoundsM: zBounds,
-    },
-  };
-}
-
-export async function fetchVegetationShadowResultMetadata(
+export async function fetchVegetationShadowResult(
  resultId: string,
  {
    fetcher = fetch,
@@ -1043,85 +428,5 @@ export async function fetchVegetationShadowResultMetadata(
  if (!response.ok) {
    throw new VegetationShadowContractError(`Vegetation LAB недоступна: HTTP ${response.status}.`);
  }
-  const result = parseResult(
-    await response.json(),
-    resultId,
-    "/api/v1/laboratory/vegetation-shadow",
-  );
-  return result;
-}
-
-export async function fetchVegetationShadowResult(
-  resultId: string,
-  {
-    fetcher = fetch,
-    signal,
-  }: { fetcher?: LaboratoryFetch; signal?: AbortSignal } = {},
-): Promise<VegetationShadowResult> {
-  const result = await fetchVegetationShadowResultMetadata(resultId, { fetcher, signal });
-  if (!result.routeFullReview) return result;
-  const timelineResponse = await fetcher(
-    `/api/v1/laboratory/vegetation-shadow/${encodeURIComponent(resultId)}/route-timeline`,
-    { method: "GET", headers: { Accept: "application/octet-stream" }, signal },
-  );
-  if (!timelineResponse.ok) {
-    throw new VegetationShadowContractError(
-      `Vegetation LAB timeline недоступна: HTTP ${timelineResponse.status}.`,
-    );
-  }
-  if (
-    timelineResponse.headers.get("etag")
-    !== `"${result.routeFullReview.timelineArtifact.sha256}"`
-  ) {
-    throw new VegetationShadowContractError("Vegetation LAB timeline digest изменён.");
-  }
-  const timelinePayload = await timelineResponse.arrayBuffer();
-  if (timelinePayload.byteLength !== result.routeFullReview.timelineArtifact.byteLength) {
-    throw new VegetationShadowContractError("Vegetation LAB timeline size изменён.");
-  }
-  const timelineView = new DataView(timelinePayload);
-  const frameSourceTimesNs = Array.from({ length: result.routeFullReview.frameCount }, (_, index) => {
-    const value = Number(timelineView.getBigUint64(index * 8, true));
-    if (!Number.isSafeInteger(value)) {
-      throw new VegetationShadowContractError("Vegetation LAB timeline содержит unsafe time.");
-    }
-    return value;
-  });
-  if (
-    frameSourceTimesNs[0] !== Math.round(result.routeFullReview.timelineStartSeconds * 1_000_000_000)
-    || frameSourceTimesNs.some((time, index) => index > 0 && time <= frameSourceTimesNs[index - 1]!)
-  ) {
-    throw new VegetationShadowContractError("Vegetation LAB timeline нарушена.");
-  }
-  return {
-    ...result,
-    routeFullReview: { ...result.routeFullReview, frameSourceTimesNs },
-  };
-}
-
-export async function fetchVegetationBenchmarkResult(
-  resultId: string,
-  {
-    fetcher = fetch,
-    signal,
-  }: { fetcher?: LaboratoryFetch; signal?: AbortSignal } = {},
-): Promise<VegetationShadowResult> {
-  if (!BENCHMARK_RESULT_ID.test(resultId)) {
-    throw new VegetationShadowContractError("Vegetation benchmark identity недопустима.");
-  }
-  const endpointRoot = "/api/v1/laboratory/vegetation-benchmark";
-  const response = await fetcher(
-    `${endpointRoot}/${encodeURIComponent(resultId)}`,
-    { method: "GET", headers: { Accept: "application/json" }, signal },
-  );
-  if (!response.ok) {
-    throw new VegetationShadowContractError(
-      `Vegetation benchmark недоступен: HTTP ${response.status}.`,
-    );
-  }
-  const result = parseResult(await response.json(), resultId, endpointRoot);
-  if (result.routeVideo) {
-    throw new VegetationShadowContractError("Vegetation benchmark содержит route video.");
-  }
-  return result;
+  return parseResult(await response.json(), resultId);
 }
@@ -1,140 +0,0 @@
-export const OBSERVATION_LAB_CALCULATION_PROFILE_SCHEMA =
-  "missioncore.observatory-calculation-profile/v1" as const;
-
-export type ObservationLabCalculationProfileOrigin =
-  | "archived-definition"
-  | "existing-result";
-
-export interface ObservationLabCalculationProfile {
-  readonly schemaVersion: typeof OBSERVATION_LAB_CALCULATION_PROFILE_SCHEMA;
-  readonly setupId: string;
-  readonly displayName: string;
-  readonly origin: ObservationLabCalculationProfileOrigin;
-  readonly definitionId: string | null;
-  readonly definitionVersion: number | null;
-  readonly definitionSha256: string | null;
-}
-
-export class ObservationLabCalculationProfileContractError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "ObservationLabCalculationProfileContractError";
-  }
-}
-
-const PROFILE_KEYS = new Set([
-  "schema_version",
-  "setup_id",
-  "display_name",
-  "origin",
-  "definition_id",
-  "definition_version",
-  "definition_sha256",
-]);
-const IDENTIFIER = /^[a-z][a-z0-9-]{2,95}$/;
-const SHA256 = /^[a-f0-9]{64}$/;
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function requireText(value: unknown, field: string, maximum: number): string {
-  if (
-    typeof value !== "string"
-    || value.length === 0
-    || value.length > maximum
-    || value !== value.trim()
-  ) {
-    throw new ObservationLabCalculationProfileContractError(
-      `Поле calculation_profile.${field} должно быть непустой строкой.`,
-    );
-  }
-  return value;
-}
-
-function requireIdentifier(value: unknown, field: string): string {
-  const identifier = requireText(value, field, 96);
-  if (!IDENTIFIER.test(identifier)) {
-    throw new ObservationLabCalculationProfileContractError(
-      `Поле calculation_profile.${field} содержит некорректный идентификатор.`,
-    );
-  }
-  return identifier;
-}
-
-export function decodeObservationLabCalculationProfile(
-  value: unknown,
-  sessionId: string,
-): ObservationLabCalculationProfile | null {
-  if (value === null) return null;
-  if (!isRecord(value) || Object.keys(value).some((key) => !PROFILE_KEYS.has(key))) {
-    throw new ObservationLabCalculationProfileContractError(
-      `Профиль расчёта LAB-сессии ${sessionId} нарушил контракт полей.`,
-    );
-  }
-  if (
-    Object.keys(value).length !== PROFILE_KEYS.size
-    || value.schema_version !== OBSERVATION_LAB_CALCULATION_PROFILE_SCHEMA
-  ) {
-    throw new ObservationLabCalculationProfileContractError(
-      `Профиль расчёта LAB-сессии ${sessionId} имеет неизвестную версию.`,
-    );
-  }
-
-  const origin = value.origin;
-  if (origin !== "archived-definition" && origin !== "existing-result") {
-    throw new ObservationLabCalculationProfileContractError(
-      `Профиль расчёта LAB-сессии ${sessionId} имеет неизвестное происхождение.`,
-    );
-  }
-  const definitionId = value.definition_id === null
-    ? null
-    : requireIdentifier(value.definition_id, "definition_id");
-  const definitionVersion = value.definition_version === null
-    ? null
-    : value.definition_version;
-  if (
-    definitionVersion !== null
-    && (
-      typeof definitionVersion !== "number"
-      || !Number.isInteger(definitionVersion)
-      || definitionVersion < 1
-    )
-  ) {
-    throw new ObservationLabCalculationProfileContractError(
-      `Профиль расчёта LAB-сессии ${sessionId} содержит некорректную версию определения.`,
-    );
-  }
-  const definitionSha256 = value.definition_sha256 === null
-    ? null
-    : requireText(value.definition_sha256, "definition_sha256", 64);
-  if (definitionSha256 !== null && !SHA256.test(definitionSha256)) {
-    throw new ObservationLabCalculationProfileContractError(
-      `Профиль расчёта LAB-сессии ${sessionId} не содержит SHA-256 определения.`,
-    );
-  }
-
-  const definitionFieldCount = [
-    definitionId,
-    definitionVersion,
-    definitionSha256,
-  ].filter((entry) => entry !== null).length;
-  if (
-    (origin === "existing-result" && definitionFieldCount !== 0)
-    || (origin === "archived-definition" && definitionFieldCount !== 3)
-  ) {
-    throw new ObservationLabCalculationProfileContractError(
-      `Профиль расчёта LAB-сессии ${sessionId} содержит неполную идентичность определения.`,
-    );
-  }
-
-  return {
-    schemaVersion: OBSERVATION_LAB_CALCULATION_PROFILE_SCHEMA,
-    setupId: requireIdentifier(value.setup_id, "setup_id"),
-    displayName: requireText(value.display_name, "display_name", 256),
-    origin,
-    definitionId,
-    definitionVersion,
-    definitionSha256,
-  };
-}
@@ -1,280 +0,0 @@
-export interface ObservationCanonicalLabReplayCapability {
-  schemaVersion: "missioncore.observation-lab-replay-capability/v1";
-  kind: "canonical-recorded-rerun";
-  viewerProfile: "recorded-session";
-  timeline: "session_time";
-  activation: "explicit";
-  commandsEnabled: false;
-}
-
-export interface ObservationPortableLabReplayCapability {
-  schemaVersion: "missioncore.observation-lab-replay-capability/v2";
-  kind: "portable-result-review";
-  viewerProfile: "portable-result";
-  timeline: "result-defined";
-  activation: "explicit";
-  commandsEnabled: false;
-}
-
-export type ObservationLabReplayCapability =
-  | ObservationCanonicalLabReplayCapability
-  | ObservationPortableLabReplayCapability;
-
-export class ObservationLabReplayCapabilityContractError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "ObservationLabReplayCapabilityContractError";
-  }
-}
-
-const SHA256 = /^[a-f0-9]{64}$/;
-const CAPABILITY_KEYS = new Set([
-  "schema_version",
-  "kind",
-  "viewer_profile",
-  "timeline",
-  "activation",
-  "commands_enabled",
-]);
-const CANONICAL_PROVENANCE_KEYS = new Set([
-  "schema_version",
-  "evidence_identity_sha256",
-  "result_document_sha256",
-  "replay_capability",
-  "authority",
-  "method",
-]);
-const PORTABLE_PROVENANCE_KEYS = new Set([
-  "schema_version",
-  "authority",
-  "calculation_profile",
-  "calculation_profile_sha256",
-  "job",
-  "source",
-  "run_definition",
-  "result_package",
-  "replay_capability",
-  "storage",
-  "method",
-]);
-const AUTHORITY_KEYS = new Set([
-  "commands_enabled",
-  "navigation_or_safety_accepted",
-  "actuation_accepted",
-]);
-const METHOD_KEYS = new Set([
-  "schema_version",
-  "completeness",
-  "execution_class",
-  "pipeline_id",
-  "components",
-]);
-const METHOD_COMPONENT_KEYS = new Set([
-  "kind",
-  "name",
-  "version",
-  "role",
-  "identity_sha256",
-]);
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-function assertExactKeys(
-  value: Record<string, unknown>,
-  expected: ReadonlySet<string>,
-  label: string,
-): void {
-  const keys = Object.keys(value);
-  if (keys.length !== expected.size || keys.some((key) => !expected.has(key))) {
-    throw new ObservationLabReplayCapabilityContractError(
-      `${label} содержит неизвестные или пропущенные поля.`,
-    );
-  }
-}
-
-export function decodeLabReplayCapability(
-  value: unknown,
-  sessionId: string,
-): ObservationLabReplayCapability | null {
-  if (value === null || value === undefined) return null;
-  if (!isRecord(value)) {
-    throw new ObservationLabReplayCapabilityContractError(
-      `Replay-возможность LAB-сессии ${sessionId} должна быть объектом или null.`,
-    );
-  }
-  assertExactKeys(value, CAPABILITY_KEYS, `Replay-возможность LAB-сессии ${sessionId}`);
-  if (
-    value.activation !== "explicit"
-    || value.commands_enabled !== false
-  ) {
-    throw new ObservationLabReplayCapabilityContractError(
-      `Replay-возможность LAB-сессии ${sessionId} нарушает observation-only контракт.`,
-    );
-  }
-  if (
-    value.schema_version === "missioncore.observation-lab-replay-capability/v1"
-    && value.kind === "canonical-recorded-rerun"
-    && value.viewer_profile === "recorded-session"
-    && value.timeline === "session_time"
-  ) {
-    return {
-      schemaVersion: "missioncore.observation-lab-replay-capability/v1",
-      kind: "canonical-recorded-rerun",
-      viewerProfile: "recorded-session",
-      timeline: "session_time",
-      activation: "explicit",
-      commandsEnabled: false,
-    };
-  }
-  if (
-    value.schema_version === "missioncore.observation-lab-replay-capability/v2"
-    && value.kind === "portable-result-review"
-    && value.viewer_profile === "portable-result"
-    && value.timeline === "result-defined"
-  ) {
-    return {
-      schemaVersion: "missioncore.observation-lab-replay-capability/v2",
-      kind: "portable-result-review",
-      viewerProfile: "portable-result",
-      timeline: "result-defined",
-      activation: "explicit",
-      commandsEnabled: false,
-    };
-  }
-  throw new ObservationLabReplayCapabilityContractError(
-    `Replay-возможность LAB-сессии ${sessionId} содержит неизвестный viewer capability.`,
-  );
-}
-
-export function decodeCanonicalLabReplayCapabilityProvenance(
-  provenance: Readonly<Record<string, unknown>>,
-  sessionId: string,
-  resultId: string,
-): ObservationCanonicalLabReplayCapability {
-  assertExactKeys(provenance, CANONICAL_PROVENANCE_KEYS, `Canonical provenance LAB-сессии ${sessionId}`);
-  if (
-    provenance.schema_version !== "missioncore.canonical-recorded-lab-projection/v1"
-    || typeof provenance.evidence_identity_sha256 !== "string"
-    || !SHA256.test(provenance.evidence_identity_sha256)
-    || resultId !== `lab-v1-vegetation-shadow-${provenance.evidence_identity_sha256}`
-    || typeof provenance.result_document_sha256 !== "string"
-    || !SHA256.test(provenance.result_document_sha256)
-  ) {
-    throw new ObservationLabReplayCapabilityContractError(
-      `Canonical provenance LAB-сессии ${sessionId} потеряла immutable identity.`,
-    );
-  }
-  if (!isRecord(provenance.authority)) {
-    throw new ObservationLabReplayCapabilityContractError(
-      `Canonical provenance LAB-сессии ${sessionId} не содержит authority.`,
-    );
-  }
-  assertExactKeys(provenance.authority, AUTHORITY_KEYS, `Canonical authority LAB-сессии ${sessionId}`);
-  if (
-    provenance.authority.commands_enabled !== false
-    || provenance.authority.navigation_or_safety_accepted !== false
-    || provenance.authority.actuation_accepted !== false
-  ) {
-    throw new ObservationLabReplayCapabilityContractError(
-      `Canonical provenance LAB-сессии ${sessionId} нарушает observation-only authority.`,
-    );
-  }
-  if (!isRecord(provenance.method)) {
-    throw new ObservationLabReplayCapabilityContractError(
-      `Canonical provenance LAB-сессии ${sessionId} не содержит method manifest.`,
-    );
-  }
-  assertExactKeys(provenance.method, METHOD_KEYS, `Canonical method LAB-сессии ${sessionId}`);
-  if (
-    provenance.method.schema_version !== "missioncore.laboratory-method/v1"
-    || provenance.method.completeness !== "legacy-partial"
-    || provenance.method.execution_class !== "ai-inference"
-    || provenance.method.pipeline_id
-      !== "ravnoves004tree-full-eomt-ddrnet-recorded-review/v1"
-    || !Array.isArray(provenance.method.components)
-    || provenance.method.components.length !== 1
-  ) {
-    throw new ObservationLabReplayCapabilityContractError(
-      `Canonical method LAB-сессии ${sessionId} не соответствует записанному прогону.`,
-    );
-  }
-  const component = provenance.method.components[0];
-  if (!isRecord(component)) {
-    throw new ObservationLabReplayCapabilityContractError(
-      `Canonical method LAB-сессии ${sessionId} не содержит source component.`,
-    );
-  }
-  assertExactKeys(
-    component,
-    METHOD_COMPONENT_KEYS,
-    `Canonical source component LAB-сессии ${sessionId}`,
-  );
-  if (
-    component.kind !== "source"
-    || component.name !== "sealed full-route LAB result"
-    || component.version !== "missioncore.lab-v1-vegetation-shadow/v1"
-    || component.role !== "immutable Session catalog projection"
-    || component.identity_sha256 !== provenance.evidence_identity_sha256
-  ) {
-    throw new ObservationLabReplayCapabilityContractError(
-      `Canonical source component LAB-сессии ${sessionId} потерял immutable identity.`,
-    );
-  }
-  const capability = decodeLabReplayCapability(provenance.replay_capability, sessionId);
-  if (capability === null || capability.kind !== "canonical-recorded-rerun") {
-    throw new ObservationLabReplayCapabilityContractError(
-      `Canonical provenance LAB-сессии ${sessionId} не содержит replay capability.`,
-    );
-  }
-  return capability;
-}
-
-export function decodePortableLabReplayCapabilityProvenance(
-  provenance: Readonly<Record<string, unknown>>,
-  sessionId: string,
-  resultId: string,
-  sourceSessionId: string,
-  definitionSha256: string,
-): ObservationPortableLabReplayCapability {
-  assertExactKeys(
-    provenance,
-    PORTABLE_PROVENANCE_KEYS,
-    `Portable provenance LAB-сессии ${sessionId}`,
-  );
-  if (
-    provenance.schema_version !== "missioncore.observatory-portable-result-publication/v1"
-    || !isRecord(provenance.source)
-    || provenance.source.session_id !== sourceSessionId
-    || !isRecord(provenance.run_definition)
-    || provenance.run_definition.definition_sha256 !== definitionSha256
-    || !isRecord(provenance.result_package)
-    || typeof provenance.result_package.manifest_sha256 !== "string"
-    || !SHA256.test(provenance.result_package.manifest_sha256)
-    || typeof provenance.result_package.artifact_manifest_id !== "string"
-    || !SHA256.test(provenance.result_package.artifact_manifest_id)
-    || sessionId !== resultId
-  ) {
-    throw new ObservationLabReplayCapabilityContractError(
-      `Portable provenance LAB-сессии ${sessionId} потеряла immutable identity.`,
-    );
-  }
-  const capability = decodeLabReplayCapability(provenance.replay_capability, sessionId);
-  if (capability === null || capability.kind !== "portable-result-review") {
-    throw new ObservationLabReplayCapabilityContractError(
-      `Portable provenance LAB-сессии ${sessionId} не содержит viewer capability.`,
-    );
-  }
-  return capability;
-}
-
-/** Rolling bridge for a new frontend against the pre-v2 catalog endpoint. */
-export function decodeRollingCanonicalLabReplayCapability(
-  provenance: Readonly<Record<string, unknown>>,
-  sessionId: string,
-  resultId: string,
-): ObservationLabReplayCapability | null {
-  if (!Object.prototype.hasOwnProperty.call(provenance, "replay_capability")) return null;
-  return decodeCanonicalLabReplayCapabilityProvenance(provenance, sessionId, resultId);
-}
@@ -1,70 +0,0 @@
-import { isUsableRecordedPlaybackRange } from "./recordedRerunLifecycle";
-
-export function createReentrantViewerDisposer(
-  cleanupOnce: () => void,
-  releaseNativeViewer: () => void,
-): () => void {
-  let cleanupComplete = false;
-  return () => {
-    try {
-      if (!cleanupComplete) {
-        cleanupComplete = true;
-        cleanupOnce();
-      }
-    } finally {
-      // A deferred native start can resolve after a pre-ready stop. Reapply
-      // release at every boundary so it cannot reopen after React unmount.
-      releaseNativeViewer();
-    }
-  };
-}
-
-interface ActiveLiveViewerOwner {
-  release: () => void;
-}
-
-let activeLiveViewerOwner: ActiveLiveViewerOwner | null = null;
-
-/** Own exactly one native live receiver per application document. */
-export function claimExclusiveLiveViewer(release: () => void): () => void {
-  const owner = { release };
-  const previous = activeLiveViewerOwner;
-  activeLiveViewerOwner = owner;
-  previous?.release();
-  return () => {
-    if (activeLiveViewerOwner === owner) activeLiveViewerOwner = null;
-  };
-}
-
-export function isLiveRerunPresentationReady(
-  viewerStarted: boolean,
-  rangeNs: { min: number; max: number } | null,
-  backendActivitySequence: number | null,
-): boolean {
-  return viewerStarted
-    && Number.isSafeInteger(backendActivitySequence)
-    && (backendActivitySequence ?? 0) > 0
-    && isUsableRecordedPlaybackRange(rangeNs);
-}
-
-export function liveTimelineNeedsSynchronization(
-  followLive: boolean,
-  activeTimeline: string | null | undefined,
-  rangeNs: { min: number; max: number } | null,
-): boolean {
-  return followLive
-    && isUsableRecordedPlaybackRange(rangeNs)
-    && activeTimeline !== "stream_time";
-}
-
-export function liveRerunReceiverBindingIdentity(
-  sourceUrl: string,
-  liveStreamId: string | null,
-  followLive: boolean,
-): string {
-  return JSON.stringify([
-    followLive ? "live" : "recorded",
-    sourceUrl.trim(),
-    followLive ? liveStreamId?.trim() ?? "" : "",
-  ]);
-}
@@ -327,53 +327,6 @@ export function verifyLiveViewerClientBuild(
  });
 }

-/**
- * Recover a recorded viewer whose lazy module disappeared during a frontend
- * deployment. Live acquisition deliberately never reloads automatically, but
- * a saved recording has no device-side authority to preserve and can safely
- * move to the current immutable application build.
- */
-export async function reloadRecordedViewerAfterStaleModuleFailure({
-  loadedUiBuildId,
-  signal,
-  fetcher = globalThis.fetch,
-  reload = () => window.location.reload(),
-}: {
-  loadedUiBuildId: string;
-  signal?: AbortSignal;
-  fetcher?: typeof globalThis.fetch;
-  reload?: () => void;
-}): Promise<boolean> {
-  if (
-    signal?.aborted ||
-    loadedUiBuildId === DEVELOPMENT_UI_BUILD_ID ||
-    !HASHED_UI_BUILD_ID.test(loadedUiBuildId)
-  ) return false;
-  try {
-    const response = await fetcher("/api/v1/viewer/client-contract", {
-      method: "GET",
-      headers: {
-        Accept: "application/json",
-        "X-MissionCore-UI-Build": loadedUiBuildId,
-      },
-      cache: "no-store",
-      signal,
-    });
-    if (signal?.aborted || !response.ok) return false;
-    const expectedUiBuildId = response.headers.get(UI_BUILD_HEADER);
-    if (
-      !expectedUiBuildId ||
-      expectedUiBuildId === loadedUiBuildId ||
-      !HASHED_UI_BUILD_ID.test(expectedUiBuildId)
-    ) return false;
-    browserUiBuildCoordinator().report({ loadedUiBuildId, expectedUiBuildId });
-    reload();
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 function startBuildMonitor(): void {
  if (buildMonitorAbort || typeof window === "undefined") return;
  const lineage = createLiveViewerLineage(createLiveViewerInstanceId(), 1);
@@ -1,53 +0,0 @@
-/** Small lease for the server's ephemeral blueprint, never for the recording. */
-export function keepRecordedBlueprintSession({
-  endpointUrl,
-  origin,
-  applicationId,
-  recordingId,
-  ownerId,
-  fetcher = fetch,
-  schedule = (callback: () => void) => window.setInterval(callback, 30_000),
-  cancel = (handle: number) => window.clearInterval(handle),
-}: {
-  endpointUrl: string;
-  origin: string;
-  applicationId: string;
-  recordingId: string;
-  ownerId: string;
-  fetcher?: typeof fetch;
-  schedule?: (callback: () => void) => number;
-  cancel?: (handle: number) => void;
-}): () => void {
-  const endpoint = new URL(endpointUrl, origin);
-  if (endpoint.origin !== origin || endpoint.search || endpoint.hash ||
-      !/^\/api\/v1\/observation-sessions\/[A-Za-z0-9._:-]+\/blueprint\.rrd$/.test(endpoint.pathname)) {
-    throw new Error("Unsafe recorded blueprint lifecycle endpoint");
-  }
-  endpoint.pathname = endpoint.pathname.replace(/blueprint\.rrd$/, "blueprint-lifecycle");
-  const identity = { application_id: applicationId, recording_id: recordingId,
-    blueprint_session_id: ownerId };
-  let closed = false;
-  let pending: AbortController | null = null;
-  const renew = () => {
-    if (closed) return;
-    pending?.abort();
-    pending = new AbortController();
-    void fetcher(endpoint.href, {
-      method: "POST", headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ ...identity, action: "renew" }), signal: pending.signal,
-    }).catch(() => { /* The TTL cleans up after a lost browser/network. */ });
-  };
-  const timer = schedule(renew);
-  return () => {
-    if (closed) return;
-    closed = true;
-    cancel(timer);
-    pending?.abort();
-    pending = null;
-    void fetcher(endpoint.href, {
-      method: "POST", headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ ...identity, action: "release" }),
-      keepalive: true, signal: AbortSignal.timeout(5_000),
-    }).catch(() => { /* Terminal release is best-effort; the server also has TTL. */ });
-  };
-}
@@ -1,303 +0,0 @@
-import type { SceneSettings } from "../../sceneSettings";
-import type { RecordedAdmissionPhase } from "./recordedSessionAdmission";
-import type { RerunPlaybackState, RerunViewportStatus } from "./viewerProfile";
-
-const BUFFER_END_TOLERANCE_NS = 1_000_000;
-const RECORDED_OPEN_MIN_TIMEOUT_MS = 120_000;
-const RECORDED_OPEN_MAX_TIMEOUT_MS = 1_800_000;
-const RECORDED_OPEN_GRACE_MS = 30_000;
-const RECORDED_OPEN_MIN_BYTES_PER_SECOND = 2 * 1024 * 1024;
-
-export const RECORDED_BASE_POINT_COLOR_KEY = "intensity|turbo|-";
-
-export interface RecordedPlaybackBufferState {
-  bufferedEndNs: number | null;
-  expectedStartNs: number | null;
-  expectedEndNs: number | null;
-  bufferProgress: number | null;
-  fullyBuffered: boolean;
-}
-
-export function recordedPointColorKey(
-  settings: Pick<SceneSettings, "colorMode" | "palette" | "customColor">,
-): string {
-  const custom = settings.palette === "custom" || settings.colorMode === "class"
-    ? settings.customColor.toLowerCase()
-    : "-";
-  return `${settings.colorMode}|${settings.palette}|${custom}`;
-}
-
-export function recordedOpenWatchdogTimeoutMs(byteLength: number): number {
-  if (!Number.isSafeInteger(byteLength) || byteLength < 4) {
-    throw new Error("Unsafe recorded RRD byte length");
-  }
-  const transferBudgetMs = Math.ceil(
-    (byteLength / RECORDED_OPEN_MIN_BYTES_PER_SECOND) * 1_000,
-  );
-  return Math.min(
-    RECORDED_OPEN_MAX_TIMEOUT_MS,
-    Math.max(RECORDED_OPEN_MIN_TIMEOUT_MS, transferBudgetMs + RECORDED_OPEN_GRACE_MS),
-  );
-}
-
-export function createRecordedOpenWatchdog<T>({
-  byteLength,
-  schedule,
-  cancel,
-  onTimeout,
-}: {
-  byteLength: number;
-  schedule: (callback: () => void, timeoutMs: number) => T;
-  cancel: (handle: T) => void;
-  onTimeout: () => void;
-}): { arm: () => void; clear: () => void; pending: () => boolean } {
-  const timeoutMs = recordedOpenWatchdogTimeoutMs(byteLength);
-  let handle: T | null = null;
-  return {
-    arm() {
-      if (handle !== null) return;
-      handle = schedule(() => {
-        handle = null;
-        onTimeout();
-      }, timeoutMs);
-    },
-    clear() {
-      if (handle === null) return;
-      cancel(handle);
-      handle = null;
-    },
-    pending: () => handle !== null,
-  };
-}
-
-export function isUsableRecordedPlaybackRange(
-  rangeNs: { min: number; max: number } | null,
-): rangeNs is { min: number; max: number } {
-  return Boolean(
-    rangeNs
-    && Number.isFinite(rangeNs.min)
-    && Number.isFinite(rangeNs.max)
-    && rangeNs.max >= rangeNs.min,
-  );
-}
-
-export function recordedPlaybackBufferState(
-  rangeNs: { min: number; max: number } | null,
-  expectedTimelineEndSeconds?: number,
-  expectedTimelineStartSeconds?: number,
-): RecordedPlaybackBufferState {
-  const usableRange = isUsableRecordedPlaybackRange(rangeNs) ? rangeNs : null;
-  const bufferedEndNs = usableRange?.max ?? null;
-  if (expectedTimelineEndSeconds === undefined) {
-    return {
-      bufferedEndNs,
-      expectedStartNs: null,
-      expectedEndNs: null,
-      bufferProgress: null,
-      fullyBuffered: usableRange !== null,
-    };
-  }
-  if (!Number.isFinite(expectedTimelineEndSeconds) || expectedTimelineEndSeconds < 0) {
-    return {
-      bufferedEndNs,
-      expectedStartNs: null,
-      expectedEndNs: null,
-      bufferProgress: null,
-      fullyBuffered: false,
-    };
-  }
-
-  const expectedEndNs = expectedTimelineEndSeconds * 1_000_000_000;
-  const expectedStartNs = expectedTimelineStartSeconds === undefined
-    ? 0
-    : expectedTimelineStartSeconds * 1_000_000_000;
-  if (
-    !Number.isFinite(expectedEndNs)
-    || !Number.isFinite(expectedStartNs)
-    || expectedStartNs < 0
-    || expectedEndNs < expectedStartNs
-  ) {
-    return {
-      bufferedEndNs,
-      expectedStartNs: null,
-      expectedEndNs: null,
-      bufferProgress: null,
-      fullyBuffered: false,
-    };
-  }
-  const fullyBuffered = usableRange !== null
-    && usableRange.min <= expectedStartNs + BUFFER_END_TOLERANCE_NS
-    && usableRange.max >= expectedEndNs - BUFFER_END_TOLERANCE_NS;
-  const expectedDurationNs = expectedEndNs - expectedStartNs;
-  const bufferProgress = bufferedEndNs === null
-    ? 0
-    : expectedDurationNs <= 0
-      ? (fullyBuffered ? 1 : 0)
-      : Math.min(1, Math.max(0, (bufferedEndNs - expectedStartNs) / expectedDurationNs));
-  return {
-    bufferedEndNs,
-    expectedStartNs,
-    expectedEndNs,
-    bufferProgress,
-    fullyBuffered,
-  };
-}
-
-export function isRecordedPlaybackReady(
-  viewerStarted: boolean,
-  artifactVerified: boolean,
-  buffer: RecordedPlaybackBufferState,
-): boolean {
-  return viewerStarted && artifactVerified && buffer.bufferedEndNs !== null;
-}
-
-export function recordedPlaybackRangeWhenReady(
-  rangeNs: { min: number; max: number } | null,
-  buffer: RecordedPlaybackBufferState,
-  artifactVerified: boolean,
-): { min: number; max: number } | null {
-  if (
-    !artifactVerified
-    || !buffer.fullyBuffered
-    || !isUsableRecordedPlaybackRange(rangeNs)
-  ) return null;
-  return {
-    min: buffer.expectedStartNs === null
-      ? rangeNs.min
-      : Math.max(rangeNs.min, buffer.expectedStartNs),
-    max: buffer.expectedEndNs === null
-      ? rangeNs.max
-      : Math.min(rangeNs.max, buffer.expectedEndNs),
-  };
-}
-
-export function isRecordedPlaybackPresentationReady(
-  status: RerunViewportStatus,
-  playback: RerunPlaybackState | null,
-): boolean {
-  return status === "ready"
-    && playback?.fullyBuffered === true
-    && isUsableRecordedPlaybackRange(playback.rangeNs);
-}
-
-export function rerunPresentationStatus(
-  status: RerunViewportStatus,
-  _gate: RecordedAdmissionPhase,
-  recorded: boolean,
-): RerunViewportStatus {
-  if (!recorded) return status;
-  return status === "error" ? "error" : status;
-}
-
-export function isRecordedPlaybackFullyBuffered(
-  rangeNs: { min: number; max: number } | null,
-  expectedTimelineEndSeconds?: number,
-): boolean {
-  return recordedPlaybackBufferState(rangeNs, expectedTimelineEndSeconds).fullyBuffered;
-}
-
-export function attemptRecordedAutoplay(
-  seekToStart: () => void,
-  startPlaying: () => void,
-): boolean {
-  try {
-    seekToStart();
-    startPlaying();
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export function createRecordedInitialSeekGate(): {
-  attempt: (
-    viewerStarted: boolean,
-    fullyBuffered: boolean,
-    presentationReady: boolean,
-    rangeNs: { min: number; max: number } | null,
-    seekToStart: (startNs: number) => void,
-    preferredStartNs?: number,
-  ) => boolean;
-  attempted: () => boolean;
-} {
-  let consumed = false;
-  return {
-    attempt(
-      viewerStarted,
-      fullyBuffered,
-      presentationReady,
-      rangeNs,
-      seekToStart,
-      preferredStartNs,
-    ) {
-      if (
-        consumed
-        || !viewerStarted
-        || !fullyBuffered
-        || !presentationReady
-        || !isUsableRecordedPlaybackRange(rangeNs)
-      ) return false;
-      consumed = true;
-      const startNs = Number.isFinite(preferredStartNs)
-        ? Math.min(Math.max(preferredStartNs as number, rangeNs.min), rangeNs.max)
-        : rangeNs.min;
-      try {
-        seekToStart(startNs);
-        return true;
-      } catch {
-        return false;
-      }
-    },
-    attempted: () => consumed,
-  };
-}
-
-export function createRecordedAutoplayGate(): {
-  attempt: (
-    viewerStarted: boolean,
-    fullyBuffered: boolean,
-    presentationReady: boolean,
-    rangeNs: { min: number; max: number } | null,
-    seekToStart: (startNs: number) => void,
-    startPlaying: () => void,
-    preferredStartNs?: number,
-  ) => boolean;
-  attempted: () => boolean;
-} {
-  let consumed = false;
-  return {
-    attempt(
-      viewerStarted,
-      fullyBuffered,
-      presentationReady,
-      rangeNs,
-      seekToStart,
-      startPlaying,
-      preferredStartNs,
-    ) {
-      if (
-        consumed
-        || !viewerStarted
-        || !fullyBuffered
-        || !presentationReady
-        || !isUsableRecordedPlaybackRange(rangeNs)
-      ) return false;
-      consumed = true;
-      const startNs = Number.isFinite(preferredStartNs)
-        ? Math.min(Math.max(preferredStartNs as number, rangeNs.min), rangeNs.max)
-        : rangeNs.min;
-      return attemptRecordedAutoplay(
-        () => seekToStart(startNs),
-        startPlaying,
-      );
-    },
-    attempted: () => consumed,
-  };
-}
-
-export function canPublishRecordedPlaybackController(
-  readyToRender: boolean,
-  presentationGate: RecordedAdmissionPhase,
-): boolean {
-  return readyToRender && presentationGate === "ready";
-}
@@ -1,43 +0,0 @@
-export interface ObservationReplayAttempt {
-  readonly signal: AbortSignal;
-  isCurrent: () => boolean;
-  finish: () => boolean;
-}
-
-export interface ObservationReplayCoordinator {
-  begin: () => ObservationReplayAttempt;
-  cancel: () => void;
-}
-
-/** Latest explicit admission owns the viewer, even if an older promise settles later. */
-export function createObservationReplayCoordinator(): ObservationReplayCoordinator {
-  let sequence = 0;
-  let active: AbortController | null = null;
-
-  return {
-    begin() {
-      active?.abort();
-      const controller = new AbortController();
-      const attemptSequence = ++sequence;
-      active = controller;
-      return {
-        signal: controller.signal,
-        isCurrent: () => (
-          !controller.signal.aborted
-          && active === controller
-          && sequence === attemptSequence
-        ),
-        finish: () => {
-          if (active !== controller || sequence !== attemptSequence) return false;
-          active = null;
-          return true;
-        },
-      };
-    },
-    cancel() {
-      active?.abort();
-      // Keep settlement ownership until finish(). isCurrent() already fails,
-      // while begin() can replace this attempt immediately.
-    },
-  };
-}
@@ -1,20 +1,6 @@
 import {
  MAX_RECORDED_CAMERA_SOURCES,
 } from "./recordedSessionAdmission";
-import {
-  decodeLabReplayCapability,
-  decodeRollingCanonicalLabReplayCapability,
-  ObservationLabReplayCapabilityContractError,
-  type ObservationLabReplayCapability,
-} from "./labReplayCapability";
-import {
-  decodeObservationLabCalculationProfile,
-  ObservationLabCalculationProfileContractError,
-  type ObservationLabCalculationProfile,
-} from "./labCalculationProfile";
-
-export type { ObservationLabReplayCapability } from "./labReplayCapability";
-export type { ObservationLabCalculationProfile } from "./labCalculationProfile";

 export type ObservationSessionStatus =
  | "recording"
@@ -34,8 +20,6 @@ export interface ObservationLabInstance {
  configSha256: string | null;
  runCreatedAtUtc: string;
  publishedAtUtc: string;
-  replayCapability: ObservationLabReplayCapability | null;
-  calculationProfile: ObservationLabCalculationProfile | null;
  provenance: Readonly<Record<string, unknown>>;
 }

@@ -48,21 +32,10 @@ export interface ObservationSessionSummary {
  modalities: readonly string[];
  durationSeconds: number;
  replayable: boolean;
-  captureAttestation: ObservationCaptureAttestation | null;
  preparation: ObservationSessionCatalogPreparation | null;
  lab: ObservationLabInstance | null;
 }

-export interface ObservationCaptureAttestation {
-  readonly equipmentModelId: string;
-  readonly equipmentModelSha256: string;
-  readonly equipmentDisplayName: string;
-  readonly captureProfileId: string;
-  readonly captureProfileSha256: string;
-  readonly captureAttestationSha256: string;
-  readonly state: "attested" | "attested-with-legacy-evidence" | "unknown";
-}
-
 export interface ObservationSessionCatalog {
  items: readonly ObservationSessionSummary[];
 }
@@ -179,11 +152,10 @@ const ITEM_KEYS = new Set([
  "modalities",
  "duration_seconds",
  "replayable",
-  "capture_attestation",
  "preparation",
  "lab",
 ]);
-const LEGACY_LAB_KEYS = new Set([
+const LAB_KEYS = new Set([
  "lab_id",
  "source_session_id",
  "result_kind",
@@ -194,27 +166,6 @@ const LEGACY_LAB_KEYS = new Set([
  "published_at_utc",
  "provenance",
 ]);
-const LAB_V2_KEYS = new Set([...LEGACY_LAB_KEYS, "replay_capability"]);
-const LAB_V3_KEYS = new Set([
-  ...LAB_V2_KEYS,
-  "calculation_profile",
-]);
-const CAPTURE_ATTESTATION_KEYS = new Set([
-  "schema_version",
-  "equipment_model",
-  "capture_profile",
-  "capture_attestation_sha256",
-  "state",
-]);
-const EQUIPMENT_MODEL_KEYS = new Set([
-  "equipment_model_id",
-  "equipment_model_sha256",
-  "display_name",
-]);
-const CAPTURE_PROFILE_KEYS = new Set([
-  "capture_profile_id",
-  "capture_profile_sha256",
-]);
 const CATALOG_PREPARATION_KEYS = new Set([
  "preparation_id",
  "state",
@@ -428,103 +379,11 @@ function decodeItem(value: unknown, index: number): ObservationSessionSummary {
    modalities: requireModalities(value.modalities),
    durationSeconds: value.duration_seconds,
    replayable: value.replayable,
-    captureAttestation: decodeCaptureAttestation(value.capture_attestation, id),
    preparation: decodeCatalogPreparation(value.preparation, id),
    lab: decodeLabInstance(value.lab, id),
  };
 }

-function decodeCaptureAttestation(
-  value: unknown,
-  sessionId: string,
-): ObservationCaptureAttestation | null {
-  if (value === null || value === undefined) return null;
-  if (!isRecord(value)) {
-    throw new ObservationSessionContractError(
-      `Аттестация записи ${sessionId} должна быть объектом или null.`,
-    );
-  }
-  assertExactKeys(value, CAPTURE_ATTESTATION_KEYS, `Аттестация записи ${sessionId}`);
-  if (value.schema_version !== "missioncore.recorded-capture-attestation/v1") {
-    throw new ObservationSessionContractError(
-      `Аттестация записи ${sessionId} имеет неизвестную схему.`,
-    );
-  }
-  if (!isRecord(value.equipment_model) || !isRecord(value.capture_profile)) {
-    throw new ObservationSessionContractError(
-      `Аттестация записи ${sessionId} не содержит оборудование или профиль записи.`,
-    );
-  }
-  assertExactKeys(
-    value.equipment_model,
-    EQUIPMENT_MODEL_KEYS,
-    `Оборудование записи ${sessionId}`,
-  );
-  assertExactKeys(
-    value.capture_profile,
-    CAPTURE_PROFILE_KEYS,
-    `Профиль записи ${sessionId}`,
-  );
-  const equipmentModelId = requireString(
-    value.equipment_model.equipment_model_id,
-    "equipment_model_id",
-    128,
-  );
-  const equipmentModelSha256 = requireString(
-    value.equipment_model.equipment_model_sha256,
-    "equipment_model_sha256",
-    64,
-  );
-  const captureProfileId = requireString(
-    value.capture_profile.capture_profile_id,
-    "capture_profile_id",
-    128,
-  );
-  const captureProfileSha256 = requireString(
-    value.capture_profile.capture_profile_sha256,
-    "capture_profile_sha256",
-    64,
-  );
-  const captureAttestationSha256 = requireString(
-    value.capture_attestation_sha256,
-    "capture_attestation_sha256",
-    64,
-  );
-  if (
-    !SAFE_ID.test(equipmentModelId)
-    || !SAFE_ID.test(captureProfileId)
-    || !SHA256.test(equipmentModelSha256)
-    || !SHA256.test(captureProfileSha256)
-    || !SHA256.test(captureAttestationSha256)
-  ) {
-    throw new ObservationSessionContractError(
-      `Аттестация записи ${sessionId} содержит некорректную immutable identity.`,
-    );
-  }
-  if (
-    value.state !== "attested"
-    && value.state !== "attested-with-legacy-evidence"
-    && value.state !== "unknown"
-  ) {
-    throw new ObservationSessionContractError(
-      `Аттестация записи ${sessionId} содержит неизвестное состояние.`,
-    );
-  }
-  return {
-    equipmentModelId,
-    equipmentModelSha256,
-    equipmentDisplayName: requireString(
-      value.equipment_model.display_name,
-      "equipment display_name",
-      128,
-    ),
-    captureProfileId,
-    captureProfileSha256,
-    captureAttestationSha256,
-    state: value.state,
-  };
-}
-
 function decodeLabInstance(
  value: unknown,
  sessionId: string,
@@ -535,23 +394,7 @@ function decodeLabInstance(
      `LAB-привязка сессии ${sessionId} должна быть объектом или null.`,
    );
  }
-  const hasTypedCapability = Object.prototype.hasOwnProperty.call(
-    value,
-    "replay_capability",
-  );
-  const hasCalculationProfile = Object.prototype.hasOwnProperty.call(
-    value,
-    "calculation_profile",
-  );
-  assertExactKeys(
-    value,
-    hasCalculationProfile
-      ? LAB_V3_KEYS
-      : hasTypedCapability
-        ? LAB_V2_KEYS
-        : LEGACY_LAB_KEYS,
-    `LAB-привязка сессии ${sessionId}`,
-  );
+  assertExactKeys(value, LAB_KEYS, `LAB-привязка сессии ${sessionId}`);
  const labId = requireString(value.lab_id, `lab(${sessionId}).lab_id`, 36);
  if (!/^LAB [A-Z][A-Z0-9._-]{0,31}$/.test(labId)) {
    throw new ObservationSessionContractError("Каталог содержит некорректный LAB-маркер.");
@@ -587,28 +430,6 @@ function decodeLabInstance(
  if (!isRecord(value.provenance)) {
    throw new ObservationSessionContractError("LAB provenance должен быть JSON-объектом.");
  }
-  let replayCapability: ObservationLabReplayCapability | null;
-  try {
-    replayCapability = hasTypedCapability
-      ? decodeLabReplayCapability(value.replay_capability, sessionId)
-      : decodeRollingCanonicalLabReplayCapability(value.provenance, sessionId, resultId);
-  } catch (error) {
-    if (error instanceof ObservationLabReplayCapabilityContractError) {
-      throw new ObservationSessionContractError(error.message);
-    }
-    throw error;
-  }
-  let calculationProfile: ObservationLabCalculationProfile | null;
-  try {
-    calculationProfile = hasCalculationProfile
-      ? decodeObservationLabCalculationProfile(value.calculation_profile, sessionId)
-      : null;
-  } catch (error) {
-    if (error instanceof ObservationLabCalculationProfileContractError) {
-      throw new ObservationSessionContractError(error.message);
-    }
-    throw error;
-  }
  return {
    labId,
    sourceSessionId,
@@ -624,8 +445,6 @@ function decodeLabInstance(
      value.published_at_utc,
      `lab(${sessionId}).published_at_utc`,
    ),
-    replayCapability,
-    calculationProfile,
    provenance: value.provenance,
  };
 }
@@ -1362,7 +1181,6 @@ export async function fetchObservationSessionCatalog({
    queryParameters.set("limit", String(Number(limit)));
  }
  if (scope !== "all") queryParameters.set("scope", scope);
-  if (scope === "laboratory") queryParameters.set("lab_contract", "v3");
  const serializedQuery = queryParameters.toString();
  const query = serializedQuery ? `?${serializedQuery}` : "";
  let response: Response;
@@ -1,72 +0,0 @@
-import {
-  decodeObservationSessionCatalog,
-  ObservationSessionApiError,
-  ObservationSessionContractError,
-  type ObservationSessionCatalog,
-  type ObservationSessionFetch,
-  type ObservationSessionScope,
-} from "./sessionArchive";
-
-const PAGE_SCHEMA = "missioncore.observation-session-page/v1";
-const CURSOR = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/;
-
-export interface ObservationSessionCatalogPage extends ObservationSessionCatalog {
-  readonly nextCursor: string | null;
-}
-
-/** Opt-in paging leaves the legacy catalog response and consumers unchanged. */
-export async function fetchObservationSessionCatalogPage({
-  scope,
-  limit = 100,
-  cursor = null,
-  signal,
-  fetcher = globalThis.fetch,
-}: {
-  scope: ObservationSessionScope;
-  limit?: number;
-  cursor?: string | null;
-  signal?: AbortSignal;
-  fetcher?: ObservationSessionFetch;
-}): Promise<ObservationSessionCatalogPage> {
-  if (!Number.isInteger(limit) || limit < 1 || limit > 100
-    || (cursor !== null && !CURSOR.test(cursor))) {
-    throw new ObservationSessionContractError("Некорректная страница каталога сессий.");
-  }
-  signal?.throwIfAborted();
-  const query = new URLSearchParams({ limit: String(limit), scope });
-  if (scope === "laboratory") query.set("lab_contract", "v3");
-  query.set("pagination", "cursor-v1");
-  if (cursor !== null) query.set("cursor", cursor);
-  const response = await fetcher(`/api/v1/observation-sessions?${query}`, {
-    method: "GET", headers: { Accept: "application/json" }, signal,
-  });
-  if (!response.ok) {
-    throw new ObservationSessionApiError(
-      `Не удалось загрузить страницу каталога сессий (HTTP ${response.status}).`,
-      response.status,
-    );
-  }
-  let body: unknown;
-  try {
-    body = await response.json();
-  } catch {
-    throw new ObservationSessionContractError("Некорректный ответ каталога сессий.");
-  }
-  if (typeof body !== "object" || body === null || Array.isArray(body)) {
-    throw new ObservationSessionContractError("Страница каталога должна быть объектом.");
-  }
-  const page = body as Record<string, unknown>;
-  if (Object.keys(page).length !== 3
-    || page.schema_version !== PAGE_SCHEMA
-    || !Object.hasOwn(page, "items")
-    || !(page.next_cursor === null
-      || (typeof page.next_cursor === "string" && CURSOR.test(page.next_cursor)))) {
-    throw new ObservationSessionContractError("Нарушен контракт страницы каталога сессий.");
-  }
-  const catalog = decodeObservationSessionCatalog({ items: page.items });
-  if (catalog.items.length > limit) {
-    throw new ObservationSessionContractError("Страница каталога превысила запрошенный размер.");
-  }
-  signal?.throwIfAborted();
-  return { ...catalog, nextCursor: page.next_cursor };
-}
@@ -12,16 +12,6 @@ import {
  type ObservationSessionScope,
  type ObservationSessionSummary,
 } from "./sessionArchive";
-import {
-  createObservationReplayCoordinator,
-  type ObservationReplayCoordinator,
-} from "./replayCoordinator";
-
-export {
-  createObservationReplayCoordinator,
-  type ObservationReplayAttempt,
-  type ObservationReplayCoordinator,
-} from "./replayCoordinator";

 export type ObservationSessionsLoadState = "idle" | "loading" | "ready" | "error";
 export type ObservationReplayOutcome = "accepted" | "error" | "cancelled";
@@ -51,6 +41,17 @@ export interface ObservationSessionsController {
  remove: (sessionId: string) => Promise<boolean>;
 }

+export interface ObservationReplayAttempt {
+  readonly signal: AbortSignal;
+  isCurrent: () => boolean;
+  finish: () => boolean;
+}
+
+export interface ObservationReplayCoordinator {
+  begin: () => ObservationReplayAttempt;
+  cancel: () => void;
+}
+
 export async function deleteObservationSessionAfterTeardown(
  sessionId: string,
  {
@@ -92,6 +93,41 @@ export class ObservationPreparationStalledError extends Error {
  }
 }

+/** Latest selection wins, even if an obsolete server job finishes later. */
+export function createObservationReplayCoordinator(): ObservationReplayCoordinator {
+  let sequence = 0;
+  let active: AbortController | null = null;
+
+  return {
+    begin() {
+      active?.abort();
+      const controller = new AbortController();
+      const attemptSequence = ++sequence;
+      active = controller;
+      return {
+        signal: controller.signal,
+        isCurrent: () => (
+          !controller.signal.aborted &&
+          active === controller &&
+          sequence === attemptSequence
+        ),
+        finish: () => {
+          if (active !== controller || sequence !== attemptSequence) return false;
+          active = null;
+          return true;
+        },
+      };
+    },
+    cancel() {
+      active?.abort();
+      // Keep ownership until the cancelled attempt reaches `finish()`. This
+      // lets its finally block settle a replacement that already passed
+      // onReplayBegin, while `isCurrent()` still fails immediately because the
+      // signal is aborted. A later `begin()` replaces and invalidates it.
+    },
+  };
+}
+
 function errorMessage(error: unknown): string {
  return error instanceof Error && error.message.trim()
    ? error.message
@@ -1,144 +0,0 @@
-import type { RecordedAdmissionPhase } from "./recordedSessionAdmission";
-
-export type RerunViewportStatus = "idle" | "loading" | "ready" | "error";
-export type RecordedRerunView = "spatial" | "perception" | "perception3d" | "metrics";
-
-export interface RerunPlaybackState {
-  recordingId: string;
-  timeline: string;
-  rangeNs: { min: number; max: number } | null;
-  currentNs: number;
-  playing: boolean;
-  bufferedEndNs: number | null;
-  expectedStartNs: number | null;
-  expectedEndNs: number | null;
-  bufferProgress: number | null;
-  fullyBuffered: boolean;
-}
-
-export interface RerunPlaybackController {
-  seek: (timeNs: number) => void;
-  setPlaying: (playing: boolean) => void;
-  jumpToEnd: () => void;
-}
-
-export interface RecordedPerceptionLayers {
-  enabled: boolean;
-  cameraImage?: boolean;
-  detections2d: boolean;
-  segmentation: boolean;
-  cuboids3d: boolean;
-  costmap?: boolean;
-}
-
-export interface RecordedRrdArtifactDescriptor {
-  sourceUrl: string;
-  viewerSourceUrl: string;
-  byteLength: number;
-  sha256: string;
-}
-
-/**
- * The native live receiver owns one acquisition lineage and never exposes
- * recorded transport or autoplay policy.
- */
-export interface LiveAcquisitionRerunProfile {
-  kind: "live-acquisition";
-  clock: "stream_time";
-  sourceUrl: string;
-  liveActivitySequence: number | null;
-  liveStreamId: string | null;
-  liveRecoveryAuthorityIdentity: string | null;
-}
-
-/**
- * A sealed session is progressively presentable, while its shared playback
- * controls remain fenced by the aggregate session admission gate.
- */
-export interface RecordedSessionRerunProfile {
-  kind: "recorded-session";
-  clock: "session_time";
-  sourceUrl: string;
-  artifact: RecordedRrdArtifactDescriptor | null;
-  autoplayWhenReady: boolean;
-  presentationGate: RecordedAdmissionPhase;
-  expectedTimelineStartSeconds?: number;
-  expectedTimelineEndSeconds?: number;
-  initialPlaybackStartSeconds?: number;
-  view: RecordedRerunView;
-  viewResetGeneration: 0 | 1;
-  followTrajectory: boolean;
-  perceptionLayers: RecordedPerceptionLayers;
-  /** Explicit small blueprint endpoint when the viewer source is a merged LAB RRD. */
-  blueprintSourceUrl?: string;
-  /** Optional immutable RRD sidecar for LAB/model evidence on the same recording clock. */
-  perceptionSourceUrl?: string;
-  /** Selects one semantic entity without changing the sealed sidecar. */
-  semanticLayer?: "city" | "vegetation";
-  /** Keeps one native Rerun store/viewer while presenting the accepted two-pane LAB layout. */
-  unifiedPerception?: boolean;
-  /** Controlled camera-column share for the native horizontal Rerun container. */
-  unifiedCameraShare?: number;
-  /** Requests the canonical top-down eye without changing the world coordinate frame. */
-  planView?: boolean;
-  perceptionRetryGeneration: number;
-  lockPerceptionCameraInteraction: boolean;
-}
-
-/** A LAB owns its result presentation; it does not inherit session-view settings. */
-export interface LaboratoryResultRerunProfile
-  extends Omit<RecordedSessionRerunProfile, "kind"> {
-  kind: "laboratory-result";
-  resultId: string;
-}
-
-/**
- * Deprecated comparison-only contract for LAB artifacts that have not yet
- * been republished as a native Rerun sidecar. It must never be selected by a
- * canonical LAB route or start work in the background.
- */
-export interface LaboratoryRecordedEvidenceViewerProfile {
-  kind: "lab-recorded-evidence";
-  clock: "source-sequence";
-  cameraTransport: "generation-bound-fmp4";
-  spatialTransport: "bounded-sealed-artifacts";
-  loadPolicy: "explicit-legacy-comparison-only";
-  workerRequired: false;
-}
-
-export type RerunViewerProfile =
-  | LiveAcquisitionRerunProfile
-  | RecordedSessionRerunProfile
-  | LaboratoryResultRerunProfile;
-
-export type ObservationViewerProfile =
-  | RerunViewerProfile
-  | LaboratoryRecordedEvidenceViewerProfile;
-
-export const LABORATORY_RECORDED_EVIDENCE_VIEWER_PROFILE = Object.freeze({
-  kind: "lab-recorded-evidence",
-  clock: "source-sequence",
-  cameraTransport: "generation-bound-fmp4",
-  spatialTransport: "bounded-sealed-artifacts",
-  loadPolicy: "explicit-legacy-comparison-only",
-  workerRequired: false,
-} satisfies LaboratoryRecordedEvidenceViewerProfile);
-
-export function liveAcquisitionRerunProfile(
-  input: Omit<LiveAcquisitionRerunProfile, "kind" | "clock">,
-): LiveAcquisitionRerunProfile {
-  return { ...input, kind: "live-acquisition", clock: "stream_time" };
-}
-
-export function recordedSessionRerunProfile(
-  input: Omit<RecordedSessionRerunProfile, "kind" | "clock">,
-): RecordedSessionRerunProfile {
-  return { ...input, kind: "recorded-session", clock: "session_time" };
-}
-
-export function laboratoryResultRerunProfile(
-  input: Omit<LaboratoryResultRerunProfile, "kind" | "clock">,
-): LaboratoryResultRerunProfile {
-  if (!input.resultId.trim()) throw new Error("LAB result identity is required");
-  return { ...input, kind: "laboratory-result", clock: "session_time" };
-}
@@ -1,347 +0,0 @@
-import {
-  decodeObservatoryRecordedJob,
-  type ObservatoryRecordedJob,
-} from "./recordedJobs";
-
-const COMPOSITION_SCHEMA = "missioncore.observatory-ai-composition/v1";
-const CATALOG_SCHEMA = "missioncore.observatory-ai-module-catalog/v1";
-const RECEIPT_SCHEMA = "missioncore.observatory-ai-composition-receipt/v3";
-const SHA256 = /^[a-f0-9]{64}$/;
-
-export type AIGroupId = "segmentation" | "detection" | "geometry" | "range" | "motion" | "policy";
-
-export interface AIModule {
-  readonly moduleId: string;
-  readonly moduleSha256: string;
-  readonly label: string;
-  readonly dockerName: string;
-  readonly requires: readonly string[];
-  readonly provides: readonly string[];
-  readonly defaults: Readonly<Record<string, unknown>>;
-}
-
-export interface AIModuleGroup {
-  readonly group: AIGroupId;
-  readonly modules: readonly AIModule[];
-}
-
-export interface AIModuleCatalog {
-  readonly groups: readonly AIModuleGroup[];
-}
-
-export interface AICompositionReceipt {
-  readonly compositionSha256: string;
-  readonly created: boolean;
-  readonly dispatchReady: boolean;
-  readonly dispatchReason: string;
-  readonly setupIds: readonly string[];
-  readonly jobs: readonly ObservatoryRecordedJob[];
-  readonly run: AICompositionRun;
-}
-
-export interface AIViewerLayer {
-  readonly layerId: string;
-  readonly paneId: "camera" | "spatial";
-  readonly label: string;
-  readonly control: "toggle" | "toggle-with-settings";
-  readonly order: number;
-}
-
-export interface AICompositionPresentation {
-  readonly configurationLabel: string;
-  readonly modules: readonly { readonly moduleId: string; readonly label: string }[];
-  readonly viewerLayers: readonly AIViewerLayer[];
-}
-
-export interface AICompositionRun {
-  readonly runId: string;
-  readonly sourceSessionId: string;
-  readonly compositionSha256: string;
-  readonly moduleIds: readonly string[];
-  readonly setupIds: readonly string[];
-  readonly jobIds: readonly string[];
-  readonly resultIds: readonly string[];
-  readonly createdAtUtc: string;
-  readonly state: "running" | "ready" | "failed";
-  readonly configurationLabel: string;
-  readonly displayName: string | null;
-  readonly presentation: AICompositionPresentation;
-  readonly jobs: readonly ObservatoryRecordedJob[];
-}
-
-export const AI_MODULE_SETUP_IDS: Readonly<Record<string, string>> = Object.freeze({
-  ddrnet: "ai-segmentation-ddrnet-v1",
-  eomt: "ai-segmentation-eomt-v1",
-  tgs: "m49-tgs-portable-v2",
-  "rf-detr": "ai-detection-rf-detr-v1",
-  "object-distance": "ai-range-object-distance-v1",
-});
-
-export function aiModuleIdForSetup(setupId: string): string | null {
-  return Object.entries(AI_MODULE_SETUP_IDS).find(([, value]) => value === setupId)?.[0] ?? null;
-}
-
-export async function fetchAIModuleCatalog(signal?: AbortSignal): Promise<AIModuleCatalog> {
-  const response = await fetch("/api/v1/observatory/ai-module-catalog", {
-    headers: { Accept: "application/json" }, signal,
-  });
-  const body = await bodyOf(response);
-  if (!response.ok) throw apiError(body, response.status);
-  const root = record(body, "каталог AI-модулей");
-  exactKeys(root, ["authority", "groups", "schema_version"]);
-  if (root.schema_version !== CATALOG_SCHEMA) throw new Error("Версия каталога AI-модулей изменилась.");
-  const known = new Set<AIGroupId>(["segmentation", "detection", "geometry", "range", "motion", "policy"]);
-  const groups = array(root.groups).map((value): AIModuleGroup => {
-    const group = record(value, "группа AI-модулей");
-    exactKeys(group, ["group", "modules"]);
-    if (typeof group.group !== "string" || !known.has(group.group as AIGroupId)) {
-      throw new Error("Каталог вернул неизвестную группу AI-модулей.");
-    }
-    return { group: group.group as AIGroupId, modules: array(group.modules).map(moduleOf) };
-  });
-  if (new Set(groups.map((group) => group.group)).size !== groups.length) {
-    throw new Error("Каталог AI-модулей содержит повторяющиеся группы.");
-  }
-  return { groups };
-}
-
-export async function saveAIComposition(
-  sourceSessionId: string,
-  selections: readonly { group: AIGroupId; module: AIModule }[],
-): Promise<AICompositionReceipt> {
-  const response = await fetch("/api/v1/observatory/ai-compositions", {
-    method: "POST",
-    headers: { Accept: "application/json", "Content-Type": "application/json" },
-    body: JSON.stringify({
-      schema_version: COMPOSITION_SCHEMA,
-      source_session_id: sourceSessionId,
-      idempotency_key: createIdempotencyKey(),
-      selections: selections.map(({ group, module }) => ({
-        group, module_id: module.moduleId, module_sha256: module.moduleSha256,
-        parameters: module.defaults,
-      })),
-    }),
-  });
-  const body = await bodyOf(response);
-  if (!response.ok) throw apiError(body, response.status);
-  const root = record(body, "конфигурация AI-слоя");
-  exactKeys(root, ["composition", "composition_sha256", "created", "dispatch", "run", "schema_version", "source_session_id"]);
-  if (root.schema_version !== RECEIPT_SCHEMA || root.source_session_id !== sourceSessionId) {
-    throw new Error("Сервер вернул конфигурацию для другой записи.");
-  }
-  const digest = text(root.composition_sha256);
-  if (!SHA256.test(digest)) throw new Error("Сервер вернул некорректную идентичность композиции.");
-  const dispatch = record(root.dispatch, "готовность композиции");
-  exactKeys(dispatch, ["jobs", "ready", "reason", "setup_ids"]);
-  if (dispatch.ready !== true) {
-    throw new Error(text(dispatch.reason));
-  }
-  const setupIds = array(dispatch.setup_ids).map(text);
-  const jobs = array(dispatch.jobs).map(decodeObservatoryRecordedJob);
-  if (!jobs.length || jobs.length !== setupIds.length
-    || jobs.some((job, index) => job.setupId !== setupIds[index])) {
-    throw new Error("Сервер вернул неполную очередь композиции.");
-  }
-  const run = compositionRunOf(root.run);
-  return {
-    compositionSha256: digest,
-    created: boolean(dispatch && root.created),
-    dispatchReady: boolean(dispatch.ready),
-    dispatchReason: text(dispatch.reason),
-    setupIds,
-    jobs,
-    run,
-  };
-}
-
-export async function fetchAICompositionRuns(
-  sourceSessionId: string,
-  signal?: AbortSignal,
-): Promise<readonly AICompositionRun[]> {
-  const query = new URLSearchParams({ source_session_id: sourceSessionId });
-  const response = await fetch(`/api/v1/observatory/ai-composition-runs?${query}`, {
-    headers: { Accept: "application/json" }, signal,
-  });
-  const body = await bodyOf(response);
-  if (!response.ok) throw apiError(body, response.status);
-  const root = record(body, "запуски композиций");
-  exactKeys(root, ["items", "schema_version"]);
-  if (root.schema_version !== "missioncore.observatory-ai-composition-run-list/v1") {
-    throw new Error("Версия запусков AI-композиций изменилась.");
-  }
-  return array(root.items).map(compositionRunOf);
-}
-
-export async function renameAICompositionRunProjection(
-  runId: string,
-  displayName: string,
-): Promise<string> {
-  if (!/^ai-composition-[a-f0-9]{64}$/.test(runId)) {
-    throw new Error("Некорректная идентичность результата AI Inference.");
-  }
-  const normalized = displayName.trim();
-  if (!normalized || normalized.length > 160) {
-    throw new Error("Название результата должно содержать от 1 до 160 символов.");
-  }
-  const response = await fetch(`/api/v1/observatory/ai-composition-runs/${encodeURIComponent(runId)}`, {
-    method: "PATCH",
-    headers: { Accept: "application/json", "Content-Type": "application/json" },
-    body: JSON.stringify({
-      schema_version: "missioncore.observatory-ai-composition-run-rename/v1",
-      display_name: normalized,
-    }),
-  });
-  const body = await bodyOf(response);
-  if (!response.ok) throw apiError(body, response.status);
-  const row = record(body, "результат AI Inference");
-  exactKeys(row, ["display_name", "run_id", "schema_version"]);
-  if (
-    row.schema_version !== "missioncore.observatory-ai-composition-run-projection/v1"
-    || row.run_id !== runId
-    || row.display_name !== normalized
-  ) throw new Error("Сервер не подтвердил переименование результата AI Inference.");
-  return normalized;
-}
-
-export async function deleteAICompositionRunProjection(runId: string): Promise<void> {
-  if (!/^ai-composition-[a-f0-9]{64}$/.test(runId)) {
-    throw new Error("Некорректная идентичность результата AI Inference.");
-  }
-  const response = await fetch(`/api/v1/observatory/ai-composition-runs/${encodeURIComponent(runId)}`, {
-    method: "DELETE",
-    headers: { Accept: "application/json" },
-  });
-  if (!response.ok || response.status !== 204) {
-    throw apiError(await bodyOf(response), response.status);
-  }
-}
-
-function compositionRunOf(value: unknown): AICompositionRun {
-  const row = record(value, "запуск AI-композиции");
-  const expected = [
-    "composition_sha256", "configuration_label", "created_at_utc", "display_name", "job_ids", "jobs",
-    "module_ids", "presentation", "result_ids", "run_id", "schema_version", "setup_ids",
-    "source_session_id", "state",
-  ];
-  // The receipt embeds the immutable run before its live state projection.
-  const receiptShape = [
-    "composition_sha256", "created_at_utc", "job_ids", "module_ids", "presentation",
-    "run_id", "schema_version", "setup_ids", "source_session_id",
-  ];
-  const keys = Object.keys(row);
-  const projected = keys.length === expected.length;
-  exactKeys(row, projected ? expected : receiptShape);
-  if (row.schema_version !== "missioncore.observatory-ai-composition-run/v1") {
-    throw new Error("Версия запуска AI-композиции изменилась.");
-  }
-  const sourceSessionId = text(row.source_session_id);
-  const compositionSha256 = text(row.composition_sha256);
-  const runId = text(row.run_id);
-  if (!/^ai-composition-[a-f0-9]{64}$/.test(runId) || !SHA256.test(compositionSha256)) {
-    throw new Error("Некорректная идентичность запуска AI-композиции.");
-  }
-  const presentation = presentationOf(row.presentation);
-  const state = projected ? text(row.state) : "running";
-  if (!new Set(["running", "ready", "failed"]).has(state)) {
-    throw new Error("Неизвестное состояние запуска AI-композиции.");
-  }
-  return {
-    runId,
-    sourceSessionId,
-    compositionSha256,
-    moduleIds: array(row.module_ids).map(text),
-    setupIds: array(row.setup_ids).map(text),
-    jobIds: array(row.job_ids).map(text),
-    resultIds: projected ? array(row.result_ids).map(text) : [],
-    createdAtUtc: text(row.created_at_utc),
-    state: state as AICompositionRun["state"],
-    configurationLabel: projected ? text(row.configuration_label) : presentation.configurationLabel,
-    displayName: projected
-      ? row.display_name === null ? null : text(row.display_name)
-      : null,
-    presentation,
-    jobs: projected ? array(row.jobs).map(decodeObservatoryRecordedJob) : [],
-  };
-}
-
-function presentationOf(value: unknown): AICompositionPresentation {
-  const row = record(value, "проекция AI-композиции");
-  exactKeys(row, ["configuration_label", "modules", "schema_version", "viewer_layers"]);
-  if (row.schema_version !== "missioncore.observatory-presentation-projection/v1") {
-    throw new Error("Версия проекции AI-композиции изменилась.");
-  }
-  const modules = array(row.modules).map((value) => {
-    const module = record(value, "модуль проекции");
-    exactKeys(module, ["label", "module_id"]);
-    return { moduleId: text(module.module_id), label: text(module.label) };
-  });
-  const viewerLayers = array(row.viewer_layers).map((value): AIViewerLayer => {
-    const layer = record(value, "слой viewer");
-    exactKeys(layer, ["control", "label", "layer_id", "order", "pane_id"]);
-    const paneId = text(layer.pane_id);
-    const control = text(layer.control);
-    if (!new Set(["camera", "spatial"]).has(paneId)
-      || !new Set(["toggle", "toggle-with-settings"]).has(control)
-      || typeof layer.order !== "number") {
-      throw new Error("Некорректная проекция слоя viewer.");
-    }
-    return {
-      layerId: text(layer.layer_id), paneId: paneId as AIViewerLayer["paneId"],
-      label: text(layer.label), control: control as AIViewerLayer["control"], order: layer.order,
-    };
-  });
-  return { configurationLabel: text(row.configuration_label), modules, viewerLayers };
-}
-
-export async function fetchAICompositionJobs(
-  sourceSessionId: string,
-  signal?: AbortSignal,
-): Promise<readonly ObservatoryRecordedJob[]> {
-  const query = new URLSearchParams({ source_session_id: sourceSessionId });
-  const response = await fetch(`/api/v1/observatory/ai-runs?${query}`, {
-    headers: { Accept: "application/json" }, signal,
-  });
-  const body = await bodyOf(response);
-  if (!response.ok) throw apiError(body, response.status);
-  const root = record(body, "очередь AI-слоёв");
-  exactKeys(root, ["authority", "items", "schema_version"]);
-  if (root.schema_version !== "missioncore.observatory-recorded-job-list/v1") {
-    throw new Error("Версия очереди AI-слоёв изменилась.");
-  }
-  return array(root.items).map(decodeObservatoryRecordedJob);
-}
-
-function moduleOf(value: unknown): AIModule {
-  const row = record(value, "AI-модуль");
-  exactKeys(row, ["defaults", "docker_name", "label", "module_id", "module_sha256", "parameter_choices", "provides", "requires"]);
-  const digest = text(row.module_sha256);
-  if (!SHA256.test(digest)) throw new Error("Каталог вернул некорректную версию AI-модуля.");
-  return {
-    moduleId: text(row.module_id), moduleSha256: digest, label: text(row.label),
-    dockerName: text(row.docker_name), requires: array(row.requires).map(text),
-    provides: array(row.provides).map(text), defaults: record(row.defaults, "параметры AI-модуля"),
-  };
-}
-
-function record(value: unknown, label: string): Record<string, unknown> {
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Некорректный ${label}.`);
-  return value as Record<string, unknown>;
-}
-function array(value: unknown): unknown[] { if (!Array.isArray(value)) throw new Error("Ожидался список."); return value; }
-function text(value: unknown): string { if (typeof value !== "string" || !value) throw new Error("Ожидался текст."); return value; }
-function boolean(value: unknown): boolean { if (typeof value !== "boolean") throw new Error("Ожидалось логическое значение."); return value; }
-function exactKeys(value: Record<string, unknown>, expected: string[]): void {
-  if (Object.keys(value).sort().join() !== [...expected].sort().join()) throw new Error("Контракт AI-слоя изменился.");
-}
-async function bodyOf(response: Response): Promise<unknown> { const value = await response.text(); try { return JSON.parse(value); } catch { return value; } }
-function apiError(body: unknown, status: number): Error {
-  const detail = body && typeof body === "object" && !Array.isArray(body) ? (body as Record<string, unknown>).detail : null;
-  return new Error(typeof detail === "string" ? detail : `Observatory API вернул HTTP ${status}.`);
-}
-
-function createIdempotencyKey(): string {
-  const entropy = typeof globalThis.crypto?.randomUUID === "function"
-    ? globalThis.crypto.randomUUID()
-    : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  return `ai-layer:${entropy}`;
-}
@@ -1,321 +0,0 @@
-import {
-  type ObservationLabInstance,
-  type ObservationSessionFetch,
-  type ObservationSessionSummary,
-} from "../observation/sessionArchive";
-import { fetchObservationSessionCatalogPage } from "../observation/sessionCatalogPage";
-import {
-  observatoryRecordedRunBinding,
-  type ObservatoryRecordedRunBinding,
-} from "./recordedRun";
-
-export interface ObservatoryEvidence {
-  readonly sessionId: string;
-  readonly label: string;
-  readonly status: ObservationSessionSummary["status"];
-  readonly publishedAtUtc: string;
-  readonly lab: ObservationLabInstance;
-  readonly recordedRun: ObservatoryRecordedRunBinding | null;
-}
-
-export interface ObservatorySession {
-  readonly source: ObservationSessionSummary;
-  readonly evidence: readonly ObservatoryEvidence[];
-}
-
-export interface ObservatoryCatalog {
-  readonly items: readonly ObservatorySession[];
-  readonly unresolvedEvidence: readonly ObservatoryEvidence[];
-  readonly window: {
-    readonly limit: number;
-    readonly sourceCount: number;
-    readonly laboratoryCount: number;
-    readonly sourceLimitReached: boolean;
-    readonly laboratoryLimitReached: boolean;
-  };
-}
-
-export type ObservatoryCatalogMutation =
-  | {
-      readonly kind: "rename";
-      readonly displayName: string;
-      readonly revision: number;
-    }
-  | {
-      readonly kind: "delete";
-      readonly revision: number;
-    };
-
-export type ObservatoryCatalogMutationOverlay = ReadonlyMap<
-  string,
-  ObservatoryCatalogMutation
->;
-
-export interface ObservatoryCatalogReconciliation {
-  readonly catalog: ObservatoryCatalog;
-  readonly overlay: ObservatoryCatalogMutationOverlay;
-}
-
-export class ObservatoryCatalogContractError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "ObservatoryCatalogContractError";
-  }
-}
-
-export function findObservatoryEvidence(
-  catalog: ObservatoryCatalog,
-  sessionId: string,
-): ObservatoryEvidence | null {
-  for (const item of catalog.items) {
-    const evidence = item.evidence.find(
-      (candidate) => candidate.sessionId === sessionId,
-    );
-    if (evidence) return evidence;
-  }
-  return catalog.unresolvedEvidence.find(
-    (candidate) => candidate.sessionId === sessionId,
-  ) ?? null;
-}
-
-export function observatoryCatalogConfirmsEvidenceDeletion(
-  catalog: ObservatoryCatalog,
-  sessionId: string,
-): boolean {
-  return !catalog.window.laboratoryLimitReached
-    && findObservatoryEvidence(catalog, sessionId) === null;
-}
-
-export function applyObservatoryCatalogMutationOverlay(
-  catalog: ObservatoryCatalog,
-  overlay: ObservatoryCatalogMutationOverlay,
-): ObservatoryCatalog {
-  if (overlay.size === 0) return catalog;
-
-  const removedSessionIds = new Set<string>();
-  const projectEvidence = (
-    evidence: ObservatoryEvidence,
-  ): ObservatoryEvidence | null => {
-    const mutation = overlay.get(evidence.sessionId);
-    if (!mutation) return evidence;
-    if (mutation.kind === "delete") {
-      removedSessionIds.add(evidence.sessionId);
-      return null;
-    }
-    return evidence.label === mutation.displayName
-      ? evidence
-      : { ...evidence, label: mutation.displayName };
-  };
-  const projectEvidenceList = (
-    evidence: readonly ObservatoryEvidence[],
-  ): ObservatoryEvidence[] => evidence.flatMap((candidate) => {
-    const projected = projectEvidence(candidate);
-    return projected ? [projected] : [];
-  });
-
-  const items = catalog.items.map((item) => ({
-    ...item,
-    evidence: projectEvidenceList(item.evidence),
-  }));
-  const unresolvedEvidence = projectEvidenceList(catalog.unresolvedEvidence);
-  return {
-    ...catalog,
-    items,
-    unresolvedEvidence,
-    window: {
-      ...catalog.window,
-      laboratoryCount: Math.max(
-        0,
-        catalog.window.laboratoryCount - removedSessionIds.size,
-      ),
-    },
-  };
-}
-
-export function reconcileObservatoryCatalogMutationOverlay(
-  serverCatalog: ObservatoryCatalog,
-  overlay: ObservatoryCatalogMutationOverlay,
-  requestMutationRevision: number,
-): ObservatoryCatalogReconciliation {
-  const remaining = new Map(overlay);
-  for (const [sessionId, mutation] of overlay) {
-    if (mutation.revision > requestMutationRevision) continue;
-    const evidence = findObservatoryEvidence(serverCatalog, sessionId);
-    const confirmed = mutation.kind === "rename"
-      ? evidence?.label === mutation.displayName
-      : observatoryCatalogConfirmsEvidenceDeletion(serverCatalog, sessionId);
-    if (confirmed) remaining.delete(sessionId);
-  }
-  return {
-    catalog: applyObservatoryCatalogMutationOverlay(serverCatalog, remaining),
-    overlay: remaining,
-  };
-}
-
-function newestFirst(left: string, right: string): number {
-  return Date.parse(right) - Date.parse(left);
-}
-
-function boundedLimit(limit: number): number {
-  return Number.isFinite(limit)
-    ? Math.min(100, Math.max(1, Math.floor(limit)))
-    : 100;
-}
-
-function evidenceFromSession(
-  session: ObservationSessionSummary,
-): ObservatoryEvidence | null {
-  if (!session.lab) {
-    throw new ObservatoryCatalogContractError(
-      `LAB-каталог вернул сессию ${session.id} без типизированной связи с источником.`,
-    );
-  }
-  // Historical LABs retain their archive and replay adapters. Observatory is
-  // the portable-profile product; a familiar LAB label is not admission.
-  if (session.lab.replayCapability?.kind !== "portable-result-review") return null;
-  const recordedRun = observatoryRecordedRunBinding(session.id, session.lab);
-  return {
-    sessionId: session.id,
-    label: session.label,
-    status: session.status,
-    publishedAtUtc: session.lab.publishedAtUtc,
-    lab: session.lab,
-    recordedRun,
-  };
-}
-
-function sortEvidence(
-  evidence: readonly ObservatoryEvidence[],
-): ObservatoryEvidence[] {
-  return [...evidence].sort((left, right) =>
-    newestFirst(left.publishedAtUtc, right.publishedAtUtc)
-      || left.sessionId.localeCompare(right.sessionId));
-}
-
-export function buildObservatoryCatalog(
-  sourceSessions: readonly ObservationSessionSummary[],
-  laboratorySessions: readonly ObservationSessionSummary[],
-  limit = 100,
-): ObservatoryCatalog {
-  const safeLimit = boundedLimit(limit);
-  const sources = new Map<string, ObservationSessionSummary>();
-  for (const source of sourceSessions) {
-    if (source.lab !== null) {
-      throw new ObservatoryCatalogContractError(
-        `Каталог источников вернул LAB-сессию ${source.id}.`,
-      );
-    }
-    sources.set(source.id, source);
-  }
-
-  const linked = new Map<string, ObservatoryEvidence[]>();
-  const unresolvedEvidence: ObservatoryEvidence[] = [];
-  for (const laboratorySession of laboratorySessions) {
-    const evidence = evidenceFromSession(laboratorySession);
-    if (!evidence) continue;
-    const sourceId = evidence.lab.sourceSessionId;
-    if (!sources.has(sourceId)) {
-      // A bounded traversal may stop before this source. Absence alone is
-      // not proof of a broken relationship or permission to remove data.
-      unresolvedEvidence.push(evidence);
-      continue;
-    }
-    const current = linked.get(sourceId) ?? [];
-    current.push(evidence);
-    linked.set(sourceId, current);
-  }
-
-  const items = [...sources.values()]
-    .sort((left, right) =>
-      newestFirst(left.startedAtUtc, right.startedAtUtc)
-        || left.id.localeCompare(right.id))
-    .map((source) => ({
-      source,
-      evidence: sortEvidence(linked.get(source.id) ?? []),
-    }));
-
-  return {
-    items,
-    unresolvedEvidence: sortEvidence(unresolvedEvidence),
-    window: {
-      limit: safeLimit,
-      sourceCount: sourceSessions.length,
-      laboratoryCount: [...linked.values()].reduce((count, items) => count + items.length, 0)
-        + unresolvedEvidence.length,
-      sourceLimitReached: sourceSessions.length >= safeLimit,
-      laboratoryLimitReached: laboratorySessions.length >= safeLimit,
-    },
-  };
-}
-
-export async function fetchObservatoryCatalog({
-  signal,
-  limit = 100,
-  fetcher = globalThis.fetch,
-}: {
-  signal?: AbortSignal;
-  limit?: number;
-  fetcher?: ObservationSessionFetch;
-} = {}): Promise<ObservatoryCatalog> {
-  const safeLimit = boundedLimit(limit);
-  const request = new AbortController();
-  const abort = () => request.abort(signal?.reason);
-  if (signal?.aborted) abort();
-  else signal?.addEventListener("abort", abort, { once: true });
-  try {
-    const [sources, laboratories] = await Promise.all([
-      readCatalogPages("source", safeLimit, fetcher, request.signal),
-      readCatalogPages("laboratory", safeLimit, fetcher, request.signal),
-    ]);
-    const catalog = buildObservatoryCatalog(sources.items, laboratories.items, safeLimit);
-    return {
-      ...catalog,
-      window: {
-        ...catalog.window,
-        sourceLimitReached: sources.hasMore,
-        laboratoryLimitReached: laboratories.hasMore,
-      },
-    };
-  } finally {
-    request.abort();
-    signal?.removeEventListener("abort", abort);
-  }
-}
-
-// Metadata only, never recordings or result artifacts. The cap is an explicit
-// partial window, not silent completeness or an unbounded background crawler.
-const MAX_CATALOG_PAGES = 256;
-
-async function readCatalogPages(
-  scope: "source" | "laboratory",
-  limit: number,
-  fetcher: ObservationSessionFetch,
-  signal: AbortSignal,
-): Promise<{ items: ObservationSessionSummary[]; hasMore: boolean }> {
-  const items: ObservationSessionSummary[] = [];
-  const seenIds = new Set<string>();
-  const cursors = new Set<string>();
-  let cursor: string | null = null;
-  for (let index = 0; index < MAX_CATALOG_PAGES; index += 1) {
-    const page = await fetchObservationSessionCatalogPage({ scope, limit, cursor, signal, fetcher });
-    for (const item of page.items) {
-      if (seenIds.has(item.id)) {
-        throw new ObservatoryCatalogContractError("Каталог повторил сессию между страницами.");
-      }
-      seenIds.add(item.id);
-      // Do not accumulate legacy provenance while walking the shared catalog.
-      if (scope === "source" || item.lab?.replayCapability?.kind === "portable-result-review") {
-        items.push(item);
-      } else if (!item.lab) {
-        throw new ObservatoryCatalogContractError("LAB-каталог вернул исходную сессию.");
-      }
-    }
-    cursor = page.nextCursor;
-    if (cursor === null) return { items, hasMore: false };
-    if (cursors.has(cursor)) {
-      throw new ObservatoryCatalogContractError("Каталог повторил курсор страницы.");
-    }
-    cursors.add(cursor);
-  }
-  return { items, hasMore: true };
-}
@@ -1,210 +0,0 @@
-import type { ObservatoryRecordedRunBinding } from "./recordedRun";
-
-const SAFE_SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
-const RENAME_SCHEMA = "missioncore.observatory-lab-projection-rename/v1";
-const PROJECTION_SCHEMA = "missioncore.observatory-lab-projection/v1";
-
-export type ObservatoryCatalogMutationFetch = (
-  input: RequestInfo | URL,
-  init?: RequestInit,
-) => Promise<Response>;
-
-export interface ObservatoryLabProjectionMutationResult {
-  readonly schemaVersion: typeof PROJECTION_SCHEMA;
-  readonly sessionId: string;
-  readonly displayName: string;
-}
-
-export class ObservatoryCatalogMutationError extends Error {
-  readonly status: number | null;
-
-  constructor(message: string, status: number | null = null) {
-    super(message);
-    this.name = "ObservatoryCatalogMutationError";
-    this.status = status;
-  }
-}
-
-export async function renameObservatoryLabProjection(
-  binding: ObservatoryRecordedRunBinding,
-  displayName: string,
-  {
-    signal,
-    fetcher = globalThis.fetch,
-  }: {
-    signal?: AbortSignal;
-    fetcher?: ObservatoryCatalogMutationFetch;
-  } = {},
-): Promise<ObservatoryLabProjectionMutationResult> {
-  const sessionId = admittedProjectionId(binding);
-  const normalizedName = displayName.trim();
-  if (normalizedName.length < 1 || normalizedName.length > 160) {
-    throw new ObservatoryCatalogMutationError(
-      "Название лабораторного результата должно содержать от 1 до 160 символов.",
-    );
-  }
-  const response = await request(
-    fetcher,
-    `/api/v1/observatory/lab-projections/${encodeURIComponent(sessionId)}`,
-    {
-      method: "PATCH",
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        schema_version: RENAME_SCHEMA,
-        display_name: normalizedName,
-      }),
-      signal,
-    },
-    "Не удалось переименовать лабораторный результат.",
-  );
-  const body = await responseBody(response);
-  if (!response.ok || response.status !== 200) {
-    throw apiError(
-      body,
-      `Переименование лабораторного результата вернуло HTTP ${response.status}.`,
-      response.status,
-    );
-  }
-  const decoded = decodeProjection(body);
-  if (decoded.sessionId !== sessionId || decoded.displayName !== normalizedName) {
-    throw new ObservatoryCatalogMutationError(
-      "Сервер не подтвердил точное переименование выбранного результата.",
-    );
-  }
-  return decoded;
-}
-
-export async function deleteObservatoryLabProjection(
-  binding: ObservatoryRecordedRunBinding,
-  {
-    signal,
-    fetcher = globalThis.fetch,
-  }: {
-    signal?: AbortSignal;
-    fetcher?: ObservatoryCatalogMutationFetch;
-  } = {},
-): Promise<void> {
-  const sessionId = admittedProjectionId(binding);
-  const response = await request(
-    fetcher,
-    `/api/v1/observatory/lab-projections/${encodeURIComponent(sessionId)}`,
-    {
-      method: "DELETE",
-      headers: { Accept: "application/json" },
-      signal,
-    },
-    "Не удалось удалить лабораторный результат из AI Inference.",
-  );
-  const body = await responseBody(response);
-  if (!response.ok || response.status !== 204) {
-    throw apiError(
-      body,
-      `Удаление лабораторного результата вернуло HTTP ${response.status}.`,
-      response.status,
-    );
-  }
-  if (body !== undefined) {
-    throw new ObservatoryCatalogMutationError(
-      "Сервер вернул данные после подтверждённого удаления лабораторного результата.",
-    );
-  }
-}
-
-function admittedProjectionId(binding: ObservatoryRecordedRunBinding): string {
-  const sessionId = binding.evidenceSessionId;
-  const admittedViewer = (
-    binding.kind === "canonical-recorded-rerun"
-    && binding.viewerProfile === "recorded-session"
-    && binding.timeline === "session_time"
-  ) || (
-    binding.kind === "portable-result-review"
-    && binding.viewerProfile === "portable-result"
-    && binding.timeline === "result-defined"
-  );
-  if (
-    !admittedViewer
-    || binding.activation !== "explicit"
-    || binding.resultId !== sessionId
-    || binding.sourceSessionId === sessionId
-    || !SAFE_SESSION_ID.test(sessionId)
-  ) {
-    throw new ObservatoryCatalogMutationError(
-      "Выбранный результат не допущен к изменению каталога AI Inference.",
-    );
-  }
-  return sessionId;
-}
-
-async function request(
-  fetcher: ObservatoryCatalogMutationFetch,
-  input: string,
-  init: RequestInit,
-  fallback: string,
-): Promise<Response> {
-  try {
-    return await fetcher(input, init);
-  } catch (error) {
-    if (error instanceof DOMException && error.name === "AbortError") throw error;
-    throw new ObservatoryCatalogMutationError(fallback);
-  }
-}
-
-async function responseBody(response: Response): Promise<unknown> {
-  const text = await response.text();
-  if (!text) return undefined;
-  try {
-    return JSON.parse(text) as unknown;
-  } catch {
-    return text;
-  }
-}
-
-function apiError(body: unknown, fallback: string, status: number): Error {
-  if (isRecord(body) && typeof body.detail === "string" && body.detail.trim()) {
-    return new ObservatoryCatalogMutationError(body.detail.trim(), status);
-  }
-  if (typeof body === "string" && body.trim()) {
-    return new ObservatoryCatalogMutationError(body.trim(), status);
-  }
-  return new ObservatoryCatalogMutationError(fallback, status);
-}
-
-function decodeProjection(value: unknown): ObservatoryLabProjectionMutationResult {
-  if (!isRecord(value)) {
-    throw new ObservatoryCatalogMutationError(
-      "Сервер вернул некорректное подтверждение лабораторного результата.",
-    );
-  }
-  const keys = Object.keys(value).sort();
-  const expected = ["display_name", "schema_version", "session_id"];
-  if (keys.length !== expected.length || keys.some((key, index) => key !== expected[index])) {
-    throw new ObservatoryCatalogMutationError(
-      "Подтверждение лабораторного результата содержит неизвестные поля.",
-    );
-  }
-  if (
-    value.schema_version !== PROJECTION_SCHEMA
-    || typeof value.session_id !== "string"
-    || !SAFE_SESSION_ID.test(value.session_id)
-    || typeof value.display_name !== "string"
-    || value.display_name.trim() !== value.display_name
-    || value.display_name.length < 1
-    || value.display_name.length > 160
-  ) {
-    throw new ObservatoryCatalogMutationError(
-      "Сервер вернул неподдерживаемый контракт лабораторного результата.",
-    );
-  }
-  return {
-    schemaVersion: PROJECTION_SCHEMA,
-    sessionId: value.session_id,
-    displayName: value.display_name,
-  };
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
@@ -1,104 +0,0 @@
-import type { SceneSettings } from "../../sceneSettings";
-
-const PROFILE_SCHEMA = "missioncore.observatory-lab-view-profile/v1";
-
-export async function fetchLabViewProfile(
-  resultId: string,
-  signal?: AbortSignal,
-): Promise<SceneSettings | null> {
-  const response = await fetch(`/api/v1/observatory/lab-view-profiles/${encodeURIComponent(resultId)}`, {
-    headers: { Accept: "application/json" },
-    signal,
-  });
-  if (response.status === 404) return null;
-  const body: unknown = await response.json();
-  if (!response.ok) throw new Error("Профиль отображения LAB не загрузился.");
-  return decodeProfile(body, resultId);
-}
-
-export async function saveLabViewProfile(
-  resultId: string,
-  settings: SceneSettings,
-  signal?: AbortSignal,
-): Promise<SceneSettings> {
-  const response = await fetch(`/api/v1/observatory/lab-view-profiles/${encodeURIComponent(resultId)}`, {
-    method: "PUT",
-    headers: { Accept: "application/json", "Content-Type": "application/json" },
-    body: JSON.stringify({
-      schema_version: PROFILE_SCHEMA,
-      result_id: resultId,
-      scene_settings: {
-        point_size: settings.pointSize,
-        accumulation_seconds: settings.accumulationSeconds,
-        color_mode: settings.colorMode,
-        palette: settings.palette,
-        show_grid: settings.showGrid,
-        show_labels: settings.showLabels,
-        show_camera_frustums: settings.showCameraFrustums,
-      },
-    }),
-    signal,
-  });
-  const body: unknown = await response.json();
-  if (!response.ok) throw new Error("Настройки LAB не сохранились. Повторите закрытие окна.");
-  return decodeProfile(body, resultId);
-}
-
-function decodeProfile(value: unknown, expectedResultId: string): SceneSettings {
-  const row = record(value);
-  exactKeys(row, ["result_id", "scene_settings", "schema_version", "updated_at_utc"]);
-  if (row.schema_version !== PROFILE_SCHEMA || row.result_id !== expectedResultId) {
-    throw new Error("Сервер вернул профиль другой LAB.");
-  }
-  const settings = record(row.scene_settings);
-  exactKeys(settings, [
-    "accumulation_seconds", "color_mode", "palette", "point_size",
-    "show_camera_frustums", "show_grid", "show_labels",
-  ]);
-  const pointSize = finite(settings.point_size);
-  const accumulationSeconds = finite(settings.accumulation_seconds);
-  const colorMode = settings.color_mode;
-  const palette = settings.palette;
-  if (
-    pointSize < 0.1
-    || accumulationSeconds < 0
-    || !new Set(["intensity", "height", "distance", "rgb", "class"]).has(String(colorMode))
-    || !new Set(["turbo", "viridis", "plasma", "grayscale"]).has(String(palette))
-    || typeof settings.show_grid !== "boolean"
-    || typeof settings.show_labels !== "boolean"
-    || typeof settings.show_camera_frustums !== "boolean"
-  ) throw new Error("Сервер вернул повреждённый профиль LAB.");
-  return {
-    projection: "3d",
-    pointSize,
-    colorMode: colorMode as SceneSettings["colorMode"],
-    palette: palette as SceneSettings["palette"],
-    customColor: "#35d7c1",
-    accumulationSeconds,
-    showPoints: true,
-    showTrajectory: true,
-    showGrid: settings.show_grid,
-    showLabels: settings.show_labels,
-    showCameraFrustums: settings.show_camera_frustums,
-  };
-}
-
-function record(value: unknown): Record<string, unknown> {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("Некорректный профиль отображения LAB.");
-  }
-  return value as Record<string, unknown>;
-}
-
-function finite(value: unknown): number {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new Error("Некорректное числовое значение профиля LAB.");
-  }
-  return value;
-}
-
-function exactKeys(value: Record<string, unknown>, expected: string[]): void {
-  if (Object.keys(value).sort().join() !== [...expected].sort().join()) {
-    throw new Error("Контракт профиля отображения LAB изменился.");
-  }
-}
@@ -1,449 +0,0 @@
-export { fetchObservatoryPortableLaboratorySetups } from "./portableLaboratorySetups";
-
-const CATALOG_SCHEMA = "missioncore.observatory-laboratory-setup-catalog/v1";
-const PREFLIGHT_REQUEST_SCHEMA = "missioncore.observatory-run-preflight-request/v1";
-const PREFLIGHT_SCHEMA = "missioncore.observatory-run-preflight/v1";
-const SHA256 = /^[a-f0-9]{64}$/;
-
-export type ObservatoryLaboratorySetupOrigin =
-  | "archived-definition"
-  | "existing-result"
-  | "portable-definition";
-export type ObservatoryLaboratorySetupAction =
-  | "open-existing"
-  | "open-legacy"
-  | "check"
-  | "blocked";
-
-export interface ObservatoryLaboratoryRunDefinition {
-  readonly definitionId: string;
-  readonly version: number;
-  readonly workId: string | null;
-  readonly definitionSha256: string;
-  readonly resultSchema: string | null;
-  readonly resultKind: string | null;
-  readonly models: readonly {
-    readonly name: string;
-    readonly releaseId: string;
-    readonly modelId: string;
-    readonly architecture: string;
-  }[];
-  readonly configuration: readonly {
-    readonly role: string;
-    readonly sha256: string;
-  }[];
-}
-
-export interface ObservatoryLaboratoryPreservedResult {
-  readonly resultId: string;
-  readonly resultKind: string;
-  readonly relation: string;
-  readonly access: "legacy-lab" | "observatory" | "evidence-only";
-  readonly createdAtUtc: string;
-  readonly observatoryProjectionAvailable: boolean;
-}
-
-export interface ObservatoryLaboratorySetup {
-  readonly setupId: string;
-  readonly displayName: string;
-  readonly description: string;
-  readonly origin: ObservatoryLaboratorySetupOrigin;
-  readonly runDefinition: ObservatoryLaboratoryRunDefinition | null;
-  readonly compatibility: {
-    readonly compatible: boolean;
-    readonly reasons: readonly { readonly code: string; readonly message: string }[];
-  };
-  readonly executor: {
-    readonly contourId: string;
-    readonly state: "not-installed" | "ready";
-    readonly reasonCode: string;
-    readonly reason: string;
-  };
-  readonly preservedResults: readonly ObservatoryLaboratoryPreservedResult[];
-  readonly preflight: {
-    readonly outcome: "existing" | "ready" | "blocked";
-    readonly action: ObservatoryLaboratorySetupAction;
-    readonly reason: string;
-    readonly submissionAllowed: boolean;
-    readonly existingResultIds: readonly string[];
-  };
-}
-
-export interface ObservatoryLaboratorySetupCatalog {
-  readonly sourceSessionId: string;
-  readonly setups: readonly ObservatoryLaboratorySetup[];
-}
-
-// Cache identity is verified by the portable catalog decoder/server, never by a LAB label.
-export function selectableObservatorySetups(catalog: ObservatoryLaboratorySetupCatalog | null) {
-  return catalog?.setups.filter((setup) => (
-    setup.origin === "portable-definition"
-    && setup.runDefinition !== null
-    && setup.compatibility.compatible
-    && setup.preflight.outcome !== "existing"
-  )) ?? [];
-}
-
-export interface ObservatoryLaboratoryRunPreflight {
-  readonly sourceSessionId: string;
-  readonly setupId: string;
-  readonly definitionSha256: string | null;
-  readonly checkSha256: string | null;
-  readonly outcome: "existing" | "queueable" | "blocked";
-  readonly submissionAllowed: boolean;
-  readonly checks: readonly {
-    readonly checkId: string;
-    readonly outcome: "pass" | "fail" | "not-applicable";
-    readonly reasonCode: string;
-    readonly message: string;
-  }[];
-  readonly existingResultIds: readonly string[];
-}
-
-export type ObservatoryLaboratorySetupFetch = (
-  input: RequestInfo | URL,
-  init?: RequestInit,
-) => Promise<Response>;
-
-export class ObservatoryLaboratorySetupContractError extends Error {
-  readonly status: number | null;
-
-  constructor(message: string, status: number | null = null) {
-    super(message);
-    this.name = "ObservatoryLaboratorySetupContractError";
-    this.status = status;
-  }
-}
-
-export async function fetchObservatoryLaboratorySetups(
-  sourceSessionId: string,
-  {
-    signal,
-    fetcher = globalThis.fetch,
-  }: {
-    signal?: AbortSignal;
-    fetcher?: ObservatoryLaboratorySetupFetch;
-  } = {},
-): Promise<ObservatoryLaboratorySetupCatalog> {
-  const response = await request(
-    fetcher,
-    `/api/v1/observatory/laboratory-setups?source_session_id=${encodeURIComponent(sourceSessionId)}`,
-    { method: "GET", headers: { Accept: "application/json" }, signal },
-  );
-  const body = await responseBody(response);
-  if (!response.ok) throw apiError(body, response.status);
-  const catalog = decodeCatalog(body);
-  if (catalog.sourceSessionId !== sourceSessionId) {
-    throw new ObservatoryLaboratorySetupContractError(
-      "Каталог сетапов относится к другой исходной сессии.",
-    );
-  }
-  return catalog;
-}
-
-export async function preflightObservatoryLaboratorySetup(
-  sourceSessionId: string,
-  setup: ObservatoryLaboratorySetup,
-  {
-    signal,
-    fetcher = globalThis.fetch,
-  }: {
-    signal?: AbortSignal;
-    fetcher?: ObservatoryLaboratorySetupFetch;
-  } = {},
-): Promise<ObservatoryLaboratoryRunPreflight> {
-  const response = await request(
-    fetcher,
-    "/api/v1/observatory/run-preflights",
-    {
-      method: "POST",
-      headers: { Accept: "application/json", "Content-Type": "application/json" },
-      body: JSON.stringify({
-        schema_version: PREFLIGHT_REQUEST_SCHEMA,
-        source_session_id: sourceSessionId,
-        setup_id: setup.setupId,
-        definition_sha256: setup.runDefinition?.definitionSha256 ?? null,
-      }),
-      signal,
-    },
-  );
-  const body = await responseBody(response);
-  if (!response.ok) throw apiError(body, response.status);
-  const preflight = decodePreflight(body);
-  if (preflight.sourceSessionId !== sourceSessionId || preflight.setupId !== setup.setupId) {
-    throw new ObservatoryLaboratorySetupContractError(
-      "Preflight относится к другому источнику или сетапу.",
-    );
-  }
-  if (preflight.definitionSha256 !== (setup.runDefinition?.definitionSha256 ?? null)) {
-    throw new ObservatoryLaboratorySetupContractError(
-      "Preflight относится к другой версии сетапа.",
-    );
-  }
-  return preflight;
-}
-
-function decodeCatalog(value: unknown): ObservatoryLaboratorySetupCatalog {
-  const row = record(value, "каталог сетапов");
-  exactKeys(row, ["authority", "schema_version", "setups", "source_session_id"], "каталог сетапов");
-  exact(row.schema_version, CATALOG_SCHEMA, "schema_version каталога сетапов");
-  observationAuthority(row.authority);
-  return {
-    sourceSessionId: text(row.source_session_id, "source_session_id"),
-    setups: array(row.setups, "setups").map(decodeSetup),
-  };
-}
-
-function decodeSetup(value: unknown): ObservatoryLaboratorySetup {
-  const row = record(value, "сетап");
-  exactKeys(row, [
-    "authority", "compatibility", "description", "display_name", "executor", "origin",
-    "preflight", "preserved_results", "run_definition", "setup_id", "source",
-  ], "сетап");
-  observationAuthority(row.authority);
-  const origin = oneOf(row.origin, ["archived-definition", "existing-result"] as const, "origin");
-  const compatibility = record(row.compatibility, "compatibility");
-  const executor = record(row.executor, "executor");
-  const preflight = record(row.preflight, "preflight");
-  const source = record(row.source, "source");
-  const runDefinition = row.run_definition === null
-    ? null
-    : decodeRunDefinition(row.run_definition);
-  if ((origin === "archived-definition") !== (runDefinition !== null)) {
-    throw new ObservatoryLaboratorySetupContractError(
-      "Происхождение сетапа не совпадает с RunDefinition.",
-    );
-  }
-  exactKeys(source, ["label", "required_modalities", "session_id"], "source");
-  text(source.session_id, "source.session_id");
-  text(source.label, "source.label");
-  array(source.required_modalities, "source.required_modalities").forEach((item) => text(item, "source modality"));
-  exactKeys(compatibility, ["compatible", "reasons"], "compatibility");
-  exactKeys(executor, ["contour_id", "reason", "reason_code", "state"], "executor");
-  exactKeys(preflight, ["action", "existing_result_ids", "outcome", "reason", "submission_allowed"], "preflight");
-  return {
-    setupId: text(row.setup_id, "setup_id"),
-    displayName: text(row.display_name, "display_name"),
-    description: text(row.description, "description"),
-    origin,
-    runDefinition,
-    compatibility: {
-      compatible: boolean(row.compatibility && compatibility.compatible, "compatible"),
-      reasons: array(compatibility.reasons, "compatibility.reasons").map((item) => {
-        const reason = record(item, "compatibility reason");
-        exactKeys(reason, ["code", "message"], "compatibility reason");
-        return { code: text(reason.code, "reason.code"), message: text(reason.message, "reason.message") };
-      }),
-    },
-    executor: {
-      contourId: text(executor.contour_id, "executor.contour_id"),
-      state: exact(executor.state, "not-installed", "executor.state"),
-      reasonCode: text(executor.reason_code, "executor.reason_code"),
-      reason: text(executor.reason, "executor.reason"),
-    },
-    preservedResults: array(row.preserved_results, "preserved_results").map(decodePreservedResult),
-    preflight: {
-      outcome: oneOf(preflight.outcome, ["existing", "blocked"] as const, "preflight.outcome"),
-      action: oneOf(preflight.action, ["open-existing", "open-legacy", "blocked"] as const, "preflight.action"),
-      reason: text(preflight.reason, "preflight.reason"),
-      submissionAllowed: exact(preflight.submission_allowed, false, "preflight.submission_allowed"),
-      existingResultIds: array(preflight.existing_result_ids, "preflight.existing_result_ids").map((item) => text(item, "existing result id")),
-    },
-  };
-}
-
-function decodeRunDefinition(value: unknown): ObservatoryLaboratoryRunDefinition {
-  const row = record(value, "RunDefinition");
-  exactKeys(row, [
-    "authority", "configuration", "definition_id", "definition_sha256", "schema_version",
-    "source", "version", "work_id",
-  ], "RunDefinition");
-  exact(row.schema_version, "missioncore.observatory-run-definition/v1", "RunDefinition schema");
-  observationAuthority(row.authority);
-  const source = record(row.source, "RunDefinition source");
-  exactKeys(source, ["label", "required_modalities", "session_id"], "RunDefinition source");
-  text(source.session_id, "RunDefinition source.session_id");
-  text(source.label, "RunDefinition source.label");
-  array(source.required_modalities, "RunDefinition source.required_modalities")
-    .forEach((item) => text(item, "RunDefinition source modality"));
-  const digest = text(row.definition_sha256, "definition_sha256");
-  if (!SHA256.test(digest)) throw new ObservatoryLaboratorySetupContractError("Некорректный digest RunDefinition.");
-  return {
-    definitionId: text(row.definition_id, "definition_id"),
-    version: positiveInteger(row.version, "definition version"),
-    workId: text(row.work_id, "work_id"),
-    definitionSha256: digest,
-    resultSchema: null,
-    resultKind: null,
-    models: [],
-    configuration: array(row.configuration, "configuration").map((item) => {
-      const reference = record(item, "configuration reference");
-      exactKeys(reference, ["role", "sha256"], "configuration reference");
-      const sha256 = text(reference.sha256, "configuration sha256");
-      if (!SHA256.test(sha256)) throw new ObservatoryLaboratorySetupContractError("Некорректный digest конфигурации.");
-      return { role: text(reference.role, "configuration role"), sha256 };
-    }),
-  };
-}
-
-function decodePreservedResult(value: unknown): ObservatoryLaboratoryPreservedResult {
-  const row = record(value, "preserved result");
-  exactKeys(row, [
-    "access", "created_at_utc", "observatory_projection_available", "relation",
-    "result_id", "result_kind",
-  ], "preserved result");
-  return {
-    resultId: text(row.result_id, "result_id"),
-    resultKind: text(row.result_kind, "result_kind"),
-    relation: text(row.relation, "relation"),
-    access: oneOf(row.access, ["legacy-lab", "observatory", "evidence-only"] as const, "result access"),
-    createdAtUtc: text(row.created_at_utc, "created_at_utc"),
-    observatoryProjectionAvailable: boolean(row.observatory_projection_available, "observatory projection availability"),
-  };
-}
-
-function decodePreflight(value: unknown): ObservatoryLaboratoryRunPreflight {
-  const row = record(value, "preflight");
-  const baseKeys = [
-    "authority", "checks", "definition_sha256", "executor", "existing_result_ids",
-    "outcome", "schema_version", "setup_id", "source_session_id", "submission_allowed",
-  ] as const;
-  const hasPortableCheck = Object.hasOwn(row, "check_sha256");
-  exactKeys(
-    row,
-    hasPortableCheck ? [...baseKeys, "check_sha256"] : baseKeys,
-    "preflight",
-  );
-  exact(row.schema_version, PREFLIGHT_SCHEMA, "preflight schema");
-  observationAuthority(row.authority);
-  const digest = row.definition_sha256;
-  if (digest !== null && (typeof digest !== "string" || !SHA256.test(digest))) {
-    throw new ObservatoryLaboratorySetupContractError("Некорректный digest preflight.");
-  }
-  const checkDigest = hasPortableCheck ? row.check_sha256 : null;
-  if (
-    checkDigest !== null
-    && (typeof checkDigest !== "string" || !SHA256.test(checkDigest))
-  ) {
-    throw new ObservatoryLaboratorySetupContractError(
-      "Некорректный check digest preflight.",
-    );
-  }
-  const outcome = oneOf(
-    row.outcome,
-    ["existing", "queueable", "blocked"] as const,
-    "preflight outcome",
-  );
-  const submissionAllowed = boolean(
-    row.submission_allowed,
-    "preflight submission_allowed",
-  );
-  if (
-    submissionAllowed !== (outcome === "queueable")
-    || (hasPortableCheck && outcome === "queueable" && checkDigest === null)
-  ) {
-    throw new ObservatoryLaboratorySetupContractError(
-      "Preflight содержит противоречивое разрешение постановки в очередь.",
-    );
-  }
-  return {
-    sourceSessionId: text(row.source_session_id, "preflight source_session_id"),
-    setupId: text(row.setup_id, "preflight setup_id"),
-    definitionSha256: digest,
-    checkSha256: checkDigest,
-    outcome,
-    submissionAllowed,
-    checks: array(row.checks, "preflight checks").map((item) => {
-      const check = record(item, "preflight check");
-      exactKeys(check, ["check_id", "message", "outcome", "reason_code"], "preflight check");
-      return {
-        checkId: text(check.check_id, "check_id"),
-        outcome: oneOf(check.outcome, ["pass", "fail", "not-applicable"] as const, "check outcome"),
-        reasonCode: text(check.reason_code, "check reason_code"),
-        message: text(check.message, "check message"),
-      };
-    }),
-    existingResultIds: array(row.existing_result_ids, "existing_result_ids").map((item) => text(item, "existing result id")),
-  };
-}
-
-function observationAuthority(value: unknown): void {
-  const row = record(value, "authority");
-  const keys = ["commands_enabled", "actuation_allowed", "navigation_or_safety_accepted", "production_accepted"];
-  exactKeys(row, keys, "authority");
-  for (const key of keys) {
-    exact(row[key], false, `authority.${key}`);
-  }
-}
-
-async function request(fetcher: ObservatoryLaboratorySetupFetch, input: string, init: RequestInit): Promise<Response> {
-  try {
-    return await fetcher(input, init);
-  } catch (error) {
-    if (error instanceof DOMException && error.name === "AbortError") throw error;
-    throw new ObservatoryLaboratorySetupContractError("Каталог сетапов недоступен.");
-  }
-}
-
-async function responseBody(response: Response): Promise<unknown> {
-  const textBody = await response.text();
-  if (!textBody) return undefined;
-  try { return JSON.parse(textBody) as unknown; } catch { return textBody; }
-}
-
-function apiError(body: unknown, status: number): ObservatoryLaboratorySetupContractError {
-  const detail = body && typeof body === "object" && !Array.isArray(body)
-    ? (body as Record<string, unknown>).detail
-    : null;
-  return new ObservatoryLaboratorySetupContractError(
-    typeof detail === "string" && detail.trim() ? detail : `Observatory API вернул HTTP ${status}.`,
-    status,
-  );
-}
-
-function record(value: unknown, label: string): Record<string, unknown> {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new ObservatoryLaboratorySetupContractError(`${label}: ожидался объект.`);
-  }
-  return value as Record<string, unknown>;
-}
-
-function array(value: unknown, label: string): unknown[] {
-  if (!Array.isArray(value)) throw new ObservatoryLaboratorySetupContractError(`${label}: ожидался массив.`);
-  return value;
-}
-
-function text(value: unknown, label: string): string {
-  if (typeof value !== "string" || !value.trim()) throw new ObservatoryLaboratorySetupContractError(`${label}: ожидался текст.`);
-  return value;
-}
-
-function boolean(value: unknown, label: string): boolean {
-  if (typeof value !== "boolean") throw new ObservatoryLaboratorySetupContractError(`${label}: ожидался boolean.`);
-  return value;
-}
-
-function positiveInteger(value: unknown, label: string): number {
-  if (!Number.isInteger(value) || Number(value) < 1) throw new ObservatoryLaboratorySetupContractError(`${label}: ожидалось положительное целое.`);
-  return Number(value);
-}
-
-function exact<T>(value: unknown, expected: T, label: string): T {
-  if (value !== expected) throw new ObservatoryLaboratorySetupContractError(`${label}: значение изменилось.`);
-  return expected;
-}
-
-function oneOf<const T extends readonly string[]>(value: unknown, allowed: T, label: string): T[number] {
-  if (typeof value !== "string" || !allowed.includes(value)) {
-    throw new ObservatoryLaboratorySetupContractError(`${label}: значение не поддерживается.`);
-  }
-  return value as T[number];
-}
-
-function exactKeys(value: Record<string, unknown>, expected: readonly string[], label: string): void {
-  const actual = Object.keys(value).sort();
-  const sortedExpected = [...expected].sort();
-  if (actual.length !== sortedExpected.length || actual.some((key, index) => key !== sortedExpected[index])) {
-    throw new ObservatoryLaboratorySetupContractError(`${label}: обнаружены неизвестные поля.`);
-  }
-}
@@ -1,373 +0,0 @@
-import type {
-  ObservatoryLaboratoryPreservedResult,
-  ObservatoryLaboratoryRunDefinition,
-  ObservatoryLaboratorySetup,
-  ObservatoryLaboratorySetupCatalog,
-} from "./laboratorySetups";
-
-const PORTABLE_CATALOG_SCHEMA = "missioncore.observatory-portable-setup-catalog/v2";
-const SHA256 = /^[a-f0-9]{64}$/;
-
-export class ObservatoryPortableSetupDecodeError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "ObservatoryPortableSetupDecodeError";
-  }
-}
-
-export function decodePortableCatalog(value: unknown): ObservatoryLaboratorySetupCatalog {
-  const row = record(value, "portable-каталог сетапов");
-  exactKeys(
-    row,
-    ["authority", "schema_version", "setups", "source_session_id"],
-    "portable-каталог сетапов",
-  );
-  exact(row.schema_version, PORTABLE_CATALOG_SCHEMA, "schema_version portable-каталога");
-  observationAuthority(row.authority);
-  const sourceSessionId = text(row.source_session_id, "portable source_session_id");
-  return {
-    sourceSessionId,
-    setups: array(row.setups, "portable setups").map((item) => decodePortableSetup(item, sourceSessionId)),
-  };
-}
-
-function decodePortableSetup(value: unknown, sourceSessionId: string): ObservatoryLaboratorySetup {
-  const row = record(value, "portable-сетап");
-  exactKeys(row, [
-    "authority", "description", "display_name", "executor", "existing_results",
-    "origin", "preflight", "run_definition", "setup_id", "source_compatibility",
-    "source_requirements",
-  ], "portable-сетап");
-  exact(row.origin, "portable-definition", "portable origin");
-  observationAuthority(row.authority);
-  decodePortableSourceRequirements(row.source_requirements);
-  const setupId = text(row.setup_id, "portable setup_id");
-  const runDefinition = decodePortableRunDefinition(row.run_definition);
-
-  const compatibility = record(row.source_compatibility, "portable source_compatibility");
-  exactKeys(
-    compatibility,
-    ["compatible", "outcome", "reason", "reason_code"],
-    "portable source_compatibility",
-  );
-  const compatible = boolean(compatibility.compatible, "portable compatible");
-  exact(
-    compatibility.outcome,
-    compatible ? "pass" : "blocked",
-    "portable compatibility outcome",
-  );
-  const compatibilityReason = text(compatibility.reason, "portable compatibility reason");
-  const compatibilityReasonCode = text(
-    compatibility.reason_code,
-    "portable compatibility reason_code",
-  );
-
-  const executor = record(row.executor, "portable executor");
-  exactKeys(
-    executor,
-    ["contour_id", "ready", "reason", "reason_code", "state"],
-    "portable executor",
-  );
-  const executorState = oneOf(
-    executor.state,
-    ["not-installed", "ready"] as const,
-    "portable executor state",
-  );
-  const executorReady = boolean(executor.ready, "portable executor ready");
-  if (executorReady !== (executorState === "ready")) {
-    throw new ObservatoryPortableSetupDecodeError(
-      "Portable executor: состояние готовности противоречиво.",
-    );
-  }
-  const executorReason = executor.reason === null
-    ? "Исполнитель установлен."
-    : text(executor.reason, "portable executor reason");
-  const executorReasonCode = executor.reason_code === null
-    ? "portable-executor-ready"
-    : text(executor.reason_code, "portable executor reason_code");
-  if (
-    (executorReady && (executor.reason !== null || executor.reason_code !== null))
-    || (!executorReady && (executor.reason === null || executor.reason_code === null))
-  ) {
-    throw new ObservatoryPortableSetupDecodeError(
-      "Portable executor: причина недоступности противоречит состоянию.",
-    );
-  }
-
-  const preflight = record(row.preflight, "portable preflight");
-  exactKeys(preflight, [
-    "action", "existing_result_ids", "outcome", "reason", "submission_allowed",
-  ], "portable preflight");
-  const preflightOutcome = oneOf(
-    preflight.outcome,
-    ["existing", "ready", "blocked"] as const,
-    "portable preflight outcome",
-  );
-  const preflightAction = oneOf(
-    preflight.action,
-    ["open-existing", "check", "blocked"] as const,
-    "portable preflight action",
-  );
-  const submissionAllowed = boolean(
-    preflight.submission_allowed,
-    "portable preflight submission_allowed",
-  );
-  if (
-    submissionAllowed !== (preflightOutcome === "ready")
-    || (preflightOutcome === "ready" && preflightAction !== "check")
-    || (preflightOutcome === "blocked" && preflightAction !== "blocked")
-    || (preflightOutcome === "existing" && preflightAction !== "open-existing")
-    || (submissionAllowed && (!compatible || !executorReady))
-  ) {
-    throw new ObservatoryPortableSetupDecodeError(
-      "Portable preflight: состояние запуска противоречиво.",
-    );
-  }
-  const existingResults = array(row.existing_results, "portable existing_results").map(
-    (item) => decodePortableResult(item, sourceSessionId, setupId, runDefinition),
-  );
-  const existingResultIds = array(
-    preflight.existing_result_ids,
-    "portable existing_result_ids",
-  ).map((item) => text(item, "portable existing result id"));
-  if (
-    (existingResults.length > 0) !== (preflightOutcome === "existing")
-    || existingResultIds.length !== existingResults.length
-    || new Set(existingResultIds).size !== existingResultIds.length
-    || existingResults.some((result, index) => result.resultId !== existingResultIds[index])
-  ) {
-    throw new ObservatoryPortableSetupDecodeError(
-      "Portable result: готовность не соответствует проверенным результатам.",
-    );
-  }
-
-  return {
-    setupId,
-    displayName: text(row.display_name, "portable display_name"),
-    description: text(row.description, "portable description"),
-    origin: "portable-definition",
-    runDefinition,
-    compatibility: {
-      compatible,
-      reasons: compatible
-        ? []
-        : [{ code: compatibilityReasonCode, message: compatibilityReason }],
-    },
-    executor: {
-      contourId: text(executor.contour_id, "portable executor contour_id"),
-      state: executorState,
-      reasonCode: executorReasonCode,
-      reason: executorReason,
-    },
-    preservedResults: existingResults,
-    preflight: {
-      outcome: preflightOutcome,
-      action: preflightAction,
-      reason: text(preflight.reason, "portable preflight reason"),
-      submissionAllowed,
-      existingResultIds,
-    },
-  };
-}
-
-function decodePortableResult(
-  value: unknown, sourceSessionId: string, setupId: string,
-  definition: ObservatoryLaboratoryRunDefinition,
-): ObservatoryLaboratoryPreservedResult {
-  const row = record(value, "portable result");
-  exactKeys(row, [
-    "result_id", "result_kind", "relation", "access", "created_at_utc",
-    "observatory_projection_available", "identity",
-  ], "portable result");
-  exact(row.result_kind, definition.resultKind, "portable result kind");
-  exact(row.relation, "exact-recorded-computation", "portable result relation");
-  exact(row.access, "observatory", "portable result access");
-  exact(row.observatory_projection_available, true, "portable result availability");
-  const identity = record(row.identity, "portable result identity");
-  exactKeys(identity, [
-    "job_id", "source_session_id", "source_catalog_sha256", "source_bundle_sha256",
-    "source_capability_manifest_sha256", "setup_id", "definition_sha256",
-    "package_sha256", "artifact_manifest_id",
-  ], "portable result identity");
-  exact(identity.source_session_id, sourceSessionId, "portable result source");
-  exact(identity.setup_id, setupId, "portable result setup");
-  exact(identity.definition_sha256, definition.definitionSha256, "portable result definition");
-  text(identity.job_id, "portable result job");
-  for (const key of [
-    "source_catalog_sha256", "source_bundle_sha256", "source_capability_manifest_sha256",
-    "definition_sha256", "package_sha256", "artifact_manifest_id",
-  ]) {
-    if (!SHA256.test(text(identity[key], `portable result ${key}`))) {
-      throw new ObservatoryPortableSetupDecodeError(`Portable result: некорректный ${key}.`);
-    }
-  }
-  return {
-    resultId: text(row.result_id, "portable result id"),
-    resultKind: text(row.result_kind, "portable result kind"),
-    relation: "exact-recorded-computation",
-    access: "observatory",
-    createdAtUtc: text(row.created_at_utc, "portable result created_at_utc"),
-    observatoryProjectionAvailable: true,
-  };
-}
-
-function decodePortableSourceRequirements(value: unknown): void {
-  const row = record(value, "portable source_requirements");
-  exactKeys(row, [
-    "archive_id", "calibration_identity_sha256", "calibration_slot", "camera_height",
-    "camera_semantic_channel_id", "camera_source_id", "camera_width",
-    "exactly_one_media_epoch", "plugin_id", "recorded_media_init_sha256",
-    "recorded_media_type", "required_modalities", "seekable",
-  ], "portable source_requirements");
-  for (const key of [
-    "archive_id", "calibration_slot", "camera_semantic_channel_id", "camera_source_id",
-    "plugin_id", "recorded_media_type",
-  ]) text(row[key], `portable source_requirements.${key}`);
-  for (const key of ["calibration_identity_sha256", "recorded_media_init_sha256"]) {
-    const digest = text(row[key], `portable source_requirements.${key}`);
-    if (!SHA256.test(digest)) {
-      throw new ObservatoryPortableSetupDecodeError(
-        `portable source_requirements.${key}: некорректный digest.`,
-      );
-    }
-  }
-  positiveInteger(row.camera_width, "portable camera_width");
-  positiveInteger(row.camera_height, "portable camera_height");
-  exact(row.exactly_one_media_epoch, true, "portable exactly_one_media_epoch");
-  exact(row.seekable, true, "portable seekable");
-  array(row.required_modalities, "portable required_modalities")
-    .forEach((item) => text(item, "portable required modality"));
-}
-
-function decodePortableRunDefinition(value: unknown): ObservatoryLaboratoryRunDefinition {
-  const row = record(value, "portable RunDefinition");
-  exactKeys(row, [
-    "definition_id", "definition_sha256", "models", "result_kind", "result_schema",
-    "version",
-  ], "portable RunDefinition");
-  const digest = text(row.definition_sha256, "portable definition_sha256");
-  if (!SHA256.test(digest)) {
-    throw new ObservatoryPortableSetupDecodeError(
-      "Portable RunDefinition: некорректный digest.",
-    );
-  }
-  return {
-    definitionId: text(row.definition_id, "portable definition_id"),
-    version: positiveInteger(row.version, "portable definition version"),
-    workId: null,
-    definitionSha256: digest,
-    resultSchema: text(row.result_schema, "portable result_schema"),
-    resultKind: text(row.result_kind, "portable result_kind"),
-    models: array(row.models, "portable models").map((item) => {
-      const model = record(item, "portable model");
-      exactKeys(
-        model,
-        ["architecture", "model_id", "name", "release_id"],
-        "portable model",
-      );
-      return {
-        name: text(model.name, "portable model name"),
-        releaseId: text(model.release_id, "portable model release_id"),
-        modelId: text(model.model_id, "portable model model_id"),
-        architecture: text(model.architecture, "portable model architecture"),
-      };
-    }),
-    configuration: [],
-  };
-}
-
-function observationAuthority(value: unknown): void {
-  const row = record(value, "authority");
-  const keys = [
-    "commands_enabled",
-    "actuation_allowed",
-    "navigation_or_safety_accepted",
-    "production_accepted",
-  ];
-  exactKeys(row, keys, "authority");
-  for (const key of keys) exact(row[key], false, `authority.${key}`);
-}
-
-function record(value: unknown, label: string): Record<string, unknown> {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new ObservatoryPortableSetupDecodeError(
-      `${label}: ожидался объект.`,
-    );
-  }
-  return value as Record<string, unknown>;
-}
-
-function array(value: unknown, label: string): unknown[] {
-  if (!Array.isArray(value)) {
-    throw new ObservatoryPortableSetupDecodeError(
-      `${label}: ожидался массив.`,
-    );
-  }
-  return value;
-}
-
-function text(value: unknown, label: string): string {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new ObservatoryPortableSetupDecodeError(
-      `${label}: ожидался текст.`,
-    );
-  }
-  return value;
-}
-
-function boolean(value: unknown, label: string): boolean {
-  if (typeof value !== "boolean") {
-    throw new ObservatoryPortableSetupDecodeError(
-      `${label}: ожидался boolean.`,
-    );
-  }
-  return value;
-}
-
-function positiveInteger(value: unknown, label: string): number {
-  if (!Number.isInteger(value) || Number(value) < 1) {
-    throw new ObservatoryPortableSetupDecodeError(
-      `${label}: ожидалось положительное целое.`,
-    );
-  }
-  return Number(value);
-}
-
-function exact<T>(value: unknown, expected: T, label: string): T {
-  if (value !== expected) {
-    throw new ObservatoryPortableSetupDecodeError(
-      `${label}: значение изменилось.`,
-    );
-  }
-  return expected;
-}
-
-function oneOf<const T extends readonly string[]>(
-  value: unknown,
-  allowed: T,
-  label: string,
-): T[number] {
-  if (typeof value !== "string" || !allowed.includes(value)) {
-    throw new ObservatoryPortableSetupDecodeError(
-      `${label}: значение не поддерживается.`,
-    );
-  }
-  return value as T[number];
-}
-
-function exactKeys(
-  value: Record<string, unknown>,
-  expected: readonly string[],
-  label: string,
-): void {
-  const actual = Object.keys(value).sort();
-  const sortedExpected = [...expected].sort();
-  if (
-    actual.length !== sortedExpected.length
-    || actual.some((key, index) => key !== sortedExpected[index])
-  ) {
-    throw new ObservatoryPortableSetupDecodeError(
-      `${label}: обнаружены неизвестные поля.`,
-    );
-  }
-}
@@ -1,85 +0,0 @@
-import { decodePortableCatalog } from "./portableLaboratorySetupDecoder";
-import type {
-  ObservatoryLaboratorySetupCatalog,
-} from "./laboratorySetups";
-
-export type ObservatoryPortableLaboratorySetupFetch = (
-  input: RequestInfo | URL,
-  init?: RequestInit,
-) => Promise<Response>;
-
-class ObservatoryPortableLaboratorySetupContractError extends Error {
-  readonly status: number | null;
-
-  constructor(message: string, status: number | null = null) {
-    super(message);
-    this.name = "ObservatoryPortableLaboratorySetupContractError";
-    this.status = status;
-  }
-}
-
-export async function fetchObservatoryPortableLaboratorySetups(
-  sourceSessionId: string,
-  {
-    signal,
-    fetcher = globalThis.fetch,
-  }: {
-    signal?: AbortSignal;
-    fetcher?: ObservatoryPortableLaboratorySetupFetch;
-  } = {},
-): Promise<ObservatoryLaboratorySetupCatalog> {
-  const response = await request(
-    fetcher,
-    `/api/v1/observatory/portable-laboratory-setups?source_session_id=${encodeURIComponent(sourceSessionId)}`,
-    { method: "GET", headers: { Accept: "application/json" }, signal },
-  );
-  const body = await responseBody(response);
-  if (!response.ok) throw apiError(body, response.status);
-  const catalog = decodePortableCatalog(body);
-  if (catalog.sourceSessionId !== sourceSessionId) {
-    throw new ObservatoryPortableLaboratorySetupContractError(
-      "Portable-каталог сетапов относится к другой исходной сессии.",
-    );
-  }
-  return catalog;
-}
-
-async function request(
-  fetcher: ObservatoryPortableLaboratorySetupFetch,
-  input: string,
-  init: RequestInit,
-): Promise<Response> {
-  try {
-    return await fetcher(input, init);
-  } catch (error) {
-    if (error instanceof DOMException && error.name === "AbortError") throw error;
-    throw new ObservatoryPortableLaboratorySetupContractError(
-      "Portable-каталог сетапов недоступен.",
-    );
-  }
-}
-
-async function responseBody(response: Response): Promise<unknown> {
-  const textBody = await response.text();
-  if (!textBody) return undefined;
-  try {
-    return JSON.parse(textBody) as unknown;
-  } catch {
-    return textBody;
-  }
-}
-
-function apiError(
-  body: unknown,
-  status: number,
-): ObservatoryPortableLaboratorySetupContractError {
-  const detail = body && typeof body === "object" && !Array.isArray(body)
-    ? (body as Record<string, unknown>).detail
-    : null;
-  return new ObservatoryPortableLaboratorySetupContractError(
-    typeof detail === "string" && detail.trim()
-      ? detail
-      : `Observatory API вернул HTTP ${status}.`,
-    status,
-  );
-}
@@ -1,338 +0,0 @@
-const SUBMIT_SCHEMA = "missioncore.observatory-recorded-run-submit/v1";
-const JOB_SCHEMA = "missioncore.observatory-recorded-job/v1";
-const JOB_LIST_SCHEMA = "missioncore.observatory-recorded-job-list/v1";
-const SHA256 = /^[a-f0-9]{64}$/;
-
-export type ObservatoryRecordedJobState =
-  | "accepted"
-  | "queued"
-  | "claimed"
-  | "running"
-  | "paused"
-  | "preemption-pending"
-  | "succeeded"
-  | "failed"
-  | "reconciliation-required";
-
-export type ObservatoryRecordedJobPublicationState =
-  | "not-required"
-  | "pending"
-  | "failed"
-  | "published";
-
-export interface ObservatoryRecordedJob {
-  readonly jobId: string;
-  readonly idempotencyKey: string;
-  readonly sourceSessionId: string;
-  readonly setupId: string;
-  readonly definitionSha256: string;
-  readonly claimGeneration: number;
-  readonly state: ObservatoryRecordedJobState;
-  readonly restartFromZero: boolean;
-  readonly resultId: string | null;
-  readonly terminalMessage: string | null;
-  readonly publication: {
-    readonly state: ObservatoryRecordedJobPublicationState;
-    readonly attempts: number;
-    readonly error: string | null;
-    readonly publishedAtUtc: string | null;
-  };
-  readonly createdAtUtc: string;
-  readonly updatedAtUtc: string;
-}
-
-export type ObservatoryRecordedJobFetch = (
-  input: RequestInfo | URL,
-  init?: RequestInit,
-) => Promise<Response>;
-
-export class ObservatoryRecordedJobContractError extends Error {
-  readonly status: number | null;
-
-  constructor(message: string, status: number | null = null) {
-    super(message);
-    this.name = "ObservatoryRecordedJobContractError";
-    this.status = status;
-  }
-}
-
-export async function fetchObservatoryRecordedJobs(
-  sourceSessionId: string,
-  setupId: string,
-  {
-    signal,
-    definitionSha256,
-    fetcher = globalThis.fetch,
-  }: {
-    signal?: AbortSignal;
-    definitionSha256?: string;
-    fetcher?: ObservatoryRecordedJobFetch;
-  } = {},
-): Promise<readonly ObservatoryRecordedJob[]> {
-  const query = new URLSearchParams({
-    source_session_id: sourceSessionId,
-    setup_id: setupId,
-    limit: "20",
-  });
-  if (definitionSha256 !== undefined) query.set("definition_sha256", definitionSha256);
-  const response = await request(fetcher, `/api/v1/observatory/runs?${query}`, {
-    method: "GET",
-    headers: { Accept: "application/json" },
-    signal,
-  });
-  const body = await responseBody(response);
-  if (!response.ok) throw apiError(body, response.status);
-  const row = record(body, "список расчётов");
-  exactKeys(row, ["authority", "items", "schema_version"], "список расчётов");
-  exact(row.schema_version, JOB_LIST_SCHEMA, "schema_version списка расчётов");
-  observationAuthority(row.authority);
-  return array(row.items, "items").map(decodeObservatoryRecordedJob).filter((job) => (
-    job.sourceSessionId === sourceSessionId && job.setupId === setupId
-    && (definitionSha256 === undefined || job.definitionSha256 === definitionSha256)
-  ));
-}
-
-export async function submitObservatoryRecordedJob(
-  sourceSessionId: string,
-  setupId: string,
-  idempotencyKey: string,
-  portableBinding: {
-    readonly definitionSha256: string;
-    readonly checkSha256: string;
-  } | null,
-  {
-    signal,
-    fetcher = globalThis.fetch,
-  }: {
-    signal?: AbortSignal;
-    fetcher?: ObservatoryRecordedJobFetch;
-  } = {},
-): Promise<ObservatoryRecordedJob> {
-  const response = await request(fetcher, "/api/v1/observatory/runs", {
-    method: "POST",
-    headers: { Accept: "application/json", "Content-Type": "application/json" },
-    body: JSON.stringify({
-      schema_version: SUBMIT_SCHEMA,
-      idempotency_key: idempotencyKey,
-      source_session_id: sourceSessionId,
-      setup_id: setupId,
-      ...(portableBinding === null ? {} : {
-        definition_sha256: portableBinding.definitionSha256,
-        check_sha256: portableBinding.checkSha256,
-      }),
-    }),
-    signal,
-  });
-  const body = await responseBody(response);
-  if (!response.ok) throw apiError(body, response.status);
-  const job = decodeObservatoryRecordedJob(body);
-  if (job.sourceSessionId !== sourceSessionId || job.setupId !== setupId
-    || (portableBinding !== null && job.definitionSha256 !== portableBinding.definitionSha256)) {
-    throw new ObservatoryRecordedJobContractError(
-      "Расчёт относится к другой сессии, сетапу или версии профиля.",
-    );
-  }
-  return job;
-}
-
-export async function retryObservatoryRecordedJobPublication(
-  jobId: string,
-  {
-    signal,
-    fetcher = globalThis.fetch,
-  }: {
-    signal?: AbortSignal;
-    fetcher?: ObservatoryRecordedJobFetch;
-  } = {},
-): Promise<ObservatoryRecordedJob> {
-  const response = await request(
-    fetcher,
-    `/api/v1/observatory/runs/${encodeURIComponent(jobId)}/publication/retry`,
-    {
-      method: "POST",
-      headers: { Accept: "application/json" },
-      signal,
-    },
-  );
-  const body = await responseBody(response);
-  if (!response.ok) throw apiError(body, response.status);
-  const job = decodeObservatoryRecordedJob(body);
-  if (job.jobId !== jobId) {
-    throw new ObservatoryRecordedJobContractError(
-      "Повтор публикации вернул другой расчёт.",
-    );
-  }
-  return job;
-}
-
-export function decodeObservatoryRecordedJob(value: unknown): ObservatoryRecordedJob {
-  const row = record(value, "расчёт");
-  exactKeys(row, [
-    "authority", "checkpoint_policy", "claim_generation", "claim_lease", "created_at_utc", "executor",
-    "idempotency_key", "identity_sha256", "job_id", "preemption_receipt_sha256",
-    "preemption_requested", "priority", "publication", "request_sha256", "restart_from_zero", "result",
-    "schema_version", "setup", "source", "state", "submission_receipt_sha256", "terminal",
-    "updated_at_utc",
-  ], "расчёт");
-  exact(row.schema_version, JOB_SCHEMA, "schema_version расчёта");
-  observationAuthority(row.authority);
-  digest(row.request_sha256, "request_sha256");
-  digest(row.identity_sha256, "identity_sha256");
-  digest(row.submission_receipt_sha256, "submission_receipt_sha256");
-  const source = record(row.source, "source");
-  exactKeys(source, [
-    "adapter", "bundle_sha256", "capability_manifest_sha256", "catalog_sha256", "session_id",
-  ], "source");
-  digest(source.catalog_sha256, "source.catalog_sha256");
-  digest(source.bundle_sha256, "source.bundle_sha256");
-  digest(source.capability_manifest_sha256, "source.capability_manifest_sha256");
-  const setup = record(row.setup, "setup");
-  exactKeys(setup, ["definition_id", "definition_sha256", "definition_version", "setup_id"], "setup");
-  digest(setup.definition_sha256, "setup.definition_sha256");
-  const state = oneOf(row.state, [
-    "accepted", "queued", "claimed", "running", "paused", "preemption-pending",
-    "succeeded", "failed", "reconciliation-required",
-  ] as const, "state");
-  if (row.claim_lease !== null) {
-    const lease = record(row.claim_lease, "claim_lease");
-    exactKeys(
-      lease,
-      ["claimed_at_utc", "expires_at_utc", "heartbeat_at_utc", "renewal_count"],
-      "claim_lease",
-    );
-    text(lease.claimed_at_utc, "claim_lease.claimed_at_utc");
-    text(lease.expires_at_utc, "claim_lease.expires_at_utc");
-    text(lease.heartbeat_at_utc, "claim_lease.heartbeat_at_utc");
-    nonNegativeInteger(lease.renewal_count, "claim_lease.renewal_count");
-  }
-  const result = row.result === null ? null : record(row.result, "result");
-  if (result !== null) exactKeys(result, ["result_id", "sha256"], "result");
-  const terminal = row.terminal === null ? null : record(row.terminal, "terminal");
-  if (terminal !== null) exactKeys(terminal, ["code", "message"], "terminal");
-  const publication = record(row.publication, "publication");
-  exactKeys(
-    publication,
-    ["attempts", "error", "published_at_utc", "state"],
-    "publication",
-  );
-  const publicationState = oneOf(publication.state, [
-    "not-required", "pending", "failed", "published",
-  ] as const, "publication.state");
-  const publicationError = publication.error === null
-    ? null
-    : text(publication.error, "publication.error");
-  const publishedAtUtc = publication.published_at_utc === null
-    ? null
-    : text(publication.published_at_utc, "publication.published_at_utc");
-  return {
-    jobId: text(row.job_id, "job_id"),
-    idempotencyKey: text(row.idempotency_key, "idempotency_key"),
-    sourceSessionId: text(source.session_id, "source.session_id"),
-    setupId: text(setup.setup_id, "setup.setup_id"),
-    definitionSha256: String(setup.definition_sha256),
-    claimGeneration: nonNegativeInteger(row.claim_generation, "claim_generation"),
-    state,
-    restartFromZero: boolean(row.restart_from_zero, "restart_from_zero"),
-    resultId: result === null ? null : text(result.result_id, "result.result_id"),
-    terminalMessage: terminal === null || terminal.message === null
-      ? null
-      : text(terminal.message, "terminal.message"),
-    publication: {
-      state: publicationState,
-      attempts: nonNegativeInteger(publication.attempts, "publication.attempts"),
-      error: publicationError,
-      publishedAtUtc,
-    },
-    createdAtUtc: text(row.created_at_utc, "created_at_utc"),
-    updatedAtUtc: text(row.updated_at_utc, "updated_at_utc"),
-  };
-}
-
-function observationAuthority(value: unknown): void {
-  const row = record(value, "authority");
-  const keys = ["commands_enabled", "actuation_allowed", "navigation_or_safety_accepted", "production_accepted"];
-  exactKeys(row, keys, "authority");
-  keys.forEach((key) => exact(row[key], false, `authority.${key}`));
-}
-
-async function request(fetcher: ObservatoryRecordedJobFetch, input: string, init: RequestInit): Promise<Response> {
-  try {
-    return await fetcher(input, init);
-  } catch (error) {
-    if (error instanceof DOMException && error.name === "AbortError") throw error;
-    throw new ObservatoryRecordedJobContractError("Очередь расчётов недоступна.");
-  }
-}
-
-async function responseBody(response: Response): Promise<unknown> {
-  const body = await response.text();
-  if (!body) return undefined;
-  try { return JSON.parse(body) as unknown; } catch { return body; }
-}
-
-function apiError(body: unknown, status: number): ObservatoryRecordedJobContractError {
-  const detail = body && typeof body === "object" && !Array.isArray(body)
-    ? (body as Record<string, unknown>).detail
-    : null;
-  return new ObservatoryRecordedJobContractError(
-    typeof detail === "string" && detail.trim() ? detail : `Observatory API вернул HTTP ${status}.`,
-    status,
-  );
-}
-
-function record(value: unknown, label: string): Record<string, unknown> {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new ObservatoryRecordedJobContractError(`${label}: ожидался объект.`);
-  }
-  return value as Record<string, unknown>;
-}
-
-function array(value: unknown, label: string): unknown[] {
-  if (!Array.isArray(value)) throw new ObservatoryRecordedJobContractError(`${label}: ожидался массив.`);
-  return value;
-}
-
-function text(value: unknown, label: string): string {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new ObservatoryRecordedJobContractError(`${label}: ожидался текст.`);
-  }
-  return value;
-}
-
-function digest(value: unknown, label: string): string {
-  const valueText = text(value, label);
-  if (!SHA256.test(valueText)) throw new ObservatoryRecordedJobContractError(`${label}: некорректный digest.`);
-  return valueText;
-}
-
-function boolean(value: unknown, label: string): boolean {
-  if (typeof value !== "boolean") throw new ObservatoryRecordedJobContractError(`${label}: ожидался boolean.`);
-  return value;
-}
-
-function nonNegativeInteger(value: unknown, label: string): number {
-  if (!Number.isInteger(value) || Number(value) < 0) {
-    throw new ObservatoryRecordedJobContractError(`${label}: ожидалось целое число.`);
-  }
-  return Number(value);
-}
-
-function exact<T>(value: unknown, expected: T, label: string): T {
-  if (value !== expected) throw new ObservatoryRecordedJobContractError(`${label}: значение изменилось.`);
-  return expected;
-}
-
-function oneOf<const T extends readonly string[]>(value: unknown, allowed: T, label: string): T[number] {
-  if (typeof value !== "string" || !allowed.includes(value)) {
-    throw new ObservatoryRecordedJobContractError(`${label}: значение не поддерживается.`);
-  }
-  return value as T[number];
-}
-
-function exactKeys(value: Record<string, unknown>, expected: readonly string[], label: string): void {
-  const actual = Object.keys(value).sort();
-  const sortedExpected = [...expected].sort();
-  if (actual.length !== sortedExpected.length || actual.some((key, index) => key !== sortedExpected[index])) {
-    throw new ObservatoryRecordedJobContractError(`${label}: обнаружены неизвестные поля.`);
-  }
-}
@@ -1,124 +0,0 @@
-import type { ObservatoryRecordedJob } from "./recordedJobs";
-
-const PHASES = {
-  "source-transfer": "Передаём входные данные",
-  "source-preparation": "Подготавливаем вход",
-  computing: "Обрабатываем запись",
-  "result-assembly": "Собираем результат",
-  "result-transfer": "Передаём результат",
-} as const;
-const UNITS = { frames: "кадров", members: "файлов", steps: "операций" } as const;
-type Phase = keyof typeof PHASES;
-type Unit = keyof typeof UNITS;
-
-export interface RecordedProgressView {
-  readonly jobId: string;
-  readonly claimGeneration: number;
-  readonly sequence: number;
-  readonly phase: Phase;
-  readonly unit: Unit;
-  readonly completed: number;
-  readonly total: number | null;
-  readonly ageSeconds: number;
-  readonly elapsedSeconds: number;
-  readonly phaseElapsedSeconds: number;
-}
-
-export async function fetchRecordedProgress(
-  job: ObservatoryRecordedJob,
-  { signal, fetcher = globalThis.fetch }: {
-    signal?: AbortSignal;
-    fetcher?: typeof globalThis.fetch;
-  } = {},
-): Promise<RecordedProgressView | null> {
-  const request = new AbortController();
-  const abort = () => request.abort();
-  signal?.addEventListener("abort", abort, { once: true });
-  if (signal?.aborted) request.abort();
-  const timer = globalThis.setTimeout(abort, 2_500);
-  try {
-    const response = await fetcher(
-      `/api/v1/observatory/runs/${encodeURIComponent(job.jobId)}/progress`,
-      { signal: request.signal, headers: { Accept: "application/json" } },
-    );
-    if (!response.ok) throw new Error("Прогресс расчёта недоступен.");
-    return decodeRecordedProgress(await response.json(), job);
-  } finally {
-    globalThis.clearTimeout(timer);
-    signal?.removeEventListener("abort", abort);
-  }
-}
-
-export function decodeRecordedProgress(
-  value: unknown, job: ObservatoryRecordedJob,
-): RecordedProgressView | null {
-  const row = object(value);
-  keys(row, ["schema_version", "job_id", "source_session_id", "setup_id",
-    "definition_sha256", "claim_generation", "state", "received_at_utc", "age_seconds", "progress"]);
-  if (row.schema_version !== "missioncore.observatory-recorded-progress-view/v1"
-    || row.job_id !== job.jobId || row.source_session_id !== job.sourceSessionId
-    || row.setup_id !== job.setupId || row.definition_sha256 !== job.definitionSha256
-    || row.claim_generation !== job.claimGeneration) throw new Error("Прогресс другой попытки.");
-  if (row.progress === null || row.state !== job.state) return null;
-  const progress = object(row.progress);
-  keys(progress, ["schema_version", "claim_generation", "sequence", "phase_index",
-    "phase", "unit", "completed", "total", "elapsed_seconds", "phase_elapsed_seconds"]);
-  if (progress.schema_version !== "missioncore.observatory-recorded-progress/v1"
-    || progress.claim_generation !== row.claim_generation
-    || !(typeof progress.phase === "string" && Object.hasOwn(PHASES, progress.phase))
-    || !(typeof progress.unit === "string" && Object.hasOwn(UNITS, progress.unit))
-    || typeof row.received_at_utc !== "string" || !Number.isFinite(Date.parse(row.received_at_utc))) {
-    throw new Error("Некорректный прогресс.");
-  }
-  const completed = integer(progress.completed);
-  const total = progress.total === null ? null : integer(progress.total, 1);
-  const elapsed = finite(progress.elapsed_seconds);
-  const phaseElapsed = finite(progress.phase_elapsed_seconds);
-  if ((total !== null && completed > total) || phaseElapsed > elapsed) {
-    throw new Error("Некорректные счётчики прогресса.");
-  }
-  integer(progress.phase_index);
-  return {
-    jobId: job.jobId, claimGeneration: integer(progress.claim_generation, 1),
-    sequence: integer(progress.sequence, 1), phase: progress.phase as Phase,
-    unit: progress.unit as Unit, completed, total, ageSeconds: finite(row.age_seconds),
-    elapsedSeconds: elapsed, phaseElapsedSeconds: phaseElapsed,
-  };
-}
-
-export function recordedProgressLabel(
-  job: ObservatoryRecordedJob | null, progress: RecordedProgressView | null,
-): string {
-  if (job?.publication.state === "pending") return "Сохраняем результат";
-  if (!job || job.state === "accepted" || job.state === "queued") return "Ожидаем расчёт";
-  if (job.state === "failed") return "Ошибка расчёта";
-  if (job.state === "succeeded") return "Расчёт завершён";
-  if (job.state === "paused" || job.state === "preemption-pending") return "Расчёт приостановлен";
-  if (job.state === "reconciliation-required") return "Проверяем состояние расчёта";
-  if (!progress || progress.jobId !== job.jobId
-    || progress.claimGeneration !== job.claimGeneration) return "Ожидаем данные расчёта";
-  if (progress.ageSeconds > 15) return "Ожидаем обновление прогресса";
-  const count = progress.total === null
-    ? (progress.completed > 0 ? ` · ${progress.completed.toLocaleString("ru-RU")} ${UNITS[progress.unit]}` : "")
-    : ` · ${progress.completed.toLocaleString("ru-RU")} / ${progress.total.toLocaleString("ru-RU")} ${UNITS[progress.unit]}`;
-  return PHASES[progress.phase] + count;
-}
-
-function object(value: unknown): Record<string, unknown> {
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Прогресс: ожидался объект.");
-  return value as Record<string, unknown>;
-}
-function keys(row: Record<string, unknown>, expected: string[]): void {
-  if (Object.keys(row).length !== expected.length || expected.some((key) => !Object.hasOwn(row, key))) {
-    throw new Error("Прогресс: неизвестные поля.");
-  }
-}
-function finite(value: unknown): number {
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new Error("Прогресс: некорректное число.");
-  return value;
-}
-function integer(value: unknown, minimum = 0): number {
-  const number = finite(value);
-  if (!Number.isSafeInteger(number) || number < minimum) throw new Error("Прогресс: некорректный счётчик.");
-  return number;
-}
@@ -1,335 +0,0 @@
-import type { LaboratoryFetch } from "../laboratory/advancedResults";
-import {
-  fetchVegetationShadowResultMetadata,
-  type VegetationFullRouteReview,
-  type VegetationShadowResult,
-} from "../laboratory/vegetationShadow";
-import type { ObservationLabInstance } from "../observation/sessionArchive";
-import {
-  decodeLabReplayCapability,
-  decodeCanonicalLabReplayCapabilityProvenance,
-  decodePortableLabReplayCapabilityProvenance,
-  ObservationLabReplayCapabilityContractError,
-} from "../observation/labReplayCapability";
-
-const CANONICAL_RESULT_ID = /^lab-v1-vegetation-shadow-[a-f0-9]{64}$/;
-const CANONICAL_SOURCE_SESSION_ID = "20260828T130511Z_viewer_live";
-
-interface ObservatoryRecordedRunBindingBase {
-  readonly evidenceSessionId: string;
-  readonly sourceSessionId: string;
-  readonly resultId: string;
-  readonly activation: "explicit";
-}
-
-export interface ObservatoryCanonicalRecordedRunBinding
-  extends ObservatoryRecordedRunBindingBase {
-  readonly kind: "canonical-recorded-rerun";
-  readonly viewerProfile: "recorded-session";
-  readonly timeline: "session_time";
-}
-
-export interface ObservatoryPortableResultBinding
-  extends ObservatoryRecordedRunBindingBase {
-  readonly kind: "portable-result-review";
-  readonly viewerProfile: "portable-result";
-  readonly timeline: "result-defined";
-  readonly definitionSha256: string;
-}
-
-export type ObservatoryRecordedRunBinding =
-  | ObservatoryCanonicalRecordedRunBinding
-  | ObservatoryPortableResultBinding;
-
-export interface ObservatoryPortableResultReview {
-  readonly kind: "portable-result";
-  readonly resultId: string;
-  readonly sourceSessionId: string;
-  readonly resultKind: string;
-  readonly definitionSha256: string;
-  readonly calculationProfile: Readonly<Record<string, unknown>> | null;
-  readonly artifactManifestId: string;
-  readonly artifacts: readonly {
-    readonly role: string;
-    readonly mediaType: string;
-    readonly sha256: string;
-    readonly byteLength: number;
-  }[];
-  readonly resultDocument: Readonly<Record<string, unknown>>;
-}
-
-export type ObservatoryRecordedRunReview =
-  | { readonly kind: "canonical-recorded-rerun"; readonly review: VegetationFullRouteReview }
-  | ObservatoryPortableResultReview;
-
-export class ObservatoryRecordedRunContractError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "ObservatoryRecordedRunContractError";
-  }
-}
-
-export function observatoryRecordedRunBinding(
-  evidenceSessionId: string,
-  lab: ObservationLabInstance,
-): ObservatoryRecordedRunBinding | null {
-  const capability = lab.replayCapability;
-  if (!capability) return null;
-  if (capability.kind === "portable-result-review") {
-    if (
-      evidenceSessionId !== lab.resultId
-      || lab.sourceSessionId === evidenceSessionId
-      || lab.configSha256 === null
-      || !/^[a-f0-9]{64}$/.test(lab.configSha256)
-      || capability.viewerProfile !== "portable-result"
-      || capability.timeline !== "result-defined"
-      || capability.activation !== "explicit"
-      || capability.commandsEnabled !== false
-    ) {
-      throw new ObservatoryRecordedRunContractError(
-        `Portable-результат ${lab.resultId} не допущен к универсальному viewer.`,
-      );
-    }
-    try {
-      decodePortableLabReplayCapabilityProvenance(
-        lab.provenance,
-        evidenceSessionId,
-        lab.resultId,
-        lab.sourceSessionId,
-        lab.configSha256,
-      );
-    } catch (error) {
-      if (!(error instanceof ObservationLabReplayCapabilityContractError)) throw error;
-      throw new ObservatoryRecordedRunContractError(error.message);
-    }
-    return {
-      kind: "portable-result-review",
-      evidenceSessionId,
-      sourceSessionId: lab.sourceSessionId,
-      resultId: lab.resultId,
-      viewerProfile: "portable-result",
-      timeline: "result-defined",
-      activation: "explicit",
-      definitionSha256: lab.configSha256,
-    };
-  }
-  try {
-    decodeCanonicalLabReplayCapabilityProvenance(
-      lab.provenance,
-      evidenceSessionId,
-      lab.resultId,
-    );
-  } catch (error) {
-    if (!(error instanceof ObservationLabReplayCapabilityContractError)) throw error;
-    throw new ObservatoryRecordedRunContractError(error.message);
-  }
-  if (
-    evidenceSessionId !== lab.resultId
-    || lab.sourceSessionId !== CANONICAL_SOURCE_SESSION_ID
-    || lab.labId !== "LAB V1"
-    || lab.resultKind !== "recorded-perception-qualification"
-    || !CANONICAL_RESULT_ID.test(lab.resultId)
-    || lab.configSha256 !== null
-    || lab.sourceResultId === null
-    || !CANONICAL_RESULT_ID.test(lab.sourceResultId)
-    || capability.kind !== "canonical-recorded-rerun"
-    || capability.viewerProfile !== "recorded-session"
-    || capability.timeline !== "session_time"
-    || capability.activation !== "explicit"
-    || capability.commandsEnabled !== false
-  ) {
-    throw new ObservatoryRecordedRunContractError(
-      `LAB-результат ${lab.resultId} не допущен к каноническому recorded replay.`,
-    );
-  }
-  return {
-    kind: "canonical-recorded-rerun",
-    evidenceSessionId,
-    sourceSessionId: lab.sourceSessionId,
-    resultId: lab.resultId,
-    viewerProfile: "recorded-session",
-    timeline: "session_time",
-    activation: "explicit",
-  };
-}
-
-export async function fetchObservatoryRecordedRunReview(
-  binding: ObservatoryRecordedRunBinding,
-  {
-    selectedSourceSessionId,
-    fetcher = fetch,
-    signal,
-  }: {
-    selectedSourceSessionId: string;
-    fetcher?: LaboratoryFetch;
-    signal?: AbortSignal;
-  },
-): Promise<ObservatoryRecordedRunReview> {
-  if (binding.sourceSessionId !== selectedSourceSessionId) {
-    throw new ObservatoryRecordedRunContractError(
-      "Запуск не связан с выбранной исходной сессией.",
-    );
-  }
-  if (binding.kind === "portable-result-review") {
-    return fetchPortableResultReview(binding, { fetcher, signal });
-  }
-  const result = await fetchVegetationShadowResultMetadata(binding.resultId, {
-    fetcher,
-    signal,
-  });
-  return {
-    kind: "canonical-recorded-rerun",
-    review: admitObservatoryRecordedRunReview(
-      binding,
-      selectedSourceSessionId,
-      result,
-    ),
-  };
-}
-
-export function admitObservatoryRecordedRunReview(
-  binding: ObservatoryCanonicalRecordedRunBinding,
-  selectedSourceSessionId: string,
-  result: VegetationShadowResult,
-): VegetationFullRouteReview {
-  if (binding.sourceSessionId !== selectedSourceSessionId) {
-    throw new ObservatoryRecordedRunContractError(
-      "Запуск не связан с выбранной исходной сессией.",
-    );
-  }
-  if (result.resultId !== binding.resultId) {
-    throw new ObservatoryRecordedRunContractError(
-      "Запечатанный результат не совпадает с выбранным запуском.",
-    );
-  }
-  const review = result.routeFullReview;
-  if (!review || review.sessionId !== binding.sourceSessionId) {
-    throw new ObservatoryRecordedRunContractError(
-      "Запечатанный результат потерял точную связь с исходной сессией.",
-    );
-  }
-  return review;
-}
-
-async function fetchPortableResultReview(
-  binding: ObservatoryPortableResultBinding,
-  {
-    fetcher,
-    signal,
-  }: {
-    fetcher: LaboratoryFetch;
-    signal?: AbortSignal;
-  },
-): Promise<ObservatoryPortableResultReview> {
-  const response = await fetcher(
-    `/api/v1/observatory/portable-results/${encodeURIComponent(binding.resultId)}`,
-    { headers: { Accept: "application/json" }, signal },
-  );
-  let body: unknown;
-  try {
-    body = await response.json();
-  } catch {
-    throw new ObservatoryRecordedRunContractError(
-      "Portable viewer получил некорректный ответ сервера.",
-    );
-  }
-  if (!response.ok) {
-    throw new ObservatoryRecordedRunContractError(
-      isRecord(body) && typeof body.detail === "string"
-        ? body.detail
-        : `Portable viewer вернул HTTP ${response.status}.`,
-    );
-  }
-  return decodePortableResultReview(body, binding);
-}
-
-function decodePortableResultReview(
-  value: unknown,
-  binding: ObservatoryPortableResultBinding,
-): ObservatoryPortableResultReview {
-  if (!isRecord(value)) {
-    throw new ObservatoryRecordedRunContractError("Portable viewer вернул не объект.");
-  }
-  const expected = new Set([
-    "schema_version",
-    "result_id",
-    "source_session_id",
-    "result_kind",
-    "definition_sha256",
-    "viewer_capability",
-    "calculation_profile",
-    "artifact_manifest_id",
-    "artifacts",
-    "result_document",
-  ]);
-  if (Object.keys(value).some((key) => !expected.has(key)) || Object.keys(value).length !== expected.size) {
-    throw new ObservatoryRecordedRunContractError("Portable viewer изменил контракт ответа.");
-  }
-  let viewerCapability;
-  try {
-    viewerCapability = decodeLabReplayCapability(
-      value.viewer_capability,
-      binding.evidenceSessionId,
-    );
-  } catch (error) {
-    if (!(error instanceof ObservationLabReplayCapabilityContractError)) throw error;
-    throw new ObservatoryRecordedRunContractError(error.message);
-  }
-  if (
-    value.schema_version !== "missioncore.observatory-portable-result-view/v1"
-    || value.result_id !== binding.resultId
-    || value.source_session_id !== binding.sourceSessionId
-    || value.definition_sha256 !== binding.definitionSha256
-    || typeof value.result_kind !== "string"
-    || typeof value.artifact_manifest_id !== "string"
-    || !/^[a-f0-9]{64}$/.test(value.artifact_manifest_id)
-    || !Array.isArray(value.artifacts)
-    || !isRecord(value.result_document)
-    || !isRecord(value.calculation_profile)
-    || viewerCapability === null
-    || viewerCapability.kind !== "portable-result-review"
-    || viewerCapability.viewerProfile !== binding.viewerProfile
-    || viewerCapability.timeline !== binding.timeline
-  ) {
-    throw new ObservatoryRecordedRunContractError("Portable viewer потерял identity результата.");
-  }
-  const artifacts = value.artifacts.map((item) => {
-    if (
-      !isRecord(item)
-      || Object.keys(item).length !== 4
-      || !["role", "media_type", "sha256", "byte_length"].every(
-        (key) => Object.prototype.hasOwnProperty.call(item, key),
-      )
-      || typeof item.role !== "string"
-      || typeof item.media_type !== "string"
-      || typeof item.sha256 !== "string"
-      || !/^[a-f0-9]{64}$/.test(item.sha256)
-      || typeof item.byte_length !== "number"
-      || !Number.isSafeInteger(item.byte_length)
-      || item.byte_length < 0
-    ) {
-      throw new ObservatoryRecordedRunContractError("Portable viewer получил неверный artifact.");
-    }
-    return {
-      role: item.role,
-      mediaType: item.media_type,
-      sha256: item.sha256,
-      byteLength: item.byte_length,
-    };
-  });
-  return {
-    kind: "portable-result",
-    resultId: binding.resultId,
-    sourceSessionId: binding.sourceSessionId,
-    resultKind: value.result_kind,
-    definitionSha256: binding.definitionSha256,
-    calculationProfile: value.calculation_profile,
-    artifactManifestId: value.artifact_manifest_id,
-    artifacts,
-    resultDocument: value.result_document,
-  };
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
@@ -1,98 +0,0 @@
-import { useCallback, useEffect, useState } from "react";
-
-import {
-  AI_MODULE_SETUP_IDS,
-  fetchAIModuleCatalog,
-  fetchAICompositionJobs,
-  fetchAICompositionRuns,
-  type AICompositionRun,
-} from "./aiComposition";
-import { fetchRecordedProgress, type RecordedProgressView } from "./recordedProgress";
-import type { ObservatoryRecordedJob } from "./recordedJobs";
-
-const OPEN = new Set(["accepted", "queued", "claimed", "running", "paused",
-  "preemption-pending", "reconciliation-required"]);
-
-interface Snapshot {
-  readonly sourceSessionId: string;
-  readonly jobs: readonly ObservatoryRecordedJob[];
-  readonly runs: readonly AICompositionRun[];
-  readonly moduleLabelsBySetup: Readonly<Record<string, string>>;
-  readonly progress: Readonly<Record<string, RecordedProgressView>>;
-  readonly error: string | null;
-}
-
-export function useAICompositionJobs(sourceSessionId: string) {
-  const [revision, setRevision] = useState(0);
-  const [snapshot, setSnapshot] = useState<Snapshot>({
-    sourceSessionId: "", jobs: [], runs: [], moduleLabelsBySetup: {}, progress: {}, error: null,
-  });
-  const current = snapshot.sourceSessionId === sourceSessionId ? snapshot : {
-    sourceSessionId, jobs: [], runs: [], moduleLabelsBySetup: {}, progress: {}, error: null,
-  };
-
-  useEffect(() => {
-    if (!sourceSessionId) {
-      setSnapshot({ sourceSessionId, jobs: [], runs: [], moduleLabelsBySetup: {}, progress: {}, error: null });
-      return;
-    }
-    const request = new AbortController();
-    void Promise.all([
-      fetchAICompositionJobs(sourceSessionId, request.signal),
-      fetchAICompositionRuns(sourceSessionId, request.signal),
-      fetchAIModuleCatalog(request.signal),
-    ]).then(async ([jobs, runs, catalog]) => {
-      const active = jobs.filter((job) => OPEN.has(job.state));
-      const samples = await Promise.all(active.map(async (job) => [
-        job.jobId, await fetchRecordedProgress(job, { signal: request.signal }).catch(() => null),
-      ] as const));
-      if (request.signal.aborted) return;
-      const catalogLabels = catalog.groups.flatMap(({ modules }) => (
-        modules.flatMap((module) => {
-          const setupId = AI_MODULE_SETUP_IDS[module.moduleId];
-          return setupId ? [[setupId, module.label] as const] : [];
-        })
-      ));
-      const projectedLabels = runs.flatMap((run) => run.presentation.modules.flatMap((module) => {
-        const setupId = AI_MODULE_SETUP_IDS[module.moduleId];
-        return setupId ? [[setupId, module.label] as const] : [];
-      }));
-      setSnapshot({
-        sourceSessionId, jobs, runs,
-        moduleLabelsBySetup: Object.fromEntries([...catalogLabels, ...projectedLabels]),
-        progress: Object.fromEntries(samples.filter(
-          (sample): sample is readonly [string, RecordedProgressView] => sample[1] !== null,
-        )),
-        error: null,
-      });
-    }).catch((error: unknown) => {
-      if (request.signal.aborted) return;
-      setSnapshot((value) => ({
-        sourceSessionId, jobs: value.sourceSessionId === sourceSessionId ? value.jobs : [],
-        runs: value.sourceSessionId === sourceSessionId ? value.runs : [],
-        moduleLabelsBySetup: value.sourceSessionId === sourceSessionId
-          ? value.moduleLabelsBySetup : {},
-        progress: value.sourceSessionId === sourceSessionId ? value.progress : {},
-        error: error instanceof Error ? error.message : "Очередь AI-слоёв недоступна.",
-      }));
-    });
-    return () => request.abort();
-  }, [revision, sourceSessionId]);
-
-  const active = current.runs.some((run) => run.state === "running")
-    || current.jobs.some((job) => OPEN.has(job.state) || job.publication.state === "pending");
-  useEffect(() => {
-    if (!active) return;
-    const timer = globalThis.setTimeout(() => setRevision((value) => value + 1), 1_500);
-    return () => globalThis.clearTimeout(timer);
-  }, [active, revision]);
-
-  return {
-    jobs: current.jobs,
-    runs: current.runs,
-    moduleLabelsBySetup: current.moduleLabelsBySetup,
-    progress: current.progress,
-    error: current.error,
-    refresh: useCallback(() => setRevision((value) => value + 1), []),
-  };
-}
@@ -1,148 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from "react";
-
-import {
-  applyObservatoryCatalogMutationOverlay,
-  fetchObservatoryCatalog,
-  reconcileObservatoryCatalogMutationOverlay,
-  type ObservatoryCatalog,
-  type ObservatoryCatalogMutationOverlay,
-} from "./catalog";
-
-export type ObservatoryCatalogState =
-  | "idle"
-  | "loading"
-  | "ready"
-  | "refreshing"
-  | "error";
-
-export interface ObservatoryCatalogController {
-  readonly catalog: ObservatoryCatalog | null;
-  readonly state: ObservatoryCatalogState;
-  readonly error: string | null;
-  readonly refresh: () => Promise<ObservatoryCatalog | null>;
-  readonly applyEvidenceRename: (
-    sessionId: string,
-    displayName: string,
-  ) => void;
-  readonly applyEvidenceDeletion: (sessionId: string) => void;
-}
-
-interface ActiveCatalogRequest {
-  readonly id: number;
-  readonly controller: AbortController;
-}
-
-type ObservatoryCatalogMutationDraft =
-  | { readonly kind: "rename"; readonly displayName: string }
-  | { readonly kind: "delete" };
-
-function errorMessage(error: unknown): string {
-  return error instanceof Error && error.message.trim()
-    ? error.message
-    : "Каталог AI Inference недоступен.";
-}
-
-function isAbortError(error: unknown): boolean {
-  return error instanceof DOMException && error.name === "AbortError";
-}
-
-export function useObservatoryCatalog(): ObservatoryCatalogController {
-  const [catalog, setCatalog] = useState<ObservatoryCatalog | null>(null);
-  const [state, setState] = useState<ObservatoryCatalogState>("idle");
-  const [error, setError] = useState<string | null>(null);
-  const catalogRef = useRef<ObservatoryCatalog | null>(null);
-  const overlayRef = useRef<ObservatoryCatalogMutationOverlay>(new Map());
-  const mutationRevisionRef = useRef(0);
-  const requestSequenceRef = useRef(0);
-  const activeRequestRef = useRef<ActiveCatalogRequest | null>(null);
-
-  const loadCatalog = useCallback(async (): Promise<ObservatoryCatalog | null> => {
-    const id = requestSequenceRef.current + 1;
-    requestSequenceRef.current = id;
-    activeRequestRef.current?.controller.abort();
-    const controller = new AbortController();
-    activeRequestRef.current = { id, controller };
-    const requestMutationRevision = mutationRevisionRef.current;
-
-    setState(catalogRef.current ? "refreshing" : "loading");
-    setError(null);
-    try {
-      const serverCatalog = await fetchObservatoryCatalog({
-        signal: controller.signal,
-      });
-      if (controller.signal.aborted || requestSequenceRef.current !== id) {
-        return null;
-      }
-      const reconciled = reconcileObservatoryCatalogMutationOverlay(
-        serverCatalog,
-        overlayRef.current,
-        requestMutationRevision,
-      );
-      overlayRef.current = reconciled.overlay;
-      catalogRef.current = reconciled.catalog;
-      activeRequestRef.current = null;
-      setCatalog(reconciled.catalog);
-      setState("ready");
-      return reconciled.catalog;
-    } catch (loadError: unknown) {
-      if (
-        controller.signal.aborted
-        || requestSequenceRef.current !== id
-        || isAbortError(loadError)
-      ) {
-        return null;
-      }
-      activeRequestRef.current = null;
-      setError(errorMessage(loadError));
-      setState("error");
-      return null;
-    }
-  }, []);
-
-  useEffect(() => {
-    void loadCatalog();
-    return () => {
-      requestSequenceRef.current += 1;
-      activeRequestRef.current?.controller.abort();
-      activeRequestRef.current = null;
-    };
-  }, [loadCatalog]);
-
-  const applyMutation = useCallback((
-    sessionId: string,
-    mutation: ObservatoryCatalogMutationDraft,
-  ) => {
-    const revision = mutationRevisionRef.current + 1;
-    mutationRevisionRef.current = revision;
-    const overlay = new Map(overlayRef.current);
-    overlay.set(sessionId, { ...mutation, revision });
-    overlayRef.current = overlay;
-    if (!catalogRef.current) return;
-    const projected = applyObservatoryCatalogMutationOverlay(
-      catalogRef.current,
-      overlay,
-    );
-    catalogRef.current = projected;
-    setCatalog(projected);
-  }, []);
-
-  const applyEvidenceRename = useCallback((
-    sessionId: string,
-    displayName: string,
-  ) => {
-    applyMutation(sessionId, { kind: "rename", displayName });
-  }, [applyMutation]);
-
-  const applyEvidenceDeletion = useCallback((sessionId: string) => {
-    applyMutation(sessionId, { kind: "delete" });
-  }, [applyMutation]);
-
-  return {
-    catalog,
-    state,
-    error,
-    refresh: loadCatalog,
-    applyEvidenceRename,
-    applyEvidenceDeletion,
-  };
-}
@@ -1,132 +0,0 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-
-import {
-  fetchObservatoryPortableLaboratorySetups,
-  preflightObservatoryLaboratorySetup,
-  selectableObservatorySetups,
-  type ObservatoryLaboratoryRunPreflight,
-  type ObservatoryLaboratorySetupCatalog,
-} from "./laboratorySetups";
-
-type SetupCatalogState = "idle" | "loading" | "ready" | "refreshing" | "error";
-export type SetupPreflightState =
-  | { readonly kind: "idle" }
-  | { readonly kind: "checking" }
-  | { readonly kind: "ready"; readonly value: ObservatoryLaboratoryRunPreflight }
-  | { readonly kind: "error"; readonly message: string };
-
-export function useObservatoryLaboratorySetups(sourceSessionId: string) {
-  const [catalog, setCatalog] = useState<ObservatoryLaboratorySetupCatalog | null>(null);
-  const [state, setState] = useState<SetupCatalogState>("idle");
-  const [error, setError] = useState<string | null>(null);
-  const [selectedSetupId, setSelectedSetupId] = useState("");
-  const [revision, setRevision] = useState(0);
-  const [preflight, setPreflight] = useState<SetupPreflightState>({ kind: "idle" });
-  const requestSequence = useRef(0);
-  const preflightRequest = useRef<AbortController | null>(null);
-  const activeCatalog = catalog?.sourceSessionId === sourceSessionId ? catalog : null;
-  const selectableSetups = useMemo(() => selectableObservatorySetups(activeCatalog), [activeCatalog]);
-  const selectedSetup = selectableSetups.find((setup) => setup.setupId === selectedSetupId) ?? null;
-  const selectedDefinitionSha256 = selectedSetup?.runDefinition?.definitionSha256 ?? null;
-
-  useEffect(() => {
-    preflightRequest.current?.abort();
-    preflightRequest.current = null;
-    if (!sourceSessionId) {
-      setCatalog(null);
-      setState("idle");
-      setError(null);
-      setSelectedSetupId("");
-      setPreflight({ kind: "idle" });
-      return;
-    }
-    const sequence = ++requestSequence.current;
-    const request = new AbortController();
-    setState((current) => activeCatalog && current !== "idle" ? "refreshing" : "loading");
-    setError(null);
-    setPreflight({ kind: "idle" });
-    // Archived definitions belong to evidence, not to the calculation selector.
-    void fetchObservatoryPortableLaboratorySetups(sourceSessionId, { signal: request.signal })
-      .then((next) => {
-        if (request.signal.aborted || requestSequence.current !== sequence) return;
-        setCatalog(next);
-        const selectable = selectableObservatorySetups(next);
-        setSelectedSetupId((current) => (
-          selectable.some((setup) => setup.setupId === current)
-            ? current
-            : selectable[0]?.setupId ?? ""
-        ));
-        setState("ready");
-      })
-      .catch((caught: unknown) => {
-        if (request.signal.aborted || requestSequence.current !== sequence) return;
-        setState("error");
-        setError(caught instanceof Error && caught.message.trim()
-          ? caught.message
-          : "Каталог профилей недоступен.");
-      });
-    return () => request.abort();
-  }, [revision, sourceSessionId]);
-
-  useEffect(() => () => preflightRequest.current?.abort(), []);
-
-  useEffect(() => {
-    preflightRequest.current?.abort();
-    preflightRequest.current = null;
-    setPreflight((current) => current.kind === "idle" ? current : { kind: "idle" });
-  }, [selectedSetupId, sourceSessionId, selectedDefinitionSha256]);
-
-  const selectSetup = useCallback((setupId: string) => {
-    preflightRequest.current?.abort();
-    preflightRequest.current = null;
-    setSelectedSetupId(setupId);
-    setPreflight({ kind: "idle" });
-  }, []);
-
-  const refresh = useCallback(() => setRevision((value) => value + 1), []);
-
-  const check = useCallback(async () => {
-    if (!sourceSessionId || !selectedSetup || preflight.kind === "checking") return;
-    preflightRequest.current?.abort();
-    const request = new AbortController();
-    preflightRequest.current = request;
-    setPreflight({ kind: "checking" });
-    try {
-      const value = await preflightObservatoryLaboratorySetup(
-        sourceSessionId,
-        selectedSetup,
-        { signal: request.signal },
-      );
-      if (request.signal.aborted || preflightRequest.current !== request) return;
-      setPreflight({ kind: "ready", value });
-    } catch (caught) {
-      if (request.signal.aborted || preflightRequest.current !== request) return;
-      setPreflight({
-        kind: "error",
-        message: caught instanceof Error && caught.message.trim()
-          ? caught.message
-          : "Не удалось проверить возможность запуска.",
-      });
-    } finally {
-      if (preflightRequest.current === request) preflightRequest.current = null;
-    }
-  }, [preflight.kind, selectedSetup, sourceSessionId]);
-
-  useEffect(() => {
-    if (state !== "ready" || !selectedSetup || preflight.kind !== "idle") return;
-    void check();
-  }, [check, preflight.kind, selectedSetup, state]);
-
-  return {
-    catalog: activeCatalog,
-    selectableSetups,
-    state,
-    error,
-    selectedSetupId: selectedSetup?.setupId ?? "",
-    selectedSetup,
-    selectSetup,
-    refresh,
-    preflight,
-    check,
-  };
-}
@@ -1,207 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from "react";
-import { fetchRecordedProgress, type RecordedProgressView } from "./recordedProgress";
-
-import {
-  fetchObservatoryRecordedJobs,
-  retryObservatoryRecordedJobPublication,
-  submitObservatoryRecordedJob,
-  type ObservatoryRecordedJob,
-} from "./recordedJobs";
-
-type RecordedJobsState =
-  | "idle"
-  | "loading"
-  | "ready"
-  | "refreshing"
-  | "submitting"
-  | "retrying-publication"
-  | "error";
-
-interface JobSnapshot {
-  readonly selectionKey: string;
-  readonly jobs: readonly ObservatoryRecordedJob[];
-  readonly state: RecordedJobsState;
-  readonly error: string | null;
-  readonly progress?: RecordedProgressView | null;
-}
-const EMPTY_JOBS = [] as const;
-const OPEN_STATES = new Set([
-  "accepted", "queued", "claimed", "running", "paused", "preemption-pending",
-  "reconciliation-required",
-]);
-const POLL_INTERVAL_MS = 1_500;
-
-export function useObservatoryRecordedJobs(
-  sourceSessionId: string,
-  setupId: string,
-  definitionSha256: string,
-) {
-  const selectionKey = JSON.stringify([sourceSessionId, setupId, definitionSha256]);
-  const [snapshot, setSnapshot] = useState<JobSnapshot>({
-    selectionKey: "", jobs: EMPTY_JOBS, state: "idle", error: null,
-  });
-  const [revision, setRevision] = useState(0);
-  const requestRef = useRef<AbortController | null>(null);
-  const requestSequence = useRef(0);
-  const idempotencyKeys = useRef(new Map<string, string>());
-  const observedJobId = useRef<string | null>(null);
-  const hasSelection = Boolean(sourceSessionId && setupId && definitionSha256);
-  // A source/profile change must not display even one render of the previous queue.
-  const current = snapshot.selectionKey === selectionKey ? snapshot : null;
-  const jobs = current?.jobs ?? EMPTY_JOBS;
-  const state = current?.state ?? (hasSelection ? "loading" : "idle");
-  const error = current?.error ?? null;
-
-  useEffect(() => {
-    requestRef.current?.abort();
-    requestRef.current = null;
-    if (!hasSelection) {
-      setSnapshot({ selectionKey, jobs: EMPTY_JOBS, state: "idle", error: null });
-      return;
-    }
-    const sequence = ++requestSequence.current;
-    const request = new AbortController();
-    requestRef.current = request;
-    setSnapshot({
-      selectionKey, jobs,
-      state: jobs.length > 0 ? "refreshing" : "loading", error: null,
-      progress: current?.progress ?? null,
-    });
-    void fetchObservatoryRecordedJobs(sourceSessionId, setupId, {
-      definitionSha256, signal: request.signal,
-    }).then(async (next) => {
-      if (request.signal.aborted || requestSequence.current !== sequence) return;
-      const pending = next.find((job) => OPEN_STATES.has(job.state));
-      const progress = pending
-        ? await fetchRecordedProgress(pending, { signal: request.signal }).catch(() => null)
-        : null;
-      if (request.signal.aborted || requestSequence.current !== sequence) return;
-      if (pending) observedJobId.current = pending.jobId;
-      setSnapshot({ selectionKey, jobs: next, state: "ready", error: null, progress });
-    }).catch((caught: unknown) => {
-      if (request.signal.aborted || requestSequence.current !== sequence) return;
-      setSnapshot({
-        selectionKey, jobs, state: "error",
-        error: caught instanceof Error && caught.message.trim()
-          ? caught.message
-          : "Очередь расчётов недоступна.",
-      });
-    }).finally(() => {
-      if (requestRef.current === request) requestRef.current = null;
-    });
-    return () => request.abort();
-  }, [revision, selectionKey]);
-
-  useEffect(() => () => requestRef.current?.abort(), []);
-
-  const latestJob = jobs[0] ?? null;
-  const activeJob = jobs.find((job) => OPEN_STATES.has(job.state)) ?? null;
-  const publicationPending = jobs.some((job) => job.publication.state === "pending");
-  // Do not promote historical terminal logs to a new operator action's error.
-  const computationFailed = latestJob?.state === "failed"
-    && latestJob.jobId === observedJobId.current;
-
-  useEffect(() => {
-    if ((state !== "ready" && state !== "error") || (!activeJob && !publicationPending)) return;
-    const timer = globalThis.setTimeout(
-      () => setRevision((value) => value + 1),
-      POLL_INTERVAL_MS,
-    );
-    return () => globalThis.clearTimeout(timer);
-  }, [activeJob, publicationPending, revision, state]);
-
-  useEffect(() => {
-    if (!latestJob || activeJob) return;
-    idempotencyKeys.current.delete(selectionKey);
-  }, [activeJob, latestJob, selectionKey]);
-
-  const refresh = useCallback(() => setRevision((value) => value + 1), []);
-
-  const submit = useCallback(async (
-    portableBinding: {
-      readonly definitionSha256: string;
-      readonly checkSha256: string;
-    } | null = null,
-  ): Promise<ObservatoryRecordedJob | null> => {
-    if (!hasSelection || state !== "ready"
-      || portableBinding?.definitionSha256 !== definitionSha256
-      || publicationPending || latestJob?.publication.state === "failed") return null;
-    if (activeJob) return activeJob;
-    requestRef.current?.abort();
-    const request = new AbortController();
-    requestRef.current = request;
-    const key = idempotencyKeys.current.get(selectionKey) ?? createIdempotencyKey();
-    idempotencyKeys.current.set(selectionKey, key);
-    setSnapshot({ selectionKey, jobs, state: "submitting", error: null });
-    try {
-      const job = await submitObservatoryRecordedJob(
-        sourceSessionId, setupId, key, portableBinding, { signal: request.signal },
-      );
-      if (request.signal.aborted || requestRef.current !== request) return null;
-      observedJobId.current = job.jobId;
-      setSnapshot({
-        selectionKey, jobs: [job, ...jobs.filter((candidate) => candidate.jobId !== job.jobId)],
-        state: "ready", error: null,
-      });
-      return job;
-    } catch (caught) {
-      if (request.signal.aborted || requestRef.current !== request) return null;
-      setSnapshot({
-        selectionKey, jobs, state: "error",
-        error: caught instanceof Error && caught.message.trim()
-          ? caught.message
-          : "Не удалось поставить расчёт в очередь.",
-      });
-      return null;
-    } finally {
-      if (requestRef.current === request) requestRef.current = null;
-    }
-  }, [activeJob, definitionSha256, hasSelection, jobs, latestJob,
-    publicationPending, selectionKey, setupId, sourceSessionId, state]);
-
-  const retryPublication = useCallback(async (): Promise<ObservatoryRecordedJob | null> => {
-    if (!latestJob || latestJob.publication.state !== "failed"
-      || state === "retrying-publication") return null;
-    requestRef.current?.abort();
-    const request = new AbortController();
-    requestRef.current = request;
-    setSnapshot({ selectionKey, jobs, state: "retrying-publication", error: null });
-    try {
-      const job = await retryObservatoryRecordedJobPublication(latestJob.jobId, {
-        signal: request.signal,
-      });
-      if (request.signal.aborted || requestRef.current !== request) return null;
-      setSnapshot({
-        selectionKey, jobs: [job, ...jobs.filter((candidate) => candidate.jobId !== job.jobId)],
-        state: "ready", error: null,
-      });
-      return job;
-    } catch (caught) {
-      if (request.signal.aborted || requestRef.current !== request) return null;
-      setSnapshot({
-        selectionKey, jobs, state: "error",
-        error: caught instanceof Error && caught.message.trim()
-          ? caught.message
-          : "Не удалось повторить публикацию результата.",
-      });
-      return null;
-    } finally {
-      if (requestRef.current === request) requestRef.current = null;
-    }
-  }, [jobs, latestJob, selectionKey, state]);
-
-  return {
-    jobs, latestJob, activeJob, publicationPending, computationFailed,
-    progress: current?.progress ?? null,
-    state, error, refresh, submit, retryPublication,
-  };
-}
-
-function createIdempotencyKey(): string {
-  const entropy = typeof globalThis.crypto?.randomUUID === "function"
-    ? globalThis.crypto.randomUUID()
-    : `${Date.now().toString(36)}-${Math.random().toString(16).slice(2)}`;
-  return `observatory-ui:${entropy}`;
-}
-
-export type ObservatoryRecordedJobsController = ReturnType<typeof useObservatoryRecordedJobs>;
@@ -38,8 +38,6 @@ export function useWorkerTelemetry(
      setError(null);
      return;
    }
-    setTelemetry(null);
-    setError(null);
    const controller = new AbortController();
    const stopPolling = startSequentialPolling(async () => {
      setLoading(true);
@@ -50,7 +48,6 @@ export function useWorkerTelemetry(
        setError(null);
      } catch (reason: unknown) {
        if (controller.signal.aborted) return;
-        setTelemetry(null);
        setError(
          reason instanceof Error
            ? reason.message
@@ -114,9 +114,6 @@ export interface WorkerTelemetry {
      power_watts?: number;
      temperature_celsius?: number;
      memory_used_percent?: number;
-      sm_clock_mhz?: number | null;
-      memory_clock_mhz?: number | null;
-      driver_version?: string | null;
    } | null;
    triton: {
      ready: boolean;
@@ -134,13 +131,6 @@ export interface WorkerTelemetry {
    completed_runs: number | null;
    failed_runs: number | null;
    model_load_seconds: number | null;
-    profile_name?: string | null;
-    input_state?: string | null;
-    wait_reason?: string | null;
-    live_children?: number | null;
-    input_pauses?: number | null;
-    pending_bundles?: number | null;
-    buffer_bytes?: number | null;
    stages: WorkerPipelineStage[];
  };
  network: {
@@ -199,9 +189,7 @@ export async function fetchWorkerTelemetry(
      `/api/v1/system/contours/${encodeURIComponent(contourId)}/telemetry?history=90`,
      {
        method: "GET",
-        signal: signal
-          ? AbortSignal.any([signal, AbortSignal.timeout(5_000)])
-          : AbortSignal.timeout(5_000),
+        signal,
      },
    ),
    "missioncore.worker-telemetry/v1",
@@ -6,7 +6,7 @@ import "@nodedc/tokens/themes.css";
 import "@nodedc/ui-core/styles.css";

 import App from "./App";
-import { installedDevicePlugins, installedNodeSensorContributions } from "./composition/devicePlugins";
+import { installedDevicePlugins } from "./composition/devicePlugins";
 import { DevicePluginHostProvider } from "./core/device-plugins/DevicePluginHost";
 import { ComputeContourProvider } from "./core/system/ComputeContourContext";
 import "./styles.css";
@@ -23,7 +23,7 @@ applyNodedcTheme(rootElement, { theme: "dark" });

 createRoot(rootElement).render(
  <StrictMode>
-    <DevicePluginHostProvider plugins={installedDevicePlugins} nodeSensorContributions={installedNodeSensorContributions}>
+    <DevicePluginHostProvider plugins={installedDevicePlugins}>
      <ComputeContourProvider>
        <App />
      </ComputeContourProvider>
@@ -16,7 +16,6 @@ export type WorkspaceKind =
  | "map"
  | "timeline"
  | "missions"
-  | "vehicles"
  | "catalog"
  | "contour-health"
  | "compute-modules"
@@ -24,8 +23,7 @@ export type WorkspaceKind =
  | "datasets"
  | "artifact-health"
  | "lab-archive"
-  | "simulations"
-  | "observatory";
+  | "simulations";

 export type CapabilityStatus = "active" | "ready" | "contract" | "later";

@@ -94,7 +92,7 @@ export const roots: RootDefinition[] = [
    label: "Парк",
    title: "Аппараты и устройства",
    eyebrow: "ПАРК / УСТРОЙСТВА",
-    description: "Реестр аппаратов, бортовые компьютеры, сенсоры и конфигурации борта.",
+    description: "Реестр аппаратов, локальное подключение, сенсоры и конфигурации борта.",
    statement: "Одинаково подключать одиночный стенд, наземную платформу и будущий рой.",
    accent: "АППАРАТЫ И ПОЛЕЗНАЯ НАГРУЗКА",
  },
@@ -168,17 +166,6 @@ export const workspaces: WorkspaceDefinition[] = [
    kind: "simulations",
    groups: [],
  },
-  {
-    id: "observatory",
-    root: "polygon",
-    label: "AI Inference",
-    title: "AI Inference",
-    eyebrow: "ТЕСТОВЫЙ КОНТУР / AI INFERENCE",
-    description: "Сессии и квалификация без доступа к управлению.",
-    icon: "eye",
-    kind: "observatory",
-    groups: [],
-  },
  {
    id: "contour-health",
    root: "fleet",
@@ -194,20 +181,31 @@ export const workspaces: WorkspaceDefinition[] = [
    id: "vehicles",
    root: "fleet",
    label: "Аппараты",
-    title: "Аппараты",
+    title: "Реестр аппаратов",
    eyebrow: "ПАРК / РЕЕСТР",
-    description: "Аппараты и их бортовые компьютеры в частном контуре.",
+    description: "Нейтральный реестр наземных, воздушных и стационарных платформ.",
    icon: "apps",
-    kind: "vehicles",
-    groups: [],
+    kind: "catalog",
+    groups: [
+      {
+        title: "Идентичность аппарата",
+        description: "Никакой привязки продуктовой модели к конкретному производителю.",
+        capabilities: [
+          ready("Локальный стенд", "Первый аппарат представлен текущим устройством и его адаптером."),
+          contract("Паспорт борта", "Тип, серийный профиль, вычислитель, питание и транспорт."),
+          contract("Состояние доступности", "Онлайн, занят, обслуживание, потеря связи."),
+          later("Группы и рои", "Логические группы, роли и совместное назначение миссий."),
+        ],
+      },
+    ],
  },
  {
    id: "local-device",
-    root: "polygon",
-    label: "Тестовые устройства",
-    title: "Тестовые устройства",
-    eyebrow: "LAB / ТЕСТОВЫЕ УСТРОЙСТВА",
-    description: "Подключение устройств к компьютеру оператора для испытаний и записи.",
+    root: "fleet",
+    label: "Подключение",
+    title: "Подключение",
+    eyebrow: "ПАРК / ТЕКУЩИЙ АДАПТЕР",
+    description: "Выбор модели, сценарий установленного плагина и запуск доступного потока.",
    icon: "network",
    kind: "device",
    groups: [],
@@ -258,11 +256,11 @@ export const workspaces: WorkspaceDefinition[] = [
  },
  {
    id: "spatial-scene",
-    root: "polygon",
+    root: "observation",
    label: "Пространственная сцена",
    title: "Пространственная сцена",
-    eyebrow: "LAB / ПРОСТРАНСТВЕННАЯ СЦЕНА",
-    description: "Облако точек, камеры и траектория тестового устройства в реальном времени.",
+    eyebrow: "НАБЛЮДЕНИЕ / ЭФИР",
+    description: "Облако точек, траектория, преобразования и пространственные слои в единой 3D-сцене.",
    icon: "globe",
    kind: "spatial",
    groups: [
@@ -1 +1,31 @@
-export * from "../../../packages/spatial-ui/src/sceneSettings";
+export type SceneProjection = "3d" | "2d" | "map";
+export type PointColorMode = "intensity" | "height" | "distance" | "rgb" | "class";
+export type PointPalette = "turbo" | "viridis" | "plasma" | "grayscale" | "custom";
+
+export interface SceneSettings {
+  projection: SceneProjection;
+  pointSize: number;
+  colorMode: PointColorMode;
+  palette: PointPalette;
+  customColor: string;
+  accumulationSeconds: number;
+  showPoints: boolean;
+  showTrajectory: boolean;
+  showGrid: boolean;
+  showLabels: boolean;
+  showCameraFrustums: boolean;
+}
+
+export const defaultSceneSettings: SceneSettings = {
+  projection: "3d",
+  pointSize: 2.5,
+  colorMode: "intensity",
+  palette: "turbo",
+  customColor: "#35d7c1",
+  accumulationSeconds: 12,
+  showPoints: true,
+  showTrajectory: true,
+  showGrid: true,
+  showLabels: false,
+  showCameraFrustums: true,
+};
@@ -21,7 +21,7 @@
@import "./styles/device.css";
@import "./styles/responsive.css";
@import "./styles/observation.css";
-@import "./styles/observatory.css";
+@import "./styles/environment-settings.css";
@import "./styles/system-telemetry.css";
@import "./styles/artifact-health.css";
@import "./styles/map.css";
@@ -0,0 +1,141 @@
+.environment-settings {
+  display: grid;
+  gap: 1rem;
+}
+
+.environment-settings__copy {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 0.85rem;
+}
+
+.environment-settings__editor {
+  display: grid;
+  gap: 1rem;
+}
+
+.environment-settings__surface {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(18rem, 24rem);
+  align-items: center;
+  gap: 1rem;
+}
+
+.environment-settings__surface > span {
+  color: var(--nodedc-text-secondary);
+  font-size: 0.74rem;
+  font-weight: 650;
+}
+
+.environment-settings__surface .nodedc-select-anchor,
+.environment-settings__surface .nodedc-select {
+  width: 100%;
+}
+
+.environment-settings__quick-actions {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 0.85rem;
+}
+
+.environment-settings__quick-actions > div {
+  display: grid;
+  gap: 0.4rem;
+}
+
+.environment-settings__quick-actions span {
+  color: var(--nodedc-text-secondary);
+  font-size: 0.68rem;
+  font-weight: 650;
+}
+
+.environment-settings__quick-actions .nodedc-select-anchor,
+.environment-settings__quick-actions .nodedc-select {
+  width: 100%;
+}
+
+.environment-media-playlist {
+  display: grid;
+  min-width: 0;
+  gap: 0.85rem;
+}
+
+.environment-media-playlist__head {
+  display: flex;
+  min-width: 0;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+}
+
+.environment-media-playlist__head > div {
+  display: grid;
+  min-width: 0;
+  gap: 0.22rem;
+}
+
+.environment-media-playlist__head span {
+  color: var(--nodedc-text-secondary);
+  font-size: var(--nodedc-font-size-sm);
+  font-weight: var(--nodedc-font-weight-medium);
+}
+
+.environment-media-playlist__head p,
+.environment-media-playlist__empty,
+.environment-media-playlist__timing > span,
+.environment-media-playlist__error {
+  margin: 0;
+  color: var(--nodedc-text-muted);
+  font-size: var(--nodedc-font-size-xs);
+  line-height: 1.4;
+}
+
+.environment-media-playlist__error {
+  color: rgb(var(--nodedc-danger-rgb));
+}
+
+.environment-media-playlist__items {
+  display: grid;
+  min-width: 0;
+  gap: 0.7rem;
+}
+
+.environment-media-playlist__item {
+  display: grid;
+  min-width: 0;
+  grid-template-columns: minmax(0, 1fr) auto;
+  align-items: start;
+  gap: 0.4rem;
+}
+
+.environment-media-playlist__item-actions {
+  display: flex;
+  align-items: center;
+  gap: 0.1rem;
+  padding-top: 1.65rem;
+}
+
+.environment-media-playlist__timing {
+  display: grid;
+  gap: 0.42rem;
+}
+
+@media (max-width: 760px) {
+  .environment-settings__copy,
+  .environment-settings__quick-actions {
+    grid-template-columns: 1fr;
+  }
+
+  .environment-settings__surface {
+    grid-template-columns: 1fr;
+  }
+
+  .environment-media-playlist__item {
+    grid-template-columns: minmax(0, 1fr);
+  }
+
+  .environment-media-playlist__item-actions {
+    justify-self: end;
+    padding-top: 0;
+  }
+}
@@ -27,78 +27,6 @@
  display: block;
 }

-.m4-replay-threat-visual__unified-content {
-  position: absolute;
-  z-index: 1;
-  inset: 0;
-  min-width: 0;
-  min-height: 0;
-}
-
-.m4-replay-threat-visual__unified-content > *,
-.m4-replay-threat-visual__unified-content .rerun-viewport {
-  width: 100%;
-  height: 100%;
-}
-
-.m4-replay-threat-visual__deck[data-native-rerun="true"] > .nodedc-split-pane {
-  position: relative;
-  z-index: 2;
-  pointer-events: none;
-}
-
-.m4-replay-threat-visual__deck[data-native-rerun="true"]
-  .m4-replay-threat-visual__pane {
-  background: transparent;
-  pointer-events: none;
-}
-
-.m4-replay-threat-visual__deck[data-native-rerun="true"]
-  .nodedc-split-pane__separator,
-.m4-replay-threat-visual__deck[data-native-rerun="true"]
-  .m4-replay-threat-visual__pane-toolbar,
-.m4-replay-threat-visual__deck[data-native-rerun="true"]
-  .m4-replay-threat-visual__pane-toolbar * {
-  pointer-events: auto;
-}
-
-.canonical-vegetation-rerun-replay {
-  width: 100%;
-  min-width: 0;
-}
-
-.canonical-vegetation-rerun-replay:not([data-presentation-state="ready"])
-  .m4-replay-threat-visual__pane-toolbar,
-.canonical-vegetation-rerun-replay:not([data-presentation-state="ready"])
-  .laboratory-evidence-viewer__controls,
-.canonical-vegetation-rerun-replay:not([data-presentation-state="ready"])
-  .laboratory-evidence-viewer__transport {
-  visibility: hidden;
-  pointer-events: none;
-}
-
-.canonical-vegetation-rerun-replay[data-presentation-state="loading"]
-  .m4-replay-threat-visual__unified-content {
-  visibility: hidden;
-}
-
-.canonical-vegetation-rerun-replay__viewport-lock {
-  width: 100%;
-  height: 100%;
-  min-width: 0;
-  min-height: 0;
-}
-
-.canonical-vegetation-rerun-replay__loading {
-  position: absolute;
-  z-index: 6;
-  inset: 0;
-  display: grid;
-  place-items: center;
-  background: var(--nodedc-canvas);
-  pointer-events: none;
-}
-
 .m4-replay-threat-visual__deck[data-empty="true"] > .l3-visual-audit__state {
  position: absolute;
  z-index: 1;
@@ -145,14 +73,12 @@
  display: flex;
  min-width: 0;
  align-items: center;
-  align-content: flex-start;
-  flex-wrap: wrap;
  gap: 0.35rem;
  pointer-events: none;
 }

 .m4-replay-threat-visual__pane-toolbar[data-pane-toolbar="media"] {
-  justify-content: flex-start;
+  justify-content: flex-end;
 }

 .m4-replay-threat-evidence-viewer[data-mode-controls="content"]:has(
@@ -162,17 +88,12 @@
 }

 .m4-replay-threat-visual__pane-toolbar[data-pane-toolbar="spatial"] {
-  justify-content: flex-start;
+  justify-content: space-between;
 }

 .m4-replay-threat-evidence-viewer[data-mode-controls="content"]
-  .m4-replay-threat-visual__pane-toolbar[data-pane-toolbar="spatial"],
-.m4-replay-threat-evidence-viewer[data-mode-controls="content"]
-  .m4-replay-threat-visual__deck:not([data-split="true"])
-  .m4-replay-threat-visual__pane-toolbar[data-pane-toolbar="media"] {
-  /* The two viewer-wide actions stay at the deck's right edge. Keep their
-     complete hit area out of this viewport-owned toolbar at every split. */
-  right: 7rem;
+  .m4-replay-threat-visual__pane-toolbar[data-pane-toolbar="spatial"] {
+  right: 3.8rem;
 }

 .m4-replay-threat-visual__pane-toolbar > *,
@@ -181,15 +102,18 @@
 }

 .m4-replay-threat-visual__spatial-toolbar-end {
-  display: contents;
+  display: flex;
+  min-width: 0;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 0.35rem;
+  overflow-x: auto;
+  overscroll-behavior-inline: contain;
+  scrollbar-width: none;
 }

-.m4-replay-threat-visual__pane-toolbar > .m4-replay-threat-visual__pane-layer-controls,
-.m4-replay-threat-visual__spatial-toolbar-end > .m4-replay-threat-visual__pane-layer-controls {
-  /* A viewport toolbar is one adaptive flex sequence. `display: contents`
-     keeps the semantic layer group while allowing each control to move to the
-     next row only when the viewport itself runs out of width. */
-  display: contents;
+.m4-replay-threat-visual__spatial-toolbar-end::-webkit-scrollbar {
+  display: none;
 }

 .m4-replay-threat-visual__pane-mode-controls {
@@ -238,8 +162,7 @@
  display: flex;
  align-items: center;
  gap: 0.4rem;
-  border: 0;
-  outline: 0;
+  border: 1px solid var(--nodedc-glass-outline);
  border-radius: var(--nodedc-radius-control-compact);
  background: var(--nodedc-floating-surface);
  padding: 0.42rem 0.58rem;
@@ -260,15 +183,6 @@
  pointer-events: none;
 }

-.canonical-vegetation-rerun-replay
-  .m4-replay-threat-evidence-viewer[data-mode-controls="content"]
-  .laboratory-evidence-viewer__controls {
-  right: 0.6rem;
-  left: auto;
-  width: auto;
-  justify-content: flex-end;
-}
-
 .m4-replay-threat-evidence-viewer[data-mode-controls="content"] .laboratory-evidence-viewer__controls > .nodedc-icon-button {
  pointer-events: auto;
 }
@@ -293,30 +207,6 @@
  scrollbar-width: none;
 }

-.m4-replay-threat-visual__layer-with-settings {
-  display: inline-flex;
-  flex: none;
-  align-items: center;
-  gap: 0.18rem;
-  border: 0;
-  border-radius: 999px;
-  background: var(--nodedc-glass-control-bg);
-  padding: 0.12rem;
-}
-
-.m4-replay-threat-visual__layer-with-settings > .nodedc-icon-button {
-  width: 1.75rem;
-  height: 1.75rem;
-  border: 0;
-  outline: 0;
-  box-shadow: none;
-}
-
-.m4-replay-threat-visual__layer-with-settings > .nodedc-icon-button:focus-visible {
-  background: var(--nodedc-focus-surface);
-  box-shadow: inset 0 0 0 1px rgb(var(--nodedc-accent-rgb) / 0.22);
-}
-
 .m4-replay-threat-visual__review-controls,
 .m4-replay-threat-visual__review-controls > *,
 .m4-replay-threat-visual__single-pane-controls,
@@ -342,10 +232,6 @@
  grid-template-columns: auto auto auto minmax(0, 1fr) auto;
 }

-.canonical-vegetation-rerun-replay__timeline .observation-timeline__playback {
-  grid-template-columns: auto auto minmax(0, 1fr) auto;
-}
-
 .m4-replay-threat-visual__overlay {
  box-sizing: border-box;
  min-width: 0;
@@ -1 +1,659 @@
-@import "../../../../packages/spatial-ui/src/observation.css";
+.scene-source-controls {
+  position: absolute;
+  z-index: 12;
+  top: 0.85rem;
+  left: 0.85rem;
+  display: flex;
+  align-items: center;
+  gap: 0.45rem;
+}
+
+.scene-device-controls {
+  position: absolute;
+  z-index: 30;
+  top: 0.85rem;
+  left: 50%;
+  max-width: calc(100% - 9rem);
+  transform: translateX(-50%);
+}
+
+.scene-source-picker__trigger,
+.scene-source-control,
+.scene-focus-exit {
+  display: inline-grid;
+  width: 2.75rem;
+  height: 2.75rem;
+  place-items: center;
+  border: 1px solid rgb(255 255 255 / 0.09);
+  border-radius: 50%;
+  background: rgb(12 13 16 / 0.82);
+  color: var(--nodedc-text-secondary);
+  cursor: pointer;
+  backdrop-filter: blur(18px);
+}
+
+.scene-navigation-hint {
+  position: absolute;
+  z-index: 11;
+  right: 0.85rem;
+  bottom: 4.9rem;
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  border: 1px solid rgb(255 255 255 / 0.07);
+  border-radius: 999px;
+  background: rgb(9 10 13 / 0.7);
+  color: var(--nodedc-text-muted);
+  padding: 0.42rem 0.65rem;
+  font-size: 0.52rem;
+  font-weight: 680;
+  pointer-events: none;
+  backdrop-filter: blur(14px);
+}
+
+.scene-source-picker__trigger {
+  position: relative;
+}
+
+.scene-source-picker__trigger:hover,
+.scene-source-control:hover,
+.scene-focus-exit:hover,
+.scene-source-picker__trigger[data-active="true"] {
+  border-color: rgb(255 255 255 / 0.18);
+  color: var(--nodedc-text-primary);
+}
+
+.scene-source-picker__trigger > span {
+  position: absolute;
+  top: -0.2rem;
+  right: -0.2rem;
+  display: grid;
+  min-width: 1.05rem;
+  height: 1.05rem;
+  place-items: center;
+  border-radius: 999px;
+  background: var(--nodedc-text-primary);
+  color: #090a0c;
+  padding: 0 0.25rem;
+  font-size: 0.5rem;
+  font-weight: 800;
+}
+
+.scene-focus-exit {
+  position: absolute;
+  z-index: 20;
+  top: 0.85rem;
+  right: 0.85rem;
+}
+
+.scene-status--top-left {
+  left: 7.1rem;
+}
+
+.scene-status[aria-hidden="true"],
+.scene-metrics[aria-hidden="true"] {
+  display: none;
+}
+
+.observation-source-menu {
+  overflow: hidden;
+  font-family: var(--nodedc-font-family);
+}
+
+.observation-source-menu__head,
+.observation-source-menu__foot {
+  padding: 0.85rem 0.9rem;
+}
+
+.observation-source-menu__head {
+  display: flex;
+  align-items: flex-end;
+  justify-content: space-between;
+  gap: 1rem;
+}
+
+.observation-source-menu__head strong,
+.observation-source-menu__head span {
+  display: block;
+}
+
+.observation-source-menu__head strong {
+  margin-top: 0.34rem;
+  color: var(--nodedc-text-primary);
+  font-size: var(--nodedc-font-size-md);
+}
+
+.observation-source-menu__head small,
+.observation-source-menu__foot {
+  color: var(--nodedc-text-muted);
+  font-size: var(--nodedc-font-size-xs);
+  line-height: 1.4;
+}
+
+.observation-source-menu__list {
+  display: grid;
+  max-height: min(28rem, 60vh);
+  overflow: auto;
+  padding: 0.35rem;
+}
+
+.observation-source-option .nodedc-dropdown-option__description {
+  display: flex;
+  align-items: center;
+  gap: 0.35rem;
+}
+
+.observation-source-option i,
+.floating-observation-window i,
+.camera-slot__status i {
+  width: 0.42rem;
+  height: 0.42rem;
+  flex: 0 0 0.42rem;
+  border-radius: 50%;
+  background: var(--nodedc-text-muted);
+}
+
+i[data-availability="available"],
+i[data-availability="streaming"] {
+  background: rgb(var(--nodedc-success-rgb));
+}
+
+i[data-availability="connecting"],
+i[data-availability="declared"] {
+  background: rgb(var(--nodedc-warning-rgb));
+}
+
+i[data-availability="unverified"] {
+  background: var(--nodedc-text-muted);
+}
+
+i[data-availability="degraded"],
+i[data-availability="error"] {
+  background: rgb(var(--nodedc-danger-rgb));
+}
+
+.observation-source-menu__empty,
+.camera-grid__empty,
+.observation-media__empty {
+  display: grid;
+  place-items: center;
+  align-content: center;
+  gap: 0.5rem;
+  color: var(--nodedc-text-muted);
+  text-align: center;
+}
+
+.observation-source-menu__empty {
+  min-height: 10rem;
+  padding: 1rem;
+}
+
+.observation-source-menu__empty strong,
+.observation-media__empty strong,
+.camera-grid__empty strong {
+  color: var(--nodedc-text-secondary);
+  font-size: 0.7rem;
+}
+
+.observation-source-menu__empty span,
+.observation-media__empty span,
+.camera-grid__empty span {
+  max-width: 24rem;
+  font-size: 0.59rem;
+  line-height: 1.45;
+}
+
+.observation-source-menu__foot {
+  border-top: 0;
+}
+
+.observation-media__asset,
+.observation-media__empty {
+  width: 100%;
+  height: 100%;
+}
+
+.observation-media__asset {
+  display: block;
+  object-fit: contain;
+  background: #050608;
+}
+
+.recorded-media-player {
+  position: relative;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  background: #070809;
+}
+
+.recorded-media-player:not([data-state="ready"]) .observation-media__asset {
+  visibility: hidden;
+}
+
+.recorded-media-player__notice {
+  position: absolute;
+  inset: 0;
+  display: grid;
+  place-items: center;
+  padding: 18px;
+  color: rgba(247, 248, 244, 0.72);
+  background: #070809;
+  font: inherit;
+  font-size: 11px;
+  text-align: center;
+  pointer-events: none;
+}
+
+.mse-fmp4-player {
+  position: relative;
+  width: 100%;
+  height: 100%;
+  min-height: 9rem;
+  overflow: hidden;
+  background: #050608;
+}
+
+.mse-fmp4-player__status {
+  position: absolute;
+  inset: 0;
+  display: grid;
+  place-items: center;
+  align-content: center;
+  gap: 0.5rem;
+  padding: 1rem;
+  background: rgb(5 6 8 / 0.88);
+  color: var(--nodedc-text-muted);
+  text-align: center;
+}
+
+.mse-fmp4-player__status strong {
+  color: var(--nodedc-text-secondary);
+  font-size: 0.7rem;
+}
+
+.mse-fmp4-player__status span {
+  max-width: 24rem;
+  font-size: 0.59rem;
+  line-height: 1.45;
+}
+
+.mse-fmp4-player__status button {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.4rem;
+  margin-top: 0.25rem;
+  border: 1px solid rgb(255 255 255 / 0.12);
+  border-radius: 999px;
+  background: rgb(255 255 255 / 0.06);
+  color: var(--nodedc-text-primary);
+  padding: 0.48rem 0.72rem;
+  font: inherit;
+  font-size: 0.58rem;
+  font-weight: 760;
+  cursor: pointer;
+}
+
+.mse-fmp4-player__status button:hover {
+  background: rgb(255 255 255 / 0.11);
+}
+
+.observation-media__empty {
+  min-height: 9rem;
+  background: #07080a;
+}
+
+.floating-observation-window__status,
+.floating-observation-window__footer {
+  display: flex;
+  align-items: center;
+  gap: 0.45rem;
+}
+
+.camera-slot__head-actions button {
+  display: grid;
+  width: 1.9rem;
+  height: 1.9rem;
+  place-items: center;
+  border: 0;
+  border-radius: 50%;
+  background: rgb(255 255 255 / 0.05);
+  color: var(--nodedc-text-secondary);
+  cursor: pointer;
+}
+
+.camera-slot__head-actions button:hover {
+  background: rgb(255 255 255 / 0.1);
+  color: var(--nodedc-text-primary);
+}
+
+.camera-slot__head-actions .camera-slot__activation {
+  width: auto;
+  min-width: 5.6rem;
+  height: 1.9rem;
+  border: 1px solid rgb(255 255 255 / 0.09);
+  border-radius: 999px;
+  padding: 0 0.65rem;
+  font: inherit;
+  font-size: 0.53rem;
+  font-weight: 760;
+  white-space: nowrap;
+}
+
+.camera-slot__head-actions .camera-slot__activation:disabled {
+  cursor: wait;
+  opacity: 0.48;
+}
+
+.floating-observation-window__status {
+  color: var(--nodedc-text-secondary);
+  font-size: 0.54rem;
+}
+
+.floating-observation-window__footer {
+  width: 100%;
+  justify-content: space-between;
+  color: var(--nodedc-text-muted);
+  font-size: 0.53rem;
+}
+
+.floating-observation-window .nodedc-workspace-window__body {
+  background: #06070a;
+}
+
+.floating-observation-window.nodedc-material-rim::after {
+  display: none;
+}
+
+.floating-observation-window[data-active="true"] {
+  box-shadow: 0 1.5rem 4rem rgb(0 0 0 / 0.34);
+}
+
+.floating-observation-window--hidden {
+  visibility: hidden;
+  pointer-events: none;
+}
+
+.observation-timeline {
+  display: block;
+  min-width: 0;
+  border: 0;
+  border-radius: 0.9rem;
+  background: rgb(9 10 13 / 0.78);
+  padding: 0.4rem;
+  backdrop-filter: blur(16px);
+}
+
+.observation-timeline[data-accumulation="true"] {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  align-items: center;
+  gap: 0.8rem;
+}
+
+.observation-timeline__playback {
+  display: grid;
+  min-width: 0;
+  grid-template-columns: auto auto minmax(0, 1fr) auto auto;
+  align-items: center;
+  gap: 0.6rem;
+}
+
+.observation-timeline__playback > .nodedc-select-anchor {
+  display: inline-flex;
+  width: auto;
+  flex: none;
+}
+
+.observation-timeline__transport {
+  width: var(--nodedc-control-height-compact);
+  padding: 0;
+  border-radius: var(--nodedc-radius-circle);
+}
+
+.observation-timeline__accumulation {
+  display: grid;
+  min-width: 0;
+  grid-template-columns: auto minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 0.7rem;
+  padding: 0 0.45rem;
+}
+
+.observation-timeline__accumulation span,
+.observation-timeline__accumulation code {
+  color: var(--nodedc-text-muted);
+  font-size: 0.55rem;
+  white-space: nowrap;
+}
+
+.observation-timeline__accumulation code {
+  min-width: 2.65rem;
+  color: var(--nodedc-text-primary);
+  text-align: right;
+}
+
+.observation-timeline__track {
+  width: 100%;
+  height: 0.3rem;
+  appearance: none;
+  border: 0;
+  border-radius: 999px;
+  background: rgb(255 255 255 / 0.08);
+  cursor: pointer;
+}
+
+.observation-timeline__track::-webkit-slider-thumb {
+  width: 0.72rem;
+  height: 0.72rem;
+  appearance: none;
+  border: 0;
+  border-radius: 50%;
+  background: var(--nodedc-text-primary);
+}
+
+.observation-timeline__track::-moz-range-thumb {
+  width: 0.72rem;
+  height: 0.72rem;
+  border: 0;
+  border-radius: 50%;
+  background: var(--nodedc-text-primary);
+}
+
+.observation-timeline__track:disabled {
+  opacity: 0.46;
+  cursor: default;
+}
+
+.observation-timeline__meta {
+  display: grid;
+  justify-items: end;
+  gap: 0.12rem;
+}
+
+.observation-timeline__meta code,
+.observation-timeline__meta small {
+  color: var(--nodedc-text-muted);
+  font-size: 0.52rem;
+  white-space: nowrap;
+}
+
+.observation-timeline__follow {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.38rem;
+  color: var(--nodedc-text-muted);
+  border: 0;
+  background: transparent;
+  padding: 0.3rem 0.45rem;
+  font-size: 0.52rem;
+  font-weight: 820;
+}
+
+.observation-timeline__follow:not(:disabled) {
+  cursor: pointer;
+}
+
+.observation-timeline__follow::before {
+  width: 0.4rem;
+  height: 0.4rem;
+  border-radius: 50%;
+  background: var(--nodedc-text-muted);
+  content: "";
+}
+
+.observation-timeline__follow[data-active="true"] {
+  color: var(--nodedc-text-primary);
+}
+
+.observation-timeline__follow[data-active="true"]::before {
+  background: rgb(var(--nodedc-success-rgb));
+}
+
+.scene-timeline {
+  position: absolute;
+  z-index: 10;
+  right: 0.75rem;
+  bottom: 0.75rem;
+  left: 0.75rem;
+}
+
+.spatial-workspace[data-focused="true"] {
+  min-height: 0;
+  grid-template-rows: minmax(0, 1fr);
+  gap: 0;
+}
+
+.spatial-workspace[data-focused="true"] > .spatial-toolbar,
+.spatial-workspace[data-focused="true"] > .spatial-contract-strip {
+  display: none;
+}
+
+.cameras-workspace {
+  height: 100%;
+  min-height: 0;
+  grid-template-rows: auto auto minmax(0, 1fr) auto;
+  overflow: hidden;
+  padding-bottom: 0;
+}
+
+.camera-workspace__catalog {
+  display: flex;
+  min-width: 0;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 0.8rem;
+  color: var(--nodedc-text-muted);
+  font-size: 0.6rem;
+}
+
+.camera-grid {
+  display: grid;
+  min-height: 0;
+  grid-template-columns: repeat(auto-fit, minmax(min(24rem, 100%), 1fr));
+  grid-template-rows: none;
+  grid-auto-rows: minmax(16rem, 1fr);
+  gap: 0.75rem;
+  overflow: auto;
+}
+
+.camera-grid[data-count="1"] {
+  grid-template-columns: minmax(0, 1fr);
+}
+
+.camera-grid__empty {
+  min-height: 18rem;
+  border-radius: 1rem;
+  background: #07080a;
+  box-shadow: none;
+}
+
+.camera-slot {
+  grid-template-rows: auto minmax(0, 1fr) auto;
+}
+
+.camera-slot header,
+.camera-slot footer {
+  z-index: 2;
+}
+
+.camera-slot__head-actions,
+.camera-slot__status {
+  display: flex;
+  align-items: center;
+  gap: 0.45rem;
+}
+
+.camera-slot__status {
+  color: var(--nodedc-text-muted);
+  font-size: 0.56rem;
+}
+
+.camera-slot__body {
+  position: relative;
+  z-index: 1;
+  min-width: 0;
+  min-height: 0;
+  overflow: hidden;
+}
+
+.camera-slot footer {
+  align-items: flex-end;
+}
+
+.camera-slot footer span {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.camera-slot footer small {
+  flex: 0 0 auto;
+  color: var(--nodedc-text-secondary);
+  font-size: 0.53rem;
+}
+
+.camera-timeline {
+  position: relative;
+}
+
+.cameras-workspace[data-focused="true"] {
+  height: 100%;
+  grid-template-rows: minmax(0, 1fr) auto;
+  padding-bottom: 0;
+}
+
+.cameras-workspace[data-focused="true"] > .workspace-lead,
+.cameras-workspace[data-focused="true"] > .camera-workspace__catalog {
+  display: none;
+}
+
+.cameras-workspace[data-focused="true"] .camera-grid {
+  min-height: 0;
+  overflow: hidden;
+}
+
+@media (max-width: 760px) {
+  .scene-status--top-left {
+    top: 4.2rem;
+    left: 0.6rem;
+  }
+
+  .observation-timeline[data-accumulation="true"] {
+    grid-template-columns: minmax(0, 1fr);
+  }
+
+  .observation-timeline__playback {
+    grid-template-columns: auto minmax(0, 1fr) auto;
+  }
+
+  .observation-timeline__playback > .nodedc-button:first-child,
+  .observation-timeline__meta {
+    display: none;
+  }
+
+  .camera-grid {
+    grid-template-columns: 1fr;
+    grid-auto-rows: minmax(14rem, 1fr);
+  }
+}
@@ -1,640 +0,0 @@
-.observatory-workspace {
-  display: grid;
-  grid-auto-rows: max-content;
-  align-content: start;
-  gap: 1rem;
-  min-width: 0;
-  min-height: 100%;
-  padding: 1rem;
-  container-name: observatory-workspace;
-  container-type: inline-size;
-}
-
-.observatory-catalog-bar,
-.observatory-catalog-bar__controls,
-.observatory-notice,
-.observatory-evidence > header {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 1rem;
-}
-
-.observatory-notice {
-  flex-wrap: wrap;
-}
-
-.observatory-catalog-bar__copy,
-.observatory-evidence header > div {
-  min-width: 0;
-}
-
-.observatory-catalog-bar h3,
-.observatory-session-summary h3,
-.observatory-evidence h3 {
-  margin: 0.3rem 0 0;
-}
-
-.observatory-catalog-bar h3,
-.observatory-session-summary h3,
-.observatory-evidence h3 {
-  font-size: var(--nodedc-font-size-lg);
-  letter-spacing: -0.02em;
-  line-height: 1.15;
-}
-
-.observatory-state p,
-.observatory-evidence-empty p {
-  max-width: 52rem;
-  margin: 0.35rem 0 0;
-  color: var(--nodedc-text-muted);
-  font-size: var(--nodedc-font-size-sm);
-  line-height: 1.35;
-}
-
-.observatory-catalog-bar,
-.observatory-session-summary {
-  align-self: start;
-  min-height: 0;
-}
-
-.observatory-catalog-bar__copy {
-  display: grid;
-  flex: 0 0 auto;
-  align-content: center;
-  gap: 0.1rem;
-}
-
-.observatory-catalog-bar h3 {
-  margin-top: 0.1rem;
-}
-
-.observatory-catalog-bar__controls {
-  min-width: 0;
-  flex: 1 1 auto;
-  flex-wrap: nowrap;
-  justify-content: flex-end;
-}
-
-.observatory-catalog-bar__controls .nodedc-select-anchor {
-  flex: 1 1 18rem;
-  min-width: 0;
-}
-
-.observatory-catalog-bar__controls > .nodedc-button {
-  flex: 0 0 auto;
-}
-
-.observatory-catalog-bar__run {
-  display: flex;
-  flex: 0 0 auto;
-  align-items: center;
-  gap: 0.55rem;
-}
-
-.observatory-state {
-  display: grid;
-  min-height: 19rem;
-  place-items: center;
-  align-content: center;
-  gap: 0.7rem;
-  text-align: center;
-}
-
-.observatory-state h3 {
-  max-width: 42rem;
-  margin: 0;
-}
-
-.observatory-session-stack {
-  display: grid;
-  grid-auto-rows: max-content;
-  align-content: start;
-  gap: 0.9rem;
-  container-name: observatory-session;
-  container-type: inline-size;
-}
-
-.observatory-session-summary {
-  display: grid;
-  grid-template-columns: minmax(11rem, 1.05fr) minmax(20rem, 1.6fr) minmax(11rem, auto);
-  align-items: center;
-  gap: 0.75rem;
-}
-
-.observatory-session-summary__identity {
-  display: grid;
-  min-width: 0;
-  gap: 0.22rem;
-}
-
-.observatory-session-summary__identity h3 {
-  margin: 0.1rem 0 0;
-}
-
-.observatory-session-summary__identity code {
-  overflow: hidden;
-  color: var(--nodedc-text-muted);
-  font-size: var(--nodedc-font-size-xs);
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.observatory-session-summary__facts {
-  display: grid;
-  grid-template-columns: repeat(3, minmax(6.5rem, 1fr));
-  gap: 0.75rem;
-  margin: 0;
-}
-
-.observatory-session-summary__facts > div {
-  display: grid;
-  min-width: 0;
-  gap: 0.24rem;
-}
-
-.observatory-session-summary__facts dt {
-  color: var(--nodedc-text-muted);
-  font-size: var(--nodedc-font-size-xs);
-}
-
-.observatory-session-summary__facts dd {
-  min-width: 0;
-  margin: 0;
-  overflow-wrap: anywhere;
-  color: var(--nodedc-text-secondary);
-  font-size: var(--nodedc-font-size-sm);
-  line-height: 1.35;
-}
-
-.observatory-session-summary__end {
-  display: grid;
-  min-width: 0;
-  justify-items: end;
-  gap: 0.4rem;
-}
-
-.observatory-modalities {
-  display: flex;
-  flex-wrap: wrap;
-  justify-content: flex-end;
-  gap: 0.45rem;
-  align-items: center;
-  color: var(--nodedc-text-muted);
-}
-
-.observatory-evidence {
-  display: grid;
-  gap: 0.65rem;
-}
-
-.observatory-evidence > header {
-  padding: 0 0.2rem;
-}
-
-.observatory-evidence__ordering {
-  display: flex;
-  flex: none;
-  align-items: center;
-  gap: 0.55rem;
-}
-
-.observatory-evidence__sort {
-  display: grid;
-  width: 1.7rem;
-  height: 1.7rem;
-  place-items: center;
-  border: 0;
-  outline: 0;
-  border-radius: 0;
-  background: transparent;
-  padding: 0;
-  color: var(--nodedc-text-secondary);
-  cursor: pointer;
-}
-
-.observatory-evidence__sort:hover,
-.observatory-evidence__sort:focus-visible {
-  background: var(--nodedc-glass-control-bg);
-  color: var(--nodedc-text-primary);
-}
-
-.observatory-evidence__sort svg {
-  width: 1.1rem;
-  height: 1.1rem;
-  transition: transform 160ms ease-out;
-}
-
-.observatory-evidence__sort path {
-  fill: none;
-  stroke: currentColor;
-  stroke-linecap: round;
-  stroke-width: 1.5;
-}
-
-.observatory-evidence__sort[data-direction="oldest"] svg {
-  transform: rotate(180deg);
-}
-
-.observatory-evidence-list {
-  display: grid;
-  gap: 0.4rem;
-  margin: 0;
-  padding: 0;
-  list-style: none;
-}
-
-.observatory-evidence-card {
-  display: grid;
-  grid-template-columns: auto minmax(0, 1fr) auto auto;
-  align-items: center;
-  gap: 0.8rem;
-  min-height: 4.25rem;
-  padding: 0.7rem 0.85rem;
-  border-radius: var(--nodedc-radius-control-compact);
-  background: var(--nodedc-glass-control-bg);
-}
-
-.observatory-evidence-card__icon {
-  display: grid;
-  width: 2.15rem;
-  height: 2.15rem;
-  place-items: center;
-  border-radius: var(--nodedc-radius-circle);
-  background: var(--nodedc-panel-icon-bg);
-  color: var(--nodedc-text-secondary);
-}
-
-.observatory-evidence-card__copy {
-  display: grid;
-  min-width: 0;
-  gap: 0.16rem;
-}
-
-.observatory-evidence-card__copy strong,
-.observatory-evidence-card__copy span,
-.observatory-evidence-card__copy small {
-  min-width: 0;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.observatory-evidence-card__copy strong {
-  overflow: visible;
-  text-overflow: clip;
-  white-space: normal;
-  font-size: var(--nodedc-font-size-sm);
-  line-height: 1.3;
-}
-
-.observatory-evidence-card__copy span {
-  color: var(--nodedc-text-secondary);
-  font-size: var(--nodedc-font-size-sm);
-}
-
-.observatory-evidence-card__copy small {
-  color: var(--nodedc-text-muted);
-  font-size: var(--nodedc-font-size-xs);
-}
-
-.observatory-evidence-card--progress {
-  grid-template-columns: auto minmax(0, 1fr) auto auto;
-  border: 0;
-  outline: 0;
-}
-
-.observatory-evidence-card__progress {
-  height: 0.28rem;
-  margin: 0.18rem 0 0.08rem;
-  overflow: hidden;
-  border-radius: 999px;
-  background: rgb(var(--nodedc-accent-rgb) / 0.12);
-}
-
-.observatory-evidence-card__progress > span {
-  display: block;
-  height: 100%;
-  border-radius: inherit;
-  background: rgb(var(--nodedc-accent-rgb));
-  transition: width 180ms ease-out;
-}
-
-.observatory-evidence-card__actions,
-.observatory-replay__header,
-.observatory-replay-state,
-.observatory-replay-state__actions {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 0.85rem;
-}
-
-.observatory-replay-state {
-  flex-wrap: wrap;
-}
-
-.observatory-replay__header > div,
-.observatory-replay-state > div {
-  min-width: 0;
-}
-
-.observatory-evidence-card__actions:empty {
-  display: none;
-}
-
-.observatory-replay,
-.observatory-replay-state {
-  min-width: 0;
-}
-
-.observatory-replay {
-  display: grid;
-  gap: 0.85rem;
-  font-family: var(--nodedc-font-family);
-}
-
-.observatory-replay__header {
-  padding: 0.25rem 0.25rem 0;
-}
-
-.observatory-replay__header h3,
-.observatory-replay-state h3 {
-  margin: 0.3rem 0 0;
-}
-
-.observatory-replay__header h3 {
-  font-size: var(--nodedc-font-size-sm);
-  line-height: 1.3;
-}
-
-.observatory-replay__header p,
-.observatory-replay-state p,
-.observatory-replay__description {
-  margin: 0.35rem 0 0;
-  color: var(--nodedc-text-muted);
-  font-family: var(--nodedc-font-family);
-  font-size: var(--nodedc-font-size-sm);
-  font-weight: var(--nodedc-font-weight-regular);
-  line-height: 1.35;
-}
-
-.observatory-replay__description {
-  margin-right: 0.25rem;
-  margin-left: 0.25rem;
-}
-
-.observatory-replay .m4-replay-threat-visual__buffering {
-  border: 0;
-  outline: 0;
-}
-
-.observatory-replay .laboratory-evidence-viewer {
-  border: 0;
-  outline: 0;
-  border-radius: 0;
-  box-shadow: none;
-}
-
-.observatory-evidence-empty {
-  display: grid;
-  min-height: 13rem;
-  place-items: center;
-  align-content: center;
-  gap: 0.55rem;
-  text-align: center;
-}
-
-.observatory-notice {
-  justify-content: flex-start;
-  color: var(--nodedc-text-secondary);
-}
-
-.observatory-notice__copy {
-  min-width: 0;
-  flex: 1 1 auto;
-}
-
-.observatory-rename-form,
-.observatory-delete-confirmation {
-  display: grid;
-  gap: 0.75rem;
-}
-
-.observatory-delete-confirmation p,
-.observatory-mutation-error {
-  margin: 0;
-  line-height: 1.5;
-}
-
-.observatory-mutation-error {
-  color: rgb(var(--nodedc-danger-rgb));
-  font-size: var(--nodedc-font-size-sm);
-}
-
-@container observatory-session (max-width: 46rem) {
-  .observatory-session-summary {
-    grid-template-columns: minmax(0, 1fr);
-    align-items: start;
-  }
-
-  .observatory-session-summary__end,
-  .observatory-modalities {
-    justify-items: start;
-    justify-content: flex-start;
-  }
-}
-
-@container observatory-session (max-width: 48rem) {
-  .observatory-evidence-card {
-    grid-template-columns: auto minmax(0, 1fr) auto;
-  }
-
-  .observatory-evidence-card > .nodedc-status {
-    display: none;
-  }
-}
-
-@container observatory-session (max-width: 38rem) {
-  .observatory-session-summary__facts {
-    grid-template-columns: minmax(0, 1fr);
-  }
-
-  .observatory-evidence-card__copy small {
-    white-space: normal;
-  }
-}
-
-@container observatory-workspace (max-width: 920px) {
-  .observatory-catalog-bar,
-  .observatory-catalog-bar__controls,
-  .observatory-notice {
-    align-items: stretch;
-    flex-direction: column;
-  }
-
-  .observatory-catalog-bar__controls {
-    flex-basis: auto;
-  }
-
-  .observatory-catalog-bar__controls .nodedc-select-anchor {
-    flex: 0 0 auto;
-    width: 100%;
-    min-width: 0;
-  }
-
-  .observatory-catalog-bar__run {
-    justify-content: flex-end;
-  }
-}
-
-@media (max-width: 920px) {
-  .observatory-replay__header,
-  .observatory-replay-state {
-    align-items: stretch;
-    flex-direction: column;
-  }
-}
-.observatory-ai-config {
-  display: grid;
-  gap: var(--nodedc-space-4);
-}
-
-.observatory-ai-config__lead,
-.observatory-ai-config__error {
-  margin: 0;
-  color: var(--nodedc-text-secondary);
-  font-size: var(--nodedc-font-size-sm);
-  line-height: 1.45;
-}
-
-.observatory-ai-config__error {
-  color: rgb(var(--nodedc-danger-rgb));
-}
-
-.observatory-ai-config__duplicate {
-  margin-right: auto;
-  color: var(--nodedc-text-secondary);
-  font-size: var(--nodedc-font-size-sm);
-  line-height: 1.4;
-}
-
-@keyframes observatory-ai-calculate-pulse {
-  0%,
-  100% {
-    background-color: var(--nodedc-primary-action-bg);
-  }
-
-  50% {
-    background-color: color-mix(
-      in srgb,
-      var(--nodedc-primary-action-bg) 88%,
-      var(--nodedc-canvas-soft)
-    );
-  }
-}
-
-.observatory-ai-config__calculate--saving:disabled {
-  animation: observatory-ai-calculate-pulse 1.8s ease-in-out infinite;
-  cursor: progress;
-  opacity: 1;
-}
-
-.observatory-ai-config-window {
-  border: 0;
-  outline: 0;
-  box-shadow: var(--nodedc-shadow-window);
-}
-
-.observatory-ai-config-window::before,
-.observatory-ai-config-window::after {
-  display: none;
-}
-
-.observatory-ai-module-group {
-  overflow: hidden;
-  border: 0;
-  outline: 0;
-  border-radius: var(--nodedc-radius-control-compact);
-  background: var(--nodedc-glass-control-bg);
-}
-
-.observatory-ai-module-group > header {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: var(--nodedc-space-3);
-  padding: var(--nodedc-space-3) var(--nodedc-space-4);
-  border: 0;
-  outline: 0;
-}
-
-.observatory-ai-module-group > header > div {
-  display: grid;
-  min-width: 0;
-  gap: 0.2rem;
-}
-
-.observatory-ai-module-group > header .nodedc-status {
-  min-width: 0;
-  max-width: 55%;
-  overflow: hidden;
-  text-overflow: ellipsis;
-}
-
-.observatory-ai-module-group > header span {
-  color: var(--nodedc-text-muted);
-  font-size: var(--nodedc-font-size-xs);
-}
-
-.observatory-ai-module-group__body {
-  padding: var(--nodedc-space-4);
-  border: 0;
-  outline: 0;
-}
-
-.observatory-ai-module-group__body .nodedc-select-anchor {
-  width: 100%;
-}
-
-.observatory-ai-config-window .nodedc-select-trigger,
-.observatory-ai-config-window .nodedc-window__close {
-  border: 0;
-  outline: 0;
-  box-shadow: none;
-}
-
-.observatory-ai-config-window .nodedc-select-trigger:focus-visible,
-.observatory-ai-config-window .nodedc-window__close:focus-visible {
-  background-color: var(--nodedc-focus-surface);
-  box-shadow:
-    var(--nodedc-glass-control-shadow),
-    inset 0 0 0 1px rgb(var(--nodedc-accent-rgb) / 0.22);
-}
-
-@media (max-width: 560px) {
-  .observatory-ai-config-window .nodedc-window__title {
-    white-space: normal;
-  }
-
-  .observatory-ai-module-group > header {
-    align-items: flex-start;
-    flex-direction: column;
-  }
-
-  .observatory-ai-module-group > header .nodedc-status {
-    max-width: 100%;
-    justify-content: flex-start;
-  }
-}
-
-@media (prefers-reduced-motion: reduce) {
-  .observatory-ai-config__calculate--saving:disabled {
-    animation: none;
-    background-color: color-mix(
-      in srgb,
-      var(--nodedc-primary-action-bg) 94%,
-      var(--nodedc-canvas-soft)
-    );
-  }
-}
@@ -3,6 +3,9 @@
    grid-template-columns: repeat(2, minmax(0, 1fr));
  }

+  .landing-stage__copy {
+    width: min(35rem, 54%);
+  }
 }

@media (max-width: 1280px) {
@@ -187,6 +190,15 @@
    text-align: left;
  }

+  .landing-stage__status {
+    width: 20rem;
+    max-width: 36vw;
+  }
+
+  .landing-stage__copy h1 {
+    font-size: clamp(2.7rem, 7vw, 5.6rem);
+  }
+
  .scene-metrics {
    display: none;
  }
@@ -412,6 +424,36 @@
    display: none;
  }

+  .landing-stage__copy {
+    top: 42%;
+    right: 1.2rem;
+    left: 1.2rem;
+    width: auto;
+  }
+
+  .landing-stage__copy h1 {
+    font-size: clamp(2.8rem, 14vw, 5rem);
+  }
+
+  .landing-stage__status {
+    top: auto;
+    right: 1rem;
+    bottom: 3.3rem;
+    left: 1rem;
+    width: auto;
+    max-width: none;
+  }
+
+  .landing-stage__footer {
+    right: 1rem;
+    bottom: 1.1rem;
+    left: 1rem;
+  }
+
+  .landing-stage__footer span:first-child {
+    display: none;
+  }
+
  .metrics-grid,
  .capability-summary,
  .camera-grid,
@@ -603,5 +645,20 @@
 }

@media (max-height: 720px) and (min-width: 761px) {
+  .landing-stage__copy h1 {
+    font-size: clamp(2.7rem, 6vw, 5rem);
+  }

+  .landing-stage__copy p {
+    font-size: 0.76rem;
+  }
+
+  .landing-stage__actions {
+    margin-top: 1rem;
+  }
+
+  .landing-stage__status {
+    top: 1.2rem;
+    right: 1.2rem;
+  }
 }
@@ -1 +1,83 @@
-@import "../../../../packages/spatial-ui/src/scene-windows.css";
+.scene-tool-window {
+  --scene-tool-window-top: 5.75rem;
+  --scene-tool-window-right: 27rem;
+  position: fixed;
+  top: var(--scene-tool-window-top);
+  right: var(--scene-tool-window-right);
+  max-height: calc(100vh - var(--scene-tool-window-top) - 1.5rem);
+}
+
+.scene-tool-window--display {
+  --scene-tool-window-top: 7.75rem;
+  --scene-tool-window-right: 28.5rem;
+}
+
+.scene-tool-window--layers {
+  --scene-tool-window-top: 9.75rem;
+  --scene-tool-window-right: 30rem;
+}
+
+.scene-tool-window--layout {
+  --scene-tool-window-top: 11.75rem;
+  --scene-tool-window-right: 31.5rem;
+}
+
+.nodedc-overlay:has(> .scene-tool-window[data-scene-active="true"]) {
+  z-index: calc(var(--nodedc-layer-overlay) + 1);
+}
+
+.nodedc-overlay[data-placement="center"] {
+  z-index: calc(var(--nodedc-layer-overlay) + 2);
+}
+
+.scene-window-state {
+  display: inline-flex;
+  min-width: 0;
+  align-items: center;
+  gap: 0.5rem;
+  color: var(--nodedc-text-secondary);
+  font-size: var(--nodedc-font-size-sm);
+  line-height: 1.3;
+}
+
+.scene-window-code {
+  display: block;
+  overflow: hidden;
+  border-radius: var(--nodedc-radius-control-compact);
+  background: var(--nodedc-field-bg);
+  color: var(--nodedc-text-secondary);
+  padding: 0.72rem 0.8rem;
+  font-size: var(--nodedc-font-size-xs);
+  line-height: 1.35;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.scene-window-note {
+  margin: 0;
+  color: var(--nodedc-text-muted);
+  font-size: var(--nodedc-font-size-xs);
+  line-height: 1.5;
+}
+
+@media (max-width: 44rem) {
+  .scene-tool-window,
+  .scene-tool-window--display,
+  .scene-tool-window--layers,
+  .scene-tool-window--layout {
+    --scene-tool-window-top: 4.75rem;
+    --scene-tool-window-right: 0.875rem;
+    max-height: calc(100vh - 5.625rem);
+  }
+}
+
+@media (min-width: 44.01rem) and (max-width: 70rem) {
+  .scene-tool-window,
+  .scene-tool-window--display,
+  .scene-tool-window--layers,
+  .scene-tool-window--layout {
+    --scene-tool-window-top: 13.5rem;
+    --scene-tool-window-right: 1.5rem;
+    max-height: calc(100vh - 15rem);
+  }
+}
@@ -48,3 +48,116 @@
  height: 100%;
  overflow: hidden;
 }
+
+.landing-stage {
+  position: relative;
+  min-width: 0;
+  min-height: 0;
+  overflow: hidden;
+  border-radius: var(--nodedc-radius-card);
+  background: var(--station-stage);
+}
+
+.landing-stage__media,
+.landing-stage__shade {
+  position: absolute;
+  inset: 0;
+}
+
+.landing-stage__media img,
+.landing-stage__media video {
+  width: 100%;
+  height: 100%;
+  display: block;
+  object-fit: cover;
+}
+
+.landing-stage__shade {
+  z-index: 1;
+  background:
+    linear-gradient(90deg, rgb(5 6 8 / 0.82) 0%, rgb(5 6 8 / 0.54) 46%, rgb(5 6 8 / 0.24) 100%),
+    linear-gradient(0deg, rgb(5 6 8 / 0.58), transparent 38%);
+  pointer-events: none;
+}
+
+.landing-stage:not([data-has-media="true"]) .landing-stage__shade {
+  background:
+    radial-gradient(circle at 68% 42%, rgb(255 255 255 / 0.035), transparent 34%),
+    linear-gradient(90deg, rgb(5 6 8 / 0.2), transparent 62%);
+}
+
+.landing-stage__copy {
+  position: absolute;
+  z-index: 2;
+  top: 50%;
+  left: clamp(2rem, 5vw, 6rem);
+  width: min(39rem, 50%);
+  transform: translateY(-55%);
+}
+
+.landing-stage__copy h1 {
+  margin: 0.75rem 0 1rem;
+  color: var(--nodedc-text-primary);
+  font-size: clamp(3rem, 7vw, 7.6rem);
+  font-weight: 600;
+  letter-spacing: -0.072em;
+  line-height: 0.87;
+}
+
+.landing-stage__copy p {
+  max-width: 34rem;
+  margin: 0;
+  color: var(--nodedc-text-secondary);
+  font-size: clamp(0.8rem, 1vw, 1rem);
+  line-height: 1.6;
+}
+
+.landing-stage__actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.65rem;
+  margin-top: 1.6rem;
+}
+
+.landing-stage__status {
+  position: absolute;
+  z-index: 2;
+  top: 2.4rem;
+  right: 2.4rem;
+  display: grid;
+  width: min(24rem, 30vw);
+  gap: 0.6rem;
+  border-radius: 1.25rem;
+  background: rgb(10 10 12 / 0.58);
+  padding: 1rem;
+  backdrop-filter: blur(18px);
+}
+
+.landing-stage__status > div {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+}
+
+.landing-stage__status p {
+  margin: 0.15rem 0 0;
+  color: var(--nodedc-text-muted);
+  font-size: 0.66rem;
+  line-height: 1.45;
+}
+
+.landing-stage__footer {
+  position: absolute;
+  z-index: 2;
+  right: 2.4rem;
+  bottom: 1.8rem;
+  left: 2.4rem;
+  display: flex;
+  justify-content: space-between;
+  gap: 1rem;
+  color: var(--nodedc-text-muted);
+  font-size: 0.57rem;
+  font-weight: 780;
+  letter-spacing: 0.12em;
+}
@@ -1 +1,477 @@
-@import "../../../../packages/spatial-ui/src/spatial.css";
+.spatial-workspace {
+  display: grid;
+  width: 100%;
+  height: 100%;
+  min-width: 0;
+  min-height: 34rem;
+  grid-template-rows: auto minmax(0, 1fr) auto;
+  gap: 0.65rem;
+  overflow: hidden;
+}
+
+.spatial-toolbar {
+  display: flex;
+  min-width: 0;
+  align-items: center;
+  justify-content: flex-start;
+  gap: 1rem;
+}
+
+.spatial-toolbar__actions {
+  display: flex;
+  min-width: 0;
+  align-items: center;
+  gap: 0.45rem;
+}
+
+.spatial-toolbar__view-switch {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+  border: 1px solid rgb(255 255 255 / 0.07);
+  border-radius: 999px;
+  background: rgb(255 255 255 / 0.025);
+  padding: 0.2rem;
+}
+
+.spatial-toolbar__view-switch .nodedc-button {
+  border-radius: 999px;
+}
+
+.spatial-viewport-shell {
+  position: relative;
+  min-width: 0;
+  min-height: 0;
+  overflow: hidden;
+  border-radius: 1rem;
+  background: #06070a;
+  box-shadow: none;
+}
+
+.rerun-viewport,
+.rerun-viewport__canvas {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  min-width: 0;
+  min-height: 0;
+}
+
+.rerun-viewport__canvas[data-presented="false"] {
+  visibility: hidden;
+}
+
+.recorded-session-preloaders {
+  position: fixed;
+  left: -10000px;
+  top: -10000px;
+  width: 1px;
+  height: 1px;
+  overflow: hidden;
+  opacity: 0;
+  pointer-events: none;
+}
+
+.rerun-viewport {
+  --rerun-native-chrome-height: 72px;
+  overflow: hidden;
+}
+
+/* Rerun WebViewer 0.34.1 keeps three fixed 24px canvas rows even after its
+   panels are overridden: the native top row, recording tab and view tab.
+   They are drawn inside WASM and cannot be styled independently, so crop the
+   fixed native chrome while keeping the actual 3D viewport full-height. */
+.rerun-viewport__canvas {
+  top: calc(-1 * var(--rerun-native-chrome-height));
+  bottom: auto;
+  height: calc(100% + var(--rerun-native-chrome-height));
+}
+
+.rerun-viewport__canvas canvas {
+  display: block;
+  width: 100% !important;
+  height: 100% !important;
+}
+
+.rerun-viewport__camera-lock {
+  position: absolute;
+  z-index: 2;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  width: calc(46% - 2px);
+  cursor: default;
+  touch-action: none;
+}
+
+.rerun-viewport:is([data-status="loading"], [data-status="error"])
+  .rerun-viewport__canvas {
+  visibility: hidden;
+  pointer-events: none;
+}
+
+.rerun-viewport__notice {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  display: flex;
+  align-items: center;
+  gap: 0.8rem;
+  border: 0;
+  border-radius: 1rem;
+  background: rgb(10 11 14 / 0.82);
+  padding: 0.9rem 1rem;
+  transform: translate(-50%, -50%);
+  backdrop-filter: blur(18px);
+}
+
+.rerun-viewport__notice strong,
+.rerun-viewport__notice span {
+  display: block;
+}
+
+.rerun-viewport__notice strong {
+  font-size: 0.72rem;
+}
+
+.rerun-viewport__notice span {
+  margin-top: 0.18rem;
+  color: var(--nodedc-text-muted);
+  font-size: 0.61rem;
+}
+
+.rerun-viewport__notice--error {
+  background: rgb(10 11 14 / 0.9);
+}
+
+.rerun-viewport__retry {
+  margin-top: 0.65rem;
+  border: 1px solid var(--station-hairline-strong);
+  border-radius: 999px;
+  background: rgb(255 255 255 / 0.08);
+  padding: 0.42rem 0.7rem;
+  color: var(--nodedc-text-primary);
+  font: inherit;
+  font-size: 0.61rem;
+  cursor: pointer;
+}
+
+.rerun-viewport__retry:hover,
+.rerun-viewport__retry:focus-visible {
+  background: rgb(255 255 255 / 0.14);
+  outline: none;
+}
+
+.busy-indicator {
+  width: 1rem;
+  height: 1rem;
+  flex: 0 0 1rem;
+  border: 2px solid rgb(255 255 255 / 0.12);
+  border-top-color: var(--nodedc-text-primary);
+  border-radius: 50%;
+  animation: viewer-spin 900ms linear infinite;
+}
+
+@keyframes viewer-spin {
+  to { transform: rotate(360deg); }
+}
+
+.empty-spatial-stage {
+  position: absolute;
+  inset: 0;
+  overflow: hidden;
+  background: #06070a;
+}
+
+.empty-spatial-stage__grid {
+  display: none;
+}
+
+.spatial-axis {
+  position: absolute;
+  right: 2rem;
+  bottom: 5.2rem;
+  width: 4.4rem;
+  height: 4.4rem;
+  color: var(--nodedc-text-muted);
+  font-size: 0.53rem;
+}
+
+.spatial-axis::before,
+.spatial-axis::after {
+  position: absolute;
+  bottom: 0.65rem;
+  left: 0.75rem;
+  width: 2.7rem;
+  height: 1px;
+  background: rgb(255 255 255 / 0.2);
+  content: "";
+  transform-origin: left center;
+}
+
+.spatial-axis::before { transform: rotate(-24deg); }
+.spatial-axis::after { transform: rotate(-90deg); }
+.spatial-axis span { position: absolute; }
+.spatial-axis span[data-axis="x"] { right: 0; bottom: 0; color: var(--nodedc-text-muted); }
+.spatial-axis span[data-axis="y"] { top: 0; left: 0.55rem; color: var(--nodedc-text-muted); }
+.spatial-axis span[data-axis="z"] { right: 0.55rem; bottom: 2.2rem; color: var(--nodedc-text-muted); }
+
+.empty-spatial-stage__message {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  display: grid;
+  max-width: 25rem;
+  justify-items: center;
+  gap: 0.62rem;
+  transform: translate(-50%, -58%);
+  text-align: center;
+}
+
+.empty-spatial-stage__icon {
+  display: grid;
+  width: 3.4rem;
+  height: 3.4rem;
+  place-items: center;
+  border: 0;
+  border-radius: 50%;
+  background: rgb(255 255 255 / 0.035);
+  color: var(--nodedc-text-secondary);
+}
+
+.empty-spatial-stage__message strong {
+  color: var(--nodedc-text-primary);
+  font-size: 0.82rem;
+}
+
+.empty-spatial-stage__message p {
+  margin: 0;
+  color: var(--nodedc-text-muted);
+  font-size: 0.67rem;
+  line-height: 1.5;
+}
+
+.scene-status,
+.scene-metrics,
+.scene-adapter-note,
+.scene-selection,
+.scene-timeline {
+  position: absolute;
+  z-index: 3;
+  border: 0;
+  background: rgb(9 10 13 / 0.74);
+  backdrop-filter: blur(16px);
+}
+
+.scene-status--top-left {
+  top: 0.85rem;
+  left: 0.85rem;
+  display: grid;
+  justify-items: start;
+  gap: 0.42rem;
+  border-radius: 0.9rem;
+  padding: 0.7rem;
+}
+
+.scene-status small {
+  max-width: 18rem;
+  color: var(--nodedc-text-muted);
+  font-size: 0.57rem;
+  line-height: 1.35;
+}
+
+.scene-metrics {
+  top: 0.85rem;
+  right: 0.85rem;
+  display: grid;
+  min-width: 10rem;
+  border-radius: 0.9rem;
+  padding: 0.35rem 0.75rem;
+}
+
+.scene-metrics > div {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 1rem;
+  border-bottom: 0;
+  padding: 0.38rem 0;
+}
+
+.scene-metrics > div:last-child { border-bottom: 0; }
+.scene-metrics span { color: var(--nodedc-text-muted); font-size: 0.56rem; }
+.scene-metrics strong { color: var(--nodedc-text-primary); font-size: 0.72rem; }
+.scene-metrics small { color: var(--nodedc-text-muted); font-size: 0.52rem; font-weight: 500; }
+
+.scene-adapter-note {
+  top: 50%;
+  left: 50%;
+  display: flex;
+  max-width: 34rem;
+  align-items: center;
+  gap: 0.65rem;
+  border-radius: 0.9rem;
+  color: var(--nodedc-text-secondary);
+  padding: 0.75rem 0.9rem;
+  font-size: 0.63rem;
+  line-height: 1.4;
+  transform: translate(-50%, 5.2rem);
+}
+
+.scene-adapter-note > svg { flex: 0 0 auto; color: var(--nodedc-text-secondary); }
+
+.scene-selection {
+  right: 0.85rem;
+  bottom: 4.6rem;
+  display: grid;
+  max-width: 19rem;
+  gap: 0.2rem;
+  border-radius: 0.85rem;
+  padding: 0.65rem 0.75rem;
+}
+
+.scene-selection span,
+.scene-selection small { color: var(--nodedc-text-muted); font-size: 0.55rem; }
+.scene-selection strong { overflow: hidden; font-size: 0.66rem; text-overflow: ellipsis; white-space: nowrap; }
+
+.scene-operation-status-stack {
+  position: absolute;
+  z-index: 11;
+  left: 0.85rem;
+  bottom: 7.15rem;
+  display: grid;
+  justify-items: start;
+  gap: 0.3rem;
+}
+
+.scene-operation-status {
+  display: inline-flex;
+  max-width: min(24rem, calc(100% - 1.7rem));
+  align-items: center;
+  gap: 0.42rem;
+  border: 1px solid rgb(255 255 255 / 0.07);
+  border-radius: 999px;
+  background: rgb(9 10 13 / 0.7);
+  color: var(--nodedc-text-muted);
+  padding: 0.42rem 0.65rem;
+  font: inherit;
+  font-size: 0.52rem;
+  font-weight: 680;
+  line-height: 1;
+  white-space: nowrap;
+  backdrop-filter: blur(14px);
+}
+
+.scene-operation-status .busy-indicator {
+  width: 0.66rem;
+  height: 0.66rem;
+  flex-basis: 0.66rem;
+  border-width: 1px;
+}
+
+.scene-operation-status--action {
+  color: var(--nodedc-text-secondary);
+  cursor: pointer;
+}
+
+.scene-operation-status--action:hover,
+.scene-operation-status--action:focus-visible {
+  border-color: rgb(255 255 255 / 0.14);
+  background: rgb(20 21 25 / 0.82);
+  color: var(--nodedc-text-primary);
+  outline: none;
+}
+
+.scene-operation-status--error {
+  color: rgb(var(--nodedc-danger-rgb));
+}
+
+.scene-timeline {
+  right: 0.75rem;
+  bottom: 0.75rem;
+  left: 0.75rem;
+  display: grid;
+  min-width: 0;
+  grid-template-columns: auto auto minmax(0, 1fr) auto auto;
+  align-items: center;
+  gap: 0.6rem;
+  border-radius: 0.9rem;
+  padding: 0.4rem;
+}
+
+.scene-timeline__track {
+  height: 0.3rem;
+  overflow: hidden;
+  border-radius: 999px;
+  background: rgb(255 255 255 / 0.08);
+}
+
+.scene-timeline__track span {
+  display: block;
+  height: 100%;
+  border-radius: inherit;
+  background: var(--nodedc-text-primary);
+}
+
+.scene-timeline__track[data-disabled="true"] { opacity: 0.46; }
+.scene-timeline code { color: var(--nodedc-text-muted); font-size: 0.57rem; }
+
+.scene-timeline__follow {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.38rem;
+  border-radius: var(--nodedc-radius-circle);
+  background: transparent;
+  color: var(--nodedc-text-muted);
+  padding: 0.3rem 0.45rem;
+  font-size: 0.52rem;
+  font-weight: 820;
+}
+
+.scene-timeline__follow::before {
+  width: 0.4rem;
+  height: 0.4rem;
+  border-radius: 50%;
+  background: var(--nodedc-text-muted);
+  content: "";
+}
+
+.scene-timeline__follow[data-active="true"] {
+  background: transparent;
+  color: var(--nodedc-text-primary);
+}
+
+.scene-timeline__follow[data-active="true"]::before {
+  background: rgb(var(--nodedc-success-rgb));
+}
+
+.spatial-contract-strip {
+  display: flex;
+  min-width: 0;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.45rem 1rem;
+  color: var(--nodedc-text-muted);
+  font-size: 0.57rem;
+}
+
+.spatial-contract-strip span {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.38rem;
+}
+
+.spatial-contract-strip i {
+  width: 0.42rem;
+  height: 0.42rem;
+  border-radius: 50%;
+  background: var(--nodedc-text-muted);
+}
+
+.spatial-contract-strip i[data-state="ready"] { background: var(--nodedc-text-primary); }
+.spatial-contract-strip i[data-state="contract"] { background: rgb(var(--nodedc-warning-rgb)); }
+
+@media (prefers-reduced-motion: reduce) {
+  .busy-indicator { animation: none; }
+}
@@ -1,6 +1,3 @@
-import {SpatialScene, EmptySpatialStage} from '../../../../packages/spatial-ui/src';
-import {SpatialToolbarActions} from "../../../../packages/spatial-ui/src/SpatialToolbarActions";
-import { VehiclesWorkspace } from "./fleet/VehiclesWorkspace";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Button, GlassSurface, Icon, StatusBadge } from "@nodedc/ui-react";
 import {
@@ -15,7 +12,6 @@ import type {
  RecordedCameraAdmissionState,
 } from "../core/observation/recordedSessionAdmission";
 import { liveRerunRecoveryAuthorityIdentity } from "../core/observation/liveReceiverWatchdog";
-import { liveAcquisitionRerunProfile, recordedSessionRerunProfile } from "../core/observation/viewerProfile";
 import type { ObservationSourceDescriptor } from "../core/runtime/contracts";
 import {
  RerunViewport,
@@ -34,6 +30,7 @@ import {
  type WorkspaceDefinition,
 } from "../productModel";
 import { finiteMetric, formatNumber, pipelineLatency, sourceModeLabel } from "../presentation";
+import type { SceneSettings } from "../sceneSettings";
 import type { WorkspaceRendererProps } from "./contracts";
 import { DatasetGatewayWorkspace } from "./DatasetGatewayWorkspace";
 import { ArtifactHealthWorkspace } from "./data/ArtifactHealthWorkspace";
@@ -43,13 +40,13 @@ import { SimulationWorkspace } from "./simulation/SimulationWorkspace";
 import { ComputeModulesWorkspace } from "./system/ComputeModulesWorkspace";
 import { NetworkWorkspace } from "./system/NetworkWorkspace";
 import { WorldMapWorkspace } from "./map/WorldMapWorkspace";
-import { ObservatoryWorkspace } from "./observatory/ObservatoryWorkspace";
 function statusTone(status: CapabilityStatus): "success" | "accent" | "warning" | "neutral" {
  if (status === "active") return "success";
  if (status === "ready") return "accent";
  if (status === "contract") return "warning";
  return "neutral";
 }
+
 function FeatureInventory({ definition }: { definition: WorkspaceDefinition }) {
  return (
    <div className="feature-inventory">
@@ -79,6 +76,7 @@ function FeatureInventory({ definition }: { definition: WorkspaceDefinition }) {
    </div>
  );
 }
+
 function WorkspaceLead({ definition, note }: { definition: WorkspaceDefinition; note?: string }) {
  return (
    <section className="workspace-lead workspace-lead--compact">
@@ -91,6 +89,27 @@ function WorkspaceLead({ definition, note }: { definition: WorkspaceDefinition;
    </section>
  );
 }
+
+function EmptySpatialStage({ settings }: { settings: SceneSettings }) {
+  return (
+    <div className="empty-spatial-stage" data-grid={settings.showGrid ? "true" : undefined}>
+      <div className="empty-spatial-stage__grid" aria-hidden="true" />
+      <div className="spatial-axis" aria-hidden="true">
+        <span data-axis="x">X</span>
+        <span data-axis="z">Z</span>
+      </div>
+      <div className="empty-spatial-stage__message">
+        <span className="empty-spatial-stage__icon"><Icon name="globe" size={20} /></span>
+        <strong>Визуальный источник не назначен</strong>
+        <p>
+          Область сцены не подставляет демонстрационные точки. Назначьте RRD или Rerun gRPC, чтобы
+          открыть реальные данные.
+        </p>
+      </div>
+    </div>
+  );
+}
+
 function SpatialWorkspace({
  state,
  sourceUrl,
@@ -162,7 +181,7 @@ function SpatialWorkspace({
  );
  const recordedPerceptionSupported =
    recordedSource && perceptionLoad.phase !== "unavailable";
-  const recordedPerceptionLoading = recordedSource && perceptionLoad.phase === "loading";
+  const recordedPerceptionReady = recordedSource && perceptionLoad.phase === "ready";
  const recordedPerceptionEnabled =
    showDetections2d || showSegmentation || showCuboids3d;
  // The native recorded camera remains the authoritative original. Only 2D
@@ -242,7 +261,7 @@ function SpatialWorkspace({
  const shouldPrepareRecordedSource = useCallback((sourceId: string) => {
    if (!recordedSessionAdmission) return false;
    return recordedSessionAdmission.activeCameraSourceIds.has(sourceId) ||
-      ["ready", "error"].includes(recordedSessionAdmission.cameras[sourceId]?.phase ?? "loading");
+      recordedSessionAdmission.cameras[sourceId]?.phase === "ready";
  }, [recordedSessionAdmission]);
  const onSelectionChange = useCallback((next: RerunSelection | null) => setSelection(next), []);
  const onPlaybackChange = useCallback(
@@ -362,39 +381,15 @@ function SpatialWorkspace({
    : presentedViewerStatus === "error"
      ? "danger"
      : "neutral";
-  const rerunViewerProfile = recordedSource
-    ? recordedSessionRerunProfile({
-        sourceUrl,
-        artifact: recordedReplay,
-        autoplayWhenReady: true,
-        presentationGate: recordedSessionGate,
-        expectedTimelineStartSeconds: state?.observationTimeline?.range?.startSeconds,
-        expectedTimelineEndSeconds: state?.observationTimeline?.range?.endSeconds,
-        initialPlaybackStartSeconds: initialRecordedPlaybackStartSeconds,
-        view: "spatial",
-        viewResetGeneration: recordedViewResetGeneration,
-        followTrajectory: followRecordedTrajectory,
-        perceptionLayers: {
-          enabled: recordedPerceptionSupported && recordedPerceptionEnabled,
-          detections2d: showDetections2d,
-          segmentation: showSegmentation,
-          cuboids3d: showCuboids3d,
-        },
-        perceptionRetryGeneration,
-        lockPerceptionCameraInteraction: unifiedPerception,
-      })
-    : liveAcquisitionRerunProfile({
-        sourceUrl,
-        liveActivitySequence: livePresentationActivitySequence,
-        liveStreamId: state?.spatialSource?.id ?? null,
-        liveRecoveryAuthorityIdentity: streamActive
-          ? liveRerunRecoveryAuthorityIdentity(pointCloudSource, state?.spatialSource)
-          : null,
-      });

-  return <SpatialScene viewportRef={viewportRef} focused={pointCloudFocused||floatingSourceMaximized}
-    primaryFocused={pointCloudFocused} mediaMaximized={floatingSourceMaximized}
-    toolbar={<>          {recordedPerceptionSupported || livePerceptionAvailable ? (
+  return (
+    <div
+      className="spatial-workspace"
+      data-focused={pointCloudFocused || floatingSourceMaximized ? "true" : undefined}
+    >
+      <div className="spatial-toolbar" data-viewer-controls="v1">
+        <div className="spatial-toolbar__actions">
+          {recordedPerceptionSupported || livePerceptionAvailable ? (
            <div className="spatial-toolbar__view-switch" role="group" aria-label="Слои распознавания сцены">
              <Button
                size="compact"
@@ -410,7 +405,7 @@ function SpatialWorkspace({
                variant={detections2dActive ? "primary" : "secondary"}
                icon={<Icon name="target" />}
                aria-pressed={detections2dActive}
-                disabled={recordedPerceptionLoading}
+                disabled={recordedSource && !recordedPerceptionReady}
                onClick={() => recordedSource
                  ? setShowDetections2d((current) => !current)
                  : onLivePerceptionLayersChange({
@@ -425,7 +420,7 @@ function SpatialWorkspace({
                variant={segmentationActive ? "primary" : "secondary"}
                icon={<Icon name="image" />}
                aria-pressed={segmentationActive}
-                disabled={recordedPerceptionLoading}
+                disabled={recordedSource && !recordedPerceptionReady}
                onClick={() => recordedSource
                  ? setShowSegmentation((current) => !current)
                  : onLivePerceptionLayersChange({
@@ -440,7 +435,7 @@ function SpatialWorkspace({
                variant={cuboids3dActive ? "primary" : "secondary"}
                icon={<Icon name="apps" />}
                aria-pressed={cuboids3dActive}
-                disabled={recordedPerceptionLoading}
+                disabled={recordedSource && !recordedPerceptionReady}
                onClick={() => recordedSource
                  ? setShowCuboids3d((current) => !current)
                  : onLivePerceptionLayersChange({
@@ -474,10 +469,55 @@ function SpatialWorkspace({
              Сброс вида
            </Button>
          ) : null}
-          <SpatialToolbarActions openSource={navigation.openSource} openLayers={navigation.openLayers} openDisplay={navigation.openDisplay}/></>} renderer={<>          {sourceUrl.trim() && pointCloudVisible && !intentionalSourceEnd ? (
+          <Button size="compact" variant="secondary" icon={<Icon name="network" />} onClick={navigation.openSource}>
+            Движок
+          </Button>
+          <Button size="compact" variant="secondary" icon={<Icon name="list" />} onClick={navigation.openLayers}>
+            Слои
+          </Button>
+          <Button size="compact" variant="secondary" icon={<Icon name="sliders" />} onClick={navigation.openDisplay}>
+            Отображение
+          </Button>
+        </div>
+      </div>
+
+      <div
+        ref={viewportRef}
+        className="spatial-viewport-shell"
+        data-primary-focused={pointCloudFocused ? "true" : undefined}
+        data-media-maximized={floatingSourceMaximized ? "true" : undefined}
+      >
+          {sourceUrl.trim() && pointCloudVisible && !intentionalSourceEnd ? (
            <RerunViewport
-              profile={rerunViewerProfile}
+              sourceUrl={sourceUrl}
+              recordedArtifact={recordedSource ? recordedReplay : null}
+              followLive={liveRerunSource}
+              liveActivitySequence={livePresentationActivitySequence}
+              liveStreamId={state?.spatialSource?.id}
+              liveRecoveryAuthorityIdentity={!recordedSource && streamActive ? liveRerunRecoveryAuthorityIdentity(pointCloudSource, state?.spatialSource) : null}
+              autoplayWhenReady={recordedSource}
+              presentationGate={recordedSessionGate}
+              expectedTimelineStartSeconds={recordedSource
+                ? state?.observationTimeline?.range?.startSeconds
+                : undefined}
+              expectedTimelineEndSeconds={recordedSource
+                ? state?.observationTimeline?.range?.endSeconds
+                : undefined}
+              initialPlaybackStartSeconds={initialRecordedPlaybackStartSeconds}
              sceneSettings={sceneSettings}
+              recordedViewResetGeneration={recordedViewResetGeneration}
+              recordedFollowTrajectory={followRecordedTrajectory}
+              recordedPerceptionLayers={{
+                enabled:
+                  recordedPerceptionSupported &&
+                  recordedPerceptionReady &&
+                  recordedPerceptionEnabled,
+                detections2d: showDetections2d,
+                segmentation: showSegmentation,
+                cuboids3d: showCuboids3d,
+              }}
+              recordedPerceptionRetryGeneration={perceptionRetryGeneration}
+              lockPerceptionCameraInteraction={unifiedPerception}
              onPerceptionLoadChange={onPerceptionLoadChange}
              onPointColorLoadChange={onPointColorLoadChange}
              onStatusChange={onStatusChange}
@@ -488,15 +528,20 @@ function SpatialWorkspace({
          ) : (
            <EmptySpatialStage settings={sceneSettings} />
          )}
-</>}
-    deviceControls={spatialControls&&!recordedSource?(              <spatialControls.View
+
+          {spatialControls && !recordedSource ? (
+            <div className="scene-device-controls">
+              <spatialControls.View
                model={spatialControls.model}
                host={{
                  openSpatialScene: () => navigation.openView("spatial-scene"),
                  activateAutomaticSpatialSource: navigation.activateAutomaticSpatialSource,
                }}
-              />):null}
-    sourceControls={<>          {pointCloudFocused ? (
+              />
+            </div>
+          ) : null}
+
+          {pointCloudFocused ? (
            <button
              type="button"
              className="scene-focus-exit"
@@ -527,9 +572,22 @@ function SpatialWorkspace({
              ) : null}
            </div>
          ) : null}
-</>}
-    status={{label:viewerStatusLabel,tone:viewerStatusTone,message:!intentionalSourceEnd?viewerMessage:undefined}}
-    metrics={<>            <div>
+
+          <div
+            className="scene-status scene-status--top-left"
+            aria-hidden={pointCloudFocused || floatingSourceMaximized}
+          >
+            <span className="section-eyebrow">ВИЗУАЛЬНЫЙ ДВИЖОК</span>
+            <StatusBadge tone={viewerStatusTone}>{viewerStatusLabel}</StatusBadge>
+            {!intentionalSourceEnd && viewerMessage ? <small>{viewerMessage}</small> : null}
+          </div>
+
+          <div
+            className="scene-metrics"
+            aria-label="Метрики пространственной сцены"
+            aria-hidden={pointCloudFocused || floatingSourceMaximized}
+          >
+            <div>
              <span>КАДР/С</span>
              <strong>{formatNumber(frameRate)}</strong>
            </div>
@@ -550,7 +608,10 @@ function SpatialWorkspace({
                  {aiFrameRate === null ? null : <small> · {formatNumber(aiFrameRate)} Гц</small>}
                </strong>
              </div>
-            ) : null}</>} overlays={<>          {!pointCloudFocused && !floatingSourceMaximized && state?.sourceMode && state.sourceMode !== "idle" && !sourceUrl.trim() ? (
+            ) : null}
+          </div>
+
+          {!pointCloudFocused && !floatingSourceMaximized && state?.sourceMode && state.sourceMode !== "idle" && !sourceUrl.trim() ? (
            <div className="scene-adapter-note">
              <Icon name="alert" />
              <span>
@@ -605,8 +666,14 @@ function SpatialWorkspace({
            </div>
          ) : null}

-</>}
-    navigationReady={presentedViewerStatus==='ready'} timeline={<>          {!pointCloudFocused && !floatingSourceMaximized && recordedPlaybackReady ? (
+          {presentedViewerStatus === "ready" && !floatingSourceMaximized ? (
+            <div className="scene-navigation-hint" aria-label="Навигация по 3D-сцене">
+              <span>Колесо · зум к курсору</span>
+              <span>WASD · свободный проход</span>
+            </div>
+          ) : null}
+
+          {!pointCloudFocused && !floatingSourceMaximized && recordedPlaybackReady ? (
            <ObservationTimeline
              active={presentedViewerStatus === "ready"}
              sourceCount={Math.max(1, (unifiedPerception ? 2 : 1) + presentedMediaSourceCount)}
@@ -629,8 +696,8 @@ function SpatialWorkspace({
              className="scene-timeline"
            />
          ) : null}
-</>}
-    media={<>          {visibleMediaSources.map((source, index) => (
+
+          {visibleMediaSources.map((source, index) => (
            <FloatingObservationWindow
              key={source.id}
              source={source}
@@ -681,7 +748,10 @@ function SpatialWorkspace({
                />
              ))}
            </div>
-          ) : null}</>} footer={      <div className="spatial-contract-strip">
+          ) : null}
+      </div>
+
+      <div className="spatial-contract-strip">
        <span><i data-state="ready" />Облако точек</span>
        <span><i data-state="ready" />Траектория</span>
        <span><i data-state="ready" />Преобразования</span>
@@ -690,7 +760,9 @@ function SpatialWorkspace({
        <span><i data-state={segmentationActive ? "ready" : "contract"} />Сегментация</span>
        <span><i data-state={cuboids3dActive ? "ready" : "contract"} />Кубы 3D</span>
        <span><i data-state="contract" />Компоновка</span>
-      </div>}/>;
+      </div>
+    </div>
+  );
 }

 function CameraSourceCard({
@@ -833,7 +905,7 @@ function CamerasWorkspace({
    if (!recordedReplay) return true;
    if (!recordedSessionAdmission) return false;
    return recordedSessionAdmission.activeCameraSourceIds.has(sourceId) ||
-      ["ready", "error"].includes(recordedSessionAdmission.cameras[sourceId]?.phase ?? "loading");
+      recordedSessionAdmission.cameras[sourceId]?.phase === "ready";
  }, [recordedReplay, recordedSessionAdmission]);
  return (
    <div className="standard-workspace cameras-workspace" data-focused={focusedSource ? "true" : undefined}>
@@ -1094,8 +1166,6 @@ export function WorkspaceRenderer(props: WorkspaceRendererProps) {
      return <TimelineWorkspace {...props} />;
    case "missions":
      return <MissionWorkspace {...props} />;
-    case "vehicles":
-      return <VehiclesWorkspace createRequest={props.fleetCreateRequest} />;
    case "catalog":
      return <CatalogWorkspace {...props} />;
    case "contour-health":
@@ -1121,8 +1191,6 @@ export function WorkspaceRenderer(props: WorkspaceRendererProps) {
      );
    case "simulations":
      return <SimulationWorkspace />;
-    case "observatory":
-      return <ObservatoryWorkspace definition={props.definition} />;
    case "device":
      return null;
  }
@@ -35,7 +35,6 @@ export interface LaboratoryViewAction {
 }

 export interface WorkspaceRendererProps {
-  fleetCreateRequest?: number;
  definition: WorkspaceDefinition;
  state: MissionRuntimeState | null;
  backendStatus: BackendStatus;
@@ -1,45 +0,0 @@
-import {useState} from 'react';
-import {ActivityIndicator,Button,Icon,ResourceList,ResourceRow,Select,SettingsCard,StatusBadge,TextField,ToastStack} from '@nodedc/ui-react';
-import {useBoardMonitor,monitorSeries,monitorValue} from '../../core/fleet/boardMonitor';
-import {TelemetrySeries} from '../../components/system/TelemetrySeries';
-import '../../styles/system-telemetry.css';
-import './board-monitor.css';
-
-const eventLabels:Record<string,string>={'ui-error':'Ошибка интерфейса','ui-rejection':'Ошибка асинхронной операции','ui-render-error':'Ошибка представления','system-oom':'Нехватка памяти','gpu-reset':'Сброс GPU','disk-error':'Ошибка диска','usb-disconnected':'Отключение USB','usb-error':'Ошибка USB','service-failed':'Сбой службы','ui-process-exit':'Завершение процесса окна','ui-load-failed':'Ошибка загрузки окна'};
-const time=(value:number)=>new Date(value*1000).toLocaleString('ru-RU');
-export function BoardMonitorView({vehicle,name,back}:{vehicle:string;name:string;back:()=>void}) {
- const [metric,setMetric]=useState('cpu.usage'),[group,setGroup]=useState('CPU'),[window,setWindow]=useState(900),[end,setEnd]=useState<number|null>(null),[mode,setMode]=useState<'min'|'max'|'mean'>('max');
- const {value,error,dismissError}=useBoardMonitor(vehicle,metric,window,end);
- const definitions=value?.definitions??{},definition=definitions[metric];
- const groups=[...new Set(Object.values(definitions).map(item=>item.group))];
- const metrics=Object.entries(definitions).filter(([,item])=>item.group===group);
- const latest=value?.latest;
- return <div className="board-monitor">
-  <div><Button onClick={back}><Icon name="chevron-left"/>К аппарату</Button></div>
-  <SettingsCard title="Мониторинг системы БК" description={name} actions={<StatusBadge tone={value?.fresh&&!error?'success':'neutral'}>{value?.fresh&&!error?'Данные поступают':'Нет свежих данных'}</StatusBadge>}>
-   {latest&&<p>Измерено на БК: {time(latest.at)}. {value?.storage==='ready'?'Локальная история записывается.':'Запись локальной истории недоступна.'} {value?.backlog?'История догружается в Mission Core.':''}</p>}
-   {value?.database_bytes!=null&&<p>Архив на БК: {monitorValue(value.database_bytes,'bytes')} из {monitorValue(value.database_budget_bytes,'bytes')}. {value.archive_since?`Копия в Mission Core с ${time(value.archive_since)}.`:''}</p>}
-  </SettingsCard>
-  {!value?<ActivityIndicator label="Получение мониторинга БК"/>:!value.available?<SettingsCard title="История БК пока не получена" description="Данные появятся после подключения бортового сборщика телеметрии."/>:<>
-   <SettingsCard title="История нагрузки">
-    <div className="board-monitor-controls">
-     <Select label="Ресурс" value={group} options={groups.map(label=>({value:label,label}))} onChange={next=>{setGroup(next);const first=Object.entries(definitions).find(([,item])=>item.group===next);if(first)setMetric(first[0]);}}/>
-     <Select label="Показатель" value={metric} options={metrics.map(([key,item])=>({value:key,label:`${item.resource} · ${item.label}`}))} onChange={setMetric}/>
-     <Select label="Период" value={String(window)} options={[{value:'900',label:'15 минут'},{value:'3600',label:'1 час'},{value:'21600',label:'6 часов'},{value:'86400',label:'24 часа'},{value:'604800',label:'7 дней'}]} onChange={next=>setWindow(Number(next))}/>
-     <Select label="Значение в интервале" value={mode} options={[{value:'max',label:'Максимум'},{value:'mean',label:'Среднее'},{value:'min',label:'Минимум'}]} onChange={next=>setMode(next as typeof mode)}/>
-    </div>
-    <div className="board-monitor-controls"><Button onClick={()=>setEnd(end===null?Date.now()/1000:null)}>{end===null?'Зафиксировать время':'В реальном времени'}</Button>{end!==null&&<TextField label="Конец периода" type="datetime-local" step="1" value={new Date((end-new Date(end*1000).getTimezoneOffset()*60)*1000).toISOString().slice(0,19)} onChange={event=>{const next=new Date(event.target.value).getTime()/1000;if(Number.isFinite(next))setEnd(next);}}/>}</div>
-    <TelemetrySeries label={definition?`${definition.resource} · ${definition.label}`:'Загрузка CPU'} resource="Последний интервал периода" value={monitorValue(value.series.at(-1)?.[mode],definition?.unit)} values={monitorSeries(value,mode)} ceiling={definition?.unit==='%'?100:undefined}/>
-    <p>{time(value.start)} — {time(value.end)} · интервал {value.bucket_seconds} с. Разрывы означают отсутствие измерений.</p>
-    {!value.series.length&&<p>За выбранный период измерений нет.</p>}
-   </SettingsCard>
-   <SettingsCard title={`Последние измерения · ${group}`} description={latest?time(latest.at):'Ожидание измерений'}>
-    <ResourceList aria-label="Показатели системы">{metrics.map(([key,item])=><li key={key}><ResourceRow title={`${item.resource} · ${item.label}`} description={latest?.values[key]==null?item.reason??'Счётчик недоступен':undefined} metadata={monitorValue(latest?.values[key],item.unit)}/></li>)}</ResourceList>
-   </SettingsCard>
-   <SettingsCard title="События системы и приложения" description="За выбранный период">
-    {value.events.length?<ResourceList aria-label="События БК">{value.events.map((event,index)=><li key={`${event.at}-${index}`}><ResourceRow title={eventLabels[event.code]??'Событие системы'} description={time(event.at)}/></li>)}</ResourceList>:<p>Событий не получено.</p>}
-   </SettingsCard>
-  </>}
-  <ToastStack items={error?[{id:'monitor-error',title:error,tone:'error',durationMs:null}]:[]} onDismiss={dismissError}/>
- </div>;
-}
@@ -1,11 +0,0 @@
-import {useMemo} from 'react';
-import {useDevicePluginHost} from '../../core/device-plugins/DevicePluginHost';
-import {createIsolatedRerunHost} from '../../components/rerun/isolatedRerunHost';
-import {SensorWorkspace} from '../../../../../packages/sensor-ui/src/SensorWorkspace';
-import {createFleetSensorTransport} from '../../core/fleet/sensorTransport';
-export function VehicleSensors({vehicleID,enabled,onDetailChange}:{vehicleID:string;enabled:boolean;onDetailChange:(open:boolean)=>void}){
- const {registry}=useDevicePluginHost();
- const sensorContributions=registry.sensorContributions;
- const transport=useMemo(()=>createFleetSensorTransport(vehicleID),[vehicleID]);
- return <SensorWorkspace contributions={sensorContributions} createRerunHost={createIsolatedRerunHost} key={vehicleID} transport={transport} enabled={enabled} onDetailChange={onDetailChange}/>;
-}
@@ -1,77 +0,0 @@
-import {BoardObservationCenter} from './observation/BoardObservationCenter';
-import {BoardMonitorView} from './BoardMonitorView';
-import { useEffect, useRef, useState } from "react";
-import { LoadingRegion, Button, ConfirmationModal, Icon, IconButton, ResourceList, ResourceRow, Select, SettingsCard, StatusBadge, TextAreaField, TextField, Window, WindowFooterActions } from "@nodedc/ui-react";
-import { fleetRequest, useFleet, type FleetPreview, type Vehicle } from "../../core/fleet/useFleet";
-import "./fleet.css";
-import { VehicleSensors } from "./VehicleSensors";
-
-const platforms = [{ value: "ugv", label: "Наземный (UGV)" }, { value: "uav", label: "Воздушный (UAV)" }, { value: "stationary", label: "Стационарный" }, { value: "other", label: "Другой" }];
-const platformLabel = (value: string) => platforms.find(item => item.value === value)?.label ?? value;
-function statusLabel(item: Vehicle) { return item.enrollment === "pending" ? "Подтверждаем привязку" : item.enrollment === "revoked" ? "Доверие отозвано" : item.enrollment === "failed" ? "Привязка не завершена" : item.connectivity === "online" ? "В сети" : "Нет связи"; }
-
-export function VehiclesWorkspace({ createRequest = 0 }: { createRequest?: number }) {
-  const fleet = useFleet();
-  const [adding, setAdding] = useState(false);
-  const [code, setCode] = useState("");
-  const [name, setName] = useState("");
-  const [platform, setPlatform] = useState("ugv");
-  const [preview, setPreview] = useState<FleetPreview | null>(null);
-  const [pending, setPending] = useState(false);
-  const [error, setError] = useState("");
-  const [selected, setSelected] = useState<string | null>(null);
-  const [sensorOpen, setSensorOpen] = useState(false);
-  const [monitorOpen,setMonitorOpen]=useState(false);
-  const [observationOpen,setObservationOpen]=useState(false);
-  const [revoking, setRevoking] = useState<Vehicle | null>(null);
-  const lastCreateRequest = useRef(createRequest);
-  useEffect(() => { if (createRequest !== lastCreateRequest.current) { lastCreateRequest.current = createRequest; setAdding(true); setError(""); } }, [createRequest]);
-  function close() { if (pending) return; setAdding(false); setPreview(null); setCode(""); setName(""); setError(""); }
-  async function inspect(event: React.FormEvent) {
-    event.preventDefault(); if (pending) return;
-    setPending(true); setError("");
-    try { const value = await fleetRequest<FleetPreview>("/preview", "POST", { code: code.trim() }); setPreview(value); setName(current => current || value.name); setCode(""); }
-    catch (error) { setError(error instanceof Error ? error.message : "Не удалось проверить приглашение."); }
-    finally { setPending(false); }
-  }
-  async function add() {
-    if (!preview || pending) return;
-    setPending(true); setError("");
-    try {
-      const item = await fleetRequest<Vehicle>("", "POST", { preview_id: preview.preview_id, name: name.trim(), platform });
-      await fleet.refresh(); setSelected(item.id); setAdding(false); setPreview(null); setCode(""); setName("");
-    } catch (error) { setError(error instanceof Error ? error.message : "Не удалось добавить аппарат."); void fleet.refresh().catch(() => undefined); }
-    finally { setPending(false); }
-  }
-  const detail = fleet.items?.find(item => item.id === selected);
-  if(detail&&observationOpen)return <BoardObservationCenter key={detail.id} vehicleID={detail.id} name={detail.name} enabled={!fleet.error&&detail.enrollment==="paired"&&detail.connectivity==="online"} back={()=>{setObservationOpen(false);setSensorOpen(false);}}/>;
-  if(detail&&monitorOpen)return <BoardMonitorView vehicle={detail.id} name={detail.name} back={()=>setMonitorOpen(false)}/>;
-  return <div className="fleet-workspace">
-    {fleet.error && <p role="alert">{fleet.error}</p>}
-    {!adding && error && <p role="alert">{error}</p>}
-    {detail ? <>
-      <div><Button onClick={() => {setSelected(null);setSensorOpen(false);}}>К списку аппаратов</Button></div>
-      {!sensorOpen && <SettingsCard title={detail.name} description={`${platformLabel(detail.platform)} · с бортовым компьютером`} actions={<StatusBadge tone={!fleet.error && detail.enrollment === "paired" && detail.connectivity === "online" ? "success" : "neutral"}>{fleet.error ? "Нет свежих данных" : statusLabel(detail)}</StatusBadge>}>
-        {detail.notice && <p role="status">{detail.notice}</p>}
-        <dl className="fleet-facts"><div><dt>Бортовой компьютер</dt><dd>{detail.node_id}</dd></div>
-          <div><dt>Последняя связь</dt><dd>{detail.last_seen ? new Date(detail.last_seen * 1000).toLocaleString("ru-RU") : "Соединение ещё не получено"}</dd></div>
-          {detail.host && <><div><dt>Имя БК в системе</dt><dd>{detail.host.hostname}</dd></div><div><dt>Операционная система</dt><dd>{detail.host.os}</dd></div><div><dt>Архитектура</dt><dd>{detail.host.architecture}</dd></div><div><dt>Процессоры</dt><dd>{detail.host.cpus}</dd></div><div><dt>Память</dt><dd>{detail.host.memory_kib ? `${(detail.host.memory_kib / 1024 / 1024).toFixed(1)} ГиБ` : "Нет сведений"}</dd></div></>}
-        </dl>
-        <div className="fleet-board-actions"><Button onClick={()=>setMonitorOpen(true)}><Icon name="activity"/>Мониторинг системы БК</Button>
-        <Button onClick={()=>setObservationOpen(true)}><Icon name="eye"/>Центр наблюдения</Button>
-        {detail.enrollment !== "revoked" && <Button onClick={() => setRevoking(detail)}>Отозвать привязку БК</Button>}</div>
-      </SettingsCard>}
-      <SettingsCard title="Устройства аппарата"><VehicleSensors onDetailChange={setSensorOpen} vehicleID={detail.id} enabled={!fleet.error && detail.enrollment === "paired" && detail.connectivity === "online"} /></SettingsCard>
-    </> : !fleet.items ? <LoadingRegion loading label="Получение аппаратов" /> : fleet.items.length === 0 ? <SettingsCard title="Аппаратов пока нет" description="Добавьте аппарат по приглашению из Mission Core Node на его бортовом компьютере."><Button onClick={() => setAdding(true)}>Добавить аппарат</Button></SettingsCard> : <ResourceList aria-label="Аппараты">{fleet.items.map(item => <li key={item.id}><ResourceRow icon={<Icon name="apps" />} title={item.name} description={`${platformLabel(item.platform)} · бортовой компьютер`} status={<StatusBadge tone={!fleet.error && item.enrollment === "paired" && item.connectivity === "online" ? "success" : "neutral"}>{fleet.error ? "Нет свежих данных" : statusLabel(item)}</StatusBadge>} actions={<><IconButton label={`Конфигурация: ${item.name}`} onClick={() => setSelected(item.id)}><Icon name="sliders" /></IconButton><IconButton label={`Центр наблюдения: ${item.name}`} onClick={() => {setSelected(item.id);setObservationOpen(true);}}><Icon name="eye" /></IconButton></>} /></li>)}</ResourceList>}
-    <Window open={adding} title="Добавить аппарат" subtitle="Подключить бортовой компьютер по приглашению Node" size="md" closeOnBackdrop={false} closeOnEscape={!pending} onClose={close} footer={<WindowFooterActions><Button disabled={pending} onClick={close}>Отмена</Button>{preview ? <Button disabled={pending || !name.trim()} onClick={() => void add()}>{pending ? "Добавление…" : "Добавить аппарат"}</Button> : <Button type="submit" form="fleet-invitation" disabled={pending || !code.trim()}>{pending ? "Проверка БК…" : "Проверить БК"}</Button>}</WindowFooterActions>}>
-      <form id="fleet-invitation" className="fleet-form" onSubmit={inspect} aria-busy={pending}>
-        <Select label="Способ подключения" value="node" options={[{ value: "node", label: "С бортовым компьютером" }]} onChange={() => undefined} disabled={pending} />
-        <Select label="Класс аппарата" value={platform} options={platforms} onChange={setPlatform} disabled={pending} />
-        <TextField label="Название аппарата" value={name} maxLength={80} onChange={event => setName(event.target.value)} disabled={pending} autoComplete="off" />
-        {preview ? <SettingsCard title={preview.name} description="Идентичность БК проверена по приглашению"><dl className="fleet-facts"><div><dt>Идентификатор БК</dt><dd>{preview.node_id}</dd></div><div><dt>Система</dt><dd>{preview.host.os} · {preview.host.architecture}</dd></div><div><dt>Адрес БК</dt><dd>{preview.endpoint}</dd></div></dl><Button disabled={pending} onClick={() => setPreview(null)}>Другое приглашение</Button></SettingsCard> : <TextAreaField label="Код приглашения из Node" value={code} rows={5} maxLength={4096} spellCheck={false} autoComplete="off" disabled={pending} onChange={event => setCode(event.target.value)} />}
-        {error && <p role="alert">{error}</p>}
-      </form>
-    </Window>
-    <ConfirmationModal open={revoking !== null} title="Отозвать привязку БК?" description={`Аппарат «${revoking?.name ?? ""}» останется в реестре, а его БК потеряет доступ к Core. БК получит отзыв при следующем соединении.`} confirmLabel="Отозвать" cancelLabel="Отмена" danger onClose={() => setRevoking(null)} onConfirm={async () => { if (!revoking) return; try { await fleetRequest(`/${encodeURIComponent(revoking.id)}`, "DELETE"); await fleet.refresh(); setRevoking(null); } catch (error) { setError(error instanceof Error ? error.message : "Не удалось отозвать привязку."); throw error; } }} />
-  </div>;
-}
@@ -1,3 +0,0 @@
-.board-monitor { display: grid; gap: var(--nodedc-space-4); min-width: 0; }
-.board-monitor-controls { display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap: var(--nodedc-space-3); align-items: end; margin-bottom: var(--nodedc-space-3); }
-.board-monitor p { font-size: var(--nodedc-font-size-sm); color: var(--nodedc-text-secondary); }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
DCCONSTRUCTIONS	2e44e27967	feat(simulation): auto-build source mesh collision	2026-08-28 13:48:44 +03:00
DCCONSTRUCTIONS	2ccf172319	feat(simulation): add Gaussian UGV runtime pipeline	2026-08-28 11:51:48 +03:00