feat: add multimodal search and granular performance diagnostics

apps/desktop/tests/media-display.test.mjs

@@ -0,0 +1,83 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  timestampLabel,
+  seekSeconds,
+  sourceLabel,
+  matchLabel,
+  PreviewRevision,
+} from "../src/media-display.ts";
+import { LatestLane } from "../src/search-state.ts";
+const settle = () => new Promise((resolve) => setImmediate(resolve));
+
+test("millisecond seeks preserve fractions and readable minute labels", () => {
+  assert.equal(timestampLabel(125450), "2:05");
+  assert.equal(timestampLabel(3600000), "60:00");
+  assert.equal(seekSeconds({ kind: "timestamp_ms", number: 125450 }), 125.45);
+  assert.equal(seekSeconds({ kind: "page", number: 4 }), undefined);
+  assert.equal(seekSeconds({ kind: "timestamp_ms", number: -1 }), undefined);
+  assert.equal(timestampLabel(Infinity), "Unknown time");
+  assert.equal(sourceLabel({ kind: "image", number: 0 }), "Image");
+  assert.equal(matchLabel("semantic_audio"), "Audio meaning");
+  assert.equal(matchLabel("semantic_video"), "Video frame meaning");
+});
+
+test("another timestamp in the same movie invalidates older preparations", () => {
+  const gate = new PreviewRevision();
+  const first = gate.select("movie:1000");
+  assert.equal(gate.select("movie:1000").changed, false);
+  const second = gate.select("movie:3000");
+  assert.equal(gate.accepts(first.revision), false);
+  assert.equal(gate.accepts(second.revision), true);
+  gate.clear();
+  assert.equal(gate.accepts(second.revision), false);
+});
+
+test("one active preview and only latest pending reject stale output", async () => {
+  const gate = new PreviewRevision();
+  const executed = [];
+  const accepted = [];
+  let release;
+  const lane = new LatestLane(
+    async (request) => {
+      executed.push(request.path);
+      if (request.path === "first")
+        await new Promise((resolve) => {
+          release = resolve;
+        });
+      if (gate.accepts(request.revision)) accepted.push(request.path);
+    },
+    (request) => gate.accepts(request.revision),
+    () => assert.fail("Unexpected preview failure"),
+  );
+  lane.submit({ path: "first", revision: gate.select("first").revision });
+  lane.submit({ path: "middle", revision: gate.select("middle").revision });
+  lane.submit({ path: "latest", revision: gate.select("latest").revision });
+  release();
+  await settle();
+  assert.deepEqual(executed, ["first", "latest"]);
+  assert.deepEqual(accepted, ["latest"]);
+});
+
+test("Escape clears queued preparation and rejects active output", async () => {
+  const gate = new PreviewRevision();
+  let release;
+  const accepted = [];
+  const lane = new LatestLane(
+    async (request) => {
+      await new Promise((resolve) => {
+        release = resolve;
+      });
+      if (gate.accepts(request.revision)) accepted.push(request.path);
+    },
+    (request) => gate.accepts(request.revision),
+    () => assert.fail("Unexpected preview failure"),
+  );
+  lane.submit({ path: "one", revision: gate.select("one").revision });
+  lane.submit({ path: "two", revision: gate.select("two").revision });
+  gate.clear();
+  lane.clear();
+  release();
+  await settle();
+  assert.deepEqual(accepted, []);
+});

apps/desktop/tests/search-performance.test.mjs

@@ -0,0 +1,102 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { SearchMeasurement, measuredFailure, spanDepth, briefMs } from '../src/search-performance.ts';
+
+const finish = (trace, lane, start, end, metrics, failed) => trace.completed(trace.begin(lane, start), end, metrics, failed);
+
+const native = { total_ms: 12, result_count: 2, trace: [], dropped_spans: 0 };
+
+test('separates debounce, intentional semantic delay, queue, invoke and DOM update', () => {
+  const trace = new SearchMeasurement(100, 165, true);
+  trace.submitted('lexical', 165);
+  finish(trace, 'lexical', 180, 200, native, false);
+  trace.displayed('lexical', 200, 203, 2);
+  trace.submitted('hybrid', 515);
+  finish(trace, 'hybrid', 520, 550, native, false);
+  trace.displayed('hybrid', 550, 554, 3);
+  const report = trace.export();
+  assert.equal(report.debounce_ms, 65);
+  assert.equal(report.lane_schedule_ms.hybrid, 350);
+  assert.equal(report.attempts[0].queued_ms, 15);
+  assert.equal(report.attempts[0].invoke_ms, 20);
+  assert.equal(report.attempts[0].transport_estimate_ms, 8);
+  assert.equal(report.displays[0].dom_update_ms, 3);
+  assert.equal(report.first_results_ms, 103);
+  assert.equal(report.hybrid_final_results_ms, 454);
+});
+
+test('failed attempt timings survive retry and lexical response does not pretend hybrid completion', () => {
+  const trace = new SearchMeasurement(0, 0, true);
+  trace.submitted('lexical', 0);
+  finish(trace, 'lexical', 0, 2, native, true);
+  finish(trace, 'lexical', 402, 414, native, false);
+  trace.displayed('lexical', 414, 415, 2);
+  const report = trace.export();
+  assert.equal(report.attempts[1].retry_wait_ms, 400);
+  assert.equal(report.attempts[0].failed, true);
+  assert.equal(report.attempts[0].transport_estimate_ms, 0);
+  assert.equal(report.hybrid_final_results_ms, null);
+  assert.equal(report.latest_displayed_ms, 415);
+  assert.equal(measuredFailure({message: 'worker busy', metrics: native}).message, 'worker busy');
+  assert.equal(measuredFailure('legacy failure'), null);
+});
+
+test('debug history is bounded and first response survives dropped displays', () => {
+  const context = { device: 'cpu', threads: 1 };
+  const trace = new SearchMeasurement(0, 0, true, context);
+  context.threads = 8;
+  for (let i = 0; i < 40; i++) {
+    finish(trace, 'hybrid', i, i + 1, native, false);
+    trace.displayed('hybrid', i, i + 1, 1);
+  }
+  const report = trace.export();
+  assert.equal(report.attempts.length, 32);
+  assert.equal(report.displays.length, 16);
+  assert.equal(report.dropped_attempts, 8);
+  assert.equal(report.dropped_displays, 24);
+  assert.equal(report.first_results_ms, 1);
+  assert.equal(report.context.threads, 1);
+  assert.doesNotMatch(JSON.stringify(report), /query|filename|snippet|ended_at/);
+});
+
+test('cyclic or invalid native span parents cannot hang hierarchy rendering', () => {
+  const spans = [{parent: 1}, {parent: 0}, {parent: 99}];
+  assert.equal(spanDepth(spans, 0), 1);
+  assert.equal(spanDepth(spans, 2), 0);
+});
+
+test('a later refresh has queue timing rather than being misreported as a busy retry', () => {
+  const trace = new SearchMeasurement(0, 0, true);
+  trace.submitted('hybrid', 350);
+  finish(trace, 'hybrid', 350, 360, native, false);
+  trace.submitted('hybrid', 1000);
+  finish(trace, 'hybrid', 1010, 1020, native, false);
+  assert.equal(trace.export().attempts[1].queued_ms, 10);
+  assert.equal(trace.export().attempts[1].retry_wait_ms, 0);
+  assert.equal(briefMs(.44), '<1');
+  assert.equal(briefMs(3.14), '3.1');
+});
+
+test('new submission after a failure measures pending queue rather than retry wait', () => {
+  const trace = new SearchMeasurement(0, 0, true);
+  trace.submitted('hybrid', 350);
+  finish(trace, 'hybrid', 350, 360, native, true);
+  trace.submitted('hybrid', 1000);
+  finish(trace, 'hybrid', 1010, 1020, native, false);
+  assert.equal(trace.export().attempts[1].queued_ms, 10);
+  assert.equal(trace.export().attempts[1].retry_wait_ms, 0);
+});
+
+test('an in-flight attempt keeps its captured submission when a refresh queues', () => {
+  const trace = new SearchMeasurement(0, 0, true);
+  trace.submitted('hybrid', 350);
+  const active = trace.begin('hybrid', 355);
+  trace.submitted('hybrid', 1000);
+  trace.completed(active, 1005, native, true);
+  finish(trace, 'hybrid', 1010, 1020, native, false);
+  const attempts = trace.export().attempts;
+  assert.equal(attempts[0].queued_ms, 5);
+  assert.equal(attempts[1].queued_ms, 10);
+  assert.equal(attempts[1].retry_wait_ms, 0);
+  assert.notEqual(attempts[0].submission, attempts[1].submission);
+});