import { bindFakeCesiumCamera } from '../testSupport/fakeCameraPort.mjs'; import { rendererOf } from '../render/rendererOf.js'; import { readShellSource } from '../testSupport/readShellSource.mjs'; import { useStatusStore } from '../ui/stores/status.js'; import { applicationPinia } from '../ui/vueRuntime.js'; // Director-level pins for scene playback. // // scenePolicy.test.mjs pins the pure decisions; these pin the wiring, which is // where every regression in this file's history actually lived: the reconcile // walking the whole registry, captured tracking params handing the camera back // to the follow loop, a refused enable reported as success, STOP landing layer // changes after the operator stopped, and a stale LOAD completing last. // // The cancellation pins matter twice over: checking a boolean AFTER an await // only stops the NEXT step, so the awaited operation itself has to be // cancellable — an AbortSignal for the data manager, a liveness predicate for // the visual commit. Several of these assert exactly that plumbing. import assert from 'node:assert/strict'; import test from 'node:test'; import { LayerLifecycle } from '../data/lifecycle.js'; import { SceneDirector } from './director.js'; import { stringifySceneDocument, validateSceneDocument, } from '../director/document.js'; import { SCENE_TRACKING_PARAM_KEYS } from './scenePolicy.js'; import { SCENE_APPEND_RECIPES, SCENE_RECIPES, getSceneAppendRecipeById, } from './recipes.js'; import { STORY_TAGS } from './storyTags.js'; const NEPAL_ORIGINAL_SHOT_TITLES = [ 'Global Incident Context', 'Nepal-Focused Globe Rotation', 'Bhote Koshi Regional Approach', 'Bhote Koshi Nearby Cities', 'Bhote Koshi Incident Corridor', 'Bhote Koshi Flood Path', 'Bhote Koshi Corridor Overview', 'Bhote Koshi Upper Valley', ]; function nepalProjectFixture() { const project = structuredClone(PROJECT_FIXTURE); project.scenes[0].title = 'Nepal Flood Incident'; project.scenes[0].shots = NEPAL_ORIGINAL_SHOT_TITLES.map((title, index) => ({ ...structuredClone(PROJECT_FIXTURE.scenes[0].shots[index % 2]), id: `nepal-original-${index + 1}`, title, camera: { lat: 27 + index / 10, lon: 85 + index / 10, alt: 1000 + index * 100, heading: index * 10, pitch: -35 - index, roll: 0, }, visual: { ...structuredClone(PROJECT_FIXTURE.scenes[0].shots[index % 2].visual), mapStack: 'photoreal', }, layers: { ...structuredClone(PROJECT_FIXTURE.scenes[0].shots[index % 2].layers), 'bhote-koshi-locator': { enabled: index > 0, params: { presentation: `fixture-${index + 1}` }, }, }, })); project.scenes[0].shots[7].layers['bhote-koshi-locator'] = { enabled: true, params: { presentation: 'bhote-koshi-trigger-record' }, }; project.scenes[0].shots[7].holdSec = 8; return project; } function legacyThreeShotNepalProjectFixture() { const project = structuredClone(PROJECT_FIXTURE); project.scenes[0].title = 'Nepal Flood Incident'; project.scenes[0].shots = [0, 1, 2].map((index) => ({ ...structuredClone(PROJECT_FIXTURE.scenes[0].shots[index % 2]), id: `legacy-nepal-${index + 1}`, title: `Shot ${index + 1}`, camera: { lat: 20 + index, lon: 80 + index, alt: 1000000 + index * 100000, heading: index * 15, pitch: -50 - index, roll: 0, }, })); return project; } function legacyDefaultProjectWithoutNepalFixture() { const project = structuredClone(PROJECT_FIXTURE); project.scenes[0].id = 'bhote-koshi-flood'; project.scenes[0].title = 'Bhote Koshi Flood Reconstruction'; project.scenes[0].shots = [{ ...structuredClone(PROJECT_FIXTURE.scenes[0].shots[0]), id: 'standalone-shot', title: 'Shot 1', }]; return project; } test('Mailung clip trim estimates seven seconds and its exit, including older saved holds', () => { const { director, restore } = makeDirector(); try { const scene = director._project.scenes[0]; const shot = scene.shots[0]; shot.sourcePackId = 'bhote-koshi-nepal-evidence-pack'; shot.durationSec = 4.2; shot.holdSec = 15; shot.layers = { 'bhote-koshi-2026': { enabled: true, params: { presentation: 'scene-beat', beatId: 'mailung-bazzar', } } }; assert.equal(director._effectiveShotHoldSec(scene, shot), 7.65); assert.equal(director._shotRuntimeDurationSec(scene, shot), 4.2 + 7.65); const state = director._layerStatesForShot(scene, shot)['bhote-koshi-2026']; assert.equal(state.params.sceneContext.holdSec, 7.65); assert.equal(state.params.sceneControls.mediaPlaybackHoldSec, 7); assert.equal(state.params.sceneControls.minimumHoldSec, 7.65); assert.equal(shot.holdSec, 15, 'runtime correction does not rewrite saved shots'); shot.layers['bhote-koshi-2026'].params.beatId = 'dandagaun'; assert.equal(director._effectiveShotHoldSec(scene, shot), 15, 'other shots keep their authored hold'); } finally { restore(); } }); test('Incident Corridor gives all overview pins time to reveal without rewriting saved shots', () => { const { director, restore } = makeDirector(); try { const scene = director._project.scenes[0]; const shot = scene.shots[0]; shot.holdSec = 0.9; shot.layers = { 'bhote-koshi-locator': { enabled: true, params: { presentation: 'bhote-koshi-incident-places' }, } }; assert.equal(director._effectiveShotHoldSec(scene, shot), 11); assert.equal(shot.holdSec, 0.9); shot.holdSec = 15; assert.equal(director._effectiveShotHoldSec(scene, shot), 15); shot.holdSec = 0.9; shot.layers['bhote-koshi-locator'].params.presentation = 'bhote-koshi-flood-path'; assert.equal(director._effectiveShotHoldSec(scene, shot), 0.9); shot.layers['bhote-koshi-locator'].params.presentation = 'bhote-koshi-incident-places'; shot.layers['bhote-koshi-locator'].enabled = false; assert.equal(director._effectiveShotHoldSec(scene, shot), 0.9); } finally { restore(); } }); test('scene clock seek resolves the exact shot phase and camera in both directions', async () => { const { director, restore } = makeDirector(); const loads = []; director._loadShot = async (sceneId, shotId, options) => { loads.push({ sceneId, shotId, options }); return { started: true, shotId }; }; try { assert.equal(await director.seekScene('scene-1', 0), true); assert.equal(await director.seekScene('scene-1', 0.99), true); assert.equal(await director.seekScene('scene-1', 0.25), true); assert.equal(await director.seekScene('missing', 0.5), false); assert.deepEqual(loads.map(({ sceneId, shotId }) => ({ sceneId, shotId })), [ { sceneId: 'scene-1', shotId: 'shot-a' }, { sceneId: 'scene-1', shotId: 'shot-b' }, { sceneId: 'scene-1', shotId: 'shot-a' }, ]); assert.equal(loads[0].options.sceneSeek.sceneProgress, 0); assert.equal(loads[0].options.sceneSeek.cameraProgress, 0); assert.ok(loads[1].options.sceneSeek.cameraProgress > 0.9); assert.equal(loads[1].options.sceneSeek.shotIndex, 1); assert.equal(loads[2].options.sceneSeek.sceneProgress, 0.25); assert.equal(loads[2].options.sceneSeek.cameraProgress, 0.5); assert.equal(loads[2].options.sceneSeek.camera.lat, 10); assert.equal(loads[2].options.sceneSeek.camera.lon, 20); } finally { restore(); } }); test('same-shot seeking restores declared layer visibility after manual changes', async () => { const { director, dataManager, styleManager, restore } = makeDirector(); try { const shot = director._project.scenes[0].shots[0]; shot.layers = { flights: { enabled: true }, traffic: { enabled: false } }; await director.loadShot('scene-1', 'shot-a', { flyDuration: 0 }); await dataManager.setEnabled('flights', false); await dataManager.setEnabled('traffic', true); await dataManager.setEnabled('satellites', true); dataManager.setEnabledCalls.length = 0; const visualCalls = styleManager.visualCalls.length; assert.equal(await director.seekScene('scene-1', 0.25), true); assert.equal(styleManager.visualCalls.length, visualCalls, 'do not rebuild the shot'); assert.equal(director.getPlaybackTimingState().snapshot.sceneProgress, 0.25); const enabled = new Map(dataManager.getAll().map(({ id, enabled }) => [id, enabled])); assert.equal(enabled.get('flights'), true, 'restore the shot\'s enabled layer'); assert.equal(enabled.get('traffic'), false, 'restore the shot\'s disabled layer'); assert.equal(enabled.get('satellites'), true, 'preserve undeclared operator layers'); assert.ok(dataManager.setEnabledCalls.every(({ id }) => id !== 'satellites')); } finally { await director.destroy(); restore(); } }); test('same-shot seeking reports refusal when a manually disabled layer cannot be restored', async () => { let refuse = false; const { director, dataManager, styleManager, restore } = makeDirector({ data: { refuse: () => refuse }, }); try { await director.loadShot('scene-1', 'shot-a', { flyDuration: 0 }); assert.equal(await director.seekScene('scene-1', 0.1), true); await dataManager.setEnabled('flights', false); refuse = true; const visualCalls = styleManager.visualCalls.length; assert.equal(await director.seekScene('scene-1', 0.25), false); assert.equal(dataManager.getAll().find(({ id }) => id === 'flights').enabled, false); const timing = director.getPlaybackTimingState(); assert.equal(timing.activeTimers, 0); assert.ok(Math.abs(timing.snapshot.sceneProgress - 0.1) < 1e-9, 'keep the last settled seek position'); assert.equal(styleManager.visualCalls.length, visualCalls, 'do not rebuild the shot'); } finally { await director.destroy(); restore(); } }); test('same-shot seeking restores visibility a manual toggle is still changing', async () => { const { director, dataManager, restore } = makeDirector(); try { await director.loadShot('scene-1', 'shot-a', { flyDuration: 0 }); const disabling = dataManager.setEnabled('flights', false); assert.equal(await director.seekScene('scene-1', 0.25), true); await disabling; await settle(); assert.equal(dataManager.getAll().find(({ id }) => id === 'flights').enabled, true); } finally { await director.destroy(); restore(); } }); test('same-shot seeking restores a layer whose superseded LOAD transition rolls back', async () => { const { director, dataManager, styleManager, viewer, restore } = makeDirector(); const lifecycle = new LayerLifecycle(viewer); for (const id of ['flights', 'traffic', 'satellites']) { lifecycle.register({ id, name: id, init() {}, enable() {}, disable() {}, update() {}, }); } const realDirector = new SceneDirector(viewer, styleManager, lifecycle); try { await director.loadShot('scene-1', 'shot-a', { flyDuration: 0 }); await dataManager.setEnabled('flights', false); dataManager.setEnabledCalls.length = 0; const reload = director.loadShot('scene-1', 'shot-a', { flyDuration: 0 }); for (let i = 0; i < 20 && !dataManager.setEnabledCalls.length; i++) await Promise.resolve(); assert.equal(dataManager.getLayerLifecycleState('flights').lifecycleState, 'enabling'); assert.equal(await director.seekScene('scene-1', 0.25), true); await reload; await settle(); assert.equal(dataManager.getAll().find(({ id }) => id === 'flights').enabled, true); await realDirector.loadShot('scene-1', 'shot-a', { flyDuration: 0 }); await lifecycle.setEnabled('flights', false); const queuedReload = realDirector.loadShot('scene-1', 'shot-a', { flyDuration: 0 }); for (let i = 0; i < 20 && !lifecycle.isEffectivelyEnabled('flights'); i++) { await Promise.resolve(); } assert.deepEqual(lifecycle.getLayerLifecycleState('flights'), { enabled: false, lifecycleState: 'disabled', uncertain: false, }); assert.equal(await realDirector.seekScene('scene-1', 0.25), true); await queuedReload; await settle(); assert.equal(lifecycle.isEnabled('flights'), true); lifecycle.layers.get('flights').lifecycleUncertain = true; assert.equal(await realDirector.seekScene('scene-1', 0.3), true); assert.equal(lifecycle.getLayerLifecycleState('flights').uncertain, false); let navClaims = 0; styleManager.runImmediateNavigation = () => { navClaims += 1; return false; }; assert.equal(await realDirector.seekScene('scene-1', 0.4), false); assert.equal(navClaims, 1, 'camera refusal fails the seek without falling back to LOAD'); } finally { await realDirector.destroy(); await director.destroy(); restore(); } }); test('same-shot seeking rolls back earlier layers and preserves Context, clock and camera when a later layer is refused', async () => { let refuse = () => false; const { director, dataManager, styleManager, viewer, restore } = makeDirector({ data: { refuse: (id, on) => refuse(id, on) }, }); try { const shot = director._project.scenes[0].shots[0]; shot.layers = { flights: { enabled: true }, traffic: { enabled: true }, satellites: { enabled: true }, }; await director.loadShot('scene-1', 'shot-a', { flyDuration: 0 }); assert.equal(await director.seekScene('scene-1', 0.1), true); await dataManager.setEnabled('flights', false); await dataManager.setEnabled('traffic', false); await dataManager.setEnabled('satellites', false); styleManager.contextMode = 'space-missions'; styleManager.contextExits.length = 0; refuse = (id) => id === 'traffic'; dataManager.setEnabledCalls.length = 0; const viewsBefore = viewer.views.length; const visualCalls = styleManager.visualCalls.length; assert.equal(await director.seekScene('scene-1', 0.25), false); assert.equal( dataManager.setEnabledCalls.some(({ id }) => id === 'satellites'), false, 'stop the plan before later ids are written', ); const enabled = new Map(dataManager.getAll().map(({ id, enabled }) => [id, enabled])); assert.equal(enabled.get('flights'), false, 'first stale layer stays disabled'); assert.equal(enabled.get('traffic'), false, 'refused second layer stays disabled'); assert.equal(enabled.get('satellites'), false, 'later stale layer is never written'); assert.equal(styleManager.contextMode, 'space-missions'); assert.deepEqual(styleManager.contextExits, []); assert.equal(viewer.views.length, viewsBefore, 'camera stays at the pre-seek pose'); assert.equal(styleManager.visualCalls.length, visualCalls, 'do not rebuild the shot'); assert.ok( Math.abs(director.getPlaybackTimingState().snapshot.sceneProgress - 0.1) < 1e-9, 'clock stays at the last settled seek position', ); } finally { await director.destroy(); restore(); } }); test('same-shot seeking aborts in-flight admission when superseded by an early-return load or start', async () => { const { styleManager, viewer, restore } = makeDirector(); let holdEnable = false; let releaseEnable; const enableGate = new Promise((resolve) => { releaseEnable = resolve; }); const lifecycle = new LayerLifecycle(viewer); lifecycle.register({ id: 'flights', name: 'flights', init() {}, async enable() { if (holdEnable) await enableGate; }, disable() {}, update() {}, }); const director = new SceneDirector(viewer, styleManager, lifecycle); try { await director.loadShot('scene-1', 'shot-a', { flyDuration: 0 }); assert.equal(await director.seekScene('scene-1', 0.1), true); await lifecycle.setEnabled('flights', false); holdEnable = true; const viewsBefore = viewer.views.length; const seek = director.seekScene('scene-1', 0.25); for ( let i = 0; i < 20 && lifecycle.getLayerLifecycleState('flights').lifecycleState !== 'enabling'; i++ ) { await Promise.resolve(); } assert.equal(lifecycle.getLayerLifecycleState('flights').lifecycleState, 'enabling'); const admissionSignal = director._loadAbort?.signal; assert.ok(admissionSignal, 'same-shot seek installs an admission controller'); const missingLoad = director.loadShot('missing', 'nope'); assert.equal( admissionSignal.aborted, true, 'missing load aborts the admission controller before returning', ); assert.equal((await missingLoad).reason, 'shot-not-found'); assert.equal(viewer.views.length, viewsBefore, 'shortcut has not committed before abort'); releaseEnable(); assert.equal(await seek, false); await settle(); assert.equal(lifecycle.isEnabled('flights'), false, 'layer is not restored'); assert.equal(viewer.views.length, viewsBefore, 'setView is not called'); assert.ok( Math.abs(director.getPlaybackTimingState().snapshot.sceneProgress - 0.1) < 1e-9, 'sceneProgress stays at the last settled value', ); let loadFallbackCalls = 0; const origLoadShot = director._loadShot.bind(director); director._loadShot = (...args) => { loadFallbackCalls += 1; return origLoadShot(...args); }; const origSeekLoadedShot = director._seekLoadedShot.bind(director); director._seekLoadedShot = async () => { await director.startScene('missing'); return null; }; assert.equal(await director.seekScene('scene-1', 0.25), false); assert.equal(loadFallbackCalls, 0, 'stale seek returning null must not start _loadShot'); director._seekLoadedShot = origSeekLoadedShot; } finally { releaseEnable?.(); await director.destroy(); restore(); } }); test('a rejected loadShot does not cancel an in-flight LOAD', async () => { const { styleManager, viewer, restore } = makeDirector(); let holdEnable = true; let releaseEnable; const enableGate = new Promise((resolve) => { releaseEnable = resolve; }); const lifecycle = new LayerLifecycle(viewer); lifecycle.register({ id: 'flights', name: 'flights', init() {}, async enable() { if (holdEnable) await enableGate; }, disable() {}, update() {}, }); const director = new SceneDirector(viewer, styleManager, lifecycle); try { const load = director.loadShot('scene-1', 'shot-a', { flyDuration: 0 }); for ( let i = 0; i < 20 && lifecycle.getLayerLifecycleState('flights').lifecycleState !== 'enabling'; i++ ) { await Promise.resolve(); } assert.equal(lifecycle.getLayerLifecycleState('flights').lifecycleState, 'enabling'); assert.equal((await director.loadShot('missing', 'nope')).reason, 'shot-not-found'); holdEnable = false; releaseEnable(); assert.equal((await load)?.started, true, 'the valid LOAD still lands'); assert.equal(lifecycle.isEnabled('flights'), true); } finally { releaseEnable?.(); await director.destroy(); restore(); } }); test('refused same-shot seek rollback keeps a manual toggle still in flight', async () => { let refuse = () => false; const { director, dataManager, restore } = makeDirector({ data: { refuse: (id, on) => refuse(id, on) }, }); try { const shot = director._project.scenes[0].shots[0]; shot.layers = { flights: { enabled: true }, traffic: { enabled: true } }; await director.loadShot('scene-1', 'shot-a', { flyDuration: 0 }); assert.equal(await director.seekScene('scene-1', 0.1), true); await dataManager.setEnabled('flights', false); await dataManager.setEnabled('traffic', false); refuse = (id) => id === 'traffic'; const manualEnable = dataManager.setEnabled('flights', true); assert.equal(await director.seekScene('scene-1', 0.25), false); await manualEnable; await settle(); assert.equal( dataManager.getAll().find(({ id }) => id === 'flights').enabled, true, 'rollback restores the operator\'s intended state, not the stale committed one', ); } finally { await director.destroy(); restore(); } }); test('reopening the same shot reapplies its look while ordinary seeks reuse it', async () => { const project = structuredClone(PROJECT_FIXTURE); project.scenes[0].shots[0].visual.style = 'retro'; const { director, dataManager, styleManager, restore } = makeDirector({ project }); try { await director.loadShot('scene-1', 'shot-a', { flyDuration: 0 }); await styleManager.applyVisualState({ style: 'normal' }); await dataManager.setEnabled('satellites', true); dataManager.setEnabledCalls.length = 0; const visualCalls = styleManager.visualCalls.length; assert.equal(await director.seekScene('scene-1', 0.25), true); assert.deepEqual(dataManager.setEnabledCalls, []); assert.equal(styleManager.visualCalls.length, visualCalls); assert.equal(director.getPlaybackTimingState().snapshot.sceneProgress, 0.25); assert.equal(await director.seekScene('scene-1', 0.25, { reloadShot: true }), true); assert.equal(styleManager.visualCalls.length, visualCalls + 1); assert.equal(styleManager.visualStates.at(-1).style, 'retro'); const { sceneProgress, seeking } = director.getPlaybackTimingState().snapshot; assert.equal(sceneProgress, 0.25); assert.equal(seeking, true); } finally { await director.destroy(); restore(); } }); test('scene clock subscribers receive authoritative forward playback snapshots', () => { const { director, restore } = makeDirector(); const snapshots = []; const unsubscribe = director.subscribeSceneClock((snapshot) => snapshots.push(snapshot)); try { const scene = director._project.scenes[0]; director._publishSceneClock(scene, scene.shots[0], 0.1, { running: true }); director._publishSceneClock(scene, scene.shots[1], 0.3, { running: true }); unsubscribe(); director._publishSceneClock(scene, scene.shots[1], 0.4, { running: false }); assert.deepEqual(snapshots.map(({ shotId, sceneElapsedSec, running }) => ({ shotId, sceneElapsedSec, running, })), [ { shotId: 'shot-a', sceneElapsedSec: 0.1, running: true }, { shotId: 'shot-b', sceneElapsedSec: 0.3, running: true }, ]); } finally { restore(); } }); test('the Nepal evidence pack appends once and applies the approved corridor framing', () => { const project = nepalProjectFixture(); const originalShots = structuredClone(project.scenes[0].shots); const { director, restore } = makeDirector({ project }); try { const scene = director._project.scenes[0]; const originalShotIds = scene.shots.map(({ id }) => id); const first = director.appendShotPack('scene-1', 'bhote-koshi-nepal-evidence-pack'); assert.deepEqual(first, { appended: true, updated: false, shotCount: 17, patchedShotCount: 14, firstShotId: scene.shots[8].id, }); assert.deepEqual(scene.shots.slice(0, 8).map(({ id }) => id), originalShotIds); assert.equal(scene.shots.length, 25); assert.ok(scene.releaseLayerIds.includes('bhote-koshi-2026')); assert.ok(scene.releaseLayerIds.includes('bhote-koshi-locator')); assert.equal(scene.appliedShotPacks[0].id, 'bhote-koshi-nepal-evidence-pack'); assert.equal(scene.appliedShotPacks[0].version, 18); assert.deepEqual( Object.keys(scene.appliedShotPacks[0].shotBindings), [...NEPAL_ORIGINAL_SHOT_TITLES, ...scene.shots.slice(8).map(({ title }) => title)], ); assert.deepEqual( scene.shots.map((shot) => shot.visual.mapStack), [ ...Array(25).fill('photoreal'), ], ); assert.deepEqual( scene.shots.map((shot) => shot.layers['bhote-koshi-2026'].params.beatId), [ 'immediate-collapse-viewpoint', 'debris-dammed-lake', 'gyirong-border-gate', 'timure-cluster', 'syabru-besi', 'bidur-trishuli-bridge', 'gyirong-border-gate', 'immediate-collapse-viewpoint', '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', 'final-view', ], ); assert.deepEqual( scene.shots[8].layers['bhote-koshi-2026'].params.sceneControls, { evidenceMediaAutoplay: true }, ); assert.deepEqual( scene.shots[9].layers['bhote-koshi-2026'].params.sceneControls, { evidenceMediaAutoplay: true }, ); assert.deepEqual( scene.shots[11].layers['bhote-koshi-2026'].params.sceneControls, { imageryComparison: true, evidenceSequence: true, evidenceSequenceDurationSec: 2.5, deferEvidenceUntilCameraSettled: true, evidenceRevealDurationSec: 2.5, }, ); assert.deepEqual( scene.shots.slice(12, 14).map( (shot) => shot.layers['bhote-koshi-2026'].params.sceneControls, ), [ { imageryComparison: true, evidenceSequence: true, evidenceSequenceDurationSec: 4, }, { imageryComparison: true, evidenceSequence: true, evidenceSequenceDurationSec: 4, }, ], ); assert.deepEqual( scene.shots[21].layers['bhote-koshi-2026'].params.sceneControls, { evidenceSequence: true, evidenceSequenceDurationSec: 4, }, ); for (const shot of scene.shots) { assert.equal(shot.layers['bhote-koshi-2026'].enabled, true); assert.equal(shot.layers['bhote-koshi-2026'].params.presentation, 'scene-beat'); } assert.deepEqual( scene.shots.slice(0, 8).filter((_, index) => index !== 4).map(({ camera }) => camera), originalShots.filter((_, index) => index !== 4).map(({ camera }) => camera), ); assert.deepEqual(scene.shots[4].camera, { lat: 28.0529, lon: 85.2189, alt: 126931, heading: 0, pitch: -90, roll: 0, }); assert.equal(scene.shots[4].holdSec, 11); assert.deepEqual( scene.shots.slice(0, 8).map((shot) => shot.layers['bhote-koshi-locator']), originalShots.map((shot) => shot.layers['bhote-koshi-locator']), ); assert.equal(new Set(scene.shots.map(({ id }) => id)).size, 25); assert.deepEqual( director.appendShotPack('scene-1', 'bhote-koshi-nepal-evidence-pack'), { appended: false, reason: 'already-appended' }, ); assert.equal(scene.shots.length, 25); } finally { restore(); } }); test('installed v12 Nepal pack inserts ten points without replacing renamed cameras', () => { const first = makeDirector({ project: nepalProjectFixture() }); let legacy; const recipe = getSceneAppendRecipeById('bhote-koshi-nepal-evidence-pack'); try { first.director.appendShotPack('scene-1', recipe.id); legacy = structuredClone(first.director._project); const scene = legacy.scenes[0]; scene.shots = scene.shots.filter((shot) => !shot.sourcePackId || recipe.previousRequiredSourcePackBeatIds.includes(shot.layers['bhote-koshi-2026'].params.beatId)); scene.appliedShotPacks[0].version = 12; const ids = new Set(scene.shots.map(({ id }) => id)); scene.appliedShotPacks[0].shotBindings = Object.fromEntries( Object.entries(scene.appliedShotPacks[0].shotBindings).filter(([, id]) => ids.has(id))); scene.shots[8].title = 'My collapse camera'; scene.shots[8].camera.heading = 149; } finally { first.restore(); } const originalShots = structuredClone(legacy.scenes[0].shots); const upgraded = makeDirector({ project: legacy }); try { const scene = upgraded.director._project.scenes[0]; assert.equal(scene.shots.length, 25); for (const old of originalShots) { const current = scene.shots.find(({ id }) => id === old.id); assert.ok(current); assert.deepEqual(current.camera, old.camera); assert.equal(current.title, old.title); } assert.deepEqual(scene.shots.filter((shot) => shot.sourcePackId).map((shot) => shot.layers['bhote-koshi-2026'].params.beatId), recipe.requiredSourcePackBeatIds); assert.equal(scene.appliedShotPacks[0].version, 18); assert.equal(upgraded.director.appendShotPack(scene.id, recipe.id).reason, 'already-appended'); } finally { upgraded.restore(); } }); test('startup selects the first scene after upgrading a later scene’s shot pack', () => { const first = makeDirector({ project: nepalProjectFixture() }); let legacy; const recipe = getSceneAppendRecipeById('bhote-koshi-nepal-evidence-pack'); try { first.director.appendShotPack('scene-1', recipe.id); legacy = structuredClone(first.director._project); const scene = legacy.scenes[0]; scene.id = 'nepal'; scene.shots = scene.shots.filter((shot) => !shot.sourcePackId || recipe.previousRequiredSourcePackBeatIds.includes(shot.layers['bhote-koshi-2026'].params.beatId)); scene.appliedShotPacks[0].version = 12; const ids = new Set(scene.shots.map(({ id }) => id)); scene.appliedShotPacks[0].shotBindings = Object.fromEntries( Object.entries(scene.appliedShotPacks[0].shotBindings).filter(([, id]) => ids.has(id))); // An ordinary scene comes first; the pack to upgrade is in the second. legacy.scenes.unshift(structuredClone(PROJECT_FIXTURE.scenes[0])); } finally { first.restore(); } const upgraded = makeDirector({ project: legacy }); try { const { director } = upgraded; assert.equal(director._project.scenes[1].appliedShotPacks[0].version, 18, 'the pack was upgraded'); assert.equal(director._selectedSceneId, 'scene-1'); assert.equal(director._selectedShotId, 'shot-a'); } finally { upgraded.restore(); } }); test('a legacy three-shot Nepal browser project bootstraps to the current 25-shot sequence', () => { const project = legacyThreeShotNepalProjectFixture(); const originalIds = project.scenes[0].shots.map(({ id }) => id); const originalCameras = project.scenes[0].shots.map(({ camera }) => structuredClone(camera)); const { director, restore } = makeDirector({ project }); try { const scene = director._project.scenes[0]; assert.equal(scene.shots.length, 25); assert.deepEqual(scene.shots.map(({ title }) => title), getSceneAppendRecipeById('bhote-koshi-nepal-evidence-pack').requiredShotTitles); assert.deepEqual(scene.shots.slice(0, 3).map(({ id }) => id), originalIds); assert.deepEqual(scene.shots.slice(0, 3).map(({ camera }) => camera), originalCameras); assert.equal(scene.appliedShotPacks[0].id, 'bhote-koshi-nepal-evidence-pack'); assert.equal(scene.appliedShotPacks[0].version, 18); // displayShotTitle trusts these bindings to localize the bootstrap shots. for (const shot of scene.shots.slice(0, 8)) { assert.equal(scene.appliedShotPacks[0].shotBindings[shot.title], shot.id); } assert.equal(director._selectedSceneId, scene.id); assert.equal(director._selectedShotId, scene.shots[0].id); } finally { restore(); } }); test('the Nepal evidence pack refuses a partial inventory without mutating the scene', () => { const project = nepalProjectFixture(); project.scenes[0].shots[3].title = 'Renamed Nearby Cities'; const { director, restore } = makeDirector({ project }); try { const sceneBefore = structuredClone(director._project.scenes[0]); assert.deepEqual( director.appendShotPack('scene-1', 'bhote-koshi-nepal-evidence-pack'), { appended: false, updated: false, reason: 'shot-inventory-mismatch', }, ); assert.deepEqual(director._project.scenes[0], sceneBefore); } finally { restore(); } }); test('the Nepal pack upgrades the upper-valley shots without duplicating evidence beats', () => { const initial = makeDirector({ project: nepalProjectFixture() }); initial.director.appendShotPack('scene-1', 'bhote-koshi-nepal-evidence-pack'); const project = structuredClone(initial.director._project); initial.restore(); project.scenes[0].appliedShotPacks = [{ id: 'bhote-koshi-nepal-evidence-pack', version: 4, }]; for (const shot of project.scenes[0].shots.slice(0, 8)) { delete shot.layers['bhote-koshi-2026']; } const originalLength = project.scenes[0].shots.length; const originalIds = project.scenes[0].shots.map(({ id }) => id); const originalCameras = project.scenes[0].shots.map(({ camera }) => structuredClone(camera)); const originalLocators = project.scenes[0].shots.map( (shot) => structuredClone(shot.layers['bhote-koshi-locator']), ); const { director, restore } = makeDirector({ project }); try { const scene = director._project.scenes[0]; assert.deepEqual( director.appendShotPack('scene-1', 'bhote-koshi-nepal-evidence-pack'), { appended: false, reason: 'already-appended' }, ); assert.equal(scene.shots.length, originalLength); assert.deepEqual(scene.shots.map(({ id }) => id), originalIds); assert.deepEqual(scene.shots.map(({ camera }) => camera), originalCameras); assert.deepEqual( scene.shots.map((shot) => shot.layers['bhote-koshi-locator']), originalLocators, ); assert.deepEqual(scene.shots[8].camera, { lat: 28.417, lon: 85.3937, alt: 9850, heading: 146, pitch: -34, roll: 0, }); assert.equal(scene.appliedShotPacks[0].version, 18); assert.equal(Object.keys(scene.appliedShotPacks[0].shotBindings).length, 25); assert.ok(scene.shots.every((shot) => ( shot.layers['bhote-koshi-2026']?.enabled === true && shot.layers['bhote-koshi-2026']?.params?.presentation === 'scene-beat' ))); const afterUpgrade = structuredClone(scene); assert.deepEqual( director.appendShotPack('scene-1', 'bhote-koshi-nepal-evidence-pack'), { appended: false, reason: 'already-appended' }, ); assert.deepEqual(scene, afterUpgrade); } finally { restore(); } }); test('an older default project gains the complete selectable Nepal scene once', () => { const project = legacyDefaultProjectWithoutNepalFixture(); const { director, restore } = makeDirector({ project, data: { registered: [...REGISTERED, 'bhote-koshi-2026', 'bhote-koshi-locator'] }, }); try { const nepal = director._project.scenes.find(({ title }) => title === 'Nepal Flood Incident'); assert.ok(nepal); assert.equal(nepal.shots.length, 25); assert.equal(nepal.shots[0].title, 'Global Incident Context'); assert.equal(nepal.shots.at(-1).title, 'Final view'); assert.deepEqual(director._project.installedBuiltInSceneIds, ['bhote-koshi-nepal-scene']); } finally { restore(); } }); test('a previously installed Nepal scene stays deleted when its marker remains', () => { const project = legacyDefaultProjectWithoutNepalFixture(); project.installedBuiltInSceneIds = ['bhote-koshi-nepal-scene']; const { director, restore } = makeDirector({ project }); try { assert.equal( director._project.scenes.some(({ title }) => title === 'Nepal Flood Incident'), false, ); } finally { restore(); } }); test('public defaults include Nepal without an extra standalone flood recipe', () => { assert.equal(SCENE_RECIPES.some((item) => item.id === 'bhote-koshi-flood'), false); assert.equal(SCENE_RECIPES.filter((item) => item.id === 'bhote-koshi-nepal-scene').length, 1); }); test('an existing public default project gains Nepal without replacing authored shots', () => { const project = structuredClone(PROJECT_FIXTURE); project.scenes[0].id = 'flights-radar'; const original = structuredClone(project.scenes[0].shots); const { director, restore } = makeDirector({ project }); try { assert.deepEqual(director._project.scenes[0].shots.map(({ id, camera }) => ({ id, camera })), original.map(({ id, camera }) => ({ id, camera }))); assert.equal(director._project.scenes[1].title, 'Nepal Flood Incident'); assert.equal(director._project.scenes[1].shots.length, 25); assert.deepEqual(director._project.installedBuiltInSceneIds, ['bhote-koshi-nepal-scene']); } finally { restore(); } }); test('Nepal comparison shots load Esri beneath Vantor even from a saved OSM or photoreal shot', async () => { const { director, styleManager, restore } = makeDirector({ project: nepalProjectFixture(), data: { registered: [...REGISTERED, 'bhote-koshi-2026', 'bhote-koshi-locator'] }, }); try { director.appendShotPack('scene-1', 'bhote-koshi-nepal-evidence-pack'); const scene = director._project.scenes[0]; const comparisonShots = scene.shots.filter((shot) => director._layerStatesForShot(scene, shot)['bhote-koshi-2026']?.params?.sceneControls?.imageryComparison); assert.ok(comparisonShots.length >= 2, 'the real comparison beats must be exercised'); for (const shot of comparisonShots) { for (const prior of ['osm', 'photoreal']) { shot.visual.mapStack = prior; await director.loadShot(scene.id, shot.id, { flyDuration: 0.2 }); assert.equal(styleManager.visualStates.at(-1).mapStack, 'esri-imagery', shot.title); } } } finally { await director.destroy(); restore(); } }); test('all saved Nepal shots choose a usable map in keyed and keyless runtimes without rewriting the project', async () => { let photorealAvailable = false; const { director, styleManager, restore } = makeDirector({ project: nepalProjectFixture(), isMapStackAvailable: (id) => id === 'photoreal' && photorealAvailable, data: { registered: [...REGISTERED, 'bhote-koshi-2026', 'bhote-koshi-locator'] }, }); try { director.appendShotPack('scene-1', 'bhote-koshi-nepal-evidence-pack'); const scene = director._project.scenes[0]; const savedShots = structuredClone(scene.shots); for (const available of [false, true, false]) { photorealAvailable = available; for (const shot of scene.shots) { const comparison = director._layerStatesForShot(scene, shot) ['bhote-koshi-2026']?.params?.sceneControls?.imageryComparison; const visual = director._visualStateForShot(shot); assert.equal(visual.mapStack, available && !comparison ? 'photoreal' : 'esri-imagery', shot.title); } await director.loadShot(scene.id, scene.shots[0].id, { flyDuration: 0.2 }); assert.equal(styleManager.visualStates.at(-1).mapStack, available ? 'photoreal' : 'esri-imagery'); } assert.deepEqual(scene.shots, savedShots); const unrelated = { visual: { mapStack: 'photoreal' }, layers: { flights: { enabled: true } } }; assert.equal(director._visualStateForShot(unrelated), unrelated.visual, 'other scenes keep their provider policy'); } finally { await director.destroy(); restore(); } }); /** The layer registry as main.js builds it (src/main.js dataManager.register calls). */ const REGISTERED = [ 'flights', 'military', 'earthquakes', 'satellites', 'rocket-launches', 'traffic', 'cctv', 'radio', 'bikeshare', 'ais-live-vessels', 'military-installations', 'military-awareness', 'local-datacenters', 'local-dams', 'telegeography-submarine-cables', 'local-firms', ]; /** Layers Space Missions permits while it isolates the globe (contextModePolicy). */ const SPACE_MISSIONS_ALLOWED = new Set(['rocket-launches', 'satellites', 'radio']); const PROJECT_FIXTURE = { version: 3, scenes: [{ id: 'scene-1', title: 'Fixture Scene', shots: [ { id: 'shot-a', title: 'Shot A', durationSec: 0.2, holdSec: 0, camera: { lat: 10, lon: 20, alt: 500000, heading: 0, pitch: -40, roll: 0 }, visual: { style: 'normal' }, layers: { flights: { enabled: true } }, }, { id: 'shot-b', title: 'Shot B', durationSec: 0.2, holdSec: 0, camera: { lat: -30, lon: 140, alt: 900000, heading: 0, pitch: -40, roll: 0 }, visual: { style: 'retro' }, layers: { traffic: { enabled: true } }, }, ], }], }; /** * Stub the browser globals the director touches, headlessly. `storage` replaces * the seeded entries (key -> raw string); setting `localStorage.full` makes * every write throw a quota error. */ function installSceneRuntime(project = PROJECT_FIXTURE, { storage } = {}) { const originalDocument = globalThis.document; const originalLocalStorage = globalThis.localStorage; const noopClassList = { add() {}, remove() {}, toggle() {}, contains: () => false }; globalThis.document = { getElementById: () => null, createElement: () => ({ classList: noopClassList, style: {}, appendChild() {}, remove() {} }), addEventListener() {}, removeEventListener() {}, body: { classList: noopClassList, appendChild() {} }, }; const stored = new Map(storage ? Object.entries(storage) : [['godsEyeView.sceneProject.v2', JSON.stringify(project)]]); globalThis.localStorage = { stored, full: false, getItem: (key) => stored.get(key) ?? null, setItem(key, value) { if (this.full) throw new DOMException('quota exceeded', 'QuotaExceededError'); stored.set(key, value); }, removeItem: (key) => stored.delete(key), }; return () => { globalThis.document = originalDocument; globalThis.localStorage = originalLocalStorage; }; } /** * Data manager double recording every reconcile call the director makes. * * Models the real abort contract (src/data/manager.js): an aborted transition * is rolled back through the module's own disable() and answers false, so an * abort leaves NO half-applied layer — which is the whole point of passing the * signal rather than only checking a boolean afterwards. */ function fakeDataManager({ registered = REGISTERED, refuse = () => false } = {}) { const enabled = new Map(); const pending = new Map(); const setEnabledCalls = []; const setParamsCalls = []; const committed = []; return { setEnabledCalls, subscribeVisibilityRequests(listener) { this.visibilityListener = listener; return () => { this.visibilityListener = null; }; }, setParamsCalls, committed, getAll: () => registered.map((id) => ({ id, enabled: !!enabled.get(id) })), getLayerLifecycleState: (id) => { if (!registered.includes(id)) return null; const on = !!enabled.get(id); const target = pending.get(id); return { enabled: on, lifecycleState: target === undefined ? (on ? 'enabled' : 'disabled') : target ? 'enabling' : 'disabling', }; }, isEffectivelyEnabled: (id) => pending.get(id) ?? !!enabled.get(id), getLayerParams: () => null, async setEnabled(id, shouldEnable, { signal } = {}) { setEnabledCalls.push({ id, enabled: shouldEnable, signal }); if (refuse(id, shouldEnable)) return false; // Yield once so a stop landing during the transition is observable. pending.set(id, shouldEnable); await Promise.resolve(); if (pending.get(id) === shouldEnable) pending.delete(id); if (signal?.aborted) return false; enabled.set(id, shouldEnable); committed.push({ id, enabled: shouldEnable }); return true; }, setLayerParams(id, params) { setParamsCalls.push({ id, params }); return true; }, }; } /** Style manager double covering the camera, visual, and Context facades. */ function fakeStyleManager({ contextMode = null, exitFails = false } = {}) { const manager = { contextMode, contextExits: [], visualStates: [], visualCalls: [], runImmediateNavigation: (noun, navigate) => navigate(), applyVisualState: async (visual, options = {}) => { manager.visualStates.push(visual); manager.visualCalls.push({ visual, isCurrent: options.isCurrent }); return true; }, getCameraState: () => ({ lat: 0, lon: 0, alt: 1000, heading: 0, pitch: -40, roll: 0 }), getVisualState: () => ({ style: 'normal' }), setRecordingMode() {}, getContextModeState: () => ({ mode: manager.contextMode, entering: null }), async setContextMode(mode) { manager.contextExits.push(mode); if (exitFails) return { ok: false, error: 'transition did not complete' }; manager.contextMode = null; return { ok: true }; }, }; return manager; } /** Cesium viewer double whose flights complete on the next microtask turn. */ function fakeViewer() { const flights = []; const views = []; let cancelled = 0; return bindFakeCesiumCamera({ flights, views, get cancelledFlights() { return cancelled; }, camera: { flyTo(options) { flights.push(options); Promise.resolve().then(() => options.complete?.()); }, setView(options) { views.push(options); }, cancelFlight() { cancelled++; }, }, }); } /** Yield enough turns for the director's pending awaits to advance. */ async function settle(turns = 8) { for (let i = 0; i < turns; i++) await Promise.resolve(); } /** Build a director over doubles, with the fixture project loaded. */ function makeDirector(options = {}) { const restore = installSceneRuntime(options.project, { storage: options.storage }); const storage = globalThis.localStorage; const viewer = fakeViewer(); const styleManager = fakeStyleManager(options.style); const dataManager = fakeDataManager(options.data); const director = new SceneDirector(viewer, styleManager, dataManager, { isMapStackAvailable: options.isMapStackAvailable, }); // Telemetry is only accumulated during a run; observable-failure assertions // need the accumulator without driving a whole run. director._activeRun = { events: [] }; return { director, viewer, styleManager, dataManager, storage, restore }; } test('only Play Shot or a scene run grants transient media authority; LOAD, Stop and replacement revoke it', async () => { const { director, dataManager, restore } = makeDirector(); let owner = null; const owners = []; dataManager.layers = new Map([['flights', { module: { setSceneMediaPlayback(value = null) { owner = value; if (value) owners.push(value.shotId); }, } }]]); try { await director.loadShot('scene-1', 'shot-a', { flyDuration: 0 }); assert.equal(owner, null, 'passive LOAD is not playback'); await director.replayShot('scene-1', 'shot-a'); assert.equal(owner?.shotId, 'shot-a'); assert.equal(owner.token.cancelled, false); await director.loadShot('missing-scene', 'missing-shot'); assert.equal(owner?.shotId, 'shot-a', 'rejected navigation does not revoke another action'); director._running = true; await director.loadShot('scene-1', 'shot-b'); assert.equal(owner?.shotId, 'shot-a', 'LOAD refused during a run cannot stop its media'); director._running = false; await director.loadShot('scene-1', 'shot-b', { flyDuration: 0 }); assert.equal(owner, null, 'replacement LOAD revokes the prior replay'); await director.replayShot('scene-1', 'shot-a'); director.stopScene(); assert.equal(owner, null); director._sleep = async () => {}; owners.length = 0; await director.startScene('scene-1', { single: true, preview: false }); assert.deepEqual(owners, ['shot-a'], 'only enabled opt-in layers receive playback authority'); assert.equal(owner, null, 'run completion releases the last shot owner'); } finally { await director.destroy(); restore(); } }); test('cross-scene replay grants media ownership only after the previous scene releases its layers', async () => { const { director, dataManager, restore } = makeDirector(); let owner = null; const events = []; const media = { setSceneMediaPlayback(value = null) { owner = value; } }; dataManager.layers = new Map([['flights', { module: media }]]); const setEnabled = dataManager.setEnabled.bind(dataManager); dataManager.setEnabled = async (id, enabled, options) => { if (id === 'flights') { events.push({ enabled, owner: owner?.shotId ?? null }); if (!enabled) media.setSceneMediaPlayback(); } return setEnabled(id, enabled, options); }; try { const previous = director._project.scenes[0]; previous.releaseLayerIds = ['flights']; const target = structuredClone(previous); target.id = 'other-media-scene'; director._project.scenes.push(target); await director.loadShot(previous.id, 'shot-a', { flyDuration: 0 }); events.length = 0; const result = await director.replayShot(target.id, 'shot-a'); assert.equal(result.started, true); assert.deepEqual(events.slice(0, 2), [ { enabled: false, owner: null }, { enabled: true, owner: 'shot-a' }, ], 'old-scene disable must finish before granting the new owner'); assert.equal(owner?.sceneId, target.id); assert.equal(owner?.token.cancelled, false); director.stopScene(); assert.equal(owner, null); } finally { await director.destroy(); restore(); } }); test('scene camera waits for provider completion and fade rather than the saved media hold', async () => { const { director, viewer, dataManager, restore } = makeDirector(); let release; let pending = true; const gate = new Promise((resolve) => { release = resolve; }); try { const scene = director._project.scenes[0]; scene.shots[0].layers.flights.params = { beatId: 'trimmed' }; dataManager.layers = new Map([['flights', { module: { getSceneShotMediaHold: (id) => id === 'trimmed' ? { pending, maxWaitMs: 20000 } : null, } }]]); const waits = []; director._sleep = async (ms) => { waits.push(ms); if (ms === 70) await gate; }; const run = director.startScene('scene-1', { single: true, preview: false }); await settle(40); assert.equal(viewer.flights.length, 1, 'no next flight while source is starting, playing or fading'); assert.deepEqual(waits, [70]); pending = false; release(); await run; assert.equal(viewer.flights.length, 2, 'the next shot starts immediately after owned media completion'); } finally { release(); await director.destroy(); restore(); } }); test('Stop cancels a provider-owned shot hold and late completion cannot fly the next camera', async () => { const { director, viewer, dataManager, restore } = makeDirector(); let release; const gate = new Promise((resolve) => { release = resolve; }); try { dataManager.layers = new Map([['flights', { module: { getSceneShotMediaHold: () => ({ pending: true, maxWaitMs: 20000 }), } }]]); director._sleep = () => gate; const run = director.startScene('scene-1', { single: true, preview: false }); await settle(40); assert.equal(viewer.flights.length, 1); director.stopScene('test stop'); release(); await run; assert.equal(viewer.flights.length, 1); assert.equal(director.running, false); } finally { release(); await director.destroy(); restore(); } }); test('a provider-owned hold fails boundedly if its owner never settles', async () => { const { director, restore } = makeDirector(); try { director.dataManager.layers = new Map([['flights', { module: { getSceneShotMediaHold: () => ({ pending: true, maxWaitMs: 0 }), } }]]); const scene = director._project.scenes[0]; await assert.rejects(director._holdShot(scene, scene.shots[0], { cancelled: false }), /bounded playback window/); } finally { await director.destroy(); restore(); } }); /** The layer map a shipped recipe declares, in normalized form. */ function recipeLayers(recipeId) { const recipe = SCENE_RECIPES.find((item) => item.id === recipeId); return Object.fromEntries( Object.entries(recipe.layers).map(([id, enabled]) => [id, { enabled }]), ); } test('destroyed directors refuse seek, replay, adjacent and continuation without writes', async () => { const { director, viewer, dataManager, restore } = makeDirector(); try { await director.destroy(); director._loadedSceneId = 'scene-1'; assert.equal(await director.seekScene('scene-1', 0), false); assert.equal((await director.replayShot('scene-1', 'shot-a')).started, false); assert.equal(await director.loadAdjacentShot('scene-1', 'shot-a', 1), false); assert.equal((await director.continueScene('scene-1', 'shot-a')).started, false); assert.equal(viewer.flights.length, 0); assert.equal(dataManager.setParamsCalls.length, 0); } finally { restore(); } }); test('replay, adjacent and seek report layer refusal rather than success', async () => { const { director, restore } = makeDirector({ data: { refuse: () => true } }); try { assert.equal((await director.replayShot('scene-1', 'shot-a')).started, false); assert.equal(await director.loadAdjacentShot('scene-1', 'shot-a', 1), false); assert.equal(await director.seekScene('scene-1', 0), false); } finally { await director.destroy(); restore(); } }); test('a seek waiting for run teardown is revoked by newer Stop, Load, Start or destroy', async () => { for (const action of ['stop', 'load', 'start', 'destroy']) { const { director, restore } = makeDirector(); try { let release; director._waitForRunIdle = () => new Promise((resolve) => { release = resolve; }); director._running = true; director._runToken = { cancelled: false }; const seek = director.seekScene('scene-1', 0); assert.equal(director._pendingWork.has(seek), true); let newer; if (action === 'stop') director.stopScene(); if (action === 'load') newer = director.loadShot('scene-1', 'shot-b'); if (action === 'start') newer = director.startScene('scene-1'); if (action === 'destroy') newer = director.destroy(); director._running = false; release(); assert.equal(await seek, false, action); await newer; } finally { await director.destroy(); restore(); } } }); test('explicit scene-layer OFF revokes continuation during enable, flight and hold; internal OFF does not', async () => { for (const phase of ['enable', 'flight', 'hold']) { const { director, dataManager, restore } = makeDirector(); try { director._project.scenes[0].releaseLayerIds = ['flights']; let release; const gate = new Promise((resolve) => { release = resolve; }); if (phase === 'enable') { const enable = dataManager.setEnabled.bind(dataManager); dataManager.setEnabled = async (...args) => { await gate; return enable(...args); }; } else if (phase === 'flight') director._flyCamera = () => gate; else director._sleep = () => gate; director._project.scenes[0].shots[0].holdSec = 1; const run = director.startScene('scene-1', { single: true, preview: false }); await settle(40); const token = director._runToken; dataManager.visibilityListener({ layerId: 'flights', enabled: false, origin: 'scene' }); assert.equal(token.cancelled, false); dataManager.visibilityListener({ layerId: 'flights', enabled: false, origin: 'user' }); assert.equal(token.cancelled, true, phase); dataManager.visibilityListener({ layerId: 'flights', enabled: false, origin: 'tool' }); release(); await run; assert.equal(dataManager.committed.some(({ id, enabled }) => id === 'traffic' && enabled), false); } finally { await director.destroy(); restore(); } } }); test('scene preview owns recording chrome while panel playback leaves it available', async () => { for (const preview of [true, false]) { const { director, styleManager, restore } = makeDirector(); const recording = []; const playback = []; let release; const flight = new Promise((resolve) => { release = resolve; }); director._flyCamera = () => flight; styleManager.setRecordingMode = (active) => recording.push(active); director._setPlaybackActive = (active) => playback.push(active); try { const run = director.startScene('scene-1', { single: true, preview }); await settle(40); assert.deepEqual(recording, preview ? [true] : []); assert.deepEqual(playback, preview ? [true] : []); director.stopScene(); release(); await run; assert.deepEqual(recording, preview ? [true, false] : []); assert.deepEqual(playback, preview ? [true, false] : []); } finally { release(); await director.destroy(); restore(); } } }); test('the director reconciles only the layers a shot declares', async () => { // Regression: _applyLayerStates walked the LIVE registry and forced every // undeclared layer off, tearing down CCTV/vessels/fires with no restore pass. // Pinned here rather than only on the helper, because the walk lived here. const { director, dataManager, restore } = makeDirector(); try { await director._applyLayerStates({ flights: { enabled: true }, satellites: { enabled: false } }); assert.deepEqual( dataManager.setEnabledCalls.map(({ id, enabled }) => ({ id, enabled })), [ { id: 'flights', enabled: true }, { id: 'satellites', enabled: false }, ], ); } finally { restore(); } }); test('a shot captured while tracking never re-establishes tracking on playback', async () => { // Two writers on the camera is the documented jitter failure mode: the scene // claims the camera, then a captured tracking id hands it straight back to // the follow loop. Playback drops those keys on the way to the layer. const { director, dataManager, restore } = makeDirector(); try { await director._applyLayerStates({ flights: { enabled: true, params: { models3d: true, selectedFlightsTrackingId: 'a835af' } }, military: { enabled: true, params: { selectedMilitaryTrackingId: 'ae1460' } }, satellites: { enabled: true, params: { catalog: 'dense', selectedSatTrackingId: 25544 } }, }); const pushed = Object.fromEntries(dataManager.setParamsCalls.map((call) => [call.id, call.params])); assert.deepEqual(pushed.flights, { models3d: true }); assert.deepEqual(pushed.satellites, { catalog: 'dense' }); // Nothing survived military's params, so nothing is pushed at all. assert.equal(Object.hasOwn(pushed, 'military'), false); for (const call of dataManager.setParamsCalls) { for (const key of SCENE_TRACKING_PARAM_KEYS) { assert.equal(Object.hasOwn(call.params, key), false, `${call.id} leaked ${key}`); } } } finally { restore(); } }); test('a dirty Space Missions state is exited before a recipe applies its layers', async () => { // Space Missions refuses every enable outside its own replay bundle. The old // full-registry walk dismantled it by accident; the sparse policy never does, // so all four Flights Radar enables were refused and reported as success. const style = { contextMode: 'space-missions' }; const holder = {}; const data = { refuse: (id, on) => on && holder.styleManager?.contextMode === 'space-missions' && !SPACE_MISSIONS_ALLOWED.has(id), }; const { director, styleManager, dataManager, restore } = makeDirector({ style, data }); holder.styleManager = styleManager; try { const result = await director._applyLayerStates(recipeLayers('flights-radar')); assert.deepEqual(styleManager.contextExits, ['off']); assert.equal(styleManager.contextMode, null); assert.deepEqual(result.refused, []); assert.ok(result.applied.includes('flights')); assert.deepEqual( dataManager.setEnabledCalls.filter((call) => call.enabled).map((call) => call.id), ['flights'], ); } finally { restore(); } }); test('Orbital Watch does not compose over a Space Missions replay', async () => { // Orbital Watch declares satellites, which the guard permits — so nothing is // refused and a refusal-only check would pass while rocket-launches stayed // on screen. Playback leaves an isolating mode whether or not it refuses. const { director, styleManager, dataManager, restore } = makeDirector({ style: { contextMode: 'space-missions' }, }); try { await director._applyLayerStates(recipeLayers('orbital-watch')); assert.deepEqual(styleManager.contextExits, ['off']); assert.equal( dataManager.setEnabledCalls.some((call) => call.id === 'rocket-launches'), false, 'the recipe never declares rocket-launches; exiting the mode is what clears it', ); } finally { restore(); } }); test('a non-isolating context mode is left alone', async () => { for (const contextMode of [null, 'flights']) { const { director, styleManager, restore } = makeDirector({ style: { contextMode } }); try { await director._applyLayerStates({ flights: { enabled: true } }); assert.deepEqual(styleManager.contextExits, [], `${contextMode} must not be exited`); } finally { restore(); } } }); test('a refused layer is reported, never counted as applied', async () => { const { director, dataManager, restore } = makeDirector({ data: { refuse: (id) => id === 'flights' }, }); try { const result = await director._applyLayerStates({ flights: { enabled: true, params: { models3d: true } }, traffic: { enabled: false }, }); assert.deepEqual(result.refused, ['flights']); assert.deepEqual(result.applied, ['traffic']); // Params must not be pushed at a layer whose transition was vetoed. assert.deepEqual(dataManager.setParamsCalls, []); const refusals = director._activeRun.events.filter((event) => event.type === 'shot_layers_refused'); assert.equal(refusals.length, 1); assert.deepEqual(refusals[0].payload, { layerIds: ['flights'] }); } finally { restore(); } }); test('cancellation between two layers ends the reconcile where it stands', async () => { const { director, dataManager, restore } = makeDirector(); const token = { cancelled: false }; const inner = dataManager.setEnabled.bind(dataManager); dataManager.setEnabled = async (id, on) => { const settled = await inner(id, on); if (id === 'flights') token.cancelled = true; return settled; }; try { const result = await director._applyLayerStates({ flights: { enabled: true }, satellites: { enabled: true }, traffic: { enabled: true }, }, token); assert.deepEqual(dataManager.setEnabledCalls.map((call) => call.id), ['flights']); assert.equal(result.cancelled, true); } finally { restore(); } }); test('STOP during a suspended visual transition lands no layer changes', async () => { // Repro shape from review: applyVisualState suspends (a map-stack switch), // STOP arrives, the visual resolves — and the shot's layer pass still ran. const { director, viewer, styleManager, dataManager, restore } = makeDirector(); let releaseVisual; styleManager.applyVisualState = (visual) => { styleManager.visualStates.push(visual); return new Promise((resolve) => { releaseVisual = resolve; }); }; try { const run = director.startScene('scene-1', { single: true }); await settle(); assert.equal(styleManager.visualStates.length, 1, 'the run must be parked on the visual await'); director.stopScene('Stopped (Esc)'); releaseVisual(); await run; assert.deepEqual(dataManager.setEnabledCalls, []); assert.deepEqual(viewer.flights, []); assert.equal(director.running, false); } finally { restore(); } }); test('STOP between two layers lands no further layer changes', async () => { const { director, dataManager, restore } = makeDirector({ project: { version: 3, scenes: [{ id: 'scene-1', title: 'Fixture Scene', shots: [{ id: 'shot-a', title: 'Shot A', durationSec: 0.2, holdSec: 0, camera: { lat: 10, lon: 20, alt: 500000, heading: 0, pitch: -40, roll: 0 }, visual: { style: 'normal' }, layers: { flights: { enabled: true }, satellites: { enabled: true }, traffic: { enabled: true } }, }], }], }, }); const inner = dataManager.setEnabled.bind(dataManager); dataManager.setEnabled = async (id, on) => { const settled = await inner(id, on); if (id === 'flights') director.stopScene('Stopped (Esc)'); return settled; }; try { await director.startScene('scene-1', { single: true }); assert.deepEqual(dataManager.setEnabledCalls.map((call) => call.id), ['flights']); } finally { restore(); } }); test('STOP aborts the layer transition in flight, not merely the next one', async () => { // Checking the token AFTER the await is a backstop, not the fix: by then an // un-aborted transition has already committed, and the pass returns without // its params — the layer left enabled carrying stale ones. The signal is // what actually stops the layer that is currently moving. const { director, dataManager, restore } = makeDirector({ project: { version: 3, scenes: [{ id: 'scene-1', title: 'Fixture Scene', shots: [{ id: 'shot-a', title: 'Shot A', durationSec: 0.2, holdSec: 0, camera: { lat: 10, lon: 20, alt: 500000, heading: 0, pitch: -40, roll: 0 }, visual: { style: 'normal' }, layers: { flights: { enabled: true, params: { models3d: true } }, satellites: { enabled: true }, }, }], }], }, }); const inner = dataManager.setEnabled.bind(dataManager); dataManager.setEnabled = (id, on, options) => { // STOP lands while the transition is in flight, before it can commit. if (id === 'flights') director.stopScene('Stopped (Esc)'); return inner(id, on, options); }; try { await director.startScene('scene-1', { single: true }); assert.equal(dataManager.setEnabledCalls.length, 1, 'only the in-flight layer is touched'); assert.ok( dataManager.setEnabledCalls[0].signal instanceof AbortSignal, 'the run must hand its abort signal to every transition', ); assert.equal(dataManager.setEnabledCalls[0].signal.aborted, true, 'STOP must abort that signal'); assert.deepEqual(dataManager.committed, [], 'an aborted transition must not commit'); assert.deepEqual(dataManager.setParamsCalls, [], 'no params for a layer that never moved'); } finally { restore(); } }); test('a newer LOAD aborts the previous LOAD transition rather than disowning it', async () => { const { director, styleManager, dataManager, restore } = makeDirector(); const gates = []; styleManager.applyVisualState = (visual, options = {}) => { styleManager.visualCalls.push({ visual, isCurrent: options.isCurrent }); return new Promise((resolve) => { gates.push(resolve); }); }; try { const first = director.loadShot('scene-1', 'shot-a'); await settle(); const second = director.loadShot('scene-1', 'shot-b'); gates[0](); gates[1](); await Promise.all([first, second]); // Only the newer LOAD reconciled, and it carried a live (unaborted) signal. assert.deepEqual(dataManager.setEnabledCalls.map((call) => call.id), ['traffic']); assert.ok(dataManager.setEnabledCalls[0].signal instanceof AbortSignal); assert.equal(dataManager.setEnabledCalls[0].signal.aborted, false); } finally { restore(); } }); test('applyVisualState gates the map-stack switch on both sides of its await', () => { // The other half of the contract, and the half these doubles cannot see. // ui.js cannot be imported here (its mgrs dependency is CJS), so this pins // the structure the way the repo pins other cross-module shape // (cockpitMarkup.test.mjs), while qa-shots/scenes-audit.mjs proves the // BEHAVIOUR against the real StyleManager in a browser. // // Gating only the post-await uniform commit is not enough: the stack switch // is ITSELF a mutation. The controller invalidates a switch only when // another setStack() arrives, and a winning state that omits `mapStack` // never issues one — every normalized scene shot omits it — so a stale // switch would otherwise stand on the globe. const source = readShellSource(); const method = source.match(/\n {2}async applyVisualState\([\s\S]*?\n {2}\}\n/); assert.ok(method, 'applyVisualState is missing from the UI shell source'); assert.match(method[0], /async applyVisualState\(state = \{\}, \{ isCurrent = null \} = \{\}\)/); const mapStackBlock = method[0].match(/if \(state\.mapStack\) \{[\s\S]*?\n {4}\}/); assert.ok(mapStackBlock, 'the map-stack block is missing from applyVisualState'); const block = mapStackBlock[0]; // Before: an already-superseded caller must not start the switch at all. assert.match( block, /if \(superseded\(\)\) return false;\s*const stackBefore =/, 'the switch must be skipped outright when the caller is already superseded', ); // After: supersession that landed DURING the switch must put the globe back. assert.match( block, /await this\._setMapStack\(state\.mapStack[\s\S]*?if \(superseded\(\)\) \{[\s\S]*?await this\._setMapStack\(stackBefore/, 'a switch superseded mid-flight must be reverted to the stack the winner inherited', ); // And only what is still ours — a newer switch owns the globe, never revert it. assert.match(block, /getSwitchGeneration/, 'the revert must consult the switch generation'); assert.match( block, /if \(globeIsStillOurs && stackBefore && landed !== stackBefore\) \{\s*await this\._setMapStack\(stackBefore/, 'the revert must be guarded by the generation check and the stack that actually landed', ); }); test('a superseded LOAD is refused its visual commit', async () => { // applyVisualState suspends on a map-stack switch and writes its shader // uniforms AFTER that await. A stale LOAD resuming there would commit the // look of a shot the operator has already moved past, so the director hands // it a liveness predicate that is false by the time it would commit. const { director, styleManager, restore } = makeDirector(); const gates = []; styleManager.applyVisualState = (visual, options = {}) => { styleManager.visualCalls.push({ visual, isCurrent: options.isCurrent }); return new Promise((resolve) => { gates.push(resolve); }); }; try { const first = director.loadShot('scene-1', 'shot-a'); const second = director.loadShot('scene-1', 'shot-b'); gates[1](); await settle(); gates[0](); await Promise.all([first, second]); const [stale, live] = styleManager.visualCalls; assert.equal(typeof stale.isCurrent, 'function', 'the visual call must carry a liveness predicate'); assert.equal(stale.isCurrent(), false, 'the superseded LOAD must be refused its commit'); assert.equal(live.isCurrent(), true, 'the live LOAD must still be allowed to commit'); } finally { restore(); } }); test('a run refuses the visual commit of a shot cancelled mid-transition', async () => { const { director, styleManager, restore } = makeDirector(); let releaseVisual; styleManager.applyVisualState = (visual, options = {}) => { styleManager.visualCalls.push({ visual, isCurrent: options.isCurrent }); return new Promise((resolve) => { releaseVisual = resolve; }); }; const run = director.startScene('scene-1', { single: true }); try { await settle(); const call = styleManager.visualCalls[0]; assert.equal(typeof call.isCurrent, 'function', 'the visual call must carry a liveness predicate'); assert.equal(call.isCurrent(), true, 'live while the run owns the shot'); director.stopScene('Stopped (Esc)'); assert.equal(call.isCurrent(), false, 'STOP must revoke the pending commit'); } finally { // Always let the run finish: _finishRun() owns the progress interval, so a // failed assertion that skipped this would leave a live timer behind and // hang the suite instead of reporting. director.stopScene('cleanup'); releaseVisual?.(); await run; restore(); } }); test('the newest LOAD wins when two loads race', async () => { // Both loads suspend on their visual await; the OLDER one resolves second. // Without a generation it completes last and overwrites the newer intent. const { director, viewer, styleManager, dataManager, restore } = makeDirector(); const gates = []; styleManager.applyVisualState = (visual) => { styleManager.visualStates.push(visual); return new Promise((resolve) => { gates.push(resolve); }); }; try { const first = director.loadShot('scene-1', 'shot-a'); const second = director.loadShot('scene-1', 'shot-b'); assert.equal(gates.length, 2); gates[1](); await settle(); gates[0](); await Promise.all([first, second]); assert.deepEqual( dataManager.setEnabledCalls.map(({ id, enabled }) => ({ id, enabled })), [{ id: 'traffic', enabled: true }], ); assert.equal(viewer.flights.length, 1); assert.equal(director._selectedShotId, 'shot-b'); } finally { restore(); } }); test('a scene run supersedes a LOAD still suspended on its visual await', async () => { const { director, styleManager, dataManager, restore } = makeDirector(); let releaseLoadVisual; let calls = 0; styleManager.applyVisualState = (visual) => { styleManager.visualStates.push(visual); if (++calls === 1) return new Promise((resolve) => { releaseLoadVisual = resolve; }); return Promise.resolve(); }; try { const load = director.loadShot('scene-1', 'shot-a'); await settle(); const run = director.startScene('scene-1', { single: true }); releaseLoadVisual(); await Promise.all([load, run]); // Only the run's own shots reconciled; the stale LOAD's flights never did. assert.deepEqual( dataManager.setEnabledCalls.map((call) => call.id), ['flights', 'traffic'], ); } finally { restore(); } }); test('destroy drains cancelled LOAD work before its viewer can be discarded', async (t) => { const restore = installSceneRuntime(); t.after(restore); let finishVisual; const dataManager = fakeDataManager(); const viewer = bindFakeCesiumCamera({ camera: { cancelFlight() {} } }); const director = new SceneDirector(viewer, { applyVisualState: () => new Promise((resolve) => { finishVisual = resolve; }), }, dataManager); const loading = director.loadShot('scene-1', 'shot-a'); let destroyed = false; const stopping = director.destroy().then(() => { destroyed = true; }); await Promise.resolve(); assert.equal(destroyed, false); finishVisual(); await Promise.all([loading, stopping]); assert.equal(destroyed, true); assert.equal(dataManager.setEnabledCalls.length, 0); assert.equal((await director.startScene('scene-1')).reason, 'destroyed'); await director.destroy(); }); test('Scene snapshots are immutable and editing outcomes retain the affected shot and index', async () => { const { director, restore } = makeDirector(); try { director._activeRun = null; director.selectShot('scene-1'); const seen = []; const unsubscribe = director.subscribe((notification) => seen.push(notification)); assert.equal(seen[0].initial, true); assert.equal(seen[0].state.selectedShotId, 'shot-a'); assert.ok(Object.isFrozen(seen[0].state)); director.captureShot(); const captured = seen.find(({ change }) => change?.type === 'shot-captured'); assert.equal(captured.change.index, 2); assert.ok(Object.isFrozen(captured.change.shot.camera)); const id = captured.change.shot.id; director.deleteShot('scene-1', id); const deleted = seen.find(({ change }) => change?.type === 'shot-deleted'); assert.equal(deleted.change.index, 2); assert.equal(deleted.change.shot.id, id); assert.equal(captured.state.selectedShotId, id); unsubscribe(); const count = seen.length; director.captureShot(); assert.equal(seen.length, count); await director.destroy(); } finally { restore(); } }); test('Scene load outcomes exclude superseded and disposed completions', async () => { const { director, styleManager, restore } = makeDirector(); try { director._activeRun = null; const seen = []; director.subscribe(({ change }) => { if (change) seen.push(change); }); const pending = []; styleManager.applyVisualState = () => new Promise((resolve) => pending.push(resolve)); const old = director.loadShot('scene-1', 'shot-a'); const current = director.loadShot('scene-1', 'shot-b'); pending[1](); await current; pending[0](); await old; assert.deepEqual(seen.filter((change) => change.type === 'shot-loaded').map((change) => change.shot.id), ['shot-b']); const late = director.loadShot('scene-1', 'shot-a'); const disposal = director.destroy(); const count = seen.length; pending[2](); await Promise.all([late, disposal]); director.subscribe(() => assert.fail('disposed director must not notify')); assert.equal(seen.length, count); } finally { restore(); } }); test('invalid and unsupported imports retain the current project, selection and saved bytes', async () => { const { director, restore } = makeDirector(); try { const project = director._project; const selected = director._selectedShotId; const saved = localStorage.getItem('godsEyeView.sceneProject.v2'); for (const value of ['{}', '{"version":99,"scenes":[]}', '{"scenes":[{"shots":"bad"}]}']) { await director.importProjectFile({ name: 'bad.json', text: async () => value }); assert.equal(director._project, project); assert.equal(director._selectedShotId, selected); assert.equal(localStorage.getItem('godsEyeView.sceneProject.v2'), saved); assert.match(director._presentation.status, /Import failed: \$/); } let read = false; await director.importProjectFile({ size: 6 * 1024 * 1024, text: async () => { read = true; } }); assert.equal(read, false); assert.equal(director._project, project); } finally { restore(); } }); test('newer imports win delayed file reads, and an empty project is preserved', async () => { const { director, restore } = makeDirector(); try { let release; const older = director.importProjectFile({ name: 'old.json', text: () => new Promise((resolve) => { release = resolve; }) }); await director.importProjectFile({ name: 'empty.json', text: async () => '{"version":3,"scenes":[]}' }); release(JSON.stringify(PROJECT_FIXTURE)); await older; assert.deepEqual(director._project.scenes, []); assert.equal(director._selectedSceneId, null); assert.deepEqual(JSON.parse(localStorage.getItem('godsEyeView.sceneProject.v2')).scenes, []); } finally { restore(); } }); test('unsupported stored documents cannot be overwritten by fallback edits', async () => { const { director, restore } = makeDirector({ project: { version: 99, scenes: [] } }); try { const saved = localStorage.getItem('godsEyeView.sceneProject.v2'); assert.ok(director._storageReadError); director._project.scenes[0].title = 'Fallback edit'; director._saveProject(); assert.equal(localStorage.getItem('godsEyeView.sceneProject.v2'), saved); await director.importProjectFile({ name: 'valid.json', text: async () => JSON.stringify(PROJECT_FIXTURE) }); assert.equal(director._storageReadError, null); assert.equal(JSON.parse(localStorage.getItem('godsEyeView.sceneProject.v2')).version, 7); } finally { restore(); } }); test('valid import settles a cancelled load before replacing the project', async () => { const { director, styleManager, restore } = makeDirector(); let release; styleManager.applyVisualState = () => new Promise((resolve) => { release = resolve; }); try { const before = director._project; const load = director.loadShot('scene-1', 'shot-a'); await settle(); const importing = director.importProjectFile({ name: 'empty.json', text: async () => '{"version":3,"scenes":[]}' }); await settle(); assert.equal(director._project, before, 'old work still owns cleanup'); release(true); await Promise.all([load, importing]); assert.deepEqual(director._project.scenes, []); assert.equal(director._pendingWork.size, 0); assert.equal(director.getPlaybackTimingState().activeTimers, 0); } finally { restore(); } }); test('a delayed import cannot publish after disposal', async () => { const { director, restore } = makeDirector(); let release; try { const before = director._project; const reading = director.importProjectFile({ name: 'empty.json', text: () => new Promise((resolve) => { release = resolve; }) }); await director.destroy(); release('{"version":3,"scenes":[]}'); await reading; assert.equal(director._project, before); } finally { restore(); } }); test('invalid authored edits cannot persist an unreadable project over a good save', () => { const { director, restore } = makeDirector(); try { const before = localStorage.getItem('godsEyeView.sceneProject.v2'); let notice; director._toastStorageError = (message) => { notice = message(); }; director._project.scenes[0].shots[0].camera.lat = 91; director._saveProject(); assert.equal(localStorage.getItem('godsEyeView.sceneProject.v2'), before); assert.match(notice, /camera.lat/); } finally { restore(); } }); test('zero camera pitch is preserved by both immediate placement and ordinary flight', async () => { const { director, viewer, restore } = makeDirector(); try { let placed; viewer.camera.setView = (options) => { placed = options; }; const pose = { lat: 10, lon: 20, alt: 500, heading: 0, pitch: 0, roll: 0 }; director._setCameraView(pose); assert.equal(placed.orientation.pitch, 0); await director._flyCamera(pose, 0.2, { cancelled: false }); assert.equal(viewer.flights.at(-1).orientation.pitch, 0); } finally { restore(); } }); test('camera refusal starts no authored frame or playback clock', async () => { const { director, styleManager, viewer, restore } = makeDirector(); try { const shot = director._project.scenes[0].shots[0]; shot.move = { from: { ...shot.camera, altitudeReference: 'ellipsoid' }, easing: 'linear' }; styleManager.runImmediateNavigation = () => false; assert.equal((await director.startScene('scene-1', { single: true })).reason, 'camera-unavailable'); assert.equal(director._cameraMotion.active, false); assert.equal(director.getPlaybackTimingState().activeTimers, 0); assert.deepEqual(viewer.flights, []); } finally { restore(); } }); test('an unreadable saved project does not overwrite its recovery checkpoint (#971)', async () => { const unreadable = '{"version":99,"scenes":[]}'; const warn = console.warn; console.warn = () => {}; const { director, storage, restore } = makeDirector({ storage: { 'godsEyeView.sceneProject.v2': unreadable, 'godsEyeView.sceneProject.checkpoint.v1': 'EARLIER-CHECKPOINT', } }); try { assert.equal(storage.stored.get('godsEyeView.sceneProject.v2'), unreadable); assert.equal(storage.stored.get('godsEyeView.sceneProject.checkpoint.v1'), 'EARLIER-CHECKPOINT'); } finally { console.warn = warn; await director.destroy(); restore(); } }); test('a capture, update or import that cannot be saved keeps the "Scene not saved" status (#971)', async () => { const warn = console.warn; console.warn = () => {}; const { director, storage, restore } = makeDirector(); let status = ''; director.subscribe(({ state }) => { status = state.status; }); try { storage.full = true; director._selectedSceneId = 'scene-1'; director._selectedShotId = 'shot-a'; director.captureShot(); assert.match(status, /^Scene not saved/, 'failed capture keeps the save failure'); director.updateSelectedShot(); assert.match(status, /^Scene not saved/, 'failed update keeps the save failure'); assert.equal(await director.importProjectFile( { name: 'fixture.json' }, { prepared: { project: structuredClone(PROJECT_FIXTURE), assets: [] } }, ), true); assert.match(status, /^Scene not saved/, 'failed import keeps the save failure'); const toast = useStatusStore(applicationPinia()).toast; assert.equal(toast.visible, true); assert.match(toast.text, /^Scene not saved/, 'the page toast says so too'); } finally { console.warn = warn; await director.destroy(); restore(); } }); test('startScene resolves its result, resumes after a shot without a scene id, and counts distinct scenes (#971)', async () => { const { director, restore } = makeDirector(); try { const options = { single: true, preview: false }; assert.deepEqual(await director.startScene('scene-1', options), { started: true, shots: 2 }); assert.equal(director._lastRun.scenesRun, 1, 'one scene with two shots is one scene run'); assert.deepEqual( await director.startScene(undefined, { ...options, afterShotId: 'shot-a' }), { started: true, shots: 1 }, ); } finally { await director.destroy(); restore(); } }); test('a revoked scene release turns no further layer off', async () => { const project = structuredClone(PROJECT_FIXTURE); project.scenes[0].releaseLayerIds = ['flights', 'traffic']; const { director, dataManager, restore } = makeDirector({ project }); try { const calls = []; let finishFirst; dataManager.setEnabled = (id, enabled, { signal }) => { calls.push({ id, enabled, signal }); // The first layer's disable hangs, as a stuck teardown does. return new Promise((resolve) => { finishFirst = resolve; }); }; const releasing = director._releaseSceneLayers(director._project.scenes[0]); await settle(); assert.deepEqual(calls.map(({ id }) => id), ['flights']); director.revokeSceneRelease(); assert.equal(calls[0].signal.aborted, true, 'the disable under way is aborted'); finishFirst(true); assert.equal(await releasing, false); assert.deepEqual( calls.map(({ id }) => id), ['flights'], 'the next layer is never turned off', ); // A release started afterwards has its say again. dataManager.setEnabled = async (id, enabled, { signal }) => { calls.push({ id, enabled, signal }); return true; }; assert.equal(await director._releaseSceneLayers(director._project.scenes[0]), true); assert.deepEqual(calls.slice(1).map(({ id }) => id), ['flights', 'traffic']); } finally { await director.destroy(); restore(); } }); test('a revocation also covers the release a stopped run reaches later', async () => { const project = structuredClone(PROJECT_FIXTURE); project.scenes[0].releaseLayerIds = ['flights']; const { director, styleManager, dataManager, restore } = makeDirector({ project }); try { // The run's visual phase hangs and ignores Stop, as a stuck teardown does. let settlePhase; styleManager.applyVisualState = () => new Promise((resolve) => { settlePhase = resolve; }); const run = director.startScene('scene-1', { single: true, preview: true }); await settle(); assert.ok(settlePhase, 'the run is waiting in its phase'); director.stopScene(); director.revokeSceneRelease(); const after = dataManager.setEnabledCalls.length; settlePhase(true); await run; const late = dataManager.setEnabledCalls .slice(after) .filter(({ enabled, signal }) => !enabled && !signal?.aborted); assert.deepEqual(late, [], 'no layer is turned off after the revoke'); // A run started afterwards releases its layers again. styleManager.applyVisualState = async () => true; await director.startScene('scene-1', { single: true, preview: true }); assert.ok( dataManager.setEnabledCalls.some( ({ id, enabled, signal }) => id === 'flights' && !enabled && !signal?.aborted, ), ); } finally { await director.destroy(); restore(); } }); test('a hold resumed partway waits for a clip that starts again, else only its rest', async () => { const hold = async (pendingReads) => { let reads = 0; const module = { getSceneShotMediaHold: () => ({ pending: reads++ < pendingReads, maxWaitMs: 20000 }), sceneShotRestartsMedia: () => pendingReads > 0, }; const waits = []; await SceneDirector.prototype._holdShot.call( { _layerStatesForShot: () => ({ media: { enabled: true, params: { beatId: 'b' } } }), dataManager: { layers: new Map([['media', { module }]]) }, _effectiveShotHoldSec: () => 3, _sleep: async (ms) => waits.push(ms), stopScene: () => assert.fail('no timeout'), }, { id: 'scene' }, { id: 'shot' }, { cancelled: false }, { holdElapsedSec: 1, holdDurationSec: 3 }, ); return waits; }; // The clip plays again: the hold polls until it is done, as any hold does. const polls = await hold(4); assert.ok(polls.length && polls.every((ms) => ms === 70), String(polls)); // The moment was past the clip: only the rest of the hold. assert.deepEqual(await hold(0), [2000]); }); /** Drive frame-by-frame camera motion headlessly for one test. */ function installAnimationFrames() { const original = globalThis.requestAnimationFrame; const originalCancel = globalThis.cancelAnimationFrame; globalThis.requestAnimationFrame = (callback) => setTimeout(callback, 16); globalThis.cancelAnimationFrame = (handle) => clearTimeout(handle); return () => { globalThis.requestAnimationFrame = original; globalThis.cancelAnimationFrame = originalCancel; }; } test('a run resumed inside a flight goes on from that point of the path and clock', async () => { const { director, viewer, restore } = makeDirector(); const restoreFrames = installAnimationFrames(); const clock = []; director.subscribeSceneClock((snap) => clock.push(snap)); const poses = []; const setView = director._setCameraView.bind(director); director._setCameraView = (pose) => { poses.push(pose); return setView(pose); }; try { // 0.75 of a 0.4 s scene: halfway along shot B's 0.2 s flight. const run = director.startScene('scene-1', { single: true, fromProgress: 0.75, preview: false, }); await settle(40); const first = clock.find((snap) => snap.running); assert.equal(first.shotId, 'shot-b', 'starts in the shot that moment is in'); assert.ok(Math.abs(first.sceneElapsedSec - 0.3) < 1e-9, 'the clock starts at the moment'); // The first frame is the seek's own framing, halfway from A to B. assert.ok(poses.length, 'the camera is driven from where it is'); assert.ok(Math.abs(poses[0].lat - -10) < 0.5, 'halfway from A to B'); assert.deepEqual(await run, { started: true, shots: 1 }); assert.equal(poses.at(-1).lat, -30, 'and ends on shot B'); assert.equal(viewer.flights.length, 0, 'no fresh flight from the shot start'); assert.equal(director._lastRun.wasCancelled, false); } finally { await director.destroy(); restoreFrames(); restore(); } }); test('a run resumed inside a hold plays its layers on from the seek’s state and waits only the rest of it', async () => { const project = structuredClone(PROJECT_FIXTURE); project.scenes[0].shots[0].holdSec = 0.6; const { director, viewer, restore } = makeDirector({ project }); const layerCalls = []; const layerStates = director._layerStatesForShot.bind(director); director._layerStatesForShot = (scene, shot, options) => { layerCalls.push({ shot, options }); return layerStates(scene, shot, options); }; const clock = []; director.subscribeSceneClock((snap) => clock.push(snap)); const poses = []; const setView = director._setCameraView.bind(director); director._setCameraView = (pose) => { poses.push(pose); return setView(pose); }; const sleeps = []; const sleep = director._sleep.bind(director); director._sleep = (ms, token) => { sleeps.push(ms); return sleep(ms, token); }; try { // Shot A is 0.2 s of flight and 0.6 s of hold; the scene is 1 s long. // 0.6 of it is 0.4 s into A's hold, with 0.2 s of it left. const result = await director.startScene('scene-1', { single: true, fromProgress: 0.6, preview: false, }); assert.deepEqual(result, { started: true, shots: 2 }); const first = clock.find((snap) => snap.running); assert.equal(first.shotId, 'shot-a'); assert.ok(Math.abs(first.sceneElapsedSec - 0.6) < 1e-9); assert.ok(Math.abs(sleeps[0] - 200) < 1e-6, 'only the rest of the hold'); // Shot A's camera is placed at its end; only shot B flies. assert.equal(poses[0].lat, 10); assert.equal(viewer.flights.length, 1); const seekStates = layerCalls.filter(({ options }) => options?.sceneSeek); assert.equal(seekStates.length, 1, 'shot A’s layers are given the moment'); assert.equal(seekStates[0].shot.id, 'shot-a'); assert.ok(Math.abs(seekStates[0].options.sceneSeek.holdElapsedSec - 0.4) < 1e-9); // Then they play on from that moment: shot A settles without the seek. const after = layerCalls.slice(layerCalls.indexOf(seekStates[0]) + 1); const played = after.find(({ shot }) => shot.id === 'shot-a'); assert.ok(played, 'shot A’s layers go back to running playback'); assert.equal(played.options.cameraSettled, true); assert.equal(played.options.sceneSeek, undefined); } finally { await director.destroy(); restore(); } }); test('a caught run failure resolves as run-failed, not success (#971)', async () => { const { director, styleManager, restore } = makeDirector(); const warn = console.warn; console.warn = () => {}; styleManager.applyVisualState = async () => { throw new Error('visual failed'); }; try { assert.deepEqual( await director.startScene('scene-1', { single: true, preview: false }), { started: false, reason: 'run-failed' }, ); } finally { console.warn = warn; await director.destroy(); restore(); } }); test('listShots gives a scene its shots in order, each starting where the last ends', () => { const { director, restore } = makeDirector(); try { const scene = director._project.scenes[0]; const shots = director.listShots(scene.id); assert.deepEqual( shots.map((s) => s.id), scene.shots.map((s) => s.id), ); assert.equal(shots[0].startSec, 0); for (let i = 1; i < shots.length; i++) assert.equal( shots[i].startSec, shots[i - 1].startSec + shots[i - 1].durationSec, ); assert.ok(shots.every((s) => typeof s.title === 'string' && s.title)); assert.deepEqual(director.listShots('no-such-scene'), []); } finally { restore(); } }); test('selectShot selects a scene and shot for authoring, falling back to the first shot', () => { const { director, restore } = makeDirector(); try { const scene = director._project.scenes.at(-1); const last = scene.shots.at(-1); assert.equal(director.selectShot(scene.id, last.id), true); assert.equal(director._selectedSceneId, scene.id); assert.equal(director._selectedShotId, last.id); assert.equal(director.selectShot(scene.id, 'no-such-shot'), true); assert.equal(director._selectedShotId, scene.shots[0].id); assert.equal(director.selectShot('no-such-scene'), false); assert.deepEqual(director.selection(), { sceneId: scene.id, shotId: scene.shots[0].id, }); assert.equal(director.hasScene(scene.id), true); assert.equal(director.hasScene('no-such-scene'), false); // No scene id changes nothing. assert.equal(director.selectShot(null), false); assert.equal(director._selectedSceneId, scene.id); } finally { restore(); } }); test('whenIdle waits for tracked work, including work started while waiting', async () => { const { director, restore } = makeDirector(); try { let first; let second; director._trackWork(new Promise((resolve) => (first = resolve))); let idle = false; const waiting = director.whenIdle().then(() => (idle = true)); await settle(); director._trackWork(new Promise((resolve) => (second = resolve))); first(); await settle(); assert.equal(idle, false, 'the later work is still pending'); second(); await waiting; assert.equal(idle, true); } finally { restore(); } }); /** Record the change types a director publishes. */ function recordChanges(director) { const types = []; director.subscribe(({ change }) => { if (change?.type) types.push(change.type); }); return types; } const savedProject = () => JSON.parse(localStorage.getItem('godsEyeView.sceneProject.v2')); test('setSceneInStories saves the flag, publishes, and storyScenes lists the scene', () => { const { director, restore } = makeDirector(); try { const changes = recordChanges(director); const scene = director._project.scenes[0]; assert.deepEqual(director.storyScenes(), []); assert.equal(director.setSceneInStories(scene.id, true), true); assert.equal(savedProject().scenes[0].stories, true); assert.ok(changes.includes('stories-changed')); assert.deepEqual(director.storyScenes(), [ { id: scene.id, title: 'Fixture Scene', camera: { lat: 10, lon: 20, alt: 500000, heading: 0, pitch: -40, roll: 0, }, shotCount: 2, thumb: '', tags: [], }, ]); // The camera is a copy; editing it leaves the project alone. director.storyScenes()[0].camera.lat = 0; assert.equal(scene.shots[0].camera.lat, 10); changes.length = 0; assert.equal(director.setSceneInStories(scene.id, false), true); assert.equal(Object.hasOwn(savedProject().scenes[0], 'stories'), false); assert.deepEqual(changes, ['stories-changed']); assert.deepEqual(director.storyScenes(), []); assert.equal(director.setSceneInStories('no-such-scene', true), false); } finally { restore(); } }); test('draftScenes lists the person’s own scenes with shots that are not on the Stories page', () => { const { director, restore } = makeDirector(); try { const scene = director._project.scenes[0]; // The fixture scene is the person's own: a draft until saved. assert.deepEqual( director.draftScenes().map(({ id }) => id), [scene.id], ); director.setSceneInStories(scene.id, true); assert.deepEqual(director.draftScenes(), [], 'saved: no longer a draft'); director.setSceneInStories(scene.id, false); // A built-in scene is never a draft. scene.id = 'flights-radar'; assert.deepEqual(director.draftScenes(), []); } finally { restore(); } }); test('a scene without shots cannot be saved to Stories', () => { const project = structuredClone(PROJECT_FIXTURE); project.scenes.push({ id: 'empty', title: 'Empty', shots: [] }); const { director, restore } = makeDirector({ project }); try { const changes = recordChanges(director); assert.equal(director.setSceneInStories('empty', true), false); assert.equal(Object.hasOwn(director._project.scenes[1], 'stories'), false); assert.equal(changes.includes('stories-changed'), false); // Taking it off is always allowed. assert.equal(director.setSceneInStories('empty', false), true); } finally { restore(); } }); test('the Stories flag survives a reload and an export/import round trip', async () => { const project = structuredClone(PROJECT_FIXTURE); project.scenes.push({ id: 'scene-2', title: 'Second', shots: PROJECT_FIXTURE.scenes[0].shots.map((shot) => ({ ...structuredClone(shot), id: `${shot.id}-2`, })), }); const first = makeDirector({ project }); let saved; try { first.director.setSceneInStories('scene-2', true); saved = localStorage.getItem('godsEyeView.sceneProject.v2'); } finally { first.restore(); } const { director, restore } = makeDirector({ storage: { 'godsEyeView.sceneProject.v2': saved }, }); try { assert.deepEqual( director.storyScenes().map((s) => s.id), ['scene-2'], ); const exported = stringifySceneDocument(director._project); director.setSceneInStories('scene-2', false); const changes = recordChanges(director); assert.equal( await director.importProjectFile({ name: 'scenes.json', text: async () => exported, }), true, ); assert.ok(changes.includes('stories-changed')); assert.deepEqual( director.storyScenes().map((s) => s.id), ['scene-2'], ); assert.equal(savedProject().scenes[1].stories, true); assert.equal(Object.hasOwn(savedProject().scenes[0], 'stories'), false); } finally { restore(); } }); test('projects saved before the Stories flag still load, and a malformed flag is refused', async () => { const { director, restore } = makeDirector(); try { assert.equal(Object.hasOwn(director._project.scenes[0], 'stories'), false); const project = { ...structuredClone(PROJECT_FIXTURE), version: 7 }; project.scenes[0].stories = 'yes'; const before = director._project; await director.importProjectFile({ name: 'bad.json', text: async () => JSON.stringify(project), }); assert.equal(director._project, before); assert.match(director._presentation.status, /stories: expected true/); } finally { restore(); } }); test('deleting a scene or its last shot in Stories publishes stories-changed', () => { const project = structuredClone(PROJECT_FIXTURE); project.scenes.push({ id: 'scene-2', title: 'Second', shots: [ { ...structuredClone(PROJECT_FIXTURE.scenes[0].shots[0]), id: 'only' }, ], }); const { director, restore } = makeDirector({ project }); try { director.setSceneInStories('scene-1', true); director.setSceneInStories('scene-2', true); const changes = recordChanges(director); director.deleteShot('scene-2', 'only'); assert.ok(changes.includes('stories-changed')); assert.equal(Object.hasOwn(director._project.scenes[1], 'stories'), false); assert.deepEqual( director.storyScenes().map((s) => s.id), ['scene-1'], ); changes.length = 0; director.selectShot('scene-1'); director._deleteSelectedScene(); assert.ok(changes.includes('scene-deleted')); assert.ok(changes.includes('stories-changed')); assert.deepEqual(director.storyScenes(), []); } finally { restore(); } }); test('authoring selects the first scene and shot on load, with or without a saved project', () => { for (const options of [{}, { storage: {} }]) { const { director, restore } = makeDirector(options); try { const [first] = director._project.scenes; assert.ok(first, 'the project has scenes'); assert.equal(director._selectedSceneId, first.id); assert.equal(director._selectedShotId, first.shots[0]?.id ?? null); director._selectedSceneId = 'gone'; director._renderSceneSelect(); assert.equal( director._selectedSceneId, first.id, 'a missing scene falls back to the first scene', ); } finally { restore(); } } }); test('capture with no scene starts a new scene and captures into it', () => { const { director, restore } = makeDirector(); try { // An imported empty project leaves nothing selected. director._selectedSceneId = null; director._selectedShotId = null; const changes = recordChanges(director); const before = director._project.scenes.length; director.captureShot(); assert.equal(director._project.scenes.length, before + 1); const scene = director._project.scenes.at(-1); assert.equal(scene.title, `Scene ${before + 1}`); assert.equal(director._selectedSceneId, scene.id); assert.equal(scene.shots.length, 1); assert.equal(director._selectedShotId, scene.shots[0].id); assert.deepEqual( changes.filter((type) => ['scene-created', 'shot-captured'].includes(type), ), ['scene-created', 'shot-captured'], ); assert.equal(savedProject().scenes.at(-1).shots.length, 1); } finally { restore(); } }); test('capture with no scene and no camera creates nothing', () => { const { director, styleManager, restore } = makeDirector(); try { styleManager.getCameraState = () => null; director._selectedSceneId = null; const before = director._project.scenes.length; director.captureShot(); assert.equal(director._project.scenes.length, before); assert.equal(director._selectedSceneId, null); } finally { restore(); } }); test('deleting the current scene selects the first scene', () => { const project = structuredClone(PROJECT_FIXTURE); project.scenes.push({ id: 'scene-2', title: 'Second', shots: [] }); const { director, restore } = makeDirector({ project }); try { director.selectShot('scene-2'); director._deleteSelectedScene(); assert.equal(director._selectedSceneId, 'scene-1'); assert.equal(director._selectedShotId, 'shot-a'); assert.deepEqual( director._project.scenes.map(({ id }) => id), ['scene-1'], ); } finally { restore(); } }); test('an import keeps the current scene, else picks a non-built-in scene, else the first', async () => { const { director, restore } = makeDirector(); try { const exported = stringifySceneDocument(director._project); const file = { name: 'scenes.json', text: async () => exported }; assert.equal(await director.importProjectFile(file), true); assert.equal(director._selectedSceneId, 'scene-1', 'the authored scene'); const builtIn = JSON.stringify({ version: 6, scenes: [ { ...structuredClone(PROJECT_FIXTURE.scenes[0]), id: SCENE_RECIPES[0].id, }, ], }); assert.equal( await director.importProjectFile({ name: 'b.json', text: async () => builtIn, }), true, ); assert.equal( director._selectedSceneId, SCENE_RECIPES[0].id, 'a built-in scene only when there is nothing else', ); // An appended pack's scene is built in too, as Stories' drafts count it. const [pack] = SCENE_APPEND_RECIPES; const withPack = JSON.stringify({ version: 6, scenes: [ { ...structuredClone(PROJECT_FIXTURE.scenes[0]), id: pack.id }, { ...structuredClone(PROJECT_FIXTURE.scenes[0]), id: 'mine' }, ], }); director._selectedSceneId = null; assert.equal( await director.importProjectFile({ name: 'c.json', text: async () => withPack, }), true, ); assert.equal(director._selectedSceneId, 'mine'); assert.deepEqual(director.draftScenes().map(({ id }) => id), ['mine']); } finally { restore(); } }); const THUMB = 'data:image/jpeg;base64,/9j/AAAA'; test('story thumbnail and tags are saved, listed and announced for a scene in Stories', () => { const { director, restore } = makeDirector(); try { const changes = recordChanges(director); assert.equal(director.setSceneStoryThumb('scene-1', THUMB), true); assert.equal( director.setSceneStoryTags('scene-1', ['Floods', 'Climate']), true, ); assert.equal(savedProject().scenes[0].storyThumb, THUMB); assert.deepEqual(savedProject().scenes[0].storyTags, ['Floods', 'Climate']); assert.equal( changes.filter((type) => type === 'story-details-changed').length, 2, ); assert.equal( changes.includes('stories-changed'), false, 'not in Stories yet', ); director.setSceneInStories('scene-1', true); assert.equal(director.storyScenes()[0].thumb, THUMB); assert.deepEqual(director.storyScenes()[0].tags, ['Floods', 'Climate']); director.storyScenes()[0].tags.push('Space'); assert.deepEqual(director._project.scenes[0].storyTags, [ 'Floods', 'Climate', ]); changes.length = 0; director.setSceneStoryThumb('scene-1', 'data:image/png;base64,AAAA'); assert.ok(changes.includes('stories-changed')); changes.length = 0; director.selectShot('scene-1'); director._toggleSelectedSceneTag('Floods'); assert.ok(changes.includes('stories-changed')); assert.deepEqual(director.storyScenes()[0].tags, ['Climate']); director._toggleSelectedSceneTag('Climate'); assert.equal( Object.hasOwn(director._project.scenes[0], 'storyTags'), false, ); assert.deepEqual(director.storyScenes()[0].tags, []); // Unknown tags, more than five, or no such scene are refused. assert.equal(director.setSceneStoryTags('scene-1', ['Nope']), false); assert.equal( director.setSceneStoryTags('scene-1', STORY_TAGS.slice(0, 6)), false, ); assert.equal(director.setSceneStoryTags('no-such-scene', []), false); assert.equal(director.setSceneStoryThumb('no-such-scene', THUMB), false); director.setSceneStoryTags('scene-1', STORY_TAGS.slice(0, 5)); director._toggleSelectedSceneTag(STORY_TAGS[5]); assert.equal(director._project.scenes[0].storyTags.length, 5); } finally { restore(); } }); test('an invalid thumbnail is not kept and the save error is shown', () => { const { director, restore } = makeDirector(); try { // A thumbnail may pass the usual 65,536-character text limit. const large = `data:image/jpeg;base64,${'A'.repeat(200000)}`; assert.equal(director.setSceneStoryThumb('scene-1', large), true); assert.equal(savedProject().scenes[0].storyThumb, large); director.setSceneStoryThumb('scene-1', THUMB); assert.equal( director.setSceneStoryThumb('scene-1', 'https://example.com/a.jpg'), false, ); assert.equal(director._project.scenes[0].storyThumb, THUMB); assert.match(director._presentation.status, /Scene not saved/); } finally { restore(); } }); test('SAVE TO STORIES and tags that cannot be saved roll back and show the save error', () => { const warn = console.warn; console.warn = () => {}; const { director, storage, restore } = makeDirector(); const changes = recordChanges(director); try { director.setSceneStoryTags('scene-1', ['Storms']); storage.full = true; changes.length = 0; assert.equal(director.setSceneInStories('scene-1', true), false); assert.equal(Object.hasOwn(director._project.scenes[0], 'stories'), false); assert.deepEqual(director.storyScenes(), []); assert.match(director._presentation.status, /^Scene not saved/); assert.equal(director.setSceneStoryTags('scene-1', ['Floods', 'Storms']), false); assert.deepEqual(director._project.scenes[0].storyTags, ['Storms']); assert.equal(director.setSceneStoryTags('scene-1', []), false); assert.deepEqual(director._project.scenes[0].storyTags, ['Storms']); assert.deepEqual( changes.filter((type) => type !== 'status-changed'), [], 'only the save error is announced', ); // Taking a scene off Stories rolls back the same way. storage.full = false; assert.equal(director.setSceneInStories('scene-1', true), true); storage.full = true; assert.equal(director.setSceneInStories('scene-1', false), false); assert.equal(director._project.scenes[0].stories, true); // The panel's toggle reports no success either. director._selectedSceneId = 'scene-1'; director._toggleSelectedSceneInStories(); assert.equal(director._project.scenes[0].stories, true); assert.match(director._presentation.status, /^Scene not saved/); } finally { console.warn = warn; restore(); } }); test('story thumbnail and tags survive a reload and an export/import round trip', async () => { const first = makeDirector(); let saved; try { first.director.setSceneStoryThumb('scene-1', THUMB); first.director.setSceneStoryTags('scene-1', ['Storms']); // Draft builds wrote the same optional Stories fields in version 6. saved = JSON.stringify({ ...savedProject(), version: 6 }); } finally { first.restore(); } const { director, restore } = makeDirector({ storage: { 'godsEyeView.sceneProject.v2': saved }, }); try { const scene = director._project.scenes.find(({ id }) => id === 'scene-1'); assert.equal(scene.storyThumb, THUMB); assert.deepEqual(scene.storyTags, ['Storms']); const exported = stringifySceneDocument(director._project); assert.equal(JSON.parse(exported).version, 7); director.setSceneStoryTags('scene-1', []); director.setSceneStoryThumb('scene-1', 'data:image/png;base64,AAAA'); assert.equal( await director.importProjectFile({ name: 'scenes.json', text: async () => exported, }), true, ); assert.equal(director._project.scenes[0].storyThumb, THUMB); assert.deepEqual(director._project.scenes[0].storyTags, ['Storms']); assert.equal(savedProject().scenes[0].storyThumb, THUMB); } finally { restore(); } }); test('Stories fields are refused before document version 6, like other new fields', () => { for (const [field, value] of [ ['stories', true], ['storyThumb', THUMB], ['storyTags', ['Storms']], ]) { const project = { ...structuredClone(PROJECT_FIXTURE), version: 5 }; project.scenes[0][field] = value; assert.throws( () => validateSceneDocument(project), new RegExp(`scenes\\[0\\]\\.${field}`), field, ); validateSceneDocument({ ...project, version: 6 }); validateSceneDocument({ ...project, version: 7 }); } }); test('imports with a malformed thumbnail or tags are refused', async () => { const { director, restore } = makeDirector(); try { const before = director._project; for (const [field, value, reason] of [ [ 'storyThumb', 'data:image/gif;base64,AAAA', /storyThumb: expected a JPEG or PNG data URL/, ], [ 'storyThumb', `data:image/jpeg;base64,${'A'.repeat(300000)}`, /storyThumb/, ], [ 'storyTags', ['Floods', 'Floods'], /storyTags: expected at most 5 different Stories tags/, ], ['storyTags', ['Volcanoes'], /storyTags/], ['storyTags', STORY_TAGS.slice(0, 6), /storyTags/], ]) { const project = { ...structuredClone(PROJECT_FIXTURE), version: 7 }; project.scenes[0][field] = value; await director.importProjectFile({ name: 'bad.json', text: async () => JSON.stringify(project), }); assert.equal(director._project, before, field); assert.match(director._presentation.status, reason); } } finally { restore(); } }); test('THUMBNAIL stores only a credited Esri frame on the selected scene', async () => { const { director, viewer, styleManager, restore } = makeDirector(); const createElement = document.createElement; try { assert.equal( await director.captureSceneThumb(), false, 'no scene, no capture', ); director.selectShot('scene-1'); let activeId = 'photoreal'; styleManager.mapStackController = { getState: () => ({ activeId, status: 'ready' }), }; // The renderer's frame port: postRender runs on the frame it is asked for. const listeners = new Set(); const renderer = rendererOf(viewer); viewer.canvas = { width: 640, height: 360 }; renderer.credits = { list: () => [{ text: 'Powered by Esri — Source: Esri and Maxar' }], }; renderer.frame = { on(phase, listener) { assert.equal(phase, 'postRender'); listeners.add(listener); return () => listeners.delete(listener); }, requestRender() {}, }; const frame = () => [...listeners].forEach((listener) => listener()); const credit = []; document.createElement = () => ({ getContext: () => ({ drawImage() {}, fillRect() {}, fillText: (line) => credit.push(line), }), toDataURL: () => THUMB, }); assert.equal(await director.captureSceneThumb(), false); assert.equal(listeners.size, 0); activeId = 'esri-imagery'; const capturing = director.captureSceneThumb(); frame(); assert.equal(await capturing, true); assert.ok(credit.some((line) => /Esri/.test(line))); assert.equal(director._project.scenes[0].storyThumb, THUMB); assert.equal(director._presentation.status, 'Thumbnail captured'); const switching = director.captureSceneThumb(); activeId = 'photoreal'; credit.length = 0; frame(); assert.equal(await switching, false); assert.deepEqual(credit, []); assert.equal(director._project.scenes[0].storyThumb, THUMB); activeId = 'esri-imagery'; delete renderer.frame; assert.equal(await director.captureSceneThumb(), false); assert.equal( director._presentation.status, 'Thumbnail could not be captured', ); } finally { document.createElement = createElement; restore(); } });