@flighthq/physics2d 0.3.0-edge.1458.0c01b63

package/src/colliderTransform.test.ts

@@ -0,0 +1,115 @@
+import type { CollisionShape } from '@flighthq/types/contract';
+import { describe, expect, it } from 'vitest';
+
+import {
+  createPhysics2DColliderWorldShape,
+  updatePhysics2DColliderWorldShape,
+  writePhysics2DColliderBounds,
+} from './colliderTransform';
+import { createPhysics2DCollider, createRigidBody2D } from './world';
+
+const STONE = { density: 1, friction: 0.3, restitution: 0 };
+
+function bounds() {
+  return { minX: 0, minY: 0, maxX: 0, maxY: 0 };
+}
+
+describe('createPhysics2DColliderWorldShape', () => {
+  it('promotes an axis-aligned box to an oriented box, since a rotated box is not axis-aligned', () => {
+    expect(createPhysics2DColliderWorldShape({ kind: 'aabb', minX: 0, minY: 0, maxX: 1, maxY: 1 }).kind).toBe('obb');
+  });
+
+  it('keeps the kind for shapes a rigid transform preserves', () => {
+    expect(createPhysics2DColliderWorldShape({ kind: 'circle', x: 0, y: 0, radius: 1 }).kind).toBe('circle');
+    expect(createPhysics2DColliderWorldShape({ kind: 'polygon', points: [0, 0, 1, 0, 0, 1] }).kind).toBe('polygon');
+  });
+
+  it('gives a polygon its own points array so the per-step transform cannot write through to the local shape', () => {
+    const local: CollisionShape = { kind: 'polygon', points: [0, 0, 1, 0, 0, 1] };
+    const world = createPhysics2DColliderWorldShape(local);
+    expect(world.kind === 'polygon' && world.points).not.toBe(local.points);
+  });
+});
+
+describe('updatePhysics2DColliderWorldShape', () => {
+  it('rotates and translates a circle offset from the body origin', () => {
+    const collider = createPhysics2DCollider({ kind: 'circle', x: 1, y: 0, radius: 0.5 }, STONE);
+    const body = createRigidBody2D('dynamic', 10, 5, Math.PI / 2);
+    updatePhysics2DColliderWorldShape(collider, body);
+    expect(collider.world.kind).toBe('circle');
+    if (collider.world.kind !== 'circle') return;
+    expect(collider.world.x).toBeCloseTo(10);
+    expect(collider.world.y).toBeCloseTo(6);
+    expect(collider.world.radius).toBe(0.5);
+  });
+
+  it('carries the body angle onto the promoted oriented box rather than growing its extents', () => {
+    const collider = createPhysics2DCollider({ kind: 'aabb', minX: -1, minY: -0.5, maxX: 1, maxY: 0.5 }, STONE);
+    const body = createRigidBody2D('dynamic', 0, 0, 0.7);
+    updatePhysics2DColliderWorldShape(collider, body);
+    expect(collider.world.kind).toBe('obb');
+    if (collider.world.kind !== 'obb') return;
+    expect(collider.world.rotation).toBeCloseTo(0.7);
+    expect(collider.world.halfW).toBeCloseTo(1);
+    expect(collider.world.halfH).toBeCloseTo(0.5);
+  });
+
+  it('composes the body angle with an oriented box collider own rotation', () => {
+    const collider = createPhysics2DCollider({ kind: 'obb', x: 0, y: 0, halfW: 1, halfH: 1, rotation: 0.2 }, STONE);
+    const body = createRigidBody2D('dynamic', 0, 0, 0.5);
+    updatePhysics2DColliderWorldShape(collider, body);
+    if (collider.world.kind !== 'obb') return;
+    expect(collider.world.rotation).toBeCloseTo(0.7);
+  });
+
+  it('transforms every polygon vertex in place', () => {
+    const collider = createPhysics2DCollider({ kind: 'polygon', points: [0, 0, 1, 0, 0, 1] }, STONE);
+    const body = createRigidBody2D('dynamic', 3, 4, 0);
+    updatePhysics2DColliderWorldShape(collider, body);
+    if (collider.world.kind !== 'polygon') return;
+    expect(Array.from(collider.world.points)).toEqual([3, 4, 4, 4, 3, 5]);
+  });
+});
+
+describe('writePhysics2DColliderBounds', () => {
+  it('bounds a circle by its radius', () => {
+    const collider = createPhysics2DCollider({ kind: 'circle', x: 0, y: 0, radius: 2 }, STONE);
+    updatePhysics2DColliderWorldShape(collider, createRigidBody2D('dynamic', 1, 1));
+    const out = bounds();
+    writePhysics2DColliderBounds(collider, out);
+    expect(out).toEqual({ minX: -1, minY: -1, maxX: 3, maxY: 3 });
+  });
+
+  it('grows an oriented box bound as it turns, and returns to its extents at a quarter turn', () => {
+    // The bound of a rotated box is larger than the box; at 45 degrees it is largest, and at 90 it is the
+    // original extents with width and height exchanged. Pinned because a bound that did not grow would
+    // let the broadphase miss a genuine overlap.
+    const collider = createPhysics2DCollider({ kind: 'aabb', minX: -1, minY: -0.5, maxX: 1, maxY: 0.5 }, STONE);
+    const out = bounds();
+
+    updatePhysics2DColliderWorldShape(collider, createRigidBody2D('dynamic', 0, 0, Math.PI / 4));
+    writePhysics2DColliderBounds(collider, out);
+    expect(out.maxX).toBeGreaterThan(1);
+
+    updatePhysics2DColliderWorldShape(collider, createRigidBody2D('dynamic', 0, 0, Math.PI / 2));
+    writePhysics2DColliderBounds(collider, out);
+    expect(out.maxX).toBeCloseTo(0.5);
+    expect(out.maxY).toBeCloseTo(1);
+  });
+
+  it('bounds a polygon by its extreme vertices', () => {
+    const collider = createPhysics2DCollider({ kind: 'polygon', points: [0, 0, 4, 1, 2, 5] }, STONE);
+    updatePhysics2DColliderWorldShape(collider, createRigidBody2D('dynamic', 0, 0));
+    const out = bounds();
+    writePhysics2DColliderBounds(collider, out);
+    expect(out).toEqual({ minX: 0, minY: 0, maxX: 4, maxY: 5 });
+  });
+
+  it('gives an area-less shape empty bounds rather than infinities', () => {
+    const collider = createPhysics2DCollider({ kind: 'point', x: 1, y: 1 }, STONE);
+    const out = bounds();
+    writePhysics2DColliderBounds(collider, out);
+    expect(Number.isFinite(out.minX)).toBe(true);
+    expect(Number.isFinite(out.maxY)).toBe(true);
+  });
+});

package/src/islands.test.ts

@@ -0,0 +1,262 @@
+import type { Physics2DWorld, RigidBody2D } from '@flighthq/types/contract';
+import { describe, expect, it } from 'vitest';
+
+import { isRigidBody2DPairAwake, updatePhysics2DSleep, wakePhysics2DBody } from './islands';
+import { addPhysics2DBody, createPhysics2DWorld, createRigidBody2D } from './world';
+
+// A contact carries no mass properties and no geometry that sleep cares about — only which two bodies it
+// links — so the island tests build the linkage directly rather than dropping shapes on each other and
+// hoping the narrow phase produces the pair under test.
+function link(world: Physics2DWorld, a: Readonly<RigidBody2D>, b: Readonly<RigidBody2D>, sensor = false): void {
+  world.contacts.push({
+    bodyA: Math.min(a.index, b.index),
+    bodyB: Math.max(a.index, b.index),
+    colliderA: 0,
+    colliderB: 0,
+    normalX: 0,
+    normalY: 1,
+    pointCount: 0,
+    points: [],
+    friction: 0,
+    restitution: 0,
+    sensor,
+    touching: true,
+  });
+}
+
+function still(world: Physics2DWorld, x = 0): RigidBody2D {
+  return addPhysics2DBody(world, createRigidBody2D('dynamic', x, 0));
+}
+
+function moving(world: Physics2DWorld, x = 0): RigidBody2D {
+  const body = addPhysics2DBody(world, createRigidBody2D('dynamic', x, 0));
+  body.velocityX = 5;
+  return body;
+}
+
+describe('isRigidBody2DPairAwake', () => {
+  it('reports a pair awake when one end is an awake dynamic body', () => {
+    const world = createPhysics2DWorld();
+    const anchor = addPhysics2DBody(world, createRigidBody2D('static', 0, 0));
+    const crate = still(world);
+
+    expect(isRigidBody2DPairAwake(anchor, crate)).toBe(true);
+  });
+
+  it('reports a pair asleep when both ends are sleeping', () => {
+    const world = createPhysics2DWorld();
+    const first = still(world, 0);
+    const second = still(world, 1);
+    first.sleeping = true;
+    second.sleeping = true;
+
+    expect(isRigidBody2DPairAwake(first, second)).toBe(false);
+  });
+
+  it('reports a sleeper anchored to static scenery asleep', () => {
+    const world = createPhysics2DWorld();
+    const anchor = addPhysics2DBody(world, createRigidBody2D('static', 0, 0));
+    const crate = still(world);
+    crate.sleeping = true;
+
+    expect(isRigidBody2DPairAwake(anchor, crate)).toBe(false);
+  });
+});
+
+describe('updatePhysics2DSleep', () => {
+  it('sleeps a body that has been still for the full timeToSleep', () => {
+    const world = createPhysics2DWorld();
+    const crate = still(world);
+
+    updatePhysics2DSleep(world, world.config.timeToSleep + 0.01);
+
+    expect(crate.sleeping).toBe(true);
+  });
+
+  it('leaves a still body awake until timeToSleep has elapsed', () => {
+    const world = createPhysics2DWorld();
+    const crate = still(world);
+
+    updatePhysics2DSleep(world, world.config.timeToSleep - 0.01);
+
+    expect(crate.sleeping).toBe(false);
+    expect(crate.sleepTimer).toBeCloseTo(world.config.timeToSleep - 0.01);
+  });
+
+  it('resets the timer of a body moving faster than the linear threshold', () => {
+    const world = createPhysics2DWorld();
+    const crate = still(world);
+    updatePhysics2DSleep(world, 0.4);
+    crate.velocityX = world.config.sleepLinearThreshold * 10;
+
+    updatePhysics2DSleep(world, 0.4);
+
+    expect(crate.sleepTimer).toBe(0);
+    expect(crate.sleeping).toBe(false);
+  });
+
+  it('resets the timer of a body spinning faster than the angular threshold', () => {
+    const world = createPhysics2DWorld();
+    const crate = still(world);
+    updatePhysics2DSleep(world, 0.4);
+    crate.angularVelocity = world.config.sleepAngularThreshold * 10;
+
+    updatePhysics2DSleep(world, 0.4);
+
+    expect(crate.sleepTimer).toBe(0);
+    expect(crate.sleeping).toBe(false);
+  });
+
+  it('treats a body carrying an applied force as moving even at zero velocity', () => {
+    const world = createPhysics2DWorld();
+    const crate = still(world);
+    crate.forceX = 100;
+
+    updatePhysics2DSleep(world, world.config.timeToSleep + 0.01);
+
+    expect(crate.sleeping).toBe(false);
+    expect(crate.sleepTimer).toBe(0);
+  });
+
+  it('treats a body carrying an applied torque as moving even at zero velocity', () => {
+    const world = createPhysics2DWorld();
+    const crate = still(world);
+    crate.torque = 100;
+
+    updatePhysics2DSleep(world, world.config.timeToSleep + 0.01);
+
+    expect(crate.sleeping).toBe(false);
+  });
+
+  it('zeroes the velocity of a body it puts to sleep', () => {
+    const world = createPhysics2DWorld();
+    const crate = still(world);
+    // Under both thresholds, so it still qualifies as at rest — but not exactly zero, which is the drift
+    // a sleeping body would otherwise resume on waking.
+    crate.velocityX = world.config.sleepLinearThreshold / 2;
+    crate.angularVelocity = world.config.sleepAngularThreshold / 2;
+
+    updatePhysics2DSleep(world, world.config.timeToSleep + 0.01);
+
+    expect(crate.sleeping).toBe(true);
+    expect(crate.velocityX).toBe(0);
+    expect(crate.angularVelocity).toBe(0);
+  });
+
+  it('keeps a contact island awake while any one member is moving', () => {
+    const world = createPhysics2DWorld();
+    const settled = still(world, 0);
+    const shoved = moving(world, 1);
+    link(world, settled, shoved);
+
+    updatePhysics2DSleep(world, world.config.timeToSleep + 0.01);
+
+    expect(shoved.sleeping).toBe(false);
+    expect(settled.sleeping).toBe(false);
+  });
+
+  it('keeps a transitively linked member awake through an intermediate body', () => {
+    const world = createPhysics2DWorld();
+    const settled = still(world, 0);
+    const middle = still(world, 1);
+    const shoved = moving(world, 2);
+    link(world, settled, middle);
+    link(world, middle, shoved);
+
+    updatePhysics2DSleep(world, world.config.timeToSleep + 0.01);
+
+    expect(settled.sleeping).toBe(false);
+  });
+
+  it('keeps a joint island awake while any one member is moving', () => {
+    const world = createPhysics2DWorld();
+    const settled = still(world, 0);
+    const shoved = moving(world, 1);
+    world.joints.push({ kind: 'test', bodyA: settled.index, bodyB: shoved.index, collideConnected: false } as never);
+
+    updatePhysics2DSleep(world, world.config.timeToSleep + 0.01);
+
+    expect(settled.sleeping).toBe(false);
+  });
+
+  it('does not let a shared static body merge two islands', () => {
+    // The failure this prevents is world-sized: every crate in a level rests on the same ground, so a
+    // static bridge would make the whole level one island that sleeps only when nothing anywhere moves.
+    const world = createPhysics2DWorld();
+    const ground = addPhysics2DBody(world, createRigidBody2D('static', 0, 0));
+    const settled = still(world, 0);
+    const shoved = moving(world, 20);
+    link(world, ground, settled);
+    link(world, ground, shoved);
+
+    updatePhysics2DSleep(world, world.config.timeToSleep + 0.01);
+
+    expect(settled.sleeping).toBe(true);
+    expect(shoved.sleeping).toBe(false);
+  });
+
+  it('does not let a sensor contact merge two islands', () => {
+    // A sensor reports overlap and resolves nothing, so it transmits no motion between the bodies it
+    // reports on and must not hold a settled body awake.
+    const world = createPhysics2DWorld();
+    const settled = still(world, 0);
+    const shoved = moving(world, 1);
+    link(world, settled, shoved, true);
+
+    updatePhysics2DSleep(world, world.config.timeToSleep + 0.01);
+
+    expect(settled.sleeping).toBe(true);
+  });
+
+  it('leaves static bodies neither asleep nor accumulating a timer', () => {
+    const world = createPhysics2DWorld();
+    const ground = addPhysics2DBody(world, createRigidBody2D('static', 0, 0));
+
+    updatePhysics2DSleep(world, world.config.timeToSleep + 0.01);
+
+    expect(ground.sleeping).toBe(false);
+    expect(ground.sleepTimer).toBe(0);
+  });
+
+  it('wakes everything already asleep when allowSleeping is turned off', () => {
+    // A body left asleep after the mechanism is disabled would never be integrated again, so it would
+    // hang frozen for the rest of the session.
+    const world = createPhysics2DWorld();
+    const crate = still(world);
+    updatePhysics2DSleep(world, world.config.timeToSleep + 0.01);
+    expect(crate.sleeping).toBe(true);
+
+    world.config.allowSleeping = false;
+    updatePhysics2DSleep(world, 0.016);
+
+    expect(crate.sleeping).toBe(false);
+    expect(crate.sleepTimer).toBe(0);
+  });
+
+  it('clears the timer of a body it wakes so rest has to be earned again', () => {
+    const world = createPhysics2DWorld();
+    const settled = still(world, 0);
+    updatePhysics2DSleep(world, world.config.timeToSleep + 0.01);
+    expect(settled.sleeping).toBe(true);
+
+    const shoved = moving(world, 1);
+    link(world, settled, shoved);
+    updatePhysics2DSleep(world, 0.016);
+
+    expect(settled.sleeping).toBe(false);
+    expect(settled.sleepTimer).toBe(0);
+  });
+});
+
+describe('wakePhysics2DBody', () => {
+  it('clears both the sleeping flag and the stillness timer', () => {
+    const world = createPhysics2DWorld();
+    const crate = still(world);
+    updatePhysics2DSleep(world, world.config.timeToSleep + 0.01);
+
+    wakePhysics2DBody(crate);
+
+    expect(crate.sleeping).toBe(false);
+    expect(crate.sleepTimer).toBe(0);
+  });
+});

package/src/jointRegistry.test.ts

@@ -0,0 +1,205 @@
+import type { Physics2DJoint } from '@flighthq/types/contract';
+import { describe, expect, it } from 'vitest';
+
+import {
+  addPhysics2DJoint,
+  getPhysics2DJointSolver,
+  registerPhysics2DJointSolver,
+  removePhysics2DJoint,
+} from './jointRegistry';
+import { stepPhysics2D } from './step';
+import {
+  addPhysics2DBody,
+  createPhysics2DCollider,
+  createPhysics2DWorld,
+  createRigidBody2D,
+  removePhysics2DBody,
+} from './world';
+
+const STONE = { density: 1, friction: 0.3, restitution: 0 };
+
+function body(world: ReturnType<typeof createPhysics2DWorld>, x: number, y: number) {
+  const made = createRigidBody2D('dynamic', x, y);
+  made.colliders.push(createPhysics2DCollider({ kind: 'aabb', minX: -0.5, minY: -0.5, maxX: 0.5, maxY: 0.5 }, STONE));
+  return addPhysics2DBody(world, made);
+}
+
+function joint(kind: string, bodyA: number, bodyB: number, anchorAX = 0, anchorBX = 0): Physics2DJoint {
+  return {
+    kind,
+    bodyA,
+    bodyB,
+    localAnchorAX: anchorAX,
+    localAnchorAY: 0,
+    localAnchorBX: anchorBX,
+    localAnchorBY: 0,
+    collideConnected: false,
+    impulse0: 0,
+    impulse1: 0,
+    impulse2: 0,
+    rAX: 0,
+    rAY: 0,
+    rBX: 0,
+    rBY: 0,
+  };
+}
+
+describe('addPhysics2DJoint', () => {
+  it('orders the joint by body index, carrying its anchors with the swap', () => {
+    // Obligation 1 applies to joints too: they enter the SAME sequential solve list as contacts, and a
+    // joint has no broadphase to canonicalise it, so this is the one place it can be enforced. The
+    // anchors have to travel with the bodies — a joint whose ends were exchanged without its anchors
+    // would attach to the wrong points and hold the pair in a pose nobody asked for.
+    const world = createPhysics2DWorld();
+    registerPhysics2DJointSolver(world, 'Test', { prepare: () => {}, solve: () => {} });
+    const first = body(world, 0, 0);
+    const second = body(world, 2, 0);
+    const added = addPhysics2DJoint(world, joint('Test', second.index, first.index, 7, 9));
+
+    expect(added.bodyA).toBe(first.index);
+    expect(added.bodyB).toBe(second.index);
+    expect(added.localAnchorAX).toBe(9);
+    expect(added.localAnchorBX).toBe(7);
+  });
+
+  // Adding a joint whose kind has no solver yet is explicitly supported — a scene can deserialize
+  // ahead of the code that solves it. Canonicalizing there would exchange bodies and anchors while the
+  // kind's own direction fields stayed as authored, and no later registration would repair that half
+  // swap. So ordering waits for the kind, and an unsolved joint constrains nothing meanwhile.
+  it('leaves a joint whose kind has no solver in its authored order', () => {
+    const world = createPhysics2DWorld();
+    const first = body(world, 0, 0);
+    const second = body(world, 2, 0);
+
+    const added = addPhysics2DJoint(world, joint('Unknown', second.index, first.index, 7, 9));
+
+    expect(added.bodyA).toBe(second.index);
+    expect(added.localAnchorAX).toBe(7);
+  });
+
+  // Critic's repro: register the solver AFTER the joint is already in the world, and the kind's own
+  // reversal must still run. Previously the generic swap had already happened at add time without the
+  // kind's consent, so the directional field kept its authored sign forever.
+  it('canonicalizes an already-added joint when its solver registers later, reversing direction', () => {
+    const world = createPhysics2DWorld();
+    const first = body(world, 0, 0);
+    const second = body(world, 2, 0);
+    const added = addPhysics2DJoint(world, {
+      ...joint('Directional', second.index, first.index, 7, 9),
+      direction: 1,
+    } as Physics2DJoint & { direction: number });
+
+    registerPhysics2DJointSolver(world, 'Directional', {
+      prepare: () => {},
+      solve: () => {},
+      swapEnds: (target) => {
+        const directional = target as Physics2DJoint & { direction: number };
+        directional.direction = -directional.direction;
+        return true;
+      },
+    });
+
+    expect(added.bodyA).toBe(first.index);
+    expect(added.localAnchorAX).toBe(9);
+    expect((added as Physics2DJoint & { direction: number }).direction).toBe(-1);
+  });
+
+  // A kind that vetoes the exchange must still be obeyed on the deferred path.
+  it('honours a solver that vetoes the swap when it registers later', () => {
+    const world = createPhysics2DWorld();
+    const first = body(world, 0, 0);
+    const second = body(world, 2, 0);
+    const added = addPhysics2DJoint(world, joint('Vetoing', second.index, first.index, 7, 9));
+
+    registerPhysics2DJointSolver(world, 'Vetoing', {
+      prepare: () => {},
+      solve: () => {},
+      swapEnds: () => false,
+    });
+
+    expect(added.bodyA).toBe(second.index);
+    expect(added.localAnchorAX).toBe(7);
+  });
+
+  it('leaves an already-ordered joint untouched', () => {
+    const world = createPhysics2DWorld();
+    const first = body(world, 0, 0);
+    const second = body(world, 2, 0);
+    const added = addPhysics2DJoint(world, joint('Test', first.index, second.index, 7, 9));
+    expect(added.bodyA).toBe(first.index);
+    expect(added.localAnchorAX).toBe(7);
+  });
+});
+
+describe('getPhysics2DJointSolver', () => {
+  it('returns null for an unregistered kind rather than throwing', () => {
+    // A scene deserialized with a joint kind this build does not know about should import and simply not
+    // constrain, not refuse to load.
+    const world = createPhysics2DWorld();
+    expect(getPhysics2DJointSolver(world, 'acme.Conveyor')).toBeNull();
+  });
+
+  it('steps a world holding a joint whose kind has no solver', () => {
+    const world = createPhysics2DWorld();
+    const first = body(world, 0, 0);
+    const second = body(world, 2, 0);
+    addPhysics2DJoint(world, joint('acme.Unknown', first.index, second.index));
+    expect(() => stepPhysics2D(world, 1 / 60)).not.toThrow();
+  });
+});
+
+describe('registerPhysics2DJointSolver', () => {
+  it('makes a custom kind solvable without this package knowing it', () => {
+    const world = createPhysics2DWorld(0, 0);
+    let prepared = 0;
+    let solved = 0;
+    registerPhysics2DJointSolver(world, 'acme.Conveyor', {
+      prepare: () => void prepared++,
+      solve: () => void solved++,
+    });
+    const first = body(world, 0, 0);
+    const second = body(world, 2, 0);
+    addPhysics2DJoint(world, joint('acme.Conveyor', first.index, second.index));
+    stepPhysics2D(world, 1 / 60);
+
+    expect(prepared).toBe(1);
+    expect(solved).toBe(world.config.velocityIterations);
+  });
+
+  it('is scoped to its world, so two worlds can register different kinds', () => {
+    const first = createPhysics2DWorld();
+    const second = createPhysics2DWorld();
+    registerPhysics2DJointSolver(first, 'acme.One', { prepare: () => {}, solve: () => {} });
+    expect(getPhysics2DJointSolver(first, 'acme.One')).not.toBeNull();
+    expect(getPhysics2DJointSolver(second, 'acme.One')).toBeNull();
+  });
+
+  it('lets a later registration replace an earlier one', () => {
+    const world = createPhysics2DWorld();
+    const replacement = { prepare: () => {}, solve: () => {} };
+    registerPhysics2DJointSolver(world, 'acme.One', { prepare: () => {}, solve: () => {} });
+    registerPhysics2DJointSolver(world, 'acme.One', replacement);
+    expect(getPhysics2DJointSolver(world, 'acme.One')).toBe(replacement);
+  });
+});
+
+describe('removePhysics2DJoint', () => {
+  it('removes the joint and reports false for one the world does not hold', () => {
+    const world = createPhysics2DWorld();
+    const first = body(world, 0, 0);
+    const second = body(world, 2, 0);
+    const added = addPhysics2DJoint(world, joint('Test', first.index, second.index));
+    expect(removePhysics2DJoint(world, added)).toBe(true);
+    expect(world.joints).toHaveLength(0);
+    expect(removePhysics2DJoint(world, added)).toBe(false);
+  });
+
+  it('drops joints naming a removed body, so a later body cannot inherit the constraint', () => {
+    const world = createPhysics2DWorld();
+    const first = body(world, 0, 0);
+    const second = body(world, 2, 0);
+    addPhysics2DJoint(world, joint('Test', first.index, second.index));
+    removePhysics2DBody(world, second);
+    expect(world.joints).toHaveLength(0);
+  });
+});