mixdog 0.7.18 → 0.8.0

package/scripts/doctor.mjs

@@ -1,489 +0,0 @@
-#!/usr/bin/env bun
-/**
- * mixdog doctor - health diagnostics for the mixdog plugin.
- * Usage:
- *   bun scripts/doctor.mjs           # run checks only
- *   bun scripts/doctor.mjs --setup   # run checks then launch setup UI
- *
- * Pure Node/Bun built-ins only. No external deps. Cross-OS.
- * Exit 0 unless FAIL count > 0, then exit 1.
- */
-import { existsSync, readFileSync, statSync, readdirSync, lstatSync } from 'fs';
-import { join, basename, dirname } from 'path';
-import { homedir, tmpdir } from 'os';
-import { spawnSync, spawn } from 'child_process';
-import { fileURLToPath } from 'url';
-import { createConnection } from 'net';
-import { createRequire } from 'module';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const require = createRequire(import.meta.url);
-
-// ---------------------------------------------------------------------------
-// Resolve PLUGIN_ROOT and PLUGIN_DATA
-// ---------------------------------------------------------------------------
-const PLUGIN_ROOT = process.env.CLAUDE_PLUGIN_ROOT || dirname(__dirname);
-
-// Claude config base — honours CLAUDE_CONFIG_DIR (matches settings-loader / statusline).
-function claudeConfigBase() {
-  return process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
-}
-
-function resolvePluginData() {
-  if (process.env.CLAUDE_PLUGIN_DATA) return process.env.CLAUDE_PLUGIN_DATA;
-  const dirName = basename(PLUGIN_ROOT);
-  // Cache layout: <plugin>/<marketplace>/<semver>/
-  if (/^\d+\.\d+\.\d+/.test(dirName)) {
-    const pluginName = basename(join(PLUGIN_ROOT, '..'));
-    const marketplace = basename(join(PLUGIN_ROOT, '..', '..'));
-    return join(claudeConfigBase(), 'plugins', 'data', `${pluginName}-${marketplace}`);
-  }
-  // Marketplace layout: root IS the plugin dir
-  const marketplace = dirName;
-  let pluginName = 'mixdog';
-  try {
-    const manifest = JSON.parse(readFileSync(join(PLUGIN_ROOT, '.claude-plugin', 'plugin.json'), 'utf8'));
-    if (typeof manifest?.name === 'string' && manifest.name.trim()) pluginName = manifest.name.trim();
-  } catch { /* fall through */ }
-  return join(claudeConfigBase(), 'plugins', 'data', `${pluginName}-${marketplace}`);
-}
-
-const PLUGIN_DATA = resolvePluginData();
-const isSetup = process.argv.includes('--setup');
-
-// ---------------------------------------------------------------------------
-// Result tracking
-// ---------------------------------------------------------------------------
-const rows = [];
-let failCount = 0;
-let warnCount = 0;
-let okCount = 0;
-
-function addRow(status, label, detail) {
-  rows.push({ status, label, detail: detail ?? '' });
-  if (status === 'FAIL') failCount++;
-  else if (status === 'WARN') warnCount++;
-  else okCount++;
-}
-const ok   = (label, detail) => addRow('OK',   label, detail);
-const warn = (label, detail) => addRow('WARN', label, detail);
-const fail = (label, detail) => addRow('FAIL', label, detail);
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function readJson(p) {
-  try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return null; }
-}
-
-function parsePositivePid(value) {
-  const pid = Number(value);
-  return Number.isFinite(pid) && pid > 0 ? pid : null;
-}
-
-function getActiveOwnerPid(inst) {
-  return parsePositivePid(inst?.ownerLeadPid)
-    ?? parsePositivePid(inst?.terminalLeadPid)
-    ?? parsePositivePid(inst?.supervisor_pid)
-    ?? parsePositivePid(inst?.instanceId);
-}
-
-function dirSize(p, limitBytes = Infinity) {
-  let total = 0;
-  try {
-    const entries = readdirSync(p, { withFileTypes: true });
-    for (const e of entries) {
-      if (total >= limitBytes) break;
-      const full = join(p, e.name);
-      try {
-        if (e.isDirectory()) total += dirSize(full, limitBytes - total);
-        else total += statSync(full).size;
-      } catch { /* skip inaccessible */ }
-    }
-  } catch { /* skip inaccessible dir */ }
-  return total;
-}
-
-function toMB(bytes) { return (bytes / 1024 / 1024).toFixed(1); }
-
-function semverGte(a, b) {
-  // Returns true if version string a >= b (numeric segments only)
-  const pa = a.replace(/[^0-9.]/g, '').split('.').map(Number);
-  const pb = b.replace(/[^0-9.]/g, '').split('.').map(Number);
-  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-    const na = pa[i] ?? 0, nb = pb[i] ?? 0;
-    if (na > nb) return true;
-    if (na < nb) return false;
-  }
-  return true;
-}
-
-// ---------------------------------------------------------------------------
-// Check 1: Version sync (package.json vs .claude-plugin/plugin.json)
-// ---------------------------------------------------------------------------
-(function checkVersionSync() {
-  const pkgPath    = join(PLUGIN_ROOT, 'package.json');
-  const pluginPath = join(PLUGIN_ROOT, '.claude-plugin', 'plugin.json');
-  const pkg    = readJson(pkgPath);
-  const plugin = readJson(pluginPath);
-  if (!pkg)    { fail('Version sync', `cannot read ${pkgPath}`); return; }
-  if (!plugin) { fail('Version sync', `cannot read ${pluginPath}`); return; }
-  const pv = pkg.version ?? '(missing)';
-  const pjv = plugin.version ?? '(missing)';
-  if (pv === pjv) ok('Version sync', `${pv}`);
-  else fail('Version sync', `package.json=${pv} vs plugin.json=${pjv}`);
-})();
-
-// ---------------------------------------------------------------------------
-// Check 2: Bun version >= 1.1.0
-// ---------------------------------------------------------------------------
-(function checkBunVersion() {
-  // When running under bun, Bun.version is available; otherwise fall back to CLI.
-  let version = typeof Bun !== 'undefined' ? Bun.version : null;
-  if (!version) {
-    const r = spawnSync('bun', ['--version'], { encoding: 'utf8' });
-    version = (r.stdout ?? '').trim();
-  }
-  if (!version) { fail('Bun version', 'bun not found on PATH'); return; }
-  const clean = version.replace(/^v/, '');
-  if (semverGte(clean, '1.1.0')) ok('Bun version', `${clean} (>= 1.1.0)`);
-  else fail('Bun version', `${clean} < 1.1.0 - upgrade required`);
-})();
-
-// ---------------------------------------------------------------------------
-// Check 3: Bun source (system PATH vs plugin-local vs absent)
-// ---------------------------------------------------------------------------
-(function checkBunSource() {
-  const isWin = process.platform === 'win32';
-  // Try system PATH first.
-  const whichCmd = isWin ? 'where.exe' : 'which';
-  const r = spawnSync(whichCmd, ['bun'], { encoding: 'utf8' });
-  if (r.status === 0 && r.stdout) {
-    const first = r.stdout.split(/\r?\n/).map(l => l.trim()).find(l => l.length > 0);
-    if (first && existsSync(first)) { ok('Bun source', `system: ${first}`); return; }
-  }
-  // Check plugin-local node_modules/.bin/bun.
-  const localBin = join(PLUGIN_ROOT, 'node_modules', '.bin', isWin ? 'bun.exe' : 'bun');
-  if (existsSync(localBin)) { ok('Bun source', `local: ${localBin}`); return; }
-  // Not found - bootstrap will install on first launch.
-  warn('Bun source', 'not found (bootstrap will install via npm on first launch)');
-})();
-
-// ---------------------------------------------------------------------------
-// Check 4: Shell availability
-// ---------------------------------------------------------------------------
-(function checkShellSource() {
-  const isWindows = process.platform === 'win32'
-    || !!(process.env.WINDIR || process.env.SystemRoot);
-  if (!isWindows) {
-    if (existsSync('/bin/sh')) ok('Shell source', '/bin/sh');
-    else fail('Shell source', '/bin/sh not found');
-    return;
-  }
-  const explicit = process.env.CLAUDE_CODE_SHELL;
-  if (explicit) {
-    const stem = basename(explicit).toLowerCase().replace(/\.exe$/, '');
-    if (stem !== 'pwsh' && stem !== 'powershell') {
-      warn('Shell source', `CLAUDE_CODE_SHELL is ignored on Windows unless it is PowerShell/pwsh: ${explicit}`);
-    } else if (existsSync(explicit)) {
-      ok('Shell source', `PowerShell: ${explicit}`);
-      return;
-    } else {
-      warn('Shell source', `CLAUDE_CODE_SHELL set but not found: ${explicit}`);
-    }
-  }
-  const candidates = [
-    join(process.env.ProgramFiles || 'C:\\Program Files', 'PowerShell', '7', 'pwsh.exe'),
-    join(process.env.SystemRoot || process.env.WINDIR || 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe'),
-  ];
-  for (const c of candidates) {
-    if (existsSync(c)) { ok('Shell source', `PowerShell: ${c}`); return; }
-  }
-  const r = spawnSync('where.exe', ['powershell.exe'], { encoding: 'utf8' });
-  const found = (r.stdout || '').split(/\r?\n/).map(l => l.trim()).find(l => l && existsSync(l));
-  if (found) ok('Shell source', `PowerShell: ${found}`);
-  else fail('Shell source', 'PowerShell not found');
-})();
-
-// ---------------------------------------------------------------------------
-// Check 4: Active supervisor
-// ---------------------------------------------------------------------------
-(function checkSupervisor() {
-  const instancePath = join(tmpdir(), 'mixdog', 'active-instance.json');
-  if (!existsSync(instancePath)) {
-    warn('Supervisor', 'active-instance.json not found - supervisor not running');
-    return;
-  }
-  const inst = readJson(instancePath);
-  if (!inst) { warn('Supervisor', 'active-instance.json unreadable or invalid JSON'); return; }
-  const pid = getActiveOwnerPid(inst);
-  if (!pid) { warn('Supervisor', 'owner PID missing in active-instance.json'); return; }
-  let alive = false;
-  try { process.kill(pid, 0); alive = true; } catch { alive = false; }
-  if (!alive) { warn('Supervisor', `ownerPid=${pid} is not alive`); return; }
-  const ready = inst.backendReady === true;
-  if (ready) ok('Supervisor', `ownerPid=${pid} alive, backendReady=true`);
-  else warn('Supervisor', `ownerPid=${pid} alive but backendReady=${inst.backendReady} — permission hooks may be fail-open (bypassed) until the daemon is ready`);
-})();
-
-// ---------------------------------------------------------------------------
-// Check 4.5: Hook IPC pipe reachability (fail-open warning)
-// ---------------------------------------------------------------------------
-// Hooks are fail-open by design: if the daemon/pipe is down, the shim exits 0
-// and the server emits "null", so nothing is blocked. Surface that clearly so
-// an operator knows permission hooks are bypassed until the daemon is restored.
-// See SECURITY.md "Fail-open Hook Model".
-await (async function checkHookPipe() {
-  let pipePath;
-  try {
-    pipePath = require('../lib/hook-pipe-path.cjs')();
-  } catch (err) {
-    warn('Hook pipe', `cannot resolve pipe path: ${err?.message || String(err)}`);
-    return;
-  }
-  const reachable = await new Promise((resolve) => {
-    let done = false;
-    const finish = (val) => { if (!done) { done = true; resolve(val); } };
-    let sock;
-    try {
-      sock = createConnection(pipePath);
-    } catch { finish(false); return; }
-    const timer = setTimeout(() => { try { sock.destroy(); } catch {} finish(false); }, 1000);
-    sock.once('connect', () => { clearTimeout(timer); try { sock.destroy(); } catch {} finish(true); });
-    sock.once('error', () => { clearTimeout(timer); try { sock.destroy(); } catch {} finish(false); });
-  });
-  if (reachable) {
-    ok('Hook pipe', `reachable at ${pipePath}`);
-  } else {
-    warn('Hook pipe', `unreachable at ${pipePath} — permission hooks are FAIL-OPEN (bypassed); restart the daemon to restore them`);
-  }
-})();
-
-// ---------------------------------------------------------------------------
-// Check 5: Plugin DATA dir - required config files
-// ---------------------------------------------------------------------------
-(function checkDataDir() {
-  const configFile   = join(PLUGIN_DATA, 'mixdog-config.json');
-  const workflowFile = join(PLUGIN_DATA, 'user-workflow.json');
-  const missingFiles = [];
-  if (!existsSync(configFile))   missingFiles.push('mixdog-config.json');
-  if (!existsSync(workflowFile)) missingFiles.push('user-workflow.json');
-  if (missingFiles.length === 0) ok('Plugin DATA dir', PLUGIN_DATA);
-  else warn('Plugin DATA dir', `missing: ${missingFiles.join(', ')} in ${PLUGIN_DATA}`);
-})();
-
-// ---------------------------------------------------------------------------
-// Check 6: Cache layout - ~/.claude/plugins/cache/trib-plugin/mixdog/<ver>/
-// ---------------------------------------------------------------------------
-(function checkCacheLayout() {
-  const cacheBase = join(claudeConfigBase(), 'plugins', 'cache', 'trib-plugin', 'mixdog');
-  if (!existsSync(cacheBase)) {
-    warn('Cache layout', `cache dir not found: ${cacheBase}`);
-    return;
-  }
-  let entries;
-  try { entries = readdirSync(cacheBase, { withFileTypes: true }); } catch {
-    warn('Cache layout', `cannot read ${cacheBase}`);
-    return;
-  }
-  const verDirs = entries.filter(e => e.isDirectory());
-  if (verDirs.length === 0) { warn('Cache layout', 'no version directories found'); return; }
-
-  const THRESHOLD = 100 * 1024 * 1024; // 100 MB
-  let anyFail = false;
-  for (const vd of verDirs) {
-    const verPath = join(cacheBase, vd.name);
-    const nmPath  = join(verPath, 'node_modules');
-    if (!existsSync(nmPath)) {
-      ok(`Cache ${vd.name}`, 'no node_modules');
-      continue;
-    }
-    let isJunction = false;
-    try {
-      const lst = lstatSync(nmPath);
-      isJunction = lst.isSymbolicLink();
-    } catch { /* treat as real */ }
-    const kind = isJunction ? 'junction/symlink' : 'real';
-    if (isJunction) {
-      ok(`Cache ${vd.name}`, `node_modules=${kind}`);
-    } else {
-      const sz = dirSize(nmPath, THRESHOLD + 1);
-      const mb = toMB(sz);
-      if (sz > THRESHOLD) {
-        warn(`Cache ${vd.name}`, `node_modules=${kind} ${mb} MB (> 100 MB - regression risk)`);
-        anyFail = true;
-      } else {
-        ok(`Cache ${vd.name}`, `node_modules=${kind} ${mb} MB`);
-      }
-    }
-  }
-})();
-
-// ---------------------------------------------------------------------------
-// Check 7: Voice runtime
-// ---------------------------------------------------------------------------
-await (async function checkVoiceRuntime() {
-  try {
-    const { resolveVoiceRuntime } = await import('../src/channels/lib/voice-runtime-fetcher.mjs');
-    const runtime = resolveVoiceRuntime(PLUGIN_DATA);
-    if (runtime?.installed) {
-      ok('Voice runtime', `${runtime.kind}: whisper=${basename(runtime.whisperCmd || '')}, ffmpeg=${basename(runtime.ffmpegPath || '')}, model=${runtime.modelName || basename(runtime.modelPath || '')}`);
-      return;
-    }
-    const missing = [
-      runtime?.binary ? null : 'binary',
-      runtime?.model ? null : 'model',
-      runtime?.ffmpeg ? null : 'ffmpeg',
-    ].filter(Boolean);
-    warn('Voice runtime', `not installed - missing: ${missing.join(', ')}`);
-  } catch (err) {
-    warn('Voice runtime', `check failed: ${err?.message || String(err)}`);
-  }
-})();
-
-// ---------------------------------------------------------------------------
-// Check 8: Required npm dependencies
-// ---------------------------------------------------------------------------
-(function checkDeps() {
-  const required = [
-    '@modelcontextprotocol/sdk',
-    'zod',
-    'openai',
-    'pg',
-  ];
-  // Search in PLUGIN_ROOT/node_modules (typical) and parent cache node_modules.
-  const nmCandidates = [
-    join(PLUGIN_ROOT, 'node_modules'),
-    join(PLUGIN_ROOT, '..', 'node_modules'),
-  ];
-  const missing = [];
-  for (const dep of required) {
-    const found = nmCandidates.some(nm => existsSync(join(nm, dep)));
-    if (!found) missing.push(dep);
-  }
-  if (missing.length === 0) ok('Required deps', required.join(', '));
-  else fail('Required deps', `missing: ${missing.join(', ')}`);
-})();
-
-// ---------------------------------------------------------------------------
-// Check 9.5: Cache / sidecar storage sizes
-// ---------------------------------------------------------------------------
-(function checkCacheStorage() {
-  const targets = [
-    { p: join(PLUGIN_DATA, 'code-graph-cache.json'), label: 'code-graph-cache.json' },
-    { p: join(PLUGIN_DATA, 'code-graph-cache'),      label: 'code-graph-cache/' },
-    { p: join(PLUGIN_DATA, 'sidecars'),              label: 'sidecars/' },
-    { p: join(PLUGIN_DATA, 'sessions-archive'),      label: 'sessions-archive/' },
-    { p: join(PLUGIN_DATA, 'shell-output'),          label: 'shell-output/' },
-    { p: join(PLUGIN_DATA, 'shell-jobs'),            label: 'shell-jobs/' },
-  ];
-  const WARN_THRESHOLD = 100 * 1024 * 1024; // 100 MB per target
-  const lines = [];
-  const oversized = [];
-  for (const { p, label } of targets) {
-    if (!existsSync(p)) continue;
-    let sz = 0;
-    try {
-      const st = statSync(p);
-      sz = st.isDirectory() ? dirSize(p, WARN_THRESHOLD * 2 + 1) : st.size;
-    } catch { continue; }
-    if (sz === 0) continue;
-    const mb = toMB(sz);
-    lines.push(`${label}=${mb} MB`);
-    if (sz > WARN_THRESHOLD) oversized.push(`${label} ${mb} MB`);
-  }
-  if (lines.length === 0) ok('Cache storage', 'no cache artefacts');
-  else if (oversized.length > 0) warn('Cache storage', `oversized (> 100 MB): ${oversized.join(', ')} | all: ${lines.join(', ')}`);
-  else ok('Cache storage', lines.join(', '));
-})();
-
-// ---------------------------------------------------------------------------
-// Check 9: Log file sizes
-// ---------------------------------------------------------------------------
-(function checkLogs() {
-  const WARN_THRESHOLD = 50 * 1024 * 1024; // 50 MB
-  let logEntries;
-  try {
-    logEntries = readdirSync(PLUGIN_DATA, { withFileTypes: true })
-      .filter(e => e.isFile() && e.name.endsWith('.log'));
-  } catch {
-    ok('Logs', 'data dir not yet created or no log files');
-    return;
-  }
-  if (logEntries.length === 0) { ok('Logs', 'no log files'); return; }
-  const large = [];
-  const lines = [];
-  for (const e of logEntries) {
-    const p = join(PLUGIN_DATA, e.name);
-    let sz = 0;
-    try { sz = statSync(p).size; } catch { /* skip */ }
-    const mb = toMB(sz);
-    lines.push({ name: e.name, size: sz, text: `${e.name}=${mb} MB` });
-    if (sz > WARN_THRESHOLD) large.push(`${e.name} ${mb} MB`);
-  }
-  if (large.length > 0) warn('Logs', `oversized (> 50 MB): ${large.join(', ')}`);
-  else if (lines.length > 300) warn('Logs', `${lines.length} files (> 300) — likely stale per-PID log accumulation`);
-  else {
-    lines.sort((a, b) => b.size - a.size);
-    const shown = lines.slice(0, 8).map(e => e.text);
-    const suffix = lines.length > shown.length ? `, +${lines.length - shown.length} more` : '';
-    ok('Logs', `${lines.length} files; largest: ${shown.join(', ')}${suffix}`);
-  }
-})();
-
-// ---------------------------------------------------------------------------
-// Check 9.7: Memory DB size (Postgres pgdata)
-// ---------------------------------------------------------------------------
-(function checkMemoryDbSize() {
-  const pgdata = join(PLUGIN_DATA, 'pgdata');
-  if (!existsSync(pgdata)) { ok('Memory DB size', 'pgdata not found'); return; }
-  const WARN_THRESHOLD = 1024 * 1024 * 1024; // 1 GB
-  let total = 0;
-  try { total = dirSize(pgdata); } catch { warn('Memory DB size', `cannot read ${pgdata}`); return; }
-  const baseBytes = existsSync(join(pgdata, 'base')) ? dirSize(join(pgdata, 'base')) : 0;
-  const walBytes  = existsSync(join(pgdata, 'pg_wal')) ? dirSize(join(pgdata, 'pg_wal')) : 0;
-  const detail = `pgdata ${toMB(total)} MB (base ${toMB(baseBytes)}, wal ${toMB(walBytes)})`;
-  if (total >= WARN_THRESHOLD) warn('Memory DB size', `${detail} — >= 1 GB, review memory retention`);
-  else ok('Memory DB size', detail);
-})();
-
-// ---------------------------------------------------------------------------
-// Print report
-// ---------------------------------------------------------------------------
-const SEP = '-'.repeat(62);
-console.log('');
-console.log('mixdog doctor');
-console.log(SEP);
-for (const { status, label, detail } of rows) {
-  const tag = `[${status}]`.padEnd(6);
-  console.log(`${tag} ${label}${detail ? ': ' + detail : ''}`);
-}
-console.log(SEP);
-console.log(`${okCount} OK  ${warnCount} WARN  ${failCount} FAIL`);
-console.log('');
-
-// ---------------------------------------------------------------------------
-// --setup: launch setup UI after report
-// ---------------------------------------------------------------------------
-if (isSetup) {
-  const launchScript = join(PLUGIN_ROOT, 'setup', 'launch.mjs');
-  if (!existsSync(launchScript)) {
-    console.error(`[FAIL] setup launcher not found: ${launchScript}`);
-    process.exit(1);
-  }
-  console.log('Launching setup UI...');
-  const child = spawn(process.execPath, [launchScript], {
-    detached: true,
-    stdio: 'ignore',
-    cwd: PLUGIN_ROOT,
-    windowsHide: true,
-    env: {
-      ...process.env,
-      CLAUDE_PLUGIN_ROOT: PLUGIN_ROOT,
-      CLAUDE_PLUGIN_DATA: PLUGIN_DATA,
-    },
-  });
-  child.unref();
-}
-
-process.exit(failCount > 0 ? 1 : 0);

package/scripts/edit-normalize-fuzz.mjs

@@ -1,130 +0,0 @@
-// Fuzz test: _findActualString invariants under random drift.
-//
-// Approach: pick a random substring of randomly-generated content, apply
-// one of several deterministic drift transforms (NFC/NFD swap, codepoint
-// fold variants, trailing-whitespace injection, indent shift, line-end
-// drop) to the substring, and feed it through _findActualString.
-//
-// Invariants checked when the matcher returns a non-null slice:
-//   • returned string IS a substring of `content` (content.includes(slice))
-//   • content.indexOf(slice) finds a position (no synthesised bytes)
-//   • slice.normalize('NFD').indexOf(searchAfterDriftNfd) === 0 or close
-//     — the matched slice's NFD form contains the search's NFD form at
-//     the start, confirming the matcher did not pick something unrelated
-//
-// Seed: a deterministic LCG so the same DEV_FUZZ_SEED env reproduces
-// failures bit-for-bit.
-
-import { findActualString as _findActualString } from '../src/agent/orchestrator/tools/edit-normalize.mjs';
-
-const ITERATIONS = Number(process.env.DEV_FUZZ_ITER) || 1000;
-const SEED = Number(process.env.DEV_FUZZ_SEED) || 0xC0DE1234;
-
-// LCG PRNG for reproducible fuzz.
-let _state = SEED >>> 0;
-function rand() {
-    _state = (_state * 1664525 + 1013904223) >>> 0;
-    return _state / 0x100000000;
-}
-function randInt(min, max) {
-    return min + Math.floor(rand() * (max - min + 1));
-}
-function pick(arr) {
-    return arr[Math.floor(rand() * arr.length)];
-}
-
-const ASCII = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_(){}[],.;:!? \t\n';
-const HANGUL = '가나다라마바사아자차카타파하각간갈감갑값나라말사람';
-const FOLD_VARIANTS = '     　‐–—―−－‘’“”＂＇';
-
-function randomChar() {
-    const r = rand();
-    if (r < 0.70) return ASCII[Math.floor(rand() * ASCII.length)];
-    if (r < 0.85) return HANGUL[Math.floor(rand() * HANGUL.length)];
-    return FOLD_VARIANTS[Math.floor(rand() * FOLD_VARIANTS.length)];
-}
-
-function randomContent() {
-    const len = randInt(80, 300);
-    let out = '';
-    for (let i = 0; i < len; i++) out += randomChar();
-    return out;
-}
-
-// Drift transforms — each takes a slice and produces a possibly different
-// representation. The matcher must still locate the original slice.
-const drifts = [
-    (s) => s,                                              // identity
-    (s) => s.normalize('NFC'),                             // NFC
-    (s) => s.normalize('NFD'),                             // NFD
-    (s) => s.replace(/-/g, '—'),                       // hyphen → em dash
-    (s) => s.replace(/'/g, '‘'),                       // straight → curly single
-    (s) => s.replace(/"/g, '“'),                       // straight → curly double
-    (s) => s.replace(/ /g, ' '),                       // space → NBSP
-    (s) => s.replace(/—/g, '-'),                       // em dash → hyphen
-    (s) => s.replace(/‘/g, "'"),                       // curly → straight
-    (s) => s.replace(/“/g, '"'),                       // curly → straight
-    (s) => s.replace(/ /g, ' '),                       // NBSP → space
-    (s) => s.split('\n').map((l) => l + '   ').join('\n'),  // add trailing spaces
-    (s) => s.split('\n').map((l) => l.replace(/ +$/, '')).join('\n'), // strip trailing
-    (s) => s.split('\n').map((l) => '  ' + l).join('\n'),   // add leading indent
-    (s) => s.split('\n').map((l) => l.replace(/^ +/, '')).join('\n'), // strip leading
-];
-
-let matched = 0;
-let unmatched = 0;
-let invariantFails = 0;
-const failSamples = [];
-
-for (let i = 0; i < ITERATIONS; i++) {
-    const content = randomContent();
-    const start = randInt(0, Math.max(0, content.length - 10));
-    const len = randInt(3, Math.min(60, content.length - start));
-    const original = content.substring(start, start + len);
-    if (original.length < 2) continue;
-    const drift = pick(drifts);
-    const search = drift(original);
-    const info = {};
-    let result;
-    try {
-        result = _findActualString(content, search, info);
-    } catch (err) {
-        invariantFails++;
-        failSamples.push({ reason: 'throw', err: String(err), content, search });
-        if (failSamples.length > 5) break;
-        continue;
-    }
-    if (result === null) {
-        unmatched++;
-        continue;
-    }
-    matched++;
-    if (typeof result !== 'string') {
-        invariantFails++;
-        failSamples.push({ reason: 'non-string', result, content, search });
-        if (failSamples.length > 5) break;
-        continue;
-    }
-    if (!content.includes(result)) {
-        invariantFails++;
-        failSamples.push({ reason: 'not-substring', result, content, search });
-        if (failSamples.length > 5) break;
-    }
-}
-
-console.log(`edit-normalize-fuzz: ${ITERATIONS} iterations (seed=0x${SEED.toString(16).toUpperCase()})`);
-console.log(`  matched:         ${matched}`);
-console.log(`  unmatched:       ${unmatched}`);
-console.log(`  invariant fails: ${invariantFails}`);
-
-if (invariantFails > 0) {
-    console.error('\nFAIL samples:');
-    for (const s of failSamples) {
-        console.error(`  reason: ${s.reason}`);
-        console.error(`    content: ${JSON.stringify(s.content).slice(0, 200)}`);
-        console.error(`    search:  ${JSON.stringify(s.search).slice(0, 200)}`);
-        if (s.result !== undefined) console.error(`    result:  ${JSON.stringify(s.result).slice(0, 200)}`);
-        if (s.err) console.error(`    err:     ${s.err}`);
-    }
-    process.exit(1);
-}