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

package/README.md

@@ -1,360 +1,288 @@
-# OpenCore Framework
+[![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)
 
-> **The robust TypeScript Engine for FiveM.**
-> Built on strong OOP principles, Layered Architecture, and Security-first design.
-> _Stop writing scripts; start engineering gameplay._
 
-[![License: MPL 2.0](https://img.shields.io/badge/License-MPL_2.0-brightgreen.svg)](https://opensource.org/licenses/MPL-2.0)
-[![Version](https://img.shields.io/badge/beta-1.0.0-orange.svg)](https://github.com/newcore-network/opencore)
-![Tests](https://img.shields.io/badge/tests-265%20passing-brightgreen)
-![Coverage](https://img.shields.io/badge/coverage-43%25-yellow)
-![Core Decorators](https://img.shields.io/badge/core%20decorators-100%25-brightgreen)
+# OpenCore Framework - Open Stable beta
 
-## 📋 Table of Contents
+OpenCore is a TypeScript multiplayer runtime framework targeting CitizenFX runtimes (Cfx) via adapters.
 
-- [Why OpenCore?](#-why-opencore)
-- [Installation](#-installation)
-- [Quick Start](#-quick-start)
-- [Security System](#️-security-system)
-- [Architecture](#️-architecture)
-- [Testing](#-testing)
-- [Performance](#-performance--benchmarks)
-- [Project Structure](#-project-structure)
-- [Scripts](#-available-scripts)
-- [License](#-license)
+It is not a gamemode or RP framework. It provides:
 
----
+- A stable execution model (server and client)
+- Dependency Injection and metadata-driven wiring
+- An event/command system
+- Security primitives (validation, access control, rate limiting)
 
-## 🚀 Why OpenCore?
+License: MPL-2.0
 
-OpenCore transforms FiveM development from chaotic scripting into professional software engineering. Inspired by enterprise frameworks like **Spring Boot** and **NestJS**, it brings structure, security, and strict typing to your server.
+[Discord Community](https://discord.gg/99g3FgvkPs) | [Docs](https://opencorejs.dev) | [OpenCore CLI](https://github.com/newcore-network/opencore-cli)
 
-### ✨ Key Features
-
-- **🛡️ Security by Design:** Built-in Input Validation (**Zod**), Rate Limiting (`@Throttle`), and Access Control (`@Guard`).
-- **🏗️ Decoupled Architecture:** Logic is separated into **Controllers**, **Services**, and **Entities**.
-- **💉 Dependency Injection:** Full IoC container powered by `tsyringe`.
-- **📝 Type-Safe:** No more guessing `source` types or argument structures.
-- **📡 Event-Driven:** Powerful Event Bus for internal and network communication.
-- **⚡ High Performance:** Sub-microsecond latencies, millions of ops/sec.
-- **🧪 Fully Tested:** Comprehensive unit, integration, and load tests.
-
----
-
-## 📦 Installation
+## Installation
 
 ```bash
 pnpm add @open-core/framework reflect-metadata tsyringe zod uuid
 ```
 
-> **Note:** Ensure you have `experimentalDecorators` and `emitDecoratorMetadata` enabled in your `tsconfig.json`.
+This framework uses TypeScript decorators. Ensure your project has decorators enabled.
 
----
+## Imports and entry points
 
-## ⚡ Quick Start
+The package exposes subpath entry points:
 
-Define a Controller, validate inputs with Zod, and protect it with a Guard. Zero boilerplate.
+- `@open-core/framework` (root)
+- `@open-core/framework/server`
+- `@open-core/framework/client`
 
-**Server-side:**
+## Architecture
 
-```ts
-import { Server } from '@open-core/framework/server'
-import { z } from 'zod'
+OpenCore follows a Ports & Adapters (Hexagonal) architecture.
 
-// 1. Define your Input Schema
-const TransferSchema = z.tuple([
-  z.coerce.number().positive(), // Target ID
-  z.coerce.number().min(1).max(50000), // Amount
-])
+- Kernel (`src/kernel`): engine-agnostic infrastructure (DI, logger, metadata scanning)
+- Runtime (`src/runtime`): multiplayer execution model (controllers, processors, security, lifecycle)
+- Adapters (`src/adapters`): platform integration (Cfx, Node testing)
 
-@Server.Controller()
-export class BankController {
-  constructor(private readonly bankService: BankService) {}
+The runtime never auto-detects the platform. Adapters are selected explicitly at bootstrap time.
 
-  @Server.Command({
-    name: 'transfer',
-    schema: TransferSchema,
-    usage: '/transfer [id] [amount]',
-  })
-  @Server.Guard({ rank: 1 }) // Must be at least Rank 1 (User)
-  @Server.Throttle(1, 2000) // Max 1 request per 2 seconds
-  async handleTransfer(player: Server.Player, args: z.infer<typeof TransferSchema>) {
-    const [targetId, amount] = args
+### Cfx game profiles
 
-    // Logic is pure and type-safe
-    await this.bankService.transfer(player, targetId, amount)
+OpenCore treats CitizenFX (`cfx`) as the platform and supports game profiles (`gta5` and `rdr3`).
 
-    player.emit('chat:message', `Successfully transferred $${amount}`)
-  }
-}
-```
-
----
+- Shared runtime APIs (events, exports, transport, DI) are registered through the Cfx adapter.
+- Game-specific behavior is controlled through platform capabilities/config (`gameProfile`, `defaultSpawnModel`, etc.).
+- Optional RedM-specific enhancements can be layered as external libraries without changing core runtime contracts.
 
-## 🛡️ Security System
+## Operating modes
 
-OpenCore handles the dirty work so you can focus on gameplay.
+Each instance runs in exactly one mode configured via `Server.init()`:
 
-### 1. Input Validation (`@Command`, `@OnNet`)
+- `CORE`: authoritative runtime. Typically provides identity/auth/players via exports.
+- `RESOURCE`: a normal Cfx resource using CORE as provider for some features.
+- `STANDALONE`: a self-contained runtime (useful for tooling, simulations, or small servers).
 
-All network inputs are validated against Zod schemas before they reach your logic. Malformed packets are rejected automatically.
+## Server bootstrap
 
-### 2. Access Control (`@Guard`)
-
-Protect methods with granular permissions or hierarchical ranks:
+Initialize the server runtime:
 
 ```ts
-@Server.Guard({ permission: 'admin.ban' })
-@Server.Guard({ rank: 10 }) // Admin level
-```
+import { Server } from '@open-core/framework/server'
 
-### 3. Rate Limiting (`@Throttle`)
+await Server.init({
+  mode: 'CORE'
+})
+```
 
-Prevent abuse with configurable rate limits:
+Some features require providers (depending on your mode and configuration). Configure them before calling `init()`:
 
 ```ts
-@Server.Throttle(5, 10000) // 5 requests per 10 seconds
+import { Server } from '@open-core/framework/server'
+
+Server.setPrincipalProvider(MyPrincipalProvider)
+Server.setSecurityHandler(MySecurityHandler)
+Server.setPersistenceProvider(MyPlayerPersistence)
+Server.setNetEventSecurityObserver(MyNetEventSecurityObserver)
 ```
 
-### 4. State Management (`@RequiresState`)
+## Controllers and decorators
 
-Avoid "dead player exploits" or interaction glitches:
+OpenCore uses a decorator + processor pattern.
 
-```ts
-@Server.RequiresState({ missing: ['dead', 'cuffed'] })
-openInventory(player: Server.Player) { ... }
-```
-
----
+Decorators store metadata with `Reflect.defineMetadata()`. During bootstrap, the `MetadataScanner` reads metadata and processors register handlers.
 
-## 🏗️ Architecture
+### Commands
 
-OpenCore follows a clean, layered architecture:
+```ts
+import { Controller, Command, Guard, Throttle, Player } from '@open-core/framework/server'
+import { z } from 'zod'
 
-| Layer           | Responsibility                                               | Example          |
-| --------------- | ------------------------------------------------------------ | ---------------- |
-| **Controllers** | Handle entry points (Commands, Events, NUI). Keep them thin. | `BankController` |
-| **Services**    | Contain business logic. Singletons injectable anywhere.      | `BankService`    |
-| **Entities**    | Wrappers around FiveM objects with rich APIs.                | `Player`         |
+const TransferSchema = z.tuple([z.coerce.number().int().positive(), z.coerce.number().min(1)])
 
-```
-┌─────────────────────────────────────────────────────────┐
-│                     Client / FiveM                       │
-└─────────────────────────┬───────────────────────────────┘
-                          │
-┌─────────────────────────▼───────────────────────────────┐
-│                    Controllers                           │
-│  @Command  @OnNet  @NUI  @GameEvent  @OnTick            │
-└─────────────────────────┬───────────────────────────────┘
-                          │
-┌─────────────────────────▼───────────────────────────────┐
-│              Security Layer (Middleware)                 │
-│  @Guard  @Throttle  @RequiresState  Zod Validation      │
-└─────────────────────────┬───────────────────────────────┘
-                          │
-┌─────────────────────────▼───────────────────────────────┐
-│                     Services                             │
-│  Business Logic  •  PlayerService  •  BankService       │
-└─────────────────────────┬───────────────────────────────┘
-                          │
-┌─────────────────────────▼───────────────────────────────┐
-│                  Core Event Bus                          │
-│  Internal Events  •  Cross-Service Communication        │
-└─────────────────────────────────────────────────────────┘
+@Controller()
+export class BankController {
+  @Command({
+    command: 'transfer',
+    usage: '/transfer <id> <amount>',
+    schema: TransferSchema,
+  })
+  @Guard({ rank: 1 })
+  @Throttle(1, 2000)
+  async transfer(player: Player, args: z.infer<typeof TransferSchema>) {
+    const [targetId, amount] = args
+    player.emit('chat:message', `transfer -> ${targetId} (${amount})`)
+  }
+}
 ```
 
----
+### Network events
 
-## 🧪 Testing
+`@OnNet()` handlers always receive `Player` as the first parameter.
 
-OpenCore has a comprehensive testing suite using **Vitest**.
+```ts
+import { Controller, OnNet, Player } from '@open-core/framework/server'
+import { z } from 'zod'
 
-### Test Categories
+const PayloadSchema = z.object({ action: z.string(), amount: z.number().int().positive() })
 
-| Category        | Description                             | Command                 |
-| --------------- | --------------------------------------- | ----------------------- |
-| **Unit**        | Individual components and decorators    | `pnpm test:unit`        |
-| **Integration** | Component interactions and bootstrap    | `pnpm test:integration` |
-| **Load**        | Performance under simulated player load | `pnpm bench:load`       |
-| **All Tests**   | Run everything                          | `pnpm test`             |
+@Controller()
+export class ExampleNetController {
+  @OnNet('bank:action', { schema: PayloadSchema })
+  async onBankAction(player: Player, payload: z.infer<typeof PayloadSchema>) {
+    player.emit('chat:message', `action=${payload.action} amount=${payload.amount}`)
+  }
+}
+```
 
-### Running Tests
+### Security decorators
 
-```bash
-# Run all tests
-pnpm test
+- `@Guard({ rank })` or `@Guard({ permission })`
+- `@Throttle(limit, windowMs)`
+- `@RequiresState({ missing: [...] })`
 
-# Run specific test suites
-pnpm test:unit
-pnpm test:integration
+### Library events
 
-# Watch mode for development
-pnpm test:watch
+Use library wrappers to emit domain events and `@OnLibraryEvent()` to observe them.
 
-# Generate coverage report
-pnpm test:coverage
-```
-
-### Test Structure
+`@OnLibraryEvent()` listens to events emitted through `library.emit(...)` only.
+It does not listen to `emitExternal`, `emitNetExternal`, or `emitServer`.
 
-```
-tests/
-├── unit/              # Unit tests
-│   ├── server/
-│   │   └── decorators/
-│   │       ├── command.test.ts
-│   │       ├── guard.test.ts
-│   │       ├── throttle.test.ts
-│   │       └── ...
-│   └── utils/
-├── integration/       # Integration tests
-│   ├── client/
-│   └── server/
-├── mocks/             # FiveM mocks
-│   └── citizenfx.ts
-└── helpers/           # Test utilities
-```
+```ts
+import { Server } from '@open-core/framework/server'
 
-### Coverage
+const characters = Server.createServerLibrary('characters')
 
-All core decorators are **100% tested**:
+@Controller()
+export class CharacterListeners {
+  @OnLibraryEvent('characters', 'session:created')
+  onSessionCreated(payload: { sessionId: string; playerId: number }) {
+    // optional listener for library domain events
+  }
+}
 
-- `@Command`, `@Guard`, `@Throttle`, `@OnNet`, `@OnTick`
-- `@Controller`, `@Public`, `@Export`, `@CoreEvent`, `@Bind`
+characters.emit('session:created', { sessionId: 's-1', playerId: 10 })
+```
 
----
+Client usage follows the same pattern with `Client.createClientLibrary(...)` and
+`@Client.OnLibraryEvent(...)`.
 
-## ⚡ Performance & Benchmarks
+## Plugins
 
-OpenCore is built for performance. Our benchmark suite validates that the framework can handle production workloads with ease.
+Plugin contracts are exposed by runtime entrypoint, not by root:
 
-### Run Benchmarks
+- Server plugins: `@open-core/framework/server`
+- Client plugins: `@open-core/framework/client`
 
-```bash
-# Core component benchmarks (Tinybench)
-pnpm bench:core
+```ts
+import { Server, type OpenCorePlugin } from '@open-core/framework/server'
+import { Client, type OpenCoreClientPlugin } from '@open-core/framework/client'
+
+const serverPlugin: OpenCorePlugin = {
+  name: 'server-example',
+  install(ctx) {
+    ctx.server.registerApiExtension('ExampleServerDecorator', () => {})
+  },
+}
 
-# Load benchmarks with player simulation (Vitest)
-pnpm bench:load
+const clientPlugin: OpenCoreClientPlugin = {
+  name: 'client-example',
+  install(ctx) {
+    ctx.client.registerApiExtension('ExampleClientDecorator', () => {})
+  },
+}
 
-# Full benchmark suite with reports
-pnpm bench:all
+await Server.init({ mode: 'CORE', plugins: [serverPlugin] })
+await Client.init({ mode: 'CORE', plugins: [clientPlugin] })
 ```
 
-### Latest Results (v0.6.0-beta.1)
+Module augmentation for plugin APIs:
 
-#### Core Components
+```ts
+declare module '@open-core/framework/server' {
+  interface ServerPluginApi {
+    ExampleServerDecorator: () => void
+  }
+}
 
-| Component         | Operation          | Throughput    | Latency |
-| ----------------- | ------------------ | ------------- | ------- |
-| **DI Container**  | Resolve service    | 1.65M ops/sec | 0.61μs  |
-| **Zod**           | Simple validation  | 1.99M ops/sec | 0.50μs  |
-| **Zod**           | Complex validation | 1.00M ops/sec | 1.00μs  |
-| **RateLimiter**   | Key check          | 2.56M ops/sec | 0.39μs  |
-| **AccessControl** | Permission check   | 2.76M ops/sec | 0.36μs  |
-| **EventBus**      | Emit event         | 3.22M ops/sec | 0.31μs  |
-| **Decorators**    | Define metadata    | 5.48M ops/sec | 0.18μs  |
+declare module '@open-core/framework/client' {
+  interface ClientPluginApi {
+    ExampleClientDecorator: () => void
+  }
+}
+```
 
-#### Load Tests (500 Concurrent Players)
+## Testing
 
-| Scenario                    | Throughput      | p95 Latency | Error Rate |
-| --------------------------- | --------------- | ----------- | ---------- |
-| **Net Events (Simple)**     | 92.59M ops/sec  | 0.80μs      | 0.00%      |
-| **Net Events (Validated)**  | 11.47M ops/sec  | 2.70μs      | 0.00%      |
-| **Net Events (Concurrent)** | 1.61M ops/sec   | 294.22μs    | 0.00%      |
-| **Serialization (Large)**   | 146.53K ops/sec | 951.11μs    | 0.00%      |
+Tests run with Vitest.
 
-#### Key Performance Highlights
+```bash
+pnpm test
+pnpm test:unit
+pnpm test:integration
+pnpm test:coverage
+```
 
-- ✅ **Zero error rate** across all load scenarios (10 → 500 players)
-- ✅ **Sub-microsecond latency** for core operations
-- ✅ **Excellent scalability** - handles 500+ concurrent players
-- ✅ **Consistent p95/p99** - predictable latency behavior
+Note: `pnpm test` does not run benchmarks.
 
-> Full benchmark details available in [`benchmark/README.md`](./benchmark/README.md)
+## Benchmarks
 
----
+There are two benchmark suites:
 
-## 📁 Project Structure
+- Core benchmarks (Tinybench)
+- Load benchmarks (Vitest project `benchmark`)
 
+```bash
+pnpm bench:core
+pnpm bench:load
+pnpm bench:all
 ```
-opencore/
-├── src/
-│   ├── client/           # Client-side framework
-│   │   ├── decorators/   # @OnNet, @Key, @Tick, @NUI, etc.
-│   │   ├── services/     # Streaming, UI, World services
-│   │   └── system/       # Processors and metadata
-│   ├── server/           # Server-side framework
-│   │   ├── decorators/   # @Command, @Guard, @Throttle, etc.
-│   │   ├── services/     # Player, Command, RateLimiter, etc.
-│   │   ├── entities/     # Player entity
-│   │   └── bus/          # Core Event Bus
-│   ├── shared/           # Shared utilities
-│   │   └── logger/       # Logging system
-│   └── system/           # Core system (MetadataScanner, DI)
-├── tests/                # Test suites
-│   ├── unit/
-│   ├── integration/
-│   └── mocks/
-├── benchmark/            # Performance benchmarks
-│   ├── core/             # Tinybench benchmarks
-│   ├── load/             # Vitest load tests
-│   └── reports/          # Generated reports
-└── dist/                 # Compiled output
-```
-
----
 
-## 📜 Available Scripts
+### Snapshot (latest local run)
 
-| Script                  | Description                      |
-| ----------------------- | -------------------------------- |
-| `pnpm build`            | Compile TypeScript to JavaScript |
-| `pnpm watch`            | Watch mode for development       |
-| `pnpm lint`             | Run ESLint                       |
-| `pnpm lint:fix`         | Fix ESLint issues                |
-| `pnpm format`           | Format code with Prettier        |
-| `pnpm test`             | Run all tests                    |
-| `pnpm test:unit`        | Run unit tests only              |
-| `pnpm test:integration` | Run integration tests only       |
-| `pnpm test:coverage`    | Generate coverage report         |
-| `pnpm bench`            | Show benchmark options           |
-| `pnpm bench:core`       | Run core benchmarks              |
-| `pnpm bench:load`       | Run load benchmarks              |
-| `pnpm bench:all`        | Run all benchmarks with reports  |
+These values are a small extract from the latest local run (`1.0.0-beta.1`, Feb 26, 2026). Results vary by machine.
 
----
+- **Core**
+  - BinaryService - classify response type: `~18.25M ops/sec` (mean `~0.055μs`, p95 `~0.076μs`)
+  - EventInterceptor - getStatistics (1000 events): `~17.78M ops/sec` (mean `~0.056μs`)
+  - RuntimeConfig - resolve CORE mode: `~10.49M ops/sec` (mean `~0.095μs`)
+  - Decorators - define metadata (Command): `~6.92M ops/sec` (mean `~0.145μs`)
+  - EventBus - multiple event types: `~2.57M ops/sec` (mean `~0.390μs`)
+  - DI - resolve simple service: `~1.78M ops/sec` (mean `~0.560μs`)
+- **Load**
+  - Commands - 500 players (validated): `~4.78M ops/sec` (p95 `~0.008ms`)
+  - Pipeline - validated (500 players): `~4.79M ops/sec` (p95 `~0.024ms`)
+  - Pipeline - full (500 players): `~2.34M ops/sec` (p95 `~0.011ms`)
+  - RPC - schema generation complex (500 methods): `~705K ops/sec` (p95 `~0.335ms`)
+  - Commands - 500 players (concurrent): `~6.31K ops/sec` (p95 `~76.00ms`)
 
-## Available Modules
+Full reports and methodology are available in benchmark/README.md.
 
-A module is a library belonging to the OpenCore family, where you can take advantage of its functionality if you wish, and where we provide the foundation for building a specific system.
+### Reports
 
-- [Open-core Identity](https://github.com/newcore-network/opencore-identity): Flexible identity and permission system for OpenCore. Provides multiple authentication strategies, role management, and permission-based authorization through the framework's Principal system. [NPM](https://www.npmjs.com/package/@open-core/identity).
+Benchmark reports are generated under `benchmark/reports/`.
 
-```bash
-pnpm add @open-core/identity
-```
-
-## 🤝 Contributing
+- `pnpm bench:all` generates aggregated reports (text/json/html)
+- Load metrics used by load benchmarks are persisted in `benchmark/reports/.load-metrics.json`
 
-Contributions are welcome! Please ensure:
+For details about the benchmark system, see `benchmark/README.md`.
 
-1. All tests pass (`pnpm test`)
-2. Code is formatted (`pnpm format`)
-3. No linting errors (`pnpm lint`)
-4. New features include tests
+## Development scripts
 
----
+```bash
+pnpm build
+pnpm watch
+pnpm lint
+pnpm lint:fix
+pnpm format
+```
 
-## 📄 License
+## Ecosystem
 
-OpenCore is licensed under the **MPL-2.0**.
+OpenCore is designed to be extended via separate packages/resources.
 
-See [LICENSE](./LICENSE) for details.
+- `@open-core/identity`: identity and permission system
 
----
+## License
 
-<p align="center">
-  <strong>OpenCore Framework</strong><br>
-  <em>Stop scripting. Start engineering.</em>
-</p>
+MPL-2.0. See `LICENSE`.

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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,70 @@
+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

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