@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/walk/judge.js

@@ -0,0 +1,287 @@
+export const WALK_TOL = {
+    clipM: 0.12, clipShare: 0.25,
+    floatM: 0.15, sinkM: 0.25,
+    scaleShare: 0.2,
+    overlapY: 0.2,
+};
+const MOVERS = new Set(['player', 'person', 'creature', 'machine']);
+export function footprint(a) {
+    if (a.w !== null && a.d !== null && typeof a.yaw === 'number' && a.kind === 'prop')
+        return { kind: 'box', x: a.x, z: a.z, hw: a.w / 2, hd: a.d / 2, yaw: a.yaw };
+    const r = a.r ?? (a.w !== null && a.d !== null ? Math.min(a.w, a.d) / 2 : null);
+    return r !== null && r > 0 ? { kind: 'circle', x: a.x, z: a.z, r } : null;
+}
+export function penetration(p, q) {
+    if (p.kind === 'box' && q.kind === 'box') {
+        return Math.min(p.hw, p.hd) + Math.min(q.hw, q.hd) - Math.hypot(p.x - q.x, p.z - q.z);
+    }
+    if (p.kind === 'box')
+        return penetration(q, p);
+    if (q.kind === 'circle')
+        return p.r + q.r - Math.hypot(p.x - q.x, p.z - q.z);
+    const dx = p.x - q.x, dz = p.z - q.z, c = Math.cos(q.yaw), s = Math.sin(q.yaw);
+    const lx = dx * c - dz * s, lz = dx * s + dz * c;
+    const ox = Math.abs(lx) - q.hw, oz = Math.abs(lz) - q.hd;
+    const outside = Math.hypot(Math.max(ox, 0), Math.max(oz, 0));
+    const inside = Math.min(Math.max(ox, oz), 0);
+    return p.r - (outside + inside);
+}
+const yOverlap = (a, b) => {
+    const top = (x) => (x.h === null ? Infinity : x.y + x.h);
+    return Math.min(top(a), top(b)) - Math.max(a.y, b.y);
+};
+export function clipsIn(actors, props = false) {
+    const out = new Map();
+    const solid = actors.filter((a) => a.solid && !(a.kind === 'machine' && a.flies));
+    const shapes = new Map(solid.map((a) => [a, footprint(a)]));
+    for (let i = 0; i < solid.length; i++) {
+        const a = solid[i];
+        for (let j = i + 1; j < solid.length; j++) {
+            const b = solid[j];
+            const moving = MOVERS.has(a.kind) || MOVERS.has(b.kind);
+            if (!moving && !props)
+                continue;
+            if (!moving && a.type === b.type && a.node === b.node && a.type === 'container') {
+                if (Math.abs(a.y - b.y) > 0.5)
+                    continue;
+            }
+            if (yOverlap(a, b) < WALK_TOL.overlapY)
+                continue;
+            const p = shapes.get(a), q = shapes.get(b);
+            if (!p || !q)
+                continue;
+            const depth = penetration(p, q);
+            const small = Math.min(p.kind === 'circle' ? p.r : Math.min(p.hw, p.hd), q.kind === 'circle' ? q.r : Math.min(q.hw, q.hd));
+            if (depth > WALK_TOL.clipM && depth > WALK_TOL.clipShare * small) {
+                const [x, y] = MOVERS.has(b.kind) && !MOVERS.has(a.kind) ? [b, a] : [a, b];
+                out.set(`${x.id}|${y.id}`, { depth: Math.round(depth * 100) / 100, at: { x: Math.round(x.x * 10) / 10, z: Math.round(x.z * 10) / 10 } });
+            }
+        }
+    }
+    return out;
+}
+export function tallyClips(tally, found, t) {
+    for (const [key, c] of found) {
+        const [a, b] = key.split('|');
+        const was = tally.get(key);
+        if (!was)
+            tally.set(key, { a, b, depth: c.depth, at: c.at, times: 1, first_s: Math.round(t * 10) / 10 });
+        else {
+            was.times++;
+            if (c.depth > was.depth) {
+                was.depth = c.depth;
+                was.at = c.at;
+            }
+        }
+    }
+}
+export function floatsIn(actors) {
+    const grounded = actors.filter((a) => a.ground !== null && !a.flies);
+    if (!grounded.length)
+        return null;
+    const out = [];
+    for (const a of grounded) {
+        const gap = a.y - a.ground;
+        if (gap > WALK_TOL.floatM) {
+            const p = footprint(a);
+            const held = actors.some((b) => b !== a && b.solid && b.h !== null && Math.abs(b.y + b.h - a.y) <= WALK_TOL.floatM && (() => { const q = footprint(b); return !!p && !!q && penetration(p, q) > 0; })());
+            if (!held)
+                out.push({ id: a.id, type: a.type, gap: Math.round(gap * 100) / 100, kind: 'floating' });
+        }
+        else if (gap < -WALK_TOL.sinkM && a.kind !== 'prop')
+            out.push({ id: a.id, type: a.type, gap: Math.round(gap * 100) / 100, kind: 'buried' });
+    }
+    return out;
+}
+const sheetFor = (sheet, a) => {
+    if (a.type && sheet[a.type] !== undefined)
+        return sheet[a.type];
+    const pre = Object.keys(sheet).find((k) => a.id === k || a.id.startsWith(`${k}-`) || a.node === k);
+    return pre ? sheet[pre] : null;
+};
+export function scaleMisses(actors, sheet) {
+    let judged = 0;
+    const misses = [];
+    for (const a of actors) {
+        if (a.h === null)
+            continue;
+        const want = sheetFor(sheet, a);
+        if (want === null)
+            continue;
+        judged++;
+        const [lo, hi] = Array.isArray(want) ? want : [want, want];
+        const off = a.h < lo ? a.h / lo - 1 : a.h > hi ? a.h / hi - 1 : 0;
+        if (Math.abs(off) > WALK_TOL.scaleShare)
+            misses.push({ id: a.id, type: a.type, h: Math.round(a.h * 100) / 100, want: Array.isArray(want) ? `${lo}–${hi} m` : `${lo} m`, off: Math.round(off * 100) / 100 });
+    }
+    return judged ? { misses, judged } : null;
+}
+export function scaleSpread(actors) {
+    const by = new Map();
+    for (const a of actors)
+        if (a.h !== null && a.type && a.kind !== 'prop') {
+            const l = by.get(a.type) ?? [];
+            l.push(a.h);
+            by.set(a.type, l);
+        }
+    const out = [];
+    for (const [type, hs] of by) {
+        if (hs.length < 2)
+            continue;
+        const min = Math.min(...hs), max = Math.max(...hs);
+        if (max / min - 1 > WALK_TOL.scaleShare)
+            out.push({ type, min: Math.round(min * 100) / 100, max: Math.round(max * 100) / 100, n: hs.length });
+    }
+    return out;
+}
+export function stallsIn(ticks, stallS) {
+    const out = [];
+    let start = -1;
+    const moved = (a, b) => (a.at && b.at ? Math.hypot(a.at.x - b.at.x, a.at.z - b.at.z) > 0.3 : false) || (a.progress !== null && b.progress !== null && Math.abs(a.progress - b.progress) > 0.3);
+    for (let i = 0; i <= ticks.length; i++) {
+        const t = ticks[i];
+        const still = t && t.pressing && start >= 0 && !moved(ticks[start], t);
+        if (t && t.pressing && start < 0) {
+            start = i;
+            continue;
+        }
+        if (still)
+            continue;
+        if (start >= 0) {
+            const end = ticks[Math.max(start, i - 1)];
+            const s = ticks[start];
+            if (end.t - s.t >= stallS) {
+                const same = s.state === end.state;
+                out.push({ from_s: Math.round(s.t * 10) / 10, to_s: Math.round(end.t * 10) / 10, at: end.at, kind: same ? 'dead_end' : 'blocked', by: end.near });
+            }
+            start = t && t.pressing ? i : -1;
+        }
+    }
+    return out;
+}
+export const CHALLENGE_WORDS = /stumble|fall|slip|trip|detect|spotted|seen|heard|alert|tag|caught|hit|damage|hurt|fail|lose|lost|dead|death|die|timer|timeout|late|alarm|chase|pursu|crash|drop/i;
+export function challengeCount(marks, counters, words = CHALLENGE_WORDS) {
+    const by = {};
+    for (const m of marks)
+        if (words.test(m.name))
+            by[m.name] = (by[m.name] ?? 0) + 1;
+    for (const [k, v] of Object.entries(counters))
+        if (v > 0 && words.test(k) && !(k in by))
+            by[k] = v;
+    return { total: Object.values(by).reduce((n, v) => n + v, 0), by };
+}
+export function counterRise(before, after) {
+    const out = {};
+    if (!before || !after)
+        return out;
+    for (const [k, v] of Object.entries(after)) {
+        const b = before[k];
+        if (typeof v === 'number' && typeof b === 'number' && Number.isInteger(v) && v > b)
+            out[k] = v - b;
+    }
+    return out;
+}
+export function stateHash(s) {
+    if (!s)
+        return '';
+    const skip = /^(t|time|now|clock|elapsed|frame|frames|tick|ticks|fps|sounds|tension)$/i;
+    const keep = {};
+    for (const [k, v] of Object.entries(s))
+        if (!skip.test(k) && (typeof v !== 'object' || v === null))
+            keep[k] = typeof v === 'number' ? Math.round(v * 10) / 10 : v;
+    return JSON.stringify(keep);
+}
+export const ACTORS_DOC = 'the actors contract: skill funpixel-verify, references/actors.md (in a game: .agents/skills/funpixel-verify/references/actors.md)';
+export const LIVING_DOC = 'skill funpixel-world-and-story, references/living-world.md';
+export function tallyTravel(tally, actors) {
+    for (const a of actors) {
+        if (a.kind === 'prop' || a.kind === 'player')
+            continue;
+        const was = tally.get(a.id);
+        if (!was) {
+            tally.set(a.id, { id: a.id, kind: a.kind, type: a.type, first: { x: a.x, z: a.z }, last: { x: a.x, z: a.z }, path: 0, span: 0 });
+            continue;
+        }
+        const step = Math.hypot(a.x - was.last.x, a.z - was.last.z);
+        if (step < 25) {
+            was.path += step;
+            was.span = Math.max(was.span, Math.hypot(a.x - was.first.x, a.z - was.first.z));
+        }
+        else
+            was.first = { x: a.x, z: a.z };
+        was.last = { x: a.x, z: a.z };
+    }
+}
+export const TRAVEL_M = 2;
+const groupTypes = (list) => {
+    const by = new Map();
+    for (const t of list)
+        by.set(t.type || t.id, (by.get(t.type || t.id) ?? 0) + 1);
+    return [...by].map(([n, k]) => (k > 1 ? `${n} ×${k}` : n)).slice(0, 8).join(', ');
+};
+export function crowdTravel(tally) {
+    const people = [...tally.values()].filter((t) => t.kind === 'person');
+    if (!people.length)
+        return null;
+    const go = people.filter((t) => t.span >= TRAVEL_M);
+    if (!go.length && people.length >= 2)
+        return { status: 'warn', text: `A CROWD THAT NEVER TRAVELS: none of ${people.length} people got ${TRAVEL_M} m from where they stood`, hint: `each person needs a task loop that moves them through space (haul, patrol, errand), the walk clip's rate following the ground speed (${LIVING_DOC})`, items: [groupTypes(people)] };
+    return { status: go.length === people.length ? 'pass' : 'note', text: `people: ${go.length} of ${people.length} moved through space (≥ ${TRAVEL_M} m)${go.length < people.length ? `; ${people.length - go.length} stayed in place` : ''}` };
+}
+export const LOSS_WORDS = /^(lost|lose|loss|failed|fail|failure|game ?over|gameover|over|caught|dead|died|death|wrecked|busted|defeat(ed)?)$/i;
+export const LOSS_MARKS = /lost|fail|game.?over|caught|death|died|defeat|wreck|busted/i;
+export function lostNow(state, marks = []) {
+    for (const k of ['screen', 'phase', 'outcome', 'result', 'mode', 'status']) {
+        const v = state?.[k];
+        if (typeof v === 'string' && LOSS_WORDS.test(v.trim()))
+            return `${k} ${v}`;
+    }
+    if (state && (state.lost === true || state.failed === true || state.gameOver === true))
+        return 'the state says lost';
+    const m = marks.find((x) => LOSS_MARKS.test(x.name));
+    return m ? `mark ${m.name}` : null;
+}
+export const FRAMING_OUT_SHARE = 0.15;
+export function framingOf(id, samples, want) {
+    const l = samples.map((s) => s.share);
+    const r3 = (v) => Math.round(v * 1000) / 1000;
+    const read = { id, share: { min: r3(Math.min(...l)), mean: r3(l.reduce((a, b) => a + b, 0) / l.length), max: r3(Math.max(...l)) }, want };
+    if (!want || samples.length < 2)
+        return read;
+    const steps = samples.slice(1).map((s, i) => s.t - samples[i].t).filter((d) => d > 0).sort((a, b) => a - b);
+    const typical = steps.length ? steps[steps.length >> 1] : 0.25;
+    const dur = samples.map((s, i) => Math.min(i + 1 < samples.length ? samples[i + 1].t - s.t : typical, 4 * typical));
+    const total = dur.reduce((a, b) => a + b, 0);
+    const side = (v) => (v < want[0] ? 'under' : v > want[1] ? 'over' : null);
+    let outT = 0;
+    const stretches = [];
+    for (const [i, s] of samples.entries()) {
+        const sd = side(s.share);
+        if (!sd)
+            continue;
+        outT += dur[i];
+        const last = stretches[stretches.length - 1];
+        if (last && last.side === sd && s.t - last.to_s <= 2) {
+            last.to_s = s.t + dur[i];
+            last.min = Math.min(last.min, s.share);
+            last.max = Math.max(last.max, s.share);
+        }
+        else
+            stretches.push({ from_s: s.t, to_s: s.t + dur[i], min: s.share, max: s.share, side: sd });
+    }
+    const named = stretches.filter((x) => x.to_s - x.from_s >= 1).map((x) => ({ ...x, from_s: Math.round(x.from_s), to_s: Math.round(x.to_s), min: r3(x.min), max: r3(x.max) }));
+    return { ...read, out: { share: total > 0 ? Math.round((outT / total) * 100) / 100 : 0, stretches: named } };
+}
+const pcf = (v) => `${Math.round(v * 100)}%`;
+export function framingCheck(f) {
+    if (!f.want)
+        return null;
+    const band = `${pcf(f.want[0])}–${pcf(f.want[1])}`;
+    const hint = 'funtools framing --actors <id> reads it live while the camera is tuned';
+    const items = (f.out?.stretches ?? []).slice(0, 8).map((x) => `s ${x.from_s}–${x.to_s} at ${x.min === x.max ? pcf(x.min) : `${pcf(x.min)}–${pcf(x.max)}`} (${x.side === 'under' ? `floor ${pcf(f.want[0])}` : `ceiling ${pcf(f.want[1])}`})`);
+    if (f.share.mean < f.want[0] || f.share.mean > f.want[1])
+        return { status: 'warn', text: `FRAMING: ${f.id} fills ${pcf(f.share.mean)} of the frame height on average (the plan: ${band})`, hint, ...(items.length ? { items } : {}) };
+    if (f.out && f.out.share > FRAMING_OUT_SHARE)
+        return { status: 'warn', text: `FRAMING: ${f.id} is outside ${band} of the frame height ${pcf(f.out.share)} of the time (mean ${pcf(f.share.mean)}, range ${pcf(f.share.min)}–${pcf(f.share.max)})`, hint, items };
+    return { status: 'pass', text: `framing: ${f.id} at ${pcf(f.share.mean)} of the frame height${f.out?.share ? ` (outside ${band} ${pcf(f.out.share)} of the time)` : ''}` };
+}

package/dist/walk/routes.js

@@ -0,0 +1,199 @@
+import { playerOf } from "../look/player.js";
+const num = (v, d) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : d);
+const strs = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string') : []);
+export function forwardKey(manifest) {
+    const checks = Array.isArray(manifest?.checks) ? manifest.checks : [];
+    const hit = checks.find((c) => typeof c?.key === 'string' && c.expect === 'increases' && /move|walk|forward|away|up|run|go/i.test(String(c.verb ?? c.mechanic ?? '')));
+    return hit?.key ?? 'ArrowUp';
+}
+export function readWalk(manifest) {
+    const w = manifest?.walk && typeof manifest.walk === 'object' ? manifest.walk : {};
+    const problems = [];
+    const routes = [];
+    for (const [i, r] of (Array.isArray(w.routes) ? w.routes : []).entries()) {
+        if (!r || typeof r !== 'object') {
+            problems.push(`walk.routes[${i}] is not an object`);
+            continue;
+        }
+        const s = r.steer;
+        const pts = (v) => {
+            if (!Array.isArray(v))
+                return undefined;
+            const out = v.map((p) => (Array.isArray(p) && typeof p[0] === 'number' && typeof p[1] === 'number' ? [p[0], p[1]] : p && typeof p.x === 'number' && typeof p.z === 'number' ? [p.x, p.z] : null)).filter((p) => !!p);
+            return out.length >= 2 ? out : undefined;
+        };
+        const wp = pts(s?.waypoints ?? r.waypoints);
+        routes.push({
+            name: typeof r.name === 'string' && r.name ? r.name : `route-${i + 1}`,
+            start: strs(r.start),
+            ...(strs(r.continue).length ? { continue: strs(r.continue) } : {}),
+            hold: strs(r.hold).length ? strs(r.hold) : [forwardKey(manifest)],
+            steer: s && (typeof s.field === 'string' || wp || s.by === 'position') && typeof s.lower === 'string' && typeof s.raise === 'string'
+                ? { field: typeof s.field === 'string' ? s.field : '', to: typeof s.to === 'number' ? s.to : 0, lower: s.lower, raise: s.raise, within: num(s.within, 0.5), ...(wp ? { waypoints: wp } : {}) } : null,
+            progress: typeof r.progress === 'string' ? r.progress : null,
+            done: r.done && typeof r.done.field === 'string' ? r.done : null,
+            maxS: num(r.max_s, 90),
+            from: 'funpixel.json',
+            then: typeof r.then === 'string' && r.then ? r.then : null,
+        });
+    }
+    for (const r of routes)
+        if (r.then && !routes.some((x) => x.name === r.then)) {
+            problems.push(`walk.routes ${r.name}: then names no route "${r.then}"`);
+            r.then = null;
+        }
+    if (!routes.length) {
+        routes.push({ name: 'explore', start: ['press Enter', 'wait 1500', 'press Enter', 'wait 1000'], hold: [forwardKey(manifest)], steer: null, progress: null, done: null, maxS: 45, from: 'fallback' });
+    }
+    const scale = {};
+    for (const [k, v] of Object.entries(manifest?.scale && typeof manifest.scale === 'object' ? manifest.scale : {})) {
+        if (typeof v === 'number' && v > 0)
+            scale[k] = v;
+        else if (Array.isArray(v) && v.length === 2 && v.every((x) => typeof x === 'number'))
+            scale[k] = [v[0], v[1]];
+    }
+    const framing = {};
+    for (const [k, v] of Object.entries(manifest?.framing && typeof manifest.framing === 'object' ? manifest.framing : {})) {
+        if (Array.isArray(v) && v.length === 2 && v.every((x) => typeof x === 'number'))
+            framing[k] = [v[0], v[1]];
+    }
+    const life = manifest?.life && typeof manifest.life === 'object' ? manifest.life : {};
+    const c = w.crowd && typeof w.crowd === 'object' ? w.crowd : {};
+    const people = typeof c.people === 'number' && c.people >= 0 ? [c.people, c.people]
+        : Array.isArray(c.people) && c.people.length === 2 && c.people.every((x) => typeof x === 'number') ? [c.people[0], c.people[1]] : null;
+    return {
+        routes, stallS: num(w.stall_s, 6), reactM: num(w.react_m, 8), challenge: strs(w.challenge).length ? strs(w.challenge) : null,
+        scale, framing,
+        actors: {
+            player: playerOf(manifest).from === 'default' ? undefined : playerOf(manifest).pattern,
+            people: typeof life.people === 'string' ? life.people : undefined,
+            creatures: typeof life.creatures === 'string' ? life.creatures : undefined,
+        },
+        crowd: { people, clumpM: num(c.clump_m, 1.5), gapM: num(c.gap_m, 40) },
+        problems,
+    };
+}
+export function field(state, path) {
+    let v = state;
+    for (const k of path.split('.')) {
+        if (!v || typeof v !== 'object')
+            return undefined;
+        v = v[k];
+    }
+    return v;
+}
+export function isDone(d, state) {
+    if (!d || !state)
+        return false;
+    const v = field(state, d.field);
+    if (v === undefined)
+        return false;
+    if (d.is !== undefined)
+        return v === d.is;
+    if (d.not !== undefined)
+        return v !== d.not;
+    if (typeof v === 'number' && d.above !== undefined)
+        return v > d.above;
+    if (typeof v === 'number' && d.below !== undefined)
+        return v < d.below;
+    return false;
+}
+export function steerKey(s, state) {
+    if (!s)
+        return null;
+    const v = field(state, s.field);
+    if (typeof v !== 'number')
+        return null;
+    if (v > s.to + s.within)
+        return s.lower;
+    if (v < s.to - s.within)
+        return s.raise;
+    return null;
+}
+export function chainsOf(routes, only = [], chain = []) {
+    const by = new Map(routes.map((r) => [r.name, r]));
+    const problems = [];
+    if (chain.length) {
+        const legs = chain.map((n) => by.get(n)).filter((r) => !!r);
+        const missing = chain.filter((n) => !by.has(n));
+        if (missing.length)
+            problems.push(`--chain names no route ${missing.join(', ')} (routes: ${routes.map((r) => r.name).join(', ')})`);
+        return { chains: legs.length ? [legs] : [], problems };
+    }
+    const follow = (r) => {
+        const out = [r];
+        const seen = new Set([r.name]);
+        let at = r;
+        while (at.then && by.has(at.then) && !seen.has(at.then)) {
+            at = by.get(at.then);
+            seen.add(at.name);
+            out.push(at);
+        }
+        return out;
+    };
+    if (only.length) {
+        const legs = only.map((n) => by.get(n)).filter((r) => !!r);
+        return { chains: legs.map((r) => follow(r)), problems };
+    }
+    const continued = new Set(routes.map((r) => r.then).filter((x) => !!x));
+    return { chains: routes.filter((r) => !continued.has(r.name)).map(follow), problems };
+}
+export function pathFromState(state) {
+    for (const k of ['waypoints', 'path', 'route', 'pts']) {
+        const v = field(state, k);
+        const list = Array.isArray(v) ? v : v && typeof v === 'object' && Array.isArray(v.pts) ? v.pts : null;
+        if (!list)
+            continue;
+        const pts = list.map((p) => (Array.isArray(p) && typeof p[0] === 'number' ? [p[0], p[p.length > 2 ? 2 : 1]] : p && typeof p.x === 'number' && typeof p.z === 'number' ? [p.x, p.z] : null)).filter(Boolean);
+        if (pts.length >= 2)
+            return pts;
+    }
+    return null;
+}
+export function lateral(at, pts) {
+    let best = { d: Infinity, lat: 0, along: 0 };
+    let run = 0;
+    for (let i = 0; i < pts.length - 1; i++) {
+        const [ax, az] = pts[i], [bx, bz] = pts[i + 1];
+        const vx = bx - ax, vz = bz - az, len = Math.hypot(vx, vz) || 1e-9;
+        const t = Math.max(0, Math.min(1, ((at.x - ax) * vx + (at.z - az) * vz) / (len * len)));
+        const px = ax + vx * t, pz = az + vz * t, d = Math.hypot(at.x - px, at.z - pz);
+        if (d < best.d)
+            best = { d, lat: Math.sign(vx * (at.z - az) - vz * (at.x - ax)) * d, along: run + t * len };
+        run += len;
+    }
+    return { lat: Math.round(best.lat * 100) / 100, along: Math.round(best.along * 100) / 100, length: Math.round(run * 100) / 100 };
+}
+export class PositionSteer {
+    swap = false;
+    last = null;
+    worse = 0;
+    flipped = 0;
+    s;
+    constructor(s) { this.s = s; }
+    next(at, pts) {
+        if (!at || !pts)
+            return { key: null, lat: null, along: null };
+        const { lat, along } = lateral(at, pts);
+        if (this.last) {
+            if (Math.abs(lat) > Math.abs(this.last.lat) + 0.02)
+                this.worse++;
+            else
+                this.worse = 0;
+            if (this.worse >= 2) {
+                this.swap = !this.swap;
+                this.worse = 0;
+                this.flipped++;
+            }
+        }
+        let key = null;
+        if (lat > this.s.within)
+            key = this.swap ? this.s.raise : this.s.lower;
+        else if (lat < -this.s.within)
+            key = this.swap ? this.s.lower : this.s.raise;
+        this.last = key ? { lat, key } : null;
+        if (!key)
+            this.worse = 0;
+        return { key, lat, along };
+    }
+}