sandlot 0.1.0

package/dist/index.js

@@ -0,0 +1,2920 @@
+// src/sandbox.ts
+import { Bash } from "just-bash/browser";
+
+// src/fs.ts
+var DEFAULT_FILE_MODE = 420;
+var DEFAULT_DIR_MODE = 493;
+var DEFAULT_SYMLINK_MODE = 511;
+var DEFAULT_MAX_SIZE_BYTES = 50 * 1024 * 1024;
+
+class IndexedDbFs {
+  entries;
+  db = null;
+  dbName;
+  maxSizeBytes;
+  dirty = false;
+  constructor(entries, db, dbName, maxSizeBytes) {
+    this.entries = entries;
+    this.db = db;
+    this.dbName = dbName;
+    this.maxSizeBytes = maxSizeBytes;
+  }
+  static async create(options = {}) {
+    const dbName = options.dbName ?? "sandlot-fs";
+    const maxSizeBytes = options.maxSizeBytes ?? DEFAULT_MAX_SIZE_BYTES;
+    const db = await IndexedDbFs.openDatabase(dbName);
+    const entries = await IndexedDbFs.loadEntries(db);
+    if (entries.size === 0) {
+      entries.set("/", {
+        type: "directory",
+        mode: DEFAULT_DIR_MODE,
+        mtime: new Date
+      });
+      if (options.initialFiles) {
+        for (const [path, value] of Object.entries(options.initialFiles)) {
+          const normalizedPath = IndexedDbFs.normalizePath(path);
+          const init = IndexedDbFs.parseFileInit(value);
+          IndexedDbFs.ensureParentDirs(entries, normalizedPath);
+          entries.set(normalizedPath, {
+            type: "file",
+            content: init.content,
+            mode: init.mode ?? DEFAULT_FILE_MODE,
+            mtime: init.mtime ?? new Date
+          });
+        }
+      }
+    }
+    const fs = new IndexedDbFs(entries, db, dbName, maxSizeBytes);
+    return fs;
+  }
+  static createInMemory(options = {}) {
+    const maxSizeBytes = options.maxSizeBytes ?? DEFAULT_MAX_SIZE_BYTES;
+    const entries = new Map;
+    entries.set("/", {
+      type: "directory",
+      mode: DEFAULT_DIR_MODE,
+      mtime: new Date
+    });
+    if (options.initialFiles) {
+      for (const [path, value] of Object.entries(options.initialFiles)) {
+        const normalizedPath = IndexedDbFs.normalizePath(path);
+        const init = IndexedDbFs.parseFileInit(value);
+        IndexedDbFs.ensureParentDirs(entries, normalizedPath);
+        entries.set(normalizedPath, {
+          type: "file",
+          content: init.content,
+          mode: init.mode ?? DEFAULT_FILE_MODE,
+          mtime: init.mtime ?? new Date
+        });
+      }
+    }
+    return new IndexedDbFs(entries, null, "", maxSizeBytes);
+  }
+  async save() {
+    if (!this.db || !this.dirty) {
+      return false;
+    }
+    const tx = this.db.transaction("entries", "readwrite");
+    const store = tx.objectStore("entries");
+    await this.promisifyRequest(store.clear());
+    for (const [path, entry] of this.entries) {
+      store.put({ path, entry: this.serializeEntry(entry) });
+    }
+    await this.promisifyTransaction(tx);
+    this.dirty = false;
+    return true;
+  }
+  async reload() {
+    if (!this.db) {
+      return;
+    }
+    this.entries = await IndexedDbFs.loadEntries(this.db);
+    this.dirty = false;
+  }
+  isDirty() {
+    return this.dirty;
+  }
+  getSize() {
+    let size = 0;
+    for (const [path, entry] of this.entries) {
+      size += path.length * 2;
+      if (entry.type === "file") {
+        if (typeof entry.content === "string") {
+          size += entry.content.length * 2;
+        } else {
+          size += entry.content.byteLength;
+        }
+      }
+    }
+    return size;
+  }
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  async readFile(path, options) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.resolveSymlinks(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, open '${path}'`);
+    }
+    if (entry.type !== "file") {
+      throw new Error(`EISDIR: illegal operation on a directory, read '${path}'`);
+    }
+    const content = entry.content;
+    if (typeof content === "string") {
+      return content;
+    }
+    const encoding = this.getEncoding(options) ?? "utf8";
+    return this.decodeBuffer(content, encoding);
+  }
+  async readFileBuffer(path) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.resolveSymlinks(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, open '${path}'`);
+    }
+    if (entry.type !== "file") {
+      throw new Error(`EISDIR: illegal operation on a directory, read '${path}'`);
+    }
+    const content = entry.content;
+    if (content instanceof Uint8Array) {
+      return content;
+    }
+    return new TextEncoder().encode(content);
+  }
+  async writeFile(path, content, options) {
+    const normalizedPath = this.normalizePath(path);
+    this.checkSizeLimit(content);
+    this.ensureParentDirs(normalizedPath);
+    const existing = this.entries.get(normalizedPath);
+    if (existing && existing.type === "directory") {
+      throw new Error(`EISDIR: illegal operation on a directory, open '${path}'`);
+    }
+    this.entries.set(normalizedPath, {
+      type: "file",
+      content,
+      mode: existing?.mode ?? DEFAULT_FILE_MODE,
+      mtime: new Date
+    });
+    this.dirty = true;
+  }
+  async appendFile(path, content, options) {
+    const normalizedPath = this.normalizePath(path);
+    let existing = "";
+    try {
+      existing = await 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);
+  }
+  async exists(path) {
+    const normalizedPath = this.normalizePath(path);
+    return this.entries.has(normalizedPath);
+  }
+  async stat(path) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.resolveSymlinks(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
+    }
+    return this.entryToStat(entry);
+  }
+  async lstat(path) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.entries.get(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, lstat '${path}'`);
+    }
+    return this.entryToStat(entry);
+  }
+  async mkdir(path, options) {
+    const normalizedPath = this.normalizePath(path);
+    if (this.entries.has(normalizedPath)) {
+      if (options?.recursive) {
+        return;
+      }
+      throw new Error(`EEXIST: file already exists, mkdir '${path}'`);
+    }
+    if (options?.recursive) {
+      this.ensureParentDirs(normalizedPath);
+    } else {
+      const parent = this.getParentPath(normalizedPath);
+      if (parent && !this.entries.has(parent)) {
+        throw new Error(`ENOENT: no such file or directory, mkdir '${path}'`);
+      }
+    }
+    this.entries.set(normalizedPath, {
+      type: "directory",
+      mode: DEFAULT_DIR_MODE,
+      mtime: new Date
+    });
+    this.dirty = true;
+  }
+  async readdir(path) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.resolveSymlinks(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, scandir '${path}'`);
+    }
+    if (entry.type !== "directory") {
+      throw new Error(`ENOTDIR: not a directory, scandir '${path}'`);
+    }
+    const prefix = normalizedPath === "/" ? "/" : normalizedPath + "/";
+    const names = [];
+    for (const entryPath of this.entries.keys()) {
+      if (entryPath === normalizedPath)
+        continue;
+      if (!entryPath.startsWith(prefix))
+        continue;
+      const relative = entryPath.slice(prefix.length);
+      if (!relative.includes("/")) {
+        names.push(relative);
+      }
+    }
+    return names.sort();
+  }
+  async readdirWithFileTypes(path) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.resolveSymlinks(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, scandir '${path}'`);
+    }
+    if (entry.type !== "directory") {
+      throw new Error(`ENOTDIR: not a directory, scandir '${path}'`);
+    }
+    const prefix = normalizedPath === "/" ? "/" : normalizedPath + "/";
+    const dirents = [];
+    for (const [entryPath, e] of this.entries) {
+      if (entryPath === normalizedPath)
+        continue;
+      if (!entryPath.startsWith(prefix))
+        continue;
+      const relative = entryPath.slice(prefix.length);
+      if (!relative.includes("/")) {
+        dirents.push({
+          name: relative,
+          isFile: e.type === "file",
+          isDirectory: e.type === "directory",
+          isSymbolicLink: e.type === "symlink"
+        });
+      }
+    }
+    return dirents.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  async rm(path, options) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.entries.get(normalizedPath);
+    if (!entry) {
+      if (options?.force)
+        return;
+      throw new Error(`ENOENT: no such file or directory, rm '${path}'`);
+    }
+    if (entry.type === "directory") {
+      const children = await this.readdir(normalizedPath);
+      if (children.length > 0 && !options?.recursive) {
+        throw new Error(`ENOTEMPTY: directory not empty, rm '${path}'`);
+      }
+      if (options?.recursive) {
+        const prefix = normalizedPath === "/" ? "/" : normalizedPath + "/";
+        for (const entryPath of [...this.entries.keys()]) {
+          if (entryPath.startsWith(prefix)) {
+            this.entries.delete(entryPath);
+          }
+        }
+      }
+    }
+    this.entries.delete(normalizedPath);
+    this.dirty = true;
+  }
+  async cp(src, dest, options) {
+    const srcPath = this.normalizePath(src);
+    const destPath = this.normalizePath(dest);
+    const entry = this.entries.get(srcPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, cp '${src}'`);
+    }
+    if (entry.type === "directory") {
+      if (!options?.recursive) {
+        throw new Error(`EISDIR: cp called on directory without recursive '${src}'`);
+      }
+      this.ensureParentDirs(destPath);
+      this.entries.set(destPath, { ...entry, mtime: new Date });
+      const prefix = srcPath === "/" ? "/" : srcPath + "/";
+      for (const [entryPath, e] of this.entries) {
+        if (entryPath.startsWith(prefix)) {
+          const relative = entryPath.slice(srcPath.length);
+          const newPath = destPath + relative;
+          this.entries.set(newPath, this.cloneEntry(e));
+        }
+      }
+    } else {
+      this.ensureParentDirs(destPath);
+      this.entries.set(destPath, this.cloneEntry(entry));
+    }
+    this.dirty = true;
+  }
+  async mv(src, dest) {
+    const srcPath = this.normalizePath(src);
+    const destPath = this.normalizePath(dest);
+    const entry = this.entries.get(srcPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, mv '${src}'`);
+    }
+    this.ensureParentDirs(destPath);
+    if (entry.type === "directory") {
+      const prefix = srcPath === "/" ? "/" : srcPath + "/";
+      const toMove = [];
+      for (const [entryPath, e] of this.entries) {
+        if (entryPath === srcPath || entryPath.startsWith(prefix)) {
+          const relative = entryPath.slice(srcPath.length);
+          toMove.push([destPath + relative, e]);
+          this.entries.delete(entryPath);
+        }
+      }
+      for (const [newPath, e] of toMove) {
+        this.entries.set(newPath, e);
+      }
+    } else {
+      this.entries.delete(srcPath);
+      this.entries.set(destPath, entry);
+    }
+    this.dirty = true;
+  }
+  resolvePath(base, path) {
+    if (path.startsWith("/")) {
+      return this.normalizePath(path);
+    }
+    const baseParts = base.split("/").filter(Boolean);
+    const pathParts = path.split("/").filter(Boolean);
+    for (const part of pathParts) {
+      if (part === ".") {
+        continue;
+      } else if (part === "..") {
+        baseParts.pop();
+      } else {
+        baseParts.push(part);
+      }
+    }
+    return "/" + baseParts.join("/");
+  }
+  getAllPaths() {
+    return [...this.entries.keys()].sort();
+  }
+  async chmod(path, mode) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.entries.get(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, chmod '${path}'`);
+    }
+    entry.mode = mode;
+    entry.mtime = new Date;
+    this.dirty = true;
+  }
+  async symlink(target, linkPath) {
+    const normalizedLinkPath = this.normalizePath(linkPath);
+    if (this.entries.has(normalizedLinkPath)) {
+      throw new Error(`EEXIST: file already exists, symlink '${linkPath}'`);
+    }
+    this.ensureParentDirs(normalizedLinkPath);
+    this.entries.set(normalizedLinkPath, {
+      type: "symlink",
+      target,
+      mode: DEFAULT_SYMLINK_MODE,
+      mtime: new Date
+    });
+    this.dirty = true;
+  }
+  async link(existingPath, newPath) {
+    const srcPath = this.normalizePath(existingPath);
+    const destPath = this.normalizePath(newPath);
+    const entry = this.entries.get(srcPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, link '${existingPath}'`);
+    }
+    if (entry.type !== "file") {
+      throw new Error(`EPERM: operation not permitted, link '${existingPath}'`);
+    }
+    if (this.entries.has(destPath)) {
+      throw new Error(`EEXIST: file already exists, link '${newPath}'`);
+    }
+    this.ensureParentDirs(destPath);
+    this.entries.set(destPath, {
+      type: "file",
+      content: entry.content,
+      mode: entry.mode,
+      mtime: new Date
+    });
+    this.dirty = true;
+  }
+  async readlink(path) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.entries.get(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, readlink '${path}'`);
+    }
+    if (entry.type !== "symlink") {
+      throw new Error(`EINVAL: invalid argument, readlink '${path}'`);
+    }
+    return entry.target;
+  }
+  async realpath(path) {
+    const normalizedPath = this.normalizePath(path);
+    const parts = normalizedPath.split("/").filter(Boolean);
+    let resolved = "/";
+    for (const part of parts) {
+      resolved = resolved === "/" ? `/${part}` : `${resolved}/${part}`;
+      const entry = this.entries.get(resolved);
+      if (!entry) {
+        throw new Error(`ENOENT: no such file or directory, realpath '${path}'`);
+      }
+      if (entry.type === "symlink") {
+        const target = entry.target;
+        if (target.startsWith("/")) {
+          resolved = this.normalizePath(target);
+        } else {
+          const parent = this.getParentPath(resolved) ?? "/";
+          resolved = this.resolvePath(parent, target);
+        }
+        const targetEntry = this.entries.get(resolved);
+        if (!targetEntry) {
+          throw new Error(`ENOENT: no such file or directory, realpath '${path}'`);
+        }
+      }
+    }
+    return resolved;
+  }
+  async utimes(path, atime, mtime) {
+    const normalizedPath = this.normalizePath(path);
+    const entry = this.entries.get(normalizedPath);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory, utimes '${path}'`);
+    }
+    entry.mtime = mtime;
+    this.dirty = true;
+  }
+  normalizePath(path) {
+    return IndexedDbFs.normalizePath(path);
+  }
+  static normalizePath(path) {
+    if (!path || path === ".")
+      return "/";
+    if (!path.startsWith("/")) {
+      path = "/" + path;
+    }
+    const parts = path.split("/").filter(Boolean);
+    const normalized = [];
+    for (const part of parts) {
+      if (part === ".")
+        continue;
+      if (part === "..") {
+        normalized.pop();
+      } else {
+        normalized.push(part);
+      }
+    }
+    return "/" + normalized.join("/");
+  }
+  getParentPath(path) {
+    if (path === "/")
+      return null;
+    const lastSlash = path.lastIndexOf("/");
+    return lastSlash === 0 ? "/" : path.slice(0, lastSlash);
+  }
+  ensureParentDirs(path) {
+    IndexedDbFs.ensureParentDirs(this.entries, path);
+    this.dirty = true;
+  }
+  static ensureParentDirs(entries, path) {
+    const parts = path.split("/").filter(Boolean);
+    let current = "";
+    for (let i = 0;i < parts.length - 1; i++) {
+      current += "/" + parts[i];
+      if (!entries.has(current)) {
+        entries.set(current, {
+          type: "directory",
+          mode: DEFAULT_DIR_MODE,
+          mtime: new Date
+        });
+      }
+    }
+  }
+  resolveSymlinks(path, maxDepth = 10) {
+    let current = path;
+    let depth = 0;
+    while (depth < maxDepth) {
+      const entry = this.entries.get(current);
+      if (!entry)
+        return null;
+      if (entry.type !== "symlink")
+        return entry;
+      const target = entry.target;
+      current = target.startsWith("/") ? this.normalizePath(target) : this.resolvePath(this.getParentPath(current) ?? "/", target);
+      depth++;
+    }
+    throw new Error(`ELOOP: too many levels of symbolic links, stat '${path}'`);
+  }
+  entryToStat(entry) {
+    return {
+      isFile: entry.type === "file",
+      isDirectory: entry.type === "directory",
+      isSymbolicLink: entry.type === "symlink",
+      mode: entry.mode,
+      size: entry.type === "file" ? this.getContentSize(entry.content) : 0,
+      mtime: entry.mtime
+    };
+  }
+  getContentSize(content) {
+    if (typeof content === "string") {
+      return new TextEncoder().encode(content).byteLength;
+    }
+    return content.byteLength;
+  }
+  cloneEntry(entry) {
+    if (entry.type === "file") {
+      return {
+        type: "file",
+        content: entry.content instanceof Uint8Array ? new Uint8Array(entry.content) : entry.content,
+        mode: entry.mode,
+        mtime: new Date
+      };
+    }
+    return { ...entry, mtime: new Date };
+  }
+  checkSizeLimit(content) {
+    const currentSize = this.getSize();
+    const newSize = typeof content === "string" ? content.length * 2 : content.byteLength;
+    if (currentSize + newSize > this.maxSizeBytes) {
+      throw new Error(`ENOSPC: filesystem size limit exceeded (${this.maxSizeBytes} bytes)`);
+    }
+  }
+  getEncoding(options) {
+    if (!options)
+      return null;
+    if (typeof options === "string")
+      return options;
+    return options.encoding ?? null;
+  }
+  decodeBuffer(buffer, encoding) {
+    if (encoding === "utf8" || encoding === "utf-8") {
+      return new TextDecoder("utf-8").decode(buffer);
+    }
+    if (encoding === "base64") {
+      let binary = "";
+      for (let i = 0;i < buffer.byteLength; i++) {
+        binary += String.fromCharCode(buffer[i]);
+      }
+      return btoa(binary);
+    }
+    if (encoding === "hex") {
+      return Array.from(buffer).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    return new TextDecoder("utf-8").decode(buffer);
+  }
+  concatBuffers(a, b) {
+    const result = new Uint8Array(a.byteLength + b.byteLength);
+    result.set(a, 0);
+    result.set(b, a.byteLength);
+    return result;
+  }
+  static parseFileInit(value) {
+    if (typeof value === "string" || value instanceof Uint8Array) {
+      return { content: value };
+    }
+    return value;
+  }
+  static openDatabase(dbName) {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(dbName, 1);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains("entries")) {
+          db.createObjectStore("entries", { keyPath: "path" });
+        }
+      };
+    });
+  }
+  static async loadEntries(db) {
+    const tx = db.transaction("entries", "readonly");
+    const store = tx.objectStore("entries");
+    return new Promise((resolve, reject) => {
+      const request = store.getAll();
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        const entries = new Map;
+        for (const record of request.result) {
+          entries.set(record.path, IndexedDbFs.deserializeEntry(record.entry));
+        }
+        resolve(entries);
+      };
+    });
+  }
+  serializeEntry(entry) {
+    if (entry.type === "file" && entry.content instanceof Uint8Array) {
+      return {
+        ...entry,
+        content: Array.from(entry.content),
+        contentType: "uint8array",
+        mtime: entry.mtime.toISOString()
+      };
+    }
+    return {
+      ...entry,
+      mtime: entry.mtime.toISOString()
+    };
+  }
+  static deserializeEntry(data) {
+    const mtime = new Date(data.mtime);
+    if (data.type === "file") {
+      let content = data.content;
+      if (data.contentType === "uint8array" && Array.isArray(content)) {
+        content = new Uint8Array(content);
+      }
+      return { type: "file", content, mode: data.mode, mtime };
+    }
+    if (data.type === "symlink") {
+      return { type: "symlink", target: data.target, mode: data.mode, mtime };
+    }
+    return { type: "directory", mode: data.mode, mtime };
+  }
+  promisifyRequest(request) {
+    return new Promise((resolve, reject) => {
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+    });
+  }
+  promisifyTransaction(tx) {
+    return new Promise((resolve, reject) => {
+      tx.onerror = () => reject(tx.error);
+      tx.oncomplete = () => resolve();
+    });
+  }
+}
+function createIndexedDbFs(initialFiles) {
+  return IndexedDbFs.createInMemory({ initialFiles });
+}
+
+// src/bundler.ts
+import * as esbuild from "esbuild-wasm";
+
+// src/packages.ts
+var ESM_CDN_BASE = "https://esm.sh";
+var KNOWN_SUBPATHS = {
+  react: ["jsx-runtime", "jsx-dev-runtime"],
+  "react-dom": ["client", "server"]
+};
+
+class InMemoryTypesCache {
+  cache = new Map;
+  key(name, version) {
+    return `${name}@${version}`;
+  }
+  get(name, version) {
+    return this.cache.get(this.key(name, version)) ?? null;
+  }
+  set(name, version, types) {
+    this.cache.set(this.key(name, version), types);
+  }
+  has(name, version) {
+    return this.cache.has(this.key(name, version));
+  }
+  delete(name, version) {
+    return this.cache.delete(this.key(name, version));
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+}
+var PACKAGE_JSON_PATH = "/package.json";
+function parsePackageSpec(spec) {
+  if (spec.startsWith("@")) {
+    const slashIndex = spec.indexOf("/");
+    if (slashIndex === -1) {
+      return { name: spec };
+    }
+    const afterSlash = spec.slice(slashIndex + 1);
+    const atIndex2 = afterSlash.indexOf("@");
+    if (atIndex2 === -1) {
+      return { name: spec };
+    }
+    return {
+      name: spec.slice(0, slashIndex + 1 + atIndex2),
+      version: afterSlash.slice(atIndex2 + 1)
+    };
+  }
+  const atIndex = spec.indexOf("@");
+  if (atIndex === -1) {
+    return { name: spec };
+  }
+  return {
+    name: spec.slice(0, atIndex),
+    version: spec.slice(atIndex + 1)
+  };
+}
+function 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;
+  try {
+    const response = await fetch(typesUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch types: ${response.status}`);
+    }
+    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 {}
+  }
+}
+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);
+  }
+  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 {}
+  }
+  return { version: resolvedVersion, types };
+}
+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: {} };
+}
+async function savePackageManifest(fs, manifest) {
+  let existing = {};
+  try {
+    if (await fs.exists(PACKAGE_JSON_PATH)) {
+      const content = await 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
+  };
+}
+async function ensureDir(fs, path) {
+  if (path === "/" || path === "")
+    return;
+  if (await fs.exists(path)) {
+    const stat = await 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 });
+}
+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 };
+    }
+    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;
+  constructor() {
+    globalThis[GLOBAL_KEY] = this;
+  }
+  register(moduleId, module) {
+    this.modules.set(moduleId, module);
+    return this;
+  }
+  registerAll(modules) {
+    for (const [id, mod] of Object.entries(modules)) {
+      this.modules.set(id, mod);
+    }
+    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.`);
+    }
+    return mod;
+  }
+  has(moduleId) {
+    return this.modules.has(moduleId);
+  }
+  list() {
+    return [...this.modules.keys()];
+  }
+  clear() {
+    this.modules.clear();
+  }
+  get size() {
+    return this.modules.size;
+  }
+}
+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 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 initialized = false;
+var initPromise = null;
+function getWasmUrl() {
+  const version = "0.27.2";
+  return `https://unpkg.com/esbuild-wasm@${version}/esbuild.wasm`;
+}
+async function initBundler() {
+  if (initialized)
+    return;
+  if (initPromise) {
+    await initPromise;
+    return;
+  }
+  initPromise = esbuild.initialize({
+    wasmURL: getWasmUrl()
+  });
+  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;
+  }
+  for (const moduleId of sharedModuleIds) {
+    if (importPath === moduleId || importPath.startsWith(moduleId + "/")) {
+      return importPath;
+    }
+  }
+  return null;
+}
+function createVfsPlugin(options) {
+  const {
+    fs,
+    entryPoint,
+    npmImports,
+    installedPackages,
+    includedFiles,
+    sharedModuleIds
+  } = options;
+  return {
+    name: "virtual-fs",
+    setup(build2) {
+      build2.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" };
+          }
+        }
+        return { errors: [{ text: `Cannot resolve: ${args.path} from ${args.resolveDir}` }] };
+      });
+      build2.onLoad({ filter: /.*/, namespace: "sandlot-shared" }, (args) => {
+        const contents = `export default ${getSharedModuleRuntimeCode(args.path)};
+export * from ${JSON.stringify(args.path)};
+// Re-export all named exports by importing from registry
+const __mod__ = ${getSharedModuleRuntimeCode(args.path)};
+for (const __k__ in __mod__) {
+  if (__k__ !== 'default') Object.defineProperty(exports, __k__, { 
+    enumerable: true, 
+    get: function() { return __mod__[__k__]; } 
+  });
+}`;
+        const esmContents = `
+const __sandlot_mod__ = ${getSharedModuleRuntimeCode(args.path)};
+export default __sandlot_mod__.default ?? __sandlot_mod__;
+${generateNamedExports(args.path)}
+`;
+        return {
+          contents: esmContents.trim(),
+          loader: "js"
+        };
+      });
+      build2.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 knownExports = {
+    react: [
+      "useState",
+      "useEffect",
+      "useContext",
+      "useReducer",
+      "useCallback",
+      "useMemo",
+      "useRef",
+      "useImperativeHandle",
+      "useLayoutEffect",
+      "useDebugValue",
+      "useDeferredValue",
+      "useTransition",
+      "useId",
+      "useSyncExternalStore",
+      "useInsertionEffect",
+      "useOptimistic",
+      "useActionState",
+      "createElement",
+      "cloneElement",
+      "createContext",
+      "forwardRef",
+      "lazy",
+      "memo",
+      "startTransition",
+      "Children",
+      "Component",
+      "PureComponent",
+      "Fragment",
+      "Profiler",
+      "StrictMode",
+      "Suspense",
+      "version",
+      "isValidElement"
+    ],
+    "react-dom": ["createPortal", "flushSync", "version"],
+    "react-dom/client": ["createRoot", "hydrateRoot"],
+    "react-dom/server": ["renderToString", "renderToStaticMarkup", "renderToPipeableStream"]
+  };
+  const exports = knownExports[moduleId];
+  if (!exports) {
+    return `
+// Dynamic re-export for unknown module
+export const __moduleProxy__ = __sandlot_mod__;
+`;
+  }
+  return exports.map((name) => `export const ${name} = __sandlot_mod__.${name};`).join(`
+`);
+}
+async function bundle(options) {
+  await initBundler();
+  const {
+    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 result = await esbuild.build({
+    entryPoints: [normalizedEntry],
+    bundle: true,
+    write: false,
+    format,
+    minify,
+    sourcemap: sourcemap ? "inline" : false,
+    globalName,
+    target,
+    external,
+    plugins: [plugin]
+  });
+  const code = result.outputFiles?.[0]?.text ?? "";
+  return {
+    code,
+    warnings: result.warnings,
+    includedFiles: Array.from(includedFiles)
+  };
+}
+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.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 {}
+    }
+  }
+  return cache;
+}
+function parseTsConfig(configText, _configPath) {
+  try {
+    const config = JSON.parse(configText);
+    const compilerOptions = config.compilerOptions || {};
+    const options = {
+      ...getDefaultCompilerOptions()
+    };
+    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.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(`
+`);
+}
+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, 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
+      });
+      if (onBuild) {
+        await onBuild(bundleResult);
+      }
+      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)
+`;
+      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
+      };
+    }
+  });
+}
+function createInstallCommand(deps) {
+  const { fs, typesCache } = deps;
+  return defineCommand("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 defineCommand("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 defineCommand("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
+      };
+    }
+  });
+}
+function createRunCommand(deps) {
+  const { fs, libFiles, tsconfigPath, runOptions = {}, sharedModules } = deps;
+  return defineCommand("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
+      };
+    }
+  });
+}
+function createDefaultCommands(deps) {
+  return [
+    createTscCommand(deps),
+    createBuildCommand(deps),
+    createRunCommand(deps),
+    createInstallCommand(deps),
+    createUninstallCommand(deps),
+    createListCommand(deps)
+  ];
+}
+
+// src/ts-libs.ts
+var TS_VERSION = "5.9.3";
+var CDN_BASE = `https://cdn.jsdelivr.net/npm/typescript@${TS_VERSION}/lib`;
+var DB_NAME = "ts-lib-cache";
+var DB_VERSION = 1;
+var STORE_NAME = "libs";
+function getDefaultBrowserLibs() {
+  return ["es2020", "dom", "dom.iterable"];
+}
+function parseLibReferences(content) {
+  const refs = [];
+  const regex = /\/\/\/\s*<reference\s+lib="([^"]+)"\s*\/>/g;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    if (match[1]) {
+      refs.push(match[1]);
+    }
+  }
+  return refs;
+}
+function libNameToFileName(name) {
+  return `lib.${name}.d.ts`;
+}
+function extractLibName(filePath) {
+  const match = filePath.match(/lib\.([^/]+)\.d\.ts$/);
+  return match?.[1] ?? null;
+}
+async function fetchLibFile(name) {
+  const fileName = libNameToFileName(name);
+  const url = `${CDN_BASE}/${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) {
+  const result = new Map;
+  const pending = new Set(libs);
+  const fetched = new Set;
+  while (pending.size > 0) {
+    const batch = Array.from(pending);
+    pending.clear();
+    const results = await Promise.all(batch.map(async (name) => {
+      if (fetched.has(name)) {
+        return { name, content: null };
+      }
+      fetched.add(name);
+      try {
+        const content = await fetchLibFile(name);
+        return { name, content };
+      } catch (err) {
+        console.warn(`Failed to fetch lib.${name}.d.ts:`, err);
+        return { name, content: null };
+      }
+    }));
+    for (const { name, content } of results) {
+      if (content === null)
+        continue;
+      result.set(name, content);
+      const refs = parseLibReferences(content);
+      for (const ref of refs) {
+        if (!fetched.has(ref) && !pending.has(ref)) {
+          pending.add(ref);
+        }
+      }
+    }
+  }
+  return result;
+}
+async function openDatabase() {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    request.onerror = () => reject(request.error);
+    request.onsuccess = () => resolve(request.result);
+    request.onupgradeneeded = (event) => {
+      const db = event.target.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME);
+      }
+    };
+  });
+}
+function promisifyRequest(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+function getCacheKey() {
+  return `libs-${TS_VERSION}`;
+}
+
+class LibCache {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  static async create() {
+    const db = await openDatabase();
+    return new LibCache(db);
+  }
+  async getOrFetch(libs) {
+    const cached = await this.get();
+    if (cached) {
+      const missing = libs.filter((lib) => !cached.has(lib));
+      if (missing.length === 0) {
+        return cached;
+      }
+      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`);
+    await this.set(fetched);
+    return fetched;
+  }
+  async get() {
+    const tx = this.db.transaction(STORE_NAME, "readonly");
+    const store = tx.objectStore(STORE_NAME);
+    const key = getCacheKey();
+    const cached = await promisifyRequest(store.get(key));
+    if (!cached) {
+      return null;
+    }
+    if (cached.version !== TS_VERSION) {
+      console.log(`Cache version mismatch: ${cached.version} vs ${TS_VERSION}`);
+      return null;
+    }
+    return new Map(Object.entries(cached.libs));
+  }
+  async set(libs) {
+    const tx = this.db.transaction(STORE_NAME, "readwrite");
+    const store = tx.objectStore(STORE_NAME);
+    const key = getCacheKey();
+    const cached = {
+      version: TS_VERSION,
+      timestamp: Date.now(),
+      libs: Object.fromEntries(libs)
+    };
+    await promisifyRequest(store.put(cached, key));
+  }
+  async clear() {
+    const tx = this.db.transaction(STORE_NAME, "readwrite");
+    const store = tx.objectStore(STORE_NAME);
+    await promisifyRequest(store.clear());
+  }
+  close() {
+    this.db.close();
+  }
+}
+async function fetchAndCacheLibs(libs = getDefaultBrowserLibs()) {
+  const cache = await LibCache.create();
+  try {
+    return await cache.getOrFetch(libs);
+  } finally {
+    cache.close();
+  }
+}
+
+// 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]);
+  return {
+    libFiles,
+    bundlerReady: Promise.resolve(),
+    typesCache
+  };
+}
+var defaultResourcesInstance = null;
+var defaultResourcesPromise = null;
+async function getDefaultResources() {
+  if (defaultResourcesInstance) {
+    return defaultResourcesInstance;
+  }
+  if (!defaultResourcesPromise) {
+    defaultResourcesPromise = createSharedResources().then((resources) => {
+      defaultResourcesInstance = resources;
+      return resources;
+    });
+  }
+  return defaultResourcesPromise;
+}
+function clearDefaultResources() {
+  defaultResourcesInstance = null;
+  defaultResourcesPromise = null;
+}
+function hasDefaultResources() {
+  return defaultResourcesInstance !== null;
+}
+
+// src/sandbox.ts
+class BuildEmitter {
+  listeners = new Set;
+  lastResult = null;
+  emit = async (result) => {
+    this.lastResult = result;
+    const promises = [];
+    for (const listener of this.listeners) {
+      const ret = listener(result);
+      if (ret instanceof Promise) {
+        promises.push(ret);
+      }
+    }
+    await Promise.all(promises);
+  };
+  on(callback) {
+    this.listeners.add(callback);
+    return () => {
+      this.listeners.delete(callback);
+    };
+  }
+  waitFor() {
+    if (this.lastResult) {
+      const result = this.lastResult;
+      this.lastResult = null;
+      return Promise.resolve(result);
+    }
+    return new Promise((resolve) => {
+      const unsub = this.on((result) => {
+        unsub();
+        this.lastResult = null;
+        resolve(result);
+      });
+    });
+  }
+}
+async function createSandbox(options = {}) {
+  const {
+    fsOptions = {},
+    tsconfigPath = "/tsconfig.json",
+    resources: providedResources,
+    onBuild: onBuildCallback,
+    customCommands = [],
+    sharedModules
+  } = options;
+  const fsPromise = IndexedDbFs.create(fsOptions);
+  const resourcesPromise = providedResources ? Promise.resolve(providedResources) : getDefaultResources();
+  const bundlerPromise = initBundler();
+  const [fs, resources] = await Promise.all([fsPromise, resourcesPromise, bundlerPromise]);
+  const libFiles = resources.libFiles;
+  const typesCache = resources.typesCache;
+  const buildEmitter = new BuildEmitter;
+  if (onBuildCallback) {
+    buildEmitter.on(onBuildCallback);
+  }
+  const commandDeps = {
+    fs,
+    libFiles,
+    tsconfigPath,
+    onBuild: buildEmitter.emit,
+    typesCache,
+    sharedModules
+  };
+  const defaultCommands = createDefaultCommands(commandDeps);
+  const bash = new Bash({
+    fs,
+    cwd: "/",
+    customCommands: [...defaultCommands, ...customCommands]
+  });
+  return {
+    fs,
+    bash,
+    isDirty: () => fs.isDirty(),
+    save: () => fs.save(),
+    close: () => fs.close(),
+    onBuild: (callback) => buildEmitter.on(callback)
+  };
+}
+async function createInMemorySandbox(options = {}) {
+  const {
+    initialFiles,
+    tsconfigPath = "/tsconfig.json",
+    resources: providedResources,
+    onBuild: onBuildCallback,
+    customCommands = [],
+    sharedModules
+  } = options;
+  const resourcesPromise = providedResources ? Promise.resolve(providedResources) : getDefaultResources();
+  const bundlerPromise = initBundler();
+  const fs = IndexedDbFs.createInMemory({ initialFiles });
+  const [resources] = await Promise.all([resourcesPromise, bundlerPromise]);
+  const libFiles = resources.libFiles;
+  const typesCache = resources.typesCache;
+  const buildEmitter = new BuildEmitter;
+  if (onBuildCallback) {
+    buildEmitter.on(onBuildCallback);
+  }
+  const commandDeps = {
+    fs,
+    libFiles,
+    tsconfigPath,
+    onBuild: buildEmitter.emit,
+    typesCache,
+    sharedModules
+  };
+  const defaultCommands = createDefaultCommands(commandDeps);
+  const bash = new Bash({
+    fs,
+    cwd: "/",
+    customCommands: [...defaultCommands, ...customCommands]
+  });
+  return {
+    fs,
+    bash,
+    isDirty: () => fs.isDirty(),
+    save: () => Promise.resolve(false),
+    close: () => {},
+    onBuild: (callback) => buildEmitter.on(callback)
+  };
+}
+// src/sandbox-manager.ts
+import { Bash as Bash2 } from "just-bash/browser";
+class BuildEmitter2 {
+  listeners = new Set;
+  lastResult = null;
+  emit = async (result) => {
+    this.lastResult = result;
+    const promises = [];
+    for (const listener of this.listeners) {
+      const ret = listener(result);
+      if (ret instanceof Promise) {
+        promises.push(ret);
+      }
+    }
+    await Promise.all(promises);
+  };
+  on(callback) {
+    this.listeners.add(callback);
+    return () => {
+      this.listeners.delete(callback);
+    };
+  }
+  waitFor() {
+    if (this.lastResult) {
+      const result = this.lastResult;
+      this.lastResult = null;
+      return Promise.resolve(result);
+    }
+    return new Promise((resolve) => {
+      const unsub = this.on((result) => {
+        unsub();
+        this.lastResult = null;
+        resolve(result);
+      });
+    });
+  }
+}
+
+class SandboxManager {
+  resources = null;
+  sandboxes = new Map;
+  initialized = false;
+  initPromise = null;
+  nextId = 1;
+  options;
+  constructor(options = {}) {
+    this.options = {
+      libs: options.libs ?? getDefaultBrowserLibs(),
+      ...options
+    };
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    if (this.initPromise) {
+      await this.initPromise;
+      return;
+    }
+    this.initPromise = this.doInitialize();
+    await this.initPromise;
+    this.initialized = true;
+  }
+  async doInitialize() {
+    this.resources = await createSharedResources({
+      libs: this.options.libs,
+      skipLibs: this.options.skipLibs,
+      skipBundler: this.options.skipBundler
+    });
+  }
+  async createSandbox(options = {}) {
+    await this.initialize();
+    const {
+      id = `sandbox-${this.nextId++}`,
+      fsOptions = {},
+      initialFiles,
+      tsconfigPath = "/tsconfig.json",
+      onBuild,
+      customCommands = [],
+      inMemory = true,
+      sharedModules = this.options.sharedModules
+    } = options;
+    let fs;
+    if (inMemory) {
+      fs = IndexedDbFs.createInMemory({
+        initialFiles,
+        maxSizeBytes: fsOptions.maxSizeBytes
+      });
+    } else {
+      fs = await IndexedDbFs.create({
+        dbName: fsOptions.dbName ?? id,
+        initialFiles,
+        maxSizeBytes: fsOptions.maxSizeBytes
+      });
+    }
+    const buildEmitter = new BuildEmitter2;
+    if (onBuild) {
+      buildEmitter.on(onBuild);
+    }
+    const commandDeps = {
+      fs,
+      libFiles: this.resources.libFiles,
+      tsconfigPath,
+      onBuild: buildEmitter.emit,
+      typesCache: this.resources.typesCache,
+      sharedModules
+    };
+    const defaultCommands = createDefaultCommands(commandDeps);
+    const bash = new Bash2({
+      fs,
+      cwd: "/",
+      customCommands: [...defaultCommands, ...customCommands]
+    });
+    const sandbox = {
+      id,
+      fs,
+      bash,
+      isDirty: () => fs.isDirty(),
+      save: () => fs.save(),
+      close: () => {
+        fs.close();
+        this.sandboxes.delete(id);
+      },
+      onBuild: (callback) => buildEmitter.on(callback)
+    };
+    this.sandboxes.set(id, sandbox);
+    return sandbox;
+  }
+  getSandbox(id) {
+    return this.sandboxes.get(id);
+  }
+  getAllSandboxes() {
+    return Array.from(this.sandboxes.values());
+  }
+  closeSandbox(id) {
+    const sandbox = this.sandboxes.get(id);
+    if (sandbox) {
+      sandbox.close();
+      return true;
+    }
+    return false;
+  }
+  destroyAll() {
+    for (const sandbox of this.sandboxes.values()) {
+      sandbox.fs.close();
+    }
+    this.sandboxes.clear();
+  }
+  async saveAll() {
+    const results = new Map;
+    for (const [id, sandbox] of this.sandboxes) {
+      const saved = await sandbox.save();
+      results.set(id, saved);
+    }
+    return results;
+  }
+  getDirtySandboxes() {
+    return Array.from(this.sandboxes.entries()).filter(([_, sandbox]) => sandbox.isDirty()).map(([id]) => id);
+  }
+  getStats() {
+    return {
+      initialized: this.initialized,
+      activeSandboxes: this.sandboxes.size,
+      libFilesCount: this.resources?.libFiles.size ?? 0,
+      sandboxIds: Array.from(this.sandboxes.keys())
+    };
+  }
+  getResources() {
+    return this.resources;
+  }
+  getLibFiles() {
+    return this.resources?.libFiles ?? new Map;
+  }
+}
+async function createSandboxManager(options = {}) {
+  const manager = new SandboxManager(options);
+  await manager.initialize();
+  return manager;
+}
+export {
+  unregisterSharedModule,
+  uninstallPackage,
+  typecheck,
+  registerSharedModules,
+  loadModule,
+  loadExport,
+  loadDefault,
+  listPackages,
+  installPackage,
+  initBundler,
+  hasExport,
+  hasDefaultResources,
+  getPackageManifest,
+  getExportNames,
+  getDefaultResources,
+  getDefaultBrowserLibs,
+  formatDiagnosticsForAgent,
+  formatDiagnostics,
+  fetchAndCacheLibs,
+  createUninstallCommand,
+  createTscCommand,
+  createSharedResources,
+  createSandboxManager,
+  createSandbox,
+  createRunCommand,
+  createListCommand,
+  createInstallCommand,
+  createIndexedDbFs,
+  createInMemorySandbox,
+  createDefaultCommands,
+  createBuildCommand,
+  clearSharedModules,
+  clearDefaultResources,
+  bundleToUrl,
+  bundleAndImport,
+  bundle,
+  SandboxManager,
+  ModuleLoadError,
+  IndexedDbFs,
+  ExportNotFoundError
+};