#!/usr/bin/env node
// Public, offline verifier for the frozen July 13, 2026 evidence bundle.
// Usage: node verify-2026-07-13.mjs /path/to/downloaded-evidence
import { createHash } from "node:crypto";
import { readFile } from "node:fs/promises";
import { resolve } from "node:path";

const files = {
  dataset: "dataset-2026-07-13.json",
  result: "result-2026-07-13.json",
  protocol: "protocol-2026-07-13.txt",
  manifest: "reproducibility-2026-07-13.json",
  verifier: "verify-2026-07-13.mjs",
};
const sha256 = (text) => createHash("sha256").update(text, "utf8").digest("hex");
const fail = (message) => { throw new Error(message); };
const expect = (condition, message) => { if (!condition) fail(message); };
const number = (value, name) => expect(typeof value === "number" && Number.isFinite(value), `${name} must be a finite number`);

async function load(dir, name) {
  return readFile(resolve(dir, files[name]), "utf8");
}

async function main() {
  const directory = resolve(process.argv[2] || ".");
  const [datasetText, resultText, protocolText, manifestText, verifierText] = await Promise.all(
    Object.keys(files).map((name) => load(directory, name)),
  );
  const dataset = JSON.parse(datasetText);
  const result = JSON.parse(resultText);
  const manifest = JSON.parse(manifestText);

  expect(manifest.reproductionLevel === "partial", "manifest must not claim full public reproducibility");
  expect(manifest.historicalSourceRepository?.availability === "private_at_publication", "manifest must disclose private historical source");
  expect(manifest.rawPerRequestEvidence?.availability === "private", "manifest must disclose private raw evidence");
  expect(manifest.nonCustomerBoundary?.affiliation === "none", "manifest must state the non-affiliation boundary");
  expect(protocolText.includes("Public-verification boundary"), "protocol is missing its public-verification boundary");

  for (const [name, expected] of Object.entries(manifest.artifacts || {})) {
    expect(files[name], `manifest references unknown artifact: ${name}`);
    expect(expected.path === files[name], `${name} manifest path differs from the downloaded evidence filename`);
    expect(typeof expected.sha256 === "string" && /^[a-f0-9]{64}$/.test(expected.sha256), `${name} manifest checksum is malformed`);
    const actual = sha256({ dataset: datasetText, result: resultText, protocol: protocolText, verifier: verifierText }[name]);
    expect(actual === expected.sha256, `${name} file checksum differs from manifest`);
  }

  expect(Array.isArray(dataset.issues) && dataset.issues.length === 100, "dataset must contain exactly 100 issues");
  const frozenIssues = dataset.issues.map(({ number: issueNumber, htmlUrl, createdAt, updatedAt }) => ({
    number: issueNumber, htmlUrl, createdAt, updatedAt,
  }));
  expect(sha256(JSON.stringify(frozenIssues)) === dataset.sha256, "dataset SHA-256 does not match the frozen issues");
  expect(dataset.sha256 === result.source?.datasetSha256, "result dataset SHA-256 does not match the manifest");
  expect(JSON.stringify(frozenIssues.map((issue) => issue.number)) === JSON.stringify(result.source?.selectedIssueNumbers), "result issue numbers do not match the frozen dataset");

  const traffic = result.traffic;
  const proof = result.proof;
  const paired = result.heldOutPairedEvaluation;
  const control = paired?.control;
  const treatment = paired?.treatment;
  for (const [value, name] of [
    [traffic?.uniqueIssues, "traffic.uniqueIssues"], [traffic?.gatewayRequests, "traffic.gatewayRequests"],
    [traffic?.observationBenchmarkLiveModelRequests, "traffic.observationBenchmarkLiveModelRequests"],
    [traffic?.shadowBenchmarkLiveModelRequests, "traffic.shadowBenchmarkLiveModelRequests"],
    [traffic?.heldOutControlRequests, "traffic.heldOutControlRequests"], [traffic?.heldOutTreatmentRequests, "traffic.heldOutTreatmentRequests"],
    [paired?.pairs, "heldOutPairedEvaluation.pairs"], [control?.recordedModelCostUsd, "control.recordedModelCostUsd"],
    [treatment?.recordedModelCostUsd, "treatment.recordedModelCostUsd"],
  ]) number(value, name);

  expect(traffic.uniqueIssues === dataset.issues.length, "unique issue total must equal dataset length");
  expect(traffic.gatewayRequests === traffic.observationBenchmarkLiveModelRequests + traffic.shadowBenchmarkLiveModelRequests + traffic.heldOutControlRequests + traffic.heldOutTreatmentRequests, "gateway request total is impossible");
  expect(traffic.totalLiveModelRequests === traffic.observationBenchmarkLiveModelRequests + traffic.shadowBenchmarkLiveModelRequests + control.modelRequests, "live-model request total is impossible");
  expect(traffic.totalArtifactRequests === treatment.artifactRoutes, "artifact request total is impossible");
  expect(paired.pairs === traffic.heldOutControlRequests && paired.pairs === traffic.heldOutTreatmentRequests, "paired denominators must agree");
  expect(control.liveRoutes === paired.pairs && control.exactPlans === paired.pairs && control.modelRequests === paired.pairs, "control claims are inconsistent");
  expect(treatment.artifactRoutes === paired.pairs && treatment.exactPlans === paired.pairs && treatment.freshGitHubReads === paired.pairs && treatment.modelRequests === 0, "treatment claims are inconsistent");
  expect(proof.replayPasses === 20 && proof.replayFails === 0 && proof.shadowPasses === 20 && proof.shadowFails === 0, "replay/shadow counts are inconsistent with the public protocol");
  expect(paired.pairedRecordedModelCostAvoidedUsd === Number((control.recordedModelCostUsd - treatment.recordedModelCostUsd).toFixed(8)), "recorded model-cost avoidance is inconsistent");
  expect(paired.controlRecordedModelCostPer1000RequestsUsd === Number((control.recordedModelCostUsd / paired.pairs * 1000).toFixed(3)), "per-1,000 recorded model cost is inconsistent");
  expect(paired.errors === 0 && paired.fallbacks === 0 && paired.malformedPlans === 0 && paired.exclusions === 0, "positive result has non-zero integrity counters");
  expect(result.publicationGate?.all50TreatmentArtifactRouted && result.publicationGate?.all50TreatmentPlansExact && result.publicationGate?.all50FreshReadsSucceeded && result.publicationGate?.treatmentModelRequestsZero, "positive publication gate is incomplete");
  expect(result.publicationGate?.externalWritesAttempted === 0, "public result records an external write");

  console.log(JSON.stringify({
    status: "verified_public_artifacts_only",
    datasetSha256: dataset.sha256,
    heldOutPairs: paired.pairs,
    note: "Checks frozen public files and aggregate arithmetic only; it does not reproduce or independently prove the private provider-backed run.",
  }, null, 2));
}

main().catch((error) => {
  console.error(`verification failed: ${error instanceof Error ? error.message : String(error)}`);
  process.exitCode = 1;
});