@newkrok/nape-js 3.6.0 → 3.7.0

package/dist/index.d.ts

@@ -1186,13 +1186,13 @@ declare class Constraint {
      * 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.
+     * @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.
+     * @param _fn - Function to call for each body.
      */
     visitBodies(_fn: (body: Body) => void): void;
     /**
@@ -1214,25 +1214,75 @@ declare class Constraint {
  */
 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;
 }
 
@@ -1278,433 +1328,948 @@ declare class InteractionType {
 }
 
 /**
- * The physics world. Add bodies, shapes, and constraints, then call `step()` each frame to advance the simulation.
+ * 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.
  */
-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. */
+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;
     /**
-     * World gravity applied to all dynamic bodies each step. Live Vec2.
-     * @throws If set to null or a disposed Vec2.
+     * 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).
      */
-    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);
+    constructor(localVerts?: Vec2[] | any, material?: Material, filter?: InteractionFilter);
     /**
-     * Global angular drag coefficient applied to all bodies.
-     * @throws If set to NaN.
+     * 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.
      */
-    get worldAngularDrag(): number;
-    set worldAngularDrag(value: number);
+    static rect(x: number, y: number, width: number, height: number, weak?: boolean): Vec2[];
     /**
-     * Global linear drag coefficient applied to all bodies.
-     * @throws If set to NaN.
+     * 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.
      */
-    get worldLinearDrag(): number;
-    set worldLinearDrag(value: number);
-    /** Read-only list of all Compound objects in this space. */
-    get compounds(): object;
-    /** Read-only list of all Body objects directly in this space. */
-    get bodies(): object;
-    /** Read-only list of bodies that are awake and actively simulated. */
-    get liveBodies(): object;
-    /** Read-only list of all Constraint objects in this space. */
-    get constraints(): object;
-    /** Read-only list of active (awake) constraints. */
-    get liveConstraints(): object;
-    /** 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(): object;
-    /** Read-only list of all event listeners registered to this space. */
-    get listeners(): object;
-    /** Number of `step()` calls made so far. */
-    get timeStamp(): number;
-    /** Cumulative time simulated (sum of all `deltaTime` values passed to `step()`). */
-    get elapsedTime(): number;
+    static box(width: number, height?: number, weak?: boolean): Vec2[];
     /**
-     * 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.
+     * 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.
      */
-    step(deltaTime: number, velocityIterations?: number, positionIterations?: number): void;
+    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;
     /**
-     * Remove all bodies, constraints, and compounds from this space.
-     * @throws If called during a `step()`.
+     * 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.
      */
-    clear(): void;
+    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;
     /**
-     * Call `lambda` for every body in the space, including those inside compounds.
-     * @param lambda - Callback invoked with each Body.
-     * @throws If `lambda` is null.
+     * Wrap a ZPP_Vec2 vertex into its public Vec2 outer.
+     * Mirrors the compiled vertex wrapping pattern.
      */
-    visitBodies(lambda: (body: Body) => void): void;
+    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();
     /**
-     * Call `lambda` for every constraint in the space, including those inside compounds.
-     * @param lambda - Callback invoked with each Constraint.
-     * @throws If `lambda` is null.
+     * The list of active contact points between the two shapes.
+     * Contains 1 or 2 {@link Contact} objects depending on the collision geometry.
      */
-    visitConstraints(lambda: (constraint: Constraint) => void): void;
+    get contacts(): object;
     /**
-     * Call `lambda` for every compound in the space (recursively).
-     * @param lambda - Callback invoked with each Compound.
-     * @throws If `lambda` is null.
+     * Collision normal vector pointing from `shape1` toward `shape2`.
+     * Read-only; available after the arbiter is active.
      */
-    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?: object | null): object;
-    /**
-     * 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?: object | null): object;
-    /**
-     * 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?: object | null): object;
-    /**
-     * 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?: object | null): object;
+    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;
     /**
-     * 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.
+     * 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._
      */
-    shapesInCircle(position: Vec2, radius: number, containment?: boolean, filter?: InteractionFilter | null, output?: object | null): object;
+    get elasticity(): number;
+    set elasticity(value: number);
     /**
-     * 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.
+     * Dynamic (kinetic) friction coefficient — applied when the contact is sliding.
+     * Combined from the two shapes' material values. _Mutable in pre-handler only._
      */
-    bodiesInCircle(position: Vec2, radius: number, containment?: boolean, filter?: InteractionFilter | null, output?: object | null): object;
+    get dynamicFriction(): number;
+    set dynamicFriction(value: number);
     /**
-     * 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.
+     * Static friction coefficient — applied when the contact is at rest.
+     * Combined from the two shapes' material values. _Mutable in pre-handler only._
      */
-    shapesInShape(shape: Shape, containment?: boolean, filter?: InteractionFilter | null, output?: object | null): object;
+    get staticFriction(): number;
+    set staticFriction(value: number);
     /**
-     * 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.
+     * Rolling friction coefficient — resists rolling motion.
+     * Combined from the two shapes' material values. _Mutable in pre-handler only._
      */
-    bodiesInShape(shape: Shape, containment?: boolean, filter?: InteractionFilter | null, output?: object | null): object;
+    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;
     /**
-     * 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.
+     * 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`.
      */
-    shapesInBody(body: Body, filter?: InteractionFilter | null, output?: object | null): object;
+    normalImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
     /**
-     * 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.
+     * 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`.
      */
-    bodiesInBody(body: Body, filter?: InteractionFilter | null, output?: object | null): object;
+    tangentImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
+    /** Total impulse (normal + tangent + rolling) accumulated across all contacts. */
+    totalImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
     /**
-     * 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.
+     * 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`.
      */
-    convexCast(shape: Shape, deltaTime: number, liveSweep?: boolean, filter?: InteractionFilter | null): object | null;
+    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();
     /**
-     * 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.
+     * Centre of the overlap region between the fluid and the body shape.
+     * _Mutable in pre-handler only._
      */
-    convexMultiCast(shape: Shape, deltaTime: number, liveSweep?: boolean, filter?: InteractionFilter | null, output?: object | null): object;
+    get position(): Vec2;
+    set position(value: Vec2);
     /**
-     * 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.
+     * Area of the overlap region in pixels². Used to compute buoyancy force.
+     * Must be strictly positive and finite.
+     * _Mutable in pre-handler only._
      */
-    rayCast(ray: Ray, inner?: boolean, filter?: InteractionFilter | null): object | null;
+    get overlap(): number;
+    set overlap(value: number);
     /**
-     * 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.
+     * Buoyancy impulse applied in the last step as `(fx, fy, torque)`.
+     * @param body - One of the two bodies, or `null` for the combined value.
      */
-    rayMultiCast(ray: Ray, inner?: boolean, filter?: InteractionFilter | null, output?: object | null): object;
+    buoyancyImpulse(body?: Body | null): Vec3;
     /**
-     * Returns a brief string summary of this space.
-     * @returns A string in the form `Space(bodies=N)`.
+     * 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.
      */
-    toString(): string;
+    dragImpulse(body?: Body | null): Vec3;
+    /** Total impulse (buoyancy + drag). */
+    totalImpulse(body?: Body | null, _freshOnly?: boolean): Vec3;
 }
 
 /**
- * Body type enumeration.
+ * Return value for {@link PreListener} handlers — controls whether the interaction
+ * is resolved this step and in future steps.
  *
- * - `STATIC`    — immovable, infinite mass (walls, floors)
- * - `DYNAMIC`   — fully simulated (default)
- * - `KINEMATIC` — moves only via velocity, not affected by forces
+ * - `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
  *
- * Converted from nape-compiled.js lines 24640–24705.
+ * 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 BodyType {
+declare class PreFlag {
     static __name__: string[];
     constructor();
-    static get STATIC(): BodyType;
-    static get DYNAMIC(): BodyType;
-    static get KINEMATIC(): BodyType;
+    /** 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;
 }
 
 /**
- * Physical material properties applied to shapes.
+ * Represents an active interaction between two 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.
+ * 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
  *
- * Converted from nape-compiled.js lines 38254–38573.
+ * 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 Material {
+declare class Arbiter {
     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;
+    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;
-    static wood(): Material;
-    static steel(): Material;
-    static ice(): Material;
-    static rubber(): Material;
-    static glass(): Material;
-    static sand(): Material;
 }
 
 /**
- * Fluid properties for shapes that act as fluid regions.
+ * Enumeration of physics callback event types.
  *
- * 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.
+ * Use these singletons to specify which phase of an interaction a listener
+ * should respond to:
  *
- * Converted from nape-compiled.js lines 37002–37511.
+ * - `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 FluidProperties {
+declare class CbEvent {
     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;
+    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;
 }
 
 /**
- * Mass mode for a body.
+ * Listener type classification.
  *
- * - `DEFAULT` — use computed mass from shapes
- * - `FIXED`   — use a fixed mass value
+ * - `BODY`        — body event listener
+ * - `CONSTRAINT`  — constraint event listener
+ * - `INTERACTION` — interaction event listener
+ * - `PRE`         — pre-interaction listener
  *
- * Converted from nape-compiled.js lines 26966–27013.
+ * Converted from nape-compiled.js lines 2554–2646.
  */
-declare class MassMode {
+declare class ListenerType {
     static __name__: string[];
     constructor();
-    static get DEFAULT(): MassMode;
-    static get FIXED(): MassMode;
+    static get BODY(): ListenerType;
+    static get CONSTRAINT(): ListenerType;
+    static get INTERACTION(): ListenerType;
+    static get PRE(): ListenerType;
     toString(): string;
 }
 
 /**
- * Inertia mode for a body.
+ * Listener — Base class for all physics event listeners.
  *
- * - `DEFAULT` — use computed inertia from shapes
- * - `FIXED`   — use a fixed inertia value
+ * Provides common properties (type, event, precedence, space) and
+ * toString() for all listener subclasses.
  *
- * Converted from nape-compiled.js lines 26343–26390.
+ * Fully modernized from nape-compiled.js lines 231–433.
  */
-declare class InertiaMode {
-    static __name__: string[];
-    constructor();
-    static get DEFAULT(): InertiaMode;
-    static get FIXED(): InertiaMode;
-    toString(): string;
-}
 
 /**
- * Gravity mass mode for a body.
+ * Base class for all physics event listeners.
  *
- * - `DEFAULT` — use computed mass for gravity
- * - `FIXED`   — use a fixed gravity mass value
- * - `SCALED`  — scale the computed gravity mass
+ * Cannot be instantiated directly — use one of the concrete subclasses:
+ * {@link BodyListener}, {@link ConstraintListener}, {@link InteractionListener},
+ * or {@link PreListener}.
  *
- * Converted from nape-compiled.js lines 26272–26342.
+ * Provides common properties (`type`, `event`, `precedence`, `space`) shared
+ * by all listener types.
+ *
+ * Fully modernized from nape-compiled.js lines 231–433.
  */
-declare class GravMassMode {
+declare class Listener {
     static __name__: string[];
     constructor();
-    static get DEFAULT(): GravMassMode;
-    static get FIXED(): GravMassMode;
-    static get SCALED(): GravMassMode;
+    /** 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;
 }
 
 /**
- * A rigid body in the physics simulation. Add shapes to give it geometry, then add it to a `Space` to participate in simulation.
+ * 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.
  */
-declare class Body extends Interactor {
-    static __name__: string[];
-    static __super__: typeof Interactor;
-    /** If true, this body is included in debug rendering. */
-    debugDraw: boolean;
+
+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>;
+
+/**
+ * The physics world. Add bodies, shapes, and constraints, then call `step()` each frame to advance the simulation.
+ */
+declare class Space {
     /**
-     * @param type - Body type (DYNAMIC by default).
-     * @param position - Initial world-space position (defaults to origin).
+     * @param gravity - Initial gravity vector (default (0, 0)).
+     * @param broadphase - Broadphase algorithm to use.
      */
-    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);
+    constructor(gravity?: Vec2, broadphase?: Broadphase);
+    /** Arbitrary user data attached to this Space. */
+    get userData(): Record<string, unknown>;
     /**
-     * Rotation of the body in radians.
-     * @throws If set on a static body that is already in a space.
+     * World gravity applied to all dynamic bodies each step. Live Vec2.
+     * @throws If set to null or a disposed Vec2.
      */
-    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);
+    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);
     /**
-     * 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.
+     * Global angular drag coefficient applied to all bodies.
+     * @throws If set to NaN.
      */
-    get mass(): number;
-    set mass(value: number);
+    get worldAngularDrag(): number;
+    set worldAngularDrag(value: number);
     /**
-     * Moment of inertia. Must be finite and > 0. Setting switches inertiaMode to FIXED.
+     * 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;
+    /**
+     * 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;
@@ -1882,677 +2447,325 @@ declare class Body extends Interactor {
      * @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?: object | null): object;
-    /**
-     * 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?: object | null): object;
-    /**
-     * 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;
+    rotate(centre: Vec2, angle: number): Body;
     /**
-     * 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).
+     * Set the same `Material` on every shape attached to this body.
+     * @param material - The material to apply.
      * @returns `this` for chaining.
      */
-    scale(scaleX: number, scaleY: number): Shape;
+    setShapeMaterials(material: Material): Body;
     /**
-     * Rotate the shape's local vertices by `angle` radians.
-     * @param angle - Rotation in radians.
+     * Set the same `InteractionFilter` on every shape attached to this body.
+     * @param filter - The interaction filter to apply.
      * @returns `this` for chaining.
      */
-    rotate(angle: number): Shape;
+    setShapeFilters(filter: InteractionFilter): Body;
     /**
-     * Apply a Mat23 affine transform to the shape's local geometry.
-     * @param matrix - The transformation matrix (must be non-singular; Circles require equiorthogonal).
+     * Set the same `FluidProperties` on every shape attached to this body.
+     * @param fluidProperties - The fluid properties to apply.
      * @returns `this` for chaining.
      */
-    transform(matrix: {
-        _inner: NapeInner;
-    }): Shape;
+    setShapeFluidProperties(fluidProperties: FluidProperties): Body;
     /**
-     * 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.
+     * 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;
     /**
-     * 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;
-}
-
-/**
- * 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;
-}
-
-/**
- * Static utility class for geometric queries between shapes and bodies.
- *
- * Fully modernized — calls ZPP_Geom, ZPP_SweepDistance, and ZPP_Collide directly.
- */
-declare class Geom {
-    static __name__: string[];
-    /**
-     * Calculate minimum distance between two bodies and return closest points.
+     * 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.
      */
-    static distanceBody(body1: Body, body2: Body, out1: Vec2, out2: Vec2): number;
+    connectedBodies(depth?: number, output?: BodyList | null): BodyList;
     /**
-     * Calculate minimum distance between two shapes and return closest points.
+     * 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.
      */
-    static distance(shape1: Shape, shape2: Shape, out1: Vec2, out2: Vec2): number;
+    interactingBodies(type?: InteractionType | null, _depth?: number, output?: BodyList | null): BodyList;
     /**
-     * Test if two bodies intersect (any of their shapes overlap).
+     * 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.
      */
-    static intersectsBody(body1: Body, body2: Body): boolean;
+    normalImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
     /**
-     * Test if two shapes intersect.
+     * 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.
      */
-    static intersects(shape1: Shape, shape2: Shape): boolean;
+    tangentImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
     /**
-     * Test if shape1 fully contains shape2.
+     * 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.
      */
-    static contains(shape1: Shape, shape2: Shape): boolean;
-}
-
-/**
- * A circular physics shape. The simplest and most performant collision shape.
- */
-declare class Circle extends Shape {
-    static __name__: string[];
-    static __super__: any;
+    totalContactsImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
     /**
-     * Create a circle with the given radius and optional local centre-of-mass offset.
-     * @param radius - Circle radius (must be > 0).
-     * @param localCOM - Local centre offset (defaults to origin).
-     * @param material - Material to assign (uses default if omitted).
-     * @param filter - InteractionFilter to assign (uses default if omitted).
+     * 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.
      */
-    constructor(radius?: number, localCOM?: Vec2, material?: Material, filter?: InteractionFilter);
-    /** The circle's radius. Must be > 0. */
-    get radius(): number;
-    set radius(value: number);
-}
-
-/**
- * A convex polygon physics shape.
- */
-declare class Polygon extends Shape {
-    static __name__: string[];
-    static __super__: any;
+    rollingImpulse(body?: Body | null, freshOnly?: boolean): number;
     /**
-     * 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).
+     * 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.
      */
-    constructor(localVerts?: Vec2[] | any, material?: Material, filter?: InteractionFilter);
+    buoyancyImpulse(body?: Body | null): Vec3;
     /**
-     * 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.
+     * 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.
      */
-    static rect(x: number, y: number, width: number, height: number, weak?: boolean): Vec2[];
+    dragImpulse(body?: Body | null): Vec3;
     /**
-     * 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.
+     * 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.
      */
-    static box(width: number, height?: number, weak?: boolean): Vec2[];
+    totalFluidImpulse(body?: Body | null): Vec3;
     /**
-     * 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.
+     * 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.
      */
-    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;
+    constraintsImpulse(): Vec3;
     /**
-     * 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.
+     * 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.
      */
-    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;
+    totalImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
     /**
-     * Wrap a ZPP_Vec2 vertex into its public Vec2 outer.
-     * Mirrors the compiled vertex wrapping pattern.
+     * 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.
      */
-    private _wrapVert;
-}
-
-/**
- * Result of polygon shape validation.
- *
- * - `VALID`              — shape is valid
- * - `DEGENERATE`         — shape is degenerate (e.g., zero area)
- * - `CONCAVE`            — shape is concave (must be convex)
- * - `SELF_INTERSECTING`  — shape edges self-intersect
- *
- * Converted from nape-compiled.js lines 30760–30856.
- */
-declare class ValidationResult {
-    static __name__: string[];
-    constructor();
-    static get VALID(): ValidationResult;
-    static get DEGENERATE(): ValidationResult;
-    static get CONCAVE(): ValidationResult;
-    static get SELF_INTERSECTING(): ValidationResult;
-    toString(): string;
+    crushFactor(): number;
+    private _getArbiters;
+    private _getConstraints;
+    private _arbiterImpulseQuery;
 }
 
 /**
- * Arbiter type classification.
+ * Shape type classification.
  *
- * - `COLLISION` — collision arbiter
- * - `SENSOR`    — sensor arbiter
- * - `FLUID`     — fluid arbiter
+ * - `CIRCLE`  — circle shape
+ * - `POLYGON` — polygon shape
  *
- * Converted from nape-compiled.js lines 11653–11725.
+ * Converted from nape-compiled.js lines 30435–30482.
  */
-declare class ArbiterType {
+declare class ShapeType {
     static __name__: string[];
     constructor();
-    static get COLLISION(): ArbiterType;
-    static get SENSOR(): ArbiterType;
-    static get FLUID(): ArbiterType;
+    static get CIRCLE(): ShapeType;
+    static get POLYGON(): ShapeType;
     toString(): string;
 }
 
 /**
- * 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.
+ * Base class for physics shapes (Circle, Polygon). Never instantiated directly — use
+ * `new Circle(...)` or `Polygon.box(...)` etc.
  */
-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;
+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;
     /**
-     * Collision normal vector pointing from `shape1` toward `shape2`.
-     * Read-only; available after the arbiter is active.
+     * The Body this shape belongs to. Setting moves the shape between bodies.
      */
-    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;
+    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;
     /**
-     * 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._
+     * Local-space centre of mass. Can be set to override the default shape centroid.
      */
-    get elasticity(): number;
-    set elasticity(value: number);
+    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;
     /**
-     * Dynamic (kinetic) friction coefficient — applied when the contact is sliding.
-     * Combined from the two shapes' material values. _Mutable in pre-handler only._
+     * Translate the shape's local vertices by the given vector (in-place).
+     * @param translation - The displacement vector to apply.
+     * @returns `this` for chaining.
      */
-    get dynamicFriction(): number;
-    set dynamicFriction(value: number);
+    translate(translation: Vec2): Shape;
     /**
-     * Static friction coefficient — applied when the contact is at rest.
-     * Combined from the two shapes' material values. _Mutable in pre-handler only._
+     * 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.
      */
-    get staticFriction(): number;
-    set staticFriction(value: number);
+    scale(scaleX: number, scaleY: number): Shape;
     /**
-     * Rolling friction coefficient — resists rolling motion.
-     * Combined from the two shapes' material values. _Mutable in pre-handler only._
+     * Rotate the shape's local vertices by `angle` radians.
+     * @param angle - Rotation in radians.
+     * @returns `this` for chaining.
      */
-    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;
+    rotate(angle: number): Shape;
     /**
-     * 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`.
+     * 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.
      */
-    normalImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
+    transform(matrix: {
+        _inner: NapeInner;
+    }): Shape;
     /**
-     * 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`.
+     * 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.
      */
-    tangentImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
-    /** Total impulse (normal + tangent + rolling) accumulated across all contacts. */
-    totalImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
+    contains(point: Vec2): boolean;
     /**
-     * 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`.
+     * Create a deep copy of this shape with the same type, geometry, material, and filter.
+     * @returns A new Shape instance independent of this one.
      */
-    rollingImpulse(body?: Body | null, freshOnly?: boolean): number;
+    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;
 }
 
 /**
- * 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.
+ * Result from a convex-cast query.
  *
- * Fully modernized — uses extracted ZPP_FluidArbiter directly.
+ * Provides the contact normal, position, time-of-impact, and shape hit.
+ * Instances are pooled — call `dispose()` when done to return to pool.
  */
-declare class FluidArbiter extends Arbiter {
+declare class ConvexResult {
     static __name__: string[];
-    static __super__: typeof Arbiter;
     constructor();
+    get normal(): Vec2;
+    get position(): Vec2;
+    get toi(): number;
+    get shape(): Shape;
+    dispose(): void;
+    toString(): string;
+}
+
+/**
+ * Static utility class for geometric queries between shapes and bodies.
+ *
+ * Fully modernized — calls ZPP_Geom, ZPP_SweepDistance, and ZPP_Collide directly.
+ */
+declare class Geom {
+    static __name__: string[];
     /**
-     * Centre of the overlap region between the fluid and the body shape.
-     * _Mutable in pre-handler only._
+     * Calculate minimum distance between two bodies and return closest points.
      */
-    get position(): Vec2;
-    set position(value: Vec2);
+    static distanceBody(body1: Body, body2: Body, out1: Vec2, out2: Vec2): number;
     /**
-     * Area of the overlap region in pixels². Used to compute buoyancy force.
-     * Must be strictly positive and finite.
-     * _Mutable in pre-handler only._
+     * Calculate minimum distance between two shapes and return closest points.
      */
-    get overlap(): number;
-    set overlap(value: number);
+    static distance(shape1: Shape, shape2: Shape, out1: Vec2, out2: Vec2): 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.
+     * Test if two bodies intersect (any of their shapes overlap).
      */
-    buoyancyImpulse(body?: Body | null): Vec3;
+    static intersectsBody(body1: Body, body2: Body): boolean;
     /**
-     * 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.
+     * Test if two shapes intersect.
      */
-    dragImpulse(body?: Body | null): Vec3;
-    /** Total impulse (buoyancy + drag). */
-    totalImpulse(body?: Body | null, _freshOnly?: boolean): Vec3;
+    static intersects(shape1: Shape, shape2: Shape): boolean;
+    /**
+     * Test if shape1 fully contains shape2.
+     */
+    static contains(shape1: Shape, shape2: Shape): boolean;
 }
 
 /**
- * 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.
+ * A circular physics shape. The simplest and most performant collision shape.
  */
-declare class PreFlag {
+declare class Circle extends Shape {
     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;
+    static __super__: any;
+    /**
+     * Create a circle with the given radius and optional local centre-of-mass offset.
+     * @param radius - Circle radius (must be > 0).
+     * @param localCOM - Local centre offset (defaults to origin).
+     * @param material - Material to assign (uses default if omitted).
+     * @param filter - InteractionFilter to assign (uses default if omitted).
+     */
+    constructor(radius?: number, localCOM?: Vec2, material?: Material, filter?: InteractionFilter);
+    /** The circle's radius. Must be > 0. */
+    get radius(): number;
+    set radius(value: number);
 }
 
 /**
- * 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.
+ * Result of polygon shape validation.
  *
- * **Warning:** do not hold references to `Arbiter` objects after the current
- * simulation step — they are pooled and may be reused.
+ * - `VALID`              — shape is valid
+ * - `DEGENERATE`         — shape is degenerate (e.g., zero area)
+ * - `CONCAVE`            — shape is concave (must be convex)
+ * - `SELF_INTERSECTING`  — shape edges self-intersect
  *
- * Fully modernized — uses extracted ZPP_Arbiter directly.
+ * Converted from nape-compiled.js lines 30760–30856.
  */
-declare class Arbiter {
+declare class ValidationResult {
     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;
+    static get VALID(): ValidationResult;
+    static get DEGENERATE(): ValidationResult;
+    static get CONCAVE(): ValidationResult;
+    static get SELF_INTERSECTING(): ValidationResult;
     toString(): string;
 }
 
@@ -2604,48 +2817,6 @@ declare class Contact {
     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;
-}
-
 /**
  * Composite callback option type — combines include and exclude {@link CbType} lists
  * to express complex listener filter conditions.
@@ -2778,82 +2949,6 @@ declare class CbType {
     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;
-}
-
 /**
  * Base class for all physics engine callback objects.
  *
@@ -3627,6 +3722,194 @@ declare class PulleyJoint extends Constraint {
     visitBodies(lambda: (body: Body) => void): void;
 }
 
+/**
+ * ZPP_Constraint — Internal base class for all constraints / joints.
+ *
+ * Manages activation/deactivation, callback types, space integration,
+ * and provides stubs for solver methods overridden by joint subclasses.
+ *
+ * Converted from nape-compiled.js lines 21424–21827.
+ */
+declare class ZPP_Constraint {
+    static __name__: string[];
+    /**
+     * Namespace references, set by the compiled module after import.
+     * _nape = the `nape` public namespace (for CbTypeIterator in copyto)
+     * _zpp = the `zpp_nape` internal namespace (for ZNPList_*, ZPP_CbSet, etc.)
+     */
+    static _nape: any;
+    static _zpp: any;
+    outer: any;
+    id: number;
+    userData: any;
+    compound: any;
+    space: any;
+    active: boolean;
+    stiff: boolean;
+    frequency: number;
+    damping: number;
+    maxForce: number;
+    maxError: number;
+    breakUnderForce: boolean;
+    breakUnderError: boolean;
+    removeOnBreak: boolean;
+    component: any;
+    ignore: boolean;
+    __velocity: boolean;
+    cbTypes: any;
+    cbSet: any;
+    wrap_cbTypes: any;
+    pre_dt: number;
+    __class__: any;
+    constructor();
+    /**
+     * Initialise base constraint fields.
+     * Extracted into a separate method because compiled joint subclasses
+     * call `ZPP_Constraint.call(this)` — ES classes can't be invoked that
+     * way, so the compiled wrapper delegates to this method instead.
+     */
+    _initBase(): void;
+    clear(): void;
+    activeBodies(): void;
+    inactiveBodies(): void;
+    clearcache(): void;
+    validate(): void;
+    wake_connected(): void;
+    forest(): void;
+    broken(): void;
+    warmStart(): void;
+    draw(_g: any): void;
+    pair_exists(_id: any, _di: any): boolean;
+    preStep(_dt: number): boolean;
+    applyImpulseVel(): boolean;
+    applyImpulsePos(): boolean;
+    copy(_dict?: any, _todo?: any): any;
+    immutable_midstep(name: string): void;
+    setupcbTypes(): void;
+    immutable_cbTypes(): void;
+    wrap_cbTypes_subber(pcb: any): void;
+    wrap_cbTypes_adder(cb: any): boolean;
+    insert_cbtype(cb: any): void;
+    alloc_cbSet(): void;
+    dealloc_cbSet(): void;
+    activate(): void;
+    deactivate(): void;
+    addedToSpace(): void;
+    removedFromSpace(): void;
+    activeInSpace(): void;
+    inactiveOrOutSpace(): void;
+    wake(): void;
+    copyto(ret: any): void;
+    static _findRoot(comp: any): any;
+    static _unionComponents(a: any, b: any): void;
+}
+
+/**
+ * ZPP_UserBody — pairs a body with a reference count for user constraints.
+ *
+ * Converted from nape-compiled.js lines 28038–28054.
+ */
+declare class ZPP_UserBody {
+    static __name__: string[];
+    cnt: number;
+    body: any;
+    constructor(cnt: number, body: any);
+}
+
+/**
+ * ZPP_UserConstraint — Internal N-DOF user-defined constraint with Cholesky decomposition.
+ *
+ * A generic constraint where the user supplies callbacks for effective mass,
+ * velocity/position errors, impulse application, and clamping.  The solver
+ * factorises the effective-mass matrix via Cholesky (solve/transform) and
+ * drives the constraint each step through warmStart / applyImpulseVel /
+ * applyImpulsePos.
+ *
+ * Converted from nape-compiled.js lines 27368–28037.
+ */
+
+declare class ZPP_UserConstraint extends ZPP_Constraint {
+    static __name__: string[];
+    static __super__: typeof ZPP_Constraint;
+    outer_zn: any;
+    bodies: ZPP_UserBody[];
+    dim: number;
+    jAcc: number[];
+    bias: number[];
+    stepped: boolean;
+    L: number[];
+    y: number[];
+    soft: number;
+    gamma: number;
+    velonly: boolean;
+    jMax: number;
+    Keff: number[];
+    vec3: any;
+    J: number[];
+    jOld: number[];
+    __class__: any;
+    constructor(dim: number, velonly: boolean);
+    bindVec2_invalidate(_: any): void;
+    addBody(b: any): void;
+    remBody(b: any): boolean;
+    bodyImpulse(b: any): any;
+    activeBodies(): void;
+    inactiveBodies(): void;
+    copy(_dict: any, _todo: any): any;
+    validate(): void;
+    wake_connected(): void;
+    forest(): void;
+    pair_exists(id: number, di: number): boolean;
+    broken(): void;
+    clearcache(): void;
+    lsq(v: number[]): number;
+    _clamp(v: number[], max: number): void;
+    solve(m: number[]): number[];
+    transform(L: number[], x: number[]): void;
+    preStep(dt: number): boolean;
+    warmStart(): void;
+    applyImpulseVel(): boolean;
+    applyImpulsePos(): boolean;
+    draw(g: any): void;
+}
+
+/**
+ * Base class for user-defined N-DOF constraints.
+ *
+ * Fully modernized — uses ZPP_UserConstraint directly (extracted to TypeScript).
+ * Subclass and override the abstract callback methods to define custom constraints.
+ */
+declare abstract class UserConstraint extends Constraint {
+    zpp_inner: ZPP_UserConstraint;
+    constructor(dimensions: number, velocityOnly?: boolean);
+    __bindVec2(): Vec2;
+    /** Create a copy of this constraint. Must be overridden. */
+    __copy(): UserConstraint;
+    /** Called when the constraint breaks. Optional override. */
+    __broken(): void;
+    /** Called to validate the constraint. Optional override. */
+    __validate(): void;
+    /** Draw debug visualization. Optional override. */
+    __draw(_debug: any): void;
+    /** Prepare the constraint for solving. Optional override. */
+    __prepare(): void;
+    /** Compute positional error. Must be overridden for non-velocity-only constraints. */
+    __position(_err: number[]): void;
+    /** Compute velocity error. Must be overridden. */
+    __velocity(_err: number[]): void;
+    /** Compute effective mass matrix (upper triangle). Must be overridden. */
+    __eff_mass(_eff: number[]): void;
+    /** Clamp accumulated impulse. Optional override. */
+    __clamp(_jAcc: number[]): void;
+    /** Apply impulse to a body. Must be overridden. */
+    __impulse(_imp: number[], _body: Body, _out: any): void;
+    impulse(): MatMN;
+    bodyImpulse(body: Body): Vec3;
+    visitBodies(lambda: (body: Body) => void): void;
+    __invalidate(): void;
+    __registerBody(oldBody: Body | null, newBody: Body | null): Body | null;
+}
+
 declare const VERSION: string;
 
-export { AABB, AngleJoint, Arbiter, ArbiterType, Body, BodyCallback, BodyListener, BodyType, Broadphase, Callback, CbEvent, CbType, Circle, CollisionArbiter, Compound, Constraint, ConstraintCallback, ConstraintListener, Contact, ConvexResult, DistanceJoint, Edge, FluidArbiter, FluidProperties, Geom, GeomPoly, GravMassMode, InertiaMode, InteractionCallback, InteractionFilter, InteractionGroup, InteractionListener, InteractionType, Interactor, LineJoint, Listener, ListenerType, MarchingSquares, MassMode, Mat23, MatMN, Material, MotorJoint, NapeList, OptionType, PivotJoint, Polygon, PreCallback, PreFlag, PreListener, PulleyJoint, Ray, RayResult, Shape, ShapeType, Space, VERSION, ValidationResult, Vec2, Vec3, WeldJoint, Winding };
+export { AABB, AngleJoint, Arbiter, type ArbiterList, ArbiterType, Body, BodyCallback, type BodyList, BodyListener, BodyType, Broadphase, Callback, CbEvent, CbType, type CbTypeSet, Circle, CollisionArbiter, Compound, type CompoundList, Constraint, ConstraintCallback, type ConstraintList, ConstraintListener, Contact, ConvexResult, type ConvexResultList, DistanceJoint, Edge, FluidArbiter, FluidProperties, Geom, GeomPoly, GravMassMode, InertiaMode, InteractionCallback, InteractionFilter, InteractionGroup, InteractionListener, InteractionType, Interactor, LineJoint, Listener, type ListenerList, ListenerType, MarchingSquares, MassMode, Mat23, MatMN, Material, MotorJoint, NapeList, OptionType, PivotJoint, Polygon, PreCallback, PreFlag, PreListener, PulleyJoint, Ray, RayResult, type RayResultList, Shape, type ShapeList, ShapeType, Space, type TypedListLike, UserConstraint, VERSION, ValidationResult, Vec2, Vec3, WeldJoint, Winding };