@spatial-engine/core 0.0.1

package/dist/index.cjs

@@ -0,0 +1,709 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AABBPool: () => AABBPool,
+  AABB_STRIDE: () => AABB_STRIDE,
+  MAX_OBJECTS_PER_NODE: () => MAX_OBJECTS_PER_NODE,
+  NODE_AABB_OFFSET: () => NODE_AABB_OFFSET,
+  NODE_FIRST_CHILD_OFFSET: () => NODE_FIRST_CHILD_OFFSET,
+  NODE_OBJECTS_OFFSET: () => NODE_OBJECTS_OFFSET,
+  NODE_OBJECT_COUNT_OFFSET: () => NODE_OBJECT_COUNT_OFFSET,
+  NODE_PARENT_OFFSET: () => NODE_PARENT_OFFSET,
+  NODE_STRIDE: () => NODE_STRIDE,
+  ObjectPool: () => ObjectPool,
+  Octree: () => Octree,
+  OctreeNodePool: () => OctreeNodePool,
+  RAY_STRIDE: () => RAY_STRIDE,
+  RayPool: () => RayPool,
+  aabbExpand: () => aabbExpand,
+  aabbIntersects: () => aabbIntersects,
+  aabbMerge: () => aabbMerge,
+  createLidarProcessor: () => createLidarProcessor,
+  rayIntersectsAABB: () => rayIntersectsAABB,
+  vec3Cross: () => vec3Cross,
+  vec3Distance: () => vec3Distance,
+  vec3DistanceSq: () => vec3DistanceSq,
+  vec3Dot: () => vec3Dot
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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/object-pool.ts
+var ObjectPool = class {
+  freeList;
+  top;
+  /** Total number of slots in the pool. */
+  capacity;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.freeList = new Int32Array(capacity);
+    for (let i = 0; i < capacity; i++) {
+      this.freeList[i] = capacity - 1 - i;
+    }
+    this.top = capacity;
+  }
+  /** Number of indices currently available for acquisition. */
+  get available() {
+    return this.top;
+  }
+  /**
+   * Acquire a free index from the pool.
+   * Returns the index, or `null` when the pool is exhausted.
+   */
+  acquire() {
+    if (this.top === 0) {
+      return null;
+    }
+    this.top -= 1;
+    return this.freeList[this.top];
+  }
+  /**
+   * Release a previously acquired index back to the pool.
+   * Throws if the index is out of range or the pool is already full.
+   */
+  release(index) {
+    if (index < 0 || index >= this.capacity) {
+      throw new RangeError(`ObjectPool.release: index ${index} is out of range [0, ${this.capacity})`);
+    }
+    if (this.top >= this.capacity) {
+      throw new RangeError("ObjectPool.release: pool is already at full capacity");
+    }
+    this.freeList[this.top] = index;
+    this.top += 1;
+  }
+};
+
+// src/flat-math.ts
+function vec3Dot(buf, i, j) {
+  return (buf[i] ?? 0) * (buf[j] ?? 0) + (buf[i + 1] ?? 0) * (buf[j + 1] ?? 0) + (buf[i + 2] ?? 0) * (buf[j + 2] ?? 0);
+}
+function vec3DistanceSq(buf, i, j) {
+  const dx = (buf[i] ?? 0) - (buf[j] ?? 0);
+  const dy = (buf[i + 1] ?? 0) - (buf[j + 1] ?? 0);
+  const dz = (buf[i + 2] ?? 0) - (buf[j + 2] ?? 0);
+  return dx * dx + dy * dy + dz * dz;
+}
+function vec3Distance(buf, i, j) {
+  return Math.sqrt(vec3DistanceSq(buf, i, j));
+}
+function vec3Cross(out, outOffset, buf, i, j) {
+  const ax = buf[i] ?? 0;
+  const ay = buf[i + 1] ?? 0;
+  const az = buf[i + 2] ?? 0;
+  const bx = buf[j] ?? 0;
+  const by = buf[j + 1] ?? 0;
+  const bz = buf[j + 2] ?? 0;
+  out[outOffset] = ay * bz - az * by;
+  out[outOffset + 1] = az * bx - ax * bz;
+  out[outOffset + 2] = ax * by - ay * bx;
+}
+
+// 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/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));
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AABBPool,
+  AABB_STRIDE,
+  MAX_OBJECTS_PER_NODE,
+  NODE_AABB_OFFSET,
+  NODE_FIRST_CHILD_OFFSET,
+  NODE_OBJECTS_OFFSET,
+  NODE_OBJECT_COUNT_OFFSET,
+  NODE_PARENT_OFFSET,
+  NODE_STRIDE,
+  ObjectPool,
+  Octree,
+  OctreeNodePool,
+  RAY_STRIDE,
+  RayPool,
+  aabbExpand,
+  aabbIntersects,
+  aabbMerge,
+  createLidarProcessor,
+  rayIntersectsAABB,
+  vec3Cross,
+  vec3Distance,
+  vec3DistanceSq,
+  vec3Dot
+});
+//# sourceMappingURL=index.cjs.map