// This browser's own scanner in a design test. Whether the browser has one the test can use is found once a page // session, sending nothing (the probe and its working check), and it is named by platform. In a test it reads the // scenes' rebuilt frames (frames.js), the plain code's and the design's, as they arrive, and stops once no reads of // the scenes left could change its answer (the exact early stop), or when the scans come too slowly for the budget. // The rule every scanner is judged by is here too, as the server has it. What this scanner reads stays in the page. import { CAPTURE, FRAME, decodeGrey, ending, fetchScene, linked, sha256Hex, toBitmap } from './frames.js'; let T = null; // web/data/test.json (useTest) let C = null; // binomial coefficients C[n][k], for n up to the test's scenes const encoder = new TextEncoder(); /** test.js, before useTest: what the code relies on in test.json: whole numbers where it counts, the frame sizes the * shrink is exact for, and a sign test whose alpha is one over a whole number. */ export function fits(s) { const whole = (...xs) => xs.every((x) => Number.isInteger(x) && x >= 0); const pair = (a, b) => Array.isArray(a) && a[0] === b[0] && a[1] === b[1]; const inv = 1 / s.rule.alpha; return typeof s.page === 'boolean' && whole(s.scenes.s, s.rule.like_cost, s.rule.q, s.join, s.limits.max_version) && s.scenes.s >= 1 && s.scenes.s <= 20 && Math.abs(inv - Math.round(inv)) < 1e-9 && pair(s.frames.capture, CAPTURE) && pair(s.frames.frame, FRAME) && Boolean(s.check.png && s.check.jpeg && s.mb.jpeg && s.mb.png && s.figures); } /** test.js, once test.json is in: the settings everything here reads. */ export function useTest(settings) { T = settings; C = [[1]]; for (let n = 1; n <= T.scenes.s; n += 1) C.push(C[n - 1].map((v, k) => v + (C[n - 1][k - 1] || 0)).concat(1)); } // ---- the rule, per scanner, over the paired scenes ----------------------------------------------------------------- /** The one-sided exact sign test on (b, c) under the rule's alpha, in whole numbers: sum over k = b..n of C(n, k), * times 1 / alpha, under 2^n (n = b + c), so this and the server's never round differently. */ const under = (b, c) => Math.round(1 / T.rule.alpha) * C[b + c].slice(b).reduce((sum, v) => sum + v, 0) < 2 ** (b + c); /** One scanner's answer: b counts the scenes where it read the plain code and missed the design, c the reverse, t * and d the scenes where it read the plain code and the design. 'worse' when the sign test confirms the loss; 'like' * (as well as a plain code) with a cost b - c of at most like_cost, and t or d at least q; otherwise it can't tell: * 'close' with a higher cost, else 'few'. */ export function answer(b, c, t, d) { const { like_cost: cost, q } = T.rule; if (under(b, c)) return 'worse'; if (b - c <= cost && (t >= q || d >= q)) return 'like'; return b - c > cost ? 'close' : 'few'; } /** The answer once no reads of the r scenes left could change it, else null: the exact early stop in closed form * (equal to trying every way the scenes left could read). At r = 0 it is the answer itself. */ export function settled(b, c, t, d, r) { const { like_cost: cost, q } = T.rule; if (r === 0) return answer(b, c, t, d); if (under(b, c + r)) return 'worse'; if ((t >= q || d >= q) && b - c + r <= cost) return 'like'; if (b - c - r > cost && !under(b + r, c)) return 'close'; if (b - c + r <= cost && t + r < q && d + r < q) return 'few'; return null; } // ---- the probe: once a page session, sending nothing ---------------------------------------------------------------- let probing = null; let found = { state: 'pending' }; /** Whether this browser has a scanner the test can use: { state: 'ready', name: 'apple' | 'google', frames: 'jpeg' | * 'png' }, 'none' with the step that failed (1: no BarcodeDetector here, 2: not Google Chrome on macOS or Android, * 3: it lists no QR codes), 'broken' (the working check's read failed) or 'blocked' (this browser's canvas reads are * altered or blocked). Run once a page session, when a picture is first marked The original graphic. */ export function probe() { probing ||= steps().catch(() => ({ state: 'none', step: 1 })).then((r) => { found = r; return r; }); return probing; } /** The probe's result so far: { state: 'pending' } until it has one. */ export const probed = () => found; async function steps() { if (!(window.isSecureContext && 'BarcodeDetector' in window)) return { state: 'none', step: 1 }; if (!platformName()) return { state: 'none', step: 2 }; let formats = []; try { formats = await BarcodeDetector.getSupportedFormats(); } catch { /* none listed */ } if (!Array.isArray(formats) || !formats.includes('qr_code')) return { state: 'none', step: 3 }; return check(); } /** After 'broken', a test's start runs the working check again (local, with the same two pictures), so the next test * or Try again can bring the scanner back; any other result stands for the page session. */ export async function recheck() { if (found.state === 'broken') found = await check(); return found; } /** 'apple' or 'google' for Google Chrome on macOS or on Android, from userAgentData's brands and platform (never its * high-entropy hints, which the Hub's iframe may not pass), else ''. */ function platformName() { const ua = navigator.userAgentData; const { brand, platforms } = T.browsers; const chrome = Array.isArray(ua?.brands) && ua.brands.some((b) => b.brand === brand); return chrome && Object.hasOwn(platforms, ua.platform) ? platforms[ua.platform] : ''; } /** Which words fit this browser: 'chrome-mac', 'chrome-android', 'mac' (a Mac, not Chrome: "Macintosh" with no touch * points, so an iPad isn't taken for one) or 'other'. It only chooses words. */ export function platformKind() { if (platformName()) return navigator.userAgentData.platform === 'Android' ? 'chrome-android' : 'chrome-mac'; return /Macintosh/.test(navigator.userAgent) && navigator.maxTouchPoints === 0 ? 'mac' : 'other'; } /** Whether this browser's scanner can read a test's code, given whether its two truths differ (differ: the SHA-256 of * its raw bytes, then of its text in UTF-8, from the 202, or before it where the first reading shows it, test_turn.js * rawNotText): in Chrome on Android only when they don't, raw bytes that are UTF-8 text; elsewhere always. Chrome 113 * on Android crashed its GPU process on every other code measured (detect rejected with NotSupportedError, each * time), so trying again can't help there. */ export const readsContent = (differ) => platformKind() !== 'chrome-android' || !differ; /** Whether this browser asks to save data: read at every test's start, so turning it off and Try again bring the * scanner in. */ export const saveDataOn = () => navigator.connection?.saveData === true; /** What this browser's scanner does in a test (rec: test.js's record; joins: tests it joined by itself so far this * page session), from the probe's result: { decision, name, frames }. It joins (with its frames: 'jpeg', or 'png' * when this browser decodes JPEG differently); is offered, once a page session's first {join} tests have taken it * by themselves, unless Add was pressed or this test's first decision was to join; is kept out by Save-Data; or * isn't in the test: 'late' (the probe not done in time), 'broken', 'none' or 'blocked'. A code the record already * knows this scanner can't read (readsContent) gives 'none' from the start, whatever the probe found. */ export function partFor(rec, joins, pr = found) { const part = { name: pr.name || platformName(), frames: pr.frames || 'jpeg' }; if (!readsContent(rec.truthsDiffer)) part.decision = 'none'; else if (pr.state !== 'ready') part.decision = pr.state === 'pending' ? 'late' : pr.state; else if (saveDataOn()) part.decision = 'save_data'; else part.decision = rec.added || rec.first === 'joins' || joins < T.join ? 'joins' : 'offered'; return part; } /** At a test's start: the probe, waited for at most probe_wait_s, and after 'broken' the working check again. */ export async function decide(rec, joins) { if (found.state === 'pending') await Promise.race([probe(), wait(T.page_waits.probe_wait_s * 1000)]); if (found.state === 'broken') await recheck(); return partFor(rec, joins); } const bytesOf = (b64) => Uint8Array.from(atob(b64), (ch) => ch.charCodeAt(0)); const wait = (ms) => new Promise((resolve) => { setTimeout(resolve, ms); }); /** The working check, on test.json's two pictures, decoded along the frames' own path: the plain code's PNG must * give its pinned grey bytes (else 'blocked': this browser's canvas reads are altered or blocked, as a readback that * throws is), and a new detector must read its known content (else 'broken'); either is tried once more after * check_retry_s. A JPEG that decodes to other bytes keeps the scanner, with PNG frames from the start. */ async function check() { let got = await checkOnce(); if (got.state !== 'ready') { await wait(T.page_waits.check_retry_s * 1000); got = await checkOnce(); } return got; } async function checkOnce() { const { png, jpeg } = T.check; let code; let frames = 'jpeg'; try { code = await decodeGrey(bytesOf(png.b64), 'image/png', png.w, png.h); if ((await sha256Hex(code)) !== png.grey_sha256) return { state: 'blocked' }; const scene = await decodeGrey(bytesOf(jpeg.b64), 'image/jpeg', jpeg.w, jpeg.h); if ((await sha256Hex(scene)) !== jpeg.grey_sha256) frames = 'png'; } catch { return { state: 'blocked' }; } try { const detector = new BarcodeDetector({ formats: ['qr_code'] }); if (!(await reads(detector, code, png.w, png.h, [png.content_sha256]))) return { state: 'broken' }; } catch { return { state: 'broken' }; } return { state: 'ready', name: platformName(), frames }; } /** Whether the detector reads one of truths (the content's UTF-8 SHA-256s) from grey bytes, through an ImageBitmap * of them; throws when detect throws, or takes over detect_s. */ async function reads(detector, grey, w, h, truths) { const bitmap = await toBitmap(grey, w, h); const detecting = detector.detect(bitmap); detecting.then(() => bitmap.close(), () => bitmap.close()); let timer = 0; const late = new Promise((resolve, reject) => { timer = setTimeout(() => reject(new Error('detect')), T.budget.detect_s * 1000); }); try { const codes = await Promise.race([detecting, late]); for (const code of codes) if (truths.includes(await sha256Hex(encoder.encode(code.rawValue)))) return true; return false; } finally { clearTimeout(timer); } } // ---- the browser's part of one test -------------------------------------------------------------------------------- /** The browser's part of a test. opts: base (the test's routes), truths, mode ('jpeg' or 'png': the probe's frames), * signal (aborted when the page leaves the test, or Leave it out is pressed), onScene(k) after each whole scene, and * onMode('png') once the rest of the test takes PNG frames. One detector reads every frame; one scene is in hand and * the next in flight. The budget counts only the pictures' fetches: after project_after_scenes scenes, and after * each one from then on, the part stops when the time they took, projected over every scene from the link's own * pace, passes fetch_s (it can't count on an early stop), and at once when they reach it. Resolves to { end, answer }: * 'settled' (the early stop) or 'complete', with the scanner's answer; 'start', 'stopped' or 'slow' (a fallback); * 'dropped' (the server no longer has the test); or 'aborted'. Never rejects. */ export async function runBrowserPart(opts) { const n = T.scenes.s; const [w, h] = FRAME; const B = T.budget; const meter = { bytes: 0, ms: 0, scenes: 0, limit: B.fetch_s * 1000, tries: B.fetch_tries, wait: T.page_waits.scene_retry_s * 1000, hold: 2 * T.server.scene_wait_s * 1000, // facts come within scene_wait_s, a 503 included: twice that is a stall }; let detector; try { detector = new BarcodeDetector({ formats: ['qr_code'] }); } catch { return { end: 'start' }; } let mode = opts.mode; const fetchOne = (i) => { const ctl = linked(opts.signal); const job = fetchScene(opts.base, i, mode, ctl.signal, meter); job.catch(() => {}); // awaited in turn, or aborted unread return { ctl, job }; }; let next = fetchOne(0); let b = 0; let c = 0; let t = 0; let d = 0; try { for (let i = 0; i < n; i += 1) { const scene = await next.job; if (scene.switched && mode === 'jpeg') { mode = 'png'; opts.onMode('png'); } next = i + 1 < n ? fetchOne(i + 1) : null; // in flight while this scene is read, so a switch wastes nothing const plain = await reads(detector, scene.plain, w, h, opts.truths); const design = await reads(detector, scene.design, w, h, opts.truths); if (opts.signal.aborted) throw ending('aborted'); b += plain && !design; c += design && !plain; t += plain; d += design; const k = i + 1; opts.onScene(k); const a = settled(b, c, t, d, n - k); if (a) { next?.ctl.abort(); return { end: k === n ? 'complete' : 'settled', answer: a }; } if (k >= B.project_after_scenes && (meter.ms * n) / Math.max(1, meter.scenes) > meter.limit) { next?.ctl.abort(); return { end: 'slow' }; } } } catch (err) { next?.ctl.abort(); return { end: err.end || (opts.signal.aborted ? 'aborted' : 'stopped') }; } return { end: 'stopped' }; // not reached: the last scene always settles }