pedalkernel/

dsl.rs

//! DSL parser for `.pedal` circuit definition files.
//!
//! Parses component declarations, net connections, and control mappings
//! into an AST that can drive WDF tree construction or KiCad export.

use nom::{
    branch::alt,
    bytes::complete::{tag, take_till, take_while, take_while1},
    character::complete::{alpha1, char, multispace1, not_line_ending},
    combinator::{map, opt, peek, recognize, value},
    multi::{many0, separated_list1},
    number::complete::double,
    sequence::{delimited, pair, preceded, tuple},
    IResult,
};

use crate::compiler::components::*;

/// Type alias for boxed component trait objects returned by parser functions.
type BoxComp = Box<dyn crate::compiler::Component>;

// ---------------------------------------------------------------------------
// AST
// ---------------------------------------------------------------------------

/// Rectifier type — determines supply output impedance character.
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub enum RectifierType {
    /// Tube rectifier (GZ34, 5U4, 5Y3) — high impedance, significant sag.
    /// Adds ~40–80V drop under load depending on tube type.
    Tube,
    /// Solid-state rectifier (silicon diodes) — very low impedance, stiff supply.
    /// Adds ~1–2V drop under load.
    #[default]
    SolidState,
}

/// Power supply configuration — models B+ rail behavior under load.
///
/// In real amps, the power supply has finite output impedance from the
/// rectifier forward drop, transformer winding resistance, and filter cap ESR.
/// When the output stage draws current, the B+ voltage sags proportionally.
///
/// Simple form: `supply 9V` — just sets nominal voltage, no sag.
/// Block form: `supply 480V { impedance: 150, filter_cap: 40u, rectifier: tube }`
#[derive(Debug, Clone, PartialEq)]
pub struct SupplyConfig {
    /// Nominal (no-load) supply voltage in volts.
    pub voltage: f64,
    /// Supply output impedance in ohms (rectifier + transformer + ESR).
    /// Higher = more sag. Tube rectifier: 50–200Ω, solid-state: 1–10Ω.
    pub impedance: Option<f64>,
    /// Main filter capacitance in farads — sets sag recovery time.
    /// Larger cap = faster recovery. Typical: 40µF (vintage) to 220µF (modern).
    pub filter_cap: Option<f64>,
    /// Rectifier type — tube (saggy) or solid-state (stiff).
    pub rectifier: RectifierType,
}

impl SupplyConfig {
    /// Create a simple supply config with just a voltage (no sag modeling).
    pub fn voltage_only(voltage: f64) -> Self {
        Self {
            voltage,
            impedance: None,
            filter_cap: None,
            rectifier: RectifierType::default(),
        }
    }

    /// Returns true if this supply has sag parameters configured.
    pub fn has_sag(&self) -> bool {
        self.impedance.is_some()
    }
}

/// A named power supply rail.
///
/// Allows circuits to have multiple supply voltages with different names
/// (e.g., `V+`, `V-`, `B+` for bipolar supplies or tube circuits).
#[derive(Debug, Clone, PartialEq)]
pub struct NamedSupply {
    /// Rail name (e.g., "vcc", "V+", "V-", "B+")
    pub name: String,
    /// Supply configuration (voltage and optional sag parameters)
    pub config: SupplyConfig,
}

impl NamedSupply {
    /// Create a named supply with just a voltage (no sag modeling).
    pub fn new(name: impl Into<String>, voltage: f64) -> Self {
        Self {
            name: name.into(),
            config: SupplyConfig::voltage_only(voltage),
        }
    }

    /// Create a named supply with full configuration.
    pub fn with_config(name: impl Into<String>, config: SupplyConfig) -> Self {
        Self {
            name: name.into(),
            config,
        }
    }
}

/// Sidechain target — what the sidechain CV modulates.
#[derive(Debug, Clone, PartialEq)]
pub enum SidechainTarget {
    /// Modulate the push-pull grid bias (variable-mu compression).
    /// CV is subtracted from the grid bias: Vgrid = Vbias - Vcv.
    PushPullGridBias,
}

/// Sidechain definition for feedback compression loops.
///
/// Describes a sidechain path that taps the audio output, extracts an
/// envelope via amplification + rectification + RC time constant, and
/// feeds back a control voltage to modulate the audio path gain.
///
/// ```text
/// sidechain {
///     tap: A_node_ch_out          # node to tap audio from
///     cv: A_node_sc_cv            # node where CV feeds back
///     target: push_pull_grid      # modulation target
/// }
/// ```
#[derive(Debug, Clone, PartialEq)]
pub struct SidechainInfo {
    /// Node name where audio is tapped (e.g., "A_node_ch_out").
    pub tap_node: String,
    /// Node name where the CV feeds back (e.g., "A_node_sc_cv").
    pub cv_node: String,
    /// What the sidechain CV modulates.
    pub target: SidechainTarget,
}

// ─────────────────────────────────────────────────────────────────────────────
// Init block types
// ─────────────────────────────────────────────────────────────────────────────

/// Named or explicit initial state for one NL device in an `init { ... }` block.
///
/// Named states expand to physics-based voltages at compile time:
/// - BJT NPN: `saturated` → [Vbe=0.75, Vce=0.1], `cutoff` → [Vbe=0.0, Vce=supply],
///   `active` → [Vbe=0.65, Vce=supply/2]
/// - Diode: `forward` → Vd=0.7, `reverse` → Vd=-supply/2
/// - PNP signs are flipped automatically.
#[derive(Debug, Clone, PartialEq)]
pub enum InitState {
    /// A human-readable alias: "saturated", "cutoff", "active", "forward", "reverse".
    Named(String),
    /// Explicit per-terminal operating-point seed from the optional `op { }` block.
    ///
    /// For a BJT these are the two nonlinear-port voltages the grouped-NR solves
    /// over: base-emitter (`vbe`) and collector-emitter (`vce`). This is a pure
    /// warm-start seed (`v_prev`); it never folds device Jacobians or changes the
    /// stage's DC source term. Used to test whether an externally-derived
    /// operating point (e.g. ngspice's `.op`) is a stable WDF fixed point.
    Explicit { vbe: f64, vce: f64 },
    /// Explicit **node voltage** seed from the optional `op { nodes { ... } }`
    /// sub-block. `device_label` carries the circuit node NAME (a pin name like
    /// `Q3.base`, or a reserved node like `in`/`out`/`vcc`), and `v` is its DC
    /// voltage. Used to seed reactive (capacitor) ports at a full operating
    /// point: each cap's stored DC voltage is `V(node_a) − V(node_b)`. Like
    /// `Explicit`, it is a pure warm-start seed — it never changes the stage's
    /// DC source term.
    NodeVoltage { v: f64 },
}

/// One device hint from the `init { ... }` block.
///
/// ```text
/// init {
///     Q1: saturated
///     Q2: cutoff
/// }
/// ```
#[derive(Debug, Clone, PartialEq)]
pub struct InitHint {
    /// Component label in the pedal (e.g., "Q1").
    pub device_label: String,
    /// Desired initial state.
    pub state: InitState,
}

/// Top-level pedal definition.
#[derive(Debug, Clone, PartialEq)]
pub struct PedalDef {
    pub name: String,
    /// Optional subtitle for UI display (e.g., "Klon Centaur — transparent overdrive")
    pub subtitle: Option<String>,
    /// Power supply rails.
    /// Multiple named supplies are supported (e.g., V+, V-, B+).
    /// If empty, defaults to a single 9V "vcc" rail in the compiler.
    pub supplies: Vec<NamedSupply>,
    pub components: Vec<ComponentDef>,
    pub nets: Vec<NetDef>,
    pub controls: Vec<ControlDef>,
    /// Internal trim pots (not user-facing, factory adjustments)
    pub trims: Vec<ControlDef>,
    /// Monitor definitions for real-time metering visualization
    pub monitors: Vec<MonitorDef>,
    /// Sidechain definitions for feedback compression loops.
    /// Each entry defines a tap point, CV return, and modulation target.
    pub sidechains: Vec<SidechainInfo>,
    /// Mirrored pot mappings: mirrored_pot_id → source_pot_id.
    /// A mirrored pot's position is always `1.0 - source.position`.
    /// Used for dual-gang pots where one gang tracks inversely.
    pub mirrors: hashbrown::HashMap<String, String>,
    /// When true, auto-calibrate output level at compile time.
    pub calibrate: bool,
    /// Subcircuit definitions. When non-empty, the top-level `components` and
    /// `nets` become the routing layer connecting subcircuits.
    pub subcircuits: Vec<SubcircuitDef>,
    /// Named voltage port declarations (audio I/O, CV, gates, envelope taps).
    /// Ports are voltage nodes in the circuit, drivable at audio rate.
    /// When empty, implicit `in`/`out` ports are created by the compiler.
    pub ports: Vec<PortDef>,
    /// Optional initial NL device states from the `init { ... }` block.
    /// Empty when no `init` block is present (the common case — all existing pedals).
    /// Used by the compiler to seed the homotopy pre-convergence asymmetrically,
    /// which is required for free-running oscillators (BJT astable multivibrators)
    /// that would otherwise converge to a symmetric saddle point.
    pub init_hints: Vec<InitHint>,
    /// File-based subcircuit instances declared via `id: use("path.pedal")`
    /// inside the `components { ... }` block. These are FLATTENED into the
    /// parent's component/net/control lists by [`crate::dsl_expand::expand_uses`]
    /// before compilation; the compiler never sees them. Empty for the common
    /// case (no `use(...)` instances).
    pub uses: Vec<UseInstance>,
}

/// A file-based subcircuit instance: `micamp: use("../sub/ba284.pedal")`.
///
/// Declared inside the `components { ... }` block. The instance `id` namespaces
/// every component/node of the instantiated sub when flattened into the parent.
///
/// An optional `with { }` block overrides specific component values before
/// flattening:
///
/// ```text
/// g1: use("sub/sub_gain.pedal") with { R1: 348k, C1: 8.2n }
/// ```
#[derive(Debug, Clone, PartialEq)]
pub struct UseInstance {
    /// Instance identifier (e.g. `micamp`). Used as the namespace prefix.
    pub id: String,
    /// Path to the sub `.pedal` file, relative to the parent file's directory.
    pub path: String,
    /// Optional component-value overrides: `(component_id, new_value)`.
    /// Applied to the sub's matching `ComponentDef` before namespacing/merge.
    /// An error is returned if any id has no matching component in the sub.
    pub overrides: Vec<(String, f64)>,
}

/// Named port declaration from the .pedal DSL.
///
/// ```text
/// ports {
///     audio_in: input
///     cv_cutoff: input
///     audio_out: output
/// }
/// ```
#[derive(Debug, Clone, PartialEq)]
pub struct PortDef {
    pub name: String,
    pub direction: pedalkernel_rt::PortDirection,
    /// Optional source/load impedance in Ohms.
    /// When set, the WDF VoltageSource gets this Rp instead of the default 1Ω.
    /// Syntax: `audio_in: input(10k)` → impedance = Some(10_000.0)
    pub impedance: Option<f64>,
}

/// A subcircuit block within a pedal/equipment definition.
/// Subcircuits partition a circuit into named sub-networks that can have
/// independent rate domains (e.g., audio path vs. sidechain).
#[derive(Debug, Clone, PartialEq)]
pub struct SubcircuitDef {
    /// Name of the subcircuit (e.g., "sidechain", "audio").
    pub name: String,
    /// Optional decimation factor (power of 2). None = full audio rate.
    pub rate: Option<u32>,
    /// Components local to this subcircuit.
    pub components: Vec<ComponentDef>,
    /// Internal nets. Node names not resolving to component pins or reserved
    /// nodes (gnd, vcc, supply rails) become implicit ports.
    pub nets: Vec<NetDef>,
    /// Controls scoped to this subcircuit.
    pub controls: Vec<ControlDef>,
    /// Trims scoped to this subcircuit.
    pub trims: Vec<ControlDef>,
    /// Monitor definitions scoped to this subcircuit.
    pub monitors: Vec<MonitorDef>,
    /// Mirrored pot mappings within this subcircuit.
    pub mirrors: hashbrown::HashMap<String, String>,
}

impl PedalDef {
    /// Returns true if this pedal has an FX send/return loop defined.
    pub fn has_fx_loop(&self) -> bool {
        let has_send = self.nets.iter().any(|n| {
            n.from == Pin::Reserved("fx_send".into())
                || n.to.contains(&Pin::Reserved("fx_send".into()))
        });
        let has_return = self.nets.iter().any(|n| {
            n.from == Pin::Reserved("fx_return".into())
                || n.to.contains(&Pin::Reserved("fx_return".into()))
        });
        has_send && has_return
    }

    /// Get the primary supply voltage (first supply, or default 9V).
    /// For backwards compatibility with single-supply code.
    pub fn primary_supply_voltage(&self) -> f64 {
        self.supplies
            .first()
            .map(|s| s.config.voltage)
            .unwrap_or(9.0)
    }

    /// Get a supply by name.
    pub fn get_supply(&self, name: &str) -> Option<&NamedSupply> {
        self.supplies.iter().find(|s| s.name == name)
    }

    /// Get all supply rail names.
    pub fn supply_names(&self) -> Vec<&str> {
        self.supplies.iter().map(|s| s.name.as_str()).collect()
    }

    /// Check if a name is a supply rail.
    pub fn is_supply_rail(&self, name: &str) -> bool {
        self.supplies.iter().any(|s| s.name == name)
    }
}

/// A single component declaration, e.g. `R1: resistor(4.7k)`
#[derive(Debug, Clone)]
pub struct ComponentDef {
    pub id: String,
    pub kind: Box<dyn crate::compiler::Component>,
}

impl PartialEq for ComponentDef {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id && self.kind.dyn_eq(other.kind.as_ref())
    }
}

pub use crate::pot_taper::PotTaper;

/// Op-amp types with different characteristics.
/// Each type has distinct slew rate, gain-bandwidth product, and input impedance
/// that affect the tone and response of the circuit.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum OpAmpType {
    /// Generic op-amp (defaults to TL072 characteristics)
    #[default]
    Generic,
    /// TL071 - Single JFET-input op-amp, electrically identical to TL072
    /// (slew: 13V/µs, GBW: 3MHz). Single package drops into an LM308 socket
    /// (the "FET RAT" mod); the TL072 is a dual with a different pinout.
    Tl071,
    /// TL072 - JFET input, fast, clean (slew: 13V/µs, GBW: 3MHz)
    /// Common in: Tube Screamer mods, Klon, modern pedals
    Tl072,
    /// JRC4558D - BJT input, warmer, compressed (slew: 1.7V/µs, GBW: 3MHz)
    /// The classic Tube Screamer op-amp
    Jrc4558,
    /// LM308 - Slow slew rate gives distinctive compression (slew: 0.3V/µs, GBW: 1MHz)
    /// The heart of the Pro-Co RAT
    Lm308,
    /// LM741 - Classic slow op-amp (slew: 0.5V/µs, GBW: 1MHz)
    /// Vintage circuits
    Lm741,
    /// NE5532 - Low noise, high drive (slew: 9V/µs, GBW: 10MHz)
    /// Studio-grade circuits
    Ne5532,
    /// CA3080 - Operational Transconductance Amplifier (OTA)
    /// Current-controlled gain, used in compressors like Dyna Comp
    Ca3080,
    /// RC4558 - Texas Instruments version of 4558 (slew: 1.7V/µs)
    Rc4558,
    /// TL082 - Similar to TL072 but different bias (slew: 13V/µs)
    Tl082,
    /// OP07 - Precision low-offset op-amp (slew: 0.3V/µs, GBW: 0.6MHz)
    Op07,
}

impl OpAmpType {
    /// Slew rate in V/µs - affects high frequency response and distortion character
    pub fn slew_rate(&self) -> f64 {
        match self {
            OpAmpType::Generic | OpAmpType::Tl071 | OpAmpType::Tl072 | OpAmpType::Tl082 => 13.0,
            OpAmpType::Jrc4558 | OpAmpType::Rc4558 => 1.7,
            OpAmpType::Lm308 => 0.3,
            OpAmpType::Lm741 => 0.5,
            OpAmpType::Ne5532 => 9.0,
            OpAmpType::Ca3080 => 50.0, // OTA - very fast
            OpAmpType::Op07 => 0.3,
        }
    }

    /// Gain-bandwidth product in Hz - affects frequency response
    pub fn gain_bandwidth(&self) -> f64 {
        match self {
            OpAmpType::Generic | OpAmpType::Tl071 | OpAmpType::Tl072 | OpAmpType::Tl082 => 3e6,
            OpAmpType::Jrc4558 | OpAmpType::Rc4558 => 3e6,
            OpAmpType::Lm308 => 1e6,
            OpAmpType::Lm741 => 1e6,
            OpAmpType::Ne5532 => 10e6,
            OpAmpType::Ca3080 => 2e6, // Transconductance-dependent
            OpAmpType::Op07 => 0.6e6,
        }
    }

    /// Maximum supply voltage (total V+ to V-)
    pub fn supply_max(&self) -> f64 {
        match self {
            OpAmpType::Generic | OpAmpType::Tl071 | OpAmpType::Tl072 | OpAmpType::Tl082 => 36.0,
            OpAmpType::Jrc4558 | OpAmpType::Rc4558 => 36.0,
            OpAmpType::Lm308 => 36.0,
            OpAmpType::Lm741 => 36.0,
            OpAmpType::Ne5532 => 44.0,
            OpAmpType::Ca3080 => 36.0,
            OpAmpType::Op07 => 44.0,
        }
    }

    /// Whether this is an OTA (Operational Transconductance Amplifier)
    /// OTAs have current output and behave differently
    pub fn is_ota(&self) -> bool {
        matches!(self, OpAmpType::Ca3080)
    }
}

/// Default SPICE model name for a generic NPN BJT.
pub const DEFAULT_NPN_MODEL: &str = "GENERIC_NPN";
/// Default SPICE model name for a generic PNP BJT.
pub const DEFAULT_PNP_MODEL: &str = "GENERIC_PNP";

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DiodeType {
    Silicon,
    Germanium,
    Led,
    Schottky,
}

/// Capacitor dielectric types with different parasitic characteristics.
///
/// Different dielectric materials have different leakage and dielectric
/// absorption properties. Film caps are nearly ideal, while electrolytics
/// have significant leakage and aging effects.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum CapType {
    /// Film capacitor (polyester, polypropylene, etc.)
    /// Negligible leakage, no dielectric absorption.
    /// Used in: coupling caps, tone stacks, most pedal applications.
    #[default]
    Film,
    /// Electrolytic capacitor (aluminum, tantalum).
    /// Significant leakage (typ. 100kΩ-10MΩ parallel resistance).
    /// Aging increases leakage. Can exhibit dielectric absorption.
    /// Used in: power supply filtering, bias decoupling, large coupling caps.
    Electrolytic,
    /// Ceramic capacitor (X7R, C0G/NP0, Y5V).
    /// Low leakage but can have voltage coefficient (capacitance changes with voltage).
    /// C0G/NP0 types are stable; X7R/Y5V lose capacitance under DC bias.
    /// Used in: HF bypass, decoupling, RF applications.
    Ceramic,
    /// Tantalum capacitor (solid electrolytic).
    /// Better leakage than aluminum electrolytic, smaller size.
    /// Used in: compact designs, stable bypass applications.
    Tantalum,
}

/// Extended capacitor configuration with parasitic modeling.
///
/// Supports leakage resistance (parallel R) and dielectric absorption.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CapConfig {
    /// Capacitance value in Farads.
    pub value: f64,
    /// Dielectric type (affects default parasitics).
    pub cap_type: CapType,
    /// Parallel leakage resistance in ohms. None = ideal (infinite).
    /// Typical values: 100kΩ (worn electrolytic) to 10MΩ (new electrolytic).
    pub leakage: Option<f64>,
    /// Dielectric absorption coefficient (0.0 to 1.0). None = no DA.
    /// Represents fraction of charge that "soaks in" and slowly returns.
    /// Typical: 0.01-0.05 for electrolytics, <0.001 for film.
    pub da: Option<f64>,
}

impl CapConfig {
    pub fn new(value: f64) -> Self {
        Self {
            value,
            cap_type: CapType::Film,
            leakage: None,
            da: None,
        }
    }

    pub fn with_type(mut self, cap_type: CapType) -> Self {
        self.cap_type = cap_type;
        self
    }

    pub fn with_leakage(mut self, leakage: f64) -> Self {
        self.leakage = Some(leakage);
        self
    }

    pub fn with_da(mut self, da: f64) -> Self {
        self.da = Some(da);
        self
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PhotocouplerType {
    Vtl5c3,
    Vtl5c1,
    Nsl32,
    /// T4B - Electroluminescent panel + CdS LDR used in LA-2A
    /// EL panel driven by sidechain, LDR in audio path as variable attenuator
    T4b,
}

/// LFO waveform shapes for DSL.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LfoWaveformDsl {
    Sine,
    Triangle,
    Square,
    SawUp,
    SawDown,
    SampleAndHold,
}

/// VCO waveform selection for DSL.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VcoWaveformDsl {
    Saw,
    Triangle,
    Pulse,
}

// Triode and Pentode types use String model names, looked up from the
// embedded model files (triodes.model, pentodes.model) at compile time.

/// MOSFET types for enhancement-mode devices used in guitar pedals.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MosfetType {
    /// 2N7000 N-channel MOSFET - common in Fulltone OCD clipping, modern drives
    N2n7000,
    /// IRF520 N-channel power MOSFET - higher current capability
    Irf520,
    /// BS250 P-channel MOSFET - used in some boost circuits
    Bs250,
    /// IRF9520 P-channel power MOSFET
    Irf9520,
}

/// BBD (Bucket-Brigade Device) types for analog delay lines.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BbdType {
    /// MN3207 — 1024-stage, Boss CE-2 chorus
    Mn3207,
    /// MN3007 — 1024-stage low-noise, Boss DM-2 delay
    Mn3007,
    /// MN3005 — 4096-stage long delay, Memory Man
    Mn3005,
}

/// Spring-reverb tank models (Accutronics / RE-201 grounded).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SpringTankType {
    /// Accutronics Type 4 — 17" tank, Fender standard, long decay.
    Type4,
    /// Accutronics Type 8 — 9.25" short tank, 3 springs.
    Type8,
    /// Accutronics Type 9 — 17", 6-spring (3 coupled pairs), densest.
    Type9,
    /// Roland RE-201 small dark 2-spring tank.
    Re201Tank,
}

/// Neon bulb types for relaxation oscillators and optocouplers.
/// Neon bulbs exhibit negative resistance behavior:
/// - Off until striking voltage is reached (~90V for NE-2)
/// - Conduct and emit light until voltage drops below maintaining voltage (~60V)
/// - Used in vintage tremolo/vibrato circuits (Fender, Wurlitzer)
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum NeonType {
    /// NE-2 — Standard miniature neon indicator
    /// Striking: ~90V, Maintaining: ~60V, Current: 0.3-2mA
    #[default]
    Ne2,
    /// NE-51 — Higher current neon lamp
    /// Striking: ~95V, Maintaining: ~65V, Current: 0.5-3mA
    Ne51,
    /// NE-83 — Lower striking voltage variant
    /// Striking: ~65V, Maintaining: ~50V
    Ne83,
}

impl NeonType {
    /// Striking voltage - voltage at which the bulb ionizes and begins conducting
    pub fn striking_voltage(&self) -> f64 {
        match self {
            NeonType::Ne2 => 90.0,
            NeonType::Ne51 => 95.0,
            NeonType::Ne83 => 65.0,
        }
    }

    /// Maintaining voltage - voltage below which the bulb extinguishes
    pub fn maintaining_voltage(&self) -> f64 {
        match self {
            NeonType::Ne2 => 60.0,
            NeonType::Ne51 => 65.0,
            NeonType::Ne83 => 50.0,
        }
    }

    /// Typical operating current in Amps
    pub fn typical_current(&self) -> f64 {
        match self {
            NeonType::Ne2 => 0.5e-3,  // 0.5mA
            NeonType::Ne51 => 1.0e-3, // 1mA
            NeonType::Ne83 => 0.3e-3, // 0.3mA
        }
    }

    /// Whether this neon bulb emits enough light for optocoupler use
    pub fn suitable_for_opto(&self) -> bool {
        // All common neon types work with LDRs
        true
    }
}

// ── Synth-specific component type enums ─────────────────────────────────

/// VCO (Voltage-Controlled Oscillator) IC types.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VcoType {
    /// CEM3340 — Curtis original. Prophet 5, MemoryMoog, Jupiter 6.
    Cem3340,
    /// AS3340 — Alfa RPAR clone (currently in production, pin-compatible).
    As3340,
    /// V3340 — CoolAudio clone (currently in production, pin-compatible).
    V3340,
}

/// VCF (Voltage-Controlled Filter) IC types.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VcfType {
    /// CEM3320 — Curtis 4-pole lowpass. Prophet 5, Oberheim OB-Xa.
    Cem3320,
    /// AS3320 — Alfa RPAR clone (currently in production).
    As3320,
}

/// VCA (Voltage-Controlled Amplifier) IC types.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VcaType {
    /// SSM2164 — Quad exponential VCA. Widely used in Eurorack.
    Ssm2164,
    /// V2164 — CoolAudio clone (currently in production, pin-compatible).
    V2164,
}

/// Comparator IC types.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ComparatorType {
    /// LM311 — Single comparator, open-collector output. VCO reset, Schmitt triggers.
    Lm311,
    /// LM393 — Dual comparator. Precision applications, window comparators.
    Lm393,
}

/// Analog switch IC types.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AnalogSwitchType {
    /// CD4066 — Quad bilateral switch (~100Ω on-resistance). S&H, muting, routing.
    Cd4066,
    /// DG411 — Quad SPST analog switch (~25Ω on-resistance). Higher precision.
    Dg411,
}

/// Matched transistor pair/array types for exponential converters.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MatchedTransistorType {
    /// SSM2210 — Matched dual NPN. Tight Vbe matching for V/Oct tracking.
    Ssm2210,
    /// CA3046 — 5-NPN transistor array (common substrate). Expo converters.
    Ca3046,
    /// LM394 — Supermatch pair. Ultralow Vbe offset.
    Lm394,
    /// THAT340 — Modern matched quad NPN (THAT Corporation).
    That340,
}

// ═══════════════════════════════════════════════════════════════════════════
// Studio Equipment Types
// ═══════════════════════════════════════════════════════════════════════════

/// Transformer winding configuration.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum WindingType {
    /// Standard two-terminal winding
    #[default]
    Standard,
    /// Center-tapped winding (adds .ct terminal)
    CenterTap,
    /// Push-pull primary (two halves with center tap for B+)
    PushPull,
}

/// Audio transformer configuration.
///
/// Transformers are modeled with:
/// - Turns ratio (affects impedance transformation by n²)
/// - Primary inductance (determines low-frequency response)
/// - Optional center taps for push-pull configurations
/// - Parasitic elements (DCR, capacitance) for accurate HF response
#[derive(Debug, Clone, PartialEq)]
pub struct TransformerConfig {
    /// Optional model-library name. When present, library values seed the
    /// electrical/core fields and explicit DSL fields override them.
    pub model: Option<String>,
    /// Turns ratio (primary:secondary). 1.0 = 1:1, 10.0 = 10:1 step-down
    pub turns_ratio: f64,
    /// Primary winding inductance in Henries
    pub primary_inductance: f64,
    /// Primary winding configuration
    pub primary_type: WindingType,
    /// Secondary winding configuration
    pub secondary_type: WindingType,
    /// DC resistance of primary winding (Ω), default 0
    pub primary_dcr: f64,
    /// DC resistance of secondary winding (Ω), default 0
    pub secondary_dcr: f64,
    /// Parasitic capacitance (F), default 0
    pub capacitance: f64,
    /// Coupling coefficient (0-1), default 0.99 for audio transformers
    pub coupling: f64,
    /// Optional explicit primary leakage inductance in Henries.
    pub primary_leakage: Option<f64>,
    /// Optional explicit secondary leakage inductance in Henries.
    pub secondary_leakage: Option<f64>,
    /// Optional explicit magnetizing inductance in Henries.
    pub magnetizing_inductance: Option<f64>,
    /// Optional core-loss resistance in Ohms.
    pub core_loss_resistance: Option<f64>,
    /// Optional primary turns for a nonlinear magnetizing core model.
    pub core_primary_turns: Option<f64>,
    /// Optional core cross-sectional area in square meters.
    pub core_area: Option<f64>,
    /// Optional magnetic path length in meters.
    pub core_path_length: Option<f64>,
    /// Optional air gap length in meters.
    pub core_gap: Option<f64>,
    /// Optional standing primary DC bias current in Amps.
    pub dc_bias_current: Option<f64>,
    /// Optional Jiles-Atherton saturation magnetization in A/m.
    pub ja_ms: Option<f64>,
    /// Optional Jiles-Atherton anhysteretic shape parameter in A/m.
    pub ja_a: Option<f64>,
    /// Optional Jiles-Atherton inter-domain coupling.
    pub ja_alpha: Option<f64>,
    /// Optional Jiles-Atherton domain-wall pinning parameter in A/m.
    pub ja_k: Option<f64>,
    /// Optional Jiles-Atherton reversible magnetization fraction.
    pub ja_c: Option<f64>,
    /// Optional tertiary winding turns ratio (primary:tertiary).
    /// When present, the transformer is modeled as a 3-winding R-type adaptor.
    /// Used for transformers with NFB windings (e.g., Fairchild 670 sidechain output).
    pub tertiary_turns_ratio: Option<f64>,
}

impl Default for TransformerConfig {
    fn default() -> Self {
        Self {
            turns_ratio: 1.0,
            primary_inductance: 1.0,
            model: None,
            primary_type: WindingType::Standard,
            secondary_type: WindingType::Standard,
            primary_dcr: 0.0,
            secondary_dcr: 0.0,
            capacitance: 0.0,
            coupling: 0.99,
            primary_leakage: None,
            secondary_leakage: None,
            magnetizing_inductance: None,
            core_loss_resistance: None,
            core_primary_turns: None,
            core_area: None,
            core_path_length: None,
            core_gap: None,
            dc_bias_current: None,
            ja_ms: None,
            ja_a: None,
            ja_alpha: None,
            ja_k: None,
            ja_c: None,
            tertiary_turns_ratio: None,
        }
    }
}

impl TransformerConfig {
    /// Create a simple transformer with turns ratio and inductance.
    pub fn new(turns_ratio: f64, primary_inductance: f64) -> Self {
        Self {
            turns_ratio,
            primary_inductance,
            ..Default::default()
        }
    }

    /// Create a transformer backed by an embedded model-library entry.
    pub fn with_model(turns_ratio: f64, model: String) -> Self {
        Self {
            turns_ratio,
            primary_inductance: 0.0,
            coupling: 0.0,
            model: Some(model),
            ..Default::default()
        }
    }

    /// Create a center-tapped secondary transformer.
    pub fn with_center_tap(mut self) -> Self {
        self.secondary_type = WindingType::CenterTap;
        self
    }

    /// Create a push-pull primary transformer.
    pub fn with_push_pull_primary(mut self) -> Self {
        self.primary_type = WindingType::PushPull;
        self
    }

    /// Add DC resistance to windings.
    pub fn with_dcr(mut self, primary: f64, secondary: f64) -> Self {
        self.primary_dcr = primary;
        self.secondary_dcr = secondary;
        self
    }

    /// Add parasitic capacitance.
    pub fn with_capacitance(mut self, cap: f64) -> Self {
        self.capacitance = cap;
        self
    }

    /// Add a tertiary winding with the given primary:tertiary turns ratio.
    pub fn with_tertiary(mut self, tertiary_turns_ratio: f64) -> Self {
        self.tertiary_turns_ratio = Some(tertiary_turns_ratio);
        self
    }

    /// Returns true if this transformer has a tertiary (third) winding.
    pub fn has_tertiary(&self) -> bool {
        self.tertiary_turns_ratio.is_some()
    }
}

/// Voltage-driven Jiles-Atherton tape head configuration.
///
/// Unlike a transformer core (driven by Ampere-law magnetizing CURRENT, whose
/// knee needs hundreds of mA at studio turns counts), a record/playback head is
/// a tiny gap/coil whose magnetic field is driven by the head GAP VOLTAGE:
/// `H = kv * V`. With `kv` chosen so the J-A knee lands at line level (~1 V),
/// tape saturation tracks signal Drive directly.
///
/// The J-A hysteresis parameters share physics with the transformer core
/// (Jiles & Atherton 1986; Chowdhury DAFx-19 wave-digital tape realization)
/// but use a SMALL-GEOMETRY head whose saturation occurs at ~1 V:
///   - `ja_a` is reduced vs an output-transformer core so the Langevin knee is
///     reached at the small fields a head produces,
///   - the geometry turns/area/path are nominal (the voltage law uses `kv`, not
///     Ampere's law, so they only need to be sane positives).
#[derive(Debug, Clone, PartialEq)]
pub struct TapeHeadConfig {
    /// Optional named head model (for provenance / future library lookup).
    pub model: Option<String>,
    /// Jiles-Atherton saturation magnetization (A/m).
    pub ja_ms: f64,
    /// Jiles-Atherton anhysteretic shape parameter (A/m).
    pub ja_a: f64,
    /// Jiles-Atherton inter-domain coupling.
    pub ja_alpha: f64,
    /// Jiles-Atherton domain-wall pinning parameter (A/m).
    pub ja_k: f64,
    /// Jiles-Atherton reversible magnetization fraction (0..1).
    pub ja_c: f64,
    /// Field-per-volt coupling (A/m per V) — places the knee at line level.
    pub kv: f64,
    /// Saturating magnetic current scale (A) — harmonic drive strength.
    pub isat: f64,
    /// Linear leakage conductance (S) keeping the port well-posed.
    pub gp: f64,
    /// Fixed record-bias field offset (A/m): asymmetric transfer -> even
    /// harmonics (the soft, even-rich tape/transformer colour).
    pub h_bias: f64,
    /// WDF port resistance (Ω) — sets the scattering port impedance.
    pub rp: f64,
}

impl Default for TapeHeadConfig {
    fn default() -> Self {
        Self::studio_head()
    }
}

impl TapeHeadConfig {
    /// A studio record/playback head whose J-A knee lands at ~1 V line level.
    ///
    /// Values verified in `pedalkernel-rt/tests/tape_head_voltage.rs`: THD
    /// climbs monotonically from ~0.7% at 0.05 V to ~7% at 2 V, Newton
    /// converges in well under the iteration budget, output is finite/stable.
    pub fn studio_head() -> Self {
        Self {
            model: Some("STUDIO-HEAD".to_string()),
            ja_ms: 3.5e5,
            ja_a: 1500.0,
            ja_alpha: 1.6e-3,
            ja_k: 30.0,
            ja_c: 0.65,
            kv: 8000.0,
            isat: 2.0e-4,
            gp: 8.0e-5,
            h_bias: 400.0,
            rp: 1_000.0,
        }
    }

    pub fn with_model(model: String) -> Self {
        Self {
            model: Some(model),
            ..Self::studio_head()
        }
    }
}

/// A net connection: `in -> C1.a` or `C1.b -> R1.a, D1.a`
#[derive(Debug, Clone, PartialEq)]
pub struct NetDef {
    pub from: Pin,
    pub to: Vec<Pin>,
}

/// A pin reference – either a reserved node (`in`, `out`, `gnd`, `vcc`),
/// a component pin (`C1.a`, `R1.b`), or a fork for dynamic routing.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Pin {
    Reserved(String),
    ComponentPin {
        component: String,
        pin: String,
    },
    /// Dynamic routing controlled by a switch component.
    /// `fork(SW_time, [B8.a, B9.a])` routes signal to one of the destinations
    /// based on the switch position.
    Fork {
        /// The switch component that controls routing
        switch: String,
        /// Destination pins for each switch position
        destinations: Vec<Pin>,
    },
    /// Reference to a subcircuit port from the parent scope.
    /// `audio.ctrl` → SubcircuitPort { subcircuit: "audio", port: "ctrl" }
    SubcircuitPort {
        subcircuit: String,
        port: String,
    },
}

/// Control mapping: `Gain.position -> "Drive" [0.0, 1.0] = 0.5`
#[derive(Debug, Clone, PartialEq)]
pub struct ControlDef {
    pub component: String,
    pub property: String,
    pub label: String,
    pub range: (f64, f64),
    pub default: f64,
}

// MIDI binding: maps a component trigger to a specific MIDI note number.

/// Monitor definition for real-time metering visualization.
///
/// Specifies which circuit nodes/components to tap for VU meters and visualizations.
///
/// # Syntax
/// ```text
/// monitors {
///   V1.plate_current -> "Tube 1" [vu]
///   output -> "Output Level" [ppm]
///   GR.reduction -> "Gain Reduction" [gr]
/// }
/// ```
#[derive(Debug, Clone, PartialEq)]
pub struct MonitorDef {
    /// Component to monitor (e.g., "V1", "input", "output", "GR")
    pub component: String,
    /// Property to monitor (e.g., "plate_current", "level", "reduction")
    pub property: String,
    /// Display label for the meter
    pub label: String,
    /// Meter type (VU, PPM, peak, gain reduction)
    pub meter_type: MeterType,
}

/// Meter type for monitor visualization.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum MeterType {
    /// VU meter (300ms rise/fall, RMS-responding)
    #[default]
    Vu,
    /// Peak Programme Meter (10ms rise, 1.5s fall)
    Ppm,
    /// True peak with hold
    Peak,
    /// Gain reduction meter (for compressors)
    GainReduction,
    /// Tube glow visualization
    TubeGlow,
    /// Supply sag indicator
    SupplySag,
}

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

/// Consume whitespace **and** `# …` comments.
fn ws_comments(input: &str) -> IResult<&str, ()> {
    let (input, _) = many0(alt((
        value((), multispace1),
        value((), pair(char('#'), not_line_ending)),
    )))(input)?;
    Ok((input, ()))
}

/// Identifier: starts with alpha/underscore, continues with alphanumeric/underscore.
fn identifier(input: &str) -> IResult<&str, &str> {
    recognize(pair(
        take_while1(|c: char| c.is_ascii_alphabetic() || c == '_'),
        take_while(|c: char| c.is_ascii_alphanumeric() || c == '_'),
    ))(input)
}

/// Engineering-notation multiplier suffix.
fn eng_suffix(input: &str) -> IResult<&str, f64> {
    alt((
        value(1e-12, tag("p")),
        value(1e-9, tag("n")),
        value(1e-6, tag("us")), // microseconds (before 'u' to consume unit)
        value(1e-6, tag("u")),
        value(1e-6, tag("µ")), // micro (Unicode µ)
        value(1e3, tag("k")),
        value(1e3, tag("K")), // kilo (uppercase variant)
        value(1e6, tag("M")),
        value(1e-3, tag("ms")), // milliseconds (before 'm' to consume unit)
        value(1e-3, tag("m")),  // milli – after 'M' to disambiguate
        value(1.0, tag("H")),   // Henries (unit marker, no scaling)
        value(1.0, tag("F")),   // Farads (unit marker, no scaling)
        value(1.0, tag("s")),   // Seconds (unit marker, no scaling)
        value(1.0, tag("Ω")),   // Ohms (unit marker, no scaling)
        value(1.0, tag("R")),   // Ohms alternate notation
    ))(input)
}

/// Parse a number with optional engineering suffix, e.g. `4.7k`, `220n`, `100m`.
/// Supports IEC 60062 embedded-decimal notation where the multiplier letter replaces
/// the decimal point: `4k7` = 4.7k = 4700, `2u5` = 2.5µF, `0R47` = 0.47Ω.
/// Also accepts `inf` for infinite impedance (open circuit).
fn eng_value(input: &str) -> IResult<&str, f64> {
    // Try `inf` keyword first (infinite impedance / open circuit)
    if let Ok((rest, _)) = tag::<&str, &str, nom::error::Error<&str>>("inf")(input) {
        return Ok((rest, f64::INFINITY));
    }
    // Otherwise parse numeric value with optional suffix
    let (input, num) = double(input)?;
    let (input, mult) = opt(eng_suffix)(input)?;
    match mult {
        Some(m) => {
            // Check for embedded-decimal notation (IEC 60062): digits after the
            // multiplier letter form the fractional part.
            // e.g. "4k7" → 4.7 × 1e3, "0R47" → 0.47 × 1
            let (input, frac_digits) = opt(take_while1(|c: char| c.is_ascii_digit()))(input)?;
            if let Some(frac_str) = frac_digits {
                let frac: f64 = frac_str.parse().unwrap_or(0.0);
                let shift = 10f64.powi(frac_str.len() as i32);
                Ok((input, (num + frac / shift) * m))
            } else {
                Ok((input, num * m))
            }
        }
        None => Ok((input, num)),
    }
}

/// Quoted string: `"Foo Bar"`
fn quoted_string(input: &str) -> IResult<&str, &str> {
    delimited(char('"'), take_while(|c: char| c != '"'), char('"'))(input)
}

// ---------------------------------------------------------------------------
// Component parsers
// ---------------------------------------------------------------------------

fn parse_resistor(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("resistor")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, val) = eng_value(input)?;
    let (input, _) = ws_comments(input)?;

    // Optional wattage rating (ignored for WDF, but allows parsing)
    let (input, _wattage) = opt(tuple((
        char(','),
        ws_comments,
        eng_value, // e.g., 2W or 0.5W
        opt(char('W')),
    )))(input)?;

    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(Resistor { value: val })))
}

/// Parse capacitor type keyword.
fn cap_type(input: &str) -> IResult<&str, CapType> {
    alt((
        value(CapType::Film, tag("film")),
        value(CapType::Electrolytic, tag("electrolytic")),
        value(CapType::Ceramic, tag("ceramic")),
        value(CapType::Tantalum, tag("tantalum")),
    ))(input)
}

/// Parse `leakage: 100k` parameter (resistance in ohms).
fn cap_field_leakage(input: &str) -> IResult<&str, f64> {
    let (input, _) = tag("leakage")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(':')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, val) = eng_value(input)?;
    Ok((input, val))
}

/// Parse `da: 0.05` parameter (dielectric absorption coefficient 0-1).
fn cap_field_da(input: &str) -> IResult<&str, f64> {
    let (input, _) = tag("da")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(':')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, val) = double(input)?;
    Ok((input, val))
}

/// Parse capacitor with optional type and parasitics.
///
/// Syntax:
/// - `cap(22u)` - film cap (default), no parasitics
/// - `cap(22u, electrolytic)` - electrolytic, no explicit parasitics
/// - `cap(22u, electrolytic, leakage: 100k)` - with leakage resistance
/// - `cap(22u, electrolytic, leakage: 10k, da: 0.05)` - with leakage and DA
fn parse_cap(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("cap")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, val) = eng_value(input)?;
    let (input, _) = ws_comments(input)?;

    // Optional cap type (electrolytic, film, ceramic, tantalum)
    let (input, ctype) = opt(preceded(tuple((char(','), ws_comments)), cap_type))(input)?;

    let (input, _) = ws_comments(input)?;

    // Parse optional named parameters (leakage, da) in any order
    let mut leakage = None;
    let mut da = None;
    let mut input = input;

    loop {
        let (rest, _) = ws_comments(input)?;

        // Check for comma-separated parameter
        if let Ok((rest2, _)) = char::<_, nom::error::Error<&str>>(',')(rest) {
            let (rest3, _) = ws_comments(rest2)?;

            // Try parsing each parameter type
            if let Ok((rest4, val)) = cap_field_leakage(rest3) {
                leakage = Some(val);
                input = rest4;
                continue;
            }
            if let Ok((rest4, val)) = cap_field_da(rest3) {
                da = Some(val);
                input = rest4;
                continue;
            }
        }
        break;
    }

    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;

    Ok((
        input,
        Box::new(Capacitor {
            config: CapConfig {
                value: val,
                cap_type: ctype.unwrap_or(CapType::Film),
                leakage,
                da,
            },
        }),
    ))
}

fn parse_inductor(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("inductor")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, val) = eng_value(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(Inductor { value: val })))
}

fn diode_type(input: &str) -> IResult<&str, DiodeType> {
    alt((
        value(DiodeType::Silicon, tag("silicon")),
        value(DiodeType::Germanium, tag("germanium")),
        value(DiodeType::Led, tag("led")),
        value(DiodeType::Schottky, tag("schottky")),
    ))(input)
}

fn parse_diode_pair(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("diode_pair")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, dt) = diode_type(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(DiodePair { diode_type: dt })))
}

fn parse_diode(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("diode")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, dt) = diode_type(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(Diode { diode_type: dt })))
}

/// Parse zener diode: `zener(5.1)` or `zener(5.1v)`
///
/// The voltage parameter specifies the breakdown voltage in volts.
/// Common values: 3.3, 4.7, 5.1, 5.6, 6.2, 9.1, 12
fn parse_zener(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("zener")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, voltage) = double(input)?;
    // Optional 'v' suffix for clarity
    let (input, _) = opt(tag("v"))(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((
        input,
        Box::new(Zener {
            breakdown_voltage: voltage,
        }),
    ))
}

fn parse_pot(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("pot")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, val) = eng_value(input)?;
    let (input, _) = ws_comments(input)?;

    // Optional taper type: a (audio/log), b (linear), c (reverse log)
    // Also support legacy names: log, linear, audio
    let (input, taper) = opt(tuple((
        char(','),
        ws_comments,
        alt((
            // Legacy names (must be before single-letter to avoid partial match)
            value(PotTaper::A, tag("audio")),
            value(PotTaper::B, tag("linear")),
            value(PotTaper::A, tag("log")),
            // Single-letter tapers (preferred)
            value(PotTaper::A, tag("a")),
            value(PotTaper::B, tag("b")),
            value(PotTaper::C, tag("c")),
        )),
    )))(input)?;

    let taper = taper.map(|(_, _, t)| t).unwrap_or(PotTaper::B);

    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(Potentiometer { max_r: val, taper })))
}

/// Parse a SPICE model name: alphanumeric, hyphens, underscores → uppercase.
fn model_name_str(input: &str) -> IResult<&str, String> {
    let (input, name) = take_while1(|c: char| c.is_alphanumeric() || c == '-' || c == '_')(input)?;
    Ok((input, name.to_uppercase()))
}

fn parse_npn(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("npn")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, name) = opt(model_name_str)(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((
        input,
        Box::new(Npn {
            model: name.unwrap_or_else(|| DEFAULT_NPN_MODEL.to_string()),
        }),
    ))
}

fn parse_pnp(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("pnp")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, name) = opt(model_name_str)(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((
        input,
        Box::new(Pnp {
            model: name.unwrap_or_else(|| DEFAULT_PNP_MODEL.to_string()),
        }),
    ))
}

fn opamp_type(input: &str) -> IResult<&str, OpAmpType> {
    alt((
        // NOTE: "tl071"/"tl072"/"tl082" are all full 5-char tags, so none can
        // prefix-shadow another in this `alt` chain.
        value(OpAmpType::Tl071, tag("tl071")),
        value(OpAmpType::Tl072, tag("tl072")),
        value(OpAmpType::Tl082, tag("tl082")),
        value(OpAmpType::Jrc4558, alt((tag("jrc4558"), tag("4558")))),
        value(OpAmpType::Rc4558, tag("rc4558")),
        value(OpAmpType::Lm308, tag("lm308")),
        value(OpAmpType::Lm741, tag("lm741")),
        value(
            OpAmpType::Ne5532,
            alt((tag("njm5532"), tag("ne5532"), tag("5532"))),
        ),
        value(OpAmpType::Ca3080, tag("ca3080")),
        value(OpAmpType::Op07, tag("op07")),
    ))(input)
}

fn parse_opamp(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("opamp")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, ot) = opt(opamp_type)(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((
        input,
        Box::new(OpAmp {
            op_type: ot.unwrap_or(OpAmpType::Generic),
        }),
    ))
}

fn parse_njfet(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("njfet")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, name) = model_name_str(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(NJfet { model: name })))
}

fn parse_pjfet(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("pjfet")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, name) = model_name_str(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(PJfet { model: name })))
}

fn photocoupler_type(input: &str) -> IResult<&str, PhotocouplerType> {
    alt((
        value(PhotocouplerType::Vtl5c3, tag("vtl5c3")),
        value(PhotocouplerType::Vtl5c1, tag("vtl5c1")),
        value(PhotocouplerType::Nsl32, tag("nsl32")),
        value(PhotocouplerType::T4b, tag("t4b")),
    ))(input)
}

fn parse_photocoupler(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("photocoupler")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, pt) = photocoupler_type(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(PhotocouplerComp { coupler_type: pt })))
}

fn parse_triode(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("triode")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, name) = model_name_str(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(Triode { model: name })))
}

fn parse_pentode(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("pentode")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, name) = model_name_str(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(Pentode { model: name })))
}

fn parse_vari_mu(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("vari_mu")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, name) = model_name_str(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(VariMu { model: name })))
}

fn mosfet_type(input: &str) -> IResult<&str, MosfetType> {
    alt((
        value(MosfetType::N2n7000, tag("2n7000")),
        value(MosfetType::Irf520, tag("irf520")),
        value(MosfetType::Bs250, tag("bs250")),
        value(MosfetType::Irf9520, tag("irf9520")),
    ))(input)
}

fn parse_nmos(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("nmos")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, mt) = mosfet_type(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(Nmos { mosfet_type: mt })))
}

fn parse_pmos(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("pmos")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, mt) = mosfet_type(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(Pmos { mosfet_type: mt })))
}

fn bbd_type(input: &str) -> IResult<&str, BbdType> {
    alt((
        value(BbdType::Mn3207, tag("mn3207")),
        value(BbdType::Mn3007, tag("mn3007")),
        value(BbdType::Mn3005, tag("mn3005")),
    ))(input)
}

/// `bbd(mn3207)` — Bucket-brigade device delay line.
fn parse_bbd(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("bbd")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, bt) = bbd_type(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(Bbd { bbd_type: bt })))
}

/// Spring-tank model keyword. `type9` must precede `type8`/`type4` only by
/// distinctness; `tag` matches a prefix so order the longer-unique first is
/// not needed here (all four are full tokens followed by `)`).
fn spring_type(input: &str) -> IResult<&str, SpringTankType> {
    alt((
        value(SpringTankType::Type4, tag("type4")),
        value(SpringTankType::Type8, tag("type8")),
        value(SpringTankType::Type9, tag("type9")),
        value(SpringTankType::Re201Tank, tag("re201_tank")),
    ))(input)
}

/// `spring(type4)` — dispersive spring-reverb tank (behavioral island).
fn parse_spring(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("spring")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, st) = spring_type(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(Spring { tank_type: st })))
}

/// Parse interpolation mode keyword.
fn interpolation_mode(input: &str) -> IResult<&str, crate::elements::Interpolation> {
    alt((
        value(crate::elements::Interpolation::Linear, tag("linear")),
        value(crate::elements::Interpolation::Allpass, tag("allpass")),
        value(crate::elements::Interpolation::Cubic, tag("cubic")),
    ))(input)
}

/// Parse medium type keyword.
fn medium_type(input: &str) -> IResult<&str, crate::elements::Medium> {
    alt((
        value(crate::elements::Medium::None, tag("none")),
        value(crate::elements::Medium::TapeOxide, tag("tape_oxide")),
        value(crate::elements::Medium::BbdLeakage, tag("bbd_leakage")),
        value(
            crate::elements::Medium::DigitalQuantize,
            tag("digital_quantize"),
        ),
    ))(input)
}

/// `delay_line(1ms, 1200ms)` — Generic delay line.
///
/// Supports optional interpolation mode and medium type:
/// - `delay_line(1ms, 1200ms)` — defaults: allpass interpolation, no medium
/// - `delay_line(1ms, 1200ms, allpass)` — explicit interpolation
/// - `delay_line(1ms, 1200ms, medium: tape_oxide)` — with medium
/// - `delay_line(1ms, 1200ms, allpass, medium: tape_oxide)` — both
fn parse_delay_line(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("delay_line")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, min_delay) = eng_value(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(',')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, max_delay) = eng_value(input)?;
    let (input, _) = ws_comments(input)?;
    // Optional interpolation mode
    let (input, interp) = opt(preceded(pair(char(','), ws_comments), interpolation_mode))(input)?;
    let (input, _) = ws_comments(input)?;
    // Optional medium: keyword
    let (input, medium) = opt(preceded(
        pair(char(','), ws_comments),
        preceded(pair(tag("medium:"), ws_comments), medium_type),
    ))(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    let interp = interp.unwrap_or(crate::elements::Interpolation::Allpass);
    let medium = medium.unwrap_or(crate::elements::Medium::None);
    Ok((
        input,
        Box::new(DelayLineComp {
            min_delay,
            max_delay,
            interpolation: interp,
            medium,
        }),
    ))
}

/// `tap(DL1, 2.0)` — Read-only tap into a named delay line.
///
/// Parameters: parent delay line component ID, ratio relative to base delay.
fn parse_tap(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("tap")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, parent_id) = take_while1(|c: char| c.is_alphanumeric() || c == '_')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(',')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, ratio) = double(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((
        input,
        Box::new(Tap {
            parent_id: parent_id.to_string(),
            ratio,
        }),
    ))
}

fn neon_type(input: &str) -> IResult<&str, NeonType> {
    alt((
        value(
            NeonType::Ne2,
            alt((tag("ne2"), tag("ne-2"), tag("NE2"), tag("NE-2"))),
        ),
        value(
            NeonType::Ne51,
            alt((tag("ne51"), tag("ne-51"), tag("NE51"), tag("NE-51"))),
        ),
        value(
            NeonType::Ne83,
            alt((tag("ne83"), tag("ne-83"), tag("NE83"), tag("NE-83"))),
        ),
    ))(input)
}

/// `neon()` or `neon(ne2)` — Neon bulb for relaxation oscillators.
/// Used in vintage tremolo circuits (Fender Vibrato, Wurlitzer) paired with LDRs.
fn parse_neon(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("neon")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    // Optional type - defaults to NE-2 if empty
    let (input, nt) = opt(neon_type)(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((
        input,
        Box::new(Neon {
            neon_type: nt.unwrap_or_default(),
        }),
    ))
}

// ── Synth component parsers ─────────────────────────────────────────────

fn vco_type(input: &str) -> IResult<&str, VcoType> {
    alt((
        value(VcoType::Cem3340, tag("cem3340")),
        value(VcoType::As3340, tag("as3340")),
        value(VcoType::V3340, tag("v3340")),
    ))(input)
}

fn vco_waveform(input: &str) -> IResult<&str, VcoWaveformDsl> {
    alt((
        value(VcoWaveformDsl::Saw, tag("saw")),
        value(VcoWaveformDsl::Triangle, alt((tag("triangle"), tag("tri")))),
        value(VcoWaveformDsl::Pulse, alt((tag("pulse"), tag("square")))),
    ))(input)
}

fn parse_vco(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("vco")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, vt) = vco_type(input)?;
    let (input, _) = ws_comments(input)?;
    // Optional frequency (default 440 Hz)
    let (input, freq) = opt(preceded(tuple((char(','), ws_comments)), eng_value))(input)?;
    let (input, _) = ws_comments(input)?;
    // Optional waveform (default saw)
    let (input, wf) = opt(preceded(tuple((char(','), ws_comments)), vco_waveform))(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((
        input,
        Box::new(Vco {
            vco_type: vt,
            base_freq: freq.unwrap_or(440.0),
            waveform: wf.unwrap_or(VcoWaveformDsl::Saw),
        }),
    ))
}

fn vcf_type(input: &str) -> IResult<&str, VcfType> {
    alt((
        value(VcfType::Cem3320, tag("cem3320")),
        value(VcfType::As3320, tag("as3320")),
    ))(input)
}

fn parse_vcf(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("vcf")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, vt) = vcf_type(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(Vcf { vcf_type: vt })))
}

fn vca_type(input: &str) -> IResult<&str, VcaType> {
    alt((
        value(VcaType::Ssm2164, tag("ssm2164")),
        value(VcaType::V2164, tag("v2164")),
    ))(input)
}

fn parse_vca(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("vca")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, vt) = vca_type(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(Vca { vca_type: vt })))
}

fn comparator_type(input: &str) -> IResult<&str, ComparatorType> {
    alt((
        value(ComparatorType::Lm311, tag("lm311")),
        value(ComparatorType::Lm393, tag("lm393")),
    ))(input)
}

fn parse_comparator(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("comparator")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, ct) = comparator_type(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(Comparator { comp_type: ct })))
}

fn analog_switch_type(input: &str) -> IResult<&str, AnalogSwitchType> {
    alt((
        value(AnalogSwitchType::Cd4066, tag("cd4066")),
        value(AnalogSwitchType::Dg411, tag("dg411")),
    ))(input)
}

fn parse_analog_switch(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("switch")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, st) = analog_switch_type(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(AnalogSwitch { switch_type: st })))
}

fn matched_transistor_type(input: &str) -> IResult<&str, MatchedTransistorType> {
    alt((
        value(MatchedTransistorType::Ssm2210, tag("ssm2210")),
        value(MatchedTransistorType::Ca3046, tag("ca3046")),
        value(MatchedTransistorType::Lm394, tag("lm394")),
        value(MatchedTransistorType::That340, tag("that340")),
    ))(input)
}

fn parse_matched_npn(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("matched_npn")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, mt) = matched_transistor_type(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(MatchedNpn { matched_type: mt })))
}

fn parse_matched_pnp(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("matched_pnp")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, mt) = matched_transistor_type(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(MatchedPnp { matched_type: mt })))
}

/// `tempco(2k, 3500)` — tempco resistor: nominal_r, ppm/°C
fn parse_tempco(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("tempco")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, resistance) = eng_value(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(',')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, ppm) = double(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((input, Box::new(Tempco { resistance, ppm })))
}

// ═══════════════════════════════════════════════════════════════════════════
// Studio Equipment Parsers
// ═══════════════════════════════════════════════════════════════════════════

/// Parse winding type modifier: `ct` for center-tap, `pp` for push-pull
/// Parse winding modifiers. Returns (winding_type, is_primary).
/// ct = center-tap secondary, ct_primary = center-tap primary, pp = push-pull
fn winding_modifier(input: &str) -> IResult<&str, WindingType> {
    alt((
        value(WindingType::CenterTap, tag("ct")),
        value(WindingType::PushPull, tag("pp")),
    ))(input)
}

/// Parse ct_primary specifically (center-tapped primary)
fn winding_modifier_primary(input: &str) -> IResult<&str, WindingType> {
    value(WindingType::CenterTap, tag("ct_primary"))(input)
}

/// `transformer(10:1, JT11P1)` — model-backed transformer
/// `transformer(10:1, 2H)` — explicit generic transformer
/// `transformer(1:4, 2H, 75, 200p)` — with positional DCR and parasitic cap
/// `transformer(1:1, 4H, ct)` — center-tapped secondary
/// `transformer(1:1, 4H, pp, ct)` — push-pull primary, center-tapped secondary
/// `transformer(10:1, 10H, 150, 300p, ct_primary)` — center-tapped primary
/// `transformer(10:1, 2H, dcr=75, Cp=200p)` — with named parasitics
/// `transformer(10:1, JT11P1, Lm=8H, Rc=250k)` — model-backed with overrides
/// `transformer(10:1, 2H, Llp=20m, Lls=200u, Lm=1.98H, Rc=100k)` — linear T model
///
/// Positional syntax: transformer(ratio, model|inductance [, dcr] [, cap] [, winding_mod])
/// Named syntax: transformer(ratio, model|inductance [, dcr=val] [, Cp=val] [, k=val] [, Lp=val] [, Llp=val] [, Lls=val] [, Lm=val] [, Rc=val])
fn parse_transformer(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("transformer")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;

    // Parse turns ratio: "10:1" or "1:1" or just a number
    let (input, ratio_num) = double(input)?;
    let (input, ratio) = if let Ok((input, _)) = char::<&str, nom::error::Error<&str>>(':')(input) {
        let (input, denom) = double(input)?;
        (input, ratio_num / denom)
    } else {
        (input, ratio_num)
    };

    let (input, _) = ws_comments(input)?;
    let (input, _) = char(',')(input)?;
    let (input, _) = ws_comments(input)?;

    // Parse either model name or explicit primary inductance.
    let (input, mut config) = if let Ok((input, inductance)) = eng_value(input) {
        (input, TransformerConfig::new(ratio, inductance))
    } else {
        let (input, model) = model_name_str(input)?;
        (input, TransformerConfig::with_model(ratio, model))
    };
    let (input, _) = ws_comments(input)?;

    // Parse optional modifiers and named parameters
    let mut positional_count = 0; // Track positional numeric args after inductance

    // Try to parse additional comma-separated options
    let mut remaining = input;
    loop {
        // Check for comma
        if let Ok((input, _)) = tuple((
            ws_comments,
            char::<&str, nom::error::Error<&str>>(','),
            ws_comments,
        ))(remaining)
        {
            remaining = input;

            // Try ct_primary first (must come before ct to match longer tag)
            if let Ok((input, wt)) = winding_modifier_primary(remaining) {
                config.primary_type = wt;
                remaining = input;
                continue;
            }

            // Try other winding modifiers
            if let Ok((input, wt)) = winding_modifier(remaining) {
                // Determine if this is for primary or secondary based on context
                // pp = push-pull primary, ct = center-tap secondary
                if wt == WindingType::PushPull {
                    config.primary_type = wt;
                } else {
                    // ct defaults to secondary unless already set
                    if config.secondary_type == WindingType::Standard {
                        config.secondary_type = wt;
                    } else {
                        config.primary_type = wt;
                    }
                }
                remaining = input;
                continue;
            }

            // Try named parameters: dcr=value, Cp=value, k=value
            if let Ok((input, _)) = tag::<&str, &str, nom::error::Error<&str>>("dcr")(remaining) {
                let (input, _) = ws_comments(input)?;
                let (input, _) = char('=')(input)?;
                let (input, _) = ws_comments(input)?;
                let (input, dcr) = eng_value(input)?;
                config.primary_dcr = dcr;
                config.secondary_dcr = dcr; // Apply to both by default
                remaining = input;
                continue;
            }

            if let Ok((input, _)) =
                alt((tag::<&str, &str, nom::error::Error<&str>>("Cp"), tag("cp")))(remaining)
            {
                let (input, _) = ws_comments(input)?;
                let (input, _) = char('=')(input)?;
                let (input, _) = ws_comments(input)?;
                let (input, cap) = eng_value(input)?;
                config.capacitance = cap;
                remaining = input;
                continue;
            }

            if let Ok((input, _)) = tag::<&str, &str, nom::error::Error<&str>>("k")(remaining) {
                let (input, _) = ws_comments(input)?;
                let (input, _) = char('=')(input)?;
                let (input, _) = ws_comments(input)?;
                let (input, k) = double(input)?;
                config.coupling = k;
                remaining = input;
                continue;
            }

            if let Ok((input, name)) = alt((
                tag::<&str, &str, nom::error::Error<&str>>("Llp"),
                tag("llp"),
                tag("Lls"),
                tag("lls"),
                tag("Lm"),
                tag("lm"),
                tag("Lp"),
                tag("lp"),
                tag("Rc"),
                tag("rc"),
                tag("Idc"),
                tag("idc"),
            ))(remaining)
            {
                let (input, _) = ws_comments(input)?;
                let (input, _) = char('=')(input)?;
                let (input, _) = ws_comments(input)?;
                let (input, value) = eng_value(input)?;
                match name {
                    "Llp" | "llp" => config.primary_leakage = Some(value),
                    "Lls" | "lls" => config.secondary_leakage = Some(value),
                    "Lm" | "lm" => config.magnetizing_inductance = Some(value),
                    "Lp" | "lp" => config.primary_inductance = value,
                    "Rc" | "rc" => config.core_loss_resistance = Some(value),
                    "Idc" | "idc" => config.dc_bias_current = Some(value),
                    _ => unreachable!(),
                }
                remaining = input;
                continue;
            }

            // tertiary=N:M — adds a third winding with its own turns ratio
            if let Ok((input, _)) =
                tag::<&str, &str, nom::error::Error<&str>>("tertiary")(remaining)
            {
                let (input, _) = ws_comments(input)?;
                let (input, _) = char('=')(input)?;
                let (input, _) = ws_comments(input)?;
                let (input, t_num) = double(input)?;
                let (input, t_ratio) =
                    if let Ok((input, _)) = char::<&str, nom::error::Error<&str>>(':')(input) {
                        let (input, denom) = double(input)?;
                        (input, t_num / denom)
                    } else {
                        (input, t_num)
                    };
                config.tertiary_turns_ratio = Some(t_ratio);
                remaining = input;
                continue;
            }

            // Try positional numeric values (DCR, then cap)
            if let Ok((input, val)) = eng_value(remaining) {
                match positional_count {
                    0 => {
                        // First positional = DCR
                        config.primary_dcr = val;
                        config.secondary_dcr = val;
                    }
                    1 => {
                        // Second positional = parasitic capacitance
                        config.capacitance = val;
                    }
                    _ => {
                        // Too many positional args, stop
                        break;
                    }
                }
                positional_count += 1;
                remaining = input;
                continue;
            }

            // Unknown parameter, break
            break;
        } else {
            break;
        }
    }

    let (input, _) = ws_comments(remaining)?;
    let (input, _) = char(')')(input)?;

    Ok((input, Box::new(TransformerComp { config })))
}

/// `tape_head()` — voltage-driven Jiles-Atherton record/playback head.
///
/// Drives the magnetic field from PORT VOLTAGE so tape saturation tracks Drive
/// at line level (the transformer core saturates only at hundreds of mA).
///
/// Forms:
///   `tape_head()`                         — default studio head
///   `tape_head(STUDIO-HEAD)`              — named head model
///   `tape_head(kv=900, a=550, isat=4m)`   — named-parameter overrides
///
/// Override keys: `kv`, `isat`, `gp`, `rp`, `ms`, `a`, `alpha`, `k`, `c`.
fn parse_tape_head(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("tape_head")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;

    let mut config = TapeHeadConfig::studio_head();

    // A key=value override token: an override key immediately followed by '='.
    // Probed with `peek` so a leading bare model name is not mistaken for a key
    // (e.g. `tape_head(kv=...)` must NOT read "kv" as a model name).
    fn override_key(input: &str) -> IResult<&str, &str> {
        let (rest, name) = alt((
            tag("isat"),
            tag("alpha"),
            tag("h_bias"),
            tag("kv"),
            tag("gp"),
            tag("rp"),
            tag("ms"),
            tag("a"),
            tag("k"),
            tag("c"),
        ))(input)?;
        let (rest, _) = ws_comments(rest)?;
        let (rest, _) = peek(char('='))(rest)?;
        Ok((rest, name))
    }

    // Optional leading model name — only if it is NOT a key=value override.
    let input = if peek(override_key)(input).is_ok() {
        input
    } else if let Ok((input, model)) = model_name_str(input) {
        config = TapeHeadConfig::with_model(model.to_string());
        input
    } else {
        input
    };
    let (input, _) = ws_comments(input)?;

    // Comma-separated key=value overrides.
    let mut remaining = input;
    loop {
        if let Ok((input, _)) = tuple((
            ws_comments,
            char::<&str, nom::error::Error<&str>>(','),
            ws_comments,
        ))(remaining)
        {
            remaining = input;
        }

        if let Ok((input, name)) = override_key(remaining) {
            let (input, _) = char('=')(input)?;
            let (input, _) = ws_comments(input)?;
            let (input, value) = eng_value(input)?;
            match name {
                "kv" => config.kv = value,
                "isat" => config.isat = value,
                "gp" => config.gp = value,
                "rp" => config.rp = value,
                "h_bias" => config.h_bias = value,
                "ms" => config.ja_ms = value,
                "a" => config.ja_a = value,
                "alpha" => config.ja_alpha = value,
                "k" => config.ja_k = value,
                "c" => config.ja_c = value,
                _ => unreachable!(),
            }
            remaining = input;
            continue;
        }
        break;
    }

    let (input, _) = ws_comments(remaining)?;
    let (input, _) = char(')')(input)?;

    Ok((input, Box::new(TapeHeadComp { config })))
}

/// `cap_switched([1.5u, 220n, 68n, 27n])` — capacitor with switchable values
fn parse_cap_switched(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("cap_switched")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;

    // Optional opening bracket
    let (input, has_bracket) = opt(char('['))(input)?;
    let (input, _) = ws_comments(input)?;

    // Parse comma-separated values
    let (input, values) =
        separated_list1(tuple((ws_comments, char(','), ws_comments)), eng_value)(input)?;

    let (input, _) = ws_comments(input)?;

    // Closing bracket if we had opening
    let input = if has_bracket.is_some() {
        let (input, _) = char(']')(input)?;
        let (input, _) = ws_comments(input)?;
        input
    } else {
        input
    };

    let (input, _) = char(')')(input)?;

    Ok((input, Box::new(CapSwitched { values })))
}

/// `inductor_switched(27m, 47m, 82m, 150m)` — inductor with switchable values (multi-tap)
/// `inductor_switched([27m, 47m, 82m])` — with optional brackets
fn parse_inductor_switched(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("inductor_switched")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;

    // Optional opening bracket
    let (input, has_bracket) = opt(char('['))(input)?;
    let (input, _) = ws_comments(input)?;

    // Parse comma-separated values
    let (input, values) =
        separated_list1(tuple((ws_comments, char(','), ws_comments)), eng_value)(input)?;

    let (input, _) = ws_comments(input)?;

    // Closing bracket if we had opening
    let input = if has_bracket.is_some() {
        let (input, _) = char(']')(input)?;
        let (input, _) = ws_comments(input)?;
        input
    } else {
        input
    };

    let (input, _) = char(')')(input)?;

    Ok((input, Box::new(InductorSwitched { values })))
}

/// `resistor_switched([12k, 6.8k, 3.9k, 1.5k])` — resistor with switchable values
/// Used for ratio selection networks (1176), feedback networks, etc.
fn parse_resistor_switched(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("resistor_switched")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;

    // Optional opening bracket
    let (input, has_bracket) = opt(char('['))(input)?;
    let (input, _) = ws_comments(input)?;

    // Parse comma-separated values
    let (input, values) =
        separated_list1(tuple((ws_comments, char(','), ws_comments)), eng_value)(input)?;

    let (input, _) = ws_comments(input)?;

    // Closing bracket if we had opening
    let input = if has_bracket.is_some() {
        let (input, _) = char(']')(input)?;
        let (input, _) = ws_comments(input)?;
        input
    } else {
        input
    };

    let (input, _) = char(')')(input)?;

    Ok((input, Box::new(ResistorSwitched { values })))
}

/// `switch(2)` — simple n-position mechanical switch
/// Unlike AnalogSwitch (CD4066), this is a passive mechanical element.
/// Used for mode selection, bypass, etc.
fn parse_trigger_input(input: &str) -> IResult<&str, BoxComp> {
    let (rest, _) = tag("trigger_input()")(input)?;
    Ok((rest, Box::new(TriggerInputComp)))
}

fn parse_switch(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("switch")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, positions) = double(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;

    Ok((
        input,
        Box::new(Switch {
            positions: positions as usize,
        }),
    ))
}

/// `rotary("20Hz", "30Hz", "60Hz", "100Hz")` — rotary switch with position labels
/// `rotary(pos1, pos2, pos3)` — rotary switch with identifier position labels
fn parse_rotary_switch(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("rotary")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;

    // Parse comma-separated position labels (quoted strings or identifiers)
    let (input, labels) = separated_list1(
        tuple((ws_comments, char(','), ws_comments)),
        alt((
            map(quoted_string, String::from),
            map(identifier, String::from),
        )),
    )(input)?;

    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;

    Ok((input, Box::new(RotarySwitch { linked_ids: labels })))
}

fn component_kind(input: &str) -> IResult<&str, BoxComp> {
    alt((
        alt((
            parse_resistor_switched, // must come before parse_resistor
            parse_resistor,
            parse_cap_switched, // must come before parse_cap
            parse_cap,
            parse_inductor_switched, // must come before parse_inductor
            parse_inductor,
            parse_diode_pair, // must come before parse_diode
            parse_diode,
            parse_zener, // zener diode with voltage parameter
            parse_pot,
        )),
        alt((
            parse_npn,
            parse_pnp,
            parse_opamp,
            parse_njfet,
            parse_pjfet,
            parse_photocoupler,
            parse_envelope_follower, // must come before parse_lfo (both are long keywords)
            parse_lfo,
            parse_triode,
            parse_pentode,
            parse_vari_mu,
        )),
        alt((
            parse_nmos,
            parse_pmos,
            parse_bbd,
            parse_spring,
            parse_delay_line,
            parse_tap,
            parse_neon,
            parse_vco,
            parse_vcf,
            parse_vca,
            parse_comparator,
        )),
        alt((
            parse_analog_switch,
            parse_matched_npn, // must come before parse_matched_pnp
            parse_matched_pnp,
            parse_tempco,
            parse_tape_head, // must come before parse_transformer (distinct tag, kept grouped)
            parse_transformer,
            parse_rotary_switch,
            parse_switch, // simple n-position switch
            parse_trigger_input,
        )),
    ))(input)
}

/// `R1: resistor(4.7k)` or `R1: pot(100k, b) mirrors R2`
fn component_def(input: &str) -> IResult<&str, (ComponentDef, Option<String>)> {
    let (input, _) = ws_comments(input)?;
    let (input, id) = identifier(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(':')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, kind) = component_kind(input)?;
    // Optional `mirrors <ident>` suffix for dual-gang pots
    let (input, mirrors_target) = opt(tuple((
        ws_comments,
        tag("mirrors"),
        ws_comments,
        identifier,
    )))(input)?;
    let mirrors = mirrors_target.map(|(_, _, _, target)| target.to_string());
    Ok((
        input,
        (
            ComponentDef {
                id: id.to_string(),
                kind,
            },
            mirrors,
        ),
    ))
}

// ---------------------------------------------------------------------------
// Net parsers
// ---------------------------------------------------------------------------

const RESERVED_NODES: &[&str] = &[
    "in",
    "out",
    "gnd",
    "vcc",
    "fx_send",
    "fx_return",
    // Synth-specific CV/Gate nodes
    "gate",      // Note on/off (0V / +5V)
    "cv_pitch",  // Pitch CV (1V/Oct standard)
    "cv_mod",    // Modulation CV (mod wheel, aftertouch)
    "cv_filter", // Filter cutoff CV
];

/// Parse an identifier or supply rail name (V+, V-, B+, etc.)
/// Supply rails can have + or - suffix which regular identifiers don't allow.
fn identifier_or_supply_rail(input: &str) -> IResult<&str, &str> {
    alt((
        // Special rail names with + or - (e.g., "V+", "V-", "B+")
        recognize(pair(alpha1, alt((char('+'), char('-'))))),
        // Regular identifier
        identifier,
    ))(input)
}

fn pin(input: &str) -> IResult<&str, Pin> {
    let (input, first) = identifier_or_supply_rail(input)?;

    // Parse all dot-separated parts: T1.primary.a -> ["primary", "a"]
    let (input, rest_parts) = many0(preceded(char('.'), identifier))(input)?;

    if rest_parts.is_empty() {
        // No dots — reserved node or bare component
        if RESERVED_NODES.contains(&first) {
            Ok((input, Pin::Reserved(first.to_string())))
        } else {
            // Bare component name treated as reserved-style node (includes supply rails like V+, V-)
            Ok((input, Pin::Reserved(first.to_string())))
        }
    } else {
        // Has dots — component + pin (pin may include sub-parts)
        // T1.primary.a -> component="T1", pin="primary.a"
        let pin_name = rest_parts.join(".");
        Ok((
            input,
            Pin::ComponentPin {
                component: first.to_string(),
                pin: pin_name,
            },
        ))
    }
}

/// Parse a fork destination: `fork(SW_time, [B8.a, B9.a])`
/// Routes signal dynamically based on switch position.
fn parse_fork(input: &str) -> IResult<&str, Pin> {
    let (input, _) = tag("fork")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    // Switch component ID
    let (input, switch_id) = identifier(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(',')(input)?;
    let (input, _) = ws_comments(input)?;
    // Destination list: [pin1, pin2, ...]
    let (input, _) = char('[')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, destinations) =
        separated_list1(tuple((ws_comments, char(','), ws_comments)), pin)(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(']')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((
        input,
        Pin::Fork {
            switch: switch_id.to_string(),
            destinations,
        },
    ))
}

/// Parse a destination pin - either a fork or a regular pin.
fn dest_pin(input: &str) -> IResult<&str, Pin> {
    alt((parse_fork, pin))(input)
}

/// `in -> C1.a`  or  `C1.b -> R1.a, D1.a`  or  `B7.a -> fork(SW_time, [B8.a, B9.a])`
fn net_def(input: &str) -> IResult<&str, NetDef> {
    let (input, _) = ws_comments(input)?;
    let (input, from) = pin(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("->")(input)?;
    let (input, _) = ws_comments(input)?;
    // Destinations can be regular pins or fork() constructs
    let (input, to) =
        separated_list1(tuple((ws_comments, char(','), ws_comments)), dest_pin)(input)?;
    Ok((input, NetDef { from, to }))
}

// ---------------------------------------------------------------------------
// Control parsers
// ---------------------------------------------------------------------------

/// `Gain.position -> "Drive" [0.0, 1.0] = 0.5`
fn control_def(input: &str) -> IResult<&str, ControlDef> {
    let (input, _) = ws_comments(input)?;
    let (input, comp) = identifier(input)?;
    let (input, _) = char('.')(input)?;
    let (input, prop) = identifier(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("->")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, label) = quoted_string(input)?;
    let (input, _) = ws_comments(input)?;
    // [min, max]
    let (input, _) = char('[')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, lo) = double(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(',')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, hi) = double(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(']')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('=')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, def) = double(input)?;
    Ok((
        input,
        ControlDef {
            component: comp.to_string(),
            property: prop.to_string(),
            label: label.to_string(),
            range: (lo, hi),
            default: def,
        },
    ))
}

fn lfo_waveform(input: &str) -> IResult<&str, LfoWaveformDsl> {
    alt((
        value(LfoWaveformDsl::Sine, tag("sine")),
        value(LfoWaveformDsl::Triangle, tag("triangle")),
        value(LfoWaveformDsl::Square, tag("square")),
        value(LfoWaveformDsl::SawUp, tag("saw_up")),
        value(LfoWaveformDsl::SawDown, tag("saw_down")),
        value(LfoWaveformDsl::SampleAndHold, tag("sample_hold")),
    ))(input)
}

/// `envelope_follower(1k, 4.7u, 100k, 1u, 20k)` - attack_r, attack_c, release_r, release_c, sensitivity_r
/// Attack τ = R_attack × C_attack, Release τ = R_release × C_release
/// Sensitivity gain = R_sensitivity / 10kΩ
fn parse_envelope_follower(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("envelope_follower")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, attack_r) = eng_value(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(',')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, attack_c) = eng_value(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(',')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, release_r) = eng_value(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(',')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, release_c) = eng_value(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(',')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, sensitivity_r) = eng_value(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((
        input,
        Box::new(EnvelopeFollower {
            attack_r,
            attack_c,
            release_r,
            release_c,
            sensitivity_r,
        }),
    ))
}

/// `lfo(triangle, 100k, 220n)` - waveform, timing_r, timing_c
/// Frequency is computed as f = 1/(2πRC)
fn parse_lfo(input: &str) -> IResult<&str, BoxComp> {
    let (input, _) = tag("lfo")(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, waveform) = lfo_waveform(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(',')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, timing_r) = eng_value(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(',')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, timing_c) = eng_value(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    Ok((
        input,
        Box::new(Lfo {
            waveform,
            timing_r,
            timing_c,
        }),
    ))
}

// ---------------------------------------------------------------------------
// Section parsers
// ---------------------------------------------------------------------------

/// One entry inside a `components { ... }` block: either a real component
/// definition (with optional `mirrors` target) or a file-based `use(...)`
/// subcircuit instance.
enum ComponentEntry {
    Component(ComponentDef, Option<String>),
    Use(UseInstance),
}

/// Parse one `ident: eng_value` entry inside a `with { }` override block.
fn override_entry(input: &str) -> IResult<&str, (String, f64)> {
    let (input, _) = ws_comments(input)?;
    let (input, comp_id) = identifier(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(':')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, val) = eng_value(input)?;
    Ok((input, (comp_id.to_string(), val)))
}

/// Parse an optional trailing `with { R1: 10k, C1: 22n }` override block.
/// Returns an empty Vec when the block is absent (backward compatible).
fn with_overrides(input: &str) -> IResult<&str, Vec<(String, f64)>> {
    let (input, _) = ws_comments(input)?;
    // Optional: if there is no `with` keyword, return empty overrides.
    if let Ok((input2, _)) = tag::<&str, &str, nom::error::Error<&str>>("with")(input) {
        let (input2, _) = ws_comments(input2)?;
        let (input2, _) = char('{')(input2)?;
        // Parse comma- or whitespace-separated `id: value` entries.
        let mut overrides = Vec::new();
        let mut input2 = input2;
        loop {
            let (rest, _) = ws_comments(input2)?;
            // Try to consume an optional comma separator.
            let rest = if let Ok((r, _)) =
                char::<&str, nom::error::Error<&str>>(',')(rest)
            {
                r
            } else {
                rest
            };
            let (rest, _) = ws_comments(rest)?;
            // Stop at closing brace.
            if rest.starts_with('}') {
                input2 = rest;
                break;
            }
            match override_entry(rest) {
                Ok((r, entry)) => {
                    overrides.push(entry);
                    input2 = r;
                }
                Err(_) => {
                    input2 = rest;
                    break;
                }
            }
        }
        let (input2, _) = ws_comments(input2)?;
        let (input2, _) = char('}')(input2)?;
        Ok((input2, overrides))
    } else {
        Ok((input, Vec::new()))
    }
}

/// Parse a `use(...)` subcircuit instance line: `id: use("path string")`.
/// Tried BEFORE `component_def` so the `use(...)` form is recognized; falls
/// through to a normal component otherwise (backward compatible).
///
/// An optional `with { R1: 10k, C1: 22n }` block may follow the closing `)`.
fn use_instance(input: &str) -> IResult<&str, UseInstance> {
    let (input, _) = ws_comments(input)?;
    let (input, id) = identifier(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(':')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("use")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('(')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, path) = quoted_string(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(')')(input)?;
    let (input, overrides) = with_overrides(input)?;
    Ok((
        input,
        UseInstance {
            id: id.to_string(),
            path: path.to_string(),
            overrides,
        },
    ))
}

fn component_entry(input: &str) -> IResult<&str, ComponentEntry> {
    alt((
        nom::combinator::map(use_instance, ComponentEntry::Use),
        nom::combinator::map(component_def, |(c, m)| ComponentEntry::Component(c, m)),
    ))(input)
}

fn components_section(
    input: &str,
) -> IResult<
    &str,
    (
        Vec<ComponentDef>,
        hashbrown::HashMap<String, String>,
        Vec<UseInstance>,
    ),
> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("components")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('{')(input)?;
    let (input, entries) = many0(component_entry)(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('}')(input)?;
    let mut mirrors = hashbrown::HashMap::new();
    let mut comps = Vec::new();
    let mut uses = Vec::new();
    for entry in entries {
        match entry {
            ComponentEntry::Component(comp, mirror_target) => {
                if let Some(target) = mirror_target {
                    mirrors.insert(comp.id.clone(), target);
                }
                comps.push(comp);
            }
            ComponentEntry::Use(u) => uses.push(u),
        }
    }
    Ok((input, (comps, mirrors, uses)))
}

fn nets_section(input: &str) -> IResult<&str, Vec<NetDef>> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("nets")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('{')(input)?;
    let (input, nets) = many0(net_def)(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('}')(input)?;
    Ok((input, nets))
}

/// Skip a line we can't parse (for forward compatibility)
fn skip_line(input: &str) -> IResult<&str, ()> {
    let (input, _) = ws_comments(input)?;
    // Skip until newline or closing brace
    let (input, _) = take_while(|c: char| c != '\n' && c != '}')(input)?;
    // Consume the newline if present
    let (input, _) = opt(char('\n'))(input)?;
    Ok((input, ()))
}

/// Try to parse a control_def or skip the line if unparsable
fn control_or_skip(input: &str) -> IResult<&str, Option<ControlDef>> {
    let (input, _) = ws_comments(input)?;

    // Check if we're at closing brace
    if input.starts_with('}') {
        return Err(nom::Err::Error(nom::error::Error::new(
            input,
            nom::error::ErrorKind::Char,
        )));
    }

    // Try to parse a control_def
    if let Ok((remaining, ctrl)) = control_def(input) {
        return Ok((remaining, Some(ctrl)));
    }

    // Couldn't parse, skip this line
    let (remaining, _) = skip_line(input)?;
    Ok((remaining, None))
}

// ---------------------------------------------------------------------------
// Ports section parser
// ---------------------------------------------------------------------------

/// Parse a single port definition: `name: input` or `name: output`
fn port_def(input: &str) -> IResult<&str, PortDef> {
    let (input, _) = ws_comments(input)?;
    let (input, name) = identifier(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(':')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, dir_str) = alt((tag("input"), tag("output")))(input)?;
    let direction = match dir_str {
        "input" => pedalkernel_rt::PortDirection::Input,
        "output" => pedalkernel_rt::PortDirection::Output,
        _ => unreachable!(),
    };
    // Optional impedance: input(10k) or output(600)
    let (input, impedance) = opt(delimited(char('('), eng_value, char(')')))(input)?;
    Ok((
        input,
        PortDef {
            name: name.to_string(),
            direction,
            impedance,
        },
    ))
}

/// Parse the `ports { ... }` section.
fn ports_section(input: &str) -> IResult<&str, Vec<PortDef>> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("ports")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('{')(input)?;
    let (input, ports) = many0(port_def)(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('}')(input)?;
    Ok((input, ports))
}

fn controls_section(input: &str) -> IResult<&str, Vec<ControlDef>> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("controls")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('{')(input)?;

    // Parse controls, skipping lines we can't understand
    let (input, items) = many0(control_or_skip)(input)?;
    let ctrls: Vec<ControlDef> = items.into_iter().flatten().collect();

    let (input, _) = ws_comments(input)?;
    let (input, _) = char('}')(input)?;
    Ok((input, ctrls))
}

/// Internal trim pots (factory adjustments, not user-facing).
/// Same syntax as controls section, parsed identically.
fn trims_section(input: &str) -> IResult<&str, Vec<ControlDef>> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("trims")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('{')(input)?;

    // Parse trims, skipping lines we can't understand
    let (input, items) = many0(control_or_skip)(input)?;
    let trims: Vec<ControlDef> = items.into_iter().flatten().collect();

    let (input, _) = ws_comments(input)?;
    let (input, _) = char('}')(input)?;
    Ok((input, trims))
}

// ---------------------------------------------------------------------------
// Monitors Section
// ---------------------------------------------------------------------------

/// Parse meter type: vu, ppm, peak, gr, glow, sag
fn meter_type(input: &str) -> IResult<&str, MeterType> {
    alt((
        value(MeterType::Vu, alt((tag("vu"), tag("VU")))),
        value(MeterType::Ppm, alt((tag("ppm"), tag("PPM")))),
        value(MeterType::Peak, alt((tag("peak"), tag("PEAK")))),
        value(
            MeterType::GainReduction,
            alt((tag("gr"), tag("GR"), tag("gain_reduction"))),
        ),
        value(MeterType::TubeGlow, alt((tag("glow"), tag("tube_glow")))),
        value(MeterType::SupplySag, alt((tag("sag"), tag("supply_sag")))),
    ))(input)
}

/// Parse a single monitor definition:
/// `V1.plate_current -> "Tube 1" [vu]`
/// `output -> "Output Level" [ppm]`
fn monitor_def(input: &str) -> IResult<&str, MonitorDef> {
    let (input, _) = ws_comments(input)?;
    let (input, component) = identifier(input)?;
    let (input, _) = ws_comments(input)?;

    // Optional property (defaults to "level")
    let (input, property) = opt(preceded(char('.'), identifier))(input)?;
    let property = property.unwrap_or("level").to_string();

    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("->")(input)?;
    let (input, _) = ws_comments(input)?;

    // Label in quotes
    let (input, label) = quoted_string(input)?;
    let (input, _) = ws_comments(input)?;

    // Meter type in brackets: [vu] or [ppm]
    let (input, _) = char('[')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, mtype) = meter_type(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(']')(input)?;

    Ok((
        input,
        MonitorDef {
            component: component.to_string(),
            property,
            label: label.to_string(),
            meter_type: mtype,
        },
    ))
}

/// Try to parse a monitor_def, or skip the line if we can't understand it.
fn monitor_or_skip(input: &str) -> IResult<&str, Option<MonitorDef>> {
    let (input, _) = ws_comments(input)?;

    // Check if we're at closing brace
    if input.starts_with('}') {
        return Err(nom::Err::Error(nom::error::Error::new(
            input,
            nom::error::ErrorKind::Char,
        )));
    }

    // Try to parse a monitor_def
    if let Ok((remaining, mon)) = monitor_def(input) {
        return Ok((remaining, Some(mon)));
    }

    // Couldn't parse, skip this line
    let (remaining, _) = skip_line(input)?;
    Ok((remaining, None))
}

/// Parse the monitors section.
fn monitors_section(input: &str) -> IResult<&str, Vec<MonitorDef>> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("monitors")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('{')(input)?;

    // Parse monitors, skipping lines we can't understand
    let (input, maybe_mons) = many0(monitor_or_skip)(input)?;
    let mons: Vec<MonitorDef> = maybe_mons.into_iter().flatten().collect();

    let (input, _) = ws_comments(input)?;
    let (input, _) = char('}')(input)?;
    Ok((input, mons))
}

// ---------------------------------------------------------------------------
// Sidechain section
// ---------------------------------------------------------------------------

/// Parse a single sidechain field: `key: value`
fn sidechain_field<'a>(input: &'a str, key: &str) -> IResult<&'a str, &'a str> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag(key)(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(':')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, val) = take_while1(|c: char| c.is_alphanumeric() || c == '_')(input)?;
    Ok((input, val))
}

/// Parse a `sidechain { tap: ..., cv: ..., target: ... }` block.
fn sidechain_def(input: &str) -> IResult<&str, SidechainInfo> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("sidechain")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('{')(input)?;

    let mut tap_node = None;
    let mut cv_node = None;
    let mut target = None;

    let mut input = input;
    loop {
        let (rest, _) = ws_comments(input)?;
        if let Ok((rest2, _)) = char::<&str, nom::error::Error<&str>>('}')(rest) {
            input = rest2;
            break;
        }
        if let Ok((rest2, val)) = sidechain_field(rest, "tap") {
            tap_node = Some(val.to_string());
            input = rest2;
        } else if let Ok((rest2, val)) = sidechain_field(rest, "cv") {
            cv_node = Some(val.to_string());
            input = rest2;
        } else if let Ok((rest2, val)) = sidechain_field(rest, "target") {
            target = Some(match val {
                "push_pull_grid" => SidechainTarget::PushPullGridBias,
                _ => SidechainTarget::PushPullGridBias, // default
            });
            input = rest2;
        } else {
            // Skip unknown line
            let (rest2, _) = take_till(|c| c == '\n' || c == '}')(rest)?;
            input = rest2;
        }
    }

    let info = SidechainInfo {
        tap_node: tap_node.unwrap_or_default(),
        cv_node: cv_node.unwrap_or_default(),
        target: target.unwrap_or(SidechainTarget::PushPullGridBias),
    };

    Ok((input, info))
}

/// Parse a `sidechains { ... }` section containing one or more sidechain definitions.
fn sidechains_section(input: &str) -> IResult<&str, Vec<SidechainInfo>> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("sidechains")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('{')(input)?;

    let (input, sidechains) = many0(sidechain_def)(input)?;

    let (input, _) = ws_comments(input)?;
    let (input, _) = char('}')(input)?;
    Ok((input, sidechains))
}

// ---------------------------------------------------------------------------
// Top-level
// ---------------------------------------------------------------------------

/// Parse an optional supply voltage declaration.
///
/// Simple form: `supply 9V` or `supply 250V`
/// Block form:
/// ```text
/// supply 480V {
///     impedance: 150        # ohms
///     filter_cap: 40u       # farads
///     rectifier: tube       # or solid_state
/// }
/// ```
fn supply_section(input: &str) -> IResult<&str, SupplyConfig> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("supply")(input)?;
    let (input, _) = ws_comments(input)?;
    // Parse the voltage value - can be like "9V", "9.0V", "250V", etc.
    // Also support "9v" lowercase
    let (input, voltage) = recognize(pair(double, opt(alt((char('V'), char('v'))))))(input)?;
    // Extract just the numeric part
    let num_str = voltage.trim_end_matches(['V', 'v']);
    let volts = num_str.parse::<f64>().unwrap_or(9.0);

    // Try to parse an optional block with sag parameters
    let (input, block) = opt(supply_block)(input)?;

    let config = if let Some((impedance, filter_cap, rectifier)) = block {
        SupplyConfig {
            voltage: volts,
            impedance,
            filter_cap,
            rectifier: rectifier.unwrap_or_default(),
        }
    } else {
        SupplyConfig::voltage_only(volts)
    };

    Ok((input, config))
}

/// Parse the body of a supply block: `{ impedance: 150, filter_cap: 40u, rectifier: tube }`
fn supply_block(input: &str) -> IResult<&str, (Option<f64>, Option<f64>, Option<RectifierType>)> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('{')(input)?;

    let mut impedance = None;
    let mut filter_cap = None;
    let mut rectifier = None;

    let mut input = input;
    loop {
        let (rest, _) = ws_comments(input)?;
        // Skip optional comma separators between fields
        let rest = if let Ok((r, _)) = char::<&str, nom::error::Error<&str>>(',')(rest) {
            let (r, _) = ws_comments(r)?;
            r
        } else {
            rest
        };
        // Check for closing brace
        if let Ok((rest2, _)) = char::<&str, nom::error::Error<&str>>('}')(rest) {
            input = rest2;
            break;
        }
        // Try parsing each field
        if let Ok((rest2, val)) = supply_field_impedance(rest) {
            impedance = Some(val);
            input = rest2;
        } else if let Ok((rest2, val)) = supply_field_filter_cap(rest) {
            filter_cap = Some(val);
            input = rest2;
        } else if let Ok((rest2, val)) = supply_field_rectifier(rest) {
            rectifier = Some(val);
            input = rest2;
        } else {
            // Unknown field — skip to next comma, line, or closing brace
            let (rest2, _) = take_till(|c| c == ',' || c == '\n' || c == '}')(rest)?;
            input = rest2;
        }
    }

    Ok((input, (impedance, filter_cap, rectifier)))
}

/// Parse `impedance: 150` (value in ohms).
fn supply_field_impedance(input: &str) -> IResult<&str, f64> {
    let (input, _) = tag("impedance")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(':')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, val) = eng_value(input)?;
    // Skip optional inline comment
    let (input, _) = opt(preceded(ws_comments, preceded(char('#'), not_line_ending)))(input)?;
    Ok((input, val))
}

/// Parse `filter_cap: 40u` (value in farads).
fn supply_field_filter_cap(input: &str) -> IResult<&str, f64> {
    let (input, _) = tag("filter_cap")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(':')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, val) = eng_value(input)?;
    // Skip optional inline comment
    let (input, _) = opt(preceded(ws_comments, preceded(char('#'), not_line_ending)))(input)?;
    Ok((input, val))
}

/// Parse `rectifier: tube` or `rectifier: solid_state`.
fn supply_field_rectifier(input: &str) -> IResult<&str, RectifierType> {
    let (input, _) = tag("rectifier")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(':')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, rtype) = alt((
        value(RectifierType::Tube, tag("tube")),
        value(RectifierType::SolidState, tag("solid_state")),
    ))(input)?;
    // Skip optional inline comment
    let (input, _) = opt(preceded(ws_comments, preceded(char('#'), not_line_ending)))(input)?;
    Ok((input, rtype))
}

/// Parse a single named supply rail declaration.
///
/// Examples:
/// - `V+: 15V`
/// - `V-: -15V`
/// - `B+: 300V { impedance: 100, rectifier: tube }`
fn named_supply(input: &str) -> IResult<&str, NamedSupply> {
    let (input, _) = ws_comments(input)?;
    // Parse rail name - can be identifier or special chars like "V+", "V-"
    let (input, name) = identifier_or_supply_rail(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(':')(input)?;
    let (input, _) = ws_comments(input)?;

    // Parse optional negative sign for voltage
    let (input, is_negative) = opt(char('-'))(input)?;

    // Parse the voltage value
    let (input, voltage_str) = recognize(pair(double, opt(alt((char('V'), char('v'))))))(input)?;
    let num_str = voltage_str.trim_end_matches(['V', 'v']);
    let mut volts = num_str.parse::<f64>().unwrap_or(9.0);
    if is_negative.is_some() {
        volts = -volts;
    }

    // Try to parse an optional block with sag parameters
    let (input, block) = opt(supply_block)(input)?;

    let config = if let Some((impedance, filter_cap, rectifier)) = block {
        SupplyConfig {
            voltage: volts,
            impedance,
            filter_cap,
            rectifier: rectifier.unwrap_or_default(),
        }
    } else {
        SupplyConfig::voltage_only(volts)
    };

    Ok((
        input,
        NamedSupply {
            name: name.to_string(),
            config,
        },
    ))
}

/// Parse a `supplies { }` block with multiple named supply rails.
///
/// Example:
/// ```text
/// supplies {
///     V+: 15V
///     V-: -15V
///     B+: 300V { impedance: 100, rectifier: tube }
/// }
/// ```
fn supplies_section(input: &str) -> IResult<&str, Vec<NamedSupply>> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("supplies")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('{')(input)?;

    let (input, supplies) = many0(named_supply)(input)?;

    let (input, _) = ws_comments(input)?;
    let (input, _) = char('}')(input)?;

    Ok((input, supplies))
}

// ---------------------------------------------------------------------------
// Subcircuit section
// ---------------------------------------------------------------------------

/// Parse a `rate: 1/N` declaration where N must be a power of two.
fn parse_rate(input: &str) -> IResult<&str, u32> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("rate")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(':')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("1")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('/')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, divisor) = nom::character::complete::u32(input)?;
    // Validate power of two
    if divisor == 0 || (divisor & (divisor - 1)) != 0 {
        return Err(nom::Err::Failure(nom::error::Error::new(
            input,
            nom::error::ErrorKind::Verify,
        )));
    }
    Ok((input, divisor))
}

/// Parse a single `subcircuit name { ... }` block.
fn subcircuit_block(input: &str) -> IResult<&str, SubcircuitDef> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("subcircuit")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, name) = identifier(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('{')(input)?;

    // Optional rate declaration
    let (input, rate) = opt(parse_rate)(input)?;

    // Parse inner sections (same as parse_pedal internals)
    // `use(...)` instances are not supported inside inline subcircuit blocks;
    // discard any third tuple element.
    let (input, (components, mirrors, _uses)) = components_section(input)?;
    let (input, nets) = nets_section(input)?;
    let (input, controls) = opt(controls_section)(input)?;
    let (input, trims) = opt(trims_section)(input)?;
    let (input, monitors) = opt(monitors_section)(input)?;

    let (input, _) = ws_comments(input)?;
    let (input, _) = char('}')(input)?;

    Ok((
        input,
        SubcircuitDef {
            name: name.to_string(),
            rate,
            components,
            nets,
            controls: controls.unwrap_or_default(),
            trims: trims.unwrap_or_default(),
            monitors: monitors.unwrap_or_default(),
            mirrors,
        },
    ))
}

/// Reclassify `ComponentPin` references in top-level nets where the "component"
/// name matches a declared subcircuit. `audio.ctrl` parsed as `ComponentPin`
/// becomes `SubcircuitPort { subcircuit: "audio", port: "ctrl" }`.
fn resolve_subcircuit_pins(pedal: &mut PedalDef) {
    use std::collections::HashSet;
    // Both inline subcircuit names AND file-based `use(...)` instance ids are
    // treated as subcircuit-port owners: a net pin `id.port` resolves to a
    // `Pin::SubcircuitPort { subcircuit: id, port }`. The file-based ones are
    // later consumed by `crate::dsl_expand::expand_uses`.
    let mut sc_names: HashSet<&str> = pedal.subcircuits.iter().map(|s| s.name.as_str()).collect();
    for u in &pedal.uses {
        sc_names.insert(u.id.as_str());
    }
    if sc_names.is_empty() {
        return;
    }

    fn resolve_pin(pin: &Pin, sc_names: &std::collections::HashSet<&str>) -> Pin {
        match pin {
            Pin::ComponentPin {
                component,
                pin: port,
            } if sc_names.contains(component.as_str()) => Pin::SubcircuitPort {
                subcircuit: component.clone(),
                port: port.clone(),
            },
            Pin::Fork {
                switch,
                destinations,
            } => Pin::Fork {
                switch: switch.clone(),
                destinations: destinations
                    .iter()
                    .map(|d| resolve_pin(d, sc_names))
                    .collect(),
            },
            other => other.clone(),
        }
    }

    for net in &mut pedal.nets {
        net.from = resolve_pin(&net.from, &sc_names);
        net.to = net.to.iter().map(|p| resolve_pin(p, &sc_names)).collect();
    }
}

fn parse_subtitle(input: &str) -> IResult<&str, String> {
    let (input, _) = tag("subtitle")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, s) = quoted_string(input)?;
    let (input, _) = ws_comments(input)?;
    Ok((input, s.to_string()))
}

/// Parse the `calibrate` keyword (opt-in output level auto-normalization).
fn parse_calibrate(input: &str) -> IResult<&str, ()> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("calibrate")(input)?;
    let (input, _) = ws_comments(input)?;
    Ok((input, ()))
}

// ─────────────────────────────────────────────────────────────────────────────
// Init block parser
// ─────────────────────────────────────────────────────────────────────────────

/// Valid named initial states for NL devices.
const VALID_INIT_STATES: &[&str] = &["saturated", "cutoff", "active", "forward", "reverse"];

/// Parse one `DeviceLabel: state_name` line inside an `init { ... }` block.
fn parse_init_hint(input: &str) -> IResult<&str, InitHint> {
    let (input, _) = ws_comments(input)?;
    let (input, label) = identifier(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(':')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, state_str) = identifier(input)?;
    let (input, _) = ws_comments(input)?;

    if !VALID_INIT_STATES.contains(&state_str) {
        return Err(nom::Err::Failure(nom::error::Error::new(
            input,
            nom::error::ErrorKind::Tag,
        )));
    }

    Ok((
        input,
        InitHint {
            device_label: label.to_string(),
            state: InitState::Named(state_str.to_string()),
        },
    ))
}

/// Parse the optional `init { ... }` block.
///
/// ```text
/// init {
///     Q1: saturated
///     Q2: cutoff
/// }
/// ```
fn init_section(input: &str) -> IResult<&str, Vec<InitHint>> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("init")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('{')(input)?;
    let (input, hints) = many0(parse_init_hint)(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('}')(input)?;
    Ok((input, hints))
}

/// Parse one explicit per-device operating-point entry inside an `op { }` block.
///
/// ```text
/// Q1: { vbe: 0.64, vce: 5.35 }
/// ```
///
/// Fields may appear in any order and are comma- or whitespace-separated. Both
/// `vbe` and `vce` are required (a BJT's two nonlinear ports). Each entry yields
/// an [`InitHint`] carrying [`InitState::Explicit`].
fn parse_op_entry(input: &str) -> IResult<&str, InitHint> {
    let (input, _) = ws_comments(input)?;
    let (input, label) = identifier(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char(':')(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('{')(input)?;

    let mut vbe: Option<f64> = None;
    let mut vce: Option<f64> = None;
    let mut rest = input;
    loop {
        let (r, _) = ws_comments(rest)?;
        // End of entry?
        if let Ok((r2, _)) = char::<&str, nom::error::Error<&str>>('}')(r) {
            rest = r2;
            break;
        }
        let (r, field) = identifier(r)?;
        let (r, _) = ws_comments(r)?;
        let (r, _) = char(':')(r)?;
        let (r, _) = ws_comments(r)?;
        let (r, val) = double(r)?;
        match field {
            "vbe" => vbe = Some(val),
            "vce" => vce = Some(val),
            _ => {
                return Err(nom::Err::Failure(nom::error::Error::new(
                    r,
                    nom::error::ErrorKind::Tag,
                )));
            }
        }
        // Optional separator (comma).
        let (r, _) = ws_comments(r)?;
        let (r, _) = opt(char(','))(r)?;
        rest = r;
    }
    let (input, _) = ws_comments(rest)?;
    // Optional trailing separator between entries.
    let (input, _) = opt(char(','))(input)?;

    let (vbe, vce) = match (vbe, vce) {
        (Some(b), Some(c)) => (b, c),
        _ => {
            return Err(nom::Err::Failure(nom::error::Error::new(
                input,
                nom::error::ErrorKind::Tag,
            )));
        }
    };

    Ok((
        input,
        InitHint {
            device_label: label.to_string(),
            state: InitState::Explicit { vbe, vce },
        },
    ))
}

/// Parse the optional `op { ... }` block: explicit per-device operating-point
/// seeds (terminal voltages) used as a pure NR warm-start.
///
/// ```text
/// op {
///     Q1: { vbe: 0.64, vce: 5.35 }
///     Q2: { vbe: 0.54, vce: 18.8 }
/// }
/// ```
fn op_section(input: &str) -> IResult<&str, Vec<InitHint>> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("op")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('{')(input)?;
    let (input, hints) = many0(parse_op_entry)(input)?;
    // Optional `nodes { name: voltage, ... }` sub-block: node-voltage seeds for
    // reactive (capacitor) ports. Parsed AFTER the per-device entries so it does
    // not collide with `Label: { vbe, vce }`.
    let (input, node_hints) = opt(op_nodes_block)(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('}')(input)?;
    let mut hints = hints;
    if let Some(mut nh) = node_hints {
        hints.append(&mut nh);
    }
    Ok((input, hints))
}

/// Parse the optional `nodes { name: voltage, ... }` sub-block inside `op { }`.
///
/// ```text
/// op {
///     Q3: { vbe: 0.64, vce: 5.35 }
///     nodes { Q3.base: 1.0308, Q3.collector: 5.7426, in: 0.0 }
/// }
/// ```
///
/// Each entry becomes an [`InitHint`] with the node name in `device_label` and
/// an [`InitState::NodeVoltage`].
fn op_nodes_block(input: &str) -> IResult<&str, Vec<InitHint>> {
    let (input, _) = ws_comments(input)?;
    let (input, _) = tag("nodes")(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, _) = char('{')(input)?;
    let mut hints = Vec::new();
    let mut rest = input;
    loop {
        let (r, _) = ws_comments(rest)?;
        if let Ok((r2, _)) = char::<&str, nom::error::Error<&str>>('}')(r) {
            rest = r2;
            break;
        }
        // Node names may contain a dot (e.g. `Q3.base`); accept identifier with
        // an optional `.pin` suffix.
        let (r, head) = identifier(r)?;
        let (r, tail) = opt(|i| {
            let (i, _) = char('.')(i)?;
            identifier(i)
        })(r)?;
        let name = match tail {
            Some(pin) => format!("{head}.{pin}"),
            None => head.to_string(),
        };
        let (r, _) = ws_comments(r)?;
        let (r, _) = char(':')(r)?;
        let (r, _) = ws_comments(r)?;
        let (r, val) = double(r)?;
        hints.push(InitHint {
            device_label: name,
            state: InitState::NodeVoltage { v: val },
        });
        let (r, _) = ws_comments(r)?;
        let (r, _) = opt(char(','))(r)?;
        rest = r;
    }
    Ok((rest, hints))
}

/// Parse a complete `.pedal` or `.synth` file.
/// Both `pedal "Name" { ... }` and `synth "Name" { ... }` produce the same AST.
pub fn parse_pedal(input: &str) -> IResult<&str, PedalDef> {
    let (input, _) = ws_comments(input)?;
    // Accept both "pedal" and "synth" keywords — same AST, different semantics
    let (input, _) = alt((tag("pedal"), tag("synth"), tag("equipment")))(input)?;
    let (input, _) = ws_comments(input)?;
    let (input, name) = quoted_string(input)?;
    let (input, _) = ws_comments(input)?;

    // Optional subtitle before the opening brace:
    //   pedal "GOLDENROD" subtitle "Klon Centaur — transparent overdrive" {
    let (input, subtitle) = opt(parse_subtitle)(input)?;

    let (input, _) = char('{')(input)?;

    // Try multi-supply block first: `supplies { V+: 15V, V-: -15V }`
    // Fall back to legacy single supply: `supply 9V`
    // If neither, supplies will be empty (compiler defaults to 9V "vcc")
    let (input, supplies) = if let Ok((rest, multi)) = supplies_section(input) {
        (rest, multi)
    } else if let Ok((rest, single)) = supply_section(input) {
        // Convert legacy single supply to named "vcc" rail
        (rest, vec![NamedSupply::with_config("vcc", single)])
    } else {
        (input, Vec::new())
    };

    // Parse optional subcircuit blocks (zero or more, before components)
    let (input, subcircuits) = many0(subcircuit_block)(input)?;

    // Parse optional ports section (before components — ports declare
    // named voltage nodes that can be referenced in nets)
    let (input, ports) = opt(ports_section)(input)?;

    // When subcircuits are present, the top-level components/nets become
    // an optional routing layer. When absent, keep existing required behavior.
    let (input, (components, mirrors, uses)) = if subcircuits.is_empty() {
        components_section(input)?
    } else if let Ok((rest, result)) = components_section(input) {
        (rest, result)
    } else {
        (input, (Vec::new(), hashbrown::HashMap::new(), Vec::new()))
    };
    let (input, nets) = if subcircuits.is_empty() {
        nets_section(input)?
    } else if let Ok((rest, result)) = nets_section(input) {
        (rest, result)
    } else {
        (input, Vec::new())
    };
    let (input, controls) = opt(controls_section)(input)?;
    let (input, trims) = opt(trims_section)(input)?;
    let (input, monitors) = opt(monitors_section)(input)?;
    let (input, sidechains) = opt(sidechains_section)(input)?;
    let (input, calibrate) = opt(parse_calibrate)(input)?;
    let (input, init_hints) = opt(init_section)(input)?;
    // Optional `op { }` block: explicit per-device operating-point seeds. These
    // are merged into the same `init_hints` vector (carried as
    // `InitState::Explicit`), so they flow through the existing init-hint wiring.
    let (input, op_hints) = opt(op_section)(input)?;

    let (input, _) = ws_comments(input)?;
    let (input, _) = char('}')(input)?;
    let (input, _) = ws_comments(input)?;

    let mut pedal = PedalDef {
        name: name.to_string(),
        subtitle,
        supplies,
        components,
        nets,
        controls: controls.unwrap_or_default(),
        trims: trims.unwrap_or_default(),
        monitors: monitors.unwrap_or_default(),
        sidechains: sidechains.unwrap_or_default(),
        mirrors,
        calibrate: calibrate.is_some(),
        subcircuits,
        ports: ports.unwrap_or_default(),
        init_hints: {
            let mut h = init_hints.unwrap_or_default();
            h.extend(op_hints.unwrap_or_default());
            h
        },
        uses,
    };
    resolve_subcircuit_pins(&mut pedal);
    Ok((input, pedal))
}

/// Convenience wrapper that returns `Result`.
pub fn parse_pedal_file(src: &str) -> Result<PedalDef, String> {
    match parse_pedal(src) {
        Ok(("", def)) => Ok(def),
        Ok((rest, _)) => Err(format!("Trailing input: {:?}", &rest[..rest.len().min(60)])),
        Err(e) => Err(format!("Parse error: {e}")),
    }
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;
    use crate::compiler::component::Component;
    use crate::compiler::components::*;

    #[test]
    fn parse_eng_value_k() {
        let (_, v) = eng_value("4.7k").unwrap();
        assert!((v - 4700.0).abs() < 1e-6);
    }

    #[test]
    fn parse_eng_value_n() {
        let (_, v) = eng_value("220n").unwrap();
        assert!((v - 220e-9).abs() < 1e-18);
    }

    #[test]
    fn parse_eng_value_m() {
        let (_, v) = eng_value("100m").unwrap();
        assert!((v - 0.1).abs() < 1e-10);
    }

    #[test]
    #[allow(non_snake_case)]
    fn parse_eng_value_M() {
        let (_, v) = eng_value("1M").unwrap();
        assert!((v - 1e6).abs() < 1e-2);
    }

    #[test]
    fn parse_eng_value_inf() {
        let (_, v) = eng_value("inf").unwrap();
        assert!(v.is_infinite() && v.is_sign_positive());
    }

    #[test]
    fn parse_resistor_switched_with_inf() {
        let (_, (c, _)) = component_def("R_sel: resistor_switched(10k, inf, 47k)").unwrap();
        assert_eq!(c.id, "R_sel");
        let rs = c
            .kind
            .as_any()
            .downcast_ref::<ResistorSwitched>()
            .expect("expected ResistorSwitched");
        assert_eq!(rs.values.len(), 3);
        assert!((rs.values[0] - 10_000.0).abs() < 1e-6);
        assert!(rs.values[1].is_infinite());
        assert!((rs.values[2] - 47_000.0).abs() < 1e-6);
    }

    #[test]
    fn parse_resistor_switched_inf_only() {
        // Open circuit position only
        let (_, (c, _)) = component_def("R_open: resistor_switched([inf])").unwrap();
        let rs = c
            .kind
            .as_any()
            .downcast_ref::<ResistorSwitched>()
            .expect("expected ResistorSwitched");
        assert_eq!(rs.values.len(), 1);
        assert!(rs.values[0].is_infinite());
    }

    #[test]
    fn parse_component_resistor() {
        let (_, (c, _)) = component_def("R1: resistor(4.7k)").unwrap();
        assert_eq!(c.id, "R1");
        assert_eq!(
            c.kind.as_any().downcast_ref::<Resistor>().unwrap(),
            &Resistor { value: 4700.0 }
        );
    }

    #[test]
    fn parse_component_cap() {
        let (_, (c, _)) = component_def("C1: cap(220n)").unwrap();
        assert_eq!(c.id, "C1");
        let cap = c
            .kind
            .as_any()
            .downcast_ref::<Capacitor>()
            .expect("expected Capacitor");
        assert!((cap.config.value - 220e-9).abs() < 1e-18);
        assert_eq!(cap.config.cap_type, CapType::Film); // default
        assert!(cap.config.leakage.is_none());
        assert!(cap.config.da.is_none());
    }

    #[test]
    fn parse_component_cap_electrolytic() {
        let (_, (c, _)) = component_def("C1: cap(22u, electrolytic)").unwrap();
        let cap = c
            .kind
            .as_any()
            .downcast_ref::<Capacitor>()
            .expect("expected Capacitor");
        assert!((cap.config.value - 22e-6).abs() < 1e-15);
        assert_eq!(cap.config.cap_type, CapType::Electrolytic);
        assert!(cap.config.leakage.is_none());
        assert!(cap.config.da.is_none());
    }

    #[test]
    fn parse_component_cap_with_leakage() {
        let (_, (c, _)) = component_def("C1: cap(22u, electrolytic, leakage: 100k)").unwrap();
        let cap = c
            .kind
            .as_any()
            .downcast_ref::<Capacitor>()
            .expect("expected Capacitor");
        assert!((cap.config.value - 22e-6).abs() < 1e-15);
        assert_eq!(cap.config.cap_type, CapType::Electrolytic);
        assert!((cap.config.leakage.unwrap() - 100_000.0).abs() < 1.0);
        assert!(cap.config.da.is_none());
    }

    #[test]
    fn parse_component_cap_with_da() {
        let (_, (c, _)) =
            component_def("C1: cap(22u, electrolytic, leakage: 10k, da: 0.05)").unwrap();
        let cap = c
            .kind
            .as_any()
            .downcast_ref::<Capacitor>()
            .expect("expected Capacitor");
        assert!((cap.config.value - 22e-6).abs() < 1e-15);
        assert_eq!(cap.config.cap_type, CapType::Electrolytic);
        assert!((cap.config.leakage.unwrap() - 10_000.0).abs() < 1.0);
        assert!((cap.config.da.unwrap() - 0.05).abs() < 0.001);
    }

    #[test]
    fn parse_component_diode_pair() {
        let (_, (c, _)) = component_def("D1: diode_pair(silicon)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<DiodePair>().unwrap(),
            &DiodePair {
                diode_type: DiodeType::Silicon
            }
        );
    }

    #[test]
    fn parse_component_pot() {
        let (_, (c, _)) = component_def("Gain: pot(500k)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Potentiometer>().unwrap(),
            &Potentiometer {
                max_r: 500_000.0,
                taper: PotTaper::B
            }
        );
    }

    #[test]
    fn parse_component_pot_with_taper() {
        // Audio taper
        let (_, (c, _)) = component_def("Vol: pot(100k, a)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Potentiometer>().unwrap(),
            &Potentiometer {
                max_r: 100_000.0,
                taper: PotTaper::A
            }
        );

        // Linear taper
        let (_, (c, _)) = component_def("Tone: pot(10k, b)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Potentiometer>().unwrap(),
            &Potentiometer {
                max_r: 10_000.0,
                taper: PotTaper::B
            }
        );

        // Reverse log taper
        let (_, (c, _)) = component_def("Mix: pot(50k, c)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Potentiometer>().unwrap(),
            &Potentiometer {
                max_r: 50_000.0,
                taper: PotTaper::C
            }
        );

        // Legacy names
        let (_, (c, _)) = component_def("P1: pot(1M, log)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Potentiometer>().unwrap(),
            &Potentiometer {
                max_r: 1_000_000.0,
                taper: PotTaper::A
            }
        );

        let (_, (c, _)) = component_def("P2: pot(25k, linear)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Potentiometer>().unwrap(),
            &Potentiometer {
                max_r: 25_000.0,
                taper: PotTaper::B
            }
        );
    }

    #[test]
    fn parse_component_pot_mirrors() {
        let (_, (c, m)) = component_def("Gain_B: pot(100k, b) mirrors Gain_A").unwrap();
        assert_eq!(c.id, "Gain_B");
        assert_eq!(
            c.kind.as_any().downcast_ref::<Potentiometer>().unwrap(),
            &Potentiometer {
                max_r: 100_000.0,
                taper: PotTaper::B
            }
        );
        assert_eq!(m, Some("Gain_A".to_string()));
    }

    #[test]
    fn parse_component_pot_no_mirrors() {
        let (_, (c, m)) = component_def("Gain_A: pot(100k, b)").unwrap();
        assert_eq!(c.id, "Gain_A");
        assert_eq!(m, None);
    }

    #[test]
    fn parse_mirrors_in_full_pedal() {
        let src = r#"
            pedal "Dual Gang Test" {
                components {
                    Gain_A: pot(100k, b)
                    Gain_B: pot(100k, b) mirrors Gain_A
                    R1: resistor(10k)
                }
                nets {
                    in -> R1.a
                    R1.b -> Gain_A.a
                    Gain_A.b -> Gain_B.a
                    Gain_B.b -> out
                }
            }
        "#;
        let pedal = parse_pedal_file(src).unwrap();
        assert_eq!(pedal.mirrors.len(), 1);
        assert_eq!(pedal.mirrors.get("Gain_B").unwrap(), "Gain_A");
    }

    #[test]
    fn parse_calibrate_keyword() {
        let src = r#"
            pedal "Test" {
                components {
                    R1: resistor(10k)
                }
                nets {
                    in -> R1.a
                    R1.b -> out
                }
                calibrate
            }
        "#;
        let pedal = parse_pedal_file(src).unwrap();
        assert!(pedal.calibrate);
    }

    #[test]
    fn parse_no_calibrate_keyword() {
        let src = r#"
            pedal "Test" {
                components {
                    R1: resistor(10k)
                }
                nets {
                    in -> R1.a
                    R1.b -> out
                }
            }
        "#;
        let pedal = parse_pedal_file(src).unwrap();
        assert!(!pedal.calibrate);
    }

    #[test]
    fn pot_taper_curves() {
        // Linear (B): direct mapping
        assert!((PotTaper::B.apply(0.0) - 0.0).abs() < 1e-9);
        assert!((PotTaper::B.apply(0.5) - 0.5).abs() < 1e-9);
        assert!((PotTaper::B.apply(1.0) - 1.0).abs() < 1e-9);

        // Audio (A): slow start, fast end
        // Using (10^x - 1)/9 formula: at 50% gives ~24% resistance
        let a_mid = PotTaper::A.apply(0.5);
        assert!(a_mid > 0.2 && a_mid < 0.3, "A taper at 50% should be ~24%");
        assert!((PotTaper::A.apply(0.0) - 0.0).abs() < 1e-9);
        assert!((PotTaper::A.apply(1.0) - 1.0).abs() < 1e-9);

        // Reverse log (C): fast start, slow end (inverse of A)
        let c_mid = PotTaper::C.apply(0.5);
        assert!(c_mid > 0.7 && c_mid < 0.8, "C taper at 50% should be ~76%");
        assert!((PotTaper::C.apply(0.0) - 0.0).abs() < 1e-9);
        assert!((PotTaper::C.apply(1.0) - 1.0).abs() < 1e-9);

        // A and C should be symmetric around 0.5
        let a_25 = PotTaper::A.apply(0.25);
        let c_75 = PotTaper::C.apply(0.75);
        assert!(
            (a_25 - (1.0 - c_75)).abs() < 0.01,
            "A and C should be symmetric"
        );
    }

    #[test]
    fn parse_net_simple() {
        let (_, n) = net_def("in -> C1.a").unwrap();
        assert_eq!(n.from, Pin::Reserved("in".to_string()));
        assert_eq!(
            n.to,
            vec![Pin::ComponentPin {
                component: "C1".to_string(),
                pin: "a".to_string()
            }]
        );
    }

    #[test]
    fn parse_net_multi() {
        let (_, n) = net_def("C1.b -> R1.a, D1.a").unwrap();
        assert_eq!(n.to.len(), 2);
    }

    #[test]
    fn parse_net_fork_simple() {
        let (_, n) = net_def("B7.a -> fork(SW_time, [B8.a, B9.a])").unwrap();
        assert_eq!(
            n.from,
            Pin::ComponentPin {
                component: "B7".to_string(),
                pin: "a".to_string()
            }
        );
        assert_eq!(n.to.len(), 1);
        match &n.to[0] {
            Pin::Fork {
                switch,
                destinations,
            } => {
                assert_eq!(switch, "SW_time");
                assert_eq!(destinations.len(), 2);
                assert_eq!(
                    destinations[0],
                    Pin::ComponentPin {
                        component: "B8".to_string(),
                        pin: "a".to_string()
                    }
                );
                assert_eq!(
                    destinations[1],
                    Pin::ComponentPin {
                        component: "B9".to_string(),
                        pin: "a".to_string()
                    }
                );
            }
            _ => panic!("expected Fork"),
        }
    }

    #[test]
    fn parse_net_fork_three_destinations() {
        let (_, n) = net_def("in -> fork(MODE, [clean.a, crunch.a, lead.a])").unwrap();
        assert_eq!(n.from, Pin::Reserved("in".to_string()));
        match &n.to[0] {
            Pin::Fork {
                switch,
                destinations,
            } => {
                assert_eq!(switch, "MODE");
                assert_eq!(destinations.len(), 3);
            }
            _ => panic!("expected Fork"),
        }
    }

    #[test]
    fn parse_net_fork_with_reserved_dest() {
        // Fork can route to reserved nodes like gnd (for muting)
        let (_, n) = net_def("sig.out -> fork(MUTE, [out, gnd])").unwrap();
        match &n.to[0] {
            Pin::Fork {
                switch,
                destinations,
            } => {
                assert_eq!(switch, "MUTE");
                assert_eq!(destinations[0], Pin::Reserved("out".to_string()));
                assert_eq!(destinations[1], Pin::Reserved("gnd".to_string()));
            }
            _ => panic!("expected Fork"),
        }
    }

    #[test]
    fn parse_control() {
        let (_, c) = control_def(r#"Gain.position -> "Drive" [0.0, 1.0] = 0.5"#).unwrap();
        assert_eq!(c.component, "Gain");
        assert_eq!(c.label, "Drive");
        assert!((c.default - 0.5).abs() < 1e-10);
    }

    #[test]
    fn parse_full_pedal() {
        let src = r#"
pedal "Tube Screamer" {
  components {
    R1: resistor(4.7k)
    C1: cap(220n)
    D1: diode_pair(silicon)
    Gain: pot(500k)
  }
  nets {
    in -> C1.a
    C1.b -> R1.a, D1.a
    D1.b -> gnd
  }
  controls {
    Gain.position -> "Drive" [0.0, 1.0] = 0.5
  }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.name, "Tube Screamer");
        assert_eq!(def.components.len(), 4);
        assert_eq!(def.nets.len(), 3);
        assert_eq!(def.controls.len(), 1);
    }

    #[test]
    fn parse_with_comments() {
        let src = r#"
# This is a fuzz pedal
pedal "Fuzz" {
  components {
    # Input cap
    C1: cap(100n)
    Q1: npn()
  }
  nets {
    in -> C1.a
    C1.b -> Q1.base
  }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.name, "Fuzz");
        assert_eq!(def.components.len(), 2);
    }

    #[test]
    fn parse_all_component_kinds() {
        let src = r#"
pedal "All" {
  components {
    R1: resistor(10k)
    C1: cap(100n)
    L1: inductor(100m)
    D1: diode_pair(germanium)
    D2: diode(led)
    P1: pot(1M)
    Q1: npn()
    Q2: pnp()
    U1: opamp()
  }
  nets {
    in -> out
  }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.components.len(), 9);
    }

    #[test]
    fn parse_njfet_j201() {
        let (_, (c, _)) = component_def("J1: njfet(j201)").unwrap();
        assert_eq!(c.id, "J1");
        assert_eq!(
            c.kind.as_any().downcast_ref::<NJfet>().unwrap(),
            &NJfet {
                model: "J201".to_string()
            }
        );
    }

    #[test]
    fn parse_njfet_2n5457() {
        let (_, (c, _)) = component_def("J2: njfet(2n5457)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<NJfet>().unwrap(),
            &NJfet {
                model: "2N5457".to_string()
            }
        );
    }

    #[test]
    fn parse_njfet_2n5952() {
        let (_, (c, _)) = component_def("J1: njfet(2n5952)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<NJfet>().unwrap(),
            &NJfet {
                model: "2N5952".to_string()
            }
        );
    }

    #[test]
    fn parse_pjfet_2n5460() {
        let (_, (c, _)) = component_def("J3: pjfet(2n5460)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<PJfet>().unwrap(),
            &PJfet {
                model: "2N5460".to_string()
            }
        );
    }

    #[test]
    fn parse_njfet_any_model() {
        // Any model name from the .model file should be accepted
        let (_, (c, _)) = component_def("J1: njfet(2N3819-VSH)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<NJfet>().unwrap(),
            &NJfet {
                model: "2N3819-VSH".to_string()
            }
        );
    }

    #[test]
    fn parse_pedal_with_jfet() {
        let src = r#"
pedal "Tremolo" {
  components {
    C1: cap(100n)
    J1: njfet(j201)
    R1: resistor(10k)
  }
  nets {
    in -> C1.a
    C1.b -> J1.gate
    J1.drain -> R1.a
    J1.source -> gnd
  }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.name, "Tremolo");
        assert_eq!(def.components.len(), 3);
        assert_eq!(
            def.components[1]
                .kind
                .as_any()
                .downcast_ref::<NJfet>()
                .unwrap(),
            &NJfet {
                model: "J201".to_string()
            }
        );
    }

    #[test]
    fn parse_photocoupler_vtl5c3() {
        let (_, (c, _)) = component_def("OC1: photocoupler(vtl5c3)").unwrap();
        assert_eq!(c.id, "OC1");
        assert_eq!(
            c.kind.as_any().downcast_ref::<PhotocouplerComp>().unwrap(),
            &PhotocouplerComp {
                coupler_type: PhotocouplerType::Vtl5c3
            }
        );
    }

    #[test]
    fn parse_photocoupler_vtl5c1() {
        let (_, (c, _)) = component_def("OC2: photocoupler(vtl5c1)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<PhotocouplerComp>().unwrap(),
            &PhotocouplerComp {
                coupler_type: PhotocouplerType::Vtl5c1
            }
        );
    }

    #[test]
    fn parse_photocoupler_nsl32() {
        let (_, (c, _)) = component_def("OC3: photocoupler(nsl32)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<PhotocouplerComp>().unwrap(),
            &PhotocouplerComp {
                coupler_type: PhotocouplerType::Nsl32
            }
        );
    }

    #[test]
    fn parse_pedal_with_photocoupler() {
        let src = r#"
pedal "Optical Tremolo" {
  components {
    C1: cap(100n)
    OC1: photocoupler(vtl5c3)
    R1: resistor(10k)
  }
  nets {
    in -> C1.a
    C1.b -> OC1.a
    OC1.b -> R1.a
    R1.b -> out
  }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.name, "Optical Tremolo");
        assert_eq!(def.components.len(), 3);
        assert_eq!(
            def.components[1]
                .kind
                .as_any()
                .downcast_ref::<PhotocouplerComp>()
                .unwrap(),
            &PhotocouplerComp {
                coupler_type: PhotocouplerType::Vtl5c3
            }
        );
    }

    #[test]
    fn parse_triode_12ax7() {
        let (_, (c, _)) = component_def("V1: triode(12ax7)").unwrap();
        assert_eq!(c.id, "V1");
        assert_eq!(
            c.kind.as_any().downcast_ref::<Triode>().unwrap(),
            &Triode {
                model: "12AX7".into()
            }
        );
    }

    #[test]
    fn parse_triode_12at7() {
        let (_, (c, _)) = component_def("V2: triode(12at7)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Triode>().unwrap(),
            &Triode {
                model: "12AT7".into()
            }
        );
    }

    #[test]
    fn parse_triode_12au7() {
        let (_, (c, _)) = component_def("V3: triode(12au7)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Triode>().unwrap(),
            &Triode {
                model: "12AU7".into()
            }
        );
    }

    #[test]
    fn parse_triode_ecc83() {
        // ECC83 = European 12AX7 — stored as "ECC83", resolved at model lookup
        let (_, (c, _)) = component_def("V4: triode(ecc83)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Triode>().unwrap(),
            &Triode {
                model: "ECC83".into()
            }
        );
    }

    #[test]
    fn parse_triode_12ay7() {
        let (_, (c, _)) = component_def("V1: triode(12ay7)").unwrap();
        assert_eq!(c.id, "V1");
        assert_eq!(
            c.kind.as_any().downcast_ref::<Triode>().unwrap(),
            &Triode {
                model: "12AY7".into()
            }
        );
    }

    #[test]
    fn parse_triode_6072() {
        // 6072 = military designation for 12AY7 — stored as "6072", resolved at model lookup
        let (_, (c, _)) = component_def("V1: triode(6072)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Triode>().unwrap(),
            &Triode {
                model: "6072".into()
            }
        );
    }

    #[test]
    fn parse_vari_mu_6386() {
        let (_, (c, _)) = component_def("V1: vari_mu(6386)").unwrap();
        assert_eq!(c.id, "V1");
        assert_eq!(
            c.kind.as_any().downcast_ref::<VariMu>().unwrap(),
            &VariMu {
                model: "6386".into()
            }
        );
    }

    #[test]
    fn parse_lfo_component() {
        // lfo(triangle, 100k, 220n) -> f = 1/(2π*100000*220e-9) ≈ 7.2 Hz
        let (_, (c, _)) = component_def("LFO1: lfo(triangle, 100k, 220n)").unwrap();
        assert_eq!(c.id, "LFO1");
        let lfo = c.kind.as_any().downcast_ref::<Lfo>().expect("expected Lfo");
        assert_eq!(lfo.waveform, LfoWaveformDsl::Triangle);
        assert!((lfo.timing_r - 100_000.0).abs() < 1.0);
        assert!((lfo.timing_c - 220e-9).abs() < 1e-12);
    }

    #[test]
    fn parse_lfo_waveforms() {
        assert_eq!(lfo_waveform("sine").unwrap().1, LfoWaveformDsl::Sine);
        assert_eq!(
            lfo_waveform("triangle").unwrap().1,
            LfoWaveformDsl::Triangle
        );
        assert_eq!(lfo_waveform("square").unwrap().1, LfoWaveformDsl::Square);
        assert_eq!(lfo_waveform("saw_up").unwrap().1, LfoWaveformDsl::SawUp);
        assert_eq!(lfo_waveform("saw_down").unwrap().1, LfoWaveformDsl::SawDown);
        assert_eq!(
            lfo_waveform("sample_hold").unwrap().1,
            LfoWaveformDsl::SampleAndHold
        );
    }

    #[test]
    fn parse_pedal_with_lfo_component() {
        let src = r#"
pedal "Harmonic Tremolo" {
  components {
    LFO1: lfo(triangle, 100k, 220n)
    C1: cap(100n)
    J1: njfet(j201)
    R1: resistor(10k)
  }
  nets {
    in -> C1.a
    C1.b -> J1.drain
    J1.source -> gnd
    LFO1.out -> J1.vgs
  }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.name, "Harmonic Tremolo");
        assert_eq!(def.components.len(), 4);
        // Check LFO component: 100k timing resistor, 220n timing cap
        let lfo = def.components[0]
            .kind
            .as_any()
            .downcast_ref::<Lfo>()
            .expect("expected Lfo component");
        assert_eq!(lfo.waveform, LfoWaveformDsl::Triangle);
        assert!((lfo.timing_r - 100_000.0).abs() < 1.0);
        assert!((lfo.timing_c - 220e-9).abs() < 1e-12);
        // Check LFO.out net connection
        let lfo_net = def.nets.iter().find(|n| {
            matches!(&n.from, Pin::ComponentPin { component, pin }
                     if component == "LFO1" && pin == "out")
        });
        assert!(lfo_net.is_some(), "should have LFO1.out net");
    }

    #[test]
    fn parse_envelope_follower_component() {
        // envelope_follower(1k, 4.7u, 100k, 1u, 20k)
        let (_, (c, _)) = component_def("EF1: envelope_follower(1k, 4.7u, 100k, 1u, 20k)").unwrap();
        assert_eq!(c.id, "EF1");
        let ef = c
            .kind
            .as_any()
            .downcast_ref::<EnvelopeFollower>()
            .expect("expected EnvelopeFollower");
        assert!((ef.attack_r - 1_000.0).abs() < 1.0);
        assert!((ef.attack_c - 4.7e-6).abs() < 1e-9);
        assert!((ef.release_r - 100_000.0).abs() < 1.0);
        assert!((ef.release_c - 1e-6).abs() < 1e-9);
        assert!((ef.sensitivity_r - 20_000.0).abs() < 1.0);
    }

    #[test]
    fn parse_pedal_with_envelope_follower() {
        let src = r#"
pedal "Auto Wah" {
  components {
    EF1: envelope_follower(1k, 4.7u, 100k, 1.5u, 20k)
    C1: cap(100n)
    J1: njfet(j201)
    R1: resistor(10k)
  }
  nets {
    in -> C1.a
    C1.b -> J1.drain
    J1.source -> gnd
    EF1.out -> J1.vgs
    R1.a -> J1.drain
    R1.b -> out
  }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.name, "Auto Wah");
        assert_eq!(def.components.len(), 4);
        // Check EnvelopeFollower component
        let ef = def.components[0]
            .kind
            .as_any()
            .downcast_ref::<EnvelopeFollower>()
            .expect("expected EnvelopeFollower component");
        assert!((ef.attack_r - 1_000.0).abs() < 1.0);
        assert!((ef.attack_c - 4.7e-6).abs() < 1e-9);
        assert!((ef.release_r - 100_000.0).abs() < 1.0);
        assert!((ef.release_c - 1.5e-6).abs() < 1e-9);
        assert!((ef.sensitivity_r - 20_000.0).abs() < 1.0);
        // Check EF1.out net connection
        let ef_net = def.nets.iter().find(|n| {
            matches!(&n.from, Pin::ComponentPin { component, pin }
                     if component == "EF1" && pin == "out")
        });
        assert!(ef_net.is_some(), "should have EF1.out net");
    }

    #[test]
    fn parse_opamp_generic() {
        let (_, (c, _)) = component_def("U1: opamp()").unwrap();
        assert_eq!(c.id, "U1");
        assert_eq!(c.kind.op_amp_type(), Some(OpAmpType::Generic));
    }

    #[test]
    fn parse_opamp_tl071() {
        let (_, (c, _)) = component_def("U1: opamp(tl071)").unwrap();
        assert_eq!(c.kind.op_amp_type(), Some(OpAmpType::Tl071));
        // Electrically identical to the TL072 (single vs dual package).
        assert!((OpAmpType::Tl071.slew_rate() - 13.0).abs() < 0.1);
        assert!((OpAmpType::Tl071.gain_bandwidth() - 3e6).abs() < 1e3);
    }

    #[test]
    fn parse_opamp_tl072() {
        let (_, (c, _)) = component_def("U1: opamp(tl072)").unwrap();
        assert_eq!(c.kind.op_amp_type(), Some(OpAmpType::Tl072));
    }

    #[test]
    fn parse_opamp_jrc4558() {
        let (_, (c, _)) = component_def("U1: opamp(jrc4558)").unwrap();
        assert_eq!(c.kind.op_amp_type(), Some(OpAmpType::Jrc4558));
    }

    #[test]
    fn parse_opamp_4558_alias() {
        // "4558" should also work as an alias for JRC4558
        let (_, (c, _)) = component_def("U1: opamp(4558)").unwrap();
        assert_eq!(c.kind.op_amp_type(), Some(OpAmpType::Jrc4558));
    }

    #[test]
    fn parse_opamp_lm308() {
        let (_, (c, _)) = component_def("U1: opamp(lm308)").unwrap();
        assert_eq!(c.kind.op_amp_type(), Some(OpAmpType::Lm308));
    }

    #[test]
    fn parse_opamp_ne5532() {
        let (_, (c, _)) = component_def("U1: opamp(ne5532)").unwrap();
        assert_eq!(c.kind.op_amp_type(), Some(OpAmpType::Ne5532));
    }

    #[test]
    fn parse_opamp_njm5532_alias() {
        // "njm5532" and bare "5532" are aliases for NE5532.
        let (_, (c, _)) = component_def("U1: opamp(njm5532)").unwrap();
        assert_eq!(c.kind.op_amp_type(), Some(OpAmpType::Ne5532));
        let (_, (c2, _)) = component_def("U2: opamp(5532)").unwrap();
        assert_eq!(c2.kind.op_amp_type(), Some(OpAmpType::Ne5532));
    }

    #[test]
    fn parse_opamp_ca3080() {
        let (_, (c, _)) = component_def("U1: opamp(ca3080)").unwrap();
        assert_eq!(c.kind.op_amp_type(), Some(OpAmpType::Ca3080));
        // CA3080 is an OTA
        assert!(OpAmpType::Ca3080.is_ota());
    }

    #[test]
    fn opamp_slew_rates() {
        // Verify slew rates are as specified
        assert!((OpAmpType::Lm308.slew_rate() - 0.3).abs() < 0.01);
        assert!((OpAmpType::Tl072.slew_rate() - 13.0).abs() < 0.1);
        assert!((OpAmpType::Jrc4558.slew_rate() - 1.7).abs() < 0.1);
    }

    #[test]
    fn opamp_gain_bandwidth() {
        // Verify GBW products
        assert!((OpAmpType::Lm308.gain_bandwidth() - 1e6).abs() < 1e3);
        assert!((OpAmpType::Ne5532.gain_bandwidth() - 10e6).abs() < 1e3);
    }

    // ── MOSFET parser tests ──────────────────────────────────────────────

    #[test]
    fn parse_nmos_2n7000() {
        let (_, (c, _)) = component_def("M1: nmos(2n7000)").unwrap();
        assert_eq!(c.id, "M1");
        assert_eq!(
            c.kind.as_any().downcast_ref::<Nmos>().unwrap(),
            &Nmos {
                mosfet_type: MosfetType::N2n7000
            }
        );
    }

    #[test]
    fn parse_nmos_irf520() {
        let (_, (c, _)) = component_def("M1: nmos(irf520)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Nmos>().unwrap(),
            &Nmos {
                mosfet_type: MosfetType::Irf520
            }
        );
    }

    #[test]
    fn parse_pmos_bs250() {
        let (_, (c, _)) = component_def("M2: pmos(bs250)").unwrap();
        assert_eq!(c.id, "M2");
        assert_eq!(
            c.kind.as_any().downcast_ref::<Pmos>().unwrap(),
            &Pmos {
                mosfet_type: MosfetType::Bs250
            }
        );
    }

    #[test]
    fn parse_pmos_irf9520() {
        let (_, (c, _)) = component_def("M2: pmos(irf9520)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Pmos>().unwrap(),
            &Pmos {
                mosfet_type: MosfetType::Irf9520
            }
        );
    }

    // ── Zener diode parser tests ────────────────────────────────────────

    #[test]
    fn parse_zener_with_voltage_suffix() {
        let (_, (c, _)) = component_def("Z1: zener(5.1v)").unwrap();
        assert_eq!(c.id, "Z1");
        let z = c
            .kind
            .as_any()
            .downcast_ref::<Zener>()
            .expect("expected Zener");
        assert!((z.breakdown_voltage - 5.1).abs() < 1e-6);
    }

    #[test]
    fn parse_zener_without_suffix() {
        let (_, (c, _)) = component_def("Z2: zener(3.3)").unwrap();
        let z = c
            .kind
            .as_any()
            .downcast_ref::<Zener>()
            .expect("expected Zener");
        assert!((z.breakdown_voltage - 3.3).abs() < 1e-6);
    }

    #[test]
    fn parse_pedal_with_mosfet() {
        let src = r#"
pedal "MOSFET Drive" {
  components {
    C1: cap(100n)
    R1: resistor(10k)
    M1: nmos(2n7000)
    R2: resistor(1k)
  }
  nets {
    in -> C1.a
    C1.b -> R1.a, M1.drain
    R1.b -> gnd
    M1.source -> R2.a
    R2.b -> gnd
    M1.drain -> out
  }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.name, "MOSFET Drive");
        assert_eq!(def.components.len(), 4);
        assert!(def.components.iter().any(|c| c
            .kind
            .as_any()
            .downcast_ref::<Nmos>()
            .map_or(false, |m| m.mosfet_type == MosfetType::N2n7000)));
    }

    #[test]
    fn parse_pedal_with_zener() {
        let src = r#"
pedal "Zener Clipper" {
  components {
    C1: cap(100n)
    R1: resistor(10k)
    Z1: zener(5.1v)
  }
  nets {
    in -> C1.a
    C1.b -> R1.a, Z1.a
    R1.b -> gnd
    Z1.b -> gnd
  }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.name, "Zener Clipper");
        assert_eq!(def.components.len(), 3);
        assert!(def.components.iter().any(|c| c
            .kind
            .as_any()
            .downcast_ref::<Zener>()
            .map_or(false, |z| (z.breakdown_voltage - 5.1).abs() < 1e-6)));
    }

    // ── BBD parser tests ──────────────────────────────────────────────────

    #[test]
    fn parse_bbd_mn3207() {
        let (_, (c, _)) = component_def("BBD1: bbd(mn3207)").unwrap();
        assert_eq!(c.id, "BBD1");
        assert_eq!(
            c.kind.as_any().downcast_ref::<Bbd>().unwrap(),
            &Bbd {
                bbd_type: BbdType::Mn3207
            }
        );
    }

    #[test]
    fn parse_bbd_mn3007() {
        let (_, (c, _)) = component_def("BBD1: bbd(mn3007)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Bbd>().unwrap(),
            &Bbd {
                bbd_type: BbdType::Mn3007
            }
        );
    }

    #[test]
    fn parse_bbd_mn3005() {
        let (_, (c, _)) = component_def("BBD1: bbd(mn3005)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Bbd>().unwrap(),
            &Bbd {
                bbd_type: BbdType::Mn3005
            }
        );
    }

    #[test]
    fn parse_pedal_with_bbd() {
        let src = r#"
pedal "Chorus" {
  components {
    C1: cap(100n)
    R1: resistor(10k)
    BBD1: bbd(mn3207)
    LFO1: lfo(triangle, 100k, 47n)
  }
  nets {
    in -> C1.a
    C1.b -> R1.a, BBD1.in
    R1.b -> gnd
    BBD1.out -> out
    LFO1.out -> BBD1.clock
  }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.name, "Chorus");
        assert_eq!(def.components.len(), 4);
        assert!(def.components.iter().any(|c| c
            .kind
            .as_any()
            .downcast_ref::<Bbd>()
            .map_or(false, |b| b.bbd_type == BbdType::Mn3207)));
    }

    // ── Neon bulb parser tests ─────────────────────────────────────────

    #[test]
    fn parse_neon_default() {
        let (_, (c, _)) = component_def("NE1: neon()").unwrap();
        assert_eq!(c.id, "NE1");
        assert_eq!(
            c.kind.as_any().downcast_ref::<Neon>().unwrap(),
            &Neon {
                neon_type: NeonType::Ne2
            }
        );
    }

    #[test]
    fn parse_neon_ne2() {
        let (_, (c, _)) = component_def("NE1: neon(ne2)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Neon>().unwrap(),
            &Neon {
                neon_type: NeonType::Ne2
            }
        );
    }

    #[test]
    fn parse_neon_ne2_hyphen() {
        let (_, (c, _)) = component_def("NE1: neon(ne-2)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Neon>().unwrap(),
            &Neon {
                neon_type: NeonType::Ne2
            }
        );
    }

    #[test]
    fn parse_neon_ne51() {
        let (_, (c, _)) = component_def("NE1: neon(ne51)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Neon>().unwrap(),
            &Neon {
                neon_type: NeonType::Ne51
            }
        );
    }

    #[test]
    fn parse_neon_ne83() {
        let (_, (c, _)) = component_def("NE1: neon(ne-83)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Neon>().unwrap(),
            &Neon {
                neon_type: NeonType::Ne83
            }
        );
    }

    #[test]
    fn parse_pedal_with_neon_tremolo() {
        let src = r#"
pedal "Fender Vibrato" {
  components {
    R1: resistor(1M)
    NE1: neon()
    C1: cap(0.1u)
    LDR1: photocoupler(vtl5c3)
    R2: resistor(10k)
  }
  nets {
    in -> R1.a
    R1.b -> LDR1.a
    LDR1.b -> out
    NE1.a -> C1.a
    C1.b -> gnd
    NE1.b -> R2.a
    R2.b -> gnd
  }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.name, "Fender Vibrato");
        assert!(def.components.iter().any(|c| c
            .kind
            .as_any()
            .downcast_ref::<Neon>()
            .map_or(false, |n| n.neon_type == NeonType::Ne2)));
    }

    // ── Pentode parser tests ────────────────────────────────────────────

    #[test]
    fn parse_pentode_ef86() {
        let (_, (c, _)) = component_def("V1: pentode(ef86)").unwrap();
        assert_eq!(c.id, "V1");
        assert_eq!(
            c.kind.as_any().downcast_ref::<Pentode>().unwrap(),
            &Pentode {
                model: "EF86".into()
            }
        );
    }

    #[test]
    fn parse_pentode_el84() {
        let (_, (c, _)) = component_def("V1: pentode(el84)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Pentode>().unwrap(),
            &Pentode {
                model: "EL84".into()
            }
        );
    }

    #[test]
    fn parse_pentode_6267() {
        // 6267 = US designation for EF86 — stored as "6267", resolved at model lookup
        let (_, (c, _)) = component_def("V1: pentode(6267)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Pentode>().unwrap(),
            &Pentode {
                model: "6267".into()
            }
        );
    }

    #[test]
    fn parse_pentode_6bq5() {
        // 6BQ5 = US designation for EL84 — stored as "6BQ5", resolved at model lookup
        let (_, (c, _)) = component_def("V1: pentode(6bq5)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Pentode>().unwrap(),
            &Pentode {
                model: "6BQ5".into()
            }
        );
    }

    #[test]
    fn parse_pedal_with_pentode() {
        let src = r#"
pedal "Vox Preamp" {
  components {
    C1: cap(20n)
    R1: resistor(1M)
    V1: pentode(ef86)
    R2: resistor(220k)
    R3: resistor(2.2k)
    C2: cap(25u)
  }
  nets {
    in -> C1.a
    C1.b -> R1.a, V1.grid
    R1.b -> gnd
    vcc -> R2.a
    R2.b -> V1.plate
    V1.cathode -> R3.a, C2.a
    R3.b -> gnd
    C2.b -> gnd
    V1.plate -> out
  }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.name, "Vox Preamp");
        assert!(def.components.iter().any(|c| c
            .kind
            .as_any()
            .downcast_ref::<Pentode>()
            .map_or(false, |p| p.model == "EF86")));
    }

    #[test]
    fn parse_pentode_6l6gc() {
        let (_, (c, _)) = component_def("V1: pentode(6l6gc)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Pentode>().unwrap(),
            &Pentode {
                model: "6L6GC".into()
            }
        );
    }

    #[test]
    fn parse_pentode_6l6_alias() {
        // 6L6 = original lower-dissipation variant — stored as "6L6", resolved at model lookup
        let (_, (c, _)) = component_def("V1: pentode(6l6)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Pentode>().unwrap(),
            &Pentode {
                model: "6L6".into()
            }
        );
    }

    #[test]
    fn parse_pentode_5881_alias() {
        // 5881 = military equivalent of 6L6GC — stored as "5881", resolved at model lookup
        let (_, (c, _)) = component_def("V1: pentode(5881)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Pentode>().unwrap(),
            &Pentode {
                model: "5881".into()
            }
        );
    }

    #[test]
    fn parse_pentode_kt66_alias() {
        // KT66 = British equivalent of 6L6GC — stored as "KT66", resolved at model lookup
        let (_, (c, _)) = component_def("V1: pentode(kt66)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Pentode>().unwrap(),
            &Pentode {
                model: "KT66".into()
            }
        );
    }

    #[test]
    fn parse_pentode_el34() {
        let (_, (c, _)) = component_def("V1: pentode(el34)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Pentode>().unwrap(),
            &Pentode {
                model: "EL34".into()
            }
        );
    }

    #[test]
    fn parse_pentode_6ca7_alias() {
        // 6CA7 = American designation for EL34 — stored as "6CA7", resolved at model lookup
        let (_, (c, _)) = component_def("V1: pentode(6ca7)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Pentode>().unwrap(),
            &Pentode {
                model: "6CA7".into()
            }
        );
    }

    #[test]
    fn parse_pentode_kt77_alias() {
        // KT77 = drop-in alternative for EL34 — stored as "KT77", resolved at model lookup
        let (_, (c, _)) = component_def("V1: pentode(kt77)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Pentode>().unwrap(),
            &Pentode {
                model: "KT77".into()
            }
        );
    }

    #[test]
    fn parse_pentode_6550() {
        let (_, (c, _)) = component_def("V1: pentode(6550)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Pentode>().unwrap(),
            &Pentode {
                model: "6550".into()
            }
        );
    }

    #[test]
    fn parse_pentode_kt88_alias() {
        // KT88 = distinct tube — stored as "KT88", resolved at model lookup
        let (_, (c, _)) = component_def("V1: pentode(kt88)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Pentode>().unwrap(),
            &Pentode {
                model: "KT88".into()
            }
        );
    }

    #[test]
    fn parse_pentode_kt90_alias() {
        // KT90 = higher dissipation variant of 6550 — stored as "KT90", resolved at model lookup
        let (_, (c, _)) = component_def("V1: pentode(kt90)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Pentode>().unwrap(),
            &Pentode {
                model: "KT90".into()
            }
        );
    }

    // ── Synth component parser tests ──────────────────────────────────

    #[test]
    fn parse_synth_keyword() {
        let src = r#"
synth "Test Synth" {
  components {
    R1: resistor(10k)
  }
  nets {
    in -> R1.a
    R1.b -> out
  }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.name, "Test Synth");
    }

    #[test]
    fn parse_vco_cem3340() {
        let (_, (c, _)) = component_def("VCO1: vco(cem3340)").unwrap();
        assert_eq!(c.id, "VCO1");
        assert_eq!(
            c.kind.as_any().downcast_ref::<Vco>().unwrap(),
            &Vco {
                vco_type: VcoType::Cem3340,
                base_freq: 440.0,
                waveform: VcoWaveformDsl::Saw
            }
        );
    }

    #[test]
    fn parse_vco_as3340() {
        let (_, (c, _)) = component_def("VCO1: vco(as3340)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Vco>().unwrap(),
            &Vco {
                vco_type: VcoType::As3340,
                base_freq: 440.0,
                waveform: VcoWaveformDsl::Saw
            }
        );
    }

    #[test]
    fn parse_vco_v3340() {
        let (_, (c, _)) = component_def("VCO1: vco(v3340)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Vco>().unwrap(),
            &Vco {
                vco_type: VcoType::V3340,
                base_freq: 440.0,
                waveform: VcoWaveformDsl::Saw
            }
        );
    }

    #[test]
    fn parse_vco_with_freq() {
        let (_, (c, _)) = component_def("VCO1: vco(cem3340, 540)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Vco>().unwrap(),
            &Vco {
                vco_type: VcoType::Cem3340,
                base_freq: 540.0,
                waveform: VcoWaveformDsl::Saw
            }
        );
    }

    #[test]
    fn parse_vco_with_freq_and_waveform() {
        let (_, (c, _)) = component_def("VCO1: vco(cem3340, 540, pulse)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Vco>().unwrap(),
            &Vco {
                vco_type: VcoType::Cem3340,
                base_freq: 540.0,
                waveform: VcoWaveformDsl::Pulse
            }
        );
    }

    #[test]
    fn parse_vcf_cem3320() {
        let (_, (c, _)) = component_def("VCF1: vcf(cem3320)").unwrap();
        assert_eq!(c.id, "VCF1");
        assert_eq!(
            c.kind.as_any().downcast_ref::<Vcf>().unwrap(),
            &Vcf {
                vcf_type: VcfType::Cem3320
            }
        );
    }

    #[test]
    fn parse_vcf_as3320() {
        let (_, (c, _)) = component_def("VCF1: vcf(as3320)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Vcf>().unwrap(),
            &Vcf {
                vcf_type: VcfType::As3320
            }
        );
    }

    #[test]
    fn parse_vca_ssm2164() {
        let (_, (c, _)) = component_def("VCA1: vca(ssm2164)").unwrap();
        assert_eq!(c.id, "VCA1");
        assert_eq!(
            c.kind.as_any().downcast_ref::<Vca>().unwrap(),
            &Vca {
                vca_type: VcaType::Ssm2164
            }
        );
    }

    #[test]
    fn parse_vca_v2164() {
        let (_, (c, _)) = component_def("VCA1: vca(v2164)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Vca>().unwrap(),
            &Vca {
                vca_type: VcaType::V2164
            }
        );
    }

    #[test]
    fn parse_comparator_lm311() {
        let (_, (c, _)) = component_def("U1: comparator(lm311)").unwrap();
        assert_eq!(c.id, "U1");
        assert_eq!(
            c.kind.as_any().downcast_ref::<Comparator>().unwrap(),
            &Comparator {
                comp_type: ComparatorType::Lm311
            }
        );
    }

    #[test]
    fn parse_comparator_lm393() {
        let (_, (c, _)) = component_def("U1: comparator(lm393)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Comparator>().unwrap(),
            &Comparator {
                comp_type: ComparatorType::Lm393
            }
        );
    }

    #[test]
    fn parse_analog_switch_cd4066() {
        let (_, (c, _)) = component_def("SW1: switch(cd4066)").unwrap();
        assert_eq!(c.id, "SW1");
        assert_eq!(
            c.kind.as_any().downcast_ref::<AnalogSwitch>().unwrap(),
            &AnalogSwitch {
                switch_type: AnalogSwitchType::Cd4066
            }
        );
    }

    #[test]
    fn parse_analog_switch_dg411() {
        let (_, (c, _)) = component_def("SW1: switch(dg411)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<AnalogSwitch>().unwrap(),
            &AnalogSwitch {
                switch_type: AnalogSwitchType::Dg411
            }
        );
    }

    #[test]
    fn parse_matched_npn_ssm2210() {
        let (_, (c, _)) = component_def("QM1: matched_npn(ssm2210)").unwrap();
        assert_eq!(c.id, "QM1");
        assert_eq!(
            c.kind.as_any().downcast_ref::<MatchedNpn>().unwrap(),
            &MatchedNpn {
                matched_type: MatchedTransistorType::Ssm2210
            }
        );
    }

    #[test]
    fn parse_matched_npn_ca3046() {
        let (_, (c, _)) = component_def("QM1: matched_npn(ca3046)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<MatchedNpn>().unwrap(),
            &MatchedNpn {
                matched_type: MatchedTransistorType::Ca3046
            }
        );
    }

    #[test]
    fn parse_matched_pnp_lm394() {
        let (_, (c, _)) = component_def("QM1: matched_pnp(lm394)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<MatchedPnp>().unwrap(),
            &MatchedPnp {
                matched_type: MatchedTransistorType::Lm394
            }
        );
    }

    #[test]
    fn parse_tempco() {
        let (_, (c, _)) = component_def("RT1: tempco(2k, 3500)").unwrap();
        assert_eq!(c.id, "RT1");
        let tc = c
            .kind
            .as_any()
            .downcast_ref::<Tempco>()
            .expect("expected Tempco");
        assert!((tc.resistance - 2000.0).abs() < 1e-6);
        assert!((tc.ppm - 3500.0).abs() < 1e-6);
    }

    #[test]
    fn parse_synth_with_cv_gate() {
        let src = r#"
synth "CV Test" {
  components {
    VCO1: vco(as3340)
    R1: resistor(100k)
    VCF1: vcf(as3320)
    R2: resistor(100k)
  }
  nets {
    cv_pitch -> R1.a
    R1.b -> VCO1.cv
    VCO1.saw -> VCF1.in
    cv_filter -> R2.a
    R2.b -> VCF1.cv
    VCF1.out -> out
    gate -> gnd
  }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.name, "CV Test");
        assert_eq!(def.components.len(), 4);
        // Check that cv_pitch, cv_filter, and gate are valid reserved node names
        let has_reserved = |name: &str| {
            def.nets.iter().any(|n| {
                matches!(&n.from, Pin::Reserved(s) if s == name)
                    || n.to
                        .iter()
                        .any(|p| matches!(p, Pin::Reserved(s) if s == name))
            })
        };
        assert!(has_reserved("cv_pitch"));
        assert!(has_reserved("cv_filter"));
        assert!(has_reserved("gate"));
    }

    // ── Studio Equipment parser tests ──────────────────────────────────

    #[test]
    fn parse_transformer_simple() {
        let (_, (c, _)) = component_def("T1: transformer(10:1, 2H)").unwrap();
        assert_eq!(c.id, "T1");
        let cfg = c.kind.transformer_config().expect("expected Transformer");
        assert_eq!(cfg.model, None);
        assert!((cfg.turns_ratio - 10.0).abs() < 1e-6);
        assert!((cfg.primary_inductance - 2.0).abs() < 1e-6);
        assert_eq!(cfg.primary_type, WindingType::Standard);
        assert_eq!(cfg.secondary_type, WindingType::Standard);
    }

    #[test]
    fn parse_transformer_with_model_name() {
        let (_, (c, _)) = component_def("T1: transformer(10:1, JT11P1)").unwrap();
        let cfg = c.kind.transformer_config().expect("expected Transformer");
        assert_eq!(cfg.model.as_deref(), Some("JT11P1"));
        assert!((cfg.turns_ratio - 10.0).abs() < 1e-6);
        assert_eq!(cfg.primary_inductance, 0.0);
        assert_eq!(cfg.coupling, 0.0);
    }

    #[test]
    fn parse_transformer_with_winding_types() {
        // Parser syntax: pp = push-pull, ct = center-tap
        let (_, (c, _)) = component_def("T2: transformer(1.5:1, 4H, pp, ct)").unwrap();
        let cfg = c.kind.transformer_config().expect("expected Transformer");
        assert!((cfg.turns_ratio - 1.5).abs() < 1e-6);
        assert!((cfg.primary_inductance - 4.0).abs() < 1e-6);
        assert_eq!(cfg.primary_type, WindingType::PushPull);
        assert_eq!(cfg.secondary_type, WindingType::CenterTap);
    }

    #[test]
    fn parse_transformer_with_dcr_and_coupling() {
        // Parser syntax: dcr=value (applies to both), k=coupling
        let (_, (c, _)) = component_def("T3: transformer(5:1, 1H, dcr=50, k=0.98)").unwrap();
        let cfg = c.kind.transformer_config().expect("expected Transformer");
        assert!((cfg.turns_ratio - 5.0).abs() < 1e-6);
        assert!((cfg.primary_dcr - 50.0).abs() < 1e-6);
        assert!((cfg.secondary_dcr - 50.0).abs() < 1e-6); // Both set to same value
        assert!((cfg.coupling - 0.98).abs() < 1e-6);
    }

    #[test]
    fn parse_transformer_with_linear_model_fields() {
        let (_, (c, _)) = component_def(
            "T4: transformer(10:1, JT11P1, Lp=2H, Llp=20m, Lls=200u, Lm=1.98H, Rc=100k, Idc=45m)",
        )
        .unwrap();
        let cfg = c.kind.transformer_config().expect("expected Transformer");
        assert_eq!(cfg.model.as_deref(), Some("JT11P1"));
        assert!((cfg.primary_inductance - 2.0).abs() < 1e-9);
        assert!((cfg.primary_leakage.unwrap() - 20e-3).abs() < 1e-9);
        assert!((cfg.secondary_leakage.unwrap() - 200e-6).abs() < 1e-12);
        assert!((cfg.magnetizing_inductance.unwrap() - 1.98).abs() < 1e-9);
        assert!((cfg.core_loss_resistance.unwrap() - 100_000.0).abs() < 1e-6);
        assert!((cfg.dc_bias_current.unwrap() - 45e-3).abs() < 1e-12);
    }

    #[test]
    fn parse_transformer_with_tertiary() {
        let (_, (c, _)) =
            component_def("T_sc: transformer(4:1, 5.7H, 10, 10p, tertiary=9.5:1)").unwrap();
        let cfg = c.kind.transformer_config().expect("expected Transformer");
        assert!((cfg.turns_ratio - 4.0).abs() < 1e-6);
        assert!((cfg.primary_inductance - 5.7).abs() < 1e-6);
        assert!((cfg.primary_dcr - 10.0).abs() < 1e-6);
        assert!((cfg.capacitance - 10e-12).abs() < 1e-15);
        assert!(cfg.tertiary_turns_ratio.is_some());
        assert!((cfg.tertiary_turns_ratio.unwrap() - 9.5).abs() < 1e-6);
    }

    #[test]
    fn parse_transformer_no_tertiary() {
        let (_, (c, _)) = component_def("T1: transformer(10:1, 2H)").unwrap();
        let cfg = c.kind.transformer_config().expect("expected Transformer");
        assert!(cfg.tertiary_turns_ratio.is_none());
    }

    #[test]
    fn parse_cap_switched() {
        let (_, (c, _)) = component_def("C_lf: cap_switched(27n, 68n, 220n, 1.5u)").unwrap();
        assert_eq!(c.id, "C_lf");
        let cs = c
            .kind
            .as_any()
            .downcast_ref::<CapSwitched>()
            .expect("expected CapSwitched");
        assert_eq!(cs.values.len(), 4);
        assert!((cs.values[0] - 27e-9).abs() < 1e-12);
        assert!((cs.values[1] - 68e-9).abs() < 1e-12);
        assert!((cs.values[2] - 220e-9).abs() < 1e-12);
        assert!((cs.values[3] - 1.5e-6).abs() < 1e-12);
    }

    #[test]
    fn parse_inductor_switched() {
        let (_, (c, _)) =
            component_def("L_hf: inductor_switched(27m, 33m, 47m, 68m, 82m, 150m)").unwrap();
        assert_eq!(c.id, "L_hf");
        let is = c
            .kind
            .as_any()
            .downcast_ref::<InductorSwitched>()
            .expect("expected InductorSwitched");
        assert_eq!(is.values.len(), 6);
        assert!((is.values[0] - 27e-3).abs() < 1e-6);
        assert!((is.values[5] - 150e-3).abs() < 1e-6);
    }

    #[test]
    fn parse_rotary_switch() {
        let (_, (c, _)) = component_def(r#"SW1: rotary("20Hz", "30Hz", "60Hz", "100Hz")"#).unwrap();
        assert_eq!(c.id, "SW1");
        let rs = c
            .kind
            .as_any()
            .downcast_ref::<RotarySwitch>()
            .expect("expected RotarySwitch");
        assert_eq!(rs.linked_ids.len(), 4);
        assert_eq!(rs.linked_ids[0], "20Hz");
        assert_eq!(rs.linked_ids[3], "100Hz");
    }

    #[test]
    fn parse_studio_equipment_file() {
        let src = r#"
equipment "Test EQ" {
  components {
    T1: transformer(10:1, 2H, pp, ct)
    C_lf: cap_switched(27n, 68n, 220n)
    L_hf: inductor_switched(27m, 47m, 82m)
    SW_freq: rotary("100Hz", "200Hz", "400Hz")
    R1: resistor(10k)
  }
  nets {
    in -> T1.a
    T1.b -> C_lf.a
    C_lf.b -> L_hf.a
    L_hf.b -> R1.a
    R1.b -> out
  }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.name, "Test EQ");
        assert_eq!(def.components.len(), 5);
        assert!(def.components.iter().any(|c| c.kind.is_transformer()));
        assert!(def.components.iter().any(|c| c
            .kind
            .as_any()
            .downcast_ref::<CapSwitched>()
            .is_some()));
        assert!(def.components.iter().any(|c| c
            .kind
            .as_any()
            .downcast_ref::<InductorSwitched>()
            .is_some()));
        assert!(def.components.iter().any(|c| c
            .kind
            .as_any()
            .downcast_ref::<RotarySwitch>()
            .is_some()));
    }

    // ── Supply voltage parser tests ───────────────────────────────────────

    #[test]
    fn parse_supply_9v() {
        let src = r#"
pedal "9V Pedal" {
    supply 9V
    components {
        R1: resistor(10k)
    }
    nets {
        in -> R1.a
        R1.b -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.name, "9V Pedal");
        assert_eq!(def.supplies.len(), 1);
        let supply = &def.supplies[0];
        assert_eq!(supply.name, "vcc");
        assert_eq!(supply.config.voltage, 9.0);
        assert!(!supply.config.has_sag());
    }

    #[test]
    fn parse_supply_250v_tube_amp() {
        let src = r#"
pedal "Tube Amp" {
    supply 250V
    components {
        V1: triode(12ax7)
        R1: resistor(100k)
    }
    nets {
        in -> V1.grid
        V1.plate -> R1.a
        R1.b -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.name, "Tube Amp");
        assert_eq!(def.supplies[0].config.voltage, 250.0);
    }

    #[test]
    fn parse_supply_lowercase_v() {
        let src = r#"
pedal "Test" {
    supply 12v
    components {
        R1: resistor(10k)
    }
    nets {
        in -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.supplies[0].config.voltage, 12.0);
    }

    #[test]
    fn parse_supply_decimal() {
        let src = r#"
pedal "Test" {
    supply 9.6V
    components {
        R1: resistor(10k)
    }
    nets {
        in -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert!((def.supplies[0].config.voltage - 9.6).abs() < 0.01);
    }

    #[test]
    fn parse_no_supply_defaults_empty() {
        let src = r#"
pedal "Default" {
    components {
        R1: resistor(10k)
    }
    nets {
        in -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert!(def.supplies.is_empty());
    }

    #[test]
    fn parse_supply_block_tube_rectifier() {
        let src = r#"
pedal "Tube Amp Sag" {
    supply 480V {
        impedance: 150
        filter_cap: 40u
        rectifier: tube
    }
    components {
        V1: triode(12ax7)
        R1: resistor(100k)
    }
    nets {
        in -> V1.grid
        V1.plate -> R1.a
        R1.b -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        let supply = &def.supplies[0].config;
        assert_eq!(supply.voltage, 480.0);
        assert!((supply.impedance.unwrap() - 150.0).abs() < 1e-6);
        assert!((supply.filter_cap.unwrap() - 40e-6).abs() < 1e-12);
        assert_eq!(supply.rectifier, RectifierType::Tube);
        assert!(supply.has_sag());
    }

    #[test]
    fn parse_supply_block_solid_state() {
        let src = r#"
pedal "Modern Amp" {
    supply 480V {
        impedance: 5
        filter_cap: 220u
        rectifier: solid_state
    }
    components {
        R1: resistor(10k)
    }
    nets {
        in -> R1.a
        R1.b -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        let supply = &def.supplies[0].config;
        assert_eq!(supply.voltage, 480.0);
        assert!((supply.impedance.unwrap() - 5.0).abs() < 1e-6);
        assert!((supply.filter_cap.unwrap() - 220e-6).abs() < 1e-12);
        assert_eq!(supply.rectifier, RectifierType::SolidState);
    }

    #[test]
    fn parse_supply_block_with_comments() {
        let src = r#"
pedal "Commented Supply" {
    supply 400V {
        impedance: 100    # tube rectifier + transformer resistance
        filter_cap: 47u   # main filter cap
        rectifier: tube    # GZ34
    }
    components {
        R1: resistor(10k)
    }
    nets {
        in -> R1.a
        R1.b -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        let supply = &def.supplies[0].config;
        assert_eq!(supply.voltage, 400.0);
        assert!((supply.impedance.unwrap() - 100.0).abs() < 1e-6);
        assert!((supply.filter_cap.unwrap() - 47e-6).abs() < 1e-12);
        assert_eq!(supply.rectifier, RectifierType::Tube);
    }

    // ── Multiple supplies tests ────────────────────────────────────────

    #[test]
    fn parse_supplies_block_dual_rail() {
        let src = r#"
pedal "Dual Supply" {
    supplies {
        V+: 15V
        V-: -15V
    }
    components {
        R1: resistor(10k)
    }
    nets {
        in -> R1.a
        R1.b -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.supplies.len(), 2);

        let vpos = &def.supplies[0];
        assert_eq!(vpos.name, "V+");
        assert_eq!(vpos.config.voltage, 15.0);

        let vneg = &def.supplies[1];
        assert_eq!(vneg.name, "V-");
        assert_eq!(vneg.config.voltage, -15.0);
    }

    #[test]
    fn parse_supplies_block_tube_multiple_rails() {
        let src = r#"
pedal "Tube Amp Multi-Rail" {
    supplies {
        B+: 300V { impedance: 100, rectifier: tube }
        bias: -50V
        filament: 6.3V
    }
    components {
        V1: triode(12ax7)
        R1: resistor(100k)
    }
    nets {
        in -> V1.grid
        V1.plate -> R1.a
        R1.b -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.supplies.len(), 3);

        let bplus = &def.supplies[0];
        assert_eq!(bplus.name, "B+");
        assert_eq!(bplus.config.voltage, 300.0);
        assert!(bplus.config.has_sag());
        assert_eq!(bplus.config.rectifier, RectifierType::Tube);

        let bias = &def.supplies[1];
        assert_eq!(bias.name, "bias");
        assert_eq!(bias.config.voltage, -50.0);
        assert!(!bias.config.has_sag());

        let filament = &def.supplies[2];
        assert_eq!(filament.name, "filament");
        assert_eq!(filament.config.voltage, 6.3);
    }

    #[test]
    fn parse_supplies_vcc_legacy_compat() {
        // Legacy `supply 9V` should create "vcc" rail
        let src = r#"
pedal "Legacy" {
    supply 9V
    components {
        R1: resistor(10k)
    }
    nets {
        in -> R1.a
        R1.b -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.supplies.len(), 1);
        assert_eq!(def.supplies[0].name, "vcc");
        assert_eq!(def.supplies[0].config.voltage, 9.0);
    }

    #[test]
    fn pedal_def_helper_methods() {
        let src = r#"
pedal "Test Helpers" {
    supplies {
        V+: 15V
        V-: -15V
        vcc: 5V
    }
    components {
        R1: resistor(10k)
    }
    nets {
        in -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();

        // primary_supply_voltage returns first supply
        assert_eq!(def.primary_supply_voltage(), 15.0);

        // get_supply finds by name
        assert!(def.get_supply("V+").is_some());
        assert!(def.get_supply("V-").is_some());
        assert!(def.get_supply("vcc").is_some());
        assert!(def.get_supply("nonexistent").is_none());

        // supply_names returns all names
        let names = def.supply_names();
        assert_eq!(names.len(), 3);
        assert!(names.contains(&"V+"));

        // is_supply_rail checks if name is a rail
        assert!(def.is_supply_rail("V+"));
        assert!(def.is_supply_rail("V-"));
        assert!(!def.is_supply_rail("gnd"));
    }

    #[test]
    fn parse_supply_rails_in_nets() {
        // Test that V+ and V- can be used in nets section (bipolar supply circuit)
        let src = r#"
pedal "Bipolar Op-Amp" {
    supplies {
        V+: 15V
        V-: -15V
    }
    components {
        R1: resistor(10k)
        R2: resistor(10k)
        C1: cap(100u)
    }
    nets {
        V+ -> R1.a
        R1.b -> R2.a, C1.a
        R2.b -> gnd
        C1.b -> gnd
        V- -> R2.b
        in -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.nets.len(), 6);

        // Check V+ is parsed as a reserved pin
        let v_plus_net = &def.nets[0];
        assert_eq!(v_plus_net.from, Pin::Reserved("V+".to_string()));

        // Check V- is parsed as a reserved pin
        let v_minus_net = &def.nets[4];
        assert_eq!(v_minus_net.from, Pin::Reserved("V-".to_string()));
    }

    // ── Monitors section tests ────────────────────────────────────────

    #[test]
    fn parse_monitors_section() {
        let src = r#"
pedal "Tube Preamp" {
    supply 250V
    components {
        V1: triode(12ax7)
        R1: resistor(100k)
    }
    nets {
        in -> V1.grid
        V1.plate -> R1.a
        R1.b -> out
    }
    monitors {
        V1.plate_current -> "Tube 1" [vu]
        output -> "Output Level" [ppm]
        input -> "Input Level" [peak]
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.monitors.len(), 3);

        let tube_mon = &def.monitors[0];
        assert_eq!(tube_mon.component, "V1");
        assert_eq!(tube_mon.property, "plate_current");
        assert_eq!(tube_mon.label, "Tube 1");
        assert_eq!(tube_mon.meter_type, MeterType::Vu);

        let output_mon = &def.monitors[1];
        assert_eq!(output_mon.component, "output");
        assert_eq!(output_mon.property, "level");
        assert_eq!(output_mon.meter_type, MeterType::Ppm);

        let input_mon = &def.monitors[2];
        assert_eq!(input_mon.component, "input");
        assert_eq!(input_mon.meter_type, MeterType::Peak);
    }

    #[test]
    fn parse_monitors_gain_reduction() {
        let src = r#"
pedal "Compressor" {
    components {
        R1: resistor(10k)
    }
    nets {
        in -> R1.a
        R1.b -> out
    }
    monitors {
        GR.reduction -> "Gain Reduction" [gr]
        supply.sag -> "Sag" [sag]
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.monitors.len(), 2);
        assert_eq!(def.monitors[0].meter_type, MeterType::GainReduction);
        assert_eq!(def.monitors[1].meter_type, MeterType::SupplySag);
    }

    #[test]
    fn parse_empty_monitors() {
        let src = r#"
pedal "No Monitors" {
    components {
        R1: resistor(10k)
    }
    nets {
        in -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert!(def.monitors.is_empty());
    }

    // -----------------------------------------------------------------------
    // IEC 60062 embedded-decimal notation tests
    // -----------------------------------------------------------------------

    #[test]
    fn eng_value_embedded_decimal_resistance() {
        let cases: &[(&str, f64)] = &[
            ("4k7", 4700.0),
            ("2k2", 2200.0),
            ("1M5", 1_500_000.0),
            ("4R7", 4.7),
            ("0R47", 0.47),
            ("100R", 100.0),
            ("47R", 47.0),
            ("10R", 10.0),
        ];
        for &(input, expected) in cases {
            let (rest, v) =
                eng_value(input).unwrap_or_else(|e| panic!("failed to parse {:?}: {}", input, e));
            assert!(rest.is_empty(), "trailing input {:?} for {:?}", rest, input);
            assert!(
                (v - expected).abs() < expected.abs() * 1e-9 + 1e-15,
                "{:?}: got {} expected {}",
                input,
                v,
                expected
            );
        }
    }

    #[test]
    fn eng_value_embedded_decimal_capacitance() {
        let cases: &[(&str, f64)] = &[
            ("2u5", 2.5e-6),
            ("4u7", 4.7e-6),
            ("4n7", 4.7e-9),
            ("2n2", 2.2e-9),
            ("1p5", 1.5e-12),
        ];
        for &(input, expected) in cases {
            let (rest, v) =
                eng_value(input).unwrap_or_else(|e| panic!("failed to parse {:?}: {}", input, e));
            assert!(rest.is_empty(), "trailing input {:?} for {:?}", rest, input);
            assert!(
                (v - expected).abs() < expected.abs() * 1e-9,
                "{:?}: got {:.6e} expected {:.6e}",
                input,
                v,
                expected
            );
        }
    }

    #[test]
    fn eng_value_embedded_decimal_inductance() {
        let cases: &[(&str, f64)] = &[("4m7", 4.7e-3), ("2m2", 2.2e-3)];
        for &(input, expected) in cases {
            let (rest, v) =
                eng_value(input).unwrap_or_else(|e| panic!("failed to parse {:?}: {}", input, e));
            assert!(rest.is_empty(), "trailing input {:?} for {:?}", rest, input);
            assert!(
                (v - expected).abs() < expected.abs() * 1e-9,
                "{:?}: got {:.6e} expected {:.6e}",
                input,
                v,
                expected
            );
        }
    }

    #[test]
    fn eng_value_existing_formats_unchanged() {
        let cases: &[(&str, f64)] = &[
            ("10k", 10_000.0),
            ("100n", 100e-9),
            ("470p", 470e-12),
            ("1u", 1e-6),
            ("100m", 100e-3),
            ("1M", 1_000_000.0),
            ("47", 47.0),
            ("0.1", 0.1),
            ("3.3k", 3300.0),
            ("4.7k", 4700.0),
            ("220n", 220e-9),
        ];
        for &(input, expected) in cases {
            let (rest, v) =
                eng_value(input).unwrap_or_else(|e| panic!("failed to parse {:?}: {}", input, e));
            assert!(rest.is_empty(), "trailing input {:?} for {:?}", rest, input);
            assert!(
                (v - expected).abs() < expected.abs() * 1e-9 + 1e-15,
                "{:?}: got {} expected {}",
                input,
                v,
                expected
            );
        }
    }

    #[test]
    fn eng_value_uppercase_k() {
        let (rest, v) = eng_value("4K7").unwrap();
        assert!(rest.is_empty());
        assert!((v - 4700.0).abs() < 1e-6);
    }

    #[test]
    fn component_defs_with_shorthand() {
        // Resistor with embedded decimal
        let (_, (c, _)) = component_def("R1: resistor(4k7)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Resistor>().unwrap(),
            &Resistor { value: 4700.0 }
        );

        // Capacitor with embedded decimal
        let (_, (c, _)) = component_def("C1: cap(4n7)").unwrap();
        let cap = c
            .kind
            .as_any()
            .downcast_ref::<Capacitor>()
            .expect("expected Capacitor");
        assert!((cap.config.value - 4.7e-9).abs() < 1e-18);

        // Inductor with embedded decimal
        let (_, (c, _)) = component_def("L1: inductor(4m7)").unwrap();
        assert_eq!(
            c.kind.as_any().downcast_ref::<Inductor>().unwrap(),
            &Inductor { value: 4.7e-3 }
        );
    }

    #[test]
    fn full_pedal_with_shorthand_values() {
        let src = r#"
pedal "Shorthand Test" {
    components {
        R1: resistor(4k7)
        R2: resistor(2k2)
        R3: resistor(4R7)
        C1: cap(2u5)
        C2: cap(4n7)
        L1: inductor(4m7)
    }
    nets {
        in -> R1.a
        R1.b -> R2.a
        R2.b -> R3.a
        R3.b -> C1.a
        C1.b -> C2.a
        C2.b -> L1.a
        L1.b -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.components.len(), 6);
    }

    #[test]
    fn parse_subcircuit_basic() {
        let src = r#"
equipment "Test Compressor" {
    supply 30V

    subcircuit sidechain {
        rate: 1/64

        components {
            R1: resistor(10k)
            C1: cap(1u)
        }
        nets {
            in -> R1.a
            R1.b -> C1.a, out
            C1.b -> gnd
        }
    }

    subcircuit audio {
        components {
            R2: resistor(1k)
        }
        nets {
            in -> R2.a
            R2.b -> out
        }
    }

    nets {
        in -> audio.in, sidechain.in
        sidechain.out -> audio.ctrl
        audio.out -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.subcircuits.len(), 2);
        assert_eq!(def.subcircuits[0].name, "sidechain");
        assert_eq!(def.subcircuits[0].rate, Some(64));
        assert_eq!(def.subcircuits[1].name, "audio");
        assert_eq!(def.subcircuits[1].rate, None);

        // Top-level nets should have SubcircuitPort pins after resolution
        let has_sc_port = def.nets.iter().any(|n| {
            n.to.iter().any(
                |p| matches!(p, Pin::SubcircuitPort { subcircuit, .. } if subcircuit == "audio"),
            )
        });
        assert!(
            has_sc_port,
            "top-level nets should contain SubcircuitPort after resolution"
        );
    }

    #[test]
    fn parse_subcircuit_with_controls() {
        let src = r#"
equipment "Test" {
    supply 9V

    subcircuit main {
        components {
            Vol: pot(100k, a)
            R1: resistor(1k)
        }
        nets {
            in -> R1.a
            R1.b -> Vol.a
            Vol.w -> out
            Vol.b -> gnd
        }
        controls {
            Vol.position -> "Volume" [0.0, 1.0] = 0.5
        }
    }

    nets {
        in -> main.in
        main.out -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.subcircuits.len(), 1);
        assert_eq!(def.subcircuits[0].controls.len(), 1);
        assert_eq!(def.subcircuits[0].controls[0].label, "Volume");
    }

    #[test]
    fn parse_rate_power_of_two() {
        // Valid rates
        for rate_str in &[
            "1/2", "1/4", "1/8", "1/16", "1/32", "1/64", "1/128", "1/256",
        ] {
            let src = format!("rate: {}", rate_str);
            assert!(
                parse_rate(&src).is_ok(),
                "rate {} should be valid",
                rate_str
            );
        }
    }

    #[test]
    fn parse_no_subcircuits_backward_compat() {
        // Existing flat pedal syntax should still work
        let src = r#"
pedal "Simple" {
    supply 9V
    components {
        R1: resistor(1k)
    }
    nets {
        in -> R1.a
        R1.b -> out
    }
}
"#;
        let def = parse_pedal_file(src).unwrap();
        assert!(def.subcircuits.is_empty());
        assert_eq!(def.components.len(), 1);
    }

    // ── Ports parser ────────────────────────────────────────────────────

    #[test]
    fn parse_ports_section() {
        let src = r#"pedal "test" {
    supply 9V
    ports {
        audio_in: input
        cv_cutoff: input
        audio_out: output
        env_out: output
    }
    components { R1: resistor(10k) }
    nets { audio_in -> R1.a  R1.b -> audio_out }
    controls {}
}"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.ports.len(), 4, "should have 4 ports");
        assert_eq!(def.ports[0].name, "audio_in");
        assert_eq!(def.ports[0].direction, pedalkernel_rt::PortDirection::Input);
        assert_eq!(def.ports[1].name, "cv_cutoff");
        assert_eq!(def.ports[1].direction, pedalkernel_rt::PortDirection::Input);
        assert_eq!(def.ports[2].name, "audio_out");
        assert_eq!(
            def.ports[2].direction,
            pedalkernel_rt::PortDirection::Output
        );
        assert_eq!(def.ports[3].name, "env_out");
        assert_eq!(
            def.ports[3].direction,
            pedalkernel_rt::PortDirection::Output
        );
    }

    #[test]
    fn parse_no_ports_section() {
        let src = r#"pedal "test" {
    supply 9V
    components { R1: resistor(10k) }
    nets { in -> R1.a  R1.b -> out }
    controls {}
}"#;
        let def = parse_pedal_file(src).unwrap();
        assert!(
            def.ports.is_empty(),
            "should have no ports when section omitted"
        );
    }

    #[test]
    fn ports_used_in_nets() {
        // Port names should be usable in nets as reserved nodes
        let src = r#"pedal "test" {
    supply 9V
    ports {
        audio_in: input
        cv_cutoff: input
        audio_out: output
    }
    components {
        R1: resistor(10k)
        R_cv: resistor(100k)
    }
    nets {
        audio_in -> R1.a
        cv_cutoff -> R_cv.a
        R_cv.b -> R1.a
        R1.b -> audio_out
    }
    controls {}
}"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.ports.len(), 3);
        // Port names should appear in nets as reserved pins
        let has_audio_in = def.nets.iter().any(|n| {
            matches!(&n.from, Pin::Reserved(s) if s == "audio_in")
                || n.to
                    .iter()
                    .any(|p| matches!(p, Pin::Reserved(s) if s == "audio_in"))
        });
        assert!(has_audio_in, "audio_in should be in nets as reserved pin");
    }

    // ── Port impedance syntax ───────────────────────────────────────────

    #[test]
    fn parse_port_with_impedance() {
        let src = r#"pedal "test" {
    supply 9V
    ports {
        audio_in: input(10k)
        cv_cutoff: input(47k)
        audio_out: output(600)
    }
    components { R1: resistor(10k) }
    nets { audio_in -> R1.a  R1.b -> audio_out }
    controls {}
}"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.ports.len(), 3);
        assert_eq!(def.ports[0].name, "audio_in");
        assert_eq!(def.ports[0].impedance, Some(10_000.0));
        assert_eq!(def.ports[1].name, "cv_cutoff");
        assert_eq!(def.ports[1].impedance, Some(47_000.0));
        assert_eq!(def.ports[2].name, "audio_out");
        assert_eq!(def.ports[2].impedance, Some(600.0));
    }

    #[test]
    fn parse_port_without_impedance_backward_compat() {
        let src = r#"pedal "test" {
    supply 9V
    ports {
        audio_in: input
        audio_out: output
    }
    components { R1: resistor(10k) }
    nets { audio_in -> R1.a  R1.b -> audio_out }
    controls {}
}"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.ports.len(), 2);
        assert_eq!(def.ports[0].impedance, None);
        assert_eq!(def.ports[1].impedance, None);
    }

    #[test]
    fn parse_op_block_with_node_voltage_seeds() {
        // `op { Q1: { vbe, vce }  nodes { name: v, ... } }` — device-port seeds
        // PLUS reactive-port (capacitor) node-voltage seeds.
        let src = r#"pedal "test" {
    supply 24V
    components { Q1: npn(BC184C)  R1: resistor(10k)  C1: cap(10u) }
    nets { in -> C1.a  C1.b -> Q1.base, R1.a  R1.b -> gnd  Q1.collector -> out  Q1.emitter -> gnd }
    controls {}
    op {
        Q1: { vbe: 0.64, vce: 5.35 }
        nodes {
            Q1.base: 1.0308
            Q1.collector: 5.7426
            C1.a: 0.0
        }
    }
}"#;
        let def = parse_pedal_file(src).unwrap();
        let explicit: Vec<_> = def
            .init_hints
            .iter()
            .filter(|h| matches!(h.state, InitState::Explicit { .. }))
            .collect();
        let nodes: Vec<_> = def
            .init_hints
            .iter()
            .filter(|h| matches!(h.state, InitState::NodeVoltage { .. }))
            .collect();
        assert_eq!(explicit.len(), 1, "one Explicit device seed");
        assert_eq!(nodes.len(), 3, "three NodeVoltage seeds");
        let qb = nodes
            .iter()
            .find(|h| h.device_label == "Q1.base")
            .expect("Q1.base node seed");
        assert!(matches!(qb.state, InitState::NodeVoltage { v } if (v - 1.0308).abs() < 1e-6));
    }

    #[test]
    fn parse_op_block_without_nodes_still_works() {
        // Back-compat: an `op { }` block with only device seeds (no nodes block).
        let src = r#"pedal "test" {
    supply 24V
    components { Q1: npn(BC184C) }
    nets { in -> Q1.base  Q1.collector -> out  Q1.emitter -> gnd }
    controls {}
    op { Q1: { vbe: 0.64, vce: 5.35 } }
}"#;
        let def = parse_pedal_file(src).unwrap();
        assert_eq!(def.init_hints.len(), 1);
        assert!(matches!(def.init_hints[0].state, InitState::Explicit { .. }));
    }
}