mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
3151 lines
131 KiB
JavaScript
3151 lines
131 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 } 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('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;
|
|
}
|
|
});
|