@newkrok/nape-js 3.7.6 → 3.8.0

package/dist/ConvexResult-CYFNMlT2.d.ts

@@ -0,0 +1,2690 @@
+/**
+ * 2D vector used for positions, velocities, forces, and other 2D quantities.
+ *
+ * Supports object pooling via `Vec2.get()` / `dispose()`, weak references
+ * that auto-dispose after a single use, and immutability guards.
+ *
+ * Converted from nape-compiled.js lines 23448–27180.
+ */
+declare class Vec2 {
+    static __name__: string[];
+    /**
+     * Creates a Vec2 with the given components. Defaults to (0, 0).
+     *
+     * @param x - The x component (default 0).
+     * @param y - The y component (default 0).
+     */
+    constructor(x?: number, y?: number);
+    /**
+     * Allocate a Vec2 from the public object pool. If `weak` is true, the vector
+     * auto-disposes after a single API call.
+     *
+     * @param x - The x component (default 0).
+     * @param y - The y component (default 0).
+     * @param weak - If true, the returned Vec2 is auto-disposed after one use (default false).
+     * @returns A pooled or newly created Vec2.
+     * @example
+     * const v = Vec2.get(3, 4);
+     * // use v ...
+     * v.dispose();
+     */
+    static get(x?: number, y?: number, weak?: boolean): Vec2;
+    /**
+     * Allocate a weak Vec2 (auto-disposes after a single use).
+     *
+     * @param x - The x component (default 0).
+     * @param y - The y component (default 0).
+     * @returns A weak, pooled Vec2 that is automatically disposed after one API call.
+     */
+    static weak(x?: number, y?: number): Vec2;
+    /**
+     * Create a Vec2 from polar coordinates (length and angle in radians).
+     *
+     * @param length - The magnitude of the resulting vector.
+     * @param angle - The angle in radians, measured counter-clockwise from the +x axis.
+     * @param weak - If true, the returned Vec2 is auto-disposed after one use (default false).
+     * @returns A new Vec2 with components `(length * cos(angle), length * sin(angle))`.
+     * @example
+     * const v = Vec2.fromPolar(1, Math.PI / 4); // 45-degree unit vector
+     */
+    static fromPolar(length: number, angle: number, weak?: boolean): Vec2;
+    /**
+     * Create a unit Vec2 pointing in the given direction (angle in radians).
+     * Equivalent to `Vec2.fromPolar(1, radians)`.
+     *
+     * @param radians - The angle in radians, measured counter-clockwise from the +x axis.
+     * @param weak - If true, the returned Vec2 is auto-disposed after one use (default false).
+     * @returns A unit Vec2 at the given angle.
+     */
+    static fromAngle(radians: number, weak?: boolean): Vec2;
+    /**
+     * Linearly interpolate between two Vec2s. Returns `a + t * (b - a)`.
+     * Disposes weak arguments after use.
+     *
+     * @param a - The start Vec2 (t = 0).
+     * @param b - The end Vec2 (t = 1).
+     * @param t - The interpolation factor (typically 0–1, but not clamped).
+     * @param weak - If true, the returned Vec2 is auto-disposed after one use (default false).
+     * @returns A new Vec2 at the interpolated position.
+     */
+    static lerp(a: Vec2, b: Vec2, t: number, weak?: boolean): Vec2;
+    /**
+     * Check whether two Vec2s are component-wise equal, within an optional epsilon tolerance.
+     * Disposes weak arguments after comparison.
+     *
+     * @param a - The first Vec2.
+     * @param b - The second Vec2.
+     * @param epsilon - Maximum allowed difference per component (default 0).
+     * @returns `true` if both components differ by at most `epsilon`.
+     */
+    static eq(a: Vec2, b: Vec2, epsilon?: number): boolean;
+    /**
+     * Squared Euclidean distance between two Vec2s. Avoids a square root when
+     * only comparison is needed.
+     *
+     * @param a - The first Vec2.
+     * @param b - The second Vec2.
+     * @returns The squared distance `(a.x - b.x)² + (a.y - b.y)²`.
+     */
+    static dsq(a: Vec2, b: Vec2): number;
+    /**
+     * Euclidean distance between two Vec2s.
+     *
+     * @param a - The first Vec2.
+     * @param b - The second Vec2.
+     * @returns The distance `sqrt((a.x - b.x)² + (a.y - b.y)²)`.
+     */
+    static distance(a: Vec2, b: Vec2): number;
+    /** The x component. */
+    get x(): number;
+    /** The x component. */
+    set x(value: number);
+    /** The y component. */
+    get y(): number;
+    /** The y component. */
+    set y(value: number);
+    /** Magnitude (Euclidean length) of the vector. */
+    get length(): number;
+    /**
+     * Setting length scales the vector to the given magnitude. Throws if the
+     * vector is zero-length.
+     *
+     * @param value - The desired magnitude. Must not be NaN.
+     */
+    set length(value: number);
+    /**
+     * Angle of the vector in radians, measured counter-clockwise from the +x
+     * axis. Returns 0 for the zero vector.
+     */
+    get angle(): number;
+    /**
+     * Setting angle preserves the vector's magnitude and rotates it to the given
+     * angle.
+     *
+     * @param value - The desired angle in radians. Must not be NaN.
+     */
+    set angle(value: number);
+    /**
+     * Returns the squared magnitude. Faster than `length` as it avoids a square
+     * root.
+     *
+     * @returns `x² + y²`.
+     */
+    lsq(): number;
+    /**
+     * Copy another Vec2's components into this vector in-place.
+     *
+     * @param vector - The source Vec2 to copy from.
+     * @returns `this` for chaining.
+     */
+    set(vector: Vec2): this;
+    /**
+     * Set both components at once in-place.
+     *
+     * @param x - The new x component.
+     * @param y - The new y component.
+     * @returns `this` for chaining.
+     */
+    setxy(x: number, y: number): this;
+    /**
+     * Return a new Vec2 with the same components. Alias for `copy()`.
+     *
+     * @returns A new Vec2 with the same x and y values.
+     */
+    clone(): Vec2;
+    /**
+     * Check whether this Vec2 is component-wise equal to another, within an optional epsilon tolerance.
+     *
+     * @param other - The Vec2 to compare against.
+     * @param epsilon - Maximum allowed difference per component (default 0).
+     * @returns `true` if both components differ by at most `epsilon`.
+     */
+    equals(other: Vec2, epsilon?: number): boolean;
+    /**
+     * Return a new Vec2 with the same components.
+     *
+     * @param weak - If true, the returned Vec2 is auto-disposed after one use (default false).
+     * @returns A copy of this vector.
+     */
+    copy(weak?: boolean): Vec2;
+    /**
+     * Rotate this vector by `angle` radians in-place.
+     *
+     * @param angle - The rotation angle in radians.
+     * @returns `this` for chaining.
+     */
+    rotate(angle: number): this;
+    /**
+     * Reflect `vec` about this vector as a normal axis.
+     *
+     * @param vec - The Vec2 to reflect.
+     * @param weak - If true, the returned Vec2 is auto-disposed after one use (default false).
+     * @returns A new Vec2 that is the reflection of `vec` about this vector.
+     */
+    reflect(vec: Vec2, weak?: boolean): Vec2;
+    /**
+     * Normalise this vector to unit length in-place. Throws for zero-length
+     * vectors.
+     *
+     * @returns `this` for chaining.
+     */
+    normalise(): this;
+    /**
+     * Return a new unit-length vector with the same direction. Throws for
+     * zero-length vectors.
+     *
+     * @param weak - If true, the returned Vec2 is auto-disposed after one use (default false).
+     * @returns A normalised copy of this vector.
+     */
+    unit(weak?: boolean): Vec2;
+    /**
+     * Return a new Vec2 equal to `this + other`.
+     *
+     * @param vector - The Vec2 to add.
+     * @param weak - If true, the returned Vec2 is auto-disposed after one use (default false).
+     * @returns A new Vec2 with components `(this.x + other.x, this.y + other.y)`.
+     */
+    add(vector: Vec2, weak?: boolean): Vec2;
+    /**
+     * Return a new Vec2 equal to `this + other × scalar`.
+     *
+     * @param vector - The Vec2 to scale and add.
+     * @param scalar - The multiplier applied to `vector` before addition.
+     * @param weak - If true, the returned Vec2 is auto-disposed after one use (default false).
+     * @returns A new Vec2 with components `(this.x + vector.x * scalar, this.y + vector.y * scalar)`.
+     */
+    addMul(vector: Vec2, scalar: number, weak?: boolean): Vec2;
+    /**
+     * Return a new Vec2 equal to `this − other`.
+     *
+     * @param vector - The Vec2 to subtract.
+     * @param weak - If true, the returned Vec2 is auto-disposed after one use (default false).
+     * @returns A new Vec2 with components `(this.x - other.x, this.y - other.y)`.
+     */
+    sub(vector: Vec2, weak?: boolean): Vec2;
+    /**
+     * Return a new Vec2 equal to `this × scalar`.
+     *
+     * @param scalar - The multiplier.
+     * @param weak - If true, the returned Vec2 is auto-disposed after one use (default false).
+     * @returns A new Vec2 with components `(this.x * scalar, this.y * scalar)`.
+     */
+    mul(scalar: number, weak?: boolean): Vec2;
+    /**
+     * Add another Vec2 to this in-place (`this += other`).
+     *
+     * @param vector - The Vec2 to add.
+     * @returns `this` for chaining.
+     */
+    addeq(vector: Vec2): this;
+    /**
+     * Subtract another Vec2 from this in-place (`this -= other`).
+     *
+     * @param vector - The Vec2 to subtract.
+     * @returns `this` for chaining.
+     */
+    subeq(vector: Vec2): this;
+    /**
+     * Multiply this Vec2 by a scalar in-place (`this ×= scalar`).
+     *
+     * @param scalar - The multiplier.
+     * @returns `this` for chaining.
+     */
+    muleq(scalar: number): this;
+    /**
+     * Dot product of this and another Vec2.
+     *
+     * @param vector - The other Vec2.
+     * @returns `this.x * other.x + this.y * other.y`.
+     */
+    dot(vector: Vec2): number;
+    /**
+     * 2D cross product (`this.x × other.y − this.y × other.x`). Returns a
+     * scalar.
+     *
+     * @param vector - The other Vec2.
+     * @returns The scalar cross product.
+     */
+    cross(vector: Vec2): number;
+    /**
+     * Return the perpendicular vector, rotated 90° counter-clockwise.
+     *
+     * @param weak - If true, the returned Vec2 is auto-disposed after one use (default false).
+     * @returns A new Vec2 with components `(-this.y, this.x)`.
+     */
+    perp(weak?: boolean): Vec2;
+    /**
+     * Return this Vec2 to the object pool. Throws if already disposed or
+     * immutable.
+     */
+    dispose(): void;
+    /**
+     * String representation in the form `{ x: … y: … }`.
+     *
+     * @returns A human-readable string of this vector's components.
+     */
+    toString(): string;
+}
+/** Opaque handle for any nape internal object. */
+type NapeInner = any;
+
+/**
+ * 3D vector used for constraint impulses and other 3-component values.
+ *
+ * Supports object pooling via `Vec3.get()` / `dispose()`.
+ *
+ * Converted from nape-compiled.js lines 24120–25040.
+ */
+declare class Vec3 {
+    static __name__: string[];
+    /**
+     * Create a Vec3 with the given components. Defaults to (0, 0, 0).
+     * @param x - The x component.
+     * @param y - The y component.
+     * @param z - The z component.
+     */
+    constructor(x?: number, y?: number, z?: number);
+    /**
+     * Allocate a Vec3 from the public object pool, or create a new one if the pool is empty.
+     * @param x - Initial x component (default 0).
+     * @param y - Initial y component (default 0).
+     * @param z - Initial z component (default 0).
+     * @returns A Vec3 initialised with the given components.
+     */
+    static get(x?: number, y?: number, z?: number): Vec3;
+    /** The x component. */
+    get x(): number;
+    /** The x component. */
+    set x(value: number);
+    /** The y component. */
+    get y(): number;
+    /** The y component. */
+    set y(value: number);
+    /** The z component. */
+    get z(): number;
+    /** The z component. */
+    set z(value: number);
+    /**
+     * Magnitude of the 3D vector.
+     * @returns The Euclidean length `sqrt(x² + y² + z²)`.
+     */
+    get length(): number;
+    /**
+     * Scale the vector to the given magnitude.
+     * @throws If the vector has zero length.
+     */
+    set length(value: number);
+    /**
+     * Squared magnitude. Faster than `length` as it avoids a square root.
+     * @returns `x² + y² + z²`.
+     */
+    lsq(): number;
+    /**
+     * Copy another Vec3's components into this one in-place.
+     * @param vector - The source Vec3 to copy from.
+     * @returns `this` for chaining.
+     */
+    set(vector: Vec3): this;
+    /**
+     * Set all three components at once in-place.
+     * @param x - The new x component.
+     * @param y - The new y component.
+     * @param z - The new z component.
+     * @returns `this` for chaining.
+     */
+    setxyz(x: number, y: number, z: number): this;
+    /**
+     * Check whether this Vec3 is component-wise equal to another, within an optional epsilon tolerance.
+     *
+     * @param other - The Vec3 to compare against.
+     * @param epsilon - Maximum allowed difference per component (default 0).
+     * @returns `true` if all three components differ by at most `epsilon`.
+     */
+    equals(other: Vec3, epsilon?: number): boolean;
+    /**
+     * Return a new Vec3 with the same components.
+     * @returns A copy of this vector.
+     */
+    clone(): Vec3;
+    /**
+     * Return the x and y components as a new Vec2.
+     * @param weak - If true, the returned Vec2 is a weak (pooled) reference.
+     * @returns A new Vec2 containing this vector's x and y components.
+     */
+    xy(weak?: boolean): Vec2;
+    /**
+     * Return this Vec3 to the object pool.
+     * @throws If this Vec3 has already been disposed.
+     */
+    dispose(): void;
+    /**
+     * String representation `{ x: … y: … z: … }`.
+     * @returns A human-readable string of the three components.
+     */
+    toString(): string;
+}
+
+/**
+ * 2x3 affine transformation matrix [a b tx; c d ty].
+ *
+ * Converted from nape-compiled.js lines 20507–21760.
+ */
+declare class Mat23 {
+    static __name__: string[];
+    /**
+     * Create a Mat23 with the given components. Defaults to the identity matrix `[1 0 0; 0 1 0]`.
+     * @param a - Component at row 0, col 0.
+     * @param b - Component at row 0, col 1.
+     * @param c - Component at row 1, col 0.
+     * @param d - Component at row 1, col 1.
+     * @param tx - Translation component along x.
+     * @param ty - Translation component along y.
+     */
+    constructor(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number);
+    /**
+     * Create a pure rotation matrix for the given angle in radians.
+     * @param angle - Rotation angle in radians.
+     * @returns A new Mat23 representing the rotation.
+     */
+    static rotation(angle: number): Mat23;
+    /**
+     * Create a pure translation matrix.
+     * @param tx - Translation along x.
+     * @param ty - Translation along y.
+     * @returns A new Mat23 representing the translation.
+     */
+    static translation(tx: number, ty: number): Mat23;
+    /**
+     * Create a pure scale matrix.
+     * @param sx - Scale factor along x.
+     * @param sy - Scale factor along y.
+     * @returns A new Mat23 representing the scale.
+     */
+    static scale(sx: number, sy: number): Mat23;
+    static _wrap(inner: any): Mat23;
+    private _setProp;
+    /** Matrix component at row 0, col 0. The matrix layout is `[a b tx; c d ty]`. */
+    get a(): number;
+    /** Matrix component at row 0, col 0. The matrix layout is `[a b tx; c d ty]`. */
+    set a(v: number);
+    /** Matrix component at row 0, col 1. The matrix layout is `[a b tx; c d ty]`. */
+    get b(): number;
+    /** Matrix component at row 0, col 1. The matrix layout is `[a b tx; c d ty]`. */
+    set b(v: number);
+    /** Matrix component at row 1, col 0. The matrix layout is `[a b tx; c d ty]`. */
+    get c(): number;
+    /** Matrix component at row 1, col 0. The matrix layout is `[a b tx; c d ty]`. */
+    set c(v: number);
+    /** Matrix component at row 1, col 1. The matrix layout is `[a b tx; c d ty]`. */
+    get d(): number;
+    /** Matrix component at row 1, col 1. The matrix layout is `[a b tx; c d ty]`. */
+    set d(v: number);
+    /** Translation component along x. The matrix layout is `[a b tx; c d ty]`. */
+    get tx(): number;
+    /** Translation component along x. The matrix layout is `[a b tx; c d ty]`. */
+    set tx(v: number);
+    /** Translation component along y. The matrix layout is `[a b tx; c d ty]`. */
+    get ty(): number;
+    /** Translation component along y. The matrix layout is `[a b tx; c d ty]`. */
+    set ty(v: number);
+    /** The determinant of the linear 2×2 part (ad − bc). */
+    get determinant(): number;
+    /**
+     * Return a new Mat23 with the same components. Alias for `copy()`.
+     * @returns A new Mat23 with the same components.
+     */
+    clone(): Mat23;
+    /**
+     * Check whether this Mat23 is component-wise equal to another, within an optional epsilon tolerance.
+     *
+     * @param other - The Mat23 to compare against.
+     * @param epsilon - Maximum allowed difference per component (default 0).
+     * @returns `true` if all six components differ by at most `epsilon`.
+     */
+    equals(other: Mat23, epsilon?: number): boolean;
+    /**
+     * Return a new Mat23 with the same components.
+     * @returns A deep copy of this matrix.
+     */
+    copy(): Mat23;
+    /**
+     * Copy all components from another Mat23 into this one in-place.
+     * @param matrix - The source matrix to copy from.
+     * @returns `this` for chaining.
+     */
+    set(matrix: Mat23): this;
+    /**
+     * Set all six components at once in-place.
+     * @param a - Component at row 0, col 0.
+     * @param b - Component at row 0, col 1.
+     * @param c - Component at row 1, col 0.
+     * @param d - Component at row 1, col 1.
+     * @param tx - Translation along x.
+     * @param ty - Translation along y.
+     * @returns `this` for chaining.
+     */
+    setAs(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number): this;
+    /**
+     * Reset to the identity matrix in-place.
+     * @returns `this` for chaining.
+     */
+    reset(): this;
+    /**
+     * Return `true` if the matrix is singular (non-invertible) within the engine's epsilon threshold.
+     * @returns `true` when the matrix cannot be safely inverted.
+     */
+    singular(): boolean;
+    /**
+     * Return the inverse of this matrix.
+     * @returns A new Mat23 that is the inverse of this one.
+     * @throws If the matrix is singular.
+     */
+    inverse(): Mat23;
+    /**
+     * Return the transpose of this matrix.
+     * @returns A new Mat23 that is the transpose of this one.
+     */
+    transpose(): Mat23;
+    /**
+     * Return `matrix × this` (apply this matrix first, then `matrix`).
+     * @param matrix - The matrix to concatenate on the left.
+     * @returns A new Mat23 representing the combined transformation.
+     */
+    concat(matrix: Mat23): Mat23;
+    /**
+     * Transform a Vec2 by this matrix. If `noTranslation` is true, only the linear 2×2 part is applied.
+     * @param point - The Vec2 to transform.
+     * @param noTranslation - When true, the translation components (tx, ty) are ignored.
+     * @param weak - If true, the returned Vec2 is a weak (pooled) reference.
+     * @returns A new Vec2 with the transformed coordinates.
+     */
+    transform(point: Vec2, noTranslation?: boolean, weak?: boolean): Vec2;
+    /**
+     * Apply the inverse transformation to a Vec2. Throws if the matrix is singular.
+     * @param point - The Vec2 to transform.
+     * @param noTranslation - When true, the translation components (tx, ty) are ignored.
+     * @param weak - If true, the returned Vec2 is a weak (pooled) reference.
+     * @returns A new Vec2 with the inverse-transformed coordinates.
+     */
+    inverseTransform(point: Vec2, noTranslation?: boolean, weak?: boolean): Vec2;
+    /**
+     * Return `true` if the matrix is equiorthogonal (uniform scale, no shear).
+     * @returns `true` when the matrix has equal scale on both axes and no shear.
+     */
+    equiorthogonal(): boolean;
+    /**
+     * Return `true` if the matrix is orthogonal (unit-scale rotation, no shear).
+     * @returns `true` when the column vectors are orthonormal.
+     */
+    orthogonal(): boolean;
+    private _orthogonaliseImpl;
+    /**
+     * Adjust the matrix in-place to be equiorthogonal (uniform scale, no shear).
+     * @returns `this` for chaining.
+     */
+    equiorthogonalise(): this;
+    /**
+     * Adjust the matrix in-place to be orthogonal (normalise column vectors).
+     * @returns `this` for chaining.
+     */
+    orthogonalise(): this;
+    /**
+     * String representation `{ a: … b: … c: … d: … tx: … ty: … }`.
+     * @returns A human-readable string of the matrix components.
+     */
+    toString(): string;
+}
+
+/**
+ * Axis-aligned bounding box defined by min/max corners or x/y/width/height.
+ *
+ * Internally wraps a ZPP_AABB and is registered as the public
+ * `nape.geom.AABB` class in the compiled namespace.
+ *
+ * Converted from nape-compiled.js lines 14950–15653.
+ */
+declare class AABB {
+    static __name__: string[];
+    /**
+     * Create an AABB at position (x, y) with the given width and height. All
+     * values default to 0.
+     *
+     * @param x - The x position of the left edge (default 0).
+     * @param y - The y position of the top edge (default 0).
+     * @param width - The width of the box (default 0). Must be ≥ 0.
+     * @param height - The height of the box (default 0). Must be ≥ 0.
+     */
+    constructor(x?: number, y?: number, width?: number, height?: number);
+    /**
+     * Create the smallest AABB that contains all the given points.
+     * Disposes weak Vec2 arguments after use.
+     *
+     * @param points - An array of Vec2 points to enclose. Must contain at least one point.
+     * @returns A new AABB enclosing all the points.
+     */
+    static fromPoints(points: Vec2[]): AABB;
+    /** The x position of the left edge (minx). Setting shifts the box horizontally. */
+    get x(): number;
+    /** The x position of the left edge (minx). Setting shifts the box horizontally. */
+    set x(x: number);
+    /** The y position of the top edge (miny). Setting shifts the box vertically. */
+    get y(): number;
+    /** The y position of the top edge (miny). Setting shifts the box vertically. */
+    set y(y: number);
+    /** Width of the box (maxx − minx). Must be ≥ 0. */
+    get width(): number;
+    /** Width of the box (maxx − minx). Must be ≥ 0. */
+    set width(width: number);
+    /** Height of the box (maxy − miny). Must be ≥ 0. */
+    get height(): number;
+    /** Height of the box (maxy − miny). Must be ≥ 0. */
+    set height(height: number);
+    /**
+     * The top-left corner as a Vec2 (minx, miny). The returned Vec2 is a live
+     * view; mutating it updates the AABB.
+     */
+    get min(): any;
+    /**
+     * Set the top-left corner. The new min must not exceed the current max.
+     *
+     * @param min - A Vec2 whose components become the new (minx, miny).
+     */
+    set min(min: any);
+    /**
+     * The bottom-right corner as a Vec2 (maxx, maxy). The returned Vec2 is a
+     * live view; mutating it updates the AABB.
+     */
+    get max(): any;
+    /**
+     * Set the bottom-right corner. The new max must not be below the current
+     * min.
+     *
+     * @param max - A Vec2 whose components become the new (maxx, maxy).
+     */
+    set max(max: any);
+    /**
+     * Return a new AABB with the same bounds. Alias for `copy()`.
+     *
+     * @returns A new AABB with the same position and dimensions.
+     */
+    clone(): AABB;
+    /**
+     * Check whether this AABB is equal to another, within an optional epsilon tolerance.
+     *
+     * @param other - The AABB to compare against.
+     * @param epsilon - Maximum allowed difference per component (default 0).
+     * @returns `true` if all four bounds (minx, miny, maxx, maxy) differ by at most `epsilon`.
+     */
+    equals(other: AABB, epsilon?: number): boolean;
+    /**
+     * Return a new AABB with the same bounds.
+     *
+     * @returns A copy of this AABB.
+     */
+    copy(): AABB;
+    /**
+     * String representation in the form `{ x: … y: … w: … h: … }`.
+     *
+     * @returns A human-readable string of this AABB's position and dimensions.
+     */
+    toString(): string;
+}
+
+/**
+ * Variable-sized M×N matrix.
+ *
+ * Converted from nape-compiled.js lines 17261–17395.
+ */
+declare class MatMN {
+    static __name__: string[];
+    /**
+     * Create a zero-filled M×N matrix. Both dimensions must be ≥ 1.
+     * @param rows - Number of rows (must be ≥ 1).
+     * @param cols - Number of columns (must be ≥ 1).
+     */
+    constructor(rows: number, cols: number);
+    /** Number of rows. */
+    get rows(): number;
+    /** Number of columns. */
+    get cols(): number;
+    /**
+     * Read the element at (row, col). Zero-based indices.
+     * @param row - Zero-based row index.
+     * @param col - Zero-based column index.
+     * @returns The element value at the given position.
+     */
+    x(row: number, col: number): number;
+    /**
+     * Write `value` to the element at (row, col). Returns the written value.
+     * @param row - Zero-based row index.
+     * @param col - Zero-based column index.
+     * @param value - The value to write.
+     * @returns The written value.
+     */
+    setx(row: number, col: number, value: number): number;
+    /**
+     * Check whether this MatMN is element-wise equal to another, within an optional epsilon tolerance.
+     * Matrices must have the same dimensions.
+     *
+     * @param other - The MatMN to compare against.
+     * @param epsilon - Maximum allowed difference per element (default 0).
+     * @returns `true` if dimensions match and all elements differ by at most `epsilon`.
+     */
+    equals(other: MatMN, epsilon?: number): boolean;
+    /**
+     * Return a new MatMN with the same dimensions and element values.
+     * @returns A deep copy of this matrix.
+     */
+    clone(): MatMN;
+    /**
+     * String representation with rows separated by semicolons.
+     * @returns A human-readable string of the matrix elements.
+     */
+    toString(): string;
+    /**
+     * Return a new transposed matrix (N×M).
+     * @returns A new MatMN that is the transpose of this one.
+     */
+    transpose(): MatMN;
+    /**
+     * Return the matrix product `this × matrix`. Column count of this must equal row count of `matrix`.
+     * @param matrix - The right-hand matrix to multiply by.
+     * @returns A new MatMN representing the product.
+     */
+    mul(matrix: MatMN): MatMN;
+}
+
+/**
+ * A ray for raycasting queries.
+ *
+ * Fully modernized — uses ZPP_Ray directly (extracted to TypeScript).
+ */
+declare class Ray {
+    static __name__: string[];
+    /**
+     * Create a Ray from an origin point and a direction vector.
+     * Both must be non-null, non-disposed Vec2s.
+     * @param origin - The start point of the ray in world coordinates.
+     * @param direction - The direction vector (need not be unit length).
+     */
+    constructor(origin: Vec2, direction: Vec2);
+    /**
+     * Create a Ray from a line segment.
+     * The ray origin is `start`, direction is `end − start`, and `maxDistance` is the segment length.
+     * @param start - The start point of the segment.
+     * @param end - The end point of the segment.
+     * @returns A new Ray spanning the segment.
+     */
+    static fromSegment(start: Vec2, end: Vec2): Ray;
+    /** The ray's start point in world coordinates. */
+    get origin(): Vec2;
+    /** The ray's start point in world coordinates. */
+    set origin(value: Vec2);
+    /** The ray's direction vector (need not be unit length; the engine normalises internally). */
+    get direction(): Vec2;
+    /** The ray's direction vector (need not be unit length; the engine normalises internally). */
+    set direction(value: Vec2);
+    /** Maximum travel distance for raycasting queries. Defaults to `Infinity`. */
+    get maxDistance(): number;
+    /** Maximum travel distance for raycasting queries. Defaults to `Infinity`. */
+    set maxDistance(value: number);
+    /** Arbitrary user data attached to this Ray. */
+    get userData(): Record<string, unknown>;
+    /**
+     * Compute the axis-aligned bounding box that encloses the ray from origin to `maxDistance`.
+     * @returns A new AABB wrapping the ray's extent.
+     */
+    aabb(): AABB;
+    /**
+     * Return the world-space point at `distance` along the ray.
+     * @param distance - Distance from the ray origin along the ray direction.
+     * @param weak - If true, the returned Vec2 is a weak (pooled) reference.
+     * @returns The point `origin + distance * normalised_direction`.
+     */
+    at(distance: number, weak?: boolean): Vec2;
+    /**
+     * Return a new Ray with the same origin, direction, and maxDistance. Alias for `copy()`.
+     * @returns A new Ray with the same properties.
+     */
+    clone(): Ray;
+    /**
+     * Return a new Ray with the same origin, direction, and maxDistance.
+     * @returns A deep copy of this Ray.
+     */
+    copy(): Ray;
+}
+
+/**
+ * Generic typed wrapper around Haxe list objects (BodyList, ShapeList, etc.).
+ *
+ * Provides a modern iterable interface with `for...of`, `length`, `at()`, etc.
+ */
+declare class NapeList<T> implements Iterable<T> {
+    /** Number of elements in the list. */
+    get length(): number;
+    /** Get element at index. */
+    at(index: number): T;
+    /** Add an element to the list. */
+    add(item: T & {
+        _inner?: NapeInner;
+    }): void;
+    /** Remove an element from the list. */
+    remove(item: T & {
+        _inner?: NapeInner;
+    }): void;
+    /** Check if the list contains an element. */
+    has(item: T & {
+        _inner?: NapeInner;
+    }): boolean;
+    /** Remove all elements. */
+    clear(): void;
+    /** Whether the list is empty. */
+    get empty(): boolean;
+    /** Push an element to the end. */
+    push(item: T & {
+        _inner?: NapeInner;
+    }): void;
+    /** Pop the last element. */
+    pop(): T;
+    /** Shift the first element. */
+    shift(): T;
+    /** Unshift an element to the front. */
+    unshift(item: T & {
+        _inner?: NapeInner;
+    }): void;
+    /** Iterate over all elements. */
+    [Symbol.iterator](): Iterator<T>;
+    /** Convert to a plain array. */
+    toArray(): T[];
+    /** Apply a function to each element. */
+    forEach(fn: (item: T, index: number) => void): void;
+    toString(): string;
+}
+
+/**
+ * Hierarchical interaction group for controlling interactions
+ * between sets of interactors.
+ *
+ * Internally wraps a ZPP_InteractionGroup and is registered as
+ * the public `nape.dynamics.InteractionGroup` class in the compiled namespace.
+ *
+ * Converted from nape-compiled.js lines 14641–14733.
+ */
+declare class InteractionGroup {
+    static __name__: string[];
+    constructor(ignore?: boolean);
+    get group(): InteractionGroup | null;
+    set group(value: InteractionGroup | null);
+    get ignore(): boolean;
+    set ignore(value: boolean);
+    get interactors(): any;
+    get groups(): any;
+    toString(): string;
+}
+
+/**
+ * Base class for all interactable physics objects (Body, Shape, Compound).
+ *
+ * Cannot be instantiated directly — only via Body, Shape, or Compound.
+ * Provides shared properties: id, userData, group, cbTypes, and type
+ * casting methods (castBody, castShape, castCompound).
+ *
+ * Fully modernized — all methods use ZPP_Interactor fields directly
+ * via `zpp_inner_i` (no compiled prototype delegation).
+ */
+declare class Interactor {
+    /** Unique numeric identifier for this interactor. */
+    get id(): number;
+    /** User-defined data storage object. */
+    get userData(): Record<string, unknown>;
+    /** The interaction group this interactor belongs to. */
+    get group(): InteractionGroup | null;
+    set group(value: InteractionGroup | null);
+    /** Callback types assigned to this interactor. */
+    get cbTypes(): any;
+    /** Cast to Body — returns the Body wrapper if this is a Body, else null. */
+    get castBody(): any;
+    /** Cast to Shape — returns the Shape wrapper if this is a Shape, else null. */
+    get castShape(): any;
+    /** Cast to Compound — returns the Compound wrapper if this is a Compound, else null. */
+    get castCompound(): any;
+    /** Returns true if this interactor is a Shape. */
+    isShape(): boolean;
+    /** Returns true if this interactor is a Body. */
+    isBody(): boolean;
+    /** Returns true if this interactor is a Compound. */
+    isCompound(): boolean;
+    toString(): string;
+}
+
+/**
+ * A compound physics object — a hierarchical grouping of Bodies, Constraints,
+ * and other Compounds.
+ *
+ * Fully modernized — uses ZPP_Compound directly (extracted to TypeScript).
+ */
+declare class Compound extends Interactor {
+    static __name__: string[];
+    static __super__: typeof Interactor;
+    constructor();
+    /** Bodies in this compound. */
+    get bodies(): object;
+    /** Constraints in this compound. */
+    get constraints(): object;
+    /** Child compounds in this compound. */
+    get compounds(): object;
+    /** Parent compound, or null if this is a root compound. */
+    get compound(): Compound | null;
+    set compound(value: Compound | null);
+    /** Space this compound belongs to (only settable on root compounds). */
+    get space(): Space | null;
+    set space(value: Space | null);
+    /** Deep copy of this compound and all its children. */
+    copy(): Compound;
+    /** Distribute all children to the parent compound or space, then remove. */
+    breakApart(): void;
+    /** Recursively visit all bodies in this compound and its sub-compounds. */
+    visitBodies(lambda: (body: Body) => void): void;
+    /** Recursively visit all constraints in this compound and its sub-compounds. */
+    visitConstraints(lambda: (constraint: Constraint) => void): void;
+    /** Recursively visit all sub-compounds in this compound. */
+    visitCompounds(lambda: (compound: Compound) => void): void;
+    /** Calculate the center of mass of all bodies in this compound. */
+    COM(weak?: boolean): Vec2;
+    /** Translate all bodies in this compound by the given vector. */
+    translate(translation: Vec2): Compound;
+    /** Rotate all bodies in this compound around the given centre point. */
+    rotate(centre: Vec2, angle: number): Compound;
+    toString(): string;
+}
+
+/**
+ * Base class for all physics constraints (joints).
+ *
+ * Constraints restrict the relative motion of two bodies. This class provides
+ * properties common to all joint types: `active`, `stiff`, `frequency`,
+ * `damping`, `maxForce`, `maxError`, `breakUnderForce`, `breakUnderError`,
+ * `removeOnBreak`, `isSleeping`, `space`, `compound`, `cbTypes`, and `userData`.
+ *
+ * Cannot be instantiated directly — use one of the concrete joint subclasses:
+ * {@link AngleJoint}, {@link DistanceJoint}, {@link LineJoint}, {@link MotorJoint},
+ * {@link PivotJoint}, {@link PulleyJoint}, {@link WeldJoint}, or {@link UserConstraint}.
+ *
+ * **Soft vs. stiff constraints:**
+ * - `stiff = true` (default): the constraint is enforced rigidly.
+ * - `stiff = false`: uses a spring model with `frequency` (Hz) and `damping` (ratio).
+ *
+ * Fully modernized — uses ZPP_Constraint directly (extracted to TypeScript).
+ */
+declare class Constraint {
+    static __name__: string[];
+    debugDraw: boolean;
+    /**
+     * The space this constraint belongs to, or `null` if not in a space.
+     *
+     * Assign to add/remove the constraint from a space:
+     * ```ts
+     * joint.space = mySpace;  // adds to space
+     * joint.space = null;     // removes from space
+     * ```
+     * Cannot be set if the constraint belongs to a {@link Compound}.
+     */
+    get space(): Space | null;
+    set space(value: Space | null);
+    /**
+     * The compound this constraint belongs to, or `null`.
+     * When set, the constraint's `space` is managed by the compound.
+     */
+    get compound(): Compound | null;
+    set compound(value: Compound | null);
+    /**
+     * Whether the constraint is currently active (enforced by the solver).
+     *
+     * Deactivating a constraint suspends it without removing it from the space.
+     * @defaultValue `true`
+     */
+    get active(): boolean;
+    set active(value: boolean);
+    /**
+     * When `true` the constraint is completely ignored by the engine — bodies are
+     * not woken, no impulse is applied, and no callbacks fire.
+     * @defaultValue `false`
+     */
+    get ignore(): boolean;
+    set ignore(value: boolean);
+    /**
+     * When `true` (default) the constraint is stiff/rigid.
+     * When `false` the constraint uses a soft spring model driven by
+     * `frequency` and `damping`.
+     * @defaultValue `true`
+     */
+    get stiff(): boolean;
+    set stiff(value: boolean);
+    /**
+     * Spring frequency in Hz for soft constraints (`stiff = false`).
+     *
+     * Higher values make the spring stiffer; lower values make it bouncier.
+     * Must be `> 0`. Ignored when `stiff` is `true`.
+     * @defaultValue `10`
+     */
+    get frequency(): number;
+    set frequency(value: number);
+    /**
+     * Damping ratio for soft constraints (`stiff = false`).
+     *
+     * `0` = undamped (oscillates freely), `1` = critically damped.
+     * Values `> 1` are overdamped. Must be `>= 0`. Ignored when `stiff` is `true`.
+     * @defaultValue `1`
+     */
+    get damping(): number;
+    set damping(value: number);
+    /**
+     * Maximum force (in Newtons) the constraint may apply per step.
+     *
+     * When the required force exceeds this value the constraint becomes slack.
+     * If `breakUnderForce` is `true` the constraint breaks instead.
+     * Must be `>= 0`. `Infinity` disables the limit.
+     * @defaultValue `Infinity`
+     */
+    get maxForce(): number;
+    set maxForce(value: number);
+    /**
+     * Maximum positional error (in pixels) allowed before breaking.
+     *
+     * Only meaningful when `breakUnderError` is `true`.
+     * Must be `>= 0`. `Infinity` disables the limit.
+     * @defaultValue `Infinity`
+     */
+    get maxError(): number;
+    set maxError(value: number);
+    /**
+     * When `true`, the constraint breaks (fires a `BREAK` event) if the applied
+     * force exceeds `maxForce` in a single step.
+     * @defaultValue `false`
+     */
+    get breakUnderForce(): boolean;
+    set breakUnderForce(value: boolean);
+    /**
+     * When `true`, the constraint breaks if the positional error exceeds `maxError`.
+     * @defaultValue `false`
+     */
+    get breakUnderError(): boolean;
+    set breakUnderError(value: boolean);
+    /**
+     * When `true` (default), the constraint is automatically removed from its space
+     * when it breaks. Set to `false` to keep it in the space after breaking.
+     * @defaultValue `true`
+     */
+    get removeOnBreak(): boolean;
+    set removeOnBreak(value: boolean);
+    /**
+     * Whether the constraint's simulation component is currently sleeping.
+     *
+     * Only valid when the constraint is active and in a space — throws otherwise.
+     */
+    get isSleeping(): boolean;
+    /**
+     * Arbitrary user data attached to this constraint.
+     * Lazily initialized to `{}` on first access.
+     */
+    get userData(): Record<string, unknown>;
+    /**
+     * The set of {@link CbType}s assigned to this constraint.
+     * Used to filter which listeners respond to this constraint's events.
+     */
+    get cbTypes(): object;
+    /**
+     * The impulse applied by this constraint in the last simulation step.
+     *
+     * The shape of the returned {@link MatMN} depends on the constraint's degrees of
+     * freedom (e.g., 1×1 for AngleJoint/MotorJoint, 2×1 for PivotJoint/LineJoint,
+     * 3×1 for WeldJoint).
+     */
+    impulse(): MatMN | null;
+    /**
+     * The impulse applied to `body` by this constraint in the last simulation step,
+     * expressed as a {@link Vec3} `(fx, fy, torque)`.
+     *
+     * @param _body - Must be one of the bodies linked to this constraint.
+     */
+    bodyImpulse(_body: Body): Vec3 | null;
+    /**
+     * Invokes `fn` once for each distinct body linked to this constraint.
+     *
+     * @param _fn - Function to call for each body.
+     */
+    visitBodies(_fn: (body: Body) => void): void;
+    /**
+     * Creates and returns a copy of this constraint with the same parameters.
+     * The copy is not automatically added to a space.
+     */
+    copy(): Constraint;
+    toString(): string;
+}
+
+/**
+ * Bit-mask based interaction filter for controlling which shapes
+ * collide, sense, or interact as fluids.
+ *
+ * Internally wraps a ZPP_InteractionFilter and is registered as
+ * the public `nape.dynamics.InteractionFilter` class in the compiled namespace.
+ *
+ * Converted from nape-compiled.js lines 14361–14640.
+ */
+declare class InteractionFilter {
+    static __name__: string[];
+    /**
+     * @param collisionGroup - Collision group bits (default 1).
+     * @param collisionMask - Collision mask bits (default -1, all bits set).
+     * @param sensorGroup - Sensor group bits (default 1).
+     * @param sensorMask - Sensor mask bits (default -1, all bits set).
+     * @param fluidGroup - Fluid group bits (default 1).
+     * @param fluidMask - Fluid mask bits (default -1, all bits set).
+     */
+    constructor(collisionGroup?: number, collisionMask?: number, sensorGroup?: number, sensorMask?: number, fluidGroup?: number, fluidMask?: number);
+    /** Bit-mask identifying which collision group(s) this shape belongs to. */
+    get collisionGroup(): number;
+    set collisionGroup(value: number);
+    /** Bit-mask of collision groups this shape will collide with. */
+    get collisionMask(): number;
+    set collisionMask(value: number);
+    /** Bit-mask identifying which sensor group(s) this shape belongs to. */
+    get sensorGroup(): number;
+    set sensorGroup(value: number);
+    /** Bit-mask of sensor groups this shape will sense. */
+    get sensorMask(): number;
+    set sensorMask(value: number);
+    /** Bit-mask identifying which fluid group(s) this shape belongs to. */
+    get fluidGroup(): number;
+    set fluidGroup(value: number);
+    /** Bit-mask of fluid groups this shape will interact with as a fluid. */
+    get fluidMask(): number;
+    set fluidMask(value: number);
+    /** Arbitrary user data attached to this filter. */
+    get userData(): Record<string, unknown>;
+    /** Read-only list of shapes currently using this filter. */
+    get shapes(): any;
+    /**
+     * Test whether two filters allow collision interaction.
+     * @param filter - The other filter to test against.
+     * @returns `true` if the two filters' group/mask bits permit collision.
+     */
+    shouldCollide(filter: InteractionFilter): boolean;
+    /**
+     * Test whether two filters allow sensor interaction.
+     * @param filter - The other filter to test against.
+     * @returns `true` if the two filters' group/mask bits permit sensing.
+     */
+    shouldSense(filter: InteractionFilter): boolean;
+    /**
+     * Test whether two filters allow fluid interaction.
+     * @param filter - The other filter to test against.
+     * @returns `true` if the two filters' group/mask bits permit fluid interaction.
+     */
+    shouldFlow(filter: InteractionFilter): boolean;
+    /** Create a copy of this filter with the same group/mask values. */
+    copy(): InteractionFilter;
+    /** Return a hex-formatted string representation of all group/mask pairs. */
+    toString(): string;
+}
+
+/**
+ * Result from a raycast query.
+ *
+ * Provides the contact normal, distance, inside-flag, and shape hit.
+ * Instances are pooled — call `dispose()` when done to return to pool.
+ */
+declare class RayResult {
+    static __name__: string[];
+    constructor();
+    get normal(): Vec2;
+    get distance(): number;
+    get inner(): boolean;
+    get shape(): Shape;
+    dispose(): void;
+    toString(): string;
+}
+
+/**
+ * Broadphase algorithm type for Space collision detection.
+ *
+ * - `DYNAMIC_AABB_TREE` — dynamic AABB tree broadphase
+ * - `SWEEP_AND_PRUNE`   — sweep-and-prune broadphase
+ *
+ * Converted from nape-compiled.js lines 30858–30909.
+ */
+declare class Broadphase {
+    static __name__: string[];
+    constructor();
+    static get DYNAMIC_AABB_TREE(): Broadphase;
+    static get SWEEP_AND_PRUNE(): Broadphase;
+    toString(): string;
+}
+
+/**
+ * Enumeration of interaction categories used to filter {@link InteractionListener}
+ * and {@link PreListener} callbacks.
+ *
+ * - `COLLISION` — physical collisions between solid shapes
+ * - `SENSOR`    — sensor (trigger) interactions where shapes overlap but don't resolve
+ * - `FLUID`     — fluid buoyancy/drag interactions
+ * - `ANY`       — all of the above
+ *
+ * Converted from nape-compiled.js lines 1785–1883.
+ */
+declare class InteractionType {
+    static __name__: string[];
+    constructor();
+    /** Physical collision between solid shapes (default for most shapes). */
+    static get COLLISION(): InteractionType;
+    /** Sensor/trigger overlap — shapes overlap but collision is not resolved. */
+    static get SENSOR(): InteractionType;
+    /** Fluid buoyancy/drag interaction between a fluid shape and a body. */
+    static get FLUID(): InteractionType;
+    /** Matches all interaction types (COLLISION, SENSOR, and FLUID). */
+    static get ANY(): InteractionType;
+    toString(): string;
+}
+
+/**
+ * Structural interface for all dynamically-generated Nape list classes
+ * (BodyList, ShapeList, CompoundList, etc.).
+ *
+ * These classes are created at runtime by {@link createListClasses} and placed
+ * in the `nape` namespace, so they cannot be imported directly. Use this
+ * interface as the return type for Space / Body query methods.
+ */
+interface TypedListLike<T> extends Iterable<T> {
+    /** Number of elements in the list. */
+    readonly length: number;
+    /** Returns element at the given index. */
+    at(index: number): T;
+    /** Returns true if the list contains `obj`. */
+    has(obj: T): boolean;
+    /** Adds `obj` to the end of the list. Returns true if successful. */
+    push(obj: T): boolean;
+    /** Adds `obj` to the front of the list. Returns true if successful. */
+    unshift(obj: T): boolean;
+    /** Removes and returns the last element. */
+    pop(): T;
+    /** Removes and returns the first element. */
+    shift(): T;
+    /** Adds `obj` (anywhere). Returns true if successful. */
+    add(obj: T): boolean;
+    /** Removes `obj`. Returns true if it was present. */
+    remove(obj: T): boolean;
+    /** Removes all elements. */
+    clear(): void;
+    /** Returns true if the list has no elements. */
+    empty(): boolean;
+    /** Returns an iterator over the elements. */
+    iterator(): Iterable<T>;
+    /** Returns a shallow or deep copy of the list. */
+    copy(deep?: boolean): TypedListLike<T>;
+    /** Merge elements of `xs` into this list. */
+    merge(xs: TypedListLike<T>): void;
+    /** Apply `lambda` to every element. */
+    foreach(lambda: (obj: T) => void): void;
+    /** Returns a filtered copy. */
+    filter(lambda: (obj: T) => boolean): TypedListLike<T>;
+    /** Converts to a plain array. */
+    toArray(): T[];
+}
+
+/**
+ * Arbiter type classification.
+ *
+ * - `COLLISION` — collision arbiter
+ * - `SENSOR`    — sensor arbiter
+ * - `FLUID`     — fluid arbiter
+ *
+ * Converted from nape-compiled.js lines 11653–11725.
+ */
+declare class ArbiterType {
+    static __name__: string[];
+    constructor();
+    static get COLLISION(): ArbiterType;
+    static get SENSOR(): ArbiterType;
+    static get FLUID(): ArbiterType;
+    toString(): string;
+}
+
+/**
+ * Physical material properties applied to shapes.
+ *
+ * Controls elasticity (bounciness), friction coefficients, density, and
+ * rolling friction.  Internally wraps a ZPP_Material and is registered as
+ * the public `nape.phys.Material` class in the compiled namespace.
+ *
+ * Converted from nape-compiled.js lines 38254–38573.
+ */
+declare class Material {
+    static __name__: string[];
+    constructor(elasticity?: number, dynamicFriction?: number, staticFriction?: number, density?: number, rollingFriction?: number);
+    get elasticity(): number;
+    set elasticity(value: number);
+    get dynamicFriction(): number;
+    set dynamicFriction(value: number);
+    get staticFriction(): number;
+    set staticFriction(value: number);
+    get density(): number;
+    set density(value: number);
+    get rollingFriction(): number;
+    set rollingFriction(value: number);
+    get userData(): Record<string, unknown>;
+    copy(): Material;
+    toString(): string;
+    static wood(): Material;
+    static steel(): Material;
+    static ice(): Material;
+    static rubber(): Material;
+    static glass(): Material;
+    static sand(): Material;
+}
+
+/**
+ * A convex polygon physics shape.
+ */
+declare class Polygon extends Shape {
+    static __name__: string[];
+    static __super__: any;
+    /**
+     * Create a Polygon from a list of Vec2 vertices. Vertices must form a convex polygon
+     * in counter-clockwise order.
+     * @param localVerts - Vertices as `Array<Vec2>`, `Vec2List`, or `GeomPoly`.
+     * @param material - Material to assign (uses default if omitted).
+     * @param filter - InteractionFilter to assign (uses default if omitted).
+     */
+    constructor(localVerts?: Vec2[] | any, material?: Material, filter?: InteractionFilter);
+    /**
+     * Create an axis-aligned rectangle at the given position.
+     * @param x - Left edge x coordinate.
+     * @param y - Top edge y coordinate.
+     * @param width - Rectangle width.
+     * @param height - Rectangle height.
+     * @param weak - If true, returned Vec2s are marked weak and will be auto-disposed.
+     * @returns Array of four Vec2 corner vertices.
+     */
+    static rect(x: number, y: number, width: number, height: number, weak?: boolean): Vec2[];
+    /**
+     * Create an axis-aligned rectangular polygon centred at the origin.
+     * @param width - Rectangle width.
+     * @param height - Rectangle height (defaults to `width` for a square).
+     * @param weak - If true, returned Vec2s are marked weak and will be auto-disposed.
+     * @returns Array of four Vec2 corner vertices.
+     */
+    static box(width: number, height?: number, weak?: boolean): Vec2[];
+    /**
+     * Create a regular polygon (or ellipse approximation) centred at the origin.
+     * @param xRadius - Horizontal radius of the circumscribed ellipse.
+     * @param yRadius - Vertical radius of the circumscribed ellipse.
+     * @param edgeCount - Number of sides (must be >= 3).
+     * @param angleOffset - Rotation offset in radians applied to all vertices (default 0).
+     * @param weak - If true, returned Vec2s are marked weak and will be auto-disposed.
+     * @returns Array of `edgeCount` Vec2 vertices.
+     */
+    static regular(xRadius: number, yRadius: number, edgeCount: number, angleOffset?: number, weak?: boolean): Vec2[];
+    /** The list of local-space vertices defining this polygon's shape. */
+    get localVerts(): any;
+    /** World-space vertices of this polygon, updated each simulation step. */
+    get worldVerts(): any;
+    /** The list of edges derived from this polygon's vertices. */
+    get edges(): any;
+    /**
+     * Validate the polygon geometry and return a string describing any issues, or
+     * `"valid"` if the polygon is well-formed.
+     * @returns A validation result string from the underlying ZPP_Polygon.
+     */
+    validity(): any;
+}
+
+/**
+ * An edge of a polygon shape.
+ *
+ * Edges are read-only and managed by the polygon they belong to.
+ * Cannot be instantiated directly — only obtained from Polygon.edges.
+ *
+ * Fully modernized — all getters access ZPP_Edge directly.
+ */
+declare class Edge {
+    static __name__: string[];
+    constructor();
+    /** Parent polygon. */
+    get polygon(): Polygon;
+    /** Local-space normal vector (immutable Vec2). */
+    get localNormal(): Vec2;
+    /** World-space normal vector (immutable Vec2). Requires polygon in a body. */
+    get worldNormal(): Vec2;
+    /** Edge length. */
+    get length(): number;
+    /** Local-space projection along the edge normal. */
+    get localProjection(): number;
+    /** World-space projection. Requires polygon in a body. */
+    get worldProjection(): number;
+    /** First local vertex of this edge. */
+    get localVertex1(): Vec2;
+    /** Second local vertex of this edge. */
+    get localVertex2(): Vec2;
+    /** First world vertex. Requires polygon in a body. */
+    get worldVertex1(): Vec2;
+    /** Second world vertex. Requires polygon in a body. */
+    get worldVertex2(): Vec2;
+    toString(): string;
+    /**
+     * Wrap a ZPP_Vec2 vertex into its public Vec2 outer.
+     * Mirrors the compiled vertex wrapping pattern.
+     */
+    private _wrapVert;
+}
+
+/**
+ * An arbiter representing a physical collision between two solid shapes.
+ *
+ * Provides access to contact points, collision normal, friction coefficients,
+ * elasticity, and impulse data. Properties marked _mutable in pre-handler_ can
+ * only be set within a {@link PreListener} handler.
+ *
+ * Obtain via {@link Arbiter.collisionArbiter} or by casting from a callback's
+ * arbiter list.
+ *
+ * Fully modernized — uses extracted ZPP_ColArbiter directly.
+ */
+declare class CollisionArbiter extends Arbiter {
+    static __name__: string[];
+    static __super__: typeof Arbiter;
+    constructor();
+    /**
+     * The list of active contact points between the two shapes.
+     * Contains 1 or 2 {@link Contact} objects depending on the collision geometry.
+     */
+    get contacts(): object;
+    /**
+     * Collision normal vector pointing from `shape1` toward `shape2`.
+     * Read-only; available after the arbiter is active.
+     */
+    get normal(): Vec2;
+    /** Sum of the radii of the two shapes at the collision point. */
+    get radius(): number;
+    /** Reference edge of shape1 (if polygon), or null. */
+    get referenceEdge1(): Edge | null;
+    /** Reference edge of shape2 (if polygon), or null. */
+    get referenceEdge2(): Edge | null;
+    /**
+     * Coefficient of restitution (bounciness).
+     *
+     * Combined from the two shapes' `elasticity` values. Can be overridden
+     * inside a pre-handler. Must be `>= 0`.
+     *
+     * _Mutable in pre-handler only._
+     */
+    get elasticity(): number;
+    set elasticity(value: number);
+    /**
+     * Dynamic (kinetic) friction coefficient — applied when the contact is sliding.
+     * Combined from the two shapes' material values. _Mutable in pre-handler only._
+     */
+    get dynamicFriction(): number;
+    set dynamicFriction(value: number);
+    /**
+     * Static friction coefficient — applied when the contact is at rest.
+     * Combined from the two shapes' material values. _Mutable in pre-handler only._
+     */
+    get staticFriction(): number;
+    set staticFriction(value: number);
+    /**
+     * Rolling friction coefficient — resists rolling motion.
+     * Combined from the two shapes' material values. _Mutable in pre-handler only._
+     */
+    get rollingFriction(): number;
+    set rollingFriction(value: number);
+    /** Whether the first contact point lies on a polygon vertex (poly-circle only). */
+    firstVertex(): boolean;
+    /** Whether the second contact point lies on a polygon vertex (poly-circle only). */
+    secondVertex(): boolean;
+    /**
+     * Impulse applied in the normal (collision) direction, summed over all contacts.
+     * @param body - One of the two bodies, or `null` for the combined value.
+     * @param freshOnly - Only include new contact points. Default `false`.
+     */
+    normalImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
+    /**
+     * Friction impulse applied in the tangent direction, summed over all contacts.
+     * @param body - One of the two bodies, or `null` for the combined value.
+     * @param freshOnly - Only include new contact points. Default `false`.
+     */
+    tangentImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
+    /** Total impulse (normal + tangent + rolling) accumulated across all contacts. */
+    totalImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
+    /**
+     * Rolling impulse applied by this collision.
+     * @param body - One of the two bodies, or `null` for the combined value.
+     * @param freshOnly - Only include new contact points. Default `false`.
+     */
+    rollingImpulse(body?: Body | null, freshOnly?: boolean): number;
+}
+
+/**
+ * An arbiter representing a fluid interaction between a fluid shape and a body.
+ *
+ * Provides access to buoyancy and drag impulses, the overlap area, and the
+ * centre of overlap. Properties marked _mutable in pre-handler_ can only be
+ * set within a {@link PreListener} handler.
+ *
+ * Obtain via {@link Arbiter.fluidArbiter} or by casting from a callback arbiter.
+ *
+ * Fully modernized — uses extracted ZPP_FluidArbiter directly.
+ */
+declare class FluidArbiter extends Arbiter {
+    static __name__: string[];
+    static __super__: typeof Arbiter;
+    constructor();
+    /**
+     * Centre of the overlap region between the fluid and the body shape.
+     * _Mutable in pre-handler only._
+     */
+    get position(): Vec2;
+    set position(value: Vec2);
+    /**
+     * Area of the overlap region in pixels². Used to compute buoyancy force.
+     * Must be strictly positive and finite.
+     * _Mutable in pre-handler only._
+     */
+    get overlap(): number;
+    set overlap(value: number);
+    /**
+     * Buoyancy impulse applied in the last step as `(fx, fy, torque)`.
+     * @param body - One of the two bodies, or `null` for the combined value.
+     */
+    buoyancyImpulse(body?: Body | null): Vec3;
+    /**
+     * Linear and angular drag impulse applied in the last step as `(fx, fy, torque)`.
+     * @param body - One of the two bodies, or `null` for the combined value.
+     */
+    dragImpulse(body?: Body | null): Vec3;
+    /** Total impulse (buoyancy + drag). */
+    totalImpulse(body?: Body | null, _freshOnly?: boolean): Vec3;
+}
+
+/**
+ * Return value for {@link PreListener} handlers — controls whether the interaction
+ * is resolved this step and in future steps.
+ *
+ * - `ACCEPT`      — resolve the interaction (default if handler returns `null`)
+ * - `IGNORE`      — suppress the interaction permanently until the next `BEGIN`
+ * - `ACCEPT_ONCE` — accept this step only, then revert to the previous flag
+ * - `IGNORE_ONCE` — ignore this step only, then revert to the previous flag
+ *
+ * Use `IGNORE`/`ACCEPT` for stateful decisions (e.g., one-way platforms).
+ * Use `*_ONCE` variants for single-step overrides.
+ *
+ * Converted from nape-compiled.js lines 2504–2591.
+ */
+declare class PreFlag {
+    static __name__: string[];
+    constructor();
+    /** Accept and resolve the interaction normally. */
+    static get ACCEPT(): PreFlag;
+    /** Suppress the interaction permanently until the next `BEGIN` event. */
+    static get IGNORE(): PreFlag;
+    /** Accept this step only; revert to the previous flag next step. */
+    static get ACCEPT_ONCE(): PreFlag;
+    /** Ignore this step only; revert to the previous flag next step. */
+    static get IGNORE_ONCE(): PreFlag;
+    toString(): string;
+}
+
+/**
+ * Represents an active interaction between two shapes.
+ *
+ * Arbiters are created and pooled internally by the engine — they cannot be
+ * instantiated directly. Access them via:
+ * - `space.arbiters` — all active arbiters in the simulation
+ * - `body.arbiters` — arbiters involving a specific body
+ * - `InteractionCallback.arbiters` — arbiters in an interaction callback
+ * - `PreCallback.arbiter` — the arbiter in a pre-handler
+ *
+ * Use {@link Arbiter.collisionArbiter} or {@link Arbiter.fluidArbiter} to cast
+ * to a subtype for type-specific properties.
+ *
+ * **Warning:** do not hold references to `Arbiter` objects after the current
+ * simulation step — they are pooled and may be reused.
+ *
+ * Fully modernized — uses extracted ZPP_Arbiter directly.
+ */
+declare class Arbiter {
+    static __name__: string[];
+    constructor();
+    /**
+     * Whether both interacting bodies are currently sleeping.
+     * Throws if the arbiter is not active.
+     */
+    get isSleeping(): boolean;
+    /**
+     * The interaction type of this arbiter.
+     * @see {@link ArbiterType}
+     */
+    get type(): ArbiterType;
+    /** Cast to CollisionArbiter if this is a collision, else null. */
+    get collisionArbiter(): CollisionArbiter | null;
+    /** Cast to FluidArbiter if this is a fluid interaction, else null. */
+    get fluidArbiter(): FluidArbiter | null;
+    /** First shape (lower id). */
+    get shape1(): Shape;
+    /** Second shape (higher id). */
+    get shape2(): Shape;
+    /** Body of shape1. */
+    get body1(): Body;
+    /** Body of shape2. */
+    get body2(): Body;
+    /** The pre-handler state of this arbiter. */
+    get state(): PreFlag;
+    /** Whether this is a collision arbiter. */
+    isCollisionArbiter(): boolean;
+    /** Whether this is a fluid arbiter. */
+    isFluidArbiter(): boolean;
+    /** Whether this is a sensor arbiter. */
+    isSensorArbiter(): boolean;
+    /**
+     * Total impulse applied by this arbiter in the last step as `(fx, fy, torque)`.
+     *
+     * Pass a `body` to get the impulse applied specifically to that body.
+     * Pass `freshOnly = true` to include only new contact points (not persistent ones).
+     *
+     * Overridden by {@link CollisionArbiter} and {@link FluidArbiter}.
+     *
+     * @param body - One of the two interacting bodies, or `null` for the combined impulse.
+     * @param _freshOnly - When `true`, only count fresh (new) contacts. Default `false`.
+     */
+    totalImpulse(body?: Body | null, _freshOnly?: boolean): Vec3;
+    toString(): string;
+}
+
+/**
+ * Enumeration of physics callback event types.
+ *
+ * Use these singletons to specify which phase of an interaction a listener
+ * should respond to:
+ *
+ * - `BEGIN`   — fired once when two interactors first make contact
+ * - `ONGOING` — fired every simulation step while the interaction persists
+ * - `END`     — fired once when two interactors separate
+ * - `WAKE`    — fired when a body or constraint wakes from sleep
+ * - `SLEEP`   — fired when a body or constraint falls asleep
+ * - `BREAK`   — fired when a constraint exceeds its `maxForce`/`maxError` and breaks
+ * - `PRE`     — fired before collision resolution; allows per-step accept/ignore decisions
+ *
+ * Valid events per listener type:
+ * - {@link BodyListener}: `WAKE`, `SLEEP`
+ * - {@link ConstraintListener}: `WAKE`, `SLEEP`, `BREAK`
+ * - {@link InteractionListener}: `BEGIN`, `ONGOING`, `END`
+ * - {@link PreListener}: always `PRE` (set internally)
+ *
+ * Converted from nape-compiled.js lines 516–657.
+ */
+declare class CbEvent {
+    static __name__: string[];
+    constructor();
+    /** Interaction-start event. Fired once when two interactors first make contact. */
+    static get BEGIN(): CbEvent;
+    /** Interaction-continue event. Fired every step while the interaction persists. */
+    static get ONGOING(): CbEvent;
+    /** Interaction-end event. Fired once when two interactors separate. */
+    static get END(): CbEvent;
+    /** Wake event. Fired when a body or constraint wakes from sleep. */
+    static get WAKE(): CbEvent;
+    /** Sleep event. Fired when a body or constraint falls asleep. */
+    static get SLEEP(): CbEvent;
+    /** Break event. Fired when a constraint exceeds its `maxForce` or `maxError` limit. */
+    static get BREAK(): CbEvent;
+    /** Pre-interaction event. Fired before collision resolution; handler can accept or ignore. */
+    static get PRE(): CbEvent;
+    toString(): string;
+}
+
+/**
+ * Listener type classification.
+ *
+ * - `BODY`        — body event listener
+ * - `CONSTRAINT`  — constraint event listener
+ * - `INTERACTION` — interaction event listener
+ * - `PRE`         — pre-interaction listener
+ *
+ * Converted from nape-compiled.js lines 2554–2646.
+ */
+declare class ListenerType {
+    static __name__: string[];
+    constructor();
+    static get BODY(): ListenerType;
+    static get CONSTRAINT(): ListenerType;
+    static get INTERACTION(): ListenerType;
+    static get PRE(): ListenerType;
+    toString(): string;
+}
+
+/**
+ * Listener — Base class for all physics event listeners.
+ *
+ * Provides common properties (type, event, precedence, space) and
+ * toString() for all listener subclasses.
+ *
+ * Fully modernized from nape-compiled.js lines 231–433.
+ */
+
+/**
+ * Base class for all physics event listeners.
+ *
+ * Cannot be instantiated directly — use one of the concrete subclasses:
+ * {@link BodyListener}, {@link ConstraintListener}, {@link InteractionListener},
+ * or {@link PreListener}.
+ *
+ * Provides common properties (`type`, `event`, `precedence`, `space`) shared
+ * by all listener types.
+ *
+ * Fully modernized from nape-compiled.js lines 231–433.
+ */
+declare class Listener {
+    static __name__: string[];
+    constructor();
+    /** The type of this listener (BODY, CONSTRAINT, INTERACTION, or PRE). */
+    get type(): ListenerType;
+    /**
+     * The event this listener responds to.
+     *
+     * Valid values depend on the concrete listener type — see {@link CbEvent}.
+     * Changing this while the listener is assigned to a space re-registers it.
+     */
+    get event(): CbEvent;
+    set event(event: CbEvent);
+    /**
+     * Execution priority of this listener relative to other listeners for the
+     * same event. Higher values execute first.
+     *
+     * @defaultValue `0`
+     */
+    get precedence(): number;
+    set precedence(precedence: number);
+    /**
+     * The space this listener is currently registered in, or `null` if not registered.
+     *
+     * Assign to register/unregister the listener in a space:
+     * ```ts
+     * listener.space = mySpace;  // register
+     * listener.space = null;     // unregister
+     * ```
+     */
+    get space(): Space | null;
+    set space(space: Space | null);
+    toString(): string;
+}
+
+/**
+ * Concrete type aliases for all dynamically-generated Nape list classes.
+ *
+ * These aliases use {@link TypedListLike} to give IDE-visible types to the
+ * return values of Space and Body query methods, without requiring the
+ * dynamic list classes to be statically importable.
+ */
+
+type BodyList = TypedListLike<Body>;
+type CompoundList = TypedListLike<Compound>;
+type ShapeList = TypedListLike<Shape>;
+type ConstraintList = TypedListLike<Constraint>;
+type ArbiterList = TypedListLike<Arbiter>;
+type ListenerList = TypedListLike<Listener>;
+type RayResultList = TypedListLike<RayResult>;
+type ConvexResultList = TypedListLike<ConvexResult>;
+
+/**
+ * A minimal 2D point used by {@link DebugDraw} draw callbacks.
+ * Renderer implementations receive read-only snapshots — do NOT store these
+ * references; they may be reused by the engine after the call returns.
+ */
+interface DebugVec2 {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * Abstract interface for debug rendering of a physics space.
+ *
+ * Implement this class and pass an instance to `Space.debugDraw()` to visualise
+ * the physics world — shapes, joints, contacts, AABBs, velocities, and
+ * centre-of-mass markers — using any 2D rendering backend (Canvas 2D, PixiJS,
+ * p5.js, Three.js, etc.).
+ *
+ * None of the methods are abstract by language enforcement — they all default
+ * to no-ops so you can override only the primitives your renderer needs.
+ *
+ * @example
+ * ```ts
+ * class CanvasDebugDraw extends DebugDraw {
+ *   constructor(private ctx: CanvasRenderingContext2D) { super(); }
+ *
+ *   drawSegment(p1: DebugVec2, p2: DebugVec2): void {
+ *     this.ctx.beginPath();
+ *     this.ctx.moveTo(p1.x, p1.y);
+ *     this.ctx.lineTo(p2.x, p2.y);
+ *     this.ctx.stroke();
+ *   }
+ *   // ... other methods ...
+ * }
+ *
+ * space.debugDraw(new CanvasDebugDraw(ctx), DebugDrawFlags.ALL);
+ * ```
+ */
+declare abstract class DebugDraw {
+    /**
+     * Draw a line segment between two world-space points.
+     * Used for: polygon edges, velocity vectors, joint lines, AABB edges.
+     * @param p1 - Start point (world space).
+     * @param p2 - End point (world space).
+     * @param colour - Optional ARGB colour hint (0xAARRGGBB). Renderers may ignore this.
+     */
+    drawSegment(p1: DebugVec2, p2: DebugVec2, colour?: number): void;
+    /**
+     * Draw a circle outline.
+     * Used for: static/kinematic circle shapes.
+     * @param centre - World-space centre.
+     * @param radius - Circle radius.
+     * @param colour - Optional ARGB colour hint.
+     */
+    drawCircle(centre: DebugVec2, radius: number, colour?: number): void;
+    /**
+     * Draw a filled circle with an orientation indicator segment.
+     * Used for: dynamic circle shapes. The `axis` segment shows body rotation.
+     * @param centre - World-space centre.
+     * @param radius - Circle radius.
+     * @param axis - World-space end-point of the orientation indicator (from centre).
+     * @param colour - Optional ARGB colour hint.
+     */
+    drawSolidCircle(centre: DebugVec2, radius: number, axis: DebugVec2, colour?: number): void;
+    /**
+     * Draw a polygon outline.
+     * Used for: static/kinematic polygon shapes.
+     * @param vertices - World-space vertices in order. Do NOT store this array.
+     * @param colour - Optional ARGB colour hint.
+     */
+    drawPolygon(vertices: DebugVec2[], colour?: number): void;
+    /**
+     * Draw a filled polygon.
+     * Used for: dynamic polygon shapes.
+     * @param vertices - World-space vertices in order. Do NOT store this array.
+     * @param colour - Optional ARGB colour hint.
+     */
+    drawSolidPolygon(vertices: DebugVec2[], colour?: number): void;
+    /**
+     * Draw a point marker.
+     * Used for: contact points, centre-of-mass markers.
+     * @param position - World-space position.
+     * @param colour - Optional ARGB colour hint.
+     */
+    drawPoint(position: DebugVec2, colour?: number): void;
+}
+
+/**
+ * The physics world. Add bodies, shapes, and constraints, then call `step()` each frame to advance the simulation.
+ */
+declare class Space {
+    /**
+     * @param gravity - Initial gravity vector (default (0, 0)).
+     * @param broadphase - Broadphase algorithm to use.
+     */
+    constructor(gravity?: Vec2, broadphase?: Broadphase);
+    /** Arbitrary user data attached to this Space. */
+    get userData(): Record<string, unknown>;
+    /**
+     * World gravity applied to all dynamic bodies each step. Live Vec2.
+     * @throws If set to null or a disposed Vec2.
+     */
+    get gravity(): Vec2;
+    set gravity(value: Vec2);
+    /** The broadphase algorithm currently in use (SWEEP_AND_PRUNE or DYNAMIC_AABB_TREE). */
+    get broadphase(): Broadphase;
+    /** If true, contact points are sorted for determinism. Default: true. */
+    get sortContacts(): boolean;
+    set sortContacts(value: boolean);
+    /**
+     * Global angular drag coefficient applied to all bodies.
+     * @throws If set to NaN.
+     */
+    get worldAngularDrag(): number;
+    set worldAngularDrag(value: number);
+    /**
+     * Global linear drag coefficient applied to all bodies.
+     * @throws If set to NaN.
+     */
+    get worldLinearDrag(): number;
+    set worldLinearDrag(value: number);
+    /** Read-only list of all Compound objects in this space. */
+    get compounds(): CompoundList;
+    /** Read-only list of all Body objects directly in this space. */
+    get bodies(): BodyList;
+    /** Read-only list of bodies that are awake and actively simulated. */
+    get liveBodies(): BodyList;
+    /** Read-only list of all Constraint objects in this space. */
+    get constraints(): ConstraintList;
+    /** Read-only list of active (awake) constraints. */
+    get liveConstraints(): ConstraintList;
+    /** The static world body that acts as an immovable anchor for constraints. */
+    get world(): Body;
+    /** Read-only list of all active collision/fluid arbiters. */
+    get arbiters(): ArbiterList;
+    /** Read-only list of all event listeners registered to this space. */
+    get listeners(): ListenerList;
+    /** Number of `step()` calls made so far. */
+    get timeStamp(): number;
+    /** Cumulative time simulated (sum of all `deltaTime` values passed to `step()`). */
+    get elapsedTime(): number;
+    /**
+     * Advance the simulation by `deltaTime` seconds.
+     * `velocityIterations` and `positionIterations` control solver accuracy (default 10 each).
+     * @param deltaTime - Time step in seconds; must be strictly positive and not NaN.
+     * @param velocityIterations - Number of velocity solver iterations (minimum 1).
+     * @param positionIterations - Number of position solver iterations (minimum 1).
+     * @throws If `deltaTime` is NaN, non-positive, or any iteration count is less than 1.
+     */
+    step(deltaTime: number, velocityIterations?: number, positionIterations?: number): void;
+    /**
+     * Remove all bodies, constraints, and compounds from this space.
+     * @throws If called during a `step()`.
+     */
+    clear(): void;
+    /**
+     * Call `lambda` for every body in the space, including those inside compounds.
+     * @param lambda - Callback invoked with each Body.
+     * @throws If `lambda` is null.
+     */
+    visitBodies(lambda: (body: Body) => void): void;
+    /**
+     * Call `lambda` for every constraint in the space, including those inside compounds.
+     * @param lambda - Callback invoked with each Constraint.
+     * @throws If `lambda` is null.
+     */
+    visitConstraints(lambda: (constraint: Constraint) => void): void;
+    /**
+     * Call `lambda` for every compound in the space (recursively).
+     * @param lambda - Callback invoked with each Compound.
+     * @throws If `lambda` is null.
+     */
+    visitCompounds(lambda: (compound: Compound) => void): void;
+    /**
+     * Determine the type of interaction between two shapes (COLLISION, FLUID, SENSOR, or null if they don't interact).
+     * @param shape1 - The first shape; must belong to a Body.
+     * @param shape2 - The second shape; must belong to a Body.
+     * @returns The InteractionType, or null if the shapes would not interact.
+     * @throws If either shape is null or not attached to a Body.
+     */
+    interactionType(shape1: Shape, shape2: Shape): InteractionType | null;
+    /**
+     * Return all shapes whose geometry contains the given world-space point.
+     * @param point - The world-space point to test.
+     * @param filter - Optional interaction filter to restrict results.
+     * @param output - Optional existing ShapeList to accumulate results into.
+     * @returns A ShapeList of matching shapes.
+     * @throws If `point` is null or disposed.
+     */
+    shapesUnderPoint(point: Vec2, filter?: InteractionFilter | null, output?: ShapeList | null): ShapeList;
+    /**
+     * Return all bodies that have at least one shape containing the given world-space point.
+     * @param point - The world-space point to test.
+     * @param filter - Optional interaction filter to restrict results.
+     * @param output - Optional existing BodyList to accumulate results into.
+     * @returns A BodyList of matching bodies.
+     * @throws If `point` is null or disposed.
+     */
+    bodiesUnderPoint(point: Vec2, filter?: InteractionFilter | null, output?: BodyList | null): BodyList;
+    /**
+     * Return all shapes that overlap with the given AABB.
+     * @param aabb - The axis-aligned bounding box to test against.
+     * @param containment - If true, only shapes fully contained within the AABB are returned.
+     * @param strict - If true, exact shape geometry is tested; otherwise only AABBs are compared.
+     * @param filter - Optional interaction filter to restrict results.
+     * @param output - Optional existing ShapeList to accumulate results into.
+     * @returns A ShapeList of matching shapes.
+     * @throws If `aabb` is null or degenerate (zero width or height).
+     */
+    shapesInAABB(aabb: AABB, containment?: boolean, strict?: boolean, filter?: InteractionFilter | null, output?: ShapeList | null): ShapeList;
+    /**
+     * Return all bodies that have at least one shape overlapping the given AABB.
+     * @param aabb - The axis-aligned bounding box to test against.
+     * @param containment - If true, only shapes fully contained within the AABB count.
+     * @param strict - If true, exact shape geometry is tested; otherwise only AABBs are compared.
+     * @param filter - Optional interaction filter to restrict results.
+     * @param output - Optional existing BodyList to accumulate results into.
+     * @returns A BodyList of matching bodies.
+     * @throws If `aabb` is null or degenerate (zero width or height).
+     */
+    bodiesInAABB(aabb: AABB, containment?: boolean, strict?: boolean, filter?: InteractionFilter | null, output?: BodyList | null): BodyList;
+    /**
+     * Return all shapes that overlap with a circle defined by `position` and `radius`.
+     * @param position - World-space centre of the query circle.
+     * @param radius - Radius of the query circle; must be strictly positive and not NaN.
+     * @param containment - If true, only shapes fully contained within the circle are returned.
+     * @param filter - Optional interaction filter to restrict results.
+     * @param output - Optional existing ShapeList to accumulate results into.
+     * @returns A ShapeList of matching shapes.
+     * @throws If `position` is null/disposed, or `radius` is NaN or non-positive.
+     */
+    shapesInCircle(position: Vec2, radius: number, containment?: boolean, filter?: InteractionFilter | null, output?: ShapeList | null): ShapeList;
+    /**
+     * Return all bodies that have at least one shape overlapping a query circle.
+     * @param position - World-space centre of the query circle.
+     * @param radius - Radius of the query circle; must be strictly positive and not NaN.
+     * @param containment - If true, only shapes fully contained within the circle count.
+     * @param filter - Optional interaction filter to restrict results.
+     * @param output - Optional existing BodyList to accumulate results into.
+     * @returns A BodyList of matching bodies.
+     * @throws If `position` is null/disposed, or `radius` is NaN or non-positive.
+     */
+    bodiesInCircle(position: Vec2, radius: number, containment?: boolean, filter?: InteractionFilter | null, output?: BodyList | null): BodyList;
+    /**
+     * Return all shapes in the space that overlap with `shape`.
+     * @param shape - The query shape; must be attached to a Body.
+     * @param containment - If true, only shapes fully contained within `shape` are returned.
+     * @param filter - Optional interaction filter to restrict results.
+     * @param output - Optional existing ShapeList to accumulate results into.
+     * @returns A ShapeList of overlapping shapes.
+     * @throws If `shape` is null, not attached to a Body, or is an invalid polygon.
+     */
+    shapesInShape(shape: Shape, containment?: boolean, filter?: InteractionFilter | null, output?: ShapeList | null): ShapeList;
+    /**
+     * Return all bodies in the space that have at least one shape overlapping `shape`.
+     * @param shape - The query shape; must be attached to a Body.
+     * @param containment - If true, only shapes fully contained within `shape` count.
+     * @param filter - Optional interaction filter to restrict results.
+     * @param output - Optional existing BodyList to accumulate results into.
+     * @returns A BodyList of overlapping bodies.
+     * @throws If `shape` is null, not attached to a Body, or is an invalid polygon.
+     */
+    bodiesInShape(shape: Shape, containment?: boolean, filter?: InteractionFilter | null, output?: BodyList | null): BodyList;
+    /**
+     * Return all shapes in the space that overlap with any shape attached to `body`.
+     * Equivalent to calling `shapesInShape` for each of `body`'s shapes and merging results.
+     * @param body - The body whose shapes are used as the query region.
+     * @param filter - Optional interaction filter to restrict results.
+     * @param output - Optional existing ShapeList to accumulate results into.
+     * @returns A ShapeList of overlapping shapes.
+     * @throws If `body` is null.
+     */
+    shapesInBody(body: Body, filter?: InteractionFilter | null, output?: ShapeList | null): ShapeList;
+    /**
+     * Return all bodies in the space that overlap with any shape attached to `body`.
+     * Equivalent to calling `bodiesInShape` for each of `body`'s shapes and merging results.
+     * @param body - The body whose shapes are used as the query region.
+     * @param filter - Optional interaction filter to restrict results.
+     * @param output - Optional existing BodyList to accumulate results into.
+     * @returns A BodyList of overlapping bodies.
+     * @throws If `body` is null.
+     */
+    bodiesInBody(body: Body, filter?: InteractionFilter | null, output?: BodyList | null): BodyList;
+    /**
+     * Sweep `shape` along its current velocity for `deltaTime` seconds and return the first hit.
+     * @param shape - The shape to sweep; must belong to a Body.
+     * @param deltaTime - Duration of the sweep; must be non-negative.
+     * @param liveSweep - If true, other body velocities are considered during the sweep.
+     * @param filter - Optional interaction filter to restrict results.
+     * @returns The first RayResult hit, or null if nothing was struck.
+     * @throws If `shape` is null, not attached to a Body, or `deltaTime` is negative/NaN.
+     */
+    convexCast(shape: Shape, deltaTime: number, liveSweep?: boolean, filter?: InteractionFilter | null): ConvexResult | null;
+    /**
+     * Sweep `shape` along its current velocity for `deltaTime` seconds and return all hits.
+     * @param shape - The shape to sweep; must belong to a Body.
+     * @param deltaTime - Duration of the sweep; must be non-negative.
+     * @param liveSweep - If true, other body velocities are considered during the sweep.
+     * @param filter - Optional interaction filter to restrict results.
+     * @param output - Optional existing RayResultList to accumulate results into.
+     * @returns A RayResultList of all hits encountered during the sweep.
+     * @throws If `shape` is null, not attached to a Body, or `deltaTime` is negative/NaN.
+     */
+    convexMultiCast(shape: Shape, deltaTime: number, liveSweep?: boolean, filter?: InteractionFilter | null, output?: ConvexResultList | null): ConvexResultList;
+    /**
+     * Cast a ray into the space and return the closest hit.
+     * @param ray - The ray to cast.
+     * @param inner - If true, shapes are tested from the inside as well (useful for concave queries).
+     * @param filter - Optional interaction filter to restrict results.
+     * @returns The closest RayResult, or null if nothing was hit.
+     * @throws If `ray` is null.
+     */
+    rayCast(ray: Ray, inner?: boolean, filter?: InteractionFilter | null): RayResult | null;
+    /**
+     * Cast a ray into the space and return all hits.
+     * @param ray - The ray to cast.
+     * @param inner - If true, shapes are tested from the inside as well.
+     * @param filter - Optional interaction filter to restrict results.
+     * @param output - Optional existing RayResultList to accumulate results into.
+     * @returns A RayResultList of all shapes the ray intersected.
+     * @throws If `ray` is null.
+     */
+    rayMultiCast(ray: Ray, inner?: boolean, filter?: InteractionFilter | null, output?: RayResultList | null): RayResultList;
+    /**
+     * Draw the current state of the physics world using a user-supplied renderer.
+     *
+     * Walks all bodies, shapes, constraints, contacts, AABBs, and velocity
+     * vectors and calls the appropriate draw primitives on `drawer`. Only the
+     * layers selected by `flags` are rendered.
+     *
+     * **Performance note:** this method allocates temporary vertex arrays for
+     * polygon shapes on every call. It is intended for development/debug use
+     * only — do not call it in a performance-critical production loop.
+     *
+     * @param drawer - The renderer to use. Must not be null.
+     * @param flags  - Bitmask of {@link DebugDrawFlags} layers to render.
+     *                 Defaults to `DebugDrawFlags.ALL`.
+     *
+     * @example
+     * ```ts
+     * space.debugDraw(myDrawer, DebugDrawFlags.SHAPES | DebugDrawFlags.JOINTS);
+     * ```
+     */
+    debugDraw(drawer: DebugDraw, flags?: number): void;
+    /**
+     * Returns a brief string summary of this space.
+     * @returns A string in the form `Space(bodies=N)`.
+     */
+    toString(): string;
+}
+
+/**
+ * Body type enumeration.
+ *
+ * - `STATIC`    — immovable, infinite mass (walls, floors)
+ * - `DYNAMIC`   — fully simulated (default)
+ * - `KINEMATIC` — moves only via velocity, not affected by forces
+ *
+ * Converted from nape-compiled.js lines 24640–24705.
+ */
+declare class BodyType {
+    static __name__: string[];
+    constructor();
+    static get STATIC(): BodyType;
+    static get DYNAMIC(): BodyType;
+    static get KINEMATIC(): BodyType;
+    toString(): string;
+}
+
+/**
+ * Fluid properties for shapes that act as fluid regions.
+ *
+ * Controls density, viscosity, and per-fluid gravity override.
+ * Internally wraps a ZPP_FluidProperties and is registered as
+ * the public `nape.phys.FluidProperties` class in the compiled namespace.
+ *
+ * Converted from nape-compiled.js lines 37002–37511.
+ */
+declare class FluidProperties {
+    static __name__: string[];
+    constructor(density?: number, viscosity?: number);
+    get density(): number;
+    set density(value: number);
+    get viscosity(): number;
+    set viscosity(value: number);
+    get gravity(): any;
+    set gravity(gravity: any);
+    get userData(): Record<string, unknown>;
+    get shapes(): any;
+    copy(): FluidProperties;
+    toString(): string;
+}
+
+/**
+ * Mass mode for a body.
+ *
+ * - `DEFAULT` — use computed mass from shapes
+ * - `FIXED`   — use a fixed mass value
+ *
+ * Converted from nape-compiled.js lines 26966–27013.
+ */
+declare class MassMode {
+    static __name__: string[];
+    constructor();
+    static get DEFAULT(): MassMode;
+    static get FIXED(): MassMode;
+    toString(): string;
+}
+
+/**
+ * Inertia mode for a body.
+ *
+ * - `DEFAULT` — use computed inertia from shapes
+ * - `FIXED`   — use a fixed inertia value
+ *
+ * Converted from nape-compiled.js lines 26343–26390.
+ */
+declare class InertiaMode {
+    static __name__: string[];
+    constructor();
+    static get DEFAULT(): InertiaMode;
+    static get FIXED(): InertiaMode;
+    toString(): string;
+}
+
+/**
+ * Gravity mass mode for a body.
+ *
+ * - `DEFAULT` — use computed mass for gravity
+ * - `FIXED`   — use a fixed gravity mass value
+ * - `SCALED`  — scale the computed gravity mass
+ *
+ * Converted from nape-compiled.js lines 26272–26342.
+ */
+declare class GravMassMode {
+    static __name__: string[];
+    constructor();
+    static get DEFAULT(): GravMassMode;
+    static get FIXED(): GravMassMode;
+    static get SCALED(): GravMassMode;
+    toString(): string;
+}
+
+/**
+ * A rigid body in the physics simulation. Add shapes to give it geometry, then add it to a `Space` to participate in simulation.
+ */
+declare class Body extends Interactor {
+    static __name__: string[];
+    static __super__: typeof Interactor;
+    /** If true, this body is included in debug rendering. */
+    debugDraw: boolean;
+    /**
+     * @param type - Body type (DYNAMIC by default).
+     * @param position - Initial world-space position (defaults to origin).
+     */
+    constructor(type?: BodyType, position?: Vec2);
+    /** The body type: DYNAMIC, STATIC, or KINEMATIC. Cannot be changed mid-step. */
+    get type(): BodyType;
+    set type(value: BodyType);
+    /** Return true if this body is static. */
+    isStatic(): boolean;
+    /** Return true if this body is dynamic. */
+    isDynamic(): boolean;
+    /** Return true if this body is kinematic. */
+    isKinematic(): boolean;
+    /** World-space position of the body's origin. Live Vec2 — mutating it moves the body. */
+    get position(): Vec2;
+    set position(value: Vec2);
+    /**
+     * Rotation of the body in radians.
+     * @throws If set on a static body that is already in a space.
+     */
+    get rotation(): number;
+    set rotation(value: number);
+    /** Linear velocity in world space (units/s). Live Vec2. Static bodies cannot have velocity. */
+    get velocity(): Vec2;
+    set velocity(value: Vec2);
+    /** Angular velocity in radians per second. */
+    get angularVel(): number;
+    set angularVel(value: number);
+    /** Desired velocity for kinematic bodies; the engine tries to match this each step. */
+    get kinematicVel(): Vec2;
+    set kinematicVel(value: Vec2);
+    /** Desired angular velocity for kinematic bodies. */
+    get kinAngVel(): number;
+    set kinAngVel(value: number);
+    /** Surface velocity used in friction calculations. */
+    get surfaceVel(): Vec2;
+    set surfaceVel(value: Vec2);
+    /** Accumulated force applied to this body for the current step (cleared after each step). */
+    get force(): Vec2;
+    set force(value: Vec2);
+    /** Accumulated torque applied to this body for the current step (only for DYNAMIC bodies). */
+    get torque(): number;
+    set torque(value: number);
+    /**
+     * Mass in kg. Must be finite and > 0. Setting switches massMode to FIXED.
+     * @throws If the body is the world body, or if no shapes are present in DEFAULT mass mode.
+     */
+    get mass(): number;
+    set mass(value: number);
+    /**
+     * Moment of inertia. Must be finite and > 0. Setting switches inertiaMode to FIXED.
+     * @throws If the body is the world body, or if no shapes are present in DEFAULT inertia mode.
+     */
+    get inertia(): number;
+    set inertia(value: number);
+    /** Effective mass used by the constraint solver (accounts for allowMovement). */
+    get constraintMass(): number;
+    /** Effective inertia used by the constraint solver (accounts for allowRotation). */
+    get constraintInertia(): number;
+    /** Gravitational mass. Defaults to the same as `mass`. */
+    get gravMass(): number;
+    set gravMass(value: number);
+    /** Scale factor applied to gravMass relative to the dynamic mass. */
+    get gravMassScale(): number;
+    set gravMassScale(value: number);
+    /** If true, continuous collision detection (CCD) is enabled for this body. */
+    get isBullet(): boolean;
+    set isBullet(value: boolean);
+    /** If true, CCD is disabled even if `isBullet` is set. */
+    get disableCCD(): boolean;
+    set disableCCD(value: boolean);
+    /** If false, translational motion is frozen (infinite effective mass). */
+    get allowMovement(): boolean;
+    set allowMovement(value: boolean);
+    /** If false, rotational motion is frozen (infinite effective inertia). */
+    get allowRotation(): boolean;
+    set allowRotation(value: boolean);
+    /**
+     * True if the body is currently sleeping.
+     * @throws If the body is not in a Space.
+     */
+    get isSleeping(): boolean;
+    /** List of shapes attached to this body. */
+    get shapes(): NapeList<Shape>;
+    /** The Space this body belongs to. Setting adds/removes it from the space. */
+    get space(): Space;
+    set space(value: Space | null);
+    /** The Compound this body belongs to, or null. */
+    get compound(): Compound | null;
+    set compound(value: Compound | null);
+    /**
+     * World-space AABB enclosing all shapes.
+     * @throws If this is the world body.
+     */
+    get bounds(): AABB;
+    /** Constraint-solved velocity (read-only view used by the solver). */
+    get constraintVelocity(): Vec2;
+    /**
+     * Local-space centre of mass (read-only, lazy-computed from shapes).
+     * @throws If this is the world body.
+     */
+    get localCOM(): Vec2;
+    /**
+     * World-space centre of mass (read-only, lazy-computed).
+     * @throws If this is the world body.
+     */
+    get worldCOM(): Vec2;
+    /** Controls how mass is computed: DEFAULT (from shapes) or FIXED (manually set). */
+    get massMode(): MassMode;
+    set massMode(value: MassMode);
+    /** Controls how inertia is computed: DEFAULT or FIXED. */
+    get inertiaMode(): InertiaMode;
+    set inertiaMode(value: InertiaMode);
+    /** Controls gravitational mass: DEFAULT, FIXED, or SCALED. */
+    get gravMassMode(): GravMassMode;
+    set gravMassMode(value: GravMassMode);
+    /**
+     * Create a deep copy of this body (shapes, mass properties, etc.).
+     * @returns A new Body with identical configuration.
+     * @throws If this is the world body.
+     */
+    copy(): Body;
+    /**
+     * String identifier like `(dynamic)#42`.
+     * @returns A human-readable description of this body.
+     */
+    toString(): string;
+    /**
+     * Manually integrate the body's position and rotation by `deltaTime` seconds (outside of `Space.step`).
+     * @param deltaTime - Time in seconds to integrate over.
+     * @returns `this` for chaining.
+     * @throws If `deltaTime` is NaN.
+     */
+    integrate(deltaTime: number): Body;
+    /**
+     * Transform a point from local body space to world space.
+     * @param point - The point in local space.
+     * @param weak - If true, the returned Vec2 is a weak (pooled) reference.
+     * @returns The transformed point in world space.
+     */
+    localPointToWorld(point: Vec2, weak?: boolean): Vec2;
+    /**
+     * Transform a point from world space to local body space.
+     * @param point - The point in world space.
+     * @param weak - If true, the returned Vec2 is a weak (pooled) reference.
+     * @returns The transformed point in local space.
+     */
+    worldPointToLocal(point: Vec2, weak?: boolean): Vec2;
+    /**
+     * Rotate a vector from local body space to world space (no translation).
+     * @param vector - The vector in local space.
+     * @param weak - If true, the returned Vec2 is a weak (pooled) reference.
+     * @returns The rotated vector in world space.
+     */
+    localVectorToWorld(vector: Vec2, weak?: boolean): Vec2;
+    /**
+     * Rotate a vector from world space to local body space (no translation).
+     * @param vector - The vector in world space.
+     * @param weak - If true, the returned Vec2 is a weak (pooled) reference.
+     * @returns The rotated vector in local space.
+     */
+    worldVectorToLocal(vector: Vec2, weak?: boolean): Vec2;
+    /**
+     * Apply a linear (and optionally angular) impulse to the body.
+     * If `pos` is given, it creates a torque about the body's centre.
+     * If `sleepable` is true, sleeping bodies are not woken.
+     * @param impulse - The linear impulse vector (world space).
+     * @param pos - Optional world-space point of application.
+     * @param sleepable - If true, the body will not be woken if sleeping.
+     * @returns `this` for chaining.
+     */
+    applyImpulse(impulse: Vec2, pos?: Vec2, sleepable?: boolean): Body;
+    /**
+     * Apply a direct angular impulse (change in angular velocity × inertia).
+     * @param impulse - The angular impulse magnitude.
+     * @param sleepable - If true, the body will not be woken if sleeping.
+     * @returns `this` for chaining.
+     */
+    applyAngularImpulse(impulse: number, sleepable?: boolean): Body;
+    /**
+     * Set linear and angular velocity so the body reaches the given target pose in `deltaTime` seconds.
+     * Useful for kinematic or manually driven bodies.
+     * @param targetPosition - Desired world-space position.
+     * @param targetRotation - Desired rotation in radians.
+     * @param deltaTime - Time in seconds over which to reach the target.
+     * @returns `this` for chaining.
+     * @throws If `targetPosition` is null or `deltaTime` is zero.
+     */
+    setVelocityFromTarget(targetPosition: Vec2, targetRotation: number, deltaTime: number): Body;
+    /**
+     * Translate all shapes attached to this body in local space by `translation`.
+     * @param translation - Offset vector in local space.
+     * @returns `this` for chaining.
+     */
+    translateShapes(translation: Vec2): Body;
+    /**
+     * Rotate all shapes attached to this body in local space by `angle` radians.
+     * @param angle - Rotation in radians.
+     * @returns `this` for chaining.
+     */
+    rotateShapes(angle: number): Body;
+    /**
+     * Scale all shapes attached to this body in local space.
+     * @param scaleX - Horizontal scale factor.
+     * @param scaleY - Vertical scale factor.
+     * @returns `this` for chaining.
+     */
+    scaleShapes(scaleX: number, scaleY: number): Body;
+    /**
+     * Apply an affine transform matrix to all shapes in local space.
+     * @param matrix - The 2D affine transformation matrix.
+     * @returns `this` for chaining.
+     */
+    transformShapes(matrix: Mat23): Body;
+    /**
+     * Translate all shapes and adjust the body position so the local centre of mass coincides with the body origin.
+     * @returns `this` for chaining.
+     * @throws If the body has no shapes.
+     */
+    align(): Body;
+    /**
+     * Rotate the body about a world-space pivot point by `angle` radians.
+     * Moves the body's position and increments its rotation.
+     * @param centre - World-space pivot point.
+     * @param angle - Rotation in radians.
+     * @returns `this` for chaining.
+     * @throws If `centre` is null or `angle` is NaN.
+     */
+    rotate(centre: Vec2, angle: number): Body;
+    /**
+     * Set the same `Material` on every shape attached to this body.
+     * @param material - The material to apply.
+     * @returns `this` for chaining.
+     */
+    setShapeMaterials(material: Material): Body;
+    /**
+     * Set the same `InteractionFilter` on every shape attached to this body.
+     * @param filter - The interaction filter to apply.
+     * @returns `this` for chaining.
+     */
+    setShapeFilters(filter: InteractionFilter): Body;
+    /**
+     * Set the same `FluidProperties` on every shape attached to this body.
+     * @param fluidProperties - The fluid properties to apply.
+     * @returns `this` for chaining.
+     */
+    setShapeFluidProperties(fluidProperties: FluidProperties): Body;
+    /**
+     * Test whether a world-space point lies inside any shape attached to this body.
+     * @param point - The point to test in world space.
+     * @returns True if the point is inside at least one shape.
+     */
+    contains(point: Vec2): boolean;
+    /**
+     * Return the set of bodies connected to this body via constraints.
+     * @param depth - Maximum traversal depth (-1 means unlimited).
+     * @param output - Optional existing list to accumulate results into.
+     * @returns A BodyList of connected bodies.
+     */
+    connectedBodies(depth?: number, output?: BodyList | null): BodyList;
+    /**
+     * Return the set of bodies currently interacting with this body via arbiters.
+     * @param type - Filter by interaction type (COLLISION, FLUID, SENSOR), or null for all.
+     * @param _depth - Unused; reserved for future use.
+     * @param output - Optional existing list to accumulate results into.
+     * @returns A BodyList of interacting bodies.
+     */
+    interactingBodies(type?: InteractionType | null, _depth?: number, output?: BodyList | null): BodyList;
+    /**
+     * Sum of normal (penetration-resolving) impulses received from collision arbiters this step.
+     * @param body - If provided, only arbiters shared with `body` are summed.
+     * @param freshOnly - If true, only newly created arbiters are considered.
+     * @returns A Vec3 where x/y are the linear component and z is the angular component.
+     */
+    normalImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
+    /**
+     * Sum of tangent (friction) impulses received from collision arbiters this step.
+     * @param body - If provided, only arbiters shared with `body` are summed.
+     * @param freshOnly - If true, only newly created arbiters are considered.
+     * @returns A Vec3 where x/y are the linear component and z is the angular component.
+     */
+    tangentImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
+    /**
+     * Sum of total contact impulses (normal + tangent) from collision arbiters this step.
+     * @param body - If provided, only arbiters shared with `body` are summed.
+     * @param freshOnly - If true, only newly created arbiters are considered.
+     * @returns A Vec3 where x/y are the linear component and z is the angular component.
+     */
+    totalContactsImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
+    /**
+     * Sum of rolling (angular friction) impulses from collision arbiters this step.
+     * @param body - If provided, only arbiters shared with `body` are summed.
+     * @param freshOnly - If true, only newly created arbiters are considered.
+     * @returns The total rolling impulse scalar.
+     */
+    rollingImpulse(body?: Body | null, freshOnly?: boolean): number;
+    /**
+     * Sum of buoyancy impulses received from fluid arbiters this step.
+     * @param body - If provided, only arbiters shared with `body` are summed.
+     * @returns A Vec3 where x/y are the linear component and z is the angular component.
+     */
+    buoyancyImpulse(body?: Body | null): Vec3;
+    /**
+     * Sum of fluid drag impulses received from fluid arbiters this step.
+     * @param body - If provided, only arbiters shared with `body` are summed.
+     * @returns A Vec3 where x/y are the linear component and z is the angular component.
+     */
+    dragImpulse(body?: Body | null): Vec3;
+    /**
+     * Sum of total fluid impulses (buoyancy + drag) from fluid arbiters this step.
+     * @param body - If provided, only arbiters shared with `body` are summed.
+     * @returns A Vec3 where x/y are the linear component and z is the angular component.
+     */
+    totalFluidImpulse(body?: Body | null): Vec3;
+    /**
+     * Sum of impulses applied to this body by all attached constraints this step.
+     * @returns A Vec3 where x/y are the linear component and z is the angular component.
+     */
+    constraintsImpulse(): Vec3;
+    /**
+     * Sum of all impulses (contacts + constraints) applied to this body this step, excluding sensor arbiters.
+     * @param body - If provided, only arbiters shared with `body` are summed.
+     * @param freshOnly - If true, only newly created contact arbiters are considered.
+     * @returns A Vec3 where x/y are the linear component and z is the angular component.
+     */
+    totalImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
+    /**
+     * Compute a heuristic crush factor indicating how strongly this body is being compressed from multiple directions.
+     * A value near zero means balanced forces; larger values indicate compression.
+     * @returns The crush factor (dimensionless).
+     * @throws If the body is not in a Space.
+     */
+    crushFactor(): number;
+    private _getArbiters;
+    private _getConstraints;
+    private _arbiterImpulseQuery;
+}
+
+/**
+ * Shape type classification.
+ *
+ * - `CIRCLE`  — circle shape
+ * - `POLYGON` — polygon shape
+ *
+ * Converted from nape-compiled.js lines 30435–30482.
+ */
+declare class ShapeType {
+    static __name__: string[];
+    constructor();
+    static get CIRCLE(): ShapeType;
+    static get POLYGON(): ShapeType;
+    toString(): string;
+}
+
+/**
+ * Base class for physics shapes (Circle, Polygon). Never instantiated directly — use
+ * `new Circle(...)` or `Polygon.box(...)` etc.
+ */
+declare class Shape extends Interactor {
+    /** The shape type: CIRCLE or POLYGON. */
+    get type(): ShapeType;
+    /** Returns true if this is a Circle shape. */
+    isCircle(): boolean;
+    /** Returns true if this is a Polygon shape. */
+    isPolygon(): boolean;
+    /**
+     * The Body this shape belongs to. Setting moves the shape between bodies.
+     */
+    get body(): Body;
+    set body(value: Body | null);
+    /** Cast to Circle, or null if this is not a circle. */
+    get castCircle(): Shape | null;
+    /** Cast to Polygon, or null if this is not a polygon. */
+    get castPolygon(): Shape | null;
+    /** World-space centre of mass of this shape (read-only, lazy-computed). */
+    get worldCOM(): Vec2;
+    /**
+     * Local-space centre of mass. Can be set to override the default shape centroid.
+     */
+    get localCOM(): Vec2;
+    set localCOM(value: Vec2);
+    /** Cross-sectional area of this shape. */
+    get area(): number;
+    /** Contribution to moment of inertia (about local centroid, unit density). */
+    get inertia(): number;
+    /** Angular drag coefficient for this shape. */
+    get angDrag(): number;
+    /** The Material assigned to this shape (controls friction, elasticity, density). */
+    get material(): Material;
+    set material(value: Material);
+    /** The InteractionFilter controlling which shapes interact with this one. */
+    get filter(): InteractionFilter;
+    set filter(value: InteractionFilter);
+    /** Fluid simulation properties for this shape. Auto-created on first access. */
+    get fluidProperties(): FluidProperties;
+    set fluidProperties(value: FluidProperties);
+    /** Set of callback types registered on this shape for event dispatch. */
+    get cbTypes(): CbTypeSet;
+    /** If true, this shape participates in fluid interaction. */
+    get fluidEnabled(): boolean;
+    set fluidEnabled(value: boolean);
+    /** If true, this shape acts as a sensor (no physical response, only callbacks). */
+    get sensorEnabled(): boolean;
+    set sensorEnabled(value: boolean);
+    /** World-space AABB of this shape (updated each step). */
+    get bounds(): AABB;
+    /**
+     * Translate the shape's local vertices by the given vector (in-place).
+     * @param translation - The displacement vector to apply.
+     * @returns `this` for chaining.
+     */
+    translate(translation: Vec2): Shape;
+    /**
+     * Scale the shape's local geometry. Circles require uniform scaling.
+     * @param scaleX - Horizontal scale factor (must be non-zero).
+     * @param scaleY - Vertical scale factor (must be non-zero).
+     * @returns `this` for chaining.
+     */
+    scale(scaleX: number, scaleY: number): Shape;
+    /**
+     * Rotate the shape's local vertices by `angle` radians.
+     * @param angle - Rotation in radians.
+     * @returns `this` for chaining.
+     */
+    rotate(angle: number): Shape;
+    /**
+     * Apply a Mat23 affine transform to the shape's local geometry.
+     * @param matrix - The transformation matrix (must be non-singular; Circles require equiorthogonal).
+     * @returns `this` for chaining.
+     */
+    transform(matrix: {
+        _inner: NapeInner;
+    }): Shape;
+    /**
+     * Return true if the given world-space point lies inside this shape.
+     * Requires the shape to be attached to a Body.
+     * @param point - The world-space point to test.
+     * @returns True if the point is inside this shape.
+     */
+    contains(point: Vec2): boolean;
+    /**
+     * Create a deep copy of this shape with the same type, geometry, material, and filter.
+     * @returns A new Shape instance independent of this one.
+     */
+    copy(): Shape;
+    toString(): string;
+    /** Setup worldCOM lazy Vec2 wrapper */
+    private _setupWorldCOM;
+}
+/** Lightweight typed interface for the callback type set on a shape. */
+interface CbTypeSet {
+    readonly _inner: NapeInner;
+    add(cbType: {
+        _inner: NapeInner;
+    }): void;
+    remove(cbType: {
+        _inner: NapeInner;
+    }): void;
+    has(cbType: {
+        _inner: NapeInner;
+    }): boolean;
+    clear(): void;
+    readonly length: number;
+}
+
+/**
+ * Result from a convex-cast query.
+ *
+ * Provides the contact normal, position, time-of-impact, and shape hit.
+ * Instances are pooled — call `dispose()` when done to return to pool.
+ */
+declare class ConvexResult {
+    static __name__: string[];
+    constructor();
+    get normal(): Vec2;
+    get position(): Vec2;
+    get toi(): number;
+    get shape(): Shape;
+    dispose(): void;
+    toString(): string;
+}
+
+export { AABB as A, Body as B, CollisionArbiter as C, DebugDraw as D, Edge as E, FluidArbiter as F, GravMassMode as G, Polygon as H, InteractionFilter as I, RayResult as J, type RayResultList as K, Listener as L, Material as M, NapeList as N, type ShapeList as O, PreFlag as P, ShapeType as Q, Ray as R, Shape as S, Space as T, type TypedListLike as U, Vec2 as V, Vec3 as a, CbEvent as b, Interactor as c, InteractionType as d, Constraint as e, Arbiter as f, MatMN as g, type ArbiterList as h, ArbiterType as i, type BodyList as j, BodyType as k, Broadphase as l, type CbTypeSet as m, Compound as n, type CompoundList as o, type ConstraintList as p, ConvexResult as q, type ConvexResultList as r, type DebugVec2 as s, FluidProperties as t, InertiaMode as u, InteractionGroup as v, type ListenerList as w, ListenerType as x, MassMode as y, Mat23 as z };