@nice2dev/game-engine 1.3.13 → 1.3.14

package/dist/types/multiplayer/NiceNetcode.d.ts

@@ -1,434 +0,0 @@
-/** Network tick number */
-export type NetTick = number;
-/** Unique network entity ID */
-export type NetEntityId = string;
-/** Unique player ID */
-export type NetPlayerId = string;
-/** Network message priority */
-export type NetPriority = 'critical' | 'high' | 'normal' | 'low';
-/** Network reliability mode */
-export type NetReliability = 'reliable' | 'unreliable' | 'reliable-ordered' | 'unreliable-sequenced';
-/** Connection state */
-export type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'disconnecting' | 'failed';
-/** Role in network game */
-export type NetRole = 'server' | 'client' | 'host' | 'dedicated-server';
-export interface Vec2 {
-    x: number;
-    y: number;
-}
-export interface Vec3 {
-    x: number;
-    y: number;
-    z: number;
-}
-export interface Quat {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-}
-export interface NetConfig {
-    /** Target tick rate (server authority) */
-    tickRate: number;
-    /** Client send rate */
-    sendRate: number;
-    /** Server->client update rate */
-    updateRate: number;
-    /** Max packet size in bytes */
-    maxPacketSize: number;
-    /** Connection timeout in ms */
-    connectionTimeout: number;
-    /** Reconnect attempts */
-    maxReconnectAttempts: number;
-    /** Input buffer size for rollback */
-    inputBufferSize: number;
-    /** State history size for rollback */
-    stateHistorySize: number;
-    /** Max prediction frames */
-    maxPredictionFrames: number;
-    /** Interpolation delay in ticks */
-    interpolationDelay: number;
-    /** Enable delta compression */
-    deltaCompression: boolean;
-    /** Enable lag compensation */
-    lagCompensation: boolean;
-    /** Server-side rewind limit in ms */
-    maxLagCompensationMs: number;
-    /** Jitter buffer size */
-    jitterBufferSize: number;
-}
-export declare const DEFAULT_NET_CONFIG: NetConfig;
-export interface NetInput {
-    /** Input occurred at this tick */
-    tick: NetTick;
-    /** Player who sent input */
-    playerId: NetPlayerId;
-    /** Input data (game-specific) */
-    data: Record<string, unknown>;
-    /** Input sequence number */
-    sequence: number;
-    /** Timestamp when input was generated */
-    timestamp: number;
-}
-export interface InputBuffer {
-    inputs: NetInput[];
-    lastConfirmedTick: NetTick;
-    lastReceivedTick: NetTick;
-}
-export interface NetTransform {
-    position: Vec3;
-    rotation: Quat;
-    scale: Vec3;
-}
-export interface NetEntityState {
-    entityId: NetEntityId;
-    ownerId: NetPlayerId | null;
-    tick: NetTick;
-    transform: NetTransform;
-    velocity: Vec3;
-    angularVelocity: Vec3;
-    customState: Record<string, unknown>;
-    priority: NetPriority;
-    relevancy: number;
-    lastUpdated: number;
-}
-export interface NetWorldState {
-    tick: NetTick;
-    timestamp: number;
-    entities: Map<NetEntityId, NetEntityState>;
-    playerStates: Map<NetPlayerId, NetPlayerState>;
-    globalState: Record<string, unknown>;
-}
-export interface NetPlayerState {
-    playerId: NetPlayerId;
-    name: string;
-    ping: number;
-    packetLoss: number;
-    connected: boolean;
-    ready: boolean;
-    team: number;
-    score: number;
-    lastInputTick: NetTick;
-}
-export interface StateSnapshot {
-    tick: NetTick;
-    timestamp: number;
-    state: NetWorldState;
-    checksum: number;
-}
-export interface StateDelta {
-    fromTick: NetTick;
-    toTick: NetTick;
-    changes: EntityDelta[];
-    removedEntities: NetEntityId[];
-    globalChanges: Record<string, unknown>;
-}
-export interface EntityDelta {
-    entityId: NetEntityId;
-    changedFields: string[];
-    values: Record<string, unknown>;
-}
-export interface PredictionState {
-    predictedTick: NetTick;
-    confirmedTick: NetTick;
-    pendingInputs: NetInput[];
-    mispredicted: boolean;
-    rollbackCount: number;
-}
-export interface RollbackFrame {
-    tick: NetTick;
-    state: NetWorldState;
-    inputs: Map<NetPlayerId, NetInput>;
-    checksum: number;
-}
-export interface RollbackConfig {
-    maxFrames: number;
-    checksumValidation: boolean;
-    syncTestEnabled: boolean;
-    desyncDetection: boolean;
-}
-export interface InterpolationState {
-    entityId: NetEntityId;
-    fromState: NetEntityState;
-    toState: NetEntityState;
-    alpha: number;
-    method: InterpolationMethod;
-}
-export type InterpolationMethod = 'linear' | 'hermite' | 'catmull-rom' | 'none';
-export interface InterpolationConfig {
-    delay: number;
-    bufferSize: number;
-    extrapolationLimit: number;
-    method: InterpolationMethod;
-}
-export interface LagCompensationRequest {
-    playerId: NetPlayerId;
-    tick: NetTick;
-    timestamp: number;
-    position: Vec3;
-    radius: number;
-}
-export interface LagCompensationResult {
-    hitEntities: NetEntityId[];
-    rewindTick: NetTick;
-    confidence: number;
-}
-export interface HitboxSnapshot {
-    entityId: NetEntityId;
-    tick: NetTick;
-    position: Vec3;
-    bounds: {
-        min: Vec3;
-        max: Vec3;
-    };
-    active: boolean;
-}
-export type NetMessageType = 'handshake' | 'handshake-ack' | 'input' | 'input-ack' | 'state-snapshot' | 'state-delta' | 'sync-request' | 'sync-response' | 'entity-spawn' | 'entity-destroy' | 'rpc' | 'ping' | 'pong' | 'disconnect' | 'kick' | 'lobby-update' | 'match-start' | 'match-end';
-export interface NetMessage<T = unknown> {
-    type: NetMessageType;
-    sequence: number;
-    tick: NetTick;
-    timestamp: number;
-    senderId: string;
-    payload: T;
-    reliable: boolean;
-    channel: number;
-}
-export interface HandshakePayload {
-    version: string;
-    playerName: string;
-    authToken?: string;
-    clientTick: NetTick;
-}
-export interface HandshakeAckPayload {
-    accepted: boolean;
-    playerId: NetPlayerId;
-    serverTick: NetTick;
-    config: NetConfig;
-    rejectReason?: string;
-}
-export interface RPCPayload {
-    method: string;
-    args: unknown[];
-    target: 'server' | 'client' | 'broadcast' | 'multicast';
-    targetIds?: string[];
-    reliability: NetReliability;
-}
-export interface ConnectionQuality {
-    ping: number;
-    jitter: number;
-    packetLoss: number;
-    bandwidth: number;
-    quality: 'excellent' | 'good' | 'fair' | 'poor' | 'critical';
-}
-export declare function assessConnectionQuality(ping: number, jitter: number, packetLoss: number): ConnectionQuality['quality'];
-export interface RelevancyConfig {
-    /** Distance-based relevancy falloff */
-    maxDistance: number;
-    /** Update frequency falloff curve */
-    falloffCurve: 'linear' | 'quadratic' | 'exponential';
-    /** Always relevant entity types */
-    alwaysRelevant: string[];
-    /** Owner-only visibility */
-    ownerOnly: string[];
-    /** Team-only visibility */
-    teamOnly: string[];
-}
-export declare function calculateRelevancy(viewerPosition: Vec3, entityPosition: Vec3, config: RelevancyConfig): number;
-export type RPCTarget = 'server' | 'owner' | 'all-clients' | 'other-clients';
-export interface RPCDefinition<TArgs extends unknown[] = unknown[], TResult = void> {
-    name: string;
-    target: RPCTarget;
-    reliability: NetReliability;
-    validate?: (...args: TArgs) => boolean;
-    execute: (...args: TArgs) => TResult | Promise<TResult>;
-}
-export declare class RPCRegistry {
-    private rpcs;
-    register<TArgs extends unknown[], TResult>(def: RPCDefinition<TArgs, TResult>): void;
-    get(name: string): RPCDefinition | undefined;
-    has(name: string): boolean;
-    invoke(name: string, args: unknown[], context: {
-        senderId: string;
-        isServer: boolean;
-    }): Promise<unknown>;
-}
-export declare class InputPredictor {
-    private inputHistory;
-    private maxHistory;
-    constructor(maxHistory?: number);
-    addInput(input: NetInput): void;
-    getUnconfirmedInputs(confirmedTick: NetTick): NetInput[];
-    getInputAtTick(tick: NetTick): NetInput | undefined;
-    clearBefore(tick: NetTick): void;
-    predict(currentInput: NetInput, lookAhead?: number): NetInput[];
-}
-export declare class StateInterpolator {
-    private stateBuffer;
-    private config;
-    constructor(config?: Partial<InterpolationConfig>);
-    pushState(state: NetEntityState): void;
-    getInterpolatedState(entityId: NetEntityId, renderTick: number): NetEntityState | null;
-    private interpolate;
-    private linearInterpolate;
-    private hermiteInterpolate;
-    private slerpQuat;
-    clear(entityId?: NetEntityId): void;
-}
-export declare class RollbackManager {
-    private frameHistory;
-    private config;
-    private rollbackCount;
-    private lastDesync;
-    constructor(config?: Partial<RollbackConfig>);
-    saveFrame(frame: RollbackFrame): void;
-    getFrame(tick: NetTick): RollbackFrame | undefined;
-    rollbackTo(tick: NetTick): RollbackFrame | null;
-    detectDesync(localState: NetWorldState, serverState: NetWorldState): boolean;
-    private computeChecksum;
-    getStats(): {
-        rollbackCount: number;
-        lastDesync: NetTick | null;
-    };
-    clear(): void;
-}
-export declare class LagCompensator {
-    private hitboxHistory;
-    private maxHistoryMs;
-    constructor(maxHistoryMs?: number);
-    recordHitbox(snapshot: HitboxSnapshot): void;
-    rewind(request: LagCompensationRequest, currentTick: NetTick): LagCompensationResult;
-    private getClosestSnapshot;
-    private pointInBounds;
-    clear(): void;
-}
-export declare class DeltaCompressor {
-    private baselineStates;
-    setBaseline(state: NetEntityState): void;
-    computeDelta(current: NetEntityState): EntityDelta | null;
-    applyDelta(entityId: NetEntityId, delta: EntityDelta): NetEntityState | null;
-    private vec3Equal;
-    private quatEqual;
-    clearBaseline(entityId?: NetEntityId): void;
-}
-export interface LobbyConfig {
-    maxPlayers: number;
-    minPlayers: number;
-    isPublic: boolean;
-    password?: string;
-    region: string;
-    mode: string;
-    customData: Record<string, unknown>;
-}
-export interface Lobby {
-    id: string;
-    name: string;
-    hostId: NetPlayerId;
-    config: LobbyConfig;
-    players: LobbyPlayer[];
-    state: LobbyState;
-    createdAt: number;
-    startedAt?: number;
-}
-export interface LobbyPlayer {
-    playerId: NetPlayerId;
-    name: string;
-    ready: boolean;
-    team: number;
-    slot: number;
-    isHost: boolean;
-    customData: Record<string, unknown>;
-}
-export type LobbyState = 'waiting' | 'ready' | 'countdown' | 'starting' | 'in-game' | 'finished';
-export interface MatchmakingConfig {
-    mode: string;
-    region: string;
-    skillRange: number;
-    maxWaitTime: number;
-    teamSize: number;
-    customFilters: Record<string, unknown>;
-}
-export interface MatchmakingTicket {
-    id: string;
-    playerId: NetPlayerId;
-    config: MatchmakingConfig;
-    status: 'searching' | 'found' | 'cancelled' | 'expired';
-    createdAt: number;
-    matchedLobby?: string;
-}
-export interface NetClientCallbacks {
-    onConnect?: () => void;
-    onDisconnect?: (reason: string) => void;
-    onStateUpdate?: (state: NetWorldState) => void;
-    onEntitySpawn?: (entity: NetEntityState) => void;
-    onEntityDestroy?: (entityId: NetEntityId) => void;
-    onRPC?: (method: string, args: unknown[]) => void;
-    onLobbyUpdate?: (lobby: Lobby) => void;
-    onMatchStart?: () => void;
-    onMatchEnd?: (result: Record<string, unknown>) => void;
-    onDesync?: (serverTick: NetTick) => void;
-}
-export declare class NiceNetcodeClient {
-    private config;
-    private state;
-    private playerId;
-    private currentTick;
-    private serverTick;
-    private inputPredictor;
-    private interpolator;
-    private rollbackManager;
-    private deltaCompressor;
-    private rpcRegistry;
-    private callbacks;
-    private worldState;
-    private lobby;
-    constructor(config?: Partial<NetConfig>, callbacks?: NetClientCallbacks);
-    connect(_serverUrl: string, _playerName: string): Promise<boolean>;
-    disconnect(): void;
-    sendInput(input: Omit<NetInput, 'tick' | 'playerId' | 'sequence' | 'timestamp'>): void;
-    tick(deltaTime: number): void;
-    getInterpolatedEntity(entityId: NetEntityId): NetEntityState | null;
-    registerRPC<TArgs extends unknown[], TResult>(def: RPCDefinition<TArgs, TResult>): void;
-    callRPC(method: string, args: unknown[], _target?: RPCTarget): void;
-    getConnectionQuality(): ConnectionQuality;
-    getState(): ConnectionState;
-    getPlayerId(): NetPlayerId | null;
-    getCurrentTick(): NetTick;
-    getServerTick(): NetTick;
-    getLobby(): Lobby | null;
-    getWorldState(): NetWorldState | null;
-}
-export interface NetServerCallbacks {
-    onPlayerConnect?: (playerId: NetPlayerId) => void;
-    onPlayerDisconnect?: (playerId: NetPlayerId, reason: string) => void;
-    onPlayerInput?: (playerId: NetPlayerId, input: NetInput) => void;
-    onRPC?: (senderId: NetPlayerId, method: string, args: unknown[]) => void;
-}
-export declare class NiceNetcodeServer {
-    private config;
-    private currentTick;
-    private players;
-    private entities;
-    private inputBuffers;
-    private lagCompensator;
-    private deltaCompressor;
-    private rpcRegistry;
-    private callbacks;
-    private lobbies;
-    constructor(config?: Partial<NetConfig>, callbacks?: NetServerCallbacks);
-    tick(_deltaTime: number): void;
-    spawnEntity(entity: NetEntityState): NetEntityId;
-    destroyEntity(entityId: NetEntityId): boolean;
-    updateEntity(entityId: NetEntityId, updates: Partial<NetEntityState>): void;
-    performLagCompensatedHit(request: LagCompensationRequest): LagCompensationResult;
-    getWorldState(): NetWorldState;
-    createLobby(hostId: NetPlayerId, name: string, config: LobbyConfig): Lobby;
-    getLobby(id: string): Lobby | undefined;
-    getAllLobbies(): Lobby[];
-    registerRPC<TArgs extends unknown[], TResult>(def: RPCDefinition<TArgs, TResult>): void;
-    getCurrentTick(): NetTick;
-    getPlayer(playerId: NetPlayerId): NetPlayerState | undefined;
-    getAllPlayers(): NetPlayerState[];
-}
-export declare function createNetcodeClient(config?: Partial<NetConfig>, callbacks?: NetClientCallbacks): NiceNetcodeClient;
-export declare function createNetcodeServer(config?: Partial<NetConfig>, callbacks?: NetServerCallbacks): NiceNetcodeServer;

package/dist/types/multiplayer/index.d.ts

@@ -1,5 +0,0 @@
-export { PlayerManager, SplitScreenManager, PLAYER_COLORS } from './LocalMultiplayer';
-export type { Player, Viewport } from './LocalMultiplayer';
-export { GameRegistry, gameRegistry, MINI_PLAYER_COLORS, MINI_PLAYER_NAMES, KEYBOARD_GROUPS, DIR_UP, DIR_DOWN, DIR_LEFT, DIR_RIGHT, type PlayerSlot, type InputSource, type Dir, type KeyboardGroup, type MiniGameMeta, type MiniGameConfig, } from './MiniGameTypes';
-export { NiceNetcodeClient, NiceNetcodeServer, InputPredictor, StateInterpolator, RollbackManager, LagCompensator, DeltaCompressor, RPCRegistry, createNetcodeClient, createNetcodeServer, assessConnectionQuality, calculateRelevancy, DEFAULT_NET_CONFIG, } from './NiceNetcode';
-export type { NetTick, NetEntityId, NetPlayerId, NetPriority, NetReliability, ConnectionState, NetRole, Vec2, Vec3, Quat, NetConfig, NetInput, InputBuffer, NetTransform, NetEntityState, NetWorldState, NetPlayerState, StateSnapshot, StateDelta, EntityDelta, PredictionState, RollbackFrame, RollbackConfig, InterpolationState, InterpolationMethod, InterpolationConfig, LagCompensationRequest, LagCompensationResult, HitboxSnapshot, NetMessageType, NetMessage, HandshakePayload, HandshakeAckPayload, RPCPayload, RPCTarget, RPCDefinition, ConnectionQuality, RelevancyConfig, LobbyConfig, Lobby, LobbyPlayer, LobbyState, MatchmakingConfig, MatchmakingTicket, NetClientCallbacks, NetServerCallbacks, } from './NiceNetcode';

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

@@ -1,2 +0,0 @@
-export * from './Networking';
-export { LocalTransport, SignalRTransport, type IMultiplayerTransport, type TransportState, type TransportMessage, } from './MultiplayerTransport';

package/dist/types/pathfinding/index.d.ts

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

package/dist/types/performance/AssetCompression.d.ts

@@ -1,137 +0,0 @@
-export type AssetType = 'texture' | 'audio' | 'mesh' | 'animation' | 'font' | 'data';
-export interface CompressionStats {
-    originalSize: number;
-    compressedSize: number;
-    ratio: number;
-    duration: number;
-    format: string;
-}
-export interface TextureCompressionConfig {
-    format: 'webp' | 'avif' | 'basis' | 'ktx2' | 'png';
-    quality: number;
-    maxWidth: number;
-    maxHeight: number;
-    generateMipmaps: boolean;
-    premultiplyAlpha: boolean;
-    powerOfTwo: boolean;
-}
-export interface AudioCompressionConfig {
-    format: 'opus' | 'aac' | 'mp3' | 'ogg';
-    bitrate: number;
-    sampleRate: number;
-    channels: 1 | 2;
-    normalize: boolean;
-}
-export interface MeshCompressionConfig {
-    quantizationBits: number;
-    mergeVertices: boolean;
-    stripNormals: boolean;
-    stripUVs: boolean;
-    draco: boolean;
-}
-export interface AssetManifest {
-    version: number;
-    assets: AssetEntry[];
-    totalOriginalSize: number;
-    totalCompressedSize: number;
-    compressionRatio: number;
-}
-export interface AssetEntry {
-    id: string;
-    type: AssetType;
-    originalPath: string;
-    compressedPath: string;
-    originalSize: number;
-    compressedSize: number;
-    format: string;
-    hash: string;
-    metadata?: Record<string, unknown>;
-}
-export interface StreamingConfig {
-    chunkSize: number;
-    concurrency: number;
-    priorityLevels: number;
-    preloadDistance: number;
-}
-export declare class TextureCompressor {
-    private config;
-    constructor(config?: Partial<TextureCompressionConfig>);
-    compress(imageData: ImageData | HTMLCanvasElement): Promise<{
-        blob: Blob;
-        stats: CompressionStats;
-    }>;
-    generateMipmaps(canvas: HTMLCanvasElement): Promise<HTMLCanvasElement[]>;
-    private resizeCanvas;
-    private ensurePowerOfTwo;
-    private getMimeType;
-}
-export declare class AudioCompressor {
-    private config;
-    constructor(config?: Partial<AudioCompressionConfig>);
-    compress(audioBuffer: AudioBuffer): Promise<{
-        blob: Blob;
-        stats: CompressionStats;
-    }>;
-    private resample;
-    private normalizeAudio;
-    private encodeWAV;
-    private writeString;
-}
-export declare class MeshCompressor {
-    private config;
-    constructor(config?: Partial<MeshCompressionConfig>);
-    compress(vertices: Float32Array, indices: Uint32Array, normals?: Float32Array, uvs?: Float32Array): {
-        vertices: Float32Array | Int16Array;
-        indices: Uint32Array | Uint16Array;
-        normals?: Float32Array | Int8Array;
-        uvs?: Float32Array | Uint16Array;
-        stats: CompressionStats;
-    };
-    private quantizeVertices;
-    private quantizeNormals;
-    private quantizeUVs;
-    private mergeVertices;
-}
-export declare class AssetStreamer {
-    private config;
-    private activeDownloads;
-    private queue;
-    private cache;
-    constructor(config?: Partial<StreamingConfig>);
-    load(url: string, priority?: number): Promise<ArrayBuffer>;
-    private processQueue;
-    preload(urls: string[], priority?: number): Promise<void[]>;
-    evict(url: string): boolean;
-    clearCache(): void;
-    get cacheSize(): number;
-    get pendingDownloads(): number;
-}
-export declare class AssetPipeline {
-    private textureCompressor;
-    private audioCompressor;
-    private meshCompressor;
-    private streamer;
-    private manifest;
-    constructor(config?: {
-        texture?: Partial<TextureCompressionConfig>;
-        audio?: Partial<AudioCompressionConfig>;
-        mesh?: Partial<MeshCompressionConfig>;
-        streaming?: Partial<StreamingConfig>;
-    });
-    getTextureCompressor(): TextureCompressor;
-    getAudioCompressor(): AudioCompressor;
-    getMeshCompressor(): MeshCompressor;
-    getStreamer(): AssetStreamer;
-    getManifest(): Readonly<AssetManifest>;
-    addToManifest(entry: AssetEntry): void;
-    exportManifest(): string;
-    getCompressionSummary(): {
-        totalAssets: number;
-        byType: Record<string, {
-            count: number;
-            savedBytes: number;
-        }>;
-        totalSavedBytes: number;
-        overallRatio: number;
-    };
-}

package/dist/types/performance/WASMModules.d.ts

@@ -1,65 +0,0 @@
-export interface WASMModuleConfig {
-    wasmUrl?: string;
-    fallbackToJS: boolean;
-    enableSIMD: boolean;
-}
-export interface Vec2 {
-    x: number;
-    y: number;
-}
-export interface AABB {
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-}
-export interface CollisionResult {
-    collides: boolean;
-    overlapX: number;
-    overlapY: number;
-    depth: number;
-}
-export interface PathResult {
-    path: Vec2[];
-    cost: number;
-    nodesExplored: number;
-}
-export interface WASMExports {
-    memory: WebAssembly.Memory;
-    aabb_test: (ax: number, ay: number, aw: number, ah: number, bx: number, by: number, bw: number, bh: number) => number;
-    aabb_overlap: (ax: number, ay: number, aw: number, ah: number, bx: number, by: number, bw: number, bh: number, outPtr: number) => void;
-    circle_test: (ax: number, ay: number, ar: number, bx: number, by: number, br: number) => number;
-    vec2_dot: (ax: number, ay: number, bx: number, by: number) => number;
-    vec2_cross: (ax: number, ay: number, bx: number, by: number) => number;
-    vec2_length: (x: number, y: number) => number;
-    vec2_normalize: (x: number, y: number, outPtr: number) => void;
-    astar_init: (width: number, height: number, gridPtr: number) => void;
-    astar_find: (sx: number, sy: number, tx: number, ty: number, outPtr: number) => number;
-    batch_aabb_test: (aabbsPtr: number, count: number, outPtr: number) => number;
-    malloc: (size: number) => number;
-    free: (ptr: number) => void;
-}
-export declare class WASMAccelerator {
-    private config;
-    private wasmExports;
-    private initialized;
-    constructor(config?: Partial<WASMModuleConfig>);
-    init(wasmBytes?: ArrayBuffer): Promise<boolean>;
-    get isWASM(): boolean;
-    get ready(): boolean;
-    aabbTest(ax: number, ay: number, aw: number, ah: number, bx: number, by: number, bw: number, bh: number): boolean;
-    aabbOverlap(a: AABB, b: AABB): CollisionResult;
-    circleTest(ax: number, ay: number, ar: number, bx: number, by: number, br: number): boolean;
-    batchAABBTest(aabbs: AABB[]): [number, number][];
-    vec2Dot(ax: number, ay: number, bx: number, by: number): number;
-    vec2Cross(ax: number, ay: number, bx: number, by: number): number;
-    vec2Length(x: number, y: number): number;
-    vec2Normalize(x: number, y: number): Vec2;
-    findPath(grid: number[][], startX: number, startY: number, targetX: number, targetY: number): PathResult;
-    destroy(): void;
-}
-export declare function benchmarkWASMvsJS(accelerator: WASMAccelerator, iterations?: number): Record<string, {
-    wasm: number;
-    js: number;
-    speedup: number;
-}>;