@bongos/core 1.19.334 → 1.19.336

package/scripts/snapshots/render-world.mjs

@@ -1,322 +0,0 @@
-// scripts/snapshots/render-world.mjs
-//
-// Server-side world compositor. Walks INITIAL_MAP.ground + INITIAL_MAP.objects,
-// applies the same autotile picker logic as the browser client, and composites
-// all tile PNGs into a single top-down PNG for the public status dashboard.
-//
-// Snapshots are EVENT-BASED, not daily: one image per graphics-changing commit.
-// The manifest is a chronological list of `{ id, sha, timestamp, label, image }`.
-//
-// CLI flags (all optional — defaults to "now, no sha"):
-//   --sha <hash>          Full commit sha; first 7 chars become the id + filename.
-//   --timestamp <iso>     ISO 8601 timestamp for the snapshot. Default: now.
-//   --label "<text>"      Caption shown under the snapshot in the timeline.
-//   --id <slug>           Override the filename id. Default: short sha or date.
-//   --out <path>          Override the output PNG path. Default: <id>.png.
-//   --no-manifest         Render the PNG but skip updating manifest.json.
-//
-// Examples:
-//   node scripts/snapshots/render-world.mjs                           # quick "now" snapshot
-//   node scripts/snapshots/render-world.mjs --sha 5354daa1c1...       # tagged commit
-//   node scripts/snapshots/render-world.mjs --id pre-grass --label "Before the grass turned green"
-
-import { createRequire } from 'node:module';
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
-import { resolve, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import sharp from 'sharp';
-
-// ESM imports — these resolve relative to the modules themselves, so nested
-// imports (terrain.js → autotile.js) work correctly.
-import { selectBlob47, selectPath16 } from '../../public/game/world/autotile.js';
-import { TERRAIN_RENDER, OBJECT_RENDER, neighborsAt } from '../../public/game/world/terrain.js';
-
-// CJS map + terrain live in src/ (server-side). Load via createRequire.
-const require = createRequire(import.meta.url);
-const { INITIAL_MAP, WORLD_COLS, WORLD_ROWS } = require('../../src/world/map.js');
-
-// Canonical NPC + player positions. These mirror what the game actually
-// renders into the world so the snapshot matches what a player sees.
-const VENDOR_GRID = { x: 13, y: 9 };
-const PLAYER_START_GRID = { x: 10, y: 10 };
-
-// Preferred sprite game_keys per character. We try in order; first match
-// in the manifest wins. This lets the renderer stay correct across the
-// commits where the vendor went idle-only → idle/talk family, etc.
-const VENDOR_SPRITE_KEYS = ['vendor_idle', 'vendor', 'vendor_hyperion_idle', 'vendor_hyperion'];
-const PLAYER_SPRITE_KEYS = ['player_down', 'player', 'player_down_idle'];
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(HERE, '../..');
-
-const TILE_SIZE = 32;
-const MANIFEST_PATH = resolve(ROOT, 'public/assets/tiles/manifest.json');
-// The status surface moved to modules/status-ui/public/ in BV1.R84 (task 1635).
-const SNAPSHOTS_DIR = resolve(ROOT, 'modules/status-ui/public/snapshots');
-const SNAPSHOTS_MANIFEST = resolve(SNAPSHOTS_DIR, 'manifest.json');
-
-// ---------- arg parsing ----------------------------------------------------
-
-function parseArgs(argv) {
-  const args = {};
-  for (let i = 2; i < argv.length; i++) {
-    const a = argv[i];
-    if (a === '--no-manifest') { args.noManifest = true; continue; }
-    if (a.startsWith('--')) {
-      const key = a.slice(2);
-      const val = argv[i + 1];
-      args[key] = val;
-      i++;
-    }
-  }
-  return args;
-}
-
-// ---------- tile path resolution ------------------------------------------
-
-function loadTileManifest() {
-  return JSON.parse(readFileSync(MANIFEST_PATH, 'utf8'));
-}
-
-// game_key → absolute path to the PNG file. Walks BOTH tiles and sprites
-// so character art (vendor, player) can be looked up the same way.
-//
-// Also indexes by file_id (the manifest key) as a fallback, because older
-// commits (notably 6abe01c) shipped the sprite PNGs with game_key=null —
-// the canonical name on those is the file id (`vendor_hyperion`).
-function buildGameKeyMap(manifest) {
-  const m = new Map();
-  for (const bucket of ['tiles', 'sprites']) {
-    const entries = manifest[bucket] || {};
-    for (const [fileId, entry] of Object.entries(entries)) {
-      if (!entry.path) continue;
-      const abs = resolve(ROOT, 'public' + entry.path);
-      if (entry.game_key && !m.has(entry.game_key)) m.set(entry.game_key, abs);
-      if (!m.has(fileId)) m.set(fileId, abs);
-    }
-  }
-  return m;
-}
-
-// Try a list of game_keys; return the first one that resolves to an
-// existing PNG. Used for character sprites whose game_key changed across
-// commits (vendor → vendor_idle).
-function firstExistingSprite(gameKeyMap, keys) {
-  for (const k of keys) {
-    const p = gameKeyMap.get(k);
-    if (p && existsSync(p)) return p;
-  }
-  return null;
-}
-
-// Returns an absolute path for an autotile family tile by index.
-function buildFamilyResolver(manifest) {
-  const families = manifest.autotile_families || {};
-  return function resolveFamilyTile(family, idx) {
-    const fam = families[family];
-    if (!fam || !fam.path_template) return null;
-    const relPath = fam.path_template.replace('{idx:02}', String(idx).padStart(2, '0'));
-    return resolve(ROOT, 'public' + relPath);
-  };
-}
-
-// ---------- per-cell tile pickers -----------------------------------------
-
-function groundTilePath(x, y, ground, gameKeyMap, familyResolver) {
-  const terrainId = ground[y][x];
-  const cfg = TERRAIN_RENDER[terrainId];
-  if (!cfg) return gameKeyMap.get(terrainId) || null;
-
-  // Short-form { tile: 'X' } (pre-ADR-0013 commits) means single-tile.
-  if (cfg.strategy === 'single' || (!cfg.strategy && cfg.tile)) {
-    return gameKeyMap.get(cfg.tile) || null;
-  }
-
-  const neighbors = neighborsAt(ground, x, y);
-  let idx;
-  if (cfg.strategy === 'blob47') {
-    idx = selectBlob47(terrainId, neighbors);
-  } else if (cfg.strategy === 'path16') {
-    idx = selectPath16({
-      N: neighbors.N === terrainId ? 1 : 0,
-      W: neighbors.W === terrainId ? 1 : 0,
-      E: neighbors.E === terrainId ? 1 : 0,
-      S: neighbors.S === terrainId ? 1 : 0,
-    });
-  } else {
-    return gameKeyMap.get(cfg.fallbackTile) || null;
-  }
-
-  const p = familyResolver(cfg.family, idx);
-  if (p && existsSync(p)) return p;
-  return gameKeyMap.get(cfg.fallbackTile) || null;
-}
-
-function objectTilePath(x, y, objects, gameKeyMap, familyResolver) {
-  const objId = objects[y][x];
-  if (!objId) return null;
-  const cfg = OBJECT_RENDER[objId];
-  if (!cfg) return null;
-
-  // Short-form { tile: 'X' } (pre-ADR-0013 commits) means single-tile.
-  if (cfg.strategy === 'single' || (!cfg.strategy && cfg.tile)) {
-    return gameKeyMap.get(cfg.tile) || null;
-  }
-
-  const neighbors = neighborsAt(objects, x, y);
-  let idx;
-  if (cfg.strategy === 'blob47') {
-    idx = selectBlob47(objId, neighbors);
-  } else if (cfg.strategy === 'path16') {
-    idx = selectPath16({
-      N: neighbors.N === objId ? 1 : 0,
-      W: neighbors.W === objId ? 1 : 0,
-      E: neighbors.E === objId ? 1 : 0,
-      S: neighbors.S === objId ? 1 : 0,
-    });
-  } else {
-    return gameKeyMap.get(cfg.fallbackTile) || null;
-  }
-
-  const p = familyResolver(cfg.family, idx);
-  if (p && existsSync(p)) return p;
-  return gameKeyMap.get(cfg.fallbackTile) || null;
-}
-
-// ---------- compositing ----------------------------------------------------
-
-async function renderWorld(outPath) {
-  const manifest = loadTileManifest();
-  const gameKeyMap = buildGameKeyMap(manifest);
-  const familyResolver = buildFamilyResolver(manifest);
-
-  const { ground, objects } = INITIAL_MAP;
-  const width  = WORLD_COLS * TILE_SIZE;
-  const height = WORLD_ROWS * TILE_SIZE;
-
-  const composites = [];
-
-  // Ground layer first, then object layer on top.
-  for (let pass = 0; pass < 2; pass++) {
-    for (let y = 0; y < WORLD_ROWS; y++) {
-      for (let x = 0; x < WORLD_COLS; x++) {
-        const tilePath = pass === 0
-          ? groundTilePath(x, y, ground, gameKeyMap, familyResolver)
-          : objectTilePath(x, y, objects, gameKeyMap, familyResolver);
-        if (!tilePath || !existsSync(tilePath)) continue;
-        composites.push({
-          input: tilePath,
-          left: x * TILE_SIZE,
-          top:  y * TILE_SIZE,
-          blend: 'over',
-        });
-      }
-    }
-  }
-
-  // NPCs / player — composited last so they paint over ground + objects.
-  // We deliberately stay silent when a sprite is missing (older commits
-  // before the art existed) rather than fail the render.
-  const vendorPath = firstExistingSprite(gameKeyMap, VENDOR_SPRITE_KEYS);
-  if (vendorPath) {
-    composites.push({
-      input: vendorPath,
-      left: VENDOR_GRID.x * TILE_SIZE,
-      top:  VENDOR_GRID.y * TILE_SIZE,
-      blend: 'over',
-    });
-  }
-  const playerPath = firstExistingSprite(gameKeyMap, PLAYER_SPRITE_KEYS);
-  if (playerPath) {
-    composites.push({
-      input: playerPath,
-      left: PLAYER_START_GRID.x * TILE_SIZE,
-      top:  PLAYER_START_GRID.y * TILE_SIZE,
-      blend: 'over',
-    });
-  }
-
-  mkdirSync(dirname(outPath), { recursive: true });
-
-  await sharp({
-    create: {
-      width,
-      height,
-      channels: 3,
-      background: { r: 0, g: 0, b: 0 },
-    },
-  })
-    .composite(composites)
-    .png({ compressionLevel: 9 })
-    .toFile(outPath);
-
-  console.log(`[snapshot] wrote ${outPath} (${width}×${height})`);
-  return outPath;
-}
-
-// ---------- manifest -------------------------------------------------------
-
-// New manifest shape:
-//   { version: 2, snapshots: [{ id, sha?, timestamp, label?, image }, ...] }
-// Backwards-compat: if we encounter the v1 `{ dates: [...] }` shape we migrate
-// the entries (with no sha / label) by date-stamp.
-function readSnapshotManifest() {
-  if (!existsSync(SNAPSHOTS_MANIFEST)) return { version: 2, snapshots: [] };
-  let data;
-  try {
-    data = JSON.parse(readFileSync(SNAPSHOTS_MANIFEST, 'utf8'));
-  } catch {
-    return { version: 2, snapshots: [] };
-  }
-  if (Array.isArray(data.snapshots)) return data; // already v2
-  if (Array.isArray(data.dates)) {
-    const snapshots = data.dates.map((d) => ({
-      id: d,
-      timestamp: `${d}T00:00:00Z`,
-      image: `${d}.png`,
-    }));
-    return { version: 2, snapshots };
-  }
-  return { version: 2, snapshots: [] };
-}
-
-function upsertSnapshot(manifest, entry) {
-  const idx = manifest.snapshots.findIndex((s) => s.id === entry.id);
-  if (idx >= 0) {
-    manifest.snapshots[idx] = { ...manifest.snapshots[idx], ...entry };
-  } else {
-    manifest.snapshots.push(entry);
-  }
-  manifest.snapshots.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-  manifest.version = 2;
-  return manifest;
-}
-
-function writeSnapshotManifest(manifest) {
-  writeFileSync(SNAPSHOTS_MANIFEST, JSON.stringify(manifest, null, 2) + '\n');
-}
-
-// ---------- main -----------------------------------------------------------
-
-const args = parseArgs(process.argv);
-
-const sha = args.sha || null;
-const shortSha = sha ? sha.slice(0, 7) : null;
-const timestamp = args.timestamp || new Date().toISOString();
-const id = args.id || shortSha || timestamp.slice(0, 10);
-const image = args.out ? args.out : `${id}.png`;
-const outPath = resolve(SNAPSHOTS_DIR, image);
-
-await renderWorld(outPath);
-
-if (!args.noManifest) {
-  const manifest = readSnapshotManifest();
-  const entry = { id, timestamp, image };
-  if (sha) entry.sha = sha;
-  if (args.label) entry.label = args.label;
-  upsertSnapshot(manifest, entry);
-  writeSnapshotManifest(manifest);
-  console.log(`[snapshot] manifest updated (${manifest.snapshots.length} entries)`);
-}
-
-console.log(`[snapshot] done — id=${id}${sha ? ` sha=${shortSha}` : ''}`);

package/tests/anti_grid.mjs

@@ -1,89 +0,0 @@
-// tests/anti_grid.mjs
-//
-// Smoke wrapper for the anti-grid evaluation harness (task D.4-T5).
-//
-// Shells out to art/pipeline/anti_grid_eval.py, which renders a 16x16 cell
-// expanse of each autotile family, runs 2D autocorrelation, and computes
-// the peak-to-mean ratio at grid-aligned lags vs non-grid lags. A clean,
-// seam-free family scores near 1.0; one with a visible 32-px periodicity
-// scores well above the absolute target of 1.5.
-//
-// The Python tool has two modes:
-//   - regression-only (default) -- fail if any ratio > baseline * 1.30.
-//     This is what this smoke test checks. It catches future regressions
-//     where a tile or compositor change reintroduces a grid pattern.
-//   - --strict -- also fail if ratio >= 1.5 (the task spec's absolute
-//     target). New families may not meet this yet; the smoke test does
-//     NOT run strict by default so it doesn't block builds on tiles that
-//     are working-as-currently-generated.
-//
-// Run:  node tests/anti_grid.mjs
-//
-// Exit 0 = all checks passed; 1 = regression detected; 2 = setup error
-// (Python missing, no tiles built, etc.).
-
-import { spawnSync } from 'node:child_process';
-import { readFileSync, existsSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const REPO = resolve(HERE, '..');
-const EVAL_SCRIPT = resolve(REPO, 'art', 'pipeline', 'anti_grid_eval.py');
-const BASELINES = resolve(REPO, 'art', 'iterations', 'anti_grid_baselines.json');
-
-function fail(msg, code = 1) {
-  console.error(`\n[anti-grid] ${msg}`);
-  process.exit(code);
-}
-
-if (!existsSync(EVAL_SCRIPT)) {
-  fail(`evaluator missing: ${EVAL_SCRIPT}`, 2);
-}
-if (!existsSync(BASELINES)) {
-  fail(
-    `baselines missing: ${BASELINES}\n` +
-    `Run: python3 art/pipeline/anti_grid_eval.py --update-baselines`,
-    2
-  );
-}
-
-// Sanity check on the baselines file -- make sure it actually has entries.
-let baselines;
-try {
-  baselines = JSON.parse(readFileSync(BASELINES, 'utf8'));
-} catch (e) {
-  fail(`cannot parse baselines: ${e.message}`, 2);
-}
-const families = Object.keys(baselines).filter((k) => k !== '_meta');
-if (families.length === 0) {
-  fail('baselines file has no families recorded', 2);
-}
-
-console.log(`[anti-grid] checking ${families.length} families against baselines: ` +
-            families.join(', '));
-
-const result = spawnSync('python3', [EVAL_SCRIPT, '-v'], {
-  cwd: REPO,
-  encoding: 'utf8',
-  stdio: ['ignore', 'pipe', 'pipe'],
-});
-
-if (result.error) {
-  fail(`failed to spawn python3: ${result.error.message}`, 2);
-}
-
-// Forward Python output so any failures are immediately visible.
-if (result.stdout) process.stdout.write(result.stdout);
-if (result.stderr) process.stderr.write(result.stderr);
-
-const code = result.status ?? 1;
-if (code === 0) {
-  console.log('\n[anti-grid] all families within baseline tolerance -- ok');
-  process.exit(0);
-}
-if (code === 2) {
-  fail('evaluator reported a setup error (see stderr above)', 2);
-}
-fail('regression detected: one or more families scored ' +
-     `worse than baseline * 1.30. See output above.`, 1);

package/tests/autotile_variants.mjs

@@ -1,256 +0,0 @@
-// tests/autotile_variants.mjs
-//
-// GDS #144 (D.4-T4): Edge-variant matching for boundary tiles.
-//
-// D.4-T1 introduced multi-variant interior primitives so the all-interior
-// blob47 tile (index 46) doesn't visibly repeat. Each variant is produced
-// by sampling the seamless interior primitive at a different offset — which
-// leaves variants with slightly different outermost-pixel rings. Boundary
-// tiles (concave / convex / horiz / vert patches) only encode the canonical
-// interior's edge pixels, so a variant whose edges drift can produce a
-// 1-pixel seam against any boundary tile.
-//
-// Fix (autotile_orchestrator.py::_force_edge_match_to_canonical): after the
-// compositor returns its tile list, overwrite each variant's outermost-pixel
-// ring (top row, bottom row, left column, right column) with the canonical
-// all-interior tile's. The interior pixel-noise keeps the visual variety;
-// the edges become byte-identical to the canonical so the variant is seam-
-// compatible everywhere the canonical is.
-//
-// This test:
-//   1. Drives a tiny Python helper that builds a deterministic synthetic
-//      interior primitive (no AI calls — no cost), runs the orchestrator's
-//      compose-and-edge-fix flow, and saves the canonical + variants to a
-//      tmp directory as PNGs.
-//   2. Loads each PNG with sharp.
-//   3. Asserts each variant's edge ring equals the canonical's, byte-for-byte.
-//   4. Asserts the variant interiors are NOT identical to the canonical
-//      (otherwise the variants would be useless — proves the fix preserved
-//      the variety inside the ring).
-//
-// Run:  node tests/autotile_variants.mjs
-
-import { strict as assert } from 'node:assert';
-import { spawnSync } from 'node:child_process';
-import { mkdtempSync, rmSync, existsSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import sharp from 'sharp';
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const REPO_ROOT = resolve(HERE, '..');
-
-let passed = 0;
-let failed = 0;
-function test(name, fn) {
-  try {
-    fn();
-    console.log(`  ok  ${name}`);
-    passed++;
-  } catch (e) {
-    console.error(`  FAIL ${name}`);
-    console.error(`       ${e.message}`);
-    failed++;
-  }
-}
-
-// Python helper: build a synthetic 32x32 interior primitive whose pixels
-// vary across the texture (so variants produced by offset-cropping actually
-// differ), compose blob47-with-variants, apply the edge-fix step, save PNGs.
-//
-// Inlined here (rather than as a separate file) so this test owns its
-// fixture generation end-to-end — touches[] is just orchestrator + this
-// test file.
-const PY_FIXTURE = `
-import sys, os
-from pathlib import Path
-import numpy as np
-from PIL import Image
-
-sys.path.insert(0, str(Path(${JSON.stringify(REPO_ROOT)}) / "art" / "pipeline"))
-import autotile_compositor
-import autotile_orchestrator as orch
-
-# Build a 32x32 interior whose pixels are a deterministic per-coordinate
-# gradient — guarantees that offset-sampled variants differ from each other
-# AND from the canonical at non-edge positions.
-arr = np.zeros((32, 32, 3), dtype=np.uint8)
-for y in range(32):
-    for x in range(32):
-        # Three independent channels so variants are easy to tell apart;
-        # values stay in [0,255].
-        arr[y, x, 0] = (x * 7 + y * 3) % 256
-        arr[y, x, 1] = (x * 5 + y * 11) % 256
-        arr[y, x, 2] = (x * 13 + y * 17) % 256
-interior = Image.fromarray(arr, "RGB")
-
-# Build a minimal exterior + patch set so compose_blob47 runs end-to-end.
-# The boundary tiles' content doesn't matter for THIS test; only the
-# canonical (index 46) and the appended variants (47..) are inspected.
-exterior = Image.new("RGB", (32, 32), (200, 130, 80))
-# Synthesize concave/convex patches from interior+exterior using the
-# orchestrator's own helpers — keeps this test independent of upstream
-# patch generation.
-patch_concave = orch._synth_concave(interior, exterior)
-patch_convex  = orch._synth_convex(interior, exterior)
-# Horizontal patch: top half exterior, bottom half interior (16x16).
-ph = Image.new("RGB", (16, 16))
-arr_ph = np.array(ph)
-ext16 = np.array(exterior.resize((16, 16), Image.NEAREST))
-int16 = np.array(interior.resize((16, 16), Image.NEAREST))
-arr_ph[:8, :] = ext16[:8, :]
-arr_ph[8:, :] = int16[8:, :]
-patch_horiz = Image.fromarray(arr_ph, "RGB")
-patch_vert  = patch_horiz.transpose(Image.ROTATE_90)
-
-bundle = {
-    "interior": interior,
-    "exterior": exterior,
-    "patch_concave_NW": patch_concave,
-    "patch_convex_NW":  patch_convex,
-    "patch_horiz_NW":   patch_horiz,
-    "patch_vert_NW":    patch_vert,
-}
-
-VARIANT_COUNT = 4
-tiles = autotile_compositor.compose_blob47_with_variants(bundle, VARIANT_COUNT)
-assert len(tiles) == 47 + (VARIANT_COUNT - 1), \\
-    f"expected {47 + VARIANT_COUNT - 1} tiles, got {len(tiles)}"
-
-# Apply the edge-fix (mirror of the production logic in orch.run_family).
-canonical = tiles[orch._BLOB47_ALL_INTERIOR_INDEX]
-for v_idx in range(orch._BLOB47_ALL_INTERIOR_INDEX + 1, len(tiles)):
-    tiles[v_idx] = orch._force_edge_match_to_canonical(canonical, tiles[v_idx])
-
-out_dir = Path(os.environ["OUT_DIR"])
-out_dir.mkdir(parents=True, exist_ok=True)
-# Save only the tiles this test inspects.
-canonical.save(out_dir / "canonical.png")
-for v in range(1, VARIANT_COUNT):
-    tiles[orch._BLOB47_ALL_INTERIOR_INDEX + v].save(out_dir / f"variant_{v}.png")
-
-print(f"OK wrote {VARIANT_COUNT} files to {out_dir}")
-`;
-
-async function runFixture(outDir) {
-  const result = spawnSync('python3', ['-c', PY_FIXTURE], {
-    cwd: REPO_ROOT,
-    env: { ...process.env, OUT_DIR: outDir },
-    encoding: 'utf8',
-  });
-  if (result.status !== 0) {
-    const msg = (result.stderr || result.stdout || '').trim();
-    throw new Error(
-      `fixture generation failed (exit ${result.status}):\n${msg}\n` +
-      `If 'python3' is missing or numpy/Pillow aren't installed, the autotile ` +
-      `pipeline can't run — same dependency the orchestrator needs in CI.`
-    );
-  }
-}
-
-async function loadPng(path) {
-  const { data, info } = await sharp(path)
-    .raw()
-    .toBuffer({ resolveWithObject: true });
-  return { data, width: info.width, height: info.height, channels: info.channels };
-}
-
-function row(img, y) {
-  const stride = img.width * img.channels;
-  return img.data.subarray(y * stride, (y + 1) * stride);
-}
-
-function col(img, x) {
-  const out = new Uint8Array(img.height * img.channels);
-  const stride = img.width * img.channels;
-  for (let y = 0; y < img.height; y++) {
-    for (let c = 0; c < img.channels; c++) {
-      out[y * img.channels + c] = img.data[y * stride + x * img.channels + c];
-    }
-  }
-  return out;
-}
-
-function buffersEqual(a, b) {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
-  return true;
-}
-
-function interiorDiffers(canon, variant) {
-  // Count pixels that differ inside the 1-pixel border.
-  const stride = canon.width * canon.channels;
-  let diffs = 0;
-  for (let y = 1; y < canon.height - 1; y++) {
-    for (let x = 1; x < canon.width - 1; x++) {
-      for (let c = 0; c < canon.channels; c++) {
-        if (canon.data[y * stride + x * canon.channels + c] !==
-            variant.data[y * stride + x * canon.channels + c]) {
-          diffs++;
-          break;
-        }
-      }
-    }
-  }
-  return diffs;
-}
-
-async function main() {
-  const out = mkdtempSync(join(tmpdir(), 'otb-autotile-variants-'));
-  try {
-    await runFixture(out);
-
-    const canonPath = join(out, 'canonical.png');
-    assert.ok(existsSync(canonPath), `fixture did not produce ${canonPath}`);
-    const canon = await loadPng(canonPath);
-    assert.equal(canon.width, 32, 'canonical width should be 32');
-    assert.equal(canon.height, 32, 'canonical height should be 32');
-
-    const variantPaths = [1, 2, 3].map(v => join(out, `variant_${v}.png`));
-
-    for (const vp of variantPaths) {
-      const name = vp.split('/').pop();
-      assert.ok(existsSync(vp), `fixture did not produce ${vp}`);
-      const variant = await loadPng(vp);
-
-      test(`${name} top row matches canonical`, () => {
-        assert.ok(buffersEqual(row(variant, 0), row(canon, 0)),
-          'top row drifted from canonical');
-      });
-      test(`${name} bottom row matches canonical`, () => {
-        assert.ok(buffersEqual(row(variant, variant.height - 1),
-                                row(canon, canon.height - 1)),
-          'bottom row drifted from canonical');
-      });
-      test(`${name} left column matches canonical`, () => {
-        assert.ok(buffersEqual(col(variant, 0), col(canon, 0)),
-          'left column drifted from canonical');
-      });
-      test(`${name} right column matches canonical`, () => {
-        assert.ok(buffersEqual(col(variant, variant.width - 1),
-                                col(canon, canon.width - 1)),
-          'right column drifted from canonical');
-      });
-      test(`${name} interior still differs from canonical (variety preserved)`, () => {
-        const diffs = interiorDiffers(canon, variant);
-        assert.ok(diffs > 0,
-          `variant interior is identical to canonical — the edge-fix wiped the ` +
-          `variant's pixel-noise, defeating the purpose of variants. (diffs=${diffs})`);
-      });
-    }
-
-    if (failed > 0) {
-      console.error(`\n[autotile_variants] FAIL — ${failed} of ${passed + failed} assertions failed.`);
-      process.exit(1);
-    }
-    console.log(`\n[autotile_variants] OK — ${passed} edge-match + interior-variety assertions across ${variantPaths.length} variants.`);
-  } finally {
-    rmSync(out, { recursive: true, force: true });
-  }
-}
-
-main().catch(e => {
-  console.error(e.stack || e.message);
-  process.exit(1);
-});