@intelligentelectron/pcb-lens 0.0.1

package/dist/service.js

@@ -0,0 +1,1139 @@
+/**
+ * PCB Layout Service
+ *
+ * IPC-2581 XML streaming query methods.
+ * All methods take a file path to an IPC-2581 XML as input.
+ * All physical values (coordinates, trace widths) are normalized to microns.
+ */
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { attr, numAttr, streamAllLines, loadAllLines, scanLines } from "./xml-utils.js";
+// =============================================================================
+// File Validation
+// =============================================================================
+const validateFile = async (filePath) => {
+    try {
+        const s = await stat(filePath);
+        if (!s.isFile()) {
+            return { error: `'${filePath}' is not a file` };
+        }
+        if (!filePath.endsWith(".xml")) {
+            return { error: `'${filePath}' is not an XML file` };
+        }
+    }
+    catch {
+        return { error: `File not found: '${filePath}'` };
+    }
+    return null;
+};
+// =============================================================================
+// Unit Conversion
+// =============================================================================
+/**
+ * Conversion factors from IPC-2581 unit values to microns.
+ */
+const UNIT_TO_MICRON = {
+    MICRON: 1,
+    MILLIMETER: 1_000,
+    MM: 1_000,
+    INCH: 25_400,
+};
+/**
+ * Extract the micron conversion factor from the CadHeader element.
+ * Returns 1 if the file already uses MICRON or the unit is unrecognized.
+ */
+const extractMicronFactor = async (filePath) => {
+    let factor = 1;
+    await streamAllLines(filePath, (line) => {
+        if (line.includes("<CadHeader ")) {
+            const units = attr(line, "units")?.toUpperCase();
+            if (units && units in UNIT_TO_MICRON) {
+                factor = UNIT_TO_MICRON[units];
+            }
+            return false;
+        }
+    });
+    return factor;
+};
+/** Extract micron factor from in-memory lines. */
+const extractMicronFactorFromLines = (lines) => {
+    let factor = 1;
+    scanLines(lines, (line) => {
+        if (line.includes("<CadHeader ")) {
+            const units = attr(line, "units")?.toUpperCase();
+            if (units && units in UNIT_TO_MICRON) {
+                factor = UNIT_TO_MICRON[units];
+            }
+            return false;
+        }
+    });
+    return factor;
+};
+// =============================================================================
+// LineDesc Dictionary
+// =============================================================================
+/**
+ * Build a map of LineDesc IDs to their lineWidth values.
+ * These are defined in the Content/DictionaryLineDesc section.
+ */
+const buildLineDescDict = async (filePath) => {
+    const dict = new Map();
+    let currentId;
+    await streamAllLines(filePath, (line) => {
+        if (line.includes("<EntryLineDesc ")) {
+            currentId = attr(line, "id");
+        }
+        if (line.includes("<LineDesc ") && currentId) {
+            const width = numAttr(line, "lineWidth");
+            if (width !== undefined) {
+                dict.set(currentId, width);
+            }
+            currentId = undefined;
+        }
+        // Stop after Content section ends (LineDesc is always in Content)
+        if (line.includes("</Content>")) {
+            return false;
+        }
+    });
+    return dict;
+};
+// =============================================================================
+// get_design_overview
+// =============================================================================
+export const getDesignOverview = async (filePath) => {
+    const err = await validateFile(filePath);
+    if (err)
+        return err;
+    const fileStats = await stat(filePath);
+    let ipc2581Revision;
+    let stepName;
+    const layers = [];
+    const seenLayers = new Set();
+    let componentCount = 0;
+    const netNames = new Set();
+    // Track sections by top-level elements
+    const topLevelTags = [
+        "Content",
+        "LogicalNet",
+        "LogisticHeader",
+        "Bom",
+        "Ecad",
+        "PhyNet",
+        "LayerFeature",
+    ];
+    const tagPatterns = topLevelTags.map((tag) => [tag, new RegExp(`^\\s*<${tag}[\\s>]`)]);
+    const sectionMap = new Map();
+    let currentSection = null;
+    let currentSectionStart = 0;
+    let totalLineCount = 0;
+    await streamAllLines(filePath, (line, lineNumber) => {
+        totalLineCount = lineNumber;
+        // Detect IPC-2581 revision from root element
+        if (ipc2581Revision === undefined && line.includes("<IPC-2581")) {
+            ipc2581Revision = attr(line, "revision");
+        }
+        // Detect step name
+        if (stepName === undefined && line.includes("<Step ")) {
+            stepName = attr(line, "name");
+        }
+        // Collect layer definitions
+        if (line.includes("<LayerRef ") || line.includes("<Layer ")) {
+            const name = attr(line, "layerOrGroupRef") ?? attr(line, "name");
+            if (name && !seenLayers.has(name)) {
+                seenLayers.add(name);
+                const side = attr(line, "side");
+                const layerFunction = attr(line, "layerFunction");
+                const layerInfo = { name };
+                if (side)
+                    layerInfo.side = side;
+                if (layerFunction)
+                    layerInfo.layerFunction = layerFunction;
+                layers.push(layerInfo);
+            }
+        }
+        // Count components
+        if (line.includes("<Component ") && line.includes("refDes=")) {
+            componentCount++;
+        }
+        // Count unique nets
+        if (line.includes("<PhyNet ")) {
+            const netName = attr(line, "name");
+            if (netName)
+                netNames.add(netName);
+        }
+        // Track major sections
+        for (const [tag, pattern] of tagPatterns) {
+            if (pattern.test(line)) {
+                if (currentSection && currentSectionStart > 0) {
+                    sectionMap.set(currentSection, (sectionMap.get(currentSection) ?? 0) + (lineNumber - currentSectionStart));
+                }
+                currentSection = tag;
+                currentSectionStart = lineNumber;
+                break;
+            }
+        }
+    });
+    // Close last section
+    if (currentSection && currentSectionStart > 0) {
+        sectionMap.set(currentSection, (sectionMap.get(currentSection) ?? 0) + (totalLineCount - currentSectionStart + 1));
+    }
+    const sections = [...sectionMap.entries()].map(([name, lineCount]) => ({
+        name,
+        lineCount,
+    }));
+    return {
+        fileName: path.basename(filePath),
+        fileSizeBytes: fileStats.size,
+        totalLines: totalLineCount,
+        units: "MICRON",
+        ipc2581Revision,
+        stepName,
+        layers,
+        componentCount,
+        netCount: netNames.size,
+        sections: sections.sort((a, b) => b.lineCount - a.lineCount),
+    };
+};
+// =============================================================================
+// query_components
+// =============================================================================
+export const queryComponents = async (filePath, pattern) => {
+    const err = await validateFile(filePath);
+    if (err)
+        return err;
+    if (pattern.length > 200) {
+        return { error: "Regex pattern too long (max 200 characters)" };
+    }
+    let regex;
+    try {
+        regex = new RegExp(pattern, "i");
+    }
+    catch {
+        return { error: `Invalid regex pattern: '${pattern}'` };
+    }
+    const factor = await extractMicronFactor(filePath);
+    // Pass 1: Collect matching component placements from Component section.
+    // Structure:
+    //   <Component refDes="P10" packageRef="..." layerRef="BOTTOM" part="..." mountType="SMT">
+    //     <NonstandardAttribute name="VALUE" value="YL004-030-001" type="STRING"/>
+    //     <Xform rotation="90.000" mirror="true"/>
+    //     <Location x="70609.968" y="31259.780"/>
+    //   </Component>
+    const placements = new Map();
+    let currentRefdes = null;
+    await streamAllLines(filePath, (line) => {
+        if (line.includes("<Component ") && line.includes("refDes=")) {
+            const refdes = attr(line, "refDes");
+            if (refdes && regex.test(refdes)) {
+                currentRefdes = refdes;
+                placements.set(refdes, {
+                    refdes,
+                    packageRef: attr(line, "packageRef") ?? "",
+                    x: 0,
+                    y: 0,
+                    rotation: 0,
+                    layer: attr(line, "layerRef") ?? "",
+                    mountType: attr(line, "mountType"),
+                });
+            }
+            else {
+                currentRefdes = null;
+            }
+        }
+        if (currentRefdes && placements.has(currentRefdes)) {
+            const comp = placements.get(currentRefdes);
+            if (line.includes("<Location ")) {
+                const x = numAttr(line, "x");
+                const y = numAttr(line, "y");
+                if (x !== undefined)
+                    comp.x = x * factor;
+                if (y !== undefined)
+                    comp.y = y * factor;
+            }
+            if (line.includes("<Xform ")) {
+                const rotation = numAttr(line, "rotation");
+                if (rotation !== undefined)
+                    comp.rotation = rotation;
+            }
+            if (line.includes("</Component>")) {
+                currentRefdes = null;
+            }
+        }
+        // Stop after Placement section (components come before PhyNet)
+        if (line.includes("<PhyNetGroup ") || line.includes("</Step>")) {
+            return false;
+        }
+    });
+    if (placements.size === 0) {
+        return { pattern, units: "MICRON", matches: [] };
+    }
+    // Pass 2: Collect BOM data for matched refdes.
+    // Structure:
+    //   <BomItem OEMDesignNumberRef="..." quantity="1" pinCount="14" category="ELECTRICAL">
+    //     <RefDes name="P10" packageRef="..." populate="true" layerRef="BOTTOM"/>
+    //     <RefDes name="P9" .../>
+    //     <Characteristics category="ELECTRICAL">
+    //       <Textual ... textualCharacteristicName="DEVICE_TYPE" textualCharacteristicValue="..."/>
+    //       <Textual ... textualCharacteristicName="COMP_VALUE" textualCharacteristicValue="..."/>
+    //     </Characteristics>
+    //   </BomItem>
+    const bomCharacteristics = new Map();
+    const bomDescriptions = new Map();
+    let currentBomRefdes = [];
+    let currentBomChars = {};
+    let currentBomDesc;
+    await streamAllLines(filePath, (line) => {
+        if (line.includes("<BomItem ")) {
+            currentBomRefdes = [];
+            currentBomChars = {};
+            currentBomDesc = attr(line, "OEMDesignNumberRef");
+        }
+        if (line.includes("<RefDes ")) {
+            const name = attr(line, "name");
+            if (name && placements.has(name)) {
+                currentBomRefdes.push(name);
+            }
+        }
+        if (line.includes("<Textual ")) {
+            const charName = attr(line, "textualCharacteristicName");
+            const charValue = attr(line, "textualCharacteristicValue");
+            if (charName && charValue) {
+                currentBomChars[charName] = charValue;
+            }
+        }
+        if (line.includes("</BomItem>")) {
+            for (const refdes of currentBomRefdes) {
+                bomCharacteristics.set(refdes, { ...currentBomChars });
+                if (currentBomDesc) {
+                    bomDescriptions.set(refdes, currentBomDesc);
+                }
+            }
+            currentBomRefdes = [];
+            currentBomChars = {};
+            currentBomDesc = undefined;
+        }
+        if (line.includes("</Bom>")) {
+            return false;
+        }
+    });
+    // Merge placement + BOM
+    const matches = [];
+    for (const [refdes, placement] of placements) {
+        matches.push({
+            ...placement,
+            description: bomDescriptions.get(refdes),
+            characteristics: bomCharacteristics.get(refdes) ?? {},
+        });
+    }
+    matches.sort((a, b) => a.refdes.localeCompare(b.refdes));
+    return { pattern, units: "MICRON", matches };
+};
+// =============================================================================
+// query_net
+// =============================================================================
+export const queryNet = async (filePath, pattern) => {
+    const err = await validateFile(filePath);
+    if (err)
+        return err;
+    if (pattern.length > 200) {
+        return { error: "Regex pattern too long (max 200 characters)" };
+    }
+    let regex;
+    try {
+        regex = new RegExp(pattern, "i");
+    }
+    catch {
+        return { error: `Invalid regex pattern: '${pattern}'` };
+    }
+    const factor = await extractMicronFactor(filePath);
+    // Pass 1: Find matching net name from PhyNet section
+    let matchedNetName = null;
+    await streamAllLines(filePath, (line) => {
+        if (line.includes("<PhyNet ")) {
+            const name = attr(line, "name");
+            if (name && regex.test(name)) {
+                if (!matchedNetName)
+                    matchedNetName = name;
+                return false; // Found it, stop
+            }
+        }
+    });
+    if (!matchedNetName) {
+        return { error: `No net matching pattern '${pattern}' found` };
+    }
+    // Pass 2: Build LineDesc dictionary (for resolving trace widths)
+    const lineDescDict = await buildLineDescDict(filePath);
+    // Pass 3: Single pass through LayerFeature sections.
+    // Collect pins, routing, and vias for the matched net.
+    //
+    // Structure in LayerFeature:
+    //   <LayerFeature layerRef="TOP">
+    //     <Set net="VDD_3V3B">                         ← routing Set
+    //       <Features>
+    //         <Polyline>
+    //           <LineDescRef id="ROUND_1500"/>          ← trace width ref
+    //         </Polyline>
+    //       </Features>
+    //     </Set>
+    //     <Set net="DGND" testPoint="false" plate="true">  ← pad Set
+    //       <Pad padstackDefRef="60C32D">
+    //         <PinRef pin="43" componentRef="P9"/>      ← pin connection
+    //       </Pad>
+    //     </Set>
+    const pins = [];
+    const pinsSeen = new Set();
+    const routeMap = new Map();
+    const viaMap = new Map();
+    const skipLayers = new Set(["REF-route", "REF-both"]);
+    let currentLayerName = "";
+    let insideMatchedSet = false;
+    let currentSetHasPolyline = false;
+    let currentSetLineDescId;
+    let currentSetInlineWidth;
+    let currentSetGeometry;
+    await streamAllLines(filePath, (line) => {
+        // Track which LayerFeature we're in
+        if (line.includes("<LayerFeature ")) {
+            currentLayerName = attr(line, "layerRef") ?? "";
+        }
+        // Detect <Set net="..."> matching our target net (skip phantom REF layers)
+        if (line.includes("<Set ")) {
+            const netName = attr(line, "net");
+            insideMatchedSet = netName === matchedNetName && !skipLayers.has(currentLayerName);
+            currentSetHasPolyline = false;
+            currentSetLineDescId = undefined;
+            currentSetInlineWidth = undefined;
+            currentSetGeometry = attr(line, "geometry");
+        }
+        if (insideMatchedSet) {
+            // Collect pin references
+            if (line.includes("<PinRef ")) {
+                const compRef = attr(line, "componentRef");
+                const pin = attr(line, "pin");
+                if (compRef && pin) {
+                    const key = `${compRef}.${pin}`;
+                    if (!pinsSeen.has(key)) {
+                        pinsSeen.add(key);
+                        pins.push({ refdes: compRef, pin });
+                    }
+                }
+            }
+            // Track polyline (trace) segments
+            if (line.includes("<Polyline")) {
+                currentSetHasPolyline = true;
+            }
+            // Capture LineDescRef for width resolution (dictionary reference)
+            if (line.includes("<LineDescRef ")) {
+                currentSetLineDescId = attr(line, "id");
+            }
+            // Capture inline LineDesc for width (direct definition inside Polyline)
+            if (line.includes("<LineDesc ") && !line.includes("<EntryLineDesc ")) {
+                const inlineWidth = numAttr(line, "lineWidth");
+                if (inlineWidth !== undefined) {
+                    currentSetInlineWidth = inlineWidth;
+                }
+            }
+            // Track vias: <Hole platingStatus="VIA"> in DRILL layers
+            if (line.includes("<Hole ")) {
+                const platingStatus = attr(line, "platingStatus");
+                if (platingStatus === "VIA") {
+                    const diameter = numAttr(line, "diameter");
+                    const key = currentSetGeometry ?? `dia_${diameter ?? "unknown"}`;
+                    viaMap.set(key, (viaMap.get(key) ?? 0) + 1);
+                }
+            }
+            if (line.includes("</Set>")) {
+                // Finalize the Set: if it had a polyline, record the route segment
+                if (currentSetHasPolyline && currentLayerName) {
+                    if (!routeMap.has(currentLayerName)) {
+                        routeMap.set(currentLayerName, { widths: new Set(), segments: 0 });
+                    }
+                    const layerRoute = routeMap.get(currentLayerName);
+                    layerRoute.segments++;
+                    // Resolve width: prefer LineDescRef dictionary lookup, fall back to inline LineDesc
+                    if (currentSetLineDescId) {
+                        const width = lineDescDict.get(currentSetLineDescId);
+                        if (width !== undefined) {
+                            layerRoute.widths.add(width * factor);
+                        }
+                    }
+                    else if (currentSetInlineWidth !== undefined) {
+                        layerRoute.widths.add(currentSetInlineWidth * factor);
+                    }
+                }
+                insideMatchedSet = false;
+            }
+        }
+    });
+    const routing = [];
+    for (const [layerName, data] of routeMap) {
+        routing.push({
+            layerName,
+            traceWidths: [...data.widths].sort((a, b) => a - b),
+            segmentCount: data.segments,
+        });
+    }
+    const vias = [];
+    for (const [padstackRef, count] of viaMap) {
+        vias.push({ padstackRef, count });
+    }
+    const totalSegments = routing.reduce((sum, r) => sum + r.segmentCount, 0);
+    const totalVias = vias.reduce((sum, v) => sum + v.count, 0);
+    const layersUsed = routing.map((r) => r.layerName).sort();
+    return {
+        netName: matchedNetName,
+        units: "MICRON",
+        pins,
+        routing,
+        vias,
+        totalSegments,
+        totalVias,
+        layersUsed,
+    };
+};
+// =============================================================================
+// render_net
+// =============================================================================
+/**
+ * Fixed colors for well-known layers; inner layers get dynamic colors.
+ */
+const FIXED_LAYER_COLORS = {
+    TOP: "#e74c3c",
+    BOTTOM: "#3498db",
+};
+const INNER_LAYER_PALETTE = [
+    "#2ecc71", // green
+    "#9b59b6", // purple
+    "#f39c12", // orange
+    "#1abc9c", // teal
+    "#e67e22", // dark orange
+    "#3498db", // (fallback blue variant — won't collide since BOTTOM is already assigned)
+    "#e84393", // pink
+    "#00cec9", // cyan
+];
+/**
+ * Build a color map for layers actually present in the rendered data.
+ * TOP and BOTTOM get fixed colors; inner layers get assigned from the palette.
+ */
+const buildLayerColors = (layers) => {
+    const colorMap = new Map();
+    let paletteIdx = 0;
+    for (const layer of layers) {
+        const upper = layer.toUpperCase();
+        if (upper === "TOP" || upper === "BOTTOM") {
+            colorMap.set(layer, FIXED_LAYER_COLORS[upper]);
+        }
+        else {
+            colorMap.set(layer, INNER_LAYER_PALETTE[paletteIdx % INNER_LAYER_PALETTE.length]);
+            paletteIdx++;
+        }
+    }
+    return colorMap;
+};
+// ---------------------------------------------------------------------------
+// Extraction passes (in-memory line scanning)
+// ---------------------------------------------------------------------------
+const extractShapes = (lines, f) => {
+    const shapes = new Map();
+    let currentId = "";
+    scanLines(lines, (line) => {
+        if (line.includes("<EntryStandard ")) {
+            currentId = attr(line, "id") ?? "";
+        }
+        if (currentId && line.includes("<RectCenter ")) {
+            const w = numAttr(line, "width");
+            const h = numAttr(line, "height");
+            if (w !== undefined && h !== undefined) {
+                shapes.set(currentId, { type: "rect", width: w * f, height: h * f });
+            }
+            currentId = "";
+        }
+        if (currentId && line.includes("<Circle ")) {
+            const d = numAttr(line, "diameter");
+            if (d !== undefined) {
+                shapes.set(currentId, { type: "circle", width: d * f, height: d * f });
+            }
+            currentId = "";
+        }
+        if (line.includes("</Content>"))
+            return false;
+    });
+    return shapes;
+};
+const extractPackages = (lines) => {
+    const packages = new Map();
+    let currentPkg = "";
+    let inPad = false;
+    let inPin = false;
+    let padPin = "";
+    let padOffset = { x: 0, y: 0 };
+    let padShapeId = "";
+    const commitPad = () => {
+        if (currentPkg && padPin && padShapeId) {
+            packages.get(currentPkg).set(padPin, {
+                offsetX: padOffset.x,
+                offsetY: padOffset.y,
+                shapeId: padShapeId,
+            });
+        }
+        padPin = "";
+        padOffset = { x: 0, y: 0 };
+        padShapeId = "";
+    };
+    scanLines(lines, (line) => {
+        if (line.includes("<Package ")) {
+            currentPkg = attr(line, "name") ?? "";
+            if (currentPkg && !packages.has(currentPkg)) {
+                packages.set(currentPkg, new Map());
+            }
+        }
+        if (line.includes("</Package>")) {
+            currentPkg = "";
+        }
+        if (!currentPkg)
+            return;
+        // RevA/B: <LandPattern> → <Pad> → <PinRef>/<Location>/<StandardPrimitiveRef> → </Pad>
+        if (line.includes("<Pad") && (line.includes("<Pad>") || line.includes("<Pad "))) {
+            inPad = true;
+            padPin = "";
+            padOffset = { x: 0, y: 0 };
+            padShapeId = "";
+        }
+        if (inPad) {
+            if (line.includes("<PinRef ")) {
+                padPin = attr(line, "pin") ?? "";
+            }
+            if (line.includes("<Location ")) {
+                const x = numAttr(line, "x");
+                const y = numAttr(line, "y");
+                if (x !== undefined)
+                    padOffset.x = x;
+                if (y !== undefined)
+                    padOffset.y = y;
+            }
+            if (line.includes("<StandardPrimitiveRef ")) {
+                padShapeId = attr(line, "id") ?? "";
+            }
+            if (line.includes("</Pad>")) {
+                commitPad();
+                inPad = false;
+            }
+        }
+        // RevC: <Pin number="..." ...> → <Location>/<StandardPrimitiveRef> → </Pin>
+        if (!inPad && line.includes("<Pin ") && line.includes("number=")) {
+            inPin = true;
+            padPin = attr(line, "number") ?? "";
+            padOffset = { x: 0, y: 0 };
+            padShapeId = "";
+        }
+        if (inPin) {
+            if (line.includes("<Location ")) {
+                const x = numAttr(line, "x");
+                const y = numAttr(line, "y");
+                if (x !== undefined)
+                    padOffset.x = x;
+                if (y !== undefined)
+                    padOffset.y = y;
+            }
+            if (line.includes("<StandardPrimitiveRef ")) {
+                padShapeId = attr(line, "id") ?? "";
+            }
+            if (line.includes("</Pin>")) {
+                commitPad();
+                inPin = false;
+            }
+        }
+        if (line.includes("<Component ") && line.includes("refDes="))
+            return false;
+    });
+    return packages;
+};
+const extractViaPadSizes = (lines) => {
+    const viaPads = new Map();
+    let currentName = "";
+    let currentDrill = 0;
+    let foundRegular = false;
+    scanLines(lines, (line) => {
+        if (line.includes("<PadStackDef ")) {
+            currentName = attr(line, "name") ?? "";
+            currentDrill = 0;
+            foundRegular = false;
+        }
+        if (currentName && line.includes("<PadstackHoleDef ")) {
+            currentDrill = numAttr(line, "diameter") ?? 0;
+        }
+        if (currentName && !foundRegular && line.includes('padUse="REGULAR"')) {
+            foundRegular = true;
+        }
+        if (currentName && foundRegular && line.includes("<StandardPrimitiveRef ")) {
+            const id = attr(line, "id") ?? "";
+            if (id && currentDrill > 0) {
+                viaPads.set(currentName, { padShapeId: id, drillDiameter: currentDrill });
+            }
+            foundRegular = false;
+        }
+        if (line.includes("</PadStackDef>")) {
+            currentName = "";
+        }
+        if (line.includes("<Package "))
+            return false;
+    });
+    return viaPads;
+};
+const extractComponents = (lines, f) => {
+    const components = [];
+    let current = null;
+    scanLines(lines, (line) => {
+        if (line.includes("<Component ") && line.includes("refDes=")) {
+            const refdes = attr(line, "refDes");
+            if (refdes) {
+                current = {
+                    refdes,
+                    packageRef: attr(line, "packageRef") ?? "",
+                    x: 0,
+                    y: 0,
+                    rotation: 0,
+                    mirror: false,
+                    layer: attr(line, "layerRef") ?? "",
+                };
+            }
+        }
+        if (current) {
+            if (line.includes("<Location ")) {
+                const x = numAttr(line, "x");
+                const y = numAttr(line, "y");
+                if (x !== undefined)
+                    current.x = x * f;
+                if (y !== undefined)
+                    current.y = y * f;
+            }
+            if (line.includes("<Xform ")) {
+                current.rotation = numAttr(line, "rotation") ?? 0;
+                current.mirror = attr(line, "mirror") === "true";
+            }
+            if (line.includes("</Component>")) {
+                components.push(current);
+                current = null;
+            }
+        }
+        if (line.includes("<PhyNetGroup ") || line.includes("</Step>"))
+            return false;
+    });
+    return components;
+};
+const extractProfile = (lines, f) => {
+    const points = [];
+    const arcs = new Map();
+    let inProfile = false;
+    scanLines(lines, (line) => {
+        if (line.includes("<Profile>")) {
+            inProfile = true;
+            return;
+        }
+        if (line.includes("</Profile>"))
+            return false;
+        if (!inProfile)
+            return;
+        if (line.includes("<PolyBegin ")) {
+            const x = numAttr(line, "x");
+            const y = numAttr(line, "y");
+            if (x !== undefined && y !== undefined)
+                points.push({ x: x * f, y: y * f });
+        }
+        if (line.includes("<PolyStepSegment ")) {
+            const x = numAttr(line, "x");
+            const y = numAttr(line, "y");
+            if (x !== undefined && y !== undefined)
+                points.push({ x: x * f, y: y * f });
+        }
+        if (line.includes("<PolyStepCurve ")) {
+            const x = numAttr(line, "x");
+            const y = numAttr(line, "y");
+            const cx = numAttr(line, "centerX");
+            const cy = numAttr(line, "centerY");
+            const cw = attr(line, "clockwise") === "true";
+            if (x !== undefined && y !== undefined && cx !== undefined && cy !== undefined) {
+                points.push({ x: x * f, y: y * f });
+                arcs.set(points.length - 1, {
+                    x: x * f,
+                    y: y * f,
+                    centerX: cx * f,
+                    centerY: cy * f,
+                    clockwise: cw,
+                });
+            }
+        }
+    });
+    return { points, arcs };
+};
+const extractNetGeometry = (lines, netName, f) => {
+    const traces = [];
+    const vias = [];
+    let currentLayer = "";
+    let insideMatchedSet = false;
+    let currentPoints = [];
+    let currentWidth = 0;
+    let inPolyline = false;
+    let currentGeometry = "";
+    const skipLayers = new Set(["REF-route", "REF-both"]);
+    scanLines(lines, (line) => {
+        if (line.includes("<LayerFeature ")) {
+            currentLayer = attr(line, "layerRef") ?? "";
+        }
+        if (line.includes("<Set ")) {
+            const net = attr(line, "net");
+            insideMatchedSet = net === netName && !skipLayers.has(currentLayer);
+            currentPoints = [];
+            currentWidth = 0;
+            inPolyline = false;
+            currentGeometry = attr(line, "geometry") ?? "";
+        }
+        if (!insideMatchedSet)
+            return;
+        if (line.includes("<Polyline")) {
+            inPolyline = true;
+            currentPoints = [];
+            currentWidth = 0;
+        }
+        if (inPolyline) {
+            if (line.includes("<PolyBegin ")) {
+                const x = numAttr(line, "x");
+                const y = numAttr(line, "y");
+                if (x !== undefined && y !== undefined)
+                    currentPoints.push({ x: x * f, y: y * f });
+            }
+            if (line.includes("<PolyStepSegment ")) {
+                const x = numAttr(line, "x");
+                const y = numAttr(line, "y");
+                if (x !== undefined && y !== undefined)
+                    currentPoints.push({ x: x * f, y: y * f });
+            }
+            if (line.includes("<LineDesc ")) {
+                const w = numAttr(line, "lineWidth");
+                if (w !== undefined)
+                    currentWidth = w * f;
+            }
+            if (line.includes("</Polyline>")) {
+                if (currentPoints.length >= 2) {
+                    traces.push({ layer: currentLayer, points: [...currentPoints], width: currentWidth });
+                }
+                inPolyline = false;
+            }
+        }
+        if (line.includes("<Hole ")) {
+            const status = attr(line, "platingStatus");
+            if (status === "VIA") {
+                const x = numAttr(line, "x");
+                const y = numAttr(line, "y");
+                const d = (numAttr(line, "diameter") ?? 0.008) * f;
+                if (x !== undefined && y !== undefined) {
+                    vias.push({ x: x * f, y: y * f, drillDiameter: d, padstackRef: currentGeometry });
+                }
+            }
+        }
+        if (line.includes("</Set>"))
+            insideMatchedSet = false;
+    });
+    return { traces, vias };
+};
+const extractNetPins = (lines, netName) => {
+    const pins = [];
+    const seen = new Set();
+    let insideMatchedSet = false;
+    scanLines(lines, (line) => {
+        if (line.includes("<Set ")) {
+            insideMatchedSet = attr(line, "net") === netName;
+        }
+        if (insideMatchedSet && line.includes("<PinRef ")) {
+            const compRef = attr(line, "componentRef");
+            const pin = attr(line, "pin");
+            if (compRef && pin) {
+                const key = `${compRef}.${pin}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    pins.push({ refdes: compRef, pin });
+                }
+            }
+        }
+        if (line.includes("</Set>"))
+            insideMatchedSet = false;
+    });
+    return pins;
+};
+// ---------------------------------------------------------------------------
+// Geometry helpers
+// ---------------------------------------------------------------------------
+const transformPin = (comp, pinDef, f) => {
+    const rad = (comp.rotation * Math.PI) / 180;
+    const cos = Math.cos(rad);
+    const sin = Math.sin(rad);
+    let dx = pinDef.offsetX * f;
+    const dy = pinDef.offsetY * f;
+    if (comp.mirror)
+        dx = -dx;
+    return {
+        x: comp.x + dx * cos - dy * sin,
+        y: comp.y + dx * sin + dy * cos,
+    };
+};
+const svgArc = (prev, arc) => {
+    const r = Math.sqrt((arc.centerX - prev.x) ** 2 + (arc.centerY - prev.y) ** 2);
+    const sweepFlag = arc.clockwise ? 0 : 1;
+    return `A${r},${r} 0 0 ${sweepFlag} ${arc.x},${arc.y}`;
+};
+const generateSvg = (data, netName) => {
+    const { profile, shapes, packages, viaPadSizes, components, net, netPins, factor } = data;
+    // Build dynamic layer color map from layers actually used
+    const allLayers = [
+        ...new Set([
+            ...net.traces.map((t) => t.layer),
+            ...netPins
+                .map((np) => {
+                const comp = components.find((c) => c.refdes === np.refdes);
+                return comp?.layer ?? "";
+            })
+                .filter(Boolean),
+        ]),
+    ];
+    const layerColors = buildLayerColors(allLayers);
+    // Board bounds
+    const allPx = profile.points.map((p) => p.x);
+    const allPy = profile.points.map((p) => p.y);
+    const boardMinX = Math.min(...allPx);
+    const boardMaxX = Math.max(...allPx);
+    const boardMinY = Math.min(...allPy);
+    const boardMaxY = Math.max(...allPy);
+    const boardW = boardMaxX - boardMinX;
+    const boardH = boardMaxY - boardMinY;
+    const margin = Math.max(boardW, boardH) * 0.08;
+    const vbX = boardMinX - margin;
+    const vbY = boardMinY - margin;
+    const vbW = boardW + 2 * margin;
+    const vbH = boardH + 2 * margin;
+    const svgWidth = 1200;
+    const svgHeight = Math.round(svgWidth * (vbH / vbW));
+    const fontSize = boardW * 0.008;
+    const pinFontSize = boardW * 0.005;
+    const L = [];
+    L.push(`<svg xmlns="http://www.w3.org/2000/svg" width="${svgWidth}" height="${svgHeight}" viewBox="${vbX} ${vbY} ${vbW} ${vbH}">`);
+    L.push(`  <title>Net: ${netName}</title>`);
+    L.push(`  <rect x="${vbX}" y="${vbY}" width="${vbW}" height="${vbH}" fill="#1a1a2e"/>`);
+    L.push(`  <g transform="scale(1,-1) translate(0,${-(boardMinY + boardMaxY)})">`);
+    // Board outline
+    if (profile.points.length > 0) {
+        let d = `M${profile.points[0].x},${profile.points[0].y}`;
+        for (let i = 1; i < profile.points.length; i++) {
+            const arc = profile.arcs.get(i);
+            d += arc
+                ? ` ${svgArc(profile.points[i - 1], arc)}`
+                : ` L${profile.points[i].x},${profile.points[i].y}`;
+        }
+        d += " Z";
+        L.push(`    <path d="${d}" fill="#16213e" stroke="#e0e0e0" stroke-width="${boardW * 0.003}"/>`);
+    }
+    // Component dots
+    const compMap = new Map();
+    for (const c of components)
+        compMap.set(c.refdes, c);
+    const netRefdes = new Set(netPins.map((p) => p.refdes));
+    L.push(`    <!-- Components -->`);
+    L.push(`    <g>`);
+    for (const c of components) {
+        const onNet = netRefdes.has(c.refdes);
+        L.push(`      <circle cx="${c.x}" cy="${c.y}" r="${boardW * 0.0012}" fill="${onNet ? "#ffffff" : "#334155"}" opacity="${onNet ? 0.5 : 0.2}"/>`);
+    }
+    L.push(`    </g>`);
+    // Refdes labels for net components
+    L.push(`    <!-- Refdes labels -->`);
+    L.push(`    <g font-family="monospace" font-size="${fontSize}" fill="#ffffff">`);
+    const labeled = new Set();
+    for (const p of netPins) {
+        if (labeled.has(p.refdes))
+            continue;
+        labeled.add(p.refdes);
+        const comp = compMap.get(p.refdes);
+        if (!comp)
+            continue;
+        L.push(`      <text x="${comp.x}" y="${comp.y}" transform="scale(1,-1) translate(0,${-2 * comp.y})" dy="${-fontSize}">${comp.refdes}</text>`);
+    }
+    L.push(`    </g>`);
+    // Traces by layer
+    const byLayer = new Map();
+    for (const t of net.traces) {
+        const arr = byLayer.get(t.layer) ?? [];
+        arr.push(t);
+        byLayer.set(t.layer, arr);
+    }
+    for (const [layer, layerTraces] of byLayer) {
+        const color = layerColors.get(layer) ?? "#7f8c8d";
+        L.push(`    <!-- ${netName} — ${layer} -->`);
+        L.push(`    <g stroke="${color}" fill="none" stroke-linecap="round" stroke-linejoin="round" opacity="0.9">`);
+        for (const t of layerTraces) {
+            const sw = t.width > 0 ? t.width : boardW * 0.003;
+            const d = t.points.map((p, i) => `${i === 0 ? "M" : "L"}${p.x},${p.y}`).join(" ");
+            L.push(`      <path d="${d}" stroke-width="${sw}"/>`);
+        }
+        L.push(`    </g>`);
+    }
+    // SMD pads at pin locations
+    L.push(`    <!-- SMD Pads -->`);
+    L.push(`    <g>`);
+    for (const np of netPins) {
+        const comp = compMap.get(np.refdes);
+        if (!comp)
+            continue;
+        const pkg = packages.get(comp.packageRef);
+        if (!pkg)
+            continue;
+        const pinDef = pkg.get(np.pin);
+        if (!pinDef)
+            continue;
+        const pos = transformPin(comp, pinDef, factor);
+        const shape = shapes.get(pinDef.shapeId);
+        if (!shape)
+            continue;
+        const layer = comp.layer || "TOP";
+        const color = layerColors.get(layer) ?? "#7f8c8d";
+        if (shape.type === "rect") {
+            const hw = shape.width / 2;
+            const hh = shape.height / 2;
+            if (Math.abs(comp.rotation % 180) < 0.1) {
+                L.push(`      <rect x="${pos.x - hw}" y="${pos.y - hh}" width="${shape.width}" height="${shape.height}" fill="${color}" opacity="0.8"/>`);
+            }
+            else if (Math.abs((comp.rotation - 90) % 180) < 0.1) {
+                L.push(`      <rect x="${pos.x - hh}" y="${pos.y - hw}" width="${shape.height}" height="${shape.width}" fill="${color}" opacity="0.8"/>`);
+            }
+            else {
+                const rad = (comp.rotation * Math.PI) / 180;
+                L.push(`      <rect x="${-hw}" y="${-hh}" width="${shape.width}" height="${shape.height}" fill="${color}" opacity="0.8" transform="translate(${pos.x},${pos.y}) rotate(${rad * (180 / Math.PI)})"/>`);
+            }
+        }
+        else {
+            const r = shape.width / 2;
+            L.push(`      <circle cx="${pos.x}" cy="${pos.y}" r="${r}" fill="${color}" opacity="0.8"/>`);
+        }
+    }
+    L.push(`    </g>`);
+    // Vias
+    if (net.vias.length > 0) {
+        L.push(`    <!-- Vias -->`);
+        L.push(`    <g>`);
+        for (const v of net.vias) {
+            const viaDef = viaPadSizes.get(v.padstackRef);
+            let padDiameter;
+            if (viaDef) {
+                const padShape = shapes.get(viaDef.padShapeId);
+                padDiameter = padShape ? padShape.width : v.drillDiameter * 2.25;
+            }
+            else {
+                padDiameter = v.drillDiameter * 2.25;
+            }
+            const padR = padDiameter / 2;
+            const drillR = v.drillDiameter / 2;
+            L.push(`      <circle cx="${v.x}" cy="${v.y}" r="${padR}" fill="#c8a415" stroke="#a08410" stroke-width="${boardW * 0.0008}"/>`);
+            L.push(`      <circle cx="${v.x}" cy="${v.y}" r="${drillR}" fill="#1a1a2e"/>`);
+        }
+        L.push(`    </g>`);
+    }
+    // Pin labels
+    L.push(`    <!-- Pin labels -->`);
+    L.push(`    <g font-family="monospace" font-size="${pinFontSize}" fill="#f1c40f" text-anchor="middle">`);
+    for (const np of netPins) {
+        const comp = compMap.get(np.refdes);
+        if (!comp)
+            continue;
+        const pkg = packages.get(comp.packageRef);
+        const pinDef = pkg?.get(np.pin);
+        if (pinDef) {
+            const pos = transformPin(comp, pinDef, factor);
+            L.push(`      <text x="${pos.x}" y="${pos.y}" transform="scale(1,-1) translate(0,${-2 * pos.y})" dy="${pinFontSize * 1.8}">${np.refdes}.${np.pin}</text>`);
+        }
+    }
+    L.push(`    </g>`);
+    // Legend
+    const legendX = vbX + margin * 0.3;
+    const legendY = boardMaxY + margin * 0.5;
+    const legendFS = boardW * 0.01;
+    L.push(`    <!-- Legend -->`);
+    L.push(`    <g font-family="monospace" font-size="${legendFS}" transform="scale(1,-1) translate(0,${-2 * legendY})">`);
+    let ly = legendY;
+    for (const [layer, color] of layerColors) {
+        L.push(`      <rect x="${legendX}" y="${ly}" width="${legendFS}" height="${legendFS}" fill="${color}"/>`);
+        L.push(`      <text x="${legendX + legendFS * 1.5}" y="${ly + legendFS * 0.85}" fill="#e0e0e0">${layer}</text>`);
+        ly += legendFS * 1.4;
+    }
+    L.push(`    </g>`);
+    L.push(`  </g>`);
+    L.push(`</svg>`);
+    return L.join("\n");
+};
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+export const renderNet = async (filePath, pattern) => {
+    const err = await validateFile(filePath);
+    if (err)
+        return err;
+    if (pattern.length > 200) {
+        return { error: "Regex pattern too long (max 200 characters)" };
+    }
+    let regex;
+    try {
+        regex = new RegExp(pattern, "i");
+    }
+    catch {
+        return { error: `Invalid regex pattern: '${pattern}'` };
+    }
+    const lines = await loadAllLines(filePath);
+    // Find matching net name
+    let matchedNetName = null;
+    scanLines(lines, (line) => {
+        if (line.includes("<PhyNet ")) {
+            const name = attr(line, "name");
+            if (name && regex.test(name)) {
+                matchedNetName = name;
+                return false;
+            }
+        }
+    });
+    if (!matchedNetName) {
+        return { error: `No net matching pattern '${pattern}' found` };
+    }
+    const factor = extractMicronFactorFromLines(lines);
+    const shapes = extractShapes(lines, factor);
+    const packages = extractPackages(lines);
+    const viaPadSizes = extractViaPadSizes(lines);
+    const components = extractComponents(lines, factor);
+    const profile = extractProfile(lines, factor);
+    const net = extractNetGeometry(lines, matchedNetName, factor);
+    const netPins = extractNetPins(lines, matchedNetName);
+    // Count resolved pads
+    const compMap = new Map(components.map((c) => [c.refdes, c]));
+    let resolvedPads = 0;
+    for (const np of netPins) {
+        const comp = compMap.get(np.refdes);
+        if (!comp)
+            continue;
+        const pkg = packages.get(comp.packageRef);
+        if (!pkg)
+            continue;
+        const pin = pkg.get(np.pin);
+        if (pin && shapes.has(pin.shapeId))
+            resolvedPads++;
+    }
+    const svg = generateSvg({ profile, shapes, packages, viaPadSizes, components, net, netPins, factor }, matchedNetName);
+    const layersUsed = [...new Set(net.traces.map((t) => t.layer))].sort();
+    return {
+        netName: matchedNetName,
+        units: "MICRON",
+        svg,
+        stats: {
+            traceCount: net.traces.length,
+            viaCount: net.vias.length,
+            pinCount: netPins.length,
+            resolvedPads,
+            layersUsed,
+        },
+    };
+};
+//# sourceMappingURL=service.js.map