import assert from "node:assert/strict";
import { readFileSync, readdirSync } from "node:fs";
import { after, before, test } from "node:test";
import { createServer } from "vite";

let server;
let decodeM48GateStatus;
let decodeM48ReviewSourceCatalog;
let decodeM48CorrectionSession;
let decodeM48SpatialFrame;
let decodeM48QualityResult;
let decodeM48FailureAtlas;
let decodeM48FailureCase;
let assertM48BlindPayload;
let interpolateM48Extent;
let createM48Tracklet;
let nextM48ObjectId;
let laboratoryMetricLegendEntries;
let nearestLaboratoryRecordedClipFrame;
let laboratoryRecordedClipEndExclusiveNs;
let laboratoryRecordedClipClockGate;
let m48SpatialPlaybackWindow;
let trimM48SpatialPlaybackCache;
let nextM48CameraVisibility;
let nextM48SpatialMode;

const packId = `m48-object-quality-pack-${"a".repeat(64)}`;

before(async () => {
  server = await createServer({ appType: "custom", logLevel: "silent", server: { middlewareMode: true } });
  ({
    decodeM48GateStatus,
    decodeM48ReviewSourceCatalog,
    decodeM48CorrectionSession,
    decodeM48SpatialFrame,
    decodeM48QualityResult,
    decodeM48FailureAtlas,
    decodeM48FailureCase,
    assertM48BlindPayload,
  } = await server.ssrLoadModule("/src/core/laboratory/m48ObjectCentricQuality.ts"));
  ({
    interpolateM48Extent,
    createM48Tracklet,
    nextM48ObjectId,
  } = await server.ssrLoadModule("/src/workspaces/laboratory/annotation/M48BlindClipPlayer.tsx"));
  ({
    nearestLaboratoryRecordedClipFrame,
    laboratoryRecordedClipEndExclusiveNs,
    laboratoryRecordedClipClockGate,
  } = await server.ssrLoadModule(
    "/src/components/laboratory/LaboratoryRecordedClipPlayer.tsx",
  ));
  ({ laboratoryMetricLegendEntries } = await server.ssrLoadModule(
    "/src/components/laboratory/LaboratoryMetricEvidenceScene.tsx",
  ));
  ({
    m48SpatialPlaybackWindow,
    trimM48SpatialPlaybackCache,
  } = await server.ssrLoadModule(
    "/src/workspaces/laboratory/annotation/useM48SpatialClipPlayback.ts",
  ));
  ({
    nextM48CameraVisibility,
    nextM48SpatialMode,
  } = await server.ssrLoadModule(
    "/src/workspaces/laboratory/annotation/M48EvidenceModeControls.tsx",
  ));
});

after(async () => server?.close());

function authority() {
  return {
    mode: "replay-simulated",
    physical_live: false,
    commands_enabled: false,
    actuation_allowed: false,
    navigation_or_safety_accepted: false,
  };
}

function source() {
  const clips = Array.from({ length: 20 }, (_, index) => {
    const start = index * 2 + 1;
    return {
      clip_id: `clip-${String(index + 1).padStart(2, "0")}`,
      start_sequence: start,
      end_sequence: start + 1,
      frames: [start, start + 1].map((sequence) => ({
        sequence,
        source_time_ns: (sequence - 1) * 100_000_000,
        camera_fragment_sha256: String(index % 10).repeat(64),
        camera_url: `/api/v1/laboratory/m48/packs/${packId}/source/clips/clip-${String(index + 1).padStart(2, "0")}/frames/${sequence}/camera`,
        spatial_url: `/api/v1/laboratory/m48/packs/${packId}/source/clips/clip-${String(index + 1).padStart(2, "0")}/frames/${sequence}/spatial`,
      })),
    };
  });
  return {
    schema_version: "missioncore.m48-neutral-object-review-source/v2",
    pack_id: packId,
    state: "prediction-blind-neutral-source-projection",
    contract: {
      contract_id: "m48-class-free-object-tracklet/v1",
      label_unit: "clip-local-object-tracklet",
      semantic_classes_allowed: false,
      extent: "normalized-xyxy-sparse-keyframes",
      extent_interpolation: "linear-between-bounding-keyframes",
      visibility: ["occluded", "partial", "visible"],
      state_segments: {
        coverage: "contiguous-full-tracklet-lifetime",
        geometry_association: ["associated", "ineligible", "unavailable", "unknown"],
        freshness: ["current", "held", "stale", "unavailable"],
        motion: ["moving", "static", "unknown", "unsupported"],
        threat: ["not-threat", "threat", "unknown"],
        critical_corridor_obstacle: "boolean",
      },
    },
    camera_playback: {
      schema_version: "missioncore.laboratory-recorded-clip-camera/v1",
      source_id: "recorded.camera.test",
      label: "Записанная RIGHT камера",
      manifest_url: "/api/v1/observation-sessions/recorded-session/media/recorded-video-test/manifest",
      manifest_generation_sha256: "f".repeat(64),
      byte_length: 123456,
      media_type: "video/mp4",
      timeline_start_seconds: 0,
      timeline_end_seconds: 4,
      segment_count: 40,
      seekable: true,
      synchronization: "host-arrival-best-effort",
      transport: "recorded-fmp4-manifest",
      fragment_binding: "pack-frozen-sha256-verified",
    },
    clips,
    clip_count: clips.length,
    frame_count: 40,
    strata_included: false,
    split_included: false,
    candidate_identity_included: false,
    frozen_predictions_included: false,
    model_scores_included: false,
    semantic_class_task_included: false,
    evidence_capabilities: {
      state: "prediction-free-spatial-evidence-available",
      camera_epoch_time: true,
      current_point_cloud_body_xyz_m: true,
      rig: true,
      virtual_corridor: true,
      raw_lidar: false,
      graph_output: false,
      graph_boxes_ids_scores: false,
      label_authority: {
        obstacle_presence_and_extent: true,
        geometry_association: true,
        freshness: true,
        motion: true,
        threat: true,
        critical_corridor_obstacle: true,
      },
      fail_closed_reason: null,
    },
    access: "prediction-free-strata-free-source-read-only",
  };
}

test("M4.8 pack status stays fail-closed and command-free", () => {
  const result = decodeM48GateStatus({
    schema_version: "missioncore.m48-object-quality-pack-status/v1",
    pack_id: packId,
    created_at_utc: "2026-08-24T10:00:00Z",
    state: "prepared",
    metrics: { clip_count: 20, frame_count: 1020, seed_object_count: 5236, correction_state: "not-started", correction_reviewed_clip_count: 0, correction_complete: false, review_slot_count: 0, frozen_reviewer_count: 0, required_frozen_reviewer_count: 2 },
    decision: { review_collection_ready: true, two_distinct_reviews_frozen: false, adjudication_unlocked: false, adjudication_frozen: false, evaluated: false, next_action: "freeze two reviews" },
    truth_seal_id: null,
    quality_result_id: null,
    blindness: { candidate_identity_included: false, frozen_predictions_included: false, model_scores_included: false, semantic_class_task_included: false, strata_included: false },
    authority: authority(),
    access: "neutral-workflow-status-read-only",
  });
  assert.equal(result.packId, packId);
  assert.equal(result.authority.commandsEnabled, false);
  assert.equal(result.correctionState, "not-started");
  assert.equal(result.seedObjectCount, 5236);
  assert.equal(result.requiredFrozenReviewerCount, 2);
});

test("blind source admits fragment identity and structurally rejects candidate material", () => {
  const result = decodeM48ReviewSourceCatalog(source());
  assert.equal(result.clips.length, 20);
  assert.equal(result.cameraPlayback.segmentCount, 40);
  assert.equal(result.cameraPlayback.manifestGenerationSha256, "f".repeat(64));
  assert.equal(result.clips[0].frames[0].cameraFragmentSha256.length, 64);
  assert.equal(result.evidenceCapabilities.currentPointCloudBodyXyzM, true);

  for (const leak of [
    { predictions: [] },
    { strata: ["no-object"] },
    { model: { id: "candidate" } },
    { graph: [] },
    { split: "validation" },
    { semantic_class: "car" },
  ]) assert.throws(() => assertM48BlindPayload(leak), /blind|candidate|stratum/i);

  const staleName = source();
  staleName.clips[0].frames[0].camera_frame_sha256 = staleName.clips[0].frames[0].camera_fragment_sha256;
  delete staleName.clips[0].frames[0].camera_fragment_sha256;
  assert.throws(() => decodeM48ReviewSourceCatalog(staleName), /состав полей/);
});

test("candidate-assisted correction admits frozen boxes without claiming independent truth", () => {
  const candidate = {
    schema_version: "missioncore.m48-assisted-object-correction-session/v1",
    pack_id: packId,
    session_id: `m48-correction-session-${"b".repeat(64)}`,
    title: "Worker 006 correction",
    revision: 0,
    state: "draft",
    created_at_utc: "2026-08-24T12:00:00Z",
    updated_at_utc: "2026-08-24T12:00:00Z",
    clips: [{
      clip_id: "clip-01",
      start_sequence: 1,
      end_sequence: 2,
      review_state: "pending",
      no_object: null,
      tracklets: [{
        object_id: "proposal-0-0",
        first_sequence: 1,
        last_sequence: 1,
        keyframes: [{ sequence: 1, extent_xyxy: [0.1, 0.2, 0.3, 0.4], visibility: "visible" }],
        state_segments: [{ start_sequence: 1, end_sequence: 1, geometry_association: "associated", freshness: "current", motion: "unknown", threat: "unknown", critical_corridor_obstacle: false }],
        notes: null,
      }],
      notes: null,
    }],
    progress: { reviewed_clip_count: 0, clip_count: 1, complete: false },
    seed_summary: { worker_id: "006", clip_count: 1, frame_count: 2, object_count: 1, prediction_rows_sha256: "c".repeat(64) },
    evidence_summary: null,
    reviewer_id: null,
    submitted_at_utc: null,
    submission_sha256: null,
    assistance: { mode: "frozen-candidate-seeded", candidate_predictions_seen: true, model_scores_seen: false, semantic_class_task_seen: false, independent_truth_eligible: false },
    authority: authority(),
    access: "capability-protected-candidate-assisted-correction",
  };
  const decoded = decodeM48CorrectionSession(candidate);
  assert.equal(decoded.seedWorkerId, "006");
  assert.equal(decoded.seedObjectCount, 1);
  assert.equal(decoded.clips[0].tracklets[0].objectId, "proposal-0-0");

  candidate.assistance.independent_truth_eligible = true;
  assert.throws(() => decodeM48CorrectionSession(candidate), /assistance|truth/i);
});

test("spatial frame accepts only current points, virtual rig and corridor", () => {
  const result = decodeM48SpatialFrame({
    schema_version: "missioncore.m48-neutral-object-review-spatial-frame/v1",
    pack_id: packId,
    clip_id: "clip-01",
    sequence: 1,
    source_time_ns: 0,
    point_cloud_body_xyz_m: [[1, 0, 0.25]],
    rig: { profile_id: "virtual-rig", length_m: 1, width_m: 0.6, lidar_reference: "rear", nominal_sensor_height_m: 1.25, physical_mount_claimed: false },
    corridor: { profile_id: "corridor", forward_length_m: 8, rear_margin_m: 0.2, lateral_clearance_m: 0.25, half_width_m: 0.55, prediction_horizon_seconds: 5 },
    occupied_voxel_size_m: 0.2,
    source_available: true,
    body_frame_available: true,
    candidate_identity_included: false,
    graph_boxes_ids_scores_included: false,
    frozen_predictions_included: false,
    strata_included: false,
    authority: authority(),
    access: "prediction-free-current-spatial-evidence-read-only",
  });
  assert.deepEqual(result.pointCloudBodyXyzM, [[1, 0, 0.25]]);
  assert.equal(result.sourceAvailable, true);
  assert.equal(result.bodyFrameAvailable, true);
  assert.equal(result.corridor.forwardLengthM, 8);

  const unavailable = {
    schema_version: "missioncore.m48-neutral-object-review-spatial-frame/v1",
    pack_id: packId,
    clip_id: "clip-01",
    sequence: 1,
    source_time_ns: 0,
    point_cloud_body_xyz_m: [[1, 0, 0.25]],
    rig: { profile_id: "virtual-rig", length_m: 1, width_m: 0.6, lidar_reference: "rear", nominal_sensor_height_m: 1.25, physical_mount_claimed: false },
    corridor: { profile_id: "corridor", forward_length_m: 8, rear_margin_m: 0.2, lateral_clearance_m: 0.25, half_width_m: 0.55, prediction_horizon_seconds: 5 },
    occupied_voxel_size_m: 0.2,
    source_available: true,
    body_frame_available: false,
    candidate_identity_included: false,
    graph_boxes_ids_scores_included: false,
    frozen_predictions_included: false,
    strata_included: false,
    authority: authority(),
    access: "prediction-free-current-spatial-evidence-read-only",
  };
  assert.throws(() => decodeM48SpatialFrame(unavailable), /unavailable spatial frame/);
});

test("tracklet extents interpolate on the shared clip timeline", () => {
  const tracklet = {
    objectId: "object-01",
    firstSequence: 10,
    lastSequence: 20,
    keyframes: [
      { sequence: 10, extentXyxy: [0.1, 0.2, 0.3, 0.4], visibility: "visible" },
      { sequence: 20, extentXyxy: [0.2, 0.3, 0.4, 0.5], visibility: "visible" },
    ],
    stateSegments: [],
    notes: null,
  };
  const midpoint = interpolateM48Extent(tracklet, 15);
  assert.ok(midpoint.every((value, index) => Math.abs(value - [0.15, 0.25, 0.35, 0.45][index]) < 1e-12));
  assert.equal(interpolateM48Extent(tracklet, 9), null);
});

test("manual correction is frame-local, fails closed without spatial authority and never reuses a deleted id", () => {
  const clip = decodeM48ReviewSourceCatalog(source()).clips[0];
  const tracklet = createM48Tracklet("object-01", clip, [0.1, 0.2, 0.3, 0.4], false, clip.endSequence);
  assert.equal(tracklet.firstSequence, clip.endSequence);
  assert.equal(tracklet.lastSequence, clip.endSequence);
  assert.equal(tracklet.stateSegments[0].startSequence, clip.endSequence);
  assert.equal(tracklet.stateSegments[0].endSequence, clip.endSequence);
  assert.equal(interpolateM48Extent(tracklet, clip.startSequence), null);
  assert.deepEqual(interpolateM48Extent(tracklet, clip.endSequence), [0.1, 0.2, 0.3, 0.4]);
  assert.equal(tracklet.stateSegments[0].geometryAssociation, "unavailable");
  assert.equal(tracklet.stateSegments[0].motion, "unsupported");
  assert.equal(nextM48ObjectId([
    tracklet,
    { ...tracklet, objectId: "object-03" },
  ]), "object-02");
});

test("shared recorded clip clock selects exact frames and one stable loop boundary", () => {
  const frames = [
    { sequence: 11, sourceTimeNs: 1_000_000_000 },
    { sequence: 12, sourceTimeNs: 1_100_000_000 },
    { sequence: 13, sourceTimeNs: 1_200_000_000 },
  ];
  assert.equal(nearestLaboratoryRecordedClipFrame(frames, 1_049_000_000).sequence, 11);
  assert.equal(nearestLaboratoryRecordedClipFrame(frames, 1_051_000_000).sequence, 12);
  assert.equal(laboratoryRecordedClipEndExclusiveNs(frames), 1_300_000_000);
});

test("shared recorded clip rejects stale media callbacks until an explicit seek lands", () => {
  assert.deepEqual(laboratoryRecordedClipClockGate(1, 123), {
    accept: false,
    pendingSequence: 1,
  });
  assert.deepEqual(laboratoryRecordedClipClockGate(1, 1), {
    accept: true,
    pendingSequence: null,
  });
  assert.deepEqual(laboratoryRecordedClipClockGate(null, 124), {
    accept: true,
    pendingSequence: null,
  });
});

test("M4.8 camera and spatial visibility are independent without an empty viewer", () => {
  assert.equal(nextM48CameraVisibility("camera", true), true);
  assert.equal(nextM48CameraVisibility("3d", true), false);
  assert.equal(nextM48CameraVisibility("3d", false), true);
  assert.equal(nextM48SpatialMode("camera", true, "3d"), "3d");
  assert.equal(nextM48SpatialMode("3d", true, "3d"), "camera");
  assert.equal(nextM48SpatialMode("3d", false, "3d"), "3d");
  assert.equal(nextM48SpatialMode("3d", false, "plan"), "plan");
});

test("M4.8 spatial playback prefetches across the loop and remains bounded", () => {
  const frames = [11, 12, 13, 14, 15].map((sequence) => ({ sequence }));
  assert.deepEqual(m48SpatialPlaybackWindow(frames, 14, 4), [14, 15, 11, 12]);

  const cache = new Map(Array.from({ length: 30 }, (_, index) => [index + 1, index]));
  trimM48SpatialPlaybackCache(cache, [28, 29, 30, 1], 24);
  assert.equal(cache.size, 24);
  for (const sequence of [28, 29, 30, 1]) assert.equal(cache.has(sequence), true);
});

test("post-seal result and atlas reveal bounded graph material only after evaluation", () => {
  const resultId = `m48-object-quality-result-${"b".repeat(64)}`;
  const truthId = `m48-object-truth-seal-${"c".repeat(64)}`;
  const metricNames = [
    "terminal_outcome_accounting",
    "false_free_space_claims",
    "obstacle_presence_precision",
    "obstacle_presence_recall",
    "critical_corridor_obstacle_recall",
    "geometry_association_correctness",
    "freshness_correctness",
    "motion_decision_correctness",
    "critical_threat_not_threat",
    "unknown_prediction_count",
    "failure_case_count",
  ];
  const metrics = Object.fromEntries(metricNames.map((name) => [name, name.endsWith("_count") || name === "false_free_space_claims" ? 0 : 1]));
  const quality = decodeM48QualityResult({
    schema_version: "missioncore.m48-object-centric-quality-result-view/v1",
    result_id: resultId,
    pack_id: packId,
    truth_seal_id: truthId,
    created_at_utc: "2026-08-24T12:00:00Z",
    status: "accepted-object-centric-source-quality",
    accepted: true,
    metrics,
    gates: { obstacle_presence_precision: true },
    unknown_causes: {},
    prediction_material_release: "post-adjudication-seal-evaluation-only",
    authority: authority(),
    ground_truth: false,
    access: "evaluated-object-quality-summary-read-only",
  });
  assert.equal(quality.accepted, true);

  const caseId = `m48-failure-${"d".repeat(64)}`;
  const atlas = decodeM48FailureAtlas({
    schema_version: "missioncore.m48-object-quality-failure-atlas-view/v1",
    result_id: resultId,
    cases: [{ schema_version: "missioncore.m48-object-quality-failure/v1", failure_case_id: caseId, clip_id: "clip-01", split: "validation", sequence: 1, causes: ["presence-false-negative"], severity: "high", terminal_outcome: "delivered", unmatched_prediction_ids: [], unmatched_truth_object_ids: ["object-01"] }],
    case_count: 1,
    prediction_material_release: "post-adjudication-seal-evaluation-only",
    authority: authority(),
    access: "evaluated-bounded-failure-atlas-read-only",
  });
  assert.equal(atlas[0].caseId, caseId);
  assert.equal(atlas[0].split, "validation");

  const failure = decodeM48FailureCase({
    schema_version: "missioncore.m48-object-quality-failure-case-view/v1",
    result_id: resultId,
    case: { failure_case_id: caseId, clip_id: "clip-01", split: "validation", sequence: 1, causes: ["presence-false-negative"], severity: "high" },
    frame: { sequence: 1, source_time_ns: 0, camera_fragment_sha256: "e".repeat(64), camera_url: `/api/v1/laboratory/m48/packs/${packId}/source/clips/clip-01/frames/1/camera`, spatial_url: null },
    truth: [{ object_id: "object-01", extent_xyxy: [0.1, 0.1, 0.3, 0.4], geometry_association: "associated", freshness: "current", motion: "static", threat: "threat" }],
    graph: [],
    prediction_material_release: "post-adjudication-seal-evaluation-only",
    authority: authority(),
    access: "evaluated-failure-case-read-only",
  });
  assert.equal(failure.truth[0].objectId, "object-01");
  assert.equal(failure.frame.cameraFragmentSha256, "e".repeat(64));
});

test("M4.8 evidence keeps the shared viewer stage stretched over the visual frame", () => {
  const stylesheet = readFileSync(
    new URL("../src/styles/laboratory-recorded-clip-player.css", import.meta.url),
    "utf8",
  );
  const player = readFileSync(
    new URL("../src/workspaces/laboratory/annotation/M48BlindClipPlayer.tsx", import.meta.url),
    "utf8",
  );
  const shared = readFileSync(
    new URL("../src/components/laboratory/LaboratoryRecordedClipPlayer.tsx", import.meta.url),
    "utf8",
  );
  const visual = readFileSync(
    new URL("../src/workspaces/laboratory/M48FailureAtlasVisual.tsx", import.meta.url),
    "utf8",
  );
  const evidenceViewer = readFileSync(
    new URL("../src/components/laboratory/LaboratoryEvidenceViewer.tsx", import.meta.url),
    "utf8",
  );
  const laboratoryStyles = readFileSync(
    new URL("../src/styles/laboratory-evidence-viewer.css", import.meta.url),
    "utf8",
  );
  const modeControls = readFileSync(
    new URL("../src/workspaces/laboratory/annotation/M48EvidenceModeControls.tsx", import.meta.url),
    "utf8",
  );

  assert.match(
    stylesheet,
    /\.laboratory-recorded-clip-player__camera\s*>\s*\.recorded-media-player\s*\{[^}]*position:\s*absolute/s,
  );
  assert.match(player, /<LaboratoryRecordedClipPlayer/);
  assert.doesNotMatch(player, /fetch\(|image\/jpeg|createM48LatestFrameLoader|Следующий camera frame/);
  assert.match(shared, /missioncore\.laboratory-recorded-clip-viewer\/v1/);
  assert.match(shared, /<RecordedFmp4Player/);
  assert.match(shared, /<SplitPane/);
  assert.equal((shared.match(/<RecordedFmp4Player/g) ?? []).length, 1);
  assert.match(shared, /orientation="vertical"/);
  assert.match(shared, /resizable=\{companionVisible\}/);
  assert.match(shared, /separatorLabel="Изменить размер 3D\/ПЛАН и правой камеры"/);
  assert.match(shared, /segmentSequence=\{frame\?\.sequence\}/);
  assert.match(player, /cameraPresentation=\{spatialVisible/);
  assert.match(player, /effectiveCameraVisible \? "companion" : "hidden"/);
  assert.match(player, /cameraVisible: boolean/);
  assert.match(player, /continuousPlayback/);
  assert.doesNotMatch(player, /continuousPlayback=\{mode === "camera"\}/);
  assert.match(visual, /chromeLayout="stacked"/);
  assert.match(visual, /modeControlsVisible=\{false\}/);
  assert.match(visual, /<M48EvidenceModeRail/);
  assert.match(modeControls, /<GlassSurface/);
  assert.match(modeControls, /className="m48-evidence-mode-rail"/);
  assert.match(modeControls, /radius="pill"/);
  assert.match(modeControls, /padding="sm"/);
  assert.match(modeControls, /materialRim=\{false\}/);
  assert.match(modeControls, /<Icon name="video" size=\{16\}/);
  assert.match(modeControls, /<Icon name="plan" size=\{16\}/);
  assert.match(modeControls, />3D<\/span>/);
  assert.doesNotMatch(modeControls, /<SegmentedControl|<Button/);
  assert.doesNotMatch(modeControls, /value: "camera"[\s\S]*value: "3d"/);
  assert.match(evidenceViewer, /chromeLayout\?: "overlay" \| "stacked"/);
  assert.match(evidenceViewer, /laboratory-evidence-viewer__header/);
  assert.match(
    laboratoryStyles,
    /data-chrome-layout="stacked"[\s\S]*?grid-template-rows:\s*auto minmax\(0, 1fr\) auto/,
  );
  assert.match(
    stylesheet,
    /data-chrome-layout="stacked"[\s\S]*?laboratory-recorded-clip-player\s*\{[\s\S]*?gap:\s*0/,
  );
  assert.doesNotMatch(stylesheet, /grid-template-columns:[^;]*31%/);
  assert.doesNotMatch(
    stylesheet,
    /border-(?:left|top):\s*1px solid var\(--nodedc-glass-outline\)/,
  );
  assert.match(
    stylesheet,
    /nodedc-split-pane__separator::before\s*\{[^}]*background:\s*transparent/s,
  );
  assert.match(
    laboratoryStyles,
    /laboratory-evidence-viewer__header\s*\{[^}]*border:\s*0/s,
  );
});

test("LAB workspaces cannot fork the frozen recorded clip transport", () => {
  const root = new URL("../src/workspaces/laboratory/", import.meta.url);
  const sourceFiles = readdirSync(root, { recursive: true })
    .filter((name) => /\.(?:ts|tsx)$/.test(String(name)));
  for (const name of sourceFiles) {
    const sourceText = readFileSync(new URL(String(name), root), "utf8");
    assert.doesNotMatch(
      sourceText,
      /new\s+MediaSource|requestVideoFrameCallback|URL\.createObjectURL|image\/jpeg|setTimeout\s*\(|<RecordedFmp4Player/,
      `${name} forks missioncore.laboratory-recorded-clip-viewer/v1`,
    );
  }
});

test("M4.8 review and adjudication share one focus-owning workspace frame", () => {
  const review = readFileSync(
    new URL("../src/workspaces/laboratory/annotation/M48BlindReviewWorkspace.tsx", import.meta.url),
    "utf8",
  );
  const adjudication = readFileSync(
    new URL("../src/workspaces/laboratory/annotation/M48AdjudicationWorkspace.tsx", import.meta.url),
    "utf8",
  );
  const frame = readFileSync(
    new URL("../src/components/laboratory/LaboratoryReviewWorkspaceFrame.tsx", import.meta.url),
    "utf8",
  );
  const frameStyles = readFileSync(
    new URL("../src/styles/laboratory-review-workspace.css", import.meta.url),
    "utf8",
  );
  const m48Styles = readFileSync(
    new URL("../src/styles/m48-object-centric-quality.css", import.meta.url),
    "utf8",
  );
  const recordedStyles = readFileSync(
    new URL("../src/styles/laboratory-recorded-clip-player.css", import.meta.url),
    "utf8",
  );

  for (const workspace of [review, adjudication]) {
    assert.match(workspace, /LaboratoryReviewWorkspaceFrame/);
    assert.doesNotMatch(workspace, /createPortal|className="m48-review-workspace"/);
    assert.doesNotMatch(
      workspace,
      /@rerun-io|RerunViewer|Blueprint|view_id|blueprint_id/,
      "M4.8 must reuse shared viewers instead of defining a per-LAB Rerun layout",
    );
  }
  assert.match(frame, /document\.body\.style\.overflow = "hidden"/);
  assert.match(frame, /event\.key === "Escape"/);
  assert.match(frame, /keepFocusInside/);
  assert.match(frame, /returnFocusTarget\?\.isConnected/);
  assert.match(frame, /requestAnimationFrame\(\(\) => target\?\.focus\(\)\)/);

  const player = readFileSync(
    new URL("../src/workspaces/laboratory/annotation/M48BlindClipPlayer.tsx", import.meta.url),
    "utf8",
  );
  assert.match(player, /spatialFrame\.bodyFrameAvailable/);
  assert.match(player, /LiDAR в системе координат корпуса для этого кадра недоступен/);
  assert.match(player, /Number\(effectiveCameraVisible\) \+ Number\(spatialVisible\)/);
  assert.match(player, /data-spatial-sequence=\{spatialReady \? sequence : undefined\}/);
  assert.match(review, /<M48EvidenceModeRail/);
  assert.match(adjudication, /<M48EvidenceModeRail/);
  assert.match(review, /<FieldFrame label="Выбор клипа"/);
  assert.match(review, /label="Предыдущий клип"/);
  assert.match(review, /label="Следующий клип"/);
  assert.match(review, /<IconButton\s+label="Добавить объект"/);
  assert.doesNotMatch(review, />\s*Добавить объект\s*<\/Button>/);
  assert.ok(review.indexOf('label="Предыдущий клип"') < review.indexOf('<FieldFrame label="Выбор клипа"'));
  assert.ok(review.indexOf('className="m48-review-workspace__clip-reviewed"') < review.indexOf('className="m48-review-workspace__topbar-end"'));
  assert.doesNotMatch(review, /m48-review-workspace__topbar-center/);
  assert.ok(review.indexOf('label="Добавить объект"') < review.indexOf('label="Закрыть проверку M4.8"'));
  assert.doesNotMatch(review, /label="Сохранить всю проверку"/);
  assert.match(review, /void save\(nextDrafts, "clip-status", \{ drafts, dirty \}\)/);
  assert.match(review, /title: reason === "clip-status" \? "Статус клипа сохранён"/);
  assert.match(review, /setDrafts\(rollback\.drafts\);\s*setDirty\(rollback\.dirty\);/);
  assert.match(review, /className="m48-review-workspace__stage-shell"/);
  assert.match(review, /className="m48-review-workspace__source-sticker"/);
  assert.match(review, /materialRim=\{false\}/);
  assert.match(review, /label="Добавить ещё один объект"/);
  assert.match(review, /label="Сохранить изменения объекта"/);
  assert.match(review, /<FieldFrame label="Проезд"/);
  assert.match(review, /label="Объезд или запас"/);
  assert.match(review, /<FieldFrame label="Непосредственная опасность"/);
  assert.match(review, /label="Закрыть редактор объекта"/);
  assert.doesNotMatch(review, /className="m48-review-workspace__(?:reviewbar|review-actions|source-state)"/);
  assert.doesNotMatch(review, />\s*Сохранить изменения\s*<\/Button>/);
  assert.doesNotMatch(review, /Выбранный объект|Рамка здесь|Начало здесь|Конец здесь|trimM48Tracklet|рамка переносится по клипу/);
  assert.match(review, /sequence < selectedTracklet\.firstSequence \|\| sequence > selectedTracklet\.lastSequence/);
  assert.match(player, /interactionMoved\([\s\S]*?boxInteraction\.startClient,[\s\S]*?event\.clientX/);
  assert.match(player, /extentsDiffer\(boxInteraction\.originalExtent, extent\)/);
  assert.match(player, /firstSequence: sequence/);
  assert.match(player, /lastSequence: sequence/);
  assert.doesNotMatch(review, /inspector=\{/);
  assert.match(frame, /\{inspector \? <footer/);
  assert.doesNotMatch(frameStyles, /border-(?:top|bottom):/);
  assert.match(m48Styles, /\.m48-clip-player__pane-label\s*\{[^}]*border:\s*0/s);
  assert.match(m48Styles, /\.m48-review-workspace__object-tools\s*\{[^}]*justify-content:\s*flex-start/s);
  assert.match(m48Styles, /\.m48-review-workspace__topbar\s*\{[^}]*display:\s*grid[^}]*grid-template-columns:\s*minmax\(0, 1fr\) auto/s);
  assert.match(m48Styles, /\.m48-evidence-mode-rail\s*\{[^}]*position:\s*absolute[^}]*left:\s*var\(--nodedc-space-4\)[^}]*translateY\(-50%\)/s);
  assert.match(m48Styles, /\.m48-evidence-mode-controls\s*\{[^}]*flex-direction:\s*column[^}]*gap:\s*var\(--nodedc-space-2\)/s);
  assert.match(m48Styles, /\.m48-evidence-mode-controls__text\s*\{[^}]*font-size:\s*var\(--nodedc-font-size-xs\)/s);
  assert.match(m48Styles, /\.m48-review-workspace__clip-field\s*\{[^}]*19vw/s);
  assert.match(m48Styles, /\.m48-review-workspace__clip-reviewed\s*\{[^}]*16vw/s);
  assert.match(m48Styles, /\.m48-review-workspace__passage-field\s*\{[^}]*18vw/s);
  assert.match(m48Styles, /\.m48-review-workspace__source-sticker\s*\{[^}]*position:\s*absolute[^}]*pointer-events:\s*none/s);
  assert.match(
    recordedStyles,
    /\.laboratory-recorded-clip-player__timeline\.observation-timeline\s*\{[^}]*border:\s*0/s,
  );
  assert.match(
    recordedStyles,
    /grid-template-columns:\s*auto auto auto minmax\(12rem, 1fr\) auto/,
  );
});

test("spatial legend exposes only layers present in the current evidence contract", () => {
  const sourceOnly = laboratoryMetricLegendEntries({
    pointCloudCount: 128,
    localSurfaceCount: 0,
    obstacles: [],
    showCurrentIncrement: true,
    showLocalSurface: false,
    showRollingMap: false,
  });
  assert.deepEqual(sourceOnly, [{ id: "context", label: "Текущий кадр" }]);

  const threat = laboratoryMetricLegendEntries({
    pointCloudCount: 128,
    localSurfaceCount: 64,
    obstacles: [{
      id: "obstacle-1",
      decision: "threat",
      state: "retained",
      centroidBodyXyzM: [1, 0, 0],
      cellCentersBodyXyzM: [[1, 0, 0]],
    }],
    showCurrentIncrement: true,
    showLocalSurface: true,
    showRollingMap: true,
  });
  assert.deepEqual(threat.map(({ id }) => id), [
    "threat",
    "context",
    "local-surface",
    "rolling",
  ]);
});

test("M4.8 full-screen workflow suspends the background evidence owner", () => {
  const capability = readFileSync(
    new URL("../src/workspaces/laboratory/annotation/useM48ReviewCapability.tsx", import.meta.url),
    "utf8",
  );
  const archive = readFileSync(
    new URL("../src/workspaces/laboratory/LaboratoryArchiveWorkspace.tsx", import.meta.url),
    "utf8",
  );

  assert.match(capability, /\{ workspace: ReactNode; active: boolean \}/);
  assert.match(archive, /!m48Review\.active \? <div className="laboratory-work-output">/);
  assert.match(archive, /\{m48Review\.workspace\}/);
});

test("metric evidence keeps one WebGL renderer while frame labels advance", () => {
  const source = readFileSync(
    new URL("../src/components/laboratory/LaboratoryMetricEvidenceScene.tsx", import.meta.url),
    "utf8",
  );

  assert.doesNotMatch(source, /renderer\.domElement\.setAttribute\("aria-label", label\)/);
  assert.match(source, /renderer\.dispose\(\);[\s\S]{0,600}?\}, \[\]\);/);
  assert.match(
    source,
    /querySelector\("canvas"\)[\s\S]*?setAttribute\("aria-label", label\)[\s\S]*?\}, \[label\]\);/,
  );
});

test("metric evidence renders on demand while preserving damped camera interaction", () => {
  const source = readFileSync(
    new URL("../src/components/laboratory/LaboratoryMetricEvidenceScene.tsx", import.meta.url),
    "utf8",
  );

  assert.match(source, /const requestRenderRef = useRef/);
  assert.match(source, /controls\.addEventListener\("change", requestRender\)/);
  assert.match(source, /requestRenderRef\.current\(\)/);
  assert.doesNotMatch(
    source,
    /const render = \(\) => \{\s*animationFrame = window\.requestAnimationFrame\(render\)/,
  );
});