@polishd/next 0.2.3-dev.4 → 0.2.3-dev.6

package/dist/server/snapshots.js

@@ -19,11 +19,27 @@
  * optional dependencies, so a standard install needs no extra wiring. Every
  * failure degrades to a message, never a crash — the same contract as the
  * rest of the server layer.
+ *
+ * Alongside the full shots, each route call also pictures the Design tab's
+ * flagged values in place — a ringed crop of the element carrying a one-off
+ * type style, color, radius or off-grid padding (server/value-previews.ts) —
+ * stored beside the shots under the same disk-or-Blob rule, and listed in the
+ * snapshot as `previews` so hovering the value on the dashboard shows where
+ * it renders.
+ *
+ * Capture is chunked into one server call per route: begin → one
+ * `captureSnapshotRoute` per route → finish, with the in-flight state parked
+ * in the store between calls. A whole-site capture in a single request would
+ * have to outlive a serverless host's function time limit — which the package
+ * cannot raise on the host's behalf (`maxDuration` must be declared inline in
+ * the host's own page module), and which kills the function mid-shoot with no
+ * result at all. One route per request keeps every call short enough to fit.
  */
 import { isAbsolute, join } from "node:path";
-import { mkdir, mkdtemp, readFile, rm } from "node:fs/promises";
+import { copyFile, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { getMeta, setMeta, storeReady } from "./store";
+import { captureValuePreviews } from "./value-previews";
 const INDEX_KEY = "design_snapshots";
 /** Snapshots kept before the oldest is pruned (files and index entry both). */
 const MAX_SNAPSHOTS = 6;
@@ -32,6 +48,19 @@ export const MAX_SNAPSHOT_ROUTES = 12;
 /** The device/theme matrix every snapshot shoots. */
 const SNAPSHOT_DEVICES = ["phone", "desktop"];
 const SNAPSHOT_THEMES = ["light", "dark"];
+/**
+ * Where a flagged value is looked for, in order: the gallery's default view
+ * first, so most pictures match the shot the user is already looking at.
+ */
+const PREVIEW_RENDERINGS = [
+    { device: "desktop", theme: "light" },
+    { device: "desktop", theme: "dark" },
+    { device: "phone", theme: "light" },
+    { device: "phone", theme: "dark" },
+];
+/** Values pictured per route, and the time the pass may add to its call. */
+const MAX_PREVIEWS_PER_ROUTE = 16;
+const PREVIEW_BUDGET_MS = 15_000;
 /**
  * True when shots should upload to Vercel Blob rather than land on disk.
  * `BLOB_READ_WRITE_TOKEN` is injected automatically once a Blob store is
@@ -68,26 +97,32 @@ export async function listSnapshots() {
     return (await loadIndex()).snapshots;
 }
 /**
- * Read one shot's image as a data URL, or null when it doesn't exist. The
- * filename is only accepted when the index lists it for that snapshot, so a
- * caller can never read outside a snapshot directory — and Blob-stored shots
- * are only ever fetched from the URL the index recorded at capture time.
+ * Read one shot's — or one value preview's — image as a data URL, or null
+ * when it doesn't exist. The filename is only accepted when the index lists it
+ * for that snapshot, so a caller can never read outside a snapshot directory —
+ * and Blob-stored images are only ever fetched from the URL the index recorded
+ * at capture time.
  */
 export async function readSnapshotImage(snapshotId, file) {
     const index = await loadIndex();
     const snapshot = index.snapshots.find((s) => s.id === snapshotId);
-    const shot = snapshot?.shots.find((s) => s.file === file && s.file.length > 0);
-    if (!snapshot || !shot)
+    if (!snapshot || file.length === 0)
+        return null;
+    const shot = snapshot.shots.find((s) => s.file === file);
+    const preview = shot ? undefined : snapshot.previews?.find((p) => p.file === file);
+    const image = shot ?? preview;
+    if (!image)
         return null;
     try {
-        if (shot.url) {
-            const res = await fetch(shot.url);
+        if (image.url) {
+            const res = await fetch(image.url);
             if (!res.ok)
                 return null;
             const bytes = Buffer.from(await res.arrayBuffer());
             return `data:image/png;base64,${bytes.toString("base64")}`;
         }
-        const bytes = await readFile(join(snapshotsRoot(), snapshot.id, "shots", shot.file));
+        const dir = shot ? "shots" : "previews";
+        const bytes = await readFile(join(snapshotsRoot(), snapshot.id, dir, image.file));
         return `data:image/png;base64,${bytes.toString("base64")}`;
     }
     catch {
@@ -96,43 +131,129 @@ export async function readSnapshotImage(snapshotId, file) {
 }
 // ── Storage ──────────────────────────────────────────────────────────────────
 /**
- * Upload every captured PNG to Vercel Blob and annotate each shot with its
- * URL. The pathnames get a random suffix: public-but-unguessable is the only
- * access model Blob offers, and the dashboard still serves images through the
- * auth-gated action rather than handing these URLs to the browser. Returns an
- * error message, or null when every image landed; on failure the ones already
- * uploaded are deleted, so a half-stored snapshot never survives.
+ * Move one route's staged PNGs to their real home — Vercel Blob when a token
+ * is present, the snapshots directory otherwise — under a per-route filename
+ * prefix: allpages slugs are only unique within a single run, and each route
+ * is its own run now. Blob pathnames get a random suffix on top —
+ * public-but-unguessable is the only access model Blob offers, and the
+ * dashboard still serves images through the auth-gated action rather than
+ * handing these URLs to the browser. On a failed upload the pieces already
+ * uploaded are deleted, so a half-stored route never survives.
  */
-async function uploadShots(id, outDir, shots) {
-    let blob;
+async function storeRouteShots(id, routeIndex, stageDir, captured) {
+    const prefix = `r${routeIndex}-`;
+    const shots = [];
+    const toShot = (s, file, url) => ({
+        route: s.route.path,
+        device: s.device.name,
+        theme: s.theme,
+        file,
+        ...(url ? { url } : {}),
+        ...(s.skipped ? { skipped: s.skipped } : {}),
+    });
+    if (!blobConfigured()) {
+        const shotsDir = join(snapshotsRoot(), id, "shots");
+        await mkdir(shotsDir, { recursive: true });
+        for (const s of captured) {
+            if (!s.file) {
+                shots.push(toShot(s, ""));
+                continue;
+            }
+            await copyFile(join(stageDir, "shots", s.file), join(shotsDir, prefix + s.file));
+            shots.push(toShot(s, prefix + s.file));
+        }
+        return { shots };
+    }
+    const blob = await loadBlobSdk();
+    if ("message" in blob)
+        return blob;
+    const uploaded = [];
+    try {
+        for (const s of captured) {
+            if (!s.file) {
+                shots.push(toShot(s, ""));
+                continue;
+            }
+            const bytes = await readFile(join(stageDir, "shots", s.file));
+            const { url } = await blob.put(`polishd/snapshots/${id}/${prefix}${s.file}`, bytes, {
+                access: "public",
+                contentType: "image/png",
+                addRandomSuffix: true,
+            });
+            uploaded.push(url);
+            shots.push(toShot(s, prefix + s.file, url));
+        }
+        return { shots };
+    }
+    catch (err) {
+        if (uploaded.length > 0)
+            await blob.del(uploaded).catch(() => { });
+        return {
+            message: `Couldn't upload screenshots to Vercel Blob: ${err instanceof Error ? err.message : "unknown error"}`,
+        };
+    }
+}
+/** The Blob SDK, or why it couldn't load. */
+async function loadBlobSdk() {
     try {
-        blob = await import("@vercel/blob");
+        return await import("@vercel/blob");
     }
     catch {
-        return ("Blob storage is configured (BLOB_READ_WRITE_TOKEN is set) but @vercel/blob " +
-            "isn't installed. It ships as an optional dependency of @polishd/next — " +
-            "reinstall without `--omit=optional`.");
+        return {
+            message: "Blob storage is configured (BLOB_READ_WRITE_TOKEN is set) but @vercel/blob " +
+                "isn't installed. It ships as an optional dependency of @polishd/next — " +
+                "reinstall without `--omit=optional`.",
+        };
     }
+}
+/**
+ * Store one route's value previews next to its shots — the snapshot's
+ * `previews/` directory, or Blob under the same rules as the shots. Names are
+ * `v-r<route>-<n>-<device>-<theme>.png`, unique within the snapshot and never
+ * mistakable for a shot's. All or nothing, like the shots: a failed upload
+ * deletes the pieces already sent.
+ */
+async function storeRoutePreviews(id, routeIndex, route, crops) {
+    const named = crops.map((c, n) => ({
+        ...c,
+        file: `v-r${routeIndex}-${n}-${c.device}-${c.theme}.png`,
+    }));
+    const toPreview = (c, url) => ({
+        key: c.key,
+        route,
+        device: c.device,
+        theme: c.theme,
+        file: c.file,
+        ...(url ? { url } : {}),
+    });
+    if (!blobConfigured()) {
+        const dir = join(snapshotsRoot(), id, "previews");
+        await mkdir(dir, { recursive: true });
+        for (const c of named)
+            await writeFile(join(dir, c.file), c.bytes);
+        return named.map((c) => toPreview(c));
+    }
+    const blob = await loadBlobSdk();
+    if ("message" in blob)
+        return [];
     const uploaded = [];
     try {
-        for (const shot of shots) {
-            if (!shot.file)
-                continue;
-            const bytes = await readFile(join(outDir, "shots", shot.file));
-            const { url } = await blob.put(`polishd/snapshots/${id}/${shot.file}`, bytes, {
+        const previews = [];
+        for (const c of named) {
+            const { url } = await blob.put(`polishd/snapshots/${id}/previews/${c.file}`, c.bytes, {
                 access: "public",
                 contentType: "image/png",
                 addRandomSuffix: true,
             });
-            shot.url = url;
             uploaded.push(url);
+            previews.push(toPreview(c, url));
         }
-        return null;
+        return previews;
     }
-    catch (err) {
+    catch {
         if (uploaded.length > 0)
             await blob.del(uploaded).catch(() => { });
-        return `Couldn't upload screenshots to Vercel Blob: ${err instanceof Error ? err.message : "unknown error"}`;
+        return [];
     }
 }
 /**
@@ -142,7 +263,7 @@ async function uploadShots(id, outDir, shots) {
  * blob costs cents, a prune that crashed the capture would cost the feature.
  */
 async function deleteSnapshotImages(snapshot) {
-    const urls = snapshot.shots.flatMap((s) => (s.url ? [s.url] : []));
+    const urls = [...snapshot.shots, ...(snapshot.previews ?? [])].flatMap((s) => s.url ? [s.url] : []);
     if (urls.length > 0) {
         try {
             const { del } = await import("@vercel/blob");
@@ -154,6 +275,251 @@ async function deleteSnapshotImages(snapshot) {
     }
     await rm(join(snapshotsRoot(), snapshot.id), { recursive: true, force: true }).catch(() => { });
 }
+const PENDING_KEY = "design_snapshot_pending";
+async function loadPending() {
+    const raw = await getMeta(PENDING_KEY);
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed?.v === 1 && typeof parsed.id === "string") {
+            // Records parked by a version without value previews.
+            parsed.targets ??= [];
+            parsed.previews ??= [];
+            parsed.previewMisses ??= [];
+            return parsed;
+        }
+    }
+    catch {
+        // A corrupt pending record is simply abandoned.
+    }
+    return null;
+}
+/** Persist the in-flight capture; null clears it. */
+async function savePending(pending) {
+    return setMeta(PENDING_KEY, pending ? JSON.stringify(pending) : "");
+}
+/**
+ * Start a capture: run the environment preflight, sweep any unfinished
+ * predecessor's images, and park the plan in the store. The returned routes
+ * are what the caller should then feed to `captureSnapshotRoute`, one call
+ * each, before `finishSnapshot` records the run.
+ */
+export async function beginSnapshot(input) {
+    if (!(await storeReady())) {
+        return {
+            ok: false,
+            message: "The analytics store isn't writable here, so a snapshot couldn't be recorded. " +
+                "Run locally or configure a database — see DATABASE.md.",
+        };
+    }
+    // The same preflight the dashboard runs before enabling the capture button.
+    // Actions are reachable without the dashboard ever rendering, so a doomed
+    // environment must fail here too — with the diagnosis, not a minute of
+    // capture ending in an EROFS.
+    const issue = await snapshotCaptureIssue();
+    if (issue)
+        return { ok: false, message: issue };
+    const routes = input.routes.slice(0, MAX_SNAPSHOT_ROUTES);
+    if (routes.length === 0)
+        return { ok: false, message: "No routes to capture." };
+    // A predecessor that never finished (tab closed mid-run) left images
+    // behind; sweep them before its record is overwritten.
+    const stale = await loadPending();
+    if (stale)
+        await deleteSnapshotImages(stale);
+    const pending = {
+        v: 1,
+        id: Date.now().toString(36),
+        origin: input.origin,
+        fingerprint: input.fingerprint,
+        startedAt: Date.now(),
+        routes,
+        done: [],
+        shots: [],
+        authWalled: [],
+        noDarkMode: true,
+        targets: input.targets ?? [],
+        previews: [],
+        previewMisses: [],
+    };
+    if (!(await savePending(pending))) {
+        return { ok: false, message: "The store refused to record the capture in progress." };
+    }
+    return { ok: true, id: pending.id, routes };
+}
+/**
+ * Shoot one route of the capture `beginSnapshot` started — both devices, both
+ * themes — store its images, and append the results to the pending record.
+ * Bounded work per call by design: this is the request that has to fit inside
+ * a serverless host's function time limit.
+ */
+export async function captureSnapshotRoute(id, route) {
+    const pending = await loadPending();
+    if (!pending || pending.id !== id) {
+        return {
+            ok: false,
+            message: "This capture is no longer in progress — start a new one.",
+        };
+    }
+    if (!pending.routes.includes(route)) {
+        return { ok: false, message: `${route} isn't part of this capture.` };
+    }
+    if (pending.done.includes(route)) {
+        // A retry after a lost response — the shots are already recorded.
+        return { ok: true, shots: pending.shots.filter((s) => s.route === route) };
+    }
+    let run;
+    try {
+        ({ allpages: run } = await import("allpages"));
+    }
+    catch (err) {
+        return {
+            ok: false,
+            message: `The allpages screenshot engine failed to load: ${err instanceof Error ? err.message : "unknown error"}`,
+        };
+    }
+    const launched = await launchBrowser();
+    if ("message" in launched)
+        return { ok: false, message: launched.message };
+    // Every route stages into its own temp directory — the one location
+    // serverless hosts keep writable — and the files only exist for the moments
+    // between capture and `storeRouteShots` moving them home.
+    let stageDir;
+    try {
+        stageDir = await mkdtemp(join(tmpdir(), "polishd-snapshot-"));
+    }
+    catch (err) {
+        await launched.browser.close().catch(() => { });
+        return {
+            ok: false,
+            message: `Couldn't create the snapshot staging directory (${err instanceof Error ? err.message : "unknown error"}) — is the filesystem writable?`,
+        };
+    }
+    try {
+        const result = await run({
+            url: pending.origin,
+            routes: [route],
+            outDir: stageDir,
+            devices: [...SNAPSHOT_DEVICES],
+            themes: [...SNAPSHOT_THEMES],
+            // The dashboard composes its own grid; the stitched contact sheet would
+            // only duplicate every image on disk.
+            skipSheet: true,
+            browser: launched.browser,
+        });
+        const stored = await storeRouteShots(id, pending.routes.indexOf(route), stageDir, result.shots);
+        if ("message" in stored)
+            return { ok: false, message: stored.message };
+        const pictured = await pictureRouteValues(launched.browser, pending, route, stored.shots);
+        pending.done.push(route);
+        pending.shots.push(...stored.shots);
+        pending.previews.push(...pictured.previews);
+        pending.previewMisses.push(...pictured.missed);
+        for (const walled of result.authWalled) {
+            if (!pending.authWalled.includes(walled))
+                pending.authWalled.push(walled);
+        }
+        // A route that produced no images says nothing about dark mode.
+        if (stored.shots.some((s) => s.file)) {
+            pending.noDarkMode = pending.noDarkMode && result.noDarkMode;
+        }
+        if (!(await savePending(pending))) {
+            await deleteSnapshotImages({ id, shots: stored.shots, previews: pictured.previews });
+            return { ok: false, message: "The route was shot but the store refused to record it." };
+        }
+        return { ok: true, shots: stored.shots };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            message: `Screenshot capture failed: ${err instanceof Error ? err.message : "unknown error"}`,
+        };
+    }
+    finally {
+        await launched.browser.close().catch(() => { });
+        await rm(stageDir, { recursive: true, force: true }).catch(() => { });
+    }
+}
+/**
+ * Picture the capture's flagged values that were measured on `route` and
+ * aren't pictured yet, in the renderings this route actually produced shots
+ * for (an auth-walled or failed route has none, so it's skipped). Never fails
+ * the route: any error leaves the route with its full shots and no previews.
+ */
+async function pictureRouteValues(browser, pending, route, shots) {
+    const none = { previews: [], missed: [] };
+    const pictured = new Set(pending.previews.map((p) => p.key));
+    const targets = pending.targets
+        .filter((t) => t.pages.includes(route) && !pictured.has(t.key))
+        .slice(0, MAX_PREVIEWS_PER_ROUTE);
+    const renderings = PREVIEW_RENDERINGS.filter((r) => shots.some((s) => s.file && s.device === r.device && s.theme === r.theme));
+    if (targets.length === 0 || renderings.length === 0)
+        return none;
+    try {
+        const result = await captureValuePreviews(browser, pending.origin, route, targets, renderings, PREVIEW_BUDGET_MS);
+        const previews = result.crops.length > 0
+            ? await storeRoutePreviews(pending.id, pending.routes.indexOf(route), route, result.crops)
+            : [];
+        return { previews, missed: result.missed };
+    }
+    catch {
+        return none;
+    }
+}
+/**
+ * Close out the capture: record the accumulated shots in the snapshot index
+ * and prune old snapshots past `MAX_SNAPSHOTS`, images included. Called once
+ * every route has been attempted — routes whose calls failed outright are
+ * simply absent from the snapshot.
+ */
+export async function finishSnapshot(id) {
+    const pending = await loadPending();
+    if (!pending || pending.id !== id) {
+        return {
+            ok: false,
+            message: "This capture is no longer in progress — start a new one.",
+        };
+    }
+    const snapshot = {
+        id: pending.id,
+        capturedAt: Date.now(),
+        origin: pending.origin,
+        fingerprint: pending.fingerprint,
+        shots: pending.shots,
+        authWalled: pending.authWalled,
+        noDarkMode: pending.noDarkMode,
+        previews: pending.previews,
+        // A value missed on one of its pages may have been pictured on another.
+        previewMisses: [...new Set(pending.previewMisses)].filter((key) => !pending.previews.some((p) => p.key === key)),
+    };
+    if (snapshot.shots.every((s) => !s.file)) {
+        await deleteSnapshotImages(snapshot);
+        await savePending(null);
+        return {
+            ok: false,
+            message: "Every page failed to capture — is the site reachable at " +
+                `${pending.origin} from its own server?`,
+        };
+    }
+    const index = await loadIndex();
+    index.snapshots.unshift(snapshot);
+    const pruned = index.snapshots.slice(MAX_SNAPSHOTS);
+    index.snapshots = index.snapshots.slice(0, MAX_SNAPSHOTS);
+    if (!(await setMeta(INDEX_KEY, JSON.stringify(index)))) {
+        await deleteSnapshotImages(snapshot);
+        await savePending(null);
+        return {
+            ok: false,
+            message: "The snapshot was shot but the store refused to record it.",
+        };
+    }
+    await savePending(null);
+    for (const old of pruned) {
+        await deleteSnapshotImages(old);
+    }
+    return { ok: true, snapshot };
+}
 /**
  * Launch a Chromium the way the allpages CLI does — the user's own Chrome or
  * Edge first, Playwright's downloaded Chromium next — but never auto-download
@@ -164,7 +530,15 @@ async function deleteSnapshotImages(snapshot) {
  * dependency so production needs no setup step.
  */
 async function launchBrowser() {
-    const { chromium } = await import("playwright-core");
+    let chromium;
+    try {
+        ({ chromium } = await import("playwright-core"));
+    }
+    catch (err) {
+        return {
+            message: `The browser driver (playwright-core) failed to load: ${err instanceof Error ? err.message : "unknown error"}`,
+        };
+    }
     const args = ["--force-color-profile=srgb", "--hide-scrollbars"];
     for (const channel of ["chrome", "msedge", undefined]) {
         try {
@@ -262,129 +636,4 @@ export async function snapshotCaptureIssue() {
     }
     return null;
 }
-/**
- * Shoot the given routes and record the run in the snapshot index. Old
- * snapshots past `MAX_SNAPSHOTS` are pruned, images included.
- */
-export async function captureSnapshot(input) {
-    if (!(await storeReady())) {
-        return {
-            ok: false,
-            message: "The analytics store isn't writable here, so a snapshot couldn't be recorded. " +
-                "Run locally or configure a database — see DATABASE.md.",
-        };
-    }
-    // The same preflight the dashboard runs before enabling the capture button.
-    // Actions are reachable without the dashboard ever rendering, so a doomed
-    // environment must fail here too — with the diagnosis, not a minute of
-    // capture ending in an EROFS.
-    const issue = await snapshotCaptureIssue();
-    if (issue)
-        return { ok: false, message: issue };
-    let run;
-    try {
-        ({ allpages: run } = await import("allpages"));
-    }
-    catch (err) {
-        return {
-            ok: false,
-            message: `The allpages screenshot engine failed to load: ${err instanceof Error ? err.message : "unknown error"}`,
-        };
-    }
-    const launched = await launchBrowser();
-    if ("message" in launched)
-        return { ok: false, message: launched.message };
-    const id = `${Date.now().toString(36)}`;
-    const toBlob = blobConfigured();
-    // In Blob mode allpages still writes to disk first, but into the system
-    // temp directory — the one location serverless hosts keep writable — and
-    // the files only exist for the moments between capture and upload.
-    let outDir;
-    try {
-        if (toBlob) {
-            outDir = await mkdtemp(join(tmpdir(), "polishd-snapshot-"));
-        }
-        else {
-            outDir = join(snapshotsRoot(), id);
-            await mkdir(outDir, { recursive: true });
-        }
-    }
-    catch (err) {
-        await launched.browser.close().catch(() => { });
-        return {
-            ok: false,
-            message: `Couldn't create the snapshot directory (${err instanceof Error ? err.message : "unknown error"}) — is the filesystem writable?`,
-        };
-    }
-    try {
-        const result = await run({
-            url: input.origin,
-            routes: input.routes.slice(0, MAX_SNAPSHOT_ROUTES),
-            outDir,
-            devices: [...SNAPSHOT_DEVICES],
-            themes: [...SNAPSHOT_THEMES],
-            // The dashboard composes its own grid; the stitched contact sheet would
-            // only duplicate every image on disk.
-            skipSheet: true,
-            browser: launched.browser,
-        });
-        const snapshot = {
-            id,
-            capturedAt: Date.now(),
-            origin: input.origin,
-            fingerprint: input.fingerprint,
-            shots: result.shots.map((s) => ({
-                route: s.route.path,
-                device: s.device.name,
-                theme: s.theme,
-                file: s.file ?? "",
-                ...(s.skipped ? { skipped: s.skipped } : {}),
-            })),
-            authWalled: result.authWalled,
-            noDarkMode: result.noDarkMode,
-        };
-        if (snapshot.shots.every((s) => !s.file)) {
-            await rm(outDir, { recursive: true, force: true }).catch(() => { });
-            return {
-                ok: false,
-                message: "Every page failed to capture — is the site reachable at " +
-                    `${input.origin} from this process?`,
-            };
-        }
-        if (toBlob) {
-            const failure = await uploadShots(id, outDir, snapshot.shots);
-            if (failure)
-                return { ok: false, message: failure };
-        }
-        const index = await loadIndex();
-        index.snapshots.unshift(snapshot);
-        const pruned = index.snapshots.slice(MAX_SNAPSHOTS);
-        index.snapshots = index.snapshots.slice(0, MAX_SNAPSHOTS);
-        if (!(await setMeta(INDEX_KEY, JSON.stringify(index)))) {
-            await deleteSnapshotImages(snapshot);
-            return {
-                ok: false,
-                message: "The snapshot was shot but the store refused to record it.",
-            };
-        }
-        for (const old of pruned) {
-            await deleteSnapshotImages(old);
-        }
-        return { ok: true, snapshot };
-    }
-    catch (err) {
-        await rm(outDir, { recursive: true, force: true }).catch(() => { });
-        return {
-            ok: false,
-            message: `Screenshot capture failed: ${err instanceof Error ? err.message : "unknown error"}`,
-        };
-    }
-    finally {
-        await launched.browser.close().catch(() => { });
-        // The temp staging directory never outlives the capture; the disk-mode
-        // directory is the storage itself and stays.
-        if (toBlob)
-            await rm(outDir, { recursive: true, force: true }).catch(() => { });
-    }
-}
 //# sourceMappingURL=snapshots.js.map