@funpixel/tools 0.0.0-stage → 0.1.0

package/dist/feel/spec.js

@@ -0,0 +1,124 @@
+export const MEASURES = {
+    jump_height: { dim: 'distance', says: 'jump height', read: true },
+    airtime: { dim: 'time', says: 'time in the air', read: true },
+    apex_hang: { dim: 'time', says: 'apex hang (the top 10% of the arc)', read: true },
+    top_speed: { dim: 'speed', says: 'top speed', read: true },
+    time_to_top_speed: { dim: 'time', says: 'time to top speed', read: true },
+    dash_distance: { dim: 'distance', says: 'dash distance', read: true },
+    dash_time: { dim: 'time', says: 'dash time', read: true },
+    dash_speed: { dim: 'speed', says: 'dash speed', read: true },
+    invulnerable: { dim: 'time', says: 'invulnerable window', read: true },
+    cooldown: { dim: 'time', says: 'cooldown', read: true },
+    coyote: { dim: 'time', says: 'coyote time (a late press still counts)', read: true },
+    buffer: { dim: 'time', says: 'jump buffer (an early press still counts)', read: true },
+    tell: { dim: 'time', says: 'tell (warning to strike)', read: true },
+    death_beat: { dim: 'time', says: 'death beat', read: true },
+    restart: { dim: 'time', says: 'death to control again', read: true },
+};
+const WORDS = [
+    ['coyote', /coyote|ledge grace|late jump/],
+    ['buffer', /buffer|early press/],
+    ['cooldown', /cool-?down|re-?use|recharge/],
+    ['invulnerable', /invulnerab|invincib|i-?frames?|safe window|immun/],
+    ['dash_speed', /(dash|roll|dodge|lunge)\b.*speed|speed of the (dash|roll|dodge|lunge)/],
+    ['time_to_top_speed', /time to (top|full|max(imum)?) speed|to (top|full) speed|accel(eration)? time|speed-?up time/],
+    ['top_speed', /(top|max(imum)?|run(ning)?|walk(ing)?|move) speed/],
+    ['dash_distance', /(dash|roll|dodge|lunge)\b.*(distance|reach|travel)/],
+    ['dash_time', /(dash|roll|dodge|lunge)\b.*(time|duration|length)/],
+    ['jump_height', /(jump|hop|leap)\b.*(height|peak|rise)/],
+    ['apex_hang', /apex|hang/],
+    ['airtime', /air ?time|time in the air|(jump|hop|leap)\b.*(time|duration)/],
+    ['tell', /\btell|telegraph|wind-?up|warning|anticipation/],
+    ['death_beat', /death beat|death (pose|animation|moment)|dying/],
+    ['restart', /restart|respawn|retry|death to control|back in control/],
+];
+export function measureOf(label) {
+    const s = label.toLowerCase().replace(/[`*_]/g, '');
+    const id = WORDS.find(([, re]) => re.test(s))?.[0] ?? null;
+    return id === 'restart' && /gem|coin|pickup|item|power|enemy|wave/.test(s) ? null : id;
+}
+const UNIT = [
+    [/^(ms|msec|milliseconds?)$/, 's', 'time', 0.001],
+    [/^(s|sec|secs|seconds?)$/, 's', 'time', 1],
+    [/^(f|frames?)$/, 's', 'time', 1 / 60],
+    [/^(body|bodies|body heights?|heights?|hero heights?|bh)$/, 'body', 'distance', 1],
+    [/^(px|pixels?)$/, 'px', 'distance', 1],
+    [/^(tiles?)$/, 'tile', 'distance', 1],
+    [/^(slots?)$/, 'slot', 'distance', 1],
+    [/^(m|metres?|meters?)$/, 'm', 'distance', 1],
+    [/^(units?|world units?)$/, 'unit', 'distance', 1],
+];
+export function unitName(u) {
+    if (!u)
+        return null;
+    const w = u.trim().toLowerCase();
+    const hit = UNIT.find(([re]) => re.test(w));
+    return hit ? hit[1] : w;
+}
+export function parseValue(cell) {
+    const s = cell.toLowerCase().replace(/[`*_]/g, '').replace(/,(?=\d{3}\b)/g, '').trim();
+    const m = /(≤|≥|<=|>=|<|>|under|below|at most|up to|less than|over|above|at least|more than)?\s*~?\s*(-?\d+(?:\.\d+)?)\s*(?:(?:–|—|-|to)\s*(\d+(?:\.\d+)?))?\s*([a-zμ][a-z ]*?)?(?:\s*(\/|per)\s*(s|sec|second))?(?=$|[\s(;,.]|\))/.exec(s);
+    if (!m)
+        return null;
+    const [, bound, a, b, rawUnit, per] = m;
+    const word = (rawUnit ?? '').trim();
+    const u = UNIT.find(([re]) => re.test(word)) ?? (word ? UNIT.find(([re]) => re.test(word.split(' ')[0])) : undefined);
+    if (!u)
+        return null;
+    let [, unit, dim, k] = u;
+    if (per) {
+        if (dim !== 'distance')
+            return null;
+        dim = 'speed';
+    }
+    let lo = Number(a) * k, hi = (b !== undefined ? Number(b) : Number(a)) * k;
+    if (bound && /≤|<|under|below|at most|up to|less/.test(bound))
+        lo = 0;
+    if (bound && /≥|>|over|above|at least|more/.test(bound))
+        hi = Infinity;
+    return { lo, hi, dim, unit };
+}
+export function numberRows(md) {
+    const out = [];
+    let inTable = false, valueCol = 1;
+    for (const line of md.split('\n')) {
+        const t = line.trim();
+        if (!t.startsWith('|')) {
+            inTable = false;
+            continue;
+        }
+        const cells = t.replace(/^\||\|$/g, '').split('|').map((c) => c.trim());
+        if (!inTable) {
+            const head = cells.map((c) => c.toLowerCase());
+            const v = head.findIndex((c) => /^(value|number|target|spec|design)$/.test(c) && c !== head[0]);
+            inTable = /number|verb|name|what|quantity|feel/.test(head[0] ?? '') && v > 0;
+            valueCol = v > 0 ? v : 1;
+            continue;
+        }
+        if (cells.every((c) => /^:?-+:?$/.test(c)))
+            continue;
+        if (cells[0] && cells[valueCol])
+            out.push({ label: cells[0], text: cells[valueCol] });
+    }
+    return out;
+}
+export function specOf(design, expect = {}) {
+    const rows = [];
+    const add = (label, text, source) => {
+        let id = measureOf(label);
+        const value = parseValue(text);
+        if (id === 'dash_time' && value?.dim === 'distance')
+            id = 'dash_distance';
+        if (id === 'dash_distance' && value?.dim === 'time')
+            id = 'dash_time';
+        if (!id || rows.some((r) => r.id === id))
+            return;
+        rows.push({ id, label, text, value, source });
+    };
+    if (design)
+        for (const r of numberRows(design.md))
+            add(r.label, r.text, design.source);
+    for (const [label, text] of Object.entries(expect))
+        add(label, String(text), 'the feel script');
+    return rows;
+}

package/dist/feel/sweep.js

@@ -0,0 +1,156 @@
+import { launch } from "../verify/browser.js";
+import { evalJson, openTarget } from "../look/look.js";
+import { checkFeel, openFeelPage, orientationOf, playSteps } from "./run.js";
+export const WINDOW_IDS = ['coyote', 'buffer'];
+export const SWEEP_LIMITS = { attempts: 12, anchorMs: 15_000, within: 1000, stopAfterMisses: 2, offByMs: 25 };
+const EXPECT = /^([A-Za-z_][\w.]*)(>=|<=|!=|=|>|<)(.+)$/;
+const KEY = /^(Space|Enter|Escape|Arrow(Up|Down|Left|Right)|Key[A-Z]|Digit\d)$/;
+const lit = (s) => (s === 'true' || s === 'false' ? s === 'true' : /^-?\d+(\.\d+)?$/.test(s) ? Number(s) : s);
+function expectOf(text, what, problems) {
+    const m = typeof text === 'string' ? EXPECT.exec(text.trim()) : null;
+    if (!m) {
+        problems.push(`${what}: FIELD OP VALUE ("hero.grounded=false", "threats.0.phase=strike")`);
+        return null;
+    }
+    return { field: m[1], op: m[2], value: lit(m[3]) };
+}
+export function checkSweeps(raw) {
+    const problems = [], sweeps = [];
+    if (raw === undefined)
+        return { sweeps, problems };
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return { sweeps, problems: ['sweeps: { "coyote": {…}, "buffer": {…} }'] };
+    for (const [id, v] of Object.entries(raw)) {
+        const p = [];
+        if (!WINDOW_IDS.includes(id)) {
+            problems.push(`sweeps.${id}: coyote or buffer`);
+            continue;
+        }
+        const s = v;
+        if (!s || typeof s !== 'object') {
+            problems.push(`sweeps.${id}: an object`);
+            continue;
+        }
+        if (!Array.isArray(s.steps))
+            p.push('steps: the setup, a list of feel steps (can be empty)');
+        const anchor = expectOf(s.anchor, 'anchor', p), success = expectOf(s.success, 'success', p);
+        if (typeof s.press !== 'string' || !KEY.test(s.press))
+            p.push('press: a key code (ArrowUp, Space, KeyW…)');
+        if (id === 'buffer' && (typeof s.cue !== 'string' || !KEY.test(s.cue)))
+            p.push('cue: the key that starts the jump whose landing is the anchor (a buffer press comes before it)');
+        const [first, last, step] = s.offsets ?? [id === 'buffer' ? 20 : 0, 200, 20];
+        if (![first, last, step].every((n) => Number.isFinite(n) && n >= 0) || step <= 0 || last < first || last > 1000)
+            p.push('offsets: [first, last, step] in ms, up to 1000');
+        const within = s.within ?? 300;
+        if (!Number.isFinite(within) || within <= 0 || within > SWEEP_LIMITS.within)
+            p.push(`within: ms, up to ${SWEEP_LIMITS.within}`);
+        if (p.length) {
+            problems.push(...p.map((x) => `sweeps.${id}.${x}`));
+            continue;
+        }
+        const offsets = [];
+        for (let o = Math.max(first, id === 'buffer' ? step : 0); o <= last + 1e-9 && offsets.length < SWEEP_LIMITS.attempts; o += step)
+            offsets.push(Math.round(o));
+        sweeps.push({ id: id, spec: s, anchor: anchor, success: success, offsets, within });
+    }
+    return { sweeps, problems };
+}
+export function windowOf(id, attempts, clock) {
+    const mag = (a) => Math.max(0, id === 'buffer' ? -a.offset : a.offset);
+    const judged = attempts.filter((a) => a.success !== null).sort((a, b) => mag(a) - mag(b));
+    let window = 0, fails = null;
+    for (const a of judged) {
+        if (a.success && fails === null)
+            window = mag(a);
+        else if (!a.success && fails === null)
+            fails = mag(a);
+    }
+    const r = (x) => Math.round(x * 1000) / 1000;
+    return { window: r(window), took: judged.some((a) => a.success), fails_from: fails === null ? null : r(fails), clock, attempts, gaps: fails !== null && judged.some((a) => a.success && mag(a) > fails) };
+}
+export async function sweepFeel(root, script, sweeps, log = () => { }) {
+    const t = await openTarget(root);
+    if (typeof t === 'string')
+        return t;
+    const orientation = orientationOf(t, script);
+    const { browser } = await launch(false, true);
+    const windows = {}, notes = [];
+    try {
+        for (const sw of sweeps) {
+            const setup = checkFeel({ ...script, journey: undefined, steps: sw.spec.steps.length ? sw.spec.steps : ['wait 0'] }, root);
+            if (setup.problems.length) {
+                notes.push(...setup.problems.map((p) => `sweeps.${sw.id}: ${p}`));
+                continue;
+            }
+            const attempt = (offset_ms, press, lead_ms) => once(browser, t, setup.script, setup.steps, orientation, notes, {
+                ...(sw.spec.cue ? { cue: sw.spec.cue } : {}), anchor: sw.anchor, ...(press ? { press: sw.spec.press } : {}),
+                offset_ms, ...(lead_ms !== undefined ? { lead_ms } : {}), success: sw.success, within_ms: sw.within, timeout_ms: SWEEP_LIMITS.anchorMs,
+            });
+            let lead;
+            if (sw.id === 'buffer') {
+                const leads = [];
+                let why = '';
+                for (let k = 0; k < 2; k++) {
+                    const cal = await attempt(0, false);
+                    if (cal && cal.anchor_t !== null && cal.cue_t !== null)
+                        leads.push(cal.anchor_t - cal.cue_t);
+                    else
+                        why ||= cal?.why ?? 'no answer';
+                }
+                if (!leads.length) {
+                    notes.push(`sweeps.buffer: the anchor (${sw.spec.anchor}) never came after the cue (${sw.spec.cue}): ${why}`);
+                    continue;
+                }
+                lead = Math.min(...leads);
+                log(`buffer: the anchor comes ${Math.round(lead)} ms after the cue`);
+            }
+            const attempts = [];
+            let clock = 'page', misses = 0, unjudged = 0;
+            for (const o of sw.offsets) {
+                const want = sw.id === 'buffer' ? -o : o;
+                let a = await attempt(want, true, lead);
+                if (a && a.press_t !== null && a.anchor_t !== null && Math.abs(a.press_t - a.anchor_t - want) > SWEEP_LIMITS.offByMs)
+                    a = (await attempt(want, true, lead)) ?? a;
+                if (!a) {
+                    attempts.push({ offset: want / 1000, success: null, why: 'the page did not answer' });
+                    if (++unjudged >= 2)
+                        break;
+                    continue;
+                }
+                if (a.clock)
+                    clock = a.clock;
+                const real = a.press_t !== null && a.anchor_t !== null ? (a.press_t - a.anchor_t) / 1000 : want / 1000;
+                attempts.push({ offset: Math.round(real * 1000) / 1000, success: a.success, ...(a.why ? { why: a.why } : {}) });
+                log(`${sw.id}: pressed ${Math.abs(Math.round(real * 1000))} ms ${real < 0 ? 'before' : 'after'} the anchor: ${a.success === null ? `not judged (${a.why ?? 'no answer'})` : a.success ? 'took' : 'missed'}`);
+                misses = a.success === false ? misses + 1 : a.success ? 0 : misses;
+                unjudged = a.success === null ? unjudged + 1 : 0;
+                if (misses >= SWEEP_LIMITS.stopAfterMisses || unjudged >= 2)
+                    break;
+            }
+            if (!attempts.some((a) => a.success !== null)) {
+                notes.push(`sweeps.${sw.id}: no attempt was judged (${attempts[0]?.why ?? 'none ran'})`);
+                continue;
+            }
+            windows[sw.id] = windowOf(sw.id, attempts, clock);
+        }
+    }
+    finally {
+        await browser.close().catch(() => { });
+        await t.close();
+    }
+    return { windows, notes };
+}
+async function once(browser, t, script, steps, orientation, notes, args) {
+    const page = await openFeelPage(browser, t, script, orientation);
+    try {
+        const setupNotes = [];
+        await playSteps(page, script, steps, setupNotes);
+        for (const n of setupNotes)
+            if (!notes.includes(n))
+                notes.push(n);
+        return (await evalJson(page, 'feel_sweep', args));
+    }
+    finally {
+        await page.context().close().catch(() => { });
+    }
+}

package/dist/fidelity/consistency.js

@@ -0,0 +1,205 @@
+export function cameraOf(name) {
+    const m = /^(n|f)-e(\d+)-yaw(\d+)/.exec(name);
+    return m ? { orient: m[1], elevation: Number(m[2]), yaw: Number(m[3]) } : null;
+}
+export function basis(c) {
+    const ay = (c.yaw * Math.PI) / 180, ae = (c.elevation * Math.PI) / 180;
+    const f = [-Math.sin(ay) * Math.cos(ae), Math.cos(ay) * Math.cos(ae), -Math.sin(ae)];
+    let up = [-f[2] * f[0], -f[2] * f[1], 1 - f[2] * f[2]];
+    const n = Math.hypot(...up);
+    up = up.map((v) => v / n);
+    const right = [f[1] * up[2] - f[2] * up[1], f[2] * up[0] - f[0] * up[2], f[0] * up[1] - f[1] * up[0]];
+    return { right, up };
+}
+function along(v) {
+    const i = v.map(Math.abs).indexOf(Math.max(...v.map(Math.abs)));
+    return Math.abs(v[i]) >= 0.95 ? { axis: i, sign: v[i] > 0 ? 1 : -1 } : null;
+}
+export function axesOf(m) {
+    const cam = cameraOf(m.render);
+    if (!cam)
+        return null;
+    const b = basis(cam);
+    let h = along(b.right), v = along(b.up);
+    const turn = ((Math.round(m.nudge / 90) % 4) + 4) % 4;
+    const flip = (a) => (a ? { axis: a.axis, sign: (-a.sign) } : null);
+    for (let i = 0; i < turn; i++)
+        [h, v] = [flip(v), h];
+    return { name: m.name, h, v, m };
+}
+function box(m) {
+    let x0 = m.width, y0 = m.height, x1 = -1, y1 = -1;
+    for (let y = 0; y < m.height; y++)
+        for (let x = 0; x < m.width; x++) {
+            if (!m.data[y * m.width + x])
+                continue;
+            if (x < x0)
+                x0 = x;
+            if (x > x1)
+                x1 = x;
+            if (y < y0)
+                y0 = y;
+            if (y > y1)
+                y1 = y;
+        }
+    return x1 < 0 ? null : { w: x1 - x0 + 1, h: y1 - y0 + 1, x0, y0 };
+}
+export const PROPORTION_TOLERANCE = 0.04;
+export const STEP_TOLERANCE = 0.04;
+const STEP_SAME = 0.15;
+export function steps(m, onRows, sign, bins = 100) {
+    const b = box(m);
+    if (!b)
+        return [];
+    const len = onRows ? b.h : b.w;
+    if (len < 20)
+        return [];
+    const width = new Float64Array(len);
+    for (let y = 0; y < b.h; y++)
+        for (let x = 0; x < b.w; x++) {
+            if (m.data[(b.y0 + y) * m.width + b.x0 + x])
+                width[onRows ? y : x]++;
+        }
+    const prof = new Float64Array(bins);
+    for (let i = 0; i < bins; i++) {
+        const t = (i + 0.5) / bins;
+        const p = Math.min(len - 1, Math.floor(t * len));
+        const idx = onRows ? (sign === 1 ? len - 1 - p : p) : (sign === 1 ? p : len - 1 - p);
+        prof[i] = width[idx];
+    }
+    const max = Math.max(...prof) || 1;
+    const s = prof.map((v, i) => (0.25 * prof[Math.max(0, i - 1)] + 0.5 * v + 0.25 * prof[Math.min(bins - 1, i + 1)]) / max);
+    const out = [];
+    for (let i = 2; i < bins - 2; i++) {
+        const d = s[i + 1] - s[i - 1];
+        const prev = s[i] - s[i - 2], next = s[i + 2] - s[i];
+        if (Math.abs(d) >= 0.2 && Math.abs(d) >= Math.abs(prev) && Math.abs(d) >= Math.abs(next))
+            out.push({ at: i / bins, rise: d });
+    }
+    return out.filter((p, i) => !out.some((q, j) => j !== i && Math.abs(q.at - p.at) <= 0.02 && Math.abs(q.rise) > Math.abs(p.rise)));
+}
+const pct = (t) => `${Math.round(t * 100)}%`;
+function paired(m, rows, sign) {
+    const fs = steps(m.refMask, rows, sign), rs = steps(m.renderMask, rows, sign);
+    const out = [];
+    for (const r of rs) {
+        const f = fs.filter((x) => Math.sign(x.rise) === Math.sign(r.rise) && Math.abs(x.at - r.at) <= STEP_SAME)
+            .sort((x, y) => Math.abs(x.at - r.at) - Math.abs(y.at - r.at))[0];
+        if (f)
+            out.push({ model: r.at, ref: f.at, rise: r.rise });
+    }
+    return out;
+}
+function solve(eqs) {
+    const A = [[1e-6, 0, 0], [0, 1e-6, 0], [0, 0, 1e-6]], y = [0, 0, 0];
+    for (const { a, b, r } of eqs) {
+        A[a][a] += 1;
+        A[b][b] += 1;
+        A[a][b] -= 1;
+        A[b][a] -= 1;
+        y[a] += r;
+        y[b] -= r;
+    }
+    const M = A.map((row, i) => [...row, y[i]]);
+    for (let c = 0; c < 3; c++) {
+        let p = c;
+        for (let r = c + 1; r < 3; r++)
+            if (Math.abs(M[r][c]) > Math.abs(M[p][c]))
+                p = r;
+        [M[c], M[p]] = [M[p], M[c]];
+        for (let r = 0; r < 3; r++) {
+            if (r === c || !M[c][c])
+                continue;
+            const k = M[r][c] / M[c][c];
+            for (let j = c; j < 4; j++)
+                M[r][j] -= k * M[c][j];
+        }
+    }
+    const s = M.map((row, i) => row[3] / (row[i] || 1));
+    return eqs.map(({ a, b, r }) => r - (s[a] - s[b]));
+}
+export function consistency(views, opts = {}) {
+    const names = opts.axisNames ?? ['length', 'depth', 'height'];
+    const placed = [];
+    const unplaced = [];
+    for (const v of views) {
+        const s = axesOf(v);
+        if (s && (s.h || s.v))
+            placed.push(s);
+        else
+            unplaced.push(v.name);
+    }
+    const findings = [];
+    const checked = [];
+    const eqs = [];
+    for (const s of placed) {
+        if (!s.h || !s.v)
+            continue;
+        const rb = box(s.m.refMask), db = box(s.m.renderMask);
+        if (!rb || !db)
+            continue;
+        eqs.push({ a: s.h.axis, b: s.v.axis, r: Math.log((rb.w / rb.h) / (db.w / db.h)), name: s.name });
+    }
+    const pairs = new Map();
+    for (const e of eqs) {
+        const k = [e.a, e.b].sort().join();
+        pairs.set(k, (pairs.get(k) ?? 0) + 1);
+    }
+    const loop = pairs.size === 3;
+    const repeated = [...pairs.values()].some((n) => n > 1);
+    if (loop || repeated) {
+        checked.push('proportion');
+        const res = solve(eqs);
+        eqs.forEach((e, i) => {
+            const gap = Math.exp(Math.abs(res[i])) - 1;
+            if (gap > PROPORTION_TOLERANCE) {
+                findings.push({
+                    check: 'proportion', views: [e.name], axis: `${names[e.a]}:${names[e.b]}`, gap_pct: Math.round(gap * 1000) / 10,
+                    says: `${e.name} draws ${names[e.a]} against ${names[e.b]} ${Math.round(gap * 100)}% ${res[i] > 0 ? 'longer' : 'shorter'} than the other views allow`,
+                });
+            }
+        });
+    }
+    const sides = (s) => [s.h && { ...s.h, rows: false }, s.v && { ...s.v, rows: true }].filter(Boolean);
+    for (let i = 0; i < placed.length; i++)
+        for (let j = i + 1; j < placed.length; j++) {
+            const A = placed[i], B = placed[j];
+            for (const sa of sides(A))
+                for (const sb of sides(B)) {
+                    if (sa.axis !== sb.axis)
+                        continue;
+                    const axis = names[sa.axis];
+                    if (!checked.includes('parts'))
+                        checked.push('parts');
+                    const pa = paired(A.m, sa.rows, sa.sign), pb = paired(B.m, sb.rows, sb.sign);
+                    for (const p of pa) {
+                        const q = pb.find((x) => Math.sign(x.rise) === Math.sign(p.rise) && Math.abs(x.model - p.model) <= 0.02);
+                        if (!q)
+                            continue;
+                        const gap = Math.abs(p.ref - p.model - (q.ref - q.model));
+                        if (gap > STEP_TOLERANCE) {
+                            findings.push({
+                                check: 'parts', views: [A.name, B.name], axis, gap_pct: Math.round(gap * 1000) / 10,
+                                says: `the edge the model has at ${pct(p.model)} of its ${axis} is drawn at ${pct(p.ref)} in ${A.name} and ${pct(q.ref)} in ${B.name}`,
+                            });
+                        }
+                    }
+                    if (opts.sameScale) {
+                        if (!checked.includes('extents'))
+                            checked.push('extents');
+                        const ba = box(A.m.refMask), bb = box(B.m.refMask);
+                        if (!ba || !bb)
+                            continue;
+                        const ea = sa.rows ? ba.h : ba.w, eb = sb.rows ? bb.h : bb.w;
+                        const gap = Math.abs(ea - eb) / Math.max(ea, eb);
+                        if (gap > PROPORTION_TOLERANCE) {
+                            findings.push({
+                                check: 'extents', views: [A.name, B.name], axis, gap_pct: Math.round(gap * 1000) / 10,
+                                says: `the ${axis} is ${ea} px in ${A.name} and ${eb} px in ${B.name} (one sheet, one scale)`,
+                            });
+                        }
+                    }
+                }
+        }
+    return { checked, findings, unplaced };
+}