@codexo/exojs-physics 0.13.0

package/dist/esm/TimeStepper.js

@@ -0,0 +1,70 @@
+/**
+ * Fixed-timestep accumulator (package-owned; no engine clock dependency). Each
+ * frame, {@link advance} adds the variable frame delta to an internal
+ * accumulator and reports how many whole fixed sub-steps to run
+ * (`floor(accumulator / fixedDelta)`), clamped to {@link maxSubSteps}. When the
+ * clamp trips, the backlog beyond the clamp is discarded so a slow frame cannot
+ * cascade into an unbounded catch-up (the "spiral of death").
+ *
+ * {@link alpha} is the leftover fraction of a step `[0, 1)`, for interpolating
+ * bound transforms between sub-steps.
+ *
+ * The stepper holds no mutable module-level state — two stepper instances are
+ * fully independent (world isolation, gate I-1).
+ */
+class TimeStepper {
+    fixedDelta;
+    maxSubSteps;
+    _accumulator = 0;
+    constructor(options = {}) {
+        const fixedDelta = options.fixedDelta ?? 1 / 60;
+        const maxSubSteps = options.maxSubSteps ?? 8;
+        if (!Number.isFinite(fixedDelta) || fixedDelta <= 0) {
+            throw new RangeError(`TimeStepper: fixedDelta must be a positive finite number, received ${fixedDelta}.`);
+        }
+        if (!Number.isInteger(maxSubSteps) || maxSubSteps < 1) {
+            throw new RangeError(`TimeStepper: maxSubSteps must be an integer ≥ 1, received ${maxSubSteps}.`);
+        }
+        this.fixedDelta = fixedDelta;
+        this.maxSubSteps = maxSubSteps;
+    }
+    /** Unconsumed accumulated time (seconds) currently held, always `< fixedDelta` after an `advance`. */
+    get accumulator() {
+        return this._accumulator;
+    }
+    /** Interpolation fraction in `[0, 1)` = `accumulator / fixedDelta`. */
+    get alpha() {
+        return Math.min(1, Math.max(0, this._accumulator / this.fixedDelta));
+    }
+    /**
+     * Accumulate `frameDeltaSeconds` and return the number of fixed sub-steps to
+     * run this frame. Non-finite or non-positive deltas contribute nothing and
+     * return `0`.
+     */
+    advance(frameDeltaSeconds) {
+        if (!Number.isFinite(frameDeltaSeconds) || frameDeltaSeconds <= 0) {
+            return 0;
+        }
+        this._accumulator += frameDeltaSeconds;
+        let steps = Math.floor(this._accumulator / this.fixedDelta);
+        if (steps <= 0) {
+            return 0;
+        }
+        if (steps > this.maxSubSteps) {
+            steps = this.maxSubSteps;
+        }
+        this._accumulator -= steps * this.fixedDelta;
+        // Discard any backlog beyond the clamp, keeping only the sub-frame remainder.
+        if (this._accumulator >= this.fixedDelta) {
+            this._accumulator %= this.fixedDelta;
+        }
+        return steps;
+    }
+    /** Clear the accumulator (e.g. after a teleport or a pause). */
+    reset() {
+        this._accumulator = 0;
+    }
+}
+
+export { TimeStepper };
+//# sourceMappingURL=TimeStepper.js.map

package/dist/esm/TimeStepper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimeStepper.js","sources":["../../../src/TimeStepper.ts"],"sourcesContent":[null],"names":[],"mappings":"AAQA;;;;;;;;;;;;;AAaG;MACU,WAAW,CAAA;AACN,IAAA,UAAU;AACV,IAAA,WAAW;IAEnB,YAAY,GAAG,CAAC;AAExB,IAAA,WAAA,CAAmB,UAA8B,EAAE,EAAA;QACjD,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,CAAC,GAAG,EAAE;AAC/C,QAAA,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,CAAC;AAE5C,QAAA,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,UAAU,IAAI,CAAC,EAAE;AACnD,YAAA,MAAM,IAAI,UAAU,CAAC,sEAAsE,UAAU,CAAA,CAAA,CAAG,CAAC;QAC3G;AAEA,QAAA,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,WAAW,GAAG,CAAC,EAAE;AACrD,YAAA,MAAM,IAAI,UAAU,CAAC,6DAA6D,WAAW,CAAA,CAAA,CAAG,CAAC;QACnG;AAEA,QAAA,IAAI,CAAC,UAAU,GAAG,UAAU;AAC5B,QAAA,IAAI,CAAC,WAAW,GAAG,WAAW;IAChC;;AAGA,IAAA,IAAW,WAAW,GAAA;QACpB,OAAO,IAAI,CAAC,YAAY;IAC1B;;AAGA,IAAA,IAAW,KAAK,GAAA;QACd,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC;IACtE;AAEA;;;;AAIG;AACI,IAAA,OAAO,CAAC,iBAAyB,EAAA;AACtC,QAAA,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAC,IAAI,iBAAiB,IAAI,CAAC,EAAE;AACjE,YAAA,OAAO,CAAC;QACV;AAEA,QAAA,IAAI,CAAC,YAAY,IAAI,iBAAiB;AAEtC,QAAA,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC;AAE3D,QAAA,IAAI,KAAK,IAAI,CAAC,EAAE;AACd,YAAA,OAAO,CAAC;QACV;AAEA,QAAA,IAAI,KAAK,GAAG,IAAI,CAAC,WAAW,EAAE;AAC5B,YAAA,KAAK,GAAG,IAAI,CAAC,WAAW;QAC1B;QAEA,IAAI,CAAC,YAAY,IAAI,KAAK,GAAG,IAAI,CAAC,UAAU;;QAG5C,IAAI,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,UAAU,EAAE;AACxC,YAAA,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,UAAU;QACtC;AAEA,QAAA,OAAO,KAAK;IACd;;IAGO,KAAK,GAAA;AACV,QAAA,IAAI,CAAC,YAAY,GAAG,CAAC;IACvB;AACD;;;;"}

package/dist/esm/backend/NativePhysicsBackend.d.ts

@@ -0,0 +1,19 @@
+import type { CandidatePair } from '../broadphase/BroadPhase';
+import type { Collider } from '../Collider';
+import { ContactGraph } from '../ContactGraph';
+import type { PhysicsBackend } from './PhysicsBackend';
+/**
+ * The native, dependency-free backend: a {@link BroadPhase} (sweep-and-prune in
+ * the MVP, swappable for a dynamic AABB tree later) feeding the
+ * {@link ContactGraph} that diffs touching pairs into events. The dynamics
+ * solver plugs in here in a later phase without changing the frontend.
+ */
+export declare class NativePhysicsBackend implements PhysicsBackend {
+    readonly contactGraph: ContactGraph;
+    private readonly _broadPhase;
+    private readonly _pairs;
+    get candidatePairs(): readonly CandidatePair[];
+    detect(colliders: readonly Collider[]): void;
+    removeCollider(collider: Collider): void;
+    destroy(): void;
+}

package/dist/esm/backend/NativePhysicsBackend.js

@@ -0,0 +1,31 @@
+import { SweepAndPrune } from '../broadphase/SweepAndPrune.js';
+import { ContactGraph } from '../ContactGraph.js';
+
+/**
+ * The native, dependency-free backend: a {@link BroadPhase} (sweep-and-prune in
+ * the MVP, swappable for a dynamic AABB tree later) feeding the
+ * {@link ContactGraph} that diffs touching pairs into events. The dynamics
+ * solver plugs in here in a later phase without changing the frontend.
+ */
+class NativePhysicsBackend {
+    contactGraph = new ContactGraph();
+    _broadPhase = new SweepAndPrune();
+    _pairs = [];
+    get candidatePairs() {
+        return this._pairs;
+    }
+    detect(colliders) {
+        this._broadPhase.computePairs(colliders, this._pairs);
+        this.contactGraph.update(this._pairs);
+    }
+    removeCollider(collider) {
+        this.contactGraph.removeCollider(collider);
+    }
+    destroy() {
+        this.contactGraph.clear();
+        this._pairs.length = 0;
+    }
+}
+
+export { NativePhysicsBackend };
+//# sourceMappingURL=NativePhysicsBackend.js.map

package/dist/esm/backend/NativePhysicsBackend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativePhysicsBackend.js","sources":["../../../../src/backend/NativePhysicsBackend.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAMA;;;;;AAKG;MACU,oBAAoB,CAAA;AACf,IAAA,YAAY,GAAG,IAAI,YAAY,EAAE;AAEhC,IAAA,WAAW,GAAe,IAAI,aAAa,EAAE;IAC7C,MAAM,GAAoB,EAAE;AAE7C,IAAA,IAAW,cAAc,GAAA;QACvB,OAAO,IAAI,CAAC,MAAM;IACpB;AAEO,IAAA,MAAM,CAAC,SAA8B,EAAA;QAC1C,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC;QACrD,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;IACvC;AAEO,IAAA,cAAc,CAAC,QAAkB,EAAA;AACtC,QAAA,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,QAAQ,CAAC;IAC5C;IAEO,OAAO,GAAA;AACZ,QAAA,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE;AACzB,QAAA,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC;IACxB;AACD;;;;"}

package/dist/esm/backend/PhysicsBackend.d.ts

@@ -0,0 +1,23 @@
+import type { CandidatePair } from '../broadphase/BroadPhase';
+import type { Collider } from '../Collider';
+import type { ContactGraph } from '../ContactGraph';
+/**
+ * Internal world-level backend seam. The frontend {@link PhysicsWorld} delegates
+ * collision detection to a single backend; binding, debug draw and queries stay
+ * in the frontend so they work over any backend. In the MVP the only backend is
+ * {@link NativePhysicsBackend}. This boundary is intentionally **not** a public,
+ * stable contract — promoting it (or adding a Rapier backend) is a deliberate
+ * later decision (spec 00 §11), so it lives outside the published surface.
+ */
+export interface PhysicsBackend {
+    /** The persistent contact set, source of the begin/end/sensor events. */
+    readonly contactGraph: ContactGraph;
+    /** The latest broad-phase candidate pairs (read-only; for debug draw). */
+    readonly candidatePairs: readonly CandidatePair[];
+    /** Run one detection pass over `colliders`, refreshing the contact graph. */
+    detect(colliders: readonly Collider[]): void;
+    /** Forget any state referencing `collider` (called on destruction). */
+    removeCollider(collider: Collider): void;
+    /** Release all backend state. */
+    destroy(): void;
+}

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

@@ -0,0 +1,21 @@
+import type { SceneNode } from '@codexo/exojs';
+import type { PhysicsBody } from '../PhysicsBody';
+import type { BindingOptions } from './PhysicsBinding';
+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.
+ */
+export declare class BindingRegistry {
+    private readonly _bindings;
+    /** Link `body` to `node`. Rejects nodes with non-zero skew; runtime scale is ignored. */
+    bind(body: PhysicsBody, node: SceneNode, options?: BindingOptions): PhysicsBinding;
+    /** Remove the link for `body`, if any. */
+    unbind(body: PhysicsBody): void;
+    /** Write every bound node's transform from its body. */
+    sync(): void;
+    /** `true` when at least one binding exists. */
+    get size(): number;
+    /** Drop all links. */
+    clear(): void;
+}

package/dist/esm/binding/BindingRegistry.js

@@ -0,0 +1,40 @@
+import { PhysicsBinding } from './PhysicsBinding.js';
+
+/**
+ * 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, options) {
+        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, options?.drive ?? 'body-to-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();
+    }
+}
+
+export { BindingRegistry };
+//# sourceMappingURL=BindingRegistry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BindingRegistry.js","sources":["../../../../src/binding/BindingRegistry.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAMA;;;AAGG;MACU,eAAe,CAAA;AACT,IAAA,SAAS,GAAG,IAAI,GAAG,EAA+B;;AAG5D,IAAA,IAAI,CAAC,IAAiB,EAAE,IAAe,EAAE,OAAwB,EAAA;AACtE,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;AAEA,QAAA,MAAM,OAAO,GAAG,IAAI,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,cAAc,CAAC;QAEhF,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;;;;"}

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

@@ -0,0 +1,27 @@
+import type { SceneNode } from '@codexo/exojs';
+import type { PhysicsBody } from '../PhysicsBody';
+/** Options for {@link PhysicsWorld.bind}. */
+export interface BindingOptions {
+    /**
+     * Which way the transform flows. `'body-to-node'` (default) writes the body's
+     * transform onto the node each step — for dynamic and kinematic-position
+     * bodies. `'node-to-body'` (read the node, drive the body) is reserved for the
+     * kinematic-velocity follow-up and currently behaves like `'body-to-node'`.
+     */
+    drive?: 'body-to-node' | 'node-to-body';
+}
+/**
+ * A link between a {@link PhysicsBody} and a {@link SceneNode}. After each
+ * {@link PhysicsWorld.step}, the body's world position is written onto the node.
+ * Rotation is written once dynamics ship (a body cannot rotate under contacts in
+ * this collision/query release). The node must be world-space-rooted; runtime
+ * scale is ignored and non-zero skew is rejected at bind time.
+ */
+export declare class PhysicsBinding {
+    readonly body: PhysicsBody;
+    readonly node: SceneNode;
+    readonly drive: 'body-to-node' | 'node-to-body';
+    constructor(body: PhysicsBody, node: SceneNode, drive?: 'body-to-node' | 'node-to-body');
+    /** Write the body's current transform onto the bound node. */
+    sync(): void;
+}

package/dist/esm/binding/PhysicsBinding.js

@@ -0,0 +1,24 @@
+/**
+ * A link between a {@link PhysicsBody} and a {@link SceneNode}. After each
+ * {@link PhysicsWorld.step}, the body's world position is written onto the node.
+ * Rotation is written once dynamics ship (a body cannot rotate under contacts in
+ * this collision/query release). The node must be world-space-rooted; runtime
+ * scale is ignored and non-zero skew is rejected at bind time.
+ */
+class PhysicsBinding {
+    body;
+    node;
+    drive;
+    constructor(body, node, drive = 'body-to-node') {
+        this.body = body;
+        this.node = node;
+        this.drive = drive;
+    }
+    /** Write the body's current transform onto the bound node. */
+    sync() {
+        this.node.setPosition(this.body.x, this.body.y);
+    }
+}
+
+export { PhysicsBinding };
+//# sourceMappingURL=PhysicsBinding.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsBinding.js","sources":["../../../../src/binding/PhysicsBinding.ts"],"sourcesContent":[null],"names":[],"mappings":"AAeA;;;;;;AAMG;MACU,cAAc,CAAA;AAEP,IAAA,IAAA;AACA,IAAA,IAAA;AACA,IAAA,KAAA;AAHlB,IAAA,WAAA,CACkB,IAAiB,EACjB,IAAe,EACf,QAAyC,cAAc,EAAA;QAFvD,IAAA,CAAA,IAAI,GAAJ,IAAI;QACJ,IAAA,CAAA,IAAI,GAAJ,IAAI;QACJ,IAAA,CAAA,KAAK,GAAL,KAAK;IACpB;;IAGI,IAAI,GAAA;AACT,QAAA,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IACjD;AACD;;;;"}

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

@@ -0,0 +1,22 @@
+import type { Collider } from '../Collider';
+/** An unordered pair of colliders whose AABBs the broad phase reports as overlapping. */
+export interface CandidatePair {
+    a: Collider;
+    b: Collider;
+}
+/**
+ * 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.
+ */
+export interface BroadPhase {
+    /**
+     * Fill `out` with the candidate pairs for the current collider set and return
+     * it. Each pair is ordered `a.id < b.id`, and the array is sorted by
+     * `(a.id, b.id)` for deterministic downstream processing.
+     */
+    computePairs(colliders: readonly Collider[], out: CandidatePair[]): CandidatePair[];
+}

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

@@ -0,0 +1,14 @@
+import type { Collider } from '../Collider';
+import type { BroadPhase, CandidatePair } from './BroadPhase';
+/**
+ * Sort-and-sweep broad phase on the X axis. Each query sorts the live colliders
+ * by their AABB `minX`, then sweeps once, comparing each collider only against
+ * those whose X intervals still overlap and confirming the Y interval. This is
+ * an exact AABB-overlap broad phase (zero false negatives) with a deterministic,
+ * id-sorted output. The recompute-each-step design keeps it stateless between
+ * frames — two worlds never share sweep state (gate I-1).
+ */
+export declare class SweepAndPrune implements BroadPhase {
+    private readonly _sorted;
+    computePairs(colliders: readonly Collider[], out: CandidatePair[]): CandidatePair[];
+}

package/dist/esm/broadphase/SweepAndPrune.js

@@ -0,0 +1,48 @@
+/**
+ * Sort-and-sweep broad phase on the X axis. Each query sorts the live colliders
+ * by their AABB `minX`, then sweeps once, comparing each collider only against
+ * those whose X intervals still overlap and confirming the Y interval. This is
+ * an exact AABB-overlap broad phase (zero false negatives) with a deterministic,
+ * id-sorted output. The recompute-each-step design keeps it stateless between
+ * frames — two worlds never share sweep state (gate I-1).
+ */
+class SweepAndPrune {
+    _sorted = [];
+    computePairs(colliders, out) {
+        out.length = 0;
+        const sorted = this._sorted;
+        sorted.length = 0;
+        for (const collider of colliders) {
+            sorted.push(collider);
+        }
+        sorted.sort(byMinX);
+        const count = sorted.length;
+        for (let i = 0; i < count; i++) {
+            const a = sorted[i];
+            const aBox = a.aabb;
+            const aMaxX = aBox.maxX;
+            const aMinY = aBox.minY;
+            const aMaxY = aBox.maxY;
+            for (let j = i + 1; j < count; j++) {
+                const b = sorted[j];
+                const bBox = b.aabb;
+                // X intervals are sorted: once b starts past a's right edge, so do all
+                // later colliders — stop scanning this i.
+                if (bBox.minX > aMaxX) {
+                    break;
+                }
+                if (bBox.minY > aMaxY || bBox.maxY < aMinY) {
+                    continue;
+                }
+                out.push(a.id < b.id ? { a, b } : { a: b, b: a });
+            }
+        }
+        out.sort(byPairId);
+        return out;
+    }
+}
+const byMinX = (a, b) => a.aabb.minX - b.aabb.minX || a.id - b.id;
+const byPairId = (p, q) => p.a.id - q.a.id || p.b.id - q.b.id;
+
+export { SweepAndPrune };
+//# sourceMappingURL=SweepAndPrune.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SweepAndPrune.js","sources":["../../../../src/broadphase/SweepAndPrune.ts"],"sourcesContent":[null],"names":[],"mappings":"AAGA;;;;;;;AAOG;MACU,aAAa,CAAA;IACP,OAAO,GAAe,EAAE;IAElC,YAAY,CAAC,SAA8B,EAAE,GAAoB,EAAA;AACtE,QAAA,GAAG,CAAC,MAAM,GAAG,CAAC;AAEd,QAAA,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO;AAC3B,QAAA,MAAM,CAAC,MAAM,GAAG,CAAC;AAEjB,QAAA,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE;AAChC,YAAA,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC;QACvB;AAEA,QAAA,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;AAEnB,QAAA,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM;AAE3B,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;AAC9B,YAAA,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;AACnB,YAAA,MAAM,IAAI,GAAG,CAAC,CAAC,IAAI;AACnB,YAAA,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI;AACvB,YAAA,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI;AACvB,YAAA,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI;AAEvB,YAAA,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;AAClC,gBAAA,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;AACnB,gBAAA,MAAM,IAAI,GAAG,CAAC,CAAC,IAAI;;;AAInB,gBAAA,IAAI,IAAI,CAAC,IAAI,GAAG,KAAK,EAAE;oBACrB;gBACF;AAEA,gBAAA,IAAI,IAAI,CAAC,IAAI,GAAG,KAAK,IAAI,IAAI,CAAC,IAAI,GAAG,KAAK,EAAE;oBAC1C;gBACF;AAEA,gBAAA,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;YACnD;QACF;AAEA,QAAA,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC;AAElB,QAAA,OAAO,GAAG;IACZ;AACD;AAED,MAAM,MAAM,GAAG,CAAC,CAAW,EAAE,CAAW,KAAa,CAAC,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE;AAE7F,MAAM,QAAQ,GAAG,CAAC,CAAgB,EAAE,CAAgB,KAAa,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE;;;;"}

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

@@ -0,0 +1,2 @@
+export type { BroadPhase, CandidatePair } from './BroadPhase';
+export { SweepAndPrune } from './SweepAndPrune';

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

@@ -0,0 +1,14 @@
+import type { Mutable2D } from '../math';
+import type { Shape } from '../shapes/Shape';
+/**
+ * The geometric surface the narrow phase needs: a shape plus its cached world
+ * data. {@link Collider} satisfies this structurally, and shape-overlap queries
+ * build a throwaway proxy to test an arbitrary shape against the world without
+ * allocating a body/collider.
+ */
+export interface CollisionProxy {
+    readonly shape: Shape;
+    readonly worldCenter: Readonly<Mutable2D>;
+    readonly worldVertices: readonly number[];
+    readonly worldNormals: readonly number[];
+}

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

@@ -0,0 +1,33 @@
+/** A single point of a {@link Manifold}. */
+export interface ManifoldPoint {
+    /** World-space contact position X. */
+    x: number;
+    /** World-space contact position Y. */
+    y: number;
+    /** Penetration depth in px (≥ 0). */
+    penetration: number;
+    /**
+     * Stable feature id identifying which geometric features produced this point.
+     * Constant across frames while the contact features are unchanged — the basis
+     * for warm-starting the solver later (gate B-2 / SG-M*).
+     */
+    id: number;
+}
+/**
+ * A contact manifold: the collision normal (oriented from collider A toward
+ * collider B) plus 1–2 contact points. A `Manifold` is reused across narrow-phase
+ * calls — it preallocates its two points and `reset()`s `pointCount` to 0. The
+ * generation here is forward-looking work for the dynamics solver; in this
+ * collision/query release it drives debug draw and validates the narrow phase.
+ */
+export declare class Manifold {
+    /** Collision normal X (unit, A → B). */
+    normalX: number;
+    /** Collision normal Y (unit, A → B). */
+    normalY: number;
+    /** Number of valid entries in {@link points} (0, 1 or 2). */
+    pointCount: number;
+    readonly points: readonly [ManifoldPoint, ManifoldPoint];
+    /** Clear the manifold for reuse. */
+    reset(): void;
+}

package/dist/esm/collision/Manifold.js

@@ -0,0 +1,28 @@
+/**
+ * A contact manifold: the collision normal (oriented from collider A toward
+ * collider B) plus 1–2 contact points. A `Manifold` is reused across narrow-phase
+ * calls — it preallocates its two points and `reset()`s `pointCount` to 0. The
+ * generation here is forward-looking work for the dynamics solver; in this
+ * collision/query release it drives debug draw and validates the narrow phase.
+ */
+class Manifold {
+    /** Collision normal X (unit, A → B). */
+    normalX = 0;
+    /** Collision normal Y (unit, A → B). */
+    normalY = 0;
+    /** Number of valid entries in {@link points} (0, 1 or 2). */
+    pointCount = 0;
+    points = [
+        { x: 0, y: 0, penetration: 0, id: 0 },
+        { x: 0, y: 0, penetration: 0, id: 0 },
+    ];
+    /** Clear the manifold for reuse. */
+    reset() {
+        this.pointCount = 0;
+        this.normalX = 0;
+        this.normalY = 0;
+    }
+}
+
+export { Manifold };
+//# sourceMappingURL=Manifold.js.map

package/dist/esm/collision/Manifold.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Manifold.js","sources":["../../../../src/collision/Manifold.ts"],"sourcesContent":[null],"names":[],"mappings":"AAgBA;;;;;;AAMG;MACU,QAAQ,CAAA;;IAEZ,OAAO,GAAG,CAAC;;IAEX,OAAO,GAAG,CAAC;;IAEX,UAAU,GAAG,CAAC;AAEL,IAAA,MAAM,GAA4C;AAChE,QAAA,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE;AACrC,QAAA,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE;KACtC;;IAGM,KAAK,GAAA;AACV,QAAA,IAAI,CAAC,UAAU,GAAG,CAAC;AACnB,QAAA,IAAI,CAAC,OAAO,GAAG,CAAC;AAChB,QAAA,IAAI,CAAC,OAAO,GAAG,CAAC;IAClB;AACD;;;;"}

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

@@ -0,0 +1,3 @@
+export type { CollisionProxy } from './CollisionProxy';
+export { Manifold, type ManifoldPoint } from './Manifold';
+export { collide, testOverlap } from './narrowphase';

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

@@ -0,0 +1,14 @@
+import type { CollisionProxy } from './CollisionProxy';
+import type { Manifold } from './Manifold';
+/**
+ * Generate the contact manifold for `a` vs `b`, writing into `manifold` and
+ * returning `true` when the colliders touch. The manifold normal is oriented
+ * from `a` toward `b`. Dispatches on shape pair; polygon/circle is handled by
+ * the circle/polygon routine with a `flip` so the normal stays `a → b`.
+ */
+export declare const collide: (a: CollisionProxy, b: CollisionProxy, manifold: Manifold) => boolean;
+/**
+ * Boolean overlap test (no manifold) used by sensors and shape-overlap queries.
+ * Exact for the circle/circle, circle/polygon and polygon/polygon pairs.
+ */
+export declare const testOverlap: (a: CollisionProxy, b: CollisionProxy) => boolean;