@nice2dev/game-engine 1.3.14 → 1.3.16

package/dist/cjs/performance/MultiThreadedPhysics.js

@@ -1,494 +1,451 @@
-'use strict';
-
-/**
- * @file MultiThreadedPhysics.ts
- * @description Physics simulation with Web Worker threading
- * PRO-1.5: Runtime & Performance
- *
- * Features:
- * - Physics on dedicated worker thread
- * - Double-buffered state synchronization
- * - Task parallelization
- * - Thread pool management
- * - Message batching
- * - Shared memory (SharedArrayBuffer) support
- */
-// ============================================================
-// Default Configuration
-// ============================================================
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const DEFAULT_PHYSICS_CONFIG = {
-    useSharedMemory: false,
-    maxBodies: 1000,
-    substeps: 4,
-    fixedTimestep: 1 / 60,
-    gravity: { x: 0, y: -9.81, z: 0 },
+  useSharedMemory: false,
+  maxBodies: 1e3,
+  substeps: 4,
+  fixedTimestep: 1 / 60,
+  gravity: { x: 0, y: -9.81, z: 0 }
 };
-// ============================================================
-// Shared Memory Layout
-// ============================================================
-const BODY_STRIDE = 64; // bytes per body
+const BODY_STRIDE = 64;
 const POSITION_OFFSET = 0;
 const ROTATION_OFFSET = 12;
 const VELOCITY_OFFSET = 28;
 const ANGULAR_VEL_OFFSET = 40;
 const MASS_OFFSET = 52;
-// ============================================================
-// Thread Pool
-// ============================================================
 class PhysicsThreadPool {
-    constructor(workerUrl, numWorkers) {
-        this.workers = [];
-        this.taskQueue = [];
-        this.availableWorkers = [];
-        this.workerTasks = new Map();
-        this.nextTaskId = 0;
-        this.pendingTasks = new Map();
-        for (let i = 0; i < numWorkers; i++) {
-            const worker = new Worker(workerUrl, { type: 'module' });
-            worker.onmessage = (e) => this.handleMessage(worker, e.data);
-            worker.onerror = (e) => this.handleError(worker, e);
-            this.workers.push(worker);
-            this.availableWorkers.push(worker);
-        }
+  constructor(workerUrl, numWorkers) {
+    this.workers = [];
+    this.taskQueue = [];
+    this.availableWorkers = [];
+    this.workerTasks = /* @__PURE__ */ new Map();
+    this.nextTaskId = 0;
+    this.pendingTasks = /* @__PURE__ */ new Map();
+    for (let i = 0; i < numWorkers; i++) {
+      const worker = new Worker(workerUrl, { type: "module" });
+      worker.onmessage = (e) => this.handleMessage(worker, e.data);
+      worker.onerror = (e) => this.handleError(worker, e);
+      this.workers.push(worker);
+      this.availableWorkers.push(worker);
     }
-    async execute(task) {
-        return new Promise((resolve, reject) => {
-            this.taskQueue.push({
-                task,
-                resolve: resolve,
-                reject,
-            });
-            this.processQueue();
-        });
+  }
+  async execute(task) {
+    return new Promise((resolve, reject) => {
+      this.taskQueue.push({
+        task,
+        resolve,
+        reject
+      });
+      this.processQueue();
+    });
+  }
+  processQueue() {
+    while (this.taskQueue.length > 0 && this.availableWorkers.length > 0) {
+      const worker = this.availableWorkers.pop();
+      const { task, resolve, reject } = this.taskQueue.shift();
+      const taskId = this.nextTaskId++;
+      this.workerTasks.set(worker, taskId);
+      this.pendingTasks.set(taskId, { resolve, reject });
+      worker.postMessage({ type: "task", id: taskId, data: task });
     }
-    processQueue() {
-        while (this.taskQueue.length > 0 && this.availableWorkers.length > 0) {
-            const worker = this.availableWorkers.pop();
-            const { task, resolve, reject } = this.taskQueue.shift();
-            const taskId = this.nextTaskId++;
-            this.workerTasks.set(worker, taskId);
-            this.pendingTasks.set(taskId, { resolve, reject });
-            worker.postMessage({ type: 'task', id: taskId, data: task });
-        }
+  }
+  handleMessage(worker, message) {
+    const taskId = this.workerTasks.get(worker);
+    if (taskId !== void 0) {
+      const pending = this.pendingTasks.get(taskId);
+      if (pending) {
+        pending.resolve(message.data);
+        this.pendingTasks.delete(taskId);
+      }
+      this.workerTasks.delete(worker);
+      this.availableWorkers.push(worker);
+      this.processQueue();
     }
-    handleMessage(worker, message) {
-        const taskId = this.workerTasks.get(worker);
-        if (taskId !== undefined) {
-            const pending = this.pendingTasks.get(taskId);
-            if (pending) {
-                pending.resolve(message.data);
-                this.pendingTasks.delete(taskId);
-            }
-            this.workerTasks.delete(worker);
-            this.availableWorkers.push(worker);
-            this.processQueue();
-        }
+  }
+  handleError(worker, error) {
+    const taskId = this.workerTasks.get(worker);
+    if (taskId !== void 0) {
+      const pending = this.pendingTasks.get(taskId);
+      if (pending) {
+        pending.reject(new Error(error.message));
+        this.pendingTasks.delete(taskId);
+      }
+      this.workerTasks.delete(worker);
     }
-    handleError(worker, error) {
-        const taskId = this.workerTasks.get(worker);
-        if (taskId !== undefined) {
-            const pending = this.pendingTasks.get(taskId);
-            if (pending) {
-                pending.reject(new Error(error.message));
-                this.pendingTasks.delete(taskId);
-            }
-            this.workerTasks.delete(worker);
-        }
-        // Replace failed worker
-        const index = this.workers.indexOf(worker);
-        if (index !== -1) {
-            worker.terminate();
-            const newWorker = new Worker('physics-worker.js', { type: 'module' });
-            newWorker.onmessage = (e) => this.handleMessage(newWorker, e.data);
-            newWorker.onerror = (e) => this.handleError(newWorker, e);
-            this.workers[index] = newWorker;
-            this.availableWorkers.push(newWorker);
-            this.processQueue();
-        }
+    const index = this.workers.indexOf(worker);
+    if (index !== -1) {
+      worker.terminate();
+      const newWorker = new Worker("physics-worker.js", { type: "module" });
+      newWorker.onmessage = (e) => this.handleMessage(newWorker, e.data);
+      newWorker.onerror = (e) => this.handleError(newWorker, e);
+      this.workers[index] = newWorker;
+      this.availableWorkers.push(newWorker);
+      this.processQueue();
     }
-    terminate() {
-        for (const worker of this.workers) {
-            worker.terminate();
-        }
-        this.workers = [];
-        this.availableWorkers = [];
-        this.taskQueue = [];
-        this.pendingTasks.clear();
+  }
+  terminate() {
+    for (const worker of this.workers) {
+      worker.terminate();
     }
+    this.workers = [];
+    this.availableWorkers = [];
+    this.taskQueue = [];
+    this.pendingTasks.clear();
+  }
 }
-// ============================================================
-// Shared Memory Buffer
-// ============================================================
 class SharedPhysicsBuffer {
-    constructor(maxBodies) {
-        this.maxBodies = maxBodies;
-        const size = maxBodies * BODY_STRIDE + 64; // Extra for locks
-        this.buffer = new SharedArrayBuffer(size);
-        this.bodyData = new Float32Array(this.buffer, 0, maxBodies * (BODY_STRIDE / 4));
-        this.flags = new Uint32Array(this.buffer, maxBodies * (BODY_STRIDE - 4), maxBodies);
-        this.lockArray = new Int32Array(this.buffer, maxBodies * BODY_STRIDE, 16);
+  constructor(maxBodies) {
+    this.maxBodies = maxBodies;
+    const size = maxBodies * BODY_STRIDE + 64;
+    this.buffer = new SharedArrayBuffer(size);
+    this.bodyData = new Float32Array(this.buffer, 0, maxBodies * (BODY_STRIDE / 4));
+    this.flags = new Uint32Array(this.buffer, maxBodies * (BODY_STRIDE - 4), maxBodies);
+    this.lockArray = new Int32Array(this.buffer, maxBodies * BODY_STRIDE, 16);
+  }
+  getBuffer() {
+    return this.buffer;
+  }
+  writeBody(index, body) {
+    if (index < 0 || index >= this.maxBodies) {
+      return;
     }
-    getBuffer() {
-        return this.buffer;
-    }
-    writeBody(index, body) {
-        if (index < 0 || index >= this.maxBodies) {
-            return;
-        }
-        const baseOffset = index * (BODY_STRIDE / 4);
-        // Position
-        this.bodyData[baseOffset + POSITION_OFFSET / 4] = body.position.x;
-        this.bodyData[baseOffset + POSITION_OFFSET / 4 + 1] = body.position.y;
-        this.bodyData[baseOffset + POSITION_OFFSET / 4 + 2] = body.position.z;
-        // Rotation
-        this.bodyData[baseOffset + ROTATION_OFFSET / 4] = body.rotation.x;
-        this.bodyData[baseOffset + ROTATION_OFFSET / 4 + 1] = body.rotation.y;
-        this.bodyData[baseOffset + ROTATION_OFFSET / 4 + 2] = body.rotation.z;
-        this.bodyData[baseOffset + ROTATION_OFFSET / 4 + 3] = body.rotation.w;
-        // Velocity
-        this.bodyData[baseOffset + VELOCITY_OFFSET / 4] = body.velocity.x;
-        this.bodyData[baseOffset + VELOCITY_OFFSET / 4 + 1] = body.velocity.y;
-        this.bodyData[baseOffset + VELOCITY_OFFSET / 4 + 2] = body.velocity.z;
-        // Angular velocity
-        this.bodyData[baseOffset + ANGULAR_VEL_OFFSET / 4] = body.angularVelocity.x;
-        this.bodyData[baseOffset + ANGULAR_VEL_OFFSET / 4 + 1] = body.angularVelocity.y;
-        this.bodyData[baseOffset + ANGULAR_VEL_OFFSET / 4 + 2] = body.angularVelocity.z;
-        // Mass
-        this.bodyData[baseOffset + MASS_OFFSET / 4] = body.mass;
+    const baseOffset = index * (BODY_STRIDE / 4);
+    this.bodyData[baseOffset + POSITION_OFFSET / 4] = body.position.x;
+    this.bodyData[baseOffset + POSITION_OFFSET / 4 + 1] = body.position.y;
+    this.bodyData[baseOffset + POSITION_OFFSET / 4 + 2] = body.position.z;
+    this.bodyData[baseOffset + ROTATION_OFFSET / 4] = body.rotation.x;
+    this.bodyData[baseOffset + ROTATION_OFFSET / 4 + 1] = body.rotation.y;
+    this.bodyData[baseOffset + ROTATION_OFFSET / 4 + 2] = body.rotation.z;
+    this.bodyData[baseOffset + ROTATION_OFFSET / 4 + 3] = body.rotation.w;
+    this.bodyData[baseOffset + VELOCITY_OFFSET / 4] = body.velocity.x;
+    this.bodyData[baseOffset + VELOCITY_OFFSET / 4 + 1] = body.velocity.y;
+    this.bodyData[baseOffset + VELOCITY_OFFSET / 4 + 2] = body.velocity.z;
+    this.bodyData[baseOffset + ANGULAR_VEL_OFFSET / 4] = body.angularVelocity.x;
+    this.bodyData[baseOffset + ANGULAR_VEL_OFFSET / 4 + 1] = body.angularVelocity.y;
+    this.bodyData[baseOffset + ANGULAR_VEL_OFFSET / 4 + 2] = body.angularVelocity.z;
+    this.bodyData[baseOffset + MASS_OFFSET / 4] = body.mass;
+  }
+  readBody(index) {
+    if (index < 0 || index >= this.maxBodies) {
+      return {};
     }
-    readBody(index) {
-        if (index < 0 || index >= this.maxBodies) {
-            return {};
-        }
-        const baseOffset = index * (BODY_STRIDE / 4);
-        return {
-            position: {
-                x: this.bodyData[baseOffset + POSITION_OFFSET / 4],
-                y: this.bodyData[baseOffset + POSITION_OFFSET / 4 + 1],
-                z: this.bodyData[baseOffset + POSITION_OFFSET / 4 + 2],
-            },
-            rotation: {
-                x: this.bodyData[baseOffset + ROTATION_OFFSET / 4],
-                y: this.bodyData[baseOffset + ROTATION_OFFSET / 4 + 1],
-                z: this.bodyData[baseOffset + ROTATION_OFFSET / 4 + 2],
-                w: this.bodyData[baseOffset + ROTATION_OFFSET / 4 + 3],
-            },
-            velocity: {
-                x: this.bodyData[baseOffset + VELOCITY_OFFSET / 4],
-                y: this.bodyData[baseOffset + VELOCITY_OFFSET / 4 + 1],
-                z: this.bodyData[baseOffset + VELOCITY_OFFSET / 4 + 2],
-            },
-            angularVelocity: {
-                x: this.bodyData[baseOffset + ANGULAR_VEL_OFFSET / 4],
-                y: this.bodyData[baseOffset + ANGULAR_VEL_OFFSET / 4 + 1],
-                z: this.bodyData[baseOffset + ANGULAR_VEL_OFFSET / 4 + 2],
-            },
-            mass: this.bodyData[baseOffset + MASS_OFFSET / 4],
-        };
-    }
-    lock(lockIndex) {
-        while (Atomics.compareExchange(this.lockArray, lockIndex, 0, 1) !== 0) {
-            Atomics.wait(this.lockArray, lockIndex, 1);
-        }
-    }
-    unlock(lockIndex) {
-        Atomics.store(this.lockArray, lockIndex, 0);
-        Atomics.notify(this.lockArray, lockIndex);
+    const baseOffset = index * (BODY_STRIDE / 4);
+    return {
+      position: {
+        x: this.bodyData[baseOffset + POSITION_OFFSET / 4],
+        y: this.bodyData[baseOffset + POSITION_OFFSET / 4 + 1],
+        z: this.bodyData[baseOffset + POSITION_OFFSET / 4 + 2]
+      },
+      rotation: {
+        x: this.bodyData[baseOffset + ROTATION_OFFSET / 4],
+        y: this.bodyData[baseOffset + ROTATION_OFFSET / 4 + 1],
+        z: this.bodyData[baseOffset + ROTATION_OFFSET / 4 + 2],
+        w: this.bodyData[baseOffset + ROTATION_OFFSET / 4 + 3]
+      },
+      velocity: {
+        x: this.bodyData[baseOffset + VELOCITY_OFFSET / 4],
+        y: this.bodyData[baseOffset + VELOCITY_OFFSET / 4 + 1],
+        z: this.bodyData[baseOffset + VELOCITY_OFFSET / 4 + 2]
+      },
+      angularVelocity: {
+        x: this.bodyData[baseOffset + ANGULAR_VEL_OFFSET / 4],
+        y: this.bodyData[baseOffset + ANGULAR_VEL_OFFSET / 4 + 1],
+        z: this.bodyData[baseOffset + ANGULAR_VEL_OFFSET / 4 + 2]
+      },
+      mass: this.bodyData[baseOffset + MASS_OFFSET / 4]
+    };
+  }
+  lock(lockIndex) {
+    while (Atomics.compareExchange(this.lockArray, lockIndex, 0, 1) !== 0) {
+      Atomics.wait(this.lockArray, lockIndex, 1);
     }
+  }
+  unlock(lockIndex) {
+    Atomics.store(this.lockArray, lockIndex, 0);
+    Atomics.notify(this.lockArray, lockIndex);
+  }
 }
-// ============================================================
-// Physics Worker Manager
-// ============================================================
 class MultiThreadedPhysics {
-    constructor(config) {
-        this.worker = null;
-        this.sharedBuffer = null;
-        this.bodies = new Map();
-        this.bodyIndices = new Map();
-        this.nextBodyIndex = 0;
-        this.messageId = 0;
-        this.pendingMessages = new Map();
-        this.accumulator = 0;
-        this.isRunning = false;
-        this.config = { ...DEFAULT_PHYSICS_CONFIG, ...config };
-    }
-    // ─── Initialization ────────────────────────────────────
-    async initialize(workerUrl) {
-        // Create worker
-        const url = workerUrl || this.config.workerUrl || this.createWorkerBlob();
-        this.worker = new Worker(url, { type: 'module' });
-        this.worker.onmessage = (e) => this.handleMessage(e.data);
-        this.worker.onerror = (e) => this.handleError(e);
-        // Create shared buffer if supported
-        if (this.config.useSharedMemory && typeof SharedArrayBuffer !== 'undefined') {
-            this.sharedBuffer = new SharedPhysicsBuffer(this.config.maxBodies);
-        }
-        // Initialize worker
-        await this.sendMessage('init', {
-            config: this.config,
-            sharedBuffer: this.sharedBuffer?.getBuffer(),
-        });
-        this.isRunning = true;
+  constructor(config) {
+    this.worker = null;
+    this.sharedBuffer = null;
+    this.bodies = /* @__PURE__ */ new Map();
+    this.bodyIndices = /* @__PURE__ */ new Map();
+    this.nextBodyIndex = 0;
+    this.messageId = 0;
+    this.pendingMessages = /* @__PURE__ */ new Map();
+    this.accumulator = 0;
+    this.isRunning = false;
+    this.config = { ...DEFAULT_PHYSICS_CONFIG, ...config };
+  }
+  // ─── Initialization ────────────────────────────────────
+  async initialize(workerUrl) {
+    const url = workerUrl || this.config.workerUrl || this.createWorkerBlob();
+    this.worker = new Worker(url, { type: "module" });
+    this.worker.onmessage = (e) => this.handleMessage(e.data);
+    this.worker.onerror = (e) => this.handleError(e);
+    if (this.config.useSharedMemory && typeof SharedArrayBuffer !== "undefined") {
+      this.sharedBuffer = new SharedPhysicsBuffer(this.config.maxBodies);
     }
-    createWorkerBlob() {
-        const workerCode = `
-      let world = { bodies: new Map(), gravity: { x: 0, y: -9.81, z: 0 } };
-      let config = null;
-      let sharedBuffer = null;
-      
-      self.onmessage = function(e) {
-        const { type, id, data } = e.data;
-        
-        switch (type) {
-          case 'init':
-            config = data.config;
-            world.gravity = config.gravity;
-            if (data.sharedBuffer) {
-              sharedBuffer = new Float32Array(data.sharedBuffer);
-            }
-            self.postMessage({ type: 'init', id, data: { success: true } });
-            break;
-            
-          case 'step':
-            simulateStep(data.dt);
-            syncState();
-            break;
-            
-          case 'add-body':
-            world.bodies.set(data.id, data.body);
-            self.postMessage({ type: 'add-body', id, data: { success: true } });
-            break;
-            
-          case 'remove-body':
-            world.bodies.delete(data.id);
-            self.postMessage({ type: 'remove-body', id, data: { success: true } });
-            break;
-            
-          case 'raycast':
-            const result = performRaycast(data.origin, data.direction, data.maxDistance);
-            self.postMessage({ type: 'raycast-result', id, data: result });
-            break;
-        }
-      };
-      
-      function simulateStep(dt) {
-        const substepDt = dt / config.substeps;
-        for (let i = 0; i < config.substeps; i++) {
-          integrate(substepDt);
-          detectCollisions();
-          resolveCollisions();
-        }
-      }
-      
-      function integrate(dt) {
-        for (const body of world.bodies.values()) {
-          if (body.isStatic) continue;
-          body.velocity.x += world.gravity.x * dt;
-          body.velocity.y += world.gravity.y * dt;
-          body.velocity.z += world.gravity.z * dt;
-          body.position.x += body.velocity.x * dt;
-          body.position.y += body.velocity.y * dt;
-          body.position.z += body.velocity.z * dt;
-        }
-      }
-      
-      function detectCollisions() {
-        // Simplified collision detection
-      }
-      
-      function resolveCollisions() {
-        // Simplified collision resolution
-      }
-      
-      function syncState() {
-        const stateData = {};
-        for (const [id, body] of world.bodies) {
-          stateData[id] = {
-            position: { ...body.position },
-            rotation: { ...body.rotation },
-            velocity: { ...body.velocity },
-            angularVelocity: { ...body.angularVelocity },
-          };
-        }
-        self.postMessage({ type: 'state-update', data: stateData });
-      }
-      
-      function performRaycast(origin, direction, maxDistance) {
-        // Simplified raycast
-        return { hit: false };
-      }
-    `;
-        const blob = new Blob([workerCode], { type: 'application/javascript' });
-        return URL.createObjectURL(blob);
-    }
-    // ─── Body Management ───────────────────────────────────
-    async addBody(body) {
-        const index = this.nextBodyIndex++;
-        this.bodies.set(body.id, { index, body: { ...body } });
-        this.bodyIndices.set(index, body.id);
-        if (this.sharedBuffer) {
-            this.sharedBuffer.writeBody(index, body);
-        }
-        await this.sendMessage('add-body', { id: body.id, body, index });
-    }
-    async removeBody(id) {
-        const entry = this.bodies.get(id);
-        if (entry) {
-            this.bodies.delete(id);
-            this.bodyIndices.delete(entry.index);
-            await this.sendMessage('remove-body', { id });
-        }
-    }
-    async updateBody(id, updates) {
-        const entry = this.bodies.get(id);
-        if (entry) {
-            Object.assign(entry.body, updates);
-            if (this.sharedBuffer) {
-                this.sharedBuffer.writeBody(entry.index, entry.body);
+    await this.sendMessage("init", {
+      config: this.config,
+      sharedBuffer: this.sharedBuffer?.getBuffer()
+    });
+    this.isRunning = true;
+  }
+  createWorkerBlob() {
+    const workerCode = `
+      let world = { bodies: new Map(), gravity: { x: 0, y: -9.81, z: 0 } };
+      let config = null;
+      let sharedBuffer = null;
+      
+      self.onmessage = function(e) {
+        const { type, id, data } = e.data;
+        
+        switch (type) {
+          case 'init':
+            config = data.config;
+            world.gravity = config.gravity;
+            if (data.sharedBuffer) {
+              sharedBuffer = new Float32Array(data.sharedBuffer);
             }
-            await this.sendMessage('update-body', { id, updates });
+            self.postMessage({ type: 'init', id, data: { success: true } });
+            break;
+            
+          case 'step':
+            simulateStep(data.dt);
+            syncState();
+            break;
+            
+          case 'add-body':
+            world.bodies.set(data.id, data.body);
+            self.postMessage({ type: 'add-body', id, data: { success: true } });
+            break;
+            
+          case 'remove-body':
+            world.bodies.delete(data.id);
+            self.postMessage({ type: 'remove-body', id, data: { success: true } });
+            break;
+            
+          case 'raycast':
+            const result = performRaycast(data.origin, data.direction, data.maxDistance);
+            self.postMessage({ type: 'raycast-result', id, data: result });
+            break;
         }
-    }
-    getBody(id) {
-        return this.bodies.get(id)?.body;
-    }
-    // ─── Simulation ────────────────────────────────────────
-    step(dt) {
-        if (!this.isRunning || !this.worker) {
-            return;
+      };
+      
+      function simulateStep(dt) {
+        const substepDt = dt / config.substeps;
+        for (let i = 0; i < config.substeps; i++) {
+          integrate(substepDt);
+          detectCollisions();
+          resolveCollisions();
         }
-        this.accumulator += dt;
-        while (this.accumulator >= this.config.fixedTimestep) {
-            this.worker.postMessage({
-                type: 'step',
-                data: { dt: this.config.fixedTimestep },
-            });
-            this.accumulator -= this.config.fixedTimestep;
+      }
+      
+      function integrate(dt) {
+        for (const body of world.bodies.values()) {
+          if (body.isStatic) continue;
+          body.velocity.x += world.gravity.x * dt;
+          body.velocity.y += world.gravity.y * dt;
+          body.velocity.z += world.gravity.z * dt;
+          body.position.x += body.velocity.x * dt;
+          body.position.y += body.velocity.y * dt;
+          body.position.z += body.velocity.z * dt;
         }
+      }
+      
+      function detectCollisions() {
+        // Simplified collision detection
+      }
+      
+      function resolveCollisions() {
+        // Simplified collision resolution
+      }
+      
+      function syncState() {
+        const stateData = {};
+        for (const [id, body] of world.bodies) {
+          stateData[id] = {
+            position: { ...body.position },
+            rotation: { ...body.rotation },
+            velocity: { ...body.velocity },
+            angularVelocity: { ...body.angularVelocity },
+          };
+        }
+        self.postMessage({ type: 'state-update', data: stateData });
+      }
+      
+      function performRaycast(origin, direction, maxDistance) {
+        // Simplified raycast
+        return { hit: false };
+      }
+    `;
+    const blob = new Blob([workerCode], { type: "application/javascript" });
+    return URL.createObjectURL(blob);
+  }
+  // ─── Body Management ───────────────────────────────────
+  async addBody(body) {
+    const index = this.nextBodyIndex++;
+    this.bodies.set(body.id, { index, body: { ...body } });
+    this.bodyIndices.set(index, body.id);
+    if (this.sharedBuffer) {
+      this.sharedBuffer.writeBody(index, body);
     }
-    // ─── Force Application ─────────────────────────────────
-    async applyForce(bodyId, force) {
-        await this.sendMessage('apply-force', { bodyId, force });
+    await this.sendMessage("add-body", { id: body.id, body, index });
+  }
+  async removeBody(id) {
+    const entry = this.bodies.get(id);
+    if (entry) {
+      this.bodies.delete(id);
+      this.bodyIndices.delete(entry.index);
+      await this.sendMessage("remove-body", { id });
     }
-    async applyImpulse(bodyId, impulse, point) {
-        await this.sendMessage('apply-impulse', { bodyId, impulse, point });
+  }
+  async updateBody(id, updates) {
+    const entry = this.bodies.get(id);
+    if (entry) {
+      Object.assign(entry.body, updates);
+      if (this.sharedBuffer) {
+        this.sharedBuffer.writeBody(entry.index, entry.body);
+      }
+      await this.sendMessage("update-body", { id, updates });
     }
-    // ─── Queries ───────────────────────────────────────────
-    async raycast(origin, direction, maxDistance) {
-        return (await this.sendMessage('raycast', {
-            origin,
-            direction,
-            maxDistance,
-        }));
+  }
+  getBody(id) {
+    return this.bodies.get(id)?.body;
+  }
+  // ─── Simulation ────────────────────────────────────────
+  step(dt) {
+    if (!this.isRunning || !this.worker) {
+      return;
     }
-    // ─── Message Handling ──────────────────────────────────
-    sendMessage(type, data) {
-        return new Promise((resolve, reject) => {
-            const id = this.messageId++;
-            this.pendingMessages.set(id, { resolve, reject });
-            this.worker?.postMessage({ type, id, data });
-        });
+    this.accumulator += dt;
+    while (this.accumulator >= this.config.fixedTimestep) {
+      this.worker.postMessage({
+        type: "step",
+        data: { dt: this.config.fixedTimestep }
+      });
+      this.accumulator -= this.config.fixedTimestep;
     }
-    handleMessage(message) {
-        switch (message.type) {
-            case 'state-update':
-                this.handleStateUpdate(message.data);
-                break;
-            case 'collision-events':
-                this.handleCollisionEvents(message.data);
-                break;
-            default:
-                if (message.id !== undefined) {
-                    const pending = this.pendingMessages.get(message.id);
-                    if (pending) {
-                        pending.resolve(message.data);
-                        this.pendingMessages.delete(message.id);
-                    }
-                }
+  }
+  // ─── Force Application ─────────────────────────────────
+  async applyForce(bodyId, force) {
+    await this.sendMessage("apply-force", { bodyId, force });
+  }
+  async applyImpulse(bodyId, impulse, point) {
+    await this.sendMessage("apply-impulse", { bodyId, impulse, point });
+  }
+  // ─── Queries ───────────────────────────────────────────
+  async raycast(origin, direction, maxDistance) {
+    return await this.sendMessage("raycast", {
+      origin,
+      direction,
+      maxDistance
+    });
+  }
+  // ─── Message Handling ──────────────────────────────────
+  sendMessage(type, data) {
+    return new Promise((resolve, reject) => {
+      const id = this.messageId++;
+      this.pendingMessages.set(id, { resolve, reject });
+      this.worker?.postMessage({ type, id, data });
+    });
+  }
+  handleMessage(message) {
+    switch (message.type) {
+      case "state-update":
+        this.handleStateUpdate(message.data);
+        break;
+      case "collision-events":
+        this.handleCollisionEvents(message.data);
+        break;
+      default:
+        if (message.id !== void 0) {
+          const pending = this.pendingMessages.get(message.id);
+          if (pending) {
+            pending.resolve(message.data);
+            this.pendingMessages.delete(message.id);
+          }
         }
     }
-    handleStateUpdate(state) {
-        // Update local state from worker
-        for (const [id, updates] of Object.entries(state)) {
-            const entry = this.bodies.get(id);
-            if (entry) {
-                if (updates.position) {
-                    entry.body.position = { ...updates.position };
-                }
-                if (updates.rotation) {
-                    entry.body.rotation = { ...updates.rotation };
-                }
-                if (updates.velocity) {
-                    entry.body.velocity = { ...updates.velocity };
-                }
-                if (updates.angularVelocity) {
-                    entry.body.angularVelocity = { ...updates.angularVelocity };
-                }
-            }
+  }
+  handleStateUpdate(state) {
+    for (const [id, updates] of Object.entries(state)) {
+      const entry = this.bodies.get(id);
+      if (entry) {
+        if (updates.position) {
+          entry.body.position = { ...updates.position };
         }
-        // Callback
-        if (this.onStateUpdate) {
-            const bodiesMap = new Map();
-            for (const [id, entry] of this.bodies) {
-                bodiesMap.set(id, entry.body);
-            }
-            this.onStateUpdate(bodiesMap);
+        if (updates.rotation) {
+          entry.body.rotation = { ...updates.rotation };
         }
-    }
-    handleCollisionEvents(events) {
-        if (this.onCollision) {
-            for (const event of events) {
-                this.onCollision(event);
-            }
+        if (updates.velocity) {
+          entry.body.velocity = { ...updates.velocity };
         }
+        if (updates.angularVelocity) {
+          entry.body.angularVelocity = { ...updates.angularVelocity };
+        }
+      }
     }
-    handleError(error) {
-        console.error('Physics worker error:', error);
-    }
-    // ─── Callbacks ─────────────────────────────────────────
-    setOnCollision(callback) {
-        this.onCollision = callback;
-    }
-    setOnStateUpdate(callback) {
-        this.onStateUpdate = callback;
+    if (this.onStateUpdate) {
+      const bodiesMap = /* @__PURE__ */ new Map();
+      for (const [id, entry] of this.bodies) {
+        bodiesMap.set(id, entry.body);
+      }
+      this.onStateUpdate(bodiesMap);
     }
-    // ─── Cleanup ───────────────────────────────────────────
-    dispose() {
-        this.isRunning = false;
-        this.worker?.terminate();
-        this.worker = null;
-        this.bodies.clear();
-        this.bodyIndices.clear();
-        this.pendingMessages.clear();
-        this.sharedBuffer = null;
+  }
+  handleCollisionEvents(events) {
+    if (this.onCollision) {
+      for (const event of events) {
+        this.onCollision(event);
+      }
     }
+  }
+  handleError(error) {
+    console.error("Physics worker error:", error);
+  }
+  // ─── Callbacks ─────────────────────────────────────────
+  setOnCollision(callback) {
+    this.onCollision = callback;
+  }
+  setOnStateUpdate(callback) {
+    this.onStateUpdate = callback;
+  }
+  // ─── Cleanup ───────────────────────────────────────────
+  dispose() {
+    this.isRunning = false;
+    this.worker?.terminate();
+    this.worker = null;
+    this.bodies.clear();
+    this.bodyIndices.clear();
+    this.pendingMessages.clear();
+    this.sharedBuffer = null;
+  }
 }
-// ============================================================
-// Factory Functions
-// ============================================================
 function createMultiThreadedPhysics(config) {
-    return new MultiThreadedPhysics(config);
+  return new MultiThreadedPhysics(config);
 }
 function createPhysicsBody(id, options) {
-    return {
-        id,
-        position: options?.position ?? { x: 0, y: 0, z: 0 },
-        rotation: options?.rotation ?? { x: 0, y: 0, z: 0, w: 1 },
-        velocity: options?.velocity ?? { x: 0, y: 0, z: 0 },
-        angularVelocity: options?.angularVelocity ?? { x: 0, y: 0, z: 0 },
-        mass: options?.mass ?? 1,
-        isStatic: options?.isStatic ?? false,
-        shapeType: options?.shapeType ?? 'box',
-        shapeData: options?.shapeData ?? { halfExtents: { x: 0.5, y: 0.5, z: 0.5 } },
-    };
+  return {
+    id,
+    position: options?.position ?? { x: 0, y: 0, z: 0 },
+    rotation: options?.rotation ?? { x: 0, y: 0, z: 0, w: 1 },
+    velocity: options?.velocity ?? { x: 0, y: 0, z: 0 },
+    angularVelocity: options?.angularVelocity ?? { x: 0, y: 0, z: 0 },
+    mass: options?.mass ?? 1,
+    isStatic: options?.isStatic ?? false,
+    shapeType: options?.shapeType ?? "box",
+    shapeData: options?.shapeData ?? { halfExtents: { x: 0.5, y: 0.5, z: 0.5 } }
+  };
 }
 function createThreadPool(workerUrl, numWorkers = navigator.hardwareConcurrency || 4) {
-    return new PhysicsThreadPool(workerUrl, numWorkers);
+  return new PhysicsThreadPool(workerUrl, numWorkers);
 }
 function createSharedPhysicsBuffer(maxBodies) {
-    return new SharedPhysicsBuffer(maxBodies);
+  return new SharedPhysicsBuffer(maxBodies);
 }
-
 exports.DEFAULT_PHYSICS_CONFIG = DEFAULT_PHYSICS_CONFIG;
 exports.MultiThreadedPhysics = MultiThreadedPhysics;
 exports.PhysicsThreadPool = PhysicsThreadPool;