@open-core/framework 1.0.9 → 1.0.11

package/dist/runtime/client/decorators/onView.d.ts

@@ -1,3 +1,6 @@
+export interface OnViewOptions {
+    viewId?: string;
+}
 /**
  * Registers a method as a WebView callback handler.
  *
@@ -5,7 +8,12 @@
  * This decorator only stores metadata. During bootstrap, the framework binds the decorated method
  * to the active WebView runtime callback.
  *
+ * If `options.viewId` is provided, the handler will only receive messages from the
+ * specified WebView viewId. Without it, the handler receives events from all views.
+ *
  * @param eventName - Callback name.
+ * @param options - Optional configuration. Pass `{ viewId: 'my-view' }` to
+ *   filter incoming messages by viewId.
  *
  * @example
  * ```ts
@@ -15,7 +23,12 @@
  *   saveSettings(payload: unknown) {
  *     // ...
  *   }
+ *
+ *   @Client.onView('system-ui:ready', { viewId: 'system-ui' })
+ *   onSystemUiReady() {
+ *     // Only fires for the 'system-ui' WebView
+ *   }
  * }
  * ```
  */
-export declare function OnView(eventName: string): (target: any, propertyKey: string) => void;
+export declare function OnView(eventName: string, options?: OnViewOptions): (target: any, propertyKey: string) => void;

package/dist/runtime/client/decorators/onView.js

@@ -6,7 +6,12 @@ import { METADATA_KEYS } from '../system/metadata-client.keys';
  * This decorator only stores metadata. During bootstrap, the framework binds the decorated method
  * to the active WebView runtime callback.
  *
+ * If `options.viewId` is provided, the handler will only receive messages from the
+ * specified WebView viewId. Without it, the handler receives events from all views.
+ *
  * @param eventName - Callback name.
+ * @param options - Optional configuration. Pass `{ viewId: 'my-view' }` to
+ *   filter incoming messages by viewId.
  *
  * @example
  * ```ts
@@ -16,11 +21,16 @@ import { METADATA_KEYS } from '../system/metadata-client.keys';
  *   saveSettings(payload: unknown) {
  *     // ...
  *   }
+ *
+ *   @Client.onView('system-ui:ready', { viewId: 'system-ui' })
+ *   onSystemUiReady() {
+ *     // Only fires for the 'system-ui' WebView
+ *   }
  * }
  * ```
  */
-export function OnView(eventName) {
+export function OnView(eventName, options) {
     return (target, propertyKey) => {
-        Reflect.defineMetadata(METADATA_KEYS.VIEW, { eventName }, target, propertyKey);
+        Reflect.defineMetadata(METADATA_KEYS.VIEW, { eventName, viewId: options?.viewId }, target, propertyKey);
     };
 }

package/dist/runtime/client/system/processors/view.processor.d.ts

@@ -6,5 +6,6 @@ export declare class ViewProcessor implements DecoratorProcessor {
     constructor(webviews: WebViewService);
     process(target: any, methodName: string, metadata: {
         eventName: string;
+        viewId?: string;
     }): void;
 }

package/dist/runtime/client/system/processors/view.processor.js

@@ -26,6 +26,8 @@ let ViewProcessor = class ViewProcessor {
         this.webviews.onMessage(async (message) => {
             if (message.event !== metadata.eventName)
                 return;
+            if (metadata.viewId && message.viewId !== metadata.viewId)
+                return;
             try {
                 await handler(message.payload);
             }
@@ -36,7 +38,7 @@ let ViewProcessor = class ViewProcessor {
                 }, error);
             }
         });
-        loggers.webView.debug(`Registered WebView callback: ${metadata.eventName} -> ${handlerName}`);
+        loggers.webView.debug(`Registered WebView callback: ${metadata.eventName}${metadata.viewId ? ` [viewId=${metadata.viewId}]` : ''} -> ${handlerName}`);
     }
 };
 ViewProcessor = __decorate([

package/dist/runtime/client/webview-bridge.d.ts

@@ -32,3 +32,4 @@ export declare class NuiBridge<TSend extends Record<string, any> = Record<string
 }
 export declare const WebView: WebViewBridge<Record<string, any>, Record<string, any>>;
 export declare const NUI: WebViewBridge<Record<string, any>, Record<string, any>>;
+export declare function createWebView<TSend extends Record<string, any> = Record<string, any>, TReceive extends Record<string, any> = Record<string, any>>(viewId: string): WebViewBridge<TSend, TReceive>;

package/dist/runtime/client/webview-bridge.js

@@ -101,3 +101,6 @@ function resolveWebViewService() {
 }
 export const WebView = new WebViewBridge(resolveWebViewService);
 export const NUI = WebView;
+export function createWebView(viewId) {
+    return new WebViewBridge(resolveWebViewService, viewId);
+}

package/dist/runtime/server/controllers/player-export.controller.d.ts

@@ -23,6 +23,8 @@ export declare class PlayerExportController implements InternalPlayerExports {
     isPlayerOnline(accountId: string): boolean;
     getPlayerMeta(clientID: number, key: string): Promise<any>;
     setPlayerMeta(clientID: number, key: string, value: any): void;
+    linkPlayerAccount(clientID: number, accountID: string): void;
+    unlinkPlayerAccount(clientID: number): void;
     getPlayerStates(clientID: number): string[];
     hasPlayerState(clientID: number, state: string): boolean;
     addPlayerState(clientID: number, state: string): void;

package/dist/runtime/server/controllers/player-export.controller.js

@@ -11,6 +11,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject } from 'tsyringe';
+import { loggers } from '../../../kernel/logger';
 import { Controller } from '../decorators/controller';
 import { Export } from '../decorators/export';
 import { serializeServerPlayerData } from '../adapter/serialization';
@@ -67,6 +68,27 @@ let PlayerExportController = class PlayerExportController {
     setPlayerMeta(clientID, key, value) {
         this.playerService.setMeta(clientID, key, value);
     }
+    linkPlayerAccount(clientID, accountID) {
+        const player = this.playerService.getByClient(clientID);
+        if (!player)
+            return;
+        player.linkAccount(accountID);
+        loggers.session.debug('Remote player account linked in CORE', {
+            clientID,
+            accountID,
+        });
+    }
+    unlinkPlayerAccount(clientID) {
+        const player = this.playerService.getByClient(clientID);
+        if (!player)
+            return;
+        const previousAccountID = player.accountID;
+        player.unlinkAccount();
+        loggers.session.debug('Remote player account unlinked in CORE', {
+            clientID,
+            accountID: previousAccountID,
+        });
+    }
     // ═══════════════════════════════════════════════════════════════
     // State Management
     // ═══════════════════════════════════════════════════════════════
@@ -141,6 +163,18 @@ __decorate([
     __metadata("design:paramtypes", [Number, String, Object]),
     __metadata("design:returntype", void 0)
 ], PlayerExportController.prototype, "setPlayerMeta", null);
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, String]),
+    __metadata("design:returntype", void 0)
+], PlayerExportController.prototype, "linkPlayerAccount", null);
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", void 0)
+], PlayerExportController.prototype, "unlinkPlayerAccount", null);
 __decorate([
     Export(),
     __metadata("design:type", Function),

package/dist/runtime/server/implementations/remote/player.remote.d.ts

@@ -35,6 +35,10 @@ export declare class RemotePlayerImplementation extends Players {
      */
     private get core();
     private createPlayerFromData;
+    /**
+     * Proxies remote session mutations to CORE so security-critical data remains authoritative.
+     */
+    private attachAuthoritativeMutators;
     /**
      * Returns a Player instance with real session data from CORE.
      */

package/dist/runtime/server/implementations/remote/player.remote.js

@@ -77,7 +77,73 @@ let RemotePlayerImplementation = class RemotePlayerImplementation extends Player
         return coreExports;
     }
     createPlayerFromData(data) {
-        return createRemoteServerPlayer(data, this.playerAdapters);
+        const player = createRemoteServerPlayer(data, this.playerAdapters);
+        this.attachAuthoritativeMutators(player);
+        return player;
+    }
+    /**
+     * Proxies remote session mutations to CORE so security-critical data remains authoritative.
+     */
+    attachAuthoritativeMutators(player) {
+        const core = this.core;
+        const originalSetMeta = player.setMeta.bind(player);
+        const originalLinkAccount = player.linkAccount.bind(player);
+        const originalUnlinkAccount = player.unlinkAccount.bind(player);
+        const originalAddState = player.addState.bind(player);
+        const originalRemoveState = player.removeState.bind(player);
+        const originalToggleState = player.toggleState.bind(player);
+        player.setMeta = (key, value) => {
+            core.setPlayerMeta(player.clientID, key, value);
+            originalSetMeta(key, value);
+            loggers.session.debug('Remote player meta delegated to CORE', {
+                clientID: player.clientID,
+                key,
+            });
+        };
+        player.linkAccount = (accountID) => {
+            core.linkPlayerAccount(player.clientID, accountID.toString());
+            originalLinkAccount(accountID);
+            loggers.session.debug('Remote player linkAccount delegated to CORE', {
+                clientID: player.clientID,
+                accountID: accountID.toString(),
+            });
+        };
+        player.unlinkAccount = () => {
+            const previousAccountID = player.accountID;
+            core.unlinkPlayerAccount(player.clientID);
+            originalUnlinkAccount();
+            loggers.session.debug('Remote player unlinkAccount delegated to CORE', {
+                clientID: player.clientID,
+                accountID: previousAccountID,
+            });
+        };
+        player.addState = (state) => {
+            core.addPlayerState(player.clientID, state);
+            originalAddState(state);
+            loggers.session.debug('Remote player state added in CORE', {
+                clientID: player.clientID,
+                state,
+            });
+        };
+        player.removeState = (state) => {
+            core.removePlayerState(player.clientID, state);
+            originalRemoveState(state);
+            loggers.session.debug('Remote player state removed in CORE', {
+                clientID: player.clientID,
+                state,
+            });
+        };
+        player.toggleState = (state, force) => {
+            const next = force ?? !player.hasState(state);
+            if (next) {
+                player.addState(state);
+            }
+            else {
+                player.removeState(state);
+            }
+            originalToggleState(state, next);
+            return next;
+        };
     }
     /**
      * Returns a Player instance with real session data from CORE.

package/dist/runtime/server/types/core-exports.types.d.ts

@@ -225,6 +225,19 @@ export interface InternalPlayerExports {
      * @param value - Value to store
      */
     setPlayerMeta(clientID: number, key: string, value: unknown): void;
+    /**
+     * Links a persistent account to the authoritative CORE player session.
+     *
+     * @param clientID - FiveM client/server ID
+     * @param accountID - Persistent account identifier
+     */
+    linkPlayerAccount(clientID: number, accountID: string): void;
+    /**
+     * Removes any linked account from the authoritative CORE player session.
+     *
+     * @param clientID - FiveM client/server ID
+     */
+    unlinkPlayerAccount(clientID: number): void;
     /**
      * Gets complete serialized player data.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-core/framework",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Secure, event-driven TypeScript Framework & Runtime engine for CitizenFX (Cfx).",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",