mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 00:32:21 +00:00
A resumed hold waited only its rest unless the layer gave a media gate, and only trimmed clips have one, so an untrimmed clip started again (as on Gyirong) was cut short. The layer now says when a run going on from a seek started its clip again, and the hold then plays out as from its start: through the media gate when there is one, else for the whole hold.
3325 lines
140 KiB
JavaScript
3325 lines
140 KiB
JavaScript
import { bindFakeCesiumCamera } from '../testSupport/fakeCameraPort.mjs';
|
||
import { fakeDrawPort } from '../testSupport/fakeDrawPort.mjs';
|
||
import { fakeGlobePort } from '../testSupport/fakeGlobePort.mjs';
|
||
import assert from 'node:assert/strict';
|
||
import { readFile } from 'node:fs/promises';
|
||
import test from 'node:test';
|
||
import { claimPointer, releasePointer } from './inputOwnership.js';
|
||
import * as Cesium from 'cesium';
|
||
import { useBhoteKoshiPanelStore } from '../ui/stores/bhoteKoshiPanel.js';
|
||
import { useImagerySplitStore } from '../ui/stores/imagerySplit.js';
|
||
import { applicationPinia } from '../ui/vueRuntime.js';
|
||
import { SOURCE_PATH_BEAT_IDS } from './bhoteKoshiShotPaths.js';
|
||
import {
|
||
BHOTE_KOSHI_LAYER_ID,
|
||
activeEvidenceIndex,
|
||
adjacentEvidenceIndex,
|
||
buildCinematicKeyframes,
|
||
buildEvidenceTimeline,
|
||
clampUnit,
|
||
createBhoteKoshiEventLayer,
|
||
evidenceCardLayout,
|
||
createEvidenceFrame,
|
||
elapsedLabel,
|
||
evidenceBeatProgress,
|
||
evidenceBeatPresentation,
|
||
evidenceCorroborationLabel,
|
||
evidenceSequenceWindow,
|
||
evidenceSummaryLines,
|
||
floodProgressForStoryProgress,
|
||
interpolateHeadingDegrees,
|
||
sampleCinematicPose,
|
||
updateEvidenceFrame,
|
||
updateCorridorPositionCache,
|
||
usesProviderEmbeddedEvidence,
|
||
visibleSegmentCount,
|
||
} from './bhoteKoshiEvent.js';
|
||
import { SCENE_RECIPES, getSceneAppendRecipeById } from '../scenes/recipes.js';
|
||
import { LayerLifecycle } from './lifecycle.js';
|
||
import { createBhoteKoshiEmbeddedMedia } from './bhoteKoshiEmbeddedMedia.js';
|
||
import { SceneDirector } from '../scenes/director.js';
|
||
|
||
const eventUrl = new URL('../../public/events/bhote-koshi-2026/event.json', import.meta.url);
|
||
const eventModuleUrl = new URL('./bhoteKoshiEvent.js', import.meta.url);
|
||
|
||
/** The event's divider as the imagery split store holds it, or undefined. */
|
||
const eventSplit = () =>
|
||
useImagerySplitStore(applicationPinia()).splits.findLast(
|
||
(split) => split.view.id === 'bhote-koshi-split-line',
|
||
);
|
||
|
||
// The panel controls the layer presents, by the selector the panel view gives each.
|
||
const PANEL_REFS = {
|
||
'[data-role="imagery-comparison"]': 'imagerySection',
|
||
'[data-role="time"]': 'time',
|
||
'[data-role="caveat"]': 'caveat',
|
||
'[data-role="imagery-cloud-note"]': 'imageryCloudNote',
|
||
'[data-role="progress"]': 'progressInput',
|
||
'[data-role="split"]': 'splitInput',
|
||
'[data-role="timeline-label"]': 'timelineLabel',
|
||
'[data-role="beat-index"]': 'beatIndex',
|
||
'[data-role="beat-title"]': 'beatTitle',
|
||
'[data-role="beat-meta"]': 'beatMeta',
|
||
'[data-action="play"]': 'playButton',
|
||
'[data-action="play-scene"]': 'playSceneButton',
|
||
'[data-action="cinematic"]': 'cinematicButton',
|
||
'[data-action="story-replay"]': 'storyReplayButton',
|
||
'[data-action="corridor"]': 'corridorButton',
|
||
'[data-action="previous-beat"]': 'previousButton',
|
||
'[data-action="next-beat"]': 'nextButton',
|
||
'[data-action="open-source"]': 'openSourceButton',
|
||
};
|
||
// What each control calls, as the panel view wires it.
|
||
const PANEL_EVENTS = {
|
||
playButton: { click: 'play' },
|
||
playSceneButton: { click: 'playScene' },
|
||
cinematicButton: { click: 'toggleCinematic' },
|
||
storyReplayButton: { click: 'replayCinematic' },
|
||
corridorButton: { click: 'focusCorridor' },
|
||
previousButton: { click: 'previousBeat' },
|
||
nextButton: { click: 'nextBeat' },
|
||
openSourceButton: { click: 'openActiveSource' },
|
||
progressInput: {
|
||
input: (controls, value) => controls.previewProgress(Number(value) / 1000),
|
||
change: (controls, value) => controls.commitProgress(Number(value) / 1000, { final: true }),
|
||
},
|
||
splitInput: { input: (controls, value) => controls.setSplit(Number(value) / 100) },
|
||
};
|
||
|
||
/**
|
||
* The event panel as the layer presents it to the panel store, or undefined
|
||
* while it is off. Controls read the latest presentation, and dispatching an
|
||
* event calls the connected controls as the panel view does.
|
||
*/
|
||
function eventPanel() {
|
||
const store = useBhoteKoshiPanelStore(applicationPinia());
|
||
if (!store.panel) return undefined;
|
||
const control = (key) => {
|
||
let typed = null;
|
||
const record = () => store.panel.refs[key];
|
||
return {
|
||
get textContent() { return record().textContent; },
|
||
get hidden() { return record().hidden; },
|
||
get disabled() { return record().disabled; },
|
||
get value() { return typed ?? record().value; },
|
||
set value(value) { typed = value; },
|
||
getAttribute: (name) => record().attributes[name] ?? null,
|
||
dispatch(type) {
|
||
const value = typed ?? record().value;
|
||
typed = null;
|
||
const handler = PANEL_EVENTS[key]?.[type];
|
||
return typeof handler === 'function'
|
||
? handler(store.controls, value)
|
||
: store.controls[handler]?.();
|
||
},
|
||
};
|
||
};
|
||
const named = (name) => ({ dispatch: () => store.controls[name]() });
|
||
return {
|
||
querySelector(selector) {
|
||
if (selector === '.bhote-event-report-list') {
|
||
return {
|
||
children: store.panel.reports.map((_, index) => ({
|
||
dispatch: () => store.controls.openReport(index),
|
||
})),
|
||
};
|
||
}
|
||
if (selector === '[data-action="geolocation-map"]') return named('openGeolocationMap');
|
||
if (selector === '[data-action="close"]') return named('close');
|
||
return control(PANEL_REFS[selector]);
|
||
},
|
||
};
|
||
}
|
||
|
||
class FakeElement {
|
||
constructor(tagName = 'div') {
|
||
this.tagName = tagName;
|
||
this.children = [];
|
||
this.removed = false;
|
||
this._value = '';
|
||
this._textContent = '';
|
||
this._disabled = false;
|
||
this._writeCount = 0;
|
||
this._queryCount = 0;
|
||
this._attributes = new Map();
|
||
this._selectors = new Map();
|
||
this._listeners = new Map();
|
||
}
|
||
|
||
set value(value) {
|
||
if (this._value === value) return;
|
||
this._value = value;
|
||
this._writeCount += 1;
|
||
}
|
||
|
||
get value() { return this._value; }
|
||
|
||
set textContent(value) {
|
||
if (this._textContent === value) return;
|
||
this._textContent = value;
|
||
this._writeCount += 1;
|
||
}
|
||
|
||
get textContent() { return this._textContent; }
|
||
|
||
set disabled(value) {
|
||
if (this._disabled === value) return;
|
||
this._disabled = value;
|
||
this._writeCount += 1;
|
||
}
|
||
|
||
get disabled() { return this._disabled; }
|
||
|
||
setAttribute(name, value) {
|
||
if (this._attributes.get(name) === value) return;
|
||
this._attributes.set(name, value);
|
||
this._writeCount += 1;
|
||
}
|
||
|
||
getAttribute(name) { return this._attributes.get(name) ?? null; }
|
||
addEventListener(type, handler) {
|
||
this._listeners.set(type, handler);
|
||
}
|
||
|
||
removeEventListener(type, handler) {
|
||
if (this._listeners.get(type) === handler) this._listeners.delete(type);
|
||
}
|
||
|
||
dispatch(type, event = { target: this }) {
|
||
return this._listeners.get(type)?.(event);
|
||
}
|
||
|
||
append(...children) {
|
||
this.children.push(...children);
|
||
}
|
||
|
||
appendChild(child) {
|
||
this.children.push(child);
|
||
return child;
|
||
}
|
||
|
||
querySelector(selector) {
|
||
this._queryCount += 1;
|
||
if (!this._selectors.has(selector)) this._selectors.set(selector, new FakeElement());
|
||
return this._selectors.get(selector);
|
||
}
|
||
|
||
remove() {
|
||
this.removed = true;
|
||
}
|
||
|
||
set innerHTML(value) {
|
||
this._innerHTML = value;
|
||
}
|
||
|
||
get innerHTML() {
|
||
return this._innerHTML || '';
|
||
}
|
||
}
|
||
|
||
function installEventDom() {
|
||
const body = new FakeElement('body');
|
||
const removedProperties = [];
|
||
globalThis.document = {
|
||
body,
|
||
createElement: (tagName) => new FakeElement(tagName),
|
||
documentElement: {
|
||
clientWidth: 1000,
|
||
style: {
|
||
setProperty() {},
|
||
removeProperty(name) { removedProperties.push(name); },
|
||
},
|
||
},
|
||
};
|
||
return { body, removedProperties };
|
||
}
|
||
|
||
/**
|
||
* A viewer with fake draw and globe ports bound, under the Cesium camera
|
||
* port over a fake camera. `_test` reads what the event draws: its imagery
|
||
* layers (`imagery`, `removedImagery`), its flood sets (`floodSets`, live
|
||
* or not) and a flood item by id (`flood`); `scene.splitPosition` is the
|
||
* globe's split.
|
||
*/
|
||
function eventViewer(splitPosition = 0.37, ports = {}) {
|
||
const draw = fakeDrawPort();
|
||
const globe = fakeGlobePort();
|
||
globe.imagery.setSplit(splitPosition);
|
||
const canvas = new FakeElement('canvas');
|
||
const cameraLooks = [];
|
||
const cameraTransforms = [];
|
||
const floodSets = () => [...draw.sets.values()].filter(({ spec }) => spec.id.startsWith(`${BHOTE_KOSHI_LAYER_ID}:`));
|
||
const liveFloodSets = () => floodSets().filter((set) => !set.disposed);
|
||
const viewer = {
|
||
scene: {
|
||
get splitPosition() { return globe.imagery.getSplit(); },
|
||
canvas,
|
||
},
|
||
camera: {
|
||
cancelFlight() {},
|
||
lookAt(target, offset) {
|
||
cameraLooks.push({
|
||
target: { x: target.x, y: target.y, z: target.z },
|
||
offset: { heading: offset.heading, pitch: offset.pitch, range: offset.range },
|
||
});
|
||
},
|
||
lookAtTransform(transform) { cameraTransforms.push(transform); },
|
||
},
|
||
_test: {
|
||
draw,
|
||
globe,
|
||
imagery: globe.added,
|
||
get removedImagery() { return globe.added.filter((layer) => layer.removed); },
|
||
floodSets,
|
||
liveFloodSets,
|
||
/** The live flood item with this id, or undefined. */
|
||
flood(id) {
|
||
for (const set of liveFloodSets()) if (set.items.has(id)) return set.items.get(id);
|
||
return undefined;
|
||
},
|
||
/** Reads the flood item with this id as it is drawn now: whether it shows, its positions or position. */
|
||
floodView(id) {
|
||
const view = viewer._test;
|
||
return {
|
||
get show() { return view.floodShows(id); },
|
||
get positions() { return view.flood(id)?.positions; },
|
||
get position() { return view.flood(id)?.pos; },
|
||
};
|
||
},
|
||
/** Whether the flood item with this id is drawn showing. */
|
||
floodShows(id) {
|
||
for (const set of liveFloodSets()) if (set.items.has(id)) return set.items.get(id).show !== false;
|
||
return false;
|
||
},
|
||
canvas,
|
||
cameraLooks,
|
||
cameraTransforms,
|
||
},
|
||
};
|
||
return bindFakeCesiumCamera(viewer, { draw, globe, ...ports });
|
||
}
|
||
|
||
test('public lifecycle restores Nepal scene ownership without forwarding origin to enable', async () => {
|
||
const previous = { document: globalThis.document, window: globalThis.window };
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
try {
|
||
for (const initialMap of ['photoreal', 'esri-imagery']) {
|
||
for (const origin of ['scene', 'local-restore', 'share-restore']) {
|
||
installEventDom();
|
||
const timers = [];
|
||
globalThis.window = {
|
||
setTimeout(handler, delay) { timers.push({ handler, delay }); return timers.length; },
|
||
clearTimeout() {},
|
||
};
|
||
const viewer = eventViewer();
|
||
viewer.camera.flyToBoundingSphere = () => viewer._test.cameraLooks.push('corridor');
|
||
let activeMap = initialMap;
|
||
const mapCalls = [];
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => observations.map(() => ({ height: 800 })),
|
||
mediaLoader: async () => { const error = new Error('No bundled clip'); error.name = 'AbortError'; throw error; },
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => activeMap,
|
||
getSwitchGeneration: () => 1,
|
||
async setStack(id) { mapCalls.push(id); activeMap = id; },
|
||
});
|
||
const manager = new LayerLifecycle(viewer);
|
||
manager.register(layer);
|
||
manager.finalizeRegistrations([{ id: layer.id, disposition: 'enabled-only' }]);
|
||
try {
|
||
const result = await manager.restoreLayerState(layer.id, {
|
||
enabled: true,
|
||
params: { presentation: 'scene-beat', sceneSurface: 'panel-only', progress: 0.34 },
|
||
}, { origin });
|
||
assert.equal(result.succeeded, true);
|
||
assert.equal(layer.getPlaybackState().enabled, true);
|
||
assert.deepEqual(mapCalls, [], `${initialMap}/${origin}: preserve the shot map`);
|
||
assert.equal(activeMap, initialMap);
|
||
const floodSets = viewer._test.liveFloodSets();
|
||
assert.deepEqual(floodSets.map(({ kind }) => kind), ['lines', 'points']);
|
||
assert.ok(floodSets.every(({ spec }) => spec.pickable === false));
|
||
assert.equal(floodSets[1].spec.clampTo, 'both', 'the surge front clamps to the ground');
|
||
assert.ok(floodSets.every(({ items }) => items.size === 0), 'a panel-only shot draws no flood');
|
||
assert.deepEqual(viewer._test.cameraLooks, [], 'enable must not focus the corridor');
|
||
assert.deepEqual(timers, [], 'enable must not schedule independent playback');
|
||
assert.equal(layer.getPlaybackState().playing, false);
|
||
assert.equal(await manager.setEnabled(layer.id, false, { origin: 'user' }), true);
|
||
assert.deepEqual(mapCalls, [], 'disable must not restore a map it never owned');
|
||
} finally {
|
||
await manager.destroyLayer(layer.id);
|
||
}
|
||
}
|
||
}
|
||
} finally {
|
||
Object.assign(globalThis, previous);
|
||
}
|
||
});
|
||
|
||
test('trimmed scene media holds through provider startup, playback and fade, then releases the camera', async () => {
|
||
const previous = { document: globalThis.document, window: globalThis.window };
|
||
installEventDom();
|
||
const timers = new Map();
|
||
let nextId = 0;
|
||
globalThis.window = {
|
||
setTimeout(fn, delay) { const id = ++nextId; timers.set(id, { fn, delay }); return id; },
|
||
clearTimeout(id) { timers.delete(id); },
|
||
};
|
||
let phase = 'starting';
|
||
let hidden = 0;
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => observations.map(() => ({ height: 800 })),
|
||
mediaLoader: async () => { const error = new Error('No bundled clip'); error.name = 'AbortError'; throw error; },
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
embeddedMediaFactory: () => ({ warm: () => true, show: () => true, play() {}, pause() {},
|
||
getPlaybackState: () => ({ phase }), hide() { hidden++; }, destroy() {} }),
|
||
});
|
||
const fire = (delay) => {
|
||
const entry = [...timers].find(([, value]) => value.delay === delay);
|
||
assert.ok(entry, `expected ${delay}ms owned timer`);
|
||
timers.delete(entry[0]); entry[1].fn();
|
||
};
|
||
try {
|
||
const viewer = eventViewer();
|
||
await layer.init(viewer);
|
||
layer.setSceneMediaPlayback({ sceneId: 'scene', shotId: 'shot', token: { cancelled: false } });
|
||
layer.setParams({ presentation: 'scene-beat', sceneSurface: 'evidence-beat', beatId: 'mailung-bazzar',
|
||
sceneContext: { sceneId: 'scene', shotId: 'shot', holdSec: 7.65 },
|
||
sceneControls: { evidenceMediaAutoplay: true, cameraSettled: true, mediaExitDurationSec: 0.65 } }, { origin: 'scene' });
|
||
await layer.enable(viewer, { origin: 'scene' });
|
||
assert.equal(layer.getSceneShotMediaHold('mailung-bazzar').pending, true);
|
||
assert.equal(layer.getSceneShotMediaHold('different-beat'), null);
|
||
fire(100);
|
||
assert.equal(layer.getSceneShotMediaHold('mailung-bazzar').pending, true, 'startup is not treated as playback');
|
||
phase = 'playing'; fire(100);
|
||
assert.equal(layer.getSceneShotMediaHold('mailung-bazzar').pending, true);
|
||
const hiddenBeforeEnd = hidden;
|
||
phase = 'completed'; fire(100);
|
||
assert.ok(hidden > hiddenBeforeEnd);
|
||
assert.equal(layer.getSceneShotMediaHold('mailung-bazzar').pending, true, 'the fade still owns the hold');
|
||
fire(650);
|
||
assert.equal(layer.getSceneShotMediaHold('mailung-bazzar').pending, false);
|
||
await layer.disable();
|
||
assert.equal(layer.getSceneShotMediaHold('mailung-bazzar'), null);
|
||
} finally {
|
||
await layer.destroy();
|
||
globalThis.document = previous.document; globalThis.window = previous.window;
|
||
}
|
||
});
|
||
|
||
test('scene media plays again when a run goes on from a seek inside its hold, unless the seek was past the clip', async () => {
|
||
const previous = { document: globalThis.document, window: globalThis.window,
|
||
requestAnimationFrame: globalThis.requestAnimationFrame,
|
||
cancelAnimationFrame: globalThis.cancelAnimationFrame };
|
||
installEventDom();
|
||
globalThis.window = { setTimeout: () => 1, clearTimeout() {} };
|
||
// The reveal's frames are not driven here; only that it starts.
|
||
let frames = 0;
|
||
globalThis.requestAnimationFrame = () => ++frames;
|
||
globalThis.cancelAnimationFrame = () => {};
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
let plays = 0;
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => observations.map(() => ({ height: 800 })),
|
||
mediaLoader: async () => { throw Object.assign(new Error('No bundled clip'), { name: 'AbortError' }); },
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
embeddedMediaFactory: () => ({ warm: () => true, show: () => true, play() { plays++; }, pause() {},
|
||
getPlaybackState: () => ({ phase: 'playing' }), hide() {}, destroy() {} }),
|
||
});
|
||
const controls = { evidenceMediaAutoplay: true, mediaPlaybackHoldSec: 4, cameraSettled: true,
|
||
deferEvidenceUntilCameraSettled: true };
|
||
const params = (sceneControls) => ({ presentation: 'scene-beat', sceneSurface: 'evidence-beat',
|
||
beatId: 'mailung-bazzar', sceneContext: { sceneId: 'scene', shotId: 'shot', holdSec: 7.65 }, sceneControls });
|
||
const seek = (holdElapsedSec) => ({ ...controls,
|
||
timelineSeek: { cameraProgress: 1, holdElapsedSec, holdDurationSec: 7.65, flightDurationSec: 2 } });
|
||
try {
|
||
const viewer = eventViewer();
|
||
await layer.init(viewer);
|
||
layer.setSceneMediaPlayback({ sceneId: 'scene', shotId: 'shot', token: { cancelled: false } });
|
||
// A seek 1 s into the hold shows that moment and plays nothing.
|
||
layer.setParams(params(seek(1)), { origin: 'scene' });
|
||
await layer.enable(viewer, { origin: 'scene' });
|
||
assert.equal(plays, 0);
|
||
assert.equal(layer.getSceneShotMediaHold('mailung-bazzar'), null);
|
||
// The run goes on from there: the clip starts again and holds the shot.
|
||
const framesBefore = frames;
|
||
layer.setParams(params(controls), { origin: 'scene' });
|
||
assert.ok(frames > framesBefore, 'the reveal runs again');
|
||
assert.ok(plays > 0, 'the clip plays');
|
||
assert.equal(layer.getSceneShotMediaHold('mailung-bazzar').pending, true);
|
||
// A seek after the clip goes on without it.
|
||
layer.setParams(params(seek(6)), { origin: 'scene' });
|
||
const before = plays;
|
||
layer.setParams(params(controls), { origin: 'scene' });
|
||
assert.equal(plays, before, 'the clip already played');
|
||
assert.equal(layer.getSceneShotMediaHold('mailung-bazzar').pending, false);
|
||
} finally { await layer.destroy(); Object.assign(globalThis, previous); }
|
||
});
|
||
|
||
test('a run going on from a seek in Timure’s hold resumes its evidence sequence from that point', async () => {
|
||
const keys = ['document', 'window', 'performance', 'requestAnimationFrame', 'cancelAnimationFrame'];
|
||
const previous = Object.fromEntries(keys.map((key) => [key, globalThis[key]]));
|
||
installEventDom();
|
||
let now = 1000;
|
||
let nextFrame = 0;
|
||
const frames = new Map();
|
||
globalThis.window = { setTimeout: () => 1, clearTimeout() {} };
|
||
globalThis.performance = { now: () => now };
|
||
globalThis.requestAnimationFrame = (callback) => { frames.set(++nextFrame, callback); return nextFrame; };
|
||
globalThis.cancelAnimationFrame = (id) => frames.delete(id);
|
||
const frame = (ms) => {
|
||
now += ms;
|
||
const callback = frames.get(nextFrame);
|
||
frames.delete(nextFrame);
|
||
callback?.(now);
|
||
};
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async () => null,
|
||
mediaLoader: async () => { throw Object.assign(new Error('fixture'), { name: 'AbortError' }); },
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
embeddedMediaFactory: () => ({ warm: () => true, show: () => true, play() {}, pause() {},
|
||
getPlaybackState: () => ({ phase: 'completed' }), hide() {}, destroy() {} }),
|
||
});
|
||
const recipe = getSceneAppendRecipeById('bhote-koshi-nepal-evidence-pack');
|
||
const controls = { ...recipe.runtimeControlsByBeat['timure-cluster'], cameraSettled: true };
|
||
assert.equal(controls.evidenceSequence, true);
|
||
assert.equal(controls.evidencePathDuringCamera, true);
|
||
const params = (sceneControls) => ({ presentation: 'scene-beat', sceneSurface: 'evidence-beat',
|
||
beatId: 'timure-cluster', sceneControls });
|
||
// The sequence waits out the 6 s clip and its 0.65 s exit, then runs 12 s:
|
||
// 8 s into the hold it is 1.35 s along.
|
||
const seek = { ...controls,
|
||
timelineSeek: { cameraProgress: 1, holdElapsedSec: 8, holdDurationSec: 12, flightDurationSec: 2 } };
|
||
const at = (holdElapsedSec) => {
|
||
layer.setParams(params({ ...seek, timelineSeek: { ...seek.timelineSeek, holdElapsedSec } }),
|
||
{ origin: 'scene' });
|
||
return layer.getPlaybackState().progress;
|
||
};
|
||
try {
|
||
const viewer = eventViewer();
|
||
await layer.init(viewer);
|
||
layer.setParams(params(seek), { origin: 'scene' });
|
||
await layer.enable(viewer, { origin: 'scene' });
|
||
// Where the sequence starts and ends, and where the seek puts it.
|
||
const start = at(0);
|
||
const end = at(30);
|
||
const atSeek = at(8);
|
||
assert.ok(start < atSeek && atSeek < end, `the seek shows the sequence partway (${start} < ${atSeek} < ${end})`);
|
||
// The run goes on: the sequence carries on from that point, not 0 or its end.
|
||
layer.setParams(params(controls), { origin: 'scene' });
|
||
assert.ok(Math.abs(layer.getPlaybackState().progress - atSeek) < 1e-9, 'it starts where the seek stood');
|
||
frame(1000);
|
||
const later = layer.getPlaybackState().progress;
|
||
assert.ok(atSeek < later && later < end, `and moves on from there (${atSeek} < ${later} < ${end})`);
|
||
} finally { await layer.destroy(); Object.assign(globalThis, previous); }
|
||
});
|
||
|
||
test('a run going on from a seek in Gyirong’s hold plays its restarted clip out before the next shot', async () => {
|
||
const previous = { document: globalThis.document, window: globalThis.window,
|
||
requestAnimationFrame: globalThis.requestAnimationFrame, cancelAnimationFrame: globalThis.cancelAnimationFrame };
|
||
installEventDom();
|
||
globalThis.window = { setTimeout: () => 1, clearTimeout() {} };
|
||
globalThis.requestAnimationFrame = () => 1;
|
||
globalThis.cancelAnimationFrame = () => {};
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
let plays = 0;
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => observations.map(() => ({ height: 800 })),
|
||
mediaLoader: async () => { throw Object.assign(new Error('No bundled clip'), { name: 'AbortError' }); },
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
embeddedMediaFactory: () => ({ warm: () => true, show: () => true, play() { plays++; }, pause() {},
|
||
getPlaybackState: () => ({ phase: 'playing' }), hide() {}, destroy() {} }),
|
||
});
|
||
const recipe = getSceneAppendRecipeById('bhote-koshi-nepal-evidence-pack');
|
||
const controls = { ...recipe.runtimeControlsByBeat['gyirong-border-gate'], cameraSettled: true };
|
||
const params = (sceneControls) => ({ presentation: 'scene-beat', sceneSurface: 'evidence-beat',
|
||
beatId: 'gyirong-border-gate', sceneContext: { sceneId: 'scene', shotId: 'shot', holdSec: 9.15 }, sceneControls });
|
||
const token = { cancelled: false, signal: new AbortController().signal };
|
||
const hold = async (resume) => {
|
||
const waits = [];
|
||
await SceneDirector.prototype._holdShot.call({
|
||
_layerStatesForShot: () => ({ [layer.id]: { enabled: true, params: params(controls) } }),
|
||
dataManager: { layers: new Map([[layer.id, { module: layer }]]) },
|
||
_effectiveShotHoldSec: () => 9.15,
|
||
_sleep: async (ms) => waits.push(ms),
|
||
stopScene: () => assert.fail('no timeout'),
|
||
}, { id: 'scene' }, { id: 'shot' }, token, resume);
|
||
return waits;
|
||
};
|
||
try {
|
||
const viewer = eventViewer();
|
||
await layer.init(viewer);
|
||
layer.setSceneMediaPlayback({ sceneId: 'scene', shotId: 'shot', token });
|
||
// 5 s into the 9.15 s hold, inside the 6 s clip, which has no media gate.
|
||
const resume = { holdElapsedSec: 5, holdDurationSec: 9.15 };
|
||
layer.setParams(params({ ...controls, timelineSeek: { cameraProgress: 1, ...resume, flightDurationSec: 2 } }),
|
||
{ origin: 'scene' });
|
||
await layer.enable(viewer, { origin: 'scene' });
|
||
assert.equal(layer.getSceneShotMediaHold('gyirong-border-gate'), null, 'the clip is not trimmed');
|
||
layer.setParams(params(controls), { origin: 'scene' });
|
||
assert.ok(plays > 0, 'the clip starts again');
|
||
assert.equal(layer.sceneShotRestartsMedia('gyirong-border-gate'), true);
|
||
assert.deepEqual(await hold(resume), [9150], 'the hold plays out as from its start, not 4.15 s');
|
||
// A seek after the clip: only the rest of the hold.
|
||
const late = { holdElapsedSec: 8, holdDurationSec: 9.15 };
|
||
layer.setParams(params({ ...controls, timelineSeek: { cameraProgress: 1, ...late, flightDurationSec: 2 } }),
|
||
{ origin: 'scene' });
|
||
layer.setParams(params(controls), { origin: 'scene' });
|
||
assert.equal(layer.sceneShotRestartsMedia('gyirong-border-gate'), false);
|
||
const [rest] = await hold(late);
|
||
assert.ok(Math.abs(rest - 1150) < 1e-6, String(rest));
|
||
} finally { await layer.destroy(); Object.assign(globalThis, previous); }
|
||
});
|
||
|
||
test('Pinokio source-card fallback selects authored Director dwell, not an impossible player hold', async () => {
|
||
const previous = { document: globalThis.document, window: globalThis.window };
|
||
installEventDom();
|
||
globalThis.window = { setTimeout: () => 1, clearTimeout() {} };
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async url => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => observations.map(() => ({ height: 800 })),
|
||
mediaLoader: async () => { throw Object.assign(new Error('No bundled clip'), { name: 'AbortError' }); },
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
embeddedMediaFactory: options => createBhoteKoshiEmbeddedMedia({ ...options,
|
||
globalRef: { navigator: { userAgent: 'Chrome Pinokio/8.0.40' } },
|
||
documentRef: { createElement() { assert.fail('unsupported host must allocate no provider DOM'); } },
|
||
}),
|
||
});
|
||
const token = { cancelled: false, signal: new AbortController().signal };
|
||
const params = { presentation: 'scene-beat', sceneSurface: 'evidence-beat', beatId: 'mailung-bazzar',
|
||
sceneContext: { sceneId: 'scene', shotId: 'shot', holdSec: 7.65 },
|
||
sceneControls: { evidenceMediaAutoplay: true, mediaPlaybackHoldSec: 7, cameraSettled: true } };
|
||
try {
|
||
const viewer = eventViewer();
|
||
await layer.init(viewer);
|
||
layer.setSceneMediaPlayback({ sceneId: 'scene', shotId: 'shot', token });
|
||
layer.setParams(params, { origin: 'scene' });
|
||
await layer.enable(viewer, { origin: 'scene' });
|
||
assert.equal(layer.getSceneShotMediaHold('mailung-bazzar'), null);
|
||
const waits = [];
|
||
await SceneDirector.prototype._holdShot.call({
|
||
_layerStatesForShot: () => ({ [layer.id]: { enabled: true, params } }),
|
||
dataManager: { layers: new Map([[layer.id, { module: layer }]]) },
|
||
_effectiveShotHoldSec: () => 7.65,
|
||
_sleep: async ms => waits.push(ms),
|
||
stopScene: () => assert.fail('a source card must not time out'),
|
||
}, { id: 'scene' }, { id: 'shot' }, token);
|
||
assert.deepEqual(waits, [7650], 'use the authored dwell instead of completing instantly or polling 20 seconds');
|
||
event.evidenceSpine.find(item => item.id === 'mailung-bazzar').media.videoPath = 'fixture-approved.mp4';
|
||
assert.equal(layer.getSceneShotMediaHold('mailung-bazzar').pending, true,
|
||
'an approved local clip remains a real playback owner even with the provider suppressed');
|
||
} finally { await layer.destroy(); Object.assign(globalThis, previous); }
|
||
});
|
||
|
||
test('saved autoplay controls cannot authorize media; live shot ownership is cancellable and never serialized', async () => {
|
||
const previous = { document: globalThis.document, window: globalThis.window };
|
||
installEventDom();
|
||
const timers = new Map(); let timerId = 0;
|
||
globalThis.window = { setTimeout: fn => { timers.set(++timerId, fn); return timerId; }, clearTimeout: id => timers.delete(id) };
|
||
const calls = [];
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async url => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => observations.map(() => ({ height: 800 })),
|
||
mediaLoader: async () => { throw Object.assign(new Error('No bundled clip'), { name: 'AbortError' }); },
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
embeddedMediaFactory: () => ({ supportsPlayback: true, warm: () => true,
|
||
show: options => { calls.push(options.autoplay); return true; },
|
||
getPlaybackState: () => null, play() {}, pause() {}, hide() {}, destroy() {} }),
|
||
});
|
||
const params = { presentation: 'scene-beat', sceneSurface: 'evidence-beat', beatId: 'mailung-bazzar',
|
||
sceneContext: { sceneId: 'scene', shotId: 'shot', holdSec: 7.65 },
|
||
sceneControls: { evidenceMediaAutoplay: true, cameraSettled: true, mediaPlaybackHoldSec: 7 } };
|
||
try {
|
||
const viewer = eventViewer(); await layer.init(viewer);
|
||
layer.setParams(params, { origin: 'local-restore' }); await layer.enable(viewer);
|
||
assert.ok(calls.length); assert.ok(calls.every(value => value === false));
|
||
assert.equal(layer.getSceneShotMediaHold('mailung-bazzar'), null);
|
||
const saved = layer.getParams();
|
||
const abort = new AbortController();
|
||
layer.setSceneMediaPlayback({ sceneId: 'scene', shotId: 'shot', token: { cancelled: false, signal: abort.signal } });
|
||
layer.setParams(params, { origin: 'scene' });
|
||
assert.equal(calls.at(-1), true);
|
||
assert.equal(layer.getSceneShotMediaHold('mailung-bazzar').pending, true,
|
||
'a temporarily null supported-provider state is still startup, not unsupported');
|
||
assert.deepEqual(layer.getParams(), saved, 'live playback authority must not enter saved params');
|
||
const late = [...timers.values()];
|
||
abort.abort(); late.forEach(fn => fn());
|
||
assert.equal(layer.getSceneShotMediaHold('mailung-bazzar'), null);
|
||
layer.setParams(params, { origin: 'local-restore' });
|
||
assert.equal(calls.at(-1), false, 'late callbacks and restored flags cannot restart revoked playback');
|
||
layer.setSceneMediaPlayback({ sceneId: 'scene', shotId: 'different-shot', token: { cancelled: false } });
|
||
layer.setParams(params, { origin: 'scene' });
|
||
assert.equal(calls.at(-1), false, 'a different shot cannot borrow this playback owner');
|
||
} finally { await layer.destroy(); Object.assign(globalThis, previous); }
|
||
});
|
||
|
||
test('Bhote Koshi timeline helpers clamp untrusted UI values', () => {
|
||
assert.equal(clampUnit(-1), 0);
|
||
assert.equal(clampUnit(0.42), 0.42);
|
||
assert.equal(clampUnit(3), 1);
|
||
assert.equal(elapsedLabel(0.5, 4170), '34:45');
|
||
assert.equal(elapsedLabel(1, 4170), '69:30');
|
||
});
|
||
|
||
test('Bhote Koshi flood reveal is monotonic and bounded', () => {
|
||
assert.equal(visibleSegmentCount(0, 144), 0);
|
||
assert.equal(visibleSegmentCount(Number.NaN, 144), 0);
|
||
assert.equal(visibleSegmentCount(0.001, 144), 1);
|
||
assert.equal(visibleSegmentCount(0.5, 144), 72);
|
||
assert.equal(visibleSegmentCount(2, 144), 144);
|
||
});
|
||
|
||
test('Bhote Koshi flood corridor grows continuously to the animated surge head', () => {
|
||
const terrainPositions = Array.from(
|
||
{ length: 11 },
|
||
(_, index) => new Cesium.Cartesian3(index, 0, 0),
|
||
);
|
||
const cache = { visibleCount: -1, positions: [] };
|
||
|
||
assert.equal(updateCorridorPositionCache(0.201, terrainPositions, cache), true);
|
||
const firstPositions = cache.positions;
|
||
assert.equal(cache.visibleCount, 3);
|
||
assert.equal(firstPositions.length, 4);
|
||
assert.ok(Math.abs(cache.headPosition.x - 2.01) < 1e-9);
|
||
assert.equal(firstPositions.at(-1).x, cache.headPosition.x);
|
||
|
||
assert.equal(updateCorridorPositionCache(0.299, terrainPositions, cache), true);
|
||
assert.notEqual(cache.positions, firstPositions, 'the trail advances within the segment');
|
||
assert.ok(Math.abs(cache.headPosition.x - 2.99) < 1e-9);
|
||
assert.equal(cache.positions.at(-1).x, cache.headPosition.x);
|
||
|
||
const repeatedPositions = cache.positions;
|
||
assert.equal(updateCorridorPositionCache(0.299, terrainPositions, cache), false);
|
||
assert.equal(cache.positions, repeatedPositions, 'an unchanged frame reuses its positions');
|
||
|
||
assert.equal(updateCorridorPositionCache(0.301, terrainPositions, cache), true);
|
||
assert.equal(cache.visibleCount, 4);
|
||
assert.equal(cache.positions.length, 5);
|
||
assert.ok(Math.abs(cache.headPosition.x - 3.01) < 1e-9);
|
||
assert.equal(cache.positions.at(-1).x, cache.headPosition.x);
|
||
});
|
||
|
||
test('Bhote Koshi story clock holds the flood for the cause beats then completes the corridor', () => {
|
||
assert.equal(floodProgressForStoryProgress(0), 0);
|
||
assert.equal(floodProgressForStoryProgress(0.11), 0);
|
||
assert.equal(floodProgressForStoryProgress(0.22), 0);
|
||
assert.ok(floodProgressForStoryProgress(0.5) > 0.4);
|
||
assert.equal(floodProgressForStoryProgress(0.84), 1);
|
||
assert.equal(floodProgressForStoryProgress(1), 1);
|
||
});
|
||
|
||
test('Bhote Koshi camera holds its evidence beat, then travels by the next activation', () => {
|
||
assert.equal(interpolateHeadingDegrees(350, 10, 0.5), 0);
|
||
const reusableTarget = { x: 99, y: 99, z: 99 };
|
||
const result = { target: reusableTarget };
|
||
const keyframes = [
|
||
{
|
||
id: 'cause',
|
||
progress: 0,
|
||
target: { x: 0, y: 0, z: 0 },
|
||
headingDeg: 350,
|
||
pitchDeg: -50,
|
||
rangeM: 1000,
|
||
},
|
||
{
|
||
id: 'border',
|
||
progress: 1,
|
||
target: { x: 10, y: 20, z: 30 },
|
||
headingDeg: 10,
|
||
pitchDeg: -30,
|
||
rangeM: 3000,
|
||
},
|
||
];
|
||
const held = sampleCinematicPose(0.5, keyframes, result);
|
||
assert.deepEqual(held.target, { x: 0, y: 0, z: 0 });
|
||
assert.equal(held.headingDeg, 350);
|
||
assert.equal(held.pitchDeg, -50);
|
||
assert.equal(held.rangeM, 1000);
|
||
|
||
const sampled = sampleCinematicPose(0.81, keyframes, result);
|
||
assert.equal(sampled, result);
|
||
assert.equal(sampled.target, reusableTarget);
|
||
assert.ok(Math.abs(sampled.target.x - 5) < 1e-9);
|
||
assert.ok(Math.abs(sampled.target.y - 10) < 1e-9);
|
||
assert.ok(Math.abs(sampled.target.z - 15) < 1e-9);
|
||
assert.equal(sampled.headingDeg, 0);
|
||
assert.equal(sampled.pitchDeg, -40);
|
||
assert.equal(sampled.rangeM, 2000);
|
||
});
|
||
|
||
test('Bhote Koshi card summaries wrap on words instead of clipping mid-sentence', () => {
|
||
assert.deepEqual(
|
||
evidenceSummaryLines('Five geolocated public viewpoints document the flood passage.', 34, 2),
|
||
['Five geolocated public viewpoints', 'document the flood passage.'],
|
||
);
|
||
assert.deepEqual(evidenceSummaryLines('one two three four five', 9, 1), ['one two…']);
|
||
});
|
||
|
||
test('Bhote Koshi evidence timeline is ordered by phase and corridor chainage with one active beat', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const timeline = buildEvidenceTimeline(event.evidenceSpine, event.reconstruction.corridor);
|
||
assert.deepEqual(
|
||
timeline.map((beat) => beat.observation.id),
|
||
[
|
||
'immediate-collapse-viewpoint',
|
||
'debris-dammed-lake',
|
||
'second-landslide',
|
||
'gyirong-border-gate',
|
||
'timure-cluster',
|
||
'syabru-besi',
|
||
'dhunche',
|
||
'mailung-upper-trishuli',
|
||
'mailung-bazzar',
|
||
'dandagaun',
|
||
'dandagaun-viewpoint',
|
||
'betrawati-bazaar',
|
||
'bhainse',
|
||
'bidur-trishuli-bridge',
|
||
'devighat-taadi-khola-bridge',
|
||
'charaudi',
|
||
],
|
||
);
|
||
assert.equal(timeline[0].activationProgress, 0);
|
||
assert.equal(timeline[1].activationProgress, 0.065);
|
||
assert.equal(timeline[2].activationProgress, 0.13);
|
||
assert.ok(timeline[3].activationProgress > timeline[2].activationProgress);
|
||
assert.ok(timeline[4].activationProgress > timeline[3].activationProgress);
|
||
assert.equal(timeline[5].activationProgress, 0.325);
|
||
for (let index = 0; index < timeline.length; index += 1) {
|
||
assert.equal(activeEvidenceIndex(timeline[index].activationProgress, timeline), index);
|
||
const midpoint = (
|
||
timeline[index].activationProgress + Math.min(1, timeline[index].deactivationProgress)
|
||
) / 2;
|
||
assert.equal(activeEvidenceIndex(midpoint, timeline), index);
|
||
const dwellSeconds = (
|
||
Math.min(1, timeline[index].deactivationProgress) - timeline[index].activationProgress
|
||
) * 90;
|
||
assert.ok(dwellSeconds >= 2, `${timeline[index].observation.id} dwell is too short`);
|
||
}
|
||
|
||
const anchors = timeline.map((_, index) => ({ x: index, y: index + 1, z: index + 2 }));
|
||
const cameraFrames = buildCinematicKeyframes(timeline, anchors);
|
||
assert.deepEqual(cameraFrames.slice(0, 16).map((frame) => frame.id), timeline.map((beat) => beat.observation.id));
|
||
assert.deepEqual(cameraFrames.slice(0, 16).map((frame) => frame.progress), timeline.map((beat) => beat.activationProgress));
|
||
assert.equal(cameraFrames.at(-1).id, 'charaudi');
|
||
assert.equal(cameraFrames.at(-1).progress, 1);
|
||
});
|
||
|
||
test('Bhote Koshi scene beats resolve stable ids inside their reveal windows', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const timeline = buildEvidenceTimeline(event.evidenceSpine, event.reconstruction.corridor);
|
||
for (const beat of timeline) {
|
||
const progress = evidenceBeatProgress(beat.observation.id, timeline, 0.36);
|
||
assert.ok(progress > beat.activationProgress || beat.deactivationProgress <= beat.activationProgress);
|
||
assert.ok(progress < Math.min(1.000001, beat.deactivationProgress));
|
||
assert.equal(activeEvidenceIndex(progress, timeline), timeline.indexOf(beat));
|
||
}
|
||
assert.equal(evidenceBeatProgress('missing-beat', timeline), null);
|
||
});
|
||
|
||
test('Bhote Koshi scene shots continue the standalone evidence clock from Border Gate onward', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const timeline = buildEvidenceTimeline(event.evidenceSpine, event.reconstruction.corridor);
|
||
const border = evidenceSequenceWindow('gyirong-border-gate', timeline);
|
||
assert.deepEqual(border, {
|
||
startProgress: timeline[3].activationProgress,
|
||
targetProgress: timeline[3].deactivationProgress,
|
||
});
|
||
|
||
for (const beatId of [
|
||
'timure-cluster',
|
||
'syabru-besi',
|
||
'bidur-trishuli-bridge',
|
||
]) {
|
||
const beat = timeline.find(({ observation }) => observation.id === beatId);
|
||
const window = evidenceSequenceWindow(beatId, timeline);
|
||
assert.equal(window.startProgress, beat.activationProgress);
|
||
assert.equal(window.targetProgress, Math.min(1, beat.deactivationProgress));
|
||
assert.ok(window.targetProgress > window.startProgress);
|
||
}
|
||
assert.equal(evidenceSequenceWindow('missing-beat', timeline), null);
|
||
});
|
||
|
||
test('Bhote Koshi evidence presentation reveals dot, leader, and card then tears down in reverse', () => {
|
||
const beat = { activationProgress: 0.2, deactivationProgress: 0.4 };
|
||
assert.deepEqual(evidenceBeatPresentation(0.2, beat), {
|
||
alpha: 0,
|
||
scale: 0.96,
|
||
leaderProgress: 0,
|
||
contentAlpha: 0,
|
||
localProgress: 0,
|
||
});
|
||
const revealed = evidenceBeatPresentation(0.2075, beat);
|
||
assert.equal(revealed.alpha, 1);
|
||
assert.equal(revealed.leaderProgress, 1);
|
||
assert.ok(revealed.contentAlpha > 0 && revealed.contentAlpha < 1);
|
||
assert.ok(revealed.scale > 0.96 && revealed.scale < 1);
|
||
const held = evidenceBeatPresentation(0.3, beat);
|
||
assert.equal(held.alpha, 1);
|
||
assert.equal(held.contentAlpha, 1);
|
||
assert.equal(held.scale, 1);
|
||
const receding = evidenceBeatPresentation(0.35, beat);
|
||
assert.equal(receding.alpha, 1, 'the terrain dot remains after card recession starts');
|
||
assert.ok(receding.contentAlpha < receding.leaderProgress);
|
||
assert.ok(receding.scale < held.scale);
|
||
const late = evidenceBeatPresentation(0.375, beat);
|
||
assert.equal(late.contentAlpha, 0, 'card content clears first');
|
||
assert.ok(late.leaderProgress > 0 && late.leaderProgress < late.alpha);
|
||
assert.equal(evidenceBeatPresentation(0.4, beat).alpha, 0);
|
||
});
|
||
|
||
test('Bhote Koshi evidence cards freeze useful landscape, portrait, and link-only footprints', () => {
|
||
assert.equal(evidenceCardLayout({
|
||
media: { posterUrl: 'poster.jpg', width: 1920, height: 1080 },
|
||
}).kind, 'landscape');
|
||
assert.deepEqual(
|
||
{
|
||
kind: evidenceCardLayout({
|
||
media: { videoPath: 'portrait.mp4', width: 240, height: 422 },
|
||
}).kind,
|
||
width: evidenceCardLayout({
|
||
media: { videoPath: 'portrait.mp4', width: 240, height: 422 },
|
||
}).thumbnailWidth,
|
||
height: evidenceCardLayout({
|
||
media: { videoPath: 'portrait.mp4', width: 240, height: 422 },
|
||
}).thumbnailHeight,
|
||
},
|
||
{ kind: 'portrait', width: 168, height: 260 },
|
||
);
|
||
assert.equal(evidenceCardLayout({ media: { posterUrl: null } }).kind, 'link');
|
||
});
|
||
|
||
test('Bhote Koshi gives YouTube and Facebook players priority over local review clips', () => {
|
||
assert.equal(usesProviderEmbeddedEvidence({
|
||
media: {
|
||
sourceUrl: 'https://www.youtube.com/watch?v=DbqRexFxv3k',
|
||
videoPath: 'evidence-01.mp4',
|
||
},
|
||
}), true);
|
||
assert.equal(usesProviderEmbeddedEvidence({
|
||
media: {
|
||
sourceUrl: 'https://www.facebook.com/reel/1571491657757829',
|
||
videoPath: 'evidence-15.mp4',
|
||
},
|
||
}), true);
|
||
assert.equal(usesProviderEmbeddedEvidence({
|
||
media: {
|
||
sourceUrl: 'https://example.com/evidence',
|
||
videoPath: 'evidence-01.mp4',
|
||
},
|
||
}), false);
|
||
});
|
||
|
||
test('Bhote Koshi beat navigation is deterministic in both directions and clamps at its ends', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const timeline = buildEvidenceTimeline(event.evidenceSpine, event.reconstruction.corridor);
|
||
assert.equal(adjacentEvidenceIndex(0, timeline, -1), 0);
|
||
assert.equal(adjacentEvidenceIndex(0, timeline, 1), 1);
|
||
assert.equal(adjacentEvidenceIndex(timeline[3].activationProgress, timeline, -1), 2);
|
||
assert.equal(adjacentEvidenceIndex(timeline[3].activationProgress, timeline, 1), 4);
|
||
assert.equal(adjacentEvidenceIndex(1, timeline, 1), 15);
|
||
assert.equal(adjacentEvidenceIndex(0.5, [], 1), -1);
|
||
});
|
||
|
||
test('Bhote Koshi evidence fallback stays media-first and source-linked without card copy overload', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const timure = event.evidenceSpine.find((observation) => observation.id === 'timure-cluster');
|
||
const originalDocument = globalThis.document;
|
||
const contexts = [];
|
||
globalThis.document = {
|
||
createElement() {
|
||
const text = [];
|
||
const context = {
|
||
text,
|
||
beginPath() {},
|
||
clearRect() {},
|
||
moveTo() {},
|
||
lineTo() {},
|
||
stroke() {},
|
||
fillRect() {},
|
||
fillText(value) { text.push(String(value)); },
|
||
drawImage() { throw new Error('fixture poster decode failure'); },
|
||
};
|
||
contexts.push(context);
|
||
return { width: 0, height: 0, getContext: () => context };
|
||
},
|
||
};
|
||
|
||
try {
|
||
const missingPosterFrame = createEvidenceFrame(timure);
|
||
const failedPosterFrame = createEvidenceFrame(timure, { width: 640, height: 400 });
|
||
assert.ok(missingPosterFrame);
|
||
assert.ok(failedPosterFrame);
|
||
for (const context of contexts) {
|
||
assert.ok(context.text.includes('NO PREVIEW'));
|
||
assert.ok(context.text.includes('TIMURE'));
|
||
assert.ok(context.text.includes('YOUTUBE SOURCE / OPEN'));
|
||
assert.doesNotMatch(context.text.join(' '), /CAPTURE TIME|GEOLOCATED|public viewpoints/);
|
||
}
|
||
assert.match(timure.media.sourceUrl, /^https:\/\//);
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
}
|
||
});
|
||
|
||
test('Bhote Koshi evidence compositor contains portrait video from its decoded dimensions', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const observation = event.evidenceSpine[0];
|
||
const drawCalls = [];
|
||
const context = {
|
||
beginPath() {},
|
||
clearRect() {},
|
||
moveTo() {},
|
||
lineTo() {},
|
||
stroke() {},
|
||
fillRect() {},
|
||
fillText() {},
|
||
drawImage(...args) { drawCalls.push(args); },
|
||
};
|
||
const layout = evidenceCardLayout(observation);
|
||
const canvas = {
|
||
width: layout.canvasWidth,
|
||
height: layout.canvasHeight,
|
||
_bhoteEvidenceLayout: layout,
|
||
getContext: () => context,
|
||
};
|
||
const video = { videoWidth: 240, videoHeight: 422, width: 0, height: 0 };
|
||
|
||
assert.equal(updateEvidenceFrame(canvas, observation, video, { videoActive: true }), true);
|
||
assert.equal(drawCalls.length, 1);
|
||
const [, destX, destY, destWidth, destHeight] = drawCalls[0];
|
||
assert.ok(destX > 0, 'portrait video keeps narrow side gutters instead of being cropped');
|
||
assert.equal(destY, 0);
|
||
assert.ok(destWidth < layout.canvasWidth);
|
||
assert.equal(destHeight, layout.mediaHeight);
|
||
assert.equal(context.textAlign, 'left', 'repeat paints cannot inherit the outside badge alignment');
|
||
assert.equal(updateEvidenceFrame(canvas, observation, video, { videoActive: true }), true);
|
||
assert.equal(context.textAlign, 'left');
|
||
});
|
||
|
||
test('Bhote Koshi failed direct enable restores the prior map and shared split', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const mapCalls = [];
|
||
const overlayCalls = [];
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
let activeMap = 'photoreal';
|
||
let generation = 7;
|
||
const viewer = {
|
||
scene: { splitPosition: 0.37 },
|
||
};
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async () => { throw new Error('fixture image failure'); },
|
||
overlayHost: {
|
||
setEntries() {},
|
||
setVisible(id, visible) { overlayCalls.push(['visible', id, visible]); },
|
||
clearSource(id) { overlayCalls.push(['clear', id]); },
|
||
},
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => activeMap,
|
||
getSwitchGeneration: () => generation,
|
||
async setStack(id) {
|
||
activeMap = id;
|
||
generation += 1;
|
||
mapCalls.push(id);
|
||
},
|
||
});
|
||
globalThis.document = { documentElement: { style: { removeProperty() {} } } };
|
||
globalThis.window = { clearTimeout() {} };
|
||
|
||
try {
|
||
await assert.rejects(
|
||
layer.enable(viewer, { origin: 'scene' }),
|
||
/fixture image failure/,
|
||
);
|
||
assert.deepEqual(mapCalls, ['esri-imagery', 'photoreal']);
|
||
assert.equal(viewer.scene.splitPosition, 0.37);
|
||
assert.deepEqual(layer.getPlaybackState(), {
|
||
enabled: false,
|
||
playing: false,
|
||
progress: 0,
|
||
split: 0.5,
|
||
});
|
||
assert.ok(overlayCalls.some(([kind]) => kind === 'clear'));
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
}
|
||
});
|
||
|
||
test('Bhote Koshi cancellation during the map switch restores the prior stack', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
const controller = new AbortController();
|
||
const viewer = eventViewer();
|
||
let activeMap = 'photoreal';
|
||
let generation = 12;
|
||
let finishSwitch;
|
||
const switchGate = new Promise((resolve) => { finishSwitch = resolve; });
|
||
const mapCalls = [];
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => activeMap,
|
||
getSwitchGeneration: () => generation,
|
||
async setStack(id) {
|
||
activeMap = id;
|
||
generation += 1;
|
||
mapCalls.push(id);
|
||
if (id === 'esri-imagery') await switchGate;
|
||
},
|
||
});
|
||
installEventDom();
|
||
globalThis.window = { clearTimeout() {} };
|
||
|
||
try {
|
||
const enabling = layer.enable(viewer, { origin: 'scene', signal: controller.signal });
|
||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||
controller.abort();
|
||
finishSwitch();
|
||
await assert.rejects(enabling, (error) => error?.name === 'AbortError');
|
||
assert.deepEqual(mapCalls, ['esri-imagery', 'photoreal']);
|
||
assert.equal(viewer.scene.splitPosition, 0.37);
|
||
assert.equal(layer.getPlaybackState().enabled, false);
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
}
|
||
});
|
||
|
||
test('Bhote Koshi disable preserves an operator-selected map and tears down every surface', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
const { body, removedProperties } = installEventDom();
|
||
assert.equal(eventSplit(), undefined, 'no divider is left from an earlier test');
|
||
const clearedTimeouts = [];
|
||
globalThis.window = {
|
||
setTimeout: () => 71,
|
||
clearTimeout: (id) => clearedTimeouts.push(id),
|
||
};
|
||
const viewer = eventViewer();
|
||
let activeMap = 'photoreal';
|
||
let generation = 20;
|
||
const mapCalls = [];
|
||
const overlayCalls = [];
|
||
const renderCalls = [];
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
overlayHost: {
|
||
setEntries() {},
|
||
setVisible(id, visible) { overlayCalls.push(['visible', id, visible]); },
|
||
clearSource(id) { overlayCalls.push(['clear', id]); },
|
||
},
|
||
renderHost: {
|
||
request(reason) { renderCalls.push(reason); },
|
||
hold() {},
|
||
release() {},
|
||
},
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => activeMap,
|
||
getSwitchGeneration: () => generation,
|
||
async setStack(id) {
|
||
activeMap = id;
|
||
generation += 1;
|
||
mapCalls.push(id);
|
||
},
|
||
});
|
||
|
||
try {
|
||
assert.equal(await layer.enable(viewer, { origin: 'scene' }), true);
|
||
assert.equal(viewer._test.imagery.length, 2);
|
||
assert.equal(viewer._test.floodSets().length, 2);
|
||
assert.ok(eventPanel());
|
||
assert.ok(eventSplit());
|
||
|
||
activeMap = 'operator-choice';
|
||
generation += 1;
|
||
await layer.disable();
|
||
|
||
assert.deepEqual(mapCalls, ['esri-imagery']);
|
||
assert.equal(viewer._test.removedImagery.length, 2);
|
||
assert.equal(viewer._test.liveFloodSets().length, 0, 'its flood sets let go');
|
||
assert.equal(eventPanel(), undefined);
|
||
assert.equal(eventSplit(), undefined);
|
||
assert.equal(viewer.scene.splitPosition, 0.37);
|
||
assert.deepEqual(clearedTimeouts, [71]);
|
||
assert.ok(overlayCalls.some(([kind]) => kind === 'clear'));
|
||
assert.ok(removedProperties.includes('--bhote-koshi-split'));
|
||
assert.ok(renderCalls.includes('bhote-koshi-disable'));
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
}
|
||
});
|
||
|
||
test('Bhote Koshi disable stops active playback and releases its global render hold', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
const originalPerformance = globalThis.performance;
|
||
const originalRequestAnimationFrame = globalThis.requestAnimationFrame;
|
||
const originalCancelAnimationFrame = globalThis.cancelAnimationFrame;
|
||
const { body } = installEventDom();
|
||
const holds = [];
|
||
const releases = [];
|
||
const cancelledFrames = [];
|
||
globalThis.window = { setTimeout: () => 71, clearTimeout() {} };
|
||
globalThis.performance = { now: () => 1000 };
|
||
globalThis.requestAnimationFrame = () => 33;
|
||
globalThis.cancelAnimationFrame = (id) => cancelledFrames.push(id);
|
||
const viewer = eventViewer();
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: {
|
||
request() {},
|
||
hold(id) { holds.push(id); },
|
||
release(id) { releases.push(id); },
|
||
},
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => 'esri-imagery',
|
||
getSwitchGeneration: () => 1,
|
||
async setStack() {},
|
||
});
|
||
|
||
try {
|
||
await layer.enable(viewer, { origin: 'scene' });
|
||
const panel = eventPanel();
|
||
assert.equal(panel.querySelector('[data-action="play-scene"]').hidden, true);
|
||
assert.equal(await panel.querySelector('[data-action="play-scene"]').dispatch('click'), false);
|
||
panel.querySelector('[data-action="play"]').dispatch('click');
|
||
assert.equal(layer.getPlaybackState().playing, true);
|
||
|
||
await layer.disable();
|
||
|
||
assert.deepEqual(holds, ['bhote-koshi-playback']);
|
||
assert.deepEqual(releases, ['bhote-koshi-playback']);
|
||
assert.deepEqual(cancelledFrames, [33]);
|
||
assert.deepEqual(layer.getPlaybackState(), {
|
||
enabled: false,
|
||
playing: false,
|
||
progress: 0,
|
||
split: 0.5,
|
||
});
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
globalThis.performance = originalPerformance;
|
||
globalThis.requestAnimationFrame = originalRequestAnimationFrame;
|
||
globalThis.cancelAnimationFrame = originalCancelAnimationFrame;
|
||
}
|
||
});
|
||
|
||
test('Bhote Koshi passive restores do not start off-screen playback', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
installEventDom();
|
||
const timers = [];
|
||
globalThis.window = {
|
||
setTimeout(handler, delay) {
|
||
timers.push({ handler, delay });
|
||
return timers.length;
|
||
},
|
||
clearTimeout() {},
|
||
};
|
||
const viewer = eventViewer();
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
embeddedMediaFactory: () => ({ show() {}, hide() {}, pause() {}, destroy() {} }),
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => 'esri-imagery',
|
||
getSwitchGeneration: () => 1,
|
||
async setStack() {},
|
||
});
|
||
|
||
const manager = new LayerLifecycle(viewer);
|
||
manager.register(layer);
|
||
try {
|
||
assert.equal(await manager.setEnabled(layer.id, true, { origin: 'local-restore' }), true);
|
||
assert.deepEqual(timers, []);
|
||
assert.deepEqual(viewer._test.cameraLooks, []);
|
||
assert.equal(layer.getPlaybackState().playing, false);
|
||
} finally {
|
||
await manager.destroyLayer(layer.id);
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
}
|
||
});
|
||
|
||
test('Bhote Koshi standalone Scene keeps its Esri cinematic contract', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
const originalPerformance = globalThis.performance;
|
||
const originalRequestAnimationFrame = globalThis.requestAnimationFrame;
|
||
const originalCancelAnimationFrame = globalThis.cancelAnimationFrame;
|
||
installEventDom();
|
||
const timers = [];
|
||
globalThis.window = {
|
||
setTimeout(handler, delay) {
|
||
timers.push({ handler, delay });
|
||
return timers.length;
|
||
},
|
||
clearTimeout() {},
|
||
};
|
||
globalThis.performance = { now: () => 1000 };
|
||
globalThis.requestAnimationFrame = () => 44;
|
||
globalThis.cancelAnimationFrame = () => {};
|
||
const viewer = eventViewer();
|
||
let activeMap = 'photoreal';
|
||
const mapCalls = [];
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => (
|
||
observations.map((observation) => ({ height: observation.fallbackElevationM }))
|
||
),
|
||
mediaLoader: async () => {
|
||
const error = new Error('fixture media intentionally unavailable');
|
||
error.name = 'AbortError';
|
||
throw error;
|
||
},
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => activeMap,
|
||
getSwitchGeneration: () => mapCalls.length,
|
||
async setStack(id) {
|
||
activeMap = id;
|
||
mapCalls.push(id);
|
||
},
|
||
});
|
||
|
||
try {
|
||
await layer.enable(viewer, { origin: 'scene' });
|
||
assert.deepEqual(mapCalls, ['esri-imagery']);
|
||
assert.equal(viewer._test.imagery.length, 2);
|
||
assert.equal(timers.length, 1);
|
||
assert.equal(timers[0].delay, 2400);
|
||
timers[0].handler();
|
||
assert.equal(layer.getPlaybackState().playing, true);
|
||
assert.equal(layer.getCinematicState().active, true);
|
||
assert.equal(viewer._test.cameraLooks.length, 1);
|
||
await layer.disable();
|
||
assert.deepEqual(mapCalls, ['esri-imagery', 'photoreal']);
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
globalThis.performance = originalPerformance;
|
||
globalThis.requestAnimationFrame = originalRequestAnimationFrame;
|
||
globalThis.cancelAnimationFrame = originalCancelAnimationFrame;
|
||
}
|
||
});
|
||
|
||
test('Bhote Koshi scene beats preserve photoreal and never take camera ownership', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
const originalPerformance = globalThis.performance;
|
||
const originalRequestAnimationFrame = globalThis.requestAnimationFrame;
|
||
const originalCancelAnimationFrame = globalThis.cancelAnimationFrame;
|
||
const { body } = installEventDom();
|
||
assert.equal(eventSplit(), undefined, 'no divider is left from an earlier test');
|
||
const timers = [];
|
||
const openedUrls = [];
|
||
const cancelledFrames = [];
|
||
globalThis.window = {
|
||
setTimeout(handler, delay) {
|
||
timers.push({ handler, delay });
|
||
return timers.length;
|
||
},
|
||
clearTimeout() {},
|
||
open(url) {
|
||
openedUrls.push(url);
|
||
return { opener: 'fixture' };
|
||
},
|
||
};
|
||
globalThis.performance = { now: () => 1000 };
|
||
globalThis.requestAnimationFrame = () => 91;
|
||
globalThis.cancelAnimationFrame = (id) => cancelledFrames.push(id);
|
||
const viewer = eventViewer();
|
||
let activeMap = 'photoreal';
|
||
const mapCalls = [];
|
||
const overlayPublications = [];
|
||
const overlayVisibility = [];
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => (
|
||
observations.map((observation) => ({ height: observation.fallbackElevationM }))
|
||
),
|
||
mediaLoader: async () => {
|
||
const error = new Error('fixture media intentionally unavailable');
|
||
error.name = 'AbortError';
|
||
throw error;
|
||
},
|
||
overlayHost: {
|
||
setEntries(id, entries, options) {
|
||
overlayPublications.push({ id, entries, options });
|
||
},
|
||
setVisible(id, visible) {
|
||
overlayVisibility.push({ id, visible });
|
||
},
|
||
clearSource() {},
|
||
},
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => activeMap,
|
||
getSwitchGeneration: () => 1,
|
||
async setStack(id) {
|
||
activeMap = id;
|
||
mapCalls.push(id);
|
||
},
|
||
});
|
||
const sceneCalls = [];
|
||
let finishScene;
|
||
let publishSceneClock;
|
||
layer.attachSceneController({
|
||
subscribeSceneClock(listener) {
|
||
publishSceneClock = listener;
|
||
return () => { publishSceneClock = null; };
|
||
},
|
||
continueScene(sceneId, shotId) {
|
||
sceneCalls.push({ action: 'scene', sceneId, shotId });
|
||
return new Promise((resolve) => { finishScene = resolve; });
|
||
},
|
||
replayShot(sceneId, shotId) {
|
||
sceneCalls.push({ action: 'play', sceneId, shotId });
|
||
return true;
|
||
},
|
||
loadAdjacentShot(sceneId, shotId, direction) {
|
||
sceneCalls.push({ action: 'adjacent', sceneId, shotId, direction });
|
||
return true;
|
||
},
|
||
seekScene(sceneId, progress) {
|
||
sceneCalls.push({ action: 'seek', sceneId, progress });
|
||
return true;
|
||
},
|
||
});
|
||
|
||
try {
|
||
assert.equal(layer.setParams({
|
||
presentation: 'scene-beat',
|
||
sceneSurface: 'panel-only',
|
||
progress: 0.34,
|
||
split: 0.62,
|
||
cinematic: true,
|
||
autoPlay: true,
|
||
sceneContext: {
|
||
sceneId: 'nepal-scene',
|
||
sceneTitle: 'Nepal Flood Incident',
|
||
shotId: 'global-context',
|
||
shotTitle: 'Global Incident Context',
|
||
shotIndex: 0,
|
||
shotCount: 14,
|
||
durationSec: 4,
|
||
holdSec: 0.9,
|
||
sceneElapsedSec: 0,
|
||
sceneDurationSec: 120,
|
||
sceneProgress: 0,
|
||
},
|
||
}, { origin: 'scene' }), true);
|
||
await layer.enable(viewer, { origin: 'scene' });
|
||
assert.deepEqual(mapCalls, []);
|
||
assert.equal(activeMap, 'photoreal');
|
||
assert.deepEqual(timers, []);
|
||
assert.equal(viewer._test.imagery.length, 2, 'the event surface keeps its cached imagery pair');
|
||
assert.ok(viewer._test.imagery.every((imageryLayer) => imageryLayer.show === false));
|
||
const panel = eventPanel();
|
||
assert.ok(panel);
|
||
assert.ok(eventSplit());
|
||
assert.equal(eventSplit().view.hidden, true);
|
||
assert.equal(panel.querySelector('[data-role="imagery-comparison"]').hidden, true);
|
||
assert.match(panel.querySelector('[data-role="caveat"]').textContent, /SCHEMATIC CORRIDOR/i);
|
||
assert.doesNotMatch(panel.querySelector('[data-role="caveat"]').textContent, /historical/i);
|
||
assert.equal(panel.querySelector('[data-role="imagery-cloud-note"]').hidden, true);
|
||
const sceneClock = panel.querySelector('[data-role="progress"]');
|
||
assert.equal(sceneClock.hidden, false);
|
||
assert.equal(sceneClock.disabled, false);
|
||
assert.equal(sceneClock.getAttribute('aria-label'), 'Seek Nepal scene clock');
|
||
assert.equal(panel.querySelector('[data-role="timeline-label"]').textContent, 'NEPAL SCENE CLOCK');
|
||
assert.equal(panel.querySelector('[data-role="time"]').textContent, '~0:00 / 2:00');
|
||
publishSceneClock({
|
||
sceneId: 'nepal-scene',
|
||
shotId: 'global-context',
|
||
shotIndex: 0,
|
||
shotCount: 14,
|
||
sceneElapsedSec: 30,
|
||
sceneDurationSec: 120,
|
||
sceneProgress: 0.25,
|
||
running: true,
|
||
});
|
||
assert.equal(sceneClock.value, '250');
|
||
assert.equal(panel.querySelector('[data-role="time"]').textContent, '~0:30 / 2:00');
|
||
assert.equal(panel.querySelector('[data-role="beat-index"]').textContent, '01 / 14');
|
||
assert.equal(panel.querySelector('[data-role="beat-title"]').textContent, 'Global Incident Context');
|
||
assert.equal(panel.querySelector('[data-action="play"]').textContent, '▶ PLAY SHOT');
|
||
const playScene = panel.querySelector('[data-action="play-scene"]');
|
||
assert.equal(playScene.hidden, false);
|
||
assert.equal(playScene.disabled, false);
|
||
assert.equal(playScene.textContent, '▶ PLAY SCENE');
|
||
assert.equal(playScene.getAttribute('aria-label'), 'Continue Nepal Flood Incident from next shot');
|
||
assert.equal(panel.querySelector('[data-action="cinematic"]').hidden, true);
|
||
assert.equal(panel.querySelector('[data-action="cinematic"]').disabled, true);
|
||
assert.equal(panel.querySelector('[data-action="corridor"]').hidden, false);
|
||
assert.equal(panel.querySelector('[data-action="corridor"]').disabled, false);
|
||
const fullStory = panel.querySelector('[data-action="story-replay"]');
|
||
assert.equal(fullStory.textContent, '↺ FULL STORY');
|
||
assert.equal(fullStory.hidden, true, 'PLAY SCENE owns authored scene playback');
|
||
assert.equal(fullStory.disabled, true);
|
||
assert.equal(panel.querySelector('[data-action="open-source"]').hidden, true);
|
||
assert.deepEqual(layer.getParams(), {
|
||
presentation: 'scene-beat',
|
||
sceneSurface: 'panel-only',
|
||
progress: 0.34,
|
||
split: 0.62,
|
||
});
|
||
assert.equal(viewer.scene.splitPosition, 0.62);
|
||
layer.setParams({
|
||
presentation: 'scene-beat',
|
||
sceneSurface: 'evidence-beat',
|
||
beatId: 'timure-cluster',
|
||
sceneControls: { imageryComparison: true },
|
||
}, { origin: 'scene' });
|
||
assert.equal(eventSplit().view.hidden, false);
|
||
assert.equal(panel.querySelector('[data-role="imagery-comparison"]').hidden, false);
|
||
assert.ok(viewer._test.imagery.every((imageryLayer) => imageryLayer.show === true));
|
||
assert.equal(eventSplit().view.handleClass, 'bhote-koshi-split-handle');
|
||
assert.equal(eventSplit().view.valueNow, 62);
|
||
const splitHandle = eventSplit().controls;
|
||
splitHandle.pointerdown({
|
||
button: 0,
|
||
clientX: 250,
|
||
pointerId: 4,
|
||
preventDefault() {},
|
||
});
|
||
splitHandle.pointermove({
|
||
clientX: 750,
|
||
pointerId: 4,
|
||
preventDefault() {},
|
||
});
|
||
splitHandle.pointerup({ pointerId: 4 });
|
||
assert.equal(viewer.scene.splitPosition, 0.75);
|
||
assert.equal(eventSplit().view.valueNow, 75);
|
||
splitHandle.keydown({
|
||
key: 'ArrowLeft',
|
||
shiftKey: true,
|
||
preventDefault() {},
|
||
});
|
||
assert.equal(viewer.scene.splitPosition, 0.7);
|
||
layer.setParams({
|
||
presentation: 'scene-beat',
|
||
sceneSurface: 'panel-only',
|
||
progress: 0.34,
|
||
split: 0.62,
|
||
sceneControls: {},
|
||
}, { origin: 'scene' });
|
||
assert.equal(eventSplit().view.hidden, true);
|
||
assert.ok(viewer._test.imagery.every((imageryLayer) => imageryLayer.show === false));
|
||
assert.equal(viewer.scene.splitPosition, 0.62);
|
||
assert.equal(overlayVisibility.at(-1).visible, false);
|
||
for (const id of [
|
||
'bhote-koshi-flood-halo',
|
||
'bhote-koshi-flood-core',
|
||
'bhote-koshi-surge-front',
|
||
]) {
|
||
assert.equal(viewer._test.floodShows(id), false);
|
||
}
|
||
panel.querySelector('[data-action="play"]').dispatch('click');
|
||
await Promise.resolve();
|
||
panel.querySelector('[data-action="next-beat"]').dispatch('click');
|
||
await Promise.resolve();
|
||
assert.deepEqual(sceneCalls, [
|
||
{ action: 'play', sceneId: 'nepal-scene', shotId: 'global-context' },
|
||
{ action: 'adjacent', sceneId: 'nepal-scene', shotId: 'global-context', direction: 1 },
|
||
]);
|
||
const run = playScene.dispatch('click');
|
||
assert.equal(playScene.disabled, true);
|
||
assert.equal(playScene.textContent, '… PLAYING SCENE');
|
||
assert.equal(panel.querySelector('[data-action="play"]').disabled, true);
|
||
assert.equal(panel.querySelector('[data-action="play"]').textContent, '▶ PLAY SHOT');
|
||
await playScene.dispatch('click');
|
||
assert.deepEqual(sceneCalls.at(-1), {
|
||
action: 'scene', sceneId: 'nepal-scene', shotId: 'global-context',
|
||
});
|
||
assert.equal(sceneCalls.length, 3, 'duplicate clicks cannot start another scene run');
|
||
finishScene({ started: true });
|
||
await run;
|
||
assert.equal(playScene.disabled, false);
|
||
assert.equal(playScene.textContent, '▶ PLAY SCENE');
|
||
sceneClock.value = '500';
|
||
sceneClock.dispatch('input');
|
||
assert.equal(panel.querySelector('[data-role="time"]').textContent, '~1:00 / 2:00');
|
||
sceneClock.dispatch('change');
|
||
await Promise.resolve();
|
||
assert.deepEqual(sceneCalls.at(-1), { action: 'seek', sceneId: 'nepal-scene', progress: 0.5 });
|
||
assert.equal(sceneCalls.length, 4);
|
||
layer.attachSceneController({ continueScene: async () => ({ started: false, reason: 'already-running' }) });
|
||
assert.deepEqual(await playScene.dispatch('click'), { started: false, reason: 'already-running' });
|
||
assert.equal(playScene.disabled, false, 'a refused start releases the button');
|
||
layer.attachSceneController({ continueScene: async () => { throw new Error('test scene failure'); } });
|
||
const originalWarn = console.warn;
|
||
const warnings = [];
|
||
try {
|
||
console.warn = (...args) => warnings.push(args);
|
||
assert.equal(await playScene.dispatch('click'), false);
|
||
assert.equal(playScene.disabled, false, 'a rejected start releases the button');
|
||
assert.equal(warnings.length, 1);
|
||
} finally {
|
||
console.warn = originalWarn;
|
||
}
|
||
layer.attachSceneController(null);
|
||
assert.equal(playScene.disabled, true);
|
||
await playScene.dispatch('click');
|
||
assert.equal(sceneCalls.length, 4);
|
||
assert.equal(layer.getPlaybackState().playing, false);
|
||
for (const reportButton of panel.querySelector('.bhote-event-report-list').children) {
|
||
reportButton.dispatch('click');
|
||
}
|
||
panel.querySelector('[data-action="geolocation-map"]').dispatch('click');
|
||
assert.deepEqual(openedUrls, [
|
||
...event.fieldReports.map(({ url }) => url),
|
||
event.geolocationMap.sourceUrl,
|
||
]);
|
||
assert.equal(layer.getPlaybackState().playing, false);
|
||
assert.equal(layer.getCinematicState().active, false);
|
||
assert.equal(viewer._test.cameraLooks.length, 0);
|
||
assert.deepEqual(mapCalls, []);
|
||
assert.ok(eventPanel());
|
||
assert.equal(viewer.scene.splitPosition, 0.62);
|
||
for (const beatId of [
|
||
'debris-dammed-lake',
|
||
'gyirong-border-gate',
|
||
'timure-cluster',
|
||
'syabru-besi',
|
||
'bidur-trishuli-bridge',
|
||
]) {
|
||
layer.setParams({
|
||
presentation: 'scene-beat',
|
||
sceneSurface: 'evidence-beat',
|
||
beatId,
|
||
beatReveal: 0.36,
|
||
}, { origin: 'scene' });
|
||
assert.equal(layer.getParams().beatId, beatId);
|
||
assert.equal(layer.getParams().sceneSurface, 'evidence-beat');
|
||
assert.equal(panel.querySelector('[data-action="open-source"]').hidden, false);
|
||
assert.equal(overlayVisibility.at(-1).visible, true);
|
||
const entries = overlayPublications.at(-1).entries;
|
||
const visibleCards = entries.filter((entry) => (
|
||
entry.id.startsWith('evidence-card-') && entry.position() != null
|
||
));
|
||
assert.deepEqual(visibleCards.map(({ id }) => id), [`evidence-card-${beatId}`]);
|
||
assert.ok(entries
|
||
.filter((entry) => entry.id.startsWith('evidence-breadcrumb-'))
|
||
.every((entry) => entry.position() == null));
|
||
assert.equal(viewer._test.liveFloodSets().length, 2, 'surface transitions leave exactly one active event surface');
|
||
assert.equal(viewer._test.cameraLooks.length, 0, 'consecutive beats never write the camera');
|
||
}
|
||
panel.querySelector('[data-action="open-source"]').dispatch('click');
|
||
assert.equal(openedUrls.at(-1), event.evidenceSpine.find(({ id }) => id === 'bidur-trishuli-bridge').media.sourceUrl);
|
||
layer.setParams({
|
||
presentation: 'scene-beat',
|
||
progress: 0.2,
|
||
}, { origin: 'scene' });
|
||
assert.equal(layer.getParams().sceneSurface, 'panel-only', 'missing ownership fails closed');
|
||
assert.equal(panel.querySelector('[data-action="open-source"]').hidden, true);
|
||
assert.equal(overlayVisibility.at(-1).visible, false);
|
||
await layer.disable();
|
||
assert.deepEqual(
|
||
cancelledFrames,
|
||
[91],
|
||
'disable revokes the pending real-time scene-clock scrub frame',
|
||
);
|
||
assert.deepEqual(mapCalls, []);
|
||
assert.equal(viewer._test.liveFloodSets().length, 0);
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
globalThis.performance = originalPerformance;
|
||
globalThis.requestAnimationFrame = originalRequestAnimationFrame;
|
||
globalThis.cancelAnimationFrame = originalCancelAnimationFrame;
|
||
}
|
||
});
|
||
|
||
test('Nepal hybrid comparison preserves native split and terrain-clamped flood trail', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
installEventDom();
|
||
globalThis.window = { setTimeout: () => 71, clearTimeout() {} };
|
||
const viewer = eventViewer();
|
||
const mapCalls = [];
|
||
const comparisonCalls = [];
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => (
|
||
observations.map((observation) => ({ height: observation.fallbackElevationM }))
|
||
),
|
||
mediaLoader: async () => {
|
||
const error = new Error('fixture media intentionally unavailable');
|
||
error.name = 'AbortError';
|
||
throw error;
|
||
},
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => 'photoreal',
|
||
getSwitchGeneration: () => 1,
|
||
async setStack(id) { mapCalls.push(id); },
|
||
async setTerrainComparison(rectangle) { comparisonCalls.push(rectangle); return true; },
|
||
clearTerrainComparison() { comparisonCalls.push(null); },
|
||
});
|
||
|
||
try {
|
||
layer.setParams({
|
||
presentation: 'scene-beat',
|
||
sceneSurface: 'evidence-beat',
|
||
beatId: 'gyirong-border-gate',
|
||
sceneControls: { imageryComparison: true },
|
||
}, { origin: 'scene' });
|
||
await layer.enable(viewer, { origin: 'scene' });
|
||
|
||
assert.deepEqual(mapCalls, [], 'comparison does not switch the authored Google base');
|
||
assert.deepEqual(comparisonCalls, [event.imagery.rectangle]);
|
||
assert.equal(viewer._test.imagery.length, 2);
|
||
assert.ok(viewer._test.imagery.every((imageryLayer) => imageryLayer.show === true));
|
||
assert.equal(viewer.scene.splitPosition, 0.5);
|
||
assert.equal(viewer._test.imagery[0].split, 'left');
|
||
assert.equal(viewer._test.imagery[1].split, 'right');
|
||
assert.ok(viewer._test.imagery.every((imageryLayer) => imageryLayer.alpha === 0.96 && imageryLayer.drapeOn === 'surface'));
|
||
layer.setParams({ split: 0.25 });
|
||
assert.equal(viewer.scene.splitPosition, 0.25);
|
||
const flood = viewer._test.flood('bhote-koshi-flood-core');
|
||
const surge = viewer._test.flood('bhote-koshi-surge-front');
|
||
assert.equal(flood.mode, 'draped');
|
||
assert.equal(flood.clampTo, 'terrain', 'the comparison surface is terrain');
|
||
assert.equal(surge.height, 'clampGround');
|
||
assert.equal(surge.disableDepthTest, 0);
|
||
|
||
layer.setParams({
|
||
presentation: 'scene-beat',
|
||
sceneSurface: 'evidence-beat',
|
||
beatId: 'timure',
|
||
sceneControls: { imageryComparison: false },
|
||
}, { origin: 'scene' });
|
||
assert.ok(viewer._test.imagery.every((imageryLayer) => imageryLayer.show === false));
|
||
assert.equal(comparisonCalls.at(-1), null);
|
||
|
||
assert.equal(viewer._test.flood('bhote-koshi-flood-core'), undefined, 'drawn anew on the tiles as the event plays');
|
||
layer.setParams({ progress: 0.6 }, { origin: 'scene' });
|
||
const tileFlood = viewer._test.flood('bhote-koshi-flood-core');
|
||
assert.equal(tileFlood.mode, 'draped');
|
||
assert.equal(tileFlood.clampTo, 'both', 'photoreal drapes it on tiles too');
|
||
assert.equal(viewer._test.flood('bhote-koshi-surge-front').disableDepthTest, Number.POSITIVE_INFINITY);
|
||
|
||
await layer.disable();
|
||
assert.equal(viewer._test.removedImagery.length, 2);
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
}
|
||
});
|
||
|
||
test('Bhote Koshi event pack keeps observations separate from reconstruction', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
assert.equal(BHOTE_KOSHI_LAYER_ID, event.id);
|
||
assert.equal(event.imagery.before.observedAt, '2021-10-16');
|
||
assert.equal(event.imagery.after.observedAt, '2026-08-27');
|
||
assert.equal(
|
||
event.reconstruction.label,
|
||
'SCHEMATIC DOWNSTREAM PROGRESSION, NOT MODELED ARRIVAL TIME',
|
||
);
|
||
assert.match(event.imagery.before.label, /^2021 HISTORICAL REFERENCE/);
|
||
assert.match(event.imagery.after.label, /^2026 POST-EVENT/);
|
||
assert.equal(
|
||
event.geolocationMap.sourceUrl,
|
||
'https://x.com/geogeorgeology/status/2093632283442053371',
|
||
);
|
||
assert.ok(event.reconstruction.corridor.length >= 100);
|
||
assert.equal(event.witnessAnchors.length, 1);
|
||
assert.ok(Number.isFinite(event.witnessAnchors[0].elevationM));
|
||
assert.match(event.witnessAnchors[0].title, /SOURCE GEO/);
|
||
assert.equal(event.viewpoints.witness.imagery, 'before');
|
||
assert.equal(
|
||
event.fieldReports.filter((report) => report.status.includes('WORLD-PINNED')).length,
|
||
1,
|
||
);
|
||
assert.ok(event.fieldReports.some((report) => report.status.includes('UNVERIFIED')));
|
||
assert.equal(event.evidenceSpine.length, 16);
|
||
assert.equal(new Set(event.evidenceSpine.map(({ id }) => id)).size, 16);
|
||
assert.deepEqual(event.evidenceSpine.map(({ sequence }) => sequence),
|
||
Array.from({ length: 16 }, (_, index) => index + 1));
|
||
assert.equal(floodProgressForStoryProgress(0.195, event.reconstruction.storyFloodWindow), 0);
|
||
assert.equal(floodProgressForStoryProgress(0.39, event.reconstruction.storyFloodWindow), 1);
|
||
assert.equal(floodProgressForStoryProgress(0.9, event.reconstruction.storyFloodWindow), 1);
|
||
for (const { media } of event.evidenceSpine) {
|
||
for (const asset of [media.videoPath, media.posterPath].filter(Boolean)) {
|
||
assert.match(asset, /^evidence-\d+\.(mp4|jpg)$/);
|
||
assert.ok((await readFile(new URL(asset, eventUrl))).length > 0, asset);
|
||
}
|
||
}
|
||
assert.ok(event.evidenceSpine.every((observation) => observation.timing.capturedAt === null));
|
||
assert.ok(event.evidenceSpine.every((observation) => (
|
||
observation.timing.note === 'capture time unverified'
|
||
)));
|
||
assert.ok(event.evidenceSpine.every((observation) => /^https:\/\//.test(observation.media.sourceUrl)));
|
||
assert.ok(event.evidenceSpine.filter((observation) => observation.media.posterUrl).every((observation) => (
|
||
observation.media.posterUrl.startsWith('https://i.ytimg.com/')
|
||
)));
|
||
assert.equal(
|
||
event.evidenceSpine.find(({ id }) => id === 'gyirong-border-gate').media.clipInSec,
|
||
26,
|
||
);
|
||
assert.ok(event.evidenceSpine.every(({ media }) => !media.videoPath && !media.posterPath),
|
||
'Public event records must not reference privately cached social clips');
|
||
assert.equal(event.evidenceSpine.filter((observation) => (
|
||
observation.imageryCoverage === 'outside'
|
||
)).length, 13);
|
||
const timure = event.evidenceSpine.find((observation) => observation.id === 'timure-cluster');
|
||
assert.equal(timure.corroboration.kind, 'multi-source geolocation cluster');
|
||
assert.equal(timure.corroboration.sourceCount, 5);
|
||
assert.equal(timure.corroboration.displayedSourceCount, 1);
|
||
assert.equal(evidenceCorroborationLabel(timure), '5 GEOLOCATED SOURCE-MAP PLACEMENTS');
|
||
assert.match(event.reconstruction.caveat, /2021 historical reference versus 2026 post-event/i);
|
||
assert.match(event.reconstruction.caveat, /not modeled arrival time/i);
|
||
assert.match(event.reconstruction.caveat, /2025 Rasuwagadhi flood/i);
|
||
assert.equal(SCENE_RECIPES.some((recipe) => recipe.id === 'bhote-koshi-flood'), false);
|
||
assert.ok(SCENE_RECIPES.some((recipe) => recipe.id === 'bhote-koshi-nepal-scene'));
|
||
});
|
||
|
||
test('Bhote Koshi publishes the evidence spine once and scrubs through cards and breadcrumbs', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
const { body } = installEventDom();
|
||
globalThis.window = { setTimeout: () => 71, clearTimeout() {} };
|
||
const viewer = eventViewer();
|
||
const publications = [];
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => (
|
||
observations.map((observation) => ({ height: observation.fallbackElevationM }))
|
||
),
|
||
mediaLoader: async () => {
|
||
const error = new Error('fixture media intentionally unavailable');
|
||
error.name = 'AbortError';
|
||
throw error;
|
||
},
|
||
evidenceFrameFactory: (observation) => ({ fixture: observation.id }),
|
||
overlayHost: {
|
||
setEntries(id, entries, options) { publications.push({ id, entries, options }); },
|
||
setVisible() {},
|
||
clearSource() {},
|
||
},
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => 'esri-imagery',
|
||
getSwitchGeneration: () => 1,
|
||
async setStack() {},
|
||
});
|
||
|
||
try {
|
||
await layer.enable(viewer, { origin: 'local-restore' });
|
||
assert.equal(publications.length, 1);
|
||
assert.equal(publications[0].entries.length, 32);
|
||
const cards = publications[0].entries.filter((entry) => entry.variant === 'thumbnail');
|
||
const breadcrumbs = publications[0].entries.filter((entry) => entry.variant === 'label');
|
||
assert.equal(cards.filter((entry) => entry.position()).length, 1);
|
||
assert.match(cards.find((entry) => entry.position()).id, /immediate-collapse/);
|
||
assert.equal(breadcrumbs.filter((entry) => entry.position()).length, 0);
|
||
assert.ok(cards.every((entry) => entry.requireImage && entry.image.stamp === 1));
|
||
|
||
const panel = eventPanel();
|
||
const progress = panel.querySelector('[data-role="progress"]');
|
||
progress.value = '285';
|
||
progress.dispatch('input');
|
||
|
||
assert.equal(publications.length, 1);
|
||
assert.equal(cards.filter((entry) => entry.position()).length, 1);
|
||
assert.match(cards.find((entry) => entry.position()).id, /timure-cluster/);
|
||
assert.equal(breadcrumbs.filter((entry) => entry.position()).length, 4);
|
||
await layer.disable();
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
}
|
||
});
|
||
|
||
test('Bhote Koshi keeps one local fallback video active and unloads it on beat change and disable', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
// Synthetic clips exercise the player; public event data never bundles these.
|
||
event.evidenceSpine.find(({ id }) => id === 'immediate-collapse-viewpoint').media.videoPath = 'evidence-01.mp4';
|
||
event.evidenceSpine.find(({ id }) => id === 'timure-cluster').media.videoPath = 'evidence-04.mp4';
|
||
event.evidenceSpine.find(({ id }) => id === 'immediate-collapse-viewpoint').media.sourceUrl =
|
||
'https://example.com/immediate-collapse';
|
||
event.evidenceSpine.find(({ id }) => id === 'timure-cluster').media.sourceUrl =
|
||
'https://example.com/timure';
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
const { body } = installEventDom();
|
||
globalThis.window = { setTimeout: () => 71, clearTimeout() {} };
|
||
const viewer = eventViewer();
|
||
const videos = [];
|
||
const videoFactory = () => {
|
||
const listeners = new Map();
|
||
const video = {
|
||
muted: false,
|
||
playsInline: false,
|
||
preload: '',
|
||
loop: false,
|
||
paused: true,
|
||
currentTime: 0,
|
||
duration: 10,
|
||
playbackRate: 1,
|
||
pauseCalls: 0,
|
||
playCalls: 0,
|
||
loadCalls: 0,
|
||
removedSources: 0,
|
||
addEventListener(type, handler) { listeners.set(type, handler); },
|
||
load() { this.loadCalls += 1; },
|
||
pause() { this.pauseCalls += 1; this.paused = true; },
|
||
play() { this.playCalls += 1; this.paused = false; return Promise.resolve(); },
|
||
removeAttribute(name) {
|
||
if (name === 'src') {
|
||
this.src = '';
|
||
this.removedSources += 1;
|
||
}
|
||
},
|
||
dispatch(type) { listeners.get(type)?.(); },
|
||
};
|
||
videos.push(video);
|
||
return video;
|
||
};
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => (
|
||
observations.map((observation) => ({ height: observation.fallbackElevationM }))
|
||
),
|
||
mediaLoader: async () => {
|
||
const error = new Error('fixture media intentionally unavailable');
|
||
error.name = 'AbortError';
|
||
throw error;
|
||
},
|
||
evidenceFrameFactory: (observation) => ({ fixture: observation.id }),
|
||
evidenceFrameUpdater: () => true,
|
||
videoFactory,
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => 'esri-imagery',
|
||
getSwitchGeneration: () => 1,
|
||
async setStack() {},
|
||
});
|
||
|
||
try {
|
||
await layer.enable(viewer, { origin: 'local-restore' });
|
||
assert.equal(videos.length, 1);
|
||
assert.match(videos[0].src, /evidence-01\.mp4$/);
|
||
videos[0].dispatch('loadeddata');
|
||
assert.equal(layer.getCinematicState().mediaReady, true);
|
||
|
||
const panel = eventPanel();
|
||
const progress = panel.querySelector('[data-role="progress"]');
|
||
progress.value = '285';
|
||
progress.dispatch('input');
|
||
|
||
assert.equal(videos.length, 2, 'the new beat replaces rather than stacks a decoder');
|
||
assert.equal(videos[0].removedSources, 1);
|
||
assert.ok(videos[0].pauseCalls >= 1);
|
||
assert.match(videos[1].src, /evidence-04\.mp4$/);
|
||
|
||
await layer.disable();
|
||
assert.equal(videos[1].removedSources, 1);
|
||
assert.ok(videos[1].pauseCalls >= 1);
|
||
assert.equal(layer.getCinematicState().mediaEvidenceId, null);
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
}
|
||
});
|
||
|
||
test('Upper Valley Collapse autoplays its muted local fallback without starting the event clock', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
event.evidenceSpine.find(({ id }) => id === 'immediate-collapse-viewpoint').media.videoPath = 'evidence-01.mp4';
|
||
event.evidenceSpine.find(({ id }) => id === 'immediate-collapse-viewpoint').media.sourceUrl =
|
||
'https://example.com/immediate-collapse';
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
const { body } = installEventDom();
|
||
globalThis.window = { setTimeout: () => 71, clearTimeout() {} };
|
||
const viewer = eventViewer();
|
||
const videos = [];
|
||
let frameUpdates = 0;
|
||
const videoFactory = () => {
|
||
const listeners = new Map();
|
||
const frameCallbacks = new Map();
|
||
const video = {
|
||
muted: false,
|
||
playsInline: false,
|
||
preload: '',
|
||
loop: false,
|
||
paused: true,
|
||
currentTime: 0,
|
||
duration: 8.6,
|
||
playbackRate: 1,
|
||
playCalls: 0,
|
||
pauseCalls: 0,
|
||
cancelledFrameHandles: [],
|
||
addEventListener(type, handler) { listeners.set(type, handler); },
|
||
load() {},
|
||
pause() { this.pauseCalls += 1; this.paused = true; },
|
||
play() { this.playCalls += 1; this.paused = false; return Promise.resolve(); },
|
||
removeAttribute(name) { if (name === 'src') this.src = ''; },
|
||
requestVideoFrameCallback(callback) {
|
||
const handle = frameCallbacks.size + 1;
|
||
frameCallbacks.set(handle, callback);
|
||
return handle;
|
||
},
|
||
cancelVideoFrameCallback(handle) {
|
||
this.cancelledFrameHandles.push(handle);
|
||
frameCallbacks.delete(handle);
|
||
},
|
||
dispatch(type) { listeners.get(type)?.(); },
|
||
drawFrame(handle = [...frameCallbacks.keys()][0]) {
|
||
const callback = frameCallbacks.get(handle);
|
||
frameCallbacks.delete(handle);
|
||
callback?.();
|
||
},
|
||
};
|
||
videos.push(video);
|
||
return video;
|
||
};
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => (
|
||
observations.map((observation) => ({ height: observation.fallbackElevationM }))
|
||
),
|
||
mediaLoader: async () => {
|
||
const error = new Error('fixture media intentionally unavailable');
|
||
error.name = 'AbortError';
|
||
throw error;
|
||
},
|
||
evidenceFrameFactory: (observation) => ({ fixture: observation.id }),
|
||
evidenceFrameUpdater: () => { frameUpdates += 1; return true; },
|
||
videoFactory,
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => 'photoreal',
|
||
getSwitchGeneration: () => 1,
|
||
async setStack() {},
|
||
});
|
||
|
||
try {
|
||
layer.setParams({
|
||
presentation: 'scene-beat',
|
||
sceneSurface: 'evidence-beat',
|
||
sceneControls: { evidenceMediaAutoplay: true },
|
||
beatId: 'immediate-collapse-viewpoint',
|
||
beatReveal: 0.36,
|
||
sceneContext: { sceneId: 'scene', shotId: 'shot' },
|
||
}, { origin: 'scene' });
|
||
layer.setSceneMediaPlayback({ sceneId: 'scene', shotId: 'shot', token: { cancelled: false } });
|
||
await layer.enable(viewer, { origin: 'scene' });
|
||
assert.equal(videos.length, 1);
|
||
const video = videos[0];
|
||
assert.equal(video.muted, true);
|
||
assert.equal(video.loop, true);
|
||
assert.equal(video.playCalls, 0, 'play waits until decoded media is ready');
|
||
video.dispatch('loadeddata');
|
||
assert.equal(video.playCalls, 1);
|
||
assert.equal(video.playbackRate, 1);
|
||
assert.equal(layer.getPlaybackState().playing, false);
|
||
const updatesBeforeFrame = frameUpdates;
|
||
video.currentTime = 1.2;
|
||
video.drawFrame();
|
||
assert.ok(frameUpdates > updatesBeforeFrame, 'decoded frames repaint the anchored callout');
|
||
|
||
layer.setParams({ presentation: 'scene-beat', progress: 0.2 }, { origin: 'scene' });
|
||
assert.ok(video.pauseCalls >= 1);
|
||
assert.ok(video.cancelledFrameHandles.length >= 1);
|
||
assert.equal(layer.getCinematicState().mediaEvidenceId, null);
|
||
assert.ok(eventPanel());
|
||
await layer.disable();
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
}
|
||
});
|
||
|
||
test('Debris-Dammed Lake card opens its source and is armed for approved local video autoplay', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
installEventDom();
|
||
const opened = [];
|
||
globalThis.window = {
|
||
setTimeout: () => 71,
|
||
clearTimeout() {},
|
||
open(...args) {
|
||
opened.push(args);
|
||
return { opener: 'fixture' };
|
||
},
|
||
};
|
||
const viewer = eventViewer();
|
||
let activeCard = null;
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => (
|
||
observations.map((observation) => ({ height: observation.fallbackElevationM }))
|
||
),
|
||
mediaLoader: async () => {
|
||
const error = new Error('fixture media intentionally unavailable');
|
||
error.name = 'AbortError';
|
||
throw error;
|
||
},
|
||
overlayHost: {
|
||
setEntries(_id, entries) {
|
||
activeCard = entries.find((entry) => entry.id === 'evidence-card-debris-dammed-lake');
|
||
},
|
||
setVisible() {},
|
||
clearSource() {},
|
||
hitTest(_x, _y, options) {
|
||
if (!activeCard || options?.filter?.(activeCard) === false) return null;
|
||
return { entry: activeCard };
|
||
},
|
||
},
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => 'photoreal',
|
||
getSwitchGeneration: () => 1,
|
||
async setStack() {},
|
||
});
|
||
|
||
try {
|
||
layer.setParams({
|
||
presentation: 'scene-beat',
|
||
sceneSurface: 'evidence-beat',
|
||
sceneControls: { evidenceMediaAutoplay: true },
|
||
beatId: 'debris-dammed-lake',
|
||
beatReveal: 0.36,
|
||
}, { origin: 'scene' });
|
||
await layer.enable(viewer, { origin: 'scene' });
|
||
const lease = claimPointer('draw');
|
||
try {
|
||
viewer._test.canvas.dispatch('click', { offsetX: 640, offsetY: 420 });
|
||
assert.equal(opened.length, 0, 'drawing owns the pointer over evidence cards');
|
||
} finally {
|
||
releasePointer(lease);
|
||
}
|
||
viewer._test.canvas.dispatch('click', { offsetX: 640, offsetY: 420 });
|
||
assert.deepEqual(opened, [[
|
||
event.evidenceSpine[1].media.sourceUrl,
|
||
'_blank',
|
||
'noopener,noreferrer',
|
||
]]);
|
||
assert.equal(opened.length, 1);
|
||
await layer.disable();
|
||
viewer._test.canvas.dispatch('click', { offsetX: 640, offsetY: 420 });
|
||
assert.equal(opened.length, 1, 'disabled layer releases card click ownership');
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
}
|
||
});
|
||
|
||
test('Nepal evidence shots resume the standalone callout and flood sequence from Border Gate', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const timeline = buildEvidenceTimeline(event.evidenceSpine, event.reconstruction.corridor);
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
const originalPerformance = globalThis.performance;
|
||
const originalRequestAnimationFrame = globalThis.requestAnimationFrame;
|
||
const originalCancelAnimationFrame = globalThis.cancelAnimationFrame;
|
||
installEventDom();
|
||
let now = 1000;
|
||
let nextFrameId = 0;
|
||
const frames = new Map();
|
||
const cancelledFrames = [];
|
||
globalThis.window = { setTimeout: () => 71, clearTimeout() {} };
|
||
globalThis.performance = { now: () => now };
|
||
globalThis.requestAnimationFrame = (callback) => {
|
||
const id = ++nextFrameId;
|
||
frames.set(id, callback);
|
||
return id;
|
||
};
|
||
globalThis.cancelAnimationFrame = (id) => {
|
||
cancelledFrames.push(id);
|
||
frames.delete(id);
|
||
};
|
||
const viewer = eventViewer();
|
||
let entries = [];
|
||
const embeddedCalls = [];
|
||
const holds = [];
|
||
const releases = [];
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => (
|
||
observations.map((observation) => ({ height: observation.fallbackElevationM }))
|
||
),
|
||
mediaLoader: async () => {
|
||
const error = new Error('fixture media intentionally unavailable');
|
||
error.name = 'AbortError';
|
||
throw error;
|
||
},
|
||
overlayHost: {
|
||
setEntries(_id, published) { entries = published; },
|
||
setVisible() {},
|
||
clearSource() {},
|
||
},
|
||
renderHost: {
|
||
request() {},
|
||
hold(id) { holds.push(id); },
|
||
release(id) { releases.push(id); },
|
||
},
|
||
embeddedMediaFactory: () => ({
|
||
warm(options) {
|
||
embeddedCalls.push(['warm', options?.observation?.id || null]);
|
||
return Boolean(options?.observation);
|
||
},
|
||
show(options) {
|
||
embeddedCalls.push(['show', options?.observation?.id || null]);
|
||
return false;
|
||
},
|
||
hide() { embeddedCalls.push(['hide']); },
|
||
destroy() {},
|
||
}),
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => 'photoreal',
|
||
getSwitchGeneration: () => 1,
|
||
async setStack() {},
|
||
});
|
||
const params = {
|
||
presentation: 'scene-beat',
|
||
sceneSurface: 'evidence-beat',
|
||
beatId: 'gyirong-border-gate',
|
||
beatReveal: 0.36,
|
||
sceneContext: { sceneId: 'scene', shotId: 'shot' },
|
||
sceneControls: {
|
||
evidenceSequence: true,
|
||
evidenceSequenceDurationSec: 0.9,
|
||
deferEvidenceUntilCameraSettled: true,
|
||
evidenceRevealDurationSec: 0.9,
|
||
cameraSettled: false,
|
||
},
|
||
};
|
||
|
||
try {
|
||
await layer.init(viewer);
|
||
layer.setParams(params, { origin: 'scene' });
|
||
layer.setSceneMediaPlayback({ sceneId: 'scene', shotId: 'shot', token: { cancelled: false } });
|
||
await layer.enable(viewer, { origin: 'scene' });
|
||
const card = entries.find(({ id }) => id === 'evidence-card-gyirong-border-gate');
|
||
const flood = viewer._test.floodView('bhote-koshi-flood-core');
|
||
const surge = viewer._test.floodView('bhote-koshi-surge-front');
|
||
assert.equal(card.position(), null, 'the evidence card is absent during the camera flight');
|
||
assert.equal(flood.show, false);
|
||
assert.equal(surge.show, false);
|
||
assert.ok(
|
||
embeddedCalls.some(([action, id]) => action === 'warm' && id === 'gyirong-border-gate'),
|
||
'the upcoming Border Gate provider player warms while the camera is travelling',
|
||
);
|
||
assert.equal(
|
||
embeddedCalls.some(([action]) => action === 'show'),
|
||
false,
|
||
'warming does not expose or autoplay the embedded card before camera settle',
|
||
);
|
||
|
||
layer.setParams({
|
||
...params,
|
||
sceneControls: { ...params.sceneControls, cameraSettled: true },
|
||
}, { origin: 'scene' });
|
||
assert.ok(
|
||
embeddedCalls.some(([action, id]) => action === 'show' && id === 'gyirong-border-gate'),
|
||
'camera settle promotes the warmed source into the visible callout',
|
||
);
|
||
assert.ok(card.position(), 'camera settle publishes the anchored card');
|
||
assert.equal(card.sourceAlpha(), 0, 'the card starts from a hidden reveal state');
|
||
assert.ok(holds.includes('bhote-koshi-scene-beat-reveal'));
|
||
|
||
now = 1050;
|
||
const earlyReveal = frames.get(Math.max(...frames.keys()));
|
||
frames.delete(Math.max(...frames.keys()));
|
||
earlyReveal(now);
|
||
assert.ok(card.sourceAlpha() > 0 && card.sourceAlpha() < 1);
|
||
assert.equal(flood.show, true, 'the amber corridor grows with the callout reveal');
|
||
assert.equal(surge.show, true, 'the amber surge circle advances with the corridor');
|
||
|
||
now = 1900;
|
||
const finalFrameId = Math.max(...frames.keys());
|
||
const finalFrame = frames.get(finalFrameId);
|
||
frames.delete(finalFrameId);
|
||
finalFrame(now);
|
||
assert.equal(
|
||
layer.getPlaybackState().progress,
|
||
timeline.find(({ observation }) => observation.id === 'timure-cluster').activationProgress,
|
||
'the Border Gate surge reaches the next evidence point',
|
||
);
|
||
assert.equal(card.sourceAlpha(), 0, 'the Border Gate card recedes at the next beat');
|
||
assert.ok(releases.includes('bhote-koshi-scene-beat-reveal'));
|
||
|
||
const timureBeat = timeline.find(({ observation }) => observation.id === 'timure-cluster');
|
||
layer.setParams({
|
||
presentation: 'scene-beat',
|
||
sceneSurface: 'evidence-beat',
|
||
beatId: 'timure-cluster',
|
||
beatReveal: 0.36,
|
||
sceneControls: {
|
||
imageryComparison: true,
|
||
evidenceSequence: true,
|
||
evidenceSequenceDurationSec: 4,
|
||
},
|
||
}, { origin: 'scene' });
|
||
const timureCard = entries.find(({ id }) => id === 'evidence-card-timure-cluster');
|
||
assert.equal(layer.getPlaybackState().progress, timureBeat.activationProgress);
|
||
assert.equal(timureCard.sourceAlpha(), 0, 'the next callout begins below its activation');
|
||
|
||
now = 3900;
|
||
const timureReveal = frames.get(Math.max(...frames.keys()));
|
||
frames.delete(Math.max(...frames.keys()));
|
||
timureReveal(now);
|
||
assert.ok(timureCard.sourceAlpha() > 0, 'the Timure callout enters during its authored shot');
|
||
|
||
now = 5900;
|
||
const timureFinalId = Math.max(...frames.keys());
|
||
const timureFinal = frames.get(timureFinalId);
|
||
frames.delete(timureFinalId);
|
||
timureFinal(now);
|
||
assert.equal(layer.getPlaybackState().progress, timureBeat.deactivationProgress);
|
||
assert.equal(timureCard.sourceAlpha(), 0);
|
||
await layer.disable();
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
globalThis.performance = originalPerformance;
|
||
globalThis.requestAnimationFrame = originalRequestAnimationFrame;
|
||
globalThis.cancelAnimationFrame = originalCancelAnimationFrame;
|
||
}
|
||
});
|
||
|
||
test('Bhote Koshi beat controls keep cards, flood, camera, and panel on the one clock', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const timeline = buildEvidenceTimeline(event.evidenceSpine, event.reconstruction.corridor);
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
const originalPerformance = globalThis.performance;
|
||
const originalRequestAnimationFrame = globalThis.requestAnimationFrame;
|
||
const originalCancelAnimationFrame = globalThis.cancelAnimationFrame;
|
||
const { body } = installEventDom();
|
||
const openedUrls = [];
|
||
const cancelledFrames = [];
|
||
globalThis.window = {
|
||
setTimeout: () => 71,
|
||
clearTimeout() {},
|
||
open(url) {
|
||
openedUrls.push(url);
|
||
return { opener: 'fixture' };
|
||
},
|
||
};
|
||
globalThis.performance = { now: () => 1000 };
|
||
globalThis.requestAnimationFrame = () => 91;
|
||
globalThis.cancelAnimationFrame = (id) => cancelledFrames.push(id);
|
||
const viewer = eventViewer();
|
||
const publications = [];
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => (
|
||
observations.map((observation) => ({ height: observation.fallbackElevationM }))
|
||
),
|
||
mediaLoader: async () => {
|
||
const error = new Error('fixture media intentionally unavailable');
|
||
error.name = 'AbortError';
|
||
throw error;
|
||
},
|
||
evidenceFrameFactory: (observation) => ({ fixture: observation.id }),
|
||
overlayHost: {
|
||
setEntries(id, entries, options) { publications.push({ id, entries, options }); },
|
||
setVisible() {},
|
||
clearSource() {},
|
||
},
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => 'esri-imagery',
|
||
getSwitchGeneration: () => 1,
|
||
async setStack() {},
|
||
});
|
||
|
||
try {
|
||
await layer.enable(viewer, { origin: 'local-restore' });
|
||
const panel = eventPanel();
|
||
assert.equal(panel.querySelector('[data-role="timeline-label"]').textContent, 'RECONSTRUCTION CLOCK');
|
||
const entries = publications[0].entries;
|
||
const cards = entries.filter((entry) => entry.variant === 'thumbnail');
|
||
const breadcrumbs = entries.filter((entry) => entry.variant === 'label');
|
||
const next = panel.querySelector('[data-action="next-beat"]');
|
||
const previous = panel.querySelector('[data-action="previous-beat"]');
|
||
|
||
next.dispatch('click');
|
||
assert.equal(layer.getPlaybackState().progress, timeline[1].activationProgress);
|
||
assert.equal(layer.getPlaybackState().playing, false);
|
||
assert.equal(layer.getCinematicState().active, true);
|
||
assert.match(cards.find((entry) => entry.position()).id, /debris-dammed-lake/);
|
||
assert.equal(breadcrumbs.filter((entry) => entry.position()).length, 1);
|
||
assert.equal(panel.querySelector('[data-role="beat-index"]').textContent, '02 / 16');
|
||
assert.equal(panel.querySelector('[data-role="beat-title"]').textContent, 'Dammed lake');
|
||
|
||
next.dispatch('click');
|
||
next.dispatch('click');
|
||
next.dispatch('click');
|
||
assert.equal(layer.getPlaybackState().progress, timeline[4].activationProgress);
|
||
assert.equal(layer.getCinematicState().evidenceId, 'timure-cluster');
|
||
assert.match(cards.find((entry) => entry.position()).id, /timure-cluster/);
|
||
assert.equal(breadcrumbs.filter((entry) => entry.position()).length, 4);
|
||
assert.equal(
|
||
panel.querySelector('[data-role="beat-meta"]').textContent,
|
||
'PROPAGATION / TIME UNVERIFIED / 5 SOURCES',
|
||
);
|
||
const flood = viewer._test.floodView('bhote-koshi-flood-core');
|
||
assert.ok(flood.positions.length > 1);
|
||
assert.equal(
|
||
body.children.some((element) => element.id === 'bhote-koshi-story-strap'),
|
||
false,
|
||
);
|
||
panel.querySelector('[data-action="open-source"]').dispatch('click');
|
||
assert.deepEqual(openedUrls, [timeline[4].observation.media.sourceUrl]);
|
||
panel.querySelector('[data-action="geolocation-map"]').dispatch('click');
|
||
assert.deepEqual(openedUrls, [
|
||
timeline[4].observation.media.sourceUrl,
|
||
event.geolocationMap.sourceUrl,
|
||
]);
|
||
|
||
previous.dispatch('click');
|
||
assert.equal(layer.getPlaybackState().progress, timeline[3].activationProgress);
|
||
assert.equal(layer.getCinematicState().evidenceId, 'gyirong-border-gate');
|
||
assert.equal(panel.querySelector('[data-role="beat-index"]').textContent, '04 / 16');
|
||
assert.equal(publications.length, 1, 'beat navigation never republishes overlay entries');
|
||
|
||
viewer._test.canvas.dispatch('pointerdown');
|
||
assert.equal(layer.getCinematicState().active, false);
|
||
const cameraLookCount = viewer._test.cameraLooks.length;
|
||
const progress = panel.querySelector('[data-role="progress"]');
|
||
progress.value = '500';
|
||
progress.dispatch('input');
|
||
assert.equal(layer.getCinematicState().active, false, 'manual release survives slider changes');
|
||
assert.equal(viewer._test.cameraLooks.length, cameraLookCount);
|
||
|
||
previous.dispatch('click');
|
||
assert.equal(layer.getCinematicState().active, true, 'explicit beat navigation reclaims camera');
|
||
assert.equal(layer.getCinematicState().evidenceId, 'dhunche');
|
||
panel.querySelector('[data-action="story-replay"]').dispatch('click');
|
||
assert.equal(layer.getPlaybackState().progress, 0);
|
||
assert.equal(layer.getPlaybackState().playing, true);
|
||
assert.equal(layer.getCinematicState().active, true);
|
||
assert.equal(layer.getCinematicState().evidenceId, 'immediate-collapse-viewpoint');
|
||
assert.equal(panel.querySelector('[data-role="beat-index"]').textContent, '01 / 16');
|
||
assert.equal(publications.length, 1);
|
||
|
||
await layer.disable();
|
||
assert.deepEqual(cancelledFrames, [91]);
|
||
assert.equal(viewer._test.canvas._listeners.size, 0);
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
globalThis.performance = originalPerformance;
|
||
globalThis.requestAnimationFrame = originalRequestAnimationFrame;
|
||
globalThis.cancelAnimationFrame = originalCancelAnimationFrame;
|
||
}
|
||
});
|
||
|
||
test('Bhote Koshi repeated event frames republish no panel and churn no camera', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
const originalPerformance = globalThis.performance;
|
||
const originalRequestAnimationFrame = globalThis.requestAnimationFrame;
|
||
const originalCancelAnimationFrame = globalThis.cancelAnimationFrame;
|
||
const { body } = installEventDom();
|
||
globalThis.window = { setTimeout: () => 71, clearTimeout() {} };
|
||
globalThis.performance = { now: () => 1000 };
|
||
globalThis.requestAnimationFrame = () => 93;
|
||
globalThis.cancelAnimationFrame = () => {};
|
||
const viewer = eventViewer();
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => (
|
||
observations.map((observation) => ({ height: observation.fallbackElevationM }))
|
||
),
|
||
mediaLoader: async () => {
|
||
const error = new Error('fixture media intentionally unavailable');
|
||
error.name = 'AbortError';
|
||
throw error;
|
||
},
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => 'esri-imagery',
|
||
getSwitchGeneration: () => 1,
|
||
async setStack() {},
|
||
});
|
||
|
||
try {
|
||
await layer.enable(viewer, { origin: 'local-restore' });
|
||
const panel = eventPanel();
|
||
const cinematic = panel.querySelector('[data-action="cinematic"]');
|
||
const progress = panel.querySelector('[data-role="progress"]');
|
||
cinematic.dispatch('click');
|
||
progress.value = '500';
|
||
progress.dispatch('input');
|
||
|
||
const panelStore = useBhoteKoshiPanelStore(applicationPinia());
|
||
const published = panelStore.panel;
|
||
const cameraLookCount = viewer._test.cameraLooks.length;
|
||
const floodWrites = () => viewer._test.liveFloodSets().map(({ writes }) => writes);
|
||
const drawnWrites = floodWrites();
|
||
for (let index = 0; index < 20; index += 1) progress.dispatch('input');
|
||
assert.deepEqual(floodWrites(), drawnWrites, 'unchanged frames draw no flood again');
|
||
|
||
assert.ok(panelStore.panel === published, 'unchanged frames do not republish the panel');
|
||
assert.equal(
|
||
viewer._test.cameraLooks.length,
|
||
cameraLookCount,
|
||
'unchanged progress does not reapply the cinematic camera object',
|
||
);
|
||
await layer.disable();
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
globalThis.performance = originalPerformance;
|
||
globalThis.requestAnimationFrame = originalRequestAnimationFrame;
|
||
globalThis.cancelAnimationFrame = originalCancelAnimationFrame;
|
||
}
|
||
});
|
||
|
||
test('Bhote Koshi frame path keeps evidence lookup scalar and wrapper-free', async () => {
|
||
const source = await readFile(eventModuleUrl, 'utf8');
|
||
assert.doesNotMatch(source, /#ffd166/i, 'event UI no longer publishes the prototype yellow');
|
||
assert.doesNotMatch(
|
||
source,
|
||
/function\s+activeEvidenceEntry\s*\(/,
|
||
'the event frame path must not restore an object-returning evidence wrapper',
|
||
);
|
||
assert.doesNotMatch(
|
||
source,
|
||
/return\s*\{\s*(?:index\s*,\s*observation|observation\s*,\s*index)\s*\}/,
|
||
'evidence lookup must not allocate an index/observation pair',
|
||
);
|
||
assert.match(
|
||
source,
|
||
/const beatIndex = currentEvidenceIndex\(\);\s*const sceneBeatIndex = sceneDirected\s*\? _evidenceTimeline\.findIndex\(\s*\(\{ observation: item \}\) => item\.id === _sceneBeatId,?\s*\)\s*:\s*beatIndex;\s*const observation =\s*_evidenceTimeline\[sceneBeatIndex\]\?\.observation \|\| null;/,
|
||
'syncPanel must resolve authored scene beats to one scalar index before reading the observation',
|
||
);
|
||
});
|
||
|
||
test('Bhote Koshi cinematic camera stays synchronized through pause and deterministic scrubbing', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
const originalPerformance = globalThis.performance;
|
||
const originalRequestAnimationFrame = globalThis.requestAnimationFrame;
|
||
const originalCancelAnimationFrame = globalThis.cancelAnimationFrame;
|
||
const { body } = installEventDom();
|
||
globalThis.window = { setTimeout: () => 71, clearTimeout() {} };
|
||
globalThis.performance = { now: () => 1000 };
|
||
globalThis.requestAnimationFrame = () => 33;
|
||
globalThis.cancelAnimationFrame = () => {};
|
||
const viewer = eventViewer();
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => (
|
||
observations.map((observation) => ({ height: observation.fallbackElevationM }))
|
||
),
|
||
mediaLoader: async () => {
|
||
const error = new Error('fixture media intentionally unavailable');
|
||
error.name = 'AbortError';
|
||
throw error;
|
||
},
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => 'esri-imagery',
|
||
getSwitchGeneration: () => 1,
|
||
async setStack() {},
|
||
});
|
||
|
||
try {
|
||
await layer.enable(viewer, { origin: 'local-restore' });
|
||
const panel = eventPanel();
|
||
panel.querySelector('[data-action="cinematic"]').dispatch('click');
|
||
assert.equal(layer.getCinematicState().active, true);
|
||
assert.equal(layer.getPlaybackState().playing, true);
|
||
assert.equal(viewer._test.cameraLooks.length, 1);
|
||
assert.equal(
|
||
body.children.some((element) => element.id === 'bhote-koshi-story-strap'),
|
||
false,
|
||
);
|
||
|
||
panel.querySelector('[data-action="play"]').dispatch('click');
|
||
assert.equal(layer.getPlaybackState().playing, false);
|
||
const progress = panel.querySelector('[data-role="progress"]');
|
||
progress.value = '500';
|
||
progress.dispatch('input');
|
||
const firstPose = viewer._test.cameraLooks.at(-1);
|
||
progress.dispatch('input');
|
||
assert.deepEqual(viewer._test.cameraLooks.at(-1), firstPose);
|
||
assert.deepEqual(layer.getCinematicState(), {
|
||
active: true,
|
||
progress: 0.5,
|
||
evidenceId: 'mailung-upper-trishuli',
|
||
mediaReady: false,
|
||
mediaEvidenceId: null,
|
||
});
|
||
|
||
viewer._test.canvas.dispatch('pointerdown');
|
||
assert.equal(layer.getCinematicState().active, false);
|
||
assert.equal(viewer._test.cameraTransforms.length, 1);
|
||
await layer.disable();
|
||
assert.equal(viewer._test.canvas._listeners.size, 0);
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
globalThis.performance = originalPerformance;
|
||
globalThis.requestAnimationFrame = originalRequestAnimationFrame;
|
||
globalThis.cancelAnimationFrame = originalCancelAnimationFrame;
|
||
}
|
||
});
|
||
|
||
test('Bhote Koshi replay restores cinematic ownership unless the operator released it', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
const originalPerformance = globalThis.performance;
|
||
const originalRequestAnimationFrame = globalThis.requestAnimationFrame;
|
||
const originalCancelAnimationFrame = globalThis.cancelAnimationFrame;
|
||
const { body } = installEventDom();
|
||
const animationCallbacks = [];
|
||
const cancelledFrames = [];
|
||
const releases = [];
|
||
globalThis.window = { setTimeout: () => 71, clearTimeout() {} };
|
||
globalThis.performance = { now: () => 1000 };
|
||
globalThis.requestAnimationFrame = (callback) => {
|
||
animationCallbacks.push(callback);
|
||
return animationCallbacks.length;
|
||
};
|
||
globalThis.cancelAnimationFrame = (id) => cancelledFrames.push(id);
|
||
const viewer = eventViewer();
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => (
|
||
observations.map((observation) => ({ height: observation.fallbackElevationM }))
|
||
),
|
||
mediaLoader: async () => {
|
||
const error = new Error('fixture media intentionally unavailable');
|
||
error.name = 'AbortError';
|
||
throw error;
|
||
},
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: {
|
||
request() {},
|
||
hold() {},
|
||
release(id) { releases.push(id); },
|
||
},
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => 'esri-imagery',
|
||
getSwitchGeneration: () => 1,
|
||
async setStack() {},
|
||
});
|
||
|
||
try {
|
||
await layer.enable(viewer, { origin: 'local-restore' });
|
||
const panel = eventPanel();
|
||
panel.querySelector('[data-action="cinematic"]').dispatch('click');
|
||
animationCallbacks[0](91001);
|
||
assert.equal(layer.getPlaybackState().progress, 1);
|
||
assert.equal(layer.getPlaybackState().playing, false);
|
||
assert.equal(layer.getCinematicState().active, false);
|
||
assert.equal(viewer._test.cameraTransforms.length, 1);
|
||
assert.deepEqual(releases, ['bhote-koshi-playback']);
|
||
const play = panel.querySelector('[data-action="play"]');
|
||
assert.equal(play.textContent, '↺ REPLAY CINEMATIC');
|
||
|
||
play.dispatch('click');
|
||
assert.equal(layer.getCinematicState().active, true);
|
||
assert.equal(layer.getPlaybackState().progress, 0);
|
||
assert.equal(layer.getPlaybackState().playing, true);
|
||
assert.equal(
|
||
body.children.some((element) => element.id === 'bhote-koshi-story-strap'),
|
||
false,
|
||
);
|
||
|
||
panel.querySelector('[data-action="cinematic"]').dispatch('click');
|
||
assert.equal(layer.getCinematicState().active, false);
|
||
assert.equal(viewer._test.cameraTransforms.length, 2);
|
||
animationCallbacks[1](91001);
|
||
assert.equal(play.textContent, '↺ REPLAY');
|
||
const cameraLookCount = viewer._test.cameraLooks.length;
|
||
play.dispatch('click');
|
||
assert.equal(layer.getPlaybackState().playing, true);
|
||
assert.equal(layer.getCinematicState().active, false);
|
||
assert.equal(viewer._test.cameraLooks.length, cameraLookCount);
|
||
|
||
await layer.disable();
|
||
assert.equal(layer.getCinematicState().active, false);
|
||
assert.equal(viewer._test.cameraTransforms.length, 2);
|
||
assert.deepEqual(cancelledFrames, [1, 2, 3]);
|
||
assert.equal(viewer._test.canvas._listeners.size, 0);
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
globalThis.performance = originalPerformance;
|
||
globalThis.requestAnimationFrame = originalRequestAnimationFrame;
|
||
globalThis.cancelAnimationFrame = originalCancelAnimationFrame;
|
||
}
|
||
});
|
||
|
||
test('Bhote Koshi closes a poster that resolves after disable', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
event.evidenceSpine = event.evidenceSpine.slice(0, 1);
|
||
event.evidenceSpine[0].media.posterPath = 'evidence-09.jpg';
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
installEventDom();
|
||
globalThis.window = { setTimeout: () => 71, clearTimeout() {} };
|
||
const viewer = eventViewer();
|
||
let resolvePoster;
|
||
const poster = { closed: false, close() { this.closed = true; } };
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async () => [{ height: 2800 }],
|
||
mediaLoader: async (url) => {
|
||
assert.equal(url, '/events/bhote-koshi-2026/evidence-09.jpg');
|
||
return new Promise((resolve) => { resolvePoster = resolve; });
|
||
},
|
||
evidenceFrameFactory: (observation) => ({ fixture: observation.id }),
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
layer.attachMapStackController({
|
||
getActiveId: () => 'esri-imagery',
|
||
getSwitchGeneration: () => 1,
|
||
async setStack() {},
|
||
});
|
||
|
||
try {
|
||
await layer.enable(viewer, { origin: 'local-restore' });
|
||
await layer.disable();
|
||
resolvePoster(poster);
|
||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||
assert.equal(poster.closed, true);
|
||
} finally {
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
}
|
||
});
|
||
|
||
test('every sourced shot grows its tail with its head, keeps its own card, and clears on exit', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originals = Object.fromEntries(['document', 'window', 'performance', 'requestAnimationFrame', 'cancelAnimationFrame']
|
||
.map((key) => [key, globalThis[key]]));
|
||
installEventDom();
|
||
let now = 1000;
|
||
let nextFrame = 0;
|
||
const frames = new Map();
|
||
globalThis.window = { setTimeout: () => 71, clearTimeout() {} };
|
||
globalThis.performance = { now: () => now };
|
||
globalThis.requestAnimationFrame = (callback) => { frames.set(++nextFrame, callback); return nextFrame; };
|
||
globalThis.cancelAnimationFrame = (id) => frames.delete(id);
|
||
let heightSamples = 0;
|
||
let surfaceHeight = 1500;
|
||
const viewer = eventViewer(0.37, {
|
||
query: { sampleHeightNow: () => { heightSamples++; return surfaceHeight; } },
|
||
});
|
||
let entries = [];
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async () => null,
|
||
mediaLoader: async () => { throw Object.assign(new Error('fixture'), { name: 'AbortError' }); },
|
||
overlayHost: { setEntries(_id, value) { entries = value; }, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
layer.attachMapStackController({ getActiveId: () => 'photoreal', getSwitchGeneration: () => 1 });
|
||
const params = (beatId, cameraSettled, evidencePath = 'source', evidencePathElevation = null) => ({
|
||
presentation: 'scene-beat', sceneSurface: 'evidence-beat', beatId,
|
||
sceneControls: { cameraSettled, evidencePath, evidencePathElevation, evidencePathDurationSec: 4,
|
||
deferEvidenceUntilCameraSettled: true, evidenceHoldCard: true },
|
||
});
|
||
const advance = (elapsed) => {
|
||
const callback = frames.get(nextFrame);
|
||
frames.delete(nextFrame);
|
||
callback(now + elapsed);
|
||
};
|
||
try {
|
||
layer.setParams(params(SOURCE_PATH_BEAT_IDS[0], false));
|
||
await layer.enable(viewer, { origin: 'scene' });
|
||
const flood = viewer._test.floodView('bhote-koshi-flood-core');
|
||
const surge = viewer._test.floodView('bhote-koshi-surge-front');
|
||
for (const id of SOURCE_PATH_BEAT_IDS) {
|
||
layer.setParams(params(id, false));
|
||
assert.equal(flood.show, false, `${id}: hide the previous route during flight`);
|
||
assert.equal(surge.show, false);
|
||
layer.setParams(params(id, true));
|
||
const sampleCount = heightSamples;
|
||
assert.ok(sampleCount > 0, 'surface heights are sampled while preparing the shot');
|
||
let previousLength = 0;
|
||
for (const elapsed of [400, 1800, 4000]) {
|
||
advance(elapsed);
|
||
const points = flood.positions;
|
||
assert.ok(points.length >= previousLength);
|
||
assert.equal(flood.show, true);
|
||
assert.equal(surge.show, true);
|
||
assert.ok(Cesium.Cartesian3.equals(points.at(-1), surge.position), `${id}: tail must reach head in every frame`);
|
||
previousLength = points.length;
|
||
}
|
||
assert.equal(heightSamples, sampleCount, 'do not resample geometry during motion');
|
||
const visibleCards = entries.filter((entry) => entry.id.startsWith('evidence-card-') && entry.position());
|
||
assert.deepEqual(visibleCards.map(({ id: cardId }) => cardId), [`evidence-card-${id}`]);
|
||
assert.ok(visibleCards[0].sourceAlpha() > 0, 'keep the source readable after the path settles');
|
||
now += 5000;
|
||
}
|
||
// A settled-to-settled entry must not paint the last shot's completed
|
||
// progress on the new route for a frame, then jump back to its start.
|
||
layer.setParams(params('dhunche', true));
|
||
assert.equal(flood.show, false, 'new shot clears its tail before the first animation frame');
|
||
assert.equal(surge.show, false);
|
||
advance(1800);
|
||
const headBeforeSync = Cesium.Cartesian3.clone(surge.position);
|
||
const frameBeforeSync = nextFrame;
|
||
layer.setParams(params('dhunche', true));
|
||
assert.equal(nextFrame, frameBeforeSync, 'repeated settled notification does not restart the reveal');
|
||
assert.ok(Cesium.Cartesian3.equals(headBeforeSync, surge.position));
|
||
advance(2200);
|
||
assert.ok(!Cesium.Cartesian3.equals(headBeforeSync, surge.position));
|
||
// The comparison exit can expose coarse photogrammetry samples a kilometre
|
||
// above the river. Dhunche's schematic profile must not dive through them.
|
||
surfaceHeight = 2703;
|
||
layer.setParams(params('dhunche', false, 'source', 'source'));
|
||
const samplesBeforeProfile = heightSamples;
|
||
layer.setParams(params('dhunche', true, 'source', 'source'));
|
||
for (const elapsed of [40, 400, 1800, 4000]) {
|
||
advance(elapsed);
|
||
const points = flood.positions;
|
||
for (const position of points) {
|
||
const height = Cesium.Cartographic.fromCartesian(position).height;
|
||
assert.ok(height >= 1307 && height <= 1332, `source profile stays near river elevation, got ${height}`);
|
||
}
|
||
assert.ok(Cesium.Cartesian3.equals(points.at(-1), surge.position));
|
||
}
|
||
assert.equal(heightSamples, samplesBeforeProfile, 'source elevation does not sample the changing mesh');
|
||
layer.setParams(params('charaudi', false, 'none'));
|
||
layer.setParams(params('charaudi', true, 'none'));
|
||
advance(1000);
|
||
assert.equal(flood.show, false);
|
||
assert.equal(surge.show, false);
|
||
await layer.disable();
|
||
assert.equal(frames.size, 0);
|
||
} finally {
|
||
for (const [key, value] of Object.entries(originals)) globalThis[key] = value;
|
||
}
|
||
});
|
||
|
||
test('media-led upper-valley shots retain only their upstream prefix during camera travel', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originals = Object.fromEntries(['document', 'window', 'performance', 'requestAnimationFrame', 'cancelAnimationFrame']
|
||
.map((key) => [key, globalThis[key]]));
|
||
installEventDom();
|
||
let now = 1000;
|
||
let nextFrame = 0;
|
||
const frames = new Map();
|
||
globalThis.window = { setTimeout: () => 71, clearTimeout() {} };
|
||
globalThis.performance = { now: () => now };
|
||
globalThis.requestAnimationFrame = callback => { frames.set(++nextFrame, callback); return nextFrame; };
|
||
globalThis.cancelAnimationFrame = id => frames.delete(id);
|
||
const viewer = eventViewer();
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async url => ({ url }),
|
||
terrainSampler: async () => null,
|
||
mediaLoader: async () => { throw Object.assign(new Error('fixture'), { name: 'AbortError' }); },
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
layer.attachMapStackController({ getActiveId: () => 'esri-imagery', getSwitchGeneration: () => 1 });
|
||
const params = (beatId, cameraSettled, extras = {}) => ({
|
||
presentation: 'scene-beat', sceneSurface: 'evidence-beat', beatId,
|
||
sceneControls: {
|
||
evidencePath: 'source', evidencePathHistory: true, evidencePathPersistent: true,
|
||
evidencePathDuringMedia: true, evidencePathDurationSec: 4.8,
|
||
deferEvidenceUntilCameraSettled: true, evidenceHoldCard: true,
|
||
cameraSettled, ...extras,
|
||
},
|
||
});
|
||
const finishReveal = () => {
|
||
now += 7000;
|
||
const callback = frames.get(nextFrame);
|
||
frames.delete(nextFrame);
|
||
callback(now);
|
||
};
|
||
try {
|
||
layer.setParams(params('debris-dammed-lake', false));
|
||
await layer.enable(viewer, { origin: 'scene' });
|
||
const flood = viewer._test.floodView('bhote-koshi-flood-core');
|
||
const surge = viewer._test.floodView('bhote-koshi-surge-front');
|
||
layer.setParams(params('debris-dammed-lake', true));
|
||
finishReveal();
|
||
const lakeTail = flood.positions.map(({ x, y, z }) => ({ x, y, z }));
|
||
assert.ok(lakeTail.length > 1);
|
||
const origin = Cesium.Cartographic.fromCartesian(lakeTail[0]);
|
||
assert.ok(Math.abs(Cesium.Math.toDegrees(origin.longitude) - 85.48476) < 1e-6);
|
||
assert.ok(Math.abs(Cesium.Math.toDegrees(origin.latitude) - 28.33255) < 1e-6,
|
||
'the rendered trail starts at the lake reach, not the earlier trigger reach');
|
||
layer.setParams(params('second-landslide', false));
|
||
assert.equal(flood.show, true, 'lake trail survives departure before the next camera settles');
|
||
assert.deepEqual(flood.positions, lakeTail, 'retain the prefix without revealing the next segment');
|
||
assert.ok(Cesium.Cartesian3.equals(surge.position, lakeTail.at(-1)));
|
||
layer.setParams(params('second-landslide', true));
|
||
assert.deepEqual(flood.positions, lakeTail, 'arrival does not clear the prefix');
|
||
finishReveal();
|
||
assert.ok(flood.positions.length > lakeTail.length);
|
||
layer.setParams(params('debris-dammed-lake', false));
|
||
assert.equal(flood.show, false, 'backward replay trims future segments instead of retaining stale history');
|
||
layer.setParams(params('second-landslide', false));
|
||
assert.deepEqual(flood.positions, lakeTail, 'direct load reconstructs the same prefix');
|
||
layer.setParams(params('second-landslide', false, { evidencePathPersistent: false }));
|
||
assert.equal(flood.show, false, 'nonpersistent shots retain their arrival gate');
|
||
for (const beatId of ['devighat-taadi-khola-bridge', 'charaudi', 'final-view']) {
|
||
const historyControls = {
|
||
evidencePath: 'history', evidencePathHistoryBeatId: SOURCE_PATH_BEAT_IDS.at(-1),
|
||
evidencePathDuringMedia: false, evidenceMediaAutoplay: beatId !== 'final-view',
|
||
};
|
||
layer.setParams(params(beatId, false, historyControls));
|
||
const completedTail = [...flood.positions];
|
||
assert.ok(completedTail.length > 100, `${beatId}: direct load reconstructs full sourced history`);
|
||
layer.setParams(params(beatId, true, historyControls));
|
||
assert.deepEqual(flood.positions, completedTail,
|
||
`${beatId}: arrival must not reset the completed history`);
|
||
finishReveal();
|
||
assert.deepEqual(flood.positions, completedTail,
|
||
`${beatId}: media/card reveal must not erase or regrow completed history`);
|
||
}
|
||
await layer.disable();
|
||
assert.equal(frames.size, 0);
|
||
} finally {
|
||
for (const [key, value] of Object.entries(originals)) globalThis[key] = value;
|
||
}
|
||
});
|
||
|
||
test('camera-led Nepal flood motion preserves its prefix and stays ahead of shot travel', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originals = Object.fromEntries(['document', 'window', 'performance', 'requestAnimationFrame', 'cancelAnimationFrame']
|
||
.map((key) => [key, globalThis[key]]));
|
||
installEventDom();
|
||
let now = 1000;
|
||
let nextFrame = 0;
|
||
let nextTimer = 0;
|
||
const frames = new Map();
|
||
const timers = new Map();
|
||
const holds = [];
|
||
const releases = [];
|
||
globalThis.window = {
|
||
setTimeout(callback, delay) {
|
||
const id = ++nextTimer;
|
||
timers.set(id, { callback, delay });
|
||
return id;
|
||
},
|
||
clearTimeout(id) { timers.delete(id); },
|
||
};
|
||
globalThis.performance = { now: () => now };
|
||
globalThis.requestAnimationFrame = (callback) => { frames.set(++nextFrame, callback); return nextFrame; };
|
||
globalThis.cancelAnimationFrame = (id) => frames.delete(id);
|
||
const viewer = eventViewer();
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async () => null,
|
||
mediaLoader: async () => { throw Object.assign(new Error('fixture'), { name: 'AbortError' }); },
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: {
|
||
request() {},
|
||
hold(id) { holds.push(id); },
|
||
release(id) { releases.push(id); },
|
||
},
|
||
});
|
||
layer.attachMapStackController({ getActiveId: () => 'photoreal', getSwitchGeneration: () => 1 });
|
||
const travel = (id, durationSec = 4.2, overrides = {}) => ({
|
||
id, durationSec, active: true, completed: false, cancelled: false, ...overrides,
|
||
});
|
||
const params = (beatId, evidencePath, cameraTravel, extras = {}) => ({
|
||
presentation: 'scene-beat',
|
||
sceneSurface: 'evidence-beat',
|
||
beatId,
|
||
sceneControls: {
|
||
evidencePath,
|
||
evidencePathDuringCamera: true,
|
||
evidencePathPersistent: true,
|
||
deferEvidenceUntilCameraSettled: true,
|
||
cameraSettled: false,
|
||
cameraTravel,
|
||
...extras,
|
||
},
|
||
});
|
||
const advance = (elapsed) => {
|
||
now += elapsed;
|
||
const id = Math.max(...frames.keys());
|
||
const callback = frames.get(id);
|
||
frames.delete(id);
|
||
assert.equal(typeof callback, 'function');
|
||
callback(now);
|
||
};
|
||
|
||
try {
|
||
layer.setParams(params('timure-cluster', 'comparison', travel(1), {
|
||
evidenceSequence: true,
|
||
}));
|
||
await layer.enable(viewer, { origin: 'scene' });
|
||
let flood = viewer._test.floodView('bhote-koshi-flood-core');
|
||
let surge = viewer._test.floodView('bhote-koshi-surge-front');
|
||
const timureStart = flood.positions.length;
|
||
assert.ok(timureStart > 1, 'the completed Border Gate prefix is already visible during travel');
|
||
assert.equal(surge.show, true);
|
||
advance(420);
|
||
const earlyTimureLength = flood.positions.length;
|
||
assert.ok(earlyTimureLength > timureStart,
|
||
'the trail leads during the opening tenth of camera travel instead of waiting for arrival');
|
||
advance(2880);
|
||
const timureEnd = flood.positions.length;
|
||
assert.ok(timureEnd > timureStart);
|
||
assert.equal(flood.show, true, 'the completed tail remains visible at the next point');
|
||
assert.ok(Cesium.Cartesian3.equals(flood.positions.at(-1), surge.position));
|
||
|
||
layer.setParams(params('syabru-besi', 'comparison', travel(2), {
|
||
evidenceSequence: true,
|
||
}));
|
||
assert.ok(flood.positions.length >= timureEnd,
|
||
'the Timure segment remains painted when Syabru travel starts');
|
||
advance(3300);
|
||
assert.equal(surge.show, true, 'the amber head remains visible at comparison completion');
|
||
assert.ok(Cesium.Cartesian3.equals(flood.positions.at(-1), surge.position));
|
||
|
||
layer.setParams(params('dhunche', 'source', travel(3), {
|
||
evidencePathHistory: true,
|
||
evidencePathElevation: 'source',
|
||
evidenceHoldCard: true,
|
||
}));
|
||
flood = viewer._test.floodView('bhote-koshi-flood-core');
|
||
surge = viewer._test.floodView('bhote-koshi-surge-front');
|
||
const dhuncheStart = flood.positions.length;
|
||
assert.ok(dhuncheStart >= event.reconstruction.corridor.length,
|
||
'the comparison corridor survives the transition onto Google photogrammetry');
|
||
advance(3300);
|
||
const dhuncheEnd = flood.positions.length;
|
||
assert.ok(dhuncheEnd > dhuncheStart);
|
||
assert.equal(surge.show, true);
|
||
|
||
layer.setParams(params('mailung-upper-trishuli', 'source', travel(4), {
|
||
evidencePathHistory: true,
|
||
evidencePathElevation: 'source',
|
||
evidenceHoldCard: true,
|
||
}));
|
||
assert.ok(flood.positions.length >= dhuncheEnd,
|
||
'the completed Dhunche segment never disappears');
|
||
advance(900);
|
||
const frozenHead = Cesium.Cartesian3.clone(surge.position);
|
||
const frozenLength = flood.positions.length;
|
||
layer.setParams(params('mailung-upper-trishuli', 'source', travel(4, 4.2, {
|
||
active: false, cancelled: true,
|
||
}), {
|
||
evidencePathHistory: true,
|
||
evidencePathElevation: 'source',
|
||
evidenceHoldCard: true,
|
||
}));
|
||
assert.equal(frames.size, 0, 'cancelling camera travel revokes the path animation frame');
|
||
assert.equal(flood.positions.length, frozenLength);
|
||
assert.ok(Cesium.Cartesian3.equals(surge.position, frozenHead));
|
||
assert.ok(holds.includes('bhote-koshi-scene-path-travel'));
|
||
assert.ok(releases.includes('bhote-koshi-scene-path-travel'));
|
||
|
||
let previousCompleteLength = dhuncheEnd;
|
||
let travelId = 5;
|
||
for (const beatId of SOURCE_PATH_BEAT_IDS.slice(3)) {
|
||
layer.setParams(params(beatId, 'source', travel(travelId++), {
|
||
evidencePathHistory: true,
|
||
evidencePathElevation: 'source',
|
||
evidenceHoldCard: true,
|
||
}));
|
||
const startLength = flood.positions.length;
|
||
assert.ok(startLength >= previousCompleteLength,
|
||
`${beatId} retains every completed upstream segment while travel begins`);
|
||
advance(3300);
|
||
const completeLength = flood.positions.length;
|
||
assert.ok(completeLength > startLength, `${beatId} grows its own segment during travel`);
|
||
assert.equal(flood.show, true);
|
||
assert.equal(surge.show, true);
|
||
assert.ok(Cesium.Cartesian3.equals(
|
||
flood.positions.at(-1), surge.position,
|
||
));
|
||
previousCompleteLength = completeLength;
|
||
}
|
||
const bidurCompleteLength = previousCompleteLength;
|
||
|
||
// Direct entry must reconstruct its supported prefix without relying on
|
||
// earlier playback, while backward navigation must trim later segments.
|
||
layer.setParams({
|
||
presentation: 'scene-beat', sceneSurface: 'evidence-beat', beatId: 'devighat-taadi-khola-bridge',
|
||
sceneControls: { evidencePath: 'none', deferEvidenceUntilCameraSettled: true, cameraSettled: false },
|
||
});
|
||
assert.equal(flood.show, false, 'Devighat does not leak the supported route');
|
||
assert.equal(surge.show, false);
|
||
layer.setParams(params('bidur-trishuli-bridge', 'source', travel(travelId++), {
|
||
evidencePathHistory: true,
|
||
evidencePathElevation: 'source',
|
||
evidenceHoldCard: true,
|
||
}));
|
||
assert.ok(flood.positions.length > dhuncheEnd,
|
||
'a direct Bidur load reconstructs its complete upstream prefix');
|
||
advance(3300);
|
||
assert.equal(flood.positions.length, bidurCompleteLength);
|
||
|
||
layer.setParams(params('dhunche', 'source', travel(travelId++), {
|
||
evidencePathHistory: true,
|
||
evidencePathElevation: 'source',
|
||
evidenceHoldCard: true,
|
||
}));
|
||
assert.ok(flood.positions.length < bidurCompleteLength,
|
||
'backward navigation trims unsupported downstream history immediately');
|
||
advance(3300);
|
||
assert.equal(flood.positions.length, dhuncheEnd);
|
||
|
||
// The deadline is independent of RAF, so a throttled render loop still
|
||
// completes the active segment before the camera's longer flight ends.
|
||
layer.setParams(params('mailung-upper-trishuli', 'source', travel(travelId++), {
|
||
evidencePathHistory: true,
|
||
evidencePathElevation: 'source',
|
||
evidenceHoldCard: true,
|
||
}));
|
||
const deadlineEntry = [...timers.entries()].find(([, entry]) => entry.delay >= 2400);
|
||
assert.ok(deadlineEntry, 'camera-led travel registers a pre-arrival completion deadline');
|
||
now += deadlineEntry[1].delay;
|
||
deadlineEntry[1].callback();
|
||
assert.equal(frames.size, 0, 'the deadline cancels a stalled animation frame');
|
||
assert.ok(flood.positions.length > dhuncheEnd);
|
||
|
||
layer.setParams({
|
||
presentation: 'scene-beat', sceneSurface: 'evidence-beat', beatId: 'charaudi',
|
||
sceneControls: { evidencePath: 'none', deferEvidenceUntilCameraSettled: true, cameraSettled: false },
|
||
});
|
||
assert.equal(flood.show, false, 'unsupported downstream shots do not invent or leak a route');
|
||
assert.equal(surge.show, false);
|
||
await layer.disable();
|
||
} finally {
|
||
for (const [key, value] of Object.entries(originals)) globalThis[key] = value;
|
||
}
|
||
});
|
||
|
||
test('Bhote Koshi corridor remains ordered downstream and inside the imagery rectangle', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const { west, south, east, north } = event.imagery.rectangle;
|
||
let priorChainage = Number.NEGATIVE_INFINITY;
|
||
for (const point of event.reconstruction.corridor) {
|
||
assert.ok(point.chainageM > priorChainage);
|
||
assert.ok(point.lon >= west && point.lon <= east);
|
||
assert.ok(point.lat >= south && point.lat <= north);
|
||
priorChainage = point.chainageM;
|
||
}
|
||
});
|
||
|
||
test('an evidence point whose terrain sample misses sits at its fallback elevation, not sea level', async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
installEventDom();
|
||
globalThis.window = { setTimeout: () => 71, clearTimeout() {} };
|
||
const viewer = eventViewer();
|
||
const publications = [];
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
terrainSampler: async (_viewer, observations) => observations.map(() => ({ height: null })),
|
||
mediaLoader: async () => {
|
||
const error = new Error('fixture media intentionally unavailable');
|
||
error.name = 'AbortError';
|
||
throw error;
|
||
},
|
||
overlayHost: { setEntries(_source, entries) { publications.push(entries); }, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
try {
|
||
layer.setParams({
|
||
presentation: 'scene-beat',
|
||
sceneSurface: 'evidence-beat',
|
||
beatId: 'gyirong-border-gate',
|
||
}, { origin: 'scene' });
|
||
await layer.enable(viewer, { origin: 'scene' });
|
||
const card = publications.at(-1).find((entry) => entry.id === 'evidence-card-gyirong-border-gate');
|
||
const fallback = event.evidenceSpine.find(({ id }) => id === 'gyirong-border-gate').fallbackElevationM;
|
||
assert.ok(fallback > 100, 'the fixture has a real fallback elevation');
|
||
const height = Cesium.Cartographic.fromCartesian(card.position()).height;
|
||
assert.ok(Math.abs(height - (fallback + 18)) < 1, `card at ${height} m`);
|
||
await layer.disable();
|
||
} finally {
|
||
await layer.destroy();
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
}
|
||
});
|
||
|
||
for (const [source, expected] of [['terrain', 'sampled'], ['ellipsoid', 'fallback']]) {
|
||
test(`the default terrain sampler places an evidence point at a ${source} answer's ${expected} height`, async () => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
installEventDom();
|
||
globalThis.window = { setTimeout: () => 71, clearTimeout() {} };
|
||
const asked = [];
|
||
const query = {
|
||
async sampleHeight(points, options) {
|
||
asked.push(options);
|
||
return points.map(() => ({ height: 1234, source, confidence: 1, lod: 'finest' }));
|
||
},
|
||
};
|
||
const viewer = eventViewer(0.37, { query });
|
||
const publications = [];
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
imagerySpecFactory: async (url) => ({ url }),
|
||
mediaLoader: async () => {
|
||
const error = new Error('fixture media intentionally unavailable');
|
||
error.name = 'AbortError';
|
||
throw error;
|
||
},
|
||
overlayHost: { setEntries(_source, entries) { publications.push(entries); }, setVisible() {}, clearSource() {} },
|
||
renderHost: { request() {}, hold() {}, release() {} },
|
||
});
|
||
try {
|
||
layer.setParams({
|
||
presentation: 'scene-beat',
|
||
sceneSurface: 'evidence-beat',
|
||
beatId: 'gyirong-border-gate',
|
||
}, { origin: 'scene' });
|
||
await layer.enable(viewer, { origin: 'scene' });
|
||
assert.deepEqual(asked, [{ against: 'terrain', mostDetailed: true }]);
|
||
const card = publications.at(-1).find((entry) => entry.id === 'evidence-card-gyirong-border-gate');
|
||
const fallback = event.evidenceSpine.find(({ id }) => id === 'gyirong-border-gate').fallbackElevationM;
|
||
const height = Cesium.Cartographic.fromCartesian(card.position()).height;
|
||
const want = (expected === 'sampled' ? 1234 : fallback) + 18;
|
||
assert.ok(Math.abs(height - want) < 1, `card at ${height} m, not ${want} m`);
|
||
await layer.disable();
|
||
} finally {
|
||
await layer.destroy();
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
}
|
||
});
|
||
}
|
||
|
||
test('an event image that fails to load takes the comparison down, not the event', async (t) => {
|
||
const event = JSON.parse(await readFile(eventUrl, 'utf8'));
|
||
const originalDocument = globalThis.document;
|
||
const originalWindow = globalThis.window;
|
||
installEventDom();
|
||
globalThis.window = { setTimeout: () => 71, clearTimeout() {} };
|
||
const warn = t.mock.method(console, 'warn', () => {});
|
||
const viewer = eventViewer();
|
||
const renders = [];
|
||
const layer = createBhoteKoshiEventLayer({
|
||
eventLoader: async () => event,
|
||
embeddedMediaFactory: () => ({ show() {}, hide() {}, pause() {}, destroy() {} }),
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
renderHost: { request(reason) { renders.push(reason); }, hold() {}, release() {} },
|
||
});
|
||
try {
|
||
layer.setParams({ progress: 0.4 }, { origin: 'local-restore' });
|
||
assert.equal(await layer.enable(viewer), true);
|
||
const [before, after] = viewer._test.imagery;
|
||
assert.equal(before.spec.kind, 'single-image', 'the default spec is one image');
|
||
assert.deepEqual(Object.keys(before.spec.rectangle).sort(), ['east', 'north', 'south', 'west']);
|
||
assert.equal(before.spec.credit.text, 'Vantor WorldView Open Data · CC BY-NC 4.0');
|
||
assert.deepEqual(viewer._test.globe.layers, [before, after], 'the pair goes on top, before under after');
|
||
assert.equal(eventSplit().view.hidden, false);
|
||
assert.equal(eventPanel().querySelector('[data-role="imagery-comparison"]').hidden, false);
|
||
|
||
after.fail({ tile: { x: 0, y: 0, level: 0 }, status: 404 });
|
||
assert.ok(before.removed && after.removed, 'neither image is left to compare');
|
||
assert.equal(eventSplit().view.hidden, true);
|
||
assert.equal(eventPanel().querySelector('[data-role="imagery-comparison"]').hidden, true);
|
||
assert.equal(layer.getPlaybackState().enabled, true, 'the event itself stays on');
|
||
assert.ok(renders.includes('bhote-koshi-imagery-failed'));
|
||
assert.equal(warn.mock.callCount(), 1);
|
||
before.fail({ tile: { x: 0, y: 0, level: 0 } });
|
||
assert.equal(warn.mock.callCount(), 1, 'a removed layer reports nothing more');
|
||
|
||
await layer.disable();
|
||
assert.equal(await layer.enable(viewer), true);
|
||
assert.equal(viewer._test.globe.layers.length, 2, 'the next enable tries the images again');
|
||
assert.equal(eventSplit().view.hidden, false);
|
||
await layer.disable();
|
||
} finally {
|
||
await layer.destroy();
|
||
globalThis.document = originalDocument;
|
||
globalThis.window = originalWindow;
|
||
}
|
||
});
|