// Native media, independent clocks. No follower seek or rate-based correction. export function safeLocalURL(value) { if (typeof value !== 'string' || value.length > 4096 || !value) throw Error('Missing local link'); const decoded = decodeURIComponent(value); if (/[?#]/.test(value) || /[\\:<>"\u0000-\u001f]/.test(decoded) || decoded.startsWith('/') || decoded.split('/').some(p => !p || p === '.' || p === '..')) throw Error('Unsafe local link'); return value; } const finiteNonnegative = value => typeof value === 'number' && Number.isFinite(value) && value >= 0; const sha = value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value); export function differenceEligibility(original, port) { for (const a of [original, port]) { const f = a?.frame; if (!f || !sha(a.sha256) || !sha(f.media_sha256) || !f.lossless || !a.url?.toLowerCase().endsWith('.png') || !finiteNonnegative(f.media_seconds) || typeof f.event !== 'string' || !f.event || !(a.size > 0)) return {eligible: false, reason: 'Missing identified lossless PNG frame and source-media provenance'}; try { safeLocalURL(a.url); } catch { return {eligible: false, reason: 'Unsafe frame link'}; } if (![f.width, f.height].every(n => Number.isInteger(n) && n > 0 && n <= 8192) || !Array.isArray(f.viewport) || f.viewport.length !== 2 || !f.viewport.every(n => Number.isInteger(n) && n > 0 && n <= 8192) || !Array.isArray(f.crop) || f.crop.length !== 4 || !f.crop.every(n => Number.isInteger(n) && n >= 0) || f.crop[2] !== f.width || f.crop[3] !== f.height || f.crop[0] + f.width > f.viewport[0] || f.crop[1] + f.height > f.viewport[1]) return {eligible: false, reason: 'Invalid frame dimensions, viewport or crop'}; } const a = original.frame, b = port.frame; if (a.event !== b.event || a.width !== b.width || a.height !== b.height || JSON.stringify(a.viewport) !== JSON.stringify(b.viewport) || JSON.stringify(a.crop) !== JSON.stringify(b.crop)) return {eligible: false, reason: 'Frame event, viewport/aspect or crop mismatch'}; return {eligible: true, reason: 'Matched identified lossless stills; review aid only'}; } export function createPairController({original, port, onChange = () => {}, timeoutMs = 5000, frames = {}}) { const media = {original, port}; let problem = '', selected = null, gain = 1, audio = 'none', generation = 0; let selecting = false; const overlays = {annotations: false, difference: false}; const listeners = []; function snapshot() { const sides = {}; for (const [side, m] of Object.entries(media)) { sides[side] = {recording_seconds: m?.currentTime ?? null, duration: m?.duration ?? null, aligned_elapsed: m && selected?.[side] ? m.currentTime - selected[side].media_seconds : null, state: !m ? 'missing' : m.error ? 'decoding error' : m.currentTime >= m.duration ? 'ended' : m.seeking ? 'seeking' : m.readyState < 3 ? 'buffering' : m.paused ? 'paused' : 'playing'}; } return {problem, selected, sides, gain, audio, gainAdjusted: gain !== 1, gainLabel: gain === 1 ? 'Unadjusted · 1.00' : 'Review-only volume · ' + gain.toFixed(2), overlays: {...overlays}, selecting, eventDrift: selected ? {seconds: selected.port.elapsed_seconds - selected.original.elapsed_seconds, uncertainty_seconds: selected.original.uncertainty_seconds + selected.port.uncertainty_seconds} : null, playbackDrift: selected && original && port ? sides.port.aligned_elapsed - sides.original.aligned_elapsed : null}; } const notify = () => onChange(snapshot()); const pause = () => { generation++; selecting = false; for (const m of Object.values(media)) if (m) m.pause(); notify(); }; const fail = message => { problem = message; pause(); }; function listen(m, event, callback) { m.addEventListener(event, callback); listeners.push(() => m.removeEventListener(event, callback)); } function setAudio(side) { if (!['none', 'original', 'port'].includes(side)) throw Error('Unknown soundtrack'); for (const m of Object.values(media)) if (m && !m.muted) m.muted = true; audio = side; if (media[side]) media[side].muted = false; notify(); } function setGain(value) { if (!finiteNonnegative(value) || value > 1) throw Error('Review volume must be between zero and one'); gain = value; for (const m of Object.values(media)) if (m && m.volume !== gain) m.volume = gain; notify(); } for (const [side, m] of Object.entries(media)) { if (!m) continue; m.muted = true; m.volume = 1; m.playbackRate = 1; for (const event of ['waiting', 'stalled']) listen(m, event, () => { if (!selecting) fail(side + ' buffering; wait for readiness then explicitly play'); }); listen(m, 'error', () => fail(side + ' decoding/media error (code ' + (m.error?.code ?? 'unknown') + ')')); listen(m, 'ended', () => fail(side + ' ended; the other recording tail remains playable')); listen(m, 'ratechange', () => { if (m.playbackRate !== 1) m.playbackRate = 1; notify(); }); for (const event of ['timeupdate', 'canplay', 'pause', 'playing', 'seeked']) listen(m, event, notify); // The UI has dedicated audio controls and per-side play/seek controls. // Guard external unmute changes as well; never enable a second soundtrack. listen(m, 'volumechange', () => { if (!m.muted && audio !== side) { m.muted = true; } if (m.volume !== gain) m.volume = gain; notify(); }); } function waitUntil(m, ready, events, label) { if (m.error) return Promise.reject(Error('Decode failure during ' + label)); if (ready()) return Promise.resolve(); return new Promise((resolve, reject) => { let timer; const clean = () => { clearTimeout(timer); for (const event of [...events, 'error']) m.removeEventListener(event, check); }; const check = () => { if (m.error) { clean(); reject(Error('Decode failure during ' + label)); } else if (ready()) { clean(); resolve(); } }; for (const event of [...events, 'error']) m.addEventListener(event, check); timer = setTimeout(() => { clean(); reject(Error(label + ' readiness timed out')); }, timeoutMs); check(); }); } async function seek(m, value) { m.playbackRate = 1; m.currentTime = value; await waitUntil(m, () => !m.seeking, ['seeked'], 'Seek'); } async function selectEvent(event) { pause(); const token = generation; selecting = true; problem = 'Waiting for event seek readiness'; notify(); try { for (const side of ['original', 'port']) { const marker = event?.[side]; if (!media[side] || !marker || !['media_seconds', 'elapsed_seconds', 'uncertainty_seconds'] .every(key => finiteNonnegative(marker[key]))) throw Error('Missing or invalid corresponding event'); } await Promise.all(Object.values(media).map(m => waitUntil(m, () => m.readyState >= 1, ['loadedmetadata', 'durationchange', 'canplay'], 'Metadata'))); if (token !== generation) throw Error('Event selection cancelled'); for (const side of ['original', 'port']) { if (!Number.isFinite(media[side].duration) || event[side].media_seconds > media[side].duration) throw Error('Out-of-range corresponding event'); } await Promise.all(Object.entries(media).map(([side, m]) => seek(m, event[side].media_seconds))); if (token !== generation) throw Error('Event selection cancelled'); selected = structuredClone(event); problem = ''; } catch (error) { if (token === generation) fail(error.message); throw error; } finally { if (token === generation) selecting = false; notify(); } } async function seekSide(side, seconds) { pause(); const m = media[side]; if (!m || !finiteNonnegative(seconds) || !Number.isFinite(m.duration) || seconds > m.duration) throw Error('Invalid manual seek'); try { await seek(m, seconds); problem = ''; notify(); } catch (error) { fail(error.message); throw error; } } async function start(sides) { if (selecting) { problem = 'Event seek still pending'; notify(); return false; } const active = sides.filter(side => media[side] && media[side].currentTime < media[side].duration); for (const side of active) { const m = media[side]; if (m.error) { fail(side + ' decoding/media error'); return false; } if (m.readyState < 3 || m.seeking) { fail(side + ' buffering or seeking; explicit recovery required'); return false; } } if (!active.length) { fail('Recordings ended or not ready; seek to review again'); return false; } const token = ++generation; try { const results = await Promise.allSettled(active.map(side => { media[side].playbackRate = 1; return media[side].play(); })); if (generation !== token) { for (const m of Object.values(media)) m?.pause(); notify(); return false; } const rejected = results.find(r => r.status === 'rejected'); if (rejected) throw rejected.reason; problem = ''; notify(); return true; } catch (error) { fail('Play rejected: ' + error.message); return false; } } async function play() { if (!original || !port) { fail('Missing recording; available side has manual controls'); return false; } return start(['original', 'port']); } async function playSide(side) { if (!media[side]) { fail('Missing ' + side + ' recording'); return false; } pause(); return start([side]); } function setOverlay(name, enabled) { if (!Object.hasOwn(overlays, name)) throw Error('Unknown overlay'); if (name === 'difference' && enabled) { const eligible = differenceEligibility(frames.original, frames.port); if (!eligible.eligible) throw Error(eligible.reason); } overlays[name] = Boolean(enabled); notify(); } function dispose() { pause(); for (const remove of listeners) remove(); } return {selectEvent, play, playSide, seekSide, pause, snapshot, setAudio, setGain, setOverlay, dispose}; } function element(doc, tag, text) { const node = doc.createElement(tag); node.textContent = text; return node; } function describe(doc, value) { if (Array.isArray(value)) { const list = doc.createElement('ul'); for (const item of value) { const li = doc.createElement('li'); li.append(describe(doc, item)); list.append(li); } if (!value.length) list.append(element(doc, 'li', 'None recorded')); return list; } if (value && typeof value === 'object') { const list = doc.createElement('dl'); for (const [key, item] of Object.entries(value)) { const dd = doc.createElement('dd'); dd.append(describe(doc, item)); list.append(element(doc, 'dt', key.replaceAll('_', ' ')), dd); } return list; } return element(doc, 'span', value == null ? 'Unrecorded' : String(value)); } export function renderCapabilities(container, ledger) { const doc = container.ownerDocument; container.replaceChildren(element(doc, 'h2', 'Capability evidence')); const rows = ledger?.capabilities ?? []; if (!rows.length) { container.append(element(doc, 'p', 'No capability ledger supplied. Acceptance remains open.')); return; } const nav = doc.createElement('nav'); nav.setAttribute?.('aria-label', 'Browse gameplay capabilities'); for (const row of rows) { const a = element(doc, 'a', row.group + ' · ' + row.id); a.href = '#capability-' + encodeURIComponent(row.id); nav.append(a, element(doc, 'span', ' · ')); } container.append(nav); for (const row of rows) { const article = doc.createElement('article'); article.id = 'capability-' + encodeURIComponent(row.id); article.append(element(doc, 'h3', row.group + ' · ' + row.id), element(doc, 'p', row.summary), element(doc, 'p', 'Requirements: ' + (row.requirement_ids ?? []).join(', '))); const impact = {blocking: 0, disruptive: 1, subtle: 2, missing_verification: 3}; const discrepancies = [...(row.discrepancies ?? [])].sort((a, b) => (impact[a.impact] ?? 4) - (impact[b.impact] ?? 4) || String(a.id).localeCompare(String(b.id))); for (const [label, value] of [['Verified scope', row.verified_scope], ['Known differences', row.differences], ['Acceptance conditions', row.acceptance], ['Current applicable evidence', row.current], ['Discrepancies by impact', discrepancies], ['Scenarios', row.scenario_ids]]) { article.append(element(doc, 'h4', label), describe(doc, value)); } article.append(element(doc, 'h4', 'Source evidence')); for (const link of row.source_links ?? []) { if (link.validated_local === true && typeof link.href === 'string' && link.href.startsWith('sources/')) { try { const a = element(doc, 'a', link.label + ' · ' + link.path); a.href = safeLocalURL(link.href); a.target = '_blank'; a.rel = 'noopener'; article.append(a); } catch { article.append(element(doc, 'p', 'Invalid local source link')); } } else article.append(element(doc, 'p', (link.label ?? String(link)) + ' · ' + (link.path ?? '') + ' · ' + (link.missing ?? 'Source reference not bundled; acceptance remains open'))); } const history = doc.createElement('details'); history.append(element(doc, 'summary', 'History / superseded evidence'), describe(doc, row.history)); article.append(history); container.append(article); } } export function framePair(model) { const candidates = {}; for (const side of ['original', 'port']) { const s = model.sides[side]; candidates[side] = s.artifacts.filter(a => a.frame && a.frame.media_sha256 === s.media?.sha256 && finiteNonnegative(a.frame.media_seconds) && a.frame.media_seconds <= s.media.duration_seconds && s.events.some(e => e.name === a.frame.event && e.artifact === s.media.path && e.media_seconds === a.frame.media_seconds)); } for (const a of candidates.original) for (const b of candidates.port) { if (differenceEligibility(a, b).eligible) return {original: a, port: b}; } return {original: candidates.original[0], port: candidates.port[0]}; } async function drawDifference(canvas, frames) { const eligible = differenceEligibility(frames.original, frames.port); if (!eligible.eligible) throw Error(eligible.reason); const images = await Promise.all([frames.original, frames.port].map(a => new Promise((resolve, reject) => { const image = new Image(); image.onload = () => resolve(image); image.onerror = () => reject(Error('Lossless still failed to decode')); image.src = safeLocalURL(a.url); }))); const {width, height} = frames.original.frame; if (images.some(i => i.naturalWidth !== width || i.naturalHeight !== height)) throw Error('Decoded still dimensions disagree with identified metadata'); canvas.width = width; canvas.height = height; const context = canvas.getContext('2d', {willReadFrequently: true}); context.drawImage(images[0], 0, 0); const a = context.getImageData(0, 0, width, height); context.drawImage(images[1], 0, 0); const b = context.getImageData(0, 0, width, height); for (let i = 0; i < a.data.length; i += 4) { for (let c = 0; c < 3; c++) a.data[i + c] = Math.abs(a.data[i + c] - b.data[i + c]); a.data[i + 3] = 255; } context.putImageData(a, 0, 0); } async function mount() { const doc = document; try { const response = await fetch('review.json'); if (!response.ok) throw Error('Review JSON unavailable'); const model = await response.json(); doc.querySelector('#scope').textContent = 'Case: ' + model.case_id; const media = {}; for (const side of ['original', 'port']) { const data = model.sides[side], panel = doc.querySelector('#' + side + '-panel'); const m = doc.querySelector('#' + side); media[side] = data.media ? m : null; if (data.media) m.src = safeLocalURL(data.media.url); panel.querySelector('.missing').textContent = [data.missing, data.reference_warning].filter(Boolean).join(' · '); panel.querySelector('.classification').textContent = [data.evidence_kind ?? 'missing', JSON.stringify(data.platform ?? {}), data.scope ?? '', data.historical ? 'HISTORICAL' : '', ...(data.limitations ?? [])].join(' · '); for (const artifact of data.artifacts) { const a = element(doc, 'a', artifact.role + ' · ' + artifact.path); a.href = safeLocalURL(artifact.url); a.target = '_blank'; a.rel = 'noopener'; panel.querySelector('.links').append(a); } } const frames = framePair(model); const format = n => Number.isFinite(n) ? n.toFixed(3) + ' s' : 'unrecorded'; function display(state) { doc.querySelector('#state').textContent = state.problem || 'Review at actual recording speed · 1×'; doc.querySelector('#gain-label').textContent = state.gainLabel; for (const side of ['original', 'port']) { const panel = doc.querySelector('#' + side + '-panel'), clock = state.sides[side]; panel.querySelector('.clock').textContent = 'Recording elapsed ' + format(clock.recording_seconds) + ' / ' + format(clock.duration) + ' · Event offset ' + format(clock.aligned_elapsed) + ' · ' + clock.state; const seek = panel.querySelector('.seek'); seek.max = String(Number.isFinite(clock.duration) ? clock.duration : 0); seek.value = String(clock.recording_seconds ?? 0); } doc.querySelector('#drift').textContent = state.eventDrift ? 'Observed scenario-event drift (port − original): ' + format(state.eventDrift.seconds) + ' ± ' + format(state.eventDrift.uncertainty_seconds) + ' · Browser playback drift after selected anchors: ' + format(state.playbackDrift) : 'Select corresponding observed markers to see scenario-event and playback drift separately.'; } const controller = createPairController({...media, frames, onChange: display}); display(controller.snapshot()); for (const side of ['original', 'port']) { const panel = doc.querySelector('#' + side + '-panel'); panel.querySelector('.side-play').disabled = !media[side]; panel.querySelector('.seek').disabled = !media[side]; panel.querySelector('.side-play').addEventListener('click', () => controller.playSide(side)); panel.querySelector('.side-pause').addEventListener('click', controller.pause); panel.querySelector('.seek').addEventListener('change', async event => { try { await controller.seekSide(side, Number(event.target.value)); } catch (error) { doc.querySelector('#state').textContent = error.message; } }); const receipt = model.sides[side].receipt_url; if (receipt) { const a = element(doc, 'a', 'Receipt / raw and derivative provenance'); a.href = safeLocalURL(receipt); a.target = '_blank'; a.rel = 'noopener'; panel.querySelector('.links').append(a); } } const events = doc.querySelector('#events'); model.events.forEach((event, i) => { const option = element(doc, 'option', event.name + (!event.original || !event.port ? ' · missing correspondence' : '')); option.value = String(i); events.append(option); }); events.addEventListener('change', async () => { if (events.value === '') return; try { await controller.selectEvent(model.events[Number(events.value)]); } catch (error) { doc.querySelector('#state').textContent = error.message; } }); doc.querySelector('#play').addEventListener('click', () => controller.play()); doc.querySelector('#pause').addEventListener('click', controller.pause); doc.querySelector('#audio').addEventListener('change', event => controller.setAudio(event.target.value)); doc.querySelector('#gain').addEventListener('input', event => controller.setGain(Number(event.target.value))); const annotations = doc.querySelector('#annotation-layer'); annotations.textContent = model.events.map(e => e.name + ' · Original ' + format(e.original?.media_seconds) + ' · Port ' + format(e.port?.media_seconds)).join(' | '); doc.querySelector('#annotations').addEventListener('change', event => { controller.setOverlay('annotations', event.target.checked); annotations.hidden = !event.target.checked; }); const eligibility = differenceEligibility(frames.original, frames.port); doc.querySelector('#difference-state').textContent = eligibility.reason; doc.querySelector('#difference').addEventListener('change', async event => { const canvas = doc.querySelector('#difference-layer'); try { controller.setOverlay('difference', event.target.checked); if (event.target.checked) await drawDifference(canvas, frames); canvas.hidden = !event.target.checked; } catch (error) { event.target.checked = false; controller.setOverlay('difference', false); canvas.hidden = true; doc.querySelector('#difference-state').textContent = error.message; } }); renderCapabilities(doc.querySelector('#capabilities'), model.ledger); } catch (error) { doc.querySelector('#scope').textContent = 'Review unavailable: ' + error.message; } } if (typeof document !== 'undefined') mount();