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

package/dist/runtime/client/adapter/node-log-console.js

@@ -0,0 +1,48 @@
+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 { IClientLogConsole, } from '../../../adapters/contracts/client/IClientLogConsole';
+import { setClientLogConsole } from '../../../kernel/logger';
+const NODE_CLIENT_LOG_CAPABILITIES = {
+    supportsColors: false,
+    supportsStructuredData: true,
+    supportsRichFormatting: false,
+};
+let NodeClientLogConsole = class NodeClientLogConsole extends IClientLogConsole {
+    getCapabilities() {
+        return NODE_CLIENT_LOG_CAPABILITIES;
+    }
+    trace(message, details) {
+        this.write('debug', message, details);
+    }
+    debug(message, details) {
+        this.write('debug', message, details);
+    }
+    info(message, details) {
+        this.write('info', message, details);
+    }
+    warn(message, details) {
+        this.write('warn', message, details);
+    }
+    error(message, details) {
+        this.write('error', message, details);
+    }
+    write(level, message, details) {
+        if (details === undefined) {
+            console[level](message);
+            return;
+        }
+        console[level](message, details);
+    }
+};
+NodeClientLogConsole = __decorate([
+    injectable()
+], NodeClientLogConsole);
+export { NodeClientLogConsole };
+export function installNodeClientLogConsole(logConsole) {
+    setClientLogConsole(logConsole);
+}

package/dist/runtime/client/adapter/node-marker-bridge.d.ts

@@ -0,0 +1,10 @@
+import { IClientMarkerBridge, type ClientMarkerDefinition } from '../../../adapters/contracts/client/ui/IClientMarkerBridge';
+export declare class NodeClientMarkerBridge extends IClientMarkerBridge {
+    private readonly markers;
+    create(id: string, definition: ClientMarkerDefinition): void;
+    update(id: string, patch: Partial<ClientMarkerDefinition>): boolean;
+    remove(id: string): boolean;
+    exists(id: string): boolean;
+    clear(): void;
+    draw(_definition: ClientMarkerDefinition): void;
+}

package/dist/runtime/client/adapter/node-marker-bridge.js

@@ -0,0 +1,35 @@
+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 { IClientMarkerBridge, } from '../../../adapters/contracts/client/ui/IClientMarkerBridge';
+let NodeClientMarkerBridge = class NodeClientMarkerBridge extends IClientMarkerBridge {
+    markers = new Map();
+    create(id, definition) {
+        this.markers.set(id, { ...definition });
+    }
+    update(id, patch) {
+        const existing = this.markers.get(id);
+        if (!existing)
+            return false;
+        this.markers.set(id, { ...existing, ...patch });
+        return true;
+    }
+    remove(id) {
+        return this.markers.delete(id);
+    }
+    exists(id) {
+        return this.markers.has(id);
+    }
+    clear() {
+        this.markers.clear();
+    }
+    draw(_definition) { }
+};
+NodeClientMarkerBridge = __decorate([
+    injectable()
+], NodeClientMarkerBridge);
+export { NodeClientMarkerBridge };

package/dist/runtime/client/adapter/node-notification-bridge.d.ts

@@ -0,0 +1,5 @@
+import { IClientNotificationBridge, type ClientNotificationDefinition } from '../../../adapters/contracts/client/ui/IClientNotificationBridge';
+export declare class NodeClientNotificationBridge extends IClientNotificationBridge {
+    show(_definition: ClientNotificationDefinition): void;
+    clear(_scope?: 'help' | 'subtitle' | 'all'): void;
+}

package/dist/{adapters/fivem/fivem-hasher.js → runtime/client/adapter/node-notification-bridge.js}

@@ -5,16 +5,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { injectable } from 'tsyringe';
-import { IHasher } from '../contracts/IHasher';
-/**
- * FiveM implementation of hash utilities.
- */
-let FiveMHasher = class FiveMHasher extends IHasher {
-    getHashKey(str) {
-        return GetHashKey(str);
-    }
+import { IClientNotificationBridge, } from '../../../adapters/contracts/client/ui/IClientNotificationBridge';
+let NodeClientNotificationBridge = class NodeClientNotificationBridge extends IClientNotificationBridge {
+    show(_definition) { }
+    clear(_scope) { }
 };
-FiveMHasher = __decorate([
+NodeClientNotificationBridge = __decorate([
     injectable()
-], FiveMHasher);
-export { FiveMHasher };
+], NodeClientNotificationBridge);
+export { NodeClientNotificationBridge };

package/dist/runtime/client/adapter/node-ped-port.d.ts

@@ -0,0 +1,20 @@
+import { type ClientPedAnimationOptions, type ClientPedSpawnOptions, IClientPedPort } from '../../../adapters/contracts/client/ped/IClientPedPort';
+import type { Vector3 } from '../../../kernel/utils/vector3';
+export declare class NodeClientPedPort extends IClientPedPort {
+    spawn(_options: ClientPedSpawnOptions): Promise<number>;
+    delete(_handle: number): void;
+    exists(_handle: number): boolean;
+    playAnimation(_handle: number, _options: ClientPedAnimationOptions): Promise<void>;
+    stopAnimation(_handle: number): void;
+    stopAnimationImmediately(_handle: number): void;
+    freeze(_handle: number, _freeze: boolean): void;
+    setInvincible(_handle: number, _invincible: boolean): void;
+    giveWeapon(_handle: number, _weapon: string, _ammo?: number, _hidden?: boolean, _forceInHand?: boolean): void;
+    removeAllWeapons(_handle: number): void;
+    getClosest(_radius?: number, _excludeLocalPlayer?: boolean): number | null;
+    getNearby(_position: Vector3, _radius: number, _excludeEntity?: number): number[];
+    lookAtEntity(_handle: number, _entity: number, _duration?: number): void;
+    lookAtCoords(_handle: number, _position: Vector3, _duration?: number): void;
+    walkTo(_handle: number, _position: Vector3, _speed?: number): void;
+    setCombatAttributes(_handle: number, _canFight: boolean, _canUseCover?: boolean): void;
+}

package/dist/runtime/client/adapter/node-ped-port.js

@@ -0,0 +1,38 @@
+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 { IClientPedPort, } from '../../../adapters/contracts/client/ped/IClientPedPort';
+let NodeClientPedPort = class NodeClientPedPort extends IClientPedPort {
+    async spawn(_options) {
+        return 0;
+    }
+    delete(_handle) { }
+    exists(_handle) {
+        return false;
+    }
+    async playAnimation(_handle, _options) { }
+    stopAnimation(_handle) { }
+    stopAnimationImmediately(_handle) { }
+    freeze(_handle, _freeze) { }
+    setInvincible(_handle, _invincible) { }
+    giveWeapon(_handle, _weapon, _ammo = 100, _hidden = false, _forceInHand = true) { }
+    removeAllWeapons(_handle) { }
+    getClosest(_radius = 10, _excludeLocalPlayer = true) {
+        return null;
+    }
+    getNearby(_position, _radius, _excludeEntity) {
+        return [];
+    }
+    lookAtEntity(_handle, _entity, _duration = -1) { }
+    lookAtCoords(_handle, _position, _duration = -1) { }
+    walkTo(_handle, _position, _speed = 1) { }
+    setCombatAttributes(_handle, _canFight, _canUseCover = true) { }
+};
+NodeClientPedPort = __decorate([
+    injectable()
+], NodeClientPedPort);
+export { NodeClientPedPort };

package/dist/runtime/client/adapter/node-platform-bridge.d.ts

@@ -0,0 +1,3 @@
+import { IClientPlatformBridge } from './platform-bridge';
+export declare class NodeClientPlatformBridge extends IClientPlatformBridge {
+}

package/dist/{adapters/fivem/fivem-tick.js → runtime/client/adapter/node-platform-bridge.js}

@@ -5,15 +5,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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);
-    }
+import { IClientPlatformBridge } from './platform-bridge';
+let NodeClientPlatformBridge = class NodeClientPlatformBridge extends IClientPlatformBridge {
 };
-FiveMTick = __decorate([
+NodeClientPlatformBridge = __decorate([
     injectable()
-], FiveMTick);
-export { FiveMTick };
+], NodeClientPlatformBridge);
+export { NodeClientPlatformBridge };

package/dist/runtime/client/adapter/node-progress-port.d.ts

@@ -0,0 +1,8 @@
+import { type ClientProgressOptions, type ClientProgressState, IClientProgressPort } from '../../../adapters/contracts/client/progress/IClientProgressPort';
+export declare class NodeClientProgressPort extends IClientProgressPort {
+    start(_options: ClientProgressOptions): Promise<boolean>;
+    cancel(): void;
+    isActive(): boolean;
+    getProgress(): number;
+    getState(): ClientProgressState | null;
+}

package/dist/runtime/client/adapter/node-progress-port.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';
+import { IClientProgressPort, } from '../../../adapters/contracts/client/progress/IClientProgressPort';
+let NodeClientProgressPort = class NodeClientProgressPort extends IClientProgressPort {
+    start(_options) {
+        return Promise.resolve(true);
+    }
+    cancel() { }
+    isActive() {
+        return false;
+    }
+    getProgress() {
+        return 0;
+    }
+    getState() {
+        return null;
+    }
+};
+NodeClientProgressPort = __decorate([
+    injectable()
+], NodeClientProgressPort);
+export { NodeClientProgressPort };

package/dist/runtime/client/adapter/node-runtime-bridge.d.ts

@@ -0,0 +1,22 @@
+import { IClientRuntimeBridge } from './runtime-bridge';
+type WebViewCallback = (data: unknown, cb: (response: unknown) => void) => void | Promise<void>;
+/**
+ * Node fallback runtime bridge used in tests and standalone execution.
+ */
+export declare class NodeClientRuntimeBridge extends IClientRuntimeBridge {
+    private readonly events;
+    private readonly tickHandles;
+    getCurrentResourceName(): string;
+    on<TArgs extends readonly unknown[]>(eventName: string, handler: (...args: TArgs) => void | Promise<void>): void;
+    registerCommand(_commandName: string, _handler: (...args: readonly unknown[]) => void, _restricted: boolean): void;
+    registerKeyMapping(_commandName: string, _description: string, _inputMapper: string, _key: string): void;
+    setTick(handler: () => void | Promise<void>): unknown;
+    clearTick(handle: unknown): void;
+    getGameTimer(): number;
+    registerNuiCallback(eventName: string, handler: WebViewCallback): void;
+    sendNuiMessage(_message: string): void;
+    setNuiFocus(_hasFocus: boolean, _hasCursor: boolean): void;
+    setNuiFocusKeepInput(_keepInput: boolean): void;
+    registerExport<TArgs extends readonly unknown[], TResult = unknown>(exportName: string, handler: (...args: TArgs) => TResult): void;
+}
+export {};

package/dist/runtime/client/adapter/node-runtime-bridge.js

@@ -0,0 +1,58 @@
+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 { EventEmitter } from 'node:events';
+import { injectable } from 'tsyringe';
+import { IClientRuntimeBridge } from './runtime-bridge';
+/**
+ * Node fallback runtime bridge used in tests and standalone execution.
+ */
+let NodeClientRuntimeBridge = class NodeClientRuntimeBridge extends IClientRuntimeBridge {
+    events = new EventEmitter();
+    tickHandles = new Set();
+    getCurrentResourceName() {
+        return process.env.RESOURCE_NAME || 'default';
+    }
+    on(eventName, handler) {
+        this.events.on(eventName, (...args) => {
+            void handler(...args);
+        });
+    }
+    registerCommand(_commandName, _handler, _restricted) { }
+    registerKeyMapping(_commandName, _description, _inputMapper, _key) { }
+    setTick(handler) {
+        const tick = setInterval(() => {
+            void handler();
+        }, 0);
+        this.tickHandles.add(tick);
+        return tick;
+    }
+    clearTick(handle) {
+        if (handle && this.tickHandles.has(handle)) {
+            clearInterval(handle);
+            this.tickHandles.delete(handle);
+        }
+    }
+    getGameTimer() {
+        return Date.now();
+    }
+    registerNuiCallback(eventName, handler) {
+        this.events.on(`__nui:${eventName}`, (data, cb) => {
+            void handler(data, cb);
+        });
+    }
+    sendNuiMessage(_message) { }
+    setNuiFocus(_hasFocus, _hasCursor) { }
+    setNuiFocusKeepInput(_keepInput) { }
+    registerExport(exportName, handler) {
+        ;
+        globalThis[`__client_export:${exportName}`] = handler;
+    }
+};
+NodeClientRuntimeBridge = __decorate([
+    injectable()
+], NodeClientRuntimeBridge);
+export { NodeClientRuntimeBridge };

package/dist/runtime/client/adapter/node-spawn-bridge.d.ts

@@ -0,0 +1,8 @@
+import { IClientSpawnPort } from '../../../adapters/contracts/client/spawn/IClientSpawnPort';
+import type { RespawnRequest, SpawnExecutionResult, SpawnRequest, TeleportRequest } from '../../../adapters/contracts/client/spawn/types';
+export declare class NodeClientSpawnBridge extends IClientSpawnPort {
+    waitUntilReady(_timeoutMs?: number): Promise<void>;
+    spawn(_request: SpawnRequest): Promise<SpawnExecutionResult>;
+    respawn(_request: RespawnRequest): Promise<SpawnExecutionResult>;
+    teleport(_request: TeleportRequest): Promise<void>;
+}

package/dist/runtime/client/adapter/node-spawn-bridge.js

@@ -0,0 +1,22 @@
+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 { IClientSpawnPort } from '../../../adapters/contracts/client/spawn/IClientSpawnPort';
+let NodeClientSpawnBridge = class NodeClientSpawnBridge extends IClientSpawnPort {
+    async waitUntilReady(_timeoutMs) { }
+    async spawn(_request) {
+        return {};
+    }
+    async respawn(_request) {
+        return {};
+    }
+    async teleport(_request) { }
+};
+NodeClientSpawnBridge = __decorate([
+    injectable()
+], NodeClientSpawnBridge);
+export { NodeClientSpawnBridge };

package/dist/runtime/client/adapter/node-vehicle-port.d.ts

@@ -0,0 +1,31 @@
+import { type ClientVehicleMods, type ClientVehicleSpawnOptions, IClientVehiclePort } from '../../../adapters/contracts/client/vehicle/IClientVehiclePort';
+import type { Vector3 } from '../../../kernel/utils/vector3';
+export declare class NodeClientVehiclePort extends IClientVehiclePort {
+    spawn(_options: ClientVehicleSpawnOptions): Promise<number>;
+    delete(_vehicle: number): void;
+    repair(_vehicle: number): void;
+    setFuel(_vehicle: number, _level: number): void;
+    getFuel(_vehicle: number): number;
+    getClosest(_radius?: number): number | null;
+    isLocalPlayerInVehicle(): boolean;
+    getCurrentForLocalPlayer(): number | null;
+    getLastForLocalPlayer(): number | null;
+    isLocalPlayerDriver(_vehicle: number): boolean;
+    warpLocalPlayerInto(_vehicle: number, _seatIndex?: number): void;
+    leaveLocalPlayerVehicle(_vehicle: number, _flags?: number): void;
+    applyMods(_vehicle: number, _mods: ClientVehicleMods): void;
+    setDoorsLocked(_vehicle: number, _locked: boolean): void;
+    setEngineRunning(_vehicle: number, _running: boolean, _instant?: boolean): void;
+    setInvincible(_vehicle: number, _invincible: boolean): void;
+    getSpeed(_vehicle: number): number;
+    setHeading(_vehicle: number, _heading: number): void;
+    teleport(_vehicle: number, _position: Vector3, _heading?: number): void;
+    exists(_vehicle: number): boolean;
+    getNetworkId(_vehicle: number): number;
+    getFromNetworkId(_networkId: number): number;
+    getState<T = unknown>(_vehicle: number, _key: string): T | undefined;
+    getPosition(_vehicle: number): Vector3 | null;
+    getHeading(_vehicle: number): number;
+    getModel(_vehicle: number): number;
+    getPlate(_vehicle: number): string;
+}

package/dist/runtime/client/adapter/node-vehicle-port.js

@@ -0,0 +1,73 @@
+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 { IClientVehiclePort, } from '../../../adapters/contracts/client/vehicle/IClientVehiclePort';
+let NodeClientVehiclePort = class NodeClientVehiclePort extends IClientVehiclePort {
+    async spawn(_options) {
+        return 0;
+    }
+    delete(_vehicle) { }
+    repair(_vehicle) { }
+    setFuel(_vehicle, _level) { }
+    getFuel(_vehicle) {
+        return 0;
+    }
+    getClosest(_radius = 10) {
+        return null;
+    }
+    isLocalPlayerInVehicle() {
+        return false;
+    }
+    getCurrentForLocalPlayer() {
+        return null;
+    }
+    getLastForLocalPlayer() {
+        return null;
+    }
+    isLocalPlayerDriver(_vehicle) {
+        return false;
+    }
+    warpLocalPlayerInto(_vehicle, _seatIndex = -1) { }
+    leaveLocalPlayerVehicle(_vehicle, _flags = 16) { }
+    applyMods(_vehicle, _mods) { }
+    setDoorsLocked(_vehicle, _locked) { }
+    setEngineRunning(_vehicle, _running, _instant = false) { }
+    setInvincible(_vehicle, _invincible) { }
+    getSpeed(_vehicle) {
+        return 0;
+    }
+    setHeading(_vehicle, _heading) { }
+    teleport(_vehicle, _position, _heading) { }
+    exists(_vehicle) {
+        return false;
+    }
+    getNetworkId(_vehicle) {
+        return 0;
+    }
+    getFromNetworkId(_networkId) {
+        return 0;
+    }
+    getState(_vehicle, _key) {
+        return undefined;
+    }
+    getPosition(_vehicle) {
+        return null;
+    }
+    getHeading(_vehicle) {
+        return 0;
+    }
+    getModel(_vehicle) {
+        return 0;
+    }
+    getPlate(_vehicle) {
+        return '';
+    }
+};
+NodeClientVehiclePort = __decorate([
+    injectable()
+], NodeClientVehiclePort);
+export { NodeClientVehiclePort };

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

@@ -0,0 +1,16 @@
+import { IClientWebViewBridge } from '../../../adapters/contracts/client/ui/webview/IClientWebViewBridge';
+import type { WebViewCapabilities, WebViewDefinition, WebViewFocusOptions, WebViewMessage } from '../../../adapters/contracts/client/ui/webview/types';
+export declare class NodeClientWebViewBridge extends IClientWebViewBridge {
+    private readonly views;
+    getCapabilities(): WebViewCapabilities;
+    create(definition: WebViewDefinition): void;
+    destroy(viewId: string): void;
+    exists(viewId: string): boolean;
+    show(_viewId: string): void;
+    hide(_viewId: string): void;
+    focus(_viewId: string, _options?: WebViewFocusOptions): void;
+    blur(_viewId: string): void;
+    markAsChat(_viewId: string): void;
+    send(_viewId: string, _event: string, _payload: unknown): void;
+    onMessage(_handler: (message: WebViewMessage) => void | Promise<void>): () => void;
+}

package/dist/runtime/client/adapter/node-webview-bridge.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 { IClientWebViewBridge } from '../../../adapters/contracts/client/ui/webview/IClientWebViewBridge';
+const NODE_WEBVIEW_CAPABILITIES = {
+    supportsFocus: false,
+    supportsCursor: false,
+    supportsInputPassthrough: false,
+    supportsBidirectionalMessaging: false,
+    supportsExecute: false,
+    supportsHeadless: false,
+    supportsChatMode: false,
+};
+let NodeClientWebViewBridge = class NodeClientWebViewBridge extends IClientWebViewBridge {
+    views = new Set();
+    getCapabilities() {
+        return NODE_WEBVIEW_CAPABILITIES;
+    }
+    create(definition) {
+        this.views.add(definition.id);
+    }
+    destroy(viewId) {
+        this.views.delete(viewId);
+    }
+    exists(viewId) {
+        return this.views.has(viewId);
+    }
+    show(_viewId) { }
+    hide(_viewId) { }
+    focus(_viewId, _options) { }
+    blur(_viewId) { }
+    markAsChat(_viewId) { }
+    send(_viewId, _event, _payload) { }
+    onMessage(_handler) {
+        return () => { };
+    }
+};
+NodeClientWebViewBridge = __decorate([
+    injectable()
+], NodeClientWebViewBridge);
+export { NodeClientWebViewBridge };

package/dist/runtime/client/adapter/platform-bridge.d.ts

@@ -0,0 +1 @@
+export { IClientPlatformBridge, type TextDrawOptions, } from '../../../adapters/contracts/client/IClientPlatformBridge';

package/dist/runtime/client/adapter/platform-bridge.js

@@ -0,0 +1 @@
+export { IClientPlatformBridge, } from '../../../adapters/contracts/client/IClientPlatformBridge';

package/dist/runtime/client/adapter/registry.d.ts

@@ -0,0 +1,9 @@
+import { type OpenCoreClientAdapter } from './client-adapter';
+/**
+ * Installs the active client adapter for the current bootstrap.
+ */
+export declare function installClientAdapter(adapter?: OpenCoreClientAdapter): Promise<void>;
+export declare function getActiveClientAdapterName(): string | undefined;
+export declare function assertClientAdapterCompatibility(adapter?: OpenCoreClientAdapter): void;
+export declare function getCurrentClientResourceName(): string;
+export declare function __resetClientAdapterRegistryForTests(): void;

package/dist/runtime/client/adapter/registry.js

@@ -0,0 +1,85 @@
+import { di } from '../client-container';
+import { bindClientTransportInstances, } from './client-adapter';
+import { IClientRuntimeBridge } from './runtime-bridge';
+let activeClientAdapterName = null;
+async function getDefaultClientAdapter() {
+    if (typeof __OPENCORE_TARGET__ !== 'undefined' && __OPENCORE_TARGET__ === 'client') {
+        throw new Error('[OpenCore] No client adapter provided. Configure one in opencore.config.ts or pass adapter to Client.init().');
+    }
+    const { createNodeClientAdapter } = await import('./node-client-adapter');
+    return createNodeClientAdapter();
+}
+function assertTokenAvailable(token, adapterName) {
+    if (di.isRegistered(token)) {
+        throw new Error(`[OpenCore] Adapter '${adapterName}' cannot bind an already registered token.`);
+    }
+}
+function createAdapterContext(adapterName) {
+    return {
+        adapterName,
+        container: di,
+        isRegistered(token) {
+            return di.isRegistered(token);
+        },
+        bindSingleton(token, implementation) {
+            assertTokenAvailable(token, adapterName);
+            di.registerSingleton(token, implementation);
+        },
+        bindInstance(token, value) {
+            assertTokenAvailable(token, adapterName);
+            di.registerInstance(token, value);
+        },
+        bindFactory(token, factory) {
+            assertTokenAvailable(token, adapterName);
+            di.register(token, { useFactory: factory });
+        },
+        bindMessagingTransport(transport) {
+            bindClientTransportInstances(this, transport);
+        },
+        useRuntimeBridge(runtime) {
+            this.bindInstance(IClientRuntimeBridge, runtime);
+        },
+    };
+}
+/**
+ * Installs the active client adapter for the current bootstrap.
+ */
+export async function installClientAdapter(adapter) {
+    const active = adapter ?? (await getDefaultClientAdapter());
+    if (activeClientAdapterName) {
+        if (activeClientAdapterName !== active.name) {
+            throw new Error(`[OpenCore] Client adapter '${active.name}' cannot be installed because '${activeClientAdapterName}' is already active.`);
+        }
+        return;
+    }
+    await active.register(createAdapterContext(active.name));
+    activeClientAdapterName = active.name;
+}
+export function getActiveClientAdapterName() {
+    return activeClientAdapterName ?? undefined;
+}
+export function assertClientAdapterCompatibility(adapter) {
+    if (!adapter || !activeClientAdapterName) {
+        return;
+    }
+    if (adapter.name !== activeClientAdapterName) {
+        throw new Error(`[OpenCore] Client adapter '${adapter.name}' does not match active adapter '${activeClientAdapterName}'.`);
+    }
+}
+export function getCurrentClientResourceName() {
+    if (di.isRegistered(IClientRuntimeBridge)) {
+        return di
+            .resolve(IClientRuntimeBridge)
+            .getCurrentResourceName();
+    }
+    const fn = globalThis.GetCurrentResourceName;
+    if (typeof fn === 'function') {
+        const name = fn();
+        if (typeof name === 'string' && name.trim())
+            return name;
+    }
+    return 'default';
+}
+export function __resetClientAdapterRegistryForTests() {
+    activeClientAdapterName = null;
+}

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

@@ -0,0 +1 @@
+export { IClientRuntimeBridge } from '../../../adapters/contracts/client/IClientRuntimeBridge';

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

@@ -0,0 +1 @@
+export { IClientRuntimeBridge } from '../../../adapters/contracts/client/IClientRuntimeBridge';