@nice2dev/game-engine 1.0.28 → 1.1.6

package/dist/types/native-engine/RenderingEngine.d.ts

@@ -0,0 +1,509 @@
+/**
+ * @file RenderingEngine.ts
+ * @description WebGPU/WebGL2 Rendering Engine for Nice2Dev Game Engine
+ * PRO-1.11.1: Core Engine Systems - Rendering
+ *
+ * Features:
+ * - WebGPU primary backend with WebGL2 fallback
+ * - Deferred rendering pipeline
+ * - PBR materials (metallic-roughness workflow)
+ * - IBL (Image-Based Lighting)
+ * - Cascaded Shadow Maps
+ * - Post-processing effects
+ */
+export type RenderBackend = 'webgpu' | 'webgl2' | 'auto';
+export type RenderPipeline = 'forward' | 'deferred' | 'forward-plus';
+export type AntiAliasingMode = 'none' | 'fxaa' | 'taa' | 'msaa';
+export type ToneMappingMode = 'none' | 'reinhard' | 'aces' | 'filmic' | 'uncharted2';
+export type ShadowQuality = 'off' | 'low' | 'medium' | 'high' | 'ultra';
+export type AmbientOcclusionMode = 'off' | 'ssao' | 'gtao' | 'hbao';
+export interface RenderConfig {
+    backend: RenderBackend;
+    pipeline: RenderPipeline;
+    resolution: {
+        width: number;
+        height: number;
+    };
+    renderScale: number;
+    maxFps: number;
+    vsync: boolean;
+    hdr: boolean;
+    antiAliasing: AntiAliasingMode;
+    msaaSamples?: 2 | 4 | 8;
+    toneMapping: ToneMappingMode;
+    exposure: number;
+    gamma: number;
+    shadows: ShadowConfig;
+    lighting: LightingConfig;
+    postProcessing: PostProcessingConfig;
+}
+export interface ShadowConfig {
+    enabled: boolean;
+    quality: ShadowQuality;
+    cascadeCount: number;
+    cascadeDistances: number[];
+    shadowMapSize: number;
+    softShadows: boolean;
+    shadowBias: number;
+    normalBias: number;
+}
+export interface LightingConfig {
+    maxDirectionalLights: number;
+    maxPointLights: number;
+    maxSpotLights: number;
+    iblEnabled: boolean;
+    iblIntensity: number;
+    ambientIntensity: number;
+    ambientColor: {
+        r: number;
+        g: number;
+        b: number;
+    };
+}
+export interface PostProcessingConfig {
+    bloom: BloomConfig;
+    ambientOcclusion: AmbientOcclusionConfig;
+    ssr: SSRConfig;
+    motionBlur: MotionBlurConfig;
+    dof: DOFConfig;
+    colorGrading: ColorGradingConfig;
+    vignette: VignetteConfig;
+    chromaticAberration: ChromaticAberrationConfig;
+    filmGrain: FilmGrainConfig;
+}
+export interface BloomConfig {
+    enabled: boolean;
+    threshold: number;
+    intensity: number;
+    radius: number;
+    softKnee: number;
+    iterations: number;
+}
+export interface AmbientOcclusionConfig {
+    enabled: boolean;
+    mode: AmbientOcclusionMode;
+    radius: number;
+    intensity: number;
+    bias: number;
+    sampleCount: number;
+}
+export interface SSRConfig {
+    enabled: boolean;
+    maxSteps: number;
+    thickness: number;
+    maxDistance: number;
+    stride: number;
+}
+export interface MotionBlurConfig {
+    enabled: boolean;
+    samples: number;
+    intensity: number;
+}
+export interface DOFConfig {
+    enabled: boolean;
+    focusDistance: number;
+    aperture: number;
+    focalLength: number;
+    bokehShape: 'circle' | 'hexagon' | 'octagon';
+}
+export interface ColorGradingConfig {
+    enabled: boolean;
+    temperature: number;
+    tint: number;
+    contrast: number;
+    saturation: number;
+    brightness: number;
+    lift: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    gamma: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    gain: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    lut?: string;
+}
+export interface VignetteConfig {
+    enabled: boolean;
+    intensity: number;
+    smoothness: number;
+    roundedness: number;
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+}
+export interface ChromaticAberrationConfig {
+    enabled: boolean;
+    intensity: number;
+}
+export interface FilmGrainConfig {
+    enabled: boolean;
+    intensity: number;
+    response: number;
+}
+export interface PBRMaterial {
+    name: string;
+    albedo: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    albedoMap?: string;
+    metallic: number;
+    metallicMap?: string;
+    roughness: number;
+    roughnessMap?: string;
+    normalMap?: string;
+    normalScale: number;
+    occlusionMap?: string;
+    occlusionStrength: number;
+    emissive: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    emissiveMap?: string;
+    emissiveIntensity: number;
+    alphaMode: 'opaque' | 'mask' | 'blend';
+    alphaCutoff: number;
+    doubleSided: boolean;
+    clearCoat?: ClearCoatConfig;
+    transmission?: TransmissionConfig;
+    subsurface?: SubsurfaceConfig;
+}
+export interface ClearCoatConfig {
+    factor: number;
+    roughness: number;
+    normalMap?: string;
+}
+export interface TransmissionConfig {
+    factor: number;
+    ior: number;
+    thicknessFactor: number;
+    attenuationColor: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    attenuationDistance: number;
+}
+export interface SubsurfaceConfig {
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    radius: number;
+}
+export interface DirectionalLight {
+    type: 'directional';
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    intensity: number;
+    direction: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    castShadows: boolean;
+    shadowBias: number;
+}
+export interface PointLight {
+    type: 'point';
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    intensity: number;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    range: number;
+    decay: number;
+    castShadows: boolean;
+    shadowBias: number;
+}
+export interface SpotLight {
+    type: 'spot';
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    intensity: number;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    direction: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    range: number;
+    innerConeAngle: number;
+    outerConeAngle: number;
+    decay: number;
+    castShadows: boolean;
+    shadowBias: number;
+}
+export interface AreaLight {
+    type: 'area';
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    intensity: number;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    direction: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    width: number;
+    height: number;
+    twoSided: boolean;
+}
+export type Light = DirectionalLight | PointLight | SpotLight | AreaLight;
+export interface EnvironmentMap {
+    diffuseIrradiance: string;
+    specularRadiance: string;
+    brdfLUT: string;
+    skybox?: string;
+    intensity: number;
+    rotation: number;
+}
+export interface MeshData {
+    positions: Float32Array;
+    normals?: Float32Array;
+    tangents?: Float32Array;
+    uvs?: Float32Array;
+    uvs2?: Float32Array;
+    colors?: Float32Array;
+    joints?: Uint16Array;
+    weights?: Float32Array;
+    indices?: Uint32Array | Uint16Array;
+}
+export interface MeshPrimitive {
+    mesh: MeshData;
+    material: PBRMaterial;
+    boundingBox: BoundingBox;
+    boundingSphere: BoundingSphere;
+}
+export interface BoundingBox {
+    min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+export interface BoundingSphere {
+    center: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    radius: number;
+}
+export interface RenderPass {
+    name: string;
+    enabled: boolean;
+    order: number;
+    execute: (context: RenderContext) => void;
+}
+export interface RenderContext {
+    backend: RenderBackendInstance;
+    camera: CameraData;
+    lights: Light[];
+    environment?: EnvironmentMap;
+    renderables: Renderable[];
+    time: number;
+    deltaTime: number;
+    frameIndex: number;
+}
+export interface Renderable {
+    id: string;
+    mesh: MeshPrimitive;
+    transform: Float32Array;
+    visible: boolean;
+    castShadows: boolean;
+    receiveShadows: boolean;
+    layer: number;
+    sortingOrder: number;
+}
+export interface CameraData {
+    viewMatrix: Float32Array;
+    projectionMatrix: Float32Array;
+    viewProjectionMatrix: Float32Array;
+    inverseViewMatrix: Float32Array;
+    inverseProjectionMatrix: Float32Array;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    forward: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    near: number;
+    far: number;
+    fov: number;
+    aspectRatio: number;
+}
+export interface RenderBackendInstance {
+    readonly type: 'webgpu' | 'webgl2';
+    readonly capabilities: BackendCapabilities;
+    initialize(canvas: HTMLCanvasElement): Promise<void>;
+    dispose(): void;
+    beginFrame(): void;
+    endFrame(): void;
+    createBuffer(data: ArrayBuffer, usage: BufferUsage): GPUBufferHandle;
+    updateBuffer(handle: GPUBufferHandle, data: ArrayBuffer, offset?: number): void;
+    deleteBuffer(handle: GPUBufferHandle): void;
+    createTexture(descriptor: TextureDescriptor): GPUTextureHandle;
+    updateTexture(handle: GPUTextureHandle, data: ArrayBuffer, mipLevel?: number): void;
+    deleteTexture(handle: GPUTextureHandle): void;
+    createShader(vertex: string, fragment: string): GPUShaderHandle;
+    deleteShader(handle: GPUShaderHandle): void;
+    createRenderTarget(width: number, height: number, format: TextureFormat, samples?: number): GPURenderTargetHandle;
+    deleteRenderTarget(handle: GPURenderTargetHandle): void;
+    setRenderTarget(handle: GPURenderTargetHandle | null): void;
+    clear(color: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    }, depth?: number, stencil?: number): void;
+    draw(primitive: DrawPrimitive): void;
+    drawInstanced(primitive: DrawPrimitive, instanceCount: number): void;
+}
+export interface BackendCapabilities {
+    maxTextureSize: number;
+    maxCubeMapSize: number;
+    maxSamples: number;
+    maxUniformBufferSize: number;
+    maxStorageBufferSize: number;
+    supportsCompute: boolean;
+    supportsTimestampQuery: boolean;
+    supportsIndirectDrawing: boolean;
+    supportsBindlessTextures: boolean;
+    supportedTextureFormats: TextureFormat[];
+}
+export type BufferUsage = 'vertex' | 'index' | 'uniform' | 'storage' | 'indirect';
+export type TextureFormat = 'rgba8unorm' | 'rgba8snorm' | 'rgba16float' | 'rgba32float' | 'rg16float' | 'rg32float' | 'r16float' | 'r32float' | 'depth24plus' | 'depth32float' | 'depth24plus-stencil8' | 'bc1-rgba-unorm' | 'bc3-rgba-unorm' | 'bc5-rg-unorm' | 'bc7-rgba-unorm';
+export type GPUBufferHandle = number;
+export type GPUTextureHandle = number;
+export type GPUShaderHandle = number;
+export type GPURenderTargetHandle = number;
+export interface TextureDescriptor {
+    width: number;
+    height: number;
+    depth?: number;
+    format: TextureFormat;
+    mipLevels?: number;
+    samples?: number;
+    usage: TextureUsage[];
+    data?: ArrayBuffer;
+}
+export type TextureUsage = 'sampled' | 'storage' | 'render-target' | 'copy-src' | 'copy-dst';
+export interface DrawPrimitive {
+    shader: GPUShaderHandle;
+    vertexBuffer: GPUBufferHandle;
+    indexBuffer?: GPUBufferHandle;
+    indexCount?: number;
+    vertexCount: number;
+    uniforms: UniformBindings;
+    textures: TextureBindings;
+    blendState?: BlendState;
+    depthState?: DepthState;
+    cullMode?: CullMode;
+}
+export type UniformBindings = Record<string, ArrayBuffer | number | Float32Array>;
+export type TextureBindings = Record<string, GPUTextureHandle>;
+export interface BlendState {
+    enabled: boolean;
+    srcFactor: BlendFactor;
+    dstFactor: BlendFactor;
+    operation: BlendOperation;
+}
+export type BlendFactor = 'zero' | 'one' | 'src-alpha' | 'one-minus-src-alpha' | 'dst-alpha' | 'one-minus-dst-alpha';
+export type BlendOperation = 'add' | 'subtract' | 'reverse-subtract' | 'min' | 'max';
+export interface DepthState {
+    enabled: boolean;
+    writeEnabled: boolean;
+    compareFunction: CompareFunction;
+}
+export type CompareFunction = 'never' | 'less' | 'equal' | 'less-equal' | 'greater' | 'not-equal' | 'greater-equal' | 'always';
+export type CullMode = 'none' | 'front' | 'back';
+export declare class RenderingEngine {
+    private config;
+    private backend;
+    private canvas;
+    private passes;
+    private lights;
+    private renderables;
+    private environment;
+    private camera;
+    private frameIndex;
+    private lastFrameTime;
+    constructor(config?: Partial<RenderConfig>);
+    initialize(canvas: HTMLCanvasElement): Promise<void>;
+    private isWebGPUSupported;
+    private createWebGPUBackend;
+    private createWebGL2Backend;
+    private setupRenderPasses;
+    private executeGBufferPass;
+    private executeShadowPass;
+    private executeLightingPass;
+    private executeTransparentPass;
+    private executeForwardPass;
+    private executeAOPass;
+    private executeSSRPass;
+    private executeBloomPass;
+    private executeToneMappingPass;
+    private executeAAPass;
+    private executeFinalPass;
+    render(): void;
+    setCamera(camera: CameraData): void;
+    addLight(light: Light): void;
+    removeLight(light: Light): void;
+    clearLights(): void;
+    setEnvironment(environment: EnvironmentMap | null): void;
+    addRenderable(renderable: Renderable): void;
+    removeRenderable(id: string): void;
+    clearRenderables(): void;
+    setConfig(config: Partial<RenderConfig>): void;
+    getConfig(): RenderConfig;
+    setPostProcessing(config: Partial<PostProcessingConfig>): void;
+    dispose(): void;
+}
+export declare function createRenderingEngine(config?: Partial<RenderConfig>): RenderingEngine;

package/dist/types/native-engine/SceneGraph.d.ts

@@ -0,0 +1,164 @@
+/**
+ * @file SceneGraph.ts
+ * @description Scene Graph system for Nice2Dev Game Engine
+ * PRO-1.11.1: Core Engine Systems - Scene Graph
+ *
+ * Features:
+ * - Hierarchical transforms
+ * - Frustum culling
+ * - Octree/BVH spatial partitioning
+ * - Instanced rendering support
+ * - LOD system
+ */
+export type SceneNodeType = 'empty' | 'mesh' | 'light' | 'camera' | 'particle' | 'audio' | 'trigger' | 'group';
+export type CullingResult = 'inside' | 'outside' | 'intersecting';
+export interface Transform3D {
+    position: Vec3;
+    rotation: Quaternion;
+    scale: Vec3;
+    localMatrix: Mat4;
+    worldMatrix: Mat4;
+    dirty: boolean;
+}
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export type Mat4 = Float32Array;
+export interface AABB {
+    min: Vec3;
+    max: Vec3;
+}
+export interface Sphere {
+    center: Vec3;
+    radius: number;
+}
+export interface OBB {
+    center: Vec3;
+    halfExtents: Vec3;
+    rotation: Quaternion;
+}
+export interface Frustum {
+    planes: Plane[];
+    corners: Vec3[];
+}
+export interface Plane {
+    normal: Vec3;
+    distance: number;
+}
+export interface LODConfig {
+    levels: LODLevel[];
+    strategy: 'distance' | 'screen-size' | 'custom';
+    fadeTransition: boolean;
+    fadeRange: number;
+}
+export interface LODLevel {
+    distance: number;
+    screenSizeThreshold?: number;
+    meshId?: string;
+    billboardMode?: 'none' | 'spherical' | 'cylindrical';
+    visible: boolean;
+}
+export interface SceneNodeData {
+    meshId?: string;
+    materialId?: string;
+    lightData?: unknown;
+    cameraData?: unknown;
+    customData?: Record<string, unknown>;
+}
+export declare class SceneNode {
+    id: string;
+    name: string;
+    type: SceneNodeType;
+    transform: Transform3D;
+    parent: SceneNode | null;
+    children: SceneNode[];
+    visible: boolean;
+    castShadows: boolean;
+    receiveShadows: boolean;
+    layer: number;
+    tags: Set<string>;
+    data: SceneNodeData;
+    localBounds: AABB;
+    worldBounds: AABB;
+    boundingSphere: Sphere;
+    lod?: LODConfig;
+    currentLODLevel: number;
+    instanceGroup?: string;
+    private static nextId;
+    constructor(name: string, type?: SceneNodeType);
+    setPosition(x: number, y: number, z: number): void;
+    setRotation(x: number, y: number, z: number, w: number): void;
+    setRotationEuler(pitch: number, yaw: number, roll: number): void;
+    setScale(x: number, y: number, z: number): void;
+    translate(x: number, y: number, z: number): void;
+    rotate(x: number, y: number, z: number, w: number): void;
+    lookAt(target: Vec3, up?: Vec3): void;
+    getWorldPosition(): Vec3;
+    getForward(): Vec3;
+    getRight(): Vec3;
+    getUp(): Vec3;
+    private markDirty;
+    updateLocalMatrix(): void;
+    updateWorldMatrix(): void;
+    private updateWorldBounds;
+    addChild(node: SceneNode): void;
+    removeChild(node: SceneNode): void;
+    removeFromParent(): void;
+    getRoot(): SceneNode;
+    findByName(name: string): SceneNode | null;
+    findById(id: string): SceneNode | null;
+    findByTag(tag: string): SceneNode[];
+    private collectByTag;
+    traverse(callback: (node: SceneNode) => boolean | void): void;
+    traverseVisible(callback: (node: SceneNode) => boolean | void): void;
+    setLOD(config: LODConfig): void;
+    updateLOD(cameraPosition: Vec3): void;
+    clone(deep?: boolean): SceneNode;
+}
+export interface OctreeConfig {
+    maxDepth: number;
+    maxObjectsPerNode: number;
+    looseness: number;
+    minSize: number;
+}
+export declare class Octree {
+    private root;
+    private config;
+    private nodePool;
+    constructor(bounds: AABB, config?: Partial<OctreeConfig>);
+    private createNode;
+    private releaseNode;
+    insert(node: SceneNode): void;
+    private insertIntoNode;
+    private split;
+    private getChildIndex;
+    remove(node: SceneNode): void;
+    private removeFromNode;
+    update(node: SceneNode): void;
+    queryFrustum(frustum: Frustum): SceneNode[];
+    private queryFrustumNode;
+    private collectAllObjects;
+    queryAABB(bounds: AABB): SceneNode[];
+    private queryAABBNode;
+    querySphere(center: Vec3, radius: number): SceneNode[];
+    private querySphereNode;
+    raycast(origin: Vec3, direction: Vec3, maxDistance?: number): RaycastHit[];
+    private raycastNode;
+    clear(): void;
+}
+export interface RaycastHit {
+    node: SceneNode;
+    distance: number;
+    point: Vec3;
+    normal: Vec3;
+}
+export declare function createSceneNode(name: string, type?: SceneNodeType): SceneNode;
+export declare function createOctree(bounds: AABB, config?: Partial<OctreeConfig>): Octree;

package/dist/types/native-engine/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @file index.ts
+ * @description Native Engine exports for Nice2Dev Game Engine
+ * PRO-1.11: Nice2Dev Native Engine
+ *
+ * Complete standalone game engine with:
+ * - WebGPU/WebGL2 rendering
+ * - Scene graph with spatial partitioning
+ * - Asset pipeline with hot reloading
+ * - Physics (Rapier.js compatible)
+ * - Audio (Web Audio API)
+ * - Animation (skeletal, state machine, IK)
+ * - Input system (keyboard, mouse, gamepad, touch)
+ * - IMGUI-style UI system
+ * - Networking (WebSocket, lobbies, matchmaking)
+ */
+export { type RenderConfig, type PostProcessingConfig, type ShadowConfig, type PBRMaterial, type Light, type DirectionalLight, type PointLight, type SpotLight, type AreaLight, type BoundingBox, type BoundingSphere, RenderingEngine, createRenderingEngine, } from './RenderingEngine';
+export { type Transform3D, type Frustum, type LODLevel, type OctreeConfig, type AABB, type Sphere, SceneNode, Octree, createSceneNode, createOctree, } from './SceneGraph';
+export { type AssetType, type AssetState, type Asset, type AssetLoader, type AssetProcessor, type AssetCallbacks, type SceneImportSettings, AssetManager, createAssetManager, } from './AssetPipeline';
+export { type RigidBodyType, type ColliderShape, type JointType, type CollisionEvent, type Vec3, type Quaternion, type Vec2, type PhysicsConfig, type RigidBodyDescriptor, type RigidBody, type ColliderDescriptor, type Collider, type JointDescriptor, type Joint, type RaycastHit, type ShapecastHit, type OverlapResult, type ContactPoint, type ContactPair, type CharacterControllerDescriptor, type CharacterController, type CharacterMovementFlags, PhysicsWorld, createPhysicsWorld, } from './PhysicsEngine';
+export { type AudioState, type EffectType, type SpatialModelType, type AudioSourceDescriptor, type AudioSource, type AudioChannelDescriptor, type AudioChannel, type EffectDescriptor, type AudioEffect, type ReverbZoneDescriptor, type ReverbZone, type MusicTrackDescriptor, type MusicLayerDescriptor, type MusicTransitionDescriptor, type MusicTrack, type MusicLayer, type AudioListener, AudioEngine, createAudioEngine, } from './AudioEngine';
+export { type BlendMode, type WrapMode, type IKSolverType, type BoneDescriptor, type Bone, type Skeleton, type AnimationClipDescriptor, type AnimationTrack, type Keyframe, type AnimationEvent, type AnimationClip, type AnimationLayerDescriptor, type AnimationLayer, type AvatarMask, type AnimationStateMachineDescriptor, type AnimationStateDescriptor, type AnimationTransitionDescriptor, type TransitionCondition, type AnimationParameter, type AnimationState, type AnimationTransition, type BlendTreeDescriptor, type BlendTreeChildDescriptor, type BlendTree, type BlendTreeChild, type IKChainDescriptor, type IKJointLimit, type IKChain, type MorphTargetDescriptor, type MorphTarget, type MorphTargetManager, AnimatorController, AnimationStateMachine, createAnimatorController, createAnimationClip, } from './AnimationSystem';
+export { type InputDeviceType, type KeyState, type MouseButton, type GamepadButton, type GamepadAxis, type InputBinding, type InputAction, type InputMap, type KeyboardState, type MouseState, type GamepadState, type TouchState, type Touch, type UIContext, InputSystem, UISystem, createInputSystem, createUISystem, } from './InputSystem';
+export { type ConnectionState, type NetworkRole, type SyncMode, type MessageChannel, type NetworkConfig, type NetworkPlayer, type LocalPlayer, type PlayerInput, type NetworkMessage, type StateSnapshot, type EntityState, type NetworkEvents, type LobbyConfig, type Lobby, type MatchmakingCriteria, type MatchmakingStatus, NetworkManager, NetworkEntity, LobbyManager, MatchmakingManager, createNetworkManager, createLobbyManager, createMatchmakingManager, } from './NetworkingSystem';

package/dist/types/network/MultiplayerTransport.d.ts

@@ -8,7 +8,7 @@
  *
  * For raw WebRTC, see PeerManager in network/Networking.ts.
  */
-export type TransportState = "disconnected" | "connecting" | "connected" | "reconnecting";
+export type TransportState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
 export interface TransportMessage {
     type: string;
     payload: unknown;