@ksp-gonogo/kerbcast-react 1.11.0 → 1.12.0-rc.1

package/src/CameraFeed.tsx

@@ -1,4 +1,4 @@
-import type { CameraState, KerbcastClient } from "@ksp-gonogo/kerbcast";
+import type { Anchor, CameraState, DisplayedFrameUt, KerbcastClient } from "@ksp-gonogo/kerbcast";
 import {
   CameraKind,
   CommandAimKind,
@@ -32,16 +32,19 @@ import {
   type FeedAction,
   type FeedActionBarEntry,
 } from "./FeedActionBar";
-import { CommandBlank, CommandBrackets, type CommandBracketOverlay } from "./CommandBrackets";
+import { CommandBlank, LiveCommandBrackets, type CommandBracketOverlay } from "./CommandBrackets";
+import { LiveAnchorMarkers, type AnchorOverlay } from "./AnchorMarkers";
 import { useCommandDisplayUt } from "./hooks/useCommandDisplayUt";
 import { useKerbcastCameras } from "./hooks/useKerbcastCameras";
 import { useKerbcastInFlight } from "./hooks/useKerbcastInFlight";
 import { useKerbcastStream } from "./hooks/useKerbcastStream";
+import { useKerbcastWaitingForSlot } from "./hooks/useKerbcastWaitingForSlot";
 import { useRecordings } from "./hooks/useRecordings";
 import { DEFAULT_FEED_ASPECT, useReportDisplaySize } from "./hooks/useReportDisplaySize";
 import { useTargetBracketsPreference } from "./hooks/useTargetBracketsPreference";
 import { StandbyIcon } from "./StandbyIcon";
 import { isCameraDestroyed } from "./lifecycle";
+import { claimAnchors } from "./sharedAnchors";
 import { usePortalMenu } from "./menuPositioning";
 import { formatElapsed, nowMs } from "./timing";
 
@@ -265,8 +268,9 @@ export interface CameraFeedProps {
   enableRecording?: boolean;
   /**
    * Record this feed at the operator's full render size for the duration of
-   * the built-in REC control's recording (overrides only the display-size
-   * demand; still yields to the adaptive framerate shed). Off by default.
+   * the built-in REC control's recording (overrides the display-size
+   * demand and any viewer quality preset; still capped by an operator
+   * render-size cap and the adaptive shed). Off by default.
    * Threaded straight into `start(flightId, { forceFullResolution })`; has
    * no effect unless `enableRecording` is also set. While the feed is armed
    * (force sent, waiting for the resolution bump) the tile shows an
@@ -314,14 +318,53 @@ export interface CameraFeedProps {
    * brackets. See {@link CommandBracketOverlay}.
    */
   targetBracketOverlay?: CommandBracketOverlay;
+  /**
+   * What a command camera feed says while the camera has no subject to aim
+   * at yet and shows its placeholder framing (a launch site camera on its
+   * pad, a station looking at the horizon). Drawn over the picture, never
+   * into the video, so recordings stay clean. Default "Waiting for target";
+   * `null` or an empty string shows nothing.
+   */
+  waitingForTargetLabel?: string | null;
+  /**
+   * What the feed says while its camera has no video slot on this connection
+   * (`KerbcastCameraHandle.waitingForSlot`): the pool is at its ceiling or
+   * cannot grow. The feed takes the next slot another feed gives up. Drawn
+   * over the picture; `null` or an empty string shows nothing.
+   */
+  noSlotLabel?: string | null;
   /**
    * Mission UT the displayed video was captured at, for a host running its
    * own delayed playout. Picks which command-track transition is in force and
    * ages the readout. Defaults to the displayed frame's own capture UT where
    * the browser reports frame RTP timestamps, else the client's capture
-   * clock interpolated to now.
+   * clock interpolated to now. While a command lock is held the brackets and
+   * readout come from the displayed frame's own state, which a UT alone does
+   * not carry: such a host passes `displayFrame` instead.
    */
   displayUt?: number;
+  /**
+   * The frame a host's own delayed playout is showing, as
+   * `watchDisplayedFrames` reported it when it arrived. Wins over
+   * `displayUt`: its `ut` picks the transition in force and its `command`
+   * draws the brackets and readout, so they never run ahead of the picture.
+   */
+  displayFrame?: DisplayedFrameUt | null;
+  /**
+   * Things to mark on this feed's picture: parts, craft, points on a body or
+   * directions. Set for the displayed camera as this client's anchors and
+   * cleared when the feed shows another camera or unmounts; the game
+   * projects each through the camera that rendered every frame, and a
+   * default marker is drawn where it lands. One set per camera per client:
+   * two feeds on the same camera share it, the last to set winning. At
+   * most 16. Pass a stable or memoised array; it is compared by value.
+   */
+  anchors?: Anchor[];
+  /**
+   * Restyle the anchor markers, add SVG of your own, put text under them,
+   * or draw anchors set in game too. See {@link AnchorOverlay}.
+   */
+  anchorOverlay?: AnchorOverlay;
 }
 
 export interface CameraFeedHandle {
@@ -362,7 +405,12 @@ const CameraFeedInner = forwardRef<CameraFeedHandle, CameraFeedProps>(
       useStream,
       enableTargetBrackets = true,
       targetBracketOverlay,
+      waitingForTargetLabel = "Waiting for target",
+      noSlotLabel = "Not streaming: too many feeds are open. Close a feed to watch this one.",
       displayUt: displayUtProp,
+      displayFrame,
+      anchors,
+      anchorOverlay,
     },
     ref,
   ) {
@@ -402,7 +450,7 @@ const CameraFeedInner = forwardRef<CameraFeedHandle, CameraFeedProps>(
     const effectiveShowStatic = showStatic === undefined ? !reducedMotion : showStatic;
 
     // -------------------------------------------------------------------------
-    // Selection model (mirrors gonogo's CameraFeed)
+    // Selection model
     //
     // Resolution order:
     //   1. Explicit pick, if still present in the list (destroyed or not).
@@ -558,6 +606,7 @@ const CameraFeedInner = forwardRef<CameraFeedHandle, CameraFeedProps>(
     }, []);
 
     const isDestroyed = camera ? isCameraDestroyed(camera) : false;
+    const waitingForSlot = useKerbcastWaitingForSlot(flightId);
     /* Gating here rather than at the render sites covers the whole manual
        path at once: the controls unmount, the effects below zero any in-flight
        rate, and the imperative handle's pan/zoom methods no-op. */
@@ -582,16 +631,29 @@ const CameraFeedInner = forwardRef<CameraFeedHandle, CameraFeedProps>(
     const commandTrack = commandCamera?.commandTrack ?? null;
     const commandDisplayUt = useCommandDisplayUt(
       commandTrack !== null,
-      displayUtProp,
+      displayFrame ? displayFrame.ut : displayUtProp,
       commandTrack?.events,
       commandCamera?.flightId ?? null,
       videoEl,
+      displayFrame?.command,
     );
     const commandState = commandTrack
-      ? effectiveCommandTrack(commandTrack, commandDisplayUt?.ut)
+      ? effectiveCommandTrack(commandTrack, commandDisplayUt?.ut, commandDisplayUt?.command)
       : null;
+    /* This feed's anchors go to the camera it displays, and leave with it. */
+    const anchorsKey = anchors?.length ? JSON.stringify(anchors) : "";
+    useEffect(() => {
+      if (flightId === null || !anchorsKey) return;
+      return claimAnchors(client, flightId, JSON.parse(anchorsKey) as Anchor[]);
+    }, [client, flightId, anchorsKey]);
+    const drawsAnchors = !!anchorsKey || !!anchorOverlay?.owners?.length;
+
     const [bracketsOn, toggleBrackets] = useTargetBracketsPreference(
-      commandCamera ? (commandCamera.commandCentre?.stationId ?? String(commandCamera.flightId)) : null,
+      commandCamera
+        ? (commandCamera.commandCentre?.siteKey || commandCamera.commandCentre?.nodeName || String(commandCamera.flightId))
+        : null,
+      // 1.11 keyed the preference by stationId; carry a saved choice over.
+      commandCamera?.commandCentre?.stationId ?? null,
     );
     const targetBracketsAvailable = enableTargetBrackets && isCommandFeed;
 
@@ -861,8 +923,12 @@ const CameraFeedInner = forwardRef<CameraFeedHandle, CameraFeedProps>(
     // one aims the camera at it. Hidden while a command authority holds the
     // aim lock, since only it can aim then.
     // -------------------------------------------------------------------------
-    const commandTargets = commandCamera?.commandCentre?.targets ?? [];
-    const commandTargetId = commandCamera?.commandCentre?.subjectPersistentId ?? 0;
+    /* The list as it stood at the displayed frame, so a delayed feed never offers what its picture has not reached. */
+    const shownCentre = commandCamera
+      ? client.commandCentreAt(commandCamera.flightId, commandDisplayUt?.ut)
+      : null;
+    const commandTargets = shownCentre?.targets ?? [];
+    const commandTargetId = shownCentre?.subjectPersistentId ?? 0;
     const commandLocked = commandCamera?.commandTrack?.authority != null;
     const commandTargetAvailable =
       isCommandFeed && !disableManualControls && !commandLocked && commandTargets.length > 0;
@@ -900,6 +966,8 @@ const CameraFeedInner = forwardRef<CameraFeedHandle, CameraFeedProps>(
        yet (see ActiveRecordingInfo.arming). Drives the ARMING pill below in
        place of the REC badge. */
     const armingActive = activeRecording?.arming === true;
+    /* Stopped, clip not in the store yet (ActiveRecordingInfo.stopping). */
+    const savingActive = activeRecording?.stopping === true;
 
     // Ticks once a second while recording so the elapsed timer stays live;
     // the timer itself is derived from activeRecording.startedAt each render.
@@ -1391,8 +1459,12 @@ const CameraFeedInner = forwardRef<CameraFeedHandle, CameraFeedProps>(
                 (
                   <>
                     {commandState.blank && <CommandBlank reason={commandState.blank} />}
+                    {commandState.waitingForTarget && !commandState.blank && !isDestroyed && waitingForTargetLabel && (
+                      <WaitingBadge role="status">{waitingForTargetLabel}</WaitingBadge>
+                    )}
                     {targetBracketsAvailable && bracketsOn && (
-                      <CommandBrackets
+                      <LiveCommandBrackets
+                        flightId={commandCamera?.flightId ?? null}
                         state={commandState}
                         displayUt={commandDisplayUt?.ut ?? commandTrack!.ut}
                         utSource={commandDisplayUt?.source ?? null}
@@ -1405,6 +1477,12 @@ const CameraFeedInner = forwardRef<CameraFeedHandle, CameraFeedProps>(
                     )}
                   </>
                 )}
+              {waitingForSlot && !outOfFlight && !isDestroyed && noSlotLabel && (
+                <NoSlotNotice role="status">{noSlotLabel}</NoSlotNotice>
+              )}
+              {drawsAnchors && !outOfFlight && !isDestroyed && !commandState?.blank && (
+                <LiveAnchorMarkers flightId={flightId} video={videoEl} overlay={anchorOverlay} />
+              )}
               {outOfFlight ? (
                 showStandbyIcon && (
                   <StandbyOverlay role="status" aria-label="Standby, no active flight">
@@ -1437,12 +1515,17 @@ const CameraFeedInner = forwardRef<CameraFeedHandle, CameraFeedProps>(
                   ARMING
                 </ArmingBadge>
               )}
-              {recordingActive && !armingActive && (
+              {recordingActive && !armingActive && !savingActive && (
                 <RecBadge role="status" aria-label="Recording">
                   <RecDot aria-hidden="true" />
                   REC {formatElapsed(recordingElapsedMs)}
                 </RecBadge>
               )}
+              {recordingActive && savingActive && (
+                <RecBadge role="status" aria-label="Saving recording">
+                  SAVING
+                </RecBadge>
+              )}
               {showZoom && (
                 <ZoomControlsWrap $disabled={manualDisabled} aria-hidden={manualDisabled}>
                   <ZoomButton
@@ -1588,7 +1671,7 @@ export const CameraFeed = forwardRef<CameraFeedHandle, CameraFeedProps>(
 );
 
 // ---------------------------------------------------------------------------
-// Inline UI primitives (replacing @gonogo/ui dependencies)
+// Inline UI primitives
 // ---------------------------------------------------------------------------
 
 function ChevronDownIcon(props: React.SVGProps<SVGSVGElement>) {
@@ -2326,6 +2409,54 @@ const StaleScrim = styled.div`
   pointer-events: none;
 `;
 
+/* Centred in the picture, clear of the chrome along the edges, and wrapping so
+   a small tile still shows the whole sentence. */
+const NoSlotNotice = styled.div`
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  z-index: 2;
+  max-width: calc(100% - 32px);
+  padding: 6px 10px;
+  background: rgba(0, 0, 0, 0.6);
+  border: 1px solid rgba(255, 255, 255, 0.4);
+  border-radius: 3px;
+  color: rgba(255, 255, 255, 0.9);
+  font-size: 12px;
+  line-height: 1.4;
+  text-align: center;
+  text-shadow: 0 1px 2px rgba(0, 0, 0, 0.9);
+  pointer-events: none;
+`;
+
+/* Bottom centre: the zoom controls take the bottom left, pan and the stale
+   badge the bottom right, the title and REC badge the top left and the
+   action bar the top right. */
+const WaitingBadge = styled.div`
+  position: absolute;
+  bottom: 8px;
+  left: 50%;
+  transform: translateX(-50%);
+  z-index: 2;
+  /* Clear of the stale badge on the bottom right, even on a small tile. */
+  max-width: calc(100% - 180px);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  padding: 2px 6px;
+  background: rgba(0, 0, 0, 0.6);
+  border: 1px solid rgba(255, 255, 255, 0.4);
+  border-radius: 3px;
+  color: rgba(255, 255, 255, 0.9);
+  font-size: 10px;
+  font-weight: 600;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  text-shadow: 0 1px 2px rgba(0, 0, 0, 0.9);
+  pointer-events: none;
+`;
+
 const StaleBadge = styled.div`
   position: absolute;
   bottom: 8px;

package/src/CommandBrackets.test.tsx

@@ -1,4 +1,4 @@
-import { effectiveCommandTrack, type CommandTrackState } from "@ksp-gonogo/kerbcast";
+import { effectiveCommandTrack, type CommandTrackState, type FrameAnchor } from "@ksp-gonogo/kerbcast";
 import { cleanup, render, screen } from "@testing-library/react";
 import { afterEach, describe, expect, it } from "vitest";
 import {
@@ -33,7 +33,7 @@ function track(overrides: Partial<CommandTrackState> = {}): CommandTrackState {
   };
 }
 
-const AUTHORITY = { owner: "gonogo" };
+const AUTHORITY = { owner: "mission-control" };
 
 describe("containedContentRect", () => {
   it("letterboxes wide media in a tall box", () => {
@@ -154,6 +154,19 @@ describe("CommandBrackets", () => {
     expect(container.querySelector("svg")).toBeNull();
     expect(screen.getByText("NO FIX")).toBeTruthy();
   });
+
+  it("leaves NO FIX out while the feed says it is waiting for a target", () => {
+    render(
+      <CommandBrackets
+        state={{ ...effectiveCommandTrack(track({ hasFix: false, rangeM: undefined }), 1000), waitingForTarget: true }}
+        displayUt={1000}
+        utSource="override"
+        video={null}
+        fallbackSize={{ width: 1024, height: 576 }}
+      />,
+    );
+    expect(screen.queryByText("NO FIX")).toBeNull();
+  });
 });
 
 describe("CommandBrackets overlay", () => {
@@ -249,11 +262,198 @@ describe("CommandBrackets overlay", () => {
   });
 });
 
+/** A video element with a laid-out box and a decoded size, as a browser reports them. */
+function sizedVideo(boxW: number, boxH: number, mediaW = boxW, mediaH = boxH): HTMLVideoElement {
+  const v = document.createElement("video");
+  Object.defineProperty(v, "clientWidth", { value: boxW });
+  Object.defineProperty(v, "clientHeight", { value: boxH });
+  Object.defineProperty(v, "videoWidth", { value: mediaW });
+  Object.defineProperty(v, "videoHeight", { value: mediaH });
+  return v;
+}
+
+function subjectAnchor(overrides: Partial<FrameAnchor> = {}): FrameAnchor {
+  return {
+    id: "subject",
+    owner: "kerbcast",
+    x: 256,
+    y: 144,
+    inFrame: true,
+    behind: false,
+    distanceM: 4200,
+    apparentRadiusPx: 40,
+    angleOffAxis: 12,
+    occluded: false,
+    ...overrides,
+  };
+}
+
+describe("CommandBrackets on the subject anchor", () => {
+  function renderOnSubject(
+    subject: FrameAnchor | null,
+    t: CommandTrackState = track(),
+    overlay?: CommandBracketOverlay,
+    frame = { width: 1024, height: 576 },
+  ) {
+    return render(
+      <CommandBrackets
+        state={effectiveCommandTrack(t, 1000)}
+        displayUt={1000}
+        utSource="exact"
+        video={sizedVideo(1024, 576)}
+        overlay={overlay}
+        subject={subject}
+        subjectFrameSize={frame}
+      />,
+    );
+  }
+
+  function seenWith(subject: FrameAnchor | null, t: CommandTrackState = track()) {
+    let seen: CommandBracketContext | null = null;
+    const view = renderOnSubject(subject, t, { render: (ctx) => ((seen = ctx), null) });
+    return { ctx: seen as unknown as CommandBracketContext, view };
+  }
+
+  /* An observed result out of frame or occluded: no coordinates at all. */
+  const unseen = (o: Partial<FrameAnchor>): FrameAnchor => ({
+    id: "subject",
+    owner: "kerbcast",
+    observed: true,
+    inFrame: true,
+    ...o,
+  });
+
+  it("brackets the subject where it really is, not the frame centre", () => {
+    const { ctx, view } = seenWith(subjectAnchor());
+    expect([ctx.geometry.cx, ctx.geometry.cy, ctx.geometry.half]).toEqual([256, 144, 40]);
+    expect(ctx.subject?.id).toBe("subject");
+    expect(view.container.querySelector("svg")!.getAttribute("data-subject")).toBe("placed");
+    expect(corner(view.container, "topLeft")!.getAttribute("stroke-dasharray")).toBeNull();
+  });
+
+  it("maps a capture frame larger than the decoded video by the frame's own size", () => {
+    let seen: CommandBracketContext | null = null;
+    renderOnSubject(
+      subjectAnchor({ x: 512, y: 288, apparentRadiusPx: 80 }),
+      track(),
+      { render: (ctx) => ((seen = ctx), null) },
+      { width: 2048, height: 1152 },
+    );
+    const g = (seen as CommandBracketContext | null)!.geometry;
+    expect([g.cx, g.cy, g.half]).toEqual([256, 144, 40]);
+  });
+
+  it("falls back to the 1.11 box when the subject is occluded: centred, aimed range, aim-line colour", () => {
+    const t = track({ occluded: true, occluder: "Mun" });
+    const { ctx, view } = seenWith(unseen({ occluded: true }), t);
+    expect([ctx.geometry.cx, ctx.geometry.cy]).toEqual([512, 288]);
+    expect(ctx.geometry).toEqual(bracketGeometry({ x: 0, y: 0, width: 1024, height: 576 }, 20, 576));
+    expect(corner(view.container, "topLeft")!.getAttribute("stroke-dasharray")).toBe("3 2");
+    expect(view.container.querySelector("svg")!.getAttribute("data-subject")).toBe("centred");
+    expect(ctx.subject?.occluded).toBe(true);
+  });
+
+  it("falls back to the 1.11 box, corners drawn, when the subject is out of frame", () => {
+    const { ctx, view } = seenWith(unseen({ inFrame: false, occluded: false }));
+    expect([ctx.geometry.cx, ctx.geometry.cy]).toEqual([512, 288]);
+    expect(view.container.querySelectorAll("path")).toHaveLength(2);
+    expect(screen.getByText("IN VIEW · 4.2 km")).toBeTruthy();
+  });
+
+  it("keeps the 1.11 box under the command lock even with the subject in view", () => {
+    /* The authority aims somewhere else; the box is its aim, the anchor a second mark for the consumer. */
+    const locked = track({ authority: AUTHORITY, occluded: true, occluder: "Mun", bracketHalfPx: 30 });
+    const { ctx, view } = seenWith(subjectAnchor(), locked);
+    expect(ctx.geometry).toEqual(bracketGeometry({ x: 0, y: 0, width: 1024, height: 576 }, 30, 576));
+    expect(corner(view.container, "topLeft")!.getAttribute("stroke-dasharray")).toBe("3 2");
+    expect(ctx.subject).toMatchObject({ id: "subject", x: 256, y: 144 });
+    expect(screen.getByText("OCCLUDED MUN · 4.2 km")).toBeTruthy();
+  });
+
+  it("puts the aimed box on the aim anchor while the view turns onto a moved aim", () => {
+    const locked = track({ authority: AUTHORITY, bracketHalfPx: 30 });
+    let seen: CommandBracketContext | null = null;
+    render(
+      <CommandBrackets
+        state={effectiveCommandTrack(locked, 1000)}
+        displayUt={1000}
+        utSource="exact"
+        video={sizedVideo(1024, 576)}
+        overlay={{ render: (ctx) => ((seen = ctx), null) }}
+        subject={subjectAnchor()}
+        subjectFrameSize={{ width: 1024, height: 576 }}
+        aim={{ id: "aim", owner: "kerbcast", observed: true, inFrame: true, x: 700, y: 200 }}
+      />,
+    );
+    const g = (seen as CommandBracketContext | null)!.geometry;
+    expect([g.cx, g.cy]).toEqual([700, 200]);
+    expect(g).toEqual(bracketGeometry({ x: 0, y: 0, width: 1024, height: 576 }, 30, 576, { x: 700, y: 200 }));
+  });
+
+  it("keeps the aimed box on the edge nearest an aim off the frame, with a cue toward it", () => {
+    const locked = track({ authority: AUTHORITY, bracketHalfPx: 30 });
+    let seen: CommandBracketContext | null = null;
+    const view = render(
+      <CommandBrackets
+        state={effectiveCommandTrack(locked, 1000)}
+        displayUt={1000}
+        utSource="exact"
+        video={sizedVideo(1024, 576)}
+        overlay={{ render: (ctx) => ((seen = ctx), null) }}
+        subjectFrameSize={{ width: 1024, height: 576 }}
+        aim={{ id: "aim", owner: "kerbcast", inFrame: false, behind: false, x: 1500, y: 200, observed: false }}
+      />,
+    );
+    const ctx = seen as CommandBracketContext | null;
+    expect(ctx!.aimOffscreen).toBe(true);
+    expect(ctx!.geometry.bottomRight.x).toBeLessThanOrEqual(1024);
+    expect(ctx!.geometry.cy).toBe(200);
+    expect(view.container.querySelector("path[data-aim-cue]")).toBeTruthy();
+  });
+
+  function renderAimed(aimAt: { x: number; y: number }, t: CommandTrackState) {
+    let seen: CommandBracketContext | null = null;
+    const view = render(
+      <CommandBrackets
+        state={effectiveCommandTrack(t, 1000)}
+        displayUt={1000}
+        utSource="exact"
+        video={sizedVideo(1024, 576)}
+        overlay={{ render: (ctx) => ((seen = ctx), null) }}
+        subject={subjectAnchor()}
+        subjectFrameSize={{ width: 1024, height: 576 }}
+        aim={{ id: "aim", owner: "kerbcast", observed: false, inFrame: true, behind: false, ...aimAt }}
+      />,
+    );
+    return { ctx: seen as unknown as CommandBracketContext, view };
+  }
+
+  it("draws the aimed box when it holds the subject, so a craft and its parachute are framed whole", () => {
+    /* The view aims between a capsule and the canopy above it; the subject anchor stays on the centre of mass. */
+    const { ctx, view } = renderAimed({ x: 256, y: 100 }, track({ bracketHalfPx: 60 }));
+    expect(ctx.geometry).toEqual(bracketGeometry({ x: 0, y: 0, width: 1024, height: 576 }, 60, 576, { x: 256, y: 100 }));
+    expect(ctx.subject).toMatchObject({ id: "subject", x: 256, y: 144 });
+    expect(view.container.querySelector("svg")!.getAttribute("data-subject")).toBe("placed");
+  });
+
+  it("keeps the box on the subject when the aimed box does not hold it", () => {
+    const { ctx } = renderAimed({ x: 700, y: 400 }, track({ bracketHalfPx: 60 }));
+    expect([ctx.geometry.cx, ctx.geometry.cy, ctx.geometry.half]).toEqual([256, 144, 40]);
+    expect(ctx.aimOffscreen).toBe(false);
+  });
+
+  it("centres on the frame as before without a subject anchor", () => {
+    const { ctx } = seenWith(null);
+    expect([ctx.geometry.cx, ctx.geometry.cy]).toEqual([512, 288]);
+    expect(ctx.subject).toBeNull();
+  });
+});
+
 describe("CommandBlank", () => {
   it("labels the blank with its reason", () => {
-    render(<CommandBlank reason="Waiting for gonogo" />);
+    render(<CommandBlank reason="Waiting for mission control" />);
     expect(screen.getByRole("status", { name: "Feed blanked" }).textContent).toBe(
-      "Waiting for gonogo",
+      "Waiting for mission control",
     );
   });
 });