@agent-native/core 0.114.13 → 0.114.16

package/corpus/templates/analytics/server/lib/dashboard-report.ts

@@ -15,6 +15,10 @@ import {
   EMBED_TOKEN_QUERY_PARAM,
 } from "@agent-native/core/shared";
 
+import {
+  listReportablePanelIds,
+  REPORT_PANEL_CHUNK_SIZE,
+} from "../../app/pages/adhoc/sql-dashboard/report-panel-window";
 import type {
   DashboardFilter,
   FilterType,
@@ -22,6 +26,7 @@ import type {
 } from "../../app/pages/adhoc/sql-dashboard/types";
 import {
   getReportDashboard,
+  normalizeDashboardReportRecipients,
   type AccessCtx,
   type DashboardReportSubscription,
 } from "./dashboard-report-subscriptions";
@@ -34,6 +39,7 @@ type ReportSnapshot = {
   dashboardUrl: string;
   reportSettingsUrl: string;
   generatedAt: string;
+  panelIds: string[];
 };
 
 const DATE_FILTER_TYPES: ReadonlySet<FilterType> = new Set([
@@ -49,23 +55,21 @@ const DASHBOARD_REPORT_CID = "dashboard-report-snapshot";
 const LOCAL_SCREENSHOT_TIMEOUT_MS = 90_000;
 const SERVERLESS_SCREENSHOT_TIMEOUT_MS = 90_000;
 const SERVERLESS_SECOND_READY_TIMEOUT_MS = 45_000;
-// Keep enough room under Netlify's 300s background-function limit for the
-// bounded browser-close/profile-cleanup steps after each failed attempt and
-// for the final email send. The three attempts total 225s; cleanup can spend
-// up to 60s, leaving a small delivery buffer.
-const SERVERLESS_FULL_ATTEMPT_TIMEOUT_MS = 110_000;
-const SERVERLESS_LIGHTWEIGHT_ATTEMPT_TIMEOUT_MS = 70_000;
+// Reserve 90s under Netlify's 300s background-function limit for bounded
+// browser cleanup plus delivery to the capped recipient list.
+const SERVERLESS_CHUNKED_ATTEMPT_TIMEOUT_MS = 210_000;
 const BROWSER_CLEANUP_TIMEOUT_MS = 10_000;
 const SCREENSHOT_VIEWPORT_PADDING = 64;
+const MAX_DASHBOARD_REPORT_CHUNKS = 10;
+const MAX_DASHBOARD_REPORT_ATTACHMENT_BYTES = 14 * 1024 * 1024;
 
 type DashboardScreenshotAttempt = {
-  label: "full" | "full-lightweight" | "limited";
+  label: "chunked";
   viewport: { width: number; height: number };
   captureScale?: number;
   readyTimeout?: number;
   secondReadyTimeout?: number;
   totalTimeout?: number;
-  reportPanelLimit?: number;
 };
 
 type LaunchedScreenshotBrowser = {
@@ -209,6 +213,7 @@ async function collectReportSnapshot(
       reportSettings: true,
     }),
     generatedAt: new Date().toISOString(),
+    panelIds: listReportablePanelIds(config.panels),
   };
 }
 
@@ -351,6 +356,37 @@ function secondReadyTimeoutMs(): number {
     : screenshotTimeoutMs();
 }
 
+function boundedStageTimeout(capMs: number, deadlineAt?: number): number {
+  if (!deadlineAt) return capMs;
+  const remainingMs = deadlineAt - Date.now();
+  if (remainingMs <= 0) throw new Error("capture deadline exhausted");
+  return Math.max(1, Math.min(capMs, remainingMs));
+}
+
+async function runWithinCaptureDeadline<T>(
+  operation: () => Promise<T>,
+  deadlineAt?: number,
+): Promise<T> {
+  if (!deadlineAt) return operation();
+  const timeoutMs = deadlineAt - Date.now();
+  if (timeoutMs <= 0) throw new Error("capture deadline exhausted");
+
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      operation(),
+      new Promise<never>((_, reject) => {
+        timeout = setTimeout(
+          () => reject(new Error("capture deadline exhausted")),
+          timeoutMs,
+        );
+      }),
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
 function positiveIntEnv(name: string): number | null {
   const raw = process.env[name]?.trim();
   if (!raw) return null;
@@ -392,12 +428,6 @@ async function waitForDashboardReportReady(
         };
       })()`)
       .catch(() => null);
-    if (detail?.ready === "true") {
-      console.warn(
-        "[dashboard-report] Dashboard surface stayed partially loaded; capturing the available panels.",
-      );
-      return false;
-    }
     const message = detail
       ? `${err?.message ?? String(err)}; dashboard state: ${JSON.stringify(detail)}`
       : `${err?.message ?? String(err)}; dashboard page was not inspectable`;
@@ -405,6 +435,34 @@ async function waitForDashboardReportReady(
   }
 }
 
+async function assertDashboardReportPanelWindow(
+  page: any,
+  expectedPanelIds: string[],
+): Promise<void> {
+  const rawPanelIds = await page.evaluate(`(() =>
+    document
+      .querySelector("[data-dashboard-report-capture]")
+      ?.getAttribute("data-dashboard-report-panel-ids") ?? null
+  )()`);
+  let actualPanelIds: unknown;
+  try {
+    actualPanelIds =
+      typeof rawPanelIds === "string" ? JSON.parse(rawPanelIds) : null;
+  } catch {
+    actualPanelIds = null;
+  }
+  if (
+    !Array.isArray(actualPanelIds) ||
+    actualPanelIds.some((panelId) => typeof panelId !== "string") ||
+    actualPanelIds.length !== expectedPanelIds.length ||
+    actualPanelIds.some((panelId, index) => panelId !== expectedPanelIds[index])
+  ) {
+    throw new Error(
+      `report chunk panel mismatch; expected=${JSON.stringify(expectedPanelIds)} actual=${JSON.stringify(actualPanelIds)}`,
+    );
+  }
+}
+
 async function scrollDashboardForLazyRendering(page: any): Promise<void> {
   await page.evaluate(`(async () => {
     const wait = (ms) =>
@@ -483,6 +541,15 @@ const DIAGNOSTICS_PROBE_TIMEOUT_MS = 2_000;
 const DIAGNOSTICS_MAX_LENGTH = 700;
 const DIAGNOSTICS_COLLECTOR_LIMIT = 5;
 
+// netlify.toml's memory = "2gb" is plan-gated and can be silently ignored, so
+// capture the actual lambda memory ceiling alongside current RSS.
+function memoryDiagnostics(): string {
+  const lambdaMemoryMb =
+    process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE ?? "unknown";
+  const rssMb = Math.round(process.memoryUsage().rss / 1024 / 1024);
+  return `lambdaMemoryMb=${lambdaMemoryMb} rssMb=${rssMb}`;
+}
+
 // Best-effort page inspection used when the report surface never becomes
 // visible, so failures carry enough state to tell wrong-page/wedged-renderer/
 // auth-bounce apart. Must never throw and must stay bounded even if the page
@@ -492,6 +559,7 @@ async function collectPageDiagnostics(
   consoleErrors: string[],
   failedRequests: string[],
 ): Promise<string> {
+  const memory = memoryDiagnostics();
   try {
     let responsive = true;
     let probeTimeout: ReturnType<typeof setTimeout> | undefined;
@@ -512,7 +580,7 @@ async function collectPageDiagnostics(
     }
 
     if (!responsive) {
-      return `page unresponsive (renderer hung or crashed); consoleErrors=${JSON.stringify(
+      return `${memory} page unresponsive (renderer hung or crashed); consoleErrors=${JSON.stringify(
         consoleErrors,
       )} failedRequests=${JSON.stringify(failedRequests)}`.slice(
         0,
@@ -557,7 +625,7 @@ async function collectPageDiagnostics(
       if (detailsTimeout) clearTimeout(detailsTimeout);
     }
 
-    return `page state: ${JSON.stringify({
+    return `${memory} page state: ${JSON.stringify({
       url,
       title,
       bodyText,
@@ -565,88 +633,85 @@ async function collectPageDiagnostics(
       failedRequests,
     })}`.slice(0, DIAGNOSTICS_MAX_LENGTH);
   } catch {
-    return "diagnostics unavailable";
+    return `${memory} diagnostics unavailable`;
   }
 }
 
-async function captureDashboardPng(
+function reportChunkOffsets(panelCount: number): number[] {
+  if (panelCount === 0) return [0];
+  return Array.from(
+    { length: Math.ceil(panelCount / REPORT_PANEL_CHUNK_SIZE) },
+    (_, index) => index * REPORT_PANEL_CHUNK_SIZE,
+  );
+}
+
+function screenshotUrlForChunk(
   sub: DashboardReportSubscription,
   snapshot: ReportSnapshot,
-  attempt: DashboardScreenshotAttempt,
-): Promise<Buffer> {
+  offset: number,
+): { token: string; url: string } {
   const targetPath = buildDashboardPath(
     snapshot.dashboardId,
     snapshot.filters,
-    {
-      reportScreenshot: true,
-    },
+    { reportScreenshot: true },
+  );
+  const targetUrl = new URL(targetPath, "https://agent-native.invalid/");
+  targetUrl.searchParams.set("reportPanelOffset", String(offset));
+  targetUrl.searchParams.set(
+    "reportPanelLimit",
+    String(REPORT_PANEL_CHUNK_SIZE),
   );
+  const signedTargetPath = `${targetUrl.pathname}${targetUrl.search}`;
   const token = signEmbedSessionToken({
     ownerEmail: sub.ownerEmail,
     orgId: sub.orgId,
-    targetPath,
+    targetPath: signedTargetPath,
     scope: `dashboard-report-screenshot:${sub.id}`,
     ttlSeconds: 5 * 60,
   });
-  const screenshotUrl = new URL(targetPath, `${dashboardBaseUrl()}/`);
-  screenshotUrl.searchParams.set(EMBED_MODE_QUERY_PARAM, "1");
-  screenshotUrl.searchParams.set(EMBED_TOKEN_QUERY_PARAM, token);
-  if (attempt.reportPanelLimit) {
-    screenshotUrl.searchParams.set(
-      "reportPanelLimit",
-      String(attempt.reportPanelLimit),
-    );
-  }
+  const url = new URL(signedTargetPath, `${dashboardBaseUrl()}/`);
+  url.searchParams.set(EMBED_MODE_QUERY_PARAM, "1");
+  url.searchParams.set(EMBED_TOKEN_QUERY_PARAM, token);
+  return { token, url: url.toString() };
+}
 
-  let browser: any;
-  let cleanup = async () => {};
-  let newPage = async (): Promise<any> => {
-    throw new Error("Screenshot browser did not provide a page factory");
-  };
-  let launchPromise: Promise<LaunchedScreenshotBrowser> | undefined;
-  let launchTimeout: ReturnType<typeof setTimeout> | undefined;
-  let captureStage = "launching the screenshot browser";
-  let attemptTimedOut = false;
-  let lastDiagnostics: string | null = null;
-  const attemptTimeout = attempt.totalTimeout
-    ? setTimeout(() => {
-        attemptTimedOut = true;
-        if (browser) void browser.close().catch(() => {});
-      }, attempt.totalTimeout)
-    : null;
+async function captureDashboardChunk(
+  page: any,
+  attempt: DashboardScreenshotAttempt,
+  token: string,
+  screenshotUrl: string,
+  expectedPanelIds: string[],
+  deadlineAt?: number,
+): Promise<Buffer> {
+  const timeout = screenshotTimeoutMs();
+  let captureStage = "pre-seeding the embed session";
+  const consoleErrors: string[] = [];
+  const failedRequests: string[] = [];
+  page.on("console", (msg: any) => {
+    if (
+      msg.type() !== "error" ||
+      consoleErrors.length >= DIAGNOSTICS_COLLECTOR_LIMIT
+    )
+      return;
+    consoleErrors.push(msg.text().slice(0, 160));
+  });
+  page.on("requestfailed", (req: any) => {
+    if (failedRequests.length >= DIAGNOSTICS_COLLECTOR_LIMIT) return;
+    failedRequests.push(
+      `${req.method()} ${req.url().slice(0, 120)}: ${req.failure()?.errorText ?? "failed"}`,
+    );
+  });
+  page.on("response", (res: any) => {
+    if (
+      res.status() < 400 ||
+      failedRequests.length >= DIAGNOSTICS_COLLECTOR_LIMIT
+    )
+      return;
+    failedRequests.push(
+      `${res.request().method()} ${res.url().slice(0, 120)}: HTTP ${res.status()}`,
+    );
+  });
   try {
-    launchPromise = launchScreenshotBrowser(attempt.viewport);
-    const launched = attempt.totalTimeout
-      ? await Promise.race([
-          launchPromise,
-          new Promise<never>((_, reject) => {
-            launchTimeout = setTimeout(() => {
-              attemptTimedOut = true;
-              reject(
-                new Error(
-                  `${attempt.label} browser launch exceeded ${attempt.totalTimeout}ms`,
-                ),
-              );
-            }, attempt.totalTimeout);
-          }),
-        ])
-      : await launchPromise;
-    browser = launched.browser;
-    cleanup = launched.cleanup;
-    newPage = launched.newPage;
-    if (attemptTimedOut) {
-      throw new Error("Screenshot browser launch exceeded attempt timeout");
-    }
-
-    const timeout = screenshotTimeoutMs();
-    const page = await newPage();
-
-    // Belt-and-braces auth: the query token authenticates only after the
-    // client-side bootstrap harvests it from the URL, which gives the
-    // stripped-down serverless browser several ways to end up session-less.
-    // Seeding the same signed token as a cookie authenticates every request
-    // server-side with no client cooperation. Never abort the capture over
-    // this — the query token path still exists.
     try {
       await page.context().addCookies([
         {
@@ -661,81 +726,170 @@ async function captureDashboardPng(
         errorMessage(err),
       );
     }
-
-    // Bounded diagnostics collectors so a failed wait carries evidence of
-    // wrong-page/wedged-renderer/auth-bounce instead of a bare timeout.
-    const consoleErrors: string[] = [];
-    page.on("console", (msg: any) => {
-      if (msg.type() !== "error") return;
-      if (consoleErrors.length >= DIAGNOSTICS_COLLECTOR_LIMIT) return;
-      consoleErrors.push(msg.text().slice(0, 160));
-    });
-    const failedRequests: string[] = [];
-    page.on("requestfailed", (req: any) => {
-      if (failedRequests.length >= DIAGNOSTICS_COLLECTOR_LIMIT) return;
-      failedRequests.push(
-        `${req.method()} ${req.url().slice(0, 120)}: ${req.failure()?.errorText ?? "failed"}`,
-      );
-    });
-    page.on("response", (res: any) => {
-      if (res.status() < 400) return;
-      if (failedRequests.length >= DIAGNOSTICS_COLLECTOR_LIMIT) return;
-      failedRequests.push(
-        `${res.request().method()} ${res.url().slice(0, 120)}: HTTP ${res.status()}`,
-      );
-    });
-
-    page.setDefaultTimeout(timeout);
+    page.setDefaultTimeout(boundedStageTimeout(timeout, deadlineAt));
     await page.emulateMedia({ media: "screen", colorScheme: "light" });
-    await page.addInitScript(() => {
-      window.localStorage.setItem("theme", "light");
-    });
-    await page.goto(screenshotUrl.toString(), {
+    await page.addInitScript(() =>
+      window.localStorage.setItem("theme", "light"),
+    );
+    captureStage = "navigating to the report chunk";
+    await page.goto(screenshotUrl, {
       waitUntil: "domcontentloaded",
-      timeout,
+      timeout: boundedStageTimeout(timeout, deadlineAt),
     });
-
-    captureStage = "waiting for the report surface";
     const capture = page.locator("[data-dashboard-report-capture]");
+    captureStage = "waiting for the report chunk surface";
     try {
-      await capture.waitFor({ state: "visible", timeout });
+      await capture.waitFor({
+        state: "visible",
+        timeout: boundedStageTimeout(timeout, deadlineAt),
+      });
     } catch (err) {
-      lastDiagnostics = errorMessage(
+      const diagnostics = errorMessage(
         await collectPageDiagnostics(page, consoleErrors, failedRequests),
       );
-      throw new Error(`${errorMessage(err)}; ${lastDiagnostics}`);
+      throw new Error(`${errorMessage(err)}; ${diagnostics}`);
     }
-    captureStage = "waiting for dashboard queries";
-    await waitForDashboardReportReady(page, attempt.readyTimeout ?? timeout);
-    captureStage = "rendering lazy dashboard panels";
+    captureStage = "waiting for report chunk queries";
+    await waitForDashboardReportReady(
+      page,
+      boundedStageTimeout(attempt.readyTimeout ?? timeout, deadlineAt),
+    );
+    captureStage = "validating the report chunk panels";
+    await assertDashboardReportPanelWindow(page, expectedPanelIds);
+    captureStage = "rendering lazy report chunk panels";
     await scrollDashboardForLazyRendering(page);
-    captureStage = "waiting for lazy dashboard panels";
+    captureStage = "waiting for lazy report chunk panels";
     await waitForDashboardReportReady(
       page,
-      attempt.secondReadyTimeout ?? secondReadyTimeoutMs(),
+      boundedStageTimeout(
+        attempt.secondReadyTimeout ?? secondReadyTimeoutMs(),
+        deadlineAt,
+      ),
     );
-
-    captureStage = "sizing the dashboard capture";
+    captureStage = "revalidating the report chunk panels";
+    await assertDashboardReportPanelWindow(page, expectedPanelIds);
+    captureStage = "sizing the report chunk";
     await fitViewportWidthToDashboardCapture(page, capture, attempt.viewport);
     await scaleDashboardCapture(page, attempt.captureScale);
     await capture.scrollIntoViewIfNeeded();
-    captureStage = "rasterizing the dashboard PNG";
+    captureStage = "rasterizing the report chunk PNG";
+    page.setDefaultTimeout(boundedStageTimeout(timeout, deadlineAt));
     const image = await capture.screenshot({
       type: "png",
       animations: "disabled",
     });
-    if (!image?.length) {
-      throw new Error("Dashboard screenshot was empty");
-    }
+    if (!image?.length) throw new Error("Dashboard screenshot was empty");
     return Buffer.from(image);
+  } catch (err) {
+    throw new Error(`${captureStage}: ${errorMessage(err)}`);
+  }
+}
+
+async function captureDashboardPngChunks(
+  sub: DashboardReportSubscription,
+  snapshot: ReportSnapshot,
+): Promise<Buffer[]> {
+  const offsets = reportChunkOffsets(snapshot.panelIds.length);
+  if (offsets.length > MAX_DASHBOARD_REPORT_CHUNKS) {
+    throw new Error(
+      `complete dashboard requires ${offsets.length} image chunks; email delivery supports at most ${MAX_DASHBOARD_REPORT_CHUNKS}`,
+    );
+  }
+  const serverless = isServerlessBrowserRuntime();
+  const attempt: DashboardScreenshotAttempt = {
+    label: "chunked",
+    viewport: { width: 1200, height: 1400 },
+    captureScale: 0.7,
+    ...(serverless
+      ? {
+          readyTimeout: 35_000,
+          secondReadyTimeout: 15_000,
+          totalTimeout: SERVERLESS_CHUNKED_ATTEMPT_TIMEOUT_MS,
+        }
+      : {}),
+  };
+  let browser: any;
+  let cleanup = async () => {};
+  let launchPromise: Promise<LaunchedScreenshotBrowser> | undefined;
+  let launchTimeout: ReturnType<typeof setTimeout> | undefined;
+  let attemptTimedOut = false;
+  const deadlineAt = attempt.totalTimeout
+    ? Date.now() + attempt.totalTimeout
+    : undefined;
+  const attemptTimeout = attempt.totalTimeout
+    ? setTimeout(() => {
+        attemptTimedOut = true;
+        if (browser) void browser.close().catch(() => {});
+      }, attempt.totalTimeout)
+    : null;
+  try {
+    launchPromise = launchScreenshotBrowser(attempt.viewport);
+    const launched = attempt.totalTimeout
+      ? await Promise.race([
+          launchPromise,
+          new Promise<never>((_, reject) => {
+            launchTimeout = setTimeout(
+              () =>
+                reject(
+                  new Error(
+                    `${attempt.label} browser launch exceeded ${attempt.totalTimeout}ms`,
+                  ),
+                ),
+              attempt.totalTimeout,
+            );
+          }),
+        ])
+      : await launchPromise;
+    browser = launched.browser;
+    cleanup = launched.cleanup;
+    const images: Buffer[] = [];
+    let attachmentBytes = 0;
+    for (const offset of offsets) {
+      if (attemptTimedOut)
+        throw new Error(`capture exceeded ${attempt.totalTimeout}ms`);
+      const page = await runWithinCaptureDeadline(
+        () => launched.newPage(),
+        deadlineAt,
+      );
+      try {
+        const { token, url } = screenshotUrlForChunk(sub, snapshot, offset);
+        const expectedPanelIds = snapshot.panelIds.slice(
+          offset,
+          offset + REPORT_PANEL_CHUNK_SIZE,
+        );
+        const image = await runWithinCaptureDeadline(
+          () =>
+            captureDashboardChunk(
+              page,
+              attempt,
+              token,
+              url,
+              expectedPanelIds,
+              deadlineAt,
+            ),
+          deadlineAt,
+        );
+        attachmentBytes += image.length;
+        if (attachmentBytes > MAX_DASHBOARD_REPORT_ATTACHMENT_BYTES) {
+          throw new Error(
+            `complete dashboard images total ${attachmentBytes} bytes; email delivery supports at most ${MAX_DASHBOARD_REPORT_ATTACHMENT_BYTES} bytes`,
+          );
+        }
+        images.push(image);
+      } finally {
+        await runBoundedBrowserCleanup("Failed to close screenshot page", () =>
+          page.close(),
+        );
+      }
+    }
+    return images;
   } catch (err) {
     if (attemptTimedOut) {
       throw new Error(
-        `${attempt.label} capture exceeded ${attempt.totalTimeout}ms while ${captureStage}` +
-          (lastDiagnostics ? `; ${lastDiagnostics}` : ""),
+        `${memoryDiagnostics()} ${attempt.label} capture exceeded ${attempt.totalTimeout}ms: ${errorMessage(err)}`,
       );
     }
-    throw new Error(`${captureStage}: ${errorMessage(err)}`);
+    throw new Error(`${attempt.label}: ${errorMessage(err)}`);
   } finally {
     if (attemptTimeout) clearTimeout(attemptTimeout);
     if (launchTimeout) clearTimeout(launchTimeout);
@@ -751,9 +905,7 @@ async function captureDashboardPng(
             lateBrowser.cleanup,
           );
         },
-        () => {
-          // The launch rejection was already handled by the race above.
-        },
+        () => {},
       );
     }
     if (browser) {
@@ -773,91 +925,36 @@ function errorMessage(err: unknown): string {
   );
 }
 
-function storedAttemptError(message: string): string {
-  const normalized = message.replace(/\s+/g, " ").trim();
-  return normalized.length > 400 ? `${normalized.slice(0, 399)}…` : normalized;
-}
-
 async function captureDashboardPngWithFallback(
   sub: DashboardReportSubscription,
   snapshot: ReportSnapshot,
-  options?: { includeLimitedFallback?: boolean },
 ): Promise<{
-  png: Buffer | null;
-  mode: "full" | "full-lightweight" | "limited" | "none";
+  pngs: Buffer[] | null;
+  mode: "full" | "none";
   error?: string;
 }> {
-  const serverless = isServerlessBrowserRuntime();
-  const attempts: DashboardScreenshotAttempt[] = [
-    {
-      label: "full",
-      viewport: { width: 1440, height: 1800 },
-      captureScale: 0.85,
-      ...(serverless
-        ? {
-            readyTimeout: 45_000,
-            secondReadyTimeout: 25_000,
-            totalTimeout: SERVERLESS_FULL_ATTEMPT_TIMEOUT_MS,
-          }
-        : {}),
-    },
-    {
-      label: "full-lightweight",
-      viewport: { width: 1200, height: 1400 },
-      captureScale: 0.7,
-      ...(serverless
-        ? {
-            readyTimeout: 35_000,
-            secondReadyTimeout: 15_000,
-            totalTimeout: SERVERLESS_LIGHTWEIGHT_ATTEMPT_TIMEOUT_MS,
-          }
-        : {}),
-    },
-  ];
-  if (options?.includeLimitedFallback) {
-    // Only added on the final sweep after the 1-hour retry window, when the
-    // alternative is a no-image fallback email. All three serverless attempt
-    // totalTimeouts sum to 225s, leaving room for bounded cleanup and email
-    // delivery under the 300s Netlify background-function timeout.
-    attempts.push({
-      label: "limited",
-      viewport: { width: 1200, height: 1400 },
-      captureScale: 0.7,
-      reportPanelLimit: 8,
-      ...(serverless
-        ? {
-            readyTimeout: 25_000,
-            secondReadyTimeout: 10_000,
-            totalTimeout: 45_000,
-          }
-        : {}),
-    });
-  }
-  const errors: string[] = [];
-
-  for (const attempt of attempts) {
-    try {
-      const png = await captureDashboardPng(sub, snapshot, attempt);
-      return {
-        png,
-        mode: attempt.label,
-        ...(errors.length ? { error: errors.join(" | ") } : {}),
-      };
-    } catch (err) {
-      const attemptError = errorMessage(err);
-      errors.push(`${attempt.label}: ${storedAttemptError(attemptError)}`);
-      console.error(
-        `[dashboard-report] ${attempt.label} screenshot failed for subscription ${sub.id}:`,
-        attemptError,
+  try {
+    const pngs = await captureDashboardPngChunks(sub, snapshot);
+    if (isServerlessBrowserRuntime()) {
+      console.info(
+        `[dashboard-report] complete chunked capture succeeded: chunks=${pngs.length} ${memoryDiagnostics()}`,
       );
     }
+    return {
+      pngs,
+      mode: "full",
+    };
+  } catch (err) {
+    const rawError = errorMessage(err).replace(/\s+/g, " ").trim();
+    const error = rawError.includes("lambdaMemoryMb=")
+      ? rawError
+      : `${rawError}; ${memoryDiagnostics()}`;
+    console.error(
+      `[dashboard-report] complete chunked screenshot failed for subscription ${sub.id}:`,
+      error,
+    );
+    return { pngs: null, mode: "none", error };
   }
-
-  return {
-    png: null,
-    mode: "none",
-    ...(errors.length ? { error: errors.join(" | ") } : {}),
-  };
 }
 
 function reportDate(snapshot: ReportSnapshot): string {
@@ -872,7 +969,7 @@ function renderReportEmailHtml(
   snapshot: ReportSnapshot,
   options: {
     screenshotAttached: boolean;
-    screenshotMode: "full" | "full-lightweight" | "limited" | "none";
+    screenshotCount: number;
   },
 ): string {
   const title = escapeHtml(snapshot.title);
@@ -880,18 +977,18 @@ function renderReportEmailHtml(
   const reportSettingsUrl = escapeHtml(snapshot.reportSettingsUrl);
   const date = escapeHtml(reportDate(snapshot));
   const screenshotBlock = options.screenshotAttached
-    ? `<a href="${dashboardUrl}" style="display:block;text-decoration:none;">
-      <img src="cid:${DASHBOARD_REPORT_CID}" alt="${title}" width="100%" style="display:block;width:100%;max-width:1280px;height:auto;border:0;outline:0;border-radius:0;" />
-    </a>`
+    ? Array.from(
+        { length: options.screenshotCount },
+        (
+          _,
+          index,
+        ) => `<a href="${dashboardUrl}" style="display:block;text-decoration:none;">
+      <img src="cid:${DASHBOARD_REPORT_CID}-${index + 1}" alt="${title}${options.screenshotCount > 1 ? ` (part ${index + 1})` : ""}" width="100%" style="display:block;width:100%;max-width:1280px;height:auto;border:0;outline:0;border-radius:0;" />
+    </a>`,
+      ).join("\n")
     : `<div style="margin:18px 0;padding:14px 16px;border:1px solid #e5e7eb;border-radius:8px;background:#f9fafb;color:#374151;font-size:14px;line-height:1.5;">
       The dashboard image was unavailable for this run. Open the live dashboard to view the latest report.
     </div>`;
-  const limitedScreenshotNotice =
-    options.screenshotMode === "limited"
-      ? `<div style="margin:12px 0 0;padding:12px 14px;border:1px solid #f3c46b;border-radius:8px;background:#fff8e6;color:#6b4f14;font-size:13px;line-height:1.45;">
-      This is a limited fallback image and may omit some dashboard panels. <a href="${dashboardUrl}" style="color:#2563eb;text-decoration:none;">Open the full dashboard</a> to see every panel.
-    </div>`
-      : "";
 
   return `<!doctype html>
 <html>
@@ -900,7 +997,6 @@ function renderReportEmailHtml(
       Here's your report of <a href="${dashboardUrl}" style="color:#2563eb;text-decoration:none;">${title}</a> for ${date}
     </p>
     ${screenshotBlock}
-    ${limitedScreenshotNotice}
     <p style="margin:18px 0 0;color:#525866;font-size:13px;line-height:1.45;">
       <a href="${dashboardUrl}" style="color:#2563eb;text-decoration:none;">Open dashboard</a>
       <span style="color:#9ca3af;"> · </span>
@@ -914,7 +1010,6 @@ function renderReportText(
   snapshot: ReportSnapshot,
   options: {
     screenshotAttached: boolean;
-    screenshotMode: "full" | "full-lightweight" | "limited" | "none";
   },
 ): string {
   const lines = [
@@ -926,21 +1021,17 @@ function renderReportText(
   if (!options.screenshotAttached) {
     lines.push("Dashboard image unavailable for this run.");
   }
-  if (options.screenshotMode === "limited") {
-    lines.push(
-      `This is a limited fallback image and may omit some dashboard panels. Open the full dashboard: ${snapshot.dashboardUrl}`,
-    );
-  }
   return lines.join("\n");
 }
 
-function reportFilename(title: string): string {
+function reportFilename(title: string, part: number, total: number): string {
   const slug = title
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, "-")
     .replace(/^-|-$/g, "")
     .slice(0, 64);
-  return `${slug || "dashboard"}-report.png`;
+  const suffix = total > 1 ? `-part-${part}` : "";
+  return `${slug || "dashboard"}-report${suffix}.png`;
 }
 
 export async function sendDashboardReportSubscription(
@@ -948,71 +1039,70 @@ export async function sendDashboardReportSubscription(
   options: {
     requireScreenshot?: boolean;
     skipEmailWithoutScreenshot?: boolean;
-    allowLimitedFallback?: boolean;
   } = {},
 ): Promise<{
   dashboardUrl: string;
   recipientCount: number;
   screenshotAttached: boolean;
-  screenshotMode: "full" | "full-lightweight" | "limited" | "none";
+  screenshotMode: "full" | "none";
   screenshotError?: string;
   emailsSent: boolean;
 }> {
+  const recipients = normalizeDashboardReportRecipients(sub.recipients);
   const snapshot = await collectReportSnapshot(sub);
-  const capture = await captureDashboardPngWithFallback(sub, snapshot, {
-    includeLimitedFallback: options?.allowLimitedFallback,
-  });
-  if (!capture.png && options.requireScreenshot) {
+  const capture = await captureDashboardPngWithFallback(sub, snapshot);
+  if (!capture.pngs && options.requireScreenshot) {
     throw new Error(
       capture.error
         ? `Dashboard screenshot unavailable: ${capture.error}`
         : "Dashboard screenshot unavailable",
     );
   }
-  if (!capture.png && options.skipEmailWithoutScreenshot) {
+  if (!capture.pngs && options.skipEmailWithoutScreenshot) {
     return {
       dashboardUrl: snapshot.dashboardUrl,
-      recipientCount: sub.recipients.length,
+      recipientCount: recipients.length,
       screenshotAttached: false,
       screenshotMode: capture.mode,
       emailsSent: false,
       ...(capture.error ? { screenshotError: capture.error } : {}),
     };
   }
-  const screenshotAttached = Boolean(capture.png);
+  const screenshotAttached = Boolean(capture.pngs?.length);
   const html = renderReportEmailHtml(snapshot, {
     screenshotAttached,
-    screenshotMode: capture.mode,
+    screenshotCount: capture.pngs?.length ?? 0,
   });
   const text = renderReportText(snapshot, {
     screenshotAttached,
-    screenshotMode: capture.mode,
   });
   const subject = `Daily dashboard: ${snapshot.title}`;
 
-  for (const to of sub.recipients) {
+  for (const to of recipients) {
     await sendEmail({
       to,
       subject,
       html,
       text,
-      attachments: capture.png
-        ? [
-            {
-              filename: reportFilename(snapshot.title),
-              content: capture.png,
-              contentType: "image/png",
-              contentId: DASHBOARD_REPORT_CID,
-              disposition: "inline",
-            },
-          ]
+      attachments: capture.pngs
+        ? capture.pngs.map((png, index) => ({
+            filename: reportFilename(
+              snapshot.title,
+              index + 1,
+              capture.pngs!.length,
+            ),
+            content: png,
+            contentType: "image/png",
+            contentId: `${DASHBOARD_REPORT_CID}-${index + 1}`,
+            disposition: "inline",
+          }))
         : undefined,
     });
   }
 
   return {
     dashboardUrl: snapshot.dashboardUrl,
-    recipientCount: sub.recipients.length,
+    recipientCount: recipients.length,
     screenshotAttached,
     screenshotMode: capture.mode,
     emailsSent: true,