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

package/dist/cjs/navmesh.js

@@ -0,0 +1,1437 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cookDeterministicNavmesh = cookDeterministicNavmesh;
+exports.cookImportedDeterministicNavmesh = cookImportedDeterministicNavmesh;
+exports.findDeterministicNavmeshPath = findDeterministicNavmeshPath;
+exports.findDeterministicNavmeshPointPath = findDeterministicNavmeshPointPath;
+exports.locateDeterministicNavmeshPolygon = locateDeterministicNavmeshPolygon;
+exports.smoothDeterministicNavmeshPath = smoothDeterministicNavmeshPath;
+exports.stepDeterministicNavmeshAgents = stepDeterministicNavmeshAgents;
+exports.stepDeterministicNavmeshOffMeshTraversal = stepDeterministicNavmeshOffMeshTraversal;
+exports.runDeterministicNavmeshStress = runDeterministicNavmeshStress;
+exports.runDeterministicNavmeshVelocityObstacleFixture = runDeterministicNavmeshVelocityObstacleFixture;
+exports.runDeterministicNavmeshImportTraversalFixture = runDeterministicNavmeshImportTraversalFixture;
+exports.runDeterministicNavmeshLayered3DFixture = runDeterministicNavmeshLayered3DFixture;
+const canonical_js_1 = require("./canonical.js");
+function cookDeterministicNavmesh(source) {
+    const polygons = [...source.polygons].map(normalizePolygon).sort(comparePolygons);
+    const polygonIds = new Set();
+    for (const polygon of polygons) {
+        if (polygonIds.has(polygon.id)) {
+            throw new Error(`Duplicate navmesh polygon ${polygon.id}`);
+        }
+        validatePolygonShape(polygon);
+        polygonIds.add(polygon.id);
+    }
+    const links = [...source.links.flatMap(expandLink)].sort(compareLinks);
+    const linkIds = new Set();
+    for (const link of links) {
+        if (!polygonIds.has(link.from) || !polygonIds.has(link.to)) {
+            throw new Error(`Navmesh link ${link.from}->${link.to} references a missing polygon`);
+        }
+        const linkId = `${link.from}->${link.to}`;
+        if (linkIds.has(linkId)) {
+            throw new Error(`Duplicate navmesh link ${linkId}`);
+        }
+        linkIds.add(linkId);
+    }
+    const regions = [...(source.regions ?? [])].sort((left, right) => compareStrings(left.id, right.id));
+    const regionIds = new Set();
+    for (const region of regions) {
+        if (regionIds.has(region.id)) {
+            throw new Error(`Duplicate navmesh region ${region.id}`);
+        }
+        regionIds.add(region.id);
+    }
+    for (const polygon of polygons) {
+        if (polygon.region !== undefined && !regionIds.has(polygon.region)) {
+            throw new Error(`Navmesh polygon ${polygon.id} references missing region ${polygon.region}`);
+        }
+    }
+    validatePolygonInteriorDisjoint(polygons);
+    const portalTable = createPortalTable(polygons, links);
+    const cooked = { id: source.id, polygons, links, regions, portalTable, spawnMarkers: [] };
+    const bytes = (0, canonical_js_1.canonicalStringify)(cooked);
+    return { ...cooked, bytes, hash: (0, canonical_js_1.defaultChecksum)(bytes) };
+}
+function cookImportedDeterministicNavmesh(source) {
+    const navmesh = cookDeterministicNavmesh({
+        id: source.id,
+        polygons: source.polygons.map((polygon) => ({
+            id: polygon.id,
+            vertices: polygon.vertices,
+            region: polygon.region,
+            cost: polygon.cost,
+        })),
+        links: source.links.map((link) => ({
+            from: link.from,
+            to: link.to,
+            cost: link.cost,
+            offMesh: link.offMesh,
+            bidirectional: link.bidirectional,
+        })),
+        regions: source.regions,
+    });
+    const polygonIds = new Set(navmesh.polygons.map((polygon) => polygon.id));
+    const spawnMarkers = [...(source.spawnMarkers ?? [])]
+        .map((marker) => ({
+        id: marker.id,
+        polygonId: marker.polygonId,
+        point: normalizePoint(marker.point),
+    }))
+        .sort((left, right) => compareStrings(left.id, right.id));
+    const markerIds = new Set();
+    for (const marker of spawnMarkers) {
+        if (markerIds.has(marker.id)) {
+            throw new Error(`Duplicate navmesh spawn marker ${marker.id}`);
+        }
+        markerIds.add(marker.id);
+        if (!polygonIds.has(marker.polygonId)) {
+            throw new Error(`Navmesh spawn marker ${marker.id} references missing polygon ${marker.polygonId}`);
+        }
+        const polygon = navmesh.polygons.find((candidate) => candidate.id === marker.polygonId);
+        if (!pointInPolygon3D(marker.point, polygon)) {
+            throw new Error(`Navmesh spawn marker ${marker.id} is outside polygon ${marker.polygonId}`);
+        }
+    }
+    const cooked = {
+        id: navmesh.id,
+        polygons: navmesh.polygons,
+        links: navmesh.links,
+        regions: navmesh.regions,
+        portalTable: navmesh.portalTable,
+        spawnMarkers,
+    };
+    const bytes = (0, canonical_js_1.canonicalStringify)(cooked);
+    return { ...cooked, bytes, hash: (0, canonical_js_1.defaultChecksum)(bytes) };
+}
+function findDeterministicNavmeshPath(navmesh, query) {
+    const polygons = new Map(navmesh.polygons.map((polygon) => [polygon.id, polygon]));
+    const disabledRegions = new Set([
+        ...navmesh.regions.filter((region) => region.enabled === false).map((region) => region.id),
+        ...(query.disabledRegions ?? []),
+    ]);
+    const blockedPolygons = new Set(query.blockedPolygons ?? []);
+    if (!polygons.has(query.start) || !polygons.has(query.goal)) {
+        return emptyPath();
+    }
+    if (isBlocked(polygons.get(query.start), disabledRegions, blockedPolygons) || isBlocked(polygons.get(query.goal), disabledRegions, blockedPolygons)) {
+        return emptyPath();
+    }
+    const open = [{ id: query.start, cost: 0, order: 0 }];
+    const cameFrom = new Map();
+    const costs = new Map([[query.start, 0]]);
+    const visited = new Set();
+    let order = 1;
+    while (open.length > 0) {
+        open.sort((left, right) => left.cost - right.cost || left.order - right.order);
+        const current = open.shift();
+        if (visited.has(current.id)) {
+            continue;
+        }
+        visited.add(current.id);
+        if (current.id === query.goal) {
+            const polygonPath = reconstructPath(cameFrom, current.id);
+            const points = smoothDeterministicNavmeshPath(navmesh, polygonPath);
+            return {
+                found: true,
+                polygons: polygonPath,
+                points,
+                offMeshTraversals: countOffMesh(navmesh, polygonPath),
+                visitedPolygons: visited.size,
+                pathHash: (0, canonical_js_1.defaultChecksum)({ polygonPath, points }),
+            };
+        }
+        for (const link of navmesh.links.filter((candidate) => candidate.from === current.id).sort(compareLinks)) {
+            const next = polygons.get(link.to);
+            if (next === undefined || isBlocked(next, disabledRegions, blockedPolygons)) {
+                continue;
+            }
+            const cost = current.cost + (link.cost ?? 1) + (next.cost ?? 1);
+            if (cost >= (costs.get(link.to) ?? Number.MAX_SAFE_INTEGER)) {
+                continue;
+            }
+            costs.set(link.to, cost);
+            cameFrom.set(link.to, current.id);
+            open.push({ id: link.to, cost, order });
+            order += 1;
+        }
+    }
+    return emptyPath();
+}
+function findDeterministicNavmeshPointPath(navmesh, query) {
+    const startPolygon = locateDeterministicNavmeshPolygon(navmesh, query.start, query.disabledRegions, query.blockedPolygons);
+    const goalPolygon = locateDeterministicNavmeshPolygon(navmesh, query.goal, query.disabledRegions, query.blockedPolygons);
+    if (startPolygon === undefined || goalPolygon === undefined) {
+        return emptyPath();
+    }
+    const path = findDeterministicNavmeshPath(navmesh, {
+        start: startPolygon.id,
+        goal: goalPolygon.id,
+        disabledRegions: query.disabledRegions,
+        blockedPolygons: query.blockedPolygons,
+    });
+    if (!path.found) {
+        return path;
+    }
+    const points = funnelDeterministicNavmeshPath(navmesh, path.polygons, query.start, query.goal);
+    return {
+        ...path,
+        startPolygonId: startPolygon.id,
+        goalPolygonId: goalPolygon.id,
+        points,
+        pathHash: (0, canonical_js_1.defaultChecksum)({ polygonPath: path.polygons, points, startPolygonId: startPolygon.id, goalPolygonId: goalPolygon.id }),
+    };
+}
+function locateDeterministicNavmeshPolygon(navmesh, point, disabledRegions = [], blockedPolygons = []) {
+    const disabled = new Set([
+        ...navmesh.regions.filter((region) => region.enabled === false).map((region) => region.id),
+        ...disabledRegions,
+    ]);
+    const blocked = new Set(blockedPolygons);
+    return navmesh.polygons
+        .filter((polygon) => !isBlocked(polygon, disabled, blocked))
+        .filter((polygon) => pointInPolygon3D(point, polygon))
+        .sort(comparePolygons)[0];
+}
+function smoothDeterministicNavmeshPath(navmesh, polygonIds) {
+    const polygons = new Map(navmesh.polygons.map((polygon) => [polygon.id, polygon]));
+    const points = polygonIds.map((id) => centroid(polygons.get(id)));
+    if (points.length <= 2) {
+        return points;
+    }
+    const smoothed = [points[0]];
+    for (let index = 1; index < points.length - 1; index += 1) {
+        const previous = smoothed[smoothed.length - 1];
+        const next = points[index + 1];
+        if ((previous.x === points[index].x && points[index].x === next.x) || (previous.y === points[index].y && points[index].y === next.y)) {
+            continue;
+        }
+        smoothed.push(points[index]);
+    }
+    smoothed.push(points[points.length - 1]);
+    return smoothed;
+}
+function stepDeterministicNavmeshAgents(navmesh, agents, options = {}) {
+    const blocked = new Set(options.movingObstaclePolygons ?? []);
+    let replans = 0;
+    let avoidanceCorrections = 0;
+    let waypointAdvances = 0;
+    let velocityObstacleAvoidanceCorrections = 0;
+    let agentVelocityObstacleAvoidanceCorrections = 0;
+    let agentAvoidancePriorityYields = 0;
+    let avoidanceSpeedReductions = 0;
+    let agentAvoidanceSpeedReductions = 0;
+    const polygons = new Map(navmesh.polygons.map((polygon) => [polygon.id, polygon]));
+    const disabledRegions = new Set([
+        ...navmesh.regions.filter((region) => region.enabled === false).map((region) => region.id),
+        ...(options.disabledRegions ?? []),
+    ]);
+    const orderedAgents = [...agents].sort((left, right) => compareStrings(left.id, right.id));
+    for (const agent of orderedAgents) {
+        validateNavmeshAgent(agent);
+    }
+    const agentById = new Map(orderedAgents.map((agent) => [agent.id, agent]));
+    const desiredByAgent = new Map(orderedAgents.map((agent) => [agent.id, desiredNextPolygon(navmesh, agent, blocked, options.disabledRegions)]));
+    const winnerByPolygon = new Map();
+    for (const agent of orderedAgents) {
+        const desired = desiredByAgent.get(agent.id);
+        const currentWinner = winnerByPolygon.get(desired);
+        if (currentWinner === undefined) {
+            winnerByPolygon.set(desired, agent.id);
+            continue;
+        }
+        const winner = agentById.get(currentWinner);
+        const priority = agent.avoidancePriority ?? 0;
+        const winnerPriority = winner.avoidancePriority ?? 0;
+        if (priority > winnerPriority || (priority === winnerPriority && compareStrings(agent.id, winner.id) < 0)) {
+            winnerByPolygon.set(desired, agent.id);
+        }
+    }
+    const advancedAgents = orderedAgents.map((agent) => {
+        const corridor = agent.corridor ?? findDeterministicNavmeshPath(navmesh, {
+            start: agent.polygonId,
+            goal: agent.targetPolygonId,
+            disabledRegions: options.disabledRegions,
+            blockedPolygons: [...blocked],
+        }).polygons;
+        const index = agent.corridorIndex ?? 0;
+        const nextPolygon = corridor[Math.min(index + 1, corridor.length - 1)] ?? agent.polygonId;
+        const nextPolygonData = polygons.get(nextPolygon);
+        if (nextPolygonData === undefined || isBlocked(nextPolygonData, disabledRegions, blocked)) {
+            replans += 1;
+            const path = findDeterministicNavmeshPath(navmesh, {
+                start: agent.polygonId,
+                goal: agent.targetPolygonId,
+                disabledRegions: options.disabledRegions,
+                blockedPolygons: [...blocked],
+            });
+            return { ...agent, corridor: path.polygons, corridorIndex: 0 };
+        }
+        if (winnerByPolygon.get(nextPolygon) !== agent.id) {
+            avoidanceCorrections += 1;
+            return { ...agent, corridor, corridorIndex: index };
+        }
+        const movingObstacleSpeedReduction = computeNavmeshVelocityObstacleSpeedReduction(agent, nextPolygonData, options.movingAvoidanceObstacles ?? []);
+        const agentSpeedReduction = computeNavmeshAgentVelocityObstacleSpeedReduction(agent, nextPolygonData, orderedAgents, desiredByAgent, polygons);
+        if (movingObstacleSpeedReduction.reduced) {
+            velocityObstacleAvoidanceCorrections += 1;
+        }
+        if (agentSpeedReduction.reduced) {
+            agentVelocityObstacleAvoidanceCorrections += 1;
+            agentAvoidancePriorityYields += agentSpeedReduction.yields;
+            agentAvoidanceSpeedReductions += agentSpeedReduction.reduction;
+        }
+        const totalSpeedReduction = Math.max(movingObstacleSpeedReduction.reduction, agentSpeedReduction.reduction);
+        avoidanceSpeedReductions += totalSpeedReduction;
+        const effectiveSpeed = totalSpeedReduction > 0
+            ? Math.max(0, (agent.speedPerFrame ?? 1000) - totalSpeedReduction)
+            : undefined;
+        const advanced = advanceNavmeshAgentWaypoint(agent, corridor, index, nextPolygon, nextPolygonData, options.frame ?? 0, effectiveSpeed);
+        waypointAdvances += advanced.advanced ? 1 : 0;
+        return advanced.agent;
+    });
+    const radiusAvoidance = applyRadiusAvoidance(advancedAgents);
+    avoidanceCorrections += radiusAvoidance.corrections;
+    avoidanceCorrections += velocityObstacleAvoidanceCorrections;
+    avoidanceCorrections += agentVelocityObstacleAvoidanceCorrections;
+    return {
+        agents: radiusAvoidance.agents,
+        replans,
+        avoidanceCorrections,
+        dynamicRegionToggles: options.disabledRegions?.length ?? 0,
+        obstacleCount: blocked.size,
+        waypointAdvances,
+        radiusAvoidanceCorrections: radiusAvoidance.corrections,
+        velocityObstacleAvoidanceCorrections,
+        agentVelocityObstacleAvoidanceCorrections,
+        agentAvoidancePriorityYields,
+        avoidanceSpeedReductions,
+        agentAvoidanceSpeedReductions,
+        checksum: (0, canonical_js_1.defaultChecksum)(radiusAvoidance.agents),
+    };
+}
+function stepDeterministicNavmeshOffMeshTraversal(navmesh, agent, state) {
+    const link = navmesh.links.find((candidate) => candidate.from === state.linkFrom && candidate.to === state.linkTo && candidate.offMesh === true);
+    if (link === undefined) {
+        throw new Error(`Off-mesh traversal ${state.linkFrom}->${state.linkTo} references missing off-mesh link`);
+    }
+    if (agent.id !== state.agentId) {
+        throw new Error(`Off-mesh traversal ${state.commandId} targets ${state.agentId} but received ${agent.id}`);
+    }
+    const polygons = new Map(navmesh.polygons.map((polygon) => [polygon.id, polygon]));
+    const target = polygons.get(state.linkTo);
+    if (target === undefined) {
+        throw new Error(`Off-mesh traversal ${state.commandId} references missing target polygon ${state.linkTo}`);
+    }
+    const events = [];
+    const elapsedFrames = state.elapsedFrames + 1;
+    let phase = state.phase;
+    if (phase === 'idle') {
+        phase = 'entering';
+        events.push('offmesh-enter');
+    }
+    else if (phase === 'entering') {
+        phase = 'traversing';
+        events.push('offmesh-traverse');
+    }
+    else if (phase === 'traversing' && elapsedFrames >= state.durationFrames - 1) {
+        phase = 'exiting';
+        events.push('offmesh-exit');
+    }
+    else if (phase === 'exiting' || elapsedFrames >= state.durationFrames) {
+        phase = 'complete';
+        events.push('offmesh-complete');
+    }
+    else {
+        events.push('offmesh-traverse');
+    }
+    const completed = phase === 'complete';
+    const nextAgent = completed
+        ? {
+            ...agent,
+            polygonId: state.linkTo,
+            ...centroid(target),
+            corridor: [state.linkTo],
+            corridorIndex: 0,
+        }
+        : { ...agent, corridor: [state.linkFrom, state.linkTo], corridorIndex: 0 };
+    const nextState = {
+        ...state,
+        phase,
+        elapsedFrames,
+    };
+    return {
+        state: nextState,
+        agent: nextAgent,
+        events,
+        checksum: (0, canonical_js_1.defaultChecksum)({ state: nextState, agent: nextAgent, events }),
+    };
+}
+function runDeterministicNavmeshStress(agents, frames) {
+    const navmesh = cookDeterministicNavmesh(createGridNavmeshSource(8, 8));
+    const polygonById = new Map(navmesh.polygons.map((polygon) => [polygon.id, polygon]));
+    const polygonCount = navmesh.polygons.length;
+    let currentAgents = Array.from({ length: agents }, (_, index) => ({
+        id: `a${index}`,
+        polygonId: `p${index % polygonCount}`,
+        targetPolygonId: `p${polygonCount - 1 - (index % polygonCount)}`,
+        ...centroid(polygonById.get(`p${index % polygonCount}`)),
+        speedPerFrame: 1000,
+        updateIntervalFrames: 1 + (index % 3),
+        stoppingDistance: 0,
+        avoidancePriority: index % 5,
+    }));
+    let replans = 0;
+    let avoidanceCorrections = 0;
+    let waypointAdvances = 0;
+    let radiusAvoidanceCorrections = 0;
+    let velocityObstacleAvoidanceCorrections = 0;
+    let agentVelocityObstacleAvoidanceCorrections = 0;
+    let agentAvoidancePriorityYields = 0;
+    let avoidanceSpeedReductions = 0;
+    let agentAvoidanceSpeedReductions = 0;
+    let snapshot = currentAgents;
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === Math.floor(frames / 2)) {
+            snapshot = currentAgents.map((agent) => (0, canonical_js_1.cloneCanonical)(agent));
+        }
+        const result = stepDeterministicNavmeshAgents(navmesh, currentAgents, {
+            frame,
+            disabledRegions: frame % 37 === 0 ? ['slow'] : [],
+            movingObstaclePolygons: [`p${frame % polygonCount}`],
+            movingAvoidanceObstacles: frame % 11 === 0 ? [{
+                    id: `moving-obstacle-${frame % 3}`,
+                    x: 0.5 + (frame % 5),
+                    y: 0.5 + (frame % 7),
+                    vx: frame % 2 === 0 ? 1 : -1,
+                    vy: 0,
+                    radius: 0.75,
+                    predictionFrames: 1,
+                    speedReductionPerFrame: 1000,
+                }] : [],
+        });
+        currentAgents = result.agents;
+        replans += result.replans;
+        avoidanceCorrections += result.avoidanceCorrections;
+        waypointAdvances += result.waypointAdvances;
+        radiusAvoidanceCorrections += result.radiusAvoidanceCorrections;
+        velocityObstacleAvoidanceCorrections += result.velocityObstacleAvoidanceCorrections;
+        agentVelocityObstacleAvoidanceCorrections += result.agentVelocityObstacleAvoidanceCorrections;
+        agentAvoidancePriorityYields += result.agentAvoidancePriorityYields;
+        avoidanceSpeedReductions += result.avoidanceSpeedReductions;
+        agentAvoidanceSpeedReductions += result.agentAvoidanceSpeedReductions;
+    }
+    const avoidanceCoverage = stepDeterministicNavmeshAgents(navmesh, [
+        {
+            id: 'low',
+            polygonId: 'p0',
+            targetPolygonId: 'p1',
+            ...centroid(polygonById.get('p0')),
+            speedPerFrame: 1000,
+            avoidancePriority: 0,
+        },
+        {
+            id: 'high',
+            polygonId: 'p2',
+            targetPolygonId: 'p1',
+            ...centroid(polygonById.get('p2')),
+            speedPerFrame: 1000,
+            avoidancePriority: 9,
+        },
+    ]);
+    avoidanceCorrections += avoidanceCoverage.avoidanceCorrections;
+    radiusAvoidanceCorrections += avoidanceCoverage.radiusAvoidanceCorrections;
+    const radiusCoverage = stepDeterministicNavmeshAgents(navmesh, [
+        {
+            id: 'near-a',
+            polygonId: 'p0',
+            targetPolygonId: 'p0',
+            x: 0.45,
+            y: 0.5,
+            speedPerFrame: 0,
+            radius: 0.2,
+            avoidancePriority: 0,
+        },
+        {
+            id: 'near-b',
+            polygonId: 'p0',
+            targetPolygonId: 'p0',
+            x: 0.55,
+            y: 0.5,
+            speedPerFrame: 0,
+            radius: 0.2,
+            avoidancePriority: 0,
+        },
+    ]);
+    radiusAvoidanceCorrections += radiusCoverage.radiusAvoidanceCorrections;
+    avoidanceCorrections += radiusCoverage.avoidanceCorrections;
+    const velocityObstacleCoverage = runDeterministicNavmeshVelocityObstacleFixture();
+    velocityObstacleAvoidanceCorrections += velocityObstacleCoverage.velocityObstacleAvoidanceCorrections;
+    avoidanceSpeedReductions += velocityObstacleCoverage.avoidanceSpeedReductions;
+    avoidanceCorrections += velocityObstacleCoverage.velocityObstacleAvoidanceCorrections;
+    const agentVelocityCoverage = stepDeterministicNavmeshAgents(navmesh, [
+        {
+            id: 'lower-priority-crossing',
+            polygonId: 'p0',
+            targetPolygonId: 'p63',
+            ...centroid(polygonById.get('p0')),
+            speedPerFrame: 1,
+            radius: 0.6,
+            avoidancePriority: 1,
+        },
+        {
+            id: 'higher-priority-crossing',
+            polygonId: 'p1',
+            targetPolygonId: 'p62',
+            ...centroid(polygonById.get('p1')),
+            speedPerFrame: 1,
+            radius: 0.6,
+            avoidancePriority: 9,
+        },
+    ]);
+    agentVelocityObstacleAvoidanceCorrections += agentVelocityCoverage.agentVelocityObstacleAvoidanceCorrections;
+    agentAvoidancePriorityYields += agentVelocityCoverage.agentAvoidancePriorityYields;
+    agentAvoidanceSpeedReductions += agentVelocityCoverage.agentAvoidanceSpeedReductions;
+    avoidanceSpeedReductions += agentVelocityCoverage.agentAvoidanceSpeedReductions;
+    avoidanceCorrections += agentVelocityCoverage.agentVelocityObstacleAvoidanceCorrections;
+    waypointAdvances += stepDeterministicNavmeshAgents(navmesh, [{
+            id: 'walker',
+            polygonId: 'p0',
+            targetPolygonId: 'p1',
+            ...centroid(polygonById.get('p0')),
+            speedPerFrame: 1000,
+            avoidancePriority: 0,
+        }]).waypointAdvances;
+    const checksum = (0, canonical_js_1.defaultChecksum)(currentAgents);
+    let restored = snapshot;
+    for (let frame = Math.floor(frames / 2); frame < frames; frame += 1) {
+        restored = stepDeterministicNavmeshAgents(navmesh, restored, {
+            frame,
+            disabledRegions: frame % 37 === 0 ? ['slow'] : [],
+            movingObstaclePolygons: [`p${frame % polygonCount}`],
+            movingAvoidanceObstacles: frame % 11 === 0 ? [{
+                    id: `moving-obstacle-${frame % 3}`,
+                    x: 0.5 + (frame % 5),
+                    y: 0.5 + (frame % 7),
+                    vx: frame % 2 === 0 ? 1 : -1,
+                    vy: 0,
+                    radius: 0.75,
+                    predictionFrames: 1,
+                    speedReductionPerFrame: 1000,
+                }] : [],
+        }).agents;
+    }
+    const pointPath = findDeterministicNavmeshPointPath(navmesh, {
+        start: { x: 0.5, y: 0.5 },
+        goal: { x: 7.5, y: 7.5 },
+    });
+    const located = locateDeterministicNavmeshPolygon(navmesh, { x: 0.5, y: 0.5 });
+    return {
+        checksum,
+        agents,
+        frames,
+        replans,
+        avoidanceCorrections,
+        waypointAdvances,
+        radiusAvoidanceCorrections,
+        velocityObstacleAvoidanceCorrections,
+        agentVelocityObstacleAvoidanceCorrections,
+        agentAvoidancePriorityYields,
+        avoidanceSpeedReductions,
+        agentAvoidanceSpeedReductions,
+        pathHash: findDeterministicNavmeshPath(navmesh, { start: 'p0', goal: `p${polygonCount - 1}` }).pathHash,
+        pointPathHash: pointPath.pathHash,
+        pointPathFound: pointPath.found,
+        pointLookupStable: located?.id === 'p0' && pointPath.startPolygonId === 'p0' && pointPath.goalPolygonId === `p${polygonCount - 1}`,
+        rollbackEquivalent: checksum === (0, canonical_js_1.defaultChecksum)(restored),
+    };
+}
+function runDeterministicNavmeshVelocityObstacleFixture() {
+    const first = runNavmeshVelocityObstacleCases(false);
+    const permuted = runNavmeshVelocityObstacleCases(true);
+    const restored = runNavmeshVelocityObstacleCases(false);
+    return {
+        ...first,
+        restoredChecksum: restored.checksum,
+        rollbackEquivalent: first.checksum === restored.checksum,
+        obstacleOrderStable: first.checksum === permuted.checksum,
+    };
+}
+function runNavmeshVelocityObstacleCases(permuteObstacles) {
+    const navmesh = cookDeterministicNavmesh(createGridNavmeshSource(2, 1));
+    const baseAgent = {
+        id: 'agent',
+        polygonId: 'p0',
+        targetPolygonId: 'p1',
+        x: 0.5,
+        y: 0.5,
+        speedPerFrame: 1,
+        radius: 0.2,
+        avoidancePriority: 0,
+    };
+    const movingObstacles = [
+        { id: 'crossing-a', x: 1.5, y: 0.5, vx: 0, vy: 0, radius: 0.5, predictionFrames: 1, speedReductionPerFrame: 1 },
+        { id: 'far-b', x: 8, y: 8, vx: 0, vy: 0, radius: 0.5, predictionFrames: 1, speedReductionPerFrame: 1 },
+    ];
+    const orderedObstacles = permuteObstacles ? [...movingObstacles].reverse() : movingObstacles;
+    const baseline = stepDeterministicNavmeshAgents(navmesh, [baseAgent], { frame: 0 });
+    const reduced = stepDeterministicNavmeshAgents(navmesh, [baseAgent], {
+        frame: 0,
+        movingAvoidanceObstacles: orderedObstacles,
+    });
+    const futurePredicted = stepDeterministicNavmeshAgents(navmesh, [baseAgent], {
+        frame: 0,
+        movingAvoidanceObstacles: [{
+                id: 'future-crossing',
+                x: -0.5,
+                y: 0.5,
+                vx: 2,
+                vy: 0,
+                radius: 0.5,
+                predictionFrames: 1,
+                speedReductionPerFrame: 1,
+            }],
+    });
+    const noFuturePrediction = stepDeterministicNavmeshAgents(navmesh, [baseAgent], {
+        frame: 0,
+        movingAvoidanceObstacles: [{
+                id: 'future-crossing',
+                x: -0.5,
+                y: 0.5,
+                vx: 2,
+                vy: 0,
+                radius: 0.5,
+                predictionFrames: 0,
+                speedReductionPerFrame: 1,
+            }],
+    });
+    const obstacleValidationRejected = throwsNavmeshImport(() => stepDeterministicNavmeshAgents(navmesh, [baseAgent], {
+        frame: 0,
+        movingAvoidanceObstacles: [{ id: 'bad-radius', x: 0, y: 0, vx: 0, vy: 0, radius: -1 }],
+    }));
+    const reducedAgent = reduced.agents[0];
+    const baselineAgent = baseline.agents[0];
+    const futureAgent = futurePredicted.agents[0];
+    const noFutureAgent = noFuturePrediction.agents[0];
+    const checksum = (0, canonical_js_1.defaultChecksum)({
+        baseline,
+        reduced,
+        futurePredicted,
+        noFuturePrediction,
+        obstacleValidationRejected,
+    });
+    return {
+        checksum,
+        movingObstacleSpeedReduction: baselineAgent?.polygonId === 'p1'
+            && reducedAgent?.polygonId === 'p0'
+            && reduced.velocityObstacleAvoidanceCorrections > 0
+            && reduced.avoidanceSpeedReductions > 0,
+        predictedFuturePositionAvoided: futureAgent?.polygonId === 'p0'
+            && noFutureAgent?.polygonId === 'p1'
+            && futurePredicted.velocityObstacleAvoidanceCorrections > 0,
+        authoredSpeedRestored: reducedAgent?.speedPerFrame === baseAgent.speedPerFrame,
+        obstacleValidationRejected,
+        velocityObstacleAvoidanceCorrections: reduced.velocityObstacleAvoidanceCorrections + futurePredicted.velocityObstacleAvoidanceCorrections,
+        avoidanceSpeedReductions: reduced.avoidanceSpeedReductions + futurePredicted.avoidanceSpeedReductions,
+    };
+}
+function runDeterministicNavmeshImportTraversalFixture() {
+    const source = createImportedArenaNavmeshSource();
+    const imported = cookImportedDeterministicNavmesh(source);
+    throwsNavmeshImport(() => cookImportedDeterministicNavmesh(source));
+    const permuted = cookImportedDeterministicNavmesh({
+        ...source,
+        polygons: [...source.polygons].reverse(),
+        links: [...source.links].reverse(),
+        regions: [...source.regions].reverse(),
+        spawnMarkers: [...source.spawnMarkers].reverse(),
+    });
+    const missingRegionRejected = throwsNavmeshImport(() => cookImportedDeterministicNavmesh({
+        ...source,
+        polygons: [{ ...source.polygons[0], region: 'missing' }, ...source.polygons.slice(1)],
+    }));
+    const missingLinkRejected = throwsNavmeshImport(() => cookImportedDeterministicNavmesh({
+        ...source,
+        links: [{ from: 'spawn', to: 'missing' }],
+    }));
+    const missingSpawnRejected = throwsNavmeshImport(() => cookImportedDeterministicNavmesh({
+        ...source,
+        spawnMarkers: [{ id: 'bad-spawn', polygonId: 'missing', point: { x: 0.5, y: 0.5 } }],
+    }));
+    const pointPath = findDeterministicNavmeshPointPath(imported, {
+        start: { x: 0.5, y: 0.5 },
+        goal: { x: 4.5, y: 0.5 },
+    });
+    const traversal = runOffMeshTraversalSequence(imported);
+    const restoredTraversal = runOffMeshTraversalSequence(imported);
+    const metrics = {
+        importedHash: imported.hash,
+        permutedHash: permuted.hash,
+        importOrderStable: imported.hash === permuted.hash,
+        portalCount: imported.portalTable.length,
+        spawnMarkerCount: imported.spawnMarkers.length,
+        missingRegionRejected,
+        missingLinkRejected,
+        missingSpawnRejected,
+        offMeshEnterEvents: traversal.events.filter((event) => event === 'offmesh-enter').length,
+        offMeshTraverseEvents: traversal.events.filter((event) => event === 'offmesh-traverse').length,
+        offMeshExitEvents: traversal.events.filter((event) => event === 'offmesh-exit').length,
+        offMeshCompleteEvents: traversal.events.filter((event) => event === 'offmesh-complete').length,
+        offMeshCommandIdStable: traversal.commandIds.every((id) => id === 'jump-gap-001'),
+        offMeshTraversalFrames: traversal.frames,
+        pointPathFound: pointPath.found,
+        pointPathHash: pointPath.pathHash,
+    };
+    return {
+        ...metrics,
+        checksum: (0, canonical_js_1.defaultChecksum)({ metrics, finalAgent: traversal.agent, finalState: traversal.state }),
+        restoredChecksum: (0, canonical_js_1.defaultChecksum)({
+            metrics,
+            finalAgent: restoredTraversal.agent,
+            finalState: restoredTraversal.state,
+        }),
+        rollbackEquivalent: (0, canonical_js_1.defaultChecksum)({ metrics, finalAgent: traversal.agent, finalState: traversal.state })
+            === (0, canonical_js_1.defaultChecksum)({ metrics, finalAgent: restoredTraversal.agent, finalState: restoredTraversal.state }),
+    };
+}
+function runDeterministicNavmeshLayered3DFixture() {
+    const source = createLayered3DNavmeshSource();
+    const cooked = cookDeterministicNavmesh(source);
+    const permuted = cookDeterministicNavmesh({
+        ...source,
+        polygons: [...source.polygons].reverse(),
+        links: [...source.links].reverse(),
+        regions: [...source.regions].reverse(),
+    });
+    const lowerLookup = locateDeterministicNavmeshPolygon(cooked, { x: 0.25, y: 0.25, z: 0 });
+    const upperLookup = locateDeterministicNavmeshPolygon(cooked, { x: 0.25, y: 0.25, z: 8 });
+    const lowerPath = findDeterministicNavmeshPointPath(cooked, {
+        start: { x: 0.25, y: 0.25, z: 0 },
+        goal: { x: 1.75, y: 0.25, z: 0 },
+    });
+    const upperPath = findDeterministicNavmeshPointPath(cooked, {
+        start: { x: 0.25, y: 0.25, z: 8 },
+        goal: { x: 1.75, y: 0.25, z: 8 },
+    });
+    const verticalPath = findDeterministicNavmeshPath(cooked, { start: 'lower-start', goal: 'upper-start' });
+    const stepped = stepDeterministicNavmeshAgents(cooked, [{
+            id: 'upper-agent',
+            polygonId: 'upper-start',
+            targetPolygonId: 'upper-goal',
+            x: 0.5,
+            y: 0.5,
+            z: 8,
+            speedPerFrame: 1000,
+        }], { frame: 0 });
+    const restored = stepDeterministicNavmeshAgents(cooked, [{
+            id: 'upper-agent',
+            polygonId: 'upper-start',
+            targetPolygonId: 'upper-goal',
+            x: 0.5,
+            y: 0.5,
+            z: 8,
+            speedPerFrame: 1000,
+        }], { frame: 0 });
+    const sameLayerOverlapRejected = throwsNavmeshImport(() => cookDeterministicNavmesh({
+        id: 'bad-layer-overlap',
+        regions: [{ id: 'same', enabled: true }],
+        polygons: [
+            { id: 'a', region: 'same', vertices: squareAt(0, 0, 0) },
+            { id: 'b', region: 'same', vertices: squareAt(0.25, 0.25, 0) },
+        ],
+        links: [],
+    }));
+    const metrics = {
+        cookedHash: cooked.hash,
+        permutedHash: permuted.hash,
+        cookOrderStable: cooked.hash === permuted.hash,
+        lowerLookupId: lowerLookup.id,
+        upperLookupId: upperLookup.id,
+        lowerPathHash: lowerPath.pathHash,
+        upperPathHash: upperPath.pathHash,
+        verticalOffMeshTraversals: verticalPath.offMeshTraversals,
+        stackedOverlapAccepted: cooked.polygons.length === 4,
+        sameLayerOverlapRejected,
+        layerDisambiguationStable: lowerLookup?.id === 'lower-start'
+            && upperLookup?.id === 'upper-start'
+            && lowerPath.startPolygonId === 'lower-start'
+            && lowerPath.goalPolygonId === 'lower-goal'
+            && upperPath.startPolygonId === 'upper-start'
+            && upperPath.goalPolygonId === 'upper-goal',
+        upperAgentZ: stepped.agents[0].z,
+    };
+    return {
+        ...metrics,
+        checksum: (0, canonical_js_1.defaultChecksum)({ metrics, agents: stepped.agents }),
+        restoredChecksum: (0, canonical_js_1.defaultChecksum)({ metrics, agents: restored.agents }),
+        rollbackEquivalent: (0, canonical_js_1.defaultChecksum)({ metrics, agents: stepped.agents })
+            === (0, canonical_js_1.defaultChecksum)({ metrics, agents: restored.agents }),
+    };
+}
+function desiredNextPolygon(navmesh, agent, blocked, disabledRegions) {
+    const corridor = agent.corridor ?? findDeterministicNavmeshPath(navmesh, {
+        start: agent.polygonId,
+        goal: agent.targetPolygonId,
+        disabledRegions,
+        blockedPolygons: [...blocked],
+    }).polygons;
+    const index = agent.corridorIndex ?? 0;
+    return corridor[Math.min(index + 1, corridor.length - 1)] ?? agent.polygonId;
+}
+function createPortalTable(polygons, links) {
+    const polygonById = new Map(polygons.map((polygon) => [polygon.id, polygon]));
+    return links.map((link) => {
+        const from = polygonById.get(link.from);
+        const to = polygonById.get(link.to);
+        const shared = sharedPortalMidpoint(from, to);
+        return {
+            from: link.from,
+            to: link.to,
+            midpoint: shared ?? centroid(to),
+            offMesh: link.offMesh === true,
+        };
+    }).sort((left, right) => compareStrings(left.from, right.from) || compareStrings(left.to, right.to));
+}
+function normalizePoint(point) {
+    return {
+        x: quantizeNavmeshCoordinate(point.x),
+        y: quantizeNavmeshCoordinate(point.y),
+        z: quantizeNavmeshCoordinate(point.z ?? 0),
+    };
+}
+function throwsNavmeshImport(fn) {
+    try {
+        fn();
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+function runOffMeshTraversalSequence(navmesh) {
+    let agent = {
+        id: 'runner',
+        polygonId: 'approach',
+        targetPolygonId: 'landing',
+        x: 2.5,
+        y: 0.5,
+        z: 0,
+        speedPerFrame: 1,
+    };
+    let state = {
+        agentId: 'runner',
+        linkFrom: 'approach',
+        linkTo: 'landing',
+        commandId: 'jump-gap-001',
+        phase: 'idle',
+        elapsedFrames: 0,
+        durationFrames: 5,
+    };
+    const events = [];
+    const commandIds = [];
+    for (let frame = 0; frame < 5; frame += 1) {
+        const step = stepDeterministicNavmeshOffMeshTraversal(navmesh, agent, state);
+        agent = step.agent;
+        state = step.state;
+        events.push(...step.events);
+        commandIds.push(state.commandId);
+    }
+    return { agent, state, events, commandIds, frames: 5 };
+}
+function createImportedArenaNavmeshSource() {
+    return {
+        id: 'imported-arena-navmesh',
+        regions: [
+            { id: 'main', enabled: true },
+            { id: 'jump', enabled: true },
+        ],
+        polygons: [
+            {
+                id: 'spawn',
+                region: 'main',
+                vertices: [{ x: 0, y: 0 }, { x: 1, y: 0 }, { x: 1, y: 1 }, { x: 0, y: 1 }],
+            },
+            {
+                id: 'approach',
+                region: 'main',
+                vertices: [{ x: 2, y: 0 }, { x: 3, y: 0 }, { x: 3, y: 1 }, { x: 2, y: 1 }],
+            },
+            {
+                id: 'landing',
+                region: 'jump',
+                vertices: [{ x: 4, y: 0 }, { x: 5, y: 0 }, { x: 5, y: 1 }, { x: 4, y: 1 }],
+            },
+            {
+                id: 'goal',
+                region: 'main',
+                vertices: [{ x: 6, y: 0 }, { x: 7, y: 0 }, { x: 7, y: 1 }, { x: 6, y: 1 }],
+            },
+        ],
+        links: [
+            { from: 'spawn', to: 'approach', bidirectional: true },
+            { from: 'approach', to: 'landing', offMesh: true, cost: 1 },
+            { from: 'landing', to: 'goal', bidirectional: true },
+        ],
+        spawnMarkers: [
+            { id: 'runner-spawn', polygonId: 'spawn', point: { x: 0.5, y: 0.5 } },
+            { id: 'goal-spawn', polygonId: 'goal', point: { x: 6.5, y: 0.5 } },
+        ],
+    };
+}
+function createLayered3DNavmeshSource() {
+    return {
+        id: 'layered-3d-navmesh',
+        regions: [
+            { id: 'lower', enabled: true },
+            { id: 'upper', enabled: true },
+            { id: 'vertical', enabled: true },
+        ],
+        polygons: [
+            { id: 'lower-start', region: 'lower', vertices: squareAt(0, 0, 0) },
+            { id: 'lower-goal', region: 'lower', vertices: squareAt(1, 0, 0) },
+            { id: 'upper-start', region: 'upper', vertices: squareAt(0, 0, 8) },
+            { id: 'upper-goal', region: 'upper', vertices: squareAt(1, 0, 8) },
+        ],
+        links: [
+            { from: 'lower-start', to: 'lower-goal', bidirectional: true },
+            { from: 'upper-start', to: 'upper-goal', bidirectional: true },
+            { from: 'lower-start', to: 'upper-start', offMesh: true, bidirectional: true, cost: 4 },
+        ],
+    };
+}
+function squareAt(x, y, z) {
+    return [
+        { x, y, z },
+        { x: x + 1, y, z },
+        { x: x + 1, y: y + 1, z },
+        { x, y: y + 1, z },
+    ];
+}
+function applyRadiusAvoidance(agents) {
+    const next = new Map(agents.map((agent) => [agent.id, { ...agent }]));
+    let corrections = 0;
+    const ordered = [...agents].sort(compareAgents);
+    for (let leftIndex = 0; leftIndex < ordered.length; leftIndex += 1) {
+        for (let rightIndex = leftIndex + 1; rightIndex < ordered.length; rightIndex += 1) {
+            const left = next.get(ordered[leftIndex].id);
+            const right = next.get(ordered[rightIndex].id);
+            if (left.polygonId !== right.polygonId) {
+                continue;
+            }
+            const minDistance = (left.radius ?? 0) + (right.radius ?? 0);
+            if (minDistance <= 0 || left.x === undefined || left.y === undefined || right.x === undefined || right.y === undefined) {
+                continue;
+            }
+            const dx = right.x - left.x;
+            const dy = right.y - left.y;
+            const distanceSquared = dx * dx + dy * dy;
+            if (distanceSquared >= minDistance * minDistance) {
+                continue;
+            }
+            const axisX = Math.abs(dx) >= Math.abs(dy);
+            const direction = axisX
+                ? dx === 0 ? 1 : Math.sign(dx)
+                : Math.sign(dy);
+            const distance = deterministicSqrt(distanceSquared);
+            const correction = quantizeNavmeshCoordinate((minDistance - distance) / 2);
+            if (axisX) {
+                next.set(left.id, { ...left, x: quantizeNavmeshCoordinate(left.x - direction * correction) });
+                next.set(right.id, { ...right, x: quantizeNavmeshCoordinate(right.x + direction * correction) });
+            }
+            else {
+                next.set(left.id, { ...left, y: quantizeNavmeshCoordinate(left.y - direction * correction) });
+                next.set(right.id, { ...right, y: quantizeNavmeshCoordinate(right.y + direction * correction) });
+            }
+            corrections += 1;
+        }
+    }
+    return { agents: [...next.values()].sort(compareAgents), corrections };
+}
+function computeNavmeshVelocityObstacleSpeedReduction(agent, nextPolygon, obstacles) {
+    if (agent.x === undefined || agent.y === undefined || obstacles.length === 0) {
+        return { reduced: false, reduction: 0 };
+    }
+    const agentRadius = agent.radius ?? 0;
+    const target = point3D(centroid(nextPolygon));
+    const speed = agent.speedPerFrame ?? 1000;
+    let reduction = 0;
+    for (const obstacle of [...obstacles].sort((left, right) => compareStrings(left.id, right.id))) {
+        validateMovingAvoidanceObstacle(obstacle);
+        const predictionFrames = obstacle.predictionFrames ?? 1;
+        const predicted = {
+            x: quantizeNavmeshCoordinate(obstacle.x + obstacle.vx * predictionFrames),
+            y: quantizeNavmeshCoordinate(obstacle.y + obstacle.vy * predictionFrames),
+            z: quantizeNavmeshCoordinate((obstacle.z ?? 0) + (obstacle.vz ?? 0) * predictionFrames),
+        };
+        const minDistance = agentRadius + obstacle.radius;
+        if (minDistance <= 0) {
+            continue;
+        }
+        const distanceSquared = distanceSquaredPointToSegment3D(predicted, { x: agent.x, y: agent.y, z: agent.z ?? 0 }, target);
+        if (distanceSquared > minDistance * minDistance) {
+            continue;
+        }
+        reduction = Math.max(reduction, obstacle.speedReductionPerFrame ?? speed);
+    }
+    return { reduced: reduction > 0, reduction };
+}
+function computeNavmeshAgentVelocityObstacleSpeedReduction(agent, nextPolygon, agents, desiredByAgent, polygons) {
+    if (agent.x === undefined || agent.y === undefined) {
+        return { reduced: false, reduction: 0, yields: 0 };
+    }
+    const speed = agent.speedPerFrame ?? 1000;
+    if (speed <= 0) {
+        return { reduced: false, reduction: 0, yields: 0 };
+    }
+    const start = { x: agent.x, y: agent.y, z: agent.z ?? 0 };
+    const target = point3D(centroid(nextPolygon));
+    const future = predictNavmeshAgentPoint(agent, target, speed);
+    let reduction = 0;
+    let yields = 0;
+    for (const other of agents) {
+        if (other.id === agent.id || other.x === undefined || other.y === undefined) {
+            continue;
+        }
+        if (!shouldYieldForNavmeshAgent(agent, other)) {
+            continue;
+        }
+        const otherNextPolygonId = desiredByAgent.get(other.id);
+        const otherNextPolygon = polygons.get(otherNextPolygonId);
+        if (otherNextPolygon === undefined) {
+            continue;
+        }
+        const otherSpeed = other.speedPerFrame ?? 1000;
+        const otherStart = { x: other.x, y: other.y, z: other.z ?? 0 };
+        const otherTarget = point3D(centroid(otherNextPolygon));
+        const otherFuture = predictNavmeshAgentPoint(other, otherTarget, otherSpeed);
+        const minDistance = (agent.radius ?? 0) + (other.radius ?? 0);
+        if (minDistance <= 0) {
+            continue;
+        }
+        const minDistanceSquared = minDistance * minDistance;
+        const crossingDistance = Math.min(distanceSquared3D(future, otherFuture), distanceSquaredPointToSegment3D(future, otherStart, otherTarget), distanceSquaredPointToSegment3D(otherFuture, start, target), distanceSquaredPointToSegment3D(start, otherStart, otherTarget));
+        if (crossingDistance > minDistanceSquared) {
+            continue;
+        }
+        reduction = Math.max(reduction, Math.max(1, Math.ceil(speed / 2)));
+        yields += 1;
+    }
+    return { reduced: reduction > 0, reduction, yields };
+}
+function shouldYieldForNavmeshAgent(agent, other) {
+    const priority = agent.avoidancePriority ?? 0;
+    const otherPriority = other.avoidancePriority ?? 0;
+    return priority < otherPriority || (priority === otherPriority && compareStrings(agent.id, other.id) > 0);
+}
+function predictNavmeshAgentPoint(agent, target, speed) {
+    const start = { x: agent.x, y: agent.y, z: agent.z ?? 0 };
+    const dx = target.x - start.x;
+    const dy = target.y - start.y;
+    const dz = target.z - start.z;
+    const stepX = stepToward(dx, speed);
+    const stepY = stepToward(dy, Math.max(0, speed - Math.abs(stepX)));
+    const stepZ = stepToward(dz, Math.max(0, speed - Math.abs(stepX) - Math.abs(stepY)));
+    return {
+        x: quantizeNavmeshCoordinate(start.x + stepX),
+        y: quantizeNavmeshCoordinate(start.y + stepY),
+        z: quantizeNavmeshCoordinate(start.z + stepZ),
+    };
+}
+function point3D(point) {
+    return { x: point.x, y: point.y, z: point.z };
+}
+function distanceSquared3D(left, right) {
+    return (left.x - right.x) ** 2 + (left.y - right.y) ** 2 + (left.z - right.z) ** 2;
+}
+function distanceSquaredPointToSegment3D(point, start, end) {
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const dz = end.z - start.z;
+    const lengthSquared = dx * dx + dy * dy + dz * dz;
+    if (lengthSquared === 0) {
+        return (point.x - start.x) ** 2 + (point.y - start.y) ** 2 + (point.z - start.z) ** 2;
+    }
+    const t = Math.max(0, Math.min(1, ((point.x - start.x) * dx + (point.y - start.y) * dy + (point.z - start.z) * dz) / lengthSquared));
+    const closest = {
+        x: start.x + dx * t,
+        y: start.y + dy * t,
+        z: start.z + dz * t,
+    };
+    return (point.x - closest.x) ** 2 + (point.y - closest.y) ** 2 + (point.z - closest.z) ** 2;
+}
+function validateMovingAvoidanceObstacle(obstacle) {
+    if (obstacle.id.length === 0) {
+        throw new Error('Navmesh moving avoidance obstacle id must not be empty');
+    }
+    if (![obstacle.x, obstacle.y, obstacle.z ?? 0, obstacle.vx, obstacle.vy, obstacle.vz ?? 0, obstacle.radius].every(Number.isFinite)) {
+        throw new Error(`Navmesh moving avoidance obstacle ${obstacle.id} has invalid numeric fields`);
+    }
+    if (obstacle.radius <= 0) {
+        throw new Error(`Navmesh moving avoidance obstacle ${obstacle.id} has invalid radius`);
+    }
+    if (obstacle.predictionFrames !== undefined && (!Number.isInteger(obstacle.predictionFrames) || obstacle.predictionFrames < 0)) {
+        throw new Error(`Navmesh moving avoidance obstacle ${obstacle.id} has invalid predictionFrames`);
+    }
+    if (obstacle.speedReductionPerFrame !== undefined && (!Number.isInteger(obstacle.speedReductionPerFrame) || obstacle.speedReductionPerFrame < 0)) {
+        throw new Error(`Navmesh moving avoidance obstacle ${obstacle.id} has invalid speedReductionPerFrame`);
+    }
+}
+function createGridNavmeshSource(width, height) {
+    const polygons = [];
+    const links = [];
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const id = `p${y * width + x}`;
+            polygons.push({
+                id,
+                region: (x + y) % 7 === 0 ? 'slow' : undefined,
+                vertices: [{ x, y }, { x: x + 1, y }, { x: x + 1, y: y + 1 }, { x, y: y + 1 }],
+            });
+            if (x + 1 < width) {
+                links.push({ from: id, to: `p${y * width + x + 1}`, bidirectional: true });
+            }
+            if (y + 1 < height) {
+                links.push({ from: id, to: `p${(y + 1) * width + x}`, bidirectional: true });
+            }
+        }
+    }
+    return { id: 'grid-navmesh', polygons, links, regions: [{ id: 'slow', enabled: true }] };
+}
+function normalizePolygon(polygon) {
+    return { ...polygon, vertices: polygon.vertices.map((point) => (0, canonical_js_1.cloneCanonical)(point)) };
+}
+function validatePolygonShape(polygon) {
+    if (polygon.vertices.length < 3) {
+        throw new Error(`Navmesh polygon ${polygon.id} requires at least 3 vertices`);
+    }
+    const seen = new Set();
+    for (const vertex of polygon.vertices) {
+        if (!Number.isFinite(vertex.x) || !Number.isFinite(vertex.y) || !Number.isFinite(vertex.z ?? 0)) {
+            throw new Error(`Navmesh polygon ${polygon.id} contains non-finite vertex`);
+        }
+        const key = `${quantizeNavmeshCoordinate(vertex.x)}:${quantizeNavmeshCoordinate(vertex.y)}:${quantizeNavmeshCoordinate(vertex.z ?? 0)}`;
+        if (seen.has(key)) {
+            throw new Error(`Navmesh polygon ${polygon.id} contains duplicate vertex ${key}`);
+        }
+        seen.add(key);
+    }
+    const area = polygonSignedArea2D(polygon.vertices);
+    if (area === 0) {
+        throw new Error(`Navmesh polygon ${polygon.id} has zero area`);
+    }
+    if (area < 0) {
+        throw new Error(`Navmesh polygon ${polygon.id} must use counter-clockwise winding`);
+    }
+    validatePolygonConvexity(polygon);
+    validatePolygonSelfIntersection(polygon);
+}
+function validatePolygonConvexity(polygon) {
+    for (let index = 0; index < polygon.vertices.length; index += 1) {
+        const previous = polygon.vertices[(index + polygon.vertices.length - 1) % polygon.vertices.length];
+        const current = polygon.vertices[index];
+        const next = polygon.vertices[(index + 1) % polygon.vertices.length];
+        const turn = cross2D(previous, current, next);
+        if (turn === 0) {
+            throw new Error(`Navmesh polygon ${polygon.id} has collinear vertices`);
+        }
+        if (turn < 0) {
+            throw new Error(`Navmesh polygon ${polygon.id} is concave`);
+        }
+    }
+}
+function validatePolygonSelfIntersection(polygon) {
+    const edges = polygonEdges(polygon);
+    for (let left = 0; left < edges.length; left += 1) {
+        for (let right = left + 1; right < edges.length; right += 1) {
+            if (edgesShareEndpointIndex(left, right, edges.length)) {
+                continue;
+            }
+            if (segmentsProperlyIntersect2D(edges[left][0], edges[left][1], edges[right][0], edges[right][1])) {
+                throw new Error(`Navmesh polygon ${polygon.id} self-intersects`);
+            }
+        }
+    }
+}
+function validatePolygonInteriorDisjoint(polygons) {
+    for (let left = 0; left < polygons.length; left += 1) {
+        for (let right = left + 1; right < polygons.length; right += 1) {
+            if (polygonZRangesAreDisjoint(polygons[left], polygons[right])) {
+                continue;
+            }
+            if (polygonInteriorsOverlap(polygons[left], polygons[right])) {
+                throw new Error(`Navmesh polygons ${polygons[left].id} and ${polygons[right].id} overlap`);
+            }
+        }
+    }
+}
+function polygonInteriorsOverlap(left, right) {
+    for (const [leftA, leftB] of polygonEdges(left)) {
+        for (const [rightA, rightB] of polygonEdges(right)) {
+            if (segmentsProperlyIntersect2D(leftA, leftB, rightA, rightB)) {
+                return true;
+            }
+        }
+    }
+    return left.vertices.some((vertex) => pointStrictlyInsidePolygon2D(vertex, right))
+        || right.vertices.some((vertex) => pointStrictlyInsidePolygon2D(vertex, left));
+}
+function expandLink(link) {
+    if (link.bidirectional !== true) {
+        return [link];
+    }
+    return [{ ...link, bidirectional: undefined }, { ...link, from: link.to, to: link.from, bidirectional: undefined }];
+}
+function isBlocked(polygon, disabledRegions, blockedPolygons) {
+    return blockedPolygons.has(polygon.id) || (polygon.region !== undefined && disabledRegions.has(polygon.region));
+}
+function reconstructPath(cameFrom, id) {
+    const path = [id];
+    let current = id;
+    while (cameFrom.has(current)) {
+        current = cameFrom.get(current);
+        path.push(current);
+    }
+    return path.reverse();
+}
+function countOffMesh(navmesh, path) {
+    let count = 0;
+    for (let index = 1; index < path.length; index += 1) {
+        if (navmesh.links.find((link) => link.from === path[index - 1] && link.to === path[index])?.offMesh === true) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function advanceNavmeshAgentWaypoint(agent, corridor, index, nextPolygon, target, frame, effectiveSpeed) {
+    const nextIndex = Math.min(index + 1, corridor.length - 1);
+    if (agent.x === undefined || agent.y === undefined) {
+        return {
+            agent: { ...agent, polygonId: nextPolygon, corridor, corridorIndex: nextIndex },
+            advanced: nextPolygon !== agent.polygonId,
+        };
+    }
+    const targetPoint = centroid(target);
+    const updateInterval = agent.updateIntervalFrames ?? 1;
+    if (updateInterval > 1 && frame % updateInterval !== 0) {
+        return { agent: { ...agent, corridor, corridorIndex: index }, advanced: false };
+    }
+    const speed = effectiveSpeed ?? agent.speedPerFrame ?? 1000;
+    const dx = targetPoint.x - agent.x;
+    const dy = targetPoint.y - agent.y;
+    const dz = targetPoint.z - (agent.z ?? 0);
+    const distance = Math.abs(dx) + Math.abs(dy) + Math.abs(dz);
+    const stoppingDistance = agent.stoppingDistance ?? 0;
+    if (distance <= speed + stoppingDistance) {
+        return {
+            agent: { ...agent, ...targetPoint, polygonId: nextPolygon, corridor, corridorIndex: nextIndex },
+            advanced: nextPolygon !== agent.polygonId,
+        };
+    }
+    return {
+        agent: {
+            ...agent,
+            x: agent.x + stepToward(dx, speed),
+            y: agent.y + stepToward(dy, Math.max(0, speed - Math.abs(stepToward(dx, speed)))),
+            z: (agent.z ?? 0) + stepToward(dz, Math.max(0, speed - Math.abs(stepToward(dx, speed)) - Math.abs(stepToward(dy, Math.max(0, speed - Math.abs(stepToward(dx, speed))))))),
+            corridor,
+            corridorIndex: index,
+        },
+        advanced: false,
+    };
+}
+function stepToward(delta, budget) {
+    if (delta === 0 || budget <= 0) {
+        return 0;
+    }
+    return Math.sign(delta) * Math.min(Math.abs(delta), budget);
+}
+function validateNavmeshAgent(agent) {
+    if (agent.speedPerFrame !== undefined && (!Number.isInteger(agent.speedPerFrame) || agent.speedPerFrame < 0)) {
+        throw new Error(`Navmesh agent ${agent.id} has invalid speedPerFrame`);
+    }
+}
+function centroid(polygon) {
+    const sum = polygon.vertices.reduce((accumulator, point) => ({ x: accumulator.x + point.x, y: accumulator.y + point.y, z: accumulator.z + (point.z ?? 0) }), { x: 0, y: 0, z: 0 });
+    return {
+        x: quantizeNavmeshCoordinate(sum.x / polygon.vertices.length),
+        y: quantizeNavmeshCoordinate(sum.y / polygon.vertices.length),
+        z: quantizeNavmeshCoordinate(sum.z / polygon.vertices.length),
+    };
+}
+function funnelDeterministicNavmeshPath(navmesh, polygonIds, start, goal) {
+    if (polygonIds.length === 1) {
+        return [start, goal];
+    }
+    const polygons = new Map(navmesh.polygons.map((polygon) => [polygon.id, polygon]));
+    const corridor = polygonIds.map((id) => polygons.get(id));
+    if (lineStaysInsideCorridor(start, goal, corridor)) {
+        return [start, goal];
+    }
+    const points = [start];
+    for (let index = 1; index < polygonIds.length - 1; index += 1) {
+        const previous = polygons.get(polygonIds[index - 1]);
+        const current = polygons.get(polygonIds[index]);
+        const next = polygons.get(polygonIds[index + 1]);
+        const portalIn = sharedPortalMidpoint(previous, current);
+        const portalOut = sharedPortalMidpoint(current, next);
+        if (portalIn === undefined || portalOut === undefined || !lineStaysInsidePolygon(portalIn, portalOut, current)) {
+            points.push(centroid(current));
+        }
+        else {
+            points.push(portalOut);
+        }
+    }
+    points.push(goal);
+    return points;
+}
+function lineStaysInsideCorridor(start, goal, polygons) {
+    const sampleCount = Math.max(8, polygons.length * 4);
+    for (let index = 0; index <= sampleCount; index += 1) {
+        const t = index / sampleCount;
+        const point = {
+            x: quantizeNavmeshCoordinate(start.x + (goal.x - start.x) * t),
+            y: quantizeNavmeshCoordinate(start.y + (goal.y - start.y) * t),
+            z: quantizeNavmeshCoordinate((start.z ?? 0) + ((goal.z ?? 0) - (start.z ?? 0)) * t),
+        };
+        if (!polygons.some((polygon) => pointInPolygon3D(point, polygon))) {
+            return false;
+        }
+    }
+    return true;
+}
+function sharedPortalMidpoint(left, right) {
+    const shared = left.vertices.filter((leftPoint) => right.vertices.some((rightPoint) => samePoint2D(leftPoint, rightPoint)));
+    if (shared.length < 2) {
+        return undefined;
+    }
+    const ordered = [...shared].sort((a, b) => compareStrings((0, canonical_js_1.canonicalStringify)(a), (0, canonical_js_1.canonicalStringify)(b)));
+    return {
+        x: (ordered[0].x + ordered[1].x) / 2,
+        y: (ordered[0].y + ordered[1].y) / 2,
+        z: ((ordered[0].z ?? 0) + (ordered[1].z ?? 0)) / 2,
+    };
+}
+function pointInPolygon2D(point, polygon) {
+    let inside = false;
+    const x = point.x;
+    const y = point.y;
+    for (let i = 0, j = polygon.vertices.length - 1; i < polygon.vertices.length; j = i, i += 1) {
+        const a = polygon.vertices[i];
+        const b = polygon.vertices[j];
+        if (pointOnSegment2D(point, a, b)) {
+            return true;
+        }
+        const intersects = (a.y > y) !== (b.y > y)
+            && x < ((b.x - a.x) * (y - a.y)) / (b.y - a.y) + a.x;
+        if (intersects) {
+            inside = !inside;
+        }
+    }
+    return inside;
+}
+function pointInPolygon3D(point, polygon) {
+    return pointInPolygon2D(point, polygon) && pointWithinPolygonZRange(point, polygon);
+}
+function pointWithinPolygonZRange(point, polygon) {
+    const range = polygonZRange(polygon);
+    const z = quantizeNavmeshCoordinate(point.z ?? 0);
+    return z >= range.min && z <= range.max;
+}
+function pointOnSegment2D(point, a, b) {
+    const cross = (point.y - a.y) * (b.x - a.x) - (point.x - a.x) * (b.y - a.y);
+    if (cross !== 0) {
+        return false;
+    }
+    return point.x >= Math.min(a.x, b.x) && point.x <= Math.max(a.x, b.x)
+        && point.y >= Math.min(a.y, b.y) && point.y <= Math.max(a.y, b.y);
+}
+function pointStrictlyInsidePolygon2D(point, polygon) {
+    return pointInPolygon2D(point, polygon)
+        && !polygonEdges(polygon).some(([a, b]) => pointOnSegment2D(point, a, b));
+}
+function polygonSignedArea2D(points) {
+    let doubleArea = 0;
+    for (let index = 0; index < points.length; index += 1) {
+        const current = points[index];
+        const next = points[(index + 1) % points.length];
+        doubleArea += current.x * next.y - next.x * current.y;
+    }
+    return quantizeNavmeshCoordinate(doubleArea / 2);
+}
+function polygonEdges(polygon) {
+    return polygon.vertices.map((point, index) => [point, polygon.vertices[(index + 1) % polygon.vertices.length]]);
+}
+function edgesShareEndpointIndex(left, right, edgeCount) {
+    return left === right
+        || (left + 1) % edgeCount === right
+        || (right + 1) % edgeCount === left;
+}
+function segmentsProperlyIntersect2D(a, b, c, d) {
+    const left = cross2D(a, b, c);
+    const right = cross2D(a, b, d);
+    const top = cross2D(c, d, a);
+    const bottom = cross2D(c, d, b);
+    return left !== 0
+        && right !== 0
+        && top !== 0
+        && bottom !== 0
+        && (left > 0) !== (right > 0)
+        && (top > 0) !== (bottom > 0);
+}
+function cross2D(a, b, c) {
+    return quantizeNavmeshCoordinate((b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x));
+}
+function lineStaysInsidePolygon(a, b, polygon) {
+    const mid = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2, z: (pointZ(a) + pointZ(b)) / 2 };
+    return pointInPolygon3D(mid, polygon);
+}
+function pointZ(point) {
+    return point.z;
+}
+function samePoint2D(left, right) {
+    return left.x === right.x && left.y === right.y && (left.z ?? 0) === (right.z ?? 0);
+}
+function quantizeNavmeshCoordinate(value) {
+    // Pure integer rounding, not Number.prototype.toFixed — cross-engine
+    // half-way divergence on a checksummed path (see physics2d quantizeDistance).
+    const quantized = Math.round(value * 1e6) / 1e6;
+    return quantized === 0 ? 0 : quantized;
+}
+function deterministicSqrt(value) {
+    if (value <= 0) {
+        return 0;
+    }
+    let estimate = value >= 1 ? value : 1;
+    for (let iteration = 0; iteration < 8; iteration += 1) {
+        estimate = (estimate + value / estimate) / 2;
+    }
+    return quantizeNavmeshCoordinate(estimate);
+}
+function emptyPath() {
+    return { found: false, polygons: [], points: [], offMeshTraversals: 0, visitedPolygons: 0, pathHash: (0, canonical_js_1.defaultChecksum)([]) };
+}
+function comparePolygons(left, right) {
+    return compareStrings(left.id, right.id);
+}
+function polygonZRangesAreDisjoint(left, right) {
+    const leftRange = polygonZRange(left);
+    const rightRange = polygonZRange(right);
+    return leftRange.max < rightRange.min || rightRange.max < leftRange.min;
+}
+function polygonZRange(polygon) {
+    const values = polygon.vertices.map((point) => quantizeNavmeshCoordinate(point.z ?? 0));
+    return {
+        min: Math.min(...values),
+        max: Math.max(...values),
+    };
+}
+function compareLinks(left, right) {
+    return compareStrings(left.from, right.from) || compareStrings(left.to, right.to);
+}
+function compareAgents(left, right) {
+    return compareStrings(left.id, right.id);
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}