@scelar/nodepod 1.0.1 → 1.0.2

package/dist/__tests__/smoke.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/constants/cdn-urls.d.ts

@@ -0,0 +1,12 @@
+export declare const PINNED_ESBUILD_WASM = "0.20.0";
+export declare const PINNED_ROLLUP_BROWSER = "4.9.0";
+export declare const PINNED_BROTLI_WASM = "3.0.1";
+export declare const PINNED_LIGHTNINGCSS_WASM = "1.31.1";
+export declare const CDN_ESBUILD_ESM = "https://esm.sh/esbuild-wasm@0.20.0";
+export declare const CDN_ESBUILD_BINARY = "https://esm.sh/esbuild-wasm@0.20.0/esbuild.wasm";
+export declare const CDN_ESBUILD_BROWSER = "https://esm.sh/esbuild-wasm@0.20.0/esm/browser.min.js";
+export declare const CDN_ROLLUP_BROWSER = "https://esm.sh/@rollup/browser@4.9.0";
+export declare const CDN_BROTLI_WASM = "https://esm.sh/brotli-wasm@3.0.1";
+export declare const CDN_LIGHTNINGCSS_WASM = "https://esm.sh/lightningcss-wasm@1.31.1";
+declare const _dynamicImport: (url: string) => Promise<any>;
+export { _dynamicImport as cdnImport };

package/dist/constants/config.d.ts

@@ -0,0 +1,121 @@
+export declare const VERSIONS: {
+    readonly NODE: "v22.12.0";
+    readonly NODE_BARE: "22.12.0";
+    readonly NPM: "10.0.0";
+    readonly PNPM: "9.15.4";
+    readonly YARN: "4.6.0";
+    readonly BUN: "1.1.38";
+    readonly BUN_V: "v1.1.38";
+    readonly GIT: "2.43.0";
+};
+export declare const NODE_SUB_VERSIONS: {
+    readonly node: "22.12.0";
+    readonly v8: "11.3.244.8";
+    readonly uv: "1.44.2";
+    readonly modules: "115";
+    readonly openssl: "3.0.13";
+    readonly napi: "9";
+    readonly webcontainer: "1.0.0";
+};
+export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org";
+export declare const NPM_REGISTRY_URL_SLASH = "https://registry.npmjs.org/";
+export declare const PINNED_PAKO = "2.1.0";
+export declare const CDN_PAKO = "https://esm.sh/pako@2.1.0";
+export declare const RESOLVE_EXTENSIONS: readonly [".js", ".ts", ".jsx", ".tsx", ".mjs", ".cjs", ".json"];
+export declare const MAIN_FIELD_EXTENSIONS: readonly [".js", ".ts", ".tsx", ".mts", ".jsx", ".json", ".mjs", ".cjs"];
+export declare const INDEX_FILES: readonly ["index.js", "index.ts", "index.tsx", "index.mjs", "index.cjs"];
+export declare const IMPORTS_FIELD_EXTENSIONS: readonly [".js", ".ts", ".cjs", ".mjs", ".json"];
+export declare const ESBUILD_LOADER_MAP: Record<string, string>;
+export declare const MOCK_OS: {
+    readonly PLATFORM: "linux";
+    readonly ARCH: "x64";
+    readonly TYPE: "Linux";
+    readonly RELEASE: "5.10.0";
+    readonly VERSION: "#1 SMP";
+    readonly MACHINE: "x86_64";
+    readonly HOSTNAME: "localhost";
+    readonly HOMEDIR: "/home/user";
+    readonly TMPDIR: "/tmp";
+    readonly SHELL: "/bin/bash";
+    readonly USERNAME: "user";
+    readonly ENDIANNESS: "LE";
+};
+export declare const MOCK_IDS: {
+    readonly UID: 1000;
+    readonly GID: 1000;
+};
+export declare const MOCK_FS: {
+    readonly BLOCK_SIZE: 4096;
+    readonly BLOCK_CALC_SIZE: 512;
+};
+export declare const MOCK_CPU: {
+    readonly MODEL: "Virtual CPU";
+    readonly SPEED: 2400;
+    readonly COUNT: 2;
+};
+export declare const MOCK_MEMORY: {
+    readonly TOTAL: number;
+    readonly FREE: number;
+    readonly RSS: number;
+    readonly HEAP_TOTAL: number;
+    readonly HEAP_USED: number;
+    readonly EXTERNAL: number;
+};
+export declare const MOCK_LOADAVG: readonly [number, number, number];
+export declare const DEFAULT_TERMINAL: {
+    readonly COLUMNS: 80;
+    readonly ROWS: 24;
+    readonly FONT_SIZE: 13;
+};
+export declare const MOCK_PROCESS: {
+    readonly PID: 1;
+    readonly PPID: 0;
+    readonly TITLE: "node";
+    readonly EXEC_PATH: "/usr/local/bin/node";
+};
+export declare const DEFAULT_ENV: {
+    readonly NODE_ENV: "development";
+    readonly PATH: "/usr/local/bin:/usr/bin:/bin";
+    readonly HOME: "/";
+    readonly SHELL: "/bin/sh";
+    readonly TERM: "xterm-256color";
+    readonly COLORTERM: "truecolor";
+    readonly REQUIRES_WASM: "true";
+    readonly npm_config_user_agent: "npm/10.0.0 node/v22.12.0 linux x64 workspaces/false";
+    readonly npm_execpath: "/usr/local/lib/node_modules/npm/bin/npm-cli.js";
+    readonly npm_node_execpath: "/usr/local/bin/node";
+};
+export declare const TIMEOUTS: {
+    readonly SYNC_OP: 120000;
+    readonly WAIT_LOOP_TICK: 200;
+    readonly SW_HEARTBEAT: 20000;
+    readonly WORKER_REAP_INTERVAL: 10000;
+    readonly WORKER_IDLE_TIMEOUT: 30000;
+    readonly WORKER_INIT_TIMEOUT: 30000;
+    readonly HTTP_KEEP_ALIVE: 5000;
+    readonly HTTP_HEADERS: 60000;
+    readonly HTTP_DISPATCH_SAFETY: 120000;
+};
+export declare const LIMITS: {
+    readonly MAX_RESOLVE_DEPTH: 50;
+    readonly MODULE_CACHE_MAX: 2000;
+    readonly MAX_WORKERS_CAP: 6;
+};
+export declare const PORT_RANGE: {
+    readonly BASE: 3000;
+    readonly RANGE: 1000;
+};
+export declare const DEFAULT_NODEPOD_CDN = "https://unpkg.com/@scelar/nodepod/dist/index.js";
+export declare const MOCK_PID: {
+    readonly BASE: 1000;
+    readonly RANGE: 10000;
+};
+export declare const LS_BLOCK_SIZE = 512;
+export declare const YES_REPEAT_COUNT = 100;
+export declare const WS_OPCODE: {
+    readonly TEXT: 1;
+    readonly BINARY: 2;
+    readonly CLOSE: 8;
+    readonly PING: 9;
+    readonly PONG: 10;
+};

package/dist/cross-origin.d.ts

@@ -0,0 +1,5 @@
+export declare function setProxy(url: string | null): void;
+export declare function getProxy(): string | null;
+export declare function isProxyActive(): boolean;
+export declare function proxiedFetch(url: string, init?: RequestInit): Promise<Response>;
+export declare function resolveProxyUrl(url: string): string;

package/dist/engine-factory.d.ts

@@ -0,0 +1,24 @@
+import type { MemoryVolume } from './memory-volume';
+import type { IScriptEngine, ExecutionOutcome, SpawnEngineConfig, EngineConfig } from './engine-types';
+import { ProcessManager } from './threading/process-manager';
+export declare function spawnEngine(vol: MemoryVolume, config?: SpawnEngineConfig): Promise<IScriptEngine>;
+declare class ProcessWorkerAdapter implements IScriptEngine {
+    private _vol;
+    private _processManager;
+    private _vfsBridge;
+    private _cfg;
+    constructor(vol: MemoryVolume, cfg?: EngineConfig);
+    execute(code: string, filename?: string): Promise<ExecutionOutcome>;
+    runFile(filename: string): Promise<ExecutionOutcome>;
+    private _runInWorker;
+    clearCache(): void;
+    getVolume(): MemoryVolume;
+    getProcessManager(): ProcessManager;
+    teardown(): void;
+}
+export declare function spawnProcessWorkerEngine(vol: MemoryVolume, config?: EngineConfig): Promise<ProcessWorkerAdapter>;
+export { ScriptEngine } from './script-engine';
+export { WorkerSandbox } from './worker-sandbox';
+export { IframeSandbox } from './iframe-sandbox';
+export { ProcessWorkerAdapter };
+export type { IScriptEngine, ExecutionOutcome, EngineConfig, SpawnEngineConfig, VolumeSnapshot } from './engine-types';

package/dist/engine-types.d.ts

@@ -0,0 +1,40 @@
+import type { MemoryVolume } from './memory-volume';
+export interface EngineConfig {
+    cwd?: string;
+    env?: Record<string, string>;
+    onConsole?: (method: string, args: unknown[]) => void;
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+}
+export interface LoadedModule {
+    id: string;
+    filename: string;
+    exports: unknown;
+    loaded: boolean;
+    children: LoadedModule[];
+    paths: string[];
+}
+export interface ExecutionOutcome {
+    exports: unknown;
+    module: LoadedModule;
+}
+export interface IScriptEngine {
+    execute(code: string, filename?: string): Promise<ExecutionOutcome>;
+    runFile(filename: string): Promise<ExecutionOutcome>;
+    clearCache(): void;
+    getVolume?(): MemoryVolume;
+    terminate?(): void;
+}
+export interface SpawnEngineConfig extends EngineConfig {
+    sandboxUrl?: string;
+    allowUnsafeEval?: boolean;
+    useWorker?: boolean | 'auto';
+}
+export interface VolumeSnapshot {
+    entries: VolumeEntry[];
+}
+export interface VolumeEntry {
+    path: string;
+    kind: 'file' | 'directory';
+    data?: string;
+}

package/dist/helpers/byte-encoding.d.ts

@@ -0,0 +1,4 @@
+export declare function bytesToBase64(data: Uint8Array): string;
+export declare function base64ToBytes(encoded: string): Uint8Array;
+export declare function bytesToHex(data: Uint8Array): string;
+export declare function bytesToLatin1(data: Uint8Array): string;

package/dist/helpers/digest.d.ts

@@ -0,0 +1 @@
+export declare function quickDigest(input: string): string;

package/dist/helpers/event-loop.d.ts

@@ -0,0 +1,12 @@
+import type { ProcessContext } from "../threading/process-context";
+export declare function addDrainListener(cb: () => void): () => void;
+export declare function notifyDrain(): void;
+export declare function ref(): void;
+export declare function unref(): void;
+export declare function getRefCount(): number;
+export declare function setRefCount(n: number): void;
+export declare function resetRefCount(): void;
+export declare function refCtx(ctx: ProcessContext): void;
+export declare function unrefCtx(ctx: ProcessContext): void;
+export declare function getRefCountCtx(ctx: ProcessContext): number;
+export declare function addDrainListenerCtx(ctx: ProcessContext, cb: () => void): () => void;

package/dist/helpers/wasm-cache.d.ts

@@ -0,0 +1,6 @@
+declare const PRECOMPILE_THRESHOLD: number;
+export declare function precompileWasm(bytes: Uint8Array | ArrayBuffer): void;
+export declare function getCachedModule(bytes: BufferSource): WebAssembly.Module | null;
+export declare function compileWasmInWorker(bytes: Uint8Array | ArrayBuffer): Promise<WebAssembly.Module>;
+export declare function needsAsyncCompile(bytes: BufferSource): boolean;
+export { PRECOMPILE_THRESHOLD };

package/dist/iframe-sandbox.d.ts

@@ -0,0 +1,25 @@
+import type { MemoryVolume } from './memory-volume';
+import type { IScriptEngine, ExecutionOutcome, EngineConfig } from './engine-types';
+export declare class IframeSandbox implements IScriptEngine {
+    private frame;
+    private targetOrigin;
+    private vol;
+    private cfg;
+    private ready;
+    private pendingCalls;
+    private nextId;
+    private onFileChange;
+    private onFileDelete;
+    private onMessage;
+    constructor(sandboxUrl: string, vol: MemoryVolume, cfg?: EngineConfig);
+    private bindMessageHandler;
+    private awaitReady;
+    private sendInit;
+    private attachVolumeSync;
+    private dispatch;
+    execute(code: string, filename?: string): Promise<ExecutionOutcome>;
+    runFile(filename: string): Promise<ExecutionOutcome>;
+    clearCache(): void;
+    getVolume(): MemoryVolume;
+    terminate(): void;
+}

package/dist/index.d.ts

@@ -0,0 +1,86 @@
+export { MemoryVolume } from "./memory-volume";
+export type { VolumeNode, FileStat, FileWatchHandle, WatchCallback, WatchEventKind, SystemError, } from "./memory-volume";
+export { ScriptEngine, executeCode } from "./script-engine";
+export type { ModuleRecord, EngineOptions, ResolverFn } from "./script-engine";
+export { spawnEngine, WorkerSandbox, IframeSandbox, spawnProcessWorkerEngine, ProcessWorkerAdapter } from "./engine-factory";
+export type { IScriptEngine, ExecutionOutcome, SpawnEngineConfig, EngineConfig, VolumeSnapshot, } from "./engine-types";
+export { generateSandboxDeployment, getSandboxPageHtml, getSandboxHostingConfig, SANDBOX_DEPLOYMENT_GUIDE, } from "./isolation-helpers";
+export { buildFileSystemBridge } from "./polyfills/fs";
+export type { FsBridge } from "./polyfills/fs";
+export { buildProcessEnv } from "./polyfills/process";
+export type { ProcessObject, ProcessEnvVars } from "./polyfills/process";
+export * as path from "./polyfills/path";
+export * as http from "./polyfills/http";
+export * as net from "./polyfills/net";
+export * as events from "./polyfills/events";
+export * as stream from "./polyfills/stream";
+export * as url from "./polyfills/url";
+export * as querystring from "./polyfills/querystring";
+export * as util from "./polyfills/util";
+export * as npm from "./packages/installer";
+export { DependencyInstaller, install } from "./packages/installer";
+export { RequestProxy, getProxyInstance, resetProxy } from "./request-proxy";
+export type { ProxyOptions, ServiceWorkerConfig } from "./request-proxy";
+export * as chokidar from "./polyfills/chokidar";
+export * as ws from "./polyfills/ws";
+export * as fsevents from "./polyfills/fsevents";
+export * as readdirp from "./polyfills/readdirp";
+export * as module from "./polyfills/module";
+export * as perf_hooks from "./polyfills/perf_hooks";
+export * as worker_threads from "./polyfills/worker_threads";
+export * as esbuild from "./polyfills/esbuild";
+export * as rollup from "./polyfills/rollup";
+export * as assert from "./polyfills/assert";
+import { MemoryVolume } from "./memory-volume";
+import { ScriptEngine, EngineOptions } from "./script-engine";
+import { DependencyInstaller } from "./packages/installer";
+import { RequestProxy } from "./request-proxy";
+export interface CommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export interface CommandOptions {
+    cwd?: string;
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+    signal?: AbortSignal;
+}
+export interface WorkspaceConfig extends EngineOptions {
+    baseUrl?: string;
+    onServerReady?: (port: number, url: string) => void;
+}
+export declare function createWorkspace(config?: WorkspaceConfig): {
+    volume: MemoryVolume;
+    engine: ScriptEngine;
+    packages: DependencyInstaller;
+    proxy: RequestProxy;
+    execute: (code: string, filename?: string) => {
+        exports: unknown;
+    };
+    runFile: (filename: string) => {
+        exports: unknown;
+    };
+    run: (command: string, options?: CommandOptions) => Promise<CommandResult>;
+    sendInput: (data: string) => Promise<void>;
+    createREPL: () => {
+        eval: (code: string) => unknown;
+    };
+    on: (event: string, listener: (...args: unknown[]) => void) => void;
+};
+export default createWorkspace;
+export { Nodepod } from "./sdk/nodepod";
+export { NodepodTerminal } from "./sdk/nodepod-terminal";
+export { NodepodProcess } from "./sdk/nodepod-process";
+export { NodepodFS } from "./sdk/nodepod-fs";
+export type { NodepodOptions, TerminalOptions, TerminalTheme, StatResult, Snapshot, SpawnOptions, } from "./sdk/types";
+export { ProcessManager } from "./threading/process-manager";
+export { ProcessHandle } from "./threading/process-handle";
+export type { ProcessState } from "./threading/process-handle";
+export { VFSBridge } from "./threading/vfs-bridge";
+export { WorkerVFS } from "./threading/worker-vfs";
+export { SyncChannelController, SyncChannelWorker } from "./threading/sync-channel";
+export { SharedVFSController, SharedVFSReader, isSharedArrayBufferAvailable } from "./threading/shared-vfs";
+export { createProcessContext, getActiveContext, setActiveContext } from "./threading/process-context";
+export type { ProcessContext, ProcessWriter, ProcessReader, OpenFileEntry } from "./threading/process-context";
+export type { VFSBinarySnapshot, VFSSnapshotEntry, SpawnConfig, ProcessInfo, MainToWorkerMessage, WorkerToMainMessage, } from "./threading/worker-protocol";

package/dist/isolation-helpers.d.ts

@@ -0,0 +1,13 @@
+export interface SandboxPageConfig {
+    nodepodUrl?: string;
+    enableServiceWorker?: boolean;
+}
+export declare function getSandboxPageHtml(config?: SandboxPageConfig | string): string;
+export declare function getSandboxHostingConfig(): object;
+export interface GeneratedSandboxFiles {
+    'index.html': string;
+    'vercel.json': string;
+    '__sw__.js'?: string;
+}
+export declare function generateSandboxDeployment(config?: SandboxPageConfig | string): GeneratedSandboxFiles;
+export declare const SANDBOX_DEPLOYMENT_GUIDE: string;

package/dist/memory-volume.d.ts

@@ -0,0 +1,147 @@
+import type { VolumeSnapshot } from './engine-types';
+export interface VolumeNode {
+    kind: 'file' | 'directory' | 'symlink';
+    content?: Uint8Array;
+    children?: Map<string, VolumeNode>;
+    target?: string;
+    modified: number;
+}
+type FileChangeHandler = (filePath: string, content: string) => void;
+type FileDeleteHandler = (filePath: string) => void;
+export interface FileStat {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+    size: number;
+    mode: number;
+    mtime: Date;
+    atime: Date;
+    ctime: Date;
+    birthtime: Date;
+    mtimeMs: number;
+    atimeMs: number;
+    ctimeMs: number;
+    birthtimeMs: number;
+    nlink: number;
+    uid: number;
+    gid: number;
+    dev: number;
+    ino: number;
+    rdev: number;
+    blksize: number;
+    blocks: number;
+    atimeNs: bigint;
+    mtimeNs: bigint;
+    ctimeNs: bigint;
+    birthtimeNs: bigint;
+}
+export type WatchEventKind = 'change' | 'rename';
+export type WatchCallback = (event: WatchEventKind, name: string | null) => void;
+export interface FileWatchHandle {
+    close(): void;
+    ref(): this;
+    unref(): this;
+    on(event: string, listener: (...args: unknown[]) => void): this;
+    once(event: string, listener: (...args: unknown[]) => void): this;
+    removeListener(event: string, listener: (...args: unknown[]) => void): this;
+    off(event: string, listener: (...args: unknown[]) => void): this;
+    addListener(event: string, listener: (...args: unknown[]) => void): this;
+    removeAllListeners(event?: string): this;
+    emit(event: string, ...args: unknown[]): boolean;
+}
+export interface SystemError extends Error {
+    code: string;
+    errno: number;
+    syscall: string;
+    path?: string;
+}
+export declare function makeSystemError(code: 'ENOENT' | 'ENOTDIR' | 'EISDIR' | 'EEXIST' | 'ENOTEMPTY', syscall: string, targetPath: string, detail?: string): SystemError;
+export declare class MemoryVolume {
+    private tree;
+    private textEncoder;
+    private textDecoder;
+    private activeWatchers;
+    private subscribers;
+    constructor();
+    on(event: 'change', handler: FileChangeHandler): this;
+    on(event: 'delete', handler: FileDeleteHandler): this;
+    off(event: 'change', handler: FileChangeHandler): this;
+    off(event: 'delete', handler: FileDeleteHandler): this;
+    private broadcast;
+    toSnapshot(): VolumeSnapshot;
+    private collectEntries;
+    static fromBinarySnapshot(snapshot: {
+        manifest: Array<{
+            path: string;
+            offset: number;
+            length: number;
+            isDirectory: boolean;
+        }>;
+        data: ArrayBuffer;
+    }): MemoryVolume;
+    static fromSnapshot(snapshot: VolumeSnapshot): MemoryVolume;
+    private normalize;
+    private segments;
+    private parentOf;
+    private nameOf;
+    private locateRaw;
+    private locate;
+    private ensureDir;
+    private writeInternal;
+    existsSync(p: string): boolean;
+    statSync(p: string): FileStat;
+    lstatSync(p: string): FileStat;
+    readFileSync(p: string): Uint8Array;
+    readFileSync(p: string, encoding: 'utf8' | 'utf-8'): string;
+    writeFileSync(p: string, data: string | Uint8Array): void;
+    mkdirSync(p: string, options?: {
+        recursive?: boolean;
+    }): void;
+    readdirSync(p: string): string[];
+    unlinkSync(p: string): void;
+    rmdirSync(p: string): void;
+    renameSync(from: string, to: string): void;
+    accessSync(p: string, _mode?: number): void;
+    copyFileSync(src: string, dest: string): void;
+    realpathSync(p: string): string;
+    symlinkSync(target: string, linkPath: string, _type?: string): void;
+    readlinkSync(p: string): string;
+    linkSync(existingPath: string, newPath: string): void;
+    chmodSync(_p: string, _mode: number): void;
+    chownSync(_p: string, _uid: number, _gid: number): void;
+    appendFileSync(p: string, data: string | Uint8Array): void;
+    truncateSync(p: string, len?: number): void;
+    readFile(p: string, optionsOrCb?: {
+        encoding?: string;
+    } | ((err: Error | null, data?: Uint8Array | string) => void), cb?: (err: Error | null, data?: Uint8Array | string) => void): void;
+    stat(p: string, cb?: (err: Error | null, stats?: FileStat) => void): void;
+    lstat(p: string, cb?: (err: Error | null, stats?: FileStat) => void): void;
+    readdir(p: string, optionsOrCb?: {
+        withFileTypes?: boolean;
+    } | ((err: Error | null, files?: string[]) => void), cb?: (err: Error | null, files?: string[]) => void): void;
+    realpath(p: string, cb?: (err: Error | null, resolved?: string) => void): void;
+    access(p: string, modeOrCb?: number | ((err: Error | null) => void), cb?: (err: Error | null) => void): void;
+    watch(target: string, optionsOrCb?: {
+        persistent?: boolean;
+        recursive?: boolean;
+        encoding?: string;
+    } | WatchCallback, cb?: WatchCallback): FileWatchHandle;
+    private triggerWatchers;
+    private globalChangeListeners;
+    onGlobalChange(cb: (path: string, event: string) => void): () => void;
+    private notifyGlobalListeners;
+    createReadStream(p: string): {
+        on: (event: string, cb: (...args: unknown[]) => void) => void;
+        pipe: (dest: unknown) => unknown;
+    };
+    createWriteStream(p: string): {
+        write: (data: string | Uint8Array) => boolean;
+        end: (data?: string | Uint8Array) => void;
+        on: (event: string, cb: (...args: unknown[]) => void) => void;
+    };
+}
+export {};

package/dist/module-transformer.d.ts

@@ -0,0 +1,6 @@
+import type { MemoryVolume } from "./memory-volume";
+export declare function prepareTransformer(): Promise<void>;
+export declare function isTransformerLoaded(): boolean;
+export declare function convertFile(source: string, filePath: string): Promise<string>;
+export declare function convertFileDirect(source: string, filePath: string): Promise<string>;
+export declare function convertPackage(vol: MemoryVolume, packageDir: string, onProgress?: (msg: string) => void): Promise<number>;

package/dist/packages/archive-extractor.d.ts

@@ -0,0 +1,28 @@
+import { MemoryVolume } from "../memory-volume";
+export interface ExtractionOptions {
+    stripComponents?: number;
+    filter?: (entryPath: string) => boolean;
+    onProgress?: (msg: string) => void;
+}
+type EntryKind = "file" | "directory" | "link" | "other";
+interface ArchiveEntry {
+    filepath: string;
+    kind: EntryKind;
+    byteSize: number;
+    fileMode: number;
+    payload?: Uint8Array;
+    linkDestination?: string;
+}
+export declare function parseTarArchive(raw: Uint8Array): Generator<ArchiveEntry>;
+export declare function inflateGzip(compressed: ArrayBuffer | Uint8Array): Uint8Array;
+export declare function extractArchive(archiveBytes: ArrayBuffer | Uint8Array, vol: MemoryVolume, destDir: string, opts?: ExtractionOptions): string[];
+export declare function downloadAndExtract(url: string, vol: MemoryVolume, destDir: string, opts?: ExtractionOptions): Promise<string[]>;
+export declare function downloadAndExtractDirect(url: string, vol: MemoryVolume, destDir: string, opts?: ExtractionOptions): Promise<string[]>;
+declare const _default: {
+    downloadAndExtract: typeof downloadAndExtract;
+    downloadAndExtractDirect: typeof downloadAndExtractDirect;
+    parseTarArchive: typeof parseTarArchive;
+    extractArchive: typeof extractArchive;
+    inflateGzip: typeof inflateGzip;
+};
+export default _default;

package/dist/packages/browser-bundler.d.ts

@@ -0,0 +1,14 @@
+import type { MemoryVolume } from "../memory-volume";
+export declare function invalidateBundleCache(): void;
+export declare function attachVolume(vol: MemoryVolume): void;
+export declare function setExternalPackages(packages: string[]): void;
+export declare function bundleForBrowser(specifier: string): Promise<string>;
+export declare class BrowserBundler {
+    private vol;
+    constructor(vol: MemoryVolume, options?: {
+        external?: string[];
+    });
+    bundle(specifier: string): Promise<string>;
+    clearCache(): void;
+}
+export default BrowserBundler;

package/dist/packages/installer.d.ts

@@ -0,0 +1,41 @@
+import { MemoryVolume } from "../memory-volume";
+import { RegistryConfig } from "./registry-client";
+import { ResolvedDependency } from "./version-resolver";
+export interface InstallFlags {
+    registry?: string;
+    persist?: boolean;
+    persistDev?: boolean;
+    withDevDeps?: boolean;
+    withOptionalDeps?: boolean;
+    onProgress?: (message: string) => void;
+    transformModules?: boolean;
+}
+export interface InstallOutcome {
+    resolved: Map<string, ResolvedDependency>;
+    newPackages: string[];
+}
+declare function splitSpecifier(spec: string): {
+    name: string;
+    version?: string;
+};
+export declare class DependencyInstaller {
+    private vol;
+    private registryClient;
+    private workingDir;
+    constructor(vol: MemoryVolume, opts?: {
+        cwd?: string;
+    } & RegistryConfig);
+    install(packageName: string, version?: string, flags?: InstallFlags): Promise<InstallOutcome>;
+    installFromManifest(manifestPath?: string, flags?: InstallFlags): Promise<InstallOutcome>;
+    listInstalled(): Record<string, string>;
+    private materializePackages;
+    private createBinStubs;
+    private writeLockFile;
+    private patchManifest;
+}
+export declare function install(specifier: string, vol: MemoryVolume, flags?: InstallFlags): Promise<InstallOutcome>;
+export { RegistryClient } from "./registry-client";
+export type { RegistryConfig, VersionDetail, PackageMetadata, } from "./registry-client";
+export type { ResolvedDependency, ResolutionConfig } from "./version-resolver";
+export type { ExtractionOptions } from "./archive-extractor";
+export { splitSpecifier };

package/dist/packages/registry-client.d.ts

@@ -0,0 +1,46 @@
+export interface VersionDetail {
+    name: string;
+    version: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    peerDependenciesMeta?: Record<string, {
+        optional?: boolean;
+    }>;
+    optionalDependencies?: Record<string, string>;
+    dist: {
+        tarball: string;
+        shasum: string;
+        integrity?: string;
+    };
+    main?: string;
+    module?: string;
+    exports?: Record<string, unknown>;
+    bin?: Record<string, string> | string;
+}
+export interface PackageMetadata {
+    name: string;
+    'dist-tags': {
+        latest: string;
+        [label: string]: string;
+    };
+    versions: Record<string, VersionDetail>;
+    time?: Record<string, string>;
+}
+export interface RegistryConfig {
+    endpoint?: string;
+    metadataCache?: Map<string, PackageMetadata>;
+}
+export declare class RegistryClient {
+    private baseUrl;
+    private metadataStore;
+    constructor(config?: RegistryConfig);
+    fetchManifest(name: string): Promise<PackageMetadata>;
+    fetchVersion(name: string, version: string): Promise<VersionDetail>;
+    getLatestVersion(name: string): Promise<string>;
+    listVersions(name: string): Promise<string[]>;
+    getTarballUrl(name: string, version: string): Promise<string>;
+    downloadArchive(tarballUrl: string): Promise<ArrayBuffer>;
+    flushCache(): void;
+}
+export default RegistryClient;