@spatial-engine/core 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Francisco Rueda Esquivel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-JF4RVZK3.js

@@ -0,0 +1,586 @@
+// src/octree-node.ts
+var NODE_AABB_OFFSET = 0;
+var NODE_FIRST_CHILD_OFFSET = 6;
+var NODE_PARENT_OFFSET = 7;
+var NODE_OBJECT_COUNT_OFFSET = 8;
+var NODE_OBJECTS_OFFSET = 9;
+var MAX_OBJECTS_PER_NODE = 8;
+var NODE_STRIDE = NODE_OBJECTS_OFFSET + MAX_OBJECTS_PER_NODE;
+var OctreeNodePool = class _OctreeNodePool {
+  buffer;
+  count = 0;
+  constructor(capacity, sharedBuffer) {
+    this.buffer = sharedBuffer ? new Float32Array(sharedBuffer, 0, capacity * NODE_STRIDE) : new Float32Array(capacity * NODE_STRIDE);
+  }
+  /**
+   * Create an OctreeNodePool backed by a new `SharedArrayBuffer`.
+   * Both the pool and the underlying `SharedArrayBuffer` are returned so the
+   * caller can transfer the buffer to a `Worker` via `postMessage`.
+   */
+  static createShared(capacity) {
+    const sab = new SharedArrayBuffer(capacity * NODE_STRIDE * Float32Array.BYTES_PER_ELEMENT);
+    return { pool: new _OctreeNodePool(capacity, sab), sab };
+  }
+  /** Allocate a new node slot, initialise sentinel values, and return its index. */
+  allocate() {
+    const index = this.count;
+    const offset = index * NODE_STRIDE;
+    this.buffer[offset + NODE_FIRST_CHILD_OFFSET] = -1;
+    this.buffer[offset + NODE_PARENT_OFFSET] = -1;
+    this.buffer[offset + NODE_OBJECT_COUNT_OFFSET] = 0;
+    this.count += 1;
+    return index;
+  }
+  /** Returns the number of allocated nodes. */
+  get size() {
+    return this.count;
+  }
+  /** Reset the pool (all allocations freed, no GC). */
+  reset() {
+    this.count = 0;
+  }
+  // ── AABB ──────────────────────────────────────────────────────────────────
+  /** Set the AABB bounds for the node at the given index. */
+  setAABB(index, minX, minY, minZ, maxX, maxY, maxZ) {
+    const off = index * NODE_STRIDE + NODE_AABB_OFFSET;
+    this.buffer[off] = minX;
+    this.buffer[off + 1] = minY;
+    this.buffer[off + 2] = minZ;
+    this.buffer[off + 3] = maxX;
+    this.buffer[off + 4] = maxY;
+    this.buffer[off + 5] = maxZ;
+  }
+  /** Read a single AABB component (0–5) from the node at the given index. */
+  getAABB(index, component) {
+    return this.buffer[index * NODE_STRIDE + NODE_AABB_OFFSET + component] ?? 0;
+  }
+  // ── First-child link ──────────────────────────────────────────────────────
+  /** Set the first-child index for the node (-1 = leaf). */
+  setFirstChild(index, childIndex) {
+    this.buffer[index * NODE_STRIDE + NODE_FIRST_CHILD_OFFSET] = childIndex;
+  }
+  /** Get the first-child index for the node (-1 = leaf). */
+  getFirstChild(index) {
+    return this.buffer[index * NODE_STRIDE + NODE_FIRST_CHILD_OFFSET] ?? -1;
+  }
+  // ── Parent link ───────────────────────────────────────────────────────────
+  /** Set the parent index for the node (-1 = root). */
+  setParent(index, parentIndex) {
+    this.buffer[index * NODE_STRIDE + NODE_PARENT_OFFSET] = parentIndex;
+  }
+  /** Get the parent index for the node (-1 = root). */
+  getParent(index) {
+    return this.buffer[index * NODE_STRIDE + NODE_PARENT_OFFSET] ?? -1;
+  }
+  // ── Object pointers ───────────────────────────────────────────────────────
+  /** Return the number of objects stored in the node at the given index. */
+  getObjectCount(index) {
+    return this.buffer[index * NODE_STRIDE + NODE_OBJECT_COUNT_OFFSET] ?? 0;
+  }
+  /**
+   * Append an object index to the node's object list.
+   * Throws a RangeError when MAX_OBJECTS_PER_NODE is exceeded.
+   */
+  addObject(index, objectIndex) {
+    const countOff = index * NODE_STRIDE + NODE_OBJECT_COUNT_OFFSET;
+    const count = this.buffer[countOff] ?? 0;
+    if (count >= MAX_OBJECTS_PER_NODE) {
+      throw new RangeError(
+        `OctreeNodePool.addObject: node ${index} already contains MAX_OBJECTS_PER_NODE (${MAX_OBJECTS_PER_NODE}) objects`
+      );
+    }
+    this.buffer[index * NODE_STRIDE + NODE_OBJECTS_OFFSET + count] = objectIndex;
+    this.buffer[countOff] = count + 1;
+  }
+  /** Return the object index stored at slot `slot` in the given node. */
+  getObject(index, slot) {
+    return this.buffer[index * NODE_STRIDE + NODE_OBJECTS_OFFSET + slot] ?? 0;
+  }
+  /** Reset the object count of the given node to zero (does not zero the slots). */
+  clearObjects(index) {
+    this.buffer[index * NODE_STRIDE + NODE_OBJECT_COUNT_OFFSET] = 0;
+  }
+  /**
+   * Remove a single object index from the node's object list.
+   * Uses swap-with-last to avoid shifting. Returns true if found and removed.
+   */
+  removeObject(index, objectIndex) {
+    const countOff = index * NODE_STRIDE + NODE_OBJECT_COUNT_OFFSET;
+    const count = this.buffer[countOff] ?? 0;
+    const baseOff = index * NODE_STRIDE + NODE_OBJECTS_OFFSET;
+    for (let i = 0; i < count; i++) {
+      if (this.buffer[baseOff + i] === objectIndex) {
+        this.buffer[baseOff + i] = this.buffer[baseOff + count - 1] ?? 0;
+        this.buffer[countOff] = count - 1;
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+// src/aabb.ts
+var AABB_STRIDE = 6;
+var AABBPool = class _AABBPool {
+  buffer;
+  count = 0;
+  constructor(capacity, sharedBuffer) {
+    this.buffer = sharedBuffer ? new Float32Array(sharedBuffer, 0, capacity * AABB_STRIDE) : new Float32Array(capacity * AABB_STRIDE);
+  }
+  /**
+   * Create an AABBPool backed by a new `SharedArrayBuffer`.
+   * Both the pool and the underlying `SharedArrayBuffer` are returned so the
+   * caller can transfer the buffer to a `Worker` via `postMessage`.
+   */
+  static createShared(capacity) {
+    const sab = new SharedArrayBuffer(capacity * AABB_STRIDE * Float32Array.BYTES_PER_ELEMENT);
+    return { pool: new _AABBPool(capacity, sab), sab };
+  }
+  /** Allocate a new AABB slot and return its index. */
+  allocate() {
+    const index = this.count;
+    this.count += 1;
+    return index;
+  }
+  /** Set the bounds of an AABB at the given index. */
+  set(index, minX, minY, minZ, maxX, maxY, maxZ) {
+    const offset = index * AABB_STRIDE;
+    this.buffer[offset] = minX;
+    this.buffer[offset + 1] = minY;
+    this.buffer[offset + 2] = minZ;
+    this.buffer[offset + 3] = maxX;
+    this.buffer[offset + 4] = maxY;
+    this.buffer[offset + 5] = maxZ;
+  }
+  /** Read a single component value from the buffer. */
+  get(index, component) {
+    return this.buffer[index * AABB_STRIDE + component] ?? 0;
+  }
+  /** Returns the number of allocated AABBs. */
+  get size() {
+    return this.count;
+  }
+  /** Reset the pool (all allocations freed, no GC). */
+  reset() {
+    this.count = 0;
+  }
+};
+function aabbExpand(pool, a, b) {
+  const buf = pool.buffer;
+  const aOff = a * AABB_STRIDE;
+  const bOff = b * AABB_STRIDE;
+  buf[aOff] = Math.min(buf[aOff] ?? 0, buf[bOff] ?? 0);
+  buf[aOff + 1] = Math.min(buf[aOff + 1] ?? 0, buf[bOff + 1] ?? 0);
+  buf[aOff + 2] = Math.min(buf[aOff + 2] ?? 0, buf[bOff + 2] ?? 0);
+  buf[aOff + 3] = Math.max(buf[aOff + 3] ?? 0, buf[bOff + 3] ?? 0);
+  buf[aOff + 4] = Math.max(buf[aOff + 4] ?? 0, buf[bOff + 4] ?? 0);
+  buf[aOff + 5] = Math.max(buf[aOff + 5] ?? 0, buf[bOff + 5] ?? 0);
+}
+function aabbMerge(pool, dest, a, b) {
+  const buf = pool.buffer;
+  const aOff = a * AABB_STRIDE;
+  const bOff = b * AABB_STRIDE;
+  const dOff = dest * AABB_STRIDE;
+  buf[dOff] = Math.min(buf[aOff] ?? 0, buf[bOff] ?? 0);
+  buf[dOff + 1] = Math.min(buf[aOff + 1] ?? 0, buf[bOff + 1] ?? 0);
+  buf[dOff + 2] = Math.min(buf[aOff + 2] ?? 0, buf[bOff + 2] ?? 0);
+  buf[dOff + 3] = Math.max(buf[aOff + 3] ?? 0, buf[bOff + 3] ?? 0);
+  buf[dOff + 4] = Math.max(buf[aOff + 4] ?? 0, buf[bOff + 4] ?? 0);
+  buf[dOff + 5] = Math.max(buf[aOff + 5] ?? 0, buf[bOff + 5] ?? 0);
+}
+function aabbIntersects(pool, a, b) {
+  const aOff = a * AABB_STRIDE;
+  const bOff = b * AABB_STRIDE;
+  const buf = pool.buffer;
+  return (buf[aOff] ?? 0) <= (buf[bOff + 3] ?? 0) && (buf[aOff + 3] ?? 0) >= (buf[bOff] ?? 0) && (buf[aOff + 1] ?? 0) <= (buf[bOff + 4] ?? 0) && (buf[aOff + 4] ?? 0) >= (buf[bOff + 1] ?? 0) && (buf[aOff + 2] ?? 0) <= (buf[bOff + 5] ?? 0) && (buf[aOff + 5] ?? 0) >= (buf[bOff + 2] ?? 0);
+}
+
+// src/ray.ts
+var RAY_STRIDE = 6;
+var RayPool = class _RayPool {
+  buffer;
+  count = 0;
+  constructor(capacity, sharedBuffer) {
+    this.buffer = sharedBuffer ? new Float32Array(sharedBuffer, 0, capacity * RAY_STRIDE) : new Float32Array(capacity * RAY_STRIDE);
+  }
+  /**
+   * Create a RayPool backed by a new `SharedArrayBuffer`.
+   * Both the pool and the underlying `SharedArrayBuffer` are returned so the
+   * caller can transfer the buffer to a `Worker` via `postMessage`.
+   */
+  static createShared(capacity) {
+    const sab = new SharedArrayBuffer(capacity * RAY_STRIDE * Float32Array.BYTES_PER_ELEMENT);
+    return { pool: new _RayPool(capacity, sab), sab };
+  }
+  /** Allocate a new Ray slot and return its index. */
+  allocate() {
+    const index = this.count;
+    this.count += 1;
+    return index;
+  }
+  /** Set origin and direction of a ray at the given index. */
+  set(index, ox, oy, oz, dx, dy, dz) {
+    const offset = index * RAY_STRIDE;
+    this.buffer[offset] = ox;
+    this.buffer[offset + 1] = oy;
+    this.buffer[offset + 2] = oz;
+    this.buffer[offset + 3] = dx;
+    this.buffer[offset + 4] = dy;
+    this.buffer[offset + 5] = dz;
+  }
+  /** Read a single component value from the buffer. */
+  get(index, component) {
+    return this.buffer[index * RAY_STRIDE + component] ?? 0;
+  }
+  /** Returns the number of allocated Rays. */
+  get size() {
+    return this.count;
+  }
+  /** Reset the pool (all allocations freed, no GC). */
+  reset() {
+    this.count = 0;
+  }
+};
+function rayIntersectsAABB(rayBuf, rayOffset, aabbBuf, aabbOffset) {
+  const ox = rayBuf[rayOffset] ?? 0;
+  const oy = rayBuf[rayOffset + 1] ?? 0;
+  const oz = rayBuf[rayOffset + 2] ?? 0;
+  const idx = 1 / (rayBuf[rayOffset + 3] ?? 0);
+  const idy = 1 / (rayBuf[rayOffset + 4] ?? 0);
+  const idz = 1 / (rayBuf[rayOffset + 5] ?? 0);
+  const minX = aabbBuf[aabbOffset] ?? 0;
+  const minY = aabbBuf[aabbOffset + 1] ?? 0;
+  const minZ = aabbBuf[aabbOffset + 2] ?? 0;
+  const maxX = aabbBuf[aabbOffset + 3] ?? 0;
+  const maxY = aabbBuf[aabbOffset + 4] ?? 0;
+  const maxZ = aabbBuf[aabbOffset + 5] ?? 0;
+  const t1x = (minX - ox) * idx;
+  const t2x = (maxX - ox) * idx;
+  const t1y = (minY - oy) * idy;
+  const t2y = (maxY - oy) * idy;
+  const t1z = (minZ - oz) * idz;
+  const t2z = (maxZ - oz) * idz;
+  const tmin = Math.max(Math.min(t1x, t2x), Math.min(t1y, t2y), Math.min(t1z, t2z));
+  const tmax = Math.min(Math.max(t1x, t2x), Math.max(t1y, t2y), Math.max(t1z, t2z));
+  if (tmax < 0 || !(tmin <= tmax)) return -1;
+  return tmin >= 0 ? tmin : tmax;
+}
+
+// src/octree.ts
+function aabbOverlapsBox(buf, bufOffset, qMinX, qMinY, qMinZ, qMaxX, qMaxY, qMaxZ) {
+  return buf[bufOffset] <= qMaxX && buf[bufOffset + 3] >= qMinX && buf[bufOffset + 1] <= qMaxY && buf[bufOffset + 4] >= qMinY && buf[bufOffset + 2] <= qMaxZ && buf[bufOffset + 5] >= qMinZ;
+}
+var Octree = class {
+  nodePool;
+  aabbPool;
+  root;
+  /** Tracks which node each object (by AABBPool index) is currently stored in. */
+  objectNodeMap = /* @__PURE__ */ new Map();
+  /** Pre-allocated traversal stack reused across raycast calls to avoid GC pressure. */
+  _stack = [];
+  constructor(nodePool, aabbPool) {
+    this.nodePool = nodePool;
+    this.aabbPool = aabbPool;
+    this.root = nodePool.allocate();
+  }
+  /** The index of the root node in the underlying OctreeNodePool. */
+  get rootIndex() {
+    return this.root;
+  }
+  /** Set the world-space AABB that the root node covers. */
+  setBounds(minX, minY, minZ, maxX, maxY, maxZ) {
+    this.nodePool.setAABB(this.root, minX, minY, minZ, maxX, maxY, maxZ);
+  }
+  /** Insert the AABB at `objectIndex` (in the AABBPool) into the tree. */
+  insert(objectIndex) {
+    this.insertIntoNode(this.root, objectIndex);
+  }
+  /**
+   * Update the AABB at `objectIndex` with new bounds and reposition it in the
+   * tree without rebuilding. If the new bounds still fit in the current node
+   * the object stays there; otherwise it is removed and re-inserted from the
+   * lowest ancestor whose bounds fully contain the new AABB.
+   */
+  update(objectIndex, newMinX, newMinY, newMinZ, newMaxX, newMaxY, newMaxZ) {
+    const np = this.nodePool;
+    const ap = this.aabbPool;
+    ap.set(objectIndex, newMinX, newMinY, newMinZ, newMaxX, newMaxY, newMaxZ);
+    const currentNode = this.objectNodeMap.get(objectIndex);
+    if (currentNode === void 0) return;
+    if (this.fitsInNode(objectIndex, currentNode)) return;
+    np.removeObject(currentNode, objectIndex);
+    this.objectNodeMap.delete(objectIndex);
+    let ancestorNode = np.getParent(currentNode);
+    while (ancestorNode !== -1 && !this.fitsInNode(objectIndex, ancestorNode)) {
+      ancestorNode = np.getParent(ancestorNode);
+    }
+    if (ancestorNode === -1) ancestorNode = this.root;
+    this.insertIntoNode(ancestorNode, objectIndex);
+  }
+  /**
+   * Cast a ray through the octree and return the closest intersecting object.
+   *
+   * Uses an iterative stack traversal (pre-allocated, no recursion) to avoid
+   * GC pressure. Only descends into child nodes whose AABBs are intersected by
+   * the ray, providing efficient pruning of non-intersecting subtrees.
+   *
+   * @param rayBuf   Float32Array containing the ray data [ox,oy,oz,dx,dy,dz].
+   * @param rayOffset Element offset (in floats) within `rayBuf` to the ray's origin.
+   * @returns The closest `{ objectIndex, t }` hit, or `null` if nothing is hit.
+   */
+  raycast(rayBuf, rayOffset) {
+    const np = this.nodePool;
+    const npBuf = np.buffer;
+    const apBuf = this.aabbPool.buffer;
+    if (rayIntersectsAABB(rayBuf, rayOffset, npBuf, this.root * NODE_STRIDE + NODE_AABB_OFFSET) < 0) {
+      return null;
+    }
+    this._stack.length = 0;
+    this._stack.push(this.root);
+    let closestT = Infinity;
+    let closestIndex = -1;
+    while (this._stack.length > 0) {
+      const nodeIdx = this._stack.pop();
+      const objCount = np.getObjectCount(nodeIdx);
+      for (let i = 0; i < objCount; i++) {
+        const objIdx = np.getObject(nodeIdx, i);
+        const t = rayIntersectsAABB(rayBuf, rayOffset, apBuf, objIdx * AABB_STRIDE);
+        if (t >= 0 && t < closestT) {
+          closestT = t;
+          closestIndex = objIdx;
+        }
+      }
+      const firstChild = np.getFirstChild(nodeIdx);
+      if (firstChild !== -1) {
+        for (let i = 0; i < 8; i++) {
+          const childIdx = firstChild + i;
+          if (rayIntersectsAABB(rayBuf, rayOffset, npBuf, childIdx * NODE_STRIDE + NODE_AABB_OFFSET) >= 0) {
+            this._stack.push(childIdx);
+          }
+        }
+      }
+    }
+    if (closestIndex === -1) return null;
+    return { objectIndex: closestIndex, t: closestT };
+  }
+  /**
+   * Query the octree for all objects whose AABB overlaps the given axis-aligned
+   * box region and return their indices (in the AABBPool).
+   *
+   * Uses the same pre-allocated iterative stack as `raycast` to avoid GC
+   * pressure. Descends only into child nodes whose AABBs overlap the query box,
+   * pruning non-intersecting subtrees.
+   *
+   * @param minX  Minimum X of the query box.
+   * @param minY  Minimum Y of the query box.
+   * @param minZ  Minimum Z of the query box.
+   * @param maxX  Maximum X of the query box.
+   * @param maxY  Maximum Y of the query box.
+   * @param maxZ  Maximum Z of the query box.
+   * @returns Array of AABBPool indices for every object that overlaps the box.
+   */
+  queryBox(minX, minY, minZ, maxX, maxY, maxZ) {
+    const np = this.nodePool;
+    const npBuf = np.buffer;
+    const apBuf = this.aabbPool.buffer;
+    const results = [];
+    if (!aabbOverlapsBox(npBuf, this.root * NODE_STRIDE + NODE_AABB_OFFSET, minX, minY, minZ, maxX, maxY, maxZ)) {
+      return results;
+    }
+    this._stack.length = 0;
+    this._stack.push(this.root);
+    while (this._stack.length > 0) {
+      const nodeIdx = this._stack.pop();
+      const objCount = np.getObjectCount(nodeIdx);
+      for (let i = 0; i < objCount; i++) {
+        const objIdx = np.getObject(nodeIdx, i);
+        if (aabbOverlapsBox(apBuf, objIdx * AABB_STRIDE, minX, minY, minZ, maxX, maxY, maxZ)) {
+          results.push(objIdx);
+        }
+      }
+      const firstChild = np.getFirstChild(nodeIdx);
+      if (firstChild !== -1) {
+        for (let i = 0; i < 8; i++) {
+          const childIdx = firstChild + i;
+          if (aabbOverlapsBox(npBuf, childIdx * NODE_STRIDE + NODE_AABB_OFFSET, minX, minY, minZ, maxX, maxY, maxZ)) {
+            this._stack.push(childIdx);
+          }
+        }
+      }
+    }
+    return results;
+  }
+  // ── Private helpers ──────────────────────────────────────────────────────
+  insertIntoNode(nodeIdx, objectIndex) {
+    const np = this.nodePool;
+    const firstChild = np.getFirstChild(nodeIdx);
+    if (firstChild !== -1) {
+      for (let i = 0; i < 8; i++) {
+        if (this.fitsInNode(objectIndex, firstChild + i)) {
+          this.insertIntoNode(firstChild + i, objectIndex);
+          return;
+        }
+      }
+      np.addObject(nodeIdx, objectIndex);
+      this.objectNodeMap.set(objectIndex, nodeIdx);
+      return;
+    }
+    const count = np.getObjectCount(nodeIdx);
+    if (count < MAX_OBJECTS_PER_NODE) {
+      np.addObject(nodeIdx, objectIndex);
+      this.objectNodeMap.set(objectIndex, nodeIdx);
+    } else {
+      this.subdivide(nodeIdx);
+      this.insertIntoNode(nodeIdx, objectIndex);
+    }
+  }
+  /** Split a leaf node into 8 children and redistribute its objects. */
+  subdivide(nodeIdx) {
+    const np = this.nodePool;
+    const minX = np.getAABB(nodeIdx, 0);
+    const minY = np.getAABB(nodeIdx, 1);
+    const minZ = np.getAABB(nodeIdx, 2);
+    const maxX = np.getAABB(nodeIdx, 3);
+    const maxY = np.getAABB(nodeIdx, 4);
+    const maxZ = np.getAABB(nodeIdx, 5);
+    const midX = (minX + maxX) / 2;
+    const midY = (minY + maxY) / 2;
+    const midZ = (minZ + maxZ) / 2;
+    const firstChild = np.allocate();
+    for (let i = 1; i < 8; i++) {
+      np.allocate();
+    }
+    np.setFirstChild(nodeIdx, firstChild);
+    for (let i = 0; i < 8; i++) {
+      const childIdx = firstChild + i;
+      const cMinX = (i & 1) === 0 ? minX : midX;
+      const cMaxX = (i & 1) === 0 ? midX : maxX;
+      const cMinY = (i & 2) === 0 ? minY : midY;
+      const cMaxY = (i & 2) === 0 ? midY : maxY;
+      const cMinZ = (i & 4) === 0 ? minZ : midZ;
+      const cMaxZ = (i & 4) === 0 ? midZ : maxZ;
+      np.setAABB(childIdx, cMinX, cMinY, cMinZ, cMaxX, cMaxY, cMaxZ);
+      np.setParent(childIdx, nodeIdx);
+    }
+    const count = np.getObjectCount(nodeIdx);
+    const saved = [];
+    for (let i = 0; i < count; i++) {
+      saved.push(np.getObject(nodeIdx, i));
+    }
+    np.clearObjects(nodeIdx);
+    for (const obj of saved) {
+      this.objectNodeMap.delete(obj);
+      this.insertIntoNode(nodeIdx, obj);
+    }
+  }
+  /** Returns true when the AABB at `objectIndex` is fully contained by `nodeIdx`. */
+  fitsInNode(objectIndex, nodeIdx) {
+    const np = this.nodePool;
+    const ap = this.aabbPool;
+    return ap.get(objectIndex, 0) >= np.getAABB(nodeIdx, 0) && ap.get(objectIndex, 1) >= np.getAABB(nodeIdx, 1) && ap.get(objectIndex, 2) >= np.getAABB(nodeIdx, 2) && ap.get(objectIndex, 3) <= np.getAABB(nodeIdx, 3) && ap.get(objectIndex, 4) <= np.getAABB(nodeIdx, 4) && ap.get(objectIndex, 5) <= np.getAABB(nodeIdx, 5);
+  }
+};
+
+// src/lidar-worker.ts
+function createLidarProcessor() {
+  let octree = null;
+  let aabbPool = null;
+  let raysBuf = null;
+  let resultsBuf = null;
+  let totalRayCount = 0;
+  let insertedObjectCount = 0;
+  return {
+    /** Initialise shared buffers and create the Octree. */
+    init(msg) {
+      const nodePool = new OctreeNodePool(msg.nodeCapacity, msg.nodesSab);
+      aabbPool = new AABBPool(msg.objectCapacity, msg.aabbsSab);
+      raysBuf = new Float32Array(msg.raysSab);
+      resultsBuf = new Float32Array(msg.resultsSab);
+      totalRayCount = msg.rayCount;
+      insertedObjectCount = 0;
+      octree = new Octree(nodePool, aabbPool);
+      octree.setBounds(
+        msg.worldMinX,
+        msg.worldMinY,
+        msg.worldMinZ,
+        msg.worldMaxX,
+        msg.worldMaxY,
+        msg.worldMaxZ
+      );
+      return { type: "ready" };
+    },
+    /**
+     * Read current object AABB data from the shared buffer, update the Octree,
+     * cast every sweep ray, and write results to the results buffer.
+     */
+    sweep(msg) {
+      if (octree === null || aabbPool === null || raysBuf === null || resultsBuf === null) {
+        throw new Error("LidarProcessor: sweep called before init");
+      }
+      const objectCount = msg.objectCount;
+      while (aabbPool.size < objectCount) {
+        aabbPool.allocate();
+      }
+      for (let i = 0; i < objectCount; i++) {
+        const minX = aabbPool.get(i, 0);
+        const minY = aabbPool.get(i, 1);
+        const minZ = aabbPool.get(i, 2);
+        const maxX = aabbPool.get(i, 3);
+        const maxY = aabbPool.get(i, 4);
+        const maxZ = aabbPool.get(i, 5);
+        if (i < insertedObjectCount) {
+          octree.update(i, minX, minY, minZ, maxX, maxY, maxZ);
+        } else {
+          octree.insert(i);
+          insertedObjectCount++;
+        }
+      }
+      for (let r = 0; r < totalRayCount; r++) {
+        const hit = octree.raycast(raysBuf, r * RAY_STRIDE);
+        if (hit !== null) {
+          resultsBuf[r * 2] = hit.objectIndex;
+          resultsBuf[r * 2 + 1] = hit.t;
+        } else {
+          resultsBuf[r * 2] = -1;
+          resultsBuf[r * 2 + 1] = -1;
+        }
+      }
+      return { type: "done", rayCount: totalRayCount };
+    }
+  };
+}
+var globalScope = globalThis;
+if (typeof globalScope["postMessage"] === "function" && typeof globalScope["onmessage"] !== "undefined") {
+  const workerSelf = globalThis;
+  const processor = createLidarProcessor();
+  workerSelf.onmessage = (event) => {
+    const msg = event.data;
+    if (msg.type === "init") {
+      workerSelf.postMessage(processor.init(msg));
+    } else if (msg.type === "sweep") {
+      workerSelf.postMessage(processor.sweep(msg));
+    }
+  };
+}
+
+export {
+  AABB_STRIDE,
+  AABBPool,
+  aabbExpand,
+  aabbMerge,
+  aabbIntersects,
+  RAY_STRIDE,
+  RayPool,
+  rayIntersectsAABB,
+  NODE_AABB_OFFSET,
+  NODE_FIRST_CHILD_OFFSET,
+  NODE_PARENT_OFFSET,
+  NODE_OBJECT_COUNT_OFFSET,
+  NODE_OBJECTS_OFFSET,
+  MAX_OBJECTS_PER_NODE,
+  NODE_STRIDE,
+  OctreeNodePool,
+  Octree,
+  createLidarProcessor
+};
+//# sourceMappingURL=chunk-JF4RVZK3.js.map