altium-toolkit 0.1.1 → 0.1.16

package/src/ui/PcbSideResolvedRenderModel.mjs

@@ -0,0 +1,336 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/**
+ * Prepares normalized Altium PCB models for side-specific top-oriented renderers.
+ */
+export class PcbSideResolvedRenderModel {
+    /**
+     * Resolves a normalized PCB model for the requested board side.
+     * @param {object | null} board
+     * @param {'front' | 'back' | { side?: 'front' | 'back' }} [options]
+     * @returns {object | null}
+     */
+    static resolve(board, options = {}) {
+        if (!board?.pcb) return board || null
+
+        const side = PcbSideResolvedRenderModel.#normalizeSide(options)
+        const pcb = board.pcb
+        return {
+            ...board,
+            pcb: {
+                ...pcb,
+                components: (pcb.components || []).filter((component) =>
+                    PcbSideResolvedRenderModel.#isComponentVisibleOnSide(
+                        component,
+                        side
+                    )
+                ),
+                primitiveLayers:
+                    PcbSideResolvedRenderModel.#preparePrimitiveLayersForSide(
+                        pcb.primitiveLayers || [],
+                        side
+                    ),
+                polygons: PcbSideResolvedRenderModel.#preparePolygonsForSide(
+                    pcb.polygons || [],
+                    side
+                ),
+                fills: PcbSideResolvedRenderModel.#preparePrimitivesForSide(
+                    pcb.fills || [],
+                    side
+                ),
+                tracks: PcbSideResolvedRenderModel.#preparePrimitivesForSide(
+                    pcb.tracks || [],
+                    side
+                ),
+                arcs: PcbSideResolvedRenderModel.#preparePrimitivesForSide(
+                    pcb.arcs || [],
+                    side
+                ),
+                regions: PcbSideResolvedRenderModel.#preparePrimitivesForSide(
+                    pcb.regions || [],
+                    side
+                ),
+                shapeBasedRegions:
+                    PcbSideResolvedRenderModel.#preparePrimitivesForSide(
+                        pcb.shapeBasedRegions || [],
+                        side
+                    ),
+                boardRegions:
+                    PcbSideResolvedRenderModel.#preparePrimitivesForSide(
+                        pcb.boardRegions || [],
+                        side
+                    ),
+                vias: PcbSideResolvedRenderModel.#prepareViasForSide(
+                    pcb.vias || [],
+                    side
+                ),
+                pads: PcbSideResolvedRenderModel.#preparePadsForSide(
+                    pcb.pads || [],
+                    side
+                )
+            }
+        }
+    }
+
+    /**
+     * Checks whether a primitive belongs to an Altium copper signal layer.
+     * @param {object | null} primitive
+     * @returns {boolean}
+     */
+    static isCopperPrimitive(primitive) {
+        const layerId = Number(primitive?.layerId)
+        return Number.isInteger(layerId) && layerId >= 1 && layerId <= 32
+    }
+
+    /**
+     * Normalizes the caller side option.
+     * @param {'front' | 'back' | { side?: 'front' | 'back' }} options
+     * @returns {'front' | 'back'}
+     */
+    static #normalizeSide(options) {
+        if (options === 'back') return 'back'
+        if (options && typeof options === 'object' && options.side === 'back') {
+            return 'back'
+        }
+        return 'front'
+    }
+
+    /**
+     * Checks whether a component should be visible for a requested side.
+     * @param {object | null} component
+     * @param {'front' | 'back'} side
+     * @returns {boolean}
+     */
+    static #isComponentVisibleOnSide(component, side) {
+        const layer = String(component?.layer || '')
+            .trim()
+            .toLowerCase()
+        const isBottom = layer.includes('bottom') || layer === 'bot'
+        return side === 'back' ? isBottom : !isBottom
+    }
+
+    /**
+     * Projects primitive layer names for a top-oriented renderer.
+     * @param {readonly object[]} primitiveLayers
+     * @param {'front' | 'back'} side
+     * @returns {object[]}
+     */
+    static #preparePrimitiveLayersForSide(primitiveLayers, side) {
+        if (side !== 'back') return Array.from(primitiveLayers)
+
+        return primitiveLayers.map((layer) => ({
+            ...layer,
+            name: PcbSideResolvedRenderModel.#backLayerNameForTopRenderer(
+                layer.name
+            )
+        }))
+    }
+
+    /**
+     * Converts top/bottom layer labels for back-side top-oriented rendering.
+     * @param {unknown} name
+     * @returns {string}
+     */
+    static #backLayerNameForTopRenderer(name) {
+        const value = String(name || '')
+        if (/\bbottom\b/iu.test(value)) {
+            return value.replace(/\bbottom\b/giu, 'Top')
+        }
+        if (/\btop\b/iu.test(value)) {
+            return value.replace(/\btop\b/giu, 'Hidden')
+        }
+        return value
+    }
+
+    /**
+     * Projects polygon side labels for a top-oriented renderer.
+     * @param {readonly object[]} polygons
+     * @param {'front' | 'back'} side
+     * @returns {object[]}
+     */
+    static #preparePolygonsForSide(polygons, side) {
+        if (side !== 'back') return Array.from(polygons)
+
+        return polygons.map((polygon) => {
+            const layer = String(polygon?.layer || '')
+                .trim()
+                .toUpperCase()
+            if (layer === 'BOTTOM' || layer === 'BOT') {
+                return { ...polygon, layer: 'TOP' }
+            }
+            if (layer === 'TOP') {
+                return { ...polygon, layer: 'HIDDEN' }
+            }
+            return { ...polygon }
+        })
+    }
+
+    /**
+     * Projects primitive layer codes for a top-oriented renderer.
+     * @param {readonly object[]} primitives
+     * @param {'front' | 'back'} side
+     * @returns {object[]}
+     */
+    static #preparePrimitivesForSide(primitives, side) {
+        if (side !== 'back') return Array.from(primitives)
+
+        return primitives.map((primitive) => {
+            if (!PcbSideResolvedRenderModel.isCopperPrimitive(primitive)) {
+                return { ...primitive }
+            }
+
+            const layerCode = Number(primitive.layerCode)
+            const fallbackCode = Number(primitive.layerId)
+            return {
+                ...primitive,
+                layerCode: -(Number.isFinite(layerCode)
+                    ? layerCode
+                    : fallbackCode || 0)
+            }
+        })
+    }
+
+    /**
+     * Filters vias to those visible from the requested side.
+     * @param {readonly object[]} vias
+     * @param {'front' | 'back'} side
+     * @returns {object[]}
+     */
+    static #prepareViasForSide(vias, side) {
+        return vias
+            .filter((via) =>
+                PcbSideResolvedRenderModel.#isViaVisibleOnSide(via, side)
+            )
+            .map((via) => ({ ...via }))
+    }
+
+    /**
+     * Checks whether a via spans the requested surface layer.
+     * @param {object | null} via
+     * @param {'front' | 'back'} side
+     * @returns {boolean}
+     */
+    static #isViaVisibleOnSide(via, side) {
+        const start = Number(via?.layerStartId)
+        const end = Number(via?.layerEndId)
+        if (!Number.isInteger(start) || !Number.isInteger(end)) return true
+
+        const surfaceLayerId = side === 'back' ? 32 : 1
+        return (
+            surfaceLayerId >= Math.min(start, end) &&
+            surfaceLayerId <= Math.max(start, end)
+        )
+    }
+
+    /**
+     * Filters and projects pads to the requested side.
+     * @param {readonly object[]} pads
+     * @param {'front' | 'back'} side
+     * @returns {object[]}
+     */
+    static #preparePadsForSide(pads, side) {
+        const visiblePads = pads.filter((pad) =>
+            PcbSideResolvedRenderModel.#isPadVisibleOnSide(pad, side)
+        )
+        if (side !== 'back') return visiblePads.map((pad) => ({ ...pad }))
+
+        return visiblePads.map((pad) => {
+            const layerId = PcbSideResolvedRenderModel.#effectivePadLayerId(pad)
+            return {
+                ...pad,
+                sizeTopX: PcbSideResolvedRenderModel.#firstFiniteValue(
+                    pad.sizeBottomX,
+                    pad.sizeMidX,
+                    pad.sizeTopX
+                ),
+                sizeTopY: PcbSideResolvedRenderModel.#firstFiniteValue(
+                    pad.sizeBottomY,
+                    pad.sizeMidY,
+                    pad.sizeTopY
+                ),
+                shapeTop: PcbSideResolvedRenderModel.#firstFiniteValue(
+                    pad.shapeBottom,
+                    pad.shapeMid,
+                    pad.shapeTop
+                ),
+                roundedRectShapeTop:
+                    PcbSideResolvedRenderModel.#firstFiniteValue(
+                        pad.roundedRectShapeBottom,
+                        pad.roundedRectShapeMid,
+                        pad.roundedRectShapeTop
+                    ),
+                cornerRadiusTop: PcbSideResolvedRenderModel.#firstFiniteValue(
+                    pad.cornerRadiusBottom,
+                    pad.cornerRadiusMid,
+                    pad.cornerRadiusTop
+                ),
+                layerCode: layerId === 32 ? 1 : pad.layerCode,
+                layerId: layerId === 32 ? 1 : pad.layerId
+            }
+        })
+    }
+
+    /**
+     * Checks whether a pad should be visible on the requested side.
+     * @param {object | null} pad
+     * @param {'front' | 'back'} side
+     * @returns {boolean}
+     */
+    static #isPadVisibleOnSide(pad, side) {
+        const layerId = PcbSideResolvedRenderModel.#effectivePadLayerId(pad)
+        if (layerId === 1) return side === 'front'
+        if (layerId === 32) return side === 'back'
+        return true
+    }
+
+    /**
+     * Resolves the authored Altium layer id for a pad.
+     * @param {object | null} pad
+     * @returns {number | null}
+     */
+    static #effectivePadLayerId(pad) {
+        const layerId = Number(pad?.layerId)
+        if (Number.isInteger(layerId) && layerId > 0) return layerId
+
+        const legacyLayerId = Number(pad?.legacyLayerId)
+        if (Number.isInteger(legacyLayerId) && legacyLayerId > 0) {
+            return legacyLayerId
+        }
+
+        return null
+    }
+
+    /**
+     * Returns the first finite numeric value.
+     * @param {...unknown} values
+     * @returns {number | undefined}
+     */
+    static #firstFiniteValue(...values) {
+        for (const value of values) {
+            const number = Number(value)
+            if (Number.isFinite(number)) return number
+        }
+        return undefined
+    }
+}
+
+/**
+ * Resolves a normalized PCB model for the requested board side.
+ * @param {object | null} board
+ * @param {'front' | 'back' | { side?: 'front' | 'back' }} [options]
+ * @returns {object | null}
+ */
+export function preparePcbSideResolvedRenderModel(board, options = {}) {
+    return PcbSideResolvedRenderModel.resolve(board, options)
+}
+
+/**
+ * Checks whether a primitive belongs to an Altium copper signal layer.
+ * @param {object | null} primitive
+ * @returns {boolean}
+ */
+export function isCopperPrimitive(primitive) {
+    return PcbSideResolvedRenderModel.isCopperPrimitive(primitive)
+}

package/src/ui/PcbSvgRenderer.mjs

@@ -4,7 +4,11 @@
 
 import { PcbArcUtils } from './PcbArcUtils.mjs'
 import { PcbEdgeFacingGlyphNormalizer } from './PcbEdgeFacingGlyphNormalizer.mjs'
+import { PcbEmbeddedFontFaceRenderer } from './PcbEmbeddedFontFaceRenderer.mjs'
 import { PcbFootprintPrimitiveSelector } from './PcbFootprintPrimitiveSelector.mjs'
+import { PcbCopperPrimitiveSplitter } from './PcbCopperPrimitiveSplitter.mjs'
+import { PcbRegionPrimitiveRenderer } from './PcbRegionPrimitiveRenderer.mjs'
+import { PcbTextPrimitiveRenderer } from './PcbTextPrimitiveRenderer.mjs'
 import { SchematicSvgUtils } from './SchematicSvgUtils.mjs'
 /**
  * Renders normalized PCB models into HTML and SVG markup.
@@ -15,7 +19,7 @@ export class PcbSvgRenderer {
     static #GENERIC_DETAIL_SEARCH_HALF_EXTENT = 240
     /**
      * Renders a normalized PCB model into HTML and SVG markup.
-     * @param {{ summary: { title?: string }, pcb?: { boardOutline: { segments: Array<Record<string, number | string>>, minX: number, minY: number, widthMil: number, heightMil: number }, layers: { name: string }[], primitiveLayers?: { layerId: number, name: string }[], polygons?: { layer?: string, segments: Array<Record<string, number | string>> }[], fills?: { x1: number, y1: number, x2: number, y2: number, layerCode?: number, layerId?: number }[], tracks?: { x1: number, y1: number, x2: number, y2: number, width: number, layerCode?: number, layerId?: number }[], arcs?: { x: number, y: number, radius: number, startAngle: number, endAngle: number, width: number, layerCode?: number, layerId?: number }[], vias?: { x: number, y: number, diameter: number, holeDiameter: number }[], pads?: { x: number, y: number, sizeTopX?: number, sizeTopY?: number, sizeMidX?: number, sizeMidY?: number, sizeBottomX?: number, sizeBottomY?: number, holeDiameter?: number, shapeTop?: number, shapeMid?: number, shapeBottom?: number, rotation?: number, isPlated?: boolean }[], components: { designator: string, x: number, y: number, rotation: number, layer: string, pattern: string }[] } }} documentModel
+     * @param {{ summary: { title?: string }, pcb?: { boardOutline: { segments: Array<Record<string, number | string>>, minX: number, minY: number, widthMil: number, heightMil: number }, layers: { name: string }[], primitiveLayers?: { layerId: number, name: string }[], polygons?: { layer?: string, segments: Array<Record<string, number | string>> }[], fills?: { x1: number, y1: number, x2: number, y2: number, layerCode?: number, layerId?: number }[], tracks?: { x1: number, y1: number, x2: number, y2: number, width: number, layerCode?: number, layerId?: number }[], arcs?: { x: number, y: number, radius: number, startAngle: number, endAngle: number, width: number, layerCode?: number, layerId?: number }[], vias?: { x: number, y: number, diameter: number, holeDiameter: number }[], pads?: { x: number, y: number, sizeTopX?: number, sizeTopY?: number, sizeMidX?: number, sizeMidY?: number, sizeBottomX?: number, sizeBottomY?: number, holeDiameter?: number, shapeTop?: number, shapeMid?: number, shapeBottom?: number, rotation?: number, isPlated?: boolean }[], texts?: { text: string, x: number, y: number, height?: number, rotation?: number, layerId?: number, visible?: boolean }[], components: { designator: string, x: number, y: number, rotation: number, layer: string, pattern: string }[] } }} documentModel
      * @returns {string}
      */
     static render(documentModel) {
@@ -28,14 +32,25 @@ export class PcbSvgRenderer {
         const fills = pcb.fills || []
         const tracks = pcb.tracks || []
         const arcs = pcb.arcs || []
+        const regions = pcb.regions || []
+        const shapeBasedRegions = pcb.shapeBasedRegions || []
+        const renderedRegions = shapeBasedRegions.length
+            ? shapeBasedRegions
+            : regions
         const vias = pcb.vias || []
         const pads = pcb.pads || []
         const components = pcb.components.slice(0, 260)
-        const copperGroups = PcbSvgRenderer.#splitCopperPrimitives(
+        const texts = PcbTextPrimitiveRenderer.select(
+            pcb.primitiveLayers || [],
+            pcb.texts || [],
+            'top'
+        )
+        const copperGroups = PcbCopperPrimitiveSplitter.split(
             polygons,
             fills,
             tracks,
-            arcs
+            arcs,
+            renderedRegions
         )
         const footprintPrimitives = PcbEdgeFacingGlyphNormalizer.normalize(
             PcbFootprintPrimitiveSelector.select(
@@ -43,6 +58,7 @@ export class PcbSvgRenderer {
                 fills,
                 tracks,
                 arcs,
+                renderedRegions,
                 'top'
             ),
             outline
@@ -71,6 +87,11 @@ export class PcbSvgRenderer {
                 ...copperGroups.subsurface.arcs,
                 ...footprintPrimitives.arcs
             ],
+            [
+                ...copperGroups.surface.regions,
+                ...copperGroups.subsurface.regions,
+                ...footprintPrimitives.regions
+            ],
             vias,
             pads
         )
@@ -151,6 +172,11 @@ export class PcbSvgRenderer {
                     )
                 )
                 .join('')
+        const regionMarkup = (regionList, visibilityClass) =>
+            PcbRegionPrimitiveRenderer.buildMarkup(
+                regionList,
+                'pcb-region pcb-region--' + visibilityClass
+            )
         const viaMarkup = vias
             .map((via) => {
                 const ringRadius = Math.max((via.diameter || 0) / 2, 1)
@@ -222,6 +248,14 @@ export class PcbSvgRenderer {
         const footprintArcMarkup = footprintPrimitives.arcs
             .map((arc) => PcbArcUtils.buildMarkup(arc, 'pcb-footprint-arc'))
             .join('')
+        const footprintRegionMarkup = PcbRegionPrimitiveRenderer.buildMarkup(
+            footprintPrimitives.regions,
+            'pcb-footprint-region'
+        )
+        const textMarkup = PcbTextPrimitiveRenderer.render(texts)
+        const fontFaceMarkup = PcbEmbeddedFontFaceRenderer.buildMarkup(
+            pcb.embeddedFonts || []
+        )
 
         const componentMarkup = components
             .map((component) => {
@@ -260,13 +294,7 @@ export class PcbSvgRenderer {
                     SchematicSvgUtils.formatNumber(component.rotation) +
                     ')">' +
                     bodyMarkup +
-                    '<text x="0" y="' +
-                    SchematicSvgUtils.formatNumber(
-                        bodyGeometry.height * -0.75
-                    ) +
-                    '">' +
-                    SchematicSvgUtils.escapeHtml(component.designator) +
-                    '</text></g>'
+                    '</g>'
                 )
             })
             .join('')
@@ -288,7 +316,9 @@ export class PcbSvgRenderer {
             '<svg class="pcb-svg" viewBox="' +
             SchematicSvgUtils.escapeHtml(viewBox) +
             '" preserveAspectRatio="xMidYMid meet" aria-label="PCB view">' +
-            '<defs><clipPath id="' +
+            '<defs>' +
+            fontFaceMarkup +
+            '<clipPath id="' +
             clipPathId +
             '"><path d="' +
             SchematicSvgUtils.escapeHtml(path) +
@@ -302,12 +332,14 @@ export class PcbSvgRenderer {
             '<g class="pcb-copper pcb-copper--subsurface">' +
             polygonMarkup(copperGroups.subsurface.polygons, 'subsurface') +
             fillMarkup(copperGroups.subsurface.fills, 'subsurface') +
+            regionMarkup(copperGroups.subsurface.regions, 'subsurface') +
             trackMarkup(copperGroups.subsurface.tracks, 'subsurface') +
             arcMarkup(copperGroups.subsurface.arcs, 'subsurface') +
             '</g>' +
             '<g class="pcb-copper pcb-copper--surface">' +
             polygonMarkup(copperGroups.surface.polygons, 'surface') +
             fillMarkup(copperGroups.surface.fills, 'surface') +
+            regionMarkup(copperGroups.surface.regions, 'surface') +
             trackMarkup(copperGroups.surface.tracks, 'surface') +
             arcMarkup(copperGroups.surface.arcs, 'surface') +
             padMarkup +
@@ -318,6 +350,12 @@ export class PcbSvgRenderer {
             footprintFillMarkup +
             footprintTrackMarkup +
             footprintArcMarkup +
+            footprintRegionMarkup +
+            '</g>' +
+            '<g class="pcb-texts" clip-path="url(#' +
+            clipPathId +
+            ')">' +
+            textMarkup +
             '</g>' +
             '<path class="board-outline board-outline--stroke" d="' +
             SchematicSvgUtils.escapeHtml(path) +
@@ -382,6 +420,7 @@ export class PcbSvgRenderer {
      * @param {{ x1: number, y1: number, x2: number, y2: number }[]} fills
      * @param {{ x1: number, y1: number, x2: number, y2: number }[]} tracks
      * @param {{ x: number, y: number, radius: number, width?: number }[]} arcs
+     * @param {{ points?: { x: number, y: number }[], holes?: { x: number, y: number }[][] }[]} regions
      * @param {{ x: number, y: number, diameter: number }[]} vias
      * @param {{ x: number, y: number, sizeTopX?: number, sizeTopY?: number, sizeMidX?: number, sizeMidY?: number, sizeBottomX?: number, sizeBottomY?: number, holeDiameter?: number }[]} pads
      * @returns {string}
@@ -393,6 +432,7 @@ export class PcbSvgRenderer {
         fills,
         tracks,
         arcs,
+        regions,
         vias,
         pads
     ) {
@@ -424,6 +464,10 @@ export class PcbSvgRenderer {
             PcbArcUtils.pushExtents(xs, ys, arc)
         }
 
+        for (const region of regions) {
+            PcbRegionPrimitiveRenderer.pushExtents(xs, ys, region)
+        }
+
         for (const via of vias) {
             const radius = (via.diameter || 0) / 2
             xs.push(via.x - radius, via.x + radius)
@@ -664,14 +708,24 @@ export class PcbSvgRenderer {
     }
 
     /**
-     * Returns true when one component already has authored local geometry from
-     * selected top-side documentation layers.
-     * @param {{ x: number, y: number, pattern: string }} component
-     * @param {{ fills: { x1: number, y1: number, x2: number, y2: number }[], tracks: { x1: number, y1: number, x2: number, y2: number }[], arcs: { x: number, y: number, radius: number, width?: number }[] }} footprintPrimitives
-     * @param {{ x: number, y: number, sizeTopX?: number, sizeTopY?: number, sizeMidX?: number, sizeMidY?: number, sizeBottomX?: number, sizeBottomY?: number, rotation?: number, offsetTopX?: number, offsetTopY?: number, holeDiameter?: number }[]} pads
+     * Returns true when one component already has authored geometry, either by
+     * an explicit component ownership link or by nearby recovered primitives.
+     * @param {{ componentIndex?: number | null, x: number, y: number, pattern: string }} component
+     * @param {{ fills: { componentIndex?: number | null, x1: number, y1: number, x2: number, y2: number }[], tracks: { componentIndex?: number | null, x1: number, y1: number, x2: number, y2: number }[], arcs: { componentIndex?: number | null, x: number, y: number, radius: number, width?: number }[], regions?: { componentIndex?: number | null, points?: { x: number, y: number }[], holes?: { x: number, y: number }[][] }[] }} footprintPrimitives
+     * @param {{ componentIndex?: number | null, x: number, y: number, sizeTopX?: number, sizeTopY?: number, sizeMidX?: number, sizeMidY?: number, sizeBottomX?: number, sizeBottomY?: number, rotation?: number, offsetTopX?: number, offsetTopY?: number, holeDiameter?: number }[]} pads
      * @returns {boolean}
      */
     static #hasAuthoredFootprintDetail(component, footprintPrimitives, pads) {
+        if (
+            PcbSvgRenderer.#hasComponentOwnedFootprintDetail(
+                component,
+                footprintPrimitives,
+                pads
+            )
+        ) {
+            return true
+        }
+
         const bounds = PcbSvgRenderer.#footprintDetailBounds(component)
 
         return (
@@ -684,12 +738,43 @@ export class PcbSvgRenderer {
             (footprintPrimitives.arcs || []).some((arc) =>
                 PcbArcUtils.intersectsBounds(arc, bounds)
             ) ||
+            (footprintPrimitives.regions || []).some((region) =>
+                PcbRegionPrimitiveRenderer.intersectsBounds(region, bounds)
+            ) ||
             (pads || []).some((pad) =>
                 PcbSvgRenderer.#padIntersectsBounds(pad, bounds)
             )
         )
     }
 
+    /**
+     * Returns true when recovered primitives directly reference the component.
+     * @param {{ componentIndex?: number | null }} component
+     * @param {{ fills?: { componentIndex?: number | null }[], tracks?: { componentIndex?: number | null }[], arcs?: { componentIndex?: number | null }[], regions?: { componentIndex?: number | null }[] }} footprintPrimitives
+     * @param {{ componentIndex?: number | null }[]} pads
+     * @returns {boolean}
+     */
+    static #hasComponentOwnedFootprintDetail(
+        component,
+        footprintPrimitives,
+        pads
+    ) {
+        const componentIndex = Number(component?.componentIndex)
+        if (!Number.isInteger(componentIndex)) {
+            return false
+        }
+
+        return [
+            ...(footprintPrimitives.tracks || []),
+            ...(footprintPrimitives.fills || []),
+            ...(footprintPrimitives.arcs || []),
+            ...(footprintPrimitives.regions || []),
+            ...(pads || [])
+        ].some(
+            (primitive) => Number(primitive?.componentIndex) === componentIndex
+        )
+    }
+
     /**
      * Returns true when one recovered pad surface overlaps a component-local
      * search box, which means the footprint already has concrete 2D items.
@@ -771,89 +856,6 @@ export class PcbSvgRenderer {
         )
     }
 
-    /**
-     * Splits recovered copper primitives into the default top-facing surface
-     * view and de-emphasized buried layers.
-     * @param {{ layer?: string, segments: Array<Record<string, number | string>> }[]} polygons
-     * @param {{ x1: number, y1: number, x2: number, y2: number, layerCode?: number, layerId?: number }[]} fills
-     * @param {{ x1: number, y1: number, x2: number, y2: number, width: number, layerCode?: number, layerId?: number }[]} tracks
-     * @param {{ x: number, y: number, radius: number, startAngle: number, endAngle: number, width: number, layerCode?: number, layerId?: number }[]} arcs
-     * @returns {{ surface: { polygons: { layer?: string, segments: Array<Record<string, number | string>> }[], fills: { x1: number, y1: number, x2: number, y2: number, layerCode?: number, layerId?: number }[], tracks: { x1: number, y1: number, x2: number, y2: number, width: number, layerCode?: number, layerId?: number }[], arcs: { x: number, y: number, radius: number, startAngle: number, endAngle: number, width: number, layerCode?: number, layerId?: number }[] }, subsurface: { polygons: { layer?: string, segments: Array<Record<string, number | string>> }[], fills: { x1: number, y1: number, x2: number, y2: number, layerCode?: number, layerId?: number }[], tracks: { x1: number, y1: number, x2: number, y2: number, width: number, layerCode?: number, layerId?: number }[], arcs: { x: number, y: number, radius: number, startAngle: number, endAngle: number, width: number, layerCode?: number, layerId?: number }[] } }}
-     */
-    static #splitCopperPrimitives(polygons, fills, tracks, arcs) {
-        const copperFills = fills.filter((fill) =>
-            PcbSvgRenderer.#isCopperLayerId(fill.layerId)
-        )
-        const copperTracks = tracks.filter((track) =>
-            PcbSvgRenderer.#isCopperLayerId(track.layerId)
-        )
-        const copperArcs = arcs.filter((arc) =>
-            PcbSvgRenderer.#isCopperLayerId(arc.layerId)
-        )
-        const surfaceTrackLayerCode =
-            PcbSvgRenderer.#resolveSurfaceLayerCode(copperTracks)
-        const surfaceFillLayerCode =
-            PcbSvgRenderer.#resolveSurfaceLayerCode(copperFills)
-        const surfaceArcLayerCode =
-            PcbSvgRenderer.#resolveSurfaceLayerCode(copperArcs)
-
-        return {
-            surface: {
-                polygons: polygons.filter((polygon) =>
-                    PcbSvgRenderer.#isSurfacePolygon(polygon)
-                ),
-                fills: copperFills.filter(
-                    (fill) => fill.layerCode === surfaceFillLayerCode
-                ),
-                tracks: copperTracks.filter(
-                    (track) => track.layerCode === surfaceTrackLayerCode
-                ),
-                arcs: copperArcs.filter(
-                    (arc) => arc.layerCode === surfaceArcLayerCode
-                )
-            },
-            subsurface: {
-                polygons: polygons.filter(
-                    (polygon) => !PcbSvgRenderer.#isSurfacePolygon(polygon)
-                ),
-                fills: copperFills.filter(
-                    (fill) => fill.layerCode !== surfaceFillLayerCode
-                ),
-                tracks: copperTracks.filter(
-                    (track) => track.layerCode !== surfaceTrackLayerCode
-                ),
-                arcs: copperArcs.filter(
-                    (arc) => arc.layerCode !== surfaceArcLayerCode
-                )
-            }
-        }
-    }
-
-    /**
-     * Returns the default visible layer code from one primitive family.
-     * @param {{ layerCode?: number }[]} primitives
-     * @returns {number | null}
-     */
-    static #resolveSurfaceLayerCode(primitives) {
-        const layerCodes = primitives
-            .map((primitive) => primitive.layerCode)
-            .filter((layerCode) => Number.isFinite(layerCode))
-        return layerCodes.length ? Math.min(...layerCodes) : null
-    }
-
-    /**
-     * Returns true when one polygon belongs to the top-facing copper view.
-     * @param {{ layer?: string }} polygon
-     * @returns {boolean}
-     */
-    static #isSurfacePolygon(polygon) {
-        return (
-            String(polygon.layer || '')
-                .trim()
-                .toUpperCase() === 'TOP'
-        )
-    }
-
     /**
      * Returns true when one track intersects a component-local search box.
      * @param {{ x1: number, y1: number, x2: number, y2: number }} track
@@ -893,14 +895,4 @@ export class PcbSvgRenderer {
             minY > bounds.maxY
         )
     }
-
-    /**
-     * Returns true when one decoded primitive layer belongs to the copper
-     * stack instead of a mechanical or annotation layer.
-     * @param {number | undefined} layerId
-     * @returns {boolean}
-     */
-    static #isCopperLayerId(layerId) {
-        return Number.isInteger(layerId) && layerId >= 1 && layerId <= 32
-    }
 }