altium-toolkit 1.0.10 → 1.1.1

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

@@ -8,6 +8,68 @@ import { CircuitJsonModelAdapterPcbElements } from './CircuitJsonModelAdapterPcb
 
 const Primitives = CircuitJsonModelAdapterPrimitives
 const PcbElements = CircuitJsonModelAdapterPcbElements
+const ALTIUM_TOOLKIT_SIDECARS = [
+    {
+        type: 'altium_toolkit_pcb_layer_stack',
+        paths: [['pcb', 'layerStackReadModel']],
+        schema: 'altium-toolkit.pcb.layer-stack.a1'
+    },
+    {
+        type: 'altium_toolkit_pcb_rigid_flex_topology',
+        paths: [['pcb', 'rigidFlexTopology']],
+        schema: 'altium-toolkit.pcb.rigid-flex-topology.a1'
+    },
+    {
+        type: 'altium_toolkit_pcb_review_metadata',
+        paths: [['pcb', 'reviewMetadata']],
+        schema: 'altium-toolkit.pcb.review-metadata.a1'
+    },
+    {
+        type: 'altium_toolkit_pcb_placed_footprint_extraction',
+        paths: [['pcb', 'footprintExtractionManifest']],
+        schema: 'altium-toolkit.pcb.placed-footprint-extraction.a1'
+    },
+    {
+        type: 'altium_toolkit_pcblib_parity',
+        paths: [['pcbLibrary', 'parityReport']],
+        schema: 'altium-toolkit.pcblib.parity.a1'
+    },
+    {
+        type: 'altium_toolkit_project_outjob_digest',
+        paths: [['project', 'outJobDigest']],
+        schema: 'altium-toolkit.project.outjob-digest.a1'
+    },
+    {
+        type: 'altium_toolkit_project_document_graph',
+        paths: [['project', 'documentGraph'], ['documentGraph']],
+        schema: 'altium-toolkit.project.document-graph.a1'
+    },
+    {
+        type: 'altium_toolkit_project_bom_pnp_reconciliation',
+        paths: [['reconciliation']],
+        schema: 'altium-toolkit.project.bom-pnp-reconciliation.a1'
+    },
+    {
+        type: 'altium_toolkit_draftsman_image_payloads',
+        paths: [['draftsman', 'imagePayloads']],
+        schema: 'altium-toolkit.draftsman.image-payloads.a1'
+    },
+    {
+        type: 'altium_toolkit_draftsman_board_view_metadata',
+        paths: [['draftsman', 'boardViewMetadata']],
+        schema: 'altium-toolkit.draftsman.board-view-cache.a1'
+    },
+    {
+        type: 'altium_toolkit_contract_gate',
+        paths: [['contractGate']],
+        schema: 'altium-toolkit.contract-gate.a1'
+    },
+    {
+        type: 'altium_toolkit_host_capabilities',
+        paths: [['hostCapabilities']],
+        schema: 'altium-toolkit.host-capabilities.a1'
+    }
+]
 
 /**
  * Converts between legacy renderer models and Circuit JSON element arrays.
@@ -55,6 +117,7 @@ export class CircuitJsonModelAdapter {
         }
 
         CircuitJsonModelAdapter.#appendBom(circuitJson, model, idScope)
+        CircuitJsonModelAdapter.#appendSidecars(circuitJson, model, idScope)
         CircuitJsonModelAdapter.#attachCompatibility(circuitJson, model)
 
         return CircuitJsonModelSchema.attach(circuitJson)
@@ -651,6 +714,107 @@ export class CircuitJsonModelAdapter {
         }
     }
 
+    /**
+     * Appends serialized Altium Toolkit sidecar elements.
+     * @param {object[]} circuitJson
+     * @param {Record<string, unknown>} model
+     * @param {string} idScope
+     * @returns {void}
+     */
+    static #appendSidecars(circuitJson, model, idScope) {
+        for (const descriptor of ALTIUM_TOOLKIT_SIDECARS) {
+            const payload = CircuitJsonModelAdapter.#sidecarPayload(
+                model,
+                descriptor.paths
+            )
+            if (!payload) continue
+
+            circuitJson.push(
+                CircuitJsonModelAdapter.#sidecarElement(
+                    descriptor,
+                    payload,
+                    model,
+                    idScope
+                )
+            )
+        }
+    }
+
+    /**
+     * Builds one custom Altium Toolkit Circuit JSON sidecar element.
+     * @param {{ type: string, schema: string }} descriptor
+     * @param {Record<string, unknown>} payload
+     * @param {Record<string, unknown>} model
+     * @param {string} idScope
+     * @returns {object}
+     */
+    static #sidecarElement(descriptor, payload, model, idScope) {
+        return {
+            type: descriptor.type,
+            altium_toolkit_sidecar_id: Primitives.id(idScope, [
+                'altium_toolkit_sidecar',
+                descriptor.type
+            ]),
+            source_document: CircuitJsonModelAdapter.#sourceDocument(model),
+            schema: Primitives.string(payload.schema, descriptor.schema),
+            payload
+        }
+    }
+
+    /**
+     * Returns the first available sidecar payload from candidate model paths.
+     * @param {Record<string, unknown>} model
+     * @param {string[][]} paths
+     * @returns {Record<string, unknown> | null}
+     */
+    static #sidecarPayload(model, paths) {
+        for (const path of paths) {
+            const payload = CircuitJsonModelAdapter.#valueAtPath(model, path)
+            if (CircuitJsonModelAdapter.#isSidecarPayload(payload)) {
+                return payload
+            }
+        }
+        return null
+    }
+
+    /**
+     * Returns a nested object value.
+     * @param {Record<string, unknown>} value
+     * @param {string[]} path
+     * @returns {unknown}
+     */
+    static #valueAtPath(value, path) {
+        return path.reduce(
+            (current, key) =>
+                current && typeof current === 'object'
+                    ? current[key]
+                    : undefined,
+            value
+        )
+    }
+
+    /**
+     * Returns true when a value can be serialized as a sidecar payload.
+     * @param {unknown} value
+     * @returns {value is Record<string, unknown>}
+     */
+    static #isSidecarPayload(value) {
+        return !!value && typeof value === 'object' && !Array.isArray(value)
+    }
+
+    /**
+     * Builds the source document identity for sidecar elements.
+     * @param {Record<string, unknown>} model
+     * @returns {{ kind: string, file_type: string, file_name: string }}
+     */
+    static #sourceDocument(model) {
+        return {
+            kind: Primitives.string(model.kind, 'document'),
+            file_type: Primitives.string(model.fileType, ''),
+            file_name: Primitives.string(model.fileName, '')
+        }
+    }
+
     /**
      * Appends one schematic line or trace.
      * @param {object[]} circuitJson

package/src/parser.mjs

@@ -9,12 +9,16 @@ export { OleDirectoryEntry } from './core/ole/OleDirectoryEntry.mjs'
 export { AltiumParser } from './core/altium/AltiumParser.mjs'
 export { AltiumLayoutParser } from './core/altium/AltiumLayoutParser.mjs'
 export { AsciiRecordParser } from './core/altium/AsciiRecordParser.mjs'
+export { HostCapabilityDiagnosticsBuilder } from './core/altium/HostCapabilityDiagnosticsBuilder.mjs'
 export { IntLibModelParser } from './core/altium/IntLibModelParser.mjs'
 export { IntLibStreamExtractor } from './core/altium/IntLibStreamExtractor.mjs'
 export { EmbeddedFileInventoryBuilder } from './core/altium/EmbeddedFileInventoryBuilder.mjs'
 export { CiArtifactBundleBuilder } from './core/altium/CiArtifactBundleBuilder.mjs'
+export { ContractGateReportBuilder } from './core/altium/ContractGateReportBuilder.mjs'
+export { DraftsmanBoardViewMetadataBuilder } from './core/altium/DraftsmanBoardViewMetadataBuilder.mjs'
 export { DraftsmanDigestParser } from './core/altium/DraftsmanDigestParser.mjs'
 export { LibraryRenderManifestBuilder } from './core/altium/LibraryRenderManifestBuilder.mjs'
+export { LibraryQaReportBuilder } from './core/altium/LibraryQaReportBuilder.mjs'
 export { LibrarySearchIndex } from './core/altium/LibrarySearchIndex.mjs'
 export { ParserUtils } from './core/altium/ParserUtils.mjs'
 export { ParserCompatibilityFuzzer } from './core/altium/ParserCompatibilityFuzzer.mjs'
@@ -27,7 +31,9 @@ export { ProjectVariantViewBuilder } from './core/altium/ProjectVariantViewBuild
 export { CircuitJsonModelSchema } from './core/circuit-json/CircuitJsonModelSchema.mjs'
 export { CircuitJsonModelAdapter } from './core/circuit-json/CircuitJsonModelAdapter.mjs'
 export { PcbBinaryPrimitiveParser } from './core/altium/PcbBinaryPrimitiveParser.mjs'
+export { PcbBomProfileBuilder } from './core/altium/PcbBomProfileBuilder.mjs'
 export { PcbBoardRegionSemanticsParser } from './core/altium/PcbBoardRegionSemanticsParser.mjs'
+export { PcbComponentKindPolicy } from './core/altium/PcbComponentKindPolicy.mjs'
 export { PcbComponentPrimitiveIndexer } from './core/altium/PcbComponentPrimitiveIndexer.mjs'
 export { PcbCustomPadShapeParser } from './core/altium/PcbCustomPadShapeParser.mjs'
 export { PcbDimensionParser } from './core/altium/PcbDimensionParser.mjs'
@@ -36,7 +42,11 @@ export { PcbEmbeddedModelExtractor } from './core/altium/PcbEmbeddedModelExtract
 export { PcbExtendedPrimitiveInformationParser } from './core/altium/PcbExtendedPrimitiveInformationParser.mjs'
 export { PcbFontMetricsParser } from './core/altium/PcbFontMetricsParser.mjs'
 export { PcbLayerIdCodec } from './core/altium/PcbLayerIdCodec.mjs'
+export { PcbLayerStackFidelityReportBuilder } from './core/altium/PcbLayerStackFidelityReportBuilder.mjs'
+export { PcbLayerStackInterchangeParser } from './core/altium/PcbLayerStackInterchangeParser.mjs'
+export { PcbLayerStackQueryHelper } from './core/altium/PcbLayerStackQueryHelper.mjs'
 export { PcbLibModelParser } from './core/altium/PcbLibModelParser.mjs'
+export { PcbLibParityReportBuilder } from './core/altium/PcbLibParityReportBuilder.mjs'
 export { PcbLibStreamExtractor } from './core/altium/PcbLibStreamExtractor.mjs'
 export { PcbMechanicalLayerPairParser } from './core/altium/PcbMechanicalLayerPairParser.mjs'
 export { PcbModelParser } from './core/altium/PcbModelParser.mjs'
@@ -44,8 +54,11 @@ export { PcbOutlineRasterizer } from './core/altium/PcbOutlineRasterizer.mjs'
 export { PcbOutlineRecovery } from './core/altium/PcbOutlineRecovery.mjs'
 export { PcbOwnershipGraphBuilder } from './core/altium/PcbOwnershipGraphBuilder.mjs'
 export { PcbPadStackParser } from './core/altium/PcbPadStackParser.mjs'
+export { PcbPlacedFootprintManifestBuilder } from './core/altium/PcbPlacedFootprintManifestBuilder.mjs'
 export { PcbPickPlacePositionResolver } from './core/altium/PcbPickPlacePositionResolver.mjs'
+export { PcbPolygonRecordParser } from './core/altium/PcbPolygonRecordParser.mjs'
 export { PcbRawRecordRegistry } from './core/altium/PcbRawRecordRegistry.mjs'
+export { PcbReviewMetadataBuilder } from './core/altium/PcbReviewMetadataBuilder.mjs'
 export { PcbRouteAnalysisBuilder } from './core/altium/PcbRouteAnalysisBuilder.mjs'
 export { PcbRuleParser } from './core/altium/PcbRuleParser.mjs'
 export { PcbSidecarRecordParser } from './core/altium/PcbSidecarRecordParser.mjs'
@@ -57,6 +70,8 @@ export { PcbViaStackParser } from './core/altium/PcbViaStackParser.mjs'
 export { PcbViaStructureParser } from './core/altium/PcbViaStructureParser.mjs'
 export { PrintableTextDecoder } from './core/altium/PrintableTextDecoder.mjs'
 export { PrjPcbModelParser } from './core/altium/PrjPcbModelParser.mjs'
+export { PrjScrModelParser } from './core/altium/PrjScrModelParser.mjs'
+export { ProjectBomPnpReconciliationBuilder } from './core/altium/ProjectBomPnpReconciliationBuilder.mjs'
 export { SchematicMultipartOwnerMatcher } from './core/altium/SchematicMultipartOwnerMatcher.mjs'
 export { SchematicCrossSheetConnectorParser } from './core/altium/SchematicCrossSheetConnectorParser.mjs'
 export { SchematicHarnessParser } from './core/altium/SchematicHarnessParser.mjs'

package/src/ui/PcbEdgeFacingGlyphNormalizer.mjs

@@ -14,6 +14,8 @@ export class PcbEdgeFacingGlyphNormalizer {
     static #EDGE_GLYPH_CENTER_TOLERANCE = 1.5
     static #EDGE_GLYPH_PROXIMITY_RATIO = 0.2
     static #MARKER_PROXIMITY_MULTIPLIER = 3
+    static #SPATIAL_INDEX_MIN_CELL_SIZE = 32
+    static #SPATIAL_INDEX_MAX_CELLS_PER_ITEM = 256
 
     /**
      * Normalizes repeated edge-facing documentation glyphs so their opening
@@ -107,6 +109,8 @@ export class PcbEdgeFacingGlyphNormalizer {
                 )
         ]
         const visited = new Array(items.length).fill(false)
+        const spatialIndex =
+            PcbEdgeFacingGlyphNormalizer.#buildSpatialIndex(items)
         const groups = []
 
         for (let index = 0; index < items.length; index += 1) {
@@ -137,11 +141,10 @@ export class PcbEdgeFacingGlyphNormalizer {
                     arcIndexes.push(currentItem.arcIndex)
                 }
 
-                for (
-                    let nextIndex = 0;
-                    nextIndex < items.length;
-                    nextIndex += 1
-                ) {
+                for (const nextIndex of PcbEdgeFacingGlyphNormalizer.#collectCandidateIndexes(
+                    currentItem.bounds,
+                    spatialIndex
+                )) {
                     if (visited[nextIndex]) {
                         continue
                     }
@@ -171,6 +174,153 @@ export class PcbEdgeFacingGlyphNormalizer {
         return groups
     }
 
+    /**
+     * Builds a spatial lookup for candidate bounds intersections.
+     * @param {{ bounds: { minX: number, maxX: number, minY: number, maxY: number } }[]} items
+     * @returns {{ cellSize: number, cells: Map<string, number[]>, overflowIndexes: number[], marks: Uint32Array, mark: number }}
+     */
+    static #buildSpatialIndex(items) {
+        const cellSize =
+            PcbEdgeFacingGlyphNormalizer.#resolveSpatialCellSize(items)
+        const cells = new Map()
+        const overflowIndexes = []
+
+        items.forEach((item, index) => {
+            const range = PcbEdgeFacingGlyphNormalizer.#resolveCellRange(
+                item.bounds,
+                cellSize
+            )
+            const cellCount =
+                (range.maxX - range.minX + 1) * (range.maxY - range.minY + 1)
+
+            if (
+                cellCount >
+                PcbEdgeFacingGlyphNormalizer.#SPATIAL_INDEX_MAX_CELLS_PER_ITEM
+            ) {
+                overflowIndexes.push(index)
+                return
+            }
+
+            for (let cellX = range.minX; cellX <= range.maxX; cellX += 1) {
+                for (let cellY = range.minY; cellY <= range.maxY; cellY += 1) {
+                    const key = PcbEdgeFacingGlyphNormalizer.#cellKey(
+                        cellX,
+                        cellY
+                    )
+                    const bucket = cells.get(key)
+
+                    if (bucket) {
+                        bucket.push(index)
+                    } else {
+                        cells.set(key, [index])
+                    }
+                }
+            }
+        })
+
+        return {
+            cellSize,
+            cells,
+            overflowIndexes,
+            marks: new Uint32Array(items.length),
+            mark: 0
+        }
+    }
+
+    /**
+     * Collects unique candidate item indexes that could intersect one bounds box.
+     * @param {{ minX: number, maxX: number, minY: number, maxY: number }} bounds
+     * @param {{ cellSize: number, cells: Map<string, number[]>, overflowIndexes: number[], marks: Uint32Array, mark: number }} spatialIndex
+     * @returns {number[]}
+     */
+    static #collectCandidateIndexes(bounds, spatialIndex) {
+        const candidates = []
+        const range = PcbEdgeFacingGlyphNormalizer.#resolveCellRange(
+            bounds,
+            spatialIndex.cellSize
+        )
+
+        spatialIndex.mark += 1
+        if (spatialIndex.mark >= 0xffffffff) {
+            spatialIndex.marks.fill(0)
+            spatialIndex.mark = 1
+        }
+
+        const appendCandidate = (index) => {
+            if (spatialIndex.marks[index] === spatialIndex.mark) {
+                return
+            }
+
+            spatialIndex.marks[index] = spatialIndex.mark
+            candidates.push(index)
+        }
+
+        for (let cellX = range.minX; cellX <= range.maxX; cellX += 1) {
+            for (let cellY = range.minY; cellY <= range.maxY; cellY += 1) {
+                const bucket = spatialIndex.cells.get(
+                    PcbEdgeFacingGlyphNormalizer.#cellKey(cellX, cellY)
+                )
+
+                if (bucket) {
+                    bucket.forEach(appendCandidate)
+                }
+            }
+        }
+
+        spatialIndex.overflowIndexes.forEach(appendCandidate)
+        return candidates
+    }
+
+    /**
+     * Resolves a spatial cell size from typical primitive bounds spans.
+     * @param {{ bounds: { minX: number, maxX: number, minY: number, maxY: number } }[]} items
+     * @returns {number}
+     */
+    static #resolveSpatialCellSize(items) {
+        const spans = items
+            .map((item) =>
+                Math.max(
+                    Number(item.bounds.maxX) - Number(item.bounds.minX),
+                    Number(item.bounds.maxY) - Number(item.bounds.minY),
+                    0
+                )
+            )
+            .filter((span) => Number.isFinite(span))
+            .sort((left, right) => left - right)
+        const medianSpan = spans[Math.floor(spans.length / 2)] || 0
+
+        return Math.max(
+            medianSpan * 4,
+            PcbEdgeFacingGlyphNormalizer.#EDGE_GLYPH_CONNECTION_TOLERANCE * 8,
+            PcbEdgeFacingGlyphNormalizer.#SPATIAL_INDEX_MIN_CELL_SIZE
+        )
+    }
+
+    /**
+     * Resolves the inclusive grid-cell range for one bounds box.
+     * @param {{ minX: number, maxX: number, minY: number, maxY: number }} bounds
+     * @param {number} cellSize
+     * @returns {{ minX: number, maxX: number, minY: number, maxY: number }}
+     */
+    static #resolveCellRange(bounds, cellSize) {
+        return {
+            minX: Math.floor(Number(bounds.minX) / cellSize),
+            maxX: Math.floor(Number(bounds.maxX) / cellSize),
+            minY: Math.floor(Number(bounds.minY) / cellSize),
+            maxY: Math.floor(Number(bounds.maxY) / cellSize)
+        }
+    }
+
+    /**
+     * Builds one deterministic spatial index key.
+     * @param {number} cellX
+     * @param {number} cellY
+     * @returns {string}
+     */
+    static #cellKey(cellX, cellY) {
+        return `${cellX}:${cellY}`
+    }
+
     /**
      * Resolves whether one connected screw glyph needs its semicircular head
      * moved onto the same side as the screw tip while keeping the authored

package/src/ui/PcbFootprintPrimitiveSelector.mjs

@@ -141,9 +141,21 @@ export class PcbFootprintPrimitiveSelector {
      * @returns {boolean}
      */
     static #includesLayerName(layerName, needle) {
+        return PcbFootprintPrimitiveSelector.#compactLayerName(
+            layerName
+        ).includes(PcbFootprintPrimitiveSelector.#compactLayerName(needle))
+    }
+
+    /**
+     * Normalizes layer labels so compact names such as TopOverlay match
+     * spaced Altium labels such as Top Overlay.
+     * @param {string} layerName
+     * @returns {string}
+     */
+    static #compactLayerName(layerName) {
         return String(layerName || '')
             .trim()
             .toUpperCase()
-            .includes(needle)
+            .replace(/[^A-Z0-9]/g, '')
     }
 }

package/src/ui/PcbScene3dBuilder.mjs

@@ -986,16 +986,38 @@ export class PcbScene3dBuilder {
         return new Set(
             (Array.isArray(primitiveLayers) ? primitiveLayers : [])
                 .filter((layer) =>
-                    String(layer?.name || '')
-                        .trim()
-                        .toUpperCase()
-                        .includes(needle)
+                    PcbScene3dBuilder.#includesLayerName(layer?.name, needle)
                 )
                 .map((layer) => Number(layer.layerId))
                 .filter((layerId) => Number.isInteger(layerId))
         )
     }
 
+    /**
+     * Returns true when one layer name matches a spaced or compact target.
+     * @param {string} layerName
+     * @param {string} needle
+     * @returns {boolean}
+     */
+    static #includesLayerName(layerName, needle) {
+        return PcbScene3dBuilder.#compactLayerName(layerName).includes(
+            PcbScene3dBuilder.#compactLayerName(needle)
+        )
+    }
+
+    /**
+     * Normalizes layer labels so compact names such as TopOverlay match
+     * spaced Altium labels such as Top Overlay.
+     * @param {string} layerName
+     * @returns {string}
+     */
+    static #compactLayerName(layerName) {
+        return String(layerName || '')
+            .trim()
+            .toUpperCase()
+            .replace(/[^A-Z0-9]/g, '')
+    }
+
     /**
      * Normalizes one Altium overlay text into the runtime stroke-text shape.
      * @param {{ text?: string, value?: string, x?: number, y?: number, height?: number, strokeWidth?: number, rotation?: number, mirrored?: boolean | number | string, isMirrored?: boolean | number | string, mirrorFlag?: boolean | number | string, Mirrored?: boolean | number | string, IsMirrored?: boolean | number | string, MirrorFlag?: boolean | number | string, layerId?: number }} text