altium-toolkit 1.1.38 → 1.1.40

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "altium-toolkit",
-    "version": "1.1.38",
+    "version": "1.1.40",
     "description": "Altium document parsing and non-interactive rendering utilities",
     "keywords": [
         "altium",

package/src/core/altium/SchematicDirectiveParser.mjs

@@ -12,7 +12,7 @@ export class SchematicDirectiveParser {
     /**
      * Normalizes schematic directive records into drawable directive metadata.
      * @param {{ fields: Record<string, string | string[]> }[]} records
-     * @returns {{ x: number, y: number, color: string, name: string, orientation: number }[]}
+     * @returns {{ x: number, y: number, color: string, name: string, orientation: number, style?: number }[]}
      */
     static parseSchematicDirectives(records) {
         return records
@@ -31,7 +31,11 @@ export class SchematicDirectiveParser {
                     return null
                 }
 
-                return {
+                const style = ParserUtils.parseNumericField(
+                    record.fields,
+                    'Style'
+                )
+                const directive = {
                     x,
                     y,
                     color: ParserUtils.toColor(record.fields.Color, '#ff0000'),
@@ -42,6 +46,12 @@ export class SchematicDirectiveParser {
                             'Orientation'
                         ) || 0
                 }
+
+                if (style !== null) {
+                    directive.style = style
+                }
+
+                return directive
             })
             .filter(Boolean)
     }
@@ -210,6 +220,8 @@ export class SchematicDirectiveParser {
             orientation:
                 ParserUtils.parseNumericField(record.fields, 'Orientation') ||
                 0,
+            style:
+                ParserUtils.parseNumericField(record.fields, 'Style') ?? null,
             parameters,
             parameterMap,
             isDifferentialPair,

package/src/core/altium/SchematicPinParser.mjs

@@ -873,11 +873,18 @@ export class SchematicPinParser {
             ownerDrawnInternalPinOwners.has(ownerIndex) &&
             SchematicPinParser.#isCompactNumberedFetTerminalGroup(
                 normalizedPins,
-                semanticNames,
                 orientationCount
             )
         ) {
             labelMode = 'number-only'
+        } else if (
+            ownerDrawnInternalPinOwners.has(ownerIndex) &&
+            SchematicPinParser.#isOwnerDrawnAmplifierTerminalGroup(
+                normalizedPins,
+                semanticNames
+            )
+        ) {
+            labelMode = 'number-only'
         } else if (
             SchematicPinParser.#isOwnerDrawnTerminalGlyphGroup(
                 normalizedPins,
@@ -904,6 +911,15 @@ export class SchematicPinParser {
             )
         ) {
             labelMode = 'number-only'
+        } else if (
+            ownerDrawnInternalPinOwners.has(ownerIndex) &&
+            SchematicPinParser.#isCompactCommonTerminalDiodeGroup(
+                normalizedPins,
+                names,
+                orientationCount
+            )
+        ) {
+            labelMode = 'number-only'
         } else if (!semanticNames.length && orientationCount <= 2) {
             labelMode = 'number-only'
         } else if (
@@ -948,32 +964,94 @@ export class SchematicPinParser {
     }
 
     /**
-     * Returns true when a compact owner-drawn FET body uses semantic terminal
-     * names internally but still exposes external numeric contact labels.
+     * Returns true when a compact owner-drawn FET body or pin array uses
+     * semantic terminal names internally but still exposes external numeric
+     * contact labels.
      * @param {{ designator: string, name: string, orientation: 'left' | 'right' | 'top' | 'bottom' }[]} pins
-     * @param {string[]} semanticNames
      * @param {number} orientationCount
      * @returns {boolean}
      */
-    static #isCompactNumberedFetTerminalGroup(
-        pins,
-        semanticNames,
-        orientationCount
-    ) {
+    static #isCompactNumberedFetTerminalGroup(pins, orientationCount) {
         if (
-            pins.length !== 4 ||
-            orientationCount < 3 ||
+            pins.length < 4 ||
+            pins.length > 12 ||
+            orientationCount < 2 ||
+            !pins.every((pin) => /^\d+$/.test(String(pin.designator || '')))
+        ) {
+            return false
+        }
+
+        const normalizedNames = pins.map((pin) =>
+            String(pin.name || '')
+                .trim()
+                .toUpperCase()
+        )
+
+        return (
+            new Set(normalizedNames).size >= 2 &&
+            normalizedNames.every((name) =>
+                SchematicPinParser.#isFetTerminalName(name)
+            )
+        )
+    }
+
+    /**
+     * Returns true when an owner-drawn amplifier body already represents its
+     * input, output, and supply terminal names in the drawn symbol artwork.
+     * @param {{ designator: string, name: string }[]} pins
+     * @param {string[]} semanticNames
+     * @returns {boolean}
+     */
+    static #isOwnerDrawnAmplifierTerminalGroup(pins, semanticNames) {
+        if (
+            pins.length < 3 ||
+            pins.length > 8 ||
             semanticNames.length !== pins.length ||
             !pins.every((pin) => /^\d+$/.test(String(pin.designator || '')))
         ) {
             return false
         }
 
-        return semanticNames.every((name) =>
-            SchematicPinParser.#isFetTerminalName(name)
+        const normalizedNames = semanticNames.map((name) =>
+            SchematicPinParser.#normalizeAmplifierTerminalName(name)
+        )
+
+        return (
+            normalizedNames.every(Boolean) &&
+            normalizedNames.some((name) => name === 'IN+' || name === 'IN-') &&
+            normalizedNames.includes('OUT')
         )
     }
 
+    /**
+     * Normalizes amplifier terminal names that are normally drawn inside the
+     * owner-authored symbol body.
+     * @param {string} name Raw pin name.
+     * @returns {string}
+     */
+    static #normalizeAmplifierTerminalName(name) {
+        const normalized = String(name || '')
+            .trim()
+            .toUpperCase()
+
+        switch (normalized) {
+            case 'IN+':
+            case '+IN':
+            case '+':
+                return 'IN+'
+            case 'IN-':
+            case '-IN':
+            case '-':
+                return 'IN-'
+            case 'OUT':
+            case 'V+':
+            case 'V-':
+                return normalized
+            default:
+                return ''
+        }
+    }
+
     /**
      * Returns true when a compact multi-side owner has transistor-like terminal
      * letters that are part of the drawn symbol body, not external pin labels.
@@ -1059,6 +1137,48 @@ export class SchematicPinParser {
         )
     }
 
+    /**
+     * Returns true when a compact owner-drawn diode-like section exposes one
+     * ordinary anode/cathode terminal and one common terminal name internally.
+     * @param {{ designator: string, name: string, length: number, electrical?: number, orientation: 'left' | 'right' | 'top' | 'bottom' }[]} pins
+     * @param {string[]} names
+     * @param {number} orientationCount
+     * @returns {boolean}
+     */
+    static #isCompactCommonTerminalDiodeGroup(pins, names, orientationCount) {
+        if (
+            pins.length !== 2 ||
+            orientationCount !== 2 ||
+            names.length !== pins.length ||
+            !SchematicPinParser.#hasOptionalNumericPinDesignators(pins)
+        ) {
+            return false
+        }
+
+        if (
+            pins.some((pin) => {
+                const length = Math.abs(Number(pin.length || 0))
+                const electrical = Number(pin.electrical)
+                return (
+                    length <= 0 ||
+                    length > 15 ||
+                    (Number.isFinite(electrical) && electrical !== 4)
+                )
+            })
+        ) {
+            return false
+        }
+
+        const hasDiodeTerminal = names.some((name) =>
+            SchematicPinParser.#isDiodeTerminalName(name)
+        )
+        const hasCommonTerminal = names.some((name) =>
+            SchematicPinParser.#isCommonDiodeTerminalName(name)
+        )
+
+        return hasDiodeTerminal && hasCommonTerminal
+    }
+
     /**
      * Returns true when compact owner-drawn terminal glyph pins have either no
      * external designators or ordinary numeric pin numbers.
@@ -1104,6 +1224,24 @@ export class SchematicPinParser {
         )
     }
 
+    /**
+     * Returns true for one-letter terminals used inside diode-style symbols.
+     * @param {string} name
+     * @returns {boolean}
+     */
+    static #isDiodeTerminalName(name) {
+        return /^[AKC]$/i.test(String(name || '').trim())
+    }
+
+    /**
+     * Returns true for common-terminal names used by multipart diode symbols.
+     * @param {string} name
+     * @returns {boolean}
+     */
+    static #isCommonDiodeTerminalName(name) {
+        return /^COM[AC]$/i.test(String(name || '').trim())
+    }
+
     /**
      * Returns true when one passive two-pin symbol uses the ordinary 1/2 pin
      * numbering that should stay hidden for simple resistor-like parts.

package/src/core/altium/SchematicTextOrientationResolver.mjs

@@ -29,12 +29,19 @@ export class SchematicTextOrientationResolver {
     }
 
     /**
-     * Resolves component text orientation bit 1 to top source anchoring.
+     * Resolves text vertical anchoring from Altium's justification grid and
+     * component text orientation bits.
      * @param {Record<string, string | string[]>} fields Text record fields.
      * @param {string} recordType Native text record type.
-     * @returns {'top' | null}
+     * @returns {'middle' | 'top' | null}
      */
     static resolveVerticalAnchor(fields, recordType) {
+        const justificationAnchor =
+            SchematicTextOrientationResolver.#resolveJustificationVerticalAnchor(
+                fields
+            )
+        if (justificationAnchor) return justificationAnchor
+
         return SchematicTextOrientationResolver.resolveHorizontalAnchor(
             fields,
             recordType
@@ -65,6 +72,28 @@ export class SchematicTextOrientationResolver {
         return orientation === 1
     }
 
+    /**
+     * Resolves the vertical row from Altium's 3x3 justification grid.
+     * @param {Record<string, string | string[]>} fields Text record fields.
+     * @returns {'middle' | 'top' | null}
+     */
+    static #resolveJustificationVerticalAnchor(fields) {
+        const justification =
+            ParserUtils.parseNumericField(fields, 'Justification') ??
+            ParserUtils.parseNumericField(fields, 'Alignment')
+
+        if (!Number.isInteger(justification)) {
+            return null
+        }
+
+        const normalizedJustification = ((justification % 9) + 9) % 9
+        const verticalRow = Math.floor(normalizedJustification / 3)
+
+        if (verticalRow === 1) return 'middle'
+        if (verticalRow === 2) return 'top'
+        return null
+    }
+
     /**
      * Returns true for component designator and parameter text records.
      * @param {string} recordType Native text record type.

package/src/core/altium/SchematicTextParser.mjs

@@ -137,7 +137,7 @@ export class SchematicTextParser {
      * @param {{ width: number, marginWidth: number, titleBlockOn?: boolean }} sheet
      * @param {Record<string, { size: number, family: string, bold: boolean, italic?: boolean, rotation: number }>} fonts
      * @param {Map<string, Record<string, string>>} [ownerMetadata]
-     * @returns {{ x: number, y: number, text: string, color: string, hidden: boolean, name: string, ownerIndex?: string, recordType: string, style: number, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string, rotation: number, sourceOrientation?: number, isMirrored?: boolean, anchor: 'start' | 'middle' | 'end', verticalAnchor?: 'top', powerPortDirection?: 'up' | 'down' | 'left' | 'right', cornerX?: number, cornerY?: number, fill?: string, borderColor?: string, isSolid?: boolean, showBorder?: boolean, textMargin?: number, noteLines?: string[] } | null}
+     * @returns {{ x: number, y: number, text: string, color: string, hidden: boolean, name: string, ownerIndex?: string, recordType: string, style: number, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string, rotation: number, sourceOrientation?: number, isMirrored?: boolean, anchor: 'start' | 'middle' | 'end', verticalAnchor?: 'middle' | 'top', powerPortDirection?: 'up' | 'down' | 'left' | 'right', cornerX?: number, cornerY?: number, fill?: string, borderColor?: string, isSolid?: boolean, showBorder?: boolean, textMargin?: number, noteLines?: string[] } | null}
      */
     static normalizeSchematicTextRecord(
         fields,

package/src/ui/SchematicColorResolver.mjs

@@ -49,6 +49,12 @@ export class SchematicColorResolver {
             return normalized
         }
 
+        if (SchematicColorResolver.#isDefaultInkSourceColor(normalized)) {
+            return SchematicColorResolver.#toVariable(
+                '--schematic-default-ink-color'
+            )
+        }
+
         const token = COLOR_TOKEN_BY_VALUE.get(normalized)
 
         if (token) {
@@ -316,6 +322,30 @@ export class SchematicColorResolver {
         return Math.max(rgb.r, rgb.g, rgb.b) <= 32
     }
 
+    /**
+     * Returns true for dark saturated blue source colors that represent
+     * Altium's default schematic ink family rather than custom artwork color.
+     * @param {string} color Normalized color.
+     * @returns {boolean}
+     */
+    static #isDefaultInkSourceColor(color) {
+        const rgb = SchematicColorResolver.#parseHexColor(color)
+        if (!rgb) {
+            return false
+        }
+
+        const hsl = SchematicColorResolver.#rgbToHsl(rgb)
+        const hueDegrees = hsl.h * 360
+
+        return (
+            hueDegrees >= 220 &&
+            hueDegrees <= 270 &&
+            hsl.s >= 45 &&
+            hsl.l >= 12 &&
+            hsl.l <= 38
+        )
+    }
+
     /**
      * Converts RGB channels to HSL.
      * @param {{ r: number, g: number, b: number }} color

package/src/ui/SchematicDirectiveRenderer.mjs

@@ -15,7 +15,7 @@ const { createSvgText, escapeHtml, formatNumber, projectSchematicY } =
 export class SchematicDirectiveRenderer {
     /**
      * Builds directive markup for supported schematic directive primitives.
-     * @param {{ x: number, y: number, color: string, name: string, orientation?: number }[]} directives
+     * @param {{ x: number, y: number, color: string, name: string, orientation?: number, style?: number }[]} directives
      * @param {number} sheetHeight
      * @param {{ fonts?: Record<string, { size: number, family: string, bold: boolean }> }} sheet
      * @returns {string}
@@ -34,7 +34,7 @@ export class SchematicDirectiveRenderer {
 
     /**
      * Builds one supported directive glyph.
-     * @param {{ x: number, y: number, color: string, name: string, orientation?: number }} directive
+     * @param {{ x: number, y: number, color: string, name: string, orientation?: number, style?: number }} directive
      * @param {number} sheetHeight
      * @param {{ fonts?: Record<string, { size: number, family: string, bold: boolean }> }} sheet
      * @returns {string}
@@ -67,13 +67,24 @@ export class SchematicDirectiveRenderer {
 
     /**
      * Builds the labeled info-callout marker for one parameter-set directive.
-     * @param {{ x: number, y: number, color: string, name: string, orientation?: number }} directive
+     * @param {{ x: number, y: number, color: string, name: string, orientation?: number, style?: number }} directive
      * @param {number} sheetHeight
      * @param {{ fonts?: Record<string, { size: number, family: string, bold: boolean }> }} sheet
      * @param {string} classModifier
      * @returns {string}
      */
     static #buildRouteMarkup(directive, sheetHeight, sheet, classModifier) {
+        if (
+            classModifier === 'parameter-set' &&
+            Number(directive?.style) === 1
+        ) {
+            return SchematicDirectiveRenderer.#buildCompactParameterSetMarkup(
+                directive,
+                sheetHeight,
+                classModifier
+            )
+        }
+
         const color = SchematicColorResolver.resolveColor(
             directive.color,
             '--schematic-alert-color'
@@ -154,6 +165,61 @@ export class SchematicDirectiveRenderer {
         )
     }
 
+    /**
+     * Builds the compact style-1 parameter-set marker used for connection
+     * adornments whose class name is carried as metadata rather than text.
+     * @param {{ x: number, y: number, color: string, orientation?: number }} directive
+     * @param {number} sheetHeight
+     * @param {string} classModifier
+     * @returns {string}
+     */
+    static #buildCompactParameterSetMarkup(
+        directive,
+        sheetHeight,
+        classModifier
+    ) {
+        const color = SchematicColorResolver.resolveColor(
+            directive.color,
+            '--schematic-alert-color'
+        )
+        const projectedY = projectSchematicY(sheetHeight, directive.y)
+        const direction = SchematicDirectiveRenderer.#resolveCalloutDirection(
+            directive.orientation
+        )
+        const circleRadius = 3
+        const circleCenterX = directive.x + direction.x * 6
+        const circleCenterY = projectedY + direction.y * 6
+        const leaderEndX = circleCenterX - direction.x * circleRadius
+        const leaderEndY = circleCenterY - direction.y * circleRadius
+
+        return (
+            '<g class="schematic-directive schematic-directive--' +
+            escapeHtml(classModifier) +
+            '">' +
+            '<line x1="' +
+            formatNumber(directive.x) +
+            '" y1="' +
+            formatNumber(projectedY) +
+            '" x2="' +
+            formatNumber(leaderEndX) +
+            '" y2="' +
+            formatNumber(leaderEndY) +
+            '" stroke="' +
+            escapeHtml(color) +
+            '" stroke-width="1" />' +
+            '<circle cx="' +
+            formatNumber(circleCenterX) +
+            '" cy="' +
+            formatNumber(circleCenterY) +
+            '" r="' +
+            formatNumber(circleRadius) +
+            '" fill="none" stroke="' +
+            escapeHtml(color) +
+            '" stroke-width="1" />' +
+            '</g>'
+        )
+    }
+
     /**
      * Resolves Altium's four-way callout orientation into an outward vector.
      * @param {number | undefined} orientation

package/src/ui/SchematicLineColorResolver.mjs

@@ -17,7 +17,8 @@ export class SchematicLineColorResolver {
         if (SchematicLineColorResolver.isElectricalLine(line)) {
             return SchematicColorResolver.resolveNonTextColor(
                 line?.color,
-                '--schematic-default-ink-color'
+                '--schematic-default-ink-color',
+                true
             )
         }
 
@@ -37,7 +38,8 @@ export class SchematicLineColorResolver {
 
         return SchematicColorResolver.resolveNonTextColor(
             line?.color,
-            '--schematic-default-ink-color'
+            '--schematic-default-ink-color',
+            true
         )
     }
 

package/src/ui/SchematicOwnerPinLabelLayout.mjs

@@ -143,6 +143,56 @@ export class SchematicOwnerPinLabelLayout {
         return offsets
     }
 
+    /**
+     * Collects pins whose owner already draws a visible text label for the pin
+     * designator, avoiding a second synthetic pin-number label at the contact.
+     * @param {{ ownerIndex?: string, text?: string, x?: number, y?: number, recordType?: string, hidden?: boolean }[]} texts
+     * @param {{ ownerIndex?: string, designator?: string, x: number, y: number, length?: number, orientation: 'left' | 'right' | 'top' | 'bottom', labelMode?: 'hidden' | 'number-only' | 'name-only' | 'name-and-number' }[]} pins
+     * @returns {Set<string>}
+     */
+    static collectExplicitOwnerPinNumberLabelKeys(texts, pins) {
+        const ownerTexts = SchematicOwnerPinLabelLayout.#groupByOwnerIndex(
+            (texts || []).filter(
+                (text) => text.recordType === '4' && !text.hidden
+            )
+        )
+        const keys = new Set()
+
+        for (const pin of pins || []) {
+            const ownerIndex = String(pin.ownerIndex || '').trim()
+            const designator = String(pin.designator || '').trim()
+
+            if (
+                !ownerIndex ||
+                !designator ||
+                (pin.labelMode || 'name-and-number') === 'hidden' ||
+                (pin.labelMode || 'name-and-number') === 'name-only'
+            ) {
+                continue
+            }
+
+            const nativeNumberLabels = ownerTexts.get(ownerIndex) || []
+            const hasNativeNumberLabel = nativeNumberLabels.some((text) =>
+                SchematicOwnerPinLabelLayout.#isExplicitOwnerPinNumberLabel(
+                    text,
+                    pin,
+                    designator
+                )
+            )
+
+            if (hasNativeNumberLabel) {
+                keys.add(
+                    SchematicOwnerPinLabelLayout.buildOwnerPinLabelKey(
+                        ownerIndex,
+                        designator
+                    )
+                )
+            }
+        }
+
+        return keys
+    }
+
     /**
      * Collects compact FET-like owner groups whose numeric contact labels need
      * to stay outside the owner-drawn device body.
@@ -481,6 +531,53 @@ export class SchematicOwnerPinLabelLayout {
         )
     }
 
+    /**
+     * Returns true when an owner text is a native pin-number label for a pin.
+     * @param {{ text?: string, x?: number, y?: number }} text
+     * @param {{ x: number, y: number, length?: number, orientation: 'left' | 'right' | 'top' | 'bottom' }} pin
+     * @param {string} designator
+     * @returns {boolean}
+     */
+    static #isExplicitOwnerPinNumberLabel(text, pin, designator) {
+        if (String(text?.text || '').trim() !== designator) {
+            return false
+        }
+
+        const textX = Number(text?.x)
+        const textY = Number(text?.y)
+        const pinX = Number(pin?.x)
+        const pinY = Number(pin?.y)
+
+        if (
+            !Number.isFinite(textX) ||
+            !Number.isFinite(textY) ||
+            !Number.isFinite(pinX) ||
+            !Number.isFinite(pinY)
+        ) {
+            return false
+        }
+
+        const laneTolerance = 6
+        const axisTolerance =
+            Math.max(Math.abs(Number(pin.length || 0)), 10) + 6
+
+        if (pin.orientation === 'left' || pin.orientation === 'right') {
+            return (
+                Math.abs(textY - pinY) <= laneTolerance &&
+                Math.abs(textX - pinX) <= axisTolerance
+            )
+        }
+
+        if (pin.orientation === 'top' || pin.orientation === 'bottom') {
+            return (
+                Math.abs(textX - pinX) <= laneTolerance &&
+                Math.abs(textY - pinY) <= axisTolerance
+            )
+        }
+
+        return false
+    }
+
     /**
      * Groups schematic owner-local primitives by owner index.
      * @template T

package/src/ui/SchematicPinSvgRenderer.mjs

@@ -24,6 +24,7 @@ export class SchematicPinSvgRenderer {
      * @param {Map<string, number>} explicitOwnerPinLabelOffsets
      * @param {Map<string, 'left' | 'right'>} compactExternalNumberLabelSides
      * @param {Map<string, { left: number, right: number }>} internalNumberLabelBoxes
+     * @param {Set<string>} explicitOwnerPinNumberLabelKeys
      * @param {Set<string>} overlappingExternalNumberLabelKeys
      * @returns {string}
      */
@@ -36,6 +37,7 @@ export class SchematicPinSvgRenderer {
         explicitOwnerPinLabelOffsets,
         compactExternalNumberLabelSides = new Map(),
         internalNumberLabelBoxes = new Map(),
+        explicitOwnerPinNumberLabelKeys = new Set(),
         overlappingExternalNumberLabelKeys = new Set()
     ) {
         const geometry =
@@ -76,13 +78,14 @@ export class SchematicPinSvgRenderer {
             null
         const internalNumberLabelBox =
             internalNumberLabelBoxes.get(String(pin.ownerIndex || '')) || null
-        const shouldRenderExternalNumber =
-            !overlappingExternalNumberLabelKeys.has(
-                SchematicOwnerPinLabelLayout.buildOwnerPinLabelKey(
-                    pin.ownerIndex,
-                    pin.designator
-                )
+        const ownerPinNumberLabelKey =
+            SchematicOwnerPinLabelLayout.buildOwnerPinLabelKey(
+                pin.ownerIndex,
+                pin.designator
             )
+        const shouldRenderExternalNumber =
+            !explicitOwnerPinNumberLabelKeys.has(ownerPinNumberLabelKey) &&
+            !overlappingExternalNumberLabelKeys.has(ownerPinNumberLabelKey)
 
         if (pin.orientation === 'left') {
             if (labelMode !== 'hidden' && labelMode !== 'name-only') {
@@ -247,6 +250,7 @@ export class SchematicPinSvgRenderer {
         if (
             labelMode !== 'hidden' &&
             labelMode !== 'name-only' &&
+            shouldRenderExternalNumber &&
             (pin.orientation === 'top' || pin.orientation === 'bottom')
         ) {
             texts.push(

package/src/ui/SchematicSvgRenderer.mjs

@@ -34,6 +34,7 @@ const SECTION_HEADING_LINE_X_PADDING = 15
 const BODY_TEXT_ASCENT_RATIO = 0.72
 const BODY_TEXT_DESCENT_RATIO = 0.14
 const BODY_TEXT_FLAT_DESCENT_RATIO = 0
+const TEXT_VERTICAL_MIDDLE_BASELINE_RATIO = 0.36
 const BODY_TEXT_MIN_SEPARATOR_SPAN_RATIO = 0.3
 const BODY_TEXT_DESCENDER_PATTERN = /[gjpqyQ_,;]/
 
@@ -45,7 +46,7 @@ export class SchematicSvgRenderer {
 
     /**
      * Renders a normalized schematic model into SVG markup.
-     * @param {{ fileName?: string, summary: { title?: string }, schematic?: { sheet: { width: number, height: number, sourceWidth?: number, sourceHeight?: number, paperSize?: string, borderOn?: boolean, titleBlockOn?: boolean, marginWidth?: number, xZones?: number, yZones?: number, titleBlock?: { title?: string, revision?: string, documentNumber?: string, sheetNumber?: string, sheetTotal?: string, date?: string, drawnBy?: string } }, lines: { x1: number, y1: number, x2: number, y2: number, color: string, width: number, lineStyle?: number, isBus?: boolean, ownerIndex?: string, renderOrder?: number, recordType?: string }[], polygons?: { points: { x: number, y: number }[], color: string, fill: string, isSolid: boolean, transparent: boolean, lineWidth: number, ownerIndex?: string, renderOrder?: number }[], rectangles?: { x: number, y: number, width: number, height: number, color: string, fill: string, isSolid: boolean, transparent: boolean, lineWidth: number, ownerIndex?: string, renderOrder?: number }[], regions?: { x: number, y: number, width: number, height: number, color: string, fill: string, renderOrder?: number }[], ellipses?: { x: number, y: number, radiusX: number, radiusY: number, color: string, fill: string, isSolid: boolean, transparent: boolean, lineWidth: number, ownerIndex?: string, renderOrder?: number }[], arcs?: { x: number, y: number, radius: number, startAngle: number, endAngle: number, color: string, width: number, ownerIndex?: string, renderOrder?: number }[], directives?: { x: number, y: number, color: string, name: string, orientation?: number }[], texts: { x: number, y: number, text: string, textSegments?: { text: string, overline: boolean }[], color: string, recordType?: string, style?: number, fontSize?: number, fontFamily?: string, fontWeight?: number, fontStyle?: string, rotation?: number, sourceOrientation?: number, isMirrored?: boolean, anchor?: 'start' | 'middle' | 'end', powerPortDirection?: 'up' | 'down' | 'left' | 'right', cornerX?: number, cornerY?: number, fill?: string, borderColor?: string, isSolid?: boolean, showBorder?: boolean, textMargin?: number, noteLines?: string[] }[], components: { x: number, y: number, designator: string }[], pins?: { x: number, y: number, length: number, name: string, nameSegments?: { text: string, overline: boolean }[], designator: string, orientation: 'left' | 'right' | 'top' | 'bottom', electrical?: number, symbolOuter?: number, color: string, labelColor?: string, labelMode?: 'hidden' | 'number-only' | 'name-only' | 'name-and-number', ownerIndex?: string }[], ports?: { x: number, y: number, width: number, height: number, name: string, fill: string, color: string, direction?: 'left' | 'right' | 'up' | 'down', shape?: 'single' | 'double' | 'plain' }[], crosses?: { x: number, y: number, size: number, color: string }[] } }} documentModel
+     * @param {{ fileName?: string, summary: { title?: string }, schematic?: { sheet: { width: number, height: number, sourceWidth?: number, sourceHeight?: number, paperSize?: string, borderOn?: boolean, titleBlockOn?: boolean, marginWidth?: number, xZones?: number, yZones?: number, titleBlock?: { title?: string, revision?: string, documentNumber?: string, sheetNumber?: string, sheetTotal?: string, date?: string, drawnBy?: string } }, lines: { x1: number, y1: number, x2: number, y2: number, color: string, width: number, lineStyle?: number, isBus?: boolean, ownerIndex?: string, renderOrder?: number, recordType?: string }[], polygons?: { points: { x: number, y: number }[], color: string, fill: string, isSolid: boolean, transparent: boolean, lineWidth: number, ownerIndex?: string, renderOrder?: number }[], rectangles?: { x: number, y: number, width: number, height: number, color: string, fill: string, isSolid: boolean, transparent: boolean, lineWidth: number, ownerIndex?: string, renderOrder?: number }[], regions?: { x: number, y: number, width: number, height: number, color: string, fill: string, renderOrder?: number }[], ellipses?: { x: number, y: number, radiusX: number, radiusY: number, color: string, fill: string, isSolid: boolean, transparent: boolean, lineWidth: number, ownerIndex?: string, renderOrder?: number }[], arcs?: { x: number, y: number, radius: number, startAngle: number, endAngle: number, color: string, width: number, ownerIndex?: string, renderOrder?: number }[], directives?: { x: number, y: number, color: string, name: string, orientation?: number, style?: number }[], texts: { x: number, y: number, text: string, textSegments?: { text: string, overline: boolean }[], color: string, recordType?: string, style?: number, fontSize?: number, fontFamily?: string, fontWeight?: number, fontStyle?: string, rotation?: number, sourceOrientation?: number, isMirrored?: boolean, anchor?: 'start' | 'middle' | 'end', powerPortDirection?: 'up' | 'down' | 'left' | 'right', cornerX?: number, cornerY?: number, fill?: string, borderColor?: string, isSolid?: boolean, showBorder?: boolean, textMargin?: number, noteLines?: string[] }[], components: { x: number, y: number, designator: string }[], pins?: { x: number, y: number, length: number, name: string, nameSegments?: { text: string, overline: boolean }[], designator: string, orientation: 'left' | 'right' | 'top' | 'bottom', electrical?: number, symbolOuter?: number, color: string, labelColor?: string, labelMode?: 'hidden' | 'number-only' | 'name-only' | 'name-and-number', ownerIndex?: string }[], ports?: { x: number, y: number, width: number, height: number, name: string, fill: string, color: string, direction?: 'left' | 'right' | 'up' | 'down', shape?: 'single' | 'double' | 'plain' }[], crosses?: { x: number, y: number, size: number, color: string }[] } }} documentModel
      * @param {{ projectParameters?: Record<string, string | number | boolean | null | undefined>, colorizeImages?: boolean, colorize_images?: boolean }} options Render options.
      * @returns {string}
      */
@@ -634,6 +635,11 @@ export class SchematicSvgRenderer {
                 pins,
                 contentRectangles
             )
+        const explicitOwnerPinNumberLabelKeys =
+            SchematicOwnerPinLabelLayout.collectExplicitOwnerPinNumberLabelKeys(
+                texts,
+                pins
+            )
         const overlappingExternalNumberLabelKeys =
             SchematicOwnerPinLabelLayout.collectOverlappingExternalNumberLabelKeys(
                 pins,
@@ -652,6 +658,7 @@ export class SchematicSvgRenderer {
                         explicitOwnerPinLabelOffsets,
                         compactExternalNumberLabelSides,
                         internalNumberLabelBoxes,
+                        explicitOwnerPinNumberLabelKeys,
                         overlappingExternalNumberLabelKeys
                     ),
                     SchematicSvgRenderer.#semanticAttributes(
@@ -2702,7 +2709,7 @@ export class SchematicSvgRenderer {
 
     /**
      * Resolves final text placement for schematic free-text annotations.
-     * @param {{ x: number, y: number, text: string, ownerIndex?: string, recordType?: string, fontSize?: number, rotation?: number, anchor?: 'start' | 'middle' | 'end', verticalAnchor?: 'top' }} text
+     * @param {{ x: number, y: number, text: string, ownerIndex?: string, recordType?: string, fontSize?: number, rotation?: number, anchor?: 'start' | 'middle' | 'end', verticalAnchor?: 'middle' | 'top' }} text
      * @param {number} sheetHeight
      * @param {{ x1: number, y1: number, x2: number, y2: number, lineStyle?: number }[]} lines
      * @param {{ x: number, y: number, name?: string, ownerIndex?: string, orientation: 'left' | 'right' | 'top' | 'bottom' } | null} matchedOwnerPin
@@ -2822,17 +2829,26 @@ export class SchematicSvgRenderer {
     }
 
     /**
-     * Converts top-anchored text coordinates into SVG baseline coordinates.
-     * @param {{ verticalAnchor?: 'top' }} text Text primitive.
+     * Converts vertically anchored text coordinates into SVG baseline
+     * coordinates.
+     * @param {{ verticalAnchor?: 'middle' | 'top' }} text Text primitive.
      * @param {number} fontSize Viewer font size.
      * @returns {number}
      */
     static #resolveVerticalAnchorBaselineOffset(text, fontSize) {
-        if (text?.verticalAnchor !== 'top') {
+        if (!Number.isFinite(fontSize) || fontSize <= 0) {
             return 0
         }
 
-        return Number.isFinite(fontSize) && fontSize > 0 ? fontSize : 0
+        if (text?.verticalAnchor === 'middle') {
+            return fontSize * TEXT_VERTICAL_MIDDLE_BASELINE_RATIO
+        }
+
+        if (text?.verticalAnchor === 'top') {
+            return fontSize
+        }
+
+        return 0
     }
 
     /**