altium-toolkit 1.0.8 → 1.0.10

package/src/core/altium/AltiumParser.mjs

@@ -13,6 +13,9 @@ import { SchematicPinParser } from './SchematicPinParser.mjs'
 import { SchematicPrimitiveParser } from './SchematicPrimitiveParser.mjs'
 import { AltiumLayoutParser } from './AltiumLayoutParser.mjs'
 import { NormalizedModelSchema } from './NormalizedModelSchema.mjs'
+import { IntLibModelParser } from './IntLibModelParser.mjs'
+import { IntLibStreamExtractor } from './IntLibStreamExtractor.mjs'
+import { DraftsmanDigestParser } from './DraftsmanDigestParser.mjs'
 import { PcbModelParser } from './PcbModelParser.mjs'
 import { PcbLibModelParser } from './PcbLibModelParser.mjs'
 import { PcbLibStreamExtractor } from './PcbLibStreamExtractor.mjs'
@@ -25,8 +28,20 @@ import { SchematicJunctionParser } from './SchematicJunctionParser.mjs'
 import { SchematicBusEntryParser } from './SchematicBusEntryParser.mjs'
 import { SchematicImageParser } from './SchematicImageParser.mjs'
 import { SchematicNetlistBuilder } from './SchematicNetlistBuilder.mjs'
+import { SchematicRecordTypeRegistry } from './SchematicRecordTypeRegistry.mjs'
 import { SchematicComponentTextResolver } from './SchematicComponentTextResolver.mjs'
+import { SchematicComponentOwnerTextResolver } from './SchematicComponentOwnerTextResolver.mjs'
+import { SchematicOwnershipGraphParser } from './SchematicOwnershipGraphParser.mjs'
 import { SchematicStreamExtractor } from './SchematicStreamExtractor.mjs'
+import { SchematicTemplateParser } from './SchematicTemplateParser.mjs'
+import { SchematicHarnessParser } from './SchematicHarnessParser.mjs'
+import { SchematicImplementationParser } from './SchematicImplementationParser.mjs'
+import { SchematicCrossSheetConnectorParser } from './SchematicCrossSheetConnectorParser.mjs'
+import { SchematicRepeatedChannelParser } from './SchematicRepeatedChannelParser.mjs'
+import { SchematicDisplayModeCatalogParser } from './SchematicDisplayModeCatalogParser.mjs'
+import { SchematicBindingProvenanceParser } from './SchematicBindingProvenanceParser.mjs'
+import { SchematicConnectivityQaBuilder } from './SchematicConnectivityQaBuilder.mjs'
+import { SchematicQaReportBuilder } from './SchematicQaReportBuilder.mjs'
 import { SchematicWireNormalizer } from './SchematicWireNormalizer.mjs'
 import { CircuitJsonModelAdapter } from '../circuit-json/CircuitJsonModelAdapter.mjs'
 const {
@@ -41,6 +56,7 @@ const {
 } = ParserUtils
 const {
     extractSchematicFonts,
+    extractSchematicFontDiagnostics,
     extractSchematicMetadata,
     extractSchematicTitleBlock,
     normalizeSchematicTextRecord
@@ -74,7 +90,7 @@ export class AltiumParser {
      * Parses a native Altium buffer into the renderer compatibility model.
      * @param {string} fileName
      * @param {ArrayBuffer} arrayBuffer
-     * @returns {{ schema: string, kind: 'schematic' | 'pcb' | 'pcb-library' | 'project', fileType: 'SchDoc' | 'PcbDoc' | 'PcbLib' | 'PrjPcb', fileName: string, summary: Record<string, number | string>, diagnostics: { severity: 'info' | 'warning', message: string }[], schematic?: Record<string, unknown>, pcb?: Record<string, unknown>, pcbLibrary?: Record<string, unknown>, project?: Record<string, unknown>, bom: { designators: string[], quantity: number, pattern: string, source: string, value: string }[] }}
+     * @returns {{ schema: string, kind: 'schematic' | 'pcb' | 'pcb-library' | 'project' | 'integrated-library' | 'draftsman', fileType: 'SchDoc' | 'PcbDoc' | 'PcbLib' | 'PrjPcb' | 'IntLib' | 'PCBDwf', fileName: string, summary: Record<string, number | string>, diagnostics: { severity: 'info' | 'warning', message: string }[], schematic?: Record<string, unknown>, pcb?: Record<string, unknown>, pcbLibrary?: Record<string, unknown>, project?: Record<string, unknown>, integratedLibrary?: Record<string, unknown>, draftsman?: Record<string, unknown>, bom: { designators: string[], quantity: number, pattern: string, source: string, value: string }[] }}
      */
     static parseArrayBufferToRendererModel(fileName, arrayBuffer) {
         const records = AsciiRecordParser.parse(arrayBuffer)
@@ -85,7 +101,8 @@ export class AltiumParser {
             return AltiumParser.#parseSchematic(
                 fileName,
                 schematicExtraction?.records || records,
-                arrayBuffer
+                arrayBuffer,
+                schematicExtraction
             )
         }
         if (fileType === 'PcbDoc') {
@@ -106,6 +123,15 @@ export class AltiumParser {
         if (fileType === 'PrjPcb') {
             return PrjPcbModelParser.parse(fileName, arrayBuffer)
         }
+        if (fileType === 'IntLib') {
+            return IntLibModelParser.parse(
+                fileName,
+                IntLibStreamExtractor.extractFromArrayBuffer(arrayBuffer)
+            )
+        }
+        if (fileType === 'PCBDwf') {
+            return DraftsmanDigestParser.parse(fileName, arrayBuffer)
+        }
         throw new Error('Unsupported file type: ' + fileName)
     }
 
@@ -113,7 +139,7 @@ export class AltiumParser {
      * Chooses the format based on extension and content.
      * @param {string} fileName
      * @param {{ fields: Record<string, string | string[]> }[]} records
-     * @returns {'SchDoc' | 'PcbDoc' | 'PcbLib' | 'PrjPcb'}
+     * @returns {'SchDoc' | 'PcbDoc' | 'PcbLib' | 'PrjPcb' | 'IntLib' | 'PCBDwf'}
      */
     static #sniffFileType(fileName, records) {
         const normalized = String(fileName || '').toLowerCase()
@@ -121,6 +147,8 @@ export class AltiumParser {
         if (normalized.endsWith('.pcbdoc')) return 'PcbDoc'
         if (normalized.endsWith('.pcblib')) return 'PcbLib'
         if (normalized.endsWith('.prjpcb')) return 'PrjPcb'
+        if (normalized.endsWith('.intlib')) return 'IntLib'
+        if (normalized.endsWith('.pcbdwf')) return 'PCBDwf'
 
         const hasSchematicHeader = records.some((record) =>
             getField(record.fields, 'HEADER').includes('Schematic')
@@ -132,12 +160,23 @@ export class AltiumParser {
      * @param {string} fileName
      * @param {{ raw: string, fields: Record<string, string | string[]> }[]} records
      * @param {ArrayBuffer} arrayBuffer
+     * @param {{ embeddedFiles?: object } | null} schematicExtraction
      * @returns {ReturnType<typeof AltiumParser.parseArrayBufferToRendererModel>}
      */
-    static #parseSchematic(fileName, records, arrayBuffer) {
-        const componentRecords = records.filter(
+    static #parseSchematic(
+        fileName,
+        records,
+        arrayBuffer,
+        schematicExtraction = null
+    ) {
+        const recordIndexAwareRecords = records.map((record, recordIndex) => ({
+            ...record,
+            recordIndex
+        }))
+        const componentRecords = recordIndexAwareRecords.filter(
             (record) => getField(record.fields, 'RECORD') === '1'
         )
+        const recordTypes = SchematicRecordTypeRegistry.summarize(records)
         const ownersWithImplicitDisplayMode =
             AltiumParser.#collectOwnersWithImplicitDisplayMode(records)
         const activeMultipartOwnerParts =
@@ -176,6 +215,10 @@ export class AltiumParser {
                 getField(record.fields, 'RECORD') !== '30' &&
                 getField(record.fields, 'RECORD') !== '37' &&
                 !SchematicPrimitiveParser.isRectangleRecord(record.fields) &&
+                !SchematicPrimitiveParser.isRoundedRectangleRecord(
+                    record.fields
+                ) &&
+                !SchematicPrimitiveParser.isIeeeSymbolRecord(record.fields) &&
                 !AltiumParser.#hasDisplayText(record.fields) &&
                 AltiumParser.#hasCoordinatePair(record.fields, 'Location') &&
                 AltiumParser.#hasCoordinatePair(record.fields, 'Corner')
@@ -192,12 +235,34 @@ export class AltiumParser {
                 AltiumParser.#hasCoordinatePair(record.fields, 'Location') &&
                 AltiumParser.#hasCoordinatePair(record.fields, 'Corner')
         )
+        const roundedRectangleRecords = drawableRecords.filter(
+            (record) =>
+                SchematicPrimitiveParser.isRoundedRectangleRecord(
+                    record.fields
+                ) &&
+                AltiumParser.#hasCoordinatePair(record.fields, 'Location') &&
+                AltiumParser.#hasCoordinatePair(record.fields, 'Corner')
+        )
+        const ieeeSymbolRecords = drawableRecords.filter(
+            (record) =>
+                SchematicPrimitiveParser.isIeeeSymbolRecord(record.fields) &&
+                AltiumParser.#hasCoordinatePair(record.fields, 'Location')
+        )
         const arcRecords = drawableRecords.filter(
             (record) =>
                 ['11', '12'].includes(getField(record.fields, 'RECORD')) &&
                 AltiumParser.#hasCoordinatePair(record.fields, 'Location') &&
                 parseNumericField(record.fields, 'Radius') !== null
         )
+        const bezierRecords = drawableRecords.filter(
+            (record) => getField(record.fields, 'RECORD') === '5'
+        )
+        const pieRecords = drawableRecords.filter(
+            (record) =>
+                getField(record.fields, 'RECORD') === '9' &&
+                AltiumParser.#hasCoordinatePair(record.fields, 'Location') &&
+                parseNumericField(record.fields, 'Radius') !== null
+        )
         const ellipseRecords = drawableRecords.filter(
             (record) =>
                 getField(record.fields, 'RECORD') === '8' &&
@@ -227,10 +292,26 @@ export class AltiumParser {
         const crossRecords = drawableRecords.filter(
             (record) => getField(record.fields, 'RECORD') === '22'
         )
-        const recordIndexAwareRecords = records.map((record, recordIndex) => ({
-            ...record,
-            recordIndex
-        }))
+        const ownership = SchematicOwnershipGraphParser.parse(
+            recordIndexAwareRecords
+        )
+        const harnesses = SchematicHarnessParser.parse(recordIndexAwareRecords)
+        const implementations = SchematicImplementationParser.parse(
+            recordIndexAwareRecords
+        )
+        const displayModes = SchematicDisplayModeCatalogParser.parse(
+            recordIndexAwareRecords
+        )
+        const bindings = SchematicBindingProvenanceParser.parse(
+            recordIndexAwareRecords,
+            implementations
+        )
+        const crossSheetConnectors = SchematicCrossSheetConnectorParser.parse(
+            recordIndexAwareRecords
+        )
+        const repeatedChannels = SchematicRepeatedChannelParser.parse(
+            recordIndexAwareRecords
+        )
         const relatedTexts = new Map()
 
         for (const record of records) {
@@ -244,6 +325,9 @@ export class AltiumParser {
 
         const metadataTexts = extractSchematicMetadata(textRecords)
         const schematicFonts = extractSchematicFonts(sheetRecord?.fields)
+        const schematicRenderDiagnostics = extractSchematicFontDiagnostics(
+            sheetRecord?.fields
+        )
         const sheetWidth =
             parseNumericField(sheetRecord?.fields, 'CustomX') || 1500
         const sheetHeight =
@@ -343,6 +427,9 @@ export class AltiumParser {
                 polygons
             ))
         const arcs = SchematicPrimitiveParser.parseSchematicArcs(arcRecords)
+        const beziers =
+            SchematicPrimitiveParser.parseSchematicBeziers(bezierRecords)
+        const pies = SchematicPrimitiveParser.parseSchematicPies(pieRecords)
         const ellipses =
             SchematicPrimitiveParser.parseSchematicEllipses(ellipseRecords)
         const rectangles =
@@ -358,8 +445,20 @@ export class AltiumParser {
             )
         const regions =
             SchematicPrimitiveParser.parseSchematicRegions(regionRecords)
+        const roundedRectangles =
+            SchematicPrimitiveParser.parseSchematicRoundedRectangles(
+                roundedRectangleRecords
+            )
+        const ieeeSymbols =
+            SchematicPrimitiveParser.parseSchematicIeeeSymbols(
+                ieeeSymbolRecords
+            )
         const directives =
             SchematicDirectiveParser.parseSchematicDirectives(directiveRecords)
+        const directiveSemantics =
+            SchematicDirectiveParser.parseDirectiveSemantics(
+                recordIndexAwareRecords
+            )
         const { sheetSymbols, sheetEntries } = SchematicSheetParser.parse(
             recordIndexAwareRecords
         )
@@ -371,6 +470,11 @@ export class AltiumParser {
                 recordIndexAwareRecords,
                 arrayBuffer
             )
+        const template = SchematicTemplateParser.parse(
+            recordIndexAwareRecords,
+            sheetRecord,
+            sheet
+        )
 
         const ports = parseSchematicPorts(portRecords, lines)
         const crosses = parseSchematicCrosses(crossRecords)
@@ -421,6 +525,8 @@ export class AltiumParser {
                 pins,
                 ports
             )
+        const textFrames =
+            SchematicTextParser.extractSchematicTextFrames(anchoredTexts)
 
         const components = componentRecords.map((record) => {
             const x = parseNumericField(record.fields, 'Location.X') || 0
@@ -428,25 +534,28 @@ export class AltiumParser {
             const libReference =
                 getField(record.fields, 'LibReference') ||
                 getField(record.fields, 'DesignItemId')
-            const ownerIndex = String(
-                (parseNumericField(record.fields, 'IndexInSheet') || 0) + 1
+            const ownerTexts =
+                SchematicComponentOwnerTextResolver.resolveOwnerTexts(
+                    record,
+                    recordIndexAwareRecords,
+                    relatedTexts
+                )
+
+            const designator = SchematicComponentTextResolver.resolveDesignator(
+                ownerTexts,
+                anchoredTexts,
+                {
+                    x,
+                    y,
+                    libReference
+                }
             )
-            const ownerTexts = relatedTexts.get(ownerIndex) || []
 
             return {
                 x,
                 y,
                 libReference,
-                designator:
-                    SchematicComponentTextResolver.resolveDesignator(
-                        ownerTexts,
-                        anchoredTexts,
-                        {
-                            x,
-                            y,
-                            libReference
-                        }
-                    ) || 'U?',
+                designator: designator === null ? 'U?' : designator,
                 value: SchematicComponentTextResolver.resolveValue(
                     ownerTexts,
                     anchoredTexts,
@@ -513,6 +622,16 @@ export class AltiumParser {
                     'Sheet metadata record 31 was not found. Using fallback dimensions.'
             })
         }
+        diagnostics.push(
+            ...schematicRenderDiagnostics.fontFallbacks.map((fallback) => ({
+                severity: fallback.severity,
+                code: fallback.code,
+                fontId: fallback.fontId,
+                sourceFamily: fallback.sourceFamily,
+                resolvedFamily: fallback.resolvedFamily,
+                message: fallback.message
+            }))
+        )
         diagnostics.push(...imageDiagnostics)
         const { nets, diagnostics: netDiagnostics } =
             SchematicNetlistBuilder.build({
@@ -520,11 +639,36 @@ export class AltiumParser {
                 texts: anchoredTexts,
                 pins,
                 ports,
+                crossSheetConnectors: crossSheetConnectors?.connectors || [],
                 junctions,
                 busEntries,
                 sheetEntries
             })
         diagnostics.push(...netDiagnostics)
+        const qa = SchematicQaReportBuilder.build({
+            records: recordIndexAwareRecords,
+            sheet: resolvedSheet,
+            lines: normalizedLines,
+            texts: anchoredTexts
+        })
+        const connectivityQa = SchematicConnectivityQaBuilder.build({
+            nets,
+            texts: anchoredTexts,
+            pins,
+            ports,
+            junctions
+        })
+        const embeddedFiles = schematicExtraction?.embeddedFiles || null
+
+        if (embeddedFiles?.diagnostics?.length) {
+            diagnostics.push(
+                ...embeddedFiles.diagnostics.map((issue) => ({
+                    severity: issue.severity === 'info' ? 'info' : 'warning',
+                    code: issue.code,
+                    message: issue.message
+                }))
+            )
+        }
 
         return NormalizedModelSchema.attach({
             kind: 'schematic',
@@ -535,19 +679,30 @@ export class AltiumParser {
                 componentCount: components.length,
                 lineCount: lines.length,
                 textCount: anchoredTexts.length,
+                recordTypeCount: recordTypes.length,
                 bomRowCount: bom.length
             },
             diagnostics,
             schematic: {
                 sheet: resolvedSheet,
+                recordTypes,
+                ...(schematicRenderDiagnostics.fontFallbacks.length
+                    ? { renderDiagnostics: schematicRenderDiagnostics }
+                    : {}),
                 lines: normalizedLines,
                 polygons,
                 rectangles,
+                roundedRectangles,
                 regions,
                 ellipses,
                 arcs,
+                beziers,
+                pies,
+                ieeeSymbols,
                 directives,
+                directiveSemantics,
                 texts: anchoredTexts,
+                textFrames,
                 components,
                 pins,
                 ports,
@@ -560,7 +715,22 @@ export class AltiumParser {
                 junctions,
                 busEntries,
                 images,
-                nets
+                nets,
+                ownership,
+                ...(template ? { template } : {}),
+                ...(harnesses ? { harnesses } : {}),
+                ...(implementations ? { implementations } : {}),
+                ...(displayModes ? { displayModes } : {}),
+                ...(bindings ? { bindings } : {}),
+                ...(crossSheetConnectors ? { crossSheetConnectors } : {}),
+                ...(repeatedChannels ? { repeatedChannels } : {}),
+                ...(embeddedFiles &&
+                (embeddedFiles.files?.length ||
+                    embeddedFiles.diagnostics?.length)
+                    ? { embeddedFiles }
+                    : {}),
+                qa,
+                connectivityQa
             },
             bom
         })
@@ -598,7 +768,9 @@ export class AltiumParser {
                 ownerPartId &&
                 ownerPartId !== '-1' &&
                 !getField(record.fields, 'OwnerPartDisplayMode') &&
-                AltiumParser.#isDisplayModeSelectablePrimitive(record.fields)
+                SchematicComponentOwnerTextResolver.isDisplayModeSelectablePrimitive(
+                    record.fields
+                )
             ) {
                 owners.add(ownerIndex)
             }
@@ -652,27 +824,6 @@ export class AltiumParser {
         )
     }
 
-    /**
-     * Returns true when a schematic primitive participates in owner display
-     * mode selection.
-     * @param {Record<string, string | string[]>} fields
-     * @returns {boolean}
-     */
-    static #isDisplayModeSelectablePrimitive(fields) {
-        const recordType = getField(fields, 'RECORD')
-
-        return (
-            recordType === '2' ||
-            recordType === '6' ||
-            recordType === '11' ||
-            recordType === '12' ||
-            recordType === '13' ||
-            recordType === '27' ||
-            (AltiumParser.#hasCoordinatePair(fields, 'Location') &&
-                AltiumParser.#hasCoordinatePair(fields, 'Corner'))
-        )
-    }
-
     /**
      * Groups designators into BOM rows.
      * @param {{ designator: string, pattern: string, source: string, value: string }[]} entries

package/src/core/altium/CiArtifactBundleBuilder.mjs

@@ -0,0 +1,202 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import { PcbSvgRenderer } from '../../ui/PcbSvgRenderer.mjs'
+import { SchematicSvgRenderer } from '../../ui/SchematicSvgRenderer.mjs'
+import { PcbStatisticsBuilder } from './PcbStatisticsBuilder.mjs'
+import { ProjectDesignBundleBuilder } from './ProjectDesignBundleBuilder.mjs'
+import { ProjectDocumentGraphBuilder } from './ProjectDocumentGraphBuilder.mjs'
+import { ProjectNetlistExporter } from './ProjectNetlistExporter.mjs'
+
+/**
+ * Builds one deterministic CI artifact package from parsed project documents.
+ */
+export class CiArtifactBundleBuilder {
+    static SCHEMA = 'altium-toolkit.ci.artifact-bundle.a1'
+
+    static #UNITS = {
+        coordinate: 'mil',
+        length: 'mil',
+        board: 'mil',
+        pnp: 'mil',
+        angle: 'deg'
+    }
+
+    static #PNP_UNITS = {
+        coordinate: 'mil',
+        angle: 'deg'
+    }
+
+    /**
+     * Builds a deterministic bundle of normalized, rendered, and report outputs.
+     * @param {{ projectModel?: object, documentModels?: object[], designBundle?: object, annotationModels?: object[], variantName?: string, renderSchematicSvg?: boolean, renderPcbLayerSvgs?: boolean, schematicSvgOptions?: object }} options Bundle options.
+     * @returns {object}
+     */
+    static build(options = {}) {
+        const documentModels = Array.isArray(options.documentModels)
+            ? options.documentModels
+            : []
+        const designBundle =
+            options.designBundle ||
+            ProjectDesignBundleBuilder.build({
+                projectModel: options.projectModel,
+                documentModels,
+                annotationModels: options.annotationModels || [],
+                variantName: options.variantName
+            })
+        const activeBundle = designBundle.effectiveVariant || designBundle
+        const schematicSvgs =
+            options.renderSchematicSvg === false
+                ? []
+                : CiArtifactBundleBuilder.#schematicSvgs(
+                      documentModels,
+                      options.schematicSvgOptions || {}
+                  )
+        const pcbLayerSvgs =
+            options.renderPcbLayerSvgs === false
+                ? []
+                : CiArtifactBundleBuilder.#pcbLayerSvgs(documentModels)
+        const statistics = CiArtifactBundleBuilder.#statistics(documentModels)
+        const diagnostics = CiArtifactBundleBuilder.#diagnostics(
+            designBundle,
+            documentModels
+        )
+        const netlistJson =
+            ProjectNetlistExporter.buildNetlistJson(activeBundle)
+        const documentGraph =
+            designBundle.project?.documentGraph ||
+            ProjectDocumentGraphBuilder.build(
+                options.projectModel?.project || designBundle.project || {}
+            )
+
+        return {
+            schema: CiArtifactBundleBuilder.SCHEMA,
+            summary: {
+                normalizedModelCount: documentModels.length,
+                schematicSvgCount: schematicSvgs.length,
+                pcbLayerSvgCount: pcbLayerSvgs.reduce(
+                    (total, entry) => total + entry.layers.length,
+                    0
+                ),
+                netCount: netlistJson.nets.length,
+                bomRowCount: (activeBundle.bom || designBundle.bom || [])
+                    .length,
+                pnpCount: (activeBundle.pnp?.entries || []).length,
+                diagnosticCount: diagnostics.length
+            },
+            units: designBundle.units || CiArtifactBundleBuilder.#UNITS,
+            designBundle,
+            documentGraph,
+            normalizedModels: documentModels,
+            netlist: {
+                json: netlistJson,
+                wirelist: ProjectNetlistExporter.buildWirelist(activeBundle)
+            },
+            bom: {
+                rows: activeBundle.bom || designBundle.bom || []
+            },
+            pnp: CiArtifactBundleBuilder.#pnp(activeBundle, designBundle),
+            schematicSvgs,
+            pcbLayerSvgs,
+            statistics,
+            diagnostics
+        }
+    }
+
+    /**
+     * Resolves a PnP payload with explicit output units.
+     * @param {object} activeBundle Effective bundle or variant.
+     * @param {object} designBundle Source design bundle.
+     * @returns {object}
+     */
+    static #pnp(activeBundle, designBundle) {
+        const pnp = activeBundle.pnp || designBundle.pnp || { entries: [] }
+
+        return {
+            units: pnp.units || CiArtifactBundleBuilder.#PNP_UNITS,
+            ...pnp
+        }
+    }
+
+    /**
+     * Renders schematic SVG entries.
+     * @param {object[]} documentModels Parsed document models.
+     * @param {object} renderOptions Schematic SVG render options.
+     * @returns {object[]}
+     */
+    static #schematicSvgs(documentModels, renderOptions) {
+        return documentModels
+            .filter((model) => model?.kind === 'schematic')
+            .map((model) => ({
+                fileName: model.fileName || '',
+                svg: SchematicSvgRenderer.render(model, renderOptions)
+            }))
+    }
+
+    /**
+     * Renders per-layer PCB SVG entries.
+     * @param {object[]} documentModels Parsed document models.
+     * @returns {object[]}
+     */
+    static #pcbLayerSvgs(documentModels) {
+        return documentModels
+            .filter((model) => model?.kind === 'pcb')
+            .map((model) => ({
+                fileName: model.fileName || '',
+                layers: PcbSvgRenderer.renderLayerSvgs(model)
+            }))
+    }
+
+    /**
+     * Builds statistics package entries.
+     * @param {object[]} documentModels Parsed document models.
+     * @returns {{ pcb: object[] }}
+     */
+    static #statistics(documentModels) {
+        return {
+            pcb: documentModels
+                .filter((model) => model?.kind === 'pcb')
+                .map((model) => ({
+                    fileName: model.fileName || '',
+                    statistics:
+                        model.pcb?.statistics ||
+                        PcbStatisticsBuilder.build(model.pcb || {})
+                }))
+        }
+    }
+
+    /**
+     * Collects diagnostics from the bundle and source documents.
+     * @param {object} designBundle Composed design bundle.
+     * @param {object[]} documentModels Parsed document models.
+     * @returns {object[]}
+     */
+    static #diagnostics(designBundle, documentModels) {
+        return [
+            ...CiArtifactBundleBuilder.#sourceDiagnostics(
+                'design-bundle',
+                designBundle.diagnostics || []
+            ),
+            ...documentModels.flatMap((model) =>
+                CiArtifactBundleBuilder.#sourceDiagnostics(
+                    model.fileName || model.kind || 'document',
+                    model.diagnostics || []
+                )
+            )
+        ]
+    }
+
+    /**
+     * Adds source labels to diagnostics without changing their codes.
+     * @param {string} source Diagnostic source label.
+     * @param {object[]} diagnostics Source diagnostics.
+     * @returns {object[]}
+     */
+    static #sourceDiagnostics(source, diagnostics) {
+        return (diagnostics || []).map((diagnostic) => ({
+            source,
+            ...diagnostic
+        }))
+    }
+}