sandlot 0.1.3 → 0.2.0

package/dist/sandbox-manager.d.ts

@@ -1,261 +0,0 @@
-/**
- * SandboxManager - Manages lifecycle and orchestration for multiple sandboxes.
- *
- * When running many sandboxes concurrently (e.g., for multiple AI agents),
- * this manager provides:
- *
- * - ID-based tracking and lookup of sandboxes
- * - Batch operations (saveAll, destroyAll, getDirtySandboxes)
- * - Manager-level default options inherited by all sandboxes
- * - Statistics and introspection
- *
- * Note: Resources (TypeScript libs, bundler) are shared via a global singleton
- * regardless of whether you use the manager or standalone sandbox functions.
- * The manager's value is lifecycle management, not resource efficiency.
- *
- * Usage:
- * ```ts
- * const manager = await createSandboxManager();
- *
- * // Create multiple sandboxes with automatic ID tracking
- * const sandbox1 = await manager.createSandbox({ id: "agent-1", ... });
- * const sandbox2 = await manager.createSandbox({ id: "agent-2", ... });
- *
- * // Lookup, batch operations, etc.
- * manager.getSandbox("agent-1");
- * manager.getDirtySandboxes();
- * await manager.saveAll();
- *
- * // Clean up all at once
- * manager.destroyAll();
- * ```
- */
-import { defineCommand } from "just-bash/browser";
-import { type IndexedDbFsOptions } from "./fs";
-import { type BundleResult } from "./bundler";
-import { type SharedResources } from "./shared-resources";
-import type { Sandbox, SandboxBashOptions } from "./sandbox";
-/**
- * Options for creating a sandbox via the manager
- */
-export interface ManagedSandboxOptions {
-    /**
-     * Unique identifier for this sandbox.
-     *
-     * Also used as the IndexedDB database name if `fsOptions.dbName` is not provided
-     * and `inMemory` is false. If both are provided, `fsOptions.dbName` takes precedence.
-     *
-     * @default Auto-generated as "sandbox-1", "sandbox-2", etc.
-     */
-    id?: string;
-    /**
-     * Options for the IndexedDB filesystem.
-     *
-     * Note: `fsOptions.dbName` takes precedence over `id` for the database name.
-     * If neither is provided, the auto-generated `id` is used.
-     */
-    fsOptions?: IndexedDbFsOptions;
-    /**
-     * Initial files to populate the filesystem with
-     */
-    initialFiles?: Record<string, string>;
-    /**
-     * Path to tsconfig.json in the virtual filesystem.
-     * Default: "/tsconfig.json"
-     */
-    tsconfigPath?: string;
-    /**
-     * Callback invoked when a build succeeds.
-     * Receives the bundle result with the compiled code.
-     */
-    onBuild?: (result: BundleResult) => void | Promise<void>;
-    /**
-     * Additional custom commands to add to the bash environment
-     */
-    customCommands?: ReturnType<typeof defineCommand>[];
-    /**
-     * If true, use in-memory filesystem only (no IndexedDB persistence).
-     * Default: true
-     */
-    inMemory?: boolean;
-    /**
-     * Module IDs that should be resolved from the host's SharedModuleRegistry
-     * instead of esm.sh CDN. Overrides manager-level sharedModules for this sandbox.
-     *
-     * @see SandboxOptions.sharedModules for full documentation
-     */
-    sharedModules?: string[];
-    /**
-     * Options passed through to the just-bash Bash constructor.
-     * Overrides manager-level bashOptions for this sandbox.
-     *
-     * @see SandboxOptions.bashOptions for full documentation
-     */
-    bashOptions?: SandboxBashOptions;
-}
-/**
- * A sandbox instance managed by the SandboxManager.
- *
- * Extends the base Sandbox interface with an `id` property for
- * identification within the manager. This ensures ManagedSandbox
- * has full feature parity with Sandbox.
- */
-export interface ManagedSandbox extends Sandbox {
-    /**
-     * Unique identifier for this sandbox within the manager.
-     */
-    id: string;
-}
-/**
- * Statistics about the sandbox manager
- */
-export interface SandboxManagerStats {
-    /**
-     * Whether shared resources have been initialized
-     */
-    initialized: boolean;
-    /**
-     * Number of currently active sandboxes
-     */
-    activeSandboxes: number;
-    /**
-     * Number of TypeScript lib files loaded
-     */
-    libFilesCount: number;
-    /**
-     * IDs of active sandboxes
-     */
-    sandboxIds: string[];
-}
-/**
- * Options for creating a SandboxManager
- */
-export interface SandboxManagerOptions {
-    /**
-     * Default shared modules for all sandboxes created by this manager.
-     * Individual sandboxes can override with their own sharedModules option.
-     *
-     * Module IDs that should be resolved from the host's SharedModuleRegistry
-     * instead of esm.sh CDN. The host must have registered these modules
-     * using `registerSharedModules()` before loading dynamic code.
-     *
-     * @example
-     * ```ts
-     * const manager = await createSandboxManager({
-     *   sharedModules: ['react', 'react-dom/client'],
-     * });
-     * ```
-     */
-    sharedModules?: string[];
-    /**
-     * Default bash options for all sandboxes created by this manager.
-     * Individual sandboxes can override with their own bashOptions.
-     *
-     * @see SandboxOptions.bashOptions for full documentation
-     */
-    bashOptions?: SandboxBashOptions;
-}
-/**
- * Manager for creating and managing multiple sandboxes.
- *
- * Provides lifecycle management, ID-based tracking, and batch operations
- * for multiple concurrent sandboxes. Resources (TypeScript libs, bundler)
- * are shared via a global singleton.
- */
-export declare class SandboxManager {
-    private resources;
-    private sandboxes;
-    private initialized;
-    private initPromise;
-    private nextId;
-    private options;
-    constructor(options?: SandboxManagerOptions);
-    /**
-     * Initialize the manager by loading shared resources.
-     * Called automatically on first sandbox creation, but can be called
-     * explicitly to pre-warm the global resource cache.
-     */
-    initialize(): Promise<void>;
-    private doInitialize;
-    /**
-     * Create a new managed sandbox.
-     * The sandbox is tracked by the manager and can be looked up by ID.
-     */
-    createSandbox(options?: ManagedSandboxOptions): Promise<ManagedSandbox>;
-    /**
-     * Get a sandbox by ID
-     */
-    getSandbox(id: string): ManagedSandbox | undefined;
-    /**
-     * Get all active sandboxes
-     */
-    getAllSandboxes(): ManagedSandbox[];
-    /**
-     * Close a specific sandbox
-     */
-    closeSandbox(id: string): boolean;
-    /**
-     * Close all sandboxes managed by this manager.
-     * Does not affect the global shared resources.
-     */
-    destroyAll(): void;
-    /**
-     * Save all sandboxes that have unsaved changes.
-     *
-     * @returns Map of sandbox ID to save result (true if saved, false if nothing to save)
-     *
-     * @example
-     * ```ts
-     * const results = await manager.saveAll();
-     * for (const [id, saved] of results) {
-     *   console.log(`${id}: ${saved ? 'saved' : 'no changes'}`);
-     * }
-     * ```
-     */
-    saveAll(): Promise<Map<string, boolean>>;
-    /**
-     * Get IDs of sandboxes with unsaved changes.
-     *
-     * @example
-     * ```ts
-     * const dirtyIds = manager.getDirtySandboxes();
-     * if (dirtyIds.length > 0) {
-     *   console.log('Unsaved sandboxes:', dirtyIds.join(', '));
-     * }
-     * ```
-     */
-    getDirtySandboxes(): string[];
-    /**
-     * Get statistics about the manager
-     */
-    getStats(): SandboxManagerStats;
-    /**
-     * Get the shared resources (for advanced use cases)
-     */
-    getResources(): SharedResources | null;
-}
-/**
- * Create a new SandboxManager instance.
- *
- * @example
- * ```ts
- * const manager = await createSandboxManager();
- *
- * // Create multiple sandboxes concurrently
- * const [sandbox1, sandbox2] = await Promise.all([
- *   manager.createSandbox({ id: "agent-1", initialFiles: { ... } }),
- *   manager.createSandbox({ id: "agent-2", initialFiles: { ... } }),
- * ]);
- *
- * // Run operations in parallel
- * const [result1, result2] = await Promise.all([
- *   sandbox1.bash.exec("build"),
- *   sandbox2.bash.exec("build"),
- * ]);
- *
- * // Clean up
- * manager.destroyAll();
- * ```
- */
-export declare function createSandboxManager(options?: SandboxManagerOptions): Promise<SandboxManager>;
-//# sourceMappingURL=sandbox-manager.d.ts.map

package/dist/sandbox-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sandbox-manager.d.ts","sourceRoot":"","sources":["../src/sandbox-manager.ts"],"names":[],"mappings":"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"}

package/dist/sandbox.d.ts

@@ -1,267 +0,0 @@
-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).
- */
-export type SandboxBashOptions = Omit<BashOptions, 'fs' | 'customCommands' | 'files'>;
-/**
- * Options for creating a sandbox environment
- */
-export interface SandboxOptions {
-    /**
-     * 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)
-     */
-    maxFilesystemSize?: number;
-    /**
-     * Path to tsconfig.json in the virtual filesystem.
-     * Default: "/tsconfig.json"
-     */
-    tsconfigPath?: string;
-    /**
-     * Shared resources (lib files, bundler).
-     * If not provided, uses the default singleton resources.
-     *
-     * Provide this to share resources across multiple sandboxes,
-     * or to use custom TypeScript libs.
-     */
-    resources?: SharedResources;
-    /**
-     * Callback invoked when a build succeeds.
-     * Receives the build output with the bundle and loaded module.
-     *
-     * For agent workflows, prefer using `createBuilder()` which handles
-     * build capture automatically.
-     */
-    onBuild?: (result: BuildOutput) => void | Promise<void>;
-    /**
-     * Additional custom commands to add to the bash environment
-     */
-    customCommands?: ReturnType<typeof defineCommand>[];
-    /**
-     * Module IDs that should be resolved from the host's SharedModuleRegistry
-     * instead of esm.sh CDN. The host must have registered these modules
-     * using `registerSharedModules()` before loading dynamic code.
-     *
-     * 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
-     * import * as React from 'react';
-     * import * as ReactDOM from 'react-dom/client';
-     * import { registerSharedModules } from 'sandlot';
-     *
-     * registerSharedModules({
-     *   'react': React,
-     *   'react-dom/client': ReactDOM,
-     * });
-     *
-     * // 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
-     */
-    fs: Filesystem;
-    /**
-     * The just-bash shell environment
-     */
-    bash: Bash;
-    /**
-     * 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
-     * // 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;
-     * ```
-     */
-    lastBuild: BuildOutput | null;
-    /**
-     * Get the current sandbox state for persistence.
-     *
-     * 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 });
-     * ```
-     */
-    getState(): SandboxState;
-    /**
-     * Subscribe to build events. Called whenever a build succeeds.
-     * Returns an unsubscribe function.
-     *
-     * 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 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;
-     * }
-     * ```
-     */
-    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 };
-     * });
-     *
-     * // Now build will fail if App is missing
-     * await sandbox.bash.exec('build /src/index.ts');
-     * ```
-     */
-    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
- * type checking, and bundling capabilities.
- *
- * 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:
- * - `--format, -f <esm|iife|cjs>` - Output format (default: esm)
- * - `--minify, -m` - Enable minification
- * - `--skip-typecheck, -s` - Skip type checking
- *
- * @example
- * ```ts
- * let bundleResult: BundleResult | null = null;
- *
- * const sandbox = await createSandbox({
- *   initialFiles: {
- *     '/src/index.ts': 'export const hello = "world";',
- *     '/tsconfig.json': JSON.stringify({
- *       compilerOptions: { target: 'ES2020', strict: true }
- *     }),
- *   },
- *   onBuild: (result) => {
- *     bundleResult = result;
- *   },
- * });
- *
- * // Use bash commands
- * await sandbox.bash.exec('echo "console.log(1);" > /src/index.ts');
- *
- * // Type check
- * 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 /src/index.ts');
- * console.log(buildResult.stdout);
- * console.log(bundleResult?.code); // The compiled bundle
- *
- * // Save state for later
- * const state = sandbox.getState();
- * localStorage.setItem('my-project', JSON.stringify(state));
- * ```
- */
-export declare function createSandbox(options?: SandboxOptions): Promise<Sandbox>;
-//# sourceMappingURL=sandbox.d.ts.map

package/dist/sandbox.d.ts.map

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

@@ -1,148 +0,0 @@
-/**
- * Shared Module Registry for Sandlot
- *
- * Allows host applications to register their module instances (like React)
- * so that dynamically bundled code can use the same instances instead of
- * loading separate copies from esm.sh CDN.
- *
- * This solves the "multiple React instances" problem where hooks fail
- * because the host and dynamic code use different React copies.
- *
- * @example
- * ```ts
- * // Host application setup
- * import * as React from 'react';
- * import * as ReactDOM from 'react-dom/client';
- * import { registerSharedModules } from 'sandlot';
- *
- * registerSharedModules({
- *   'react': React,
- *   'react-dom/client': ReactDOM,
- * });
- *
- * // Now create sandbox with sharedModules option
- * const sandbox = await createSandbox({
- *   sharedModules: ['react', 'react-dom/client'],
- * });
- * ```
- */
-/**
- * Registry for sharing host modules with dynamic bundles.
- * Modules registered here will be used instead of esm.sh CDN
- * when the sandbox is configured with matching sharedModules.
- */
-export declare class SharedModuleRegistry {
-    private modules;
-    private exportNames;
-    constructor();
-    /**
-     * 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
-     * @returns this for chaining
-     */
-    register(moduleId: string, module: unknown): this;
-    /**
-     * 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
-     */
-    registerAll(modules: Record<string, unknown>): this;
-    /**
-     * Unregister a previously registered module
-     *
-     * @param moduleId - The import specifier to remove
-     * @returns true if the module was registered and removed
-     */
-    unregister(moduleId: string): boolean;
-    /**
-     * Get a registered module (used by dynamic bundles at runtime)
-     *
-     * @param moduleId - The import specifier
-     * @returns The registered module exports
-     * @throws Error if the module is not registered
-     */
-    get(moduleId: string): unknown;
-    /**
-     * Check if a module is registered
-     *
-     * @param moduleId - The import specifier to check
-     */
-    has(moduleId: string): boolean;
-    /**
-     * 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
-     */
-    clear(): void;
-    /**
-     * Get the number of registered modules
-     */
-    get size(): number;
-}
-/**
- * Get the default shared module registry.
- * Creates it if it doesn't exist.
- */
-export declare function getSharedModuleRegistry(): SharedModuleRegistry;
-/**
- * Check if a shared module registry exists on globalThis
- */
-export declare function hasSharedModuleRegistry(): boolean;
-/**
- * Convenience function to register modules with the default registry.
- *
- * @param modules - Object mapping module IDs to their exports
- *
- * @example
- * ```ts
- * import * as React from 'react';
- * import * as ReactDOM from 'react-dom/client';
- * import { registerSharedModules } from 'sandlot';
- *
- * registerSharedModules({
- *   'react': React,
- *   'react-dom/client': ReactDOM,
- * });
- * ```
- */
-export declare function registerSharedModules(modules: Record<string, unknown>): void;
-/**
- * Convenience function to unregister a module from the default registry.
- *
- * @param moduleId - The import specifier to remove
- * @returns true if the module was registered and removed
- */
-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.
- */
-export declare function getSharedModuleRuntimeCode(moduleId: string): string;
-//# sourceMappingURL=shared-modules.d.ts.map

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

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