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

package/dist/runtime/server/implementations/local/channel.local.js

@@ -12,6 +12,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { EventsAPI } from '../../../../adapters/contracts/transport/events.api';
 import { inject, injectable } from 'tsyringe';
+import { SYSTEM_EVENTS } from '../../../shared/types/system-types';
 import { Channels } from '../../ports/channel.api-port';
 import { ChannelType } from '../../types';
 import { Players } from '../../ports/players.api-port';
@@ -96,7 +97,7 @@ let LocalChannelImplementation = class LocalChannelImplementation extends Channe
         if (targetIds.length === 0) {
             return;
         }
-        this.events.emit('core:chat:addMessage', targetIds, {
+        this.events.emit(SYSTEM_EVENTS.chat.addMessage, targetIds, {
             args: [author ?? sender.name, message],
             color: color,
         });
@@ -111,7 +112,7 @@ let LocalChannelImplementation = class LocalChannelImplementation extends Channe
         if (targetIds.length === 0) {
             return;
         }
-        this.events.emit('core:chat:addMessage', targetIds, {
+        this.events.emit(SYSTEM_EVENTS.chat.addMessage, targetIds, {
             args: [author, message],
             color: color,
         });

package/dist/runtime/server/ports/channel.api-port.d.ts

@@ -1,4 +1,4 @@
-import { RGB } from 'src/kernel';
+import { RGB } from '../../../kernel/utils';
 import { Channel } from '../concepts/channel';
 import { Player } from '../entities';
 import { ChannelMetadata, ChannelType, IChannelValidator } from '../types';

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

@@ -23,7 +23,7 @@ export declare class WorkerPool extends SimpleEventEmitter {
     private workerIdCounter;
     private cleanupInterval;
     private isShuttingDown;
-    private workerScriptPath;
+    private workerSource;
     constructor(config?: Partial<WorkerPoolConfig>);
     /**
      * Check if using native workers

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/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/shared/helpers/process-tuple-schema.js

@@ -25,5 +25,8 @@ export function processTupleSchema(schema, args) {
             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.2",
+  "version": "1.0.5",
   "description": "Secure, event-driven TypeScript Framework & Runtime engine for CitizenFX (Cfx).",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -75,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",
@@ -88,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",
@@ -98,16 +101,23 @@
     "uuid": "^13.0.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.11",
-    "@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"
+    ]
   }
 }