@nowline/layout 0.8.5 → 0.9.0

package/dist/edge-routing.js

@@ -1,435 +1,305 @@
-// Channel-based dependency-arrow router. Replaces the single-elbow
-// `routeEdge` shipped in m2g with one that:
+// Date-port dependency router (specs/true-width-layout.md §3.4).
 //
-//   - Drops the vertical leg in the cleanest inter-column gutter (item
-//     bars are obstacles).
-//   - Nudges the elbow X away from any visible parallel/group bracket
-//     within `BRACKET_NUDGE_PX` so arrows breathe instead of hugging
-//     the bracket line.
-//   - Assigns distinct slots when multiple edges share a channel so
-//     parallel arrows don't stack on top of one another.
-//   - Falls back to under-bar routing (rendered behind the bars with a
-//     thinner stroke) when no clean channel exists in the source-target
-//     gap.
+// An arrow runs on the dates. It leaves the middle of its source's last
+// day through the source's bottom edge (top edge when the target is
+// above), drops into a gap between rows, runs horizontally in that gap to
+// the middle of the target's first day, and turns into the target's top
+// edge (bottom edge when the source is below), arrowhead first. Day
+// centres, never date lines: in a chain the successor starts exactly on
+// its predecessor's end date, so a leg on the date line would run down the
+// successor's edge.
 //
-// Containers are NOT treated as obstacles. Endpoints inside a parallel
-// or group route directly through the items-only obstacle map and use
-// the under-bar fallback when needed. Looping around container edges
-// to avoid a single intersecting bar produced unsatisfying detours
-// (see `specs/handoffs/handoff-channel-routing-design.md`).
-/** Distance (px) the elbow X must keep from any visible bracket. Picked
- *  to leave a small visible gap between the arrow's vertical leg and
- *  the bracket stroke without forcing the arrow far from its natural
- *  mid-gutter line. */
-export const BRACKET_NUDGE_PX = 4;
-/** Minimum horizontal source stub (px) — distance from the source's
- *  exit point to the vertical-leg elbow. Below this, the source-side
- *  arrow body collapses into the bar's right edge with no visible
- *  horizontal segment. Treated as a hard constraint when picking
- *  the channel X for left-to-right edges. */
-export const MIN_SOURCE_STUB_PX = 6;
-/** Minimum horizontal target stub (px) — distance from the vertical-leg
- *  elbow to the target's left edge. Below this, the arrowhead has no
- *  horizontal lead-in: the leg appears to plunge directly into the bar
- *  without a visible target-side stub. Treated as a hard constraint
- *  when picking the channel X for left-to-right edges; conflicts with
- *  obstacle / bracket clearance trigger the under-bar fallback. */
-export const MIN_TARGET_STUB_PX = 6;
-/** Spacing between slots inside one channel. With a 12 px gutter and
- *  this spacing, three slots (-1, 0, +1) fit comfortably; more than
- *  three sharing a channel collapses to centerline. */
-const SLOT_SPACING_PX = 3;
-/** Tolerance (px) when grouping edges by channel X for slot assignment.
- *  Edges within this distance share a channel. */
-const SLOT_GROUP_TOLERANCE_PX = 1;
-/** Stub length leaving each endpoint before the elbow turn for
- *  right-to-left edges. The router also inserts a quarter-arc at the
- *  elbow corner; the renderer's `roundedOrthogonalPath` rounds the
- *  corners. Left-to-right edges use the per-side `MIN_*_STUB_PX`
- *  constants instead — they provide tighter, asymmetric control over
- *  the source vs target sides. */
-const STUB_OUT_PX = 10;
-export class ChannelGrid {
-    items;
-    brackets;
-    constructor(input) {
-        this.items = input.itemBars;
-        this.brackets = input.brackets;
-    }
-    /** True when a vertical line at `x` intersects any item bar within
-     *  the Y span `[yMin, yMax]`. */
-    hasObstacle(x, yMin, yMax) {
-        const lo = Math.min(yMin, yMax);
-        const hi = Math.max(yMin, yMax);
-        for (const bar of this.items) {
-            if (x <= bar.x || x >= bar.x + bar.width)
-                continue;
-            if (bar.y + bar.height <= lo || bar.y >= hi)
-                continue;
-            return true;
-        }
-        return false;
-    }
-    /** Visible brackets within `radius` px of `x` whose Y span overlaps
-     *  `[yMin, yMax]`. The clearance nudge uses these to shift the
-     *  elbow X away from the bracket. */
-    bracketsNear(x, yMin, yMax, radius) {
-        const lo = Math.min(yMin, yMax);
-        const hi = Math.max(yMin, yMax);
-        const out = [];
-        for (const b of this.brackets) {
-            if (Math.abs(b.x - x) > radius)
-                continue;
-            if (b.yBottom <= lo || b.yTop >= hi)
-                continue;
-            out.push(b);
-        }
-        return out;
-    }
+// Legs pass behind bars and cross them at right angles. The horizontal leg
+// sits in a gap no bar, spilled caption or container header reaches into
+// (between the source and the target, over the leg's x-range); among the
+// gaps, the router takes the one whose vertical legs keep clear of every
+// bar edge, then the one whose vertical legs cross the fewest bars, then
+// the one nearest the source. Arrows sharing a gap take offset lanes
+// `CHANNEL_LANE_PX` apart; arrows landing in the same day column share one
+// lane, so they merge into one trunk over their target (§8 O1).
+//
+// Two shapes need no gap: a target on its source's row (a dotted leg at
+// the row's midline, or no arrow when it starts where the source ends),
+// and a marker source (`dependency-edges.ts`). Everything here is pure
+// geometry on numbers the caller reads off the final model.
+/** Spacing between the lanes of one gap (§3.4 "Channels"). */
+export const CHANNEL_LANE_PX = 2.5;
+/** A vertical leg keeps more than this from a bar's left or right edge over its height (§6). */
+export const EDGE_CLEARANCE_PX = 1;
+/** Full arrowhead width (and the length along the leg is `ARROW_HEAD_LENGTH_PX`). */
+export const ARROW_HEAD_WIDTH_PX = 7;
+/** Length of a full arrowhead along its leg. */
+export const ARROW_HEAD_LENGTH_PX = 5;
+/** The narrowest arrowhead; a target narrower than this gets a dot of this diameter (§8 O6). */
+export const ARROW_HEAD_MIN_PX = 3;
+/** Two x's (or y's) closer than this are the same date line. */
+const SAME_PX = 0.01;
+/** A gap must be at least this tall to carry a leg. */
+const MIN_GAP_PX = 2;
+/** Clearance kept between a horizontal leg and anything it must not touch. */
+const BLOCK_MARGIN_PX = 1;
+/** Where an arrow leaves `end`: the middle of its last day, or its middle when shorter than a day. */
+export function sourcePortX(end, pixelsPerDay) {
+    return end.endX - Math.min(pixelsPerDay / 2, (end.endX - end.startX) / 2);
 }
-/**
- * Walk a positioned swimlane tree and collect every painted item bar
- * (visual edges) AND every visible bracket stroke. Output feeds
- * `ChannelGrid` so the router knows what to avoid.
- *
- * Swimlanes contained in include regions count too — items inside an
- * isolated region share the parent timeline so cross-region arrows
- * still need the obstacle/bracket data to route cleanly.
- */
-export function collectRoutingObstacles(swimlanes, includes) {
-    const itemBars = [];
-    const brackets = [];
-    const visitChild = (child) => {
-        if (child.kind === 'item') {
-            itemBars.push(child.box);
-            return;
-        }
-        if (child.kind === 'parallel') {
-            // Parallel `bracket:solid|dashed` paints `[ ]` strokes at
-            // the box's left/right edges with 12 px vertical padding
-            // (matches `renderParallel`). The bracket has THREE
-            // strokes per side — a vertical bar at the box edge, plus
-            // top/bottom horizontal "feet" extending 4 px inward
-            // toward the parallel's center. We model the verticals as
-            // full-height bracket lines AND emit thin-Y-band entries
-            // at the foot tips so the clearance nudge sees the foot
-            // extent (otherwise an elbow nudged just past the
-            // vertical at +4 px would land squarely on the inward
-            // foot tip — see issue #2 in the channel-routing handoff).
-            if (child.style.bracket === 'solid' || child.style.bracket === 'dashed') {
-                const padding = 12;
-                const stub = 4;
-                const yTop = child.box.y - padding;
-                const yBottom = child.box.y + child.box.height + padding;
-                const lx = child.box.x;
-                const rx = child.box.x + child.box.width;
-                brackets.push({ x: lx, yTop, yBottom });
-                brackets.push({ x: rx, yTop, yBottom });
-                // Foot tips: tiny Y bands centered on each foot row
-                // so the entries only fire when the elbow's Y span
-                // actually crosses the foot line.
-                brackets.push({ x: lx + stub, yTop: yTop - 1, yBottom: yTop + 1 });
-                brackets.push({ x: lx + stub, yTop: yBottom - 1, yBottom: yBottom + 1 });
-                brackets.push({ x: rx - stub, yTop: yTop - 1, yBottom: yTop + 1 });
-                brackets.push({ x: rx - stub, yTop: yBottom - 1, yBottom: yBottom + 1 });
-            }
-            for (const sub of child.children)
-                visitChild(sub);
-            return;
-        }
-        if (child.kind === 'group') {
-            // Bracket-style groups (no fill) paint a left-side `[`
-            // glyph along `box.x`. Filled-style groups have no bracket
-            // — the chiclet is the visual instead.
-            const isFilled = child.style.bg !== 'none' && child.style.bg !== '#ffffff';
-            if (!isFilled && child.style.bracket && child.style.bracket !== 'none') {
-                brackets.push({
-                    x: child.box.x,
-                    yTop: child.box.y,
-                    yBottom: child.box.y + child.box.height,
-                });
-            }
-            for (const sub of child.children)
-                visitChild(sub);
-            return;
-        }
-    };
-    const visitSwimlane = (lane) => {
-        for (const child of lane.children)
-            visitChild(child);
-        for (const nested of lane.nested)
-            visitSwimlane(nested);
-    };
-    for (const lane of swimlanes)
-        visitSwimlane(lane);
-    for (const region of includes) {
-        for (const lane of region.nestedSwimlanes)
-            visitSwimlane(lane);
-    }
-    return { itemBars, brackets };
+/** Where an arrow lands on `end`: the middle of its first day, or its middle when shorter than a day. */
+export function targetPortX(end, pixelsPerDay) {
+    return end.startX + Math.min(pixelsPerDay / 2, (end.endX - end.startX) / 2);
+}
+/** Arrowhead for a leg landing across a target `width` wide (§8 O6). */
+export function arrowHead(width) {
+    if (width < ARROW_HEAD_MIN_PX)
+        return { headWidth: ARROW_HEAD_MIN_PX, head: 'dot' };
+    return { headWidth: Math.min(ARROW_HEAD_WIDTH_PX, width), head: 'arrow' };
 }
+const within = (y, lo, hi) => y >= lo - SAME_PX && y <= hi + SAME_PX;
 /**
- * Pick a channel X for one edge (no slot offset yet). Returns the
- * provisional X, an `underBar` flag, and the satisfiable stub range
- * so the bracket-clearance nudge can stay inside it. Same-row edges
- * (`from.y ≈ to.y`) get a degenerate "channel" at midX so the
- * renderer emits a straight line.
+ * True when the target sits on its source's row: each one's row midline
+ * crosses the other (a container source, which has no row, only needs the
+ * target's midline to cross it).
  */
-function pickChannelX(req, grid) {
-    const { from, to } = req;
-    if (Math.abs(from.y - to.y) < 0.5) {
-        return { x: (from.x + to.x) / 2, underBar: false, range: null };
+function onSameRow(s, t) {
+    if (t.rowY === undefined || !within(t.rowY, s.top, s.bottom))
+        return false;
+    return s.rowY === undefined || within(s.rowY, t.top, t.bottom);
+}
+/** The free stretches of `(lo, hi)` no block over `[xLo, xHi]` reaches into. */
+function freeGaps(blocks, xLo, xHi, lo, hi) {
+    const covered = [];
+    for (const b of blocks) {
+        if (b.x >= xHi + BLOCK_MARGIN_PX || b.x + b.width <= xLo - BLOCK_MARGIN_PX)
+            continue;
+        const top = b.y - BLOCK_MARGIN_PX;
+        const bottom = b.y + b.height + BLOCK_MARGIN_PX;
+        if (bottom <= lo || top >= hi)
+            continue;
+        covered.push([Math.max(lo, top), Math.min(hi, bottom)]);
     }
-    const yMin = Math.min(from.y, to.y);
-    const yMax = Math.max(from.y, to.y);
-    if (from.x <= to.x) {
-        // Left-to-right edge. The elbow X must satisfy both the
-        // min-source-stub and min-target-stub constraints — when the
-        // gutter is wider than the sum of the stubs, that's a band;
-        // when it's tighter the band collapses or inverts and the
-        // arrow drops to under-bar at the target-stub line.
-        const minX = from.x + MIN_SOURCE_STUB_PX;
-        const maxX = to.x - MIN_TARGET_STUB_PX;
-        if (minX > maxX) {
-            // Gutter narrower than the combined min stubs — give up
-            // and honor the target-stub line so the arrowhead still
-            // has its visible lead-in. Source stub absorbs the loss.
-            return {
-                x: to.x - MIN_TARGET_STUB_PX,
-                underBar: true,
-                range: null,
-            };
-        }
-        const range = { minX, maxX };
-        // Try the natural gutter midpoint, clamped into the range.
-        const naturalMid = (from.x + to.x) / 2;
-        const mid = Math.max(minX, Math.min(maxX, naturalMid));
-        if (!grid.hasObstacle(mid, yMin, yMax)) {
-            return { x: mid, underBar: false, range };
-        }
-        // Walk inside the satisfiable range looking for a clear strip.
-        const span = maxX - minX;
-        for (let step = 1; step <= span; step++) {
-            const left = mid - step;
-            if (left >= minX && !grid.hasObstacle(left, yMin, yMax)) {
-                return { x: left, underBar: false, range };
-            }
-            const right = mid + step;
-            if (right <= maxX && !grid.hasObstacle(right, yMin, yMax)) {
-                return { x: right, underBar: false, range };
-            }
-        }
-        return { x: mid, underBar: true, range };
+    covered.sort((a, b) => a[0] - b[0]);
+    const gaps = [];
+    let y = lo;
+    for (const [top, bottom] of covered) {
+        if (top - y >= MIN_GAP_PX)
+            gaps.push([y, top]);
+        y = Math.max(y, bottom);
     }
-    // Right-to-left edge: source ends past target's left edge. Try a
-    // channel just right of source first; then walk leftward across
-    // the source/target span looking for any clear vertical strip.
-    const probes = [from.x + STUB_OUT_PX, to.x - STUB_OUT_PX];
-    for (const probe of probes) {
-        if (probe > 0 && !grid.hasObstacle(probe, yMin, yMax)) {
-            return { x: probe, underBar: false, range: null };
-        }
+    if (hi - y >= MIN_GAP_PX)
+        gaps.push([y, hi]);
+    return gaps;
+}
+/** Bar or container edges a vertical leg at `x` over `(y0, y1)` runs within the clearance of. */
+function grazes(edges, x, y0, y1) {
+    const lo = Math.min(y0, y1);
+    const hi = Math.max(y0, y1);
+    let n = 0;
+    for (const e of edges) {
+        if (Math.abs(e.x - x) > EDGE_CLEARANCE_PX)
+            continue;
+        if (e.bottom <= lo || e.top >= hi)
+            continue;
+        n++;
+    }
+    return n;
+}
+/** Blocks a vertical leg at `x` over `(y0, y1)` passes behind. */
+function crossings(blocks, x, y0, y1) {
+    const lo = Math.min(y0, y1);
+    const hi = Math.max(y0, y1);
+    let n = 0;
+    for (const b of blocks) {
+        if (b.height <= 0 || x <= b.x || x >= b.x + b.width)
+            continue;
+        if (b.y + b.height <= lo || b.y >= hi)
+            continue;
+        n++;
     }
-    // Fallback to under-bar at the source-side stub.
-    return { x: from.x + STUB_OUT_PX, underBar: true, range: null };
+    return n;
 }
 /**
- * Apply the bracket-clearance nudge to a chosen channel X. Shifts `x`
- * away from the nearest visible bracket within `BRACKET_NUDGE_PX`,
- * preferring the direction that stays inside the satisfiable stub
- * range. When neither direction fits — or the candidate position is
- * still within nudge distance of another bracket — returns the input
- * X clamped to the range and signals `forceUnderBar` so the leg paints
- * BEHIND the bars and bracket strokes (z-order: bracket renders after
- * under-bar edges, so the bracket cleanly covers the colliding
- * portion).
+ * Pick the gap for an arrow from `from` (on the source's edge) to `to` (on
+ * the target's edge): clear of every bar edge first, then fewest bars
+ * crossed, then nearest the source. With no free gap at all, the leg runs
+ * just past the source and passes behind whatever is there.
  */
-function nudgeAwayFromBrackets(x, range, req, grid) {
-    const yMin = Math.min(req.from.y, req.to.y);
-    const yMax = Math.max(req.from.y, req.to.y);
-    const near = grid.bracketsNear(x, yMin, yMax, BRACKET_NUDGE_PX);
-    if (near.length === 0)
-        return { x, forceUnderBar: false };
-    // Find the closest bracket — that's the one driving the nudge.
-    let closest = near[0];
-    let closestDist = Math.abs(near[0].x - x);
-    for (let i = 1; i < near.length; i++) {
-        const d = Math.abs(near[i].x - x);
-        if (d < closestDist) {
-            closest = near[i];
-            closestDist = d;
-        }
+function pickGap(from, to, dir, obstacles) {
+    const xLo = Math.min(from.x, to.x);
+    const xHi = Math.max(from.x, to.x);
+    const lo = Math.min(from.y, to.y);
+    const hi = Math.max(from.y, to.y);
+    let best = null;
+    for (const gap of freeGaps(obstacles.blocks, xLo, xHi, lo, hi)) {
+        const centre = (gap[0] + gap[1]) / 2;
+        const key = [
+            grazes(obstacles.edges, from.x, from.y, centre) +
+                grazes(obstacles.edges, to.x, centre, to.y),
+            crossings(obstacles.blocks, from.x, from.y, centre) +
+                crossings(obstacles.blocks, to.x, centre, to.y),
+            Math.abs(centre - from.y),
+        ];
+        if (!best || lessThan(key, best.key))
+            best = { gap, centre, key };
     }
-    // Try both sides of the closest bracket. Accept the first
-    // candidate that stays within the satisfiable range AND clears
-    // every other nearby bracket. The recheck radius is one epsilon
-    // tighter than `BRACKET_NUDGE_PX` so the closest bracket itself
-    // (now sitting at exactly the nudge distance) doesn't falsely
-    // trip the rejection — and so a SECOND bracket exactly at the
-    // nudge distance is also accepted as "just clear enough".
-    const candidates = [closest.x + BRACKET_NUDGE_PX, closest.x - BRACKET_NUDGE_PX];
-    const recheckRadius = BRACKET_NUDGE_PX - 0.01;
-    for (const candidate of candidates) {
-        if (range && (candidate < range.minX || candidate > range.maxX))
-            continue;
-        // Clamp right-to-left candidates to the natural gap so they
-        // don't escape past either endpoint (range is null on that path).
-        const clamped = range
-            ? candidate
-            : Math.max(Math.min(req.from.x, req.to.x) + 1, Math.min(Math.max(req.from.x, req.to.x) - 1, candidate));
-        const stillNear = grid.bracketsNear(clamped, yMin, yMax, recheckRadius);
-        if (stillNear.length === 0) {
-            return { x: clamped, forceUnderBar: false };
-        }
+    if (best)
+        return { gap: best.gap, centre: best.centre };
+    const reach = Math.min(4, (hi - lo) / 2);
+    const centre = from.y + dir * reach;
+    return { gap: [lo, hi], centre };
+}
+function lessThan(a, b) {
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return a[i] < b[i];
+    }
+    return false;
+}
+/** Lane offsets to try, the first one toward the source (so the arrowhead keeps its leg). */
+function laneOffsets(dir, halfHeight) {
+    const out = [0];
+    for (let k = 1; k * CHANNEL_LANE_PX <= halfHeight + SAME_PX; k++) {
+        out.push(-dir * k * CHANNEL_LANE_PX, dir * k * CHANNEL_LANE_PX);
     }
-    // No nudge fits. Keep the channel at its current X (clamped into
-    // the range) and force under-bar so item bars + bracket strokes
-    // mask the colliding portion of the leg.
-    const fallback = range ? Math.min(Math.max(x, range.minX), range.maxX) : x;
-    return { x: fallback, forceUnderBar: true };
+    return out;
 }
 /**
- * Greedy interval coloring per channel. Edges sharing a channel
- * (within `SLOT_GROUP_TOLERANCE_PX`) get distinct slot indices;
- * overlapping Y spans land on different slots. Slot 0 is the
- * centerline; ±1 sit `SLOT_SPACING_PX` to either side; further slots
- * collapse back to the centerline (rare; visual stacking accepted).
+ * Give each gap-routed arrow its lane: an arrow whose day column already
+ * has a lane in this gap joins it; otherwise the first offset no other
+ * horizontal leg over the same x's sits on, or, when the gap is full, the
+ * least crowded one.
  */
-function assignSlots(edges) {
-    // Group by channel X (sort first so close-X edges collapse).
-    const byX = [...edges].sort((a, b) => {
-        if (Math.abs(a.channelX - b.channelX) >= SLOT_GROUP_TOLERANCE_PX) {
-            return a.channelX - b.channelX;
-        }
-        // Within the same channel, deterministic by orderIndex.
-        return a.orderIndex - b.orderIndex;
-    });
-    const slotsByOrderIndex = new Map();
-    let groupStart = 0;
-    while (groupStart < byX.length) {
-        let groupEnd = groupStart + 1;
-        while (groupEnd < byX.length &&
-            Math.abs(byX[groupEnd].channelX - byX[groupStart].channelX) < SLOT_GROUP_TOLERANCE_PX) {
-            groupEnd++;
+function assignLanes(pending) {
+    const placed = [];
+    const out = new Map();
+    const order = [...pending].sort((a, b) => a.centre - b.centre || a.xLo - b.xLo || a.index - b.index);
+    for (const p of order) {
+        const [lo, hi] = p.gap;
+        const mate = placed.find((q) => q.bundle === p.bundle && q.y >= lo - SAME_PX && q.y <= hi + SAME_PX);
+        let y = p.centre;
+        if (mate) {
+            y = mate.y;
         }
-        const group = byX.slice(groupStart, groupEnd);
-        // Within the group, greedy color by Y span. Sort by min Y then
-        // (deterministically) by orderIndex.
-        const sortedGroup = [...group].sort((a, b) => {
-            const aMin = Math.min(a.req.from.y, a.req.to.y);
-            const bMin = Math.min(b.req.from.y, b.req.to.y);
-            if (Math.abs(aMin - bMin) > 0.5)
-                return aMin - bMin;
-            return a.orderIndex - b.orderIndex;
-        });
-        // Track per-slot maxY assigned so far.
-        const slotMaxY = [];
-        for (const entry of sortedGroup) {
-            const eMin = Math.min(entry.req.from.y, entry.req.to.y);
-            const eMax = Math.max(entry.req.from.y, entry.req.to.y);
-            let assigned = -1;
-            for (let s = 0; s < slotMaxY.length; s++) {
-                if (slotMaxY[s] <= eMin) {
-                    assigned = s;
-                    slotMaxY[s] = eMax;
-                    break;
+        else {
+            // The gap already keeps `BLOCK_MARGIN_PX` from its neighbours.
+            const offsets = laneOffsets(p.dir, (hi - lo) / 2);
+            let bestConflicts = Number.POSITIVE_INFINITY;
+            for (const off of offsets) {
+                const cy = p.centre + off;
+                const conflicts = placed.filter((q) => q.bundle !== p.bundle &&
+                    Math.abs(q.y - cy) < CHANNEL_LANE_PX - SAME_PX &&
+                    q.xLo < p.xHi + BLOCK_MARGIN_PX &&
+                    q.xHi > p.xLo - BLOCK_MARGIN_PX).length;
+                if (conflicts < bestConflicts) {
+                    bestConflicts = conflicts;
+                    y = cy;
                 }
+                if (conflicts === 0)
+                    break;
             }
-            if (assigned === -1) {
-                assigned = slotMaxY.length;
-                slotMaxY.push(eMax);
-            }
-            slotsByOrderIndex.set(entry.orderIndex, assigned);
         }
-        groupStart = groupEnd;
+        placed.push({ y, xLo: p.xLo, xHi: p.xHi, bundle: p.bundle });
+        out.set(p.index, y);
     }
-    return slotsByOrderIndex;
-}
-/** Convert a slot index to its signed offset around the channel
- *  centerline. Slots 0/1/2/... become 0, +SLOT, -SLOT, +2*SLOT,
- *  -2*SLOT... so the FIRST edge sits on the centerline (no shift)
- *  and additional edges fan out alternately. Past 2 ± slots, slots
- *  collapse back to the centerline (visual stacking accepted). */
-function slotOffset(slot) {
-    if (slot === 0)
-        return 0;
-    if (slot > 4)
-        return 0; // collapse beyond ±2 slots
-    const half = Math.ceil(slot / 2);
-    const sign = slot % 2 === 1 ? 1 : -1;
-    return sign * half * SLOT_SPACING_PX;
+    return out;
 }
 /**
- * Marker → item stub. Source X sits on the marker's vertical cut
- * line; the stub is a short horizontal segment to the target's left
- * visual edge at the target's row mid-Y. No channel selection, no
- * obstacle check — the cut line is the stem.
+ * Route every item dependency of one chart (the host, or one isolated
+ * region) in a batch, so arrows sharing a gap can take lanes. Returns one
+ * entry per request; `null` where position already says it (a target on
+ * its source's row that starts where the source ends).
  */
-function routeMarkerStub(req) {
-    // When the cut line sits AT or PAST the target's left edge (item
-    // hugs the anchor's date column), nudge the source 1 px back so
-    // routeEdge produces a non-degenerate path with a visible
-    // arrowhead.
-    const from = req.from.x >= req.to.x ? { x: req.to.x - 1, y: req.from.y } : req.from;
-    return {
-        fromId: req.fromId,
-        toId: req.toId,
-        waypoints: [from, req.to],
-        underBar: false,
-    };
-}
-/**
- * Route every dependency edge in one batch so slot assignment can
- * coordinate across edges that share a channel. Marker → item edges
- * route as direct stubs and bypass the channel router.
- */
-export function routeChannelEdges(requests, grid) {
-    const results = new Array(requests.length);
-    const channelEdges = [];
-    for (let i = 0; i < requests.length; i++) {
-        const req = requests[i];
-        if (req.isMarkerSource) {
-            results[i] = routeMarkerStub(req);
-            continue;
+export function routeDependencies(requests, obstacles, pixelsPerDay) {
+    const out = new Array(requests.length).fill(null);
+    const pending = [];
+    requests.forEach((req, index) => {
+        const { source: s, target: t } = req;
+        const slack = t.startX - s.endX > SAME_PX;
+        if (onSameRow(s, t) && t.startX >= s.endX - SAME_PX) {
+            if (!slack)
+                return;
+            // A dotted leg along the row, from the source's end date to the
+            // target's painted start.
+            const y = s.exitY !== undefined && within(s.exitY, t.top, t.bottom) ? s.exitY : (t.rowY ?? 0);
+            out[index] = {
+                fromId: req.fromId,
+                toId: req.toId,
+                waypoints: [
+                    { x: s.endX, y },
+                    { x: t.paintedX, y },
+                ],
+                slack: true,
+                ...arrowHead(t.bottom - t.top),
+            };
+            return;
+        }
+        const px = sourcePortX(s, pixelsPerDay);
+        const tx = targetPortX(t, pixelsPerDay);
+        let from;
+        let to;
+        let dir;
+        if (t.top >= s.bottom - SAME_PX) {
+            dir = 1;
+            from = { x: px, y: s.bottom };
+            to = { x: tx, y: t.top };
         }
-        // Same-row contiguous chains drop entirely. The caller skips
-        // them before passing in, but defend against direct calls.
-        if (Math.abs(req.from.y - req.to.y) < 0.5 && req.to.x - req.from.x < 20) {
-            results[i] = {
+        else if (t.bottom <= s.top + SAME_PX) {
+            dir = -1;
+            from = { x: px, y: s.top };
+            to = { x: tx, y: t.bottom };
+        }
+        else {
+            // Overlapping but not on one row (a target that starts before
+            // its source ends): leave the source's bottom, run below both,
+            // come up into the target's bottom.
+            const below = Math.max(s.bottom, t.bottom) + 4;
+            out[index] = {
                 fromId: req.fromId,
                 toId: req.toId,
-                waypoints: [req.from, req.to],
-                underBar: false,
+                waypoints: [
+                    { x: px, y: s.bottom },
+                    { x: px, y: below },
+                    { x: tx, y: below },
+                    { x: tx, y: t.bottom },
+                ],
+                slack,
+                ...arrowHead(t.paintedWidth),
             };
-            continue;
+            return;
         }
-        const { x: provisionalX, underBar: provisionalUnderBar, range } = pickChannelX(req, grid);
-        const { x: channelX, forceUnderBar } = nudgeAwayFromBrackets(provisionalX, range, req, grid);
-        const underBar = provisionalUnderBar || forceUnderBar;
-        channelEdges.push({ req, channelX, underBar, orderIndex: i });
-    }
-    const slots = assignSlots(channelEdges);
-    for (const entry of channelEdges) {
-        const offset = slotOffset(slots.get(entry.orderIndex) ?? 0);
-        const slotX = entry.channelX + offset;
-        results[entry.orderIndex] = {
-            fromId: entry.req.fromId,
-            toId: entry.req.toId,
-            waypoints: buildOrthogonalPath(entry.req.from, entry.req.to, slotX),
-            underBar: entry.underBar,
+        if (Math.abs(px - tx) < SAME_PX) {
+            out[index] = {
+                fromId: req.fromId,
+                toId: req.toId,
+                waypoints: [from, to],
+                slack,
+                ...arrowHead(t.paintedWidth),
+            };
+            return;
+        }
+        const { gap, centre } = pickGap(from, to, dir, obstacles);
+        pending.push({
+            index,
+            req,
+            from,
+            to,
+            dir,
+            gap,
+            centre,
+            xLo: Math.min(px, tx),
+            xHi: Math.max(px, tx),
+            bundle: `${Math.round(tx * 100)}:${dir}`,
+        });
+    });
+    const lanes = assignLanes(pending);
+    for (const p of pending) {
+        const y = lanes.get(p.index) ?? p.centre;
+        const slack = p.req.target.startX - p.req.source.endX > SAME_PX;
+        out[p.index] = {
+            fromId: p.req.fromId,
+            toId: p.req.toId,
+            waypoints: [p.from, { x: p.from.x, y }, { x: p.to.x, y }, p.to],
+            slack,
+            ...arrowHead(p.req.target.paintedWidth),
         };
     }
-    return results;
-}
-/**
- * Build the orthogonal polyline through a chosen vertical channel.
- * Source-out-stub → vertical leg → target-in-stub. Same-row edges
- * collapse to two points (handled by the caller's same-row skip).
- */
-function buildOrthogonalPath(from, to, slotX) {
-    if (Math.abs(from.y - to.y) < 0.5) {
-        return [from, to];
-    }
-    return [from, { x: slotX, y: from.y }, { x: slotX, y: to.y }, to];
+    return out;
 }
 //# sourceMappingURL=edge-routing.js.map