@pipeworx/mcp-edge-case-museum 0.1.0 → 0.2.0

package/src/exhibits/unicode/truncation-splits-surrogate-pair.json

@@ -1,65 +0,0 @@
-{
-  "id": "truncation-splits-surrogate-pair",
-  "title": "Truncating a JavaScript string to \"4 characters\" can produce an unencodable string",
-  "category": "unicode",
-  "assumption": "Slicing a string to the first N characters always produces a valid, re-encodable string.",
-  "input": {
-    "display": "\"Hi \\u{1F600}\".slice(0, 4) where \\u{1F600} is GRINNING FACE (outside the Basic Multilingual Plane)",
-    "description": "A bio/comment preview truncated to a fixed character count for a card or notification, where the full text happens to end exactly on an emoji."
-  },
-  "what_goes_wrong": "slice(0, 4) cuts between the two UTF-16 code units of the emoji, leaving a lone surrogate. encodeURIComponent() on the result throws \"URI malformed\", and converting it to UTF-8 (Buffer.from, TextEncoder) silently replaces it with U+FFFD, the replacement character.",
-  "why": "JavaScript strings are sequences of 16-bit UTF-16 code units, and .length and .slice() count code units. Any code point above U+FFFF (which includes most emoji) is stored as a surrogate pair, and slicing between the two halves leaves a lone surrogate, which is not well-formed UTF-16. Lone surrogates have no UTF-8 encoding, so encodeURIComponent throws, while TextEncoder and Buffer substitute U+FFFD. Python's str indexes by code point, so a character-count slice never splits a code point; but Python code that truncates encoded UTF-8 by BYTE count (common for a database column limit) has the same failure one level down: decoding raises UnicodeDecodeError, or substitutes U+FFFD with errors=\"replace\".",
-  "affects": [
-    "javascript"
-  ],
-  "repros": [
-    {
-      "language": "python",
-      "code": "s = \"Hi \\U0001F600\"\nprint(len(s), s[:4] == s)\nb = s.encode(\"utf-8\")\nbcut = b[:5]\ntry:\n    bcut.decode(\"utf-8\")\n    print(\"decoded clean\")\nexcept UnicodeDecodeError as e:\n    print(\"UnicodeDecodeError\")\nprint(bcut.decode(\"utf-8\", errors=\"replace\"))\n",
-      "expected_output": "4 True\nUnicodeDecodeError\nHi �",
-      "verified_with": "Python 3.14.2"
-    },
-    {
-      "language": "javascript",
-      "code": "const s = \"Hi \\u{1F600}\";\nconsole.log(s.length);\nconst cut = s.slice(0, 4);\nconsole.log(JSON.stringify(cut), cut.length);\nconsole.log(Buffer.from(cut, \"utf8\"));\ntry {\n  encodeURIComponent(cut);\n  console.log(\"encoded clean\");\n} catch (e) {\n  console.log(e.message);\n}\n",
-      "expected_output": "5\n\"Hi \\ud83d\" 4\n<Buffer 48 69 20 ef bf bd>\nURI malformed",
-      "verified_with": "Node.js v22.22.2"
-    }
-  ],
-  "fix": "Truncate by grapheme cluster (Intl.Segmenter in JS) or at minimum by code point (Array.from(s) or [...s]), never by raw .length/slice() index, when the text may contain astral characters. In Python, never truncate encoded UTF-8 bytes to a fixed byte budget without first decoding, truncating the string, and re-encoding.",
-  "related": [
-    "grapheme-vs-codepoint-length",
-    "truncation-orphans-combining-mark"
-  ],
-  "sources": [
-    {
-      "title": "Unicode Standard: Surrogates (Chapter 3, UTF-16)",
-      "url": "https://www.unicode.org/versions/latest/"
-    },
-    {
-      "title": "MDN: String.prototype.slice()",
-      "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice"
-    },
-    {
-      "title": "Python docs: codecs error handlers (UnicodeDecodeError)",
-      "url": "https://docs.python.org/3/library/codecs.html#error-handlers"
-    }
-  ],
-  "tags": [
-    "truncation",
-    "length validation",
-    "display",
-    "parsing",
-    "url"
-  ],
-  "test_cases": [
-    {
-      "inputs": [
-        "Hi 😀",
-        4
-      ],
-      "relation": "no_crash",
-      "note": "their_function(text, maxLen) that truncates to maxLen UTF-16 units should not hand back a string that crashes when URL-encoded or re-serialized."
-    }
-  ]
-}

package/src/exhibits/unicode/turkish-dotless-i-case-mapping.json

@@ -1,72 +0,0 @@
-{
-  "id": "turkish-dotless-i-case-mapping",
-  "title": "Lowercasing a Turkish İ does not give you plain \"i\"",
-  "category": "unicode",
-  "assumption": "Lowercasing a capital letter and comparing it to the obvious ASCII spelling works the way it does for A-Z.",
-  "input": {
-    "display": "\"\\u0130stanbul\" (capital I with dot above, U+0130) vs \"istanbul\"",
-    "description": "A user from Turkey types their city, or their own name, into a search box or signup form that lowercases input to build a case-insensitive lookup key."
-  },
-  "what_goes_wrong": "\"\\u0130stanbul\".lower() is not \"istanbul\" — it becomes \"i\\u0307stanbul\" (9 code points instead of 8), so the case-insensitive match against the plain spelling fails, and NFC normalization does not repair it.",
-  "why": "Python's str.lower() and JavaScript's toLowerCase() apply Unicode's default, locale-independent case mapping. The default lowercase of U+0130 (LATIN CAPITAL LETTER I WITH DOT ABOVE) is two code points, U+0069 U+0307 (\"i\" plus COMBINING DOT ABOVE), so the dot is preserved without knowing whether the text is Turkish. Turkish and Azerbaijani pair İ with i and I with ı (dotless), which needs a locale-specific mapping: JavaScript has one in toLocaleLowerCase(\"tr\"), which returns plain \"istanbul\" here, but Python's str methods take no locale. There is no precomposed lowercase \"i with dot above\" (i already has a dot), so NFC normalization afterwards does not collapse the pair back to plain \"i\".",
-  "affects": [
-    "python",
-    "javascript"
-  ],
-  "repros": [
-    {
-      "language": "python",
-      "code": "import unicodedata\ns = \"\\u0130stanbul\"\nlowered = s.lower()\nprint(lowered, len(s), len(lowered))\nprint(lowered == \"istanbul\")\nprint(unicodedata.normalize(\"NFC\", lowered) == \"istanbul\")\n",
-      "expected_output": "i̇stanbul 8 9\nFalse\nFalse",
-      "verified_with": "Python 3.14.2"
-    },
-    {
-      "language": "javascript",
-      "code": "const s = \"\\u0130stanbul\";\nconst lowered = s.toLowerCase();\nconsole.log(lowered, s.length, lowered.length);\nconsole.log(lowered === \"istanbul\");\nconsole.log(lowered.normalize(\"NFC\") === \"istanbul\");\n",
-      "expected_output": "i̇stanbul 8 9\nfalse\nfalse",
-      "verified_with": "Node.js v22.22.2"
-    }
-  ],
-  "fix": "Do not build a uniqueness or search key by calling lower()/upper() on raw user text when the content may be Turkish or Azerbaijani. When you know the locale, use locale-aware mapping (toLocaleLowerCase(\"tr\") in JavaScript, ICU case mapping with locale \"tr\"/\"az\" in Python via a third-party binding). When you do not, use casefold() consistently on both sides, and accept that İ/I/ı/i cannot be folded correctly for every language at once.",
-  "related": [
-    "german-eszett-case-fold",
-    "nfc-nfd-same-name-two-accounts"
-  ],
-  "sources": [
-    {
-      "title": "Unicode Standard: SpecialCasing.txt (default vs. Turkish/Azeri case mappings)",
-      "url": "https://www.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt"
-    },
-    {
-      "title": "Python docs: str.lower / str.upper",
-      "url": "https://docs.python.org/3/library/stdtypes.html#str.lower"
-    },
-    {
-      "title": "MDN: String.prototype.toLowerCase()",
-      "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase"
-    },
-    {
-      "title": "MDN: String.prototype.toLocaleLowerCase()",
-      "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase"
-    }
-  ],
-  "tags": [
-    "username",
-    "uniqueness",
-    "login",
-    "search",
-    "i18n",
-    "normalization",
-    "validation"
-  ],
-  "test_cases": [
-    {
-      "inputs": [
-        "İstanbul",
-        "İSTANBUL"
-      ],
-      "relation": "equal",
-      "note": "Any case-insensitive key should unify these two (casefold() does). Whether \"İstanbul\" should also match plain \"istanbul\" depends on the locale: yes under Turkish rules, no under the default mapping."
-    }
-  ]
-}

package/src/exhibits/unicode/zalgo-combining-mark-stacking.json

@@ -1,57 +0,0 @@
-{
-  "id": "zalgo-combining-mark-stacking",
-  "title": "A nickname that looks like one letter can be 161 code points long",
-  "category": "unicode",
-  "assumption": "A short-looking string is a short string, so a per-character length limit also bounds how much text it can contain.",
-  "input": {
-    "display": "\"e\" followed by a combining mark repeated 20 times (\"\\u0301\\u0310\\u0327\\u032d\\u0353\\u0338\\u035f\\u0360\" x 20) — \"Zalgo text\"",
-    "description": "A display name, comment, or review submitted with Unicode combining marks stacked onto a single base character (easy to generate with any \"Zalgo text\" web tool), occupying one visual line position but arbitrarily many code points."
-  },
-  "what_goes_wrong": "The string occupies roughly one glyph's space (an \"e\" under a stack of marks) but is 161 code points and 321 UTF-8 bytes. A \"nickname must be 1-20 characters\" validator that counts grapheme clusters, the measure usually recommended for user-facing length, counts it as 1 character and accepts it, while it takes far more storage than any 20-character name and can render as a tall smear over neighbouring lines.",
-  "why": "Unicode's definition of well-formed text puts no limit on how many combining marks (General Category Mn, Mc, Me) may follow one base character. Each mark is a legal code point that stacks on the previous one, and UAX #29 groups the base and all of its marks into a single grapheme cluster, so a grapheme count sees one character however many marks follow. UAX #15 defines a \"Stream-Safe Text Format\" that caps runs of non-starters at 30, but it is a recommendation that nothing enforces by default. Code-point or byte limits catch this particular string, which is why the fix combines both measures.",
-  "affects": [
-    "python",
-    "javascript"
-  ],
-  "repros": [
-    {
-      "language": "python",
-      "code": "base = \"e\"\nmarks = \"\\u0301\\u0310\\u0327\\u032d\\u0353\\u0338\\u035f\\u0360\"\nzalgo = base + marks * 20\nprint(len(zalgo), len(zalgo.encode(\"utf-8\")))\n",
-      "expected_output": "161 321",
-      "verified_with": "Python 3.14.2"
-    },
-    {
-      "language": "javascript",
-      "code": "const base = \"e\";\nconst marks = \"\\u0301\\u0310\\u0327\\u032d\\u0353\\u0338\\u035f\\u0360\";\nconst zalgo = base + marks.repeat(20);\nconsole.log(zalgo.length, Buffer.byteLength(zalgo, \"utf8\"));\n",
-      "expected_output": "161 321",
-      "verified_with": "Node.js v22.22.2"
-    }
-  ],
-  "fix": "Enforce a limit in code points or bytes for storage as well as a grapheme-cluster limit for what the user sees, and cap the number of combining marks per base character (a handful covers real orthographies; UAX #15's Stream-Safe Text Format uses 30 as an upper bound).",
-  "related": [
-    "grapheme-vs-codepoint-length",
-    "bidi-override-filename-spoof"
-  ],
-  "sources": [
-    {
-      "title": "UAX #29: Unicode Text Segmentation (grapheme clusters)",
-      "url": "https://www.unicode.org/reports/tr29/"
-    },
-    {
-      "title": "UAX #15: Stream-Safe Text Format",
-      "url": "https://www.unicode.org/reports/tr15/#Stream_Safe_Text_Format"
-    },
-    {
-      "title": "Big List of Naughty Strings (MIT)",
-      "url": "https://github.com/minimaxir/big-list-of-naughty-strings"
-    }
-  ],
-  "tags": [
-    "username",
-    "length validation",
-    "forms",
-    "display",
-    "validation",
-    "security"
-  ]
-}

package/src/exhibits/unicode/zero-width-space-username.json

@@ -1,62 +0,0 @@
-{
-  "id": "zero-width-space-username",
-  "title": "A username with an invisible character survives trim() and slips past a block on \"admin\"",
-  "category": "unicode",
-  "assumption": "strip()/trim() removes anything that isn't visible, so a trimmed string can't contain hidden characters.",
-  "input": {
-    "display": "\"ad\\u200bmin\" (ZERO WIDTH SPACE, U+200B, inserted in the middle) vs \"admin\"",
-    "description": "Pasted text from a chat app, a scraped web page, or a deliberately crafted signup request trying to register a name that looks reserved but technically isn't."
-  },
-  "what_goes_wrong": "\"ad\\u200bmin\" renders as \"admin\", is not equal to \"admin\", is one code point longer, and strip()/trim() leaves it completely unchanged because U+200B sits in the middle of the string, not at an edge, and Unicode does not even classify it as whitespace.",
-  "why": "ZERO WIDTH SPACE (U+200B) has no visible glyph; text-layout engines use it to mark an optional line break inside long words. Its General Category is Cf (format), not Zs (space separator), and it does not have the Unicode White_Space property, so Python's str.strip() and JavaScript's trim() do not treat it as whitespace, and here it is in the middle of the string anyway. ZERO WIDTH JOINER (U+200D) and ZERO WIDTH NO-BREAK SPACE / BOM (U+FEFF) work the same way in the middle of a string. (At the edges JavaScript's trim() does remove U+FEFF, because ECMAScript counts it as whitespace; Python's strip() does not.)",
-  "affects": [
-    "python",
-    "javascript"
-  ],
-  "repros": [
-    {
-      "language": "python",
-      "code": "a = \"admin\"\nb = \"ad\\u200bmin\"\nprint(a == b, len(a), len(b))\nprint(b.strip() == a, len(b.strip()))\n",
-      "expected_output": "False 5 6\nFalse 6",
-      "verified_with": "Python 3.14.2"
-    },
-    {
-      "language": "javascript",
-      "code": "const a = \"admin\";\nconst b = \"ad\\u200bmin\";\nconsole.log(a === b, a.length, b.length);\nconsole.log(b.trim() === a, b.trim().length);\n",
-      "expected_output": "false 5 6\nfalse 6",
-      "verified_with": "Node.js v22.22.2"
-    }
-  ],
-  "fix": "Strip or reject Unicode format characters (category Cf) and other invisible code points explicitly during input sanitization, not just leading/trailing whitespace — don't rely on strip()/trim() to catch them, and don't assume a blocklist check on reserved names (\"admin\", \"root\") is safe without first removing invisibles.",
-  "related": [
-    "cyrillic-homoglyph-paypal-spoof"
-  ],
-  "sources": [
-    {
-      "title": "Unicode Character Database: General Category values (Cf = Format)",
-      "url": "https://www.unicode.org/reports/tr44/#General_Category_Values"
-    },
-    {
-      "title": "Big List of Naughty Strings (MIT)",
-      "url": "https://github.com/minimaxir/big-list-of-naughty-strings"
-    }
-  ],
-  "tags": [
-    "username",
-    "uniqueness",
-    "login",
-    "security",
-    "validation",
-    "forms"
-  ],
-  "test_cases": [
-    {
-      "inputs": [
-        "admin",
-        "ad​min"
-      ],
-      "relation": "equal",
-      "note": "The key used for reserved-name and uniqueness checks should remove invisible format characters (category Cf) so both map to \"admin\" and the second is blocked."
-    }
-  ]
-}

package/src/harness.mjs

@@ -1,331 +0,0 @@
-#!/usr/bin/env node
-/**
- * Edge Case Museum repro harness (fleet #3034).
- *
- * Every exhibit in src/exhibits/<category>/<id>.json
- * carries one or more `repros`. A repro is either
- *   { language: "python" | "javascript", code, expected_output, verified_with }
- * which this harness EXECUTES, or
- *   { language, status: "documented", note, source }
- * which it never claims to have run.
- *
- * The rule the museum exists on: no expected_output is typed from memory.
- * It is captured from a run (--capture), and every later run asserts it.
- *
- * Runtimes: python repros run as `python3 <file>.py`; javascript repros run
- * as `node <file>.mjs` (ES module: use `import`, not `require`). Each runs in
- * its own empty temp directory with a fixed environment (TZ=UTC,
- * LC_ALL=en_US.UTF-8, PYTHONHASHSEED=0) so the output does not depend on the
- * machine's clock zone or locale unless the repro sets them itself.
- *
- * Output: src/verified.json maps "<exhibit id>:<language>" to the sha256 of
- * (code, expected_output) and the runtime that produced it. The bake script
- * (src/bake.mjs) refuses to ship any executable
- * repro whose hash is not in that file, so an edited repro that was never
- * re-run cannot reach the pack.
- *
- * Usage:
- *   node src/harness.mjs                 check every repro; exit 1 on any mismatch
- *   node src/harness.mjs --capture       fill in expected_output where it is missing
- *   node src/harness.mjs --recapture     overwrite expected_output from the run (review the diff!)
- *   node src/harness.mjs --only <id>     restrict to exhibits whose id contains <id>
- *   node src/harness.mjs --category <c>  restrict to one category directory
- *   node src/harness.mjs --dir <path>    exhibits root (default: the pack's src/exhibits)
- *   node src/harness.mjs --no-write      do not touch verified.json (used by the red-path test)
- */
-import { readFileSync, writeFileSync, readdirSync, statSync, mkdtempSync, mkdirSync, rmSync, existsSync, realpathSync } from 'node:fs';
-import { execFileSync, spawn } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-// This file lives at <pack>/src/harness.mjs, both in the Pipeworx monorepo (mcps/edge-case-museum) and in the
-// standalone repo, so every path is relative to the pack root rather than to any repository root.
-const PACK = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const ROOT = PACK;
-const argv = process.argv.slice(2);
-const flag = (f) => argv.includes(f);
-const opt = (f) => {
-  const i = argv.indexOf(f);
-  return i >= 0 ? argv[i + 1] : null;
-};
-const DIR = path.resolve(opt('--dir') ?? path.join(PACK, 'src/exhibits'));
-const VERIFIED = path.join(path.dirname(DIR), 'verified.json');
-const CAPTURE = flag('--capture') || flag('--recapture');
-const RECAPTURE = flag('--recapture');
-const ONLY = opt('--only');
-const CATEGORY = opt('--category');
-const NO_WRITE = flag('--no-write');
-const CONCURRENCY = Number(opt('--jobs') ?? Math.max(2, Math.min(8, os.cpus().length)));
-const TIMEOUT_MS = 15_000;
-
-export const CATEGORIES = ['unicode', 'datetime', 'float-money', 'sorting', 'filenames', 'parsing', 'integers', 'names-addresses'];
-export const RUNNABLE = { python: { cmd: 'python3', ext: '.py' }, javascript: { cmd: 'node', ext: '.mjs' } };
-
-export function reproHash(code, expected) {
-  return createHash('sha256').update(String(code)).update('\0').update(String(expected)).digest('hex');
-}
-
-/** Trailing whitespace on each line and trailing blank lines are not part of the claim. */
-export function normalizeOutput(s) {
-  return String(s)
-    .replace(/\r\n/g, '\n')
-    .split('\n')
-    .map((l) => l.replace(/[ \t]+$/, ''))
-    .join('\n')
-    .replace(/\n+$/, '');
-}
-
-function runtimeVersion(lang) {
-  if (lang !== 'python') return `Node.js ${process.version}`;
-  try {
-    return execFileSync('python3', ['--version'], { encoding: 'utf8' }).trim();
-  } catch {
-    return 'python3 unavailable'; // python repros will then fail loudly as crashes, never pass
-  }
-}
-
-/** Write exhibits into a fresh temp tree (<tmp>/exhibits/<category>/<id>.json) and return its root. Used by the red-path test. */
-export function writeExhibitTree(exhibits) {
-  const root = path.join(mkdtempSync(path.join(os.tmpdir(), 'ecm-tree-')), 'exhibits');
-  for (const ex of exhibits) {
-    const dir = path.join(root, ex.category);
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(path.join(dir, `${ex.id}.json`), JSON.stringify(ex, null, 2));
-  }
-  return root;
-}
-
-export function loadExhibits(dir = DIR) {
-  const out = [];
-  if (!existsSync(dir)) return out;
-  for (const cat of readdirSync(dir).sort()) {
-    const cdir = path.join(dir, cat);
-    if (!statSync(cdir).isDirectory()) continue;
-    for (const f of readdirSync(cdir).sort()) {
-      if (!f.endsWith('.json')) continue;
-      const file = path.join(cdir, f);
-      let ex;
-      try {
-        ex = JSON.parse(readFileSync(file, 'utf8'));
-      } catch (e) {
-        out.push({ file, dirCategory: cat, parseError: e.message });
-        continue;
-      }
-      out.push({ file, dirCategory: cat, ex });
-    }
-  }
-  return out;
-}
-
-const RELATIONS = new Set(['equal', 'not_equal', 'returns', 'no_crash', 'raises']);
-
-/** Structural validation. Returns a list of problems (empty = valid). */
-export function validateExhibit({ file, dirCategory, ex, parseError }) {
-  const where = path.relative(ROOT, file);
-  if (parseError) return [`${where}: invalid JSON (${parseError})`];
-  const errs = [];
-  const str = (k) => {
-    if (typeof ex[k] !== 'string' || !ex[k].trim()) errs.push(`${where}: "${k}" must be a non-empty string`);
-  };
-  for (const k of ['id', 'title', 'category', 'assumption', 'what_goes_wrong', 'why', 'fix']) str(k);
-  if (ex.id && path.basename(file, '.json') !== ex.id) errs.push(`${where}: file name must equal id (${ex.id})`);
-  if (ex.id && !/^[a-z0-9]+(-[a-z0-9]+)*$/.test(ex.id)) errs.push(`${where}: id must be kebab-case`);
-  if (!CATEGORIES.includes(ex.category)) errs.push(`${where}: category "${ex.category}" not one of ${CATEGORIES.join(', ')}`);
-  if (ex.category !== dirCategory) errs.push(`${where}: category "${ex.category}" does not match its directory "${dirCategory}"`);
-  if (!ex.input || typeof ex.input.display !== 'string' || !ex.input.display) errs.push(`${where}: input.display (exact value, with escapes) is required`);
-  if (!Array.isArray(ex.affects) || !ex.affects.length) errs.push(`${where}: affects must list at least one stack`);
-  if (!Array.isArray(ex.tags) || ex.tags.length < 2) errs.push(`${where}: tags must have at least two retrieval contexts`);
-  if (!Array.isArray(ex.sources) || !ex.sources.length) errs.push(`${where}: at least one source is required`);
-  for (const s of ex.sources ?? []) if (!s || typeof s.title !== 'string' || !/^https?:\/\//.test(s.url ?? '')) errs.push(`${where}: every source needs a title and an http(s) url`);
-  if (!Array.isArray(ex.related)) errs.push(`${where}: related must be an array (may be empty)`);
-  if (!Array.isArray(ex.repros) || !ex.repros.length) errs.push(`${where}: at least one repro is required`);
-  const langs = new Set();
-  for (const r of ex.repros ?? []) {
-    if (!r || typeof r.language !== 'string') {
-      errs.push(`${where}: repro without language`);
-      continue;
-    }
-    if (langs.has(r.language)) errs.push(`${where}: two repros for ${r.language}`);
-    langs.add(r.language);
-    if (r.status === 'documented') {
-      if (typeof r.note !== 'string' || !r.note) errs.push(`${where}: documented ${r.language} repro needs a note`);
-      if (!/^https?:\/\//.test(r.source ?? '')) errs.push(`${where}: documented ${r.language} repro needs a source url`);
-      continue;
-    }
-    if (!RUNNABLE[r.language]) errs.push(`${where}: ${r.language} repro is not executable here; mark it status:"documented" with a note and source`);
-    if (typeof r.code !== 'string' || !r.code.trim()) errs.push(`${where}: ${r.language} repro has no code`);
-  }
-  if (!langs.has('python') && !langs.has('javascript')) errs.push(`${where}: needs at least one executable python or javascript repro`);
-  for (const t of ex.test_cases ?? []) {
-    if (!RELATIONS.has(t.relation)) errs.push(`${where}: test_case relation "${t.relation}" not one of ${[...RELATIONS].join(', ')}`);
-    if (!Array.isArray(t.inputs) || !t.inputs.length) errs.push(`${where}: test_case needs inputs[]`);
-    if ((t.relation === 'equal' || t.relation === 'not_equal') && t.inputs?.length !== 2) errs.push(`${where}: ${t.relation} test_case needs exactly two inputs`);
-    if (t.relation === 'returns' && !('expected' in t)) errs.push(`${where}: returns test_case needs expected`);
-  }
-  return errs;
-}
-
-function runOne(lang, code) {
-  const dir = mkdtempSync(path.join(os.tmpdir(), 'ecm-'));
-  const file = path.join(dir, `repro${RUNNABLE[lang].ext}`);
-  writeFileSync(file, code);
-  return new Promise((resolve) => {
-    const env = {
-      PATH: process.env.PATH,
-      HOME: dir,
-      TZ: 'UTC',
-      LANG: 'en_US.UTF-8',
-      LC_ALL: 'en_US.UTF-8',
-      PYTHONHASHSEED: '0',
-      PYTHONIOENCODING: 'utf-8',
-      PYTHONDONTWRITEBYTECODE: '1',
-      PYTHONWARNINGS: 'ignore',
-      NODE_NO_WARNINGS: '1',
-    };
-    const child = spawn(RUNNABLE[lang].cmd, [file], { cwd: dir, env });
-    let stdout = '';
-    let stderr = '';
-    child.stdout.on('data', (d) => (stdout += d));
-    child.stderr.on('data', (d) => (stderr += d));
-    const timer = setTimeout(() => child.kill('SIGKILL'), TIMEOUT_MS);
-    child.on('close', (code, signal) => {
-      clearTimeout(timer);
-      rmSync(dir, { recursive: true, force: true });
-      resolve({ exit: code, signal, stdout, stderr });
-    });
-  });
-}
-
-async function pool(items, n, fn) {
-  const results = new Array(items.length);
-  let i = 0;
-  await Promise.all(
-    Array.from({ length: Math.min(n, items.length) }, async () => {
-      while (i < items.length) {
-        const k = i++;
-        results[k] = await fn(items[k]);
-      }
-    }),
-  );
-  return results;
-}
-
-export async function runHarness({ dir = DIR, capture = CAPTURE, recapture = RECAPTURE, only = ONLY, category = CATEGORY, write = !NO_WRITE, log = console.log } = {}) {
-  const verifiedPath = path.join(path.dirname(dir), 'verified.json');
-  const loaded = loadExhibits(dir).filter((e) => (!only || e.ex?.id?.includes(only)) && (!category || e.dirCategory === category));
-  const problems = [];
-  for (const e of loaded) problems.push(...validateExhibit(e));
-  const ids = new Set();
-  for (const e of loaded) {
-    if (!e.ex) continue;
-    if (ids.has(e.ex.id)) problems.push(`duplicate exhibit id ${e.ex.id}`);
-    ids.add(e.ex.id);
-  }
-  const versions = { python: runtimeVersion('python'), javascript: runtimeVersion('javascript') };
-  const jobs = [];
-  for (const e of loaded) {
-    if (!e.ex) continue;
-    for (const r of e.ex.repros ?? []) if (r.status !== 'documented' && RUNNABLE[r.language] && typeof r.code === 'string') jobs.push({ e, r });
-  }
-  const results = await pool(jobs, CONCURRENCY, async ({ e, r }) => ({ e, r, run: await runOne(r.language, r.code) }));
-
-  let passed = 0;
-  let failed = 0;
-  let captured = 0;
-  const failures = [];
-  const dirty = new Set();
-  const verified = existsSync(verifiedPath) ? JSON.parse(readFileSync(verifiedPath, 'utf8')) : {};
-  const entries = verified.repros ?? {};
-  for (const { e, r, run } of results) {
-    const key = `${e.ex.id}:${r.language}`;
-    const actual = normalizeOutput(run.stdout);
-    const crashed = run.exit !== 0 || run.signal;
-    if (crashed) {
-      failed++;
-      failures.push({ key, file: e.file, reason: `exited ${run.signal ?? run.exit}`, stderr: run.stderr.trim().split('\n').slice(-4).join('\n') });
-      delete entries[key];
-      continue;
-    }
-    if (!actual) {
-      failed++;
-      failures.push({ key, file: e.file, reason: 'printed nothing (a repro must print what it demonstrates)' });
-      delete entries[key];
-      continue;
-    }
-    if (capture && (recapture || typeof r.expected_output !== 'string')) {
-      if (r.expected_output !== actual || r.verified_with !== versions[r.language]) {
-        r.expected_output = actual;
-        r.verified_with = versions[r.language];
-        dirty.add(e);
-        captured++;
-      }
-    }
-    if (typeof r.expected_output !== 'string') {
-      failed++;
-      failures.push({ key, file: e.file, reason: 'no expected_output (run with --capture)' });
-      delete entries[key];
-      continue;
-    }
-    if (normalizeOutput(r.expected_output) === actual) {
-      passed++;
-      if (r.verified_with !== versions[r.language]) {
-        // Same output on a different runtime: record which runtime last confirmed it.
-        r.verified_with = versions[r.language];
-        dirty.add(e);
-      }
-      entries[key] = { sha256: reproHash(r.code, normalizeOutput(r.expected_output)), verified_with: versions[r.language] };
-    } else {
-      failed++;
-      failures.push({ key, file: e.file, reason: 'output differs', expected: normalizeOutput(r.expected_output), actual });
-      delete entries[key];
-    }
-  }
-  // Prune verified entries for repros that no longer exist (only on a full run).
-  if (!only && !category) {
-    const live = new Set(jobs.map(({ e, r }) => `${e.ex.id}:${r.language}`));
-    for (const k of Object.keys(entries)) if (!live.has(k)) delete entries[k];
-  }
-  if (write) {
-    for (const e of dirty) writeFileSync(e.file, JSON.stringify(e.ex, null, 2) + '\n');
-    const sorted = Object.fromEntries(Object.keys(entries).sort().map((k) => [k, entries[k]]));
-    writeFileSync(
-      verifiedPath,
-      JSON.stringify({ _comment: 'GENERATED by src/harness.mjs. One row per executed repro that matched its expected_output; the bake refuses any repro not listed here with the same hash.', runtimes: versions, repros: sorted }, null, 2) + '\n',
-    );
-  }
-
-  const documented = loaded.reduce((n, e) => n + (e.ex?.repros ?? []).filter((r) => r.status === 'documented').length, 0);
-  const byCat = {};
-  for (const e of loaded) if (e.ex) byCat[e.ex.category] = (byCat[e.ex.category] ?? 0) + 1;
-  for (const p of problems) log(`SCHEMA  ${p}`);
-  for (const f of failures) {
-    log(`FAIL    ${f.key}  (${path.relative(ROOT, f.file)}): ${f.reason}`);
-    if (f.stderr) log(`        stderr: ${f.stderr.replace(/\n/g, '\n                ')}`);
-    if (f.expected !== undefined) {
-      log(`        expected: ${JSON.stringify(f.expected)}`);
-      log(`        actual:   ${JSON.stringify(f.actual)}`);
-    }
-  }
-  log(`exhibits: ${loaded.length} (${Object.entries(byCat).map(([k, v]) => `${k} ${v}`).join(', ')})`);
-  log(`repros executed: ${results.length}  passed: ${passed}  failed: ${failed}  documented (not executed): ${documented}${capture ? `  captured: ${captured}` : ''}`);
-  log(`runtimes: ${versions.python} · ${versions.javascript}`);
-  const ok = failed === 0 && problems.length === 0;
-  log(ok ? 'HARNESS GREEN' : `HARNESS RED (${failed} failing repro(s), ${problems.length} schema problem(s))`);
-  return { ok, passed, failed, problems, failures, exhibits: loaded.length, byCat };
-}
-
-// realpath on both sides: through a symlinked path (macOS /tmp -> /private/tmp) a plain
-// path.resolve comparison never matched, so the harness ran NOTHING and exited 0 -- green unrun.
-const isMain = () => {
-  try {
-    return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
-  } catch {
-    return false;
-  }
-};
-if (process.argv[1] && isMain()) {
-  const r = await runHarness();
-  process.exit(r.ok ? 0 : 1);
-}