// One-click transfer pipeline for clicked world targets (pre-launch defect #4). // The layer only announces the click; the UI owns the camera. import { test } from 'node:test'; import assert from 'node:assert/strict'; import * as Cesium from 'cesium'; import { WORLD_CLICK_FOCUS_DURATION_SEC, WORLD_FOCUS_FRAMING, WORLD_FOCUS_REQUEST_EVENT, flyToWorldTarget, isValidWorldFocusTarget, registerWorldFocusRequestListener, requestWorldFocus, routeWorldFocusRequest, } from './worldFocus.js'; const POSITION = Cesium.Cartesian3.fromDegrees(-97.74, 30.26, 0); function stubCamera() { const calls = { cancelFlight: 0, flights: [] }; return { calls, heading: Cesium.Math.toRadians(45), cancelFlight() { calls.cancelFlight += 1; }, flyToBoundingSphere(sphere, options) { calls.flights.push({ sphere, options }); }, }; } test('a focus request carries the clicked target to any registered listener', () => { const target = new EventTarget(); const seen = []; const dispose = registerWorldFocusRequestListener(target, (event) => seen.push(event.detail), ); assert.equal( requestWorldFocus( { kind: 'vessel', position: POSITION, id: '123' }, target, ), true, ); assert.equal(seen.length, 1); assert.equal(seen[0].kind, 'vessel'); assert.equal(seen[0].id, '123'); // Disposal is idempotent and removes the exact listener. dispose(); dispose(); requestWorldFocus({ kind: 'vessel', id: '123', position: POSITION }, target); assert.equal(seen.length, 1); }); test('requests without a kind or a position are dropped, never dispatched', () => { const target = new EventTarget(); let count = 0; target.addEventListener(WORLD_FOCUS_REQUEST_EVENT, () => { count += 1; }); assert.equal(requestWorldFocus({ position: POSITION }, target), false); assert.equal(requestWorldFocus({ kind: 'vessel' }, target), false); assert.equal(requestWorldFocus(null, target), false); assert.equal(count, 0); }); test('routing hands the request to the UI policy, which owns the flight', () => { const order = []; const result = routeWorldFocusRequest( { detail: { kind: 'fire', id: 'fire-1', position: POSITION } }, (detail, fly) => { order.push(`policy:${detail.kind}`); return fly(); }, (detail) => { order.push(`fly:${detail.kind}`); return 'flew'; }, ); // The policy runs FIRST — it releases the follow camera before the flight. assert.deepEqual(order, ['policy:fire', 'fly:fire']); assert.equal(result, 'flew'); }); test('a refusing policy (cockpit owns the camera) never reaches the flight', () => { let flights = 0; const result = routeWorldFocusRequest( { detail: { kind: 'vessel', id: '123', position: POSITION } }, () => false, () => { flights += 1; }, ); assert.equal(result, false); assert.equal(flights, 0); }); test('malformed requests are inert', () => { assert.equal( routeWorldFocusRequest( null, () => 'x', () => 'y', ), false, ); assert.equal( routeWorldFocusRequest( { detail: { kind: 'vessel' } }, () => 'x', () => 'y', ), false, ); }); // A request that cannot fly must never cost the user their tracking: the UI // policy releases the follow camera, so validation happens BEFORE it runs. test('an unflyable request never reaches the release policy', () => { const unflyable = [ { kind: 'plane', position: POSITION }, // no framing for this kind { kind: 'vessel', position: { x: NaN, y: 0, z: 0 } }, // malformed position { kind: 'vessel', position: { x: 0, y: 0 } }, // truthy but incomplete { kind: 'vessel', id: '123', position: { x: 0, y: 0, z: 0 } }, // ECEF origin { kind: 'fire', id: 'fire-1', position: { x: 1, y: 1, z: 1 } }, // finite but inside Earth { kind: 'vessel', position: 'somewhere' }, { kind: 'vessel', position: POSITION }, // missing owner id { position: POSITION }, ]; for (const detail of unflyable) { assert.equal( isValidWorldFocusTarget(detail), false, JSON.stringify(detail), ); let policyRuns = 0; const result = routeWorldFocusRequest( { detail }, () => { policyRuns += 1; return 'released'; }, () => 'flew', ); assert.equal(result, false, JSON.stringify(detail)); assert.equal( policyRuns, 0, `the policy must not run for ${JSON.stringify(detail)}`, ); // Nor may such a request be dispatched in the first place. assert.equal(requestWorldFocus(detail, new EventTarget()), false); } assert.equal( isValidWorldFocusTarget({ kind: 'vessel', id: '123', position: POSITION }), true, ); assert.equal( isValidWorldFocusTarget({ kind: 'fire', id: 'fire-1', position: POSITION }), true, ); }); test('the transfer flight supersedes any flight in progress and keeps the operator heading', () => { const camera = stubCamera(); assert.equal( flyToWorldTarget( { camera }, { kind: 'vessel', id: '123', position: POSITION }, ), true, ); assert.equal( camera.calls.cancelFlight, 1, 'a prior flight must be cancelled, not queued', ); assert.equal(camera.calls.flights.length, 1); const { sphere, options } = camera.calls.flights[0]; assert.equal(sphere.radius, WORLD_FOCUS_FRAMING.vessel.radiusM); assert.equal(options.duration, WORLD_CLICK_FOCUS_DURATION_SEC); assert.equal(options.offset.range, WORLD_FOCUS_FRAMING.vessel.rangeM); // Heading is preserved so the transfer never spins the operator around. assert.equal(options.offset.heading, camera.heading); assert.equal(options.easingFunction, Cesium.EasingFunction.CUBIC_IN_OUT); }); test('fires frame wider than vessels — a fire is read by its surroundings', () => { const camera = stubCamera(); flyToWorldTarget( { camera }, { kind: 'fire', id: 'fire-1', position: POSITION }, ); const { sphere, options } = camera.calls.flights[0]; assert.equal(sphere.radius, WORLD_FOCUS_FRAMING.fire.radiusM); assert.equal(options.offset.range, WORLD_FOCUS_FRAMING.fire.rangeM); assert.ok( WORLD_FOCUS_FRAMING.fire.rangeM > WORLD_FOCUS_FRAMING.vessel.rangeM, ); assert.ok( WORLD_FOCUS_FRAMING.fire.radiusM > WORLD_FOCUS_FRAMING.vessel.radiusM, ); }); test('every framing is a real oblique standoff, not a nadir or an inside-out sphere', () => { const kinds = Object.keys(WORLD_FOCUS_FRAMING); assert.deepEqual(kinds.sort(), [ 'fire', 'sighting', 'sighting-area', 'vessel', ]); for (const kind of kinds) { const framing = WORLD_FOCUS_FRAMING[kind]; // Looking DOWN at the target, but obliquely — a nadir drop reads as a map. assert.ok( framing.pitchDeg < 0, `${kind}: pitch must look down, got ${framing.pitchDeg}`, ); assert.ok( framing.pitchDeg > -80, `${kind}: pitch must stay oblique, got ${framing.pitchDeg}`, ); // Standing off outside the framed sphere, at a human-readable distance. assert.ok(framing.radiusM > 0, `${kind}: radius must be positive`); assert.ok( framing.rangeM > framing.radiusM, `${kind}: range ${framing.rangeM} must stand off outside radius ${framing.radiusM}`, ); // An obscured sighting frames its entire 0.2° privacy cell. const maximumRange = kind === 'sighting-area' ? 60000 : 10000; assert.ok( framing.rangeM <= maximumRange, `${kind}: range must fit its surface extent, got ${framing.rangeM}`, ); } // Exact shipped values — a silent retune must show up as a failing test. assert.deepEqual( { ...WORLD_FOCUS_FRAMING.vessel }, { radiusM: 150, rangeM: 1200, pitchDeg: -30 }, ); assert.deepEqual( { ...WORLD_FOCUS_FRAMING.fire }, { radiusM: 400, rangeM: 3000, pitchDeg: -35 }, ); assert.deepEqual( { ...WORLD_FOCUS_FRAMING.sighting }, { radiusM: 250, rangeM: 2500, pitchDeg: -40 }, ); assert.deepEqual( { ...WORLD_FOCUS_FRAMING['sighting-area'] }, { radiusM: 11000, rangeM: 60000, pitchDeg: -55 }, ); }); test('unknown kinds and missing viewers issue no flight', () => { const camera = stubCamera(); assert.equal( flyToWorldTarget({ camera }, { kind: 'plane', position: POSITION }), false, ); assert.equal(flyToWorldTarget({ camera }, { kind: 'vessel' }), false); assert.equal( flyToWorldTarget(null, { kind: 'vessel', position: POSITION }), false, ); assert.equal(camera.calls.flights.length, 0); });