@newkrok/nape-js 3.6.2 → 3.7.0

package/dist/index.d.cts

@@ -1269,6 +1269,23 @@ declare class InteractionFilter {
     toString(): string;
 }
 
+/**
+ * Result from a raycast query.
+ *
+ * Provides the contact normal, distance, inside-flag, and shape hit.
+ * Instances are pooled — call `dispose()` when done to return to pool.
+ */
+declare class RayResult {
+    static __name__: string[];
+    constructor();
+    get normal(): Vec2;
+    get distance(): number;
+    get inner(): boolean;
+    get shape(): Shape;
+    dispose(): void;
+    toString(): string;
+}
+
 /**
  * Broadphase algorithm type for Space collision detection.
  *
@@ -1311,1281 +1328,1444 @@ 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;
+    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;
     /**
-     * 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;
-    /**
-     * 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;
-    toString(): string;
-    static wood(): Material;
-    static steel(): Material;
-    static ice(): Material;
-    static rubber(): Material;
-    static glass(): Material;
-    static sand(): 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;
 }
 
 /**
- * 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.
-     * @throws If the body is the world body, or if no shapes are present in DEFAULT inertia mode.
+     * Global linear drag coefficient applied to all bodies.
+     * @throws If set to NaN.
      */
-    get inertia(): number;
-    set inertia(value: number);
-    /** Effective mass used by the constraint solver (accounts for allowMovement). */
-    get constraintMass(): number;
-    /** Effective inertia used by the constraint solver (accounts for allowRotation). */
-    get constraintInertia(): number;
-    /** Gravitational mass. Defaults to the same as `mass`. */
-    get gravMass(): number;
-    set gravMass(value: number);
-    /** Scale factor applied to gravMass relative to the dynamic mass. */
-    get gravMassScale(): number;
-    set gravMassScale(value: number);
-    /** If true, continuous collision detection (CCD) is enabled for this body. */
-    get isBullet(): boolean;
-    set isBullet(value: boolean);
-    /** If true, CCD is disabled even if `isBullet` is set. */
-    get disableCCD(): boolean;
-    set disableCCD(value: boolean);
-    /** If false, translational motion is frozen (infinite effective mass). */
-    get allowMovement(): boolean;
-    set allowMovement(value: boolean);
-    /** If false, rotational motion is frozen (infinite effective inertia). */
-    get allowRotation(): boolean;
-    set allowRotation(value: boolean);
+    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;
     /**
-     * True if the body is currently sleeping.
-     * @throws If the body is not in a Space.
+     * 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.
      */
-    get isSleeping(): boolean;
-    /** List of shapes attached to this body. */
-    get shapes(): NapeList<Shape>;
-    /** The Space this body belongs to. Setting adds/removes it from the space. */
-    get space(): Space;
-    set space(value: Space | null);
-    /** The Compound this body belongs to, or null. */
-    get compound(): Compound | null;
-    set compound(value: Compound | null);
+    step(deltaTime: number, velocityIterations?: number, positionIterations?: number): void;
     /**
-     * World-space AABB enclosing all shapes.
-     * @throws If this is the world body.
+     * Remove all bodies, constraints, and compounds from this space.
+     * @throws If called during a `step()`.
      */
-    get bounds(): AABB;
-    /** Constraint-solved velocity (read-only view used by the solver). */
-    get constraintVelocity(): Vec2;
+    clear(): void;
     /**
-     * Local-space centre of mass (read-only, lazy-computed from shapes).
-     * @throws If this is the world body.
+     * Call `lambda` for every body in the space, including those inside compounds.
+     * @param lambda - Callback invoked with each Body.
+     * @throws If `lambda` is null.
      */
-    get localCOM(): Vec2;
+    visitBodies(lambda: (body: Body) => void): void;
     /**
-     * World-space centre of mass (read-only, lazy-computed).
-     * @throws If this is the world body.
+     * Call `lambda` for every constraint in the space, including those inside compounds.
+     * @param lambda - Callback invoked with each Constraint.
+     * @throws If `lambda` is null.
      */
-    get worldCOM(): Vec2;
-    /** Controls how mass is computed: DEFAULT (from shapes) or FIXED (manually set). */
-    get massMode(): MassMode;
-    set massMode(value: MassMode);
-    /** Controls how inertia is computed: DEFAULT or FIXED. */
-    get inertiaMode(): InertiaMode;
-    set inertiaMode(value: InertiaMode);
-    /** Controls gravitational mass: DEFAULT, FIXED, or SCALED. */
-    get gravMassMode(): GravMassMode;
-    set gravMassMode(value: GravMassMode);
+    visitConstraints(lambda: (constraint: Constraint) => void): void;
     /**
-     * Create a deep copy of this body (shapes, mass properties, etc.).
-     * @returns A new Body with identical configuration.
-     * @throws If this is the world body.
+     * Call `lambda` for every compound in the space (recursively).
+     * @param lambda - Callback invoked with each Compound.
+     * @throws If `lambda` is null.
      */
-    copy(): Body;
+    visitCompounds(lambda: (compound: Compound) => void): void;
     /**
-     * String identifier like `(dynamic)#42`.
-     * @returns A human-readable description of this body.
+     * 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.
      */
-    toString(): string;
+    interactionType(shape1: Shape, shape2: Shape): InteractionType | null;
     /**
-     * Manually integrate the body's position and rotation by `deltaTime` seconds (outside of `Space.step`).
-     * @param deltaTime - Time in seconds to integrate over.
-     * @returns `this` for chaining.
-     * @throws If `deltaTime` is NaN.
+     * 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.
      */
-    integrate(deltaTime: number): Body;
+    shapesUnderPoint(point: Vec2, filter?: InteractionFilter | null, output?: ShapeList | null): ShapeList;
     /**
-     * Transform a point from local body space to world space.
-     * @param point - The point in local space.
-     * @param weak - If true, the returned Vec2 is a weak (pooled) reference.
-     * @returns The transformed point in world space.
+     * 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.
      */
-    localPointToWorld(point: Vec2, weak?: boolean): Vec2;
+    bodiesUnderPoint(point: Vec2, filter?: InteractionFilter | null, output?: BodyList | null): BodyList;
     /**
-     * Transform a point from world space to local body space.
-     * @param point - The point in world space.
-     * @param weak - If true, the returned Vec2 is a weak (pooled) reference.
-     * @returns The transformed point in local space.
+     * 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).
      */
-    worldPointToLocal(point: Vec2, weak?: boolean): Vec2;
+    shapesInAABB(aabb: AABB, containment?: boolean, strict?: boolean, filter?: InteractionFilter | null, output?: ShapeList | null): ShapeList;
     /**
-     * Rotate a vector from local body space to world space (no translation).
-     * @param vector - The vector in local space.
-     * @param weak - If true, the returned Vec2 is a weak (pooled) reference.
-     * @returns The rotated vector in world space.
+     * 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).
      */
-    localVectorToWorld(vector: Vec2, weak?: boolean): Vec2;
+    bodiesInAABB(aabb: AABB, containment?: boolean, strict?: boolean, filter?: InteractionFilter | null, output?: BodyList | null): BodyList;
     /**
-     * Rotate a vector from world space to local body space (no translation).
-     * @param vector - The vector in world space.
-     * @param weak - If true, the returned Vec2 is a weak (pooled) reference.
-     * @returns The rotated vector in local space.
+     * 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.
      */
-    worldVectorToLocal(vector: Vec2, weak?: boolean): Vec2;
+    shapesInCircle(position: Vec2, radius: number, containment?: boolean, filter?: InteractionFilter | null, output?: ShapeList | null): ShapeList;
     /**
-     * Apply a linear (and optionally angular) impulse to the body.
-     * If `pos` is given, it creates a torque about the body's centre.
-     * If `sleepable` is true, sleeping bodies are not woken.
-     * @param impulse - The linear impulse vector (world space).
-     * @param pos - Optional world-space point of application.
-     * @param sleepable - If true, the body will not be woken if sleeping.
-     * @returns `this` for chaining.
+     * 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.
      */
-    applyImpulse(impulse: Vec2, pos?: Vec2, sleepable?: boolean): Body;
+    bodiesInCircle(position: Vec2, radius: number, containment?: boolean, filter?: InteractionFilter | null, output?: BodyList | null): BodyList;
     /**
-     * Apply a direct angular impulse (change in angular velocity × inertia).
-     * @param impulse - The angular impulse magnitude.
-     * @param sleepable - If true, the body will not be woken if sleeping.
-     * @returns `this` for chaining.
+     * 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.
      */
-    applyAngularImpulse(impulse: number, sleepable?: boolean): Body;
+    shapesInShape(shape: Shape, containment?: boolean, filter?: InteractionFilter | null, output?: ShapeList | null): ShapeList;
     /**
-     * Set linear and angular velocity so the body reaches the given target pose in `deltaTime` seconds.
-     * Useful for kinematic or manually driven bodies.
-     * @param targetPosition - Desired world-space position.
-     * @param targetRotation - Desired rotation in radians.
-     * @param deltaTime - Time in seconds over which to reach the target.
-     * @returns `this` for chaining.
-     * @throws If `targetPosition` is null or `deltaTime` is zero.
+     * 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.
      */
-    setVelocityFromTarget(targetPosition: Vec2, targetRotation: number, deltaTime: number): Body;
+    bodiesInShape(shape: Shape, containment?: boolean, filter?: InteractionFilter | null, output?: BodyList | null): BodyList;
     /**
-     * Translate all shapes attached to this body in local space by `translation`.
-     * @param translation - Offset vector in local space.
-     * @returns `this` for chaining.
+     * 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.
      */
-    translateShapes(translation: Vec2): Body;
+    shapesInBody(body: Body, filter?: InteractionFilter | null, output?: ShapeList | null): ShapeList;
     /**
-     * Rotate all shapes attached to this body in local space by `angle` radians.
-     * @param angle - Rotation in radians.
-     * @returns `this` for chaining.
+     * 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.
      */
-    rotateShapes(angle: number): Body;
+    bodiesInBody(body: Body, filter?: InteractionFilter | null, output?: BodyList | null): BodyList;
     /**
-     * Scale all shapes attached to this body in local space.
-     * @param scaleX - Horizontal scale factor.
-     * @param scaleY - Vertical scale factor.
-     * @returns `this` for chaining.
+     * 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.
      */
-    scaleShapes(scaleX: number, scaleY: number): Body;
+    convexCast(shape: Shape, deltaTime: number, liveSweep?: boolean, filter?: InteractionFilter | null): ConvexResult | null;
     /**
-     * Apply an affine transform matrix to all shapes in local space.
-     * @param matrix - The 2D affine transformation matrix.
-     * @returns `this` for chaining.
+     * 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.
      */
-    transformShapes(matrix: Mat23): Body;
+    convexMultiCast(shape: Shape, deltaTime: number, liveSweep?: boolean, filter?: InteractionFilter | null, output?: ConvexResultList | null): ConvexResultList;
     /**
-     * Translate all shapes and adjust the body position so the local centre of mass coincides with the body origin.
-     * @returns `this` for chaining.
-     * @throws If the body has no shapes.
+     * 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.
      */
-    align(): Body;
+    rayCast(ray: Ray, inner?: boolean, filter?: InteractionFilter | null): RayResult | null;
     /**
-     * Rotate the body about a world-space pivot point by `angle` radians.
-     * Moves the body's position and increments its rotation.
-     * @param centre - World-space pivot point.
-     * @param angle - Rotation in radians.
-     * @returns `this` for chaining.
-     * @throws If `centre` is null or `angle` is NaN.
+     * 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.
      */
-    rotate(centre: Vec2, angle: number): Body;
+    rayMultiCast(ray: Ray, inner?: boolean, filter?: InteractionFilter | null, output?: RayResultList | null): RayResultList;
     /**
-     * Set the same `Material` on every shape attached to this body.
-     * @param material - The material to apply.
-     * @returns `this` for chaining.
+     * Returns a brief string summary of this space.
+     * @returns A string in the form `Space(bodies=N)`.
      */
-    setShapeMaterials(material: Material): Body;
+    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;
     /**
-     * Set the same `InteractionFilter` on every shape attached to this body.
-     * @param filter - The interaction filter to apply.
-     * @returns `this` for chaining.
+     * @param type - Body type (DYNAMIC by default).
+     * @param position - Initial world-space position (defaults to origin).
      */
-    setShapeFilters(filter: InteractionFilter): Body;
+    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);
     /**
-     * Set the same `FluidProperties` on every shape attached to this body.
-     * @param fluidProperties - The fluid properties to apply.
-     * @returns `this` for chaining.
+     * Rotation of the body in radians.
+     * @throws If set on a static body that is already in a space.
      */
-    setShapeFluidProperties(fluidProperties: FluidProperties): Body;
+    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);
     /**
-     * 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.
+     * 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.
      */
-    contains(point: Vec2): boolean;
+    get mass(): number;
+    set mass(value: number);
     /**
-     * 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.
+     * 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.
      */
-    connectedBodies(depth?: number, output?: object | null): object;
+    get inertia(): number;
+    set inertia(value: number);
+    /** Effective mass used by the constraint solver (accounts for allowMovement). */
+    get constraintMass(): number;
+    /** Effective inertia used by the constraint solver (accounts for allowRotation). */
+    get constraintInertia(): number;
+    /** Gravitational mass. Defaults to the same as `mass`. */
+    get gravMass(): number;
+    set gravMass(value: number);
+    /** Scale factor applied to gravMass relative to the dynamic mass. */
+    get gravMassScale(): number;
+    set gravMassScale(value: number);
+    /** If true, continuous collision detection (CCD) is enabled for this body. */
+    get isBullet(): boolean;
+    set isBullet(value: boolean);
+    /** If true, CCD is disabled even if `isBullet` is set. */
+    get disableCCD(): boolean;
+    set disableCCD(value: boolean);
+    /** If false, translational motion is frozen (infinite effective mass). */
+    get allowMovement(): boolean;
+    set allowMovement(value: boolean);
+    /** If false, rotational motion is frozen (infinite effective inertia). */
+    get allowRotation(): boolean;
+    set allowRotation(value: boolean);
     /**
-     * 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.
+     * True if the body is currently sleeping.
+     * @throws If the body is not in a Space.
      */
-    interactingBodies(type?: InteractionType | null, _depth?: number, output?: object | null): object;
+    get isSleeping(): boolean;
+    /** List of shapes attached to this body. */
+    get shapes(): NapeList<Shape>;
+    /** The Space this body belongs to. Setting adds/removes it from the space. */
+    get space(): Space;
+    set space(value: Space | null);
+    /** The Compound this body belongs to, or null. */
+    get compound(): Compound | null;
+    set compound(value: Compound | null);
     /**
-     * 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.
+     * World-space AABB enclosing all shapes.
+     * @throws If this is the world body.
      */
-    normalImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
+    get bounds(): AABB;
+    /** Constraint-solved velocity (read-only view used by the solver). */
+    get constraintVelocity(): Vec2;
     /**
-     * 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.
+     * Local-space centre of mass (read-only, lazy-computed from shapes).
+     * @throws If this is the world body.
      */
-    tangentImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
+    get localCOM(): Vec2;
     /**
-     * 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.
+     * World-space centre of mass (read-only, lazy-computed).
+     * @throws If this is the world body.
      */
-    totalContactsImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
+    get worldCOM(): Vec2;
+    /** Controls how mass is computed: DEFAULT (from shapes) or FIXED (manually set). */
+    get massMode(): MassMode;
+    set massMode(value: MassMode);
+    /** Controls how inertia is computed: DEFAULT or FIXED. */
+    get inertiaMode(): InertiaMode;
+    set inertiaMode(value: InertiaMode);
+    /** Controls gravitational mass: DEFAULT, FIXED, or SCALED. */
+    get gravMassMode(): GravMassMode;
+    set gravMassMode(value: GravMassMode);
     /**
-     * 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.
+     * Create a deep copy of this body (shapes, mass properties, etc.).
+     * @returns A new Body with identical configuration.
+     * @throws If this is the world body.
      */
-    rollingImpulse(body?: Body | null, freshOnly?: boolean): number;
+    copy(): Body;
     /**
-     * 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.
+     * String identifier like `(dynamic)#42`.
+     * @returns A human-readable description of this body.
      */
-    buoyancyImpulse(body?: Body | null): Vec3;
+    toString(): string;
     /**
-     * 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.
+     * Manually integrate the body's position and rotation by `deltaTime` seconds (outside of `Space.step`).
+     * @param deltaTime - Time in seconds to integrate over.
+     * @returns `this` for chaining.
+     * @throws If `deltaTime` is NaN.
      */
-    dragImpulse(body?: Body | null): Vec3;
+    integrate(deltaTime: number): Body;
     /**
-     * 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.
+     * Transform a point from local body space to world space.
+     * @param point - The point in local space.
+     * @param weak - If true, the returned Vec2 is a weak (pooled) reference.
+     * @returns The transformed point in world space.
      */
-    totalFluidImpulse(body?: Body | null): Vec3;
+    localPointToWorld(point: Vec2, weak?: boolean): Vec2;
     /**
-     * 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.
+     * Transform a point from world space to local body space.
+     * @param point - The point in world space.
+     * @param weak - If true, the returned Vec2 is a weak (pooled) reference.
+     * @returns The transformed point in local space.
      */
-    constraintsImpulse(): Vec3;
+    worldPointToLocal(point: Vec2, weak?: boolean): Vec2;
     /**
-     * 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.
+     * Rotate a vector from local body space to world space (no translation).
+     * @param vector - The vector in local space.
+     * @param weak - If true, the returned Vec2 is a weak (pooled) reference.
+     * @returns The rotated vector in world space.
      */
-    totalImpulse(body?: Body | null, freshOnly?: boolean): Vec3;
+    localVectorToWorld(vector: Vec2, weak?: boolean): Vec2;
     /**
-     * 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.
+     * Rotate a vector from world space to local body space (no translation).
+     * @param vector - The vector in world space.
+     * @param weak - If true, the returned Vec2 is a weak (pooled) reference.
+     * @returns The rotated vector in local space.
      */
-    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;
+    worldVectorToLocal(vector: Vec2, weak?: boolean): Vec2;
     /**
-     * The Body this shape belongs to. Setting moves the shape between bodies.
+     * Apply a linear (and optionally angular) impulse to the body.
+     * If `pos` is given, it creates a torque about the body's centre.
+     * If `sleepable` is true, sleeping bodies are not woken.
+     * @param impulse - The linear impulse vector (world space).
+     * @param pos - Optional world-space point of application.
+     * @param sleepable - If true, the body will not be woken if sleeping.
+     * @returns `this` for chaining.
      */
-    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;
+    applyImpulse(impulse: Vec2, pos?: Vec2, sleepable?: boolean): Body;
     /**
-     * Local-space centre of mass. Can be set to override the default shape centroid.
+     * Apply a direct angular impulse (change in angular velocity × inertia).
+     * @param impulse - The angular impulse magnitude.
+     * @param sleepable - If true, the body will not be woken if sleeping.
+     * @returns `this` for chaining.
      */
-    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;
+    applyAngularImpulse(impulse: number, sleepable?: boolean): Body;
     /**
-     * Translate the shape's local vertices by the given vector (in-place).
-     * @param translation - The displacement vector to apply.
+     * Set linear and angular velocity so the body reaches the given target pose in `deltaTime` seconds.
+     * Useful for kinematic or manually driven bodies.
+     * @param targetPosition - Desired world-space position.
+     * @param targetRotation - Desired rotation in radians.
+     * @param deltaTime - Time in seconds over which to reach the target.
      * @returns `this` for chaining.
+     * @throws If `targetPosition` is null or `deltaTime` is zero.
      */
-    translate(translation: Vec2): Shape;
+    setVelocityFromTarget(targetPosition: Vec2, targetRotation: number, deltaTime: 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).
+     * Translate all shapes attached to this body in local space by `translation`.
+     * @param translation - Offset vector in local space.
      * @returns `this` for chaining.
      */
-    scale(scaleX: number, scaleY: number): Shape;
+    translateShapes(translation: Vec2): Body;
     /**
-     * Rotate the shape's local vertices by `angle` radians.
+     * Rotate all shapes attached to this body in local space by `angle` radians.
      * @param angle - Rotation in radians.
      * @returns `this` for chaining.
      */
-    rotate(angle: number): Shape;
+    rotateShapes(angle: number): Body;
     /**
-     * Apply a Mat23 affine transform to the shape's local geometry.
-     * @param matrix - The transformation matrix (must be non-singular; Circles require equiorthogonal).
+     * Scale all shapes attached to this body in local space.
+     * @param scaleX - Horizontal scale factor.
+     * @param scaleY - Vertical scale factor.
      * @returns `this` for chaining.
      */
-    transform(matrix: {
-        _inner: NapeInner;
-    }): Shape;
+    scaleShapes(scaleX: number, scaleY: number): 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.
+     * Apply an affine transform matrix to all shapes in local space.
+     * @param matrix - The 2D affine transformation matrix.
+     * @returns `this` for chaining.
      */
-    contains(point: Vec2): boolean;
+    transformShapes(matrix: Mat23): Body;
     /**
-     * Create a deep copy of this shape with the same type, geometry, material, and filter.
-     * @returns A new Shape instance independent of this one.
+     * Translate all shapes and adjust the body position so the local centre of mass coincides with the body origin.
+     * @returns `this` for chaining.
+     * @throws If the body has no shapes.
      */
-    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[];
+    align(): Body;
     /**
-     * Calculate minimum distance between two bodies and return closest points.
+     * Rotate the body about a world-space pivot point by `angle` radians.
+     * Moves the body's position and increments its rotation.
+     * @param centre - World-space pivot point.
+     * @param angle - Rotation in radians.
+     * @returns `this` for chaining.
+     * @throws If `centre` is null or `angle` is NaN.
      */
-    static distanceBody(body1: Body, body2: Body, out1: Vec2, out2: Vec2): number;
+    rotate(centre: Vec2, angle: number): Body;
     /**
-     * Calculate minimum distance between two shapes and return closest points.
+     * Set the same `Material` on every shape attached to this body.
+     * @param material - The material to apply.
+     * @returns `this` for chaining.
      */
-    static distance(shape1: Shape, shape2: Shape, out1: Vec2, out2: Vec2): number;
+    setShapeMaterials(material: Material): Body;
     /**
-     * Test if two bodies intersect (any of their shapes overlap).
+     * Set the same `InteractionFilter` on every shape attached to this body.
+     * @param filter - The interaction filter to apply.
+     * @returns `this` for chaining.
      */
-    static intersectsBody(body1: Body, body2: Body): boolean;
+    setShapeFilters(filter: InteractionFilter): Body;
     /**
-     * Test if two shapes intersect.
+     * Set the same `FluidProperties` on every shape attached to this body.
+     * @param fluidProperties - The fluid properties to apply.
+     * @returns `this` for chaining.
      */
-    static intersects(shape1: Shape, shape2: Shape): boolean;
+    setShapeFluidProperties(fluidProperties: FluidProperties): Body;
     /**
-     * Test if shape1 fully contains shape2.
+     * 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.
      */
-    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;
+    contains(point: Vec2): boolean;
     /**
-     * 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).
+     * 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.
      */
-    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;
+    connectedBodies(depth?: number, output?: BodyList | null): BodyList;
     /**
-     * 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).
+     * 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.
      */
-    constructor(localVerts?: Vec2[] | any, material?: Material, filter?: InteractionFilter);
+    interactingBodies(type?: InteractionType | null, _depth?: number, output?: BodyList | null): BodyList;
     /**
-     * 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 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 rect(x: number, y: number, width: number, height: number, weak?: boolean): Vec2[];
+    normalImpulse(body?: Body | null, freshOnly?: boolean): 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 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 box(width: number, height?: number, weak?: boolean): Vec2[];
+    tangentImpulse(body?: Body | null, freshOnly?: boolean): 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 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 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;
+    totalContactsImpulse(body?: Body | null, freshOnly?: boolean): 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 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.
      */
-    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;
+    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;
     /**
-     * Wrap a ZPP_Vec2 vertex into its public Vec2 outer.
-     * Mirrors the compiled vertex wrapping pattern.
+     * 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.
      */
-    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;
+    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;
 }
 
 /**
- * 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.
+ * Result from a convex-cast query.
  *
- * Obtain via {@link Arbiter.fluidArbiter} or by casting from a callback arbiter.
+ * 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;
+}
+
+/**
+ * Static utility class for geometric queries between shapes and bodies.
  *
- * Fully modernized — uses extracted ZPP_FluidArbiter directly.
+ * Fully modernized — calls ZPP_Geom, ZPP_SweepDistance, and ZPP_Collide directly.
  */
-declare class FluidArbiter extends Arbiter {
+declare class Geom {
     static __name__: string[];
-    static __super__: typeof Arbiter;
-    constructor();
     /**
-     * Centre of the overlap region between the fluid and the body shape.
-     * _Mutable in pre-handler only._
+     * 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;
 }
 
@@ -2637,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.
@@ -2811,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.
  *
@@ -3850,4 +3912,4 @@ declare abstract class UserConstraint extends Constraint {
 
 declare const VERSION: string;
 
-export { AABB, AngleJoint, Arbiter, ArbiterType, Body, BodyCallback, BodyListener, BodyType, Broadphase, Callback, CbEvent, CbType, type CbTypeSet, 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, UserConstraint, 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 };