@codexo/exojs-physics 0.15.3 → 0.16.0

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

@@ -8,15 +8,15 @@ export interface ManifoldPoint {
     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*).
+     * Constant across frames while the contact features are unchanged - the basis
+     * for warm-starting the solver later.
      */
     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
+ * 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.
  */
@@ -31,3 +31,4 @@ export declare class Manifold {
     /** Clear the manifold for reuse. */
     reset(): void;
 }
+//# sourceMappingURL=Manifold.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Manifold.d.ts","sourceRoot":"","sources":["../../../src/collision/Manifold.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,MAAM,WAAW,aAAa;IAC5B,sCAAsC;IACtC,CAAC,EAAE,MAAM,CAAC;IACV,sCAAsC;IACtC,CAAC,EAAE,MAAM,CAAC;IACV,qCAAqC;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;;;;GAMG;AACH,qBAAa,QAAQ;IACnB,wCAAwC;IACjC,OAAO,SAAK;IACnB,wCAAwC;IACjC,OAAO,SAAK;IACnB,6DAA6D;IACtD,UAAU,SAAK;IAEtB,SAAgB,MAAM,EAAE,SAAS,CAAC,aAAa,EAAE,aAAa,CAAC,CAG7D;IAEF,oCAAoC;IAC7B,KAAK,IAAI,IAAI;CAKrB"}

package/dist/esm/collision/Manifold.js

@@ -1,28 +1,37 @@
+//#region src/collision/Manifold.ts
 /**
- * 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;
-    }
-}
+* 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.
+*/
+var Manifold = class {
+	/** 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;
+	}
+};
 
+//#endregion
 export { Manifold };
-//# sourceMappingURL=Manifold.js.map
+//# sourceMappingURL=Manifold.js.map

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

@@ -1 +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;;;;"}
+{"version":3,"file":"Manifold.js","names":[],"sources":["../../../src/collision/Manifold.ts"],"sourcesContent":["/** A single point of a {@link Manifold}. */\nexport interface ManifoldPoint {\n  /** World-space contact position X. */\n  x: number;\n  /** World-space contact position Y. */\n  y: number;\n  /** Penetration depth in px (≥ 0). */\n  penetration: number;\n  /**\n   * Stable feature id identifying which geometric features produced this point.\n   * Constant across frames while the contact features are unchanged - the basis\n   * for warm-starting the solver later.\n   */\n  id: number;\n}\n\n/**\n * A contact manifold: the collision normal (oriented from collider A toward\n * collider B) plus 1-2 contact points. A `Manifold` is reused across narrow-phase\n * calls - it preallocates its two points and `reset()`s `pointCount` to 0. The\n * generation here is forward-looking work for the dynamics solver; in this\n * collision/query release it drives debug draw and validates the narrow phase.\n */\nexport class Manifold {\n  /** Collision normal X (unit, A → B). */\n  public normalX = 0;\n  /** Collision normal Y (unit, A → B). */\n  public normalY = 0;\n  /** Number of valid entries in {@link points} (0, 1 or 2). */\n  public pointCount = 0;\n\n  public readonly points: readonly [ManifoldPoint, ManifoldPoint] = [\n    { x: 0, y: 0, penetration: 0, id: 0 },\n    { x: 0, y: 0, penetration: 0, id: 0 },\n  ];\n\n  /** Clear the manifold for reuse. */\n  public reset(): void {\n    this.pointCount = 0;\n    this.normalX = 0;\n    this.normalY = 0;\n  }\n}\n"],"mappings":";;;;;;;;AAuBA,IAAa,WAAb,MAAsB;;CAEpB,AAAO,UAAU;;CAEjB,AAAO,UAAU;;CAEjB,AAAO,aAAa;CAEpB,AAAgB,SAAkD,CAChE;EAAE,GAAG;EAAG,GAAG;EAAG,aAAa;EAAG,IAAI;CAAE,GACpC;EAAE,GAAG;EAAG,GAAG;EAAG,aAAa;EAAG,IAAI;CAAE,CACtC;;CAGA,AAAO,QAAc;EACnB,KAAK,aAAa;EAClB,KAAK,UAAU;EACf,KAAK,UAAU;CACjB;AACF"}

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

@@ -0,0 +1,29 @@
+import type { CollisionProxy } from './CollisionProxy';
+/**
+ * Adjacency filter for a chain edge: `true` when this edge owns the contact
+ * whose outward normal is `(nx, ny)`. Any other shape admits everything.
+ *
+ * A chain is one-sided, so a normal pointing into the solid side is never this
+ * edge's. Beyond that, the normals around a shared vertex are partitioned by
+ * proximity: the edge whose own normal is closest to the contact normal keeps
+ * the contact, and its neighbours drop it. That is what removes internal vertex
+ * snagging - a body sliding onto the next edge stops producing a contact against
+ * the previous one, instead of receiving two contradicting normals at the seam -
+ * while a body wedged in a concave corner still keeps one contact per wall,
+ * because each wall's own normal is the closest one there.
+ *
+ * A tie (collinear edges) is kept by both, which is what lets a straight run of
+ * chain edges carry a box across the join. A free end has no neighbour on that
+ * side and admits the whole half-plane, so a body can pass around it.
+ *
+ * The neighbour normals are reconstructed from the stored rotations rather than
+ * cached in world space: rotating this edge's world normal by the (transform
+ * invariant) angle to a neighbour's is exact and needs no second sync pass.
+ *
+ * The discrete narrow phase and the sweep both apply it, so a fast body meets
+ * the same one-sided, seam-free chain a slow one does.
+ *
+ * @internal
+ */
+export declare const chainEdgeAdmits: (proxy: CollisionProxy, nx: number, ny: number) => boolean;
+//# sourceMappingURL=chainAdjacency.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chainAdjacency.d.ts","sourceRoot":"","sources":["../../../src/collision/chainAdjacency.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,cAAc,EAAE,IAAI,MAAM,EAAE,IAAI,MAAM,KAAG,OAsB/E,CAAC"}

package/dist/esm/collision/chainAdjacency.js

@@ -0,0 +1,44 @@
+import { ChainEdgeShape } from "../shapes/ChainEdgeShape.js";
+
+//#region src/collision/chainAdjacency.ts
+/**
+* Adjacency filter for a chain edge: `true` when this edge owns the contact
+* whose outward normal is `(nx, ny)`. Any other shape admits everything.
+*
+* A chain is one-sided, so a normal pointing into the solid side is never this
+* edge's. Beyond that, the normals around a shared vertex are partitioned by
+* proximity: the edge whose own normal is closest to the contact normal keeps
+* the contact, and its neighbours drop it. That is what removes internal vertex
+* snagging - a body sliding onto the next edge stops producing a contact against
+* the previous one, instead of receiving two contradicting normals at the seam -
+* while a body wedged in a concave corner still keeps one contact per wall,
+* because each wall's own normal is the closest one there.
+*
+* A tie (collinear edges) is kept by both, which is what lets a straight run of
+* chain edges carry a box across the join. A free end has no neighbour on that
+* side and admits the whole half-plane, so a body can pass around it.
+*
+* The neighbour normals are reconstructed from the stored rotations rather than
+* cached in world space: rotating this edge's world normal by the (transform
+* invariant) angle to a neighbour's is exact and needs no second sync pass.
+*
+* The discrete narrow phase and the sweep both apply it, so a fast body meets
+* the same one-sided, seam-free chain a slow one does.
+*
+* @internal
+*/
+const chainEdgeAdmits = (proxy, nx, ny) => {
+	const shape = proxy.shape;
+	if (!(shape instanceof ChainEdgeShape)) return true;
+	const ownX = proxy.worldNormals[0];
+	const ownY = proxy.worldNormals[1];
+	const own = nx * ownX + ny * ownY;
+	if (own <= 0) return false;
+	const cross = ownX * ny - ownY * nx;
+	if (shape.hasPrevious && shape.previousCos * own + shape.previousSin * cross > own) return false;
+	return !(shape.hasNext && shape.nextCos * own + shape.nextSin * cross > own);
+};
+
+//#endregion
+export { chainEdgeAdmits };
+//# sourceMappingURL=chainAdjacency.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chainAdjacency.js","names":[],"sources":["../../../src/collision/chainAdjacency.ts"],"sourcesContent":["import { ChainEdgeShape } from '../shapes/ChainEdgeShape';\nimport type { CollisionProxy } from './CollisionProxy';\n\n/**\n * Adjacency filter for a chain edge: `true` when this edge owns the contact\n * whose outward normal is `(nx, ny)`. Any other shape admits everything.\n *\n * A chain is one-sided, so a normal pointing into the solid side is never this\n * edge's. Beyond that, the normals around a shared vertex are partitioned by\n * proximity: the edge whose own normal is closest to the contact normal keeps\n * the contact, and its neighbours drop it. That is what removes internal vertex\n * snagging - a body sliding onto the next edge stops producing a contact against\n * the previous one, instead of receiving two contradicting normals at the seam -\n * while a body wedged in a concave corner still keeps one contact per wall,\n * because each wall's own normal is the closest one there.\n *\n * A tie (collinear edges) is kept by both, which is what lets a straight run of\n * chain edges carry a box across the join. A free end has no neighbour on that\n * side and admits the whole half-plane, so a body can pass around it.\n *\n * The neighbour normals are reconstructed from the stored rotations rather than\n * cached in world space: rotating this edge's world normal by the (transform\n * invariant) angle to a neighbour's is exact and needs no second sync pass.\n *\n * The discrete narrow phase and the sweep both apply it, so a fast body meets\n * the same one-sided, seam-free chain a slow one does.\n *\n * @internal\n */\nexport const chainEdgeAdmits = (proxy: CollisionProxy, nx: number, ny: number): boolean => {\n  const shape = proxy.shape;\n\n  if (!(shape instanceof ChainEdgeShape)) {\n    return true;\n  }\n\n  const ownX = proxy.worldNormals[0]!;\n  const ownY = proxy.worldNormals[1]!;\n  const own = nx * ownX + ny * ownY;\n\n  if (own <= 0) {\n    return false;\n  }\n\n  const cross = ownX * ny - ownY * nx;\n\n  if (shape.hasPrevious && shape.previousCos * own + shape.previousSin * cross > own) {\n    return false;\n  }\n\n  return !(shape.hasNext && shape.nextCos * own + shape.nextSin * cross > own);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAa,mBAAmB,OAAuB,IAAY,OAAwB;CACzF,MAAM,QAAQ,MAAM;CAEpB,IAAI,EAAE,iBAAiB,iBACrB,OAAO;CAGT,MAAM,OAAO,MAAM,aAAa;CAChC,MAAM,OAAO,MAAM,aAAa;CAChC,MAAM,MAAM,KAAK,OAAO,KAAK;CAE7B,IAAI,OAAO,GACT,OAAO;CAGT,MAAM,QAAQ,OAAO,KAAK,OAAO;CAEjC,IAAI,MAAM,eAAe,MAAM,cAAc,MAAM,MAAM,cAAc,QAAQ,KAC7E,OAAO;CAGT,OAAO,EAAE,MAAM,WAAW,MAAM,UAAU,MAAM,MAAM,UAAU,QAAQ;AAC1E"}

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

@@ -0,0 +1,35 @@
+import type { ShapeType } from '../shapes/Shape';
+/**
+ * Canonical order of the shape kinds, roundest first. Two things depend on it
+ * and nothing else should: a pair table stores each unordered pair once, under
+ * the lower kind, and a mixed pair is always solved with the lower kind as the
+ * first operand plus a flip flag that reverses the resulting normal. One
+ * implementation per pair, never two mirrored copies.
+ *
+ * Inserting a kind changes only which slot a pair lands in, never which
+ * implementation runs.
+ */
+export declare const shapeKindOrder: Readonly<Record<ShapeType, number>>;
+export declare const shapeKindCount: number;
+/**
+ * Flat `kind × kind` table. Symmetric tables fill only the upper triangle and
+ * are read through {@link symmetricEntry}; ordered ones (a sweep distinguishes
+ * the moving operand from the target) fill both halves and are read directly
+ * with {@link orderedEntry}.
+ */
+export type PairTable<T> = Array<T | undefined>;
+/** Build a table holding one entry per **unordered** pair. */
+export declare const symmetricTable: <T>(entries: ReadonlyArray<readonly [ShapeType, ShapeType, T]>) => PairTable<T>;
+/** Build a table holding one entry per **ordered** pair. */
+export declare const orderedTable: <T>(entries: ReadonlyArray<readonly [ShapeType, ShapeType, T]>) => PairTable<T>;
+/**
+ * Entry for the unordered pair `(first, second)`. `undefined` means the pair is
+ * deliberately unsupported - callers must treat that as "no contact", never as
+ * an approximation.
+ */
+export declare const symmetricEntry: <T>(table: PairTable<T>, first: ShapeType, second: ShapeType) => T | undefined;
+/** `true` when the operands have to be swapped to reach the canonical order. */
+export declare const needsFlip: (first: ShapeType, second: ShapeType) => boolean;
+/** Entry for the ordered pair `(first, second)`; see {@link symmetricEntry} on `undefined`. */
+export declare const orderedEntry: <T>(table: PairTable<T>, first: ShapeType, second: ShapeType) => T | undefined;
+//# sourceMappingURL=dispatch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../../src/collision/dispatch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAS9D,CAAC;AAEF,eAAO,MAAM,cAAc,QAAqC,CAAC;AAEjE;;;;;GAKG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;AAYhD,8DAA8D;AAC9D,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,SAAS,aAAa,CAAC,SAAS,CAAC,SAAS,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAWzG,CAAC;AAEF,4DAA4D;AAC5D,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,SAAS,aAAa,CAAC,SAAS,CAAC,SAAS,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAQvG,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,OAAO,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,SAAS,EAAE,QAAQ,SAAS,KAAG,CAAC,GAAG,SAKhG,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,SAAS,GAAI,OAAO,SAAS,EAAE,QAAQ,SAAS,KAAG,OAAyD,CAAC;AAE1H,+FAA+F;AAC/F,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,OAAO,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,SAAS,EAAE,QAAQ,SAAS,KAAG,CAAC,GAAG,SACvB,CAAC"}

package/dist/esm/collision/dispatch.js

@@ -0,0 +1,58 @@
+//#region src/collision/dispatch.ts
+/**
+* Canonical order of the shape kinds, roundest first. Two things depend on it
+* and nothing else should: a pair table stores each unordered pair once, under
+* the lower kind, and a mixed pair is always solved with the lower kind as the
+* first operand plus a flip flag that reverses the resulting normal. One
+* implementation per pair, never two mirrored copies.
+*
+* Inserting a kind changes only which slot a pair lands in, never which
+* implementation runs.
+*/
+const shapeKindOrder = {
+	circle: 0,
+	capsule: 1,
+	segment: 2,
+	polygon: 3,
+	chain: 4
+};
+const shapeKindCount = Object.keys(shapeKindOrder).length;
+const emptyTable = () => {
+	const table = [];
+	for (let i = 0; i < shapeKindCount * shapeKindCount; i++) table.push(void 0);
+	return table;
+};
+/** Build a table holding one entry per **unordered** pair. */
+const symmetricTable = (entries) => {
+	const table = emptyTable();
+	for (const [first, second, value] of entries) {
+		const a = shapeKindOrder[first];
+		const b = shapeKindOrder[second];
+		table[Math.min(a, b) * shapeKindCount + Math.max(a, b)] = value;
+	}
+	return table;
+};
+/** Build a table holding one entry per **ordered** pair. */
+const orderedTable = (entries) => {
+	const table = emptyTable();
+	for (const [first, second, value] of entries) table[shapeKindOrder[first] * shapeKindCount + shapeKindOrder[second]] = value;
+	return table;
+};
+/**
+* Entry for the unordered pair `(first, second)`. `undefined` means the pair is
+* deliberately unsupported - callers must treat that as "no contact", never as
+* an approximation.
+*/
+const symmetricEntry = (table, first, second) => {
+	const a = shapeKindOrder[first];
+	const b = shapeKindOrder[second];
+	return table[Math.min(a, b) * shapeKindCount + Math.max(a, b)];
+};
+/** `true` when the operands have to be swapped to reach the canonical order. */
+const needsFlip = (first, second) => shapeKindOrder[first] > shapeKindOrder[second];
+/** Entry for the ordered pair `(first, second)`; see {@link symmetricEntry} on `undefined`. */
+const orderedEntry = (table, first, second) => table[shapeKindOrder[first] * shapeKindCount + shapeKindOrder[second]];
+
+//#endregion
+export { needsFlip, orderedEntry, orderedTable, shapeKindCount, shapeKindOrder, symmetricEntry, symmetricTable };
+//# sourceMappingURL=dispatch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.js","names":[],"sources":["../../../src/collision/dispatch.ts"],"sourcesContent":["import type { ShapeType } from '../shapes/Shape';\n\n/**\n * Canonical order of the shape kinds, roundest first. Two things depend on it\n * and nothing else should: a pair table stores each unordered pair once, under\n * the lower kind, and a mixed pair is always solved with the lower kind as the\n * first operand plus a flip flag that reverses the resulting normal. One\n * implementation per pair, never two mirrored copies.\n *\n * Inserting a kind changes only which slot a pair lands in, never which\n * implementation runs.\n */\nexport const shapeKindOrder: Readonly<Record<ShapeType, number>> = {\n  circle: 0,\n  capsule: 1,\n  segment: 2,\n  polygon: 3,\n  // A chain never reaches the narrow phase itself: a chain collider is solved\n  // through its per-edge child proxies, which are segments carrying adjacency.\n  // The slot exists so the tables stay total over `ShapeType`, and stays empty.\n  chain: 4,\n};\n\nexport const shapeKindCount = Object.keys(shapeKindOrder).length;\n\n/**\n * Flat `kind × kind` table. Symmetric tables fill only the upper triangle and\n * are read through {@link symmetricEntry}; ordered ones (a sweep distinguishes\n * the moving operand from the target) fill both halves and are read directly\n * with {@link orderedEntry}.\n */\nexport type PairTable<T> = Array<T | undefined>;\n\nconst emptyTable = <T>(): PairTable<T> => {\n  const table: PairTable<T> = [];\n\n  for (let i = 0; i < shapeKindCount * shapeKindCount; i++) {\n    table.push(undefined);\n  }\n\n  return table;\n};\n\n/** Build a table holding one entry per **unordered** pair. */\nexport const symmetricTable = <T>(entries: ReadonlyArray<readonly [ShapeType, ShapeType, T]>): PairTable<T> => {\n  const table = emptyTable<T>();\n\n  for (const [first, second, value] of entries) {\n    const a = shapeKindOrder[first];\n    const b = shapeKindOrder[second];\n\n    table[Math.min(a, b) * shapeKindCount + Math.max(a, b)] = value;\n  }\n\n  return table;\n};\n\n/** Build a table holding one entry per **ordered** pair. */\nexport const orderedTable = <T>(entries: ReadonlyArray<readonly [ShapeType, ShapeType, T]>): PairTable<T> => {\n  const table = emptyTable<T>();\n\n  for (const [first, second, value] of entries) {\n    table[shapeKindOrder[first] * shapeKindCount + shapeKindOrder[second]] = value;\n  }\n\n  return table;\n};\n\n/**\n * Entry for the unordered pair `(first, second)`. `undefined` means the pair is\n * deliberately unsupported - callers must treat that as \"no contact\", never as\n * an approximation.\n */\nexport const symmetricEntry = <T>(table: PairTable<T>, first: ShapeType, second: ShapeType): T | undefined => {\n  const a = shapeKindOrder[first];\n  const b = shapeKindOrder[second];\n\n  return table[Math.min(a, b) * shapeKindCount + Math.max(a, b)];\n};\n\n/** `true` when the operands have to be swapped to reach the canonical order. */\nexport const needsFlip = (first: ShapeType, second: ShapeType): boolean => shapeKindOrder[first] > shapeKindOrder[second];\n\n/** Entry for the ordered pair `(first, second)`; see {@link symmetricEntry} on `undefined`. */\nexport const orderedEntry = <T>(table: PairTable<T>, first: ShapeType, second: ShapeType): T | undefined =>\n  table[shapeKindOrder[first] * shapeKindCount + shapeKindOrder[second]];\n"],"mappings":";;;;;;;;;;;AAYA,MAAa,iBAAsD;CACjE,QAAQ;CACR,SAAS;CACT,SAAS;CACT,SAAS;CAIT,OAAO;AACT;AAEA,MAAa,iBAAiB,OAAO,KAAK,cAAc,CAAC,CAAC;AAU1D,MAAM,mBAAoC;CACxC,MAAM,QAAsB,CAAC;CAE7B,KAAK,IAAI,IAAI,GAAG,IAAI,iBAAiB,gBAAgB,KACnD,MAAM,KAAK,MAAS;CAGtB,OAAO;AACT;;AAGA,MAAa,kBAAqB,YAA6E;CAC7G,MAAM,QAAQ,WAAc;CAE5B,KAAK,MAAM,CAAC,OAAO,QAAQ,UAAU,SAAS;EAC5C,MAAM,IAAI,eAAe;EACzB,MAAM,IAAI,eAAe;EAEzB,MAAM,KAAK,IAAI,GAAG,CAAC,IAAI,iBAAiB,KAAK,IAAI,GAAG,CAAC,KAAK;CAC5D;CAEA,OAAO;AACT;;AAGA,MAAa,gBAAmB,YAA6E;CAC3G,MAAM,QAAQ,WAAc;CAE5B,KAAK,MAAM,CAAC,OAAO,QAAQ,UAAU,SACnC,MAAM,eAAe,SAAS,iBAAiB,eAAe,WAAW;CAG3E,OAAO;AACT;;;;;;AAOA,MAAa,kBAAqB,OAAqB,OAAkB,WAAqC;CAC5G,MAAM,IAAI,eAAe;CACzB,MAAM,IAAI,eAAe;CAEzB,OAAO,MAAM,KAAK,IAAI,GAAG,CAAC,IAAI,iBAAiB,KAAK,IAAI,GAAG,CAAC;AAC9D;;AAGA,MAAa,aAAa,OAAkB,WAA+B,eAAe,SAAS,eAAe;;AAGlH,MAAa,gBAAmB,OAAqB,OAAkB,WACrE,MAAM,eAAe,SAAS,iBAAiB,eAAe"}

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

@@ -1,3 +1,5 @@
 export type { CollisionProxy } from './CollisionProxy';
 export { Manifold, type ManifoldPoint } from './Manifold';
 export { collide, testOverlap } from './narrowphase';
+export { type SweepHit, sweepProxies } from './sweep';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/collision/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,KAAK,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC"}

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

@@ -3,8 +3,10 @@ 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`.
+ * from `a` toward `b`.
+ *
+ * A pair with no entry in the table is deliberately unsupported and reports no
+ * contact rather than an approximation.
  */
 export declare const collide: (a: CollisionProxy, b: CollisionProxy, manifold: Manifold) => boolean;
 /**
@@ -12,3 +14,4 @@ export declare const collide: (a: CollisionProxy, b: CollisionProxy, manifold: M
  * Exact for the circle/circle, circle/polygon and polygon/polygon pairs.
  */
 export declare const testOverlap: (a: CollisionProxy, b: CollisionProxy) => boolean;
+//# sourceMappingURL=narrowphase.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"narrowphase.d.ts","sourceRoot":"","sources":["../../../src/collision/narrowphase.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAmB3C;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,GAAI,GAAG,cAAc,EAAE,GAAG,cAAc,EAAE,UAAU,QAAQ,KAAG,OA0BlF,CAAC;AAkdF;;;GAGG;AACH,eAAO,MAAM,WAAW,GAAI,GAAG,cAAc,EAAE,GAAG,cAAc,KAAG,OAUlE,CAAC"}