@codexo/exojs-physics 0.15.3 → 0.16.0

package/dist/esm/binding/BindingRegistry.d.ts

@@ -1,20 +1,41 @@
-import type { SceneNode } from '@codexo/exojs';
+import { type SceneNode } from '@codexo/exojs';
 import type { PhysicsBody } from '../PhysicsBody';
 import { PhysicsBinding } from './PhysicsBinding';
 /**
  * Owns the body ↔ node links and writes bound node transforms after each step.
- * Backend-agnostic (frontend-level) — it reads only the public body transform.
+ * Backend-agnostic (frontend-level) - it reads only the public body transform.
  */
 export declare class BindingRegistry {
     private readonly _bindings;
-    /** Link `body` to `node`. Rejects nodes with non-zero skew; runtime scale is ignored. */
+    /**
+     * Link `body` to `node`. Rejects destroyed nodes and nodes with non-zero
+     * skew; runtime scale is ignored. In dev builds, warns when the node is not
+     * world-space-rooted (moved ancestor or transform-group boundary above it) -
+     * see {@link PhysicsBinding} for the local==world contract.
+     */
     bind(body: PhysicsBody, node: SceneNode): PhysicsBinding;
     /** Remove the link for `body`, if any. */
     unbind(body: PhysicsBody): void;
-    /** Write every bound node's transform from its body. */
+    /**
+     * Write every bound node's transform from its body, dropping links whose node
+     * has been destroyed.
+     *
+     * `SceneNode.destroy()` returns the node's position/rotation state to a shared
+     * pool, so a `sync()` that kept writing would not merely update a dead node -
+     * it would write through recycled state into whichever live node next takes
+     * that slot. Pruning here (rather than only on an explicit `unbind`) is what
+     * makes destroying a bound node safe without a physics-side teardown call.
+     */
     sync(): void;
+    /**
+     * Like {@link sync}, but places each node `alpha` of the way from its body's
+     * previous fixed state to its current one - see
+     * {@link PhysicsBinding.syncInterpolated}. Same destroyed-node pruning.
+     */
+    syncInterpolated(alpha: number): void;
     /** `true` when at least one binding exists. */
     get size(): number;
     /** Drop all links. */
     clear(): void;
 }
+//# sourceMappingURL=BindingRegistry.d.ts.map

package/dist/esm/binding/BindingRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BindingRegistry.d.ts","sourceRoot":"","sources":["../../../src/binding/BindingRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAEvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAgDlD;;;GAGG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0C;IAEpE;;;;;OAKG;IACI,IAAI,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,GAAG,cAAc;IAqB/D,0CAA0C;IACnC,MAAM,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI;IAItC;;;;;;;;;OASG;IACI,IAAI,IAAI,IAAI;IAWnB;;;;OAIG;IACI,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAW5C,+CAA+C;IAC/C,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,sBAAsB;IACf,KAAK,IAAI,IAAI;CAGrB"}

package/dist/esm/binding/BindingRegistry.js

@@ -1,40 +1,74 @@
-import { PhysicsBinding } from './PhysicsBinding.js';
+import { PhysicsBinding } from "./PhysicsBinding.js";
+import "@codexo/exojs";
 
+//#region src/binding/BindingRegistry.ts
 /**
- * Owns the body ↔ node links and writes bound node transforms after each step.
- * Backend-agnostic (frontend-level) — it reads only the public body transform.
- */
-class BindingRegistry {
-    _bindings = new Map();
-    /** Link `body` to `node`. Rejects nodes with non-zero skew; runtime scale is ignored. */
-    bind(body, node) {
-        if (node.skewX !== 0 || node.skewY !== 0) {
-            throw new Error(`PhysicsBinding: the bound node has non-zero skew (${node.skewX}°, ${node.skewY}°); skewed nodes are not supported.`);
-        }
-        const binding = new PhysicsBinding(body, node);
-        this._bindings.set(body, binding);
-        binding.sync();
-        return binding;
-    }
-    /** Remove the link for `body`, if any. */
-    unbind(body) {
-        this._bindings.delete(body);
-    }
-    /** Write every bound node's transform from its body. */
-    sync() {
-        for (const binding of this._bindings.values()) {
-            binding.sync();
-        }
-    }
-    /** `true` when at least one binding exists. */
-    get size() {
-        return this._bindings.size;
-    }
-    /** Drop all links. */
-    clear() {
-        this._bindings.clear();
-    }
-}
+* Owns the body ↔ node links and writes bound node transforms after each step.
+* Backend-agnostic (frontend-level) - it reads only the public body transform.
+*/
+var BindingRegistry = class {
+	_bindings = /* @__PURE__ */ new Map();
+	/**
+	* Link `body` to `node`. Rejects destroyed nodes and nodes with non-zero
+	* skew; runtime scale is ignored. In dev builds, warns when the node is not
+	* world-space-rooted (moved ancestor or transform-group boundary above it) -
+	* see {@link PhysicsBinding} for the local==world contract.
+	*/
+	bind(body, node) {
+		if (node.destroyed) throw new Error("PhysicsBinding: cannot bind a destroyed node — its pooled transform has already been released.");
+		if (node.skewX !== 0 || node.skewY !== 0) throw new Error(`PhysicsBinding: the bound node has non-zero skew (${node.skewX}°, ${node.skewY}°); skewed nodes are not supported.`);
+		const binding = new PhysicsBinding(body, node);
+		this._bindings.set(body, binding);
+		binding.sync();
+		return binding;
+	}
+	/** Remove the link for `body`, if any. */
+	unbind(body) {
+		this._bindings.delete(body);
+	}
+	/**
+	* Write every bound node's transform from its body, dropping links whose node
+	* has been destroyed.
+	*
+	* `SceneNode.destroy()` returns the node's position/rotation state to a shared
+	* pool, so a `sync()` that kept writing would not merely update a dead node -
+	* it would write through recycled state into whichever live node next takes
+	* that slot. Pruning here (rather than only on an explicit `unbind`) is what
+	* makes destroying a bound node safe without a physics-side teardown call.
+	*/
+	sync() {
+		for (const [body, binding] of this._bindings) {
+			if (binding.node.destroyed) {
+				this._bindings.delete(body);
+				continue;
+			}
+			binding.sync();
+		}
+	}
+	/**
+	* Like {@link sync}, but places each node `alpha` of the way from its body's
+	* previous fixed state to its current one - see
+	* {@link PhysicsBinding.syncInterpolated}. Same destroyed-node pruning.
+	*/
+	syncInterpolated(alpha) {
+		for (const [body, binding] of this._bindings) {
+			if (binding.node.destroyed) {
+				this._bindings.delete(body);
+				continue;
+			}
+			binding.syncInterpolated(alpha);
+		}
+	}
+	/** `true` when at least one binding exists. */
+	get size() {
+		return this._bindings.size;
+	}
+	/** Drop all links. */
+	clear() {
+		this._bindings.clear();
+	}
+};
 
+//#endregion
 export { BindingRegistry };
-//# sourceMappingURL=BindingRegistry.js.map
+//# sourceMappingURL=BindingRegistry.js.map

package/dist/esm/binding/BindingRegistry.js.map

@@ -1 +1 @@
-{"version":3,"file":"BindingRegistry.js","sources":["../../../../src/binding/BindingRegistry.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;;;AAGG;MACU,eAAe,CAAA;AACT,IAAA,SAAS,GAAG,IAAI,GAAG,EAA+B;;IAG5D,IAAI,CAAC,IAAiB,EAAE,IAAe,EAAA;AAC5C,QAAA,IAAI,IAAI,CAAC,KAAK,KAAK,CAAC,IAAI,IAAI,CAAC,KAAK,KAAK,CAAC,EAAE;AACxC,YAAA,MAAM,IAAI,KAAK,CAAC,CAAA,kDAAA,EAAqD,IAAI,CAAC,KAAK,CAAA,GAAA,EAAM,IAAI,CAAC,KAAK,CAAA,mCAAA,CAAqC,CAAC;QACvI;QAEA,MAAM,OAAO,GAAG,IAAI,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC;QAE9C,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC;QACjC,OAAO,CAAC,IAAI,EAAE;AAEd,QAAA,OAAO,OAAO;IAChB;;AAGO,IAAA,MAAM,CAAC,IAAiB,EAAA;AAC7B,QAAA,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC;IAC7B;;IAGO,IAAI,GAAA;QACT,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE;YAC7C,OAAO,CAAC,IAAI,EAAE;QAChB;IACF;;AAGA,IAAA,IAAW,IAAI,GAAA;AACb,QAAA,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI;IAC5B;;IAGO,KAAK,GAAA;AACV,QAAA,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE;IACxB;AACD;;;;"}
+{"version":3,"file":"BindingRegistry.js","names":[],"sources":["../../../src/binding/BindingRegistry.ts"],"sourcesContent":["import { logger, type SceneNode } from '@codexo/exojs';\n\nimport type { PhysicsBody } from '../PhysicsBody';\nimport { PhysicsBinding } from './PhysicsBinding';\n\n/** `true` when `ancestor` contributes anything beyond identity to a descendant's world transform. */\nconst hasNonIdentityTransform = (ancestor: SceneNode): boolean =>\n  ancestor.x !== 0 ||\n  ancestor.y !== 0 ||\n  ancestor.rotation !== 0 ||\n  ancestor.skewX !== 0 ||\n  ancestor.skewY !== 0 ||\n  ancestor.scale.x !== 1 ||\n  ancestor.scale.y !== 1 ||\n  ancestor.origin.x !== 0 ||\n  ancestor.origin.y !== 0;\n\n/**\n * Dev-only bind-time guard (F16): {@link PhysicsBinding.sync} writes the\n * body's WORLD transform into the node's LOCAL position/rotation, which is\n * only correct when local space == world space. Walk the parent chain and\n * warn when an ancestor either carries a non-identity transform or is a\n * transform-group boundary (RetainedContainer) - in both cases the ancestor\n * contribution is applied ON TOP of the world-space values sync() writes,\n * double-transforming the node on screen.\n */\nconst warnUnlessWorldSpaceRooted = (node: SceneNode): void => {\n  // Duck-typed test doubles may omit `parent`; treat that as world-space-rooted.\n  let ancestor: SceneNode | null = node.parent ?? null;\n\n  while (ancestor !== null) {\n    if (ancestor._isTransformGroupBoundary || hasNonIdentityTransform(ancestor)) {\n      const nodeName = node.name !== null && node.name !== '' ? ` '${node.name}'` : '';\n      const ancestorName = ancestor.name !== null && ancestor.name !== '' ? ` '${ancestor.name}'` : '';\n\n      logger.warn(\n        `PhysicsBinding: the bound node${nodeName} is not world-space-rooted — ancestor${ancestorName} ${\n          ancestor._isTransformGroupBoundary ? 'is a transform-group boundary (RetainedContainer)' : 'has a non-identity transform'\n        }. sync() writes the body's WORLD transform into the node's LOCAL position/rotation, so nesting it under a ` +\n          'moved/rotated/scaled container (or a transform group) will double-transform it on screen. Re-parent the node ' +\n          'to a world-space-rooted container.',\n        { source: 'physics' },\n      );\n\n      return;\n    }\n\n    ancestor = ancestor.parent ?? null;\n  }\n};\n\n/**\n * Owns the body ↔ node links and writes bound node transforms after each step.\n * Backend-agnostic (frontend-level) - it reads only the public body transform.\n */\nexport class BindingRegistry {\n  private readonly _bindings = new Map<PhysicsBody, PhysicsBinding>();\n\n  /**\n   * Link `body` to `node`. Rejects destroyed nodes and nodes with non-zero\n   * skew; runtime scale is ignored. In dev builds, warns when the node is not\n   * world-space-rooted (moved ancestor or transform-group boundary above it) -\n   * see {@link PhysicsBinding} for the local==world contract.\n   */\n  public bind(body: PhysicsBody, node: SceneNode): PhysicsBinding {\n    if (node.destroyed) {\n      throw new Error('PhysicsBinding: cannot bind a destroyed node — its pooled transform has already been released.');\n    }\n\n    if (node.skewX !== 0 || node.skewY !== 0) {\n      throw new Error(`PhysicsBinding: the bound node has non-zero skew (${node.skewX}°, ${node.skewY}°); skewed nodes are not supported.`);\n    }\n\n    if (__DEV__) {\n      warnUnlessWorldSpaceRooted(node);\n    }\n\n    const binding = new PhysicsBinding(body, node);\n\n    this._bindings.set(body, binding);\n    binding.sync();\n\n    return binding;\n  }\n\n  /** Remove the link for `body`, if any. */\n  public unbind(body: PhysicsBody): void {\n    this._bindings.delete(body);\n  }\n\n  /**\n   * Write every bound node's transform from its body, dropping links whose node\n   * has been destroyed.\n   *\n   * `SceneNode.destroy()` returns the node's position/rotation state to a shared\n   * pool, so a `sync()` that kept writing would not merely update a dead node -\n   * it would write through recycled state into whichever live node next takes\n   * that slot. Pruning here (rather than only on an explicit `unbind`) is what\n   * makes destroying a bound node safe without a physics-side teardown call.\n   */\n  public sync(): void {\n    for (const [body, binding] of this._bindings) {\n      if (binding.node.destroyed) {\n        this._bindings.delete(body);\n        continue;\n      }\n\n      binding.sync();\n    }\n  }\n\n  /**\n   * Like {@link sync}, but places each node `alpha` of the way from its body's\n   * previous fixed state to its current one - see\n   * {@link PhysicsBinding.syncInterpolated}. Same destroyed-node pruning.\n   */\n  public syncInterpolated(alpha: number): void {\n    for (const [body, binding] of this._bindings) {\n      if (binding.node.destroyed) {\n        this._bindings.delete(body);\n        continue;\n      }\n\n      binding.syncInterpolated(alpha);\n    }\n  }\n\n  /** `true` when at least one binding exists. */\n  public get size(): number {\n    return this._bindings.size;\n  }\n\n  /** Drop all links. */\n  public clear(): void {\n    this._bindings.clear();\n  }\n}\n"],"mappings":";;;;;;;;AAuDA,IAAa,kBAAb,MAA6B;CAC3B,AAAiB,4BAAY,IAAI,IAAiC;;;;;;;CAQlE,AAAO,KAAK,MAAmB,MAAiC;EAC9D,IAAI,KAAK,WACP,MAAM,IAAI,MAAM,gGAAgG;EAGlH,IAAI,KAAK,UAAU,KAAK,KAAK,UAAU,GACrC,MAAM,IAAI,MAAM,qDAAqD,KAAK,MAAM,KAAK,KAAK,MAAM,oCAAoC;EAOtI,MAAM,UAAU,IAAI,eAAe,MAAM,IAAI;EAE7C,KAAK,UAAU,IAAI,MAAM,OAAO;EAChC,QAAQ,KAAK;EAEb,OAAO;CACT;;CAGA,AAAO,OAAO,MAAyB;EACrC,KAAK,UAAU,OAAO,IAAI;CAC5B;;;;;;;;;;;CAYA,AAAO,OAAa;EAClB,KAAK,MAAM,CAAC,MAAM,YAAY,KAAK,WAAW;GAC5C,IAAI,QAAQ,KAAK,WAAW;IAC1B,KAAK,UAAU,OAAO,IAAI;IAC1B;GACF;GAEA,QAAQ,KAAK;EACf;CACF;;;;;;CAOA,AAAO,iBAAiB,OAAqB;EAC3C,KAAK,MAAM,CAAC,MAAM,YAAY,KAAK,WAAW;GAC5C,IAAI,QAAQ,KAAK,WAAW;IAC1B,KAAK,UAAU,OAAO,IAAI;IAC1B;GACF;GAEA,QAAQ,iBAAiB,KAAK;EAChC;CACF;;CAGA,IAAW,OAAe;EACxB,OAAO,KAAK,UAAU;CACxB;;CAGA,AAAO,QAAc;EACnB,KAAK,UAAU,MAAM;CACvB;AACF"}

package/dist/esm/binding/PhysicsBinding.d.ts

@@ -1,11 +1,16 @@
 import { type SceneNode } from '@codexo/exojs';
 import type { PhysicsBody } from '../PhysicsBody';
 /**
- * A link between a {@link PhysicsBody} and a {@link SceneNode}. After each
- * {@link PhysicsWorld.step}, the body's world position **and rotation** are
- * written onto the node (the body's angle is radians; the node's rotation is
- * degrees). The node must be world-space-rooted; runtime scale is ignored and
- * non-zero skew is rejected at bind time.
+ * A link between a {@link PhysicsBody} and a {@link SceneNode}. The body's world
+ * position **and rotation** are written onto the node (the body's angle is
+ * radians; the node's rotation is degrees). The node must be world-space-rooted;
+ * runtime scale is ignored and non-zero skew is rejected at bind time.
+ *
+ * By default the node snaps to the latest fixed-step state after each step. With
+ * `PhysicsWorld`'s interpolation enabled the node is instead placed between the
+ * body's previous and current fixed states, which smooths motion when the fixed
+ * rate is below the frame rate. Either way this is presentation: nothing written
+ * onto the node is read back into the simulation.
  */
 export declare class PhysicsBinding {
     readonly body: PhysicsBody;
@@ -13,4 +18,16 @@ export declare class PhysicsBinding {
     constructor(body: PhysicsBody, node: SceneNode);
     /** Write the body's current transform (position + rotation) onto the bound node. */
     sync(): void;
+    /**
+     * Place the node `alpha` of the way from the body's previous fixed state to
+     * its current one. `alpha` is the host's leftover sub-step fraction, so `0`
+     * renders the state the last fixed step started from and values approaching
+     * `1` render the state it produced.
+     *
+     * A plain lerp is correct for the angle too: body angles are continuous and
+     * unbounded, never wrapped into a range, so there is no shortest-arc case to
+     * resolve.
+     */
+    syncInterpolated(alpha: number): void;
 }
+//# sourceMappingURL=PhysicsBinding.d.ts.map

package/dist/esm/binding/PhysicsBinding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsBinding.d.ts","sourceRoot":"","sources":["../../../src/binding/PhysicsBinding.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAEjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD;;;;;;;;;;;GAWG;AACH,qBAAa,cAAc;aAEP,IAAI,EAAE,WAAW;aACjB,IAAI,EAAE,SAAS;gBADf,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,SAAS;IAGjC,oFAAoF;IAC7E,IAAI,IAAI,IAAI;IAKnB;;;;;;;;;OASG;IACI,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAS7C"}

package/dist/esm/binding/PhysicsBinding.js

@@ -1,25 +1,50 @@
-import { MathUtils } from '@codexo/exojs';
+import { radiansToDegrees } from "@codexo/exojs";
 
+//#region src/binding/PhysicsBinding.ts
 /**
- * A link between a {@link PhysicsBody} and a {@link SceneNode}. After each
- * {@link PhysicsWorld.step}, the body's world position **and rotation** are
- * written onto the node (the body's angle is radians; the node's rotation is
- * degrees). The node must be world-space-rooted; runtime scale is ignored and
- * non-zero skew is rejected at bind time.
- */
-class PhysicsBinding {
-    body;
-    node;
-    constructor(body, node) {
-        this.body = body;
-        this.node = node;
-    }
-    /** Write the body's current transform (position + rotation) onto the bound node. */
-    sync() {
-        this.node.setPosition(this.body.x, this.body.y);
-        this.node.setRotation(MathUtils.radiansToDegrees(this.body.angle));
-    }
-}
+* A link between a {@link PhysicsBody} and a {@link SceneNode}. The body's world
+* position **and rotation** are written onto the node (the body's angle is
+* radians; the node's rotation is degrees). The node must be world-space-rooted;
+* runtime scale is ignored and non-zero skew is rejected at bind time.
+*
+* By default the node snaps to the latest fixed-step state after each step. With
+* `PhysicsWorld`'s interpolation enabled the node is instead placed between the
+* body's previous and current fixed states, which smooths motion when the fixed
+* rate is below the frame rate. Either way this is presentation: nothing written
+* onto the node is read back into the simulation.
+*/
+var PhysicsBinding = class {
+	body;
+	node;
+	constructor(body, node) {
+		this.body = body;
+		this.node = node;
+	}
+	/** Write the body's current transform (position + rotation) onto the bound node. */
+	sync() {
+		this.node.setPosition(this.body.x, this.body.y);
+		this.node.setRotation(radiansToDegrees(this.body.angle));
+	}
+	/**
+	* Place the node `alpha` of the way from the body's previous fixed state to
+	* its current one. `alpha` is the host's leftover sub-step fraction, so `0`
+	* renders the state the last fixed step started from and values approaching
+	* `1` render the state it produced.
+	*
+	* A plain lerp is correct for the angle too: body angles are continuous and
+	* unbounded, never wrapped into a range, so there is no shortest-arc case to
+	* resolve.
+	*/
+	syncInterpolated(alpha) {
+		const body = this.body;
+		const previousX = body.previousX;
+		const previousY = body.previousY;
+		const previousAngle = body.previousAngle;
+		this.node.setPosition(previousX + (body.x - previousX) * alpha, previousY + (body.y - previousY) * alpha);
+		this.node.setRotation(radiansToDegrees(previousAngle + (body.angle - previousAngle) * alpha));
+	}
+};
 
+//#endregion
 export { PhysicsBinding };
-//# sourceMappingURL=PhysicsBinding.js.map
+//# sourceMappingURL=PhysicsBinding.js.map

package/dist/esm/binding/PhysicsBinding.js.map

@@ -1 +1 @@
-{"version":3,"file":"PhysicsBinding.js","sources":["../../../../src/binding/PhysicsBinding.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;AAMG;MACU,cAAc,CAAA;AAEP,IAAA,IAAA;AACA,IAAA,IAAA;IAFlB,WAAA,CACkB,IAAiB,EACjB,IAAe,EAAA;QADf,IAAA,CAAA,IAAI,GAAJ,IAAI;QACJ,IAAA,CAAA,IAAI,GAAJ,IAAI;IACnB;;IAGI,IAAI,GAAA;AACT,QAAA,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;AAC/C,QAAA,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACpE;AACD;;;;"}
+{"version":3,"file":"PhysicsBinding.js","names":[],"sources":["../../../src/binding/PhysicsBinding.ts"],"sourcesContent":["import { radiansToDegrees, type SceneNode } from '@codexo/exojs';\n\nimport type { PhysicsBody } from '../PhysicsBody';\n\n/**\n * A link between a {@link PhysicsBody} and a {@link SceneNode}. The body's world\n * position **and rotation** are written onto the node (the body's angle is\n * radians; the node's rotation is degrees). The node must be world-space-rooted;\n * runtime scale is ignored and non-zero skew is rejected at bind time.\n *\n * By default the node snaps to the latest fixed-step state after each step. With\n * `PhysicsWorld`'s interpolation enabled the node is instead placed between the\n * body's previous and current fixed states, which smooths motion when the fixed\n * rate is below the frame rate. Either way this is presentation: nothing written\n * onto the node is read back into the simulation.\n */\nexport class PhysicsBinding {\n  public constructor(\n    public readonly body: PhysicsBody,\n    public readonly node: SceneNode,\n  ) {}\n\n  /** Write the body's current transform (position + rotation) onto the bound node. */\n  public sync(): void {\n    this.node.setPosition(this.body.x, this.body.y);\n    this.node.setRotation(radiansToDegrees(this.body.angle));\n  }\n\n  /**\n   * Place the node `alpha` of the way from the body's previous fixed state to\n   * its current one. `alpha` is the host's leftover sub-step fraction, so `0`\n   * renders the state the last fixed step started from and values approaching\n   * `1` render the state it produced.\n   *\n   * A plain lerp is correct for the angle too: body angles are continuous and\n   * unbounded, never wrapped into a range, so there is no shortest-arc case to\n   * resolve.\n   */\n  public syncInterpolated(alpha: number): void {\n    const body = this.body;\n    const previousX = body.previousX;\n    const previousY = body.previousY;\n    const previousAngle = body.previousAngle;\n\n    this.node.setPosition(previousX + (body.x - previousX) * alpha, previousY + (body.y - previousY) * alpha);\n    this.node.setRotation(radiansToDegrees(previousAngle + (body.angle - previousAngle) * alpha));\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAgBA,IAAa,iBAAb,MAA4B;CAER;CACA;CAFlB,AAAO,YACL,AAAgB,MAChB,AAAgB,MAChB;EAFgB;EACA;CACf;;CAGH,AAAO,OAAa;EAClB,KAAK,KAAK,YAAY,KAAK,KAAK,GAAG,KAAK,KAAK,CAAC;EAC9C,KAAK,KAAK,YAAY,iBAAiB,KAAK,KAAK,KAAK,CAAC;CACzD;;;;;;;;;;;CAYA,AAAO,iBAAiB,OAAqB;EAC3C,MAAM,OAAO,KAAK;EAClB,MAAM,YAAY,KAAK;EACvB,MAAM,YAAY,KAAK;EACvB,MAAM,gBAAgB,KAAK;EAE3B,KAAK,KAAK,YAAY,aAAa,KAAK,IAAI,aAAa,OAAO,aAAa,KAAK,IAAI,aAAa,KAAK;EACxG,KAAK,KAAK,YAAY,iBAAiB,iBAAiB,KAAK,QAAQ,iBAAiB,KAAK,CAAC;CAC9F;AACF"}

package/dist/esm/broadphase/AabbTreeBroadPhase.d.ts

@@ -0,0 +1,68 @@
+import type { AabbLike } from '@codexo/exojs';
+import type { Collider } from '../Collider';
+import type { SpatialIndex } from '../query/SpatialIndex';
+import type { BroadPhase, CandidatePair } from './BroadPhase';
+/**
+ * Dynamic-AABB-tree broad phase (Box2D-style), wrapping a generic
+ * `DynamicAabbTree<Collider>`. Stateful across steps: a collider whose tight
+ * AABB stays inside its stored fat AABB costs nothing to re-sync.
+ *
+ * Three phases per `computePairs` call: (1) sync every live collider (insert
+ * new ones, reinsert moved ones, querying only around reinsertions to discover
+ * NEW fat-overlap candidates); (2) one full pass over the persistent pair set
+ * dropping any pair whose fat AABBs no longer overlap - cheap (O(1) per pair)
+ * and run every step regardless of movement, exactly mirroring Box2D's own
+ * `b2ContactManager::Collide` (see the design's correctness argument for why a
+ * single global pass, not a per-moved-leaf rescan, is both correct and the
+ * right complexity); (3) emit, keeping only pairs whose *tight* AABBs overlap.
+ *
+ * The persistent set is intentionally keyed on *fat* overlap so temporal
+ * coherence carries across steps (a leaf that stays inside its fat AABB is
+ * never re-discovered). Emitting is filtered to tight-AABB overlap so the
+ * candidate set the caller sees is exact - the fat margin never leaks a false
+ * positive downstream, and a fat-but-not-tight pair simply stays parked in the
+ * set (costing one O(1) re-check per step) until the leaves separate.
+ *
+ * **Single-owner contract.** A collider's tree membership is tracked through its
+ * `Collider._treeProxy` field, which - like `PhysicsBody._islandIndex` /
+ * `_sleepTime` - is a single slot on the shared object. Exactly ONE
+ * `AabbTreeBroadPhase` instance may track a given collider at a time (in
+ * production that is the world's own `_broadPhase`, for the collider's whole
+ * lifetime until `removeCollider`). Do NOT stand up a second, throwaway
+ * `AabbTreeBroadPhase` over colliders another instance already owns (e.g. for
+ * debug visualization): the second instance would clobber the first's
+ * `_treeProxy` values and corrupt its tree. Use a plain brute-force scan for
+ * such one-off, read-only needs instead.
+ */
+export declare class AabbTreeBroadPhase implements BroadPhase, SpatialIndex {
+    private readonly _tree;
+    private readonly _pairs;
+    private readonly _scratchFatAabb;
+    private _syncingCollider;
+    private _syncingProxy;
+    private readonly _onNeighborFound;
+    private readonly _dropIfStale;
+    private _collectTarget;
+    private readonly _collectPair;
+    private _queryTarget;
+    private readonly _onQueryHit;
+    private readonly _resetTreeProxy;
+    computePairs(colliders: readonly Collider[], out: CandidatePair[]): CandidatePair[];
+    /**
+     * Insert every not-yet-tracked collider and reinsert every moved one (the
+     * `computePairs` phase-1 loop, extracted so {@link queryAabb} callers can
+     * force it independently of a full detection pass - see {@link SpatialIndex.sync}).
+     */
+    sync(colliders: readonly Collider[]): void;
+    /** Colliders whose AABB overlaps `aabb`. Writes into `out` (cleared first) and returns it. */
+    queryAabb(aabb: Readonly<AabbLike>, out: Collider[]): Collider[];
+    /** Colliders whose AABB the ray could cross within `maxDistance`, via the tree's own ray-cast prune. */
+    rayCast(originX: number, originY: number, dirX: number, dirY: number, maxDistance: number, callback: (collider: Collider) => void): void;
+    /** Drop `collider`'s leaf and every pair referencing it. Called when a collider is destroyed. */
+    removeCollider(collider: Collider): void;
+    destroy(): void;
+    private _sync;
+    private _discoverNeighbors;
+    private _addPair;
+}
+//# sourceMappingURL=AabbTreeBroadPhase.d.ts.map

package/dist/esm/broadphase/AabbTreeBroadPhase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AabbTreeBroadPhase.d.ts","sourceRoot":"","sources":["../../../src/broadphase/AabbTreeBroadPhase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAI9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAe9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,kBAAmB,YAAW,UAAU,EAAE,YAAY;IACjE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8C;IACpE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoC;IAC3D,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAoD;IAEpF,OAAO,CAAC,gBAAgB,CAAyB;IACjD,OAAO,CAAC,aAAa,CAAM;IAC3B,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAM/B;IAEF,OAAO,CAAC,QAAQ,CAAC,YAAY,CAI3B;IAEF,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAM3B;IAEF,OAAO,CAAC,YAAY,CAAkB;IACtC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAE1B;IAEF,OAAO,CAAC,QAAQ,CAAC,eAAe,CAE9B;IAEK,YAAY,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,EAAE,GAAG,EAAE,aAAa,EAAE,GAAG,aAAa,EAAE;IAa1F;;;;OAIG;IACI,IAAI,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,GAAG,IAAI;IAMjD,8FAA8F;IACvF,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE;IAQvE,wGAAwG;IACjG,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,GAAG,IAAI;IAI/I,iGAAiG;IAC1F,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAexC,OAAO,IAAI,IAAI;IAYtB,OAAO,CAAC,KAAK;IAiBb,OAAO,CAAC,kBAAkB;IAS1B,OAAO,CAAC,QAAQ;CAiBjB"}

package/dist/esm/broadphase/AabbTreeBroadPhase.js

@@ -0,0 +1,149 @@
+import { aabbOverlap } from "../Aabb.js";
+import { sortInPlace } from "../sort.js";
+import { pairKey } from "../ContactGraph.js";
+import { DynamicAabbTree } from "@codexo/exojs";
+
+//#region src/broadphase/AabbTreeBroadPhase.ts
+/**
+* Fixed fat-AABB margin (world px) applied to every collider's tree leaf.
+* Chosen relative to the engine's typical small-collider scale (test/example
+* shapes commonly span 10-30px): large enough that a few steps of ordinary
+* motion stay inside the margin (skipping the sync phase's remove+reinsert),
+* small enough it doesn't inflate fat AABBs into spurious candidates for
+* densely packed scenes. Fixed per the design's v1 scope (no velocity-based
+* predictive expansion) - revisit if benchmarks want a different value.
+*/
+const AABB_MARGIN = 4;
+const byPairId = (p, q) => p.a.id - q.a.id || p.b.id - q.b.id;
+/**
+* Dynamic-AABB-tree broad phase (Box2D-style), wrapping a generic
+* `DynamicAabbTree<Collider>`. Stateful across steps: a collider whose tight
+* AABB stays inside its stored fat AABB costs nothing to re-sync.
+*
+* Three phases per `computePairs` call: (1) sync every live collider (insert
+* new ones, reinsert moved ones, querying only around reinsertions to discover
+* NEW fat-overlap candidates); (2) one full pass over the persistent pair set
+* dropping any pair whose fat AABBs no longer overlap - cheap (O(1) per pair)
+* and run every step regardless of movement, exactly mirroring Box2D's own
+* `b2ContactManager::Collide` (see the design's correctness argument for why a
+* single global pass, not a per-moved-leaf rescan, is both correct and the
+* right complexity); (3) emit, keeping only pairs whose *tight* AABBs overlap.
+*
+* The persistent set is intentionally keyed on *fat* overlap so temporal
+* coherence carries across steps (a leaf that stays inside its fat AABB is
+* never re-discovered). Emitting is filtered to tight-AABB overlap so the
+* candidate set the caller sees is exact - the fat margin never leaks a false
+* positive downstream, and a fat-but-not-tight pair simply stays parked in the
+* set (costing one O(1) re-check per step) until the leaves separate.
+*
+* **Single-owner contract.** A collider's tree membership is tracked through its
+* `Collider._treeProxy` field, which - like `PhysicsBody._islandIndex` /
+* `_sleepTime` - is a single slot on the shared object. Exactly ONE
+* `AabbTreeBroadPhase` instance may track a given collider at a time (in
+* production that is the world's own `_broadPhase`, for the collider's whole
+* lifetime until `removeCollider`). Do NOT stand up a second, throwaway
+* `AabbTreeBroadPhase` over colliders another instance already owns (e.g. for
+* debug visualization): the second instance would clobber the first's
+* `_treeProxy` values and corrupt its tree. Use a plain brute-force scan for
+* such one-off, read-only needs instead.
+*/
+var AabbTreeBroadPhase = class {
+	_tree = new DynamicAabbTree(AABB_MARGIN);
+	_pairs = /* @__PURE__ */ new Map();
+	_scratchFatAabb = {
+		minX: 0,
+		minY: 0,
+		maxX: 0,
+		maxY: 0
+	};
+	_syncingCollider = null;
+	_syncingProxy = -1;
+	_onNeighborFound = (payload, proxy) => {
+		if (proxy === this._syncingProxy) return;
+		this._addPair(this._syncingCollider, payload);
+	};
+	_dropIfStale = (pair, key) => {
+		if (!this._tree.fatOverlaps(pair.a._treeProxy, pair.b._treeProxy)) this._pairs.delete(key);
+	};
+	_collectTarget = [];
+	_collectPair = (pair) => {
+		if (aabbOverlap(pair.a.aabb, pair.b.aabb)) this._collectTarget.push(pair);
+	};
+	_queryTarget = [];
+	_onQueryHit = (payload) => {
+		this._queryTarget.push(payload);
+	};
+	_resetTreeProxy = (payload) => {
+		payload._treeProxy = -1;
+	};
+	computePairs(colliders, out) {
+		this.sync(colliders);
+		this._pairs.forEach(this._dropIfStale);
+		out.length = 0;
+		this._collectTarget = out;
+		this._pairs.forEach(this._collectPair);
+		sortInPlace(out, byPairId);
+		return out;
+	}
+	/**
+	* Insert every not-yet-tracked collider and reinsert every moved one (the
+	* `computePairs` phase-1 loop, extracted so {@link queryAabb} callers can
+	* force it independently of a full detection pass - see {@link SpatialIndex.sync}).
+	*/
+	sync(colliders) {
+		for (const collider of colliders) this._sync(collider);
+	}
+	/** Colliders whose AABB overlaps `aabb`. Writes into `out` (cleared first) and returns it. */
+	queryAabb(aabb, out) {
+		out.length = 0;
+		this._queryTarget = out;
+		this._tree.query(aabb.minX, aabb.minY, aabb.maxX, aabb.maxY, this._onQueryHit);
+		return out;
+	}
+	/** Colliders whose AABB the ray could cross within `maxDistance`, via the tree's own ray-cast prune. */
+	rayCast(originX, originY, dirX, dirY, maxDistance, callback) {
+		this._tree.rayCast(originX, originY, dirX, dirY, maxDistance, callback);
+	}
+	/** Drop `collider`'s leaf and every pair referencing it. Called when a collider is destroyed. */
+	removeCollider(collider) {
+		if (collider._treeProxy === -1) return;
+		this._tree.remove(collider._treeProxy);
+		collider._treeProxy = -1;
+		for (const [key, pair] of this._pairs) if (pair.a === collider || pair.b === collider) this._pairs.delete(key);
+	}
+	destroy() {
+		this._tree.query(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, this._resetTreeProxy);
+		this._tree.destroy();
+		this._pairs.clear();
+	}
+	_sync(collider) {
+		const box = collider.aabb;
+		if (collider._treeProxy === -1) {
+			collider._treeProxy = this._tree.insert(box.minX, box.minY, box.maxX, box.maxY, collider);
+			this._discoverNeighbors(collider);
+			return;
+		}
+		if (this._tree.update(collider._treeProxy, box.minX, box.minY, box.maxX, box.maxY)) this._discoverNeighbors(collider);
+	}
+	_discoverNeighbors(collider) {
+		const proxy = collider._treeProxy;
+		const fat = this._tree.fatAabbOf(proxy, this._scratchFatAabb);
+		this._syncingCollider = collider;
+		this._syncingProxy = proxy;
+		this._tree.query(fat.minX, fat.minY, fat.maxX, fat.maxY, this._onNeighborFound);
+	}
+	_addPair(a, b) {
+		if (a.body === b.body) return;
+		const lo = a.id < b.id ? a : b;
+		const hi = a.id < b.id ? b : a;
+		const key = pairKey(lo.id, hi.id);
+		if (!this._pairs.has(key)) this._pairs.set(key, {
+			a: lo,
+			b: hi
+		});
+	}
+};
+
+//#endregion
+export { AabbTreeBroadPhase };
+//# sourceMappingURL=AabbTreeBroadPhase.js.map

package/dist/esm/broadphase/AabbTreeBroadPhase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AabbTreeBroadPhase.js","names":[],"sources":["../../../src/broadphase/AabbTreeBroadPhase.ts"],"sourcesContent":["import type { AabbLike } from '@codexo/exojs';\nimport { DynamicAabbTree } from '@codexo/exojs';\n\nimport { aabbOverlap } from '../Aabb';\nimport type { Collider } from '../Collider';\nimport { pairKey } from '../ContactGraph';\nimport type { SpatialIndex } from '../query/SpatialIndex';\nimport { sortInPlace } from '../sort';\nimport type { BroadPhase, CandidatePair } from './BroadPhase';\n\n/**\n * Fixed fat-AABB margin (world px) applied to every collider's tree leaf.\n * Chosen relative to the engine's typical small-collider scale (test/example\n * shapes commonly span 10-30px): large enough that a few steps of ordinary\n * motion stay inside the margin (skipping the sync phase's remove+reinsert),\n * small enough it doesn't inflate fat AABBs into spurious candidates for\n * densely packed scenes. Fixed per the design's v1 scope (no velocity-based\n * predictive expansion) - revisit if benchmarks want a different value.\n */\nconst AABB_MARGIN = 4;\n\nconst byPairId = (p: CandidatePair, q: CandidatePair): number => p.a.id - q.a.id || p.b.id - q.b.id;\n\n/**\n * Dynamic-AABB-tree broad phase (Box2D-style), wrapping a generic\n * `DynamicAabbTree<Collider>`. Stateful across steps: a collider whose tight\n * AABB stays inside its stored fat AABB costs nothing to re-sync.\n *\n * Three phases per `computePairs` call: (1) sync every live collider (insert\n * new ones, reinsert moved ones, querying only around reinsertions to discover\n * NEW fat-overlap candidates); (2) one full pass over the persistent pair set\n * dropping any pair whose fat AABBs no longer overlap - cheap (O(1) per pair)\n * and run every step regardless of movement, exactly mirroring Box2D's own\n * `b2ContactManager::Collide` (see the design's correctness argument for why a\n * single global pass, not a per-moved-leaf rescan, is both correct and the\n * right complexity); (3) emit, keeping only pairs whose *tight* AABBs overlap.\n *\n * The persistent set is intentionally keyed on *fat* overlap so temporal\n * coherence carries across steps (a leaf that stays inside its fat AABB is\n * never re-discovered). Emitting is filtered to tight-AABB overlap so the\n * candidate set the caller sees is exact - the fat margin never leaks a false\n * positive downstream, and a fat-but-not-tight pair simply stays parked in the\n * set (costing one O(1) re-check per step) until the leaves separate.\n *\n * **Single-owner contract.** A collider's tree membership is tracked through its\n * `Collider._treeProxy` field, which - like `PhysicsBody._islandIndex` /\n * `_sleepTime` - is a single slot on the shared object. Exactly ONE\n * `AabbTreeBroadPhase` instance may track a given collider at a time (in\n * production that is the world's own `_broadPhase`, for the collider's whole\n * lifetime until `removeCollider`). Do NOT stand up a second, throwaway\n * `AabbTreeBroadPhase` over colliders another instance already owns (e.g. for\n * debug visualization): the second instance would clobber the first's\n * `_treeProxy` values and corrupt its tree. Use a plain brute-force scan for\n * such one-off, read-only needs instead.\n */\nexport class AabbTreeBroadPhase implements BroadPhase, SpatialIndex {\n  private readonly _tree = new DynamicAabbTree<Collider>(AABB_MARGIN);\n  private readonly _pairs = new Map<number, CandidatePair>();\n  private readonly _scratchFatAabb: AabbLike = { minX: 0, minY: 0, maxX: 0, maxY: 0 };\n\n  private _syncingCollider: Collider | null = null;\n  private _syncingProxy = -1;\n  private readonly _onNeighborFound = (payload: Collider, proxy: number): void => {\n    if (proxy === this._syncingProxy) {\n      return;\n    }\n\n    this._addPair(this._syncingCollider!, payload);\n  };\n\n  private readonly _dropIfStale = (pair: CandidatePair, key: number): void => {\n    if (!this._tree.fatOverlaps(pair.a._treeProxy, pair.b._treeProxy)) {\n      this._pairs.delete(key);\n    }\n  };\n\n  private _collectTarget: CandidatePair[] = [];\n  private readonly _collectPair = (pair: CandidatePair): void => {\n    // Emit only true (tight-AABB) overlaps; the persistent set is fat-keyed for\n    // coherence, so a fat-but-not-tight pair is parked here, not a candidate.\n    if (aabbOverlap(pair.a.aabb, pair.b.aabb)) {\n      this._collectTarget.push(pair);\n    }\n  };\n\n  private _queryTarget: Collider[] = [];\n  private readonly _onQueryHit = (payload: Collider): void => {\n    this._queryTarget.push(payload);\n  };\n\n  private readonly _resetTreeProxy = (payload: Collider): void => {\n    payload._treeProxy = -1;\n  };\n\n  public computePairs(colliders: readonly Collider[], out: CandidatePair[]): CandidatePair[] {\n    this.sync(colliders);\n\n    this._pairs.forEach(this._dropIfStale);\n\n    out.length = 0;\n    this._collectTarget = out;\n    this._pairs.forEach(this._collectPair);\n    sortInPlace(out, byPairId);\n\n    return out;\n  }\n\n  /**\n   * Insert every not-yet-tracked collider and reinsert every moved one (the\n   * `computePairs` phase-1 loop, extracted so {@link queryAabb} callers can\n   * force it independently of a full detection pass - see {@link SpatialIndex.sync}).\n   */\n  public sync(colliders: readonly Collider[]): void {\n    for (const collider of colliders) {\n      this._sync(collider);\n    }\n  }\n\n  /** Colliders whose AABB overlaps `aabb`. Writes into `out` (cleared first) and returns it. */\n  public queryAabb(aabb: Readonly<AabbLike>, out: Collider[]): Collider[] {\n    out.length = 0;\n    this._queryTarget = out;\n    this._tree.query(aabb.minX, aabb.minY, aabb.maxX, aabb.maxY, this._onQueryHit);\n\n    return out;\n  }\n\n  /** Colliders whose AABB the ray could cross within `maxDistance`, via the tree's own ray-cast prune. */\n  public rayCast(originX: number, originY: number, dirX: number, dirY: number, maxDistance: number, callback: (collider: Collider) => void): void {\n    this._tree.rayCast(originX, originY, dirX, dirY, maxDistance, callback);\n  }\n\n  /** Drop `collider`'s leaf and every pair referencing it. Called when a collider is destroyed. */\n  public removeCollider(collider: Collider): void {\n    if (collider._treeProxy === -1) {\n      return;\n    }\n\n    this._tree.remove(collider._treeProxy);\n    collider._treeProxy = -1;\n\n    for (const [key, pair] of this._pairs) {\n      if (pair.a === collider || pair.b === collider) {\n        this._pairs.delete(key);\n      }\n    }\n  }\n\n  public destroy(): void {\n    // Reset `_treeProxy` on every still-tracked collider before tearing down the\n    // tree: the single-owner contract only guarantees at most one owner AT A\n    // TIME, so a collider handed to a later `AabbTreeBroadPhase` (sequential\n    // reuse, not concurrent dual-ownership) must not carry a stale non-`-1`\n    // proxy from this instance forward. `query` with infinite bounds visits\n    // every leaf currently in the tree, allocation-free.\n    this._tree.query(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, this._resetTreeProxy);\n    this._tree.destroy();\n    this._pairs.clear();\n  }\n\n  private _sync(collider: Collider): void {\n    const box = collider.aabb;\n\n    if (collider._treeProxy === -1) {\n      collider._treeProxy = this._tree.insert(box.minX, box.minY, box.maxX, box.maxY, collider);\n      this._discoverNeighbors(collider);\n\n      return;\n    }\n\n    const moved = this._tree.update(collider._treeProxy, box.minX, box.minY, box.maxX, box.maxY);\n\n    if (moved) {\n      this._discoverNeighbors(collider);\n    }\n  }\n\n  private _discoverNeighbors(collider: Collider): void {\n    const proxy = collider._treeProxy;\n    const fat = this._tree.fatAabbOf(proxy, this._scratchFatAabb);\n\n    this._syncingCollider = collider;\n    this._syncingProxy = proxy;\n    this._tree.query(fat.minX, fat.minY, fat.maxX, fat.maxY, this._onNeighborFound);\n  }\n\n  private _addPair(a: Collider, b: Collider): void {\n    // Two colliders of the same body are a compound shape, not a collision.\n    // Rejecting the pair here rather than downstream also keeps it out of the\n    // persistent set, so a compound body costs nothing per step - which matters\n    // once convex decomposition attaches many edge-sharing colliders to one body.\n    if (a.body === b.body) {\n      return;\n    }\n\n    const lo = a.id < b.id ? a : b;\n    const hi = a.id < b.id ? b : a;\n    const key = pairKey(lo.id, hi.id);\n\n    if (!this._pairs.has(key)) {\n      this._pairs.set(key, { a: lo, b: hi });\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/esm/broadphase/BroadPhase.d.ts

@@ -7,10 +7,12 @@ export interface CandidatePair {
 /**
  * Broad-phase contract: reduce the O(n²) all-pairs test to a candidate set of
  * AABB-overlapping pairs. The candidate set must contain **every** truly
- * overlapping pair (zero false negatives, gate B-3); false positives are
- * resolved by the narrow phase. This interface is the seam behind which the MVP
- * ships {@link SweepAndPrune} and a future dynamic-AABB-tree can be swapped in
- * without touching callers.
+ * overlapping pair of colliders on *different* bodies (zero false negatives);
+ * false positives are resolved by the narrow phase. Two colliders of the same
+ * body form a compound shape and must never be paired. This interface is the
+ * seam behind which broad-phase implementations (currently the
+ * dynamic-AABB-tree-backed `AabbTreeBroadPhase`) can be swapped without
+ * touching callers.
  */
 export interface BroadPhase {
     /**
@@ -20,3 +22,4 @@ export interface BroadPhase {
      */
     computePairs(colliders: readonly Collider[], out: CandidatePair[]): CandidatePair[];
 }
+//# sourceMappingURL=BroadPhase.d.ts.map

package/dist/esm/broadphase/BroadPhase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BroadPhase.d.ts","sourceRoot":"","sources":["../../../src/broadphase/BroadPhase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,yFAAyF;AACzF,MAAM,WAAW,aAAa;IAC5B,CAAC,EAAE,QAAQ,CAAC;IACZ,CAAC,EAAE,QAAQ,CAAC;CACb;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IACzB;;;;OAIG;IACH,YAAY,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,EAAE,GAAG,EAAE,aAAa,EAAE,GAAG,aAAa,EAAE,CAAC;CACrF"}

package/dist/esm/broadphase/index.d.ts

@@ -1,2 +1,3 @@
+export { AabbTreeBroadPhase } from './AabbTreeBroadPhase';
 export type { BroadPhase, CandidatePair } from './BroadPhase';
-export { SweepAndPrune } from './SweepAndPrune';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/broadphase/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/broadphase/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}

package/dist/esm/collision/CollisionProxy.d.ts

@@ -1,4 +1,4 @@
-import type { Mutable2D } from '../math';
+import type { PointLike } from '@codexo/exojs';
 import type { AnyShape } from '../shapes/AnyShape';
 /**
  * The geometric surface the narrow phase needs: a shape plus its cached world
@@ -8,7 +8,8 @@ import type { AnyShape } from '../shapes/AnyShape';
  */
 export interface CollisionProxy {
     readonly shape: AnyShape;
-    readonly worldCenter: Readonly<Mutable2D>;
+    readonly worldCenter: Readonly<PointLike>;
     readonly worldVertices: readonly number[];
     readonly worldNormals: readonly number[];
 }
+//# sourceMappingURL=CollisionProxy.d.ts.map

package/dist/esm/collision/CollisionProxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollisionProxy.d.ts","sourceRoot":"","sources":["../../../src/collision/CollisionProxy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC1C,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C"}