diff --git a/edg/abstract_parts/AbstractInductor.py b/edg/abstract_parts/AbstractInductor.py
index c9415e6aa..7a7e17b10 100644
--- a/edg/abstract_parts/AbstractInductor.py
+++ b/edg/abstract_parts/AbstractInductor.py
@@ -1,7 +1,7 @@
 from typing import Dict, Optional, cast
 
 from ..electronics_model import *
-from .PartsTable import PartsTableColumn, PartsTableRow
+from .PartsTable import PartsTableColumn, PartsTableRow, ExperimentalUserFnPartsTable
 from .PartsTablePart import PartsTableSelector
 from .Categories import *
 from .StandardFootprint import StandardFootprint, HasStandardFootprint
@@ -94,7 +94,9 @@ def symbol_pinning(self, symbol_name: str) -> Dict[str, BasePort]:
   def __init__(self, inductance: RangeLike,
                current: RangeLike = RangeExpr.ZERO,
                frequency: RangeLike = RangeExpr.ZERO,
-               resistance_dc: RangeLike = (0, 1)*Ohm  # generic sane choice?
+               resistance_dc: RangeLike = (0, 1)*Ohm,  # generic sane choice?
+               *,
+               experimental_filter_fn: StringLike = ""
                ) -> None:
     super().__init__()
 
@@ -105,6 +107,7 @@ def __init__(self, inductance: RangeLike,
     self.current = self.ArgParameter(current)  # defined as operating current range, non-directioned
     self.frequency = self.ArgParameter(frequency)  # defined as operating frequency range
     self.resistance_dc = self.ArgParameter(resistance_dc)
+    self.experimental_filter_fn = self.ArgParameter(experimental_filter_fn)
 
     self.actual_inductance = self.Parameter(RangeExpr())
     self.actual_current_rating = self.Parameter(RangeExpr())
@@ -136,15 +139,23 @@ class TableInductor(PartsTableSelector, Inductor):
   @init_in_parent
   def __init__(self, *args, **kwargs) -> None:
     super().__init__(*args, **kwargs)
-    self.generator_param(self.inductance, self.current, self.frequency, self.resistance_dc)
+    self.generator_param(self.inductance, self.current, self.frequency, self.resistance_dc,
+                         self.experimental_filter_fn)
 
   def _row_filter(self, row: PartsTableRow) -> bool:
     # TODO eliminate arbitrary DCR limit in favor of exposing max DCR to upper levels
+    filter_fn_str = self.get(self.experimental_filter_fn)
+    if filter_fn_str:
+      filter_fn = ExperimentalUserFnPartsTable.deserialize_fn(filter_fn_str)
+    else:
+      filter_fn = None
+
     return super()._row_filter(row) and \
       row[self.INDUCTANCE].fuzzy_in(self.get(self.inductance)) and \
       self.get(self.current).fuzzy_in(row[self.CURRENT_RATING]) and \
       row[self.DC_RESISTANCE].fuzzy_in(self.get(self.resistance_dc)) and \
-      self.get(self.frequency).fuzzy_in(row[self.FREQUENCY_RATING])
+      self.get(self.frequency).fuzzy_in(row[self.FREQUENCY_RATING]) and\
+      (filter_fn is None or filter_fn(row))
 
   def _row_generate(self, row: PartsTableRow) -> None:
     super()._row_generate(row)
diff --git a/edg/abstract_parts/AbstractPowerConverters.py b/edg/abstract_parts/AbstractPowerConverters.py
index 5d29276df..f78ad53a6 100644
--- a/edg/abstract_parts/AbstractPowerConverters.py
+++ b/edg/abstract_parts/AbstractPowerConverters.py
@@ -1,10 +1,14 @@
 from abc import abstractmethod
-from typing import Optional, NamedTuple, Generic, TypeVar, Union
-from ..electronics_model import *
-from .Categories import *
+from typing import Optional, NamedTuple
+
+from deprecated import deprecated
+
 from .AbstractCapacitor import DecouplingCapacitor
-from .AbstractInductor import Inductor
+from .AbstractInductor import Inductor, TableInductor
+from .Categories import *
+from .PartsTable import PartsTableRow, ExperimentalUserFnPartsTable
 from .Resettable import Resettable
+from ..electronics_model import *
 
 
 @abstract_block_default(lambda: IdealVoltageRegulator)
@@ -121,6 +125,7 @@ def __init__(self) -> None:
 @abstract_block
 class SwitchingVoltageRegulator(VoltageRegulator):
   @staticmethod
+  @deprecated("ripple calculation moved into the power-path block itself")
   def _calculate_ripple(output_current: RangeLike, ripple_ratio: RangeLike, *,
                         rated_current: Optional[FloatLike] = None) -> RangeExpr:
     """
@@ -146,7 +151,7 @@ def _calculate_ripple(output_current: RangeLike, ripple_ratio: RangeLike, *,
       upper_ripple_limit))
 
   @init_in_parent
-  def __init__(self, *args, ripple_current_factor: RangeLike,
+  def __init__(self, *args,
                input_ripple_limit: FloatLike = 75 * mVolt,
                output_ripple_limit: FloatLike = 25 * mVolt,
                **kwargs) -> None:
@@ -154,7 +159,6 @@ def __init__(self, *args, ripple_current_factor: RangeLike,
     """
     super().__init__(*args, **kwargs)
 
-    self.ripple_current_factor = self.ArgParameter(ripple_current_factor)
     self.input_ripple_limit = self.ArgParameter(input_ripple_limit)
     self.output_ripple_limit = self.ArgParameter(output_ripple_limit)
 
@@ -164,9 +168,8 @@ def __init__(self, *args, ripple_current_factor: RangeLike,
 @abstract_block_default(lambda: IdealBuckConverter)
 class BuckConverter(SwitchingVoltageRegulator):
   """Step-down switching converter"""
-  def __init__(self, *args, ripple_current_factor: RangeLike = (0.2, 0.5), **kwargs) -> None:
-    # TODO default ripple is very heuristic, intended 0.3-0.4, loosely adjusted for inductor tolerance
-    super().__init__(*args, ripple_current_factor=ripple_current_factor, **kwargs)
+  def __init__(self, *args, **kwargs) -> None:
+    super().__init__(*args, **kwargs)
     self.require(self.pwr_out.voltage_out.upper() <= self.pwr_in.voltage_limits.upper())
 
 
@@ -192,60 +195,146 @@ def contents(self):
 class BuckConverterPowerPath(InternalSubcircuit, GeneratorBlock):
   """A helper block to generate the power path (inductors, capacitors) for a switching buck converter.
 
-  Main assumptions in component sizing:
-  - Operating only in continuous mode, TODO: also consider boundary and discontinuous mode
-  - TODO: account for capacitor ESR?
-
   Useful resources:
   https://www.ti.com/lit/an/slva477b/slva477b.pdf
     Component sizing in continuous mode
-    Listed references go into more detail
   http://www.onmyphd.com/?p=voltage.regulators.buck.step.down.converter
     Very detailed analysis including component sizing, operating modes, calculating losses
   """
 
+  @staticmethod
+  def _d_inverse_d(d_range: Range) -> Range:
+    """Some power calculations require the maximum of D*(1-D), which has a maximum at D=0.5"""
+    # can't use range ops since they will double-count the tolerance of D, so calculate endpoints separately
+    range_endpoints = [d_range.lower * (1 - d_range.lower), d_range.upper * (1 - d_range.upper)]
+    raw_range = Range(min(range_endpoints), max(range_endpoints))
+    if 0.5 in d_range:  # the function has a maximum at 0.5
+      return raw_range.hull(Range.exact(0.5 * (1 - 0.5)))
+    else:
+      return raw_range
+
+  @staticmethod
+  def _ripple_current_from_sw_current(sw_current: float, ripple_ratio: Range) -> Range:
+    """Calculates the ripple current from a total switch current and ripple ratio."""
+    return Range(  # separate range parts to avoid double-counting tolerances
+      sw_current / (1 + ripple_ratio.lower) * ripple_ratio.lower,
+      sw_current / (1 + ripple_ratio.upper) * ripple_ratio.upper
+    )
+
   class Values(NamedTuple):
     dutycycle: Range
     inductance: Range
     input_capacitance: Range
     output_capacitance: Range
 
-    inductor_peak_currents: Range  # based on the worst case input spec
+    inductor_avg_current: Range
+    ripple_scale: float  # divide this by inductance to get the inductor ripple current
+    min_ripple: float  # fallback minimum ripple current for component sizing for light-load, may be 0
+    output_capacitance_scale: float  # multiply inductor ripple by this to get required output capacitance
+
+    inductor_peak_currents: Range  # based on the worst case input spec, for unit testing
     effective_dutycycle: Range  # duty cycle adjusted for tracking behavior
 
   @classmethod
-  def calculate_parameters(cls, input_voltage: Range, output_voltage: Range, frequency: Range, output_current: Range,
-                           inductor_current_ripple: Range, input_voltage_ripple: float, output_voltage_ripple: float,
-                           efficiency: Range = Range(0.9, 1.0), dutycycle_limit: Range = Range(0.1, 0.9)) -> 'BuckConverterPowerPath.Values':
+  def _calculate_parameters(cls, input_voltage: Range, output_voltage: Range, frequency: Range, output_current: Range,
+                            sw_current_limits: Range, ripple_ratio: Range,
+                            input_voltage_ripple: float, output_voltage_ripple: float,
+                            efficiency: Range = Range(0.9, 1.0), dutycycle_limit: Range = Range(0.1, 0.9),
+                            limit_ripple_ratio: Range = Range(0.1, 0.5)) -> 'BuckConverterPowerPath.Values':
+    """Calculates parameters for the buck converter power path.
+
+    This uses the continuous conduction mode (CCM) equations to calculate component sizes.
+    DCM is not explicitly calculated since it requires additional parameters like minimum on-time.
+    The limit_ripple_ratio provides some broadly sane values for light-load / DCM operation.
+    This also ignores higher-order component behavior like capacitor ESR.
+
+    The ripple_ratio is optional and may be set to Range.all(), allowing the inductor selector
+    to optimize the inductor by trading off inductance and max current.
+
+    Values for component selections are bounded by:
+    - the ripple_ratio at output_current (if ripple_ratio < inf), and
+    - the limit_ripple_ratio at sw_current_limits (if sw_current_limits is not zero), as a fallback
+      for light-load conditions (where otherwise current goes to zero and inductance goes to the moon)
+    """
     dutycycle = output_voltage / input_voltage / efficiency
     effective_dutycycle = dutycycle.bound_to(dutycycle_limit)  # account for tracking behavior
 
-    # TODO different equation for DCM operation
-    inductor_peak_currents = Range(max(0, output_current.lower - inductor_current_ripple.upper / 2),
-      output_current.upper + inductor_current_ripple.upper / 2)
-
     # calculate minimum inductance based on worst case values (operating range corners producing maximum inductance)
     # worst-case input/output voltages and frequency is used to avoid double-counting tolerances as ranges
-    inductance = (output_voltage.lower * (input_voltage.upper - output_voltage.lower) /
-                  (inductor_current_ripple * frequency.lower * input_voltage.upper))
-
-    input_capacitance = Range.from_lower(output_current.upper * cls.max_d_inverse_d(effective_dutycycle) /
+    # note, for buck converter, L = (Vin - Vout) * D / (f * Iripple) = Vout (Vin - Vout) / (Iripple * f * Vin)
+    # this is at a maximum at Vin,max, and on that curve with a critical point at Vout = Vin,max / 2
+    # note, the same formula calculates ripple-from-inductance and inductance-from-ripple
+    inductance_scale_candidates = [
+      output_voltage.lower * (input_voltage.upper - output_voltage.lower) / input_voltage.upper,
+      output_voltage.upper * (input_voltage.upper - output_voltage.upper) / input_voltage.upper,
+    ]
+    if input_voltage.upper / 2 in output_voltage:
+      inductance_scale_candidates.append(
+        input_voltage.upper/2 * (input_voltage.upper - input_voltage.upper/2) / input_voltage.upper)
+    inductance_scale = max(inductance_scale_candidates) / frequency.lower
+
+    inductance = Range.all()
+    min_ripple = 0.0
+    if sw_current_limits.upper > 0:  # fallback for light-load
+      ripple_current = cls._ripple_current_from_sw_current(sw_current_limits.upper, limit_ripple_ratio)
+      inductance = inductance.intersect(inductance_scale / ripple_current)
+      min_ripple = ripple_current.lower
+    if ripple_ratio.upper < float('inf'):
+      assert ripple_ratio.lower > 0, f"invalid non-inf ripple ratio {ripple_ratio}"
+
+      inductance = inductance.intersect(inductance_scale / (output_current.upper * ripple_ratio))
+    assert inductance.upper < float('inf'), 'neither ripple_ratio nor fallback sw_current_limits given'
+
+    input_capacitance = Range.from_lower(output_current.upper * cls._d_inverse_d(effective_dutycycle).upper /
                                          (frequency.lower * input_voltage_ripple))
-    output_capacitance = Range.from_lower(inductor_current_ripple.upper /
-                                          (8 * frequency.lower * output_voltage_ripple))
+    output_capacitance_scale = 1 / (8 * frequency.lower * output_voltage_ripple)
+
+    # these are static worst-case estimates for the range of specified ripple currents
+    # mainly used for unit testing
+    inductor_current_ripple = output_current * ripple_ratio.intersect(limit_ripple_ratio)
+    inductor_peak_currents = Range(max(0, output_current.lower - inductor_current_ripple.upper / 2),
+                                   max(output_current.upper + inductor_current_ripple.upper / 2,
+                                       inductor_current_ripple.upper))
+    output_capacitance = Range.from_lower(output_capacitance_scale * inductor_current_ripple.upper)
 
     return cls.Values(dutycycle=dutycycle, inductance=inductance,
                       input_capacitance=input_capacitance, output_capacitance=output_capacitance,
+                      inductor_avg_current=output_current / efficiency,
+                      ripple_scale=inductance_scale, min_ripple=min_ripple,
+                      output_capacitance_scale=output_capacitance_scale,
                       inductor_peak_currents=inductor_peak_currents,
-                      effective_dutycycle= effective_dutycycle)
+                      effective_dutycycle=effective_dutycycle)
+
+  @staticmethod
+  @ExperimentalUserFnPartsTable.user_fn([float, float, float])
+  def _buck_inductor_filter(max_avg_current: float, ripple_scale: float, min_ripple: float):
+    """Applies further filtering to inductors using the trade-off between inductance and peak-peak current.
+    max_avg_current is the maximum average current (not accounting for ripple) seen by the inductor
+    ripple_scale is the scaling factor from 1/L to ripple
+    This structure also works for boost converters, which would have its ripple_scale calculated differently."""
+    def filter_fn(row: PartsTableRow) -> bool:
+      ripple_current = max(ripple_scale / row[TableInductor.INDUCTANCE].lower, min_ripple)
+      max_current_pp = max_avg_current + ripple_current / 2
+      return max_current_pp in row[TableInductor.CURRENT_RATING]
+    return filter_fn
+
+  @staticmethod
+  def _ilim_expr(inductor_ilim: RangeExpr, sw_ilim: RangeExpr, inductor_iripple: RangeExpr):
+    """Returns the average current limit, as an expression, derived from the inductor and switch (instantaneous)
+    current limits."""
+    iout_limit_inductor = inductor_ilim - (inductor_iripple.upper() / 2)
+    iout_limit_sw = (sw_ilim.upper() > 0).then_else(
+      sw_ilim - (inductor_iripple.upper() / 2), Range.all())
+    return iout_limit_inductor.intersect(iout_limit_sw)
 
   @init_in_parent
   def __init__(self, input_voltage: RangeLike, output_voltage: RangeLike, frequency: RangeLike,
-               output_current: RangeLike, current_limits: RangeLike, inductor_current_ripple: RangeLike, *,
+               output_current: RangeLike, sw_current_limits: RangeLike, *,
                input_voltage_ripple: FloatLike,
                output_voltage_ripple: FloatLike,
                efficiency: RangeLike = (0.9, 1.0),  # from TI reference
-               dutycycle_limit: RangeLike = (0.1, 0.9)):
+               dutycycle_limit: RangeLike = (0.1, 0.9),
+               ripple_ratio: RangeLike = Range.all()):
     super().__init__()
 
     self.pwr_in = self.Port(VoltageSink.empty(), [Power])  # models the input cap only
@@ -257,16 +346,17 @@ def __init__(self, input_voltage: RangeLike, output_voltage: RangeLike, frequenc
     self.output_voltage = self.ArgParameter(output_voltage)
     self.frequency = self.ArgParameter(frequency)
     self.output_current = self.ArgParameter(output_current)
-    self.inductor_current_ripple = self.ArgParameter(inductor_current_ripple)
+    self.sw_current_limits = self.ArgParameter(sw_current_limits)
+
     self.efficiency = self.ArgParameter(efficiency)
     self.input_voltage_ripple = self.ArgParameter(input_voltage_ripple)
     self.output_voltage_ripple = self.ArgParameter(output_voltage_ripple)
     self.dutycycle_limit = self.ArgParameter(dutycycle_limit)
-    self.generator_param(self.input_voltage, self.output_voltage, self.frequency, self.output_current,
-                         self.inductor_current_ripple, self.efficiency,
-                         self.input_voltage_ripple, self.output_voltage_ripple, self.dutycycle_limit)
+    self.ripple_ratio = self.ArgParameter(ripple_ratio)  # only used to force a ripple ratio at the actual currents
 
-    self.current_limits = self.ArgParameter(current_limits)
+    self.generator_param(self.input_voltage, self.output_voltage, self.frequency, self.output_current,
+                         self.sw_current_limits, self.input_voltage_ripple, self.output_voltage_ripple,
+                         self.efficiency, self.dutycycle_limit, self.ripple_ratio)
 
     self.actual_dutycycle = self.Parameter(RangeExpr())
     self.actual_inductor_current_ripple = self.Parameter(RangeExpr())
@@ -281,50 +371,33 @@ def contents(self):
       ", <b>ripple:</b> ", DescriptionString.FormatUnits(self.actual_inductor_current_ripple, "A")
     )
 
-  @staticmethod
-  def max_d_inverse_d(d_range: Range) -> float:
-    """Some power calculations require the maximum of D*(1-D), which has a maximum at D=0.5"""
-    if 0.5 in d_range:
-      return 0.5 * (1 - 0.5)
-    elif d_range.lower > 0.5:
-      return d_range.lower * (1 - d_range.lower)
-    elif d_range.upper < 0.5:
-      return d_range.upper * (1 - d_range.upper)
-    else:
-      raise Exception(f"unexpected D range {d_range}")
-
   def generate(self) -> None:
     super().generate()
-    values = self.calculate_parameters(self.get(self.input_voltage), self.get(self.output_voltage),
-                                       self.get(self.frequency), self.get(self.output_current),
-                                       self.get(self.inductor_current_ripple),
-                                       self.get(self.input_voltage_ripple), self.get(self.output_voltage_ripple),
-                                       efficiency=self.get(self.efficiency),
-                                       dutycycle_limit=self.get(self.dutycycle_limit))
+    values = self._calculate_parameters(self.get(self.input_voltage), self.get(self.output_voltage),
+                                        self.get(self.frequency), self.get(self.output_current),
+                                        self.get(self.sw_current_limits), self.get(self.ripple_ratio),
+                                        self.get(self.input_voltage_ripple), self.get(self.output_voltage_ripple),
+                                        efficiency=self.get(self.efficiency),
+                                        dutycycle_limit=self.get(self.dutycycle_limit))
     self.assign(self.actual_dutycycle, values.dutycycle)
     self.require(values.dutycycle == values.effective_dutycycle, "dutycycle outside limit")
 
-    # TODO maximum current depends on the inductance, but this just uses a worst-case value for simplicity
-    # TODO ideally the inductor selector would take a function that can account for this coupled equation
     self.inductor = self.Block(Inductor(
-      inductance=values.inductance*Henry,
-      current=values.inductor_peak_currents,
-      frequency=self.frequency
+      inductance=values.inductance * Henry,
+      current=values.inductor_avg_current,  # min-bound only, the real filter happens in the filter_fn
+      frequency=self.frequency,
+      experimental_filter_fn=ExperimentalUserFnPartsTable.serialize_fn(
+        self._buck_inductor_filter, values.inductor_avg_current.upper, values.ripple_scale, values.min_ripple)
     ))
-
-    # expand out the equation to avoid double-counting tolerance
-    actual_peak_ripple = (self.output_voltage.lower() * (self.input_voltage.upper() - self.output_voltage.lower()) /
-                          (self.inductor.actual_inductance * self.frequency.lower() * self.input_voltage.upper()))
-    self.assign(self.actual_inductor_current_ripple, actual_peak_ripple)
+    self.assign(self.actual_inductor_current_ripple, values.ripple_scale / self.inductor.actual_inductance)
 
     self.connect(self.switch, self.inductor.a.adapt_to(VoltageSink(
-      voltage_limits=RangeExpr.ALL,
       current_draw=self.pwr_out.link().current_drawn * values.dutycycle
     )))
     self.connect(self.pwr_out, self.inductor.b.adapt_to(VoltageSource(
       voltage_out=self.output_voltage,
-      current_limits=(0, self.current_limits.intersect(self.inductor.actual_current_rating).upper() -
-                      (self.actual_inductor_current_ripple.upper() / 2))
+      current_limits=self._ilim_expr(self.inductor.actual_current_rating, self.sw_current_limits,
+                                     self.actual_inductor_current_ripple)
     )))
 
     self.in_cap = self.Block(DecouplingCapacitor(
@@ -332,7 +405,8 @@ def generate(self) -> None:
       exact_capacitance=True
     )).connected(self.gnd, self.pwr_in)
     self.out_cap = self.Block(DecouplingCapacitor(
-      capacitance=values.output_capacitance * Farad,
+      capacitance=(Range.exact(float('inf')) * Farad).hull(
+        (values.output_capacitance_scale * self.actual_inductor_current_ripple.upper().max(values.min_ripple))),
       exact_capacitance=True
     )).connected(self.gnd, self.pwr_out)
 
@@ -340,9 +414,8 @@ def generate(self) -> None:
 @abstract_block_default(lambda: IdealBoostConverter)
 class BoostConverter(SwitchingVoltageRegulator):
   """Step-up switching converter"""
-  def __init__(self, *args, ripple_current_factor: RangeLike = (0.2, 0.5), **kwargs) -> None:
-    # TODO default ripple is very heuristic, intended 0.3-0.4, loosely adjusted for inductor tolerance
-    super().__init__(*args, ripple_current_factor=ripple_current_factor, **kwargs)
+  def __init__(self, *args, **kwargs) -> None:
+    super().__init__(*args, **kwargs)
     self.require(self.pwr_out.voltage_out.lower() >= self.pwr_in.voltage_limits.lower())
 
 
@@ -368,14 +441,9 @@ def contents(self):
 class BoostConverterPowerPath(InternalSubcircuit, GeneratorBlock):
   """A helper block to generate the power path (inductors, capacitors) for a synchronous boost converter.
 
-  Main assumptions in component sizing
-  - Operating only in continuous mode, TODO: also consider boundary and discontinuous mode
-  - TODO: account for capacitor ESR?
-
   Useful resources:
   https://www.ti.com/lit/an/slva372c/slva372c.pdf
     Component sizing in continuous mode
-    Listed references go into more detail
   http://www.simonbramble.co.uk/dc_dc_converter_design/boost_converter/boost_converter_design.htm
     Detailed analysis of converter with discrete FET and diode
   """
@@ -386,26 +454,52 @@ class Values(NamedTuple):
     input_capacitance: Range
     output_capacitance: Range
 
-    inductor_peak_currents: Range  # based on the worst case input spec
+    inductor_avg_current: Range
+    ripple_scale: float  # divide this by inductance to get the inductor ripple current
+    min_ripple: float  # fallback minimum ripple current for component sizing for light-load, may be 0
+
+    inductor_peak_currents: Range  # based on the worst case input spec, for unit testing
     effective_dutycycle: Range
 
   @classmethod
-  def calculate_parameters(cls, input_voltage: Range, output_voltage: Range, frequency: Range, output_current: Range,
-                           inductor_current_ripple: Range, input_voltage_ripple: float, output_voltage_ripple: float,
-                           efficiency: Range = Range(0.8, 1.0), dutycycle_limit: Range = Range(0.1, 0.9)) -> 'BoostConverterPowerPath.Values':
+  def _calculate_parameters(cls, input_voltage: Range, output_voltage: Range, frequency: Range, output_current: Range,
+                            sw_current_limits: Range, ripple_ratio: Range,
+                            input_voltage_ripple: float, output_voltage_ripple: float,
+                            efficiency: Range = Range(0.8, 1.0), dutycycle_limit: Range = Range(0.1, 0.9),
+                            limit_ripple_ratio: Range = Range(0.1, 0.5)) -> 'BoostConverterPowerPath.Values':
+    """See BuckConverterPowerPath._calculate_parameters, this performs a similar function."""
     dutycycle = 1 - input_voltage / output_voltage * efficiency
     effective_dutycycle = dutycycle.bound_to(dutycycle_limit)  # account for tracking behavior
-
-    # TODO different equation for DCM operation
-    inductor_peak_currents = Range(max(0, output_current.upper / (1 - effective_dutycycle.upper)
-                                       - inductor_current_ripple.upper / 2),
-                                   output_current.upper / (1 - effective_dutycycle.upper)
-                                   + inductor_current_ripple.upper / 2)
+    inductor_avg_current = output_current / (1 - effective_dutycycle)
 
     # calculate minimum inductance based on worst case values (operating range corners producing maximum inductance)
     # worst-case input/output voltages and frequency is used to avoid double-counting tolerances as ranges
-    inductance = (input_voltage.lower * (output_voltage.upper - input_voltage.lower) /
-                  (inductor_current_ripple * frequency.lower * output_voltage.upper))
+    # note, for boost converter, L = Vin * D / (f * Iripple) = Vin (Vout - Vin) / (Iripple * f * Vout)
+    # this is at a maximum at Vout,max, and on that curve with a critical point at Vin = Vout,max / 2
+    inductance_scale_candidates = [
+      input_voltage.lower * (output_voltage.upper - input_voltage.lower) / output_voltage.upper,
+      input_voltage.upper * (output_voltage.upper - input_voltage.upper) / output_voltage.upper,
+    ]
+    if output_voltage.upper / 2 in input_voltage:
+      inductance_scale_candidates.append(
+        output_voltage.upper/2 * (output_voltage.upper - output_voltage.upper/2) / output_voltage.upper)
+    inductance_scale = max(inductance_scale_candidates) / frequency.lower
+
+    inductance = Range.all()
+    min_ripple = 0.0
+    if sw_current_limits.upper > 0:  # fallback for light-load
+      ripple_current = BuckConverterPowerPath._ripple_current_from_sw_current(sw_current_limits.upper, limit_ripple_ratio)
+      inductance = inductance.intersect(inductance_scale / ripple_current)
+      min_ripple = ripple_current.lower
+    if ripple_ratio.upper < float('inf'):
+      assert ripple_ratio.lower > 0, f"invalid non-inf ripple ratio {ripple_ratio}"
+      inductance = inductance.intersect(inductance_scale / (inductor_avg_current.upper * ripple_ratio))
+    assert inductance.upper < float('inf'), 'neither ripple_ratio nor fallback sw_current_limits given'
+
+    inductor_current_ripple = inductor_avg_current * ripple_ratio.intersect(limit_ripple_ratio)
+    inductor_peak_currents = Range(max(0, inductor_current_ripple.lower - inductor_current_ripple.upper / 2),
+                                   max(inductor_avg_current.upper + inductor_current_ripple.upper / 2,
+                                       inductor_current_ripple.upper))
 
     # Capacitor equation Q = CV => i = C dv/dt => for constant current, i * t = C dV => dV = i * t / C
     # C = i * t / dV => C = i / (f * dV)
@@ -420,16 +514,18 @@ def calculate_parameters(cls, input_voltage: Range, output_voltage: Range, frequ
 
     return cls.Values(dutycycle=dutycycle, inductance=inductance,
                       input_capacitance=input_capacitance, output_capacitance=output_capacitance,
+                      inductor_avg_current=inductor_avg_current, ripple_scale=inductance_scale, min_ripple=min_ripple,
                       inductor_peak_currents=inductor_peak_currents,
                       effective_dutycycle=effective_dutycycle)
 
   @init_in_parent
   def __init__(self, input_voltage: RangeLike, output_voltage: RangeLike, frequency: RangeLike,
-               output_current: RangeLike, current_limits: RangeLike, inductor_current_ripple: RangeLike, *,
-               efficiency: RangeLike = (0.8, 1.0),  # from TI reference
+               output_current: RangeLike, sw_current_limits: RangeLike, *,
                input_voltage_ripple: FloatLike = 75*mVolt,
                output_voltage_ripple: FloatLike = 25*mVolt,
-               dutycycle_limit: RangeLike = (0.1, 0.9)):  # arbitrary
+               efficiency: RangeLike = (0.8, 1.0),  # from TI reference
+               dutycycle_limit: RangeLike = (0.1, 0.9),  # arbitrary
+               ripple_ratio: RangeLike = Range.all()):
     super().__init__()
 
     self.pwr_in = self.Port(VoltageSink.empty(), [Power])  # models input cap and inductor power draw
@@ -441,16 +537,17 @@ def __init__(self, input_voltage: RangeLike, output_voltage: RangeLike, frequenc
     self.output_voltage = self.ArgParameter(output_voltage)
     self.frequency = self.ArgParameter(frequency)
     self.output_current = self.ArgParameter(output_current)
-    self.inductor_current_ripple = self.ArgParameter(inductor_current_ripple)
+    self.sw_current_limits = self.ArgParameter(sw_current_limits)
+
     self.efficiency = self.ArgParameter(efficiency)
     self.input_voltage_ripple = self.ArgParameter(input_voltage_ripple)
     self.output_voltage_ripple = self.ArgParameter(output_voltage_ripple)
     self.dutycycle_limit = self.ArgParameter(dutycycle_limit)
-    self.generator_param(self.input_voltage, self.output_voltage, self.frequency, self.output_current,
-                         self.inductor_current_ripple, self.efficiency,
-                         self.input_voltage_ripple, self.output_voltage_ripple, self.dutycycle_limit)
+    self.ripple_ratio = self.ArgParameter(ripple_ratio)  # only used to force a ripple ratio at the actual currents
 
-    self.current_limits = self.ArgParameter(current_limits)
+    self.generator_param(self.input_voltage, self.output_voltage, self.frequency, self.output_current,
+                         self.sw_current_limits, self.input_voltage_ripple, self.output_voltage_ripple,
+                         self.efficiency, self.dutycycle_limit, self.ripple_ratio)
 
     self.actual_dutycycle = self.Parameter(RangeExpr())
     self.actual_inductor_current_ripple = self.Parameter(RangeExpr())
@@ -467,33 +564,33 @@ def contents(self):
 
   def generate(self) -> None:
     super().generate()
-    values = self.calculate_parameters(self.get(self.input_voltage), self.get(self.output_voltage),
-                                       self.get(self.frequency), self.get(self.output_current),
-                                       self.get(self.inductor_current_ripple),
-                                       self.get(self.input_voltage_ripple), self.get(self.output_voltage_ripple),
-                                       efficiency=self.get(self.efficiency),
-                                       dutycycle_limit=self.get(self.dutycycle_limit))
+    values = self._calculate_parameters(self.get(self.input_voltage), self.get(self.output_voltage),
+                                        self.get(self.frequency), self.get(self.output_current),
+                                        self.get(self.sw_current_limits), self.get(self.ripple_ratio),
+                                        self.get(self.input_voltage_ripple), self.get(self.output_voltage_ripple),
+                                        efficiency=self.get(self.efficiency),
+                                        dutycycle_limit=self.get(self.dutycycle_limit))
     self.assign(self.actual_dutycycle, values.dutycycle)
     self.require(values.dutycycle == values.effective_dutycycle, "dutycycle outside limit")
 
     self.inductor = self.Block(Inductor(
       inductance=values.inductance * Henry,
-      current=values.inductor_peak_currents,
-      frequency=self.frequency
+      current=values.inductor_avg_current,  # min-bound only, the real filter happens in the filter_fn
+      frequency=self.frequency,
+      experimental_filter_fn=ExperimentalUserFnPartsTable.serialize_fn(
+        BuckConverterPowerPath._buck_inductor_filter,
+        values.inductor_avg_current.upper, values.ripple_scale, values.min_ripple)
     ))
-
-    actual_ripple = (self.input_voltage.lower() * (self.output_voltage.upper() - self.input_voltage.lower()) /
-                         (self.inductor.actual_inductance * self.frequency.lower() * self.output_voltage.lower()))
-    self.assign(self.actual_inductor_current_ripple, actual_ripple)
+    self.assign(self.actual_inductor_current_ripple, values.ripple_scale / self.inductor.actual_inductance)
 
     self.connect(self.pwr_in, self.inductor.a.adapt_to(VoltageSink(
-      voltage_limits=RangeExpr.ALL,
       current_draw=self.pwr_out.link().current_drawn / (1 - values.dutycycle)
     )))
     self.connect(self.switch, self.inductor.b.adapt_to(VoltageSource(
       voltage_out=self.output_voltage,
-      current_limits=(0, self.current_limits.intersect(self.inductor.actual_current_rating).upper() -
-                      (self.actual_inductor_current_ripple.upper() / 2))
+      current_limits=BuckConverterPowerPath._ilim_expr(self.inductor.actual_current_rating, self.sw_current_limits,
+                                                       self.actual_inductor_current_ripple)
+                     * self.input_voltage / self.output_voltage
     )))
 
     self.in_cap = self.Block(DecouplingCapacitor(
@@ -510,9 +607,6 @@ def generate(self) -> None:
 @abstract_block_default(lambda: IdealVoltageRegulator)
 class BuckBoostConverter(SwitchingVoltageRegulator):
   """Step-up or switch-down switching converter"""
-  def __init__(self, *args, ripple_current_factor: RangeLike = (0.2, 0.5), **kwargs) -> None:
-    # TODO default ripple is very heuristic, intended 0.3-0.4, loosely adjusted for inductor tolerance
-    super().__init__(*args, ripple_current_factor=ripple_current_factor, **kwargs)
 
 
 @abstract_block_default(lambda: IdealVoltageRegulator)
@@ -546,10 +640,11 @@ class BuckBoostConverterPowerPath(InternalSubcircuit, GeneratorBlock):
   """
   @init_in_parent
   def __init__(self, input_voltage: RangeLike, output_voltage: RangeLike, frequency: RangeLike,
-               output_current: RangeLike, current_limits: RangeLike, inductor_current_ripple: RangeLike, *,
+               output_current: RangeLike, sw_current_limits: RangeLike, *,
                efficiency: RangeLike = (0.8, 1.0),  # from TI reference
                input_voltage_ripple: FloatLike = 75*mVolt,
-               output_voltage_ripple: FloatLike = 25*mVolt):  # arbitrary
+               output_voltage_ripple: FloatLike = 25*mVolt,  # arbitrary
+               ripple_ratio: RangeLike = Range.all()):
     super().__init__()
 
     self.pwr_in = self.Port(VoltageSink.empty(), [Power])  # connected to the input cap, models input current
@@ -562,15 +657,16 @@ def __init__(self, input_voltage: RangeLike, output_voltage: RangeLike, frequenc
     self.output_voltage = self.ArgParameter(output_voltage)
     self.frequency = self.ArgParameter(frequency)
     self.output_current = self.ArgParameter(output_current)
-    self.inductor_current_ripple = self.ArgParameter(inductor_current_ripple)
-    self.current_limits = self.ArgParameter(current_limits)
+    self.sw_current_limits = self.ArgParameter(sw_current_limits)
     self.efficiency = self.ArgParameter(efficiency)
     self.input_voltage_ripple = self.ArgParameter(input_voltage_ripple)
     self.output_voltage_ripple = self.ArgParameter(output_voltage_ripple)
+    self.ripple_ratio = self.ArgParameter(ripple_ratio)  # only used to force a ripple ratio at the actual currents
+
     # duty cycle limits not supported, since the crossover point has a dutycycle of 0 (boost) and 1 (buck)
     self.generator_param(self.input_voltage, self.output_voltage, self.frequency, self.output_current,
-                         self.inductor_current_ripple, self.current_limits, self.efficiency,
-                         self.input_voltage_ripple, self.output_voltage_ripple)
+                         self.sw_current_limits, self.input_voltage_ripple, self.output_voltage_ripple,
+                         self.efficiency, self.ripple_ratio)
 
     self.actual_buck_dutycycle = self.Parameter(RangeExpr())  # possible actual duty cycle in buck mode
     self.actual_boost_dutycycle = self.Parameter(RangeExpr())  # possible actual duty cycle in boost mode
@@ -590,46 +686,49 @@ def contents(self):
 
   def generate(self) -> None:
     super().generate()
-    buck_values = BuckConverterPowerPath.calculate_parameters(
+    buck_values = BuckConverterPowerPath._calculate_parameters(
       self.get(self.input_voltage), self.get(self.output_voltage),
       self.get(self.frequency), self.get(self.output_current),
-      self.get(self.inductor_current_ripple), self.get(self.input_voltage_ripple), self.get(self.output_voltage_ripple),
+      self.get(self.sw_current_limits), self.get(self.ripple_ratio),
+      self.get(self.input_voltage_ripple), self.get(self.output_voltage_ripple),
       efficiency=self.get(self.efficiency), dutycycle_limit=Range(0, 1))
-    boost_values = BoostConverterPowerPath.calculate_parameters(
+    boost_values = BoostConverterPowerPath._calculate_parameters(
       self.get(self.input_voltage), self.get(self.output_voltage),
       self.get(self.frequency), self.get(self.output_current),
-      self.get(self.inductor_current_ripple), self.get(self.input_voltage_ripple), self.get(self.output_voltage_ripple),
+      self.get(self.sw_current_limits), self.get(self.ripple_ratio),
+      self.get(self.input_voltage_ripple), self.get(self.output_voltage_ripple),
       efficiency=self.get(self.efficiency), dutycycle_limit=Range(0, 1))
     self.assign(self.actual_buck_dutycycle, buck_values.effective_dutycycle)
     self.assign(self.actual_boost_dutycycle, boost_values.effective_dutycycle)
 
+    combined_ripple_scale = max(buck_values.ripple_scale, boost_values.ripple_scale)
+    combined_inductor_avg_current = boost_values.inductor_avg_current.hull(boost_values.inductor_avg_current)
+    combined_min_ripple = max(buck_values.min_ripple, boost_values.min_ripple)
+
     self.inductor = self.Block(Inductor(
       inductance=buck_values.inductance.intersect(boost_values.inductance) * Henry,
-      current=buck_values.inductor_peak_currents.hull(boost_values.inductor_peak_currents),
-      frequency=self.frequency
+      current=buck_values.inductor_avg_current.hull(boost_values.inductor_avg_current),
+      frequency=self.frequency,
+      experimental_filter_fn=ExperimentalUserFnPartsTable.serialize_fn(
+        BuckConverterPowerPath._buck_inductor_filter,
+        combined_inductor_avg_current.upper, combined_ripple_scale, combined_min_ripple)
     ))
-
-    # TODO deduplciate w/ ripple code in buck and boost converters
-    buck_actual_ripple = (self.output_voltage.lower() * (self.input_voltage.upper() - self.output_voltage.lower()) /
-                          (self.inductor.actual_inductance * self.frequency.lower() * self.input_voltage.upper()))
-    boost_actual_ripple = (self.input_voltage.lower() * (self.output_voltage.upper() - self.input_voltage.lower()) /
-                           (self.inductor.actual_inductance * self.frequency.lower() * self.output_voltage.lower()))
-    self.assign(self.actual_inductor_current_ripple, buck_actual_ripple.hull(boost_actual_ripple))
-
     self.connect(self.switch_in, self.inductor.a)
-
-    # full range across all modes
-    dc_current_range = self.output_current / Range((1 - boost_values.effective_dutycycle.upper), 1)
-    self.assign(self.actual_inductor_current, dc_current_range + (self.actual_inductor_current_ripple.upper() / 2))
     self.connect(self.switch_out, self.inductor.b)
-    self.assign(self.actual_avg_current_rating, (0, self.current_limits.intersect(self.inductor.actual_current_rating).upper() -
-                                                 (self.actual_inductor_current_ripple.upper() / 2)))
+    self.assign(self.actual_inductor_current_ripple, combined_ripple_scale / self.inductor.actual_inductance)
+    self.assign(self.actual_avg_current_rating,
+                BuckConverterPowerPath._ilim_expr(self.inductor.actual_current_rating, self.sw_current_limits,
+                                                  self.actual_inductor_current_ripple))
+    self.assign(self.actual_inductor_current, combined_inductor_avg_current + self.actual_inductor_current_ripple / 2)
 
     self.in_cap = self.Block(DecouplingCapacitor(
       capacitance=buck_values.input_capacitance.intersect(boost_values.input_capacitance) * Farad,
       exact_capacitance=True
     )).connected(self.gnd, self.pwr_in)
     self.out_cap = self.Block(DecouplingCapacitor(
-      capacitance=buck_values.output_capacitance.intersect(boost_values.output_capacitance) * Farad,
+      capacitance=(Range.exact(float('inf')) * Farad).hull(
+        (buck_values.output_capacitance_scale * self.actual_inductor_current_ripple.upper()).max(
+        boost_values.output_capacitance.lower)
+      ),
       exact_capacitance=True
     )).connected(self.gnd, self.pwr_out)
diff --git a/edg/abstract_parts/PartsTable.py b/edg/abstract_parts/PartsTable.py
index 387c1a67b..8fecfac3d 100644
--- a/edg/abstract_parts/PartsTable.py
+++ b/edg/abstract_parts/PartsTable.py
@@ -2,14 +2,12 @@
 
 import csv
 import itertools
-import sys
 from typing import TypeVar, Generic, Type, overload, Union, Callable, List, Dict, Any, KeysView, Optional, OrderedDict, \
-  cast
+  cast, Tuple, Sequence, Protocol
 
-if sys.version_info[1] < 8:
-  from typing_extensions import Protocol
-else:
-  from typing import Protocol
+from typing_extensions import ParamSpec
+
+from ..core import Range
 
 
 # from https://stackoverflow.com/questions/47965083/comparable-types-with-mypy
@@ -152,3 +150,90 @@ def first(self, err="no elements in list") -> PartsTableRow:
     if not self.rows:
       raise IndexError(err)
     return self.rows[0]
+
+
+UserFnMetaParams = ParamSpec('UserFnMetaParams')
+UserFnType = TypeVar('UserFnType', bound=Callable, covariant=True)
+class UserFnSerialiable(Protocol[UserFnMetaParams, UserFnType]):
+  """A protocol that marks functions as usable in deserialize, that they have been registered."""
+  _is_serializable: None  # guard attribute
+
+  def __call__(self, *args: UserFnMetaParams.args, **kwargs: UserFnMetaParams.kwargs) -> UserFnType: ...
+  __name__: str
+
+
+class ExperimentalUserFnPartsTable(PartsTable):
+  """A PartsTable that can take in a user-defined function for filtering and (possibly) other operations.
+  These functions are serialized to a string by an internal name (cannot execute arbitrary code,
+  bounded to defined functions in the codebase), and some arguments can be serialized with the name
+  (think partial(...)).
+  Functions must be pre-registered using the @ExperimentalUserFnPartsTable.user_fn(...) decorator,
+  non-pre-registered functions will not be available.
+
+  This is intended to support searches on parts tables that are cross-coupled across multiple parameters,
+  but still restricted to within on table (e.g., no cross-optimizing RC filters).
+
+  EXPERIMENTAL - subject to change without notice."""
+
+  _FN_SERIALIZATION_SEPARATOR = ";"
+
+  _user_fns: Dict[str, Tuple[Callable, Sequence[Type]]] = {}  # name -> fn, [arg types]
+  _fn_name_dict: Dict[Callable, str] = {}
+
+  @staticmethod
+  def user_fn(param_types: Sequence[Type] = []) -> Callable[[Callable[UserFnMetaParams, UserFnType]],
+      UserFnSerialiable[UserFnMetaParams, UserFnType]]:
+    def decorator(fn: Callable[UserFnMetaParams, UserFnType]) -> UserFnSerialiable[UserFnMetaParams, UserFnType]:
+      """Decorator to register a user function that can be used in ExperimentalUserFnPartsTable."""
+      if fn.__name__ in ExperimentalUserFnPartsTable._user_fns or fn in ExperimentalUserFnPartsTable._fn_name_dict:
+          raise ValueError(f"Function {fn.__name__} already registered.")
+      ExperimentalUserFnPartsTable._user_fns[fn.__name__] = (fn, param_types)
+      ExperimentalUserFnPartsTable._fn_name_dict[fn] = fn.__name__
+      return fn  # type: ignore
+    return decorator
+
+  @classmethod
+  def serialize_fn(cls, fn: UserFnSerialiable[UserFnMetaParams, UserFnType],
+                   *args: UserFnMetaParams.args, **kwargs: UserFnMetaParams.kwargs) -> str:
+    """Serializes a user function to a string."""
+    assert not kwargs, "kwargs not supported in serialization"
+    if fn not in cls._fn_name_dict:
+      raise ValueError(f"Function {fn} not registered.")
+    fn_ctor, fn_argtypes = cls._user_fns[fn.__name__]
+    def serialize_arg(tpe: Type, val: Any) -> str:
+      assert isinstance(val, tpe), f"in serialize {val}, expected {tpe}, got {type(val)}"
+      if tpe is bool:
+        return str(val)
+      elif tpe is int:
+        return str(val)
+      elif tpe is float:
+        return str(val)
+      elif tpe is Range:
+        return f"({val.lower},{val.upper})"
+      else:
+        raise TypeError(f"cannot serialize type {tpe} in user function serialization")
+    serialized_args = [serialize_arg(tpe, arg) for tpe, arg in zip(fn_argtypes, args)]
+    return cls._FN_SERIALIZATION_SEPARATOR.join([fn.__name__] + serialized_args)
+
+  @classmethod
+  def deserialize_fn(cls, serialized: str) -> Callable:
+    """Deserializes a user function from a string."""
+    split = serialized.split(cls._FN_SERIALIZATION_SEPARATOR)
+    if split[0] not in cls._user_fns:
+      raise ValueError(f"Function {serialized} not registered.")
+    fn_ctor, fn_argtypes = cls._user_fns[split[0]]
+    assert len(split) == len(fn_argtypes) + 1
+    def deserialize_arg(tpe: Type, val: str) -> Any:
+      if tpe is bool:
+        return val == 'True'
+      elif tpe is int:
+        return int(val)
+      elif tpe is float:
+        return float(val)
+      elif tpe is Range:
+        parts = val[1:-1].split(",")
+        return Range(float(parts[0]), float(parts[1]))  # type: ignore
+      else:
+        raise TypeError(f"cannot deserialize type {tpe} in user function serialization")
+    deserialized_args = [deserialize_arg(tpe, arg) for tpe, arg in zip(fn_argtypes, split[1:])]
+    return fn_ctor(*deserialized_args)
diff --git a/edg/abstract_parts/test_parts_table.py b/edg/abstract_parts/test_parts_table.py
index 4f2e18a14..6c7408748 100644
--- a/edg/abstract_parts/test_parts_table.py
+++ b/edg/abstract_parts/test_parts_table.py
@@ -75,3 +75,49 @@ def test_map(self) -> None:
 
   def test_first(self) -> None:
     self.assertEqual(self.table.first().value, {'header1': '1', 'header2': 'foo', 'header3': '9'})
+
+
+class UserFnPartsTableTest(unittest.TestCase):
+  @staticmethod
+  @ExperimentalUserFnPartsTable.user_fn()
+  def user_fn_false() -> Callable[[], bool]:
+    def inner() -> bool:
+      return False
+    return inner
+
+  @staticmethod
+  @ExperimentalUserFnPartsTable.user_fn([bool])
+  def user_fn_bool_pass(meta_arg: bool) -> Callable[[], bool]:
+    def inner() -> bool:
+      return meta_arg
+    return inner
+
+  @staticmethod
+  @ExperimentalUserFnPartsTable.user_fn([float])
+  def user_fn_float_pass(meta_arg: float) -> Callable[[], float]:
+    def inner() -> float:
+      return meta_arg
+    return inner
+
+  @staticmethod
+  def user_fn_unserialized() -> Callable[[], None]:
+    def inner() -> None:
+      return None
+    return inner
+
+  def test_serialize_deserialize(self) -> None:
+    self.assertEqual(ExperimentalUserFnPartsTable.serialize_fn(self.user_fn_false), 'user_fn_false')
+    self.assertEqual(ExperimentalUserFnPartsTable.deserialize_fn(
+      ExperimentalUserFnPartsTable.serialize_fn(self.user_fn_false))(), False)
+
+    self.assertEqual(ExperimentalUserFnPartsTable.serialize_fn(self.user_fn_bool_pass, False),
+                     'user_fn_bool_pass;False')
+    self.assertEqual(ExperimentalUserFnPartsTable.deserialize_fn(
+      ExperimentalUserFnPartsTable.serialize_fn(self.user_fn_bool_pass, False))(), False)
+    self.assertEqual(ExperimentalUserFnPartsTable.deserialize_fn(
+      ExperimentalUserFnPartsTable.serialize_fn(self.user_fn_bool_pass, True))(), True)
+
+    self.assertEqual(ExperimentalUserFnPartsTable.serialize_fn(self.user_fn_float_pass, 0.42),
+                     'user_fn_float_pass;0.42')
+    self.assertEqual(ExperimentalUserFnPartsTable.deserialize_fn(
+      ExperimentalUserFnPartsTable.serialize_fn(self.user_fn_float_pass, 0.42))(), 0.42)
diff --git a/edg/abstract_parts/test_switching_converters.py b/edg/abstract_parts/test_switching_converters.py
index b490594e2..a399f7802 100644
--- a/edg/abstract_parts/test_switching_converters.py
+++ b/edg/abstract_parts/test_switching_converters.py
@@ -4,11 +4,11 @@
 from ..core import Range
 
 
-class BuckConverterCalculationTest(unittest.TestCase):
+class SwitchingConverterCalculationTest(unittest.TestCase):
     def test_buck_converter(self):
-        values_ref = BuckConverterPowerPath.calculate_parameters(
+        values_ref = BuckConverterPowerPath._calculate_parameters(
             Range.exact(5), Range.exact(2.5), Range.exact(100e3), Range.exact(1),
-            Range.exact(0.1), 0.01, 0.001,
+            Range.exact(1), Range.exact(0.1), 0.01, 0.001,
             efficiency=Range.exact(1)
         )
         self.assertEqual(values_ref.dutycycle, Range.exact(0.5))
@@ -16,9 +16,9 @@ def test_buck_converter(self):
         self.assertEqual(values_ref.inductance, Range.exact(125e-6))
 
         # test that component values are calculated for worst-case conversion
-        values = BuckConverterPowerPath.calculate_parameters(
+        values = BuckConverterPowerPath._calculate_parameters(
             Range(4, 5), Range(2.5, 4), Range.exact(100e3), Range.exact(1),
-            Range.exact(0.1), 0.01, 0.001,
+            Range.exact(1), Range.exact(0.1), 0.01, 0.001,
             efficiency=Range.exact(1)
         )
         self.assertEqual(values_ref.inductance, values.inductance)
@@ -27,37 +27,38 @@ def test_buck_converter(self):
 
     def test_buck_converter_example(self):
         # using the example from https://passive-components.eu/buck-converter-design-and-calculation/
-        values = BuckConverterPowerPath.calculate_parameters(
+        values = BuckConverterPowerPath._calculate_parameters(
             Range.exact(12 + 0.4), Range.exact(3.3 + 0.4), Range.exact(500e3), Range.exact(1),
-            Range.exact(0.35), 1, 0.0165,
+            Range.exact(2), Range.exact(0.35), 1, 0.0165,
             efficiency=Range.exact(1)
         )
         self.assertAlmostEqual(values.dutycycle.upper, 0.298, places=3)
         self.assertAlmostEqual(values.inductance.upper, 14.8e-6, places=7)
 
         # the example uses a ripple current of 0.346 for the rest of the calculations
-        values = BuckConverterPowerPath.calculate_parameters(
+        values = BuckConverterPowerPath._calculate_parameters(
             Range.exact(12 + 0.4), Range.exact(3.3 + 0.4), Range.exact(500e3), Range.exact(1),
-            Range.exact(0.346), 1, 0.0165,
+            Range.exact(2), Range.exact(0.346), 1, 0.0165,
             efficiency=Range.exact(1)
         )
         self.assertAlmostEqual(values.inductor_peak_currents.upper, 1.173, places=3)
         self.assertAlmostEqual(values.output_capacitance.lower, 5.24e-6, places=7)
 
     def test_boost_converter(self):
-        values_ref = BoostConverterPowerPath.calculate_parameters(
-            Range.exact(5), Range.exact(10), Range.exact(100e3), Range.exact(1),
-            Range.exact(0.1), 0.01, 0.001,
+        values_ref = BoostConverterPowerPath._calculate_parameters(
+            Range.exact(5), Range.exact(10), Range.exact(100e3), Range.exact(0.5),
+            Range.exact(2), Range.exact(0.4), 0.01, 0.001,
             efficiency=Range.exact(1)
         )
         self.assertEqual(values_ref.dutycycle, Range.exact(0.5))
         # validated against https://www.omnicalculator.com/physics/boost-converter
-        self.assertEqual(values_ref.inductance, Range.exact(250e-6))
+        self.assertEqual(values_ref.inductance, Range.exact(62.5e-6))
+        self.assertEqual(values_ref.inductor_avg_current, Range.exact(1))
 
         # test that component values are calculated for worst-case conversion
-        values = BoostConverterPowerPath.calculate_parameters(
-            Range(5, 8), Range(7, 10), Range.exact(100e3), Range.exact(1),
-            Range.exact(0.1), 0.01, 0.001,
+        values = BoostConverterPowerPath._calculate_parameters(
+            Range(5, 8), Range(7, 10), Range.exact(100e3), Range.exact(0.5),
+            Range.exact(2), Range.exact(0.4), 0.01, 0.001,
             efficiency=Range.exact(1)
         )
         self.assertEqual(values_ref.inductance, values.inductance)
@@ -66,19 +67,19 @@ def test_boost_converter(self):
 
     def test_boost_converter_example(self):
         # using the example from https://passive-components.eu/boost-converter-design-and-calculation/
-        # 0.4342A ripple current from .35 factor in example converted in output current terms
-        values = BoostConverterPowerPath.calculate_parameters(
+        values = BoostConverterPowerPath._calculate_parameters(
             Range.exact(5), Range.exact(12 + 0.4), Range.exact(500e3), Range.exact(0.5),
-            Range.exact(0.4342), 1, 1,
+            Range.exact(2), Range.exact(0.35), 1, 1,
             efficiency=Range.exact(1)
         )
         self.assertAlmostEqual(values.dutycycle.upper, 0.597, places=3)
         self.assertAlmostEqual(values.inductance.upper, 13.75e-6, places=7)
+        self.assertAlmostEqual(values.inductor_avg_current.upper, 1.24, places=2)
 
         # the example continues with a normalized inductance of 15uH
-        values = BoostConverterPowerPath.calculate_parameters(
+        values = BoostConverterPowerPath._calculate_parameters(
             Range.exact(5), Range.exact(12 + 0.4), Range.exact(500e3), Range.exact(0.5),
-            Range.exact(.4342*13.75/15), 0.01, 0.06,
+            Range.exact(2), Range.exact(0.321), 0.01, 0.06,
             efficiency=Range.exact(1)
         )
         self.assertAlmostEqual(values.dutycycle.upper, 0.597, places=3)
diff --git a/edg/core/ConstraintExpr.py b/edg/core/ConstraintExpr.py
index c89a475e2..c370e932b 100644
--- a/edg/core/ConstraintExpr.py
+++ b/edg/core/ConstraintExpr.py
@@ -26,6 +26,8 @@ class ConstraintExpr(Refable, Generic[WrappedType, CastableType]):
   """Base class for constraint expressions. Basically a container for operations.
   Actual meaning is held in the Binding.
   """
+  _CASTABLE_TYPES: Tuple[Type[CastableType], ...]  # for use in ininstance(), excluding self-cls
+
   def __repr__(self) -> str:
     if self.binding is not None and self.initializer is not None:
       return f"{super().__repr__()}({self.binding})={self.initializer}"
@@ -101,6 +103,9 @@ def __eq__(self: SelfType, other: ConstraintExprCastable) -> BoolExpr:  #type: i
 BoolLike = Union[bool, 'BoolExpr']
 class BoolExpr(ConstraintExpr[bool, BoolLike]):
   """Boolean expression, can be used as a constraint"""
+
+  _CASTABLE_TYPES = (bool, )
+
   @classmethod
   def _to_expr_type(cls, input: BoolLike) -> BoolExpr:
     if isinstance(input, BoolExpr):
@@ -159,11 +164,23 @@ def implies(self, target: BoolLike) -> BoolExpr:
   def __invert__(self) -> BoolExpr:
     return self._new_bind(UnaryOpBinding(self, BoolOp.op_not))
 
-
+  # does not seem possible to restrict type-params of type vars pre-Python3.12
+  # so where a single cast is needed we're stuck with Any
   IteType = TypeVar('IteType', bound=ConstraintExpr)
-  def then_else(self, then_val: IteType, else_val: IteType) -> IteType:
-    assert isinstance(then_val, type(else_val)) and isinstance(else_val, type(then_val)), \
-        f"if-then-else results must be of same type, got then={then_val}, else={else_val}"
+  @overload
+  def then_else(self, then_val: IteType, else_val: IteType) -> IteType: ...  # optional strongest-typed version
+  @overload
+  def then_else(self, then_val: IteType, else_val: Any) -> IteType: ...
+  @overload
+  def then_else(self, then_val: Any, else_val: IteType) -> IteType: ...
+
+  def then_else(self, then_val: Any, else_val: Any) -> ConstraintExpr:  # type: ignore
+    if isinstance(then_val, ConstraintExpr):
+      else_val = then_val._to_expr_type(else_val)
+    elif isinstance(else_val, ConstraintExpr):
+      then_val = else_val._to_expr_type(then_val)
+    else:
+      raise ValueError("either then_val or else_val must be ConstraintExpr, TODO support dual-casting")
     assert self._is_bound() and then_val._is_bound() and else_val._is_bound()
     return then_val._new_bind(IfThenElseBinding(self, then_val, else_val))
 
@@ -173,8 +190,6 @@ def then_else(self, then_val: IteType, else_val: IteType) -> IteType:
 class NumLikeExpr(ConstraintExpr[WrappedType, NumLikeCastable], Generic[WrappedType, NumLikeCastable]):
   """Trait for numeric-like expressions, providing common arithmetic operations"""
 
-  _CASTABLE_TYPES: Tuple[Type[NumLikeCastable], ...]  # NumLikeCastable for use in ininstance(), excluding self-cls
-
   @classmethod
   @abstractmethod
   def _to_expr_type(cls: Type[NumLikeSelfType],
@@ -479,6 +494,9 @@ def abs(self) -> RangeExpr:
 StringLike = Union['StringExpr', str]
 class StringExpr(ConstraintExpr[str, StringLike]):
   """String expression, can be used as a constraint"""
+
+  _CASTABLE_TYPES = (str, )
+
   @classmethod
   def _to_expr_type(cls, input: StringLike) -> StringExpr:
     if isinstance(input, StringExpr):
@@ -596,7 +614,8 @@ def __rmul__(self, other: Union[float, Range, Tuple[float, float]]) -> Union[Flo
       return FloatExpr._to_expr_type(other * self.scale)
     elif isinstance(other, Range):
       return RangeExpr._to_expr_type(other * self.scale)
-    elif isinstance(other, tuple) and isinstance(other[0], (int, float)) and isinstance(other[1], (int, float)):
-      return RangeExpr._to_expr_type(Range(other[0], other[1]) * self.scale)
+    elif isinstance(other, tuple) and isinstance(other[0], (int, float, IntExpr, FloatExpr)) \
+            and isinstance(other[1], (int, float, IntExpr, FloatExpr)):
+      return RangeExpr._to_expr_type((other[0] * self.scale, other[1] * self.scale))
     else:
       raise TypeError(f"expected Float or Range Literal, got {other} of type {type(other)}")
diff --git a/edg/parts/BoostConverter_AnalogDevices.py b/edg/parts/BoostConverter_AnalogDevices.py
index 45f55bd0e..869d4ab23 100644
--- a/edg/parts/BoostConverter_AnalogDevices.py
+++ b/edg/parts/BoostConverter_AnalogDevices.py
@@ -71,11 +71,8 @@ def contents(self):
       self.power_path = imp.Block(BoostConverterPowerPath(
         self.pwr_in.link().voltage, self.fb.actual_input_voltage, self.actual_frequency,
         self.pwr_out.link().current_drawn, (0, self.NMOS_CURRENT_LIMIT)*Amp,
-        inductor_current_ripple=self._calculate_ripple(self.pwr_out.link().current_drawn,
-                                                       self.ripple_current_factor,
-                                                       rated_current=self.NMOS_CURRENT_LIMIT*Amp),
         input_voltage_ripple=self.input_ripple_limit,
-        output_voltage_ripple=self.output_ripple_limit
+        output_voltage_ripple=self.output_ripple_limit,
       ))
       self.connect(self.power_path.pwr_out, self.pwr_out)
       self.connect(self.power_path.switch, self.ic.sw)
diff --git a/edg/parts/BoostConverter_DiodesInc.py b/edg/parts/BoostConverter_DiodesInc.py
index 99fc787c9..c381f6074 100644
--- a/edg/parts/BoostConverter_DiodesInc.py
+++ b/edg/parts/BoostConverter_DiodesInc.py
@@ -66,11 +66,8 @@ def contents(self):
       self.power_path = imp.Block(BoostConverterPowerPath(
         self.pwr_in.link().voltage, self.fb.actual_input_voltage, self.actual_frequency,
         self.pwr_out.link().current_drawn, (0, 0.5)*Amp,
-        inductor_current_ripple=self._calculate_ripple(self.pwr_out.link().current_drawn,
-                                                       self.ripple_current_factor,
-                                                       rated_current=0.5*Amp),
         input_voltage_ripple=self.input_ripple_limit,
-        output_voltage_ripple=self.output_ripple_limit
+        output_voltage_ripple=self.output_ripple_limit,
       ))
       self.connect(self.power_path.pwr_out, self.pwr_out)
       self.connect(self.power_path.switch, self.ic.sw)
diff --git a/edg/parts/BoostConverter_TexasInstruments.py b/edg/parts/BoostConverter_TexasInstruments.py
index b81f92c72..b18d87dfd 100644
--- a/edg/parts/BoostConverter_TexasInstruments.py
+++ b/edg/parts/BoostConverter_TexasInstruments.py
@@ -222,11 +222,8 @@ def contents(self):
       self.power_path = imp.Block(BoostConverterPowerPath(
         self.pwr_in.link().voltage, self.fb.actual_input_voltage, self.actual_frequency,
         self.pwr_out.link().current_drawn, (0, 1)*Amp,
-        inductor_current_ripple=self._calculate_ripple(self.pwr_out.link().current_drawn,
-                                                       self.ripple_current_factor,
-                                                       rated_current=0.5*Amp),
         input_voltage_ripple=self.input_ripple_limit,
-        output_voltage_ripple=self.output_ripple_limit
+        output_voltage_ripple=self.output_ripple_limit,
       ))
       self.connect(self.power_path.pwr_out, self.pwr_out)
       self.connect(self.power_path.switch, self.ic.sw)
diff --git a/edg/parts/BoostConverter_Torex.py b/edg/parts/BoostConverter_Torex.py
index f908bbe6a..f623e7cc8 100644
--- a/edg/parts/BoostConverter_Torex.py
+++ b/edg/parts/BoostConverter_Torex.py
@@ -2,7 +2,7 @@
 
 
 class Xc9142_Device(InternalSubcircuit, FootprintBlock, GeneratorBlock):
-  parts_output_voltage_current = [  # from Table 2, Vout and Ilim
+  parts_output_voltage_current = [  # from Table 2, Vout and Ilim (min/typ, max)
     ('18', Range(1.764, 1.836), Range(0.96, 2.30)),
     ('25', Range(2.450, 2.550), Range(1.19, 2.30)),
     ('30', Range(2.940, 3.060), Range(0.96, 2.30)),
@@ -89,11 +89,8 @@ def contents(self):
       self.power_path = imp.Block(BoostConverterPowerPath(
         self.pwr_in.link().voltage, self.ic.vout.voltage_out, self.actual_frequency,
         self.pwr_out.link().current_drawn, self.ic.actual_current_limit,
-        inductor_current_ripple=self._calculate_ripple(self.pwr_out.link().current_drawn,
-                                                       self.ripple_current_factor,
-                                                       rated_current=self.ic.actual_current_limit.lower()),
         input_voltage_ripple=self.input_ripple_limit,
-        output_voltage_ripple=self.output_ripple_limit
+        output_voltage_ripple=self.output_ripple_limit,
       ))
       self.connect(self.power_path.pwr_out, self.pwr_out)
       self.connect(self.power_path.switch, self.ic.sw)
diff --git a/edg/parts/BuckBoostConverter_Custom.py b/edg/parts/BuckBoostConverter_Custom.py
index 61214ca6f..306148ccd 100644
--- a/edg/parts/BuckBoostConverter_Custom.py
+++ b/edg/parts/BuckBoostConverter_Custom.py
@@ -25,6 +25,7 @@ class CustomSyncBuckBoostConverterPwm(DiscreteBoostConverter, Resettable):
   @init_in_parent
   def __init__(self, *args,
                frequency: RangeLike = (100, 1000)*kHertz,
+               ripple_ratio: RangeLike = (0.2, 0.5),
                voltage_drop: RangeLike = (0, 1)*Volt, rds_on: RangeLike = (0, 1.0)*Ohm,
                **kwargs):
     super().__init__(*args, **kwargs)
@@ -34,6 +35,7 @@ def __init__(self, *args,
     self.boost_pwm = self.Port(DigitalSink.empty())
 
     self.frequency = self.ArgParameter(frequency)
+    self.ripple_ratio = self.ArgParameter(ripple_ratio)
     self.voltage_drop = self.ArgParameter(voltage_drop)
     self.rds_on = self.ArgParameter(rds_on)
 
@@ -43,12 +45,10 @@ def contents(self):
     self.assign(self.actual_frequency, self.frequency)
     self.power_path = self.Block(BuckBoostConverterPowerPath(
       self.pwr_in.link().voltage, self.output_voltage, self.actual_frequency,
-      self.pwr_out.link().current_drawn, Range.all(),  # TODO model current limits from FETs
-      inductor_current_ripple=self._calculate_ripple(self.pwr_out.link().current_drawn,
-                                                     self.ripple_current_factor,
-                                                     rated_current=self.pwr_out.link().current_drawn.upper()),
+      self.pwr_out.link().current_drawn, Range.exact(0),
       input_voltage_ripple=self.input_ripple_limit,
-      output_voltage_ripple=self.output_ripple_limit
+      output_voltage_ripple=self.output_ripple_limit,
+      ripple_ratio=self.ripple_ratio,
     ))
     self.connect(self.power_path.pwr_in, self.pwr_in)
     self.connect(self.power_path.pwr_out, self.pwr_out)
diff --git a/edg/parts/BuckConverter_Ap3418.py b/edg/parts/BuckConverter_Ap3418.py
index 7da222b1f..75eb46f2c 100644
--- a/edg/parts/BuckConverter_Ap3418.py
+++ b/edg/parts/BuckConverter_Ap3418.py
@@ -64,11 +64,7 @@ def contents(self):
       # TODO: the control mechanism requires a specific capacitor / inductor selection, datasheet 8.2.2.3
       self.power_path = imp.Block(BuckConverterPowerPath(
         self.pwr_in.link().voltage, self.fb.actual_input_voltage, self.actual_frequency,
-        self.pwr_out.link().current_drawn, (0, 1.5)*Amp,
-        inductor_current_ripple=self._calculate_ripple(
-          self.pwr_out.link().current_drawn,
-          self.ripple_current_factor,
-          rated_current=1.5*Amp),
+        self.pwr_out.link().current_drawn, (0, 1.8)*Amp,
         input_voltage_ripple=self.input_ripple_limit,
         output_voltage_ripple=self.output_ripple_limit,
         dutycycle_limit=(0, 1)
diff --git a/edg/parts/BuckConverter_Custom.py b/edg/parts/BuckConverter_Custom.py
index 912e5c752..026153d01 100644
--- a/edg/parts/BuckConverter_Custom.py
+++ b/edg/parts/BuckConverter_Custom.py
@@ -7,6 +7,7 @@ class CustomSyncBuckConverterIndependent(DiscreteBoostConverter):
     @init_in_parent
     def __init__(self, *args,
                  frequency: RangeLike = (100, 1000)*kHertz,
+                 ripple_ratio: RangeLike = (0.2, 0.5),
                  voltage_drop: RangeLike = (0, 1)*Volt, rds_on: RangeLike = (0, 1.0)*Ohm,
                  **kwargs):
         super().__init__(*args, **kwargs)
@@ -16,6 +17,7 @@ def __init__(self, *args,
         self.pwm_high = self.Port(DigitalSink.empty())
 
         self.frequency = self.ArgParameter(frequency)
+        self.ripple_ratio = self.ArgParameter(ripple_ratio)
         self.voltage_drop = self.ArgParameter(voltage_drop)
         self.rds_on = self.ArgParameter(rds_on)
 
@@ -25,13 +27,10 @@ def contents(self):
         self.assign(self.actual_frequency, self.frequency)
         self.power_path = self.Block(BuckConverterPowerPath(
             self.pwr_in.link().voltage, self.output_voltage, self.actual_frequency,
-            self.pwr_out.link().current_drawn, Range.all(),  # TODO model current limits from FETs
-            inductor_current_ripple=self._calculate_ripple(self.pwr_out.link().current_drawn,
-                                                           self.ripple_current_factor,
-                                                           rated_current=self.pwr_out.link().current_drawn.upper()),
+            self.pwr_out.link().current_drawn, Range.exact(0),
             input_voltage_ripple=self.input_ripple_limit,
             output_voltage_ripple=self.output_ripple_limit,
-            dutycycle_limit=(0, 1)
+            ripple_ratio=self.ripple_ratio
         ))
         self.connect(self.power_path.pwr_in, self.pwr_in)
         self.connect(self.power_path.pwr_out, self.pwr_out)
diff --git a/edg/parts/BuckConverter_TexasInstruments.py b/edg/parts/BuckConverter_TexasInstruments.py
index 337c4c51e..22f6d935e 100644
--- a/edg/parts/BuckConverter_TexasInstruments.py
+++ b/edg/parts/BuckConverter_TexasInstruments.py
@@ -71,10 +71,7 @@ def contents(self):
       # TODO: the control mechanism requires a specific capacitor / inductor selection, datasheet 8.2.2.3
       self.power_path = imp.Block(BuckConverterPowerPath(
         self.pwr_in.link().voltage, self.fb.actual_input_voltage, self.actual_frequency,
-        self.pwr_out.link().current_drawn, (0, 1.2)*Amp,
-        inductor_current_ripple=self._calculate_ripple(self.pwr_out.link().current_drawn,
-                                                       self.ripple_current_factor,
-                                                       rated_current=1.2*Amp),
+        self.pwr_out.link().current_drawn, (0, 1.2)*Amp,  # output current limit, switch limit not given
         input_voltage_ripple=self.input_ripple_limit,
         output_voltage_ripple=self.output_ripple_limit,
       ))
@@ -157,10 +154,7 @@ def contents(self):
 
       self.power_path = imp.Block(BuckConverterPowerPath(
         self.pwr_in.link().voltage, self.fb.actual_input_voltage, self.actual_frequency,
-        self.pwr_out.link().current_drawn, (0, 2)*Amp,
-        inductor_current_ripple=self._calculate_ripple(self.pwr_out.link().current_drawn,
-                                                       self.ripple_current_factor,
-                                                       rated_current=2*Amp),
+        self.pwr_out.link().current_drawn, (0, 2.5)*Amp,
         input_voltage_ripple=self.input_ripple_limit,
         output_voltage_ripple=self.output_ripple_limit,
       ))
diff --git a/examples/Fcml/Fcml.net b/examples/Fcml/Fcml.net
index 46788cced..63bc35380 100644
--- a/examples/Fcml/Fcml.net
+++ b/examples/Fcml/Fcml.net
@@ -221,14 +221,14 @@
   (sheetpath (names "/reg_vgate/fb/") (tstamps "/129803b5/013000c9/"))
   (tstamps "175b043f"))
 (comp (ref "reg_vgate.power_path.inductor")
-  (value "500mA 33uH ±10% 410mΩ 1210 Inductors (SMD) ROHS")
-  (footprint "Inductor_SMD:L_1210_3225Metric")
+  (value "530mA 22uH ±20% 839mΩ SMD Power Inductors ROHS")
+  (footprint "Inductor_SMD:L_Sunlord_SWPA3012S")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BoostConverterPowerPath"))
   (property (name "edg_path") (value "reg_vgate.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_vgate.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "CBC3225T330KR (Taiyo Yuden)"))
+  (property (name "edg_part") (value "SWPA3012S220MT (Sunlord)"))
   (sheetpath (names "/reg_vgate/power_path/") (tstamps "/129803b5/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg_vgate.power_path.in_cap")
@@ -276,14 +276,14 @@
   (sheetpath (names "/") (tstamps "/"))
   (tstamps "0f4c035b"))
 (comp (ref "conv.power_path.inductor")
-  (value "4.1A 4.7uH ±30% 23.4mΩ SMD,8x8x4.2mm Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Taiyo-Yuden_NR-80xx")
+  (value "5.4A 10uH ±20% 21mΩ SMD Power Inductors ROHS")
+  (footprint "Inductor_SMD:L_Sunlord_SWRB1207S")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "examples.test_fcml.FcmlPowerPath"))
   (property (name "edg_path") (value "conv.power_path.inductor"))
   (property (name "edg_short_path") (value "conv.power_path.inductor"))
   (property (name "edg_refdes") (value "L2"))
-  (property (name "edg_part") (value "NR8040T4R7N (Taiyo Yuden)"))
+  (property (name "edg_part") (value "SWRB1207S-100MT (Sunlord)"))
   (sheetpath (names "/conv/power_path/") (tstamps "/042f01b7/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "conv.power_path.in_cap.c[0]")
@@ -374,17 +374,6 @@
   (property (name "edg_part") (value "CL31A226KPHNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/power_path/out_cap/") (tstamps "/042f01b7/1786043a/0be902ec/"))
   (tstamps "0362014e"))
-(comp (ref "conv.power_path.out_cap.c[3]")
-  (value "10V 22uF X5R ±10% 1206 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
-  (footprint "Capacitor_SMD:C_1206_3216Metric")
-  (property (name "Sheetname") (value "out_cap"))
-  (property (name "Sheetfile") (value "edg.abstract_parts.AbstractCapacitor.DecouplingCapacitor"))
-  (property (name "edg_path") (value "conv.power_path.out_cap.cap.c[3]"))
-  (property (name "edg_short_path") (value "conv.power_path.out_cap.c[3]"))
-  (property (name "edg_refdes") (value "C13"))
-  (property (name "edg_part") (value "CL31A226KPHNNNE (Samsung Electro-Mechanics)"))
-  (sheetpath (names "/conv/power_path/out_cap/") (tstamps "/042f01b7/1786043a/0be902ec/"))
-  (tstamps "0364014f"))
 (comp (ref "conv.sw[0].driver.ic")
   (value "IR2301")
   (footprint "Package_SO:SOIC-8_3.9x4.9mm_P1.27mm")
@@ -403,7 +392,7 @@
   (property (name "Sheetfile") (value "edg.parts.GateDriver_Ir2301.Ir2301"))
   (property (name "edg_path") (value "conv.sw[0].driver.cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[0].driver.cap"))
-  (property (name "edg_refdes") (value "C14"))
+  (property (name "edg_refdes") (value "C13"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[0]/driver/") (tstamps "/042f01b7/05ee01d3/08da028d/"))
   (tstamps "025e0135"))
@@ -414,7 +403,7 @@
   (property (name "Sheetfile") (value "edg.parts.GateDriver_Ir2301.Ir2301"))
   (property (name "edg_path") (value "conv.sw[0].driver.high_cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[0].driver.high_cap"))
-  (property (name "edg_refdes") (value "C15"))
+  (property (name "edg_refdes") (value "C14"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[0]/driver/") (tstamps "/042f01b7/05ee01d3/08da028d/"))
   (tstamps "0e700334"))
@@ -469,7 +458,7 @@
   (property (name "Sheetfile") (value "examples.test_fcml.MultilevelSwitchingCell"))
   (property (name "edg_path") (value "conv.sw[0].high_boot_cap"))
   (property (name "edg_short_path") (value "conv.sw[0].high_boot_cap"))
-  (property (name "edg_refdes") (value "C16"))
+  (property (name "edg_refdes") (value "C15"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[0]/") (tstamps "/042f01b7/05ee01d3/"))
   (tstamps "24e30547"))
@@ -502,7 +491,7 @@
   (property (name "Sheetfile") (value "edg.parts.LinearRegulators.Ap2204k"))
   (property (name "edg_path") (value "conv.sw[1].ldo.in_cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[1].ldo.in_cap"))
-  (property (name "edg_refdes") (value "C17"))
+  (property (name "edg_refdes") (value "C16"))
   (property (name "edg_part") (value "CL10A105KB8NNNC (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/sw[1]/ldo/") (tstamps "/042f01b7/05f001d4/027e0140/"))
   (tstamps "0879026b"))
@@ -513,7 +502,7 @@
   (property (name "Sheetfile") (value "edg.parts.LinearRegulators.Ap2204k"))
   (property (name "edg_path") (value "conv.sw[1].ldo.out_cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[1].ldo.out_cap"))
-  (property (name "edg_refdes") (value "C18"))
+  (property (name "edg_refdes") (value "C17"))
   (property (name "edg_part") (value "CL31B225KBHNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/sw[1]/ldo/") (tstamps "/042f01b7/05f001d4/027e0140/"))
   (tstamps "0be902ec"))
@@ -535,7 +524,7 @@
   (property (name "Sheetfile") (value "edg.parts.Isolator_Cbmud1200.Cbmud1200l"))
   (property (name "edg_path") (value "conv.sw[1].iso.cap_a.cap"))
   (property (name "edg_short_path") (value "conv.sw[1].iso.cap_a"))
-  (property (name "edg_refdes") (value "C19"))
+  (property (name "edg_refdes") (value "C18"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[1]/iso/") (tstamps "/042f01b7/05f001d4/0293014c/"))
   (tstamps "05e701f5"))
@@ -546,7 +535,7 @@
   (property (name "Sheetfile") (value "edg.parts.Isolator_Cbmud1200.Cbmud1200l"))
   (property (name "edg_path") (value "conv.sw[1].iso.cap_b.cap"))
   (property (name "edg_short_path") (value "conv.sw[1].iso.cap_b"))
-  (property (name "edg_refdes") (value "C20"))
+  (property (name "edg_refdes") (value "C19"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[1]/iso/") (tstamps "/042f01b7/05f001d4/0293014c/"))
   (tstamps "05e801f6"))
@@ -568,7 +557,7 @@
   (property (name "Sheetfile") (value "edg.parts.GateDriver_Ir2301.Ir2301"))
   (property (name "edg_path") (value "conv.sw[1].driver.cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[1].driver.cap"))
-  (property (name "edg_refdes") (value "C21"))
+  (property (name "edg_refdes") (value "C20"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[1]/driver/") (tstamps "/042f01b7/05f001d4/08da028d/"))
   (tstamps "025e0135"))
@@ -579,7 +568,7 @@
   (property (name "Sheetfile") (value "edg.parts.GateDriver_Ir2301.Ir2301"))
   (property (name "edg_path") (value "conv.sw[1].driver.high_cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[1].driver.high_cap"))
-  (property (name "edg_refdes") (value "C22"))
+  (property (name "edg_refdes") (value "C21"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[1]/driver/") (tstamps "/042f01b7/05f001d4/08da028d/"))
   (tstamps "0e700334"))
@@ -601,7 +590,7 @@
   (property (name "Sheetfile") (value "edg.parts.JlcCapacitor.JlcCapacitor"))
   (property (name "edg_path") (value "conv.sw[1].cap.c[0]"))
   (property (name "edg_short_path") (value "conv.sw[1].cap.c[0]"))
-  (property (name "edg_refdes") (value "C23"))
+  (property (name "edg_refdes") (value "C22"))
   (property (name "edg_part") (value "CL31A226KAHNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/sw[1]/cap/") (tstamps "/042f01b7/05f001d4/025e0135/"))
   (tstamps "035e014c"))
@@ -612,7 +601,7 @@
   (property (name "Sheetfile") (value "edg.parts.JlcCapacitor.JlcCapacitor"))
   (property (name "edg_path") (value "conv.sw[1].cap.c[1]"))
   (property (name "edg_short_path") (value "conv.sw[1].cap.c[1]"))
-  (property (name "edg_refdes") (value "C24"))
+  (property (name "edg_refdes") (value "C23"))
   (property (name "edg_part") (value "CL31A226KAHNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/sw[1]/cap/") (tstamps "/042f01b7/05f001d4/025e0135/"))
   (tstamps "0360014d"))
@@ -667,7 +656,7 @@
   (property (name "Sheetfile") (value "examples.test_fcml.MultilevelSwitchingCell"))
   (property (name "edg_path") (value "conv.sw[1].high_boot_cap"))
   (property (name "edg_short_path") (value "conv.sw[1].high_boot_cap"))
-  (property (name "edg_refdes") (value "C25"))
+  (property (name "edg_refdes") (value "C24"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[1]/") (tstamps "/042f01b7/05f001d4/"))
   (tstamps "24e30547"))
@@ -678,7 +667,7 @@
   (property (name "Sheetfile") (value "examples.test_fcml.MultilevelSwitchingCell"))
   (property (name "edg_path") (value "conv.sw[1].low_boot_cap"))
   (property (name "edg_short_path") (value "conv.sw[1].low_boot_cap"))
-  (property (name "edg_refdes") (value "C26"))
+  (property (name "edg_refdes") (value "C25"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[1]/") (tstamps "/042f01b7/05f001d4/"))
   (tstamps "20ac04f9"))
@@ -711,7 +700,7 @@
   (property (name "Sheetfile") (value "edg.parts.LinearRegulators.Ap2204k"))
   (property (name "edg_path") (value "conv.sw[2].ldo.in_cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[2].ldo.in_cap"))
-  (property (name "edg_refdes") (value "C27"))
+  (property (name "edg_refdes") (value "C26"))
   (property (name "edg_part") (value "CL10A105KB8NNNC (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/sw[2]/ldo/") (tstamps "/042f01b7/05f201d5/027e0140/"))
   (tstamps "0879026b"))
@@ -722,7 +711,7 @@
   (property (name "Sheetfile") (value "edg.parts.LinearRegulators.Ap2204k"))
   (property (name "edg_path") (value "conv.sw[2].ldo.out_cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[2].ldo.out_cap"))
-  (property (name "edg_refdes") (value "C28"))
+  (property (name "edg_refdes") (value "C27"))
   (property (name "edg_part") (value "CL31B225KBHNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/sw[2]/ldo/") (tstamps "/042f01b7/05f201d5/027e0140/"))
   (tstamps "0be902ec"))
@@ -744,7 +733,7 @@
   (property (name "Sheetfile") (value "edg.parts.Isolator_Cbmud1200.Cbmud1200l"))
   (property (name "edg_path") (value "conv.sw[2].iso.cap_a.cap"))
   (property (name "edg_short_path") (value "conv.sw[2].iso.cap_a"))
-  (property (name "edg_refdes") (value "C29"))
+  (property (name "edg_refdes") (value "C28"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[2]/iso/") (tstamps "/042f01b7/05f201d5/0293014c/"))
   (tstamps "05e701f5"))
@@ -755,7 +744,7 @@
   (property (name "Sheetfile") (value "edg.parts.Isolator_Cbmud1200.Cbmud1200l"))
   (property (name "edg_path") (value "conv.sw[2].iso.cap_b.cap"))
   (property (name "edg_short_path") (value "conv.sw[2].iso.cap_b"))
-  (property (name "edg_refdes") (value "C30"))
+  (property (name "edg_refdes") (value "C29"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[2]/iso/") (tstamps "/042f01b7/05f201d5/0293014c/"))
   (tstamps "05e801f6"))
@@ -777,7 +766,7 @@
   (property (name "Sheetfile") (value "edg.parts.GateDriver_Ir2301.Ir2301"))
   (property (name "edg_path") (value "conv.sw[2].driver.cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[2].driver.cap"))
-  (property (name "edg_refdes") (value "C31"))
+  (property (name "edg_refdes") (value "C30"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[2]/driver/") (tstamps "/042f01b7/05f201d5/08da028d/"))
   (tstamps "025e0135"))
@@ -788,7 +777,7 @@
   (property (name "Sheetfile") (value "edg.parts.GateDriver_Ir2301.Ir2301"))
   (property (name "edg_path") (value "conv.sw[2].driver.high_cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[2].driver.high_cap"))
-  (property (name "edg_refdes") (value "C32"))
+  (property (name "edg_refdes") (value "C31"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[2]/driver/") (tstamps "/042f01b7/05f201d5/08da028d/"))
   (tstamps "0e700334"))
@@ -810,7 +799,7 @@
   (property (name "Sheetfile") (value "edg.parts.JlcCapacitor.JlcCapacitor"))
   (property (name "edg_path") (value "conv.sw[2].cap.c[0]"))
   (property (name "edg_short_path") (value "conv.sw[2].cap.c[0]"))
-  (property (name "edg_refdes") (value "C33"))
+  (property (name "edg_refdes") (value "C32"))
   (property (name "edg_part") (value "CL31A226KAHNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/sw[2]/cap/") (tstamps "/042f01b7/05f201d5/025e0135/"))
   (tstamps "035e014c"))
@@ -821,7 +810,7 @@
   (property (name "Sheetfile") (value "edg.parts.JlcCapacitor.JlcCapacitor"))
   (property (name "edg_path") (value "conv.sw[2].cap.c[1]"))
   (property (name "edg_short_path") (value "conv.sw[2].cap.c[1]"))
-  (property (name "edg_refdes") (value "C34"))
+  (property (name "edg_refdes") (value "C33"))
   (property (name "edg_part") (value "CL31A226KAHNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/sw[2]/cap/") (tstamps "/042f01b7/05f201d5/025e0135/"))
   (tstamps "0360014d"))
@@ -876,7 +865,7 @@
   (property (name "Sheetfile") (value "examples.test_fcml.MultilevelSwitchingCell"))
   (property (name "edg_path") (value "conv.sw[2].high_boot_cap"))
   (property (name "edg_short_path") (value "conv.sw[2].high_boot_cap"))
-  (property (name "edg_refdes") (value "C35"))
+  (property (name "edg_refdes") (value "C34"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[2]/") (tstamps "/042f01b7/05f201d5/"))
   (tstamps "24e30547"))
@@ -887,7 +876,7 @@
   (property (name "Sheetfile") (value "examples.test_fcml.MultilevelSwitchingCell"))
   (property (name "edg_path") (value "conv.sw[2].low_boot_cap"))
   (property (name "edg_short_path") (value "conv.sw[2].low_boot_cap"))
-  (property (name "edg_refdes") (value "C36"))
+  (property (name "edg_refdes") (value "C35"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[2]/") (tstamps "/042f01b7/05f201d5/"))
   (tstamps "20ac04f9"))
@@ -964,7 +953,7 @@
   (property (name "Sheetfile") (value "edg.parts.LinearRegulators.Lp5907"))
   (property (name "edg_path") (value "fpga.vcc_reg.in_cap.cap"))
   (property (name "edg_short_path") (value "fpga.vcc_reg.in_cap"))
-  (property (name "edg_refdes") (value "C37"))
+  (property (name "edg_refdes") (value "C36"))
   (property (name "edg_part") (value "CL10A105KB8NNNC (Samsung Electro-Mechanics)"))
   (sheetpath (names "/fpga/vcc_reg/") (tstamps "/041b019f/0b8502da/"))
   (tstamps "0879026b"))
@@ -975,7 +964,7 @@
   (property (name "Sheetfile") (value "edg.parts.LinearRegulators.Lp5907"))
   (property (name "edg_path") (value "fpga.vcc_reg.out_cap.cap"))
   (property (name "edg_short_path") (value "fpga.vcc_reg.out_cap"))
-  (property (name "edg_refdes") (value "C38"))
+  (property (name "edg_refdes") (value "C37"))
   (property (name "edg_part") (value "CL10A105KB8NNNC (Samsung Electro-Mechanics)"))
   (sheetpath (names "/fpga/vcc_reg/") (tstamps "/041b019f/0b8502da/"))
   (tstamps "0be902ec"))
@@ -1008,7 +997,7 @@
   (property (name "Sheetfile") (value "edg.parts.SpiMemory_W25q.W25q"))
   (property (name "edg_path") (value "fpga.mem.vcc_cap.cap"))
   (property (name "edg_short_path") (value "fpga.mem.vcc_cap"))
-  (property (name "edg_refdes") (value "C39"))
+  (property (name "edg_refdes") (value "C38"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/fpga/mem/") (tstamps "/041b019f/02810140/"))
   (tstamps "0b5902d0"))
@@ -1052,7 +1041,7 @@
   (property (name "Sheetfile") (value "edg.parts.Fpga_Ice40up.Ice40up5k_Sg48"))
   (property (name "edg_path") (value "fpga.vio_cap0.cap"))
   (property (name "edg_short_path") (value "fpga.vio_cap0"))
-  (property (name "edg_refdes") (value "C40"))
+  (property (name "edg_refdes") (value "C39"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/fpga/") (tstamps "/041b019f/"))
   (tstamps "0ecb0312"))
@@ -1063,7 +1052,7 @@
   (property (name "Sheetfile") (value "edg.parts.Fpga_Ice40up.Ice40up5k_Sg48"))
   (property (name "edg_path") (value "fpga.vio_cap1.cap"))
   (property (name "edg_short_path") (value "fpga.vio_cap1"))
-  (property (name "edg_refdes") (value "C41"))
+  (property (name "edg_refdes") (value "C40"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/fpga/") (tstamps "/041b019f/"))
   (tstamps "0ecc0313"))
@@ -1074,7 +1063,7 @@
   (property (name "Sheetfile") (value "edg.parts.Fpga_Ice40up.Ice40up5k_Sg48"))
   (property (name "edg_path") (value "fpga.vio_cap2.cap"))
   (property (name "edg_short_path") (value "fpga.vio_cap2"))
-  (property (name "edg_refdes") (value "C42"))
+  (property (name "edg_refdes") (value "C41"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/fpga/") (tstamps "/041b019f/"))
   (tstamps "0ecd0314"))
@@ -1085,7 +1074,7 @@
   (property (name "Sheetfile") (value "edg.parts.Fpga_Ice40up.Ice40up5k_Sg48"))
   (property (name "edg_path") (value "fpga.vpp_cap.cap"))
   (property (name "edg_short_path") (value "fpga.vpp_cap"))
-  (property (name "edg_refdes") (value "C43"))
+  (property (name "edg_refdes") (value "C42"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/fpga/") (tstamps "/041b019f/"))
   (tstamps "0be802ea"))
@@ -1107,7 +1096,7 @@
   (property (name "Sheetfile") (value "edg.parts.Fpga_Ice40up.Ice40up5k_Sg48"))
   (property (name "edg_path") (value "fpga.vcc_cap.cap"))
   (property (name "edg_short_path") (value "fpga.vcc_cap"))
-  (property (name "edg_refdes") (value "C44"))
+  (property (name "edg_refdes") (value "C43"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/fpga/") (tstamps "/041b019f/"))
   (tstamps "0b5902d0"))
@@ -1118,7 +1107,7 @@
   (property (name "Sheetfile") (value "edg.parts.Fpga_Ice40up.Ice40up5k_Sg48"))
   (property (name "edg_path") (value "fpga.pll_lf.cap"))
   (property (name "edg_short_path") (value "fpga.pll_lf"))
-  (property (name "edg_refdes") (value "C45"))
+  (property (name "edg_refdes") (value "C44"))
   (property (name "edg_part") (value "CL21A106KAYNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/fpga/") (tstamps "/041b019f/"))
   (tstamps "08cd027a"))
@@ -1129,7 +1118,7 @@
   (property (name "Sheetfile") (value "edg.parts.Fpga_Ice40up.Ice40up5k_Sg48"))
   (property (name "edg_path") (value "fpga.pll_hf.cap"))
   (property (name "edg_short_path") (value "fpga.pll_hf"))
-  (property (name "edg_refdes") (value "C46"))
+  (property (name "edg_refdes") (value "C45"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/fpga/") (tstamps "/041b019f/"))
   (tstamps "08c50276"))
@@ -1173,7 +1162,7 @@
   (property (name "Sheetfile") (value "edg.parts.JlcOscillator.JlcOscillator"))
   (property (name "edg_path") (value "fpga_osc.cap.cap"))
   (property (name "edg_short_path") (value "fpga_osc.cap"))
-  (property (name "edg_refdes") (value "C47"))
+  (property (name "edg_refdes") (value "C46"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/fpga_osc/") (tstamps "/0ea90343/"))
   (tstamps "025e0135"))
@@ -1349,7 +1338,7 @@
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.iovdd_cap[0].cap"))
   (property (name "edg_short_path") (value "mcu.iovdd_cap[0]"))
-  (property (name "edg_refdes") (value "C48"))
+  (property (name "edg_refdes") (value "C47"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "1f5b0492"))
@@ -1360,7 +1349,7 @@
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.iovdd_cap[1].cap"))
   (property (name "edg_short_path") (value "mcu.iovdd_cap[1]"))
-  (property (name "edg_refdes") (value "C49"))
+  (property (name "edg_refdes") (value "C48"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "1f5d0493"))
@@ -1371,7 +1360,7 @@
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.iovdd_cap[2].cap"))
   (property (name "edg_short_path") (value "mcu.iovdd_cap[2]"))
-  (property (name "edg_refdes") (value "C50"))
+  (property (name "edg_refdes") (value "C49"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "1f5f0494"))
@@ -1382,7 +1371,7 @@
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.iovdd_cap[3].cap"))
   (property (name "edg_short_path") (value "mcu.iovdd_cap[3]"))
-  (property (name "edg_refdes") (value "C51"))
+  (property (name "edg_refdes") (value "C50"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "1f610495"))
@@ -1393,7 +1382,7 @@
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.iovdd_cap[4].cap"))
   (property (name "edg_short_path") (value "mcu.iovdd_cap[4]"))
-  (property (name "edg_refdes") (value "C52"))
+  (property (name "edg_refdes") (value "C51"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "1f630496"))
@@ -1404,7 +1393,7 @@
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.iovdd_cap[5].cap"))
   (property (name "edg_short_path") (value "mcu.iovdd_cap[5]"))
-  (property (name "edg_refdes") (value "C53"))
+  (property (name "edg_refdes") (value "C52"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "1f650497"))
@@ -1415,7 +1404,7 @@
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.avdd_cap.cap"))
   (property (name "edg_short_path") (value "mcu.avdd_cap"))
-  (property (name "edg_refdes") (value "C54"))
+  (property (name "edg_refdes") (value "C53"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "0e6d0333"))
@@ -1426,7 +1415,7 @@
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.vreg_in_cap.cap"))
   (property (name "edg_short_path") (value "mcu.vreg_in_cap"))
-  (property (name "edg_refdes") (value "C55"))
+  (property (name "edg_refdes") (value "C54"))
   (property (name "edg_part") (value "CL10A105KB8NNNC (Samsung Electro-Mechanics)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "1b62047e"))
@@ -1448,7 +1437,7 @@
   (property (name "Sheetfile") (value "edg.parts.SpiMemory_W25q.W25q"))
   (property (name "edg_path") (value "mcu.mem.vcc_cap.cap"))
   (property (name "edg_short_path") (value "mcu.mem.vcc_cap"))
-  (property (name "edg_refdes") (value "C56"))
+  (property (name "edg_refdes") (value "C55"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/mem/") (tstamps "/02850146/02810140/"))
   (tstamps "0b5902d0"))
@@ -1459,7 +1448,7 @@
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.dvdd_cap[0].cap"))
   (property (name "edg_short_path") (value "mcu.dvdd_cap[0]"))
-  (property (name "edg_refdes") (value "C57"))
+  (property (name "edg_refdes") (value "C56"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "19f5041e"))
@@ -1470,7 +1459,7 @@
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.dvdd_cap[1].cap"))
   (property (name "edg_short_path") (value "mcu.dvdd_cap[1]"))
-  (property (name "edg_refdes") (value "C58"))
+  (property (name "edg_refdes") (value "C57"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "19f7041f"))
@@ -1481,7 +1470,7 @@
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.vreg_out_cap.cap"))
   (property (name "edg_short_path") (value "mcu.vreg_out_cap"))
-  (property (name "edg_refdes") (value "C59"))
+  (property (name "edg_refdes") (value "C58"))
   (property (name "edg_part") (value "CL10A105KB8NNNC (Samsung Electro-Mechanics)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "20e504ff"))
@@ -1525,7 +1514,7 @@
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractCrystal.OscillatorCrystal"))
   (property (name "edg_path") (value "mcu.crystal.cap_a"))
   (property (name "edg_short_path") (value "mcu.crystal.cap_a"))
-  (property (name "edg_refdes") (value "C60"))
+  (property (name "edg_refdes") (value "C59"))
   (property (name "edg_part") (value "CL10C330JB8NNNC (Samsung Electro-Mechanics)"))
   (sheetpath (names "/mcu/crystal/") (tstamps "/02850146/0c1b0303/"))
   (tstamps "05e701f5"))
@@ -1536,7 +1525,7 @@
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractCrystal.OscillatorCrystal"))
   (property (name "edg_path") (value "mcu.crystal.cap_b"))
   (property (name "edg_short_path") (value "mcu.crystal.cap_b"))
-  (property (name "edg_refdes") (value "C61"))
+  (property (name "edg_refdes") (value "C60"))
   (property (name "edg_part") (value "CL10C330JB8NNNC (Samsung Electro-Mechanics)"))
   (sheetpath (names "/mcu/crystal/") (tstamps "/02850146/0c1b0303/"))
   (tstamps "05e801f6"))
@@ -1778,7 +1767,7 @@
   (property (name "Sheetfile") (value "edg.abstract_parts.PassiveFilters.DigitalLowPassRc"))
   (property (name "edg_path") (value "tp_pwm.elts[0L].rc.c"))
   (property (name "edg_short_path") (value "tp_pwm.elts[0L].c"))
-  (property (name "edg_refdes") (value "C62"))
+  (property (name "edg_refdes") (value "C61"))
   (property (name "edg_part") (value "0603B151K500NT (FH(Guangdong Fenghua Advanced Tech))"))
   (sheetpath (names "/tp_pwm/elts[0L]/") (tstamps "/09150298/0e0c02ed/"))
   (tstamps "00640064"))
@@ -1800,7 +1789,7 @@
   (property (name "Sheetfile") (value "edg.abstract_parts.PassiveFilters.DigitalLowPassRc"))
   (property (name "edg_path") (value "tp_pwm.elts[0H].rc.c"))
   (property (name "edg_short_path") (value "tp_pwm.elts[0H].c"))
-  (property (name "edg_refdes") (value "C63"))
+  (property (name "edg_refdes") (value "C62"))
   (property (name "edg_part") (value "0603B151K500NT (FH(Guangdong Fenghua Advanced Tech))"))
   (sheetpath (names "/tp_pwm/elts[0H]/") (tstamps "/09150298/0e0402e9/"))
   (tstamps "00640064"))
@@ -1822,7 +1811,7 @@
   (property (name "Sheetfile") (value "edg.abstract_parts.PassiveFilters.DigitalLowPassRc"))
   (property (name "edg_path") (value "tp_pwm.elts[1L].rc.c"))
   (property (name "edg_short_path") (value "tp_pwm.elts[1L].c"))
-  (property (name "edg_refdes") (value "C64"))
+  (property (name "edg_refdes") (value "C63"))
   (property (name "edg_part") (value "0603B151K500NT (FH(Guangdong Fenghua Advanced Tech))"))
   (sheetpath (names "/tp_pwm/elts[1L]/") (tstamps "/09150298/0e0f02ee/"))
   (tstamps "00640064"))
@@ -1844,7 +1833,7 @@
   (property (name "Sheetfile") (value "edg.abstract_parts.PassiveFilters.DigitalLowPassRc"))
   (property (name "edg_path") (value "tp_pwm.elts[1H].rc.c"))
   (property (name "edg_short_path") (value "tp_pwm.elts[1H].c"))
-  (property (name "edg_refdes") (value "C65"))
+  (property (name "edg_refdes") (value "C64"))
   (property (name "edg_part") (value "0603B151K500NT (FH(Guangdong Fenghua Advanced Tech))"))
   (sheetpath (names "/tp_pwm/elts[1H]/") (tstamps "/09150298/0e0702ea/"))
   (tstamps "00640064"))
@@ -1866,7 +1855,7 @@
   (property (name "Sheetfile") (value "edg.abstract_parts.PassiveFilters.DigitalLowPassRc"))
   (property (name "edg_path") (value "tp_pwm.elts[2L].rc.c"))
   (property (name "edg_short_path") (value "tp_pwm.elts[2L].c"))
-  (property (name "edg_refdes") (value "C66"))
+  (property (name "edg_refdes") (value "C65"))
   (property (name "edg_part") (value "0603B151K500NT (FH(Guangdong Fenghua Advanced Tech))"))
   (sheetpath (names "/tp_pwm/elts[2L]/") (tstamps "/09150298/0e1202ef/"))
   (tstamps "00640064"))
@@ -1888,7 +1877,7 @@
   (property (name "Sheetfile") (value "edg.abstract_parts.PassiveFilters.DigitalLowPassRc"))
   (property (name "edg_path") (value "tp_pwm.elts[2H].rc.c"))
   (property (name "edg_short_path") (value "tp_pwm.elts[2H].c"))
-  (property (name "edg_refdes") (value "C67"))
+  (property (name "edg_refdes") (value "C66"))
   (property (name "edg_part") (value "0603B151K500NT (FH(Guangdong Fenghua Advanced Tech))"))
   (sheetpath (names "/tp_pwm/elts[2H]/") (tstamps "/09150298/0e0a02eb/"))
   (tstamps "00640064"))
@@ -2057,7 +2046,6 @@
   (node (ref conv.power_path.out_cap.c[0]) (pin 2))
   (node (ref conv.power_path.out_cap.c[1]) (pin 2))
   (node (ref conv.power_path.out_cap.c[2]) (pin 2))
-  (node (ref conv.power_path.out_cap.c[3]) (pin 2))
   (node (ref conv.sw[0].driver.cap) (pin 2)))
 (net (code 3) (name "v3v3")
   (node (ref reg_3v3.ic) (pin 2))
@@ -2136,8 +2124,7 @@
   (node (ref conv.power_path.inductor) (pin 2))
   (node (ref conv.power_path.out_cap.c[0]) (pin 1))
   (node (ref conv.power_path.out_cap.c[1]) (pin 1))
-  (node (ref conv.power_path.out_cap.c[2]) (pin 1))
-  (node (ref conv.power_path.out_cap.c[3]) (pin 1)))
+  (node (ref conv.power_path.out_cap.c[2]) (pin 1)))
 (net (code 7) (name "fpga.cdone")
   (node (ref fpga.ic) (pin 7))
   (node (ref cdone.package) (pin 2)))
diff --git a/examples/Fcml/Fcml.ref.net b/examples/Fcml/Fcml.ref.net
index e6e459eba..10f033c41 100644
--- a/examples/Fcml/Fcml.ref.net
+++ b/examples/Fcml/Fcml.ref.net
@@ -221,14 +221,14 @@
   (sheetpath (names "/reg_vgate/fb/") (tstamps "/129803b5/013000c9/"))
   (tstamps "175b043f"))
 (comp (ref "L1")
-  (value "500mA 33uH ±10% 410mΩ 1210 Inductors (SMD) ROHS")
-  (footprint "Inductor_SMD:L_1210_3225Metric")
+  (value "530mA 22uH ±20% 839mΩ SMD Power Inductors ROHS")
+  (footprint "Inductor_SMD:L_Sunlord_SWPA3012S")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BoostConverterPowerPath"))
   (property (name "edg_path") (value "reg_vgate.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_vgate.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "CBC3225T330KR (Taiyo Yuden)"))
+  (property (name "edg_part") (value "SWPA3012S220MT (Sunlord)"))
   (sheetpath (names "/reg_vgate/power_path/") (tstamps "/129803b5/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C3")
@@ -276,14 +276,14 @@
   (sheetpath (names "/") (tstamps "/"))
   (tstamps "0f4c035b"))
 (comp (ref "L2")
-  (value "4.1A 4.7uH ±30% 23.4mΩ SMD,8x8x4.2mm Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Taiyo-Yuden_NR-80xx")
+  (value "5.4A 10uH ±20% 21mΩ SMD Power Inductors ROHS")
+  (footprint "Inductor_SMD:L_Sunlord_SWRB1207S")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "examples.test_fcml.FcmlPowerPath"))
   (property (name "edg_path") (value "conv.power_path.inductor"))
   (property (name "edg_short_path") (value "conv.power_path.inductor"))
   (property (name "edg_refdes") (value "L2"))
-  (property (name "edg_part") (value "NR8040T4R7N (Taiyo Yuden)"))
+  (property (name "edg_part") (value "SWRB1207S-100MT (Sunlord)"))
   (sheetpath (names "/conv/power_path/") (tstamps "/042f01b7/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C5")
@@ -374,17 +374,6 @@
   (property (name "edg_part") (value "CL31A226KPHNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/power_path/out_cap/") (tstamps "/042f01b7/1786043a/0be902ec/"))
   (tstamps "0362014e"))
-(comp (ref "C13")
-  (value "10V 22uF X5R ±10% 1206 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
-  (footprint "Capacitor_SMD:C_1206_3216Metric")
-  (property (name "Sheetname") (value "out_cap"))
-  (property (name "Sheetfile") (value "edg.abstract_parts.AbstractCapacitor.DecouplingCapacitor"))
-  (property (name "edg_path") (value "conv.power_path.out_cap.cap.c[3]"))
-  (property (name "edg_short_path") (value "conv.power_path.out_cap.c[3]"))
-  (property (name "edg_refdes") (value "C13"))
-  (property (name "edg_part") (value "CL31A226KPHNNNE (Samsung Electro-Mechanics)"))
-  (sheetpath (names "/conv/power_path/out_cap/") (tstamps "/042f01b7/1786043a/0be902ec/"))
-  (tstamps "0364014f"))
 (comp (ref "U3")
   (value "IR2301")
   (footprint "Package_SO:SOIC-8_3.9x4.9mm_P1.27mm")
@@ -396,25 +385,25 @@
   (property (name "edg_part") (value "IR2301 (Infineon Technologies)"))
   (sheetpath (names "/conv/sw[0]/driver/") (tstamps "/042f01b7/05ee01d3/08da028d/"))
   (tstamps "013700cd"))
-(comp (ref "C14")
+(comp (ref "C13")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "driver"))
   (property (name "Sheetfile") (value "edg.parts.GateDriver_Ir2301.Ir2301"))
   (property (name "edg_path") (value "conv.sw[0].driver.cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[0].driver.cap"))
-  (property (name "edg_refdes") (value "C14"))
+  (property (name "edg_refdes") (value "C13"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[0]/driver/") (tstamps "/042f01b7/05ee01d3/08da028d/"))
   (tstamps "025e0135"))
-(comp (ref "C15")
+(comp (ref "C14")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "driver"))
   (property (name "Sheetfile") (value "edg.parts.GateDriver_Ir2301.Ir2301"))
   (property (name "edg_path") (value "conv.sw[0].driver.high_cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[0].driver.high_cap"))
-  (property (name "edg_refdes") (value "C15"))
+  (property (name "edg_refdes") (value "C14"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[0]/driver/") (tstamps "/042f01b7/05ee01d3/08da028d/"))
   (tstamps "0e700334"))
@@ -462,14 +451,14 @@
   (property (name "edg_part") (value "HSM4410 (HUASHUO)"))
   (sheetpath (names "/conv/sw[0]/") (tstamps "/042f01b7/05ee01d3/"))
   (tstamps "0bd402f1"))
-(comp (ref "C16")
+(comp (ref "C15")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "sw[0]"))
   (property (name "Sheetfile") (value "examples.test_fcml.MultilevelSwitchingCell"))
   (property (name "edg_path") (value "conv.sw[0].high_boot_cap"))
   (property (name "edg_short_path") (value "conv.sw[0].high_boot_cap"))
-  (property (name "edg_refdes") (value "C16"))
+  (property (name "edg_refdes") (value "C15"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[0]/") (tstamps "/042f01b7/05ee01d3/"))
   (tstamps "24e30547"))
@@ -495,25 +484,25 @@
   (property (name "edg_part") (value "AP2204K-3.3 (Diodes Incorporated)"))
   (sheetpath (names "/conv/sw[1]/ldo/") (tstamps "/042f01b7/05f001d4/027e0140/"))
   (tstamps "013700cd"))
-(comp (ref "C17")
+(comp (ref "C16")
   (value "50V 1uF X5R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "ldo"))
   (property (name "Sheetfile") (value "edg.parts.LinearRegulators.Ap2204k"))
   (property (name "edg_path") (value "conv.sw[1].ldo.in_cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[1].ldo.in_cap"))
-  (property (name "edg_refdes") (value "C17"))
+  (property (name "edg_refdes") (value "C16"))
   (property (name "edg_part") (value "CL10A105KB8NNNC (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/sw[1]/ldo/") (tstamps "/042f01b7/05f001d4/027e0140/"))
   (tstamps "0879026b"))
-(comp (ref "C18")
+(comp (ref "C17")
   (value "50V 2.2uF X7R ±10% 1206 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_1206_3216Metric")
   (property (name "Sheetname") (value "ldo"))
   (property (name "Sheetfile") (value "edg.parts.LinearRegulators.Ap2204k"))
   (property (name "edg_path") (value "conv.sw[1].ldo.out_cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[1].ldo.out_cap"))
-  (property (name "edg_refdes") (value "C18"))
+  (property (name "edg_refdes") (value "C17"))
   (property (name "edg_part") (value "CL31B225KBHNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/sw[1]/ldo/") (tstamps "/042f01b7/05f001d4/027e0140/"))
   (tstamps "0be902ec"))
@@ -528,25 +517,25 @@
   (property (name "edg_part") (value "CBMuD1200L (Corebai)"))
   (sheetpath (names "/conv/sw[1]/iso/") (tstamps "/042f01b7/05f001d4/0293014c/"))
   (tstamps "013700cd"))
-(comp (ref "C19")
+(comp (ref "C18")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "iso"))
   (property (name "Sheetfile") (value "edg.parts.Isolator_Cbmud1200.Cbmud1200l"))
   (property (name "edg_path") (value "conv.sw[1].iso.cap_a.cap"))
   (property (name "edg_short_path") (value "conv.sw[1].iso.cap_a"))
-  (property (name "edg_refdes") (value "C19"))
+  (property (name "edg_refdes") (value "C18"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[1]/iso/") (tstamps "/042f01b7/05f001d4/0293014c/"))
   (tstamps "05e701f5"))
-(comp (ref "C20")
+(comp (ref "C19")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "iso"))
   (property (name "Sheetfile") (value "edg.parts.Isolator_Cbmud1200.Cbmud1200l"))
   (property (name "edg_path") (value "conv.sw[1].iso.cap_b.cap"))
   (property (name "edg_short_path") (value "conv.sw[1].iso.cap_b"))
-  (property (name "edg_refdes") (value "C20"))
+  (property (name "edg_refdes") (value "C19"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[1]/iso/") (tstamps "/042f01b7/05f001d4/0293014c/"))
   (tstamps "05e801f6"))
@@ -561,25 +550,25 @@
   (property (name "edg_part") (value "IR2301 (Infineon Technologies)"))
   (sheetpath (names "/conv/sw[1]/driver/") (tstamps "/042f01b7/05f001d4/08da028d/"))
   (tstamps "013700cd"))
-(comp (ref "C21")
+(comp (ref "C20")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "driver"))
   (property (name "Sheetfile") (value "edg.parts.GateDriver_Ir2301.Ir2301"))
   (property (name "edg_path") (value "conv.sw[1].driver.cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[1].driver.cap"))
-  (property (name "edg_refdes") (value "C21"))
+  (property (name "edg_refdes") (value "C20"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[1]/driver/") (tstamps "/042f01b7/05f001d4/08da028d/"))
   (tstamps "025e0135"))
-(comp (ref "C22")
+(comp (ref "C21")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "driver"))
   (property (name "Sheetfile") (value "edg.parts.GateDriver_Ir2301.Ir2301"))
   (property (name "edg_path") (value "conv.sw[1].driver.high_cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[1].driver.high_cap"))
-  (property (name "edg_refdes") (value "C22"))
+  (property (name "edg_refdes") (value "C21"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[1]/driver/") (tstamps "/042f01b7/05f001d4/08da028d/"))
   (tstamps "0e700334"))
@@ -594,25 +583,25 @@
   (property (name "edg_part") (value "0603WAF220JT5E (UNI-ROYAL(Uniroyal Elec))"))
   (sheetpath (names "/conv/sw[1]/") (tstamps "/042f01b7/05f001d4/"))
   (tstamps "24b4054a"))
-(comp (ref "C23")
+(comp (ref "C22")
   (value "25V 22uF X5R ±10% 1206 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_1206_3216Metric")
   (property (name "Sheetname") (value "cap"))
   (property (name "Sheetfile") (value "edg.parts.JlcCapacitor.JlcCapacitor"))
   (property (name "edg_path") (value "conv.sw[1].cap.c[0]"))
   (property (name "edg_short_path") (value "conv.sw[1].cap.c[0]"))
-  (property (name "edg_refdes") (value "C23"))
+  (property (name "edg_refdes") (value "C22"))
   (property (name "edg_part") (value "CL31A226KAHNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/sw[1]/cap/") (tstamps "/042f01b7/05f001d4/025e0135/"))
   (tstamps "035e014c"))
-(comp (ref "C24")
+(comp (ref "C23")
   (value "25V 22uF X5R ±10% 1206 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_1206_3216Metric")
   (property (name "Sheetname") (value "cap"))
   (property (name "Sheetfile") (value "edg.parts.JlcCapacitor.JlcCapacitor"))
   (property (name "edg_path") (value "conv.sw[1].cap.c[1]"))
   (property (name "edg_short_path") (value "conv.sw[1].cap.c[1]"))
-  (property (name "edg_refdes") (value "C24"))
+  (property (name "edg_refdes") (value "C23"))
   (property (name "edg_part") (value "CL31A226KAHNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/sw[1]/cap/") (tstamps "/042f01b7/05f001d4/025e0135/"))
   (tstamps "0360014d"))
@@ -660,25 +649,25 @@
   (property (name "edg_part") (value "1N5819WS (Guangdong Hottech)"))
   (sheetpath (names "/conv/sw[1]/") (tstamps "/042f01b7/05f001d4/"))
   (tstamps "2bed05ca"))
-(comp (ref "C25")
+(comp (ref "C24")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "sw[1]"))
   (property (name "Sheetfile") (value "examples.test_fcml.MultilevelSwitchingCell"))
   (property (name "edg_path") (value "conv.sw[1].high_boot_cap"))
   (property (name "edg_short_path") (value "conv.sw[1].high_boot_cap"))
-  (property (name "edg_refdes") (value "C25"))
+  (property (name "edg_refdes") (value "C24"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[1]/") (tstamps "/042f01b7/05f001d4/"))
   (tstamps "24e30547"))
-(comp (ref "C26")
+(comp (ref "C25")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "sw[1]"))
   (property (name "Sheetfile") (value "examples.test_fcml.MultilevelSwitchingCell"))
   (property (name "edg_path") (value "conv.sw[1].low_boot_cap"))
   (property (name "edg_short_path") (value "conv.sw[1].low_boot_cap"))
-  (property (name "edg_refdes") (value "C26"))
+  (property (name "edg_refdes") (value "C25"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[1]/") (tstamps "/042f01b7/05f001d4/"))
   (tstamps "20ac04f9"))
@@ -704,25 +693,25 @@
   (property (name "edg_part") (value "AP2204K-3.3 (Diodes Incorporated)"))
   (sheetpath (names "/conv/sw[2]/ldo/") (tstamps "/042f01b7/05f201d5/027e0140/"))
   (tstamps "013700cd"))
-(comp (ref "C27")
+(comp (ref "C26")
   (value "50V 1uF X5R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "ldo"))
   (property (name "Sheetfile") (value "edg.parts.LinearRegulators.Ap2204k"))
   (property (name "edg_path") (value "conv.sw[2].ldo.in_cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[2].ldo.in_cap"))
-  (property (name "edg_refdes") (value "C27"))
+  (property (name "edg_refdes") (value "C26"))
   (property (name "edg_part") (value "CL10A105KB8NNNC (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/sw[2]/ldo/") (tstamps "/042f01b7/05f201d5/027e0140/"))
   (tstamps "0879026b"))
-(comp (ref "C28")
+(comp (ref "C27")
   (value "50V 2.2uF X7R ±10% 1206 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_1206_3216Metric")
   (property (name "Sheetname") (value "ldo"))
   (property (name "Sheetfile") (value "edg.parts.LinearRegulators.Ap2204k"))
   (property (name "edg_path") (value "conv.sw[2].ldo.out_cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[2].ldo.out_cap"))
-  (property (name "edg_refdes") (value "C28"))
+  (property (name "edg_refdes") (value "C27"))
   (property (name "edg_part") (value "CL31B225KBHNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/sw[2]/ldo/") (tstamps "/042f01b7/05f201d5/027e0140/"))
   (tstamps "0be902ec"))
@@ -737,25 +726,25 @@
   (property (name "edg_part") (value "CBMuD1200L (Corebai)"))
   (sheetpath (names "/conv/sw[2]/iso/") (tstamps "/042f01b7/05f201d5/0293014c/"))
   (tstamps "013700cd"))
-(comp (ref "C29")
+(comp (ref "C28")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "iso"))
   (property (name "Sheetfile") (value "edg.parts.Isolator_Cbmud1200.Cbmud1200l"))
   (property (name "edg_path") (value "conv.sw[2].iso.cap_a.cap"))
   (property (name "edg_short_path") (value "conv.sw[2].iso.cap_a"))
-  (property (name "edg_refdes") (value "C29"))
+  (property (name "edg_refdes") (value "C28"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[2]/iso/") (tstamps "/042f01b7/05f201d5/0293014c/"))
   (tstamps "05e701f5"))
-(comp (ref "C30")
+(comp (ref "C29")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "iso"))
   (property (name "Sheetfile") (value "edg.parts.Isolator_Cbmud1200.Cbmud1200l"))
   (property (name "edg_path") (value "conv.sw[2].iso.cap_b.cap"))
   (property (name "edg_short_path") (value "conv.sw[2].iso.cap_b"))
-  (property (name "edg_refdes") (value "C30"))
+  (property (name "edg_refdes") (value "C29"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[2]/iso/") (tstamps "/042f01b7/05f201d5/0293014c/"))
   (tstamps "05e801f6"))
@@ -770,25 +759,25 @@
   (property (name "edg_part") (value "IR2301 (Infineon Technologies)"))
   (sheetpath (names "/conv/sw[2]/driver/") (tstamps "/042f01b7/05f201d5/08da028d/"))
   (tstamps "013700cd"))
-(comp (ref "C31")
+(comp (ref "C30")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "driver"))
   (property (name "Sheetfile") (value "edg.parts.GateDriver_Ir2301.Ir2301"))
   (property (name "edg_path") (value "conv.sw[2].driver.cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[2].driver.cap"))
-  (property (name "edg_refdes") (value "C31"))
+  (property (name "edg_refdes") (value "C30"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[2]/driver/") (tstamps "/042f01b7/05f201d5/08da028d/"))
   (tstamps "025e0135"))
-(comp (ref "C32")
+(comp (ref "C31")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "driver"))
   (property (name "Sheetfile") (value "edg.parts.GateDriver_Ir2301.Ir2301"))
   (property (name "edg_path") (value "conv.sw[2].driver.high_cap.cap"))
   (property (name "edg_short_path") (value "conv.sw[2].driver.high_cap"))
-  (property (name "edg_refdes") (value "C32"))
+  (property (name "edg_refdes") (value "C31"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[2]/driver/") (tstamps "/042f01b7/05f201d5/08da028d/"))
   (tstamps "0e700334"))
@@ -803,25 +792,25 @@
   (property (name "edg_part") (value "0603WAF220JT5E (UNI-ROYAL(Uniroyal Elec))"))
   (sheetpath (names "/conv/sw[2]/") (tstamps "/042f01b7/05f201d5/"))
   (tstamps "24b4054a"))
-(comp (ref "C33")
+(comp (ref "C32")
   (value "25V 22uF X5R ±10% 1206 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_1206_3216Metric")
   (property (name "Sheetname") (value "cap"))
   (property (name "Sheetfile") (value "edg.parts.JlcCapacitor.JlcCapacitor"))
   (property (name "edg_path") (value "conv.sw[2].cap.c[0]"))
   (property (name "edg_short_path") (value "conv.sw[2].cap.c[0]"))
-  (property (name "edg_refdes") (value "C33"))
+  (property (name "edg_refdes") (value "C32"))
   (property (name "edg_part") (value "CL31A226KAHNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/sw[2]/cap/") (tstamps "/042f01b7/05f201d5/025e0135/"))
   (tstamps "035e014c"))
-(comp (ref "C34")
+(comp (ref "C33")
   (value "25V 22uF X5R ±10% 1206 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_1206_3216Metric")
   (property (name "Sheetname") (value "cap"))
   (property (name "Sheetfile") (value "edg.parts.JlcCapacitor.JlcCapacitor"))
   (property (name "edg_path") (value "conv.sw[2].cap.c[1]"))
   (property (name "edg_short_path") (value "conv.sw[2].cap.c[1]"))
-  (property (name "edg_refdes") (value "C34"))
+  (property (name "edg_refdes") (value "C33"))
   (property (name "edg_part") (value "CL31A226KAHNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/conv/sw[2]/cap/") (tstamps "/042f01b7/05f201d5/025e0135/"))
   (tstamps "0360014d"))
@@ -869,25 +858,25 @@
   (property (name "edg_part") (value "1N5819WS (Guangdong Hottech)"))
   (sheetpath (names "/conv/sw[2]/") (tstamps "/042f01b7/05f201d5/"))
   (tstamps "2bed05ca"))
-(comp (ref "C35")
+(comp (ref "C34")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "sw[2]"))
   (property (name "Sheetfile") (value "examples.test_fcml.MultilevelSwitchingCell"))
   (property (name "edg_path") (value "conv.sw[2].high_boot_cap"))
   (property (name "edg_short_path") (value "conv.sw[2].high_boot_cap"))
-  (property (name "edg_refdes") (value "C35"))
+  (property (name "edg_refdes") (value "C34"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[2]/") (tstamps "/042f01b7/05f201d5/"))
   (tstamps "24e30547"))
-(comp (ref "C36")
+(comp (ref "C35")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "sw[2]"))
   (property (name "Sheetfile") (value "examples.test_fcml.MultilevelSwitchingCell"))
   (property (name "edg_path") (value "conv.sw[2].low_boot_cap"))
   (property (name "edg_short_path") (value "conv.sw[2].low_boot_cap"))
-  (property (name "edg_refdes") (value "C36"))
+  (property (name "edg_refdes") (value "C35"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/conv/sw[2]/") (tstamps "/042f01b7/05f201d5/"))
   (tstamps "20ac04f9"))
@@ -957,25 +946,25 @@
   (property (name "edg_part") (value "LP5907MFX-1.2/NOPB (Texas Instruments)"))
   (sheetpath (names "/fpga/vcc_reg/") (tstamps "/041b019f/0b8502da/"))
   (tstamps "013700cd"))
-(comp (ref "C37")
+(comp (ref "C36")
   (value "50V 1uF X5R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "vcc_reg"))
   (property (name "Sheetfile") (value "edg.parts.LinearRegulators.Lp5907"))
   (property (name "edg_path") (value "fpga.vcc_reg.in_cap.cap"))
   (property (name "edg_short_path") (value "fpga.vcc_reg.in_cap"))
-  (property (name "edg_refdes") (value "C37"))
+  (property (name "edg_refdes") (value "C36"))
   (property (name "edg_part") (value "CL10A105KB8NNNC (Samsung Electro-Mechanics)"))
   (sheetpath (names "/fpga/vcc_reg/") (tstamps "/041b019f/0b8502da/"))
   (tstamps "0879026b"))
-(comp (ref "C38")
+(comp (ref "C37")
   (value "50V 1uF X5R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "vcc_reg"))
   (property (name "Sheetfile") (value "edg.parts.LinearRegulators.Lp5907"))
   (property (name "edg_path") (value "fpga.vcc_reg.out_cap.cap"))
   (property (name "edg_short_path") (value "fpga.vcc_reg.out_cap"))
-  (property (name "edg_refdes") (value "C38"))
+  (property (name "edg_refdes") (value "C37"))
   (property (name "edg_part") (value "CL10A105KB8NNNC (Samsung Electro-Mechanics)"))
   (sheetpath (names "/fpga/vcc_reg/") (tstamps "/041b019f/0b8502da/"))
   (tstamps "0be902ec"))
@@ -1001,14 +990,14 @@
   (property (name "edg_part") (value "W25Q128JVSIQ (Winbond Electronics)"))
   (sheetpath (names "/fpga/mem/") (tstamps "/041b019f/02810140/"))
   (tstamps "013700cd"))
-(comp (ref "C39")
+(comp (ref "C38")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "mem"))
   (property (name "Sheetfile") (value "edg.parts.SpiMemory_W25q.W25q"))
   (property (name "edg_path") (value "fpga.mem.vcc_cap.cap"))
   (property (name "edg_short_path") (value "fpga.mem.vcc_cap"))
-  (property (name "edg_refdes") (value "C39"))
+  (property (name "edg_refdes") (value "C38"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/fpga/mem/") (tstamps "/041b019f/02810140/"))
   (tstamps "0b5902d0"))
@@ -1045,47 +1034,47 @@
   (property (name "edg_part") (value "0603WAF1002T5E (UNI-ROYAL(Uniroyal Elec))"))
   (sheetpath (names "/fpga/") (tstamps "/041b019f/"))
   (tstamps "08b30284"))
-(comp (ref "C40")
+(comp (ref "C39")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "fpga"))
   (property (name "Sheetfile") (value "edg.parts.Fpga_Ice40up.Ice40up5k_Sg48"))
   (property (name "edg_path") (value "fpga.vio_cap0.cap"))
   (property (name "edg_short_path") (value "fpga.vio_cap0"))
-  (property (name "edg_refdes") (value "C40"))
+  (property (name "edg_refdes") (value "C39"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/fpga/") (tstamps "/041b019f/"))
   (tstamps "0ecb0312"))
-(comp (ref "C41")
+(comp (ref "C40")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "fpga"))
   (property (name "Sheetfile") (value "edg.parts.Fpga_Ice40up.Ice40up5k_Sg48"))
   (property (name "edg_path") (value "fpga.vio_cap1.cap"))
   (property (name "edg_short_path") (value "fpga.vio_cap1"))
-  (property (name "edg_refdes") (value "C41"))
+  (property (name "edg_refdes") (value "C40"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/fpga/") (tstamps "/041b019f/"))
   (tstamps "0ecc0313"))
-(comp (ref "C42")
+(comp (ref "C41")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "fpga"))
   (property (name "Sheetfile") (value "edg.parts.Fpga_Ice40up.Ice40up5k_Sg48"))
   (property (name "edg_path") (value "fpga.vio_cap2.cap"))
   (property (name "edg_short_path") (value "fpga.vio_cap2"))
-  (property (name "edg_refdes") (value "C42"))
+  (property (name "edg_refdes") (value "C41"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/fpga/") (tstamps "/041b019f/"))
   (tstamps "0ecd0314"))
-(comp (ref "C43")
+(comp (ref "C42")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "fpga"))
   (property (name "Sheetfile") (value "edg.parts.Fpga_Ice40up.Ice40up5k_Sg48"))
   (property (name "edg_path") (value "fpga.vpp_cap.cap"))
   (property (name "edg_short_path") (value "fpga.vpp_cap"))
-  (property (name "edg_refdes") (value "C43"))
+  (property (name "edg_refdes") (value "C42"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/fpga/") (tstamps "/041b019f/"))
   (tstamps "0be802ea"))
@@ -1100,36 +1089,36 @@
   (property (name "edg_part") (value "0603WAF1000T5E (UNI-ROYAL(Uniroyal Elec))"))
   (sheetpath (names "/fpga/") (tstamps "/041b019f/"))
   (tstamps "0bca02f2"))
-(comp (ref "C44")
+(comp (ref "C43")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "fpga"))
   (property (name "Sheetfile") (value "edg.parts.Fpga_Ice40up.Ice40up5k_Sg48"))
   (property (name "edg_path") (value "fpga.vcc_cap.cap"))
   (property (name "edg_short_path") (value "fpga.vcc_cap"))
-  (property (name "edg_refdes") (value "C44"))
+  (property (name "edg_refdes") (value "C43"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/fpga/") (tstamps "/041b019f/"))
   (tstamps "0b5902d0"))
-(comp (ref "C45")
+(comp (ref "C44")
   (value "X5R 25V ±10% 10uF 0805 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0805_2012Metric")
   (property (name "Sheetname") (value "fpga"))
   (property (name "Sheetfile") (value "edg.parts.Fpga_Ice40up.Ice40up5k_Sg48"))
   (property (name "edg_path") (value "fpga.pll_lf.cap"))
   (property (name "edg_short_path") (value "fpga.pll_lf"))
-  (property (name "edg_refdes") (value "C45"))
+  (property (name "edg_refdes") (value "C44"))
   (property (name "edg_part") (value "CL21A106KAYNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/fpga/") (tstamps "/041b019f/"))
   (tstamps "08cd027a"))
-(comp (ref "C46")
+(comp (ref "C45")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "fpga"))
   (property (name "Sheetfile") (value "edg.parts.Fpga_Ice40up.Ice40up5k_Sg48"))
   (property (name "edg_path") (value "fpga.pll_hf.cap"))
   (property (name "edg_short_path") (value "fpga.pll_hf"))
-  (property (name "edg_refdes") (value "C46"))
+  (property (name "edg_refdes") (value "C45"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/fpga/") (tstamps "/041b019f/"))
   (tstamps "08c50276"))
@@ -1166,14 +1155,14 @@
   (property (name "edg_part") (value "SG-8101CG 48.000000MHz TBGSA"))
   (sheetpath (names "/fpga_osc/") (tstamps "/0ea90343/"))
   (tstamps "08950271"))
-(comp (ref "C47")
+(comp (ref "C46")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "fpga_osc"))
   (property (name "Sheetfile") (value "edg.parts.JlcOscillator.JlcOscillator"))
   (property (name "edg_path") (value "fpga_osc.cap.cap"))
   (property (name "edg_short_path") (value "fpga_osc.cap"))
-  (property (name "edg_refdes") (value "C47"))
+  (property (name "edg_refdes") (value "C46"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/fpga_osc/") (tstamps "/0ea90343/"))
   (tstamps "025e0135"))
@@ -1342,91 +1331,91 @@
   (property (name "edg_part") (value "RP2040 (Raspberry Pi)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "013700cd"))
-(comp (ref "C48")
+(comp (ref "C47")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "mcu"))
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.iovdd_cap[0].cap"))
   (property (name "edg_short_path") (value "mcu.iovdd_cap[0]"))
-  (property (name "edg_refdes") (value "C48"))
+  (property (name "edg_refdes") (value "C47"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "1f5b0492"))
-(comp (ref "C49")
+(comp (ref "C48")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "mcu"))
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.iovdd_cap[1].cap"))
   (property (name "edg_short_path") (value "mcu.iovdd_cap[1]"))
-  (property (name "edg_refdes") (value "C49"))
+  (property (name "edg_refdes") (value "C48"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "1f5d0493"))
-(comp (ref "C50")
+(comp (ref "C49")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "mcu"))
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.iovdd_cap[2].cap"))
   (property (name "edg_short_path") (value "mcu.iovdd_cap[2]"))
-  (property (name "edg_refdes") (value "C50"))
+  (property (name "edg_refdes") (value "C49"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "1f5f0494"))
-(comp (ref "C51")
+(comp (ref "C50")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "mcu"))
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.iovdd_cap[3].cap"))
   (property (name "edg_short_path") (value "mcu.iovdd_cap[3]"))
-  (property (name "edg_refdes") (value "C51"))
+  (property (name "edg_refdes") (value "C50"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "1f610495"))
-(comp (ref "C52")
+(comp (ref "C51")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "mcu"))
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.iovdd_cap[4].cap"))
   (property (name "edg_short_path") (value "mcu.iovdd_cap[4]"))
-  (property (name "edg_refdes") (value "C52"))
+  (property (name "edg_refdes") (value "C51"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "1f630496"))
-(comp (ref "C53")
+(comp (ref "C52")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "mcu"))
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.iovdd_cap[5].cap"))
   (property (name "edg_short_path") (value "mcu.iovdd_cap[5]"))
-  (property (name "edg_refdes") (value "C53"))
+  (property (name "edg_refdes") (value "C52"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "1f650497"))
-(comp (ref "C54")
+(comp (ref "C53")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "mcu"))
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.avdd_cap.cap"))
   (property (name "edg_short_path") (value "mcu.avdd_cap"))
-  (property (name "edg_refdes") (value "C54"))
+  (property (name "edg_refdes") (value "C53"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "0e6d0333"))
-(comp (ref "C55")
+(comp (ref "C54")
   (value "50V 1uF X5R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "mcu"))
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.vreg_in_cap.cap"))
   (property (name "edg_short_path") (value "mcu.vreg_in_cap"))
-  (property (name "edg_refdes") (value "C55"))
+  (property (name "edg_refdes") (value "C54"))
   (property (name "edg_part") (value "CL10A105KB8NNNC (Samsung Electro-Mechanics)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "1b62047e"))
@@ -1441,47 +1430,47 @@
   (property (name "edg_part") (value "W25Q128JVSIQ (Winbond Electronics)"))
   (sheetpath (names "/mcu/mem/") (tstamps "/02850146/02810140/"))
   (tstamps "013700cd"))
-(comp (ref "C56")
+(comp (ref "C55")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "mem"))
   (property (name "Sheetfile") (value "edg.parts.SpiMemory_W25q.W25q"))
   (property (name "edg_path") (value "mcu.mem.vcc_cap.cap"))
   (property (name "edg_short_path") (value "mcu.mem.vcc_cap"))
-  (property (name "edg_refdes") (value "C56"))
+  (property (name "edg_refdes") (value "C55"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/mem/") (tstamps "/02850146/02810140/"))
   (tstamps "0b5902d0"))
-(comp (ref "C57")
+(comp (ref "C56")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "mcu"))
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.dvdd_cap[0].cap"))
   (property (name "edg_short_path") (value "mcu.dvdd_cap[0]"))
-  (property (name "edg_refdes") (value "C57"))
+  (property (name "edg_refdes") (value "C56"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "19f5041e"))
-(comp (ref "C58")
+(comp (ref "C57")
   (value "50V 100nF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "mcu"))
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.dvdd_cap[1].cap"))
   (property (name "edg_short_path") (value "mcu.dvdd_cap[1]"))
-  (property (name "edg_refdes") (value "C58"))
+  (property (name "edg_refdes") (value "C57"))
   (property (name "edg_part") (value "CC0603KRX7R9BB104 (YAGEO)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "19f7041f"))
-(comp (ref "C59")
+(comp (ref "C58")
   (value "50V 1uF X5R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "mcu"))
   (property (name "Sheetfile") (value "edg.parts.Microcontroller_Rp2040.Rp2040"))
   (property (name "edg_path") (value "mcu.vreg_out_cap.cap"))
   (property (name "edg_short_path") (value "mcu.vreg_out_cap"))
-  (property (name "edg_refdes") (value "C59"))
+  (property (name "edg_refdes") (value "C58"))
   (property (name "edg_part") (value "CL10A105KB8NNNC (Samsung Electro-Mechanics)"))
   (sheetpath (names "/mcu/") (tstamps "/02850146/"))
   (tstamps "20e504ff"))
@@ -1518,25 +1507,25 @@
   (property (name "edg_part") (value "X322512MSB4SI (Yangxing Tech)"))
   (sheetpath (names "/mcu/crystal/") (tstamps "/02850146/0c1b0303/"))
   (tstamps "0b4e02cd"))
-(comp (ref "C60")
+(comp (ref "C59")
   (value "50V 33pF C0G ±5% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "crystal"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractCrystal.OscillatorCrystal"))
   (property (name "edg_path") (value "mcu.crystal.cap_a"))
   (property (name "edg_short_path") (value "mcu.crystal.cap_a"))
-  (property (name "edg_refdes") (value "C60"))
+  (property (name "edg_refdes") (value "C59"))
   (property (name "edg_part") (value "CL10C330JB8NNNC (Samsung Electro-Mechanics)"))
   (sheetpath (names "/mcu/crystal/") (tstamps "/02850146/0c1b0303/"))
   (tstamps "05e701f5"))
-(comp (ref "C61")
+(comp (ref "C60")
   (value "50V 33pF C0G ±5% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "crystal"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractCrystal.OscillatorCrystal"))
   (property (name "edg_path") (value "mcu.crystal.cap_b"))
   (property (name "edg_short_path") (value "mcu.crystal.cap_b"))
-  (property (name "edg_refdes") (value "C61"))
+  (property (name "edg_refdes") (value "C60"))
   (property (name "edg_part") (value "CL10C330JB8NNNC (Samsung Electro-Mechanics)"))
   (sheetpath (names "/mcu/crystal/") (tstamps "/02850146/0c1b0303/"))
   (tstamps "05e801f6"))
@@ -1771,14 +1760,14 @@
   (property (name "edg_part") (value "0603WAF1500T5E (UNI-ROYAL(Uniroyal Elec))"))
   (sheetpath (names "/tp_pwm/elts[0L]/") (tstamps "/09150298/0e0c02ed/"))
   (tstamps "00730073"))
-(comp (ref "C62")
+(comp (ref "C61")
   (value "50V 150pF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "elts[0L]"))
   (property (name "Sheetfile") (value "edg.abstract_parts.PassiveFilters.DigitalLowPassRc"))
   (property (name "edg_path") (value "tp_pwm.elts[0L].rc.c"))
   (property (name "edg_short_path") (value "tp_pwm.elts[0L].c"))
-  (property (name "edg_refdes") (value "C62"))
+  (property (name "edg_refdes") (value "C61"))
   (property (name "edg_part") (value "0603B151K500NT (FH(Guangdong Fenghua Advanced Tech))"))
   (sheetpath (names "/tp_pwm/elts[0L]/") (tstamps "/09150298/0e0c02ed/"))
   (tstamps "00640064"))
@@ -1793,14 +1782,14 @@
   (property (name "edg_part") (value "0603WAF1500T5E (UNI-ROYAL(Uniroyal Elec))"))
   (sheetpath (names "/tp_pwm/elts[0H]/") (tstamps "/09150298/0e0402e9/"))
   (tstamps "00730073"))
-(comp (ref "C63")
+(comp (ref "C62")
   (value "50V 150pF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "elts[0H]"))
   (property (name "Sheetfile") (value "edg.abstract_parts.PassiveFilters.DigitalLowPassRc"))
   (property (name "edg_path") (value "tp_pwm.elts[0H].rc.c"))
   (property (name "edg_short_path") (value "tp_pwm.elts[0H].c"))
-  (property (name "edg_refdes") (value "C63"))
+  (property (name "edg_refdes") (value "C62"))
   (property (name "edg_part") (value "0603B151K500NT (FH(Guangdong Fenghua Advanced Tech))"))
   (sheetpath (names "/tp_pwm/elts[0H]/") (tstamps "/09150298/0e0402e9/"))
   (tstamps "00640064"))
@@ -1815,14 +1804,14 @@
   (property (name "edg_part") (value "0603WAF1500T5E (UNI-ROYAL(Uniroyal Elec))"))
   (sheetpath (names "/tp_pwm/elts[1L]/") (tstamps "/09150298/0e0f02ee/"))
   (tstamps "00730073"))
-(comp (ref "C64")
+(comp (ref "C63")
   (value "50V 150pF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "elts[1L]"))
   (property (name "Sheetfile") (value "edg.abstract_parts.PassiveFilters.DigitalLowPassRc"))
   (property (name "edg_path") (value "tp_pwm.elts[1L].rc.c"))
   (property (name "edg_short_path") (value "tp_pwm.elts[1L].c"))
-  (property (name "edg_refdes") (value "C64"))
+  (property (name "edg_refdes") (value "C63"))
   (property (name "edg_part") (value "0603B151K500NT (FH(Guangdong Fenghua Advanced Tech))"))
   (sheetpath (names "/tp_pwm/elts[1L]/") (tstamps "/09150298/0e0f02ee/"))
   (tstamps "00640064"))
@@ -1837,14 +1826,14 @@
   (property (name "edg_part") (value "0603WAF1500T5E (UNI-ROYAL(Uniroyal Elec))"))
   (sheetpath (names "/tp_pwm/elts[1H]/") (tstamps "/09150298/0e0702ea/"))
   (tstamps "00730073"))
-(comp (ref "C65")
+(comp (ref "C64")
   (value "50V 150pF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "elts[1H]"))
   (property (name "Sheetfile") (value "edg.abstract_parts.PassiveFilters.DigitalLowPassRc"))
   (property (name "edg_path") (value "tp_pwm.elts[1H].rc.c"))
   (property (name "edg_short_path") (value "tp_pwm.elts[1H].c"))
-  (property (name "edg_refdes") (value "C65"))
+  (property (name "edg_refdes") (value "C64"))
   (property (name "edg_part") (value "0603B151K500NT (FH(Guangdong Fenghua Advanced Tech))"))
   (sheetpath (names "/tp_pwm/elts[1H]/") (tstamps "/09150298/0e0702ea/"))
   (tstamps "00640064"))
@@ -1859,14 +1848,14 @@
   (property (name "edg_part") (value "0603WAF1500T5E (UNI-ROYAL(Uniroyal Elec))"))
   (sheetpath (names "/tp_pwm/elts[2L]/") (tstamps "/09150298/0e1202ef/"))
   (tstamps "00730073"))
-(comp (ref "C66")
+(comp (ref "C65")
   (value "50V 150pF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "elts[2L]"))
   (property (name "Sheetfile") (value "edg.abstract_parts.PassiveFilters.DigitalLowPassRc"))
   (property (name "edg_path") (value "tp_pwm.elts[2L].rc.c"))
   (property (name "edg_short_path") (value "tp_pwm.elts[2L].c"))
-  (property (name "edg_refdes") (value "C66"))
+  (property (name "edg_refdes") (value "C65"))
   (property (name "edg_part") (value "0603B151K500NT (FH(Guangdong Fenghua Advanced Tech))"))
   (sheetpath (names "/tp_pwm/elts[2L]/") (tstamps "/09150298/0e1202ef/"))
   (tstamps "00640064"))
@@ -1881,14 +1870,14 @@
   (property (name "edg_part") (value "0603WAF1500T5E (UNI-ROYAL(Uniroyal Elec))"))
   (sheetpath (names "/tp_pwm/elts[2H]/") (tstamps "/09150298/0e0a02eb/"))
   (tstamps "00730073"))
-(comp (ref "C67")
+(comp (ref "C66")
   (value "50V 150pF X7R ±10% 0603 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
   (footprint "Capacitor_SMD:C_0603_1608Metric")
   (property (name "Sheetname") (value "elts[2H]"))
   (property (name "Sheetfile") (value "edg.abstract_parts.PassiveFilters.DigitalLowPassRc"))
   (property (name "edg_path") (value "tp_pwm.elts[2H].rc.c"))
   (property (name "edg_short_path") (value "tp_pwm.elts[2H].c"))
-  (property (name "edg_refdes") (value "C67"))
+  (property (name "edg_refdes") (value "C66"))
   (property (name "edg_part") (value "0603B151K500NT (FH(Guangdong Fenghua Advanced Tech))"))
   (sheetpath (names "/tp_pwm/elts[2H]/") (tstamps "/09150298/0e0a02eb/"))
   (tstamps "00640064"))
@@ -1986,6 +1975,7 @@
   (node (ref C2) (pin 2))
   (node (ref U11) (pin 2))
   (node (ref U12) (pin 4))
+  (node (ref C39) (pin 2))
   (node (ref C40) (pin 2))
   (node (ref C41) (pin 2))
   (node (ref C42) (pin 2))
@@ -1993,11 +1983,11 @@
   (node (ref C44) (pin 2))
   (node (ref C45) (pin 2))
   (node (ref C46) (pin 2))
-  (node (ref C47) (pin 2))
   (node (ref R17) (pin 2))
   (node (ref R18) (pin 2))
   (node (ref R19) (pin 2))
   (node (ref R20) (pin 2))
+  (node (ref C47) (pin 2))
   (node (ref C48) (pin 2))
   (node (ref C49) (pin 2))
   (node (ref C50) (pin 2))
@@ -2005,11 +1995,10 @@
   (node (ref C52) (pin 2))
   (node (ref C53) (pin 2))
   (node (ref C54) (pin 2))
-  (node (ref C55) (pin 2))
   (node (ref U15) (pin 4))
+  (node (ref C56) (pin 2))
   (node (ref C57) (pin 2))
   (node (ref C58) (pin 2))
-  (node (ref C59) (pin 2))
   (node (ref X2) (pin 2))
   (node (ref X2) (pin 4))
   (node (ref R26) (pin 2))
@@ -2019,12 +2008,12 @@
   (node (ref R6) (pin 2))
   (node (ref U5) (pin 4))
   (node (ref U8) (pin 4))
+  (node (ref C61) (pin 2))
   (node (ref C62) (pin 2))
   (node (ref C63) (pin 2))
   (node (ref C64) (pin 2))
   (node (ref C65) (pin 2))
   (node (ref C66) (pin 2))
-  (node (ref C67) (pin 2))
   (node (ref R1) (pin 1))
   (node (ref R2) (pin 1))
   (node (ref Q2) (pin 1))
@@ -2036,19 +2025,19 @@
   (node (ref J6) (pin 3))
   (node (ref J6) (pin 5))
   (node (ref J6) (pin 9))
+  (node (ref C59) (pin 2))
   (node (ref C60) (pin 2))
-  (node (ref C61) (pin 2))
   (node (ref R3) (pin 1))
   (node (ref R4) (pin 1))
   (node (ref C3) (pin 2))
   (node (ref C4) (pin 2))
   (node (ref U3) (pin 4))
+  (node (ref C36) (pin 2))
   (node (ref C37) (pin 2))
   (node (ref C38) (pin 2))
-  (node (ref C39) (pin 2))
-  (node (ref C56) (pin 2))
-  (node (ref C19) (pin 2))
-  (node (ref C29) (pin 2))
+  (node (ref C55) (pin 2))
+  (node (ref C18) (pin 2))
+  (node (ref C28) (pin 2))
   (node (ref C5) (pin 2))
   (node (ref C6) (pin 2))
   (node (ref C7) (pin 2))
@@ -2057,8 +2046,7 @@
   (node (ref C10) (pin 2))
   (node (ref C11) (pin 2))
   (node (ref C12) (pin 2))
-  (node (ref C13) (pin 2))
-  (node (ref C14) (pin 2)))
+  (node (ref C13) (pin 2)))
 (net (code 3) (name "v3v3")
   (node (ref U1) (pin 2))
   (node (ref TP3) (pin 1))
@@ -2084,12 +2072,13 @@
   (node (ref U12) (pin 8))
   (node (ref J5) (pin 1))
   (node (ref R14) (pin 1))
+  (node (ref C39) (pin 1))
   (node (ref C40) (pin 1))
   (node (ref C41) (pin 1))
   (node (ref C42) (pin 1))
-  (node (ref C43) (pin 1))
-  (node (ref C47) (pin 1))
+  (node (ref C46) (pin 1))
   (node (ref J6) (pin 1))
+  (node (ref C47) (pin 1))
   (node (ref C48) (pin 1))
   (node (ref C49) (pin 1))
   (node (ref C50) (pin 1))
@@ -2097,25 +2086,24 @@
   (node (ref C52) (pin 1))
   (node (ref C53) (pin 1))
   (node (ref C54) (pin 1))
-  (node (ref C55) (pin 1))
   (node (ref U15) (pin 8))
   (node (ref U5) (pin 1))
   (node (ref U8) (pin 1))
   (node (ref U11) (pin 3))
   (node (ref U12) (pin 3))
   (node (ref U12) (pin 7))
-  (node (ref C37) (pin 1))
-  (node (ref C39) (pin 1))
-  (node (ref C56) (pin 1))
-  (node (ref C19) (pin 1))
-  (node (ref C29) (pin 1)))
+  (node (ref C36) (pin 1))
+  (node (ref C38) (pin 1))
+  (node (ref C55) (pin 1))
+  (node (ref C18) (pin 1))
+  (node (ref C28) (pin 1)))
 (net (code 4) (name "vgate")
   (node (ref TP4) (pin 1))
   (node (ref D2) (pin 1))
   (node (ref R5) (pin 1))
   (node (ref C4) (pin 1))
   (node (ref U3) (pin 1))
-  (node (ref C14) (pin 1))
+  (node (ref C13) (pin 1))
   (node (ref D4) (pin 2)))
 (net (code 5) (name "conv.pwr_in")
   (node (ref J3) (pin 2))
@@ -2136,8 +2124,7 @@
   (node (ref L2) (pin 2))
   (node (ref C10) (pin 1))
   (node (ref C11) (pin 1))
-  (node (ref C12) (pin 1))
-  (node (ref C13) (pin 1)))
+  (node (ref C12) (pin 1)))
 (net (code 7) (name "fpga.cdone")
   (node (ref U10) (pin 7))
   (node (ref D8) (pin 2)))
@@ -2247,27 +2234,27 @@
 (net (code 36) (name "tp_pwm.output.0L")
   (node (ref U3) (pin 3))
   (node (ref R30) (pin 2))
-  (node (ref C62) (pin 1)))
+  (node (ref C61) (pin 1)))
 (net (code 37) (name "tp_pwm.output.0H")
   (node (ref U3) (pin 2))
   (node (ref R31) (pin 2))
-  (node (ref C63) (pin 1)))
+  (node (ref C62) (pin 1)))
 (net (code 38) (name "tp_pwm.output.1L")
   (node (ref U5) (pin 3))
   (node (ref R32) (pin 2))
-  (node (ref C64) (pin 1)))
+  (node (ref C63) (pin 1)))
 (net (code 39) (name "tp_pwm.output.1H")
   (node (ref U5) (pin 2))
   (node (ref R33) (pin 2))
-  (node (ref C65) (pin 1)))
+  (node (ref C64) (pin 1)))
 (net (code 40) (name "tp_pwm.output.2L")
   (node (ref U8) (pin 3))
   (node (ref R34) (pin 2))
-  (node (ref C66) (pin 1)))
+  (node (ref C65) (pin 1)))
 (net (code 41) (name "tp_pwm.output.2H")
   (node (ref U8) (pin 2))
   (node (ref R35) (pin 2))
-  (node (ref C67) (pin 1)))
+  (node (ref C66) (pin 1)))
 (net (code 42) (name "conv_in_sense.output")
   (node (ref U14) (pin 38))
   (node (ref R36) (pin 2))
@@ -2304,35 +2291,35 @@
   (node (ref Q4) (pin 1))
   (node (ref Q4) (pin 2))
   (node (ref Q4) (pin 3))
-  (node (ref C26) (pin 2))
+  (node (ref C25) (pin 2))
   (node (ref U4) (pin 2))
   (node (ref U5) (pin 5))
   (node (ref U6) (pin 4))
+  (node (ref C22) (pin 2))
   (node (ref C23) (pin 2))
-  (node (ref C24) (pin 2))
+  (node (ref C16) (pin 2))
   (node (ref C17) (pin 2))
-  (node (ref C18) (pin 2))
-  (node (ref C20) (pin 2))
-  (node (ref C21) (pin 2)))
+  (node (ref C19) (pin 2))
+  (node (ref C20) (pin 2)))
 (net (code 51) (name "conv.sw[1].high_in")
   (node (ref Q3) (pin 5))
   (node (ref Q3) (pin 6))
   (node (ref Q3) (pin 7))
   (node (ref Q3) (pin 8))
+  (node (ref C22) (pin 1))
   (node (ref C23) (pin 1))
-  (node (ref C24) (pin 1))
   (node (ref Q1) (pin 1))
   (node (ref Q1) (pin 2))
   (node (ref Q1) (pin 3))
-  (node (ref C16) (pin 2))
+  (node (ref C15) (pin 2))
   (node (ref U3) (pin 6))
-  (node (ref C15) (pin 2)))
+  (node (ref C14) (pin 2)))
 (net (code 52) (name "conv.sw[1].high_boot_out")
   (node (ref D3) (pin 2))
-  (node (ref C25) (pin 1))
+  (node (ref C24) (pin 1))
   (node (ref D5) (pin 1))
   (node (ref U6) (pin 8))
-  (node (ref C22) (pin 1)))
+  (node (ref C21) (pin 1)))
 (net (code 53) (name "conv.sw[1].low_out")
   (node (ref Q4) (pin 5))
   (node (ref Q4) (pin 6))
@@ -2341,53 +2328,53 @@
   (node (ref Q6) (pin 1))
   (node (ref Q6) (pin 2))
   (node (ref Q6) (pin 3))
-  (node (ref C36) (pin 2))
+  (node (ref C35) (pin 2))
   (node (ref U7) (pin 2))
   (node (ref U8) (pin 5))
   (node (ref U9) (pin 4))
+  (node (ref C32) (pin 2))
   (node (ref C33) (pin 2))
-  (node (ref C34) (pin 2))
+  (node (ref C26) (pin 2))
   (node (ref C27) (pin 2))
-  (node (ref C28) (pin 2))
-  (node (ref C30) (pin 2))
-  (node (ref C31) (pin 2)))
+  (node (ref C29) (pin 2))
+  (node (ref C30) (pin 2)))
 (net (code 54) (name "conv.sw[2].high_in")
   (node (ref Q5) (pin 5))
   (node (ref Q5) (pin 6))
   (node (ref Q5) (pin 7))
   (node (ref Q5) (pin 8))
+  (node (ref C32) (pin 1))
   (node (ref C33) (pin 1))
-  (node (ref C34) (pin 1))
   (node (ref Q3) (pin 1))
   (node (ref Q3) (pin 2))
   (node (ref Q3) (pin 3))
-  (node (ref C25) (pin 2))
+  (node (ref C24) (pin 2))
   (node (ref U6) (pin 6))
-  (node (ref C22) (pin 2)))
+  (node (ref C21) (pin 2)))
 (net (code 55) (name "conv.sw[2].low_boot_in")
   (node (ref D6) (pin 2))
-  (node (ref C26) (pin 1))
+  (node (ref C25) (pin 1))
   (node (ref D4) (pin 1))
   (node (ref U4) (pin 1))
   (node (ref U6) (pin 1))
   (node (ref U4) (pin 3))
-  (node (ref C17) (pin 1))
-  (node (ref C21) (pin 1)))
+  (node (ref C16) (pin 1))
+  (node (ref C20) (pin 1)))
 (net (code 56) (name "conv.sw[2].high_boot_out")
   (node (ref D5) (pin 2))
-  (node (ref C35) (pin 1))
+  (node (ref C34) (pin 1))
   (node (ref D7) (pin 1))
   (node (ref U9) (pin 8))
-  (node (ref C32) (pin 1)))
+  (node (ref C31) (pin 1)))
 (net (code 57) (name "conv.sw[2].low_boot_out")
   (node (ref D7) (pin 2))
-  (node (ref C36) (pin 1))
+  (node (ref C35) (pin 1))
   (node (ref D6) (pin 1))
   (node (ref U7) (pin 1))
   (node (ref U9) (pin 1))
   (node (ref U7) (pin 3))
-  (node (ref C27) (pin 1))
-  (node (ref C31) (pin 1)))
+  (node (ref C26) (pin 1))
+  (node (ref C30) (pin 1)))
 (net (code 58) (name "conv.sw_merge")
   (node (ref Q6) (pin 5))
   (node (ref Q6) (pin 6))
@@ -2397,9 +2384,9 @@
   (node (ref Q5) (pin 1))
   (node (ref Q5) (pin 2))
   (node (ref Q5) (pin 3))
-  (node (ref C35) (pin 2))
+  (node (ref C34) (pin 2))
   (node (ref U9) (pin 6))
-  (node (ref C32) (pin 2)))
+  (node (ref C31) (pin 2)))
 (net (code 59) (name "conv.sw[0].high_gate_res.a")
   (node (ref R7) (pin 1))
   (node (ref U3) (pin 7)))
@@ -2413,15 +2400,15 @@
   (node (ref R8) (pin 2))
   (node (ref Q2) (pin 4)))
 (net (code 63) (name "conv.sw[0].high_boot_cap.pos")
-  (node (ref C16) (pin 1))
+  (node (ref C15) (pin 1))
   (node (ref D3) (pin 1))
   (node (ref U3) (pin 8))
-  (node (ref C15) (pin 1)))
+  (node (ref C14) (pin 1)))
 (net (code 64) (name "conv.sw[1].iso.pwr_b")
   (node (ref U5) (pin 8))
   (node (ref U4) (pin 5))
-  (node (ref C20) (pin 1))
-  (node (ref C18) (pin 1)))
+  (node (ref C19) (pin 1))
+  (node (ref C17) (pin 1)))
 (net (code 65) (name "conv.sw[1].driver.high_in")
   (node (ref U6) (pin 2))
   (node (ref U5) (pin 7)))
@@ -2443,8 +2430,8 @@
 (net (code 71) (name "conv.sw[2].iso.pwr_b")
   (node (ref U8) (pin 8))
   (node (ref U7) (pin 5))
-  (node (ref C30) (pin 1))
-  (node (ref C28) (pin 1)))
+  (node (ref C29) (pin 1))
+  (node (ref C27) (pin 1)))
 (net (code 72) (name "conv.sw[2].driver.high_in")
   (node (ref U9) (pin 2))
   (node (ref U8) (pin 7)))
@@ -2492,13 +2479,13 @@
   (node (ref U10) (pin 30))
   (node (ref U11) (pin 5))
   (node (ref R15) (pin 1))
-  (node (ref C44) (pin 1))
-  (node (ref C38) (pin 1)))
+  (node (ref C43) (pin 1))
+  (node (ref C37) (pin 1)))
 (net (code 85) (name "fpga.pll_res.pwr_out")
   (node (ref U10) (pin 29))
   (node (ref R15) (pin 2))
-  (node (ref C45) (pin 1))
-  (node (ref C46) (pin 1)))
+  (node (ref C44) (pin 1))
+  (node (ref C45) (pin 1)))
 (net (code 86) (name "cdone.res.a")
   (node (ref R16) (pin 1))
   (node (ref D8) (pin 1)))
@@ -2517,11 +2504,11 @@
 (net (code 91) (name "mcu.xtal_node.xi")
   (node (ref U14) (pin 20))
   (node (ref X2) (pin 1))
-  (node (ref C60) (pin 1)))
+  (node (ref C59) (pin 1)))
 (net (code 92) (name "mcu.xtal_node.xo")
   (node (ref U14) (pin 21))
   (node (ref X2) (pin 3))
-  (node (ref C61) (pin 1)))
+  (node (ref C60) (pin 1)))
 (net (code 93) (name "mcu.swd_node.swdio")
   (node (ref U14) (pin 25))
   (node (ref J6) (pin 2)))
@@ -2553,9 +2540,9 @@
   (node (ref U14) (pin 45))
   (node (ref U14) (pin 23))
   (node (ref U14) (pin 50))
+  (node (ref C56) (pin 1))
   (node (ref C57) (pin 1))
-  (node (ref C58) (pin 1))
-  (node (ref C59) (pin 1)))
+  (node (ref C58) (pin 1)))
 (net (code 103) (name "mcu.usb_chain_0.d_P")
   (node (ref U14) (pin 47))
   (node (ref R24) (pin 1)))
diff --git a/examples/IotDisplay/IotDisplay.net b/examples/IotDisplay/IotDisplay.net
index e4e873dea..14c2fbdbf 100644
--- a/examples/IotDisplay/IotDisplay.net
+++ b/examples/IotDisplay/IotDisplay.net
@@ -144,14 +144,14 @@
   (sheetpath (names "/reg_3v3/") (tstamps "/0aba027a/"))
   (tstamps "0ed60348"))
 (comp (ref "reg_3v3.power_path.inductor")
-  (value "840mA 33uH ±20% 429mΩ SMD Power Inductors ROHS")
+  (value "1.11A 15uH ±20% 247mΩ SMD Power Inductors ROHS")
   (footprint "Inductor_SMD:L_Sunlord_SWPA4030S")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg_3v3.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_3v3.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA4030S330MT (Sunlord)"))
+  (property (name "edg_part") (value "SWPA4030S150MT (Sunlord)"))
   (sheetpath (names "/reg_3v3/power_path/") (tstamps "/0aba027a/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg_3v3.power_path.in_cap")
diff --git a/examples/IotDisplay/IotDisplay.ref.net b/examples/IotDisplay/IotDisplay.ref.net
index 868f5ce28..5ba2bd2bf 100644
--- a/examples/IotDisplay/IotDisplay.ref.net
+++ b/examples/IotDisplay/IotDisplay.ref.net
@@ -144,14 +144,14 @@
   (sheetpath (names "/reg_3v3/") (tstamps "/0aba027a/"))
   (tstamps "0ed60348"))
 (comp (ref "L1")
-  (value "840mA 33uH ±20% 429mΩ SMD Power Inductors ROHS")
+  (value "1.11A 15uH ±20% 247mΩ SMD Power Inductors ROHS")
   (footprint "Inductor_SMD:L_Sunlord_SWPA4030S")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg_3v3.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_3v3.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA4030S330MT (Sunlord)"))
+  (property (name "edg_part") (value "SWPA4030S150MT (Sunlord)"))
   (sheetpath (names "/reg_3v3/power_path/") (tstamps "/0aba027a/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C3")
diff --git a/examples/IotFan/IotFan.net b/examples/IotFan/IotFan.net
index b0a94edf2..92afdd74b 100644
--- a/examples/IotFan/IotFan.net
+++ b/examples/IotFan/IotFan.net
@@ -122,14 +122,14 @@
   (sheetpath (names "/reg_5v/") (tstamps "/08440249/"))
   (tstamps "0ed60348"))
 (comp (ref "reg_5v.power_path.inductor")
-  (value "1.4A 22uH ±20% 126mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Taiyo-Yuden_NR-50xx")
+  (value "1.11A 15uH ±20% 247mΩ SMD Power Inductors ROHS")
+  (footprint "Inductor_SMD:L_Sunlord_SWPA4030S")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg_5v.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_5v.power_path.inductor"))
   (property (name "edg_refdes") (value "FL1"))
-  (property (name "edg_part") (value "NR5040T220M (Taiyo Yuden)"))
+  (property (name "edg_part") (value "SWPA4030S150MT (Sunlord)"))
   (sheetpath (names "/reg_5v/power_path/") (tstamps "/08440249/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg_5v.power_path.in_cap")
diff --git a/examples/IotFan/IotFan.ref.net b/examples/IotFan/IotFan.ref.net
index 999968fd6..99e0ad6b5 100644
--- a/examples/IotFan/IotFan.ref.net
+++ b/examples/IotFan/IotFan.ref.net
@@ -122,14 +122,14 @@
   (sheetpath (names "/reg_5v/") (tstamps "/08440249/"))
   (tstamps "0ed60348"))
 (comp (ref "FL1")
-  (value "1.4A 22uH ±20% 126mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Taiyo-Yuden_NR-50xx")
+  (value "1.11A 15uH ±20% 247mΩ SMD Power Inductors ROHS")
+  (footprint "Inductor_SMD:L_Sunlord_SWPA4030S")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg_5v.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_5v.power_path.inductor"))
   (property (name "edg_refdes") (value "FL1"))
-  (property (name "edg_part") (value "NR5040T220M (Taiyo Yuden)"))
+  (property (name "edg_part") (value "SWPA4030S150MT (Sunlord)"))
   (sheetpath (names "/reg_5v/power_path/") (tstamps "/08440249/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "FC3")
diff --git a/examples/IotIron/IotIron.net b/examples/IotIron/IotIron.net
index 365f4a482..27f167d92 100644
--- a/examples/IotIron/IotIron.net
+++ b/examples/IotIron/IotIron.net
@@ -595,14 +595,14 @@
   (sheetpath (names "/ledr/") (tstamps "/041d01a8/"))
   (tstamps "0296014b"))
 (comp (ref "conv.power_path.inductor")
-  (value "4.2A 15uH ±20% 28.4mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_TDK_SLF12565")
+  (value "4.7A 15uH ±20% 22.1mΩ SMD,12.5x12.5x7.5mm Power Inductors ROHS")
+  (footprint "Inductor_SMD:L_TDK_SLF12575")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "conv.power_path.inductor"))
   (property (name "edg_short_path") (value "conv.power_path.inductor"))
   (property (name "edg_refdes") (value "IL2"))
-  (property (name "edg_part") (value "SLF12565T-150M4R2-PF (TDK)"))
+  (property (name "edg_part") (value "SLF12575T-150M4R7-PF (TDK)"))
   (sheetpath (names "/conv/power_path/") (tstamps "/042f01b7/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "conv.power_path.in_cap.c[0]")
diff --git a/examples/IotIron/IotIron.ref.net b/examples/IotIron/IotIron.ref.net
index 3d200d3f1..00156dea4 100644
--- a/examples/IotIron/IotIron.ref.net
+++ b/examples/IotIron/IotIron.ref.net
@@ -595,14 +595,14 @@
   (sheetpath (names "/ledr/") (tstamps "/041d01a8/"))
   (tstamps "0296014b"))
 (comp (ref "IL2")
-  (value "4.2A 15uH ±20% 28.4mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_TDK_SLF12565")
+  (value "4.7A 15uH ±20% 22.1mΩ SMD,12.5x12.5x7.5mm Power Inductors ROHS")
+  (footprint "Inductor_SMD:L_TDK_SLF12575")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "conv.power_path.inductor"))
   (property (name "edg_short_path") (value "conv.power_path.inductor"))
   (property (name "edg_refdes") (value "IL2"))
-  (property (name "edg_part") (value "SLF12565T-150M4R2-PF (TDK)"))
+  (property (name "edg_part") (value "SLF12575T-150M4R7-PF (TDK)"))
   (sheetpath (names "/conv/power_path/") (tstamps "/042f01b7/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "IC22")
diff --git a/examples/IotLedDriver/IotLedDriver.net b/examples/IotLedDriver/IotLedDriver.net
index cd95d48a6..55b96099a 100644
--- a/examples/IotLedDriver/IotLedDriver.net
+++ b/examples/IotLedDriver/IotLedDriver.net
@@ -122,14 +122,14 @@
   (sheetpath (names "/reg_5v/") (tstamps "/08440249/"))
   (tstamps "0ed60348"))
 (comp (ref "reg_5v.power_path.inductor")
-  (value "1.4A 22uH ±20% 126mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Taiyo-Yuden_NR-50xx")
+  (value "1.11A 15uH ±20% 247mΩ SMD Power Inductors ROHS")
+  (footprint "Inductor_SMD:L_Sunlord_SWPA4030S")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg_5v.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_5v.power_path.inductor"))
   (property (name "edg_refdes") (value "LL1"))
-  (property (name "edg_part") (value "NR5040T220M (Taiyo Yuden)"))
+  (property (name "edg_part") (value "SWPA4030S150MT (Sunlord)"))
   (sheetpath (names "/reg_5v/power_path/") (tstamps "/08440249/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg_5v.power_path.in_cap")
diff --git a/examples/IotLedDriver/IotLedDriver.ref.net b/examples/IotLedDriver/IotLedDriver.ref.net
index 434ee0f5d..465a994ec 100644
--- a/examples/IotLedDriver/IotLedDriver.ref.net
+++ b/examples/IotLedDriver/IotLedDriver.ref.net
@@ -122,14 +122,14 @@
   (sheetpath (names "/reg_5v/") (tstamps "/08440249/"))
   (tstamps "0ed60348"))
 (comp (ref "LL1")
-  (value "1.4A 22uH ±20% 126mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Taiyo-Yuden_NR-50xx")
+  (value "1.11A 15uH ±20% 247mΩ SMD Power Inductors ROHS")
+  (footprint "Inductor_SMD:L_Sunlord_SWPA4030S")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg_5v.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_5v.power_path.inductor"))
   (property (name "edg_refdes") (value "LL1"))
-  (property (name "edg_part") (value "NR5040T220M (Taiyo Yuden)"))
+  (property (name "edg_part") (value "SWPA4030S150MT (Sunlord)"))
   (sheetpath (names "/reg_5v/power_path/") (tstamps "/08440249/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "LC3")
diff --git a/examples/Multimeter/Multimeter.net b/examples/Multimeter/Multimeter.net
index d93b439fd..4c4b5ca72 100644
--- a/examples/Multimeter/Multimeter.net
+++ b/examples/Multimeter/Multimeter.net
@@ -166,14 +166,14 @@
   (sheetpath (names "/reg_5v/") (tstamps "/08440249/"))
   (tstamps "013700cd"))
 (comp (ref "reg_5v.power_path.inductor")
-  (value "900mA 10uH ±10% 172.9mΩ 1210 Inductors (SMD) ROHS")
-  (footprint "Inductor_SMD:L_1210_3225Metric")
+  (value "800mA 4.7uH ±20% 250mΩ 0603 Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0603_1608Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BoostConverterPowerPath"))
   (property (name "edg_path") (value "reg_5v.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_5v.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "CBC3225T100KR (Taiyo Yuden)"))
+  (property (name "edg_part") (value "CPY160808T-4R7M-NP (Chilisin Elec)"))
   (sheetpath (names "/reg_5v/power_path/") (tstamps "/08440249/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg_5v.power_path.in_cap")
diff --git a/examples/Multimeter/Multimeter.ref.net b/examples/Multimeter/Multimeter.ref.net
index 17738ad7f..30ce6083e 100644
--- a/examples/Multimeter/Multimeter.ref.net
+++ b/examples/Multimeter/Multimeter.ref.net
@@ -166,14 +166,14 @@
   (sheetpath (names "/reg_5v/") (tstamps "/08440249/"))
   (tstamps "013700cd"))
 (comp (ref "L1")
-  (value "900mA 10uH ±10% 172.9mΩ 1210 Inductors (SMD) ROHS")
-  (footprint "Inductor_SMD:L_1210_3225Metric")
+  (value "800mA 4.7uH ±20% 250mΩ 0603 Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0603_1608Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BoostConverterPowerPath"))
   (property (name "edg_path") (value "reg_5v.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_5v.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "CBC3225T100KR (Taiyo Yuden)"))
+  (property (name "edg_part") (value "CPY160808T-4R7M-NP (Chilisin Elec)"))
   (sheetpath (names "/reg_5v/power_path/") (tstamps "/08440249/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C1")
diff --git a/examples/RobotDriver/RobotDriver.net b/examples/RobotDriver/RobotDriver.net
index 587d1c5ab..121ae77a6 100644
--- a/examples/RobotDriver/RobotDriver.net
+++ b/examples/RobotDriver/RobotDriver.net
@@ -177,14 +177,14 @@
   (sheetpath (names "/reg_3v3/fb/") (tstamps "/0aba027a/013000c9/"))
   (tstamps "175b043f"))
 (comp (ref "reg_3v3.power_path.inductor")
-  (value "800mA 4.7uH ±20% 250mΩ 0603 Inductors (SMD) ROHS")
+  (value "750mA 2.2uH ±20% 240mΩ 0603 Power Inductors ROHS")
   (footprint "Inductor_SMD:L_0603_1608Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg_3v3.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_3v3.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "CPY160808T-4R7M-NP (Chilisin Elec)"))
+  (property (name "edg_part") (value "CMH160808B2R2MT (FH(Guangdong Fenghua Advanced Tech))"))
   (sheetpath (names "/reg_3v3/power_path/") (tstamps "/0aba027a/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg_3v3.power_path.in_cap")
diff --git a/examples/RobotDriver/RobotDriver.ref.net b/examples/RobotDriver/RobotDriver.ref.net
index 15e587794..1f8251805 100644
--- a/examples/RobotDriver/RobotDriver.ref.net
+++ b/examples/RobotDriver/RobotDriver.ref.net
@@ -177,14 +177,14 @@
   (sheetpath (names "/reg_3v3/fb/") (tstamps "/0aba027a/013000c9/"))
   (tstamps "175b043f"))
 (comp (ref "L1")
-  (value "800mA 4.7uH ±20% 250mΩ 0603 Inductors (SMD) ROHS")
+  (value "750mA 2.2uH ±20% 240mΩ 0603 Power Inductors ROHS")
   (footprint "Inductor_SMD:L_0603_1608Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg_3v3.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_3v3.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "CPY160808T-4R7M-NP (Chilisin Elec)"))
+  (property (name "edg_part") (value "CMH160808B2R2MT (FH(Guangdong Fenghua Advanced Tech))"))
   (sheetpath (names "/reg_3v3/power_path/") (tstamps "/0aba027a/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C2")
diff --git a/examples/Simon/Simon.net b/examples/Simon/Simon.net
index c88a1ab8d..f12136a0e 100644
--- a/examples/Simon/Simon.net
+++ b/examples/Simon/Simon.net
@@ -276,14 +276,14 @@
   (sheetpath (names "/pwr/fb/") (tstamps "/02b3015a/013000c9/"))
   (tstamps "175b043f"))
 (comp (ref "pwr.power_path.inductor")
-  (value "250mA 33uH ±10% 800mΩ 1210 Inductors (SMD) ROHS")
-  (footprint "Inductor_SMD:L_1210_3225Metric")
+  (value "300mA 22uH ±20% 700mΩ 0805 Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BoostConverterPowerPath"))
   (property (name "edg_path") (value "pwr.power_path.inductor"))
   (property (name "edg_short_path") (value "pwr.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "CMI322513J330KT (FH(Guangdong Fenghua Advanced Tech))"))
+  (property (name "edg_part") (value "MGFL2012F220MT-LF (microgate)"))
   (sheetpath (names "/pwr/power_path/") (tstamps "/02b3015a/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "pwr.power_path.in_cap")
diff --git a/examples/Simon/Simon.ref.net b/examples/Simon/Simon.ref.net
index e0f630163..5a8b95b30 100644
--- a/examples/Simon/Simon.ref.net
+++ b/examples/Simon/Simon.ref.net
@@ -276,14 +276,14 @@
   (sheetpath (names "/pwr/fb/") (tstamps "/02b3015a/013000c9/"))
   (tstamps "175b043f"))
 (comp (ref "L1")
-  (value "250mA 33uH ±10% 800mΩ 1210 Inductors (SMD) ROHS")
-  (footprint "Inductor_SMD:L_1210_3225Metric")
+  (value "300mA 22uH ±20% 700mΩ 0805 Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BoostConverterPowerPath"))
   (property (name "edg_path") (value "pwr.power_path.inductor"))
   (property (name "edg_short_path") (value "pwr.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "CMI322513J330KT (FH(Guangdong Fenghua Advanced Tech))"))
+  (property (name "edg_part") (value "MGFL2012F220MT-LF (microgate)"))
   (sheetpath (names "/pwr/power_path/") (tstamps "/02b3015a/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C4")
diff --git a/examples/TestBlinkyArray/TestBlinkyArray.net b/examples/TestBlinkyArray/TestBlinkyArray.net
index fa14fb3dd..95be5a494 100644
--- a/examples/TestBlinkyArray/TestBlinkyArray.net
+++ b/examples/TestBlinkyArray/TestBlinkyArray.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "reg.power_path.inductor")
-  (value "530mA 22uH ±20% 839mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Sunlord_SWPA3012S")
+  (value "1A 10uH ±20% 375mΩ SMD,2.0x1.25x1.45mm Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA3012S220MT (Sunlord)"))
+  (property (name "edg_part") (value "MPH201214S100MT (Sunlord)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg.power_path.in_cap")
diff --git a/examples/TestBlinkyArray/TestBlinkyArray.ref.net b/examples/TestBlinkyArray/TestBlinkyArray.ref.net
index 7c041f5db..af942a034 100644
--- a/examples/TestBlinkyArray/TestBlinkyArray.ref.net
+++ b/examples/TestBlinkyArray/TestBlinkyArray.ref.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "L1")
-  (value "530mA 22uH ±20% 839mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Sunlord_SWPA3012S")
+  (value "1A 10uH ±20% 375mΩ SMD,2.0x1.25x1.45mm Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA3012S220MT (Sunlord)"))
+  (property (name "edg_part") (value "MPH201214S100MT (Sunlord)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C3")
diff --git a/examples/TestBlinkyChain/TestBlinkyChain.net b/examples/TestBlinkyChain/TestBlinkyChain.net
index dfdceca54..462a041cb 100644
--- a/examples/TestBlinkyChain/TestBlinkyChain.net
+++ b/examples/TestBlinkyChain/TestBlinkyChain.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "reg.power_path.inductor")
-  (value "220mA 15uH ±20% 900mΩ 0603 Inductors (SMD) ROHS")
+  (value "400mA 6.8uH ±20% 530mΩ 0603 Inductors (SMD) ROHS")
   (footprint "Inductor_SMD:L_0603_1608Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "MGFL1608F150MT-LF (microgate)"))
+  (property (name "edg_part") (value "MGFL1608F6R8MT-LF (microgate)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg.power_path.in_cap")
diff --git a/examples/TestBlinkyChain/TestBlinkyChain.ref.net b/examples/TestBlinkyChain/TestBlinkyChain.ref.net
index 3210ad798..c0641d326 100644
--- a/examples/TestBlinkyChain/TestBlinkyChain.ref.net
+++ b/examples/TestBlinkyChain/TestBlinkyChain.ref.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "L1")
-  (value "220mA 15uH ±20% 900mΩ 0603 Inductors (SMD) ROHS")
+  (value "400mA 6.8uH ±20% 530mΩ 0603 Inductors (SMD) ROHS")
   (footprint "Inductor_SMD:L_0603_1608Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "MGFL1608F150MT-LF (microgate)"))
+  (property (name "edg_part") (value "MGFL1608F6R8MT-LF (microgate)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C3")
diff --git a/examples/TestBlinkyComplete/TestBlinkyComplete.net b/examples/TestBlinkyComplete/TestBlinkyComplete.net
index e1c544453..b5e1d43ff 100644
--- a/examples/TestBlinkyComplete/TestBlinkyComplete.net
+++ b/examples/TestBlinkyComplete/TestBlinkyComplete.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "reg.power_path.inductor")
-  (value "220mA 15uH ±20% 900mΩ 0603 Inductors (SMD) ROHS")
+  (value "400mA 6.8uH ±20% 530mΩ 0603 Inductors (SMD) ROHS")
   (footprint "Inductor_SMD:L_0603_1608Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "MGFL1608F150MT-LF (microgate)"))
+  (property (name "edg_part") (value "MGFL1608F6R8MT-LF (microgate)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg.power_path.in_cap")
diff --git a/examples/TestBlinkyComplete/TestBlinkyComplete.ref.net b/examples/TestBlinkyComplete/TestBlinkyComplete.ref.net
index 7db6f0466..f5546a6fa 100644
--- a/examples/TestBlinkyComplete/TestBlinkyComplete.ref.net
+++ b/examples/TestBlinkyComplete/TestBlinkyComplete.ref.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "L1")
-  (value "220mA 15uH ±20% 900mΩ 0603 Inductors (SMD) ROHS")
+  (value "400mA 6.8uH ±20% 530mΩ 0603 Inductors (SMD) ROHS")
   (footprint "Inductor_SMD:L_0603_1608Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "MGFL1608F150MT-LF (microgate)"))
+  (property (name "edg_part") (value "MGFL1608F6R8MT-LF (microgate)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C3")
diff --git a/examples/TestBlinkyExpanded/TestBlinkyExpanded.net b/examples/TestBlinkyExpanded/TestBlinkyExpanded.net
index dfdceca54..462a041cb 100644
--- a/examples/TestBlinkyExpanded/TestBlinkyExpanded.net
+++ b/examples/TestBlinkyExpanded/TestBlinkyExpanded.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "reg.power_path.inductor")
-  (value "220mA 15uH ±20% 900mΩ 0603 Inductors (SMD) ROHS")
+  (value "400mA 6.8uH ±20% 530mΩ 0603 Inductors (SMD) ROHS")
   (footprint "Inductor_SMD:L_0603_1608Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "MGFL1608F150MT-LF (microgate)"))
+  (property (name "edg_part") (value "MGFL1608F6R8MT-LF (microgate)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg.power_path.in_cap")
diff --git a/examples/TestBlinkyExpanded/TestBlinkyExpanded.ref.net b/examples/TestBlinkyExpanded/TestBlinkyExpanded.ref.net
index 3210ad798..c0641d326 100644
--- a/examples/TestBlinkyExpanded/TestBlinkyExpanded.ref.net
+++ b/examples/TestBlinkyExpanded/TestBlinkyExpanded.ref.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "L1")
-  (value "220mA 15uH ±20% 900mΩ 0603 Inductors (SMD) ROHS")
+  (value "400mA 6.8uH ±20% 530mΩ 0603 Inductors (SMD) ROHS")
   (footprint "Inductor_SMD:L_0603_1608Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "MGFL1608F150MT-LF (microgate)"))
+  (property (name "edg_part") (value "MGFL1608F6R8MT-LF (microgate)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C3")
diff --git a/examples/TestBlinkyImplicit/TestBlinkyImplicit.net b/examples/TestBlinkyImplicit/TestBlinkyImplicit.net
index dfdceca54..462a041cb 100644
--- a/examples/TestBlinkyImplicit/TestBlinkyImplicit.net
+++ b/examples/TestBlinkyImplicit/TestBlinkyImplicit.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "reg.power_path.inductor")
-  (value "220mA 15uH ±20% 900mΩ 0603 Inductors (SMD) ROHS")
+  (value "400mA 6.8uH ±20% 530mΩ 0603 Inductors (SMD) ROHS")
   (footprint "Inductor_SMD:L_0603_1608Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "MGFL1608F150MT-LF (microgate)"))
+  (property (name "edg_part") (value "MGFL1608F6R8MT-LF (microgate)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg.power_path.in_cap")
diff --git a/examples/TestBlinkyImplicit/TestBlinkyImplicit.ref.net b/examples/TestBlinkyImplicit/TestBlinkyImplicit.ref.net
index 3210ad798..c0641d326 100644
--- a/examples/TestBlinkyImplicit/TestBlinkyImplicit.ref.net
+++ b/examples/TestBlinkyImplicit/TestBlinkyImplicit.ref.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "L1")
-  (value "220mA 15uH ±20% 900mΩ 0603 Inductors (SMD) ROHS")
+  (value "400mA 6.8uH ±20% 530mΩ 0603 Inductors (SMD) ROHS")
   (footprint "Inductor_SMD:L_0603_1608Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "MGFL1608F150MT-LF (microgate)"))
+  (property (name "edg_part") (value "MGFL1608F6R8MT-LF (microgate)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C3")
diff --git a/examples/TestBlinkyMicro/TestBlinkyMicro.net b/examples/TestBlinkyMicro/TestBlinkyMicro.net
index 7ae1c53a9..83b98025c 100644
--- a/examples/TestBlinkyMicro/TestBlinkyMicro.net
+++ b/examples/TestBlinkyMicro/TestBlinkyMicro.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "reg.power_path.inductor")
-  (value "530mA 22uH ±20% 839mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Sunlord_SWPA3012S")
+  (value "1A 10uH ±20% 375mΩ SMD,2.0x1.25x1.45mm Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA3012S220MT (Sunlord)"))
+  (property (name "edg_part") (value "MPH201214S100MT (Sunlord)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg.power_path.in_cap")
diff --git a/examples/TestBlinkyMicro/TestBlinkyMicro.ref.net b/examples/TestBlinkyMicro/TestBlinkyMicro.ref.net
index 12cd39f86..9661e2a7b 100644
--- a/examples/TestBlinkyMicro/TestBlinkyMicro.ref.net
+++ b/examples/TestBlinkyMicro/TestBlinkyMicro.ref.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "L1")
-  (value "530mA 22uH ±20% 839mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Sunlord_SWPA3012S")
+  (value "1A 10uH ±20% 375mΩ SMD,2.0x1.25x1.45mm Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA3012S220MT (Sunlord)"))
+  (property (name "edg_part") (value "MPH201214S100MT (Sunlord)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C3")
diff --git a/examples/TestBlinkyPacked/TestBlinkyPacked.net b/examples/TestBlinkyPacked/TestBlinkyPacked.net
index 7a739b77b..69ed64f79 100644
--- a/examples/TestBlinkyPacked/TestBlinkyPacked.net
+++ b/examples/TestBlinkyPacked/TestBlinkyPacked.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "reg.power_path.inductor")
-  (value "530mA 22uH ±20% 839mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Sunlord_SWPA3012S")
+  (value "1A 10uH ±20% 375mΩ SMD,2.0x1.25x1.45mm Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA3012S220MT (Sunlord)"))
+  (property (name "edg_part") (value "MPH201214S100MT (Sunlord)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg.power_path.in_cap")
diff --git a/examples/TestBlinkyPacked/TestBlinkyPacked.ref.net b/examples/TestBlinkyPacked/TestBlinkyPacked.ref.net
index 0167b4147..816c2885a 100644
--- a/examples/TestBlinkyPacked/TestBlinkyPacked.ref.net
+++ b/examples/TestBlinkyPacked/TestBlinkyPacked.ref.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "L1")
-  (value "530mA 22uH ±20% 839mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Sunlord_SWPA3012S")
+  (value "1A 10uH ±20% 375mΩ SMD,2.0x1.25x1.45mm Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA3012S220MT (Sunlord)"))
+  (property (name "edg_part") (value "MPH201214S100MT (Sunlord)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C3")
diff --git a/examples/TestBlinkyWithLibrary/TestBlinkyWithLibrary.net b/examples/TestBlinkyWithLibrary/TestBlinkyWithLibrary.net
index bf2eeef31..cff35aaab 100644
--- a/examples/TestBlinkyWithLibrary/TestBlinkyWithLibrary.net
+++ b/examples/TestBlinkyWithLibrary/TestBlinkyWithLibrary.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "reg.power_path.inductor")
-  (value "530mA 22uH ±20% 839mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Sunlord_SWPA3012S")
+  (value "1A 10uH ±20% 375mΩ SMD,2.0x1.25x1.45mm Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA3012S220MT (Sunlord)"))
+  (property (name "edg_part") (value "MPH201214S100MT (Sunlord)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg.power_path.in_cap")
diff --git a/examples/TestBlinkyWithLibrary/TestBlinkyWithLibrary.ref.net b/examples/TestBlinkyWithLibrary/TestBlinkyWithLibrary.ref.net
index 457c36bb6..2bf6eeb12 100644
--- a/examples/TestBlinkyWithLibrary/TestBlinkyWithLibrary.ref.net
+++ b/examples/TestBlinkyWithLibrary/TestBlinkyWithLibrary.ref.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "L1")
-  (value "530mA 22uH ±20% 839mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Sunlord_SWPA3012S")
+  (value "1A 10uH ±20% 375mΩ SMD,2.0x1.25x1.45mm Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA3012S220MT (Sunlord)"))
+  (property (name "edg_part") (value "MPH201214S100MT (Sunlord)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C3")
diff --git a/examples/TestBlinkyWithLibraryExport/TestBlinkyWithLibraryExport.net b/examples/TestBlinkyWithLibraryExport/TestBlinkyWithLibraryExport.net
index f53dc1d23..bfba535ab 100644
--- a/examples/TestBlinkyWithLibraryExport/TestBlinkyWithLibraryExport.net
+++ b/examples/TestBlinkyWithLibraryExport/TestBlinkyWithLibraryExport.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "reg.power_path.inductor")
-  (value "530mA 22uH ±20% 839mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Sunlord_SWPA3012S")
+  (value "1A 10uH ±20% 375mΩ SMD,2.0x1.25x1.45mm Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA3012S220MT (Sunlord)"))
+  (property (name "edg_part") (value "MPH201214S100MT (Sunlord)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg.power_path.in_cap")
diff --git a/examples/TestBlinkyWithLibraryExport/TestBlinkyWithLibraryExport.ref.net b/examples/TestBlinkyWithLibraryExport/TestBlinkyWithLibraryExport.ref.net
index c11a1d7f8..57c320ea8 100644
--- a/examples/TestBlinkyWithLibraryExport/TestBlinkyWithLibraryExport.ref.net
+++ b/examples/TestBlinkyWithLibraryExport/TestBlinkyWithLibraryExport.ref.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "L1")
-  (value "530mA 22uH ±20% 839mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Sunlord_SWPA3012S")
+  (value "1A 10uH ±20% 375mΩ SMD,2.0x1.25x1.45mm Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA3012S220MT (Sunlord)"))
+  (property (name "edg_part") (value "MPH201214S100MT (Sunlord)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C3")
diff --git a/examples/TestBlinkyWithModeledSchematicImport/TestBlinkyWithModeledSchematicImport.net b/examples/TestBlinkyWithModeledSchematicImport/TestBlinkyWithModeledSchematicImport.net
index 580533935..d2800888e 100644
--- a/examples/TestBlinkyWithModeledSchematicImport/TestBlinkyWithModeledSchematicImport.net
+++ b/examples/TestBlinkyWithModeledSchematicImport/TestBlinkyWithModeledSchematicImport.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "reg.power_path.inductor")
-  (value "530mA 22uH ±20% 839mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Sunlord_SWPA3012S")
+  (value "1A 10uH ±20% 375mΩ SMD,2.0x1.25x1.45mm Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA3012S220MT (Sunlord)"))
+  (property (name "edg_part") (value "MPH201214S100MT (Sunlord)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg.power_path.in_cap")
diff --git a/examples/TestBlinkyWithModeledSchematicImport/TestBlinkyWithModeledSchematicImport.ref.net b/examples/TestBlinkyWithModeledSchematicImport/TestBlinkyWithModeledSchematicImport.ref.net
index a6cbb2715..5827203dc 100644
--- a/examples/TestBlinkyWithModeledSchematicImport/TestBlinkyWithModeledSchematicImport.ref.net
+++ b/examples/TestBlinkyWithModeledSchematicImport/TestBlinkyWithModeledSchematicImport.ref.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "L1")
-  (value "530mA 22uH ±20% 839mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Sunlord_SWPA3012S")
+  (value "1A 10uH ±20% 375mΩ SMD,2.0x1.25x1.45mm Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA3012S220MT (Sunlord)"))
+  (property (name "edg_part") (value "MPH201214S100MT (Sunlord)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C3")
diff --git a/examples/TestBlinkyWithSchematicImport/TestBlinkyWithSchematicImport.net b/examples/TestBlinkyWithSchematicImport/TestBlinkyWithSchematicImport.net
index 4c26c61ea..bd6b0a7ab 100644
--- a/examples/TestBlinkyWithSchematicImport/TestBlinkyWithSchematicImport.net
+++ b/examples/TestBlinkyWithSchematicImport/TestBlinkyWithSchematicImport.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "reg.power_path.inductor")
-  (value "530mA 22uH ±20% 839mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Sunlord_SWPA3012S")
+  (value "1A 10uH ±20% 375mΩ SMD,2.0x1.25x1.45mm Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA3012S220MT (Sunlord)"))
+  (property (name "edg_part") (value "MPH201214S100MT (Sunlord)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg.power_path.in_cap")
diff --git a/examples/TestBlinkyWithSchematicImport/TestBlinkyWithSchematicImport.ref.net b/examples/TestBlinkyWithSchematicImport/TestBlinkyWithSchematicImport.ref.net
index 74062d581..1ac68393c 100644
--- a/examples/TestBlinkyWithSchematicImport/TestBlinkyWithSchematicImport.ref.net
+++ b/examples/TestBlinkyWithSchematicImport/TestBlinkyWithSchematicImport.ref.net
@@ -89,14 +89,14 @@
   (sheetpath (names "/reg/") (tstamps "/028a013f/"))
   (tstamps "0f330353"))
 (comp (ref "L1")
-  (value "530mA 22uH ±20% 839mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Sunlord_SWPA3012S")
+  (value "1A 10uH ±20% 375mΩ SMD,2.0x1.25x1.45mm Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg.power_path.inductor"))
   (property (name "edg_short_path") (value "reg.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA3012S220MT (Sunlord)"))
+  (property (name "edg_part") (value "MPH201214S100MT (Sunlord)"))
   (sheetpath (names "/reg/power_path/") (tstamps "/028a013f/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C3")
diff --git a/examples/UsbSourceMeasure/UsbSourceMeasure.net b/examples/UsbSourceMeasure/UsbSourceMeasure.net
index c7a292f56..96474fd98 100644
--- a/examples/UsbSourceMeasure/UsbSourceMeasure.net
+++ b/examples/UsbSourceMeasure/UsbSourceMeasure.net
@@ -155,14 +155,14 @@
   (sheetpath (names "/reg_v5/") (tstamps "/08850249/"))
   (tstamps "0ed60348"))
 (comp (ref "reg_v5.power_path.inductor")
-  (value "1.6A 33uH ±20% 126mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Sunlord_SWPA8040S")
+  (value "2A 15uH ±20% 112mΩ SMD Power Inductors ROHS")
+  (footprint "Inductor_SMD:L_Sunlord_SWPA5040S")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg_v5.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_v5.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA8040S330MT (Sunlord)"))
+  (property (name "edg_part") (value "SWPA5040S150MT (Sunlord)"))
   (sheetpath (names "/reg_v5/power_path/") (tstamps "/08850249/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg_v5.power_path.in_cap")
@@ -177,14 +177,14 @@
   (sheetpath (names "/reg_v5/power_path/") (tstamps "/08850249/1786043a/"))
   (tstamps "0879026b"))
 (comp (ref "reg_v5.power_path.out_cap")
-  (value "X5R 25V ±10% 10uF 0805 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
-  (footprint "Capacitor_SMD:C_0805_2012Metric")
+  (value "25V 22uF X5R ±10% 1206 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
+  (footprint "Capacitor_SMD:C_1206_3216Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg_v5.power_path.out_cap.cap"))
   (property (name "edg_short_path") (value "reg_v5.power_path.out_cap"))
   (property (name "edg_refdes") (value "C5"))
-  (property (name "edg_part") (value "CL21A106KAYNNNE (Samsung Electro-Mechanics)"))
+  (property (name "edg_part") (value "CL31A226KAHNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/reg_v5/power_path/") (tstamps "/08850249/1786043a/"))
   (tstamps "0be902ec"))
 (comp (ref "reg_v5.en_res")
@@ -639,14 +639,14 @@
   (sheetpath (names "/reg_v12/fb/") (tstamps "/0af80277/013000c9/"))
   (tstamps "175b043f"))
 (comp (ref "reg_v12.power_path.inductor")
-  (value "250mA 33uH ±10% 800mΩ 1210 Inductors (SMD) ROHS")
-  (footprint "Inductor_SMD:L_1210_3225Metric")
+  (value "600mA 10uH ±10% 360mA 850mΩ 0805 Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BoostConverterPowerPath"))
   (property (name "edg_path") (value "reg_v12.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_v12.power_path.inductor"))
   (property (name "edg_refdes") (value "L3"))
-  (property (name "edg_part") (value "CMI322513J330KT (FH(Guangdong Fenghua Advanced Tech))"))
+  (property (name "edg_part") (value "CMCW2012F100KTT (Cybermax)"))
   (sheetpath (names "/reg_v12/power_path/") (tstamps "/0af80277/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg_v12.power_path.in_cap")
@@ -848,14 +848,14 @@
   (sheetpath (names "/reg_vcontrol/fb/") (tstamps "/20ad0515/013000c9/"))
   (tstamps "175b043f"))
 (comp (ref "reg_vcontrol.power_path.inductor")
-  (value "390mA 47uH ±10% 1Ω 1210 Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_1210_3225Metric")
+  (value "220mA 15uH ±20% 900mΩ 0603 Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0603_1608Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BoostConverterPowerPath"))
   (property (name "edg_path") (value "reg_vcontrol.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_vcontrol.power_path.inductor"))
   (property (name "edg_refdes") (value "L4"))
-  (property (name "edg_part") (value "BRL3225T470K (Taiyo Yuden)"))
+  (property (name "edg_part") (value "MGFL1608F150MT-LF (microgate)"))
   (sheetpath (names "/reg_vcontrol/power_path/") (tstamps "/20ad0515/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "reg_vcontrol.power_path.in_cap")
diff --git a/examples/UsbSourceMeasure/UsbSourceMeasure.ref.net b/examples/UsbSourceMeasure/UsbSourceMeasure.ref.net
index ea32d8fd9..4cba5aa24 100644
--- a/examples/UsbSourceMeasure/UsbSourceMeasure.ref.net
+++ b/examples/UsbSourceMeasure/UsbSourceMeasure.ref.net
@@ -155,14 +155,14 @@
   (sheetpath (names "/reg_v5/") (tstamps "/08850249/"))
   (tstamps "0ed60348"))
 (comp (ref "L1")
-  (value "1.6A 33uH ±20% 126mΩ SMD Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_Sunlord_SWPA8040S")
+  (value "2A 15uH ±20% 112mΩ SMD Power Inductors ROHS")
+  (footprint "Inductor_SMD:L_Sunlord_SWPA5040S")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg_v5.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_v5.power_path.inductor"))
   (property (name "edg_refdes") (value "L1"))
-  (property (name "edg_part") (value "SWPA8040S330MT (Sunlord)"))
+  (property (name "edg_part") (value "SWPA5040S150MT (Sunlord)"))
   (sheetpath (names "/reg_v5/power_path/") (tstamps "/08850249/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C4")
@@ -177,14 +177,14 @@
   (sheetpath (names "/reg_v5/power_path/") (tstamps "/08850249/1786043a/"))
   (tstamps "0879026b"))
 (comp (ref "C5")
-  (value "X5R 25V ±10% 10uF 0805 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
-  (footprint "Capacitor_SMD:C_0805_2012Metric")
+  (value "25V 22uF X5R ±10% 1206 Multilayer Ceramic Capacitors MLCC - SMD/SMT ROHS")
+  (footprint "Capacitor_SMD:C_1206_3216Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BuckConverterPowerPath"))
   (property (name "edg_path") (value "reg_v5.power_path.out_cap.cap"))
   (property (name "edg_short_path") (value "reg_v5.power_path.out_cap"))
   (property (name "edg_refdes") (value "C5"))
-  (property (name "edg_part") (value "CL21A106KAYNNNE (Samsung Electro-Mechanics)"))
+  (property (name "edg_part") (value "CL31A226KAHNNNE (Samsung Electro-Mechanics)"))
   (sheetpath (names "/reg_v5/power_path/") (tstamps "/08850249/1786043a/"))
   (tstamps "0be902ec"))
 (comp (ref "R3")
@@ -639,14 +639,14 @@
   (sheetpath (names "/reg_v12/fb/") (tstamps "/0af80277/013000c9/"))
   (tstamps "175b043f"))
 (comp (ref "L3")
-  (value "250mA 33uH ±10% 800mΩ 1210 Inductors (SMD) ROHS")
-  (footprint "Inductor_SMD:L_1210_3225Metric")
+  (value "600mA 10uH ±10% 360mA 850mΩ 0805 Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0805_2012Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BoostConverterPowerPath"))
   (property (name "edg_path") (value "reg_v12.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_v12.power_path.inductor"))
   (property (name "edg_refdes") (value "L3"))
-  (property (name "edg_part") (value "CMI322513J330KT (FH(Guangdong Fenghua Advanced Tech))"))
+  (property (name "edg_part") (value "CMCW2012F100KTT (Cybermax)"))
   (sheetpath (names "/reg_v12/power_path/") (tstamps "/0af80277/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C24")
@@ -848,14 +848,14 @@
   (sheetpath (names "/reg_vcontrol/fb/") (tstamps "/20ad0515/013000c9/"))
   (tstamps "175b043f"))
 (comp (ref "L4")
-  (value "390mA 47uH ±10% 1Ω 1210 Power Inductors ROHS")
-  (footprint "Inductor_SMD:L_1210_3225Metric")
+  (value "220mA 15uH ±20% 900mΩ 0603 Inductors (SMD) ROHS")
+  (footprint "Inductor_SMD:L_0603_1608Metric")
   (property (name "Sheetname") (value "power_path"))
   (property (name "Sheetfile") (value "edg.abstract_parts.AbstractPowerConverters.BoostConverterPowerPath"))
   (property (name "edg_path") (value "reg_vcontrol.power_path.inductor"))
   (property (name "edg_short_path") (value "reg_vcontrol.power_path.inductor"))
   (property (name "edg_refdes") (value "L4"))
-  (property (name "edg_part") (value "BRL3225T470K (Taiyo Yuden)"))
+  (property (name "edg_part") (value "MGFL1608F150MT-LF (microgate)"))
   (sheetpath (names "/reg_vcontrol/power_path/") (tstamps "/20ad0515/1786043a/"))
   (tstamps "0f2b0369"))
 (comp (ref "C31")
diff --git a/examples/test_fcml.py b/examples/test_fcml.py
index 8c595da4d..a3e60e4b9 100644
--- a/examples/test_fcml.py
+++ b/examples/test_fcml.py
@@ -2,6 +2,7 @@
 from typing import Optional, Dict
 
 from edg import *
+from edg.abstract_parts.PartsTable import ExperimentalUserFnPartsTable
 
 
 class PowerOutConnector(Connector, Block):
@@ -179,11 +180,12 @@ class FcmlPowerPath(InternalSubcircuit, GeneratorBlock):
   """
   @init_in_parent
   def __init__(self, input_voltage: RangeLike, output_voltage: RangeLike, frequency: RangeLike,
-               output_current: RangeLike, current_limits: RangeLike, inductor_current_ripple: RangeLike, *,
+               output_current: RangeLike, sw_current_limits: RangeLike, *,
                input_voltage_ripple: FloatLike,
                output_voltage_ripple: FloatLike,
                efficiency: RangeLike = (0.9, 1.0),  # from TI reference
                dutycycle_limit: RangeLike = (0.1, 0.9),
+               ripple_ratio: RangeLike = Range.all(),
                inductor_scale: FloatLike = 1.0):  # arbitrary
     super().__init__()
 
@@ -196,43 +198,44 @@ def __init__(self, input_voltage: RangeLike, output_voltage: RangeLike, frequenc
     self.output_voltage = self.ArgParameter(output_voltage)
     self.frequency = self.ArgParameter(frequency)
     self.output_current = self.ArgParameter(output_current)
-    self.inductor_current_ripple = self.ArgParameter(inductor_current_ripple)
+    self.sw_current_limits = self.ArgParameter(sw_current_limits)
+
     self.efficiency = self.ArgParameter(efficiency)
     self.input_voltage_ripple = self.ArgParameter(input_voltage_ripple)
     self.output_voltage_ripple = self.ArgParameter(output_voltage_ripple)
     self.dutycycle_limit = self.ArgParameter(dutycycle_limit)
-    self.generator_param(self.input_voltage, self.output_voltage, self.frequency, self.output_current,
-                         self.inductor_current_ripple, self.efficiency,
-                         self.input_voltage_ripple, self.output_voltage_ripple, self.dutycycle_limit)
-
-    self.current_limits = self.ArgParameter(current_limits)
+    self.ripple_ratio = self.ArgParameter(ripple_ratio)  # only used to force a ripple ratio at the actual currents
     self.inductor_scale = self.ArgParameter(inductor_scale)
 
+    self.generator_param(self.input_voltage, self.output_voltage, self.frequency, self.output_current,
+                         self.sw_current_limits, self.input_voltage_ripple, self.output_voltage_ripple,
+                         self.efficiency, self.dutycycle_limit, self.ripple_ratio, self.inductor_scale)
+
     self.actual_dutycycle = self.Parameter(RangeExpr())
     self.actual_inductor_current_ripple = self.Parameter(RangeExpr())
 
   def generate(self) -> None:
     super().generate()
-    values = BuckConverterPowerPath.calculate_parameters(
+    inductor_scale = self.get(self.inductor_scale)
+    values = BuckConverterPowerPath._calculate_parameters(
       self.get(self.input_voltage), self.get(self.output_voltage),
-      self.get(self.frequency), self.get(self.output_current), self.get(self.inductor_current_ripple),
+      self.get(self.frequency), self.get(self.output_current),
+      self.get(self.sw_current_limits), self.get(self.ripple_ratio),
       self.get(self.input_voltage_ripple), self.get(self.output_voltage_ripple),
-      efficiency=self.get(self.efficiency), dutycycle_limit=self.get(self.dutycycle_limit))
+      efficiency=self.get(self.efficiency),
+      dutycycle_limit=self.get(self.dutycycle_limit))
     self.assign(self.actual_dutycycle, values.dutycycle)
     self.require(values.dutycycle == values.effective_dutycycle, "dutycycle outside limit")
 
-    # TODO maximum current depends on the inductance, but this just uses a worst-case value for simplicity
-    # TODO ideally the inductor selector would take a function that can account for this coupled equation
     self.inductor = self.Block(Inductor(
-      inductance=values.inductance*Henry / self.inductor_scale,
-      current=values.inductor_peak_currents,
-      frequency=self.frequency
+      inductance=(values.inductance / inductor_scale) * Henry,
+      current=values.inductor_avg_current,
+      frequency=self.frequency,
+      experimental_filter_fn=ExperimentalUserFnPartsTable.serialize_fn(
+        BuckConverterPowerPath._buck_inductor_filter, values.inductor_avg_current.upper,
+        values.ripple_scale / inductor_scale, values.min_ripple)
     ))
-
-    # expand out the equation to avoid double-counting tolerance
-    actual_peak_ripple = (self.output_voltage.lower() * (self.input_voltage.upper() - self.output_voltage.lower()) /
-                          (self.inductor.actual_inductance * self.frequency.lower() * self.input_voltage.upper()))
-    self.assign(self.actual_inductor_current_ripple, actual_peak_ripple / self.inductor_scale)
+    self.assign(self.actual_inductor_current_ripple, values.ripple_scale / self.inductor.actual_inductance / inductor_scale)
 
     self.connect(self.switch, self.inductor.a.adapt_to(VoltageSink(
       voltage_limits=RangeExpr.ALL,
@@ -240,8 +243,8 @@ def generate(self) -> None:
     )))
     self.connect(self.pwr_out, self.inductor.b.adapt_to(VoltageSource(
       voltage_out=self.output_voltage,
-      current_limits=(0, self.current_limits.intersect(self.inductor.actual_current_rating).upper() -
-                      (self.actual_inductor_current_ripple.upper() / 2))
+      current_limits=BuckConverterPowerPath._ilim_expr(self.inductor.actual_current_rating, self.sw_current_limits,
+                                                       self.actual_inductor_current_ripple)
     )))
 
     self.in_cap = self.Block(DecouplingCapacitor(
@@ -249,7 +252,8 @@ def generate(self) -> None:
       exact_capacitance=True
     )).connected(self.gnd, self.pwr_in)
     self.out_cap = self.Block(DecouplingCapacitor(
-      capacitance=values.output_capacitance * Farad,
+      capacitance=(Range.exact(float('inf')) * Farad).hull(
+        (values.output_capacitance_scale * self.actual_inductor_current_ripple.upper().max(values.min_ripple))),
       exact_capacitance=True
     )).connected(self.gnd, self.pwr_out)
 
@@ -274,7 +278,7 @@ class DiscreteMutlilevelBuckConverter(PowerConditioner, GeneratorBlock):
   """
   @init_in_parent
   def __init__(self, levels: IntLike, ratios: RangeLike, frequency: RangeLike, *,
-               inductor_current_ripple: RangeLike, fet_rds: RangeLike = (0, 0.1)*Ohm):
+               ripple_ratio: RangeLike = (0.2, 0.5), fet_rds: RangeLike = (0, 0.1)*Ohm):
     super().__init__()
     self.pwr_in = self.Port(VoltageSink.empty())
     self.pwr_out = self.Port(VoltageSource.empty())
@@ -285,7 +289,7 @@ def __init__(self, levels: IntLike, ratios: RangeLike, frequency: RangeLike, *,
     self.pwms = self.Port(Vector(DigitalSink.empty()))
 
     self.frequency = self.ArgParameter(frequency)
-    self.inductor_current_ripple = self.ArgParameter(inductor_current_ripple)
+    self.ripple_ratio = self.ArgParameter(ripple_ratio)
     self.fet_rds = self.ArgParameter(fet_rds)
 
     self.levels = self.ArgParameter(levels)
@@ -298,10 +302,10 @@ def generate(self):
     assert levels >= 2, "levels must be 2 or more"
     self.power_path = self.Block(FcmlPowerPath(
       self.pwr_in.link().voltage, self.pwr_in.link().voltage * self.get(self.ratios), self.frequency,
-      self.pwr_out.link().current_drawn, Range.all(),  # TODO add current limits from FETs
-      inductor_current_ripple=self.inductor_current_ripple,
+      self.pwr_out.link().current_drawn, Range.exact(0),
       input_voltage_ripple=250*mVolt,
       output_voltage_ripple=25*mVolt,  # TODO plumb through to user config
+      ripple_ratio=self.ripple_ratio,
       dutycycle_limit=(0, 1),
       inductor_scale=(levels - 1)**2
     ))
@@ -383,8 +387,7 @@ def contents(self) -> None:
 
       self.conv = imp.Block(DiscreteMutlilevelBuckConverter(
         4, (0.15, 0.5), 100*kHertz(tol=0),
-        inductor_current_ripple=(0.1, 1)*Amp,
-        fet_rds=(0, 0.010)*Ohm
+        ripple_ratio=(0.1, 0.4), fet_rds=(0, 0.010)*Ohm
       ))
       self.conv_out = imp.Block(PowerOutConnector((0, 3)*Amp))
       self.connect(self.conv.pwr_in, self.conv_in.pwr)
@@ -502,7 +505,6 @@ def refinements(self) -> Refinements:
         (['conv', 'sw[2]', 'cap', 'footprint_spec'], ParamValue(['conv', 'sw[1]', 'cap', 'footprint_spec'])),
 
         # JLC does not have frequency specs, must be checked TODO
-        (['conv', 'power_path', 'inductor', 'part'], 'NR8040T4R7N'),  # peg to prior part selection
         (['conv', 'power_path', 'inductor', 'manual_frequency_rating'], Range.all()),
         (['reg_vgate', 'power_path', 'inductor', 'manual_frequency_rating'], Range.all()),
 
diff --git a/examples/test_iot_display.py b/examples/test_iot_display.py
index 1b4fb60f4..4887b33fe 100644
--- a/examples/test_iot_display.py
+++ b/examples/test_iot_display.py
@@ -179,7 +179,6 @@ def refinements(self) -> Refinements:
         ]),
         (['mcu', 'programming'], 'uart-auto-button'),
 
-        (['reg_3v3', 'power_path', 'inductor', 'part'], "SWPA4030S330MT"),
         (['reg_3v3', 'power_path', 'inductor', 'manual_frequency_rating'], Range(0, 10e6)),
         (['reg_3v3', 'fb', 'impedance'], Range(20000.0, 100000.0)),
         (['epd', 'boost', 'sense', 'require_basic_part'], False),  # 3R is not a basic part
diff --git a/examples/test_iot_fan.py b/examples/test_iot_fan.py
index 8fd53c46b..9969c0245 100644
--- a/examples/test_iot_fan.py
+++ b/examples/test_iot_fan.py
@@ -121,7 +121,6 @@ def refinements(self) -> Refinements:
           'enc_a=26',
         ]),
         (['mcu', 'programming'], 'uart-auto'),
-        (['reg_5v', 'power_path', 'inductor', 'part'], "NR5040T220M"),
         (['reg_5v', 'power_path', 'inductor', 'manual_frequency_rating'], Range(0, 9e6)),
         (['fan_drv[0]', 'drv', 'footprint_spec'], "Package_SO:SOIC-8_3.9x4.9mm_P1.27mm"),
         (['fan_drv[0]', 'drv', 'part'], "AO4407A"),  # default DMG4407 is out of stock
diff --git a/examples/test_iot_iron.py b/examples/test_iot_iron.py
index 129315c06..40d62ca07 100644
--- a/examples/test_iot_iron.py
+++ b/examples/test_iot_iron.py
@@ -233,9 +233,7 @@ def refinements(self) -> Refinements:
         # these will be enforced by the firmware control mechanism
         # (['conv', 'pwr_in', 'current_draw'], Range(0, 3)),  # max 3A input draw
         # force JLC frequency spec
-        (['conv', 'power_path', 'inductor', 'part'], 'SLF12565T-150M4R2-PF'),
         (['conv', 'power_path', 'inductor', 'manual_frequency_rating'], Range(0, 1e6)),  # from charts, inductance constant up to 1MHz
-        (['reg_3v3', 'power_path', 'inductor', 'part'], 'SWPA5040S220MT'),
         (['reg_3v3', 'power_path', 'inductor', 'manual_frequency_rating'], Range(0, 11e6)),
 
         (['reg_gate', 'ic', 'actual_dropout'], Range.exact(0)),  # allow tracking
diff --git a/examples/test_iot_led_driver.py b/examples/test_iot_led_driver.py
index 0bdddc7d3..61bf92c9c 100644
--- a/examples/test_iot_led_driver.py
+++ b/examples/test_iot_led_driver.py
@@ -123,7 +123,6 @@ def refinements(self) -> Refinements:
           'led_pwm_3=33',
         ]),
         (['mcu', 'programming'], 'uart-auto'),
-        (['reg_5v', 'power_path', 'inductor', 'part'], "NR5040T220M"),
         (['reg_5v', 'power_path', 'inductor', 'manual_frequency_rating'], Range(0, 9e6)),
 
         (['led_drv[0]', 'diode_voltage_drop'], Range(0, 0.5)),
diff --git a/examples/test_multimeter.py b/examples/test_multimeter.py
index 95f4d57cb..97ac1f13c 100644
--- a/examples/test_multimeter.py
+++ b/examples/test_multimeter.py
@@ -1,5 +1,5 @@
 import unittest
-from typing import List, Dict
+from typing import Dict
 
 from edg import *
 
@@ -369,7 +369,6 @@ def refinements(self) -> Refinements:
         ]),
         (['mcu', 'swd_swo_pin'], 'P1.00'),
         (['reg_5v', 'power_path', 'dutycycle_limit'], Range(float('-inf'), float('inf'))),  # allow the regulator to go into tracking mode
-        (['reg_5v', 'ripple_current_factor'], Range(0.75, 1.0)),  # smaller inductor
         (['reg_5v', 'fb', 'div', 'series'], 12),  # JLC has limited resistors
         (['measure', 'res', 'footprint_spec'], 'Resistor_SMD:R_2512_6332Metric'),  # beefy input resistor
         (['measure', 'res', 'fp_mfr'], 'Bourns Inc.'),
diff --git a/examples/test_usb_source_measure.py b/examples/test_usb_source_measure.py
index 51bba93ee..64a8bdcf6 100644
--- a/examples/test_usb_source_measure.py
+++ b/examples/test_usb_source_measure.py
@@ -424,7 +424,7 @@ def contents(self) -> None:
         imp.Block(ForcedVoltage(20*Volt(tol=0))),
         imp.Block(CustomSyncBuckBoostConverterPwm(output_voltage=(15, 30)*Volt,  # design for 0.5x - 1.5x conv ratio
                                                   frequency=500*kHertz(tol=0),
-                                                  ripple_current_factor=(0.01, 0.9),
+                                                  ripple_ratio=(0.01, 0.9),
                                                   input_ripple_limit=250*mVolt,
                                                   output_ripple_limit=(25*(7/9))*mVolt  # fill out the row of caps
                                                   )),