@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/reach/spec3d.js

@@ -0,0 +1,338 @@
+import { fmt, maxRise, reachAcross } from "./envelope.js";
+const G = 0.25;
+const MAX_CELLS = 1_500_000;
+const TARGET_KINDS = ['exit', 'pickup', 'checkpoint'];
+export const isSpec = (raw) => !!raw && typeof raw === 'object' && !('tiles' in raw) && !('levels' in raw)
+    && (Array.isArray(raw.areas) || Array.isArray(raw.platforms)) && Array.isArray(raw.markers);
+export const SIGHT_M = 20;
+export function checkSpec(spec, file, env, judged, sealed, seen = []) {
+    const bodyH = env.size[1], radius = env.size[0] / 2, step = env.step, top = maxRise(env);
+    const areas = spec.areas ?? [], platforms = spec.platforms ?? [], ramps = spec.ramps ?? [];
+    const walls = spec.walls ?? [], markers = spec.markers ?? [];
+    const name = typeof spec.name === 'string' ? spec.name : file;
+    const xs = [], zs = [];
+    for (const r of [...areas, ...platforms, ...ramps]) {
+        xs.push(r.x, r.x + r.w);
+        zs.push(r.z, r.z + r.d);
+    }
+    for (const w of walls) {
+        xs.push(w.from[0], w.to[0]);
+        zs.push(w.from[1], w.to[1]);
+    }
+    for (const m of markers) {
+        xs.push(m.at[0]);
+        zs.push(m.at[2]);
+    }
+    const minX = Math.floor(Math.min(...xs) / G) * G - G, minZ = Math.floor(Math.min(...zs) / G) * G - G;
+    const nx = Math.ceil((Math.max(...xs) - minX) / G) + 2, nz = Math.ceil((Math.max(...zs) - minZ) / G) + 2;
+    const base = { file, name, kind: '3d', size: `${fmt(nx * G)}×${fmt(nz * G)} m` };
+    if (!Number.isFinite(nx * nz) || nx * nz > MAX_CELLS)
+        return { ...base, verdict: 'not_observed', gaps: [], findings: [{ status: 'not_observed', what: 'too large to lay on the grid' }] };
+    const ci = (x) => Math.round((x - minX) / G), cz = (z) => Math.round((z - minZ) / G);
+    const cell = (ix, iz) => ix * nz + iz;
+    const centre = (ix) => minX + (ix + 0.5) * G, centreZ = (iz) => minZ + (iz + 0.5) * G;
+    const places = [];
+    const surf = new Map();
+    const slabs = new Map();
+    const add = (m, k, v) => { const a = m.get(k); if (a)
+        a.push(v);
+    else
+        m.set(k, [v]); };
+    const rect = (r, each) => {
+        for (let ix = ci(r.x); ix < ci(r.x + r.w); ix++)
+            for (let iz = cz(r.z); iz < cz(r.z + r.d); iz++)
+                each(ix, iz);
+    };
+    for (const a of areas) {
+        if (a.kind === 'water')
+            continue;
+        const p = places.push({ name: a.name, kind: a.kind ?? 'room' }) - 1;
+        const fy = a.floor_y ?? 0;
+        rect(a, (ix, iz) => {
+            add(surf, cell(ix, iz), { y: fy, place: p });
+            add(slabs, cell(ix, iz), [fy - 0.2, fy]);
+            if ((a.kind ?? 'room') === 'room' && a.ceiling)
+                add(slabs, cell(ix, iz), [fy + (a.height ?? 3), fy + (a.height ?? 3) + 0.2]);
+        });
+    }
+    for (const pl of platforms) {
+        const p = places.push({ name: pl.name, kind: 'platform' }) - 1;
+        rect(pl, (ix, iz) => { add(surf, cell(ix, iz), { y: pl.y, place: p }); add(slabs, cell(ix, iz), [pl.y - (pl.thickness ?? 0.3), pl.y]); });
+    }
+    for (const r of ramps) {
+        const p = places.push({ name: r.name, kind: 'ramp' }) - 1;
+        rect(r, (ix, iz) => {
+            const x = centre(ix), z = centreZ(iz);
+            const t = r.dir === 'n' ? (r.z + r.d - z) / r.d : r.dir === 's' ? (z - r.z) / r.d : r.dir === 'e' ? (x - r.x) / r.w : (r.x + r.w - x) / r.w;
+            add(surf, cell(ix, iz), { y: r.from_y + t * (r.to_y - r.from_y), place: p });
+        });
+    }
+    const vWalls = new Map(), hWalls = new Map();
+    const holesAt = (openings, pos, y) => openings.filter((o) => pos >= o.at && pos <= o.at + o.width)
+        .map((o) => [y + (o.sill ?? 0), y + (o.sill ?? 0) + (o.height ?? 2.2)]);
+    const run = (vertical, line, from, to, origin, wy, height, openings) => {
+        const lo = Math.min(from, to), hi = Math.max(from, to);
+        for (let i = vertical ? cz(lo) : ci(lo); i < (vertical ? cz(hi) : ci(hi)); i++) {
+            const pos = Math.abs((vertical ? centreZ(i) : centre(i)) - origin);
+            add(vertical ? vWalls : hWalls, vertical ? cell(line, i) : cell(i, line), { base: wy, top: wy + height, holes: holesAt(openings, pos, wy) });
+        }
+    };
+    for (const a of areas) {
+        if ((a.kind ?? 'room') !== 'room' || a.walls === false)
+            continue;
+        const fy = a.floor_y ?? 0, h = a.height ?? 3, side = (s) => (a.openings ?? []).filter((o) => o.side === s);
+        run(false, cz(a.z), a.x, a.x + a.w, a.x, fy, h, side('n'));
+        run(false, cz(a.z + a.d), a.x, a.x + a.w, a.x, fy, h, side('s'));
+        run(true, ci(a.x), a.z, a.z + a.d, a.z, fy, h, side('w'));
+        run(true, ci(a.x + a.w), a.z, a.z + a.d, a.z, fy, h, side('e'));
+    }
+    for (const w of walls) {
+        const alongX = w.from[1] === w.to[1];
+        if (alongX)
+            run(false, cz(w.from[1]), w.from[0], w.to[0], w.from[0], w.y ?? 0, w.height ?? 3, w.openings ?? []);
+        else
+            run(true, ci(w.from[0]), w.from[1], w.to[1], w.from[1], w.y ?? 0, w.height ?? 3, w.openings ?? []);
+    }
+    const passes = (pieces, lo, hi) => {
+        if (!pieces)
+            return true;
+        const solid = [];
+        for (const p of pieces) {
+            let parts = [[p.base, p.top]];
+            for (const [a, b] of p.holes)
+                parts = parts.flatMap(([s, e]) => (b <= s || a >= e ? [[s, e]] : [[s, a], [b, e]].filter(([x, y]) => y - x > 1e-6)));
+            solid.push(...parts);
+        }
+        const free = (f) => solid.every(([s, e]) => e <= f + 0.01 || s >= f + bodyH - 0.01);
+        return [lo, ...solid.map(([, e]) => e)].some((f) => f >= lo - 1e-6 && f <= hi + 1e-6 && free(f));
+    };
+    const lineBetween = (a, b) => {
+        const ax = Math.floor(a / nz), az = a % nz, bx = Math.floor(b / nz), bz = b % nz;
+        if (ax !== bx)
+            return vWalls.get(cell(Math.max(ax, bx), az));
+        return hWalls.get(cell(ax, Math.max(az, bz)));
+    };
+    const nodeY = [], nodeCell = [], nodePlace = [];
+    const cellNodes = new Map();
+    for (const [c, list] of surf) {
+        const above = slabs.get(c) ?? [];
+        const ys = [...list].sort((a, b) => a.y - b.y).filter((s, i, all) => i === 0 || s.y - all[i - 1].y > 0.02);
+        for (const s of ys) {
+            const head = Math.min(Infinity, ...above.filter(([b]) => b > s.y + 0.01).map(([b]) => b));
+            if (head - s.y < bodyH - 1e-6)
+                continue;
+            add(cellNodes, c, nodeY.length);
+            nodeY.push(s.y);
+            nodeCell.push(c);
+            nodePlace.push(s.place);
+        }
+    }
+    const N = nodeY.length;
+    const NB = [[1, 0], [-1, 0], [0, 1], [0, -1]];
+    const neighbour = (c, dx, dz) => {
+        const ix = Math.floor(c / nz) + dx, iz = (c % nz) + dz;
+        return ix < 0 || iz < 0 || ix >= nx || iz >= nz ? -1 : cell(ix, iz);
+    };
+    const walk = (u, b) => {
+        const y = nodeY[u];
+        const land = (cellNodes.get(b) ?? []).filter((v) => nodeY[v] <= y + step + 1e-6).sort((p, q) => nodeY[q] - nodeY[p])[0];
+        if (land === undefined)
+            return null;
+        const m = Math.max(y, nodeY[land]);
+        if (!passes(lineBetween(nodeCell[u], b), m, m + step))
+            return null;
+        const drop = nodeY[land] < y - step - 1e-6;
+        if (drop && env.safeDrop !== null && y - nodeY[land] > env.safeDrop)
+            return null;
+        return { v: land, drop };
+    };
+    const reachR = Math.min(48, Math.ceil(Math.max(0, reachAcross(env, -20)) / G) + 1);
+    const jumps = (u, out) => {
+        if (env.height <= 0 && env.dash <= 0)
+            return;
+        const c = nodeCell[u], y = nodeY[u], ix = Math.floor(c / nz), iz = c % nz;
+        for (let dx = -reachR; dx <= reachR; dx++)
+            for (let dz = -reachR; dz <= reachR; dz++) {
+                const b = neighbour(c, dx, dz);
+                if (b < 0 || (dx === 0 && dz === 0))
+                    continue;
+                for (const v of cellNodes.get(b) ?? []) {
+                    const rise = nodeY[v] - y;
+                    const across = Math.max(0, Math.hypot(dx, dz) * G - G);
+                    const can = reachAcross(env, rise);
+                    if (!Number.isFinite(can) || across > can + 1e-6)
+                        continue;
+                    if (crossesClear(ix, iz, ix + dx, iz + dz, Math.max(y, nodeY[v]), y + top))
+                        out(v);
+                }
+            }
+    };
+    const crossesClear = (ax, az, bx, bz, lo, hi) => {
+        const steps = Math.max(Math.abs(bx - ax), Math.abs(bz - az)) * 2;
+        let px = ax, pz = az;
+        for (let s = 1; s <= steps; s++) {
+            const qx = Math.round(ax + ((bx - ax) * s) / steps), qz = Math.round(az + ((bz - az) * s) / steps);
+            for (const [fx, fz, tx, tz] of qx !== px && qz !== pz ? [[px, pz, qx, pz], [qx, pz, qx, qz]] : [[px, pz, qx, qz]]) {
+                if ((fx !== tx || fz !== tz) && !passes(lineBetween(cell(fx, fz), cell(tx, tz)), lo, hi))
+                    return false;
+            }
+            px = qx;
+            pz = qz;
+        }
+        return true;
+    };
+    const isEdge = (u) => NB.some(([dx, dz]) => {
+        const b = neighbour(nodeCell[u], dx, dz);
+        if (b < 0)
+            return true;
+        const w = walk(u, b);
+        return !w || w.drop || (cellNodes.get(b) ?? []).some((v) => nodeY[v] > nodeY[u] + step && nodeY[v] <= nodeY[u] + top);
+    });
+    const bfs = (starts, withJumps = true) => {
+        const seen = new Uint8Array(N);
+        const q = starts.filter((s) => s >= 0);
+        for (const s of q)
+            seen[s] = 1;
+        for (let h = 0; h < q.length; h++) {
+            const u = q[h];
+            const visit = (v) => { if (!seen[v]) {
+                seen[v] = 1;
+                q.push(v);
+            } };
+            for (const [dx, dz] of NB) {
+                const b = neighbour(nodeCell[u], dx, dz);
+                const w = b < 0 ? null : walk(u, b);
+                if (w && (withJumps || !w.drop))
+                    visit(w.v);
+            }
+            if (withJumps && isEdge(u))
+                jumps(u, visit);
+        }
+        return seen;
+    };
+    const nodesAt = (m) => {
+        const ix = ci(m.at[0] - G / 2), iz = cz(m.at[2] - G / 2), r = Math.ceil(radius / G);
+        const out = [];
+        for (let dx = -r; dx <= r; dx++)
+            for (let dz = -r; dz <= r; dz++) {
+                for (const v of cellNodes.get(cell(ix + dx, iz + dz)) ?? [])
+                    if (nodeY[v] - step - 0.05 <= m.at[1] && m.at[1] <= nodeY[v] + bodyH + top)
+                        out.push(v);
+            }
+        return out;
+    };
+    const where = (v) => `(x ${fmt(centre(Math.floor(nodeCell[v] / nz)))}, z ${fmt(centreZ(nodeCell[v] % nz))}, y ${fmt(nodeY[v])})`;
+    const findings = [];
+    const gaps = [];
+    const spawns = markers.filter((m) => m.kind === 'spawn');
+    if (!spawns.length)
+        return { ...base, verdict: 'not_observed', gaps, findings: [{ status: 'not_observed', what: 'no spawn marker', why: 'add a marker of kind "spawn" where the player starts' }] };
+    const reached = new Uint8Array(N);
+    const exits = markers.filter((m) => m.kind === 'exit');
+    const miss = judged ? 'fail' : 'not_observed';
+    for (const s of spawns) {
+        const start = nodesAt(s).filter((v) => nodeY[v] <= s.at[1] + step + 0.05).sort((a, b) => nodeY[b] - nodeY[a])[0];
+        if (start === undefined) {
+            findings.push({ status: 'fail', what: `spawn ${s.name} stands on nothing` });
+            continue;
+        }
+        const mine = bfs([start]);
+        mine.forEach((on, v) => { if (on)
+            reached[v] = 1; });
+        if (spawns.length > 1 && exits.length && !exits.some((e) => nodesAt(e).some((v) => mine[v]))) {
+            findings.push({ status: miss, what: `spawn ${s.name} reaches no exit` });
+        }
+    }
+    const approach = (targets) => {
+        const comp = bfs(targets, false);
+        const cand = [], from = [];
+        for (let v = 0; v < N; v++) {
+            if (comp[v])
+                cand.push(v);
+            else if (reached[v])
+                from.push(v);
+        }
+        const fromEdge = from.filter(isEdge);
+        const thin = (a, max) => (a.length <= max ? a : a.filter((_, i) => i % Math.ceil(a.length / max) === 0));
+        let best = null;
+        for (const r of thin(fromEdge.length ? fromEdge : from, 3000))
+            for (const t of thin(cand, 1500)) {
+                const rc = nodeCell[r], tc = nodeCell[t];
+                const rx = Math.floor(rc / nz), rz = rc % nz, tx = Math.floor(tc / nz), tz = tc % nz;
+                const d = Math.hypot(rx - tx, rz - tz) * G;
+                const across = Math.max(0, d - G), rise = nodeY[t] - nodeY[r];
+                const can = reachAcross(env, Math.min(rise, top));
+                const short = Math.max(0, rise - top) + Math.max(0, across - (Number.isFinite(can) ? can : 0));
+                let cost = (short > 0 ? short + 0.01 : 0.5) + d * 1e-4;
+                if (best && cost >= best.cost)
+                    continue;
+                const wall = !crossesClear(rx, rz, tx, tz, Math.max(nodeY[r], nodeY[t]), nodeY[r] + top);
+                if (wall)
+                    cost = 0.5 + d * 1e-4;
+                if (best && cost >= best.cost)
+                    continue;
+                best = { cost, gap: { from: where(r), to: where(t), across, rise, clears: rise > top || !Number.isFinite(can) ? null : can, blocked: wall || short === 0, wall } };
+            }
+        return best?.gap ?? null;
+    };
+    const report = (what, targets, allowed) => {
+        if (targets.some((v) => reached[v])) {
+            findings.push({ status: 'pass', what: `${what} reached` });
+            return;
+        }
+        if (!targets.length) {
+            findings.push({ status: allowed ? 'note' : miss, what: `${what}: nothing to stand on at it`, why: 'no floor, platform or ramp under it with room for the body' });
+            return;
+        }
+        const g = approach(targets);
+        findings.push({ status: allowed ? 'note' : miss, what: `${what} cannot be reached from the spawn${allowed ? ' (listed in reach.sealed)' : ''}`, why: judged ? undefined : 'on foot; no jump declared, so a jump could still reach it' });
+        if (g && !allowed && !gaps.some((o) => o.from === g.from && o.to === g.to))
+            gaps.push(g);
+    };
+    const reportSeen = (m) => {
+        const mx = ci(m.at[0]), mz = cz(m.at[2]);
+        const near = [];
+        for (let v = 0; v < N; v++) {
+            if (!reached[v])
+                continue;
+            const c = nodeCell[v], vx = Math.floor(c / nz), vz = c % nz;
+            const d = Math.hypot(vx - mx, vz - mz) * G;
+            if (d <= SIGHT_M)
+                near.push({ v, d });
+        }
+        near.sort((a, b) => a.d - b.d);
+        for (const { v, d } of near.slice(0, 400)) {
+            const c = nodeCell[v], vx = Math.floor(c / nz), vz = c % nz;
+            const mid = (nodeY[v] + bodyH * 0.9 + m.at[1]) / 2;
+            for (const [ex, ez] of [[mx, mz], [mx + 1, mz], [mx - 1, mz], [mx, mz + 1], [mx, mz - 1]]) {
+                if (crossesClear(vx, vz, ex, ez, mid - 0.05, mid + 0.05)) {
+                    findings.push({ status: 'pass', what: `${m.kind} ${m.name} seen from ${fmt(d)} m (a wall target, reach.seen)` });
+                    return;
+                }
+            }
+        }
+        findings.push({ status: sealed.includes(m.name) ? 'note' : miss, what: `${m.kind} ${m.name}: no reached place sees it within ${SIGHT_M} m`, why: near.length ? 'a wall stands between every reached place and it' : 'nothing reached comes within sight distance' });
+    };
+    for (const m of markers.filter((mk) => seen.includes(mk.name)))
+        reportSeen(m);
+    for (const m of markers.filter((mk) => TARGET_KINDS.includes(mk.kind) && !seen.includes(mk.name))) {
+        const at = nodesAt(m);
+        report(`${m.kind} ${m.name}`, at, sealed.includes(m.name));
+        if (!at.length && !sealed.includes(m.name))
+            findings.push({ status: 'note', what: `${m.name}: is it a wall target (a painting, a switch, a sign) played from where you stand?`, why: 'name it in funpixel.json reach.seen and reach checks the line of sight instead of a floor under it' });
+    }
+    places.forEach((p, i) => {
+        if (p.kind === 'platform' || p.kind === 'ramp')
+            return;
+        const own = [];
+        for (let v = 0; v < N; v++)
+            if (nodePlace[v] === i)
+                own.push(v);
+        report(`${p.kind} ${p.name}`, own, sealed.includes(p.name));
+    });
+    const lost = places.filter((p, i) => p.kind === 'platform' && !nodePlace.some((pl, v) => pl === i && reached[v])).map((p) => p.name);
+    if (lost.length)
+        findings.push({ status: 'note', what: `platforms never stood on: ${lost.slice(0, 8).join(', ')}${lost.length > 8 ? ` and ${lost.length - 8} more` : ''}` });
+    const verdict = findings.some((f) => f.status === 'fail') ? 'fail' : findings.some((f) => f.status === 'not_observed') ? 'not_observed' : 'pass';
+    return { ...base, verdict, findings, gaps };
+}

package/dist/reach/tiles.js

@@ -0,0 +1,163 @@
+const ROLES = ['solid', 'empty', 'spawn', 'exit', 'pickup', 'checkpoint', 'hazard', 'platform', 'ladder'];
+export const TARGET_ROLES = ['exit', 'pickup', 'checkpoint'];
+export const DEFAULT_LEGEND = {
+    '#': 'solid', X: 'solid', '.': 'empty', ' ': 'empty', '-': 'empty', S: 'spawn', '@': 'spawn', E: 'exit', G: 'exit',
+    '*': 'pickup', o: 'pickup', C: 'checkpoint', '^': 'hazard', '=': 'platform', H: 'ladder',
+};
+export function parseTileLevel(raw, fallbackName) {
+    if (!raw || typeof raw !== 'object' || !Array.isArray(raw.tiles) || raw.tiles.length === 0)
+        return 'no "tiles" rows';
+    if (raw.view !== 'side' && raw.view !== 'top')
+        return '"view" is "side" (platformer: gravity, jumps) or "top" (walks in four directions)';
+    const legend = { ...DEFAULT_LEGEND };
+    if (raw.legend && typeof raw.legend === 'object') {
+        for (const [k, v] of Object.entries(raw.legend)) {
+            if (!ROLES.includes(v))
+                return `legend "${k}": "${String(v)}" is not one of ${ROLES.join(', ')}`;
+            legend[k] = v;
+        }
+    }
+    const numeric = raw.tiles.every((r) => Array.isArray(r));
+    if (numeric && !raw.legend)
+        return 'number rows need a "legend" ({ "0": "empty", "1": "solid", … })';
+    const rows = raw.tiles.map((r) => (Array.isArray(r) ? r.map(String) : [...String(r)]));
+    const cols = Math.max(...rows.map((r) => r.length));
+    const unknown = new Set();
+    const cells = rows.map((r) => Array.from({ length: cols }, (_, c) => {
+        const ch = r[c] ?? ' ';
+        if (!(ch in legend)) {
+            unknown.add(ch);
+            return 'empty';
+        }
+        return legend[ch];
+    }));
+    return { name: typeof raw.name === 'string' ? raw.name : fallbackName, view: raw.view, cols, rows: rows.length, cells, unknown: [...unknown] };
+}
+export const at = (c, r) => `col ${c}, row ${r}`;
+export function targetsOf(level) {
+    const seen = new Set();
+    const out = [];
+    for (let r = 0; r < level.rows; r++)
+        for (let c = 0; c < level.cols; c++) {
+            const role = level.cells[r][c];
+            if (!TARGET_ROLES.includes(role) || seen.has(r * level.cols + c))
+                continue;
+            const cells = [];
+            const stack = [[c, r]];
+            seen.add(r * level.cols + c);
+            while (stack.length) {
+                const [x, y] = stack.pop();
+                cells.push([x, y]);
+                for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
+                    const nx = x + dx, ny = y + dy;
+                    if (nx < 0 || ny < 0 || nx >= level.cols || ny >= level.rows || seen.has(ny * level.cols + nx) || level.cells[ny][nx] !== role)
+                        continue;
+                    seen.add(ny * level.cols + nx);
+                    stack.push([nx, ny]);
+                }
+            }
+            out.push({ role, cells });
+        }
+    return out;
+}
+export function spawnsOf(level) {
+    const out = [];
+    level.cells.forEach((row, r) => row.forEach((role, c) => { if (role === 'spawn')
+        out.push([c, r]); }));
+    return out;
+}
+export function checkTop(level, file) {
+    const { cols, rows, cells } = level;
+    const open = (c, r) => c >= 0 && r >= 0 && c < cols && r < rows && cells[r][c] !== 'solid' && cells[r][c] !== 'hazard';
+    const base = { file, name: level.name, kind: 'top', size: `${cols}×${rows} tiles`, gaps: [] };
+    const spawns = spawnsOf(level);
+    if (!spawns.length)
+        return { ...base, verdict: 'not_observed', findings: [{ status: 'not_observed', what: 'no spawn tile', why: 'mark where the player starts (S or @, or a legend entry "spawn")' }] };
+    const reached = new Uint8Array(cols * rows);
+    const stack = spawns.filter(([c, r]) => open(c, r));
+    for (const [c, r] of stack)
+        reached[r * cols + c] = 1;
+    while (stack.length) {
+        const [c, r] = stack.pop();
+        for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
+            const nc = c + dx, nr = r + dy;
+            if (open(nc, nr) && !reached[nr * cols + nc]) {
+                reached[nr * cols + nc] = 1;
+                stack.push([nc, nr]);
+            }
+        }
+    }
+    const findings = [];
+    for (const t of targetsOf(level)) {
+        const [c, r] = t.cells[0];
+        const label = `${t.role} (${at(c, r)})`;
+        if (t.cells.some(([x, y]) => reached[y * cols + x])) {
+            findings.push({ status: 'pass', what: `${label} reached` });
+            continue;
+        }
+        const wall = nearestWall(level, reached, t.cells);
+        findings.push({ status: 'fail', what: `${label} cannot be reached from the spawn`, why: wall });
+    }
+    const inPocket = new Uint8Array(cols * rows);
+    for (let r = 0; r < rows; r++)
+        for (let c = 0; c < cols; c++) {
+            if (!open(c, r) || reached[r * cols + c] || inPocket[r * cols + c])
+                continue;
+            const region = [];
+            const s = [[c, r]];
+            inPocket[r * cols + c] = 1;
+            while (s.length) {
+                const [x, y] = s.pop();
+                region.push([x, y]);
+                for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
+                    const nx = x + dx, ny = y + dy;
+                    if (open(nx, ny) && !reached[ny * cols + nx] && !inPocket[ny * cols + nx]) {
+                        inPocket[ny * cols + nx] = 1;
+                        s.push([nx, ny]);
+                    }
+                }
+            }
+            if (region.some(([x, y]) => TARGET_ROLES.includes(cells[y][x])) || region.length < 2)
+                continue;
+            findings.push({ status: 'warn', what: `a sealed pocket of ${region.length} tiles at ${span(region)}`, why: 'no one can enter it: a room meant to be visited needs a way in' });
+        }
+    const verdict = findings.some((f) => f.status === 'fail') ? 'fail' : 'pass';
+    return { ...base, verdict, findings };
+}
+function nearestWall(level, reached, from) {
+    const { cols, rows, cells } = level;
+    const dist = new Int32Array(cols * rows).fill(-1);
+    let bucket = [], next = [];
+    for (const [c, r] of from) {
+        dist[r * cols + c] = 0;
+        bucket.push(r * cols + c);
+    }
+    for (let d = 0; bucket.length; d++, bucket = next, next = []) {
+        for (let h = 0; h < bucket.length; h++) {
+            const i = bucket[h];
+            if (dist[i] !== d)
+                continue;
+            if (reached[i])
+                return `${d} solid tile${d === 1 ? '' : 's'} (or hazards) stand between it and ${at(i % cols, Math.floor(i / cols))}, the nearest place the player reaches`;
+            const c = i % cols, r = Math.floor(i / cols);
+            for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
+                const nc = c + dx, nr = r + dy;
+                if (nc < 0 || nr < 0 || nc >= cols || nr >= rows)
+                    continue;
+                const j = nr * cols + nc;
+                const w = cells[nr][nc] === 'solid' || cells[nr][nc] === 'hazard' ? 1 : 0;
+                if (dist[j] !== -1 && dist[j] <= d + w)
+                    continue;
+                dist[j] = d + w;
+                (w ? next : bucket).push(j);
+            }
+        }
+    }
+    return 'nothing the player reaches connects to it';
+}
+export function span(cells) {
+    const xs = cells.map(([c]) => c), ys = cells.map(([, r]) => r);
+    const lo = (a) => Math.min(...a), hi = (a) => Math.max(...a);
+    const range = (a) => (lo(a) === hi(a) ? `${lo(a)}` : `${lo(a)}–${hi(a)}`);
+    return `col ${range(xs)}, row ${range(ys)}`;
+}

package/dist/reel/encode.js

@@ -0,0 +1,34 @@
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+export const OUT = { width: 1080, height: 1920 };
+export const FRAME_PATTERN = 'f%04d.png';
+export const frameName = (i) => `f${String(i).padStart(4, '0')}.png`;
+export function ffmpegBin() {
+    const r = spawnSync('ffmpeg', ['-version'], { stdio: 'ignore', shell: false });
+    return r.status === 0 ? 'ffmpeg' : null;
+}
+export function reelFilter(landscape) {
+    const { width: w, height: h } = OUT;
+    const cover = `scale=${w}:${h}:force_original_aspect_ratio=increase,crop=${w}:${h}`;
+    if (!landscape)
+        return `[0:v]${cover},format=yuv420p[v]`;
+    return `[0:v]split=2[bg][fg];[bg]${cover},gblur=sigma=28,eq=brightness=-0.12[bg2];`
+        + `[fg]scale=${w}:-2[fg2];[bg2][fg2]overlay=(W-w)/2:(H-h)/2,format=yuv420p[v]`;
+}
+export function ffmpegArgs(framesDir, fps, out, landscape) {
+    return [
+        '-hide_banner', '-loglevel', 'error', '-y',
+        '-framerate', String(fps), '-i', join(framesDir, FRAME_PATTERN),
+        '-filter_complex', reelFilter(landscape), '-map', '[v]',
+        '-c:v', 'libx264', '-preset', 'medium', '-crf', '21',
+        '-pix_fmt', 'yuv420p',
+        '-movflags', '+faststart',
+        out,
+    ];
+}
+export function encode(bin, framesDir, fps, out, landscape) {
+    const r = spawnSync(bin, ffmpegArgs(framesDir, fps, out, landscape), { encoding: 'utf8' });
+    if (r.status === 0)
+        return { ok: true };
+    return { ok: false, error: (r.stderr || r.error?.message || `ffmpeg exited ${r.status}`).trim().split('\n').slice(-3).join(' ') };
+}

package/dist/reel/tour.js

@@ -0,0 +1,81 @@
+export function checkedVerbs(checks) {
+    const list = (Array.isArray(checks) ? checks : []).filter((c) => !!c && typeof c === 'object' && typeof c.verb === 'string' && !!c.verb);
+    const tied = (c) => (typeof c.key === 'string' && !!c.key) || (typeof c.pointer === 'string' && !!c.pointer);
+    return { verbs: [...new Set(list.map((c) => c.verb))], input: [...new Set(list.filter(tied).map((c) => c.verb))] };
+}
+const TITLE = /^(title|menu|intro|splash|start)$/;
+const ENDING = /^(over|gameover|win|won|lose|lost|end|ending|results?|victory|defeat|complete|completed|scores?|highscores?)$/;
+const words = (name) => name.replace(/([a-z0-9])([A-Z])/g, '$1 $2').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+const named = (re, name) => words(name).some((w) => re.test(w));
+const NOT_PLAY = /^(reset|restart|retry|pause|resume|quit|exit|menu|title|mute|unmute|sound|debug|cheat|win|lose|die|kill|gameover|skip|next|level|load|save)/i;
+const NOT_PLAY_KEYS = /^(Escape|KeyP|KeyM|Tab|F\d+|Meta|Alt|Control)/;
+const endFrames = (total, fps) => Math.max(1, Math.min(Math.round(total * 0.15), fps * 2));
+export function planTour(d, checked, total, fps) {
+    const moments = d.views.filter((v) => v.moment);
+    const plain = d.views.filter((v) => !v.moment);
+    const motion = plain.find((v) => v.motion) ?? plain.find((v) => v.name === 'playing') ?? null;
+    const others = plain.filter((v) => v !== motion);
+    const title = others.find((v) => named(TITLE, v.name)) ?? null;
+    const ending = others.find((v) => v !== title && named(ENDING, v.name)) ?? null;
+    const setups = checked.input.length ? checked.verbs.filter((v) => !checked.input.includes(v)) : [];
+    const skipped = setups.filter((v) => d.verbs.includes(v));
+    const verbs = [...new Set([...checked.verbs.filter((v) => d.verbs.includes(v)), ...d.verbs])].filter((v) => !NOT_PLAY.test(v) && !setups.includes(v));
+    const keys = d.keys.filter((k) => !NOT_PLAY_KEYS.test(k));
+    const inputs = verbs.length ? verbs : keys;
+    const driven = verbs.length ? 'verbs' : keys.length ? 'keys' : 'passive';
+    const head = title && total >= 3 ? endFrames(total, fps) : 0;
+    const tail = ending && total - head >= 3 ? endFrames(total, fps) : 0;
+    const each = moments.length ? Math.min(fps * 2, Math.floor((total * 0.4) / moments.length)) : 0;
+    const staged = each >= 3 ? moments : [];
+    const segments = [];
+    if (head)
+        segments.push({ view: title.name, frames: head, play: false });
+    segments.push({ view: motion?.name ?? null, frames: total - head - tail - staged.length * each, play: true });
+    for (const m of staged)
+        segments.push({ view: m.name, frames: each, play: false });
+    if (tail)
+        segments.push({ view: ending.name, frames: tail, play: false });
+    return { segments, inputs, driven, skipped: driven === 'verbs' ? skipped : [] };
+}
+export function inputAt(tour, i, fps) {
+    if (!tour.inputs.length)
+        return null;
+    const every = Math.max(1, Math.round(fps / 4));
+    return i % every === 0 ? tour.inputs[(i / every) % tour.inputs.length] : null;
+}
+export async function readDeclared(page) {
+    const r = await page.evaluate(() => {
+        const w = window;
+        const obj = (v) => (v && typeof v === 'object' ? v : {});
+        const views = Object.entries(obj(w.__FPX_VIEWS__))
+            .filter(([, v]) => typeof obj(v).enter === 'function')
+            .map(([name, v]) => ({ name, motion: obj(v).motion === true, moment: obj(v).moment === true }));
+        const verbs = Object.entries(obj(w.__FPX_VERBS__)).filter(([, f]) => typeof f === 'function').map(([n]) => n);
+        return { views, verbs, keys: Object.keys(obj(w.__FPX_KEYS__)) };
+    }).catch(() => null);
+    return r ?? { views: [], verbs: [], keys: [] };
+}
+export async function enterView(page, name) {
+    await page.evaluate((n) => {
+        try {
+            (window.__FPX_VIEWS__)[n].enter();
+        }
+        catch { }
+    }, name).catch(() => { });
+}
+export async function press(page, tour, input, touch = null) {
+    if (tour.driven === 'verbs') {
+        await page.evaluate((n) => {
+            try {
+                (window.__FPX_VERBS__)[n]();
+            }
+            catch { }
+        }, input).catch(() => { });
+    }
+    else if (touch) {
+        await touch.tap(input, 180);
+    }
+    else {
+        await page.keyboard.press(input, { delay: 60 }).catch(() => { });
+    }
+}