altium-toolkit 1.1.23 → 1.1.25

package/docs/api.md

@@ -76,8 +76,10 @@ Specialized parser helpers are exported for lower-level integrations, including
 `EmbeddedAssetReportBuilder`, `LibraryDiffReportBuilder`,
 `LibraryInspectionReportBuilder`,
 `PcbBoardRegionSemanticsParser`, `PcbComponentPrimitiveIndexer`,
-`PcbCustomPadShapeParser`, `PcbDimensionParser`, `PcbEmbeddedFontExtractor`,
-`PcbExtendedPrimitiveInformationParser`, `PcbFontMetricsParser`,
+`PcbCustomPadShapeParser`, `PcbDimensionParser`,
+`PcbDimensionReportBuilder`, `PcbEmbeddedFontExtractor`,
+`PcbExtendedPrimitiveInformationParser`,
+`PcbFabricationReadinessReportBuilder`, `PcbFontMetricsParser`,
 `LibraryRenderManifestBuilder`, `LibraryCatalogArtifactBuilder`,
 `LibrarySearchIndex`, `SchLibModelParser`, `SchLibStreamExtractor`,
 `PcbBomProfileBuilder`, `PcbClassReportBuilder`,
@@ -88,8 +90,10 @@ Specialized parser helpers are exported for lower-level integrations, including
 `ProjectDesignBundleBuilder`, `ProjectHierarchyReportBuilder`,
 `ProjectNetlistExporter`, `ProjectVariantViewBuilder`,
 `PcbMechanicalLayerPairParser`, `PcbSpecialStringResolver`, `PcbUnionParser`,
-`PcbViaStackParser`, `PcbRuleParser`, `PcbRawRecordRegistry`,
+`PcbViaStackParser`, `PcbRuleImpactReportBuilder`, `PcbRuleParser`,
+`PcbRawRecordRegistry`, `PcbReviewPolygonRealizationBuilder`,
 `PcbStatisticsBuilder`, `SchematicCodeSymbolParser`,
+`SchematicConnectivityQaBuilder`, `SchematicImageDiagnosticsBuilder`,
 `SchematicOwnershipGraphParser`,
 `SchematicProjectParameterResolver`, `SchematicRecordStreamParser`, and
 `SchematicTextRunParser`.
@@ -100,6 +104,15 @@ the native component-index grouping used to populate
 rule helpers expose the same mask/cache, stack, and typed-constraint
 normalization used by `.PcbDoc` parsing. `PcbDimensionParser` exposes the
 parser-only Dimensions6 normalization used by `.PcbDoc` parsing.
+`PcbDimensionReportBuilder` classifies recovered PCB dimensions as renderable
+or unresolved from their reference geometry, and
+`PcbRuleImpactReportBuilder` summarizes enabled/disabled design rules by
+affected primitive family, scope predicate, manufacturing category, and
+length-valued constraints. `PcbFabricationReadinessReportBuilder` summarizes
+pad/via fabrication review items such as local pad stacks, offsets, slots,
+mask overrides, thermal relief, via spans, and via protection metadata.
+`PcbReviewPolygonRealizationBuilder` exposes the polygon-pour realization rows
+used by `pcb.reviewMetadata`.
 `SchematicOwnershipGraphParser` and `PcbOwnershipGraphBuilder` expose the
 read-only ownership sidecars that parser roots attach under
 `schematic.ownership` and `pcb.ownership`.
@@ -190,10 +203,16 @@ implementation child rows where available.
 `LibrarySearchIndex` expose deterministic SchLib/PcbLib render/export
 manifests, static catalog artifacts, search metadata, plus exact, keyword, and
 fuzzy lookup helpers. `PcbStatisticsBuilder`, `PcbNetMembershipReportBuilder`,
-`PcbClassReportBuilder`, and `PcbInspectionReportBuilder` emit board QA,
-net-ownership, class-membership, and combined inspection artifacts for
-`.PcbDoc` models. `SchematicProjectParameterResolver` resolves dot-prefixed and
-equals-prefixed schematic special strings for parser and SVG integrations.
+`PcbClassReportBuilder`, `PcbDimensionReportBuilder`,
+`PcbRuleImpactReportBuilder`, `PcbFabricationReadinessReportBuilder`, and
+`PcbInspectionReportBuilder` emit board QA, net-ownership, class-membership,
+dimension QA, rule-impact, fabrication-readiness, and combined inspection
+artifacts for `.PcbDoc` models. `SchematicImageDiagnosticsBuilder` and
+`SchematicConnectivityQaBuilder` expose the same image payload and connectivity
+QA sidecars attached to parsed schematic models.
+`SchematicProjectParameterResolver`
+resolves dot-prefixed and equals-prefixed schematic special strings for parser
+and SVG integrations.
 `SchematicTextRunParser` parses schematic backslash suffix markers into display
 text plus overline run metadata reused by pin and text rendering.
 
@@ -303,13 +322,14 @@ available. The embedded `schematic-semantic-metadata` JSON sidecar uses schema
 components, and pins for downstream highlighting.
 
 PCB SVG output includes stable semantic `data-*` attributes on recovered board,
-copper, pad, via, component, and text elements. The embedded
+copper, pad, via, component, text, and dimension elements. The embedded
 `pcb-semantic-metadata` JSON sidecar uses schema
 `altium-toolkit.pcb.svg.semantics.a1` and links SVG element keys to primitive
-kind, layer, net/class, component, pad number, hole ownership, and board-outline
-identity where that metadata is available. The same sidecar also records view
-context, including board centroid, included layer ids, layer roles, cutouts, and
-pad/via drill render state (`open`, `covered`, `filled`, or `capped`).
+kind, layer, net/class, component, pad number, dimension kind/text, hole
+ownership, and board-outline identity where that metadata is available. The
+same sidecar also records view context, including board centroid, included layer
+ids, layer roles, cutouts, and pad/via drill render state (`open`, `covered`,
+`filled`, or `capped`).
 `PcbSvgRenderer.renderLayerSvgs()` uses the same semantic sidecar shape with
 `view.kind: 'layer'` and a layer-specific `layerSet`.
 
@@ -331,7 +351,8 @@ import {
   `drillCutouts` plus fill holes for drilled pads and vias. External model
   placements include `projection` diagnostics indicating whether bounds came
   from authored overrides, resolved model bounds, nearby pad spans, procedural
-  component fallback, or only the model anchor.
+  component fallback, or only the model anchor. Shape-based 3D bodies with
+  complete native geometry are exposed as `staticBodyPlacements`.
 - `PcbScene3dModelRegistry` resolves embedded or session model candidates for
   component placements.
 - `PcbScene3dScenePreparator.prepare(documentModel, options)` prepares the same

package/docs/model-format.md

@@ -170,10 +170,23 @@ possible unrouted pad-only nets are split into deterministic lists.
 `PcbClassReportBuilder.build()` emits
 `altium-toolkit.pcb.class-report.a1` reports that summarize PCB classes by
 kind, enabled state, member resolution, empty classes, and unresolved members.
+`PcbDimensionReportBuilder.build()` emits
+`altium-toolkit.pcb.dimensions.a1` reports that classify recovered PCB
+dimensions as renderable or unresolved from reference geometry and summarize
+dimension kinds. `PcbRuleImpactReportBuilder.build()` emits
+`altium-toolkit.pcb.rule-impact.a1` reports that group design rules by enabled
+state, affected primitive families, scope predicates, manufacturing category,
+and length-valued constraints.
+`PcbFabricationReadinessReportBuilder.build()` emits
+`altium-toolkit.pcb.fabrication-readiness.a1` reports that summarize pad/via
+fabrication review items such as non-simple pad stack modes, local pad
+offsets, slotted and non-plated holes, mask overrides, thermal relief, via
+spans, via protection, and microvia-like geometry.
 `PcbInspectionReportBuilder.build()` emits `altium-toolkit.pcb.inspection.a1`
 reports that compose board statistics, primitive counts, design-rule counts,
-diagnostics, net membership, class membership, and route-analysis summaries
-into one inspection artifact.
+diagnostics, net membership, class membership, dimension QA, rule-impact,
+review metadata, fabrication-readiness, and route-analysis summaries into one
+inspection artifact.
 
 `PcbLayerGroups` provides stable layer-group names, deterministic display
 colors, and draw priorities for legacy PCB layer ids. `AltiumUnits` provides
@@ -254,7 +267,12 @@ multi-sheet design netlist.
 `schematic.connectivityQa` reports read-only connectivity findings, including
 implicit generated net names, dangling labels, orphan ports, unconnected pins,
 ambiguous junctions, and un-junctioned tee contacts where one wire endpoint
-touches another wire interior without an authored junction.
+touches another wire interior without an authored junction. Harness-specific
+findings flag sheet entries whose local harness type cannot be resolved,
+harness entries without linked signal-harness geometry, and connector type-label
+mismatches. Pin interpretation findings flag hidden name/number labels,
+endpoint symbol markers, and power-like pin names whose recovered electrical
+type is not a power pin.
 
 Embedded schematic images preserve the raw record geometry and expose
 browser-facing payload metadata. When an embedded stream contains a native
@@ -262,6 +280,10 @@ PNG/JPEG/GIF/SVG/WebP payload alongside a preview, `mimeType` and `dataBase64`
 refer to the native payload while `sourceMimeType` records the preview format.
 Alpha-bearing 32-bit BMP previews are converted to PNG and marked with
 `hasAlpha` so SVG renderers can display transparency deterministically.
+`schematic.imageDiagnostics` reports embedded payload counts, external image
+references, missing embedded payloads, unsupported MIME states, converted
+preview/native payloads, and alpha-bearing images without attempting any file
+system lookups.
 When a schematic OLE container exposes preview metadata, `schematic.thumbnails`
 contains PNG thumbnail sidecars with `kind`, dimensions, `sourceStream`,
 `pixelFormat`, `mimeType`, and `dataBase64` fields.
@@ -378,9 +400,11 @@ consumers.
 
 PCB dimensions from `Dimensions6/Data` are exposed through `pcb.dimensions`.
 Dimension entries preserve native kind codes and raw fields while adding a
-normalized `kind` (`linear`, `angular`, `radial`, `datum`, `baseline`, or
-`ordinate`), reference points, optional text location, prefix/suffix, precision,
-measured value, angle value, and unit.
+normalized `kind` (`linear`, `angular`, `radial`, `diameter`, `datum`,
+`baseline`, or `ordinate`), reference points, optional text location,
+prefix/suffix, precision, measured value, angle value, and unit. PCB SVG output
+renders dimensions with sufficient reference geometry as static mechanical
+dimension primitives and includes them in the semantic sidecar.
 
 `pcb.extendedPrimitiveInformation` exposes
 `ExtendedPrimitiveInformation/Data` entries keyed by primitive index and, when
@@ -454,7 +478,9 @@ preserves raw mixed-format primitive records with the same registry metadata
 shape used by PcbDoc raw records. Library-level `embeddedFonts` uses the same
 payload and metric shape as PCB documents. Library-level `embeddedModels` and
 `componentBodies` preserve embedded 3D payloads and body references when
-present.
+present. Shape-based component bodies may include `staticGeometry` for
+extruded-polygon, cone, cylinder, and sphere bodies, with dimensions and
+vertices expressed in mils when native evidence is available.
 `pcbLibrary.indexes.footprintsByName` provides read-only footprint lookup and
 search metadata, including source storage, primitive counts, pad/text counts,
 and keyword tokens from footprint and component parameters. Footprint entries
@@ -540,7 +566,10 @@ External model placements in the 3D scene description include a `projection`
 diagnostic object. The `source` explains whether bounds came from an authored
 projection override, resolved model bounds, nearby pad-span fallback,
 procedural component fallback, or model-anchor fallback. The diagnostic does
-not alter placement coordinates.
+not alter placement coordinates. Shape-based component bodies with complete
+static geometry are exposed separately as `staticBodyPlacements`, using the
+same board-centered coordinate convention as component and external-model
+placements.
 
 ## Integrated Library Fields
 

package/docs/schemas/altium_toolkit/unsupported_features_a1.schema.json

@@ -10,7 +10,8 @@
         "recordTypes",
         "rawRecords",
         "opaqueRecords",
-        "diagnostics"
+        "diagnostics",
+        "edgeCases"
     ],
     "properties": {
         "schema": {
@@ -25,6 +26,7 @@
                 "rawRecordCount",
                 "opaqueRecordCount",
                 "diagnosticCount",
+                "edgeCaseCount",
                 "itemCount",
                 "status"
             ],
@@ -44,6 +46,9 @@
                 "diagnosticCount": {
                     "type": "number"
                 },
+                "edgeCaseCount": {
+                    "type": "number"
+                },
                 "itemCount": {
                     "type": "number"
                 },
@@ -75,6 +80,12 @@
             "items": {
                 "$ref": "#/$defs/diagnostic"
             }
+        },
+        "edgeCases": {
+            "type": "array",
+            "items": {
+                "$ref": "#/$defs/edgeCase"
+            }
         }
     },
     "$defs": {
@@ -207,6 +218,52 @@
                     "type": "string"
                 }
             }
+        },
+        "edgeCase": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["code"],
+            "properties": {
+                "fileName": {
+                    "type": "string"
+                },
+                "domain": {
+                    "type": "string"
+                },
+                "code": {
+                    "type": "string"
+                },
+                "feature": {
+                    "type": "string"
+                },
+                "supportState": {
+                    "type": "string"
+                },
+                "severity": {
+                    "enum": ["info", "warning", "error"]
+                },
+                "message": {
+                    "type": "string"
+                },
+                "source": {
+                    "type": "string"
+                },
+                "sourceStream": {
+                    "type": "string"
+                },
+                "sourceStorage": {
+                    "type": "string"
+                },
+                "recordIndex": {
+                    "type": "number"
+                },
+                "recordType": {
+                    "type": "number"
+                },
+                "errorKind": {
+                    "type": "string"
+                }
+            }
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "altium-toolkit",
-    "version": "1.1.23",
+    "version": "1.1.25",
     "description": "Altium document parsing and non-interactive rendering utilities",
     "keywords": [
         "altium",

package/src/core/altium/AltiumParser.mjs

@@ -32,6 +32,7 @@ import { SchematicSheetParser } from './SchematicSheetParser.mjs'
 import { SchematicJunctionParser } from './SchematicJunctionParser.mjs'
 import { SchematicBusEntryParser } from './SchematicBusEntryParser.mjs'
 import { SchematicImageParser } from './SchematicImageParser.mjs'
+import { SchematicImageDiagnosticsBuilder } from './SchematicImageDiagnosticsBuilder.mjs'
 import { SchematicNetlistBuilder } from './SchematicNetlistBuilder.mjs'
 import { SchematicRecordTypeRegistry } from './SchematicRecordTypeRegistry.mjs'
 import { SchematicComponentTextResolver } from './SchematicComponentTextResolver.mjs'
@@ -617,6 +618,9 @@ export class AltiumParser {
                 recordIndexAwareRecords,
                 arrayBuffer
             )
+        const imageDiagnosticsReport = SchematicImageDiagnosticsBuilder.build({
+            images
+        })
         const { thumbnails, diagnostics: thumbnailDiagnostics } =
             SchematicThumbnailParser.parse(arrayBuffer)
         const template = SchematicTemplateParser.parse(
@@ -832,7 +836,9 @@ export class AltiumParser {
             texts: anchoredTexts,
             pins,
             ports,
-            junctions
+            junctions,
+            sheetEntries,
+            harnesses
         })
         const embeddedFiles = schematicExtraction?.embeddedFiles || null
         const nativeStreams = schematicExtraction?.nativeStreams || null
@@ -905,6 +911,7 @@ export class AltiumParser {
                 junctions,
                 busEntries,
                 images,
+                imageDiagnostics: imageDiagnosticsReport,
                 ...(thumbnails.length ? { thumbnails } : {}),
                 nets,
                 ownership,

package/src/core/altium/PcbDimensionParser.mjs

@@ -173,6 +173,7 @@ export class PcbDimensionParser {
     static #normalizeKind(kindCode) {
         const normalized = String(kindCode || '').toLowerCase()
         if (/ang/u.test(normalized)) return 'angular'
+        if (/diam/u.test(normalized)) return 'diameter'
         if (/radial|radius/u.test(normalized)) return 'radial'
         if (/datum/u.test(normalized)) return 'datum'
         if (/baseline/u.test(normalized)) return 'baseline'

package/src/core/altium/PcbDimensionReportBuilder.mjs

@@ -0,0 +1,190 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/**
+ * Builds deterministic QA summaries for recovered PCB dimension records.
+ */
+export class PcbDimensionReportBuilder {
+    static SCHEMA = 'altium-toolkit.pcb.dimensions.a1'
+
+    /**
+     * Builds a dimension QA report from a parser root or PCB model.
+     * @param {object} input Parser root, PCB model, or options object.
+     * @returns {object}
+     */
+    static build(input = {}) {
+        const pcb = PcbDimensionReportBuilder.#pcb(input)
+        const dimensions = PcbDimensionReportBuilder.#dimensions(pcb)
+        const rows = dimensions.map((dimension) =>
+            PcbDimensionReportBuilder.#dimensionRow(dimension)
+        )
+        const findings = rows.flatMap((row) =>
+            PcbDimensionReportBuilder.#findingsForRow(row)
+        )
+
+        return {
+            schema: PcbDimensionReportBuilder.SCHEMA,
+            summary: PcbDimensionReportBuilder.#summary(rows),
+            dimensions: rows,
+            findings
+        }
+    }
+
+    /**
+     * Resolves the PCB payload from a parser root or direct PCB model.
+     * @param {object} input Parser root or PCB model.
+     * @returns {object}
+     */
+    static #pcb(input) {
+        return input?.pcb || input || {}
+    }
+
+    /**
+     * Resolves normalized dimension rows from a PCB payload.
+     * @param {object} pcb PCB model.
+     * @returns {object[]}
+     */
+    static #dimensions(pcb) {
+        return Array.isArray(pcb?.dimensions) ? pcb.dimensions : []
+    }
+
+    /**
+     * Builds one public dimension report row.
+     * @param {object} dimension Normalized dimension record.
+     * @returns {object}
+     */
+    static #dimensionRow(dimension) {
+        const kind = PcbDimensionReportBuilder.#kind(dimension)
+        const references = Array.isArray(dimension?.references)
+            ? dimension.references
+            : []
+        const requiredReferenceCount =
+            PcbDimensionReportBuilder.#requiredReferenceCount(kind)
+        const status =
+            references.length >= requiredReferenceCount
+                ? 'renderable'
+                : 'unresolved'
+
+        return PcbDimensionReportBuilder.#stripEmpty({
+            dimensionIndex: PcbDimensionReportBuilder.#integerOrFallback(
+                dimension?.dimensionIndex,
+                0
+            ),
+            kind,
+            name: dimension?.name || '',
+            layer: dimension?.layer || '',
+            text: dimension?.text || '',
+            status,
+            referenceCount: references.length,
+            requiredReferenceCount,
+            hasTextLocation: Boolean(dimension?.textLocation),
+            measuredValue: dimension?.measuredValue ?? undefined,
+            angleValue: dimension?.angleValue ?? undefined,
+            unit: dimension?.unit || ''
+        })
+    }
+
+    /**
+     * Builds report findings for one dimension row.
+     * @param {object} row Dimension report row.
+     * @returns {object[]}
+     */
+    static #findingsForRow(row) {
+        if (row.status !== 'unresolved') {
+            return []
+        }
+
+        return [
+            PcbDimensionReportBuilder.#stripEmpty({
+                code: 'pcb.dimension.missing-reference',
+                severity: 'warning',
+                dimensionIndex: row.dimensionIndex,
+                kind: row.kind,
+                name: row.name,
+                referenceCount: row.referenceCount,
+                requiredReferenceCount: row.requiredReferenceCount
+            })
+        ]
+    }
+
+    /**
+     * Builds top-level dimension counters.
+     * @param {object[]} rows Dimension report rows.
+     * @returns {object}
+     */
+    static #summary(rows) {
+        const byKind = new Map()
+
+        for (const row of rows) {
+            byKind.set(row.kind, Number(byKind.get(row.kind) || 0) + 1)
+        }
+
+        return {
+            dimensionCount: rows.length,
+            renderableCount: rows.filter((row) => row.status === 'renderable')
+                .length,
+            unresolvedCount: rows.filter((row) => row.status === 'unresolved')
+                .length,
+            missingTextLocationCount: rows.filter(
+                (row) => row.hasTextLocation !== true
+            ).length,
+            byKind: [...byKind.entries()]
+                .map(([kind, count]) => ({ kind, count }))
+                .sort((left, right) =>
+                    left.kind.localeCompare(right.kind, undefined, {
+                        numeric: true
+                    })
+                )
+        }
+    }
+
+    /**
+     * Resolves the canonical dimension kind.
+     * @param {object} dimension Dimension record.
+     * @returns {string}
+     */
+    static #kind(dimension) {
+        const kind = String(dimension?.kind || '')
+            .trim()
+            .toLowerCase()
+        return kind || 'linear'
+    }
+
+    /**
+     * Returns the minimum reference count needed for deterministic rendering.
+     * @param {string} kind Dimension kind.
+     * @returns {number}
+     */
+    static #requiredReferenceCount(kind) {
+        if (kind === 'angular') {
+            return 3
+        }
+
+        return 2
+    }
+
+    /**
+     * Parses an integer with a fallback.
+     * @param {unknown} value Numeric candidate.
+     * @param {number} fallback Fallback value.
+     * @returns {number}
+     */
+    static #integerOrFallback(value, fallback) {
+        const number = Number(value)
+        return Number.isInteger(number) ? number : fallback
+    }
+
+    /**
+     * Removes undefined and blank-string values from a shallow object.
+     * @param {Record<string, unknown>} row Input row.
+     * @returns {Record<string, unknown>}
+     */
+    static #stripEmpty(row) {
+        return Object.fromEntries(
+            Object.entries(row).filter(
+                ([, value]) => value !== undefined && value !== ''
+            )
+        )
+    }
+}