sandlot 0.1.2 → 0.1.4

package/dist/sandbox.d.ts

@@ -1,15 +1,35 @@
-import { Bash, defineCommand } from "just-bash/browser";
-import { IndexedDbFs, type IndexedDbFsOptions } from "./fs";
-import { type BundleResult } from "./bundler";
+import { Bash, defineCommand, type BashOptions } from "just-bash/browser";
+import { Filesystem } from "./fs";
+import { type BuildOutput, type ValidateFn } from "./commands";
 import { type SharedResources } from "./shared-resources";
+/**
+ * Options that can be passed through to the just-bash Bash constructor.
+ * Excludes options that sandlot controls internally (fs, customCommands, files, cwd).
+ * The working directory is always root (/).
+ */
+export type SandboxBashOptions = Omit<BashOptions, 'fs' | 'customCommands' | 'files' | 'cwd'>;
 /**
  * Options for creating a sandbox environment
  */
 export interface SandboxOptions {
     /**
-     * Options for the IndexedDB filesystem
+     * Initial files to populate the filesystem with.
+     *
+     * @example
+     * ```ts
+     * const sandbox = await createSandbox({
+     *   initialFiles: {
+     *     '/src/index.ts': 'export const x = 1;',
+     *     '/tsconfig.json': JSON.stringify({ compilerOptions: { strict: true } }),
+     *   },
+     * });
+     * ```
+     */
+    initialFiles?: Record<string, string>;
+    /**
+     * Maximum filesystem size in bytes (default: 50MB)
      */
-    fsOptions?: IndexedDbFsOptions;
+    maxFilesystemSize?: number;
     /**
      * Path to tsconfig.json in the virtual filesystem.
      * Default: "/tsconfig.json"
@@ -25,10 +45,12 @@ export interface SandboxOptions {
     resources?: SharedResources;
     /**
      * Callback invoked when a build succeeds.
-     * Receives the bundle result with the compiled code.
-     * Use this to dynamically import the bundle or halt the agent.
+     * Receives the build output with the bundle and loaded module.
+     *
+     * For agent workflows, prefer using `createBuilder()` which handles
+     * build capture automatically.
      */
-    onBuild?: (result: BundleResult) => void | Promise<void>;
+    onBuild?: (result: BuildOutput) => void | Promise<void>;
     /**
      * Additional custom commands to add to the bash environment
      */
@@ -41,6 +63,9 @@ export interface SandboxOptions {
      * This solves the "multiple React instances" problem by allowing dynamic
      * components to share the same React instance as the host application.
      *
+     * Type definitions are automatically installed for these modules so that
+     * TypeScript can typecheck code that imports them.
+     *
      * @example
      * ```ts
      * // Host setup
@@ -53,73 +78,140 @@ export interface SandboxOptions {
      *   'react-dom/client': ReactDOM,
      * });
      *
-     * // Create sandbox with shared modules
-     * const sandbox = await createInMemorySandbox({
+     * // Create sandbox with shared modules (types auto-installed)
+     * const sandbox = await createSandbox({
      *   sharedModules: ['react', 'react-dom/client'],
      * });
      * ```
      */
     sharedModules?: string[];
+    /**
+     * Options passed through to the just-bash Bash constructor.
+     * Use this to configure environment variables, execution limits,
+     * network access, logging, and other bash-level settings.
+     *
+     * Note: `fs`, `customCommands`, `files`, and `cwd` are controlled by sandlot
+     * and cannot be overridden here. The working directory is always root (/).
+     *
+     * @example
+     * ```ts
+     * const sandbox = await createSandbox({
+     *   bashOptions: {
+     *     env: { NODE_ENV: 'development' },
+     *     executionLimits: { maxCommandCount: 1000 },
+     *   },
+     * });
+     * ```
+     */
+    bashOptions?: SandboxBashOptions;
+}
+/**
+ * Sandbox state that can be serialized for persistence.
+ */
+export interface SandboxState {
+    /**
+     * All files in the filesystem as path -> content mapping.
+     * Can be passed as `initialFiles` when creating a new sandbox.
+     */
+    files: Record<string, string>;
 }
 /**
  * The sandbox environment containing the filesystem and bash shell
  */
 export interface Sandbox {
     /**
-     * The virtual filesystem (IndexedDB-backed)
+     * The virtual filesystem
      */
-    fs: IndexedDbFs;
+    fs: Filesystem;
     /**
      * The just-bash shell environment
      */
     bash: Bash;
     /**
-     * Check if there are unsaved changes in the filesystem.
+     * The last successful build output, or null if no build has succeeded yet.
+     *
+     * This is updated automatically whenever a `build` command succeeds.
+     * Contains both the bundle and the loaded (and validated, if applicable) module.
      *
      * @example
      * ```ts
-     * await sandbox.bash.exec('echo "hello" > /test.txt');
-     * console.log(sandbox.isDirty()); // true
-     * await sandbox.save();
-     * console.log(sandbox.isDirty()); // false
+     * // Agent loop pattern
+     * while (!sandbox.lastBuild) {
+     *   const response = await agent.step();
+     *   await sandbox.bash.exec(response.command);
+     * }
+     * // Build succeeded, sandbox.lastBuild contains bundle + module
+     * const App = sandbox.lastBuild.module.App;
      * ```
      */
-    isDirty(): boolean;
+    lastBuild: BuildOutput | null;
     /**
-     * Save the filesystem to IndexedDB.
+     * Get the current sandbox state for persistence.
      *
-     * @returns true if saved, false if nothing to save or in-memory only
-     */
-    save(): Promise<boolean>;
-    /**
-     * Close all resources (filesystem, etc.)
+     * Returns a serializable object containing all files that can be
+     * JSON-serialized and used to restore the sandbox later.
+     *
+     * @example
+     * ```ts
+     * // Save sandbox state
+     * const state = sandbox.getState();
+     * localStorage.setItem('my-project', JSON.stringify(state));
+     *
+     * // Later, restore the sandbox
+     * const saved = JSON.parse(localStorage.getItem('my-project'));
+     * const sandbox2 = await createSandbox({ initialFiles: saved.files });
+     * ```
      */
-    close(): void;
+    getState(): SandboxState;
     /**
      * Subscribe to build events. Called whenever a build succeeds.
      * Returns an unsubscribe function.
      *
-     * Use this to capture the bundle result when build succeeds.
-     * The callback receives the BundleResult with the compiled code.
+     * For agent workflows, prefer using `createBuilder()` which handles
+     * build capture automatically. Use `onBuild` directly when you need
+     * more control over the subscription lifecycle.
      *
      * @example
      * ```ts
-     * let bundle: BundleResult | null = null;
-     *
-     * const sandbox = await createInMemorySandbox({
-     *   onBuild: (result) => {
-     *     bundle = result;
-     *     console.log('Built:', result.code.length, 'bytes');
-     *   },
+     * let lastBuild: BuildOutput | null = null;
+     * const unsubscribe = sandbox.onBuild((result) => {
+     *   lastBuild = result;
      * });
      *
-     * // ... agent writes files and calls build ...
+     * await sandbox.bash.exec('build /src/index.ts');
+     * unsubscribe();
+     *
+     * if (lastBuild) {
+     *   const App = lastBuild.module.App as React.ComponentType;
+     * }
+     * ```
+     */
+    onBuild(callback: (result: BuildOutput) => void | Promise<void>): () => void;
+    /**
+     * Set a validation function for the build command.
+     *
+     * When set, the build command will run this function after loading
+     * the module. If validation throws, the build fails and the agent
+     * sees the error. If validation passes, the validated module is
+     * available in the build output.
+     *
+     * @example
+     * ```ts
+     * sandbox.setValidation((mod) => {
+     *   if (!mod.App) throw new Error("Must export App component");
+     *   return { App: mod.App as React.ComponentType };
+     * });
      *
-     * // After successful build, bundle is available
-     * console.log(bundle?.code);
+     * // Now build will fail if App is missing
+     * await sandbox.bash.exec('build /src/index.ts');
      * ```
      */
-    onBuild(callback: (result: BundleResult) => void | Promise<void>): () => void;
+    setValidation(fn: ValidateFn): void;
+    /**
+     * Clear the validation function.
+     * After calling this, builds will not perform validation.
+     */
+    clearValidation(): void;
 }
 /**
  * Create an in-browser agent sandbox with a virtual filesystem, TypeScript
@@ -128,9 +220,12 @@ export interface Sandbox {
  * The sandbox provides a just-bash shell with custom commands:
  * - `tsc [entry]` - Type check the project
  * - `build [entry] [options]` - Build the project (runs typecheck first)
+ * - `install <pkg>` - Install npm packages
+ * - `uninstall <pkg>` - Remove packages
+ * - `list` - List installed packages
+ * - `run <entry>` - Run a script
  *
  * Build options:
- * - `--output, -o <path>` - Output path (default: /dist/bundle.js)
  * - `--format, -f <esm|iife|cjs>` - Output format (default: esm)
  * - `--minify, -m` - Enable minification
  * - `--skip-typecheck, -s` - Skip type checking
@@ -140,18 +235,14 @@ export interface Sandbox {
  * let bundleResult: BundleResult | null = null;
  *
  * const sandbox = await createSandbox({
- *   fsOptions: {
- *     dbName: "my-project",
- *     initialFiles: {
- *       "/src/index.ts": "export const hello = 'world';",
- *       "/tsconfig.json": JSON.stringify({
- *         compilerOptions: { target: "ES2020", strict: true }
- *       }),
- *     },
+ *   initialFiles: {
+ *     '/src/index.ts': 'export const hello = "world";',
+ *     '/tsconfig.json': JSON.stringify({
+ *       compilerOptions: { target: 'ES2020', strict: true }
+ *     }),
  *   },
  *   onBuild: (result) => {
  *     bundleResult = result;
- *     // Could also: dynamically import, halt agent, etc.
  *   },
  * });
  *
@@ -159,27 +250,18 @@ export interface Sandbox {
  * await sandbox.bash.exec('echo "console.log(1);" > /src/index.ts');
  *
  * // Type check
- * const tscResult = await sandbox.bash.exec("tsc");
+ * const tscResult = await sandbox.bash.exec('tsc /src/index.ts');
  * console.log(tscResult.stdout);
  *
  * // Build (includes typecheck, triggers onBuild callback)
- * const buildResult = await sandbox.bash.exec("build");
+ * const buildResult = await sandbox.bash.exec('build /src/index.ts');
  * console.log(buildResult.stdout);
  * console.log(bundleResult?.code); // The compiled bundle
  *
- * // Save to IndexedDB
- * await sandbox.save();
- *
- * // Clean up
- * sandbox.close();
+ * // Save state for later
+ * const state = sandbox.getState();
+ * localStorage.setItem('my-project', JSON.stringify(state));
  * ```
  */
 export declare function createSandbox(options?: SandboxOptions): Promise<Sandbox>;
-/**
- * Create an in-memory sandbox (no IndexedDB persistence).
- * Useful for testing or temporary workspaces.
- */
-export declare function createInMemorySandbox(options?: Omit<SandboxOptions, "fsOptions"> & {
-    initialFiles?: Record<string, string>;
-}): Promise<Sandbox>;
 //# sourceMappingURL=sandbox.d.ts.map

package/dist/sandbox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sandbox.d.ts","sourceRoot":"","sources":["../src/sandbox.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,MAAM,CAAC;AAC5D,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,WAAW,CAAC;AAE3D,OAAO,EAAuB,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAG/E;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,SAAS,CAAC,EAAE,kBAAkB,CAAC;IAE/B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,eAAe,CAAC;IAE5B;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzD;;OAEG;IACH,cAAc,CAAC,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,EAAE,CAAC;IAEpD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB;;OAEG;IACH,EAAE,EAAE,WAAW,CAAC;IAEhB;;OAEG;IACH,IAAI,EAAE,IAAI,CAAC;IAEX;;;;;;;;;;OAUG;IACH,OAAO,IAAI,OAAO,CAAC;IAEnB;;;;OAIG;IACH,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAEzB;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,OAAO,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC;CAC/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,wBAAsB,aAAa,CAAC,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,OAAO,CAAC,CAgElF;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,GAAE,IAAI,CAAC,cAAc,EAAE,WAAW,CAAC,GAAG;IAC3C,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC,GACL,OAAO,CAAC,OAAO,CAAC,CA8DlB"}
+{"version":3,"file":"sandbox.d.ts","sourceRoot":"","sources":["../src/sandbox.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,EAAE,UAAU,EAA0B,MAAM,MAAM,CAAC;AAE1D,OAAO,EAA2C,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AACxG,OAAO,EAAuB,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAI/E;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,gBAAgB,GAAG,OAAO,GAAG,KAAK,CAAC,CAAC;AAE9F;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;;;;;;;OAYG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEtC;;OAEG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,eAAe,CAAC;IAE5B;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAExD;;OAEG;IACH,cAAc,CAAC,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,EAAE,CAAC;IAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAEzB;;;;;;;;;;;;;;;;;OAiBG;IACH,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB;;OAEG;IACH,EAAE,EAAE,UAAU,CAAC;IAEf;;OAEG;IACH,IAAI,EAAE,IAAI,CAAC;IAEX;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,EAAE,WAAW,GAAG,IAAI,CAAC;IAE9B;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,IAAI,YAAY,CAAC;IAEzB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,OAAO,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC;IAE7E;;;;;;;;;;;;;;;;;;OAkBG;IACH,aAAa,CAAC,EAAE,EAAE,UAAU,GAAG,IAAI,CAAC;IAEpC;;;OAGG;IACH,eAAe,IAAI,IAAI,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAsB,aAAa,CAAC,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,OAAO,CAAC,CA8GlF"}

package/dist/shared-modules.d.ts

@@ -21,7 +21,7 @@
  * });
  *
  * // Now create sandbox with sharedModules option
- * const sandbox = await createInMemorySandbox({
+ * const sandbox = await createSandbox({
  *   sharedModules: ['react', 'react-dom/client'],
  * });
  * ```
@@ -33,9 +33,11 @@
  */
 export declare class SharedModuleRegistry {
     private modules;
+    private exportNames;
     constructor();
     /**
-     * Register a module to be shared with dynamic bundles
+     * Register a module to be shared with dynamic bundles.
+     * Automatically introspects the module to discover its exports.
      *
      * @param moduleId - The import specifier (e.g., 'react', 'react-dom/client')
      * @param module - The module's exports object
@@ -43,7 +45,8 @@ export declare class SharedModuleRegistry {
      */
     register(moduleId: string, module: unknown): this;
     /**
-     * Register multiple modules at once
+     * Register multiple modules at once.
+     * Automatically introspects each module to discover its exports.
      *
      * @param modules - Object mapping module IDs to their exports
      * @returns this for chaining
@@ -74,6 +77,14 @@ export declare class SharedModuleRegistry {
      * Get list of all registered module IDs
      */
     list(): string[];
+    /**
+     * Get the export names for a registered module.
+     * These were discovered by introspecting the module at registration time.
+     *
+     * @param moduleId - The import specifier
+     * @returns Array of export names, or empty array if not registered
+     */
+    getExportNames(moduleId: string): string[];
     /**
      * Clear all registrations
      */
@@ -121,6 +132,14 @@ export declare function unregisterSharedModule(moduleId: string): boolean;
  * Clear all shared modules from the default registry.
  */
 export declare function clearSharedModules(): void;
+/**
+ * Get the export names for a registered shared module.
+ * Used by the bundler to generate proper re-export statements.
+ *
+ * @param moduleId - The import specifier
+ * @returns Array of export names, or empty array if not registered
+ */
+export declare function getSharedModuleExports(moduleId: string): string[];
 /**
  * Generate the runtime code that dynamic bundles use to access shared modules.
  * This is injected into bundles when they import from shared modules.

package/dist/shared-modules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared-modules.d.ts","sourceRoot":"","sources":["../src/shared-modules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAOH;;;;GAIG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,OAAO,CAA8B;;IAO7C;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAKjD;;;;;OAKG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAOnD;;;;;OAKG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIrC;;;;;;OAMG;IACH,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAa9B;;;;OAIG;IACH,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI9B;;OAEG;IACH,IAAI,IAAI,MAAM,EAAE;IAIhB;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF;AAKD;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,oBAAoB,CAK9D;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,OAAO,CAEjD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAE5E;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEhE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAanE"}
+{"version":3,"file":"shared-modules.d.ts","sourceRoot":"","sources":["../src/shared-modules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAOH;;;;GAIG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,OAAO,CAA8B;IAC7C,OAAO,CAAC,WAAW,CAA+B;;IAOlD;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAOjD;;;;;;OAMG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAOnD;;;;;OAKG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIrC;;;;;;OAMG;IACH,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAa9B;;;;OAIG;IACH,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI9B;;OAEG;IACH,IAAI,IAAI,MAAM,EAAE;IAIhB;;;;;;OAMG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE;IAI1C;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF;AA+CD;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,oBAAoB,CAK9D;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,OAAO,CAEjD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAE5E;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEhE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAEjE;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAanE"}

package/dist/shared-resources.d.ts

@@ -6,9 +6,6 @@
  * - esbuild WASM (~10MB) - singleton bundler initialization
  * - Types cache - avoids redundant network fetches when multiple sandboxes
  *   install the same packages
- *
- * This module consolidates what was previously scattered across
- * sandbox.ts and sandbox-manager.ts into a single source of truth.
  */
 import { type TypesCache } from "./packages";
 export type { TypesCache } from "./packages";

package/dist/shared-resources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared-resources.d.ts","sourceRoot":"","sources":["../src/shared-resources.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAGjE,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE9B;;OAEG;IACH,YAAY,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5B;;;;OAIG;IACH,UAAU,EAAE,UAAU,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAEhB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,eAAe,CAAC,CAqB1B;AAWD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,eAAe,CAAC,CAapE;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAG5C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C"}
+{"version":3,"file":"shared-resources.d.ts","sourceRoot":"","sources":["../src/shared-resources.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAGjE,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE9B;;OAEG;IACH,YAAY,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5B;;;;OAIG;IACH,UAAU,EAAE,UAAU,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAEhB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,eAAe,CAAC,CAqB1B;AAWD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,eAAe,CAAC,CAapE;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAG5C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C"}

package/dist/ts-libs.d.ts

@@ -2,8 +2,8 @@
  * TypeScript standard library fetcher and cache.
  *
  * Fetches TypeScript's lib.*.d.ts files from jsDelivr CDN and caches
- * them in IndexedDB for reuse. These files provide types for built-in
- * JavaScript APIs (Array, Number, String) and browser APIs (console, window, document).
+ * them in memory. These files provide types for built-in JavaScript APIs
+ * (Array, Number, String) and browser APIs (console, window, document).
  */
 /**
  * Default libs for browser environment with ES2020 target.
@@ -46,21 +46,15 @@ export declare function fetchLibFile(name: string): Promise<string>;
  */
 export declare function fetchAllLibs(libs: string[]): Promise<Map<string, string>>;
 /**
- * LibCache provides IndexedDB-backed caching for TypeScript lib files.
+ * LibCache provides in-memory caching for TypeScript lib files.
  *
  * Usage:
  * ```ts
- * const cache = await LibCache.create();
+ * const cache = new LibCache();
  * const libs = await cache.getOrFetch(getDefaultBrowserLibs());
  * ```
  */
 export declare class LibCache {
-    private db;
-    private constructor();
-    /**
-     * Create and initialize a LibCache instance.
-     */
-    static create(): Promise<LibCache>;
     /**
      * Get cached libs if available, otherwise fetch from CDN and cache.
      *
@@ -71,25 +65,18 @@ export declare class LibCache {
     /**
      * Get cached libs if available.
      */
-    get(): Promise<Map<string, string> | null>;
+    get(): Map<string, string> | null;
     /**
      * Store libs in the cache.
      */
-    set(libs: Map<string, string>): Promise<void>;
+    set(libs: Map<string, string>): void;
     /**
      * Clear all cached libs.
      */
-    clear(): Promise<void>;
-    /**
-     * Close the database connection.
-     */
-    close(): void;
+    clear(): void;
 }
 /**
  * Convenience function to fetch and cache libs in one call.
- * Creates a temporary LibCache, fetches libs, and returns the result.
- *
- * For repeated use, prefer creating a LibCache instance directly.
  *
  * @param libs - Lib names to fetch (defaults to getDefaultBrowserLibs())
  * @returns Map of lib name to content

package/dist/ts-libs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ts-libs.d.ts","sourceRoot":"","sources":["../src/ts-libs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAoBH;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,EAAE,CAEhD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAY5D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG9D;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAUhE;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CA6C/E;AA+CD;;;;;;;;GAQG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,EAAE,CAAc;IAExB,OAAO;IAIP;;OAEG;WACU,MAAM,IAAI,OAAO,CAAC,QAAQ,CAAC;IAKxC;;;;;OAKG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAwB9D;;OAEG;IACG,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAmBhD;;OAEG;IACG,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAcnD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5B;;OAEG;IACH,KAAK,IAAI,IAAI;CAGd;AAED;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,GAAE,MAAM,EAA4B,GACvC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAO9B"}
+{"version":3,"file":"ts-libs.d.ts","sourceRoot":"","sources":["../src/ts-libs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAaH;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,EAAE,CAEhD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAY5D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG9D;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAUhE;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CA6C/E;AAQD;;;;;;;;GAQG;AACH,qBAAa,QAAQ;IACnB;;;;;OAKG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAuB9D;;OAEG;IACH,GAAG,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAIjC;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAIpC;;OAEG;IACH,KAAK,IAAI,IAAI;CAGd;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,GAAE,MAAM,EAA4B,GACvC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAG9B"}

package/dist/typechecker.d.ts

@@ -76,7 +76,7 @@ export interface TypecheckResult {
  *
  * @example
  * ```ts
- * const fs = IndexedDbFs.createInMemory({
+ * const fs = Filesystem.create({
  *   initialFiles: {
  *     "/tsconfig.json": JSON.stringify({
  *       compilerOptions: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sandlot",
-  "version": "0.1.2",
-  "description": "Browser-based TypeScript sandbox with esbuild bundling and type checking",
+  "version": "0.1.4",
+  "description": "TypeScript sandbox with esbuild bundling and type checking for browser and server",
   "author": "blindmansion",
   "license": "MIT",
   "keywords": [
@@ -44,16 +44,16 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "react": ">=17.0.0"
+    "esbuild": ">=0.20.0"
   },
   "peerDependenciesMeta": {
-    "react": {
+    "esbuild": {
       "optional": true
     }
   },
   "devDependencies": {
     "@types/bun": "latest",
     "@types/react": "^19",
-    "react": "^19.2.3"
+    "esbuild": "^0.27.2"
   }
 }

package/src/build-emitter.ts

@@ -1,25 +1,29 @@
 /**
  * Build event emitter for sandbox environments.
  *
- * Simple typed event emitter for build results.
- * Caches the last result so waitFor() can be called after build completes.
+ * Simple typed event emitter for successful build results.
+ * Used internally by the sandbox to notify listeners when a build succeeds.
  */
 
-import type { BundleResult } from "./bundler";
+import type { BuildOutput } from "./commands/types";
 
 /**
  * Simple typed event emitter for build results.
- * Caches the last result so waitFor() can be called after build completes.
+ *
+ * Only emits on successful builds—build failures are communicated via
+ * the bash command's exit code and stderr.
+ *
+ * For most use cases, prefer using `createBuilder()` which handles
+ * build result capture automatically.
  */
 export class BuildEmitter {
-  private listeners = new Set<(result: BundleResult) => void | Promise<void>>();
-  private lastResult: BundleResult | null = null;
+  private listeners = new Set<(result: BuildOutput) => void | Promise<void>>();
 
   /**
-   * Emit a build result to all listeners and cache it
+   * Emit a build result to all listeners.
+   * Called internally when a build command succeeds.
    */
-  emit = async (result: BundleResult): Promise<void> => {
-    this.lastResult = result;
+  emit = async (result: BuildOutput): Promise<void> => {
     const promises: Promise<void>[] = [];
     for (const listener of this.listeners) {
       const ret = listener(result);
@@ -32,30 +36,29 @@ export class BuildEmitter {
 
   /**
    * Subscribe to build events. Returns an unsubscribe function.
+   *
+   * The callback is invoked each time a build succeeds, receiving
+   * the BuildOutput with the bundle and loaded module.
+   *
+   * @example
+   * ```ts
+   * let lastBuild: BuildOutput | null = null;
+   * const unsubscribe = sandbox.onBuild((result) => {
+   *   lastBuild = result;
+   * });
+   *
+   * await sandbox.bash.exec('build /src/index.ts');
+   * unsubscribe();
+   *
+   * if (lastBuild) {
+   *   const App = lastBuild.module.App as React.ComponentType;
+   * }
+   * ```
    */
-  on(callback: (result: BundleResult) => void | Promise<void>): () => void {
+  on(callback: (result: BuildOutput) => void | Promise<void>): () => void {
     this.listeners.add(callback);
     return () => {
       this.listeners.delete(callback);
     };
   }
-
-  /**
-   * Get the last build result, or wait for the next one if none exists.
-   * Clears the cached result after returning, so subsequent calls wait for new builds.
-   */
-  waitFor(): Promise<BundleResult> {
-    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);
-      });
-    });
-  }
 }