@schemd/core 0.2.0 → 0.3.0

package/dist/layout.js

@@ -1,12 +1,68 @@
-import { CLASSICAL_GATE_KINDS, UML_COMPONENT_KINDS, SchematicSyntaxError } from './types.js';
+import { CLASSICAL_GATE_KINDS, DIGITAL_COMPONENT_KINDS, QUANTUM_SPECIAL_KINDS, UML_COMPONENT_KINDS, SchematicSyntaxError } from './types.js';
 import { mathLabelTextWidth } from './math-label.js';
 import { MAX_SCHEMATIC_WIRE_CROSSINGS } from './limits.js';
 export const PORT_HOTSPOT_RADIUS = 4;
 export const SCHEMATIC_OBSTACLE_CLEARANCE = 12;
 export const SCHEMATIC_BRIDGE_RADIUS = 5;
+export function orientationQuarterTurn(orientation) {
+    switch (orientation) {
+        case 'right':
+            return 0;
+        case 'down':
+            return 1;
+        case 'left':
+            return 2;
+        case 'up':
+            return 3;
+    }
+}
+function normalizedQuarterTurn(value) {
+    switch (value & 3) {
+        case 0:
+            return 0;
+        case 1:
+            return 1;
+        case 2:
+            return 2;
+        default:
+            return 3;
+    }
+}
+export function composeQuarterTurns(first, second) {
+    return normalizedQuarterTurn(first + second);
+}
+export function inverseQuarterTurn(turn) {
+    return normalizedQuarterTurn(4 - turn);
+}
+function negatedCoordinate(value) {
+    return value === 0 ? 0 : -value;
+}
+function canonicalCoordinate(value) {
+    return value === 0 ? 0 : value;
+}
+export function rotateQuarterPoint(point, turn) {
+    switch (turn) {
+        case 0:
+            return { x: canonicalCoordinate(point.x), y: canonicalCoordinate(point.y) };
+        case 1:
+            return { x: negatedCoordinate(point.y), y: canonicalCoordinate(point.x) };
+        case 2:
+            return { x: negatedCoordinate(point.x), y: negatedCoordinate(point.y) };
+        case 3:
+            return { x: canonicalCoordinate(point.y), y: negatedCoordinate(point.x) };
+    }
+}
+export function rotateQuarterExtents(extents, turn) {
+    const halfWidth = canonicalCoordinate(extents.halfWidth);
+    const halfHeight = canonicalCoordinate(extents.halfHeight);
+    return turn === 1 || turn === 3
+        ? { halfWidth: halfHeight, halfHeight: halfWidth }
+        : { halfWidth, halfHeight };
+}
 const MAX_ROUTER_STATES = 40_000;
 const ROUTER_BEND_PENALTY = 0.25;
 const CROSSING_BUCKET_SIZE = 64;
+const MIN_RENDERABLE_BRIDGE_RADIUS = 0.001;
 const DESIGNATOR_BASELINE_GAP = 10;
 const LABEL_BASELINE_GAP = 19;
 const TEXT_ASCENT_GUTTER = 12;
@@ -30,26 +86,96 @@ export function distributedCoordinate(index, count, span) {
 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);
+    let widest = 16;
+    if (details.length > 0 && component.kind === 'qgate')
+        widest = mathLabelTextWidth(component.label, 8);
+    for (const detail of details)
+        widest = Math.max(widest, mathLabelTextWidth(detail, 7));
+    const bodyWidth = Math.max(50, Math.min(104, widest + 20));
+    const bodyHeight = 50 + details.length * 15;
+    return { bodyWidth, bodyHeight, stubExtent: bodyWidth / 2 + 23 };
+}
 function isClassicalGate(component) {
     return CLASSICAL_GATE_KINDS.includes(component.kind);
 }
+function isDigitalComponent(component) {
+    return DIGITAL_COMPONENT_KINDS.includes(component.kind);
+}
+function isQuantumSpecial(component) {
+    return QUANTUM_SPECIAL_KINDS.includes(component.kind);
+}
 function isUmlComponent(component) {
     return UML_COMPONENT_KINDS.includes(component.kind);
 }
+function componentTurn(component) {
+    return 'orientation' in component && component.orientation !== undefined
+        ? orientationQuarterTurn(component.orientation)
+        : 0;
+}
+function positionedQuarterPoint(component, local) {
+    const rotated = rotateQuarterPoint(local, componentTurn(component));
+    return { x: component.x + rotated.x, y: component.y + rotated.y };
+}
+function positionedQuarterNormal(component, normal) {
+    return rotateQuarterPoint(normal, componentTurn(component));
+}
 function umlHalfExtents(component) {
     switch (component.kind) {
         case 'class':
+        case 'interface':
+        case 'enumeration':
+        case 'datatype':
+        case 'object':
         case 'state':
         case 'usecase':
         case 'lifeline':
         case 'note':
         case 'package':
+        case 'component':
+        case 'artifact':
+        case 'node':
+        case 'device':
+        case 'execution':
+        case 'system':
+        case 'action':
+        case 'object-node':
+        case 'partition':
+        case 'activation':
+        case 'fragment':
+        case 'interaction':
+        case 'region':
             return { halfWidth: component.bodyWidth / 2, halfHeight: component.bodyHeight / 2 };
         case 'actor':
             return { halfWidth: 24, halfHeight: 50 };
         case 'initial':
         case 'final':
+        case 'activity-final':
+        case 'flow-final':
+        case 'provided-interface':
+        case 'required-interface':
+        case 'component-port':
+        case 'destruction':
+        case 'gate':
+        case 'found':
+        case 'lost':
+        case 'state-junction':
+        case 'history':
+        case 'entry':
+        case 'exit':
+        case 'terminate':
             return { halfWidth: 12, halfHeight: 12 };
+        case 'decision':
+        case 'merge':
+        case 'choice':
+            return { halfWidth: 18, halfHeight: 18 };
+        case 'fork':
+        case 'join':
+            return { halfWidth: 38, halfHeight: 5 };
+        case 'send-signal':
+        case 'receive-signal':
+            return { halfWidth: 22, halfHeight: 15 };
     }
 }
 function umlPortPoint(component, port) {
@@ -81,28 +207,30 @@ function indexedPortPoint(component, port) {
     const count = output ? component.outputs : component.inputs;
     const suffix = port.match(/\d+$/)?.[0];
     const index = suffix === undefined ? 0 : Number(suffix) - 1;
-    return {
-        x: component.x + (output ? 48 : -48),
-        y: component.y + distributedCoordinate(index, count, classicalGateHeight(component))
-    };
+    return positionedQuarterPoint(component, {
+        x: output ? 48 : -48,
+        y: distributedCoordinate(index, count, classicalGateHeight(component))
+    });
 }
 export function positionIcPin(component, side, index) {
     const pins = component.pins[side];
     if (!Number.isInteger(index) || index < 0 || index >= pins.length) {
         throw new RangeError(`IC pin index ${index} is outside ${component.id}.${side}.`);
     }
+    let local;
     if (side === 'left' || side === 'right') {
-        return {
-            x: component.x +
-                (side === 'left' ? -component.bodyWidth / 2 - 16 : component.bodyWidth / 2 + 16),
-            y: component.y + distributedCoordinate(index, pins.length, component.bodyHeight)
+        local = {
+            x: side === 'left' ? -component.bodyWidth / 2 - 16 : component.bodyWidth / 2 + 16,
+            y: distributedCoordinate(index, pins.length, component.bodyHeight)
         };
     }
-    return {
-        x: component.x + distributedCoordinate(index, pins.length, component.bodyWidth),
-        y: component.y +
-            (side === 'top' ? -component.bodyHeight / 2 - 16 : component.bodyHeight / 2 + 16)
-    };
+    else {
+        local = {
+            x: distributedCoordinate(index, pins.length, component.bodyWidth),
+            y: side === 'top' ? -component.bodyHeight / 2 - 16 : component.bodyHeight / 2 + 16
+        };
+    }
+    return positionedQuarterPoint(component, local);
 }
 function findIcPinLocation(component, port) {
     const sides = ['left', 'right', 'top', 'bottom'];
@@ -149,73 +277,205 @@ export function resolvePortPoint(component, port) {
             return point;
         throw new Error(`Validated port ${component.id}.${port} is missing.`);
     }
-    const left = { x: component.x - 42, y: component.y };
-    const right = { x: component.x + 42, y: component.y };
+    if (component.kind === 'ic') {
+        const location = icPinLocation(component, port);
+        if (location !== undefined)
+            return location.point;
+        throw new Error(`Validated port ${component.id}.${port} is missing.`);
+    }
+    let local;
+    const left = { x: -42, y: 0 };
+    const right = { x: 42, y: 0 };
     switch (component.kind) {
         case 'resistor':
         case 'capacitor':
         case 'inductor':
             if (PASSIVE_INPUT_PORTS.has(port))
-                return left;
+                local = left;
             if (PASSIVE_OUTPUT_PORTS.has(port))
-                return right;
+                local = right;
             break;
         case 'diode':
             if (DIODE_ANODE_PORTS.has(port))
-                return left;
+                local = left;
             if (DIODE_CATHODE_PORTS.has(port))
-                return right;
+                local = right;
             break;
         case 'transistor':
             if (TRANSISTOR_CONTROL_PORTS.has(port))
-                return left;
-            if (TRANSISTOR_UPPER_PORTS.has(port)) {
-                return { x: component.x + 42, y: component.y - 22 };
-            }
-            if (TRANSISTOR_LOWER_PORTS.has(port)) {
-                return { x: component.x + 42, y: component.y + 22 };
-            }
+                local = left;
+            if (TRANSISTOR_UPPER_PORTS.has(port))
+                local = { x: 42, y: -22 };
+            if (TRANSISTOR_LOWER_PORTS.has(port))
+                local = { x: 42, y: 22 };
             break;
         case 'port':
             if (port === 'in')
-                return left;
+                local = left;
             if (port === 'out')
-                return right;
+                local = right;
             break;
         case 'ground':
             if (port === 'in')
-                return { x: component.x, y: component.y - 42 };
+                local = { x: 0, y: -42 };
             break;
         case 'hadamard':
         case 'qgate':
+        case 'xgate':
+        case 'ygate':
+        case 'zgate':
+        case 'sgate':
+        case 'sdg':
+        case 'tgate':
+        case 'tdg':
+        case 'sx':
+        case 'phase':
+        case 'rx':
+        case 'ry':
+        case 'rz':
+        case 'ugate':
             if (port === 'in')
-                return { x: component.x - 48, y: component.y };
+                local = { x: -quantumGateDimensions(component).stubExtent, y: 0 };
             if (port === 'out')
-                return { x: component.x + 48, y: component.y };
+                local = { x: quantumGateDimensions(component).stubExtent, y: 0 };
             break;
         case 'cnot':
             if (port === 'in')
-                return left;
+                local = left;
             if (port === 'out')
-                return right;
+                local = right;
             if (port === 'control')
-                return { x: component.x, y: component.y - 16 };
+                local = { x: 0, y: -16 };
             if (port === 'target')
-                return { x: component.x, y: component.y + 16 };
+                local = { x: 0, y: 16 };
             break;
-        case 'ic': {
-            const location = icPinLocation(component, port);
-            if (location !== undefined)
-                return location.point;
+        case 'junction':
+        case 'testpoint':
+            local = { x: 0, y: 0 };
+            break;
+        case 'connector':
+            local = port === 'out' ? { x: 32, y: 0 } : { x: -32, y: 0 };
+            break;
+        case 'source':
+            if (port === 'in' || port === 'negative')
+                local = left;
+            else if (port === 'out' || port === 'positive')
+                local = right;
+            else
+                local = { x: 0, y: port === 'control-positive' ? -34 : 34 };
+            break;
+        case 'power':
+            local = { x: -32, y: 0 };
+            break;
+        case 'switch':
+            if (port === 'in' || port === 'common')
+                local = left;
+            else if (port === 'normally-open')
+                local = { x: 42, y: -12 };
+            else if (port === 'normally-closed')
+                local = { x: 42, y: 12 };
+            else if (port === 'coil1')
+                local = { x: -12, y: 34 };
+            else if (port === 'coil2')
+                local = { x: 12, y: 34 };
+            else
+                local = right;
+            break;
+        case 'amplifier':
+            if (port === 'out')
+                local = { x: 48, y: 0 };
+            else if (port === 'v+')
+                local = { x: 0, y: -36 };
+            else if (port === 'v-')
+                local = { x: 0, y: 36 };
+            else
+                local = { x: -48, y: port === 'negative' ? 13 : -13 };
+            break;
+        case 'protection':
+        case 'resonator':
+        case 'meter':
+        case 'load':
+            local = port === 'out' ? right : left;
+            break;
+        case 'buffer':
+        case 'logic':
+        case 'clock':
+        case 'flipflop':
+        case 'mux':
+        case 'encoder':
+        case 'decoder':
+        case 'register':
+        case 'counter':
+        case 'adder':
+        case 'comparator':
+        case 'bus': {
+            const output = port === 'out' || port.startsWith('out') || ['q', 'nq', 'gt', 'eq', 'lt', 'tap'].includes(port) || (component.kind === 'bus' && component.variant === 'joiner' && port === 'bus');
+            const match = port.match(/\d+$/);
+            const count = output ? component.outputs : component.inputs;
+            const index = match === null ? 0 : Number(match[0]) - 1;
+            if (port === 'clock' || port === 'enable' || port === 'select')
+                local = { x: 0, y: component.bodyHeight / 2 + 16 };
+            else if (port === 'preset' || port === 'clear')
+                local = { x: 0, y: -component.bodyHeight / 2 - 16 };
+            else
+                local = {
+                    x: (output ? 1 : -1) * (component.bodyWidth / 2 + 16),
+                    y: distributedCoordinate(index, Math.max(1, count), component.bodyHeight)
+                };
+            break;
+        }
+        case 'measure':
+            if (port === 'classical')
+                local = { x: 0, y: 34 };
+            else
+                local = port === 'out' ? { x: 40, y: 0 } : { x: -40, y: 0 };
+            break;
+        case 'prepare':
+            local = { x: 40, y: 0 };
+            break;
+        case 'control':
+            local = port === 'control' ? { x: 0, y: 0 } : port === 'out' ? right : left;
+            break;
+        case 'reset':
+        case 'classical-bit':
+        case 'classical-register':
+            local = port === 'out' ? { x: 40, y: 0 } : { x: -40, y: 0 };
+            break;
+        case 'swap':
+        case 'cz':
+        case 'cphase':
+        case 'toffoli':
+        case 'controlled':
+        case 'barrier':
+        case 'delay': {
+            const indexed = port.match(/^(?:in|out|control|target)([1-9]\d*)$/);
+            let index = indexed === null ? 0 : Number(indexed[1]) - 1;
+            if (port.startsWith('target'))
+                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)) };
+            }
+            else {
+                local = {
+                    x: port.startsWith('out') ? 42 : -42,
+                    y: distributedCoordinate(index, Math.max(1, tracks), Math.max(16, (tracks - 1) * 18))
+                };
+            }
             break;
         }
     }
+    if (local !== undefined)
+        return positionedQuarterPoint(component, local);
     throw new Error(`Validated port ${component.id}.${port} is missing.`);
 }
 export function resolvePortGeometry(component, port) {
     const point = resolvePortPoint(component, port);
     if (isClassicalGate(component)) {
-        return { point, normal: port.startsWith('out') ? { x: 1, y: 0 } : { x: -1, y: 0 } };
+        return {
+            point,
+            normal: positionedQuarterNormal(component, port.startsWith('out') ? { x: 1, y: 0 } : { x: -1, y: 0 })
+        };
     }
     if (isUmlComponent(component)) {
         if (port === 'left' || port === 'in' || port.startsWith('left')) {
@@ -226,40 +486,103 @@ export function resolvePortGeometry(component, port) {
         }
         return { point, normal: port === 'top' ? { x: 0, y: -1 } : { x: 0, y: 1 } };
     }
+    const geometry = (normal) => ({
+        point,
+        normal: positionedQuarterNormal(component, normal)
+    });
     switch (component.kind) {
         case 'resistor':
         case 'capacitor':
         case 'inductor':
-            return {
-                point,
-                normal: PASSIVE_OUTPUT_PORTS.has(port) ? { x: 1, y: 0 } : { x: -1, y: 0 }
-            };
+            return geometry(PASSIVE_OUTPUT_PORTS.has(port) ? { x: 1, y: 0 } : { x: -1, y: 0 });
         case 'diode':
-            return {
-                point,
-                normal: DIODE_CATHODE_PORTS.has(port) ? { x: 1, y: 0 } : { x: -1, y: 0 }
-            };
+            return geometry(DIODE_CATHODE_PORTS.has(port) ? { x: 1, y: 0 } : { x: -1, y: 0 });
         case 'transistor':
-            return {
-                point,
-                normal: TRANSISTOR_CONTROL_PORTS.has(port) ? { x: -1, y: 0 } : { x: 1, y: 0 }
-            };
+            return geometry(TRANSISTOR_CONTROL_PORTS.has(port) ? { x: -1, y: 0 } : { x: 1, y: 0 });
         case 'port':
         case 'hadamard':
         case 'qgate':
-            return { point, normal: port === 'out' ? { x: 1, y: 0 } : { x: -1, y: 0 } };
+        case 'xgate':
+        case 'ygate':
+        case 'zgate':
+        case 'sgate':
+        case 'sdg':
+        case 'tgate':
+        case 'tdg':
+        case 'sx':
+        case 'phase':
+        case 'rx':
+        case 'ry':
+        case 'rz':
+        case 'ugate':
+        case 'connector':
+        case 'protection':
+        case 'resonator':
+        case 'meter':
+        case 'load':
+        case 'reset':
+        case 'prepare':
+        case 'classical-bit':
+        case 'classical-register':
+            return geometry(port === 'out' ? { x: 1, y: 0 } : { x: -1, y: 0 });
         case 'ground':
-            return { point, normal: { x: 0, y: -1 } };
+            return geometry({ x: 0, y: -1 });
         case 'cnot':
             if (port === 'control')
-                return { point, normal: { x: 0, y: -1 } };
+                return geometry({ x: 0, y: -1 });
             if (port === 'target')
-                return { point, normal: { x: 0, y: 1 } };
-            return { point, normal: port === 'out' ? { x: 1, y: 0 } : { x: -1, y: 0 } };
+                return geometry({ x: 0, y: 1 });
+            return geometry(port === 'out' ? { x: 1, y: 0 } : { x: -1, y: 0 });
         case 'ic': {
             const location = icPinLocation(component, port);
-            return { point, normal: sideNormal(location.side) };
+            return geometry(sideNormal(location.side));
         }
+        case 'junction':
+        case 'testpoint':
+            return geometry(port === 'out' ? { x: 1, y: 0 } : { x: -1, y: 0 });
+        case 'source':
+            if (port.startsWith('control-'))
+                return geometry({ x: 0, y: port.endsWith('positive') ? -1 : 1 });
+            return geometry(port === 'out' || port === 'positive' ? { x: 1, y: 0 } : { x: -1, y: 0 });
+        case 'power':
+            return geometry({ x: -1, y: 0 });
+        case 'switch':
+            if (port.startsWith('coil'))
+                return geometry({ x: 0, y: 1 });
+            return geometry(port === 'in' || port === 'common' ? { x: -1, y: 0 } : { x: 1, y: 0 });
+        case 'amplifier':
+            if (port === 'v+' || port === 'v-')
+                return geometry({ x: 0, y: port === 'v+' ? -1 : 1 });
+            return geometry(port === 'out' ? { x: 1, y: 0 } : { x: -1, y: 0 });
+        case 'buffer':
+        case 'logic':
+        case 'clock':
+        case 'flipflop':
+        case 'mux':
+        case 'encoder':
+        case 'decoder':
+        case 'register':
+        case 'counter':
+        case 'adder':
+        case 'comparator':
+        case 'bus':
+            if (['clock', 'enable', 'select'].includes(port))
+                return geometry({ x: 0, y: 1 });
+            if (['preset', 'clear'].includes(port))
+                return geometry({ x: 0, y: -1 });
+            return geometry(port === 'out' || port.startsWith('out') || ['q', 'nq', 'gt', 'eq', 'lt', 'tap'].includes(port) || (component.kind === 'bus' && component.variant === 'joiner' && port === 'bus') ? { x: 1, y: 0 } : { x: -1, y: 0 });
+        case 'measure':
+            return geometry(port === 'classical' ? { x: 0, y: 1 } : port === 'out' ? { x: 1, y: 0 } : { x: -1, y: 0 });
+        case 'control':
+            return geometry(port === 'control' ? { x: 0, y: -1 } : port === 'out' ? { x: 1, y: 0 } : { x: -1, y: 0 });
+        case 'swap':
+        case 'cz':
+        case 'cphase':
+        case 'toffoli':
+        case 'controlled':
+        case 'barrier':
+        case 'delay':
+            return geometry(port.startsWith('out') ? { x: 1, y: 0 } : port.startsWith('in') ? { x: -1, y: 0 } : { x: 0, y: -1 });
     }
     throw new Error(`Validated port ${port} is missing.`);
 }
@@ -273,6 +596,50 @@ export function enumerateComponentPorts(component) {
             ...Array.from({ length: component.outputs }, (_, index) => namedPort(component, `out${index + 1}`))
         ];
     }
+    if (isDigitalComponent(component)) {
+        let ports = [
+            ...Array.from({ length: component.inputs }, (_, index) => `in${index + 1}`),
+            ...Array.from({ length: component.outputs }, (_, index) => `out${index + 1}`)
+        ];
+        if (component.kind === 'logic' || component.kind === 'clock')
+            ports = ['out'];
+        else if (component.kind === 'flipflop') {
+            const inputs = component.variant === 'jk' ? ['j', 'k', 'clock'] : component.variant === 't' ? ['t', 'clock', 'clear'] : component.variant === 'sr-latch' ? ['s', 'r', 'enable'] : ['d', 'clock', 'clear'];
+            ports = [...inputs, 'q', 'nq', 'preset'];
+        }
+        else if (component.kind === 'register')
+            ports = ['in', 'out', 'clock', 'enable', 'clear'];
+        else if (component.kind === 'counter')
+            ports.push('clock', 'enable', 'clear');
+        else if (component.kind === 'mux')
+            ports.push('select', 'enable');
+        else if (component.kind === 'comparator')
+            ports = ['in1', 'in2', 'gt', 'eq', 'lt'];
+        else if (component.kind === 'bus') {
+            ports = component.variant === 'tap' ? ['bus', 'tap'] : component.variant === 'joiner' ? [...Array.from({ length: component.inputs }, (_, index) => `in${index + 1}`), 'bus'] : ['bus', ...Array.from({ length: component.outputs }, (_, index) => `out${index + 1}`)];
+        }
+        else if (component.kind === 'buffer' && component.variant?.startsWith('tristate') === true)
+            ports.push('enable');
+        return ports.map((port) => namedPort(component, port));
+    }
+    if (isQuantumSpecial(component)) {
+        if (component.kind === 'prepare')
+            return [namedPort(component, 'out')];
+        if (component.kind === 'measure')
+            return ['in', 'out', 'classical'].map((port) => namedPort(component, port));
+        if (component.kind === 'control')
+            return ['in', 'out', 'control'].map((port) => namedPort(component, port));
+        if (component.kind === 'reset' || component.kind === 'classical-bit' || component.kind === 'classical-register') {
+            return ['in', 'out'].map((port) => namedPort(component, port));
+        }
+        const tracks = Math.max(component.wires, component.controls + component.targets);
+        return [
+            ...Array.from({ length: tracks }, (_, index) => namedPort(component, `in${index + 1}`)),
+            ...Array.from({ length: tracks }, (_, index) => namedPort(component, `out${index + 1}`)),
+            ...Array.from({ length: component.controls }, (_, index) => namedPort(component, `control${index + 1}`)),
+            ...Array.from({ length: component.targets }, (_, index) => namedPort(component, `target${index + 1}`))
+        ];
+    }
     if (isUmlComponent(component)) {
         return ['left', 'right', 'top', 'bottom'].map((port) => namedPort(component, port));
     }
@@ -283,6 +650,24 @@ export function enumerateComponentPorts(component) {
         case 'port':
         case 'hadamard':
         case 'qgate':
+        case 'xgate':
+        case 'ygate':
+        case 'zgate':
+        case 'sgate':
+        case 'sdg':
+        case 'tgate':
+        case 'tdg':
+        case 'sx':
+        case 'phase':
+        case 'rx':
+        case 'ry':
+        case 'rz':
+        case 'ugate':
+        case 'connector':
+        case 'protection':
+        case 'resonator':
+        case 'meter':
+        case 'load':
             return [namedPort(component, 'in'), namedPort(component, 'out')];
         case 'diode':
             return [namedPort(component, 'anode'), namedPort(component, 'cathode')];
@@ -309,12 +694,34 @@ export function enumerateComponentPorts(component) {
                 namedPort(component, 'control'),
                 namedPort(component, 'target')
             ];
+        case 'junction':
+        case 'testpoint':
+            return [namedPort(component, 'node')];
+        case 'source': {
+            const ports = ['negative', 'positive'];
+            if (component.variant !== undefined && ['vcvs', 'vccs', 'ccvs', 'cccs'].includes(component.variant)) {
+                ports.push('control-positive', 'control-negative');
+            }
+            return ports.map((port) => namedPort(component, port));
+        }
+        case 'power':
+            return [namedPort(component, 'in')];
+        case 'switch': {
+            const ports = component.variant === 'spdt'
+                ? ['common', 'normally-open', 'normally-closed']
+                : component.variant === 'relay'
+                    ? ['in', 'out', 'coil1', 'coil2']
+                    : ['in', 'out'];
+            return ports.map((port) => namedPort(component, port));
+        }
+        case 'amplifier':
+            return ['positive', 'negative', 'out', 'v+', 'v-'].map((port) => namedPort(component, port));
         case 'ic': {
             const sides = ['left', 'right', 'top', 'bottom'];
             return sides.flatMap((side) => component.pins[side].map((id, index) => ({
                 id,
                 point: positionIcPin(component, side, index),
-                normal: sideNormal(side)
+                normal: positionedQuarterNormal(component, sideNormal(side))
             })));
         }
     }
@@ -609,6 +1016,19 @@ function routeBetweenEscapes(start, end, obstacles, bounds, line) {
     }
     return best ?? searchOrthogonalRoute(start, end, obstacles, bounds, line);
 }
+function endpointsFaceEachOther(from, to) {
+    const dx = to.point.x - from.point.x;
+    const dy = to.point.y - from.point.y;
+    if (dy === 0 && dx !== 0) {
+        const direction = Math.sign(dx);
+        return from.normal.x === direction && to.normal.x === -direction;
+    }
+    if (dx === 0 && dy !== 0) {
+        const direction = Math.sign(dy);
+        return from.normal.y === direction && to.normal.y === -direction;
+    }
+    return false;
+}
 function routeConnectionInternal(connection, components, bounds, cachedObstacles) {
     const from = endpointGeometry(connection.from, components);
     const to = endpointGeometry(connection.to, components);
@@ -635,6 +1055,13 @@ function routeConnectionInternal(connection, components, bounds, cachedObstacles
                 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] };
+        }
         const fromObstacle = componentObstacleRectangle(from.component);
         const toObstacle = componentObstacleRectangle(to.component);
         const escape = (geometry, obstacle) => ({
@@ -651,13 +1078,8 @@ function routeConnectionInternal(connection, components, bounds, cachedObstacles
         });
         const startEscape = escape(from, fromObstacle);
         const endEscape = escape(to, toObstacle);
-        const obstacleEntries = obstacleCache.map((entry) => ({
-            id: entry.id,
-            rectangle: entry.id === from.component.id || entry.id === to.component.id
-                ? entry.body
-                : entry.expanded
-        }));
-        const obstacleRectangles = obstacleEntries.map((entry) => entry.rectangle);
+        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);
         if (middle === undefined) {
             throw new SchematicSyntaxError('No collision-free orthogonal route exists.', connection.line);
@@ -666,10 +1088,10 @@ 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 obstacleEntries) {
+            for (const obstacle of obstacleCache) {
                 if (!(allowFrom && obstacle.id === from.component.id) &&
                     !(allowTo && obstacle.id === to.component.id) &&
-                    segmentIntersectsRectangle(points[index - 1], points[index], obstacle.rectangle)) {
+                    segmentIntersectsRectangle(points[index - 1], points[index], obstacleRectangle(obstacle))) {
                     throw new SchematicSyntaxError(`Orthogonal route intersects ${obstacle.id} after routing.`, connection.line);
                 }
             }
@@ -743,6 +1165,8 @@ 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;
                 const before = crossing.x - direction * radius;
                 const after = crossing.x + direction * radius;
                 if (before !== cursorX)
@@ -758,6 +1182,8 @@ 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;
                 const before = crossing.y - direction * radius;
                 const after = crossing.y + direction * radius;
                 if (before !== cursorY)
@@ -851,6 +1277,17 @@ function componentHalfExtents(component) {
     else if (isUmlComponent(component)) {
         return umlHalfExtents(component);
     }
+    else if (isDigitalComponent(component)) {
+        halfWidth = component.bodyWidth / 2 + 16;
+        halfHeight = component.bodyHeight / 2 + 16;
+    }
+    else if (isQuantumSpecial(component)) {
+        const tracks = Math.max(component.wires, component.controls + component.targets);
+        halfWidth = 42;
+        halfHeight = Math.max(24, (tracks - 1) * 9 + 14);
+        if (component.kind === 'measure')
+            halfHeight = 34;
+    }
     else {
         switch (component.kind) {
             case 'resistor':
@@ -861,7 +1298,7 @@ function componentHalfExtents(component) {
                 break;
             case 'diode':
                 halfWidth = 42;
-                halfHeight = component.diodeType === 'led' ? 30 : 20;
+                halfHeight = component.diodeType === 'led' || component.diodeType === 'photodiode' ? 30 : 20;
                 break;
             case 'transistor':
                 halfWidth = 42;
@@ -877,9 +1314,24 @@ function componentHalfExtents(component) {
                 break;
             case 'hadamard':
             case 'qgate':
-                halfWidth = 48;
-                halfHeight = 30;
+            case 'xgate':
+            case 'ygate':
+            case 'zgate':
+            case 'sgate':
+            case 'sdg':
+            case 'tgate':
+            case 'tdg':
+            case 'sx':
+            case 'phase':
+            case 'rx':
+            case 'ry':
+            case 'rz':
+            case 'ugate': {
+                const dimensions = quantumGateDimensions(component);
+                halfWidth = dimensions.stubExtent;
+                halfHeight = dimensions.bodyHeight / 2;
                 break;
+            }
             case 'cnot':
                 halfWidth = 42;
                 halfHeight = 26;
@@ -888,9 +1340,39 @@ function componentHalfExtents(component) {
                 halfWidth = component.bodyWidth / 2 + 16;
                 halfHeight = component.bodyHeight / 2 + 16;
                 break;
+            case 'source':
+                halfWidth = 42;
+                halfHeight = 34;
+                break;
+            case 'junction':
+                halfWidth = halfHeight = 5;
+                break;
+            case 'testpoint':
+                halfWidth = halfHeight = 12;
+                break;
+            case 'connector':
+            case 'power':
+                halfWidth = 32;
+                halfHeight = 18;
+                break;
+            case 'switch':
+                halfWidth = 42;
+                halfHeight = component.variant === 'relay' ? 34 : 20;
+                break;
+            case 'amplifier':
+                halfWidth = 48;
+                halfHeight = 36;
+                break;
+            case 'protection':
+            case 'resonator':
+            case 'meter':
+            case 'load':
+                halfWidth = 42;
+                halfHeight = 24;
+                break;
         }
     }
-    return { halfWidth, halfHeight };
+    return rotateQuarterExtents({ halfWidth, halfHeight }, componentTurn(component));
 }
 export function componentTextAnchors(component) {
     const { halfHeight } = componentHalfExtents(component);
@@ -961,4 +1443,5 @@ export function validateDocumentGeometry(document, fence, routedConnections) {
             throw new SchematicSyntaxError('Connection trace exceeds the declared schematic bounds.', connection.line);
         }
     }
+    return routes;
 }