@oh-just-another/scene 0.57.0

package/dist/edge-curve.js

@@ -0,0 +1,72 @@
+import { CURVE_CATMULL_TENSION, CURVE_END_TANGENT_MAX_PX, CURVE_END_TANGENT_RATIO, CURVE_FLATTEN_SEGMENTS, } from "./constants.js";
+const req = (v) => {
+    if (v === undefined)
+        throw new Error("packages/scene: index out of range");
+    return v;
+};
+/**
+ * Cubic bezier from `from` to `to` that LEAVES `from` along `dirFrom` and
+ * ENTERS `to` along `-dirTo` (both unit outward directions). This makes a
+ * connector exit/enter perpendicular to an element's edge (flowchart look),
+ * instead of always bowing to one fixed side. Control-arm length scales with
+ * the endpoint distance (capped).
+ */
+export const cubicWithEndTangents = (from, to, dirFrom, dirTo) => {
+    const dist = Math.hypot(to.x - from.x, to.y - from.y);
+    const d = Math.min(dist * CURVE_END_TANGENT_RATIO, CURVE_END_TANGENT_MAX_PX);
+    return {
+        c1: { x: from.x + dirFrom.x * d, y: from.y + dirFrom.y * d },
+        c2: { x: to.x + dirTo.x * d, y: to.y + dirTo.y * d },
+        to,
+    };
+};
+/**
+ * Catmull-Rom spline through `pts` as cubic bezier segments. Each segment
+ * Pi→Pi+1 uses tangents from the neighbouring points; endpoints duplicate
+ * themselves. The curve passes through every point with no corners. Used for
+ * a waypointed curve (the bends define the shape).
+ */
+export const catmullRomBeziers = (pts) => {
+    const segs = [];
+    const k = CURVE_CATMULL_TENSION;
+    for (let i = 0; i < pts.length - 1; i++) {
+        const p1 = req(pts[i]);
+        const p2 = req(pts[i + 1]);
+        const p0 = pts[i - 1] ?? p1;
+        const p3 = pts[i + 2] ?? p2;
+        segs.push({
+            c1: { x: p1.x + (p2.x - p0.x) / k, y: p1.y + (p2.y - p0.y) / k },
+            c2: { x: p2.x - (p3.x - p1.x) / k, y: p2.y - (p3.y - p1.y) / k },
+            to: p2,
+        });
+    }
+    return segs;
+};
+/** Point on a cubic bezier at parameter `t` (0..1). de Casteljau / Bernstein. */
+export const cubicAt = (p0, c1, c2, p1, t) => {
+    const u = 1 - t;
+    const a = u * u * u;
+    const b = 3 * u * u * t;
+    const c = 3 * u * t * t;
+    const d = t * t * t;
+    return {
+        x: a * p0.x + b * c1.x + c * c2.x + d * p1.x,
+        y: a * p0.y + b * c1.y + c * c2.y + d * p1.y,
+    };
+};
+/**
+ * Flatten a `start` + cubic-segment list into a dense point list (for
+ * hit-testing / bounds). Includes `start` then `perSegment` samples per cubic.
+ */
+export const flattenSegments = (start, segments, perSegment = CURVE_FLATTEN_SEGMENTS) => {
+    const out = [start];
+    let prev = start;
+    for (const s of segments) {
+        for (let i = 1; i <= perSegment; i++) {
+            out.push(cubicAt(prev, s.c1, s.c2, s.to, i / perSegment));
+        }
+        prev = s.to;
+    }
+    return out;
+};
+//# sourceMappingURL=edge-curve.js.map

package/dist/edge-curve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-curve.js","sourceRoot":"","sources":["../src/edge-curve.ts"],"names":[],"mappings":"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"}

package/dist/edge-geometry.d.ts

@@ -0,0 +1,96 @@
+import type { Bounds, Vec2 } from "@oh-just-another/types";
+import { type BezierSegment } from "./edge-curve.js";
+import type { Link, LinkEndpoint } from "./edge.js";
+import type { Scene } from "./scene.js";
+/**
+ * --- Self-loop geometry ---
+ *
+ * A link whose `from` and `to` both bind to the SAME element. Routed OUTSIDE the
+ * element: curved → an arc, orthogonal/straight → a rectangular loop. Without
+ * this both ends collapse to (nearly) the same point and the link renders as a
+ * flat line on/across the shape.
+ */
+interface SelfLoopSpec {
+    readonly p1: Vec2;
+    readonly n1: Vec2;
+    readonly p2: Vec2;
+    readonly n2: Vec2;
+    readonly bounds: Bounds;
+}
+/**
+ * Resolve a self-loop's two outline exit points + outward normals, or `null`
+ * when the link isn't a self-loop. When both ends land on the same point
+ * (centre / floating / same anchor) they're spread along the chosen side
+ * (default top) so the loop has width.
+ */
+export declare const getSelfLoopSpec: (scene: Scene, edge: Link) => SelfLoopSpec | null;
+/**
+ * Resolve a single `LinkEndpoint` to a world-space point.
+ *
+ * `kind: "point"` returns the stored position as-is. `kind: "anchor"`
+ * looks up the referenced shape and resolves the anchor through
+ * `getAnchorWorld` — picking up the shape's current position / rotation /
+ * scale automatically.
+ *
+ * Returns `null` when an `anchor` endpoint references a shape id that
+ * isn't (or no longer is) in the scene. Callers usually drop the edge
+ * from the render pass in that case.
+ *
+ * `toward` is only consulted for `floating` endpoints — it's the world
+ * point of the *other* endpoint, which the floating side aims at. When
+ * omitted, a floating endpoint resolves to the shape's centre (used as a
+ * provisional value before the partner is known; see `getLinkPath`).
+ */
+export declare const getLinkEndpointWorld: (scene: Scene, endpoint: LinkEndpoint, toward?: Vec2) => Vec2 | null;
+/**
+ * Produce the full polyline an edge draws, in world coordinates:
+ * `[from, ...waypoints, to]` for `straight` routing; an axis-aligned
+ * elbow for `orthogonal`; the two endpoints for `bezier` (control points
+ * are derived by the renderer).
+ *
+ * Returns `null` if either endpoint can't be resolved. Honours an
+ * explicit `edge.waypoints` array on every routing — hosts can pre-route
+ * an edge with custom bends.
+ */
+export declare const getLinkPath: (scene: Scene, edge: Link) => readonly Vec2[] | null;
+/**
+ * Cubic-bezier representation of a curved (bezier) edge: the start point and
+ * the list of cubic segments. A no-waypoint span is a single cubic whose
+ * control arms follow the endpoints' edge normals (exits/enters perpendicular
+ * to the element edge — flowchart look); a waypointed span is a Catmull-Rom
+ * spline through the bends. Returns `null` for non-bezier / unresolvable.
+ */
+export declare const getLinkCurveSegments: (scene: Scene, edge: Link) => {
+    start: Vec2;
+    segments: BezierSegment[];
+} | null;
+/**
+ * Hit-test / bounds polyline for an edge: the routed path, except a curved
+ * (bezier) edge is flattened to follow the drawn arc (so clicking the
+ * visible curve — which bows away from the straight chord — actually hits).
+ * Returns `null` when the path is unresolvable.
+ */
+export declare const getLinkCurvePoints: (scene: Scene, edge: Link) => readonly Vec2[] | null;
+/**
+ * Per-span "add a waypoint" handle positions for a selected link's bend
+ * editing — one handle per logical span of `[from, ...waypoints, to]`, index i
+ * being the span between point i and i+1 (what `beginWaypointDrag(i, insert)`
+ * expects). The handle sits at the VISUAL middle of its span:
+ *   - bezier — the curve point at `t=0.5` of that span's cubic, so the handle
+ *     lands ON the drawn arc (not the straight chord beside it);
+ *   - straight — the chord midpoint (the span IS straight).
+ * Returns `null` for orthogonal (elbow) links — their segment handles are
+ * computed from the routed path by the caller — or when unresolvable.
+ */
+export declare const getLinkWaypointMidpoints: (scene: Scene, edge: Link) => Vec2[] | null;
+/**
+ * Topmost edge under `worldPoint`, or `null` if none is within
+ * `threshold` world-pixels of any segment. Iterates edges in layer
+ * order; later layers (rendered on top) win when paths overlap.
+ *
+ * Curved (bezier) edges are tested against the flattened curve (via
+ * `getLinkCurvePoints`) so the clickable line matches the drawn arc.
+ */
+export declare const findLinkAt: (scene: Scene, worldPoint: Vec2, threshold?: number) => Link | null;
+export {};
+//# sourceMappingURL=edge-geometry.d.ts.map

package/dist/edge-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-geometry.d.ts","sourceRoot":"","sources":["../src/edge-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAa,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAItE,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAIpD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAQxC;;;;;;;GAOG;AACH,UAAU,YAAY;IACpB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AA2BD;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,KAAK,EAAE,MAAM,IAAI,KAAG,YAAY,GAAG,IA6BzE,CAAC;AAsGF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,KAAK,EACZ,UAAU,YAAY,EACtB,SAAS,IAAI,KACZ,IAAI,GAAG,IAQT,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,KAAK,EAAE,MAAM,IAAI,KAAG,SAAS,IAAI,EAAE,GAAG,IA8FxE,CAAC;AA+DF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,KAAK,EACZ,MAAM,IAAI,KACT;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,aAAa,EAAE,CAAA;CAAE,GAAG,IAe/C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,KAAK,EAAE,MAAM,IAAI,KAAG,SAAS,IAAI,EAAE,GAAG,IAK/E,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,GAAI,OAAO,KAAK,EAAE,MAAM,IAAI,KAAG,IAAI,EAAE,GAAG,IAuB5E,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,KAAK,EAAE,YAAY,IAAI,EAAE,kBAAa,KAAG,IAAI,GAAG,IAkBjF,CAAC"}

package/dist/edge-geometry.js

@@ -0,0 +1,467 @@
+import { intersect } from "@oh-just-another/math";
+import { getAnchorOutwardNormal, getAnchorWorld } from "./anchors.js";
+import { SELF_LOOP_CURVE_ARM_FACTOR, SELF_LOOP_SIZE, SELF_LOOP_SPREAD } from "./constants.js";
+import { catmullRomBeziers, cubicAt, cubicWithEndTangents, flattenSegments, } from "./edge-curve.js";
+import { headingForEdgePoint } from "./heading.js";
+import { getOutlinePoint, getOutlineSampler } from "./outline.js";
+import { getElementWorldBounds } from "./shape.js";
+import { getElement } from "./queries.js";
+const req = (v) => {
+    if (v === undefined)
+        throw new Error("packages/scene: index out of range");
+    return v;
+};
+const endpointElementOf = (ep) => ep.kind === "point" ? null : ep.elementId;
+/** Snap a unit vector to the dominant axis (corner anchors give diagonals). */
+const axisSnap = (n) => Math.abs(n.x) >= Math.abs(n.y) ? { x: Math.sign(n.x) || 0, y: 0 } : { x: 0, y: Math.sign(n.y) };
+const outwardNormalFor = (shape, ep, p) => {
+    if (ep.kind === "anchor") {
+        const n = axisSnap(getAnchorOutwardNormal(shape, ep.anchor));
+        if (n.x !== 0 || n.y !== 0)
+            return n;
+    }
+    const h = axisSnap(headingForEdgePoint(shape, p));
+    return h.x !== 0 || h.y !== 0 ? h : { x: 0, y: -1 };
+};
+const edgeMidpoint = (b, n) => {
+    const cx = b.x + b.width / 2;
+    const cy = b.y + b.height / 2;
+    if (n.y < 0)
+        return { x: cx, y: b.y };
+    if (n.y > 0)
+        return { x: cx, y: b.y + b.height };
+    if (n.x < 0)
+        return { x: b.x, y: cy };
+    return { x: b.x + b.width, y: cy };
+};
+/**
+ * Resolve a self-loop's two outline exit points + outward normals, or `null`
+ * when the link isn't a self-loop. When both ends land on the same point
+ * (centre / floating / same anchor) they're spread along the chosen side
+ * (default top) so the loop has width.
+ */
+export const getSelfLoopSpec = (scene, edge) => {
+    const el = endpointElementOf(edge.from);
+    if (!el || el !== endpointElementOf(edge.to))
+        return null;
+    const shape = getElement(scene, el);
+    if (!shape)
+        return null;
+    const bounds = getElementWorldBounds(shape);
+    const w1 = getLinkEndpointWorld(scene, edge.from);
+    const w2 = getLinkEndpointWorld(scene, edge.to);
+    if (!w1 || !w2)
+        return null;
+    let p1 = w1;
+    let p2 = w2;
+    let n1 = outwardNormalFor(shape, edge.from, p1);
+    let n2 = outwardNormalFor(shape, edge.to, p2);
+    if (Math.hypot(p2.x - p1.x, p2.y - p1.y) < 1) {
+        // Degenerate: both ends at one point → loop on n1's side (default top),
+        // two points spread symmetrically along that edge.
+        const side = n1.x !== 0 || n1.y !== 0 ? n1 : { x: 0, y: -1 };
+        n1 = side;
+        n2 = side;
+        const t = { x: -side.y, y: side.x }; // tangent along the edge
+        const sideLen = side.x !== 0 ? bounds.height : bounds.width;
+        const half = Math.min(SELF_LOOP_SPREAD, sideLen / 3);
+        const mid = edgeMidpoint(bounds, side);
+        p1 = { x: mid.x - t.x * half, y: mid.y - t.y * half };
+        p2 = { x: mid.x + t.x * half, y: mid.y + t.y * half };
+    }
+    return { p1, n1, p2, n2, bounds };
+};
+/** Orthogonal/straight self-loop polyline `[p1, …outside…, p2]`. */
+const selfLoopPolyline = (spec) => {
+    const L = SELF_LOOP_SIZE;
+    const { p1, n1, p2, n2, bounds } = spec;
+    const a1 = { x: p1.x + n1.x * L, y: p1.y + n1.y * L };
+    const a2 = { x: p2.x + n2.x * L, y: p2.y + n2.y * L };
+    const same = n1.x === n2.x && n1.y === n2.y;
+    const opposite = n1.x === -n2.x && n1.y === -n2.y;
+    if (same) {
+        // Staple: both stubs on the same outward level.
+        return [p1, a1, a2, p2];
+    }
+    if (opposite) {
+        // Wrap around one side (the +x side for a vertical pair, +y for horizontal).
+        if (n1.x === 0) {
+            const outX = bounds.x + bounds.width + L;
+            return [p1, a1, { x: outX, y: a1.y }, { x: outX, y: a2.y }, a2, p2];
+        }
+        const outY = bounds.y + bounds.height + L;
+        return [p1, a1, { x: a1.x, y: outY }, { x: a2.x, y: outY }, a2, p2];
+    }
+    // Perpendicular: route through the outside corner.
+    const corner = { x: n1.y !== 0 ? a2.x : a1.x, y: n1.y !== 0 ? a1.y : a2.y };
+    return [p1, a1, corner, a2, p2];
+};
+/** Curved self-loop: a single cubic that bows out along both normals. */
+const selfLoopCurve = (spec) => {
+    const k = SELF_LOOP_SIZE * SELF_LOOP_CURVE_ARM_FACTOR;
+    const { p1, n1, p2, n2 } = spec;
+    return {
+        start: p1,
+        segments: [
+            {
+                c1: { x: p1.x + n1.x * k, y: p1.y + n1.y * k },
+                c2: { x: p2.x + n2.x * k, y: p2.y + n2.y * k },
+                to: p2,
+            },
+        ],
+    };
+};
+/**
+ * World-space centre of a shape's bounding box. Origin of the ray used to
+ * resolve a `floating` endpoint.
+ */
+const shapeCentre = (shape) => {
+    const b = getElementWorldBounds(shape);
+    return { x: b.x + b.width / 2, y: b.y + b.height / 2 };
+};
+/**
+ * Number of segments the outline is sampled into when intersecting it with
+ * the floating-endpoint ray. 96 is smooth enough for ellipses at high zoom
+ * without being a hot-loop cost (resolved once per edge per frame).
+ */
+const FLOATING_OUTLINE_SAMPLES = 96;
+/**
+ * Resolve a `floating` endpoint: the point where the shape's outline is
+ * crossed by the ray from the shape's centre toward `toward` (the other
+ * endpoint). Slides along the perimeter as either shape moves, always
+ * entering from the side facing the partner.
+ *
+ * Falls back to the centre when the ray is degenerate (partner at the
+ * centre) or the shape has no outline sampler. Picks the crossing nearest
+ * to `toward` so a convex shape connects on its outward-facing side.
+ */
+const floatingOutlineWorld = (shape, toward) => {
+    const centre = shapeCentre(shape);
+    const dx = toward.x - centre.x;
+    const dy = toward.y - centre.y;
+    if (Math.abs(dx) < 1e-6 && Math.abs(dy) < 1e-6)
+        return centre;
+    const sampler = getOutlineSampler(shape.type);
+    if (!sampler)
+        return centre;
+    // Extend the ray well past `toward` so the crossing is always inside the
+    // tested segment even when `toward` sits on or inside the outline.
+    const len = Math.hypot(dx, dy);
+    const far = { x: centre.x + (dx / len) * 1e6, y: centre.y + (dy / len) * 1e6 };
+    let best = null;
+    let bestDist = Infinity;
+    let prev = getOutlinePoint(shape, 0);
+    for (let i = 1; i <= FLOATING_OUTLINE_SAMPLES; i++) {
+        const cur = getOutlinePoint(shape, i / FLOATING_OUTLINE_SAMPLES);
+        const hit = intersect.segmentSegment(centre, far, prev, cur);
+        if (hit) {
+            const d = Math.hypot(hit.x - toward.x, hit.y - toward.y);
+            if (d < bestDist) {
+                bestDist = d;
+                best = hit;
+            }
+        }
+        prev = cur;
+    }
+    return best ?? centre;
+};
+/**
+ * Resolve a single `LinkEndpoint` to a world-space point.
+ *
+ * `kind: "point"` returns the stored position as-is. `kind: "anchor"`
+ * looks up the referenced shape and resolves the anchor through
+ * `getAnchorWorld` — picking up the shape's current position / rotation /
+ * scale automatically.
+ *
+ * Returns `null` when an `anchor` endpoint references a shape id that
+ * isn't (or no longer is) in the scene. Callers usually drop the edge
+ * from the render pass in that case.
+ *
+ * `toward` is only consulted for `floating` endpoints — it's the world
+ * point of the *other* endpoint, which the floating side aims at. When
+ * omitted, a floating endpoint resolves to the shape's centre (used as a
+ * provisional value before the partner is known; see `getLinkPath`).
+ */
+export const getLinkEndpointWorld = (scene, endpoint, toward) => {
+    if (endpoint.kind === "point")
+        return endpoint.position;
+    const shape = getElement(scene, endpoint.elementId);
+    if (!shape)
+        return null;
+    if (endpoint.kind === "anchor")
+        return getAnchorWorld(shape, endpoint.anchor);
+    if (endpoint.kind === "floating")
+        return floatingOutlineWorld(shape, toward ?? shapeCentre(shape));
+    return getOutlinePoint(shape, endpoint.ratio);
+};
+/**
+ * Produce the full polyline an edge draws, in world coordinates:
+ * `[from, ...waypoints, to]` for `straight` routing; an axis-aligned
+ * elbow for `orthogonal`; the two endpoints for `bezier` (control points
+ * are derived by the renderer).
+ *
+ * Returns `null` if either endpoint can't be resolved. Honours an
+ * explicit `edge.waypoints` array on every routing — hosts can pre-route
+ * an edge with custom bends.
+ */
+export const getLinkPath = (scene, edge) => {
+    // Self-loop (both ends on the same element): route a loop OUTSIDE the shape
+    // (orthogonal/straight → rectangular loop) instead of a flat line. Curved
+    // self-loops are handled in `getLinkCurveSegments`.
+    const loop = getSelfLoopSpec(scene, edge);
+    if (loop)
+        return selfLoopPolyline(loop);
+    // Two-pass resolve so a `floating` endpoint can aim at its partner.
+    // Pass 1: provisional points (floating → its own centre). Pass 2:
+    // re-resolve floating ends toward the partner's provisional point. When
+    // both ends float, each aims at the other shape's centre — stable.
+    const fromProvisional = getLinkEndpointWorld(scene, edge.from);
+    if (!fromProvisional)
+        return null;
+    const toProvisional = getLinkEndpointWorld(scene, edge.to);
+    if (!toProvisional)
+        return null;
+    const from = edge.from.kind === "floating"
+        ? (getLinkEndpointWorld(scene, edge.from, toProvisional) ?? fromProvisional)
+        : fromProvisional;
+    const to = edge.to.kind === "floating"
+        ? (getLinkEndpointWorld(scene, edge.to, fromProvisional) ?? toProvisional)
+        : toProvisional;
+    const routing = edge.routing ?? "straight";
+    if (routing !== "orthogonal") {
+        // straight / bezier: honour user-placed waypoints (free bend points).
+        return [from, ...(edge.waypoints ?? []), to];
+    }
+    // Orthogonal (elbow): the path is the router's output, stored on the edge
+    // as `routedPoints` (corner points between from and to). Elbow points are
+    // NOT user-placed — segments must stay axis-aligned — so `waypoints` are
+    // ignored here. A *defined* `routedPoints` means the editor has routed this
+    // edge — use it verbatim (empty = a straight run). Only fall back to the
+    // side-aware heuristic when the edge has never been routed (undefined),
+    // e.g. headless `getLinkPath` outside the editor's reroute pass.
+    if (edge.routedPoints !== undefined) {
+        return [from, ...edge.routedPoints, to];
+    }
+    // Orthogonal heuristic fallback — modern-style elbow with side-aware
+    // stubs.
+    // When either endpoint is anchored to a named side (top / right /
+    // bottom / left), we know which axis the edge should *exit* on,
+    // so we add a small stub in that direction before bending toward
+    // the other endpoint. Corner / center anchors and free `point`
+    // endpoints fall back to the longest-axis-first heuristic.
+    const fromDir = exitDirectionFor(edge.from);
+    const toDir = exitDirectionFor(edge.to);
+    const stub = Math.min(40, Math.max(8, Math.abs(to.x - from.x) / 4, Math.abs(to.y - from.y) / 4));
+    if (fromDir || toDir) {
+        const path = [from];
+        let cursorFrom = from;
+        const cursorTo = to;
+        if (fromDir) {
+            cursorFrom = { x: from.x + fromDir.x * stub, y: from.y + fromDir.y * stub };
+            path.push(cursorFrom);
+        }
+        let toStubPoint = null;
+        if (toDir) {
+            toStubPoint = { x: to.x + toDir.x * stub, y: to.y + toDir.y * stub };
+        }
+        // Bend between cursorFrom and (toStubPoint ?? to).
+        const end = toStubPoint ?? cursorTo;
+        const dx = end.x - cursorFrom.x;
+        const dy = end.y - cursorFrom.y;
+        // Pick bend axis based on the originating stub direction when
+        // available — horizontal stub bends vertical first to align,
+        // and vice-versa.
+        const horizontalFirst = fromDir
+            ? Math.abs(fromDir.x) > Math.abs(fromDir.y)
+            : Math.abs(dx) >= Math.abs(dy);
+        if (Math.abs(dx) > 0.5 && Math.abs(dy) > 0.5) {
+            const bend = horizontalFirst
+                ? { x: end.x, y: cursorFrom.y }
+                : { x: cursorFrom.x, y: end.y };
+            path.push(bend);
+        }
+        if (toStubPoint)
+            path.push(toStubPoint);
+        path.push(to);
+        return path;
+    }
+    // Free-floating fallback — single elbow midway. Picks the larger
+    // axis so an edge that's mostly horizontal goes horizontal-then-
+    // vertical, and vice-versa.
+    const dx = to.x - from.x;
+    const dy = to.y - from.y;
+    const horizontalFirst = Math.abs(dx) >= Math.abs(dy);
+    const mid = horizontalFirst ? { x: to.x, y: from.y } : { x: from.x, y: to.y };
+    return [from, mid, to];
+};
+/**
+ * Outward direction (unit vector) for an edge endpoint anchored to
+ * a named side. Returns null when the endpoint has no clear
+ * directional hint (centre / corner / free point / non-anchor).
+ *
+ * Used by the orthogonal routing to add a side-aware stub before
+ * bending — matches the look of standard connectors.
+ */
+const exitDirectionFor = (endpoint) => {
+    if (endpoint.kind !== "anchor")
+        return null;
+    if (endpoint.anchor.kind !== "named")
+        return null;
+    switch (endpoint.anchor.name) {
+        case "top":
+            return { x: 0, y: -1 };
+        case "right":
+            return { x: 1, y: 0 };
+        case "bottom":
+            return { x: 0, y: 1 };
+        case "left":
+            return { x: -1, y: 0 };
+        default:
+            // top-left / top-right / bottom-left / bottom-right / center / custom
+            return null;
+    }
+};
+/**
+ * Distance from a point to a finite line segment in world coordinates.
+ * Used by `findLinkAt` for hit-testing.
+ */
+const distanceToSegment = (point, a, b) => {
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const lenSq = dx * dx + dy * dy;
+    if (lenSq === 0) {
+        const ex = point.x - a.x;
+        const ey = point.y - a.y;
+        return Math.hypot(ex, ey);
+    }
+    let t = ((point.x - a.x) * dx + (point.y - a.y) * dy) / lenSq;
+    t = Math.max(0, Math.min(1, t));
+    const cx = a.x + dx * t;
+    const cy = a.y + dy * t;
+    return Math.hypot(point.x - cx, point.y - cy);
+};
+/**
+ * Unit direction a curved link should leave/enter an endpoint along: the
+ * edge's outward normal for a named-side anchor, else a fallback along the
+ * dominant axis toward `toward` (so a free point / corner / floating end
+ * gives a sensible flat-ish curve instead of a fixed one-sided bow).
+ */
+const curveEndDir = (endpoint, at, toward) => {
+    const named = exitDirectionFor(endpoint);
+    if (named)
+        return named;
+    const dx = toward.x - at.x;
+    const dy = toward.y - at.y;
+    if (Math.abs(dx) >= Math.abs(dy))
+        return { x: Math.sign(dx) || 1, y: 0 };
+    return { x: 0, y: Math.sign(dy) || 1 };
+};
+/**
+ * Cubic-bezier representation of a curved (bezier) edge: the start point and
+ * the list of cubic segments. A no-waypoint span is a single cubic whose
+ * control arms follow the endpoints' edge normals (exits/enters perpendicular
+ * to the element edge — flowchart look); a waypointed span is a Catmull-Rom
+ * spline through the bends. Returns `null` for non-bezier / unresolvable.
+ */
+export const getLinkCurveSegments = (scene, edge) => {
+    if ((edge.routing ?? "straight") !== "bezier")
+        return null;
+    // Self-loop → an arc that bows outside the element (see getSelfLoopSpec).
+    const loop = getSelfLoopSpec(scene, edge);
+    if (loop)
+        return selfLoopCurve(loop);
+    const path = getLinkPath(scene, edge);
+    if (!path || path.length < 2)
+        return null;
+    const start = req(path[0]);
+    const end = req(path[path.length - 1]);
+    if (path.length === 2) {
+        const dirFrom = curveEndDir(edge.from, start, end);
+        const dirTo = curveEndDir(edge.to, end, start);
+        return { start, segments: [cubicWithEndTangents(start, end, dirFrom, dirTo)] };
+    }
+    return { start, segments: catmullRomBeziers(path) };
+};
+/**
+ * Hit-test / bounds polyline for an edge: the routed path, except a curved
+ * (bezier) edge is flattened to follow the drawn arc (so clicking the
+ * visible curve — which bows away from the straight chord — actually hits).
+ * Returns `null` when the path is unresolvable.
+ */
+export const getLinkCurvePoints = (scene, edge) => {
+    if ((edge.routing ?? "straight") !== "bezier")
+        return getLinkPath(scene, edge);
+    const curve = getLinkCurveSegments(scene, edge);
+    if (!curve)
+        return null;
+    return flattenSegments(curve.start, curve.segments);
+};
+/**
+ * Per-span "add a waypoint" handle positions for a selected link's bend
+ * editing — one handle per logical span of `[from, ...waypoints, to]`, index i
+ * being the span between point i and i+1 (what `beginWaypointDrag(i, insert)`
+ * expects). The handle sits at the VISUAL middle of its span:
+ *   - bezier — the curve point at `t=0.5` of that span's cubic, so the handle
+ *     lands ON the drawn arc (not the straight chord beside it);
+ *   - straight — the chord midpoint (the span IS straight).
+ * Returns `null` for orthogonal (elbow) links — their segment handles are
+ * computed from the routed path by the caller — or when unresolvable.
+ */
+export const getLinkWaypointMidpoints = (scene, edge) => {
+    const routing = edge.routing ?? "straight";
+    if (routing === "orthogonal")
+        return null;
+    if (routing === "bezier") {
+        const curve = getLinkCurveSegments(scene, edge);
+        if (!curve)
+            return null;
+        const mids = [];
+        let prev = curve.start;
+        for (const s of curve.segments) {
+            mids.push(cubicAt(prev, s.c1, s.c2, s.to, 0.5));
+            prev = s.to;
+        }
+        return mids;
+    }
+    const path = getLinkPath(scene, edge);
+    if (!path || path.length < 2)
+        return null;
+    const mids = [];
+    for (let i = 0; i < path.length - 1; i++) {
+        const a = req(path[i]);
+        const b = req(path[i + 1]);
+        mids.push({ x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 });
+    }
+    return mids;
+};
+/**
+ * Topmost edge under `worldPoint`, or `null` if none is within
+ * `threshold` world-pixels of any segment. Iterates edges in layer
+ * order; later layers (rendered on top) win when paths overlap.
+ *
+ * Curved (bezier) edges are tested against the flattened curve (via
+ * `getLinkCurvePoints`) so the clickable line matches the drawn arc.
+ */
+export const findLinkAt = (scene, worldPoint, threshold = 5) => {
+    let best = null;
+    for (const edge of scene.links.values()) {
+        const path = getLinkCurvePoints(scene, edge);
+        if (!path)
+            continue;
+        let minDistance = Infinity;
+        for (let i = 1; i < path.length; i++) {
+            const d = distanceToSegment(worldPoint, req(path[i - 1]), req(path[i]));
+            if (d < minDistance)
+                minDistance = d;
+        }
+        if (minDistance > threshold)
+            continue;
+        // Layer ordering: a later edge in iteration order is rendered on top,
+        // so it should win for ties.
+        if (!best || minDistance <= best.distance) {
+            best = { edge, distance: minDistance };
+        }
+    }
+    return best?.edge ?? null;
+};
+//# sourceMappingURL=edge-geometry.js.map