@open-core/framework 0.2.8 → 0.2.9

package/README.md

@@ -1,3 +1,11 @@
+[![CI](https://github.com/newcore-network/opencore/actions/workflows/ci.yml/badge.svg)](https://github.com/newcore-network/opencore/actions/workflows/ci.yml)
+![npm](https://img.shields.io/npm/v/@open-core/framework?style=flat-square)
+![license](https://img.shields.io/github/license/newcore-network/opencore?style=flat-square)
+![typescript](https://img.shields.io/badge/TypeScript-first-blue?style=flat-square)
+[![cli](https://img.shields.io/badge/CLI-opencore--cli-purple?style=flat-square)](https://opencorejs.dev/docs/cli/introduction)
+[![website](https://img.shields.io/badge/web-opencorejs.dev-black?style=flat-square)](https://opencorejs.dev)
+
+
 # OpenCore Framework - Open Stable beta
 
 OpenCore is a TypeScript multiplayer runtime framework targeting FiveM via an adapter.
@@ -11,6 +19,8 @@ It is not a gamemode or RP framework. It provides:
 
 License: MPL-2.0
 
+[Discord Community](https://discord.gg/99g3FgvkPs) | [Website](https://opencorejs.dev) | [OpenCore CLI](https://github.com/newcore-network/opencore-cli)
+
 ## Scope
 
 This package (`@open-core/framework`) contains transversal infrastructure only.

package/dist/runtime/client/system/processors/nui.processor.js

@@ -20,15 +20,16 @@ let NuiProcessor = class NuiProcessor {
         RegisterNuiCallbackType(metadata.eventName);
         on(`__cfx_nui:${metadata.eventName}`, async (data, cb) => {
             try {
-                await handler(data);
-                cb({ ok: true });
+                const result = await handler(data);
+                cb({ ok: true, data: result });
             }
             catch (error) {
                 logger_1.loggers.nui.error(`NUI callback error`, {
                     event: metadata.eventName,
                     handler: handlerName,
                 }, error);
-                cb({ ok: false, error: String(error) });
+                const message = error instanceof Error ? error.message : String(error);
+                cb({ ok: false, error: message });
             }
         });
         logger_1.loggers.nui.debug(`Registered: ${metadata.eventName} -> ${handlerName}`);

package/dist/runtime/server/decorators/guard.d.ts

@@ -30,20 +30,22 @@ export interface GuardOptions {
  *
  * @throws Error - If the method is invoked without a valid `Player` as the first argument.
  *
- * @example
  * ```ts
  * @Server.Controller()
- * export class FactionController {
+ * export class AdminController {
+ *
  *   @Server.Guard({ permission: 'factions.manage' })
- *   async createFaction(player: Server.Player, dto: CreateFactionDTO) {
+ *   @Server.Command('newfaction', schema)
+ *   async createFaction(player: Server.Player, dto: Infer<typeof schema>) {
  *     return this.service.create(dto)
  *   }
  *
  *   @Server.Guard({ rank: 3 })
- *   async promoteMember(player: Server.Player, memberID: string) {
- *     return this.service.promote(player, memberID)
+ *   @Server.Command('ban')
+ *   async ban(player: Server.Player, targetID: string) {
+ *     return this.service.ban(player, memberID)
  *   }
- * }
+}
  * ```
  */
 export declare function Guard(options: GuardOptions): (target: any, propertyKey: string, descriptor?: PropertyDescriptor) => PropertyDescriptor | undefined;

package/dist/runtime/server/decorators/guard.js

@@ -25,20 +25,22 @@ const principal_port_1 = require("../services/ports/principal.port");
  *
  * @throws Error - If the method is invoked without a valid `Player` as the first argument.
  *
- * @example
  * ```ts
  * @Server.Controller()
- * export class FactionController {
+ * export class AdminController {
+ *
  *   @Server.Guard({ permission: 'factions.manage' })
- *   async createFaction(player: Server.Player, dto: CreateFactionDTO) {
+ *   @Server.Command('newfaction', schema)
+ *   async createFaction(player: Server.Player, dto: Infer<typeof schema>) {
  *     return this.service.create(dto)
  *   }
  *
  *   @Server.Guard({ rank: 3 })
- *   async promoteMember(player: Server.Player, memberID: string) {
- *     return this.service.promote(player, memberID)
+ *   @Server.Command('ban')
+ *   async ban(player: Server.Player, targetID: string) {
+ *     return this.service.ban(player, memberID)
  *   }
- * }
+}
  * ```
  */
 function Guard(options) {

package/dist/runtime/server/decorators/onNet.d.ts

@@ -48,15 +48,15 @@ type ServerNetHandler<TArgs extends any[] = any[]> = (player: Player, ...args: T
  * export class ExampleController {
  *   // Simple handler (no schema)
  *   @Server.OnNet('example:ping')
- *   ping(player: Player, message: string) { }
+ *   ping(player: Server.Player, message: string) { }
  *
  *   // With schema directly (recommended)
  *   @Server.OnNet('example:data', PayloadSchema)
- *   handleData(player: Player, data: Infer<typeof PayloadSchema>) { }
+ *   handleData(player: Server.Player, data: Infer<typeof PayloadSchema>) { }
  *
  *   // With options object (legacy)
  *   @Server.OnNet('example:legacy', { schema: PayloadSchema })
- *   handleLegacy(player: Player, data: Infer<typeof PayloadSchema>) { }
+ *   handleLegacy(player: Server.Player, data: Infer<typeof PayloadSchema>) { }
  * }
  * ```
  */

package/dist/runtime/server/services/parallel/index.d.ts

@@ -1,47 +1,3 @@
-/**
- * ParallelCompute Module
- *
- * Provides parallel computation capabilities using worker threads.
- *
- * @example
- * ```typescript
- * import {
- *   initParallelCompute,
- *   defineTask,
- *   filterByDistance,
- * } from '@open-core/framework/server'
- *
- * // Initialize the worker pool (call once at startup)
- * initParallelCompute({ maxWorkers: 4 })
- *
- * // Use built-in tasks
- * const nearby = await filterByDistance.run({
- *   entities: allEntities,
- *   position: player.coords,
- *   radius: 100,
- * })
- *
- * // Define custom tasks
- * const processPlayers = defineTask({
- *   name: 'processPlayers',
- *   estimateCost: (input) => input.length * 10,
- *   workerThreshold: 500,
- *   compute: (players) => players.map(p => ({
- *     ...p,
- *     processed: true,
- *   })),
- * })
- *
- * // Run with automatic mode selection
- * const result = await processPlayers.run(players)
- *
- * // Force sync execution
- * const resultSync = processPlayers.sync(players)
- *
- * // Force parallel execution
- * const resultParallel = await processPlayers.parallel(players)
- * ```
- */
-export { defineBatchFilter, defineBatchReduce, defineBatchTransform, defineTask, filterByDistance, findClosest, getParallelComputeService, initParallelCompute, ParallelComputeService, shutdownParallelCompute, sortByDistance, type Vector3Like, } from './parallel-compute.service';
+export { defineBatchFilter, defineBatchReduce, defineBatchTransform, defineTask, filterByDistance, findClosest, getParallelComputeService, initParallelCompute, ParallelComputeService, shutdownParallelCompute, sortByDistance, } from './parallel-compute.service';
 export type { ExecutionMode, ParallelComputeMetrics, ParallelTask, ParallelTaskOptions, TaskResult, WorkerInfo, WorkerPoolConfig, WorkerStatus, } from './types';
 export { WorkerPool } from './worker-pool';

package/dist/runtime/server/services/parallel/index.js

@@ -1,48 +1,4 @@
 "use strict";
-/**
- * ParallelCompute Module
- *
- * Provides parallel computation capabilities using worker threads.
- *
- * @example
- * ```typescript
- * import {
- *   initParallelCompute,
- *   defineTask,
- *   filterByDistance,
- * } from '@open-core/framework/server'
- *
- * // Initialize the worker pool (call once at startup)
- * initParallelCompute({ maxWorkers: 4 })
- *
- * // Use built-in tasks
- * const nearby = await filterByDistance.run({
- *   entities: allEntities,
- *   position: player.coords,
- *   radius: 100,
- * })
- *
- * // Define custom tasks
- * const processPlayers = defineTask({
- *   name: 'processPlayers',
- *   estimateCost: (input) => input.length * 10,
- *   workerThreshold: 500,
- *   compute: (players) => players.map(p => ({
- *     ...p,
- *     processed: true,
- *   })),
- * })
- *
- * // Run with automatic mode selection
- * const result = await processPlayers.run(players)
- *
- * // Force sync execution
- * const resultSync = processPlayers.sync(players)
- *
- * // Force parallel execution
- * const resultParallel = await processPlayers.parallel(players)
- * ```
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerPool = exports.sortByDistance = exports.shutdownParallelCompute = exports.ParallelComputeService = exports.initParallelCompute = exports.getParallelComputeService = exports.findClosest = exports.filterByDistance = exports.defineTask = exports.defineBatchTransform = exports.defineBatchReduce = exports.defineBatchFilter = void 0;
 // Service

package/dist/runtime/server/services/parallel/native-worker.entry.d.ts

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

package/dist/runtime/server/services/parallel/native-worker.entry.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_worker_threads_1 = require("node:worker_threads");
+const worker_1 = require("./worker");
+const port = node_worker_threads_1.parentPort;
+if (!port) {
+    throw new Error('native-worker.entry.ts must be executed inside a Worker thread');
+}
+port.on('message', (message) => {
+    const response = (0, worker_1.processMessage)(message);
+    port.postMessage(response);
+});

package/dist/runtime/server/services/parallel/parallel-compute.service.d.ts

@@ -2,12 +2,17 @@
  * ParallelCompute Service
  *
  * Provides an ergonomic API for parallel computation.
- * Uses virtual workers in FiveM environment, with async execution
- * that yields to the event loop for better performance.
+ * Uses native `node:worker_threads` to run CPU-bound work off the main thread.
  *
- * Automatically decides whether to run synchronously or asynchronously
+ * Automatically decides whether to run synchronously or in a worker
  * based on estimated computational cost.
+ *
+ * Requirements/limitations:
+ * - The compute function is serialized with `Function#toString()`.
+ * - The compute function must be pure (no closures / no external references).
+ * - Inputs/outputs must be structured-cloneable.
  */
+import { Vector3 } from '../../../../kernel';
 import { ParallelComputeMetrics, ParallelTask, ParallelTaskOptions, TaskResult, WorkerPoolConfig } from './types';
 /**
  * Service for managing parallel computation
@@ -91,33 +96,28 @@ export declare function shutdownParallelCompute(): Promise<void>;
  * Returns a task object with run, sync, parallel, and distributed methods
  */
 export declare function defineTask<TInput, TOutput>(options: ParallelTaskOptions<TInput, TOutput>): ParallelTask<TInput, TOutput>;
-export interface Vector3Like {
-    x: number;
-    y: number;
-    z: number;
-}
 /**
  * Built-in task: Filter entities by distance from a position
  */
 export declare const filterByDistance: ParallelTask<{
-    entities: Vector3Like[];
-    position: Vector3Like;
+    entities: Vector3[];
+    position: Vector3;
     radius: number;
-}, Vector3Like[]>;
+}, Vector3[]>;
 /**
  * Built-in task: Sort entities by distance from a position
  */
 export declare const sortByDistance: ParallelTask<{
-    entities: Vector3Like[];
-    position: Vector3Like;
-}, Vector3Like[]>;
+    entities: Vector3[];
+    position: Vector3;
+}, Vector3[]>;
 /**
  * Built-in task: Find closest entity to a position
  */
 export declare const findClosest: ParallelTask<{
-    entities: Vector3Like[];
-    position: Vector3Like;
-}, Vector3Like | null>;
+    entities: Vector3[];
+    position: Vector3;
+}, Vector3 | null>;
 /**
  * Built-in task: Batch transform items
  */

package/dist/runtime/server/services/parallel/parallel-compute.service.js

@@ -3,11 +3,15 @@
  * ParallelCompute Service
  *
  * Provides an ergonomic API for parallel computation.
- * Uses virtual workers in FiveM environment, with async execution
- * that yields to the event loop for better performance.
+ * Uses native `node:worker_threads` to run CPU-bound work off the main thread.
  *
- * Automatically decides whether to run synchronously or asynchronously
+ * Automatically decides whether to run synchronously or in a worker
  * based on estimated computational cost.
+ *
+ * Requirements/limitations:
+ * - The compute function is serialized with `Function#toString()`.
+ * - The compute function must be pure (no closures / no external references).
+ * - Inputs/outputs must be structured-cloneable.
  */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -308,6 +312,9 @@ function defineTask(options) {
         },
     };
 }
+// ─────────────────────────────────────────────────────────────────────────────
+// Built-in Tasks
+// ─────────────────────────────────────────────────────────────────────────────
 /**
  * Built-in task: Filter entities by distance from a position
  */

package/dist/runtime/server/services/parallel/types.d.ts

@@ -39,8 +39,11 @@ export interface ParallelTaskOptions<TInput, TOutput> {
     workerThreshold?: number;
     /**
      * The compute function to execute.
-     * MUST be pure (no closures, no external dependencies).
-     * Will be serialized and sent to worker.
+     *
+     * Requirements/limitations:
+     * - MUST be pure (no closures / no external references).
+     * - Inputs/outputs MUST be structured-cloneable.
+     * - The function body is serialized with `Function#toString()` and evaluated in a worker.
      */
     compute: (input: TInput) => TOutput;
     /**

package/dist/runtime/server/services/parallel/worker-pool.d.ts

@@ -1,9 +1,9 @@
 /**
  * Worker Pool
  *
- * Abstract worker pool that supports different backends.
- * In FiveM environment, falls back to async execution.
- * Can be extended to support native workers when available.
+ * Native worker thread pool for CPU-bound computations.
+ * Tasks are executed in `node:worker_threads` and communicated through
+ * structured-cloned messages.
  */
 import { WorkerInfo, WorkerMessage, WorkerPoolConfig } from './types';
 type EventCallback = (...args: unknown[]) => void;
@@ -23,12 +23,8 @@ export declare class WorkerPool extends SimpleEventEmitter {
     private workerIdCounter;
     private cleanupInterval;
     private isShuttingDown;
-    private useNativeWorkers;
+    private workerScriptPath;
     constructor(config?: Partial<WorkerPoolConfig>);
-    /**
-     * Detect if native worker threads are available
-     */
-    private detectWorkerSupport;
     /**
      * Check if using native workers
      */
@@ -56,7 +52,7 @@ export declare class WorkerPool extends SimpleEventEmitter {
      */
     shutdown(): Promise<void>;
     /**
-     * Spawn a new virtual worker
+     * Spawn a new native worker
      */
     private spawnWorker;
     /**

package/dist/runtime/server/services/parallel/worker-pool.js

@@ -2,12 +2,47 @@
 /**
  * Worker Pool
  *
- * Abstract worker pool that supports different backends.
- * In FiveM environment, falls back to async execution.
- * Can be extended to support native workers when available.
+ * Native worker thread pool for CPU-bound computations.
+ * Tasks are executed in `node:worker_threads` and communicated through
+ * structured-cloned messages.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerPool = void 0;
+const path = __importStar(require("node:path"));
+const node_worker_threads_1 = require("node:worker_threads");
 const DEFAULT_CONFIG = {
     minWorkers: 0,
     maxWorkers: 4,
@@ -46,16 +81,41 @@ class SimpleEventEmitter {
     }
 }
 /**
- * Virtual worker that executes tasks asynchronously
- * Used as fallback when native workers aren't available
+ * Native worker backed by `node:worker_threads`.
+ *
+ * Executes one task at a time and returns `WorkerResponse` coming from the
+ * worker entrypoint.
  */
-class VirtualWorker {
-    constructor(id) {
+class NativeWorker {
+    constructor(id, workerScriptPath, callbacks) {
         this._status = 'idle';
         this.tasksCompleted = 0;
         this.lastActiveAt = Date.now();
         this.currentTask = null;
+        this.pendingResponses = new Map();
         this.id = id;
+        this.worker = new node_worker_threads_1.Worker(workerScriptPath);
+        this.worker.on('message', (response) => {
+            const handlers = this.pendingResponses.get(response.id);
+            if (handlers) {
+                this.pendingResponses.delete(response.id);
+                handlers.resolve(response);
+            }
+        });
+        this.worker.on('error', (error) => {
+            this.failAllPending(error instanceof Error ? error : new Error(String(error)));
+            this._status = 'terminated';
+            this.currentTask = null;
+            callbacks.onError(this.id, error instanceof Error ? error : new Error(String(error)));
+        });
+        this.worker.on('exit', (code) => {
+            if (this._status !== 'terminated') {
+                this.failAllPending(new Error(`Worker exited with code ${code}`));
+            }
+            this._status = 'terminated';
+            this.currentTask = null;
+            callbacks.onExit(this.id, code);
+        });
     }
     get status() {
         return this._status;
@@ -71,40 +131,52 @@ class VirtualWorker {
         };
     }
     async execute(task) {
+        if (this._status === 'terminated') {
+            throw new Error('Worker is terminated');
+        }
         this._status = 'busy';
         this.currentTask = task;
-        const startTime = performance.now();
-        try {
-            // Execute the function
-            const fn = new Function('input', `return (${task.message.functionBody})(input)`);
-            const result = fn(task.message.input);
-            const executionTime = performance.now() - startTime;
-            this.tasksCompleted++;
-            this.lastActiveAt = Date.now();
-            this._status = 'idle';
-            this.currentTask = null;
-            return {
-                id: task.id,
-                success: true,
-                result,
-                executionTime,
-            };
-        }
-        catch (error) {
-            const executionTime = performance.now() - startTime;
-            this._status = 'idle';
-            this.currentTask = null;
-            return {
-                id: task.id,
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                executionTime,
-            };
-        }
+        return new Promise((resolve, reject) => {
+            this.pendingResponses.set(task.id, {
+                resolve: (response) => {
+                    this.tasksCompleted++;
+                    this.lastActiveAt = Date.now();
+                    this._status = 'idle';
+                    this.currentTask = null;
+                    resolve(response);
+                },
+                reject: (error) => {
+                    this._status = 'idle';
+                    this.currentTask = null;
+                    reject(error);
+                },
+            });
+            this.worker.postMessage(task.message);
+        });
     }
     terminate() {
         this._status = 'terminated';
         this.currentTask = null;
+        void this.worker.terminate();
+    }
+    cancelTask(taskId, reason) {
+        const handlers = this.pendingResponses.get(taskId);
+        if (handlers) {
+            this.pendingResponses.delete(taskId);
+            handlers.reject(reason);
+        }
+    }
+    failAllPending(error) {
+        const handlers = Array.from(this.pendingResponses.values());
+        this.pendingResponses.clear();
+        for (const h of handlers) {
+            try {
+                h.reject(error);
+            }
+            catch (_a) {
+                // ignore
+            }
+        }
     }
 }
 class WorkerPool extends SimpleEventEmitter {
@@ -115,10 +187,8 @@ class WorkerPool extends SimpleEventEmitter {
         this.workerIdCounter = 0;
         this.cleanupInterval = null;
         this.isShuttingDown = false;
-        this.useNativeWorkers = false;
         this.config = Object.assign(Object.assign({}, DEFAULT_CONFIG), config);
-        // Check if native workers are available
-        this.detectWorkerSupport();
+        this.workerScriptPath = path.join(__dirname, 'native-worker.entry.js');
         // Start cleanup interval
         this.cleanupInterval = setInterval(() => this.cleanupIdleWorkers(), 10000);
         // Spawn minimum workers
@@ -126,24 +196,11 @@ class WorkerPool extends SimpleEventEmitter {
             this.spawnWorker();
         }
     }
-    /**
-     * Detect if native worker threads are available
-     */
-    detectWorkerSupport() {
-        try {
-            // Try to detect worker_threads module
-            // In FiveM this will fail, which is expected
-            this.useNativeWorkers = false;
-        }
-        catch (_a) {
-            this.useNativeWorkers = false;
-        }
-    }
     /**
      * Check if using native workers
      */
     get isNative() {
-        return this.useNativeWorkers;
+        return true;
     }
     /**
      * Execute a task
@@ -160,6 +217,7 @@ class WorkerPool extends SimpleEventEmitter {
                 reject,
                 startTime: Date.now(),
                 timeoutId: null,
+                settled: false,
             };
             // Set timeout
             task.timeoutId = setTimeout(() => {
@@ -201,7 +259,7 @@ class WorkerPool extends SimpleEventEmitter {
             idleWorkers: idle,
             busyWorkers: busy,
             queuedTasks: this.taskQueue.length,
-            isNative: this.useNativeWorkers,
+            isNative: true,
         };
     }
     /**
@@ -233,12 +291,33 @@ class WorkerPool extends SimpleEventEmitter {
         this.workers.clear();
     }
     /**
-     * Spawn a new virtual worker
+     * Spawn a new native worker
      */
     spawnWorker() {
         try {
             const id = this.workerIdCounter++;
-            const worker = new VirtualWorker(id);
+            const worker = new NativeWorker(id, this.workerScriptPath, {
+                onExit: (workerId, code) => {
+                    const existing = this.workers.get(workerId);
+                    if (!existing)
+                        return;
+                    this.workers.delete(workerId);
+                    this.emit('workerExit', { workerId, code: code !== null && code !== void 0 ? code : 0 });
+                    if (!this.isShuttingDown && this.workers.size < this.config.minWorkers) {
+                        this.spawnWorker();
+                    }
+                },
+                onError: (workerId, error) => {
+                    const existing = this.workers.get(workerId);
+                    if (!existing)
+                        return;
+                    this.workers.delete(workerId);
+                    this.emit('workerExit', { workerId, code: 1, error: error.message });
+                    if (!this.isShuttingDown && this.workers.size < this.config.minWorkers) {
+                        this.spawnWorker();
+                    }
+                },
+            });
             this.workers.set(id, worker);
             this.emit('workerSpawned', id);
             return worker;
@@ -266,10 +345,17 @@ class WorkerPool extends SimpleEventEmitter {
             const response = await worker.execute(task);
             if (task.timeoutId)
                 clearTimeout(task.timeoutId);
+            if (task.settled) {
+                // Task was already rejected (e.g. timeout). Ignore late responses.
+                this.processQueue();
+                return;
+            }
             if (response.success) {
+                task.settled = true;
                 task.resolve(response.result);
             }
             else {
+                task.settled = true;
                 task.reject(new Error(response.error || 'Unknown worker error'));
             }
             this.emit('taskCompleted', {
@@ -283,14 +369,38 @@ class WorkerPool extends SimpleEventEmitter {
         catch (error) {
             if (task.timeoutId)
                 clearTimeout(task.timeoutId);
-            task.reject(error instanceof Error ? error : new Error(String(error)));
+            if (!task.settled) {
+                task.settled = true;
+                task.reject(error instanceof Error ? error : new Error(String(error)));
+            }
         }
     }
     /**
      * Handle task timeout
      */
     handleTaskTimeout(task) {
-        task.reject(new Error('Task timeout'));
+        const timeoutError = new Error('Task timeout');
+        if (task.timeoutId) {
+            clearTimeout(task.timeoutId);
+            task.timeoutId = null;
+        }
+        if (!task.settled) {
+            task.settled = true;
+            task.reject(timeoutError);
+        }
+        // Try to terminate the worker that was executing this task.
+        for (const [id, worker] of this.workers) {
+            if (worker.info.currentTaskId === task.id) {
+                worker.cancelTask(task.id, timeoutError);
+                worker.terminate();
+                this.workers.delete(id);
+                this.emit('workerExit', { workerId: id, code: 1 });
+                if (!this.isShuttingDown && this.workers.size < this.config.minWorkers) {
+                    this.spawnWorker();
+                }
+                break;
+            }
+        }
         // Remove from queue if present
         const queueIndex = this.taskQueue.findIndex((t) => t.id === task.id);
         if (queueIndex !== -1) {

package/dist/runtime/server/services/parallel/worker.d.ts

@@ -1,12 +1,15 @@
 /**
  * Worker Script
  *
- * This file is reserved for future native worker thread support.
- * Currently, the WorkerPool uses virtual workers that execute
- * tasks asynchronously on the main thread with yielding.
+ * Utilities used by the native worker thread entrypoint.
  *
- * When FiveM or the target environment supports native worker threads,
- * this script can be used as the worker entry point.
+ * The worker pool executes user-provided compute functions by serializing the
+ * function body (`Function#toString()`) and evaluating it with `new Function`.
+ *
+ * Requirements/limitations:
+ * - The compute function must be pure (no closures / no external references).
+ * - Inputs/outputs must be structured-cloneable.
+ * - Do not pass untrusted code as compute functions.
  */
 import { WorkerMessage, WorkerResponse } from './types';
 /**

package/dist/runtime/server/services/parallel/worker.js

@@ -2,12 +2,15 @@
 /**
  * Worker Script
  *
- * This file is reserved for future native worker thread support.
- * Currently, the WorkerPool uses virtual workers that execute
- * tasks asynchronously on the main thread with yielding.
+ * Utilities used by the native worker thread entrypoint.
  *
- * When FiveM or the target environment supports native worker threads,
- * this script can be used as the worker entry point.
+ * The worker pool executes user-provided compute functions by serializing the
+ * function body (`Function#toString()`) and evaluating it with `new Function`.
+ *
+ * Requirements/limitations:
+ * - The compute function must be pure (no closures / no external references).
+ * - Inputs/outputs must be structured-cloneable.
+ * - Do not pass untrusted code as compute functions.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeCompute = executeCompute;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-core/framework",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Secure, Event-Driven, OOP Engine for FiveM. Stop scripting, start engineering.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,7 +9,7 @@
     "type": "git",
     "url": "git+https://github.com/newcore-network/opencore.git"
   },
-  "homepage": "https://github.com/newcore-network/opencore",
+  "homepage": "https://opencorejs.dev",
   "bugs": {
     "url": "https://github.com/newcore-network/opencore/issues"
   },