@schemd/core 0.3.0 → 0.3.2

package/dist/layout.js

@@ -61,6 +61,8 @@ export function rotateQuarterExtents(extents, turn) {
 }
 const MAX_ROUTER_STATES = 40_000;
 const ROUTER_BEND_PENALTY = 0.25;
+const ROUTER_CROSSING_PENALTY = 8;
+const ROUTER_CHANNEL_REUSE_PENALTY = 16_384;
 const CROSSING_BUCKET_SIZE = 64;
 const MIN_RENDERABLE_BRIDGE_RADIUS = 0.001;
 const DESIGNATOR_BASELINE_GAP = 10;
@@ -68,6 +70,7 @@ const LABEL_BASELINE_GAP = 19;
 const TEXT_ASCENT_GUTTER = 12;
 const TEXT_DESCENT_GUTTER = 5;
 const TEXT_ADVANCE = 7;
+const CONNECTION_TEXT_ADVANCE = 6;
 const TEXT_HORIZONTAL_GUTTER = 4;
 const PASSIVE_INPUT_PORTS = new Set(['in', 'left', 'l']);
 const PASSIVE_OUTPUT_PORTS = new Set(['out', 'right', 'r']);
@@ -76,18 +79,27 @@ const DIODE_CATHODE_PORTS = new Set(['cathode', 'k', 'c']);
 const TRANSISTOR_CONTROL_PORTS = new Set(['base', 'gate', 'b', 'g']);
 const TRANSISTOR_UPPER_PORTS = new Set(['collector', 'drain', 'c', 'd']);
 const TRANSISTOR_LOWER_PORTS = new Set(['emitter', 'source', 'e', 's']);
-function formatNumber(value) {
+export function formatNumber(value) {
     const rounded = Math.abs(value) < 0.0005 ? 0 : Number(value.toFixed(3));
     return String(rounded);
 }
 export function distributedCoordinate(index, count, span) {
     return ((index + 1) * span) / (count + 1) - span / 2;
 }
+export function quantumTrackSpan(tracks) {
+    return Math.max(16, (tracks - 1) * 18);
+}
+export function quantumTrackCoordinate(index, tracks) {
+    if (tracks <= 1)
+        return 0;
+    const span = quantumTrackSpan(tracks);
+    return -span / 2 + (index * span) / (tracks - 1);
+}
 export function classicalGateHeight(component) {
     return Math.max(48, Math.max(component.inputs, component.outputs) * 16);
 }
 export function quantumGateDimensions(component) {
-    const details = [component.parameter, component.phase, component.matrix].filter((value) => value !== undefined);
+    const details = [component.parameter, component.phase, component.matrix].filter((value) => value !== undefined && value !== '');
     let widest = 16;
     if (details.length > 0 && component.kind === 'qgate')
         widest = mathLabelTextWidth(component.label, 8);
@@ -97,16 +109,16 @@ export function quantumGateDimensions(component) {
     const bodyHeight = 50 + details.length * 15;
     return { bodyWidth, bodyHeight, stubExtent: bodyWidth / 2 + 23 };
 }
-function isClassicalGate(component) {
+export function isClassicalGate(component) {
     return CLASSICAL_GATE_KINDS.includes(component.kind);
 }
-function isDigitalComponent(component) {
+export function isDigitalComponent(component) {
     return DIGITAL_COMPONENT_KINDS.includes(component.kind);
 }
-function isQuantumSpecial(component) {
+export function isQuantumSpecial(component) {
     return QUANTUM_SPECIAL_KINDS.includes(component.kind);
 }
-function isUmlComponent(component) {
+export function isUmlComponent(component) {
     return UML_COMPONENT_KINDS.includes(component.kind);
 }
 function componentTurn(component) {
@@ -454,12 +466,12 @@ export function resolvePortPoint(component, port) {
                 index += component.controls;
             const tracks = Math.max(component.wires, component.controls + component.targets);
             if (port.startsWith('control') || port.startsWith('target')) {
-                local = { x: 0, y: distributedCoordinate(index, Math.max(1, tracks), Math.max(16, (tracks - 1) * 18)) };
+                local = { x: 0, y: quantumTrackCoordinate(index, tracks) };
             }
             else {
                 local = {
                     x: port.startsWith('out') ? 42 : -42,
-                    y: distributedCoordinate(index, Math.max(1, tracks), Math.max(16, (tracks - 1) * 18))
+                    y: quantumTrackCoordinate(index, tracks)
                 };
             }
             break;
@@ -785,6 +797,96 @@ export function componentObstacleRectangle(component, clearance = SCHEMATIC_OBST
     }
     return expandedComponentRectangle(component, clearance);
 }
+export function connectionLabelPoint(route) {
+    if (route.curve === 'bezier' && route.points.length >= 4) {
+        const a = route.points[0];
+        const b = route.points[1];
+        const c = route.points[2];
+        const d = route.points[3];
+        return {
+            x: (a.x + 3 * b.x + 3 * c.x + d.x) / 8,
+            y: (a.y + 3 * b.y + 3 * c.y + d.y) / 8
+        };
+    }
+    let total = 0;
+    for (let index = 1; index < route.points.length; index += 1) {
+        total +=
+            Math.abs(route.points[index].x - route.points[index - 1].x) +
+                Math.abs(route.points[index].y - route.points[index - 1].y);
+    }
+    let remaining = total / 2;
+    for (let index = 1; index < route.points.length; index += 1) {
+        const start = route.points[index - 1];
+        const end = route.points[index];
+        const length = Math.abs(end.x - start.x) + Math.abs(end.y - start.y);
+        if (remaining <= length) {
+            const ratio = length === 0 ? 0 : remaining / length;
+            return { x: start.x + (end.x - start.x) * ratio, y: start.y + (end.y - start.y) * ratio };
+        }
+        remaining -= length;
+    }
+    return route.points.at(-1);
+}
+export function connectionLabelRectangle(connection, route) {
+    if (connection.label === undefined)
+        return undefined;
+    const point = connectionLabelPoint(route);
+    const halfWidth = mathLabelTextWidth(connection.label, CONNECTION_TEXT_ADVANCE) / 2 + 3;
+    return {
+        minX: point.x - halfWidth,
+        minY: point.y - 20,
+        maxX: point.x + halfWidth,
+        maxY: point.y
+    };
+}
+function addRoutingRectangle(index, owner, kind, rectangle) {
+    const entry = { owner, kind, rectangle, seen: 0 };
+    index.rectangles.push(entry);
+    const minimum = Math.floor(rectangle.minX / CROSSING_BUCKET_SIZE);
+    const maximum = Math.floor(rectangle.maxX / CROSSING_BUCKET_SIZE);
+    for (let bucket = minimum; bucket <= maximum; bucket += 1) {
+        const entries = index.rectangleBuckets.get(bucket) ?? [];
+        entries.push(entry);
+        index.rectangleBuckets.set(bucket, entries);
+    }
+}
+function componentLabelRectangles(component) {
+    if (isUmlComponent(component))
+        return [];
+    const anchors = componentTextAnchors(component);
+    return [
+        {
+            minX: component.x - anchors.designatorWidth / 2 - TEXT_HORIZONTAL_GUTTER,
+            minY: component.y + anchors.designatorY - TEXT_ASCENT_GUTTER,
+            maxX: component.x + anchors.designatorWidth / 2 + TEXT_HORIZONTAL_GUTTER,
+            maxY: component.y + anchors.designatorY + TEXT_DESCENT_GUTTER
+        },
+        {
+            minX: component.x - anchors.labelWidth / 2 - TEXT_HORIZONTAL_GUTTER,
+            minY: component.y + anchors.labelY - TEXT_ASCENT_GUTTER,
+            maxX: component.x + anchors.labelWidth / 2 + TEXT_HORIZONTAL_GUTTER,
+            maxY: component.y + anchors.labelY + TEXT_DESCENT_GUTTER
+        }
+    ];
+}
+function createRoutingIndex(components) {
+    const index = {
+        rectangles: [],
+        rectangleBuckets: new Map(),
+        wireBuckets: new Map(),
+        nextWireKey: 0,
+        rectangleQuery: 0,
+        wireQuery: 0
+    };
+    for (const component of components.values()) {
+        addRoutingRectangle(index, component.id, 'body', componentObstacleRectangle(component, 0));
+        addRoutingRectangle(index, component.id, 'expanded', componentObstacleRectangle(component));
+        for (const label of componentLabelRectangles(component)) {
+            addRoutingRectangle(index, component.id, 'label', label);
+        }
+    }
+    return index;
+}
 function segmentIntersectsRectangle(start, end, rectangle) {
     if (start.y === end.y) {
         return (start.y > rectangle.minY &&
@@ -792,16 +894,94 @@ function segmentIntersectsRectangle(start, end, rectangle) {
             Math.max(start.x, end.x) > rectangle.minX &&
             Math.min(start.x, end.x) < rectangle.maxX);
     }
-    return (start.x > rectangle.minX &&
-        start.x < rectangle.maxX &&
-        Math.max(start.y, end.y) > rectangle.minY &&
-        Math.min(start.y, end.y) < rectangle.maxY);
+    if (start.x === end.x) {
+        return (start.x > rectangle.minX &&
+            start.x < rectangle.maxX &&
+            Math.max(start.y, end.y) > rectangle.minY &&
+            Math.min(start.y, end.y) < rectangle.maxY);
+    }
+    let minimum = 0;
+    let maximum = 1;
+    for (const [origin, delta, low, high] of [
+        [start.x, end.x - start.x, rectangle.minX, rectangle.maxX],
+        [start.y, end.y - start.y, rectangle.minY, rectangle.maxY]
+    ]) {
+        const first = (low - origin) / delta;
+        const second = (high - origin) / delta;
+        minimum = Math.max(minimum, Math.min(first, second));
+        maximum = Math.min(maximum, Math.max(first, second));
+        if (minimum >= maximum)
+            return false;
+    }
+    return maximum > 0 && minimum < 1;
 }
-function routeIntersectsObstacles(points, obstacles) {
-    for (let index = 1; index < points.length; index += 1) {
-        for (const obstacle of obstacles) {
-            if (segmentIntersectsRectangle(points[index - 1], points[index], obstacle))
-                return true;
+function rectangleParticipates(entry, mode, fromId, toId) {
+    const endpoint = entry.owner === fromId || entry.owner === toId;
+    if (mode === 'body')
+        return entry.kind === 'body' && !endpoint;
+    if (mode === 'manual')
+        return !endpoint && entry.kind !== 'expanded';
+    return endpoint ? entry.kind === 'body' : entry.kind !== 'body';
+}
+function indexedSegmentCollision(index, start, end, fromId, toId, mode, margin = 0) {
+    const minimum = Math.floor((Math.min(start.x, end.x) - margin) / CROSSING_BUCKET_SIZE);
+    const maximum = Math.floor((Math.max(start.x, end.x) + margin) / CROSSING_BUCKET_SIZE);
+    const query = ++index.rectangleQuery;
+    for (let bucket = minimum; bucket <= maximum; bucket += 1) {
+        for (const entry of index.rectangleBuckets.get(bucket) ?? []) {
+            if (entry.seen === query || !rectangleParticipates(entry, mode, fromId, toId))
+                continue;
+            entry.seen = query;
+            const rectangle = margin === 0
+                ? entry.rectangle
+                : {
+                    minX: entry.rectangle.minX - margin,
+                    minY: entry.rectangle.minY - margin,
+                    maxX: entry.rectangle.maxX + margin,
+                    maxY: entry.rectangle.maxY + margin
+                };
+            if (segmentIntersectsRectangle(start, end, rectangle))
+                return entry;
+        }
+    }
+    return undefined;
+}
+function routingRectangles(index, fromId, toId) {
+    return index.rectangles
+        .filter((entry) => rectangleParticipates(entry, 'route', fromId, toId))
+        .map((entry) => entry.rectangle);
+}
+function cubicIntersectsRectangle(points, rectangle) {
+    const minX = Math.min(...points.map((point) => point.x));
+    const minY = Math.min(...points.map((point) => point.y));
+    const maxX = Math.max(...points.map((point) => point.x));
+    const maxY = Math.max(...points.map((point) => point.y));
+    if (maxX <= rectangle.minX ||
+        minX >= rectangle.maxX ||
+        maxY <= rectangle.minY ||
+        minY >= rectangle.maxY) {
+        return false;
+    }
+    if (maxX - minX <= 0.25 && maxY - minY <= 0.25)
+        return true;
+    const midpoint = (left, right) => ({
+        x: (left.x + right.x) / 2,
+        y: (left.y + right.y) / 2
+    });
+    const [a, b, c, d] = points;
+    const ab = midpoint(a, b);
+    const bc = midpoint(b, c);
+    const cd = midpoint(c, d);
+    const abc = midpoint(ab, bc);
+    const bcd = midpoint(bc, cd);
+    const center = midpoint(abc, bcd);
+    return (cubicIntersectsRectangle([a, ab, abc, center], rectangle) ||
+        cubicIntersectsRectangle([center, bcd, cd, d], rectangle));
+}
+function routeIntersectsObstacles(points, spatialIndex, fromId, toId) {
+    for (let pointIndex = 1; pointIndex < points.length; pointIndex += 1) {
+        if (indexedSegmentCollision(spatialIndex, points[pointIndex - 1], points[pointIndex], fromId, toId, 'route')) {
+            return true;
         }
     }
     return false;
@@ -818,6 +998,52 @@ function candidateLength(points) {
 function candidateBends(points) {
     return Math.max(0, points.length - 2);
 }
+function wireSegmentCost(index, start, end, netId) {
+    const minimum = Math.floor(Math.min(start.x, end.x) / CROSSING_BUCKET_SIZE);
+    const maximum = Math.floor(Math.max(start.x, end.x) / CROSSING_BUCKET_SIZE);
+    const query = ++index.wireQuery;
+    const candidate = { id: -1, routeIndex: -1, start, end, orthogonal: true, seen: 0 };
+    let cost = 0;
+    for (let bucket = minimum; bucket <= maximum; bucket += 1) {
+        for (const previous of index.wireBuckets.get(bucket) ?? []) {
+            if (previous.seen === query)
+                continue;
+            previous.seen = query;
+            if (netId !== undefined && previous.netId === netId)
+                continue;
+            const contact = segmentContact(candidate, previous);
+            if (contact !== undefined) {
+                cost += contact.strict && !contact.overlap && previous.orthogonal
+                    ? ROUTER_CROSSING_PENALTY
+                    : ROUTER_CHANNEL_REUSE_PENALTY;
+            }
+        }
+    }
+    return cost;
+}
+function routeOccupancyCost(points, index, netId) {
+    let cost = 0;
+    for (let pointIndex = 1; pointIndex < points.length; pointIndex += 1) {
+        cost += wireSegmentCost(index, points[pointIndex - 1], points[pointIndex], netId);
+    }
+    return cost;
+}
+function indexCompletedRoute(index, route, connection, routeIndex) {
+    const segments = traceSegments(route, routeIndex, index.nextWireKey, connection.netId);
+    index.nextWireKey += segments.length;
+    for (const segment of segments) {
+        const minimum = Math.floor(Math.min(segment.start.x, segment.end.x) / CROSSING_BUCKET_SIZE);
+        const maximum = Math.floor(Math.max(segment.start.x, segment.end.x) / CROSSING_BUCKET_SIZE);
+        for (let bucket = minimum; bucket <= maximum; bucket += 1) {
+            const entries = index.wireBuckets.get(bucket) ?? [];
+            entries.push(segment);
+            index.wireBuckets.set(bucket, entries);
+        }
+    }
+    const label = connectionLabelRectangle(connection, route);
+    if (label !== undefined)
+        addRoutingRectangle(index, `wire-${routeIndex}`, 'label', label);
+}
 class RouteHeap {
     #items = [];
     get size() {
@@ -868,7 +1094,7 @@ class RouteHeap {
 function uniqueSorted(values) {
     return [...new Set(values)].sort((left, right) => left - right);
 }
-function searchOrthogonalRoute(start, end, obstacles, bounds, line) {
+function searchOrthogonalRoute(start, end, obstacles, index, fromId, toId, netId, bounds, line) {
     const withinX = (value) => bounds === undefined || (value >= 0 && value <= bounds.width);
     const withinY = (value) => bounds === undefined || (value >= 0 && value <= bounds.height);
     const boundaryXs = bounds === undefined ? [] : [0, bounds.width];
@@ -929,19 +1155,16 @@ function searchOrthogonalRoute(start, end, obstacles, bounds, line) {
             if (nextX < 0 || nextY < 0 || nextX >= width || nextY >= ys.length)
                 continue;
             const to = { x: xs[nextX], y: ys[nextY] };
-            let blocked = false;
-            for (const obstacle of obstacles) {
-                if (segmentIntersectsRectangle(from, to, obstacle)) {
-                    blocked = true;
-                    break;
-                }
-            }
-            if (blocked)
+            if (indexedSegmentCollision(index, from, to, fromId, toId, 'route'))
                 continue;
             const cell = nextY * width + nextX;
             const state = stateId(cell, direction);
             const bend = current.direction !== 0 && current.direction !== direction;
-            const g = current.g + Math.abs(from.x - to.x) + Math.abs(from.y - to.y) + (bend ? ROUTER_BEND_PENALTY : 0);
+            const g = current.g +
+                Math.abs(from.x - to.x) +
+                Math.abs(from.y - to.y) +
+                (bend ? ROUTER_BEND_PENALTY : 0) +
+                wireSegmentCost(index, from, to, netId);
             if (g >= (gScore.get(state) ?? Number.POSITIVE_INFINITY))
                 continue;
             gScore.set(state, g);
@@ -969,7 +1192,7 @@ function searchOrthogonalRoute(start, end, obstacles, bounds, line) {
     }
     return compactOrthogonalPoints(reversed.reverse());
 }
-function routeBetweenEscapes(start, end, obstacles, bounds, line) {
+function routeBetweenEscapes(start, end, obstacles, index, fromId, toId, netId, bounds, line) {
     const middleX = (start.x + end.x) / 2;
     const direct = compactOrthogonalPoints([
         start,
@@ -977,9 +1200,26 @@ function routeBetweenEscapes(start, end, obstacles, bounds, line) {
         { x: middleX, y: end.y },
         end
     ]);
-    if (!routeIntersectsObstacles(direct, obstacles))
-        return direct;
-    const candidates = [];
+    let best;
+    let bestScore = Number.POSITIVE_INFINITY;
+    if (!routeIntersectsObstacles(direct, index, fromId, toId)) {
+        const occupancy = routeOccupancyCost(direct, index, netId);
+        if (occupancy === 0)
+            return direct;
+        best = direct;
+        bestScore = candidateLength(direct) + candidateBends(direct) * ROUTER_BEND_PENALTY + occupancy;
+    }
+    const consider = (raw) => {
+        const candidate = compactOrthogonalPoints(raw);
+        const baseScore = candidateLength(candidate) + candidateBends(candidate) * ROUTER_BEND_PENALTY;
+        if (baseScore >= bestScore || routeIntersectsObstacles(candidate, index, fromId, toId))
+            return;
+        const score = baseScore + routeOccupancyCost(candidate, index, netId);
+        if (score < bestScore) {
+            best = candidate;
+            bestScore = score;
+        }
+    };
     const yLanes = uniqueSorted([
         start.y,
         end.y,
@@ -989,7 +1229,7 @@ function routeBetweenEscapes(start, end, obstacles, bounds, line) {
     for (const y of yLanes) {
         if (bounds !== undefined && (y < 0 || y > bounds.height))
             continue;
-        candidates.push([start, { x: start.x, y }, { x: end.x, y }, end]);
+        consider([start, { x: start.x, y }, { x: end.x, y }, end]);
     }
     const xLanes = uniqueSorted([
         start.x,
@@ -1000,21 +1240,53 @@ function routeBetweenEscapes(start, end, obstacles, bounds, line) {
     for (const x of xLanes) {
         if (bounds !== undefined && (x < 0 || x > bounds.width))
             continue;
-        candidates.push([start, { x, y: start.y }, { x, y: end.y }, end]);
+        consider([start, { x, y: start.y }, { x, y: end.y }, end]);
     }
-    let best;
-    let bestScore = Number.POSITIVE_INFINITY;
-    for (const raw of candidates) {
-        const candidate = compactOrthogonalPoints(raw);
-        if (routeIntersectsObstacles(candidate, obstacles))
+    return best ?? searchOrthogonalRoute(start, end, obstacles, index, fromId, toId, netId, bounds, line);
+}
+function markerCollisionSize(marker) {
+    switch (marker) {
+        case 'dot':
+            return { length: 4, radius: 4 };
+        case 'arrow':
+            return { length: 8, radius: 4 };
+        case 'open-arrow':
+            return { length: 9, radius: 5 };
+        case 'triangle':
+        case 'diamond':
+        case 'diamond-filled':
+            return { length: 12, radius: 6 };
+        default:
+            return { length: 0, radius: 0 };
+    }
+}
+function validateMarkerCollisions(connection, route, index, fromId, toId) {
+    if (connection.markerStart === 'none' && connection.markerEnd === 'none')
+        return route;
+    for (const [atStart, marker] of [
+        [true, connection.markerStart],
+        [false, connection.markerEnd]
+    ]) {
+        const size = markerCollisionSize(marker);
+        if (size.length === 0)
             continue;
-        const score = candidateLength(candidate) + candidateBends(candidate) * ROUTER_BEND_PENALTY;
-        if (score < bestScore) {
-            best = candidate;
-            bestScore = score;
+        const endpoint = atStart ? route.points[0] : route.points.at(-1);
+        const adjacent = atStart ? route.points[1] : route.points.at(-2);
+        const dx = adjacent.x - endpoint.x;
+        const dy = adjacent.y - endpoint.y;
+        const magnitude = Math.hypot(dx, dy);
+        if (magnitude === 0)
+            continue;
+        const inward = {
+            x: endpoint.x + (dx / magnitude) * size.length,
+            y: endpoint.y + (dy / magnitude) * size.length
+        };
+        const collision = indexedSegmentCollision(index, endpoint, inward, fromId, toId, 'body', size.radius);
+        if (collision !== undefined) {
+            throw new SchematicSyntaxError(`${marker} marker intersects ${collision.owner}; use ortho or move the obstacle.`, connection.line);
         }
     }
-    return best ?? searchOrthogonalRoute(start, end, obstacles, bounds, line);
+    return route;
 }
 function endpointsFaceEachOther(from, to) {
     const dx = to.point.x - from.point.x;
@@ -1029,7 +1301,7 @@ function endpointsFaceEachOther(from, to) {
     }
     return false;
 }
-function routeConnectionInternal(connection, components, bounds, cachedObstacles) {
+function routeConnectionInternal(connection, components, bounds, spatialIndex) {
     const from = endpointGeometry(connection.from, components);
     const to = endpointGeometry(connection.to, components);
     const start = from.point;
@@ -1038,29 +1310,29 @@ function routeConnectionInternal(connection, components, bounds, cachedObstacles
     const sy = formatNumber(start.y);
     const ex = formatNumber(end.x);
     const ey = formatNumber(end.y);
+    const routingIndex = spatialIndex ?? createRoutingIndex(components);
     if (connection.curve === 'bezier') {
         const middleX = (start.x + end.x) / 2;
         const controlA = { x: middleX, y: start.y };
         const controlB = { x: middleX, y: end.y };
-        return {
+        for (const obstacle of routingIndex.rectangles) {
+            if (rectangleParticipates(obstacle, 'manual', from.component.id, to.component.id) &&
+                cubicIntersectsRectangle([start, controlA, controlB, end], obstacle.rectangle)) {
+                throw new SchematicSyntaxError(`Bézier route intersects ${obstacle.owner}; use an orthogonal route or move the obstacle.`, connection.line);
+            }
+        }
+        return validateMarkerCollisions(connection, {
             curve: 'bezier',
             d: `M ${sx} ${sy} C ${formatNumber(controlA.x)} ${formatNumber(controlA.y)}, ${formatNumber(controlB.x)} ${formatNumber(controlB.y)}, ${ex} ${ey}`,
             points: [start, controlA, controlB, end]
-        };
+        }, routingIndex, from.component.id, to.component.id);
     }
     if (connection.curve === 'ortho') {
-        const obstacleCache = cachedObstacles ??
-            Array.from(components.values(), (component) => ({
-                id: component.id,
-                expanded: componentObstacleRectangle(component),
-                body: componentObstacleRectangle(component, 0)
-            }));
         if (from.component.id !== to.component.id &&
             endpointsFaceEachOther(from, to) &&
-            !obstacleCache.some((entry) => entry.id !== from.component.id &&
-                entry.id !== to.component.id &&
-                segmentIntersectsRectangle(start, end, entry.expanded))) {
-            return { curve: 'ortho', d: orthogonalPath([start, end]), points: [start, end] };
+            indexedSegmentCollision(routingIndex, start, end, from.component.id, to.component.id, 'route') === undefined &&
+            wireSegmentCost(routingIndex, start, end, connection.netId) === 0) {
+            return validateMarkerCollisions(connection, { curve: 'ortho', d: orthogonalPath([start, end]), points: [start, end] }, routingIndex, from.component.id, to.component.id);
         }
         const fromObstacle = componentObstacleRectangle(from.component);
         const toObstacle = componentObstacleRectangle(to.component);
@@ -1078,9 +1350,8 @@ function routeConnectionInternal(connection, components, bounds, cachedObstacles
         });
         const startEscape = escape(from, fromObstacle);
         const endEscape = escape(to, toObstacle);
-        const obstacleRectangle = (entry) => entry.id === from.component.id || entry.id === to.component.id ? entry.body : entry.expanded;
-        const obstacleRectangles = obstacleCache.map(obstacleRectangle);
-        const middle = routeBetweenEscapes(startEscape, endEscape, obstacleRectangles, bounds, connection.line);
+        const obstacleRectangles = routingRectangles(routingIndex, from.component.id, to.component.id);
+        const middle = routeBetweenEscapes(startEscape, endEscape, obstacleRectangles, routingIndex, from.component.id, to.component.id, connection.netId, bounds, connection.line);
         if (middle === undefined) {
             throw new SchematicSyntaxError('No collision-free orthogonal route exists.', connection.line);
         }
@@ -1088,25 +1359,169 @@ function routeConnectionInternal(connection, components, bounds, cachedObstacles
         for (let index = 1; index < points.length; index += 1) {
             const allowFrom = index === 1;
             const allowTo = index === points.length - 1;
-            for (const obstacle of obstacleCache) {
-                if (!(allowFrom && obstacle.id === from.component.id) &&
-                    !(allowTo && obstacle.id === to.component.id) &&
-                    segmentIntersectsRectangle(points[index - 1], points[index], obstacleRectangle(obstacle))) {
-                    throw new SchematicSyntaxError(`Orthogonal route intersects ${obstacle.id} after routing.`, connection.line);
-                }
+            const collision = indexedSegmentCollision(routingIndex, points[index - 1], points[index], allowFrom ? from.component.id : '', allowTo ? to.component.id : '', 'body');
+            if (collision !== undefined) {
+                throw new SchematicSyntaxError(`Orthogonal route intersects ${collision.owner} after routing.`, connection.line);
             }
         }
-        return {
+        return validateMarkerCollisions(connection, {
             curve: 'ortho',
             d: orthogonalPath(points),
             points: points
-        };
+        }, routingIndex, from.component.id, to.component.id);
+    }
+    const collision = indexedSegmentCollision(routingIndex, start, end, from.component.id, to.component.id, 'manual');
+    if (collision !== undefined) {
+        throw new SchematicSyntaxError(`Line route intersects ${collision.owner}; use an orthogonal route or move the obstacle.`, connection.line);
     }
-    return { curve: 'line', d: `M ${sx} ${sy} L ${ex} ${ey}`, points: [start, end] };
+    return validateMarkerCollisions(connection, { curve: 'line', d: `M ${sx} ${sy} L ${ex} ${ey}`, points: [start, end] }, routingIndex, from.component.id, to.component.id);
 }
 export function routeConnection(connection, components, bounds) {
     return routeConnectionInternal(connection, components, bounds, undefined);
 }
+function connectionsShareNet(left, right) {
+    if (left.netId !== undefined && right.netId !== undefined)
+        return left.netId === right.netId;
+    if (left.net !== undefined && right.net !== undefined && left.net === right.net)
+        return true;
+    const leftEndpoints = [
+        `${left.from.componentId}.${left.from.port}`,
+        `${left.to.componentId}.${left.to.port}`
+    ];
+    return leftEndpoints.includes(`${right.from.componentId}.${right.from.port}`) ||
+        leftEndpoints.includes(`${right.to.componentId}.${right.to.port}`);
+}
+function connectionsAreInternalToSameComponent(left, right) {
+    return (left.from.componentId === left.to.componentId &&
+        right.from.componentId === right.to.componentId &&
+        left.from.componentId === right.from.componentId);
+}
+function traceSegments(route, routeIndex, firstId, netId) {
+    let points = route.points;
+    if (route.curve === 'bezier') {
+        const a = route.points[0];
+        const b = route.points[1];
+        const c = route.points[2];
+        const d = route.points[3];
+        const flattened = [];
+        for (let step = 0; step <= 24; step += 1) {
+            const t = step / 24;
+            const inverse = 1 - t;
+            flattened.push({
+                x: inverse ** 3 * a.x +
+                    3 * inverse ** 2 * t * b.x +
+                    3 * inverse * t ** 2 * c.x +
+                    t ** 3 * d.x,
+                y: inverse ** 3 * a.y +
+                    3 * inverse ** 2 * t * b.y +
+                    3 * inverse * t ** 2 * c.y +
+                    t ** 3 * d.y
+            });
+        }
+        points = flattened;
+    }
+    const segments = [];
+    for (let index = 1; index < points.length; index += 1) {
+        const start = points[index - 1];
+        const end = points[index];
+        if (start.x === end.x && start.y === end.y)
+            continue;
+        segments.push({
+            id: firstId + segments.length,
+            routeIndex,
+            ...(netId === undefined ? {} : { netId }),
+            seen: 0,
+            start,
+            end,
+            orthogonal: route.curve === 'ortho'
+        });
+    }
+    return segments;
+}
+function segmentContact(left, right) {
+    const rx = left.end.x - left.start.x;
+    const ry = left.end.y - left.start.y;
+    const sx = right.end.x - right.start.x;
+    const sy = right.end.y - right.start.y;
+    const qx = right.start.x - left.start.x;
+    const qy = right.start.y - left.start.y;
+    const denominator = rx * sy - ry * sx;
+    const epsilon = 1e-9;
+    if (Math.abs(denominator) <= epsilon) {
+        if (Math.abs(qx * ry - qy * rx) > epsilon)
+            return undefined;
+        const useX = Math.abs(rx) >= Math.abs(ry);
+        const leftStart = useX ? left.start.x : left.start.y;
+        const leftEnd = useX ? left.end.x : left.end.y;
+        const rightStart = useX ? right.start.x : right.start.y;
+        const rightEnd = useX ? right.end.x : right.end.y;
+        const low = Math.max(Math.min(leftStart, leftEnd), Math.min(rightStart, rightEnd));
+        const high = Math.min(Math.max(leftStart, leftEnd), Math.max(rightStart, rightEnd));
+        if (high < low - epsilon)
+            return undefined;
+        return { overlap: high > low + epsilon, strict: false };
+    }
+    const t = (qx * sy - qy * sx) / denominator;
+    const u = (qx * ry - qy * rx) / denominator;
+    if (t < -epsilon || t > 1 + epsilon || u < -epsilon || u > 1 + epsilon)
+        return undefined;
+    return {
+        overlap: false,
+        strict: t > epsilon && t < 1 - epsilon && u > epsilon && u < 1 - epsilon
+    };
+}
+function validateUniversalWireContacts(connections, routes) {
+    if (routes.every((route) => route.curve === 'ortho'))
+        return;
+    const buckets = new Map();
+    let nextSegmentId = 0;
+    for (let routeIndex = 0; routeIndex < routes.length; routeIndex += 1) {
+        const segments = traceSegments(routes[routeIndex], routeIndex, nextSegmentId);
+        nextSegmentId += segments.length;
+        for (const segment of segments) {
+            const checked = new Set();
+            const minimumBucket = Math.floor(Math.min(segment.start.x, segment.end.x) / CROSSING_BUCKET_SIZE);
+            const maximumBucket = Math.floor(Math.max(segment.start.x, segment.end.x) / CROSSING_BUCKET_SIZE);
+            for (let bucket = minimumBucket; bucket <= maximumBucket; bucket += 1) {
+                for (const previous of buckets.get(bucket) ?? []) {
+                    if (checked.has(previous.id))
+                        continue;
+                    checked.add(previous.id);
+                    if (Math.max(segment.start.y, segment.end.y) <
+                        Math.min(previous.start.y, previous.end.y) ||
+                        Math.min(segment.start.y, segment.end.y) >
+                            Math.max(previous.start.y, previous.end.y)) {
+                        continue;
+                    }
+                    const contact = segmentContact(segment, previous);
+                    if (contact === undefined ||
+                        connectionsAreInternalToSameComponent(connections[routeIndex], connections[previous.routeIndex]) ||
+                        connectionsShareNet(connections[routeIndex], connections[previous.routeIndex])) {
+                        continue;
+                    }
+                    const bridgeable = contact.strict &&
+                        !contact.overlap &&
+                        segment.orthogonal &&
+                        previous.orthogonal &&
+                        (segment.start.x === segment.end.x) !==
+                            (previous.start.x === previous.end.x);
+                    if (!bridgeable) {
+                        throw new SchematicSyntaxError('Separate nets touch or cross without an orthogonal bridge; use ortho, a shared net, or an explicit junction.', connections[routeIndex].line);
+                    }
+                }
+            }
+        }
+        for (const segment of segments) {
+            const minimumBucket = Math.floor(Math.min(segment.start.x, segment.end.x) / CROSSING_BUCKET_SIZE);
+            const maximumBucket = Math.floor(Math.max(segment.start.x, segment.end.x) / CROSSING_BUCKET_SIZE);
+            for (let bucket = minimumBucket; bucket <= maximumBucket; bucket += 1) {
+                const entries = buckets.get(bucket) ?? [];
+                entries.push(segment);
+                buckets.set(bucket, entries);
+            }
+        }
+    }
+}
 function axisSegments(route, routeIndex) {
     const segments = [];
     if (route.curve !== 'ortho')
@@ -1135,12 +1550,29 @@ function segmentCrossing(left, right) {
     }
     return point;
 }
-function bridgedOrthogonalPath(route, crossings) {
+function axisSegmentsTouch(left, right) {
+    if (left.orientation === right.orientation) {
+        if ((left.orientation === 'horizontal' && left.start.y !== right.start.y) ||
+            (left.orientation === 'vertical' && left.start.x !== right.start.x)) {
+            return false;
+        }
+        const coordinate = left.orientation === 'horizontal' ? 'x' : 'y';
+        return (Math.max(Math.min(left.start[coordinate], left.end[coordinate]), Math.min(right.start[coordinate], right.end[coordinate])) <=
+            Math.min(Math.max(left.start[coordinate], left.end[coordinate]), Math.max(right.start[coordinate], right.end[coordinate])));
+    }
+    const horizontal = left.orientation === 'horizontal' ? left : right;
+    const vertical = left.orientation === 'vertical' ? left : right;
+    return (vertical.start.x >= Math.min(horizontal.start.x, horizontal.end.x) &&
+        vertical.start.x <= Math.max(horizontal.start.x, horizontal.end.x) &&
+        horizontal.start.y >= Math.min(vertical.start.y, vertical.end.y) &&
+        horizontal.start.y <= Math.max(vertical.start.y, vertical.end.y));
+}
+function bridgedOrthogonalPath(route, crossings, line) {
     if (crossings.size === 0)
         return route;
     const first = route.points[0];
     let path = `M ${formatNumber(first.x)} ${formatNumber(first.y)}`;
-    const boundsPoints = [...route.points];
+    const boundsPoints = [first];
     for (let index = 1; index < route.points.length; index += 1) {
         const start = route.points[index - 1];
         const end = route.points[index];
@@ -1165,15 +1597,16 @@ function bridgedOrthogonalPath(route, crossings) {
             let cursorX = start.x;
             for (const [crossingIndex, crossing] of segmentCrossings.entries()) {
                 const radius = radii[crossingIndex];
-                if (radius < MIN_RENDERABLE_BRIDGE_RADIUS)
-                    continue;
+                if (radius < MIN_RENDERABLE_BRIDGE_RADIUS) {
+                    throw new SchematicSyntaxError('Wire crossings are too close to render distinct bridge arcs.', line);
+                }
                 const before = crossing.x - direction * radius;
                 const after = crossing.x + direction * radius;
                 if (before !== cursorX)
                     path += ` H ${formatNumber(before)}`;
                 path += ` A ${formatNumber(radius)} ${formatNumber(radius)} 0 0 ${direction > 0 ? 1 : 0} ${formatNumber(after)} ${formatNumber(crossing.y)}`;
                 cursorX = after;
-                boundsPoints.push({ x: before, y: crossing.y }, { x: after, y: crossing.y }, { x: crossing.x, y: crossing.y - radius });
+                boundsPoints.push({ x: before, y: crossing.y }, { x: crossing.x, y: crossing.y - radius }, { x: after, y: crossing.y });
             }
             if (cursorX !== end.x)
                 path += ` H ${formatNumber(end.x)}`;
@@ -1182,19 +1615,23 @@ function bridgedOrthogonalPath(route, crossings) {
             let cursorY = start.y;
             for (const [crossingIndex, crossing] of segmentCrossings.entries()) {
                 const radius = radii[crossingIndex];
-                if (radius < MIN_RENDERABLE_BRIDGE_RADIUS)
-                    continue;
+                if (radius < MIN_RENDERABLE_BRIDGE_RADIUS) {
+                    throw new SchematicSyntaxError('Wire crossings are too close to render distinct bridge arcs.', line);
+                }
                 const before = crossing.y - direction * radius;
                 const after = crossing.y + direction * radius;
                 if (before !== cursorY)
                     path += ` V ${formatNumber(before)}`;
                 path += ` A ${formatNumber(radius)} ${formatNumber(radius)} 0 0 ${direction > 0 ? 0 : 1} ${formatNumber(crossing.x)} ${formatNumber(after)}`;
                 cursorY = after;
-                boundsPoints.push({ x: crossing.x, y: before }, { x: crossing.x, y: after }, { x: crossing.x - radius, y: crossing.y });
+                boundsPoints.push({ x: crossing.x, y: before }, { x: crossing.x - radius, y: crossing.y }, { x: crossing.x, y: after });
             }
             if (cursorY !== end.y)
                 path += ` V ${formatNumber(end.y)}`;
         }
+        if (boundsPoints.at(-1).x !== end.x || boundsPoints.at(-1).y !== end.y) {
+            boundsPoints.push(end);
+        }
     }
     return {
         curve: route.curve,
@@ -1203,12 +1640,14 @@ function bridgedOrthogonalPath(route, crossings) {
     };
 }
 export function routeConnections(connections, components, bounds) {
-    const cachedObstacles = Array.from(components.values(), (component) => ({
-        id: component.id,
-        expanded: componentObstacleRectangle(component),
-        body: componentObstacleRectangle(component, 0)
-    }));
-    const routes = connections.map((connection) => routeConnectionInternal(connection, components, bounds, cachedObstacles));
+    const spatialIndex = createRoutingIndex(components);
+    const routes = [];
+    for (const [routeIndex, connection] of connections.entries()) {
+        const route = routeConnectionInternal(connection, components, bounds, spatialIndex);
+        routes.push(route);
+        indexCompletedRoute(spatialIndex, route, connection, routeIndex);
+    }
+    validateUniversalWireContacts(connections, routes);
     const horizontalBuckets = new Map();
     const verticalBuckets = new Map();
     const crossingsByRoute = new Map();
@@ -1232,28 +1671,55 @@ export function routeConnections(connections, components, bounds) {
         }
         routeCrossings.set(segmentIndex, points);
     };
+    const rejectUnbridgeableContact = (routeIndex) => {
+        throw new SchematicSyntaxError('Separate nets touch or overlap without a bridgeable crossing; use a shared net or an explicit junction.', connections[routeIndex]?.line);
+    };
     for (let routeIndex = 0; routeIndex < routes.length; routeIndex += 1) {
         const route = routes[routeIndex];
         for (const segment of axisSegments(route, routeIndex)) {
             if (segment.orientation === 'horizontal') {
+                for (const previous of horizontalBuckets.get(Math.floor(segment.start.y / CROSSING_BUCKET_SIZE)) ?? []) {
+                    if (axisSegmentsTouch(segment, previous) &&
+                        !connectionsShareNet(connections[routeIndex], connections[previous.routeIndex])) {
+                        rejectUnbridgeableContact(routeIndex);
+                    }
+                }
                 const minBucket = Math.floor(Math.min(segment.start.x, segment.end.x) / CROSSING_BUCKET_SIZE);
                 const maxBucket = Math.floor(Math.max(segment.start.x, segment.end.x) / CROSSING_BUCKET_SIZE);
                 for (let bucket = minBucket; bucket <= maxBucket; bucket += 1) {
                     for (const previous of verticalBuckets.get(bucket) ?? []) {
                         const crossing = segmentCrossing(segment, previous);
-                        if (crossing !== undefined)
+                        const shared = connectionsShareNet(connections[routeIndex], connections[previous.routeIndex]);
+                        if (crossing !== undefined &&
+                            !shared) {
                             recordCrossing(routeIndex, segment.segmentIndex, crossing);
+                        }
+                        else if (crossing === undefined && !shared && axisSegmentsTouch(segment, previous)) {
+                            rejectUnbridgeableContact(routeIndex);
+                        }
                     }
                 }
             }
             else {
+                for (const previous of verticalBuckets.get(Math.floor(segment.start.x / CROSSING_BUCKET_SIZE)) ?? []) {
+                    if (axisSegmentsTouch(segment, previous) &&
+                        !connectionsShareNet(connections[routeIndex], connections[previous.routeIndex])) {
+                        rejectUnbridgeableContact(routeIndex);
+                    }
+                }
                 const minBucket = Math.floor(Math.min(segment.start.y, segment.end.y) / CROSSING_BUCKET_SIZE);
                 const maxBucket = Math.floor(Math.max(segment.start.y, segment.end.y) / CROSSING_BUCKET_SIZE);
                 for (let bucket = minBucket; bucket <= maxBucket; bucket += 1) {
                     for (const previous of horizontalBuckets.get(bucket) ?? []) {
                         const crossing = segmentCrossing(segment, previous);
-                        if (crossing !== undefined)
+                        const shared = connectionsShareNet(connections[routeIndex], connections[previous.routeIndex]);
+                        if (crossing !== undefined &&
+                            !shared) {
                             recordCrossing(routeIndex, segment.segmentIndex, crossing);
+                        }
+                        else if (crossing === undefined && !shared && axisSegmentsTouch(segment, previous)) {
+                            rejectUnbridgeableContact(routeIndex);
+                        }
                     }
                 }
             }
@@ -1265,7 +1731,7 @@ export function routeConnections(connections, components, bounds) {
             index.set(bucketIndex, bucket);
         }
     }
-    return routes.map((route, index) => bridgedOrthogonalPath(route, crossingsByRoute.get(index) ?? new Map()));
+    return routes.map((route, index) => bridgedOrthogonalPath(route, crossingsByRoute.get(index) ?? new Map(), connections[index]?.line));
 }
 function componentHalfExtents(component) {
     let halfWidth;
@@ -1426,7 +1892,89 @@ function rectangleInsideBounds(rectangle, bounds) {
 function pointInsideBounds(point, bounds) {
     return point.x >= 0 && point.y >= 0 && point.x <= bounds.width && point.y <= bounds.height;
 }
+const OVERLAP_CONTAINER_KINDS = new Set([
+    'package',
+    'component',
+    'node',
+    'device',
+    'system',
+    'partition',
+    'fragment',
+    'interaction',
+    'region'
+]);
+function rectangleContains(outer, inner) {
+    return (outer.minX <= inner.minX &&
+        outer.minY <= inner.minY &&
+        outer.maxX >= inner.maxX &&
+        outer.maxY >= inner.maxY);
+}
+function rectanglesOverlap(left, right) {
+    return (left.minX < right.maxX &&
+        left.maxX > right.minX &&
+        left.minY < right.maxY &&
+        left.maxY > right.minY);
+}
+function componentOverlapAllowed(left, right) {
+    for (const [container, child] of [
+        [left, right],
+        [right, left]
+    ]) {
+        if (OVERLAP_CONTAINER_KINDS.has(container.component.kind) &&
+            (rectangleContains(container.rectangle, child.rectangle) ||
+                (['component-port', 'gate'].includes(child.component.kind) &&
+                    child.component.x >= container.rectangle.minX &&
+                    child.component.x <= container.rectangle.maxX &&
+                    child.component.y >= container.rectangle.minY &&
+                    child.component.y <= container.rectangle.maxY))) {
+            return true;
+        }
+    }
+    return ((left.component.kind === 'lifeline' &&
+        ['activation', 'execution', 'destruction'].includes(right.component.kind)) ||
+        (right.component.kind === 'lifeline' &&
+            ['activation', 'execution', 'destruction'].includes(left.component.kind)));
+}
+function validateComponentOverlaps(components) {
+    const ordered = components
+        .map((component) => ({
+        component,
+        rectangle: componentObstacleRectangle(component, 0)
+    }))
+        .sort((left, right) => left.rectangle.minX - right.rectangle.minX ||
+        left.rectangle.minY - right.rectangle.minY ||
+        left.component.line - right.component.line);
+    const buckets = [];
+    for (const current of ordered) {
+        const minimumBucket = Math.floor(current.rectangle.minY / CROSSING_BUCKET_SIZE);
+        const maximumBucket = Math.floor(current.rectangle.maxY / CROSSING_BUCKET_SIZE);
+        const candidates = new Set();
+        for (let bucket = minimumBucket; bucket <= maximumBucket; bucket += 1) {
+            const entries = buckets[bucket];
+            if (entries === undefined)
+                continue;
+            let retained = 0;
+            for (const entry of entries) {
+                if (entry.rectangle.maxX <= current.rectangle.minX)
+                    continue;
+                entries[retained++] = entry;
+                candidates.add(entry);
+            }
+            entries.length = retained;
+        }
+        for (const previous of candidates) {
+            if (rectanglesOverlap(previous.rectangle, current.rectangle) &&
+                !componentOverlapAllowed(previous, current)) {
+                throw new SchematicSyntaxError(`${current.component.id} overlaps ${previous.component.id}; move one component or use a UML container.`, current.component.line);
+            }
+        }
+        for (let bucket = minimumBucket; bucket <= maximumBucket; bucket += 1) {
+            (buckets[bucket] ??= []).push(current);
+        }
+    }
+}
 export function validateDocumentGeometry(document, fence, routedConnections) {
+    validateComponentOverlaps(document.components);
     for (const component of document.components) {
         if (!rectangleInsideBounds(componentRectangle(component), fence.bounds)) {
             throw new SchematicSyntaxError(`${component.id} geometry exceeds the declared ${fence.bounds.width}x${fence.bounds.height} bounds.`, component.line);