@oneuptime/common 13.0.1 → 13.0.4

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

@@ -16,7 +16,9 @@ import {
  */
 import * as React from "react";
 import { MemoryRouter } from "react-router-dom";
+import Route from "../../../Types/API/Route";
 import { describe, expect, it, jest } from "@jest/globals";
+import getJestMockFunction, { MockFunction } from "../../MockType";
 import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
 import ObjectID from "../../../Types/ObjectID";
 import ExceptionInstance from "../../../Models/AnalyticsModels/ExceptionInstance";
@@ -535,6 +537,89 @@ describe("ReplayRail row click (scrubber-devtools-5)", () => {
     expect(rows()[2]).toHaveAttribute("data-active", "false");
   });
 
+  it("keeps a row between the playhead and the pre-roll-selected row dimmed as future", () => {
+    /*
+     * isFuture is "offset > playhead", NOT "after the active row": in the
+     * selected row's pre-roll window the active row jumps ahead of the
+     * playhead, and a row sitting between the two has not happened yet.
+     */
+    const signals: Array<ReplaySignal> = [
+      ...defaultSignals(),
+      makeSignal("console", 8500, { id: "rec:0:5", title: "between" }),
+    ];
+    const result: RenderResult = renderRail({ signals: signals });
+
+    fireEvent.click(within(rows()[4] as HTMLElement).getByText(/TypeError/));
+
+    result.rerender({ currentTimeMs: 8000, selectedSignalId: "rec:0:4" });
+
+    const allRows: Array<HTMLElement> = rows();
+
+    expect(rowTitles()).toEqual([
+      "rec:0:1",
+      "rec:0:2",
+      "rec:0:3",
+      "rec:0:5",
+      "rec:0:4",
+    ]);
+    expect(allRows[2]).toHaveAttribute("data-future", "false");
+    expect(allRows[2]).toHaveAttribute("data-active", "false");
+    /* 8500 > 8000: still ahead of the playhead even though the active row is past it. */
+    expect(allRows[3]).toHaveAttribute("data-future", "true");
+    expect(allRows[3]).toHaveAttribute("data-active", "false");
+    expect(allRows[4]).toHaveAttribute("data-active", "true");
+    expect(allRows[4]).toHaveAttribute("data-selected", "true");
+    expect(allRows[4]).toHaveAttribute("data-future", "false");
+  });
+
+  it("keeps the trace link on a row across playhead ticks", () => {
+    const traceViewCalls: Array<string> = [];
+    const result: RenderResult = renderRail({
+      currentTimeMs: 1000,
+      links: {
+        traceView: (traceId: string): Route => {
+          traceViewCalls.push(traceId);
+
+          return new Route(`/dashboard/p/traces/${traceId}`);
+        },
+      },
+    });
+
+    const row: HTMLElement = rows()[0] as HTMLElement;
+    const href: string | null =
+      within(row).getByText("trace").closest("a")?.getAttribute("href") ?? null;
+
+    expect(href).not.toBeNull();
+    expect(href).toContain(TRACE_ID);
+
+    /*
+     * Ticks across the row's own offset (2000ms), so the run also covers
+     * the moment isFuture flips: the row must keep its element and its
+     * link identity through the flip, not be rebuilt by it.
+     */
+    for (let tick: number = 1; tick <= 30; tick++) {
+      result.rerender({ currentTimeMs: 1000 + tick * 40 });
+    }
+
+    const sameRow: HTMLElement = rows()[0] as HTMLElement;
+
+    expect(sameRow).toBe(row);
+    expect(
+      within(sameRow).getByText("trace").closest("a")?.getAttribute("href"),
+    ).toBe(href);
+    expect(sameRow).toHaveAttribute("data-future", "false");
+
+    /*
+     * The route is built once per rows/links change, not once per row per
+     * tick. Without that, every trace-linked row got a fresh
+     * `{ route, label }` object on every publish - defeating the row's
+     * own memo and building a Route each time - and the element identity
+     * above would still have held, because React keys the rows by signal
+     * id. So the count is the assertion that can actually fail.
+     */
+    expect(traceViewCalls.length).toBeLessThanOrEqual(2);
+  });
+
   it("expands the detail under the selected row and closes it from the detail", () => {
     const result: RenderResult = renderRail({ selectedSignalId: "rec:0:4" });
 
@@ -904,6 +989,59 @@ describe("ReplayRail keyboard and stepping", () => {
 });
 
 describe("ReplayRail filtering", () => {
+  it("clears event search from its visible action and restores keyboard focus", () => {
+    const result: RenderResult = renderRail();
+    const search: HTMLElement = screen.getByTestId("rail-search-input");
+
+    expect(
+      screen.queryByRole("button", { name: "Clear event search" }),
+    ).not.toBeInTheDocument();
+    fireEvent.change(search, { target: { value: "status:>=400" } });
+    expect(rowTitles()).toEqual(["rec:0:1"]);
+    fireEvent.click(screen.getByRole("button", { name: "Clear event search" }));
+
+    expect(result.queries).toEqual(["status:>=400", ""]);
+    expect(search).toHaveValue("");
+    expect(search).toHaveFocus();
+    expect(rowTitles()).toEqual(["rec:0:1", "rec:0:2", "rec:0:3", "rec:0:4"]);
+    expect(
+      screen.queryByRole("button", { name: "Clear event search" }),
+    ).not.toBeInTheDocument();
+  });
+
+  it("clearing text preserves the selected event type and quick filter", () => {
+    renderRail({ activeTab: "network" });
+    fireEvent.click(screen.getByTestId("rail-chip-network-2xx"));
+    fireEvent.change(screen.getByTestId("rail-search-input"), {
+      target: { value: "checkout" },
+    });
+    fireEvent.click(screen.getByRole("button", { name: "Clear event search" }));
+
+    expect(screen.getByTestId("rail-tab-network")).toHaveAttribute(
+      "aria-selected",
+      "true",
+    );
+    expect(screen.getByTestId("rail-chip-network-2xx")).toHaveAttribute(
+      "aria-pressed",
+      "true",
+    );
+    expect(rows()).toHaveLength(0);
+  });
+
+  it("places collapse in the Events header only when a collapse action is supplied", () => {
+    const collapse: MockFunction = getJestMockFunction();
+    const result: RenderResult = renderRail({ onCollapse: collapse });
+    expect(screen.getByRole("heading", { name: "Events" })).toBeInTheDocument();
+    fireEvent.click(
+      screen.getByRole("button", { name: "Collapse the events rail" }),
+    );
+    expect(collapse).toHaveBeenCalledTimes(1);
+    result.rerender({ onCollapse: undefined });
+    expect(
+      screen.queryByRole("button", { name: "Collapse the events rail" }),
+    ).not.toBeInTheDocument();
+  });
+
   it("filters rows by query tokens and reports the query", () => {
     const result: RenderResult = renderRail();
 
@@ -939,7 +1077,11 @@ describe("ReplayRail filtering", () => {
       ],
     });
 
-    fireEvent.click(screen.getByText("±30s"));
+    fireEvent.click(
+      screen.getByRole("button", {
+        name: "Scope: within 30 seconds of the playhead",
+      }),
+    );
 
     expect(rowTitles()).toEqual(["rec:0:1"]);
   });

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

@@ -0,0 +1,338 @@
+import "@testing-library/jest-dom";
+import { act, render, screen } from "@testing-library/react";
+import * as React from "react";
+import { describe, expect, it } from "@jest/globals";
+import ReplayScrubber, {
+  REPLAY_CONTROLS_CLOCK_MS,
+  REPLAY_TRACK_CLOCK_MS,
+  ReplayScrubberProps,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/SessionReplay/ReplayScrubber";
+import useReplayClock, {
+  ReplayClockLike,
+  quantiseReplayClock,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/SessionReplay/useReplayClock";
+import {
+  ReplayClockListener,
+  ReplayEngineListener,
+  ReplayEngineSnapshot,
+  derivePhase,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/SessionReplay/Engine/ReplayEngineTypes";
+
+/*
+ * The render budget of the player while the playhead moves.
+ *
+ * The engine publishes about thirty times a second while playing, and
+ * every publish used to reach the composition root as a brand-new
+ * snapshot object, so React re-rendered the header, the overlays, the
+ * stage, the transport, the timeline and the 1800-line rail on every
+ * tick - synchronously, in the same frame rrweb was using to cast
+ * mutations into the replay iframe. The clock channel exists to stop
+ * that, and this file is what keeps it stopped: it counts renders, not
+ * appearances, because the regression it guards against is invisible in
+ * a screenshot and shows up only as a dropped frame.
+ *
+ * The rule these tests encode: a component re-renders when the playhead
+ * crosses ITS OWN quantum, and never merely because the engine published.
+ */
+
+const DURATION_MS: number = 600000;
+const PUBLISH_INTERVAL_MS: number = 33;
+
+/*
+ * The engine as a clock, with nothing else in it. Publishes carry the
+ * playhead alone, exactly as ReplayEngine's clock channel does.
+ */
+class FakeClock implements ReplayClockLike {
+  public currentTimeMs: number = 0;
+  public snapshotReads: number = 0;
+  private readonly clockListeners: Set<ReplayClockListener> =
+    new Set<ReplayClockListener>();
+  private readonly listeners: Set<ReplayEngineListener> =
+    new Set<ReplayEngineListener>();
+  private snapshotValue: ReplayEngineSnapshot = makeSnapshot();
+
+  public subscribeClock(listener: ReplayClockListener): () => void {
+    this.clockListeners.add(listener);
+
+    return (): void => {
+      this.clockListeners.delete(listener);
+    };
+  }
+
+  public getCurrentTimeMs(): number {
+    return this.currentTimeMs;
+  }
+
+  public subscribe(listener: ReplayEngineListener): () => void {
+    this.listeners.add(listener);
+
+    return (): void => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  public getSnapshot(): ReplayEngineSnapshot {
+    this.snapshotReads += 1;
+
+    return this.snapshotValue;
+  }
+
+  /* One engine publish: the playhead moved, nothing structural did. */
+  public publish(currentTimeMs: number): void {
+    this.currentTimeMs = currentTimeMs;
+    this.snapshotValue = {
+      ...this.snapshotValue,
+      currentTimeMs: currentTimeMs,
+    };
+
+    for (const listener of [...this.clockListeners]) {
+      listener(currentTimeMs);
+    }
+
+    for (const listener of [...this.listeners]) {
+      listener(this.snapshotValue);
+    }
+  }
+
+  public tick(times: number): void {
+    for (let index: number = 1; index <= times; index++) {
+      act((): void => {
+        this.publish(this.currentTimeMs + PUBLISH_INTERVAL_MS);
+      });
+    }
+  }
+}
+
+/* A clock source that predates the split: only the whole-snapshot channel. */
+class LegacyClock implements ReplayClockLike {
+  private readonly listeners: Set<ReplayEngineListener> =
+    new Set<ReplayEngineListener>();
+  private snapshotValue: ReplayEngineSnapshot = makeSnapshot();
+
+  public subscribe(listener: ReplayEngineListener): () => void {
+    this.listeners.add(listener);
+
+    return (): void => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  public getSnapshot(): ReplayEngineSnapshot {
+    return this.snapshotValue;
+  }
+
+  public publish(currentTimeMs: number): void {
+    this.snapshotValue = {
+      ...this.snapshotValue,
+      currentTimeMs: currentTimeMs,
+    };
+
+    for (const listener of [...this.listeners]) {
+      listener(this.snapshotValue);
+    }
+  }
+}
+
+function makeSnapshot(
+  overrides?: Partial<ReplayEngineSnapshot>,
+): ReplayEngineSnapshot {
+  const buffer: ReplayEngineSnapshot["buffer"] = overrides?.buffer ?? "ok";
+  const intent: ReplayEngineSnapshot["intent"] = overrides?.intent ?? "playing";
+
+  return {
+    phase: derivePhase(buffer, intent),
+    intent: intent,
+    buffer: buffer,
+    currentTimeMs: 0,
+    durationMs: DURATION_MS,
+    speed: 1,
+    skipInactive: false,
+    fedRange: { fromMs: 0, toMs: 60000 },
+    loadedChunkIndexes: [0, 1, 2, 3],
+    activeTabId: "tab-1",
+    recordedSize: null,
+    bufferingSinceMs: null,
+    lastGap: null,
+    lastIdleSkip: null,
+    error: null,
+    pendingSeekMs: null,
+    generation: 1,
+    ...overrides,
+  };
+}
+
+function noop(): void {
+  /* Handlers these assertions do not exercise. */
+}
+
+function makeScrubberProps(
+  overrides?: Partial<ReplayScrubberProps>,
+): ReplayScrubberProps {
+  return {
+    snapshot: makeSnapshot(),
+    bands: [],
+    markers: [],
+    onSeek: noop,
+    onPlayPause: noop,
+    onSkipInactiveChange: noop,
+    onSpeedChange: noop,
+    ...overrides,
+  };
+}
+
+interface CountingProps {
+  clock: ReplayClockLike;
+  quantumMs: number;
+  renders: { count: number };
+}
+
+/* Renders the quantised clock and counts how often React called it. */
+const Counting: React.FunctionComponent<CountingProps> = (
+  props: CountingProps,
+): React.ReactElement => {
+  const currentTimeMs: number = useReplayClock(props.clock, props.quantumMs);
+
+  props.renders.count += 1;
+
+  return <span data-testid="counting">{currentTimeMs}</span>;
+};
+
+describe("quantiseReplayClock", () => {
+  it("floors to the quantum and passes everything through below 1ms", () => {
+    expect(quantiseReplayClock(1234, 250)).toBe(1000);
+    expect(quantiseReplayClock(1250, 250)).toBe(1250);
+    expect(quantiseReplayClock(1234, 1)).toBe(1234);
+    expect(quantiseReplayClock(1234, 0)).toBe(1234);
+  });
+
+  it("answers a non-finite clock with zero rather than NaN", () => {
+    expect(quantiseReplayClock(Number.NaN, 250)).toBe(0);
+    expect(quantiseReplayClock(Number.POSITIVE_INFINITY, 250)).toBe(0);
+  });
+});
+
+describe("useReplayClock render budget", () => {
+  /*
+   * 100 publishes at 33ms is 3.3 seconds of playback. A component on the
+   * 250ms quantum may render about thirteen times for that; one on the
+   * frame quantum renders for every publish. The gap between those two
+   * numbers IS the fix.
+   */
+  it("renders a quarter-second consumer a dozen times across 100 publishes", () => {
+    const clock: FakeClock = new FakeClock();
+    const renders: { count: number } = { count: 0 };
+
+    render(<Counting clock={clock} quantumMs={250} renders={renders} />);
+
+    const initial: number = renders.count;
+
+    clock.tick(100);
+
+    const renderedForClock: number = renders.count - initial;
+
+    expect(renderedForClock).toBeLessThanOrEqual(
+      Math.ceil((100 * PUBLISH_INTERVAL_MS) / 250) + 1,
+    );
+    expect(renderedForClock).toBeGreaterThan(0);
+    /* The value on screen is still the current one, floored to the quantum. */
+    expect(screen.getByTestId("counting").textContent).toBe(
+      String(quantiseReplayClock(clock.currentTimeMs, 250)),
+    );
+  });
+
+  it("renders a frame-quantum consumer for every publish", () => {
+    const clock: FakeClock = new FakeClock();
+    const renders: { count: number } = { count: 0 };
+
+    render(<Counting clock={clock} quantumMs={16} renders={renders} />);
+
+    const initial: number = renders.count;
+
+    clock.tick(100);
+
+    expect(renders.count - initial).toBe(100);
+  });
+
+  it("does not render at all while the playhead stays inside the quantum", () => {
+    const clock: FakeClock = new FakeClock();
+    const renders: { count: number } = { count: 0 };
+
+    render(<Counting clock={clock} quantumMs={1000} renders={renders} />);
+
+    const initial: number = renders.count;
+
+    /* Four publishes, 132ms of playback: nowhere near the next second. */
+    clock.tick(4);
+
+    expect(renders.count).toBe(initial);
+  });
+
+  it("falls back to the whole-snapshot channel when the engine has no clock", () => {
+    const clock: LegacyClock = new LegacyClock();
+    const renders: { count: number } = { count: 0 };
+
+    render(<Counting clock={clock} quantumMs={250} renders={renders} />);
+
+    act((): void => {
+      clock.publish(4321);
+    });
+
+    expect(screen.getByTestId("counting").textContent).toBe("4250");
+    expect(renders.count).toBeGreaterThan(0);
+  });
+});
+
+describe("ReplayScrubber render budget", () => {
+  /*
+   * The transport shows tenths; the track's needle has to move with the
+   * picture. Given a clock the scrubber drives them at different rates
+   * from one subscription, so the buttons are not reconciled thirty
+   * times a second to move a needle.
+   */
+  it("moves the needle on every publish without re-rendering the transport", () => {
+    const clock: FakeClock = new FakeClock();
+    const props: ReplayScrubberProps = makeScrubberProps({ clock: clock });
+
+    render(<ReplayScrubber {...props} />);
+
+    clock.tick(3);
+
+    /* 99ms in: the needle tracks the clock publish for publish. */
+    expect(screen.getByTestId("timeline-playhead").style.left).toBe(
+      `${(quantiseReplayClock(clock.currentTimeMs, REPLAY_TRACK_CLOCK_MS) / DURATION_MS) * 100}%`,
+    );
+
+    clock.tick(30);
+
+    expect(screen.getByTestId("timeline-playhead").style.left).toBe(
+      `${(quantiseReplayClock(clock.currentTimeMs, REPLAY_TRACK_CLOCK_MS) / DURATION_MS) * 100}%`,
+    );
+    /*
+     * The transport is on a coarser quantum than the publish interval,
+     * which is what keeps the buttons out of the per-frame path.
+     */
+    expect(REPLAY_CONTROLS_CLOCK_MS).toBeGreaterThan(PUBLISH_INTERVAL_MS);
+  });
+
+  it("reads the playhead from the clock, never from the structural snapshot", () => {
+    const clock: FakeClock = new FakeClock();
+    /*
+     * A structural snapshot whose currentTimeMs is deliberately stale -
+     * which is exactly what the composition root now holds between
+     * structural changes. Anything that rendered from it would show
+     * 99000 forever.
+     */
+    const props: ReplayScrubberProps = makeScrubberProps({
+      clock: clock,
+      snapshot: makeSnapshot({ currentTimeMs: 99000 }),
+    });
+
+    render(<ReplayScrubber {...props} />);
+
+    clock.tick(10);
+
+    expect(screen.getByTestId("timeline-playhead").style.left).toBe(
+      `${(quantiseReplayClock(clock.currentTimeMs, REPLAY_TRACK_CLOCK_MS) / DURATION_MS) * 100}%`,
+    );
+  });
+});

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

@@ -34,6 +34,7 @@ import {
   buildErrorCounterpartIndex,
   findErrorAfterInteraction,
   findErrorLogsForTrace,
+  findLastSignalIndexAtOrBefore,
   findSignalMatch,
   formatPerformanceMeasure,
   formatSignalBytes,
@@ -713,6 +714,81 @@ describe("custom and marker rows", () => {
       }),
     ).toEqual(["rec:0:0", "rec:0:1"]);
   });
+
+  /*
+   * The loader hands the player one shared array per extraction state and
+   * the player's memo re-runs more often than that array changes; the
+   * batch adapter must not re-adapt thousands of unchanged rows each time.
+   */
+  it("fromTimelineEvents returns the same signals for the same array and clock", () => {
+    const events: Array<ReplayTimelineEvent> = [
+      makeEvent("console", { id: "rec:0:0", level: "warn", message: "a" }),
+      makeEvent("network", {
+        id: "rec:0:1",
+        method: "GET",
+        url: "https://api.example.com/items",
+        status: 200,
+      }),
+    ];
+
+    const first: Array<ReplaySignal> = fromTimelineEvents(events, {
+      startTimeUnixMs: null,
+    });
+    const second: Array<ReplaySignal> = fromTimelineEvents(events, {
+      startTimeUnixMs: null,
+    });
+
+    expect(second).toBe(first);
+    expect(second[0]).toBe(first[0]);
+    expect(second[1]).toBe(first[1]);
+
+    /* The wall clock feeds atUnixMs, so a different clock re-adapts. */
+    const reclocked: Array<ReplaySignal> = fromTimelineEvents(events, {
+      startTimeUnixMs: 1_000,
+    });
+
+    expect(reclocked).not.toBe(first);
+    expect(reclocked[0]).not.toBe(first[0]);
+    expect(reclocked[0]?.detail["atUnixMs"]).toBe(1_000 + 12_500);
+
+    /* Same clock again: the cache follows the latest clock for that array. */
+    expect(fromTimelineEvents(events, { startTimeUnixMs: 1_000 })).toBe(
+      reclocked,
+    );
+
+    /* A different array with identical rows is a different input. */
+    expect(
+      fromTimelineEvents([...events], { startTimeUnixMs: 1_000 }),
+    ).not.toBe(reclocked);
+
+    /* fromTimelineEvent itself stays pure: a fresh object every call. */
+    const event: ReplayTimelineEvent = events[0] as ReplayTimelineEvent;
+
+    expect(fromTimelineEvent(event, { startTimeUnixMs: null })).not.toBe(
+      fromTimelineEvent(event, { startTimeUnixMs: null }),
+    );
+  });
+
+  it("fromTimelineEvents re-adapts an array that was grown in place", () => {
+    const events: Array<ReplayTimelineEvent> = [
+      makeEvent("console", { id: "rec:0:0", level: "log", message: "a" }),
+    ];
+
+    const first: Array<ReplaySignal> = fromTimelineEvents(events, {
+      startTimeUnixMs: null,
+    });
+
+    events.push(
+      makeEvent("console", { id: "rec:0:1", level: "log", message: "b" }),
+    );
+
+    const grown: Array<ReplaySignal> = fromTimelineEvents(events, {
+      startTimeUnixMs: null,
+    });
+
+    expect(grown).not.toBe(first);
+    expect(grown).toHaveLength(2);
+  });
 });
 
 describe("fromLogRow", () => {
@@ -1083,6 +1159,109 @@ describe("mergeSignals", () => {
   });
 });
 
+describe("findLastSignalIndexAtOrBefore", () => {
+  /* The loop the rail used before the binary search; the reference. */
+  function linearReference(
+    signals: Array<ReplaySignal>,
+    currentTimeMs: number,
+  ): number {
+    let index: number = -1;
+
+    for (let i: number = 0; i < signals.length; i++) {
+      const signal: ReplaySignal | undefined = signals[i];
+
+      if (!signal) {
+        break;
+      }
+
+      if (signal.offsetMs <= currentTimeMs) {
+        index = i;
+      } else {
+        break;
+      }
+    }
+
+    return index;
+  }
+
+  const signals: Array<ReplaySignal> = [
+    makeSignal({ id: "a", offsetMs: 1000 }),
+    makeSignal({ id: "b", offsetMs: 2000 }),
+    makeSignal({ id: "c", offsetMs: 2000 }),
+    makeSignal({ id: "d", offsetMs: 2000 }),
+    makeSignal({ id: "e", offsetMs: 3000 }),
+  ];
+
+  it("returns -1 for an empty list, before the first row and for NaN", () => {
+    expect(findLastSignalIndexAtOrBefore([], 5)).toBe(-1);
+    expect(findLastSignalIndexAtOrBefore(signals, 0)).toBe(-1);
+    expect(findLastSignalIndexAtOrBefore(signals, 999)).toBe(-1);
+    expect(findLastSignalIndexAtOrBefore(signals, Number.NaN)).toBe(-1);
+    expect(findLastSignalIndexAtOrBefore([], Number.NaN)).toBe(-1);
+  });
+
+  it("lands on the row exactly at the playhead and on the LAST of a tie", () => {
+    expect(findLastSignalIndexAtOrBefore(signals, 1000)).toBe(0);
+    expect(findLastSignalIndexAtOrBefore(signals, 1999)).toBe(0);
+    expect(findLastSignalIndexAtOrBefore(signals, 2000)).toBe(3);
+    expect(findLastSignalIndexAtOrBefore(signals, 2999)).toBe(3);
+    expect(findLastSignalIndexAtOrBefore(signals, 3000)).toBe(4);
+  });
+
+  it("returns the last index after the last row", () => {
+    expect(findLastSignalIndexAtOrBefore(signals, 3001)).toBe(4);
+    expect(
+      findLastSignalIndexAtOrBefore(signals, Number.POSITIVE_INFINITY),
+    ).toBe(4);
+  });
+
+  it("agrees with the linear scan on random sorted lists with duplicates", () => {
+    /* Deterministic LCG so a failure reproduces. */
+    let seed: number = 0x2f6e2b1;
+    const nextRandom: () => number = (): number => {
+      seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0;
+      return seed / 0x100000000;
+    };
+
+    const offsets: Array<number> = [];
+    let offset: number = 0;
+
+    for (let i: number = 0; i < 2000; i++) {
+      /* ~30% ties, otherwise a small forward step. */
+      if (nextRandom() > 0.3) {
+        offset += Math.floor(nextRandom() * 500);
+      }
+
+      offsets.push(offset);
+    }
+
+    const random: Array<ReplaySignal> = offsets.map(
+      (value: number, index: number): ReplaySignal => {
+        return makeSignal({ id: `r-${index}`, offsetMs: value });
+      },
+    );
+    const lastOffset: number = offsets[offsets.length - 1] as number;
+
+    for (let probe: number = 0; probe < 500; probe++) {
+      /* Probes span before-first, inside and past-last. */
+      const currentTimeMs: number = Math.floor(
+        nextRandom() * (lastOffset + 2000) - 1000,
+      );
+
+      expect(findLastSignalIndexAtOrBefore(random, currentTimeMs)).toBe(
+        linearReference(random, currentTimeMs),
+      );
+    }
+
+    /* Every distinct offset, exactly. */
+    for (const value of offsets) {
+      expect(findLastSignalIndexAtOrBefore(random, value)).toBe(
+        linearReference(random, value),
+      );
+    }
+  });
+});
+
 describe("getActiveSignalIndex", () => {
   const signals: Array<ReplaySignal> = [
     makeSignal({ id: "a", offsetMs: 1000 }),