@open-core/ragemp-adapter 0.1.1 → 1.0.2

package/dist/server/ragemp-exports.js

@@ -16,17 +16,218 @@ exports.RageMPExports = void 0;
 const tsyringe_1 = require("tsyringe");
 const server_1 = require("@open-core/framework/contracts/server");
 const exports_registry_1 = require("../shared/exports-registry");
+const REQUEST_EVENT_PREFIX = '__oc:exports:req:';
+const RESPONSE_EVENT_PREFIX = '__oc:exports:res:';
+const EXPORTS_TIMEOUT_MS = 7500;
+const WAIT_INTERVAL_MS = 150;
+const META_HAS_EXPORT = '__oc_meta_has_export__';
+function isObjectRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isPlayerMpLike(value) {
+    return isObjectRecord(value) && 'id' in value && 'serial' in value;
+}
+function isExportRequestPayload(value) {
+    return (isObjectRecord(value) &&
+        typeof value.requestId === 'string' &&
+        typeof value.callerResource === 'string' &&
+        typeof value.exportName === 'string' &&
+        Array.isArray(value.args));
+}
+function isExportResponsePayload(value) {
+    if (!isObjectRecord(value) ||
+        typeof value.requestId !== 'string' ||
+        typeof value.ok !== 'boolean') {
+        return false;
+    }
+    if (value.ok) {
+        return true;
+    }
+    return (isObjectRecord(value.error) &&
+        typeof value.error.name === 'string' &&
+        typeof value.error.message === 'string');
+}
 let RageMPExports = class RageMPExports extends server_1.IExports {
     constructor(resourceInfo) {
         super();
         this.resourceInfo = resourceInfo;
+        this.pendingRequests = new Map();
+        this.localHandlers = new Map();
+        this.currentResourceName = this.resourceInfo.getCurrentResourceName();
+        this.requestEventName = `${REQUEST_EVENT_PREFIX}${this.currentResourceName}`;
+        this.responseEventName = `${RESPONSE_EVENT_PREFIX}${this.currentResourceName}`;
+        this.registerTransportListeners();
     }
     register(exportName, handler) {
-        exports_registry_1.exportsRegistry.register(this.resourceInfo.getCurrentResourceName(), exportName, handler);
+        this.localHandlers.set(exportName, handler);
+        exports_registry_1.exportsRegistry.register(this.currentResourceName, exportName, handler);
     }
+    /**
+     * Resolves exports through the local registry shared by the current adapter runtime.
+     */
     getResource(resourceName) {
         return exports_registry_1.exportsRegistry.resourceProxy(resourceName);
     }
+    /**
+     * Returns an async proxy that forwards method calls to another server resource.
+     *
+     * @remarks
+     * The proxy intentionally ignores Promise-like properties (`then`, `catch`, `finally`)
+     * so `await` does not accidentally treat the proxy itself as a thenable.
+     */
+    getRemoteResource(resourceName) {
+        return new Proxy({}, {
+            get: (_, exportName) => {
+                if (typeof exportName !== 'string' ||
+                    exportName === 'then' ||
+                    exportName === 'catch' ||
+                    exportName === 'finally') {
+                    return undefined;
+                }
+                return (...args) => this.callRemoteExport(resourceName, exportName, ...args);
+            },
+        });
+    }
+    /**
+     * Invokes a remote export by sending a server-side RageMP event to the target resource.
+     */
+    callRemoteExport(resourceName, exportName, ...args) {
+        const requestId = this.createRequestId(resourceName, exportName);
+        const requestEventName = `${REQUEST_EVENT_PREFIX}${resourceName}`;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(requestId);
+                reject(new Error(`[exports] Timed out calling "${exportName}" on resource "${resourceName}".`));
+            }, EXPORTS_TIMEOUT_MS);
+            this.pendingRequests.set(requestId, { resolve, reject, timeout });
+            mp.events.call(requestEventName, {
+                requestId,
+                callerResource: this.currentResourceName,
+                exportName,
+                args,
+            });
+        });
+    }
+    /**
+     * Waits for a remote resource to expose a matching export before returning the async proxy.
+     */
+    async waitForRemoteResource(resourceName, options) {
+        const timeoutMs = options?.timeoutMs ?? EXPORTS_TIMEOUT_MS;
+        const intervalMs = options?.intervalMs ?? WAIT_INTERVAL_MS;
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < timeoutMs) {
+            try {
+                const isAvailable = await this.callRemoteExport(resourceName, META_HAS_EXPORT, options?.exportName);
+                if (isAvailable) {
+                    return this.getRemoteResource(resourceName);
+                }
+            }
+            catch {
+                // Ignore transient availability failures while waiting.
+            }
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+        throw new Error(`[exports] Timed out waiting for resource "${resourceName}" remote exports.`);
+    }
+    /**
+     * Installs the request/response listeners used by the optional remote export helper layer.
+     *
+     * @remarks
+     * The listeners reject payloads that look like player-originated server events so clients
+     * cannot invoke server resource exports through this transport.
+     */
+    registerTransportListeners() {
+        mp.events.add(this.requestEventName, (...args) => {
+            const payload = args[0];
+            if (isPlayerMpLike(payload) || !isExportRequestPayload(payload)) {
+                return;
+            }
+            void this.handleExportRequest(payload);
+        });
+        mp.events.add(this.responseEventName, (...args) => {
+            const payload = args[0];
+            if (isPlayerMpLike(payload) || !isExportResponsePayload(payload)) {
+                return;
+            }
+            this.handleExportResponse(payload);
+        });
+    }
+    /**
+     * Executes one remote export request against handlers registered in the current resource.
+     */
+    async handleExportRequest(payload) {
+        const responseEventName = `${RESPONSE_EVENT_PREFIX}${payload.callerResource}`;
+        try {
+            const result = await this.executeLocalExport(payload.exportName, payload.args);
+            mp.events.call(responseEventName, {
+                requestId: payload.requestId,
+                ok: true,
+                result,
+            });
+        }
+        catch (error) {
+            mp.events.call(responseEventName, {
+                requestId: payload.requestId,
+                ok: false,
+                error: this.serializeError(error),
+            });
+        }
+    }
+    /**
+     * Resolves or rejects the pending promise associated with a remote export response.
+     */
+    handleExportResponse(payload) {
+        const pendingRequest = this.pendingRequests.get(payload.requestId);
+        if (!pendingRequest) {
+            return;
+        }
+        clearTimeout(pendingRequest.timeout);
+        this.pendingRequests.delete(payload.requestId);
+        if (payload.ok) {
+            pendingRequest.resolve(payload.result);
+            return;
+        }
+        pendingRequest.reject(this.deserializeError(payload.error));
+    }
+    /**
+     * Executes an export from the current resource without going back through the shared registry.
+     */
+    async executeLocalExport(exportName, args) {
+        if (exportName === META_HAS_EXPORT) {
+            const requestedExportName = typeof args[0] === 'string' ? args[0] : undefined;
+            if (!requestedExportName) {
+                return this.localHandlers.size > 0;
+            }
+            return this.localHandlers.has(requestedExportName);
+        }
+        const handler = this.localHandlers.get(exportName);
+        if (!handler) {
+            throw new Error(`[exports] Export "${exportName}" not found in resource "${this.currentResourceName}".`);
+        }
+        return Promise.resolve(handler(...args));
+    }
+    createRequestId(resourceName, exportName) {
+        return `${this.currentResourceName}:${resourceName}:${exportName}:${Date.now()}:${Math.random()}`;
+    }
+    serializeError(error) {
+        if (error instanceof Error) {
+            return {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+            };
+        }
+        return {
+            name: 'Error',
+            message: String(error),
+        };
+    }
+    deserializeError(error) {
+        const result = new Error(error.message);
+        result.name = error.name;
+        result.stack = error.stack;
+        return result;
+    }
 };
 exports.RageMPExports = RageMPExports;
 exports.RageMPExports = RageMPExports = __decorate([

package/dist/server/ragemp-player-appearance-lifecycle-server.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageMPPlayerAppearanceLifecycleServer = void 0;
 const tsyringe_1 = require("tsyringe");
 const contracts_1 = require("@open-core/framework/contracts");
+const framework_1 = require("@open-core/framework");
 const server_1 = require("@open-core/framework/server");
 const server_2 = require("@open-core/framework/contracts/server");
 const server_3 = require("@open-core/framework/contracts/server");
@@ -33,21 +34,21 @@ let RageMPPlayerAppearanceLifecycleServer = class RageMPPlayerAppearanceLifecycl
         if (appearance.model) {
             this.playerServer.setModel(playerSrc, appearance.model);
         }
-        this.events.emit('opencore:appearance:apply', target, appearance);
+        this.events.emit(framework_1.SYSTEM_EVENTS.appearance.apply, target, appearance);
         return { success: true, appearance };
     }
     applyClothing(playerSrc, appearance) {
         const target = this.resolveTarget(playerSrc);
         if (!target)
             return false;
-        this.events.emit('opencore:appearance:apply', target, appearance);
+        this.events.emit(framework_1.SYSTEM_EVENTS.appearance.apply, target, appearance);
         return true;
     }
     reset(playerSrc) {
         const target = this.resolveTarget(playerSrc);
         if (!target)
             return false;
-        this.events.emit('opencore:appearance:reset', target);
+        this.events.emit(framework_1.SYSTEM_EVENTS.appearance.reset, target);
         return true;
     }
     resolveTarget(playerSrc) {

package/dist/server/ragemp-resourceinfo.js

@@ -4,6 +4,9 @@ exports.RageMPResourceInfo = void 0;
 const server_1 = require("@open-core/framework/contracts/server");
 class RageMPResourceInfo extends server_1.IResourceInfo {
     getCurrentResourceName() {
+        if (typeof __OPENCORE_RESOURCE_NAME__ === 'string' && __OPENCORE_RESOURCE_NAME__.trim()) {
+            return __OPENCORE_RESOURCE_NAME__;
+        }
         if (typeof __dirname !== 'string')
             return 'default';
         const normalized = __dirname.replace(/\\/g, '/');

package/dist/shared/exports-registry.d.ts

@@ -11,7 +11,7 @@ export type ExportsProxy = {
 export declare class ExportsRegistry {
     private readonly registry;
     private readonly namespaceProxyCache;
-    register(resource: string, name: string, handler: ExportHandler): void;
+    register<TArgs extends readonly unknown[], TResult = unknown>(resource: string, name: string, handler: (...args: TArgs) => TResult): void;
     call(resource: string, name: string, ...args: ExportArgs): unknown;
     private createNamespaceProxy;
     private getOrCreateNamespaceProxy;
@@ -24,6 +24,6 @@ export declare class ExportsRegistry {
     list(resource: string): string[];
 }
 export declare const exportsRegistry: ExportsRegistry;
-export declare function registerExport(resource: string, name: string, handler: ExportHandler): void;
+export declare function registerExport<TArgs extends readonly unknown[], TResult = unknown>(resource: string, name: string, handler: (...args: TArgs) => TResult): void;
 export declare function callExport(resource: string, name: string, ...args: ExportArgs): unknown;
 export {};

package/dist/shared/transport/helpers.d.ts

@@ -5,10 +5,10 @@ import type { RuntimeContext } from '@open-core/framework/contracts';
  *
  * Analogous to FiveM's `onNet`:
  * - Server: RageMP prepends the PlayerMp as the first native argument.
- *   We expose it as-is so callers can read player.id before any await.
+ *   We expose it as-is so callers can read player.id before awaiting.
  * - Client: no source argument; we pass undefined to keep the signature uniform.
  */
-export declare function onNet(context: RuntimeContext, event: string, handler: (source: PlayerMp | undefined, ...args: any[]) => void): void;
+export declare function onNet<TArgs extends readonly unknown[]>(context: RuntimeContext, event: string, handler: (source: PlayerMp | undefined, ...args: TArgs) => void): void;
 /**
  * Normalizes RageMP's server/client event emission into a single interface.
  *
@@ -21,4 +21,4 @@ export declare function onNet(context: RuntimeContext, event: string, handler: (
  * NOTE: Only player targets are supported — vehicles/peds are not valid
  * network targets, matching FiveM's TriggerClientEvent semantics.
  */
-export declare function emitNet(context: RuntimeContext, event: string, target: number | number[] | -1, ...payload: any[]): void;
+export declare function emitNet(context: RuntimeContext, event: string, target: number | number[] | -1, ...payload: unknown[]): void;

package/dist/shared/transport/helpers.js

@@ -2,6 +2,29 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.onNet = onNet;
 exports.emitNet = emitNet;
+const JSON_WIRE_PREFIX = '__OPENCORE_JSON__:';
+function serializeWireValue(value) {
+    if (value === null || value === undefined)
+        return value;
+    if (Array.isArray(value) || (typeof value === 'object' && value.constructor === Object)) {
+        return `${JSON_WIRE_PREFIX}${JSON.stringify(value)}`;
+    }
+    return value;
+}
+function deserializeWireValue(value) {
+    if (typeof value !== 'string' || !value.startsWith(JSON_WIRE_PREFIX)) {
+        return value;
+    }
+    try {
+        return JSON.parse(value.slice(JSON_WIRE_PREFIX.length));
+    }
+    catch {
+        return value;
+    }
+}
+function deserializeWireArgs(args) {
+    return args.map((arg) => deserializeWireValue(arg));
+}
 /**
  * Resolves a player by numeric ID, returning undefined when the player no
  * longer exists (disconnected, invalid handle, etc.).
@@ -21,7 +44,7 @@ function resolvePlayer(id) {
  *
  * Analogous to FiveM's `onNet`:
  * - Server: RageMP prepends the PlayerMp as the first native argument.
- *   We expose it as-is so callers can read player.id before any await.
+ *   We expose it as-is so callers can read player.id before awaiting.
  * - Client: no source argument; we pass undefined to keep the signature uniform.
  */
 function onNet(context, event, handler) {
@@ -32,11 +55,13 @@ function onNet(context, event, handler) {
             // all other events should be safe to guard this way.
             if (!mp.players.exists(player.id))
                 return;
-            handler(player, ...args);
+            handler(player, ...deserializeWireArgs(args));
         });
     }
     else {
-        mp.events.add(event, (...args) => handler(undefined, ...args));
+        mp.events.add(event, (...args) => {
+            handler(undefined, ...deserializeWireArgs(args));
+        });
     }
 }
 /**
@@ -52,19 +77,20 @@ function onNet(context, event, handler) {
  * network targets, matching FiveM's TriggerClientEvent semantics.
  */
 function emitNet(context, event, target, ...payload) {
+    const serializedPayload = payload.map((item) => serializeWireValue(item));
     if (context !== 'server') {
-        mp.events.callRemote(event, ...payload);
+        mp.events.callRemote(event, ...serializedPayload);
         return;
     }
     if (target === -1) {
-        mp.players.call(event, payload);
+        mp.players.call(event, serializedPayload);
         return;
     }
     if (Array.isArray(target)) {
         for (const id of target) {
-            resolvePlayer(id)?.call(event, payload);
+            resolvePlayer(id)?.call(event, serializedPayload);
         }
         return;
     }
-    resolvePlayer(target)?.call(event, payload);
+    resolvePlayer(target)?.call(event, serializedPayload);
 }

package/dist/shared/transport/ragemp.events.d.ts

@@ -2,9 +2,9 @@ import { EventsAPI, type RuntimeContext } from '@open-core/framework/contracts';
 export declare class RageMPEvents extends EventsAPI<RuntimeContext> {
     private readonly context;
     constructor(context: RuntimeContext);
-    on(event: string, handler: (source: {
+    on<TArgs extends readonly unknown[]>(event: string, handler: (source: {
         clientId: number | undefined;
         raw: PlayerMp | undefined;
-    }, ...args: any[]) => void): void;
-    emit(event: string, ...args: any[]): void;
+    }, ...args: TArgs) => void | Promise<void>): void;
+    emit(event: string, ...args: unknown[]): void;
 }

package/dist/shared/transport/ragemp.events.js

@@ -16,7 +16,7 @@ class RageMPEvents extends contracts_1.EventsAPI {
     }
     on(event, handler) {
         (0, helpers_1.onNet)(this.context, event, (source, ...args) => {
-            handler({ clientId: source?.id, raw: source }, ...args);
+            void handler({ clientId: source?.id, raw: source }, ...args);
         });
     }
     emit(event, ...args) {
@@ -39,7 +39,9 @@ class RageMPEvents extends contracts_1.EventsAPI {
             (0, helpers_1.emitNet)(this.context, event, target.clientID, ...payload);
             return;
         }
-        (0, helpers_1.emitNet)(this.context, event, target, ...payload);
+        if (typeof target === 'number') {
+            (0, helpers_1.emitNet)(this.context, event, target, ...payload);
+        }
     }
 }
 exports.RageMPEvents = RageMPEvents;

package/dist/shared/transport/ragemp.rpc.d.ts

@@ -1,4 +1,4 @@
-import { RpcAPI, type RuntimeContext } from '@open-core/framework/contracts';
+import { RpcAPI, type RpcContext, type RuntimeContext } from '@open-core/framework/contracts';
 export declare class RageMPRpc<C extends RuntimeContext = RuntimeContext> extends RpcAPI<C> {
     private readonly context;
     private readonly pending;
@@ -9,13 +9,9 @@ export declare class RageMPRpc<C extends RuntimeContext = RuntimeContext> extend
     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>;
+    on<TArgs extends readonly unknown[], TResult>(name: string, handler: (ctx: RpcContext, ...args: TArgs) => TResult | Promise<TResult>): void;
+    call<TResult = unknown>(name: string, ...args: unknown[]): Promise<TResult>;
+    notify(name: string, ...args: unknown[]): Promise<void>;
     private normalizeInvocation;
     private isValidTarget;
     private sendAndWait;

package/dist/shared/transport/ragemp.rpc.js

@@ -3,7 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageMPRpc = void 0;
 const contracts_1 = require("@open-core/framework/contracts");
 const helpers_1 = require("./helpers");
+function serializeRpcError(error) {
+    if (typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        typeof error.message === 'string' &&
+        'expose' in error &&
+        error.expose === true) {
+        return {
+            message: error.message,
+            name: 'name' in error && typeof error.name === 'string' ? error.name : undefined,
+        };
+    }
+    return { message: 'An internal server error occurred' };
+}
 function getCurrentResourceNameSafe() {
+    if (typeof __OPENCORE_RESOURCE_NAME__ === 'string' && __OPENCORE_RESOURCE_NAME__.trim()) {
+        return __OPENCORE_RESOURCE_NAME__;
+    }
     if (typeof __dirname !== 'string')
         return 'default';
     const parts = __dirname.replace(/\\/g, '/').split('/');
@@ -28,7 +45,7 @@ class RageMPRpc extends contracts_1.RpcAPI {
         });
     }
     on(name, handler) {
-        this.handlers.set(name, handler);
+        this.handlers.set(name, (ctx, ...args) => handler(ctx, ...args));
     }
     call(name, ...args) {
         const { target, payload } = this.normalizeInvocation(name, 'call', args);
@@ -76,7 +93,7 @@ class RageMPRpc extends contracts_1.RpcAPI {
                 this.pending.delete(id);
                 reject(new Error(`RageMPRpc: timeout waiting for '${input.kind}' response for '${input.name}' (${id})`));
             }, this.defaultTimeoutMs);
-            this.pending.set(id, { resolve: resolve, reject, timeout });
+            this.pending.set(id, { resolve: (value) => resolve(value), reject, timeout });
             if (this.context === 'server') {
                 const resolvedTarget = this.resolveServerTarget(target, input.kind, input.name);
                 (0, helpers_1.emitNet)(this.context, this.requestEvent, resolvedTarget, msg);
@@ -139,6 +156,7 @@ class RageMPRpc extends contracts_1.RpcAPI {
             }
         }
         catch (err) {
+            const errorInfo = serializeRpcError(err);
             if (msg.kind === 'notify') {
                 this.emitResponse(replyTarget, { kind: 'ack', id: msg.id });
                 return;
@@ -148,8 +166,8 @@ class RageMPRpc extends contracts_1.RpcAPI {
                 id: msg.id,
                 ok: false,
                 error: {
-                    message: err?.message ? String(err.message) : String(err),
-                    name: err?.name ? String(err.name) : undefined,
+                    message: errorInfo.message,
+                    name: errorInfo.name,
                 },
             });
         }
@@ -171,7 +189,13 @@ class RageMPRpc extends contracts_1.RpcAPI {
             return;
         }
         const error = new Error(msg.error?.message ?? 'RageMPRpc: remote error');
-        error.name = msg.error?.name ?? error.name;
+        if (msg.error?.name) {
+            Object.defineProperty(error, 'name', {
+                value: msg.error.name,
+                configurable: true,
+                writable: true,
+            });
+        }
         pending.reject(error);
     }
     emitResponse(target, msg) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-core/ragemp-adapter",
-  "version": "0.1.1",
+  "version": "1.0.2",
   "description": "External Rage Multiplayer adapter for OpenCore framework.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,20 +37,18 @@
     "adapter"
   ],
   "license": "MPL-2.0",
-  "dependencies": {
-    "@open-core/framework": "v1.0.5-beta.2"
-  },
   "peerDependencies": {
     "reflect-metadata": "^0.2.2",
     "tsyringe": "^4.10.0",
     "zod": "^4.3.5"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.11",
+    "@biomejs/biome": "^2.4.10",
+    "@open-core/framework": "latest",
     "@ragempcommunity/types-client": "^2.1.9",
     "@ragempcommunity/types-server": "^2.1.9",
-    "@types/node": "^25.0.3",
-    "typescript": "^5.9.3"
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
   },
   "scripts": {
     "build": "tsc -b",