easyeda-mcp-pro 0.3.2 → 0.5.2

package/dist/net-validation/schema.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Net validation — schema types and naming convention definitions.
+ *
+ * Defines the input contract for net validation functions and the
+ * convention sets used to classify net names into analog, digital,
+ * power, ground, and high-voltage domains.
+ *
+ * @module
+ */
+/**
+ * Electrical domain inferred from a net name.
+ *
+ * Used by naming-convention rules to detect misclassifications
+ * (e.g. an analog signal connected to a digital rail).
+ */
+export declare enum NetDomain {
+    /** General-purpose analogue signal (e.g. "SENSE", "FB", "VREF"). */
+    Analog = "analog",
+    /** Digital signal, bus, or protocol (e.g. "I2C_SCL", "UART_TXD"). */
+    Digital = "digital",
+    /** Power rail or voltage supply (e.g. "3V3", "VIN", "VCC"). */
+    Power = "power",
+    /** Ground or return (e.g. "GND", "AGND", "DGND", "PGND"). */
+    Ground = "ground",
+    /** AC mains or high-voltage domain (e.g. "L", "N", "HV_BULK"). */
+    HighVoltage = "high-voltage",
+    /** Clock or timing signal (e.g. "CLK_32K", "MCO"). */
+    Clock = "clock",
+    /** Reset or control signal (e.g. "nRST", "EN", "PWR_ON"). */
+    Control = "control",
+    /** Unclassified or custom. */
+    Other = "other"
+}
+/**
+ * Naming convention pattern sets used to classify a net name into a domain.
+ *
+ * Each entry is a list of **case-insensitive** substrings / regex patterns
+ * that, when matched against a net name, assign it to the corresponding
+ * {@link NetDomain}.
+ */
+export declare const NET_DOMAIN_PATTERNS: Record<Exclude<NetDomain, NetDomain.Other>, RegExp[]>;
+/**
+ * Net names that are reserved for specific purposes and should not be
+ * reassigned to other signal types.
+ */
+export declare const RESERVED_NET_NAMES: Set<string>;
+/**
+ * Minimum set of power nets that a complete design should contain
+ * (case-insensitive matching).
+ */
+export declare const REQUIRED_POWER_NETS: Set<string>;
+/**
+ * Minimum set of ground nets that a complete design should contain.
+ */
+export declare const REQUIRED_GROUND_NETS: Set<string>;
+/**
+ * Map from NetType to expected naming convention domain.
+ * A net with a given NetType should have a name matching the
+ * corresponding domain(s).
+ */
+export declare const NET_TYPE_EXPECTED_DOMAIN: Record<string, NetDomain[]>;
+/**
+ * A minimal net representation for validation purposes.
+ *
+ * This is intentionally decoupled from the full CircuitIR NetSchema
+ * so that validation can operate on net data from any source
+ * (CircuitIR, EasyEDA bridge, hand-authored test data).
+ */
+export interface NetValidationEntry {
+    /** Unique net identifier. */
+    id: string;
+    /** Human-readable net name (e.g. "3V3", "I2C_SCL", "GND"). */
+    name: string;
+    /** Net type classification. */
+    type: 'power' | 'signal' | 'ground';
+    /** Connected device pins, may be empty for floating nets. */
+    nodes: Array<{
+        deviceRef: string;
+        pin: string;
+    }>;
+}
+/**
+ * A minimal device representation for validation.
+ */
+export interface DeviceValidationEntry {
+    /** Device identifier (matches deviceRef in net nodes). */
+    id: string;
+    /** Reference designator (e.g. "U1", "R3"). */
+    ref: string;
+    /** Functional category for determining required pins. */
+    category?: string;
+}
+/**
+ * A hierarchical port / interface for cross-sheet validation.
+ */
+export interface InterfaceValidationEntry {
+    /** Interface identifier. */
+    id: string;
+    /** Interface / port name. */
+    name: string;
+    /** Pins on this interface. */
+    pinout: Array<{
+        pin: string;
+        signal: string;
+        type?: string;
+    }>;
+}
+/**
+ * Complete input to the net validation function.
+ */
+export interface NetValidationInput {
+    /** Nets to validate. */
+    nets: NetValidationEntry[];
+    /** Optional device list for unconnected-pin checks. */
+    devices?: DeviceValidationEntry[];
+    /** Optional interface list for cross-sheet checks. */
+    interfaces?: InterfaceValidationEntry[];
+}

package/dist/net-validation/schema.js

@@ -0,0 +1,140 @@
+/**
+ * Net validation — schema types and naming convention definitions.
+ *
+ * Defines the input contract for net validation functions and the
+ * convention sets used to classify net names into analog, digital,
+ * power, ground, and high-voltage domains.
+ *
+ * @module
+ */
+// ── Naming convention categories ──────────────────────────────────────────
+/**
+ * Electrical domain inferred from a net name.
+ *
+ * Used by naming-convention rules to detect misclassifications
+ * (e.g. an analog signal connected to a digital rail).
+ */
+export var NetDomain;
+(function (NetDomain) {
+    /** General-purpose analogue signal (e.g. "SENSE", "FB", "VREF"). */
+    NetDomain["Analog"] = "analog";
+    /** Digital signal, bus, or protocol (e.g. "I2C_SCL", "UART_TXD"). */
+    NetDomain["Digital"] = "digital";
+    /** Power rail or voltage supply (e.g. "3V3", "VIN", "VCC"). */
+    NetDomain["Power"] = "power";
+    /** Ground or return (e.g. "GND", "AGND", "DGND", "PGND"). */
+    NetDomain["Ground"] = "ground";
+    /** AC mains or high-voltage domain (e.g. "L", "N", "HV_BULK"). */
+    NetDomain["HighVoltage"] = "high-voltage";
+    /** Clock or timing signal (e.g. "CLK_32K", "MCO"). */
+    NetDomain["Clock"] = "clock";
+    /** Reset or control signal (e.g. "nRST", "EN", "PWR_ON"). */
+    NetDomain["Control"] = "control";
+    /** Unclassified or custom. */
+    NetDomain["Other"] = "other";
+})(NetDomain || (NetDomain = {}));
+/**
+ * Naming convention pattern sets used to classify a net name into a domain.
+ *
+ * Each entry is a list of **case-insensitive** substrings / regex patterns
+ * that, when matched against a net name, assign it to the corresponding
+ * {@link NetDomain}.
+ */
+export const NET_DOMAIN_PATTERNS = {
+    [NetDomain.Power]: [
+        /^[0-9]+V[0-9]*/, // 3V3, 5V, 12V, 1V8
+        /^V(CC|DD|EE|SS|IN|OUT|BAT|REF|PP|DRV)/i, // VCC, VDD, VIN, VOUT, VBAT
+        /_V(CC|DD|EE|SS|IN|OUT)\b/i, // AVCC, DVDD
+        /PWR/i,
+        /POWER/i,
+        /VSUPPLY/i,
+    ],
+    [NetDomain.Ground]: [
+        /^GND$/i,
+        /GND\b/i, // AGND, DGND, PGND, GNDD, GNDA
+        /^VSS$/i,
+        /GROUND/i,
+        /^RETURN$/i,
+    ],
+    [NetDomain.Analog]: [
+        /SENSE/i,
+        /FB\b/i, // feedback
+        /VREF/i,
+        /REFIN/i,
+        /REFOUT/i,
+        /COMP/i, // comparator output
+        /OSC/i,
+        /FILTER/i,
+        /AGND\b/i, // analog ground reference
+    ],
+    [NetDomain.Digital]: [
+        /^(I2C|SPI|UART|CAN|USB|ETH|MII|RMII|SDIO|I2S|PCM)_/i,
+        /_(SCL|SDA|MOSI|MISO|CS|SCK|TXD|RXD|RTS|CTS|TX|RX)\b/i,
+        /^[A-Z]+_[A-Z]+(_[A-Z]+)*$/, // SHOUTING_CASE signals like DATA_READY, INT_OUT
+    ],
+    [NetDomain.Clock]: [/CLK/i, /_MCO\b/i, /XTAL/i, /OSC/i, /TIM/i, /PWM/i],
+    [NetDomain.Control]: [
+        /^n?(RST|RESET|EN|ENABLE|CS|CE|SHDN|PWR_UP|PWR_DN|WAKE|SLEEP)\b/i,
+        /_EN\b/i,
+        /_nRST\b/i,
+        /_OE\b/i,
+    ],
+    [NetDomain.HighVoltage]: [
+        /^HV/i,
+        /^AC_/i,
+        /^L\b/i, // Live (mains)
+        /^N\b/i, // Neutral (mains)
+        /_HV\b/i,
+        /MAINS/i,
+        /BULK/i,
+        /RECT/i,
+    ],
+};
+// ── Reserved net names ────────────────────────────────────────────────────
+/**
+ * Net names that are reserved for specific purposes and should not be
+ * reassigned to other signal types.
+ */
+export const RESERVED_NET_NAMES = new Set([
+    'GND',
+    'VSS',
+    'VCC',
+    'VDD',
+    'VEE',
+    'VSSA',
+    'VDDA',
+    'AGND',
+    'DGND',
+    'PGND',
+    'GNDA',
+    'GNDD',
+    'GNDP',
+]);
+// ── Power / Ground expectation sets ────────────────────────────────────────
+/**
+ * Minimum set of power nets that a complete design should contain
+ * (case-insensitive matching).
+ */
+export const REQUIRED_POWER_NETS = new Set(['VIN', '3V3']);
+/**
+ * Minimum set of ground nets that a complete design should contain.
+ */
+export const REQUIRED_GROUND_NETS = new Set(['GND']);
+// ── Convention mappings ───────────────────────────────────────────────────
+/**
+ * Map from NetType to expected naming convention domain.
+ * A net with a given NetType should have a name matching the
+ * corresponding domain(s).
+ */
+export const NET_TYPE_EXPECTED_DOMAIN = {
+    power: [NetDomain.Power],
+    ground: [NetDomain.Ground],
+    signal: [
+        NetDomain.Digital,
+        NetDomain.Analog,
+        NetDomain.Clock,
+        NetDomain.Control,
+        NetDomain.Other,
+    ],
+};
+//# sourceMappingURL=schema.js.map

package/dist/net-validation/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/net-validation/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,6EAA6E;AAE7E;;;;;GAKG;AACH,MAAM,CAAN,IAAY,SAiBX;AAjBD,WAAY,SAAS;IACnB,oEAAoE;IACpE,8BAAiB,CAAA;IACjB,qEAAqE;IACrE,gCAAmB,CAAA;IACnB,+DAA+D;IAC/D,4BAAe,CAAA;IACf,6DAA6D;IAC7D,8BAAiB,CAAA;IACjB,kEAAkE;IAClE,yCAA4B,CAAA;IAC5B,sDAAsD;IACtD,4BAAe,CAAA;IACf,6DAA6D;IAC7D,gCAAmB,CAAA;IACnB,8BAA8B;IAC9B,4BAAe,CAAA;AACjB,CAAC,EAjBW,SAAS,KAAT,SAAS,QAiBpB;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAA0D;IACxF,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;QACjB,gBAAgB,EAAE,oBAAoB;QACtC,wCAAwC,EAAE,4BAA4B;QACtE,2BAA2B,EAAE,aAAa;QAC1C,MAAM;QACN,QAAQ;QACR,UAAU;KACX;IACD,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;QAClB,QAAQ;QACR,QAAQ,EAAE,+BAA+B;QACzC,QAAQ;QACR,SAAS;QACT,WAAW;KACZ;IACD,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;QAClB,QAAQ;QACR,OAAO,EAAE,WAAW;QACpB,OAAO;QACP,QAAQ;QACR,SAAS;QACT,OAAO,EAAE,oBAAoB;QAC7B,MAAM;QACN,SAAS;QACT,SAAS,EAAE,0BAA0B;KACtC;IACD,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE;QACnB,qDAAqD;QACrD,sDAAsD;QACtD,2BAA2B,EAAE,iDAAiD;KAC/E;IACD,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IACvE,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE;QACnB,iEAAiE;QACjE,QAAQ;QACR,UAAU;QACV,QAAQ;KACT;IACD,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE;QACvB,MAAM;QACN,OAAO;QACP,OAAO,EAAE,eAAe;QACxB,OAAO,EAAE,kBAAkB;QAC3B,QAAQ;QACR,QAAQ;QACR,OAAO;QACP,OAAO;KACR;CACF,CAAC;AAEF,6EAA6E;AAE7E;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC;IACxC,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;CACP,CAAC,CAAC;AAEH,8EAA8E;AAE9E;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;AAE3D;;GAEG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;AAErD,6EAA6E;AAE7E;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAgC;IACnE,KAAK,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC;IACxB,MAAM,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC;IAC1B,MAAM,EAAE;QACN,SAAS,CAAC,OAAO;QACjB,SAAS,CAAC,MAAM;QAChB,SAAS,CAAC,KAAK;QACf,SAAS,CAAC,OAAO;QACjB,SAAS,CAAC,KAAK;KAChB;CACF,CAAC"}

package/dist/net-validation/validation.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Net validation — wire-name and topology validation rules.
+ *
+ * Implements 10 validation rules that operate on {@link NetValidationInput}
+ * and produce structured {@link NetValidationIssue}s.
+ *
+ * Rules:
+ *  1. Floating net (zero nodes)
+ *  2. Duplicate net names
+ *  3. Accidental short (same device pin on different nets)
+ *  4. Missing power net
+ *  5. Missing ground net
+ *  6. Missing hierarchical port
+ *  7. Unconnected required pin
+ *  8. Inconsistent cross-sheet interface pins
+ *  9. Naming convention violation (domain mismatch)
+ * 10. Protected AC/high-voltage domain naming
+ *
+ * @module
+ */
+import { NetValidationResult } from './errors.js';
+import type { NetValidationInput } from './schema.js';
+/**
+ * Run all net validation rules against an input net list.
+ *
+ * Orchestrates 10 rules:
+ *  1. Floating nets            — error if net has zero nodes
+ *  2. Duplicate names          — error if multiple nets share a name
+ *  3. Accidental shorts        — error if one device pin belongs to multiple nets
+ *  4. Missing power            — error if no type=power net + warnings for specific names
+ *  5. Missing ground           — error if no type=ground net + warnings for specific names
+ *  6. Missing hierarchical port — error if interface references an unknown net
+ *  7. Unconnected required pins — warning if a device has zero connections
+ *  8. Cross-sheet consistency   — error if same-name interfaces have different pinouts
+ *  9. Naming convention         — warning if power/ground nets have non-standard names
+ * 10. Protected domain          — error if high-voltage net lacks protective naming
+ */
+export declare function validateNets(input: NetValidationInput): NetValidationResult;
+/**
+ * Validate nets and throw on the first error.
+ *
+ * Returns the full result on success. Throws the first `NetValidationIssue`
+ * found (as an error) if validation fails.
+ */
+export declare function validateNetsOrThrow(input: NetValidationInput): NetValidationResult;

package/dist/net-validation/validation.js

@@ -0,0 +1,369 @@
+/**
+ * Net validation — wire-name and topology validation rules.
+ *
+ * Implements 10 validation rules that operate on {@link NetValidationInput}
+ * and produce structured {@link NetValidationIssue}s.
+ *
+ * Rules:
+ *  1. Floating net (zero nodes)
+ *  2. Duplicate net names
+ *  3. Accidental short (same device pin on different nets)
+ *  4. Missing power net
+ *  5. Missing ground net
+ *  6. Missing hierarchical port
+ *  7. Unconnected required pin
+ *  8. Inconsistent cross-sheet interface pins
+ *  9. Naming convention violation (domain mismatch)
+ * 10. Protected AC/high-voltage domain naming
+ *
+ * @module
+ */
+import { NetValidationCode, netError, netWarning } from './errors.js';
+import { NET_DOMAIN_PATTERNS, NET_TYPE_EXPECTED_DOMAIN, REQUIRED_GROUND_NETS, REQUIRED_POWER_NETS, RESERVED_NET_NAMES, NetDomain, } from './schema.js';
+// ── Rule: floating nets ────────────────────────────────────────────────────
+function checkFloatingNets(input) {
+    const issues = [];
+    for (const net of input.nets) {
+        if (net.nodes.length === 0) {
+            issues.push(netError(NetValidationCode.NetFloating, `Net "${net.name}" (${net.id}) has no node connections — it is floating`, {
+                path: `nets[${input.nets.indexOf(net)}]`,
+                netName: net.name,
+                remediationHint: 'Connect this net to at least one device pin or remove it',
+            }));
+        }
+    }
+    return issues;
+}
+// ── Rule: duplicate net names ──────────────────────────────────────────────
+function checkDuplicateNetNames(input) {
+    const issues = [];
+    const nameMap = new Map();
+    for (const net of input.nets) {
+        const normalised = net.name.toUpperCase();
+        if (!nameMap.has(normalised)) {
+            nameMap.set(normalised, []);
+        }
+        nameMap.get(normalised).push(net);
+    }
+    for (const [name, nets] of nameMap) {
+        if (nets.length > 1) {
+            const ids = nets.map((n) => n.id).join(', ');
+            issues.push(netError(NetValidationCode.NetDuplicateName, `Net name "${name}" is used by ${nets.length} nets: ${ids}`, {
+                netName: name,
+                remediationHint: 'Rename conflicting nets or merge them if they are intended to be the same electrical node',
+                details: { matchingNetIds: nets.map((n) => n.id) },
+            }));
+        }
+    }
+    return issues;
+}
+// ── Rule: accidental shorts ────────────────────────────────────────────────
+function checkAccidentalShorts(input) {
+    const issues = [];
+    const pinToNets = new Map();
+    for (const net of input.nets) {
+        for (const node of net.nodes) {
+            const key = `${node.deviceRef}:${node.pin}`;
+            if (!pinToNets.has(key)) {
+                pinToNets.set(key, []);
+            }
+            pinToNets.get(key).push(net);
+        }
+    }
+    for (const [key, nets] of pinToNets) {
+        if (nets.length > 1) {
+            const parts = key.split(':');
+            issues.push(netError(NetValidationCode.NetAccidentalShort, `Device pin "${key}" is connected to ${nets.length} different nets: ${nets.map((n) => n.name).join(', ')}`, {
+                componentRef: parts[0],
+                pin: parts[1],
+                remediationHint: 'Ensure only one net connects to each device pin, or use a net junction if intentional',
+                details: {
+                    conflictingNets: nets.map((n) => ({ id: n.id, name: n.name })),
+                },
+            }));
+        }
+    }
+    return issues;
+}
+// ── Rule: missing power net ────────────────────────────────────────────────
+function checkMissingPowerNet(input) {
+    const issues = [];
+    // Check that at least one net has type=power
+    const powerNets = input.nets.filter((n) => n.type === 'power');
+    if (powerNets.length === 0) {
+        issues.push(netError(NetValidationCode.NetMissingPower, 'No power net found — the design must have at least one net of type=power', {
+            remediationHint: 'Add a power net (e.g. "3V3", "VIN", "VCC") with type="power"',
+        }));
+    }
+    // Also check for required specific power net names
+    for (const required of REQUIRED_POWER_NETS) {
+        const found = input.nets.some((n) => n.name.toUpperCase() === required.toUpperCase());
+        if (!found) {
+            issues.push(netWarning(NetValidationCode.NetMissingPower, `Required power net "${required}" not found in the design`, {
+                netName: required,
+                remediationHint: `Add a "${required}" power rail or ensure your power source is properly named`,
+            }));
+        }
+    }
+    return issues;
+}
+// ── Rule: missing ground net ───────────────────────────────────────────────
+function checkMissingGroundNet(input) {
+    const issues = [];
+    const groundNets = input.nets.filter((n) => n.type === 'ground');
+    if (groundNets.length === 0) {
+        issues.push(netError(NetValidationCode.NetMissingGround, 'No ground net found — the design must have at least one net of type=ground', {
+            remediationHint: 'Add a ground net (e.g. "GND") with type="ground"',
+        }));
+    }
+    // Also check for required specific ground net names
+    for (const required of REQUIRED_GROUND_NETS) {
+        const found = input.nets.some((n) => n.name.toUpperCase() === required.toUpperCase());
+        if (!found) {
+            issues.push(netWarning(NetValidationCode.NetMissingGround, `Required ground net "${required}" not found in the design`, {
+                netName: required,
+                remediationHint: `Add a "${required}" net with type="ground"`,
+            }));
+        }
+    }
+    return issues;
+}
+// ── Rule: missing hierarchical port ────────────────────────────────────────
+function checkMissingHierarchicalPorts(input) {
+    const issues = [];
+    if (!input.interfaces || input.interfaces.length === 0) {
+        return issues; // No interfaces defined — skip
+    }
+    const netNames = new Set(input.nets.map((n) => n.name.toUpperCase()));
+    for (const intf of input.interfaces) {
+        for (const pinEntry of intf.pinout) {
+            if (!netNames.has(pinEntry.signal.toUpperCase())) {
+                issues.push(netError(NetValidationCode.NetMissingHierarchicalPort, `Interface "${intf.name}" references signal "${pinEntry.signal}" (pin ${pinEntry.pin}) but no matching net was found`, {
+                    netName: pinEntry.signal,
+                    pin: pinEntry.pin,
+                    remediationHint: `Add a net named "${pinEntry.signal}" or update the interface pinout`,
+                    details: { interfaceName: intf.name },
+                }));
+            }
+        }
+    }
+    return issues;
+}
+// ── Rule: unconnected required pins ────────────────────────────────────────
+function checkUnconnectedPins(input) {
+    const issues = [];
+    if (!input.devices || input.devices.length === 0) {
+        return issues;
+    }
+    // Build set of connected pins
+    const connectedPins = new Set();
+    for (const net of input.nets) {
+        for (const node of net.nodes) {
+            connectedPins.add(`${node.deviceRef}:${node.pin}`);
+        }
+    }
+    // Check each device for unconnected pins
+    // For now, only flag devices with no connections at all (not individual pins,
+    // since we don't have a comprehensive required-pin list per device category)
+    for (const device of input.devices) {
+        const devicePins = [...connectedPins].filter((p) => p.startsWith(`${device.id}:`));
+        if (devicePins.length === 0) {
+            issues.push(netWarning(NetValidationCode.NetUnconnectedRequiredPin, `Device "${device.ref}" (${device.id}) has no pin connections`, {
+                componentRef: device.ref,
+                remediationHint: 'Connect at least one pin of this device to a net, or remove it if unused',
+            }));
+        }
+    }
+    return issues;
+}
+// ── Rule: inconsistent cross-sheet interfaces ──────────────────────────────
+function checkCrossSheetConsistency(input) {
+    const issues = [];
+    if (!input.interfaces || input.interfaces.length < 2) {
+        return issues; // Need at least 2 interfaces to compare
+    }
+    // For cross-sheet validation, interfaces with the same name on different
+    // sheets should have matching pinout lists
+    const byName = new Map();
+    for (const intf of input.interfaces) {
+        const key = intf.name.toUpperCase();
+        if (!byName.has(key)) {
+            byName.set(key, []);
+        }
+        byName.get(key).push(intf);
+    }
+    for (const [name, group] of byName) {
+        if (group.length < 2)
+            continue;
+        // Compare all interfaces with the same name (group.length >= 2 here)
+        const reference = group[0];
+        for (let i = 1; i < group.length; i++) {
+            const other = group[i];
+            // Check pin count matches
+            if (reference.pinout.length !== other.pinout.length) {
+                issues.push(netError(NetValidationCode.NetInconsistentCrossSheet, `Interface "${name}" has inconsistent pin counts: sheet 1 has ${reference.pinout.length} pins, sheet ${i + 1} has ${other.pinout.length} pins`, {
+                    remediationHint: 'Ensure all instances of this interface have the same pinout',
+                    details: {
+                        interfaceName: name,
+                        firstInstanceId: reference.id,
+                        otherInstanceId: other.id,
+                    },
+                }));
+                continue;
+            }
+            // Check individual pin names match
+            for (let j = 0; j < reference.pinout.length; j++) {
+                const refPin = reference.pinout[j];
+                const otherPin = other.pinout[j];
+                if (refPin.signal.toUpperCase() !== otherPin.signal.toUpperCase()) {
+                    issues.push(netError(NetValidationCode.NetInconsistentCrossSheet, `Interface "${name}" has mismatched signals at index ${j}: "${refPin.signal}" vs "${otherPin.signal}"`, {
+                        pin: refPin.pin,
+                        remediationHint: 'Update the interface pinout to match across all sheets',
+                        details: {
+                            interfaceName: name,
+                            expectedSignal: refPin.signal,
+                            actualSignal: otherPin.signal,
+                        },
+                    }));
+                }
+            }
+        }
+    }
+    return issues;
+}
+// ── Rule: naming convention violations ─────────────────────────────────────
+/**
+ * Classify a net name into one or more {@link NetDomain}s.
+ */
+function classifyNetDomain(name) {
+    const domains = new Set();
+    for (const [domain, patterns] of Object.entries(NET_DOMAIN_PATTERNS)) {
+        for (const pattern of patterns) {
+            if (pattern.test(name)) {
+                domains.add(domain);
+                break; // One match per domain is enough
+            }
+        }
+    }
+    return domains;
+}
+function checkNamingConventions(input) {
+    const issues = [];
+    for (const net of input.nets) {
+        const name = net.name;
+        // Skip reserved names (GND, VCC, etc.) — these are convention by definition
+        if (RESERVED_NET_NAMES.has(name.toUpperCase()))
+            continue;
+        // Get expected domain for this net's type
+        const expectedDomains = NET_TYPE_EXPECTED_DOMAIN[net.type];
+        if (!expectedDomains)
+            continue;
+        // Classify the net name
+        const actualDomains = classifyNetDomain(name);
+        // If the net type is power, the name should look like a power rail
+        if (net.type === 'power' && !actualDomains.has(NetDomain.Power)) {
+            issues.push(netWarning(NetValidationCode.NetNamingConvention, `Power net "${name}" does not follow power rail naming conventions (e.g. "3V3", "VCC", "VIN")`, {
+                netName: name,
+                remediationHint: 'Rename to a conventional power rail name like "VCC", "3V3", or "VIN_5V"',
+            }));
+        }
+        // If the net type is ground, the name should look like a ground
+        if (net.type === 'ground' && !actualDomains.has(NetDomain.Ground)) {
+            issues.push(netWarning(NetValidationCode.NetNamingConvention, `Ground net "${name}" does not follow ground naming conventions (e.g. "GND", "AGND", "PGND")`, {
+                netName: name,
+                remediationHint: 'Rename to a conventional ground name like "GND", "AGND", or "PGND"',
+            }));
+        }
+        // Check for AC/high-voltage naming without protection (next rule handles this more specifically)
+    }
+    return issues;
+}
+// ── Rule: protected AC/high-voltage domain ─────────────────────────────────
+function checkProtectedDomain(input) {
+    const issues = [];
+    for (const net of input.nets) {
+        const actualDomains = classifyNetDomain(net.name);
+        // If the net name suggests high-voltage domain, it should have clear
+        // protective labeling
+        if (actualDomains.has(NetDomain.HighVoltage)) {
+            // High-voltage nets should not be named generically
+            if (/^[A-Z]?[0-9]?$/.test(net.name.trim())) {
+                issues.push(netError(NetValidationCode.NetProtectedDomain, `Net "${net.name}" appears to be in the high-voltage domain but has a generic name — use protective naming like "HV_*" or "AC_*"`, {
+                    netName: net.name,
+                    remediationHint: 'Prefix the net name with "HV_" or "AC_" to clearly indicate high-voltage domain (e.g. "HV_BULK", "AC_L")',
+                }));
+            }
+            // High-voltage nets should not be mixed with low-voltage signal naming
+            if (actualDomains.has(NetDomain.Digital) || actualDomains.has(NetDomain.Clock)) {
+                issues.push(netError(NetValidationCode.NetProtectedDomain, `Net "${net.name}" is classified as both high-voltage and digital/clock — this is a safety hazard`, {
+                    netName: net.name,
+                    remediationHint: 'Separate high-voltage and low-voltage domains; use isolated net names with "HV_" prefix',
+                    details: { detectedDomains: [...actualDomains] },
+                }));
+            }
+        }
+    }
+    return issues;
+}
+const RULES = [
+    checkFloatingNets,
+    checkDuplicateNetNames,
+    checkAccidentalShorts,
+    checkMissingPowerNet,
+    checkMissingGroundNet,
+    checkMissingHierarchicalPorts,
+    checkUnconnectedPins,
+    checkCrossSheetConsistency,
+    checkNamingConventions,
+    checkProtectedDomain,
+];
+// ── Main entry point ───────────────────────────────────────────────────────
+/**
+ * Run all net validation rules against an input net list.
+ *
+ * Orchestrates 10 rules:
+ *  1. Floating nets            — error if net has zero nodes
+ *  2. Duplicate names          — error if multiple nets share a name
+ *  3. Accidental shorts        — error if one device pin belongs to multiple nets
+ *  4. Missing power            — error if no type=power net + warnings for specific names
+ *  5. Missing ground           — error if no type=ground net + warnings for specific names
+ *  6. Missing hierarchical port — error if interface references an unknown net
+ *  7. Unconnected required pins — warning if a device has zero connections
+ *  8. Cross-sheet consistency   — error if same-name interfaces have different pinouts
+ *  9. Naming convention         — warning if power/ground nets have non-standard names
+ * 10. Protected domain          — error if high-voltage net lacks protective naming
+ */
+export function validateNets(input) {
+    const errors = [];
+    const warnings = [];
+    for (const rule of RULES) {
+        const issues = rule(input);
+        for (const issue of issues) {
+            if (issue.severity === 'error') {
+                errors.push(issue);
+            }
+            else {
+                warnings.push(issue);
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Validate nets and throw on the first error.
+ *
+ * Returns the full result on success. Throws the first `NetValidationIssue`
+ * found (as an error) if validation fails.
+ */
+export function validateNetsOrThrow(input) {
+    const result = validateNets(input);
+    if (!result.valid) {
+        throw result.errors[0];
+    }
+    return result;
+}
+//# sourceMappingURL=validation.js.map