dsh-drawai 0.4.1 → 0.4.2

package/lib/routing/vendor/libavoid-routing.js

@@ -1,753 +1,753 @@
-/*
- * libavoid-routing.js — the draw.io routing core over the libavoid solver.
- * Hand-authored; engine-agnostic (takes the `Avoid` namespace as a parameter,
- * so it works whether the host loads libavoid as WASM or pure JS) and never
- * changes with the libavoid build.
- *
- * CANONICAL SOURCE: this file (drawio-dev js/libavoid-js/). drawio-mcp vendors
- * verbatim copies (mcp-app-server/vendor/libavoid/ and
- * mcp-tool-server/vendor/libavoid/) — copy this file over when it changes.
- *
- * A plain script defining globalThis.AvoidRouting, so the SAME artifact is:
- *  - concatenated into extensions.min.js here (glue → wasm → loader → this →
- *    the Closure-compiled LibavoidRouting editor binding),
- *  - inlined into (or CDN-loaded by) the drawio-mcp app-server viewer,
- *  - side-effect imported from Node by the drawio-mcp tool server
- *    (import the file, then read globalThis.AvoidRouting).
- * It does not depend on the glue/loader — every entry point takes the Avoid
- * namespace as a parameter — and must stay dependency-free (no mxGraph, no
- * DOM): anything editor-specific belongs in js/diagramly/LibavoidRouting.js.
- *
- * libavoid API gotchas baked in here (empirically verified against the
- * vendored build, libavoid-js 0.5.0-beta.5):
- *  - Router flag is an integer: RouterFlag.OrthogonalRouting.value
- *  - setRoutingParameter takes the enum OBJECT (RoutingParameter.x), not
- *    .value (the integer silently no-ops and routes run flush against boxes)
- *  - cleanup is router.delete() (embind), not Avoid.destroy()
- *  - Point/Rectangle/ConnEnd/Checkpoint(+vector) are embind wrappers COPIED
- *    into the objects they parameterize and NOT freed by router.delete();
- *    free each temporary with .delete()
- *  - a directed ShapeConnectionPin gives the route NO minimum straight
- *    lead-out (it may turn at the anchor and run flush along the shape); a
- *    minimum stub needs a routing checkpoint at the stub tip. Checkpoint
- *    DIRECTION flags have an inverted vertical convention in this build —
- *    use plain 1-arg checkpoints only.
- */
-(function()
-{
-	var AvoidRouting = {};
-
-	// libavoid ConnDirFlags (the enum isn't exposed by the JS bindings): a
-	// bitmask of the directions a connector may approach an endpoint.
-	AvoidRouting.DIR = {up: 1, down: 2, left: 4, right: 8, all: 15};
-
-	/**
-	 * Clamp to [0,1] — the ShapeConnectionPin proportional-offset domain.
-	 */
-	AvoidRouting.clamp01 = function(v)
-	{
-		return (v < 0) ? 0 : ((v > 1) ? 1 : v);
-	};
-
-	/**
-	 * ConnDirFlags for a proportional connection point: perpendicular to the
-	 * nearest shape edge (x<=0 left, x>=1 right, y<=0 up, y>=1 down), else any
-	 * direction.
-	 */
-	AvoidRouting.dirForPoint = function(x, y)
-	{
-		var DIR = AvoidRouting.DIR;
-		var d = 0;
-
-		if (x <= 0) { d |= DIR.left; }
-		else if (x >= 1) { d |= DIR.right; }
-
-		if (y <= 0) { d |= DIR.up; }
-		else if (y >= 1) { d |= DIR.down; }
-
-		return (d != 0) ? d : DIR.all;
-	};
-
-	/**
-	 * A fixed connection point as a routing constraint {x, y, dir}: the
-	 * proportional position clamped to [0,1] (some shapes' connection points
-	 * sit slightly outside, e.g. a hexagon tip at y=-0.017, which
-	 * ShapeConnectionPin rejects) plus the ConnDirFlags direction derived from
-	 * the ORIGINAL values so it still points off the correct edge. Returns
-	 * null when either coordinate is missing/not a number (floating endpoint).
-	 */
-	AvoidRouting.constraintForPoint = function(x, y)
-	{
-		if (x == null || y == null || isNaN(x) || isNaN(y))
-		{
-			return null;
-		}
-
-		return {x: AvoidRouting.clamp01(x), y: AvoidRouting.clamp01(y),
-			dir: AvoidRouting.dirForPoint(x, y)};
-	};
-
-	/**
-	 * Proportional pin points for one masked side of bounds b ({x,y,w,h}):
-	 * one pin per ~20px of side length (1..9, spread evenly so a single pin
-	 * sits at the side midpoint), each directed off its side. Side letters
-	 * follow the mxGraph port-constraint vocabulary (N/S/E/W). Used by
-	 * computeRoutes' sourceSides/targetSides handling — the pins of all
-	 * allowed sides share one pin class, so libavoid picks the side AND the
-	 * position that route best.
-	 */
-	AvoidRouting.maskPinPoints = function(side, b)
-	{
-		var DIR = AvoidRouting.DIR;
-		var horizontal = (side == 'N' || side == 'S');
-		var len = horizontal ? b.w : b.h;
-		var n = Math.max(1, Math.min(9, Math.round(len / 20)));
-		var pts = [];
-
-		for (var i = 0; i < n; i++)
-		{
-			var f = (i + 0.5) / n;
-
-			pts.push((side == 'N') ? {x: f, y: 0, dir: DIR.up} :
-				(side == 'S') ? {x: f, y: 1, dir: DIR.down} :
-				(side == 'W') ? {x: 0, y: f, dir: DIR.left} :
-					{x: 1, y: f, dir: DIR.right});
-		}
-
-		return pts;
-	};
-
-	/**
-	 * True when the point lies strictly inside any of the obstacles. A pinned
-	 * anchor sits ON its own shape's boundary, so the strict test never
-	 * matches the point's own shape.
-	 */
-	AvoidRouting.insideAny = function(x, y, obstacles)
-	{
-		if (obstacles != null)
-		{
-			for (var i = 0; i < obstacles.length; i++)
-			{
-				var v = obstacles[i];
-
-				if (v != null && x > v.x && x < v.x + v.w && y > v.y && y < v.y + v.h)
-				{
-					return true;
-				}
-			}
-		}
-
-		return false;
-	};
-
-	/**
-	 * The stub tip a jetty checkpoint pins the route through: the constrained
-	 * anchor on bounds b ({x,y,w,h}), moved jetty px outward along the pin's
-	 * single ConnDirFlags direction. Returns {x, y} or null when there is
-	 * nothing to enforce: no constraint, non-positive jetty, an ambiguous
-	 * direction (corner/interior anchors carry 2+ direction bits), or a tip
-	 * inside an obstacle ({x,y,w,h} array) INFLATED by the solve's buffer —
-	 * libavoid's orthogonal visibility network stays clear of the buffered
-	 * zones, so a checkpoint there is unreachable and libavoid warns
-	 * ("Warning: skipping checkpoint for connector ...") on the console and
-	 * ignores it; not requesting it keeps the route identical without the
-	 * noise. The stub's OWN shape (matched by bounds) is exempt from the
-	 * inflation — the pin's lead-out segment crosses its own buffer zone
-	 * legitimately (verified against the WASM: no warning there).
-	 */
-	AvoidRouting.jettyStub = function(constraint, jetty, b, obstacles, buffer)
-	{
-		if (constraint == null || !(jetty > 0))
-		{
-			return null;
-		}
-
-		var d = constraint.dir;
-		var DIR = AvoidRouting.DIR;
-
-		if (d != DIR.up && d != DIR.down && d != DIR.left && d != DIR.right)
-		{
-			return null;
-		}
-
-		var x = b.x + constraint.x * b.w +
-			((d == DIR.right) ? jetty : ((d == DIR.left) ? -jetty : 0));
-		var y = b.y + constraint.y * b.h +
-			((d == DIR.down) ? jetty : ((d == DIR.up) ? -jetty : 0));
-
-		if (obstacles != null)
-		{
-			var inflate = (buffer > 0) ? buffer : 0;
-
-			for (var i = 0; i < obstacles.length; i++)
-			{
-				var v = obstacles[i];
-
-				if (v == null ||
-					(v.x == b.x && v.y == b.y && v.w == b.w && v.h == b.h))
-				{
-					continue;
-				}
-
-				if (x > v.x - inflate && x < v.x + v.w + inflate &&
-					y > v.y - inflate && y < v.y + v.h + inflate)
-				{
-					return null;
-				}
-			}
-		}
-
-		return {x: x, y: y};
-	};
-
-	/**
-	 * One end's jetty capped to the clearance toward the OTHER terminal along
-	 * the stub's own axis: half the directed gap (stub's base side to the
-	 * facing side of the other shape) minus the 4px routing channel — so two
-	 * facing stubs can never cross and a capped tip lands on the corridor
-	 * channel's boundary; an uncapped stub in a tight gap puts its checkpoint
-	 * past the channel and libavoid answers with a self-overlapping hairpin
-	 * that nudging splays into flat side-loops. No cap when the end floats,
-	 * the anchor is a corner/interior one (2+ direction bits — jettyStub
-	 * skips those ends anyway), the stub points away from the other shape, or
-	 * the shapes overlap along the stub's axis: such a stub never enters the
-	 * pair's corridor, so a narrow gap along the OTHER axis must not shorten
-	 * it (only the center segment squeezes through that gap, e.g. an L around
-	 * a 15px horizontal gap keeps its full vertical lead-out).
-	 */
-	AvoidRouting.cappedJetty = function(jetty, constraint, from, to)
-	{
-		// A dangling (free-point) end has no bounds to measure the gap against.
-		if (from == null || to == null)
-		{
-			return jetty;
-		}
-
-		var DIR = AvoidRouting.DIR;
-		var d = (constraint != null) ? constraint.dir : 0;
-		var dgap = (d == DIR.down) ? to.y - (from.y + from.h) :
-			((d == DIR.up) ? from.y - (to.y + to.h) :
-			((d == DIR.right) ? to.x - (from.x + from.w) :
-			((d == DIR.left) ? from.x - (to.x + to.w) : 0)));
-
-		if (dgap > 0)
-		{
-			var half = Math.max(2, Math.floor((dgap - 4) / 2));
-
-			if (jetty > half)
-			{
-				return half;
-			}
-		}
-
-		return jetty;
-	};
-
-	/**
-	 * Obstacles minus ENCLOSING shapes: a shape whose bounds fully contain a
-	 * routed edge's terminal (and that is not itself a terminal of one of the
-	 * edges) is the container/pool/group the terminal lives IN, not something
-	 * to route around. Registering it starves the solve of corridors (both
-	 * endpoints sit inside a hard obstacle, so routes escape it or degenerate)
-	 * and suppresses the terminals' jetty stubs (jettyStub refuses tips inside
-	 * any obstacle). Model ancestry is unknown here (this file is model-free),
-	 * so containment is geometric: rect-contains-rect, inclusive. Terminals of
-	 * the routed edges are never dropped (their ShapeRefs carry the connection
-	 * pins). Returns a filtered copy; the input arrays are not modified.
-	 */
-	AvoidRouting.filterEnclosing = function(vertices, edges)
-	{
-		if (vertices == null || edges == null || edges.length === 0)
-		{
-			return vertices;
-		}
-
-		var terminalIds = Object.create(null);
-		var i;
-
-		for (i = 0; i < edges.length; i++)
-		{
-			if (edges[i] != null)
-			{
-				terminalIds[edges[i].source] = true;
-				terminalIds[edges[i].target] = true;
-			}
-		}
-
-		var terminals = [];
-
-		for (i = 0; i < vertices.length; i++)
-		{
-			var v = vertices[i];
-
-			if (v != null && terminalIds[v.id] === true)
-			{
-				terminals.push(v);
-			}
-		}
-
-		var out = [];
-
-		for (i = 0; i < vertices.length; i++)
-		{
-			var v = vertices[i];
-
-			if (v == null)
-			{
-				continue;
-			}
-
-			var enclosing = false;
-
-			if (terminalIds[v.id] !== true)
-			{
-				for (var j = 0; j < terminals.length; j++)
-				{
-					var t = terminals[j];
-
-					if (v.x <= t.x && v.y <= t.y &&
-						v.x + v.w >= t.x + t.w && v.y + v.h >= t.y + t.h)
-					{
-						enclosing = true;
-						break;
-					}
-				}
-			}
-
-			if (!enclosing)
-			{
-				out.push(v);
-			}
-		}
-
-		return out;
-	};
-
-	/**
-	 * Compute obstacle-avoiding orthogonal routes for a set of edges.
-	 *
-	 * @param {object} Avoid - the libavoid instance (AvoidLib.getInstance()).
-	 * @param {Array<{id:string,x:number,y:number,w:number,h:number}>} vertices
-	 *        Obstacles, in ABSOLUTE coordinates. Shapes enclosing a terminal
-	 *        of a routed edge are dropped (filterEnclosing).
-	 * @param {Array<{id,source,target,sourcePoint?,targetPoint?,
-	 *        sourceConstraint?,targetConstraint?,
-	 *        sourcePoints?,targetPoints?,sourceSides?,targetSides?,
-	 *        sourceJetty?,targetJetty?}>} edges
-	 *        Edges referencing vertex ids. An end may instead be a DANGLING free
-	 *        point — sourcePoint/targetPoint {x,y} in absolute coords, used when
-	 *        that terminal has no vertex (an unconnected endpoint): it routes to
-	 *        a plain Point ConnEnd (no shape, no direction), matching the
-	 *        drag-preview, and takes no constraint/pin/mask/jetty. An edge is
-	 *        skipped when an end is neither a vertex nor a free point, and
-	 *        when it is a SELF-LOOP (source === target) — loops keep the
-	 *        caller's own loop styling and waypoints.
-	 *        *Constraint = {x,y,dir} (constraintForPoint): a
-	 *        fixed connection point routed via a directed ShapeConnectionPin;
-	 *        absent => the endpoint floats at the shape centre. *Points = an
-	 *        array of {x,y,dir} candidate anchors (draw.io's snapToPoint —
-	 *        the shape's declared connection points): non-exclusive directed
-	 *        pins at each candidate under one pin class, libavoid picks the
-	 *        anchor that routes best; beaten by a *Constraint on the same end
-	 *        (an explicit anchor wins) and beats a *Sides mask (the renderer's
-	 *        snapToPoint branch runs before mask enforcement). *Sides = an
-	 *        array of allowed attach sides ('N'/'S'/'E'/'W', the legacy
-	 *        mxGraph portConstraint masks): non-exclusive pins spread along
-	 *        the allowed sides under one pin class, libavoid picks side and
-	 *        position. *Jetty = the minimum length of the first/last
-	 *        segment in px (draw.io's jettySize), enforced for ends with a
-	 *        *Constraint by a routing checkpoint at the stub tip — requested
-	 *        lazily, only for edges whose natural route falls short of the
-	 *        minimum; snapped and masked ends behave like floating ones here
-	 *        (their first bend naturally sits ~shapeBufferDistance out).
-	 * @param {{shapeBufferDistance?:number,idealNudgingDistance?:number}} [opts]
-	 *        Defaults: 16 / 14.
-	 * @returns {Object<string, Array<{x:number,y:number}>>} edge id -> interior
-	 *        bend points (ABSOLUTE, collinear-filtered). The first/last route
-	 *        points (endpoints) are dropped — a floating endpoint connects at
-	 *        the shape side midpoint, which is where a floating
-	 *        orthogonalEdgeStyle endpoint lands anyway. An edge with a
-	 *        straight (bend-free) route maps to [].
-	 */
-	AvoidRouting.computeRoutes = function(Avoid, vertices, edges, opts)
-	{
-		var out = Object.create(null);
-
-		if (Avoid == null || vertices == null || edges == null)
-		{
-			return out;
-		}
-
-		var buffer = (opts && opts.shapeBufferDistance != null) ? opts.shapeBufferDistance : 16;
-		var nudge = (opts && opts.idealNudgingDistance != null) ? opts.idealNudgingDistance : 14;
-
-		// Containers the terminals live in are not obstacles (also feeds the
-		// jettyStub checks below, so stubs inside a container are preserved).
-		vertices = AvoidRouting.filterEnclosing(vertices, edges);
-
-		function collinear(a, b, c)
-		{
-			// Zero cross product (1px tolerance) => b lies on segment a..c (redundant).
-			return Math.abs((b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y)) < 1;
-		}
-
-		var router = new Avoid.Router(Avoid.RouterFlag.OrthogonalRouting.value);
-
-		try { router.setRoutingParameter(Avoid.RoutingParameter.shapeBufferDistance, buffer); } catch (e) {}
-		try { router.setRoutingParameter(Avoid.RoutingParameter.idealNudgingDistance, nudge); } catch (e) {}
-
-		var bounds = Object.create(null);
-		var shapeRefs = Object.create(null);
-		var pinClass = 0;
-		var i;
-
-		for (i = 0; i < vertices.length; i++)
-		{
-			var v = vertices[i];
-
-			if (v == null || v.id == null || !(v.w > 0) || !(v.h > 0))
-			{
-				continue;
-			}
-
-			bounds[v.id] = v;
-			// Point/Rectangle are embind value wrappers that COPY into the
-			// ShapeRef and are NOT freed by router.delete(); free the temporaries.
-			var rp1 = new Avoid.Point(v.x, v.y);
-			var rp2 = new Avoid.Point(v.x + v.w, v.y + v.h);
-			var rect = new Avoid.Rectangle(rp1, rp2);
-			shapeRefs[v.id] = new Avoid.ShapeRef(router, rect);
-			rect.delete();
-			rp1.delete();
-			rp2.delete();
-		}
-
-		// An endpoint is FLOATING (ConnEnd at the shape centre) unless the edge
-		// gives a fixed connection point — a directed ShapeConnectionPin makes
-		// the route leave/enter the anchor perpendicular to the shape edge
-		// instead of cutting through it — a snap-point set (draw.io's
-		// snapToPoint: the shape's declared connection points as candidate
-		// anchors, one non-exclusive directed pin each, sharing ONE pin class
-		// so libavoid picks the anchor that routes best) — or a side MASK (the
-		// legacy mxGraph portConstraint vocabulary): pins spread along every
-		// allowed side (maskPinPoints), all sharing ONE pin class, so libavoid
-		// picks the side and the position that route best. Snap/mask pins are
-		// non-exclusive: several edges may share a pin and nudging separates
-		// their corridors, like the render-time router spreading floating
-		// attaches. Precedence per end mirrors the renderer: a fixed
-		// constraint (pinned exit/entry) wins over both, and a snap-point set
-		// wins over a mask (the snapToPoint branch of
-		// updateFloatingTerminalPoint runs before any mask enforcement).
-		function makeEnd(vid, b, constraint, sides, points, freePoint)
-		{
-			// Dangling end: no vertex bounds, just a free point (the edge's
-			// unconnected endpoint). Route to a plain Point ConnEnd — no shape,
-			// no direction — exactly as the warm-session drag preview does, so a
-			// committed edge with an unconnected end matches its live preview.
-			if (b == null)
-			{
-				var dp = new Avoid.Point(freePoint.x, freePoint.y);
-				var dce = new Avoid.ConnEnd(dp);
-				dp.delete();
-				return dce;
-			}
-
-			if (constraint != null && constraint.dir != null && shapeRefs[vid] != null)
-			{
-				pinClass++;
-				new Avoid.ShapeConnectionPin(shapeRefs[vid], pinClass,
-					constraint.x, constraint.y, true, 0, constraint.dir);
-				return new Avoid.ConnEnd(shapeRefs[vid], pinClass);
-			}
-
-			if (points != null && points.length > 0 && shapeRefs[vid] != null)
-			{
-				pinClass++;
-
-				for (var q = 0; q < points.length; q++)
-				{
-					// Registers itself with the ShapeRef (freed with the
-					// router), like the mask pins below.
-					var spin = new Avoid.ShapeConnectionPin(shapeRefs[vid],
-						pinClass, points[q].x, points[q].y, true, 0,
-						(points[q].dir != null) ? points[q].dir : AvoidRouting.DIR.all);
-					spin.setExclusive(false);
-				}
-
-				return new Avoid.ConnEnd(shapeRefs[vid], pinClass);
-			}
-
-			if (sides != null && sides.length > 0 && shapeRefs[vid] != null)
-			{
-				pinClass++;
-
-				for (var s = 0; s < sides.length; s++)
-				{
-					var pts = AvoidRouting.maskPinPoints(sides[s], b);
-
-					for (var p = 0; p < pts.length; p++)
-					{
-						// The pin registers itself with the ShapeRef (freed
-						// with the router); the wrapper is only kept long
-						// enough to make it shareable.
-						var pin = new Avoid.ShapeConnectionPin(shapeRefs[vid],
-							pinClass, pts[p].x, pts[p].y, true, 0, pts[p].dir);
-						pin.setExclusive(false);
-					}
-				}
-
-				return new Avoid.ConnEnd(shapeRefs[vid], pinClass);
-			}
-
-			// Free the temporary centre Point (copied into the ConnEnd); the
-			// ConnEnd itself is freed by the ConnRef caller below.
-			var cp = new Avoid.Point(b.x + b.w / 2, b.y + b.h / 2);
-			var ce = new Avoid.ConnEnd(cp);
-			cp.delete();
-
-			return ce;
-		}
-
-		// Endpoint anchor: the free point for a dangling end, else the fixed
-		// connection point, else the shape centre — the point the ConnEnd routes
-		// from.
-		function anchor(b, constraint, freePoint)
-		{
-			if (b == null)
-			{
-				return freePoint;
-			}
-
-			return (constraint != null) ?
-				{x: b.x + constraint.x * b.w, y: b.y + constraint.y * b.h} :
-				{x: b.x + b.w / 2, y: b.y + b.h / 2};
-		}
-
-		// Wrap a stub tip as a routing checkpoint. Checkpoint copies the Point
-		// and the vector copies the Checkpoint — free both embind wrappers.
-		function addCheckpoint(vec, p)
-		{
-			if (p != null)
-			{
-				var pt = new Avoid.Point(p.x, p.y);
-				var cp = new Avoid.Checkpoint(pt);
-				vec.push_back(cp);
-				cp.delete();
-				pt.delete();
-			}
-		}
-
-		var conns = [];
-
-		for (i = 0; i < edges.length; i++)
-		{
-			var e = edges[i];
-
-			if (e == null)
-			{
-				continue;
-			}
-
-			var sb = bounds[e.source];
-			var tb = bounds[e.target];
-
-			// An end is either a known vertex (sb/tb) or a dangling free point
-			// (e.sourcePoint / e.targetPoint, absolute coords) for an unconnected
-			// endpoint. Skip only when an end is neither.
-			if ((sb == null && e.sourcePoint == null) ||
-				(tb == null && e.targetPoint == null))
-			{
-				continue;
-			}
-
-			// Self-loops are out of scope: obstacle avoidance between identical
-			// endpoints is meaningless and the orthogonal router degenerates to
-			// a buffer-sized hook beside the shape. Skipping leaves the caller's
-			// loop styling and waypoints untouched (an edge with no route entry
-			// is never written), e.g. draw.io's inner-loop-waypoint self-loops.
-			if (e.source != null && e.source === e.target)
-			{
-				continue;
-			}
-
-			// ConnRef copies the ConnEnds, so free them after construction
-			// (they are not owned by the router).
-			var se = makeEnd(e.source, sb, e.sourceConstraint, e.sourceSides, e.sourcePoints, e.sourcePoint);
-			var de = makeEnd(e.target, tb, e.targetConstraint, e.targetSides, e.targetPoints, e.targetPoint);
-			var conn = new Avoid.ConnRef(router, se, de);
-			se.delete();
-			de.delete();
-
-			// Jetty stubs: force the route through a checkpoint jetty px
-			// outward of each constrained anchor, so the first/last segment is
-			// at least that long. Capped per end to the clearance the terminal
-			// pair's gap allows along the stub's axis (cappedJetty). Skipped
-			// for ends where there is nothing to enforce (jettyStub), and for
-			// the whole edge when the anchors are closer than the summed
-			// stubs — the same too-short guard as mxEdgeStyle.OrthConnector —
-			// so a short edge isn't forced to double back through its
-			// checkpoints. The stubs are computed here but requested LAZILY
-			// after the first solve (see below).
-			var sourceJetty = AvoidRouting.cappedJetty(e.sourceJetty, e.sourceConstraint, sb, tb);
-			var targetJetty = AvoidRouting.cappedJetty(e.targetJetty, e.targetConstraint, tb, sb);
-			var sa = anchor(sb, e.sourceConstraint, e.sourcePoint);
-			var ta = anchor(tb, e.targetConstraint, e.targetPoint);
-
-			// A pinned anchor buried inside ANOTHER obstacle (a shape dragged
-			// over the terminal) puts the whole route into libavoid's escape /
-			// degenerate mode: checkpoints on such a route are unreachable and
-			// libavoid warns ("skipping checkpoint") for EVERY end — including
-			// tips in perfectly clear space — before discarding them. Skip BOTH
-			// stubs for the edge instead (verified against the WASM: same
-			// route, no console noise).
-			var buried = (e.sourceConstraint != null &&
-					AvoidRouting.insideAny(sa.x, sa.y, vertices)) ||
-				(e.targetConstraint != null &&
-					AvoidRouting.insideAny(ta.x, ta.y, vertices));
-
-			var scp = buried ? null :
-				AvoidRouting.jettyStub(e.sourceConstraint, sourceJetty, sb, vertices, buffer);
-			var tcp = buried ? null :
-				AvoidRouting.jettyStub(e.targetConstraint, targetJetty, tb, vertices, buffer);
-
-			if (scp != null || tcp != null)
-			{
-				var dx = ta.x - sa.x;
-				var dy = ta.y - sa.y;
-				var total = ((scp != null) ? sourceJetty : 0) +
-					((tcp != null) ? targetJetty : 0);
-
-				if (dx * dx + dy * dy < total * total)
-				{
-					scp = null;
-					tcp = null;
-				}
-			}
-
-			conns.push({id: e.id, conn: conn, scp: scp, tcp: tcp,
-				sourceJetty: sourceJetty, targetJetty: targetJetty});
-		}
-
-		if (conns.length === 0)
-		{
-			router.delete();
-			return out;
-		}
-
-		router.processTransaction();
-
-		// LAZY jetty enforcement: the first solve runs WITHOUT the stub
-		// checkpoints; they are requested only for edges whose natural route
-		// violates a jetty minimum, and the transaction re-processed once. A
-		// checkpoint is a hard point the route must touch: when libavoid
-		// TURNS at one instead of crossing it mid-segment, the adjacent bend
-		// is pinned at the stub tip and nudging cannot center the segment in
-		// its channel — lopsided lead-outs (e.g. 30/10 on one edge next to a
-		// centered 20/20 twin) on routes that met the minimum for free.
-		// Enforcing lazily keeps the nudged, evenly distributed route
-		// wherever it already satisfies the jetty, and falls back to the
-		// checkpointed solve only where it does not.
-		function endSegment(route, atStart)
-		{
-			var n = route.size();
-
-			if (n < 2)
-			{
-				// Degenerate route; checkpoints cannot improve it.
-				return Infinity;
-			}
-
-			var a = route.at(atStart ? 0 : n - 1);
-			var b = route.at(atStart ? 1 : n - 2);
-			var horizontal = Math.abs(b.x - a.x) >= Math.abs(b.y - a.y);
-			var len = 0;
-
-			// Merge collinear raw points (libavoid may split a straight
-			// lead-out): the run ends at the first point that leaves the
-			// terminal's row/column.
-			for (var k = atStart ? 1 : n - 2; k >= 0 && k < n; k += atStart ? 1 : -1)
-			{
-				var p = route.at(k);
-
-				if (Math.abs(horizontal ? p.y - a.y : p.x - a.x) > 0.5)
-				{
-					break;
-				}
-
-				len = Math.abs(horizontal ? p.x - a.x : p.y - a.y);
-			}
-
-			return len;
-		}
-
-		var dirty = false;
-
-		for (i = 0; i < conns.length; i++)
-		{
-			var c = conns[i];
-
-			if (c.scp == null && c.tcp == null)
-			{
-				continue;
-			}
-
-			// 0.5px tolerance: sub-pixel misses vanish in the output rounding
-			// and do not warrant pinning the route to the checkpoints.
-			var r0 = c.conn.displayRoute();
-
-			if ((c.scp != null && endSegment(r0, true) < c.sourceJetty - 0.5) ||
-				(c.tcp != null && endSegment(r0, false) < c.targetJetty - 0.5))
-			{
-				// In route order (source first); setRoutingCheckpoints copies
-				// the vector, so free the wrapper.
-				var cps = new Avoid.CheckpointVector();
-				addCheckpoint(cps, c.scp);
-				addCheckpoint(cps, c.tcp);
-				c.conn.setRoutingCheckpoints(cps);
-				cps.delete();
-				dirty = true;
-			}
-		}
-
-		if (dirty)
-		{
-			router.processTransaction();
-		}
-
-		for (i = 0; i < conns.length; i++)
-		{
-			var route = conns[i].conn.displayRoute();
-			var n = route.size();
-			var wps = [];
-
-			if (n >= 2)
-			{
-				var pts = [];
-				var k;
-
-				for (k = 0; k < n; k++)
-				{
-					var p = route.at(k);
-					pts.push({x: p.x, y: p.y});
-				}
-
-				for (k = 1; k < n - 1; k++)
-				{
-					if (collinear(pts[k - 1], pts[k], pts[k + 1]))
-					{
-						continue;
-					}
-
-					wps.push({x: Math.round(pts[k].x), y: Math.round(pts[k].y)});
-				}
-			}
-
-			out[conns[i].id] = wps;
-		}
-
-		router.delete();
-		return out;
-	};
-
-	globalThis.AvoidRouting = AvoidRouting;
-})();
+/*
+ * libavoid-routing.js — the draw.io routing core over the libavoid solver.
+ * Hand-authored; engine-agnostic (takes the `Avoid` namespace as a parameter,
+ * so it works whether the host loads libavoid as WASM or pure JS) and never
+ * changes with the libavoid build.
+ *
+ * CANONICAL SOURCE: this file (drawio-dev js/libavoid-js/). drawio-mcp vendors
+ * verbatim copies (mcp-app-server/vendor/libavoid/ and
+ * mcp-tool-server/vendor/libavoid/) — copy this file over when it changes.
+ *
+ * A plain script defining globalThis.AvoidRouting, so the SAME artifact is:
+ *  - concatenated into extensions.min.js here (glue → wasm → loader → this →
+ *    the Closure-compiled LibavoidRouting editor binding),
+ *  - inlined into (or CDN-loaded by) the drawio-mcp app-server viewer,
+ *  - side-effect imported from Node by the drawio-mcp tool server
+ *    (import the file, then read globalThis.AvoidRouting).
+ * It does not depend on the glue/loader — every entry point takes the Avoid
+ * namespace as a parameter — and must stay dependency-free (no mxGraph, no
+ * DOM): anything editor-specific belongs in js/diagramly/LibavoidRouting.js.
+ *
+ * libavoid API gotchas baked in here (empirically verified against the
+ * vendored build, libavoid-js 0.5.0-beta.5):
+ *  - Router flag is an integer: RouterFlag.OrthogonalRouting.value
+ *  - setRoutingParameter takes the enum OBJECT (RoutingParameter.x), not
+ *    .value (the integer silently no-ops and routes run flush against boxes)
+ *  - cleanup is router.delete() (embind), not Avoid.destroy()
+ *  - Point/Rectangle/ConnEnd/Checkpoint(+vector) are embind wrappers COPIED
+ *    into the objects they parameterize and NOT freed by router.delete();
+ *    free each temporary with .delete()
+ *  - a directed ShapeConnectionPin gives the route NO minimum straight
+ *    lead-out (it may turn at the anchor and run flush along the shape); a
+ *    minimum stub needs a routing checkpoint at the stub tip. Checkpoint
+ *    DIRECTION flags have an inverted vertical convention in this build —
+ *    use plain 1-arg checkpoints only.
+ */
+(function()
+{
+	var AvoidRouting = {};
+
+	// libavoid ConnDirFlags (the enum isn't exposed by the JS bindings): a
+	// bitmask of the directions a connector may approach an endpoint.
+	AvoidRouting.DIR = {up: 1, down: 2, left: 4, right: 8, all: 15};
+
+	/**
+	 * Clamp to [0,1] — the ShapeConnectionPin proportional-offset domain.
+	 */
+	AvoidRouting.clamp01 = function(v)
+	{
+		return (v < 0) ? 0 : ((v > 1) ? 1 : v);
+	};
+
+	/**
+	 * ConnDirFlags for a proportional connection point: perpendicular to the
+	 * nearest shape edge (x<=0 left, x>=1 right, y<=0 up, y>=1 down), else any
+	 * direction.
+	 */
+	AvoidRouting.dirForPoint = function(x, y)
+	{
+		var DIR = AvoidRouting.DIR;
+		var d = 0;
+
+		if (x <= 0) { d |= DIR.left; }
+		else if (x >= 1) { d |= DIR.right; }
+
+		if (y <= 0) { d |= DIR.up; }
+		else if (y >= 1) { d |= DIR.down; }
+
+		return (d != 0) ? d : DIR.all;
+	};
+
+	/**
+	 * A fixed connection point as a routing constraint {x, y, dir}: the
+	 * proportional position clamped to [0,1] (some shapes' connection points
+	 * sit slightly outside, e.g. a hexagon tip at y=-0.017, which
+	 * ShapeConnectionPin rejects) plus the ConnDirFlags direction derived from
+	 * the ORIGINAL values so it still points off the correct edge. Returns
+	 * null when either coordinate is missing/not a number (floating endpoint).
+	 */
+	AvoidRouting.constraintForPoint = function(x, y)
+	{
+		if (x == null || y == null || isNaN(x) || isNaN(y))
+		{
+			return null;
+		}
+
+		return {x: AvoidRouting.clamp01(x), y: AvoidRouting.clamp01(y),
+			dir: AvoidRouting.dirForPoint(x, y)};
+	};
+
+	/**
+	 * Proportional pin points for one masked side of bounds b ({x,y,w,h}):
+	 * one pin per ~20px of side length (1..9, spread evenly so a single pin
+	 * sits at the side midpoint), each directed off its side. Side letters
+	 * follow the mxGraph port-constraint vocabulary (N/S/E/W). Used by
+	 * computeRoutes' sourceSides/targetSides handling — the pins of all
+	 * allowed sides share one pin class, so libavoid picks the side AND the
+	 * position that route best.
+	 */
+	AvoidRouting.maskPinPoints = function(side, b)
+	{
+		var DIR = AvoidRouting.DIR;
+		var horizontal = (side == 'N' || side == 'S');
+		var len = horizontal ? b.w : b.h;
+		var n = Math.max(1, Math.min(9, Math.round(len / 20)));
+		var pts = [];
+
+		for (var i = 0; i < n; i++)
+		{
+			var f = (i + 0.5) / n;
+
+			pts.push((side == 'N') ? {x: f, y: 0, dir: DIR.up} :
+				(side == 'S') ? {x: f, y: 1, dir: DIR.down} :
+				(side == 'W') ? {x: 0, y: f, dir: DIR.left} :
+					{x: 1, y: f, dir: DIR.right});
+		}
+
+		return pts;
+	};
+
+	/**
+	 * True when the point lies strictly inside any of the obstacles. A pinned
+	 * anchor sits ON its own shape's boundary, so the strict test never
+	 * matches the point's own shape.
+	 */
+	AvoidRouting.insideAny = function(x, y, obstacles)
+	{
+		if (obstacles != null)
+		{
+			for (var i = 0; i < obstacles.length; i++)
+			{
+				var v = obstacles[i];
+
+				if (v != null && x > v.x && x < v.x + v.w && y > v.y && y < v.y + v.h)
+				{
+					return true;
+				}
+			}
+		}
+
+		return false;
+	};
+
+	/**
+	 * The stub tip a jetty checkpoint pins the route through: the constrained
+	 * anchor on bounds b ({x,y,w,h}), moved jetty px outward along the pin's
+	 * single ConnDirFlags direction. Returns {x, y} or null when there is
+	 * nothing to enforce: no constraint, non-positive jetty, an ambiguous
+	 * direction (corner/interior anchors carry 2+ direction bits), or a tip
+	 * inside an obstacle ({x,y,w,h} array) INFLATED by the solve's buffer —
+	 * libavoid's orthogonal visibility network stays clear of the buffered
+	 * zones, so a checkpoint there is unreachable and libavoid warns
+	 * ("Warning: skipping checkpoint for connector ...") on the console and
+	 * ignores it; not requesting it keeps the route identical without the
+	 * noise. The stub's OWN shape (matched by bounds) is exempt from the
+	 * inflation — the pin's lead-out segment crosses its own buffer zone
+	 * legitimately (verified against the WASM: no warning there).
+	 */
+	AvoidRouting.jettyStub = function(constraint, jetty, b, obstacles, buffer)
+	{
+		if (constraint == null || !(jetty > 0))
+		{
+			return null;
+		}
+
+		var d = constraint.dir;
+		var DIR = AvoidRouting.DIR;
+
+		if (d != DIR.up && d != DIR.down && d != DIR.left && d != DIR.right)
+		{
+			return null;
+		}
+
+		var x = b.x + constraint.x * b.w +
+			((d == DIR.right) ? jetty : ((d == DIR.left) ? -jetty : 0));
+		var y = b.y + constraint.y * b.h +
+			((d == DIR.down) ? jetty : ((d == DIR.up) ? -jetty : 0));
+
+		if (obstacles != null)
+		{
+			var inflate = (buffer > 0) ? buffer : 0;
+
+			for (var i = 0; i < obstacles.length; i++)
+			{
+				var v = obstacles[i];
+
+				if (v == null ||
+					(v.x == b.x && v.y == b.y && v.w == b.w && v.h == b.h))
+				{
+					continue;
+				}
+
+				if (x > v.x - inflate && x < v.x + v.w + inflate &&
+					y > v.y - inflate && y < v.y + v.h + inflate)
+				{
+					return null;
+				}
+			}
+		}
+
+		return {x: x, y: y};
+	};
+
+	/**
+	 * One end's jetty capped to the clearance toward the OTHER terminal along
+	 * the stub's own axis: half the directed gap (stub's base side to the
+	 * facing side of the other shape) minus the 4px routing channel — so two
+	 * facing stubs can never cross and a capped tip lands on the corridor
+	 * channel's boundary; an uncapped stub in a tight gap puts its checkpoint
+	 * past the channel and libavoid answers with a self-overlapping hairpin
+	 * that nudging splays into flat side-loops. No cap when the end floats,
+	 * the anchor is a corner/interior one (2+ direction bits — jettyStub
+	 * skips those ends anyway), the stub points away from the other shape, or
+	 * the shapes overlap along the stub's axis: such a stub never enters the
+	 * pair's corridor, so a narrow gap along the OTHER axis must not shorten
+	 * it (only the center segment squeezes through that gap, e.g. an L around
+	 * a 15px horizontal gap keeps its full vertical lead-out).
+	 */
+	AvoidRouting.cappedJetty = function(jetty, constraint, from, to)
+	{
+		// A dangling (free-point) end has no bounds to measure the gap against.
+		if (from == null || to == null)
+		{
+			return jetty;
+		}
+
+		var DIR = AvoidRouting.DIR;
+		var d = (constraint != null) ? constraint.dir : 0;
+		var dgap = (d == DIR.down) ? to.y - (from.y + from.h) :
+			((d == DIR.up) ? from.y - (to.y + to.h) :
+			((d == DIR.right) ? to.x - (from.x + from.w) :
+			((d == DIR.left) ? from.x - (to.x + to.w) : 0)));
+
+		if (dgap > 0)
+		{
+			var half = Math.max(2, Math.floor((dgap - 4) / 2));
+
+			if (jetty > half)
+			{
+				return half;
+			}
+		}
+
+		return jetty;
+	};
+
+	/**
+	 * Obstacles minus ENCLOSING shapes: a shape whose bounds fully contain a
+	 * routed edge's terminal (and that is not itself a terminal of one of the
+	 * edges) is the container/pool/group the terminal lives IN, not something
+	 * to route around. Registering it starves the solve of corridors (both
+	 * endpoints sit inside a hard obstacle, so routes escape it or degenerate)
+	 * and suppresses the terminals' jetty stubs (jettyStub refuses tips inside
+	 * any obstacle). Model ancestry is unknown here (this file is model-free),
+	 * so containment is geometric: rect-contains-rect, inclusive. Terminals of
+	 * the routed edges are never dropped (their ShapeRefs carry the connection
+	 * pins). Returns a filtered copy; the input arrays are not modified.
+	 */
+	AvoidRouting.filterEnclosing = function(vertices, edges)
+	{
+		if (vertices == null || edges == null || edges.length === 0)
+		{
+			return vertices;
+		}
+
+		var terminalIds = Object.create(null);
+		var i;
+
+		for (i = 0; i < edges.length; i++)
+		{
+			if (edges[i] != null)
+			{
+				terminalIds[edges[i].source] = true;
+				terminalIds[edges[i].target] = true;
+			}
+		}
+
+		var terminals = [];
+
+		for (i = 0; i < vertices.length; i++)
+		{
+			var v = vertices[i];
+
+			if (v != null && terminalIds[v.id] === true)
+			{
+				terminals.push(v);
+			}
+		}
+
+		var out = [];
+
+		for (i = 0; i < vertices.length; i++)
+		{
+			var v = vertices[i];
+
+			if (v == null)
+			{
+				continue;
+			}
+
+			var enclosing = false;
+
+			if (terminalIds[v.id] !== true)
+			{
+				for (var j = 0; j < terminals.length; j++)
+				{
+					var t = terminals[j];
+
+					if (v.x <= t.x && v.y <= t.y &&
+						v.x + v.w >= t.x + t.w && v.y + v.h >= t.y + t.h)
+					{
+						enclosing = true;
+						break;
+					}
+				}
+			}
+
+			if (!enclosing)
+			{
+				out.push(v);
+			}
+		}
+
+		return out;
+	};
+
+	/**
+	 * Compute obstacle-avoiding orthogonal routes for a set of edges.
+	 *
+	 * @param {object} Avoid - the libavoid instance (AvoidLib.getInstance()).
+	 * @param {Array<{id:string,x:number,y:number,w:number,h:number}>} vertices
+	 *        Obstacles, in ABSOLUTE coordinates. Shapes enclosing a terminal
+	 *        of a routed edge are dropped (filterEnclosing).
+	 * @param {Array<{id,source,target,sourcePoint?,targetPoint?,
+	 *        sourceConstraint?,targetConstraint?,
+	 *        sourcePoints?,targetPoints?,sourceSides?,targetSides?,
+	 *        sourceJetty?,targetJetty?}>} edges
+	 *        Edges referencing vertex ids. An end may instead be a DANGLING free
+	 *        point — sourcePoint/targetPoint {x,y} in absolute coords, used when
+	 *        that terminal has no vertex (an unconnected endpoint): it routes to
+	 *        a plain Point ConnEnd (no shape, no direction), matching the
+	 *        drag-preview, and takes no constraint/pin/mask/jetty. An edge is
+	 *        skipped when an end is neither a vertex nor a free point, and
+	 *        when it is a SELF-LOOP (source === target) — loops keep the
+	 *        caller's own loop styling and waypoints.
+	 *        *Constraint = {x,y,dir} (constraintForPoint): a
+	 *        fixed connection point routed via a directed ShapeConnectionPin;
+	 *        absent => the endpoint floats at the shape centre. *Points = an
+	 *        array of {x,y,dir} candidate anchors (draw.io's snapToPoint —
+	 *        the shape's declared connection points): non-exclusive directed
+	 *        pins at each candidate under one pin class, libavoid picks the
+	 *        anchor that routes best; beaten by a *Constraint on the same end
+	 *        (an explicit anchor wins) and beats a *Sides mask (the renderer's
+	 *        snapToPoint branch runs before mask enforcement). *Sides = an
+	 *        array of allowed attach sides ('N'/'S'/'E'/'W', the legacy
+	 *        mxGraph portConstraint masks): non-exclusive pins spread along
+	 *        the allowed sides under one pin class, libavoid picks side and
+	 *        position. *Jetty = the minimum length of the first/last
+	 *        segment in px (draw.io's jettySize), enforced for ends with a
+	 *        *Constraint by a routing checkpoint at the stub tip — requested
+	 *        lazily, only for edges whose natural route falls short of the
+	 *        minimum; snapped and masked ends behave like floating ones here
+	 *        (their first bend naturally sits ~shapeBufferDistance out).
+	 * @param {{shapeBufferDistance?:number,idealNudgingDistance?:number}} [opts]
+	 *        Defaults: 16 / 14.
+	 * @returns {Object<string, Array<{x:number,y:number}>>} edge id -> interior
+	 *        bend points (ABSOLUTE, collinear-filtered). The first/last route
+	 *        points (endpoints) are dropped — a floating endpoint connects at
+	 *        the shape side midpoint, which is where a floating
+	 *        orthogonalEdgeStyle endpoint lands anyway. An edge with a
+	 *        straight (bend-free) route maps to [].
+	 */
+	AvoidRouting.computeRoutes = function(Avoid, vertices, edges, opts)
+	{
+		var out = Object.create(null);
+
+		if (Avoid == null || vertices == null || edges == null)
+		{
+			return out;
+		}
+
+		var buffer = (opts && opts.shapeBufferDistance != null) ? opts.shapeBufferDistance : 16;
+		var nudge = (opts && opts.idealNudgingDistance != null) ? opts.idealNudgingDistance : 14;
+
+		// Containers the terminals live in are not obstacles (also feeds the
+		// jettyStub checks below, so stubs inside a container are preserved).
+		vertices = AvoidRouting.filterEnclosing(vertices, edges);
+
+		function collinear(a, b, c)
+		{
+			// Zero cross product (1px tolerance) => b lies on segment a..c (redundant).
+			return Math.abs((b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y)) < 1;
+		}
+
+		var router = new Avoid.Router(Avoid.RouterFlag.OrthogonalRouting.value);
+
+		try { router.setRoutingParameter(Avoid.RoutingParameter.shapeBufferDistance, buffer); } catch (e) {}
+		try { router.setRoutingParameter(Avoid.RoutingParameter.idealNudgingDistance, nudge); } catch (e) {}
+
+		var bounds = Object.create(null);
+		var shapeRefs = Object.create(null);
+		var pinClass = 0;
+		var i;
+
+		for (i = 0; i < vertices.length; i++)
+		{
+			var v = vertices[i];
+
+			if (v == null || v.id == null || !(v.w > 0) || !(v.h > 0))
+			{
+				continue;
+			}
+
+			bounds[v.id] = v;
+			// Point/Rectangle are embind value wrappers that COPY into the
+			// ShapeRef and are NOT freed by router.delete(); free the temporaries.
+			var rp1 = new Avoid.Point(v.x, v.y);
+			var rp2 = new Avoid.Point(v.x + v.w, v.y + v.h);
+			var rect = new Avoid.Rectangle(rp1, rp2);
+			shapeRefs[v.id] = new Avoid.ShapeRef(router, rect);
+			rect.delete();
+			rp1.delete();
+			rp2.delete();
+		}
+
+		// An endpoint is FLOATING (ConnEnd at the shape centre) unless the edge
+		// gives a fixed connection point — a directed ShapeConnectionPin makes
+		// the route leave/enter the anchor perpendicular to the shape edge
+		// instead of cutting through it — a snap-point set (draw.io's
+		// snapToPoint: the shape's declared connection points as candidate
+		// anchors, one non-exclusive directed pin each, sharing ONE pin class
+		// so libavoid picks the anchor that routes best) — or a side MASK (the
+		// legacy mxGraph portConstraint vocabulary): pins spread along every
+		// allowed side (maskPinPoints), all sharing ONE pin class, so libavoid
+		// picks the side and the position that route best. Snap/mask pins are
+		// non-exclusive: several edges may share a pin and nudging separates
+		// their corridors, like the render-time router spreading floating
+		// attaches. Precedence per end mirrors the renderer: a fixed
+		// constraint (pinned exit/entry) wins over both, and a snap-point set
+		// wins over a mask (the snapToPoint branch of
+		// updateFloatingTerminalPoint runs before any mask enforcement).
+		function makeEnd(vid, b, constraint, sides, points, freePoint)
+		{
+			// Dangling end: no vertex bounds, just a free point (the edge's
+			// unconnected endpoint). Route to a plain Point ConnEnd — no shape,
+			// no direction — exactly as the warm-session drag preview does, so a
+			// committed edge with an unconnected end matches its live preview.
+			if (b == null)
+			{
+				var dp = new Avoid.Point(freePoint.x, freePoint.y);
+				var dce = new Avoid.ConnEnd(dp);
+				dp.delete();
+				return dce;
+			}
+
+			if (constraint != null && constraint.dir != null && shapeRefs[vid] != null)
+			{
+				pinClass++;
+				new Avoid.ShapeConnectionPin(shapeRefs[vid], pinClass,
+					constraint.x, constraint.y, true, 0, constraint.dir);
+				return new Avoid.ConnEnd(shapeRefs[vid], pinClass);
+			}
+
+			if (points != null && points.length > 0 && shapeRefs[vid] != null)
+			{
+				pinClass++;
+
+				for (var q = 0; q < points.length; q++)
+				{
+					// Registers itself with the ShapeRef (freed with the
+					// router), like the mask pins below.
+					var spin = new Avoid.ShapeConnectionPin(shapeRefs[vid],
+						pinClass, points[q].x, points[q].y, true, 0,
+						(points[q].dir != null) ? points[q].dir : AvoidRouting.DIR.all);
+					spin.setExclusive(false);
+				}
+
+				return new Avoid.ConnEnd(shapeRefs[vid], pinClass);
+			}
+
+			if (sides != null && sides.length > 0 && shapeRefs[vid] != null)
+			{
+				pinClass++;
+
+				for (var s = 0; s < sides.length; s++)
+				{
+					var pts = AvoidRouting.maskPinPoints(sides[s], b);
+
+					for (var p = 0; p < pts.length; p++)
+					{
+						// The pin registers itself with the ShapeRef (freed
+						// with the router); the wrapper is only kept long
+						// enough to make it shareable.
+						var pin = new Avoid.ShapeConnectionPin(shapeRefs[vid],
+							pinClass, pts[p].x, pts[p].y, true, 0, pts[p].dir);
+						pin.setExclusive(false);
+					}
+				}
+
+				return new Avoid.ConnEnd(shapeRefs[vid], pinClass);
+			}
+
+			// Free the temporary centre Point (copied into the ConnEnd); the
+			// ConnEnd itself is freed by the ConnRef caller below.
+			var cp = new Avoid.Point(b.x + b.w / 2, b.y + b.h / 2);
+			var ce = new Avoid.ConnEnd(cp);
+			cp.delete();
+
+			return ce;
+		}
+
+		// Endpoint anchor: the free point for a dangling end, else the fixed
+		// connection point, else the shape centre — the point the ConnEnd routes
+		// from.
+		function anchor(b, constraint, freePoint)
+		{
+			if (b == null)
+			{
+				return freePoint;
+			}
+
+			return (constraint != null) ?
+				{x: b.x + constraint.x * b.w, y: b.y + constraint.y * b.h} :
+				{x: b.x + b.w / 2, y: b.y + b.h / 2};
+		}
+
+		// Wrap a stub tip as a routing checkpoint. Checkpoint copies the Point
+		// and the vector copies the Checkpoint — free both embind wrappers.
+		function addCheckpoint(vec, p)
+		{
+			if (p != null)
+			{
+				var pt = new Avoid.Point(p.x, p.y);
+				var cp = new Avoid.Checkpoint(pt);
+				vec.push_back(cp);
+				cp.delete();
+				pt.delete();
+			}
+		}
+
+		var conns = [];
+
+		for (i = 0; i < edges.length; i++)
+		{
+			var e = edges[i];
+
+			if (e == null)
+			{
+				continue;
+			}
+
+			var sb = bounds[e.source];
+			var tb = bounds[e.target];
+
+			// An end is either a known vertex (sb/tb) or a dangling free point
+			// (e.sourcePoint / e.targetPoint, absolute coords) for an unconnected
+			// endpoint. Skip only when an end is neither.
+			if ((sb == null && e.sourcePoint == null) ||
+				(tb == null && e.targetPoint == null))
+			{
+				continue;
+			}
+
+			// Self-loops are out of scope: obstacle avoidance between identical
+			// endpoints is meaningless and the orthogonal router degenerates to
+			// a buffer-sized hook beside the shape. Skipping leaves the caller's
+			// loop styling and waypoints untouched (an edge with no route entry
+			// is never written), e.g. draw.io's inner-loop-waypoint self-loops.
+			if (e.source != null && e.source === e.target)
+			{
+				continue;
+			}
+
+			// ConnRef copies the ConnEnds, so free them after construction
+			// (they are not owned by the router).
+			var se = makeEnd(e.source, sb, e.sourceConstraint, e.sourceSides, e.sourcePoints, e.sourcePoint);
+			var de = makeEnd(e.target, tb, e.targetConstraint, e.targetSides, e.targetPoints, e.targetPoint);
+			var conn = new Avoid.ConnRef(router, se, de);
+			se.delete();
+			de.delete();
+
+			// Jetty stubs: force the route through a checkpoint jetty px
+			// outward of each constrained anchor, so the first/last segment is
+			// at least that long. Capped per end to the clearance the terminal
+			// pair's gap allows along the stub's axis (cappedJetty). Skipped
+			// for ends where there is nothing to enforce (jettyStub), and for
+			// the whole edge when the anchors are closer than the summed
+			// stubs — the same too-short guard as mxEdgeStyle.OrthConnector —
+			// so a short edge isn't forced to double back through its
+			// checkpoints. The stubs are computed here but requested LAZILY
+			// after the first solve (see below).
+			var sourceJetty = AvoidRouting.cappedJetty(e.sourceJetty, e.sourceConstraint, sb, tb);
+			var targetJetty = AvoidRouting.cappedJetty(e.targetJetty, e.targetConstraint, tb, sb);
+			var sa = anchor(sb, e.sourceConstraint, e.sourcePoint);
+			var ta = anchor(tb, e.targetConstraint, e.targetPoint);
+
+			// A pinned anchor buried inside ANOTHER obstacle (a shape dragged
+			// over the terminal) puts the whole route into libavoid's escape /
+			// degenerate mode: checkpoints on such a route are unreachable and
+			// libavoid warns ("skipping checkpoint") for EVERY end — including
+			// tips in perfectly clear space — before discarding them. Skip BOTH
+			// stubs for the edge instead (verified against the WASM: same
+			// route, no console noise).
+			var buried = (e.sourceConstraint != null &&
+					AvoidRouting.insideAny(sa.x, sa.y, vertices)) ||
+				(e.targetConstraint != null &&
+					AvoidRouting.insideAny(ta.x, ta.y, vertices));
+
+			var scp = buried ? null :
+				AvoidRouting.jettyStub(e.sourceConstraint, sourceJetty, sb, vertices, buffer);
+			var tcp = buried ? null :
+				AvoidRouting.jettyStub(e.targetConstraint, targetJetty, tb, vertices, buffer);
+
+			if (scp != null || tcp != null)
+			{
+				var dx = ta.x - sa.x;
+				var dy = ta.y - sa.y;
+				var total = ((scp != null) ? sourceJetty : 0) +
+					((tcp != null) ? targetJetty : 0);
+
+				if (dx * dx + dy * dy < total * total)
+				{
+					scp = null;
+					tcp = null;
+				}
+			}
+
+			conns.push({id: e.id, conn: conn, scp: scp, tcp: tcp,
+				sourceJetty: sourceJetty, targetJetty: targetJetty});
+		}
+
+		if (conns.length === 0)
+		{
+			router.delete();
+			return out;
+		}
+
+		router.processTransaction();
+
+		// LAZY jetty enforcement: the first solve runs WITHOUT the stub
+		// checkpoints; they are requested only for edges whose natural route
+		// violates a jetty minimum, and the transaction re-processed once. A
+		// checkpoint is a hard point the route must touch: when libavoid
+		// TURNS at one instead of crossing it mid-segment, the adjacent bend
+		// is pinned at the stub tip and nudging cannot center the segment in
+		// its channel — lopsided lead-outs (e.g. 30/10 on one edge next to a
+		// centered 20/20 twin) on routes that met the minimum for free.
+		// Enforcing lazily keeps the nudged, evenly distributed route
+		// wherever it already satisfies the jetty, and falls back to the
+		// checkpointed solve only where it does not.
+		function endSegment(route, atStart)
+		{
+			var n = route.size();
+
+			if (n < 2)
+			{
+				// Degenerate route; checkpoints cannot improve it.
+				return Infinity;
+			}
+
+			var a = route.at(atStart ? 0 : n - 1);
+			var b = route.at(atStart ? 1 : n - 2);
+			var horizontal = Math.abs(b.x - a.x) >= Math.abs(b.y - a.y);
+			var len = 0;
+
+			// Merge collinear raw points (libavoid may split a straight
+			// lead-out): the run ends at the first point that leaves the
+			// terminal's row/column.
+			for (var k = atStart ? 1 : n - 2; k >= 0 && k < n; k += atStart ? 1 : -1)
+			{
+				var p = route.at(k);
+
+				if (Math.abs(horizontal ? p.y - a.y : p.x - a.x) > 0.5)
+				{
+					break;
+				}
+
+				len = Math.abs(horizontal ? p.x - a.x : p.y - a.y);
+			}
+
+			return len;
+		}
+
+		var dirty = false;
+
+		for (i = 0; i < conns.length; i++)
+		{
+			var c = conns[i];
+
+			if (c.scp == null && c.tcp == null)
+			{
+				continue;
+			}
+
+			// 0.5px tolerance: sub-pixel misses vanish in the output rounding
+			// and do not warrant pinning the route to the checkpoints.
+			var r0 = c.conn.displayRoute();
+
+			if ((c.scp != null && endSegment(r0, true) < c.sourceJetty - 0.5) ||
+				(c.tcp != null && endSegment(r0, false) < c.targetJetty - 0.5))
+			{
+				// In route order (source first); setRoutingCheckpoints copies
+				// the vector, so free the wrapper.
+				var cps = new Avoid.CheckpointVector();
+				addCheckpoint(cps, c.scp);
+				addCheckpoint(cps, c.tcp);
+				c.conn.setRoutingCheckpoints(cps);
+				cps.delete();
+				dirty = true;
+			}
+		}
+
+		if (dirty)
+		{
+			router.processTransaction();
+		}
+
+		for (i = 0; i < conns.length; i++)
+		{
+			var route = conns[i].conn.displayRoute();
+			var n = route.size();
+			var wps = [];
+
+			if (n >= 2)
+			{
+				var pts = [];
+				var k;
+
+				for (k = 0; k < n; k++)
+				{
+					var p = route.at(k);
+					pts.push({x: p.x, y: p.y});
+				}
+
+				for (k = 1; k < n - 1; k++)
+				{
+					if (collinear(pts[k - 1], pts[k], pts[k + 1]))
+					{
+						continue;
+					}
+
+					wps.push({x: Math.round(pts[k].x), y: Math.round(pts[k].y)});
+				}
+			}
+
+			out[conns[i].id] = wps;
+		}
+
+		router.delete();
+		return out;
+	};
+
+	globalThis.AvoidRouting = AvoidRouting;
+})();