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

package/dist/adapters/node/node-ped-server.js

@@ -0,0 +1,45 @@
+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 { IPedServer } from '../contracts/server/IPedServer';
+/** Node.js mock implementation of server-side ped operations. */
+let NodePedServer = class NodePedServer extends IPedServer {
+    byHandle = new Map();
+    byNetworkId = new Map();
+    nextHandle = 2000;
+    nextNetworkId = 5000;
+    create(_pedType, _modelHash, _x, _y, _z, _heading, networked) {
+        const handle = this.nextHandle++;
+        this.byHandle.set(handle, 0);
+        if (networked) {
+            const netId = this.nextNetworkId++;
+            this.byHandle.set(handle, netId);
+            this.byNetworkId.set(netId, handle);
+        }
+        return handle;
+    }
+    delete(handle) {
+        const netId = this.byHandle.get(handle);
+        if (netId && netId > 0) {
+            this.byNetworkId.delete(netId);
+        }
+        this.byHandle.delete(handle);
+    }
+    getNetworkIdFromEntity(handle) {
+        return this.byHandle.get(handle) ?? 0;
+    }
+    getEntityFromNetworkId(networkId) {
+        return this.byNetworkId.get(networkId) ?? 0;
+    }
+    networkIdExists(networkId) {
+        return this.byNetworkId.has(networkId);
+    }
+};
+NodePedServer = __decorate([
+    injectable()
+], NodePedServer);
+export { NodePedServer };

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

@@ -0,0 +1,5 @@
+import type { PlatformAdapter } from '../platform/platform-registry';
+/**
+ * Node.js mock platform adapter for testing and standalone development.
+ */
+export declare const NodePlatform: PlatformAdapter;

package/dist/adapters/node/node-platform.js

@@ -0,0 +1,76 @@
+import { IEngineEvents } from '../contracts/IEngineEvents';
+import { IExports } from '../contracts/IExports';
+import { IHasher } from '../contracts/IHasher';
+import { IPlatformCapabilities } from '../contracts/IPlatformCapabilities';
+import { IPlayerInfo } from '../contracts/IPlayerInfo';
+import { IResourceInfo } from '../contracts/IResourceInfo';
+import { ITick } from '../contracts/ITick';
+import { IEntityServer } from '../contracts/server/IEntityServer';
+import { IPedServer } from '../contracts/server/IPedServer';
+import { IPedAppearanceServer } from '../contracts/server/IPedAppearanceServer';
+import { IPlayerServer } from '../contracts/server/IPlayerServer';
+import { IVehicleServer } from '../contracts/server/IVehicleServer';
+import { EventsAPI } from '../contracts/transport/events.api';
+import { MessagingTransport } from '../contracts/transport/messaging.transport';
+import { RpcAPI } from '../contracts/transport/rpc.api';
+/**
+ * Node.js mock platform adapter for testing and standalone development.
+ */
+export const NodePlatform = {
+    name: 'node',
+    priority: 0, // Lowest priority - fallback platform
+    detect() {
+        // Node is the fallback platform when no other platform is detected
+        // It should only match if we're running in pure Node.js
+        return typeof process !== 'undefined' && process.versions?.node !== undefined;
+    },
+    async register(container) {
+        // Dynamically import Node.js mock implementations
+        const [{ NodeMessagingTransport }, { NodeEngineEvents }, { NodeExports }, { NodeResourceInfo }, { NodeTick }, { NodePlayerInfo }, { NodeEntityServer }, { NodePedServer }, { NodeVehicleServer }, { NodePlayerServer }, { NodeHasher }, { NodePedAppearanceServer }, { NodeCapabilities },] = await Promise.all([
+            import('./transport/adapter'),
+            import('./node-engine-events'),
+            import('./node-exports'),
+            import('./node-resourceinfo'),
+            import('./node-tick'),
+            import('./node-playerinfo'),
+            import('./node-entity-server'),
+            import('./node-ped-server'),
+            import('./node-vehicle-server'),
+            import('./node-player-server'),
+            import('./node-hasher'),
+            import('./node-ped-appearance-server'),
+            import('./node-capabilities'),
+        ]);
+        // Register all Node.js mock implementations
+        if (!container.isRegistered(IPlatformCapabilities))
+            container.registerSingleton(IPlatformCapabilities, NodeCapabilities);
+        if (!container.isRegistered(MessagingTransport)) {
+            const transport = new NodeMessagingTransport('server');
+            container.registerInstance(MessagingTransport, transport);
+            container.registerInstance(EventsAPI, transport.events);
+            container.registerInstance(RpcAPI, transport.rpc);
+        }
+        if (!container.isRegistered(IEngineEvents))
+            container.registerSingleton(IEngineEvents, NodeEngineEvents);
+        if (!container.isRegistered(IExports))
+            container.registerSingleton(IExports, NodeExports);
+        if (!container.isRegistered(IResourceInfo))
+            container.registerSingleton(IResourceInfo, NodeResourceInfo);
+        if (!container.isRegistered(ITick))
+            container.registerSingleton(ITick, NodeTick);
+        if (!container.isRegistered(IPlayerInfo))
+            container.registerSingleton(IPlayerInfo, NodePlayerInfo);
+        if (!container.isRegistered(IEntityServer))
+            container.registerSingleton(IEntityServer, NodeEntityServer);
+        if (!container.isRegistered(IPedServer))
+            container.registerSingleton(IPedServer, NodePedServer);
+        if (!container.isRegistered(IVehicleServer))
+            container.registerSingleton(IVehicleServer, NodeVehicleServer);
+        if (!container.isRegistered(IPlayerServer))
+            container.registerSingleton(IPlayerServer, NodePlayerServer);
+        if (!container.isRegistered(IHasher))
+            container.registerSingleton(IHasher, NodeHasher);
+        if (!container.isRegistered(IPedAppearanceServer))
+            container.registerSingleton(IPedAppearanceServer, NodePedAppearanceServer);
+    },
+};

package/dist/adapters/node/node-player-server.d.ts

@@ -0,0 +1,44 @@
+import { IPlayerServer } from '../contracts/server/IPlayerServer';
+import { type PlayerIdentifier } from '../contracts/types/identifier';
+/**
+ * Node.js mock implementation of server-side player operations.
+ * Used for testing and standalone mode.
+ */
+export declare class NodePlayerServer extends IPlayerServer {
+    private players;
+    private droppedPlayers;
+    getPed(playerSrc: string): number;
+    drop(playerSrc: string, _reason: string): void;
+    getIdentifier(playerSrc: string, identifierType: string): string | undefined;
+    /**
+     * @deprecated Use getPlayerIdentifiers() for structured identifier data.
+     */
+    getIdentifiers(playerSrc: string): string[];
+    getPlayerIdentifiers(playerSrc: string): PlayerIdentifier[];
+    getNumIdentifiers(playerSrc: string): number;
+    getName(playerSrc: string): string;
+    getPing(playerSrc: string): number;
+    getEndpoint(playerSrc: string): string;
+    setRoutingBucket(playerSrc: string, bucket: number): void;
+    getRoutingBucket(playerSrc: string): number;
+    getConnectedPlayers(): string[];
+    /**
+     * Add a mock player for testing.
+     */
+    _addMockPlayer(playerSrc: string, data: {
+        ped?: number;
+        name?: string;
+        identifiers?: string[];
+        ping?: number;
+        endpoint?: string;
+        routingBucket?: number;
+    }): void;
+    /**
+     * Check if a player was dropped.
+     */
+    _wasDropped(playerSrc: string): boolean;
+    /**
+     * Clear all mock data.
+     */
+    _clear(): void;
+}

package/dist/adapters/node/node-player-server.js

@@ -0,0 +1,105 @@
+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 { IPlayerServer } from '../contracts/server/IPlayerServer';
+import { parseIdentifier } from '../contracts/types/identifier';
+/**
+ * Node.js mock implementation of server-side player operations.
+ * Used for testing and standalone mode.
+ */
+let NodePlayerServer = class NodePlayerServer extends IPlayerServer {
+    players = new Map();
+    droppedPlayers = [];
+    getPed(playerSrc) {
+        return this.players.get(playerSrc)?.ped ?? 0;
+    }
+    drop(playerSrc, _reason) {
+        this.droppedPlayers.push(playerSrc);
+        this.players.delete(playerSrc);
+    }
+    getIdentifier(playerSrc, identifierType) {
+        const player = this.players.get(playerSrc);
+        if (!player)
+            return undefined;
+        const prefix = `${identifierType}:`;
+        return player.identifiers.find((id) => id.startsWith(prefix));
+    }
+    /**
+     * @deprecated Use getPlayerIdentifiers() for structured identifier data.
+     */
+    getIdentifiers(playerSrc) {
+        return this.players.get(playerSrc)?.identifiers ?? [];
+    }
+    getPlayerIdentifiers(playerSrc) {
+        const rawIdentifiers = this.getIdentifiers(playerSrc);
+        const identifiers = [];
+        for (const raw of rawIdentifiers) {
+            const parsed = parseIdentifier(raw);
+            if (parsed) {
+                identifiers.push(parsed);
+            }
+        }
+        return identifiers;
+    }
+    getNumIdentifiers(playerSrc) {
+        return this.players.get(playerSrc)?.identifiers.length ?? 0;
+    }
+    getName(playerSrc) {
+        return this.players.get(playerSrc)?.name ?? 'Unknown';
+    }
+    getPing(playerSrc) {
+        return this.players.get(playerSrc)?.ping ?? 0;
+    }
+    getEndpoint(playerSrc) {
+        return this.players.get(playerSrc)?.endpoint ?? '';
+    }
+    setRoutingBucket(playerSrc, bucket) {
+        const player = this.players.get(playerSrc);
+        if (player) {
+            player.routingBucket = bucket;
+        }
+    }
+    getRoutingBucket(playerSrc) {
+        return this.players.get(playerSrc)?.routingBucket ?? 0;
+    }
+    getConnectedPlayers() {
+        return Array.from(this.players.keys());
+    }
+    // ─────────────────────────────────────────────────────────────────
+    // Test Helpers
+    // ─────────────────────────────────────────────────────────────────
+    /**
+     * Add a mock player for testing.
+     */
+    _addMockPlayer(playerSrc, data) {
+        this.players.set(playerSrc, {
+            ped: data.ped ?? 0,
+            name: data.name ?? 'TestPlayer',
+            identifiers: data.identifiers ?? [],
+            ping: data.ping ?? 50,
+            endpoint: data.endpoint ?? '127.0.0.1:30120',
+            routingBucket: data.routingBucket ?? 0,
+        });
+    }
+    /**
+     * Check if a player was dropped.
+     */
+    _wasDropped(playerSrc) {
+        return this.droppedPlayers.includes(playerSrc);
+    }
+    /**
+     * Clear all mock data.
+     */
+    _clear() {
+        this.players.clear();
+        this.droppedPlayers = [];
+    }
+};
+NodePlayerServer = __decorate([
+    injectable()
+], NodePlayerServer);
+export { NodePlayerServer };

package/dist/adapters/node/node-playerinfo.d.ts

@@ -0,0 +1,6 @@
+import { Vector3 } from '../../kernel';
+import { IPlayerInfo } from '../contracts/IPlayerInfo';
+export declare class NodePlayerInfo extends IPlayerInfo {
+    getPlayerName(clientId: number): string | null;
+    getPlayerPosition(_clientId: number): Vector3;
+}

package/dist/adapters/node/node-playerinfo.js

@@ -0,0 +1,20 @@
+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 { IPlayerInfo } from '../contracts/IPlayerInfo';
+let NodePlayerInfo = class NodePlayerInfo extends IPlayerInfo {
+    getPlayerName(clientId) {
+        return `Player${clientId.toString()}`;
+    }
+    getPlayerPosition(_clientId) {
+        return { x: 0, y: 0, z: 0 };
+    }
+};
+NodePlayerInfo = __decorate([
+    injectable()
+], NodePlayerInfo);
+export { NodePlayerInfo };

package/dist/adapters/node/node-resourceinfo.d.ts

@@ -0,0 +1,13 @@
+import { IResourceInfo } from '../contracts/IResourceInfo';
+/**
+ * Node.js implementation of IResourceInfo.
+ * Suitable for testing and non-FiveM runtime environments.
+ *
+ * Resource name is determined by:
+ * 1. RESOURCE_NAME environment variable
+ * 2. Fallback to 'default'
+ */
+export declare class NodeResourceInfo implements IResourceInfo {
+    getCurrentResourceName(): string;
+    getCurrentResourcePath(): string;
+}

package/dist/adapters/node/node-resourceinfo.js

@@ -0,0 +1,27 @@
+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';
+/**
+ * Node.js implementation of IResourceInfo.
+ * Suitable for testing and non-FiveM runtime environments.
+ *
+ * Resource name is determined by:
+ * 1. RESOURCE_NAME environment variable
+ * 2. Fallback to 'default'
+ */
+let NodeResourceInfo = class NodeResourceInfo {
+    getCurrentResourceName() {
+        return process.env.RESOURCE_NAME || 'default';
+    }
+    getCurrentResourcePath() {
+        return process.env.RESOURCE_PATH || process.cwd();
+    }
+};
+NodeResourceInfo = __decorate([
+    injectable()
+], NodeResourceInfo);
+export { NodeResourceInfo };

package/dist/adapters/node/node-tick.d.ts

@@ -0,0 +1,10 @@
+import { ITick } from '../contracts/ITick';
+/**
+ * Node.js implementation of ITick using setInterval.
+ * Default tick interval: 0ms (next tick via setImmediate for high frequency)
+ */
+export declare class NodeTick implements ITick {
+    private tickInterval;
+    constructor(tickInterval?: number);
+    setTick(handler: () => void | Promise<void>): void;
+}

package/dist/adapters/node/node-tick.js

@@ -0,0 +1,41 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { injectable } from 'tsyringe';
+/**
+ * Node.js implementation of ITick using setInterval.
+ * Default tick interval: 0ms (next tick via setImmediate for high frequency)
+ */
+let NodeTick = class NodeTick {
+    tickInterval;
+    constructor(tickInterval = 0) {
+        this.tickInterval = tickInterval;
+    }
+    setTick(handler) {
+        if (this.tickInterval === 0) {
+            // High-frequency tick using setImmediate (similar to FiveM's every-frame tick)
+            const tick = async () => {
+                await handler();
+                setImmediate(tick);
+            };
+            setImmediate(tick);
+        }
+        else {
+            // Interval-based tick
+            setInterval(async () => {
+                await handler();
+            }, this.tickInterval);
+        }
+    }
+};
+NodeTick = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Number])
+], NodeTick);
+export { NodeTick };

package/dist/adapters/node/node-vehicle-server.d.ts

@@ -0,0 +1,21 @@
+import { IVehicleServer } from '../contracts/server/IVehicleServer';
+/**
+ * Node.js mock implementation of server-side vehicle operations.
+ * Used for testing and standalone mode.
+ */
+export declare class NodeVehicleServer extends IVehicleServer {
+    private vehicles;
+    private nextHandle;
+    private nextNetworkId;
+    createServerSetter(modelHash: number, _vehicleType: string, _x: number, _y: number, _z: number, _heading: number): number;
+    getColours(handle: number): [number, number];
+    setColours(handle: number, primary: number, secondary: number): void;
+    getNumberPlateText(handle: number): string;
+    setNumberPlateText(handle: number, text: string): void;
+    setDoorsLocked(handle: number, state: number): void;
+    getNetworkIdFromEntity(handle: number): number;
+    getEntityFromNetworkId(networkId: number): number;
+    networkIdExists(networkId: number): boolean;
+    _deleteVehicle(handle: number): void;
+    _vehicleExists(handle: number): boolean;
+}

package/dist/adapters/node/node-vehicle-server.js

@@ -0,0 +1,84 @@
+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 { IVehicleServer } from '../contracts/server/IVehicleServer';
+/**
+ * Node.js mock implementation of server-side vehicle operations.
+ * Used for testing and standalone mode.
+ */
+let NodeVehicleServer = class NodeVehicleServer extends IVehicleServer {
+    vehicles = new Map();
+    nextHandle = 1000;
+    nextNetworkId = 1;
+    createServerSetter(modelHash, _vehicleType, _x, _y, _z, _heading) {
+        const handle = this.nextHandle++;
+        const networkId = this.nextNetworkId++;
+        this.vehicles.set(handle, {
+            model: modelHash,
+            colors: [0, 0],
+            plate: '',
+            doorsLocked: 1,
+            networkId,
+        });
+        return handle;
+    }
+    getColours(handle) {
+        return this.vehicles.get(handle)?.colors ?? [0, 0];
+    }
+    setColours(handle, primary, secondary) {
+        const vehicle = this.vehicles.get(handle);
+        if (vehicle) {
+            vehicle.colors = [primary, secondary];
+        }
+    }
+    getNumberPlateText(handle) {
+        return this.vehicles.get(handle)?.plate ?? '';
+    }
+    setNumberPlateText(handle, text) {
+        const vehicle = this.vehicles.get(handle);
+        if (vehicle) {
+            vehicle.plate = text.substring(0, 8);
+        }
+    }
+    setDoorsLocked(handle, state) {
+        const vehicle = this.vehicles.get(handle);
+        if (vehicle) {
+            vehicle.doorsLocked = state;
+        }
+    }
+    getNetworkIdFromEntity(handle) {
+        return this.vehicles.get(handle)?.networkId ?? 0;
+    }
+    getEntityFromNetworkId(networkId) {
+        for (const [handle, vehicle] of this.vehicles) {
+            if (vehicle.networkId === networkId) {
+                return handle;
+            }
+        }
+        return 0;
+    }
+    networkIdExists(networkId) {
+        for (const vehicle of this.vehicles.values()) {
+            if (vehicle.networkId === networkId) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // Test helper: delete vehicle
+    _deleteVehicle(handle) {
+        this.vehicles.delete(handle);
+    }
+    // Test helper: check if vehicle exists
+    _vehicleExists(handle) {
+        return this.vehicles.has(handle);
+    }
+};
+NodeVehicleServer = __decorate([
+    injectable()
+], NodeVehicleServer);
+export { NodeVehicleServer };

package/dist/adapters/node/transport/adapter.d.ts

@@ -0,0 +1,10 @@
+import { MessagingTransport } from '../../contracts/transport/messaging.transport';
+import type { RuntimeContext } from '../../contracts/transport/context';
+import { NodeEvents } from './node.events';
+import { NodeRpc } from './node.rpc';
+export declare class NodeMessagingTransport extends MessagingTransport {
+    readonly context: RuntimeContext;
+    readonly events: NodeEvents;
+    readonly rpc: NodeRpc;
+    constructor(context?: RuntimeContext);
+}

package/dist/adapters/node/transport/adapter.js

@@ -0,0 +1,14 @@
+import { MessagingTransport } from '../../contracts/transport/messaging.transport';
+import { NodeEvents } from './node.events';
+import { NodeRpc } from './node.rpc';
+export class NodeMessagingTransport extends MessagingTransport {
+    context;
+    events;
+    rpc;
+    constructor(context = 'server') {
+        super();
+        this.context = context;
+        this.events = new NodeEvents();
+        this.rpc = new NodeRpc(this.context);
+    }
+}

package/dist/adapters/node/transport/node.events.d.ts

@@ -0,0 +1,14 @@
+import { EventsAPI } from '../../contracts/transport/events.api';
+import { RuntimeContext } from '../../contracts/transport/context';
+type NodeTarget = number | number[] | 'all';
+export declare class NodeEvents extends EventsAPI<RuntimeContext> {
+    private readonly emitter;
+    on(event: string, handler: (ctx: {
+        clientId?: number;
+        raw?: unknown;
+    }, ...args: any[]) => any): void;
+    emit(event: string, targetOrArg?: NodeTarget | any, ...args: any[]): void;
+    simulateClientEvent(event: string, clientId: number, ...args: any[]): void;
+    clearHandlers(): void;
+}
+export {};

package/dist/adapters/node/transport/node.events.js

@@ -0,0 +1,38 @@
+import { EventEmitter } from 'node:events';
+import { EventsAPI } from '../../contracts/transport/events.api';
+import { loggers } from '../../../kernel/logger';
+export class NodeEvents extends EventsAPI {
+    emitter = new EventEmitter();
+    on(event, handler) {
+        this.emitter.on(event, (ctx, ...args) => {
+            void Promise.resolve(handler(ctx, ...args)).catch((err) => {
+                loggers.netEvent.error(`handler error for '${event}'`, {}, err);
+            });
+        });
+    }
+    emit(event, targetOrArg, ...args) {
+        if (targetOrArg === 'all' || typeof targetOrArg === 'number' || Array.isArray(targetOrArg)) {
+            const target = (targetOrArg ?? 'all');
+            const payloadArgs = args;
+            if (target === 'all') {
+                this.emitter.emit(event, { clientId: -1, raw: -1 }, ...payloadArgs);
+                return;
+            }
+            if (Array.isArray(target)) {
+                for (const clientId of target) {
+                    this.emitter.emit(event, { clientId, raw: clientId }, ...payloadArgs);
+                }
+                return;
+            }
+            this.emitter.emit(event, { clientId: target, raw: target }, ...payloadArgs);
+            return;
+        }
+        this.emitter.emit(event, { clientId: -1, raw: -1 }, targetOrArg, ...args);
+    }
+    simulateClientEvent(event, clientId, ...args) {
+        this.emitter.emit(event, { clientId, raw: clientId }, ...args);
+    }
+    clearHandlers() {
+        this.emitter.removeAllListeners();
+    }
+}

package/dist/adapters/node/transport/node.rpc.d.ts

@@ -0,0 +1,18 @@
+import { RpcAPI } from '../../contracts/transport/rpc.api';
+import type { RuntimeContext } from '../../contracts/transport/context';
+export declare class NodeRpc<C extends RuntimeContext = RuntimeContext> extends RpcAPI<C> {
+    private readonly context;
+    private readonly handlers;
+    constructor(context: C);
+    on<TArgs extends any[], TResult>(name: string, handler: (ctx: {
+        requestId: string;
+        clientId?: number;
+        raw?: unknown;
+    }, ...args: TArgs) => TResult | Promise<TResult>): void;
+    call<TResult = unknown>(name: string, ...args: any[]): Promise<TResult>;
+    notify(name: string, ...args: any[]): Promise<void>;
+    private normalizeInvocation;
+    private isValidTarget;
+    private executeCall;
+    private executeNotify;
+}