@pibbl/core 0.0.1

package/dist/features/physics/lib/2d/world/world.js

@@ -0,0 +1,1713 @@
+import { manifoldBetweenShapeRecords2D } from "../collision/pairs.js";
+import {
+  DEFAULT_FIXED_STEP_MILLISECONDS,
+  DEFAULT_GRAVITY,
+  DEFAULT_INTERPOLATION,
+  DEFAULT_MAX_CATCH_UP_STEPS,
+  DEFAULT_POSITION_ITERATIONS,
+  DEFAULT_SLEEPING,
+  DEFAULT_VELOCITY_ITERATIONS,
+  MAX_CATCH_UP_STEPS,
+  MAX_SOLVER_ITERATIONS,
+  MIN_CATCH_UP_STEPS,
+  MIN_SOLVER_ITERATIONS,
+  RADIANS_TO_DEGREES
+} from "../numeric-policy.js";
+import { recordPhysicsWorld2DTrace } from "../runtime/trace.js";
+import { createPhysicsOwnershipCounters2D } from "../runtime/ownership.js";
+import { DynamicAabbBroadPhase2D } from "./broad-phase.js";
+import { BoundedCcd2D, collisionFiltersAllow2D } from "./ccd.js";
+import { ContactCache2D, updateSortedContactCache2D } from "./contact-cache.js";
+import {
+  BODY_TYPE_DYNAMIC_2D,
+  BODY_TYPE_KINEMATIC_2D,
+  applyForceAtPointToCandidateBody2D,
+  applyImpulseAtPointToCandidateBody2D,
+  applyTorqueToCandidateBody2D,
+  integrateCandidateVelocities2D,
+  integrateCandidatePoses2D
+} from "./integrator.js";
+import { BODY_SLEEPING_2D, SequentialImpulseSolver2D } from "./solver.js";
+import {
+  BodyStore2D,
+  ColliderStore2D
+} from "./storage.js";
+const NO_INDEX = -1;
+let failureInjector;
+function installPhysicsWorld2DFailureInjectorForTest(injector) {
+  const previous = failureInjector;
+  failureInjector = injector;
+  return () => {
+    if (failureInjector === injector) failureInjector = previous;
+  };
+}
+class PhysicsWorld2DCandidate {
+  constructor(owner, checkpoint, frameId, logicalTime, stepCount, tick, accumulatorMilliseconds, advanceEligible, eventOffset, eventCount, eventTicks, eventKinds, eventFirstColliderIndices, eventFirstColliderGenerations, eventSecondColliderIndices, eventSecondColliderGenerations, eventNormalX, eventNormalY, eventPointCounts, eventPointFirstX, eventPointFirstY, eventPointSecondX, eventPointSecondY, eventPointSeparations, eventTotalNormalImpulses, topologyRevision, commandRevision, commandCount) {
+    this.owner = owner;
+    this.checkpoint = checkpoint;
+    this.frameId = frameId;
+    this.logicalTime = logicalTime;
+    this.stepCount = stepCount;
+    this.tick = tick;
+    this.accumulatorMilliseconds = accumulatorMilliseconds;
+    this.advanceEligible = advanceEligible;
+    this.eventOffset = eventOffset;
+    this.eventCount = eventCount;
+    this.eventTicks = eventTicks;
+    this.eventKinds = eventKinds;
+    this.eventFirstColliderIndices = eventFirstColliderIndices;
+    this.eventFirstColliderGenerations = eventFirstColliderGenerations;
+    this.eventSecondColliderIndices = eventSecondColliderIndices;
+    this.eventSecondColliderGenerations = eventSecondColliderGenerations;
+    this.eventNormalX = eventNormalX;
+    this.eventNormalY = eventNormalY;
+    this.eventPointCounts = eventPointCounts;
+    this.eventPointFirstX = eventPointFirstX;
+    this.eventPointFirstY = eventPointFirstY;
+    this.eventPointSecondX = eventPointSecondX;
+    this.eventPointSecondY = eventPointSecondY;
+    this.eventPointSeparations = eventPointSeparations;
+    this.eventTotalNormalImpulses = eventTotalNormalImpulses;
+    this.topologyRevision = topologyRevision;
+    this.commandRevision = commandRevision;
+    this.commandCount = commandCount;
+  }
+  owner;
+  checkpoint;
+  frameId;
+  logicalTime;
+  stepCount;
+  tick;
+  accumulatorMilliseconds;
+  advanceEligible;
+  eventOffset;
+  eventCount;
+  eventTicks;
+  eventKinds;
+  eventFirstColliderIndices;
+  eventFirstColliderGenerations;
+  eventSecondColliderIndices;
+  eventSecondColliderGenerations;
+  eventNormalX;
+  eventNormalY;
+  eventPointCounts;
+  eventPointFirstX;
+  eventPointFirstY;
+  eventPointSecondX;
+  eventPointSecondY;
+  eventPointSeparations;
+  eventTotalNormalImpulses;
+  topologyRevision;
+  commandRevision;
+  commandCount;
+  status = "live";
+  get lifecycle() {
+    return this.status;
+  }
+  consume(status) {
+    if (this.status !== "live") {
+      throw new Error("physics world candidate has already been consumed.");
+    }
+    const checkpoint = this.checkpoint;
+    this.checkpoint = void 0;
+    this.status = status;
+    return checkpoint;
+  }
+}
+class PhysicsWorld2DKernel {
+  constructor(configuration = {}, simulation) {
+    this.simulation = simulation;
+    this.state = {
+      configuration: normalizePhysicsWorld2DConfiguration(configuration),
+      accumulatorMilliseconds: 0,
+      previousLogicalTime: 0,
+      anchored: false,
+      tick: 0,
+      topologyRevision: 0,
+      commandRevision: 0,
+      bodySlots: /* @__PURE__ */ new Map(),
+      colliderSlots: /* @__PURE__ */ new Map(),
+      bodyRecords: /* @__PURE__ */ new Map(),
+      colliderRecords: /* @__PURE__ */ new Map(),
+      disabledBodies: /* @__PURE__ */ new Map(),
+      previousPositionX: new Float64Array(this.bodies.capacity),
+      previousPositionY: new Float64Array(this.bodies.capacity),
+      previousRotationRadians: new Float64Array(this.bodies.capacity),
+      bodyIndices: new Int32Array(this.bodies.capacity),
+      bodyCount: 0,
+      integrationBodyIndices: new Int32Array(this.bodies.capacity),
+      integrationBodyCount: 0,
+      eventTicks: new Float64Array(4),
+      eventKinds: new Uint8Array(4),
+      eventFirstColliderIndices: new Int32Array(4),
+      eventFirstColliderGenerations: new Uint32Array(4),
+      eventSecondColliderIndices: new Int32Array(4),
+      eventSecondColliderGenerations: new Uint32Array(4),
+      eventNormalX: new Float64Array(4),
+      eventNormalY: new Float64Array(4),
+      eventPointCounts: new Uint8Array(4),
+      eventPointFirstX: new Float64Array(8),
+      eventPointFirstY: new Float64Array(8),
+      eventPointSecondX: new Float64Array(8),
+      eventPointSecondY: new Float64Array(8),
+      eventPointSeparations: new Float64Array(8),
+      eventTotalNormalImpulses: new Float64Array(4),
+      eventCount: 0,
+      contactEventFacts: /* @__PURE__ */ new Map(),
+      savedNormalImpulses: new Float64Array(8),
+      savedTangentImpulses: new Float64Array(8)
+    };
+  }
+  simulation;
+  counters = createPhysicsOwnershipCounters2D();
+  bodies = new BodyStore2D(this.counters);
+  colliders = new ColliderStore2D(this.counters);
+  broadPhase = new DynamicAabbBroadPhase2D(this.counters);
+  contacts = new ContactCache2D();
+  solver = new SequentialImpulseSolver2D();
+  positionSolver = new SequentialImpulseSolver2D();
+  ccd = new BoundedCcd2D();
+  state;
+  pendingTopology;
+  pendingCommands = Object.freeze([]);
+  nextTopologyRevision = 0;
+  nextCommandRevision = 0;
+  liveCandidate;
+  disposed = false;
+  /** Refresh listener/tag metadata after a successful render without waking physics. */
+  updateColliderMetadata(records) {
+    this.assertUsable();
+    for (const record of records) {
+      if (record.kind !== "collider") continue;
+      const previous = this.state.colliderRecords.get(record.id);
+      if (!previous || previous.bodyId !== record.bodyId) continue;
+      const { handlers, tag, owner } = record.definition;
+      if (previous.definition.handlers === handlers && previous.definition.tag === tag && previous.definition.owner === owner)
+        continue;
+      this.state.colliderRecords.set(record.id, {
+        ...previous,
+        definition: { ...previous.definition, handlers, tag, owner }
+      });
+      const slot = this.state.colliderSlots.get(record.id);
+      if (!slot) continue;
+      this.colliders.handlers[slot.index] = handlers;
+      this.colliders.tags[slot.index] = tag;
+      this.colliders.owners[slot.index] = owner;
+    }
+  }
+  proposeTopology(records) {
+    this.assertUsable();
+    validateTopology(records);
+    this.pendingTopology = Object.freeze([...records]);
+    this.nextTopologyRevision += 1;
+  }
+  applyBegin(commands) {
+    this.assertUsable();
+    for (const command of commands) validateCommand(command);
+    this.pendingCommands = Object.freeze([
+      ...this.pendingCommands,
+      ...commands
+    ]);
+    if (commands.length > 0) this.nextCommandRevision += 1;
+  }
+  advance(input) {
+    this.assertUsable();
+    if (this.liveCandidate !== void 0) {
+      throw new Error("physics world already has a live candidate.");
+    }
+    if (!Number.isSafeInteger(input.frameId) || input.frameId < 0) {
+      throw new RangeError("frameId must be a nonnegative safe integer.");
+    }
+    if (!Number.isFinite(input.logicalTime)) {
+      throw new RangeError("logicalTime must be finite.");
+    }
+    for (const [bodyId, pose] of input.stagedKinematicTargets) {
+      validateId(bodyId, "staged kinematic body id");
+      validatePose(pose, "staged kinematic pose");
+    }
+    const eventOffset = this.state.eventCount;
+    const checkpoint = this.captureCheckpoint();
+    const topologyRevision = this.nextTopologyRevision;
+    const commandRevision = this.nextCommandRevision;
+    const commandCount = this.pendingCommands.length;
+    try {
+      const topologyPending = this.pendingTopology !== void 0 && topologyRevision > this.state.topologyRevision;
+      const commandsPending = commandRevision > this.state.commandRevision;
+      if (topologyPending) {
+        this.reconcileTopology(this.pendingTopology);
+        this.state.topologyRevision = topologyRevision;
+      }
+      if (commandsPending) {
+        this.applyCommands(this.pendingCommands);
+        this.state.commandRevision = commandRevision;
+      }
+      injectFailure("topology");
+      const reanchor = !this.state.anchored;
+      const elapsed = reanchor ? 0 : Math.max(0, input.logicalTime - this.state.previousLogicalTime);
+      this.state.previousLogicalTime = input.logicalTime;
+      this.state.anchored = true;
+      const configuration = this.state.configuration;
+      const maximumElapsed = configuration.fixedStepMilliseconds * configuration.maxCatchUpSteps;
+      const acceptedElapsed = Math.min(elapsed, maximumElapsed);
+      const discardedElapsed = elapsed - acceptedElapsed;
+      if (discardedElapsed > 0) {
+        recordPhysicsWorld2DTrace({
+          kind: "physics-2d-clamp",
+          frameId: input.frameId,
+          logicalTime: input.logicalTime,
+          acceptedElapsedMilliseconds: acceptedElapsed,
+          discardedElapsedMilliseconds: discardedElapsed
+        });
+      }
+      this.state.accumulatorMilliseconds += acceptedElapsed;
+      const stepCount = Math.min(
+        configuration.maxCatchUpSteps,
+        Math.floor(
+          (this.state.accumulatorMilliseconds + Number.EPSILON) / configuration.fixedStepMilliseconds
+        )
+      );
+      const starts = /* @__PURE__ */ new Map();
+      if (stepCount > 1)
+        for (const [bodyId] of input.stagedKinematicTargets) {
+          if (this.state.bodySlots.has(bodyId))
+            starts.set(bodyId, this.authoritativePose(bodyId));
+        }
+      for (let step = 0; step < stepCount; step += 1) {
+        let tickInput = input;
+        if (stepCount > 1) {
+          const fraction = (step + 1) / stepCount;
+          const targets = /* @__PURE__ */ new Map();
+          for (const [bodyId, target] of input.stagedKinematicTargets) {
+            const start = starts.get(bodyId);
+            if (!start) continue;
+            targets.set(bodyId, {
+              position: [
+                start.position[0] + (target.position[0] - start.position[0]) * fraction,
+                start.position[1] + (target.position[1] - start.position[1]) * fraction
+              ],
+              rotationDegrees: start.rotationDegrees + shortestRadians(
+                start.rotationDegrees / RADIANS_TO_DEGREES,
+                target.rotationDegrees / RADIANS_TO_DEGREES
+              ) * RADIANS_TO_DEGREES * fraction
+            });
+          }
+          tickInput = { ...input, stagedKinematicTargets: targets };
+        }
+        this.simulateFixedTick(tickInput);
+        this.state.accumulatorMilliseconds -= configuration.fixedStepMilliseconds;
+        if (this.state.accumulatorMilliseconds < Number.EPSILON) {
+          this.state.accumulatorMilliseconds = 0;
+        }
+      }
+      if (stepCount > 0 && !this.solver.advanceEligible && !this.hasKinematicBodies()) {
+        this.state.accumulatorMilliseconds = 0;
+        this.state.anchored = false;
+        this.capturePreviousPoses();
+      }
+      const candidate = new PhysicsWorld2DCandidate(
+        this,
+        checkpoint,
+        input.frameId,
+        input.logicalTime,
+        stepCount,
+        this.state.tick,
+        this.state.accumulatorMilliseconds,
+        this.hasAdvanceWork(),
+        eventOffset,
+        this.state.eventCount - eventOffset,
+        this.state.eventTicks,
+        this.state.eventKinds,
+        this.state.eventFirstColliderIndices,
+        this.state.eventFirstColliderGenerations,
+        this.state.eventSecondColliderIndices,
+        this.state.eventSecondColliderGenerations,
+        this.state.eventNormalX,
+        this.state.eventNormalY,
+        this.state.eventPointCounts,
+        this.state.eventPointFirstX,
+        this.state.eventPointFirstY,
+        this.state.eventPointSecondX,
+        this.state.eventPointSecondY,
+        this.state.eventPointSeparations,
+        this.state.eventTotalNormalImpulses,
+        topologyRevision,
+        commandRevision,
+        commandCount
+      );
+      this.liveCandidate = candidate;
+      recordPhysicsWorld2DTrace({
+        kind: "physics-2d-candidate",
+        frameId: input.frameId,
+        logicalTime: input.logicalTime,
+        tick: this.state.tick,
+        stepCount
+      });
+      return candidate;
+    } catch (error) {
+      this.restoreCheckpoint(checkpoint);
+      recordPhysicsWorld2DTrace({
+        kind: "physics-2d-error",
+        frameId: input.frameId,
+        logicalTime: input.logicalTime,
+        error
+      });
+      throw error;
+    }
+  }
+  adopt(candidate) {
+    this.assertCandidate(candidate);
+    candidate.consume("adopted");
+    this.liveCandidate = void 0;
+    if (candidate.topologyRevision === this.nextTopologyRevision) {
+      this.pendingTopology = void 0;
+    }
+    if (candidate.commandRevision === this.nextCommandRevision) {
+      this.pendingCommands = Object.freeze([]);
+    } else if (candidate.commandCount > 0) {
+      this.pendingCommands = Object.freeze(
+        this.pendingCommands.slice(candidate.commandCount)
+      );
+    }
+    recordPhysicsWorld2DTrace({
+      kind: "physics-2d-adopt",
+      frameId: candidate.frameId,
+      tick: candidate.tick
+    });
+  }
+  discard(candidate) {
+    this.assertCandidate(candidate);
+    const checkpoint = candidate.consume("discarded");
+    this.restoreCheckpoint(checkpoint);
+    this.liveCandidate = void 0;
+    recordPhysicsWorld2DTrace({
+      kind: "physics-2d-discard",
+      frameId: candidate.frameId,
+      tick: candidate.tick
+    });
+  }
+  authoritativePose(bodyId) {
+    this.assertUsable();
+    const slot = this.requireBody(bodyId);
+    return publicBodyOriginPose(this.bodies, slot.index);
+  }
+  isBodyEnabled(bodyId) {
+    this.assertUsable();
+    return this.state.bodySlots.has(bodyId) && !this.state.disabledBodies.has(bodyId);
+  }
+  bodyIdentity(bodyId) {
+    this.assertUsable();
+    return this.state.bodySlots.get(bodyId);
+  }
+  bodyIdForIdentity(index, generation) {
+    this.assertUsable();
+    for (const [id, slot] of this.state.bodySlots) {
+      if (slot.index === index && slot.generation === generation) return id;
+    }
+    return void 0;
+  }
+  colliderIdForIdentity(index, generation) {
+    this.assertUsable();
+    for (const [id, slot] of this.state.colliderSlots) {
+      if (slot.index === index && slot.generation === generation) return id;
+    }
+    return void 0;
+  }
+  colliderIdentity(colliderId) {
+    this.assertUsable();
+    return this.state.colliderSlots.get(colliderId);
+  }
+  presentationPose(bodyId) {
+    this.assertUsable();
+    const slot = this.requireBody(bodyId);
+    const index = slot.index;
+    if (this.state.configuration.interpolation === "none") {
+      return this.authoritativePose(bodyId);
+    }
+    const alpha = this.state.accumulatorMilliseconds / this.state.configuration.fixedStepMilliseconds;
+    const previousRotation = this.state.previousRotationRadians[index];
+    const currentRotation = this.bodies.rotationRadians[index];
+    return publicPoseFromCenter(
+      this.bodies,
+      index,
+      lerp(
+        this.state.previousPositionX[index],
+        this.bodies.positionX[index],
+        alpha
+      ),
+      lerp(
+        this.state.previousPositionY[index],
+        this.bodies.positionY[index],
+        alpha
+      ),
+      previousRotation + shortestRadians(previousRotation, currentRotation) * alpha
+    );
+  }
+  snapshot() {
+    const bodies = [...this.state.bodySlots.entries()].sort(([first], [second]) => first - second).map(
+      ([id, slot]) => Object.freeze({
+        id,
+        index: slot.index,
+        generation: slot.generation,
+        positionX: this.bodies.positionX[slot.index],
+        positionY: this.bodies.positionY[slot.index],
+        rotationRadians: this.bodies.rotationRadians[slot.index],
+        localCenterX: this.bodies.localCenterX[slot.index],
+        localCenterY: this.bodies.localCenterY[slot.index],
+        linearVelocityX: this.bodies.linearVelocityX[slot.index],
+        linearVelocityY: this.bodies.linearVelocityY[slot.index],
+        angularVelocity: this.bodies.angularVelocity[slot.index],
+        inverseMass: this.bodies.inverseMass[slot.index],
+        inverseInertia: this.bodies.inverseInertia[slot.index],
+        flags: this.bodies.flags[slot.index]
+      })
+    );
+    return Object.freeze({
+      tick: this.state.tick,
+      accumulatorMilliseconds: this.state.accumulatorMilliseconds,
+      anchored: this.state.anchored,
+      bodyCount: this.state.bodySlots.size,
+      colliderCount: this.state.colliderSlots.size,
+      contactCount: this.contacts.contactCount,
+      eventCount: this.state.eventCount,
+      rootNode: this.broadPhase.rootNode,
+      pairCount: this.broadPhase.pairCount,
+      counters: Object.freeze({ ...this.counters }),
+      bodies: Object.freeze(bodies)
+    });
+  }
+  dispose() {
+    if (this.disposed) return;
+    if (this.liveCandidate !== void 0) this.discard(this.liveCandidate);
+    this.reconcileTopology(Object.freeze([]));
+    this.state.eventCount = 0;
+    this.pendingTopology = void 0;
+    this.pendingCommands = Object.freeze([]);
+    this.simulation?.dispose();
+    this.disposed = true;
+  }
+  simulateFixedTick(input) {
+    this.ensureBodyScratchCapacity();
+    this.capturePreviousPoses();
+    const dt = this.state.configuration.fixedStepMilliseconds / 1e3;
+    this.applyKinematicTargets(input.stagedKinematicTargets, dt);
+    this.rebuildIntegrationBodyIndices();
+    if (this.simulation) {
+      const previousFlags = this.bodies.flags.slice();
+      this.simulation.step(
+        this.bodies,
+        this.colliders,
+        dt,
+        this.state.configuration.gravityX,
+        this.state.configuration.gravityY,
+        this.state.configuration.sleeping,
+        this.state.configuration.velocityIterations,
+        this.state.configuration.positionIterations
+      );
+      injectFailure("broad-phase");
+      injectFailure("ccd");
+      this.moveBroadPhaseProxies();
+      this.broadPhase.publishPairs();
+      updateSortedContactCache2D(
+        this.contacts,
+        this.simulation.contactPairs(this.broadPhase, this.colliders),
+        this.colliders,
+        (first, second) => {
+          const sensor = (this.colliders.flags[first] | this.colliders.flags[second]) & 1;
+          const dynamic = (this.bodies.flags[this.colliders.bodyIndices[first]] | this.bodies.flags[this.colliders.bodyIndices[second]]) & BODY_TYPE_DYNAMIC_2D;
+          return sensor || !dynamic ? this.manifoldBetweenColliders(first, second) : this.simulation.manifold(first, second);
+        }
+      );
+      for (let contact = 0; contact < this.contacts.contactCount; contact++) {
+        const impulses = this.simulation.normalImpulses(
+          this.contacts.firstColliderIndices[contact],
+          this.contacts.secondColliderIndices[contact]
+        );
+        for (let point = 0; point < 2; point++)
+          this.contacts.pointNormalImpulses[contact * 2 + point] = impulses[point] ?? 0;
+      }
+      injectFailure("narrow-phase");
+      injectFailure("velocity-solve");
+      injectFailure("position-solve");
+      this.solver.advanceEligible = false;
+      for (let offset = 0; offset < this.state.bodyCount; offset++) {
+        const body = this.state.bodyIndices[offset];
+        if (!(this.bodies.flags[body] & BODY_TYPE_DYNAMIC_2D)) continue;
+        const sleeping = !!(this.bodies.flags[body] & BODY_SLEEPING_2D);
+        if (!sleeping) this.solver.advanceEligible = true;
+        if (sleeping !== !!(previousFlags[body] & BODY_SLEEPING_2D))
+          this.appendEvent(sleeping ? 6 : 5, body, NO_INDEX);
+      }
+      this.stageContactEvents();
+      injectFailure("event-staging");
+      this.state.tick++;
+      recordPhysicsWorld2DTrace({
+        kind: "physics-2d-tick",
+        frameId: input.frameId,
+        logicalTime: input.logicalTime,
+        tick: this.state.tick
+      });
+      return;
+    }
+    integrateCandidateVelocities2D(
+      this.bodies,
+      this.state.integrationBodyIndices,
+      this.state.integrationBodyCount,
+      this.state.configuration.gravityX,
+      this.state.configuration.gravityY,
+      dt
+    );
+    this.moveBroadPhaseProxies();
+    this.broadPhase.publishPairs();
+    updateSortedContactCache2D(
+      this.contacts,
+      this.broadPhase,
+      this.colliders,
+      (first, second) => this.manifoldBetweenColliders(first, second)
+    );
+    const restitutionThreshold = Math.max(
+      1,
+      2 * dt * Math.hypot(
+        this.state.configuration.gravityX,
+        this.state.configuration.gravityY
+      )
+    );
+    this.solver.solveCandidate(
+      this.bodies,
+      this.state.bodyIndices,
+      this.state.bodyCount,
+      this.contacts,
+      this.state.configuration.velocityIterations,
+      0,
+      true,
+      restitutionThreshold
+    );
+    this.stageContactEvents(false);
+    integrateCandidatePoses2D(
+      this.bodies,
+      this.state.integrationBodyIndices,
+      this.state.integrationBodyCount,
+      dt
+    );
+    this.moveBroadPhaseProxies();
+    injectFailure("broad-phase");
+    this.ccd.resolveCandidateBodies(
+      this.bodies,
+      this.colliders,
+      this.broadPhase,
+      this.state.integrationBodyIndices,
+      this.state.integrationBodyCount,
+      this.state.previousPositionX,
+      this.state.previousPositionY,
+      this.state.previousRotationRadians
+    );
+    this.moveBroadPhaseProxies();
+    injectFailure("ccd");
+    this.broadPhase.publishPairs();
+    updateSortedContactCache2D(
+      this.contacts,
+      this.broadPhase,
+      this.colliders,
+      (firstCollider, secondCollider) => this.manifoldBetweenColliders(firstCollider, secondCollider)
+    );
+    injectFailure("narrow-phase");
+    this.solver.solveCandidate(
+      this.bodies,
+      this.state.bodyIndices,
+      this.state.bodyCount,
+      this.contacts,
+      this.state.configuration.velocityIterations,
+      0,
+      false,
+      restitutionThreshold
+    );
+    injectFailure("velocity-solve");
+    this.solvePositions();
+    injectFailure("position-solve");
+    this.solver.updateSleepingCandidate(this.bodies, this.contacts, dt, {
+      enabled: this.state.configuration.sleeping,
+      recordTransition: (bodyIndex, sleeping) => {
+        this.appendEvent(sleeping ? 6 : 5, bodyIndex, NO_INDEX);
+      }
+    });
+    this.stageContactEvents();
+    injectFailure("event-staging");
+    this.state.tick += 1;
+    recordPhysicsWorld2DTrace({
+      kind: "physics-2d-tick",
+      frameId: input.frameId,
+      logicalTime: input.logicalTime,
+      tick: this.state.tick
+    });
+  }
+  reconcileTopology(records) {
+    const desiredBodies = /* @__PURE__ */ new Map();
+    const desiredColliders = /* @__PURE__ */ new Map();
+    for (const record of records) {
+      if (record.kind === "body") desiredBodies.set(record.id, record);
+      else desiredColliders.set(record.id, record);
+    }
+    for (const [id, slot] of sortedEntries(this.state.colliderSlots, true)) {
+      if (desiredColliders.has(id)) continue;
+      this.releaseCollider(slot);
+      this.state.colliderSlots.delete(id);
+      this.state.colliderRecords.delete(id);
+    }
+    for (const [id, slot] of sortedEntries(this.state.bodySlots, true)) {
+      if (desiredBodies.has(id)) continue;
+      this.bodies.release(slot.index, slot.generation);
+      this.state.bodySlots.delete(id);
+      this.state.bodyRecords.delete(id);
+      this.state.disabledBodies.delete(id);
+    }
+    for (const [id, record] of sortedEntries(desiredBodies)) {
+      const existing = this.state.bodySlots.get(id);
+      if (existing === void 0) {
+        const index = this.bodies.allocate(record.definition);
+        const slot = Object.freeze({
+          index,
+          generation: this.bodies.generations[index]
+        });
+        this.state.bodySlots.set(id, slot);
+        this.state.anchored = false;
+        this.state.accumulatorMilliseconds = 0;
+        this.ensureBodyScratchCapacity();
+        this.snapPreviousPose(index);
+        this.state.bodyRecords.set(id, record);
+      } else if (!sameBodyDefinition(
+        this.state.bodyRecords.get(id)?.definition,
+        record.definition
+      )) {
+        const disabledState = this.state.disabledBodies.get(id);
+        if (disabledState === void 0 && this.wakeBody(existing.index)) {
+          this.state.anchored = false;
+          this.state.accumulatorMilliseconds = 0;
+        }
+        const preserveDynamicPose = disabledState === void 0 && (this.bodies.flags[existing.index] & BODY_TYPE_DYNAMIC_2D) !== 0 && (record.definition.flags & BODY_TYPE_DYNAMIC_2D) !== 0;
+        const dynamicState = preserveDynamicPose ? {
+          pose: publicBodyOriginPose(this.bodies, existing.index),
+          linearVelocityX: this.bodies.linearVelocityX[existing.index],
+          linearVelocityY: this.bodies.linearVelocityY[existing.index],
+          angularVelocity: this.bodies.angularVelocity[existing.index],
+          forceX: this.bodies.forceX[existing.index],
+          forceY: this.bodies.forceY[existing.index],
+          torque: this.bodies.torque[existing.index]
+        } : null;
+        writeBodyDefinition(this.bodies, existing.index, record.definition);
+        if (dynamicState !== null) {
+          this.setBodyOriginPose(existing.index, dynamicState.pose);
+          this.bodies.linearVelocityX[existing.index] = dynamicState.linearVelocityX;
+          this.bodies.linearVelocityY[existing.index] = dynamicState.linearVelocityY;
+          this.bodies.angularVelocity[existing.index] = dynamicState.angularVelocity;
+          this.bodies.forceX[existing.index] = dynamicState.forceX;
+          this.bodies.forceY[existing.index] = dynamicState.forceY;
+          this.bodies.torque[existing.index] = dynamicState.torque;
+        }
+        if (disabledState !== void 0) {
+          this.state.disabledBodies.set(
+            id,
+            Object.freeze({
+              ...disabledState,
+              flags: record.definition.flags
+            })
+          );
+          this.bodies.flags[existing.index] = 0;
+          this.bodies.linearVelocityX[existing.index] = 0;
+          this.bodies.linearVelocityY[existing.index] = 0;
+          this.bodies.angularVelocity[existing.index] = 0;
+          this.bodies.forceX[existing.index] = 0;
+          this.bodies.forceY[existing.index] = 0;
+          this.bodies.torque[existing.index] = 0;
+        }
+        this.snapPreviousPose(existing.index);
+        this.state.bodyRecords.set(id, record);
+      }
+    }
+    for (const [id, record] of sortedEntries(desiredColliders)) {
+      const body = this.state.bodySlots.get(record.bodyId);
+      if (body === void 0) {
+        throw new Error(
+          `collider ${id} references missing body ${record.bodyId}.`
+        );
+      }
+      const existing = this.state.colliderSlots.get(id);
+      if (existing !== void 0 && sameColliderRecord(this.state.colliderRecords.get(id), record)) {
+        this.colliders.handlers[existing.index] = record.definition.handlers;
+        this.colliders.tags[existing.index] = record.definition.tag;
+        this.colliders.owners[existing.index] = record.definition.owner;
+        this.state.colliderRecords.set(id, record);
+        continue;
+      }
+      if (existing !== void 0) this.releaseCollider(existing);
+      this.state.colliderRecords.set(id, record);
+      if (this.state.disabledBodies.has(record.bodyId)) continue;
+      this.allocateColliderRecord(id, record, body);
+      if (this.wakeBody(body.index)) {
+        this.state.anchored = false;
+        this.state.accumulatorMilliseconds = 0;
+      }
+    }
+    this.rebuildBodyIndices();
+    this.moveBroadPhaseProxies();
+  }
+  applyCommands(commands) {
+    for (const command of commands) {
+      if (command.kind === "configure") {
+        const previousStep = this.state.configuration.fixedStepMilliseconds;
+        const sleepingWasEnabled = this.state.configuration.sleeping;
+        this.state.configuration = normalizePhysicsWorld2DConfiguration({
+          gravity: [
+            this.state.configuration.gravityX,
+            this.state.configuration.gravityY
+          ],
+          fixedStepMilliseconds: this.state.configuration.fixedStepMilliseconds,
+          maxCatchUpSteps: this.state.configuration.maxCatchUpSteps,
+          interpolation: this.state.configuration.interpolation,
+          sleeping: this.state.configuration.sleeping,
+          ...command.configuration,
+          solver: {
+            velocityIterations: this.state.configuration.velocityIterations,
+            positionIterations: this.state.configuration.positionIterations,
+            ...command.configuration.solver
+          }
+        });
+        if (this.state.configuration.fixedStepMilliseconds !== previousStep) {
+          this.state.accumulatorMilliseconds = 0;
+          this.state.anchored = false;
+        }
+        if (sleepingWasEnabled && !this.state.configuration.sleeping) {
+          for (let offset = 0; offset < this.state.bodyCount; offset += 1) {
+            this.wakeBody(this.state.bodyIndices[offset]);
+          }
+          this.state.accumulatorMilliseconds = 0;
+          this.state.anchored = false;
+        }
+        continue;
+      }
+      const slot = this.state.bodySlots.get(command.bodyId);
+      if (slot === void 0) continue;
+      switch (command.kind) {
+        case "apply-force":
+          if (command.wake !== false) this.wakeCommandBody(slot.index);
+          applyForceAtPointToCandidateBody2D(
+            this.bodies,
+            slot.index,
+            slot.generation,
+            command.forceX,
+            command.forceY,
+            command.pointX ?? this.bodies.positionX[slot.index],
+            command.pointY ?? this.bodies.positionY[slot.index]
+          );
+          break;
+        case "apply-torque":
+          this.wakeCommandBody(slot.index);
+          applyTorqueToCandidateBody2D(
+            this.bodies,
+            slot.index,
+            slot.generation,
+            command.torque
+          );
+          break;
+        case "apply-impulse":
+          if (command.wake !== false) this.wakeCommandBody(slot.index);
+          applyImpulseAtPointToCandidateBody2D(
+            this.bodies,
+            slot.index,
+            slot.generation,
+            command.impulseX,
+            command.impulseY,
+            command.pointX ?? this.bodies.positionX[slot.index],
+            command.pointY ?? this.bodies.positionY[slot.index]
+          );
+          break;
+        case "set-pose":
+          this.wakeCommandBody(slot.index);
+          this.setBodyOriginPose(slot.index, command.pose);
+          this.snapPreviousPose(slot.index);
+          this.moveBroadPhaseProxies();
+          break;
+        case "set-velocity":
+          this.wakeCommandBody(slot.index);
+          this.bodies.linearVelocityX[slot.index] = command.linearVelocityX;
+          this.bodies.linearVelocityY[slot.index] = command.linearVelocityY;
+          this.bodies.angularVelocity[slot.index] = command.angularVelocityDegrees / RADIANS_TO_DEGREES;
+          break;
+        case "set-linear-velocity":
+          this.wakeCommandBody(slot.index);
+          this.bodies.linearVelocityX[slot.index] = command.linearVelocityX;
+          this.bodies.linearVelocityY[slot.index] = command.linearVelocityY;
+          break;
+        case "set-angular-velocity":
+          this.wakeCommandBody(slot.index);
+          this.bodies.angularVelocity[slot.index] = command.angularVelocityDegrees / RADIANS_TO_DEGREES;
+          break;
+        case "wake":
+          this.wakeCommandBody(slot.index);
+          break;
+        case "sleep":
+          this.sleepCommandBody(slot.index);
+          break;
+        case "disable":
+          this.disableCommandBody(command.bodyId, slot);
+          break;
+        case "enable":
+          this.enableCommandBody(command.bodyId, slot, command.velocity);
+          break;
+      }
+    }
+  }
+  wakeCommandBody(bodyIndex) {
+    if (this.wakeBody(bodyIndex)) {
+      this.state.anchored = false;
+      this.state.accumulatorMilliseconds = 0;
+    }
+  }
+  sleepCommandBody(bodyIndex) {
+    if ((this.bodies.flags[bodyIndex] & BODY_SLEEPING_2D) !== 0) return;
+    this.bodies.flags[bodyIndex] |= BODY_SLEEPING_2D;
+    this.bodies.linearVelocityX[bodyIndex] = 0;
+    this.bodies.linearVelocityY[bodyIndex] = 0;
+    this.bodies.angularVelocity[bodyIndex] = 0;
+    this.bodies.forceX[bodyIndex] = 0;
+    this.bodies.forceY[bodyIndex] = 0;
+    this.bodies.torque[bodyIndex] = 0;
+    this.appendEvent(6, bodyIndex, NO_INDEX);
+  }
+  disableCommandBody(bodyId, slot) {
+    if (this.state.disabledBodies.has(bodyId)) return;
+    this.state.disabledBodies.set(
+      bodyId,
+      Object.freeze({
+        flags: this.bodies.flags[slot.index],
+        linearVelocityX: this.bodies.linearVelocityX[slot.index],
+        linearVelocityY: this.bodies.linearVelocityY[slot.index],
+        angularVelocity: this.bodies.angularVelocity[slot.index]
+      })
+    );
+    for (const [colliderId, record] of this.state.colliderRecords) {
+      if (record.bodyId !== bodyId) continue;
+      const collider = this.state.colliderSlots.get(colliderId);
+      if (collider !== void 0) this.releaseCollider(collider);
+      this.state.colliderSlots.delete(colliderId);
+    }
+    this.bodies.flags[slot.index] = 0;
+    this.bodies.linearVelocityX[slot.index] = 0;
+    this.bodies.linearVelocityY[slot.index] = 0;
+    this.bodies.angularVelocity[slot.index] = 0;
+    this.bodies.forceX[slot.index] = 0;
+    this.bodies.forceY[slot.index] = 0;
+    this.bodies.torque[slot.index] = 0;
+    this.broadPhase.publishPairs();
+    updateSortedContactCache2D(
+      this.contacts,
+      this.broadPhase,
+      this.colliders,
+      (first, second) => this.manifoldBetweenColliders(first, second)
+    );
+    this.stageContactEvents();
+  }
+  enableCommandBody(bodyId, slot, velocity) {
+    const disabled = this.state.disabledBodies.get(bodyId);
+    if (disabled === void 0) return;
+    const authored = this.state.bodyRecords.get(bodyId)?.definition;
+    if (authored === void 0) return;
+    const disabledPose = publicBodyOriginPose(this.bodies, slot.index);
+    this.state.disabledBodies.delete(bodyId);
+    writeBodyDefinition(this.bodies, slot.index, authored);
+    this.setBodyOriginPose(slot.index, disabledPose);
+    this.bodies.flags[slot.index] = disabled.flags & ~BODY_SLEEPING_2D;
+    this.bodies.linearVelocityX[slot.index] = velocity === "preserve" ? disabled.linearVelocityX : 0;
+    this.bodies.linearVelocityY[slot.index] = velocity === "preserve" ? disabled.linearVelocityY : 0;
+    this.bodies.angularVelocity[slot.index] = velocity === "preserve" ? disabled.angularVelocity : 0;
+    this.snapPreviousPose(slot.index);
+    for (const [colliderId, record] of sortedEntries(
+      this.state.colliderRecords
+    )) {
+      if (record.bodyId !== bodyId || this.state.colliderSlots.has(colliderId))
+        continue;
+      this.allocateColliderRecord(colliderId, record, slot);
+    }
+    this.state.anchored = false;
+    this.state.accumulatorMilliseconds = 0;
+  }
+  allocateColliderRecord(id, record, body) {
+    const index = this.colliders.allocate({
+      ...record.definition,
+      bodyIndex: body.index,
+      bodyGeneration: body.generation
+    });
+    const generation = this.colliders.generations[index];
+    const pose = internalPose(this.bodies, body.index);
+    const bounds = colliderBounds(
+      record.definition.shape,
+      pose.x,
+      pose.y,
+      pose.rotationRadians
+    );
+    const proxy = this.broadPhase.createProxy(
+      index,
+      generation,
+      bounds[0],
+      bounds[1],
+      bounds[2],
+      bounds[3]
+    );
+    this.colliders.setProxy(
+      index,
+      generation,
+      proxy,
+      this.broadPhase.proxyGenerations[proxy]
+    );
+    this.state.colliderSlots.set(id, Object.freeze({ index, generation }));
+  }
+  manifoldBetweenColliders(first, second) {
+    if (!collisionFiltersAllow2D(
+      this.colliders.filters[first],
+      this.colliders.filters[second]
+    )) {
+      return null;
+    }
+    const firstShape = this.colliders.shapes[first];
+    const secondShape = this.colliders.shapes[second];
+    if (firstShape === null || secondShape === null) return null;
+    const firstBody = this.colliders.bodyIndices[first];
+    const secondBody = this.colliders.bodyIndices[second];
+    return manifoldBetweenShapeRecords2D(
+      firstShape,
+      internalPose(this.bodies, firstBody),
+      first,
+      secondShape,
+      internalPose(this.bodies, secondBody),
+      second
+    );
+  }
+  moveBroadPhaseProxies() {
+    for (const [, slot] of sortedEntries(this.state.colliderSlots)) {
+      const body = this.colliders.bodyIndices[slot.index];
+      const shape = this.colliders.shapes[slot.index];
+      if (shape === null) continue;
+      const pose = internalPose(this.bodies, body);
+      const bounds = colliderBounds(
+        shape,
+        pose.x,
+        pose.y,
+        pose.rotationRadians
+      );
+      this.broadPhase.moveProxy(
+        this.colliders.proxyIndices[slot.index],
+        this.colliders.proxyGenerations[slot.index],
+        bounds[0],
+        bounds[1],
+        bounds[2],
+        bounds[3],
+        this.bodies.positionX[body] - this.state.previousPositionX[body],
+        this.bodies.positionY[body] - this.state.previousPositionY[body]
+      );
+    }
+  }
+  applyKinematicTargets(targets, dt) {
+    for (const [bodyId, pose] of targets) {
+      const slot = this.state.bodySlots.get(bodyId);
+      if (slot === void 0) continue;
+      const index = slot.index;
+      if ((this.bodies.flags[index] & BODY_TYPE_KINEMATIC_2D) === 0) continue;
+      const targetRadians = pose.rotationDegrees / RADIANS_TO_DEGREES;
+      const targetCenter = centerFromOrigin(
+        this.bodies,
+        index,
+        pose.position[0],
+        pose.position[1],
+        targetRadians
+      );
+      this.bodies.linearVelocityX[index] = (targetCenter[0] - this.bodies.positionX[index]) / dt;
+      this.bodies.linearVelocityY[index] = (targetCenter[1] - this.bodies.positionY[index]) / dt;
+      this.bodies.angularVelocity[index] = shortestRadians(this.bodies.rotationRadians[index], targetRadians) / dt;
+      if (this.wakeBody(index)) {
+        this.state.anchored = false;
+        this.state.accumulatorMilliseconds = 0;
+      }
+    }
+  }
+  stageContactEvents(includeHits = true) {
+    for (let event = 0; event < this.contacts.eventCount; event += 1) {
+      const first = this.contacts.eventFirstColliderIndices[event];
+      const firstGeneration = this.contacts.eventFirstColliderGenerations[event];
+      const second = this.contacts.eventSecondColliderIndices[event];
+      const secondGeneration = this.contacts.eventSecondColliderGenerations[event];
+      const kind = this.contacts.eventTypes[event];
+      const contact = this.findContact(
+        first,
+        firstGeneration,
+        second,
+        secondGeneration
+      );
+      const key = contactKey(first, firstGeneration, second, secondGeneration);
+      this.appendEvent(
+        kind,
+        first,
+        second,
+        firstGeneration,
+        secondGeneration,
+        kind === 2 || kind === 4 ? this.state.contactEventFacts.get(key) : contact < 0 ? void 0 : this.contactEventFact(contact)
+      );
+    }
+    for (let contact = 0; contact < this.contacts.contactCount; contact += 1) {
+      if (!includeHits || this.contacts.sensorFlags[contact] !== 0) continue;
+      const first = this.contacts.firstColliderIndices[contact];
+      const second = this.contacts.secondColliderIndices[contact];
+      if (!hasColliderHandler(this.colliders.handlers[first], "onHit") && !hasColliderHandler(this.colliders.handlers[second], "onHit")) {
+        continue;
+      }
+      const fact = this.contactEventFact(contact);
+      if (fact.totalNormalImpulse <= 0) continue;
+      this.appendEvent(
+        7,
+        first,
+        second,
+        this.contacts.firstColliderGenerations[contact],
+        this.contacts.secondColliderGenerations[contact],
+        fact
+      );
+    }
+    this.state.contactEventFacts.clear();
+    for (let contact = 0; contact < this.contacts.contactCount; contact += 1) {
+      this.state.contactEventFacts.set(
+        contactKey(
+          this.contacts.firstColliderIndices[contact],
+          this.contacts.firstColliderGenerations[contact],
+          this.contacts.secondColliderIndices[contact],
+          this.contacts.secondColliderGenerations[contact]
+        ),
+        this.contactEventFact(contact)
+      );
+    }
+  }
+  findContact(first, firstGeneration, second, secondGeneration) {
+    for (let contact = 0; contact < this.contacts.contactCount; contact += 1) {
+      if (this.contacts.firstColliderIndices[contact] === first && this.contacts.firstColliderGenerations[contact] === firstGeneration && this.contacts.secondColliderIndices[contact] === second && this.contacts.secondColliderGenerations[contact] === secondGeneration) {
+        return contact;
+      }
+    }
+    return -1;
+  }
+  contactEventFact(contact) {
+    const base = contact * 2;
+    const pointCount = this.contacts.pointCounts[contact];
+    return Object.freeze({
+      normalX: this.contacts.normalX[contact],
+      normalY: this.contacts.normalY[contact],
+      pointCount,
+      pointFirstX: Object.freeze([
+        this.contacts.pointFirstX[base],
+        this.contacts.pointFirstX[base + 1]
+      ]),
+      pointFirstY: Object.freeze([
+        this.contacts.pointFirstY[base],
+        this.contacts.pointFirstY[base + 1]
+      ]),
+      pointSecondX: Object.freeze([
+        this.contacts.pointSecondX[base],
+        this.contacts.pointSecondX[base + 1]
+      ]),
+      pointSecondY: Object.freeze([
+        this.contacts.pointSecondY[base],
+        this.contacts.pointSecondY[base + 1]
+      ]),
+      pointSeparations: Object.freeze([
+        this.contacts.pointSeparations[base],
+        this.contacts.pointSeparations[base + 1]
+      ]),
+      totalNormalImpulse: this.contacts.pointNormalImpulses[base] + this.contacts.pointNormalImpulses[base + 1]
+    });
+  }
+  solvePositions() {
+    const pointCount = this.contacts.contactCount * 2;
+    this.ensureSavedImpulseCapacity(pointCount);
+    this.state.savedNormalImpulses.set(
+      this.contacts.pointNormalImpulses.subarray(0, pointCount),
+      0
+    );
+    this.state.savedTangentImpulses.set(
+      this.contacts.pointTangentImpulses.subarray(0, pointCount),
+      0
+    );
+    this.contacts.pointNormalImpulses.fill(0, 0, pointCount);
+    this.contacts.pointTangentImpulses.fill(0, 0, pointCount);
+    this.positionSolver.solveCandidate(
+      this.bodies,
+      this.state.bodyIndices,
+      this.state.bodyCount,
+      this.contacts,
+      0,
+      this.state.configuration.positionIterations
+    );
+    this.contacts.pointNormalImpulses.set(
+      this.state.savedNormalImpulses.subarray(0, pointCount),
+      0
+    );
+    this.contacts.pointTangentImpulses.set(
+      this.state.savedTangentImpulses.subarray(0, pointCount),
+      0
+    );
+    this.solver.positionIterationsPerformed = this.positionSolver.positionIterationsPerformed;
+  }
+  ensureSavedImpulseCapacity(required) {
+    if (required <= this.state.savedNormalImpulses.length) return;
+    let capacity = this.state.savedNormalImpulses.length * 2;
+    while (capacity < required) capacity *= 2;
+    this.state.savedNormalImpulses = growFloat64(
+      this.state.savedNormalImpulses,
+      capacity
+    );
+    this.state.savedTangentImpulses = growFloat64(
+      this.state.savedTangentImpulses,
+      capacity
+    );
+  }
+  appendEvent(kind, first, second, firstGeneration = 0, secondGeneration = 0, fact) {
+    this.ensureEventCapacity(this.state.eventCount + 1);
+    const event = this.state.eventCount;
+    this.state.eventTicks[event] = this.state.tick + 1;
+    this.state.eventKinds[event] = kind;
+    this.state.eventFirstColliderIndices[event] = first;
+    this.state.eventFirstColliderGenerations[event] = firstGeneration;
+    this.state.eventSecondColliderIndices[event] = second;
+    this.state.eventSecondColliderGenerations[event] = secondGeneration;
+    this.state.eventNormalX[event] = fact?.normalX ?? 0;
+    this.state.eventNormalY[event] = fact?.normalY ?? 0;
+    this.state.eventPointCounts[event] = fact?.pointCount ?? 0;
+    this.state.eventTotalNormalImpulses[event] = fact?.totalNormalImpulse ?? 0;
+    const pointBase = event * 2;
+    for (let point = 0; point < 2; point += 1) {
+      this.state.eventPointFirstX[pointBase + point] = fact?.pointFirstX[point] ?? 0;
+      this.state.eventPointFirstY[pointBase + point] = fact?.pointFirstY[point] ?? 0;
+      this.state.eventPointSecondX[pointBase + point] = fact?.pointSecondX[point] ?? 0;
+      this.state.eventPointSecondY[pointBase + point] = fact?.pointSecondY[point] ?? 0;
+      this.state.eventPointSeparations[pointBase + point] = fact?.pointSeparations[point] ?? 0;
+    }
+    this.state.eventCount += 1;
+  }
+  ensureEventCapacity(required) {
+    if (required <= this.state.eventKinds.length) return;
+    let capacity = this.state.eventKinds.length * 2;
+    while (capacity < required) capacity *= 2;
+    this.state.eventTicks = growFloat64(this.state.eventTicks, capacity);
+    this.state.eventKinds = growUint8(this.state.eventKinds, capacity);
+    this.state.eventFirstColliderIndices = growInt32(
+      this.state.eventFirstColliderIndices,
+      capacity
+    );
+    this.state.eventFirstColliderGenerations = growUint32(
+      this.state.eventFirstColliderGenerations,
+      capacity
+    );
+    this.state.eventSecondColliderIndices = growInt32(
+      this.state.eventSecondColliderIndices,
+      capacity
+    );
+    this.state.eventSecondColliderGenerations = growUint32(
+      this.state.eventSecondColliderGenerations,
+      capacity
+    );
+    this.state.eventNormalX = growFloat64(this.state.eventNormalX, capacity);
+    this.state.eventNormalY = growFloat64(this.state.eventNormalY, capacity);
+    this.state.eventPointCounts = growUint8(
+      this.state.eventPointCounts,
+      capacity
+    );
+    this.state.eventPointFirstX = growFloat64(
+      this.state.eventPointFirstX,
+      capacity * 2
+    );
+    this.state.eventPointFirstY = growFloat64(
+      this.state.eventPointFirstY,
+      capacity * 2
+    );
+    this.state.eventPointSecondX = growFloat64(
+      this.state.eventPointSecondX,
+      capacity * 2
+    );
+    this.state.eventPointSecondY = growFloat64(
+      this.state.eventPointSecondY,
+      capacity * 2
+    );
+    this.state.eventPointSeparations = growFloat64(
+      this.state.eventPointSeparations,
+      capacity * 2
+    );
+    this.state.eventTotalNormalImpulses = growFloat64(
+      this.state.eventTotalNormalImpulses,
+      capacity
+    );
+  }
+  capturePreviousPoses() {
+    for (let offset = 0; offset < this.state.bodyCount; offset += 1) {
+      this.snapPreviousPose(this.state.bodyIndices[offset]);
+    }
+  }
+  snapPreviousPose(index) {
+    this.state.previousPositionX[index] = this.bodies.positionX[index];
+    this.state.previousPositionY[index] = this.bodies.positionY[index];
+    this.state.previousRotationRadians[index] = this.bodies.rotationRadians[index];
+  }
+  setBodyOriginPose(index, pose) {
+    const rotationRadians = pose.rotationDegrees / RADIANS_TO_DEGREES;
+    const center = centerFromOrigin(
+      this.bodies,
+      index,
+      pose.position[0],
+      pose.position[1],
+      rotationRadians
+    );
+    this.bodies.positionX[index] = center[0];
+    this.bodies.positionY[index] = center[1];
+    this.bodies.rotationRadians[index] = rotationRadians;
+  }
+  rebuildBodyIndices() {
+    this.ensureBodyScratchCapacity();
+    const indices = [...this.state.bodySlots.values()].map((slot) => slot.index).sort((first, second) => first - second);
+    this.state.bodyCount = indices.length;
+    for (let offset = 0; offset < indices.length; offset += 1) {
+      this.state.bodyIndices[offset] = indices[offset];
+    }
+  }
+  rebuildIntegrationBodyIndices() {
+    let count = 0;
+    for (let offset = 0; offset < this.state.bodyCount; offset += 1) {
+      const body = this.state.bodyIndices[offset];
+      if ((this.bodies.flags[body] & BODY_SLEEPING_2D) !== 0) continue;
+      this.state.integrationBodyIndices[count] = body;
+      count += 1;
+    }
+    this.state.integrationBodyCount = count;
+  }
+  ensureBodyScratchCapacity() {
+    if (this.bodies.capacity <= this.state.previousPositionX.length) return;
+    const capacity = this.bodies.capacity;
+    this.state.previousPositionX = growFloat64(
+      this.state.previousPositionX,
+      capacity
+    );
+    this.state.previousPositionY = growFloat64(
+      this.state.previousPositionY,
+      capacity
+    );
+    this.state.previousRotationRadians = growFloat64(
+      this.state.previousRotationRadians,
+      capacity
+    );
+    this.state.bodyIndices = growInt32(this.state.bodyIndices, capacity);
+    this.state.integrationBodyIndices = growInt32(
+      this.state.integrationBodyIndices,
+      capacity
+    );
+  }
+  wakeBody(bodyIndex) {
+    const wasSleeping = (this.bodies.flags[bodyIndex] & BODY_SLEEPING_2D) !== 0;
+    let targetWakeRecorded = false;
+    const islandChanged = this.solver.wakeIslandContainingCandidate(
+      this.bodies,
+      bodyIndex,
+      (body, sleeping) => {
+        if (body === bodyIndex && !sleeping) targetWakeRecorded = true;
+        this.appendEvent(sleeping ? 6 : 5, body, NO_INDEX);
+      }
+    );
+    this.bodies.flags[bodyIndex] &= ~BODY_SLEEPING_2D;
+    this.bodies.sleepTime[bodyIndex] = 0;
+    if (wasSleeping && !targetWakeRecorded) {
+      this.appendEvent(5, bodyIndex, NO_INDEX);
+    }
+    return wasSleeping || islandChanged;
+  }
+  releaseCollider(slot) {
+    const proxy = this.colliders.proxyIndices[slot.index];
+    const proxyGeneration = this.colliders.proxyGenerations[slot.index];
+    if (proxy !== NO_INDEX)
+      this.broadPhase.destroyProxy(proxy, proxyGeneration);
+    this.colliders.release(slot.index, slot.generation);
+  }
+  captureCheckpoint() {
+    return {
+      rapier: this.simulation?.checkpoint(),
+      snapshots: [
+        captureObject(this.state),
+        captureObject(this.counters),
+        captureObject(this.bodies),
+        captureObject(this.colliders),
+        captureObject(this.broadPhase),
+        captureObject(this.contacts),
+        captureObject(this.solver),
+        captureObject(this.positionSolver),
+        captureObject(this.ccd)
+      ]
+    };
+  }
+  restoreCheckpoint(checkpoint) {
+    if (checkpoint.rapier) this.simulation.restore(checkpoint.rapier);
+    for (let index = checkpoint.snapshots.length - 1; index >= 0; index -= 1) {
+      restoreObject(checkpoint.snapshots[index]);
+    }
+  }
+  requireBody(bodyId) {
+    const slot = this.state.bodySlots.get(bodyId);
+    if (slot === void 0) throw new Error(`unknown physics body ${bodyId}.`);
+    return slot;
+  }
+  hasAdvanceWork() {
+    if (this.pendingTopology !== void 0 || this.pendingCommands.length > 0) {
+      return true;
+    }
+    for (let offset = 0; offset < this.state.bodyCount; offset += 1) {
+      const body = this.state.bodyIndices[offset];
+      if ((this.bodies.flags[body] & BODY_TYPE_KINEMATIC_2D) !== 0)
+        return true;
+      if ((this.bodies.flags[body] & BODY_SLEEPING_2D) === 0) return true;
+    }
+    return false;
+  }
+  hasKinematicBodies() {
+    for (let offset = 0; offset < this.state.bodyCount; offset += 1) {
+      const body = this.state.bodyIndices[offset];
+      if ((this.bodies.flags[body] & BODY_TYPE_KINEMATIC_2D) !== 0)
+        return true;
+    }
+    return false;
+  }
+  assertCandidate(candidate) {
+    this.assertUsable();
+    if (candidate.owner !== this || candidate !== this.liveCandidate || candidate.lifecycle !== "live") {
+      throw new Error("candidate is not the live candidate for this world.");
+    }
+  }
+  assertUsable() {
+    if (this.disposed) throw new Error("physics world is disposed.");
+  }
+}
+function normalizePhysicsWorld2DConfiguration(configuration) {
+  const gravity = configuration.gravity ?? DEFAULT_GRAVITY;
+  if (gravity.length !== 2 || !Number.isFinite(gravity[0]) || !Number.isFinite(gravity[1])) {
+    throw new RangeError("gravity must contain two finite numbers.");
+  }
+  const fixedStepMilliseconds = configuration.fixedStepMilliseconds ?? DEFAULT_FIXED_STEP_MILLISECONDS;
+  if (!Number.isFinite(fixedStepMilliseconds) || fixedStepMilliseconds <= 0) {
+    throw new RangeError("fixedStepMilliseconds must be finite and positive.");
+  }
+  const maxCatchUpSteps = configuration.maxCatchUpSteps ?? DEFAULT_MAX_CATCH_UP_STEPS;
+  validateIntegerRange(
+    maxCatchUpSteps,
+    MIN_CATCH_UP_STEPS,
+    MAX_CATCH_UP_STEPS,
+    "maxCatchUpSteps"
+  );
+  const interpolation = configuration.interpolation ?? DEFAULT_INTERPOLATION;
+  if (interpolation !== "linear" && interpolation !== "none") {
+    throw new RangeError('interpolation must be "linear" or "none".');
+  }
+  const velocityIterations = configuration.solver?.velocityIterations ?? configuration.velocityIterations ?? DEFAULT_VELOCITY_ITERATIONS;
+  const positionIterations = configuration.solver?.positionIterations ?? configuration.positionIterations ?? DEFAULT_POSITION_ITERATIONS;
+  validateIntegerRange(
+    velocityIterations,
+    MIN_SOLVER_ITERATIONS,
+    MAX_SOLVER_ITERATIONS,
+    "velocityIterations"
+  );
+  validateIntegerRange(
+    positionIterations,
+    MIN_SOLVER_ITERATIONS,
+    MAX_SOLVER_ITERATIONS,
+    "positionIterations"
+  );
+  return Object.freeze({
+    gravityX: gravity[0],
+    gravityY: gravity[1],
+    fixedStepMilliseconds,
+    maxCatchUpSteps,
+    interpolation,
+    sleeping: configuration.sleeping ?? DEFAULT_SLEEPING,
+    velocityIterations,
+    positionIterations
+  });
+}
+function captureObject(target) {
+  const record = target;
+  const values = Reflect.ownKeys(record).map((key) => {
+    const value = record[key];
+    if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
+      return {
+        key,
+        kind: "typed-array",
+        reference: value,
+        contents: value.slice()
+      };
+    }
+    if (Array.isArray(value)) {
+      return { key, kind: "array", reference: value, contents: [...value] };
+    }
+    if (value instanceof Map) {
+      return {
+        key,
+        kind: "map",
+        reference: value,
+        contents: [...value.entries()]
+      };
+    }
+    return { key, kind: "value", reference: value };
+  });
+  return { target: record, values };
+}
+function restoreObject(snapshot) {
+  for (let index = snapshot.values.length - 1; index >= 0; index -= 1) {
+    const value = snapshot.values[index];
+    switch (value.kind) {
+      case "typed-array": {
+        snapshot.target[value.key] = value.reference;
+        const target = value.reference;
+        target.set(value.contents);
+        break;
+      }
+      case "array": {
+        snapshot.target[value.key] = value.reference;
+        const target = value.reference;
+        target.length = 0;
+        target.push(...value.contents);
+        break;
+      }
+      case "map": {
+        snapshot.target[value.key] = value.reference;
+        const target = value.reference;
+        target.clear();
+        for (const [key, entry] of value.contents) {
+          target.set(key, entry);
+        }
+        break;
+      }
+      case "value":
+        snapshot.target[value.key] = value.reference;
+        break;
+    }
+  }
+}
+function validateTopology(records) {
+  const bodies = /* @__PURE__ */ new Set();
+  const colliders = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    validateId(record.id, `${record.kind} id`);
+    const ids = record.kind === "body" ? bodies : colliders;
+    if (ids.has(record.id)) {
+      throw new Error(`duplicate ${record.kind} id ${record.id}.`);
+    }
+    ids.add(record.id);
+    if (record.kind === "body") validateBodyDefinition(record.definition);
+    else validateId(record.bodyId, "collider bodyId");
+  }
+  for (const record of records) {
+    if (record.kind === "collider" && !bodies.has(record.bodyId)) {
+      throw new Error(
+        `collider ${record.id} references missing body ${record.bodyId}.`
+      );
+    }
+  }
+}
+function hasColliderHandler(handlers, name) {
+  return typeof handlers === "object" && handlers !== null && typeof handlers[name] === "function";
+}
+function validateBodyDefinition(definition) {
+  for (const [name, value] of Object.entries(definition)) {
+    if (name === "owner" || name === "flags") continue;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      throw new RangeError(`body ${name} must be finite.`);
+    }
+  }
+  if (!Number.isSafeInteger(definition.flags) || definition.flags < 0) {
+    throw new RangeError("body flags must be a nonnegative safe integer.");
+  }
+}
+function validateCommand(command) {
+  if (command.kind === "configure") {
+    normalizePhysicsWorld2DConfiguration(command.configuration);
+    return;
+  }
+  validateId(command.bodyId, "command bodyId");
+  if (command.kind === "set-pose") {
+    validatePose(command.pose, "command pose");
+    return;
+  }
+  if (command.kind === "enable") {
+    if (command.velocity !== "zero" && command.velocity !== "preserve") {
+      throw new RangeError('command velocity must be "zero" or "preserve".');
+    }
+    return;
+  }
+  for (const [name, value] of Object.entries(command)) {
+    if (name === "kind" || name === "bodyId" || name === "wake") continue;
+    if ((name === "pointX" || name === "pointY") && value === void 0)
+      continue;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      throw new RangeError(`command ${name} must be finite.`);
+    }
+  }
+}
+function injectFailure(stage) {
+  failureInjector?.(stage);
+}
+function validatePose(pose, path) {
+  if (pose.position.length !== 2 || !Number.isFinite(pose.position[0]) || !Number.isFinite(pose.position[1]) || !Number.isFinite(pose.rotationDegrees)) {
+    throw new RangeError(`${path} must contain finite position and rotation.`);
+  }
+}
+function validateId(value, path) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new RangeError(`${path} must be a nonnegative safe integer.`);
+  }
+}
+function validateIntegerRange(value, minimum, maximum, path) {
+  if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+    throw new RangeError(
+      `${path} must be an integer from ${minimum} through ${maximum}.`
+    );
+  }
+}
+function writeBodyDefinition(bodies, index, definition) {
+  bodies.positionX[index] = definition.positionX;
+  bodies.positionY[index] = definition.positionY;
+  bodies.rotationRadians[index] = definition.rotationRadians;
+  bodies.localCenterX[index] = definition.localCenterX ?? 0;
+  bodies.localCenterY[index] = definition.localCenterY ?? 0;
+  bodies.linearVelocityX[index] = definition.linearVelocityX;
+  bodies.linearVelocityY[index] = definition.linearVelocityY;
+  bodies.angularVelocity[index] = definition.angularVelocity;
+  bodies.forceX[index] = definition.forceX;
+  bodies.forceY[index] = definition.forceY;
+  bodies.torque[index] = definition.torque;
+  bodies.inverseMass[index] = definition.inverseMass;
+  bodies.inverseInertia[index] = definition.inverseInertia;
+  bodies.linearDamping[index] = definition.linearDamping;
+  bodies.angularDamping[index] = definition.angularDamping;
+  bodies.gravityScale[index] = definition.gravityScale;
+  bodies.sleepTime[index] = definition.sleepTime;
+  bodies.flags[index] = definition.flags;
+  bodies.owners[index] = definition.owner;
+}
+function sameBodyDefinition(first, second) {
+  return first !== void 0 && first.positionX === second.positionX && first.positionY === second.positionY && first.rotationRadians === second.rotationRadians && (first.localCenterX ?? 0) === (second.localCenterX ?? 0) && (first.localCenterY ?? 0) === (second.localCenterY ?? 0) && first.linearVelocityX === second.linearVelocityX && first.linearVelocityY === second.linearVelocityY && first.angularVelocity === second.angularVelocity && first.forceX === second.forceX && first.forceY === second.forceY && first.torque === second.torque && first.inverseMass === second.inverseMass && first.inverseInertia === second.inverseInertia && first.linearDamping === second.linearDamping && first.angularDamping === second.angularDamping && first.gravityScale === second.gravityScale && first.sleepTime === second.sleepTime && first.flags === second.flags && first.owner === second.owner;
+}
+function sameColliderRecord(first, second) {
+  return first !== void 0 && first.bodyId === second.bodyId && first.definition.shape === second.definition.shape && first.definition.flags === second.definition.flags && shallowRecordEqual(first.definition.material, second.definition.material) && shallowRecordEqual(first.definition.filter, second.definition.filter);
+}
+function shallowRecordEqual(first, second) {
+  if (first === second) return true;
+  if (typeof first !== "object" || first === null || typeof second !== "object" || second === null) {
+    return false;
+  }
+  const firstEntries = Object.entries(first);
+  const secondRecord = second;
+  if (firstEntries.length !== Object.keys(secondRecord).length) return false;
+  return firstEntries.every(([key, value]) => secondRecord[key] === value);
+}
+function colliderBounds(shape, x, y, rotation) {
+  const bounds = shape.localBounds;
+  const cosine = Math.cos(rotation);
+  const sine = Math.sin(rotation);
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (let corner = 0; corner < 4; corner += 1) {
+    const localX = corner % 2 === 0 ? bounds[0] : bounds[2];
+    const localY = corner < 2 ? bounds[1] : bounds[3];
+    const worldX = x + cosine * localX - sine * localY;
+    const worldY = y + sine * localX + cosine * localY;
+    minX = Math.min(minX, worldX);
+    minY = Math.min(minY, worldY);
+    maxX = Math.max(maxX, worldX);
+    maxY = Math.max(maxY, worldY);
+  }
+  return [minX, minY, maxX, maxY];
+}
+function internalPose(bodies, index) {
+  const rotationRadians = bodies.rotationRadians[index];
+  const cosine = Math.cos(rotationRadians);
+  const sine = Math.sin(rotationRadians);
+  const localCenterX = bodies.localCenterX[index];
+  const localCenterY = bodies.localCenterY[index];
+  return {
+    x: bodies.positionX[index] - cosine * localCenterX + sine * localCenterY,
+    y: bodies.positionY[index] - sine * localCenterX - cosine * localCenterY,
+    rotationRadians
+  };
+}
+function centerFromOrigin(bodies, index, originX, originY, rotationRadians) {
+  const cosine = Math.cos(rotationRadians);
+  const sine = Math.sin(rotationRadians);
+  const localCenterX = bodies.localCenterX[index];
+  const localCenterY = bodies.localCenterY[index];
+  return [
+    originX + cosine * localCenterX - sine * localCenterY,
+    originY + sine * localCenterX + cosine * localCenterY
+  ];
+}
+function publicBodyOriginPose(bodies, index) {
+  const pose = internalPose(bodies, index);
+  return publicPose(pose.x, pose.y, pose.rotationRadians);
+}
+function publicPoseFromCenter(bodies, index, centerX, centerY, rotationRadians) {
+  const cosine = Math.cos(rotationRadians);
+  const sine = Math.sin(rotationRadians);
+  const localCenterX = bodies.localCenterX[index];
+  const localCenterY = bodies.localCenterY[index];
+  return publicPose(
+    centerX - cosine * localCenterX + sine * localCenterY,
+    centerY - sine * localCenterX - cosine * localCenterY,
+    rotationRadians
+  );
+}
+function publicPose(x, y, rotationRadians) {
+  return Object.freeze({
+    position: Object.freeze([x, y]),
+    rotationDegrees: rotationRadians * RADIANS_TO_DEGREES
+  });
+}
+function shortestRadians(from, to) {
+  const full = Math.PI * 2;
+  let delta = ((to - from + Math.PI) % full + full) % full - Math.PI;
+  if (delta === -Math.PI) delta = Math.PI;
+  return delta;
+}
+function lerp(from, to, amount) {
+  return from + (to - from) * amount;
+}
+function sortedEntries(map, descending = false) {
+  return [...map.entries()].sort(
+    ([first], [second]) => descending ? second - first : first - second
+  );
+}
+function contactKey(first, firstGeneration, second, secondGeneration) {
+  return `${String(first)}:${String(firstGeneration)}:${String(second)}:${String(secondGeneration)}`;
+}
+function growFloat64(source, capacity) {
+  const result = new Float64Array(capacity);
+  result.set(source);
+  return result;
+}
+function growInt32(source, capacity) {
+  const result = new Int32Array(capacity);
+  result.set(source);
+  return result;
+}
+function growUint8(source, capacity) {
+  const result = new Uint8Array(capacity);
+  result.set(source);
+  return result;
+}
+function growUint32(source, capacity) {
+  const result = new Uint32Array(capacity);
+  result.set(source);
+  return result;
+}
+export {
+  PhysicsWorld2DCandidate,
+  PhysicsWorld2DKernel,
+  installPhysicsWorld2DFailureInjectorForTest,
+  normalizePhysicsWorld2DConfiguration
+};
+//# sourceMappingURL=world.js.map