altium-toolkit 0.1.1 → 0.1.16

package/src/core/altium/SchematicComponentTextResolver.mjs

@@ -0,0 +1,355 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import { ParserUtils } from './ParserUtils.mjs'
+
+const { getDisplayText, getField } = ParserUtils
+
+/**
+ * Resolves visible schematic component labels from owner-linked and nearby text.
+ */
+export class SchematicComponentTextResolver {
+    /**
+     * Resolves a component designator from owner-linked text or nearby labels.
+     * @param {{ fields: Record<string, string | string[]> }[]} ownerTexts
+     * @param {{ x: number, y: number, text: string, name: string }[]} texts
+     * @param {{ x: number, y: number, libReference: string }} component
+     * @returns {string}
+     */
+    static resolveDesignator(ownerTexts, texts, component) {
+        const ownerDesignator = SchematicComponentTextResolver.#findRelatedText(
+            ownerTexts,
+            'Designator'
+        )
+        if (
+            SchematicComponentTextResolver.#isResolvedComponentText(
+                ownerDesignator
+            )
+        ) {
+            return ownerDesignator
+        }
+
+        return SchematicComponentTextResolver.#findNearbyComponentDesignator(
+            texts,
+            component
+        )
+    }
+
+    /**
+     * Resolves a component value from owner-linked text or nearby labels.
+     * @param {{ fields: Record<string, string | string[]> }[]} ownerTexts
+     * @param {{ x: number, y: number, text: string, name: string }[]} texts
+     * @param {{ x: number, y: number, libReference: string }} component
+     * @returns {string}
+     */
+    static resolveValue(ownerTexts, texts, component) {
+        const ownerValue =
+            SchematicComponentTextResolver.#findRelatedText(
+                ownerTexts,
+                'Comment'
+            ) ||
+            SchematicComponentTextResolver.#findRelatedText(ownerTexts, 'VALUE')
+        if (
+            SchematicComponentTextResolver.#isResolvedComponentText(ownerValue)
+        ) {
+            return ownerValue
+        }
+
+        return (
+            SchematicComponentTextResolver.#findNearbyComponentText(
+                texts,
+                component,
+                ['comment', 'value'],
+                '',
+                SchematicComponentTextResolver.#inferComponentValueHint(
+                    component.libReference
+                )
+            ) || ownerValue
+        )
+    }
+
+    /**
+     * Finds a related text value by name.
+     * @param {{ fields: Record<string, string | string[]> }[]} records
+     * @param {string} logicalName
+     * @returns {string}
+     */
+    static #findRelatedText(records, logicalName) {
+        const match = records.find(
+            (record) =>
+                getField(record.fields, 'Name').toLowerCase() ===
+                logicalName.toLowerCase()
+        )
+        return match ? getDisplayText(match.fields) : ''
+    }
+
+    /**
+     * Finds the closest nearby designator text for one component.
+     * @param {{ x: number, y: number, text: string, name: string }[]} texts
+     * @param {{ x: number, y: number, libReference: string }} component
+     * @returns {string}
+     */
+    static #findNearbyComponentDesignator(texts, component) {
+        const expectedPrefix =
+            SchematicComponentTextResolver.#inferComponentDesignatorPrefix(
+                component.libReference
+            )
+        const expectedValueHint =
+            SchematicComponentTextResolver.#inferComponentValueHint(
+                component.libReference
+            )
+        const candidates =
+            SchematicComponentTextResolver.#collectNearbyComponentTextCandidates(
+                texts,
+                component,
+                ['designator']
+            )
+        const scopedCandidates = expectedPrefix
+            ? candidates.filter((candidate) =>
+                  candidate.text
+                      .toUpperCase()
+                      .startsWith(expectedPrefix.toUpperCase())
+              )
+            : candidates
+        const usableCandidates = scopedCandidates.length
+            ? scopedCandidates
+            : candidates
+        const rankedCandidates = usableCandidates
+            .map((candidate) => ({
+                ...candidate,
+                score:
+                    candidate.distance +
+                    SchematicComponentTextResolver.#scoreAssociatedValueMismatch(
+                        texts,
+                        candidate,
+                        expectedValueHint
+                    )
+            }))
+            .sort((left, right) => left.score - right.score)
+
+        return rankedCandidates[0]?.text || ''
+    }
+
+    /**
+     * Finds the closest nearby visible text for one component.
+     * @param {{ x: number, y: number, text: string, name: string }[]} texts
+     * @param {{ x: number, y: number }} component
+     * @param {string[]} logicalNames
+     * @param {string} expectedPrefix
+     * @param {string} expectedTextHint
+     * @returns {string}
+     */
+    static #findNearbyComponentText(
+        texts,
+        component,
+        logicalNames,
+        expectedPrefix = '',
+        expectedTextHint = ''
+    ) {
+        const candidates =
+            SchematicComponentTextResolver.#collectNearbyComponentTextCandidates(
+                texts,
+                component,
+                logicalNames
+            )
+        const prefixedCandidates = expectedPrefix
+            ? candidates.filter((candidate) =>
+                  candidate.text
+                      .toUpperCase()
+                      .startsWith(expectedPrefix.toUpperCase())
+              )
+            : candidates
+        const scopedCandidates = prefixedCandidates.length
+            ? prefixedCandidates
+            : candidates
+        const hintedCandidates = expectedTextHint
+            ? scopedCandidates.filter((candidate) =>
+                  SchematicComponentTextResolver.#normalizeTextMatch(
+                      candidate.text
+                  ).includes(
+                      SchematicComponentTextResolver.#normalizeTextMatch(
+                          expectedTextHint
+                      )
+                  )
+              )
+            : scopedCandidates
+        const usableCandidates = hintedCandidates.length
+            ? hintedCandidates
+            : scopedCandidates
+
+        return usableCandidates.sort(
+            (left, right) => left.distance - right.distance
+        )[0]?.text
+    }
+
+    /**
+     * Collects nearby visible schematic text candidates around one component.
+     * @param {{ x: number, y: number, text: string, name: string }[]} texts
+     * @param {{ x: number, y: number }} component
+     * @param {string[]} logicalNames
+     * @returns {{ x: number, y: number, text: string, distance: number }[]}
+     */
+    static #collectNearbyComponentTextCandidates(
+        texts,
+        component,
+        logicalNames
+    ) {
+        const allowedNames = new Set(
+            logicalNames.map((name) => name.toLowerCase())
+        )
+
+        return texts
+            .filter((text) =>
+                allowedNames.has(
+                    String(text.name || '')
+                        .trim()
+                        .toLowerCase()
+                )
+            )
+            .map((text) => ({
+                x: text.x,
+                y: text.y,
+                text: text.text,
+                distance:
+                    Math.abs(text.x - component.x) +
+                    Math.abs(text.y - component.y)
+            }))
+            .filter(
+                (text) =>
+                    Math.abs(text.x - component.x) <= 80 &&
+                    Math.abs(text.y - component.y) <= 80
+            )
+    }
+
+    /**
+     * Penalizes a designator candidate when nearby value text mismatches.
+     * @param {{ x: number, y: number, text: string, name: string }[]} texts
+     * @param {{ x: number, y: number }} candidate
+     * @param {string} expectedValueHint
+     * @returns {number}
+     */
+    static #scoreAssociatedValueMismatch(texts, candidate, expectedValueHint) {
+        if (!expectedValueHint) {
+            return 0
+        }
+
+        const associatedValue =
+            SchematicComponentTextResolver.#findNearbyComponentText(
+                texts,
+                candidate,
+                ['comment', 'value']
+            )
+        if (!associatedValue) {
+            return 0
+        }
+
+        return SchematicComponentTextResolver.#normalizeTextMatch(
+            associatedValue
+        ).includes(
+            SchematicComponentTextResolver.#normalizeTextMatch(
+                expectedValueHint
+            )
+        )
+            ? -30
+            : 30
+    }
+
+    /**
+     * Returns true when owner-linked text is usable as a display value.
+     * @param {string} value
+     * @returns {boolean}
+     */
+    static #isResolvedComponentText(value) {
+        const normalized = String(value || '').trim()
+
+        return Boolean(
+            normalized && normalized !== '*' && !normalized.startsWith('=')
+        )
+    }
+
+    /**
+     * Infers the visible designator prefix from a library reference.
+     * @param {string} libReference
+     * @returns {string}
+     */
+    static #inferComponentDesignatorPrefix(libReference) {
+        const normalized = String(libReference || '')
+            .trim()
+            .toUpperCase()
+
+        if (normalized.startsWith('RES/')) return 'R'
+        if (normalized.startsWith('CAP/')) return 'C'
+        if (normalized.startsWith('DIODE/')) return 'D'
+        if (normalized.startsWith('CON/')) return 'J'
+        if (normalized.startsWith('IC/')) return 'U'
+
+        return ''
+    }
+
+    /**
+     * Infers the visible value label from a library reference.
+     * @param {string} libReference
+     * @returns {string}
+     */
+    static #inferComponentValueHint(libReference) {
+        const segments = String(libReference || '')
+            .split('/')
+            .map((segment) => segment.trim())
+            .filter(Boolean)
+
+        for (let index = segments.length - 1; index >= 0; index -= 1) {
+            const segment = segments[index]
+
+            if (
+                SchematicComponentTextResolver.#isPackageLikeComponentSegment(
+                    segment
+                ) ||
+                /\s/.test(segment)
+            ) {
+                continue
+            }
+
+            if (
+                /^(?:\d+(?:\.\d+)?(?:R|K|M|UF|NF|PF)|1N[A-Z0-9-]+)$/i.test(
+                    segment
+                )
+            ) {
+                return segment
+            }
+
+            if (
+                /[A-Z]/i.test(segment) &&
+                /\d/.test(segment) &&
+                segment.length >= 6
+            ) {
+                return segment
+            }
+        }
+
+        return ''
+    }
+
+    /**
+     * Returns true when a library segment is package/rating-like.
+     * @param {string} segment
+     * @returns {boolean}
+     */
+    static #isPackageLikeComponentSegment(segment) {
+        return /^(?:CE|\d{4}|SC\d+|SOD-\d+|\d+(?:\.\d+)?V|\d+(?:\.\d+)?[%％])$/i.test(
+            String(segment || '').trim()
+        )
+    }
+
+    /**
+     * Normalizes a text fragment for proximity matching.
+     * @param {string} value
+     * @returns {string}
+     */
+    static #normalizeTextMatch(value) {
+        return String(value || '')
+            .toUpperCase()
+            .replaceAll(/\s+/g, '')
+            .replaceAll('％', '%')
+    }
+}

package/src/parser.mjs

@@ -10,12 +10,25 @@ export { AltiumParser } from './core/altium/AltiumParser.mjs'
 export { AltiumLayoutParser } from './core/altium/AltiumLayoutParser.mjs'
 export { AsciiRecordParser } from './core/altium/AsciiRecordParser.mjs'
 export { ParserUtils } from './core/altium/ParserUtils.mjs'
+export { NormalizedModelSchema } from './core/altium/NormalizedModelSchema.mjs'
 export { PcbBinaryPrimitiveParser } from './core/altium/PcbBinaryPrimitiveParser.mjs'
+export { PcbBoardRegionSemanticsParser } from './core/altium/PcbBoardRegionSemanticsParser.mjs'
+export { PcbComponentPrimitiveIndexer } from './core/altium/PcbComponentPrimitiveIndexer.mjs'
+export { PcbEmbeddedFontExtractor } from './core/altium/PcbEmbeddedFontExtractor.mjs'
 export { PcbEmbeddedModelExtractor } from './core/altium/PcbEmbeddedModelExtractor.mjs'
+export { PcbFontMetricsParser } from './core/altium/PcbFontMetricsParser.mjs'
+export { PcbLayerIdCodec } from './core/altium/PcbLayerIdCodec.mjs'
+export { PcbLibModelParser } from './core/altium/PcbLibModelParser.mjs'
+export { PcbLibStreamExtractor } from './core/altium/PcbLibStreamExtractor.mjs'
 export { PcbModelParser } from './core/altium/PcbModelParser.mjs'
 export { PcbOutlineRasterizer } from './core/altium/PcbOutlineRasterizer.mjs'
 export { PcbOutlineRecovery } from './core/altium/PcbOutlineRecovery.mjs'
+export { PcbPadStackParser } from './core/altium/PcbPadStackParser.mjs'
+export { PcbRawRecordRegistry } from './core/altium/PcbRawRecordRegistry.mjs'
+export { PcbRuleParser } from './core/altium/PcbRuleParser.mjs'
 export { PcbStreamExtractor } from './core/altium/PcbStreamExtractor.mjs'
+export { PcbViaStackParser } from './core/altium/PcbViaStackParser.mjs'
 export { PrintableTextDecoder } from './core/altium/PrintableTextDecoder.mjs'
+export { PrjPcbModelParser } from './core/altium/PrjPcbModelParser.mjs'
 export { SchematicMultipartOwnerMatcher } from './core/altium/SchematicMultipartOwnerMatcher.mjs'
 export { SchematicStandaloneCalloutNormalizer } from './core/altium/SchematicStandaloneCalloutNormalizer.mjs'

package/src/renderers.mjs

@@ -6,6 +6,11 @@ export { BomTableRenderer } from './ui/BomTableRenderer.mjs'
 export { PcbArcUtils } from './ui/PcbArcUtils.mjs'
 export { PcbEdgeFacingGlyphNormalizer } from './ui/PcbEdgeFacingGlyphNormalizer.mjs'
 export { PcbFootprintPrimitiveSelector } from './ui/PcbFootprintPrimitiveSelector.mjs'
+export {
+    PcbSideResolvedRenderModel,
+    isCopperPrimitive,
+    preparePcbSideResolvedRenderModel
+} from './ui/PcbSideResolvedRenderModel.mjs'
 export { PcbSvgRenderer } from './ui/PcbSvgRenderer.mjs'
 export { SchematicColorResolver } from './ui/SchematicColorResolver.mjs'
 export { SchematicContentLayout } from './ui/SchematicContentLayout.mjs'

package/src/styles/altium-renderers.css

@@ -186,7 +186,8 @@
 }
 
 .pcb-polygon,
-.pcb-fill {
+.pcb-fill,
+.pcb-region {
     stroke: none;
 }
 
@@ -207,11 +208,13 @@
     fill: var(--pcb-subsurface-copper-fill);
 }
 
-.pcb-copper--surface .pcb-fill {
+.pcb-copper--surface .pcb-fill,
+.pcb-copper--surface .pcb-region {
     fill: var(--pcb-surface-fill);
 }
 
-.pcb-copper--subsurface .pcb-fill {
+.pcb-copper--subsurface .pcb-fill,
+.pcb-copper--subsurface .pcb-region {
     fill: var(--pcb-subsurface-fill);
 }
 
@@ -244,7 +247,8 @@
     fill: var(--pcb-copper-solid-fill);
 }
 
-.pcb-footprint-fill {
+.pcb-footprint-fill,
+.pcb-footprint-region {
     fill: var(--pcb-footprint-fill);
 }
 
@@ -263,11 +267,12 @@
     fill: var(--pcb-component-bottom-fill);
 }
 
-.pcb-component text {
+.pcb-text {
     font-size: 29px;
-    text-anchor: middle;
     fill: var(--pcb-component-text);
     font-weight: 700;
+    font-family: Arial, sans-serif;
+    pointer-events: none;
 }
 
 .bom-panel {

package/src/ui/PcbCopperPrimitiveSplitter.mjs

@@ -0,0 +1,113 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/**
+ * Splits PCB copper primitives into surface and subsurface render groups.
+ */
+export class PcbCopperPrimitiveSplitter {
+    /**
+     * 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
+     * @param {{ points?: object[], holes?: object[][], layerCode?: number, layerId?: number }[]} regions
+     * @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 }[], regions: { points?: object[], holes?: object[][], 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 }[], regions: { points?: object[], holes?: object[][], layerCode?: number, layerId?: number }[] } }}
+     */
+    static split(polygons, fills, tracks, arcs, regions) {
+        const copperFills = fills.filter((fill) =>
+            PcbCopperPrimitiveSplitter.#isCopperLayerId(fill.layerId)
+        )
+        const copperTracks = tracks.filter((track) =>
+            PcbCopperPrimitiveSplitter.#isCopperLayerId(track.layerId)
+        )
+        const copperArcs = arcs.filter((arc) =>
+            PcbCopperPrimitiveSplitter.#isCopperLayerId(arc.layerId)
+        )
+        const copperRegions = regions.filter((region) =>
+            PcbCopperPrimitiveSplitter.#isCopperLayerId(region.layerId)
+        )
+        const surfaceTrackLayerCode =
+            PcbCopperPrimitiveSplitter.#resolveSurfaceLayerCode(copperTracks)
+        const surfaceFillLayerCode =
+            PcbCopperPrimitiveSplitter.#resolveSurfaceLayerCode(copperFills)
+        const surfaceArcLayerCode =
+            PcbCopperPrimitiveSplitter.#resolveSurfaceLayerCode(copperArcs)
+        const surfaceRegionLayerCode =
+            PcbCopperPrimitiveSplitter.#resolveSurfaceLayerCode(copperRegions)
+
+        return {
+            surface: {
+                polygons: polygons.filter((polygon) =>
+                    PcbCopperPrimitiveSplitter.#isSurfacePolygon(polygon)
+                ),
+                fills: copperFills.filter(
+                    (fill) => fill.layerCode === surfaceFillLayerCode
+                ),
+                tracks: copperTracks.filter(
+                    (track) => track.layerCode === surfaceTrackLayerCode
+                ),
+                arcs: copperArcs.filter(
+                    (arc) => arc.layerCode === surfaceArcLayerCode
+                ),
+                regions: copperRegions.filter(
+                    (region) => region.layerCode === surfaceRegionLayerCode
+                )
+            },
+            subsurface: {
+                polygons: polygons.filter(
+                    (polygon) =>
+                        !PcbCopperPrimitiveSplitter.#isSurfacePolygon(polygon)
+                ),
+                fills: copperFills.filter(
+                    (fill) => fill.layerCode !== surfaceFillLayerCode
+                ),
+                tracks: copperTracks.filter(
+                    (track) => track.layerCode !== surfaceTrackLayerCode
+                ),
+                arcs: copperArcs.filter(
+                    (arc) => arc.layerCode !== surfaceArcLayerCode
+                ),
+                regions: copperRegions.filter(
+                    (region) => region.layerCode !== surfaceRegionLayerCode
+                )
+            }
+        }
+    }
+
+    /**
+     * 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 decoded primitive layer belongs to copper.
+     * @param {number | undefined} layerId
+     * @returns {boolean}
+     */
+    static #isCopperLayerId(layerId) {
+        return Number.isInteger(layerId) && layerId >= 1 && layerId <= 32
+    }
+}

package/src/ui/PcbEdgeFacingGlyphNormalizer.mjs

@@ -19,10 +19,10 @@ export class PcbEdgeFacingGlyphNormalizer {
      * Normalizes repeated edge-facing documentation glyphs so their opening
      * stays on the board edge even when the authored primitive cluster is
      * mirrored inward.
-     * @param {{ 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 }[] }} footprintPrimitives
+     * @param {{ 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 }[], regions?: { points?: object[], holes?: object[][], layerCode?: number, layerId?: number }[] }} footprintPrimitives
      * @param {{ minX: number, minY: number, widthMil: number, heightMil: number }} outline
      * @param {{ preferMarkers?: boolean }} [options]
-     * @returns {{ 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 }[] }}
+     * @returns {{ 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 }[], regions: { points?: object[], holes?: object[][], layerCode?: number, layerId?: number }[] }}
      */
     static normalize(footprintPrimitives, outline, options = {}) {
         const normalizedTracks = (footprintPrimitives?.tracks || []).map(
@@ -61,16 +61,17 @@ export class PcbEdgeFacingGlyphNormalizer {
         return {
             fills: footprintPrimitives?.fills || [],
             tracks: normalizedTracks,
-            arcs: normalizedArcs
+            arcs: normalizedArcs,
+            regions: footprintPrimitives?.regions || []
         }
     }
 
     /**
      * Normalizes glyphs using only the nearest board edge so 3D silkscreen
      * detail does not overreact to nearby circular markers on other features.
-     * @param {{ 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 }[] }} footprintPrimitives
+     * @param {{ 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 }[], regions?: { points?: object[], holes?: object[][], layerCode?: number, layerId?: number }[] }} footprintPrimitives
      * @param {{ minX: number, minY: number, widthMil: number, heightMil: number }} outline
-     * @returns {{ 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 }[] }}
+     * @returns {{ 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 }[], regions: { points?: object[], holes?: object[][], layerCode?: number, layerId?: number }[] }}
      */
     static normalizeForBoardEdge(footprintPrimitives, outline) {
         return PcbEdgeFacingGlyphNormalizer.normalize(