@bongos/core 1.17.0

package/scripts/snapshots/render-world.mjs

@@ -0,0 +1,322 @@
+// 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/scripts/status-mirror-sync.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+// scripts/status-mirror-sync.js — publish the status surface to the off-box status
+// mirror (lars589/amazonprimea-status → GitHub Pages → status.amazonprimea.com).
+//
+// SOURCE PATH (BV1.R84 / task 1635): the status dashboard moved from public-status/
+// to modules/status-ui/public/ when the status surface became a module (a web
+// surface is first-class — ADR 0093 §1). This script (status-UI domain tooling that
+// travels with its domain but stays a CLI under scripts/, the sessions/autonomy
+// precedent) reads from the new location; its output to the mirror is unchanged.
+//
+// WHY THIS EXISTS (#737): the live status page is served OFF the droplet for
+// outage resilience (ADR 0029) from a SEPARATE repo. Before this script there
+// was no sync, so every change to the status surface silently missed the live page
+// (that's how #726's reorg + #731's theming never showed up). This makes the
+// publish deterministic and CI-driven.
+//
+// DESIGN: status.js + style.css + cursors/ are byte-identical between the
+// droplet copy and the mirror (#737 parameterized the one differing constant via
+// window.STATUS_API_BASE), so they are PURE COPIES. Only index.html carries the
+// three off-box additions, injected here at stable anchors:
+//   1. <script>window.STATUS_API_BASE='https://amazonprimea.com'</script>  (head)
+//   2. <div id="offbox-status">…</div>                                     (after <body>)
+//   3. the availability-banner driver <script> (reads the status-data branch)  (before status.js)
+// If any anchor is missing the script THROWS — a silent mis-sync is worse than
+// a failed run.
+//
+// USAGE:
+//   node scripts/status-mirror-sync.js --repo-dir <path-to-mirror-checkout> [--push]
+//     --repo-dir : a checkout of lars589/amazonprimea-status (its `main` branch).
+//     --push     : commit + push the result. Without it the files are written
+//                  and `git status` is printed for inspection (dry-ish run).
+//
+// The mirror's CNAME, scripts/, .github/, and the orphan status-data branch are
+// NEVER touched here — only the page assets are republished.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const SRC = path.join(REPO_ROOT, 'modules', 'status-ui', 'public');
+const { branding, clientBranding } = require('../src/branding');
+
+// Stamp instance-identity tokens into the mirror HTML. The off-box mirror is
+// served by GitHub Pages, NOT the branding-injecting Node server — so this script
+// must reproduce serve-internal.applyBrandTokens (task 1705, ADR 0062 §3), else the
+// mirror would render literal {{worldName}}/{{currency}} placeholders. KEEP IN SYNC
+// with src/bongos/serve-internal.js applyBrandTokens.
+function brandTokens(html) {
+  const b = clientBranding();
+  const world = (b.identity && b.identity.worldName) || '';
+  const product = (b.identity && b.identity.productName) || '';
+  const cur = (b.currency && b.currency.label) || 'credits';
+  const Cur = cur ? cur.charAt(0).toUpperCase() + cur.slice(1) : cur;
+  let origin = '';
+  try { origin = branding().domains.publicOrigin || ''; } catch (_) { /* neutral */ }
+  return html
+    .split('{{worldName}}').join(world)
+    .split('{{productName}}').join(product)
+    .split('{{Currency}}').join(Cur)
+    .split('{{currency}}').join(cur)
+    .split('{{publicOrigin}}').join(origin);
+}
+
+function arg(name) {
+  const i = process.argv.indexOf(name);
+  return i >= 0 ? process.argv[i + 1] : null;
+}
+const repoDir = arg('--repo-dir');
+const doPush = process.argv.includes('--push');
+if (!repoDir) {
+  console.error('usage: node scripts/status-mirror-sync.js --repo-dir <mirror-checkout> [--push]');
+  process.exit(2);
+}
+if (!fs.existsSync(path.join(repoDir, 'CNAME'))) {
+  console.error(`refusing: ${repoDir} does not look like the status mirror (no CNAME). Clone lars589/amazonprimea-status first.`);
+  process.exit(2);
+}
+
+// ---- the three off-box index.html injections -------------------------------
+
+const HEAD_INJECT =
+  `  <!-- #737: off-box mirror runs cross-origin against the droplet. -->\n` +
+  `  <script>window.STATUS_API_BASE = 'https://amazonprimea.com';</script>\n`;
+
+// The client-safe branding pack, so status.js reads the instance currency label
+// on the mirror exactly as it does on the droplet (serve-internal injects the same
+// global there). Without this, status.js would fall back to the neutral 'credits'.
+const BRANDING_INJECT =
+  `  <script>window.__BRANDING__ = ${JSON.stringify(clientBranding())};</script>\n`;
+
+const BANNER_DIV =
+  `\n<!-- Off-box availability banner (ADR 0029) — injected by scripts/status-mirror-sync.js.\n` +
+  `     The ONE element that stays truthful when the droplet is dark: it reads the\n` +
+  `     prober's status.json from this repo's status-data branch, no droplet dependency. -->\n` +
+  `<div id="offbox-status" role="status" aria-live="polite"></div>\n`;
+
+const BANNER_DRIVER = `<!-- Off-box availability banner driver (ADR 0029) — loaded before status.js so
+     it lights up even if the dashboard script or its cross-origin fetches fail. -->
+<script>
+(function () {
+  var OFFBOX_URL = 'https://raw.githubusercontent.com/lars589/amazonprimea-status/status-data/status.json';
+  var el = document.getElementById('offbox-status');
+  if (!el) return;
+  function fmtUtc(iso) {
+    var d = new Date(iso);
+    if (isNaN(d.getTime())) return '';
+    return String(d.getUTCHours()).padStart(2, '0') + ':' + String(d.getUTCMinutes()).padStart(2, '0') + ' UTC';
+  }
+  function setState(cls, text) { el.className = 'offbox-status offbox-status--' + cls; el.textContent = text; }
+  function update() {
+    fetch(OFFBOX_URL, { cache: 'no-store' })
+      .then(function (res) { if (!res.ok) throw new Error('HTTP ' + res.status); return res.json(); })
+      .then(function (data) {
+        var cur = data && data.current, status = cur && cur.status, when = fmtUtc(cur && cur.t);
+        if (status === 'up') setState('up', '\\uD83D\\uDFE2 amazonprimea.com is operational \\u2014 checked ' + when);
+        else if (status === 'down') setState('down', '\\uD83D\\uDD34 amazonprimea.com is DOWN \\u2014 checked ' + when);
+        else setState('unknown', 'status data is momentarily unavailable');
+      })
+      .catch(function () { setState('unknown', 'status data is momentarily unavailable'); });
+  }
+  update();
+  setInterval(update, 60000);
+})();
+</script>
+`;
+
+// ---- build the mirror index.html from the droplet source -------------------
+
+function injectOnce(haystack, anchor, insertion, where) {
+  const idx = haystack.indexOf(anchor);
+  if (idx < 0) throw new Error(`anchor not found in modules/status-ui/public/index.html: ${JSON.stringify(anchor)} — sync aborted (refusing a silent mis-publish).`);
+  if (where === 'before') return haystack.slice(0, idx) + insertion + haystack.slice(idx);
+  return haystack.slice(0, idx + anchor.length) + insertion + haystack.slice(idx + anchor.length);
+}
+
+function buildIndexHtml() {
+  let html = fs.readFileSync(path.join(SRC, 'index.html'), 'utf8');
+  if (html.includes('offbox-status')) {
+    throw new Error('modules/status-ui/public/index.html already contains offbox markup — the source should be the droplet (no-banner) copy. Aborting.');
+  }
+  html = injectOnce(html, '</head>', HEAD_INJECT + BRANDING_INJECT, 'before');
+  html = injectOnce(html, '<body>', BANNER_DIV, 'after');
+  // Insert the driver right before the main status.js script tag.
+  const scriptAnchor = '<script src="/status.js';
+  html = injectOnce(html, scriptAnchor, BANNER_DRIVER + '', 'before');
+  // Stamp the instance branding tokens LAST — GitHub Pages won't run the server's
+  // injection, so the mirror must resolve {{worldName}}/{{currency}}/… itself.
+  html = brandTokens(html);
+  return html;
+}
+
+// ---- copy the verbatim assets + the transformed index ----------------------
+
+function copyFile(rel) {
+  fs.copyFileSync(path.join(SRC, rel), path.join(repoDir, rel));
+  console.error(`  copied ${rel}`);
+}
+function copyDir(rel) {
+  const from = path.join(SRC, rel), to = path.join(repoDir, rel);
+  if (!fs.existsSync(from)) return;
+  fs.rmSync(to, { recursive: true, force: true });
+  fs.cpSync(from, to, { recursive: true });
+  console.error(`  copied ${rel}/`);
+}
+
+console.error('[status-mirror-sync] building mirror from modules/status-ui/public/ …');
+fs.writeFileSync(path.join(repoDir, 'index.html'), buildIndexHtml());
+console.error('  wrote index.html (with off-box injections)');
+copyFile('status.js');
+copyFile('style.css');
+copyDir('cursors');
+
+// ---- commit + (optionally) push -------------------------------------------
+
+function git(args) {
+  return execFileSync('git', ['-C', repoDir, ...args], { encoding: 'utf8' });
+}
+git(['add', 'index.html', 'status.js', 'style.css', 'cursors']);
+const status = git(['status', '--porcelain']);
+if (!status.trim()) {
+  console.error('[status-mirror-sync] mirror already up to date — nothing to publish.');
+  process.exit(0);
+}
+console.error('[status-mirror-sync] changes staged:\n' + status);
+if (!doPush) {
+  console.error('[status-mirror-sync] dry run (no --push). Review the checkout, then re-run with --push.');
+  process.exit(0);
+}
+git(['commit', '-m', 'chore(status): sync off-box mirror from modules/status-ui/public/ (#737)']);
+git(['push', 'origin', 'HEAD:main']);
+console.error('[status-mirror-sync] published. GitHub Pages rebuilds status.amazonprimea.com in ~1 min.');