tamper-signal 1.2.0

package/node/receipts.js

@@ -0,0 +1,335 @@
+// Receipt creation and chain verification: the Node port of
+// tamper_signal/receipts.py. Chains written here verify with the Python CLI
+// and the browser, and vice versa.
+
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+
+import { canonicalJsonBytes } from "./canonical.js";
+import { keyFingerprint, publicHexFromPrivate, sign, verify } from "./keys.js";
+import { controlTotals, totalsDelta } from "./totals.js";
+
+export const SPEC_VERSION = "1.1";
+export const CHAIN_FILENAME = "chain.json";
+export const SOURCE_RECEIPT_NAME = "000_source.json";
+
+const nowIso = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+
+export function codeHashOf(fn) {
+  // Node has no inspect.getsource; the function's own toString() is the
+  // closest stable equivalent. Code hashes are per-receipt metadata, not
+  // chain links, so they never need to match across languages.
+  return createHash("sha256").update(String(fn), "utf-8").digest("hex");
+}
+
+function signBody(body, privateKey) {
+  const message = canonicalJsonBytes(body);
+  const publicHex = publicHexFromPrivate(privateKey);
+  return {
+    ...body,
+    signature: {
+      alg: "ed25519",
+      key_fingerprint: keyFingerprint(Buffer.from(publicHex, "hex")),
+      value: sign(privateKey, message),
+    },
+  };
+}
+
+export function buildSourceManifest({
+  filename,
+  evidenceHash,
+  byteSize,
+  declaredOrigin,
+  semanticHash,
+  records,
+  privateKey,
+  createdAt,
+}) {
+  return signBody(
+    {
+      kind: "source_manifest",
+      spec_version: SPEC_VERSION,
+      created_at: createdAt ?? nowIso(),
+      source: {
+        filename,
+        evidence_hash: evidenceHash,
+        byte_size: byteSize,
+        declared_origin: declaredOrigin,
+      },
+      semantic_hash: semanticHash,
+      control_totals: controlTotals(records),
+    },
+    privateKey
+  );
+}
+
+export function buildTransformReceipt({
+  name,
+  codeHash,
+  codeFile,
+  inputSemanticHash,
+  outputSemanticHash,
+  outputRecords,
+  privateKey,
+  createdAt,
+}) {
+  return signBody(
+    {
+      kind: "transform_receipt",
+      spec_version: SPEC_VERSION,
+      created_at: createdAt ?? nowIso(),
+      transform: { name, code_hash: codeHash, code_file: codeFile },
+      input_semantic_hash: inputSemanticHash,
+      output_semantic_hash: outputSemanticHash,
+      output_control_totals: controlTotals(outputRecords),
+    },
+    privateKey
+  );
+}
+
+// --- Defensive hash accessors mirroring the Python side. -------------------
+const MISSING_OUTPUT = "<missing-output-hash>";
+const MISSING_INPUT = "<missing-input-hash>";
+
+const strAt = (receipt, keys, fallback) => {
+  let cur = receipt;
+  for (const key of keys) {
+    if (cur === null || typeof cur !== "object" || Array.isArray(cur) || !(key in cur)) return fallback;
+    cur = cur[key];
+  }
+  return typeof cur === "string" ? cur : fallback;
+};
+
+const kindOf = (r) => (r !== null && typeof r === "object" ? r.kind : undefined);
+
+export function outputHashOf(receipt) {
+  if (kindOf(receipt) === "source_manifest") return strAt(receipt, ["semantic_hash"], MISSING_OUTPUT);
+  return strAt(receipt, ["output_semantic_hash"], MISSING_OUTPUT);
+}
+
+export function inputHashOf(receipt) {
+  if (kindOf(receipt) === "source_manifest") return null;
+  return strAt(receipt, ["input_semantic_hash"], MISSING_INPUT);
+}
+
+export function totalsOf(receipt) {
+  const key = kindOf(receipt) === "source_manifest" ? "control_totals" : "output_control_totals";
+  const value = receipt !== null && typeof receipt === "object" ? receipt[key] : undefined;
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+export function stageNameOf(receipt) {
+  if (kindOf(receipt) === "source_manifest") return "source";
+  return strAt(receipt, ["transform", "name"], "") || "<unknown>";
+}
+
+// --- Persistence ------------------------------------------------------------
+function receiptBody(receipt) {
+  const body = {};
+  for (const k of Object.keys(receipt)) if (k !== "signature") body[k] = receipt[k];
+  return body;
+}
+
+export function writeReceipt(chainDir, filename, receipt) {
+  mkdirSync(chainDir, { recursive: true });
+  const path = join(chainDir, filename);
+  writeFileSync(path, JSON.stringify(receipt, null, 2) + "\n");
+  return path;
+}
+
+export function readReceipt(chainDir, filename) {
+  // Receipt filenames come from chain.json, which is attacker-controlled.
+  const base = resolve(chainDir);
+  const target = resolve(base, filename);
+  if (dirname(target) !== base || basename(target) !== filename) {
+    throw new Error(`Unsafe receipt path outside chain directory: ${filename}`);
+  }
+  try {
+    return JSON.parse(readFileSync(target, "utf-8"));
+  } catch (err) {
+    throw new Error(`Could not read receipt ${filename}: ${err.message}`);
+  }
+}
+
+export function readChain(chainPath) {
+  return JSON.parse(readFileSync(chainPath, "utf-8"));
+}
+
+export function writeChain(chainDir, receiptFiles, publicHex) {
+  mkdirSync(chainDir, { recursive: true });
+  const chain = { spec_version: SPEC_VERSION, public_key: publicHex, receipts: receiptFiles };
+  const path = join(chainDir, CHAIN_FILENAME);
+  writeFileSync(path, JSON.stringify(chain, null, 2) + "\n");
+  return path;
+}
+
+export function readChainFiles(chainDir) {
+  const chainPath = join(chainDir, CHAIN_FILENAME);
+  if (!existsSync(chainPath)) return [];
+  return readChain(chainPath).receipts ?? [];
+}
+
+export function loadReceipts(chainDir) {
+  return readChainFiles(chainDir).map((name) => readReceipt(chainDir, name));
+}
+
+export function nextReceiptFilename(chainDir, transformName) {
+  const index = readChainFiles(chainDir).length;
+  return `${String(index).padStart(3, "0")}_${transformName}.json`;
+}
+
+// --- Verification -----------------------------------------------------------
+export function verifySignature(receipt, publicHex) {
+  const signature = receipt?.signature;
+  if (!signature || !("value" in signature)) return false;
+  let message;
+  try {
+    message = canonicalJsonBytes(receiptBody(receipt));
+  } catch {
+    return false;
+  }
+  return verify(publicHex, message, signature.value);
+}
+
+function coverageGaps(receiptNames) {
+  const indices = [];
+  for (const name of receiptNames) {
+    const prefix = String(name).split("_", 1)[0];
+    if (!/^[0-9]{3}$/.test(prefix)) return [];
+    indices.push(parseInt(prefix, 10));
+  }
+  const gaps = [];
+  if (indices.length && indices[0] !== 0) {
+    gaps.push(`chain starts at ${String(indices[0]).padStart(3, "0")}, not 000`);
+  }
+  for (let i = 1; i < indices.length; i++) {
+    if (indices[i] !== indices[i - 1] + 1) {
+      gaps.push(
+        `numbering jumps ${String(indices[i - 1]).padStart(3, "0")} -> ${String(indices[i]).padStart(3, "0")}`
+      );
+    }
+  }
+  return gaps;
+}
+
+const short = (value) =>
+  value === null || value === undefined
+    ? "(none)"
+    : value.length <= 10
+      ? value
+      : `${value.slice(0, 4)}...${value.slice(-2)}`;
+
+// Mirrors tamper_signal/receipts.py verify_chain, including the yellow
+// verdict. Returns { ok, verdict, caveats, lines, brokenLink }.
+export function verifyChain(receipts, publicHex, dataSemanticHash = null, dataTotals = null, options = {}) {
+  const { chainPublicHex = null, receiptNames = null, warnDrift = false } = options;
+  const result = { ok: true, verdict: "green", caveats: [], lines: [], brokenLink: null };
+  const fail = (...lines) => {
+    result.ok = false;
+    result.verdict = "red";
+    result.lines.push(...lines);
+  };
+
+  if (!receipts.length) {
+    fail("✗ CHAIN EMPTY: no receipts to verify");
+    return result;
+  }
+
+  // 1) Signatures, trusted key first, chain key as fallback.
+  const unrecognized = [];
+  const useFallback = Boolean(chainPublicHex) && chainPublicHex !== publicHex;
+  receipts.forEach((receipt, index) => {
+    if (verifySignature(receipt, publicHex)) return;
+    if (useFallback && verifySignature(receipt, chainPublicHex)) {
+      unrecognized.push(index);
+      return;
+    }
+    fail(`✗ SIGNATURE INVALID on receipt ${index} (${stageNameOf(receipt)})`);
+  });
+  if (!result.ok) return result;
+  if (unrecognized.length) {
+    const stages = unrecognized.map((i) => stageNameOf(receipts[i])).join(", ");
+    const fp = (hex) => {
+      try {
+        return keyFingerprint(Buffer.from(hex, "hex"));
+      } catch {
+        return "<malformed key>";
+      }
+    };
+    result.caveats.push(
+      `unrecognized signing key: ${unrecognized.length} receipt(s) (${stages}) verify under ` +
+        `the chain's embedded key ${fp(chainPublicHex)}, not the trusted key ${fp(publicHex)}`
+    );
+  }
+
+  // 2) Links.
+  for (let index = 1; index < receipts.length; index++) {
+    const expected = outputHashOf(receipts[index - 1]);
+    const found = inputHashOf(receipts[index]);
+    if (found !== expected) {
+      result.brokenLink = index;
+      const delta = totalsDelta(totalsOf(receipts[index - 1]), totalsOf(receipts[index]));
+      fail(
+        `✗ CHAIN BROKEN at link ${index - 1} -> ${index} (${stageNameOf(receipts[index])})`,
+        `  expected input hash ${short(expected)}  (output of ${stageNameOf(receipts[index - 1])})`,
+        `  found    input hash ${short(found)}`,
+        `  Control totals delta vs upstream: ${delta.length ? delta.join(", ") : "(no totals changes detected)"}`
+      );
+      return result;
+    }
+  }
+
+  // 3) Optional current-data check.
+  if (dataSemanticHash !== null) {
+    const final = receipts[receipts.length - 1];
+    const expected = outputHashOf(final);
+    if (dataSemanticHash !== expected) {
+      const delta = dataTotals !== null ? totalsDelta(totalsOf(final), dataTotals) : null;
+      fail(
+        `✗ DATA MISMATCH against final receipt (${stageNameOf(final)})`,
+        `  expected output hash ${short(expected)}`,
+        `  found    data hash   ${short(dataSemanticHash)}`,
+        `  Control totals delta vs receipt: ${
+          delta === null
+            ? "(pass the data records to see which values moved)"
+            : delta.length
+              ? delta.join(", ")
+              : "(no totals changes detected)"
+        }`
+      );
+      return result;
+    }
+  }
+
+  // 4) Yellow caveats; red findings above returned early.
+  for (const gap of coverageGaps(receiptNames ?? [])) {
+    result.caveats.push(`coverage gap: receipt ${gap}; a stage may have run without leaving a receipt`);
+  }
+  if (warnDrift) {
+    for (let index = 1; index < receipts.length; index++) {
+      const delta = totalsDelta(totalsOf(receipts[index - 1]), totalsOf(receipts[index]));
+      if (delta.length) {
+        result.caveats.push(
+          `totals drift at link ${index - 1} -> ${index} (${stageNameOf(receipts[index])}): ${delta.join(", ")}`
+        );
+      }
+    }
+  }
+
+  const rows = totalsOf(receipts[receipts.length - 1]).row_count ?? "?";
+  const transforms = receipts.filter((r) => r.kind === "transform_receipt").length;
+  if (result.caveats.length) {
+    result.verdict = "yellow";
+    result.lines.push(
+      `⚠ CHAIN VERIFIES, WITH CAVEATS: ${receipts.length} receipts, ${transforms} transforms, final row_count ${rows}`
+    );
+    for (const caveat of result.caveats) result.lines.push(`  - ${caveat}`);
+    result.lines.push("  A human should look.");
+  } else {
+    result.lines.push(
+      `✓ CHAIN INTACT: ${receipts.length} receipts, ${transforms} transforms, final row_count ${rows}`
+    );
+  }
+  return result;
+}

package/node/test/canonical.test.js

@@ -0,0 +1,55 @@
+// Golden-vector tests: vectors.json is generated by the Python side
+// (tamper_signal/canonical.py, spec 1.1). Byte equality here is the
+// cross-language contract; any failure is a bug in the Node port.
+
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { test } from "node:test";
+
+import { canonicalize, decimalToPlainString, parseDecimal, semanticHash } from "../canonical.js";
+
+const { vectors } = JSON.parse(readFileSync(new URL("./vectors.json", import.meta.url), "utf-8"));
+
+// {"__date__": "..."} markers become Date instances (midnight UTC); a
+// {"__datetime__": "..."} marker carries a real timestamp.
+function decode(records) {
+  return records.map((record) => {
+    const out = {};
+    for (const [key, value] of Object.entries(record)) {
+      if (value !== null && typeof value === "object" && "__date__" in value) {
+        out[key] = new Date(`${value.__date__}T00:00:00Z`);
+      } else if (value !== null && typeof value === "object" && "__datetime__" in value) {
+        out[key] = new Date(value.__datetime__);
+      } else {
+        out[key] = value;
+      }
+    }
+    return out;
+  });
+}
+
+for (const vector of vectors) {
+  test(`vector: ${vector.name}`, () => {
+    const records = decode(vector.records);
+    assert.equal(canonicalize(records).toString("utf-8"), vector.canonical);
+    assert.equal(semanticHash(records), vector.semantic_hash);
+  });
+}
+
+test("decimal parsing accepts the forms Python's Decimal accepts", () => {
+  assert.equal(decimalToPlainString(parseDecimal("1.")), "1");
+  assert.equal(decimalToPlainString(parseDecimal(".5")), "0.5");
+  assert.equal(decimalToPlainString(parseDecimal("+30")), "30");
+  assert.equal(decimalToPlainString(parseDecimal("1e3")), "1000");
+  assert.equal(decimalToPlainString(parseDecimal("1E+20")), "100000000000000000000");
+  assert.equal(parseDecimal("Infinity"), null);
+  assert.equal(parseDecimal("NaN"), null);
+  assert.equal(parseDecimal("1_000"), null);
+  assert.equal(parseDecimal("0x10"), null);
+});
+
+test("half-even quantization at the sixth place", () => {
+  assert.equal(decimalToPlainString(parseDecimal("0.0000005")), "0"); // ties to even (0)
+  assert.equal(decimalToPlainString(parseDecimal("0.0000015")), "0.000002"); // ties to even (2)
+  assert.equal(decimalToPlainString(parseDecimal("-0.0000005")), "0"); // negative zero collapses
+});

package/node/test/chain.test.js

@@ -0,0 +1,97 @@
+// End-to-end in Node: keygen -> ingest CSV -> receiptStep transform ->
+// verify green; tamper -> red; foreign input -> ChainTailMismatch.
+
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+import { evidenceHash, semanticHash } from "../canonical.js";
+import { generateKeys, loadPrivateKey, publicHexFromPrivate } from "../keys.js";
+import { loadCsv } from "../load.js";
+import {
+  SOURCE_RECEIPT_NAME,
+  buildSourceManifest,
+  loadReceipts,
+  readReceipt,
+  verifyChain,
+  writeChain,
+  writeReceipt,
+} from "../receipts.js";
+import { ChainTailMismatch, receiptStep } from "../wrapper.js";
+
+const CSV = "date,campaign_name,spend_usd\n2026-05-01,a,10.50\n2026-05-02,b,20.00\n2026-05-03,,5\n";
+
+function setup() {
+  const dir = mkdtempSync(join(tmpdir(), "tamper-signal-"));
+  const keys = join(dir, "keys");
+  const chainDir = join(dir, "receipts");
+  generateKeys(keys);
+  const privateKey = loadPrivateKey(join(keys, "signing.key"));
+  const publicHex = publicHexFromPrivate(privateKey);
+
+  const csvPath = join(dir, "export.csv");
+  writeFileSync(csvPath, CSV);
+  const records = loadCsv(csvPath);
+  const manifest = buildSourceManifest({
+    filename: "export.csv",
+    evidenceHash: evidenceHash(Buffer.from(CSV)),
+    byteSize: CSV.length,
+    declaredOrigin: "test export",
+    semanticHash: semanticHash(records),
+    records,
+    privateKey,
+  });
+  writeReceipt(chainDir, SOURCE_RECEIPT_NAME, manifest);
+  writeChain(chainDir, [SOURCE_RECEIPT_NAME], publicHex);
+  return { dir, keys, chainDir, records, publicHex };
+}
+
+test("ingest -> wrapped transform -> verify green", async () => {
+  const { keys, chainDir, records, publicHex } = setup();
+
+  const clean = receiptStep((rows) => rows.filter((r) => r.campaign_name !== null), {
+    chainDir,
+    keyPath: join(keys, "signing.key"),
+    codeFile: "test/chain.test.js",
+  });
+  const output = await clean(records);
+  assert.equal(output.length, 2);
+
+  const receipts = loadReceipts(chainDir);
+  assert.equal(receipts.length, 2);
+  const result = verifyChain(receipts, publicHex);
+  assert.equal(result.verdict, "green");
+  // The receipt caught the silent row drop in its totals.
+  assert.equal(receipts[1].output_control_totals.row_count, 2);
+});
+
+test("tampered receipt turns the chain red", async () => {
+  const { keys, chainDir, records, publicHex } = setup();
+  const step = receiptStep((rows) => rows, { chainDir, keyPath: join(keys, "signing.key") });
+  await step(records);
+
+  const name = "001_transform.json";
+  const receipt = readReceipt(chainDir, name);
+  receipt.output_semantic_hash = "0".repeat(64); // tamper without re-signing
+  writeReceipt(chainDir, name, receipt);
+
+  const result = verifyChain(loadReceipts(chainDir), publicHex);
+  assert.equal(result.verdict, "red");
+  assert.match(result.lines[0], /SIGNATURE INVALID/);
+});
+
+test("foreign input is refused before the transform runs", async () => {
+  const { keys, chainDir } = setup();
+  let ran = false;
+  const step = receiptStep(
+    (rows) => {
+      ran = true;
+      return rows;
+    },
+    { chainDir, keyPath: join(keys, "signing.key") }
+  );
+  await assert.rejects(step([{ not: "the chain tail" }]), ChainTailMismatch);
+  assert.equal(ran, false);
+});

package/node/test/interop.test.js

@@ -0,0 +1,46 @@
+// Cross-language interop: the chains committed under examples/chains/ were
+// created and signed by the Python package. The Node verifier must agree
+// with the Python verdicts exactly.
+
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+import { loadReceipts, readChain, verifyChain } from "../receipts.js";
+
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+function verifyDir(dir, options = {}) {
+  const chain = readChain(join(dir, "chain.json"));
+  return verifyChain(loadReceipts(dir), chain.public_key, null, null, {
+    chainPublicHex: chain.public_key,
+    receiptNames: chain.receipts,
+    ...options,
+  });
+}
+
+test("python-signed intact chain verifies green", () => {
+  const result = verifyDir(join(repoRoot, "examples", "chains", "intact"));
+  assert.equal(result.verdict, "green");
+  assert.ok(result.ok);
+});
+
+test("python-signed tampered chain breaks at link 1 -> 2", () => {
+  const result = verifyDir(join(repoRoot, "examples", "chains", "tampered"));
+  assert.equal(result.verdict, "red");
+  assert.equal(result.brokenLink, 2);
+  assert.match(result.lines.join("\n"), /CHAIN BROKEN at link 1 -> 2/);
+  assert.match(result.lines.join("\n"), /spend_usd/);
+});
+
+test("untrusted key yields the yellow verdict", () => {
+  const dir = join(repoRoot, "examples", "chains", "intact");
+  const chain = readChain(join(dir, "chain.json"));
+  const result = verifyChain(loadReceipts(dir), "ab".repeat(32), null, null, {
+    chainPublicHex: chain.public_key,
+    receiptNames: chain.receipts,
+  });
+  assert.equal(result.verdict, "yellow");
+  assert.match(result.caveats[0], /unrecognized signing key/);
+});

package/node/test/vectors.json

@@ -0,0 +1,115 @@
+{
+  "generated_by": "python tamper_signal.canonical (spec 1.1); regenerate with the script in this file's git history",
+  "vectors": [
+    {
+      "name": "mixed types, shuffled rows, numeric text, dates",
+      "records": [
+        {
+          "date": {
+            "__date__": "2026-05-03"
+          },
+          "campaign_name": "c",
+          "impressions": 300,
+          "spend_usd": 30.0,
+          "active": true
+        },
+        {
+          "date": {
+            "__date__": "2026-05-01"
+          },
+          "campaign_name": "a",
+          "impressions": "100",
+          "spend_usd": "10.50",
+          "active": false
+        },
+        {
+          "date": {
+            "__date__": "2026-05-02"
+          },
+          "campaign_name": null,
+          "impressions": 200,
+          "spend_usd": 20.25,
+          "active": null
+        }
+      ],
+      "canonical": "{\"headers\":[\"active\",\"campaign_name\",\"date\",\"impressions\",\"spend_usd\"],\"rows\":[[null,null,\"2026-05-02\",\"200\",\"20.25\"],[false,\"a\",\"2026-05-01\",\"100\",\"10.5\"],[true,\"c\",\"2026-05-03\",\"300\",\"30\"]]}",
+      "semantic_hash": "64b96900ef4e99d550bc3382dcfc64afb39c26c247835366bd8e0d55107d1c8c"
+    },
+    {
+      "name": "float artifacts, negative zero, big ints, exponent text",
+      "records": [
+        {
+          "x": 0.30000000000000004,
+          "y": -0.0,
+          "z": 1000000000000000,
+          "w": "1e3"
+        },
+        {
+          "x": 0.3,
+          "y": 0,
+          "z": "1000000000000000",
+          "w": 1000
+        }
+      ],
+      "canonical": "{\"headers\":[\"w\",\"x\",\"y\",\"z\"],\"rows\":[[\"1000\",\"0.3\",\"0\",\"1000000000000000\"],[\"1000\",\"0.3\",\"0\",\"1000000000000000\"]]}",
+      "semantic_hash": "ef0590333cb71cf5beca635897a16b6edcfd67ff0bfcc1c6c431bf95fe5d3a5d"
+    },
+    {
+      "name": "unicode NFD input, whitespace trim, empty string vs null",
+      "records": [
+        {
+          "col": "café",
+          "note": "  padded  ",
+          "empty": "",
+          "missing": null
+        }
+      ],
+      "canonical": "{\"headers\":[\"col\",\"empty\",\"missing\",\"note\"],\"rows\":[[\"café\",\"\",null,\"padded\"]]}",
+      "semantic_hash": "844ff5f0d41ddc17ee9937a59e68a43e143954c17dc1e5d2bb700d6ed887ab74"
+    },
+    {
+      "name": "header normalization and union of keys",
+      "records": [
+        {
+          "Total  Spend (USD)": 10,
+          "Channel": "fb"
+        },
+        {
+          "total spend (usd)": "20.0",
+          "Channel": "ig",
+          "extra": "x"
+        }
+      ],
+      "canonical": "{\"headers\":[\"channel\",\"extra\",\"total_spend_(usd)\"],\"rows\":[[\"fb\",null,\"10\"],[\"ig\",\"x\",\"20\"]]}",
+      "semantic_hash": "8a41089d5444c9ce8887f654c40a768ff0472f5e16638bedf3a432b28ef3b9b2"
+    },
+    {
+      "name": "midnight datetime collapses to date; real timestamp keeps time",
+      "records": [
+        {
+          "a": {
+            "__datetime__": "2026-05-01T00:00:00Z"
+          },
+          "b": {
+            "__datetime__": "2026-05-01T13:45:09Z"
+          }
+        }
+      ],
+      "canonical": "{\"headers\":[\"a\",\"b\"],\"rows\":[[\"2026-05-01\",\"2026-05-01T13:45:09Z\"]]}",
+      "semantic_hash": "9c7c3f0f2885b729f63f7c1f1130af8f09016c2c90739d71aa98e1f1ac31e31d"
+    },
+    {
+      "name": "tiny values quantize half-even at six places",
+      "records": [
+        {
+          "a": "0.0000005",
+          "b": "0.0000015",
+          "c": 4e-07,
+          "d": "-0.0000005"
+        }
+      ],
+      "canonical": "{\"headers\":[\"a\",\"b\",\"c\",\"d\"],\"rows\":[[\"0\",\"0.000002\",\"0\",\"0\"]]}",
+      "semantic_hash": "154bbdb4556dd3f8ad90a68c9c3c07c0a32c602c357da87db9bda04198e28325"
+    }
+  ]
+}