@scelar/nodepod 1.0.1 → 1.0.2

package/dist/threading/offload.d.ts

@@ -0,0 +1,16 @@
+import type { OffloadTask, OffloadResult, PoolConfig, TransformTask, TransformResult, ExtractTask, ExtractResult, BuildTask, BuildResult } from "./offload-types";
+export { TaskPriority } from "./offload-types";
+export type { TransformTask, TransformResult, ExtractTask, ExtractResult, BuildTask, BuildResult, OffloadTask, OffloadResult, PoolConfig, } from "./offload-types";
+export declare function taskId(): string;
+export declare function offload<T extends OffloadTask>(task: T): Promise<T extends TransformTask ? TransformResult : T extends ExtractTask ? ExtractResult : T extends BuildTask ? BuildResult : OffloadResult>;
+export declare function offloadBatch(tasks: OffloadTask[]): Promise<OffloadResult[]>;
+export declare function cancelTask(id: string): boolean;
+export declare function poolStats(): {
+    total: number;
+    busy: number;
+    idle: number;
+    initialized: number;
+    fallback: boolean;
+};
+export declare function disposePool(): void;
+export declare function configurePool(config: PoolConfig): void;

package/dist/threading/process-context.d.ts

@@ -0,0 +1,40 @@
+import type { MemoryVolume } from "../memory-volume";
+export interface ProcessWriter {
+    write(data: string): void;
+}
+export interface ProcessReader {
+    on(event: string, cb: (...args: unknown[]) => void): void;
+    emit(event: string, ...args: unknown[]): void;
+}
+export interface ProcessContext {
+    pid: number;
+    cwd: string;
+    env: Record<string, string>;
+    stdoutSink: ((text: string) => void) | null;
+    stderrSink: ((text: string) => void) | null;
+    liveStdin: {
+        emit: (e: string, ...a: unknown[]) => void;
+    } | null;
+    abortController: AbortController;
+    volume: MemoryVolume;
+    refCount: number;
+    drainListeners: Set<() => void>;
+    termCols: (() => number) | null;
+    termRows: (() => number) | null;
+    fdCounter: number;
+    openFiles: Map<number, OpenFileEntry>;
+}
+export interface OpenFileEntry {
+    filePath: string;
+    cursor: number;
+    mode: string;
+    data: Uint8Array;
+}
+export declare function createProcessContext(opts: {
+    volume: MemoryVolume;
+    cwd?: string;
+    env?: Record<string, string>;
+    pid?: number;
+}): ProcessContext;
+export declare function getActiveContext(): ProcessContext | null;
+export declare function setActiveContext(ctx: ProcessContext | null): void;

package/dist/threading/process-handle.d.ts

@@ -0,0 +1,42 @@
+import { EventEmitter } from "../polyfills/events";
+import type { MainToWorkerMessage, SpawnConfig, MainToWorker_Init, MainToWorker_Exec } from "./worker-protocol";
+export type ProcessState = "starting" | "running" | "exited";
+export declare class ProcessHandle extends EventEmitter {
+    readonly pid: number;
+    readonly worker: Worker;
+    readonly command: string;
+    readonly args: string[];
+    readonly parentPid?: number;
+    private _state;
+    private _exitCode;
+    private _stdout;
+    private _stderr;
+    private _exitHoldCount;
+    private _deferredExit;
+    private _shellDoneHoldCount;
+    private _deferredShellDone;
+    private _syncBlockedCount;
+    get workerExited(): boolean;
+    get shellCommandDone(): boolean;
+    get syncBlocked(): boolean;
+    holdSync(): void;
+    releaseSync(): void;
+    get stdout(): string;
+    get stderr(): string;
+    get state(): ProcessState;
+    get exitCode(): number | undefined;
+    constructor(worker: Worker, config: SpawnConfig);
+    _setPid(pid: number): void;
+    postMessage(msg: MainToWorkerMessage, transfer?: Transferable[]): void;
+    init(initMsg: MainToWorker_Init): void;
+    exec(execMsg: MainToWorker_Exec): void;
+    sendStdin(data: string): void;
+    kill(signal?: string): void;
+    resize(cols: number, rows: number): void;
+    holdExit(): void;
+    releaseExit(): void;
+    holdShellDone(): void;
+    releaseShellDone(): void;
+    private _terminate;
+    private _setupWorkerListeners;
+}

package/dist/threading/process-manager.d.ts

@@ -0,0 +1,52 @@
+import { EventEmitter } from "../polyfills/events";
+import type { MemoryVolume } from "../memory-volume";
+import { ProcessHandle } from "./process-handle";
+import type { ProcessInfo } from "./worker-protocol";
+import type { VFSBridge } from "./vfs-bridge";
+export declare class ProcessManager extends EventEmitter {
+    private _processes;
+    private _nextPid;
+    private _volume;
+    private _vfsBridge;
+    private _sharedBuffer;
+    private _syncBuffer;
+    private _serverPorts;
+    private _childPids;
+    private _httpCallbacks;
+    private _nextHttpRequestId;
+    constructor(volume: MemoryVolume);
+    setVFSBridge(bridge: VFSBridge): void;
+    setSharedBuffer(buf: SharedArrayBuffer): void;
+    setSyncBuffer(buf: SharedArrayBuffer): void;
+    spawn(config: {
+        command: string;
+        args?: string[];
+        cwd?: string;
+        env?: Record<string, string>;
+        parentPid?: number;
+    }): ProcessHandle;
+    getProcess(pid: number): ProcessHandle | undefined;
+    listProcesses(): ProcessInfo[];
+    kill(pid: number, signal?: string): boolean;
+    private _cleanupServerPorts;
+    private _killDescendants;
+    teardown(): void;
+    get processCount(): number;
+    registerServerPort(port: number, pid: number): void;
+    unregisterServerPort(port: number): void;
+    getServerPorts(): number[];
+    dispatchHttpRequest(port: number, method: string, path: string, headers: Record<string, string>, body?: string | null): Promise<{
+        statusCode: number;
+        statusMessage: string;
+        headers: Record<string, string>;
+        body: string;
+    }>;
+    dispatchWsUpgrade(port: number, uid: string, path: string, headers: Record<string, string>): number;
+    dispatchWsData(pid: number, uid: string, frame: number[]): void;
+    dispatchWsClose(pid: number, uid: string, code: number): void;
+    private static _workerBlobUrl;
+    private _createWorker;
+    private _wireHandleEvents;
+    private _createEmptySnapshot;
+    broadcastVFSChange(path: string, content: ArrayBuffer | null, isDirectory: boolean, excludePid: number): void;
+}

package/dist/threading/process-worker-entry.d.ts

@@ -0,0 +1,24 @@
+export declare function forkChild(modulePath: string, args: string[], opts: {
+    cwd: string;
+    env: Record<string, string>;
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+    onIPC?: (data: unknown) => void;
+    onExit?: (exitCode: number) => void;
+}): {
+    sendIPC: (data: unknown) => void;
+    disconnect: () => void;
+    requestId: number;
+};
+export declare function spawnChild(command: string, args: string[], opts?: {
+    cwd?: string;
+    env?: Record<string, string>;
+    stdio?: "pipe" | "inherit";
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+}): Promise<{
+    pid: number;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}>;

package/dist/threading/shared-vfs.d.ts

@@ -0,0 +1,36 @@
+export declare function isSharedArrayBufferAvailable(): boolean;
+export declare class SharedVFSController {
+    private _buffer;
+    private _view;
+    private _int32;
+    private _uint8;
+    private _pathEncoder;
+    private _pathDecoder;
+    constructor(bufferSize?: number);
+    get buffer(): SharedArrayBuffer;
+    writeFile(path: string, content: Uint8Array): boolean;
+    writeDirectory(path: string): boolean;
+    deleteFile(path: string): boolean;
+    readFile(path: string): Uint8Array | null;
+    exists(path: string): boolean;
+    get version(): number;
+    private _findEntry;
+    private _updateEntry;
+    private _lock;
+    private _unlock;
+}
+export declare class SharedVFSReader {
+    private _buffer;
+    private _view;
+    private _int32;
+    private _uint8;
+    private _pathEncoder;
+    private _pathDecoder;
+    constructor(buffer: SharedArrayBuffer);
+    readFileSync(path: string): Uint8Array | null;
+    existsSync(path: string): boolean;
+    isDirectorySync(path: string): boolean;
+    get version(): number;
+    waitForChange(currentVersion: number, timeoutMs?: number): number;
+    private _findEntry;
+}

package/dist/threading/sync-channel.d.ts

@@ -0,0 +1,21 @@
+export declare const SLOT_SIZE = 4096;
+export declare const MAX_SLOTS = 64;
+export declare class SyncChannelController {
+    private _buffer;
+    private _int32;
+    private _uint8;
+    constructor(bufferSize?: number);
+    get buffer(): SharedArrayBuffer;
+    writeResult(syncSlot: number, exitCode: number, stdout: string): void;
+    writeError(syncSlot: number, exitCode: number, errorMessage: string): void;
+}
+export declare class SyncChannelWorker {
+    private _int32;
+    private _uint8;
+    constructor(buffer: SharedArrayBuffer);
+    allocateSlot(): number;
+    waitForResult(syncSlot: number, timeoutMs?: number): {
+        exitCode: number;
+        stdout: string;
+    };
+}

package/dist/threading/task-queue.d.ts

@@ -0,0 +1,15 @@
+import type { WorkerPool } from "./worker-pool";
+import type { OffloadTask, OffloadResult, TransformTask, TransformResult, ExtractTask, ExtractResult, BuildTask, BuildResult } from "./offload-types";
+export declare class TaskQueue {
+    private queue;
+    private pool;
+    private dispatching;
+    constructor(pool: WorkerPool);
+    submit<T extends OffloadTask>(task: T): Promise<T extends TransformTask ? TransformResult : T extends ExtractTask ? ExtractResult : T extends BuildTask ? BuildResult : OffloadResult>;
+    submitBatch(tasks: OffloadTask[]): Promise<OffloadResult[]>;
+    cancel(taskId: string): boolean;
+    get pending(): number;
+    private dispatch;
+    private rejectAll;
+    private executeTask;
+}

package/dist/threading/vfs-bridge.d.ts

@@ -0,0 +1,25 @@
+import type { MemoryVolume } from "../memory-volume";
+import type { VFSBinarySnapshot, VFSSnapshotEntry } from "./worker-protocol";
+import type { SharedVFSController } from "./shared-vfs";
+export declare class VFSBridge {
+    private _volume;
+    private _broadcaster;
+    private _sharedVFS;
+    private _suppressWatch;
+    constructor(volume: MemoryVolume);
+    setBroadcaster(fn: (path: string, content: ArrayBuffer | null, excludePid: number) => void): void;
+    setSharedVFS(controller: SharedVFSController): void;
+    createSnapshot(): VFSBinarySnapshot;
+    createChunkedSnapshots(): {
+        chunkIndex: number;
+        totalChunks: number;
+        data: ArrayBuffer;
+        manifest: VFSSnapshotEntry[];
+    }[];
+    handleWorkerWrite(path: string, content: Uint8Array): void;
+    handleWorkerMkdir(path: string): void;
+    handleWorkerDelete(path: string): void;
+    broadcastChange(path: string, content: ArrayBuffer | null, excludePid: number): void;
+    watch(): () => void;
+    private _walkVolume;
+}

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

@@ -0,0 +1,38 @@
+import { type Remote } from "comlink";
+import type { OffloadWorkerEndpoint, PoolConfig } from "./offload-types";
+interface PooledWorker {
+    thread: Worker;
+    endpoint: Remote<OffloadWorkerEndpoint>;
+    busy: boolean;
+    initialized: boolean;
+    initPromise: Promise<void> | null;
+    lastUsed: number;
+    id: number;
+}
+export declare class WorkerPool {
+    private workers;
+    private waitQueue;
+    private nextId;
+    private config;
+    private idleTimer;
+    private disposed;
+    broken: boolean;
+    constructor(config?: PoolConfig);
+    acquire(): Promise<{
+        worker: PooledWorker;
+        release: () => void;
+    }>;
+    dispose(): void;
+    stats(): {
+        total: number;
+        busy: number;
+        idle: number;
+        initialized: number;
+    };
+    private rejectAllWaiters;
+    private release;
+    private tryCreateWorker;
+    private reapIdle;
+    private terminateWorker;
+}
+export {};

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

@@ -0,0 +1,264 @@
+export interface VFSBinarySnapshot {
+    manifest: VFSSnapshotEntry[];
+    data: ArrayBuffer;
+}
+export interface VFSSnapshotEntry {
+    path: string;
+    offset: number;
+    length: number;
+    isDirectory: boolean;
+}
+export interface MainToWorker_Init {
+    type: "init";
+    pid: number;
+    cwd: string;
+    env: Record<string, string>;
+    snapshot: VFSBinarySnapshot;
+    sharedBuffer?: SharedArrayBuffer;
+    syncBuffer?: SharedArrayBuffer;
+}
+export interface MainToWorker_Exec {
+    type: "exec";
+    filePath: string;
+    args: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    isShell?: boolean;
+    shellCommand?: string;
+    isFork?: boolean;
+    persistent?: boolean;
+    isWorkerThread?: boolean;
+    workerData?: unknown;
+    threadId?: number;
+}
+export interface MainToWorker_Stdin {
+    type: "stdin";
+    data: string;
+}
+export interface MainToWorker_Signal {
+    type: "signal";
+    signal: string;
+}
+export interface MainToWorker_Resize {
+    type: "resize";
+    cols: number;
+    rows: number;
+}
+export interface MainToWorker_VFSSync {
+    type: "vfs-sync";
+    path: string;
+    content: ArrayBuffer | null;
+    isDirectory: boolean;
+}
+export interface MainToWorker_VFSChunk {
+    type: "vfs-chunk";
+    chunkIndex: number;
+    totalChunks: number;
+    data: ArrayBuffer;
+    manifest: VFSSnapshotEntry[];
+}
+export interface MainToWorker_SpawnResult {
+    type: "spawn-result";
+    requestId: number;
+    pid: number;
+    error?: string;
+}
+export interface MainToWorker_ChildOutput {
+    type: "child-output";
+    requestId: number;
+    stream: "stdout" | "stderr";
+    data: string;
+}
+export interface MainToWorker_ChildExit {
+    type: "child-exit";
+    requestId: number;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface MainToWorker_HttpRequest {
+    type: "http-request";
+    requestId: number;
+    port: number;
+    method: string;
+    path: string;
+    headers: Record<string, string>;
+    body: string | null;
+}
+export interface MainToWorker_IPC {
+    type: "ipc-message";
+    data: unknown;
+    targetRequestId?: number;
+}
+export interface MainToWorker_WsUpgrade {
+    type: "ws-upgrade";
+    uid: string;
+    port: number;
+    path: string;
+    headers: Record<string, string>;
+}
+export interface MainToWorker_WsData {
+    type: "ws-data";
+    uid: string;
+    frame: number[];
+}
+export interface MainToWorker_WsClose {
+    type: "ws-close";
+    uid: string;
+    code: number;
+}
+export type MainToWorkerMessage = MainToWorker_Init | MainToWorker_Exec | MainToWorker_Stdin | MainToWorker_Signal | MainToWorker_Resize | MainToWorker_VFSSync | MainToWorker_VFSChunk | MainToWorker_SpawnResult | MainToWorker_ChildOutput | MainToWorker_ChildExit | MainToWorker_HttpRequest | MainToWorker_IPC | MainToWorker_WsUpgrade | MainToWorker_WsData | MainToWorker_WsClose;
+export interface WorkerToMain_Ready {
+    type: "ready";
+    pid: number;
+}
+export interface WorkerToMain_Stdout {
+    type: "stdout";
+    data: string;
+}
+export interface WorkerToMain_Stderr {
+    type: "stderr";
+    data: string;
+}
+export interface WorkerToMain_Exit {
+    type: "exit";
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface WorkerToMain_Console {
+    type: "console";
+    method: string;
+    args: string[];
+}
+export interface WorkerToMain_VFSWrite {
+    type: "vfs-write";
+    path: string;
+    content: ArrayBuffer;
+    isDirectory: boolean;
+}
+export interface WorkerToMain_VFSDelete {
+    type: "vfs-delete";
+    path: string;
+}
+export interface WorkerToMain_VFSRead {
+    type: "vfs-read";
+    requestId: number;
+    path: string;
+}
+export interface WorkerToMain_SpawnRequest {
+    type: "spawn-request";
+    requestId: number;
+    command: string;
+    args: string[];
+    cwd: string;
+    env: Record<string, string>;
+    stdio: "pipe" | "inherit";
+}
+export interface WorkerToMain_ForkRequest {
+    type: "fork-request";
+    requestId: number;
+    modulePath: string;
+    args: string[];
+    cwd: string;
+    env: Record<string, string>;
+}
+export interface WorkerToMain_WorkerThreadRequest {
+    type: "workerthread-request";
+    requestId: number;
+    modulePath: string;
+    isEval?: boolean;
+    args: string[];
+    cwd: string;
+    env: Record<string, string>;
+    workerData: unknown;
+    threadId: number;
+}
+export interface WorkerToMain_SpawnSync {
+    type: "spawn-sync";
+    requestId: number;
+    command: string;
+    args: string[];
+    cwd: string;
+    env: Record<string, string>;
+    syncSlot: number;
+    shellCommand?: string;
+}
+export interface WorkerToMain_ServerListen {
+    type: "server-listen";
+    port: number;
+    hostname: string;
+}
+export interface WorkerToMain_ServerClose {
+    type: "server-close";
+    port: number;
+}
+export interface WorkerToMain_HttpRequest {
+    type: "http-request";
+    requestId: number;
+    port: number;
+    method: string;
+    path: string;
+    headers: Record<string, string>;
+    body: string | null;
+}
+export interface WorkerToMain_CwdChange {
+    type: "cwd-change";
+    cwd: string;
+}
+export interface WorkerToMain_StdinRawStatus {
+    type: "stdin-raw-status";
+    isRaw: boolean;
+}
+export interface WorkerToMain_HttpResponse {
+    type: "http-response";
+    requestId: number;
+    statusCode: number;
+    statusMessage: string;
+    headers: Record<string, string>;
+    body: string;
+}
+export interface WorkerToMain_IPC {
+    type: "ipc-message";
+    data: unknown;
+    targetRequestId?: number;
+}
+export interface WorkerToMain_ShellDone {
+    type: "shell-done";
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface WorkerToMain_Error {
+    type: "error";
+    message: string;
+    stack?: string;
+}
+export interface WorkerToMain_WsFrame {
+    type: "ws-frame";
+    uid: string;
+    kind: string;
+    data?: string;
+    bytes?: number[];
+    code?: number;
+    message?: string;
+}
+export type WorkerToMainMessage = WorkerToMain_Ready | WorkerToMain_Stdout | WorkerToMain_Stderr | WorkerToMain_Exit | WorkerToMain_Console | WorkerToMain_VFSWrite | WorkerToMain_VFSDelete | WorkerToMain_VFSRead | WorkerToMain_SpawnRequest | WorkerToMain_ForkRequest | WorkerToMain_WorkerThreadRequest | WorkerToMain_SpawnSync | WorkerToMain_ServerListen | WorkerToMain_ServerClose | WorkerToMain_HttpRequest | WorkerToMain_CwdChange | WorkerToMain_StdinRawStatus | WorkerToMain_HttpResponse | WorkerToMain_IPC | WorkerToMain_ShellDone | WorkerToMain_Error | WorkerToMain_WsFrame;
+export interface SpawnConfig {
+    command: string;
+    args: string[];
+    cwd: string;
+    env: Record<string, string>;
+    snapshot: VFSBinarySnapshot;
+    sharedBuffer?: SharedArrayBuffer;
+    syncBuffer?: SharedArrayBuffer;
+    parentPid?: number;
+}
+export interface ProcessInfo {
+    pid: number;
+    command: string;
+    args: string[];
+    state: "starting" | "running" | "exited";
+    exitCode?: number;
+    parentPid?: number;
+}

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

@@ -0,0 +1,34 @@
+import type { VFSBinarySnapshot } from "./worker-protocol";
+export declare class WorkerVFS {
+    private _files;
+    private _dirs;
+    private _onWrite;
+    private _onDelete;
+    private _decoder;
+    private _encoder;
+    constructor();
+    initFromSnapshot(snapshot: VFSBinarySnapshot): void;
+    setWriteCallback(cb: (path: string, content: Uint8Array, isDir: boolean) => void): void;
+    setDeleteCallback(cb: (path: string) => void): void;
+    readFileSync(path: string, encoding?: string): string | Uint8Array;
+    existsSync(path: string): boolean;
+    statSync(path: string): {
+        isFile: () => boolean;
+        isDirectory: () => boolean;
+        size: number;
+    };
+    readdirSync(path: string): string[];
+    writeFileSync(path: string, content: string | Uint8Array): void;
+    mkdirSync(path: string, opts?: {
+        recursive?: boolean;
+    }): void;
+    unlinkSync(path: string): void;
+    rmdirSync(path: string): void;
+    renameSync(src: string, dest: string): void;
+    appendFileSync(path: string, content: string | Uint8Array): void;
+    copyFileSync(src: string, dest: string): void;
+    applySync(path: string, content: ArrayBuffer | null, isDirectory: boolean): void;
+    private _ensureParentDirs;
+    get fileCount(): number;
+    get dirCount(): number;
+}