@nice2dev/game-engine 1.1.5 → 1.1.7

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

@@ -0,0 +1,173 @@
+/**
+ * @file AssetStreaming.ts
+ * @description Progressive asset loading with LOD management
+ * PRO-1.5: Runtime & Performance
+ *
+ * Features:
+ * - Progressive/streaming loading
+ * - Level of Detail (LOD) system
+ * - Priority-based loading queue
+ * - Memory budget management
+ * - Distance-based LOD selection
+ * - Asset reference counting
+ * - Async loading with cancellation
+ * - Texture streaming
+ * - Mesh LOD chains
+ */
+export type AssetType = 'texture' | 'mesh' | 'audio' | 'animation' | 'material' | 'shader' | 'font' | 'data' | 'prefab' | 'scene';
+export type AssetState = 'unloaded' | 'queued' | 'loading' | 'loaded' | 'streaming' | 'error';
+export type LODLevel = 0 | 1 | 2 | 3 | 4;
+export interface AssetDescriptor {
+    id: string;
+    type: AssetType;
+    url: string;
+    size: number;
+    priority: number;
+    lodLevels?: LODAsset[];
+    mipLevels?: number;
+    streamable: boolean;
+    persistent: boolean;
+    preload: boolean;
+    tags: string[];
+}
+export interface LODAsset {
+    level: LODLevel;
+    url: string;
+    size: number;
+    screenCoverage: number;
+    distance: number;
+}
+export interface StreamingAsset {
+    descriptor: AssetDescriptor;
+    state: AssetState;
+    data: unknown;
+    currentLOD: LODLevel;
+    targetLOD: LODLevel;
+    refCount: number;
+    lastUsed: number;
+    loadProgress: number;
+    error?: string;
+    abortController?: AbortController;
+}
+export interface LoadRequest {
+    assetId: string;
+    priority: number;
+    lodLevel: LODLevel;
+    callback?: (asset: StreamingAsset) => void;
+    onProgress?: (progress: number) => void;
+    onError?: (error: string) => void;
+}
+export interface MemoryBudget {
+    total: number;
+    textures: number;
+    meshes: number;
+    audio: number;
+    other: number;
+}
+export interface StreamingConfig {
+    maxConcurrentLoads: number;
+    maxQueueSize: number;
+    memoryBudget: MemoryBudget;
+    lodBias: number;
+    distanceScale: number;
+    hysteresis: number;
+    updateInterval: number;
+    unloadDelay: number;
+}
+export interface StreamingStats {
+    assetsLoaded: number;
+    assetsStreaming: number;
+    assetsQueued: number;
+    memoryUsed: number;
+    memoryBudget: number;
+    loadBandwidth: number;
+    cacheHits: number;
+    cacheMisses: number;
+}
+export interface CameraInfo {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    forward: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    fov: number;
+    aspect: number;
+    near: number;
+    far: number;
+}
+export interface AssetInstance {
+    assetId: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    scale: number;
+    importance: number;
+}
+export declare const DEFAULT_STREAMING_CONFIG: StreamingConfig;
+export declare class LODCalculator {
+    private config;
+    constructor(config: StreamingConfig);
+    calculateScreenCoverage(instance: AssetInstance, camera: CameraInfo): number;
+    calculateLODLevel(descriptor: AssetDescriptor, instance: AssetInstance, camera: CameraInfo, currentLOD: LODLevel): LODLevel;
+    setConfig(config: Partial<StreamingConfig>): void;
+}
+export declare class AssetStreamingManager {
+    private config;
+    private lodCalculator;
+    private descriptors;
+    private assets;
+    private loadQueue;
+    private activeLoads;
+    private memoryUsage;
+    private stats;
+    private updateTimer;
+    private lastUpdateTime;
+    private bytesLoadedSinceLastUpdate;
+    private loaders;
+    private onAssetLoaded?;
+    private onAssetUnloaded?;
+    private onMemoryWarning?;
+    private onLoadError?;
+    constructor(config?: Partial<StreamingConfig>);
+    private setupDefaultLoaders;
+    registerAsset(descriptor: AssetDescriptor): void;
+    registerAssets(descriptors: AssetDescriptor[]): void;
+    unregisterAsset(assetId: string): void;
+    setLoader(type: AssetType, loader: (url: string, signal: AbortSignal, onProgress: (p: number) => void) => Promise<unknown>): void;
+    requestLoad(assetId: string, priority?: number, lodLevel?: LODLevel, callback?: (asset: StreamingAsset) => void, onProgress?: (progress: number) => void, onError?: (error: string) => void): void;
+    private processQueue;
+    private loadAsset;
+    cancelLoad(assetId: string): void;
+    releaseAsset(assetId: string): void;
+    unloadAsset(assetId: string): void;
+    unloadUnused(): void;
+    private getAssetSize;
+    private canAllocate;
+    private addMemoryUsage;
+    private removeMemoryUsage;
+    private updateTotalMemory;
+    private freeMemory;
+    updateLODs(camera: CameraInfo, instances: AssetInstance[]): void;
+    getAsset(assetId: string): StreamingAsset | undefined;
+    getAssetState(assetId: string): AssetState;
+    getDescriptor(assetId: string): AssetDescriptor | undefined;
+    getStats(): StreamingStats;
+    getConfig(): StreamingConfig;
+    setConfig(config: Partial<StreamingConfig>): void;
+    start(): void;
+    stop(): void;
+    setOnAssetLoaded(callback: (asset: StreamingAsset) => void): void;
+    setOnAssetUnloaded(callback: (assetId: string) => void): void;
+    setOnMemoryWarning(callback: (used: number, budget: number) => void): void;
+    setOnLoadError(callback: (assetId: string, error: string) => void): void;
+}
+export declare function createAssetStreamingManager(config?: Partial<StreamingConfig>): AssetStreamingManager;
+export declare function createAssetDescriptor(id: string, type: AssetType, url: string, size: number, options?: Partial<Omit<AssetDescriptor, 'id' | 'type' | 'url' | 'size'>>): AssetDescriptor;
+export declare function createLODAsset(level: LODLevel, url: string, size: number, screenCoverage: number, distance: number): LODAsset;

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

@@ -0,0 +1,143 @@
+/**
+ * @file DeltaCompression.ts
+ * @description Network bandwidth optimization using delta compression
+ * PRO-1.5: Runtime & Performance
+ *
+ * Features:
+ * - Delta encoding for state updates
+ * - Variable-length encoding
+ * - Bit packing
+ * - Huffman compression
+ * - Quantization
+ * - Interest-based filtering
+ */
+export interface DeltaState {
+    frame: number;
+    timestamp: number;
+    entities: DeltaEntity[];
+    deletedEntities: string[];
+    events: DeltaEvent[];
+}
+export interface DeltaEntity {
+    id: string;
+    isNew: boolean;
+    changedFields: string[];
+    values: Record<string, DeltaValue>;
+}
+export interface DeltaValue {
+    type: ValueType;
+    value: number | string | boolean;
+    quantized?: number;
+    bits?: number;
+}
+export type ValueType = 'int8' | 'int16' | 'int32' | 'uint8' | 'uint16' | 'uint32' | 'float16' | 'float32' | 'bool' | 'string' | 'enum';
+export interface DeltaEvent {
+    type: string;
+    data: Record<string, DeltaValue>;
+}
+export interface QuantizationConfig {
+    position: {
+        min: number;
+        max: number;
+        bits: number;
+    };
+    rotation: {
+        min: number;
+        max: number;
+        bits: number;
+    };
+    velocity: {
+        min: number;
+        max: number;
+        bits: number;
+    };
+    health: {
+        min: number;
+        max: number;
+        bits: number;
+    };
+    custom: Record<string, {
+        min: number;
+        max: number;
+        bits: number;
+    }>;
+}
+export interface CompressionStats {
+    rawBytes: number;
+    compressedBytes: number;
+    compressionRatio: number;
+    entitiesEncoded: number;
+    fieldsChanged: number;
+    bitsUsed: number;
+}
+export declare const DEFAULT_QUANTIZATION: QuantizationConfig;
+export declare class BitWriter {
+    private buffer;
+    private bitPosition;
+    private bytePosition;
+    private currentByte;
+    constructor(initialSize?: number);
+    writeBits(value: number, bits: number): void;
+    writeBool(value: boolean): void;
+    writeInt8(value: number): void;
+    writeInt16(value: number): void;
+    writeInt32(value: number): void;
+    writeFloat16(value: number): void;
+    writeFloat32(value: number): void;
+    writeString(str: string): void;
+    writeVarInt(value: number): void;
+    private flushByte;
+    private ensureCapacity;
+    finish(): Uint8Array;
+    getBitCount(): number;
+}
+export declare class BitReader {
+    private buffer;
+    private bitPosition;
+    private bytePosition;
+    private currentByte;
+    constructor(buffer: Uint8Array);
+    readBits(bits: number): number;
+    readBool(): boolean;
+    readInt8(): number;
+    readInt16(): number;
+    readInt32(): number;
+    readFloat16(): number;
+    readFloat32(): number;
+    readString(): string;
+    readVarInt(): number;
+    hasMore(): boolean;
+}
+export declare function quantize(value: number, min: number, max: number, bits: number): number;
+export declare function dequantize(quantized: number, min: number, max: number, bits: number): number;
+export declare class DeltaEncoder {
+    private quantization;
+    private previousStates;
+    constructor(quantization?: Partial<QuantizationConfig>);
+    encode(currentState: Record<string, Record<string, unknown>>): {
+        delta: DeltaState;
+        bytes: Uint8Array;
+        stats: CompressionStats;
+    };
+    private valuesEqual;
+    private encodeValue;
+    private getQuantizationConfig;
+    private writeDelta;
+    private writeValue;
+    private calculateStats;
+    reset(): void;
+}
+export declare class DeltaDecoder {
+    private quantization;
+    private currentState;
+    constructor(quantization?: Partial<QuantizationConfig>);
+    decode(bytes: Uint8Array): Record<string, Record<string, unknown>>;
+    private readValue;
+    private getQuantizationConfig;
+    reset(): void;
+    getState(): Record<string, Record<string, unknown>>;
+}
+export declare function createDeltaEncoder(quantization?: Partial<QuantizationConfig>): DeltaEncoder;
+export declare function createDeltaDecoder(quantization?: Partial<QuantizationConfig>): DeltaDecoder;
+export declare function createBitWriter(initialSize?: number): BitWriter;
+export declare function createBitReader(buffer: Uint8Array): BitReader;

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

@@ -0,0 +1,142 @@
+/**
+ * @file DeterministicPhysics.ts
+ * @description Deterministic physics simulation for competitive games
+ * PRO-1.5: Runtime & Performance
+ *
+ * Features:
+ * - Fixed-point arithmetic
+ * - Deterministic collision detection
+ * - Frame-based simulation
+ * - Lockstep networking support
+ * - State hashing for desync detection
+ * - Replay validation
+ */
+export type Fixed = number;
+export declare const FIXED_SHIFT = 16;
+export declare const FIXED_ONE: number;
+export declare const FIXED_HALF: number;
+export interface FixedVec2 {
+    x: Fixed;
+    y: Fixed;
+}
+export interface FixedAABB {
+    minX: Fixed;
+    minY: Fixed;
+    maxX: Fixed;
+    maxY: Fixed;
+}
+export interface DeterministicBody {
+    id: string;
+    position: FixedVec2;
+    velocity: FixedVec2;
+    acceleration: FixedVec2;
+    mass: Fixed;
+    restitution: Fixed;
+    friction: Fixed;
+    isStatic: boolean;
+    isTrigger: boolean;
+    collisionMask: number;
+    collisionLayer: number;
+    shape: CollisionShape;
+    userData?: unknown;
+}
+export type CollisionShape = {
+    type: 'circle';
+    radius: Fixed;
+} | {
+    type: 'aabb';
+    halfWidth: Fixed;
+    halfHeight: Fixed;
+} | {
+    type: 'capsule';
+    radius: Fixed;
+    height: Fixed;
+};
+export interface CollisionPair {
+    bodyA: string;
+    bodyB: string;
+    normal: FixedVec2;
+    penetration: Fixed;
+    contactPoint: FixedVec2;
+}
+export interface DeterministicConfig {
+    gravity: FixedVec2;
+    maxBodies: number;
+    maxIterations: number;
+    substeps: number;
+    sleepThreshold: Fixed;
+    sleepFrames: number;
+    broadphase: 'naive' | 'spatial';
+    cellSize: number;
+}
+export interface SimulationState {
+    frame: number;
+    bodies: DeterministicBody[];
+    hash: number;
+}
+export interface FrameInput {
+    frame: number;
+    inputs: Record<string, PlayerInputState>;
+}
+export interface PlayerInputState {
+    moveX: Fixed;
+    moveY: Fixed;
+    buttons: number;
+}
+export declare const DEFAULT_DETERMINISTIC_CONFIG: DeterministicConfig;
+export declare function fixedFromFloat(f: number): Fixed;
+export declare function fixedToFloat(f: Fixed): number;
+export declare function fixedMul(a: Fixed, b: Fixed): Fixed;
+export declare function fixedDiv(a: Fixed, b: Fixed): Fixed;
+export declare function fixedSqrt(a: Fixed): Fixed;
+export declare function fixedAbs(a: Fixed): Fixed;
+export declare function fixedMin(a: Fixed, b: Fixed): Fixed;
+export declare function fixedMax(a: Fixed, b: Fixed): Fixed;
+export declare function fixedClamp(value: Fixed, min: Fixed, max: Fixed): Fixed;
+export declare function vec2Add(a: FixedVec2, b: FixedVec2): FixedVec2;
+export declare function vec2Sub(a: FixedVec2, b: FixedVec2): FixedVec2;
+export declare function vec2Scale(v: FixedVec2, s: Fixed): FixedVec2;
+export declare function vec2Dot(a: FixedVec2, b: FixedVec2): Fixed;
+export declare function vec2LengthSq(v: FixedVec2): Fixed;
+export declare function vec2Length(v: FixedVec2): Fixed;
+export declare function vec2Normalize(v: FixedVec2): FixedVec2;
+export declare function vec2Negate(v: FixedVec2): FixedVec2;
+export declare function circleVsCircle(posA: FixedVec2, radiusA: Fixed, posB: FixedVec2, radiusB: Fixed): CollisionPair | null;
+export declare function aabbVsAABB(posA: FixedVec2, halfA: FixedVec2, posB: FixedVec2, halfB: FixedVec2): CollisionPair | null;
+export declare function circleVsAABB(circlePos: FixedVec2, radius: Fixed, aabbPos: FixedVec2, halfExtents: FixedVec2): CollisionPair | null;
+export declare class DeterministicWorld {
+    private config;
+    private bodies;
+    private spatialHash;
+    private frame;
+    private collisionPairs;
+    private onCollision?;
+    private onTrigger?;
+    constructor(config?: Partial<DeterministicConfig>);
+    addBody(body: DeterministicBody): void;
+    removeBody(id: string): void;
+    getBody(id: string): DeterministicBody | undefined;
+    step(dt: Fixed): void;
+    private integrate;
+    private broadphase;
+    private shouldCollide;
+    private narrowphase;
+    private testCollision;
+    private resolveCollisions;
+    getState(): SimulationState;
+    setState(state: SimulationState): void;
+    calculateHash(): number;
+    getFrame(): number;
+    setFrame(frame: number): void;
+    applyForce(bodyId: string, force: FixedVec2): void;
+    applyImpulse(bodyId: string, impulse: FixedVec2): void;
+    setVelocity(bodyId: string, velocity: FixedVec2): void;
+    setPosition(bodyId: string, position: FixedVec2): void;
+    setOnCollision(callback: (pair: CollisionPair) => void): void;
+    setOnTrigger(callback: (bodyA: string, bodyB: string) => void): void;
+    clear(): void;
+}
+export declare function createDeterministicWorld(config?: Partial<DeterministicConfig>): DeterministicWorld;
+export declare function createCircleBody(id: string, position: FixedVec2, radius: Fixed, options?: Partial<DeterministicBody>): DeterministicBody;
+export declare function createBoxBody(id: string, position: FixedVec2, halfWidth: Fixed, halfHeight: Fixed, options?: Partial<DeterministicBody>): DeterministicBody;
+export declare function createStaticBody(id: string, position: FixedVec2, halfWidth: Fixed, halfHeight: Fixed): DeterministicBody;

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

@@ -0,0 +1,209 @@
+/**
+ * @file ECSOptimization.ts
+ * @description Optimized ECS with SIMD-like operations and job scheduling
+ * PRO-1.5: Runtime & Performance
+ *
+ * Features:
+ * - SIMD-like batch operations on typed arrays
+ * - Job scheduler for parallel system execution
+ * - Component pools with cache-friendly layout
+ * - Query caching and invalidation
+ * - Archetype-based storage
+ * - System dependency graph
+ * - Batch entity operations
+ * - Memory-aligned components
+ */
+export type ComponentId = number;
+export type EntityId = number;
+export type ArchetypeId = string;
+export interface ComponentSchema {
+    id: ComponentId;
+    name: string;
+    size: number;
+    alignment: number;
+    fields: ComponentField[];
+}
+export interface ComponentField {
+    name: string;
+    type: 'f32' | 'f64' | 'i32' | 'u32' | 'i16' | 'u16' | 'i8' | 'u8' | 'bool';
+    offset: number;
+    count: number;
+}
+export interface ArchetypeLayout {
+    id: ArchetypeId;
+    componentMask: bigint;
+    componentIds: ComponentId[];
+    entityCount: number;
+    capacity: number;
+    storage: Map<ComponentId, ArrayBuffer>;
+    entities: EntityId[];
+}
+export interface SystemJob {
+    id: string;
+    name: string;
+    fn: (world: OptimizedWorld, deltaTime: number) => void;
+    dependencies: string[];
+    readComponents: ComponentId[];
+    writeComponents: ComponentId[];
+    priority: number;
+    enabled: boolean;
+}
+export interface JobHandle {
+    id: string;
+    status: 'pending' | 'running' | 'complete' | 'failed';
+    startTime?: number;
+    endTime?: number;
+    error?: Error;
+}
+export interface QueryDescriptor {
+    id: string;
+    include: ComponentId[];
+    exclude: ComponentId[];
+    cached: boolean;
+}
+export interface QueryResult {
+    archetypes: ArchetypeLayout[];
+    entityCount: number;
+    lastUpdated: number;
+}
+export interface BatchOperation {
+    type: 'create' | 'destroy' | 'addComponent' | 'removeComponent';
+    entities?: EntityId[];
+    count?: number;
+    componentId?: ComponentId;
+    data?: ArrayBuffer;
+}
+export interface PerformanceStats {
+    frameTime: number;
+    systemTimes: Map<string, number>;
+    entityCount: number;
+    componentCount: number;
+    archetypeCount: number;
+    queryCount: number;
+    cacheHits: number;
+    cacheMisses: number;
+    memoryUsed: number;
+}
+export declare class ComponentRegistry {
+    private schemas;
+    private nameToId;
+    private nextId;
+    register(name: string, fields: Omit<ComponentField, 'offset'>[]): ComponentId;
+    getSchema(id: ComponentId): ComponentSchema | undefined;
+    getIdByName(name: string): ComponentId | undefined;
+    private getFieldSize;
+    private getFieldAlignment;
+}
+export declare class ArchetypeManager {
+    private archetypes;
+    private componentRegistry;
+    constructor(componentRegistry: ComponentRegistry);
+    getOrCreateArchetype(componentIds: ComponentId[]): ArchetypeLayout;
+    ensureCapacity(archetype: ArchetypeLayout, needed: number): void;
+    getArchetypes(): ArchetypeLayout[];
+    findArchetypesWithComponents(componentIds: ComponentId[]): ArchetypeLayout[];
+    findArchetypesWithoutComponents(componentIds: ComponentId[]): ArchetypeLayout[];
+}
+export declare class QueryCache {
+    private cache;
+    private descriptors;
+    private invalidated;
+    private hits;
+    private misses;
+    register(descriptor: QueryDescriptor): void;
+    get(id: string): QueryResult | undefined;
+    set(id: string, result: QueryResult): void;
+    invalidate(componentId: ComponentId): void;
+    invalidateAll(): void;
+    getStats(): {
+        hits: number;
+        misses: number;
+    };
+}
+export declare class JobScheduler {
+    private jobs;
+    private executionOrder;
+    private handles;
+    private dirty;
+    register(job: SystemJob): void;
+    unregister(jobId: string): void;
+    setEnabled(jobId: string, enabled: boolean): void;
+    private buildExecutionOrder;
+    execute(world: OptimizedWorld, deltaTime: number): Map<string, JobHandle>;
+    getExecutionOrder(): string[];
+    getLastHandles(): Map<string, JobHandle>;
+    canParallelize(jobA: string, jobB: string): boolean;
+}
+export declare class SIMDOperations {
+    /**
+     * Add two float32 arrays element-wise
+     */
+    static addF32(a: Float32Array, b: Float32Array, out: Float32Array): void;
+    /**
+     * Multiply float32 array by scalar
+     */
+    static mulScalarF32(a: Float32Array, scalar: number, out: Float32Array): void;
+    /**
+     * Fused multiply-add: out = a * b + c
+     */
+    static fmaF32(a: Float32Array, b: Float32Array, c: Float32Array, out: Float32Array): void;
+    /**
+     * Linear interpolation
+     */
+    static lerpF32(a: Float32Array, b: Float32Array, t: number, out: Float32Array): void;
+    /**
+     * Dot product of 3D vectors stored in SOA format
+     */
+    static dot3DSOA(ax: Float32Array, ay: Float32Array, az: Float32Array, bx: Float32Array, by: Float32Array, bz: Float32Array, out: Float32Array): void;
+    /**
+     * Normalize 3D vectors stored in SOA format
+     */
+    static normalize3DSOA(x: Float32Array, y: Float32Array, z: Float32Array, outX: Float32Array, outY: Float32Array, outZ: Float32Array): void;
+    /**
+     * Cross product of 3D vectors stored in SOA format
+     */
+    static cross3DSOA(ax: Float32Array, ay: Float32Array, az: Float32Array, bx: Float32Array, by: Float32Array, bz: Float32Array, outX: Float32Array, outY: Float32Array, outZ: Float32Array): void;
+    /**
+     * Transform 3D positions by 4x4 matrix (assumes w=1)
+     */
+    static transformPositions(x: Float32Array, y: Float32Array, z: Float32Array, matrix: Float32Array, // 16 elements, column-major
+    outX: Float32Array, outY: Float32Array, outZ: Float32Array): void;
+}
+export declare class OptimizedWorld {
+    private componentRegistry;
+    private archetypeManager;
+    private queryCache;
+    private jobScheduler;
+    private entityToArchetype;
+    private freeEntityIds;
+    private nextEntityId;
+    private stats;
+    constructor();
+    registerComponent(name: string, fields: Omit<ComponentField, 'offset'>[]): ComponentId;
+    getComponentId(name: string): ComponentId | undefined;
+    getComponentSchema(id: ComponentId): ComponentSchema | undefined;
+    createEntity(componentIds: ComponentId[]): EntityId;
+    createEntities(componentIds: ComponentId[], count: number): EntityId[];
+    destroyEntity(id: EntityId): boolean;
+    hasEntity(id: EntityId): boolean;
+    getComponentBuffer(entityId: EntityId, componentId: ComponentId): ArrayBuffer | null;
+    setComponentData(entityId: EntityId, componentId: ComponentId, data: ArrayBuffer): boolean;
+    registerQuery(descriptor: QueryDescriptor): void;
+    query(descriptor: QueryDescriptor): QueryResult;
+    executeBatch(operations: BatchOperation[]): void;
+    registerSystem(job: SystemJob): void;
+    unregisterSystem(jobId: string): void;
+    setSystemEnabled(jobId: string, enabled: boolean): void;
+    update(deltaTime: number): void;
+    getStats(): PerformanceStats;
+    getComponentRegistry(): ComponentRegistry;
+    getArchetypeManager(): ArchetypeManager;
+    getJobScheduler(): JobScheduler;
+    /**
+     * Get typed array view for a component field across all entities in query
+     */
+    getComponentFieldArray<T extends Float32Array | Int32Array | Uint32Array | Uint8Array>(queryResult: QueryResult, componentId: ComponentId, fieldName: string, arrayType: new (buffer: ArrayBuffer, offset: number, length: number) => T): T | null;
+}
+export declare function createOptimizedWorld(): OptimizedWorld;
+export declare function createSystemJob(id: string, name: string, fn: (world: OptimizedWorld, deltaTime: number) => void, options?: Partial<Omit<SystemJob, 'id' | 'name' | 'fn'>>): SystemJob;
+export declare function createQueryDescriptor(id: string, include: ComponentId[], exclude?: ComponentId[], cached?: boolean): QueryDescriptor;