@replohq/sandbox-runtime 1.8.0 → 1.9.0

package/PageCaptureResponder.d.ts

@@ -0,0 +1 @@
+export declare function PageCaptureResponder(): import("react/jsx-runtime").JSX.Element;

package/PageCaptureResponder.js

@@ -0,0 +1,12 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { startPageCaptureResponder } from "./startPageCaptureResponder";
+function startResponder() {
+  return startPageCaptureResponder(window);
+}
+function PageCaptureResponder() {
+  return /* @__PURE__ */ jsx("template", { ref: startResponder });
+}
+export {
+  PageCaptureResponder
+};

package/_vendor/replo-utils/lib/crypto.mjs

@@ -0,0 +1 @@
+export { base64UrlToBytes, bytesToBase64Url, constantTimeEqual, getHmacSha256Hex, randomBase64Url, randomUUID, sha256Hex } from '../../../chunk-LIPH4O4F.mjs';

package/_vendor/replo-utils/lib/math.mjs

@@ -1,4 +1,4 @@
-import { randomUUID } from '../../../chunk-SGKQ5HGT.mjs';
+import { randomUUID } from '../../../chunk-LIPH4O4F.mjs';
 import { isNumber_default } from '../../../chunk-FLYEIRFK.mjs';
 import '../../../chunk-G3S6ZNPF.mjs';
 

package/_vendor/replo-utils/lib/pageCapture.d.ts

@@ -0,0 +1,34 @@
+/** Site Builder asks the cross-origin preview iframe to draw its own first screen; the site's runtime replies with a JPEG. */
+export declare const PAGE_CAPTURE_REQUEST = "replo:page-capture:request";
+export declare const PAGE_CAPTURE_RESPONSE = "replo:page-capture:response";
+export interface PageCaptureRequestMessage {
+    type: typeof PAGE_CAPTURE_REQUEST;
+    requestId: string;
+    width: number;
+    height: number;
+}
+export type PageCaptureResponseMessage = {
+    type: typeof PAGE_CAPTURE_RESPONSE;
+    requestId: string;
+    jpeg: ArrayBuffer;
+    ms: number;
+} | {
+    type: typeof PAGE_CAPTURE_RESPONSE;
+    requestId: string;
+    jpeg: null;
+    error: string;
+};
+export declare function isPageCaptureRequestMessage(value: unknown): value is PageCaptureRequestMessage;
+export declare class PageCaptureError extends Error {
+}
+/** Parent side: ask `frame` to capture itself and resolve with its JPEG bytes. */
+export declare function requestPageCapture({ frame, targetOrigin, width, height, timeoutMs, }: {
+    frame: Window;
+    targetOrigin: string;
+    width: number;
+    height: number;
+    timeoutMs?: number;
+}): Promise<{
+    jpeg: ArrayBuffer;
+    ms: number;
+}>;

package/_vendor/replo-utils/lib/pageCapture.mjs

@@ -0,0 +1,52 @@
+import { randomUUID } from '../../../chunk-LIPH4O4F.mjs';
+
+var PAGE_CAPTURE_REQUEST = "replo:page-capture:request";
+var PAGE_CAPTURE_RESPONSE = "replo:page-capture:response";
+function isPageCaptureRequestMessage(value) {
+  return typeof value === "object" && value !== null && "type" in value && value.type === PAGE_CAPTURE_REQUEST && "requestId" in value && typeof value.requestId === "string" && "width" in value && typeof value.width === "number" && "height" in value && typeof value.height === "number";
+}
+function isPageCaptureResponseMessage(value, requestId) {
+  return typeof value === "object" && value !== null && "type" in value && value.type === PAGE_CAPTURE_RESPONSE && "requestId" in value && value.requestId === requestId;
+}
+var PageCaptureError = class extends Error {
+};
+function requestPageCapture({
+  frame,
+  targetOrigin,
+  width,
+  height,
+  timeoutMs = 15e3
+}) {
+  const requestId = randomUUID();
+  return new Promise((resolve, reject) => {
+    const onMessage = (event) => {
+      if (event.source !== frame || !isPageCaptureResponseMessage(event.data, requestId)) {
+        return;
+      }
+      cleanup();
+      if (event.data.jpeg) {
+        resolve({ jpeg: event.data.jpeg, ms: event.data.ms });
+      } else {
+        reject(new PageCaptureError(event.data.error));
+      }
+    };
+    const timeout = setTimeout(() => {
+      cleanup();
+      reject(new PageCaptureError("capture timed out"));
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timeout);
+      window.removeEventListener("message", onMessage);
+    };
+    window.addEventListener("message", onMessage);
+    const request = {
+      type: PAGE_CAPTURE_REQUEST,
+      requestId,
+      width,
+      height
+    };
+    frame.postMessage(request, targetOrigin);
+  });
+}
+
+export { PAGE_CAPTURE_REQUEST, PAGE_CAPTURE_RESPONSE, PageCaptureError, isPageCaptureRequestMessage, requestPageCapture };

package/_vendor/schemas/iframeRpcChannel.mjs

@@ -1,4 +1,4 @@
-import { randomUUID } from '../../chunk-SGKQ5HGT.mjs';
+import { randomUUID } from '../../chunk-LIPH4O4F.mjs';
 import { isNullish } from '../../chunk-JUKCUPQ6.mjs';
 import '../../chunk-FLYEIRFK.mjs';
 import '../../chunk-TESFJQID.mjs';

package/_vendor/schemas/selectMode.d.ts

@@ -389,9 +389,9 @@ export declare const selectModeFormatCommandSchema: z.ZodEnum<{
  * Renaming or adding a variant here is a TS error in all three.
  */
 export declare const selectModeSelectionTypeSchema: z.ZodEnum<{
-    element: "element";
-    area: "area";
     drag: "drag";
+    area: "area";
+    element: "element";
     none: "none";
 }>;
 /**

package/_vendor/schemas/selectModeIframeRpc.d.ts

@@ -342,9 +342,9 @@ export declare const websiteBuilderToPreviewIframeMethodConfig: {
     setSelectionType: {
         inputSchema: z.ZodObject<{
             selectionType: z.ZodEnum<{
-                element: "element";
-                area: "area";
                 drag: "drag";
+                area: "area";
+                element: "element";
                 none: "none";
             }>;
             selectors: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -862,9 +862,9 @@ export declare const selectModeParentMessageSchema: z.ZodDiscriminatedUnion<[z.Z
     method: z.ZodLiteral<"setSelectionType">;
     data: z.ZodObject<{
         selectionType: z.ZodEnum<{
-            element: "element";
-            area: "area";
             drag: "drag";
+            area: "area";
+            element: "element";
             none: "none";
         }>;
         selectors: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/buildMetadata.js

@@ -1,7 +1,7 @@
 export const BUILD_METADATA = {
   "packageName": "@replohq/sandbox-runtime",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "branch": "HEAD",
-  "commit": "6ad933540e110b76d214b8700e7a356a551c869a",
-  "builtAt": "2026-09-24T18:57:19.451Z"
+  "commit": "455eef2903f4cc6a8f457d5ec77be1e1dc95aad9",
+  "builtAt": "2026-09-25T00:24:57.880Z"
 };

package/capturePage.d.ts

@@ -0,0 +1,11 @@
+export declare function parseYouTubeId(src: string): string | null;
+export declare function parseVimeoId(src: string): string | null;
+/**
+ * Draws the page's first screen (from the document top, regardless of scroll)
+ * into an exact width×height JPEG. Videos and YouTube/Vimeo embeds, which the
+ * page cannot read directly, are swapped for their current frame or thumbnail.
+ */
+export declare function capturePage({ width, height, }: {
+    width: number;
+    height: number;
+}): Promise<Blob>;

package/capturePage.js

@@ -0,0 +1,261 @@
+import { snapdom } from "@zumer/snapdom";
+import { PageCaptureError } from "./_vendor/replo-utils/lib/pageCapture.mjs";
+import { z } from "zod";
+const JPEG_QUALITY = 0.8;
+const VIDEO_FRAME_QUALITY = 0.85;
+const VIDEO_LOAD_TIMEOUT_MS = 4e3;
+const VIDEO_SEEK_TIMEOUT_MS = 1500;
+const PLACEHOLDER_BACKGROUND = "#d9d9d6";
+const IFRAME_PLACEHOLDER_MARKER = "repeating-linear-gradient(45deg";
+const vimeoOembedSchema = z.object({ thumbnail_url: z.string() });
+function parseYouTubeId(src) {
+  const match = src.match(
+    /(?:youtube(?:-nocookie)?\.com\/embed\/|youtu\.be\/)([\w-]{11})/
+  );
+  return match?.[1] ?? null;
+}
+function parseVimeoId(src) {
+  const match = src.match(/player\.vimeo\.com\/video\/(\d+)/);
+  return match?.[1] ?? null;
+}
+function canReadIframeDocument(iframe) {
+  try {
+    return Boolean(iframe.contentDocument ?? iframe.contentWindow?.document);
+  } catch {
+    return false;
+  }
+}
+async function fetchAsDataUrl(url) {
+  const blob = await (await fetch(url)).blob();
+  return await new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.addEventListener("load", () => {
+      resolve(String(reader.result));
+    });
+    reader.addEventListener("error", () => {
+      reject(reader.error ?? new PageCaptureError("image read failed"));
+    });
+    reader.readAsDataURL(blob);
+  });
+}
+function isCanvasReadable(source) {
+  try {
+    const canvas = document.createElement("canvas");
+    canvas.width = 1;
+    canvas.height = 1;
+    canvas.getContext("2d")?.drawImage(source, 0, 0, 1, 1);
+    canvas.toDataURL();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function videoFrameDataUrl(video) {
+  const canvas = document.createElement("canvas");
+  canvas.width = video.videoWidth;
+  canvas.height = video.videoHeight;
+  const context = canvas.getContext("2d");
+  if (!context) {
+    return null;
+  }
+  context.drawImage(video, 0, 0);
+  return canvas.toDataURL("image/jpeg", VIDEO_FRAME_QUALITY);
+}
+function isOnScreen({
+  element,
+  height
+}) {
+  const rect = element.getBoundingClientRect();
+  return rect.bottom > 0 && rect.top < height && rect.width > 0;
+}
+async function readVideoFrame({
+  video,
+  height
+}) {
+  if (!isOnScreen({ element: video, height })) {
+    return null;
+  }
+  if (video.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA && isCanvasReadable(video)) {
+    return videoFrameDataUrl(video);
+  }
+  const copy = document.createElement("video");
+  copy.crossOrigin = "anonymous";
+  copy.muted = true;
+  copy.preload = "auto";
+  try {
+    copy.src = video.currentSrc || video.src;
+    await new Promise((resolve, reject) => {
+      copy.addEventListener("loadeddata", () => {
+        resolve();
+      });
+      copy.addEventListener("error", () => {
+        reject(new PageCaptureError("video load failed"));
+      });
+      setTimeout(() => {
+        reject(new PageCaptureError("video load timed out"));
+      }, VIDEO_LOAD_TIMEOUT_MS);
+    });
+    if (video.currentTime > 0.1) {
+      copy.currentTime = video.currentTime;
+      await new Promise((resolve) => {
+        copy.addEventListener("seeked", () => {
+          resolve();
+        });
+        setTimeout(resolve, VIDEO_SEEK_TIMEOUT_MS);
+      });
+    }
+    return isCanvasReadable(copy) ? videoFrameDataUrl(copy) : null;
+  } catch {
+    return null;
+  } finally {
+    copy.removeAttribute("src");
+    copy.load();
+  }
+}
+async function readIframeThumbnail(iframe) {
+  const src = iframe.src;
+  let url = null;
+  const youTubeId = parseYouTubeId(src);
+  if (youTubeId) {
+    url = `https://i.ytimg.com/vi/${youTubeId}/hqdefault.jpg`;
+  }
+  const vimeoId = parseVimeoId(src);
+  if (vimeoId) {
+    try {
+      const response = await fetch(
+        `https://vimeo.com/api/oembed.json?url=https://vimeo.com/${vimeoId}&width=1280`
+      );
+      const body = vimeoOembedSchema.safeParse(await response.json());
+      url = body.success ? body.data.thumbnail_url : null;
+    } catch {
+      url = null;
+    }
+  }
+  if (!url) {
+    return null;
+  }
+  return fetchAsDataUrl(url).catch(() => null);
+}
+function createStandInsPlugin({
+  objectFitByFrame,
+  iframeThumbnails
+}) {
+  return {
+    name: "replo-page-capture-stand-ins",
+    afterClone(context) {
+      const clone = context.clone;
+      if (!clone) {
+        return;
+      }
+      for (const image of clone.querySelectorAll("img")) {
+        const objectFit = objectFitByFrame.get(image.getAttribute("src") ?? "");
+        if (objectFit) {
+          image.style.objectFit = objectFit;
+        }
+      }
+      const placeholders = Array.from(
+        clone.querySelectorAll("div")
+      ).filter((element) => {
+        return (element.getAttribute("style") ?? "").includes(
+          IFRAME_PLACEHOLDER_MARKER
+        );
+      });
+      placeholders.forEach((placeholder, index) => {
+        const thumbnail = iframeThumbnails[index];
+        placeholder.style.backgroundImage = thumbnail ? `url("${thumbnail}")` : "none";
+        placeholder.style.backgroundColor = PLACEHOLDER_BACKGROUND;
+        placeholder.style.backgroundSize = "cover";
+        placeholder.style.backgroundPosition = "center";
+      });
+    }
+  };
+}
+function pageBackgroundColor() {
+  for (const element of [document.body, document.documentElement]) {
+    const color = getComputedStyle(element).backgroundColor;
+    if (color && color !== "transparent" && color !== "rgba(0, 0, 0, 0)") {
+      return color;
+    }
+  }
+  return "#fff";
+}
+function canvasToJpeg(canvas) {
+  return new Promise((resolve, reject) => {
+    canvas.toBlob(
+      (blob) => {
+        if (blob) {
+          resolve(blob);
+        } else {
+          reject(new PageCaptureError("jpeg encode failed"));
+        }
+      },
+      "image/jpeg",
+      JPEG_QUALITY
+    );
+  });
+}
+async function capturePage({
+  width,
+  height
+}) {
+  const videos = Array.from(document.querySelectorAll("video"));
+  const iframes = Array.from(document.querySelectorAll("iframe")).filter(
+    (iframe) => !canReadIframeDocument(iframe)
+  );
+  const [videoFrames, iframeThumbnails] = await Promise.all([
+    Promise.all(
+      videos.map((video) => {
+        return readVideoFrame({ video, height });
+      })
+    ),
+    Promise.all(iframes.map(readIframeThumbnail))
+  ]);
+  const originalPosters = [];
+  const objectFitByFrame = /* @__PURE__ */ new Map();
+  videos.forEach((video, index) => {
+    const frame = videoFrames[index];
+    if (!frame) {
+      return;
+    }
+    originalPosters.push({ video, poster: video.getAttribute("poster") });
+    video.setAttribute("poster", frame);
+    objectFitByFrame.set(frame, getComputedStyle(video).objectFit);
+  });
+  try {
+    const raw = await snapdom.toRaw(document.body, {
+      scale: 1,
+      embedFonts: true,
+      plugins: [createStandInsPlugin({ objectFitByFrame, iframeThumbnails })]
+    });
+    const image = new Image();
+    image.src = raw;
+    await image.decode();
+    await new Promise((resolve) => {
+      setTimeout(resolve, 100);
+    });
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const context = canvas.getContext("2d");
+    if (!context) {
+      throw new PageCaptureError("canvas 2d context unavailable");
+    }
+    context.fillStyle = pageBackgroundColor();
+    context.fillRect(0, 0, width, height);
+    context.drawImage(image, 0, 0);
+    return await canvasToJpeg(canvas);
+  } finally {
+    for (const { video, poster } of originalPosters) {
+      if (poster === null) {
+        video.removeAttribute("poster");
+      } else {
+        video.setAttribute("poster", poster);
+      }
+    }
+  }
+}
+export {
+  capturePage,
+  parseVimeoId,
+  parseYouTubeId
+};

package/chunk-LIPH4O4F.mjs

@@ -0,0 +1,67 @@
+import { v4 } from 'uuid';
+
+function bytesToBase64Url(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function base64UrlToBytes(input) {
+  const normalized = input.replaceAll("-", "+").replaceAll("_", "/");
+  const padded = normalized.padEnd(
+    normalized.length + (4 - normalized.length % 4) % 4,
+    "="
+  );
+  const binary = atob(padded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function randomBase64Url(byteLength) {
+  return bytesToBase64Url(crypto.getRandomValues(new Uint8Array(byteLength)));
+}
+function randomUUID() {
+  return v4();
+}
+async function sha256Hex(input) {
+  const buffer = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  const hash = await crypto.subtle.digest("SHA-256", buffer);
+  return [...new Uint8Array(hash)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function constantTimeEqual({
+  left,
+  right
+}) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  let difference = 0;
+  for (let index = 0; index < left.length; index += 1) {
+    difference |= (left[index] ?? 0) ^ (right[index] ?? 0);
+  }
+  return difference === 0;
+}
+async function getHmacSha256Hex({
+  rawBody,
+  signingKey
+}) {
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(signingKey),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign(
+    "HMAC",
+    key,
+    encoder.encode(rawBody)
+  );
+  return [...new Uint8Array(signature)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+export { base64UrlToBytes, bytesToBase64Url, constantTimeEqual, getHmacSha256Hex, randomBase64Url, randomUUID, sha256Hex };

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@replohq/sandbox-runtime",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "reploBuild": {
     "packageName": "@replohq/sandbox-runtime",
-    "version": "1.8.0",
+    "version": "1.9.0",
     "branch": "HEAD",
-    "commit": "6ad933540e110b76d214b8700e7a356a551c869a",
-    "builtAt": "2026-09-24T18:57:19.451Z"
+    "commit": "455eef2903f4cc6a8f457d5ec77be1e1dc95aad9",
+    "builtAt": "2026-09-25T00:24:57.880Z"
   },
   "description": "Replo sandbox runtime — editor integration for agent-built Next.js sites.",
   "license": "SEE LICENSE IN LICENSE",
@@ -40,6 +40,7 @@
     "@tiptap/extension-text": "^2.25.0",
     "@tiptap/extension-underline": "^2.25.0",
     "@tiptap/pm": "^2.25.0",
+    "@zumer/snapdom": "^3.0.0",
     "uuid": "^11.1.0",
     "zod": "^4.3.6",
     "zustand": "^4.5.7"

package/sandbox-runtime.js

@@ -8,6 +8,7 @@ import { DocumentReadyBeacon } from "./DocumentReadyBeacon";
 import LinkInterceptor from "./LinkInterceptor";
 import { NavigationReceiver } from "./NavigationReceiver";
 import { NextErrorReporter } from "./NextErrorReporter";
+import { PageCaptureResponder } from "./PageCaptureResponder";
 import PostHogRelay from "./posthog-relay";
 import { EditorSelection } from "./select-mode/EditorSelection";
 function ViewportSnapshotResponder() {
@@ -24,6 +25,7 @@ function SandboxRuntime({ children }) {
       /* @__PURE__ */ jsx(NavigationReceiver, {}),
       /* @__PURE__ */ jsx(PostHogRelay, {}),
       /* @__PURE__ */ jsx(ViewportSnapshotResponder, {}),
+      /* @__PURE__ */ jsx(PageCaptureResponder, {}),
       /* @__PURE__ */ jsx(EditorSelection, {}),
       /* @__PURE__ */ jsx(AnnotationLayerMount, {}),
       /* @__PURE__ */ jsx(DesignLibraryPreview, {}),

package/startPageCaptureResponder.d.ts

@@ -0,0 +1,32 @@
+import type { PageCaptureResponseMessage } from "./_vendor/replo-utils/lib/pageCapture";
+interface PageCaptureMessageListener {
+    (event: {
+        data: unknown;
+        source: unknown;
+        origin: string;
+    }): void;
+}
+/** The slice of `window` the responder touches, so specs can pass a fake. */
+export interface PageCaptureWindow {
+    readonly innerWidth: number;
+    readonly parent: {
+        postMessage(message: PageCaptureResponseMessage, targetOrigin: string, transfer: Transferable[]): void;
+    };
+    readonly document: {
+        readonly fonts?: {
+            readonly ready: Promise<unknown>;
+        };
+    };
+    requestIdleCallback?(callback: () => void, options: {
+        timeout: number;
+    }): number;
+    addEventListener(type: "message", listener: PageCaptureMessageListener): void;
+    removeEventListener(type: "message", listener: PageCaptureMessageListener): void;
+}
+/**
+ * Answers Site Builder's page-capture requests with a JPEG of this page's
+ * first screen. Requests run one at a time so concurrent captures never
+ * fight over the page's temporary video posters.
+ */
+export declare function startPageCaptureResponder(targetWindow: PageCaptureWindow): () => void;
+export {};

package/startPageCaptureResponder.js

@@ -0,0 +1,87 @@
+import {
+  isPageCaptureRequestMessage,
+  PAGE_CAPTURE_RESPONSE
+} from "./_vendor/replo-utils/lib/pageCapture.mjs";
+import { isTrustedViewportSnapshotRequester } from "./_vendor/replo-utils/lib/viewportSnapshot.mjs";
+const IDLE_TIMEOUT_MS = 1e3;
+function waitForIdle(targetWindow) {
+  return new Promise((resolve) => {
+    if (targetWindow.requestIdleCallback) {
+      targetWindow.requestIdleCallback(
+        () => {
+          resolve();
+        },
+        { timeout: IDLE_TIMEOUT_MS }
+      );
+    } else {
+      setTimeout(resolve, 0);
+    }
+  });
+}
+async function respondToRequest({
+  targetWindow,
+  request
+}) {
+  const failure = (error) => {
+    return {
+      response: {
+        type: PAGE_CAPTURE_RESPONSE,
+        requestId: request.requestId,
+        jpeg: null,
+        error
+      },
+      transfer: []
+    };
+  };
+  if (targetWindow.innerWidth !== request.width) {
+    return failure("layout-width-mismatch");
+  }
+  try {
+    const startedAt = performance.now();
+    await waitForIdle(targetWindow);
+    await targetWindow.document.fonts?.ready;
+    const { capturePage } = await import("./capturePage");
+    const blob = await capturePage({
+      width: request.width,
+      height: request.height
+    });
+    const jpeg = await blob.arrayBuffer();
+    return {
+      response: {
+        type: PAGE_CAPTURE_RESPONSE,
+        requestId: request.requestId,
+        jpeg,
+        ms: Math.round(performance.now() - startedAt)
+      },
+      transfer: [jpeg]
+    };
+  } catch (error) {
+    return failure(error instanceof Error ? error.message : String(error));
+  }
+}
+function startPageCaptureResponder(targetWindow) {
+  let queue = Promise.resolve();
+  const onMessage = (event) => {
+    if (event.source !== targetWindow.parent || !isPageCaptureRequestMessage(event.data) || !isTrustedViewportSnapshotRequester(event.origin)) {
+      return;
+    }
+    const request = event.data;
+    const requesterOrigin = event.origin;
+    queue = queue.then(async () => {
+      const { response, transfer } = await respondToRequest({
+        targetWindow,
+        request
+      });
+      targetWindow.parent.postMessage(response, requesterOrigin, transfer);
+    }).catch((error) => {
+      console.warn("[replo] page capture reply failed", error);
+    });
+  };
+  targetWindow.addEventListener("message", onMessage);
+  return () => {
+    targetWindow.removeEventListener("message", onMessage);
+  };
+}
+export {
+  startPageCaptureResponder
+};

package/chunk-SGKQ5HGT.mjs

@@ -1,7 +0,0 @@
-import { v4 } from 'uuid';
-
-function randomUUID() {
-  return v4();
-}
-
-export { randomUUID };