sandlot 0.1.1 → 0.1.3

package/dist/sandbox.d.ts

@@ -1,23 +1,34 @@
-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";
-export type { BundleResult } from "./bundler";
-export type { TypecheckResult } from "./typechecker";
-export type { SharedResources, TypesCache } from "./shared-resources";
-export type { PackageManifest, InstallResult } from "./packages";
-export type { RunContext, RunOptions, RunResult } from "./commands";
-export { installPackage, uninstallPackage, listPackages, getPackageManifest } from "./packages";
-export { InMemoryTypesCache } from "./shared-resources";
-export { loadModule, loadExport, loadDefault, getExportNames, hasExport, createModuleUrl, revokeModuleUrl, ModuleLoadError, ExportNotFoundError, } from "./loader";
+/**
+ * Options that can be passed through to the just-bash Bash constructor.
+ * Excludes options that sandlot controls internally (fs, customCommands, files).
+ */
+export type SandboxBashOptions = Omit<BashOptions, 'fs' | 'customCommands' | 'files'>;
 /**
  * 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"
@@ -33,10 +44,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
      */
@@ -49,6 +62,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
@@ -61,73 +77,141 @@ 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`, and `files` are controlled by sandlot
+     * and cannot be overridden here.
+     *
+     * @example
+     * ```ts
+     * const sandbox = await createSandbox({
+     *   bashOptions: {
+     *     cwd: '/src',
+     *     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
@@ -136,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
@@ -148,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.
  *   },
  * });
  *
@@ -167,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,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,YAAY,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACtE,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACjE,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChG,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAGxD,OAAO,EACL,UAAU,EACV,UAAU,EACV,WAAW,EACX,cAAc,EACd,SAAS,EACT,eAAe,EACf,eAAe,EACf,eAAe,EACf,mBAAmB,GACpB,MAAM,UAAU,CAAC;AAuDlB;;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;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,gBAAgB,GAAG,OAAO,CAAC,CAAC;AAEtF;;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;;;;;;;;;;;;;;;;;;OAkBG;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,CA4GlF"}

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/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,6 +1,6 @@
 {
   "name": "sandlot",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Browser-based TypeScript sandbox with esbuild bundling and type checking",
   "author": "blindmansion",
   "license": "MIT",
@@ -22,11 +22,6 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
-    "./react": {
-      "types": "./dist/react.d.ts",
-      "import": "./dist/react.js",
-      "default": "./dist/react.js"
-    },
     "./internal": {
       "types": "./dist/internal.d.ts",
       "import": "./dist/internal.js",
@@ -39,7 +34,7 @@
   ],
   "scripts": {
     "build": "bun run build:js && bun run build:types",
-    "build:js": "bun build ./src/index.ts ./src/react.tsx ./src/internal.ts --outdir ./dist --format esm --packages external",
+    "build:js": "bun build ./src/index.ts ./src/internal.ts --outdir ./dist --format esm --packages external",
     "build:types": "tsc --emitDeclarationOnly",
     "prepublishOnly": "bun run build"
   },
@@ -48,17 +43,8 @@
     "just-bash": "^2.6.0",
     "typescript": "^5.9.3"
   },
-  "peerDependencies": {
-    "react": ">=17.0.0"
-  },
-  "peerDependenciesMeta": {
-    "react": {
-      "optional": true
-    }
-  },
   "devDependencies": {
     "@types/bun": "latest",
-    "@types/react": "^19",
-    "react": "^19.2.3"
+    "@types/react": "^19"
   }
 }

package/src/build-emitter.ts

@@ -0,0 +1,64 @@
+/**
+ * Build event emitter for sandbox environments.
+ *
+ * Simple typed event emitter for successful build results.
+ * Used internally by the sandbox to notify listeners when a build succeeds.
+ */
+
+import type { BuildOutput } from "./commands/types";
+
+/**
+ * Simple typed event emitter for build results.
+ *
+ * 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: BuildOutput) => void | Promise<void>>();
+
+  /**
+   * Emit a build result to all listeners.
+   * Called internally when a build command succeeds.
+   */
+  emit = async (result: BuildOutput): Promise<void> => {
+    const promises: Promise<void>[] = [];
+    for (const listener of this.listeners) {
+      const ret = listener(result);
+      if (ret instanceof Promise) {
+        promises.push(ret);
+      }
+    }
+    await Promise.all(promises);
+  };
+
+  /**
+   * 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: BuildOutput) => void | Promise<void>): () => void {
+    this.listeners.add(callback);
+    return () => {
+      this.listeners.delete(callback);
+    };
+  }
+}