@open-core/framework 0.2.7 → 0.2.9

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/dist/runtime/server/services/services.register.js

@@ -7,6 +7,7 @@ const chat_service_1 = require("./chat.service");
 const command_service_1 = require("./core/command.service");
 const player_service_1 = require("./core/player.service");
 const principal_service_1 = require("./core/principal.service");
+const session_recovery_service_1 = require("./core/session-recovery.service");
 const http_service_1 = require("./http/http.service");
 const persistence_service_1 = require("./persistence.service");
 const command_execution_port_1 = require("./ports/command-execution.port");
@@ -60,6 +61,7 @@ function registerServicesServer(ctx) {
     }
     if (features.sessionLifecycle.enabled && mode !== 'RESOURCE') {
         index_1.di.registerSingleton(persistence_service_1.PlayerPersistenceService, persistence_service_1.PlayerPersistenceService);
+        index_1.di.registerSingleton(session_recovery_service_1.SessionRecoveryService, session_recovery_service_1.SessionRecoveryService);
     }
     if (features.principal.enabled) {
         if (features.principal.provider === 'local' || mode === 'CORE' || mode === 'STANDALONE') {

package/dist/runtime/server/types/internal-events.d.ts

@@ -14,9 +14,15 @@ export interface TransferCompletedPayload {
 export interface PlayerFullyConnectedPayload {
     player: Player;
 }
+export interface PlayerSessionRecoveredPayload {
+    clientId: number;
+    player: Player;
+    license: string | undefined;
+}
 export type InternalEventMap = {
     'internal:playerSessionCreated': PlayerSessionCreatedPayload;
     'internal:playerSessionDestroyed': PlayerSessionDestroyedPayload;
     'internal:transfer:completed': TransferCompletedPayload;
     'internal:playerFullyConnected': PlayerFullyConnectedPayload;
+    'internal:playerSessionRecovered': PlayerSessionRecoveredPayload;
 };