sandlot 0.1.2 → 0.1.4

package/dist/index.js

@@ -1,3 +1,11 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/sandbox.ts
 import { Bash } from "just-bash/browser";
 
@@ -7,47 +15,14 @@ var DEFAULT_DIR_MODE = 493;
 var DEFAULT_SYMLINK_MODE = 511;
 var DEFAULT_MAX_SIZE_BYTES = 50 * 1024 * 1024;
 
-class IndexedDbFs {
+class Filesystem {
   entries;
-  db = null;
-  dbName;
   maxSizeBytes;
-  dirty = false;
-  constructor(entries, db, dbName, maxSizeBytes) {
+  constructor(entries, 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 = {}) {
+  static create(options = {}) {
     const maxSizeBytes = options.maxSizeBytes ?? DEFAULT_MAX_SIZE_BYTES;
     const entries = new Map;
     entries.set("/", {
@@ -57,9 +32,9 @@ class IndexedDbFs {
     });
     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);
+        const normalizedPath = Filesystem.normalizePath(path);
+        const init = Filesystem.parseFileInit(value);
+        Filesystem.ensureParentDirs(entries, normalizedPath);
         entries.set(normalizedPath, {
           type: "file",
           content: init.content,
@@ -68,31 +43,21 @@ class IndexedDbFs {
         });
       }
     }
-    return new IndexedDbFs(entries, null, "", maxSizeBytes);
+    return new Filesystem(entries, 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());
+  getFiles() {
+    const files = {};
     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;
+      if (entry.type === "file") {
+        if (typeof entry.content === "string") {
+          files[path] = entry.content;
+        } else {
+          const base64 = this.encodeBase64(entry.content);
+          files[path] = `data:application/octet-stream;base64,${base64}`;
+        }
+      }
     }
-    this.entries = await IndexedDbFs.loadEntries(this.db);
-    this.dirty = false;
-  }
-  isDirty() {
-    return this.dirty;
+    return files;
   }
   getSize() {
     let size = 0;
@@ -108,12 +73,6 @@ class IndexedDbFs {
     }
     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);
@@ -159,7 +118,6 @@ class IndexedDbFs {
       mode: existing?.mode ?? DEFAULT_FILE_MODE,
       mtime: new Date
     });
-    this.dirty = true;
   }
   async appendFile(path, content, options) {
     const normalizedPath = this.normalizePath(path);
@@ -211,7 +169,6 @@ class IndexedDbFs {
       mode: DEFAULT_DIR_MODE,
       mtime: new Date
     });
-    this.dirty = true;
   }
   async readdir(path) {
     const normalizedPath = this.normalizePath(path);
@@ -287,7 +244,6 @@ class IndexedDbFs {
       }
     }
     this.entries.delete(normalizedPath);
-    this.dirty = true;
   }
   async cp(src, dest, options) {
     const srcPath = this.normalizePath(src);
@@ -314,7 +270,6 @@ class IndexedDbFs {
       this.ensureParentDirs(destPath);
       this.entries.set(destPath, this.cloneEntry(entry));
     }
-    this.dirty = true;
   }
   async mv(src, dest) {
     const srcPath = this.normalizePath(src);
@@ -341,7 +296,6 @@ class IndexedDbFs {
       this.entries.delete(srcPath);
       this.entries.set(destPath, entry);
     }
-    this.dirty = true;
   }
   resolvePath(base, path) {
     if (path.startsWith("/")) {
@@ -371,7 +325,6 @@ class IndexedDbFs {
     }
     entry.mode = mode;
     entry.mtime = new Date;
-    this.dirty = true;
   }
   async symlink(target, linkPath) {
     const normalizedLinkPath = this.normalizePath(linkPath);
@@ -385,7 +338,6 @@ class IndexedDbFs {
       mode: DEFAULT_SYMLINK_MODE,
       mtime: new Date
     });
-    this.dirty = true;
   }
   async link(existingPath, newPath) {
     const srcPath = this.normalizePath(existingPath);
@@ -407,7 +359,6 @@ class IndexedDbFs {
       mode: entry.mode,
       mtime: new Date
     });
-    this.dirty = true;
   }
   async readlink(path) {
     const normalizedPath = this.normalizePath(path);
@@ -453,10 +404,9 @@ class IndexedDbFs {
       throw new Error(`ENOENT: no such file or directory, utimes '${path}'`);
     }
     entry.mtime = mtime;
-    this.dirty = true;
   }
   normalizePath(path) {
-    return IndexedDbFs.normalizePath(path);
+    return Filesystem.normalizePath(path);
   }
   static normalizePath(path) {
     if (!path || path === ".")
@@ -484,8 +434,7 @@ class IndexedDbFs {
     return lastSlash === 0 ? "/" : path.slice(0, lastSlash);
   }
   ensureParentDirs(path) {
-    IndexedDbFs.ensureParentDirs(this.entries, path);
-    this.dirty = true;
+    Filesystem.ensureParentDirs(this.entries, path);
   }
   static ensureParentDirs(entries, path) {
     const parts = path.split("/").filter(Boolean);
@@ -562,17 +511,20 @@ class IndexedDbFs {
       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);
+      return this.encodeBase64(buffer);
     }
     if (encoding === "hex") {
       return Array.from(buffer).map((b) => b.toString(16).padStart(2, "0")).join("");
     }
     return new TextDecoder("utf-8").decode(buffer);
   }
+  encodeBase64(buffer) {
+    let binary = "";
+    for (let i = 0;i < buffer.byteLength; i++) {
+      binary += String.fromCharCode(buffer[i]);
+    }
+    return btoa(binary);
+  }
   concatBuffers(a, b) {
     const result = new Uint8Array(a.byteLength + b.byteLength);
     result.set(a, 0);
@@ -585,77 +537,9 @@ class IndexedDbFs {
     }
     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 createInMemoryFs(initialFiles) {
-  return IndexedDbFs.createInMemory({ initialFiles });
+function createFilesystem(options) {
+  return Filesystem.create(options);
 }
 
 // src/packages.ts
@@ -1122,16 +1006,18 @@ 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;
   }
   registerAll(modules) {
     for (const [id, mod] of Object.entries(modules)) {
-      this.modules.set(id, mod);
+      this.register(id, mod);
     }
     return this;
   }
@@ -1152,13 +1038,44 @@ class SharedModuleRegistry {
   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);
+    }
+  }
+  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) {
@@ -1178,6 +1095,9 @@ function unregisterSharedModule(moduleId) {
 function clearSharedModules() {
   getSharedModuleRegistry().clear();
 }
+function getSharedModuleExports(moduleId) {
+  return getSharedModuleRegistry().getExportNames(moduleId);
+}
 function getSharedModuleRuntimeCode(moduleId) {
   return `
 (function() {
@@ -1195,15 +1115,32 @@ function getSharedModuleRuntimeCode(moduleId) {
 
 // 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;
-  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");
+  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;
 }
@@ -1231,12 +1168,14 @@ async function initBundler() {
     await initPromise;
     return;
   }
-  checkCrossOriginIsolation();
   initPromise = (async () => {
     const es = await getEsbuild();
-    await es.initialize({
-      wasmURL: getWasmUrl()
-    });
+    if (!isServerEnvironment() && typeof es.initialize === "function") {
+      checkCrossOriginIsolation();
+      await es.initialize({
+        wasmURL: getWasmUrl()
+      });
+    }
   })();
   await initPromise;
   initialized = true;
@@ -1375,55 +1314,12 @@ ${generateNamedExports(args.path)}
   };
 }
 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(`
+  const exports = getSharedModuleExports(moduleId);
+  if (exports.length > 0) {
+    return exports.map((name) => `export const ${name} = __sandlot_mod__.${name};`).join(`
 `);
+  }
+  return `// No exports discovered for "${moduleId}" - use default import or call registerSharedModules() first`;
 }
 async function bundle(options) {
   await initBundler();
@@ -1466,7 +1362,8 @@ async function bundle(options) {
     globalName,
     target,
     external,
-    plugins: [plugin]
+    plugins: [plugin],
+    jsx: "automatic"
   });
   const code = result.outputFiles?.[0]?.text ?? "";
   return {
@@ -1489,7 +1386,21 @@ async function bundleAndImport(options) {
   }
 }
 
-// src/commands.ts
+// 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
@@ -1880,20 +1791,7 @@ async function hasExport(result, exportName) {
   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(`
-`);
-}
+// src/commands/compile.ts
 function createTscCommand(deps) {
   const { fs, libFiles, tsconfigPath } = deps;
   return defineCommand("tsc", async (args, _ctx) => {
@@ -1958,7 +1856,7 @@ ${formatDiagnosticsForAgent(result.diagnostics.filter((d) => d.category === "war
   });
 }
 function createBuildCommand(deps) {
-  const { fs, libFiles, tsconfigPath, onBuild, sharedModules } = deps;
+  const { fs, libFiles, tsconfigPath, onBuild, getValidation, sharedModules } = deps;
   return defineCommand("build", async (args, _ctx) => {
     let entryPoint = null;
     let skipTypecheck = false;
@@ -2030,8 +1928,39 @@ ${formatted}
         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(bundleResult);
+        await onBuild({ bundle: bundleResult, module: validatedModule });
       }
       let output = `Build successful!
 `;
@@ -2047,6 +1976,15 @@ ${formatted}
       }
       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:
@@ -2078,9 +2016,11 @@ ${formatDiagnosticsForAgent(warnings)}
     }
   });
 }
+// src/commands/packages.ts
+import { defineCommand as defineCommand2 } from "just-bash/browser";
 function createInstallCommand(deps) {
   const { fs, typesCache } = deps;
-  return defineCommand("install", async (args, _ctx) => {
+  return defineCommand2("install", async (args, _ctx) => {
     if (args.length === 0) {
       return {
         stdout: "",
@@ -2134,7 +2074,7 @@ Examples:
 }
 function createUninstallCommand(deps) {
   const { fs } = deps;
-  return defineCommand("uninstall", async (args, _ctx) => {
+  return defineCommand2("uninstall", async (args, _ctx) => {
     if (args.length === 0) {
       return {
         stdout: "",
@@ -2179,7 +2119,7 @@ function createUninstallCommand(deps) {
 }
 function createListCommand(deps) {
   const { fs } = deps;
-  return defineCommand("list", async (_args, _ctx) => {
+  return defineCommand2("list", async (_args, _ctx) => {
     try {
       const packages = await listPackages(fs);
       if (packages.length === 0) {
@@ -2209,9 +2149,11 @@ function createListCommand(deps) {
     }
   });
 }
+// src/commands/run.ts
+import { defineCommand as defineCommand3 } from "just-bash/browser";
 function createRunCommand(deps) {
   const { fs, libFiles, tsconfigPath, runOptions = {}, sharedModules } = deps;
-  return defineCommand("run", async (args, _ctx) => {
+  return defineCommand3("run", async (args, _ctx) => {
     let entryPoint = null;
     let skipTypecheck = runOptions.skipTypecheck ?? false;
     let timeout = runOptions.timeout ?? 30000;
@@ -2388,6 +2330,7 @@ ${err.stack}` : "";
     }
   });
 }
+// src/commands/index.ts
 function createDefaultCommands(deps) {
   return [
     createTscCommand(deps),
@@ -2402,9 +2345,6 @@ function createDefaultCommands(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"];
 }
@@ -2469,94 +2409,36 @@ async function fetchAllLibs(libs) {
   }
   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}`;
-}
+var memoryCache = null;
 
 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 (memoryCache) {
+      const missing = libs.filter((lib) => !memoryCache.has(lib));
       if (missing.length === 0) {
-        return cached;
+        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`);
-    await this.set(fetched);
+    memoryCache = 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));
+  get() {
+    return memoryCache;
   }
-  async clear() {
-    const tx = this.db.transaction(STORE_NAME, "readwrite");
-    const store = tx.objectStore(STORE_NAME);
-    await promisifyRequest(store.clear());
+  set(libs) {
+    memoryCache = libs;
   }
-  close() {
-    this.db.close();
+  clear() {
+    memoryCache = null;
   }
 }
 async function fetchAndCacheLibs(libs = getDefaultBrowserLibs()) {
-  const cache = await LibCache.create();
-  try {
-    return await cache.getOrFetch(libs);
-  } finally {
-    cache.close();
-  }
+  const cache = new LibCache;
+  return cache.getOrFetch(libs);
 }
 
 // src/shared-resources.ts
@@ -2597,9 +2479,7 @@ function hasDefaultResources() {
 // src/build-emitter.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);
@@ -2615,245 +2495,156 @@ class BuildEmitter {
       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);
-      });
-    });
-  }
 }
 
 // src/sandbox.ts
 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,
+    maxFilesystemSize,
     tsconfigPath = "/tsconfig.json",
     resources: providedResources,
     onBuild: onBuildCallback,
     customCommands = [],
-    sharedModules
+    sharedModules,
+    bashOptions = {}
   } = options;
+  const fs = Filesystem.create({
+    initialFiles,
+    maxSizeBytes: maxFilesystemSize
+  });
   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;
+  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);
+      }
+    }));
+  }
   const buildEmitter = new BuildEmitter;
+  let lastBuild = null;
+  buildEmitter.on((result) => {
+    lastBuild = result;
+  });
   if (onBuildCallback) {
     buildEmitter.on(onBuildCallback);
   }
+  let validationFn = null;
   const commandDeps = {
     fs,
     libFiles,
     tsconfigPath,
     onBuild: buildEmitter.emit,
+    getValidation: () => validationFn,
     typesCache,
     sharedModules
   };
   const defaultCommands = createDefaultCommands(commandDeps);
   const bash = new Bash({
-    fs,
+    ...bashOptions,
     cwd: "/",
+    fs,
     customCommands: [...defaultCommands, ...customCommands]
   });
   return {
     fs,
     bash,
-    isDirty: () => fs.isDirty(),
-    save: () => Promise.resolve(false),
-    close: () => {},
-    onBuild: (callback) => buildEmitter.on(callback)
+    get lastBuild() {
+      return lastBuild;
+    },
+    getState: () => ({ files: fs.getFiles() }),
+    onBuild: (callback) => buildEmitter.on(callback),
+    setValidation: (fn) => {
+      validationFn = fn;
+    },
+    clearValidation: () => {
+      validationFn = null;
+    }
   };
 }
-// src/sandbox-manager.ts
-import { Bash as Bash2 } from "just-bash/browser";
-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
-      });
+// 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 buildEmitter = new BuildEmitter;
-    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 captured = { output: null };
+    const unsubscribe = sandbox.onBuild((output) => {
+      captured.output = output;
     });
-    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();
+    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);
+      }
+      if (signal !== undefined) {
+        if (signal.aborted) {
+          abortController.abort(signal.reason);
+        } else {
+          signal.addEventListener("abort", () => {
+            abortController.abort(signal.reason);
+          }, { once: true });
+        }
+      }
     }
-    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);
+    let result;
+    let error = null;
+    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;
+      }
+    } catch (err) {
+      error = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      if (timeoutId !== undefined) {
+        clearTimeout(timeoutId);
+      }
+      unsubscribe();
+      if (callOptions?.validate) {
+        sandbox.clearValidation();
+      }
     }
-    return results;
-  }
-  getDirtySandboxes() {
-    return Array.from(this.sandboxes.entries()).filter(([_, sandbox]) => sandbox.isDirty()).map(([id]) => id);
-  }
-  getStats() {
+    const buildOutput = captured.output;
     return {
-      initialized: this.initialized,
-      activeSandboxes: this.sandboxes.size,
-      libFilesCount: this.resources?.libFiles.size ?? 0,
-      sandboxIds: Array.from(this.sandboxes.keys())
+      result,
+      error,
+      bundle: buildOutput?.bundle ?? null,
+      module: buildOutput?.module ?? null,
+      sandbox
     };
-  }
-  getResources() {
-    return this.resources;
-  }
-}
-async function createSandboxManager(options = {}) {
-  const manager = new SandboxManager(options);
-  await manager.initialize();
-  return manager;
+  };
 }
 
 // src/index.ts
@@ -2890,22 +2681,20 @@ export {
   createUninstallCommand,
   createTscCommand,
   createSharedResources,
-  createSandboxManager,
   createSandbox,
   createRunCommand,
   createListCommand,
   createInstallCommand,
-  createInMemorySandbox,
-  createInMemoryFs,
+  createFilesystem,
   createDefaultCommands,
+  createBuilder,
   createBuildCommand,
   clearSharedModules,
   clearDefaultResources,
   bundleToUrl,
   bundleAndImport,
   bundle,
-  SandboxManager,
   ModuleLoadError,
-  IndexedDbFs,
+  Filesystem,
   ExportNotFoundError
 };