sandlot 0.1.4 → 0.2.0

package/dist/index.js

@@ -6,10 +6,101 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// src/sandbox.ts
+// 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/fs.ts
+// src/core/fs.ts
 var DEFAULT_FILE_MODE = 420;
 var DEFAULT_DIR_MODE = 493;
 var DEFAULT_SYMLINK_MODE = 511;
@@ -73,7 +164,7 @@ class Filesystem {
     }
     return size;
   }
-  async readFile(path, options) {
+  readFile(path, options) {
     const normalizedPath = this.normalizePath(path);
     const entry = this.resolveSymlinks(normalizedPath);
     if (!entry) {
@@ -89,7 +180,7 @@ class Filesystem {
     const encoding = this.getEncoding(options) ?? "utf8";
     return this.decodeBuffer(content, encoding);
   }
-  async readFileBuffer(path) {
+  readFileBuffer(path) {
     const normalizedPath = this.normalizePath(path);
     const entry = this.resolveSymlinks(normalizedPath);
     if (!entry) {
@@ -104,7 +195,7 @@ class Filesystem {
     }
     return new TextEncoder().encode(content);
   }
-  async writeFile(path, content, _options) {
+  writeFile(path, content, _options) {
     const normalizedPath = this.normalizePath(path);
     this.checkSizeLimit(content);
     this.ensureParentDirs(normalizedPath);
@@ -119,20 +210,20 @@ class Filesystem {
       mtime: new Date
     });
   }
-  async appendFile(path, content, options) {
+  appendFile(path, content, options) {
     const normalizedPath = this.normalizePath(path);
     let existing = "";
     try {
-      existing = await this.readFile(normalizedPath);
+      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);
-    await this.writeFile(normalizedPath, newContent, options);
+    this.writeFile(normalizedPath, newContent, options);
   }
-  async exists(path) {
+  exists(path) {
     const normalizedPath = this.normalizePath(path);
     return this.entries.has(normalizedPath);
   }
-  async stat(path) {
+  stat(path) {
     const normalizedPath = this.normalizePath(path);
     const entry = this.resolveSymlinks(normalizedPath);
     if (!entry) {
@@ -140,7 +231,7 @@ class Filesystem {
     }
     return this.entryToStat(entry);
   }
-  async lstat(path) {
+  lstat(path) {
     const normalizedPath = this.normalizePath(path);
     const entry = this.entries.get(normalizedPath);
     if (!entry) {
@@ -148,7 +239,7 @@ class Filesystem {
     }
     return this.entryToStat(entry);
   }
-  async mkdir(path, options) {
+  mkdir(path, options) {
     const normalizedPath = this.normalizePath(path);
     if (this.entries.has(normalizedPath)) {
       if (options?.recursive) {
@@ -170,7 +261,7 @@ class Filesystem {
       mtime: new Date
     });
   }
-  async readdir(path) {
+  readdir(path) {
     const normalizedPath = this.normalizePath(path);
     const entry = this.resolveSymlinks(normalizedPath);
     if (!entry) {
@@ -193,7 +284,7 @@ class Filesystem {
     }
     return names.sort();
   }
-  async readdirWithFileTypes(path) {
+  readdirWithFileTypes(path) {
     const normalizedPath = this.normalizePath(path);
     const entry = this.resolveSymlinks(normalizedPath);
     if (!entry) {
@@ -221,7 +312,7 @@ class Filesystem {
     }
     return dirents.sort((a, b) => a.name.localeCompare(b.name));
   }
-  async rm(path, options) {
+  rm(path, options) {
     const normalizedPath = this.normalizePath(path);
     const entry = this.entries.get(normalizedPath);
     if (!entry) {
@@ -230,7 +321,7 @@ class Filesystem {
       throw new Error(`ENOENT: no such file or directory, rm '${path}'`);
     }
     if (entry.type === "directory") {
-      const children = await this.readdir(normalizedPath);
+      const children = this.readdir(normalizedPath);
       if (children.length > 0 && !options?.recursive) {
         throw new Error(`ENOTEMPTY: directory not empty, rm '${path}'`);
       }
@@ -245,7 +336,7 @@ class Filesystem {
     }
     this.entries.delete(normalizedPath);
   }
-  async cp(src, dest, options) {
+  cp(src, dest, options) {
     const srcPath = this.normalizePath(src);
     const destPath = this.normalizePath(dest);
     const entry = this.entries.get(srcPath);
@@ -271,7 +362,7 @@ class Filesystem {
       this.entries.set(destPath, this.cloneEntry(entry));
     }
   }
-  async mv(src, dest) {
+  mv(src, dest) {
     const srcPath = this.normalizePath(src);
     const destPath = this.normalizePath(dest);
     const entry = this.entries.get(srcPath);
@@ -317,7 +408,7 @@ class Filesystem {
   getAllPaths() {
     return [...this.entries.keys()].sort();
   }
-  async chmod(path, mode) {
+  chmod(path, mode) {
     const normalizedPath = this.normalizePath(path);
     const entry = this.entries.get(normalizedPath);
     if (!entry) {
@@ -326,7 +417,7 @@ class Filesystem {
     entry.mode = mode;
     entry.mtime = new Date;
   }
-  async symlink(target, linkPath) {
+  symlink(target, linkPath) {
     const normalizedLinkPath = this.normalizePath(linkPath);
     if (this.entries.has(normalizedLinkPath)) {
       throw new Error(`EEXIST: file already exists, symlink '${linkPath}'`);
@@ -339,7 +430,7 @@ class Filesystem {
       mtime: new Date
     });
   }
-  async link(existingPath, newPath) {
+  link(existingPath, newPath) {
     const srcPath = this.normalizePath(existingPath);
     const destPath = this.normalizePath(newPath);
     const entry = this.entries.get(srcPath);
@@ -360,7 +451,7 @@ class Filesystem {
       mtime: new Date
     });
   }
-  async readlink(path) {
+  readlink(path) {
     const normalizedPath = this.normalizePath(path);
     const entry = this.entries.get(normalizedPath);
     if (!entry) {
@@ -371,7 +462,7 @@ class Filesystem {
     }
     return entry.target;
   }
-  async realpath(path) {
+  realpath(path) {
     const normalizedPath = this.normalizePath(path);
     const parts = normalizedPath.split("/").filter(Boolean);
     let resolved = "/";
@@ -397,7 +488,7 @@ class Filesystem {
     }
     return resolved;
   }
-  async utimes(path, atime, mtime) {
+  utimes(path, atime, mtime) {
     const normalizedPath = this.normalizePath(path);
     const entry = this.entries.get(normalizedPath);
     if (!entry) {
@@ -541,39 +632,559 @@ class Filesystem {
 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/packages.ts
-var ESM_CDN_BASE = "https://esm.sh";
-var KNOWN_SUBPATHS = {
-  react: ["jsx-runtime", "jsx-dev-runtime"],
-  "react-dom": ["client", "server"]
-};
+// src/commands/index.ts
+import { defineCommand } from "just-bash/browser";
 
-class InMemoryTypesCache {
-  cache = new Map;
-  key(name, version) {
-    return `${name}@${version}`;
+// 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
+    };
   }
-  get(name, version) {
-    return this.cache.get(this.key(name, version)) ?? null;
+}
+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
+    };
   }
-  set(name, version, types) {
-    this.cache.set(this.key(name, version), types);
+  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
+    };
   }
-  has(name, version) {
-    return this.cache.has(this.key(name, version));
+  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}`);
+    }
   }
-  delete(name, version) {
-    return this.cache.delete(this.key(name, version));
+  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
+    };
   }
-  clear() {
-    this.cache.clear();
+  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;
+    }
   }
-  get size() {
-    return this.cache.size;
+  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("/");
@@ -599,1755 +1210,358 @@ function parsePackageSpec(spec) {
     version: spec.slice(atIndex + 1)
   };
 }
-function isTypesPackage(name) {
-  return name.startsWith("@types/");
-}
-function extractVersionFromUrl(url, packageName) {
-  const exactRegex = new RegExp(`${escapeRegExp(packageName)}@([^/]+)`);
-  const exactMatch = url.match(exactRegex);
-  if (exactMatch?.[1]) {
-    return exactMatch[1];
-  }
-  if (packageName.startsWith("@")) {
-    const scopedParts = packageName.split("/");
-    if (scopedParts.length === 2 && scopedParts[1]) {
-      const partialRegex = new RegExp(`${escapeRegExp(scopedParts[1])}@([^/]+)`);
-      const partialMatch = url.match(partialRegex);
-      if (partialMatch?.[1]) {
-        return partialMatch[1];
-      }
-    }
-  }
-  const genericMatch = url.match(/@(\d+\.\d+\.\d+[^/]*)/);
-  if (genericMatch?.[1]) {
-    return genericMatch[1];
-  }
-  return null;
-}
-async function fetchVersionFromNpm(name) {
-  const registryUrl = `https://registry.npmjs.org/${name}/latest`;
-  const response = await fetch(registryUrl);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch version from npm: ${response.status}`);
-  }
-  const data = await response.json();
-  return data.version;
-}
-function extractVersionFromHeaders(headers, packageName) {
-  const esmId = headers.get("x-esm-id");
-  if (esmId) {
-    const version = extractVersionFromUrl(esmId, packageName);
-    if (version)
-      return version;
-  }
-  const typesHeader = headers.get("X-TypeScript-Types");
-  if (typesHeader) {
-    const versionMatch = typesHeader.match(/@(\d+\.\d+\.\d+[^/]*)/);
-    if (versionMatch?.[1]) {
-      return versionMatch[1];
-    }
-  }
-  return null;
-}
-async function fetchPackageInfo(name, version, subpath) {
-  let url = version ? `${ESM_CDN_BASE}/${name}@${version}` : `${ESM_CDN_BASE}/${name}`;
-  if (subpath) {
-    url += `/${subpath}`;
-  }
-  const response = await fetch(url, { method: "HEAD" });
-  if (!response.ok) {
-    throw new Error(`Package not found: ${name}${version ? `@${version}` : ""}${subpath ? `/${subpath}` : ""}`);
-  }
-  const resolvedUrl = response.url;
-  let resolvedVersion = extractVersionFromUrl(resolvedUrl, name);
-  if (!resolvedVersion) {
-    resolvedVersion = extractVersionFromHeaders(response.headers, name);
-  }
-  if (!resolvedVersion && version && version !== "latest") {
-    resolvedVersion = version;
-  }
-  if (!resolvedVersion) {
-    try {
-      resolvedVersion = await fetchVersionFromNpm(name);
-    } catch (err) {
-      console.warn(`Could not resolve version for ${name}:`, err);
-      resolvedVersion = "latest";
-    }
-  }
-  const typesUrl = response.headers.get("X-TypeScript-Types") ?? undefined;
-  return {
-    version: resolvedVersion,
-    typesUrl: typesUrl ? new URL(typesUrl, resolvedUrl).href : undefined
-  };
-}
-function escapeRegExp(string) {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-async function fetchTypeDefinitions(typesUrl, packageName) {
-  const types = new Map;
+function readPackageJson(fs) {
   try {
-    const response = await fetch(typesUrl);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch types: ${response.status}`);
+    if (fs.exists(PACKAGE_JSON_PATH)) {
+      const content = fs.readFile(PACKAGE_JSON_PATH);
+      return JSON.parse(content);
     }
-    const content = await response.text();
-    const typePath = `/node_modules/${packageName}/index.d.ts`;
-    types.set(typePath, content);
-    const refs = parseTypeReferences(content);
-    await fetchReferencedTypes(refs, typesUrl, packageName, types);
-  } catch (err) {
-    console.warn(`Failed to fetch types for ${packageName}:`, err);
-    throw err;
-  }
-  return types;
-}
-function parseTypeReferences(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 };
-}
-async function fetchReferencedTypes(refs, baseUrl, packageName, collected, visited = new Set) {
-  for (const pathRef of refs.paths) {
-    const refUrl = new URL(pathRef, baseUrl).href;
-    if (visited.has(refUrl))
-      continue;
-    visited.add(refUrl);
-    try {
-      const response = await fetch(refUrl);
-      if (!response.ok)
-        continue;
-      const content = await response.text();
-      const fileName = pathRef.split("/").pop() ?? "types.d.ts";
-      const typePath = `/node_modules/${packageName}/${fileName}`;
-      collected.set(typePath, content);
-      const nestedRefs = parseTypeReferences(content);
-      await fetchReferencedTypes(nestedRefs, refUrl, packageName, collected, visited);
-    } catch {}
-  }
+  } catch {}
+  return {};
 }
-async function fetchSubpathTypes(packageName, subpath, version) {
-  const types = new Map;
-  try {
-    const info = await fetchPackageInfo(packageName, version, subpath);
-    if (!info.typesUrl) {
-      return types;
-    }
-    const response = await fetch(info.typesUrl);
-    if (!response.ok) {
-      return types;
-    }
-    const content = await response.text();
-    const typePath = `/node_modules/${packageName}/${subpath}.d.ts`;
-    types.set(typePath, content);
-    const indexTypePath = `/node_modules/${packageName}/${subpath}/index.d.ts`;
-    types.set(indexTypePath, content);
-    const refs = parseTypeReferences(content);
-    await fetchReferencedTypes(refs, info.typesUrl, packageName, types);
-  } catch (err) {
-    console.warn(`Failed to fetch types for ${packageName}/${subpath}:`, err);
+function getEntryPoint(fs) {
+  const pkg = readPackageJson(fs);
+  const main = pkg.main ?? DEFAULT_ENTRY_POINT;
+  if (main.startsWith("/")) {
+    return main;
   }
-  return types;
-}
-async function fetchTypesPackageContent(name, version) {
-  const url = version ? `${ESM_CDN_BASE}/${name}@${version}` : `${ESM_CDN_BASE}/${name}`;
-  const headResponse = await fetch(url, { method: "HEAD" });
-  if (!headResponse.ok) {
-    throw new Error(`Package not found: ${name}${version ? `@${version}` : ""}`);
-  }
-  const resolvedVersion = extractVersionFromUrl(headResponse.url, name) ?? version ?? "latest";
-  const indexUrl = `${ESM_CDN_BASE}/${name}@${resolvedVersion}/index.d.ts`;
-  const response = await fetch(indexUrl);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch types from ${name}: ${response.status}`);
-  }
-  const content = await response.text();
-  const types = new Map;
-  const typePath = `/node_modules/${name}/index.d.ts`;
-  types.set(typePath, content);
-  const refs = parseTypeReferences(content);
-  for (const pathRef of refs.paths) {
-    try {
-      const refUrl = new URL(pathRef, indexUrl).href;
-      const refResponse = await fetch(refUrl);
-      if (refResponse.ok) {
-        const refContent = await refResponse.text();
-        const fileName = pathRef.startsWith("./") ? pathRef.slice(2) : pathRef;
-        const refTypePath = `/node_modules/${name}/${fileName}`;
-        types.set(refTypePath, refContent);
-      }
-    } catch {}
+  if (main.startsWith("./")) {
+    return "/" + main.slice(2);
   }
-  return { version: resolvedVersion, types };
+  return "/" + main;
 }
-async function getPackageManifest(fs) {
-  try {
-    if (await fs.exists(PACKAGE_JSON_PATH)) {
-      const content = await fs.readFile(PACKAGE_JSON_PATH);
-      const parsed = JSON.parse(content);
-      return {
-        dependencies: parsed.dependencies ?? {}
-      };
-    }
-  } catch {}
-  return { dependencies: {} };
+function getInstalledPackages(fs) {
+  const pkg = readPackageJson(fs);
+  return pkg.dependencies ?? {};
 }
-async function savePackageManifest(fs, manifest) {
+function saveInstalledPackages(fs, dependencies) {
   let existing = {};
   try {
-    if (await fs.exists(PACKAGE_JSON_PATH)) {
-      const content = await fs.readFile(PACKAGE_JSON_PATH);
+    if (fs.exists(PACKAGE_JSON_PATH)) {
+      const content = fs.readFile(PACKAGE_JSON_PATH);
       existing = JSON.parse(content);
     }
   } catch {}
   const updated = {
     ...existing,
-    dependencies: manifest.dependencies
-  };
-  await fs.writeFile(PACKAGE_JSON_PATH, JSON.stringify(updated, null, 2));
-}
-async function installPackage(fs, packageSpec, options) {
-  const { name, version } = parsePackageSpec(packageSpec);
-  const { cache } = options ?? {};
-  if (isTypesPackage(name)) {
-    return installTypesPackage(fs, name, version, cache);
-  }
-  const info = await fetchPackageInfo(name, version);
-  const packageDir = `/node_modules/${name}`;
-  await ensureDir(fs, packageDir);
-  const packageJsonPath = `${packageDir}/package.json`;
-  const packageJson = {
-    name,
-    version: info.version,
-    types: "./index.d.ts",
-    main: "./index.js"
-  };
-  await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
-  let typeFiles = null;
-  let fromCache = false;
-  if (cache) {
-    typeFiles = cache.get(name, info.version);
-    if (typeFiles) {
-      fromCache = true;
-    }
-  }
-  let typesError;
-  if (!typeFiles) {
-    typeFiles = new Map;
-    if (info.typesUrl) {
-      try {
-        const mainTypes = await fetchTypeDefinitions(info.typesUrl, name);
-        for (const [path, content] of mainTypes) {
-          typeFiles.set(path, content);
-        }
-      } catch (err) {
-        typesError = err instanceof Error ? err.message : String(err);
-      }
-    } else {
-      typesError = "No TypeScript types available from esm.sh";
-    }
-    const knownSubpaths = KNOWN_SUBPATHS[name];
-    if (knownSubpaths && knownSubpaths.length > 0) {
-      const subpathResults = await Promise.allSettled(knownSubpaths.map((subpath) => fetchSubpathTypes(name, subpath, info.version)));
-      for (const result of subpathResults) {
-        if (result.status === "fulfilled") {
-          for (const [path, content] of result.value) {
-            typeFiles.set(path, content);
-          }
-        }
-      }
-    }
-    if (cache && typeFiles.size > 0) {
-      cache.set(name, info.version, typeFiles);
-    }
-  }
-  for (const [path, content] of typeFiles) {
-    const dir = path.substring(0, path.lastIndexOf("/"));
-    await ensureDir(fs, dir);
-    await fs.writeFile(path, content);
-  }
-  const manifest = await getPackageManifest(fs);
-  manifest.dependencies[name] = info.version;
-  await savePackageManifest(fs, manifest);
-  return {
-    name,
-    version: info.version,
-    typesInstalled: typeFiles.size > 0,
-    typeFilesCount: typeFiles.size,
-    typesError,
-    fromCache
-  };
-}
-async function installTypesPackage(fs, name, version, cache) {
-  const url = version ? `${ESM_CDN_BASE}/${name}@${version}` : `${ESM_CDN_BASE}/${name}`;
-  const headResponse = await fetch(url, { method: "HEAD" });
-  if (!headResponse.ok) {
-    throw new Error(`Package not found: ${name}${version ? `@${version}` : ""}`);
-  }
-  const resolvedVersion = extractVersionFromUrl(headResponse.url, name) ?? version ?? "latest";
-  let types = null;
-  let fromCache = false;
-  if (cache) {
-    types = cache.get(name, resolvedVersion);
-    if (types) {
-      fromCache = true;
-    }
-  }
-  if (!types) {
-    const result = await fetchTypesPackageContent(name, version);
-    types = result.types;
-    if (cache && types.size > 0) {
-      cache.set(name, resolvedVersion, types);
-    }
-  }
-  const packageDir = `/node_modules/${name}`;
-  await ensureDir(fs, packageDir);
-  const packageJsonPath = `${packageDir}/package.json`;
-  const packageJson = {
-    name,
-    version: resolvedVersion,
-    types: "./index.d.ts"
-  };
-  await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
-  for (const [path, content] of types) {
-    const dir = path.substring(0, path.lastIndexOf("/"));
-    await ensureDir(fs, dir);
-    await fs.writeFile(path, content);
-  }
-  const manifest = await getPackageManifest(fs);
-  manifest.dependencies[name] = resolvedVersion;
-  await savePackageManifest(fs, manifest);
-  return {
-    name,
-    version: resolvedVersion,
-    typesInstalled: types.size > 0,
-    typeFilesCount: types.size,
-    fromCache
+    dependencies
   };
+  fs.writeFile(PACKAGE_JSON_PATH, JSON.stringify(updated, null, 2));
 }
-async function ensureDir(fs, path) {
+function ensureDir(fs, path) {
   if (path === "/" || path === "")
     return;
-  if (await fs.exists(path)) {
-    const stat = await fs.stat(path);
+  if (fs.exists(path)) {
+    const stat = fs.stat(path);
     if (stat.isDirectory)
       return;
   }
   const parent = path.substring(0, path.lastIndexOf("/")) || "/";
-  await ensureDir(fs, parent);
-  await fs.mkdir(path);
-}
-async function uninstallPackage(fs, packageName) {
-  const manifest = await getPackageManifest(fs);
-  if (!(packageName in manifest.dependencies)) {
-    return false;
-  }
-  delete manifest.dependencies[packageName];
-  await savePackageManifest(fs, manifest);
-  const typesPath = `/node_modules/${packageName}`;
-  if (await fs.exists(typesPath)) {
-    await removePath(fs, typesPath);
-  }
-  return true;
-}
-async function removePath(fs, path) {
-  if (!await fs.exists(path))
-    return;
-  await fs.rm(path, { recursive: true, force: true });
+  ensureDir(fs, parent);
+  fs.mkdir(path);
 }
-function resolveToEsmUrl(importPath, installedPackages) {
-  const { packageName, subpath } = parseImportPath(importPath);
-  const version = installedPackages[packageName];
-  if (!version) {
-    return null;
-  }
-  const baseUrl = `${ESM_CDN_BASE}/${packageName}@${version}`;
-  return subpath ? `${baseUrl}/${subpath}` : baseUrl;
-}
-function parseImportPath(importPath) {
-  if (importPath.startsWith("@")) {
-    const parts = importPath.split("/");
-    if (parts.length >= 2) {
-      const packageName = `${parts[0]}/${parts[1]}`;
-      const subpath = parts.slice(2).join("/") || undefined;
-      return { packageName, subpath };
+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);
+      }
     }
-    return { packageName: importPath };
-  }
-  const slashIndex = importPath.indexOf("/");
-  if (slashIndex === -1) {
-    return { packageName: importPath };
-  }
-  return {
-    packageName: importPath.slice(0, slashIndex),
-    subpath: importPath.slice(slashIndex + 1)
-  };
-}
-async function listPackages(fs) {
-  const manifest = await getPackageManifest(fs);
-  return Object.entries(manifest.dependencies).map(([name, version]) => ({
-    name,
-    version
-  }));
-}
-
-// src/shared-modules.ts
-var GLOBAL_KEY = "__sandlot_shared_modules__";
-
-class SharedModuleRegistry {
-  modules = new Map;
-  exportNames = new Map;
-  constructor() {
-    globalThis[GLOBAL_KEY] = this;
-  }
-  register(moduleId, module) {
-    this.modules.set(moduleId, module);
-    this.exportNames.set(moduleId, introspectExports(module));
-    return this;
+    const dependencies = getInstalledPackages(fs);
+    dependencies[name] = resolvedVersion;
+    saveInstalledPackages(fs, dependencies);
+    return {
+      name,
+      version: resolvedVersion,
+      typesInstalled,
+      typeFilesCount,
+      typesError,
+      fromCache
+    };
   }
-  registerAll(modules) {
-    for (const [id, mod] of Object.entries(modules)) {
-      this.register(id, mod);
+  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}`
+      };
     }
-    return this;
-  }
-  unregister(moduleId) {
-    return this.modules.delete(moduleId);
-  }
-  get(moduleId) {
-    const mod = this.modules.get(moduleId);
-    if (mod === undefined && !this.modules.has(moduleId)) {
-      const available = this.list();
-      throw new Error(`Shared module "${moduleId}" not registered. ` + `Available: ${available.length > 0 ? available.join(", ") : "(none)"}. ` + `Call registerSharedModules({ '${moduleId}': ... }) in your host application.`);
+    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
+        };
+      }
     }
-    return mod;
-  }
-  has(moduleId) {
-    return this.modules.has(moduleId);
-  }
-  list() {
-    return [...this.modules.keys()];
-  }
-  getExportNames(moduleId) {
-    return this.exportNames.get(moduleId) ?? [];
-  }
-  clear() {
-    this.modules.clear();
-    this.exportNames.clear();
-  }
-  get size() {
-    return this.modules.size;
-  }
-}
-function 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 (isValidIdentifier(key)) {
-      exports.push(key);
+    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
+      };
     }
-  }
-  return exports;
-}
-function isValidIdentifier(name) {
-  if (name.length === 0)
-    return false;
-  if (!/^[a-zA-Z_$]/.test(name))
-    return false;
-  if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name))
-    return false;
-  const reserved = ["default", "class", "function", "var", "let", "const", "import", "export"];
-  if (reserved.includes(name))
-    return false;
-  return true;
-}
-var defaultRegistry = null;
-function getSharedModuleRegistry() {
-  if (!defaultRegistry) {
-    defaultRegistry = new SharedModuleRegistry;
-  }
-  return defaultRegistry;
-}
-function hasSharedModuleRegistry() {
-  return GLOBAL_KEY in globalThis;
-}
-function registerSharedModules(modules) {
-  getSharedModuleRegistry().registerAll(modules);
-}
-function unregisterSharedModule(moduleId) {
-  return getSharedModuleRegistry().unregister(moduleId);
-}
-function clearSharedModules() {
-  getSharedModuleRegistry().clear();
-}
-function getSharedModuleExports(moduleId) {
-  return getSharedModuleRegistry().getExportNames(moduleId);
-}
-function getSharedModuleRuntimeCode(moduleId) {
-  return `
-(function() {
-  var registry = globalThis["${GLOBAL_KEY}"];
-  if (!registry) {
-    throw new Error(
-      'Sandlot SharedModuleRegistry not found. ' +
-      'Call registerSharedModules() in your host application before loading dynamic modules.'
-    );
-  }
-  return registry.get(${JSON.stringify(moduleId)});
-})()
-`.trim();
-}
-
-// src/bundler.ts
-var esbuild = null;
-function isServerEnvironment() {
-  if (typeof globalThis !== "undefined" && "Bun" in globalThis) {
-    return true;
-  }
-  if (typeof globalThis !== "undefined" && "Deno" in globalThis) {
-    return true;
-  }
-  if (typeof process !== "undefined" && process.versions?.node) {
-    return true;
-  }
-  return false;
-}
-async function getEsbuild() {
-  if (esbuild)
-    return esbuild;
-  if (isServerEnvironment()) {
-    const mod = await import("esbuild");
-    esbuild = mod.default ?? mod;
-  } else {
-    const cdnUrl = `https://esm.sh/esbuild-wasm@${ESBUILD_VERSION}`;
-    const mod = await import(cdnUrl);
-    esbuild = mod.default ?? mod;
-    if (typeof esbuild?.initialize !== "function") {
-      console.error("esbuild-wasm module structure:", mod);
-      throw new Error("Failed to load esbuild-wasm: initialize function not found");
-    }
-  }
-  return esbuild;
-}
-var ESBUILD_VERSION = "0.27.2";
-var initialized = false;
-var initPromise = null;
-function getWasmUrl() {
-  return `https://unpkg.com/esbuild-wasm@${ESBUILD_VERSION}/esbuild.wasm`;
-}
-function checkCrossOriginIsolation() {
-  if (typeof window === "undefined")
-    return;
-  if (!window.crossOriginIsolated) {
-    console.warn(`[sandlot] Cross-origin isolation is not enabled. esbuild-wasm may have reduced performance or fail on some browsers.
-To enable, add these headers to your dev server:
-  Cross-Origin-Embedder-Policy: require-corp
-  Cross-Origin-Opener-Policy: same-origin
-In Vite, add a plugin to configureServer. See sandlot README for details.`);
-  }
-}
-async function initBundler() {
-  if (initialized)
-    return;
-  if (initPromise) {
-    await initPromise;
-    return;
-  }
-  initPromise = (async () => {
-    const es = await getEsbuild();
-    if (!isServerEnvironment() && typeof es.initialize === "function") {
-      checkCrossOriginIsolation();
-      await es.initialize({
-        wasmURL: getWasmUrl()
-      });
+    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);
+      }
     }
-  })();
-  await initPromise;
-  initialized = true;
-}
-function isBareImport(path) {
-  return !path.startsWith(".") && !path.startsWith("/");
-}
-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 matchesSharedModule(importPath, sharedModuleIds) {
-  if (sharedModuleIds.has(importPath)) {
-    return importPath;
+    return output;
   }
-  for (const moduleId of sharedModuleIds) {
-    if (importPath === moduleId || importPath.startsWith(moduleId + "/")) {
-      return importPath;
+  async function typecheck(typecheckOptions) {
+    if (!typechecker) {
+      return { success: true, diagnostics: [] };
     }
-  }
-  return null;
-}
-function createVfsPlugin(options) {
-  const {
-    fs,
-    entryPoint,
-    npmImports,
-    installedPackages,
-    includedFiles,
-    sharedModuleIds
-  } = options;
-  return {
-    name: "virtual-fs",
-    setup(build) {
-      build.onResolve({ filter: /.*/ }, async (args) => {
-        if (args.kind === "entry-point") {
-          return { path: entryPoint, namespace: "vfs" };
-        }
-        if (isBareImport(args.path)) {
-          const sharedMatch = matchesSharedModule(args.path, sharedModuleIds);
-          if (sharedMatch) {
-            return {
-              path: sharedMatch,
-              namespace: "sandlot-shared"
-            };
-          }
-          switch (npmImports) {
-            case "cdn": {
-              const esmUrl = resolveToEsmUrl(args.path, installedPackages);
-              if (esmUrl) {
-                return { path: esmUrl, external: true };
-              }
-              return { path: args.path, external: true };
-            }
-            case "external":
-              return { path: args.path, external: true };
-            case "bundle": {
-              const resolved2 = fs.resolvePath(args.resolveDir, `node_modules/${args.path}`);
-              const exists = await fs.exists(resolved2);
-              if (exists) {
-                return { path: resolved2, namespace: "vfs" };
-              }
-              return { path: args.path, external: true };
-            }
-          }
-        }
-        const resolved = fs.resolvePath(args.resolveDir, args.path);
-        const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".json"];
-        const hasExtension = extensions.some((ext) => resolved.endsWith(ext));
-        if (hasExtension) {
-          const exists = await fs.exists(resolved);
-          if (exists) {
-            return { path: resolved, namespace: "vfs" };
-          }
-          return { errors: [{ text: `File not found: ${resolved}` }] };
-        }
-        for (const ext of extensions) {
-          const withExt = resolved + ext;
-          if (await fs.exists(withExt)) {
-            return { path: withExt, namespace: "vfs" };
-          }
-        }
-        for (const ext of extensions) {
-          const indexPath = `${resolved}/index${ext}`;
-          if (await fs.exists(indexPath)) {
-            return { path: indexPath, namespace: "vfs" };
+    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
         }
-        return { errors: [{ text: `Cannot resolve: ${args.path} from ${args.resolveDir}` }] };
-      });
-      build.onLoad({ filter: /.*/, namespace: "sandlot-shared" }, (args) => {
-        const contents = `
-const __sandlot_mod__ = ${getSharedModuleRuntimeCode(args.path)};
-export default __sandlot_mod__.default ?? __sandlot_mod__;
-${generateNamedExports(args.path)}
-`;
-        return {
-          contents: contents.trim(),
-          loader: "js"
-        };
-      });
-      build.onLoad({ filter: /.*/, namespace: "vfs" }, async (args) => {
-        try {
-          const contents = await fs.readFile(args.path);
-          includedFiles.add(args.path);
-          return {
-            contents,
-            loader: getLoader(args.path),
-            resolveDir: args.path.substring(0, args.path.lastIndexOf("/"))
-          };
-        } catch (err) {
-          return {
-            errors: [{ text: `Failed to read ${args.path}: ${err}` }]
-          };
-        }
-      });
+      };
     }
-  };
-}
-function generateNamedExports(moduleId) {
-  const exports = getSharedModuleExports(moduleId);
-  if (exports.length > 0) {
-    return exports.map((name) => `export const ${name} = __sandlot_mod__.${name};`).join(`
-`);
+    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
+    };
   }
-  return `// No exports discovered for "${moduleId}" - use default import or call registerSharedModules() first`;
-}
-async function bundle(options) {
-  await initBundler();
-  const {
+  const sandboxRef = {
     fs,
-    entryPoint,
-    external = [],
-    npmImports = "cdn",
-    sharedModules = [],
-    format = "esm",
-    minify = false,
-    sourcemap = false,
-    globalName,
-    target = ["es2020"]
-  } = options;
-  const normalizedEntry = entryPoint.startsWith("/") ? entryPoint : `/${entryPoint}`;
-  if (!await fs.exists(normalizedEntry)) {
-    throw new Error(`Entry point not found: ${normalizedEntry}`);
-  }
-  const manifest = await getPackageManifest(fs);
-  const installedPackages = manifest.dependencies;
-  const sharedModuleIds = new Set(sharedModules);
-  const includedFiles = new Set;
-  const plugin = createVfsPlugin({
-    fs,
-    entryPoint: normalizedEntry,
-    npmImports,
-    installedPackages,
-    includedFiles,
-    sharedModuleIds
-  });
-  const es = await getEsbuild();
-  const result = await es.build({
-    entryPoints: [normalizedEntry],
-    bundle: true,
-    write: false,
-    format,
-    minify,
-    sourcemap: sourcemap ? "inline" : false,
-    globalName,
-    target,
-    external,
-    plugins: [plugin],
-    jsx: "automatic"
-  });
-  const code = result.outputFiles?.[0]?.text ?? "";
-  return {
-    code,
-    warnings: result.warnings,
-    includedFiles: Array.from(includedFiles)
+    install,
+    uninstall,
+    build,
+    typecheck,
+    run
   };
-}
-async function bundleToUrl(options) {
-  const result = await bundle(options);
-  const blob = new Blob([result.code], { type: "application/javascript" });
-  return URL.createObjectURL(blob);
-}
-async function bundleAndImport(options) {
-  const url = await bundleToUrl(options);
-  try {
-    return await import(url);
-  } finally {
-    URL.revokeObjectURL(url);
-  }
-}
-
-// src/commands/types.ts
-function formatEsbuildMessages(messages) {
-  if (messages.length === 0)
-    return "";
-  return messages.map((msg) => {
-    if (msg.location) {
-      const { file, line, column } = msg.location;
-      const loc = file ? `${file}${line ? `:${line}` : ""}${column ? `:${column}` : ""}` : "";
-      return loc ? `${loc}: ${msg.text}` : msg.text;
-    }
-    return msg.text;
-  }).join(`
-`);
-}
-// src/commands/compile.ts
-import { defineCommand } from "just-bash/browser";
-
-// src/typechecker.ts
-import ts from "typescript";
-function categoryToString(category) {
-  switch (category) {
-    case ts.DiagnosticCategory.Error:
-      return "error";
-    case ts.DiagnosticCategory.Warning:
-      return "warning";
-    case ts.DiagnosticCategory.Suggestion:
-      return "suggestion";
-    case ts.DiagnosticCategory.Message:
-      return "message";
-    default:
-      return "error";
-  }
-}
-function convertDiagnostic(diag) {
-  let file = null;
-  let line = null;
-  let column = null;
-  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,
-    code: diag.code,
-    category: categoryToString(diag.category),
-    message: ts.flattenDiagnosticMessageText(diag.messageText, `
-`)
-  };
-}
-function normalizePath(path) {
-  if (!path.startsWith("/")) {
-    return "/" + path;
-  }
-  return path;
-}
-async function preloadFiles(fs) {
-  const cache = new Map;
-  const allPaths = fs.getAllPaths();
-  for (const path of allPaths) {
-    if (path.endsWith(".ts") || path.endsWith(".tsx") || path.endsWith(".js") || path.endsWith(".jsx") || path.endsWith(".json") || path.endsWith(".d.ts")) {
-      try {
-        const stat = await fs.stat(path);
-        if (stat.isFile) {
-          const content = await fs.readFile(path);
-          cache.set(path, content);
-        }
-      } catch {}
+  let bashInstance = null;
+  function getBash() {
+    if (!bashInstance) {
+      const commands = createDefaultCommands(sandboxRef);
+      bashInstance = new Bash({
+        cwd: "/",
+        fs: wrapFilesystemForJustBash(fs),
+        customCommands: commands
+      });
     }
+    return bashInstance;
   }
-  return cache;
-}
-function parseTsConfig(configText, _configPath) {
-  try {
-    const config = JSON.parse(configText);
-    const compilerOptions = config.compilerOptions || {};
-    const options = {
-      ...getDefaultCompilerOptions()
+  async function exec(command) {
+    const bash = getBash();
+    const result = await bash.exec(command);
+    return {
+      exitCode: result.exitCode,
+      stdout: result.stdout,
+      stderr: result.stderr
     };
-    if (compilerOptions.target) {
-      const targetMap = {
-        es5: ts.ScriptTarget.ES5,
-        es6: ts.ScriptTarget.ES2015,
-        es2015: ts.ScriptTarget.ES2015,
-        es2016: ts.ScriptTarget.ES2016,
-        es2017: ts.ScriptTarget.ES2017,
-        es2018: ts.ScriptTarget.ES2018,
-        es2019: ts.ScriptTarget.ES2019,
-        es2020: ts.ScriptTarget.ES2020,
-        es2021: ts.ScriptTarget.ES2021,
-        es2022: ts.ScriptTarget.ES2022,
-        esnext: ts.ScriptTarget.ESNext
-      };
-      options.target = targetMap[compilerOptions.target.toLowerCase()] ?? ts.ScriptTarget.ES2020;
-    }
-    if (compilerOptions.module) {
-      const moduleMap = {
-        commonjs: ts.ModuleKind.CommonJS,
-        amd: ts.ModuleKind.AMD,
-        umd: ts.ModuleKind.UMD,
-        system: ts.ModuleKind.System,
-        es6: ts.ModuleKind.ES2015,
-        es2015: ts.ModuleKind.ES2015,
-        es2020: ts.ModuleKind.ES2020,
-        es2022: ts.ModuleKind.ES2022,
-        esnext: ts.ModuleKind.ESNext,
-        node16: ts.ModuleKind.Node16,
-        nodenext: ts.ModuleKind.NodeNext
-      };
-      options.module = moduleMap[compilerOptions.module.toLowerCase()] ?? ts.ModuleKind.ESNext;
-    }
-    if (compilerOptions.moduleResolution) {
-      const resolutionMap = {
-        classic: ts.ModuleResolutionKind.Classic,
-        node: ts.ModuleResolutionKind.NodeJs,
-        node10: ts.ModuleResolutionKind.NodeJs,
-        node16: ts.ModuleResolutionKind.Node16,
-        nodenext: ts.ModuleResolutionKind.NodeNext,
-        bundler: ts.ModuleResolutionKind.Bundler
-      };
-      options.moduleResolution = resolutionMap[compilerOptions.moduleResolution.toLowerCase()] ?? ts.ModuleResolutionKind.Bundler;
-    }
-    if (compilerOptions.jsx) {
-      const jsxMap = {
-        preserve: ts.JsxEmit.Preserve,
-        react: ts.JsxEmit.React,
-        "react-jsx": ts.JsxEmit.ReactJSX,
-        "react-jsxdev": ts.JsxEmit.ReactJSXDev,
-        "react-native": ts.JsxEmit.ReactNative
-      };
-      options.jsx = jsxMap[compilerOptions.jsx.toLowerCase()] ?? ts.JsxEmit.ReactJSX;
-    }
-    if (compilerOptions.strict !== undefined)
-      options.strict = compilerOptions.strict;
-    if (compilerOptions.esModuleInterop !== undefined)
-      options.esModuleInterop = compilerOptions.esModuleInterop;
-    if (compilerOptions.skipLibCheck !== undefined)
-      options.skipLibCheck = compilerOptions.skipLibCheck;
-    if (compilerOptions.allowJs !== undefined)
-      options.allowJs = compilerOptions.allowJs;
-    if (compilerOptions.resolveJsonModule !== undefined)
-      options.resolveJsonModule = compilerOptions.resolveJsonModule;
-    if (compilerOptions.noImplicitAny !== undefined)
-      options.noImplicitAny = compilerOptions.noImplicitAny;
-    if (compilerOptions.strictNullChecks !== undefined)
-      options.strictNullChecks = compilerOptions.strictNullChecks;
-    if (Array.isArray(compilerOptions.lib)) {
-      options.lib = compilerOptions.lib.map((lib) => lib.toLowerCase().startsWith("lib.") ? lib : `lib.${lib.toLowerCase()}.d.ts`);
-    }
-    options.noEmit = true;
-    return options;
-  } catch (err) {
-    console.warn("Error parsing tsconfig.json:", err);
-    return getDefaultCompilerOptions();
-  }
-}
-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,
-    noLib: false,
-    lib: [
-      "lib.es2020.d.ts",
-      "lib.dom.d.ts",
-      "lib.dom.iterable.d.ts"
-    ]
-  };
-}
-var LIB_PATH_PREFIX = "/node_modules/typescript/lib/";
-function createVfsCompilerHost(fileCache, libFiles, _options) {
-  function getLibContent(fileName) {
-    const libMatch = fileName.match(/lib\.([^/]+)\.d\.ts$/);
-    if (libMatch && libMatch[1]) {
-      return libFiles.get(libMatch[1]);
-    }
-    return;
   }
   return {
-    getSourceFile(fileName, languageVersion, onError) {
-      const normalizedPath = normalizePath(fileName);
-      const content = fileCache.get(normalizedPath);
-      if (content !== undefined) {
-        return ts.createSourceFile(normalizedPath, content, languageVersion, true);
-      }
-      const altContent = fileCache.get(fileName);
-      if (altContent !== undefined) {
-        return ts.createSourceFile(fileName, altContent, languageVersion, true);
-      }
-      const libContent = getLibContent(fileName);
-      if (libContent !== undefined) {
-        return ts.createSourceFile(fileName, libContent, languageVersion, true);
-      }
-      if (onError) {
-        onError(`File not found: ${fileName}`);
-      }
-      return;
-    },
-    getDefaultLibFileName(options) {
-      return LIB_PATH_PREFIX + ts.getDefaultLibFileName(options);
-    },
-    writeFile() {},
-    getCurrentDirectory() {
-      return "/";
-    },
-    getCanonicalFileName(fileName) {
-      return fileName;
-    },
-    useCaseSensitiveFileNames() {
-      return true;
-    },
-    getNewLine() {
-      return `
-`;
-    },
-    fileExists(fileName) {
-      const normalizedPath = normalizePath(fileName);
-      if (fileCache.has(normalizedPath) || fileCache.has(fileName)) {
-        return true;
-      }
-      return getLibContent(fileName) !== undefined;
-    },
-    readFile(fileName) {
-      const normalizedPath = normalizePath(fileName);
-      const content = fileCache.get(normalizedPath) ?? fileCache.get(fileName);
-      if (content !== undefined) {
-        return content;
-      }
-      return getLibContent(fileName);
-    },
-    directoryExists(directoryName) {
-      const normalizedDir = normalizePath(directoryName);
-      for (const path of fileCache.keys()) {
-        if (path.startsWith(normalizedDir + "/")) {
-          return true;
-        }
-      }
-      if (normalizedDir === "/node_modules/typescript/lib" || normalizedDir === "/node_modules/typescript") {
-        return libFiles.size > 0;
-      }
-      if (normalizedDir === "/node_modules") {
-        return libFiles.size > 0 || Array.from(fileCache.keys()).some((p) => p.startsWith("/node_modules/"));
-      }
-      if (normalizedDir === "/node_modules/@types") {
-        return Array.from(fileCache.keys()).some((p) => p.startsWith("/node_modules/@types/"));
-      }
-      return false;
-    },
-    getDirectories(path) {
-      const normalizedPath = normalizePath(path);
-      const prefix = normalizedPath === "/" ? "/" : normalizedPath + "/";
-      const dirs = new Set;
-      for (const filePath of fileCache.keys()) {
-        if (filePath.startsWith(prefix)) {
-          const relative = filePath.slice(prefix.length);
-          const firstSlash = relative.indexOf("/");
-          if (firstSlash > 0) {
-            dirs.add(relative.slice(0, firstSlash));
-          }
-        }
-      }
-      if (normalizedPath === "/") {
-        const hasNodeModules = libFiles.size > 0 || Array.from(fileCache.keys()).some((p) => p.startsWith("/node_modules/"));
-        if (hasNodeModules) {
-          dirs.add("node_modules");
-        }
-      }
-      return Array.from(dirs);
-    },
-    realpath(path) {
-      return path;
-    },
-    getEnvironmentVariable() {
-      return;
-    }
-  };
-}
-async function typecheck(options) {
-  const {
     fs,
-    entryPoint,
-    tsconfigPath = "/tsconfig.json",
-    libFiles = new Map
-  } = options;
-  const normalizedEntry = normalizePath(entryPoint);
-  if (!await fs.exists(normalizedEntry)) {
-    throw new Error(`Entry point not found: ${normalizedEntry}`);
-  }
-  const fileCache = await preloadFiles(fs);
-  let compilerOptions = getDefaultCompilerOptions();
-  const tsconfigContent = fileCache.get(normalizePath(tsconfigPath));
-  if (tsconfigContent) {
-    compilerOptions = {
-      ...parseTsConfig(tsconfigContent, tsconfigPath),
-      noEmit: true
-    };
-  }
-  const host = createVfsCompilerHost(fileCache, libFiles, compilerOptions);
-  const program = ts.createProgram([normalizedEntry], compilerOptions, host);
-  const allDiagnostics = [
-    ...program.getSyntacticDiagnostics(),
-    ...program.getSemanticDiagnostics(),
-    ...program.getDeclarationDiagnostics()
-  ];
-  const diagnostics = allDiagnostics.map(convertDiagnostic);
-  const checkedFiles = program.getSourceFiles().map((sf) => sf.fileName).filter((f) => !f.includes("node_modules/typescript/lib"));
-  const hasErrors = diagnostics.some((d) => d.category === "error");
-  return {
-    diagnostics,
-    hasErrors,
-    checkedFiles
-  };
-}
-function formatDiagnostics(diagnostics) {
-  return diagnostics.map((d) => {
-    const location = d.file ? `${d.file}${d.line ? `:${d.line}` : ""}${d.column ? `:${d.column}` : ""}` : "(global)";
-    return `${location} - ${d.category} TS${d.code}: ${d.message}`;
-  }).join(`
-`);
-}
-function formatDiagnosticsForAgent(diagnostics) {
-  if (diagnostics.length === 0) {
-    return "No type errors found.";
-  }
-  const errorCount = diagnostics.filter((d) => d.category === "error").length;
-  const warningCount = diagnostics.filter((d) => d.category === "warning").length;
-  const summary = errorCount > 0 || warningCount > 0 ? `Found ${errorCount} error(s) and ${warningCount} warning(s):
-
-` : "";
-  const formatted = diagnostics.map((d) => {
-    const location = d.file ? `${d.file}${d.line ? ` at line ${d.line}` : ""}` : "Global";
-    const prefix = d.category === "error" ? "Error" : d.category === "warning" ? "Warning" : "Info";
-    return `${prefix} in ${location}: ${d.message} (TS${d.code})`;
-  }).join(`
-
-`);
-  return summary + formatted;
-}
-
-// src/loader.ts
-class ModuleLoadError extends Error {
-  constructor(message, cause) {
-    super(message, { cause });
-    this.name = "ModuleLoadError";
-  }
-}
-
-class ExportNotFoundError extends Error {
-  exportName;
-  availableExports;
-  constructor(exportName, availableExports) {
-    super(`Export "${exportName}" not found. Available exports: ${availableExports.length > 0 ? availableExports.join(", ") : "(none)"}`);
-    this.exportName = exportName;
-    this.availableExports = availableExports;
-    this.name = "ExportNotFoundError";
-  }
-}
-function createModuleUrl(result) {
-  const blob = new Blob([result.code], { type: "application/javascript" });
-  return URL.createObjectURL(blob);
-}
-function revokeModuleUrl(url) {
-  URL.revokeObjectURL(url);
-}
-async function loadModule(result) {
-  const url = createModuleUrl(result);
-  try {
-    const module = await import(url);
-    return module;
-  } catch (err) {
-    throw new ModuleLoadError(`Failed to load module: ${err instanceof Error ? err.message : String(err)}`, err);
-  } finally {
-    revokeModuleUrl(url);
-  }
-}
-async function loadExport(result, exportName = "default") {
-  const module = await loadModule(result);
-  if (!(exportName in module)) {
-    const availableExports = Object.keys(module).filter((key) => !key.startsWith("__"));
-    throw new ExportNotFoundError(exportName, availableExports);
-  }
-  return module[exportName];
-}
-async function loadDefault(result) {
-  return loadExport(result, "default");
-}
-async function getExportNames(result) {
-  const module = await loadModule(result);
-  return Object.keys(module).filter((key) => !key.startsWith("__"));
-}
-async function hasExport(result, exportName) {
-  const module = await loadModule(result);
-  return exportName in module;
-}
-
-// src/commands/compile.ts
-function createTscCommand(deps) {
-  const { fs, libFiles, tsconfigPath } = deps;
-  return defineCommand("tsc", async (args, _ctx) => {
-    const entryPoint = args[0];
-    if (!entryPoint) {
-      return {
-        stdout: "",
-        stderr: `Usage: tsc <entry-point>
-
-Example: tsc /src/index.ts
-`,
-        exitCode: 1
-      };
-    }
-    try {
-      if (!await fs.exists(entryPoint)) {
-        return {
-          stdout: "",
-          stderr: `Error: Entry point not found: ${entryPoint}
-`,
-          exitCode: 1
-        };
-      }
-      const result = await typecheck({
-        fs,
-        entryPoint,
-        tsconfigPath,
-        libFiles
-      });
-      if (result.hasErrors) {
-        const formatted = formatDiagnosticsForAgent(result.diagnostics);
-        return {
-          stdout: "",
-          stderr: formatted + `
-`,
-          exitCode: 1
-        };
-      }
-      const checkedCount = result.checkedFiles.length;
-      const warningCount = result.diagnostics.filter((d) => d.category === "warning").length;
-      let output = `Type check passed. Checked ${checkedCount} file(s).
-`;
-      if (warningCount > 0) {
-        output += `
-Warnings:
-${formatDiagnosticsForAgent(result.diagnostics.filter((d) => d.category === "warning"))}
-`;
-      }
-      return {
-        stdout: output,
-        stderr: "",
-        exitCode: 0
-      };
-    } catch (err) {
-      return {
-        stdout: "",
-        stderr: `Type check failed: ${err instanceof Error ? err.message : String(err)}
-`,
-        exitCode: 1
-      };
-    }
-  });
-}
-function createBuildCommand(deps) {
-  const { fs, libFiles, tsconfigPath, onBuild, getValidation, sharedModules } = deps;
-  return defineCommand("build", async (args, _ctx) => {
-    let entryPoint = null;
-    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.startsWith("-")) {
-        entryPoint = arg;
-      }
-    }
-    if (!entryPoint) {
-      return {
-        stdout: "",
-        stderr: `Usage: build <entry-point> [options]
-
-Options:
-  --skip-typecheck, -s  Skip type checking
-  --minify, -m          Minify output
-  --format, -f <fmt>    Output format (esm|iife|cjs)
-
-Example: build /src/index.ts
-`,
-        exitCode: 1
-      };
-    }
-    try {
-      if (!await fs.exists(entryPoint)) {
-        return {
-          stdout: "",
-          stderr: `Error: Entry point not found: ${entryPoint}
-`,
-          exitCode: 1
-        };
-      }
-      let typecheckResult = null;
-      if (!skipTypecheck) {
-        typecheckResult = await typecheck({
-          fs,
-          entryPoint,
-          tsconfigPath,
-          libFiles
-        });
-        if (typecheckResult.hasErrors) {
-          const formatted = formatDiagnosticsForAgent(typecheckResult.diagnostics);
-          return {
-            stdout: "",
-            stderr: `Build failed: Type errors found.
-
-${formatted}
-`,
-            exitCode: 1
-          };
-        }
-      }
-      const bundleResult = await bundle({
-        fs,
-        entryPoint,
-        format,
-        minify,
-        sharedModules
-      });
-      let loadedModule;
-      try {
-        loadedModule = await loadModule(bundleResult);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        return {
-          stdout: "",
-          stderr: `Build failed: Module failed to load.
-
-${errorMessage}
-`,
-          exitCode: 1
-        };
-      }
-      const validateFn = getValidation?.();
-      let validatedModule = loadedModule;
-      if (validateFn) {
-        try {
-          validatedModule = validateFn(loadedModule);
-        } catch (err) {
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          return {
-            stdout: "",
-            stderr: `Build failed: Validation error.
-
-${errorMessage}
-`,
-            exitCode: 1
-          };
-        }
-      }
-      if (onBuild) {
-        await onBuild({ bundle: bundleResult, module: validatedModule });
-      }
-      let output = `Build successful!
-`;
-      output += `Entry: ${entryPoint}
-`;
-      output += `Format: ${format}
-`;
-      output += `Size: ${(bundleResult.code.length / 1024).toFixed(2)} KB
-`;
-      if (typecheckResult) {
-        output += `Type checked: ${typecheckResult.checkedFiles.length} file(s)
-`;
-      }
-      output += `Bundled: ${bundleResult.includedFiles.length} file(s)
-`;
-      const exportNames = Object.keys(loadedModule).filter((k) => !k.startsWith("__"));
-      if (exportNames.length > 0) {
-        output += `Exports: ${exportNames.join(", ")}
-`;
-      }
-      if (validateFn) {
-        output += `Validation: passed
-`;
-      }
-      if (bundleResult.warnings.length > 0) {
-        output += `
-Build warnings:
-${formatEsbuildMessages(bundleResult.warnings)}
-`;
-      }
-      if (typecheckResult) {
-        const warnings = typecheckResult.diagnostics.filter((d) => d.category === "warning");
-        if (warnings.length > 0) {
-          output += `
-Type warnings:
-${formatDiagnosticsForAgent(warnings)}
-`;
-        }
-      }
-      return {
-        stdout: output,
-        stderr: "",
-        exitCode: 0
-      };
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      return {
-        stdout: "",
-        stderr: `Build failed: ${errorMessage}
-`,
-        exitCode: 1
-      };
-    }
-  });
-}
-// src/commands/packages.ts
-import { defineCommand as defineCommand2 } from "just-bash/browser";
-function createInstallCommand(deps) {
-  const { fs, typesCache } = deps;
-  return defineCommand2("install", async (args, _ctx) => {
-    if (args.length === 0) {
-      return {
-        stdout: "",
-        stderr: `Usage: install <package>[@version] [...packages]
-
-Examples:
-  install react
-  install lodash@4.17.21
-  install @tanstack/react-query@5
-`,
-        exitCode: 1
-      };
-    }
-    const results = [];
-    let hasError = false;
-    for (const packageSpec of args) {
-      try {
-        const result = await installPackage(fs, packageSpec, { cache: typesCache });
-        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(`
-`) + `
-`;
-    if (hasError) {
-      return {
-        stdout: "",
-        stderr: output,
-        exitCode: 1
-      };
-    }
-    return {
-      stdout: output,
-      stderr: "",
-      exitCode: 0
-    };
-  });
-}
-function createUninstallCommand(deps) {
-  const { fs } = deps;
-  return defineCommand2("uninstall", async (args, _ctx) => {
-    if (args.length === 0) {
-      return {
-        stdout: "",
-        stderr: `Usage: uninstall <package> [...packages]
-`,
-        exitCode: 1
-      };
-    }
-    const results = [];
-    let hasError = false;
-    for (const packageName of args) {
-      try {
-        const removed = await uninstallPackage(fs, packageName);
-        if (removed) {
-          results.push(`- ${packageName}`);
-        } 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(`
-`) + `
-`;
-    if (hasError) {
-      return {
-        stdout: "",
-        stderr: output,
-        exitCode: 1
-      };
-    }
-    return {
-      stdout: output,
-      stderr: "",
-      exitCode: 0
-    };
-  });
-}
-function createListCommand(deps) {
-  const { fs } = deps;
-  return defineCommand2("list", async (_args, _ctx) => {
-    try {
-      const packages = await listPackages(fs);
-      if (packages.length === 0) {
-        return {
-          stdout: `No packages installed.
-`,
-          stderr: "",
-          exitCode: 0
-        };
-      }
-      const output = packages.map((pkg) => `${pkg.name}@${pkg.version}`).join(`
-`) + `
-`;
-      return {
-        stdout: output,
-        stderr: "",
-        exitCode: 0
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return {
-        stdout: "",
-        stderr: `Failed to list packages: ${message}
-`,
-        exitCode: 1
-      };
-    }
-  });
-}
-// src/commands/run.ts
-import { defineCommand as defineCommand3 } from "just-bash/browser";
-function createRunCommand(deps) {
-  const { fs, libFiles, tsconfigPath, runOptions = {}, sharedModules } = deps;
-  return defineCommand3("run", async (args, _ctx) => {
-    let entryPoint = null;
-    let skipTypecheck = runOptions.skipTypecheck ?? false;
-    let timeout = runOptions.timeout ?? 30000;
-    const scriptArgs = [];
-    let collectingArgs = false;
-    for (let i = 0;i < args.length; i++) {
-      const arg = args[i];
-      if (collectingArgs) {
-        scriptArgs.push(arg);
-        continue;
-      }
-      if (arg === "--") {
-        collectingArgs = true;
-      } else if (arg === "--skip-typecheck" || arg === "-s") {
-        skipTypecheck = true;
-      } else if ((arg === "--timeout" || arg === "-t") && args[i + 1]) {
-        timeout = parseInt(args[++i], 10);
-        if (isNaN(timeout))
-          timeout = 30000;
-      } else if (!arg.startsWith("-")) {
-        entryPoint = arg;
-      }
-    }
-    if (!entryPoint) {
-      return {
-        stdout: "",
-        stderr: `Usage: run <entry-point> [options] [-- args...]
-
-Options:
-  --skip-typecheck, -s  Skip type checking
-  --timeout, -t <ms>    Execution timeout (default: 30000)
-
-Example: run /src/index.ts
-`,
-        exitCode: 1
-      };
-    }
-    const logs = [];
-    const originalConsole = {
-      log: console.log,
-      warn: console.warn,
-      error: console.error,
-      info: console.info,
-      debug: console.debug
-    };
-    const formatArgs = (...a) => a.map((v) => typeof v === "object" ? JSON.stringify(v) : String(v)).join(" ");
-    const captureLog = (...a) => {
-      logs.push(formatArgs(...a));
-      originalConsole.log.apply(console, a);
-    };
-    const captureWarn = (...a) => {
-      logs.push(`[warn] ${formatArgs(...a)}`);
-      originalConsole.warn.apply(console, a);
-    };
-    const captureError = (...a) => {
-      logs.push(`[error] ${formatArgs(...a)}`);
-      originalConsole.error.apply(console, a);
-    };
-    const captureInfo = (...a) => {
-      logs.push(`[info] ${formatArgs(...a)}`);
-      originalConsole.info.apply(console, a);
-    };
-    const captureDebug = (...a) => {
-      logs.push(`[debug] ${formatArgs(...a)}`);
-      originalConsole.debug.apply(console, a);
-    };
-    const restoreConsole = () => {
-      console.log = originalConsole.log;
-      console.warn = originalConsole.warn;
-      console.error = originalConsole.error;
-      console.info = originalConsole.info;
-      console.debug = originalConsole.debug;
-    };
-    try {
-      if (!await fs.exists(entryPoint)) {
-        return {
-          stdout: "",
-          stderr: `Error: Entry point not found: ${entryPoint}
-`,
-          exitCode: 1
-        };
-      }
-      if (!skipTypecheck) {
-        const typecheckResult = await typecheck({
-          fs,
-          entryPoint,
-          tsconfigPath,
-          libFiles
-        });
-        if (typecheckResult.hasErrors) {
-          const formatted = formatDiagnosticsForAgent(typecheckResult.diagnostics);
-          return {
-            stdout: "",
-            stderr: `Type errors:
-${formatted}
-`,
-            exitCode: 1
-          };
-        }
-      }
-      const bundleResult = await bundle({
-        fs,
-        entryPoint,
-        format: "esm",
-        sharedModules
-      });
-      console.log = captureLog;
-      console.warn = captureWarn;
-      console.error = captureError;
-      console.info = captureInfo;
-      console.debug = captureDebug;
-      const context = {
-        fs,
-        env: { ...runOptions.env },
-        args: scriptArgs,
-        log: captureLog,
-        error: captureError
-      };
-      const startTime = performance.now();
-      let returnValue;
-      const executeCode = async () => {
-        const module = await loadModule(bundleResult);
-        if (typeof module.main === "function") {
-          returnValue = await module.main(context);
-        }
-      };
-      if (timeout > 0) {
-        const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => reject(new Error(`Execution timed out after ${timeout}ms`)), timeout);
-        });
-        await Promise.race([executeCode(), timeoutPromise]);
-      } else {
-        await executeCode();
-      }
-      const executionTimeMs = performance.now() - startTime;
-      restoreConsole();
-      let output = "";
-      if (logs.length > 0) {
-        output = logs.join(`
-`) + `
-`;
-      }
-      if (returnValue !== undefined) {
-        const returnStr = typeof returnValue === "object" ? JSON.stringify(returnValue, null, 2) : String(returnValue);
-        output += `[return] ${returnStr}
-`;
-      }
-      output += `
-Execution completed in ${executionTimeMs.toFixed(2)}ms
-`;
-      return {
-        stdout: output,
-        stderr: "",
-        exitCode: 0
-      };
-    } catch (err) {
-      restoreConsole();
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      const errorStack = err instanceof Error && err.stack ? `
-${err.stack}` : "";
-      let output = "";
-      if (logs.length > 0) {
-        output = logs.join(`
-`) + `
-
-`;
-      }
-      return {
-        stdout: output,
-        stderr: `Runtime error: ${errorMessage}${errorStack}
-`,
-        exitCode: 1
+    exec,
+    get lastBuild() {
+      return lastBuild;
+    },
+    getState() {
+      return { files: fs.getFiles() };
+    },
+    onBuild(callback) {
+      onBuildCallbacks.add(callback);
+      return () => {
+        onBuildCallbacks.delete(callback);
       };
-    }
-  });
-}
-// src/commands/index.ts
-function createDefaultCommands(deps) {
-  return [
-    createTscCommand(deps),
-    createBuildCommand(deps),
-    createRunCommand(deps),
-    createInstallCommand(deps),
-    createUninstallCommand(deps),
-    createListCommand(deps)
-  ];
+    },
+    install,
+    uninstall,
+    build,
+    typecheck,
+    run,
+    readFile: (path) => fs.readFile(path),
+    writeFile: (path, content) => fs.writeFile(path, content)
+  };
 }
 
-// src/ts-libs.ts
-var TS_VERSION = "5.9.3";
-var CDN_BASE = `https://cdn.jsdelivr.net/npm/typescript@${TS_VERSION}/lib`;
-function getDefaultBrowserLibs() {
-  return ["es2020", "dom", "dom.iterable"];
+// 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/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;
@@ -2362,20 +1576,16 @@ function parseLibReferences(content) {
 function libNameToFileName(name) {
   return `lib.${name}.d.ts`;
 }
-function extractLibName(filePath) {
-  const match = filePath.match(/lib\.([^/]+)\.d\.ts$/);
-  return match?.[1] ?? null;
-}
-async function fetchLibFile(name) {
+async function fetchLibFile(name, baseUrl) {
   const fileName = libNameToFileName(name);
-  const url = `${CDN_BASE}/${fileName}`;
+  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) {
+async function fetchAllLibs(libs, baseUrl) {
   const result = new Map;
   const pending = new Set(libs);
   const fetched = new Set;
@@ -2388,10 +1598,10 @@ async function fetchAllLibs(libs) {
       }
       fetched.add(name);
       try {
-        const content = await fetchLibFile(name);
+        const content = await fetchLibFile(name, baseUrl);
         return { name, content };
       } catch (err) {
-        console.warn(`Failed to fetch lib.${name}.d.ts:`, err);
+        console.warn(`[typechecker] Failed to fetch lib.${name}.d.ts:`, err);
         return { name, content: null };
       }
     }));
@@ -2409,292 +1619,471 @@ async function fetchAllLibs(libs) {
   }
   return result;
 }
-var memoryCache = null;
-
-class LibCache {
-  async getOrFetch(libs) {
-    if (memoryCache) {
-      const missing = libs.filter((lib) => !memoryCache.has(lib));
-      if (missing.length === 0) {
-        return memoryCache;
-      }
-      console.log(`Cache missing libs: ${missing.join(", ")}, fetching all...`);
-    }
-    console.log(`Fetching TypeScript libs from CDN: ${libs.join(", ")}...`);
-    const fetched = await fetchAllLibs(libs);
-    console.log(`Fetched ${fetched.size} lib files`);
-    memoryCache = fetched;
-    return fetched;
-  }
-  get() {
-    return memoryCache;
-  }
-  set(libs) {
-    memoryCache = libs;
+function normalizePath(path) {
+  if (!path.startsWith("/")) {
+    return "/" + path;
   }
-  clear() {
-    memoryCache = null;
+  return path;
+}
+function getLibContent(fileName, libFiles) {
+  const match = fileName.match(/lib\.([^/]+)\.d\.ts$/);
+  if (match?.[1]) {
+    return libFiles.get(match[1]);
   }
+  return;
 }
-async function fetchAndCacheLibs(libs = getDefaultBrowserLibs()) {
-  const cache = new LibCache;
-  return cache.getOrFetch(libs);
+function createCompilerHost(fs, libFiles, options) {
+  return {
+    getSourceFile(fileName, languageVersion, onError) {
+      const normalizedPath = normalizePath(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 = normalizePath(fileName);
+      try {
+        if (fs.exists(normalizedPath)) {
+          return fs.stat(normalizedPath).isFile;
+        }
+      } catch {}
+      return getLibContent(fileName, libFiles) !== undefined;
+    },
+    readFile(fileName) {
+      const normalizedPath = normalizePath(fileName);
+      try {
+        if (fs.exists(normalizedPath)) {
+          return fs.readFile(normalizedPath);
+        }
+      } catch {}
+      return getLibContent(fileName, libFiles);
+    },
+    directoryExists(directoryName) {
+      const normalizedDir = normalizePath(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 = normalizePath(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;
+    }
+  };
 }
-
-// src/shared-resources.ts
-async function createSharedResources(options = {}) {
-  const { libs = getDefaultBrowserLibs(), skipLibs = false, skipBundler = false } = options;
-  const libsPromise = skipLibs ? Promise.resolve(new Map) : fetchAndCacheLibs(libs);
-  const bundlerPromise = skipBundler ? Promise.resolve() : initBundler();
-  const typesCache = new InMemoryTypesCache;
-  const [libFiles] = await Promise.all([libsPromise, bundlerPromise]);
+function getDefaultCompilerOptions() {
   return {
-    libFiles,
-    bundlerReady: Promise.resolve(),
-    typesCache
+    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"]
   };
 }
-var defaultResourcesInstance = null;
-var defaultResourcesPromise = null;
-async function getDefaultResources() {
-  if (defaultResourcesInstance) {
-    return defaultResourcesInstance;
-  }
-  if (!defaultResourcesPromise) {
-    defaultResourcesPromise = createSharedResources().then((resources) => {
-      defaultResourcesInstance = resources;
-      return resources;
-    });
+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(normalizePath(path)),
+      readFile: (path) => {
+        try {
+          return fs.readFile(normalizePath(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();
   }
-  return defaultResourcesPromise;
 }
-function clearDefaultResources() {
-  defaultResourcesInstance = null;
-  defaultResourcesPromise = null;
+function categoryToSeverity(category) {
+  switch (category) {
+    case ts.DiagnosticCategory.Error:
+      return "error";
+    case ts.DiagnosticCategory.Warning:
+      return "warning";
+    default:
+      return "info";
+  }
 }
-function hasDefaultResources() {
-  return defaultResourcesInstance !== null;
+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)
+  };
 }
 
-// src/build-emitter.ts
-class BuildEmitter {
-  listeners = new Set;
-  emit = async (result) => {
-    const promises = [];
-    for (const listener of this.listeners) {
-      const ret = listener(result);
-      if (ret instanceof Promise) {
-        promises.push(ret);
-      }
+class Typechecker {
+  options;
+  libCache = new Map;
+  initPromise = null;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async initialize() {
+    if (this.initPromise) {
+      await this.initPromise;
+      return;
     }
-    await Promise.all(promises);
-  };
-  on(callback) {
-    this.listeners.add(callback);
-    return () => {
-      this.listeners.delete(callback);
+    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 = normalizePath(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
     };
   }
 }
-
-// src/sandbox.ts
-async function createSandbox(options = {}) {
-  const {
-    initialFiles,
-    maxFilesystemSize,
-    tsconfigPath = "/tsconfig.json",
-    resources: providedResources,
-    onBuild: onBuildCallback,
-    customCommands = [],
-    sharedModules,
-    bashOptions = {}
-  } = options;
-  const fs = Filesystem.create({
-    initialFiles,
-    maxSizeBytes: maxFilesystemSize
-  });
-  const resourcesPromise = providedResources ? Promise.resolve(providedResources) : getDefaultResources();
-  const bundlerPromise = initBundler();
-  const [resources] = await Promise.all([resourcesPromise, bundlerPromise]);
-  const libFiles = resources.libFiles;
-  const typesCache = resources.typesCache;
-  if (sharedModules && sharedModules.length > 0) {
-    const basePackages = new Set;
-    for (const moduleId of sharedModules) {
-      const { packageName } = parseImportPath(moduleId);
-      basePackages.add(packageName);
-    }
-    await Promise.all(Array.from(basePackages).map(async (packageName) => {
-      try {
-        await installPackage(fs, packageName, { cache: typesCache });
-      } catch (err) {
-        console.warn(`[sandlot] Failed to install types for shared module "${packageName}":`, err);
-      }
-    }));
+function createTypechecker(options) {
+  return new Typechecker(options);
+}
+// src/core/esm-types-resolver.ts
+class InMemoryTypesCache {
+  cache = new Map;
+  async get(key) {
+    return this.cache.get(key) ?? null;
   }
-  const buildEmitter = new BuildEmitter;
-  let lastBuild = null;
-  buildEmitter.on((result) => {
-    lastBuild = result;
-  });
-  if (onBuildCallback) {
-    buildEmitter.on(onBuildCallback);
+  async set(key, value) {
+    this.cache.set(key, value);
+  }
+  async has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
   }
-  let validationFn = null;
-  const commandDeps = {
-    fs,
-    libFiles,
-    tsconfigPath,
-    onBuild: buildEmitter.emit,
-    getValidation: () => validationFn,
-    typesCache,
-    sharedModules
-  };
-  const defaultCommands = createDefaultCommands(commandDeps);
-  const bash = new Bash({
-    ...bashOptions,
-    cwd: "/",
-    fs,
-    customCommands: [...defaultCommands, ...customCommands]
-  });
-  return {
-    fs,
-    bash,
-    get lastBuild() {
-      return lastBuild;
-    },
-    getState: () => ({ files: fs.getFiles() }),
-    onBuild: (callback) => buildEmitter.on(callback),
-    setValidation: (fn) => {
-      validationFn = fn;
-    },
-    clearValidation: () => {
-      validationFn = null;
-    }
-  };
 }
-// src/builder.ts
-function createBuilder(options) {
-  return async (prompt, callOptions) => {
-    const sandbox = options.sandbox ?? await createSandbox(options.sandboxOptions);
-    if (callOptions?.validate) {
-      sandbox.setValidation(callOptions.validate);
-    }
-    const captured = { output: null };
-    const unsubscribe = sandbox.onBuild((output) => {
-      captured.output = output;
-    });
-    const { timeout, signal } = callOptions ?? {};
-    let timeoutId;
-    let abortController;
-    if (timeout !== undefined || signal !== undefined) {
-      abortController = new AbortController;
-      if (timeout !== undefined) {
-        timeoutId = setTimeout(() => {
-          abortController.abort(new Error(`Build timed out after ${timeout}ms`));
-        }, timeout);
+
+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;
       }
-      if (signal !== undefined) {
-        if (signal.aborted) {
-          abortController.abort(signal.reason);
-        } else {
-          signal.addEventListener("abort", () => {
-            abortController.abort(signal.reason);
-          }, { once: true });
-        }
+    }
+    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;
       }
     }
-    let result;
-    let error = null;
+    if (result && this.cache) {
+      await this.cache.set(cacheKey, result);
+    }
+    return result;
+  }
+  async tryResolve(packageName, subpath, version) {
     try {
-      const buildPromise = options.build(sandbox, prompt);
-      if (abortController) {
-        const abortPromise = new Promise((_, reject) => {
-          abortController.signal.addEventListener("abort", () => {
-            const err = abortController.signal.reason instanceof Error ? abortController.signal.reason : new Error("Build aborted");
-            err.name = "AbortError";
-            reject(err);
-          }, { once: true });
-          if (abortController.signal.aborted) {
-            const err = abortController.signal.reason instanceof Error ? abortController.signal.reason : new Error("Build aborted");
-            err.name = "AbortError";
-            reject(err);
-          }
-        });
-        result = await Promise.race([buildPromise, abortPromise]);
-      } else {
-        result = await buildPromise;
+      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;
       }
-    } catch (err) {
-      error = err instanceof Error ? err : new Error(String(err));
-    } finally {
-      if (timeoutId !== undefined) {
-        clearTimeout(timeoutId);
+      const resolvedVersion = this.extractVersion(response, packageName, version);
+      const typesHeader = response.headers.get("X-TypeScript-Types");
+      if (!typesHeader) {
+        return null;
       }
-      unsubscribe();
-      if (callOptions?.validate) {
-        sandbox.clearValidation();
+      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;
+        }
       }
     }
-    const buildOutput = captured.output;
-    return {
-      result,
-      error,
-      bundle: buildOutput?.bundle ?? null,
-      module: buildOutput?.module ?? null,
-      sandbox
-    };
-  };
+    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";
+  }
 }
-
-// src/index.ts
-if (typeof window !== "undefined" && typeof globalThis.process === "undefined") {
-  globalThis.process = {
-    env: {},
-    platform: "browser",
-    version: "v20.0.0",
-    browser: true,
-    cwd: () => "/",
-    nextTick: (fn) => setTimeout(fn, 0)
+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, "\\$&");
+}
 export {
-  unregisterSharedModule,
-  uninstallPackage,
-  typecheck,
-  registerSharedModules,
-  loadModule,
-  loadExport,
-  loadDefault,
-  listPackages,
-  installPackage,
-  initBundler,
-  hasExport,
-  hasDefaultResources,
-  getPackageManifest,
-  getExportNames,
-  getDefaultResources,
-  getDefaultBrowserLibs,
-  formatDiagnosticsForAgent,
+  wrapFilesystemForJustBash,
+  formatSize,
   formatDiagnostics,
-  fetchAndCacheLibs,
-  createUninstallCommand,
-  createTscCommand,
-  createSharedResources,
-  createSandbox,
-  createRunCommand,
-  createListCommand,
-  createInstallCommand,
+  formatBundleErrors,
+  createTypechecker,
+  createSharedModuleRegistry,
+  createSandlotCommand,
+  createSandlot,
   createFilesystem,
   createDefaultCommands,
-  createBuilder,
-  createBuildCommand,
-  clearSharedModules,
-  clearDefaultResources,
-  bundleToUrl,
-  bundleAndImport,
-  bundle,
-  ModuleLoadError,
+  Typechecker,
+  SharedModuleRegistry,
+  InMemoryTypesCache,
   Filesystem,
-  ExportNotFoundError
+  EsmTypesResolver
 };