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

package/dist/runtime/server/controllers/vehicle.controller.js

@@ -12,6 +12,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { inject } from 'tsyringe';
 import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
+import { SYSTEM_EVENTS } from '../../shared/types/system-types';
 import { Controller, OnNet } from '../decorators';
 import { Player } from '../entities/player';
 import { Vehicles } from '../apis/vehicles.api';
@@ -34,11 +35,11 @@ let VehicleController = class VehicleController {
     handleGetData(player, networkId) {
         const vehicle = this.vehicleService.getByNetworkId(networkId);
         if (!vehicle) {
-            this.events.emit('opencore:vehicle:dataResult', player.clientID, null);
+            this.events.emit(SYSTEM_EVENTS.vehicle.dataResult, player.clientID, null);
             return null;
         }
         const data = vehicle.serialize();
-        this.events.emit('opencore:vehicle:dataResult', player.clientID, data);
+        this.events.emit(SYSTEM_EVENTS.vehicle.dataResult, player.clientID, data);
         return data;
     }
     /**
@@ -47,18 +48,18 @@ let VehicleController = class VehicleController {
     handleGetPlayerVehicles(player) {
         const vehicles = this.vehicleService.getPlayerVehicles(player.clientID);
         const serialized = vehicles.map((v) => v.serialize());
-        this.events.emit('opencore:vehicle:playerVehiclesResult', player.clientID, serialized);
+        this.events.emit(SYSTEM_EVENTS.vehicle.playerVehiclesResult, player.clientID, serialized);
         return serialized;
     }
 };
 __decorate([
-    OnNet('opencore:vehicle:getData'),
+    OnNet(SYSTEM_EVENTS.vehicle.getData),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Player, Number]),
     __metadata("design:returntype", void 0)
 ], VehicleController.prototype, "handleGetData", null);
 __decorate([
-    OnNet('opencore:vehicle:getPlayerVehicles'),
+    OnNet(SYSTEM_EVENTS.vehicle.getPlayerVehicles),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Player]),
     __metadata("design:returntype", void 0)

package/dist/runtime/server/decorators/command.d.ts

@@ -36,6 +36,8 @@ export interface CommandMetadata extends CommandConfig {
     security?: SecurityMetadata;
     /** True if the last parameter uses the spread operator (...args) */
     hasSpreadParam?: boolean;
+    /** True when a parameter defines a JS default value. */
+    defaultParams?: boolean[];
 }
 type ServerCommandHandler = (() => any) | ((player: Player, ...args: any[]) => any);
 /**

package/dist/runtime/server/decorators/command.js

@@ -1,5 +1,5 @@
 import { Player } from '../entities/player';
-import { getParameterNames, getSpreadParameterIndices } from '../helpers/function-helper';
+import { getDefaultParameterIndices, getParameterNames, getSpreadParameterIndices, } from '../helpers/function-helper';
 import { METADATA_KEYS } from '../system/metadata-server.keys';
 // Implementation
 export function Command(configOrName, schema) {
@@ -20,6 +20,7 @@ export function Command(configOrName, schema) {
             throw new Error(`@Command '${config.command}': first parameter must be Player if parameters are present`);
         }
         const paramNames = getParameterNames(descriptor.value);
+        const defaultParams = getDefaultParameterIndices(descriptor.value);
         const spreadIndices = getSpreadParameterIndices(descriptor.value);
         const hasSpreadParam = spreadIndices.length > 0 && spreadIndices[spreadIndices.length - 1];
         const metadata = {
@@ -30,6 +31,7 @@ export function Command(configOrName, schema) {
             paramNames,
             expectsPlayer,
             hasSpreadParam,
+            defaultParams,
         };
         Reflect.defineMetadata(METADATA_KEYS.COMMAND, metadata, target, propertyKey);
     };

package/dist/runtime/server/entities/npc.d.ts

@@ -1,4 +1,3 @@
-import { NativeHandle } from 'src/runtime/core/nativehandle';
 import { IEntityServer } from '../../../adapters/contracts/server/IEntityServer';
 import { INpcLifecycleServer } from '../../../adapters/contracts/server/npc-lifecycle/INpcLifecycleServer';
 import { IPedServer } from '../../../adapters/contracts/server/IPedServer';
@@ -6,6 +5,7 @@ import { Vector3 } from '../../../kernel/utils/vector3';
 import { BaseEntity } from '../../core/entity';
 import { Spatial } from '../../core/spatial';
 import { SerializedNpcData } from '../types/npc.types';
+import { NativeHandle } from '../../core';
 export interface NpcAdapters {
     entityServer: IEntityServer;
     pedServer: IPedServer;

package/dist/runtime/server/entities/player.d.ts

@@ -11,7 +11,7 @@ import { Spatial } from '../../core/spatial';
 import { LinkedID } from '../types/linked-id';
 import { PlayerSession } from '../types/player-session.types';
 import { SerializedPlayerData } from '../types/core-exports.types';
-import { NativeHandle } from 'src/runtime/core/nativehandle';
+import { NativeHandle } from '../../core';
 /**
  * Adapter bundle for player operations.
  * Passed to Player instances by PlayerDirectory.

package/dist/runtime/server/entities/player.js

@@ -1,5 +1,6 @@
 import { loggers } from '../../../kernel/logger';
 import { BaseEntity } from '../../core/entity';
+import { SYSTEM_EVENTS } from '../../shared/types/system-types';
 /**
  * Core-level representation of a connected player on the server.
  *
@@ -30,10 +31,16 @@ export class Player extends BaseEntity {
         this._position = adapters.playerInfo.getPlayerPosition(session.clientID);
     }
     getHeading() {
-        return this.adapters.entityServer.getHeading(this.clientID);
+        const ped = this.adapters.playerServer.getPed(this.clientID.toString());
+        if (!ped || ped === 0)
+            return 0;
+        return this.adapters.entityServer.getHeading(ped);
     }
     setHeading(heading) {
-        this.adapters.entityServer.setHeading(this.clientID, heading);
+        const ped = this.adapters.playerServer.getPed(this.clientID.toString());
+        if (!ped || ped === 0)
+            return;
+        this.adapters.entityServer.setHeading(ped, heading);
     }
     getHandle() {
         return this.clientID;
@@ -120,7 +127,7 @@ export class Player extends BaseEntity {
      * @param type - Message type for styling
      */
     send(message, type = 'chat') {
-        this.emit('core:chat:send', message, type);
+        this.emit(SYSTEM_EVENTS.chat.send, message, type);
     }
     // ─────────────────────────────────────────────────────────────────
     // Spawning / Teleporting

package/dist/runtime/server/helpers/command-validation.helper.js

@@ -4,17 +4,21 @@ import { generateSchemaFromTypes } from '../system/schema-generator';
 import { processTupleSchema } from '../../shared/helpers/process-tuple-schema';
 export async function validateAndExecuteCommand(meta, player, args, handler) {
     const paramNames = meta.expectsPlayer ? meta.paramNames.slice(1) : meta.paramNames;
+    const defaultParams = meta.expectsPlayer
+        ? (meta.defaultParams ?? []).slice(1)
+        : (meta.defaultParams ?? []);
     let schema = meta.schema;
     if (!meta.expectsPlayer) {
         if (args.length > 0) {
-            throw new AppError('GAME:BAD_REQUEST', `Incorrect usage, use: ${meta.usage}`, 'client', {
-                usage: meta.usage,
+            const usage = resolveCommandUsage(meta, paramNames, defaultParams);
+            throw new AppError('GAME:BAD_REQUEST', `Incorrect usage, use: ${usage}`, 'client', {
+                usage,
             });
         }
         return await handler();
     }
     if (!schema) {
-        schema = generateSchemaFromTypes(meta.paramTypes);
+        schema = generateSchemaFromTypes(meta.paramTypes, meta.defaultParams);
         if (!schema) {
             if (paramNames.length > 0) {
                 throw new AppError('SCHEMA:MISMATCH', `Command '${meta.command}' has parameters ${paramNames.join(', ')} but no schema was provided.`, 'core');
@@ -39,8 +43,9 @@ export async function validateAndExecuteCommand(meta, player, args, handler) {
             inputObj[paramNames[i]] = args[i];
         }
         const validated = await schema.parseAsync(inputObj).catch(() => {
-            throw new AppError('GAME:BAD_REQUEST', `Incorrect usage, use: ${meta.usage}`, 'client', {
-                usage: meta.usage,
+            const usage = resolveCommandUsage(meta, paramNames, defaultParams);
+            throw new AppError('GAME:BAD_REQUEST', `Incorrect usage, use: ${usage}`, 'client', {
+                usage,
             });
         });
         const obj = validated;
@@ -51,8 +56,9 @@ export async function validateAndExecuteCommand(meta, player, args, handler) {
     if (schema instanceof z.ZodTuple) {
         const processedArgs = processTupleSchema(schema, args);
         const validated = await schema.parseAsync(processedArgs).catch(() => {
-            throw new AppError('GAME:BAD_REQUEST', `Incorrect usage, use: ${meta.usage}`, 'client', {
-                usage: meta.usage,
+            const usage = resolveCommandUsage(meta, paramNames, defaultParams);
+            throw new AppError('GAME:BAD_REQUEST', `Incorrect usage, use: ${usage}`, 'client', {
+                usage,
             });
         });
         const finalArgs = validated;
@@ -71,3 +77,10 @@ export async function validateAndExecuteCommand(meta, player, args, handler) {
     // fallback
     return await handler(player);
 }
+function resolveCommandUsage(meta, paramNames, defaultParams) {
+    if (meta.usage?.trim()) {
+        return meta.usage;
+    }
+    const renderedParams = paramNames.map((name, index) => defaultParams[index] ? `[${name}]` : `<${name}>`);
+    return `/${meta.command}${renderedParams.length > 0 ? ` ${renderedParams.join(' ')}` : ''}`;
+}

package/dist/runtime/server/helpers/function-helper.d.ts

@@ -1,4 +1,5 @@
 export declare function getParameterNames(func: (...args: any[]) => any): string[];
+export declare function getDefaultParameterIndices(func: (...args: any[]) => any): boolean[];
 /**
  * Detects which parameter indices use the spread operator (...args).
  * Returns an array of booleans where true means the parameter at that index is a spread parameter.

package/dist/runtime/server/helpers/function-helper.js

@@ -1,14 +1,10 @@
 export function getParameterNames(func) {
-    const stripped = func
-        .toString()
-        .replace(/\/\/.*$/gm, '')
-        .replace(/\/\*[\s\S]*?\*\//gm, '');
-    const args = stripped
-        .slice(stripped.indexOf('(') + 1, stripped.indexOf(')'))
-        .split(',')
+    return parseParameterTokens(func)
         .map((arg) => arg.replace(/=[\s\S]*/, '').trim())
         .filter(Boolean);
-    return args;
+}
+export function getDefaultParameterIndices(func) {
+    return parseParameterTokens(func).map((arg) => arg.includes('='));
 }
 /**
  * Detects which parameter indices use the spread operator (...args).
@@ -26,3 +22,14 @@ export function getSpreadParameterIndices(func) {
         .filter(Boolean);
     return args.map((arg) => arg.startsWith('...'));
 }
+function parseParameterTokens(func) {
+    const stripped = func
+        .toString()
+        .replace(/\/\/.*$/gm, '')
+        .replace(/\/\*[\s\S]*?\*\//gm, '');
+    return stripped
+        .slice(stripped.indexOf('(') + 1, stripped.indexOf(')'))
+        .split(',')
+        .map((arg) => arg.trim())
+        .filter(Boolean);
+}

package/dist/runtime/server/implementations/local/channel.local.d.ts

@@ -1,5 +1,5 @@
 import { EventsAPI } from '../../../../adapters/contracts/transport/events.api';
-import { RGB } from 'src/kernel';
+import { RGB } from '../../../../kernel/utils';
 import { Player } from '../../entities';
 import { Channels } from '../../ports/channel.api-port';
 import { IChannelValidator, ChannelMetadata, ChannelType } from '../../types';

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/processors/onRpc.processor.js

@@ -124,10 +124,21 @@ let OnRpcProcessor = class OnRpcProcessor {
                 });
                 throw error;
             }
-            if (hasNoDeclaredParams) {
-                return handler();
+            try {
+                if (hasNoDeclaredParams) {
+                    return await handler();
+                }
+                return await handler(player, ...validatedArgs);
+            }
+            catch (error) {
+                loggers.netEvent.error(`Handler error in RPC`, {
+                    event: metadata.eventName,
+                    handler: handlerName,
+                    playerId: player.clientID,
+                    accountId: player.accountID,
+                }, error);
+                throw error;
             }
-            return handler(player, ...validatedArgs);
         });
         loggers.netEvent.debug(`Registered RPC: ${metadata.eventName} -> ${handlerName}`);
     }

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.6",
   "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"
+    ]
   }
 }