@replohq/sandbox-runtime 0.1.0

package/_vendor/schemas/generated/selectModeIframeRpc.d.ts

@@ -0,0 +1,100 @@
+import type { DisplayMode, SelectModeSelectionType, SelectModeOptimisticUpdatePayload, SelectModeFormatCommand, SelectableData, SelectModeBoundingRect, SelectModeClickPosition, SelectModeSelectionRect, SelectModeTiptapActiveMarks } from "./selectMode.ts";
+export type SelectModeParentMessage = {
+    method: "setDisplayMode";
+    data: {
+        displayMode: DisplayMode;
+    };
+} | {
+    method: "setSelectionType";
+    data: {
+        selectionType: SelectModeSelectionType;
+    };
+} | {
+    method: "applyOptimisticUpdate";
+    data: {
+        editId: string;
+        payload: SelectModeOptimisticUpdatePayload;
+        targetSelector: string;
+        targetMode: "primary" | "group";
+    };
+} | {
+    method: "markCommitted";
+    data: {
+        editId: string;
+        sessionId: string;
+    };
+} | {
+    method: "resolveSessionOverrides";
+    data: {
+        sessionId: string;
+        outcome: "persisted" | "failed";
+    };
+} | {
+    method: "revertOverride";
+    data: {
+        editId: string;
+    };
+} | {
+    method: "enterEditMode";
+} | {
+    method: "exitEditMode";
+} | {
+    method: "formatCommand";
+    data: {
+        command: SelectModeFormatCommand;
+    };
+};
+export type SelectModeIframeMessage = {
+    method: "iframeReady";
+} | {
+    method: "elementSelected";
+    data: {
+        data: SelectableData;
+    };
+} | {
+    method: "hoverElement";
+    data: {
+        rect: SelectModeBoundingRect | null;
+    };
+} | {
+    method: "selectedElementRectUpdate";
+    data: {
+        rect: SelectModeBoundingRect;
+        clickPosition: SelectModeClickPosition;
+    };
+} | {
+    method: "selectedAreaRectUpdate";
+    data: {
+        rect: SelectModeBoundingRect;
+    };
+} | {
+    method: "dragRectUpdated";
+    data: {
+        dragRect: SelectModeBoundingRect | null;
+        selectionRects: SelectModeSelectionRect[];
+    };
+} | {
+    method: "areaSelected";
+    data: {
+        rect: SelectModeBoundingRect;
+        items: SelectableData[];
+    };
+} | {
+    method: "textCommitted";
+    data: {
+        editId: string;
+        html: string;
+        json: {
+            [x: string]: unknown;
+        };
+        originalInnerHTML: string;
+    };
+} | {
+    method: "editorStateUpdate";
+    data: {
+        activeMarks: SelectModeTiptapActiveMarks;
+        isEditing: boolean;
+    };
+} | {
+    method: "fastRefreshComplete";
+};

package/_vendor/schemas/generated/selectModeIframeRpc.mjs

@@ -0,0 +1 @@
+

package/_vendor/schemas/iframeRpcChannel.d.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+export type IframeRpcChannelMethodConfig = Record<string, {
+    inputSchema: z.ZodType;
+    outputSchema: z.ZodType;
+    timeoutMs?: number;
+}>;
+type MethodInput<Config extends IframeRpcChannelMethodConfig, Method extends keyof Config> = z.input<Config[Method]["inputSchema"]>;
+type MethodOutput<Config extends IframeRpcChannelMethodConfig, Method extends keyof Config> = z.output<Config[Method]["outputSchema"]>;
+type IsVoidMethod<Config extends IframeRpcChannelMethodConfig, Method extends keyof Config> = MethodOutput<Config, Method> extends void ? true : false;
+type CallResult<Config extends IframeRpcChannelMethodConfig, Method extends keyof Config> = IsVoidMethod<Config, Method> extends true ? void : Promise<MethodOutput<Config, Method>>;
+type MethodArgs<Config extends IframeRpcChannelMethodConfig, Method extends keyof Config> = undefined extends MethodInput<Config, Method> ? [input?: MethodInput<Config, Method>] : [input: MethodInput<Config, Method>];
+export type IframeRpcChannelRemote<Config extends IframeRpcChannelMethodConfig> = {
+    [Method in keyof Config]: (...args: MethodArgs<Config, Method>) => CallResult<Config, Method>;
+};
+export type IframeRpcChannelHandlerMeta<OutgoingMethods extends IframeRpcChannelMethodConfig> = {
+    channel: IframeRpcChannelRemote<OutgoingMethods>;
+};
+export type IframeRpcChannelHandlers<IncomingMethods extends IframeRpcChannelMethodConfig, OutgoingMethods extends IframeRpcChannelMethodConfig = IframeRpcChannelMethodConfig> = {
+    [Method in keyof IncomingMethods]: (input: z.output<IncomingMethods[Method]["inputSchema"]>, meta: IframeRpcChannelHandlerMeta<OutgoingMethods>) => IsVoidMethod<IncomingMethods, Method> extends true ? void : // Valued handlers stay `unknown` so callers can return domain/generated
+    unknown | Promise<unknown>;
+};
+export type IframeRpcChannelInputHandlers<IncomingMethods extends IframeRpcChannelMethodConfig> = {
+    [Method in keyof IncomingMethods]: (input: z.output<IncomingMethods[Method]["inputSchema"]>) => IsVoidMethod<IncomingMethods, Method> extends true ? void : unknown | Promise<unknown>;
+};
+export declare const iframeRpcCallSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"notify">;
+    method: z.ZodString;
+    data: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"request">;
+    id: z.ZodUUID;
+    method: z.ZodString;
+    data: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"response">;
+    id: z.ZodUUID;
+    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"success">;
+        data: z.ZodUnknown;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"error">;
+        errorMessage: z.ZodString;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>], "type">;
+export type IframeRpcCall = z.infer<typeof iframeRpcCallSchema>;
+type SubscriberWindow = {
+    addEventListener: (type: "message", listener: (event: MessageEvent) => void) => void;
+    removeEventListener: (type: "message", listener: (event: MessageEvent) => void) => void;
+};
+type TargetIframeWindow = {
+    postMessage: (message: unknown, targetOrigin: string) => void;
+};
+type IframeRpcChannelOptions<OutgoingMethods extends IframeRpcChannelMethodConfig, IncomingMethods extends IframeRpcChannelMethodConfig> = {
+    subscriberWindow: SubscriberWindow;
+    channelIdentifier: string;
+    version: number;
+    getTargetWindow: () => TargetIframeWindow | null;
+    targetOrigin: string;
+    isExpectedMessage: (event: MessageEvent) => boolean;
+    outgoingMethods: OutgoingMethods;
+    incomingMethods: IncomingMethods;
+    handlers: IframeRpcChannelHandlers<IncomingMethods, OutgoingMethods>;
+};
+export type IframeRpcChannel<OutgoingMethods extends IframeRpcChannelMethodConfig = IframeRpcChannelMethodConfig> = {
+    subscribe: () => () => void;
+    call: <Method extends keyof OutgoingMethods & string>(input: {
+        method: Method;
+        input: MethodInput<OutgoingMethods, Method>;
+    }) => CallResult<OutgoingMethods, Method>;
+    outgoingMethods: OutgoingMethods;
+};
+/**
+ * Flat method-per-key facade over `channel.call`. Prefer this at call sites
+ * over hand-writing `useMemo(() => ({ foo: (input) => channel.call(...) }))`.
+ *
+ * Pass a channel directly, or a getter (plus its method config) when the
+ * channel is created lazily / may be unavailable (e.g. SSR).
+ */
+export declare function createIframeRpcRemote<OutgoingMethods extends IframeRpcChannelMethodConfig>(channel: IframeRpcChannel<OutgoingMethods>): IframeRpcChannelRemote<OutgoingMethods>;
+export declare function createIframeRpcRemote<OutgoingMethods extends IframeRpcChannelMethodConfig>(getChannel: () => IframeRpcChannel<OutgoingMethods> | null, methods: OutgoingMethods): IframeRpcChannelRemote<OutgoingMethods>;
+export declare function createIframeRpcChannel<OutgoingMethods extends IframeRpcChannelMethodConfig, IncomingMethods extends IframeRpcChannelMethodConfig>(options: IframeRpcChannelOptions<OutgoingMethods, IncomingMethods>): IframeRpcChannel<OutgoingMethods>;
+export {};

package/_vendor/schemas/iframeRpcChannel.mjs

@@ -0,0 +1,520 @@
+import { isNullish } from '../../chunk-N5EI2MOZ.mjs';
+import '../../chunk-FNTGY7I5.mjs';
+import { v4 } from 'uuid';
+import { z } from 'zod';
+
+function randomUUID() {
+  return v4();
+}
+
+// ../replo-utils/lib/log.ts
+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",
+    // Agent Billing ONLY
+    "agentBilling.shopifyThemeBuilder.publishedElements.exceeded",
+    "agentBilling.shopifyThemeBuilder.projects.exceeded",
+    "agentBilling.sites.exceeded",
+    "agentBilling.credits.exceeded",
+    "agentBilling.upgradeRequired"
+  ]),
+  message: z.string(),
+  isRecoverable: z.boolean().optional(),
+  // NOTE (Matt 2024-03-22): We support detail being an array of strings
+  // in FullPageModal only.
+  detail: z.array(z.string()).or(z.string()).optional(),
+  key: z.string(),
+  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", [
+  /**
+   * Normal errors, show error UI depending on the type
+   */
+  errorUserFacingDetailsMessageSchema,
+  /**
+   * Errors which should be ignored by the frontend. This is uncommon, usually
+   * you want to show an error in the UI, and if you don't want to then you catch
+   * the error in your route.
+   */
+  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 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 }
+    });
+  }
+};
+
+// ../schemas/iframeRpcChannel.ts
+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) => {
+    getTargetWindow()?.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[
+        // eslint-disable-next-line replo/no-as-cast -- NOTE (Noah, 2026-07-25): The method existence check above narrows this dynamic wire string to the configured handler keys.
+        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[
+      // eslint-disable-next-line replo/no-as-cast -- NOTE (Noah, 2026-08-07): Method existence check narrows this wire string to configured handler keys.
+      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) => {
+    if (!isExpectedMessage(event)) {
+      return;
+    }
+    const parsedMetadata = z.object({
+      channelIdentifier: z.literal(channelIdentifier),
+      version: z.literal(version)
+    }).safeParse(event.data);
+    if (!parsedMetadata.success) {
+      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 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,
+          // PendingRequest is shared across methods, so resolve is typed as
+          // unknown; handleResponse already validated against this method's
+          // outputSchema before calling it.
+          resolve: (value) => {
+            resolve(value);
+          },
+          reject,
+          timeoutId
+        });
+        postMessage({
+          type: "request",
+          id,
+          method,
+          data: parsedInput.data
+        });
+      }
+    );
+  };
+  const channel = {
+    subscribe,
+    call,
+    outgoingMethods
+  };
+  handlerMeta = { channel: createIframeRpcRemote(channel) };
+  return channel;
+}
+
+export { createIframeRpcChannel, createIframeRpcRemote, iframeRpcCallSchema };