feat(01-02): preserve clocks exclusive audio and complete review tails

This commit is contained in:
UnixNight committed 2026-11-12 19:46:04 -05:00
1 parent 75d7ca4279
commit 91da92f17d
6 files changed
+505 -47

No files matched your search

+7 -2
View File
@@ -13,10 +13,14 @@
<main>
<section aria-label="Paired recordings" class="pair">
<article id="original-panel"><h2>Original reference</h2><p class="classification"></p>
<video id="original" controls preload="metadata" playsinline muted></video>
<video id="original" preload="metadata" playsinline muted></video>
<button class="side-play" type="button">Play original only</button><button class="side-pause" type="button">Pause</button>
<label>Original elapsed seek <input class="seek" aria-label="Seek original recording" type="range" min="0" max="0" value="0" step="0.01"></label>
<p class="missing"></p><output class="clock"></output><div class="links"></div></article>
<article id="port-panel"><h2>Port recording</h2><p class="classification"></p>
<video id="port" controls preload="metadata" playsinline muted></video>
<video id="port" preload="metadata" playsinline muted></video>
<button class="side-play" type="button">Play port only</button><button class="side-pause" type="button">Pause</button>
<label>Port elapsed seek <input class="seek" aria-label="Seek port recording" type="range" min="0" max="0" value="0" step="0.01"></label>
<p class="missing"></p><output class="clock"></output><div class="links"></div></article>
</section>
<section class="review-controls" aria-label="Review controls">
@@ -26,6 +30,7 @@
<label>Review volume <input id="gain" type="range" min="0" max="1" step="0.05" value="1"></label>
<output id="gain-label">Unadjusted · 1.00</output>
<p id="state" role="status" aria-live="polite"></p><p id="drift"></p>
<p>Event selection pauses and seeks each observed marker. Playback resumes only when you press Play. Each recording keeps its complete duration at 1×.</p>
</section>
<section aria-label="Optional review aids"><h2>Review aids</h2>
<label><input id="annotations" type="checkbox"> Show event annotations</label>
+2
View File
@@ -19,6 +19,8 @@ a { color: #9ad9e9; overflow-wrap: anywhere; }
.links { display: flex; flex-wrap: wrap; gap: .7rem; margin-top: .5rem; }
.classification { min-height: 3em; overflow-wrap: anywhere; }
output { font-variant-numeric: tabular-nums; }
dt { font-weight: 600; color: #acd0db; } dd { margin-left: 1rem; overflow-wrap: anywhere; }
h4 { margin: .8rem 0 .3rem; } ul { padding-left: 1.3rem; }
canvas { max-width: 100%; background: #000; }
details { margin: .5rem 0; }
summary { cursor: pointer; }
+307 -36
View File
@@ -2,74 +2,289 @@
export function safeLocalURL(value) {
if (typeof value !== 'string' || value.length > 4096 || !value) throw Error('Missing local link');
const decoded = decodeURIComponent(value);
if (/[\\:?#<>"\u0000-\u0020]/.test(decoded) || decoded.startsWith('/') ||
if (/[?#]/.test(value) || /[\\:<>"\u0000-\u001f]/.test(decoded) || decoded.startsWith('/') ||
decoded.split('/').some(p => !p || p === '.' || p === '..')) throw Error('Unsafe local link');
return value;
}
export function createPairController({original, port, onChange = () => {}}) {
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;
const snapshot = () => ({problem, selected});
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 = () => { for (const m of Object.values(media)) if (m) m.pause(); notify(); };
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.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.addEventListener('waiting', () => fail(side + ' buffering'));
m.addEventListener('error', () => fail(side + ' decoding/media error'));
m.currentTime = value;
await waitUntil(m, () => !m.seeking, ['seeked'], 'Seek');
}
async function selectEvent(event) {
pause();
for (const side of ['original', 'port']) {
const m = media[side], marker = event?.[side];
if (!m || !marker || !Number.isFinite(marker.media_seconds) || marker.media_seconds < 0 ||
marker.media_seconds > m.duration) throw Error('Missing or out-of-range corresponding event');
}
for (const side of ['original', 'port']) {
media[side].playbackRate = 1;
media[side].currentTime = event[side].media_seconds;
}
selected = event; problem = ''; notify();
}
async function play() {
if (!original || !port) { fail('Missing recording'); return false; }
const token = generation;
selecting = true; problem = 'Waiting for event seek readiness'; notify();
try {
for (const m of Object.values(media)) m.playbackRate = 1;
const results = await Promise.allSettled(Object.values(media).map(m => m.play()));
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; }
}
return {selectEvent, play, pause, snapshot};
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(', ')),
element(doc, 'p', 'Verified scope: ' + JSON.stringify(row.verified_scope)),
element(doc, 'p', 'Differences: ' + JSON.stringify(row.differences)),
element(doc, 'p', 'Acceptance: ' + JSON.stringify(row.acceptance)),
element(doc, 'p', 'Current evidence: ' + JSON.stringify(row.current)),
element(doc, 'p', 'Scenarios: ' + row.scenario_ids.join(', ')),
element(doc, 'p', 'Source references: ' + JSON.stringify(row.source_links)));
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'), element(doc, 'p', JSON.stringify(row.history)));
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 {
@@ -83,7 +298,7 @@ async function mount() {
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;
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(' · ');
@@ -93,9 +308,44 @@ async function mount() {
panel.querySelector('.links').append(a);
}
}
const controller = createPairController({...media, onChange: state => {
doc.querySelector('#state').textContent = state.problem || 'Paused or playing at actual recording speed';
}});
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); });
@@ -106,6 +356,27 @@ async function mount() {
});
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; }
}