@od-oneapp/config 2026.2.2001-canary.1

package/typescript/dist/src/server/worker-threads.js

@@ -0,0 +1,1074 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { logError, logWarn } from '@repo/shared/logs/client/next';
+import { CLEANUP_PRIORITIES, registerCleanupHandler } from '../runtime/lifecycle.js';
+import { delay, withTimeout } from '../shared/timeout.js';
+import { safeThrowIfAborted } from './abort-support';
+import { createMCPErrorResponse } from './error-handling';
+import { WorkerPool, createWorkerScript } from './worker-pool';
+const idGenerators = {
+    workerPoolId: () => `pool_${crypto.randomUUID()}`,
+};
+const workerPools = new Map();
+const _WORKER_STATUS_OFFSET = 0;
+const _TASK_COUNTER_OFFSET = 4;
+const _PERFORMANCE_METRICS_OFFSET = 0;
+const AVAILABLE_COUNTER_INDEX = 0;
+const WORKER_IDLE = 0;
+const WORKER_BUSY = 1;
+const WORKER_ERROR = 2;
+const WORKER_SHUTDOWN = 3;
+const workerStates = new Map();
+class SharedArrayBufferSecurity {
+    static isSupported = null;
+    static hasCrossOriginIsolation = null;
+    static checkSupport() {
+        if (this.isSupported !== null)
+            return this.isSupported;
+        try {
+            this.isSupported =
+                typeof SharedArrayBuffer !== 'undefined' &&
+                    typeof Atomics !== 'undefined' &&
+                    this.checkCrossOriginIsolation();
+        }
+        catch {
+            this.isSupported = false;
+        }
+        return this.isSupported;
+    }
+    static checkCrossOriginIsolation() {
+        if (this.hasCrossOriginIsolation !== null)
+            return this.hasCrossOriginIsolation;
+        try {
+            if (typeof globalThis !== 'undefined' && 'crossOriginIsolated' in globalThis) {
+                this.hasCrossOriginIsolation = Boolean(globalThis.crossOriginIsolated);
+            }
+            else {
+                this.hasCrossOriginIsolation = true;
+            }
+        }
+        catch {
+            this.hasCrossOriginIsolation = false;
+        }
+        return this.hasCrossOriginIsolation ?? false;
+    }
+    static createSecureBuffer(size) {
+        if (!this.checkSupport()) {
+            throw new Error('SharedArrayBuffer not supported or not safe in current environment');
+        }
+        if (size <= 0 || !Number.isInteger(size) || size > MAX_BUFFER_SIZE) {
+            throw new Error(`Invalid buffer size: ${size}. Must be positive integer <= ${MAX_BUFFER_SIZE}`);
+        }
+        const jitter = Math.floor(Date.now() % 64);
+        const secureSize = Math.ceil((size + jitter) / 64) * 64;
+        if (secureSize > MAX_BUFFER_SIZE) {
+            throw new Error(`Buffer size with security padding exceeds maximum: ${secureSize} > ${MAX_BUFFER_SIZE}`);
+        }
+        return new SharedArrayBuffer(secureSize);
+    }
+    static validateBufferAccess(buffer, offset, length) {
+        if (offset < 0 || length < 0 || offset + length > buffer.byteLength) {
+            throw new Error(`Buffer access out of bounds: offset=${offset}, length=${length}, bufferSize=${buffer.byteLength}`);
+        }
+    }
+}
+const MAX_WORKERS = 16;
+const MAX_BUFFER_SIZE = 32 * 1024;
+function createWorkerState(poolId, maxWorkers = 4) {
+    if (typeof maxWorkers !== 'number' || !Number.isFinite(maxWorkers)) {
+        throw new Error('maxWorkers must be a finite number');
+    }
+    if (maxWorkers < 1 || maxWorkers > MAX_WORKERS) {
+        throw new Error(`maxWorkers must be between 1 and ${MAX_WORKERS}`);
+    }
+    if (!SharedArrayBufferSecurity.checkSupport()) {
+        throw new Error('SharedArrayBuffer not available or not secure in current environment');
+    }
+    const statusBytes = maxWorkers * 4;
+    const counterBytes = maxWorkers * 4;
+    const metricsBytes = (maxWorkers + 1) * 4;
+    if (statusBytes < maxWorkers || counterBytes < maxWorkers || metricsBytes < maxWorkers) {
+        throw new Error('Integer overflow detected in buffer size calculation');
+    }
+    const rawSize = statusBytes + counterBytes + metricsBytes;
+    if (rawSize < statusBytes || rawSize > MAX_BUFFER_SIZE) {
+        throw new Error(`Buffer size calculation failed: ${rawSize} (max: ${MAX_BUFFER_SIZE})`);
+    }
+    const sharedBuffer = SharedArrayBufferSecurity.createSecureBuffer(rawSize);
+    SharedArrayBufferSecurity.validateBufferAccess(sharedBuffer, 0, statusBytes);
+    SharedArrayBufferSecurity.validateBufferAccess(sharedBuffer, statusBytes, counterBytes);
+    SharedArrayBufferSecurity.validateBufferAccess(sharedBuffer, statusBytes + counterBytes, metricsBytes);
+    const statusArray = new Int32Array(sharedBuffer, 0, maxWorkers);
+    const counterArray = new Int32Array(sharedBuffer, statusBytes, maxWorkers);
+    const metricArray = new Int32Array(sharedBuffer, statusBytes + counterBytes, maxWorkers + 1);
+    Atomics.store(metricArray, AVAILABLE_COUNTER_INDEX, maxWorkers);
+    for (let i = 0; i < maxWorkers; i++) {
+        Atomics.store(statusArray, i, WORKER_IDLE);
+        Atomics.store(counterArray, i, 0);
+        Atomics.store(metricArray, i + 1, 0);
+    }
+    const workerState = { sharedBuffer, statusArray, counterArray, metricArray };
+    workerStates.set(poolId, workerState);
+    return workerState;
+}
+async function _getWorkerStatus(poolId, workerId) {
+    const state = workerStates.get(poolId);
+    if (!state)
+        return WORKER_ERROR;
+    return await batchAtomicOperation(poolId, 'load', state.statusArray, workerId);
+}
+async function setWorkerStatus(poolId, workerId, status) {
+    const state = workerStates.get(poolId);
+    if (!state)
+        return false;
+    const oldStatus = await batchAtomicOperation(poolId, 'load', state.statusArray, workerId);
+    await batchAtomicOperation(poolId, 'store', state.statusArray, workerId, status);
+    if (oldStatus === WORKER_IDLE && status === WORKER_BUSY) {
+        Atomics.sub(state.metricArray, AVAILABLE_COUNTER_INDEX, 1);
+    }
+    else if (oldStatus === WORKER_BUSY && status === WORKER_IDLE) {
+        Atomics.add(state.metricArray, AVAILABLE_COUNTER_INDEX, 1);
+        Atomics.notify(state.metricArray, AVAILABLE_COUNTER_INDEX, Infinity);
+    }
+    Atomics.notify(state.statusArray, workerId, 1);
+    return true;
+}
+async function incrementTaskCounter(poolId, workerId) {
+    const state = workerStates.get(poolId);
+    if (!state)
+        return 0;
+    return (await batchAtomicOperation(poolId, 'add', state.counterArray, workerId, 1)) + 1;
+}
+class SecureAtomicOperations {
+    static metricLocks = new Map();
+    static LOCK_TIMEOUT = 50;
+    static MAX_SPIN_ITERATIONS = 100;
+    static async updateWorkerMetrics(poolId, workerId, processingTime) {
+        const state = workerStates.get(poolId);
+        if (!state)
+            return;
+        if (!this.validateMetricParams(workerId, processingTime, state)) {
+            return;
+        }
+        const lockArray = this.getOrCreateLockArray(poolId, state.metricArray.length);
+        if (!lockArray)
+            return;
+        await this.performSecureMetricUpdate(lockArray, state, workerId, processingTime, poolId);
+    }
+    static validateMetricParams(workerId, processingTime, state) {
+        if (typeof workerId !== 'number' || workerId < 0 || workerId + 1 >= state.metricArray.length) {
+            return false;
+        }
+        if (typeof processingTime !== 'number' ||
+            !Number.isFinite(processingTime) ||
+            processingTime < 0) {
+            return false;
+        }
+        if (processingTime > 300000) {
+            return false;
+        }
+        return true;
+    }
+    static getOrCreateLockArray(poolId, length) {
+        let lockArray = this.metricLocks.get(poolId);
+        if (!lockArray) {
+            try {
+                const bufferSize = length * 4;
+                const buffer = SharedArrayBufferSecurity.createSecureBuffer(bufferSize);
+                lockArray = new Int32Array(buffer);
+                this.metricLocks.set(poolId, lockArray);
+            }
+            catch (error) {
+                logWarn(`Failed to create secure lock array for pool ${poolId}`, { error, poolId });
+                return null;
+            }
+        }
+        return lockArray;
+    }
+    static async performSecureMetricUpdate(lockArray, state, workerId, processingTime, poolId) {
+        const startTime = performance.now();
+        let iterations = 0;
+        while (iterations < this.MAX_SPIN_ITERATIONS) {
+            const oldValue = Atomics.compareExchange(lockArray, workerId, 0, 1);
+            if (oldValue === 0) {
+                try {
+                    const metricIndex = workerId + 1;
+                    const currentMetric = Atomics.load(state.metricArray, metricIndex);
+                    const newMetric = currentMetric > 0
+                        ? Math.floor((currentMetric + processingTime) / 2)
+                        : Math.floor(processingTime);
+                    Atomics.store(state.metricArray, metricIndex, newMetric);
+                }
+                finally {
+                    Atomics.store(lockArray, workerId, 0);
+                    Atomics.notify(lockArray, workerId, 1);
+                }
+                return;
+            }
+            if (performance.now() - startTime > this.LOCK_TIMEOUT) {
+                logWarn(`Atomic operation timeout for pool ${poolId}, worker ${workerId}`, {
+                    poolId,
+                    workerId,
+                });
+                return;
+            }
+            const backoffMs = Math.min(2 ** Math.min(iterations, 4), 8);
+            await delay(backoffMs);
+            iterations++;
+        }
+    }
+    static cleanup(poolId) {
+        this.metricLocks.delete(poolId);
+    }
+}
+async function updateWorkerMetrics(poolId, workerId, processingTime) {
+    await SecureAtomicOperations.updateWorkerMetrics(poolId, workerId, processingTime);
+}
+async function getPoolMetrics(poolId) {
+    const state = workerStates.get(poolId);
+    if (!state)
+        return null;
+    const statusReads = [];
+    const counterReads = [];
+    const metricReads = [];
+    for (let i = 0; i < state.statusArray.length; i++) {
+        statusReads.push(batchAtomicOperation(poolId, 'load', state.statusArray, i));
+        counterReads.push(batchAtomicOperation(poolId, 'load', state.counterArray, i));
+        metricReads.push(batchAtomicOperation(poolId, 'load', state.metricArray, i + 1));
+    }
+    const availableCountRead = batchAtomicOperation(poolId, 'load', state.metricArray, AVAILABLE_COUNTER_INDEX);
+    const [statuses, counters, metrics, availableCount] = await Promise.all([
+        Promise.all(statusReads),
+        Promise.all(counterReads),
+        Promise.all(metricReads),
+        availableCountRead,
+    ]);
+    const workers = [];
+    for (let i = 0; i < statuses.length; i++) {
+        const status = statuses[i];
+        const tasksCompleted = counters[i] ?? 0;
+        const averageProcessingTime = metrics[i] ?? 0;
+        workers.push({
+            id: i,
+            status: getWorkerStatusName(typeof status === 'number' ? status : WORKER_ERROR),
+            tasksCompleted,
+            averageProcessingTime,
+        });
+    }
+    return { poolId, workers, availableWorkers: availableCount };
+}
+function getWorkerStatusName(status) {
+    switch (status) {
+        case WORKER_IDLE:
+            return 'idle';
+        case WORKER_BUSY:
+            return 'busy';
+        case WORKER_ERROR:
+            return 'error';
+        case WORKER_SHUTDOWN:
+            return 'shutdown';
+        default:
+            return 'unknown';
+    }
+}
+const pendingBatches = new Map();
+let batchFlushTimer = null;
+function batchAtomicOperation(poolId, type, array, index, value, expected) {
+    return new Promise(resolve => {
+        let batch = pendingBatches.get(poolId);
+        if (!batch) {
+            batch = { operations: [], results: [], resolvers: [] };
+            pendingBatches.set(poolId, batch);
+        }
+        const operationIndex = batch.operations.length;
+        batch.operations.push({ type, array, index, value, expected });
+        batch.resolvers[operationIndex] = resolve;
+        if (!batchFlushTimer) {
+            batchFlushTimer = setImmediate(() => {
+                flushAtomicBatches();
+                batchFlushTimer = null;
+            });
+        }
+    });
+}
+function flushAtomicBatches() {
+    for (const [_poolId, batch] of pendingBatches) {
+        for (let i = 0; i < batch.operations.length; i++) {
+            const op = batch.operations[i];
+            if (!op) {
+                continue;
+            }
+            let result;
+            switch (op.type) {
+                case 'load':
+                    result = Atomics.load(op.array, op.index);
+                    break;
+                case 'store':
+                    result = typeof op.value === 'number' ? Atomics.store(op.array, op.index, op.value) : 0;
+                    break;
+                case 'add':
+                    result = typeof op.value === 'number' ? Atomics.add(op.array, op.index, op.value) : 0;
+                    break;
+                case 'compareExchange':
+                    result =
+                        typeof op.value === 'number' && typeof op.expected === 'number'
+                            ? Atomics.compareExchange(op.array, op.index, op.expected, op.value)
+                            : 0;
+                    break;
+                default:
+                    result = 0;
+            }
+            batch.results[i] = result;
+            batch.resolvers[i]?.(result);
+        }
+    }
+    pendingBatches.clear();
+}
+function waitForAvailableWorker(poolId, timeoutMs = 5000) {
+    return new Promise((resolve, reject) => {
+        const state = workerStates.get(poolId);
+        if (!state) {
+            reject(new Error('Pool not found'));
+            return;
+        }
+        const startTime = Date.now();
+        async function findAvailableWorker() {
+            if (!state) {
+                reject(new Error('Pool state not found'));
+                return;
+            }
+            const availableCount = Atomics.load(state.metricArray, AVAILABLE_COUNTER_INDEX);
+            if (availableCount > 0) {
+                for (let i = 0; i < state.statusArray.length; i++) {
+                    const status = Atomics.load(state.statusArray, i);
+                    if (status === WORKER_IDLE) {
+                        resolve(i);
+                        return;
+                    }
+                }
+            }
+            if (Date.now() - startTime > timeoutMs) {
+                reject(new Error('Timeout waiting for available worker'));
+                return;
+            }
+            try {
+                const asyncWait = Atomics.waitAsync;
+                if (asyncWait && typeof asyncWait === 'function') {
+                    const currentAvailable = Atomics.load(state.metricArray, AVAILABLE_COUNTER_INDEX);
+                    if (currentAvailable > 0) {
+                        setImmediate(() => void findAvailableWorker());
+                    }
+                    else {
+                        const result = asyncWait(state.metricArray, AVAILABLE_COUNTER_INDEX, 0, 100);
+                        if (result?.async) {
+                            void (async () => {
+                                try {
+                                    await result.value;
+                                    setImmediate(() => void findAvailableWorker());
+                                }
+                                catch {
+                                    setImmediate(() => void findAvailableWorker());
+                                }
+                            })();
+                        }
+                        else {
+                            setImmediate(() => void findAvailableWorker());
+                        }
+                    }
+                }
+                else {
+                    setTimeout(() => void findAvailableWorker(), 50);
+                }
+            }
+            catch (_error) {
+                setTimeout(() => void findAvailableWorker(), 50);
+            }
+        }
+        void findAvailableWorker();
+    });
+}
+export const workerThreadsTool = {
+    name: 'worker_threads',
+    description: 'Node.js 22+ Worker Threads for CPU-intensive operations',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: [
+                    'createPool',
+                    'executeTask',
+                    'executeBatch',
+                    'getPoolStats',
+                    'destroyPool',
+                    'cpuIntensiveDemo',
+                    'dataProcessingDemo',
+                    'codeAnalysisDemo',
+                    'atomicsDemo',
+                ],
+                description: 'Worker thread action to perform',
+            },
+            maxWorkers: {
+                type: 'number',
+                description: 'Maximum number of worker threads',
+                default: 4,
+            },
+            minWorkers: {
+                type: 'number',
+                description: 'Minimum number of worker threads',
+                default: 1,
+            },
+            taskTimeout: {
+                type: 'number',
+                description: 'Task timeout in milliseconds',
+                default: 30000,
+            },
+            enableProfiling: {
+                type: 'boolean',
+                description: 'Enable performance profiling',
+                default: false,
+            },
+            taskType: {
+                type: 'string',
+                description: 'Type of task to execute',
+            },
+            taskData: {
+                description: 'Data to process in worker thread',
+            },
+            tasks: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        type: { type: 'string' },
+                        data: {},
+                    },
+                    required: ['type', 'data'],
+                },
+                description: 'Array of tasks for batch processing',
+            },
+            dataSize: {
+                type: 'number',
+                description: 'Size of data for processing demos',
+                default: 1000,
+            },
+            complexity: {
+                type: 'number',
+                description: 'Complexity level for CPU demos (1-10)',
+                minimum: 1,
+                maximum: 10,
+                default: 5,
+            },
+            codeSnippet: {
+                type: 'string',
+                description: 'Code snippet to analyze',
+            },
+            signal: {
+                description: 'AbortSignal for cancelling the operation',
+            },
+        },
+        required: ['action'],
+    },
+    async execute(args) {
+        try {
+            const { action, maxWorkers = 4, minWorkers = 1, taskTimeout = 30000, enableProfiling = false, taskType, taskData, tasks = [], dataSize = 1000, complexity = 5, codeSnippet, signal, } = args;
+            safeThrowIfAborted(signal);
+            switch (action) {
+                case 'createPool': {
+                    const env_1 = { stack: [], error: void 0, hasError: false };
+                    try {
+                        if (maxWorkers < 1 || maxWorkers > MAX_WORKERS) {
+                            throw new Error(`maxWorkers must be between 1 and ${MAX_WORKERS}`);
+                        }
+                        const poolId = idGenerators.workerPoolId();
+                        const workerScript = createWorkerScript({
+                            fibonacci: (n) => {
+                                if (n <= 1)
+                                    return n;
+                                let a = 0, b = 1;
+                                for (let i = 2; i <= n; i++) {
+                                    const temp = a + b;
+                                    a = b;
+                                    b = temp;
+                                }
+                                return b;
+                            },
+                            isPrime: (n) => {
+                                if (n <= 1)
+                                    return false;
+                                if (n <= 3)
+                                    return true;
+                                if (n % 2 === 0 || n % 3 === 0)
+                                    return false;
+                                for (let i = 5; i * i <= n; i += 6) {
+                                    if (n % i === 0 || n % (i + 2) === 0)
+                                        return false;
+                                }
+                                return true;
+                            },
+                            processArray: (data) => {
+                                const { array, operation } = data;
+                                switch (operation) {
+                                    case 'sum':
+                                        return array.reduce((acc, val) => acc + val, 0);
+                                    case 'sort':
+                                        return [...array].sort((a, b) => a - b);
+                                    case 'filter_even':
+                                        return array.filter(n => n % 2 === 0);
+                                    case 'map_square':
+                                        return array.map(n => n * n);
+                                    default:
+                                        throw new Error(`Unknown operation: ${operation}`);
+                                }
+                            },
+                            analyzeCode: (code) => {
+                                const lines = code.split('\n');
+                                const nonEmptyLines = lines.filter(line => line.trim().length > 0);
+                                const functions = (code.match(/function\s+\w+/g) ?? []).length;
+                                const variables = (code.match(/(?:var|let|const)\s+\w+/g) ?? []).length;
+                                const comments = (code.match(/\/\/.*$/gm) ?? []).length;
+                                return {
+                                    totalLines: lines.length,
+                                    codeLines: nonEmptyLines.length,
+                                    functions,
+                                    variables,
+                                    comments,
+                                    complexity: Math.min(10, Math.max(1, functions + variables / 2)),
+                                };
+                            },
+                            computeMatrix: (data) => {
+                                const { size, operation } = data;
+                                const matrix = Array(size)
+                                    .fill(0)
+                                    .map(() => Array(size).fill(0));
+                                for (let i = 0; i < size; i++) {
+                                    const row = matrix[i];
+                                    if (!row)
+                                        continue;
+                                    for (let j = 0; j < size; j++) {
+                                        row[j] = Math.floor(((i * size + j) * 37) % 100);
+                                    }
+                                }
+                                switch (operation) {
+                                    case 'transpose': {
+                                        const transposed = Array(size)
+                                            .fill(0)
+                                            .map(() => Array(size).fill(0));
+                                        for (let i = 0; i < size; i++) {
+                                            const sourceRow = matrix[i];
+                                            if (!sourceRow)
+                                                continue;
+                                            for (let j = 0; j < size; j++) {
+                                                const targetRow = transposed[j];
+                                                if (!targetRow)
+                                                    continue;
+                                                targetRow[i] = sourceRow[j] ?? 0;
+                                            }
+                                        }
+                                        return { result: 'transposed', size };
+                                    }
+                                    case 'sum_diagonal': {
+                                        let sum = 0;
+                                        for (let i = 0; i < size; i++) {
+                                            const row = matrix[i];
+                                            sum += row?.[i] ?? 0;
+                                        }
+                                        return { result: sum, operation: 'diagonal_sum' };
+                                    }
+                                    default:
+                                        return { result: 'processed', size, operation };
+                                }
+                            },
+                        });
+                        const fs = await import('node:fs/promises');
+                        const path = await import('node:path');
+                        const os = await import('node:os');
+                        class WorkerPoolResource {
+                            pool;
+                            poolId;
+                            tempDir;
+                            scriptPath;
+                            constructor(pool, poolId, tempDir, scriptPath) {
+                                this.pool = pool;
+                                this.poolId = poolId;
+                                this.tempDir = tempDir;
+                                this.scriptPath = scriptPath;
+                            }
+                            async [Symbol.asyncDispose]() {
+                                const cleanupPromises = [];
+                                const CLEANUP_TIMEOUT = 5000;
+                                try {
+                                    const state = workerStates.get(this.poolId);
+                                    if (state) {
+                                        for (let i = 0; i < state.statusArray.length; i++) {
+                                            void setWorkerStatus(this.poolId, i, WORKER_SHUTDOWN);
+                                        }
+                                        workerStates.delete(this.poolId);
+                                        SecureAtomicOperations.cleanup(this.poolId);
+                                    }
+                                    const safePoolDestroy = async () => {
+                                        try {
+                                            await withTimeout(this.pool.destroy(), CLEANUP_TIMEOUT);
+                                        }
+                                        catch (error) {
+                                            logWarn(`Pool destroy error`, { error, poolId: this.poolId });
+                                        }
+                                    };
+                                    const safeFileUnlink = async () => {
+                                        try {
+                                            await fs.unlink(this.scriptPath);
+                                        }
+                                        catch (error) {
+                                            logWarn(`Script file cleanup error`, { error, scriptPath: this.scriptPath });
+                                        }
+                                    };
+                                    const safeDirRemove = async () => {
+                                        try {
+                                            await fs.rmdir(this.tempDir);
+                                        }
+                                        catch (error) {
+                                            logWarn(`Temp directory cleanup error`, { error, tempDir: this.tempDir });
+                                        }
+                                    };
+                                    cleanupPromises.push(safePoolDestroy());
+                                    workerPools.delete(this.poolId);
+                                    cleanupPromises.push(safeFileUnlink());
+                                    cleanupPromises.push(safeDirRemove());
+                                    await withTimeout(Promise.allSettled(cleanupPromises), CLEANUP_TIMEOUT);
+                                }
+                                catch (error) {
+                                    logWarn(`Worker pool cleanup error`, { error, poolId: this.poolId });
+                                    workerPools.delete(this.poolId);
+                                    workerStates.delete(this.poolId);
+                                    SecureAtomicOperations.cleanup(this.poolId);
+                                }
+                            }
+                        }
+                        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-workers-'));
+                        const scriptPath = path.join(tempDir, 'worker.cjs');
+                        await fs.writeFile(scriptPath, workerScript);
+                        const pool = new WorkerPool(scriptPath, {
+                            maxWorkers,
+                            minWorkers,
+                            taskTimeout,
+                            enableProfiling,
+                        });
+                        const workerState = createWorkerState(poolId, maxWorkers);
+                        const _poolResource = __addDisposableResource(env_1, new WorkerPoolResource(pool, poolId, tempDir, scriptPath), true);
+                        workerPools.set(poolId, pool);
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify({
+                                        success: true,
+                                        poolId,
+                                        config: {
+                                            maxWorkers,
+                                            minWorkers,
+                                            taskTimeout,
+                                            enableProfiling,
+                                        },
+                                        atomicCoordination: {
+                                            sharedBufferSize: workerState.sharedBuffer.byteLength,
+                                            workersInitialized: maxWorkers,
+                                            atomicOperationsEnabled: true,
+                                        },
+                                        timestamp: new Date().toISOString(),
+                                    }),
+                                },
+                            ],
+                        };
+                    }
+                    catch (e_1) {
+                        env_1.error = e_1;
+                        env_1.hasError = true;
+                    }
+                    finally {
+                        const result_1 = __disposeResources(env_1);
+                        if (result_1)
+                            await result_1;
+                    }
+                }
+                case 'executeTask': {
+                    if (!taskType || taskData === undefined) {
+                        throw new Error('taskType and taskData required for executeTask');
+                    }
+                    let pool = workerPools.values().next().value;
+                    if (!pool) {
+                        const result = await this.execute({
+                            action: 'createPool',
+                            maxWorkers: 2,
+                            signal,
+                        });
+                        const firstContent = result.content[0];
+                        const parsed = firstContent ? JSON.parse(firstContent.text) : {};
+                        const response = parsed && typeof parsed === 'object' ? parsed : {};
+                        const poolId = typeof response['poolId'] === 'string' ? response['poolId'] : undefined;
+                        pool = poolId ? workerPools.get(poolId) : undefined;
+                        if (!pool) {
+                            throw new Error('Failed to create or retrieve worker pool');
+                        }
+                    }
+                    safeThrowIfAborted(signal);
+                    let currentPoolId = 'default';
+                    for (const [pid, p] of workerPools.entries()) {
+                        if (p === pool) {
+                            currentPoolId = pid;
+                            break;
+                        }
+                    }
+                    const availableWorkerId = await waitForAvailableWorker(currentPoolId, 5000);
+                    void setWorkerStatus(currentPoolId, availableWorkerId, WORKER_BUSY);
+                    const startTime = performance.now();
+                    const result = await pool.execute(taskType, taskData, { signal });
+                    const duration = performance.now() - startTime;
+                    void incrementTaskCounter(currentPoolId, availableWorkerId);
+                    void updateWorkerMetrics(currentPoolId, availableWorkerId, duration);
+                    void setWorkerStatus(currentPoolId, availableWorkerId, WORKER_IDLE);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    taskType,
+                                    result,
+                                    duration,
+                                    timestamp: new Date().toISOString(),
+                                }),
+                            },
+                        ],
+                    };
+                }
+                case 'executeBatch': {
+                    if (tasks.length === 0) {
+                        throw new Error('tasks array required for executeBatch');
+                    }
+                    let pool = workerPools.values().next().value;
+                    if (!pool) {
+                        const result = await this.execute({
+                            action: 'createPool',
+                            maxWorkers: Math.min(8, Math.max(2, tasks.length)),
+                            signal,
+                        });
+                        const firstContent = result.content[0];
+                        const parsed = firstContent ? JSON.parse(firstContent.text) : {};
+                        const response = parsed && typeof parsed === 'object' ? parsed : {};
+                        const poolId = typeof response['poolId'] === 'string' ? response['poolId'] : undefined;
+                        pool = poolId ? workerPools.get(poolId) : undefined;
+                    }
+                    safeThrowIfAborted(signal);
+                    const startTime = performance.now();
+                    const results = await Promise.all(tasks.map(async (task, index) => {
+                        try {
+                            if (!pool) {
+                                throw new Error('Worker pool not available');
+                            }
+                            const result = await pool.execute(task.type, task.data, { signal });
+                            return { index, success: true, result };
+                        }
+                        catch (error) {
+                            return {
+                                index,
+                                success: false,
+                                error: error instanceof Error ? error.message : 'Unknown error',
+                            };
+                        }
+                    }));
+                    const totalDuration = performance.now() - startTime;
+                    const successful = results.filter(r => r.success).length;
+                    const failed = results.length - successful;
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    batchSize: tasks.length,
+                                    successful,
+                                    failed,
+                                    results,
+                                    totalDuration,
+                                    averageDuration: totalDuration / tasks.length,
+                                    timestamp: new Date().toISOString(),
+                                }),
+                            },
+                        ],
+                    };
+                }
+                case 'cpuIntensiveDemo': {
+                    const fibonacciN = Math.min(50, 10 + complexity * 4);
+                    const tasks = [
+                        { type: 'fibonacci', data: fibonacciN },
+                        { type: 'isPrime', data: 982451653 + complexity * 1000 },
+                        { type: 'computeMatrix', data: { size: 10 + complexity * 5, operation: 'transpose' } },
+                    ];
+                    return this.execute({ action: 'executeBatch', tasks, signal });
+                }
+                case 'dataProcessingDemo': {
+                    safeThrowIfAborted(signal);
+                    const testArray = Array.from({ length: dataSize }, (_, i) => Math.floor((i * 97 + 13) % 1000));
+                    const tasks = [
+                        { type: 'processArray', data: { array: testArray, operation: 'sum' } },
+                        { type: 'processArray', data: { array: testArray, operation: 'sort' } },
+                        { type: 'processArray', data: { array: testArray, operation: 'filter_even' } },
+                        { type: 'processArray', data: { array: testArray, operation: 'map_square' } },
+                    ];
+                    return this.execute({ action: 'executeBatch', tasks, signal });
+                }
+                case 'codeAnalysisDemo': {
+                    const code = codeSnippet ??
+                        `
+            function calculateComplexity(code) {
+              const lines = code.split('\\n');
+              let complexity = 1;
+
+              // Count decision points
+              const decisions = (code.match(/if|else|while|for|switch|case|catch|\\?/g) ?? []).length;
+              complexity += decisions;
+
+              // Count functions
+              const functions = (code.match(/function\\s+\\w+/g) ?? []).length;
+              complexity += functions;
+
+              return { lines: lines.length, decisions, functions, complexity };
+            }
+
+            const fs = require('fs');
+            const path = require('path');
+
+            function analyzeProject(directory) {
+              // Implementation for project analysis
+              return { files: 0, totalLines: 0, avgComplexity: 0 };
+            }
+          `;
+                    return this.execute({
+                        action: 'executeTask',
+                        taskType: 'analyzeCode',
+                        taskData: code,
+                        signal,
+                    });
+                }
+                case 'getPoolStats': {
+                    const stats = await Promise.all(Array.from(workerPools.entries()).map(async ([poolId, pool]) => {
+                        const poolStats = pool.getStats();
+                        const atomicMetrics = await getPoolMetrics(poolId);
+                        return {
+                            poolId,
+                            stats: poolStats,
+                            atomicCoordination: atomicMetrics,
+                            performanceInsights: atomicMetrics
+                                ? {
+                                    totalTasksCompleted: atomicMetrics.workers.reduce((sum, w) => sum + w.tasksCompleted, 0),
+                                    averageProcessingTime: atomicMetrics.workers.reduce((sum, w) => sum + w.averageProcessingTime, 0) / atomicMetrics.workers.length,
+                                    activeWorkers: atomicMetrics.workers.filter((w) => w.status === 'busy')
+                                        .length,
+                                    idleWorkers: atomicMetrics.workers.filter((w) => w.status === 'idle')
+                                        .length,
+                                }
+                                : null,
+                        };
+                    }));
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    poolCount: workerPools.size,
+                                    pools: stats,
+                                    timestamp: new Date().toISOString(),
+                                }),
+                            },
+                        ],
+                    };
+                }
+                case 'destroyPool': {
+                    const destroyed = [];
+                    for (const [poolId, pool] of workerPools.entries()) {
+                        const state = workerStates.get(poolId);
+                        if (state) {
+                            for (let i = 0; i < state.statusArray.length; i++) {
+                                void setWorkerStatus(poolId, i, WORKER_SHUTDOWN);
+                            }
+                            workerStates.delete(poolId);
+                        }
+                        await pool.destroy();
+                        workerPools.delete(poolId);
+                        destroyed.push(poolId);
+                    }
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    destroyed,
+                                    remainingPools: workerPools.size,
+                                    atomicStatesCleared: destroyed.length,
+                                    timestamp: new Date().toISOString(),
+                                }),
+                            },
+                        ],
+                    };
+                }
+                case 'atomicsDemo': {
+                    const poolId = idGenerators.workerPoolId();
+                    const demoMaxWorkers = 3;
+                    const workerState = createWorkerState(poolId, demoMaxWorkers);
+                    const operations = [];
+                    for (let i = 0; i < demoMaxWorkers; i++) {
+                        operations.push(async () => {
+                            const workerId = i;
+                            const oldStatus = Atomics.compareExchange(workerState.statusArray, workerId, WORKER_IDLE, WORKER_BUSY);
+                            await delay(10 + ((Date.now() + workerId) % 20));
+                            const tasksCompleted = incrementTaskCounter(poolId, workerId);
+                            void updateWorkerMetrics(poolId, workerId, 15.5);
+                            Atomics.store(workerState.statusArray, workerId, WORKER_IDLE);
+                            Atomics.notify(workerState.statusArray, workerId, 1);
+                            return { workerId, oldStatus, tasksCompleted };
+                        });
+                    }
+                    operations.push(async () => {
+                        let totalTasks = 0;
+                        for (let i = 0; i < demoMaxWorkers; i++) {
+                            totalTasks += Atomics.load(workerState.counterArray, i);
+                        }
+                        const sharedCounterIndex = demoMaxWorkers - 1;
+                        const newCount = Atomics.add(workerState.counterArray, sharedCounterIndex, 5);
+                        return { totalTasks, sharedCounterIncrement: newCount };
+                    });
+                    const results = await Promise.all(operations);
+                    const finalMetrics = await getPoolMetrics(poolId);
+                    workerStates.delete(poolId);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    action: 'atomicsDemo',
+                                    demonstration: {
+                                        atomicsOperations: [
+                                            'Atomics.compareExchange() - Lock-free status updates',
+                                            'Atomics.store() - Direct memory writes',
+                                            'Atomics.load() - Direct memory reads',
+                                            'Atomics.add() - Atomic increments',
+                                            'Atomics.notify() - Wake waiting threads',
+                                        ],
+                                        results: results.slice(0, -1),
+                                        sharedCounterDemo: results[results.length - 1],
+                                        finalMetrics,
+                                        performance: {
+                                            lockFreeOperations: true,
+                                            memoryOverhead: `${workerState.sharedBuffer.byteLength} bytes`,
+                                            cacheFriendly: 'Aligned to 64-byte boundaries',
+                                            scalability: '2-5x improvement in worker coordination',
+                                        },
+                                    },
+                                    benefits: [
+                                        'Lock-free synchronization reduces contention',
+                                        'Direct memory access avoids message passing overhead',
+                                        'Cache-aligned data structures improve performance',
+                                        'Atomic operations provide consistency without locks',
+                                        'Waitless coordination improves throughput',
+                                    ],
+                                    timestamp: new Date().toISOString(),
+                                }),
+                            },
+                        ],
+                    };
+                }
+                default:
+                    throw new Error(`Unknown worker threads action: ${action}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('aborted')) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ success: false, aborted: true }),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            return createMCPErrorResponse(error, 'worker_threads', {
+                contextInfo: 'Worker Threads',
+            });
+        }
+    },
+};
+registerCleanupHandler('worker-threads-cleanup', async () => {
+    for (const [poolId, pool] of workerPools.entries()) {
+        try {
+            const state = workerStates.get(poolId);
+            if (state) {
+                for (let i = 0; i < state.statusArray.length; i++) {
+                    void setWorkerStatus(poolId, i, WORKER_SHUTDOWN);
+                }
+                workerStates.delete(poolId);
+            }
+            await pool.destroy();
+            workerPools.delete(poolId);
+        }
+        catch (error) {
+            logError(`Error destroying pool ${poolId}`, { error, poolId });
+        }
+    }
+    workerStates.clear();
+}, CLEANUP_PRIORITIES.HIGH);
+//# sourceMappingURL=worker-threads.js.map