@woosh/meep-engine 2.156.0 → 2.158.0

package/src/engine/physics/narrowphase/reduce_manifold_contacts.d.ts

@@ -1,7 +1,7 @@
 /**
  * In-place reduction of a strided contact-candidate buffer to at most `maxKept`
  * points:
- *   1. keep the deepest candidate (penetration depth at lane `stride - 1`) in
+ *   1. keep the deepest candidate (penetration depth at lane `depth_lane`) in
  *      slot 0;
  *   2. then greedily pick the candidate whose MINIMUM squared distance to the
  *      already-kept set is largest (farthest-point sampling) — a behaviour-
@@ -11,19 +11,26 @@
  * The contact position is lanes 0,1,2 of each `stride`-float record; the buffer
  * is reordered in place and the caller reads the first `maxKept` records.
  *
- * Shared by {@link box_box_manifold} and {@link convex_convex_manifold} (both
- * stride 4), which previously each carried a byte-identical copy. The stride-7
- * (box_triangle) and stride-10 (narrowphase_step) variants differ only in stride
- * and can adopt this too.
+ * Shared by {@link box_box_manifold} / {@link convex_convex_manifold} (stride 4,
+ * depth lane 3), {@link box_triangle_contact} (stride 7, depth lane 6) and the
+ * narrowphase dispatcher's pair-candidate buffer (stride 13, depth lane 9 —
+ * lanes 10..12 are feature id / friction / restitution). Each previously
+ * carried its own byte-identical copy.
+ *
+ * `depth_lane` is deliberately REQUIRED, not defaulted to `stride - 1`: the
+ * candidate layouts genuinely differ (the dispatcher's lane 12 is RESTITUTION),
+ * and a stride-derived default is exactly the trap that would silently rank
+ * contacts by the wrong lane (REVIEW_003 E2).
  *
  * @param {Float64Array} buf  strided candidate buffer
  * @param {number} n          input candidate count
- * @param {number} stride     floats per candidate (depth at lane stride-1)
+ * @param {number} stride     floats per candidate
  * @param {number} maxKept    maximum candidates to keep
+ * @param {number} depth_lane lane within each record holding penetration depth
  * @returns {number} kept count = min(n, maxKept)
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function reduce_manifold_contacts(buf: Float64Array, n: number, stride: number, maxKept: number): number;
+export function reduce_manifold_contacts(buf: Float64Array, n: number, stride: number, maxKept: number, depth_lane: number): number;
 //# sourceMappingURL=reduce_manifold_contacts.d.ts.map

package/src/engine/physics/narrowphase/reduce_manifold_contacts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reduce_manifold_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/reduce_manifold_contacts.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,8CATW,YAAY,KACZ,MAAM,UACN,MAAM,WACN,MAAM,GACJ,MAAM,CAqClB"}
+{"version":3,"file":"reduce_manifold_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/reduce_manifold_contacts.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,8CAVW,YAAY,KACZ,MAAM,UACN,MAAM,WACN,MAAM,cACN,MAAM,GACJ,MAAM,CAmClB"}

package/src/engine/physics/narrowphase/reduce_manifold_contacts.js

@@ -1,69 +1,74 @@
-/**
- * In-place reduction of a strided contact-candidate buffer to at most `maxKept`
- * points:
- *   1. keep the deepest candidate (penetration depth at lane `stride - 1`) in
- *      slot 0;
- *   2. then greedily pick the candidate whose MINIMUM squared distance to the
- *      already-kept set is largest (farthest-point sampling) — a behaviour-
- *      preserving max-spread approximation that avoids degenerate near-coincident
- *      manifolds.
- *
- * The contact position is lanes 0,1,2 of each `stride`-float record; the buffer
- * is reordered in place and the caller reads the first `maxKept` records.
- *
- * Shared by {@link box_box_manifold} and {@link convex_convex_manifold} (both
- * stride 4), which previously each carried a byte-identical copy. The stride-7
- * (box_triangle) and stride-10 (narrowphase_step) variants differ only in stride
- * and can adopt this too.
- *
- * @param {Float64Array} buf  strided candidate buffer
- * @param {number} n          input candidate count
- * @param {number} stride     floats per candidate (depth at lane stride-1)
- * @param {number} maxKept    maximum candidates to keep
- * @returns {number} kept count = min(n, maxKept)
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function reduce_manifold_contacts(buf, n, stride, maxKept) {
-    if (n <= maxKept) return n;
-
-    const depth_lane = stride - 1;
-
-    // Deepest into slot 0.
-    let deepest_idx = 0;
-    let deepest_val = buf[depth_lane];
-    for (let i = 1; i < n; i++) {
-        const v = buf[i * stride + depth_lane];
-        if (v > deepest_val) { deepest_val = v; deepest_idx = i; }
-    }
-    if (deepest_idx !== 0) swap(buf, stride, 0, deepest_idx);
-
-    // Greedy farthest-point for the remaining slots.
-    for (let k = 1; k < maxKept; k++) {
-        let best_score = -1;
-        let best_i = -1;
-        for (let i = k; i < n; i++) {
-            let min_d2 = Infinity;
-            for (let j = 0; j < k; j++) {
-                const dx = buf[i * stride] - buf[j * stride];
-                const dy = buf[i * stride + 1] - buf[j * stride + 1];
-                const dz = buf[i * stride + 2] - buf[j * stride + 2];
-                const d2 = dx * dx + dy * dy + dz * dz;
-                if (d2 < min_d2) min_d2 = d2;
-            }
-            if (min_d2 > best_score) { best_score = min_d2; best_i = i; }
-        }
-        if (best_i !== k) swap(buf, stride, k, best_i);
-    }
-    return maxKept;
-}
-
-function swap(buf, stride, a, b) {
-    const ao = a * stride, bo = b * stride;
-    for (let k = 0; k < stride; k++) {
-        const t = buf[ao + k];
-        buf[ao + k] = buf[bo + k];
-        buf[bo + k] = t;
-    }
-}
+/**
+ * In-place reduction of a strided contact-candidate buffer to at most `maxKept`
+ * points:
+ *   1. keep the deepest candidate (penetration depth at lane `depth_lane`) in
+ *      slot 0;
+ *   2. then greedily pick the candidate whose MINIMUM squared distance to the
+ *      already-kept set is largest (farthest-point sampling) — a behaviour-
+ *      preserving max-spread approximation that avoids degenerate near-coincident
+ *      manifolds.
+ *
+ * The contact position is lanes 0,1,2 of each `stride`-float record; the buffer
+ * is reordered in place and the caller reads the first `maxKept` records.
+ *
+ * Shared by {@link box_box_manifold} / {@link convex_convex_manifold} (stride 4,
+ * depth lane 3), {@link box_triangle_contact} (stride 7, depth lane 6) and the
+ * narrowphase dispatcher's pair-candidate buffer (stride 13, depth lane 9 —
+ * lanes 10..12 are feature id / friction / restitution). Each previously
+ * carried its own byte-identical copy.
+ *
+ * `depth_lane` is deliberately REQUIRED, not defaulted to `stride - 1`: the
+ * candidate layouts genuinely differ (the dispatcher's lane 12 is RESTITUTION),
+ * and a stride-derived default is exactly the trap that would silently rank
+ * contacts by the wrong lane (REVIEW_003 E2).
+ *
+ * @param {Float64Array} buf  strided candidate buffer
+ * @param {number} n          input candidate count
+ * @param {number} stride     floats per candidate
+ * @param {number} maxKept    maximum candidates to keep
+ * @param {number} depth_lane lane within each record holding penetration depth
+ * @returns {number} kept count = min(n, maxKept)
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function reduce_manifold_contacts(buf, n, stride, maxKept, depth_lane) {
+    if (n <= maxKept) return n;
+
+    // Deepest into slot 0.
+    let deepest_idx = 0;
+    let deepest_val = buf[depth_lane];
+    for (let i = 1; i < n; i++) {
+        const v = buf[i * stride + depth_lane];
+        if (v > deepest_val) { deepest_val = v; deepest_idx = i; }
+    }
+    if (deepest_idx !== 0) swap(buf, stride, 0, deepest_idx);
+
+    // Greedy farthest-point for the remaining slots.
+    for (let k = 1; k < maxKept; k++) {
+        let best_score = -1;
+        let best_i = -1;
+        for (let i = k; i < n; i++) {
+            let min_d2 = Infinity;
+            for (let j = 0; j < k; j++) {
+                const dx = buf[i * stride] - buf[j * stride];
+                const dy = buf[i * stride + 1] - buf[j * stride + 1];
+                const dz = buf[i * stride + 2] - buf[j * stride + 2];
+                const d2 = dx * dx + dy * dy + dz * dz;
+                if (d2 < min_d2) min_d2 = d2;
+            }
+            if (min_d2 > best_score) { best_score = min_d2; best_i = i; }
+        }
+        if (best_i !== k) swap(buf, stride, k, best_i);
+    }
+    return maxKept;
+}
+
+function swap(buf, stride, a, b) {
+    const ao = a * stride, bo = b * stride;
+    for (let k = 0; k < stride; k++) {
+        const t = buf[ao + k];
+        buf[ao + k] = buf[bo + k];
+        buf[bo + k] = t;
+    }
+}

package/src/engine/physics/persistence/solver_caches.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Serialize the system's solver caches. Call at a step boundary (between
+ * fixedUpdate calls) — mid-step state is not exportable.
+ *
+ * @param {import("../ecs/PhysicsSystem.js").PhysicsSystem} system
+ * @param {BinaryBuffer} buffer
+ */
+export function write_solver_caches(system: import("../ecs/PhysicsSystem.js").PhysicsSystem, buffer: BinaryBuffer): void;
+/**
+ * Restore solver caches exported by {@link write_solver_caches} into a
+ * system whose bodies (and joints) have been re-linked under the SAME
+ * entity ids. The manifold store must be empty (a fresh system, or
+ * `system.manifolds.clear()` after a remove-all) so slot allocation starts
+ * from a known state.
+ *
+ * @param {import("../ecs/PhysicsSystem.js").PhysicsSystem} system
+ * @param {BinaryBuffer} buffer
+ */
+export function read_solver_caches(system: import("../ecs/PhysicsSystem.js").PhysicsSystem, buffer: BinaryBuffer): void;
+//# sourceMappingURL=solver_caches.d.ts.map

package/src/engine/physics/persistence/solver_caches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solver_caches.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/persistence/solver_caches.js"],"names":[],"mappings":"AA+CA;;;;;;GAMG;AACH,4CAHW,OAAO,yBAAyB,EAAE,aAAa,8BASzD;AAED;;;;;;;;;GASG;AACH,2CAHW,OAAO,yBAAyB,EAAE,aAAa,8BAUzD"}

package/src/engine/physics/persistence/solver_caches.js

@@ -0,0 +1,309 @@
+import { assert } from "../../../core/assert.js";
+import { BODY_INDEX_ABSENT, body_id_index, pack_body_id } from "../body/BodyStorage.js";
+import { CONTACT_STRIDE } from "../contact/ManifoldStore.js";
+import { SleepState } from "../ecs/SleepState.js";
+
+/**
+ * # Solver-cache serialization
+ *
+ * The engine's outcome-affecting state that does NOT live on components:
+ *
+ *  - contact manifolds: warm-start impulses, contact geometry awaiting the
+ *    next match-and-merge, and the lifecycle bits (grace, had_contacts,
+ *    prox-edge memory) that drive events and the stage-0 wake;
+ *  - joint warm-start impulses (`dofImpulse` — zeroed by link_joint, so a
+ *    re-linked joint must have it restored explicitly);
+ *  - sleep-group membership (circular chains of body indices — pure
+ *    world-instance ids that cannot ride on components).
+ *
+ * Reconstruction-determinism contract: copying body components alone makes
+ * a rebuilt world *converge* with the original, but the first few ticks
+ * differ — a cold solver re-converges its impulses, evicted manifolds
+ * re-fire Begin events, sleepers wake as singletons. Exporting this blob
+ * alongside the components and importing it after relinking makes the
+ * rebuilt world continue BIT-IDENTICALLY.
+ *
+ * Everything is keyed by ENTITY (the cross-engine identity); packed body
+ * ids and slot ids never enter the stream. Slots are written sorted by
+ * entity pair, so two engines holding identical state produce identical
+ * bytes. No mirroring is ever needed on import: the broadphase assigns
+ * manifold A/B roles entity-canonically (see generate_pairs), so the
+ * exported A side is the importing engine's A side by construction.
+ *
+ * Usage:
+ *
+ *     // export, at a step boundary:
+ *     write_solver_caches(system, buffer);
+ *
+ *     // import, into a freshly-built (or fully cleared) system AFTER all
+ *     // bodies and joints have been linked with their restored components:
+ *     read_solver_caches(system, buffer);
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+const FORMAT_VERSION = 1;
+
+/**
+ * Serialize the system's solver caches. Call at a step boundary (between
+ * fixedUpdate calls) — mid-step state is not exportable.
+ *
+ * @param {import("../ecs/PhysicsSystem.js").PhysicsSystem} system
+ * @param {BinaryBuffer} buffer
+ */
+export function write_solver_caches(system, buffer) {
+    buffer.writeUint8(FORMAT_VERSION);
+
+    __write_manifolds(system, buffer);
+    __write_joint_impulses(system, buffer);
+    __write_sleep_groups(system, buffer);
+}
+
+/**
+ * Restore solver caches exported by {@link write_solver_caches} into a
+ * system whose bodies (and joints) have been re-linked under the SAME
+ * entity ids. The manifold store must be empty (a fresh system, or
+ * `system.manifolds.clear()` after a remove-all) so slot allocation starts
+ * from a known state.
+ *
+ * @param {import("../ecs/PhysicsSystem.js").PhysicsSystem} system
+ * @param {BinaryBuffer} buffer
+ */
+export function read_solver_caches(system, buffer) {
+    const version = buffer.readUint8();
+    assert.equal(version, FORMAT_VERSION, `solver-cache stream version ${version}, expected ${FORMAT_VERSION}`);
+
+    __read_manifolds(system, buffer);
+    __read_joint_impulses(system, buffer);
+    __read_sleep_groups(system, buffer);
+}
+
+/**
+ * @private
+ * @param {import("../ecs/PhysicsSystem.js").PhysicsSystem} system
+ * @param {BinaryBuffer} buffer
+ */
+function __write_manifolds(system, buffer) {
+    const manifolds = system.manifolds;
+    const storage = system.storage;
+
+    // Collect live slots whose bodies are both still valid (a slot whose
+    // body was unlinked is inert, awaiting grace eviction — nothing to
+    // restore), then sort by entity pair so the stream is canonical.
+    const records = [];
+    const live_count = manifolds.count;
+    for (let i = 0; i < live_count; i++) {
+        const slot = manifolds.live_at(i);
+        const idA = manifolds.bodyA(slot);
+        const idB = manifolds.bodyB(slot);
+        if (!storage.is_valid(idA) || !storage.is_valid(idB)) continue;
+        records.push({
+            slot,
+            entA: storage.entity_at(body_id_index(idA)),
+            entB: storage.entity_at(body_id_index(idB)),
+        });
+    }
+    records.sort((a, b) => (a.entA - b.entA) || (a.entB - b.entB));
+
+    buffer.writeUint32(records.length);
+
+    const data = manifolds.data_buffer;
+    for (let i = 0; i < records.length; i++) {
+        const r = records[i];
+        buffer.writeInt32(r.entA);
+        buffer.writeInt32(r.entB);
+        buffer.writeUint32(manifolds.meta_bits(r.slot));
+
+        const count = manifolds.contact_count(r.slot);
+        const off = manifolds.slot_data_offset(r.slot);
+        const words = count * CONTACT_STRIDE;
+        for (let w = 0; w < words; w++) {
+            buffer.writeFloat64(data[off + w]);
+        }
+    }
+}
+
+/**
+ * @private
+ * @param {import("../ecs/PhysicsSystem.js").PhysicsSystem} system
+ * @param {BinaryBuffer} buffer
+ */
+function __read_manifolds(system, buffer) {
+    const manifolds = system.manifolds;
+    const storage = system.storage;
+
+    assert.equal(manifolds.count, 0,
+        'read_solver_caches: manifold store must be empty (fresh system, or manifolds.clear() after a remove-all)');
+
+    const n = buffer.readUint32();
+    for (let i = 0; i < n; i++) {
+        const entA = buffer.readInt32();
+        const entB = buffer.readInt32();
+        const bits = buffer.readUint32();
+
+        const idxA = storage.index_of_entity(entA);
+        const idxB = storage.index_of_entity(entB);
+        assert.notEqual(idxA, BODY_INDEX_ABSENT, `read_solver_caches: no body linked for entity ${entA}`);
+        assert.notEqual(idxB, BODY_INDEX_ABSENT, `read_solver_caches: no body linked for entity ${entB}`);
+
+        // Entity-canonical roles: entA < entB in the stream, and the
+        // broadphase assigns A to the smaller entity — same side, no mirror.
+        const idA = pack_body_id(idxA, storage.generation_at(idxA));
+        const idB = pack_body_id(idxB, storage.generation_at(idxB));
+
+        const slot = manifolds.acquire(idA, idB);
+        manifolds.restore_meta_bits(slot, bits);
+
+        const count = manifolds.contact_count(slot);
+        const off = manifolds.slot_data_offset(slot);
+        const data = manifolds.data_buffer; // re-read: acquire may have grown the store
+        const words = count * CONTACT_STRIDE;
+        for (let w = 0; w < words; w++) {
+            data[off + w] = buffer.readFloat64();
+        }
+    }
+}
+
+/**
+ * Joint warm-start impulses, in canonical solve order. The importing
+ * engine must hold the SAME joints linked in the SAME per-pair order —
+ * the reconstruction contract replays joint links — so the records are
+ * matched positionally against its sorted registry, with the entity pair
+ * asserted at each position.
+ *
+ * @private
+ * @param {import("../ecs/PhysicsSystem.js").PhysicsSystem} system
+ * @param {BinaryBuffer} buffer
+ */
+function __write_joint_impulses(system, buffer) {
+    const sorted = system.__joints_sorted;
+    buffer.writeUint32(sorted.length);
+    for (let i = 0; i < sorted.length; i++) {
+        const joint = sorted[i];
+        buffer.writeInt32(joint.entityA);
+        buffer.writeInt32(joint.entityB);
+        for (let d = 0; d < 6; d++) {
+            buffer.writeFloat64(joint.dofImpulse[d]);
+        }
+    }
+}
+
+/**
+ * @private
+ * @param {import("../ecs/PhysicsSystem.js").PhysicsSystem} system
+ * @param {BinaryBuffer} buffer
+ */
+function __read_joint_impulses(system, buffer) {
+    const sorted = system.__joints_sorted;
+    const n = buffer.readUint32();
+    assert.equal(n, sorted.length,
+        `read_solver_caches: stream holds ${n} joints, system has ${sorted.length} linked`);
+
+    for (let i = 0; i < n; i++) {
+        const entA = buffer.readInt32();
+        const entB = buffer.readInt32();
+        const joint = sorted[i];
+        assert.ok(joint.entityA === entA && joint.entityB === entB,
+            `read_solver_caches: joint ${i} is (${joint.entityA}, ${joint.entityB}), stream says (${entA}, ${entB})`);
+        for (let d = 0; d < 6; d++) {
+            joint.dofImpulse[d] = buffer.readFloat64();
+        }
+    }
+}
+
+/**
+ * Sleep groups as entity chains. Only multi-member groups are written —
+ * a singleton sleeper's links are already `-1`, which is how link()
+ * restores every sleeper. Each chain is rotated to start at its
+ * smallest-entity member so the stream is canonical; the circular order
+ * itself only affects wake-walk order, which is outcome-neutral, but
+ * verbatim restore keeps the worlds bit-comparable.
+ *
+ * @private
+ * @param {import("../ecs/PhysicsSystem.js").PhysicsSystem} system
+ * @param {BinaryBuffer} buffer
+ */
+function __write_sleep_groups(system, buffer) {
+    const storage = system.storage;
+    const bodies = system.__bodies;
+    const hwm = storage.high_water_mark;
+
+    const groups = [];
+    const visited = new Set();
+
+    for (let idx = 0; idx < hwm; idx++) {
+        const rb = bodies[idx];
+        if (rb === undefined) continue;
+        if (rb.sleep_group_next === -1) continue;
+        if (visited.has(idx)) continue;
+
+        // Walk the circular chain once, collecting member indices.
+        const chain = [];
+        let cur = idx;
+        do {
+            chain.push(cur);
+            visited.add(cur);
+            cur = bodies[cur].sleep_group_next;
+        } while (cur !== -1 && cur !== idx && !visited.has(cur));
+
+        // Rotate so the smallest-entity member leads.
+        let lead = 0;
+        let lead_entity = storage.entity_at(chain[0]);
+        for (let i = 1; i < chain.length; i++) {
+            const e = storage.entity_at(chain[i]);
+            if (e < lead_entity) {
+                lead_entity = e;
+                lead = i;
+            }
+        }
+        const entities = [];
+        for (let i = 0; i < chain.length; i++) {
+            entities.push(storage.entity_at(chain[(lead + i) % chain.length]));
+        }
+        groups.push(entities);
+    }
+
+    groups.sort((a, b) => a[0] - b[0]);
+
+    buffer.writeUint32(groups.length);
+    for (let g = 0; g < groups.length; g++) {
+        const entities = groups[g];
+        buffer.writeUint32(entities.length);
+        for (let i = 0; i < entities.length; i++) {
+            buffer.writeInt32(entities[i]);
+        }
+    }
+}
+
+/**
+ * @private
+ * @param {import("../ecs/PhysicsSystem.js").PhysicsSystem} system
+ * @param {BinaryBuffer} buffer
+ */
+function __read_sleep_groups(system, buffer) {
+    const storage = system.storage;
+    const bodies = system.__bodies;
+
+    const group_count = buffer.readUint32();
+    for (let g = 0; g < group_count; g++) {
+        const len = buffer.readUint32();
+        assert.greaterThan(len, 1, 'read_solver_caches: a sleep group must have at least 2 members');
+
+        const indices = new Array(len);
+        for (let i = 0; i < len; i++) {
+            const entity = buffer.readInt32();
+            const idx = storage.index_of_entity(entity);
+            assert.notEqual(idx, BODY_INDEX_ABSENT, `read_solver_caches: no body linked for sleep-group entity ${entity}`);
+            indices[i] = idx;
+        }
+
+        for (let i = 0; i < len; i++) {
+            const rb = bodies[indices[i]];
+            assert.equal(rb.sleepState, SleepState.Sleeping,
+                'read_solver_caches: sleep-group member must be restored with sleepState=Sleeping before import');
+            rb.sleep_group_next = indices[(i + 1) % len];
+            rb.sleep_group_prev = indices[(i - 1 + len) % len];
+        }
+    }
+}

package/src/engine/physics/queries/overlap_shape.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"overlap_shape.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/overlap_shape.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,uFAZW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,YAE5B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,UAErC,WAAW,GAAC,MAAM,EAAE,iBAEpB,MAAM,oBACE,MAAM,yBAAsB,OAAO,GAEzC,MAAM,CAoGlB"}
+{"version":3,"file":"overlap_shape.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/overlap_shape.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,uFAZW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,YAE5B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,UAErC,WAAW,GAAC,MAAM,EAAE,iBAEpB,MAAM,oBACE,MAAM,yBAAsB,OAAO,GAEzC,MAAM,CAuGlB"}