@7365admin1/layer-common 3.2.1 → 3.2.2-staging.77

package/utils/camera-wall.test.ts

@@ -0,0 +1,571 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import {
+  agoLabel,
+  capabilityView,
+  CAPABILITY_NEXT_STEPS,
+  clampPage,
+  clampPan,
+  clampZoom,
+  focusedCamera,
+  healthView,
+  isDenseLayout,
+  playerOrigin,
+  playerSignal,
+  sharedCapabilityNote,
+  tileView,
+  wallCameras,
+  wallLayout,
+  wallPageCount,
+  wallRows,
+  wallTiles,
+  WALL_CAPABILITY_CONTROLS,
+  zoomStep,
+} from "./camera-wall.ts";
+
+const ip = (over: Record<string, unknown> = {}) => ({
+  _id: "c1",
+  name: "GYM AREA",
+  type: "ip",
+  status: "active",
+  host: "https://example.invalid/4",
+  ...over,
+});
+
+/* ---------------------------------------------------------------- rule 1 */
+
+test("an ANPR camera can never reach the wall", () => {
+  const items = [ip(), { _id: "c2", type: "anpr", host: "http://example.invalid:1234" }];
+  const kept = wallCameras(items);
+  assert.equal(kept.length, 1);
+  assert.equal(kept[0]._id, "c1");
+});
+
+test("a junk response is an empty wall, not a crash", () => {
+  assert.deepEqual(wallCameras(undefined), []);
+  assert.deepEqual(wallCameras([null, 3, "x"]), []);
+});
+
+/* ---------------------------------------------------------- layout + order */
+
+test("an unknown layout key falls back to four tiles", () => {
+  assert.equal(wallLayout("7x7").tiles, 4);
+  assert.equal(isDenseLayout("3x3"), true);
+  assert.equal(isDenseLayout("2x2"), false);
+});
+
+test("no selection means the site's own order, not a blank wall", () => {
+  const cams = [ip({ _id: "a" }), ip({ _id: "b" })];
+  const tiles = wallTiles(cams, [], "2x2");
+  // Two cameras on a four-tile wall are TWO tiles, not two tiles and two
+  // dashed boxes. The grid packs; see wallRows.
+  assert.equal(tiles.length, 2);
+  assert.equal(tiles[0]._id, "a");
+  assert.equal(tiles[1]._id, "b");
+});
+
+test("a selection sets the order, and a stale id is dropped rather than drawn", () => {
+  const cams = [ip({ _id: "a" }), ip({ _id: "b" })];
+  const tiles = wallTiles(cams, ["b", "gone", "a"], "1x1");
+  assert.equal(tiles.length, 1);
+  assert.equal(tiles[0]._id, "b");
+});
+
+/* ------------------------------------------- which tile the panel is about */
+
+/*
+  THE PANEL STOPPED PRINTING THE CAMERA'S NAME, AND THESE ARE THE TWO FACTS
+  THAT LET IT.
+
+  The name was there so the reader could tell which of up to nine tiles the
+  panel described. It is now the selected tile's accent ring that answers that —
+  which is only safe while the panel can never be about a tile that is not
+  drawn. Five cameras across two pages is exactly the case the owner asked
+  about, so it is exactly the case pinned here.
+*/
+const FIVE = ["a", "b", "c", "d", "e"].map((id) => ip({ _id: id, name: id.toUpperCase() }));
+
+test("nothing selected yet: the panel is about the first tile ON THIS PAGE", () => {
+  assert.equal(focusedCamera(wallTiles(FIVE, [], "2x2", 0), "")?._id, "a");
+  // Page 2 of the same wall holds one camera, and the panel is about that one —
+  // not still about "a", which is no longer on screen.
+  assert.equal(focusedCamera(wallTiles(FIVE, [], "2x2", 1), "")?._id, "e");
+});
+
+test("paging away from your selection never leaves the panel describing an off-page camera", () => {
+  // Selected "a" on page 1, then paged to page 2. "a" is not drawn there.
+  const pageTwo = wallTiles(FIVE, [], "2x2", 1);
+  const shown = focusedCamera(pageTwo, "a");
+  assert.equal(shown?._id, "e");
+  assert.ok(
+    pageTwo.some((c) => c._id === shown?._id),
+    "the panel must always describe a tile on the current page"
+  );
+});
+
+test("paging back restores the selection, because the raw id is kept", () => {
+  assert.equal(focusedCamera(wallTiles(FIVE, [], "2x2", 0), "c")?._id, "c");
+});
+
+test("an empty wall has nothing to describe", () => {
+  assert.equal(focusedCamera([], "a"), null);
+});
+
+/* ---------------------------------------------------------------- rule 2/3 */
+
+test("no descriptor at all counts as NOT available", () => {
+  const v = capabilityView(ip(), "ptz");
+  assert.equal(v.available, false);
+  assert.equal(v.tag, "Not checked yet");
+  assert.match(v.detail, /has not been asked/);
+});
+
+test("the server's own sentence is shown, never rewritten", () => {
+  const cam = ip({
+    capabilities: {
+      playback: {
+        state: "unsupported",
+        detail: "No direct connection to this camera's recorder is configured on this server.",
+      },
+    },
+  });
+  const v = capabilityView(cam, "playback");
+  assert.equal(v.tag, "Not set up yet");
+  assert.equal(
+    v.detail,
+    "No direct connection to this camera's recorder is configured on this server."
+  );
+});
+
+/*
+  CHANGED DELIBERATELY. This asserted `tag === null` for a working capability,
+  and that was fine while every capability on this screen was switched off. It
+  stopped being fine the moment one was on: an untagged panel beside four
+  tagged ones reads as a panel whose tag failed to render, not as good news.
+  It also hid a real defect, which the next test pins.
+*/
+test("a working capability says so, and does not fall back to the not-probed sentence", () => {
+  const cam = ip({ capabilities: { playback: { state: "supported", detail: null } } });
+  const v = capabilityView(cam, "playback");
+  assert.equal(v.available, true);
+  assert.equal(v.tag, "Ready");
+  // The defect: `detail` used to fall back to "has not been asked what it can
+  // do yet" whenever the server sent none — and the server sends none for a
+  // capability that WORKS. A working control claiming it had never been checked
+  // is a contradiction on screen, and it would have shipped the day zoom landed.
+  assert.equal(v.detail, null);
+  assert.equal(v.nextStep, null);
+});
+
+/* ---------------------------------------------------------------- rule 5 */
+
+test("a switched-off control says what would switch it on and who to ask", () => {
+  const cam = ip({
+    capabilities: {
+      playback: {
+        state: "unsupported",
+        reason: "device-http-not-configured",
+        detail: "No direct connection to this camera's recorder is configured on this server.",
+      },
+    },
+  });
+  const v = capabilityView(cam, "playback");
+  // The server's sentence is still verbatim — rule 3 is not traded away for rule 5.
+  assert.match(v.detail, /^No direct connection/);
+  assert.match(v.nextStep, /Seven365 administrator/);
+  assert.match(v.nextStep, /not switchable from this page/i);
+});
+
+/*
+  THE ADVICE HAS TO NAME THE TWO CHANGES, AND IT HAS TO STAY OUT OF THE
+  DEPLOYMENT MANUAL.
+
+  "Ask your Seven365 administrator" was the whole of the old advice and it was a
+  dead end — worse than useless for the owner, who IS the administrator. What
+  makes the new line actionable is that it names the two real changes: the
+  network has to let the server reach the recorder, and the recorder then has to
+  be configured on the server. Both halves are pinned here, because dropping
+  either one silently returns the sentence to a shrug.
+
+  And the other direction is pinned too: no environment variable name may appear
+  in copy a property manager reads. The names are correct, they are in
+  `iservice365-core/docs/camera-integration-config.md`, and they are unreadable
+  to the person this screen is written for.
+*/
+test("the setup advice names the network change AND the server change", () => {
+  const advice = CAPABILITY_NEXT_STEPS["device-http-not-configured"];
+  assert.match(advice, /network/i);
+  assert.match(advice, /recorder/i);
+  assert.match(advice, /server's configuration/i);
+});
+
+test("no environment variable name is ever shown to a reader", () => {
+  // Anything SCREAMING_SNAKE would be a deployment detail leaking into product
+  // copy. `CAMERA_DEVICE_HTTP` and friends belong in the deployment document.
+  for (const [reason, advice] of Object.entries(CAPABILITY_NEXT_STEPS)) {
+    assert.doesNotMatch(advice, /[A-Z][A-Z0-9]*_[A-Z0-9_]+/, `${reason} names a variable`);
+  }
+});
+
+/* ---------------------------------------------------------------- rule 7 */
+
+const OFF_FOR_THE_SAME_REASON = {
+  state: "unsupported",
+  reason: "device-http-not-configured",
+  detail: "No direct connection to this camera's recorder is configured on this server.",
+};
+const CAP_KEYS = WALL_CAPABILITY_CONTROLS.map((c) => c.key);
+
+test("four controls off for one reason state that reason once", () => {
+  // What the owner actually saw: the same sentence and the same next step,
+  // four times in a row, under four different titles.
+  const cam = ip({
+    capabilities: {
+      // Exactly the live wall: zoom works, the other four are off together.
+      digitalZoom: { state: "supported" },
+      playback: OFF_FOR_THE_SAME_REASON,
+      events: OFF_FOR_THE_SAME_REASON,
+      ptz: OFF_FOR_THE_SAME_REASON,
+      presets: OFF_FOR_THE_SAME_REASON,
+    },
+  });
+  const note = sharedCapabilityNote(cam, CAP_KEYS);
+  assert.match(note.detail, /^No direct connection/);
+  assert.match(note.nextStep, /Seven365 administrator/);
+});
+
+test("controls off for DIFFERENT reasons are never merged into one", () => {
+  // "The recorder is unreachable" and "this camera cannot move" are two
+  // problems with two different people to ask. Flattening them would be a lie
+  // of convenience, so the group note is refused and each card keeps its own.
+  const cam = ip({
+    capabilities: {
+      playback: OFF_FOR_THE_SAME_REASON,
+      ptz: { state: "unsupported", reason: "device-no-ptz", detail: "This camera cannot move." },
+    },
+  });
+  assert.equal(sharedCapabilityNote(cam, CAP_KEYS), null);
+});
+
+test("one control off on its own does not get a group note", () => {
+  const cam = ip({
+    capabilities: {
+      playback: OFF_FOR_THE_SAME_REASON,
+      events: { state: "supported" },
+      ptz: { state: "supported" },
+      presets: { state: "supported" },
+      digitalZoom: { state: "supported" },
+    },
+  });
+  assert.equal(sharedCapabilityNote(cam, CAP_KEYS), null);
+});
+
+test("a camera with no descriptor at all still groups its unknowns", () => {
+  // Every control reads "Not checked yet" with the same not-probed sentence —
+  // which is four identical cards, the same noise, and the same fix.
+  const note = sharedCapabilityNote(ip(), CAP_KEYS);
+  assert.match(note.detail, /has not been asked/);
+});
+
+test("a reason code this build has never seen still names somebody to ask", () => {
+  const cam = ip({
+    capabilities: { ptz: { state: "unsupported", reason: "invented-later", detail: "Nope." } },
+  });
+  assert.match(capabilityView(cam, "ptz").nextStep, /Seven365 administrator/);
+});
+
+test("every control the wall draws has a sentence for when it works", () => {
+  // Otherwise a capability flipping on shows a panel with a "Ready" tag and no
+  // explanation of what to do with it.
+  for (const control of WALL_CAPABILITY_CONTROLS) {
+    assert.ok(control.ready.length > 0, `${control.key} has no ready sentence`);
+  }
+});
+
+test("zoom is drawn as a capability, and it is the one that works today", () => {
+  const keys = WALL_CAPABILITY_CONTROLS.map((c) => c.key);
+  assert.ok(keys.includes("digitalZoom"));
+  // Digital zoom is cropping, not movement. If these two ever read the same on
+  // screen, somebody will believe they moved a camera that never moved.
+  assert.ok(keys.includes("ptz"));
+  assert.notEqual(
+    WALL_CAPABILITY_CONTROLS.find((c) => c.key === "digitalZoom").title,
+    WALL_CAPABILITY_CONTROLS.find((c) => c.key === "ptz").title
+  );
+});
+
+/* ------------------------------------------------------------------ rule 4 */
+
+test("a page that has not loaded is Connecting, never Live", () => {
+  assert.equal(tileView(ip(), { player: "loading" }).state, "connecting");
+  assert.equal(tileView(ip(), { player: "failed" }).state, "no-signal");
+});
+
+/**
+ * THE DEFECT THIS FILE EXISTS FOR.
+ *
+ * On the live wall two cameras rendered a blank rectangle and both carried a
+ * green "Live". The page had loaded; no picture was arriving. A loaded page is
+ * now worth exactly one thing, and it is not the word "Live".
+ */
+test("a loaded player page is NOT Live - it is Not confirmed", () => {
+  const v = tileView(ip(), { player: "page-up" });
+  assert.equal(v.state, "unverified");
+  assert.equal(v.label, "Not confirmed");
+  // No scrim: there may be a perfectly good picture under that badge, and
+  // covering a working camera would be a worse lie than the one being fixed.
+  assert.equal(v.detail, null);
+  assert.equal(v.showPlayer, true);
+  assert.match(v.note, /cannot confirm the picture is arriving/);
+  // Plain English, and an instruction rather than an explanation: the reader is
+  // a guard, not a browser engineer. Nothing about origins, players or frames.
+  assert.match(v.note, /check the tile/i);
+  assert.doesNotMatch(v.note, /browser|origin|player|iframe|service/i);
+});
+
+test("only a reported frame earns the word Live", () => {
+  assert.equal(tileView(ip(), { player: "playing" }).label, "Live");
+  assert.equal(tileView(ip(), { player: "playing" }).state, "live");
+});
+
+test("a picture that arrived and stopped stops being Live", () => {
+  // The mobile app's "Live over a nine-second-old still", refused here.
+  const v = tileView(ip(), { player: "stalled" });
+  assert.equal(v.state, "no-signal");
+  assert.match(v.detail, /stopped arriving/);
+});
+
+test("only signals the video service could actually send are believed", () => {
+  assert.equal(playerSignal({ event: "frame" }), "playing");
+  assert.equal(playerSignal("videoDecode"), "playing");
+  assert.equal(playerSignal({ type: "stalled" }), "stalled");
+  assert.equal(playerSignal({ event: "error" }), "failed");
+  // Anything else leaves the tile exactly where it was. A message we do not
+  // understand must never be able to turn a badge green.
+  assert.equal(playerSignal({ event: "live" }), null);
+  assert.equal(playerSignal(null), null);
+  assert.equal(playerSignal(42), null);
+  assert.equal(playerSignal({}), null);
+});
+
+test("a message is only believed from the camera's own origin", () => {
+  assert.equal(playerOrigin("https://relay.example.test/7"), "https://relay.example.test");
+  assert.equal(playerOrigin("not a url"), "");
+  assert.equal(playerOrigin(""), "");
+  assert.equal(playerOrigin(null), "");
+});
+
+test("the browser being offline outranks everything and says so differently", () => {
+  assert.equal(tileView(ip(), { online: false, player: "playing" }).label, "No connection");
+  assert.equal(tileView(ip(), { player: "failed" }).label, "No signal");
+});
+
+test("an inactive camera, a camera with no address, and an empty tile all explain themselves", () => {
+  assert.match(tileView(ip({ status: "inactive" })).detail, /not active/);
+  assert.match(tileView(ip({ host: "" })).detail, /no address/);
+  assert.match(tileView(null).detail, /No camera in this position/);
+  assert.equal(tileView(ip({ host: "" })).showPlayer, false);
+});
+
+test("a server that says live video is unsupported is believed", () => {
+  const cam = ip({
+    capabilities: {
+      liveVideo: { state: "unsupported", detail: "This camera is not active." },
+    },
+  });
+  const v = tileView(cam, { player: "playing" });
+  assert.equal(v.showPlayer, false);
+  assert.equal(v.detail, "This camera is not active.");
+});
+
+/* ------------------------------------------- the server's reason wins */
+
+test("the server's own refusal is shown verbatim, not replaced with a guess", () => {
+  // The one that matters: the browser cannot know this, and until the API host
+  // is configured it is the true answer for every camera in the estate.
+  const noRecorder = "No recorder is configured for this camera's relay.";
+  const view = tileView(ip({ unavailableReason: noRecorder }));
+  assert.equal(view.detail, noRecorder);
+  assert.equal(view.state, "unavailable");
+  assert.equal(view.showPlayer, false);
+});
+
+test("the server's reason beats the reasons the wall could work out itself", () => {
+  const reason = "This camera has no address configured.";
+  assert.equal(tileView(ip({ status: "inactive", unavailableReason: reason })).detail, reason);
+});
+
+test("an absent or blank reason changes nothing", () => {
+  assert.equal(tileView(ip({ unavailableReason: null })).state, "connecting");
+  assert.equal(tileView(ip({ unavailableReason: "   " })).state, "connecting");
+  assert.equal(tileView(ip()).state, "connecting");
+});
+
+test("being offline still explains every tile at once, ahead of the server's reason", () => {
+  const view = tileView(ip({ unavailableReason: "Something server-side." }), { online: false });
+  assert.equal(view.state, "offline");
+});
+
+/* ------------------------------------------------------------------ paging */
+
+test("the fifth camera on a four-tile wall is reachable, not dropped", () => {
+  // The defect this fixes, exactly: a site with five cameras showed four, said
+  // "Cameras 5" in the toolbar, and had nowhere to put the fifth.
+  const cams = ["a", "b", "c", "d", "e"].map((id) => ip({ _id: id }));
+  assert.equal(wallPageCount(cams, [], "2x2"), 2);
+
+  const second = wallTiles(cams, [], "2x2", 1);
+  assert.equal(second[0]._id, "e");
+  // A short last page is short, not padded - and it must never wrap back
+  // round to the first camera, which would show "a" twice on one wall.
+  assert.equal(second.length, 1);
+});
+
+test("the grid packs to the cameras on it instead of drawing holes", () => {
+  // Five cameras on a nine-tile wall: five pictures over two rows, not five
+  // pictures and four dead grey boxes over three.
+  const cams = ["a", "b", "c", "d", "e"].map((id) => ip({ _id: id }));
+  const tiles = wallTiles(cams, [], "3x3");
+  assert.equal(tiles.length, 5);
+  assert.equal(wallRows(tiles.length, "3x3"), 2);
+
+  assert.equal(wallRows(1, "3x3"), 1);
+  assert.equal(wallRows(9, "3x3"), 3);
+  // Never taller than the layout asked for, and never zero rows.
+  assert.equal(wallRows(99, "3x3"), 3);
+  assert.equal(wallRows(0, "2x2"), 1);
+});
+
+test("an exactly-full wall is one page, and an empty one is still one", () => {
+  const four = ["a", "b", "c", "d"].map((id) => ip({ _id: id }));
+  assert.equal(wallPageCount(four, [], "2x2"), 1);
+  assert.equal(wallPageCount([], [], "2x2"), 1);
+});
+
+test("a page number is clamped rather than left pointing past the end", () => {
+  const cams = ["a", "b", "c", "d", "e"].map((id) => ip({ _id: id }));
+  // Going from 2x2 page 2 to a 3x3 wall: page 1 no longer exists.
+  assert.equal(clampPage(1, wallPageCount(cams, [], "3x3")), 0);
+  assert.equal(clampPage(-4, 3), 0);
+  assert.equal(clampPage(99, 3), 2);
+  assert.equal(clampPage(NaN, 3), 0);
+  // Asking for a page past the end returns the last one's tiles, never nothing.
+  assert.equal(wallTiles(cams, [], "2x2", 9)[0]._id, "e");
+});
+
+test("paging respects a selection instead of quietly paging the whole site", () => {
+  const cams = ["a", "b", "c", "d", "e"].map((id) => ip({ _id: id }));
+  assert.equal(wallPageCount(cams, ["a", "b"], "1x1"), 2);
+  assert.equal(wallTiles(cams, ["a", "b"], "1x1", 1)[0]._id, "b");
+});
+
+/* ------------------------------------------------------------------ health */
+
+test("the recorder's state and the player page's state are separate answers", () => {
+  const camera = ip();
+  // The tile badge says the page is up; the recorder says it is not. Both are
+  // true at once when a relay outlives the device behind it, and a wall that
+  // merged them would tell a supervisor only the reassuring half.
+  assert.equal(tileView(camera, { player: "playing" }).label, "Live");
+  assert.equal(healthView({ health: "unreachable", reachable: false }).tone, "down");
+});
+
+test("health that has never been asked for does not read as healthy", () => {
+  assert.equal(healthView(null).tone, "unknown");
+  assert.equal(healthView(undefined).lastFrame, null);
+  assert.match(healthView(null).label, /not checked/i);
+});
+
+test("a drifted clock is a warning, not a failure", () => {
+  assert.equal(healthView({ health: "drifted", reachable: true }).tone, "warn");
+  assert.equal(healthView({ health: "ok", reachable: true }).tone, "ok");
+});
+
+test("reachability alone is enough when the server sends no summary word", () => {
+  assert.equal(healthView({ reachable: true }).tone, "ok");
+  assert.equal(healthView({ reachable: false }).tone, "down");
+});
+
+test("the server's health sentence is carried through, not rewritten", () => {
+  const v = healthView({
+    health: "unreachable",
+    reachable: false,
+    reason: "The recorder did not respond.",
+  });
+  assert.equal(v.detail, "The recorder did not respond.");
+});
+
+/**
+ * The firmware-and-clock sentence is the server explaining why two values it
+ * never showed are blank. It was drawn on the panel and appended to the tile's
+ * tooltip; a guard can do nothing with a firmware version, so it is not carried
+ * at all now. Pinned, because "soften it" was the tempting answer and the wrong
+ * one.
+ */
+test("the firmware and device-clock sentence is not carried to the screen", () => {
+  const v = healthView({
+    health: "ok",
+    reachable: true,
+    detailUnavailableReason:
+      "Firmware and device clock are not available: this recorder is reachable over video only.",
+  });
+  assert.equal(v.detail, null);
+  assert.equal("deviceDetail" in v, false);
+});
+
+/**
+ * The complaint that started this: a green "Recorder responding" beside "Last
+ * picture this server received: none yet" reads as a contradiction. It is not
+ * one — but the panel now simply says nothing when there has never been a
+ * picture, which is the only reading a guard can act on.
+ */
+test("a recorder that is up with no picture yet reports no picture line at all", () => {
+  const v = healthView({ health: "ok", reachable: true, lastFrameAt: null });
+  assert.equal(v.tone, "ok");
+  assert.equal(v.label, "Recorder responding");
+  assert.equal(v.lastFrame, null);
+});
+
+test("a picture's age is coarse above a minute, and never a fake time", () => {
+  const now = Date.parse("2026-08-11T10:00:00.000Z");
+  const at = (ms) => new Date(now - ms).toISOString();
+  assert.equal(agoLabel(at(1000), now), "just now");
+  assert.equal(agoLabel(at(40_000), now), "40s ago");
+  assert.equal(agoLabel(at(6 * 60_000), now), "6 min ago");
+  assert.equal(agoLabel(at(3 * 3_600_000), now), "3 h ago");
+  // Never invent one: no timestamp and a broken timestamp both mean "no answer".
+  assert.equal(agoLabel(null, now), null);
+  assert.equal(agoLabel("not a date", now), null);
+  // A clock ahead of ours must not read as a picture from the future.
+  assert.equal(agoLabel(at(-5000), now), "just now");
+});
+
+/* -------------------------------------------------------------------- zoom */
+
+test("zoom stops at 4x and never goes below the whole picture", () => {
+  assert.equal(clampZoom(0.2), 1);
+  assert.equal(clampZoom(99), 4);
+  assert.equal(clampZoom(NaN), 1);
+  assert.equal(clampZoom(2.5), 2.5);
+});
+
+test("a wheel notch zooms by direction, not by however much the device reports", () => {
+  assert.ok(zoomStep(1, -120) > 1);
+  assert.ok(zoomStep(2, 3) < 2);
+  // A trackpad's tiny delta and a mouse's huge one take the same step.
+  assert.equal(zoomStep(1, -1), zoomStep(1, -4000));
+  assert.equal(zoomStep(1, 120), 1, "cannot zoom out past the whole picture");
+  assert.equal(zoomStep(4, -120), 4, "cannot zoom in past the ceiling");
+});
+
+test("panning cannot walk the picture off the tile", () => {
+  const frame = { width: 400, height: 200 };
+  // At 2x the picture is twice the frame, so half the frame each way and no more.
+  assert.deepEqual(clampPan({ x: 9999, y: 9999 }, 2, frame), { x: 200, y: 100 });
+  assert.deepEqual(clampPan({ x: -9999, y: -9999 }, 2, frame), { x: -200, y: -100 });
+  // At 1x there is nothing to pan, so every drag resolves to centred.
+  assert.deepEqual(clampPan({ x: 50, y: 50 }, 1, frame), { x: 0, y: 0 });
+  // A tile that has not been measured yet cannot be dragged into the void.
+  assert.deepEqual(clampPan({ x: 50, y: 50 }, 3, { width: 0, height: 0 }), { x: 0, y: 0 });
+});