@replohq/sandbox-runtime 1.17.0 → 1.18.0

package/chunk-KRA4LUIR.mjs

@@ -0,0 +1,541 @@
+import { randomUUID } from './chunk-LIPH4O4F.mjs';
+import { isNullish } from './chunk-PH3S6LJI.mjs';
+import * as z from 'zod';
+
+var defaultLogger = {
+  info: console.log,
+  debug: console.debug,
+  error: console.error
+};
+
+var ReploError = class _ReploError extends Error {
+  config;
+  id;
+  constructor(config) {
+    super(config.message);
+    this.message = config.message ?? this.constructor.name;
+    this.config = config;
+    this.id = randomUUID();
+    const cause = config.cause;
+    if (cause) {
+      this.cause = cause;
+      if (cause instanceof _ReploError) {
+        this.config.additionalData = {
+          ...this.config.additionalData,
+          ...cause.config.additionalData
+        };
+      }
+    }
+  }
+};
+
+var errorUserFacingDetailsMessageSchema = z.object({
+  type: z.enum([
+    "toast",
+    "fullPageModal",
+    "shopifyStorePassword",
+    "billing.addPublishedElements",
+    "billing.addShopifyThemeProject",
+    "billing.addReploSite",
+    "agentBilling.shopifyThemeBuilder.publishedElements.exceeded",
+    "agentBilling.shopifyThemeBuilder.projects.exceeded",
+    "agentBilling.sites.exceeded",
+    "agentBilling.credits.exceeded",
+    "agentBilling.upgradeRequired"
+  ]),
+  message: z.string(),
+  isRecoverable: z.boolean().optional(),
+  detail: z.array(z.string()).or(z.string()).optional(),
+  key: z.string(),
+  details: z.record(z.string(), z.unknown()).optional(),
+  usage: z.object({
+    current: z.number(),
+    maximum: z.number()
+  }).optional(),
+  plan: z.string().optional(),
+  callToAction: z.discriminatedUnion("type", [
+    z.object({ type: z.literal("reload") }),
+    z.object({ type: z.literal("installApp") }),
+    z.object({ type: z.literal("goToHomepage") }),
+    z.object({ type: z.literal("navigateToProjectEditor") }),
+    z.object({ type: z.literal("closeModal") }),
+    z.object({
+      type: z.literal("navigateToLink"),
+      link: z.discriminatedUnion("type", [
+        z.object({ type: z.literal("errors.wrongJsonExtension") }),
+        z.object({ type: z.literal("errors.chunkingError") }),
+        z.object({ type: z.literal("errors.indexBackupError") }),
+        z.object({
+          type: z.literal("errors.shopifyIntegrationAlreadyAssigned")
+        }),
+        z.object({
+          type: z.literal("errors.shopifyIntegrationMissingAccessScopes"),
+          url: z.string()
+        }),
+        z.object({
+          type: z.literal("customLink"),
+          url: z.string()
+        }),
+        z.object({
+          type: z.literal(
+            "errors.projectConnectedToBillingIntegrationForShopifyWorkspace"
+          )
+        }),
+        z.object({ type: z.literal("errors.themeAssetSizeLimitExceeded") }),
+        z.object({ type: z.literal("errors.themeTotalSizeLimitExceeded") }),
+        z.object({
+          type: z.literal("errors.pageMetafieldDefinitionsChanged")
+        }),
+        z.object({ type: z.literal("settings.billing") })
+      ])
+    })
+  ]).optional()
+}).describe("ErrorUserFacingDetailsWithMessage");
+z.discriminatedUnion("type", [
+  errorUserFacingDetailsMessageSchema,
+  z.object({
+    type: z.literal("uncommon_none"),
+    key: z.string(),
+    usage: z.object({
+      current: z.number(),
+      maximum: z.number()
+    }).optional(),
+    message: z.string().optional(),
+    isRecoverable: z.boolean().optional(),
+    detail: z.array(z.string()).or(z.string()).optional()
+  })
+]).describe("ErrorUserFacingDetails");
+var IframeRpcChannelError = class extends ReploError {
+};
+var IframeRpcChannelTimeoutError = class extends IframeRpcChannelError {
+  constructor({ method, timeoutMs }) {
+    super({
+      message: `RPC method '${method}' timed out after ${timeoutMs}ms`,
+      additionalData: { method, timeoutMs }
+    });
+  }
+};
+var IframeRpcChannelTargetUnavailableError = class extends IframeRpcChannelError {
+  constructor({
+    callType,
+    method
+  }) {
+    super({
+      message: method ? `RPC target window was unavailable for '${method}'` : "RPC target window was unavailable for a response",
+      additionalData: { callType, method }
+    });
+  }
+};
+var IframeRpcChannelRemoteError = class extends IframeRpcChannelError {
+  constructor({ method, message }) {
+    super({
+      message: `RPC method '${method}' failed: ${message}`,
+      additionalData: { method }
+    });
+  }
+};
+var IframeRpcChannelUnsubscribedError = class extends IframeRpcChannelError {
+  constructor({ method }) {
+    super({
+      message: `RPC was unsubscribed while '${method}' was pending`,
+      additionalData: { method }
+    });
+  }
+};
+var IframeRpcChannelUnknownMethodError = class extends IframeRpcChannelError {
+  constructor({ method }) {
+    super({
+      message: `Unknown RPC method '${method}'`,
+      additionalData: { method }
+    });
+  }
+};
+var IframeRpcChannelConfigurationError = class extends IframeRpcChannelError {
+  constructor({ message }) {
+    super({ message });
+  }
+};
+var IframeRpcChannelInvalidInputError = class extends IframeRpcChannelError {
+  constructor({ method, cause }) {
+    super({
+      message: `Invalid RPC input for '${method}': ${cause.message}`,
+      cause,
+      additionalData: { method }
+    });
+  }
+};
+
+var iframeRpcCallResultSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("success"),
+    data: z.unknown()
+  }),
+  z.object({
+    type: z.literal("error"),
+    errorMessage: z.string()
+  })
+]);
+var iframeRpcCallSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("notify"),
+    method: z.string(),
+    data: z.unknown().optional()
+  }),
+  z.object({
+    type: z.literal("request"),
+    id: z.uuid(),
+    method: z.string(),
+    data: z.unknown().optional()
+  }),
+  z.object({
+    type: z.literal("response"),
+    id: z.uuid(),
+    result: iframeRpcCallResultSchema
+  })
+]);
+function isFireAndForgetOutputSchema(outputSchema) {
+  return outputSchema.type === "void" || outputSchema instanceof z.ZodVoid;
+}
+function isUndefinedInputSchema(inputSchema) {
+  return inputSchema.type === "undefined" || inputSchema instanceof z.ZodUndefined;
+}
+function coerceEmptyRpcInput({
+  input,
+  inputSchema
+}) {
+  if (isNullish(input) && isUndefinedInputSchema(inputSchema)) {
+    return void 0;
+  }
+  return input;
+}
+function createIframeRpcRemote(channelOrGetChannel, methods) {
+  const getChannel = typeof channelOrGetChannel === "function" ? channelOrGetChannel : () => channelOrGetChannel;
+  const outgoingMethods = methods ?? getChannel()?.outgoingMethods ?? null;
+  if (!outgoingMethods) {
+    throw new IframeRpcChannelConfigurationError({
+      message: "createIframeRpcRemote requires methods when the channel may be null"
+    });
+  }
+  return Object.fromEntries(
+    Object.keys(outgoingMethods).map(
+      (method) => {
+        return [
+          method,
+          (input) => {
+            const definition = outgoingMethods[method];
+            const channel = getChannel();
+            if (!channel) {
+              if (definition && isFireAndForgetOutputSchema(definition.outputSchema)) {
+                return void 0;
+              }
+              return Promise.reject(
+                new IframeRpcChannelUnsubscribedError({ method })
+              );
+            }
+            return channel.call({
+              method,
+              input
+            });
+          }
+        ];
+      }
+    )
+  );
+}
+function createIframeRpcChannel(options) {
+  const {
+    subscriberWindow,
+    channelIdentifier,
+    version,
+    getTargetWindow,
+    targetOrigin,
+    isExpectedMessage,
+    outgoingMethods,
+    incomingMethods,
+    handlers
+  } = options;
+  const pendingRequests = /* @__PURE__ */ new Map();
+  let subscriberCount = 0;
+  let handlerMeta;
+  const postMessage = (call2, targetWindow = getTargetWindow()) => {
+    targetWindow?.postMessage(
+      {
+        channelIdentifier,
+        version,
+        ...call2
+      },
+      targetOrigin
+    );
+  };
+  const respondWithError = ({
+    id,
+    errorMessage
+  }) => {
+    postMessage({
+      type: "response",
+      id,
+      result: { type: "error", errorMessage }
+    });
+  };
+  const handleRequest = async (message) => {
+    const definition = incomingMethods[message.method];
+    if (!definition || isFireAndForgetOutputSchema(definition.outputSchema)) {
+      respondWithError({
+        id: message.id,
+        errorMessage: `Unknown RPC method '${message.method}'`
+      });
+      return;
+    }
+    const parsedInput = definition.inputSchema.safeParse(
+      coerceEmptyRpcInput({
+        input: message.data,
+        inputSchema: definition.inputSchema
+      })
+    );
+    if (!parsedInput.success) {
+      respondWithError({
+        id: message.id,
+        errorMessage: `Invalid request payload for '${message.method}': ${parsedInput.error.message}`
+      });
+      return;
+    }
+    try {
+      const handler = handlers[
+        message.method
+      ];
+      const result = await handler(parsedInput.data, handlerMeta);
+      const parsedOutput = definition.outputSchema.safeParse(result);
+      if (!parsedOutput.success) {
+        respondWithError({
+          id: message.id,
+          errorMessage: `Invalid response payload for '${message.method}': ${parsedOutput.error.message}`
+        });
+        return;
+      }
+      postMessage({
+        type: "response",
+        id: message.id,
+        result: { type: "success", data: parsedOutput.data }
+      });
+    } catch (error) {
+      respondWithError({
+        id: message.id,
+        errorMessage: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
+  const handleNotification = (message) => {
+    const definition = incomingMethods[message.method];
+    if (!definition || !isFireAndForgetOutputSchema(definition.outputSchema)) {
+      return;
+    }
+    const parsedInput = definition.inputSchema.safeParse(
+      coerceEmptyRpcInput({
+        input: message.data,
+        inputSchema: definition.inputSchema
+      })
+    );
+    if (!parsedInput.success) {
+      defaultLogger.error(
+        `[iframeRpcChannel] Dropping invalid notify for '${message.method}': ${parsedInput.error.message}`
+      );
+      return;
+    }
+    const handler = handlers[
+      message.method
+    ];
+    handler(parsedInput.data, handlerMeta);
+  };
+  const handleResponse = (message) => {
+    const pendingRequest = pendingRequests.get(message.id);
+    if (!pendingRequest) {
+      return;
+    }
+    clearTimeout(pendingRequest.timeoutId);
+    pendingRequests.delete(message.id);
+    if (message.result.type === "error") {
+      pendingRequest.reject(
+        new IframeRpcChannelRemoteError({
+          method: pendingRequest.method,
+          message: message.result.errorMessage
+        })
+      );
+      return;
+    }
+    const definition = outgoingMethods[pendingRequest.method];
+    const parsedOutput = definition?.outputSchema.safeParse(
+      message.result.data
+    );
+    if (!parsedOutput?.success) {
+      pendingRequest.reject(
+        new IframeRpcChannelRemoteError({
+          method: pendingRequest.method,
+          message: `Invalid response payload: ${parsedOutput?.error.message ?? "unknown method"}`
+        })
+      );
+      return;
+    }
+    pendingRequest.resolve(parsedOutput.data);
+  };
+  const handleMessage = (event) => {
+    const parsedMetadata = z.object({
+      channelIdentifier: z.literal(channelIdentifier),
+      version: z.literal(version)
+    }).safeParse(event.data);
+    if (!parsedMetadata.success) {
+      return;
+    }
+    if (!isExpectedMessage(event)) {
+      const isSiblingFrame = typeof document !== "undefined" && Array.from(document.querySelectorAll("iframe")).some((frame) => {
+        return event.source !== null && frame.contentWindow === event.source;
+      });
+      if (isSiblingFrame) {
+        return;
+      }
+      defaultLogger.error("[iframeRpcChannel] Dropping unexpected message", {
+        channelIdentifier,
+        version,
+        origin: event.origin,
+        hasSource: Boolean(event.source)
+      });
+      return;
+    }
+    const parsedCall = iframeRpcCallSchema.safeParse(event.data);
+    if (!parsedCall.success) {
+      return;
+    }
+    const message = parsedCall.data;
+    if (message.type === "notify") {
+      handleNotification(message);
+      return;
+    }
+    if (message.type === "request") {
+      void handleRequest(message);
+      return;
+    }
+    handleResponse(message);
+  };
+  const rejectPendingRequests = () => {
+    for (const pendingRequest of pendingRequests.values()) {
+      clearTimeout(pendingRequest.timeoutId);
+      pendingRequest.reject(
+        new IframeRpcChannelUnsubscribedError({
+          method: pendingRequest.method
+        })
+      );
+    }
+    pendingRequests.clear();
+  };
+  const subscribe = () => {
+    subscriberCount += 1;
+    if (subscriberCount === 1) {
+      subscriberWindow.addEventListener("message", handleMessage);
+    }
+    let isActive = true;
+    return () => {
+      if (!isActive) {
+        return;
+      }
+      isActive = false;
+      subscriberCount -= 1;
+      if (subscriberCount === 0) {
+        subscriberWindow.removeEventListener("message", handleMessage);
+        rejectPendingRequests();
+      }
+    };
+  };
+  const call = ({
+    method,
+    input
+  }) => {
+    const definition = outgoingMethods[method];
+    if (!definition) {
+      return Promise.reject(
+        new IframeRpcChannelUnknownMethodError({ method })
+      );
+    }
+    const isFireAndForget = isFireAndForgetOutputSchema(
+      definition.outputSchema
+    );
+    const parsedInput = definition.inputSchema.safeParse(
+      coerceEmptyRpcInput({
+        input,
+        inputSchema: definition.inputSchema
+      })
+    );
+    if (!parsedInput.success) {
+      const error = new IframeRpcChannelInvalidInputError({
+        method,
+        cause: parsedInput.error
+      });
+      if (isFireAndForget) {
+        throw error;
+      }
+      return Promise.reject(error);
+    }
+    if (isFireAndForget) {
+      postMessage({
+        type: "notify",
+        method,
+        data: parsedInput.data
+      });
+      return void 0;
+    }
+    if (subscriberCount === 0) {
+      return Promise.reject(
+        new IframeRpcChannelUnsubscribedError({ method })
+      );
+    }
+    const targetWindow = getTargetWindow();
+    if (!targetWindow) {
+      return Promise.reject(
+        new IframeRpcChannelTargetUnavailableError({
+          callType: "request",
+          method
+        })
+      );
+    }
+    const id = randomUUID();
+    const timeoutMs = definition.timeoutMs ?? 3e4;
+    return new Promise(
+      (resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+          pendingRequests.delete(id);
+          reject(new IframeRpcChannelTimeoutError({ method, timeoutMs }));
+        }, timeoutMs);
+        pendingRequests.set(id, {
+          method,
+          resolve: (value) => {
+            resolve(value);
+          },
+          reject,
+          timeoutId
+        });
+        try {
+          postMessage(
+            {
+              type: "request",
+              id,
+              method,
+              data: parsedInput.data
+            },
+            targetWindow
+          );
+        } catch (error) {
+          clearTimeout(timeoutId);
+          pendingRequests.delete(id);
+          reject(error);
+        }
+      }
+    );
+  };
+  const channel = {
+    subscribe,
+    call,
+    outgoingMethods
+  };
+  handlerMeta = { channel: createIframeRpcRemote(channel) };
+  return channel;
+}
+
+export { createIframeRpcChannel, createIframeRpcRemote, iframeRpcCallSchema };

package/nextErrorFeed.d.ts

@@ -0,0 +1,30 @@
+export type NextErrorFeedEvent = {
+    kind: "rootCaught";
+    error: unknown;
+} | {
+    kind: "error";
+    origin: "runtime" | "recoverable" | "console";
+    error: Error;
+} | {
+    kind: "rejection";
+    error: Error;
+};
+type NextErrorFeedListener = (event: NextErrorFeedEvent) => void;
+type NextErrorFeedState = {
+    listener: NextErrorFeedListener | null;
+    dispose: () => void;
+};
+declare global {
+    interface Window {
+        __reploNextErrorFeed?: NextErrorFeedState;
+    }
+}
+/**
+ * Routes Next's error feed to `listener`, replacing any previous listener.
+ * The subscriber lives in its own detached React root so it outlives a root
+ * failure of the page tree and never unmounts: unmounting `useErrorHandler`
+ * clears Next's shared error queues.
+ */
+export declare function installNextErrorFeed(listener: NextErrorFeedListener): void;
+export declare function resetNextErrorFeedForTests(): void;
+export {};

package/nextErrorFeed.js

@@ -0,0 +1,64 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { isRecoverableError } from "next/dist/client/react-client-callbacks/on-recoverable-error";
+import { isConsoleError } from "next/dist/next-devtools/shared/console-error";
+import { AppDevOverlayErrorBoundary } from "next/dist/next-devtools/userspace/app/app-dev-overlay-error-boundary";
+import { useErrorHandler } from "next/dist/next-devtools/userspace/app/errors/use-error-handler";
+import { flushSync } from "react-dom";
+import { createRoot } from "react-dom/client";
+const ROOT_BOUNDARY_PATCHED = Symbol.for(
+  "replo.previewHealth.rootBoundaryPatched"
+);
+function emit(event) {
+  window.__reploNextErrorFeed?.listener?.(event);
+}
+function classifyError(error) {
+  if (isRecoverableError(error)) {
+    return "recoverable";
+  }
+  return isConsoleError(error) ? "console" : "runtime";
+}
+function handleError(error) {
+  emit({ kind: "error", origin: classifyError(error), error });
+}
+function handleRejection(error) {
+  emit({ kind: "rejection", error });
+}
+function ErrorFeedSubscriber() {
+  useErrorHandler(handleError, handleRejection);
+  return null;
+}
+function patchRootBoundary() {
+  const prototype = AppDevOverlayErrorBoundary.prototype;
+  if (Reflect.get(prototype, ROOT_BOUNDARY_PATCHED)) {
+    return;
+  }
+  const original = prototype.componentDidCatch;
+  prototype.componentDidCatch = function componentDidCatch(error) {
+    emit({ kind: "rootCaught", error });
+    original.call(this, error);
+  };
+  Reflect.set(prototype, ROOT_BOUNDARY_PATCHED, true);
+}
+function installNextErrorFeed(listener) {
+  if (window.__reploNextErrorFeed) {
+    window.__reploNextErrorFeed.listener = listener;
+    return;
+  }
+  patchRootBoundary();
+  const feedDocument = document.implementation.createHTMLDocument();
+  const root = createRoot(feedDocument.createElement("div"));
+  window.__reploNextErrorFeed = {
+    listener,
+    dispose: () => root.unmount()
+  };
+  flushSync(() => root.render(/* @__PURE__ */ jsx(ErrorFeedSubscriber, {})));
+}
+function resetNextErrorFeedForTests() {
+  window.__reploNextErrorFeed?.dispose();
+  delete window.__reploNextErrorFeed;
+}
+export {
+  installNextErrorFeed,
+  resetNextErrorFeedForTests
+};

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@replohq/sandbox-runtime",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "reploBuild": {
     "packageName": "@replohq/sandbox-runtime",
-    "version": "1.17.0",
+    "version": "1.18.0",
     "branch": "HEAD",
-    "commit": "7d16c9a29182a37625a958569422b94a08b9a627",
-    "builtAt": "2026-10-20T04:21:24.844Z"
+    "commit": "371ae98105e9f99b04918b3dffe40867380cd9ef",
+    "builtAt": "2026-10-21T22:33:13.604Z"
   },
   "description": "Replo sandbox runtime — editor integration for agent-built Next.js sites.",
   "license": "SEE LICENSE IN LICENSE",
@@ -17,14 +17,6 @@
       "types": "./sandbox-runtime.d.ts",
       "default": "./sandbox-runtime.js"
     },
-    "./next/component-preview": {
-      "types": "./next/component-preview.d.ts",
-      "default": "./next/component-preview.js"
-    },
-    "./next/component-preview-client": {
-      "types": "./next/component-preview-client.d.ts",
-      "default": "./next/component-preview-client.js"
-    },
     "./next/config": {
       "types": "./next/config.d.ts",
       "default": "./next/config.js"
@@ -42,6 +34,7 @@
     "@tiptap/extension-underline": "^2.25.0",
     "@tiptap/pm": "^2.25.0",
     "@zumer/snapdom": "^3.0.0",
+    "async-retry": "^1.3.3",
     "uuid": "^11.1.0",
     "zod": "^4.3.6",
     "zustand": "^4.5.7"

package/previewHealth.d.ts

@@ -0,0 +1,25 @@
+type CaughtError = {
+    error: unknown;
+    componentStack: string | null;
+};
+export type PreviewHealthActions = {
+    /** The boundary committed the page: a mount, or a recovery after a reset. */
+    boundaryRendered: (boundaryId: string) => void;
+    boundaryCaughtError: (boundaryId: string, caught: CaughtError) => void;
+    boundaryUnmounted: (boundaryId: string) => void;
+    rootCaughtError: (error: unknown) => void;
+    buildErrorsChanged: (messages: string[]) => void;
+};
+type PreviewHealthMonitor = {
+    actions: PreviewHealthActions;
+    dispose: () => void;
+};
+declare global {
+    interface Window {
+        __reploPreviewHealthMonitor?: PreviewHealthMonitor;
+    }
+}
+/** The document's preview health actions; null outside an embedded preview. */
+export declare function getPreviewHealthActions(): PreviewHealthActions | null;
+export declare function resetPreviewHealthMonitorForTests(): void;
+export {};