@woosh/meep-engine 2.155.0 → 2.157.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/narrowphase/refine_ray_concave.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"refine_ray_concave.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/refine_ray_concave.js"],"names":[],"mappings":"AAsCA;;;;;;;;;GASG;AACH,qEARW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,YAC5B,UAAU,MAAM,CAAC,MACjB,MAAM,MAAa,MAAM,MAAa,MAAM,MAC5C,MAAM,MAAa,MAAM,MAAa,MAAM,QAC5C,MAAM,aACN,YAAY,UAAQ,GAClB,MAAM,CAyGlB"}
+{"version":3,"file":"refine_ray_concave.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/refine_ray_concave.js"],"names":[],"mappings":"AAwCA;;;;;;;;;GASG;AACH,qEARW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,YAC5B,UAAU,MAAM,CAAC,MACjB,MAAM,MAAa,MAAM,MAAa,MAAM,MAC5C,MAAM,MAAa,MAAM,MAAa,MAAM,QAC5C,MAAM,aACN,YAAY,UAAQ,GAClB,MAAM,CAyGlB"}

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

@@ -1,4 +1,6 @@
+import { v3_length } from "../../../core/geom/vec3/v3_length.js";
 import { v3_quat3_apply } from "../../../core/geom/vec3/v3_quat3_apply.js";
+import { v3_quat3_apply_inverse } from "../../../core/geom/vec3/v3_quat3_apply_inverse.js";
 import { TRIANGLE_FLOAT_STRIDE } from "./decomposition/triangle_buffer_layout.js";
 import { mesh_enumerate_triangles } from "./decomposition/mesh_enumerate_triangles.js";
 import { heightmap_enumerate_triangles } from "./decomposition/heightmap_enumerate_triangles.js";
@@ -49,8 +51,8 @@ const AABB_FATTEN = 1e-5; // guards triangles whose AABB just abuts the segment
 export function refine_ray_concave(shape, position, rotation, ox, oy, oz, dx, dy, dz, tMax, outNormal) {
     const qx = rotation[0], qy = rotation[1], qz = rotation[2], qw = rotation[3];
     // World → local (inverse body rotation; unit dir stays unit → t preserved).
-    v3_quat3_apply(lo, 0, ox - position.x, oy - position.y, oz - position.z, -qx, -qy, -qz, qw);
-    v3_quat3_apply(ld, 0, dx, dy, dz, -qx, -qy, -qz, qw);
+    v3_quat3_apply_inverse(lo, 0, ox - position.x, oy - position.y, oz - position.z, qx, qy, qz, qw);
+    v3_quat3_apply_inverse(ld, 0, dx, dy, dz, qx, qy, qz, qw);
     const lox = lo[0], loy = lo[1], loz = lo[2];
     const ldx = ld[0], ldy = ld[1], ldz = ld[2];
 
@@ -143,7 +145,7 @@ export function refine_ray_concave(shape, position, rotation, ox, oy, oz, dx, dy
     if (!found) return Infinity;
 
     // Normalise, orient to face the ray, then rotate the local normal to world.
-    let nl = Math.sqrt(nx * nx + ny * ny + nz * nz);
+    let nl = v3_length(nx, ny, nz);
     if (nl === 0) nl = 1;
     nx /= nl; ny /= nl; nz /= nl;
     if (nx * ldx + ny * ldy + nz * ldz > 0) { nx = -nx; ny = -ny; nz = -nz; }

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

@@ -1 +1 @@
-{"version":3,"file":"refine_ray_hit.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/refine_ray_hit.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,iEAVW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,YAC5B,UAAU,MAAM,CAAC,MACjB,MAAM,MAAa,MAAM,MAAa,MAAM,MAC5C,MAAM,MAAa,MAAM,MAAa,MAAM,QAC5C,MAAM,aACN,YAAY,UAAQ,GAElB,MAAM,CAsClB;AAzED;;;;;;GAMG;AACH,qCAFU,MAAM,CAEyB"}
+{"version":3,"file":"refine_ray_hit.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/refine_ray_hit.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,iEAVW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,YAC5B,UAAU,MAAM,CAAC,MACjB,MAAM,MAAa,MAAM,MAAa,MAAM,MAC5C,MAAM,MAAa,MAAM,MAAa,MAAM,QAC5C,MAAM,aACN,YAAY,UAAQ,GAElB,MAAM,CAsClB;AAzED;;;;;;GAMG;AACH,qCAFU,MAAM,CAEyB"}

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

@@ -1,78 +1,81 @@
-import { v3_quat3_apply } from "../../../core/geom/vec3/v3_quat3_apply.js";
-import { ray_sphere_local, ray_box_local, ray_capsule_local } from "./ray_shapes.js";
-import { refine_ray_concave } from "./refine_ray_concave.js";
-
-/**
- * Sentinel returned by {@link refine_ray_hit} for a shape it has no exact ray
- * test for (composite / arbitrary convex). The caller should keep the
- * broadphase AABB result for that leaf rather than treat it as a miss.
- * Distinct from `Infinity` (a refined miss) and any finite hit distance.
- * @type {number}
- */
-export const RAY_REFINE_UNSUPPORTED = -1;
-
-const lo = new Float64Array(3); // ray origin in shape-local frame
-const ld = new Float64Array(3); // ray direction in shape-local frame
-const ln = new Float64Array(3); // surface normal in shape-local frame
-
-/**
- * Refine a broadphase ray hit against a body's true shape geometry.
- *
- * Transforms the world ray into the shape's local frame once (rotate by the
- * inverse body rotation — a unit direction stays unit, so the hit distance is
- * preserved), runs the matching canonical primitive ({@link ray_shapes}), and
- * rotates the returned local normal back to world. Spheres are
- * rotation-invariant, so they only need the translation.
- *
- * Handles the convex primitives (sphere / box / capsule). Concave shapes
- * (mesh / heightmap) and arbitrary composite convex shapes return
- * {@link RAY_REFINE_UNSUPPORTED} — the concave path is wired in separately, and
- * composites fall back to the broadphase AABB hit (no regression).
- *
- * @param {AbstractShape3D} shape
- * @param {{x:number,y:number,z:number}} position  body world position
- * @param {ArrayLike<number>} rotation  body world rotation quaternion (x,y,z,w)
- * @param {number} ox @param {number} oy @param {number} oz  ray origin (world)
- * @param {number} dx @param {number} dy @param {number} dz  ray dir (world, unit)
- * @param {number} tMax
- * @param {Float64Array|Vector3} outNormal  world surface normal, written on a
- *   finite hit
- * @returns {number} hit distance, `Infinity` on a refined miss, or
- *   {@link RAY_REFINE_UNSUPPORTED} when the shape has no exact ray test here
- */
-export function refine_ray_hit(shape, position, rotation, ox, oy, oz, dx, dy, dz, tMax, outNormal) {
-    if (shape.isSphereShape3D === true) {
-        // Rotation-invariant: translate into the sphere's frame; the local
-        // normal is already the world normal.
-        return ray_sphere_local(outNormal, ox - position.x, oy - position.y, oz - position.z, dx, dy, dz, tMax, shape.radius);
-    }
-
-    if (shape.isBoxShape3D === true || shape.isCapsuleShape3D === true) {
-        const qx = rotation[0], qy = rotation[1], qz = rotation[2], qw = rotation[3];
-        // World → local: rotate by the inverse (conjugate) body rotation.
-        v3_quat3_apply(lo, 0, ox - position.x, oy - position.y, oz - position.z, -qx, -qy, -qz, qw);
-        v3_quat3_apply(ld, 0, dx, dy, dz, -qx, -qy, -qz, qw);
-
-        let t;
-        if (shape.isBoxShape3D === true) {
-            const h = shape.half_extents;
-            t = ray_box_local(ln, lo[0], lo[1], lo[2], ld[0], ld[1], ld[2], tMax, h.x, h.y, h.z);
-        } else {
-            t = ray_capsule_local(ln, lo[0], lo[1], lo[2], ld[0], ld[1], ld[2], tMax, shape.radius, shape.height * 0.5);
-        }
-        if (t === Infinity) return Infinity;
-
-        // Local normal → world: rotate by the body rotation.
-        v3_quat3_apply(outNormal, 0, ln[0], ln[1], ln[2], qx, qy, qz, qw);
-        return t;
-    }
-
-    // Concave (mesh / heightmap): triangle decomposition.
-    if (shape.is_convex === false) {
-        return refine_ray_concave(shape, position, rotation, ox, oy, oz, dx, dy, dz, tMax, outNormal);
-    }
-
-    // Arbitrary composite convex (TransformedShape3D / UnionShape3D / …):
-    // no exact ray test yet — caller falls back to the broadphase AABB hit.
-    return RAY_REFINE_UNSUPPORTED;
-}
+import { box3_raycast } from "../../../core/geom/3d/box/box3_raycast.js";
+import { capsule_raycast } from "../../../core/geom/3d/capsule/capsule_raycast.js";
+import { sphere_raycast } from "../../../core/geom/3d/sphere/sphere_raycast.js";
+import { v3_quat3_apply } from "../../../core/geom/vec3/v3_quat3_apply.js";
+import { v3_quat3_apply_inverse } from "../../../core/geom/vec3/v3_quat3_apply_inverse.js";
+import { refine_ray_concave } from "./refine_ray_concave.js";
+
+/**
+ * Sentinel returned by {@link refine_ray_hit} for a shape it has no exact ray
+ * test for (composite / arbitrary convex). The caller should keep the
+ * broadphase AABB result for that leaf rather than treat it as a miss.
+ * Distinct from `Infinity` (a refined miss) and any finite hit distance.
+ * @type {number}
+ */
+export const RAY_REFINE_UNSUPPORTED = -1;
+
+const lo = new Float64Array(3); // ray origin in shape-local frame
+const ld = new Float64Array(3); // ray direction in shape-local frame
+const ln = new Float64Array(3); // surface normal in shape-local frame
+
+/**
+ * Refine a broadphase ray hit against a body's true shape geometry.
+ *
+ * Transforms the world ray into the shape's local frame once (rotate by the
+ * inverse body rotation — a unit direction stays unit, so the hit distance is
+ * preserved), runs the matching canonical primitive ({@link ray_shapes}), and
+ * rotates the returned local normal back to world. Spheres are
+ * rotation-invariant, so they only need the translation.
+ *
+ * Handles the convex primitives (sphere / box / capsule). Concave shapes
+ * (mesh / heightmap) and arbitrary composite convex shapes return
+ * {@link RAY_REFINE_UNSUPPORTED} — the concave path is wired in separately, and
+ * composites fall back to the broadphase AABB hit (no regression).
+ *
+ * @param {AbstractShape3D} shape
+ * @param {{x:number,y:number,z:number}} position  body world position
+ * @param {ArrayLike<number>} rotation  body world rotation quaternion (x,y,z,w)
+ * @param {number} ox @param {number} oy @param {number} oz  ray origin (world)
+ * @param {number} dx @param {number} dy @param {number} dz  ray dir (world, unit)
+ * @param {number} tMax
+ * @param {Float64Array|Vector3} outNormal  world surface normal, written on a
+ *   finite hit
+ * @returns {number} hit distance, `Infinity` on a refined miss, or
+ *   {@link RAY_REFINE_UNSUPPORTED} when the shape has no exact ray test here
+ */
+export function refine_ray_hit(shape, position, rotation, ox, oy, oz, dx, dy, dz, tMax, outNormal) {
+    if (shape.isSphereShape3D === true) {
+        // Rotation-invariant: translate into the sphere's frame; the local
+        // normal is already the world normal.
+        return sphere_raycast(outNormal, 0, ox - position.x, oy - position.y, oz - position.z, dx, dy, dz, tMax, shape.radius);
+    }
+
+    if (shape.isBoxShape3D === true || shape.isCapsuleShape3D === true) {
+        const qx = rotation[0], qy = rotation[1], qz = rotation[2], qw = rotation[3];
+        // World → local: rotate by the inverse (conjugate) body rotation.
+        v3_quat3_apply_inverse(lo, 0, ox - position.x, oy - position.y, oz - position.z, qx, qy, qz, qw);
+        v3_quat3_apply_inverse(ld, 0, dx, dy, dz, qx, qy, qz, qw);
+
+        let t;
+        if (shape.isBoxShape3D === true) {
+            const h = shape.half_extents;
+            t = box3_raycast(ln, 0, lo[0], lo[1], lo[2], ld[0], ld[1], ld[2], tMax, h.x, h.y, h.z);
+        } else {
+            t = capsule_raycast(ln, 0, lo[0], lo[1], lo[2], ld[0], ld[1], ld[2], tMax, shape.radius, shape.height * 0.5);
+        }
+        if (t === Infinity) return Infinity;
+
+        // Local normal → world: rotate by the body rotation.
+        v3_quat3_apply(outNormal, 0, ln[0], ln[1], ln[2], qx, qy, qz, qw);
+        return t;
+    }
+
+    // Concave (mesh / heightmap): triangle decomposition.
+    if (shape.is_convex === false) {
+        return refine_ray_concave(shape, position, rotation, ox, oy, oz, dx, dy, dz, tMax, outNormal);
+    }
+
+    // Arbitrary composite convex (TransformedShape3D / UnionShape3D / …):
+    // no exact ray test yet — caller falls back to the broadphase AABB hit.
+    return RAY_REFINE_UNSUPPORTED;
+}

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"}