sandlot 0.2.0 → 0.2.2

package/dist/browser/bundler.d.ts

@@ -62,6 +62,14 @@ export declare class EsbuildWasmBundler implements IBundler {
      * Get the initialized esbuild instance.
      */
     private getEsbuild;
+    /**
+     * Dispose of the esbuild WASM service.
+     * This stops the esbuild service and allows the process to exit.
+     *
+     * Note: Since esbuild-wasm uses a global singleton, this affects all
+     * instances. After dispose(), you'll need to create a new bundler.
+     */
+    dispose(): Promise<void>;
     private checkCrossOriginIsolation;
     bundle(options: BundleOptions): Promise<BundleResult>;
 }

package/dist/browser/bundler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundler.d.ts","sourceRoot":"","sources":["../../src/browser/bundler.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EACb,YAAY,EAGb,MAAM,UAAU,CAAC;AAuClB,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,kBAAmB,YAAW,QAAQ;IACjD,OAAO,CAAC,OAAO,CAA4B;gBAE/B,OAAO,GAAE,yBAA8B;IAWnD;;;;;;OAMG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAmBnB,YAAY;IA8B1B;;OAEG;IACH,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,yBAAyB;IAc3B,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAoG5D"}
+{"version":3,"file":"bundler.d.ts","sourceRoot":"","sources":["../../src/browser/bundler.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EACb,YAAY,EAGb,MAAM,UAAU,CAAC;AAuClB,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,kBAAmB,YAAW,QAAQ;IACjD,OAAO,CAAC,OAAO,CAA4B;gBAE/B,OAAO,GAAE,yBAA8B;IAWnD;;;;;;OAMG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAmBnB,YAAY;IA8B1B;;OAEG;IACH,OAAO,CAAC,UAAU;IAQlB;;;;;;OAMG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAU9B,OAAO,CAAC,yBAAyB;IAc3B,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAoG5D"}

package/dist/browser/iframe-executor.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Iframe executor for browser environments.
+ *
+ * This executor runs code in a sandboxed iframe, providing DOM isolation
+ * and configurable security policies via the sandbox attribute.
+ *
+ * Key characteristics:
+ * - Per-execution lifecycle: fresh iframe for each execute() call
+ * - Configurable sandbox attributes (default: allow-scripts only)
+ * - No shared module support (use MainThreadExecutor for that)
+ * - Communication via postMessage
+ */
+import type { IExecutor, ExecuteOptions, ExecuteResult } from "../types";
+/**
+ * Options for creating an IframeExecutor.
+ */
+export interface IframeExecutorOptions {
+    /**
+     * Sandbox attributes for the iframe.
+     * @default ["allow-scripts"]
+     *
+     * Common options:
+     * - "allow-scripts": Required for code execution
+     * - "allow-same-origin": Enables localStorage, cookies (reduces isolation)
+     * - "allow-modals": Enables alert/confirm/prompt
+     *
+     * Security note: "allow-scripts" + "allow-same-origin" together allows
+     * the iframe code to potentially remove the sandbox via script.
+     */
+    sandbox?: string[];
+    /**
+     * Default timeout in milliseconds.
+     * @default 30000
+     */
+    defaultTimeout?: number;
+    /**
+     * Container element for iframes.
+     * Iframes are created hidden (display: none).
+     * @default document.body
+     */
+    container?: HTMLElement;
+}
+/**
+ * Executor that runs code in a sandboxed iframe.
+ *
+ * Each execute() call creates a fresh iframe, runs the code, and destroys
+ * the iframe. This provides clean isolation between executions.
+ *
+ * Note: This executor does NOT support shared modules. The iframe runs
+ * in complete isolation. Use MainThreadExecutor if you need shared modules.
+ *
+ * @example
+ * ```ts
+ * // Default: strict sandboxing (allow-scripts only)
+ * const executor = createIframeExecutor();
+ *
+ * // With additional permissions
+ * const executor = createIframeExecutor({
+ *   sandbox: ["allow-scripts", "allow-same-origin"],
+ * });
+ *
+ * const result = await executor.execute(bundledCode, {
+ *   entryExport: 'main',
+ *   context: { args: ['--verbose'] },
+ *   timeout: 5000,
+ * });
+ * console.log(result.logs);
+ * ```
+ */
+export declare class IframeExecutor implements IExecutor {
+    private options;
+    constructor(options?: IframeExecutorOptions);
+    execute(code: string, options?: ExecuteOptions): Promise<ExecuteResult>;
+}
+/**
+ * Create an iframe executor.
+ *
+ * @param options - Executor options
+ * @returns A new IframeExecutor instance
+ */
+export declare function createIframeExecutor(options?: IframeExecutorOptions): IframeExecutor;
+//# sourceMappingURL=iframe-executor.d.ts.map

package/dist/browser/iframe-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iframe-executor.d.ts","sourceRoot":"","sources":["../../src/browser/iframe-executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzE;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;OAIG;IACH,SAAS,CAAC,EAAE,WAAW,CAAC;CACzB;AAmID;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,cAAe,YAAW,SAAS;IAC9C,OAAO,CAAC,OAAO,CAEb;gBAEU,OAAO,GAAE,qBAA0B;IAQzC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,aAAa,CAAC;CA2FlF;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,CAAC,EAAE,qBAAqB,GAC9B,cAAc,CAEhB"}

package/dist/browser/index.d.ts

@@ -2,8 +2,10 @@ export { Typechecker, createTypechecker } from "../core/typechecker";
 export type { TypecheckerOptions } from "../core/typechecker";
 export { EsbuildWasmBundler } from "./bundler";
 export type { EsbuildWasmBundlerOptions } from "./bundler";
-export { MainThreadExecutor, createMainThreadExecutor } from "./executor";
-export type { MainThreadExecutorOptions } from "./executor";
+export { MainThreadExecutor, createMainThreadExecutor } from "./main-thread-executor";
+export type { MainThreadExecutorOptions } from "./main-thread-executor";
+export { IframeExecutor, createIframeExecutor } from "./iframe-executor";
+export type { IframeExecutorOptions } from "./iframe-executor";
 export { createBrowserSandlot } from "./preset";
 export type { CreateBrowserSandlotOptions } from "./preset";
 //# sourceMappingURL=index.d.ts.map

package/dist/browser/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/browser/index.ts"],"names":[],"mappings":"AAkCA,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACrE,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAM9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,YAAY,EAAE,yBAAyB,EAAE,MAAM,WAAW,CAAC;AAM3D,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAC1E,YAAY,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAM5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAChD,YAAY,EAAE,2BAA2B,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/browser/index.ts"],"names":[],"mappings":"AAkCA,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACrE,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAM9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,YAAY,EAAE,yBAAyB,EAAE,MAAM,WAAW,CAAC;AAM3D,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AACtF,YAAY,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAMxE,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzE,YAAY,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAM/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAChD,YAAY,EAAE,2BAA2B,EAAE,MAAM,UAAU,CAAC"}

package/dist/browser/index.js

@@ -232,8 +232,9 @@ function parseTsConfig(fs, configPath) {
       }
     };
     const parsed = ts.parseJsonConfigFileContent(config, parseHost, "/", undefined, configPath);
-    if (parsed.errors.length > 0) {
-      console.warn("[typechecker] tsconfig parse errors:", parsed.errors.map((e) => e.messageText));
+    const relevantErrors = parsed.errors.filter((e) => e.code !== 18003);
+    if (relevantErrors.length > 0) {
+      console.warn("[typechecker] tsconfig parse errors:", relevantErrors.map((e) => e.messageText));
     }
     return {
       ...parsed.options,
@@ -707,6 +708,15 @@ class EsbuildWasmBundler {
     }
     return state.esbuild;
   }
+  async dispose() {
+    const state = getGlobalState();
+    if (state.esbuild) {
+      await state.esbuild.stop();
+      state.esbuild = null;
+      state.initialized = false;
+      state.initPromise = null;
+    }
+  }
   checkCrossOriginIsolation() {
     if (typeof window === "undefined")
       return;
@@ -812,23 +822,18 @@ function createBasicExecutor(loadModule, options = {}) {
       const formatArgs = (...args) => args.map((v) => typeof v === "object" ? JSON.stringify(v) : String(v)).join(" ");
       const captureLog = (...args) => {
         logs.push(formatArgs(...args));
-        originalConsole.log.apply(console, args);
       };
       const captureWarn = (...args) => {
         logs.push(`[warn] ${formatArgs(...args)}`);
-        originalConsole.warn.apply(console, args);
       };
       const captureError = (...args) => {
         logs.push(`[error] ${formatArgs(...args)}`);
-        originalConsole.error.apply(console, args);
       };
       const captureInfo = (...args) => {
         logs.push(`[info] ${formatArgs(...args)}`);
-        originalConsole.info.apply(console, args);
       };
       const captureDebug = (...args) => {
         logs.push(`[debug] ${formatArgs(...args)}`);
-        originalConsole.debug.apply(console, args);
       };
       const restoreConsole = () => {
         console.log = originalConsole.log;
@@ -855,10 +860,16 @@ function createBasicExecutor(loadModule, options = {}) {
           }
         };
         if (timeout > 0) {
+          let timeoutId;
           const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => reject(new Error(`Execution timed out after ${timeout}ms`)), timeout);
+            timeoutId = setTimeout(() => reject(new Error(`Execution timed out after ${timeout}ms`)), timeout);
           });
-          await Promise.race([executeExport(), timeoutPromise]);
+          try {
+            await Promise.race([executeExport(), timeoutPromise]);
+          } finally {
+            if (timeoutId)
+              clearTimeout(timeoutId);
+          }
         } else {
           await executeExport();
         }
@@ -884,7 +895,7 @@ function createBasicExecutor(loadModule, options = {}) {
   };
 }
 
-// src/browser/executor.ts
+// src/browser/main-thread-executor.ts
 async function loadModuleFromBlobUrl(code) {
   const blob = new Blob([code], { type: "application/javascript" });
   const url = URL.createObjectURL(blob);
@@ -905,6 +916,182 @@ class MainThreadExecutor {
 function createMainThreadExecutor(options) {
   return new MainThreadExecutor(options);
 }
+// src/browser/iframe-executor.ts
+var BOOTSTRAP_HTML = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+</head>
+<body>
+<script type="module">
+// Capture console methods and forward to parent
+function formatArgs(...args) {
+  return args
+    .map(v => typeof v === "object" ? JSON.stringify(v) : String(v))
+    .join(" ");
+}
+
+function createLogger(level) {
+  return (...args) => {
+    parent.postMessage({ type: "log", level, args: formatArgs(...args) }, "*");
+  };
+}
+
+console.log = createLogger("log");
+console.warn = createLogger("warn");
+console.error = createLogger("error");
+console.info = createLogger("info");
+console.debug = createLogger("debug");
+
+// Handle unhandled promise rejections
+window.addEventListener("unhandledrejection", (event) => {
+  const message = event.reason instanceof Error 
+    ? event.reason.message 
+    : String(event.reason);
+  parent.postMessage({ 
+    type: "result", 
+    success: false, 
+    error: "Unhandled promise rejection: " + message 
+  }, "*");
+});
+
+// Handle uncaught errors
+window.addEventListener("error", (event) => {
+  parent.postMessage({ 
+    type: "result", 
+    success: false, 
+    error: event.message || "Unknown error" 
+  }, "*");
+});
+
+// Listen for execute messages from parent
+window.addEventListener("message", async (event) => {
+  if (event.data?.type !== "execute") return;
+
+  const { code, entryExport, context } = event.data;
+
+  try {
+    // Create Blob URL and import as ESM module
+    const blob = new Blob([code], { type: "application/javascript" });
+    const url = URL.createObjectURL(blob);
+    
+    let module;
+    try {
+      module = await import(url);
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+
+    // Execute the appropriate export
+    let returnValue;
+
+    if (entryExport === "main" && typeof module.main === "function") {
+      returnValue = await module.main(context);
+    } else if (entryExport === "default" && typeof module.default === "function") {
+      returnValue = await module.default();
+    } else if (entryExport === "default" && module.default !== undefined) {
+      returnValue = module.default;
+    }
+    // If neither export exists, top-level code already ran on import
+
+    parent.postMessage({ type: "result", success: true, returnValue }, "*");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    parent.postMessage({ type: "result", success: false, error: message }, "*");
+  }
+});
+
+// Signal that we're ready to receive code
+parent.postMessage({ type: "ready" }, "*");
+</script>
+</body>
+</html>`;
+
+class IframeExecutor {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      sandbox: options.sandbox ?? ["allow-scripts"],
+      defaultTimeout: options.defaultTimeout ?? 30000,
+      container: options.container
+    };
+  }
+  async execute(code, options = {}) {
+    const {
+      entryExport = "main",
+      context = {},
+      timeout = this.options.defaultTimeout
+    } = options;
+    const startTime = performance.now();
+    const logs = [];
+    const container = this.options.container ?? document.body;
+    const iframe = document.createElement("iframe");
+    iframe.style.display = "none";
+    iframe.sandbox.add(...this.options.sandbox);
+    iframe.srcdoc = BOOTSTRAP_HTML;
+    let resolved = false;
+    return new Promise((resolve) => {
+      const cleanup = () => {
+        if (iframe.parentNode) {
+          iframe.parentNode.removeChild(iframe);
+        }
+        window.removeEventListener("message", handleMessage);
+        if (timeoutId)
+          clearTimeout(timeoutId);
+      };
+      const finish = (result) => {
+        if (resolved)
+          return;
+        resolved = true;
+        cleanup();
+        resolve(result);
+      };
+      const handleMessage = (event) => {
+        if (event.source !== iframe.contentWindow)
+          return;
+        const data = event.data;
+        if (data.type === "log") {
+          const prefix = data.level === "log" ? "" : `[${data.level}] `;
+          logs.push(prefix + data.args);
+        } else if (data.type === "result") {
+          const executionTimeMs = performance.now() - startTime;
+          finish({
+            success: data.success,
+            logs,
+            returnValue: data.returnValue,
+            error: data.error,
+            executionTimeMs
+          });
+        } else if (data.type === "ready") {
+          const message = {
+            type: "execute",
+            code,
+            entryExport,
+            context
+          };
+          iframe.contentWindow?.postMessage(message, "*");
+        }
+      };
+      let timeoutId;
+      if (timeout > 0) {
+        timeoutId = setTimeout(() => {
+          const executionTimeMs = performance.now() - startTime;
+          finish({
+            success: false,
+            logs,
+            error: `Execution timed out after ${timeout}ms`,
+            executionTimeMs
+          });
+        }, timeout);
+      }
+      window.addEventListener("message", handleMessage);
+      container.appendChild(iframe);
+    });
+  }
+}
+function createIframeExecutor(options) {
+  return new IframeExecutor(options);
+}
 // src/core/shared-module-registry.ts
 var instanceCounter = 0;
 function generateInstanceId() {
@@ -1606,6 +1793,37 @@ ${padding}^`;
 
 `);
 }
+function formatBuildFailure(failure, prefix = "Build failed") {
+  switch (failure.phase) {
+    case "entry":
+      return `${prefix}: ${failure.message}
+`;
+    case "typecheck":
+      if (failure.diagnostics && failure.diagnostics.length > 0) {
+        const errors = failure.diagnostics.filter((d) => d.severity === "error");
+        if (errors.length > 0) {
+          return `${prefix}: Type check errors
+
+${formatDiagnostics(errors)}
+`;
+        }
+      }
+      return `${prefix}: Type check errors
+`;
+    case "bundle":
+      if (failure.bundleErrors && failure.bundleErrors.length > 0) {
+        return `${prefix}: Bundle errors
+
+${formatBundleErrors(failure.bundleErrors)}
+`;
+      }
+      return `${prefix}: Bundle error
+`;
+    default:
+      return `${prefix}: Unknown error
+`;
+  }
+}
 // src/commands/index.ts
 function createSandlotCommand(sandboxRef) {
   return defineCommand("sandlot", async (args, ctx) => {
@@ -1716,42 +1934,9 @@ Examples:
     format
   });
   if (!result.success) {
-    let stderr = `Build failed`;
-    switch (result.phase) {
-      case "entry":
-        stderr = `Build failed: ${result.message}
-`;
-        break;
-      case "typecheck":
-        if (result.diagnostics) {
-          const errors = result.diagnostics.filter((d) => d.severity === "error");
-          stderr = `Build failed: Type check errors
-
-${formatDiagnostics(errors)}
-`;
-        } else {
-          stderr = `Build failed: Type check errors
-`;
-        }
-        break;
-      case "bundle":
-        if (result.bundleErrors && result.bundleErrors.length > 0) {
-          stderr = `Build failed: Bundle errors
-
-${formatBundleErrors(result.bundleErrors)}
-`;
-        } else {
-          stderr = `Build failed: Bundle error
-`;
-        }
-        break;
-      default:
-        stderr = `Build failed: Unknown error
-`;
-    }
     return {
       stdout: "",
-      stderr,
+      stderr: formatBuildFailure(result),
       exitCode: 1
     };
   }
@@ -1815,18 +2000,20 @@ Examples:
       const formatted = formatDiagnostics(errors);
       return {
         stdout: "",
-        stderr: `Type check failed:
+        stderr: `Type check failed
+
 ${formatted}
 `,
         exitCode: 1
       };
     }
     const warnings = result.diagnostics.filter((d) => d.severity === "warning");
-    let output = `Type check passed.
+    let output = `Type check passed
 `;
     if (warnings.length > 0) {
       output += `
 Warnings:
+
 ${formatDiagnostics(warnings)}
 `;
     }
@@ -2001,13 +2188,7 @@ Examples:
     if (!result.success) {
       let stderr = "";
       if (result.buildFailure) {
-        stderr = `Run failed: Build error in ${result.buildFailure.phase} phase`;
-        if (result.buildFailure.message) {
-          stderr += `
-${result.buildFailure.message}`;
-        }
-        stderr += `
-`;
+        stderr = formatBuildFailure(result.buildFailure, "Run failed");
       } else {
         stderr = `Run failed: ${result.error ?? "Unknown error"}
 `;
@@ -2354,7 +2535,10 @@ async function createSandboxImpl(fs, options, context) {
         error: buildResult.message ?? `Build failed in ${buildResult.phase} phase`,
         buildFailure: {
           phase: buildResult.phase,
-          message: buildResult.message
+          message: buildResult.message,
+          diagnostics: buildResult.diagnostics,
+          bundleErrors: buildResult.bundleErrors,
+          bundleWarnings: buildResult.bundleWarnings
         }
       };
     }
@@ -2452,6 +2636,11 @@ function createSandlot(options) {
     },
     get sharedModules() {
       return sharedModuleRegistry;
+    },
+    async dispose() {
+      if (bundler.dispose) {
+        await bundler.dispose();
+      }
     }
   };
 }
@@ -2649,7 +2838,7 @@ async function createBrowserSandlot(options = {}) {
   await bundlerInstance.initialize();
   const typecheckerInstance = typechecker === false ? undefined : isTypechecker(typechecker) ? typechecker : new Typechecker(typechecker);
   const typesResolverInstance = typesResolver === false ? undefined : isTypesResolver(typesResolver) ? typesResolver : new EsmTypesResolver(typesResolver);
-  const executorInstance = executor === false ? undefined : isExecutor(executor) ? executor : new MainThreadExecutor(executor);
+  const executorInstance = executor === false ? undefined : executor === "iframe" ? new IframeExecutor : isExecutor(executor) ? executor : isIframeExecutorOptions(executor) ? new IframeExecutor(executor) : new MainThreadExecutor(executor);
   return createSandlot({
     ...rest,
     bundler: bundlerInstance,
@@ -2670,6 +2859,9 @@ function isTypesResolver(value) {
 function isExecutor(value) {
   return typeof value === "object" && value !== null && "execute" in value && typeof value.execute === "function";
 }
+function isIframeExecutorOptions(value) {
+  return typeof value === "object" && value !== null && (("sandbox" in value) || ("container" in value));
+}
 
 // src/browser/index.ts
 if (typeof window !== "undefined" && typeof globalThis.process === "undefined") {
@@ -2685,8 +2877,10 @@ if (typeof window !== "undefined" && typeof globalThis.process === "undefined")
 export {
   createTypechecker,
   createMainThreadExecutor,
+  createIframeExecutor,
   createBrowserSandlot,
   Typechecker,
   MainThreadExecutor,
+  IframeExecutor,
   EsbuildWasmBundler
 };

package/dist/browser/main-thread-executor.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Main thread executor for browser environments.
+ *
+ * This executor runs code directly in the main thread. It provides no
+ * isolation from the host environment - use only for trusted code.
+ *
+ * For untrusted code, consider using a Worker or iframe-based executor
+ * that provides proper sandboxing.
+ */
+import type { IExecutor } from "../types";
+import { type BasicExecutorOptions } from "../core/executor";
+/**
+ * Options for creating a MainThreadExecutor.
+ */
+export type MainThreadExecutorOptions = BasicExecutorOptions;
+/**
+ * Executor that runs code in the main browser thread.
+ *
+ * WARNING: This executor provides NO isolation. The executed code has
+ * full access to the page's DOM, global variables, and network.
+ * Only use for trusted code (e.g., code you're developing).
+ *
+ * @example
+ * ```ts
+ * const executor = createMainThreadExecutor();
+ * const result = await executor.execute(bundledCode, {
+ *   entryExport: 'main',
+ *   context: { args: ['--verbose'] },
+ *   timeout: 5000,
+ * });
+ * console.log(result.logs);
+ * ```
+ */
+export declare class MainThreadExecutor implements IExecutor {
+    private executor;
+    constructor(options?: MainThreadExecutorOptions);
+    execute: IExecutor["execute"];
+}
+/**
+ * Create a main thread executor.
+ *
+ * @param options - Executor options
+ * @returns A new MainThreadExecutor instance
+ */
+export declare function createMainThreadExecutor(options?: MainThreadExecutorOptions): MainThreadExecutor;
+//# sourceMappingURL=main-thread-executor.d.ts.map

package/dist/browser/main-thread-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main-thread-executor.d.ts","sourceRoot":"","sources":["../../src/browser/main-thread-executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAuB,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAElF;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG,oBAAoB,CAAC;AAgB7D;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,kBAAmB,YAAW,SAAS;IAClD,OAAO,CAAC,QAAQ,CAAY;gBAEhB,OAAO,GAAE,yBAA8B;IAInD,OAAO,EAAE,SAAS,CAAC,SAAS,CAAC,CAA+C;CAC7E;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,CAAC,EAAE,yBAAyB,GAClC,kBAAkB,CAEpB"}

package/dist/browser/preset.d.ts

@@ -2,7 +2,8 @@ import { type EsmTypesResolverOptions } from "../core/esm-types-resolver";
 import type { Sandlot, SandlotOptions } from "../types";
 import { type EsbuildWasmBundlerOptions } from "./bundler";
 import { type TypecheckerOptions } from "../core/typechecker";
-import { type MainThreadExecutorOptions } from "./executor";
+import { type MainThreadExecutorOptions } from "./main-thread-executor";
+import { type IframeExecutorOptions } from "./iframe-executor";
 export interface CreateBrowserSandlotOptions extends Omit<SandlotOptions, "bundler" | "typechecker" | "typesResolver" | "executor"> {
     /**
      * Custom bundler options, or a pre-configured bundler instance.
@@ -21,9 +22,13 @@ export interface CreateBrowserSandlotOptions extends Omit<SandlotOptions, "bundl
     /**
      * Custom executor options, or a pre-configured executor instance.
      * Set to `false` to disable execution (sandbox.run() will throw).
+     * Set to `"iframe"` to use IframeExecutor with default options.
      * Defaults to MainThreadExecutor.
+     *
+     * Note: IframeExecutor does NOT support shared modules. Use MainThreadExecutor
+     * (the default) if you need shared modules like React.
      */
-    executor?: MainThreadExecutorOptions | SandlotOptions["executor"] | false;
+    executor?: MainThreadExecutorOptions | IframeExecutorOptions | SandlotOptions["executor"] | "iframe" | false;
 }
 /**
  * Create a Sandlot instance pre-configured for browser environments.

package/dist/browser/preset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preset.d.ts","sourceRoot":"","sources":["../../src/browser/preset.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AACxD,OAAO,EAAsB,KAAK,yBAAyB,EAAE,MAAM,WAAW,CAAC;AAC/E,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAEL,KAAK,yBAAyB,EAC/B,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,2BACf,SAAQ,IAAI,CAAC,cAAc,EAAE,SAAS,GAAG,aAAa,GAAG,eAAe,GAAG,UAAU,CAAC;IACtF;;OAEG;IACH,OAAO,CAAC,EAAE,yBAAyB,GAAG,cAAc,CAAC,SAAS,CAAC,CAAC;IAEhE;;;OAGG;IACH,WAAW,CAAC,EACV,kBAAkB,GAClB,cAAc,CAAC,aAAa,CAAC,GAC7B,KAAK,CAAC;IAER;;;OAGG;IACH,aAAa,CAAC,EACZ,uBAAuB,GACvB,cAAc,CAAC,eAAe,CAAC,GAC/B,KAAK,CAAC;IAER;;;;OAIG;IACH,QAAQ,CAAC,EACP,yBAAyB,GACzB,cAAc,CAAC,UAAU,CAAC,GAC1B,KAAK,CAAC;CACT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,OAAO,CAAC,CAgDlB"}
+{"version":3,"file":"preset.d.ts","sourceRoot":"","sources":["../../src/browser/preset.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AACxD,OAAO,EAAsB,KAAK,yBAAyB,EAAE,MAAM,WAAW,CAAC;AAC/E,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAEL,KAAK,yBAAyB,EAC/B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,2BACf,SAAQ,IAAI,CAAC,cAAc,EAAE,SAAS,GAAG,aAAa,GAAG,eAAe,GAAG,UAAU,CAAC;IACtF;;OAEG;IACH,OAAO,CAAC,EAAE,yBAAyB,GAAG,cAAc,CAAC,SAAS,CAAC,CAAC;IAEhE;;;OAGG;IACH,WAAW,CAAC,EACV,kBAAkB,GAClB,cAAc,CAAC,aAAa,CAAC,GAC7B,KAAK,CAAC;IAER;;;OAGG;IACH,aAAa,CAAC,EACZ,uBAAuB,GACvB,cAAc,CAAC,eAAe,CAAC,GAC/B,KAAK,CAAC;IAER;;;;;;;;OAQG;IACH,QAAQ,CAAC,EACP,yBAAyB,GACzB,qBAAqB,GACrB,cAAc,CAAC,UAAU,CAAC,GAC1B,QAAQ,GACR,KAAK,CAAC;CACT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,OAAO,CAAC,CAoDlB"}

package/dist/commands/index.d.ts

@@ -10,7 +10,7 @@
  */
 import type { SandboxRef } from "./types";
 export type { SandboxRef } from "./types";
-export { formatSize, formatDiagnostics, formatBundleErrors } from "./types";
+export { formatSize, formatDiagnostics, formatBundleErrors, formatBuildFailure, } from "./types";
 /**
  * Create the main `sandlot` command with all subcommands.
  *

package/dist/commands/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE5E;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,UAAU,uCAuC1D;AAkdD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,UAAU,yCAE3D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,SAAS,CAAC;AAEjB;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,UAAU,uCAuC1D;AAubD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,UAAU,yCAE3D"}