altium-toolkit 1.1.2 → 1.1.3

package/src/core/altium/SchematicTextPostProcessor.mjs

@@ -2,6 +2,8 @@
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+import { SchematicMultipartDesignatorNormalizer } from './SchematicMultipartDesignatorNormalizer.mjs'
+
 /**
  * Applies placement-oriented cleanup passes to normalized schematic text.
  */
@@ -47,84 +49,17 @@ export class SchematicTextPostProcessor {
     }
 
     /**
-     * Adds multipart section suffixes like A/B/J to visible designator texts
-     * when the active Altium part id is stored separately from the base
+     * Normalizes multipart section suffixes like A/B/J on visible designator
+     * texts when the active Altium part id is stored separately from the
      * designator string.
      * @param {{ text: string, name?: string, ownerIndex?: string, recordType?: string }[]} texts
      * @param {Map<string, string>} activeMultipartOwnerParts
      * @returns {{ text: string, name?: string, ownerIndex?: string, recordType?: string }[]}
      */
     static decorateMultipartDesignators(texts, activeMultipartOwnerParts) {
-        const duplicatedActiveBaseDesignators =
-            SchematicTextPostProcessor.#collectDuplicatedActiveMultipartDesignators(
-                texts,
-                activeMultipartOwnerParts
-            )
-
-        return texts.map((text) => {
-            const ownerIndex = String(text.ownerIndex || '')
-            const suffix =
-                SchematicTextPostProcessor.#formatMultipartPartSuffix(
-                    activeMultipartOwnerParts.get(ownerIndex)
-                )
-
-            if (
-                !suffix ||
-                text.recordType !== '34' ||
-                String(text.name || '')
-                    .trim()
-                    .toLowerCase() !== 'designator' ||
-                !duplicatedActiveBaseDesignators.has(text.text)
-            ) {
-                return text
-            }
-
-            if (!/\d$/i.test(text.text) || text.text.endsWith(suffix)) {
-                return text
-            }
-
-            return {
-                ...text,
-                text: text.text + suffix
-            }
-        })
-    }
-
-    /**
-     * Collects base multipart designators that belong to more than one active
-     * visible owner on the current sheet.
-     * @param {{ text: string, name?: string, ownerIndex?: string, recordType?: string }[]} texts
-     * @param {Map<string, string>} activeMultipartOwnerParts
-     * @returns {Set<string>}
-     */
-    static #collectDuplicatedActiveMultipartDesignators(
-        texts,
-        activeMultipartOwnerParts
-    ) {
-        const counts = new Map()
-
-        for (const text of texts) {
-            const ownerIndex = String(text.ownerIndex || '')
-
-            if (
-                !activeMultipartOwnerParts.has(ownerIndex) ||
-                text.recordType !== '34' ||
-                String(text.name || '')
-                    .trim()
-                    .toLowerCase() !== 'designator' ||
-                !/\d$/i.test(String(text.text || '').trim())
-            ) {
-                continue
-            }
-
-            const baseDesignator = String(text.text || '').trim()
-            counts.set(baseDesignator, (counts.get(baseDesignator) || 0) + 1)
-        }
-
-        return new Set(
-            [...counts.entries()]
-                .filter(([, count]) => count > 1)
-                .map(([baseDesignator]) => baseDesignator)
+        return SchematicMultipartDesignatorNormalizer.normalize(
+            texts,
+            activeMultipartOwnerParts
         )
     }
 
@@ -136,7 +71,7 @@ export class SchematicTextPostProcessor {
      * @param {{ x1: number, y1: number, x2: number, y2: number, ownerIndex?: string }[]} lines
      * @param {{ x: number, y: number, ownerIndex: string, length: number, orientation: 'left' | 'right' | 'top' | 'bottom' }[]} pins
      * @param {{ x: number, y: number, width: number, direction?: 'left' | 'right' | 'up' | 'down' }[]} ports
-     * @param {{ x: number, y: number, width: number, height: number, ownerIndex?: string }[]} rectangles
+     * @param {{ x: number, y: number, width: number, height: number, ownerIndex?: string }[] | { rectangles?: { x: number, y: number, width: number, height: number, ownerIndex?: string }[], roundedRectangles?: { x: number, y: number, width: number, height: number, ownerIndex?: string }[], ellipses?: { x: number, y: number, radiusX: number, radiusY: number, ownerIndex?: string }[], arcs?: { x: number, y: number, radius: number, radiusY?: number, ownerIndex?: string }[], pies?: { x: number, y: number, radius: number, radiusY?: number, ownerIndex?: string }[] }} bodyPrimitives
      * @returns {{ x: number, y: number, text: string, name?: string, ownerIndex?: string, recordType?: string, rotation?: number, anchor?: 'start' | 'middle' | 'end' }[]}
      */
     static anchorComponentTextsFromOwnerBounds(
@@ -144,17 +79,22 @@ export class SchematicTextPostProcessor {
         lines,
         pins,
         ports = [],
-        rectangles = []
+        bodyPrimitives = []
     ) {
+        const normalizedBodyPrimitives =
+            SchematicTextPostProcessor.#normalizeOwnerBodyPrimitives(
+                bodyPrimitives
+            )
         const ownerBounds = SchematicTextPostProcessor.#buildOwnerBounds(
             lines,
             pins
         )
-        const ownerBodyBounds = SchematicTextPostProcessor.#buildOwnerBounds(
-            lines,
-            pins,
-            rectangles
-        )
+        const ownerBodyBounds =
+            SchematicTextPostProcessor.#buildOwnerBodyBounds(
+                lines,
+                pins,
+                normalizedBodyPrimitives
+            )
         const ownerPinCounts =
             SchematicTextPostProcessor.#buildOwnerPinCounts(pins)
         const ownerPinOrientations =
@@ -236,6 +176,131 @@ export class SchematicTextPostProcessor {
         })
     }
 
+    /**
+     * Normalizes owner body primitive arguments while preserving the older
+     * rectangle-array call shape.
+     * @param {{ x: number, y: number, width: number, height: number, ownerIndex?: string }[] | { rectangles?: { x: number, y: number, width: number, height: number, ownerIndex?: string }[], roundedRectangles?: { x: number, y: number, width: number, height: number, ownerIndex?: string }[], ellipses?: { x: number, y: number, radiusX: number, radiusY: number, ownerIndex?: string }[], arcs?: { x: number, y: number, radius: number, radiusY?: number, ownerIndex?: string }[], pies?: { x: number, y: number, radius: number, radiusY?: number, ownerIndex?: string }[] }} bodyPrimitives
+     * @returns {{ rectangles: { x: number, y: number, width: number, height: number, ownerIndex?: string }[], roundedRectangles: { x: number, y: number, width: number, height: number, ownerIndex?: string }[], ellipses: { x: number, y: number, radiusX: number, radiusY: number, ownerIndex?: string }[], arcs: { x: number, y: number, radius: number, radiusY?: number, ownerIndex?: string }[], pies: { x: number, y: number, radius: number, radiusY?: number, ownerIndex?: string }[] }}
+     */
+    static #normalizeOwnerBodyPrimitives(bodyPrimitives) {
+        if (Array.isArray(bodyPrimitives)) {
+            return {
+                rectangles: bodyPrimitives,
+                roundedRectangles: [],
+                ellipses: [],
+                arcs: [],
+                pies: []
+            }
+        }
+
+        return {
+            rectangles: bodyPrimitives?.rectangles || [],
+            roundedRectangles: bodyPrimitives?.roundedRectangles || [],
+            ellipses: bodyPrimitives?.ellipses || [],
+            arcs: bodyPrimitives?.arcs || [],
+            pies: bodyPrimitives?.pies || []
+        }
+    }
+
+    /**
+     * Builds per-owner body bounds from straight and curved owner primitives.
+     * @param {{ x1: number, y1: number, x2: number, y2: number, ownerIndex?: string }[]} lines
+     * @param {{ x: number, y: number, ownerIndex: string }[]} pins
+     * @param {{ rectangles: { x: number, y: number, width: number, height: number, ownerIndex?: string }[], roundedRectangles: { x: number, y: number, width: number, height: number, ownerIndex?: string }[], ellipses: { x: number, y: number, radiusX: number, radiusY: number, ownerIndex?: string }[], arcs: { x: number, y: number, radius: number, radiusY?: number, ownerIndex?: string }[], pies: { x: number, y: number, radius: number, radiusY?: number, ownerIndex?: string }[] }} bodyPrimitives
+     * @returns {Map<string, { minX: number, minY: number, maxX: number, maxY: number }>}
+     */
+    static #buildOwnerBodyBounds(lines, pins, bodyPrimitives) {
+        const ownerBounds = SchematicTextPostProcessor.#buildOwnerBounds(
+            lines,
+            pins,
+            [...bodyPrimitives.rectangles, ...bodyPrimitives.roundedRectangles]
+        )
+
+        SchematicTextPostProcessor.#extendCenteredOwnerBounds(
+            ownerBounds,
+            bodyPrimitives.ellipses
+        )
+        SchematicTextPostProcessor.#extendCenteredOwnerBounds(
+            ownerBounds,
+            bodyPrimitives.arcs
+        )
+        SchematicTextPostProcessor.#extendCenteredOwnerBounds(
+            ownerBounds,
+            bodyPrimitives.pies
+        )
+
+        return ownerBounds
+    }
+
+    /**
+     * Extends owner bounds by primitives expressed as a center and radii.
+     * @param {Map<string, { minX: number, minY: number, maxX: number, maxY: number }>} ownerBounds
+     * @param {{ x: number, y: number, radius?: number, radiusX?: number, radiusY?: number, ownerIndex?: string }[]} primitives
+     * @returns {void}
+     */
+    static #extendCenteredOwnerBounds(ownerBounds, primitives) {
+        for (const primitive of primitives) {
+            if (!primitive.ownerIndex) {
+                continue
+            }
+
+            const radiusX =
+                SchematicTextPostProcessor.#resolveHorizontalRadius(primitive)
+            const radiusY =
+                SchematicTextPostProcessor.#resolveVerticalRadius(primitive)
+
+            if (radiusX <= 0 || radiusY <= 0) {
+                continue
+            }
+
+            SchematicTextPostProcessor.#extendBounds(
+                ownerBounds,
+                primitive.ownerIndex,
+                [
+                    { x: primitive.x - radiusX, y: primitive.y - radiusY },
+                    { x: primitive.x + radiusX, y: primitive.y + radiusY }
+                ]
+            )
+        }
+    }
+
+    /**
+     * Resolves the horizontal radius of a center-defined primitive.
+     * @param {{ radius?: number, radiusX?: number }} primitive
+     * @returns {number}
+     */
+    static #resolveHorizontalRadius(primitive) {
+        return SchematicTextPostProcessor.#coercePositiveNumber(
+            primitive.radiusX ?? primitive.radius
+        )
+    }
+
+    /**
+     * Resolves the vertical radius of a center-defined primitive.
+     * @param {{ radius?: number, radiusY?: number }} primitive
+     * @returns {number}
+     */
+    static #resolveVerticalRadius(primitive) {
+        return SchematicTextPostProcessor.#coercePositiveNumber(
+            primitive.radiusY ?? primitive.radius
+        )
+    }
+
+    /**
+     * Converts finite positive numeric values, preserving zero for invalids.
+     * @param {number | string | undefined | null} value
+     * @returns {number}
+     */
+    static #coercePositiveNumber(value) {
+        const numericValue = Number(value)
+
+        if (!Number.isFinite(numericValue) || numericValue <= 0) {
+            return 0
+        }
+
+        return numericValue
+    }
+
     /**
      * Right-aligns wire labels that precede a same-row component designator so
      * they stay clear of the symbol body.
@@ -401,6 +466,8 @@ export class SchematicTextPostProcessor {
             case 2:
             case 33:
                 return 8
+            case 6:
+                return 12
             default:
                 return 2
         }
@@ -744,29 +811,6 @@ export class SchematicTextPostProcessor {
         )
     }
 
-    /**
-     * Converts one numeric multipart section id into an alphabetic suffix.
-     * @param {string | undefined} partId
-     * @returns {string}
-     */
-    static #formatMultipartPartSuffix(partId) {
-        const numericPartId = Number.parseInt(String(partId || ''), 10)
-        if (!Number.isInteger(numericPartId) || numericPartId <= 0) {
-            return ''
-        }
-
-        let suffix = ''
-        let remaining = numericPartId
-
-        while (remaining > 0) {
-            remaining -= 1
-            suffix = String.fromCharCode(65 + (remaining % 26)) + suffix
-            remaining = Math.floor(remaining / 26)
-        }
-
-        return suffix
-    }
-
     /**
      * Returns true when the horizontal wire segment under the label starts at a
      * pin endpoint, which means the label should continue reading rightward.

package/src/ui/SchematicColorResolver.mjs

@@ -59,6 +59,31 @@ export class SchematicColorResolver {
             : SchematicColorResolver.#toVariable(fallbackVariable)
     }
 
+    /**
+     * Resolves one non-text primitive color, using the semantic fallback when
+     * source artwork only supplies the default black text color.
+     * @param {string | undefined} color
+     * @param {string} fallbackVariable
+     * @param {boolean} [preserveUnknown]
+     * @returns {string}
+     */
+    static resolveNonTextColor(
+        color,
+        fallbackVariable,
+        preserveUnknown = false
+    ) {
+        const resolved = SchematicColorResolver.resolveColor(
+            color,
+            fallbackVariable,
+            preserveUnknown
+        )
+
+        return resolved ===
+            SchematicColorResolver.#toVariable('--schematic-text-color')
+            ? SchematicColorResolver.#toVariable(fallbackVariable)
+            : resolved
+    }
+
     /**
      * Resolves one SVG fill value to a schematic theme variable.
      * @param {string | undefined} fill
@@ -100,6 +125,59 @@ export class SchematicColorResolver {
             : SchematicColorResolver.#toVariable(fallbackVariable)
     }
 
+    /**
+     * Resolves an explicitly authored source stroke color without mapping it to
+     * a semantic theme token.
+     * @param {string | undefined} color
+     * @param {string} fallbackVariable
+     * @returns {string}
+     */
+    static resolveSourceColor(color, fallbackVariable) {
+        return SchematicColorResolver.#resolveSourcePaint(
+            color,
+            fallbackVariable
+        )
+    }
+
+    /**
+     * Resolves an explicitly authored source fill color without mapping it to a
+     * semantic theme token.
+     * @param {string | undefined} fill
+     * @param {string} fallbackVariable
+     * @returns {string}
+     */
+    static resolveSourceFill(fill, fallbackVariable) {
+        return SchematicColorResolver.#resolveSourcePaint(
+            fill,
+            fallbackVariable
+        )
+    }
+
+    /**
+     * Resolves one literal source paint value while preserving SVG control
+     * values and falling back only when no source paint exists.
+     * @param {string | undefined} paint
+     * @param {string} fallbackVariable
+     * @returns {string}
+     */
+    static #resolveSourcePaint(paint, fallbackVariable) {
+        const normalized = SchematicColorResolver.#normalizeColor(paint)
+
+        if (!normalized) {
+            return SchematicColorResolver.#toVariable(fallbackVariable)
+        }
+
+        if (
+            normalized === 'none' ||
+            normalized === 'transparent' ||
+            normalized.startsWith('var(')
+        ) {
+            return normalized
+        }
+
+        return normalized
+    }
+
     /**
      * Normalizes one raw color string for token lookup.
      * @param {string | undefined} color

package/src/ui/SchematicContentLayout.mjs

@@ -721,7 +721,12 @@ export class SchematicContentLayout {
         }
 
         for (const text of schematic?.texts || []) {
-            coordinates.push([text.x, projectSchematicY(sheetHeight, text.y)])
+            coordinates.push(
+                ...SchematicContentLayout.#collectRenderedTextPoints(
+                    text,
+                    sheetHeight
+                )
+            )
         }
 
         for (const component of schematic?.components || []) {
@@ -829,6 +834,58 @@ export class SchematicContentLayout {
         }))
     }
 
+    /**
+     * Collects rendered bounds points for a text primitive.
+     * @param {{ x?: number, y?: number, recordType?: string, cornerX?: number, cornerY?: number, noteLines?: string[] }} text Text primitive.
+     * @param {number} sheetHeight Sheet height.
+     * @returns {number[][]}
+     */
+    static #collectRenderedTextPoints(text, sheetHeight) {
+        const x = Number(text?.x)
+        const y = Number(text?.y)
+
+        if (!Number.isFinite(x) || !Number.isFinite(y)) {
+            return []
+        }
+
+        if (SchematicContentLayout.#hasRenderedTextFrame(text)) {
+            const cornerX = Number(text.cornerX)
+            const cornerY = Number(text.cornerY)
+            const left = Math.min(x, cornerX)
+            const right = Math.max(x, cornerX)
+            const top = Math.min(
+                projectSchematicY(sheetHeight, y),
+                projectSchematicY(sheetHeight, cornerY)
+            )
+            const bottom = Math.max(
+                projectSchematicY(sheetHeight, y),
+                projectSchematicY(sheetHeight, cornerY)
+            )
+
+            return [
+                [left, top],
+                [right, bottom]
+            ]
+        }
+
+        return [[x, projectSchematicY(sheetHeight, y)]]
+    }
+
+    /**
+     * Returns true when a text primitive renders as a framed note/callout box.
+     * @param {{ recordType?: string, cornerX?: number, cornerY?: number, noteLines?: string[] }} text Text primitive.
+     * @returns {boolean}
+     */
+    static #hasRenderedTextFrame(text) {
+        const recordType = String(text?.recordType || '')
+
+        return Boolean(
+            (recordType === '28' || recordType === '209') &&
+            Number.isFinite(Number(text?.cornerX)) &&
+            Number.isFinite(Number(text?.cornerY))
+        )
+    }
+
     /**
      * Computes the inner endpoint for one schematic pin stub.
      * @param {{ x: number, y: number, length: number, orientation: 'left' | 'right' | 'top' | 'bottom' }} pin

package/src/ui/SchematicImageRenderer.mjs

@@ -4,9 +4,11 @@
 
 import { SchematicSvgUtils } from './SchematicSvgUtils.mjs'
 import { SchematicColorResolver } from './SchematicColorResolver.mjs'
+import { SchematicPowerDiagramImageProcessor } from './SchematicPowerDiagramImageProcessor.mjs'
 
 const { escapeHtml, formatNumber, projectSchematicY } = SchematicSvgUtils
 const MISSING_IMAGE_WRAP_SAFETY_FACTOR = 0.96
+const BLUEPRINT_IMAGE_FILTER_ID = 'schematic-blueprint-image-filter'
 
 /**
  * Renders normalized schematic image placements.
@@ -16,15 +18,19 @@ export class SchematicImageRenderer {
      * Builds markup for embedded schematic images and unresolved placeholders.
      * @param {{ x: number, y: number, cornerX: number, cornerY: number, fileName?: string, mimeType?: string, dataBase64?: string, diagnosticState?: string, keepAspect?: boolean }[]} images
      * @param {number} sheetHeight
+     * @param {{ colorizeImages?: boolean, colorize_images?: boolean }} options Image render options.
      * @returns {string}
      */
-    static buildMarkup(images, sheetHeight) {
-        return images
+    static buildMarkup(images, sheetHeight, options = {}) {
+        const renderOptions =
+            SchematicImageRenderer.#normalizeRenderOptions(options)
+        const imageMarkup = images
             .map((image) =>
                 image.dataBase64 && image.mimeType
                     ? SchematicImageRenderer.#buildEmbeddedImageMarkup(
                           image,
-                          sheetHeight
+                          sheetHeight,
+                          renderOptions
                       )
                     : SchematicImageRenderer.#buildPlaceholderMarkup(
                           image,
@@ -32,19 +38,82 @@ export class SchematicImageRenderer {
                       )
             )
             .join('')
+
+        return (
+            SchematicImageRenderer.#buildImageFilterMarkup(
+                images,
+                renderOptions
+            ) + imageMarkup
+        )
+    }
+
+    /**
+     * Normalizes image renderer options.
+     * @param {{ colorizeImages?: boolean, colorize_images?: boolean }} options Raw options.
+     * @returns {{ colorizeImages: boolean }}
+     */
+    static #normalizeRenderOptions(options) {
+        return {
+            colorizeImages:
+                options?.colorizeImages === true ||
+                options?.colorize_images === true
+        }
+    }
+
+    /**
+     * Builds any SVG filters needed by the embedded image set.
+     * @param {{ x: number, y: number, cornerX: number, cornerY: number, fileName?: string, mimeType?: string, dataBase64?: string }[]} images
+     * @param {{ colorizeImages: boolean }} options Normalized render options.
+     * @returns {string}
+     */
+    static #buildImageFilterMarkup(images, options) {
+        if (!options.colorizeImages) return ''
+
+        const hasDiagramImage = (images || []).some(
+            (image) =>
+                image?.dataBase64 &&
+                image?.mimeType &&
+                SchematicImageRenderer.#isDiagramImage(image) &&
+                !SchematicImageRenderer.#isPowerDiagramImage(image)
+        )
+
+        if (!hasDiagramImage) return ''
+
+        return (
+            '<defs>' +
+            SchematicImageRenderer.#buildBlueprintImageFilterMarkup() +
+            '</defs>'
+        )
     }
 
     /**
      * Builds one embedded SVG image node.
-     * @param {{ x: number, y: number, cornerX: number, cornerY: number, mimeType: string, dataBase64: string, keepAspect?: boolean }} image
+     * @param {{ x: number, y: number, cornerX: number, cornerY: number, fileName?: string, mimeType: string, dataBase64: string, keepAspect?: boolean }} image
      * @param {number} sheetHeight
+     * @param {{ colorizeImages: boolean }} options Normalized render options.
      * @returns {string}
      */
-    static #buildEmbeddedImageMarkup(image, sheetHeight) {
+    static #buildEmbeddedImageMarkup(image, sheetHeight, options) {
         const bounds = SchematicImageRenderer.#resolveBounds(image, sheetHeight)
+        const isDiagramImage = SchematicImageRenderer.#isDiagramImage(image)
+        const isPowerDiagramImage =
+            SchematicImageRenderer.#isPowerDiagramImage(image)
+        const colorizeImage = options.colorizeImages
+        const dataBase64 =
+            colorizeImage && isPowerDiagramImage
+                ? SchematicPowerDiagramImageProcessor.process(image)
+                : image.dataBase64
 
         return (
-            '<image class="schematic-embedded-image" x="' +
+            '<image class="' +
+            escapeHtml(
+                isPowerDiagramImage
+                    ? 'schematic-embedded-image schematic-embedded-image--power-diagram'
+                    : isDiagramImage
+                      ? 'schematic-embedded-image schematic-embedded-image--diagram'
+                      : 'schematic-embedded-image'
+            ) +
+            '" x="' +
             formatNumber(bounds.x) +
             '" y="' +
             formatNumber(bounds.y) +
@@ -54,14 +123,60 @@ export class SchematicImageRenderer {
             formatNumber(bounds.height) +
             '" preserveAspectRatio="' +
             escapeHtml(image.keepAspect === false ? 'none' : 'xMidYMid meet') +
-            '" href="' +
-            escapeHtml(
-                'data:' + image.mimeType + ';base64,' + image.dataBase64
-            ) +
+            '"' +
+            (colorizeImage && isDiagramImage && !isPowerDiagramImage
+                ? ' filter="url(#' +
+                  escapeHtml(BLUEPRINT_IMAGE_FILTER_ID) +
+                  ')"'
+                : '') +
+            ' href="' +
+            escapeHtml('data:' + image.mimeType + ';base64,' + dataBase64) +
             '" />'
         )
     }
 
+    /**
+     * Builds a filter that maps black diagram artwork to the schematic blue
+     * ink while keeping white backgrounds white.
+     * @returns {string}
+     */
+    static #buildBlueprintImageFilterMarkup() {
+        return (
+            '<filter id="' +
+            escapeHtml(BLUEPRINT_IMAGE_FILTER_ID) +
+            '" color-interpolation-filters="sRGB">' +
+            '<feColorMatrix type="matrix" values="' +
+            '1 0 0 0 0 ' +
+            '0 0.431 0 0 0.569 ' +
+            '0 0 0.325 0 0.675 ' +
+            '0 0 0 1 0' +
+            '" />' +
+            '</filter>'
+        )
+    }
+
+    /**
+     * Identifies recovered diagram artwork by explicit file naming.
+     * @param {{ fileName?: string, mimeType?: string }} image
+     * @returns {boolean}
+     */
+    static #isDiagramImage(image) {
+        return /diagram/i.test(String(image?.fileName || ''))
+    }
+
+    /**
+     * Identifies recovered power-diagram PNG artwork for selective palette
+     * processing.
+     * @param {{ fileName?: string, mimeType?: string }} image
+     * @returns {boolean}
+     */
+    static #isPowerDiagramImage(image) {
+        return (
+            image?.mimeType === 'image/png' &&
+            /power/i.test(String(image?.fileName || ''))
+        )
+    }
+
     /**
      * Builds one placeholder frame when an image payload is unavailable.
      * @param {{ x: number, y: number, cornerX: number, cornerY: number, fileName?: string }} image

package/src/ui/SchematicJunctionRenderer.mjs

@@ -44,7 +44,7 @@ export class SchematicJunctionRenderer {
                     formatNumber(projectSchematicY(sheetHeight, junction.y)) +
                     '" r="2" fill="' +
                     escapeHtml(
-                        SchematicColorResolver.resolveColor(
+                        SchematicColorResolver.resolveNonTextColor(
                             junction.color,
                             '--schematic-default-ink-color'
                         )