altium-toolkit 1.1.33 → 1.1.36

package/src/ui/AltiumScene3dAuthoredBodyAnchorAdapter.mjs

@@ -7,7 +7,10 @@ export class AltiumScene3dAuthoredBodyAnchorAdapter {
     static #BODY_ANCHOR_TOLERANCE_MIL = 5
     static #AUTHORED_SOURCE = 'authored-body-anchor'
     static #AUTHORED_ANCHOR_IDENTITY_PATTERN =
-        /(?:^|[^a-z0-9])(?:antenna|coax|connector|edge|header|jack|mechanical|module|mount|shield|sma|socket|usb)(?:$|[^a-z0-9])/i
+        /(?:^|[^a-z0-9])(?:antenna|coax|connector|edge|header|jack|mechanical|module|mount|shield|sma|socket)(?:$|[^a-z0-9])/i
+    static #USB_ANCHOR_IDENTITY_PATTERN = /(?:^|[^a-z0-9])usb(?:$|[^a-z0-9])/i
+    static #INTEGRATED_CIRCUIT_PACKAGE_PATTERN =
+        /(?:^|[^a-z0-9])(?:u?qfn|v?qfn|dfn|qfp|lqfp|tqfp|bga|lga|sop|soic|ssop|tssop|msop|so[-_ ]?\d+)(?:[-_ ]?\d+)?(?:$|[^a-z0-9])/i
 
     /**
      * Marks off-anchor explicit Altium body placements so the runtime does not
@@ -149,11 +152,36 @@ export class AltiumScene3dAuthoredBodyAnchorAdapter {
      * @returns {boolean}
      */
     static #hasAuthoredAnchorIdentity(placement, component) {
-        return AltiumScene3dAuthoredBodyAnchorAdapter.#AUTHORED_ANCHOR_IDENTITY_PATTERN.test(
+        const identityText =
             AltiumScene3dAuthoredBodyAnchorAdapter.#identityText(
                 placement,
                 component
             )
+
+        return (
+            AltiumScene3dAuthoredBodyAnchorAdapter.#AUTHORED_ANCHOR_IDENTITY_PATTERN.test(
+                identityText
+            ) ||
+            AltiumScene3dAuthoredBodyAnchorAdapter.#hasUsbHardwareAnchorIdentity(
+                identityText
+            )
+        )
+    }
+
+    /**
+     * Allows USB connector-like anchors without treating USB interface ICs as
+     * authored mechanical anchors.
+     * @param {string} identityText Searchable package identity.
+     * @returns {boolean}
+     */
+    static #hasUsbHardwareAnchorIdentity(identityText) {
+        return (
+            AltiumScene3dAuthoredBodyAnchorAdapter.#USB_ANCHOR_IDENTITY_PATTERN.test(
+                identityText
+            ) &&
+            !AltiumScene3dAuthoredBodyAnchorAdapter.#INTEGRATED_CIRCUIT_PACKAGE_PATTERN.test(
+                identityText
+            )
         )
     }
 

package/src/ui/AltiumScene3dExternalPlacementAdapter.mjs

@@ -752,8 +752,12 @@ export class AltiumScene3dExternalPlacementAdapter {
             180
         const cos = Math.cos(rotationRad)
         const sin = Math.sin(rotationRad)
-        const x = Number(offset?.x || 0) * cos - Number(offset?.y || 0) * sin
-        const y = Number(offset?.x || 0) * sin + Number(offset?.y || 0) * cos
+        const sourceY =
+            AltiumScene3dExternalPlacementAdapter.#isBottomPlacement(placement)
+                ? -Number(offset?.y || 0)
+                : Number(offset?.y || 0)
+        const x = Number(offset?.x || 0) * cos - sourceY * sin
+        const y = Number(offset?.x || 0) * sin + sourceY * cos
 
         return {
             x: Math.abs(x) < Number.EPSILON ? 0 : Number(x.toFixed(10)),

package/src/ui/AltiumScene3dPlacementRotationPolicy.mjs

@@ -1,3 +1,5 @@
+import { AltiumScene3dTwoRowFootprintDetector } from './AltiumScene3dTwoRowFootprintDetector.mjs'
+
 const PASSIVE_BODY_PATTERN =
     /(?:^|[^a-z0-9])(?:cap|capacitor|res|resistor|ind|inductor|ferrite|bead|crystal|xtal|lqw|lqg)(?:$|[^a-z0-9])/i
 const CHIP_PASSIVE_BODY_PATTERN =
@@ -6,6 +8,8 @@ const LOCAL_Y_CHIP_PASSIVE_MODEL_PATTERN =
     /(?:^|[^a-z0-9])local[-_ ]?y(?:$|[^a-z0-9])/i
 const PIN_ONE_CORNER_PACKAGE_PATTERN =
     /(?:^|[^a-z0-9])(?:[avw]?qfn|vfqfn|wqfn|v?qfp|lqfp|tqfp|pqfp|mqfp)(?:[0-9]+)?(?:$|[^a-z0-9])/i
+const TWO_ROW_PIN_ONE_PACKAGE_PATTERN =
+    /(?:^|[^a-z0-9])(?:msop|qsop|soic|sop|ssop|tssop|tsop|vsop)(?:[-_ ]?\d+)?(?:$|[^a-z0-9])/i
 const FIVE_LEAD_SOT_PATTERN =
     /(?:^|[^a-z0-9])sot[-_ ]?(?:23[-_ ]?5|25|5)(?:$|[^a-z0-9])/i
 const THREE_LEAD_SOT23_PATTERN =
@@ -39,6 +43,9 @@ export class AltiumScene3dPlacementRotationPolicy {
             AltiumScene3dPlacementRotationPolicy.#needsSquarePinOneCorrection(
                 context
             ) ||
+            AltiumScene3dPlacementRotationPolicy.#needsTwoRowPinOneCorrection(
+                context
+            ) ||
             AltiumScene3dPlacementRotationPolicy.#needsFiveLeadSotCorrection(
                 context
             ) ||
@@ -211,6 +218,43 @@ export class AltiumScene3dPlacementRotationPolicy {
         )
     }
 
+    /**
+     * Detects two-row IC packages whose embedded source frame puts the
+     * package pin-one corner opposite the footprint convention.
+     * @param {{ placement?: object, component?: object | null, componentBody?: object | null, pads?: object[] }} context Rotation context.
+     * @returns {boolean}
+     */
+    static #needsTwoRowPinOneCorrection(context) {
+        const { placement, component, componentBody, pads } = context || {}
+        if (
+            !AltiumScene3dPlacementRotationPolicy.#isPadFallback(placement) ||
+            !component ||
+            String(placement?.mountSide || '').toLowerCase() !== 'top' ||
+            AltiumScene3dPlacementRotationPolicy.#isGenericPassiveBody(
+                componentBody
+            ) ||
+            !AltiumScene3dPlacementRotationPolicy.#hasRightAngleModelTilt(
+                componentBody
+            )
+        ) {
+            return false
+        }
+
+        const identityText =
+            AltiumScene3dPlacementRotationPolicy.#packageIdentityText(
+                component,
+                componentBody
+            )
+        if (!TWO_ROW_PIN_ONE_PACKAGE_PATTERN.test(identityText)) {
+            return false
+        }
+
+        return AltiumScene3dTwoRowFootprintDetector.hasTwoRowSurfaceFootprint(
+            component,
+            pads
+        )
+    }
+
     /**
      * Checks whether a source package yaw already matches the footprint and
      * does not need another pin-one half-turn.

package/src/ui/AltiumScene3dRepeatedModelOwnerRepair.mjs

@@ -1,3 +1,5 @@
+import { PcbScene3dPackageDimensionResolver } from './PcbScene3dPackageDimensionResolver.mjs'
+
 const CONNECTOR_TOKENS = new Set([
     'antenna',
     'coax',
@@ -14,9 +16,14 @@ const TIMING_PACKAGE_PATTERN =
     /(?:^|[^a-z0-9])(?:clock|crystal|osc|oscillator|resonator|tcxo|txco|xtal)(?:$|[^a-z0-9])/i
 const TIMING_DESIGNATOR_PATTERN = /^(?:y|xo)\d+[a-z]?$/i
 const AUTHORED_ANCHOR_IDENTITY_PATTERN =
-    /(?:^|[^a-z0-9])(?:antenna|coax|connector|edge|header|jack|mechanical|module|mount|shield|sma|socket|usb)(?:$|[^a-z0-9])/i
+    /(?:^|[^a-z0-9])(?:antenna|coax|connector|edge|header|jack|mechanical|module|mount|shield|sma|socket)(?:$|[^a-z0-9])/i
 const PAD_FALLBACK_AUTHORED_ANCHOR_PATTERN =
-    /(?:^|[^a-z0-9])(?:antenna|coax|conn|connector|edge|flex|fpc|frame|hardware|header|jack|mechanical|module|shield|sma|socket|usb)(?:$|[^a-z0-9])/i
+    /(?:^|[^a-z0-9])(?:antenna|coax|conn|connector|edge|flex|fpc|frame|hardware|header|jack|mechanical|module|shield|sma|socket)(?:$|[^a-z0-9])/i
+const USB_ANCHOR_IDENTITY_PATTERN = /(?:^|[^a-z0-9])usb(?:$|[^a-z0-9])/i
+const INTEGRATED_CIRCUIT_PACKAGE_PATTERN =
+    /(?:^|[^a-z0-9])(?:u?qfn|v?qfn|dfn|qfp|lqfp|tqfp|bga|lga|sop|soic|ssop|tssop|msop|so[-_ ]?\d+)(?:[-_ ]?\d+)?(?:$|[^a-z0-9])/i
+const SHIELD_COVER_TOKEN_PATTERN =
+    /(?:^|[^a-z0-9])(?:rf|emi|rfi|shield|cover)(?:$|[^a-z0-9])/gi
 
 /**
  * Repairs repeated Altium model-anchor bodies by matching their shared source
@@ -228,8 +235,20 @@ export class AltiumScene3dRepeatedModelOwnerRepair {
             String(placement?.projection?.source || '').toLowerCase() ===
             'pad-fallback'
         ) {
+            if (
+                AltiumScene3dRepeatedModelOwnerRepair.#hasShieldCoverSourceOriginOffset(
+                    placement,
+                    component,
+                    identityText
+                )
+            ) {
+                return false
+            }
+
             return (
-                PAD_FALLBACK_AUTHORED_ANCHOR_PATTERN.test(identityText) ||
+                AltiumScene3dRepeatedModelOwnerRepair.#hasPadFallbackAuthoredAnchorIdentity(
+                    identityText
+                ) ||
                 AltiumScene3dRepeatedModelOwnerRepair.#hasCompactIcSourceOriginOffset(
                     placement,
                     component,
@@ -238,7 +257,149 @@ export class AltiumScene3dRepeatedModelOwnerRepair {
             )
         }
 
-        return AUTHORED_ANCHOR_IDENTITY_PATTERN.test(identityText)
+        return AltiumScene3dRepeatedModelOwnerRepair.#hasAuthoredAnchorIdentity(
+            identityText
+        )
+    }
+
+    /**
+     * Checks whether pad-fallback identity describes an authored hardware
+     * anchor instead of a source-origin-biased IC body.
+     * @param {string} identityText Searchable package identity.
+     * @returns {boolean}
+     */
+    static #hasPadFallbackAuthoredAnchorIdentity(identityText) {
+        return (
+            PAD_FALLBACK_AUTHORED_ANCHOR_PATTERN.test(identityText) ||
+            AltiumScene3dRepeatedModelOwnerRepair.#hasUsbHardwareAnchorIdentity(
+                identityText
+            )
+        )
+    }
+
+    /**
+     * Checks whether non-pad-fallback identity describes authored hardware.
+     * @param {string} identityText Searchable package identity.
+     * @returns {boolean}
+     */
+    static #hasAuthoredAnchorIdentity(identityText) {
+        return (
+            AUTHORED_ANCHOR_IDENTITY_PATTERN.test(identityText) ||
+            AltiumScene3dRepeatedModelOwnerRepair.#hasUsbHardwareAnchorIdentity(
+                identityText
+            )
+        )
+    }
+
+    /**
+     * Allows USB connector-like anchors without treating USB interface ICs as
+     * authored mechanical anchors.
+     * @param {string} identityText Searchable package identity.
+     * @returns {boolean}
+     */
+    static #hasUsbHardwareAnchorIdentity(identityText) {
+        return (
+            USB_ANCHOR_IDENTITY_PATTERN.test(identityText) &&
+            !INTEGRATED_CIRCUIT_PACKAGE_PATTERN.test(identityText)
+        )
+    }
+
+    /**
+     * Checks whether a shield cover body origin is a package corner.
+     * @param {object} placement Scene placement.
+     * @param {object} component PCB component.
+     * @param {string} identityText Searchable package identity.
+     * @returns {boolean}
+     */
+    static #hasShieldCoverSourceOriginOffset(
+        placement,
+        component,
+        identityText
+    ) {
+        const tokens = new Set(
+            [...String(identityText || '').matchAll(SHIELD_COVER_TOKEN_PATTERN)]
+                .map((match) => String(match[0] || '').toLowerCase())
+                .map((token) => token.replace(/[^a-z0-9]+/giu, ''))
+        )
+        if (
+            !tokens.has('cover') ||
+            !['rf', 'emi', 'rfi', 'shield'].some((token) => tokens.has(token))
+        ) {
+            return false
+        }
+
+        const size =
+            PcbScene3dPackageDimensionResolver.resolvePlanarSize(component)
+        if (!size) {
+            return false
+        }
+
+        const offset = {
+            x:
+                Number(placement?.bodyPositionMil?.x || 0) -
+                Number(component?.x || 0),
+            y:
+                Number(placement?.bodyPositionMil?.y || 0) -
+                Number(component?.y || 0)
+        }
+        if (
+            !Number.isFinite(offset.x) ||
+            !Number.isFinite(offset.y) ||
+            Math.hypot(offset.x, offset.y) <=
+                AltiumScene3dRepeatedModelOwnerRepair
+                    .#MIN_PAD_FALLBACK_OWNER_OFFSET_MIL
+        ) {
+            return false
+        }
+
+        return AltiumScene3dRepeatedModelOwnerRepair.#matchesCornerOriginSize(
+            Math.abs(offset.x) * 2,
+            Math.abs(offset.y) * 2,
+            size
+        )
+    }
+
+    /**
+     * Checks whether doubled owner offset matches package dimensions.
+     * @param {number} offsetWidth Doubled X offset.
+     * @param {number} offsetDepth Doubled Y offset.
+     * @param {{ width: number, depth: number }} size Explicit package size.
+     * @returns {boolean}
+     */
+    static #matchesCornerOriginSize(offsetWidth, offsetDepth, size) {
+        return (
+            (AltiumScene3dRepeatedModelOwnerRepair.#matchesDimension(
+                offsetWidth,
+                size.width
+            ) &&
+                AltiumScene3dRepeatedModelOwnerRepair.#matchesDimension(
+                    offsetDepth,
+                    size.depth
+                )) ||
+            (AltiumScene3dRepeatedModelOwnerRepair.#matchesDimension(
+                offsetWidth,
+                size.depth
+            ) &&
+                AltiumScene3dRepeatedModelOwnerRepair.#matchesDimension(
+                    offsetDepth,
+                    size.width
+                ))
+        )
+    }
+
+    /**
+     * Checks whether two dimensions are close enough for source-origin repair.
+     * @param {number} actual Actual dimension.
+     * @param {number} expected Expected dimension.
+     * @returns {boolean}
+     */
+    static #matchesDimension(actual, expected) {
+        if (!Number.isFinite(actual) || !Number.isFinite(expected)) {
+            return false
+        }
+
+        const tolerance = Math.max(35, Math.abs(expected) * 0.08)
+        return Math.abs(actual - expected) <= tolerance
     }
 
     /**
@@ -557,8 +718,12 @@ export class AltiumScene3dRepeatedModelOwnerRepair {
             180
         const cos = Math.cos(rotationRad)
         const sin = Math.sin(rotationRad)
-        const x = Number(offset?.x || 0) * cos - Number(offset?.y || 0) * sin
-        const y = Number(offset?.x || 0) * sin + Number(offset?.y || 0) * cos
+        const sourceY =
+            AltiumScene3dRepeatedModelOwnerRepair.#isBottomPlacement(placement)
+                ? -Number(offset?.y || 0)
+                : Number(offset?.y || 0)
+        const x = Number(offset?.x || 0) * cos - sourceY * sin
+        const y = Number(offset?.x || 0) * sin + sourceY * cos
         const z = Number(
             modelTransform?.offsetMil?.z ?? modelTransform?.dzMil ?? 0
         )

package/src/ui/AltiumScene3dShapeStackOwnerAdapter.mjs

@@ -7,8 +7,11 @@ const TIMING_DESIGNATOR_PATTERN = /^(?:y|xo)\d+[a-z]?$/i
  */
 export class AltiumScene3dShapeStackOwnerAdapter {
     static #BASE_OWNER_TOLERANCE_MIL = 60
+    static #EXACT_OWNER_TOLERANCE_MIL = 1
     static #STACK_BODY_RADIUS_MIL = 220
     static #HEIGHT_TOLERANCE_MIL = 0.1
+    static #TIMING_PARAMETER_NAME_PATTERN =
+        /(?:^|[^a-z0-9])(?:comment|description|device|function|part|type|value)(?:$|[^a-z0-9])/i
 
     /**
      * Applies authored stack ownership to static and external placements.
@@ -69,7 +72,8 @@ export class AltiumScene3dShapeStackOwnerAdapter {
                 AltiumScene3dShapeStackOwnerAdapter.#repairStaticPlacements(
                     sceneDescription.staticBodyPlacements,
                     componentBodies,
-                    assignments
+                    assignments,
+                    sceneDescription.board
                 )
         }
     }
@@ -146,9 +150,15 @@ export class AltiumScene3dShapeStackOwnerAdapter {
      * @param {object[] | undefined} placements Scene static body placements.
      * @param {object[]} componentBodies Source component-body rows.
      * @param {object[]} assignments Carrier assignments.
+     * @param {object | undefined} board Scene board metadata.
      * @returns {object[]}
      */
-    static #repairStaticPlacements(placements, componentBodies, assignments) {
+    static #repairStaticPlacements(
+        placements,
+        componentBodies,
+        assignments,
+        board
+    ) {
         return (Array.isArray(placements) ? placements : []).map(
             (placement) => {
                 const assignment = assignments.find((candidate) =>
@@ -161,15 +171,122 @@ export class AltiumScene3dShapeStackOwnerAdapter {
                     return placement
                 }
 
-                return {
-                    ...placement,
-                    designator: String(assignment.owner.designator || ''),
-                    coLocatedVariantGroupKey: assignment.groupKey
-                }
+                return AltiumScene3dShapeStackOwnerAdapter.#withStaticOwner(
+                    placement,
+                    assignment,
+                    board
+                )
             }
         )
     }
 
+    /**
+     * Applies one stack owner to a repaired static carrier body.
+     * @param {object} placement Static body placement.
+     * @param {{ owner: object, groupKey: string }} assignment Stack assignment.
+     * @param {object | undefined} board Scene board metadata.
+     * @returns {object}
+     */
+    static #withStaticOwner(placement, assignment, board) {
+        const ownerDesignator = String(assignment?.owner?.designator || '')
+        const mountSide =
+            AltiumScene3dShapeStackOwnerAdapter.#mountSide(assignment?.owner) ||
+            placement?.mountSide
+        const sidePlacement =
+            AltiumScene3dShapeStackOwnerAdapter.#withStaticMountSide(
+                placement,
+                mountSide
+            )
+
+        return {
+            ...sidePlacement,
+            designator: ownerDesignator,
+            selectionKey: ownerDesignator || sidePlacement.selectionKey,
+            positionMil: AltiumScene3dShapeStackOwnerAdapter.#withOwnerAnchor(
+                sidePlacement?.positionMil,
+                assignment.owner,
+                board
+            ),
+            coLocatedVariantGroupKey: assignment.groupKey
+        }
+    }
+
+    /**
+     * Applies a static placement side while preserving its height magnitude.
+     * @param {object} placement Static body placement.
+     * @param {string | undefined} mountSide Owner mount side.
+     * @returns {object}
+     */
+    static #withStaticMountSide(placement, mountSide) {
+        const currentSide =
+            AltiumScene3dShapeStackOwnerAdapter.#normalizeMountSide(
+                placement?.mountSide
+            )
+        const side = AltiumScene3dShapeStackOwnerAdapter.#normalizeMountSide(
+            mountSide || currentSide
+        )
+        const z = Math.abs(Number(placement?.positionMil?.z || 0))
+
+        return {
+            ...placement,
+            mountSide: side,
+            positionMil: {
+                ...(placement?.positionMil || {}),
+                z: side === 'bottom' ? -z : z
+            },
+            geometry:
+                currentSide === side
+                    ? placement?.geometry
+                    : AltiumScene3dShapeStackOwnerAdapter.#mirrorStaticGeometry(
+                          placement
+                      )
+        }
+    }
+
+    /**
+     * Mirrors source-coordinate static geometry for the opposite board side.
+     * @param {{ sourceCoordinateFrame?: boolean, geometry?: object }} placement Static body placement.
+     * @returns {object | undefined}
+     */
+    static #mirrorStaticGeometry(placement) {
+        const geometry = placement?.geometry
+        if (
+            !placement?.sourceCoordinateFrame ||
+            !Array.isArray(geometry?.verticesMil)
+        ) {
+            return geometry
+        }
+
+        return {
+            ...geometry,
+            verticesMil: geometry.verticesMil.map((vertex) => ({
+                x: AltiumScene3dShapeStackOwnerAdapter.#round(vertex?.x || 0),
+                y: AltiumScene3dShapeStackOwnerAdapter.#round(
+                    -Number(vertex?.y || 0)
+                )
+            }))
+        }
+    }
+
+    /**
+     * Re-anchors a repaired static carrier on the owning component position.
+     * @param {object | undefined} position Existing render position.
+     * @param {{ x?: number, y?: number }} owner Owner component.
+     * @param {object | undefined} board Scene board metadata.
+     * @returns {{ x: number, y: number, z: number }}
+     */
+    static #withOwnerAnchor(position, owner, board) {
+        return {
+            ...(position || {}),
+            x: AltiumScene3dShapeStackOwnerAdapter.#round(
+                Number(owner?.x || 0) - Number(board?.centerX || 0)
+            ),
+            y: AltiumScene3dShapeStackOwnerAdapter.#round(
+                Number(owner?.y || 0) - Number(board?.centerY || 0)
+            )
+        }
+    }
+
     /**
      * Builds carrier-base to owner-component assignments.
      * @param {object[]} componentBodies Source component-body rows.
@@ -187,6 +304,15 @@ export class AltiumScene3dShapeStackOwnerAdapter {
             AltiumScene3dShapeStackOwnerAdapter.#groupCarrierBases(bases)
 
         return groups.flatMap((group) => {
+            if (
+                AltiumScene3dShapeStackOwnerAdapter.#hasExactNonTimingOwner(
+                    group.anchor,
+                    components
+                )
+            ) {
+                return []
+            }
+
             const owners = timingComponents
                 .filter(
                     (component) =>
@@ -242,6 +368,39 @@ export class AltiumScene3dShapeStackOwnerAdapter {
         })
     }
 
+    /**
+     * Checks whether one carrier base already sits on a non-timing component.
+     * @param {{ x?: number, y?: number }} anchor Carrier base anchor.
+     * @param {object[]} components Source components.
+     * @returns {boolean}
+     */
+    static #hasExactNonTimingOwner(anchor, components) {
+        const exactOwners = (
+            Array.isArray(components) ? components : []
+        ).filter(
+            (component) =>
+                AltiumScene3dShapeStackOwnerAdapter.#distance(
+                    anchor,
+                    component
+                ) <=
+                AltiumScene3dShapeStackOwnerAdapter.#EXACT_OWNER_TOLERANCE_MIL
+        )
+
+        return (
+            exactOwners.some(
+                (component) =>
+                    !AltiumScene3dShapeStackOwnerAdapter.#isTimingComponent(
+                        component
+                    )
+            ) &&
+            !exactOwners.some((component) =>
+                AltiumScene3dShapeStackOwnerAdapter.#isTimingComponent(
+                    component
+                )
+            )
+        )
+    }
+
     /**
      * Groups carrier bases that share one source anchor.
      * @param {object[]} bases Candidate carrier bases.
@@ -469,7 +628,11 @@ export class AltiumScene3dShapeStackOwnerAdapter {
         return (
             componentBodies
                 .filter(
-                    (componentBody) => !usedComponentBodies.has(componentBody)
+                    (componentBody) =>
+                        !usedComponentBodies.has(componentBody) &&
+                        !AltiumScene3dShapeStackOwnerAdapter.#isCarrierBase(
+                            componentBody
+                        )
                 )
                 .map((componentBody) => ({
                     componentBody,
@@ -551,15 +714,9 @@ export class AltiumScene3dShapeStackOwnerAdapter {
         return (
             TIMING_DESIGNATOR_PATTERN.test(designator) ||
             TIMING_PACKAGE_PATTERN.test(
-                [
-                    component?.pattern,
-                    component?.source,
-                    component?.description,
-                    component?.provenance?.footprintDescription,
-                    ...Object.values(component?.parameters || {})
-                ]
-                    .map((value) => String(value || ''))
-                    .join(' ')
+                AltiumScene3dShapeStackOwnerAdapter.#timingIdentityText(
+                    component
+                )
             )
         )
     }
@@ -612,6 +769,19 @@ export class AltiumScene3dShapeStackOwnerAdapter {
         return layer.includes('BOTTOM') || layer === 'BOT' ? 'bottom' : 'top'
     }
 
+    /**
+     * Normalizes a static placement side token.
+     * @param {string | undefined} mountSide Candidate mount side.
+     * @returns {'top' | 'bottom'}
+     */
+    static #normalizeMountSide(mountSide) {
+        return String(mountSide || 'top')
+            .trim()
+            .toLowerCase() === 'bottom'
+            ? 'bottom'
+            : 'top'
+    }
+
     /**
      * Resolves one board face Z coordinate.
      * @param {string} mountSide Mount side.
@@ -691,6 +861,44 @@ export class AltiumScene3dShapeStackOwnerAdapter {
             .join(' ')
     }
 
+    /**
+     * Builds timing-relevant identity text without material metadata.
+     * @param {object} component Source component.
+     * @returns {string}
+     */
+    static #timingIdentityText(component) {
+        return [
+            component?.pattern,
+            component?.source,
+            component?.description,
+            component?.provenance?.footprintDescription,
+            ...AltiumScene3dShapeStackOwnerAdapter.#timingParameterValues(
+                component?.parameters
+            )
+        ]
+            .map((value) => String(value || ''))
+            .join(' ')
+    }
+
+    /**
+     * Returns parameter values whose names describe component identity.
+     * @param {object | undefined} parameters Source component parameters.
+     * @returns {unknown[]}
+     */
+    static #timingParameterValues(parameters) {
+        if (!parameters || typeof parameters !== 'object') {
+            return []
+        }
+
+        return Object.entries(parameters)
+            .filter(([key]) =>
+                AltiumScene3dShapeStackOwnerAdapter.#TIMING_PARAMETER_NAME_PATTERN.test(
+                    String(key || '')
+                )
+            )
+            .map(([, value]) => value)
+    }
+
     /**
      * Rounds one mil value for stable scene output.
      * @param {number} value Candidate value.