@open-core/framework 1.0.5-beta.1 → 1.0.5

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

@@ -5,7 +5,6 @@
  * Tasks are executed in `node:worker_threads` and communicated through
  * structured-cloned messages.
  */
-import * as path from 'node:path';
 import { Worker } from 'node:worker_threads';
 const DEFAULT_CONFIG = {
     minWorkers: 0,
@@ -56,9 +55,9 @@ class NativeWorker {
     currentTask = null;
     worker;
     pendingResponses = new Map();
-    constructor(id, workerScriptPath, callbacks) {
+    constructor(id, workerSource, callbacks) {
         this.id = id;
-        this.worker = new Worker(workerScriptPath);
+        this.worker = new Worker(workerSource, { eval: true });
         this.worker.on('message', (response) => {
             const handlers = this.pendingResponses.get(response.id);
             if (handlers) {
@@ -149,11 +148,44 @@ export class WorkerPool extends SimpleEventEmitter {
     workerIdCounter = 0;
     cleanupInterval = null;
     isShuttingDown = false;
-    workerScriptPath;
+    workerSource;
     constructor(config = {}) {
         super();
         this.config = { ...DEFAULT_CONFIG, ...config };
-        this.workerScriptPath = path.join(__dirname, 'native-worker.entry.js');
+        this.workerSource = `
+const { parentPort } = require('worker_threads')
+const { performance } = require('perf_hooks')
+
+if (!parentPort) {
+  throw new Error('native worker must be executed inside a Worker thread')
+}
+
+function executeCompute(functionBody, input) {
+  const fn = new Function('input', 'return (' + functionBody + ')(input)')
+  return fn(input)
+}
+
+parentPort.on('message', (message) => {
+  const startTime = performance.now()
+
+  try {
+    const result = executeCompute(message.functionBody, message.input)
+    parentPort.postMessage({
+      id: message.id,
+      success: true,
+      result,
+      executionTime: performance.now() - startTime,
+    })
+  } catch (error) {
+    parentPort.postMessage({
+      id: message.id,
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      executionTime: performance.now() - startTime,
+    })
+  }
+})
+`;
         // Start cleanup interval
         this.cleanupInterval = setInterval(() => this.cleanupIdleWorkers(), 10000);
         // Spawn minimum workers
@@ -261,7 +293,7 @@ export class WorkerPool extends SimpleEventEmitter {
     spawnWorker() {
         try {
             const id = this.workerIdCounter++;
-            const worker = new NativeWorker(id, this.workerScriptPath, {
+            const worker = new NativeWorker(id, this.workerSource, {
                 onExit: (workerId, code) => {
                     const existing = this.workers.get(workerId);
                     if (!existing)

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

@@ -11,6 +11,7 @@
  * - Inputs/outputs must be structured-cloneable.
  * - Do not pass untrusted code as compute functions.
  */
+import { performance } from 'node:perf_hooks';
 /**
  * Execute a compute function from its string body
  */

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

@@ -40,26 +40,40 @@ export function registerServicesServer(ctx) {
     }
     if (features.players.enabled) {
         if (features.players.provider === 'local' || mode === 'CORE') {
-            GLOBAL_CONTAINER.registerSingleton(LocalPlayerImplementation);
-            GLOBAL_CONTAINER.register(Players, { useToken: LocalPlayerImplementation });
-            GLOBAL_CONTAINER.register(PlayerSessionLifecyclePort, {
-                useToken: LocalPlayerImplementation,
-            });
+            if (!GLOBAL_CONTAINER.isRegistered(LocalPlayerImplementation)) {
+                GLOBAL_CONTAINER.registerSingleton(LocalPlayerImplementation);
+            }
+            if (!GLOBAL_CONTAINER.isRegistered(Players)) {
+                GLOBAL_CONTAINER.register(Players, { useToken: LocalPlayerImplementation });
+            }
+            if (!GLOBAL_CONTAINER.isRegistered(PlayerSessionLifecyclePort)) {
+                GLOBAL_CONTAINER.register(PlayerSessionLifecyclePort, {
+                    useToken: LocalPlayerImplementation,
+                });
+            }
         }
         else {
-            GLOBAL_CONTAINER.registerSingleton(Players, RemotePlayerImplementation);
+            if (!GLOBAL_CONTAINER.isRegistered(Players)) {
+                GLOBAL_CONTAINER.registerSingleton(Players, RemotePlayerImplementation);
+            }
         }
     }
     if (mode === 'RESOURCE' && features.players.enabled) {
-        GLOBAL_CONTAINER.register(PlayerSessionLifecyclePort, {
-            useFactory: () => {
-                throw new Error('[OpenCore] PlayerSessionLifecyclePort is not available in RESOURCE mode');
-            },
-        });
+        if (!GLOBAL_CONTAINER.isRegistered(PlayerSessionLifecyclePort)) {
+            GLOBAL_CONTAINER.register(PlayerSessionLifecyclePort, {
+                useFactory: () => {
+                    throw new Error('[OpenCore] PlayerSessionLifecyclePort is not available in RESOURCE mode');
+                },
+            });
+        }
     }
     if (features.sessionLifecycle.enabled && mode !== 'RESOURCE') {
-        GLOBAL_CONTAINER.registerSingleton(PlayerPersistenceService, PlayerPersistenceService);
-        GLOBAL_CONTAINER.registerSingleton(SessionRecoveryService, SessionRecoveryService);
+        if (!GLOBAL_CONTAINER.isRegistered(PlayerPersistenceService)) {
+            GLOBAL_CONTAINER.registerSingleton(PlayerPersistenceService, PlayerPersistenceService);
+        }
+        if (!GLOBAL_CONTAINER.isRegistered(SessionRecoveryService)) {
+            GLOBAL_CONTAINER.registerSingleton(SessionRecoveryService, SessionRecoveryService);
+        }
     }
     if (features.principal.enabled) {
         if (features.principal.provider === 'local' || mode === 'CORE' || mode === 'STANDALONE') {
@@ -67,37 +81,55 @@ export function registerServicesServer(ctx) {
             if (!GLOBAL_CONTAINER.isRegistered(PrincipalProviderContract)) {
                 GLOBAL_CONTAINER.registerSingleton(PrincipalProviderContract, DefaultPrincipalProvider);
             }
-            GLOBAL_CONTAINER.registerSingleton(LocalPrincipalService);
-            GLOBAL_CONTAINER.register(Authorization, { useToken: LocalPrincipalService });
+            if (!GLOBAL_CONTAINER.isRegistered(LocalPrincipalService)) {
+                GLOBAL_CONTAINER.registerSingleton(LocalPrincipalService);
+            }
+            if (!GLOBAL_CONTAINER.isRegistered(Authorization)) {
+                GLOBAL_CONTAINER.register(Authorization, { useToken: LocalPrincipalService });
+            }
         }
         else {
             // RESOURCE: Remote principal service delegates to CORE
-            GLOBAL_CONTAINER.registerSingleton(Authorization, RemotePrincipalImplementation);
+            if (!GLOBAL_CONTAINER.isRegistered(Authorization)) {
+                GLOBAL_CONTAINER.registerSingleton(Authorization, RemotePrincipalImplementation);
+            }
         }
     }
     if (features.commands.enabled) {
         if (features.commands.provider === 'local' || mode === 'CORE') {
             // CORE/STANDALONE: local command execution
-            GLOBAL_CONTAINER.registerSingleton(LocalCommandImplementation);
-            GLOBAL_CONTAINER.register(CommandExecutionPort, {
-                useToken: LocalCommandImplementation,
-            });
+            if (!GLOBAL_CONTAINER.isRegistered(LocalCommandImplementation)) {
+                GLOBAL_CONTAINER.registerSingleton(LocalCommandImplementation);
+            }
+            if (!GLOBAL_CONTAINER.isRegistered(CommandExecutionPort)) {
+                GLOBAL_CONTAINER.register(CommandExecutionPort, {
+                    useToken: LocalCommandImplementation,
+                });
+            }
         }
         else {
             // RESOURCE: remote command execution (delegates to CORE)
-            GLOBAL_CONTAINER.registerSingleton(CommandExecutionPort, RemoteCommandImplementation);
+            if (!GLOBAL_CONTAINER.isRegistered(CommandExecutionPort)) {
+                GLOBAL_CONTAINER.registerSingleton(CommandExecutionPort, RemoteCommandImplementation);
+            }
         }
     }
     if (features.chat.enabled) {
         if (mode === 'RESOURCE') {
             // RESOURCE: remote channel management (delegates to CORE)
-            GLOBAL_CONTAINER.registerSingleton(Channels, RemoteChannelImplementation);
+            if (!GLOBAL_CONTAINER.isRegistered(Channels)) {
+                GLOBAL_CONTAINER.registerSingleton(Channels, RemoteChannelImplementation);
+            }
         }
         else {
             // CORE/STANDALONE: local channel management
-            GLOBAL_CONTAINER.registerSingleton(Channels, LocalChannelImplementation);
+            if (!GLOBAL_CONTAINER.isRegistered(Channels)) {
+                GLOBAL_CONTAINER.registerSingleton(Channels, LocalChannelImplementation);
+            }
+        }
+        if (!GLOBAL_CONTAINER.isRegistered(Chat)) {
+            GLOBAL_CONTAINER.registerSingleton(Chat);
         }
-        GLOBAL_CONTAINER.registerSingleton(Chat);
     }
     if (!GLOBAL_CONTAINER.isRegistered(Npcs)) {
         GLOBAL_CONTAINER.registerSingleton(Npcs);

package/dist/runtime/server/system/processors/netEvent.processor.js

@@ -17,7 +17,7 @@ import { EventsAPI } from '../../../../adapters/contracts/transport/events.api';
 import { coreLogger, loggers } from '../../../../kernel/logger';
 import { NetEventSecurityObserverContract, } from '../../contracts/security/net-event-security-observer.contract';
 import { SecurityHandlerContract } from '../../contracts/security/security-handler.contract';
-import { processTupleSchema } from '../../helpers/process-tuple-schema';
+import { processTupleSchema } from '../../../shared/helpers/process-tuple-schema';
 import { resolveMethod } from '../../helpers/resolve-method';
 import { Players } from '../../ports/players.api-port';
 import { METADATA_KEYS } from '../metadata-server.keys';

package/dist/runtime/server/system/processors/onRpc.processor.js

@@ -16,7 +16,7 @@ import { AppError } from '../../../../';
 import { RpcAPI } from '../../../../adapters/contracts/transport/rpc.api';
 import { loggers } from '../../../../kernel/logger';
 import { Player } from '../../entities/player';
-import { processTupleSchema } from '../../helpers/process-tuple-schema';
+import { processTupleSchema } from '../../../shared/helpers/process-tuple-schema';
 import { resolveMethod } from '../../helpers/resolve-method';
 import { Players } from '../../ports/players.api-port';
 import { METADATA_KEYS } from '../metadata-server.keys';

package/dist/runtime/server/system/processors/runtimeEvent.processor.d.ts

@@ -1,10 +1,11 @@
 import { IEngineEvents } from '../../../../adapters/contracts/IEngineEvents';
+import type { RuntimeEventName } from '../../../../adapters/contracts/runtime';
 import { type DecoratorProcessor } from '../../../../kernel/di/index';
 export declare class RuntimeEventProcessor implements DecoratorProcessor {
     private readonly engineEvents;
     readonly metadataKey: string;
     constructor(engineEvents: IEngineEvents);
     process(instance: any, methodName: string, metadata: {
-        event: string;
+        event: RuntimeEventName;
     }): void;
 }

package/dist/runtime/server/system/processors/runtimeEvent.processor.js

@@ -26,7 +26,7 @@ let RuntimeEventProcessor = class RuntimeEventProcessor {
         if (!result)
             return;
         const { handler, handlerName } = result;
-        this.engineEvents.on(metadata.event, (...args) => {
+        this.engineEvents.onRuntime(metadata.event, (...args) => {
             try {
                 handler(...args);
             }

package/dist/runtime/server/system/schema-generator.d.ts

@@ -1,2 +1,2 @@
 import z from 'zod';
-export declare function generateSchemaFromTypes(paramTypes: any[]): z.ZodTuple | undefined;
+export declare function generateSchemaFromTypes(paramTypes: any[], defaultParams?: boolean[]): z.ZodTuple | undefined;

package/dist/runtime/server/system/schema-generator.js

@@ -19,7 +19,10 @@ function typeToZodSchema(type) {
             return undefined;
     }
 }
-export function generateSchemaFromTypes(paramTypes) {
+function applyOptional(schema, optional) {
+    return optional ? schema.optional() : schema;
+}
+export function generateSchemaFromTypes(paramTypes, defaultParams = []) {
     if (!paramTypes || paramTypes.length === 0)
         return z.tuple([]);
     if (paramTypes[0] !== Player) {
@@ -28,11 +31,11 @@ export function generateSchemaFromTypes(paramTypes) {
     if (paramTypes.length === 1)
         return z.tuple([]);
     const argSchemas = [];
-    for (const t of paramTypes.slice(1)) {
+    for (const [index, t] of paramTypes.slice(1).entries()) {
         const s = typeToZodSchema(t);
         if (!s)
             return undefined;
-        argSchemas.push(s);
+        argSchemas.push(applyOptional(s, defaultParams[index + 1] ?? false));
     }
     return z.tuple(argSchemas);
 }

package/dist/runtime/server/types/core-exports.types.d.ts

@@ -27,6 +27,11 @@ export interface SerializedPlayerData {
     meta: Record<string, unknown>;
     /** Active state flags (dead, cuffed, etc.) */
     states: string[];
+    /** Optional adapter-owned payload used to hydrate extended Player instances. */
+    adapter?: {
+        name: string;
+        payload?: Record<string, unknown>;
+    };
 }
 /**
  * Security metadata collected from decorators for remote validation.

package/dist/runtime/shared/helpers/process-tuple-schema.d.ts

@@ -0,0 +1,2 @@
+import z from 'zod';
+export declare function processTupleSchema(schema: z.ZodTuple, args: unknown[]): unknown[];

package/dist/runtime/shared/helpers/process-tuple-schema.js

@@ -0,0 +1,32 @@
+import z from 'zod';
+export function processTupleSchema(schema, args) {
+    const tupleDef = schema._def;
+    const items = schema.description ? [] : [...(tupleDef.items ?? [])];
+    if (items.length === 0) {
+        return args;
+    }
+    const lastItem = items[items.length - 1];
+    const positionalCount = items.length - 1;
+    if (args.length > items.length) {
+        if (lastItem instanceof z.ZodString) {
+            const positional = args.slice(0, positionalCount);
+            const restString = args.slice(positionalCount).map(String).join(' ');
+            return [...positional, restString];
+        }
+        if (lastItem instanceof z.ZodArray) {
+            const positional = args.slice(0, positionalCount);
+            const restArray = args.slice(positionalCount);
+            return [...positional, restArray];
+        }
+    }
+    if (args.length === items.length) {
+        if (lastItem instanceof z.ZodArray && !Array.isArray(args[positionalCount])) {
+            const positional = args.slice(0, positionalCount);
+            return [...positional, [args[positionalCount]]];
+        }
+    }
+    if (args.length < items.length) {
+        return [...args, ...Array.from({ length: items.length - args.length }, () => undefined)];
+    }
+    return args;
+}

package/dist/runtime/shared/types/system-types.d.ts

@@ -0,0 +1,55 @@
+type ValueOf<T> = T[keyof T];
+declare const SYSTEM_EVENT_NAMESPACE = "opencore";
+export type RemoteCommandExecuteEventName = `${typeof SYSTEM_EVENT_NAMESPACE}:command:execute:${string}`;
+export declare const buildRemoteCommandExecuteEventName: (resourceName: string) => RemoteCommandExecuteEventName;
+export declare const SYSTEM_EVENTS: {
+    readonly core: {
+        readonly ready: `_systemcore:${string}`;
+        readonly requestReady: `_systemcore:${string}`;
+    };
+    readonly chat: {
+        readonly message: `opencore:${string}:${string}`;
+        readonly addMessage: `opencore:${string}:${string}`;
+        readonly send: `opencore:${string}:${string}`;
+        readonly clear: `opencore:${string}:${string}`;
+    };
+    readonly command: {
+        readonly execute: `opencore:${string}:${string}`;
+    };
+    readonly spawner: {
+        readonly spawn: `opencore:${string}:${string}`;
+        readonly teleport: `opencore:${string}:${string}`;
+        readonly respawn: `opencore:${string}:${string}`;
+    };
+    readonly appearance: {
+        readonly apply: `opencore:${string}:${string}`;
+        readonly reset: `opencore:${string}:${string}`;
+    };
+    readonly vehicle: {
+        readonly create: `opencore:${string}:${string}`;
+        readonly createResult: `opencore:${string}:${string}`;
+        readonly delete: `opencore:${string}:${string}`;
+        readonly deleteResult: `opencore:${string}:${string}`;
+        readonly repair: `opencore:${string}:${string}`;
+        readonly repairResult: `opencore:${string}:${string}`;
+        readonly repaired: `opencore:${string}:${string}`;
+        readonly setLocked: `opencore:${string}:${string}`;
+        readonly getData: `opencore:${string}:${string}`;
+        readonly dataResult: `opencore:${string}:${string}`;
+        readonly getPlayerVehicles: `opencore:${string}:${string}`;
+        readonly playerVehiclesResult: `opencore:${string}:${string}`;
+        readonly created: `opencore:${string}:${string}`;
+        readonly deleted: `opencore:${string}:${string}`;
+        readonly modified: `opencore:${string}:${string}`;
+        readonly warpInto: `opencore:${string}:${string}`;
+    };
+    readonly npc: {
+        readonly deleted: `opencore:${string}:${string}`;
+    };
+    readonly session: {
+        readonly playerInit: `opencore:${string}:${string}`;
+        readonly teleportTo: `opencore:${string}:${string}`;
+    };
+};
+export type SystemEventName = ValueOf<ValueOf<typeof SYSTEM_EVENTS>>;
+export {};

package/dist/runtime/shared/types/system-types.js

@@ -0,0 +1,54 @@
+const SYSTEM_EVENT_NAMESPACE = 'opencore';
+const SYSTEM_CORE_EVENT_NAMESPACE = '_systemcore';
+const systemEvent = (scope, action) => `${SYSTEM_EVENT_NAMESPACE}:${scope}:${action}`;
+const systemCoreEvent = (action) => `${SYSTEM_CORE_EVENT_NAMESPACE}:${action}`;
+export const buildRemoteCommandExecuteEventName = (resourceName) => `${SYSTEM_EVENTS.command.execute}:${resourceName}`;
+export const SYSTEM_EVENTS = {
+    core: {
+        ready: systemCoreEvent('ready'),
+        requestReady: systemCoreEvent('request-ready'),
+    },
+    chat: {
+        message: systemEvent('chat', 'message'),
+        addMessage: systemEvent('chat', 'addMessage'),
+        send: systemEvent('chat', 'send'),
+        clear: systemEvent('chat', 'clear'),
+    },
+    command: {
+        execute: systemEvent('command', 'execute'),
+    },
+    spawner: {
+        spawn: systemEvent('spawner', 'spawn'),
+        teleport: systemEvent('spawner', 'teleport'),
+        respawn: systemEvent('spawner', 'respawn'),
+    },
+    appearance: {
+        apply: systemEvent('appearance', 'apply'),
+        reset: systemEvent('appearance', 'reset'),
+    },
+    vehicle: {
+        create: systemEvent('vehicle', 'create'),
+        createResult: systemEvent('vehicle', 'createResult'),
+        delete: systemEvent('vehicle', 'delete'),
+        deleteResult: systemEvent('vehicle', 'deleteResult'),
+        repair: systemEvent('vehicle', 'repair'),
+        repairResult: systemEvent('vehicle', 'repairResult'),
+        repaired: systemEvent('vehicle', 'repaired'),
+        setLocked: systemEvent('vehicle', 'setLocked'),
+        getData: systemEvent('vehicle', 'getData'),
+        dataResult: systemEvent('vehicle', 'dataResult'),
+        getPlayerVehicles: systemEvent('vehicle', 'getPlayerVehicles'),
+        playerVehiclesResult: systemEvent('vehicle', 'playerVehiclesResult'),
+        created: systemEvent('vehicle', 'created'),
+        deleted: systemEvent('vehicle', 'deleted'),
+        modified: systemEvent('vehicle', 'modified'),
+        warpInto: systemEvent('vehicle', 'warpInto'),
+    },
+    npc: {
+        deleted: systemEvent('npc', 'deleted'),
+    },
+    session: {
+        playerInit: systemEvent('player', 'sessionInit'),
+        teleportTo: systemEvent('player', 'teleportTo'),
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-core/framework",
-  "version": "1.0.5-beta.1",
+  "version": "1.0.5",
   "description": "Secure, event-driven TypeScript Framework & Runtime engine for CitizenFX (Cfx).",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,6 +34,26 @@
       "import": "./dist/runtime/client/index.js",
       "require": "./dist/runtime/client/index.js"
     },
+    "./contracts": {
+      "types": "./dist/contracts.d.ts",
+      "import": "./dist/contracts.js",
+      "require": "./dist/contracts.js"
+    },
+    "./contracts/client": {
+      "types": "./dist/contracts/client.d.ts",
+      "import": "./dist/contracts/client.js",
+      "require": "./dist/contracts/client.js"
+    },
+    "./contracts/server": {
+      "types": "./dist/contracts/server.d.ts",
+      "import": "./dist/contracts/server.js",
+      "require": "./dist/contracts/server.js"
+    },
+    "./kernel": {
+      "types": "./dist/kernel-public.d.ts",
+      "import": "./dist/kernel-public.js",
+      "require": "./dist/kernel-public.js"
+    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -55,12 +75,15 @@
     "bench": "npx tsx benchmark/index.ts",
     "bench:core": "npx tsx benchmark/index.ts --core",
     "bench:load": "npx vitest run --project benchmark",
-    "bench:all": "npx tsx benchmark/index.ts --all"
+    "bench:all": "npx tsx benchmark/index.ts --all",
+    "validate": "pnpm check && pnpm typecheck && pnpm test",
+    "lint-staged": "lint-staged",
+    "prepare": "husky"
   },
   "keywords": [
     "framework",
     "opencore",
-    "cfx",
+    "ragemp",
     "citizenfx",
     "redm",
     "typescript",
@@ -68,7 +91,7 @@
   ],
   "author": "OpenCore Team",
   "license": "MPL-2.0",
-  "packageManager": "pnpm@10.13.1",
+  "packageManager": "pnpm@10.33.0",
   "peerDependencies": {
     "reflect-metadata": "^0.2.2",
     "tsyringe": "^4.10.0",
@@ -78,18 +101,23 @@
     "uuid": "^13.0.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.11",
-    "@citizenfx/client": "2.0.22443-1",
-    "@citizenfx/server": "2.0.22443-1",
-    "@types/node": "^25.0.3",
-    "@vitest/coverage-v8": "^4.0.16",
-    "dependency-cruiser": "^17.3.6",
+    "@biomejs/biome": "^2.4.8",
+    "@types/node": "^25.5.0",
+    "@vitest/coverage-v8": "^4.1.1",
+    "dependency-cruiser": "^17.3.9",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-import": "^2.32.0",
     "graphviz": "^0.0.9",
-    "tinybench": "^2.9.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.6",
+    "tinybench": "^6.0.0",
     "tsx": "^4.21.0",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.1"
+  },
+  "lint-staged": {
+    "*.{js,cjs,mjs,ts,tsx,json,md}": [
+      "biome check --write --no-errors-on-unmatched"
+    ]
   }
 }

package/dist/adapters/cfx/cfx-capabilities.d.ts

@@ -1,16 +0,0 @@
-import { IPlatformCapabilities } from '../contracts/IPlatformCapabilities';
-export declare class CfxCapabilities extends IPlatformCapabilities {
-    readonly platformName = "cfx";
-    readonly displayName = "CitizenFX";
-    private readonly gameProfile;
-    readonly supportsRoutingBuckets = true;
-    readonly supportsStateBags = true;
-    readonly supportsVoiceChat = true;
-    readonly supportsServerEntities = true;
-    readonly identifierTypes: readonly ["steam", "license", "license2", "discord", "fivem", "xbl", "live", "ip", "rockstar"];
-    readonly maxPlayers = 1024;
-    private readonly supportedFeatures;
-    private readonly config;
-    isFeatureSupported(feature: string): boolean;
-    getConfig<T = unknown>(key: string): T | undefined;
-}

package/dist/adapters/cfx/cfx-capabilities.js

@@ -1,70 +0,0 @@
-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;
-};
-import { injectable } from 'tsyringe';
-import { IPlatformCapabilities, PlatformFeatures } from '../contracts/IPlatformCapabilities';
-import { IdentifierTypes } from '../contracts/types/identifier';
-import { detectCfxGameProfile } from './runtime-profile';
-let CfxCapabilities = class CfxCapabilities extends IPlatformCapabilities {
-    platformName = 'cfx';
-    displayName = 'CitizenFX';
-    gameProfile = detectCfxGameProfile();
-    supportsRoutingBuckets = true;
-    supportsStateBags = true;
-    supportsVoiceChat = true;
-    supportsServerEntities = true;
-    identifierTypes = [
-        IdentifierTypes.STEAM,
-        IdentifierTypes.LICENSE,
-        IdentifierTypes.LICENSE2,
-        IdentifierTypes.DISCORD,
-        IdentifierTypes.FIVEM,
-        IdentifierTypes.XBL,
-        IdentifierTypes.LIVE,
-        IdentifierTypes.IP,
-        IdentifierTypes.ROCKSTAR,
-    ];
-    maxPlayers = 1024;
-    supportedFeatures = new Set([
-        PlatformFeatures.ROUTING_BUCKETS,
-        PlatformFeatures.STATE_BAGS,
-        PlatformFeatures.VOICE_CHAT,
-        PlatformFeatures.SERVER_ENTITIES,
-        PlatformFeatures.BLIPS,
-        PlatformFeatures.MARKERS,
-        PlatformFeatures.TEXT_LABELS,
-        PlatformFeatures.CHECKPOINTS,
-        PlatformFeatures.COLSHAPES,
-        ...(this.gameProfile === 'gta5'
-            ? [
-                PlatformFeatures.VEHICLE_MODS,
-                PlatformFeatures.PED_APPEARANCE,
-                PlatformFeatures.WEAPON_COMPONENTS,
-            ]
-            : []),
-    ]);
-    config = {
-        runtime: 'cfx',
-        gameProfile: this.gameProfile,
-        defaultRoutingBucket: 0,
-        maxRoutingBuckets: 63,
-        tickRate: 64,
-        syncRate: 10,
-        defaultSpawnModel: this.gameProfile === 'rdr3' ? 'mp_male' : 'mp_m_freemode_01',
-        enableServerVehicleCreation: this.gameProfile !== 'rdr3',
-        defaultVehicleType: this.gameProfile === 'rdr3' ? 'automobile' : 'automobile',
-    };
-    isFeatureSupported(feature) {
-        return this.supportedFeatures.has(feature);
-    }
-    getConfig(key) {
-        return this.config[key];
-    }
-};
-CfxCapabilities = __decorate([
-    injectable()
-], CfxCapabilities);
-export { CfxCapabilities };

package/dist/adapters/cfx/cfx-platform.d.ts

@@ -1,2 +0,0 @@
-import type { PlatformAdapter } from '../platform/platform-registry';
-export declare const CfxPlatform: PlatformAdapter;