altium-toolkit 1.0.8 → 1.0.10

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

@@ -0,0 +1,25 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "altium-toolkit.parser-compatibility-fuzz.a1",
+    "title": "Altium Toolkit Parser Compatibility Fuzz A1",
+    "type": "object",
+    "additionalProperties": true,
+    "required": ["schema", "summary", "cases"],
+    "properties": {
+        "schema": {
+            "const": "altium-toolkit.parser-compatibility-fuzz.a1"
+        },
+        "summary": {
+            "type": "object",
+            "additionalProperties": true
+        },
+        "cases": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "additionalProperties": true,
+                "required": ["key", "status"]
+            }
+        }
+    }
+}

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

@@ -0,0 +1,86 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "altium-toolkit.pcb.svg.semantics.a1",
+    "title": "Altium Toolkit PCB SVG Semantics A1",
+    "type": "object",
+    "additionalProperties": true,
+    "required": ["schema", "view", "layers", "elements"],
+    "properties": {
+        "schema": {
+            "const": "altium-toolkit.pcb.svg.semantics.a1"
+        },
+        "view": {
+            "type": "object",
+            "additionalProperties": true,
+            "properties": {
+                "kind": {
+                    "type": "string"
+                },
+                "layerSet": {
+                    "type": "object"
+                },
+                "board": {
+                    "type": "object"
+                }
+            }
+        },
+        "boardOutline": {
+            "type": "object"
+        },
+        "lookups": {
+            "type": "object",
+            "additionalProperties": true,
+            "properties": {
+                "netsByIndex": {
+                    "type": "object"
+                },
+                "netIndexByName": {
+                    "type": "object"
+                },
+                "netClassesByName": {
+                    "type": "object"
+                },
+                "componentsByIndex": {
+                    "type": "object"
+                },
+                "componentIndexByDesignator": {
+                    "type": "object"
+                },
+                "layersByKey": {
+                    "type": "object"
+                },
+                "layerKeyByDisplayName": {
+                    "type": "object"
+                }
+            }
+        },
+        "layers": {
+            "type": "array"
+        },
+        "elements": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "additionalProperties": true,
+                "required": ["elementKey", "primitive"],
+                "properties": {
+                    "elementKey": {
+                        "type": "string"
+                    },
+                    "primitive": {
+                        "type": "string"
+                    },
+                    "layerKey": {
+                        "type": "string"
+                    },
+                    "net": {
+                        "type": "string"
+                    },
+                    "component": {
+                        "type": "string"
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,63 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "urn:altium-toolkit:project-bundle:a1",
+    "title": "Altium Toolkit Project Bundle A1",
+    "type": "object",
+    "additionalProperties": true,
+    "required": [
+        "schema",
+        "kind",
+        "project",
+        "sheets",
+        "components",
+        "nets",
+        "indexes"
+    ],
+    "properties": {
+        "schema": {
+            "const": "urn:altium-toolkit:normalized-model:a1"
+        },
+        "kind": {
+            "const": "design-bundle"
+        },
+        "project": {
+            "type": "object"
+        },
+        "units": {
+            "type": "object",
+            "additionalProperties": {
+                "type": "string"
+            }
+        },
+        "variants": {
+            "type": "array"
+        },
+        "sheets": {
+            "type": "array"
+        },
+        "components": {
+            "type": "array"
+        },
+        "schematic_hierarchy": {
+            "type": "object"
+        },
+        "pnp": {
+            "type": "object"
+        },
+        "nets": {
+            "type": "array"
+        },
+        "annotations": {
+            "type": "object"
+        },
+        "indexes": {
+            "type": "object"
+        },
+        "bom": {
+            "type": "array"
+        },
+        "effectiveVariant": {
+            "type": "object"
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "altium-toolkit.project.document-graph.a1",
+    "title": "Altium Toolkit Project Document Graph A1",
+    "type": "object",
+    "additionalProperties": true,
+    "required": ["schema", "summary", "documents", "groups", "indexes"],
+    "properties": {
+        "schema": {
+            "const": "altium-toolkit.project.document-graph.a1"
+        },
+        "summary": {
+            "type": "object",
+            "additionalProperties": true
+        },
+        "documents": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "additionalProperties": true,
+                "required": ["normalizedPath", "kind"]
+            }
+        },
+        "groups": {
+            "type": "object",
+            "additionalProperties": true
+        },
+        "indexes": {
+            "type": "object",
+            "additionalProperties": true
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "altium-toolkit.schematic.svg.semantics.a1",
+    "title": "Altium Toolkit Schematic SVG Semantics A1",
+    "type": "object",
+    "additionalProperties": true,
+    "required": ["schema", "elements"],
+    "properties": {
+        "schema": {
+            "const": "altium-toolkit.schematic.svg.semantics.a1"
+        },
+        "nets": {
+            "type": "array"
+        },
+        "components": {
+            "type": "array"
+        },
+        "elements": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "additionalProperties": true,
+                "required": ["elementKey"],
+                "properties": {
+                    "elementKey": {
+                        "type": "string"
+                    },
+                    "primitive": {
+                        "type": "string"
+                    },
+                    "recordId": {
+                        "type": "string"
+                    },
+                    "component": {
+                        "type": "string"
+                    },
+                    "componentUniqueId": {
+                        "type": "string"
+                    },
+                    "net": {
+                        "type": "string"
+                    },
+                    "pin": {
+                        "type": "string"
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,39 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "altium-toolkit.svg-model-cross-link.a1",
+    "title": "Altium Toolkit SVG Model Cross-Link A1",
+    "type": "object",
+    "additionalProperties": true,
+    "required": [
+        "schema",
+        "documentKind",
+        "summary",
+        "missingElements",
+        "orphanElements",
+        "unresolvedReferences"
+    ],
+    "properties": {
+        "schema": {
+            "const": "altium-toolkit.svg-model-cross-link.a1"
+        },
+        "documentKind": {
+            "enum": ["schematic", "pcb", "unknown"]
+        },
+        "summary": {
+            "type": "object",
+            "additionalProperties": true
+        },
+        "missingElements": {
+            "type": "array"
+        },
+        "orphanElements": {
+            "type": "array"
+        },
+        "unresolvedReferences": {
+            "type": "array"
+        },
+        "metadata": {
+            "type": "object"
+        }
+    }
+}

package/docs/testing.md

@@ -16,10 +16,11 @@ The tests cover:
 
 - Binary and OLE helpers
 - Printable and binary Altium parser recovery for `.SchDoc`, `.PcbDoc`,
-  `.PcbLib`, and `.PrjPcb` entrypoints
+  `.PcbLib`, `.PrjPcb`, and `.IntLib` entrypoints
 - PCB primitive stream slicing and focused decoders for tracks, fills, arcs,
   vias, pads, text, regions, rules, raw records, board regions, ownership
-  indexes, sidecar PrimitiveParameters/Text tables, and embedded font metadata
+  indexes, sidecar PrimitiveParameters/Text tables, extended primitive
+  information, custom pad shapes, union metadata, and embedded font metadata
 - Obfuscated fake schematic and PCB fixture shards
 - Schematic SVG, side-resolved PCB SVG, BOM HTML, and static 3D summary
   renderers
@@ -27,4 +28,9 @@ The tests cover:
 
 Fixture data must remain repo-owned and obfuscated. Do not add native provided
 Altium files, real customer identifiers, real vendor identifiers, or
-source-descriptive fixture names.
+source-descriptive fixture names. The machine-readable
+`tests/fixtures/fixture-manifest.json` catalog tracks synthetic fixture coverage
+areas and must keep `assetPolicy` set to `repo-owned-synthetic-only`. Each
+fixture entry records `source: inline-synthetic-records` plus expected parser,
+SVG, schema, and diagnostic contracts so tests can catch drift between fake
+fixtures and public read-model coverage.

package/package.json

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

package/spec/library-scope.md

@@ -11,7 +11,8 @@ rendering primitives.
 
 ## In Scope
 
-- `.SchDoc`, `.PcbDoc`, `.PcbLib`, and `.PrjPcb` parsing from `ArrayBuffer`
+- `.SchDoc`, `.PcbDoc`, `.PcbLib`, `.PrjPcb`, and `.IntLib` parsing from
+  `ArrayBuffer`
 - OLE and binary stream helpers needed by parser recovery
 - Schematic SVG rendering
 - PCB SVG rendering
@@ -22,6 +23,9 @@ rendering primitives.
   SVG rendering
 - Read-only PCB primitive record registry metadata and base64 raw-record
   preservation for unsupported or partially decoded PcbDoc/PcbLib streams
+- Read-only PCB pad/via detail recovery, including hole tolerances,
+  mask/paste semantics, stack metadata, via-protection sidecars, custom pad
+  shape links, and PCB union metadata
 - Static 3D summary HTML
 - Parser worker entrypoint for host applications
 - Optional renderer CSS
@@ -37,3 +41,5 @@ rendering primitives.
 - STEP mesh loading and browser script injection
 - Model ZIP export UI and download orchestration
 - Server, deployment, and app metadata endpoints
+- Native document authoring, round-trip writing, GUI automation, and compiled
+  multi-sheet project netlist generation

package/src/core/altium/AltiumLayoutParser.mjs

@@ -114,19 +114,115 @@ export class AltiumLayoutParser {
             if (!match) continue
 
             const index = Number.parseInt(match[1], 10)
-            layers.push({
-                index,
-                name: getField(fields, key),
-                layerId: parseNumericField(
-                    fields,
-                    'V9_STACK_LAYER' + index + '_LAYERID'
-                )
-            })
+            layers.push(
+                AltiumLayoutParser.#stripUndefined({
+                    index,
+                    name: getField(fields, key),
+                    layerId: parseNumericField(
+                        fields,
+                        'V9_STACK_LAYER' + index + '_LAYERID'
+                    ),
+                    kind: AltiumLayoutParser.#firstLayerStackTextField(
+                        fields,
+                        index,
+                        ['KIND', 'TYPE', 'ROLE']
+                    ),
+                    material: AltiumLayoutParser.#firstLayerStackTextField(
+                        fields,
+                        index,
+                        ['MATERIAL', 'MATERIALNAME']
+                    ),
+                    thicknessMil:
+                        AltiumLayoutParser.#firstLayerStackNumericField(
+                            fields,
+                            index,
+                            ['THICKNESS', 'DIELECTRICTHICKNESS']
+                        ),
+                    copperThicknessMil:
+                        AltiumLayoutParser.#firstLayerStackNumericField(
+                            fields,
+                            index,
+                            ['COPPERTHICKNESS', 'COPPER_THICKNESS']
+                        ),
+                    copperWeight: AltiumLayoutParser.#firstLayerStackTextField(
+                        fields,
+                        index,
+                        ['COPPERWEIGHT', 'COPPER_WEIGHT']
+                    ),
+                    dielectricConstant:
+                        AltiumLayoutParser.#firstLayerStackNumericField(
+                            fields,
+                            index,
+                            ['DK', 'DIELECTRICCONSTANT', 'DIELECTRIC_CONSTANT']
+                        ),
+                    dissipationFactor:
+                        AltiumLayoutParser.#firstLayerStackNumericField(
+                            fields,
+                            index,
+                            ['DF', 'DISSIPATIONFACTOR', 'DISSIPATION_FACTOR']
+                        )
+                })
+            )
         }
 
         return layers.sort((left, right) => left.index - right.index)
     }
 
+    /**
+     * Reads the first non-empty text field from a layer-stack entry.
+     * @param {Record<string, string | string[]>} fields Source fields.
+     * @param {number} index Layer-stack index.
+     * @param {string[]} suffixes Candidate suffixes.
+     * @returns {string | undefined}
+     */
+    static #firstLayerStackTextField(fields, index, suffixes) {
+        for (const suffix of suffixes) {
+            const value = getField(
+                fields,
+                'V9_STACK_LAYER' + index + '_' + suffix
+            )
+            if (value) {
+                return value
+            }
+        }
+
+        return undefined
+    }
+
+    /**
+     * Reads the first finite numeric field from a layer-stack entry.
+     * @param {Record<string, string | string[]>} fields Source fields.
+     * @param {number} index Layer-stack index.
+     * @param {string[]} suffixes Candidate suffixes.
+     * @returns {number | undefined}
+     */
+    static #firstLayerStackNumericField(fields, index, suffixes) {
+        for (const suffix of suffixes) {
+            const value = parseNumericField(
+                fields,
+                'V9_STACK_LAYER' + index + '_' + suffix
+            )
+            if (value !== null) {
+                return value
+            }
+        }
+
+        return undefined
+    }
+
+    /**
+     * Removes undefined object values for stable parser output.
+     * @param {object} value Source object.
+     * @returns {object}
+     */
+    static #stripUndefined(value) {
+        return Object.fromEntries(
+            Object.entries(value).filter(
+                ([, entryValue]) => entryValue !== undefined
+            )
+        )
+    }
+
     /**
      * Extracts legacy primitive-layer names keyed by the numeric layer IDs used
      * by decoded binary track and fill streams.