sandlot 0.1.2 → 0.1.3

package/dist/index.js

@@ -7,47 +7,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 +24,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 +35,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 +65,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 +110,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 +161,6 @@ class IndexedDbFs {
       mode: DEFAULT_DIR_MODE,
       mtime: new Date
     });
-    this.dirty = true;
   }
   async readdir(path) {
     const normalizedPath = this.normalizePath(path);
@@ -287,7 +236,6 @@ class IndexedDbFs {
       }
     }
     this.entries.delete(normalizedPath);
-    this.dirty = true;
   }
   async cp(src, dest, options) {
     const srcPath = this.normalizePath(src);
@@ -314,7 +262,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 +288,6 @@ class IndexedDbFs {
       this.entries.delete(srcPath);
       this.entries.set(destPath, entry);
     }
-    this.dirty = true;
   }
   resolvePath(base, path) {
     if (path.startsWith("/")) {
@@ -371,7 +317,6 @@ class IndexedDbFs {
     }
     entry.mode = mode;
     entry.mtime = new Date;
-    this.dirty = true;
   }
   async symlink(target, linkPath) {
     const normalizedLinkPath = this.normalizePath(linkPath);
@@ -385,7 +330,6 @@ class IndexedDbFs {
       mode: DEFAULT_SYMLINK_MODE,
       mtime: new Date
     });
-    this.dirty = true;
   }
   async link(existingPath, newPath) {
     const srcPath = this.normalizePath(existingPath);
@@ -407,7 +351,6 @@ class IndexedDbFs {
       mode: entry.mode,
       mtime: new Date
     });
-    this.dirty = true;
   }
   async readlink(path) {
     const normalizedPath = this.normalizePath(path);
@@ -453,10 +396,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 +426,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 +503,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 +529,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 +998,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 +1030,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 +1087,9 @@ function unregisterSharedModule(moduleId) {
 function clearSharedModules() {
   getSharedModuleRegistry().clear();
 }
+function getSharedModuleExports(moduleId) {
+  return getSharedModuleRegistry().getExportNames(moduleId);
+}
 function getSharedModuleRuntimeCode(moduleId) {
   return `
 (function() {
@@ -1375,55 +1287,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 +1335,8 @@ async function bundle(options) {
     globalName,
     target,
     external,
-    plugins: [plugin]
+    plugins: [plugin],
+    jsx: "automatic"
   });
   const code = result.outputFiles?.[0]?.text ?? "";
   return {
@@ -1489,7 +1359,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 +1764,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 +1829,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 +1901,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 +1949,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 +1989,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 +2047,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 +2092,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 +2122,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 +2303,7 @@ ${err.stack}` : "";
     }
   });
 }
+// src/commands/index.ts
 function createDefaultCommands(deps) {
   return [
     createTscCommand(deps),
@@ -2597,9 +2513,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 +2529,155 @@ 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({
+    ...bashOptions,
     fs,
-    cwd: "/",
     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 +2714,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
 };