@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/walk/world.js

@@ -0,0 +1,292 @@
+export const ACTORS_REF = 'skill funpixel-verify, references/actors.md';
+export const CROWD_REF = 'skill funpixel-world-and-story, references/living-world.md ("A few scenes, not a crowd")';
+export const groundTolerance = (h) => ({ touch: Math.max(0.25, 0.03 * h), drop: Math.max(1.5, 0.4 * h), sink: Math.max(0.5, 0.35 * h) });
+const OFF = new Set(['hovering', 'overhang', 'sunk']);
+export const groundTally = () => ({ things: new Map(), reads: 0, ground: new Set(), supports: new Map(), observed: false });
+export function tallyGround(tally, read, t) {
+    if (!read || read.engine !== 'three')
+        return;
+    tally.reads++;
+    for (const g of read.ground ?? [])
+        tally.ground.add(g);
+    for (const s of read.supports ?? [])
+        if (!tally.supports.has(s.name))
+            tally.supports.set(s.name, s.why);
+    if (!read.ground?.length && !read.supports?.length)
+        return;
+    tally.observed = true;
+    for (const x of read.things ?? []) {
+        if (x.verdict === 'no_ground')
+            continue;
+        const id = x.instance === null ? x.name : `${x.name}#${x.instance}`;
+        let s = tally.things.get(id);
+        if (!s) {
+            s = { id, name: x.name, kind: x.kind, landed: x.hint === 'landed', size: x.size, verdict: x.verdict, gap: x.gap, edge: null, readings: 0, off: 0, seen: 0, first_s: Math.round(t * 10) / 10 };
+            tally.things.set(id, s);
+        }
+        s.readings++;
+        const off = OFF.has(x.verdict);
+        if (off && x.on)
+            s.seen++;
+        if (!off)
+            continue;
+        const edge = Math.max(...x.corners.filter((c) => c !== null), -Infinity);
+        const worse = s.off === 0 || !OFF.has(s.verdict) || Math.abs(x.gap ?? 0) + Math.max(edge, 0) > Math.abs(s.gap ?? 0) + Math.max(s.edge ?? 0, 0);
+        s.off++;
+        if (worse) {
+            s.verdict = x.verdict;
+            s.gap = x.gap;
+            s.edge = Number.isFinite(edge) ? Math.round(edge * 100) / 100 : null;
+            s.size = x.size;
+            s.at = { x: x.at.x, z: x.at.z };
+            s.nearest = x.nearest ?? null;
+            s.farthest = x.farthest ?? null;
+            s.deepest = x.deepest ?? null;
+            s.tolerance = x.tolerance ?? groundTolerance(x.size.h);
+        }
+    }
+}
+const m = (v) => `${Math.abs(v) >= 10 ? Math.round(Math.abs(v)) : Math.abs(v) >= 1 ? Math.round(Math.abs(v) * 10) / 10 : Math.round(Math.abs(v) * 100) / 100} m`;
+export function partOf(s, p) {
+    if (!p || !s.at)
+        return null;
+    const dx = p.x - s.at.x, dz = p.z - s.at.z;
+    const ax = Math.abs(dx) >= 0.25 * Math.max(s.size.w, 0.01) ? (dx > 0 ? '+x' : '−x') : '';
+    const az = Math.abs(dz) >= 0.25 * Math.max(s.size.d, 0.01) ? (dz > 0 ? '+z' : '−z') : '';
+    return ax && az ? `its ${ax} ${az} corner` : ax || az ? `its ${ax || az} side` : 'its middle';
+}
+const tolOf = (s) => s.tolerance ?? groundTolerance(s.size.h);
+function headEntry(s) {
+    const t = tolOf(s);
+    if (s.verdict === 'hovering') {
+        const low = s.nearest?.gap ?? s.gap ?? s.edge ?? 0, high = s.farthest?.gap ?? null;
+        const spread = high !== null && high > low + 0.05;
+        const where = partOf(s, spread ? s.farthest : s.nearest);
+        return `${s.id} hovers ${spread ? `${m(low).slice(0, -2)}–${m(high)}` : m(low)}${where ? `, ${spread ? 'highest ' : ''}at ${where}` : ''} (tolerance ${m(t.touch)})`;
+    }
+    if (s.verdict === 'sunk') {
+        const where = partOf(s, s.deepest);
+        return `${s.id} sunk ${m(s.gap ?? 0)}${where ? ` at ${where}` : ''} (tolerance ${m(t.sink)})`;
+    }
+    const where = partOf(s, s.farthest);
+    return `${s.id} over a drop ${m(s.edge ?? 0)}${where ? ` at ${where}` : ''} (a drop is over ${m(t.drop)})`;
+}
+export function groundLine(s) {
+    const what = `${s.id} (${s.kind === 'vehicle' ? 'a vehicle, ' : ''}${Math.round(Math.max(s.size.w, s.size.d))} × ${Math.round(s.size.h)} m${s.at ? `, centre x ${s.at.x} z ${s.at.z}` : ''})`;
+    const t = tolOf(s);
+    if (s.verdict === 'hovering') {
+        const low = s.nearest?.gap ?? s.gap ?? s.edge ?? 0;
+        const near = partOf(s, s.nearest), far = partOf(s, s.farthest);
+        const high = s.farthest?.gap ?? s.edge;
+        return `${what} hovers ${m(low)} above the ground under it${near ? ` at ${near} (its lowest point)` : ''}${high !== null && high > low + (s.farthest ? 0.05 : 0.5) ? `, ${m(high)} at ${far ?? 'its far edge'}` : ''}; no point of its footprint is within ${m(t.touch)} of the ground (the tolerance), so lower it by at least ${m(Math.max(0, low - t.touch))}`;
+    }
+    if (s.verdict === 'overhang') {
+        const far = partOf(s, s.farthest);
+        return `${what} hangs over a drop: its footprint is ${m(s.edge ?? 0)} above the ground at ${far ?? 'the edge'}${s.gap !== null ? ` while its middle is ${s.gap < 0 ? `${m(s.gap)} into` : `${m(s.gap)} above`} it` : ''}; most of its points are more than ${m(t.drop)} up (a drop)`;
+    }
+    const deep = partOf(s, s.deepest);
+    return `${what} is sunk ${m(s.gap ?? 0)} into the ground${deep ? ` at ${deep}` : ''}; most of its points are more than ${m(t.sink)} under the surface (the tolerance)`;
+}
+export const offBy = (s) => Math.abs(s.gap ?? 0) + Math.max(s.edge ?? 0, 0);
+export const groundRank = (a, b) => Number(b.kind === 'vehicle' || b.landed) - Number(a.kind === 'vehicle' || a.landed) || offBy(b) - offBy(a);
+export function groundingChecks(tally) {
+    if (!tally.reads)
+        return [{ status: 'not_observed', text: 'grounding: no Three scene to read big props and vehicles from' }];
+    if (!tally.observed)
+        return [{ status: 'not_observed', text: 'grounding: no ground mesh found under the props (name the terrain mesh ground, terrain or floor; a built deck deck, pad or platform, or list it in the actors contract\'s supports)' }];
+    const all = [...tally.things.values()];
+    const off = all.filter((s) => OFF.has(s.verdict) && s.off * 2 >= s.readings);
+    const inView = off.filter((s) => s.seen > 0).sort(groundRank);
+    const unseen = off.filter((s) => s.seen === 0).sort(groundRank);
+    const out = [];
+    const built = [...tally.supports.keys()];
+    const on = built.length ? ` (built surfaces read as ground: ${built.slice(0, 6).join(', ')}${built.length > 6 ? ` +${built.length - 6}` : ''})` : '';
+    if (inView.length) {
+        const top = inView.slice(0, 3).map(headEntry);
+        out.push({
+            status: 'warn',
+            text: `OFF THE GROUND: ${inView.length} big prop(s) or vehicle(s) in view are not standing on the ground: ${top.join(', ')}${inView.length > 3 ? `, +${inView.length - 3} more` : ''}${on}`,
+            hint: `rest what is landed on the ground under its whole footprint: read the terrain height at its feet, legs or corners, never one fixed y, and keep it off an edge; a thing meant to fly says flying: true in the actors contract, a landed one landed: true; a deck or pad it stands on is named so or listed in supports (${ACTORS_REF})`,
+            items: inView.slice(0, 10).map(groundLine),
+        });
+    }
+    else
+        out.push({ status: 'pass', text: `grounding: ${all.filter((s) => !OFF.has(s.verdict) || s.off * 2 < s.readings).length} big prop(s) and vehicle(s) stand on the ground, a support or each other${on}` });
+    if (unseen.length)
+        out.push({ status: 'note', text: `grounding: ${unseen.length} more off the ground but never in view: ${unseen.slice(0, 6).map((s) => `${s.id} (${s.verdict})`).join(', ')}` });
+    return out;
+}
+export const crowdTally = () => ({ ids: new Set(), clumps: new Map(), prev: new Map(), pairs: new Map(), inferred: new Map(), walked: 0, last: null, empty: 0, emptyAt: null, emptyFrom: 0, gaps: [], ticks: 0 });
+export const VIEW_M = 30;
+export const TALK_M = 2.5;
+export const SCENE_READINGS = 4;
+export const pairKey = (a, b) => (a < b ? `${a}|${b}` : `${b}|${a}`);
+export function sharedScene(a, b, va, vb) {
+    const dx = b.x - a.x, dz = b.z - a.z, dist = Math.hypot(dx, dz);
+    if (typeof a.facing === 'number' && typeof b.facing === 'number' && dist > 0.05 && dist <= TALK_M) {
+        const ux = dx / dist, uz = dz / dist;
+        const ca = Math.sin(a.facing) * ux + Math.cos(a.facing) * uz, cb = -(Math.sin(b.facing) * ux + Math.cos(b.facing) * uz);
+        if (Math.abs(ca) > 0.5 && Math.abs(cb) > 0.5 && Math.sign(ca) === Math.sign(cb))
+            return 'face';
+    }
+    if (va && vb) {
+        const sa = Math.hypot(va.x, va.z), sb = Math.hypot(vb.x, vb.z);
+        if (sa > 0.3 && sb > 0.3 && Math.hypot(va.x - vb.x, va.z - vb.z) <= 0.35 * Math.max(sa, sb) + 0.15)
+            return 'together';
+    }
+    return null;
+}
+export function clumpsIn(people, clumpM, linked) {
+    const n = people.length, parent = people.map((_, i) => i);
+    const find = (i) => (parent[i] === i ? i : (parent[i] = find(parent[i])));
+    for (let i = 0; i < n; i++)
+        for (let j = i + 1; j < n; j++) {
+            const a = people[i], b = people[j];
+            if (a.scene && a.scene === b.scene)
+                continue;
+            if (linked && linked(a, b))
+                continue;
+            if (Math.hypot(a.x - b.x, a.z - b.z) < clumpM)
+                parent[find(i)] = find(j);
+        }
+    const groups = new Map();
+    for (let i = 0; i < n; i++) {
+        const r = find(i);
+        const l = groups.get(r) ?? [];
+        l.push(people[i]);
+        groups.set(r, l);
+    }
+    return [...groups.values()].filter((g) => g.length >= 2).map((g) => ({
+        ids: g.map((a) => a.id).sort(),
+        at: { x: Math.round((g.reduce((s, a) => s + a.x, 0) / g.length) * 10) / 10, z: Math.round((g.reduce((s, a) => s + a.z, 0) / g.length) * 10) / 10 },
+    }));
+}
+export function tallyCrowd(tally, actors, t, plan) {
+    const people = actors.filter((a) => a.kind === 'person');
+    const player = actors.find((a) => a.kind === 'player') ?? null;
+    tally.ticks++;
+    for (const p of people)
+        tally.ids.add(p.id);
+    const vel = new Map();
+    for (const p of people) {
+        const was = tally.prev.get(p.id);
+        if (was && t > was.t && t - was.t < 2)
+            vel.set(p.id, { x: (p.x - was.x) / (t - was.t), z: (p.z - was.z) / (t - was.t) });
+        tally.prev.set(p.id, { x: p.x, z: p.z, t });
+    }
+    const near = Math.max(plan.clumpM, TALK_M);
+    for (let i = 0; i < people.length; i++)
+        for (let j = i + 1; j < people.length; j++) {
+            const a = people[i], b = people[j];
+            if ((a.scene && b.scene) || Math.hypot(a.x - b.x, a.z - b.z) > near)
+                continue;
+            const how = sharedScene(a, b, vel.get(a.id) ?? null, vel.get(b.id) ?? null);
+            if (!how)
+                continue;
+            const key = pairKey(a.id, b.id), c = tally.pairs.get(key) ?? { face: 0, together: 0 };
+            c[how]++;
+            tally.pairs.set(key, c);
+            if (c[how] >= SCENE_READINGS && !tally.inferred.has(key))
+                tally.inferred.set(key, how);
+        }
+    for (const c of clumpsIn(people, plan.clumpM, (a, b) => tally.inferred.has(pairKey(a.id, b.id)))) {
+        const key = c.ids.join('|');
+        const was = tally.clumps.get(key);
+        if (was)
+            was.times++;
+        else
+            tally.clumps.set(key, { ...c, times: 1, first_s: Math.round(t * 10) / 10 });
+    }
+    if (!player)
+        return;
+    const here = { x: player.x, z: player.z };
+    const step = tally.last ? Math.hypot(here.x - tally.last.x, here.z - tally.last.z) : 0;
+    tally.last = here;
+    if (step > 25)
+        return;
+    tally.walked += step;
+    const screened = people.some((p) => p.screen);
+    const inView = people.some((p) => (screened ? !!p.screen?.on : Math.hypot(p.x - here.x, p.z - here.z) < VIEW_M));
+    if (inView) {
+        closeGap(tally, plan);
+        return;
+    }
+    if (!tally.emptyAt) {
+        tally.emptyAt = here;
+        tally.emptyFrom = tally.walked - step;
+        tally.empty = 0;
+    }
+    tally.empty += step;
+}
+function closeGap(tally, plan) {
+    if (tally.emptyAt && tally.empty >= plan.gapM)
+        tally.gaps.push({ from_m: Math.round(tally.emptyFrom), length_m: Math.round(tally.empty), at: { x: Math.round(tally.emptyAt.x), z: Math.round(tally.emptyAt.z) } });
+    tally.emptyAt = null;
+    tally.empty = 0;
+}
+export const CLUMP_READINGS = 4;
+export const CROWD_UNPLANNED_MAX = 20;
+export function mergedClumps(tally) {
+    const scened = (ids) => {
+        const seen = new Set([ids[0]]), todo = [ids[0]];
+        while (todo.length) {
+            const a = todo.pop();
+            for (const b of ids)
+                if (!seen.has(b) && tally.inferred.has(pairKey(a, b))) {
+                    seen.add(b);
+                    todo.push(b);
+                }
+        }
+        return seen.size === ids.length;
+    };
+    const held = [...tally.clumps.values()].filter((c) => c.times >= CLUMP_READINGS && !scened(c.ids)).sort((a, b) => b.times - a.times);
+    const out = [];
+    for (const c of held) {
+        const into = out.find((o) => c.ids.filter((id) => o.set.has(id)).length >= Math.min(2, c.ids.length));
+        if (!into) {
+            out.push({ ...c, ids: [...c.ids], set: new Set(c.ids) });
+            continue;
+        }
+        for (const id of c.ids)
+            into.set.add(id);
+        into.ids = [...into.set].sort();
+        into.first_s = Math.min(into.first_s, c.first_s);
+    }
+    return out.map(({ set: _set, ...c }) => c).sort((a, b) => b.ids.length - a.ids.length || b.times - a.times);
+}
+export function inferredScenes(tally) {
+    return [...tally.inferred.entries()].map(([k, how]) => `${k.replace('|', ' + ')} ${how === 'face' ? 'face each other' : 'move together'}`);
+}
+export function crowdChecks(tally, plan) {
+    closeGap(tally, plan);
+    const count = tally.ids.size;
+    if (!count)
+        return [];
+    const out = [];
+    const clumps = mergedClumps(tally);
+    const hint = `a crowd is a few readable scenes along the player's path, each one purpose (two haulers at the crane, a vendor and a buyer), spaced so each reads on its own and one comes into view as the last leaves (${CROWD_REF})`;
+    const inferred = inferredScenes(tally);
+    if (clumps.length)
+        out.push({ status: 'warn', text: `CLUMPS: ${clumps.length} knot(s) of people stand within ${plan.clumpM} m of each other with no shared scene (not tagged, not facing each other, not moving together)`, hint: `${hint}; people of one scene say so with scene: "<name>" in the actors contract`, items: clumps.slice(0, 8).map((c) => `${c.ids.length} people (${c.ids.slice(0, 6).join(', ')}${c.ids.length > 6 ? ` +${c.ids.length - 6}` : ''}) around (${c.at.x}, ${c.at.z}) from ${c.first_s} s, held up to ${c.times} reading(s)`) });
+    else
+        out.push({ status: 'pass', text: `spacing: no clumps (people closer than ${plan.clumpM} m share a scene${inferred.length ? `; ${inferred.length} untagged: inferred scene` : ''})` });
+    if (inferred.length)
+        out.push({ status: 'note', text: `scenes: ${inferred.length} pair(s) of people close together are untagged: inferred scene — ${inferred.slice(0, 6).join('; ')}${inferred.length > 6 ? `; +${inferred.length - 6}` : ''}`, hint: `tag them scene: "<name>" in the actors contract and the read is certain (${ACTORS_REF})` });
+    if (tally.gaps.length)
+        out.push({ status: 'warn', text: `EMPTY STRETCHES: ${tally.gaps.length} stretch(es) of the walk with nobody in view for ≥ ${plan.gapM} m`, hint, items: tally.gaps.slice(0, 8).map((g) => `${g.length_m} m from ${g.from_m} m walked, starting at (${g.at.x}, ${g.at.z})`) });
+    if (plan.people) {
+        const [lo, hi] = plan.people;
+        const want = lo === hi ? `${lo}` : `${lo}–${hi}`;
+        if (count > hi * 1.25)
+            out.push({ status: 'warn', text: `CROWD: ${count} people along the walk, the plan says ${want}`, hint });
+        else if (count < lo * 0.75)
+            out.push({ status: 'note', text: `crowd: ${count} people along the walk, fewer than the plan's ${want}` });
+        else
+            out.push({ status: 'pass', text: `crowd: ${count} people, the plan says ${want}` });
+    }
+    else if (count > CROWD_UNPLANNED_MAX)
+        out.push({ status: 'warn', text: `CROWD: ${count} people along the walk and no planned number`, hint: `${hint}; plan the number in funpixel.json walk.crowd.people` });
+    else
+        out.push({ status: 'note', text: `crowd: ${count} people along the walk (no planned number: funpixel.json walk.crowd.people)` });
+    return out;
+}

package/dist/world/brief.js

@@ -0,0 +1,86 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+import { designDoc, field, section } from "../gdd/doc.js";
+import { ROLES } from "./format.js";
+const EMPTY = { from: null, title: null, kind: null, rooms: null, chapters: [], props: [], palette: [], shapes: [], step: null };
+const placeholder = (s) => !s || /^<.*>$/.test(s.trim());
+const HEX = /#[0-9a-f]{6}\b/gi;
+export function parseKit(line) {
+    const out = [];
+    for (const raw of line.split(/[,;]/)) {
+        const m = /^\s*([^()]+?)\s*(?:\(([^)]*)\))?\s*$/.exec(raw);
+        if (!m || placeholder(m[1]))
+            continue;
+        const kind = m[1].trim().toLowerCase().replace(/\s+/g, '-');
+        const role = ROLES.includes((m[2] ?? '').trim().toLowerCase()) ? m[2].trim().toLowerCase() : 'dressing';
+        if (kind && !out.some((p) => p.kind === kind))
+            out.push({ kind, role });
+    }
+    return out;
+}
+export function placesOf(md) {
+    const rows = section(md, 'Places').split('\n').filter((l) => /^\s*\|/.test(l));
+    if (rows.length < 2)
+        return [];
+    const cells = (l) => l.trim().replace(/^\||\|$/g, '').split('|').map((c) => c.trim());
+    const head = cells(rows[0]).map((h) => h.toLowerCase());
+    const lm = head.findIndex((h) => h.startsWith('landmark'));
+    return rows.slice(1).filter((l) => !/^\s*\|[\s:|-]+\|\s*$/.test(l)).map(cells)
+        .filter((c) => !placeholder(c[0] ?? ''))
+        .map((c) => ({ name: c[0].replace(/\*+/g, ''), ...(lm >= 0 && !placeholder(c[lm] ?? '') ? { landmark: c[lm] } : {}) }));
+}
+export function briefFromMarkdown(md, from) {
+    const title = /^#\s+(.+)$/m.exec(md)?.[1]?.replace(/\*+/g, '').trim() ?? null;
+    return {
+        ...EMPTY, from, title: title && !placeholder(title) ? title : null,
+        chapters: placesOf(md), props: parseKit(field(md, 'Kit')), palette: (field(md, 'Palette').match(HEX) ?? []).map((h) => h.toLowerCase()),
+    };
+}
+export function briefFromJson(raw, from) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return 'a JSON brief is an object';
+    if (raw.kind !== undefined && raw.kind !== '2d' && raw.kind !== '3d')
+        return '"kind" is "2d" or "3d"';
+    const strs = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string') : []);
+    const props = [];
+    for (const p of Array.isArray(raw.props) ? raw.props : []) {
+        const kind = typeof p === 'string' ? p : p?.kind;
+        const role = typeof p === 'object' && ROLES.includes(p?.role) ? p.role : 'dressing';
+        if (typeof kind === 'string' && kind.trim())
+            props.push({ kind: kind.trim(), role });
+    }
+    const chapters = (Array.isArray(raw.chapters) ? raw.chapters : []).map((c) => (typeof c === 'string' ? { name: c } : c && typeof c.name === 'string' ? { name: c.name, ...(typeof c.landmark === 'string' ? { landmark: c.landmark } : {}) } : null)).filter(Boolean);
+    const rooms = Number.isInteger(raw.rooms) && raw.rooms > 0 ? raw.rooms : null;
+    const step = typeof raw.step === 'number' && raw.step > 0 ? raw.step : null;
+    return { from, title: typeof raw.title === 'string' ? raw.title : null, kind: raw.kind ?? null, rooms, chapters, props, palette: strs(raw.palette).filter((h) => /^#[0-9a-f]{6}$/i.test(h)).map((h) => h.toLowerCase()), shapes: strs(raw.shapes), step };
+}
+export function kindOfGame(root) {
+    try {
+        const m = JSON.parse(readFileSync(join(root, 'funpixel.json'), 'utf8'));
+        const fw = String(m?.metadata?.framework ?? m?.framework ?? '').toLowerCase();
+        return /three/.test(fw) ? '3d' : /pixi|phaser|canvas/.test(fw) ? '2d' : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function readBrief(root, from) {
+    if (from) {
+        const p = resolve(root, from);
+        if (!existsSync(p))
+            return `no such brief: ${from}`;
+        const text = readFileSync(p, 'utf8');
+        const rel = relative(root, p) || from;
+        if (/\.json$/i.test(p)) {
+            try {
+                return briefFromJson(JSON.parse(text), rel);
+            }
+            catch (e) {
+                return `${from} is not JSON: ${e.message}`;
+            }
+        }
+        return briefFromMarkdown(text, rel);
+    }
+    const doc = designDoc(root);
+    return doc ? briefFromMarkdown(doc.text, doc.rel) : { ...EMPTY };
+}

package/dist/world/check.js

@@ -0,0 +1,254 @@
+import { estimate, flood3d } from "./forge.js";
+import { SOLID_ROLES, TILE, WORLD_FORMAT } from "./format.js";
+const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const cellOf = (at, cell, kind) => {
+    if (!Array.isArray(at) || !at.every((n) => typeof n === 'number' && Number.isFinite(n)))
+        return null;
+    return kind === '3d' ? [Math.floor(at[0] / cell), Math.floor((at[2] ?? at[1]) / cell)] : [Math.floor(at[0]), Math.floor(at[1])];
+};
+const where = (c) => `col ${c[0]}, row ${c[1]}`;
+function flood2d(tiles, from) {
+    const rows = tiles.length, cols = tiles[0]?.length ?? 0;
+    const open = (x, y) => x >= 0 && y >= 0 && x < cols && y < rows && tiles[y][x] !== TILE.solid && tiles[y][x] !== TILE.hazard;
+    const seen = new Set();
+    if (!open(from[0], from[1]))
+        return seen;
+    seen.add(from.join(','));
+    const stack = [from];
+    while (stack.length) {
+        const [x, y] = stack.pop();
+        for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
+            const nx = x + dx, ny = y + dy, k = `${nx},${ny}`;
+            if (open(nx, ny) && !seen.has(k)) {
+                seen.add(k);
+                stack.push([nx, ny]);
+            }
+        }
+    }
+    return seen;
+}
+export function checkWorld(raw, sidecar) {
+    const findings = [];
+    const add = (status, what, room, why) => findings.push({ status, what, ...(room ? { room } : {}), ...(why ? { why } : {}) });
+    const done = (rooms, kind = '?') => ({ verdict: findings.some((f) => f.status === 'fail') ? 'fail' : findings.some((f) => f.status === 'warn') ? 'warn' : 'pass', kind, rooms, findings });
+    if (!isObj(raw)) {
+        add('fail', 'world.json is not an object');
+        return done([]);
+    }
+    const w = raw;
+    if (w.format !== WORLD_FORMAT)
+        add('warn', `"format" is ${JSON.stringify(w.format)}, not "${WORLD_FORMAT}"`, undefined, 'read as a world anyway');
+    if (w.kind !== '2d' && w.kind !== '3d') {
+        add('fail', '"kind" is "2d" or "3d"');
+        return done([]);
+    }
+    const kind = w.kind;
+    for (const k of ['rooms', 'edges', 'chapters', 'critical_path'])
+        if (!Array.isArray(w[k]))
+            add('fail', `"${k}" is not a list`);
+    if (findings.some((f) => f.status === 'fail'))
+        return done([], kind);
+    if (!w.rooms.length) {
+        add('fail', 'no rooms');
+        return done([], kind);
+    }
+    const cell = typeof w.cell === 'number' && w.cell > 0 ? w.cell : kind === '3d' ? 2 : 1;
+    const step = typeof w.movement?.step === 'number' && w.movement.step > 0 ? w.movement.step : 0.6;
+    const budgets = isObj(w.budgets) ? w.budgets : {};
+    const declared = new Set((Array.isArray(w.props) ? w.props : []).map((p) => p?.kind).filter((k) => typeof k === 'string'));
+    const dupes = (ids, what, room) => {
+        const seen = new Set();
+        for (const id of ids) {
+            if (typeof id !== 'string' || !id)
+                add('fail', `a ${what} without an id`, room);
+            else if (seen.has(id))
+                add('fail', `${what} id "${id}" is used twice`, room);
+            seen.add(id);
+        }
+    };
+    dupes(w.rooms.map((r) => r?.id), 'room');
+    dupes(w.edges.map((e) => e?.id), 'edge');
+    dupes(w.chapters.map((c) => c?.id), 'chapter');
+    const rooms = new Map(w.rooms.filter((r) => isObj(r) && typeof r.id === 'string').map((r) => [r.id, r]));
+    const chapters = new Map(w.chapters.filter(isObj).map((c) => [c.id, c]));
+    for (const c of chapters.values())
+        for (const id of Array.isArray(c.rooms) ? c.rooms : []) {
+            if (!rooms.has(id))
+                add('fail', `chapter ${c.id} names room "${id}", which does not exist`);
+            else if (rooms.get(id).chapter !== c.id)
+                add('warn', `chapter ${c.id} lists room ${id}, whose own "chapter" is ${JSON.stringify(rooms.get(id).chapter)}`);
+        }
+    for (const r of rooms.values())
+        if (!chapters.has(r.chapter))
+            add('fail', `room ${r.id} names chapter ${JSON.stringify(r.chapter)}, which does not exist`, r.id);
+    const edges = w.edges.filter((e) => isObj(e));
+    for (const e of edges)
+        for (const end of ['from', 'to'])
+            if (!rooms.has(e[end]))
+                add('fail', `edge ${e.id} ${end} "${e[end]}" is not a room`);
+    for (const e of edges) {
+        for (const [here, there] of [[e.from, e.to], [e.to, e.from]]) {
+            const r = rooms.get(here);
+            if (!r)
+                continue;
+            const d = (Array.isArray(r.doors) ? r.doors : []).find((x) => x?.id === e.id);
+            if (!d)
+                add('fail', `edge ${e.id} (${e.from} ↔ ${e.to}) has no door in room ${here}`, here);
+            else if (d.to !== there)
+                add('fail', `door ${e.id} in room ${here} leads to "${d.to}", but its edge joins ${there}`, here);
+        }
+    }
+    for (const r of rooms.values())
+        for (const d of Array.isArray(r.doors) ? r.doors : []) {
+            if (!edges.some((e) => e.id === d?.id && (e.from === r.id || e.to === r.id)))
+                add('fail', `door ${d?.id} in room ${r.id} belongs to no edge of this room`, r.id, 'a door with no edge is a way out nothing leads through');
+        }
+    const summaries = [];
+    for (const r of rooms.values()) {
+        const before = findings.length;
+        const places = Array.isArray(r.places) ? r.places : [];
+        const doors = Array.isArray(r.doors) ? r.doors : [];
+        const instances = Array.isArray(r.instances) ? r.instances : [];
+        dupes(instances.map((i) => i?.id), 'instance', r.id);
+        dupes(doors.map((d) => d?.id), 'door', r.id);
+        for (const i of instances)
+            if (typeof i?.kind === 'string' && declared.size && !declared.has(i.kind))
+                add('warn', `instance ${i.id} is a "${i.kind}", a kind the world's props do not declare`, r.id, 'the forger uses only the game\'s own kinds; add it to "props" or rename it');
+        const arrival = places.find((p) => p?.name === 'arrival');
+        let size = '?', reachedCount = 0, openCount = 0;
+        let reached = null;
+        let inBounds = () => false;
+        if (kind === '2d') {
+            const side = r.file ? sidecar(r.file) : null;
+            const tiles = Array.isArray(r.tiles) ? r.tiles : isObj(side) && Array.isArray(side.tiles) ? side.tiles : null;
+            if (!tiles || !tiles.length || !tiles.every((t) => typeof t === 'string'))
+                add('fail', r.file ? `no tile rows in ${r.file}` : 'no "tiles" rows', r.id);
+            else {
+                const cols = tiles[0].length, rows = tiles.length;
+                size = `${cols}×${rows} tiles`;
+                if (!tiles.every((t) => t.length === cols))
+                    add('fail', 'tile rows differ in length', r.id);
+                inBounds = (c) => c[0] >= 0 && c[1] >= 0 && c[0] < cols && c[1] < rows;
+                let spawn = null;
+                tiles.forEach((t, y) => { const x = t.indexOf(TILE.spawn); if (x >= 0 && !spawn)
+                    spawn = [x, y]; });
+                const from = cellOf(arrival?.at, cell, kind) ?? spawn;
+                if (!from)
+                    add('fail', 'no arrival: no "arrival" place and no S tile', r.id);
+                else {
+                    reached = flood2d(tiles, from);
+                    if (!reached.size)
+                        add('fail', `the arrival (${where(from)}) is inside a wall or a hazard`, r.id);
+                    for (let y = 0; y < rows; y++)
+                        for (let x = 0; x < cols; x++) {
+                            const ch = tiles[y][x];
+                            if (ch !== TILE.solid && ch !== TILE.hazard)
+                                openCount++;
+                            if ((ch === TILE.goal || ch === TILE.pickup) && reached.size && !reached.has(`${x},${y}`))
+                                add('fail', `${ch === TILE.goal ? 'the goal' : 'a pickup'} at ${where([x, y])} cannot be reached from the arrival`, r.id);
+                        }
+                    reachedCount = reached.size;
+                    for (const d of doors) {
+                        const c = cellOf(d?.at, 1, kind);
+                        if (!c || !inBounds(c)) {
+                            add('fail', `door ${d?.id} sits outside the room`, r.id);
+                            continue;
+                        }
+                        if (tiles[c[1]][c[0]] !== TILE.door)
+                            add('warn', `door ${d.id} at ${where(c)} is not a D tile`, r.id);
+                        if (reached.size && !reached.has(c.join(',')))
+                            add('fail', `door ${d.id} (to ${d.to}) at ${where(c)} cannot be reached from the arrival`, r.id, 'a wall or a hazard closes the way');
+                    }
+                    if (reached.size && openCount - reachedCount >= 2)
+                        add('warn', `${openCount - reachedCount} open tile(s) no one can enter`, r.id, 'a sealed pocket: wall it in or give it a way in');
+                }
+            }
+        }
+        else {
+            const hf = typeof r.heights === 'string' ? sidecar(r.heights) : null;
+            const h = isObj(hf) && Array.isArray(hf.heights) ? hf.heights : null;
+            if (!h || !h.length || !h.every((row) => Array.isArray(row) && row.every((n) => typeof n === 'number' && Number.isFinite(n))))
+                add('fail', `no heightfield${typeof r.heights === 'string' ? ` in ${r.heights}` : ' ("heights" names no sidecar)'}`, r.id);
+            else {
+                const rows = h.length, cols = h[0].length;
+                size = `${cols}×${rows} cells`;
+                if (!h.every((row) => row.length === cols))
+                    add('fail', 'heightfield rows differ in length', r.id);
+                inBounds = (c) => c[0] >= 0 && c[1] >= 0 && c[0] < cols && c[1] < rows;
+                const blocked = new Set(instances.filter((i) => i?.solid || SOLID_ROLES.includes(i?.role) && i?.solid !== false).map((i) => cellOf(i.pos, cell, kind)).filter(Boolean).map((c) => c.join(',')));
+                const from = cellOf(arrival?.at, cell, kind);
+                if (!from || !inBounds(from))
+                    add('fail', 'no arrival place inside the heightfield', r.id);
+                else if (blocked.has(from.join(',')))
+                    add('fail', `the arrival (${where(from)}) stands inside a solid prop`, r.id);
+                else {
+                    reached = flood3d(h, from, step, blocked);
+                    reachedCount = reached.size;
+                    openCount = cols * rows - blocked.size;
+                    for (const d of doors) {
+                        const c = cellOf(d?.at, 1, '2d');
+                        if (!c || !inBounds(c)) {
+                            add('fail', `door ${d?.id} sits outside the room`, r.id);
+                            continue;
+                        }
+                        if (!reached.has(c.join(',')))
+                            add('fail', `door ${d.id} (to ${d.to}) at ${where(c)} cannot be reached from the arrival`, r.id, `a rise over ${step} m or a solid prop closes every way`);
+                    }
+                }
+            }
+        }
+        if (reached?.size)
+            for (const p of places) {
+                if (!p || p.name === 'arrival' || p.name === 'landmark')
+                    continue;
+                const c = cellOf(p.at, cell, kind);
+                if (!c || !inBounds(c))
+                    add('fail', `place "${p.name}" sits outside the room`, r.id);
+                else if (!reached.has(c.join(',')))
+                    add('fail', `place "${p.name}" at ${where(c)} cannot be reached from the arrival`, r.id);
+            }
+        let est = null;
+        if (instances.every((i) => Array.isArray(i?.pos))) {
+            est = estimate(instances, kind, arrival?.at ?? [0, 0, 0], typeof budgets.lod_far === 'number' ? budgets.lod_far : undefined);
+            if (typeof budgets.instances === 'number' && est.instances > budgets.instances)
+                add('warn', `${est.instances} instances, over the budget of ${budgets.instances}`, r.id, 'thin the dressing, or raise budgets.instances on purpose');
+            if (typeof budgets.draw_calls === 'number' && est.draw_calls > budgets.draw_calls)
+                add('warn', `about ${est.draw_calls} draw calls (ground + one per kind + one per light), over the budget of ${budgets.draw_calls}`, r.id, 'fewer kinds in this room, or instance them');
+        }
+        const mine = findings.slice(before).filter((f) => f.room === r.id);
+        summaries.push({ id: r.id, verdict: mine.some((f) => f.status === 'fail') ? 'fail' : mine.some((f) => f.status === 'warn') ? 'warn' : 'pass', size, reached: reachedCount, open: openCount, estimate: est });
+    }
+    const path = w.critical_path.filter((id) => typeof id === 'string');
+    const start = path[0] ?? [...rooms.values()].find((r) => r.role === 'arrival')?.id;
+    if (!start || !rooms.has(start))
+        add('fail', 'no arrival room: critical_path is empty or names no room');
+    else {
+        const next = new Map();
+        for (const e of edges) {
+            if (!rooms.has(e.from) || !rooms.has(e.to))
+                continue;
+            next.set(e.from, [...(next.get(e.from) ?? []), e.to]);
+            next.set(e.to, [...(next.get(e.to) ?? []), e.from]);
+        }
+        const seen = new Set([start]);
+        const queue = [start];
+        while (queue.length)
+            for (const n of next.get(queue.shift()) ?? [])
+                if (!seen.has(n)) {
+                    seen.add(n);
+                    queue.push(n);
+                }
+        for (const id of rooms.keys())
+            if (!seen.has(id))
+                add('fail', `room ${id} cannot be reached from the arrival room ${start}`, id, 'no chain of doors leads there');
+        const goals = [...rooms.values()].filter((r) => (Array.isArray(r.places) ? r.places : []).some((p) => p?.name === 'goal'));
+        if (!goals.length)
+            add('fail', 'no room holds the goal', undefined, 'give the last room of the critical path a "goal" place');
+        for (let i = 1; i < path.length; i++)
+            if (!(next.get(path[i - 1]) ?? []).includes(path[i]))
+                add('fail', `the critical path steps from ${path[i - 1]} to ${path[i]}, and no door joins them`);
+        if (path.length && goals.length && !goals.some((g) => g.id === path[path.length - 1]))
+            add('warn', `the critical path ends in ${path[path.length - 1]}, not in the goal room (${goals.map((g) => g.id).join(', ')})`);
+    }
+    return done(summaries, kind);
+}