feat(lab): add lazy E40 evidence review

2026-07-30 21:53:04 +03:00
parent e9bbfb9a41
commit fdcaf57ae7
24 changed files with 3570 additions and 165 deletions
@@ -0,0 +1,174 @@
+import assert from "node:assert/strict";
+import { after, before, test } from "node:test";
+
+import { createServer } from "vite";
+
+let server;
+let parseE40CaseCatalog;
+let parseE40OperatorReview;
+let fetchE40CaseCatalog;
+let saveE40OperatorVerdict;
+let E40CaseReviewContractError;
+
+const resultId = `e40-perception-product-gate-${"a".repeat(64)}`;
+const materializationId = `e30-materialization-${"b".repeat(64)}`;
+const itemId = `e30-review-item-${"c".repeat(64)}`;
+
+function payload(overrides = {}) {
+  return {
+    schema_version: "missioncore.laboratory-e40-case-catalog/v1",
+    result_id: resultId,
+    materialization_id: materializationId,
+    items: [{
+      item_id: itemId,
+      sequence: 3,
+      source_frame_index: 1080,
+      source_stratum: "geometry-only",
+      severity: "high",
+      presence_confidence: 1,
+      prediction_basis: "fixed-stratum-policy",
+      reference: {
+        presence: "object-present",
+        geometry_association: "object-associated",
+        freshness: "current",
+      },
+      prediction: {
+        presence: "occupied-environment",
+        geometry_association: "independent-occupied",
+        freshness: "current",
+      },
+      mismatched_dimensions: ["presence", "geometry_association"],
+      access: "read-only",
+    }],
+    total: 23,
+    truncated: false,
+    access: "read-only",
+    ...overrides,
+  };
+}
+
+function reviewPayload(overrides = {}) {
+  return {
+    schema_version: "missioncore.e40-operator-review/v1",
+    review_id: `e40-operator-review-${"f".repeat(64)}`,
+    protocol: "sealed-error-adjudication/v1",
+    source: {
+      result_id: resultId,
+      materialization_id: materializationId,
+      case_catalog_sha256: "1".repeat(64),
+      item_count: 1,
+      item_set_sha256: "2".repeat(64),
+    },
+    reviewer_id: "DC",
+    revision: 1,
+    decisions: [{
+      item_id: itemId,
+      verdict: "confirmed-error",
+      revision: 1,
+      idempotency_key: "ui-test",
+      decided_at_utc: "2026-07-30T17:00:00.000Z",
+      event_id: `e40-operator-verdict-${"3".repeat(64)}`,
+    }],
+    reviewed_item_count: 1,
+    remaining_item_count: 0,
+    updated_at_utc: "2026-07-30T17:00:00.000Z",
+    access: "review-write",
+    ...overrides,
+  };
+}
+
+before(async () => {
+  server = await createServer({
+    configFile: false,
+    appType: "custom",
+    optimizeDeps: { noDiscovery: true },
+    server: { middlewareMode: true, hmr: false },
+  });
+  ({
+    parseE40CaseCatalog,
+    parseE40OperatorReview,
+    fetchE40CaseCatalog,
+    saveE40OperatorVerdict,
+    E40CaseReviewContractError,
+  } = await server.ssrLoadModule("/src/core/laboratory/e40CaseReview.ts"));
+});
+
+test("E40 operator review preserves the sealed source and verdict", () => {
+  const review = parseE40OperatorReview(reviewPayload());
+
+  assert.equal(review.resultId, resultId);
+  assert.equal(review.materializationId, materializationId);
+  assert.equal(review.caseCatalogSha256, "1".repeat(64));
+  assert.equal(review.reviewedItemCount, 1);
+  assert.equal(review.decisions[0].verdict, "confirmed-error");
+});
+
+after(async () => {
+  await server.close();
+});
+
+test("E40 case catalog preserves the sealed error binding", () => {
+  const catalog = parseE40CaseCatalog(payload());
+
+  assert.equal(catalog.resultId, resultId);
+  assert.equal(catalog.materializationId, materializationId);
+  assert.equal(catalog.items[0].sourceFrameIndex, 1080);
+  assert.equal(catalog.items[0].predictionBasis, "fixed-stratum-policy");
+  assert.deepEqual(
+    catalog.items[0].mismatchedDimensions,
+    ["presence", "geometry_association"],
+  );
+  assert.equal(
+    catalog.items[0].prediction.geometryAssociation,
+    "independent-occupied",
+  );
+});
+
+test("E40 case fetch is bounded and rejects a foreign result", async () => {
+  let requestUrl = "";
+  const fetcher = async (input) => {
+    requestUrl = String(input);
+    return new Response(JSON.stringify(payload({
+      result_id: `e40-perception-product-gate-${"d".repeat(64)}`,
+    })), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  };
+
+  await assert.rejects(
+    fetchE40CaseCatalog(resultId, { fetcher }),
+    E40CaseReviewContractError,
+  );
+  assert.match(requestUrl, /cases\?limit=48$/);
+});
+
+test("E40 operator verdict is committed with revision and idempotency", async () => {
+  let requestUrl = "";
+  let requestInit;
+  const fetcher = async (input, init) => {
+    requestUrl = String(input);
+    requestInit = init;
+    return new Response(JSON.stringify(reviewPayload()), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  };
+
+  const review = await saveE40OperatorVerdict(resultId, itemId, {
+    expectedRevision: 0,
+    idempotencyKey: "ui-test",
+    verdict: "confirmed-error",
+    fetcher,
+  });
+
+  assert.match(requestUrl, /operator-review\/decisions\/e30-review-item-/);
+  assert.equal(requestInit.method, "PUT");
+  assert.deepEqual(JSON.parse(requestInit.body), {
+    reviewer_id: "DC",
+    expected_revision: 0,
+    idempotency_key: "ui-test",
+    verdict: "confirmed-error",
+  });
+  assert.equal(review.revision, 1);
+});