import assert from 'node:assert/strict';
import test from 'node:test';
import {
  buildRadioTunerBand,
  buildRadioTunerTicks,
  buildRadioCategories,
  createRadioClusterOverlayEntry,
  createRadioSelectedOverlayEntry,
  createRadioSingletonOverlayEntry,
  confirmRadioPlayback,
  DEFAULT_RADIO_FILTER,
  filterRadioStations,
  getRadioAcceptedCatalogSnapshot,
  getRadioUIState,
  isEnglishRadioStation,
  normalizeRadioTag,
  radioCategoryColor,
  radioGlobeLabel,
  radioGlobeNeedsRecentering,
  radioGlobeRecenterHeight,
  RADIO_GLOBE_INTERACTION_MAX_DISTANCE_M,
  RADIO_OVERLAY_COHORT_LIMIT,
  RADIO_OVERLAY_SOURCE_OPTIONS,
  RADIO_SINGLETON_GLOBAL_LIMIT,
  RADIO_SINGLETON_MID_LIMIT,
  RADIO_SINGLETON_NEAR_LIMIT,
  radioClusterCategoryId,
  radioCameraPositionChanged,
  radioCameraNavigationAllowed,
  radioClusterBadgeText,
  rankRadioStationsForViewport,
  rankRadioStationsForRequest,
  radioRequestIsCurrent,
  radioLayer,
  reconcileRadioClusterCandidates,
  retainRadioClusterIdentitiesForStations,
  radioStationIdFromPick,
  radioSelectionBracketSvg,
  selectRadioClusterCandidates,
  selectRadioSingletonCandidates,
  radioStationCameraPlan,
  radioTunerCommitSlot,
  radioTunerPointerPosition,
  radioTunerSlot,
  radioTuningStaticShouldPlay,
  radioStationCategoryId,
  setRadioParams,
  setRadioVolume,
  setRadioVoiceDucking,
  radioSingletonLabelLimit,
  radioViewIsGlobal,
  stationMatchesRadioCategory,
} from './radio.js';

const stations = [
  { id: 'news', tags: ['News', 'Weather Radio', 'air traffic'] },
  { id: 'safety', tags: ['police scanner', 'emergency'] },
  { id: 'music', tags: ['jazz', 'soul'] },
  { id: 'other', tags: ['community'] },
];

test('station-level tags produce canonical and detected-genre categories', () => {
  const categories = buildRadioCategories(stations);
  assert.equal(categories.find((category) => category.id === 'all').count, 4);
  assert.equal(categories.find((category) => category.id === 'weather').count, 2);
  assert.equal(categories.find((category) => category.id === 'public-safety').count, 1);
  assert.equal(categories.find((category) => category.id === 'genre:jazz').count, 1);
  assert.equal(categories.find((category) => category.id === 'other').count, 1);
  assert.equal(categories.find((category) => category.id === 'music').color, '#54d17a');
  assert.equal(categories.find((category) => category.id === 'genre:jazz').color, '#54d17a');
});

test('every generated Radio category is accepted by durable preferences', () => {
  const categories = buildRadioCategories([
    ...stations,
    { id: 'hip-hop', tags: ['hip hop'] },
    { id: 'r-and-b', tags: ['r&b'] },
  ]);
  for (const category of categories) {
    assert.equal(setRadioParams({ filter: category.id }), true, category.id);
  }
});

test('station marker categories share the dropdown palette with stable overlap priority', () => {
  assert.equal(radioStationCategoryId(stations[0]), 'news');
  assert.equal(radioStationCategoryId(stations[1]), 'public-safety');
  assert.equal(radioStationCategoryId(stations[2]), 'music');
  assert.equal(radioStationCategoryId(stations[3]), 'other');
  assert.equal(radioCategoryColor('news'), '#44adff');
  assert.equal(radioCategoryColor('music'), '#54d17a');
  assert.equal(radioCategoryColor('genre:jazz'), '#54d17a');
});

test('cluster badges lead with a readable count and concise dominant category', () => {
  assert.equal(radioClusterBadgeText('news', 12), '12 NEWS');
  assert.equal(radioClusterBadgeText('public-safety', 7.9), '7 SAFETY');
  assert.equal(radioClusterBadgeText('genre:jazz', 4), '4 MUSIC');
  assert.equal(radioClusterBadgeText('unknown', -2), '0 OTHER');
});

test('Radio globe labels are compact and frequency-first without misreading names', () => {
  assert.equal(
    radioGlobeLabel({ name: 'La Zeta (Hermosillo) - 93.9 FM - XHHY - Uniradio' }),
    '93.9 FM — La Zeta',
  );
  assert.equal(
    radioGlobeLabel({ name: '100.3 The River - WQRV - Meridianville/Huntsville, AL' }),
    '100.3 FM — The River',
  );
  assert.equal(radioGlobeLabel({ name: "80's New Wave Radio" }), "80's New Wave Radio");
  assert.equal(radioGlobeLabel({ name: "100 GREATEST OF THE 80'S" }), "100 GREATEST OF THE 80'S");
  assert.doesNotMatch(radioGlobeLabel({ name: 'Movie Soundtracks Hits Radio @ 1.fm' }), /^1 FM/);
  assert.equal(
    radioGlobeLabel({ name: '  La   Zeta - 93.9 fm - XHHY  ' }),
    '93.9 FM — La Zeta',
  );
  assert.equal(radioGlobeLabel({ name: '93.9 FM ---' }), '93.9 FM');
  assert.equal(radioGlobeLabel({ name: 'Radio One 93.9 FM / 94.1 FM' }), '93.9 FM — Radio One');
  const truncated = radioGlobeLabel({ name: 'Christian Power Praise Dot Net Worldwide Service' });
  assert.equal(truncated.length, 30);
  assert.ok(truncated.endsWith('…'));
  const unicodeTruncated = radioGlobeLabel({ name: `${'a'.repeat(28)}📻 more` });
  assert.equal(unicodeTruncated, `${'a'.repeat(28)}📻…`);
  assert.doesNotMatch(unicodeTruncated, /�/);
});

test('Radio ranks and caps cluster candidates before shared-host entry construction', () => {
  const candidates = Array.from({ length: 90 }, (_, index) => ({
    id: `cluster-${String(index).padStart(2, '0')}`,
    stationCount: index % 17,
  }));
  const selected = selectRadioClusterCandidates(candidates);
  assert.equal(selected.length, RADIO_OVERLAY_COHORT_LIMIT);
  assert.ok(selected.every((candidate) => candidates.includes(candidate)));
  for (let index = 1; index < selected.length; index += 1) {
    assert.ok(selected[index - 1].stationCount >= selected[index].stationCount);
  }
  assert.deepEqual(selectRadioClusterCandidates([
    { id: 'z', stationCount: 5 },
    { id: 'a', stationCount: 5 },
  ], 1).map(({ id }) => id), ['a']);
});

test('Radio preserves one-to-one cluster identity across substantial membership churn', () => {
  const previous = [
    { id: 'stable:north', identityId: 'stable:north', stationIds: ['a', 'b', 'c', 'd'] },
    { id: 'stable:south', identityId: 'stable:south', stationIds: ['w', 'x', 'y', 'z'] },
  ];
  const generated = [];
  const reconciled = reconcileRadioClusterCandidates([
    { id: 'b:e:4', stationIds: ['a', 'b', 'c', 'e'], text: '4 NEWS' },
    { id: 'new:weak:3', stationIds: ['d', 'm', 'n'], text: '3 OTHER' },
    { id: 'x:q:4', stationIds: ['w', 'x', 'y', 'q'], text: '4 MUSIC' },
  ], previous, (candidate) => {
    const id = `new:${candidate.id}`;
    generated.push(id);
    return id;
  });
  assert.equal(reconciled[0].id, 'stable:north');
  assert.equal(reconciled[0].text, '4 NEWS');
  assert.equal(reconciled[2].id, 'stable:south');
  assert.equal(reconciled[2].text, '4 MUSIC');
  assert.equal(reconciled[1].id, 'new:new:weak:3');
  assert.deepEqual(generated, ['new:new:weak:3']);
  assert.deepEqual(previous[0].stationIds, ['a', 'b', 'c', 'd']);
});

test('directory refresh retains only identities whose represented stations still exist', () => {
  const previous = [
    { id: 'stable:unchanged', stationIds: ['a', 'b', 'c'] },
    { id: 'stable:invalid', stationIds: ['x', 'y', 'z'] },
  ];
  const unchangedRefresh = retainRadioClusterIdentitiesForStations(previous, [
    { id: 'c' }, { id: 'a' }, { id: 'b' }, { id: 'x' }, { id: 'y' }, { id: 'z' },
  ]);
  assert.deepEqual(unchangedRefresh, previous);
  const changedRefresh = retainRadioClusterIdentitiesForStations(previous, [
    { id: 'a' }, { id: 'b' }, { id: 'c' }, { id: 'x' }, { id: 'z' },
  ]);
  assert.deepEqual(changedRefresh.map(({ id }) => id), ['stable:unchanged']);
});

test('Radio cluster identity inheritance is deterministic for splits and disjoint replacements', () => {
  const previous = [{
    id: 'stable:whole',
    identityId: 'stable:whole',
    stationIds: ['a', 'b', 'c', 'd', 'e', 'f'],
  }];
  const reconciled = reconcileRadioClusterCandidates([
    { id: 'a:c:3', stationIds: ['a', 'b', 'c'] },
    { id: 'd:f:3', stationIds: ['d', 'e', 'f'] },
    { id: 'x:z:3', stationIds: ['x', 'y', 'z'] },
  ], previous, (candidate) => `new:${candidate.id}`);
  assert.deepEqual(reconciled.map(({ id }) => id), [
    'stable:whole',
    'new:d:f:3',
    'new:x:z:3',
  ]);
  assert.equal(new Set(reconciled.map(({ id }) => id)).size, reconciled.length);
});

test('Radio allocates fresh disjoint cluster identities in canonical membership order', () => {
  const current = [
    { id: 'z-membership', stationIds: ['z2', 'z1'] },
    { id: 'a-membership', stationIds: ['a2', 'a1'] },
  ];
  const reconcile = (input) => {
    let sequence = 0;
    return reconcileRadioClusterCandidates(input, [], () => `stable:${++sequence}`);
  };
  const identities = (result) => Object.fromEntries(
    result.map(({ membershipId, identityId }) => [membershipId, identityId]),
  );

  assert.deepEqual(identities(reconcile(current)), {
    'z-membership': 'stable:2',
    'a-membership': 'stable:1',
  });
  assert.deepEqual(identities(reconcile([...current].reverse())), identities(reconcile(current)));
});

test('Radio split competition never falls through from a consumed majority to a historical minority', () => {
  const previous = [
    { id: 'stable:majority', stationIds: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] },
    { id: 'stable:minority', stationIds: ['x'] },
  ];
  const current = [
    { id: 'strong-child', stationIds: ['a', 'b', 'c', 'd', 'e'] },
    { id: 'later-child', stationIds: ['f', 'g', 'h', 'i', 'x'] },
  ];
  const reconcile = (currentInput, previousInput) => reconcileRadioClusterCandidates(
    currentInput,
    previousInput,
    (candidate) => `new:${candidate.id}`,
  );
  const forward = reconcile(current, previous);
  const permuted = reconcile([...current].reverse(), [...previous].reverse());
  const identities = (result) => Object.fromEntries(
    result.map(({ membershipId, identityId }) => [membershipId, identityId]),
  );

  assert.deepEqual(identities(forward), {
    'strong-child': 'stable:majority',
    'later-child': 'new:later-child',
  });
  assert.deepEqual(identities(permuted), identities(forward));
});

test('Radio split identities cannot migrate to weaker children to increase inherited count', () => {
  const previous = [
    { id: 'stable:alpha', stationIds: ['a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8', 'a9'] },
    { id: 'stable:beta', stationIds: ['b1', 'b2', 'b3', 'b4', 'b5'] },
  ];
  const reconciled = reconcileRadioClusterCandidates([
    {
      id: 'strong-tie',
      stationIds: ['a1', 'a2', 'a3', 'a4', 'a5', 'b1', 'b2', 'b3', 'b4', 'b5'],
    },
    { id: 'weaker-alpha-child', stationIds: ['a6', 'a7', 'a8', 'a9'] },
  ], previous, (candidate) => `new:${candidate.id}`);

  assert.deepEqual(reconciled.map(({ id }) => id), [
    'stable:beta',
    'new:weaker-alpha-child',
  ]);
});

test('Radio duplicate prior records cannot assign one stable identity twice', () => {
  const previous = [
    { id: 'stable:duplicate', stationIds: ['a', 'b'] },
    { identityId: 'stable:duplicate', stationIds: ['c', 'd'] },
  ];
  const current = [
    { id: 'a-child', stationIds: ['a', 'b'] },
    { id: 'z-child', stationIds: ['c', 'd'] },
  ];
  const reconcile = (currentInput, previousInput) => reconcileRadioClusterCandidates(
    currentInput,
    previousInput,
    (candidate) => `new:${candidate.id}`,
  );
  const forward = reconcile(current, previous);
  const permuted = reconcile([...current].reverse(), [...previous].reverse());
  const identities = (result) => Object.fromEntries(
    result.map(({ membershipId, identityId }) => [membershipId, identityId]),
  );

  assert.deepEqual(identities(forward), {
    'a-child': 'stable:duplicate',
    'z-child': 'new:z-child',
  });
  assert.deepEqual(identities(permuted), identities(forward));
  assert.equal(forward.filter(({ identityId }) => identityId === 'stable:duplicate').length, 1);
});

test('Radio cluster merges preserve the larger contributor over a fully retained minority', () => {
  const previous = [
    { id: 'stable:minority', stationIds: ['a', 'b'] },
    { id: 'stable:majority', stationIds: ['c', 'd', 'e', 'f', 'g', 'h'] },
  ];
  const [merged] = reconcileRadioClusterCandidates([
    { id: 'merged', stationIds: ['a', 'b', 'c', 'd', 'e'] },
  ], previous, () => 'new:merged');

  assert.equal(merged.id, 'stable:majority');
});

test('Radio cluster inheritance never discards the greatest low-ratio contributor', () => {
  const previous = [
    { id: 'stable:four', stationIds: ['a', 'b', 'c', 'd', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w'] },
    { id: 'stable:two', stationIds: ['e', 'f'] },
  ];
  const [merged] = reconcileRadioClusterCandidates([{
    id: 'merged',
    stationIds: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'],
  }], previous, () => 'new:merged');

  assert.equal(merged.id, 'stable:four');
});

test('Radio cluster inheritance permits a unique one-member overlap', () => {
  const [reconciled] = reconcileRadioClusterCandidates([
    { id: 'current', stationIds: ['a', 'x', 'y'] },
  ], [
    { id: 'stable:single-overlap', stationIds: ['a', 'b', 'c'] },
  ], () => 'new:current');

  assert.equal(reconciled.id, 'stable:single-overlap');
});

test('Radio cluster majority ties are deterministic across input permutations', () => {
  const previous = [
    { id: 'stable:zulu', stationIds: ['a', 'b', 'x'] },
    { id: 'stable:alpha', stationIds: ['c', 'd', 'y'] },
  ];
  const current = [{ id: 'merged', stationIds: ['a', 'b', 'c', 'd'] }];
  const forward = reconcileRadioClusterCandidates(current, previous, () => 'new:merged');
  const reversed = reconcileRadioClusterCandidates(current, [...previous].reverse(), () => 'new:merged');

  assert.equal(forward[0].id, 'stable:alpha');
  assert.equal(reversed[0].id, 'stable:alpha');
  assert.equal(new Set(forward.map(({ id }) => id)).size, forward.length);
});

test('active station tags own cluster labels even when overlapping tags have higher marker priority', () => {
  const overlapping = [
    { id: 'weather-news', tags: ['weather', 'news'] },
    { id: 'weather-only', tags: ['weather'] },
    { id: 'talk', tags: ['talk'] },
  ];
  assert.equal(radioStationCategoryId(overlapping[0]), 'news');
  assert.equal(radioClusterCategoryId(overlapping, 'weather'), 'weather');
  assert.equal(radioClusterCategoryId(overlapping, 'genre:jazz'), 'genre:jazz');
  assert.equal(radioClusterCategoryId(overlapping, 'all'), 'news');
});

test('filters do not rewrite inputs and overlapping operational tags remain discoverable', () => {
  const before = structuredClone(stations);
  assert.deepEqual(filterRadioStations(stations, 'public-safety').map((station) => station.id), ['safety']);
  assert.equal(stationMatchesRadioCategory(stations[0], 'aviation-marine'), true);
  assert.deepEqual(stations, before);
});

test('tag normalization is bounded and stable', () => {
  assert.equal(normalizeRadioTag('  Hip-Hop__Music  '), 'hip hop music');
  assert.equal(normalizeRadioTag('x'.repeat(100)).length, 80);
});

test('late directory responses cannot overwrite a disabled or newer generation', () => {
  assert.equal(radioRequestIsCurrent(4, 4, true), true);
  assert.equal(radioRequestIsCurrent(3, 4, true), false);
  assert.equal(radioRequestIsCurrent(4, 4, false), false);
});

test('destroy and re-init reset Radio audio ownership, volume, filter, and telemetry', async () => {
  const originalAudio = globalThis.Audio;
  const audioInstances = [];
  globalThis.Audio = class FakeAudio {
    constructor() {
      this.volume = 0.8;
      this.listeners = new Map();
      this.srcRemoved = false;
      audioInstances.push(this);
    }

    addEventListener(type, listener) { this.listeners.set(type, listener); }
    pause() {}
    play() { return Promise.resolve(); }
    removeAttribute(name) { if (name === 'src') this.srcRemoved = true; }
    load() {}
  };
  const viewer = {
    camera: { positionWC: { x: 7_000_000, y: 0, z: 0 } },
    scene: { canvas: { disableRootEvents: true, onwheel: null, addEventListener() {}, removeEventListener() {} } },
    dataSources: { add() {}, remove() {} },
    entities: { add(entity) { return entity; }, remove() {} },
  };

  radioLayer.destroy();
  try {
    radioLayer.init(viewer);
    radioLayer.enable();
    radioLayer.setLifecyclePresentation({
      lifecycleState: 'enabled', enabled: true, uncertain: false,
    });
    assert.equal(audioInstances.length, 1);
    assert.equal(setRadioVolume(0.25), true);
    setRadioVoiceDucking(true, { restoreDelayMs: 5, restoreDurationMs: 5 });
    assert.equal(getRadioUIState().voiceDucked, true);
    assert.equal(getRadioUIState().effectiveVolume, 0);
    const oldAudio = audioInstances[0];

    radioLayer.destroy();
    assert.equal(oldAudio.srcRemoved, true);
    assert.equal(getRadioUIState().loading, false);
    assert.equal(getRadioUIState().stale, false);
    assert.equal(getRadioUIState().degraded, false);
    assert.equal(getRadioUIState().error, null);
    assert.equal(getRadioUIState().updatedAt, null);
    assert.equal(getRadioUIState().filter, DEFAULT_RADIO_FILTER);
    assert.equal(getRadioUIState().voiceDucked, false);
    assert.equal(getRadioUIState().voiceRestoring, false);
    assert.equal(getRadioUIState().volume, 0.8);
    assert.equal(getRadioUIState().effectiveVolume, 0.8);

    radioLayer.init(viewer);
    assert.equal(audioInstances.length, 2, 're-init creates a clean Audio session');
    const nextState = getRadioUIState();
    for (const eventName of ['playing', 'pause', 'waiting', 'error']) {
      oldAudio.listeners.get(eventName)?.();
      assert.deepEqual(getRadioUIState(), nextState, `discarded ${eventName} callback is inert`);
    }
  } finally {
    radioLayer.destroy();
    if (originalAudio === undefined) delete globalThis.Audio;
    else globalThis.Audio = originalAudio;
  }
});

test('late media errors after replacement or Pause cannot mutate the active station', async () => {
  const originalAudio = globalThis.Audio;
  const originalFetch = globalThis.fetch;
  const audioInstances = [];
  globalThis.Audio = class FakeAudio {
    constructor() {
      this.volume = 0.8;
      this.src = '';
      this.currentSrc = '';
      this.listeners = new Map();
      this.playCalls = 0;
      audioInstances.push(this);
    }

    addEventListener(type, listener) { this.listeners.set(type, listener); }
    pause() {}
    play() {
      this.playCalls += 1;
      this.currentSrc = this.src;
      return new Promise(() => {});
    }
    removeAttribute(name) { if (name === 'src') this.src = ''; }
    load() {}
  };
  const stationRows = [
    {
      id: '00000000-0000-4000-8000-000000000001',
      name: 'Primary station',
      lat: 30,
      lon: -97,
      streamUrl: 'https://radio.example.com/primary.mp3',
      homepage: null,
      tags: ['news'],
      languages: ['English'],
      state: 'Texas',
      country: 'United States',
      countryCode: 'US',
      metadataTrust: 'untrusted-community',
      codec: 'MP3',
      bitrate: 128,
    },
    {
      id: '00000000-0000-4000-8000-000000000002',
      name: 'Fallback station',
      lat: 31,
      lon: -98,
      streamUrl: 'https://radio.example.com/fallback.mp3',
      homepage: null,
      tags: ['news'],
      languages: ['English'],
      state: 'Texas',
      country: 'United States',
      countryCode: 'US',
      metadataTrust: 'untrusted-community',
      codec: 'MP3',
      bitrate: 128,
    },
  ];
  globalThis.fetch = async (url) => String(url).startsWith('/api/radio/click/')
    ? { ok: true }
    : {
      ok: true,
      json: async () => ({
        stations: stationRows,
        updatedAt: new Date().toISOString(),
        stale: false,
        degraded: false,
        acceptedGeneration: 1,
        catalogInstance: 'qa-instance-a',
      }),
    };
  const viewer = {
    camera: { positionWC: { x: 7_000_000, y: 0, z: 0 } },
    scene: { canvas: { disableRootEvents: true, onwheel: null, addEventListener() {}, removeEventListener() {} } },
    dataSources: { add() {}, remove() {} },
    entities: { add(entity) { return entity; }, remove() {} },
  };

  radioLayer.destroy();
  try {
    radioLayer.init(viewer);
    radioLayer.enable();
    await radioLayer.update();
    radioLayer.setLifecyclePresentation({
      lifecycleState: 'enabled',
      enabled: true,
      uncertain: true,
    });
    assert.equal(radioLayer.getUIState().presentationActive, false);
    assert.equal(radioLayer.selectStation(stationRows[0].id, {
      autoplay: true,
      origin: 'voice',
    }), false, 'uncertain lifecycle blocks direct station selection');
    assert.equal(radioLayer.cycleStation(1, {
      stationIds: stationRows.map(({ id }) => id),
      autoplay: false,
      rotate: true,
    }), false, 'uncertain lifecycle blocks cycling before camera or fallback mutation');
    assert.equal(await radioLayer.togglePlayback({ origin: 'user' }), false);
    assert.equal(radioLayer.getUIState().selected, null);
    assert.equal(audioInstances.reduce((sum, audio) => sum + audio.playCalls, 0), 0);
    radioLayer.setLifecyclePresentation({
      lifecycleState: 'enabled',
      enabled: true,
      uncertain: false,
    });
    void radioLayer.togglePlayback({ origin: 'user' });
    await Promise.resolve();
    const primaryAudio = audioInstances.at(-1);
    const loadingState = radioLayer.getUIState();
    assert.equal(loadingState.audioState, 'loading');
    assert.equal(loadingState.selected?.id, stationRows[0].id);

    radioLayer.selectStation(stationRows[1].id, {
      autoplay: true,
      focus: false,
      origin: 'user',
    });
    await Promise.resolve();
    const replacementAudio = audioInstances.at(-1);
    assert.notEqual(replacementAudio, primaryAudio);
    assert.equal(radioLayer.getUIState().selected?.id, stationRows[1].id);
    assert.equal(audioInstances.reduce((sum, audio) => sum + audio.playCalls, 0), 2);

    primaryAudio.currentSrc = '';
    primaryAudio.listeners.get('error')?.();
    assert.equal(radioLayer.getUIState().audioState, 'loading');
    assert.equal(radioLayer.getUIState().selected?.id, stationRows[1].id);
    assert.equal(audioInstances.reduce((sum, audio) => sum + audio.playCalls, 0), 2);

    const controlEvents = [];
    const unsubscribeControls = radioLayer.subscribePlaybackControls((event) => {
      const observed = radioLayer.getUIState();
      const cleanupResult = radioLayer.stopPlayback({
        origin: 'voice-cleanup',
        attemptId: event.attemptId,
      });
      controlEvents.push({
        action: event.action,
        observedAudioState: observed.audioState,
        observedStationId: observed.playingStationId,
        cleanupResult,
      });
    });
    assert.equal(radioLayer.pause({ origin: 'user' }), true);
    replacementAudio.listeners.get('error')?.();
    await Promise.resolve();

    const state = radioLayer.getUIState();
    assert.equal(state.audioState, 'paused');
    assert.equal(state.selected?.id, stationRows[1].id);
    assert.equal(state.playingStationId, stationRows[1].id);
    assert.equal(replacementAudio.src, stationRows[1].streamUrl);
    assert.deepEqual(controlEvents, [{
      action: 'pause',
      observedAudioState: 'paused',
      observedStationId: stationRows[1].id,
      cleanupResult: false,
    }]);

    void radioLayer.togglePlayback({ origin: 'user' });
    await Promise.resolve();
    const resumedAudio = audioInstances.at(-1);
    assert.equal(radioLayer.getUIState().audioState, 'loading');
    assert.equal(radioLayer.stopPlayback({ origin: 'user' }), true);
    assert.deepEqual(controlEvents[1], {
      action: 'stop',
      observedAudioState: 'stopped',
      observedStationId: null,
      cleanupResult: false,
    });
    assert.equal(radioLayer.getUIState().audioState, 'stopped');
    assert.equal(resumedAudio.src, '');
    unsubscribeControls();
    assert.equal(audioInstances.reduce((sum, audio) => sum + audio.playCalls, 0), 3);
  } finally {
    radioLayer.destroy();
    globalThis.fetch = originalFetch;
    if (originalAudio === undefined) delete globalThis.Audio;
    else globalThis.Audio = originalAudio;
  }
});

test('unusable directory responses preserve warm client state atomically', async () => {
  const originalFetch = globalThis.fetch;
  const now = new Date().toISOString();
  const station = {
    id: '00000000-0000-4000-8000-000000000001',
    name: 'Warm Station',
    lat: 30.2672,
    lon: -97.7431,
    streamUrl: 'https://stream.example.org/live.mp3',
    homepage: null,
    tags: ['news'],
    languages: ['English'],
    state: 'Texas',
    country: 'United States',
    countryCode: 'US',
    metadataTrust: 'untrusted-community',
    codec: 'MP3',
    bitrate: 128,
  };
  const viewer = {
    camera: { positionWC: { x: 7_000_000, y: 0, z: 0 } },
    scene: { canvas: { disableRootEvents: true, onwheel: null, addEventListener() {}, removeEventListener() {} } },
    dataSources: { add() {}, remove() {} },
    entities: { add(entity) { return entity; }, remove() {} },
  };
  radioLayer.destroy();
  try {
    radioLayer.init(viewer);
    globalThis.fetch = async () => new Response(JSON.stringify({
      stations: [station],
      stale: false,
      degraded: false,
      acceptedGeneration: 1,
      catalogInstance: 'qa-instance-a',
      updatedAt: now,
    }), { status: 200, headers: { 'Content-Type': 'application/json' } });
    radioLayer.enable();
    await radioLayer.update();
    assert.equal(getRadioUIState().stationCount, 1);
    assert.equal(getRadioUIState().updatedAt, now);
    const acceptedSnapshot = getRadioAcceptedCatalogSnapshot();
    assert.equal(acceptedSnapshot.generation, 1);
    assert.equal(acceptedSnapshot.stations[0].id, station.id);
    assert.equal(acceptedSnapshot.stations[0].metadataTrust, 'untrusted-community');
    assert.equal(Object.isFrozen(acceptedSnapshot), true);
    assert.equal(Object.isFrozen(acceptedSnapshot.stations), true);
    assert.equal(Object.isFrozen(acceptedSnapshot.stations[0]), true);
    assert.equal(Object.isFrozen(acceptedSnapshot.stations[0].tags), true);
    assert.equal(Object.isFrozen(acceptedSnapshot.stations[0].languages), true);
    assert.throws(() => { acceptedSnapshot.stations[0].name = 'mutated'; }, TypeError);
    radioLayer.selectStation(station.id, { autoplay: false, focus: false });

    const replacement = {
      ...station,
      id: '00000000-0000-4000-8000-000000000002',
      name: 'Partial Replacement',
    };
    for (const body of [
      { stations: [replacement], stale: false, degraded: true, acceptedGeneration: 1, updatedAt: now },
      { stations: [replacement], stale: true, degraded: true, acceptedGeneration: 1, updatedAt: now },
    ]) {
      globalThis.fetch = async () => new Response(JSON.stringify(body), {
        status: 200,
        headers: { 'Content-Type': 'application/json' },
      });
      await radioLayer.update();
      const preserved = getRadioUIState();
      assert.equal(preserved.stationCount, 1);
      assert.equal(preserved.selected?.id, station.id);
      assert.equal(preserved.selected?.name, station.name);
      assert.equal(preserved.updatedAt, now);
      assert.equal(preserved.degraded, true);
      assert.equal(preserved.stale, body.stale);
      assert.equal(getRadioAcceptedCatalogSnapshot(), acceptedSnapshot);
    }

    for (const body of [
      { stations: {} },
      { stations: [station, { id: 'malformed' }], stale: false, degraded: false, updatedAt: now },
      { stations: [station], stale: false, degraded: false, updatedAt: 'not-a-date' },
      { stations: [station], stale: 'false', degraded: false, updatedAt: now },
    ]) {
      globalThis.fetch = async () => new Response(JSON.stringify(body), {
        status: 200,
        headers: { 'Content-Type': 'application/json' },
      });
      await radioLayer.update();
      assert.equal(getRadioUIState().stationCount, 1);
      assert.equal(getRadioUIState().updatedAt, now);
      assert.equal(getRadioUIState().stale, true);
      assert.equal(getRadioUIState().degraded, true);
    }
    globalThis.fetch = async () => new Response(JSON.stringify({
      stations: [replacement, { id: 'malformed' }], stale: false, degraded: false,
      acceptedGeneration: 2, catalogInstance: 'qa-instance-a', updatedAt: now,
    }));
    await radioLayer.update();
    assert.equal(getRadioUIState().stationCount, 1);
    assert.equal(getRadioUIState().rejectedStationCount, 1);
    assert.equal(getRadioUIState().degraded, true);
    assert.equal(getRadioUIState().stale, false);
    assert.equal(getRadioAcceptedCatalogSnapshot().generation, 2);
    assert.equal(getRadioAcceptedCatalogSnapshot().stations[0].id, replacement.id);
    // Server-side structural rejections are combined with client rejections
    // after admission; the healthy generation is still accepted.
    globalThis.fetch = async () => new Response(JSON.stringify({
      stations: [replacement, { id: 'malformed' }], stale: false, degraded: false,
      acceptedGeneration: 3, catalogInstance: 'qa-instance-a', updatedAt: now,
      rejectedStationCount: 2,
    }));
    await radioLayer.update();
    assert.equal(getRadioUIState().rejectedStationCount, 3);
    assert.equal(getRadioUIState().degraded, true);
    assert.equal(getRadioAcceptedCatalogSnapshot().generation, 3);
    globalThis.fetch = async () => new Response(JSON.stringify({
      stations: [replacement], stale: false, degraded: false,
      acceptedGeneration: 4, catalogInstance: 'qa-instance-a', updatedAt: now,
      rejectedStationCount: 10_000,
    }));
    await radioLayer.update();
    assert.equal(getRadioUIState().rejectedStationCount, 10_000);
    assert.equal(getRadioAcceptedCatalogSnapshot().generation, 4);
    for (const rejectedStationCount of [-1, 1.5, '2', null, 10_001]) {
      globalThis.fetch = async () => new Response(JSON.stringify({
        stations: [replacement], stale: false, degraded: false,
        acceptedGeneration: 5, catalogInstance: 'qa-instance-a', updatedAt: now,
        rejectedStationCount,
      }));
      await radioLayer.update();
      assert.equal(getRadioAcceptedCatalogSnapshot().generation, 4);
      assert.equal(getRadioUIState().stale, true);
    }
    globalThis.fetch = async () => new Response(JSON.stringify({
      stations: [{ id: 'malformed' }], stale: false, degraded: false,
      acceptedGeneration: 5, catalogInstance: 'qa-instance-a', updatedAt: now,
    }));
    await radioLayer.update();
    assert.equal(getRadioAcceptedCatalogSnapshot().generation, 4);
    assert.equal(getRadioUIState().stale, true);
    assert.equal(getRadioUIState().rejectedStationCount, 10_000);
    radioLayer.destroy();
    radioLayer.init(viewer);
    assert.equal(getRadioUIState().rejectedStationCount, 0);
    assert.equal(getRadioUIState().degraded, false);
  } finally {
    globalThis.fetch = originalFetch;
    radioLayer.destroy();
  }
});

test('tuner drag keeps one immutable catalog resolution through refresh and release', async () => {
  const originalFetch = globalThis.fetch;
  const viewer = {
    camera: { positionWC: { x: 7_000_000, y: 0, z: 0 } },
    scene: { canvas: { disableRootEvents: true, onwheel: null, addEventListener() {}, removeEventListener() {} } },
    dataSources: { add() {}, remove() {} },
    entities: { add(entity) { return entity; }, remove() {} },
  };
  const stationA = {
    id: '00000000-0000-4000-8000-000000000041',
    name: 'Generation A',
    lat: 30,
    lon: -97,
    streamUrl: 'https://radio.example.com/a.mp3',
    homepage: null,
    tags: ['news'],
    languages: ['English'],
    state: 'Texas',
    country: 'United States',
    countryCode: 'US',
    metadataTrust: 'untrusted-community',
    codec: 'MP3',
    bitrate: 128,
  };
  const stationB = {
    ...stationA,
    name: 'Generation B',
    streamUrl: 'https://radio.example.com/b.mp3',
  };
  const stationC = {
    ...stationB,
    id: '00000000-0000-4000-8000-000000000042',
    name: 'Generation C',
  };
  const publish = async (stationOrStations, acceptedGeneration) => {
    const stations = Array.isArray(stationOrStations) ? stationOrStations : [stationOrStations];
    globalThis.fetch = async () => new Response(JSON.stringify({
      stations,
      stale: false,
      degraded: false,
      acceptedGeneration,
      catalogInstance: 'qa-instance-a',
      updatedAt: new Date().toISOString(),
    }), { status: 200, headers: { 'Content-Type': 'application/json' } });
    await radioLayer.update();
  };

  radioLayer.destroy();
  try {
    radioLayer.init(viewer);
    radioLayer.enable();
    await publish(stationA, 1);
    assert.equal(radioLayer.beginTuning(), true);
    assert.equal(radioLayer.previewTuningStation(stationA.id, { rotate: false }), true);
    assert.equal(getRadioUIState().tuningCatalogGeneration, 1);

    await publish(stationB, 2);
    assert.equal(getRadioUIState().tuningPreviewStationId, stationA.id);
    const changed = radioLayer.commitTuningStation(stationA.id, { origin: 'user' });
    assert.deepEqual(changed, {
      ok: false,
      reason: 'station-unavailable',
      stationId: stationA.id,
      generation: 1,
    });
    assert.equal(getRadioUIState().selected, null);
    assert.equal(getRadioUIState().tuningUnavailableStationId, stationA.id);

    assert.equal(radioLayer.beginTuning(), true);
    assert.equal(radioLayer.previewTuningStation(stationB.id, { rotate: false }), true);
    await publish(stationB, 3);
    const unchanged = radioLayer.commitTuningStation(stationB.id, { origin: 'user' });
    assert.equal(unchanged.ok, true);
    assert.equal(unchanged.generation, 2);
    assert.equal(getRadioUIState().selected?.name, 'Generation B');

    assert.equal(radioLayer.beginTuning(), true);
    assert.equal(radioLayer.previewTuningStation(stationB.id, { rotate: false }), true);
    await publish(stationC, 4);
    const removed = radioLayer.commitTuningStation(stationB.id, { origin: 'user' });
    assert.equal(removed.ok, false);
    assert.equal(removed.reason, 'station-unavailable');
    assert.equal(removed.stationId, stationB.id);
    assert.notEqual(getRadioUIState().selected?.id, stationC.id);

    await publish([stationA, stationC], 5);
    assert.equal(radioLayer.selectStation(stationA.id, { autoplay: false, focus: false }), true);
    assert.equal(radioLayer.beginTuning(), true);
    assert.equal(radioLayer.previewTuningStation(stationC.id, { rotate: false }), true);
    await publish([stationA, { ...stationC, name: 'Changed target' }], 6);
    const priorSelectionMismatch = radioLayer.commitTuningStation(stationC.id, { origin: 'user' });
    assert.equal(priorSelectionMismatch.ok, false);
    assert.equal(priorSelectionMismatch.reason, 'station-unavailable');
    assert.equal(getRadioUIState().selected, null);
    assert.equal(getRadioUIState().tuningUnavailableStationId, stationC.id);

    await publish([stationB, stationC], 7);
    assert.equal(radioLayer.selectStation(stationB.id, { autoplay: false, focus: false }), true);
    assert.equal(radioLayer.beginTuning(), true);
    assert.equal(radioLayer.previewTuningStation(stationB.id, { rotate: false }), true);
    await publish([{ ...stationB, name: 'Same ID replacement' }, stationC], 8);
    const sameIdMismatch = radioLayer.commitTuningStation(stationB.id, { origin: 'user' });
    assert.equal(sameIdMismatch.ok, false);
    assert.equal(sameIdMismatch.reason, 'station-unavailable');
    assert.equal(getRadioUIState().selected, null);
    assert.equal(getRadioUIState().tuningUnavailableStationId, stationB.id);
  } finally {
    globalThis.fetch = originalFetch;
    radioLayer.destroy();
  }
});

test('failed exact tuner release cannot consume a stale playback fallback', async () => {
  const originalFetch = globalThis.fetch;
  const originalAudio = globalThis.Audio;
  const playUrls = [];
  const stationRows = [
    {
      id: '00000000-0000-4000-8000-000000000071',
      name: 'Exact target',
      lat: 30,
      lon: -97,
      streamUrl: 'https://radio.example.com/exact.mp3',
      homepage: null,
      tags: ['news'],
      languages: ['English'],
      state: 'Texas',
      country: 'United States',
      countryCode: 'US',
      metadataTrust: 'untrusted-community',
      codec: 'MP3',
      bitrate: 128,
    },
    {
      id: '00000000-0000-4000-8000-000000000072',
      name: 'Stale fallback',
      lat: 31,
      lon: -98,
      streamUrl: 'https://radio.example.com/fallback.mp3',
      homepage: null,
      tags: ['news'],
      languages: ['English'],
      state: 'Texas',
      country: 'United States',
      countryCode: 'US',
      metadataTrust: 'untrusted-community',
      codec: 'MP3',
      bitrate: 128,
    },
  ];
  globalThis.Audio = class FakeAudio {
    constructor() {
      this.volume = 0.8;
      this.src = '';
    }

    addEventListener() {}
    pause() {}
    play() {
      playUrls.push(this.src);
      if (this.src === stationRows[0].streamUrl) {
        return Promise.reject(new DOMException('Exact target unavailable', 'NotSupportedError'));
      }
      return Promise.resolve();
    }
    removeAttribute() { this.src = ''; }
    load() {}
  };
  globalThis.fetch = async (url) => String(url).startsWith('/api/radio/click/')
    ? { ok: true }
    : new Response(JSON.stringify({
      stations: stationRows,
      stale: false,
      degraded: false,
      acceptedGeneration: 1,
      catalogInstance: 'qa-instance-a',
      updatedAt: new Date().toISOString(),
    }), { status: 200, headers: { 'Content-Type': 'application/json' } });
  const viewer = {
    camera: { positionWC: { x: 7_000_000, y: 0, z: 0 } },
    scene: { canvas: { disableRootEvents: true, onwheel: null, addEventListener() {}, removeEventListener() {} } },
    dataSources: { add() {}, remove() {} },
    entities: { add(entity) { return entity; }, remove() {} },
  };

  radioLayer.destroy();
  try {
    radioLayer.init(viewer);
    radioLayer.enable();
    await radioLayer.update();
    assert.equal(radioLayer.selectStation(stationRows[0].id, { autoplay: false }), true);
    assert.equal(radioLayer.cycleStation(1, {
      stationIds: stationRows.map(({ id }) => id),
      autoplay: false,
    }), true, 'non-playing cycle creates the stale-fallback precondition');
    assert.equal(radioLayer.beginTuning(), true);
    assert.equal(radioLayer.previewTuningStation(stationRows[0].id, { rotate: false }), true);
    assert.equal(radioLayer.commitTuningStation(stationRows[0].id, { origin: 'user' }).ok, true);
    await new Promise((resolve) => setTimeout(resolve));
    const state = radioLayer.getUIState();
    assert.deepEqual(playUrls, [stationRows[0].streamUrl]);
    assert.equal(state.selected?.id, stationRows[0].id);
    assert.equal(state.audioState, 'error');
    assert.equal(state.tuningStatic, true);
    assert.equal(state.tuningAwaitingStationId, stationRows[0].id);
  } finally {
    globalThis.fetch = originalFetch;
    if (originalAudio === undefined) delete globalThis.Audio;
    else globalThis.Audio = originalAudio;
    radioLayer.destroy();
  }
});

test('tuner cancellation restores the frozen start marker after catalog removal', async () => {
  const originalFetch = globalThis.fetch;
  const originalAudio = globalThis.Audio;
  const selectedEntities = new Map();
  let playCalls = 0;
  let flyToCalls = 0;
  globalThis.Audio = class FakeAudio {
    constructor() {
      this.volume = 0.8;
    }

    addEventListener() {}
    pause() {}
    play() { playCalls += 1; return Promise.resolve(); }
    removeAttribute() {}
    load() {}
  };
  const viewer = {
    camera: {
      positionWC: { x: 7_000_000, y: 0, z: 0 },
      flyTo() { flyToCalls += 1; },
    },
    scene: {
      canvas: { disableRootEvents: true, onwheel: null, addEventListener() {}, removeEventListener() {} },
      requestRender() {},
    },
    dataSources: { add() {}, remove() {} },
    entities: {
      add(entity) { selectedEntities.set(entity.id, entity); return entity; },
      remove(entity) { return selectedEntities.delete(entity?.id); },
    },
  };
  const stationA = {
    id: '00000000-0000-4000-8000-000000000051',
    name: 'Frozen start',
    lat: 30,
    lon: -97,
    streamUrl: 'https://radio.example.com/start.mp3',
    homepage: null,
    tags: ['news'],
    languages: ['English'],
    state: 'Texas',
    country: 'United States',
    countryCode: 'US',
    metadataTrust: 'untrusted-community',
    codec: 'MP3',
    bitrate: 128,
  };
  const stationB = {
    ...stationA,
    id: '00000000-0000-4000-8000-000000000052',
    name: 'Preview target',
    lat: 44,
    lon: 12,
    streamUrl: 'https://radio.example.com/preview.mp3',
  };
  const publish = async (rows, acceptedGeneration) => {
    globalThis.fetch = async () => new Response(JSON.stringify({
      stations: rows,
      stale: false,
      degraded: false,
      acceptedGeneration,
      catalogInstance: 'qa-instance-a',
      updatedAt: new Date().toISOString(),
    }), { status: 200, headers: { 'Content-Type': 'application/json' } });
    await radioLayer.update();
  };

  radioLayer.destroy();
  try {
    radioLayer.init(viewer);
    radioLayer.enable();
    radioLayer.setLifecyclePresentation({
      lifecycleState: 'enabled', enabled: true, uncertain: false,
    });
    let nextGeneration = 1;
    const restoreRemovedStartMarker = async () => {
      await publish([stationA, stationB], nextGeneration);
      nextGeneration += 1;
      assert.equal(radioLayer.selectStation(stationA.id, { autoplay: false, focus: false }), true);
      const startMarker = selectedEntities.get(`radio:selected:${stationA.id}`);
      assert.ok(startMarker);
      assert.equal(radioLayer.beginTuning(), true);
      assert.equal(radioLayer.previewTuningStation(stationB.id, { rotate: false }), true);
      await publish([stationB], nextGeneration);
      nextGeneration += 1;
      assert.equal(getRadioUIState().selected, null);
      assert.equal(radioLayer.cancelTuning(), true);
      const restoredMarker = selectedEntities.get(`radio:selected:${stationA.id}`);
      assert.ok(restoredMarker, 'the frozen start marker remains visible after cancellation');
      assert.deepEqual(restoredMarker.position, startMarker.position);
      assert.equal(getRadioUIState().tuningRestoredStationId, stationA.id);
      assert.equal(getRadioUIState().tuningActive, false);
      assert.equal(getRadioUIState().selected, null, 'stale marker never becomes playback authority');
      assert.equal(playCalls, 0);
      assert.equal(flyToCalls, 0);
      return radioLayer.getAcceptedCatalogSnapshot();
    };

    const sameFilterSnapshot = await restoreRemovedStartMarker();
    const sameFilter = getRadioUIState().filter;
    assert.equal(radioLayer.setFilter(sameFilter), true);
    assert.equal(getRadioUIState().filter, sameFilter);
    assert.equal(getRadioUIState().tuningRestoredStationId, null);
    assert.equal(selectedEntities.has(`radio:selected:${stationA.id}`), false);
    assert.equal(radioLayer.getAcceptedCatalogSnapshot(), sameFilterSnapshot);
    assert.equal(getRadioUIState().selected, null);
    assert.equal(playCalls, 0);
    assert.equal(flyToCalls, 0);

    const changedFilterSnapshot = await restoreRemovedStartMarker();
    assert.equal(radioLayer.setFilter('news'), true);
    assert.equal(getRadioUIState().filter, 'news');
    assert.equal(getRadioUIState().tuningRestoredStationId, null);
    assert.equal(selectedEntities.has(`radio:selected:${stationA.id}`), false);
    assert.equal(radioLayer.getAcceptedCatalogSnapshot(), changedFilterSnapshot);
    assert.equal(getRadioUIState().selected, null);
    assert.equal(playCalls, 0);
    assert.equal(flyToCalls, 0);

    const equalGenerationSnapshot = await restoreRemovedStartMarker();
    await publish([stationB], equalGenerationSnapshot.generation);
    assert.equal(
      getRadioUIState().tuningRestoredStationId,
      null,
      'the next accepted equal-generation refresh clears the presentation-only marker',
    );
    assert.equal(selectedEntities.has(`radio:selected:${stationA.id}`), false);
    assert.equal(radioLayer.getAcceptedCatalogSnapshot(), equalGenerationSnapshot);
    assert.equal(playCalls, 0);
    assert.equal(flyToCalls, 0);

    assert.equal(radioLayer.selectStation(stationB.id, { autoplay: false, focus: false }), true);
    assert.equal(getRadioUIState().tuningRestoredStationId, null);
    assert.equal(selectedEntities.has(`radio:selected:${stationA.id}`), false);
  } finally {
    globalThis.fetch = originalFetch;
    radioLayer.destroy();
    if (originalAudio === undefined) delete globalThis.Audio;
    else globalThis.Audio = originalAudio;
  }
});

test('Radio public tuner, filter, and resume mutations require certain enabled lifecycle authority', async () => {
  const originalFetch = globalThis.fetch;
  const stationRows = [{
    id: '00000000-0000-4000-8000-000000000061',
    name: 'Lifecycle station',
    lat: 30,
    lon: -97,
    streamUrl: 'https://radio.example.com/lifecycle.mp3',
    homepage: null,
    tags: ['news'],
    languages: ['English'],
    state: 'Texas',
    country: 'United States',
    countryCode: 'US',
    metadataTrust: 'untrusted-community',
    codec: 'MP3',
    bitrate: 128,
  }];
  globalThis.fetch = async () => new Response(JSON.stringify({
    stations: stationRows,
    stale: false,
    degraded: false,
    acceptedGeneration: 1,
    catalogInstance: 'qa-instance-a',
    updatedAt: new Date().toISOString(),
  }), { status: 200, headers: { 'Content-Type': 'application/json' } });
  const viewer = {
    camera: { positionWC: { x: 7_000_000, y: 0, z: 0 } },
    scene: { canvas: { disableRootEvents: true, onwheel: null, addEventListener() {}, removeEventListener() {} } },
    dataSources: { add() {}, remove() {} },
    entities: { add(entity) { return entity; }, remove() {} },
  };
  viewer.scene.requestRender = () => {};

  radioLayer.destroy();
  try {
    radioLayer.init(viewer);
    radioLayer.enable();
    await radioLayer.update();
    radioLayer.setLifecyclePresentation({
      lifecycleState: 'enabled', enabled: true, uncertain: false,
    });
    assert.equal(radioLayer.beginTuning(), true);
    assert.equal(radioLayer.setTuningStatic(false), true);

    for (const presentation of [
      { lifecycleState: 'disabled', enabled: false, uncertain: false },
      { lifecycleState: 'enabling', enabled: false, uncertain: false },
      { lifecycleState: 'disabling', enabled: true, uncertain: false },
      { lifecycleState: 'enabled', enabled: true, uncertain: true },
    ]) {
      radioLayer.setLifecyclePresentation(presentation);
      const before = getRadioUIState();
      assert.equal(radioLayer.setTuningStatic(true), false, presentation.lifecycleState);
      assert.equal(radioLayer.setFilter('news'), false, presentation.lifecycleState);
      assert.equal(await radioLayer.togglePlayback({ origin: 'user' }), false, presentation.lifecycleState);
      const after = getRadioUIState();
      assert.equal(after.tuningStatic, before.tuningStatic, presentation.lifecycleState);
      assert.equal(after.filter, before.filter, presentation.lifecycleState);
      assert.equal(after.selected, null, presentation.lifecycleState);
      assert.equal(after.audioState, 'stopped', presentation.lifecycleState);
    }

    radioLayer.setLifecyclePresentation({
      lifecycleState: 'enabled', enabled: true, uncertain: false,
    });
    assert.equal(radioLayer.setTuningStatic(true), true);
    assert.equal(getRadioUIState().tuningStatic, true);
    assert.equal(radioLayer.cancelTuning(), true);
    assert.equal(radioLayer.setFilter('news'), true);
    assert.equal(getRadioUIState().filter, 'news');
  } finally {
    globalThis.fetch = originalFetch;
    radioLayer.destroy();
  }
});

test('tuner refuses a degraded fallback that has no accepted catalog generation', async () => {
  const originalFetch = globalThis.fetch;
  const viewer = {
    camera: { positionWC: { x: 7_000_000, y: 0, z: 0 } },
    scene: { canvas: { disableRootEvents: true, onwheel: null, addEventListener() {}, removeEventListener() {} } },
    dataSources: { add() {}, remove() {} },
    entities: { add(entity) { return entity; }, remove() {} },
  };
  const station = {
    id: '00000000-0000-4000-8000-000000000043',
    name: 'Degraded Fallback',
    lat: 30,
    lon: -97,
    streamUrl: 'https://radio.example.com/degraded.mp3',
    homepage: null,
    tags: ['news'],
    languages: ['English'],
    state: 'Texas',
    country: 'United States',
    countryCode: 'US',
    metadataTrust: 'untrusted-community',
    codec: 'MP3',
    bitrate: 128,
  };

  radioLayer.destroy();
  try {
    globalThis.fetch = async () => new Response(JSON.stringify({
      stations: [station],
      stale: false,
      degraded: true,
      acceptedGeneration: null,
      updatedAt: new Date().toISOString(),
    }), { status: 200, headers: { 'Content-Type': 'application/json' } });
    radioLayer.init(viewer);
    radioLayer.enable();
    await radioLayer.update();

    assert.equal(getRadioUIState().stationCount, 1, 'fallback remains visible outside the tuner');
    assert.equal(getRadioUIState().acceptedCatalogGeneration, null);
    assert.deepEqual(radioLayer.getTunerStations(), []);
    assert.equal(radioLayer.beginTuning(), false);
    assert.equal(getRadioUIState().tuningActive, false);
    assert.equal(getRadioUIState().tuningCatalogGeneration, null);
  } finally {
    globalThis.fetch = originalFetch;
    radioLayer.destroy();
  }
});

test('accepted snapshots allowlist station fields and never regress generation identity', async () => {
  const originalFetch = globalThis.fetch;
  const now = new Date().toISOString();
  const station = {
    id: '00000000-0000-4000-8000-000000000011',
    name: 'Generation One',
    lat: 30.2672,
    lon: -97.7431,
    streamUrl: 'https://stream.example.org/one.mp3',
    homepage: null,
    tags: ['news'],
    languages: ['English'],
    state: 'Texas',
    country: 'United States',
    countryCode: 'US',
    metadataTrust: 'untrusted-community',
    codec: 'MP3',
    bitrate: 128,
    extension: { mutable: true },
  };
  const viewer = {
    camera: { positionWC: { x: 7_000_000, y: 0, z: 0 } },
    scene: { canvas: { disableRootEvents: true, onwheel: null, addEventListener() {}, removeEventListener() {} } },
    dataSources: { add() {}, remove() {} },
    entities: { add(entity) { return entity; }, remove() {} },
  };
  const serve = (stations, acceptedGeneration, catalogInstance = 'qa-instance-a') => {
    globalThis.fetch = async () => new Response(JSON.stringify({
      stations,
      stale: false,
      degraded: false,
      acceptedGeneration,
      catalogInstance,
      updatedAt: now,
    }), { status: 200, headers: { 'Content-Type': 'application/json' } });
  };

  radioLayer.destroy();
  try {
    radioLayer.init(viewer);
    serve([station], 1);
    radioLayer.enable();
    await radioLayer.update();
    const generationOne = getRadioAcceptedCatalogSnapshot();
    assert.equal(generationOne.generation, 1);
    assert.equal('extension' in generationOne.stations[0], false);

    const forgedSameGeneration = {
      ...station,
      id: '00000000-0000-4000-8000-000000000012',
      name: 'Forged Same Generation',
    };
    serve([forgedSameGeneration], 1);
    await radioLayer.update();
    assert.strictEqual(getRadioAcceptedCatalogSnapshot(), generationOne);
    assert.equal(getRadioUIState().selected, null);
    assert.equal(getRadioUIState().stationCount, 1);

    const generationTwoStation = {
      ...station,
      id: '00000000-0000-4000-8000-000000000013',
      name: 'Generation Two',
    };
    serve([generationTwoStation], 2);
    await radioLayer.update();
    const generationTwo = getRadioAcceptedCatalogSnapshot();
    assert.notStrictEqual(generationTwo, generationOne);
    assert.equal(generationTwo.generation, 2);
    assert.equal(generationTwo.stations[0].id, generationTwoStation.id);

    serve([station], 1);
    await radioLayer.update();
    assert.strictEqual(getRadioAcceptedCatalogSnapshot(), generationTwo);
    assert.equal(getRadioUIState().stationCount, 1);
    assert.equal(getRadioUIState().stale, true);
    assert.equal(getRadioUIState().degraded, true);
    assert.match(getRadioUIState().error, /refresh failed/i);

    // Producer restart: a NEW instance token restarts the generation sequence.
    // Generation 1 from instance B is a fresh catalog, not a repeat of the old
    // instance's generation 1 and not a regression from its generation 2.
    const restartStation = {
      ...station,
      id: '00000000-0000-4000-8000-000000000021',
      name: 'Post Restart Station',
    };
    serve([restartStation], 1, 'qa-instance-b');
    await radioLayer.update();
    const postRestart = getRadioAcceptedCatalogSnapshot();
    assert.notStrictEqual(postRestart, generationTwo);
    assert.equal(postRestart.instance, 'qa-instance-b');
    assert.equal(postRestart.generation, 1);
    assert.equal(postRestart.stations[0].id, restartStation.id);
    assert.equal(getRadioUIState().stationCount, 1);
    assert.equal(getRadioUIState().stale, false);
    assert.equal(getRadioUIState().degraded, false);
    assert.equal(getRadioUIState().error, null);

    // Same generation NUMBER as the pre-restart snapshot from yet another
    // instance must also fully reconcile — equal numbers across instances are
    // different catalogs, not "unchanged".
    const secondRestartStation = {
      ...station,
      id: '00000000-0000-4000-8000-000000000022',
      name: 'Second Restart Station',
    };
    serve([secondRestartStation], 1, 'qa-instance-c');
    await radioLayer.update();
    const secondRestart = getRadioAcceptedCatalogSnapshot();
    assert.equal(secondRestart.instance, 'qa-instance-c');
    assert.equal(secondRestart.stations[0].id, secondRestartStation.id);
  } finally {
    globalThis.fetch = originalFetch;
    radioLayer.destroy();
  }
});

test('update abort, destroy, and re-init invalidate the prior session and reset catalog telemetry', async () => {
  const originalFetch = globalThis.fetch;
  let resolveFetch;
  let requestSignal = null;
  const viewer = {
    camera: { positionWC: { x: 7_000_000, y: 0, z: 0 } },
    scene: { canvas: { disableRootEvents: true, onwheel: null, addEventListener() {}, removeEventListener() {} } },
    dataSources: { add() {}, remove() {} },
    entities: { add(entity) { return entity; }, remove() {} },
  };
  const lateStation = {
    id: '00000000-0000-4000-8000-000000000099',
    name: 'Late Station',
    lat: 30,
    lon: -97,
    streamUrl: 'https://radio.example.com/late.mp3',
    homepage: null,
    tags: ['news'],
    languages: ['English'],
    state: 'Texas',
    country: 'United States',
    countryCode: 'US',
    metadataTrust: 'untrusted-community',
    codec: 'MP3',
    bitrate: 128,
  };

  radioLayer.destroy();
  try {
    globalThis.fetch = (_url, options) => {
      requestSignal = options.signal;
      return new Promise((resolve) => { resolveFetch = resolve; });
    };
    radioLayer.init(viewer);
    radioLayer.enable();
    const pending = radioLayer.update();
    assert.equal(getRadioUIState().loading, true);
    radioLayer.disable();
    assert.equal(requestSignal.aborted, true);
    assert.equal(getRadioUIState().loading, false);

    radioLayer.destroy();
    radioLayer.init(viewer);
    const cleanState = getRadioUIState();
    assert.deepEqual({
      enabled: cleanState.enabled,
      loading: cleanState.loading,
      stale: cleanState.stale,
      degraded: cleanState.degraded,
      error: cleanState.error,
      updatedAt: cleanState.updatedAt,
      stationCount: cleanState.stationCount,
      selected: cleanState.selected,
      audioState: cleanState.audioState,
      voiceDucked: cleanState.voiceDucked,
      voiceRestoring: cleanState.voiceRestoring,
      acceptedCatalogGeneration: cleanState.acceptedCatalogGeneration,
    }, {
      enabled: false,
      loading: false,
      stale: false,
      degraded: false,
      error: null,
      updatedAt: null,
      stationCount: 0,
      selected: null,
      audioState: 'stopped',
      voiceDucked: false,
      voiceRestoring: false,
      acceptedCatalogGeneration: null,
    });
    assert.equal(getRadioAcceptedCatalogSnapshot().generation, null);

    resolveFetch(new Response(JSON.stringify({
      stations: [lateStation],
      stale: false,
      degraded: false,
      acceptedGeneration: 99,
      catalogInstance: 'qa-instance-a',
      updatedAt: new Date().toISOString(),
    }), { status: 200, headers: { 'Content-Type': 'application/json' } }));
    await pending;
    assert.deepEqual(getRadioUIState(), cleanState, 'retired update completion is inert after re-init');
  } finally {
    globalThis.fetch = originalFetch;
    radioLayer.destroy();
  }
});

test('All is the initial Radio filter', () => {
  assert.equal(DEFAULT_RADIO_FILTER, 'all');
  assert.equal(getRadioUIState().filter, 'all');
});

test('local viewport ranking chooses geographic distance without a language override', () => {
  const ranked = rankRadioStationsForViewport([
    { id: 'english-far', lat: 30.5, lon: -97.7, languages: ['English'] },
    { id: 'spanish-near', lat: 30.2673, lon: -97.7430, languages: ['Spanish'] },
    { id: 'english-near', lat: 30.28, lon: -97.74, languages: ['en'] },
  ], { lat: 30.2672, lon: -97.7431 });
  assert.deepEqual(ranked.map((station) => station.id), ['spanish-near', 'english-near', 'english-far']);
});

test('global viewport ranking prefers English stations, then distance', () => {
  const ranked = rankRadioStationsForViewport([
    { id: 'spanish-nearest', lat: 0, lon: 0, languages: ['Spanish'] },
    { id: 'english-far', lat: 15, lon: 0, languages: ['English'] },
    { id: 'english-near', lat: 5, lon: 0, languages: ['eng'] },
  ], { lat: 0, lon: 0 }, { preferEnglish: true });
  assert.deepEqual(ranked.map((station) => station.id), ['english-near', 'english-far', 'spanish-nearest']);
  assert.equal(isEnglishRadioStation(ranked[0]), true);
});

test('explicit Radio requests combine category, country, station name, and distance', () => {
  const rows = [
    { id: 'music-austin', name: 'Austin Music', tags: ['music'], countryCode: 'US', country: 'United States', lat: 30.26, lon: -97.74 },
    { id: 'news-dallas', name: 'Texas News', tags: ['news'], countryCode: 'US', country: 'United States', lat: 32.77, lon: -96.79 },
    { id: 'news-austin', name: 'Austin Public News', tags: ['news'], countryCode: 'US', country: 'United States', lat: 30.27, lon: -97.75 },
    { id: 'news-mexico', name: 'Noticias', tags: ['news'], countryCode: 'MX', country: 'Mexico', lat: 25.68, lon: -100.31 },
  ];
  const ranked = rankRadioStationsForRequest(rows, {
    categoryId: 'news',
    country: 'US',
    anchor: { lat: 30.2672, lon: -97.7431 },
  });
  assert.deepEqual(ranked.map((station) => station.id), ['news-austin', 'news-dallas']);
  assert.equal(rankRadioStationsForRequest(rows, {
    categoryId: 'news',
    stationQuery: 'public',
  })[0].id, 'news-austin');
});

test('viewport ranking treats the antimeridian as adjacent', () => {
  const ranked = rankRadioStationsForViewport([
    { id: 'far', lat: 0, lon: 150, languages: ['English'] },
    { id: 'across-dateline', lat: 0, lon: -179.9, languages: ['English'] },
  ], { lat: 0, lon: 179.9 });
  assert.equal(ranked[0].id, 'across-dateline');
});

test('global-view threshold tolerates Cesium altitude round-off without widening the boundary', () => {
  assert.equal(radioViewIsGlobal(1_999_999.6), true);
  assert.equal(radioViewIsGlobal(1_999_998.4), false);
});

test('Radio picks resolve ordinary, selected, primitive, and clustered entity ids', () => {
  assert.equal(radioStationIdFromPick({ id: 'radio:alpha' }), 'alpha');
  assert.equal(radioStationIdFromPick({ primitive: { id: 'radio:beta' } }), 'beta');
  assert.equal(radioStationIdFromPick({ id: { id: 'radio:selected:gamma' } }), 'gamma');
  assert.equal(radioStationIdFromPick({ id: [{ id: 'other' }, { id: 'radio:delta' }] }), 'delta');
  assert.equal(radioStationIdFromPick({ primitive: { id: [{ id: 'radio:cluster-first' }, { id: 'radio:cluster-second' }] } }), 'cluster-first');
  assert.equal(radioStationIdFromPick({ id: 'flights:abc' }), null);
});

test('selected Radio station bracket is a transparent four-corner category-colored SVG', () => {
  const svg = radioSelectionBracketSvg('#44adff');
  assert.match(svg, /viewBox="0 0 40 40"/);
  assert.match(svg, /M2 13V2H13 M27 2H38V13 M38 27V38H27 M13 38H2V27/);
  assert.match(svg, /stroke="#44adff"/);
  assert.match(radioSelectionBracketSvg('bad-color'), /stroke="#9aa7b3"/);
});

test('Radio text uses protected selected and bounded ambient WorldOverlay entries', () => {
  const position = { x: 1, y: 2, z: 3 };
  const selected = createRadioSelectedOverlayEntry({
    id: 'station-a',
    name: 'Austin News 93.9 FM - KQA',
    tags: ['news'],
  }, position);
  assert.equal(selected.variant, 'selected');
  assert.equal(selected.selected, true);
  assert.equal(selected.protected, true);
  assert.equal(selected.paintLane, 'selected');
  assert.equal(selected.title, '93.9 FM — Austin News');
  assert.equal(selected.position, position);
  assert.equal(selected.maxDistance, RADIO_GLOBE_INTERACTION_MAX_DISTANCE_M);

  const cluster = createRadioClusterOverlayEntry({
    id: 'a:z:12',
    position,
    text: '12 NEWS',
    accent: '#44adff',
    stationCount: 12,
  });
  assert.equal(cluster.variant, 'label');
  assert.equal(cluster.paintLane, 'ambient-label');
  assert.equal(cluster.collisionGroup, 'ambient-label');
  assert.equal(cluster.horizonCull, true);
  assert.equal(cluster.maxDistance, RADIO_GLOBE_INTERACTION_MAX_DISTANCE_M);
  assert.equal(cluster.distanceScale.far, RADIO_GLOBE_INTERACTION_MAX_DISTANCE_M);
  assert.equal(cluster.title, '12 NEWS');
  assert.equal(cluster.priority, 12);
  assert.equal(cluster.stateless, true);
  assert.equal(cluster.edgeFade, 'none');
  assert.equal(RADIO_OVERLAY_SOURCE_OPTIONS.cohortLimit, RADIO_OVERLAY_COHORT_LIMIT);
  assert.ok(RADIO_OVERLAY_COHORT_LIMIT < 750);

  const singleton = createRadioSingletonOverlayEntry({
    station: { id: 'station-b', name: '100.3 The River - WQRV', tags: ['public safety'] },
    position,
    priority: 1.5,
  });
  assert.equal(singleton.id, 'station:station-b');
  assert.equal(singleton.title, '100.3 FM — The River');
  assert.equal(singleton.paintLane, 'ambient-label');
  assert.equal(singleton.collisionGroup, 'ambient-label');
  assert.equal(singleton.interactive, false);
  assert.equal(singleton.horizonCull, true);
  assert.equal(singleton.maxDistance, RADIO_GLOBE_INTERACTION_MAX_DISTANCE_M);
  assert.equal(singleton.distanceScale.far, RADIO_GLOBE_INTERACTION_MAX_DISTANCE_M);
  assert.equal(singleton.priority, 1.5);
  assert.equal(singleton.stateless, true);
});

test('Radio singleton labels are zoom-aware, nearest-first, stable, and bounded', () => {
  assert.equal(radioSingletonLabelLimit(25_000_000), RADIO_SINGLETON_GLOBAL_LIMIT);
  assert.equal(radioSingletonLabelLimit(2_000_000), RADIO_SINGLETON_GLOBAL_LIMIT);
  assert.equal(radioSingletonLabelLimit(1_999_999), RADIO_SINGLETON_MID_LIMIT);
  assert.equal(radioSingletonLabelLimit(250_000), RADIO_SINGLETON_MID_LIMIT);
  assert.equal(radioSingletonLabelLimit(249_999), RADIO_SINGLETON_NEAR_LIMIT);
  const ranked = selectRadioSingletonCandidates([
    { station: { id: 'far' }, distanceM: 30 },
    { station: { id: 'near-z' }, distanceM: 10 },
    { station: { id: 'near-a' }, distanceM: 10 },
  ], 2);
  assert.deepEqual(ranked.map(({ station }) => station.id), ['near-a', 'near-z']);
});

test('directory tuner maps every absolute slot to an available station', () => {
  assert.deepEqual(radioTunerSlot(0, 4), {
    slot: 0, max: 3, locked: true, stationIndex: 0, leftIndex: 0, rightIndex: 0,
  });
  assert.deepEqual(radioTunerSlot(1, 4), {
    slot: 1, max: 3, locked: true, stationIndex: 1, leftIndex: 1, rightIndex: 1,
  });
  assert.deepEqual(radioTunerSlot(99, 4), {
    slot: 3, max: 3, locked: true, stationIndex: 3, leftIndex: 3, rightIndex: 3,
  });
  assert.equal(radioTunerSlot(0, 0).locked, false);
});

test('directory tuner pointer progress maps left, center, right, and midpoint ties exactly', () => {
  assert.deepEqual(radioTunerPointerPosition(7, 0, 114, 750), {
    ratio: 0, coordinate: 0, stationIndex: 0,
  });
  assert.deepEqual(radioTunerPointerPosition(57, 0, 114, 750), {
    ratio: 0.5, coordinate: 374.5, stationIndex: 375,
  });
  assert.deepEqual(radioTunerPointerPosition(107, 0, 114, 750), {
    ratio: 1, coordinate: 749, stationIndex: 749,
  });
  assert.deepEqual(radioTunerPointerPosition(50, 10, 80, 1), {
    ratio: 0.5, coordinate: 0, stationIndex: 0,
  });
  assert.equal(radioTunerPointerPosition(50, 10, 80, 0).stationIndex, -1);
  assert.deepEqual(radioTunerCommitSlot(2.5, 5), radioTunerSlot(3, 5));
});

test('directory tuner bands preserve stable filtered order without injecting outside selections', () => {
  const ranked = Array.from({ length: 800 }, (_, index) => ({ id: `station-${index}` }));
  const selected = { id: 'selected-outside-band' };
  const band = buildRadioTunerBand(ranked, selected, 750);
  assert.equal(band.length, 750);
  assert.deepEqual(band, ranked.slice(0, 750));
  assert.ok(!band.includes(selected));
  assert.deepEqual(buildRadioTunerBand(ranked, ranked[5], 24), ranked.slice(0, 24));
});

test('directory tuner virtual tape is bounded and moves opposite the needle', () => {
  const at100 = buildRadioTunerTicks(100, 750, 300);
  const at101 = buildRadioTunerTicks(101, 750, 300);
  assert.ok(at100.ticks.length <= Math.ceil(286 / at100.pitchPx) + 6);
  assert.ok(at101.needleX > at100.needleX);
  const sharedIndex = at100.ticks.find((tick) => at101.ticks.some((next) => next.stationIndex === tick.stationIndex));
  assert.ok(sharedIndex);
  const before = at100.ticks.find((tick) => tick.stationIndex === sharedIndex.stationIndex);
  const after = at101.ticks.find((tick) => tick.stationIndex === sharedIndex.stationIndex);
  assert.ok(after.xPx < before.xPx);
  assert.ok(Math.abs(after.xPx - before.xPx) >= 4 * (at101.needleX - at100.needleX) - 1e-9);
  const singleton = buildRadioTunerTicks(0, 1, 300);
  assert.equal(singleton.ratio, 0.5);
  assert.equal(singleton.ticks.length, 1);
  assert.equal(buildRadioTunerTicks(0, 0, 300).ticks.length, 0);
});

test('station camera plans preserve altitude and viewing orientation without zooming', () => {
  const nadir = radioStationCameraPlan({ lat: 30, lon: -97 }, {
    height: 600,
    heading: 0,
    pitch: -Math.PI / 2,
    roll: 0,
  });
  assert.ok(Math.abs(nadir.lat - 30) < 1e-9);
  assert.ok(Math.abs(nadir.lon + 97) < 1e-9);
  assert.equal(nadir.height, 600);
  assert.equal(nadir.heading, 0);
  assert.equal(nadir.pitch, -Math.PI / 2);
  assert.equal(nadir.roll, 0);
  const oblique = radioStationCameraPlan({ lat: 30, lon: -97 }, {
    height: 600,
    heading: 0,
    pitch: -Math.PI / 6,
    roll: 0.2,
  });
  assert.equal(oblique.height, 600);
  assert.equal(oblique.heading, 0);
  assert.equal(oblique.pitch, -Math.PI / 6);
  assert.equal(oblique.roll, 0.2);
  assert.ok(oblique.lat < 30);
  assert.ok(Math.abs(oblique.lon + 97) < 0.001);
});

test('Radio recenters clipped global and below-center closer Earth discs', () => {
  const centered = {
    earthCenterX: 600,
    earthCenterY: 400,
    earthRadius: 250,
    keyholeCenterX: 600,
    keyholeCenterY: 400,
    keyholeRadius: 420,
  };
  assert.equal(radioGlobeNeedsRecentering(centered), false);
  assert.equal(radioGlobeNeedsRecentering({ ...centered, earthCenterY: 560 }), true);
  assert.equal(radioGlobeNeedsRecentering({ ...centered, earthCenterX: 755 }), true);
  assert.equal(radioGlobeNeedsRecentering({ ...centered, earthRadius: 405 }), false);
  const closer = { ...centered, earthRadius: 900 };
  assert.equal(radioGlobeNeedsRecentering({ ...closer, earthCenterY: 800 }), false);
  assert.equal(radioGlobeNeedsRecentering({ ...closer, earthCenterY: 1_300 }), true);
  assert.equal(radioGlobeNeedsRecentering(null), false);
});

test('Radio recovery preserves closer altitude and caps extreme full-globe zoom', () => {
  assert.equal(radioGlobeRecenterHeight(2_915_647, false), 2_915_647);
  assert.equal(radioGlobeRecenterHeight(9_748_850, true), 9_748_850);
  assert.equal(radioGlobeRecenterHeight(97_488_500, true), 13_000_000);
  assert.equal(radioGlobeRecenterHeight(Number.NaN, true), null);
});

test('Radio camera navigation yields to every live tracked-entity owner', () => {
  const viewer = { camera: {} };
  assert.equal(radioCameraNavigationAllowed(viewer), true);
  for (const gevTrackedId of ['flights:abc123', 'military:def456']) {
    const trackedEntity = { gevTrackedId };
    viewer.trackedEntity = trackedEntity;
    assert.equal(radioCameraNavigationAllowed(viewer), false, gevTrackedId);
    assert.equal(viewer.trackedEntity, trackedEntity);
  }
  viewer.trackedEntity = undefined;
  assert.equal(radioCameraNavigationAllowed(viewer), true);
  assert.equal(radioCameraNavigationAllowed({ trackedEntity: {} }), false);
  assert.equal(radioCameraNavigationAllowed(null), false);
});

test('tuner static spans drag and broadcaster handoff but voice ducking silences it', () => {
  assert.equal(radioTuningStaticShouldPlay({ tuningActive: true, tuningStatic: true }), true);
  assert.equal(radioTuningStaticShouldPlay({ tuningStatic: true, awaitingStationId: 'news' }), true);
  assert.equal(radioTuningStaticShouldPlay({
    tuningStatic: true,
    awaitingStationId: 'news',
    voiceDucked: true,
  }), false);
  assert.equal(radioTuningStaticShouldPlay({ tuningStatic: false, awaitingStationId: 'news' }), false);
});

test('station horizon scans ignore stationary camera noise but detect movement', () => {
  const prior = { x: 1_000, y: -2_000, z: 3_000 };
  assert.equal(radioCameraPositionChanged(prior, { x: 1_000, y: -2_000, z: 3_000 }), false);
  assert.equal(radioCameraPositionChanged(prior, { x: 1_000.5, y: -2_000, z: 3_000 }), false);
  assert.equal(radioCameraPositionChanged(prior, { x: 1_002, y: -2_000, z: 3_000 }), true);
  assert.equal(radioCameraPositionChanged(null, prior), true);
});

test('voice ducking preserves the user-owned Radio volume', async () => {
  radioLayer.destroy();
  radioLayer.enable();
  radioLayer.setLifecyclePresentation({
    lifecycleState: 'enabled', enabled: true, uncertain: false,
  });
  try {
    setRadioVoiceDucking(true);
    let state = getRadioUIState();
    assert.equal(state.voiceDucked, true);
    assert.equal(state.volume, 0.8);
    assert.equal(state.effectiveVolume, 0);
    assert.equal(setRadioVolume(0.42), true);
    state = getRadioUIState();
    assert.equal(state.voiceDucked, true);
    assert.equal(state.volume, 0.42);
    assert.equal(state.effectiveVolume, 0);
    setRadioVoiceDucking(false, { restoreDelayMs: 0, restoreDurationMs: 0 });
    await new Promise((resolve) => setTimeout(resolve, 25));
    state = getRadioUIState();
    assert.equal(state.voiceDucked, false);
    assert.equal(state.voiceRestoring, false);
    assert.equal(state.volume, 0.42);
    assert.equal(state.effectiveVolume, 0.42);
  } finally {
    radioLayer.destroy();
  }
});

test('Radio volume requires certain enabled lifecycle authority', () => {
  radioLayer.destroy();
  assert.equal(setRadioVolume(0.2), false);
  assert.equal(getRadioUIState().volume, 0.8);

  radioLayer.enable();
  for (const presentation of [
    { lifecycleState: 'enabling', enabled: false, uncertain: false },
    { lifecycleState: 'disabling', enabled: true, uncertain: false },
    { lifecycleState: 'enabled', enabled: true, uncertain: true },
  ]) {
    radioLayer.setLifecyclePresentation(presentation);
    assert.equal(setRadioVolume(0.2), false, presentation.lifecycleState);
    assert.equal(getRadioUIState().volume, 0.8);
  }

  radioLayer.setLifecyclePresentation({
    lifecycleState: 'enabled', enabled: true, uncertain: false,
  });
  assert.equal(setRadioVolume(0.2), true);
  assert.equal(getRadioUIState().volume, 0.2);
  radioLayer.destroy();
});

test('voice playback confirmation waits for playing and requires a hard duck', async () => {
  let listener = () => {};
  let state = {
    audioState: 'loading',
    playingStationId: 'news',
    voiceDucked: true,
  };
  const confirmed = confirmRadioPlayback({
    startPlayback: async () => {
      state = { ...state, audioState: 'playing' };
      listener(state);
      return true;
    },
    subscribe: (next) => {
      listener = next;
      next({ ...state, audioState: 'stopped' });
      return () => { listener = () => {}; };
    },
    getState: () => state,
    timeoutMs: 50,
  });
  assert.equal(await confirmed, true);

  state = { ...state, voiceDucked: false };
  assert.equal(await confirmRadioPlayback({
    startPlayback: async () => true,
    subscribe: (next) => {
      next(state);
      return () => {};
    },
    getState: () => state,
    timeoutMs: 5,
  }), false);
});

test('voice playback confirmation accepts fallback buffering but times out safely', async () => {
  const state = {
    audioState: 'loading',
    playingStationId: 'fallback',
    voiceDucked: true,
  };
  const startedAt = Date.now();
  const confirmed = await confirmRadioPlayback({
    startPlayback: async () => false,
    subscribe: (next) => {
      next(state);
      return () => {};
    },
    getState: () => state,
    timeoutMs: 10,
  });
  assert.equal(confirmed, false);
  assert.ok(Date.now() - startedAt >= 8);
});