@scelar/nodepod 1.0.1 → 1.0.2

package/dist/request-proxy.d.ts

@@ -0,0 +1,63 @@
+import type { CompletedResponse } from "./polyfills/http";
+import { Server } from "./polyfills/http";
+import { EventEmitter } from "./polyfills/events";
+export interface IVirtualServer {
+    listening: boolean;
+    address(): {
+        port: number;
+        address: string;
+        family: string;
+    } | null;
+    dispatchRequest(method: string, url: string, headers: Record<string, string>, body?: Buffer | string): Promise<CompletedResponse>;
+}
+export interface RegisteredServer {
+    server: Server | IVirtualServer;
+    port: number;
+    hostname: string;
+}
+export interface ProxyOptions {
+    baseUrl?: string;
+    onServerReady?: (port: number, url: string) => void;
+}
+export interface ServiceWorkerConfig {
+    swUrl?: string;
+}
+export { CompletedResponse };
+export declare class RequestProxy extends EventEmitter {
+    static DEBUG: boolean;
+    private registry;
+    private baseUrl;
+    private opts;
+    private channel;
+    private swReady;
+    private heartbeat;
+    private _processManager;
+    private _workerWsConns;
+    private _previewScript;
+    constructor(opts?: ProxyOptions);
+    setProcessManager(pm: any): void;
+    register(server: Server | IVirtualServer, port: number, hostname?: string): void;
+    unregister(port: number): void;
+    setPreviewScript(script: string | null): void;
+    setWatermark(enabled: boolean): void;
+    private _sendPreviewScriptToSW;
+    serverUrl(port: number): string;
+    activePorts(): number[];
+    handleRequest(port: number, method: string, url: string, headers: Record<string, string>, body?: ArrayBuffer): Promise<CompletedResponse>;
+    initServiceWorker(config?: ServiceWorkerConfig): Promise<void>;
+    private _normalizeSwUrl;
+    private onSWMessage;
+    private handleStreaming;
+    private _wsBridge;
+    private _wsConns;
+    private _startWsBridge;
+    private _handleWsConnect;
+    private _handleWorkerWsFrame;
+    private _handleWsSend;
+    private _handleWsClose;
+    private notifySW;
+    createFetchHandler(): (req: Request) => Promise<Response>;
+}
+export declare function getProxyInstance(opts?: ProxyOptions): RequestProxy;
+export declare function resetProxy(): void;
+export default RequestProxy;

package/dist/script-engine.d.ts

@@ -0,0 +1,79 @@
+import { MemoryVolume } from "./memory-volume";
+import type { ExecutionOutcome } from "./engine-types";
+import { ProcessObject } from "./polyfills/process";
+export declare function setChildProcessPolyfill(mod: any): void;
+export interface ModuleRecord {
+    id: string;
+    filename: string;
+    exports: unknown;
+    loaded: boolean;
+    children: ModuleRecord[];
+    paths: string[];
+}
+export interface EngineOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    onConsole?: (method: string, args: unknown[]) => void;
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+    workerThreadsOverride?: {
+        isMainThread: boolean;
+        parentPort: unknown;
+        workerData: unknown;
+        threadId: number;
+    };
+}
+export interface ResolverFn {
+    (id: string): unknown;
+    resolve: (id: string, options?: {
+        paths?: string[];
+    }) => string;
+    cache: Record<string, ModuleRecord>;
+    extensions: Record<string, unknown>;
+    main: ModuleRecord | null;
+}
+export declare class ScriptEngine {
+    private vol;
+    private fsBridge;
+    private proc;
+    private moduleRegistry;
+    private opts;
+    private transformCache;
+    constructor(vol: MemoryVolume, opts?: EngineOptions);
+    private patchTextDecoder;
+    private patchStackTraceApi;
+    execute(code: string, filename?: string): {
+        exports: unknown;
+        module: ModuleRecord;
+    };
+    executeSync: (code: string, filename?: string) => {
+        exports: unknown;
+        module: ModuleRecord;
+    };
+    executeAsync(code: string, filename?: string): Promise<ExecutionOutcome>;
+    runFile(filename: string): {
+        exports: unknown;
+        module: ModuleRecord;
+    };
+    runFileSync: (filename: string) => {
+        exports: unknown;
+        module: ModuleRecord;
+    };
+    runFileTLA(filename: string): Promise<{
+        exports: unknown;
+        module: ModuleRecord;
+    }>;
+    runFileAsync(filename: string): Promise<ExecutionOutcome>;
+    clearCache(): void;
+    getVolume(): MemoryVolume;
+    getProcess(): ProcessObject;
+    createREPL(): {
+        eval: (code: string) => unknown;
+    };
+}
+export declare function executeCode(code: string, vol: MemoryVolume, opts?: EngineOptions): {
+    exports: unknown;
+    module: ModuleRecord;
+};
+export type { IScriptEngine, ExecutionOutcome, EngineConfig, } from "./engine-types";
+export default ScriptEngine;

package/dist/sdk/nodepod-fs.d.ts

@@ -0,0 +1,27 @@
+import type { MemoryVolume } from "../memory-volume";
+import type { StatResult } from "./types";
+export declare class NodepodFS {
+    private _vol;
+    constructor(_vol: MemoryVolume);
+    writeFile(path: string, data: string | Uint8Array): Promise<void>;
+    readFile(path: string, encoding?: "utf-8" | "utf8"): Promise<string>;
+    readFile(path: string): Promise<Uint8Array>;
+    mkdir(path: string, opts?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    readdir(path: string): Promise<string[]>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<StatResult>;
+    unlink(path: string): Promise<void>;
+    rmdir(path: string, opts?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    watch(path: string, optionsOrCb?: {
+        recursive?: boolean;
+    } | ((event: string, filename: string | null) => void), cb?: (event: string, filename: string | null) => void): {
+        close(): void;
+    };
+    get volume(): MemoryVolume;
+    private _removeRecursive;
+}

package/dist/sdk/nodepod-process.d.ts

@@ -0,0 +1,28 @@
+import { EventEmitter } from "../polyfills/events";
+export declare class NodepodProcess extends EventEmitter {
+    private _abortController;
+    private _resolve;
+    private _stdout;
+    private _stderr;
+    private _exitCode;
+    private _sendStdinFn;
+    private _killFn;
+    readonly completion: Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
+    constructor();
+    _setSendStdin(fn: (data: string) => void): void;
+    _setKillFn(fn: () => void): void;
+    _pushStdout(chunk: string): void;
+    _pushStderr(chunk: string): void;
+    _finish(exitCode: number): void;
+    get signal(): AbortSignal;
+    get exited(): boolean;
+    write(data: string): void;
+    kill(): void;
+    on(event: "output", handler: (chunk: string) => void): this;
+    on(event: "error", handler: (chunk: string) => void): this;
+    on(event: "exit", handler: (code: number) => void): this;
+}

package/dist/sdk/nodepod-terminal.d.ts

@@ -0,0 +1,48 @@
+import type { TerminalOptions, TerminalTheme } from "./types";
+export interface TerminalWiring {
+    onCommand: (cmd: string) => Promise<void>;
+    getSendStdin: () => ((data: string) => void) | null;
+    getIsStdinRaw: () => boolean;
+    getActiveAbort: () => AbortController | null;
+    setActiveAbort: (ac: AbortController | null) => void;
+}
+export declare class NodepodTerminal {
+    private _term;
+    private _fitAddon;
+    private _dataDisposable;
+    private _resizeHandler;
+    private _lineBuffer;
+    private _history;
+    private _historyIndex;
+    private _savedLine;
+    private _running;
+    private _cwd;
+    private _promptFn;
+    private _theme;
+    private _opts;
+    private _wiring;
+    constructor(opts: TerminalOptions);
+    _wireExecution(wiring: TerminalWiring): void;
+    _setRunning(running: boolean): void;
+    _writePrompt(): void;
+    _getCols(): number;
+    _getRows(): number;
+    _writeOutput(text: string, isError?: boolean): void;
+    attach(target: HTMLElement | string): void;
+    detach(): void;
+    clear(): void;
+    input(text: string): void;
+    setTheme(theme: Partial<TerminalTheme>): void;
+    fit(): void;
+    write(text: string): void;
+    writeln(text: string): void;
+    showPrompt(): void;
+    setCwd(cwd: string): void;
+    getCwd(): string;
+    get xterm(): any;
+    private _handleInput;
+    private _historyUp;
+    private _historyDown;
+    private _replaceLineWith;
+    private _executeCommand;
+}

package/dist/sdk/nodepod.d.ts

@@ -0,0 +1,39 @@
+import { MemoryVolume } from "../memory-volume";
+import { ScriptEngine } from "../script-engine";
+import { DependencyInstaller } from "../packages/installer";
+import { RequestProxy } from "../request-proxy";
+import type { NodepodOptions, TerminalOptions, Snapshot, SpawnOptions } from "./types";
+import { NodepodFS } from "./nodepod-fs";
+import { NodepodProcess } from "./nodepod-process";
+import { NodepodTerminal } from "./nodepod-terminal";
+import { ProcessManager } from "../threading/process-manager";
+export declare class Nodepod {
+    readonly fs: NodepodFS;
+    private _volume;
+    private _engine;
+    private _packages;
+    private _proxy;
+    private _cwd;
+    private _processManager;
+    private _vfsBridge;
+    private _sharedVFS;
+    private _syncChannel;
+    private _unwatchVFS;
+    private constructor();
+    static boot(opts?: NodepodOptions): Promise<Nodepod>;
+    spawn(cmd: string, args?: string[], opts?: SpawnOptions): Promise<NodepodProcess>;
+    private _resolveCommand;
+    createTerminal(opts: TerminalOptions): NodepodTerminal;
+    setPreviewScript(script: string): Promise<void>;
+    clearPreviewScript(): Promise<void>;
+    port(num: number): string | null;
+    snapshot(): Snapshot;
+    restore(snapshot: Snapshot): void;
+    teardown(): void;
+    get volume(): MemoryVolume;
+    get engine(): ScriptEngine;
+    get packages(): DependencyInstaller;
+    get proxy(): RequestProxy;
+    get processManager(): ProcessManager;
+    get cwd(): string;
+}

package/dist/sdk/types.d.ts

@@ -0,0 +1,53 @@
+import type { VolumeSnapshot } from "../engine-types";
+export interface NodepodOptions {
+    files?: Record<string, string | Uint8Array>;
+    env?: Record<string, string>;
+    workdir?: string;
+    swUrl?: string;
+    onServerReady?: (port: number, url: string) => void;
+    /** Show a small "nodepod" watermark link in preview iframes. Defaults to true. */
+    watermark?: boolean;
+}
+export interface TerminalTheme {
+    background?: string;
+    foreground?: string;
+    cursor?: string;
+    selectionBackground?: string;
+    black?: string;
+    red?: string;
+    green?: string;
+    yellow?: string;
+    blue?: string;
+    magenta?: string;
+    cyan?: string;
+    white?: string;
+    brightBlack?: string;
+    brightRed?: string;
+    brightGreen?: string;
+    brightYellow?: string;
+    brightBlue?: string;
+    brightMagenta?: string;
+    brightCyan?: string;
+    brightWhite?: string;
+}
+export interface TerminalOptions {
+    Terminal: any;
+    FitAddon?: any;
+    WebglAddon?: any;
+    theme?: TerminalTheme;
+    fontSize?: number;
+    fontFamily?: string;
+    prompt?: (cwd: string) => string;
+}
+export interface StatResult {
+    isFile: boolean;
+    isDirectory: boolean;
+    size: number;
+    mtime: number;
+}
+export type Snapshot = VolumeSnapshot;
+export interface SpawnOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    signal?: AbortSignal;
+}

package/dist/shell/commands/bun.d.ts

@@ -0,0 +1,4 @@
+import type { ShellCommand } from "../shell-types";
+import type { PmDeps } from "./pm-types";
+export declare function createBunCommand(deps: PmDeps): ShellCommand;
+export declare function createBunxCommand(deps: PmDeps): ShellCommand;

package/dist/shell/commands/directory.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinFn } from "../shell-types";
+export declare const directoryCommands: [string, BuiltinFn][];

package/dist/shell/commands/file-ops.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinFn } from "../shell-types";
+export declare const fileOpsCommands: [string, BuiltinFn][];

package/dist/shell/commands/git.d.ts

@@ -0,0 +1,2 @@
+import type { ShellCommand } from "../shell-types";
+export declare function createGitCommand(): ShellCommand;

package/dist/shell/commands/node.d.ts

@@ -0,0 +1,4 @@
+import type { ShellCommand } from "../shell-types";
+import type { PmDeps } from "./pm-types";
+export declare function createNodeCommand(deps: PmDeps): ShellCommand;
+export declare function createNpxCommand(deps: PmDeps): ShellCommand;

package/dist/shell/commands/npm.d.ts

@@ -0,0 +1,3 @@
+import type { ShellCommand } from "../shell-types";
+import type { PmDeps } from "./pm-types";
+export declare function createNpmCommand(deps: PmDeps): ShellCommand;

package/dist/shell/commands/pm-types.d.ts

@@ -0,0 +1,25 @@
+import type { ShellResult, ShellContext } from "../shell-types";
+export type PkgManager = "npm" | "pnpm" | "yarn" | "bun";
+export interface PmDeps {
+    installPackages: (args: string[], ctx: ShellContext, pm?: PkgManager) => Promise<ShellResult>;
+    uninstallPackages: (args: string[], ctx: ShellContext, pm?: PkgManager) => Promise<ShellResult>;
+    listPackages: (ctx: ShellContext, pm?: PkgManager) => Promise<ShellResult>;
+    runScript: (args: string[], ctx: ShellContext) => Promise<ShellResult>;
+    npmInitOrCreate: (args: string[], sub: string, ctx: ShellContext) => Promise<ShellResult>;
+    npmInfo: (args: string[], ctx: ShellContext) => Promise<ShellResult>;
+    npmPack: (ctx: ShellContext) => ShellResult;
+    npmConfig: (args: string[], ctx: ShellContext) => ShellResult;
+    npxExecute: (params: string[], ctx: ShellContext) => Promise<ShellResult>;
+    executeNodeBinary: (filePath: string, args: string[], ctx: ShellContext, opts?: {
+        isFork?: boolean;
+    }) => Promise<ShellResult>;
+    evalCode: (code: string, ctx: ShellContext) => ShellResult;
+    printCode: (code: string, ctx: ShellContext) => ShellResult;
+    removeNodeModules: (cwd: string) => void;
+    formatErr: (msg: string, pm: PkgManager) => string;
+    formatWarn: (msg: string, pm: PkgManager) => string;
+    hasFile: (path: string) => boolean;
+    readFile: (path: string) => string;
+    writeFile: (path: string, data: string) => void;
+    npmPkg?: (args: string[], ctx: ShellContext) => ShellResult;
+}

package/dist/shell/commands/pnpm.d.ts

@@ -0,0 +1,3 @@
+import type { ShellCommand } from "../shell-types";
+import type { PmDeps } from "./pm-types";
+export declare function createPnpmCommand(deps: PmDeps): ShellCommand;

package/dist/shell/commands/search.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinFn } from "../shell-types";
+export declare const searchCommands: [string, BuiltinFn][];

package/dist/shell/commands/shell-env.d.ts

@@ -0,0 +1,3 @@
+import type { BuiltinFn } from "../shell-types";
+export declare function setBuiltinsRef(b: Map<string, BuiltinFn>): void;
+export declare const shellEnvCommands: [string, BuiltinFn][];

package/dist/shell/commands/text-processing.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinFn } from "../shell-types";
+export declare const textProcessingCommands: [string, BuiltinFn][];

package/dist/shell/commands/yarn.d.ts

@@ -0,0 +1,3 @@
+import type { ShellCommand } from "../shell-types";
+import type { PmDeps } from "./pm-types";
+export declare function createYarnCommand(deps: PmDeps): ShellCommand;

package/dist/shell/shell-builtins.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinFn } from "./shell-types";
+export declare const builtins: Map<string, BuiltinFn>;

package/dist/shell/shell-helpers.d.ts

@@ -0,0 +1,28 @@
+import type { ShellResult } from "./shell-types";
+import * as pathModule from "../polyfills/path";
+export declare const RESET = "\u001B[0m";
+export declare const DIM = "\u001B[2m";
+export declare const GREEN = "\u001B[32m";
+export declare const MAGENTA = "\u001B[35m";
+export declare const CYAN = "\u001B[36m";
+export declare const BOLD_BLUE = "\u001B[1;34m";
+export declare const BOLD_RED = "\u001B[1;31m";
+export declare const ok: (stdout?: string) => ShellResult;
+export declare const fail: (stderr: string, code?: number) => ShellResult;
+export declare const EXIT_OK: ShellResult;
+export declare const EXIT_FAIL: ShellResult;
+export declare const MONTHS_SHORT: readonly ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+export declare const MONTHS_LONG: readonly ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+export declare const DAYS_SHORT: readonly ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+export declare const DAYS_LONG: readonly ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+export declare function resolvePath(p: string, cwd: string): string;
+export { pathModule };
+export declare function parseArgs(args: string[], knownFlags: string[], knownOpts?: string[]): {
+    flags: Set<string>;
+    opts: Record<string, string>;
+    positional: string[];
+};
+export declare function expandCharClass(s: string): string;
+export declare function processEscapes(s: string): string;
+export declare function humanSize(bytes: number): string;
+export declare function globToRegex(pattern: string): string;

package/dist/shell/shell-interpreter.d.ts

@@ -0,0 +1,48 @@
+import type { ShellResult, ShellCommand } from "./shell-types";
+import type { MemoryVolume } from "../memory-volume";
+export type SpawnChildCallback = (command: string, args: string[], opts?: {
+    cwd?: string;
+    env?: Record<string, string>;
+    stdio?: "pipe" | "inherit";
+}) => Promise<{
+    pid: number;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}>;
+export declare class NodepodShell {
+    private volume;
+    private cwd;
+    private env;
+    private commands;
+    private lastExit;
+    private aliases;
+    private _execQueue;
+    private _spawnChild;
+    constructor(volume: MemoryVolume, opts?: {
+        cwd?: string;
+        env?: Record<string, string>;
+    });
+    registerCommand(cmd: ShellCommand): void;
+    setSpawnChildCallback(cb: SpawnChildCallback | null): void;
+    getSpawnChildCallback(): SpawnChildCallback | null;
+    getCwd(): string;
+    setCwd(cwd: string): void;
+    getEnv(): Record<string, string>;
+    exec(command: string, opts?: {
+        cwd?: string;
+        env?: Record<string, string>;
+    }): Promise<ShellResult>;
+    private _execInner;
+    private execList;
+    private execPipeline;
+    private execCommand;
+    private buildContext;
+    private resolvePath;
+    private resolveFromPath;
+    private normalizePath;
+    private applyRedirects;
+    private expandCommandSubstitution;
+    private handleAlias;
+    private handleSource;
+}

package/dist/shell/shell-parser.d.ts

@@ -0,0 +1,6 @@
+import type { Token, ListNode } from "./shell-types";
+import type { MemoryVolume } from "../memory-volume";
+export declare function expandVariables(raw: string, env: Record<string, string>, lastExit: number): string;
+export declare function expandGlob(pattern: string, cwd: string, volume: MemoryVolume): string[];
+export declare function tokenize(input: string, env: Record<string, string>, lastExit: number): Token[];
+export declare function parse(input: string, env: Record<string, string>, lastExit?: number): ListNode;

package/dist/shell/shell-types.d.ts

@@ -0,0 +1,48 @@
+import type { MemoryVolume } from "../memory-volume";
+export interface ShellResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export interface ShellContext {
+    cwd: string;
+    env: Record<string, string>;
+    volume: MemoryVolume;
+    exec: (cmd: string, opts?: {
+        cwd?: string;
+        env?: Record<string, string>;
+    }) => Promise<ShellResult>;
+}
+export interface ShellCommand {
+    name: string;
+    execute(args: string[], ctx: ShellContext): Promise<ShellResult>;
+}
+export interface RedirectNode {
+    type: "write" | "append" | "read" | "stderr-to-stdout";
+    target: string;
+}
+export interface CommandNode {
+    kind: "command";
+    args: string[];
+    redirects: RedirectNode[];
+    assignments: Record<string, string>;
+}
+export interface PipelineNode {
+    kind: "pipeline";
+    commands: CommandNode[];
+}
+export type ListOperator = "&&" | "||" | ";";
+export interface ListEntry {
+    pipeline: PipelineNode;
+    next?: ListOperator;
+}
+export interface ListNode {
+    kind: "list";
+    entries: ListEntry[];
+}
+export type TokenType = "word" | "pipe" | "and" | "or" | "semi" | "redirect-out" | "redirect-app" | "redirect-in" | "redirect-2to1" | "newline" | "eof";
+export interface Token {
+    type: TokenType;
+    value: string;
+}
+export type BuiltinFn = (args: string[], ctx: ShellContext, stdin?: string) => Promise<ShellResult> | ShellResult;

package/dist/syntax-transforms.d.ts

@@ -0,0 +1,3 @@
+export declare function esmToCjs(code: string): string;
+export declare function hasTopLevelAwait(code: string): boolean;
+export declare function stripTopLevelAwait(code: string, mode?: "topLevelOnly" | "full"): string;

package/dist/threading/engine-worker.d.ts

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

package/dist/threading/inline-worker.d.ts

@@ -0,0 +1,2 @@
+export declare function createInlineWorker(): Worker | null;
+export declare function revokeInlineWorkerUrl(): void;

package/dist/threading/offload-types.d.ts

@@ -0,0 +1,87 @@
+export declare enum TaskPriority {
+    HIGH = 0,// runtime transforms (user waiting)
+    NORMAL = 1,// install-time bulk transforms
+    LOW = 2
+}
+export interface TransformTask {
+    type: "transform";
+    id: string;
+    source: string;
+    filePath: string;
+    options?: {
+        loader?: "js" | "jsx" | "ts" | "tsx";
+        format?: "cjs" | "esm";
+        target?: string;
+        platform?: string;
+        define?: Record<string, string>;
+    };
+    priority: TaskPriority;
+}
+export interface TransformResult {
+    type: "transform";
+    id: string;
+    code: string;
+    warnings: string[];
+}
+export interface ExtractTask {
+    type: "extract";
+    id: string;
+    tarballUrl: string;
+    stripComponents: number;
+    priority: TaskPriority;
+}
+export interface ExtractedFile {
+    path: string;
+    data: string;
+    isBinary: boolean;
+}
+export interface ExtractResult {
+    type: "extract";
+    id: string;
+    files: ExtractedFile[];
+}
+export interface BuildTask {
+    type: "build";
+    id: string;
+    files: Record<string, string>;
+    entryPoints?: string[];
+    stdin?: {
+        contents: string;
+        resolveDir?: string;
+        loader?: string;
+    };
+    bundle?: boolean;
+    format?: "iife" | "cjs" | "esm";
+    platform?: "browser" | "node" | "neutral";
+    target?: string | string[];
+    minify?: boolean;
+    external?: string[];
+    absWorkingDir?: string;
+    priority: TaskPriority;
+}
+export interface BuildOutputFile {
+    path: string;
+    text: string;
+}
+export interface BuildResult {
+    type: "build";
+    id: string;
+    outputFiles: BuildOutputFile[];
+    errors: string[];
+    warnings: string[];
+}
+export type OffloadTask = TransformTask | ExtractTask | BuildTask;
+export type OffloadResult = TransformResult | ExtractResult | BuildResult;
+export interface OffloadWorkerEndpoint {
+    init(): Promise<void>;
+    transform(task: TransformTask): Promise<TransformResult>;
+    extract(task: ExtractTask): Promise<ExtractResult>;
+    build(task: BuildTask): Promise<BuildResult>;
+    ping(): boolean;
+}
+export interface PoolConfig {
+    minWorkers?: number;
+    maxWorkers?: number;
+    idleTimeoutMs?: number;
+    warmUpOnCreate?: boolean;
+}

package/dist/threading/offload-worker.d.ts

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