@openpowershift/logic-diagram-language 0.1.0

package/dist/renderer/astar-router.js

@@ -0,0 +1,532 @@
+const CELL_SIZE = 5;
+const BLOCKED_COST = 1e7;
+const WIRE_CROSS_COST = 8;
+const WIRE_PROXIMITY_COST = 3; // soft cost up to PROXIMITY_RADIUS cells from other-source wires
+const PROXIMITY_RADIUS = 2; // spread parallel wires into separate tracks (~10px apart)
+const SAME_SOURCE_BONUS = -8; // makes overlapping a same-source trunk free, so fan-out shares one trunk
+const WRONG_SIDE_COST = 30;
+const BEND_PENALTY = 4; // tuned so the optimum is a straight line or a single clean Z
+const GATE_BUFFER_RATIO = 0.2;
+const GATE_BUFFER_MIN = 10; // absolute min horizontal clearance (px) wires keep from a gate body
+// Larger vertical clearance: a horizontal wire passing above/below a gate stays >= 2x the
+// wire gap off its top/bottom edge, so it never looks visually crammed against the body.
+const GATE_BUFFER_MIN_Y = 20;
+class MinHeap {
+    constructor() {
+        this.data = [];
+    }
+    push(item) {
+        this.data.push(item);
+        this._bubbleUp(this.data.length - 1);
+    }
+    pop() {
+        if (this.data.length === 0)
+            return undefined;
+        const top = this.data[0];
+        const last = this.data.pop();
+        if (this.data.length > 0) {
+            this.data[0] = last;
+            this._sinkDown(0);
+        }
+        return top;
+    }
+    get size() {
+        return this.data.length;
+    }
+    _bubbleUp(i) {
+        while (i > 0) {
+            const parent = (i - 1) >> 1;
+            if (this.data[parent].f <= this.data[i].f)
+                break;
+            [this.data[parent], this.data[i]] = [this.data[i], this.data[parent]];
+            i = parent;
+        }
+    }
+    _sinkDown(i) {
+        const n = this.data.length;
+        while (true) {
+            let smallest = i;
+            const left = 2 * i + 1;
+            const right = 2 * i + 2;
+            if (left < n && this.data[left].f < this.data[smallest].f)
+                smallest = left;
+            if (right < n && this.data[right].f < this.data[smallest].f)
+                smallest = right;
+            if (smallest === i)
+                break;
+            [this.data[smallest], this.data[i]] = [this.data[i], this.data[smallest]];
+            i = smallest;
+        }
+    }
+}
+const DIRS = [
+    { dx: 0, dy: -1 },
+    { dx: 1, dy: 0 },
+    { dx: 0, dy: 1 },
+    { dx: -1, dy: 0 },
+];
+function toGrid(v) {
+    return Math.round(v / CELL_SIZE);
+}
+function toCanvas(v) {
+    return v * CELL_SIZE;
+}
+function rasterizeRect(grid, gridW, gridH, x, y, w, h, cost, bufferX, bufferY, ox = 0, oy = 0) {
+    const x0 = Math.max(0, toGrid(x - bufferX) - ox);
+    const y0 = Math.max(0, toGrid(y - bufferY) - oy);
+    const x1 = Math.min(gridW - 1, toGrid(x + w + bufferX) - ox);
+    const y1 = Math.min(gridH - 1, toGrid(y + h + bufferY) - oy);
+    for (let gy = y0; gy <= y1; gy++) {
+        for (let gx = x0; gx <= x1; gx++) {
+            const idx = gy * gridW + gx;
+            if (cost > grid[idx])
+                grid[idx] = cost;
+        }
+    }
+}
+function setCellCost(grid, gridW, gridH, gx, gy, cost) {
+    if (gx >= 0 && gx < gridW && gy >= 0 && gy < gridH) {
+        const idx = gy * gridW + gx;
+        if (cost > grid[idx] && grid[idx] < BLOCKED_COST)
+            grid[idx] = cost;
+    }
+}
+function rasterizeWireSegments(grid, gridW, gridH, segments, sameSourceFromId, ox = 0, oy = 0) {
+    for (const seg of segments) {
+        const isSameSource = sameSourceFromId !== undefined && seg.fromId === sameSourceFromId;
+        const crossCost = isSameSource ? Math.max(0, WIRE_CROSS_COST + SAME_SOURCE_BONUS) : WIRE_CROSS_COST;
+        const proxityCost = isSameSource ? 0 : WIRE_PROXIMITY_COST;
+        const pts = seg.points;
+        for (let i = 0; i < pts.length - 1; i++) {
+            const p0 = pts[i], p1 = pts[i + 1];
+            if (Math.abs(p0.y - p1.y) < 1) {
+                const y = toGrid(p0.y) - oy;
+                const gx0 = toGrid(Math.min(p0.x, p1.x)) - ox;
+                const gx1 = toGrid(Math.max(p0.x, p1.x)) - ox;
+                for (let gx = gx0; gx <= gx1; gx++) {
+                    setCellCost(grid, gridW, gridH, gx, y, crossCost);
+                    for (let r = 1; r <= PROXIMITY_RADIUS && proxityCost > 0; r++) {
+                        setCellCost(grid, gridW, gridH, gx, y - r, proxityCost);
+                        setCellCost(grid, gridW, gridH, gx, y + r, proxityCost);
+                    }
+                }
+            }
+            else if (Math.abs(p0.x - p1.x) < 1) {
+                const x = toGrid(p0.x) - ox;
+                const gy0 = toGrid(Math.min(p0.y, p1.y)) - oy;
+                const gy1 = toGrid(Math.max(p0.y, p1.y)) - oy;
+                for (let gy = gy0; gy <= gy1; gy++) {
+                    setCellCost(grid, gridW, gridH, x, gy, crossCost);
+                    for (let r = 1; r <= PROXIMITY_RADIUS && proxityCost > 0; r++) {
+                        setCellCost(grid, gridW, gridH, x - r, gy, proxityCost);
+                        setCellCost(grid, gridW, gridH, x + r, gy, proxityCost);
+                    }
+                }
+            }
+        }
+    }
+}
+function rasterizeWrongSideZone(grid, gridW, gridH, gateX, gateY, gateW, gateH, portX, ox = 0, oy = 0) {
+    const x0 = Math.max(0, toGrid(portX) - ox);
+    const x1 = Math.min(gridW - 1, toGrid(gateX + gateW) - ox);
+    const y0 = Math.max(0, toGrid(gateY) - oy);
+    const y1 = Math.min(gridH - 1, toGrid(gateY + gateH) - oy);
+    for (let gy = y0; gy <= y1; gy++) {
+        for (let gx = x0; gx <= x1; gx++) {
+            const idx = gy * gridW + gx;
+            if (WRONG_SIDE_COST > grid[idx])
+                grid[idx] = WRONG_SIDE_COST;
+        }
+    }
+}
+function simplifyPath(path) {
+    if (path.length <= 2)
+        return path;
+    const result = [path[0]];
+    let prevDx = path[1].x - path[0].x;
+    let prevDy = path[1].y - path[0].y;
+    for (let i = 1; i < path.length - 1; i++) {
+        const dx = path[i + 1].x - path[i].x;
+        const dy = path[i + 1].y - path[i].y;
+        if (dx !== prevDx || dy !== prevDy) {
+            result.push(path[i]);
+            prevDx = dx;
+            prevDy = dy;
+        }
+    }
+    result.push(path[path.length - 1]);
+    return result;
+}
+// A straight horizontal wire is allowed unless it actually passes through a gate
+// BODY (plus a small margin). The 20% routing buffer is intentionally NOT used here:
+// a wire running clear of a gate should stay straight rather than be forced into A*.
+function lineHitsObstacle(y, x1, x2, obstacles, sourceGateX, sourceGateY, destGateX, destGateY) {
+    const xMin = Math.min(x1, x2);
+    const xMax = Math.max(x1, x2);
+    const m = 3; // horizontal margin (just clear the gate's left/right edge)
+    const my = GATE_BUFFER_MIN_Y; // vertical clearance (keep off the gate's top/bottom edge)
+    for (const obs of obstacles) {
+        if (obs.x === sourceGateX && obs.y === sourceGateY)
+            continue;
+        if (obs.x === destGateX && obs.y === destGateY)
+            continue;
+        // An obstacle entirely left of the wire's start (or right of its end) cannot lie on this
+        // rightward horizontal run — skip it before applying the margin, so a same-column input
+        // (whose right edge meets the wire's start X) never falsely blocks its neighbour's wire.
+        if (obs.x + obs.w <= xMin + 0.5 || obs.x >= xMax - 0.5)
+            continue;
+        if (rectsOverlap(xMin, y - 1, xMax - xMin, 2, obs.x - m, obs.y - my, obs.w + m * 2, obs.h + my * 2, 0)) {
+            return true;
+        }
+    }
+    return false;
+}
+function rectsOverlap(x1, y1, w1, h1, x2, y2, w2, h2, pad) {
+    return x1 + w1 + pad > x2 && x2 + w2 + pad > x1 &&
+        y1 + h1 + pad > y2 && y2 + h2 + pad > y1;
+}
+// True if the axis-aligned segment passes through any gate body (plus the routing buffer),
+// excluding the wire's own source and destination gates.
+function segHitsObstacle(ax, ay, bx, by, obstacles, sgx, sgy, dgx, dgy) {
+    const xMin = Math.min(ax, bx), yMin = Math.min(ay, by);
+    const xMax = Math.max(ax, bx);
+    const w = Math.abs(bx - ax) + 1, h = Math.abs(by - ay) + 1;
+    for (const o of obstacles) {
+        if (o.x === sgx && o.y === sgy)
+            continue;
+        if (o.x === dgx && o.y === dgy)
+            continue;
+        // An obstacle whose BODY is entirely left of the segment's start (or right of its end) can't lie
+        // on the segment — only its buffer would reach in. Don't let that buffer block: it's what makes
+        // a wire's exit-stub past its same-column neighbour (e.g. the input stacked just below the
+        // source) impossible. (Mirrors the straight-line fast-path check.)
+        if (o.x + o.w <= xMin + 0.5 || o.x >= xMax - 0.5)
+            continue;
+        const bufX = Math.max(GATE_BUFFER_MIN, Math.ceil(o.w * GATE_BUFFER_RATIO));
+        const bufY = Math.max(GATE_BUFFER_MIN_Y, Math.ceil(o.h * GATE_BUFFER_RATIO));
+        if (rectsOverlap(xMin - 0.5, yMin - 0.5, w, h, o.x - bufX, o.y - bufY, o.w + 2 * bufX, o.h + 2 * bufY, 0))
+            return true;
+    }
+    return false;
+}
+// True if the axis-aligned segment crosses (or runs along) a routed wire from a different
+// source. Same-source overlaps are allowed (shared trunks).
+function segCrossesWire(ax, ay, bx, by, routed, fromId) {
+    const horiz = Math.abs(ay - by) < 0.5;
+    const axMin = Math.min(ax, bx), axMax = Math.max(ax, bx);
+    const ayMin = Math.min(ay, by), ayMax = Math.max(ay, by);
+    for (const s of routed) {
+        if (fromId !== undefined && s.fromId === fromId)
+            continue;
+        for (let i = 0; i < s.points.length - 1; i++) {
+            const p = s.points[i], q = s.points[i + 1];
+            const sHoriz = Math.abs(p.y - q.y) < 0.5, sVert = Math.abs(p.x - q.x) < 0.5;
+            const sxMin = Math.min(p.x, q.x), sxMax = Math.max(p.x, q.x);
+            const syMin = Math.min(p.y, q.y), syMax = Math.max(p.y, q.y);
+            if (horiz && sVert) {
+                if (p.x >= axMin - 0.5 && p.x <= axMax + 0.5 && ay >= syMin - 0.5 && ay <= syMax + 0.5)
+                    return true;
+            }
+            else if (!horiz && sHoriz) {
+                if (ax >= sxMin - 0.5 && ax <= sxMax + 0.5 && p.y >= ayMin - 0.5 && p.y <= ayMax + 0.5)
+                    return true;
+            }
+            else if (horiz && sHoriz && Math.abs(ay - p.y) < 0.5) {
+                if (axMax > sxMin + 0.5 && axMin < sxMax - 0.5)
+                    return true;
+            }
+            else if (!horiz && sVert && Math.abs(ax - p.x) < 0.5) {
+                if (ayMax > syMin + 0.5 && ayMin < syMax - 0.5)
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+// True if a channel vertical at `cx` (spanning vy0..vy1) would run within `minGap` of another
+// net's vertical that overlaps it in Y — i.e. they'd read as one cramped bundle. Used so the
+// clean-Z fast path spreads parallel verticals into separate tracks (matching A*'s proximity
+// cost, which the fast path would otherwise bypass).
+function verticalTooClose(cx, vy0, vy1, routed, fromId, minGap) {
+    const vyMin = Math.min(vy0, vy1), vyMax = Math.max(vy0, vy1);
+    for (const s of routed) {
+        if (fromId !== undefined && s.fromId === fromId)
+            continue;
+        for (let i = 0; i < s.points.length - 1; i++) {
+            const p = s.points[i], q = s.points[i + 1];
+            if (Math.abs(p.x - q.x) < 0.5 && Math.abs(p.x - cx) > 0.5 && Math.abs(p.x - cx) < minGap &&
+                Math.max(p.y, q.y) > vyMin - 0.5 && Math.min(p.y, q.y) < vyMax + 0.5)
+                return true;
+        }
+    }
+    return false;
+}
+// Try to connect source→dest with a clean Z (horizontal, vertical channel, horizontal)
+// without a grid search: cheap, and the common case. Returns null if no clear channel is
+// found (then the caller falls back to A*). The balanced-Z pass later re-centres the channel.
+function tryCleanZ(sx, sy, dx, dy, obstacles, sgx, sgy, dgx, dgy, routed, fromId) {
+    if (dx <= sx + 2 * CELL_SIZE)
+        return null; // need forward room; let A* handle the rest
+    const mid = Math.round((sx + dx) / 2 / CELL_SIZE) * CELL_SIZE;
+    // Search the whole span between source and dest (ordered from the midpoint outward), not
+    // just a narrow band. When many wires fan into one gate they each need a *distinct* clean
+    // channel; a wide search finds one per wire and avoids an expensive grid search each.
+    const cands = [mid];
+    const maxOff = Math.max(6 * CELL_SIZE, dx - sx);
+    for (let off = CELL_SIZE; off <= maxOff; off += CELL_SIZE) {
+        cands.push(mid + off);
+        cands.push(mid - off);
+    }
+    // Two passes: first prefer a channel that also keeps clear of other nets' parallel
+    // verticals (so wires spread into separate, readable tracks); if none exists, accept any
+    // obstacle- and crossing-free channel rather than fall back to an expensive grid search.
+    const SPREAD = 3 * CELL_SIZE;
+    for (const requireSpread of [true, false]) {
+        for (const cx of cands) {
+            if (cx <= sx + CELL_SIZE || cx >= dx)
+                continue;
+            if (segHitsObstacle(sx, sy, cx, sy, obstacles, sgx, sgy, dgx, dgy))
+                continue;
+            if (segHitsObstacle(cx, sy, cx, dy, obstacles, sgx, sgy, dgx, dgy))
+                continue;
+            if (segHitsObstacle(cx, dy, dx, dy, obstacles, sgx, sgy, dgx, dgy))
+                continue;
+            if (segCrossesWire(sx, sy, cx, sy, routed, fromId))
+                continue;
+            if (segCrossesWire(cx, sy, cx, dy, routed, fromId))
+                continue;
+            if (segCrossesWire(cx, dy, dx, dy, routed, fromId))
+                continue;
+            if (requireSpread && verticalTooClose(cx, sy, dy, routed, fromId, SPREAD))
+                continue;
+            return [{ x: sx, y: sy }, { x: cx, y: sy }, { x: cx, y: dy }, { x: dx, y: dy }];
+        }
+    }
+    return null;
+}
+// Drop duplicate and colinear vertices so the path is a minimal list of corners.
+function cleanColinear(pts) {
+    if (pts.length <= 2)
+        return pts;
+    const out = [pts[0]];
+    for (let i = 1; i < pts.length; i++) {
+        const cur = pts[i];
+        const prev = out[out.length - 1];
+        if (Math.abs(cur.x - prev.x) < 1 && Math.abs(cur.y - prev.y) < 1)
+            continue; // duplicate
+        if (out.length >= 2) {
+            const p2 = out[out.length - 2];
+            const colinH = Math.abs(p2.y - prev.y) < 1 && Math.abs(prev.y - cur.y) < 1;
+            const colinV = Math.abs(p2.x - prev.x) < 1 && Math.abs(prev.x - cur.x) < 1;
+            if (colinH || colinV) {
+                out[out.length - 1] = cur;
+                continue;
+            }
+        }
+        out.push(cur);
+    }
+    return out;
+}
+/**
+ * Convert a grid-aligned A* corner path to canvas coordinates with EXACT port
+ * endpoints, guaranteeing every segment is horizontal or vertical and that the
+ * path always begins at the source and ends at the destination.
+ *
+ * Interior corners come straight from the grid path (already on the 5px grid).
+ * The exact endpoints replace the first/last grid points; if that leaves a
+ * diagonal segment at an endpoint we insert a single orthogonal corner. The last
+ * segment is made horizontal so wires enter their destination port from the side.
+ */
+// Orthogonal fallback between two points when no routed path is available: a straight line if
+// they share a Y, otherwise a clean Z (exit and enter horizontally). NEVER a diagonal — an
+// orthogonal route that may clip an obstacle is always preferable to a non-orthogonal segment.
+// When obstacles are supplied, the Z's bend X is chosen (searching from the midpoint outward) so
+// the three segments clear all gate bodies where possible — only clipping as an absolute last resort.
+function orthFallback(sourceX, sourceY, destX, destY, obstacles, sgx = 0, sgy = 0, dgx = 0, dgy = 0) {
+    if (Math.abs(sourceY - destY) < 1)
+        return [{ x: sourceX, y: sourceY }, { x: destX, y: destY }];
+    const z = (mx) => [
+        { x: sourceX, y: sourceY }, { x: mx, y: sourceY }, { x: mx, y: destY }, { x: destX, y: destY },
+    ];
+    const mid = Math.round((sourceX + destX) / 2 / CELL_SIZE) * CELL_SIZE;
+    if (obstacles) {
+        const lo = Math.min(sourceX, destX), hi = Math.max(sourceX, destX);
+        const cands = [mid];
+        for (let off = CELL_SIZE; off <= Math.abs(destX - sourceX); off += CELL_SIZE) {
+            cands.push(mid + off);
+            cands.push(mid - off);
+        }
+        for (const mx of cands) {
+            if (mx <= lo + CELL_SIZE || mx >= hi)
+                continue;
+            if (segHitsObstacle(sourceX, sourceY, mx, sourceY, obstacles, sgx, sgy, dgx, dgy))
+                continue;
+            if (segHitsObstacle(mx, sourceY, mx, destY, obstacles, sgx, sgy, dgx, dgy))
+                continue;
+            if (segHitsObstacle(mx, destY, destX, destY, obstacles, sgx, sgy, dgx, dgy))
+                continue;
+            return z(mx);
+        }
+    }
+    return z(mid);
+}
+function orthogonalize(gridPath, sourceX, sourceY, destX, destY) {
+    if (gridPath.length <= 1) {
+        return orthFallback(sourceX, sourceY, destX, destY);
+    }
+    const pts = gridPath.map(p => ({ x: toCanvas(p.x), y: toCanvas(p.y) }));
+    pts[0] = { x: sourceX, y: sourceY };
+    pts[pts.length - 1] = { x: destX, y: destY };
+    const out = [pts[0]];
+    for (let i = 1; i < pts.length; i++) {
+        const prev = out[out.length - 1];
+        const cur = pts[i];
+        const diagX = Math.abs(cur.x - prev.x) >= 1;
+        const diagY = Math.abs(cur.y - prev.y) >= 1;
+        if (diagX && diagY) {
+            // Insert one corner to keep the segment orthogonal. For the final segment,
+            // corner vertically first so the wire enters the dest port horizontally;
+            // otherwise corner horizontally first (exit/travel along rows).
+            if (i === pts.length - 1)
+                out.push({ x: prev.x, y: cur.y });
+            else
+                out.push({ x: cur.x, y: prev.y });
+        }
+        out.push(cur);
+    }
+    return cleanColinear(out);
+}
+export function routeWireAStar(sourceX, sourceY, destX, destY, obstacles, sourceGateX, sourceGateY, sourceGateW, sourceGateH, destGateX, destGateY, destGateW, destGateH, destIsGate, routedSegments, canvasW, canvasH, sameSourceFromId) {
+    // Fast path: straight line when Y is same and no obstacle blocks
+    if (Math.abs(sourceY - destY) < 1) {
+        if (!lineHitsObstacle(sourceY, sourceX, destX, obstacles, sourceGateX, sourceGateY, destGateX, destGateY)) {
+            return [{ x: sourceX, y: sourceY }, { x: destX, y: destY }];
+        }
+    }
+    // Fast path: a clean Z-route avoiding gate bodies and other nets. Skips the grid search
+    // for the common case (no obstacle between source and destination), which keeps layout
+    // time low on large diagrams. A* is only used when no clear channel exists.
+    const zPath = tryCleanZ(sourceX, sourceY, destX, destY, obstacles, sourceGateX, sourceGateY, destGateX, destGateY, routedSegments, sameSourceFromId);
+    if (zPath)
+        return zPath;
+    // Grid A* over a region [oGX,oGY] (grid-cell origin) of size gW x gH cells. Returns the
+    // routed path, or null if the goal is unreachable within the region. Reconstructed points
+    // are in GLOBAL grid coordinates so orthogonalize() maps them straight to canvas pixels.
+    const NODE_FIELDS = 5;
+    const solve = (oGX, oGY, gW, gH) => {
+        const startX = toGrid(sourceX) - oGX, startY = toGrid(sourceY) - oGY;
+        const goalX = toGrid(destX) - oGX, goalY = toGrid(destY) - oGY;
+        if (startX < 0 || startX >= gW || startY < 0 || startY >= gH)
+            return null;
+        if (goalX < 0 || goalX >= gW || goalY < 0 || goalY >= gH)
+            return null;
+        const gridSize = gW * gH;
+        const grid = new Float32Array(gridSize);
+        grid.fill(1);
+        for (const obs of obstacles) {
+            const isSource = obs.x === sourceGateX && obs.y === sourceGateY;
+            const isDest = obs.x === destGateX && obs.y === destGateY;
+            const bufferX = Math.max(GATE_BUFFER_MIN, Math.ceil(obs.w * GATE_BUFFER_RATIO));
+            const bufferY = Math.max(GATE_BUFFER_MIN_Y, Math.ceil(obs.h * GATE_BUFFER_RATIO));
+            if (isSource || isDest)
+                rasterizeRect(grid, gW, gH, obs.x, obs.y, obs.w, obs.h, BLOCKED_COST, 0, 0, oGX, oGY);
+            else
+                rasterizeRect(grid, gW, gH, obs.x, obs.y, obs.w, obs.h, BLOCKED_COST, bufferX, bufferY, oGX, oGY);
+        }
+        rasterizeWireSegments(grid, gW, gH, routedSegments, sameSourceFromId, oGX, oGY);
+        if (destIsGate)
+            rasterizeWrongSideZone(grid, gW, gH, destGateX, destGateY, destGateW, destGateH, destX, oGX, oGY);
+        // Clear corridors at the ports and around start/goal so A* can always exit/enter.
+        for (let gx = startX; gx <= toGrid(sourceGateX + sourceGateW + 5) - oGX; gx++) {
+            if (gx >= 0 && gx < gW && startY >= 0 && startY < gH)
+                grid[startY * gW + gx] = 1;
+        }
+        for (let gx = Math.max(0, toGrid(destGateX - 5) - oGX); gx <= goalX; gx++) {
+            if (gx >= 0 && gx < gW && goalY >= 0 && goalY < gH)
+                grid[goalY * gW + gx] = 1;
+        }
+        for (const [px, py] of [[startX - 1, startY], [startX + 1, startY], [startX, startY - 1], [startX, startY + 1], [goalX - 1, goalY], [goalX + 1, goalY], [goalX, goalY - 1], [goalX, goalY + 1]]) {
+            if (px >= 0 && px < gW && py >= 0 && py < gH)
+                grid[py * gW + px] = 1;
+        }
+        grid[startY * gW + startX] = 1;
+        grid[goalY * gW + goalX] = 1;
+        const nodes = new Float64Array(gridSize * NODE_FIELDS);
+        const closedFlags = new Uint8Array(gridSize);
+        for (let i = 0; i < gridSize; i++)
+            nodes[i * NODE_FIELDS] = Infinity;
+        const startIdx = startY * gW + startX;
+        nodes[startIdx * NODE_FIELDS] = 0;
+        nodes[startIdx * NODE_FIELDS + 1] = Math.abs(goalX - startX) + Math.abs(goalY - startY);
+        nodes[startIdx * NODE_FIELDS + 4] = -1;
+        const openHeap = new MinHeap();
+        openHeap.push({ f: Math.abs(goalX - startX) + Math.abs(goalY - startY), x: startX, y: startY });
+        while (openHeap.size > 0) {
+            const current = openHeap.pop();
+            const cx = current.x, cy = current.y;
+            const cIdx = cy * gW + cx;
+            if (closedFlags[cIdx])
+                continue;
+            closedFlags[cIdx] = 1;
+            if (cx === goalX && cy === goalY)
+                break;
+            const currentG = nodes[cIdx * NODE_FIELDS];
+            const currentDir = nodes[cIdx * NODE_FIELDS + 4];
+            for (let d = 0; d < 4; d++) {
+                const nx = cx + DIRS[d].dx;
+                const ny = cy + DIRS[d].dy;
+                if (nx < 0 || nx >= gW || ny < 0 || ny >= gH)
+                    continue;
+                const nIdx = ny * gW + nx;
+                if (closedFlags[nIdx])
+                    continue;
+                const cellCost = grid[nIdx];
+                if (cellCost >= BLOCKED_COST)
+                    continue;
+                let moveCost = 1 + cellCost;
+                if (currentDir >= 0 && currentDir !== d)
+                    moveCost += BEND_PENALTY;
+                const newG = currentG + moveCost;
+                const nGOffset = nIdx * NODE_FIELDS;
+                if (newG < nodes[nGOffset]) {
+                    nodes[nGOffset] = newG;
+                    nodes[nIdx * NODE_FIELDS + 1] = newG + Math.abs(goalX - nx) + Math.abs(goalY - ny);
+                    nodes[nIdx * NODE_FIELDS + 2] = cx;
+                    nodes[nIdx * NODE_FIELDS + 3] = cy;
+                    nodes[nIdx * NODE_FIELDS + 4] = d;
+                    openHeap.push({ f: nodes[nIdx * NODE_FIELDS + 1], x: nx, y: ny });
+                }
+            }
+        }
+        const goalIdx = goalY * gW + goalX;
+        if (nodes[goalIdx * NODE_FIELDS] === Infinity)
+            return null;
+        const gridPath = [];
+        let cx = goalX, cy = goalY;
+        while (cx !== startX || cy !== startY) {
+            gridPath.push({ x: cx + oGX, y: cy + oGY });
+            const idx = cy * gW + cx;
+            cx = nodes[idx * NODE_FIELDS + 2];
+            cy = nodes[idx * NODE_FIELDS + 3];
+        }
+        gridPath.push({ x: startX + oGX, y: startY + oGY });
+        gridPath.reverse();
+        return orthogonalize(simplifyPath(gridPath), sourceX, sourceY, destX, destY);
+    };
+    // Try a region bounded to the source/dest bounding box (plus margin for detours) first —
+    // this keeps grid allocation and search proportional to the wire, not the whole canvas.
+    // Fall back to the full canvas if no path is found in the bounded region.
+    const fullGW = Math.ceil(canvasW / CELL_SIZE);
+    const fullGH = Math.ceil(canvasH / CELL_SIZE);
+    const margin = 160;
+    const minXpx = Math.max(0, Math.min(sourceX, destX, sourceGateX, destGateX) - margin);
+    const maxXpx = Math.min(canvasW, Math.max(sourceX, destX, sourceGateX + sourceGateW, destGateX + destGateW) + margin);
+    const minYpx = Math.max(0, Math.min(sourceY, destY, sourceGateY, destGateY) - margin);
+    const maxYpx = Math.min(canvasH, Math.max(sourceY, destY, sourceGateY + sourceGateH, destGateY + destGateH) + margin);
+    const oGX = toGrid(minXpx), oGY = toGrid(minYpx);
+    const bGW = Math.min(fullGW, toGrid(maxXpx) - oGX + 1);
+    const bGH = Math.min(fullGH, toGrid(maxYpx) - oGY + 1);
+    return solve(oGX, oGY, bGW, bGH)
+        ?? solve(0, 0, fullGW, fullGH)
+        ?? orthFallback(sourceX, sourceY, destX, destY, obstacles, sourceGateX, sourceGateY, destGateX, destGateY); // orthogonal, gate-clear, never a diagonal
+}

package/dist/renderer/gates.d.ts

@@ -0,0 +1,19 @@
+import type { DiagramTheme } from '../theme/themes.js';
+export declare const PORT_SIZE = 5;
+export declare const PORT_R = 3;
+export declare const GATE_W = 60;
+export declare const GATE_W_MULTI = 75;
+export declare const NOT_TRIANGLE_W = 50;
+export declare const BUBBLE_R = 5;
+export declare const NOT_GATE_TOTAL_W: number;
+export declare const NOT_GATE_H = 40;
+export declare const AND_GATE_H_BASE = 45;
+export declare const PORT_SPACING = 15;
+export declare const OR_CURVE_DEPTH = 10;
+export declare function andGateBody(w: number, h: number): string;
+export declare function orGateBody(w: number, h: number): string;
+export declare function orCurveTapX(h: number, localY: number): number;
+export declare function notGateBody(w: number, h: number): string;
+export declare function renderJunctionDot(x: number, y: number, theme: DiagramTheme): string;
+export declare function renderInputPortLabel(absX: number, absY: number, label: string, theme: DiagramTheme, name?: string, description?: string): string;
+export declare function renderOutputPortLabel(absX: number, absY: number, label: string, theme: DiagramTheme, name?: string, description?: string): string;

package/dist/renderer/gates.js

@@ -0,0 +1,92 @@
+export const PORT_SIZE = 5;
+export const PORT_R = 3;
+export const GATE_W = 60;
+export const GATE_W_MULTI = 75;
+export const NOT_TRIANGLE_W = 50;
+export const BUBBLE_R = 5;
+export const NOT_GATE_TOTAL_W = NOT_TRIANGLE_W + BUBBLE_R * 2 + 5;
+export const NOT_GATE_H = 40;
+export const AND_GATE_H_BASE = 45;
+export const PORT_SPACING = 15;
+// Maximum rightward bulge of the OR gate's concave left edge, at mid-height.
+// Fixed (independent of gate height) so concavity reads consistently across sizes.
+export const OR_CURVE_DEPTH = 10;
+function esc(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+export function andGateBody(w, h) {
+    // Rounded right side. Cap the corner radius at w/2 so tall gates don't produce a
+    // negative top edge (r=h/2 would make w-r < 0 once h > w) — the body then becomes a
+    // stadium/rounded rectangle. For short gates (h <= w) this is exactly the classic
+    // semicircular "D" shape, since the straight right edge between the corners is zero.
+    const r = Math.min(h / 2, w / 2);
+    return [
+        `M 0,0`,
+        `L ${w - r},0`,
+        `A ${r},${r} 0 0 1 ${w},${r}`,
+        `L ${w},${h - r}`,
+        `A ${r},${r} 0 0 1 ${w - r},${h}`,
+        `L 0,${h}`,
+        `Z`,
+    ].join(' ');
+}
+export function orGateBody(w, h) {
+    // Left edge is a single quadratic Bézier whose control point (2*depth, h/2)
+    // makes the curve's X an exact function of Y: x(localY) = orCurveTapX(h, localY).
+    // This lets input ports tap the curve precisely and keeps a constant concavity.
+    const cx = OR_CURVE_DEPTH * 2;
+    return [
+        `M 0,0`,
+        `C ${w * 0.5},0 ${w * 0.8},${h * 0.15} ${w},${h / 2}`,
+        `C ${w * 0.8},${h * 0.85} ${w * 0.5},${h} 0,${h}`,
+        `Q ${cx},${h / 2} 0,0`,
+        `Z`,
+    ].join(' ');
+}
+// Exact X (rightward offset from the bbox left edge) of the OR gate's concave left
+// curve at a given local Y. Derived from the quadratic Bézier in orGateBody:
+//   x(localY) = 4 * depth * (localY/h) * (1 - localY/h)
+// Peaks at OR_CURVE_DEPTH when localY == h/2, and is 0 at the top/bottom corners.
+export function orCurveTapX(h, localY) {
+    if (h <= 0)
+        return 0;
+    const f = localY / h;
+    return 4 * OR_CURVE_DEPTH * f * (1 - f);
+}
+export function notGateBody(w, h) {
+    return `M 0,0 L ${w},${h / 2} L 0,${h} Z`;
+}
+export function renderJunctionDot(x, y, theme) {
+    return `<circle class="ldl-junction" cx="${x}" cy="${y}" r="4" fill="${theme.junctionFill}" stroke="${theme.junctionFill}" stroke-width="1"/>`;
+}
+export function renderInputPortLabel(absX, absY, label, theme, name, description) {
+    const displayName = name || label;
+    const labelGap = 6;
+    const textX = absX - labelGap;
+    const nameY = description ? absY - 6 : absY + 4;
+    const descY = description ? absY + 12 : 0;
+    const parts = [];
+    parts.push(`<text class="ldl-label ldl-name" x="${textX}" y="${nameY}" text-anchor="end" fill="${theme.nameFill}" font-size="12" font-family="sans-serif" font-weight="500">${esc(displayName)}</text>`);
+    if (description) {
+        parts.push(`<text class="ldl-label ldl-description" x="${textX}" y="${descY}" text-anchor="end" fill="${theme.descFill}" font-size="9" font-family="sans-serif">${esc(description)}</text>`);
+    }
+    // The id text is emitted separately by renderNodeIds (svg-renderer), gated on showIds, so it is
+    // omitted from the SVG entirely when IDs are off — a CSS-hidden id leaks into non-browser SVG
+    // viewers, which was the bug. `label` is retained above as the displayName fallback.
+    return parts.join('\n');
+}
+export function renderOutputPortLabel(absX, absY, label, theme, name, description) {
+    const displayName = name || label;
+    const labelGap = 6;
+    const textX = absX + labelGap;
+    const nameY = description ? absY - 6 : absY + 4;
+    const descY = description ? absY + 12 : 0;
+    const parts = [];
+    parts.push(`<text class="ldl-label ldl-name" x="${textX}" y="${nameY}" text-anchor="start" fill="${theme.nameOutFill}" font-size="12" font-family="sans-serif" font-weight="600">${esc(displayName)}</text>`);
+    if (description) {
+        parts.push(`<text class="ldl-label ldl-description" x="${textX}" y="${descY}" text-anchor="start" fill="${theme.descFill}" font-size="9" font-family="sans-serif">${esc(description)}</text>`);
+    }
+    // The id text is emitted separately by renderNodeIds (svg-renderer), gated on showIds — see note
+    // in renderInputPortLabel.
+    return parts.join('\n');
+}

package/dist/renderer/graph.d.ts

@@ -0,0 +1,31 @@
+import type { LogicNode, Diagram, PortMeta, RenderOptions } from '../parser/ast.js';
+export interface FlatNode {
+    id: string;
+    kind: 'gate' | 'input' | 'output';
+    gateType?: string;
+    label?: string;
+    name?: string;
+    description?: string;
+    depth: number;
+    inputIds: string[];
+    invertedInputs?: Set<number>;
+    bubbledOutput?: boolean;
+    blockType?: string;
+    params?: Record<string, string>;
+    usedPorts?: Set<string>;
+    inputPorts?: (string | undefined)[];
+    inputLabels?: (string | undefined)[];
+    portGap?: number;
+}
+export interface IntermediateLabel {
+    driverId: string;
+    port?: string;
+    name?: string;
+    description?: string;
+}
+export interface Graph {
+    nodes: Map<string, FlatNode>;
+    intermediateLabels: IntermediateLabel[];
+}
+export declare function flattenGate(node: LogicNode): LogicNode;
+export declare function buildGraph(diagram: Diagram, portMeta: PortMeta[], opts: RenderOptions, uid: (prefix: string) => string): Graph;