@open-core/framework 0.1.0-alpha.1 → 0.2.0-beta.1

package/dist/runtime/server/services/core/vehicle.service.js

@@ -0,0 +1,391 @@
+'use strict'
+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
+    if (typeof Reflect === 'object' && typeof Reflect.decorate === 'function')
+      r = Reflect.decorate(decorators, target, key, desc)
+    else
+      for (var i = decorators.length - 1; i >= 0; i--)
+        if ((d = decorators[i]))
+          r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r
+    return c > 3 && r && Object.defineProperty(target, key, r), r
+  }
+var __metadata =
+  (this && this.__metadata) ||
+  ((k, v) => {
+    if (typeof Reflect === 'object' && typeof Reflect.metadata === 'function')
+      return Reflect.metadata(k, v)
+  })
+var __param =
+  (this && this.__param) ||
+  ((paramIndex, decorator) => (target, key) => {
+    decorator(target, key, paramIndex)
+  })
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.VehicleService = void 0
+const tsyringe_1 = require('tsyringe')
+const vehicle_1 = require('../../entities/vehicle')
+const logger_1 = require('../../../../kernel/shared/logger')
+const player_directory_port_1 = require('../ports/player-directory.port')
+/**
+ * Server-side service for managing vehicle entities.
+ *
+ * This service is the central authority for all vehicle operations:
+ * - Creating vehicles server-side (prevents client-side spawning abuse)
+ * - Managing vehicle registry by Network ID
+ * - Validating permissions and positions
+ * - Synchronizing vehicle state across clients
+ *
+ * @remarks
+ * All vehicle creation MUST go through this service to ensure security.
+ * Uses CreateVehicleServerSetter for server-authoritative spawning.
+ */
+let VehicleService = class VehicleService {
+  constructor(playerDirectory) {
+    this.playerDirectory = playerDirectory
+    /**
+     * Internal registry of all managed vehicles indexed by Network ID
+     */
+    this.vehiclesByNetworkId = new Map()
+  }
+  /**
+   * Creates a new vehicle on the server.
+   *
+   * This method uses CreateVehicleServerSetter to spawn the vehicle server-side,
+   * preventing client-side spawning exploits.
+   *
+   * @param options - Vehicle creation options
+   * @returns Spawn result with network ID and handle
+   */
+  async create(options) {
+    var _a
+    try {
+      const {
+        model,
+        position,
+        heading = 0,
+        plate,
+        primaryColor,
+        secondaryColor,
+        mods,
+        persistent = false,
+        ownership,
+        metadata,
+        routingBucket = 0,
+        locked = false,
+        fuel = 1.0,
+      } = options
+      const modelHash = typeof model === 'string' ? GetHashKey(model) : model
+      if (!IsModelInCdimage(modelHash) || !IsModelAVehicle(modelHash)) {
+        logger_1.coreLogger.error('Invalid vehicle model', { model, modelHash })
+        return {
+          networkId: 0,
+          handle: 0,
+          success: false,
+          error: `Invalid vehicle model: ${model}`,
+        }
+      }
+      const vehicleType = 'automobile'
+      const handle = CreateVehicleServerSetter(
+        modelHash,
+        vehicleType,
+        position.x,
+        position.y,
+        position.z,
+        heading,
+      )
+      if (!handle || handle === 0) {
+        logger_1.coreLogger.error('Failed to create vehicle', { model, position })
+        return {
+          networkId: 0,
+          handle: 0,
+          success: false,
+          error: 'Failed to create vehicle entity',
+        }
+      }
+      while (!DoesEntityExist(handle)) {
+        await new Promise((resolve) => setTimeout(resolve, 0))
+      }
+      const networkId = NetworkGetNetworkIdFromEntity(handle)
+      const vehicleOwnership = {
+        clientID: ownership === null || ownership === void 0 ? void 0 : ownership.clientID,
+        accountID: ownership === null || ownership === void 0 ? void 0 : ownership.accountID,
+        type:
+          (_a = ownership === null || ownership === void 0 ? void 0 : ownership.type) !== null &&
+          _a !== void 0
+            ? _a
+            : 'temporary',
+      }
+      const vehicle = new vehicle_1.Vehicle(
+        handle,
+        networkId,
+        vehicleOwnership,
+        persistent,
+        routingBucket,
+      )
+      if (plate) {
+        SetVehicleNumberPlateText(handle, plate)
+      }
+      if (primaryColor !== undefined || secondaryColor !== undefined) {
+        const [currentPrimary, currentSecondary] = GetVehicleColours(handle)
+        SetVehicleColours(
+          handle,
+          primaryColor !== null && primaryColor !== void 0 ? primaryColor : currentPrimary,
+          secondaryColor !== null && secondaryColor !== void 0 ? secondaryColor : currentSecondary,
+        )
+      }
+      if (mods) {
+        vehicle.applyMods(mods)
+      }
+      if (metadata) {
+        for (const [key, value] of Object.entries(metadata)) {
+          vehicle.setMetadata(key, value)
+        }
+      }
+      vehicle.setDoorsLocked(locked)
+      vehicle.setFuel(fuel)
+      if (routingBucket !== 0) {
+        vehicle.setRoutingBucket(routingBucket)
+      }
+      this.vehiclesByNetworkId.set(networkId, vehicle)
+      logger_1.coreLogger.info('Vehicle created', {
+        networkId,
+        model,
+        ownership: vehicleOwnership.type,
+        persistent,
+        totalVehicles: this.vehiclesByNetworkId.size,
+      })
+      emitNet('opencore:vehicle:created', -1, vehicle.serialize())
+      return {
+        networkId,
+        handle,
+        success: true,
+      }
+    } catch (error) {
+      logger_1.coreLogger.error('Error creating vehicle', { error, options })
+      return {
+        networkId: 0,
+        handle: 0,
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      }
+    }
+  }
+  /**
+   * Creates a vehicle for a specific player.
+   *
+   * @param clientID - Client ID of the requesting player
+   * @param options - Vehicle creation options
+   * @returns Spawn result
+   */
+  async createForPlayer(clientID, options) {
+    const player = this.playerDirectory.getByClient(clientID)
+    if (!player) {
+      return {
+        networkId: 0,
+        handle: 0,
+        success: false,
+        error: 'Player not found',
+      }
+    }
+    const ownership = {
+      clientID,
+      accountID: player.accountID,
+      type: 'player',
+    }
+    return this.create(Object.assign(Object.assign({}, options), { ownership }))
+  }
+  /**
+   * Retrieves a vehicle by its Network ID.
+   *
+   * @param networkId - Network ID of the vehicle
+   * @returns Vehicle entity or undefined
+   */
+  getByNetworkId(networkId) {
+    return this.vehiclesByNetworkId.get(networkId)
+  }
+  /**
+   * Retrieves a vehicle by its entity handle.
+   *
+   * @param handle - Entity handle
+   * @returns Vehicle entity or undefined
+   */
+  getByHandle(handle) {
+    const networkId = NetworkGetNetworkIdFromEntity(handle)
+    return this.vehiclesByNetworkId.get(networkId)
+  }
+  /**
+   * Gets all vehicles owned by a specific player.
+   *
+   * @param clientID - Client ID of the owner
+   * @returns Array of vehicles
+   */
+  getPlayerVehicles(clientID) {
+    const vehicles = []
+    for (const vehicle of this.vehiclesByNetworkId.values()) {
+      if (vehicle.ownership.clientID === clientID) {
+        vehicles.push(vehicle)
+      }
+    }
+    return vehicles
+  }
+  /**
+   * Gets all vehicles in a specific routing bucket.
+   *
+   * @param bucket - Routing bucket ID
+   * @returns Array of vehicles
+   */
+  getVehiclesInBucket(bucket) {
+    const vehicles = []
+    for (const vehicle of this.vehiclesByNetworkId.values()) {
+      if (vehicle.routingBucket === bucket) {
+        vehicles.push(vehicle)
+      }
+    }
+    return vehicles
+  }
+  /**
+   * Gets all managed vehicles.
+   *
+   * @returns Array of all vehicles
+   */
+  getAll() {
+    return Array.from(this.vehiclesByNetworkId.values())
+  }
+  /**
+   * Deletes a vehicle from the server.
+   *
+   * @param networkId - Network ID of the vehicle to delete
+   * @param requestedBy - Optional client ID for permission validation
+   * @returns Success status
+   */
+  delete(networkId, requestedBy) {
+    const vehicle = this.vehiclesByNetworkId.get(networkId)
+    if (!vehicle) {
+      return false
+    }
+    if (requestedBy !== undefined) {
+      if (vehicle.ownership.clientID !== requestedBy) {
+        logger_1.coreLogger.warn('Unauthorized vehicle deletion attempt', {
+          networkId,
+          requestedBy,
+          owner: vehicle.ownership.clientID,
+        })
+        return false
+      }
+    }
+    vehicle.delete()
+    this.vehiclesByNetworkId.delete(networkId)
+    logger_1.coreLogger.info('Vehicle deleted', {
+      networkId,
+      totalVehicles: this.vehiclesByNetworkId.size,
+    })
+    emitNet('opencore:vehicle:deleted', -1, networkId)
+    return true
+  }
+  /**
+   * Deletes all vehicles owned by a player.
+   * Useful when a player disconnects.
+   *
+   * @param clientID - Client ID of the owner
+   */
+  deletePlayerVehicles(clientID) {
+    const vehicles = this.getPlayerVehicles(clientID)
+    for (const vehicle of vehicles) {
+      this.delete(vehicle.networkId)
+    }
+  }
+  /**
+   * Validates if a player can perform an action on a vehicle.
+   *
+   * @param networkId - Network ID of the vehicle
+   * @param clientID - Client ID of the player
+   * @returns True if authorized
+   */
+  validateOwnership(networkId, clientID) {
+    const vehicle = this.vehiclesByNetworkId.get(networkId)
+    if (!vehicle) return false
+    if (vehicle.ownership.type === 'server' || vehicle.ownership.type === 'shared') {
+      return true
+    }
+    return vehicle.ownership.clientID === clientID
+  }
+  /**
+   * Validates if a player is near a vehicle.
+   *
+   * @param networkId - Network ID of the vehicle
+   * @param clientID - Client ID of the player
+   * @param maxDistance - Maximum distance in units
+   * @returns True if within range
+   */
+  validateProximity(networkId, clientID, maxDistance = 10.0) {
+    const vehicle = this.vehiclesByNetworkId.get(networkId)
+    if (!vehicle || !vehicle.exists) return false
+    const player = this.playerDirectory.getByClient(clientID)
+    if (!player) return false
+    const playerPed = GetPlayerPed(player.clientIDStr)
+    if (!playerPed || playerPed === 0) return false
+    const playerPos = GetEntityCoords(playerPed)
+    const vehiclePos = vehicle.position
+    const distance = Math.sqrt(
+      (playerPos[0] - vehiclePos.x) ** 2 +
+        (playerPos[1] - vehiclePos.y) ** 2 +
+        (playerPos[2] - vehiclePos.z) ** 2,
+    )
+    return distance <= maxDistance
+  }
+  /**
+   * Cleans up orphaned vehicles that no longer exist.
+   */
+  cleanup() {
+    const toDelete = []
+    for (const [networkId, vehicle] of this.vehiclesByNetworkId.entries()) {
+      if (!vehicle.exists) {
+        toDelete.push(networkId)
+      }
+    }
+    for (const networkId of toDelete) {
+      this.vehiclesByNetworkId.delete(networkId)
+      logger_1.coreLogger.debug('Cleaned up orphaned vehicle', { networkId })
+    }
+    if (toDelete.length > 0) {
+      logger_1.coreLogger.info('Vehicle cleanup completed', {
+        cleaned: toDelete.length,
+        remaining: this.vehiclesByNetworkId.size,
+      })
+    }
+  }
+  /**
+   * Gets the total count of managed vehicles.
+   *
+   * @returns Vehicle count
+   */
+  getCount() {
+    return this.vehiclesByNetworkId.size
+  }
+  /**
+   * Serializes all vehicles for data transfer.
+   *
+   * @returns Array of serialized vehicle data
+   */
+  serializeAll() {
+    return Array.from(this.vehiclesByNetworkId.values()).map((v) => v.serialize())
+  }
+}
+exports.VehicleService = VehicleService
+exports.VehicleService = VehicleService = __decorate(
+  [
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(player_directory_port_1.PlayerDirectoryPort)),
+    __metadata('design:paramtypes', [player_directory_port_1.PlayerDirectoryPort]),
+  ],
+  VehicleService,
+)

package/dist/runtime/server/services/default/default-net-event-security-observer.d.ts

@@ -0,0 +1,15 @@
+import { type NetEventInvalidPayloadContext, NetEventSecurityObserverContract } from '../../contracts/security/net-event-security-observer.contract';
+import { Player } from '../../entities/player';
+/**
+ * Default net-event security observer.
+ *
+ * @remarks
+ * This implementation is a no-op. Projects can provide an implementation via DI to log invalid
+ * payloads, emit metrics, or apply additional security actions.
+ */
+export declare class DefaultNetEventSecurityObserver extends NetEventSecurityObserverContract {
+    /**
+     * Called when a net event payload fails validation.
+     */
+    onInvalidPayload(_player: Player, _ctx: NetEventInvalidPayloadContext): Promise<void>;
+}

package/dist/runtime/server/services/default/default-net-event-security-observer.js

@@ -0,0 +1,28 @@
+"use strict";
+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;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultNetEventSecurityObserver = void 0;
+const tsyringe_1 = require("tsyringe");
+const net_event_security_observer_contract_1 = require("../../contracts/security/net-event-security-observer.contract");
+/**
+ * Default net-event security observer.
+ *
+ * @remarks
+ * This implementation is a no-op. Projects can provide an implementation via DI to log invalid
+ * payloads, emit metrics, or apply additional security actions.
+ */
+let DefaultNetEventSecurityObserver = class DefaultNetEventSecurityObserver extends net_event_security_observer_contract_1.NetEventSecurityObserverContract {
+    /**
+     * Called when a net event payload fails validation.
+     */
+    async onInvalidPayload(_player, _ctx) { }
+};
+exports.DefaultNetEventSecurityObserver = DefaultNetEventSecurityObserver;
+exports.DefaultNetEventSecurityObserver = DefaultNetEventSecurityObserver = __decorate([
+    (0, tsyringe_1.injectable)()
+], DefaultNetEventSecurityObserver);

package/dist/runtime/server/services/default/default-security.handler.d.ts

@@ -0,0 +1,19 @@
+import { SecurityError } from '../../../../kernel/utils/error/security.error';
+import { SecurityHandlerContract } from '../../contracts/security/security-handler.contract';
+import { Player } from '../../entities';
+/**
+ * Default implementation of the security handler.
+ *
+ * @remarks
+ * The default behavior is to log security violations. Projects can provide their own
+ * implementation via DI to apply stricter policies (kick/ban/metrics).
+ */
+export declare class DefaultSecurityHandler extends SecurityHandlerContract {
+    /**
+     * Handles a detected security violation.
+     *
+     * @param player - Player who triggered the violation.
+     * @param error - Security error describing the violation.
+     */
+    handleViolation(player: Player, error: SecurityError): Promise<void>;
+}

package/dist/{server → runtime/server}/services/default/default-security.handler.js

@@ -8,9 +8,22 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultSecurityHandler = void 0;
 const tsyringe_1 = require("tsyringe");
-const security_handler_contract_1 = require("../../templates/security/security-handler.contract");
-const logger_1 = require("../../../shared/logger");
+const logger_1 = require("../../../../kernel/shared/logger");
+const security_handler_contract_1 = require("../../contracts/security/security-handler.contract");
+/**
+ * Default implementation of the security handler.
+ *
+ * @remarks
+ * The default behavior is to log security violations. Projects can provide their own
+ * implementation via DI to apply stricter policies (kick/ban/metrics).
+ */
 let DefaultSecurityHandler = class DefaultSecurityHandler extends security_handler_contract_1.SecurityHandlerContract {
+    /**
+     * Handles a detected security violation.
+     *
+     * @param player - Player who triggered the violation.
+     * @param error - Security error describing the violation.
+     */
     async handleViolation(player, error) {
         logger_1.loggers.security.warn(`Security violation detected`, {
             playerName: player.name,

package/dist/{server → runtime/server}/services/http/http.service.js

@@ -8,7 +8,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpService = void 0;
 const tsyringe_1 = require("tsyringe");
-const utils_1 = require("../../../utils");
+const utils_1 = require("../../../../kernel/utils");
 let HttpService = class HttpService {
     /**
      * Performs an HTTP GET request to the specified URL.
@@ -78,9 +78,9 @@ let HttpService = class HttpService {
             if (err instanceof utils_1.AppError)
                 throw err;
             if (err instanceof DOMException && err.name === 'AbortError') {
-                throw new utils_1.AppError('NETWORK_ERROR', `${method} ${url} timed out after ${timeoutMs}ms`, 'external', { timeout: timeoutMs });
+                throw new utils_1.AppError('NETWORK:ERROR', `${method} ${url} timed out after ${timeoutMs}ms`, 'external', { timeout: timeoutMs });
             }
-            throw new utils_1.AppError('NETWORK_ERROR', `Network error calling ${method} ${url}`, 'external', {
+            throw new utils_1.AppError('NETWORK:ERROR', `Network error calling ${method} ${url}`, 'external', {
                 endpoint: url,
                 method,
                 cause: err instanceof Error ? err.message : String(err),
@@ -92,10 +92,10 @@ let HttpService = class HttpService {
     }
     async handleResponse(response, method, url) {
         if (!response.ok) {
-            let code = 'API_ERROR';
+            let code = 'API:ERROR';
             let errorBody = null;
             if (response.status === 401 || response.status === 403) {
-                code = 'UNAUTHORIZED';
+                code = 'AUTH:UNAUTHORIZED';
             }
             try {
                 errorBody = await response.json();

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

@@ -0,0 +1,16 @@
+export * from '../database';
+export * from './appearance.service';
+export { ChatService } from './chat.service';
+export { ConfigService } from './config.service';
+export { type HttpOptions, HttpService } from './http/http.service';
+export * from './parallel';
+export { PlayerPersistenceService } from './persistence.service';
+export * from './ports/command-execution.port';
+export * from './ports/player-directory.port';
+export * from './ports/player-session-lifecycle.port';
+export * from './ports/principal.port';
+export { RateLimiterService } from './rate-limiter.service';
+export type * from './types/linked-id';
+export * from './types/player-session.object';
+export * from './vehicle.service';
+export * from './vehicle-modification.service';

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

@@ -0,0 +1,39 @@
+"use strict";
+// Services
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimiterService = exports.PlayerPersistenceService = exports.HttpService = exports.ConfigService = exports.ChatService = void 0;
+__exportStar(require("../database"), exports);
+__exportStar(require("./appearance.service"), exports);
+var chat_service_1 = require("./chat.service");
+Object.defineProperty(exports, "ChatService", { enumerable: true, get: function () { return chat_service_1.ChatService; } });
+var config_service_1 = require("./config.service");
+Object.defineProperty(exports, "ConfigService", { enumerable: true, get: function () { return config_service_1.ConfigService; } });
+var http_service_1 = require("./http/http.service");
+Object.defineProperty(exports, "HttpService", { enumerable: true, get: function () { return http_service_1.HttpService; } });
+__exportStar(require("./parallel"), exports);
+var persistence_service_1 = require("./persistence.service");
+Object.defineProperty(exports, "PlayerPersistenceService", { enumerable: true, get: function () { return persistence_service_1.PlayerPersistenceService; } });
+__exportStar(require("./ports/command-execution.port"), exports);
+// Contract Services (Ports)
+__exportStar(require("./ports/player-directory.port"), exports);
+__exportStar(require("./ports/player-session-lifecycle.port"), exports);
+__exportStar(require("./ports/principal.port"), exports);
+var rate_limiter_service_1 = require("./rate-limiter.service");
+Object.defineProperty(exports, "RateLimiterService", { enumerable: true, get: function () { return rate_limiter_service_1.RateLimiterService; } });
+__exportStar(require("./types/player-session.object"), exports);
+__exportStar(require("./vehicle.service"), exports);
+__exportStar(require("./vehicle-modification.service"), exports);

package/dist/{server → runtime/server}/services/parallel/index.d.ts

@@ -42,8 +42,6 @@
  * const resultParallel = await processPlayers.parallel(players)
  * ```
  */
-export type { ExecutionMode, WorkerPoolConfig, ParallelTaskOptions, ParallelTask, ParallelComputeMetrics, TaskResult, WorkerInfo, WorkerStatus, } from './types';
-export { ParallelComputeService } from './parallel-compute.service';
-export { getParallelComputeService, initParallelCompute, shutdownParallelCompute, defineTask, } from './parallel-compute.service';
-export { filterByDistance, sortByDistance, findClosest, defineBatchTransform, defineBatchFilter, defineBatchReduce, type Vector3Like, } from './parallel-compute.service';
+export { defineBatchFilter, defineBatchReduce, defineBatchTransform, defineTask, filterByDistance, findClosest, getParallelComputeService, initParallelCompute, ParallelComputeService, shutdownParallelCompute, sortByDistance, type Vector3Like, } from './parallel-compute.service';
+export type { ExecutionMode, ParallelComputeMetrics, ParallelTask, ParallelTaskOptions, TaskResult, WorkerInfo, WorkerPoolConfig, WorkerStatus, } from './types';
 export { WorkerPool } from './worker-pool';

package/dist/{server → runtime/server}/services/parallel/index.js

@@ -44,24 +44,22 @@
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkerPool = exports.defineBatchReduce = exports.defineBatchFilter = exports.defineBatchTransform = exports.findClosest = exports.sortByDistance = exports.filterByDistance = exports.defineTask = exports.shutdownParallelCompute = exports.initParallelCompute = exports.getParallelComputeService = exports.ParallelComputeService = void 0;
+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
-var parallel_compute_service_1 = require("./parallel-compute.service");
-Object.defineProperty(exports, "ParallelComputeService", { enumerable: true, get: function () { return parallel_compute_service_1.ParallelComputeService; } });
 // Standalone functions
-var parallel_compute_service_2 = require("./parallel-compute.service");
-Object.defineProperty(exports, "getParallelComputeService", { enumerable: true, get: function () { return parallel_compute_service_2.getParallelComputeService; } });
-Object.defineProperty(exports, "initParallelCompute", { enumerable: true, get: function () { return parallel_compute_service_2.initParallelCompute; } });
-Object.defineProperty(exports, "shutdownParallelCompute", { enumerable: true, get: function () { return parallel_compute_service_2.shutdownParallelCompute; } });
-Object.defineProperty(exports, "defineTask", { enumerable: true, get: function () { return parallel_compute_service_2.defineTask; } });
 // Built-in tasks
-var parallel_compute_service_3 = require("./parallel-compute.service");
-Object.defineProperty(exports, "filterByDistance", { enumerable: true, get: function () { return parallel_compute_service_3.filterByDistance; } });
-Object.defineProperty(exports, "sortByDistance", { enumerable: true, get: function () { return parallel_compute_service_3.sortByDistance; } });
-Object.defineProperty(exports, "findClosest", { enumerable: true, get: function () { return parallel_compute_service_3.findClosest; } });
-Object.defineProperty(exports, "defineBatchTransform", { enumerable: true, get: function () { return parallel_compute_service_3.defineBatchTransform; } });
-Object.defineProperty(exports, "defineBatchFilter", { enumerable: true, get: function () { return parallel_compute_service_3.defineBatchFilter; } });
-Object.defineProperty(exports, "defineBatchReduce", { enumerable: true, get: function () { return parallel_compute_service_3.defineBatchReduce; } });
+var parallel_compute_service_1 = require("./parallel-compute.service");
+Object.defineProperty(exports, "defineBatchFilter", { enumerable: true, get: function () { return parallel_compute_service_1.defineBatchFilter; } });
+Object.defineProperty(exports, "defineBatchReduce", { enumerable: true, get: function () { return parallel_compute_service_1.defineBatchReduce; } });
+Object.defineProperty(exports, "defineBatchTransform", { enumerable: true, get: function () { return parallel_compute_service_1.defineBatchTransform; } });
+Object.defineProperty(exports, "defineTask", { enumerable: true, get: function () { return parallel_compute_service_1.defineTask; } });
+Object.defineProperty(exports, "filterByDistance", { enumerable: true, get: function () { return parallel_compute_service_1.filterByDistance; } });
+Object.defineProperty(exports, "findClosest", { enumerable: true, get: function () { return parallel_compute_service_1.findClosest; } });
+Object.defineProperty(exports, "getParallelComputeService", { enumerable: true, get: function () { return parallel_compute_service_1.getParallelComputeService; } });
+Object.defineProperty(exports, "initParallelCompute", { enumerable: true, get: function () { return parallel_compute_service_1.initParallelCompute; } });
+Object.defineProperty(exports, "ParallelComputeService", { enumerable: true, get: function () { return parallel_compute_service_1.ParallelComputeService; } });
+Object.defineProperty(exports, "shutdownParallelCompute", { enumerable: true, get: function () { return parallel_compute_service_1.shutdownParallelCompute; } });
+Object.defineProperty(exports, "sortByDistance", { enumerable: true, get: function () { return parallel_compute_service_1.sortByDistance; } });
 // Worker pool (for advanced usage)
 var worker_pool_1 = require("./worker-pool");
 Object.defineProperty(exports, "WorkerPool", { enumerable: true, get: function () { return worker_pool_1.WorkerPool; } });

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

@@ -8,7 +8,7 @@
  * Automatically decides whether to run synchronously or asynchronously
  * based on estimated computational cost.
  */
-import type { ParallelTaskOptions, ParallelTask, WorkerPoolConfig, ParallelComputeMetrics, TaskResult } from './types';
+import { ParallelComputeMetrics, ParallelTask, ParallelTaskOptions, TaskResult, WorkerPoolConfig } from './types';
 /**
  * Service for managing parallel computation
  */

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

@@ -209,13 +209,14 @@ let ParallelComputeService = class ParallelComputeService {
         try {
             const chunks = options.chunker(input, actualWorkerCount);
             const results = await Promise.all(chunks.map(async (chunk) => {
+                var _a;
                 const message = {
                     id: (0, uuid_1.v4)(),
                     taskName: options.name,
                     functionBody: options.compute.toString(),
                     input: chunk,
                 };
-                return this.pool.execute(message);
+                return (_a = this.pool) === null || _a === void 0 ? void 0 : _a.execute(message);
             }));
             const mergedResult = options.merger(results);
             const executionTime = performance.now() - startTime;

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

@@ -5,7 +5,7 @@
  * In FiveM environment, falls back to async execution.
  * Can be extended to support native workers when available.
  */
-import type { WorkerPoolConfig, WorkerInfo, WorkerMessage } from './types';
+import { WorkerInfo, WorkerMessage, WorkerPoolConfig } from './types';
 type EventCallback = (...args: unknown[]) => void;
 /**
  * Simple event emitter (FiveM compatible)