sandlot 0.1.2 → 0.1.4

package/dist/build-emitter.d.ts

@@ -1,29 +1,47 @@
 /**
  * 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 declare class BuildEmitter {
     private listeners;
-    private lastResult;
     /**
-     * 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: (result: BundleResult) => Promise<void>;
+    emit: (result: BuildOutput) => Promise<void>;
     /**
      * 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;
-    /**
-     * 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>;
+    on(callback: (result: BuildOutput) => void | Promise<void>): () => void;
 }
 //# sourceMappingURL=build-emitter.d.ts.map

package/dist/build-emitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-emitter.d.ts","sourceRoot":"","sources":["../src/build-emitter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C;;;GAGG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAA6D;IAC9E,OAAO,CAAC,UAAU,CAA6B;IAE/C;;OAEG;IACH,IAAI,GAAU,QAAQ,YAAY,KAAG,OAAO,CAAC,IAAI,CAAC,CAUhD;IAEF;;OAEG;IACH,EAAE,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI;IAOxE;;;OAGG;IACH,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC;CAcjC"}
+{"version":3,"file":"build-emitter.d.ts","sourceRoot":"","sources":["../src/build-emitter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;GAQG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAA4D;IAE7E;;;OAGG;IACH,IAAI,GAAU,QAAQ,WAAW,KAAG,OAAO,CAAC,IAAI,CAAC,CAS/C;IAEF;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,EAAE,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI;CAMxE"}

package/dist/builder.d.ts

@@ -0,0 +1,370 @@
+/**
+ * High-level builder for sandbox-based agent workflows.
+ *
+ * Provides a simple API that handles sandbox creation, build result capture,
+ * validation, and timeout/cancellation—letting the caller focus on their agent logic.
+ */
+import { type Sandbox, type SandboxOptions } from "./sandbox";
+import type { BundleResult } from "./bundler";
+/**
+ * Result of running a builder.
+ *
+ * @typeParam T - The return type of the build function
+ * @typeParam M - The type of the validated module (defaults to Record<string, unknown>)
+ */
+export interface BuildResult<T, M = Record<string, unknown>> {
+    /**
+     * Whatever the `build` function returned, or `undefined` if it threw.
+     */
+    result: T | undefined;
+    /**
+     * The error thrown by the `build` function, or `null` if it succeeded.
+     *
+     * When an error occurs, the bundle and module may still be available
+     * if a build succeeded before the error was thrown.
+     */
+    error: Error | null;
+    /**
+     * The last successful build result, or null if no build succeeded.
+     *
+     * This captures the bundle from any successful `build` command executed
+     * during the run. If multiple builds succeed, this contains the last one.
+     *
+     * **Important**: This is available even if the `build` function threw an error,
+     * as long as a build succeeded before the error occurred.
+     */
+    bundle: BundleResult | null;
+    /**
+     * The loaded module exports, or null if no bundle was produced.
+     *
+     * When a build succeeds, the bundle is automatically loaded. If a `validate`
+     * function was provided, the module is passed through it and the result is
+     * available here with the validated type.
+     *
+     * @example Without validation
+     * ```ts
+     * const result = await runAgent("Create a counter");
+     * result.module // Record<string, unknown> | null
+     * ```
+     *
+     * @example With validation
+     * ```ts
+     * const result = await runAgent("Create a counter", {
+     *   validate: (mod) => ({ App: mod.App as React.ComponentType }),
+     * });
+     * result.module // { App: React.ComponentType } | null
+     * ```
+     */
+    module: M | null;
+    /**
+     * The sandbox that was used.
+     *
+     * Useful when the builder created an ephemeral sandbox—you can inspect
+     * its state, save it, or reuse it for another build.
+     */
+    sandbox: Sandbox;
+}
+/**
+ * Options passed when calling the builder function.
+ *
+ * @typeParam M - The type returned by the validate function (if provided)
+ */
+export interface BuildCallOptions<M = Record<string, unknown>> {
+    /**
+     * Validation function for the built module.
+     *
+     * When provided, this function runs as part of the build command—after
+     * bundling and loading, but before the build is considered successful.
+     * If validation throws, the build fails and the agent sees the error,
+     * giving it a chance to fix the code and try again.
+     *
+     * The return type determines the type of `result.module`.
+     *
+     * @example Simple validation
+     * ```ts
+     * const result = await runAgent("Create a counter", {
+     *   validate: (mod) => {
+     *     if (typeof mod.App !== 'function') {
+     *       throw new Error("Module must export an App component");
+     *     }
+     *     return { App: mod.App as React.ComponentType };
+     *   },
+     * });
+     * // If validation fails, agent sees: "Build failed: Validation error."
+     * // Agent can fix the code and try again
+     * result.module?.App // React.ComponentType (after successful build)
+     * ```
+     *
+     * @example With Zod
+     * ```ts
+     * import { z } from 'zod';
+     *
+     * const CounterSchema = z.object({
+     *   App: z.custom<React.ComponentType>((v) => typeof v === 'function'),
+     *   initialCount: z.number().optional(),
+     * });
+     *
+     * const result = await runAgent("Create a counter", {
+     *   validate: (mod) => CounterSchema.parse(mod),
+     * });
+     * result.module?.App          // React.ComponentType
+     * result.module?.initialCount // number | undefined
+     * ```
+     */
+    validate?: (module: Record<string, unknown>) => M;
+    /**
+     * Maximum time in milliseconds for the build to complete.
+     *
+     * If the timeout is exceeded, the build is aborted and an error is thrown.
+     * The agent's partial work may still be available in the sandbox.
+     *
+     * @example
+     * ```ts
+     * const result = await runAgent("Create a complex dashboard", {
+     *   timeout: 300_000, // 5 minutes
+     * });
+     * ```
+     */
+    timeout?: number;
+    /**
+     * AbortSignal for cancelling the build.
+     *
+     * If the signal is aborted, the build stops and an error is thrown.
+     * Useful for user-initiated cancellation or external timeout management.
+     *
+     * @example
+     * ```ts
+     * const controller = new AbortController();
+     *
+     * // Start the build
+     * const promise = runAgent("Create a counter", {
+     *   signal: controller.signal,
+     * });
+     *
+     * // Cancel after 10 seconds
+     * setTimeout(() => controller.abort(), 10_000);
+     *
+     * try {
+     *   const result = await promise;
+     * } catch (err) {
+     *   if (err.name === 'AbortError') {
+     *     console.log('Build was cancelled');
+     *   }
+     * }
+     * ```
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Options for creating a reusable builder function.
+ */
+export interface CreateBuilderOptions<T> {
+    /**
+     * Existing sandbox to reuse across all calls.
+     *
+     * When provided, the same sandbox is used for every call to the returned
+     * builder function. Files and state persist between runs—useful for
+     * iterative workflows where you want to build on previous work.
+     *
+     * @example
+     * ```ts
+     * const sandbox = await createSandbox({
+     *   initialFiles: { '/src/utils.ts': 'export const PI = 3.14;' },
+     * });
+     *
+     * const runAgent = createBuilder({
+     *   sandbox, // Reused across all calls
+     *   build: async (sb, prompt) => myAgent.run(sb, prompt),
+     * });
+     *
+     * await runAgent("Create a circle component"); // Uses existing utils.ts
+     * await runAgent("Add a square component");    // Still has circle + utils
+     * ```
+     */
+    sandbox?: Sandbox;
+    /**
+     * Options for creating fresh sandboxes (only used if `sandbox` is not provided).
+     *
+     * Each call to the returned builder function creates a new sandbox with
+     * these options. Use this when you want isolated runs.
+     *
+     * @example
+     * ```ts
+     * const runAgent = createBuilder({
+     *   sandboxOptions: {
+     *     sharedModules: ['react', 'react-dom/client'],
+     *   },
+     *   build: async (sandbox, prompt) => myAgent.run(sandbox, prompt),
+     * });
+     *
+     * // Each call gets a fresh sandbox
+     * await runAgent("Create a counter");  // Fresh sandbox
+     * await runAgent("Create a todo list"); // Another fresh sandbox
+     * ```
+     */
+    sandboxOptions?: SandboxOptions;
+    /**
+     * The function to build with the sandbox and prompt.
+     *
+     * This receives the sandbox and the prompt string, and should return
+     * whatever result your agent produces.
+     *
+     * @example
+     * ```ts
+     * const runAgent = createBuilder({
+     *   build: async (sandbox, prompt) => {
+     *     const agent = new MyAgent({
+     *       tools: { bash: sandbox.bash.exec },
+     *     });
+     *     return agent.run(prompt);
+     *   },
+     * });
+     * ```
+     */
+    build: (sandbox: Sandbox, prompt: string) => Promise<T>;
+}
+/**
+ * The builder function returned by `createBuilder`.
+ *
+ * Can be called with just a prompt, or with options including validation,
+ * timeout, and abort signal.
+ */
+export interface BuilderFn<T> {
+    /**
+     * Run the builder with a prompt (no options).
+     * Module will be typed as `Record<string, unknown>`.
+     */
+    (prompt: string): Promise<BuildResult<T>>;
+    /**
+     * Run the builder with a prompt and options.
+     * If `validate` is provided, module will be typed based on its return type.
+     */
+    <M = Record<string, unknown>>(prompt: string, options: BuildCallOptions<M>): Promise<BuildResult<T, M>>;
+}
+/**
+ * Create a reusable builder function for running prompts in a sandbox.
+ *
+ * This is the main API for sandlot. Define your agent logic once, then call
+ * the returned function with different prompts. Each call:
+ *
+ * 1. Creates a sandbox (or uses one you provide)
+ * 2. Sets up build result capture
+ * 3. Runs your build function with the prompt
+ * 4. Returns everything: your result, the bundle, the module, and the sandbox
+ *
+ * **Sandbox behavior:**
+ * - If you provide `sandbox`: The same sandbox is reused for every call
+ *   (files persist, good for iteration)
+ * - If you provide `sandboxOptions` (or nothing): A fresh sandbox is created
+ *   for each call (isolated runs)
+ *
+ * **Validation behavior:**
+ * When you provide a `validate` function, it runs as part of the build command.
+ * If validation fails, the build fails and the agent sees the error—giving it
+ * a chance to fix the code and try again. This is more powerful than post-hoc
+ * validation because the agent can iterate on validation errors.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { createBuilder } from 'sandlot';
+ *
+ * const runAgent = createBuilder({
+ *   sandboxOptions: { sharedModules: ['react', 'react-dom/client'] },
+ *   build: async (sandbox, prompt) => {
+ *     const agent = new MyAgent({ tools: { bash: sandbox.bash.exec } });
+ *     return agent.run(prompt);
+ *   },
+ * });
+ *
+ * // Use it multiple times with different prompts
+ * const result1 = await runAgent("Create a counter component");
+ * const result2 = await runAgent("Create a todo list");
+ *
+ * if (result1.module?.App) {
+ *   const Counter = result1.module.App as React.ComponentType;
+ * }
+ * ```
+ *
+ * @example With validation (agent can fix validation errors)
+ * ```ts
+ * const runAgent = createBuilder({
+ *   sandboxOptions: { sharedModules: ['react'] },
+ *   build: async (sandbox, prompt) => myAgent.run(sandbox, prompt),
+ * });
+ *
+ * // Validation runs during build - agent sees errors and can fix them
+ * const counter = await runAgent("Create a counter", {
+ *   validate: (mod) => {
+ *     if (typeof mod.App !== 'function') {
+ *       throw new Error("Must export an App component");
+ *     }
+ *     return { App: mod.App as React.ComponentType };
+ *   },
+ * });
+ * // If agent's first attempt fails validation, it sees:
+ * // "Build failed: Validation error. Must export an App component"
+ * // Agent can then fix the code and run build again
+ * ```
+ *
+ * @example With Zod validation
+ * ```ts
+ * import { z } from 'zod';
+ *
+ * const CounterSchema = z.object({
+ *   App: z.custom<React.ComponentType>((v) => typeof v === 'function'),
+ *   initialCount: z.number().default(0),
+ * });
+ *
+ * const result = await runAgent("Create a counter", {
+ *   validate: (mod) => CounterSchema.parse(mod),
+ * });
+ * // result.module is fully typed from Zod inference
+ * ```
+ *
+ * @example Iterative workflow with shared sandbox
+ * ```ts
+ * const sandbox = await createSandbox();
+ *
+ * const runAgent = createBuilder({
+ *   sandbox, // Same sandbox for all calls
+ *   build: async (sb, prompt) => myAgent.run(sb, prompt),
+ * });
+ *
+ * // First prompt creates initial component
+ * await runAgent("Create a button component");
+ *
+ * // Second prompt can build on the first
+ * await runAgent("Add a click counter to the button");
+ * ```
+ *
+ * @example With timeout
+ * ```ts
+ * // Complex tasks get more time
+ * const result = await runAgent("Create a full dashboard with charts", {
+ *   timeout: 300_000, // 5 minutes
+ * });
+ * ```
+ *
+ * @example With abort signal for cancellation
+ * ```ts
+ * const controller = new AbortController();
+ *
+ * // Start the build
+ * const promise = runAgent("Create a counter", {
+ *   signal: controller.signal,
+ * });
+ *
+ * // User clicks cancel button
+ * cancelButton.onclick = () => controller.abort();
+ *
+ * try {
+ *   const result = await promise;
+ * } catch (err) {
+ *   if (err.name === 'AbortError') {
+ *     console.log('Build was cancelled by user');
+ *   }
+ * }
+ * ```
+ */
+export declare function createBuilder<T>(options: CreateBuilderOptions<T>): BuilderFn<T>;
+//# sourceMappingURL=builder.d.ts.map

package/dist/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAiB,KAAK,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAG9C;;;;;GAKG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACzD;;OAEG;IACH,MAAM,EAAE,CAAC,GAAG,SAAS,CAAC;IAEtB;;;;;OAKG;IACH,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAEpB;;;;;;;;OAQG;IACH,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAE5B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC;IAEjB;;;;;OAKG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACH,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IAElD;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB,CAAC,CAAC;IACrC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC;IAEhC;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;CACzD;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC;IAC1B;;;OAGG;IACH,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IAE1C;;;OAGG;IACH,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;CACzG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4HG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAiH/E"}

package/dist/bundler.d.ts

@@ -88,8 +88,12 @@ export interface BundleResult {
     includedFiles: string[];
 }
 /**
- * Initialize esbuild-wasm. Called automatically on first bundle.
+ * Initialize esbuild. Called automatically on first bundle.
  * Can be called explicitly to pre-warm.
+ *
+ * In browser environments, this loads and initializes esbuild-wasm.
+ * In server environments (Node.js, Bun, Deno), this loads native esbuild
+ * which doesn't require WASM initialization.
  */
 export declare function initBundler(): Promise<void>;
 /**
@@ -97,7 +101,7 @@ export declare function initBundler(): Promise<void>;
  *
  * @example
  * ```ts
- * const fs = IndexedDbFs.createInMemory({
+ * const fs = Filesystem.create({
  *   initialFiles: {
  *     "/src/index.ts": "export const hello = 'world';",
  *     "/src/utils.ts": "export function add(a: number, b: number) { return a + b; }",

package/dist/bundler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundler.d.ts","sourceRoot":"","sources":["../src/bundler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,KAAK,YAAY,MAAM,cAAc,CAAC;AA6BlD;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,UAAU,GAAG,QAAQ,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,EAAE,EAAE,WAAW,CAAC;IAEhB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAEpB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,cAAc,CAAC;IAE5B;;;;;;;;OAQG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAEzB;;OAEG;IACH,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,CAAC;IAEhC;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,QAAQ,EAAE,YAAY,CAAC,OAAO,EAAE,CAAC;IAEjC;;OAEG;IACH,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAsCD;;;GAGG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAmBjD;AA4OD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CA8D1E;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAIzE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,eAAe,CAAC,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,CAAC,CAAC,CAOrF"}
+{"version":3,"file":"bundler.d.ts","sourceRoot":"","sources":["../src/bundler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,KAAK,YAAY,MAAM,cAAc,CAAC;AAuDlD;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,UAAU,GAAG,QAAQ,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,EAAE,EAAE,WAAW,CAAC;IAEhB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAEpB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,cAAc,CAAC;IAE5B;;;;;;;;OAQG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAEzB;;OAEG;IACH,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,CAAC;IAEhC;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,QAAQ,EAAE,YAAY,CAAC,OAAO,EAAE,CAAC;IAEjC;;OAEG;IACH,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAsCD;;;;;;;GAOG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAsBjD;AA+ND;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CA+D1E;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAIzE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,eAAe,CAAC,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,CAAC,CAAC,CAOrF"}

package/dist/commands/compile.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Compile-related commands: tsc and build
+ */
+import { type CommandDeps } from "./types";
+/**
+ * Create the `tsc` command for type checking
+ */
+export declare function createTscCommand(deps: CommandDeps): import("just-bash/browser").Command;
+/**
+ * Create the `build` command for bundling (with automatic type checking)
+ */
+export declare function createBuildCommand(deps: CommandDeps): import("just-bash/browser").Command;
+//# sourceMappingURL=compile.d.ts.map

package/dist/commands/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/commands/compile.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,EAAE,KAAK,WAAW,EAAyB,MAAM,SAAS,CAAC;AAElE;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,WAAW,uCA4DjD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,WAAW,uCA6JnD"}

package/dist/commands/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Command factories for sandbox bash environments.
+ *
+ * Pure factories that create commands for type checking, bundling,
+ * package management, and code execution.
+ * No global state - all dependencies are passed in explicitly.
+ */
+export { type CommandDeps, type BuildOutput, type ValidateFn, type RunContext, type RunOptions, type RunResult, formatEsbuildMessages, } from "./types";
+export { createTscCommand, createBuildCommand } from "./compile";
+export { createInstallCommand, createUninstallCommand, createListCommand, } from "./packages";
+export { createRunCommand } from "./run";
+import type { CommandDeps } from "./types";
+/**
+ * Create all default sandbox commands
+ */
+export declare function createDefaultCommands(deps: CommandDeps): import("just-bash/browser").Command[];
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,SAAS,EACd,qBAAqB,GACtB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAGjE,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAGzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAK3C;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,WAAW,yCAStD"}

package/dist/commands/packages.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Package management commands: install, uninstall, list
+ */
+import type { CommandDeps } from "./types";
+/**
+ * Create the `install` command for adding packages from npm
+ */
+export declare function createInstallCommand(deps: CommandDeps): import("just-bash/browser").Command;
+/**
+ * Create the `uninstall` command for removing packages
+ */
+export declare function createUninstallCommand(deps: CommandDeps): import("just-bash/browser").Command;
+/**
+ * Create the `list` command (alias: `ls`) for showing installed packages
+ */
+export declare function createListCommand(deps: CommandDeps): import("just-bash/browser").Command;
+//# sourceMappingURL=packages.d.ts.map

package/dist/commands/packages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packages.d.ts","sourceRoot":"","sources":["../../src/commands/packages.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,WAAW,uCAoDrD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,WAAW,uCA+CvD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,uCAiClD"}

package/dist/commands/run.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Run command for executing code in the sandbox.
+ */
+import type { CommandDeps } from "./types";
+/**
+ * Create the `run` command for executing code in the sandbox.
+ *
+ * The run command:
+ * 1. Builds the entry point (with type checking by default)
+ * 2. Dynamically imports the bundle
+ * 3. If a `main` export exists, calls it with a RunContext
+ * 4. Captures all console output (log, warn, error)
+ * 5. Returns the captured output and any return value from main()
+ *
+ * Usage:
+ *   run [entry] [--skip-typecheck|-s] [--timeout|-t <ms>] [-- args...]
+ *
+ * Code can be written in two styles:
+ *
+ * 1. Script style (top-level code, runs on import):
+ *    ```ts
+ *    console.log("Hello from script!");
+ *    const result = 2 + 2;
+ *    console.log("Result:", result);
+ *    ```
+ *
+ * 2. Main function style (with context access):
+ *    ```ts
+ *    import type { RunContext } from "sandlot";
+ *
+ *    export async function main(ctx: RunContext) {
+ *      ctx.log("Reading file...");
+ *      const content = await ctx.fs.readFile("/data/input.txt");
+ *      ctx.log("Content:", content);
+ *      return { success: true };
+ *    }
+ *    ```
+ */
+export declare function createRunCommand(deps: CommandDeps): import("just-bash/browser").Command;
+//# sourceMappingURL=run.d.ts.map

package/dist/commands/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/commands/run.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,KAAK,EAAE,WAAW,EAAc,MAAM,SAAS,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,WAAW,uCAwMjD"}