@bongos/core 1.17.0

package/tests/ship_zero_commit.mjs

@@ -0,0 +1,60 @@
+// tests/ship_zero_commit.mjs
+//
+// Regression test for task 391 (idea #37) — ship.js zeroCommitVerdict, the gate
+// that stops the DB-only short-circuit from silently shipping ANY zero-commit
+// branch. autoMerge used to do `if (commitsAhead === '0') return true`, advancing
+// a claim with empty/wrong touches[] — or simply uncommitted work — straight to
+// shipped (credit for no change). Now a zero-commit ship must be DELIBERATELY
+// declared with --db-only; otherwise autoMerge refuses (task stays at confirmed).
+//
+// zeroCommitVerdict(commitsAhead, dbOnly) is pure:
+//   commits exist (!= '0', incl. null when git failed) → 'has-commits' (normal merge path)
+//   '0' + dbOnly                                        → 'db-only'     (short-circuit to shipped)
+//   '0' + !dbOnly                                       → 'refuse'      (almost always a mistake)
+//
+// Run:  node tests/ship_zero_commit.mjs
+
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const ship = require('../scripts/gds/ship.js');
+const { zeroCommitVerdict } = ship;
+
+let passed = 0;
+let failed = 0;
+const test = (name, fn) => {
+  try {
+    fn();
+    console.log(`PASS  ${name}`);
+    passed++;
+  } catch (e) {
+    console.log(`FAIL  ${name}\n      ${e.message}`);
+    failed++;
+  }
+};
+
+test('commits ahead → has-commits (the --db-only flag is irrelevant when there is a diff)', () => {
+  assert.equal(zeroCommitVerdict('1', false), 'has-commits');
+  assert.equal(zeroCommitVerdict('5', true), 'has-commits');
+  assert.equal(zeroCommitVerdict('12', false), 'has-commits');
+});
+
+test("null commitsAhead (git rev-list failed) → has-commits, matching the old `=== '0'` behavior", () => {
+  // gitOk returns null on failure; the original short-circuit only fired on an
+  // EXACT '0', so null must still take the normal path — it must never be
+  // mistaken for a zero-commit ship and silently shipped or wrongly refused.
+  assert.equal(zeroCommitVerdict(null, false), 'has-commits');
+  assert.equal(zeroCommitVerdict(null, true), 'has-commits');
+});
+
+test('zero commits + --db-only → db-only (a deliberate direct-SQL ship)', () => {
+  assert.equal(zeroCommitVerdict('0', true), 'db-only');
+});
+
+test('zero commits + no --db-only → refuse (the silent-zero-commit-ship bug this closes)', () => {
+  assert.equal(zeroCommitVerdict('0', false), 'refuse');
+});
+
+console.log(`\nzero-commit ship verdict (task 391) tests: ${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);

package/tests/single_host_hall.mjs

@@ -0,0 +1,98 @@
+// tests/single_host_hall.mjs
+//
+// Single-host hall routing (task 1971). isBuildersHost (src/bongos/serve-internal.js)
+// must ALSO return true when the request host equals the instance's CONFIGURED
+// buildersOrigin host — so an instance with no dedicated builders.<apex> subdomain
+// (a co-located one-level subdomain, e.g. emersonian-circles.cloudbongos.com, where
+// free-plan TLS can't cover a two-level builders.<sub>.<apex>) serves the hall on
+// its own host instead of 301-redirecting /builders to a builders.<host> that was
+// never provisioned. Back-compat: a conventional builders.<apex> instance still
+// matches via startsWith("builders."), so its routing is byte-identical.
+//
+// serve-internal.js requires DB-free (the pg pool connects lazily). branding()
+// memoizes on its first call, so each branding scenario runs in its OWN fresh child
+// process with GDS_BRANDING_FILE pointing at a temp pack. DB-free + network-free —
+// runs in the unit gate (run-unit-tests.js auto-discovers tests/*.mjs).
+//
+// Run:  node tests/single_host_hall.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { writeFileSync, mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = fileURLToPath(new URL('..', import.meta.url));
+const SERVE_INTERNAL = join(ROOT, 'src', 'bongos', 'serve-internal.js');
+
+// Load serve-internal.js in a FRESH process with `brandingPack` as the active
+// instance branding, and return { host: isBuildersHost(host) } for each host.
+// A child process per scenario sidesteps branding()'s first-call memoization.
+function buildersHostVerdicts(brandingPack, hosts) {
+  const dir = mkdtempSync(join(tmpdir(), 'cb-brand-'));
+  const file = join(dir, 'branding.json');
+  writeFileSync(file, JSON.stringify(brandingPack));
+  const script = `
+    const si = require(${JSON.stringify(SERVE_INTERNAL)});
+    const hosts = ${JSON.stringify(hosts)};
+    const out = {};
+    for (const h of hosts) out[h] = si.isBuildersHost({ headers: { host: h } });
+    process.stdout.write(JSON.stringify(out));
+  `;
+  const stdout = execFileSync(process.execPath, ['-e', script], {
+    env: { ...process.env, GDS_BRANDING_FILE: file },
+    encoding: 'utf8',
+  });
+  return JSON.parse(stdout);
+}
+
+test('single-host instance: the configured buildersOrigin host IS the hall host', () => {
+  const v = buildersHostVerdicts(
+    {
+      domains: {
+        publicOrigin: 'https://emersonian-circles.cloudbongos.com',
+        buildersOrigin: 'https://emersonian-circles.cloudbongos.com',
+        statusOrigin: 'https://emersonian-circles.cloudbongos.com',
+      },
+    },
+    [
+      'emersonian-circles.cloudbongos.com',
+      'builders.anything.com',
+      'amazonprimea.com',
+      'status.emersonian-circles.cloudbongos.com',
+      'evil.example',
+      '',
+    ],
+  );
+  // The NEW branch: the single configured host serves the hall (no dead redirect).
+  assert.equal(v['emersonian-circles.cloudbongos.com'], true);
+  // Back-compat: a builders.<apex> host still matches via startsWith("builders.").
+  assert.equal(v['builders.anything.com'], true);
+  // A DIFFERENT apex is NOT the hall host, so its /builders redirect still fires.
+  assert.equal(v['amazonprimea.com'], false);
+  // The status subdomain of the single host is a status host, not the hall.
+  assert.equal(v['status.emersonian-circles.cloudbongos.com'], false);
+  // Unrelated / empty hosts are never the hall.
+  assert.equal(v['evil.example'], false);
+  assert.equal(v[''], false);
+});
+
+test('conventional two-host instance: the apex stays a NON-builders host (no regression)', () => {
+  const v = buildersHostVerdicts(
+    {
+      domains: {
+        publicOrigin: 'https://amazonprimea.com',
+        buildersOrigin: 'https://builders.amazonprimea.com',
+        statusOrigin: 'https://status.amazonprimea.com',
+      },
+    },
+    ['builders.amazonprimea.com', 'amazonprimea.com', 'status.amazonprimea.com'],
+  );
+  // The dedicated subdomain is the hall (both the startsWith and the config branch agree).
+  assert.equal(v['builders.amazonprimea.com'], true);
+  // The apex is NOT the hall — /builders must still 301 to the subdomain here.
+  assert.equal(v['amazonprimea.com'], false);
+  assert.equal(v['status.amazonprimea.com'], false);
+});

package/tests/skill_prefs.mjs

@@ -0,0 +1,150 @@
+// tests/skill_prefs.mjs
+//
+// Unit smoke for src/bongos/skill-prefs.js (V3.R85 / #304). Verifies the pure
+// helpers — DB plumbing is exercised by routes/me.js and tested via the
+// production smoke once the migration is in place; here we cover the
+// classification, validation, and patch-apply logic without touching pg.
+//
+// Run:  node tests/skill_prefs.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const sp = require('../modules/builder-settings/skill-prefs.js');
+
+let passed = 0;
+let failed = 0;
+function t(name, fn) {
+  try { fn(); passed++; console.log(`  PASS  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+
+console.log('skill-prefs constants:');
+
+t('every KNOWN_SKILLS has a SKILL_DEFAULTS entry', () => {
+  for (const s of sp.KNOWN_SKILLS) {
+    assert.ok(s in sp.SKILL_DEFAULTS, `missing default for ${s}`);
+  }
+});
+
+t('every SKILL_DEFAULTS value is in ALLOWED_MODELS', () => {
+  for (const [skill, model] of Object.entries(sp.SKILL_DEFAULTS)) {
+    assert.ok(sp.ALLOWED_MODELS.includes(model), `bad default for ${skill}: ${model}`);
+  }
+});
+
+t('ALLOWED_MODELS includes the four canonical tokens', () => {
+  for (const tok of ['opus', 'sonnet', 'haiku', 'script']) {
+    assert.ok(sp.ALLOWED_MODELS.includes(tok), `missing ${tok}`);
+  }
+});
+
+console.log('\nresolution:');
+
+t('getForBuilder returns the override when set', () => {
+  const r = sp.getForBuilder({ 'idea-triage': 'sonnet' }, 'idea-triage');
+  assert.equal(r, 'sonnet');
+});
+
+t('getForBuilder returns the default when not overridden', () => {
+  assert.equal(sp.getForBuilder({}, 'idea-triage'), 'opus');
+});
+
+t('getForBuilder returns the default when override is an invalid model', () => {
+  // An override value that isn't a known model token must be ignored, not
+  // silently propagated — otherwise a stale jsonb row could poison
+  // resolution.
+  assert.equal(sp.getForBuilder({ 'idea-triage': 'gpt-4' }, 'idea-triage'), 'opus');
+});
+
+t('getForBuilder returns null for unknown skill', () => {
+  assert.equal(sp.getForBuilder({ 'nonexistent': 'opus' }, 'nonexistent'), null);
+});
+
+t('listEffective returns one row per KNOWN_SKILLS in stable order', () => {
+  const rows = sp.listEffective({});
+  assert.equal(rows.length, sp.KNOWN_SKILLS.length);
+  for (let i = 0; i < sp.KNOWN_SKILLS.length; i++) {
+    assert.equal(rows[i].skill, sp.KNOWN_SKILLS[i]);
+    assert.equal(rows[i].override_model, null);
+    assert.equal(rows[i].effective_model, sp.SKILL_DEFAULTS[rows[i].skill]);
+  }
+});
+
+t('listEffective surfaces overrides correctly', () => {
+  const rows = sp.listEffective({ 'planning-session': 'haiku' });
+  const row = rows.find((r) => r.skill === 'planning-session');
+  assert.equal(row.override_model, 'haiku');
+  assert.equal(row.effective_model, 'haiku');
+  assert.equal(row.default_model, 'opus');
+});
+
+console.log('\nvalidation:');
+
+t('validatePatch accepts an empty body', () => {
+  const r = sp.validatePatch({});
+  assert.equal(r.ok, true);
+  assert.deepEqual(r.patch, {});
+});
+
+t('validatePatch rejects non-object bodies', () => {
+  for (const bad of [null, undefined, 'string', 42, [1, 2]]) {
+    const r = sp.validatePatch(bad);
+    assert.equal(r.ok, false, `should reject ${JSON.stringify(bad)}`);
+  }
+});
+
+t('validatePatch rejects unknown skill names', () => {
+  const r = sp.validatePatch({ 'nonexistent': 'opus' });
+  assert.equal(r.ok, false);
+  assert.equal(r.errors[0].error, 'unknown_skill');
+});
+
+t('validatePatch rejects unknown models', () => {
+  const r = sp.validatePatch({ 'idea-triage': 'gpt-4' });
+  assert.equal(r.ok, false);
+  assert.equal(r.errors[0].error, 'unknown_model');
+});
+
+t('validatePatch accepts null as a clear-override sentinel', () => {
+  const r = sp.validatePatch({ 'idea-triage': null });
+  assert.equal(r.ok, true);
+  assert.equal(r.patch['idea-triage'], null);
+});
+
+t('validatePatch reports multiple errors at once', () => {
+  const r = sp.validatePatch({ 'nonexistent': 'opus', 'idea-triage': 'gpt-4' });
+  assert.equal(r.ok, false);
+  assert.equal(r.errors.length, 2);
+});
+
+console.log('\npatch apply:');
+
+t('applyPatch overwrites existing keys', () => {
+  const next = sp.applyPatch({ 'idea-triage': 'opus' }, { 'idea-triage': 'haiku' });
+  assert.equal(next['idea-triage'], 'haiku');
+});
+
+t('applyPatch deletes keys when value is null', () => {
+  const next = sp.applyPatch({ 'idea-triage': 'sonnet' }, { 'idea-triage': null });
+  assert.ok(!('idea-triage' in next));
+});
+
+t('applyPatch leaves unrelated keys alone', () => {
+  const next = sp.applyPatch(
+    { 'idea-triage': 'sonnet', 'blocker-review': 'opus' },
+    { 'planning-session': 'haiku' }
+  );
+  assert.equal(next['idea-triage'], 'sonnet');
+  assert.equal(next['blocker-review'], 'opus');
+  assert.equal(next['planning-session'], 'haiku');
+});
+
+t('applyPatch handles a null/undefined existing object', () => {
+  assert.deepEqual(sp.applyPatch(null, { 'idea-triage': 'haiku' }), { 'idea-triage': 'haiku' });
+  assert.deepEqual(sp.applyPatch(undefined, { 'idea-triage': 'haiku' }), { 'idea-triage': 'haiku' });
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);

package/tests/smoke_preflight.mjs

@@ -0,0 +1,66 @@
+// tests/smoke_preflight.mjs
+//
+// #958 / V4.R20 — laptop smoke preflight. The GDS smoke checks need a running
+// server; when BASE points at a LOCAL listener that isn't up, every check used to
+// flood with ECONNREFUSED and fail the ship for a non-defect (sessions 328, 1113).
+// smoke-gds.js now SKIPs (exit 0) when the target is local AND no listener answers,
+// while a remote/unreachable base still fails. These tests pin the two pure-ish
+// helpers: isLocalTarget (classification) + probeListener (a real TCP probe against
+// an ephemeral localhost server — no external network).
+//
+// Run:  node tests/smoke_preflight.mjs
+
+import { strict as assert } from 'node:assert';
+import net from 'node:net';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { isLocalTarget, probeListener } = require('../scripts/gds/smoke-gds.js');
+
+let passed = 0;
+let failed = 0;
+async function t(name, fn) {
+  try { await fn(); passed++; console.log(`  PASS  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+
+await t('isLocalTarget: localhost / 127.0.0.1 / ::1 / 0.0.0.0 are local', () => {
+  for (const h of ['localhost', 'LOCALHOST', '127.0.0.1', '::1', '0.0.0.0']) {
+    assert.equal(isLocalTarget(h), true, `${h} should be local`);
+  }
+});
+
+await t('isLocalTarget: prod + LAN hosts are NOT local (remote stays a real failure)', () => {
+  for (const h of ['amazonprimea.com', 'status.amazonprimea.com', '10.0.0.5', 'example.com']) {
+    assert.equal(isLocalTarget(h), false, `${h} should be remote`);
+  }
+});
+
+await t('probeListener: true when a server is listening on the port', async () => {
+  const server = net.createServer();
+  await new Promise((res) => server.listen(0, '127.0.0.1', res));
+  const { port } = server.address();
+  try {
+    assert.equal(await probeListener('127.0.0.1', port), true);
+  } finally {
+    await new Promise((res) => server.close(res));
+  }
+});
+
+await t('probeListener: false when nothing is listening (the laptop case)', async () => {
+  // Bind then immediately close to obtain a port we KNOW is now free.
+  const tmp = net.createServer();
+  await new Promise((res) => tmp.listen(0, '127.0.0.1', res));
+  const { port } = tmp.address();
+  await new Promise((res) => tmp.close(res));
+  assert.equal(await probeListener('127.0.0.1', port, 750), false);
+});
+
+await t('probeListener: false (not a throw) on an unroutable host within the timeout', async () => {
+  // 192.0.2.0/24 is TEST-NET-1 (RFC 5737) — guaranteed non-routable. Short timeout.
+  const v = await probeListener('192.0.2.1', 3000, 600);
+  assert.equal(v, false);
+});
+
+console.log(`\nsmoke_preflight: ${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);

package/tests/snapshot_picker.mjs

@@ -0,0 +1,233 @@
+// tests/snapshot_picker.mjs
+//
+// Parity test: verifies that the snapshot renderer's tile-picking logic
+// agrees with the JS runtime autotile pickers for a representative sample
+// of cells in INITIAL_MAP.
+//
+// The snapshot renderer (scripts/snapshots/render-world.mjs) calls the
+// SAME selectBlob47/selectPath16 and neighborsAt functions that the browser
+// client uses — so this test validates that the renderer correctly:
+//   1. Passes the ground grid to ground-layer pickers.
+//   2. Passes the object grid to object-layer pickers.
+//   3. Produces the same tile index as a direct call with the same inputs.
+//
+// If these diverge the in-game render and the snapshot would show different
+// tile choices for the same cell.
+//
+// Usage:
+//   node tests/snapshot_picker.mjs
+
+import { createRequire } from 'node:module';
+import { selectBlob47, selectPath16 } from '../modules/game/public/game/world/autotile.js';
+import {
+  TERRAIN_RENDER,
+  OBJECT_RENDER,
+  neighborsAt,
+} from '../modules/game/public/game/world/terrain.js';
+
+const require = createRequire(import.meta.url);
+const { INITIAL_MAP, WORLD_COLS, WORLD_ROWS, TERRAIN, OBJECT } = require('../modules/game/world/map.js');
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition, msg) {
+  if (condition) {
+    passed++;
+  } else {
+    console.error(`  FAIL: ${msg}`);
+    failed++;
+  }
+}
+
+// ---------- helpers mirrored from render-world.mjs -------------------------
+
+function groundIdx(x, y) {
+  const terrainId = INITIAL_MAP.ground[y][x];
+  const cfg = TERRAIN_RENDER[terrainId];
+  if (!cfg || cfg.strategy === 'single') return null;
+  const neighbors = neighborsAt(INITIAL_MAP.ground, x, y);
+  if (cfg.strategy === 'blob47') return selectBlob47(terrainId, neighbors);
+  if (cfg.strategy === 'path16') {
+    return 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,
+    });
+  }
+  return null;
+}
+
+function objectIdx(x, y) {
+  const objId = INITIAL_MAP.objects[y][x];
+  if (!objId) return null;
+  const cfg = OBJECT_RENDER[objId];
+  if (!cfg || cfg.strategy === 'single') return null;
+  const neighbors = neighborsAt(INITIAL_MAP.objects, x, y);
+  if (cfg.strategy === 'blob47') return selectBlob47(objId, neighbors);
+  if (cfg.strategy === 'path16') {
+    return 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,
+    });
+  }
+  return null;
+}
+
+// ---------- tests -----------------------------------------------------------
+
+console.log('[snapshot_picker] running parity tests…\n');
+
+// 1. All-grass interior cell (0,0 — surrounded by grass on all sides).
+{
+  const idx = groundIdx(1, 1);
+  assert(idx !== null, 'grass interior: should return a blob47 index');
+  assert(idx >= 0 && idx <= 46, `grass interior: index ${idx} out of range 0..46`);
+
+  // Direct call with the same neighbors
+  const neighbors = neighborsAt(INITIAL_MAP.ground, 1, 1);
+  const direct = selectBlob47(INITIAL_MAP.ground[1][1], neighbors);
+  assert(idx === direct, `grass interior: picker returned ${idx}, direct call returned ${direct}`);
+  console.log(`  PASS grass interior (1,1): blob47 idx=${idx}`);
+}
+
+// 2. SEA cell — single-tile strategy, no autotile index.
+{
+  const seaRow = WORLD_ROWS - 1;
+  const terrainId = INITIAL_MAP.ground[seaRow][0];
+  assert(terrainId === TERRAIN.SEA, `row ${seaRow} col 0 should be SEA, got ${terrainId}`);
+  const cfg = TERRAIN_RENDER[terrainId];
+  assert(cfg.strategy === 'single', `sea: expected single strategy, got ${cfg.strategy}`);
+  const idx = groundIdx(0, seaRow);
+  assert(idx === null, `sea: single-tile strategy should return null, got ${idx}`);
+  console.log(`  PASS sea (0,${seaRow}): single tile, no autotile index`);
+}
+
+// 3. Grass→sand boundary cell (first SAND row, leftmost column).
+// At y=6, x=0 the ground is SAND. Its N neighbor is GRASS. The blob47 picker
+// should see a non-all-interior byte and return an edge tile index.
+{
+  const x = 0, y = 6;
+  const terrainId = INITIAL_MAP.ground[y][x];
+  assert(terrainId === TERRAIN.SAND, `(0,6) should be SAND, got ${terrainId}`);
+  const idx = groundIdx(x, y);
+  assert(idx !== null, 'sand boundary: should have autotile index');
+
+  const neighbors = neighborsAt(INITIAL_MAP.ground, x, y);
+  const direct = selectBlob47(terrainId, neighbors);
+  assert(idx === direct, `sand boundary: picker=${idx}, direct=${direct}`);
+  // Sand at (0,6) has grass to the north and sea below, so it's not all-interior.
+  // We just check it produces a valid range.
+  assert(idx >= 0 && idx <= 46, `sand boundary idx ${idx} out of range`);
+  console.log(`  PASS sand boundary (0,6): blob47 idx=${idx}`);
+}
+
+// 4. Rock object — single tile, no autotile index.
+{
+  // Rocks are placed in the grass band (y<6) where the hash hits.
+  // Find the first rock in the map.
+  let rockX = -1, rockY = -1;
+  outer: for (let y = 0; y < 6; y++) {
+    for (let x = 0; x < WORLD_COLS; x++) {
+      if (INITIAL_MAP.objects[y][x] === OBJECT.ROCK) { rockX = x; rockY = y; break outer; }
+    }
+  }
+  assert(rockX >= 0, 'should find at least one rock in the grass band');
+  if (rockX >= 0) {
+    const cfg = OBJECT_RENDER[OBJECT.ROCK];
+    assert(cfg.strategy === 'single', `rock: expected single strategy, got ${cfg.strategy}`);
+    const idx = objectIdx(rockX, rockY);
+    assert(idx === null, `rock (${rockX},${rockY}): single-tile → null, got ${idx}`);
+    console.log(`  PASS rock (${rockX},${rockY}): single tile, no autotile index`);
+  }
+}
+
+// 5. Container panel — single tile, no autotile index.
+{
+  const cx = 13, cy = 8;
+  const panel = INITIAL_MAP.objects[cy][cx];
+  assert(panel && panel.startsWith('container_panel_'), `(13,8) should be a container panel, got ${panel}`);
+  const idx = objectIdx(cx, cy);
+  assert(idx === null, `container panel: single-tile → null, got ${idx}`);
+  console.log(`  PASS container panel (${cx},${cy}): single tile, no autotile index`);
+}
+
+// 6. Marble path — path16 autotile. Cells at (13, 10..13).
+// The path runs N→S at x=13, y=10-13. Middle cells should connect north+south.
+{
+  const x = 13, y = 11; // interior path cell connects N (y=10) and S (y=12)
+  const objId = INITIAL_MAP.objects[y][x];
+  assert(objId === OBJECT.PATH_MARBLE, `(13,11) should be PATH_MARBLE, got ${objId}`);
+
+  const idx = objectIdx(x, y);
+  assert(idx !== null, 'path interior: should have path16 index');
+
+  // Direct call
+  const neighbors = neighborsAt(INITIAL_MAP.objects, x, y);
+  const direct = 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,
+  });
+  assert(idx === direct, `path interior: picker=${idx}, direct=${direct}`);
+
+  // N and S neighbors are also PATH_MARBLE at (13,10) and (13,12)
+  assert(neighbors.N === OBJECT.PATH_MARBLE, `path (13,11): N should be PATH_MARBLE`);
+  assert(neighbors.S === OBJECT.PATH_MARBLE, `path (13,11): S should be PATH_MARBLE`);
+  // Expected: N+S connected, W+E not → path16 = 0b1001 = 9
+  const expected = selectPath16({ N: 1, W: 0, E: 0, S: 1 });
+  assert(idx === expected, `path interior: expected N+S connected index ${expected}, got ${idx}`);
+  console.log(`  PASS marble path interior (13,11): path16 idx=${idx} (N+S connected)`);
+}
+
+// 7. Marble path endpoint — top of the path (13,10): connects S only.
+{
+  const x = 13, y = 10;
+  const objId = INITIAL_MAP.objects[y][x];
+  assert(objId === OBJECT.PATH_MARBLE, `(13,10) should be PATH_MARBLE, got ${objId}`);
+
+  const neighbors = neighborsAt(INITIAL_MAP.objects, x, y);
+  // (13,9) is the container door panel — NOT a path marble
+  assert(neighbors.N !== OBJECT.PATH_MARBLE, `path top (13,10): N should not be PATH_MARBLE`);
+  assert(neighbors.S === OBJECT.PATH_MARBLE, `path top (13,10): S should be PATH_MARBLE`);
+
+  const idx = objectIdx(x, y);
+  const expected = selectPath16({ N: 0, W: 0, E: 0, S: 1 });
+  assert(idx === expected, `path top (13,10): expected S-only idx ${expected}, got ${idx}`);
+  console.log(`  PASS marble path top (13,10): path16 idx=${idx} (S only)`);
+}
+
+// 8. Ground layer: no object cell pollutes ground autotile neighbors.
+// The rock at (rockX, rockY) must not affect the ground tile choice for
+// any of its neighbors — picker sees the ground grid only.
+{
+  let rockX = -1, rockY = -1;
+  outer2: for (let y = 0; y < 6; y++) {
+    for (let x = 0; x < WORLD_COLS; x++) {
+      if (INITIAL_MAP.objects[y][x] === OBJECT.ROCK) { rockX = x; rockY = y; break outer2; }
+    }
+  }
+  if (rockX >= 0 && rockX + 1 < WORLD_COLS) {
+    const rightX = rockX + 1;
+    const rightY = rockY;
+    const terrainId = INITIAL_MAP.ground[rightY][rightX];
+    const groundNeighbors = neighborsAt(INITIAL_MAP.ground, rightX, rightY);
+    // The W neighbor of (rightX, rightY) should be a terrain id (grass), not a rock object id.
+    assert(
+      groundNeighbors.W === TERRAIN.GRASS,
+      `ground picks should see ground only: W neighbor of (${rightX},${rightY}) should be GRASS, got ${groundNeighbors.W}`
+    );
+    console.log(`  PASS ground isolation (${rightX},${rightY}): W ground neighbor is ${groundNeighbors.W}, not an object id`);
+  }
+}
+
+// ---------- summary ---------------------------------------------------------
+
+console.log(`\n[snapshot_picker] ${passed} passed, ${failed} failed`);
+if (failed > 0) {
+  process.exit(1);
+}