perf(webapp): compute delivery createdAt bounds from the two extreme ids

The delivery-id bounds calc decoded every id in the set to find the createdAt
span. Delivery id bodies are base32hex(big-endian timestamp then random bytes),
and base32hex is order-preserving, so lexical order equals chronological order:
the earliest and latest timestamps sit at the lexical extremes. Track the min
and max id in a single pass and decode only those two. A legacy cuid id starts
with 'c', which sorts above every v1 body, so it always lands at the max extreme
where decoding rejects it and the caller skips partition pruning.

The list-hydration query shares the same single-pass min/max helper for its
already-decoded page timestamps, dropping the last Math.min(...spread) in the
delivery repository (the spread overflows the call stack on large inputs).

Author: ericallam

apps/webapp/app/services/webhookDeliveriesRepository/clickhouseWebhookDeliveriesRepository.server.ts

@@ -1,7 +1,7 @@
 import { type ClickhouseQueryBuilder } from "@internal/clickhouse";
 import { WebhookDeliveryId } from "@trigger.dev/core/v3/isomorphic";
 import { boundedIn } from "@trigger.dev/database";
-import { deliveryIdsCreatedAtBounds } from "./deliveryIdBounds";
+import { createdAtMsBounds, deliveryIdsCreatedAtBounds } from "./deliveryIdBounds";
 import { decodeRunsCursor, encodeRunsCursor } from "../runsRepository/runsCursor.server";
 import {
   type CountDeliveriesByEndpointOptions,
@@ -195,18 +195,13 @@ export class ClickHouseWebhookDeliveriesRepository implements IWebhookDeliveries
     // `id IN (...)` query without a createdAt predicate scans every child
     // partition, so derive a [min, max] range from the CH page and pass it
     // through. This is the one place webhook hydration diverges from runs.
-    const createdAtMsValues = pageRows.map((row) => row.createdAt);
-    const minCreatedAtMs = Math.min(...createdAtMsValues);
-    const maxCreatedAtMs = Math.max(...createdAtMsValues);
+    const bounds = createdAtMsBounds(pageRows.map((row) => row.createdAt));
 
     // CH gives the ordered id list; Postgres hydrates the full lean rows by PK id.
     const deliveries = await this.options.prisma.webhookDelivery.findMany({
       where: {
         id: { in: boundedIn(deliveryIds) },
-        createdAt: {
-          gte: new Date(minCreatedAtMs),
-          lte: new Date(maxCreatedAtMs),
-        },
+        ...(bounds ? { createdAt: bounds } : {}),
       },
       select: DELIVERY_LIST_SELECT,
     });

apps/webapp/app/services/webhookDeliveriesRepository/deliveryIdBounds.ts

@@ -1,32 +1,57 @@
 import { WebhookDeliveryId } from "@trigger.dev/core/v3/isomorphic";
 
 /**
- * Compute the `createdAt` span covering a set of webhook delivery friendlyIds, for partition-pruning a
- * lookup by id on the RANGE-partitioned `WebhookDelivery` table.
+ * Single-pass min/max over a set of `createdAt` timestamps (unix ms), returned as a Prisma
+ * `{ gte, lte }` range for partition-pruning the RANGE-partitioned `WebhookDelivery` table.
  *
- * Each v1 id is time-encoded (see `WebhookDeliveryId`) with the same timestamp the engine stores as the
- * row's `createdAt`, so the returned `[gte, lte]` covers every row in the set exactly. Returns
- * `undefined` when the set is empty or contains any legacy (non-time-encoded) id: in that case the
- * caller must not add a `createdAt` predicate, since a bound derived from only the decodable ids would
- * wrongly exclude the legacy rows.
- *
- * Single pass, no intermediate arrays and no `Math.min(...spread)` (which is O(n) to build the argument
- * list and can overflow the call stack for large inputs).
+ * Avoids `Math.min(...spread)` / `Math.max(...spread)`: the spread builds an O(n) argument list and
+ * throws "Maximum call stack size exceeded" once the array is large (~1e5+ elements). Returns
+ * `undefined` for an empty set, so the caller adds no `createdAt` predicate.
  */
-export function deliveryIdsCreatedAtBounds(
-  friendlyIds: string[]
-): { gte: Date; lte: Date } | undefined {
+export function createdAtMsBounds(msValues: number[]): { gte: Date; lte: Date } | undefined {
   let min = Number.POSITIVE_INFINITY;
   let max = Number.NEGATIVE_INFINITY;
 
-  for (const friendlyId of friendlyIds) {
-    const timestamp = WebhookDeliveryId.parseTimestamp(friendlyId);
-    if (!timestamp) return undefined;
-    const ms = timestamp.getTime();
+  for (const ms of msValues) {
     if (ms < min) min = ms;
     if (ms > max) max = ms;
   }
 
   if (min === Number.POSITIVE_INFINITY) return undefined;
   return { gte: new Date(min), lte: new Date(max) };
 }
+
+/**
+ * Compute the `createdAt` span covering a set of webhook delivery friendlyIds, for partition-pruning
+ * a lookup by id on the RANGE-partitioned `WebhookDelivery` table.
+ *
+ * A v1 id body is `base32hex(big-endian ms timestamp ‖ random bytes)`, and base32hex is
+ * order-preserving, so lexical id order equals chronological order. The earliest and latest
+ * timestamps therefore sit at the lexical extremes, and we recover the span by decoding only those
+ * two ids instead of all N. The embedded timestamp equals the row's `createdAt`, so `[gte, lte]`
+ * covers every row in the set exactly.
+ *
+ * Returns `undefined` when the set is empty or either extreme fails to decode, so the caller adds no
+ * `createdAt` predicate. A legacy (cuid) id starts with `c`, which sorts above every v1 body, so it
+ * always lands at the max extreme where `parseTimestamp` rejects it: a non-time-encoded id can never
+ * yield a bogus bound that would wrongly exclude its own row.
+ */
+export function deliveryIdsCreatedAtBounds(
+  friendlyIds: string[]
+): { gte: Date; lte: Date } | undefined {
+  if (friendlyIds.length === 0) return undefined;
+
+  let minBody = WebhookDeliveryId.toId(friendlyIds[0]!);
+  let maxBody = minBody;
+  for (let i = 1; i < friendlyIds.length; i++) {
+    const body = WebhookDeliveryId.toId(friendlyIds[i]!);
+    if (body < minBody) minBody = body;
+    if (body > maxBody) maxBody = body;
+  }
+
+  const gte = WebhookDeliveryId.parseTimestamp(minBody);
+  const lte = WebhookDeliveryId.parseTimestamp(maxBody);
+  if (!gte || !lte) return undefined;
+
+  return { gte, lte };
+}

apps/webapp/test/deliveryIdBounds.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, it, vi } from "vitest";
 import { WebhookDeliveryId } from "@trigger.dev/core/v3/isomorphic";
-import { deliveryIdsCreatedAtBounds } from "../app/services/webhookDeliveriesRepository/deliveryIdBounds";
+import {
+  createdAtMsBounds,
+  deliveryIdsCreatedAtBounds,
+} from "../app/services/webhookDeliveriesRepository/deliveryIdBounds";
 
 function idAt(iso: string): string {
   vi.setSystemTime(new Date(iso));
@@ -39,14 +42,42 @@ describe("deliveryIdsCreatedAtBounds", () => {
     }
   });
 
-  it("returns undefined when any id is legacy (non-time-encoded), so the caller skips pruning", () => {
+  it("returns undefined for a legacy (cuid) id even when it sits between two v1 ids", () => {
     vi.useFakeTimers();
     try {
-      const v1 = idAt("2026-08-11T10:00:00.000Z");
-      expect(deliveryIdsCreatedAtBounds([v1, "whd_legacycuidstyleid"])).toBeUndefined();
-      expect(deliveryIdsCreatedAtBounds(["whd_legacycuidstyleid"])).toBeUndefined();
+      const legacy = "whd_clwxyz00001234567890abcde";
+      const early = idAt("2026-08-09T00:00:00.000Z");
+      const late = idAt("2026-08-11T10:00:00.000Z");
+      expect(deliveryIdsCreatedAtBounds([early, legacy, late])).toBeUndefined();
+      expect(deliveryIdsCreatedAtBounds([late, legacy])).toBeUndefined();
+      expect(deliveryIdsCreatedAtBounds([legacy])).toBeUndefined();
     } finally {
       vi.useRealTimers();
     }
   });
 });
+
+describe("createdAtMsBounds", () => {
+  it("returns undefined for an empty set", () => {
+    expect(createdAtMsBounds([])).toBeUndefined();
+  });
+
+  it("returns a zero-width span for a single value", () => {
+    const bounds = createdAtMsBounds([1_000]);
+    expect(bounds?.gte.getTime()).toBe(1_000);
+    expect(bounds?.lte.getTime()).toBe(1_000);
+  });
+
+  it("spans the smallest and largest value regardless of input order", () => {
+    const bounds = createdAtMsBounds([50, 10, 30, 90, 40]);
+    expect(bounds?.gte.getTime()).toBe(10);
+    expect(bounds?.lte.getTime()).toBe(90);
+  });
+
+  it("handles a large input without a stack overflow (unlike Math.min(...spread))", () => {
+    const values = Array.from({ length: 300_000 }, (_, i) => i);
+    const bounds = createdAtMsBounds(values);
+    expect(bounds?.gte.getTime()).toBe(0);
+    expect(bounds?.lte.getTime()).toBe(299_999);
+  });
+});