@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/plan/actions.js

@@ -0,0 +1,18 @@
+import { designDoc, planVersion } from "../gdd/doc.js";
+import { lockDesign } from "../greenlight/lock.js";
+import { writePage } from "../greenlight/page.js";
+import { markApplied } from "./notes.js";
+import { readStudio } from "../studio/pitch.js";
+import { lockStudio, studioFor } from "../commands/pitch.js";
+import { lockRefusal } from "../studio/forks.js";
+export const currentVersion = (root) => planVersion(designDoc(root)?.text ?? '');
+export function apply(root, o = {}, now = new Date()) {
+    const version = currentVersion(root);
+    const why = o.why?.trim();
+    const lock = lockDesign(root, { version, ...(why ? { override: why } : {}) }, now);
+    if (readStudio(root) && (o.by === 'owner' || !lockRefusal(root, studioFor(root).studio)))
+        lockStudio(root, now);
+    writePage(root);
+    const applied = markApplied(root, { version: lock.version, date: lock.date, at: now.toISOString(), by: o.by ?? 'agent', ...(lock.decision ? { decision: lock.decision } : {}), ...(lock.override ? { override: lock.override } : {}) });
+    return { lock, applied };
+}

package/dist/plan/notes.js

@@ -0,0 +1,15 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+export const NOTES_FILE = join('design', 'plan-notes.json');
+export function markApplied(root, a) {
+    const f = join(root, NOTES_FILE);
+    let s = {};
+    try {
+        s = JSON.parse(readFileSync(f, 'utf8'));
+    }
+    catch { }
+    const applied = { at: new Date().toISOString(), ...a };
+    mkdirSync(dirname(f), { recursive: true });
+    writeFileSync(f, JSON.stringify({ ...s, applied }, null, 2) + '\n');
+    return applied;
+}

package/dist/play/clock.js

@@ -0,0 +1,40 @@
+export const PLAY_CLOCK = `(() => {
+  if (window.__FPX_PLAY_CLOCK__) return;
+  const perfNow = performance.now.bind(performance), dateNow = Date.now.bind(Date);
+  const raf = window.requestAnimationFrame.bind(window), caf = window.cancelAnimationFrame.bind(window);
+  const st = window.setTimeout.bind(window), si = window.setInterval.bind(window), ct = window.clearTimeout.bind(window), ci = window.clearInterval.bind(window);
+  let paused = false, pausedAt = 0, offset = 0, next = 1;
+  const frames = new Map(), held = [];
+  performance.now = () => (paused ? pausedAt : perfNow()) - offset;
+  Date.now = () => Math.round(dateNow() - offset - (paused ? perfNow() - pausedAt : 0));
+  const frame = (id, cb) => raf((t) => {
+    if (!frames.has(id)) return;
+    if (paused) { frames.set(id, frame(id, cb)); return; }
+    frames.delete(id);
+    cb(t - offset);
+  });
+  window.requestAnimationFrame = (cb) => { const id = next++; frames.set(id, frame(id, cb)); return id; };
+  window.cancelAnimationFrame = (id) => { const n = frames.get(id); if (n !== undefined) caf(n); frames.delete(id); };
+  const later = (fn, args) => () => { if (paused) held.push(() => fn(...args)); else fn(...args); };
+  window.setTimeout = (fn, ms, ...args) => typeof fn === 'function' ? st(later(fn, args), ms) : st(fn, ms);
+  window.setInterval = (fn, ms, ...args) => {
+    if (typeof fn !== 'function') return si(fn, ms);
+    let pending = false;
+    return si(() => { if (!paused) return fn(...args); if (!pending) { pending = true; held.push(() => { pending = false; fn(...args); }); } }, ms);
+  };
+  window.clearTimeout = ct; window.clearInterval = ci;
+  window.__FPX_PLAY_CLOCK__ = {
+    pause() {
+      if (paused) return;
+      paused = true; pausedAt = perfNow();
+      try { for (const a of document.getAnimations()) if (a.playState === 'running') { a.pause(); a.__fpxHeld = true; } } catch (e) {}
+    },
+    resume() {
+      if (!paused) return;
+      offset += perfNow() - pausedAt; paused = false;
+      try { for (const a of document.getAnimations()) if (a.__fpxHeld) { a.__fpxHeld = false; a.play(); } } catch (e) {}
+      for (const f of held.splice(0)) { try { f(); } catch (e) { setTimeout(() => { throw e; }); } }
+    },
+    get paused() { return paused; },
+  };
+})();`;

package/dist/play/condition.js

@@ -0,0 +1,45 @@
+const EXPECT = /^([A-Za-z_][\w.]*)(>=|<=|!=|==|=|>|<)(.+)$/;
+export function literal(s) {
+    if (s === 'true' || s === 'false')
+        return s === 'true';
+    return /^-?\d+(\.\d+)?$/.test(s) ? Number(s) : s;
+}
+export function parseExpect(text) {
+    const m = EXPECT.exec(text.trim());
+    return m ? { field: m[1], op: (m[2] === '==' ? '=' : m[2]), value: literal(m[3]) } : null;
+}
+export const expectText = (e) => `${e.field}${e.op}${e.value}`;
+export function fieldOf(state, path) {
+    let v = state;
+    for (const k of path.split('.')) {
+        if (v === null || v === undefined)
+            return undefined;
+        if (k === 'length' && Array.isArray(v))
+            return v.length;
+        v = v[k];
+    }
+    return v;
+}
+export function judgeExpect(e, state) {
+    const got = state && typeof state === 'object' ? fieldOf(state, e.field) : undefined;
+    const base = { field: e.field, op: e.op, want: e.value, got };
+    if (got === undefined)
+        return { ...base, verdict: 'not_observed' };
+    const num = typeof e.value === 'number' && typeof got === 'number';
+    let ok;
+    switch (e.op) {
+        case '=':
+            ok = String(got) === String(e.value);
+            break;
+        case '!=':
+            ok = String(got) !== String(e.value);
+            break;
+        default: {
+            if (!num)
+                return { ...base, verdict: 'not_observed' };
+            const a = got, b = e.value;
+            ok = e.op === '>' ? a > b : e.op === '<' ? a < b : e.op === '>=' ? a >= b : a <= b;
+        }
+    }
+    return { ...base, verdict: ok ? 'pass' : 'fail' };
+}

package/dist/play/frames.js

@@ -0,0 +1,60 @@
+import { writeFile } from 'node:fs/promises';
+import { decodePng } from "../look/png.js";
+export const LOOK_PX = 360;
+const cdps = new WeakMap();
+export async function smallFrame(page, path, longSide = LOOK_PX) {
+    const size = page.viewportSize() ?? { width: 1280, height: 720 };
+    const scale = Math.min(1, longSide / Math.max(size.width, size.height));
+    if (!cdps.has(page))
+        cdps.set(page, await page.context().newCDPSession(page).catch(() => null));
+    const cdp = cdps.get(page);
+    if (cdp) {
+        const r = await cdp.send('Page.captureScreenshot', { format: 'jpeg', quality: 70, clip: { x: 0, y: 0, width: size.width, height: size.height, scale } }).catch(() => null);
+        if (r?.data) {
+            await writeFile(path, Buffer.from(r.data, 'base64'));
+            return { width: Math.round(size.width * scale), height: Math.round(size.height * scale) };
+        }
+    }
+    await page.screenshot({ path, type: 'jpeg', quality: 50, scale: 'css' });
+    return size;
+}
+export function gridOf(img, cols = 48, rows = 27) {
+    const out = new Float32Array(cols * rows), count = new Uint32Array(cols * rows);
+    for (let y = 0; y < img.height; y++) {
+        const r = Math.min(rows - 1, Math.floor((y * rows) / img.height));
+        for (let x = 0; x < img.width; x++) {
+            const c = Math.min(cols - 1, Math.floor((x * cols) / img.width)), i = (y * img.width + x) * 4, k = r * cols + c;
+            out[k] += 0.299 * img.data[i] + 0.587 * img.data[i + 1] + 0.114 * img.data[i + 2];
+            count[k]++;
+        }
+    }
+    for (let k = 0; k < out.length; k++)
+        out[k] /= Math.max(1, count[k]);
+    return out;
+}
+export function changeOf(a, b, step = 16) {
+    let n = 0;
+    for (let k = 0; k < a.length; k++)
+        if (Math.abs(a[k] - b[k]) > step)
+            n++;
+    return a.length ? n / a.length : 0;
+}
+export const CHANGED = 0.005;
+export async function gridNow(page, box) {
+    const png = await page.screenshot({ type: 'png', scale: 'css', ...(box ? { clip: box } : {}) });
+    const img = decodePng(png);
+    const cols = box ? Math.max(4, Math.min(48, Math.round(box.width / 8))) : 48, rows = box ? Math.max(4, Math.min(27, Math.round(box.height / 8))) : 27;
+    return gridOf(img, cols, rows);
+}
+export function stateLine(counters, max = 600) {
+    const parts = Object.entries(counters).map(([k, v]) => `${k}=${typeof v === 'number' && !Number.isInteger(v) ? Math.round(v * 100) / 100 : v}`);
+    let line = '';
+    for (const p of parts) {
+        if ((line ? line.length + 3 : 0) + p.length > max) {
+            line += line ? ' · …' : '…';
+            break;
+        }
+        line += (line ? ' · ' : '') + p;
+    }
+    return line;
+}

package/dist/play/input.js

@@ -0,0 +1,118 @@
+import { isModifier, px } from "./steps.js";
+const cursor = new WeakMap();
+const FRAME_MS = 30;
+const TAP_MS = 60;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export function pathOf(s, size) {
+    const p = (x, y) => [px(x, size.width), px(y, size.height)];
+    if (s.kind === 'tap')
+        return { from: p(s.x, s.y), to: p(s.x, s.y), ms: TAP_MS };
+    if (s.kind === 'hold_at')
+        return { from: p(s.x, s.y), to: p(s.x, s.y), ms: s.ms };
+    return { from: p(s.x1, s.y1), to: p(s.x2, s.y2), ms: s.ms };
+}
+export function at(path, t) {
+    const k = path.ms ? Math.min(1, t / path.ms) : 1;
+    return [path.from[0] + (path.to[0] - path.from[0]) * k, path.from[1] + (path.to[1] - path.from[1]) * k];
+}
+async function fingers(cdp, paths) {
+    const points = (t) => paths.flatMap((p, id) => (t <= p.ms ? [{ x: at(p, t)[0], y: at(p, t)[1], id }] : []));
+    await cdp.send('Input.dispatchTouchEvent', { type: 'touchStart', touchPoints: points(0) });
+    const end = Math.max(...paths.map((p) => p.ms));
+    for (let t = FRAME_MS; t < end + FRAME_MS; t += FRAME_MS) {
+        await sleep(FRAME_MS);
+        const now = points(Math.min(t, end));
+        if (now.length && t < end)
+            await cdp.send('Input.dispatchTouchEvent', { type: 'touchMove', touchPoints: now });
+    }
+    await cdp.send('Input.dispatchTouchEvent', { type: 'touchEnd', touchPoints: [] });
+}
+async function mouse(page, path) {
+    await page.mouse.move(...path.from);
+    await page.mouse.down();
+    for (let t = FRAME_MS; t < path.ms; t += FRAME_MS) {
+        await sleep(FRAME_MS);
+        await page.mouse.move(...at(path, t));
+    }
+    await sleep(Math.max(0, path.ms % FRAME_MS));
+    await page.mouse.move(...path.to);
+    await page.mouse.up();
+    cursor.set(page, path.to);
+}
+export function lookPlan(s, from, size, locked) {
+    const frames = Math.max(1, Math.ceil(s.ms / FRAME_MS), Math.ceil(Math.abs(s.dx) / (size.width / 3)), Math.ceil(Math.abs(s.dy) / (size.height / 3)));
+    const out = [];
+    let [x, y] = from, done = [0, 0];
+    const inside = (a, b) => a >= 1 && a <= size.width - 2 && b >= 1 && b <= size.height - 2;
+    for (let i = 1; i <= frames; i++) {
+        const want = [Math.round((s.dx * i) / frames), Math.round((s.dy * i) / frames)];
+        const mx = want[0] - done[0], my = want[1] - done[1];
+        let recenter = false;
+        if (locked && !inside(x + mx, y + my)) {
+            x = Math.round(size.width / 2);
+            y = Math.round(size.height / 2);
+            recenter = true;
+        }
+        x = locked ? x + mx : Math.min(size.width - 2, Math.max(1, x + mx));
+        y = locked ? y + my : Math.min(size.height - 2, Math.max(1, y + my));
+        out.push({ to: [x, y], recenter });
+        done = want;
+    }
+    return out;
+}
+async function look(page, s, size) {
+    const locked = await page.evaluate('!!document.pointerLockElement').catch(() => false);
+    const from = cursor.get(page) ?? [Math.round(size.width / 2), Math.round(size.height / 2)];
+    const plan = lookPlan(s, from, size, locked);
+    for (let i = 0; i < plan.length; i++) {
+        const m = plan[i];
+        if (m.recenter) {
+            await page.evaluate('window.__FPX_LOOK__ && window.__FPX_LOOK__.recenter()').catch(() => { });
+            await page.mouse.move(Math.round(size.width / 2), Math.round(size.height / 2));
+        }
+        await page.mouse.move(...m.to);
+        if (i < plan.length - 1 && s.ms)
+            await sleep(Math.max(1, Math.round(s.ms / plan.length)));
+    }
+    cursor.set(page, plan.at(-1).to);
+}
+async function keys(page, k) {
+    if (k.kind === 'hold_key') {
+        await page.keyboard.down(k.key);
+        await sleep(k.ms);
+        await page.keyboard.up(k.key);
+        return;
+    }
+    for (let i = 0; i < k.times; i++) {
+        await page.keyboard.press(k.key);
+        await sleep(60);
+    }
+}
+export async function press(page, touch, phone, h) {
+    if (h.kind === 'hold_key') {
+        await page.keyboard.down(h.key);
+        return () => page.keyboard.up(h.key);
+    }
+    const size = page.viewportSize() ?? { width: 1280, height: 720 };
+    const p = [px(h.x, size.width), px(h.y, size.height)];
+    if (phone) {
+        const c = await touch();
+        await c.send('Input.dispatchTouchEvent', { type: 'touchStart', touchPoints: [{ x: p[0], y: p[1], id: 0 }] });
+        return async () => { await c.send('Input.dispatchTouchEvent', { type: 'touchEnd', touchPoints: [] }); };
+    }
+    await page.mouse.move(...p);
+    await page.mouse.down();
+    cursor.set(page, p);
+    return () => page.mouse.up();
+}
+export async function gesture(page, touch, phone, parts) {
+    const size = page.viewportSize() ?? { width: 1280, height: 720 };
+    const pointers = parts.filter((p) => p.kind === 'tap' || p.kind === 'drag' || p.kind === 'hold_at').map((p) => pathOf(p, size));
+    const looks = parts.filter((p) => p.kind === 'look');
+    const held = parts.filter((p) => p.kind === 'hold_key' || p.kind === 'press').sort((a, b) => Number(isModifier(b.key)) - Number(isModifier(a.key)));
+    await Promise.all([
+        ...held.map((k) => keys(page, k)),
+        ...(pointers.length ? [phone ? touch().then((c) => fingers(c, pointers)) : mouse(page, pointers[0])] : []),
+        ...(looks.length && !phone ? [look(page, looks[0], size)] : []),
+    ]);
+}

package/dist/play/pointer.js

@@ -0,0 +1,21 @@
+export const PLAY_POINTER = `(() => {
+  if (window.__FPX_LOOK__) return;
+  let locked = null, swallow = 0;
+  const change = () => setTimeout(() => document.dispatchEvent(new Event('pointerlockchange')), 0);
+  try {
+    Object.defineProperty(Document.prototype, 'pointerLockElement', { configurable: true, get() { return locked && locked.isConnected ? locked : null; } });
+    Element.prototype.requestPointerLock = function () { if (locked !== this) { locked = this; change(); } return Promise.resolve(); };
+    Document.prototype.exitPointerLock = function () { if (locked) { locked = null; change(); } };
+  } catch (e) {}
+  addEventListener('keydown', (e) => { if (e.key === 'Escape' && locked) document.exitPointerLock(); }, true);
+  for (const t of ['pointermove', 'mousemove']) addEventListener(t, (e) => {
+    if (!swallow) return;
+    e.stopImmediatePropagation();
+    if (t === 'mousemove') swallow = 0;
+  }, true);
+  window.__FPX_LOOK__ = {
+    /** The next mouse move is ours, not the player's: the game never sees it. */
+    recenter() { swallow = 1; setTimeout(() => { swallow = 0; }, 250); },
+    get locked() { return !!(locked && locked.isConnected); },
+  };
+})();`;

package/dist/play/report.js

@@ -0,0 +1,124 @@
+export const ANSWERS = ['yes', 'no', 'unclear'];
+export const ENDINGS = ['won', 'lost', 'neither'];
+export const VERDICTS = ['pass', 'fail', 'inconclusive'];
+export const SEVERITIES = ['high', 'medium', 'low'];
+export const COME_BACK = ['yes', 'maybe', 'no'];
+export const MAX_DEFECTS = 3;
+const REPRO_MAX = 60;
+export function screenAnswers(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.map((x) => ({ screen: str(x?.screen), remembered: str(x?.remembered), fun: str(x?.fun), keep_going: oneOf(x?.keep_going, COME_BACK) ?? 'maybe', why: str(x?.why) }))
+        .filter((x) => x.screen).slice(0, 12);
+}
+const str = (v) => (typeof v === 'string' ? v.trim() : '');
+const oneOf = (v, of) => (of.includes(str(v).toLowerCase()) ? str(v).toLowerCase() : null);
+const got = (v) => {
+    if (v === undefined || v === null || v === '')
+        return 'got nothing';
+    if (Array.isArray(v))
+        return 'got a list';
+    if (typeof v === 'object')
+        return 'got an object';
+    return `got ${JSON.stringify(v).slice(0, 60)}`;
+};
+const stepOf = (v) => {
+    const n = typeof v === 'number' ? v : typeof v === 'string' && /^\s*\d+\s*$/.test(v) ? Number(v) : NaN;
+    return Number.isInteger(n) ? n : null;
+};
+export const CRITERION_SHAPE = '{ "id": "C1", "verdict": "pass" | "fail" | "inconclusive", "note": "what you saw, with steps" }';
+const VERDICT_WORDS = { yes: 'pass', passed: 'pass', no: 'fail', failed: 'fail', unclear: 'inconclusive', unsure: 'inconclusive', maybe: 'inconclusive', 'not sure': 'inconclusive' };
+const verdictOf = (v) => oneOf(v, VERDICTS) ?? VERDICT_WORDS[str(v).toLowerCase()] ?? null;
+export const DEFECT_SHAPE = '{ "severity": "high" | "medium" | "low", "title": "…", "expected": "…", "actual": "…", "step": <whole number, the step whose screenshot shows it> }';
+export function repro(log, upTo) {
+    const steps = log.filter((l) => l.step !== undefined && l.n <= upTo).map((l) => `${l.n}. ${l.step}${l.ok === false ? ` (refused: ${l.error})` : ''}`);
+    const cut = steps.length - REPRO_MAX;
+    return ['0. load the game (it runs only during the steps; the time between acts was held)', ...(cut > 0 ? [`… ${cut} earlier steps in log.jsonl`] : []), ...steps.slice(Math.max(0, cut))];
+}
+function shotFor(log, n) {
+    const s = log.filter((l) => l.shot && l.n >= n).sort((a, b) => a.n - b.n)[0];
+    return s ? { shot: s.shot, step: s.n } : null;
+}
+export function assemble(raw, log, criteria, opts = {}) {
+    const problems = [];
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        problems.push(`the report: ${got(raw)}; expected one JSON object { "start", "goal", "act", "end", "defects", … }`);
+    const answer = (k) => {
+        const a = oneOf(raw?.[k]?.answer, ANSWERS);
+        if (!a)
+            problems.push(`${k}.answer: ${got(raw?.[k]?.answer)}; expected one of ${ANSWERS.join(', ')} (as "${k}": { "answer": "yes", "note": "…" })`);
+        return { answer: a ?? 'unclear', note: str(raw?.[k]?.note) };
+    };
+    const start = answer('start'), goal = answer('goal'), act = answer('act');
+    const ending = oneOf(raw?.end?.answer, ENDINGS);
+    if (!ending)
+        problems.push(`end.answer: ${got(raw?.end?.answer)}; expected one of ${ENDINGS.join(', ')} (as "end": { "answer": "won", "note": "…" })`);
+    const played = log.filter((l) => l.step !== undefined).length;
+    if (!played)
+        problems.push('no steps were played this round: play first (funtools play act …)');
+    if (raw?.defects !== undefined && !Array.isArray(raw.defects))
+        problems.push(`defects: ${got(raw.defects)}; expected a list of at most ${MAX_DEFECTS}, each ${DEFECT_SHAPE}`);
+    const defectsIn = Array.isArray(raw?.defects) ? raw.defects : [];
+    if (defectsIn.length > MAX_DEFECTS)
+        problems.push(`defects: ${defectsIn.length} given; expected at most ${MAX_DEFECTS}, the most severe first`);
+    const last = Math.max(0, ...log.map((l) => l.n));
+    const defects = defectsIn.slice(0, MAX_DEFECTS).map((d, i) => {
+        const at = `defects[${i}]`;
+        if (d === null || typeof d !== 'object' || Array.isArray(d))
+            problems.push(`${at}: ${got(d)}; expected ${DEFECT_SHAPE}`);
+        const severity = oneOf(d?.severity, SEVERITIES);
+        if (!severity)
+            problems.push(`${at}.severity: ${got(d?.severity)}; expected one of ${SEVERITIES.join(', ')}`);
+        if (!str(d?.title))
+            problems.push(`${at}.title: ${got(d?.title)}; expected a short line naming the defect`);
+        const written = stepOf(d?.step);
+        const step = written !== null && written >= 0 && written <= last ? written : null;
+        if (step === null)
+            problems.push(`${at}.step: ${got(d?.step)}; expected a whole number 0–${last}, the step whose screenshot shows it`);
+        const shot = step === null ? null : shotFor(log, step);
+        return {
+            severity: severity ?? 'low', title: str(d?.title), expected: str(d?.expected), actual: str(d?.actual),
+            shot: shot?.shot ?? '', step: shot?.step ?? 0, repro: repro(log, shot?.step ?? step ?? last),
+        };
+    });
+    const rawCrit = raw?.criteria;
+    if (rawCrit !== undefined && (rawCrit === null || typeof rawCrit !== 'object'))
+        problems.push(`criteria: ${got(rawCrit)}; expected a list, each ${CRITERION_SHAPE}`);
+    const entries = Array.isArray(rawCrit) ? rawCrit
+        : rawCrit && typeof rawCrit === 'object' ? Object.entries(rawCrit).map(([id, c]) => (c && typeof c === 'object' ? { id, ...c } : { id, verdict: c })) : [];
+    const judged = new Map(entries.map((c) => [str(c?.id), c]));
+    for (const id of judged.keys())
+        if (!criteria.some((c) => c.id === id))
+            problems.push(`criterion ${id || '(no id)'} is not in funpixel.json; the game's are ${criteria.map((c) => c.id).join(', ') || 'none'}`);
+    const crit = criteria.map((c) => {
+        const j = judged.get(c.id);
+        const written = j?.verdict ?? j?.answer;
+        const verdict = verdictOf(written);
+        if (j && !verdict)
+            problems.push(`criteria ${c.id}.verdict: ${got(written)}; expected one of ${VERDICTS.join(', ')}`);
+        return { id: c.id, text: c.text, verdict: verdict ?? 'inconclusive', note: j ? str(j.note) : 'not judged' };
+    });
+    if (criteria.length && !criteria.some((c) => judged.has(c.id)))
+        problems.push(`criteria: none of the game's ${criteria.length} (${criteria.map((c) => c.id).join(', ')}) judged; expected a list, each ${CRITERION_SHAPE} (inconclusive, with a note, when you couldn't tell)`);
+    const confidence = typeof raw?.confidence === 'number' && raw.confidence >= 0 && raw.confidence <= 1 ? raw.confidence : 0.5;
+    let comeBack;
+    if (raw?.come_back !== undefined || opts.comeBack) {
+        const a = oneOf(raw?.come_back?.answer, COME_BACK);
+        if (!a)
+            problems.push(`come_back.answer: ${got(raw?.come_back?.answer)}; expected one of ${COME_BACK.join(', ')} (a long session ends with: would you come back tomorrow, and why?)`);
+        if (!str(raw?.come_back?.why))
+            problems.push('come_back.why: say why, in the terms of what you played (a reason to return, or what would bring you back)');
+        comeBack = { answer: a ?? 'maybe', why: str(raw?.come_back?.why), first: str(raw?.come_back?.first) };
+    }
+    return {
+        report: {
+            start, goal, act, end: { answer: ending ?? 'neither', note: str(raw?.end?.note) },
+            confusions: (Array.isArray(raw?.confusions) ? raw.confusions : []).map(str).filter(Boolean).slice(0, 8),
+            criteria: crit, defects, blocking: str(raw?.blocking), confidence,
+            ...(comeBack ? { come_back: comeBack } : {}),
+            ...(screenAnswers(raw?.screens).length ? { screens: screenAnswers(raw?.screens) } : {}),
+        },
+        problems,
+    };
+}
+export const blocked = (r) => r.start.answer === 'no' || r.act.answer === 'no' || !/^(|none|nothing|n\/?a|-|no)\.?$/i.test(r.blocking.trim());