sandlot 0.1.3 → 0.2.0

package/dist/node/index.js

@@ -0,0 +1,2646 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/core/bundler-utils.ts
+function isEsbuildBuildFailure(err) {
+  return typeof err === "object" && err !== null && "errors" in err && Array.isArray(err.errors);
+}
+function convertEsbuildMessage(msg) {
+  let location;
+  if (msg.location) {
+    location = {
+      file: msg.location.file,
+      line: msg.location.line,
+      column: msg.location.column,
+      lineText: msg.location.lineText
+    };
+  }
+  return {
+    text: msg.text,
+    location
+  };
+}
+function getRegistryKey(registry) {
+  return registry?.registryKey ?? null;
+}
+function createVfsPlugin(options) {
+  const {
+    fs,
+    entryPoint,
+    installedPackages,
+    sharedModules,
+    sharedModuleRegistry,
+    cdnBaseUrl,
+    includedFiles,
+    bundleCdnImports = false
+  } = options;
+  return {
+    name: "sandlot-vfs",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, async (args) => {
+        if (args.namespace === "http") {
+          return;
+        }
+        if (args.kind === "entry-point") {
+          return { path: entryPoint, namespace: "vfs" };
+        }
+        if (args.path.startsWith("http://") || args.path.startsWith("https://")) {
+          if (bundleCdnImports) {
+            return { path: args.path, namespace: "http" };
+          }
+          return { path: args.path, external: true };
+        }
+        if (isBareImport(args.path)) {
+          const sharedMatch = matchSharedModule(args.path, sharedModules);
+          if (sharedMatch) {
+            return { path: sharedMatch, namespace: "sandlot-shared" };
+          }
+          const cdnUrl = resolveToEsmUrl(args.path, installedPackages, cdnBaseUrl);
+          if (cdnUrl) {
+            if (bundleCdnImports) {
+              return { path: cdnUrl, namespace: "http" };
+            }
+            return { path: cdnUrl, external: true };
+          }
+          return { path: args.path, external: true };
+        }
+        const resolved = resolveVfsPath(fs, args.resolveDir, args.path);
+        if (resolved) {
+          return { path: resolved, namespace: "vfs" };
+        }
+        return {
+          errors: [{ text: `Cannot resolve: ${args.path} from ${args.resolveDir}` }]
+        };
+      });
+      build.onLoad({ filter: /.*/, namespace: "vfs" }, async (args) => {
+        try {
+          const contents = fs.readFile(args.path);
+          includedFiles.add(args.path);
+          return {
+            contents,
+            loader: getLoader(args.path),
+            resolveDir: dirname(args.path)
+          };
+        } catch (err) {
+          return {
+            errors: [{ text: `Failed to read ${args.path}: ${err}` }]
+          };
+        }
+      });
+      build.onLoad({ filter: /.*/, namespace: "sandlot-shared" }, (args) => {
+        const moduleId = args.path;
+        const runtimeCode = generateSharedModuleCode(moduleId, sharedModuleRegistry);
+        return {
+          contents: runtimeCode,
+          loader: "js"
+        };
+      });
+      if (bundleCdnImports) {
+        build.onResolve({ filter: /.*/, namespace: "http" }, (args) => {
+          const importerUrl = args.importer;
+          if (args.path.startsWith("node:")) {
+            return { path: args.path, external: true };
+          }
+          if (args.path.startsWith("http://") || args.path.startsWith("https://")) {
+            return { path: args.path, namespace: "http" };
+          }
+          if (args.path.startsWith("/")) {
+            const origin = new URL(importerUrl).origin;
+            return { path: origin + args.path, namespace: "http" };
+          }
+          if (args.path.startsWith(".")) {
+            const resolved = new URL(args.path, importerUrl).href;
+            return { path: resolved, namespace: "http" };
+          }
+          const cdnUrl = resolveToEsmUrl(args.path, installedPackages, cdnBaseUrl);
+          if (cdnUrl) {
+            return { path: cdnUrl, namespace: "http" };
+          }
+          const fallbackUrl = `${cdnBaseUrl}/${args.path}`;
+          return { path: fallbackUrl, namespace: "http" };
+        });
+        build.onLoad({ filter: /.*/, namespace: "http" }, async (args) => {
+          try {
+            const response = await fetch(args.path);
+            if (!response.ok) {
+              return {
+                errors: [{ text: `Failed to fetch ${args.path}: ${response.status} ${response.statusText}` }]
+              };
+            }
+            const contents = await response.text();
+            const loader = getLoaderFromUrl(args.path);
+            return {
+              contents,
+              loader
+            };
+          } catch (err) {
+            return {
+              errors: [{ text: `Failed to fetch ${args.path}: ${err}` }]
+            };
+          }
+        });
+      }
+    }
+  };
+}
+function getLoaderFromUrl(url) {
+  try {
+    const pathname = new URL(url).pathname;
+    return getLoader(pathname);
+  } catch {
+    return "js";
+  }
+}
+function isBareImport(path) {
+  return !path.startsWith(".") && !path.startsWith("/");
+}
+function matchSharedModule(importPath, sharedModules) {
+  if (sharedModules.has(importPath)) {
+    return importPath;
+  }
+  for (const moduleId of sharedModules) {
+    if (importPath.startsWith(moduleId + "/")) {
+      if (sharedModules.has(importPath)) {
+        return importPath;
+      }
+    }
+  }
+  return null;
+}
+function parseImportPath(importPath) {
+  if (importPath.startsWith("@")) {
+    const parts = importPath.split("/");
+    if (parts.length >= 2) {
+      const packageName = `${parts[0]}/${parts[1]}`;
+      const subpath = parts.length > 2 ? parts.slice(2).join("/") : undefined;
+      return { packageName, subpath };
+    }
+    return { packageName: importPath };
+  }
+  const slashIndex = importPath.indexOf("/");
+  if (slashIndex === -1) {
+    return { packageName: importPath };
+  }
+  return {
+    packageName: importPath.slice(0, slashIndex),
+    subpath: importPath.slice(slashIndex + 1)
+  };
+}
+function resolveToEsmUrl(importPath, installedPackages, cdnBaseUrl) {
+  const { packageName, subpath } = parseImportPath(importPath);
+  const version = installedPackages[packageName];
+  if (!version) {
+    return null;
+  }
+  const baseUrl = `${cdnBaseUrl}/${packageName}@${version}`;
+  return subpath ? `${baseUrl}/${subpath}` : baseUrl;
+}
+function resolveVfsPath(fs, resolveDir, importPath) {
+  const resolved = resolvePath(resolveDir, importPath);
+  const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".json"];
+  const hasExtension = extensions.some((ext) => resolved.endsWith(ext));
+  if (hasExtension) {
+    if (fs.exists(resolved)) {
+      return resolved;
+    }
+    return null;
+  }
+  for (const ext of extensions) {
+    const withExt = resolved + ext;
+    if (fs.exists(withExt)) {
+      return withExt;
+    }
+  }
+  for (const ext of extensions) {
+    const indexPath = `${resolved}/index${ext}`;
+    if (fs.exists(indexPath)) {
+      return indexPath;
+    }
+  }
+  return null;
+}
+function resolvePath(from, to) {
+  if (to.startsWith("/")) {
+    return normalizePath(to);
+  }
+  const fromParts = from.split("/").filter(Boolean);
+  const toParts = to.split("/");
+  const result = [...fromParts];
+  for (const part of toParts) {
+    if (part === "." || part === "") {
+      continue;
+    } else if (part === "..") {
+      result.pop();
+    } else {
+      result.push(part);
+    }
+  }
+  return "/" + result.join("/");
+}
+function normalizePath(path) {
+  const parts = path.split("/").filter(Boolean);
+  const result = [];
+  for (const part of parts) {
+    if (part === ".") {
+      continue;
+    } else if (part === "..") {
+      result.pop();
+    } else {
+      result.push(part);
+    }
+  }
+  return "/" + result.join("/");
+}
+function dirname(path) {
+  const lastSlash = path.lastIndexOf("/");
+  if (lastSlash <= 0)
+    return "/";
+  return path.slice(0, lastSlash);
+}
+function getLoader(path) {
+  const ext = path.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "ts":
+      return "ts";
+    case "tsx":
+      return "tsx";
+    case "jsx":
+      return "jsx";
+    case "js":
+    case "mjs":
+      return "js";
+    case "json":
+      return "json";
+    case "css":
+      return "css";
+    case "txt":
+      return "text";
+    default:
+      return "js";
+  }
+}
+function generateSharedModuleCode(moduleId, registry) {
+  const registryKey = getRegistryKey(registry);
+  if (!registryKey) {
+    return `throw new Error("Shared module '${moduleId}' requested but no registry configured");`;
+  }
+  const runtimeAccess = `
+(function() {
+  var registry = globalThis["${registryKey}"];
+  if (!registry) {
+    throw new Error(
+      'Sandlot SharedModuleRegistry not found at "${registryKey}". ' +
+      'Ensure sharedModules are configured in createSandlot() options.'
+    );
+  }
+  return registry.get(${JSON.stringify(moduleId)});
+})()
+`.trim();
+  const exportNames = registry?.getExportNames(moduleId) ?? [];
+  let code = `const __sandlot_mod__ = ${runtimeAccess};
+`;
+  code += `export default __sandlot_mod__.default ?? __sandlot_mod__;
+`;
+  if (exportNames.length > 0) {
+    for (const name of exportNames) {
+      code += `export const ${name} = __sandlot_mod__.${name};
+`;
+    }
+  } else {
+    code += `// No named exports discovered for "${moduleId}"
+`;
+    code += `// Use: import mod from "${moduleId}"; mod.exportName
+`;
+  }
+  return code;
+}
+
+// src/node/bundler.ts
+class EsbuildNativeBundler {
+  options;
+  esbuild = null;
+  constructor(options = {}) {
+    this.options = {
+      cdnBaseUrl: "https://esm.sh",
+      ...options
+    };
+  }
+  async initialize() {
+    if (this.esbuild) {
+      return;
+    }
+    this.esbuild = await import("esbuild");
+  }
+  getEsbuild() {
+    if (!this.esbuild) {
+      throw new Error("esbuild not initialized - call initialize() first");
+    }
+    return this.esbuild;
+  }
+  async bundle(options) {
+    await this.initialize();
+    const esbuild = this.getEsbuild();
+    const {
+      fs,
+      entryPoint,
+      installedPackages = {},
+      sharedModules = [],
+      sharedModuleRegistry,
+      external = [],
+      format = "esm",
+      minify = false,
+      sourcemap = false,
+      target = ["es2020"]
+    } = options;
+    const normalizedEntry = entryPoint.startsWith("/") ? entryPoint : `/${entryPoint}`;
+    if (!fs.exists(normalizedEntry)) {
+      return {
+        success: false,
+        errors: [{ text: `Entry point not found: ${normalizedEntry}` }],
+        warnings: []
+      };
+    }
+    const includedFiles = new Set;
+    const plugin = createVfsPlugin({
+      fs,
+      entryPoint: normalizedEntry,
+      installedPackages,
+      sharedModules: new Set(sharedModules),
+      sharedModuleRegistry: sharedModuleRegistry ?? null,
+      cdnBaseUrl: this.options.cdnBaseUrl,
+      includedFiles,
+      bundleCdnImports: true
+    });
+    try {
+      const result = await esbuild.build({
+        entryPoints: [normalizedEntry],
+        bundle: true,
+        write: false,
+        format,
+        minify,
+        sourcemap: sourcemap ? "inline" : false,
+        target,
+        external,
+        plugins: [plugin],
+        jsx: "automatic"
+      });
+      const code = result.outputFiles?.[0]?.text ?? "";
+      const warnings = result.warnings.map((w) => convertEsbuildMessage(w));
+      return {
+        success: true,
+        code,
+        warnings,
+        includedFiles: Array.from(includedFiles)
+      };
+    } catch (err) {
+      if (isEsbuildBuildFailure(err)) {
+        const errors = err.errors.map((e) => convertEsbuildMessage(e));
+        const warnings = err.warnings.map((w) => convertEsbuildMessage(w));
+        return {
+          success: false,
+          errors,
+          warnings
+        };
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        success: false,
+        errors: [{ text: message }],
+        warnings: []
+      };
+    }
+  }
+}
+function createEsbuildNativeBundler(options) {
+  return new EsbuildNativeBundler(options);
+}
+// src/core/typechecker.ts
+import ts from "typescript";
+var TS_VERSION = "5.9.3";
+var DEFAULT_CDN_BASE = `https://cdn.jsdelivr.net/npm/typescript@${TS_VERSION}/lib`;
+var DEFAULT_LIBS = ["es2020", "dom", "dom.iterable"];
+var LIB_PATH_PREFIX = "/node_modules/typescript/lib/";
+function parseLibReferences(content) {
+  const refs = [];
+  const regex = /\/\/\/\s*<reference\s+lib="([^"]+)"\s*\/>/g;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    if (match[1]) {
+      refs.push(match[1]);
+    }
+  }
+  return refs;
+}
+function libNameToFileName(name) {
+  return `lib.${name}.d.ts`;
+}
+async function fetchLibFile(name, baseUrl) {
+  const fileName = libNameToFileName(name);
+  const url = `${baseUrl}/${fileName}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+  }
+  return response.text();
+}
+async function fetchAllLibs(libs, baseUrl) {
+  const result = new Map;
+  const pending = new Set(libs);
+  const fetched = new Set;
+  while (pending.size > 0) {
+    const batch = Array.from(pending);
+    pending.clear();
+    const results = await Promise.all(batch.map(async (name) => {
+      if (fetched.has(name)) {
+        return { name, content: null };
+      }
+      fetched.add(name);
+      try {
+        const content = await fetchLibFile(name, baseUrl);
+        return { name, content };
+      } catch (err) {
+        console.warn(`[typechecker] Failed to fetch lib.${name}.d.ts:`, err);
+        return { name, content: null };
+      }
+    }));
+    for (const { name, content } of results) {
+      if (content === null)
+        continue;
+      result.set(name, content);
+      const refs = parseLibReferences(content);
+      for (const ref of refs) {
+        if (!fetched.has(ref) && !pending.has(ref)) {
+          pending.add(ref);
+        }
+      }
+    }
+  }
+  return result;
+}
+function normalizePath2(path) {
+  if (!path.startsWith("/")) {
+    return "/" + path;
+  }
+  return path;
+}
+function getLibContent(fileName, libFiles) {
+  const match = fileName.match(/lib\.([^/]+)\.d\.ts$/);
+  if (match?.[1]) {
+    return libFiles.get(match[1]);
+  }
+  return;
+}
+function createCompilerHost(fs, libFiles, options) {
+  return {
+    getSourceFile(fileName, languageVersion, onError) {
+      const normalizedPath = normalizePath2(fileName);
+      try {
+        if (fs.exists(normalizedPath)) {
+          const stat = fs.stat(normalizedPath);
+          if (stat.isFile) {
+            const content = fs.readFile(normalizedPath);
+            return ts.createSourceFile(normalizedPath, content, languageVersion, true);
+          }
+        }
+      } catch {}
+      try {
+        if (fs.exists(fileName)) {
+          const stat = fs.stat(fileName);
+          if (stat.isFile) {
+            const content = fs.readFile(fileName);
+            return ts.createSourceFile(fileName, content, languageVersion, true);
+          }
+        }
+      } catch {}
+      const libContent = getLibContent(fileName, libFiles);
+      if (libContent !== undefined) {
+        return ts.createSourceFile(fileName, libContent, languageVersion, true);
+      }
+      if (onError) {
+        onError(`File not found: ${fileName}`);
+      }
+      return;
+    },
+    getDefaultLibFileName(opts) {
+      return LIB_PATH_PREFIX + ts.getDefaultLibFileName(opts);
+    },
+    writeFile() {},
+    getCurrentDirectory() {
+      return "/";
+    },
+    getCanonicalFileName(fileName) {
+      return fileName;
+    },
+    useCaseSensitiveFileNames() {
+      return true;
+    },
+    getNewLine() {
+      return `
+`;
+    },
+    fileExists(fileName) {
+      const normalizedPath = normalizePath2(fileName);
+      try {
+        if (fs.exists(normalizedPath)) {
+          return fs.stat(normalizedPath).isFile;
+        }
+      } catch {}
+      return getLibContent(fileName, libFiles) !== undefined;
+    },
+    readFile(fileName) {
+      const normalizedPath = normalizePath2(fileName);
+      try {
+        if (fs.exists(normalizedPath)) {
+          return fs.readFile(normalizedPath);
+        }
+      } catch {}
+      return getLibContent(fileName, libFiles);
+    },
+    directoryExists(directoryName) {
+      const normalizedDir = normalizePath2(directoryName);
+      try {
+        if (fs.exists(normalizedDir)) {
+          return fs.stat(normalizedDir).isDirectory;
+        }
+      } catch {}
+      if (normalizedDir === "/node_modules/typescript/lib" || normalizedDir === "/node_modules/typescript" || normalizedDir === "/node_modules") {
+        return libFiles.size > 0;
+      }
+      return false;
+    },
+    getDirectories(path) {
+      const normalizedPath = normalizePath2(path);
+      try {
+        if (!fs.exists(normalizedPath)) {
+          return [];
+        }
+        const stat = fs.stat(normalizedPath);
+        if (!stat.isDirectory) {
+          return [];
+        }
+        const entries = fs.readdir(normalizedPath);
+        const dirs = [];
+        for (const name of entries) {
+          const childPath = normalizedPath === "/" ? `/${name}` : `${normalizedPath}/${name}`;
+          try {
+            if (fs.stat(childPath).isDirectory) {
+              dirs.push(name);
+            }
+          } catch {}
+        }
+        return dirs;
+      } catch {
+        return [];
+      }
+    },
+    realpath(path) {
+      return path;
+    },
+    getEnvironmentVariable() {
+      return;
+    }
+  };
+}
+function getDefaultCompilerOptions() {
+  return {
+    target: ts.ScriptTarget.ES2020,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    esModuleInterop: true,
+    strict: true,
+    skipLibCheck: true,
+    noEmit: true,
+    jsx: ts.JsxEmit.ReactJSX,
+    allowJs: true,
+    resolveJsonModule: true,
+    lib: ["lib.es2020.d.ts", "lib.dom.d.ts", "lib.dom.iterable.d.ts"]
+  };
+}
+function parseTsConfig(fs, configPath) {
+  try {
+    if (!fs.exists(configPath)) {
+      return getDefaultCompilerOptions();
+    }
+    const configText = fs.readFile(configPath);
+    const { config, error } = ts.parseConfigFileTextToJson(configPath, configText);
+    if (error) {
+      console.warn("[typechecker] Error parsing tsconfig:", error.messageText);
+      return getDefaultCompilerOptions();
+    }
+    const parseHost = {
+      useCaseSensitiveFileNames: true,
+      readDirectory: () => [],
+      fileExists: (path) => fs.exists(normalizePath2(path)),
+      readFile: (path) => {
+        try {
+          return fs.readFile(normalizePath2(path));
+        } catch {
+          return;
+        }
+      }
+    };
+    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));
+    }
+    return {
+      ...parsed.options,
+      noEmit: true
+    };
+  } catch (err) {
+    console.warn("[typechecker] Error reading tsconfig:", err);
+    return getDefaultCompilerOptions();
+  }
+}
+function categoryToSeverity(category) {
+  switch (category) {
+    case ts.DiagnosticCategory.Error:
+      return "error";
+    case ts.DiagnosticCategory.Warning:
+      return "warning";
+    default:
+      return "info";
+  }
+}
+function convertDiagnostic(diag) {
+  let file;
+  let line;
+  let column;
+  if (diag.file && diag.start !== undefined) {
+    file = diag.file.fileName;
+    const pos = diag.file.getLineAndCharacterOfPosition(diag.start);
+    line = pos.line + 1;
+    column = pos.character + 1;
+  }
+  return {
+    file,
+    line,
+    column,
+    message: ts.flattenDiagnosticMessageText(diag.messageText, `
+`),
+    severity: categoryToSeverity(diag.category)
+  };
+}
+
+class Typechecker {
+  options;
+  libCache = new Map;
+  initPromise = null;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async initialize() {
+    if (this.initPromise) {
+      await this.initPromise;
+      return;
+    }
+    if (this.libCache.size > 0) {
+      return;
+    }
+    this.initPromise = this.fetchLibs();
+    await this.initPromise;
+  }
+  async fetchLibs() {
+    const libs = this.options.libs ?? DEFAULT_LIBS;
+    const baseUrl = this.options.libsBaseUrl ?? DEFAULT_CDN_BASE;
+    console.log(`[typechecker] Fetching TypeScript libs: ${libs.join(", ")}...`);
+    const fetched = await fetchAllLibs(libs, baseUrl);
+    console.log(`[typechecker] Fetched ${fetched.size} lib files`);
+    this.libCache = fetched;
+  }
+  async typecheck(options) {
+    await this.initialize();
+    const { fs, entryPoint, tsconfigPath = "/tsconfig.json" } = options;
+    const normalizedEntry = normalizePath2(entryPoint);
+    if (!fs.exists(normalizedEntry)) {
+      return {
+        success: false,
+        diagnostics: [
+          {
+            file: normalizedEntry,
+            message: `Entry point not found: ${normalizedEntry}`,
+            severity: "error"
+          }
+        ]
+      };
+    }
+    const compilerOptions = parseTsConfig(fs, tsconfigPath);
+    const host = createCompilerHost(fs, this.libCache, compilerOptions);
+    const program = ts.createProgram([normalizedEntry], compilerOptions, host);
+    const allDiagnostics = [
+      ...program.getSyntacticDiagnostics(),
+      ...program.getSemanticDiagnostics(),
+      ...program.getDeclarationDiagnostics()
+    ];
+    const diagnostics = allDiagnostics.map(convertDiagnostic);
+    const success = !diagnostics.some((d) => d.severity === "error");
+    return {
+      success,
+      diagnostics
+    };
+  }
+}
+function createTypechecker(options) {
+  return new Typechecker(options);
+}
+// src/core/executor.ts
+function createBasicExecutor(loadModule, options = {}) {
+  const defaultTimeout = options.defaultTimeout ?? 30000;
+  return {
+    async execute(code, execOptions = {}) {
+      const {
+        entryExport = "main",
+        context = {},
+        timeout = defaultTimeout
+      } = execOptions;
+      const startTime = performance.now();
+      const logs = [];
+      const originalConsole = {
+        log: console.log,
+        warn: console.warn,
+        error: console.error,
+        info: console.info,
+        debug: console.debug
+      };
+      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;
+        console.warn = originalConsole.warn;
+        console.error = originalConsole.error;
+        console.info = originalConsole.info;
+        console.debug = originalConsole.debug;
+      };
+      console.log = captureLog;
+      console.warn = captureWarn;
+      console.error = captureError;
+      console.info = captureInfo;
+      console.debug = captureDebug;
+      try {
+        const module = await loadModule(code);
+        let returnValue;
+        const executeExport = async () => {
+          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 (timeout > 0) {
+          const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error(`Execution timed out after ${timeout}ms`)), timeout);
+          });
+          await Promise.race([executeExport(), timeoutPromise]);
+        } else {
+          await executeExport();
+        }
+        const executionTimeMs = performance.now() - startTime;
+        restoreConsole();
+        return {
+          success: true,
+          logs,
+          returnValue,
+          executionTimeMs
+        };
+      } catch (err) {
+        const executionTimeMs = performance.now() - startTime;
+        restoreConsole();
+        return {
+          success: false,
+          logs,
+          error: err instanceof Error ? err.message : String(err),
+          executionTimeMs
+        };
+      }
+    }
+  };
+}
+
+// src/node/executor.ts
+import { writeFileSync, unlinkSync, mkdtempSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+async function loadModuleFromTempFile(code) {
+  const tempDir = mkdtempSync(join(tmpdir(), "sandlot-"));
+  const tempFile = join(tempDir, `module-${Date.now()}.mjs`);
+  try {
+    writeFileSync(tempFile, code, "utf-8");
+    const fileUrl = `file://${tempFile}`;
+    return await import(fileUrl);
+  } finally {
+    try {
+      unlinkSync(tempFile);
+    } catch {}
+  }
+}
+
+class NodeExecutor {
+  executor;
+  constructor(options = {}) {
+    this.executor = createBasicExecutor(loadModuleFromTempFile, options);
+  }
+  execute = (...args) => this.executor.execute(...args);
+}
+function createNodeExecutor(options) {
+  return new NodeExecutor(options);
+}
+// src/core/shared-module-registry.ts
+var instanceCounter = 0;
+function generateInstanceId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID().slice(0, 8);
+  }
+  return `${Date.now().toString(36)}_${(++instanceCounter).toString(36)}`;
+}
+
+class SharedModuleRegistry {
+  modules;
+  exportNamesMap;
+  _registryKey;
+  constructor(modules) {
+    this._registryKey = `__sandlot_${generateInstanceId()}__`;
+    this.modules = new Map(Object.entries(modules));
+    this.exportNamesMap = new Map;
+    for (const [id, mod] of this.modules) {
+      this.exportNamesMap.set(id, this.introspectExports(mod));
+    }
+  }
+  get registryKey() {
+    return this._registryKey;
+  }
+  exposeGlobally() {
+    globalThis[this._registryKey] = this;
+    return this;
+  }
+  removeFromGlobal() {
+    if (globalThis[this._registryKey] === this) {
+      delete globalThis[this._registryKey];
+    }
+  }
+  get(moduleId) {
+    const mod = this.modules.get(moduleId);
+    if (mod === undefined && !this.modules.has(moduleId)) {
+      throw new Error(`Shared module "${moduleId}" not registered.`);
+    }
+    return mod;
+  }
+  has(moduleId) {
+    return this.modules.has(moduleId);
+  }
+  getExportNames(moduleId) {
+    return this.exportNamesMap.get(moduleId) ?? [];
+  }
+  list() {
+    return [...this.modules.keys()];
+  }
+  introspectExports(module) {
+    if (module === null || module === undefined) {
+      return [];
+    }
+    if (typeof module !== "object" && typeof module !== "function") {
+      return [];
+    }
+    const exports = [];
+    for (const key of Object.keys(module)) {
+      if (this.isValidIdentifier(key)) {
+        exports.push(key);
+      }
+    }
+    return exports;
+  }
+  isValidIdentifier(name) {
+    if (name.length === 0)
+      return false;
+    if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name))
+      return false;
+    const reserved = [
+      "default",
+      "class",
+      "function",
+      "var",
+      "let",
+      "const",
+      "import",
+      "export"
+    ];
+    return !reserved.includes(name);
+  }
+}
+function createSharedModuleRegistry(modules) {
+  if (!modules || Object.keys(modules).length === 0) {
+    return null;
+  }
+  const registry = new SharedModuleRegistry(modules);
+  registry.exposeGlobally();
+  return registry;
+}
+
+// src/core/sandbox.ts
+import { Bash } from "just-bash/browser";
+
+// src/core/fs.ts
+var DEFAULT_FILE_MODE = 420;
+var DEFAULT_DIR_MODE = 493;
+var DEFAULT_SYMLINK_MODE = 511;
+var DEFAULT_MAX_SIZE_BYTES = 50 * 1024 * 1024;
+
+class Filesystem {
+  entries;
+  maxSizeBytes;
+  constructor(entries, maxSizeBytes) {
+    this.entries = entries;
+    this.maxSizeBytes = maxSizeBytes;
+  }
+  static create(options = {}) {
+    const maxSizeBytes = options.maxSizeBytes ?? DEFAULT_MAX_SIZE_BYTES;
+    const entries = new Map;
+    entries.set("/", {
+      type: "directory",
+      mode: DEFAULT_DIR_MODE,
+      mtime: new Date
+    });
+    if (options.initialFiles) {
+      for (const [path, value] of Object.entries(options.initialFiles)) {
+        const normalizedPath = Filesystem.normalizePath(path);
+        const init = Filesystem.parseFileInit(value);
+        Filesystem.ensureParentDirs(entries, normalizedPath);
+        entries.set(normalizedPath, {
+          type: "file",
+          content: init.content,
+          mode: init.mode ?? DEFAULT_FILE_MODE,
+          mtime: init.mtime ?? new Date
+        });
+      }
+    }
+    return new Filesystem(entries, maxSizeBytes);
+  }
+  getFiles() {
+    const files = {};
+    for (const [path, entry] of this.entries) {
+      if (entry.type === "file") {
+        if (typeof entry.content === "string") {
+          files[path] = entry.content;
+        } else {
+          const base64 = this.encodeBase64(entry.content);
+          files[path] = `data:application/octet-stream;base64,${base64}`;
+        }
+      }
+    }
+    return files;
+  }
+  getSize() {
+    let size = 0;
+    for (const [path, entry] of this.entries) {
+      size += path.length * 2;
+      if (entry.type === "file") {
+        if (typeof entry.content === "string") {
+          size += entry.content.length * 2;
+        } else {
+          size += entry.content.byteLength;
+        }
+      }
+    }
+    return size;
+  }
+  readFile(path, options) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.resolveSymlinks(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, open '${path}'`);
+    }
+    if (entry.type !== "file") {
+      throw new Error(`EISDIR: illegal operation on a directory, read '${path}'`);
+    }
+    const content = entry.content;
+    if (typeof content === "string") {
+      return content;
+    }
+    const encoding = this.getEncoding(options) ?? "utf8";
+    return this.decodeBuffer(content, encoding);
+  }
+  readFileBuffer(path) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.resolveSymlinks(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, open '${path}'`);
+    }
+    if (entry.type !== "file") {
+      throw new Error(`EISDIR: illegal operation on a directory, read '${path}'`);
+    }
+    const content = entry.content;
+    if (content instanceof Uint8Array) {
+      return content;
+    }
+    return new TextEncoder().encode(content);
+  }
+  writeFile(path, content, _options) {
+    const normalizedPath = this.normalizePath(path);
+    this.checkSizeLimit(content);
+    this.ensureParentDirs(normalizedPath);
+    const existing = this.entries.get(normalizedPath);
+    if (existing && existing.type === "directory") {
+      throw new Error(`EISDIR: illegal operation on a directory, open '${path}'`);
+    }
+    this.entries.set(normalizedPath, {
+      type: "file",
+      content,
+      mode: existing?.mode ?? DEFAULT_FILE_MODE,
+      mtime: new Date
+    });
+  }
+  appendFile(path, content, options) {
+    const normalizedPath = this.normalizePath(path);
+    let existing = "";
+    try {
+      existing = this.readFile(normalizedPath);
+    } catch {}
+    const newContent = typeof existing === "string" && typeof content === "string" ? existing + content : this.concatBuffers(typeof existing === "string" ? new TextEncoder().encode(existing) : existing, typeof content === "string" ? new TextEncoder().encode(content) : content);
+    this.writeFile(normalizedPath, newContent, options);
+  }
+  exists(path) {
+    const normalizedPath = this.normalizePath(path);
+    return this.entries.has(normalizedPath);
+  }
+  stat(path) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.resolveSymlinks(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
+    }
+    return this.entryToStat(entry);
+  }
+  lstat(path) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.entries.get(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, lstat '${path}'`);
+    }
+    return this.entryToStat(entry);
+  }
+  mkdir(path, options) {
+    const normalizedPath = this.normalizePath(path);
+    if (this.entries.has(normalizedPath)) {
+      if (options?.recursive) {
+        return;
+      }
+      throw new Error(`EEXIST: file already exists, mkdir '${path}'`);
+    }
+    if (options?.recursive) {
+      this.ensureParentDirs(normalizedPath);
+    } else {
+      const parent = this.getParentPath(normalizedPath);
+      if (parent && !this.entries.has(parent)) {
+        throw new Error(`ENOENT: no such file or directory, mkdir '${path}'`);
+      }
+    }
+    this.entries.set(normalizedPath, {
+      type: "directory",
+      mode: DEFAULT_DIR_MODE,
+      mtime: new Date
+    });
+  }
+  readdir(path) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.resolveSymlinks(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, scandir '${path}'`);
+    }
+    if (entry.type !== "directory") {
+      throw new Error(`ENOTDIR: not a directory, scandir '${path}'`);
+    }
+    const prefix = normalizedPath === "/" ? "/" : normalizedPath + "/";
+    const names = [];
+    for (const entryPath of this.entries.keys()) {
+      if (entryPath === normalizedPath)
+        continue;
+      if (!entryPath.startsWith(prefix))
+        continue;
+      const relative = entryPath.slice(prefix.length);
+      if (!relative.includes("/")) {
+        names.push(relative);
+      }
+    }
+    return names.sort();
+  }
+  readdirWithFileTypes(path) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.resolveSymlinks(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, scandir '${path}'`);
+    }
+    if (entry.type !== "directory") {
+      throw new Error(`ENOTDIR: not a directory, scandir '${path}'`);
+    }
+    const prefix = normalizedPath === "/" ? "/" : normalizedPath + "/";
+    const dirents = [];
+    for (const [entryPath, e] of this.entries) {
+      if (entryPath === normalizedPath)
+        continue;
+      if (!entryPath.startsWith(prefix))
+        continue;
+      const relative = entryPath.slice(prefix.length);
+      if (!relative.includes("/")) {
+        dirents.push({
+          name: relative,
+          isFile: e.type === "file",
+          isDirectory: e.type === "directory",
+          isSymbolicLink: e.type === "symlink"
+        });
+      }
+    }
+    return dirents.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  rm(path, options) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.entries.get(normalizedPath);
+    if (!entry) {
+      if (options?.force)
+        return;
+      throw new Error(`ENOENT: no such file or directory, rm '${path}'`);
+    }
+    if (entry.type === "directory") {
+      const children = this.readdir(normalizedPath);
+      if (children.length > 0 && !options?.recursive) {
+        throw new Error(`ENOTEMPTY: directory not empty, rm '${path}'`);
+      }
+      if (options?.recursive) {
+        const prefix = normalizedPath === "/" ? "/" : normalizedPath + "/";
+        for (const entryPath of [...this.entries.keys()]) {
+          if (entryPath.startsWith(prefix)) {
+            this.entries.delete(entryPath);
+          }
+        }
+      }
+    }
+    this.entries.delete(normalizedPath);
+  }
+  cp(src, dest, options) {
+    const srcPath = this.normalizePath(src);
+    const destPath = this.normalizePath(dest);
+    const entry = this.entries.get(srcPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, cp '${src}'`);
+    }
+    if (entry.type === "directory") {
+      if (!options?.recursive) {
+        throw new Error(`EISDIR: cp called on directory without recursive '${src}'`);
+      }
+      this.ensureParentDirs(destPath);
+      this.entries.set(destPath, { ...entry, mtime: new Date });
+      const prefix = srcPath === "/" ? "/" : srcPath + "/";
+      for (const [entryPath, e] of this.entries) {
+        if (entryPath.startsWith(prefix)) {
+          const relative = entryPath.slice(srcPath.length);
+          const newPath = destPath + relative;
+          this.entries.set(newPath, this.cloneEntry(e));
+        }
+      }
+    } else {
+      this.ensureParentDirs(destPath);
+      this.entries.set(destPath, this.cloneEntry(entry));
+    }
+  }
+  mv(src, dest) {
+    const srcPath = this.normalizePath(src);
+    const destPath = this.normalizePath(dest);
+    const entry = this.entries.get(srcPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, mv '${src}'`);
+    }
+    this.ensureParentDirs(destPath);
+    if (entry.type === "directory") {
+      const prefix = srcPath === "/" ? "/" : srcPath + "/";
+      const toMove = [];
+      for (const [entryPath, e] of this.entries) {
+        if (entryPath === srcPath || entryPath.startsWith(prefix)) {
+          const relative = entryPath.slice(srcPath.length);
+          toMove.push([destPath + relative, e]);
+          this.entries.delete(entryPath);
+        }
+      }
+      for (const [newPath, e] of toMove) {
+        this.entries.set(newPath, e);
+      }
+    } else {
+      this.entries.delete(srcPath);
+      this.entries.set(destPath, entry);
+    }
+  }
+  resolvePath(base, path) {
+    if (path.startsWith("/")) {
+      return this.normalizePath(path);
+    }
+    const baseParts = base.split("/").filter(Boolean);
+    const pathParts = path.split("/").filter(Boolean);
+    for (const part of pathParts) {
+      if (part === ".") {
+        continue;
+      } else if (part === "..") {
+        baseParts.pop();
+      } else {
+        baseParts.push(part);
+      }
+    }
+    return "/" + baseParts.join("/");
+  }
+  getAllPaths() {
+    return [...this.entries.keys()].sort();
+  }
+  chmod(path, mode) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.entries.get(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, chmod '${path}'`);
+    }
+    entry.mode = mode;
+    entry.mtime = new Date;
+  }
+  symlink(target, linkPath) {
+    const normalizedLinkPath = this.normalizePath(linkPath);
+    if (this.entries.has(normalizedLinkPath)) {
+      throw new Error(`EEXIST: file already exists, symlink '${linkPath}'`);
+    }
+    this.ensureParentDirs(normalizedLinkPath);
+    this.entries.set(normalizedLinkPath, {
+      type: "symlink",
+      target,
+      mode: DEFAULT_SYMLINK_MODE,
+      mtime: new Date
+    });
+  }
+  link(existingPath, newPath) {
+    const srcPath = this.normalizePath(existingPath);
+    const destPath = this.normalizePath(newPath);
+    const entry = this.entries.get(srcPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, link '${existingPath}'`);
+    }
+    if (entry.type !== "file") {
+      throw new Error(`EPERM: operation not permitted, link '${existingPath}'`);
+    }
+    if (this.entries.has(destPath)) {
+      throw new Error(`EEXIST: file already exists, link '${newPath}'`);
+    }
+    this.ensureParentDirs(destPath);
+    this.entries.set(destPath, {
+      type: "file",
+      content: entry.content,
+      mode: entry.mode,
+      mtime: new Date
+    });
+  }
+  readlink(path) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.entries.get(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, readlink '${path}'`);
+    }
+    if (entry.type !== "symlink") {
+      throw new Error(`EINVAL: invalid argument, readlink '${path}'`);
+    }
+    return entry.target;
+  }
+  realpath(path) {
+    const normalizedPath = this.normalizePath(path);
+    const parts = normalizedPath.split("/").filter(Boolean);
+    let resolved = "/";
+    for (const part of parts) {
+      resolved = resolved === "/" ? `/${part}` : `${resolved}/${part}`;
+      const entry = this.entries.get(resolved);
+      if (!entry) {
+        throw new Error(`ENOENT: no such file or directory, realpath '${path}'`);
+      }
+      if (entry.type === "symlink") {
+        const target = entry.target;
+        if (target.startsWith("/")) {
+          resolved = this.normalizePath(target);
+        } else {
+          const parent = this.getParentPath(resolved) ?? "/";
+          resolved = this.resolvePath(parent, target);
+        }
+        const targetEntry = this.entries.get(resolved);
+        if (!targetEntry) {
+          throw new Error(`ENOENT: no such file or directory, realpath '${path}'`);
+        }
+      }
+    }
+    return resolved;
+  }
+  utimes(path, atime, mtime) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.entries.get(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, utimes '${path}'`);
+    }
+    entry.mtime = mtime;
+  }
+  normalizePath(path) {
+    return Filesystem.normalizePath(path);
+  }
+  static normalizePath(path) {
+    if (!path || path === ".")
+      return "/";
+    if (!path.startsWith("/")) {
+      path = "/" + path;
+    }
+    const parts = path.split("/").filter(Boolean);
+    const normalized = [];
+    for (const part of parts) {
+      if (part === ".")
+        continue;
+      if (part === "..") {
+        normalized.pop();
+      } else {
+        normalized.push(part);
+      }
+    }
+    return "/" + normalized.join("/");
+  }
+  getParentPath(path) {
+    if (path === "/")
+      return null;
+    const lastSlash = path.lastIndexOf("/");
+    return lastSlash === 0 ? "/" : path.slice(0, lastSlash);
+  }
+  ensureParentDirs(path) {
+    Filesystem.ensureParentDirs(this.entries, path);
+  }
+  static ensureParentDirs(entries, path) {
+    const parts = path.split("/").filter(Boolean);
+    let current = "";
+    for (let i = 0;i < parts.length - 1; i++) {
+      current += "/" + parts[i];
+      if (!entries.has(current)) {
+        entries.set(current, {
+          type: "directory",
+          mode: DEFAULT_DIR_MODE,
+          mtime: new Date
+        });
+      }
+    }
+  }
+  resolveSymlinks(path, maxDepth = 10) {
+    let current = path;
+    let depth = 0;
+    while (depth < maxDepth) {
+      const entry = this.entries.get(current);
+      if (!entry)
+        return null;
+      if (entry.type !== "symlink")
+        return entry;
+      const target = entry.target;
+      current = target.startsWith("/") ? this.normalizePath(target) : this.resolvePath(this.getParentPath(current) ?? "/", target);
+      depth++;
+    }
+    throw new Error(`ELOOP: too many levels of symbolic links, stat '${path}'`);
+  }
+  entryToStat(entry) {
+    return {
+      isFile: entry.type === "file",
+      isDirectory: entry.type === "directory",
+      isSymbolicLink: entry.type === "symlink",
+      mode: entry.mode,
+      size: entry.type === "file" ? this.getContentSize(entry.content) : 0,
+      mtime: entry.mtime
+    };
+  }
+  getContentSize(content) {
+    if (typeof content === "string") {
+      return new TextEncoder().encode(content).byteLength;
+    }
+    return content.byteLength;
+  }
+  cloneEntry(entry) {
+    if (entry.type === "file") {
+      return {
+        type: "file",
+        content: entry.content instanceof Uint8Array ? new Uint8Array(entry.content) : entry.content,
+        mode: entry.mode,
+        mtime: new Date
+      };
+    }
+    return { ...entry, mtime: new Date };
+  }
+  checkSizeLimit(content) {
+    const currentSize = this.getSize();
+    const newSize = typeof content === "string" ? content.length * 2 : content.byteLength;
+    if (currentSize + newSize > this.maxSizeBytes) {
+      throw new Error(`ENOSPC: filesystem size limit exceeded (${this.maxSizeBytes} bytes)`);
+    }
+  }
+  getEncoding(options) {
+    if (!options)
+      return null;
+    if (typeof options === "string")
+      return options;
+    return options.encoding ?? null;
+  }
+  decodeBuffer(buffer, encoding) {
+    if (encoding === "utf8" || encoding === "utf-8") {
+      return new TextDecoder("utf-8").decode(buffer);
+    }
+    if (encoding === "base64") {
+      return this.encodeBase64(buffer);
+    }
+    if (encoding === "hex") {
+      return Array.from(buffer).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    return new TextDecoder("utf-8").decode(buffer);
+  }
+  encodeBase64(buffer) {
+    let binary = "";
+    for (let i = 0;i < buffer.byteLength; i++) {
+      binary += String.fromCharCode(buffer[i]);
+    }
+    return btoa(binary);
+  }
+  concatBuffers(a, b) {
+    const result = new Uint8Array(a.byteLength + b.byteLength);
+    result.set(a, 0);
+    result.set(b, a.byteLength);
+    return result;
+  }
+  static parseFileInit(value) {
+    if (typeof value === "string" || value instanceof Uint8Array) {
+      return { content: value };
+    }
+    return value;
+  }
+}
+function createFilesystem(options) {
+  return Filesystem.create(options);
+}
+function wrapFilesystemForJustBash(fs) {
+  return {
+    readFile: async (path, options) => fs.readFile(path, options),
+    writeFile: async (path, content, options) => fs.writeFile(path, content, options),
+    appendFile: async (path, content, options) => fs.appendFile(path, content, options),
+    exists: async (path) => fs.exists(path),
+    stat: async (path) => fs.stat(path),
+    lstat: async (path) => fs.lstat(path),
+    mkdir: async (path, options) => fs.mkdir(path, options),
+    readdir: async (path) => fs.readdir(path),
+    readdirWithFileTypes: async (path) => fs.readdirWithFileTypes(path),
+    rm: async (path, options) => fs.rm(path, options),
+    cp: async (src, dest, options) => fs.cp(src, dest, options),
+    mv: async (src, dest) => fs.mv(src, dest),
+    chmod: async (path, mode) => fs.chmod(path, mode),
+    symlink: async (target, linkPath) => fs.symlink(target, linkPath),
+    link: async (existingPath, newPath) => fs.link(existingPath, newPath),
+    readlink: async (path) => fs.readlink(path),
+    realpath: async (path) => fs.realpath(path),
+    utimes: async (path, atime, mtime) => fs.utimes(path, atime, mtime),
+    readFileBuffer: async (path) => fs.readFileBuffer(path),
+    resolvePath: (base, path) => fs.resolvePath(base, path),
+    getAllPaths: () => fs.getAllPaths()
+  };
+}
+
+// src/commands/index.ts
+import { defineCommand } from "just-bash/browser";
+
+// src/commands/types.ts
+function formatSize(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(2)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+function formatDiagnostics(diagnostics) {
+  if (diagnostics.length === 0)
+    return "";
+  return diagnostics.map((d) => {
+    const severity = d.severity.toUpperCase();
+    if (d.file) {
+      const loc = `${d.file}${d.line ? `:${d.line}` : ""}${d.column ? `:${d.column}` : ""}`;
+      return `${severity}: ${loc}: ${d.message}`;
+    }
+    return `${severity}: ${d.message}`;
+  }).join(`
+`);
+}
+function formatBundleErrors(errors) {
+  if (errors.length === 0)
+    return "";
+  return errors.map((e) => {
+    let output = "";
+    if (e.location) {
+      const loc = `${e.location.file}:${e.location.line}${e.location.column ? `:${e.location.column}` : ""}`;
+      output += `ERROR: ${loc}: ${e.text}`;
+      if (e.location.lineText) {
+        output += `
+    ${e.location.line} | ${e.location.lineText}`;
+        if (e.location.column) {
+          const padding = " ".repeat(String(e.location.line).length + 3 + e.location.column - 1);
+          output += `
+${padding}^`;
+        }
+      }
+    } else {
+      output += `ERROR: ${e.text}`;
+    }
+    return output;
+  }).join(`
+
+`);
+}
+// src/commands/index.ts
+function createSandlotCommand(sandboxRef) {
+  return defineCommand("sandlot", async (args, ctx) => {
+    const subcommand = args[0];
+    if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+      return showHelp();
+    }
+    switch (subcommand) {
+      case "build":
+        return handleBuild(sandboxRef, args.slice(1));
+      case "typecheck":
+      case "tsc":
+        return handleTypecheck(sandboxRef, args.slice(1));
+      case "install":
+      case "add":
+      case "i":
+        return handleInstall(sandboxRef, args.slice(1));
+      case "uninstall":
+      case "remove":
+      case "rm":
+        return handleUninstall(sandboxRef, args.slice(1));
+      case "run":
+        return handleRun(sandboxRef, args.slice(1));
+      default:
+        return {
+          stdout: "",
+          stderr: `Unknown command: sandlot ${subcommand}
+
+Run 'sandlot help' for available commands.
+`,
+          exitCode: 1
+        };
+    }
+  });
+}
+function showHelp() {
+  return {
+    stdout: `sandlot - In-browser TypeScript sandbox
+
+Usage: sandlot <command> [options]
+
+Commands:
+  build       Build the project (typecheck, bundle)
+  run         Build and execute code
+  typecheck   Type check without building (alias: tsc)
+  install     Install packages (aliases: add, i)
+  uninstall   Remove packages (aliases: remove, rm)
+  help        Show this help message
+
+Run 'sandlot <command> --help' for command-specific options.
+
+Examples:
+  sandlot build
+  sandlot run
+  sandlot run --skip-typecheck --timeout 5000
+  sandlot install react react-dom
+  sandlot typecheck
+`,
+    stderr: "",
+    exitCode: 0
+  };
+}
+async function handleBuild(sandboxRef, args) {
+  let entryPoint;
+  let skipTypecheck = false;
+  let minify = false;
+  let format = "esm";
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--skip-typecheck" || arg === "-s") {
+      skipTypecheck = true;
+    } else if (arg === "--minify" || arg === "-m") {
+      minify = true;
+    } else if ((arg === "--format" || arg === "-f") && args[i + 1]) {
+      const f = args[++i].toLowerCase();
+      if (f === "esm" || f === "iife" || f === "cjs") {
+        format = f;
+      }
+    } else if ((arg === "--entry" || arg === "-e") && args[i + 1]) {
+      entryPoint = args[++i];
+    } else if (arg === "--help" || arg === "-h") {
+      return {
+        stdout: `Usage: sandlot build [options]
+
+Options:
+  --entry, -e <path>     Entry point (default: from package.json main)
+  --skip-typecheck, -s   Skip type checking
+  --minify, -m           Minify output
+  --format, -f <fmt>     Output format (esm|iife|cjs)
+  --help, -h             Show this help message
+
+Examples:
+  sandlot build
+  sandlot build --entry /src/main.ts
+  sandlot build --skip-typecheck --minify
+`,
+        stderr: "",
+        exitCode: 0
+      };
+    } else if (arg && !arg.startsWith("-") && !entryPoint) {
+      entryPoint = arg;
+    }
+  }
+  const result = await sandboxRef.build({
+    entryPoint,
+    skipTypecheck,
+    minify,
+    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,
+      exitCode: 1
+    };
+  }
+  let output = `Build successful!
+`;
+  output += `Size: ${formatSize(result.code.length)}
+`;
+  output += `Files: ${result.includedFiles.length}
+`;
+  if (result.warnings.length > 0) {
+    output += `
+Warnings:
+`;
+    for (const warning of result.warnings) {
+      if (warning.location) {
+        output += `  ${warning.location.file}:${warning.location.line}: ${warning.text}
+`;
+      } else {
+        output += `  ${warning.text}
+`;
+      }
+    }
+  }
+  return {
+    stdout: output,
+    stderr: "",
+    exitCode: 0
+  };
+}
+async function handleTypecheck(sandboxRef, args) {
+  let entryPoint;
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if ((arg === "--entry" || arg === "-e") && args[i + 1]) {
+      entryPoint = args[++i];
+    } else if (arg === "--help" || arg === "-h") {
+      return {
+        stdout: `Usage: sandlot typecheck [options]
+
+Options:
+  --entry, -e <path>   Entry point (default: from package.json main)
+  --help, -h           Show this help message
+
+Aliases: sandlot tsc
+
+Examples:
+  sandlot typecheck
+  sandlot typecheck --entry /src/main.ts
+`,
+        stderr: "",
+        exitCode: 0
+      };
+    } else if (arg && !arg.startsWith("-") && !entryPoint) {
+      entryPoint = arg;
+    }
+  }
+  try {
+    const result = await sandboxRef.typecheck({ entryPoint });
+    if (!result.success) {
+      const errors = result.diagnostics.filter((d) => d.severity === "error");
+      const formatted = formatDiagnostics(errors);
+      return {
+        stdout: "",
+        stderr: `Type check failed:
+${formatted}
+`,
+        exitCode: 1
+      };
+    }
+    const warnings = result.diagnostics.filter((d) => d.severity === "warning");
+    let output = `Type check passed.
+`;
+    if (warnings.length > 0) {
+      output += `
+Warnings:
+${formatDiagnostics(warnings)}
+`;
+    }
+    return {
+      stdout: output,
+      stderr: "",
+      exitCode: 0
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      stdout: "",
+      stderr: `Type check error: ${message}
+`,
+      exitCode: 1
+    };
+  }
+}
+async function handleInstall(sandboxRef, args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    return {
+      stdout: `Usage: sandlot install <package>[@version] [...packages]
+
+Examples:
+  sandlot install react
+  sandlot install lodash@4.17.21
+  sandlot install @tanstack/react-query@5
+  sandlot install react react-dom
+
+Aliases: sandlot add, sandlot i
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  const packages = args.filter((a) => !!a && !a.startsWith("-"));
+  if (packages.length === 0) {
+    return {
+      stdout: "",
+      stderr: `Usage: sandlot install <package>[@version] [...packages]
+
+Run 'sandlot install --help' for more information.
+`,
+      exitCode: 1
+    };
+  }
+  const results = [];
+  let hasError = false;
+  for (const packageSpec of packages) {
+    try {
+      const result = await sandboxRef.install(packageSpec);
+      let status = `+ ${result.name}@${result.version}`;
+      if (result.typesInstalled) {
+        status += ` (${result.typeFilesCount} type file${result.typeFilesCount !== 1 ? "s" : ""})`;
+        if (result.fromCache) {
+          status += " [cached]";
+        }
+      } else if (result.typesError) {
+        status += ` (no types: ${result.typesError})`;
+      }
+      results.push(status);
+    } catch (err) {
+      hasError = true;
+      const message = err instanceof Error ? err.message : String(err);
+      results.push(`x ${packageSpec}: ${message}`);
+    }
+  }
+  const output = results.join(`
+`) + `
+`;
+  return hasError ? { stdout: "", stderr: output, exitCode: 1 } : { stdout: output, stderr: "", exitCode: 0 };
+}
+async function handleUninstall(sandboxRef, args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    return {
+      stdout: `Usage: sandlot uninstall <package> [...packages]
+
+Examples:
+  sandlot uninstall lodash
+  sandlot uninstall react react-dom
+
+Aliases: sandlot remove, sandlot rm
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  const packages = args.filter((a) => !!a && !a.startsWith("-"));
+  if (packages.length === 0) {
+    return {
+      stdout: "",
+      stderr: `Usage: sandlot uninstall <package> [...packages]
+
+Run 'sandlot uninstall --help' for more information.
+`,
+      exitCode: 1
+    };
+  }
+  const results = [];
+  let hasError = false;
+  for (const packageName of packages) {
+    try {
+      const result = await sandboxRef.uninstall(packageName);
+      if (result.removed) {
+        results.push(`- ${result.name}`);
+      } else {
+        results.push(`x ${packageName}: not installed`);
+        hasError = true;
+      }
+    } catch (err) {
+      hasError = true;
+      const message = err instanceof Error ? err.message : String(err);
+      results.push(`x ${packageName}: ${message}`);
+    }
+  }
+  const output = results.join(`
+`) + `
+`;
+  return hasError ? { stdout: "", stderr: output, exitCode: 1 } : { stdout: output, stderr: "", exitCode: 0 };
+}
+async function handleRun(sandboxRef, args) {
+  let entryPoint;
+  let skipTypecheck = false;
+  let timeout = 30000;
+  let entryExport = "main";
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--skip-typecheck" || arg === "-s") {
+      skipTypecheck = true;
+    } else if ((arg === "--timeout" || arg === "-t") && args[i + 1]) {
+      const t = parseInt(args[++i], 10);
+      if (!isNaN(t))
+        timeout = t;
+    } else if ((arg === "--entry" || arg === "-e") && args[i + 1]) {
+      entryPoint = args[++i];
+    } else if ((arg === "--export" || arg === "-x") && args[i + 1]) {
+      const e = args[++i].toLowerCase();
+      if (e === "main" || e === "default") {
+        entryExport = e;
+      }
+    } else if (arg === "--help" || arg === "-h") {
+      return {
+        stdout: `Usage: sandlot run [options]
+
+Options:
+  --entry, -e <path>      Entry point (default: from package.json main)
+  --skip-typecheck, -s    Skip type checking
+  --timeout, -t <ms>      Execution timeout (default: 30000, 0 = none)
+  --export, -x <name>     Export to call: main or default (default: main)
+  --help, -h              Show this help message
+
+Examples:
+  sandlot run
+  sandlot run --entry /src/main.ts
+  sandlot run --skip-typecheck --timeout 5000
+  sandlot run --export default
+`,
+        stderr: "",
+        exitCode: 0
+      };
+    } else if (arg && !arg.startsWith("-") && !entryPoint) {
+      entryPoint = arg;
+    }
+  }
+  try {
+    const result = await sandboxRef.run({
+      entryPoint,
+      skipTypecheck,
+      timeout,
+      entryExport
+    });
+    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 += `
+`;
+      } else {
+        stderr = `Run failed: ${result.error ?? "Unknown error"}
+`;
+      }
+      let stdout = "";
+      if (result.logs.length > 0) {
+        stdout = result.logs.join(`
+`) + `
+`;
+      }
+      return {
+        stdout,
+        stderr,
+        exitCode: 1
+      };
+    }
+    let output = "";
+    if (result.logs.length > 0) {
+      output = result.logs.join(`
+`) + `
+`;
+    }
+    if (result.returnValue !== undefined) {
+      const returnStr = typeof result.returnValue === "object" ? JSON.stringify(result.returnValue, null, 2) : String(result.returnValue);
+      output += `[return] ${returnStr}
+`;
+    }
+    if (result.executionTimeMs !== undefined) {
+      output += `
+Completed in ${result.executionTimeMs.toFixed(2)}ms
+`;
+    }
+    return {
+      stdout: output,
+      stderr: "",
+      exitCode: 0
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      stdout: "",
+      stderr: `Run error: ${message}
+`,
+      exitCode: 1
+    };
+  }
+}
+function createDefaultCommands(sandboxRef) {
+  return [createSandlotCommand(sandboxRef)];
+}
+
+// src/core/sandbox.ts
+var DEFAULT_ENTRY_POINT = "./index.ts";
+var TSCONFIG_PATH = "/tsconfig.json";
+var PACKAGE_JSON_PATH = "/package.json";
+var DEFAULT_PACKAGE_JSON = {
+  main: DEFAULT_ENTRY_POINT,
+  dependencies: {}
+};
+var DEFAULT_TSCONFIG = {
+  compilerOptions: {
+    target: "ES2020",
+    lib: ["ES2020", "DOM", "DOM.Iterable"],
+    module: "ESNext",
+    moduleResolution: "bundler",
+    jsx: "react-jsx",
+    strict: true,
+    noEmit: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    resolveJsonModule: true,
+    isolatedModules: true
+  },
+  include: ["**/*.ts", "**/*.tsx"],
+  exclude: ["node_modules"]
+};
+function parsePackageSpec(spec) {
+  if (spec.startsWith("@")) {
+    const slashIndex = spec.indexOf("/");
+    if (slashIndex === -1) {
+      return { name: spec };
+    }
+    const afterSlash = spec.slice(slashIndex + 1);
+    const atIndex2 = afterSlash.indexOf("@");
+    if (atIndex2 === -1) {
+      return { name: spec };
+    }
+    return {
+      name: spec.slice(0, slashIndex + 1 + atIndex2),
+      version: afterSlash.slice(atIndex2 + 1)
+    };
+  }
+  const atIndex = spec.indexOf("@");
+  if (atIndex === -1) {
+    return { name: spec };
+  }
+  return {
+    name: spec.slice(0, atIndex),
+    version: spec.slice(atIndex + 1)
+  };
+}
+function readPackageJson(fs) {
+  try {
+    if (fs.exists(PACKAGE_JSON_PATH)) {
+      const content = fs.readFile(PACKAGE_JSON_PATH);
+      return JSON.parse(content);
+    }
+  } catch {}
+  return {};
+}
+function getEntryPoint(fs) {
+  const pkg = readPackageJson(fs);
+  const main = pkg.main ?? DEFAULT_ENTRY_POINT;
+  if (main.startsWith("/")) {
+    return main;
+  }
+  if (main.startsWith("./")) {
+    return "/" + main.slice(2);
+  }
+  return "/" + main;
+}
+function getInstalledPackages(fs) {
+  const pkg = readPackageJson(fs);
+  return pkg.dependencies ?? {};
+}
+function saveInstalledPackages(fs, dependencies) {
+  let existing = {};
+  try {
+    if (fs.exists(PACKAGE_JSON_PATH)) {
+      const content = fs.readFile(PACKAGE_JSON_PATH);
+      existing = JSON.parse(content);
+    }
+  } catch {}
+  const updated = {
+    ...existing,
+    dependencies
+  };
+  fs.writeFile(PACKAGE_JSON_PATH, JSON.stringify(updated, null, 2));
+}
+function ensureDir(fs, path) {
+  if (path === "/" || path === "")
+    return;
+  if (fs.exists(path)) {
+    const stat = fs.stat(path);
+    if (stat.isDirectory)
+      return;
+  }
+  const parent = path.substring(0, path.lastIndexOf("/")) || "/";
+  ensureDir(fs, parent);
+  fs.mkdir(path);
+}
+async function createSandboxImpl(fs, options, context) {
+  const {
+    bundler,
+    typechecker,
+    typesResolver,
+    sharedModuleRegistry,
+    executor
+  } = context;
+  let lastBuild = null;
+  const onBuildCallbacks = new Set;
+  if (options.onBuild) {
+    onBuildCallbacks.add(options.onBuild);
+  }
+  if (options.initialFiles) {
+    for (const [path, content] of Object.entries(options.initialFiles)) {
+      const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+      const dir = normalizedPath.substring(0, normalizedPath.lastIndexOf("/"));
+      if (dir && dir !== "/") {
+        ensureDir(fs, dir);
+      }
+      fs.writeFile(normalizedPath, content);
+    }
+  }
+  if (!fs.exists(PACKAGE_JSON_PATH)) {
+    fs.writeFile(PACKAGE_JSON_PATH, JSON.stringify(DEFAULT_PACKAGE_JSON, null, 2));
+  }
+  if (!fs.exists(TSCONFIG_PATH)) {
+    fs.writeFile(TSCONFIG_PATH, JSON.stringify(DEFAULT_TSCONFIG, null, 2));
+  }
+  async function install(packageSpec) {
+    const { name, version } = parsePackageSpec(packageSpec);
+    let resolvedVersion = version ?? "latest";
+    let typesInstalled = false;
+    let typeFilesCount = 0;
+    let typesError;
+    const fromCache = false;
+    if (typesResolver) {
+      try {
+        const typeFiles = await typesResolver.resolveTypes(name, version);
+        const packageDir = `/node_modules/${name}`;
+        ensureDir(fs, packageDir);
+        let typesEntry = "index.d.ts";
+        for (const [filePath, content] of Object.entries(typeFiles)) {
+          const fullPath = filePath.startsWith("/") ? filePath : `${packageDir}/${filePath}`;
+          const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+          ensureDir(fs, dir);
+          fs.writeFile(fullPath, content);
+          typeFilesCount++;
+          const relativePath = fullPath.replace(`${packageDir}/`, "");
+          if (relativePath === "index.d.ts") {
+            typesEntry = "index.d.ts";
+          } else if (typesEntry === "index.d.ts" && relativePath.endsWith(".d.ts") && !relativePath.includes("/")) {
+            typesEntry = relativePath;
+          }
+        }
+        typesInstalled = typeFilesCount > 0;
+        if (typesInstalled) {
+          const pkgJsonPath = `${packageDir}/package.json`;
+          const pkgJson = {
+            name,
+            version: resolvedVersion,
+            types: typesEntry,
+            main: typesEntry.replace(/\.d\.ts$/, ".js")
+          };
+          fs.writeFile(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+        }
+        if (!version) {
+          resolvedVersion = "latest";
+        }
+      } catch (err) {
+        typesError = err instanceof Error ? err.message : String(err);
+      }
+    }
+    const dependencies = getInstalledPackages(fs);
+    dependencies[name] = resolvedVersion;
+    saveInstalledPackages(fs, dependencies);
+    return {
+      name,
+      version: resolvedVersion,
+      typesInstalled,
+      typeFilesCount,
+      typesError,
+      fromCache
+    };
+  }
+  async function uninstall(packageName) {
+    const dependencies = getInstalledPackages(fs);
+    if (!(packageName in dependencies)) {
+      return { name: packageName, removed: false };
+    }
+    delete dependencies[packageName];
+    saveInstalledPackages(fs, dependencies);
+    const typesPath = `/node_modules/${packageName}`;
+    if (fs.exists(typesPath)) {
+      fs.rm(typesPath, { recursive: true, force: true });
+    }
+    return { name: packageName, removed: true };
+  }
+  async function build(buildOptions) {
+    const buildEntryPoint = buildOptions?.entryPoint ?? getEntryPoint(fs);
+    const skipTypecheck = buildOptions?.skipTypecheck ?? false;
+    const minify = buildOptions?.minify ?? false;
+    const format = buildOptions?.format ?? "esm";
+    if (!fs.exists(buildEntryPoint)) {
+      return {
+        success: false,
+        phase: "entry",
+        message: `Entry point not found: ${buildEntryPoint}`
+      };
+    }
+    if (!skipTypecheck && typechecker) {
+      const typecheckResult = await typechecker.typecheck({
+        fs,
+        entryPoint: buildEntryPoint,
+        tsconfigPath: TSCONFIG_PATH
+      });
+      if (!typecheckResult.success) {
+        return {
+          success: false,
+          phase: "typecheck",
+          diagnostics: typecheckResult.diagnostics
+        };
+      }
+    }
+    const installedPackages = getInstalledPackages(fs);
+    const bundleResult = await bundler.bundle({
+      fs,
+      entryPoint: buildEntryPoint,
+      installedPackages,
+      sharedModules: sharedModuleRegistry?.list() ?? [],
+      sharedModuleRegistry: sharedModuleRegistry ?? undefined,
+      format,
+      minify
+    });
+    if (!bundleResult.success) {
+      return {
+        success: false,
+        phase: "bundle",
+        bundleErrors: bundleResult.errors,
+        bundleWarnings: bundleResult.warnings
+      };
+    }
+    const output = {
+      success: true,
+      code: bundleResult.code,
+      includedFiles: bundleResult.includedFiles,
+      warnings: bundleResult.warnings
+    };
+    lastBuild = output;
+    for (const callback of onBuildCallbacks) {
+      try {
+        await callback(output);
+      } catch (err) {
+        console.error("[sandlot] onBuild callback error:", err);
+      }
+    }
+    return output;
+  }
+  async function typecheck(typecheckOptions) {
+    if (!typechecker) {
+      return { success: true, diagnostics: [] };
+    }
+    const checkEntryPoint = typecheckOptions?.entryPoint ?? getEntryPoint(fs);
+    if (!fs.exists(checkEntryPoint)) {
+      return {
+        success: false,
+        diagnostics: [
+          {
+            message: `Entry point not found: ${checkEntryPoint}`,
+            severity: "error"
+          }
+        ]
+      };
+    }
+    return typechecker.typecheck({
+      fs,
+      entryPoint: checkEntryPoint,
+      tsconfigPath: TSCONFIG_PATH
+    });
+  }
+  async function run(runOptions) {
+    if (!executor) {
+      throw new Error("[sandlot] No executor configured. Provide an executor when creating Sandlot to use run().");
+    }
+    const buildResult = await build({
+      entryPoint: runOptions?.entryPoint,
+      skipTypecheck: runOptions?.skipTypecheck
+    });
+    if (!buildResult.success) {
+      return {
+        success: false,
+        logs: [],
+        error: buildResult.message ?? `Build failed in ${buildResult.phase} phase`,
+        buildFailure: {
+          phase: buildResult.phase,
+          message: buildResult.message
+        }
+      };
+    }
+    const executeResult = await executor.execute(buildResult.code, {
+      entryExport: runOptions?.entryExport ?? "main",
+      context: runOptions?.context,
+      timeout: runOptions?.timeout
+    });
+    return {
+      success: executeResult.success,
+      logs: executeResult.logs,
+      returnValue: executeResult.returnValue,
+      error: executeResult.error,
+      executionTimeMs: executeResult.executionTimeMs
+    };
+  }
+  const sandboxRef = {
+    fs,
+    install,
+    uninstall,
+    build,
+    typecheck,
+    run
+  };
+  let bashInstance = null;
+  function getBash() {
+    if (!bashInstance) {
+      const commands = createDefaultCommands(sandboxRef);
+      bashInstance = new Bash({
+        cwd: "/",
+        fs: wrapFilesystemForJustBash(fs),
+        customCommands: commands
+      });
+    }
+    return bashInstance;
+  }
+  async function exec(command) {
+    const bash = getBash();
+    const result = await bash.exec(command);
+    return {
+      exitCode: result.exitCode,
+      stdout: result.stdout,
+      stderr: result.stderr
+    };
+  }
+  return {
+    fs,
+    exec,
+    get lastBuild() {
+      return lastBuild;
+    },
+    getState() {
+      return { files: fs.getFiles() };
+    },
+    onBuild(callback) {
+      onBuildCallbacks.add(callback);
+      return () => {
+        onBuildCallbacks.delete(callback);
+      };
+    },
+    install,
+    uninstall,
+    build,
+    typecheck,
+    run,
+    readFile: (path) => fs.readFile(path),
+    writeFile: (path, content) => fs.writeFile(path, content)
+  };
+}
+
+// src/core/sandlot.ts
+function createSandlot(options) {
+  const {
+    bundler,
+    typechecker,
+    typesResolver,
+    executor,
+    sharedModules,
+    sandboxDefaults = {}
+  } = options;
+  const sharedModuleRegistry = createSharedModuleRegistry(sharedModules);
+  const sandboxContext = {
+    bundler,
+    typechecker,
+    typesResolver,
+    sharedModuleRegistry,
+    executor
+  };
+  return {
+    async createSandbox(sandboxOptions = {}) {
+      const fs = Filesystem.create({
+        maxSizeBytes: sandboxOptions.maxFilesystemSize ?? sandboxDefaults.maxFilesystemSize
+      });
+      return createSandboxImpl(fs, sandboxOptions, sandboxContext);
+    },
+    get sharedModules() {
+      return sharedModuleRegistry;
+    }
+  };
+}
+
+// src/core/esm-types-resolver.ts
+class InMemoryTypesCache {
+  cache = new Map;
+  async get(key) {
+    return this.cache.get(key) ?? null;
+  }
+  async set(key, value) {
+    this.cache.set(key, value);
+  }
+  async has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+}
+
+class EsmTypesResolver {
+  baseUrl;
+  cache;
+  tryTypesPackages;
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl ?? "https://esm.sh";
+    this.cache = options.cache ?? null;
+    this.tryTypesPackages = options.tryTypesPackages ?? true;
+  }
+  async resolveTypes(specifier, version) {
+    const resolved = await this.resolve(specifier, version);
+    if (!resolved) {
+      return {};
+    }
+    const result = {};
+    const pkgPath = `/node_modules/${resolved.packageName}`;
+    for (const [relativePath, content] of Object.entries(resolved.files)) {
+      result[`${pkgPath}/${relativePath}`] = content;
+    }
+    return result;
+  }
+  async resolve(specifier, version) {
+    const { packageName, subpath } = parseSpecifier(specifier);
+    const cacheKey = makeCacheKey(packageName, subpath, version);
+    if (this.cache) {
+      const cached = await this.cache.get(cacheKey);
+      if (cached) {
+        return cached;
+      }
+    }
+    let result = await this.tryResolve(packageName, subpath, version);
+    if (!result && this.tryTypesPackages && !packageName.startsWith("@types/")) {
+      const typesPackageName = toTypesPackageName(packageName);
+      result = await this.tryResolve(typesPackageName, subpath, version);
+      if (result) {
+        result.fromTypesPackage = true;
+        result.packageName = packageName;
+      }
+    }
+    if (result && this.cache) {
+      await this.cache.set(cacheKey, result);
+    }
+    return result;
+  }
+  async tryResolve(packageName, subpath, version) {
+    try {
+      const versionSuffix = version ? `@${version}` : "";
+      const pathSuffix = subpath ? `/${subpath}` : "";
+      const url = `${this.baseUrl}/${packageName}${versionSuffix}${pathSuffix}`;
+      const response = await fetch(url, { method: "HEAD" });
+      if (!response.ok) {
+        return null;
+      }
+      const resolvedVersion = this.extractVersion(response, packageName, version);
+      const typesHeader = response.headers.get("X-TypeScript-Types");
+      if (!typesHeader) {
+        return null;
+      }
+      const typesUrl = new URL(typesHeader, response.url).href;
+      const files = await this.fetchTypesRecursively(typesUrl, subpath);
+      if (Object.keys(files).length === 0) {
+        return null;
+      }
+      return {
+        packageName,
+        version: resolvedVersion,
+        files,
+        fromTypesPackage: packageName.startsWith("@types/")
+      };
+    } catch {
+      return null;
+    }
+  }
+  async fetchTypesRecursively(entryUrl, subpath, visited = new Set) {
+    if (visited.has(entryUrl)) {
+      return {};
+    }
+    visited.add(entryUrl);
+    const response = await fetch(entryUrl);
+    if (!response.ok) {
+      return {};
+    }
+    const content = await response.text();
+    const files = {};
+    const fileName = subpath ? `${subpath}.d.ts` : "index.d.ts";
+    files[fileName] = content;
+    if (subpath) {
+      files[`${subpath}/index.d.ts`] = content;
+    }
+    const refs = parseReferences(content);
+    for (const ref of refs.paths) {
+      const refUrl = new URL(ref, entryUrl).href;
+      const refFiles = await this.fetchTypesRecursively(refUrl, undefined, visited);
+      for (const [refPath, refContent] of Object.entries(refFiles)) {
+        const normalizedRef = ref.replace(/^\.\//, "");
+        if (refPath === "index.d.ts") {
+          files[normalizedRef] = refContent;
+        } else {
+          const dir = normalizedRef.replace(/\.d\.ts$/, "");
+          files[`${dir}/${refPath}`] = refContent;
+        }
+      }
+    }
+    return files;
+  }
+  extractVersion(response, packageName, requestedVersion) {
+    const esmId = response.headers.get("x-esm-id");
+    if (esmId) {
+      const match = esmId.match(new RegExp(`${escapeRegex(packageName)}@([^/]+)`));
+      if (match?.[1]) {
+        return match[1];
+      }
+    }
+    const urlMatch = response.url.match(new RegExp(`${escapeRegex(packageName)}@([^/]+)`));
+    if (urlMatch?.[1]) {
+      return urlMatch[1];
+    }
+    return requestedVersion ?? "latest";
+  }
+}
+function parseSpecifier(specifier) {
+  if (specifier.startsWith("@")) {
+    const parts = specifier.split("/");
+    if (parts.length >= 2) {
+      const packageName = `${parts[0]}/${parts[1]}`;
+      const subpath = parts.length > 2 ? parts.slice(2).join("/") : undefined;
+      return { packageName, subpath };
+    }
+    return { packageName: specifier, subpath: undefined };
+  }
+  const slashIndex = specifier.indexOf("/");
+  if (slashIndex === -1) {
+    return { packageName: specifier, subpath: undefined };
+  }
+  return {
+    packageName: specifier.slice(0, slashIndex),
+    subpath: specifier.slice(slashIndex + 1)
+  };
+}
+function toTypesPackageName(packageName) {
+  if (packageName.startsWith("@")) {
+    return "@types/" + packageName.slice(1).replace("/", "__");
+  }
+  return `@types/${packageName}`;
+}
+function parseReferences(content) {
+  const paths = [];
+  const types = [];
+  const pathRegex = /\/\/\/\s*<reference\s+path="([^"]+)"\s*\/>/g;
+  let match;
+  while ((match = pathRegex.exec(content)) !== null) {
+    if (match[1])
+      paths.push(match[1]);
+  }
+  const typesRegex = /\/\/\/\s*<reference\s+types="([^"]+)"\s*\/>/g;
+  while ((match = typesRegex.exec(content)) !== null) {
+    if (match[1])
+      types.push(match[1]);
+  }
+  return { paths, types };
+}
+function makeCacheKey(packageName, subpath, version) {
+  const base = version ? `${packageName}@${version}` : packageName;
+  return subpath ? `${base}/${subpath}` : base;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/node/preset.ts
+async function createNodeSandlot(options = {}) {
+  const { bundler, typechecker, typesResolver, executor, ...rest } = options;
+  const bundlerInstance = isBundler(bundler) ? bundler : new EsbuildNativeBundler(bundler);
+  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 NodeExecutor(executor);
+  return createSandlot({
+    ...rest,
+    bundler: bundlerInstance,
+    typechecker: typecheckerInstance,
+    typesResolver: typesResolverInstance,
+    executor: executorInstance
+  });
+}
+function isBundler(value) {
+  return typeof value === "object" && value !== null && "bundle" in value && typeof value.bundle === "function";
+}
+function isTypechecker(value) {
+  return typeof value === "object" && value !== null && "typecheck" in value && typeof value.typecheck === "function";
+}
+function isTypesResolver(value) {
+  return typeof value === "object" && value !== null && "resolveTypes" in value && typeof value.resolveTypes === "function";
+}
+function isExecutor(value) {
+  return typeof value === "object" && value !== null && "execute" in value && typeof value.execute === "function";
+}
+export {
+  createTypechecker,
+  createNodeSandlot,
+  createNodeExecutor,
+  createEsbuildNativeBundler,
+  Typechecker,
+  NodeExecutor,
+  EsbuildNativeBundler
+};