NODEDC_MISSION_CORE/apps/control-station/test/e46gRectifiedDetectorBakeoff.test.mjs

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

let server;
let fetchE46GRectifiedDetectorBakeoff;

before(async () => {
  server = await createServer({
    server: { middlewareMode: true },
    appType: "custom",
    logLevel: "silent",
  });
  ({ fetchE46GRectifiedDetectorBakeoff } = await server.ssrLoadModule(
    "/src/core/laboratory/e46gRectifiedDetectorBakeoff.ts",
  ));
});

after(async () => {
  await server?.close();
});

function viewMetrics(overrides = {}) {
  return {
    frame_count: 600,
    detection_observation_count: 1200,
    track_observation_count: 1300,
    unique_track_count: 40,
    mean_tracked_objects_per_frame: 2.166667,
    zero_detection_frame_count: 4,
    zero_track_frame_count: 2,
    full_layer_blackout_event_count: 1,
    short_track_fraction: 0.1,
    large_track_observation_count: 3,
    large_track_fraction: 0.002308,
    ...overrides,
  };
}

function candidateMetrics(front) {
  return {
    source_frame_count: 600,
    view_frame_count: 1800,
    detection_observation_count: 3000,
    track_observation_count: 3500,
    unique_track_count: 80,
    large_track_observation_count: 400,
    large_track_fraction: 0.114286,
    views: {
      left: viewMetrics({ large_track_observation_count: 200 }),
      front,
      right: viewMetrics({ large_track_observation_count: 197 }),
    },
  };
}

test("E46G selects TrafficCamNet FRONT without granting perception authority", async () => {
  const resultId = `e46g-rectified-detector-bakeoff-${"a".repeat(64)}`;
  const identity = "b".repeat(64);
  const video = (candidate) => ({
    url: `/api/v1/laboratory/e46g/results/${resultId}/${candidate}.mp4`,
    media_type: "video/mp4",
    byte_length: 42_000_000,
    sha256: identity,
    width: 2880,
    height: 544,
    duration_seconds: 60,
    view_order: ["left", "front", "right"],
  });
  const fetcher = async () => new Response(JSON.stringify({
    schema_version: "missioncore.e46g-rectified-detector-bakeoff-catalog/v1",
    items: [{
      schema_version: "missioncore.e46g-rectified-detector-bakeoff-view/v1",
      result_id: resultId,
      created_at_utc: "2026-08-04T13:28:23.707Z",
      source_session_id: "20260720T065719Z_viewer_live",
      camera_source_id: "sensor.camera.right",
      status: "selected-for-next-diagnostic-full-route",
      selection: {
        first_source_frame_index: 1000,
        last_source_frame_index: 1599,
        frame_count: 600,
      },
      rectification: {
        provider: "NVIDIA Gst-nvdewarper",
        provider_version: "DeepStream 9.1",
        output_resolution: [960, 544],
        horizontal_fov_degrees: 100,
        retained_source_frame_index_range: [0, 4487],
        excluded_source_tail_frame_count: 1,
        view_order: ["left", "front", "right"],
      },
      metrics: {
        trafficcamnet: candidateMetrics(viewMetrics({
          track_observation_count: 4034,
          zero_track_frame_count: 0,
        })),
        dashcamnet: candidateMetrics(viewMetrics({
          track_observation_count: 1436,
          zero_track_frame_count: 34,
        })),
      },
      acceptance: {
        exact_recorded_right_source_bound: true,
        factory_calibration_bound: true,
        official_nvidia_dewarper_executed: true,
        stock_detector_tracker_executed: true,
        same_views_and_frames_for_both_candidates: true,
        visual_comparison_videos_available: true,
        independent_truth_available: false,
        candidate_accepted: false,
        navigation_or_safety_accepted: false,
      },
      method: {
        schema_version: "missioncore.laboratory-method/v1",
        completeness: "complete",
        execution_class: "hybrid",
        pipeline_id: "e46g-k1-right-kb4-nvdewarper-ready-detector-bakeoff/v1",
        components: [{
          kind: "tool",
          name: "XGRIDS K1 factory camera_1 KB4",
          version: "KB4",
          role: "fisheye source geometry",
          identity_sha256: identity,
        }],
      },
      limitations: ["not independent truth"],
      comparison: {
        visual_review: {
          status: "selected-for-next-diagnostic",
          reviewed_video_seconds: [0, 10, 20, 30, 40, 50],
          selected_candidate: "trafficcamnet",
          selected_view: "front",
          excluded_views: ["left", "right"],
          finding: "TrafficCamNet keeps more visible vehicles and people.",
          risk: "Duplicate boxes remain and side views contain the camera mount.",
          next_action: "Run complete FRONT replay.",
        },
        verdict: "select-trafficcamnet-front-only-for-e46h",
      },
      videos: {
        trafficcamnet: video("trafficcamnet"),
        dashcamnet: video("dashcamnet"),
      },
      ground_truth: false,
      authority: {
        ground_truth: false,
        independent_truth: false,
        metric_grade_reference: false,
        candidate_accepted: false,
        free_space_authority: false,
        commands_enabled: false,
        navigation_or_safety_accepted: false,
      },
    }],
  }), { status: 200, headers: { "Content-Type": "application/json" } });

  const result = await fetchE46GRectifiedDetectorBakeoff({ fetcher });
  assert.equal(result.comparison.visualReview.selectedCandidate, "trafficcamnet");
  assert.equal(result.comparison.visualReview.selectedView, "front");
  assert.deepEqual(result.comparison.visualReview.excludedViews, ["left", "right"]);
  assert.equal(result.metrics.trafficcamnet.views.front.zeroTrackFrameCount, 0);
  assert.equal(result.metrics.dashcamnet.views.front.zeroTrackFrameCount, 34);
  assert.equal(result.acceptance.candidateAccepted, false);
  assert.doesNotMatch(JSON.stringify(result), /Users|D:\\|runtime\/experiments/);
});

test("E46G uses the fixed LAB anatomy and switches immutable comparison videos", async () => {
  const [resultView, visual] = await Promise.all([
    readFile(new URL("../src/workspaces/laboratory/E46GRectifiedDetectorBakeoffResult.tsx", import.meta.url), "utf8"),
    readFile(new URL("../src/workspaces/laboratory/E46GRectifiedDetectorBakeoffVisual.tsx", import.meta.url), "utf8"),
  ]);
  assert.match(resultView, /LaboratorySummary/);
  assert.match(resultView, /LaboratoryEvidence/);
  assert.match(resultView, /LaboratoryResultSummary/);
  assert.match(resultView, /TrafficCamNet FRONT only/);
  assert.match(visual, /LaboratoryEvidenceViewer/);
  assert.match(visual, /TRAFFICCAMNET/);
  assert.match(visual, /DASHCAMNET/);
  assert.match(visual, /<video/);
});