@oneuptime/common 12.0.33 → 12.0.34

package/Tests/UI/Rum/ReplayLink.test.tsx

@@ -0,0 +1,119 @@
+import "@testing-library/jest-dom";
+import { render, screen } from "@testing-library/react";
+import * as React from "react";
+import { MemoryRouter } from "react-router-dom";
+import { describe, expect, it } from "@jest/globals";
+import ObjectID from "../../../Types/ObjectID";
+import ReplayLink from "../../../../App/FeatureSet/Dashboard/src/Components/SessionReplay/ReplayLink";
+import {
+  REPLAY_EXCEPTION_PRE_ROLL_MS,
+  REPLAY_MOMENT_PRE_ROLL_MS,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/SessionReplay/ReplayPlayerUrlState";
+
+/*
+ * The rendered side of ReplayLink: the anchor carries the moment grammar
+ * (?at=, &signal=, &rail=) the player reads, and nothing at all renders when
+ * either id is missing - a session id of "" is the default on every
+ * telemetry row that predates the recorder, so an empty render is the
+ * common case, not an edge.
+ */
+
+const APP_ID: ObjectID = new ObjectID("0193c0de-1111-4aaa-8bbb-000000000001");
+const SESSION_ID: string = "a1b2c3d4e5f60718293a4b5c6d7e8f90";
+const AT: Date = new Date("2026-08-14T10:05:00.000Z");
+
+function renderLink(element: React.ReactElement): ReturnType<typeof render> {
+  return render(<MemoryRouter>{element}</MemoryRouter>);
+}
+
+function hrefParams(anchor: HTMLElement): URLSearchParams {
+  const href: string | null = anchor.getAttribute("href");
+
+  expect(href).not.toBeNull();
+
+  return new URL(`https://example.com${href}`).searchParams;
+}
+
+describe("ReplayLink", () => {
+  it("renders an anchor into the moment with signal and rail, with the default label", () => {
+    renderLink(
+      <ReplayLink
+        rumApplicationId={APP_ID}
+        sessionId={SESSION_ID}
+        atTime={AT}
+        signal="log:0193c0de-4444-4aaa-8bbb-000000000004"
+        rail="logs"
+      />,
+    );
+
+    const anchor: HTMLElement = screen.getByRole("link", {
+      name: "Watch session replay",
+    });
+    const params: URLSearchParams = hrefParams(anchor);
+
+    expect(anchor.getAttribute("href")).toContain(
+      `/rum/${APP_ID.toString()}/session-replay/${SESSION_ID}`,
+    );
+    expect(params.get("at")).toBe(
+      String(AT.getTime() - REPLAY_MOMENT_PRE_ROLL_MS),
+    );
+    expect(params.get("signal")).toBe(
+      "log:0193c0de-4444-4aaa-8bbb-000000000004",
+    );
+    expect(params.get("rail")).toBe("logs");
+    expect(screen.getByTestId("replay-link")).toBeInTheDocument();
+  });
+
+  it("applies the ten-second run-up for an exception signal and shows a custom label", () => {
+    renderLink(
+      <ReplayLink
+        rumApplicationId={APP_ID.toString()}
+        sessionId={SESSION_ID}
+        atTime={AT}
+        signal="exc:0193c0de-5555-4aaa-8bbb-000000000005"
+        rail="errors"
+        label="Watch replay"
+      />,
+    );
+
+    const anchor: HTMLElement = screen.getByRole("link", {
+      name: "Watch replay",
+    });
+
+    expect(hrefParams(anchor).get("at")).toBe(
+      String(AT.getTime() - REPLAY_EXCEPTION_PRE_ROLL_MS),
+    );
+  });
+
+  it("writes ?t= in whole seconds for an offset", () => {
+    renderLink(
+      <ReplayLink
+        rumApplicationId={APP_ID}
+        sessionId={SESSION_ID}
+        atOffsetMs={41_500}
+      />,
+    );
+
+    const params: URLSearchParams = hrefParams(screen.getByRole("link"));
+
+    expect(params.get("t")).toBe(
+      String(Math.floor((41_500 - REPLAY_MOMENT_PRE_ROLL_MS) / 1000)),
+    );
+    expect(params.get("at")).toBeNull();
+  });
+
+  it("renders nothing without a session id or without an application id", () => {
+    const { container: noSession } = renderLink(
+      <ReplayLink rumApplicationId={APP_ID} sessionId="" atTime={AT} />,
+    );
+
+    expect(noSession).toBeEmptyDOMElement();
+
+    const { container: noApp } = renderLink(
+      <ReplayLink sessionId={SESSION_ID} atTime={AT} />,
+    );
+
+    expect(noApp).toBeEmptyDOMElement();
+    expect(screen.queryByRole("link")).not.toBeInTheDocument();
+  });
+});

package/Tests/UI/Rum/ReplayPinControl.test.tsx

@@ -0,0 +1,408 @@
+import "@testing-library/jest-dom";
+import {
+  act,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from "@testing-library/react";
+import * as React from "react";
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+import ObjectID from "../../../Types/ObjectID";
+import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+/*
+ * Pin / Unpin on the player header.
+ *
+ * player-shell-14: the previous control swallowed create and delete
+ * failures (a 403 or a plan limit showed a spinner and then the same "Pin
+ * recording" button), disappeared for the whole visit on any initial load
+ * failure, and unpinned on one click. Every one of those is pinned in the
+ * other direction here, along with the worker's semantics the copy has to
+ * reflect (a pin on a still-recording session waits for finalization; a pin
+ * with nothing to protect is deleted by the worker; an unpin's copies go
+ * within an hour).
+ */
+
+const getListMock: MockFunction = getJestMockFunction();
+const createMock: MockFunction = getJestMockFunction();
+const deleteItemMock: MockFunction = getJestMockFunction();
+
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      getList: (...args: Array<unknown>) => {
+        return getListMock(...args);
+      },
+      create: (...args: Array<unknown>) => {
+        return createMock(...args);
+      },
+      deleteItem: (...args: Array<unknown>) => {
+        return deleteItemMock(...args);
+      },
+    },
+  };
+});
+
+/* Imported after the mock is registered so the component sees it. */
+import ReplayPinControl, {
+  PENDING_POLL_INTERVAL_MS,
+  PIN_PENDING_COPY,
+  PIN_REMOVED_COPY,
+  PIN_UNPINNED_COPY,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/SessionReplay/ReplayPinControl";
+
+const APP_ID: ObjectID = new ObjectID("0193c0de-1111-4aaa-8bbb-000000000001");
+const PIN_ID: string = "0193c0de-2222-4aaa-8bbb-000000000002";
+const SESSION_ID: string = "a1b2c3d4e5f60718293a4b5c6d7e8f90";
+
+interface PinRow {
+  id: ObjectID;
+  materializedAt?: Date | undefined;
+  expiresAt?: Date | undefined;
+}
+
+function pinRow(overrides?: Partial<PinRow>): PinRow {
+  return { id: new ObjectID(PIN_ID), ...overrides };
+}
+
+function listResult(rows: Array<PinRow>): {
+  data: Array<PinRow>;
+  count: number;
+} {
+  return { data: rows, count: rows.length };
+}
+
+function httpError(statusCode: number, message: string): HTTPErrorResponse {
+  return new HTTPErrorResponse(statusCode, { message: message }, {});
+}
+
+function renderControl(): ReturnType<typeof render> {
+  return render(
+    <ReplayPinControl rumApplicationId={APP_ID} sessionId={SESSION_ID} />,
+  );
+}
+
+beforeEach(() => {
+  getListMock.mockReset();
+  createMock.mockReset();
+  deleteItemMock.mockReset();
+});
+
+describe("ReplayPinControl initial load", () => {
+  it("offers 'Pin recording' when nothing is pinned", async () => {
+    getListMock.mockResolvedValue(listResult([]));
+
+    renderControl();
+
+    expect(await screen.findByTestId("replay-pin-button")).toHaveTextContent(
+      "Pin recording",
+    );
+    expect(screen.queryByTestId("replay-pin-status")).not.toBeInTheDocument();
+  });
+
+  it("hides the control only for a permission denial", async () => {
+    getListMock.mockRejectedValue(httpError(403, "Forbidden"));
+
+    const { container } = renderControl();
+
+    await waitFor(() => {
+      expect(getListMock).toHaveBeenCalledTimes(1);
+    });
+
+    expect(container).toBeEmptyDOMElement();
+  });
+
+  it("keeps the control with the cause and a Retry on any other load failure", async () => {
+    getListMock
+      .mockRejectedValueOnce(httpError(500, "Database is unavailable"))
+      .mockResolvedValueOnce(listResult([]));
+
+    renderControl();
+
+    expect(await screen.findByTestId("replay-pin-error")).toHaveTextContent(
+      "Database is unavailable",
+    );
+
+    fireEvent.click(screen.getByTestId("replay-pin-retry"));
+
+    expect(await screen.findByTestId("replay-pin-button")).toHaveTextContent(
+      "Pin recording",
+    );
+    expect(screen.queryByTestId("replay-pin-error")).not.toBeInTheDocument();
+  });
+
+  it("says a pending pin protects nothing until the recording ends", async () => {
+    getListMock.mockResolvedValue(listResult([pinRow()]));
+
+    renderControl();
+
+    expect(await screen.findByTestId("replay-pin-status")).toHaveTextContent(
+      PIN_PENDING_COPY,
+    );
+    expect(PIN_PENDING_COPY).toContain("when the recording ends");
+    expect(PIN_PENDING_COPY).toContain("10 minutes");
+  });
+
+  it("shows a materialized pin as protected, with its lapse date", async () => {
+    getListMock.mockResolvedValue(
+      listResult([
+        pinRow({
+          materializedAt: new Date("2026-09-01T10:00:00Z"),
+          expiresAt: new Date("2028-09-01T10:00:00Z"),
+        }),
+      ]),
+    );
+
+    renderControl();
+
+    const status: HTMLElement = await screen.findByTestId("replay-pin-status");
+
+    expect(status).toHaveTextContent("Pinned");
+    expect(status.getAttribute("title")).toContain("pinned retention until");
+  });
+});
+
+describe("ReplayPinControl pin", () => {
+  it("creates the pin and reloads into the pending state", async () => {
+    getListMock
+      .mockResolvedValueOnce(listResult([]))
+      .mockResolvedValueOnce(listResult([pinRow()]));
+    createMock.mockResolvedValue({});
+
+    renderControl();
+
+    fireEvent.click(await screen.findByTestId("replay-pin-button"));
+
+    expect(await screen.findByTestId("replay-pin-status")).toHaveTextContent(
+      PIN_PENDING_COPY,
+    );
+    expect(createMock).toHaveBeenCalledTimes(1);
+
+    const created: { model: { sessionId?: string } } = createMock.mock
+      .calls[0]![0] as { model: { sessionId?: string } };
+
+    expect(created.model.sessionId).toBe(SESSION_ID);
+  });
+
+  it("surfaces a create failure with the server's message and offers a retry", async () => {
+    getListMock.mockResolvedValue(listResult([]));
+    createMock.mockRejectedValueOnce(
+      httpError(402, "Pinned recordings are not included in your plan"),
+    );
+
+    renderControl();
+
+    fireEvent.click(await screen.findByTestId("replay-pin-button"));
+
+    expect(await screen.findByTestId("replay-pin-error")).toHaveTextContent(
+      "Pinned recordings are not included in your plan",
+    );
+    expect(screen.getByTestId("replay-pin-button")).toHaveTextContent(
+      "Retry pin",
+    );
+
+    /* The retry runs the create again and clears the error on success. */
+    createMock.mockResolvedValueOnce({});
+    getListMock.mockResolvedValue(listResult([pinRow()]));
+
+    fireEvent.click(screen.getByTestId("replay-pin-button"));
+
+    expect(await screen.findByTestId("replay-pin-status")).toHaveTextContent(
+      PIN_PENDING_COPY,
+    );
+    expect(screen.queryByTestId("replay-pin-error")).not.toBeInTheDocument();
+    expect(createMock).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe("ReplayPinControl unpin", () => {
+  const protectedRow: PinRow = pinRow({
+    materializedAt: new Date("2026-09-01T10:00:00Z"),
+  });
+
+  it("asks for confirmation before deleting, and says what happens to the copies", async () => {
+    getListMock.mockResolvedValue(listResult([protectedRow]));
+
+    renderControl();
+
+    fireEvent.click(await screen.findByTestId("replay-unpin-button"));
+
+    expect(deleteItemMock).not.toHaveBeenCalled();
+    expect(screen.getByTestId("modal-title")).toHaveTextContent(
+      "Unpin this recording?",
+    );
+    expect(screen.getByTestId("confirm-modal-description")).toHaveTextContent(
+      "removed within an hour",
+    );
+  });
+
+  it("cancelling the confirmation deletes nothing", async () => {
+    getListMock.mockResolvedValue(listResult([protectedRow]));
+
+    renderControl();
+
+    fireEvent.click(await screen.findByTestId("replay-unpin-button"));
+    fireEvent.click(screen.getByText("Cancel"));
+
+    await waitFor(() => {
+      expect(screen.queryByTestId("modal-title")).not.toBeInTheDocument();
+    });
+
+    expect(deleteItemMock).not.toHaveBeenCalled();
+    expect(screen.getByTestId("replay-pin-status")).toHaveTextContent("Pinned");
+  });
+
+  it("confirming deletes the pin and tells the viewer the copy goes within an hour", async () => {
+    getListMock
+      .mockResolvedValueOnce(listResult([protectedRow]))
+      .mockResolvedValueOnce(listResult([]));
+    deleteItemMock.mockResolvedValue(undefined);
+
+    renderControl();
+
+    fireEvent.click(await screen.findByTestId("replay-unpin-button"));
+    fireEvent.click(screen.getByTestId("modal-footer-submit-button"));
+
+    /*
+     * The status element exists before and after the unpin (it flips from
+     * "Pinned" to the unpinned copy), so wait on the content, not the node.
+     */
+    await waitFor(() => {
+      expect(screen.getByTestId("replay-pin-status")).toHaveTextContent(
+        PIN_UNPINNED_COPY,
+      );
+    });
+    expect(PIN_UNPINNED_COPY).toContain("within an hour");
+    expect(deleteItemMock).toHaveBeenCalledTimes(1);
+
+    const deleted: { id: ObjectID } = deleteItemMock.mock.calls[0]![0] as {
+      id: ObjectID;
+    };
+
+    expect(deleted.id.toString()).toBe(PIN_ID);
+    /* The viewer can pin again from here. */
+    expect(screen.getByTestId("replay-pin-button")).toHaveTextContent(
+      "Pin recording",
+    );
+  });
+
+  it("surfaces a delete failure inside the confirmation and keeps the pin", async () => {
+    getListMock.mockResolvedValue(listResult([protectedRow]));
+    deleteItemMock.mockRejectedValueOnce(
+      httpError(500, "Could not reach the database"),
+    );
+
+    renderControl();
+
+    fireEvent.click(await screen.findByTestId("replay-unpin-button"));
+    fireEvent.click(screen.getByTestId("modal-footer-submit-button"));
+
+    await waitFor(() => {
+      expect(screen.getByTestId("modal")).toHaveTextContent(
+        "Could not reach the database",
+      );
+    });
+
+    /* Still pinned, still confirmable. */
+    expect(screen.getByTestId("replay-pin-status")).toHaveTextContent("Pinned");
+    expect(screen.getByTestId("modal-title")).toBeInTheDocument();
+  });
+});
+
+describe("ReplayPinControl pending poll", () => {
+  it("polls a pending pin and, when the worker has removed it, says so instead of reverting silently", async () => {
+    jest.useFakeTimers();
+
+    try {
+      getListMock
+        .mockResolvedValueOnce(listResult([pinRow()]))
+        .mockResolvedValueOnce(listResult([]));
+
+      renderControl();
+
+      expect(await screen.findByTestId("replay-pin-status")).toHaveTextContent(
+        PIN_PENDING_COPY,
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(PENDING_POLL_INTERVAL_MS + 10);
+      });
+
+      await waitFor(() => {
+        expect(screen.getByTestId("replay-pin-status")).toHaveTextContent(
+          PIN_REMOVED_COPY,
+        );
+      });
+      expect(PIN_REMOVED_COPY).toContain("already expired");
+      expect(getListMock).toHaveBeenCalledTimes(2);
+      /* Pinning again is offered, but never as a silent "Pin recording". */
+      expect(screen.getByTestId("replay-pin-button")).toBeInTheDocument();
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  it("promotes a pending pin to protected once the materializer stamps it", async () => {
+    jest.useFakeTimers();
+
+    try {
+      getListMock
+        .mockResolvedValueOnce(listResult([pinRow()]))
+        .mockResolvedValueOnce(
+          listResult([pinRow({ materializedAt: new Date() })]),
+        );
+
+      renderControl();
+
+      expect(await screen.findByTestId("replay-pin-status")).toHaveTextContent(
+        PIN_PENDING_COPY,
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(PENDING_POLL_INTERVAL_MS + 10);
+      });
+
+      await waitFor(() => {
+        expect(screen.getByTestId("replay-pin-status")).toHaveTextContent(
+          "Pinned",
+        );
+      });
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  it("keeps the pending state through a transient poll failure", async () => {
+    jest.useFakeTimers();
+
+    try {
+      getListMock
+        .mockResolvedValueOnce(listResult([pinRow()]))
+        .mockRejectedValueOnce(httpError(502, "Bad gateway"));
+
+      renderControl();
+
+      expect(await screen.findByTestId("replay-pin-status")).toHaveTextContent(
+        PIN_PENDING_COPY,
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(PENDING_POLL_INTERVAL_MS + 10);
+      });
+
+      await waitFor(() => {
+        expect(getListMock).toHaveBeenCalledTimes(2);
+      });
+
+      expect(screen.getByTestId("replay-pin-status")).toHaveTextContent(
+        PIN_PENDING_COPY,
+      );
+      expect(screen.queryByTestId("replay-pin-error")).not.toBeInTheDocument();
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+});

package/Tests/UI/Rum/ReplayPlaybackIntent.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it } from "@jest/globals";
+import {
+  DEFAULT_SKIP_INACTIVE,
+  END_OF_RECORDING_TOLERANCE_MS,
+  FEED_AHEAD_FLOOR_MS,
+  IDLE_SKIP_PREROLL_MS,
+  MAX_PREFETCH_PAGES_AHEAD,
+  computeFeedAheadMs,
+  computePrefetchPagesAhead,
+  getIdleSkipTargetMs,
+  shouldRewindBeforePlay,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/SessionReplay/ReplayPlaybackIntent";
+
+/*
+ * The two playback defaults behind the reported "Play does nothing".
+ *
+ * They are pinned here rather than inside the player component because both
+ * are product decisions with a specific failure mode behind them, and a
+ * future refactor flipping either one back would reintroduce a bug that
+ * takes a browser, a real recording and a stopwatch to notice.
+ */
+
+describe("DEFAULT_SKIP_INACTIVE", () => {
+  it("is off, so playback is faithful and cannot outrun the loader", () => {
+    /*
+     * Skip-inactive is rrweb fast-forwarding. Chunks arrive one 15-second
+     * window at a time over an authenticated fetch, so a fast-forward
+     * drains the fed range, rrweb emits Finish, and the stage sits stalled -
+     * on the very first press of Play, for any recording that opens with a
+     * few idle seconds while the page loads.
+     */
+    expect(DEFAULT_SKIP_INACTIVE).toBe(false);
+  });
+});
+
+describe("shouldRewindBeforePlay", () => {
+  it("rewinds when the playhead is sitting at the end", () => {
+    /*
+     * rrweb has nothing left to cast there: it emits Finish immediately and
+     * stops again, so the button flips to pause and straight back while the
+     * picture never moves. Every viewer who watches a session through and
+     * then presses Play hits this.
+     */
+    expect(shouldRewindBeforePlay(60000, 60000)).toBe(true);
+  });
+
+  it("rewinds from inside one playback tick of the end", () => {
+    /*
+     * The last frame rarely lands on the exact millisecond the manifest
+     * calls the end, so an exact comparison would miss this on nearly every
+     * session.
+     */
+    expect(
+      shouldRewindBeforePlay(60000 - END_OF_RECORDING_TOLERANCE_MS, 60000),
+    ).toBe(true);
+    expect(
+      shouldRewindBeforePlay(60000 - END_OF_RECORDING_TOLERANCE_MS + 1, 60000),
+    ).toBe(true);
+  });
+
+  it("leaves the playhead alone anywhere else in the recording", () => {
+    expect(shouldRewindBeforePlay(0, 60000)).toBe(false);
+    expect(shouldRewindBeforePlay(30000, 60000)).toBe(false);
+    expect(
+      shouldRewindBeforePlay(60000 - END_OF_RECORDING_TOLERANCE_MS - 1, 60000),
+    ).toBe(false);
+  });
+
+  it("rewinds when the playhead has run past the stated duration", () => {
+    /*
+     * The manifest's duration and the recorder's own clock disagree by the
+     * clock skew, so the playhead genuinely can end up past it. That is
+     * still the end of the recording.
+     */
+    expect(shouldRewindBeforePlay(61000, 60000)).toBe(true);
+  });
+
+  it("never rewinds a recording whose duration is not known yet", () => {
+    /*
+     * Zero is what the loader reports before the manifest is read, or for a
+     * session whose footage is gone. Treating it as "at the end" would fire
+     * a seek to 0 on the first press of Play on every single session.
+     */
+    expect(shouldRewindBeforePlay(0, 0)).toBe(false);
+    expect(shouldRewindBeforePlay(5000, 0)).toBe(false);
+    expect(shouldRewindBeforePlay(0, -1)).toBe(false);
+  });
+
+  it("survives the non-finite values a parsed manifest can produce", () => {
+    /*
+     * Both sides are read off an untyped JSON projection, so NaN is
+     * reachable without anything being wrong upstream.
+     */
+    expect(shouldRewindBeforePlay(Number.NaN, 60000)).toBe(false);
+    expect(shouldRewindBeforePlay(1000, Number.NaN)).toBe(false);
+    expect(shouldRewindBeforePlay(1000, Number.POSITIVE_INFINITY)).toBe(false);
+  });
+});
+
+describe("computeFeedAheadMs", () => {
+  it("keeps two flush intervals of headroom at ordinary speeds", () => {
+    expect(computeFeedAheadMs(0.5)).toBe(FEED_AHEAD_FLOOR_MS);
+    expect(computeFeedAheadMs(1)).toBe(FEED_AHEAD_FLOOR_MS);
+    expect(computeFeedAheadMs(1.5)).toBe(FEED_AHEAD_FLOOR_MS);
+  });
+
+  it("grows with the speed so 8x cannot outrun a slow fetch", () => {
+    /*
+     * At 8x, 30s of footage plays out in under four seconds - less than
+     * one slow /chunks round trip - so the window has to grow with speed.
+     */
+    expect(computeFeedAheadMs(2)).toBe(40000);
+    expect(computeFeedAheadMs(4)).toBe(80000);
+    expect(computeFeedAheadMs(8)).toBe(160000);
+  });
+
+  it("falls back to the floor for a nonsense speed", () => {
+    expect(computeFeedAheadMs(0)).toBe(FEED_AHEAD_FLOOR_MS);
+    expect(computeFeedAheadMs(Number.NaN)).toBe(FEED_AHEAD_FLOOR_MS);
+  });
+});
+
+describe("computePrefetchPagesAhead", () => {
+  it("warms two pages normally and four from 4x", () => {
+    expect(computePrefetchPagesAhead(1)).toBe(2);
+    expect(computePrefetchPagesAhead(2)).toBe(2);
+    expect(computePrefetchPagesAhead(4)).toBe(4);
+    expect(computePrefetchPagesAhead(8)).toBe(4);
+  });
+
+  it("never asks for more pages than MAX_PREFETCH_PAGES_AHEAD", () => {
+    /*
+     * ChunkLoader sizes its decoded cache from this constant. If a speed
+     * could ask for more, the cache would evict footage that had been
+     * fetched and not yet fed, and the feed loop would fetch it back.
+     */
+    for (const speed of [0.25, 0.5, 1, 2, 4, 8, 16, Number.NaN]) {
+      expect(computePrefetchPagesAhead(speed)).toBeLessThanOrEqual(
+        MAX_PREFETCH_PAGES_AHEAD,
+      );
+    }
+  });
+});
+
+describe("getIdleSkipTargetMs", () => {
+  it("lands one second before the band ends, never before it starts", () => {
+    expect(getIdleSkipTargetMs({ startMs: 10000, endMs: 40000 })).toBe(
+      40000 - IDLE_SKIP_PREROLL_MS,
+    );
+    expect(getIdleSkipTargetMs({ startMs: 10000, endMs: 10500 })).toBe(10000);
+  });
+});