unpak.js/dist/performance/WorkerThreads.d.ts

Modern TypeScript library for reading Unreal Engine pak files and assets, inspired by CUE4Parse

import { EventEmitter } from 'events';
/**
 * Worker Thread Support for unpak.js Performance Optimization
 * Phase 11 - Worker thread optimization for parallel asset processing
 *
 * This module provides:
 * - Parallel asset extraction and processing
 * - CPU-intensive operations offloading
 * - Memory-efficient large file handling
 * - Task queuing and load balancing
 * - Progress tracking and cancellation
 */
export interface IWorkerTask {
    id: string;
    type: 'extract' | 'convert' | 'compress' | 'parse' | 'analyze';
    payload: any;
    priority: 'low' | 'normal' | 'high';
    timeout?: number;
    retries?: number;
}
export interface IWorkerResult {
    taskId: string;
    success: boolean;
    result?: any;
    error?: string;
    duration: number;
    memoryUsed: number;
}
export interface IWorkerPoolOptions {
    maxWorkers?: number;
    taskTimeout?: number;
    maxRetries?: number;
    workerScript?: string;
    enableProfiling?: boolean;
}
export interface IWorkerStats {
    workerId: string;
    tasksCompleted: number;
    tasksInProgress: number;
    totalExecutionTime: number;
    averageExecutionTime: number;
    memoryUsage: number;
    cpuUsage: number;
    isActive: boolean;
    lastTaskTime: Date;
}
export interface IPoolStats {
    totalWorkers: number;
    activeWorkers: number;
    queuedTasks: number;
    completedTasks: number;
    failedTasks: number;
    totalExecutionTime: number;
    memoryUsage: {
        current: number;
        peak: number;
        average: number;
    };
}
/**
 * Worker pool manager
 */
export declare class WorkerPool extends EventEmitter {
    private workers;
    private taskQueue;
    private options;
    private stats;
    private isRunning;
    private pendingTasks;
    constructor(options?: IWorkerPoolOptions);
    private getDefaultWorkerScript;
    initialize(): Promise<void>;
    shutdown(): Promise<void>;
    submitTask(task: IWorkerTask): Promise<IWorkerResult>;
    getStats(): IPoolStats;
    getWorkerStats(): IWorkerStats[];
    resizePool(newSize: number): Promise<void>;
    private createWorker;
    private removeWorker;
    private processQueue;
    private handleTaskResult;
    private handleTaskError;
}
/**
 * High-level API for common operations
 */
export declare class ParallelProcessor extends EventEmitter {
    private workerPool;
    private taskCounter;
    constructor(options?: IWorkerPoolOptions);
    initialize(): Promise<void>;
    shutdown(): Promise<void>;
    extractAssets(archives: Array<{
        path: string;
        assets: string[];
    }>): Promise<IWorkerResult[]>;
    convertAssets(conversions: Array<{
        input: any;
        fromFormat: string;
        toFormat: string;
    }>): Promise<IWorkerResult[]>;
    analyzeAssets(assets: Array<{
        data: any;
        type: string;
    }>): Promise<IWorkerResult[]>;
    getStats(): IPoolStats;
    getWorkerStats(): IWorkerStats[];
    private submitTasks;
    private generateTaskId;
}
/**
 * Factory function for creating parallel processor
 */
export declare function createParallelProcessor(options?: IWorkerPoolOptions): ParallelProcessor;
//# sourceMappingURL=WorkerThreads.d.ts.map