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

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

@@ -0,0 +1,74 @@
+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';
+/**
+ * FiveM platform adapter for automatic registration.
+ */
+export const FiveMPlatform = {
+    name: 'fivem',
+    priority: 100, // High priority - check FiveM first
+    detect() {
+        return typeof globalThis.GetCurrentResourceName === 'function';
+    },
+    async register(container) {
+        // Dynamically import FiveM implementations
+        const [{ FiveMMessagingTransport }, { FiveMEngineEvents }, { FiveMExports }, { FiveMResourceInfo }, { FiveMTick }, { FiveMPlayerInfo }, { FiveMEntityServer }, { FiveMPedServer }, { FiveMVehicleServer }, { FiveMPlayerServer }, { FiveMHasher }, { FiveMPedAppearanceServerAdapter }, { FiveMCapabilities },] = await Promise.all([
+            import('./transport/adapter'),
+            import('./fivem-engine-events'),
+            import('./fivem-exports'),
+            import('./fivem-resourceinfo'),
+            import('./fivem-tick'),
+            import('./fivem-playerinfo'),
+            import('./fivem-entity-server'),
+            import('./fivem-ped-server'),
+            import('./fivem-vehicle-server'),
+            import('./fivem-player-server'),
+            import('./fivem-hasher'),
+            import('./fivem-ped-appearance-server'),
+            import('./fivem-capabilities'),
+        ]);
+        // Register all FiveM implementations
+        if (!container.isRegistered(IPlatformCapabilities))
+            container.registerSingleton(IPlatformCapabilities, FiveMCapabilities);
+        if (!container.isRegistered(MessagingTransport)) {
+            const transport = new FiveMMessagingTransport();
+            container.registerInstance(MessagingTransport, transport);
+            container.registerInstance(EventsAPI, transport.events);
+            container.registerInstance(RpcAPI, transport.rpc);
+        }
+        if (!container.isRegistered(IEngineEvents))
+            container.registerSingleton(IEngineEvents, FiveMEngineEvents);
+        if (!container.isRegistered(IExports))
+            container.registerSingleton(IExports, FiveMExports);
+        if (!container.isRegistered(IResourceInfo))
+            container.registerSingleton(IResourceInfo, FiveMResourceInfo);
+        if (!container.isRegistered(ITick))
+            container.registerSingleton(ITick, FiveMTick);
+        if (!container.isRegistered(IPlayerInfo))
+            container.registerSingleton(IPlayerInfo, FiveMPlayerInfo);
+        if (!container.isRegistered(IEntityServer))
+            container.registerSingleton(IEntityServer, FiveMEntityServer);
+        if (!container.isRegistered(IPedServer))
+            container.registerSingleton(IPedServer, FiveMPedServer);
+        if (!container.isRegistered(IVehicleServer))
+            container.registerSingleton(IVehicleServer, FiveMVehicleServer);
+        if (!container.isRegistered(IPlayerServer))
+            container.registerSingleton(IPlayerServer, FiveMPlayerServer);
+        if (!container.isRegistered(IHasher))
+            container.registerSingleton(IHasher, FiveMHasher);
+        if (!container.isRegistered(IPedAppearanceServer))
+            container.registerSingleton(IPedAppearanceServer, FiveMPedAppearanceServerAdapter);
+    },
+};

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

@@ -0,0 +1,24 @@
+import { IPlayerServer } from '../contracts/server/IPlayerServer';
+import { type PlayerIdentifier } from '../contracts/types/identifier';
+/**
+ * FiveM implementation of server-side player operations.
+ */
+export declare class FiveMPlayerServer extends IPlayerServer {
+    getPed(playerSrc: string): number;
+    drop(playerSrc: string, reason: string): void;
+    getIdentifier(playerSrc: string, identifierType: string): string | undefined;
+    /**
+     * Get all identifiers registered.
+     *
+     * 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[];
+}

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

@@ -0,0 +1,83 @@
+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';
+/**
+ * FiveM implementation of server-side player operations.
+ */
+let FiveMPlayerServer = class FiveMPlayerServer extends IPlayerServer {
+    getPed(playerSrc) {
+        return GetPlayerPed(playerSrc);
+    }
+    drop(playerSrc, reason) {
+        DropPlayer(playerSrc, reason);
+    }
+    getIdentifier(playerSrc, identifierType) {
+        const numIdentifiers = this.getNumIdentifiers(playerSrc);
+        const prefix = `${identifierType}:`;
+        for (let i = 0; i < numIdentifiers; i++) {
+            const identifier = GetPlayerIdentifier(playerSrc, i);
+            if (identifier?.startsWith(prefix)) {
+                return identifier;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Get all identifiers registered.
+     *
+     * Use getPlayerIdentifiers() for structured identifier data.
+     */
+    getIdentifiers(playerSrc) {
+        const identifiers = [];
+        const numIdentifiers = this.getNumIdentifiers(playerSrc);
+        for (let i = 0; i < numIdentifiers; i++) {
+            const identifier = GetPlayerIdentifier(playerSrc, i);
+            if (identifier) {
+                identifiers.push(identifier);
+            }
+        }
+        return 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 GetNumPlayerIdentifiers(playerSrc);
+    }
+    getName(playerSrc) {
+        return GetPlayerName(playerSrc) || 'Unknown';
+    }
+    getPing(playerSrc) {
+        return GetPlayerPing(playerSrc);
+    }
+    getEndpoint(playerSrc) {
+        return GetPlayerEndpoint(playerSrc) || '';
+    }
+    setRoutingBucket(playerSrc, bucket) {
+        SetPlayerRoutingBucket(playerSrc, bucket);
+    }
+    getRoutingBucket(playerSrc) {
+        return GetPlayerRoutingBucket(playerSrc);
+    }
+    getConnectedPlayers() {
+        return getPlayers();
+    }
+};
+FiveMPlayerServer = __decorate([
+    injectable()
+], FiveMPlayerServer);
+export { FiveMPlayerServer };

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

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

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

@@ -0,0 +1,10 @@
+export class FiveMPlayerInfo {
+    getPlayerName(clientId) {
+        return GetPlayerName(clientId);
+    }
+    getPlayerPosition(clientId) {
+        const ped = GetPlayerPed(clientId);
+        const [x, y, z] = GetEntityCoords(ped, false);
+        return { x, y, z };
+    }
+}

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

@@ -0,0 +1,5 @@
+import { IResourceInfo } from '../contracts/IResourceInfo';
+export declare class FiveMResourceInfo extends IResourceInfo {
+    getCurrentResourceName(): string;
+    getCurrentResourcePath(): string;
+}

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

@@ -0,0 +1,24 @@
+import { IResourceInfo } from '../contracts/IResourceInfo';
+export class FiveMResourceInfo extends IResourceInfo {
+    getCurrentResourceName() {
+        const fn = GetCurrentResourceName;
+        if (typeof fn === 'function') {
+            const name = fn();
+            if (typeof name === 'string' && name.trim())
+                return name;
+        }
+        return 'default';
+    }
+    getCurrentResourcePath() {
+        const fn = globalThis.GetResourcePath;
+        if (typeof fn === 'function') {
+            const name = this.getCurrentResourceName();
+            if (name) {
+                const path = fn(name);
+                if (typeof path === 'string' && path.trim())
+                    return path;
+            }
+        }
+        return process.cwd();
+    }
+}

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

@@ -0,0 +1,7 @@
+import { ITick } from '../contracts/ITick';
+/**
+ * FiveM implementation of ITick using native setTick
+ */
+export declare class FiveMTick implements ITick {
+    setTick(handler: () => void | Promise<void>): void;
+}

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

@@ -0,0 +1,19 @@
+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';
+/**
+ * FiveM implementation of ITick using native setTick
+ */
+let FiveMTick = class FiveMTick {
+    setTick(handler) {
+        setTick(handler);
+    }
+};
+FiveMTick = __decorate([
+    injectable()
+], FiveMTick);
+export { FiveMTick };

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

@@ -0,0 +1,15 @@
+import { IVehicleServer } from '../contracts/server/IVehicleServer';
+/**
+ * FiveM implementation of server-side vehicle operations.
+ */
+export declare class FiveMVehicleServer extends IVehicleServer {
+    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;
+}

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

@@ -0,0 +1,44 @@
+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';
+/**
+ * FiveM implementation of server-side vehicle operations.
+ */
+let FiveMVehicleServer = class FiveMVehicleServer extends IVehicleServer {
+    createServerSetter(modelHash, vehicleType, x, y, z, heading) {
+        return CreateVehicleServerSetter(modelHash, vehicleType, x, y, z, heading);
+    }
+    getColours(handle) {
+        return GetVehicleColours(handle);
+    }
+    setColours(handle, primary, secondary) {
+        SetVehicleColours(handle, primary, secondary);
+    }
+    getNumberPlateText(handle) {
+        return GetVehicleNumberPlateText(handle);
+    }
+    setNumberPlateText(handle, text) {
+        SetVehicleNumberPlateText(handle, text);
+    }
+    setDoorsLocked(handle, state) {
+        SetVehicleDoorsLocked(handle, state);
+    }
+    getNetworkIdFromEntity(handle) {
+        return NetworkGetNetworkIdFromEntity(handle);
+    }
+    getEntityFromNetworkId(networkId) {
+        return NetworkGetEntityFromNetworkId(networkId);
+    }
+    networkIdExists(networkId) {
+        return NetworkDoesEntityExistWithNetworkId(networkId);
+    }
+};
+FiveMVehicleServer = __decorate([
+    injectable()
+], FiveMVehicleServer);
+export { FiveMVehicleServer };

package/dist/adapters/fivem/index.d.ts

@@ -0,0 +1,14 @@
+export { FiveMCapabilities } from './fivem-capabilities';
+export { FiveMEngineEvents } from './fivem-engine-events';
+export { FiveMEntityServer } from './fivem-entity-server';
+export { FiveMExports } from './fivem-exports';
+export { FiveMHasher } from './fivem-hasher';
+export { FiveMPedServer } from './fivem-ped-server';
+export { FiveMMessagingTransport } from './transport/adapter';
+export { FiveMPedAppearanceServerAdapter } from './fivem-ped-appearance-server';
+export { FiveMPlatform } from './fivem-platform';
+export { FiveMPlayerServer } from './fivem-player-server';
+export { FiveMPlayerInfo } from './fivem-playerinfo';
+export { FiveMResourceInfo } from './fivem-resourceinfo';
+export { FiveMTick } from './fivem-tick';
+export { FiveMVehicleServer } from './fivem-vehicle-server';

package/dist/adapters/fivem/index.js

@@ -0,0 +1,16 @@
+// FiveM implementations
+export { FiveMCapabilities } from './fivem-capabilities';
+export { FiveMEngineEvents } from './fivem-engine-events';
+export { FiveMEntityServer } from './fivem-entity-server';
+export { FiveMExports } from './fivem-exports';
+export { FiveMHasher } from './fivem-hasher';
+export { FiveMPedServer } from './fivem-ped-server';
+export { FiveMMessagingTransport } from './transport/adapter';
+export { FiveMPedAppearanceServerAdapter } from './fivem-ped-appearance-server';
+// Platform adapter
+export { FiveMPlatform } from './fivem-platform';
+export { FiveMPlayerServer } from './fivem-player-server';
+export { FiveMPlayerInfo } from './fivem-playerinfo';
+export { FiveMResourceInfo } from './fivem-resourceinfo';
+export { FiveMTick } from './fivem-tick';
+export { FiveMVehicleServer } from './fivem-vehicle-server';

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

@@ -0,0 +1,8 @@
+import { MessagingTransport } from '../../contracts/transport/messaging.transport';
+import { FiveMEvents } from './fivem.events';
+import { FiveMRpc } from './fivem.rpc';
+export declare class FiveMMessagingTransport extends MessagingTransport {
+    readonly context: string;
+    readonly events: FiveMEvents;
+    readonly rpc: FiveMRpc<"client" | "server">;
+}

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

@@ -0,0 +1,8 @@
+import { MessagingTransport } from '../../contracts/transport/messaging.transport';
+import { FiveMEvents } from './fivem.events';
+import { FiveMRpc } from './fivem.rpc';
+export class FiveMMessagingTransport extends MessagingTransport {
+    context = IsDuplicityVersion() ? 'server' : 'client';
+    events = new FiveMEvents(this.context);
+    rpc = new FiveMRpc(this.context);
+}

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

@@ -0,0 +1,8 @@
+import { EventsAPI } from '../../contracts/transport/events.api';
+import { RuntimeContext } from '../../contracts/transport/context';
+export declare class FiveMEvents extends EventsAPI<RuntimeContext> {
+    private readonly context;
+    constructor(context: RuntimeContext);
+    on(event: string, handler: any): void;
+    emit(event: string, ...args: any[]): void;
+}

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

@@ -0,0 +1,36 @@
+import { EventsAPI } from '../../contracts/transport/events.api';
+import { Player } from '../../../runtime/server/entities/player';
+export class FiveMEvents extends EventsAPI {
+    context;
+    constructor(context) {
+        super();
+        this.context = context;
+    }
+    on(event, handler) {
+        onNet(event, (...args) => {
+            const sourceId = this.context === 'server' ? global.source : undefined;
+            handler({ clientId: sourceId, raw: sourceId }, ...args);
+        });
+    }
+    emit(event, ...args) {
+        if (this.context !== 'server') {
+            emitNet(event, ...args);
+            return;
+        }
+        const [target, ...payload] = args;
+        const send = (id) => emitNet(event, id, ...payload);
+        if (target === 'all') {
+            send(-1);
+            return;
+        }
+        if (Array.isArray(target)) {
+            target.forEach(send);
+            return;
+        }
+        if (target instanceof Player) {
+            send(target.clientID);
+            return;
+        }
+        send(target);
+    }
+}

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

@@ -0,0 +1,28 @@
+import { RpcAPI } from '../../contracts/transport/rpc.api';
+import type { RuntimeContext } from '../../contracts/transport/context';
+export declare class FiveMRpc<C extends RuntimeContext = RuntimeContext> extends RpcAPI<C> {
+    private readonly context;
+    private readonly pending;
+    private requestSeq;
+    private readonly handlers;
+    private readonly channel;
+    private readonly requestEvent;
+    private readonly responseEvent;
+    private readonly defaultTimeoutMs;
+    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 sendAndWait;
+    private createRequestId;
+    private resolveServerTarget;
+    private handleRequestMessage;
+    private handleResponseMessage;
+    private emitResponse;
+}

package/dist/adapters/fivem/transport/fivem.rpc.js

@@ -0,0 +1,183 @@
+import { RpcAPI } from '../../contracts/transport/rpc.api';
+function getCurrentResourceNameSafe() {
+    const fn = globalThis.GetCurrentResourceName;
+    if (typeof fn === 'function') {
+        const name = fn();
+        if (typeof name === 'string' && name.trim())
+            return name;
+    }
+    return 'default';
+}
+export class FiveMRpc extends RpcAPI {
+    context;
+    pending = new Map();
+    requestSeq = 0;
+    handlers = new Map();
+    channel = getCurrentResourceNameSafe();
+    requestEvent = `__oc:rpc:req:${this.channel}`;
+    responseEvent = `__oc:rpc:res:${this.channel}`;
+    defaultTimeoutMs = 7_500;
+    constructor(context) {
+        super();
+        this.context = context;
+        onNet(this.requestEvent, (msg) => {
+            void this.handleRequestMessage(msg);
+        });
+        onNet(this.responseEvent, (msg) => {
+            this.handleResponseMessage(msg);
+        });
+    }
+    on(name, handler) {
+        this.handlers.set(name, handler);
+    }
+    call(name, ...args) {
+        const { target, payload } = this.normalizeInvocation(name, 'call', args);
+        return this.sendAndWait({ kind: 'call', name, args: payload }, target);
+    }
+    notify(name, ...args) {
+        const { target, payload } = this.normalizeInvocation(name, 'notify', args);
+        return this.sendAndWait({ kind: 'notify', name, args: payload }, target);
+    }
+    normalizeInvocation(name, kind, args) {
+        if (this.context === 'server') {
+            if (args.length === 0) {
+                throw new Error(`FiveMRpc: missing target for '${kind}' '${name}' in server context`);
+            }
+            const [target, ...payload] = args;
+            if (!this.isValidTarget(target)) {
+                throw new Error(`FiveMRpc: invalid target for '${kind}' '${name}'`);
+            }
+            if (kind === 'call' && target === 'all') {
+                throw new Error(`FiveMRpc: target=all is not supported for call '${name}'`);
+            }
+            return { target, payload };
+        }
+        return { target: undefined, payload: args };
+    }
+    isValidTarget(value) {
+        if (value === 'all')
+            return true;
+        if (typeof value === 'number')
+            return true;
+        if (Array.isArray(value))
+            return value.every((item) => typeof item === 'number');
+        return false;
+    }
+    sendAndWait(input, target) {
+        const id = this.createRequestId();
+        const msg = {
+            kind: input.kind,
+            id,
+            name: input.name,
+            args: input.args ?? [],
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`FiveMRpc: timeout waiting for '${input.kind}' response for '${input.name}' (${id})`));
+            }, this.defaultTimeoutMs);
+            this.pending.set(id, { resolve: resolve, reject, timeout });
+            if (this.context === 'server') {
+                const resolvedTarget = this.resolveServerTarget(target, input.kind, input.name);
+                emitNet(this.requestEvent, resolvedTarget, msg);
+            }
+            else {
+                emitNet(this.requestEvent, msg);
+            }
+        });
+    }
+    createRequestId() {
+        this.requestSeq += 1;
+        const ts = Date.now().toString(36);
+        const seq = this.requestSeq.toString(36);
+        const rand = Math.floor(Math.random() * 1_000_000_000).toString(36);
+        return `${this.channel}:${this.context}:${ts}:${seq}:${rand}`;
+    }
+    resolveServerTarget(target, kind, name) {
+        if (target === undefined) {
+            throw new Error(`FiveMRpc: missing target for '${kind}' '${name}' in server context`);
+        }
+        if (kind === 'call' && target === 'all') {
+            throw new Error(`FiveMRpc: target=all is not supported for call '${name}'`);
+        }
+        if (target === 'all')
+            return -1;
+        return target;
+    }
+    async handleRequestMessage(msg) {
+        if (msg.kind !== 'call' && msg.kind !== 'notify')
+            return;
+        const handler = this.handlers.get(msg.name);
+        const sourceId = this.context === 'server' ? global.source : undefined;
+        const replyTarget = this.context === 'server' ? sourceId : undefined;
+        if (!handler) {
+            if (msg.kind === 'call') {
+                this.emitResponse(replyTarget, {
+                    kind: 'result',
+                    id: msg.id,
+                    ok: false,
+                    error: { message: `FiveMRpc: no handler registered for '${msg.name}'` },
+                });
+            }
+            else {
+                this.emitResponse(replyTarget, { kind: 'ack', id: msg.id });
+            }
+            return;
+        }
+        try {
+            const result = await Promise.resolve(handler({
+                requestId: msg.id,
+                clientId: sourceId,
+                raw: sourceId,
+            }, ...msg.args));
+            if (msg.kind === 'notify') {
+                this.emitResponse(replyTarget, { kind: 'ack', id: msg.id });
+            }
+            else {
+                this.emitResponse(replyTarget, { kind: 'result', id: msg.id, ok: true, result });
+            }
+        }
+        catch (err) {
+            if (msg.kind === 'notify') {
+                this.emitResponse(replyTarget, { kind: 'ack', id: msg.id });
+                return;
+            }
+            this.emitResponse(replyTarget, {
+                kind: 'result',
+                id: msg.id,
+                ok: false,
+                error: {
+                    message: err?.message ? String(err.message) : String(err),
+                    name: err?.name ? String(err.name) : undefined,
+                },
+            });
+        }
+    }
+    handleResponseMessage(msg) {
+        if (msg.kind !== 'result' && msg.kind !== 'ack')
+            return;
+        const pending = this.pending.get(msg.id);
+        if (!pending)
+            return;
+        clearTimeout(pending.timeout);
+        this.pending.delete(msg.id);
+        if (msg.kind === 'ack') {
+            pending.resolve(undefined);
+            return;
+        }
+        if (msg.ok) {
+            pending.resolve(msg.result);
+            return;
+        }
+        const error = new Error(msg.error?.message ?? 'FiveMRpc: remote error');
+        error.name = msg.error?.name ?? error.name;
+        pending.reject(error);
+    }
+    emitResponse(target, msg) {
+        if (this.context === 'server') {
+            emitNet(this.responseEvent, target ?? -1, msg);
+            return;
+        }
+        emitNet(this.responseEvent, msg);
+    }
+}

package/dist/adapters/index.d.ts

@@ -0,0 +1,21 @@
+export * from './contracts/client/IPedAppearanceClient';
+export * from './contracts/IEngineEvents';
+export * from './contracts/IExports';
+export * from './contracts/IHasher';
+export * from './contracts/IPlatformCapabilities';
+export * from './contracts/IPlayerInfo';
+export * from './contracts/IResourceInfo';
+export * from './contracts/ITick';
+export * from './contracts/transport/context';
+export * from './contracts/transport/events.api';
+export * from './contracts/transport/messaging.transport';
+export * from './contracts/transport/rpc.api';
+export * from './contracts/server/IEntityServer';
+export * from './contracts/server/IPedServer';
+export * from './contracts/server/IPedAppearanceServer';
+export * from './contracts/server/IPlayerServer';
+export * from './contracts/server/IVehicleServer';
+export * from './contracts/types/identifier';
+export * from './platform/platform-registry';
+export * from './register-capabilities';
+export * from './cfx';