circuitjson-toolkit 1.0.17 → 1.1.0

package/src/core/CircuitJsonPcbHolePrimitiveModel.mjs

@@ -14,7 +14,16 @@ export class CircuitJsonPcbHolePrimitiveModel {
     static build(element, center) {
         const shape = CircuitJsonPcbHolePrimitiveModel.#outerShape(element)
         const points = CircuitJsonPcbHolePrimitiveModel.#outerPoints(element)
-        const size = CircuitJsonPcbHolePrimitiveModel.#outerSize(element, shape)
+        const rotation =
+            CircuitJsonPcbHolePrimitiveModel.#outerRotation(element)
+        const holeRotation =
+            CircuitJsonPcbHolePrimitiveModel.#holeRotation(element)
+        const size =
+            CircuitJsonPcbHolePrimitiveModel.#polygonOuterSize(
+                points,
+                center,
+                rotation
+            ) || CircuitJsonPcbHolePrimitiveModel.#outerSize(element, shape)
         const hole = CircuitJsonPcbHolePrimitiveModel.#holeSize(
             element,
             shape,
@@ -37,10 +46,8 @@ export class CircuitJsonPcbHolePrimitiveModel {
             holeDiameter: hole.diameter,
             holeWidth: hole.width,
             holeHeight: hole.height,
-            rotation: CircuitJsonUnits.angle(
-                element.ccw_rotation ?? element.rotation,
-                0
-            ),
+            holeRotation,
+            rotation,
             points,
             bounds
         }
@@ -53,10 +60,10 @@ export class CircuitJsonPcbHolePrimitiveModel {
      */
     static #outerShape(element) {
         const raw = CircuitJsonPcbHolePrimitiveModel.#shapeText(
-            element.shape || element.hole_shape
+            element.pad_shape || element.shape || element.hole_shape
         )
         if (raw.includes('polygon')) return 'polygon'
-        if (raw.includes('rect')) return 'rect'
+        if (raw.includes('rect') || raw.includes('square')) return 'rect'
         if (
             raw.includes('pill') ||
             raw.includes('slot') ||
@@ -73,16 +80,40 @@ export class CircuitJsonPcbHolePrimitiveModel {
      * @returns {{ width: number, height: number }}
      */
     static #outerSize(element, shape) {
+        if (element.type === 'pcb_hole') {
+            const holeDiameter = CircuitJsonUnits.length(
+                element.hole_diameter,
+                0.6
+            )
+            const holeWidth = CircuitJsonUnits.length(
+                element.hole_width,
+                holeDiameter
+            )
+            const holeHeight = CircuitJsonUnits.length(
+                element.hole_height,
+                shape === 'circle' ? holeWidth : holeDiameter
+            )
+            return {
+                width: holeWidth,
+                height: shape === 'circle' ? holeWidth : holeHeight
+            }
+        }
         const diameter = CircuitJsonUnits.length(
             element.diameter ?? element.outer_diameter,
             0.6
         )
         const width = CircuitJsonUnits.length(
-            element.rect_pad_width ?? element.pad_width ?? element.width,
+            element.outer_width ??
+                element.rect_pad_width ??
+                element.pad_width ??
+                element.width,
             diameter
         )
         const height = CircuitJsonUnits.length(
-            element.rect_pad_height ?? element.pad_height ?? element.height,
+            element.outer_height ??
+                element.rect_pad_height ??
+                element.pad_height ??
+                element.height,
             shape === 'circle' ? width : diameter
         )
 
@@ -103,6 +134,41 @@ export class CircuitJsonPcbHolePrimitiveModel {
             .filter(Boolean)
     }
 
+    /**
+     * Resolves polygon extents in the pad's rotation-local coordinate system.
+     * @param {{ x: number, y: number }[]} points Polygon points.
+     * @param {{ x: number, y: number }} center Pad center.
+     * @param {number} rotation Rotation in degrees.
+     * @returns {{ width: number, height: number } | null} Local polygon size.
+     */
+    static #polygonOuterSize(points, center, rotation) {
+        if (points.length < 3) return null
+        const centerX = Number(center?.x)
+        const centerY = Number(center?.y)
+        if (!Number.isFinite(centerX) || !Number.isFinite(centerY)) return null
+
+        const angle = (-Number(rotation || 0) * Math.PI) / 180
+        const cosine = Math.cos(angle)
+        const sine = Math.sin(angle)
+        let minX = Infinity
+        let minY = Infinity
+        let maxX = -Infinity
+        let maxY = -Infinity
+        for (const point of points) {
+            const deltaX = point.x - centerX
+            const deltaY = point.y - centerY
+            const x = deltaX * cosine - deltaY * sine
+            const y = deltaX * sine + deltaY * cosine
+            minX = Math.min(minX, x)
+            minY = Math.min(minY, y)
+            maxX = Math.max(maxX, x)
+            maxY = Math.max(maxY, y)
+        }
+        const width = maxX - minX
+        const height = maxY - minY
+        return width > 0 && height > 0 ? { width, height } : null
+    }
+
     /**
      * Resolves the drilled opening size.
      * @param {object} element Drilled PCB element.
@@ -148,7 +214,11 @@ export class CircuitJsonPcbHolePrimitiveModel {
             element.hole_shape || element.shape
         )
         if (raw === 'round') return 'circle'
-        if (raw.includes('rect') && !raw.includes('rect_pad')) return 'rect'
+        if (
+            raw.includes('square') ||
+            (raw.includes('rect') && !raw.includes('rect_pad'))
+        )
+            return 'rect'
         if (
             raw.includes('pill') ||
             raw.includes('slot') ||
@@ -159,6 +229,34 @@ export class CircuitJsonPcbHolePrimitiveModel {
         return element.type === 'pcb_hole' ? outerShape : 'circle'
     }
 
+    /**
+     * Resolves the board-space outer pad rotation independently from its drill.
+     * @param {object} element Drilled PCB element.
+     * @returns {number}
+     */
+    static #outerRotation(element) {
+        return CircuitJsonUnits.angle(
+            element.rect_ccw_rotation ??
+                element.ccw_rotation ??
+                element.rotation,
+            0
+        )
+    }
+
+    /**
+     * Resolves the board-space drill rotation independently from its outer pad.
+     * @param {object} element Drilled PCB element.
+     * @returns {number}
+     */
+    static #holeRotation(element) {
+        return CircuitJsonUnits.angle(
+            element.hole_ccw_rotation ??
+                element.ccw_rotation ??
+                element.rotation,
+            0
+        )
+    }
+
     /**
      * Normalizes a shape string.
      * @param {unknown} value Shape value.

package/src/core/CircuitJsonPcbPadPrimitiveModel.mjs

@@ -10,7 +10,7 @@ export class CircuitJsonPcbPadPrimitiveModel {
      * @returns {string}
      */
     static shape(element) {
-        return String(element.shape || 'rect')
+        return String(element.legacy_shape || element.shape || 'rect')
             .trim()
             .toLowerCase()
     }

package/src/core/CircuitJsonPcbPrimitiveArtwork.mjs

@@ -5,12 +5,9 @@ import { CircuitJsonPcbPrimitiveFields } from './CircuitJsonPcbPrimitiveFields.m
 import { CircuitJsonPcbTraceLengthModel } from './CircuitJsonPcbTraceLengthModel.mjs'
 import { CircuitJsonPcbDrawingStyle } from './CircuitJsonPcbDrawingStyle.mjs'
 
-/**
- * Builds derived and documentation PCB primitives from CircuitJSON rows.
- */
+/** Builds derived and documentation PCB primitives from CircuitJSON rows. */
 export class CircuitJsonPcbPrimitiveArtwork {
-    /**
-     * Builds supplemental primitive rows.
+    /** Builds supplemental primitive rows.
      * @param {{ elementsByType: Map<string, object[]> }} index Element index.
      * @param {Map<string, object>} componentsByPcbId Component lookup.
      * @returns {object[]}
@@ -40,8 +37,7 @@ export class CircuitJsonPcbPrimitiveArtwork {
         ].filter(Boolean)
     }
 
-    /**
-     * Builds board detail primitives.
+    /** Builds board detail primitives.
      * @param {{ elementsByType: Map<string, object[]> }} index Element index.
      * @returns {object[]}
      */
@@ -69,8 +65,7 @@ export class CircuitJsonPcbPrimitiveArtwork {
             .filter(Boolean)
     }
 
-    /**
-     * Builds total routed trace length labels.
+    /** Builds total routed trace length labels.
      * @param {object[]} primitives Primitive rows.
      * @param {{ elementsByType: Map<string, object[]> }} [index] Element index.
      * @returns {object[]}
@@ -79,8 +74,7 @@ export class CircuitJsonPcbPrimitiveArtwork {
         return CircuitJsonPcbTraceLengthModel.build(primitives, index)
     }
 
-    /**
-     * Builds generated copper clearance diagnostics.
+    /** Builds generated copper clearance diagnostics.
      * @param {{ elementsByType: Map<string, object[]> }} index Element index.
      * @param {object[]} primitives Primitive rows.
      * @returns {object[]}
@@ -448,7 +442,9 @@ export class CircuitJsonPcbPrimitiveArtwork {
             id: CircuitJsonPcbPrimitiveFields.derivedId(element),
             kind,
             shape: String(
-                element.shape || (points.length ? 'polygon' : 'rect')
+                element.legacy_shape ||
+                    element.shape ||
+                    (points.length ? 'polygon' : 'rect')
             ),
             x: center?.x ?? bounds.minX + bounds.width / 2,
             y: center?.y ?? bounds.minY + bounds.height / 2,
@@ -525,21 +521,25 @@ export class CircuitJsonPcbPrimitiveArtwork {
      * @returns {object | null}
      */
     static #linePrimitive(element, kind, index = 0) {
-        const start = CircuitJsonPcbPrimitiveFields.point({
-            x: element.x1 ?? element.start?.x,
-            y: element.y1 ?? element.start?.y
-        })
-        const end = CircuitJsonPcbPrimitiveFields.point({
-            x: element.x2 ?? element.end?.x,
-            y: element.y2 ?? element.end?.y
-        })
+        const start = CircuitJsonPcbPrimitiveFields.point(
+            element.from || {
+                x: element.x1 ?? element.start?.x,
+                y: element.y1 ?? element.start?.y
+            }
+        )
+        const end = CircuitJsonPcbPrimitiveFields.point(
+            element.to || {
+                x: element.x2 ?? element.end?.x,
+                y: element.y2 ?? element.end?.y
+            }
+        )
         if (!start || !end) return null
         const width = CircuitJsonUnits.length(
             element.width ??
                 element.stroke_width ??
                 element.strokeWidth ??
                 element.line_width,
-            0.08
+            kind === 'courtyard' ? 0.05 : 0.08
         )
         return CircuitJsonPcbPrimitiveArtwork.#primitive({
             id: CircuitJsonIndexer.getElementId(element) + ':' + index,
@@ -562,17 +562,18 @@ export class CircuitJsonPcbPrimitiveArtwork {
         })
     }
 
-    /**
-     * Returns true when an element should render as open line segments.
-     * @param {object} element Element row.
-     * @returns {boolean}
-     */
+    /** Returns whether an element renders as open line segments. */
     static #isOpenPath(element) {
         const type = String(element.type || '')
-        const shape = String(element.shape || '').toLowerCase()
+        const shape = String(
+            element.legacy_shape || element.shape || ''
+        ).toLowerCase()
         return (
             type.endsWith('_line') ||
             type.endsWith('_path') ||
+            (type === 'pcb_courtyard_outline' &&
+                CircuitJsonPcbPrimitiveFields.linePoints(element).length ===
+                    2) ||
             shape === 'line' ||
             shape === 'path'
         )
@@ -651,7 +652,9 @@ export class CircuitJsonPcbPrimitiveArtwork {
             id: CircuitJsonIndexer.getElementId(element),
             kind,
             shape: String(
-                element.shape || (points.length ? 'polygon' : 'rect')
+                element.legacy_shape ||
+                    element.shape ||
+                    (points.length ? 'polygon' : 'rect')
             ),
             x: center?.x ?? bounds.minX + bounds.width / 2,
             y: center?.y ?? bounds.minY + bounds.height / 2,
@@ -703,10 +706,15 @@ export class CircuitJsonPcbPrimitiveArtwork {
      */
     static #isBoardDetailPath(element) {
         const type = String(element.type || '')
-        const shape = String(element.shape || '').toLowerCase()
+        const shape = String(
+            element.legacy_shape || element.shape || ''
+        ).toLowerCase()
         return (
             type.endsWith('_line') ||
             type.endsWith('_path') ||
+            (type === 'pcb_courtyard_outline' &&
+                CircuitJsonPcbPrimitiveFields.linePoints(element).length ===
+                    2) ||
             shape === 'line' ||
             shape === 'path'
         )
@@ -752,7 +760,7 @@ export class CircuitJsonPcbPrimitiveArtwork {
                 element.stroke_width ??
                 element.strokeWidth ??
                 element.line_width,
-            0.08
+            kind === 'courtyard' ? 0.05 : 0.08
         )
 
         return {
@@ -903,9 +911,11 @@ export class CircuitJsonPcbPrimitiveArtwork {
         if (kind === 'cutout') return 'cutouts'
         if (kind === 'keepout') return 'keepouts'
         if (kind === 'courtyard') {
-            return CircuitJsonPcbPrimitiveFields.layer(
-                element.layer || 'top_courtyard'
-            )
+            const side =
+                CircuitJsonPcbPrimitiveFields.side(
+                    CircuitJsonPcbPrimitiveFields.layer(element.layer)
+                ) || 'top'
+            return side + '_courtyard'
         }
         return CircuitJsonPcbPrimitiveFields.layer(element.layer || 'board')
     }
@@ -981,11 +991,7 @@ export class CircuitJsonPcbPrimitiveArtwork {
         }
     }
 
-    /**
-     * Rounds a numeric value for deterministic model rows.
-     * @param {number} value Numeric value.
-     * @returns {number}
-     */
+    /** Returns a deterministic rounded numeric value. */
     static #rounded(value) {
         return Number(Number(value).toFixed(6))
     }

package/src/core/CircuitJsonPcbPrimitiveBuilder.mjs

@@ -22,10 +22,22 @@ export class CircuitJsonPcbPrimitiveBuilder {
      * @returns {{ bounds: object, layers: object[], virtualLayers: object[], components: object[], nets: object[], primitives: object[], anchors: object[], diagnostics: object[], airwires: object[], traceLengths: object[], groups: object[], anchorOffsets: object[] }}
      */
     static build(documentModel) {
+        return CircuitJsonPcbPrimitiveBuilder.buildComplete(
+            documentModel,
+            CircuitJsonPcbPrimitiveBuilder.buildInteraction(documentModel)
+        )
+    }
+
+    /**
+     * Builds only geometry and selection data required for interaction. It
+     * intentionally omits clearance diagnostics, airwires, and report layers.
+     * @param {object | object[]} documentModel Parsed document model.
+     * @returns {{ bounds: object, layers: object[], virtualLayers: object[], components: object[], nets: object[], primitives: object[], anchors: object[], diagnostics: object[], airwires: object[], traceLengths: object[], groups: object[], anchorOffsets: object[] }} Interaction primitive model.
+     */
+    static buildInteraction(documentModel) {
         const elements = CircuitJsonPcbPrimitiveBuilder.elements(documentModel)
         const index = CircuitJsonPcbPrimitiveIndex.build(elements)
         const boards = CircuitJsonPcbPrimitiveBuilder.#all(index, 'pcb_board')
-        const board = boards[0] || null
         const components =
             CircuitJsonPcbPrimitiveBuilder.#componentLookups(index)
         const areaModel = CircuitJsonPcbZonePrimitiveBuilder.build(
@@ -67,36 +79,65 @@ export class CircuitJsonPcbPrimitiveBuilder {
             CircuitJsonPcbPrimitiveFields.mergedBoardBounds(boards) ||
             CircuitJsonPcbPrimitiveGeometry.mergedPrimitiveBounds(primitives) ||
             CircuitJsonPcbPrimitiveGeometry.bounds(0, 0, 1, 1)
+
+        return {
+            bounds,
+            layers: CircuitJsonPcbPrimitiveFields.layers(boards, primitives),
+            virtualLayers: [],
+            components: components.rows,
+            nets: CircuitJsonPcbNetMetadata.nets(primitives, index),
+            primitives,
+            anchors: primitives.flatMap((primitive) =>
+                primitive.anchors.map((anchor) => ({ ...anchor, primitive }))
+            ),
+            diagnostics: [],
+            airwires: [],
+            traceLengths: [],
+            groups: groupModel.groups,
+            anchorOffsets: groupModel.anchorOffsets
+        }
+    }
+
+    /**
+     * Adds legacy report and overlay data to an interaction primitive model
+     * without rebuilding its renderer-neutral geometry.
+     * @param {object | object[]} documentModel Parsed document model.
+     * @param {Record<string, any>} interactionModel Prepared interaction model.
+     * @returns {{ bounds: object, layers: object[], virtualLayers: object[], components: object[], nets: object[], primitives: object[], anchors: object[], diagnostics: object[], airwires: object[], traceLengths: object[], groups: object[], anchorOffsets: object[] }} Complete primitive model.
+     */
+    static buildComplete(documentModel, interactionModel) {
+        const elements = CircuitJsonPcbPrimitiveBuilder.elements(documentModel)
+        const index = CircuitJsonPcbPrimitiveIndex.build(elements)
+        const components =
+            CircuitJsonPcbPrimitiveBuilder.#componentLookups(index)
+        const areaDiagnostics = CircuitJsonPcbZonePrimitiveBuilder.build(
+            index,
+            components.byPcbId
+        ).diagnostics
         const overlays = CircuitJsonPcbPrimitiveOverlays.build(
             index,
             components.byPcbId,
-            primitives,
-            bounds,
-            groupModel,
+            interactionModel.primitives,
+            interactionModel.bounds,
+            {
+                groups: interactionModel.groups,
+                anchorOffsets: interactionModel.anchorOffsets
+            },
             [
                 ...CircuitJsonPcbPrimitiveBuilder.#generatedDiagnostics(index),
-                ...areaModel.diagnostics
+                ...areaDiagnostics
             ]
         )
 
         return {
-            bounds,
-            layers: CircuitJsonPcbPrimitiveFields.layers(board),
+            ...interactionModel,
             virtualLayers: overlays.virtualLayers,
-            components: components.rows,
-            nets: CircuitJsonPcbNetMetadata.nets(primitives, index),
-            primitives,
-            anchors: primitives.flatMap((primitive) =>
-                primitive.anchors.map((anchor) => ({ ...anchor, primitive }))
-            ),
             diagnostics: overlays.diagnostics,
             airwires: overlays.airwires,
             traceLengths: CircuitJsonPcbPrimitiveArtwork.traceLengths(
-                primitives,
+                interactionModel.primitives,
                 index
-            ),
-            groups: groupModel.groups,
-            anchorOffsets: groupModel.anchorOffsets
+            )
         }
     }
 
@@ -106,14 +147,74 @@ export class CircuitJsonPcbPrimitiveBuilder {
      * @returns {object[]}
      */
     static elements(documentModel) {
-        if (Array.isArray(documentModel)) return documentModel
-        if (Array.isArray(documentModel?.elements))
-            return documentModel.elements
-        if (Array.isArray(documentModel?.circuitJson))
-            return documentModel.circuitJson
+        if (Array.isArray(documentModel)) {
+            return CircuitJsonPcbPrimitiveBuilder.#elementSlots(documentModel)
+        }
+        if (!documentModel || typeof documentModel !== 'object') return []
+        let descriptors
+        try {
+            descriptors = Object.getOwnPropertyDescriptors(documentModel)
+        } catch {
+            return []
+        }
+        for (const field of ['elements', 'circuitJson']) {
+            const descriptor = descriptors[field]
+            if (
+                descriptor &&
+                Object.hasOwn(descriptor, 'value') &&
+                Array.isArray(descriptor.value)
+            ) {
+                return CircuitJsonPcbPrimitiveBuilder.#elementSlots(
+                    descriptor.value
+                )
+            }
+        }
         return []
     }
 
+    /**
+     * Returns an exact dense element array, dropping only legacy root metadata.
+     * @param {object[]} model Element-array or legacy hybrid-array candidate.
+     * @returns {object[]} Original exact array or intrinsic dense slot copy.
+     */
+    static #elementSlots(model) {
+        let prototype
+        let descriptors
+        try {
+            prototype = Object.getPrototypeOf(model)
+            descriptors = Object.getOwnPropertyDescriptors(model)
+        } catch {
+            return model
+        }
+        const lengthDescriptor = descriptors.length
+        const length =
+            lengthDescriptor && Object.hasOwn(lengthDescriptor, 'value')
+                ? lengthDescriptor.value
+                : null
+        if (
+            prototype !== Array.prototype ||
+            !Number.isSafeInteger(length) ||
+            length < 0
+        ) {
+            return model
+        }
+        const slots = new Array(length)
+        for (let index = 0; index < length; index += 1) {
+            const descriptor = descriptors[String(index)]
+            if (
+                !descriptor ||
+                !Object.hasOwn(descriptor, 'value') ||
+                descriptor.enumerable !== true
+            ) {
+                return model
+            }
+            slots[index] = descriptor.value
+        }
+        return Reflect.ownKeys(descriptors).length === length + 1
+            ? model
+            : slots
+    }
+
     /**
      * Returns indexed element rows by type.
      * @param {{ elementsByType: Map<string, object[]> }} index Element index.
@@ -678,7 +779,10 @@ export class CircuitJsonPcbPrimitiveBuilder {
                         element.isKnockout === true,
                     rotation: CircuitJsonUnits.angle(element.ccw_rotation, 0),
                     bounds,
-                    layer: CircuitJsonPcbPrimitiveFields.layer(element.layer),
+                    layer: CircuitJsonPcbPrimitiveBuilder.#detailLayer(
+                        element,
+                        CircuitJsonPcbPrimitiveBuilder.#textKind(element)
+                    ),
                     component,
                     netName: CircuitJsonPcbPrimitiveFields.netName(
                         element,
@@ -815,13 +919,27 @@ export class CircuitJsonPcbPrimitiveBuilder {
      * @returns {string}
      */
     static #lineLayer(element) {
-        if (element.layer) {
+        return CircuitJsonPcbPrimitiveBuilder.#detailLayer(
+            element,
+            CircuitJsonPcbPrimitiveBuilder.#lineKind(element)
+        )
+    }
+
+    /**
+     * Resolves a standards-side layer into its drawing-specific virtual layer.
+     * @param {object} element Source drawing element.
+     * @param {string} kind Primitive kind.
+     * @returns {string}
+     */
+    static #detailLayer(element, kind) {
+        if (kind === 'copper-text') {
             return CircuitJsonPcbPrimitiveFields.layer(element.layer)
         }
-        return CircuitJsonPcbPrimitiveBuilder.#lineKind(element) ===
-            'fabrication'
-            ? 'top_fabrication'
-            : 'top_silkscreen'
+        const side =
+            CircuitJsonPcbPrimitiveFields.side(
+                CircuitJsonPcbPrimitiveFields.layer(element.layer)
+            ) || 'top'
+        return side + (kind === 'fabrication' ? '_fabrication' : '_silkscreen')
     }
 
     /**

package/src/core/CircuitJsonPcbPrimitiveFields.mjs

@@ -2,6 +2,15 @@ import { CircuitJsonIndexer } from './CircuitJsonIndexer.mjs'
 import { CircuitJsonUnits } from './CircuitJsonUnits.mjs'
 import { CircuitJsonPcbPrimitiveGeometry } from './CircuitJsonPcbPrimitiveGeometry.mjs'
 
+const PHYSICAL_COPPER_KINDS = new Set([
+    'copper-text',
+    'pad',
+    'thermal-spoke',
+    'track',
+    'via',
+    'zone'
+])
+
 /**
  * Resolves shared CircuitJSON PCB primitive fields from common element shapes.
  */
@@ -47,13 +56,42 @@ export class CircuitJsonPcbPrimitiveFields {
 
     /**
      * Builds copper layer rows from board metadata.
-     * @param {object | null} board Board element.
+     * @param {object | object[] | null} boardOrBoards Board element or rows.
+     * @param {object[]} [primitives] Prepared primitives for observed layer union.
      * @returns {object[]}
      */
-    static layers(board) {
+    static layers(boardOrBoards, primitives = []) {
+        const boards = Array.isArray(boardOrBoards)
+            ? boardOrBoards
+            : boardOrBoards
+              ? [boardOrBoards]
+              : []
+        let declaredCount = boards.length ? 1 : 2
+        for (const board of boards) {
+            declaredCount = Math.max(
+                declaredCount,
+                Math.max(
+                    1,
+                    Math.min(
+                        8,
+                        Math.round(
+                            CircuitJsonUnits.length(board?.num_layers, 4)
+                        )
+                    )
+                )
+            )
+            if (declaredCount === 8) break
+        }
+        const observed =
+            CircuitJsonPcbPrimitiveFields.#observedCopperLayers(primitives)
+        const maximumInner = [...observed].reduce((maximum, layer) => {
+            const match = /^inner([1-6])$/u.exec(layer)
+            return match ? Math.max(maximum, Number(match[1])) : maximum
+        }, 0)
         const count = Math.max(
-            1,
-            Math.round(CircuitJsonUnits.length(board?.num_layers, 2))
+            declaredCount,
+            maximumInner ? maximumInner + 2 : 1,
+            observed.has('bottom') ? 2 : 1
         )
         const keys =
             count === 1
@@ -79,6 +117,34 @@ export class CircuitJsonPcbPrimitiveFields {
         }))
     }
 
+    /**
+     * Resolves every structurally physical layer referenced by copper geometry.
+     * @param {object[]} primitives Prepared PCB primitives.
+     * @returns {Set<string>} Observed physical layer ids.
+     */
+    static #observedCopperLayers(primitives) {
+        const result = new Set()
+        for (const primitive of primitives || []) {
+            if (!PHYSICAL_COPPER_KINDS.has(primitive.kind)) continue
+            const source = primitive.sourceRoute || primitive.source || {}
+            const candidates = [
+                primitive.layer,
+                source.from_layer,
+                source.fromLayer,
+                source.to_layer,
+                source.toLayer,
+                ...(Array.isArray(source.layers) ? source.layers : [])
+            ]
+            for (const candidate of candidates) {
+                const layer = CircuitJsonPcbPrimitiveFields.layer(candidate)
+                if (/^(?:top|bottom|inner[1-6])$/u.test(layer)) {
+                    result.add(layer)
+                }
+            }
+        }
+        return result
+    }
+
     /**
      * Resolves a center point.
      * @param {object} element Element row.