pcb-scene3d-viewer 1.1.0 → 1.1.2

package/src/PcbScene3dPadFactory.mjs

@@ -27,18 +27,28 @@ export class PcbScene3dPadFactory {
         const geometryCache = new Map()
         const side = PcbScene3dPadFactory.#normalizeSide(options?.side)
         const mirrorY = Boolean(options?.mirrorY)
+        const normalizedPads = pads || []
+        const boardDrills = PcbScene3dDrillPathFactory.resolveBoardDrillSpecs({
+            pads: normalizedPads
+        })
 
-        ;(pads || []).forEach((pad) => {
+        ;(normalizedPads || []).forEach((pad) => {
             if (!PcbScene3dPadFactory.#hasVisibleSurface(pad, side)) {
                 return
             }
 
             const spec = PcbScene3dPadFactory.resolvePadSurfaceSpec(pad, side)
+            const drillCutouts = PcbScene3dPadFactory.#resolvePadDrillCutouts(
+                pad,
+                spec,
+                boardDrills,
+                mirrorY
+            )
             const geometry = PcbScene3dPadFactory.#resolveGeometry(
                 THREE,
                 geometryCache,
                 spec,
-                pad
+                drillCutouts
             )
             const point = PcbScene3dPadFactory.#normalizePoint(
                 normalizeBoardPoint,
@@ -391,27 +401,22 @@ export class PcbScene3dPadFactory {
      * Resolves or creates one reusable geometry for the pad spec.
      * @param {any} THREE
      * @param {Map<string, any>} geometryCache
-     * @param {any} pad
      * @param {{ width: number, height: number, kind: 'circle' | 'rect' | 'rounded-rect', radius: number, cornerRadius: number, hasHole: boolean, holeDiameter: number, holeSlotLength: number | null, holeRotation: number }} spec
+     * @param {{ x: number, y: number, diameter: number, slotLength?: number | null, rotationDeg?: number | null }[]} drillCutouts
      * @returns {any}
      */
-    static #resolveGeometry(THREE, geometryCache, spec, pad) {
-        const cacheKey = [
-            spec.kind,
-            spec.width.toFixed(4),
-            spec.height.toFixed(4),
-            spec.cornerRadius.toFixed(4),
-            spec.holeDiameter.toFixed(4),
-            Number(spec.holeSlotLength || 0).toFixed(4),
-            spec.holeRotation.toFixed(4)
-        ].join(':')
+    static #resolveGeometry(THREE, geometryCache, spec, drillCutouts) {
+        const cacheKey = PcbScene3dPadFactory.#buildGeometryCacheKey(
+            spec,
+            drillCutouts
+        )
         const cached = geometryCache.get(cacheKey)
         if (cached) {
             return cached
         }
 
         let geometry
-        if (spec.kind === 'circle' && !spec.hasHole) {
+        if (spec.kind === 'circle' && !drillCutouts.length) {
             geometry = new THREE.CylinderGeometry(
                 spec.radius,
                 spec.radius,
@@ -420,12 +425,14 @@ export class PcbScene3dPadFactory {
             )
         } else {
             const shape = PcbScene3dPadFactory.#buildOuterShape(THREE, spec)
-            const drillHole = PcbScene3dDrillPathFactory.buildPadHolePath(
-                THREE,
-                pad
-            )
-            if (drillHole) {
-                shape.holes.push(drillHole)
+            for (const drillCutout of drillCutouts) {
+                const drillHole = PcbScene3dDrillPathFactory.buildDrillPath(
+                    THREE,
+                    drillCutout
+                )
+                if (drillHole) {
+                    shape.holes.push(drillHole)
+                }
             }
             geometry = new THREE.ExtrudeGeometry(shape, {
                 depth: PcbScene3dPadFactory.#PAD_THICKNESS_MIL,
@@ -444,6 +451,200 @@ export class PcbScene3dPadFactory {
         return geometry
     }
 
+    /**
+     * Resolves drill apertures that intersect one pad's local copper face.
+     * @param {{ x?: number, y?: number, rotation?: number | null }} pad
+     * @param {{ width: number, height: number, kind: 'circle' | 'rect' | 'rounded-rect', radius: number, offsetX: number, offsetY: number }} spec
+     * @param {{ x: number, y: number, diameter: number, slotLength?: number | null, rotationDeg?: number | null }[]} boardDrills
+     * @param {boolean} mirrorY
+     * @returns {{ x: number, y: number, diameter: number, slotLength?: number | null, rotationDeg?: number | null }[]}
+     */
+    static #resolvePadDrillCutouts(pad, spec, boardDrills, mirrorY) {
+        return (boardDrills || [])
+            .map((drillSpec) =>
+                PcbScene3dPadFactory.#toPadLocalDrillCutout(
+                    pad,
+                    spec,
+                    drillSpec,
+                    mirrorY
+                )
+            )
+            .filter((drillSpec) =>
+                PcbScene3dPadFactory.#drillTouchesPadSurface(drillSpec, spec)
+            )
+    }
+
+    /**
+     * Converts one board-space drill aperture into pad-local shape space.
+     * @param {{ x?: number, y?: number, rotation?: number | null }} pad
+     * @param {{ offsetX: number, offsetY: number }} spec
+     * @param {{ x: number, y: number, diameter: number, slotLength?: number | null, rotationDeg?: number | null }} drillSpec
+     * @param {boolean} mirrorY
+     * @returns {{ x: number, y: number, diameter: number, slotLength?: number | null, rotationDeg?: number | null }}
+     */
+    static #toPadLocalDrillCutout(pad, spec, drillSpec, mirrorY) {
+        const padRotationDeg = Number(pad?.rotation || 0)
+        const relative = {
+            x: Number(drillSpec?.x || 0) - Number(pad?.x || 0),
+            y: Number(drillSpec?.y || 0) - Number(pad?.y || 0)
+        }
+        if (mirrorY) {
+            relative.y *= -1
+        }
+
+        const local = PcbScene3dPadFactory.#rotatePoint(
+            relative,
+            -padRotationDeg
+        )
+        const localOffsetY = mirrorY ? -spec.offsetY : spec.offsetY
+        const diameter = Number(drillSpec?.diameter || 0)
+        const slotLength =
+            Number(drillSpec?.slotLength || 0) > diameter
+                ? Number(drillSpec.slotLength || 0)
+                : null
+
+        return {
+            x: local.x - spec.offsetX,
+            y: local.y - localOffsetY,
+            diameter,
+            slotLength,
+            rotationDeg: PcbScene3dPadFactory.#normalizeAngle(
+                Number(drillSpec?.rotationDeg || 0) - padRotationDeg
+            )
+        }
+    }
+
+    /**
+     * Checks whether a local drill aperture overlaps the pad's surface bounds.
+     * @param {{ x: number, y: number, diameter: number, slotLength?: number | null, rotationDeg?: number | null }} drillSpec
+     * @param {{ width: number, height: number, kind: 'circle' | 'rect' | 'rounded-rect', radius: number }} spec
+     * @returns {boolean}
+     */
+    static #drillTouchesPadSurface(drillSpec, spec) {
+        if (Number(drillSpec?.diameter || 0) <= 0) {
+            return false
+        }
+
+        const bounds = PcbScene3dPadFactory.#resolveDrillBounds(drillSpec)
+        const halfWidth = Number(spec.width || 0) / 2
+        const halfHeight = Number(spec.height || 0) / 2
+        const boundsOverlap =
+            bounds.maxX >= -halfWidth &&
+            bounds.minX <= halfWidth &&
+            bounds.maxY >= -halfHeight &&
+            bounds.minY <= halfHeight
+        if (!boundsOverlap) {
+            return false
+        }
+
+        if (spec.kind !== 'circle') {
+            return true
+        }
+
+        return (
+            Math.hypot(Number(drillSpec.x || 0), Number(drillSpec.y || 0)) <=
+            Number(spec.radius || 0) +
+                PcbScene3dPadFactory.#resolveDrillReach(drillSpec)
+        )
+    }
+
+    /**
+     * Resolves the axis-aligned local bounds of one drill aperture.
+     * @param {{ x: number, y: number, diameter: number, slotLength?: number | null, rotationDeg?: number | null }} drillSpec
+     * @returns {{ minX: number, maxX: number, minY: number, maxY: number }}
+     */
+    static #resolveDrillBounds(drillSpec) {
+        const radius = Math.max(Number(drillSpec.diameter || 0) / 2, 0)
+        const halfTrack = Math.max(
+            (Number(drillSpec.slotLength || 0) -
+                Number(drillSpec.diameter || 0)) /
+                2,
+            0
+        )
+        const rotationRad = (Number(drillSpec.rotationDeg || 0) * Math.PI) / 180
+        const extentX = Math.abs(Math.cos(rotationRad)) * halfTrack + radius
+        const extentY = Math.abs(Math.sin(rotationRad)) * halfTrack + radius
+
+        return {
+            minX: Number(drillSpec.x || 0) - extentX,
+            maxX: Number(drillSpec.x || 0) + extentX,
+            minY: Number(drillSpec.y || 0) - extentY,
+            maxY: Number(drillSpec.y || 0) + extentY
+        }
+    }
+
+    /**
+     * Resolves a conservative radial reach for one drill aperture.
+     * @param {{ diameter: number, slotLength?: number | null }} drillSpec
+     * @returns {number}
+     */
+    static #resolveDrillReach(drillSpec) {
+        return (
+            Math.max(
+                Number(drillSpec.diameter || 0),
+                Number(drillSpec.slotLength || 0)
+            ) / 2
+        )
+    }
+
+    /**
+     * Rotates one 2D point around the origin.
+     * @param {{ x: number, y: number }} point
+     * @param {number} angleDeg
+     * @returns {{ x: number, y: number }}
+     */
+    static #rotatePoint(point, angleDeg) {
+        const angleRad = (Number(angleDeg || 0) * Math.PI) / 180
+        const cos = Math.cos(angleRad)
+        const sin = Math.sin(angleRad)
+
+        return {
+            x: point.x * cos - point.y * sin,
+            y: point.x * sin + point.y * cos
+        }
+    }
+
+    /**
+     * Builds a cache key that includes pad geometry and local drill cutouts.
+     * @param {{ width: number, height: number, kind: 'circle' | 'rect' | 'rounded-rect', cornerRadius: number, holeDiameter: number, holeSlotLength: number | null, holeRotation: number }} spec
+     * @param {{ x: number, y: number, diameter: number, slotLength?: number | null, rotationDeg?: number | null }[]} drillCutouts
+     * @returns {string}
+     */
+    static #buildGeometryCacheKey(spec, drillCutouts) {
+        const drillKey = (drillCutouts || [])
+            .map((drillSpec) =>
+                [
+                    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(',')
+            )
+            .join('|')
+
+        return [
+            spec.kind,
+            spec.width.toFixed(4),
+            spec.height.toFixed(4),
+            spec.cornerRadius.toFixed(4),
+            spec.holeDiameter.toFixed(4),
+            Number(spec.holeSlotLength || 0).toFixed(4),
+            spec.holeRotation.toFixed(4),
+            drillKey
+        ].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
+    }
+
     /**
      * Builds one pad outline shape for extrusion.
      * @param {any} THREE

package/src/PcbScene3dRenderGroupVisibility.mjs

@@ -9,7 +9,7 @@ export class PcbScene3dRenderGroupVisibility {
 
     /**
      * Applies the active 3D detail visibility state.
-     * @param {{ groups: Map<string, any>, toggles: { 'external-models': boolean, 'fallback-bodies': boolean, copper: boolean }, fallbackBodyRoots: Map<string, Set<any>>, loadedExternalModelDesignators: Set<string>, hasLoadedBoardAssemblyModel?: boolean }} state Visibility state.
+     * @param {{ groups: Map<string, any>, toggles: { 'external-models': boolean, 'fallback-bodies': boolean, 'model-search-models'?: boolean, copper: boolean }, fallbackBodyRoots: Map<string, Set<any>>, loadedExternalModelDesignators: Set<string>, modelSearchExternalModelRoots?: Set<any>, hasLoadedBoardAssemblyModel?: boolean }} state Visibility state.
      * @returns {void}
      */
     static apply(state) {
@@ -51,6 +51,28 @@ export class PcbScene3dRenderGroupVisibility {
             state?.groups?.get('external-models'),
             Boolean(state?.toggles?.['external-models'])
         )
+        PcbScene3dRenderGroupVisibility.#applyModelSearchExternalVisibility(
+            state
+        )
+    }
+
+    /**
+     * Applies the app-discovered model toggle to individual external roots.
+     * @param {{ toggles?: { 'external-models'?: boolean, 'model-search-models'?: boolean }, modelSearchExternalModelRoots?: Set<any> }} state Visibility state.
+     * @returns {void}
+     */
+    static #applyModelSearchExternalVisibility(state) {
+        const roots = state?.modelSearchExternalModelRoots
+        if (!roots || typeof roots.forEach !== 'function') {
+            return
+        }
+
+        const visible =
+            Boolean(state?.toggles?.['external-models']) &&
+            state?.toggles?.['model-search-models'] !== false
+        roots.forEach((root) => {
+            PcbScene3dRenderGroupVisibility.#setVisible(root, visible)
+        })
     }
 
     /**

package/src/PcbScene3dRuntime.mjs

@@ -2,6 +2,8 @@ import { PcbScene3dBoardSolderMaskFactory } from './PcbScene3dBoardSolderMaskFac
 import { PcbScene3dBodyColor } from './PcbScene3dBodyColor.mjs'
 import { PcbScene3dCameraRig } from './PcbScene3dCameraRig.mjs'
 import { PcbScene3dCircuitJsonAdapter } from './PcbScene3dCircuitJsonAdapter.mjs'
+import { PcbScene3dComponentAdjustment } from './PcbScene3dComponentAdjustment.mjs'
+import { PcbScene3dComponentAdjustmentRegistry } from './PcbScene3dComponentAdjustmentRegistry.mjs'
 import { PcbScene3dCopperFactory } from './PcbScene3dCopperFactory.mjs'
 import { PcbScene3dCopperDetailFilter } from './PcbScene3dCopperDetailFilter.mjs'
 import { PcbScene3dDetailCoordinateNormalizer } from './PcbScene3dDetailCoordinateNormalizer.mjs'
@@ -10,15 +12,18 @@ import { PcbScene3dExternalModels } from './PcbScene3dExternalModels.mjs'
 import { PcbScene3dFallbackVisibility } from './PcbScene3dFallbackVisibility.mjs'
 import { PcbScene3dInteractionHints } from './PcbScene3dInteractionHints.mjs'
 import { PcbScene3dMountRig } from './PcbScene3dMountRig.mjs'
+import { PcbScene3dModelSearchPlacement } from './PcbScene3dModelSearchPlacement.mjs'
 import { PcbScene3dPresetState } from './PcbScene3dPresetState.mjs'
 import { PcbScene3dRenderGroupVisibility } from './PcbScene3dRenderGroupVisibility.mjs'
 import { PcbScene3dRuntimeBoardMeshes } from './PcbScene3dRuntimeBoardMeshes.mjs'
 import { PcbScene3dSilkscreenChunkedFactory } from './PcbScene3dSilkscreenChunkedFactory.mjs'
 import { PcbScene3dTrueTypeTextFactory } from './PcbScene3dTrueTypeTextFactory.mjs'
+import { PcbScene3dSelectionResolver } from './PcbScene3dSelectionResolver.mjs'
 import { PcbScene3dSelectionStyler } from './PcbScene3dSelectionStyler.mjs'
 import { PcbScene3dViaFactory } from './PcbScene3dViaFactory.mjs'
 import { PcbScene3dViewportResize } from './PcbScene3dViewportResize.mjs'
 import { PcbScene3dViewScale } from './PcbScene3dViewScale.mjs'
+const Z_MIL = { cu: 0.05, silk: 0.06 }
 /**
  * Browser-side Three.js runtime for the interactive PCB 3D viewport.
  */
@@ -29,7 +34,7 @@ export class PcbScene3dRuntime {
     #sceneDescription
     /** @type {{ setDiagnostics?: (messages: string[]) => void, setSelection?: (selection: any | null) => void, loadRuntimeModules?: () => Promise<{ THREE: any, OrbitControls: any }>, translate?: ((key: string) => string) | null }} */
     #hooks
-    /** @type {{ 'external-models': boolean, 'fallback-bodies': boolean, copper: boolean }} */
+    /** @type {{ 'external-models': boolean, 'fallback-bodies': boolean, 'model-search-models': boolean, copper: boolean }} */
     #toggles
     /** @type {Map<string, any>} */
     #groups
@@ -61,10 +66,14 @@ export class PcbScene3dRuntime {
     #pointerDownPosition
     /** @type {Map<string, Set<any>>} */
     #selectionRoots
+    /** @type {PcbScene3dComponentAdjustmentRegistry} */
+    #componentAdjustmentRegistry
     /** @type {Map<string, Set<any>>} */
     #fallbackBodyRoots
     /** @type {Set<string>} */
     #loadedExternalModelDesignators
+    /** @type {Set<any>} */
+    #modelSearchExternalModelRoots
     /** @type {boolean} */
     #hasLoadedBoardAssemblyModel
     /** @type {string} */
@@ -81,7 +90,6 @@ export class PcbScene3dRuntime {
     #resolveReadyPromise
     /** @type {boolean} */
     #hasSettledReady
-
     /**
      * @param {HTMLElement} viewportNode
      * @param {any} sceneDescription Scene description or CircuitJSON model.
@@ -96,6 +104,7 @@ export class PcbScene3dRuntime {
         this.#toggles = {
             'external-models': true,
             'fallback-bodies': false,
+            'model-search-models': true,
             copper: true
         }
         this.#groups = new Map()
@@ -113,8 +122,11 @@ export class PcbScene3dRuntime {
         this.#pointer = null
         this.#pointerDownPosition = null
         this.#selectionRoots = new Map()
+        this.#componentAdjustmentRegistry =
+            new PcbScene3dComponentAdjustmentRegistry(() => this.#three)
         this.#fallbackBodyRoots = new Map()
         this.#loadedExternalModelDesignators = new Set()
+        this.#modelSearchExternalModelRoots = new Set()
         this.#hasLoadedBoardAssemblyModel = false
         this.#selectedDesignator = ''
         this.#initialRadius =
@@ -134,7 +146,6 @@ export class PcbScene3dRuntime {
         ])
         this.#initialize()
     }
-
     /** @param {string} preset */
     setPreset(preset) {
         const normalizedPreset = this.#presetState.set(preset)
@@ -151,7 +162,6 @@ export class PcbScene3dRuntime {
         )
         this.#render()
     }
-
     /** @param {string} toggleName @param {boolean} enabled */
     setToggle(toggleName, enabled) {
         if (!(toggleName in this.#toggles)) {
@@ -168,6 +178,18 @@ export class PcbScene3dRuntime {
         this.#setSelectedDesignator(designator)
     }
 
+    /**
+     * Applies a live model-local adjustment to one component.
+     * @param {string} designator Component designator.
+     * @param {{ scale?: { x?: number, y?: number, z?: number }, rotationDeg?: { x?: number, y?: number, z?: number }, offsetMil?: { x?: number, y?: number, z?: number } }} adjustment Transform adjustment.
+     * @returns {void}
+     */
+    setComponentAdjustment(designator, adjustment) {
+        if (this.#componentAdjustmentRegistry.set(designator, adjustment)) {
+            this.#render()
+        }
+    }
+
     /**
      * Resolves when the runtime has completed its initial async
      * initialization and deferred scene settlement.
@@ -204,8 +226,10 @@ export class PcbScene3dRuntime {
         this.#pointer = null
         this.#pointerDownPosition = null
         this.#selectionRoots.clear()
+        this.#componentAdjustmentRegistry.clear()
         this.#fallbackBodyRoots.clear()
         this.#loadedExternalModelDesignators.clear()
+        this.#modelSearchExternalModelRoots.clear()
         this.#hasLoadedBoardAssemblyModel = false
         this.#selectedDesignator = ''
         this.#groups.clear()
@@ -464,18 +488,18 @@ export class PcbScene3dRuntime {
         await PcbScene3dTrueTypeTextFactory.prepareEmbeddedFonts(
             this.#sceneDescription.detail.embeddedFonts || []
         )
+        const topZ = this.#sceneDescription.board.thicknessMil / 2 + Z_MIL.silk
         const detailGroup = await PcbScene3dSilkscreenChunkedFactory.buildGroup(
             this.#three,
             this.#sceneDescription.detail.silkscreen || {},
-            this.#sceneDescription.board.thicknessMil / 2 + 1.18,
-            -(this.#sceneDescription.board.thicknessMil / 2 + 1.18),
+            topZ,
+            -topZ,
             (x, y) => this.#normalizeDetailPoint(x, y),
             {
                 shouldContinue: () => !this.#isDisposed,
                 yieldToMain: () => PcbScene3dRuntime.#yieldToNextFrame()
             }
         )
-
         if (this.#isDisposed) return
         if (detailGroup.children.length) {
             silkscreenGroup.add(detailGroup)
@@ -492,15 +516,15 @@ export class PcbScene3dRuntime {
         if (!copperGroup || copperGroup.children.length) {
             return
         }
-
         const copperDetail = PcbScene3dCopperDetailFilter.resolve(
             this.#sceneDescription
         )
+        const topZ = this.#sceneDescription.board.thicknessMil / 2 + Z_MIL.cu
         const detailGroup = PcbScene3dCopperFactory.buildGroup(
             this.#three,
             copperDetail,
-            this.#sceneDescription.board.thicknessMil / 2 + 0.9,
-            -(this.#sceneDescription.board.thicknessMil / 2 + 0.9),
+            topZ,
+            -topZ,
             (x, y) => this.#normalizeDetailPoint(x, y),
             { coordinateSystem: this.#sceneDescription.coordinateSystem }
         )
@@ -564,14 +588,25 @@ export class PcbScene3dRuntime {
 
         const mountRig = PcbScene3dMountRig.create(THREE, component)
         const rootGroup = mountRig.rootGroup
+        const adjustmentGroup = new THREE.Group()
 
         rootGroup.userData.scene3dSelection = {
             designator: String(component?.designator || 'component'),
             sourceType: 'component'
         }
+        adjustmentGroup.userData.scene3dAdjustmentTarget = true
+        adjustmentGroup.userData.scene3dAdjustmentDesignator = String(
+            component?.designator || 'component'
+        )
+        adjustmentGroup.userData.scene3dAdjustmentBaseline =
+            PcbScene3dComponentAdjustment.neutral()
         this.#registerSelectionRoot(component?.designator, rootGroup)
-        mountRig.faceGroup.add(mesh)
-
+        this.#componentAdjustmentRegistry.register(
+            component?.designator,
+            adjustmentGroup
+        )
+        adjustmentGroup.add(mesh)
+        mountRig.faceGroup.add(adjustmentGroup)
         return rootGroup
     }
 
@@ -599,6 +634,19 @@ export class PcbScene3dRuntime {
                     placement?.designator,
                     placementGroup
                 )
+                PcbScene3dComponentAdjustment.findTargets(
+                    placementGroup
+                ).forEach((target) => {
+                    this.#componentAdjustmentRegistry.register(
+                        placement?.designator,
+                        target
+                    )
+                })
+                PcbScene3dModelSearchPlacement.registerRoot(
+                    placement,
+                    placementGroup,
+                    this.#modelSearchExternalModelRoots
+                )
                 if (
                     String(placement?.sourceType || '').toLowerCase() ===
                     'board-assembly'
@@ -728,6 +776,7 @@ export class PcbScene3dRuntime {
             fallbackBodyRoots: this.#fallbackBodyRoots,
             loadedExternalModelDesignators:
                 this.#loadedExternalModelDesignators,
+            modelSearchExternalModelRoots: this.#modelSearchExternalModelRoots,
             hasLoadedBoardAssemblyModel: this.#hasLoadedBoardAssemblyModel
         })
     }
@@ -850,7 +899,7 @@ export class PcbScene3dRuntime {
             true
         )
         const selection =
-            PcbScene3dRuntime.#resolveSelectionFromIntersections(intersections)
+            PcbScene3dSelectionResolver.fromIntersections(intersections)
         this.#setSelectedDesignator(selection?.designator)
         this.#hooks.setSelection?.(selection)
     }
@@ -930,44 +979,6 @@ export class PcbScene3dRuntime {
         return PcbScene3dViewScale.resolve(preset, sceneDescription)
     }
 
-    /**
-     * Resolves the picked selection record from raycast intersections.
-     * @param {{ object?: any }[]} intersections
-     * @returns {{ designator?: string, sourceType?: string } | null}
-     */
-    static #resolveSelectionFromIntersections(intersections) {
-        for (const intersection of intersections) {
-            const selection = PcbScene3dRuntime.#resolveSelectionFromObject(
-                intersection?.object
-            )
-            if (selection) {
-                return selection
-            }
-        }
-
-        return null
-    }
-
-    /**
-     * Resolves one selection payload by walking up a picked object tree.
-     * @param {any} object
-     * @returns {{ designator?: string, sourceType?: string } | null}
-     */
-    static #resolveSelectionFromObject(object) {
-        let current = object
-
-        while (current) {
-            const selection = current?.userData?.scene3dSelection
-            if (selection) {
-                return selection
-            }
-
-            current = current.parent || null
-        }
-
-        return null
-    }
-
     /** @returns {number} */
     static #resolveSelectionHighlightColor() {
         return 0x14c5e6