@ngroznykh/papirus 0.8.1 → 0.8.3

package/dist/core/EdgeEndpointUpdater.d.ts

@@ -21,20 +21,18 @@ export declare class EdgeEndpointUpdater {
     private resolveEdgeEndpoint;
     private lockAnchors;
     /**
-     * When nodes are clearly stacked, retarget side ports that would force the
-     * polyline to approach along the long edge (contour crawl).
+     * When nodes are clearly stacked/side-by-side, assign facing sides only to
+     * unset endpoints. Intentional ports (including lateral reconnect with
+     * attachToOutline off) and outlineParams are kept — orthogonal routing clears
+     * same-side wraps around the stack.
      *
      * Uses bounding-box gaps (not center dx/dy): a large horizontal offset must not
      * flip bottom→left while the source is still below the target — that reintroduces
      * the left-edge contour jog when the user drags the node leftward.
-     *
-     * - Always set facing ports when unset (so lockAnchors does not pick left/right).
-     * - Rewrite target left/right → top/bottom when there is a clear vertical gap.
-     * - Do not rewrite an intentional source side exit (e.g. left exit from a nested
-     *   component around its parent).
      */
     private preferFacingSidePorts;
     private portSide;
+    private endpointSide;
     private nearestAnchorOnSide;
     private setEndpointSidePort;
     /**

package/dist/core/EdgeEndpointUpdater.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EdgeEndpointUpdater.d.ts","sourceRoot":"","sources":["../../src/core/EdgeEndpointUpdater.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAOrD,MAAM,WAAW,uBAAuB;IACtC,QAAQ,IAAI,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACtC,QAAQ,IAAI,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACtC,gBAAgB,IAAI,YAAY,EAAE,CAAC;CACpC;AAOD,qBAAa,mBAAmB;IAClB,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,uBAAuB;IAE1D,aAAa,IAAI,IAAI;IAMrB,SAAS,IAAI,IAAI;IAIjB,OAAO,CAAC,MAAM;IA+Bd,OAAO,CAAC,kBAAkB;IA2D1B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA8C9B,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,mBAAmB;IAe3B,OAAO,CAAC,WAAW;IAqBnB;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,qBAAqB;IA+C7B,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,mBAAmB;IAmB3B,OAAO,CAAC,mBAAmB;IAqB3B;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IA6B3B,OAAO,CAAC,uBAAuB;CAOhC"}
+{"version":3,"file":"EdgeEndpointUpdater.d.ts","sourceRoot":"","sources":["../../src/core/EdgeEndpointUpdater.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAOrD,MAAM,WAAW,uBAAuB;IACtC,QAAQ,IAAI,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACtC,QAAQ,IAAI,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACtC,gBAAgB,IAAI,YAAY,EAAE,CAAC;CACpC;AAOD,qBAAa,mBAAmB;IAClB,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,uBAAuB;IAE1D,aAAa,IAAI,IAAI;IAMrB,SAAS,IAAI,IAAI;IAIjB,OAAO,CAAC,MAAM;IA+Bd,OAAO,CAAC,kBAAkB;IA2D1B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA8C9B,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,mBAAmB;IAe3B,OAAO,CAAC,WAAW;IAqBnB;;;;;;;;;OASG;IACH,OAAO,CAAC,qBAAqB;IA2C7B,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,mBAAmB;IAmB3B,OAAO,CAAC,mBAAmB;IAqB3B;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IA6B3B,OAAO,CAAC,uBAAuB;CAOhC"}

package/dist/elements/paths/PolylinePathStrategy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PolylinePathStrategy.d.ts","sourceRoot":"","sources":["../../../src/elements/paths/PolylinePathStrategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAgB,MAAM,gBAAgB,CAAC;AAkYtF;;GAEG;AACH,qBAAa,oBAAqB,YAAW,YAAY;IACvD,aAAa,CACX,IAAI,EAAE,KAAK,EACX,EAAE,EAAE,KAAK,EACT,OAAO,CAAC,EAAE,MAAM,EAChB,KAAK,CAAC,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,KAAK,EAAE;IA4MV,OAAO,CAAC,qBAAqB;IAgF7B,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;CAQjE"}
+{"version":3,"file":"PolylinePathStrategy.d.ts","sourceRoot":"","sources":["../../../src/elements/paths/PolylinePathStrategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAgB,MAAM,gBAAgB,CAAC;AAgctF;;GAEG;AACH,qBAAa,oBAAqB,YAAW,YAAY;IACvD,aAAa,CACX,IAAI,EAAE,KAAK,EACX,EAAE,EAAE,KAAK,EACT,OAAO,CAAC,EAAE,MAAM,EAChB,KAAK,CAAC,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,KAAK,EAAE;IAkNV,OAAO,CAAC,qBAAqB;IAgF7B,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;CAQjE"}

package/dist/elements/paths/routeOrthogonalAround.d.ts

@@ -17,6 +17,11 @@ export type RouteOrthogonalAroundInput = {
     /** Source node owning `from` — avoid re-entering after exit. */
     source?: RouteRect;
     target?: RouteRect;
+    /**
+     * Sibling / other nodes to avoid (e.g. stack mates inside a container).
+     * Not used as exit blockers — only as mid-path obstacles.
+     */
+    others?: RouteRect[];
     margin?: number;
     exitDistance?: number;
 };
@@ -55,6 +60,12 @@ export declare function clampFacingExitEntry(from: Point, to: Point, fromDir: Si
     endEntry: Point;
 };
 export declare function routeOrthogonalAround(input: RouteOrthogonalAroundInput): Point[];
+export interface EnsureOrthogonalOptions {
+    /** Prefer leaving the first point along this side (avoids licking source face). */
+    exitDir?: Side;
+    /** Prefer arriving at the last point along this side. */
+    enterDir?: Side;
+}
 /** Insert elbows so no consecutive points form a diagonal (safety net). */
-export declare function ensureOrthogonalPath(path: Point[]): Point[];
+export declare function ensureOrthogonalPath(path: Point[], options?: EnsureOrthogonalOptions): Point[];
 //# sourceMappingURL=routeOrthogonalAround.d.ts.map

package/dist/elements/paths/routeOrthogonalAround.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routeOrthogonalAround.d.ts","sourceRoot":"","sources":["../../../src/elements/paths/routeOrthogonalAround.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC,MAAM,MAAM,IAAI,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEvD,MAAM,MAAM,SAAS,GAAG;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,IAAI,EAAE,KAAK,CAAC;IACZ,EAAE,EAAE,KAAK,CAAC;IACV,OAAO,EAAE,IAAI,CAAC;IACd,KAAK,EAAE,IAAI,CAAC;IACZ,gEAAgE;IAChE,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,gEAAgE;IAChE,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAaF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,SAAS,EACpB,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,SAAS,EACf,WAAW,SAAI,GACd,CAAC,SAAS,EAAE,SAAS,CAAC,CAiDxB;AAUD,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,GAAG,KAAK,GAAG,IAAI,CA0B3E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,SAAS,EACZ,CAAC,EAAE,SAAS,GACX;IAAE,CAAC,EAAE,SAAS,CAAC;IAAC,CAAC,EAAE,SAAS,CAAA;CAAE,GAAG,IAAI,CAQvC;AAED,2FAA2F;AAC3F,wBAAgB,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,MAAM,CAMhE;AAmBD,kFAAkF;AAClF,wBAAgB,6BAA6B,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,SAAS,GAAG,OAAO,CAcvF;AAUD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,MAAM,CA6B1F;AA6ED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,KAAK,EACX,EAAE,EAAE,KAAK,EACT,OAAO,EAAE,IAAI,EACb,KAAK,EAAE,IAAI,EACX,SAAS,EAAE,KAAK,EAChB,QAAQ,EAAE,KAAK,GACd;IAAE,SAAS,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAA;CAAE,CA8BvC;AAiWD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,0BAA0B,GAAG,KAAK,EAAE,CA4FhF;AAED,2EAA2E;AAC3E,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE,CAc3D"}
+{"version":3,"file":"routeOrthogonalAround.d.ts","sourceRoot":"","sources":["../../../src/elements/paths/routeOrthogonalAround.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC,MAAM,MAAM,IAAI,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEvD,MAAM,MAAM,SAAS,GAAG;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,IAAI,EAAE,KAAK,CAAC;IACZ,EAAE,EAAE,KAAK,CAAC;IACV,OAAO,EAAE,IAAI,CAAC;IACd,KAAK,EAAE,IAAI,CAAC;IACZ,gEAAgE;IAChE,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,gEAAgE;IAChE,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB;;;OAGG;IACH,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAaF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,SAAS,EACpB,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,SAAS,EACf,WAAW,SAAI,GACd,CAAC,SAAS,EAAE,SAAS,CAAC,CAiDxB;AAUD,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,GAAG,KAAK,GAAG,IAAI,CA0B3E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,SAAS,EACZ,CAAC,EAAE,SAAS,GACX;IAAE,CAAC,EAAE,SAAS,CAAC;IAAC,CAAC,EAAE,SAAS,CAAA;CAAE,GAAG,IAAI,CAQvC;AAED,2FAA2F;AAC3F,wBAAgB,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,MAAM,CAMhE;AAmBD,kFAAkF;AAClF,wBAAgB,6BAA6B,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,SAAS,GAAG,OAAO,CAcvF;AAUD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,MAAM,CA6B1F;AA2ND;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,KAAK,EACX,EAAE,EAAE,KAAK,EACT,OAAO,EAAE,IAAI,EACb,KAAK,EAAE,IAAI,EACX,SAAS,EAAE,KAAK,EAChB,QAAQ,EAAE,KAAK,GACd;IAAE,SAAS,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAA;CAAE,CA8BvC;AAiWD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,0BAA0B,GAAG,KAAK,EAAE,CA6LhF;AA0BD,MAAM,WAAW,uBAAuB;IACtC,mFAAmF;IACnF,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,yDAAyD;IACzD,QAAQ,CAAC,EAAE,IAAI,CAAC;CACjB;AAED,2EAA2E;AAC3E,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,KAAK,EAAE,EACb,OAAO,CAAC,EAAE,uBAAuB,GAChC,KAAK,EAAE,CAwBT"}

package/dist/papirus.js

@@ -4038,11 +4038,11 @@ function contourProximityPenalty(a, b, obstacles) {
 	const proximity = 1 - minDist / CONTOUR_BAND;
 	return segLen * (CONTOUR_PENALTY / 10) * proximity;
 }
-/** Push along dir until outside expanded parent (and at least exitDistance). */
-function computeStartExit(from, fromDir, parent, margin, exitDistance) {
+/** Push along dir until outside expanded blocker (and at least exitDistance). */
+function computeStartExit(from, fromDir, blocker, margin, exitDistance) {
 	let p = moveByDir$1(from, fromDir, exitDistance);
-	if (!parent) return p;
-	const expanded = expandRect(parent, margin);
+	if (!blocker) return p;
+	const expanded = expandRect(blocker, margin);
 	let guard = 0;
 	while (pointInOpenInterior(p, expanded) && guard++ < 64) p = moveByDir$1(p, fromDir, exitDistance);
 	if (pointInOpenInterior(p, expanded)) {
@@ -4076,6 +4076,158 @@ function computeStartExit(from, fromDir, parent, margin, exitDistance) {
 	}
 	return p;
 }
+function pointInRectClosed(p, r) {
+	return p.x >= r.x && p.x <= r.x + r.width && p.y >= r.y && p.y <= r.y + r.height;
+}
+/**
+* Push a same-side exit/entry far enough that the orthogonal span between
+* `spanA` and `spanB` clears every `others` obstacle (siblings in a stack).
+*/
+function clearCorridorOfOthers(exit, dir, others, spanA, spanB, margin) {
+	if (others.length === 0) return exit;
+	let p = { ...exit };
+	const y1 = Math.min(spanA.y, spanB.y);
+	const y2 = Math.max(spanA.y, spanB.y);
+	const x1 = Math.min(spanA.x, spanB.x);
+	const x2 = Math.max(spanA.x, spanB.x);
+	for (let guard = 0; guard < 64; guard++) {
+		let blocked;
+		for (const raw of others) {
+			const o = expandRect(raw, margin);
+			if (dir === "left" || dir === "right") {
+				if (p.x > o.x && p.x < o.x + o.width && y2 > o.y && y1 < o.y + o.height) {
+					blocked = o;
+					break;
+				}
+			} else if (p.y > o.y && p.y < o.y + o.height && x2 > o.x && x1 < o.x + o.width) {
+				blocked = o;
+				break;
+			}
+		}
+		if (!blocked) return p;
+		switch (dir) {
+			case "left":
+				p = {
+					x: blocked.x - 1,
+					y: p.y
+				};
+				break;
+			case "right":
+				p = {
+					x: blocked.x + blocked.width + 1,
+					y: p.y
+				};
+				break;
+			case "top":
+				p = {
+					x: p.x,
+					y: blocked.y - 1
+				};
+				break;
+			case "bottom":
+				p = {
+					x: p.x,
+					y: blocked.y + blocked.height + 1
+				};
+				break;
+		}
+	}
+	return p;
+}
+/**
+* When same-side exits still share an axis that crosses a blocker (top→top over
+* a stacked target), slide the *start* exit to the nearer free side. Keep
+* endEntry on the approach ray at `to` so the final stub stays ⊥ to the side.
+*/
+function offsetSameSideAroundBlockers(startExit, endEntry, dir, blockers, margin, from, to) {
+	if (blockers.length === 0) return {
+		startExit,
+		endEntry
+	};
+	let s = { ...startExit };
+	const e = { ...endEntry };
+	const y1 = Math.min(from.y, to.y, s.y, e.y);
+	const y2 = Math.max(from.y, to.y, s.y, e.y);
+	const x1 = Math.min(from.x, to.x, s.x, e.x);
+	const x2 = Math.max(from.x, to.x, s.x, e.x);
+	for (const raw of blockers) {
+		const o = expandRect(raw, margin);
+		if (dir === "top" || dir === "bottom") {
+			if (!(s.x > o.x && s.x < o.x + o.width && y2 > o.y && y1 < o.y + o.height)) continue;
+			const leftX = o.x - 1;
+			const rightX = o.x + o.width + 1;
+			s = {
+				...s,
+				x: s.x <= o.x + o.width / 2 ? leftX : rightX
+			};
+		} else {
+			if (!(s.y > o.y && s.y < o.y + o.height && x2 > o.x && x1 < o.x + o.width)) continue;
+			const topY = o.y - 1;
+			const bottomY = o.y + o.height + 1;
+			s = {
+				...s,
+				y: s.y <= o.y + o.height / 2 ? topY : bottomY
+			};
+		}
+	}
+	return {
+		startExit: s,
+		endEntry: e
+	};
+}
+/** True when collapsing same-side exits onto one rail would not pierce blockers. */
+function canAlignSameSideExits(dir, startExit, endEntry, from, to, blockers, margin) {
+	let alignedStart = { ...startExit };
+	let alignedEnd = { ...endEntry };
+	if (dir === "left") {
+		const x = Math.min(startExit.x, endEntry.x);
+		alignedStart = {
+			...alignedStart,
+			x
+		};
+		alignedEnd = {
+			...alignedEnd,
+			x
+		};
+	} else if (dir === "right") {
+		const x = Math.max(startExit.x, endEntry.x);
+		alignedStart = {
+			...alignedStart,
+			x
+		};
+		alignedEnd = {
+			...alignedEnd,
+			x
+		};
+	} else if (dir === "top") {
+		const y = Math.min(startExit.y, endEntry.y);
+		alignedStart = {
+			...alignedStart,
+			y
+		};
+		alignedEnd = {
+			...alignedEnd,
+			y
+		};
+	} else {
+		const y = Math.max(startExit.y, endEntry.y);
+		alignedStart = {
+			...alignedStart,
+			y
+		};
+		alignedEnd = {
+			...alignedEnd,
+			y
+		};
+	}
+	for (const raw of blockers) {
+		const o = expandRect(raw, margin);
+		if (segmentIntersectsOpenInterior(from, alignedStart, o)) return false;
+		if (segmentIntersectsOpenInterior(alignedEnd, to, o)) return false;
+		if (segmentIntersectsOpenInterior(alignedStart, alignedEnd, o)) return false;
+	}
+	return true;
+}
 function computeEndEntry(to, toDir, exitDistance, rawTarget, rawNeighbor) {
 	const stub = moveByDir$1(to, toDir, exitDistance);
 	if (!rawTarget || !rawNeighbor) return stub;
@@ -4506,14 +4658,69 @@ function routeMidPath(startExit, endEntry, obstacles, parent, target, margin) {
 function routeOrthogonalAround(input) {
 	const margin = input.margin ?? DEFAULT_MARGIN;
 	const exitDistance = input.exitDistance ?? DEFAULT_EXIT;
-	const exitBlocker = input.parent ?? input.source;
-	const rawStartExit = computeStartExit(input.from, input.fromDir, exitBlocker, margin, exitDistance);
-	const gapNeighbor = input.parent ?? input.source;
+	const others = input.others ?? [];
+	const internalParent = !!input.parent && pointInRectClosed(input.from, input.parent) && pointInRectClosed(input.to, input.parent);
+	const exitBlocker = internalParent ? input.source : input.parent ?? input.source;
+	let rawStartExit = computeStartExit(input.from, input.fromDir, exitBlocker, margin, exitDistance);
+	const gapNeighbor = internalParent ? input.source : input.parent ?? input.source;
 	const peeledTargetNeighbor = input.target && gapNeighbor ? peelForFacingGap(input.target, gapNeighbor) : null;
-	const rawEndEntry = computeEndEntry(input.to, input.toDir, exitDistance, peeledTargetNeighbor?.a, peeledTargetNeighbor?.b);
+	let rawEndEntry = computeEndEntry(input.to, input.toDir, exitDistance, peeledTargetNeighbor?.a, peeledTargetNeighbor?.b);
+	if (input.fromDir === input.toDir) {
+		const sameSideBlockers = [...others];
+		if (input.target) sameSideBlockers.push(input.target);
+		if (input.source) sameSideBlockers.push(input.source);
+		if (sameSideBlockers.length > 0) {
+			rawStartExit = clearCorridorOfOthers(rawStartExit, input.fromDir, sameSideBlockers, input.from, input.to, margin);
+			rawEndEntry = clearCorridorOfOthers(rawEndEntry, input.toDir, sameSideBlockers, input.from, input.to, margin);
+			({startExit: rawStartExit, endEntry: rawEndEntry} = offsetSameSideAroundBlockers(rawStartExit, rawEndEntry, input.fromDir, sameSideBlockers, margin, input.from, input.to));
+		}
+		if (canAlignSameSideExits(input.fromDir, rawStartExit, rawEndEntry, input.from, input.to, sameSideBlockers.length > 0 ? sameSideBlockers : [input.target, input.source].filter((r) => !!r), margin)) {
+			if (input.fromDir === "left") {
+				const x = Math.min(rawStartExit.x, rawEndEntry.x);
+				rawStartExit = {
+					...rawStartExit,
+					x
+				};
+				rawEndEntry = {
+					...rawEndEntry,
+					x
+				};
+			} else if (input.fromDir === "right") {
+				const x = Math.max(rawStartExit.x, rawEndEntry.x);
+				rawStartExit = {
+					...rawStartExit,
+					x
+				};
+				rawEndEntry = {
+					...rawEndEntry,
+					x
+				};
+			} else if (input.fromDir === "top") {
+				const y = Math.min(rawStartExit.y, rawEndEntry.y);
+				rawStartExit = {
+					...rawStartExit,
+					y
+				};
+				rawEndEntry = {
+					...rawEndEntry,
+					y
+				};
+			} else if (input.fromDir === "bottom") {
+				const y = Math.max(rawStartExit.y, rawEndEntry.y);
+				rawStartExit = {
+					...rawStartExit,
+					y
+				};
+				rawEndEntry = {
+					...rawEndEntry,
+					y
+				};
+			}
+		}
+	}
 	const { startExit, endEntry } = clampFacingExitEntry(input.from, input.to, input.fromDir, input.toDir, rawStartExit, rawEndEntry);
 	let sourceObs = input.source ? expandRect(input.source, margin) : void 0;
-	let parentObs = input.parent ? expandRect(input.parent, margin) : void 0;
+	let parentObs = input.parent && !internalParent ? expandRect(input.parent, margin) : void 0;
 	let targetObs = input.target ? expandRect(input.target, margin) : void 0;
 	const openCorridor = (expA, expB, inputA, inputB) => {
 		const peeled = peelForFacingGap(inputA, inputB);
@@ -4527,8 +4734,9 @@ function routeOrthogonalAround(input) {
 	if (sourceObs) obstacles.push(sourceObs);
 	if (parentObs) obstacles.push(parentObs);
 	if (targetObs) obstacles.push(targetObs);
-	const peeledLattice = input.parent && input.target ? peelForFacingGap(input.parent, input.target) : input.source && input.target ? peelForFacingGap(input.source, input.target) : null;
-	const mid = routeMidPath(startExit, endEntry, obstacles, peeledLattice?.a ?? input.parent ?? input.source, peeledLattice?.b ?? input.target, margin).slice(1, -1);
+	for (const other of others) obstacles.push(expandRect(other, margin));
+	const peeledLattice = !internalParent && input.parent && input.target ? peelForFacingGap(input.parent, input.target) : input.source && input.target ? peelForFacingGap(input.source, input.target) : null;
+	const mid = routeMidPath(startExit, endEntry, obstacles, peeledLattice?.a ?? (internalParent ? input.source : input.parent ?? input.source), peeledLattice?.b ?? input.target, margin).slice(1, -1);
 	const lastMid = mid[mid.length - 1];
 	const alreadyApproaching = !!lastMid && isOnApproachOutside(lastMid, input.to, input.toDir, 1);
 	return simplifyPath$1(ensureOrthogonalPath([
@@ -4537,19 +4745,60 @@ function routeOrthogonalAround(input) {
 		...mid,
 		...alreadyApproaching ? [] : [endEntry],
 		input.to
-	]));
+	], {
+		exitDir: input.fromDir,
+		enterDir: input.toDir
+	}));
+}
+/** Elbow that leaves `prev` along `dir` first (source exit). */
+function elbowExitFirst(prev, next, dir) {
+	switch (dir) {
+		case "left":
+		case "right": return {
+			x: next.x,
+			y: prev.y
+		};
+		case "top":
+		case "bottom": return {
+			x: prev.x,
+			y: next.y
+		};
+	}
+}
+/** Elbow that arrives at `next` along `dir` last (target entry). */
+function elbowEnterLast(prev, next, dir) {
+	switch (dir) {
+		case "left":
+		case "right": return {
+			x: prev.x,
+			y: next.y
+		};
+		case "top":
+		case "bottom": return {
+			x: next.x,
+			y: prev.y
+		};
+	}
 }
 /** Insert elbows so no consecutive points form a diagonal (safety net). */
-function ensureOrthogonalPath(path) {
+function ensureOrthogonalPath(path, options) {
 	if (path.length < 2) return path;
 	const out = [path[0]];
 	for (let i = 1; i < path.length; i++) {
 		const prev = out[out.length - 1];
 		const next = path[i];
-		if (!(Math.abs(prev.x - next.x) < .001 || Math.abs(prev.y - next.y) < .001)) out.push({
-			x: prev.x,
-			y: next.y
-		});
+		if (!(Math.abs(prev.x - next.x) < .001 || Math.abs(prev.y - next.y) < .001)) {
+			const isFirst = out.length === 1;
+			const isLast = i === path.length - 1;
+			let elbow;
+			if (isFirst && options?.exitDir) elbow = elbowExitFirst(prev, next, options.exitDir);
+			else if (isLast && options?.enterDir) elbow = elbowEnterLast(prev, next, options.enterDir);
+			else elbow = {
+				x: prev.x,
+				y: next.y
+			};
+			out.push(elbow);
+		}
 		out.push(next);
 	}
 	return out;
@@ -4582,17 +4831,58 @@ function routeDebug(tag, payload) {
 function isSide(v) {
 	return v === "top" || v === "right" || v === "bottom" || v === "left";
 }
+function pointInObstacle(p, o) {
+	return p.x >= o.x && p.x <= o.x + o.width && p.y >= o.y && p.y <= o.y + o.height;
+}
+function pointOnObstacleOutline(p, o, tol = 1) {
+	const onVertical = (Math.abs(p.x - o.x) < tol || Math.abs(p.x - (o.x + o.width)) < tol) && p.y >= o.y - tol && p.y <= o.y + o.height + tol;
+	const onHorizontal = (Math.abs(p.y - o.y) < tol || Math.abs(p.y - (o.y + o.height)) < tol) && p.x >= o.x - tol && p.x <= o.x + o.width + tol;
+	return onVertical || onHorizontal;
+}
+/** Prefer the tightest rect that contains `p` (source/composite vs ancestor). */
+function smallestContaining(p, obstacles, exclude) {
+	let best;
+	let bestArea = Infinity;
+	for (const o of obstacles) {
+		if (exclude.has(o) || !pointInObstacle(p, o)) continue;
+		const area = o.width * o.height;
+		if (area < bestArea) {
+			best = o;
+			bestArea = area;
+		}
+	}
+	return best;
+}
 function resolveRoutingRoles(from, to, obstacles) {
-	const target = obstacles.find((o) => o.role === "target") ?? obstacles.find((o) => {
-		const onVertical = (Math.abs(to.x - o.x) < 1 || Math.abs(to.x - (o.x + o.width)) < 1) && to.y >= o.y - 1 && to.y <= o.y + o.height + 1;
-		const onHorizontal = (Math.abs(to.y - o.y) < 1 || Math.abs(to.y - (o.y + o.height)) < 1) && to.x >= o.x - 1 && to.x <= o.x + o.width + 1;
-		return onVertical || onHorizontal;
-	});
-	const source = obstacles.find((o) => o.role === "source" && o !== target);
+	const target = obstacles.find((o) => o.role === "target") ?? obstacles.find((o) => pointOnObstacleOutline(to, o));
+	const excludeForSource = /* @__PURE__ */ new Set();
+	if (target) excludeForSource.add(target);
+	const source = obstacles.find((o) => o.role === "source" && o !== target) ?? smallestContaining(from, obstacles, excludeForSource);
+	const excludeForParent = /* @__PURE__ */ new Set();
+	if (target) excludeForParent.add(target);
+	if (source) excludeForParent.add(source);
+	const parent = smallestContaining(from, obstacles, excludeForParent);
+	const spanPad = 40;
+	const span = {
+		x: Math.min(from.x, to.x) - spanPad,
+		y: Math.min(from.y, to.y) - spanPad,
+		width: Math.abs(to.x - from.x) + spanPad * 2,
+		height: Math.abs(to.y - from.y) + spanPad * 2
+	};
+	const rectsOverlap = (a, b) => a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
 	return {
-		parent: obstacles.find((o) => o !== target && o !== source && o.role !== "source" && from.x >= o.x && from.x <= o.x + o.width && from.y >= o.y && from.y <= o.y + o.height),
+		parent,
 		source,
-		target
+		target,
+		others: obstacles.filter((o) => {
+			if (o === parent || o === source || o === target) return false;
+			if (pointInObstacle(from, o) && pointInObstacle(to, o)) return false;
+			if (parent) return pointInObstacle({
+				x: o.x + o.width / 2,
+				y: o.y + o.height / 2
+			}, parent);
+			return rectsOverlap(o, span);
+		})
 	};
 }
 var MIN_SEGMENT_LENGTH = 20;
@@ -4702,10 +4992,11 @@ function inferApproachDir(from, to) {
 }
 /** Which side of `target` the attachment point `to` lies on (border hit). */
 function sideOfPointOnRect(to, target) {
-	const onLeft = Math.abs(to.x - target.x) <= 1;
-	const onRight = Math.abs(to.x - (target.x + target.width)) <= 1;
-	const onTop = Math.abs(to.y - target.y) <= 1;
-	const onBottom = Math.abs(to.y - (target.y + target.height)) <= 1;
+	const tol = 6;
+	const onLeft = Math.abs(to.x - target.x) <= tol;
+	const onRight = Math.abs(to.x - (target.x + target.width)) <= tol;
+	const onTop = Math.abs(to.y - target.y) <= tol;
+	const onBottom = Math.abs(to.y - (target.y + target.height)) <= tol;
 	if (onTop && !onLeft && !onRight) return "top";
 	if (onBottom && !onLeft && !onRight) return "bottom";
 	if (onLeft && !onTop && !onBottom) return "left";
@@ -5042,7 +5333,7 @@ var PolylinePathStrategy = class {
 			];
 		}
 		if (!selfLoop && isSide(fromDir) && isSide(toDir)) {
-			const { parent, source, target } = resolveRoutingRoles(from, to, obstacles);
+			const { parent, source, target, others } = resolveRoutingRoles(from, to, obstacles);
 			const approachDir = resolveApproachDir(from, to, toDir, target);
 			if ((parent || source || target) && isSide(approachDir)) return finish("routeOrthogonalAround", routeOrthogonalAround({
 				from,
@@ -5052,6 +5343,7 @@ var PolylinePathStrategy = class {
 				parent,
 				source,
 				target,
+				others,
 				margin: 4,
 				exitDistance: 20
 			}));
@@ -5063,7 +5355,8 @@ var PolylinePathStrategy = class {
 				roles: {
 					parent: parent?.id,
 					source: source?.id,
-					target: target?.id
+					target: target?.id,
+					others: others.map((o) => o.id).filter(Boolean)
 				},
 				obstacleRoles: obstacles.map((o) => `${o.id}:${o.role ?? "?"}`)
 			});
@@ -8098,22 +8391,18 @@ var EdgeEndpointUpdater = class {
 		}
 	}
 	/**
-	* When nodes are clearly stacked, retarget side ports that would force the
-	* polyline to approach along the long edge (contour crawl).
+	* When nodes are clearly stacked/side-by-side, assign facing sides only to
+	* unset endpoints. Intentional ports (including lateral reconnect with
+	* attachToOutline off) and outlineParams are kept — orthogonal routing clears
+	* same-side wraps around the stack.
 	*
 	* Uses bounding-box gaps (not center dx/dy): a large horizontal offset must not
 	* flip bottom→left while the source is still below the target — that reintroduces
 	* the left-edge contour jog when the user drags the node leftward.
-	*
-	* - Always set facing ports when unset (so lockAnchors does not pick left/right).
-	* - Rewrite target left/right → top/bottom when there is a clear vertical gap.
-	* - Do not rewrite an intentional source side exit (e.g. left exit from a nested
-	*   component around its parent).
 	*/
 	preferFacingSidePorts(edge, fromNode, toNode) {
 		if (!edge.lockAnchors) return;
 		if (!isNodeEdgeEndpoint(edge.from) || !isNodeEdgeEndpoint(edge.to)) return;
-		if (edge.from.outlineParam !== void 0 || edge.to.outlineParam !== void 0) return;
 		const fromB = fromNode.getBounds();
 		const toB = toNode.getBounds();
 		const fromBelow = fromB.y - (toB.y + toB.height);
@@ -8122,22 +8411,20 @@ var EdgeEndpointUpdater = class {
 		const fromLeft = toB.x - (fromB.x + fromB.width);
 		const fc = fromNode.getCenter();
 		const tc = toNode.getCenter();
+		const curFrom = this.endpointSide(edge.from, fromNode);
+		const curTo = this.endpointSide(edge.to, toNode);
 		if (fromBelow > 0 || fromAbove > 0) {
 			const fromSide = fromBelow > 0 ? "top" : "bottom";
 			const toSide = fromBelow > 0 ? "bottom" : "top";
-			const curFrom = this.portSide(edge.from.portId);
-			const curTo = this.portSide(edge.to.portId);
 			if (!curFrom) this.setEndpointSidePort(edge, "from", fromNode, fromSide, tc);
-			if (!curTo || curTo === "left" || curTo === "right" || curTo === toSide) this.setEndpointSidePort(edge, "to", toNode, toSide, fc);
+			if (!curTo) this.setEndpointSidePort(edge, "to", toNode, toSide, fc);
 			return;
 		}
 		if (fromLeft > 0 || fromRight > 0) {
 			const fromSide = fromRight > 0 ? "left" : "right";
 			const toSide = fromRight > 0 ? "right" : "left";
-			const curFrom = this.portSide(edge.from.portId);
-			const curTo = this.portSide(edge.to.portId);
 			if (!curFrom) this.setEndpointSidePort(edge, "from", fromNode, fromSide, tc);
-			if (!curTo || curTo === "top" || curTo === "bottom") this.setEndpointSidePort(edge, "to", toNode, toSide, fc);
+			if (!curTo) this.setEndpointSidePort(edge, "to", toNode, toSide, fc);
 		}
 	}
 	portSide(portId) {
@@ -8145,6 +8432,13 @@ var EdgeEndpointUpdater = class {
 		const side = portId.slice(ANCHOR_PORT_PREFIX.length).split(":")[0];
 		if (side === "top" || side === "right" || side === "bottom" || side === "left") return side;
 	}
+	endpointSide(endpoint, node) {
+		if (!isNodeEdgeEndpoint(endpoint)) return void 0;
+		const fromPort = this.portSide(endpoint.portId);
+		if (fromPort) return fromPort;
+		if (endpoint.outlineParam === void 0) return void 0;
+		return getDirectionFromOutlineParam(endpoint.outlineParam, node.getBounds());
+	}
 	nearestAnchorOnSide(node, side, toward) {
 		const anchors = node.getAnchors().filter((a) => a.id.startsWith(`${side}:`));
 		if (anchors.length === 0) return null;