@series-inc/rundot-syncplay 5.23.0-beta.7

package/dist/cjs/physics2d.js

@@ -0,0 +1,751 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeterministicPhysicsWorld2D = createDeterministicPhysicsWorld2D;
+exports.stepDeterministicPhysicsWorld2D = stepDeterministicPhysicsWorld2D;
+exports.queryDeterministicPhysicsAabb2D = queryDeterministicPhysicsAabb2D;
+exports.raycastDeterministicPhysics2D = raycastDeterministicPhysics2D;
+exports.raycastAllDeterministicPhysics2D = raycastAllDeterministicPhysics2D;
+exports.nearestDeterministicPhysicsHit2D = nearestDeterministicPhysicsHit2D;
+exports.queryDeterministicPhysicsShapeOverlap2D = queryDeterministicPhysicsShapeOverlap2D;
+exports.circleCastDeterministicPhysics2D = circleCastDeterministicPhysics2D;
+const canonical_js_1 = require("./canonical.js");
+const deterministic_primitives_js_1 = require("./deterministic-primitives.js");
+const defaultPhysicsMaterial = {
+    friction: 0,
+    restitution: 0,
+};
+const rayDistanceEpsilon = 0.000001;
+function createDeterministicPhysicsWorld2D(bodies) {
+    return {
+        frame: 0,
+        bodies: normalizeBodies(bodies),
+        activePairs: [],
+        activePairMetadata: [],
+    };
+}
+function stepDeterministicPhysicsWorld2D(world, options = {}) {
+    const gravityX = options.gravityX ?? 0;
+    const gravityY = options.gravityY ?? 0;
+    let bodies = world.bodies.map((body) => integrateBody(body, gravityX, gravityY));
+    const iterations = options.iterations ?? 2;
+    for (let iteration = 0; iteration < iterations; iteration += 1) {
+        bodies = solveConstraints(bodies, options.constraints ?? []);
+    }
+    const contacts = detectContacts(bodies);
+    for (let iteration = 0; iteration < iterations; iteration += 1) {
+        bodies = solveContacts(bodies);
+    }
+    const activePairs = contacts.map((contact) => contact.pair).sort(compareStrings);
+    const activePairMetadata = contacts.map((contact) => ({
+        pair: contact.pair,
+        a: contact.a,
+        b: contact.b,
+        sensor: contact.sensor,
+        trigger: contact.trigger,
+        material: contact.material,
+    })).sort(compareActivePairMetadata);
+    const previousPairMetadata = new Map((world.activePairMetadata ?? []).map((pair) => [pair.pair, pair]));
+    const previousPairs = new Set(world.activePairs);
+    const currentPairs = new Set(activePairs);
+    const events = [
+        ...contacts.map((contact) => ({
+            ...contact,
+            type: previousPairs.has(contact.pair) ? 'stay' : 'enter',
+        })),
+        ...world.activePairs
+            .filter((pair) => !currentPairs.has(pair))
+            .sort(compareStrings)
+            .map((pair) => {
+            const previous = previousPairMetadata.get(pair);
+            const [a, b] = pair.split('|');
+            return {
+                type: 'exit',
+                pair,
+                a: previous?.a ?? a,
+                b: previous?.b ?? b,
+                sensor: previous?.sensor ?? false,
+                trigger: previous?.trigger ?? false,
+                material: previous?.material ?? defaultPhysicsMaterial,
+            };
+        }),
+    ].sort(compareEvents);
+    const nextWorld = {
+        frame: world.frame + 1,
+        bodies: normalizeBodies(bodies),
+        activePairs,
+        activePairMetadata,
+    };
+    return {
+        world: (0, canonical_js_1.cloneCanonical)(nextWorld),
+        events,
+        broadphasePairs: countCandidatePairs(nextWorld.bodies),
+        narrowphaseContacts: contacts.length,
+        solverIterations: iterations,
+        checksum: (0, canonical_js_1.defaultChecksum)(nextWorld),
+    };
+}
+function queryDeterministicPhysicsAabb2D(world, query) {
+    return world.bodies
+        .filter((body) => queryBodyAllowed(body, query))
+        .filter((body) => bodyOverlapsBounds(body, query.x, query.y, query.halfWidth, query.halfHeight))
+        .map((body) => body.id)
+        .sort(compareStrings);
+}
+function raycastDeterministicPhysics2D(world, query) {
+    const normalizedQuery = normalizeRaycastQuery2D(query);
+    return world.bodies
+        .filter((body) => queryBodyAllowed(body, normalizedQuery))
+        .map((body) => {
+        const distance = rayBodyDistance(body, normalizedQuery);
+        return distance === undefined ? undefined : { bodyId: body.id, distance };
+    })
+        .filter((hit) => hit !== undefined)
+        .sort((left, right) => left.distance - right.distance || compareStrings(left.bodyId, right.bodyId));
+}
+function raycastAllDeterministicPhysics2D(world, query) {
+    return raycastDeterministicPhysics2D(world, query);
+}
+function nearestDeterministicPhysicsHit2D(world, query) {
+    return raycastDeterministicPhysics2D(world, query)[0];
+}
+function queryDeterministicPhysicsShapeOverlap2D(world, query) {
+    return world.bodies
+        .filter((body) => queryBodyAllowed(body, query))
+        .filter((body) => bodyOverlapsShape(body, query))
+        .map((body) => body.id)
+        .sort(compareStrings);
+}
+function circleCastDeterministicPhysics2D(world, query) {
+    const normalizedQuery = normalizeCircleCastQuery2D(query);
+    return world.bodies
+        .filter((body) => queryBodyAllowed(body, normalizedQuery))
+        .map((body) => {
+        const distance = circleCastBodyDistance(body, normalizedQuery);
+        return distance === undefined ? undefined : { bodyId: body.id, distance };
+    })
+        .filter((hit) => hit !== undefined)
+        .sort((left, right) => left.distance - right.distance || compareStrings(left.bodyId, right.bodyId));
+}
+function normalizeRaycastQuery2D(query) {
+    const length = deterministicSqrt(query.dx * query.dx + query.dy * query.dy);
+    if (length === 0) {
+        return query;
+    }
+    return {
+        ...query,
+        dx: quantizeDistance(query.dx / length),
+        dy: quantizeDistance(query.dy / length),
+    };
+}
+function normalizeCircleCastQuery2D(query) {
+    const length = deterministicSqrt(query.dx * query.dx + query.dy * query.dy);
+    if (length === 0) {
+        return query;
+    }
+    return {
+        ...query,
+        dx: quantizeDistance(query.dx / length),
+        dy: quantizeDistance(query.dy / length),
+    };
+}
+function integrateBody(body, gravityX, gravityY) {
+    assertInteger(body.x, `${body.id}.x`);
+    assertInteger(body.y, `${body.id}.y`);
+    if (body.kind === 'static') {
+        return body;
+    }
+    const damping = body.damping ?? 0;
+    assertInteger(damping, `${body.id}.damping`);
+    const vx = Math.trunc(((body.vx + gravityX) * (1_000 - damping)) / 1_000);
+    const vy = Math.trunc(((body.vy + gravityY) * (1_000 - damping)) / 1_000);
+    return {
+        ...body,
+        x: body.x + vx,
+        y: body.y + vy,
+        vx,
+        vy,
+    };
+}
+function solveConstraints(bodies, constraints) {
+    let result = bodies;
+    for (const constraint of [...constraints].sort((left, right) => compareStrings(left.id, right.id))) {
+        result = applyConstraint(result, constraint);
+    }
+    return result;
+}
+function applyConstraint(bodies, constraint) {
+    const map = new Map(bodies.map((body) => [body.id, body]));
+    const a = map.get(constraint.a);
+    const b = constraint.b === undefined ? undefined : map.get(constraint.b);
+    if (a === undefined) {
+        return bodies;
+    }
+    if (constraint.type === 'motor') {
+        map.set(a.id, {
+            ...a,
+            vx: constraint.motorVx ?? a.vx,
+            vy: constraint.motorVy ?? a.vy,
+        });
+        return [...map.values()].sort(compareBodies);
+    }
+    if (b === undefined || b.kind === 'static') {
+        return bodies;
+    }
+    if (constraint.type === 'fixed') {
+        map.set(b.id, {
+            ...b,
+            x: a.x + (constraint.offsetX ?? 0),
+            y: a.y + (constraint.offsetY ?? 0),
+            vx: a.vx,
+            vy: a.vy,
+        });
+        return [...map.values()].sort(compareBodies);
+    }
+    if (constraint.type === 'distance') {
+        const restLength = constraint.restLength ?? 0;
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        const length = deterministicSqrt(dx * dx + dy * dy);
+        if (length > restLength && length > 0) {
+            const scale = restLength / length;
+            // Positions are integers (integrateBody asserts it every step) — trunc
+            // like the spring branch below, or any pair not exactly restLength apart
+            // writes a fractional coordinate and halts the sim next frame.
+            map.set(b.id, {
+                ...b,
+                x: Math.trunc(a.x + dx * scale),
+                y: Math.trunc(a.y + dy * scale),
+                vx: 0,
+                vy: 0,
+            });
+        }
+        return [...map.values()].sort(compareBodies);
+    }
+    const stiffness = constraint.stiffness ?? 500;
+    const restLength = constraint.restLength ?? 0;
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const length = deterministicSqrt(dx * dx + dy * dy);
+    const scale = length === 0 ? 0 : restLength / length;
+    const targetX = a.x + dx * scale;
+    const targetY = a.y + dy * scale;
+    map.set(b.id, {
+        ...b,
+        x: quantizeDistance(b.x + Math.trunc(((targetX - b.x) * stiffness) / 1_000)),
+        y: quantizeDistance(b.y + Math.trunc(((targetY - b.y) * stiffness) / 1_000)),
+    });
+    return [...map.values()].sort(compareBodies);
+}
+function solveContacts(bodies) {
+    const map = new Map(bodies.map((body) => [body.id, body]));
+    for (const contact of detectContacts(bodies)) {
+        const a = map.get(contact.a);
+        const b = map.get(contact.b);
+        if (a === undefined || b === undefined || contact.sensor || contact.trigger) {
+            continue;
+        }
+        if (a.kind === 'dynamic' && b.kind === 'static') {
+            map.set(a.id, separateFromStatic(a, b));
+        }
+        else if (b.kind === 'dynamic' && a.kind === 'static') {
+            map.set(b.id, separateFromStatic(b, a));
+        }
+        else if (a.kind === 'dynamic' && b.kind === 'dynamic') {
+            const separated = separateDynamicPair(a, b);
+            map.set(a.id, separated.a);
+            map.set(b.id, separated.b);
+        }
+    }
+    return [...map.values()].sort(compareBodies);
+}
+function separateDynamicPair(a, b) {
+    const left = bodyBounds(a);
+    const right = bodyBounds(b);
+    const overlapX = Math.min(left.maxX, right.maxX) - Math.max(left.minX, right.minX);
+    const overlapY = Math.min(left.maxY, right.maxY) - Math.max(left.minY, right.minY);
+    if (overlapX <= 0 || overlapY <= 0) {
+        return { a, b };
+    }
+    const material = (0, deterministic_primitives_js_1.combineDeterministicPhysicsMaterial)(a.material ?? defaultPhysicsMaterial, b.material ?? defaultPhysicsMaterial);
+    if (overlapX <= overlapY) {
+        const direction = a.x <= b.x ? -1 : 1;
+        const correctionA = Math.ceil(overlapX / 2);
+        const correctionB = Math.ceil(overlapX / 2);
+        return {
+            a: { ...a, x: a.x + direction * correctionA, vx: normalizeZero(Math.trunc((-a.vx * material.restitution) / 10)) },
+            b: { ...b, x: b.x - direction * correctionB, vx: normalizeZero(Math.trunc((-b.vx * material.restitution) / 10)) },
+        };
+    }
+    const direction = a.y <= b.y ? -1 : 1;
+    const correctionA = Math.ceil(overlapY / 2);
+    const correctionB = Math.ceil(overlapY / 2);
+    return {
+        a: { ...a, y: a.y + direction * correctionA, vy: normalizeZero(Math.trunc((-a.vy * material.restitution) / 10)) },
+        b: { ...b, y: b.y - direction * correctionB, vy: normalizeZero(Math.trunc((-b.vy * material.restitution) / 10)) },
+    };
+}
+function separateFromStatic(dynamicBody, staticBody) {
+    const dynamicBounds = bodyBounds(dynamicBody);
+    const staticBounds = bodyBounds(staticBody);
+    const overlapX = Math.min(dynamicBounds.maxX, staticBounds.maxX) - Math.max(dynamicBounds.minX, staticBounds.minX);
+    const overlapY = Math.min(dynamicBounds.maxY, staticBounds.maxY) - Math.max(dynamicBounds.minY, staticBounds.minY);
+    if (overlapX <= 0 || overlapY <= 0) {
+        return dynamicBody;
+    }
+    const material = (0, deterministic_primitives_js_1.combineDeterministicPhysicsMaterial)(dynamicBody.material ?? defaultPhysicsMaterial, staticBody.material ?? defaultPhysicsMaterial);
+    if (overlapX <= overlapY) {
+        const direction = dynamicBody.x < staticBody.x ? -1 : 1;
+        return {
+            ...dynamicBody,
+            x: dynamicBody.x + direction * overlapX,
+            vx: normalizeZero(Math.trunc((-dynamicBody.vx * material.restitution) / 10)),
+        };
+    }
+    const direction = dynamicBody.y < staticBody.y ? -1 : 1;
+    return {
+        ...dynamicBody,
+        y: dynamicBody.y + direction * overlapY,
+        vy: normalizeZero(Math.trunc((-dynamicBody.vy * material.restitution) / 10)),
+    };
+}
+function detectContacts(bodies) {
+    const contacts = [];
+    const sorted = [...bodies].sort(compareBodies);
+    for (let leftIndex = 0; leftIndex < sorted.length; leftIndex += 1) {
+        for (let rightIndex = leftIndex + 1; rightIndex < sorted.length; rightIndex += 1) {
+            const left = sorted[leftIndex];
+            const right = sorted[rightIndex];
+            if (!canCollide(left, right) || !bodiesOverlap(left, right)) {
+                continue;
+            }
+            contacts.push({
+                pair: `${left.id}|${right.id}`,
+                a: left.id,
+                b: right.id,
+                sensor: left.sensor === true || right.sensor === true,
+                trigger: left.trigger === true || right.trigger === true,
+                material: (0, deterministic_primitives_js_1.combineDeterministicPhysicsMaterial)(left.material ?? defaultPhysicsMaterial, right.material ?? defaultPhysicsMaterial),
+            });
+        }
+    }
+    return contacts.sort((left, right) => compareStrings(left.pair, right.pair));
+}
+function countCandidatePairs(bodies) {
+    return (bodies.length * (bodies.length - 1)) / 2;
+}
+function canCollide(left, right) {
+    return (left.mask & right.layer) !== 0 && (right.mask & left.layer) !== 0;
+}
+function queryBodyAllowed(body, query) {
+    if (query.layerMask !== undefined && (body.layer & query.layerMask) === 0) {
+        return false;
+    }
+    if (!queryKindAllowsBody2D(body, query)) {
+        return false;
+    }
+    const hitSensors = query.hitSensors ?? query.includeSensors ?? false;
+    const hitTriggers = query.hitTriggers ?? query.includeTriggers ?? false;
+    const hitSolids = query.hitSolids ?? true;
+    if (body.sensor === true && hitSensors !== true) {
+        return false;
+    }
+    if (body.trigger === true && hitTriggers !== true) {
+        return false;
+    }
+    return body.sensor === true || body.trigger === true || hitSolids;
+}
+function queryKindAllowsBody2D(body, query) {
+    const kindFilterSpecified = query.hitStatics !== undefined || query.hitDynamics !== undefined || query.hitKinematics !== undefined;
+    if (!kindFilterSpecified) {
+        return true;
+    }
+    if (body.kind === 'static') {
+        return query.hitStatics === true;
+    }
+    if (body.kind === 'dynamic') {
+        return query.hitDynamics === true;
+    }
+    return query.hitKinematics === true;
+}
+function bodyOverlapsShape(body, query) {
+    if ((query.z !== undefined || query.halfDepth !== undefined)
+        && !heightOverlaps(body.z ?? 0, body.halfDepth ?? 0, query.z ?? 0, query.halfDepth ?? 0)) {
+        return false;
+    }
+    if (query.shape === 'circle') {
+        return circleOverlapsBody(query.x, query.y, query.radius ?? 0, body);
+    }
+    return bodyOverlapsBounds(body, query.x, query.y, query.halfWidth ?? 0, query.halfHeight ?? 0);
+}
+function heightOverlaps(centerA, halfA, centerB, halfB) {
+    return Math.abs(centerA - centerB) <= halfA + halfB;
+}
+function circleOverlapsAabb(circleX, circleY, radius, aabbX, aabbY, halfWidth, halfHeight) {
+    const closestX = Math.max(aabbX - halfWidth, Math.min(circleX, aabbX + halfWidth));
+    const closestY = Math.max(aabbY - halfHeight, Math.min(circleY, aabbY + halfHeight));
+    const dx = circleX - closestX;
+    const dy = circleY - closestY;
+    return dx * dx + dy * dy <= radius * radius;
+}
+function bodyBounds(body) {
+    const shape = body.shape ?? { type: 'aabb' };
+    if (shape.type === 'circle') {
+        return { minX: body.x - shape.radius, maxX: body.x + shape.radius, minY: body.y - shape.radius, maxY: body.y + shape.radius };
+    }
+    if (shape.type === 'capsule') {
+        return { minX: body.x - shape.radius, maxX: body.x + shape.radius, minY: body.y - shape.halfHeight - shape.radius, maxY: body.y + shape.halfHeight + shape.radius };
+    }
+    if (shape.type === 'convex') {
+        const xs = shape.vertices.map((vertex) => body.x + vertex.x);
+        const ys = shape.vertices.map((vertex) => body.y + vertex.y);
+        return { minX: Math.min(...xs), maxX: Math.max(...xs), minY: Math.min(...ys), maxY: Math.max(...ys) };
+    }
+    return { minX: body.x - body.halfWidth, maxX: body.x + body.halfWidth, minY: body.y - body.halfHeight, maxY: body.y + body.halfHeight };
+}
+function bodyOverlapsBounds(body, x, y, halfWidth, halfHeight) {
+    return bodiesOverlap(body, {
+        id: '__query',
+        kind: 'static',
+        x,
+        y,
+        z: body.z,
+        vx: 0,
+        vy: 0,
+        halfWidth,
+        halfHeight,
+        halfDepth: body.halfDepth,
+        layer: body.mask,
+        mask: body.layer,
+    });
+}
+function bodiesOverlap(left, right) {
+    const leftShape = left.shape ?? { type: 'aabb' };
+    const rightShape = right.shape ?? { type: 'aabb' };
+    if (hasHeightExtent(left) || hasHeightExtent(right)) {
+        const leftHalfDepth = left.halfDepth ?? 0;
+        const rightHalfDepth = right.halfDepth ?? 0;
+        if (!heightOverlaps(left.z ?? 0, leftHalfDepth, right.z ?? 0, rightHalfDepth)) {
+            return false;
+        }
+    }
+    if (!boundsOverlap(bodyBounds(left), bodyBounds(right))) {
+        return false;
+    }
+    if (leftShape.type === 'circle' && rightShape.type === 'circle') {
+        return square(left.x - right.x) + square(left.y - right.y) <= square(leftShape.radius + rightShape.radius);
+    }
+    if (leftShape.type === 'circle') {
+        return circleOverlapsBody(left.x, left.y, leftShape.radius, right);
+    }
+    if (rightShape.type === 'circle') {
+        return circleOverlapsBody(right.x, right.y, rightShape.radius, left);
+    }
+    if (leftShape.type === 'capsule') {
+        return capsuleOverlapsBody(left, leftShape, right);
+    }
+    if (rightShape.type === 'capsule') {
+        return capsuleOverlapsBody(right, rightShape, left);
+    }
+    if (leftShape.type === 'convex' || rightShape.type === 'convex') {
+        return convexBodiesOverlap(left, right);
+    }
+    return true;
+}
+function hasHeightExtent(body) {
+    return body.z !== undefined || body.halfDepth !== undefined;
+}
+function boundsOverlap(left, right) {
+    return left.minX < right.maxX && left.maxX > right.minX && left.minY < right.maxY && left.maxY > right.minY;
+}
+function circleOverlapsBody(x, y, radius, body) {
+    const shape = body.shape ?? { type: 'aabb' };
+    if (shape.type === 'circle') {
+        return square(x - body.x) + square(y - body.y) <= square(radius + shape.radius);
+    }
+    if (shape.type === 'capsule') {
+        const closestY = clamp(y, body.y - shape.halfHeight, body.y + shape.halfHeight);
+        return square(x - body.x) + square(y - closestY) <= square(radius + shape.radius);
+    }
+    if (shape.type === 'convex') {
+        return polygonCircleOverlap(shape.vertices.map((vertex) => ({ x: body.x + vertex.x, y: body.y + vertex.y })), x, y, radius);
+    }
+    return circleOverlapsAabb(x, y, radius, body.x, body.y, body.halfWidth, body.halfHeight);
+}
+function capsuleOverlapsBody(capsule, shape, body) {
+    return circleOverlapsBody(capsule.x, capsule.y - shape.halfHeight, shape.radius, body)
+        || circleOverlapsBody(capsule.x, capsule.y + shape.halfHeight, shape.radius, body)
+        || bodyOverlapsBounds(body, capsule.x, capsule.y, shape.radius, shape.halfHeight);
+}
+function convexBodiesOverlap(left, right) {
+    const leftShape = left.shape ?? { type: 'aabb' };
+    const rightShape = right.shape ?? { type: 'aabb' };
+    const leftPolygon = shapePolygon(left, leftShape);
+    const rightPolygon = shapePolygon(right, rightShape);
+    return polygonsOverlap(leftPolygon, rightPolygon);
+}
+function shapePolygon(body, shape) {
+    if (shape.type === 'convex') {
+        return shape.vertices.map((vertex) => ({ x: body.x + vertex.x, y: body.y + vertex.y }));
+    }
+    const bounds = bodyBounds(body);
+    return [
+        { x: bounds.minX, y: bounds.minY },
+        { x: bounds.maxX, y: bounds.minY },
+        { x: bounds.maxX, y: bounds.maxY },
+        { x: bounds.minX, y: bounds.maxY },
+    ];
+}
+function polygonsOverlap(left, right) {
+    return left.some((point) => pointInPolygon(point, right))
+        || right.some((point) => pointInPolygon(point, left))
+        || polygonEdges(left).some((leftEdge) => polygonEdges(right).some((rightEdge) => segmentsIntersect(leftEdge.a, leftEdge.b, rightEdge.a, rightEdge.b)));
+}
+function polygonCircleOverlap(polygon, x, y, radius) {
+    return pointInPolygon({ x, y }, polygon)
+        || polygon.some((point) => square(point.x - x) + square(point.y - y) <= square(radius))
+        || polygonEdges(polygon).some((edge) => distancePointToSegmentSquared(x, y, edge.a, edge.b) <= square(radius));
+}
+function polygonEdges(polygon) {
+    return polygon.map((point, index) => ({ a: point, b: polygon[(index + 1) % polygon.length] }));
+}
+function pointInPolygon(point, polygon) {
+    let inside = false;
+    for (let index = 0, previous = polygon.length - 1; index < polygon.length; previous = index, index += 1) {
+        const currentPoint = polygon[index];
+        const previousPoint = polygon[previous];
+        if (((currentPoint.y > point.y) !== (previousPoint.y > point.y))
+            && point.x < ((previousPoint.x - currentPoint.x) * (point.y - currentPoint.y)) / (previousPoint.y - currentPoint.y) + currentPoint.x) {
+            inside = !inside;
+        }
+    }
+    return inside;
+}
+function segmentsIntersect(a, b, c, d) {
+    const abC = orientation(a, b, c);
+    const abD = orientation(a, b, d);
+    const cdA = orientation(c, d, a);
+    const cdB = orientation(c, d, b);
+    return abC * abD <= 0 && cdA * cdB <= 0;
+}
+function orientation(a, b, c) {
+    return Math.sign((b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x));
+}
+function distancePointToSegmentSquared(x, y, a, b) {
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const lengthSquared = dx * dx + dy * dy;
+    if (lengthSquared === 0) {
+        return square(x - a.x) + square(y - a.y);
+    }
+    const t = clamp(((x - a.x) * dx + (y - a.y) * dy) / lengthSquared, 0, 1);
+    return square(x - (a.x + t * dx)) + square(y - (a.y + t * dy));
+}
+function rayBodyDistance(body, query) {
+    const shape = body.shape ?? { type: 'aabb' };
+    if (shape.type === 'circle') {
+        return rayCircleDistance2D(query.x, query.y, query.dx, query.dy, body.x, body.y, shape.radius, query.maxDistance);
+    }
+    if (shape.type === 'capsule') {
+        return [
+            rayCircleDistance2D(query.x, query.y, query.dx, query.dy, body.x, body.y - shape.halfHeight, shape.radius, query.maxDistance),
+            rayCircleDistance2D(query.x, query.y, query.dx, query.dy, body.x, body.y + shape.halfHeight, shape.radius, query.maxDistance),
+            rayAabbDistanceExact2D({ minX: body.x - shape.radius, maxX: body.x + shape.radius, minY: body.y - shape.halfHeight, maxY: body.y + shape.halfHeight }, query.x, query.y, query.dx, query.dy, query.maxDistance),
+        ].filter((distance) => distance !== undefined).sort((left, right) => left - right)[0];
+    }
+    if (shape.type === 'convex') {
+        const distances = polygonEdges(shape.vertices.map((vertex) => ({ x: body.x + vertex.x, y: body.y + vertex.y })))
+            .map((edge) => raySegmentDistance(query, edge.a, edge.b))
+            .filter((distance) => distance !== undefined)
+            .sort((left, right) => left - right);
+        return distances[0];
+    }
+    const distance = rayAabbDistanceExact2D({
+        minX: body.x - body.halfWidth,
+        maxX: body.x + body.halfWidth,
+        minY: body.y - body.halfHeight,
+        maxY: body.y + body.halfHeight,
+    }, query.x, query.y, query.dx, query.dy, query.maxDistance);
+    return distance === undefined ? undefined : quantizeDistance(distance);
+}
+function raySegmentDistance(query, a, b) {
+    const vx = b.x - a.x;
+    const vy = b.y - a.y;
+    const denominator = query.dx * vy - query.dy * vx;
+    if (denominator === 0) {
+        return undefined;
+    }
+    const ax = a.x - query.x;
+    const ay = a.y - query.y;
+    const distance = (ax * vy - ay * vx) / denominator;
+    const segmentT = (ax * query.dy - ay * query.dx) / denominator;
+    return distance >= 0 && distance <= query.maxDistance && segmentT >= 0 && segmentT <= 1 ? quantizeDistance(distance) : undefined;
+}
+function circleCastBodyDistance(body, query) {
+    if (bodyOverlapsShape(body, {
+        shape: 'circle',
+        x: query.x,
+        y: query.y,
+        radius: query.radius,
+    })) {
+        return 0;
+    }
+    const bounds = bodyBounds(body);
+    return sweptCircleAabbDistance(query.x, query.y, query.dx, query.dy, query.radius, bounds.minX, bounds.maxX, bounds.minY, bounds.maxY, query.maxDistance);
+}
+function sweptCircleAabbDistance(x, y, dx, dy, radius, minX, maxX, minY, maxY, maxDistance) {
+    const candidates = [];
+    addVerticalSideCandidate(candidates, x, y, dx, dy, minX - radius, minY, maxY, maxDistance);
+    addVerticalSideCandidate(candidates, x, y, dx, dy, maxX + radius, minY, maxY, maxDistance);
+    addHorizontalSideCandidate(candidates, x, y, dx, dy, minY - radius, minX, maxX, maxDistance);
+    addHorizontalSideCandidate(candidates, x, y, dx, dy, maxY + radius, minX, maxX, maxDistance);
+    for (const cornerX of [minX, maxX]) {
+        for (const cornerY of [minY, maxY]) {
+            const distance = rayCircleDistance2D(x, y, dx, dy, cornerX, cornerY, radius, maxDistance);
+            if (distance !== undefined) {
+                candidates.push(distance);
+            }
+        }
+    }
+    return candidates.sort((left, right) => left - right)[0];
+}
+function addVerticalSideCandidate(candidates, x, y, dx, dy, sideX, minY, maxY, maxDistance) {
+    if (dx === 0) {
+        return;
+    }
+    const distance = (sideX - x) / dx;
+    const hitY = y + dy * distance;
+    if (distance >= 0 && distance <= maxDistance && hitY >= minY && hitY <= maxY) {
+        candidates.push(quantizeDistance(distance));
+    }
+}
+function addHorizontalSideCandidate(candidates, x, y, dx, dy, sideY, minX, maxX, maxDistance) {
+    if (dy === 0) {
+        return;
+    }
+    const distance = (sideY - y) / dy;
+    const hitX = x + dx * distance;
+    if (distance >= 0 && distance <= maxDistance && hitX >= minX && hitX <= maxX) {
+        candidates.push(quantizeDistance(distance));
+    }
+}
+function rayCircleDistance2D(x, y, dx, dy, circleX, circleY, radius, maxDistance) {
+    const ox = x - circleX;
+    const oy = y - circleY;
+    const a = dx * dx + dy * dy;
+    if (a === 0 || !Number.isFinite(maxDistance) || maxDistance < 0) {
+        return undefined;
+    }
+    const b = 2 * (ox * dx + oy * dy);
+    const c = ox * ox + oy * oy - radius * radius;
+    if (c <= 0) {
+        return 0;
+    }
+    const discriminant = b * b - 4 * a * c;
+    if (discriminant < 0) {
+        return undefined;
+    }
+    const root = deterministicSqrt(discriminant);
+    const near = (-b - root) / (2 * a);
+    const far = (-b + root) / (2 * a);
+    let distance;
+    if (near >= 0) {
+        distance = near;
+    }
+    else if (near >= -rayDistanceEpsilon && far >= 0) {
+        distance = 0;
+    }
+    return distance === undefined || distance > maxDistance ? undefined : quantizeDistance(distance);
+}
+function rayAabbDistanceExact2D(bounds, x, y, dx, dy, maxDistance) {
+    if (!Number.isFinite(maxDistance) || maxDistance < 0) {
+        return undefined;
+    }
+    let tMin = 0;
+    let tMax = maxDistance;
+    const axes = [
+        { origin: x, direction: dx, min: bounds.minX, max: bounds.maxX },
+        { origin: y, direction: dy, min: bounds.minY, max: bounds.maxY },
+    ];
+    for (const axis of axes) {
+        if (axis.direction === 0) {
+            if (axis.origin < axis.min || axis.origin > axis.max) {
+                return undefined;
+            }
+            continue;
+        }
+        const inv = 1 / axis.direction;
+        const near = (axis.min - axis.origin) * inv;
+        const far = (axis.max - axis.origin) * inv;
+        tMin = Math.max(tMin, Math.min(near, far));
+        tMax = Math.min(tMax, Math.max(near, far));
+        if (tMin > tMax) {
+            return undefined;
+        }
+    }
+    return Math.max(0, tMin);
+}
+function quantizeDistance(distance) {
+    // Pure integer rounding, NOT Number.prototype.toFixed: toFixed's half-way
+    // rounding has diverged across JS engines historically, and this repo ships
+    // both Hermes (native) and V8 (web) — a cross-engine desync vector on the
+    // checksummed state path. normalizeZero keeps -0 out of state.
+    return normalizeZero(Math.round(distance * 1e6) / 1e6);
+}
+function normalizeZero(value) {
+    return value === 0 ? 0 : value;
+}
+function square(value) {
+    return value * value;
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function deterministicSqrt(value) {
+    if (value <= 0) {
+        return 0;
+    }
+    // Seed the Newton iteration from the argument's magnitude (2^ceil(bits/2)):
+    // starting from `value` itself needs ~0.5*log2(value) halving steps before
+    // the quadratic regime, so 8 iterations only converged for tiny inputs —
+    // at realistic fixed-point magnitudes (dx^2+dy^2 ~ 1e10) the old seed
+    // returned results off by orders of magnitude. Every operation here is
+    // exact integer/IEEE-deterministic arithmetic, so all peers still agree.
+    let estimate = 1;
+    let magnitude = value;
+    while (magnitude >= 4) {
+        magnitude /= 4;
+        estimate *= 2;
+    }
+    if (magnitude > 1) {
+        estimate *= 2;
+    }
+    for (let iteration = 0; iteration < 8; iteration += 1) {
+        estimate = (estimate + value / estimate) / 2;
+    }
+    return quantizeDistance(estimate);
+}
+function normalizeBodies(bodies) {
+    const sorted = [...bodies].sort(compareBodies);
+    const duplicate = sorted.find((body, index) => index > 0 && body.id === sorted[index - 1].id);
+    if (duplicate !== undefined) {
+        throw new Error(`Duplicate deterministic physics body id ${duplicate.id}`);
+    }
+    return (0, canonical_js_1.cloneCanonical)(sorted);
+}
+function compareBodies(left, right) {
+    return compareStrings(left.id, right.id);
+}
+function compareEvents(left, right) {
+    return compareStrings(left.pair, right.pair);
+}
+function compareActivePairMetadata(left, right) {
+    return compareStrings(left.pair, right.pair);
+}
+function compareStrings(left, right) {
+    return Number(left > right) - Number(left < right);
+}
+function assertInteger(value, name) {
+    if (!Number.isInteger(value)) {
+        throw new Error(`${name} must be an integer`);
+    }
+}