@open-core/framework 1.0.5-beta.2 → 1.0.6

package/dist/adapters/contracts/client/vehicle/IClientVehiclePort.d.ts

@@ -0,0 +1,166 @@
+import type { Vector3 } from '../../../../kernel/utils/vector3';
+/**
+ * High-level vehicle creation options understood by client adapters.
+ */
+export interface ClientVehicleSpawnOptions {
+    model: string;
+    position: Vector3;
+    heading?: number;
+    placeOnGround?: boolean;
+    warpIntoVehicle?: boolean;
+    seatIndex?: number;
+    primaryColor?: number;
+    secondaryColor?: number;
+    plate?: string;
+    networked?: boolean;
+}
+/**
+ * Common vehicle modification payload used by the framework.
+ */
+export interface ClientVehicleMods {
+    spoiler?: number;
+    frontBumper?: number;
+    rearBumper?: number;
+    sideSkirt?: number;
+    exhaust?: number;
+    frame?: number;
+    grille?: number;
+    hood?: number;
+    fender?: number;
+    rightFender?: number;
+    roof?: number;
+    engine?: number;
+    brakes?: number;
+    transmission?: number;
+    horns?: number;
+    suspension?: number;
+    armor?: number;
+    turbo?: boolean;
+    xenon?: boolean;
+    wheelType?: number;
+    wheels?: number;
+    windowTint?: number;
+    livery?: number;
+    plateStyle?: number;
+    neonEnabled?: [boolean, boolean, boolean, boolean];
+    neonColor?: [number, number, number];
+    extras?: Record<string, boolean>;
+    pearlescentColor?: number;
+    wheelColor?: number;
+}
+/**
+ * Intent-oriented client vehicle port.
+ *
+ * The framework requests vehicle operations through this port and the adapter
+ * decides how to fulfill them for the active runtime.
+ */
+export declare abstract class IClientVehiclePort {
+    /**
+     * Spawns a vehicle and returns its runtime handle.
+     */
+    abstract spawn(options: ClientVehicleSpawnOptions): Promise<number>;
+    /**
+     * Deletes an existing vehicle handle.
+     */
+    abstract delete(vehicle: number): void;
+    /**
+     * Repairs a vehicle and restores it to a drivable state.
+     */
+    abstract repair(vehicle: number): void;
+    /**
+     * Sets normalized fuel in the 0..1 range unless the adapter documents otherwise.
+     */
+    abstract setFuel(vehicle: number, level: number): void;
+    /**
+     * Gets normalized fuel in the 0..1 range unless the adapter documents otherwise.
+     */
+    abstract getFuel(vehicle: number): number;
+    /**
+     * Returns the closest vehicle around the local player.
+     */
+    abstract getClosest(radius?: number): number | null;
+    /**
+     * Returns whether the local player is currently inside any vehicle.
+     */
+    abstract isLocalPlayerInVehicle(): boolean;
+    /**
+     * Returns the vehicle currently occupied by the local player.
+     */
+    abstract getCurrentForLocalPlayer(): number | null;
+    /**
+     * Returns the last vehicle used by the local player.
+     */
+    abstract getLastForLocalPlayer(): number | null;
+    /**
+     * Returns whether the local player is driving the provided vehicle.
+     */
+    abstract isLocalPlayerDriver(vehicle: number): boolean;
+    /**
+     * Warps the local player into a seat.
+     */
+    abstract warpLocalPlayerInto(vehicle: number, seatIndex?: number): void;
+    /**
+     * Makes the local player leave the provided vehicle.
+     */
+    abstract leaveLocalPlayerVehicle(vehicle: number, flags?: number): void;
+    /**
+     * Applies visual/performance modifications to a vehicle.
+     */
+    abstract applyMods(vehicle: number, mods: ClientVehicleMods): void;
+    /**
+     * Updates door lock state.
+     */
+    abstract setDoorsLocked(vehicle: number, locked: boolean): void;
+    /**
+     * Starts or stops the engine.
+     */
+    abstract setEngineRunning(vehicle: number, running: boolean, instant?: boolean): void;
+    /**
+     * Sets invincibility state for the vehicle entity.
+     */
+    abstract setInvincible(vehicle: number, invincible: boolean): void;
+    /**
+     * Returns speed in meters per second.
+     */
+    abstract getSpeed(vehicle: number): number;
+    /**
+     * Sets heading for a vehicle.
+     */
+    abstract setHeading(vehicle: number, heading: number): void;
+    /**
+     * Teleports a vehicle to a world position.
+     */
+    abstract teleport(vehicle: number, position: Vector3, heading?: number): void;
+    /**
+     * Returns whether a vehicle handle exists.
+     */
+    abstract exists(vehicle: number): boolean;
+    /**
+     * Resolves the runtime network identifier for a vehicle.
+     */
+    abstract getNetworkId(vehicle: number): number;
+    /**
+     * Resolves a vehicle handle from a runtime network identifier.
+     */
+    abstract getFromNetworkId(networkId: number): number;
+    /**
+     * Reads a runtime state bag/state entry from a vehicle.
+     */
+    abstract getState<T = unknown>(vehicle: number, key: string): T | undefined;
+    /**
+     * Returns the world position of a vehicle.
+     */
+    abstract getPosition(vehicle: number): Vector3 | null;
+    /**
+     * Returns the heading of a vehicle.
+     */
+    abstract getHeading(vehicle: number): number;
+    /**
+     * Returns the model hash of a vehicle.
+     */
+    abstract getModel(vehicle: number): number;
+    /**
+     * Returns the current number plate text.
+     */
+    abstract getPlate(vehicle: number): string;
+}

package/dist/adapters/contracts/client/vehicle/IClientVehiclePort.js

@@ -0,0 +1,8 @@
+/**
+ * Intent-oriented client vehicle port.
+ *
+ * The framework requests vehicle operations through this port and the adapter
+ * decides how to fulfill them for the active runtime.
+ */
+export class IClientVehiclePort {
+}

package/dist/adapters/contracts/client/vehicle/index.d.ts

@@ -0,0 +1 @@
+export * from './IClientVehiclePort';

package/dist/adapters/contracts/client/vehicle/index.js

@@ -0,0 +1 @@
+export * from './IClientVehiclePort';

package/dist/adapters/contracts/transport/events.api.d.ts

@@ -1,6 +1,6 @@
 import { EventContext, RuntimeContext } from './context';
 import { Player } from '../../../runtime/server/entities/player';
-type EmitArgs<C extends RuntimeContext> = C extends 'server' ? [target: Player | number | number[] | 'all', ...args: any[]] : [...args: any[]];
+type EmitArgs<C extends RuntimeContext> = C extends 'server' ? [target: Player | number | number[] | 'all', ...args: unknown[]] : [...args: unknown[]];
 /**
  * broadcast and listen to events without relying on runtime. The adapter will be used.
  */
@@ -13,7 +13,7 @@ export declare abstract class EventsAPI<C extends RuntimeContext> {
      * Client:
      *   - triggered by server
      */
-    abstract on(event: string, handler: (ctx: EventContext, ...args: any[]) => void | Promise<void>): void;
+    abstract on<TArgs extends readonly unknown[]>(event: string, handler: (ctx: EventContext, ...args: TArgs) => void | Promise<void>): void;
     /**
      * Emit an event.
      *  SERVER → CLIENT
@@ -22,7 +22,7 @@ export declare abstract class EventsAPI<C extends RuntimeContext> {
      * Client:
      *   - sends to server, targetOrArg will be ignored
      */
-    abstract emit(event: string, target: Player | number | number[] | 'all', ...args: any[]): void;
+    abstract emit(event: string, target: Player | number | number[] | 'all', ...args: unknown[]): void;
     /**
      * Emit an event.
      *  CLIENT → SERVER

package/dist/adapters/contracts/transport/index.d.ts

@@ -1,4 +1,5 @@
 export * from './context';
 export * from './events.api';
 export * from './rpc.api';
+export * from './rpc-error';
 export * from './messaging.transport';

package/dist/adapters/contracts/transport/index.js

@@ -1,4 +1,5 @@
 export * from './context';
 export * from './events.api';
 export * from './rpc.api';
+export * from './rpc-error';
 export * from './messaging.transport';

package/dist/adapters/contracts/transport/rpc-error.d.ts

@@ -0,0 +1,17 @@
+export declare const PUBLIC_RPC_ERROR_MESSAGE = "An internal server error occurred";
+export type RpcErrorInfo = {
+    message: string;
+    name?: string;
+};
+type ExposedRpcError = {
+    message: string;
+    name?: string;
+    expose: true;
+};
+export declare class RpcPublicError extends Error {
+    readonly expose = true;
+    constructor(message: string, name?: string);
+}
+export declare function isExposedRpcError(error: unknown): error is ExposedRpcError;
+export declare function serializeRpcError(error: unknown): RpcErrorInfo;
+export {};

package/dist/adapters/contracts/transport/rpc-error.js

@@ -0,0 +1,28 @@
+export const PUBLIC_RPC_ERROR_MESSAGE = 'An internal server error occurred';
+export class RpcPublicError extends Error {
+    expose = true;
+    constructor(message, name) {
+        super(message);
+        if (name) {
+            this.name = name;
+        }
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export function isExposedRpcError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        typeof error.message === 'string' &&
+        'expose' in error &&
+        error.expose === true);
+}
+export function serializeRpcError(error) {
+    if (isExposedRpcError(error)) {
+        return {
+            message: error.message,
+            name: 'name' in error && typeof error.name === 'string' ? error.name : undefined,
+        };
+    }
+    return { message: PUBLIC_RPC_ERROR_MESSAGE };
+}

package/dist/adapters/contracts/transport/rpc.api.d.ts

@@ -14,8 +14,8 @@ export interface RpcContext extends EventContext {
  */
 export type RpcTarget = number | number[] | 'all';
 export type RpcCallTarget = number | number[];
-type RpcCallArgs<C extends RuntimeContext> = C extends 'server' ? [target: RpcCallTarget, ...args: any[]] : [...args: any[]];
-type RpcNotifyArgs<C extends RuntimeContext> = C extends 'server' ? [target: RpcTarget, ...args: any[]] : [...args: any[]];
+type RpcCallArgs<C extends RuntimeContext> = C extends 'server' ? [target: RpcCallTarget, ...args: unknown[]] : [...args: unknown[]];
+type RpcNotifyArgs<C extends RuntimeContext> = C extends 'server' ? [target: RpcTarget, ...args: unknown[]] : [...args: unknown[]];
 /**
  * Remote Procedure Call API.
  *
@@ -47,7 +47,7 @@ export declare abstract class RpcAPI<C extends RuntimeContext> {
      * The handler receives a {@link RpcContext}. In server environments this usually includes
      * the `clientId` of the caller (via {@link EventContext}).
      */
-    abstract on<TArgs extends any[], TResult>(name: string, handler: (ctx: RpcContext, ...args: TArgs) => TResult | Promise<TResult>): void;
+    abstract on<TArgs extends readonly unknown[], TResult>(name: string, handler: (ctx: RpcContext, ...args: TArgs) => TResult | Promise<TResult>): void;
     /**
      * Call an RPC and wait for the result.
      *

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

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

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

@@ -4,13 +4,13 @@ export declare class NodeRpc<C extends RuntimeContext = RuntimeContext> extends
     private readonly context;
     private readonly handlers;
     constructor(context: C);
-    on<TArgs extends any[], TResult>(name: string, handler: (ctx: {
+    on<TArgs extends readonly unknown[], 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>;
+    call<TResult = unknown>(name: string, ...args: unknown[]): Promise<TResult>;
+    notify(name: string, ...args: unknown[]): Promise<void>;
     private normalizeInvocation;
     private isValidTarget;
     private executeCall;

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

@@ -8,7 +8,7 @@ export class NodeRpc extends RpcAPI {
         this.context = context;
     }
     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);

package/dist/contracts.d.ts

@@ -2,3 +2,4 @@ export * from './adapters/contracts/IHasher';
 export * from './adapters/contracts/transport';
 export * from './adapters/contracts/types';
 export * from './adapters/contracts/runtime';
+export * from './runtime/shared/types/system-types';

package/dist/contracts.js

@@ -2,3 +2,4 @@ export * from './adapters/contracts/IHasher';
 export * from './adapters/contracts/transport';
 export * from './adapters/contracts/types';
 export * from './adapters/contracts/runtime';
+export * from './runtime/shared/types/system-types';

package/dist/index.d.ts

@@ -2,3 +2,4 @@ import 'reflect-metadata';
 export * from './kernel';
 export * from './runtime/core';
 export * from './contracts';
+export * from './runtime/shared/types/system-types';

package/dist/index.js

@@ -2,3 +2,4 @@ import 'reflect-metadata';
 export * from './kernel';
 export * from './runtime/core';
 export * from './contracts';
+export * from './runtime/shared/types/system-types';

package/dist/kernel/logger/client-log-console.js

@@ -9,26 +9,26 @@ class DefaultClientLogConsole extends IClientLogConsole {
         return DEFAULT_CLIENT_LOG_CONSOLE_CAPABILITIES;
     }
     trace(message, details) {
-        this.write(console.debug, message, details);
+        this.write('debug', message, details);
     }
     debug(message, details) {
-        this.write(console.debug, message, details);
+        this.write('debug', message, details);
     }
     info(message, details) {
-        this.write(console.info, message, details);
+        this.write('info', message, details);
     }
     warn(message, details) {
-        this.write(console.warn, message, details);
+        this.write('warn', message, details);
     }
     error(message, details) {
-        this.write(console.error, message, details);
+        this.write('error', message, details);
     }
-    write(method, message, details) {
+    write(level, message, details) {
         if (details === undefined) {
-            method(message);
+            console[level](message);
             return;
         }
-        method(message, details);
+        console[level](message, details);
     }
 }
 let activeClientLogConsole = new DefaultClientLogConsole();

package/dist/kernel/logger/index.d.ts

@@ -6,7 +6,7 @@ export { getLogLevel, isClientEnvironment, isDebugMode, isFiveMEnvironment, isSe
 export { ChildLogger, LoggerService } from './logger.service';
 export type { ClientLogConsoleCapabilities } from '../../adapters/contracts/client/IClientLogConsole';
 export type { LogContext, LogEntry } from './logger.types';
-export { LogDomain, LogDomainLabels, LogLevel, LogLevelLabels, parseLogLevel } from './logger.types';
+export { getLogDomainLabel, LogDomain, LogDomainLabels, LogLevel, LogLevelLabels, parseLogLevel, } from './logger.types';
 export type { BufferedTransportOptions, LogOutputFormat } from './transports/buffered.transport';
 export { BufferedTransport } from './transports/buffered.transport';
 export type { ConsoleTransportOptions } from './transports/console.transport';

package/dist/kernel/logger/index.js

@@ -7,7 +7,7 @@ export { createLoggerConfig, DEFAULT_LOGGER_CONFIG } from './logger.config';
 export { getLogLevel, isClientEnvironment, isDebugMode, isFiveMEnvironment, isServerEnvironment, } from './logger.env';
 // Service
 export { ChildLogger, LoggerService } from './logger.service';
-export { LogDomain, LogDomainLabels, LogLevel, LogLevelLabels, parseLogLevel } from './logger.types';
+export { getLogDomainLabel, LogDomain, LogDomainLabels, LogLevel, LogLevelLabels, parseLogLevel, } from './logger.types';
 export { BufferedTransport } from './transports/buffered.transport';
 export { ConsoleTransport } from './transports/console.transport';
 export { SimpleConsoleTransport } from './transports/simple-console.transport';

package/dist/kernel/logger/logger.types.d.ts

@@ -45,6 +45,7 @@ export declare enum LogDomain {
  * Human-readable labels for each log domain.
  */
 export declare const LogDomainLabels: Record<LogDomain, string>;
+export declare function getLogDomainLabel(domain: LogDomain): string;
 /**
  * Additional contextual information that can be attached to any log entry.
  * Useful for tracing, debugging, and correlation.

package/dist/kernel/logger/logger.types.js

@@ -60,6 +60,41 @@ export const LogDomainLabels = {
     [LogDomain.CLIENT]: 'CLIENT',
     [LogDomain.EXTERNAL]: 'EXTERNAL',
 };
+function normalizeResourceName(resourceName) {
+    return resourceName.trim().replace(/^\[(.*)\]$/, '$1');
+}
+function getInjectedResourceName() {
+    if (typeof __OPENCORE_RESOURCE_NAME__ === 'string' &&
+        normalizeResourceName(__OPENCORE_RESOURCE_NAME__).length > 0) {
+        return normalizeResourceName(__OPENCORE_RESOURCE_NAME__);
+    }
+    const fn = globalThis.GetCurrentResourceName;
+    if (typeof fn === 'function') {
+        try {
+            const value = fn();
+            if (typeof value === 'string' && normalizeResourceName(value).length > 0) {
+                return normalizeResourceName(value);
+            }
+        }
+        catch {
+            // Ignore runtime lookup failures and fall back to default labels.
+        }
+    }
+    return undefined;
+}
+export function getLogDomainLabel(domain) {
+    if (domain !== LogDomain.FRAMEWORK) {
+        return LogDomainLabels[domain];
+    }
+    const resourceName = getInjectedResourceName();
+    if (!resourceName) {
+        return LogDomainLabels[domain];
+    }
+    if (resourceName.toLowerCase() === 'core') {
+        return 'CORE';
+    }
+    return resourceName.toUpperCase();
+}
 /**
  * Configuration for parsing log level from string (useful for env vars).
  */

package/dist/kernel/logger/transports/buffered.transport.js

@@ -1,4 +1,4 @@
-import { LogDomainLabels, LogLevel, LogLevelLabels } from '../logger.types';
+import { getLogDomainLabel, LogLevel, LogLevelLabels } from '../logger.types';
 /**
  * A transport that buffers log entries in memory for later export.
  *
@@ -95,7 +95,7 @@ export class BufferedTransport {
         const entries = this.buffer.map((entry) => ({
             timestamp: entry.timestamp,
             level: LogLevelLabels[entry.level],
-            domain: LogDomainLabels[entry.domain],
+            domain: getLogDomainLabel(entry.domain),
             source: entry.context?.source,
             message: entry.message,
             context: this.cleanContext(entry.context),
@@ -114,7 +114,7 @@ export class BufferedTransport {
             .map((entry) => {
             const time = entry.timestamp.replace('T', ' ').slice(0, 23);
             const level = LogLevelLabels[entry.level].padEnd(5);
-            const domain = LogDomainLabels[entry.domain].padEnd(8);
+            const domain = getLogDomainLabel(entry.domain).padEnd(8);
             const source = entry.context?.source ? `[${entry.context.source}]` : '';
             let line = `${time} | ${domain} | ${level} | ${source} ${entry.message}`;
             const ctx = this.cleanContext(entry.context);
@@ -133,7 +133,7 @@ export class BufferedTransport {
         const rows = this.buffer.map((entry) => [
             entry.timestamp,
             LogLevelLabels[entry.level],
-            LogDomainLabels[entry.domain],
+            getLogDomainLabel(entry.domain),
             entry.context?.source ?? '',
             `"${entry.message.replace(/"/g, '""')}"`,
             JSON.stringify(this.cleanContext(entry.context)),

package/dist/kernel/logger/transports/console.transport.js

@@ -1,4 +1,4 @@
-import { LogDomain, LogDomainLabels, LogLevel, LogLevelLabels, } from '../logger.types';
+import { getLogDomainLabel, LogDomain, LogLevel, LogLevelLabels, } from '../logger.types';
 /**
  * Color codes for console output.
  * Uses ANSI escape codes compatible with most terminals.
@@ -63,7 +63,7 @@ export class ConsoleTransport {
     write(entry) {
         const { level, domain, message, timestamp, context, error } = entry;
         const levelLabel = LogLevelLabels[level].padEnd(5);
-        const domainLabel = LogDomainLabels[domain];
+        const domainLabel = getLogDomainLabel(domain);
         const levelColor = this.colors ? LEVEL_COLORS[level] : '';
         const domainColor = this.colors ? DOMAIN_COLORS[domain] : '';
         const reset = this.colors ? COLORS.reset : '';

package/dist/kernel/logger/transports/simple-console.transport.js

@@ -1,4 +1,4 @@
-import { LogDomainLabels, LogLevel, LogLevelLabels } from '../logger.types';
+import { getLogDomainLabel, LogLevel, LogLevelLabels } from '../logger.types';
 import { getClientLogConsole } from '../client-log-console';
 /**
  * Simple console transport without ANSI color codes.
@@ -29,7 +29,7 @@ export class SimpleConsoleTransport {
         const output = getClientLogConsole();
         const capabilities = output.getCapabilities();
         const levelLabel = LogLevelLabels[level].padEnd(5);
-        const domainLabel = LogDomainLabels[domain];
+        const domainLabel = getLogDomainLabel(domain);
         // Build the log line without ANSI codes
         const parts = [];
         if (this.timestamps) {

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

@@ -1,6 +1,11 @@
 export * from './client-adapter';
+export * from '../../../adapters/contracts/client/camera/IClientCameraPort';
 export * from '../../../adapters/contracts/client/IClientLogConsole';
+export * from '../../../adapters/contracts/client/ped/IClientPedPort';
+export * from '../../../adapters/contracts/client/progress/IClientProgressPort';
+export * from '../../../adapters/contracts/client/spawn/IClientSpawnPort';
 export * from '../../../adapters/contracts/client/spawn/IClientSpawnBridge';
+export * from '../../../adapters/contracts/client/vehicle/IClientVehiclePort';
 export * from '../../../adapters/contracts/client/ui/IClientBlipBridge';
 export * from '../../../adapters/contracts/client/ui/IClientMarkerBridge';
 export * from '../../../adapters/contracts/client/ui/IClientNotificationBridge';

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

@@ -1,6 +1,11 @@
 export * from './client-adapter';
+export * from '../../../adapters/contracts/client/camera/IClientCameraPort';
 export * from '../../../adapters/contracts/client/IClientLogConsole';
+export * from '../../../adapters/contracts/client/ped/IClientPedPort';
+export * from '../../../adapters/contracts/client/progress/IClientProgressPort';
+export * from '../../../adapters/contracts/client/spawn/IClientSpawnPort';
 export * from '../../../adapters/contracts/client/spawn/IClientSpawnBridge';
+export * from '../../../adapters/contracts/client/vehicle/IClientVehiclePort';
 export * from '../../../adapters/contracts/client/ui/IClientBlipBridge';
 export * from '../../../adapters/contracts/client/ui/IClientMarkerBridge';
 export * from '../../../adapters/contracts/client/ui/IClientNotificationBridge';

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

@@ -0,0 +1,19 @@
+import { type ClientCameraCreateOptions, type ClientCameraRotation, type ClientCameraRenderOptions, type ClientCameraShakeOptions, type ClientCameraTransform, IClientCameraPort } from '../../../adapters/contracts/client/camera/IClientCameraPort';
+import type { Vector3 } from '../../../kernel/utils/vector3';
+export declare class NodeClientCameraPort extends IClientCameraPort {
+    create(_options?: ClientCameraCreateOptions): number;
+    setActive(_camera: number, _active: boolean): void;
+    render(_enable: boolean, _options?: ClientCameraRenderOptions): void;
+    destroy(_camera: number, _destroyActiveCamera?: boolean): void;
+    destroyAll(_destroyActiveCamera?: boolean): void;
+    setTransform(_camera: number, _transform: ClientCameraTransform): void;
+    setPosition(_camera: number, _position: Vector3): void;
+    setRotation(_camera: number, _rotation: ClientCameraRotation, _rotationOrder?: number): void;
+    setFov(_camera: number, _fov: number): void;
+    pointAtCoords(_camera: number, _position: Vector3): void;
+    pointAtEntity(_camera: number, _entity: number, _offset?: Vector3): void;
+    stopPointing(_camera: number): void;
+    interpolate(_fromCamera: number, _toCamera: number, _durationMs: number, _easeLocation?: boolean, _easeRotation?: boolean): void;
+    shake(_camera: number, _options: ClientCameraShakeOptions): void;
+    stopShaking(_camera: number, _stopImmediately?: boolean): void;
+}

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

@@ -0,0 +1,31 @@
+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 { IClientCameraPort, } from '../../../adapters/contracts/client/camera/IClientCameraPort';
+let NodeClientCameraPort = class NodeClientCameraPort extends IClientCameraPort {
+    create(_options) {
+        return 0;
+    }
+    setActive(_camera, _active) { }
+    render(_enable, _options) { }
+    destroy(_camera, _destroyActiveCamera) { }
+    destroyAll(_destroyActiveCamera) { }
+    setTransform(_camera, _transform) { }
+    setPosition(_camera, _position) { }
+    setRotation(_camera, _rotation, _rotationOrder) { }
+    setFov(_camera, _fov) { }
+    pointAtCoords(_camera, _position) { }
+    pointAtEntity(_camera, _entity, _offset) { }
+    stopPointing(_camera) { }
+    interpolate(_fromCamera, _toCamera, _durationMs, _easeLocation, _easeRotation) { }
+    shake(_camera, _options) { }
+    stopShaking(_camera, _stopImmediately) { }
+};
+NodeClientCameraPort = __decorate([
+    injectable()
+], NodeClientCameraPort);
+export { NodeClientCameraPort };