@modular-circuit/perc 0.0.61 → 0.1.1

package/dist/index.js

@@ -0,0 +1,1881 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConnectionGraphsBuilder: () => ConnectionGraphsBuilder,
+  DEFAULT_ERC_SETTING: () => DEFAULT_ERC_SETTING,
+  DEFAULT_PIN_MAP: () => DEFAULT_PIN_MAP,
+  DEFAULT_PP_ERROR_SEVERITY: () => DEFAULT_PP_ERROR_SEVERITY,
+  DEFAULT_SEVERITY: () => DEFAULT_SEVERITY,
+  DrivenPinTypes: () => DrivenPinTypes,
+  DrivingPinTypes: () => DrivingPinTypes,
+  ERCE_DRIVER_CONFLICT: () => ERCE_DRIVER_CONFLICT,
+  ERCE_PIN_NOT_CONNECTED: () => ERCE_PIN_NOT_CONNECTED,
+  ERCE_PIN_TO_PIN_ERROR: () => ERCE_PIN_TO_PIN_ERROR,
+  ERCE_T: () => ERCE_T,
+  ERCE_UNANNOTATED: () => ERCE_UNANNOTATED,
+  ERC_SETTING: () => ERC_SETTING,
+  ERC_TESTER: () => ERC_TESTER,
+  IR_GRAPH_CONVERTER: () => IR_GRAPH_CONVERTER,
+  MakerType: () => MakerType,
+  NetlistTester: () => NetlistTester,
+  PIN_COMPATIBILITY_MATRIX_TESTER: () => PIN_COMPATIBILITY_MATRIX_TESTER,
+  PIN_ERROR: () => PIN_ERROR,
+  PP_DUPLICATED_SOURCES: () => PP_DUPLICATED_SOURCES,
+  PP_ERROR: () => PP_ERROR,
+  PP_ILLEGAL_CONNECTION: () => PP_ILLEGAL_CONNECTION,
+  PP_IMPEDANCE_SIGNAL_INTEGRITY: () => PP_IMPEDANCE_SIGNAL_INTEGRITY,
+  PP_INAPPROPRIATE_FUNC: () => PP_INAPPROPRIATE_FUNC,
+  PP_INCOMPATIBLE_DIGITAL_THRESHOLDS: () => PP_INCOMPATIBLE_DIGITAL_THRESHOLDS,
+  PP_INCOMPATIBLE_SIGNAL_LEVELS: () => PP_INCOMPATIBLE_SIGNAL_LEVELS,
+  PP_INCOMPATIBLE_VOLTAGE_LEVELS: () => PP_INCOMPATIBLE_VOLTAGE_LEVELS,
+  PP_INSUFFICIENT_DRIVER: () => PP_INSUFFICIENT_DRIVER,
+  PP_NOT_DRIVEN: () => PP_NOT_DRIVEN,
+  PP_OVERCURRENT: () => PP_OVERCURRENT,
+  PP_OVER_DRIVEN: () => PP_OVER_DRIVEN,
+  PP_REQUIRES_CONNECTED_SOURCE_OR_BIDIR: () => PP_REQUIRES_CONNECTED_SOURCE_OR_BIDIR,
+  PP_SIGNAL_LEVELS_NOT_CONTAINED_WITHIN_VOLTAGE: () => PP_SIGNAL_LEVELS_NOT_CONTAINED_WITHIN_VOLTAGE,
+  ParameterPropagationTester: () => ParameterPropagationTester,
+  PowerDrivingPinTypes: () => PowerDrivingPinTypes,
+  SEVERITY: () => SEVERITY,
+  build_connection_graph: () => build_connection_graph,
+  fmt_erc_item_description: () => fmt_erc_item_description,
+  get_erc_severity: () => get_erc_severity,
+  graph_ecr: () => graph_ecr
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/graphics/maker/maker_type.ts
+var MakerType = /* @__PURE__ */ ((MakerType2) => {
+  MakerType2[MakerType2["MARKER_UNSPEC"] = 0] = "MARKER_UNSPEC";
+  MakerType2[MakerType2["MARKER_ERC"] = 1] = "MARKER_ERC";
+  MakerType2[MakerType2["MARKER_DRC"] = 2] = "MARKER_DRC";
+  MakerType2[MakerType2["MARKER_DRAWING_SHEET"] = 3] = "MARKER_DRAWING_SHEET";
+  MakerType2[MakerType2["MARKER_RATSNEST"] = 4] = "MARKER_RATSNEST";
+  MakerType2[MakerType2["MARKER_PARITY"] = 5] = "MARKER_PARITY";
+  MakerType2[MakerType2["MARKER_SIMUL"] = 6] = "MARKER_SIMUL";
+  return MakerType2;
+})(MakerType || {});
+
+// src/erc/context/error_severity.ts
+var SEVERITY = /* @__PURE__ */ ((SEVERITY2) => {
+  SEVERITY2[SEVERITY2["RPT_SEVERITY_UNDEFINED"] = 1] = "RPT_SEVERITY_UNDEFINED";
+  SEVERITY2[SEVERITY2["RPT_SEVERITY_INFO"] = 2] = "RPT_SEVERITY_INFO";
+  SEVERITY2[SEVERITY2["RPT_SEVERITY_EXCLUSION"] = 4] = "RPT_SEVERITY_EXCLUSION";
+  SEVERITY2[SEVERITY2["RPT_SEVERITY_ACTION"] = 8] = "RPT_SEVERITY_ACTION";
+  SEVERITY2[SEVERITY2["RPT_SEVERITY_WARNING"] = 16] = "RPT_SEVERITY_WARNING";
+  SEVERITY2[SEVERITY2["RPT_SEVERITY_ERROR"] = 32] = "RPT_SEVERITY_ERROR";
+  SEVERITY2[SEVERITY2["RPT_SEVERITY_IGNORE"] = 64] = "RPT_SEVERITY_IGNORE";
+  SEVERITY2[SEVERITY2["RPT_SEVERITY_DEBUG"] = 128] = "RPT_SEVERITY_DEBUG";
+  return SEVERITY2;
+})(SEVERITY || {});
+
+// src/erc/parameter_propagation/error_code.ts
+var PP_ERROR = /* @__PURE__ */ ((PP_ERROR2) => {
+  PP_ERROR2["UN_COMPILED_BLOCK"] = "un_compiled_block";
+  PP_ERROR2["UN_COMPILED_LINK"] = "un_compiled_link";
+  PP_ERROR2["UN_COMPILED_LINK_ARRAY"] = "un_compiled_link_array";
+  PP_ERROR2["UN_COMPILED_PARAMETER"] = "un_compiled_parameter";
+  PP_ERROR2["UN_COMPILED_INTERNAL_ELEMENT"] = "un_compiled_internal_element";
+  PP_ERROR2["UN_COMPILED_LIBRARY_ELEMENT"] = "un_compiled_library_element";
+  PP_ERROR2["UNDEFINED_PORT_ARRAY"] = "undefined_port_array";
+  PP_ERROR2["LIBRARY_ERROR"] = "library_error";
+  PP_ERROR2["GENERATOR_ERROR"] = "generator_error";
+  PP_ERROR2["REFINEMENT_SUBCLASS_ERROR"] = "refinement_subclass_error";
+  PP_ERROR2["OVER_ASSIGN"] = "over_assign";
+  PP_ERROR2["BAD_REFERENCE"] = "bad_reference";
+  PP_ERROR2["ABSTRACT_BLOCK"] = "abstract_block";
+  PP_ERROR2["FAILED_ASSERTION"] = "failed_assertion";
+  PP_ERROR2["UN_EVALUATED_ASSERTION"] = "un_evaluated_assertion";
+  PP_ERROR2["INCONSISTENT_LINK_ARRAY_ELEMENTS"] = "inconsistent_link_array_elements";
+  PP_ERROR2["PP_UNANNOTATED"] = "pp_unannotated";
+  PP_ERROR2["PP_UNKNOWN_PORT_TYPE"] = "pp_unknown_port_type";
+  PP_ERROR2["INAPPROPRIATE_FUNC"] = "Functionally inappropriate link";
+  PP_ERROR2["NOT_DRIVEN"] = "pp_not_driven";
+  PP_ERROR2["DUPLICATED_PWR_SOURCES"] = "duplicated_pwr_sources";
+  PP_ERROR2["INSUFFICIENT_DRIVER"] = "Insufficient_driver";
+  PP_ERROR2["OVER_DRIVEN"] = "over_driven";
+  PP_ERROR2["IMPEDANCE_SIGNAL_INTEGRITY"] = "impedance_signal_integrity";
+  PP_ERROR2["INCOMPATIBLE_VOLTAGE_LEVELS"] = "incompatible_voltage_levels";
+  PP_ERROR2["SIGNAL_LEVELS_NOT_CONTAINED_WITHIN_VOLTAGE"] = "signal_levels_not_contained_within_voltage";
+  PP_ERROR2["INCOMPATIBLE_SIGNAL_LEVELS"] = "incompatible_signal_levels";
+  PP_ERROR2["OVERCURRENT"] = "overcurrent";
+  PP_ERROR2["INCOMPATIBLE_DIGITAL_THRESHOLDS"] = "incompatible_digital_thresholds";
+  PP_ERROR2["REQUIRES_CONNECTED_SOURCE_OR_BIDIR"] = "requires_connected_source_or_bidir";
+  PP_ERROR2["ILLEGAL_CONNECTION"] = "Illegal_connection";
+  return PP_ERROR2;
+})(PP_ERROR || {});
+var DEFAULT_PP_ERROR_SEVERITY = {
+  ["un_compiled_block" /* UN_COMPILED_BLOCK */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["un_compiled_link" /* UN_COMPILED_LINK */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["un_compiled_link_array" /* UN_COMPILED_LINK_ARRAY */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["un_compiled_parameter" /* UN_COMPILED_PARAMETER */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["un_compiled_internal_element" /* UN_COMPILED_INTERNAL_ELEMENT */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["un_compiled_library_element" /* UN_COMPILED_LIBRARY_ELEMENT */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["undefined_port_array" /* UNDEFINED_PORT_ARRAY */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["library_error" /* LIBRARY_ERROR */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["generator_error" /* GENERATOR_ERROR */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["refinement_subclass_error" /* REFINEMENT_SUBCLASS_ERROR */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["over_assign" /* OVER_ASSIGN */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["bad_reference" /* BAD_REFERENCE */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["abstract_block" /* ABSTRACT_BLOCK */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["failed_assertion" /* FAILED_ASSERTION */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["un_evaluated_assertion" /* UN_EVALUATED_ASSERTION */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["inconsistent_link_array_elements" /* INCONSISTENT_LINK_ARRAY_ELEMENTS */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["pp_unannotated" /* PP_UNANNOTATED */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["pp_unknown_port_type" /* PP_UNKNOWN_PORT_TYPE */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["Functionally inappropriate link" /* INAPPROPRIATE_FUNC */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["pp_not_driven" /* NOT_DRIVEN */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["duplicated_pwr_sources" /* DUPLICATED_PWR_SOURCES */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["Insufficient_driver" /* INSUFFICIENT_DRIVER */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["over_driven" /* OVER_DRIVEN */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["impedance_signal_integrity" /* IMPEDANCE_SIGNAL_INTEGRITY */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["incompatible_voltage_levels" /* INCOMPATIBLE_VOLTAGE_LEVELS */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["signal_levels_not_contained_within_voltage" /* SIGNAL_LEVELS_NOT_CONTAINED_WITHIN_VOLTAGE */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["incompatible_signal_levels" /* INCOMPATIBLE_SIGNAL_LEVELS */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["overcurrent" /* OVERCURRENT */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["incompatible_digital_thresholds" /* INCOMPATIBLE_DIGITAL_THRESHOLDS */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["requires_connected_source_or_bidir" /* REQUIRES_CONNECTED_SOURCE_OR_BIDIR */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["Illegal_connection" /* ILLEGAL_CONNECTION */]: 32 /* RPT_SEVERITY_ERROR */
+};
+
+// src/erc/parameter_propagation/tester.ts
+var import_electronics_model4 = require("@modular-circuit/electronics-model");
+
+// src/report/erc_report.ts
+function fmt_erc_item_description(id, ctx) {
+  if (id in ctx.pin_module_name_table) return `Module ${ctx.pin_module_name_table[id]} port ${ctx.pin_name_table[id]}`;
+  return ctx.pin_name_table[id];
+}
+function get_erc_severity(code, settings) {
+  const erc_setting = settings?.erc_setting || DEFAULT_SEVERITY;
+  const pp_erc_setting = settings?.pp_erc_setting || DEFAULT_PP_ERROR_SEVERITY;
+  const severity = erc_setting[code] ?? pp_erc_setting[code];
+  if (severity === void 0) throw new Error(`Unknown ERC code: ${code}`);
+  return severity;
+}
+
+// src/report/erc_reporter.ts
+var import_electronics_model = require("@modular-circuit/electronics-model");
+var ERCE_UNANNOTATED = (id) => ({
+  error_code: "unannotated" /* ERCE_UNANNOTATED */,
+  error_message: "Port has no electrical type specified.",
+  eda_item_ids: [id]
+});
+var ERCE_PIN_TO_PIN_ERROR = (a, b) => ({
+  error_code: "ERCE_PIN_TO_PIN_ERROR" /* ERCE_PIN_TO_PIN_ERROR */,
+  error_message: `Port ${(0, import_electronics_model.get_electrical_pin_type)(a)} and port  ${(0, import_electronics_model.get_electrical_pin_type)(b)} are not compatible.`,
+  eda_item_ids: [a.uuid, b.uuid]
+});
+var ERCE_PIN_NOT_CONNECTED = (id) => ({
+  error_code: "pin_not_connected" /* ERCE_PIN_NOT_CONNECTED */,
+  error_message: "Port not connected.",
+  eda_item_ids: [id]
+});
+var ERCE_DRIVER_CONFLICT = (eda_item_ids, primaryName, secondaryName) => ({
+  error_code: "Functionally inappropriate link" /* INAPPROPRIATE_FUNC */,
+  error_message: `Both ${primaryName} and ${secondaryName} are attached to the same net. `,
+  eda_item_ids
+});
+var PP_INAPPROPRIATE_FUNC = (eda_item_ids) => ({
+  error_code: "Functionally inappropriate link" /* INAPPROPRIATE_FUNC */,
+  error_message: "Inappropriate ports functions.",
+  eda_item_ids
+});
+var PP_NOT_DRIVEN = (eda_item_ids) => ({
+  error_code: "pp_not_driven" /* NOT_DRIVEN */,
+  error_message: "Net not driven.",
+  eda_item_ids
+});
+var PP_DUPLICATED_SOURCES = (eda_item_ids) => ({
+  error_code: "duplicated_pwr_sources" /* DUPLICATED_PWR_SOURCES */,
+  error_message: "Net connected to multiple power sources.",
+  eda_item_ids
+});
+var PP_INSUFFICIENT_DRIVER = (eda_item_ids, desc) => ({
+  error_code: "Insufficient_driver" /* INSUFFICIENT_DRIVER */,
+  error_message: `Insufficient ${desc} driver.`,
+  eda_item_ids
+});
+var PP_OVER_DRIVEN = (eda_item_ids, desc) => ({
+  error_code: "over_driven" /* OVER_DRIVEN */,
+  error_message: `${desc} over driven.`,
+  eda_item_ids
+});
+var PP_IMPEDANCE_SIGNAL_INTEGRITY = (eda_item_ids) => ({
+  error_code: "impedance_signal_integrity" /* IMPEDANCE_SIGNAL_INTEGRITY */,
+  error_message: "Source impedance shall be 10x lower than sink impedance for signal integrity.",
+  eda_item_ids
+});
+var PP_INCOMPATIBLE_VOLTAGE_LEVELS = (source) => ({
+  error_code: "impedance_signal_integrity" /* IMPEDANCE_SIGNAL_INTEGRITY */,
+  error_message: "Incompatible voltage levels.",
+  eda_item_ids: [source]
+});
+var PP_SIGNAL_LEVELS_NOT_CONTAINED_WITHIN_VOLTAGE = (source) => ({
+  error_code: "signal_levels_not_contained_within_voltage" /* SIGNAL_LEVELS_NOT_CONTAINED_WITHIN_VOLTAGE */,
+  error_message: "Signal levels not contained within voltage.",
+  eda_item_ids: [source]
+});
+var PP_INCOMPATIBLE_SIGNAL_LEVELS = (source) => ({
+  error_code: "incompatible_signal_levels" /* INCOMPATIBLE_SIGNAL_LEVELS */,
+  error_message: "Incompatible signal levels.",
+  eda_item_ids: [source]
+});
+var PP_OVERCURRENT = (source) => ({
+  error_code: "overcurrent" /* OVERCURRENT */,
+  error_message: "overcurrent.",
+  eda_item_ids: [source]
+});
+var PP_INCOMPATIBLE_DIGITAL_THRESHOLDS = (eda_item_ids) => ({
+  error_code: "incompatible_digital_thresholds" /* INCOMPATIBLE_DIGITAL_THRESHOLDS */,
+  error_message: "Incompatible digital thresholds.",
+  eda_item_ids
+});
+var PP_REQUIRES_CONNECTED_SOURCE_OR_BIDIR = (eda_item_ids) => ({
+  error_code: "requires_connected_source_or_bidir" /* REQUIRES_CONNECTED_SOURCE_OR_BIDIR */,
+  error_message: "Requires connected source or bidir.",
+  eda_item_ids
+});
+var PP_ILLEGAL_CONNECTION = (eda_item_ids, detail) => ({
+  error_code: "Illegal_connection" /* ILLEGAL_CONNECTION */,
+  error_message: `Illegal connection: ${detail}`,
+  eda_item_ids
+});
+
+// src/erc/parameter_propagation/link_testers/tester_impl.ts
+var import_electronics_model3 = require("@modular-circuit/electronics-model");
+
+// src/erc/parameter_propagation/link_testers/link_tester_base.ts
+var import_electronics_model2 = require("@modular-circuit/electronics-model");
+var LinkTesterBase = class {
+  constructor(ctx, ports) {
+    this.ctx = ctx;
+    this.ports = ports;
+  }
+  test() {
+    if (!this.init_link()) return;
+    this.check_parameter_propagation();
+  }
+  get all_port_ids() {
+    if (!this._all_port_ids) this._all_port_ids = this.ports.map((v) => this.ctx.port_id.get(v));
+    return this._all_port_ids;
+  }
+};
+var CompositePortLinkTesterBase = class extends LinkTesterBase {
+  test() {
+    for (const port of this.ports) {
+      this.annot_composite_port(port, this.ctx.port_id.get(port));
+    }
+    super.test();
+  }
+  annot_composite_port(port, uuid) {
+    for (const [k, v] of Object.entries(port)) {
+      if (k === import_electronics_model2.LABEL_ASSOCIATED && typeof v === "string") {
+        this.ctx.port_id.set(port, v);
+      } else if (typeof v === "object" && !Array.isArray(v) && v !== null) {
+        this.annot_composite_port(v, uuid);
+      }
+    }
+  }
+};
+
+// src/erc/parameter_propagation/link_testers/tester_impl.ts
+var AnalogLinkTester = class extends LinkTesterBase {
+  init_link() {
+    const sources = [];
+    const sinks = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case import_electronics_model3.PortType.AnalogSource: {
+          sources.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.AnalogSink: {
+          sinks.push(v);
+          break;
+        }
+      }
+    }
+    if (sources.length === 0) {
+      this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, "Requires a connected analog source"));
+      return false;
+    }
+    if (sources.length > 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "Multiple analog sources are not allowed")
+      );
+      return false;
+    }
+    this.link = {
+      source: sources[0],
+      sinks
+    };
+    return true;
+  }
+  check_parameter_propagation() {
+    if (!this.link) return;
+    const source = this.link.source;
+    const sinks = this.link.sinks;
+    const source_id = this.ctx.port_id.get(source);
+    if ((0, import_electronics_model3.range_is_defined)(source.impedance)) {
+      const all_sinks_impedance = (0, import_electronics_model3.filter_defined_range)(sinks.map((v) => v.impedance));
+      if (all_sinks_impedance.length > 0) {
+        const sink_impedance = (0, import_electronics_model3.r_div)((0, import_electronics_model3.sum)(all_sinks_impedance.map((v) => (0, import_electronics_model3.r_div)(v, 1))), 1);
+        if (source.impedance.upper > sink_impedance.lower * 0.1) {
+          this.ctx.report.erc_errors.push(PP_IMPEDANCE_SIGNAL_INTEGRITY(this.all_port_ids));
+        }
+      }
+    }
+    if ((0, import_electronics_model3.range_is_defined)(source.voltage_out)) {
+      const all_voltage_limits = (0, import_electronics_model3.filter_defined_range)(sinks.map((v) => v.voltage_limits));
+      if (all_voltage_limits.length > 0) {
+        const voltage_limits = (0, import_electronics_model3.intersection)(all_voltage_limits);
+        if (!(0, import_electronics_model3.interests)(voltage_limits, source.voltage_out)) {
+          this.ctx.report.erc_errors.push(PP_INCOMPATIBLE_VOLTAGE_LEVELS(source_id));
+        }
+      }
+    }
+    if ((0, import_electronics_model3.all_range_are_defined)(source.signal_out, source.voltage_out)) {
+      if (!(0, import_electronics_model3.interests)(source.voltage_out, source.signal_out)) {
+        this.ctx.report.erc_errors.push(PP_SIGNAL_LEVELS_NOT_CONTAINED_WITHIN_VOLTAGE(source_id));
+      }
+    }
+    if ((0, import_electronics_model3.range_is_defined)(source.signal_out)) {
+      const all_sinks_signal_limits = (0, import_electronics_model3.filter_defined_range)(sinks.map((v) => v.signal_limits));
+      if (all_sinks_signal_limits.length > 0) {
+        const signal_limits = (0, import_electronics_model3.intersection)(all_sinks_signal_limits);
+        if (!(0, import_electronics_model3.interests)(signal_limits, source.signal_out)) {
+          this.ctx.report.erc_errors.push(PP_INCOMPATIBLE_SIGNAL_LEVELS(source_id));
+        }
+      }
+    }
+    if ((0, import_electronics_model3.range_is_defined)(source.current_limits)) {
+      const all_sinks_current_drawn = (0, import_electronics_model3.filter_defined_range)(sinks.map((v) => v.current_drawn));
+      if (all_sinks_current_drawn.length > 0) {
+        const current_drawn = (0, import_electronics_model3.sum)(all_sinks_current_drawn);
+        if ((0, import_electronics_model3.interests)(current_drawn, source.current_limits)) {
+          this.ctx.report.erc_errors.push(PP_OVER_DRIVEN([source_id], "current"));
+        }
+      }
+    }
+  }
+};
+var DigitalLinkTester = class extends LinkTesterBase {
+  init_link() {
+    const sinks = [];
+    const sources = [];
+    const bidirs = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case import_electronics_model3.PortType.DigitalSource: {
+          sources.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.DigitalSink: {
+          sinks.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.DigitalBidir: {
+          bidirs.push(v);
+          break;
+        }
+      }
+    }
+    this.link = {
+      sources,
+      sinks,
+      bidirs
+    };
+    return true;
+  }
+  check_parameter_propagation() {
+    if (!this.link) return;
+    const sources = this.link.sources ?? [];
+    const sinks = this.link.sinks ?? [];
+    const bidirs = this.link.bidirs ?? [];
+    const all_defined_voltage = (0, import_electronics_model3.filter_defined_range)(
+      ...bidirs.map((v) => v.voltage_out),
+      ...sources.map((v) => v.voltage_out)
+    );
+    if (all_defined_voltage.length > 0) {
+      const voltage = (0, import_electronics_model3.hull)(all_defined_voltage);
+      const all_defined_voltage_limits = (0, import_electronics_model3.filter_defined_range)(sinks.map((v) => v.voltage_limits));
+      if (all_defined_voltage_limits.length > 0) {
+        const voltage_limits = (0, import_electronics_model3.intersection)(all_defined_voltage_limits);
+        if (!(0, import_electronics_model3.contains)(voltage_limits, voltage)) {
+          this.ctx.report.erc_errors.push(PP_OVER_DRIVEN(this.all_port_ids, "voltage"));
+        }
+      }
+    }
+    const all_defined_current_limits = (0, import_electronics_model3.filter_defined_range)(
+      ...bidirs.map((v) => v.current_limits),
+      ...sources.map((v) => v.current_limits)
+    );
+    if (all_defined_current_limits.length > 0) {
+      const current_limits = (0, import_electronics_model3.sum)(all_defined_current_limits);
+      const all_defined_current_drawn = (0, import_electronics_model3.filter_defined_range)(sinks.map((v) => v.current_drawn));
+      if (all_defined_current_drawn.length > 0) {
+        const current_drawn = (0, import_electronics_model3.sum)(all_defined_current_drawn);
+        if ((0, import_electronics_model3.interests)(current_drawn, current_limits)) {
+          this.ctx.report.erc_errors.push(PP_OVER_DRIVEN(this.all_port_ids, "current"));
+        }
+      }
+    }
+    const all_defined_output_thresholds = (0, import_electronics_model3.filter_defined_range)(
+      ...bidirs.map((v) => v.output_thresholds),
+      ...sources.map((v) => v.output_thresholds)
+    );
+    if (all_defined_output_thresholds.length > 0) {
+      const output_thresholds = (0, import_electronics_model3.intersection)(all_defined_output_thresholds);
+      const all_defined_input_thresholds = (0, import_electronics_model3.filter_defined_range)(sinks.map((v) => v.input_thresholds));
+      if (all_defined_input_thresholds.length > 0) {
+        const input_thresholds = (0, import_electronics_model3.hull)(all_defined_input_thresholds);
+        if (!(0, import_electronics_model3.contains)(output_thresholds, input_thresholds)) {
+          this.ctx.report.erc_errors.push(PP_INCOMPATIBLE_DIGITAL_THRESHOLDS(this.all_port_ids));
+        }
+      }
+    }
+    if (!sources.length && !bidirs.length) {
+      this.ctx.report.erc_errors.push(PP_REQUIRES_CONNECTED_SOURCE_OR_BIDIR(this.all_port_ids));
+    }
+  }
+};
+var VoltageLinkTester = class extends LinkTesterBase {
+  check_parameter_propagation() {
+    const source = this.link.source;
+    const sinks = this.link.sinks;
+    if ((0, import_electronics_model3.range_is_defined)(source.voltage_out)) {
+      const all_voltage_limits = (0, import_electronics_model3.filter_defined_range)(sinks.map((v) => v.voltage_limits));
+      if (all_voltage_limits.length > 0) {
+        const voltage_limits = (0, import_electronics_model3.intersection)(all_voltage_limits);
+        if (!(0, import_electronics_model3.interests)(voltage_limits, source.voltage_out)) {
+          this.ctx.report.erc_errors.push(PP_OVER_DRIVEN(this.all_port_ids, "voltage"));
+        }
+      }
+    }
+    if ((0, import_electronics_model3.range_is_defined)(source.current_limits)) {
+      const all_sinks_current_drawn = (0, import_electronics_model3.filter_defined_range)(sinks.map((v) => v.current_drawn));
+      if (all_sinks_current_drawn.length > 0) {
+        const current_drawn = (0, import_electronics_model3.sum)(all_sinks_current_drawn);
+        if ((0, import_electronics_model3.interests)(current_drawn, source.current_limits)) {
+          this.ctx.report.erc_errors.push(PP_OVER_DRIVEN(this.all_port_ids, "current"));
+        }
+      }
+    }
+  }
+  init_link() {
+    const sources = [];
+    const sinks = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case import_electronics_model3.PortType.VoltageSource: {
+          sources.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.VoltageSink: {
+          sinks.push(v);
+          break;
+        }
+      }
+    }
+    if (sources.length === 0) {
+      this.ctx.report.erc_errors.push(PP_NOT_DRIVEN(this.all_port_ids));
+      return false;
+    }
+    if (sources.length > 1) {
+      this.ctx.report.erc_errors.push(PP_DUPLICATED_SOURCES(this.all_port_ids));
+      return false;
+    }
+    this.link = {
+      source: sources[0],
+      sinks
+    };
+    return true;
+  }
+};
+var GroundLinkTester = class extends LinkTesterBase {
+  check_parameter_propagation() {
+    if (!this.link) return;
+    const ref = this.link.ref;
+    const gnds = this.link.gnds;
+    let voltage = ref?.voltage_out;
+    if (!voltage || !(0, import_electronics_model3.range_is_defined)(voltage)) voltage = { lower: 0, upper: 0 };
+    const all_defined_voltage_limits = (0, import_electronics_model3.filter_defined_range)(gnds.map((v) => v.voltage_limits));
+    if (all_defined_voltage_limits.length > 0) {
+      const voltage_limits = (0, import_electronics_model3.intersection)(all_defined_voltage_limits);
+      if (!(0, import_electronics_model3.interests)(voltage_limits, voltage)) {
+        this.ctx.report.erc_errors.push(PP_OVER_DRIVEN(this.all_port_ids, "voltage"));
+      }
+    }
+  }
+  init_link() {
+    const refs = [];
+    const gnds = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case import_electronics_model3.PortType.GroundReference: {
+          refs.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.Ground: {
+          gnds.push(v);
+          break;
+        }
+      }
+    }
+    if (refs.length > 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "Cannot connect multiple ground references to a ground.")
+      );
+      return false;
+    }
+    this.link = {
+      ref: refs[0],
+      gnds
+    };
+    return true;
+  }
+};
+var CanLogicLinkTester = class extends CompositePortLinkTesterBase {
+  check_parameter_propagation() {
+    if (!this.link) return;
+    const txd_tester = new DigitalLinkTester(this.ctx, [
+      this.link.controller.txd,
+      this.link.transceiver.rxd,
+      ...this.link.passive.map((port) => port.rxd)
+    ]);
+    const rxd_tester = new DigitalLinkTester(this.ctx, [
+      this.link.controller.rxd,
+      this.link.transceiver.txd,
+      ...this.link.passive.map((port) => port.txd)
+    ]);
+    for (const tst of [txd_tester, rxd_tester]) tst.test();
+  }
+  init_link() {
+    const controllers = [];
+    const transceivers = [];
+    const passive = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case import_electronics_model3.PortType.CanControllerPort: {
+          controllers.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.CanTransceiverPort: {
+          transceivers.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.CanPassivePort: {
+          passive.push(v);
+          break;
+        }
+      }
+    }
+    if (controllers.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one controller port.")
+      );
+      return false;
+    }
+    if (transceivers.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one transceiver port.")
+      );
+      return false;
+    }
+    this.link = {
+      controller: controllers[0],
+      transceiver: transceivers[0],
+      passive
+    };
+    return true;
+  }
+};
+var CanDiffLinkTester = class extends CompositePortLinkTesterBase {
+  check_parameter_propagation() {
+    if (!this.link) return;
+    const canh_tester = new DigitalLinkTester(
+      this.ctx,
+      this.link.nodes.map((node) => node.canh)
+    );
+    const canl_tester = new DigitalLinkTester(
+      this.ctx,
+      this.link.nodes.map((node) => node.canl)
+    );
+    for (const tst of [canh_tester, canl_tester]) tst.test();
+  }
+  init_link() {
+    const nodes = [];
+    for (const v of this.ports) {
+      if (v.type === import_electronics_model3.PortType.CanDiffPort) {
+        nodes.push(v);
+      }
+    }
+    if (nodes.length === 0) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "Requires at least one CAN differential port")
+      );
+      return false;
+    }
+    this.link = {
+      nodes
+    };
+    return true;
+  }
+};
+var CrystalLinkTester = class extends CompositePortLinkTesterBase {
+  check_parameter_propagation() {
+    if (!this.link) return;
+    const driver = this.link.driver;
+    const crystal = this.link.crystal;
+    if ((0, import_electronics_model3.all_range_are_defined)(driver.frequency_limits, crystal.frequency)) {
+      if (!(0, import_electronics_model3.contains)(driver.frequency_limits, crystal.frequency)) {
+        this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, "Frequency out of range"));
+      }
+    }
+  }
+  init_link() {
+    const drivers = [];
+    const crystals = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case import_electronics_model3.PortType.CrystalDriver: {
+          drivers.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.CrystalPort: {
+          crystals.push(v);
+          break;
+        }
+      }
+    }
+    if (drivers.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one crystal driver port.")
+      );
+      return false;
+    }
+    if (crystals.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one crystal port.")
+      );
+      return false;
+    }
+    this.link = {
+      driver: drivers[0],
+      crystal: crystals[0]
+    };
+    return true;
+  }
+};
+var SwdLinkTester = class extends CompositePortLinkTesterBase {
+  check_parameter_propagation() {
+    if (!this.link) return;
+    const swdio_tester = new DigitalLinkTester(this.ctx, [
+      this.link.host.swdio,
+      this.link.device.swdio,
+      ...this.link.pull.map((port) => port.swdio)
+    ]);
+    const swclk_tester = new DigitalLinkTester(this.ctx, [
+      this.link.host.swclk,
+      this.link.device.swclk,
+      ...this.link.pull.map((port) => port.swclk)
+    ]);
+    for (const tst of [swdio_tester, swclk_tester]) tst.test();
+  }
+  init_link() {
+    const hosts = [];
+    const devices = [];
+    const pull = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case import_electronics_model3.PortType.SwdHostPort: {
+          hosts.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.SwdTargetPort: {
+          devices.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.SwdPullPort: {
+          pull.push(v);
+          break;
+        }
+      }
+    }
+    if (hosts.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one SWD host port.")
+      );
+      return false;
+    }
+    if (devices.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one SWD target port.")
+      );
+      return false;
+    }
+    this.link = {
+      host: hosts[0],
+      device: devices[0],
+      pull
+    };
+    return true;
+  }
+};
+var I2cLinkTester = class extends CompositePortLinkTesterBase {
+  check_parameter_propagation() {
+    if (!this.link) return;
+    const scl_tester = new DigitalLinkTester(this.ctx, [
+      ...this.link.pull.map((device) => device.scl),
+      this.link.controller.scl,
+      ...this.link.targets.map((device) => device.scl)
+    ]);
+    const sda_tester = new DigitalLinkTester(this.ctx, [
+      ...this.link.pull.map((device) => device.sda),
+      this.link.controller.sda,
+      ...this.link.targets.map((device) => device.sda)
+    ]);
+    for (const tst of [scl_tester, sda_tester]) tst.test();
+    if (!this.link.pull.length && !this.link.controller.has_pullup) {
+      this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, "Requires at least one pullup"));
+    }
+    if (this.link.pull.length > 1) {
+      this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, "At most one pullup allowed"));
+    }
+    const addresses = this.link.targets.map((target) => target.addresses);
+    if (new Set(addresses).size !== addresses.length) {
+      this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, "Conflicting addresses on I2C bus"));
+    }
+  }
+  init_link() {
+    const pull = [];
+    const controllers = [];
+    const targets = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case import_electronics_model3.PortType.I2cPullupPort: {
+          pull.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.I2cController: {
+          controllers.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.I2cTarget: {
+          targets.push(v);
+          break;
+        }
+      }
+    }
+    if (controllers.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one I2C controller port.")
+      );
+      return false;
+    }
+    if (targets.length === 0) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be at least one I2C target port.")
+      );
+      return false;
+    }
+    this.link = {
+      pull,
+      controller: controllers[0],
+      targets
+    };
+    return true;
+  }
+};
+var I2sLinkTester = class extends CompositePortLinkTesterBase {
+  check_parameter_propagation() {
+    if (!this.link) return;
+    const controller = this.link.controller;
+    const target_receiver = this.link.target_receiver;
+    const sck_tester = new DigitalLinkTester(this.ctx, [controller.sck, target_receiver.sck]);
+    const ws_tester = new DigitalLinkTester(this.ctx, [controller.ws, target_receiver.ws]);
+    const sd_tester = new DigitalLinkTester(this.ctx, [controller.sd, target_receiver.sd]);
+    for (const tst of [sck_tester, ws_tester, sd_tester]) tst.test();
+  }
+  init_link() {
+    const controllers = [];
+    const target_receivers = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case import_electronics_model3.PortType.I2sController: {
+          controllers.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.I2sTargetReceiver: {
+          target_receivers.push(v);
+          break;
+        }
+      }
+    }
+    if (controllers.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one I2S controller port.")
+      );
+      return false;
+    }
+    if (target_receivers.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one I2S target receiver port.")
+      );
+      return false;
+    }
+    this.link = {
+      controller: controllers[0],
+      target_receiver: target_receivers[0]
+    };
+    return true;
+  }
+};
+var SpiLinkTester = class extends CompositePortLinkTesterBase {
+  check_parameter_propagation() {
+    if (!this.link) return;
+    const controller = this.link.controller;
+    const peripherals = this.link.peripherals;
+    const sck_tester = new DigitalLinkTester(this.ctx, [controller.sck, ...peripherals.map((device) => device.sck)]);
+    const miso_tester = new DigitalLinkTester(this.ctx, [controller.miso, ...peripherals.map((device) => device.miso)]);
+    const mosi_tester = new DigitalLinkTester(this.ctx, [controller.mosi, ...peripherals.map((device) => device.mosi)]);
+    for (const tst of [sck_tester, miso_tester, mosi_tester]) tst.test();
+  }
+  init_link() {
+    const controllers = [];
+    const peripherals = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case import_electronics_model3.PortType.SpiController: {
+          controllers.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.SpiPeripheral: {
+          peripherals.push(v);
+          break;
+        }
+      }
+    }
+    if (controllers.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one SPI controller port.")
+      );
+      return false;
+    }
+    if (peripherals.length === 0) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be at least one SPI peripheral port.")
+      );
+      return false;
+    }
+    this.link = {
+      controller: controllers[0],
+      peripherals
+    };
+    return true;
+  }
+};
+var SpeakerLinkTester = class extends CompositePortLinkTesterBase {
+  check_parameter_propagation() {
+    if (!this.link) return;
+    const a_tester = new AnalogLinkTester(this.ctx, [this.link.source.a, this.link.sink.a]);
+    const b_tester = new AnalogLinkTester(this.ctx, [this.link.source.b, this.link.sink.b]);
+    for (const tst of [a_tester, b_tester]) tst.test();
+  }
+  init_link() {
+    const sources = [];
+    const sinks = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case import_electronics_model3.PortType.SpeakerDriverPort: {
+          sources.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.SpeakerPort: {
+          sinks.push(v);
+          break;
+        }
+      }
+    }
+    if (sources.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one speaker driver port.")
+      );
+      return false;
+    }
+    if (sinks.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one speaker port.")
+      );
+      return false;
+    }
+    this.link = {
+      source: sources[0],
+      sink: sinks[0]
+    };
+    return true;
+  }
+};
+var TouchLinkTester = class extends LinkTesterBase {
+  init_link() {
+    const drivers = [];
+    const pads = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case import_electronics_model3.PortType.TouchDriver: {
+          drivers.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.TouchPadPort: {
+          pads.push(v);
+          break;
+        }
+      }
+    }
+    if (drivers.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one touch driver port.")
+      );
+      return false;
+    }
+    if (pads.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one touch pad port.")
+      );
+      return false;
+    }
+    this.link = {
+      driver: drivers[0],
+      pad: pads[0]
+    };
+    return true;
+  }
+  check_parameter_propagation() {
+    return;
+  }
+};
+var UartLinkTester = class extends CompositePortLinkTesterBase {
+  check_parameter_propagation() {
+    if (!this.link) return;
+    const tx_tester = new DigitalLinkTester(this.ctx, [this.link.a.tx, this.link.b.rx]);
+    const rx_tester = new DigitalLinkTester(this.ctx, [this.link.b.tx, this.link.a.rx]);
+    for (const tst of [tx_tester, rx_tester]) tst.test();
+  }
+  init_link() {
+    const ports = [];
+    for (const v of this.ports) {
+      if (v.type === import_electronics_model3.PortType.UartPort) {
+        ports.push(v);
+      }
+    }
+    if (ports.length !== 2) {
+      this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly two UART ports."));
+      return false;
+    }
+    this.link = {
+      a: ports[0],
+      b: ports[1]
+    };
+    return true;
+  }
+};
+var UsbLinkTester = class extends CompositePortLinkTesterBase {
+  check_parameter_propagation() {
+    if (!this.link) return;
+    const dp_tester = new DigitalLinkTester(this.ctx, [
+      this.link.host.dp,
+      this.link.device.dp,
+      ...this.link.passive.map((port) => port.dp)
+    ]);
+    const dm_tester = new DigitalLinkTester(this.ctx, [
+      this.link.host.dm,
+      this.link.device.dm,
+      ...this.link.passive.map((port) => port.dm)
+    ]);
+    for (const tst of [dp_tester, dm_tester]) tst.test();
+  }
+  init_link() {
+    const hosts = [];
+    const devices = [];
+    const passive = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case import_electronics_model3.PortType.UsbHostPort: {
+          hosts.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.UsbDevicePort: {
+          devices.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.UsbPassivePort: {
+          passive.push(v);
+          break;
+        }
+      }
+    }
+    if (hosts.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one USB host port.")
+      );
+      return false;
+    }
+    if (devices.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one USB device port.")
+      );
+      return false;
+    }
+    this.link = {
+      host: hosts[0],
+      device: devices[0],
+      passive
+    };
+    return true;
+  }
+};
+var UsbCcLinkTester = class extends CompositePortLinkTesterBase {
+  check_parameter_propagation() {
+    if (!this.link) return;
+    const cc1_tester = new DigitalLinkTester(this.ctx, [this.link.a.cc1, this.link.b.cc1]);
+    const cc2_tester = new DigitalLinkTester(this.ctx, [this.link.a.cc2, this.link.b.cc2]);
+    for (const tst of [cc1_tester, cc2_tester]) tst.test();
+  }
+  init_link() {
+    const nodes = [];
+    for (const v of this.ports) {
+      if (v.type === import_electronics_model3.PortType.UsbCcPort) {
+        nodes.push(v);
+      }
+    }
+    if (nodes.length !== 2) {
+      this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly two CC ports."));
+      return false;
+    }
+    this.link = {
+      a: nodes[0],
+      b: nodes[1]
+    };
+    return true;
+  }
+};
+var Dvp8LinkTester = class extends CompositePortLinkTesterBase {
+  check_parameter_propagation() {
+    if (!this.link) return;
+    const host = this.link.host;
+    const cam = this.link.cam;
+    const digitalLinks = [
+      [host.xclk, cam.xclk],
+      [host.pclk, cam.pclk],
+      [host.href, cam.href],
+      [host.vsync, cam.vsync],
+      [host.y0, cam.y0],
+      [host.y1, cam.y1],
+      [host.y2, cam.y2],
+      [host.y3, cam.y3],
+      [host.y4, cam.y4],
+      [host.y5, cam.y5],
+      [host.y6, cam.y6],
+      [host.y7, cam.y7]
+    ];
+    for (const [hostPort, camPort] of digitalLinks) {
+      const tester = new DigitalLinkTester(this.ctx, [hostPort, camPort]);
+      tester.test();
+    }
+  }
+  init_link() {
+    const hosts = [];
+    const cams = [];
+    for (const v of this.ports) {
+      switch (v.type) {
+        case import_electronics_model3.PortType.Dvp8Host: {
+          hosts.push(v);
+          break;
+        }
+        case import_electronics_model3.PortType.Dvp8Camera: {
+          cams.push(v);
+          break;
+        }
+      }
+    }
+    if (hosts.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one DVP8 host port.")
+      );
+      return false;
+    }
+    if (cams.length !== 1) {
+      this.ctx.report.erc_errors.push(
+        PP_ILLEGAL_CONNECTION(this.all_port_ids, "There must be exactly one DVP8 camera port.")
+      );
+      return false;
+    }
+    this.link = {
+      host: hosts[0],
+      cam: cams[0]
+    };
+    return true;
+  }
+};
+
+// src/erc/parameter_propagation/tester.ts
+var ParameterPropagationTester = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.has_passive_port = false;
+  }
+  run_test(CtorClass, ports) {
+    return new CtorClass(
+      {
+        report: this.ctx.report,
+        port_id: this.port_id,
+        has_passive_port: this.has_passive_port
+      },
+      ports
+    ).test();
+  }
+  visit_cc(cc) {
+    if (cc.nodes.length < 2) {
+      return;
+    }
+    this.link_map = (0, import_electronics_model4.gen_link_map)();
+    const ports = [];
+    for (const p of cc.nodes) {
+      switch (p.type) {
+        case import_electronics_model4.ConnectionNodeType.Port: {
+          ports.push(p);
+          break;
+        }
+        case import_electronics_model4.ConnectionNodeType.Power: {
+          ports.push({
+            type: import_electronics_model4.ConnectionNodeType.Port,
+            param: p.param,
+            label_shapes: {},
+            uuid: p.uuid
+          });
+          break;
+        }
+        case import_electronics_model4.ConnectionNodeType.NetLabel: {
+          break;
+        }
+        case import_electronics_model4.ConnectionNodeType.Graphics: {
+          break;
+        }
+      }
+    }
+    this.port_id = /* @__PURE__ */ new Map();
+    for (const p of ports) this.port_id.set(p.param, p.uuid);
+    for (const v of ports) {
+      const port = v.param;
+      if (port.type === import_electronics_model4.PortType.Passive) this.has_passive_port = true;
+      const arr = this.link_map[(0, import_electronics_model4.get_port_link_type)(port)];
+      arr.push(port);
+    }
+    let link_t = 0;
+    for (const [k, v] of Object.entries(this.link_map)) {
+      if (!v || !v.length) continue;
+      switch (k) {
+        case import_electronics_model4.LinkType.AnalogLink: {
+          this.run_test(AnalogLinkTester, v);
+          break;
+        }
+        case import_electronics_model4.LinkType.DigitalLink: {
+          this.run_test(DigitalLinkTester, v);
+          break;
+        }
+        case import_electronics_model4.LinkType.VoltageLink: {
+          this.run_test(VoltageLinkTester, v);
+          break;
+        }
+        case import_electronics_model4.LinkType.GroundLink: {
+          this.run_test(GroundLinkTester, v);
+          break;
+        }
+        case import_electronics_model4.LinkType.CanLogicLink: {
+          this.run_test(CanLogicLinkTester, v);
+          break;
+        }
+        case import_electronics_model4.LinkType.CanDiffLink: {
+          this.run_test(CanDiffLinkTester, v);
+          break;
+        }
+        case import_electronics_model4.LinkType.PassiveLink: {
+          break;
+        }
+        case import_electronics_model4.LinkType.CrystalLink: {
+          this.run_test(CrystalLinkTester, v);
+          break;
+        }
+        case import_electronics_model4.LinkType.SwdLink: {
+          this.run_test(SwdLinkTester, v);
+          break;
+        }
+        case import_electronics_model4.LinkType.I2cLink: {
+          this.run_test(I2cLinkTester, v);
+          break;
+        }
+        case import_electronics_model4.LinkType.I2sLink: {
+          this.run_test(I2sLinkTester, v);
+          break;
+        }
+        case import_electronics_model4.LinkType.SpiLink: {
+          this.run_test(SpiLinkTester, v);
+          break;
+        }
+        case import_electronics_model4.LinkType.SpeakerLink: {
+          this.run_test(SpeakerLinkTester, v);
+          break;
+        }
+        case import_electronics_model4.LinkType.TouchLink: {
+          this.run_test(TouchLinkTester, v);
+          break;
+        }
+        case import_electronics_model4.LinkType.UartLink: {
+          this.run_test(UartLinkTester, v);
+          break;
+        }
+        case import_electronics_model4.LinkType.UsbLink: {
+          this.run_test(UsbLinkTester, v);
+          break;
+        }
+        case import_electronics_model4.LinkType.UsbCcLink: {
+          this.run_test(UsbCcLinkTester, v);
+          break;
+        }
+        case import_electronics_model4.LinkType.Dvp8Link: {
+          this.run_test(Dvp8LinkTester, v);
+          break;
+        }
+        default: {
+          throw new Error(`Unhandled link type: ${k}`);
+        }
+      }
+      if (v.length > 1) link_t += 1;
+    }
+    if (link_t > 2 || link_t === 2 && !this.has_passive_port) {
+      this.ctx.report.erc_errors.push(PP_INAPPROPRIATE_FUNC(cc.nodes.map((i) => i.uuid)));
+    }
+  }
+};
+
+// src/erc/pin_compatibility_matrix/error_code.ts
+var ERCE_T = /* @__PURE__ */ ((ERCE_T2) => {
+  ERCE_T2["ERCE_DUPLICATE_SHEET_NAME"] = "duplicate_sheet_names";
+  ERCE_T2["ERCE_ENDPOINT_OFF_GRID"] = "endpoint_off_grid";
+  ERCE_T2["ERCE_PIN_NOT_CONNECTED"] = "pin_not_connected";
+  ERCE_T2["ERCE_PIN_NOT_DRIVEN"] = "pin_not_driven";
+  ERCE_T2["ERCE_POWERPIN_NOT_DRIVEN"] = "power_pin_not_driven";
+  ERCE_T2["ERCE_HIERACHICAL_LABEL"] = "hier_label_mismatch";
+  ERCE_T2["ERCE_NOCONNECT_CONNECTED"] = "no_connect_connected";
+  ERCE_T2["ERCE_NOCONNECT_NOT_CONNECTED"] = "no_connect_dangling";
+  ERCE_T2["ERCE_LABEL_NOT_CONNECTED"] = "label_dangling";
+  ERCE_T2["ERCE_SIMILAR_LABELS"] = "similar_labels";
+  ERCE_T2["ERCE_SIMILAR_POWER"] = "similar_power";
+  ERCE_T2["ERCE_SIMILAR_LABEL_AND_POWER"] = "similar_label_and_power";
+  ERCE_T2["ERCE_SINGLE_GLOBAL_LABEL"] = "single_global_label";
+  ERCE_T2["ERCE_SAME_LOCAL_GLOBAL_LABEL"] = "same_local_global_label";
+  ERCE_T2["ERCE_DIFFERENT_UNIT_FP"] = "different_unit_footprint";
+  ERCE_T2["ERCE_MISSING_POWER_INPUT_PIN"] = "missing_power_input_pin";
+  ERCE_T2["ERCE_MISSING_INPUT_PIN"] = "missing_input_pin";
+  ERCE_T2["ERCE_MISSING_BIDI_PIN"] = "missing_bidi_pin";
+  ERCE_T2["ERCE_MISSING_UNIT"] = "missing_unit";
+  ERCE_T2["ERCE_DIFFERENT_UNIT_NET"] = "different_unit_net";
+  ERCE_T2["ERCE_BUS_ALIAS_CONFLICT"] = "bus_definition_conflict";
+  ERCE_T2["ERCE_DRIVER_CONFLICT"] = "multiple_net_names";
+  ERCE_T2["ERCE_BUS_ENTRY_CONFLICT"] = "net_not_bus_member";
+  ERCE_T2["ERCE_BUS_TO_BUS_CONFLICT"] = "bus_to_bus_conflict";
+  ERCE_T2["ERCE_BUS_TO_NET_CONFLICT"] = "bus_to_net_conflict";
+  ERCE_T2["ERCE_GLOBLABEL"] = "global_label_dangling";
+  ERCE_T2["ERCE_UNRESOLVED_VARIABLE"] = "unresolved_variable";
+  ERCE_T2["ERCE_UNDEFINED_NETCLASS"] = "undefined_netclass";
+  ERCE_T2["ERCE_SIMULATION_MODEL"] = "simulation_model_issue";
+  ERCE_T2["ERCE_WIRE_DANGLING"] = "wire_dangling";
+  ERCE_T2["ERCE_LIB_SYMBOL_ISSUES"] = "lib_symbol_issues";
+  ERCE_T2["ERCE_LIB_SYMBOL_MISMATCH"] = "lib_symbol_mismatch";
+  ERCE_T2["ERCE_FOOTPRINT_LINK_ISSUES"] = "footprint_link_issues";
+  ERCE_T2["ERCE_FOOTPRINT_FILTERS"] = "footprint_filter";
+  ERCE_T2["ERCE_UNANNOTATED"] = "unannotated";
+  ERCE_T2["ERCE_EXTRA_UNITS"] = "extra_units";
+  ERCE_T2["ERCE_DIFFERENT_UNIT_VALUE"] = "unit_value_mismatch";
+  ERCE_T2["ERCE_DUPLICATE_REFERENCE"] = "duplicate_reference";
+  ERCE_T2["ERCE_BUS_ENTRY_NEEDED"] = "bus_entry_needed";
+  ERCE_T2["ERCE_FOUR_WAY_JUNCTION"] = "four_way_junction";
+  ERCE_T2["ERCE_LABEL_MULTIPLE_WIRES"] = "label_multiple_wires";
+  ERCE_T2["ERCE_UNCONNECTED_WIRE_ENDPOINT"] = "unconnected_wire_endpoint";
+  ERCE_T2["ERCE_LAST"] = "unconnected_wire_endpoint";
+  ERCE_T2["ERCE_DUPLICATE_PIN_ERROR"] = "ERCE_DUPLICATE_PIN_ERROR";
+  ERCE_T2["ERCE_PIN_TO_PIN_WARNING"] = "ERCE_PIN_TO_PIN_WARNING";
+  ERCE_T2["ERCE_PIN_TO_PIN_ERROR"] = "ERCE_PIN_TO_PIN_ERROR";
+  ERCE_T2["ERCE_ANNOTATION_ACTION"] = "ERCE_ANNOTATION_ACTION";
+  ERCE_T2["ERCE_GENERIC_WARNING"] = "ERCE_GENERIC_WARNING";
+  ERCE_T2["ERCE_GENERIC_ERROR"] = "ERCE_GENERIC_ERROR";
+  return ERCE_T2;
+})(ERCE_T || {});
+
+// src/erc/pin_compatibility_matrix/pin_error.ts
+var PIN_ERROR = /* @__PURE__ */ ((PIN_ERROR2) => {
+  PIN_ERROR2[PIN_ERROR2["OK"] = 0] = "OK";
+  PIN_ERROR2[PIN_ERROR2["WARNING"] = 1] = "WARNING";
+  PIN_ERROR2[PIN_ERROR2["PP_ERROR"] = 2] = "PP_ERROR";
+  PIN_ERROR2[PIN_ERROR2["UNCONNECTED"] = 3] = "UNCONNECTED";
+  return PIN_ERROR2;
+})(PIN_ERROR || {});
+
+// src/erc/pin_compatibility_matrix/erc_setting.ts
+var ERC_SETTING = class {
+  constructor({
+    pin_map,
+    rule_severities
+  }) {
+    this.pin_map = pin_map;
+    this.rule_severities = rule_severities;
+  }
+  IsTestEnabled(code) {
+    return this.rule_severities[code] !== 64 /* RPT_SEVERITY_IGNORE */;
+  }
+  GetPinMapValue(aFirstType, aSecondType) {
+    return this.pin_map[aFirstType][aSecondType];
+  }
+  SetPinMapValue(aFirstType, aSecondType, aValue) {
+    this.pin_map[aFirstType][aSecondType] = aValue;
+  }
+  GetSeverity(code) {
+    return this.rule_severities[code];
+  }
+  SetSeverity(code, severity) {
+    this.rule_severities[code] = severity;
+  }
+  toJSON() {
+    return {
+      pin_map: this.pin_map,
+      rule_severities: this.rule_severities,
+      erc_exclusions: [],
+      meta: {
+        version: 0
+      }
+    };
+  }
+};
+var OK = 0 /* OK */;
+var WAR = 1 /* WARNING */;
+var ERR = 2 /* PP_ERROR */;
+var DEFAULT_PIN_MAP = [
+  /*         I,   O,    Bi,   3S,   Pas,  NIC,  UnS,  PwrI, PwrO, OC,   OE,   NC */
+  /* I  */
+  [OK, OK, OK, OK, OK, OK, WAR, OK, OK, OK, OK, ERR],
+  /* O  */
+  [OK, ERR, OK, WAR, OK, OK, WAR, OK, ERR, ERR, ERR, ERR],
+  /* Bi */
+  [OK, OK, OK, OK, OK, OK, WAR, OK, WAR, OK, WAR, ERR],
+  /* 3S */
+  [OK, WAR, OK, OK, OK, OK, WAR, WAR, ERR, WAR, WAR, ERR],
+  /*Pas */
+  [OK, OK, OK, OK, OK, OK, WAR, OK, OK, OK, OK, ERR],
+  /*NIC */
+  [OK, OK, OK, OK, OK, OK, OK, OK, OK, OK, OK, ERR],
+  /*UnS */
+  [WAR, WAR, WAR, WAR, WAR, OK, WAR, WAR, WAR, WAR, WAR, ERR],
+  /*PwrI*/
+  [OK, OK, OK, WAR, OK, OK, WAR, OK, OK, OK, OK, ERR],
+  /*PwrO*/
+  [OK, ERR, WAR, ERR, OK, OK, WAR, OK, ERR, ERR, ERR, ERR],
+  /* OC */
+  [OK, ERR, OK, WAR, OK, OK, WAR, OK, ERR, OK, OK, ERR],
+  /* OE */
+  [OK, ERR, WAR, WAR, OK, OK, WAR, OK, ERR, OK, OK, ERR],
+  /* NC */
+  [ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR]
+];
+var DEFAULT_SEVERITY = {
+  ["endpoint_off_grid" /* ERCE_ENDPOINT_OFF_GRID */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["ERCE_PIN_TO_PIN_WARNING" /* ERCE_PIN_TO_PIN_WARNING */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["similar_labels" /* ERCE_SIMILAR_LABELS */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["similar_power" /* ERCE_SIMILAR_POWER */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["similar_label_and_power" /* ERCE_SIMILAR_LABEL_AND_POWER */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["single_global_label" /* ERCE_SINGLE_GLOBAL_LABEL */]: 64 /* RPT_SEVERITY_IGNORE */,
+  ["same_local_global_label" /* ERCE_SAME_LOCAL_GLOBAL_LABEL */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["global_label_dangling" /* ERCE_GLOBLABEL */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["multiple_net_names" /* ERCE_DRIVER_CONFLICT */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["net_not_bus_member" /* ERCE_BUS_ENTRY_CONFLICT */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["lib_symbol_issues" /* ERCE_LIB_SYMBOL_ISSUES */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["lib_symbol_mismatch" /* ERCE_LIB_SYMBOL_MISMATCH */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["footprint_link_issues" /* ERCE_FOOTPRINT_LINK_ISSUES */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["footprint_filter" /* ERCE_FOOTPRINT_FILTERS */]: 64 /* RPT_SEVERITY_IGNORE */,
+  ["no_connect_connected" /* ERCE_NOCONNECT_CONNECTED */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["no_connect_dangling" /* ERCE_NOCONNECT_NOT_CONNECTED */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["missing_unit" /* ERCE_MISSING_UNIT */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["missing_input_pin" /* ERCE_MISSING_INPUT_PIN */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["missing_bidi_pin" /* ERCE_MISSING_BIDI_PIN */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["simulation_model_issue" /* ERCE_SIMULATION_MODEL */]: 64 /* RPT_SEVERITY_IGNORE */,
+  ["four_way_junction" /* ERCE_FOUR_WAY_JUNCTION */]: 64 /* RPT_SEVERITY_IGNORE */,
+  ["label_multiple_wires" /* ERCE_LABEL_MULTIPLE_WIRES */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["unconnected_wire_endpoint" /* ERCE_UNCONNECTED_WIRE_ENDPOINT */]: 16 /* RPT_SEVERITY_WARNING */,
+  ["pin_not_connected" /* ERCE_PIN_NOT_CONNECTED */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["pin_not_driven" /* ERCE_PIN_NOT_DRIVEN */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["power_pin_not_driven" /* ERCE_POWERPIN_NOT_DRIVEN */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["hier_label_mismatch" /* ERCE_HIERACHICAL_LABEL */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["label_dangling" /* ERCE_LABEL_NOT_CONNECTED */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["different_unit_footprint" /* ERCE_DIFFERENT_UNIT_FP */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["missing_power_input_pin" /* ERCE_MISSING_POWER_INPUT_PIN */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["different_unit_net" /* ERCE_DIFFERENT_UNIT_NET */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["bus_definition_conflict" /* ERCE_BUS_ALIAS_CONFLICT */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["bus_to_bus_conflict" /* ERCE_BUS_TO_BUS_CONFLICT */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["bus_to_net_conflict" /* ERCE_BUS_TO_NET_CONFLICT */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["unresolved_variable" /* ERCE_UNRESOLVED_VARIABLE */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["undefined_netclass" /* ERCE_UNDEFINED_NETCLASS */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["wire_dangling" /* ERCE_WIRE_DANGLING */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["unannotated" /* ERCE_UNANNOTATED */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["extra_units" /* ERCE_EXTRA_UNITS */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["unit_value_mismatch" /* ERCE_DIFFERENT_UNIT_VALUE */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["duplicate_reference" /* ERCE_DUPLICATE_REFERENCE */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["bus_entry_needed" /* ERCE_BUS_ENTRY_NEEDED */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["ERCE_DUPLICATE_PIN_ERROR" /* ERCE_DUPLICATE_PIN_ERROR */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["ERCE_PIN_TO_PIN_ERROR" /* ERCE_PIN_TO_PIN_ERROR */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["ERCE_ANNOTATION_ACTION" /* ERCE_ANNOTATION_ACTION */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["ERCE_GENERIC_WARNING" /* ERCE_GENERIC_WARNING */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["ERCE_GENERIC_ERROR" /* ERCE_GENERIC_ERROR */]: 32 /* RPT_SEVERITY_ERROR */,
+  ["duplicate_sheet_names" /* ERCE_DUPLICATE_SHEET_NAME */]: 32 /* RPT_SEVERITY_ERROR */
+};
+var DEFAULT_ERC_SETTING = new ERC_SETTING({
+  pin_map: DEFAULT_PIN_MAP,
+  rule_severities: DEFAULT_SEVERITY
+});
+
+// src/erc/pin_compatibility_matrix/tester.ts
+var import_electronics_model5 = require("@modular-circuit/electronics-model");
+var PIN_COMPATIBILITY_MATRIX_TESTER = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  visit_cc(cc) {
+    const nodes = cc.nodes.filter((i) => (0, import_electronics_model5.node_is_electrical_node)(i));
+    for (let i = 0; i < nodes.length; i++) {
+      const current = (0, import_electronics_model5.get_electrical_pin_type)(nodes[i]);
+      for (let j = i + 1; j < nodes.length; j++) {
+        const other = (0, import_electronics_model5.get_electrical_pin_type)(nodes[j]);
+        const error = this.ctx.erc_setting.GetPinMapValue(current, other);
+        if (error !== 0 /* OK */) {
+          this.ctx.report.erc_errors.push(ERCE_PIN_TO_PIN_ERROR(nodes[i], nodes[j]));
+        }
+      }
+    }
+  }
+};
+
+// src/erc/netlist/constraints.ts
+var import_electronics_model6 = require("@modular-circuit/electronics-model");
+var DrivingPinTypes = /* @__PURE__ */ new Set([
+  import_electronics_model6.ELECTRICAL_PINTYPE.PT_OUTPUT,
+  import_electronics_model6.ELECTRICAL_PINTYPE.PT_POWER_OUT,
+  import_electronics_model6.ELECTRICAL_PINTYPE.PT_PASSIVE,
+  import_electronics_model6.ELECTRICAL_PINTYPE.PT_TRISTATE,
+  import_electronics_model6.ELECTRICAL_PINTYPE.PT_BIDI
+]);
+var PowerDrivingPinTypes = /* @__PURE__ */ new Set([import_electronics_model6.ELECTRICAL_PINTYPE.PT_POWER_OUT]);
+var DrivenPinTypes = /* @__PURE__ */ new Set([import_electronics_model6.ELECTRICAL_PINTYPE.PT_INPUT, import_electronics_model6.ELECTRICAL_PINTYPE.PT_POWER_IN]);
+
+// src/erc/netlist/tester.ts
+var import_electronics_model7 = require("@modular-circuit/electronics-model");
+var NetlistTester = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  visit_cc(cc) {
+    if (cc.nodes.length === 1 && cc.nodes[0].type === import_electronics_model7.ConnectionNodeType.Port) {
+      this.ctx.report.erc_errors.push(ERCE_PIN_NOT_CONNECTED(cc.nodes[0].uuid));
+      return;
+    }
+    this.ercCheckMultipleDrivers(cc);
+  }
+  ercCheckMultipleDrivers(cc) {
+    if (!cc.net_drivers) return;
+    const node_map = cc.nodes.reduce(
+      (map, node) => {
+        map[node.uuid] = node;
+        return map;
+      },
+      {}
+    );
+    for (const driver of cc.net_drivers.drivers) {
+      if (driver === cc.net_drivers.primary_driver) continue;
+      const node = node_map[driver];
+      const net_name = cc.name;
+      switch (node.type) {
+        case import_electronics_model7.ConnectionNodeType.Port:
+        case import_electronics_model7.ConnectionNodeType.Graphics:
+          break;
+        case import_electronics_model7.ConnectionNodeType.NetLabel:
+          if (net_name !== node.text) {
+            this.ctx.report.erc_errors.push(
+              ERCE_DRIVER_CONFLICT([cc.net_drivers.primary_driver, driver], cc.name, node.text)
+            );
+          }
+          break;
+        case import_electronics_model7.ConnectionNodeType.Power:
+          if (net_name !== node.value) {
+            this.ctx.report.erc_errors.push(
+              ERCE_DRIVER_CONFLICT([cc.net_drivers.primary_driver, driver], cc.name, node.value)
+            );
+            break;
+          }
+      }
+    }
+  }
+};
+
+// src/tester/erc_tester.ts
+var ERC_TESTER = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  run_test() {
+    const report = { erc_errors: [], markers: [] };
+    const tester_context = {
+      report,
+      ...this.ctx
+    };
+    const visitors = [
+      new PIN_COMPATIBILITY_MATRIX_TESTER(tester_context),
+      new ParameterPropagationTester(tester_context),
+      new NetlistTester(tester_context)
+    ];
+    for (const cc of this.ctx.connection_graph.subgraphs) {
+      for (const visitor of visitors) {
+        visitor.visit_cc(cc);
+      }
+    }
+    return {
+      ...report,
+      connection_graph: this.ctx.connection_graph
+    };
+  }
+};
+
+// src/tester/graph/ir_graph_converter.ts
+var import_electronics_model8 = require("@modular-circuit/electronics-model");
+var import_electronics_model9 = require("@modular-circuit/electronics-model");
+var import_ir = require("@modular-circuit/ir");
+var import_utils = require("@modular-circuit/utils");
+var IR_GRAPH_CONVERTER = class {
+  constructor(circuits) {
+    this.circuits = circuits;
+    this.graph = {};
+    this.connection_node_map = {};
+    this.schematics = {};
+    this.reporter_context = {
+      pin_name_table: {},
+      pin_module_name_table: {}
+    };
+  }
+  get_report_context() {
+    return this.reporter_context;
+  }
+  convert_to_graph(designs) {
+    const errors = [];
+    if (Object.keys(designs).length > 1) {
+      throw new Error("Multiple designs are not supported");
+    }
+    for (const [sch_name, design] of Object.entries(designs)) {
+      this.schematics[sch_name] = { uuid: design.uuid ?? (0, import_utils.gen_uuid)(), sheets: [], powers: [] };
+      for (const block of design.blocks ?? []) {
+        const circuit = this.circuits[(0, import_ir.block_is_associated_with_concrete_module)(block.type) ? block.type : (0, import_utils.fmt_module_name)(block.type)];
+        this.schematics[sch_name].sheets.push({
+          uuid: block.uuid,
+          sheet_name: design.name ?? circuit.name,
+          sheet_file_name: circuit.main,
+          ports: block.ports.map((p) => p.uuid)
+        });
+        const port_map = (0, import_utils.get_circuit_ports)(circuit);
+        for (const port of block.ports) {
+          const param = (0, import_utils.deep_copy)(port_map[port.index]);
+          const uuid = port.uuid;
+          this.add_node(uuid);
+          this.connection_node_map[uuid] = {
+            uuid,
+            type: import_electronics_model8.ConnectionNodeType.Port,
+            param,
+            label_shapes: (0, import_utils.get_port_labels)(param, circuit)
+          };
+          this.reporter_context.pin_module_name_table[port.uuid] = circuit.name;
+          this.reporter_context.pin_name_table[port.uuid] = port.name;
+        }
+      }
+      const lb_map = {};
+      for (const lb of design.labels ?? []) {
+        this.add_node(lb.uuid);
+        this.reporter_context.pin_name_table[lb.uuid] = lb.text;
+        lb_map[lb.text] = [...lb_map[lb.text] ?? [], lb.uuid];
+        switch (lb.type) {
+          case "label":
+            this.connection_node_map[lb.uuid] = { uuid: lb.uuid, type: import_electronics_model8.ConnectionNodeType.NetLabel, text: lb.text };
+            break;
+          default:
+            throw new Error(`Unsupported label type ${lb.type}`);
+        }
+      }
+      for (const labels of Object.values(lb_map)) {
+        for (let i = 0; i < labels.length - 1; i++) {
+          this.add_connection(labels[i], labels[i + 1]);
+        }
+      }
+      for (const pwr of design.pwr ?? []) {
+        this.add_pwr(pwr, import_electronics_model9.PowerShape.VCC, sch_name, {
+          type: import_electronics_model8.PortType.VoltageSource,
+          name: pwr.value,
+          link_type: import_electronics_model8.LinkType.VoltageLink,
+          label_associated: pwr.value,
+          voltage_out: pwr.param ? pwr.param.voltage_out : {},
+          current_limits: pwr.param ? pwr.param.current_limits : {}
+        });
+      }
+      for (const pwr of design.gnd ?? []) {
+        this.add_pwr(pwr, import_electronics_model9.PowerShape.GND, sch_name, {
+          type: import_electronics_model8.PortType.Ground,
+          name: pwr.value,
+          link_type: import_electronics_model8.LinkType.GroundLink,
+          label_associated: pwr.value,
+          voltage_limits: pwr.param ? pwr.param.voltage_limits : {}
+        });
+      }
+      for (const j of design.junctions ?? []) {
+        const uuid = j.uuid;
+        this.add_node(uuid);
+        this.connection_node_map[uuid] = { uuid, type: import_electronics_model8.ConnectionNodeType.Graphics };
+      }
+      for (const connection of design.wires ?? []) {
+        const uuid = connection.uuid;
+        this.add_connection(connection.from, connection.to);
+        this.connection_node_map[uuid] = { uuid, type: import_electronics_model8.ConnectionNodeType.Graphics };
+      }
+    }
+    return errors.length ? errors : true;
+  }
+  add_node(id) {
+    if (!this.graph[id]) this.graph[id] = /* @__PURE__ */ new Set();
+  }
+  add_pwr(pwr, shape, sch_name, param) {
+    const uuid = pwr.uuid;
+    const value = pwr.value;
+    this.add_node(uuid);
+    this.reporter_context.pin_name_table[uuid] = pwr.value;
+    this.connection_node_map[uuid] = { uuid, type: import_electronics_model8.ConnectionNodeType.Power, value, param };
+    this.schematics[sch_name].powers.push({
+      uuid,
+      value,
+      shape
+    });
+  }
+  add_connection(from, to) {
+    this.do_add_connection({ from, to });
+  }
+  do_add_connection(conn) {
+    for (const p of [conn.from, conn.to]) this.add_node(p);
+    this.graph[conn.from].add(conn.to);
+    this.graph[conn.to].add(conn.from);
+  }
+  get_connection_node_map() {
+    return this.connection_node_map;
+  }
+  get_graph() {
+    return this.graph;
+  }
+  get_schematics() {
+    return this.schematics;
+  }
+};
+
+// src/tester/graph/connection_graphs_builder.ts
+var import_electronics_model10 = require("@modular-circuit/electronics-model");
+var import_utils3 = require("@modular-circuit/utils");
+
+// src/utils/get_dependent_modules_definition.ts
+var import_ir2 = require("@modular-circuit/ir");
+var import_utils2 = require("@modular-circuit/utils");
+async function get_dependent_modules_definition(ctx) {
+  const circuits = {};
+  for (const [, v] of Object.entries(ctx.schematics)) {
+    for (const block of v.blocks ?? []) {
+      const module_name = (0, import_ir2.block_is_associated_with_concrete_module)(block.type) ? block.type : (0, import_utils2.fmt_module_name)(block.type);
+      let def;
+      if ((0, import_ir2.block_is_associated_with_concrete_module)(block.type)) {
+        def = await ctx.module_resolver.get_module_circuit_by_id(block.type);
+      } else if (ctx.dependencies) {
+        const version = ctx.dependencies[module_name];
+        if (version === void 0) {
+          console.warn(`Module ${module_name} not found in dependencies`);
+          continue;
+        }
+        def = await ctx.module_resolver.get_module_circuit({ ...block.type, version });
+      }
+      if (def) circuits[module_name] = def;
+    }
+  }
+  return circuits;
+}
+
+// src/tester/graph/connection_graphs_builder.ts
+var ConnectionGraphsBuilder = class {
+  constructor(connection_node_map) {
+    this.connection_node_map = connection_node_map;
+    this.net_count = 0;
+    this.item_graphs = {};
+    this.connection_graph = {
+      subgraphs: []
+    };
+  }
+  end_visit_component(cc) {
+    const sub_graph = {};
+    sub_graph.is_global_pwr = false;
+    sub_graph.is_isolated = cc.length < 2;
+    const nodes = cc.map((id) => {
+      this.item_graphs[id] = sub_graph;
+      return this.connection_node_map[id];
+    });
+    sub_graph.nodes = nodes;
+    this.resolve_net_drive(nodes, sub_graph);
+    this.connection_graph.subgraphs.push(sub_graph);
+  }
+  resolve_net_drive(nodes, sub_graph) {
+    const drivers = {
+      [import_electronics_model10.PRIORITY.INVALID]: [],
+      [import_electronics_model10.PRIORITY.NONE]: [],
+      [import_electronics_model10.PRIORITY.PIN]: [],
+      [import_electronics_model10.PRIORITY.SHEET_PIN]: [],
+      [import_electronics_model10.PRIORITY.HIER_LABEL]: [],
+      [import_electronics_model10.PRIORITY.LOCAL_LABEL]: [],
+      [import_electronics_model10.PRIORITY.POWER_PIN]: [],
+      [import_electronics_model10.PRIORITY.GLOBAL]: []
+    };
+    for (const node of nodes) {
+      drivers[(0, import_electronics_model10.get_connection_node_priority)(node)] = drivers[(0, import_electronics_model10.get_connection_node_priority)(node)] || [];
+      drivers[(0, import_electronics_model10.get_connection_node_priority)(node)].push(node);
+    }
+    sub_graph.name = (() => {
+      for (const priority of [
+        import_electronics_model10.PRIORITY.GLOBAL,
+        import_electronics_model10.PRIORITY.POWER_PIN,
+        import_electronics_model10.PRIORITY.LOCAL_LABEL,
+        import_electronics_model10.PRIORITY.HIER_LABEL,
+        import_electronics_model10.PRIORITY.SHEET_PIN,
+        import_electronics_model10.PRIORITY.PIN
+      ]) {
+        const driver_list = drivers[priority];
+        if (driver_list.length) {
+          switch (priority) {
+            case import_electronics_model10.PRIORITY.POWER_PIN:
+            case import_electronics_model10.PRIORITY.LOCAL_LABEL:
+              switch (driver_list[0].type) {
+                case import_electronics_model10.ConnectionNodeType.NetLabel:
+                  sub_graph.net_drivers = {
+                    primary_driver: driver_list[0].uuid,
+                    drivers: driver_list.map((d) => d.uuid)
+                  };
+                  return driver_list[0].text;
+                case import_electronics_model10.ConnectionNodeType.Power:
+                  sub_graph.net_drivers = {
+                    primary_driver: driver_list[0].uuid,
+                    drivers: driver_list.map((d) => d.uuid)
+                  };
+                  sub_graph.is_global_pwr = true;
+                  return driver_list[0].value;
+              }
+              break;
+          }
+        }
+      }
+      return `Net-${this.net_count++}`;
+    })();
+  }
+  get_connection_graph() {
+    return this.connection_graph;
+  }
+  get_item_graphs() {
+    return this.item_graphs;
+  }
+};
+async function build_connection_graph(ctx) {
+  const converter = new IR_GRAPH_CONVERTER(await get_dependent_modules_definition(ctx));
+  const res = converter.convert_to_graph(ctx.schematics);
+  if (res !== true) throw new Error(`Failed to convert graph ${res.join(",")}`);
+  const cc_builder = new ConnectionGraphsBuilder(converter.get_connection_node_map());
+  (0, import_utils3.test_connected_components)(converter.get_graph(), [cc_builder]);
+  return {
+    ...converter.get_report_context(),
+    connection_graph: cc_builder.get_connection_graph(),
+    item_graphs: cc_builder.get_item_graphs(),
+    cg_schematics: converter.get_schematics()
+  };
+}
+
+// src/tester/graph/graph_erc.ts
+async function graph_ecr(ctx) {
+  const connection_graph = await build_connection_graph(ctx);
+  const tester = new ERC_TESTER({
+    ...ctx,
+    connection_graph: connection_graph.connection_graph
+  });
+  return { ...tester.run_test(), ...connection_graph };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConnectionGraphsBuilder,
+  DEFAULT_ERC_SETTING,
+  DEFAULT_PIN_MAP,
+  DEFAULT_PP_ERROR_SEVERITY,
+  DEFAULT_SEVERITY,
+  DrivenPinTypes,
+  DrivingPinTypes,
+  ERCE_DRIVER_CONFLICT,
+  ERCE_PIN_NOT_CONNECTED,
+  ERCE_PIN_TO_PIN_ERROR,
+  ERCE_T,
+  ERCE_UNANNOTATED,
+  ERC_SETTING,
+  ERC_TESTER,
+  IR_GRAPH_CONVERTER,
+  MakerType,
+  NetlistTester,
+  PIN_COMPATIBILITY_MATRIX_TESTER,
+  PIN_ERROR,
+  PP_DUPLICATED_SOURCES,
+  PP_ERROR,
+  PP_ILLEGAL_CONNECTION,
+  PP_IMPEDANCE_SIGNAL_INTEGRITY,
+  PP_INAPPROPRIATE_FUNC,
+  PP_INCOMPATIBLE_DIGITAL_THRESHOLDS,
+  PP_INCOMPATIBLE_SIGNAL_LEVELS,
+  PP_INCOMPATIBLE_VOLTAGE_LEVELS,
+  PP_INSUFFICIENT_DRIVER,
+  PP_NOT_DRIVEN,
+  PP_OVERCURRENT,
+  PP_OVER_DRIVEN,
+  PP_REQUIRES_CONNECTED_SOURCE_OR_BIDIR,
+  PP_SIGNAL_LEVELS_NOT_CONTAINED_WITHIN_VOLTAGE,
+  ParameterPropagationTester,
+  PowerDrivingPinTypes,
+  SEVERITY,
+  build_connection_graph,
+  fmt_erc_item_description,
+  get_erc_severity,
+  graph_ecr
+});