altium-toolkit 1.1.32 → 1.1.35

package/src/core/altium/PcbShapeBasedBodyGeometryParser.mjs

@@ -121,10 +121,11 @@ export class PcbShapeBasedBodyGeometryParser {
         }
 
         const textBytes = bytes.subarray(offset + 22, offset + 22 + textLength)
-        const text = PrintableTextDecoder.decodeBytes(textBytes).replaceAll(
-            '\u0000',
-            ''
-        )
+        const payload =
+            PcbShapeBasedBodyGeometryParser.#splitInlineVertexPayload(textBytes)
+        const text = PrintableTextDecoder.decodeBytes(
+            payload.fieldBytes
+        ).replaceAll('\u0000', '')
 
         if (
             !text.includes('MODEL.') ||
@@ -133,11 +134,17 @@ export class PcbShapeBasedBodyGeometryParser {
             return null
         }
 
-        const fields =
-            PcbShapeBasedBodyGeometryParser.#parseFieldRecordBytes(textBytes)
+        const fields = PcbShapeBasedBodyGeometryParser.#parseFieldRecordBytes(
+            payload.fieldBytes
+        )
+        const textEndOffset = offset + 22 + textLength
+        const vertexBlockOffset =
+            payload.inlineVertexBlockOffset === null
+                ? textEndOffset
+                : offset + 22 + payload.inlineVertexBlockOffset
         const vertexBlock = PcbShapeBasedBodyGeometryParser.#parseVertexBlock(
             bytes,
-            offset + 22 + textLength
+            vertexBlockOffset
         )
 
         return {
@@ -146,13 +153,80 @@ export class PcbShapeBasedBodyGeometryParser {
                 fields,
                 vertexBlock.verticesMil
             ),
-            nextOffset:
-                vertexBlock.nextOffset > offset
-                    ? vertexBlock.nextOffset
-                    : offset + 22 + textLength
+            nextOffset: Math.max(vertexBlock.nextOffset, textEndOffset)
+        }
+    }
+
+    /**
+     * Splits printable fields from Altium records whose text length also
+     * covers an inline binary vertex block after a NUL terminator.
+     * @param {Uint8Array} textBytes Declared text payload bytes.
+     * @returns {{ fieldBytes: Uint8Array, inlineVertexBlockOffset: number | null }}
+     */
+    static #splitInlineVertexPayload(textBytes) {
+        const inlineVertexBlockOffset =
+            PcbShapeBasedBodyGeometryParser.#inlineVertexBlockOffset(textBytes)
+        if (inlineVertexBlockOffset === null) {
+            return { fieldBytes: textBytes, inlineVertexBlockOffset: null }
+        }
+
+        return {
+            fieldBytes: textBytes.subarray(0, inlineVertexBlockOffset - 1),
+            inlineVertexBlockOffset
         }
     }
 
+    /**
+     * Finds the inline vertex-count offset inside a declared text payload.
+     * @param {Uint8Array} textBytes Declared text payload bytes.
+     * @returns {number | null}
+     */
+    static #inlineVertexBlockOffset(textBytes) {
+        for (let index = 0; index < textBytes.byteLength; index += 1) {
+            if (textBytes[index] !== 0) {
+                continue
+            }
+
+            const vertexBlockOffset = index + 1
+            if (
+                PcbShapeBasedBodyGeometryParser.#hasPlausibleVertexBlock(
+                    textBytes,
+                    vertexBlockOffset
+                )
+            ) {
+                return vertexBlockOffset
+            }
+        }
+
+        return null
+    }
+
+    /**
+     * Checks whether one byte offset points to a complete vertex block.
+     * @param {Uint8Array} bytes Candidate payload bytes.
+     * @param {number} offset Candidate vertex-count offset.
+     * @returns {boolean}
+     */
+    static #hasPlausibleVertexBlock(bytes, offset) {
+        if (offset + 4 > bytes.byteLength) {
+            return false
+        }
+
+        const view = new DataView(
+            bytes.buffer,
+            bytes.byteOffset,
+            bytes.byteLength
+        )
+        const vertexCount = view.getInt32(offset, true)
+        const dataOffset = offset + 4
+
+        return (
+            vertexCount >= 3 &&
+            vertexCount <= 10000 &&
+            dataOffset + vertexCount * 37 <= bytes.byteLength
+        )
+    }
+
     /**
      * Parses the optional coordinate block after a shape-body field record.
      * @param {Uint8Array} bytes Stream bytes.

package/src/core/altium/SourceComponentBundleNormalizer.mjs

@@ -137,10 +137,25 @@ export class SourceComponentBundleNormalizer {
             primitives: SourceComponentBundleNormalizer.#array(
                 footprint.primitives || footprint.shapes
             ),
+            component:
+                SourceComponentBundleNormalizer.#normalizeFootprintComponent(
+                    footprint.component || source.component
+                ),
             raw: footprint
         }
     }
 
+    /**
+     * Preserves source footprint component placement metadata for exporters.
+     * @param {object | undefined} component Source component placement.
+     * @returns {object}
+     */
+    static #normalizeFootprintComponent(component) {
+        return component && typeof component === 'object'
+            ? { ...component }
+            : {}
+    }
+
     /**
      * Normalizes model asset descriptors.
      * @param {object} source Unwrapped response.
@@ -177,6 +192,8 @@ export class SourceComponentBundleNormalizer {
         )
         const bytes =
             SourceComponentBundleNormalizer.#normalizeModelBytes(model)
+        const transform =
+            SourceComponentBundleNormalizer.#normalizeModelTransform(model)
 
         return {
             id: SourceComponentBundleNormalizer.#firstString(
@@ -199,10 +216,24 @@ export class SourceComponentBundleNormalizer {
                 model.downloadUrl,
                 model.sourceUrl
             ),
+            ...(transform ? { transform } : {}),
+            ...(model.generated === true ? { generated: true } : {}),
             raw: model
         }
     }
 
+    /**
+     * Preserves optional model placement transforms.
+     * @param {object} model Raw model asset.
+     * @returns {object | null}
+     */
+    static #normalizeModelTransform(model) {
+        const transform = model.transform || model.modelTransform || null
+        return transform && typeof transform === 'object'
+            ? { ...transform }
+            : null
+    }
+
     /**
      * Normalizes one model payload into bytes.
      * @param {object} model Raw model asset.

package/src/core/circuit-json/CircuitJsonModelSchema.mjs

@@ -6,7 +6,7 @@
  * Defines the Circuit JSON contract emitted by public parser roots.
  */
 export class CircuitJsonModelSchema {
-    static CURRENT_SCHEMA_ID = 'https://github.com/tscircuit/circuit-json'
+    static CURRENT_SCHEMA_ID = 'urn:altium-toolkit:circuit-json:0.0.433'
 
     static CURRENT_SCHEMA_VERSION = '0.0.433'
 

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

@@ -89,6 +89,14 @@ export class AltiumScene3dExternalPlacementAdapter {
         if (!placement?.bodyPositionMil || !placement?.positionMil) {
             return placement
         }
+        if (
+            AltiumScene3dExternalPlacementAdapter.#isAuthoredShapeStackPlacement(
+                placement
+            )
+        ) {
+            return placement
+        }
+
         const componentBody =
             AltiumScene3dExternalPlacementAdapter.#resolveComponentBody(
                 placement,
@@ -282,6 +290,19 @@ export class AltiumScene3dExternalPlacementAdapter {
         }
     }
 
+    /**
+     * Checks whether an earlier adapter already resolved an authored carrier
+     * stack placement.
+     * @param {object} placement External model placement.
+     * @returns {boolean}
+     */
+    static #isAuthoredShapeStackPlacement(placement) {
+        return (
+            String(placement?.projection?.source || '').toLowerCase() ===
+            'authored-shape-stack'
+        )
+    }
+
     /**
      * Resolves board-local SMT pad centers for mixed connector footprints.
      * @param {object} placement External model placement.
@@ -731,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
         )