Let readiness waits know when the app owns the camera

While the cockpit holds camera inputs or the camera follows a target,
whenSettled no longer waits for enabled inputs or a still pose; it still
waits for the engine, the restored view, drawn frames and no flight, and
its timeout now prints what it saw (inputs, following, cockpit, last pose
change). Scenarios that waited for the camera where they needed the
picture wait for it instead: weather and Nepal imagery for their tiles
and frames, imagery capture while a box drag holds inputs, and pixel and
pick polling for drawn frames. The vessel click retries at the vessel's
rendered position.

scripts/qa/ready.test.mjs

@@ -1,7 +1,9 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import { createFakeEngine } from '../../src/globe/testing/fakeEngine.js';
+import { createSettledState } from '../../src/app/qaProbe.js';
 import {
+  waitForSettled,
   whenFramesDrawn,
   whenTilesLoaded,
   whenUiSettled,
@@ -9,6 +11,164 @@ import {
   until,
 } from './ready.mjs';
 
+function pageEngine(t) {
+  const engine = createFakeEngine();
+  const previous = globalThis.window;
+  const app = {
+    engine,
+    styleManager: {
+      initialRestorePromise: Promise.resolve(),
+      getCockpitState: () => ({ active: false }),
+    },
+  };
+  globalThis.window = { __godsEyeView: app };
+  t.after(() => {
+    if (previous === undefined) delete globalThis.window;
+    else globalThis.window = previous;
+    engine.destroy();
+  });
+  return app;
+}
+
+test('cockpit and follow readiness allow held inputs and moving poses after drawn frames', async (t) => {
+  for (const owner of ['cockpit', 'follow']) {
+    await t.test(owner, async (t) => {
+      const { engine, styleManager } = pageEngine(t);
+      engine.input.suspendCameraInputs();
+      let drawn = 0;
+      if (owner === 'cockpit')
+        styleManager.getCockpitState = () => ({ active: true });
+      else
+        engine.camera.follow({
+          position: () => ({ x: 6378137, y: drawn * 10, z: 0 }),
+          viewFrom: { x: 0, y: -100, z: 100 },
+        });
+      t.mock.method(engine.render, 'request', () =>
+        setImmediate(() => {
+          engine.fake.setPose({ heading: ++drawn / 100 });
+          engine.fake.frame();
+        }),
+      );
+      const status = await waitForSettled(createSettledState, {
+        frames: 3,
+        timeoutMs: 1000,
+      });
+      assert.equal(status.settled, true);
+      assert.equal(status.framesDrawn, 3);
+      assert.equal(status.observed.inputsEnabled, false);
+      assert.equal(status.observed.cockpitActive, owner === 'cockpit');
+      assert.equal(status.observed.following, owner === 'follow');
+      assert.ok(status.observed.lastPoseDelta.orientation > 0);
+      assert.equal(engine.frames.postRender.numberOfListeners, 0);
+    });
+  }
+});
+
+test('camera owners do not excuse restoration, flights, missing frames or destruction', async (t) => {
+  for (const unmet of [
+    'initialViewRestored',
+    'noFlight',
+    'frameDrawn',
+    'engineStarted',
+  ]) {
+    await t.test(unmet, async (t) => {
+      const { engine, styleManager } = pageEngine(t);
+      styleManager.getCockpitState = () => ({ active: true });
+      engine.input.suspendCameraInputs();
+      if (unmet === 'initialViewRestored')
+        styleManager.initialRestorePromise = new Promise(() => {});
+      if (unmet === 'noFlight')
+        engine.camera.flyTo({
+          destination: { x: 7000000, y: 0, z: 0 },
+          duration: 1,
+        });
+      t.mock.method(engine.render, 'request', () => {});
+      const pending = waitForSettled(createSettledState, {
+        frames: 3,
+        timeoutMs: 10,
+      });
+      await Promise.resolve();
+      if (unmet === 'engineStarted') {
+        engine.destroy();
+        t.mock.method(engine.camera, 'pose', () => {
+          throw Error('released camera');
+        });
+      } else engine.fake.frames(unmet === 'frameDrawn' ? 2 : 4);
+      await assert.rejects(pending, (error) => {
+        assert.match(error.message, new RegExp(`Readiness timeout: ${unmet}`));
+        assert.match(error.message, /"cockpitActive":true/);
+        return true;
+      });
+      assert.equal(engine.frames.postRender.numberOfListeners, 0);
+    });
+  }
+});
+
+test('unowned input locks and moving cameras time out with observed state', async (t) => {
+  for (const moving of [false, true]) {
+    await t.test(moving ? 'moving' : 'locked', async (t) => {
+      const { engine } = pageEngine(t);
+      if (!moving) engine.input.suspendCameraInputs();
+      t.mock.method(engine.render, 'request', () => {});
+      const pending = waitForSettled(createSettledState, {
+        frames: 3,
+        timeoutMs: 10,
+      });
+      await Promise.resolve();
+      for (let i = 0; i < 5; i++) {
+        if (moving)
+          engine.fake.setPose({ position: { x: 7000000 + i, y: 0, z: 0 } });
+        engine.fake.frame();
+      }
+      await assert.rejects(pending, (error) => {
+        assert.match(error.message, /cameraPoseStable/);
+        if (!moving) assert.match(error.message, /cameraInputsEnabled/);
+        const observed = JSON.parse(error.message.split('; observed: ')[1]);
+        assert.deepEqual(observed, {
+          inputsEnabled: moving,
+          following: false,
+          cockpitActive: false,
+          lastPoseDelta: {
+            positionM: moving ? 1 : 0,
+            orientation: 0,
+            projection: 0,
+          },
+        });
+        return true;
+      });
+    });
+  }
+});
+
+test('leaving a camera owner restores strict input and pose requirements', async (t) => {
+  for (const owner of ['cockpit', 'follow']) {
+    await t.test(owner, async (t) => {
+      const { engine, styleManager } = pageEngine(t);
+      engine.input.suspendCameraInputs();
+      let active = owner === 'cockpit';
+      styleManager.getCockpitState = () => ({ active });
+      const follow =
+        owner === 'follow'
+          ? engine.camera.follow({
+              position: () => ({ x: 6378137, y: 0, z: 0 }),
+              viewFrom: { x: 0, y: -100, z: 100 },
+            })
+          : null;
+      t.mock.method(engine.render, 'request', () => {});
+      const pending = waitForSettled(createSettledState, {
+        frames: 3,
+        timeoutMs: 10,
+      });
+      await Promise.resolve();
+      engine.fake.frames(2);
+      active = false;
+      follow?.stop();
+      engine.fake.frames(4);
+      await assert.rejects(pending, /cameraInputsEnabled, cameraPoseStable/);
+    });
+  }
+});
+
 test('frame readiness advances a request-mode engine and removes its listener', async (t) => {
   const engine = createFakeEngine();
   const previous = globalThis.window;