altium-toolkit 1.1.22 → 1.1.23

package/src/core/altium/PcbStreamExtractor.mjs

@@ -4,6 +4,7 @@
 
 import { AsciiRecordParser } from './AsciiRecordParser.mjs'
 import { EmbeddedFileInventoryBuilder } from './EmbeddedFileInventoryBuilder.mjs'
+import { NativeStreamInventoryBuilder } from './NativeStreamInventoryBuilder.mjs'
 import { PcbBinaryPrimitiveParser } from './PcbBinaryPrimitiveParser.mjs'
 import { PcbCustomPadShapeParser } from './PcbCustomPadShapeParser.mjs'
 import { PcbEmbeddedFontExtractor } from './PcbEmbeddedFontExtractor.mjs'
@@ -11,12 +12,45 @@ import { PcbEmbeddedModelExtractor } from './PcbEmbeddedModelExtractor.mjs'
 import { PcbExtendedPrimitiveInformationParser } from './PcbExtendedPrimitiveInformationParser.mjs'
 import { PcbPrimitiveParameterParser } from './PcbPrimitiveParameterParser.mjs'
 import { PcbRawRecordRegistry } from './PcbRawRecordRegistry.mjs'
+import { PcbSidecarRecordParser } from './PcbSidecarRecordParser.mjs'
 import { PcbUnionParser } from './PcbUnionParser.mjs'
 import { PcbViaStructureParser } from './PcbViaStructureParser.mjs'
 import { PcbWideStringTableParser } from './PcbWideStringTableParser.mjs'
 import { OleCompoundDocument } from '../ole/OleCompoundDocument.mjs'
 import { OleConstants } from '../ole/OleConstants.mjs'
 
+const KNOWN_PCB_STREAM_STORAGES = new Set([
+    'Board6',
+    'Nets6',
+    'Arcs6',
+    'Pads6',
+    'Vias6',
+    'Tracks6',
+    'Texts',
+    'Texts6',
+    'Fills6',
+    'Regions6',
+    'ShapeBasedRegions6',
+    'BoardRegions',
+    'ComponentBodies6',
+    'Polygons6',
+    'Components6',
+    'Classes6',
+    'DifferentialPairs6',
+    'EmbeddedBoards6',
+    'Rooms6',
+    'Rules6',
+    'WideStrings6',
+    'PrimitiveParameters',
+    'ViaStructures',
+    'ViaStructureManager',
+    'ExtendedPrimitiveInformation',
+    'CustomShapes',
+    'UnionNames',
+    'SmartUnions',
+    'Models'
+])
+
 /**
  * Extracts stream-scoped printable and binary PCB content from OLE-backed
  * PcbDoc containers.
@@ -99,12 +133,15 @@ export class PcbStreamExtractor {
                 continue
             }
 
-            const recordBuffer = PcbStreamExtractor.#toArrayBuffer(bytes)
-            const streamRecords = AsciiRecordParser.parse(recordBuffer).map(
-                (record) => ({
-                    ...record,
-                    sourceStream: name
-                })
+            if (
+                PcbStreamExtractor.#isSupersededLegacyDataStream(name, streams)
+            ) {
+                continue
+            }
+
+            const streamRecords = PcbStreamExtractor.#parseDataStreamRecords(
+                name,
+                bytes
             )
 
             if (!streamRecords.length) {
@@ -335,11 +372,23 @@ export class PcbStreamExtractor {
             usedStreamNames.add(diagnostic.sourceStream)
         )
 
+        const nativeStreams = NativeStreamInventoryBuilder.buildFromStreams(
+            streams,
+            {
+                source: 'pcbdoc',
+                consumedStreamNames: usedStreamNames,
+                knownStreamNames: [...streams.keys()].filter((streamName) =>
+                    PcbStreamExtractor.#isKnownNativeStream(streamName)
+                )
+            }
+        )
+
         return {
             records,
             streamNames: [...usedStreamNames].sort((left, right) =>
                 left.localeCompare(right)
             ),
+            nativeStreams,
             binaryPrimitives,
             primitiveParameters,
             wideStrings,
@@ -395,6 +444,38 @@ export class PcbStreamExtractor {
         )
     }
 
+    /**
+     * Parses a data stream as length-prefixed sidecar records when needed, with
+     * printable-record fallback for regular pipe-delimited streams.
+     * @param {string} name Stream path.
+     * @param {Uint8Array} bytes Stream bytes.
+     * @returns {Array<{ raw?: string, fields: Record<string, string | string[]>, sourceStream: string, recordIndex?: number }>}
+     */
+    static #parseDataStreamRecords(name, bytes) {
+        if (PcbStreamExtractor.#isLengthPrefixedPrintableStream(name)) {
+            const sidecarRecords =
+                PcbSidecarRecordParser.parseLengthPrefixedRecords(bytes, name)
+            if (sidecarRecords.length) {
+                return sidecarRecords
+            }
+        }
+
+        const recordBuffer = PcbStreamExtractor.#toArrayBuffer(bytes)
+        return AsciiRecordParser.parse(recordBuffer).map((record) => ({
+            ...record,
+            sourceStream: name
+        }))
+    }
+
+    /**
+     * Returns true for printable sidecar streams that may use length prefixes.
+     * @param {string} name Stream path.
+     * @returns {boolean}
+     */
+    static #isLengthPrefixedPrintableStream(name) {
+        return name === 'EmbeddedBoards6/Data' || name === 'Rooms6/Data'
+    }
+
     /**
      * Returns true for binary sidecar streams with printable-looking payloads.
      * @param {string} name
@@ -413,6 +494,34 @@ export class PcbStreamExtractor {
         )
     }
 
+    /**
+     * Returns true when a legacy printable stream has a versioned companion.
+     * @param {string} name Stream path.
+     * @param {Map<string, Uint8Array>} streams Source stream map.
+     * @returns {boolean}
+     */
+    static #isSupersededLegacyDataStream(name, streams) {
+        const suffix = '/Data'
+        if (!name.endsWith(suffix)) {
+            return false
+        }
+
+        const storagePath = name.slice(0, -suffix.length)
+        const separatorIndex = storagePath.lastIndexOf('/')
+        const parentPath =
+            separatorIndex >= 0 ? storagePath.slice(0, separatorIndex + 1) : ''
+        const storageName =
+            separatorIndex >= 0
+                ? storagePath.slice(separatorIndex + 1)
+                : storagePath
+
+        if (!storageName || /\d$/u.test(storageName)) {
+            return false
+        }
+
+        return streams.has(parentPath + storageName + '6' + suffix)
+    }
+
     /**
      * Collects sidecar source stream names that produced via-structure data.
      * @param {{ structures?: { sourceStream?: string }[], links?: { sourceStream?: string }[] }} viaStructures
@@ -437,4 +546,19 @@ export class PcbStreamExtractor {
             .map((record) => record.sourceStream)
             .filter(Boolean)
     }
+
+    /**
+     * Returns true when a native stream name belongs to a recognized PCB
+     * storage.
+     * @param {string} streamName Native stream name.
+     * @returns {boolean}
+     */
+    static #isKnownNativeStream(streamName) {
+        if (streamName === 'FileHeader') {
+            return true
+        }
+
+        const storageName = String(streamName || '').split('/')[0]
+        return KNOWN_PCB_STREAM_STORAGES.has(storageName)
+    }
 }

package/src/core/altium/PcbTrackPrimitiveParser.mjs

@@ -19,7 +19,7 @@ export class PcbTrackPrimitiveParser {
      * Decodes one track stream.
      * @param {Uint8Array | ArrayBuffer} headerBytes
      * @param {Uint8Array | ArrayBuffer} dataBytes
-     * @returns {{ x1: number, y1: number, x2: number, y2: number, width: number, componentIndex: number | null, netIndex: number | null, polygonIndex: number | null, layerCode: number, layerId: number }[]}
+     * @returns {{ x1: number, y1: number, x2: number, y2: number, width: number, componentIndex: number | null, netIndex: number | null, polygonIndex: number | null, layerCode: number, layerId: number, [key: string]: unknown }[]}
      */
     static parseTrackStream(headerBytes, dataBytes) {
         return PcbTrackPrimitiveParser.#sliceTrackRecords(
@@ -31,7 +31,7 @@ export class PcbTrackPrimitiveParser {
     /**
      * Decodes one track record view into a normalized primitive.
      * @param {DataView} view
-     * @returns {{ x1: number, y1: number, x2: number, y2: number, width: number, componentIndex: number | null, netIndex: number | null, polygonIndex: number | null, layerCode: number, layerId: number }}
+     * @returns {{ x1: number, y1: number, x2: number, y2: number, width: number, componentIndex: number | null, netIndex: number | null, polygonIndex: number | null, layerCode: number, layerId: number, [key: string]: unknown }}
      */
     static #parseTrackRecord(view) {
         const layerId = view.getUint8(0)
@@ -49,11 +49,61 @@ export class PcbTrackPrimitiveParser {
             y2: PcbTrackPrimitiveParser.#readMil(view, 25),
             width: PcbTrackPrimitiveParser.#readMil(view, 29),
             ...ownershipIndexes,
+            ...PcbTrackPrimitiveParser.#parseTrackMetadata(view),
             layerCode: layerId,
             layerId
         }
     }
 
+    /**
+     * Decodes optional route-state metadata from one track record.
+     * @param {DataView} view Track record view.
+     * @returns {{ trackFlags?: number, isSelected?: boolean, isLocked?: boolean, isPartOfComponent?: boolean, isKeepout?: boolean, unionIndex?: number, isLengthTuning?: boolean, isUserRouted?: boolean }}
+     */
+    static #parseTrackMetadata(view) {
+        const flags = PcbTrackPrimitiveParser.#readByteIfAvailable(view, 1)
+        const keepout = PcbTrackPrimitiveParser.#readByteIfAvailable(view, 2)
+        const unionIndex = PcbTrackPrimitiveParser.#readByteIfAvailable(
+            view,
+            36
+        )
+        const lengthTuning = PcbTrackPrimitiveParser.#readByteIfAvailable(
+            view,
+            37
+        )
+        const userRouted = PcbTrackPrimitiveParser.#readByteIfAvailable(
+            view,
+            44
+        )
+
+        if (!flags && !keepout && !unionIndex && !lengthTuning && !userRouted) {
+            return {}
+        }
+
+        const result = {}
+
+        if (flags) {
+            result.trackFlags = flags
+            result.isSelected = (flags & 0x01) !== 0
+            result.isLocked = (flags & 0x04) === 0
+            result.isPartOfComponent = (flags & 0x10) !== 0
+        }
+        if (keepout) {
+            result.isKeepout = true
+        }
+        if (unionIndex) {
+            result.unionIndex = unionIndex
+        }
+        if (lengthTuning) {
+            result.isLengthTuning = true
+        }
+        if (userRouted) {
+            result.isUserRouted = true
+        }
+
+        return result
+    }
+
     /**
      * Splits a track stream into record views, preserving variable payload
      * lengths when tracks are stored with object-id and payload-length
@@ -84,4 +134,18 @@ export class PcbTrackPrimitiveParser {
     static #readMil(view, offset) {
         return view.getInt32(offset, true) / 10000
     }
+
+    /**
+     * Reads one byte when it is present in a variable-length record.
+     * @param {DataView} view Record view.
+     * @param {number} offset Byte offset.
+     * @returns {number}
+     */
+    static #readByteIfAvailable(view, offset) {
+        if (!view || offset >= view.byteLength) {
+            return 0
+        }
+
+        return view.getUint8(offset)
+    }
 }

package/src/core/altium/ProjectDesignBundleBuilder.mjs

@@ -4,6 +4,7 @@
 
 import { NormalizedModelSchema } from './NormalizedModelSchema.mjs'
 import { ProjectBomPnpReconciliationBuilder } from './ProjectBomPnpReconciliationBuilder.mjs'
+import { ProjectHierarchyReportBuilder } from './ProjectHierarchyReportBuilder.mjs'
 import { ProjectVariantViewBuilder } from './ProjectVariantViewBuilder.mjs'
 
 /**
@@ -102,6 +103,10 @@ export class ProjectDesignBundleBuilder {
                     schematicModels,
                     documents
                 ),
+            schematicHierarchyReport: ProjectHierarchyReportBuilder.build({
+                projectModel,
+                documentModels: schematicModels
+            }),
             pnp,
             nets,
             annotations,
@@ -262,7 +267,17 @@ export class ProjectDesignBundleBuilder {
                     fileName: model.fileName,
                     pins: net.pins || [],
                     labels: net.labels || [],
+                    powerPorts: net.powerPorts || [],
+                    ports: net.ports || [],
                     segments: net.segments || [],
+                    sheetEntries: net.sheetEntries || [],
+                    ...(net.autoName ? { autoName: net.autoName } : {}),
+                    ...(net.autoNameSource
+                        ? { autoNameSource: net.autoNameSource }
+                        : {}),
+                    ...(net.aliasCandidates?.length
+                        ? { aliasCandidates: net.aliasCandidates }
+                        : {}),
                     ...(model.schematic?.harnesses
                         ? { harnesses: model.schematic.harnesses.connectors }
                         : {})