pcb-scene3d-viewer 1.1.49 → 1.2.0

package/src/PcbScene3dBoardShapeFactory.mjs

@@ -2,13 +2,13 @@ import { PcbScene3dBoardEdgeCutoutBuilder } from './PcbScene3dBoardEdgeCutoutBui
 import { PcbScene3dBoardCutoutPathFactory } from './PcbScene3dBoardCutoutPathFactory.mjs'
 import { PcbScene3dDrillPathFactory } from './PcbScene3dDrillPathFactory.mjs'
 import { PcbScene3dOutlineBuilder } from './PcbScene3dOutlineBuilder.mjs'
+import { PcbScene3dPlatedDrillSpecResolver } from './PcbScene3dPlatedDrillSpecResolver.mjs'
 
 /**
  * Builds the board solid profile, including drilled holes.
  */
 export class PcbScene3dBoardShapeFactory {
     static #CURVE_SEGMENTS = 8
-    static #PAD_HOLE_SHAPE_SLOT = 2
     static #PLATED_WALL_MATERIAL_INDEX = 2
     static #EDGE_WALL_MATERIAL_INDEX = 1
     static #CONTOUR_SAMPLE_POINTS = 64
@@ -235,7 +235,9 @@ export class PcbScene3dBoardShapeFactory {
                 const diameter = Number(normalizedSpec.diameter || 0)
                 const slotLength = Number(normalizedSpec.slotLength || 0)
                 const isCircular =
-                    diameter > 0 && slotLength <= diameter + 0.001
+                    PcbScene3dBoardShapeFactory.#isCircularDrillSpec(
+                        normalizedSpec
+                    )
                 const points = isCircular
                     ? PcbScene3dBoardEdgeCutoutBuilder.buildCircularCutoutPoints(
                           Number(normalizedSpec.x || 0),
@@ -338,7 +340,7 @@ export class PcbScene3dBoardShapeFactory {
      * @returns {{ points: { x: number, y: number }[], segments: { start: { x: number, y: number }, end: { x: number, y: number }, dx: number, dy: number, lengthSquared: number, bounds: { minX: number, maxX: number, minY: number, maxY: number } }[], bounds: { minX: number, maxX: number, minY: number, maxY: number }, isCircular?: boolean, centerX?: number, centerY?: number, radius?: number }[]}
      */
     static #resolvePlatedContours(THREE, detail, normalizeBoardPoint) {
-        return PcbScene3dBoardShapeFactory.#resolvePlatedDrillSpecs(detail)
+        return PcbScene3dPlatedDrillSpecResolver.resolve(detail)
             .map((drillSpec) => {
                 const point = normalizeBoardPoint(drillSpec.x, drillSpec.y)
                 const normalizedSpec = {
@@ -373,14 +375,18 @@ export class PcbScene3dBoardShapeFactory {
 
     /**
      * Returns true when a drill aperture can be matched as a circle.
-     * @param {{ diameter?: number, slotLength?: number | null }} drillSpec
+     * @param {{ diameter?: number, shape?: string, slotLength?: number | null }} drillSpec
      * @returns {boolean}
      */
     static #isCircularDrillSpec(drillSpec) {
         const diameter = Number(drillSpec?.diameter || 0)
         const slotLength = Number(drillSpec?.slotLength || 0)
 
-        return diameter > 0 && slotLength <= diameter + 0.001
+        return (
+            diameter > 0 &&
+            drillSpec?.shape !== 'rect' &&
+            slotLength <= diameter + 0.001
+        )
     }
 
     /**
@@ -416,94 +422,6 @@ export class PcbScene3dBoardShapeFactory {
         }
     }
 
-    /**
-     * Resolves deduped drill specs that represent plated holes.
-     * @param {{ pads?: any[], vias?: any[] }} detail
-     * @returns {{ x: number, y: number, diameter: number, slotLength?: number | null, rotationDeg?: number | null }[]}
-     */
-    static #resolvePlatedDrillSpecs(detail) {
-        const platedKeys = new Set()
-
-        for (const via of detail?.vias || []) {
-            const diameter = Number(via?.holeDiameter || 0)
-            if (diameter <= 0) {
-                continue
-            }
-
-            platedKeys.add(
-                PcbScene3dBoardShapeFactory.#buildDrillSpecKey({
-                    x: Number(via?.x || 0),
-                    y: Number(via?.y || 0),
-                    diameter,
-                    slotLength: null,
-                    rotationDeg: 0
-                })
-            )
-        }
-
-        for (const pad of detail?.pads || []) {
-            const diameter = Number(pad?.holeDiameter || 0)
-            if (
-                diameter <= 0 ||
-                !PcbScene3dBoardShapeFactory.#hasPadCopperAnnulus(pad, diameter)
-            ) {
-                continue
-            }
-
-            const slotLength =
-                Number(pad?.holeShape) ===
-                    PcbScene3dBoardShapeFactory.#PAD_HOLE_SHAPE_SLOT &&
-                Number(pad?.holeSlotLength || 0) > diameter
-                    ? Number(pad?.holeSlotLength || 0)
-                    : null
-            platedKeys.add(
-                PcbScene3dBoardShapeFactory.#buildDrillSpecKey({
-                    x: Number(pad?.x || 0),
-                    y: Number(pad?.y || 0),
-                    diameter,
-                    slotLength,
-                    rotationDeg:
-                        slotLength === null
-                            ? 0
-                            : PcbScene3dBoardShapeFactory.#normalizeAngle(
-                                  Number(pad?.rotation || 0) +
-                                      Number(pad?.holeRotation || 0)
-                              )
-                })
-            )
-        }
-
-        return PcbScene3dDrillPathFactory.resolveBoardDrillSpecs(detail).filter(
-            (drillSpec) =>
-                platedKeys.has(
-                    PcbScene3dBoardShapeFactory.#buildDrillSpecKey(drillSpec)
-                )
-        )
-    }
-
-    /**
-     * Checks whether one pad has copper larger than its drill aperture.
-     * @param {any} pad
-     * @param {number} diameter
-     * @returns {boolean}
-     */
-    static #hasPadCopperAnnulus(pad, diameter) {
-        const drillSpan = Math.max(diameter, Number(pad?.holeSlotLength || 0))
-
-        return [
-            pad?.sizeTopX,
-            pad?.sizeTopY,
-            pad?.sizeMidX,
-            pad?.sizeMidY,
-            pad?.sizeBottomX,
-            pad?.sizeBottomY
-        ].some(
-            (size) =>
-                Number(size || 0) >
-                drillSpan + PcbScene3dBoardShapeFactory.#GEOMETRY_EPSILON
-        )
-    }
-
     /**
      * Builds one closed contour and bounds from sampled path points.
      * @param {any[]} points
@@ -970,29 +888,4 @@ export class PcbScene3dBoardShapeFactory {
 
         return dx * dx + dy * dy
     }
-
-    /**
-     * Builds a stable drill spec key.
-     * @param {{ x: number, y: number, diameter: number, slotLength?: number | null, rotationDeg?: number | null }} drillSpec
-     * @returns {string}
-     */
-    static #buildDrillSpecKey(drillSpec) {
-        return [
-            Number(drillSpec.x || 0).toFixed(4),
-            Number(drillSpec.y || 0).toFixed(4),
-            Number(drillSpec.diameter || 0).toFixed(4),
-            Number(drillSpec.slotLength || 0).toFixed(4),
-            Number(drillSpec.rotationDeg || 0).toFixed(4)
-        ].join(':')
-    }
-
-    /**
-     * Normalizes one angle into the inclusive `[0, 360)` range.
-     * @param {number} angleDeg
-     * @returns {number}
-     */
-    static #normalizeAngle(angleDeg) {
-        const normalized = Number(angleDeg || 0) % 360
-        return normalized < 0 ? normalized + 360 : normalized
-    }
 }

package/src/PcbScene3dBoardSolderMaskFactory.mjs

@@ -43,48 +43,71 @@ export class PcbScene3dBoardSolderMaskFactory {
             return group
         }
 
-        const geometry = PcbScene3dBoardSolderMaskFactory.#buildMaskGeometry(
-            THREE,
-            board,
-            sceneDescription?.detail || {},
-            normalizeBoardPoint
-        )
-        const topMaterial = PcbScene3dBoardSolderMaskFactory.#buildMaterial(
-            THREE,
-            board,
-            THREE.FrontSide,
-            sceneDescription?.sourceFormat
-        )
-        const bottomMaterial = PcbScene3dBoardSolderMaskFactory.#buildMaterial(
-            THREE,
-            board,
-            THREE.BackSide,
-            sceneDescription?.sourceFormat
-        )
-        const z = Number(board?.thicknessMil || 0) / 2
-
-        group.add(
-            PcbScene3dBoardSolderMaskFactory.#buildSurfaceMesh(
+        const contours = PcbScene3dBoardSolderMaskFactory.#boardContours(board)
+        contours.forEach((contour, index) => {
+            const geometry =
+                PcbScene3dBoardSolderMaskFactory.#buildMaskGeometry(
+                    THREE,
+                    contour,
+                    sceneDescription?.detail || {},
+                    normalizeBoardPoint
+                )
+            const topMaterial = PcbScene3dBoardSolderMaskFactory.#buildMaterial(
                 THREE,
-                geometry,
-                topMaterial,
-                z + PcbScene3dBoardSolderMaskFactory.#FACE_Z_OFFSET_MIL,
-                'board-solder-mask-top'
+                contour,
+                THREE.FrontSide,
+                sceneDescription?.sourceFormat
             )
-        )
-        group.add(
-            PcbScene3dBoardSolderMaskFactory.#buildSurfaceMesh(
-                THREE,
-                geometry,
-                bottomMaterial,
-                -z - PcbScene3dBoardSolderMaskFactory.#FACE_Z_OFFSET_MIL,
-                'board-solder-mask-bottom'
+            const bottomMaterial =
+                PcbScene3dBoardSolderMaskFactory.#buildMaterial(
+                    THREE,
+                    contour,
+                    THREE.BackSide,
+                    sceneDescription?.sourceFormat
+                )
+            const z = Number(contour?.thicknessMil || 0) / 2
+            const suffix = contours.length === 1 ? '' : '-' + (index + 1)
+
+            group.add(
+                PcbScene3dBoardSolderMaskFactory.#buildSurfaceMesh(
+                    THREE,
+                    geometry,
+                    topMaterial,
+                    z + PcbScene3dBoardSolderMaskFactory.#FACE_Z_OFFSET_MIL,
+                    'board-solder-mask-top' + suffix
+                )
             )
-        )
+            group.add(
+                PcbScene3dBoardSolderMaskFactory.#buildSurfaceMesh(
+                    THREE,
+                    geometry,
+                    bottomMaterial,
+                    -z - PcbScene3dBoardSolderMaskFactory.#FACE_Z_OFFSET_MIL,
+                    'board-solder-mask-bottom' + suffix
+                )
+            )
+        })
 
         return group
     }
 
+    /**
+     * Resolves independently renderable solder-mask contours.
+     * @param {object} board Aggregate board metadata.
+     * @returns {object[]}
+     */
+    static #boardContours(board) {
+        const contours = Array.isArray(board?.contours)
+            ? board.contours.filter(Boolean)
+            : []
+        if (!contours.length) return [board]
+        return contours.map((contour) => ({
+            ...board,
+            ...contour,
+            contours: []
+        }))
+    }
+
     /**
      * Builds one flat solder-mask face mesh.
      * @param {any} THREE
@@ -609,10 +632,13 @@ export class PcbScene3dBoardSolderMaskFactory {
      */
     static #buildMaterial(THREE, board, side, sourceFormat) {
         return new THREE.MeshStandardMaterial({
-            color: PcbScene3dBoardMaterialPalette.resolveSurfaceColor(board, {
-                hasBoardAssemblyModel: true,
-                sourceFormat
-            }),
+            color: PcbScene3dBoardMaterialPalette.resolveBoardSurfaceColor(
+                board,
+                {
+                    hasBoardAssemblyModel: true,
+                    sourceFormat
+                }
+            ),
             ...PcbScene3dMaterialFinish.semiMatteSolderMaskProperties(),
             polygonOffset: true,
             polygonOffsetFactor: -1,

package/src/PcbScene3dCircuitJsonAdapter.mjs

@@ -1,18 +1,23 @@
 import {
-    CircuitJsonDocument,
-    CircuitJsonIndexer,
+    CircuitJsonDocumentContext,
     CircuitJsonUnits
 } from 'circuitjson-toolkit'
+import { CircuitJsonPcbHolePrimitiveModel } from 'circuitjson-toolkit/extensions'
 import { PcbScene3dCircuitJsonGeometry } from './PcbScene3dCircuitJsonGeometry.mjs'
+import { PcbScene3dCircuitJsonDrillDetail } from './PcbScene3dCircuitJsonDrillDetail.mjs'
 import { PcbScene3dCircuitJsonModelTransform } from './PcbScene3dCircuitJsonModelTransform.mjs'
 import { PcbScene3dCircuitJsonCopperPourBuilder } from './PcbScene3dCircuitJsonCopperPourBuilder.mjs'
 import { PcbScene3dCircuitJsonSilkscreenBuilder } from './PcbScene3dCircuitJsonSilkscreenBuilder.mjs'
 import { PcbScene3dFootprintBodyBuilder } from './PcbScene3dFootprintBodyBuilder.mjs'
 import { PcbScene3dCircuitJsonLayer } from './PcbScene3dCircuitJsonLayer.mjs'
+import { PcbScene3dCircuitJsonInput } from './PcbScene3dCircuitJsonInput.mjs'
 import { PcbScene3dCircuitJsonTraceRouteBuilder } from './PcbScene3dCircuitJsonTraceRouteBuilder.mjs'
 import { PcbScene3dCircuitJsonThermalSpokeBuilder } from './PcbScene3dCircuitJsonThermalSpokeBuilder.mjs'
 import { PcbScene3dCircuitJsonModelUrlResolver } from './PcbScene3dCircuitJsonModelUrlResolver.mjs'
 import { PcbScene3dCircuitJsonSolderPasteBuilder } from './PcbScene3dCircuitJsonSolderPasteBuilder.mjs'
+import { CircuitJsonCadModelAssetResolver } from './CircuitJsonCadModelAssetResolver.mjs'
+import { PcbScene3dDescriptorSafeRecord } from './PcbScene3dDescriptorSafeRecord.mjs'
+import { PcbScene3dCircuitJsonModelAsset } from './PcbScene3dCircuitJsonModelAsset.mjs'
 
 const DEFAULT_COMPONENT_HEIGHT_MIL = 60
 const RECTANGULAR_PAD_SHAPE = 2
@@ -39,7 +44,7 @@ export class PcbScene3dCircuitJsonAdapter {
      * @returns {boolean}
      */
     static isCircuitJsonModel(value) {
-        return CircuitJsonDocument.isModel(value)
+        return PcbScene3dCircuitJsonInput.isModel(value)
     }
 
     /**
@@ -52,29 +57,61 @@ export class PcbScene3dCircuitJsonAdapter {
             return false
         }
 
-        if (String(value?.sourceFormat || '') === 'circuitjson') {
+        if (!Array.isArray(value)) return true
+
+        if (
+            String(
+                PcbScene3dCircuitJsonAdapter.#ownData(value, 'sourceFormat') ||
+                    ''
+            ) === 'circuitjson'
+        ) {
             return true
         }
 
         return !PcbScene3dCircuitJsonAdapter.#hasCompatibilityModel(value)
     }
 
+    /**
+     * Normalizes and validates one candidate through the shared CircuitJSON
+     * context while reusing an existing proof and element index.
+     * @param {unknown} circuitJson CircuitJSON model, document, or context.
+     * @returns {CircuitJsonDocumentContext} Prepared shared context.
+     */
+    static prepare(circuitJson) {
+        return CircuitJsonDocumentContext.prepare(circuitJson, {
+            indexes: ['elements']
+        })
+    }
+
     /**
      * Builds the internal render model used by the Three.js runtime.
-     * @param {object[]} circuitJson Serialized CircuitJSON model.
+     * @param {unknown} circuitJson CircuitJSON model, document envelope, or prepared context.
      * @param {{ modelUrlResolver?: (url: string, context: object) => string | object | null | undefined, projectBaseUrl?: string, boardDrillQuality?: string, showPcbNotes?: boolean, showPcbPaste?: boolean }} [options] Adapter options.
      * @returns {object}
      */
     static build(circuitJson, options = {}) {
-        CircuitJsonDocument.assertModel(circuitJson)
-        const index = CircuitJsonIndexer.index(circuitJson)
-        const board = PcbScene3dCircuitJsonGeometry.buildBoard(index, options)
-        const detail = PcbScene3dCircuitJsonAdapter.#buildDetail(index, options)
+        const context = PcbScene3dCircuitJsonAdapter.prepare(circuitJson)
+        const index = context.getIndex('elements')
+        const resolvedOptions =
+            PcbScene3dCircuitJsonAdapter.#hasExternalModelReferences(index)
+                ? CircuitJsonCadModelAssetResolver.withContextAssetResolver(
+                      options,
+                      context
+                  )
+                : options
+        const board = PcbScene3dCircuitJsonGeometry.buildBoard(
+            index,
+            resolvedOptions
+        )
+        const detail = PcbScene3dCircuitJsonAdapter.#buildDetail(
+            index,
+            resolvedOptions
+        )
         const externalPlacements =
             PcbScene3dCircuitJsonAdapter.#buildExternalPlacements(
                 index,
                 board,
-                options
+                resolvedOptions
             )
         const externalPlacementByComponentId =
             PcbScene3dCircuitJsonAdapter.#externalPlacementByComponentId(
@@ -104,6 +141,33 @@ export class PcbScene3dCircuitJsonAdapter {
         }
     }
 
+    /**
+     * Returns whether CAD rows reference models that may need asset lookup.
+     * @param {{ elementsByType: Map<string, object[]> }} index CircuitJSON index.
+     * @returns {boolean}
+     */
+    static #hasExternalModelReferences(index) {
+        return (index.elementsByType.get('cad_component') || []).some(
+            (component) =>
+                MODEL_URL_FIELDS.some(([field]) =>
+                    String(
+                        PcbScene3dCircuitJsonAdapter.#ownData(
+                            component,
+                            field
+                        ) || ''
+                    ).trim()
+                ) ||
+                Boolean(
+                    PcbScene3dCircuitJsonModelAsset.reference(
+                        PcbScene3dCircuitJsonAdapter.#ownData(
+                            component,
+                            'model_asset'
+                        )
+                    )
+                )
+        )
+    }
+
     /**
      * Returns true for parser-produced arrays that already carry a legacy
      * renderer model and must keep using their format-specific scene builder.
@@ -111,7 +175,27 @@ export class PcbScene3dCircuitJsonAdapter {
      * @returns {boolean}
      */
     static #hasCompatibilityModel(value) {
-        return Boolean(value?.pcb || value?.schematic || value?.bom)
+        return ['pcb', 'schematic', 'bom'].some((name) =>
+            Boolean(PcbScene3dCircuitJsonAdapter.#ownData(value, name))
+        )
+    }
+
+    /**
+     * Reads one own data property without invoking caller accessors.
+     * @param {unknown} value Record candidate.
+     * @param {string} name Property name.
+     * @returns {unknown} Own data value or undefined.
+     */
+    static #ownData(value, name) {
+        if (!value || typeof value !== 'object') return undefined
+        try {
+            const descriptor = Object.getOwnPropertyDescriptor(value, name)
+            return descriptor && Object.hasOwn(descriptor, 'value')
+                ? descriptor.value
+                : undefined
+        } catch {
+            return undefined
+        }
     }
 
     /**
@@ -405,12 +489,16 @@ export class PcbScene3dCircuitJsonAdapter {
         const match = MODEL_URL_FIELDS.find(([field]) =>
             String(cadComponent?.[field] || '').trim()
         )
-        if (!match) {
-            return null
-        }
-
-        const [field, format] = match
-        const sourceUrl = String(cadComponent?.[field] || '').trim()
+        const reference = match
+            ? {
+                  field: match[0],
+                  format: match[1],
+                  sourceUrl: String(cadComponent?.[match[0]] || '').trim()
+              }
+            : PcbScene3dCircuitJsonAdapter.#modelAssetReference(cadComponent)
+        if (!reference) return null
+
+        const { field, format, sourceUrl } = reference
         const context = {
             format,
             field,
@@ -432,6 +520,18 @@ export class PcbScene3dCircuitJsonAdapter {
         }
     }
 
+    /**
+     * Resolves a canonical `model_asset` fallback reference.
+     * @param {object} cadComponent CAD component element.
+     * @returns {{ field: string, format: string, sourceUrl: string } | null}
+     */
+    static #modelAssetReference(cadComponent) {
+        const reference = PcbScene3dCircuitJsonModelAsset.reference(
+            cadComponent?.model_asset
+        )
+        return reference ? { field: 'model_asset', ...reference } : null
+    }
+
     /**
      * Applies optional caller-owned model URL resolution.
      * @param {string} sourceUrl Source URL.
@@ -447,7 +547,7 @@ export class PcbScene3dCircuitJsonAdapter {
                 return { resolvedUrl: resolved }
             }
             if (resolved && typeof resolved === 'object') {
-                return { ...resolved }
+                return PcbScene3dDescriptorSafeRecord.copy(resolved)
             }
         }
 
@@ -663,13 +763,20 @@ export class PcbScene3dCircuitJsonAdapter {
     static #buildPlatedHoles(index) {
         return (index.elementsByType.get('pcb_plated_hole') || []).map(
             (hole) => {
+                const geometry = CircuitJsonPcbHolePrimitiveModel.build(hole, {
+                    x: Number(hole?.x || 0),
+                    y: Number(hole?.y || 0)
+                })
                 const size =
-                    PcbScene3dCircuitJsonAdapter.#platedHoleOuterSize(hole)
+                    PcbScene3dCircuitJsonAdapter.#platedHoleOuterSize(geometry)
                 const center = CircuitJsonUnits.pointMmToMil({
                     x: hole?.x,
                     y: hole?.y
                 })
-                const drill = PcbScene3dCircuitJsonGeometry.holeDrillSpec(hole)
+                const drill = PcbScene3dCircuitJsonGeometry.holeDrillSpec(
+                    hole,
+                    geometry
+                )
                 const exposesCopper =
                     PcbScene3dCircuitJsonAdapter.#exposesCopperThroughMask(
                         hole,
@@ -678,19 +785,18 @@ export class PcbScene3dCircuitJsonAdapter {
                 return {
                     x: center.x,
                     y: center.y,
-                    rotation: Number(hole?.ccw_rotation || 0),
-                    shapeTop: PcbScene3dCircuitJsonAdapter.#padShape(hole),
-                    shapeMid: PcbScene3dCircuitJsonAdapter.#padShape(hole),
-                    shapeBottom: PcbScene3dCircuitJsonAdapter.#padShape(hole),
+                    rotation: Number(geometry.rotation || 0),
+                    shapeTop: PcbScene3dCircuitJsonAdapter.#padShape(geometry),
+                    shapeMid: PcbScene3dCircuitJsonAdapter.#padShape(geometry),
+                    shapeBottom:
+                        PcbScene3dCircuitJsonAdapter.#padShape(geometry),
                     sizeTopX: size.width,
                     sizeTopY: size.height,
                     sizeMidX: size.width,
                     sizeMidY: size.height,
                     sizeBottomX: size.width,
                     sizeBottomY: size.height,
-                    holeDiameter: drill.diameter,
-                    holeSlotLength: drill.slotLength,
-                    holeRotation: drill.rotationDeg,
+                    ...PcbScene3dCircuitJsonDrillDetail.fields(drill),
                     holeOffsetX: drill.center.x - center.x,
                     holeOffsetY: drill.center.y - center.y,
                     hasTopSolderMaskOpening: exposesCopper,
@@ -721,9 +827,7 @@ export class PcbScene3dCircuitJsonAdapter {
                 sizeMidY: 0,
                 sizeBottomX: 0,
                 sizeBottomY: 0,
-                holeDiameter: drill.diameter,
-                holeSlotLength: drill.slotLength,
-                holeRotation: drill.rotationDeg,
+                ...PcbScene3dCircuitJsonDrillDetail.fields(drill),
                 hasTopSolderMaskOpening: false,
                 hasBottomSolderMaskOpening: false
             }
@@ -782,10 +886,17 @@ export class PcbScene3dCircuitJsonAdapter {
      * @returns {number}
      */
     static #roundedPadCornerRadiusPercent(pad, size) {
+        const width = CircuitJsonUnits.optionalLength(pad?.width)
+        const height = CircuitJsonUnits.optionalLength(pad?.height)
+        const radius = CircuitJsonUnits.optionalLength(pad?.radius)
+        if (width > 0 && height > 0 && radius > 0) {
+            return Math.min((radius / Math.min(width, height)) * 100, 50)
+        }
+
         const shortestSide = Math.min(Number(size.width), Number(size.height))
-        const radius = CircuitJsonUnits.mmToMil(pad?.radius, 0)
-        if (shortestSide > 0 && radius > 0) {
-            return Math.min((radius / shortestSide) * 100, 50)
+        const radiusMil = CircuitJsonUnits.mmToMil(pad?.radius, 0)
+        if (shortestSide > 0 && radiusMil > 0) {
+            return Math.min((radiusMil / shortestSide) * 100, 50)
         }
 
         return 50
@@ -793,23 +904,13 @@ export class PcbScene3dCircuitJsonAdapter {
 
     /**
      * Resolves plated-hole copper size from CircuitJSON fields.
-     * @param {object} hole Plated-hole element.
+     * @param {object} geometry Shared drilled-primitive geometry.
      * @returns {{ width: number, height: number }}
      */
-    static #platedHoleOuterSize(hole) {
-        if (Number(hole?.outer_diameter || 0) > 0) {
-            const diameter = CircuitJsonUnits.mmToMil(hole.outer_diameter, 1)
-            return { width: diameter, height: diameter }
-        }
+    static #platedHoleOuterSize(geometry) {
         return {
-            width: CircuitJsonUnits.mmToMil(
-                hole?.outer_width || hole?.rect_pad_width,
-                1
-            ),
-            height: CircuitJsonUnits.mmToMil(
-                hole?.outer_height || hole?.rect_pad_height,
-                1
-            )
+            width: CircuitJsonUnits.mmToMil(geometry?.width, 1),
+            height: CircuitJsonUnits.mmToMil(geometry?.height, 1)
         }
     }
 
@@ -820,7 +921,9 @@ export class PcbScene3dCircuitJsonAdapter {
      */
     static #padShape(pad) {
         const shape = String(pad?.shape || '')
-        return shape.includes('rect') || shape.endsWith('pill')
+        return shape.includes('rect') ||
+            shape.includes('polygon') ||
+            shape.endsWith('pill')
             ? RECTANGULAR_PAD_SHAPE
             : CIRCULAR_PAD_SHAPE
     }

package/src/PcbScene3dCircuitJsonDrillDetail.mjs

@@ -0,0 +1,31 @@
+/**
+ * Maps canonical drill descriptors onto the viewer's compact pad-detail shape.
+ */
+export class PcbScene3dCircuitJsonDrillDetail {
+    static #RECTANGULAR_HOLE_SHAPE = 1
+    static #SLOTTED_HOLE_SHAPE = 2
+
+    /**
+     * Builds common viewer drill fields without losing canonical aperture shape.
+     * @param {{ diameter: number, width: number, height: number, shape: 'circle' | 'pill' | 'rect', slotLength: number, rotationDeg: number }} drill Canonical drill descriptor.
+     * @returns {{ holeDiameter: number, holeSlotLength: number, holeWidth: number, holeHeight: number, holeShape: number | null, holeRotation: number }} Viewer drill fields.
+     */
+    static fields(drill) {
+        return {
+            holeDiameter: drill.diameter,
+            holeSlotLength: drill.slotLength,
+            holeWidth: drill.width,
+            holeHeight: drill.height,
+            holeShape:
+                drill.shape === 'rect'
+                    ? PcbScene3dCircuitJsonDrillDetail.#RECTANGULAR_HOLE_SHAPE
+                    : drill.slotLength > drill.diameter
+                      ? PcbScene3dCircuitJsonDrillDetail.#SLOTTED_HOLE_SHAPE
+                      : null,
+            holeRotation: drill.rotationDeg
+        }
+    }
+}
+
+Object.freeze(PcbScene3dCircuitJsonDrillDetail.prototype)
+Object.freeze(PcbScene3dCircuitJsonDrillDetail)