sandlot 0.1.4 → 0.2.0

package/README.md

@@ -1,243 +0,0 @@
-# Sandlot
-
-Browser-based TypeScript sandbox with esbuild bundling and type checking. Designed for AI agent workflows where code needs to be written, validated, and executed in real-time, all in the browser.
-
-## Installation
-
-```bash
-npm install sandlot
-```
-
-## Quick Start
-
-```typescript
-import { createBuilder, registerSharedModules } from "sandlot";
-import * as React from "react";
-
-// Share React with dynamic code to avoid duplicate instances
-registerSharedModules({ react: React });
-
-// Create a reusable builder
-const runAgent = createBuilder({
-  sandboxOptions: { sharedModules: ["react"] },
-  build: async (sandbox, prompt) => {
-    // Your agent logic here - execute commands via sandbox.bash.exec()
-    await sandbox.bash.exec(
-      'echo "export const App = () => <div>Hello</div>" > /src/index.tsx',
-    );
-    await sandbox.bash.exec("build /src/index.tsx");
-  },
-});
-
-// Run with a prompt
-const result = await runAgent("Create a counter component");
-
-if (result.module?.App) {
-  // Use the generated component
-  const App = result.module.App as React.ComponentType;
-}
-```
-
-## Builder API
-
-The `createBuilder()` function is the primary API for agent workflows. It handles sandbox lifecycle, build capture, validation, and cancellation.
-
-### `createBuilder(options)`
-
-Returns a reusable builder function that can be called with different prompts.
-
-```typescript
-const runAgent = createBuilder<T>({
-  // Sandbox configuration (pick one)
-  sandbox?: Sandbox,           // Reuse an existing sandbox (state persists between calls)
-  sandboxOptions?: SandboxOptions, // Create fresh sandbox per call (isolated runs)
-
-  // Your agent logic
-  build: (sandbox: Sandbox, prompt: string) => Promise<T>,
-});
-```
-
-#### Options
-
-| Option           | Type                              | Description                                             |
-| ---------------- | --------------------------------- | ------------------------------------------------------- |
-| `sandbox`        | `Sandbox`                         | Existing sandbox to reuse. Files persist between calls. |
-| `sandboxOptions` | `SandboxOptions`                  | Options for creating fresh sandboxes per call.          |
-| `build`          | `(sandbox, prompt) => Promise<T>` | Your agent logic. Receives the sandbox and prompt.      |
-
-### Calling the Builder
-
-```typescript
-const result = await runAgent(prompt, options?);
-```
-
-#### Call Options
-
-| Option     | Type            | Description                                                     |
-| ---------- | --------------- | --------------------------------------------------------------- |
-| `validate` | `(module) => M` | Validate exports during build. Errors are visible to the agent. |
-| `timeout`  | `number`        | Max time in ms. Throws `AbortError` if exceeded.                |
-| `signal`   | `AbortSignal`   | For external cancellation.                                      |
-
-#### Result
-
-```typescript
-interface BuildResult<T, M> {
-  result: T | undefined; // Return value from your build function
-  error: Error | null; // Error if build function threw
-  bundle: BundleResult | null; // The compiled JavaScript bundle
-  module: M | null; // Loaded module exports (validated if validate provided)
-  sandbox: Sandbox; // The sandbox used (for inspection or reuse)
-}
-```
-
-### Validation
-
-Validation runs as part of the `build` command. If it throws, the build fails and the agent sees the error, allowing it to fix the code and retry.
-
-```typescript
-const result = 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 };
-  },
-});
-// result.module is typed as { App: React.ComponentType } | null
-```
-
-With Zod:
-
-```typescript
-import { z } from "zod";
-
-const Schema = z.object({
-  App: z.custom<React.ComponentType>((v) => typeof v === "function"),
-  initialCount: z.number().optional(),
-});
-
-const result = await runAgent("Create a counter", {
-  validate: (mod) => Schema.parse(mod),
-});
-```
-
-### Cancellation
-
-```typescript
-const controller = new AbortController();
-
-const promise = runAgent("Create a dashboard", {
-  signal: controller.signal,
-  timeout: 60_000, // 1 minute
-});
-
-// Cancel on user action
-cancelButton.onclick = () => controller.abort();
-```
-
-## Sandbox API
-
-For lower-level control, use `createSandbox()` directly.
-
-```typescript
-import { createSandbox } from "sandlot";
-
-const sandbox = await createSandbox({
-  initialFiles: {
-    "/src/index.ts": "export const x = 1;",
-    "/tsconfig.json": JSON.stringify({ compilerOptions: { strict: true } }),
-  },
-  sharedModules: ["react", "react-dom/client"],
-  onBuild: (result) => console.log("Build succeeded:", result),
-});
-
-// Execute shell commands
-await sandbox.bash.exec("tsc /src/index.ts"); // Type check
-await sandbox.bash.exec("build /src/index.ts"); // Bundle
-await sandbox.bash.exec("install lodash"); // Install package
-await sandbox.bash.exec("list"); // List packages
-
-// Access the last successful build
-if (sandbox.lastBuild) {
-  const { bundle, module } = sandbox.lastBuild;
-}
-
-// Serialize state for persistence
-const state = sandbox.getState();
-localStorage.setItem("project", JSON.stringify(state));
-```
-
-### Sandbox Options
-
-| Option          | Type                     | Description                                         |
-| --------------- | ------------------------ | --------------------------------------------------- |
-| `initialFiles`  | `Record<string, string>` | Files to populate the filesystem with.              |
-| `sharedModules` | `string[]`               | Modules to resolve from host (e.g., `['react']`).   |
-| `tsconfigPath`  | `string`                 | Path to tsconfig.json (default: `/tsconfig.json`).  |
-| `onBuild`       | `(result) => void`       | Callback when a build succeeds.                     |
-| `bashOptions`   | `SandboxBashOptions`     | Options for the just-bash shell (env, limits).      |
-
-## Shell Commands
-
-The sandbox provides these built-in commands:
-
-| Command                   | Description                         |
-| ------------------------- | ----------------------------------- |
-| `tsc [entry]`             | Type check (uses tsconfig.json)     |
-| `build [entry] [options]` | Bundle (runs typecheck first)       |
-| `install <pkg>`           | Install npm package (fetches types) |
-| `uninstall <pkg>`         | Remove package                      |
-| `list`                    | List installed packages             |
-| `run <entry>`             | Execute a script                    |
-
-Build options: `--format <esm\|iife\|cjs>`, `--minify`, `--skip-typecheck`
-
-## Shared Modules
-
-To avoid duplicate library instances (important for React context/hooks), register shared modules before creating sandboxes:
-
-```typescript
-import { registerSharedModules } from "sandlot";
-import * as React from "react";
-import * as ReactDOM from "react-dom/client";
-
-registerSharedModules({
-  react: React,
-  "react-dom/client": ReactDOM,
-});
-```
-
-Then include them in `sharedModules` when creating a sandbox.
-
-## Cross-Origin Isolation
-
-For optimal esbuild-wasm performance, enable cross-origin isolation by adding these headers to your dev server:
-
-```
-Cross-Origin-Embedder-Policy: require-corp
-Cross-Origin-Opener-Policy: same-origin
-```
-
-In Vite:
-
-```typescript
-export default defineConfig({
-  plugins: [
-    {
-      name: "isolation",
-      configureServer: (server) => {
-        server.middlewares.use((_, res, next) => {
-          res.setHeader("Cross-Origin-Embedder-Policy", "require-corp");
-          res.setHeader("Cross-Origin-Opener-Policy", "same-origin");
-          next();
-        });
-      },
-    },
-  ],
-});
-```
-
-## License
-
-MIT

package/dist/build-emitter.d.ts

@@ -1,47 +0,0 @@
-/**
- * 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 declare class BuildEmitter {
-    private listeners;
-    /**
-     * Emit a build result to all listeners.
-     * Called internally when a build command succeeds.
-     */
-    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: BuildOutput) => void | Promise<void>): () => void;
-}
-//# sourceMappingURL=build-emitter.d.ts.map

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

@@ -1 +0,0 @@
-{"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

@@ -1,370 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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"}