@vessel-dsp/compiler 0.0.0-stage → 0.3.0

package/dist/fixtures/circuits.d.ts

@@ -0,0 +1,1742 @@
+/**
+ * Derive one fixture from another, refusing a replacement that matched nothing.
+ *
+ * A bare `.replace` whose target has drifted returns the original string, so the
+ * derived fixture silently becomes a copy of its parent and its test passes while
+ * asserting nothing about the variation it was written for.
+ */
+export declare const derive: (source: string, from: string, to: string) => string;
+/**
+ * Two 10k resistors from input to ground, output at the midpoint. Forces nodes,
+ * device laws, a linear solve, and the end-to-end slice. Expected gain is exactly 0.5.
+ */
+export declare const resistorDivider: string;
+/**
+ * The same divider with one inline terminal node contradicting the declared ledger.
+ *
+ * `R1.b` is authored inline on node 9 while `nodes:` places it on node 2 with `R2.a` and
+ * the output jack. Stage 1 should follow the ledger and still warn that the document is
+ * inconsistent with itself.
+ */
+export declare const ledgerOverridesInlineDivider: string;
+/**
+ * A divider with a **0 ohm link** in series ahead of it: the schematic-capture convention for
+ * an ideal wire, drawn as a resistor because the board really does have a jumper there.
+ *
+ * The behaviour existed and was untested, which is the gap this closes. `device-laws.ts` stamps
+ * a declared zero as `SWITCH_ON_OHMS` -- the same electrically-indistinguishable-from-ideal
+ * short a closed switch gets -- because `1/0` is not a representable conductance. Untested
+ * behaviour is how the CD4047 pin binding silently regressed: a fact verified and never turned
+ * into an assertion.
+ *
+ * The assertion is behavioural rather than structural: the link is in series with the signal, so
+ * a divider with it must measure the same gain as `resistorDivider` without it. A link stamped
+ * as anything but a near-short would show up as a divider ratio, and one stamped as an open
+ * would take the gain to zero.
+ *
+ * `mxr-noise-gate-line-driver`'s `R_U1B_FB` is the corpus instance -- `Resistance: { raw: "0
+ * Ohm", value: 0, unit: "Ω" }`, and the only resistor of 3090 in the corpus declaring exactly
+ * zero.
+ */
+export declare const zeroOhmLinkDivider: string;
+/**
+ * A resistor that declares no resistance at all, and is not marked unpopulated.
+ *
+ * **The control that keeps the 0 ohm link honest.** A stated zero and an absent value look
+ * similar in a diff and mean opposite things: one is a jumper the board really has, the other is
+ * a value nobody recorded. Reading the second as the first would silently short a circuit --
+ * exactly the wrong-answer-that-still-renders this pipeline refuses.
+ *
+ * So this must refuse, and it must keep refusing. `mxr-carbon-copy`'s `R4` is the corpus
+ * instance: `SourceValue: visible-no-value-or-DNP`, `SourceConfidence: medium`,
+ * `SourceStatus: defer` -- the source itself declines to say. The refusal is the correct
+ * consumer behaviour there, not a gap.
+ */
+export declare const resistorWithNoResistance: string;
+/**
+ * A `DNP` position that *does* declare its value: R2 keeps its 10k and is marked unpopulated.
+ *
+ * The corroborated shape, and the counterpart to `notPopulatedResistor`'s load-bearing one. The
+ * document says "this is a 10k position, unfitted": the part still leaves the solve, but nothing
+ * is concealed by its leaving — a reader can see what would sit there and check it against a
+ * board. Distinguishing the two is the whole of `report-source-integrity`'s DNP handling, so both
+ * need a fixture or the distinction is asserted only in prose.
+ */
+export declare const notPopulatedResistorWithValue: string;
+/**
+ * A resistor declaring a **negative** resistance.
+ *
+ * The other side of the zero boundary, and the control that says where the line is: zero is a
+ * jumper the board really has, and below zero is not a resistor at all. `device-laws.ts` refuses
+ * it (`!(ohms > 0)` after the zero case is taken), and that refusal is the reason a declared zero
+ * can be admitted safely -- the pipeline is not simply accepting whatever number appears.
+ *
+ * No corpus packet declares one; all 3090 corpus resistors are positive or zero. That is why it
+ * is a fixture: a boundary defended only where the corpus happens to push is not defended.
+ */
+export declare const resistorWithNegativeResistance: string;
+/**
+ * The same value-less resistor, marked `DNP: 'true'`.
+ *
+ * An unpopulated position is an open circuit -- a stated fact about the board, not a missing
+ * value -- so this compiles with the component dropped, where the fixture above refuses. The
+ * pair is the whole point: the same absent value is a refusal or a legitimate open depending on
+ * one typed flag, and nothing else distinguishes them.
+ *
+ * `mxr-carbon-copy` carries four of these (`R45`, `R50`, `C32`, `C34`) and is the only corpus
+ * packet that does.
+ */
+export declare const notPopulatedResistor: string;
+/**
+ * A divider plus an `InterfaceOnly` open resistor that declares no resistance. Without the
+ * interface/source-only read this fixture refuses -- a resistor with no `Resistance` throws in
+ * the parameter stage. The flag is the source's way of saying "panel-LED shell, no driver
+ * specified, do not model it", and the correct answer is to drop it (with a warning), not to
+ * refuse the whole circuit over a value the source deliberately omits. `SourceOnly` is the
+ * twin: the negative control derives it by flipping the flag, and it must behave identically.
+ */
+export declare const interfaceOnlyPlaceholder: string;
+export declare const sourceOnlyPlaceholder: string;
+/**
+ * 10k into 10n to ground, output across the capacitor. Forces state, the integration
+ * method, and a corner frequency that can be checked by hand.
+ */
+export declare const rcLowPass: string;
+/** A pot as a divider. Forces control binding, 0..1 positions, and emitted taper. */
+export declare const potDivider: string;
+/**
+ * `potDivider` plus the enclosures that are not controls: jacks and a status
+ * LED, each declared on the panel and bound to its component exactly the way
+ * `boss-od-1` declares `INPUT_JACK`, `OUTPUT_JACK` and `CHECK_LED`. The
+ * non-knob kinds must be dropped from `Program.controls` while the knob
+ * (`Level`) survives and all three devices stay in the netlist.
+ */
+export declare const panelKnobAndHardwareControls: string;
+/**
+ * A switch whose both terminals resolve to one node (`boss-od-1`'s
+ * `INPUT_BATTERY_CONTACT` shape) next to an ordinary unbound two-terminal
+ * switch on distinct nodes. The fixed contact manufactures no control; the
+ * real switch keeps its invented one (`switchInSignalPath` pins that second
+ * behaviour), so the negative control proves this gate can fail for the
+ * claimed reason.
+ */
+export declare const fixedContactSwitchCircuit: string;
+/**
+ * A **rheostat** wired so the two orientation rules disagree.
+ *
+ * `end1` sits on ground and the wiper shares node 2 with `end2`, so the live leg is
+ * `end1`-to-wiper. Quiet-distance sees the grounded end as the quiet one and swaps the ends,
+ * putting the live leg on `lower`; declaration order leaves it on `upper`. The two rules give
+ * different answers here, which is what makes this fixture worth having.
+ *
+ * The control declares a time-constant role, so `potTerminals` steps aside from quiet-distance:
+ * its premise -- a rising knob should be louder -- says nothing about a pot setting an RC, and
+ * on `boss-nf-1-noise-gate`'s `DECAY` it picked the side that ran the knob backwards.
+ */
+export declare const rheostatWithTimeConstantRole: string;
+/**
+ * The same shape and the same disagreement, with a level role instead. The exemption must NOT
+ * fire here: letting declaration order win for every rheostat was measured across the corpus and
+ * inverts four knobs that are right today, `boss-fa-1`'s `VOLUME` among them.
+ */
+export declare const rheostatWithLevelRole: string;
+/**
+ * The same pot with its wiper hanging off node 3, which nothing else touches, and its
+ * track carrying the signal from input to output instead.
+ *
+ * Electrically a fixed 10k in series: the two halves stay in series through a floating
+ * junction, so their sum is the whole track wherever the knob sits and the control
+ * cannot move a node voltage. It still compiles and still renders -- which is the
+ * defect, since `ibanez-ts808` shipped exactly this and rendered bit-identical output
+ * at `Drive=0.1` and `Drive=0.9`.
+ */
+export declare const potWithFloatingWiper: string;
+/** Anti-parallel diodes to ground after a series resistor. Forces Newton. */
+export declare const diodeClipper: string;
+/** Anti-parallel LEDs to ground after a series resistor. Moves clipping knee higher. */
+export declare const ledClipper: string;
+/**
+ * The clipper's upper diode carrying a catalogued zener part number and nothing else, so
+ * the diode law comes from the catalog's `zenerLaw` entry (1N4733A: 5.1 V knee, class
+ * forward defaults) rather than from the source.
+ */
+export declare const zenerCatalogDiode: string;
+/**
+ * The LED clipper's upper LED carrying a catalogued zener part number: the device the source
+ * declares as an LED must stay one under a catalog match, not come back a plain diode.
+ */
+export declare const zenerLedKeepsLed: string;
+/**
+ * The same zener part with the source's own forward parameters and knee typed, so every
+ * declared value must survive the catalog match and only absence is filled.
+ */
+export declare const zenerDeclaredParameters: string;
+/**
+ * Inverting amplifier: 10k in, 100k feedback, non-inverting leg at ground. Forces the
+ * auxiliary-constraint row, which is the same mechanism an ideal transformer needs.
+ * Gain is -R_f/R_in = -10 exactly, so the magnitude is a hand-checkable 10.
+ */
+export declare const invertingAmplifier: string;
+/**
+ * The same amplifier with the feedback **resistor replaced by a capacitor**: an integrator
+ * with no DC feedback path.
+ *
+ * Nothing pins the inverting node's operating point -- at DC the capacitor is an open
+ * circuit, so the output cannot influence its own input -- and any standing differential
+ * integrates. `ibanez-pql` ships this shape on its signal path and diverges to `8.55e+12 V`
+ * from a 9 V supply. Kept minimal deliberately: swapping one element is what separates a
+ * bounded stage from an unbounded one, and the fixture should show exactly that.
+ */
+export declare const opampCapacitiveFeedbackOnly: string;
+/**
+ * The same inverting amplifier with a 9 V supply present. Gain is still -10, but the
+ * output cannot leave the 0..9 V rails, so a hot input clips instead of producing
+ * a voltage the pedal could not make.
+ */
+export declare const railedAmplifier: string;
+/**
+ * An op-amp Schmitt-trigger astable: the railed amplifier with its non-inverting input moved onto
+ * a 10k/10k divider from its own output (positive feedback, hysteresis at half the swing) and its
+ * inverting input on a 100k / 100n timing network. It oscillates rail to rail.
+ *
+ * The case the op-amp step limiter's halving cap was not built for. At every edge the branch the
+ * Newton iterate starts on ceases to exist, the Jacobian points back at it, and the cap pins at its
+ * floor in a two-cycle; the runtime must reseed the comparator on its other rail rather than burn
+ * the iteration cap. Measured before the reseed: 11 of 9600 samples held at a 1024-iteration peak.
+ */
+export declare const schmittTriggerAstable: string;
+/**
+ * An op-amp powered from a rail of its own, spelled the way this corpus actually spells it.
+ *
+ * The circuit's supply set is +9 / -9, but this op-amp's `vPlus` sits on a separate +4 V node
+ * and its `vMinus` on ground, so the rails it should clip at are 4 and 0 -- neither of them a
+ * circuit extreme. While the rail lookup read only the exact spellings `vcc`/`vee`, this
+ * op-amp was given 9 and -9: a clipping ceiling more than twice its real one, on a part whose
+ * whole audible contribution in a drive pedal is where it clips.
+ *
+ * `boss-bd-2-blues-driver` is the corpus instance and it is not a corner case -- it declares
+ * three supply ports (9 V, 8 V, 4 V) and both its op-amps' `vPlus` is on the 8 V one, while
+ * the compiler handed them the 9 V inlet rail.
+ */
+export declare const opampOnItsOwnRail: string;
+/**
+ * The same op-amp with both supply pins on the one node.
+ *
+ * A degenerate pair -- `railHigh == railLow` -- which is not a narrow clipping window but a
+ * contradiction: the linear region has negative width and the output pins wherever the
+ * limiter lands. Reading a document's own supply pins can produce it, so `opampRails`
+ * requires an ordered pair and keeps the circuit set when it does not get one.
+ *
+ * Measured rather than hypothetical: `mxr-m117r-flanger`'s `U4` declares `pin8_vplus` and
+ * `pin4_vminus` and **both resolve to the same node** -- ground, carrying a declared +15 V,
+ * because that packet puts its `V15` rail component on the ground node. Eight op-amp stamps
+ * came out at `high = low = 15` before the invariant existed.
+ */
+export declare const opampWithDegenerateRails: string;
+/**
+ * An op-amp that names no inputs at all: `vPlus`, `vMinus`, `output`, in that order.
+ *
+ * The reason the supply vocabulary is split in two rather than being one list.
+ * `vplus`/`vminus` is how every corpus op-amp that declares supplies spells them -- but it is
+ * also the natural spelling for a bare differential pair, and `opampTerminals` falls back to
+ * declaration order when it cannot resolve a named input pair, so here those two terminals
+ * are wired as **the inputs**. Reading them as rails as well would clamp this op-amp to its
+ * own input voltages. The rails must come from the circuit set, +9 / -9.
+ *
+ * This is the invariant the guard protects -- a terminal cannot be both a signal input and a
+ * rail -- and it is a control no corpus census could have supplied, because the corpus
+ * happens to contain no such part. A vocabulary justified only by what the corpus does today
+ * is a vocabulary that breaks on the next document.
+ */
+export declare const opampWithUnnamedInputs: string;
+/**
+ * A divider whose lower leg can be shorted by a switch. Open, the output is the
+ * divider's half; closed, the lower leg is shorted and the output collapses. Forces
+ * topology that changes with a control, without a second netlist.
+ */
+export declare const switchedDivider: string;
+/**
+ * The same switch, but stating its contact state the way nine corpus switches do -- a
+ * `State` rather than a `Position` or a `Wipe`. Derived from `switchedDivider` by adding
+ * exactly one property, so a difference between the two can only be that property.
+ */
+export declare const switchedDividerStatingClosed: string;
+/** The amp corpus's spelling of the same fact: `SelectedState` rather than `State`. */
+export declare const switchedDividerStatingSelectedState: string;
+/**
+ * `SelectedState` carrying something that is not a contact state at all, which the corpus also
+ * does (`16 ohms`, `90w full-power silicon path`). It must be ignored rather than refused: unlike
+ * `State`, this field is not only about contacts.
+ */
+export declare const switchedDividerStatingUnrelatedSelectedState: string;
+/** A fuse, which conducts unless a source says it has blown. */
+export declare const switchedDividerWithFuseRating: string;
+/** The same again with a contact state no closed vocabulary contains. */
+export declare const switchedDividerStatingUnknownContact: string;
+/**
+ * The same unpositioned switch, wired the other way round: in series between the input
+ * port and the divider rather than shunting the midpoint to ground, so the only path
+ * from input to output runs through it. `switchedDivider`'s switch has a path around
+ * it; this one is the path. Both senses appear in the corpus under identical terminal
+ * naming, which is why the default cannot be a constant.
+ */
+export declare const switchInSignalPath: string;
+/**
+ * A JFET whose **drain sits below its source**, so `vds` is negative and only a symmetric channel
+ * conducts. The gate is at the input, the source is pulled up through 10k and the drain pulled
+ * down through 10k.
+ *
+ * A channel conducts both ways -- which is why a JFET works as an analogue switch -- and the
+ * runtime treated reverse as cutoff until 2026-08-12. With the old law the two resistors were
+ * independent and the operating point sat at 9 V and 0 V; symmetric, it solves to 7.42 V and
+ * 1.58 V, matching ngspice to 0.08%. `boss-hm-2` has three signal-path FETs spending most samples
+ * here.
+ */
+export declare const jfetReverseBiased: string;
+/**
+ * A JFET whose gate, source and drain each sit on their own 1M/1M divider off 9 V,
+ * so every terminal idles at 4.5 V and the channel (Vds = 0) carries nothing. The only
+ * current in the circuit is the gate's own: each junction draws
+ * `gateSaturationCurrent * softplus((0 - 0.5) / 0.06)` ~ 2.4 nA, and the two together
+ * sag the 0.5M-thevenin gate divider ~2.4 mV while lifting the source/drain dividers
+ * ~1.2 mV each. A voltmeter on the gate therefore reads the gate law directly.
+ *
+ * Unregistered, so this is the class default under test, not any part. The registered
+ * twin below (`jfetGateLoadedDivider2SK30A`) is the same copper with a part number,
+ * and the pair pins the per-part refinement: same dividers, no sag.
+ */
+export declare const jfetGateLoadedDivider: string;
+/**
+ * The same copper as `jfetGateLoadedDivider` with the 2SK30A part number, so the
+ * catalog's per-part gate data applies instead of the class default: the gate draws
+ * ~1e-18 A and every divider sits at its unloaded 4.5 V. The two fixtures render the
+ * same circuit with different gate laws, which is what makes their pair a regression
+ * test for the refinement rather than two readings of one law.
+ */
+export declare const jfetGateLoadedDivider2SK30A: string;
+/**
+ * A supply with a protection diode wired the wrong way round: anode on the 9 V rail, cathode on
+ * ground, so the whole supply forward biases it.
+ *
+ * `ibanez-ts808` and `ibanez-ts9` both ship this, each carrying **1.074 A** through it while
+ * rendering a plausible level, because the runtime clamps the junction voltage instead of
+ * diverging. Reversing the two terminal roles turns this fixture into the correct arrangement,
+ * which is what the paired test checks.
+ */
+export declare const diodeShortingSupply: string;
+/** The same supply with the protection diode the right way round: cathode to the rail. */
+export declare const diodeProtectingSupply: string;
+/**
+ * A 9.1 V zener shunt regulator feeding a light load, supply below breakdown.
+ * 9 V through 470 ohm into 10k//1M: the rail must sag to ~8.59 V. Below
+ * breakdown a zener passes leakage only, so any rail at or above the 9 V
+ * supply is a current the diode law invented, not the circuit.
+ */
+export declare const zenerRegulatedRail: string;
+/**
+ * `zenerRegulatedRail` fed from 12 V, so the zener conducts and regulates. About 5.3 mA
+ * reaches it, just past the 5 mA at which a declared breakdown voltage is read, so the rail
+ * must sit within a few millivolts of 9.1 V. This pins the knee, not only the leakage.
+ */
+export declare const zenerRegulatingRail: string;
+/**
+ * The 5F1's V1A triode stage, built to match `whole-amp-5f1` exactly so its operating point is
+ * a validated oracle rather than a snapshot: 68k grid stopper from the input, 1M grid leak,
+ * 1.5k cathode to ground, 100k plate load to a 250 V rail.
+ *
+ * That experiment solves `Vk 1.251`, `Vp 166.6`, `Ip 0.83 mA`, and those three are consistent
+ * by hand (`1.251/1500 = 0.834 mA`; `250 - 0.834e-3 * 100e3 = 166.6`), so the fixture is
+ * checkable without trusting the experiment's solver.
+ */
+export declare const triodeGainStage: string;
+/**
+ * Emitter follower on a 9 V rail: 10k/10k base bias, 4k7 emitter, signal coupled in
+ * through 1u. Forces Ebers-Moll, junction limiting, a DC operating point, and a
+ * voltage source. Voltage gain is Re/(Re + re) with re = Vt/Ie, so just under unity.
+ */
+export declare const emitterFollower: string;
+/**
+ * A standard NPN common-emitter amplifier stage with 4-resistor bias.
+ *
+ * 9 V rail, RB1=100k, RB2=22k base divider, RC=4.7k collector load, RE=1k emitter resistor,
+ * 10u input/output coupling caps into a 1M load.
+ *
+ * Expected small-signal AC gain is -(RC || RLOAD) / (RE + re) ~ -4.53 V/V.
+ */
+export declare const commonEmitterAmplifier: string;
+export declare const commonEmitterAmplifierHalvedRe: string;
+/**
+ * A DC-driven transformer secondary carrying a declared-voltage port, for the milestone that a
+ * transformer winding may borrow generated status from another winding of the same transformer.
+ *
+ * `VBATT` (10 V, DC) drives the primary; the secondary is fixed by the ideal transformer's own
+ * constraint at exactly `10 / 2 = 5 V`, independent of `RLOAD`, which only sets the current. The
+ * declared `BPLUS_PORT` states `6 V` -- a plausible chart value, deliberately not the true `5 V`
+ * -- so a promoted ideal rail and the real transformer answer are distinguishable by more than
+ * rounding, the same shape `tubeDiodeIntoLoadWithDeclaredPort` uses for the rectifier case.
+ *
+ * DC rather than AC on purpose, matching `tubeDiodeIntoLoad`'s own reasoning: it isolates the
+ * transformer-coupling question from the AC source and its own RMS-to-peak conversion, so a
+ * failure here is the coupling rule and nothing else.
+ */
+export declare const transformerSecondaryWithDeclaredPort: string;
+/** Ideal 1:2 step-up into a 10k load. Forces the four-terminal constraint row. */
+export declare const stepUpTransformer: string;
+/** Ideal 2:1 step-down transformer: turns ratio 2.0, so gain is 0.5. */
+export declare const stepDownTransformer: string;
+/** JFET source follower on a 9 V rail, gate at 0 V through 1M, 2k2 source. */
+export declare const jfetFollower: string;
+/**
+ * MOSFET source follower. Enhancement mode is off at zero gate bias, so unlike the
+ * JFET the gate is biased from the rail by a divider rather than referenced to
+ * ground. The divider is 10k/10k rather than 1M/1M for a reason worth recording: an
+ * uncharged coupling capacitor starts as a near-short, so the gate is dragged to 0 V
+ * and charges with tau = C * (R1 || R2). At 1M that is 0.5 s, far longer than any
+ * test window. The JFET fixture escapes this only because its bias point is 0 V, so
+ * it needs no settling at all. Same law as the JFET, opposite threshold sign.
+ */
+export declare const mosfetFollower: string;
+/** 1 H into 10k to ground, output across the resistor: an RL low pass at R/(2*pi*L). */
+export declare const rlLowPass: string;
+/** An IC with no registry entry. Forces the unsupported outcome. */
+export declare const unknownChip: string;
+/**
+ * An 8-pin chip a registry supplies as **two** sections, the shape a dual op-amp takes.
+ *
+ * Bare `pin1`..`pin8` names on purpose: a section indexes terminals positionally, so this proves
+ * the expansion does not depend on role tokens -- which is the whole reason sections exist, since an
+ * 8-pin dual op-amp has two outputs and no role token can name either unambiguously.
+ */
+export declare const dualSectionChip: string;
+/** The same IC, with a part number a fixture registry can supply a macro model for. */
+export declare const knownChip: string;
+/**
+ * The same IC again, with a part number a registry supplies a *lumped law* for.
+ *
+ * Three documents, one device, three answers -- and the document is identical apart from
+ * the part number: unsupported with no model, a macro region with one, an ordinary
+ * two-terminal element with another. That is the injected registry doing its job:
+ * opacity is a property of what the registry knows, never of the device.
+ */
+export declare const resistiveChip: string;
+/**
+ * The pinout rung, positive control: an `ic` whose only identity is two terminal roles,
+ * both covered by the fixture registry's groups (`cp1`, `vgg`). No part id, no declared
+ * type -- so it reaches the pinout rung and must match exactly.
+ */
+export declare const chipPinoutExact: string;
+/**
+ * The pinout rung, negative control: the same two roles plus `reset`, which the
+ * registry's groups do not cover. Presence alone would satisfy both groups and stamp a
+ * macro identity; the exact test must refuse it instead, because a role no group
+ * accounts for is evidence this is not that part.
+ */
+export declare const chipPinoutSuperset: string;
+/**
+ * The divider again: different coordinates, different component order, different
+ * names. Must yield the same netlist up to node relabeling.
+ */
+export declare const resistorDividerRedrawn: string;
+/**
+ * Two clippers that share only ground, so partitioning yields two nonlinear regions.
+ *
+ * The second pair sits on nodes 7 and 8, reachable from neither port, which is what
+ * makes it a second *region* rather than more devices in the first one. Needed because a
+ * failure counted per block cannot be told from one counted per sample until a document
+ * has two blocks that can fail on the same sample.
+ */
+export declare const twoDiodeClippers: string;
+/**
+ * The redrawn divider with its non-ground nodes renumbered.
+ *
+ * `resistorDividerRedrawn` varies coordinates, order, names and value notation but keeps
+ * node 1 and node 2, so it cannot show whether a node id is a label or a meaning. Here
+ * the same circuit calls them 5 and 7. Ground stays 0 because ground is not a label the
+ * document is free to choose -- the ground symbol decides it.
+ */
+export declare const resistorDividerRelabelled: string;
+/** Malformed: not valid interchange YAML. */
+export declare const malformed = "schema: circuit-interchange/v3\n  : : :\n";
+/** A resistor whose value cannot be parsed. Must refuse rather than default. */
+export declare const unparseableValue: string;
+/** The divider with every node id quoted. A node id is a token, not a number. */
+export declare const quotedNodeDivider: string;
+/**
+ * The divider with named node ids and a ground symbol.
+ *
+ * The ground token is called `n_delay_clock_bus` on purpose. Nothing in that name says
+ * ground; the only thing that does is the ground symbol sitting on it. A rule that
+ * matched node names for `gnd` would pass this fixture while being wrong, and a rule
+ * that reads the symbol passes it for the right reason.
+ */
+export declare const namedNodeDivider: string;
+/**
+ * A structured quantity whose value is stated in kilohms.
+ *
+ * Ten kilohms, not ten ohms. The format library reports `value` in whatever unit it
+ * read, so a stage that trusts `value` without reading `unit` turns every `10k` in the
+ * corpus into 10 -- a wrong answer that still renders.
+ */
+export declare const kilohmStructuredValue: string;
+/** A taper code this stage cannot read, resolved by the library in base units. */
+export declare const taperCodeStructuredValue: string;
+/** Unreadable notation *and* a non-base unit: no answer is better than a wrong one. */
+export declare const unreadableNonBaseUnit: string;
+/**
+ * The same inverting amplifier with its op-amp inputs declared in the other order.
+ *
+ * Electrically identical: `inverting` is still node 3 and `noninverting` still node 0.
+ * Only the order the document lists them in changes, and the corpus really does write
+ * it both ways. A stage reading position instead of role exchanges the two inputs
+ * here, which inverts the stage while still rendering plausible audio.
+ */
+export declare const invertingAmplifierReordered: string;
+/**
+ * A two-terminal rheostat: 100k track, control at mid travel, feeding ground through
+ * a 100k series resistor. A linear sweep at 0.5 is 50k, so the divider reads 100k over
+ * 150k = 2/3. Hand-computed before it was measured.
+ */
+export declare const rheostatDivider: string;
+/**
+ * Two rheostats that are the two gangs of one physical knob.
+ *
+ * The declared control's id is `SAG_CTL`, but each gang names it the way the packets
+ * do: one by the control's `audioBinding.controlName`, the other by `PhysicalControl`.
+ * Matching only the id leaves both unbound and each invents a control of its own, so
+ * one knob silently becomes two that each move half the circuit.
+ */
+export declare const gangedRheostats: string;
+/** The same rheostat with a residual minimum, so the bottom of the sweep is not zero. */
+export declare const rheostatWithMinimum: string;
+/**
+ * A three-terminal pot wired as a rheostat -- its wiper node **is** its `lug3` -- with both
+ * track ends cut off from every DC reference: the far end (node 4) reaches a second op-amp's
+ * `vplus` rail node in one hop, and the input-end (node 5) reaches the first op-amp's
+ * inverting input in three.
+ *
+ * This is the narrow path of the pot's orientation evidence. Before 2026-08-25 `vplus` and
+ * `vminus` were seeds for that evidence's distance map, so the rail-adjacent end read one hop
+ * from an "op-amp input" that was in fact a supply rail: the track oriented to the rail end
+ * and the control swept the stage's gain the wrong way, silent at full. Nothing else saw it --
+ * the pot still swept, the circuit still converged, and at half travel both orientations agree
+ * because a linear taper's midpoint is its own mirror. Only the off-centre values differ, and
+ * they are written down in `expected.ts` from the divider arithmetic, not captured from a run.
+ *
+ * The second op-amp is electrically dead on purpose: its non-inverting input is grounded and
+ * its inverting input hangs off a single 100k to ground, so the whole pocket settles at zero
+ * and no floating island in the fixture needs gmin to land somewhere.
+ */
+export declare const quietSeedRheostat: string;
+/**
+ * A strapped-wiper rheostat treble shunt with **declared rotation** -- the
+ * `fulltone-ocd-v1.4` `Tone` class: the 47 n series cap feeds the free end
+ * (node 6), the wiper is strapped to the grounded end (node 0), and the ends
+ * declare `ccw`/`cw` instead of the ambiguous `end`.
+ *
+ * Without the declaration the quiet-distance inference puts position 0 at the
+ * grounded strapped end, landing the live leg on `upper` (`share = 1 -
+ * fraction`) so the bleed resistance *falls* as the knob rises -- the knob runs
+ * backwards. The declaration must outrank it: `end2` is the `ccw` free end, the
+ * live leg runs wiper-to-free-end on `lower` (`share = fraction`), and bleed
+ * resistance grows with the control.
+ */
+export declare const rheostatWithDeclaredRotation: string;
+/**
+ * The feedback-gain rheostat with its wiper strapped to the `output` node and the
+ * free end (declared first) reaching the `inverting` input -- the `boss-os-2`
+ * `VR3b` case, where declaration order ran the knob backwards. See
+ * `feedbackGainRheostat` for the wiring.
+ */
+export declare const feedbackGainRheostat: string;
+/**
+ * The same stage with the wiper strapped to the inverting-side node (6) instead of
+ * the `output` node. The wiper-strapped end is then the one far from a declared
+ * output, so the feedback-output rule's guard must refuse and leave the pot in its
+ * declaration-order orientation -- a negative control for the flip above. See
+ * `feedbackGainRheostat` for the wiring.
+ */
+export declare const feedbackGainRheostatWiperOnInverting: string;
+/**
+ * The divider plus a resistor, an LED and a footswitch that declare no terminals.
+ *
+ * The corpus is full of these: panel hardware from a photo, bias markers from a build
+ * document. They are named and described exactly like circuit elements, so the only
+ * honest reason to ignore them is the empty terminal list. Adding them must change
+ * nothing at all.
+ */
+export declare const dividerWithUnconnectedParts: string;
+/**
+ * The same emitter follower with its transistor terminals in the corpus's usual order.
+ *
+ * `collector,base,emitter` is how **282 of the corpus's 490 transistors** are written,
+ * against 15 for `base,collector,emitter`. Electrically identical to the fixture above
+ * -- the base is still node 3 -- but a stage reading position exchanges base and
+ * collector, the transistor never turns on, and the pedal renders silence.
+ */
+/**
+ * The same follower with the supply's two terminals declared the other way round.
+ *
+ * Electrically identical -- node 5 is still the 9 V rail and node 0 is still the return --
+ * but read by position the rail inverts to -9 V, and the packet still compiles `ok`. A
+ * supply was the last asymmetric device in the pipeline read by declaration order, and a
+ * rail's sign is not a subtle error: every bias point in the circuit hangs off it.
+ */
+export declare const emitterFollowerSupplyReversed: string;
+/**
+ * The follower's rail stated the way most corpus rails are: one node, against ground.
+ *
+ * No fixture had this shape, so reading a supply's polarity by role -- which needs two
+ * terminals -- refused **34 packets** and took the corpus from 52 compiled to 19, with
+ * the whole unit suite still green. The scoreboard caught it; no test could.
+ */
+export declare const emitterFollowerRailToGround: string;
+/**
+ * The same supply stated twice, the second time reversed.
+ *
+ * Two rows asserting opposite signs across one pair of nodes is a contradiction, not a
+ * duplicate -- and keying the dedup on `positive:negative` made the reversed twin look
+ * like a different supply, so both were stamped.
+ */
+export declare const contradictorySupplyTwin: string;
+export declare const emitterFollowerReordered: string;
+/**
+ * The same follower with the BJT's own IS and BF typed, so the bjt law runs on declared
+ * values and `bjt-law-default-parameters` stays silent. IS/BF are the corpus spellings
+ * (`sola-sound-tone-bender-professional-mkii`, `electro-harmonix-lpb-1`); the values are
+ * the law's own defaults restated, so the program is unchanged and only the disclosure moves.
+ */
+export declare const bjtTypedParameters: string;
+/**
+ * The pot divider with the wiper declared last instead of in the middle.
+ *
+ * `anode,cathode,wiper` is 64 of the corpus's 331 three-terminal pots. Reading position
+ * 2 as the wiper makes the grounded end the wiper, which shorts both halves of the
+ * track to ground and cuts the output off from the input entirely.
+ */
+export declare const potDividerWiperLast: string;
+/**
+ * The divider with a third jack, and no jack declaring a role.
+ *
+ * `Circuit.Jack` is the corpus's untyped catch-all: it absorbs DC inlets, remote
+ * sockets and second outputs alongside the real pair. The roles here are only in the
+ * names, which no stage may read, so there is nothing to resolve a port from. The
+ * third jack is declared last on purpose -- a positional fallback would take it as the
+ * output, which is how a DC inlet came to be read as a pedal's output.
+ */
+export declare const untypedJacks: string;
+/**
+ * Jacks whose declared roles reach them only through the panel binding.
+ *
+ * Both jacks are typed `Circuit.Jack`, so the type name says nothing. The roles are
+ * declared against panel-facing ids (`INPUT_JACK`, `OUTPUT_JACK`) and the panel binds
+ * those to the components — which is how most of the corpus states it, and it is a
+ * chain no type-name table can substitute for.
+ *
+ * A third jack carries `role: direct-output` and is declared **first**, so anything
+ * choosing by position or by "the first jack that looks like an output" takes the dry
+ * send instead of the effect output.
+ */
+export declare const jacksTypedOnlyByRole: string;
+/**
+ * A single-pole, two-throw selector routing the input to one of two resistors.
+ *
+ * The throws are declared in the opposite order to the options — `throws` are
+ * `bright,dark` while `Options` is `Dark,Bright` — because three corpus selectors do
+ * exactly that, and taking the option's index would select the other throw. `Position`
+ * names the option rather than giving a number, which is how the corpus states it and
+ * why `Number(position)` silently becomes half travel.
+ */
+export declare const selectorRouting: string;
+/**
+ * The same selector with its common terminal declared **last**.
+ *
+ * `throw0,throw1,common` is a real corpus shape, and `marshall-blues-breaker` wires its
+ * input jack to exactly such a switch. Attaching throws to a preceding common builds a
+ * pole out of the first throw and drops the real common entirely — which left the input
+ * jack's node connected to nothing and the pedal silent, while every stage reported
+ * success.
+ */
+export declare const selectorCommonLast: string;
+/**
+ * Two jacks whose third terminals carry the **same role name** and opposite senses.
+ *
+ * `IN.switch` is where the battery's negative landed, so it has to make against the
+ * sleeve or the supply has no return and the whole circuit floats. `OUT.switch` carries
+ * signal, and making *it* against the sleeve shorts the output to ground.
+ *
+ * One name, two required answers, so no contact-name vocabulary can decide this. The
+ * fixture exists because a name table was tried and shorted 13 corpus jacks, five of
+ * them supply rails.
+ */
+export declare const switchedJackContacts: string;
+/**
+ * A power jack that strands the supply behind its switch contact.
+ *
+ * `BT1.positive` and `PWR.tip` are alone on node 5, and the circuit's rail is node 6 on
+ * the jack's contact. This is the battery-saving arrangement: the contact routes the
+ * battery to the pedal and inserting an adaptor breaks it. `boss-od-3` and `boss-mt-2`
+ * are exactly this shape.
+ *
+ * The element has to be tip-to-contact. Closing the contact to the *sleeve* instead is
+ * what a contact-name table does, and it shorts the 9 V rail to ground; leaving it open
+ * strands the supply and the whole pedal solves with every node at 0 V. So the assertion
+ * that matters is which terminal it makes against, not that a law exists.
+ */
+export declare const powerJackStrandedSupply: string;
+/**
+ * Wired jacks and a ground, and every other component declaring no terminals.
+ *
+ * `boss-ps-2` is exactly this: 223 real, electrically active parts that are correctly
+ * dropped for having no terminals, leaving nothing to solve. Every stage succeeds and
+ * the result is a program with no blocks, which can only ever render silence.
+ */
+export declare const nothingToExecute: string;
+/**
+ * The soft-clipping overdrive stage: anti-parallel diodes across an op-amp's feedback
+ * resistor, on rails. This is what a Tube Screamer, an OD-1 and a Blues Breaker all
+ * are, and the pipeline had no fixture for it.
+ *
+ * It is also the shape that exposes an undamped op-amp. A diode limits its own Newton
+ * step; an op-amp at a gain of 1e5 did not, so the two fought and the iterate cycled
+ * rail to rail forever. Every simpler op-amp fixture here converges with or without
+ * that damping, including one clipping hard against its rails -- only the two
+ * nonlinearities in one loop show it.
+ */
+export declare const clippingOverdriveStage: string;
+/**
+ * The hybrid the pipeline has never had a case for: analog, then a macro, then analog.
+ *
+ * An input shell feeds the delay memory's `in`; its `out` feeds an output shell; and a
+ * separate RC clock network sits on `cp1`, which is what sets a bucket brigade's delay
+ * time. So three analog regions each share exactly one node with the macro, and none
+ * shares a node with another — the macro is the only thing between input and output.
+ *
+ * Three things this is the first case for, all of them written and none exercised:
+ *
+ *   - `partition.ts` computes `dependencies[macro] = analog regions sharing a node`, and
+ *     every case so far has produced `[]`.
+ *   - `MacroModel.portTerminals` is declared in the types and read nowhere.
+ *   - `Block`'s macro variant has no `inputNode`/`outputNode`, so audio cannot pass
+ *     through it. That is the defect this fixture exists to hold still: it compiles, the
+ *     macro is placed correctly, and the output region receives nothing.
+ *
+ * When the operator format lands, the acceptance criterion inverts and this renders.
+ */
+export declare const hybridDelayPedal: string;
+/**
+ * `hybridDelayPedal` with a control-bearing trim pot added across the clock network's own
+ * nodes -- the `parameter` port's negative control. `region.controls` is no longer empty for
+ * the clock region, so `couple.ts`'s purity gate must refuse to classify the derivation as
+ * `parameter`, per the spec's safe default (missing or negative evidence -> never `parameter`).
+ * The macro still compiles and still passes audio; only `parameter` on its block should differ.
+ */
+/**
+ * S1's delay-model controls: the same pedal with one thing changed each time.
+ *
+ * The BBD delay model is **capacity-based** -- the document's `DelayMs`, converted to samples at
+ * the host's rate, then scaled by the `parameter` port's voltage ratio. That decision is recorded
+ * in `thoughts/shared/plans/2026-08-25-v2-bbd-pipeline-readiness.md` §5, and these fixtures are
+ * what make it a behavioural fact rather than a note: each one moves exactly one input and the
+ * delay has to respond, or not, in the one way the model predicts.
+ *
+ * Every prediction below is hand-derived before measuring, not read off the output:
+ * 3 ms x 48 kHz = 144 samples; 6 ms = 288; a clock rail halved against an unchanged 9 V
+ * reference halves the scale to 72; and the resolver's stand-in is 50 ms = 2400.
+ */
+export declare const hybridDelayPedalLongerDelay: string;
+/**
+ * `hybridDelayPedal` with `R_OUT_LOAD` changed from 1meg to 10k.
+ *
+ * S2 negative control: the macro output has an internal 1k impedance and 10k series resistor.
+ * Dividing into a 10k load yields an output divider of 10k/(10k + 10k + 1k) = 10/21 (~0.4762),
+ * shifting total gain from ~0.4470 to ~0.2152, verifying that output loading is modeled.
+ */
+export declare const hybridDelayPedalLoadedOutput: string;
+/**
+ * The clock rail halved, 9 V to 4.5 V, against a `parameterReferenceVolts` still 9.
+ *
+ * This is the coupling the delay model *does* have, and naming it is the honest complement to
+ * the frequency-independence assertion: the `parameter` port reads the clock node's **voltage**
+ * and scales the capacity by `|volts| / referenceVolts`. Nothing reads a frequency anywhere.
+ * A real BBD's delay is `stages / (2 * f_clock)`, so this is a capacity model with a voltage
+ * trim, not a clock model -- which is exactly what §5 chose and what S6 revisits.
+ */
+export declare const hybridDelayPedalHalfClockRail: string;
+/**
+ * `DelayMs` removed while the `cp1` parameter terminal remains.
+ *
+ * The resolver substitutes a 50 ms stand-in rather than refusing, on the grounds that a part
+ * with a clock terminal has *somewhere* the delay could have come from. **This fixture exists to
+ * pin that number as a deliberate, visible choice rather than a silent one** -- it is the
+ * mechanism by which all four of the Deluxe Memory Man's MN3008 macros resolve to
+ * `delaySeconds: 0.05` while the document declares no delay at all, and it is BBD plan S1's
+ * open question: a stand-in the size of a real echo is indistinguishable from a modelled one.
+ */
+export declare const hybridDelayPedalNoDeclaredDelay: string;
+/**
+ * `DelayMs` removed *and* the `cp1` parameter terminal removed.
+ *
+ * With no declared delay and no clock terminal there is nothing left to derive a delay from, so
+ * the pipeline refuses by name. The pair with the fixture above is the whole point: the same
+ * missing property is a 50 ms stand-in or a refusal depending on one terminal, and a reader
+ * should be able to see which lever decides it.
+ */
+export declare const hybridDelayPedalNoDelayNoClock: string;
+/**
+ * A trim pot across the clock network's own nodes, so that region is no longer control-free.
+ *
+ * **"Movable" is about the purity gate, not about a derived clock.** This is the negative
+ * control for `couple.ts`'s parameter-port rule: with a control in the clock region the
+ * derivation may no longer be classified as `parameter`, and the port falls back to null while
+ * audio stays wired. It deliberately does *not* produce a `clockControl` -- its part is the
+ * synthetic `FIXTURE-DELAY-1`, with no clock driver to derive from, so its delay tap runs in
+ * `capacity` mode. Anyone scanning fixture names for clock coverage wants
+ * `bbdClockDerivedDelay` or `pt2399ClockDerivedDelay` instead.
+ */
+export declare const hybridDelayPedalMovableClock: string;
+/**
+ * `hybridDelayPedal` with a resistor joining the input shell's node (3, the macro's audio-in
+ * tap) directly to the output shell's node (2, downstream of the macro's audio-out write-back)
+ * -- the region SCHEDULE's coincident case. This merges what were two separate analog regions
+ * into one, so that ONE region is both the macro's driver and its downstream: an unbuffered
+ * dry-blend/regen network, exactly the topology all three real delay/BBD packets that clear
+ * device-law identification (`pt2399-delay`, `boss-ce-2`, `boss-ce-5`) actually wire.
+ *
+ * Refused by `link.ts`'s `topologicalOrder` from 2026-08-14's first landing of clause 3 through
+ * the same day's correction: a genuine 2-cycle (the region must run both before the macro, for
+ * audio-in, and after it, for the write-back) with both directions added unconditionally. Now
+ * resolved with a documented one-sample write-back lag in exactly this case -- see the
+ * "coincident case" comment in `couple.ts` for the mechanism -- so this fixture **compiles**,
+ * which is what changed; `hybridDelayPedalChainedMacroCycle` below is the fixture that still
+ * refuses.
+ */
+export declare const hybridDelayPedalCyclicSchedule: string;
+/**
+ * `hybridDelayPedal` with a SECOND macro, `U2`, chained the opposite way round: its audio-in
+ * sits on node 2 (U1's downstream region) and its audio-out sits on node 3 (U1's own driver
+ * region) -- a loop through two DISTINCT regions and two DISTINCT macros, not one macro whose
+ * own driver and downstream coincide. `couple.ts`'s coincident-case lag only applies when a
+ * single macro's driver and downstream are the SAME region (a direct check on that one macro's
+ * own edges); it does not and should not paper over a longer cycle chained through a second
+ * macro, so this must still refuse exactly as before -- the negative control the resolved
+ * `hybridDelayPedalCyclicSchedule` above can no longer serve now that it compiles.
+ */
+export declare const hybridDelayPedalChainedMacroCycle: string;
+export declare const potAntiLogarithmicTaper: string;
+export declare const potReverseLinearTaper: string;
+export declare const potLogarithmicTaper: string;
+export declare const potLinearTaper: string;
+/** A manufacturer's own curve. We do not know its shape, so it must not be guessed. */
+export declare const potUnknownTaperCode: string;
+/**
+ * The source recording that it does **not** state a taper, which is a complete statement rather
+ * than a marking this stage failed to read. 18 corpus declarations are this shape.
+ */
+export declare const potSourceUnmarkedTaper: string;
+/**
+ * A taper `@vessel-dsp/core`'s format carries and this runtime has no curve for. `TaperKind` has
+ * four laws; `PotentiometerTaper` has seven. Stating one of the other three is a real taper the
+ * render cannot produce, which is a different thing from an unreadable marking.
+ */
+export declare const potSteppedTaper: string;
+/** A pot wired as a two-terminal rheostat, which lowering cannot stamp. */
+export declare const rheostatPot: string;
+/**
+ * One control on two pots in different regions, which the partition invariant refuses.
+ * A dual-gang pot is the real circuit this shape comes from.
+ */
+export declare const straddlingControl: string;
+/**
+ * A mains inlet feeding a resistive divider, and the only fixture whose supply moves.
+ *
+ * Written in the shape the amp packets use: the voltage and the frequency are both structured
+ * `{raw, value, unit}` with prose in `raw`, so this exercises the reading a bare `"10"` would
+ * not. `hot`/`neutral` are the mains pair those packets declare.
+ *
+ * Hand-computable, and the numbers are chosen so the supply's own impedance is *visible* in the
+ * answer: `SUPPLY_SOURCE_OHMS` is 1, so the loop is `1 + 999 + 1000 = 2000` ohms and the
+ * midpoint sits at exactly half the EMF. A stamp that dropped `sourceOhms` would read
+ * `1000/1999` and be wrong in the fourth digit.
+ *
+ * The input jack is deliberately alone on node 1. This circuit has no signal path -- it is a
+ * supply -- and an input source stamped onto a divider node would force the voltage this
+ * fixture is measuring.
+ */
+export declare const acMainsDivider: string;
+/**
+ * The same document with **only the frequency removed**, which is the whole discriminator.
+ *
+ * The negative control for the AC source: one deleted property has to turn a sine into a
+ * battery, and nothing else about the document changes. A `derive` rather than a copy, so the
+ * two cannot drift apart silently.
+ */
+export declare const dcMainsDivider: string;
+/**
+ * A tube rectifier passing DC into a load, which makes its space-charge law hand-checkable.
+ *
+ * A 300 V rail through 100 ohms into the plate, cathode into 10k. At the solved point two
+ * independent equations must both hold — the load's `I = V(cathode)/10k` and the tube's
+ * `I = K * (V(plate) - V(cathode))^1.5` — so the fixed point of
+ * `I = K * (300 - 10101*I)^1.5` is the answer without trusting any solver: `I = 27.9 mA` at a
+ * `18.4 V` drop, leaving the cathode at `278.8 V`. (The 10101 is 10k of load plus 100 ohms of
+ * series resistance plus the rail's own 1 ohm.)
+ *
+ * DC rather than mains on purpose: it isolates the tube's law from the AC source and the
+ * reservoir, so a failure here is the law and nothing else.
+ */
+export declare const tubeDiodeIntoLoad: string;
+/**
+ * The same rectifier, with a declared-voltage port added on the cathode/load node.
+ *
+ * `BPLUS_PORT` states `280 V` on node 2 — a plausible nominal chart value, deliberately not the
+ * `278.8 V` the tube law and the 10k load actually solve to, so a promoted ideal source and a
+ * real rectifier answer are distinguishable by more than rounding. Before this milestone,
+ * `voltagePortRails` had no way to see that node 2 is already generated (a `tube-diode` did not
+ * count as DC-conducting), so it promoted this port to an ideal `280 V` rail, deleting
+ * `V1_RECT`/`RLOAD`/`RSERIES` from the answer entirely. The fix is exactly the claim under test:
+ * the solved cathode voltage must still be `278.8 V` from the tube law, not the declared `280 V`.
+ */
+export declare const tubeDiodeIntoLoadWithDeclaredPort: string;
+export declare const tubeDiodeReversed: string;
+/**
+ * The five-terminal dual rectifier the amp corpus actually declares: `plate_a`, `plate_b`, one
+ * `cathode_filament`, and two heaters that carry no signal.
+ *
+ * Both plates are fed from the same 300 V rail through their own 150 ohms, which is a stand-in
+ * for the centre-tapped secondary the real supplies use — this fixture is about how one component
+ * becomes two elements, not about the winding. The heater nodes are wired to nothing else, which
+ * is exactly how they appear in the packets.
+ */
+export declare const dualPlateTubeRectifier: string;
+/**
+ * A working divider plus a pot in its **own galvanic island**, which the emitted program
+ * therefore does not execute.
+ *
+ * Every earlier way of being a dead knob is deliberately excluded: `VR9`'s wiper is loaded by
+ * `R91` so it is not floating, and every one of the island's nodes is shared, so no device is
+ * joined to nothing. The pot is real, grounded through `R92`, and its coefficients move with
+ * the knob -- and its region owns neither jack, so nothing it computes can reach the output
+ * and `link` leaves it out of the execution order.
+ *
+ * The island touches the signal path only at ground, which is what makes it a separate region:
+ * stage 4 groups by shared *non-ground* node. Its prose says the opposite, as every fixture's
+ * does -- `MASTER_VOLUME`, `role: output-level`, a description calling it the output control --
+ * so a stage reading names would report the most important knob on the pedal.
+ */
+export declare const controlInUnexecutedRegion: string;
+/**
+ * The negative control for the fixture above: the same island, returned to the **output node**
+ * instead of to ground.
+ *
+ * One node changes, and with it the island stops being an island -- it joins the signal path's
+ * region, gets scheduled, and the knob really does load the output. Nothing else differs, so a
+ * warning that fires on both is reporting the pot rather than the schedule.
+ */
+export declare const controlInScheduledRegion: string;
+/**
+ * The same mains inlet drawing amps instead of milliamps, for the supply-current telemetry.
+ *
+ * `3 ohms` and `1 ohm` in place of the divider's kilohms, so with the supply's own ohm the loop is
+ * `5 ohms`. The declared `10 V` is read as RMS by the `ac-source` law's convention and converted
+ * to `10 * sqrt(2)` V peak, so the peak current is exactly `10 * sqrt(2) / 5 = 2.8284... A` — a
+ * draw three orders of magnitude past anything a pedal makes, and one the **operating point
+ * cannot see at all**, because it evaluates an AC source at its `t = 0` zero.
+ */
+export declare const acSupplyDrawingAmps: string;
+/**
+ * A bridge rectifier as one component, which is what four of the amp corpus's and two of the
+ * pedal corpus's diode components are: `[ac_a, ac_b, positive, negative]`.
+ *
+ * Resistive load and **no reservoir**, deliberately: the rail then follows the rectified sine
+ * instantaneously, so every sample is hand-computable with no settling to wait for. At the sine's
+ * peak the loop is `20 V = rail + two junction drops`, and with the class-default silicon junction
+ * (`IS = 2.52e-9`, `N = 1.752`) carrying `rail/1k`, that fixed point is `18.57 V`:
+ * `2 * 1.752 * 0.025852 * ln(0.01857/2.52e-9) = 1.43 V` of drop.
+ *
+ * The **negative** peak is the point of the fixture. A bridge rectifies both halves, so the rail
+ * must read the same there; the single junction this used to lower to gives a rail of nothing at
+ * both peaks, with the two DC terminals touching nothing at all.
+ */
+export declare const bridgeRectifier: string;
+/**
+ * The same bridge with its four terminals named as a three-pin clamp package, which is a shape
+ * the role table deliberately does not cover.
+ *
+ * The refusal control. Before the multi-junction reading, a diode component naming no `anode`
+ * fell through to declaration order and lowered to a junction between its **first two**
+ * terminals, whatever they were — so this compiled, rendered, and modelled a device the source
+ * does not contain. `pin1_`/`pin2_`/`pin3_` are stripped by the role folding exactly as stage 1
+ * strips them (`^pin\d+`, which also eats the leading `5` in `pin2_5a_clamp`), so the tokens
+ * this refuses on are `groundclamp`, `aclamp` and `signal` — checked against
+ * `electro-harmonix-holy-grail`'s real `D1`, the shape this fixture is transcribed from.
+ */
+export declare const clampPackageDiode: string;
+/**
+ * A dual rectifier sharing one cathode, declared under `kind: diode` with tube electrode names —
+ * the shape eight of the amp corpus's rectifiers use (`plate_a`, `plate_b`, `cathode`, plus two
+ * heaters that carry no signal).
+ *
+ * The same winding as the bridge above, wired the way a shared-cathode pack is: `plate_a` driven,
+ * `plate_b` at ground, cathode into the load. So it rectifies **one** half — at the positive peak
+ * the loop is `20 V = rail + one junction drop`, giving `19.28 V`, and at the negative peak the
+ * rail is nothing. That is the pair of numbers that tells this topology from the bridge's, which
+ * reads the same at both peaks.
+ *
+ * Two junctions, and **both keep the silicon law the declared kind asks for**. The lowering fixes
+ * the wiring; it does not read a vacuum device out of a terminal name.
+ */
+export declare const dualAnodeRectifier: string;
+/**
+ * A transformer with one primary and one untapped secondary, specified by winding voltages
+ * rather than by a `Ratio` or an impedance pair -- the "2-winding case". `PrimaryVoltage` (not
+ * `Primary`) is the spelling declared here, and as of 2026-08-14 nothing reads it: a winding
+ * specified this way is driven at its own stated voltage and no primary is modelled. It is
+ * left in the fixture deliberately, as the check that it is now inert.
+ *
+ * `MAINS` carries the frequency the driven winding runs at. A transformer does not change
+ * frequency, so a document with no AC supply in it states none and refuses.
+ */
+export declare const twoWindingVoltageDerivedTransformer: string;
+/**
+ * A transformer with one primary and one **centre-tapped** secondary, specified by a single
+ * per-half winding voltage and isolated from any other winding so the centre-tap arithmetic is
+ * the only thing under test. `Primary` (not `PrimaryVoltage`) is the spelling declared here,
+ * and like `twoWindingVoltageDerivedTransformer`'s it is now inert.
+ */
+export declare const centerTappedVoltageDerivedTransformer: string;
+/**
+ * A power transformer with three secondaries off one primary -- a centre-tapped HV winding
+ * plus two untapped windings -- shaped exactly like `fender-5e3-deluxe-tweed`'s
+ * `PT_5E3_POWER_TRANSFORMER` but with round numbers. Three windings at three different
+ * voltages off one core is what no single `Ratio` can express, and what the driven-winding
+ * lowering handles without needing a primary at all.
+ */
+export declare const powerTransformerVoltageDerived: string;
+/**
+ * A transformer whose typed winding voltages include one this stage does not recognise --
+ * `ScreenSecondary`, typed exactly like the recognised ones but under a spelling nothing
+ * reads -- alongside a `FilamentSecondary` that *is* recognised. The v2-transformer-ratio
+ * milestone's refusal case: this must refuse by name rather than silently deriving a ratio
+ * from the winding it does recognise and dropping the one it does not.
+ */
+export declare const transformerUnlistedWindingSpelling: string;
+/**
+ * A transformer with a **centre-tapped primary** (the ordinary push-pull output-transformer
+ * shape) and one untapped secondary, its ratio typed as an impedance pair -- the
+ * v2-transformer-primary-tap milestone's core case. `PrimaryImpedance`/`SecondaryImpedance` give
+ * `declaredRatio = sqrt(4000/10) = 20`; the shared-primary reduction has no single reference
+ * winding to pivot on (the primary itself is tapped), so it swaps to the untapped secondary and
+ * halves+inverts the ratio to `2/20 = 0.1` per half.
+ */
+export declare const tappedPrimaryOutputTransformer: string;
+/**
+ * Same tapped primary as `tappedPrimaryOutputTransformer`, plus an alternate impedance tap
+ * (`secondary_8`) that connects to nothing else in the document -- `vox-ac30-top-boost`'s exact
+ * shape, "8 Ω alternate source-visible tap" beside its typed, wired 16 ohm one. The
+ * v2-transformer-primary-tap milestone's dangling-tap case: this must compile with exactly the
+ * same two stamps as `tappedPrimaryOutputTransformer`, silently dropping the extra terminal
+ * rather than refusing or guessing a ratio for it.
+ */
+export declare const danglingAlternateTapTransformer: string;
+/**
+ * The negative control for `danglingAlternateTapTransformer`: the same alternate tap, but wired
+ * to a load like any other winding would be. Connectivity now says it is *not* dangling, so this
+ * must refuse by name rather than silently dropping a terminal that is actually in use.
+ */
+export declare const connectedAlternateTapTransformer: string;
+/**
+ * A tank-shaped shell whose part number is not a tank's, so it lowers as an ordinary transformer
+ * -- `fender-super-reverb`'s `SRC_REVERB_TANK_4AB3C1B` terminals with `125A9A` on the label.
+ *
+ * Its coils declare `drive`/`pickup`, which is what a tank's coils are: neither transforms the
+ * other's voltage. This is the fixture that proves `drive` is treated as the primary on the
+ * ordinary-transformer path, so a mislabelled tank still lowers instead of refusing for want of a
+ * winding called `primary`. `InputImpedance`/`OutputImpedance` remain property-side synonyms for
+ * `PrimaryImpedance`/`SecondaryImpedance` (`parametersFor` in `netlist.ts`).
+ */
+export declare const reverbTankInputOutputTransformer: string;
+/**
+ * `tappedPrimaryOutputTransformer` plus a **third** impedance tap, `secondary_4`, dangling
+ * (connected to nothing else) beside the wired reference winding -- the same shape
+ * `danglingAlternateTapTransformer` tests for `secondary_8`. Must compile to the identical two
+ * stamps as the base fixture -- no third stamp, no stamp touching node 5.
+ */
+export declare const danglingSecondary4Transformer: string;
+/**
+ * `connectedAlternateTapTransformer` (its `secondary_8` wired to a load) plus a **third** tap,
+ * `secondary_4`, dangling.
+ *
+ * The refusal must fire exactly as it does with no `secondary_4` present -- not be masked,
+ * changed, or made order-dependent by the extra tap. It used to prove that two alternate taps
+ * held separate winding groups and so could not overwrite one another's node; they are one coil's
+ * taps now, and the property that matters is that the connectivity test finds the loaded tap
+ * regardless of how many others the coil declares.
+ */
+export declare const distinctAlternateTapsTransformer: string;
+/**
+ * A tapped primary with no other complete, untapped winding to pivot the shared-primary
+ * reduction on -- only a shield beside it, which declares `role: shield` and belongs to no coil.
+ * The v2-transformer-primary-tap milestone's "no reference available" refusal case.
+ *
+ * States its ratio as a typed `TurnsRatio` rather than as an impedance pair, because a rating
+ * belongs to a coil and the secondary it would rate is exactly what this document does not
+ * declare. That is also what keeps the fixture reaching the refusal it is here for: a document
+ * stating no ratio at all refuses earlier, in `requireWindingSpecification`.
+ */
+export declare const tappedPrimaryNoReferenceTransformer: string;
+/**
+ * A divider whose midpoint (the output) is formed by a T-junction in the middle of a
+ * diagonal wire. `wireAxisAligned` is the same circuit with that wire redrawn horizontal,
+ * so the two must yield the same netlist up to node relabeling.
+ *
+ * The midpoint terminals sit on the segment, not at an endpoint, so they are visible only
+ * through the point-on-segment test. Before diagonal segments were recognised that test
+ * returned false for them, the midpoint was dropped as unconnected, and this document
+ * refused where its horizontal sibling compiled.
+ */
+export declare const wireDiagonal: string;
+/**
+ * `wireDiagonal` redrawn with the midpoint wire horizontal. The midpoint terminals still
+ * sit in the middle of the segment; only the segment's angle changes. The two must resolve
+ * to the same netlist up to node relabeling, which is the invariant the angle must not
+ * break.
+ */
+export declare const wireAxisAligned: string;
+/**
+ * NE570 compandor terminal-mapping contract.
+ *
+ * Sixteen bare-pin terminals in strict sequential `pin1`..`pin16` order, each on a
+ * distinct node (10–25). The part catalog binds section A to [rectIn=pin2,
+ * rectCap=pin1, cellIn=pin5/INV_IN, output=pin7] and section B to the channel-2
+ * pins. This fixture asserts that binding is stable: a catalogue edit that
+ * re-points any of the four section terminals fails here rather than surfacing
+ * as a silent audio defect months later.
+ */
+export declare const ne570TerminalMap: string;
+/**
+ * The datasheet's own expander, wired exactly as onsemi NE570/D Rev. 4 Figure 6 draws
+ * it, and the reason this fixture exists rather than a bare transconductance probe: the
+ * datasheet states a closed form for this circuit's gain, so the reference is external
+ * to our code rather than a number read off our own output.
+ *
+ *   GAIN = 2 * R3 * VIN(avg) / (R1 * R2 * IB)
+ *
+ * The input drives the rectifier (pin 2) and the gain cell (pin 3) through separate
+ * coupling caps; pin 6 is tied to pin 7, which is what makes the internal 20k R3 the
+ * op-amp's feedback resistor. Both couplings are 1 uF into 10k/20k, corners at 16 Hz and
+ * 8 Hz, so at the 1 kHz test tone they pass unity and the gain is the chip's alone.
+ *
+ * Two independent numbers fall out of this one circuit, which is what makes it a
+ * settlement rather than a smoke test: the AC gain above, and a quiescent output of
+ * `(1 + R3/R4) * VREF` = 3.0 V that the datasheet also states outright. The DC figure
+ * pins down the topology -- it only comes out at 3.0 V with R4 returned to ground -- and
+ * the AC figure pins down the gain cell's scaling. See `ne570ExpanderGainAt`.
+ *
+ * CRECT is 2.2 uF as in the datasheet's own test circuit (Figure 3), giving the detector
+ * `tau = R5 * CRECT` = 22 ms. That is a real external component, not a constant: the
+ * negative control halves it and expects the attack to track.
+ */
+export declare const ne570Expander: string;
+/**
+ * The datasheet's compressor: onsemi NE570/D Rev. 4's own sentence, "a compressor is essentially
+ * an expander placed in the feedback loop of the op amp", applied to `ne570Expander` and nothing
+ * else. It is four derivations off that fixture, so the two provably differ only in the wiring
+ * under test, and the same gain cell, the same internal resistors and the same reference serve
+ * both.
+ *
+ * The three moves, and each is that sentence read literally:
+ *
+ *   - the rectifier (pin 2) and the gain cell (pin 3) are driven from the **output** rather than
+ *     from the input, which is what "in the feedback loop" means for this chip;
+ *   - the signal enters at the **R3 pin** (pin 6), which the expander had tied to pin 7, and
+ *     reaches the summing node through the internal 20k;
+ *   - an external leg closes the op amp's DC loop, per `ne570CompressorInput` above.
+ *
+ * `mxr-carbon-copy`'s own traced schematic is an independent instance of the same topology --
+ * R31 into pin 6, C24 from pin 7 back to pins 2 and 3, R34+R33 from pin 5 to pin 7 -- which is
+ * why this is a reading of the datasheet rather than an invention: two sources drawn by
+ * different people agree on it.
+ *
+ * **What this fixture is for.** The expander pins the gain cell's *magnitude* against a stated
+ * closed form, and pins nothing about its *direction*: the cell carries no current at DC, so the
+ * stated 3.0 V quiescent cannot see the sign, and the gain formula is a magnitude. Direction only
+ * becomes observable when the cell sits inside the loop, because then it either adds to the
+ * feedback conductance or subtracts from it. So this is the two-sided control the compandor
+ * rebuild never had:
+ *
+ *   - a compressor's gain must **fall** as its input level rises, and stay bounded;
+ *   - `ne570Expander`'s gain must still **rise**, which is what stops a sign flip being a free fix.
+ */
+export declare const ne570Compressor: string;
+/**
+ * The same expander with a tenth of the averaging capacitance.
+ *
+ * The negative control that proves CRECT is load-bearing. Before this rewrite the
+ * detector integrated a private state variable against a hard-coded 50 ms and never read
+ * the CRECT node at all, so this fixture and its parent rendered identically -- the
+ * external component the chip devotes a pin to did nothing. `tau = R5 * CRECT` drops from
+ * 22 ms to 2.2 ms here, which must show up as a faster attack.
+ */
+export declare const ne570ExpanderFastDetector: string;
+/**
+ * CD4047 bare-pin position-resolution contract.
+ *
+ * Fourteen terminals: `pin1`..`pin13` are bare (no role suffix) and `pin14_vdd`
+ * carries the only role token. The part catalog's pinout is `[null × 13, "vdd"]`,
+ * so position 13 must fold to `vdd` and the remaining thirteen positions accept
+ * any (null) token. This fixture asserts that a bare-pin CD4047 still compiles
+ * and that the clock-driver section resolves its five terminals by position:
+ * cp1=pin10(9), cp2=pin11(10), vgg=pin13(12), vdd=pin14(13), ox1=pin3(2).
+ */
+export declare const cd4047BarePinMap: string;
+/**
+ * A spring reverb tank alone: input jack straight into the drive coil, pickup into the output
+ * jack across a load.
+ *
+ * Deliberately nothing else. A tank inside a real amp is buried behind a driver stage, a
+ * recovery stage and a mix control, so a level measured there cannot say whether the *tank*
+ * reverberates. Here the only thing between the jacks is the tank.
+ *
+ * `PartNumber` is the whole of the classification evidence: the shell declares itself a
+ * `Circuit.Transformer`, exactly as the corpus packets do, and only the exact part id
+ * distinguishes a tank from the output transformer sitting next to it.
+ */
+export declare const springReverbTank: string;
+/**
+ * A variable attenuator using an optocoupler / Vactrol (VTL5C1).
+ *
+ * Series resistor R1=10k, shunt element is the LDR of the optocoupler to ground.
+ * VLED drives the LED anode with respect to ground.
+ *
+ * - When VLED = 0 V (dark): LDR resistance is ~10 MΩ (ldrMaxOhms), so attenuation is 10M / (10k + 10M) ~ 0.999 V/V.
+ * - When VLED = 2 V (illuminated): LED conducts forward current, LDR drops to ~100 Ω (ldrMinOhms), attenuation is 100 / (10k + 100) ~ 0.0099 V/V (-40 dB).
+ * - When VLED = 0.5 V (sub-threshold): LED remains non-conducting, LDR remains dark at ~10 MΩ.
+ */
+export declare const optocouplerAttenuator: string;
+export declare const optocouplerAttenuatorIlluminated: string;
+export declare const optocouplerAttenuatorSubThreshold: string;
+/**
+ * The LED biased into the middle of the LDR's range, at 1.14 V.
+ *
+ * **The control the two extremes cannot supply.** Dark and illuminated both agree with a model
+ * that is a two-state switch, and the sub-threshold fixture agrees with one whose LED does
+ * nothing at all -- all three read as one of the two endpoints. Only a bias that lands *between*
+ * them shows the LDR curve is continuous and actually traversed.
+ *
+ * Measured sweep across the knee, 0.1 V drive at 1 kHz: 1.00 V -> 0.9984, 1.05 -> 0.9964,
+ * 1.10 -> 0.9722, 1.12 -> 0.8865, **1.14 -> 0.4936**, 1.16 -> 0.0621, 1.18 -> 0.0112,
+ * 1.20 -> 0.0099 (floored). The assertion deliberately checks the *property* -- strictly between
+ * the endpoints -- rather than pinning 0.4936, because this is the steepest point on a steep
+ * curve and a brittle number here would fail for changes that are not defects.
+ *
+ * **A fidelity note the endpoints hide.** That whole traversal happens in an 80 mV window
+ * (1.10 V to 1.18 V). A real Vactrol's LDR responds gradually over *decades* of LED current --
+ * the slow, smooth knee is the part's musical character, and what an optocoupler tremolo or
+ * compressor is chosen for. So "the optocoupler operator is settled" means its endpoints and its
+ * continuity are pinned, **not** that the Vactrol's response shape is modelled; that lives in
+ * `ledTransconductance` and the LDR exponent's scaling and is not settled by these fixtures.
+ */
+export declare const optocouplerAttenuatorPartial: string;
+export declare const mn3007RoleMap: string;
+/**
+ * MN3007 bare-pin position-resolution contract.
+ *
+ * Eight terminals named `pin1`..`pin8` with NO role suffixes.
+ * Asserts that bare-pin DIP-8 positions resolve identically to the role-mapped
+ * IC: clk1=pin2(node 11), clk2=pin6(node 15), in=pin3(node 12),
+ * out1=pin7(node 16), out2=pin8(node 17).
+ */
+export declare const mn3007BarePinMap: string;
+/**
+ * MN3207 role-based terminal-resolution contract.
+ */
+export declare const mn3207RoleMap: string;
+/**
+ * MN3207 bare-pin position-resolution contract.
+ *
+ * Physical 8-pin DIP pinout per Panasonic datasheet and Boss VB-2 IC2:
+ * Pin 1 (VGG) = node 13
+ * Pin 2 (CP1) = node 11
+ * Pin 3 (CP2) = node 15
+ * Pin 4 (GND) = node 0
+ * Pin 5 (OUT1) = node 16
+ * Pin 6 (OUT2) = node 17
+ * Pin 7 (VDD) = node 14
+ * Pin 8 (IN) = node 12
+ */
+export declare const mn3207BarePinMap: string;
+/**
+ * Four bucket-brigade delay lines chained in series (S4).
+ *
+ * Models a multi-BBD cascade such as the SAD1024A 4-stage delay in the EH-7550 Deluxe Memory Man.
+ * Each BBD declares DelayMs: 3 (144 samples at 48 kHz).
+ * Total cascade delay across 4 stages = 4 * 3 ms = 12 ms (576 samples at 48 kHz).
+ */
+export declare const hybridCascade4DelayPedal: string;
+/**
+ * 4-BBD cascade with heterogeneous delays: U1=3ms, U2=6ms, U3=3ms, U4=3ms.
+ * Total cascade delay = 3 + 6 + 3 + 3 = 15 ms (720 samples at 48 kHz).
+ */
+export declare const hybridCascade4DelayPedalUnequalDelays: string;
+/**
+ * 3-BBD cascade: 3 stages of 3 ms each.
+ * Total cascade delay = 3 * 3 ms = 9 ms (432 samples at 48 kHz).
+ */
+export declare const hybridCascade3DelayPedal: string;
+/**
+ * `hybridDelayPedal` with a schematic feedback resistor `R_FB` (10k) from BBD output (node 4)
+ * back to BBD input (node 3) (S5).
+ *
+ * An impulse at t=0 produces repeating, geometrically decaying echoes spaced at 3 ms
+ * (144 samples at 48 kHz): t = 144, 288, 432, 576, ...
+ */
+export declare const hybridFeedbackDelayPedal: string;
+/**
+ * `hybridFeedbackDelayPedal` with higher feedback resistance (30k) -> lower loop gain (S5).
+ * Echoes decay faster than the 10k baseline.
+ */
+export declare const hybridFeedbackDelayPedalLowFeedback: string;
+/**
+ * `hybridFeedbackDelayPedal` with lower feedback resistance (4.7k) -> higher loop gain (S5).
+ * Echoes decay slower than the 10k baseline.
+ */
+export declare const hybridFeedbackDelayPedalHighFeedback: string;
+/**
+ * Active feedback delay fixture with op-amp gain in the feedback loop making loop gain > 1 (S5).
+ * Demonstrates sustained/diverging echoes when loop gain exceeds unity.
+ */
+export declare const hybridFeedbackDelayPedalUnstableLoop: string;
+/**
+ * A tapped secondary loaded at **both** taps, with nothing in it ngspice cannot express.
+ *
+ * `orange-rockerverb`'s output transformer is the corpus shape -- a 16 Ω jack and an 8 Ω jack each
+ * with its own feedback resistor -- and that packet cannot be graded against ngspice, because a
+ * spring reverb tank is a DSP operator with no circuit-level deck (5 of the 24 corpus amps are
+ * excluded for the same reason). This is the claim on its own: two loaded taps are two coupled
+ * windings, each at the turns ratio its own rating gives.
+ *
+ * Checked once against ngspice through the parity report's `--source=` mode: `agrees`,
+ * corr 1.0000, gain 1.000, with that report's `--self-check` confirming a corrupted deck
+ * disagrees and its 2% gain gate refuses a 3% level error. Both decks there are emitted from the
+ * program, so that bounds the *solve*, not the stamps -- which is what the ratio assertions below
+ * are for.
+ */
+export declare const twoLiveSecondaryTaps: string;
+/**
+ * A speaker jack one impedance-selector hop from the output transformer, which is where a real
+ * amp puts it.
+ *
+ * `orange-gro100` is the corpus case and was the only one in 142 documents: `J_SPEAKER` on node 79
+ * with `S_SPEAKER_IMPEDANCE` joining it to the winding's 76/77/78 taps. `resolvePorts`'s "after
+ * the transformer" test required the jack to be *on* a winding node, so it missed, and the output
+ * port fell through to a jack whose own `SourceBoundaryRole` reads "tone-stack output-amp handoff
+ * label". The amp rendered its tone stack -- 3 V of preamp node in place of 35 V of speaker swing,
+ * with no transformer bounding it, so the file clipped 10,991 samples of 96,000.
+ */
+export declare const speakerBehindSelector: string;
+/**
+ * A three-terminal 5 V regulator whose pins are named `pin1`/`pin2`/`pin3` and whose *roles* say
+ * which is the output and which the reference — the shape `moogerfooger-mf-102`'s `U13` has.
+ *
+ * The registry's 78Lxx entry lists `pin2` among its ground aliases and `pin3` among its output
+ * aliases, so a reader that goes by the names puts the reference on the rail here. This fixture
+ * declares the opposite, which is the only evidence that settles it.
+ */
+export declare const declaredRegulator: string;
+/** The same regulator with its electrode roles removed, so only the entry's pin naming is left. */
+export declare const undeclaredRegulator: string;
+/**
+ * `invertingAmplifier` with the op-amp **packaged as an eight-pin chip**, expanded by
+ * `sectionsRegistry`.
+ *
+ * Deliberately the same circuit, so the only variable is how the op-amp arrives. A discrete
+ * `kind: opamp` states its own three terminals by role; this one states eight numbered pins and
+ * a part number, and the registry says which three of them are the section and in what order.
+ * That is the path most of the corpus's registry-expanded devices take, and nothing graded it
+ * against a second solver before: if this row disagrees while `inverting-amplifier` agrees, the
+ * defect is in expansion rather than in the op-amp law.
+ *
+ * Pins 4-8 are in no section and connect to nothing, which is the ordinary shape of a real
+ * package -- supply pins and a second half nobody used. They must contribute nothing.
+ */
+export declare const packagedOpamp: string;
+/**
+ * An OTA on an eight-pin chip, driving a load resistor.
+ *
+ * `ota` is five corpus packets and had no fixture at all, because every real OTA arrives inside
+ * an `ic` and an `ic` was refused whole. Output current is `gm` times the input difference, so
+ * the stage's gain is `gm * Rload` -- 1 mS into 10k, a gain of ten -- which is a number the deck
+ * and the program must both produce from the same declaration rather than a shape either could
+ * fake.
+ *
+ * Three mapped pins and no fourth means no amplifier-bias terminal, which is the linear OTA.
+ */
+export declare const packagedOta: string;
+/**
+ * The four-terminal nonlinear OTA on an eight-pin chip.
+ *
+ * `ota` is five corpus packets -- the phaser and chorus OTAs -- and had no fixture, because
+ * every real one arrives inside an `ic`. The linear `packagedOta` reaches `vccs`, which is
+ * a different stamp: a fourth mapped terminal is an amplifier-bias pin, and its presence is what
+ * selects the compressive `2 * Iabc * tanh(vDiff / 2Vt)` law over the linear fallback.
+ *
+ * The input is divided down to about 20 mV before the OTA sees it, on purpose. The parity
+ * harness drives every fixture at 0.1 V, and `tanh(0.1 / 2Vt)` is 0.96 -- pinned against the
+ * compression knee, where the row would grade almost nothing but the saturation limit. At 20 mV
+ * the stage runs about 5% compressed: nonlinear enough that a linear model fails the row, gentle
+ * enough that the verdict is about the law rather than about clipping.
+ *
+ * `RBIAS` from the 9 V rail sets `Iabc` near 0.47 mA. That number is the output's scale, so a
+ * bias pin mapped to the wrong node changes the gain instead of changing nothing.
+ */
+export declare const packagedNonlinearOta: string;
+/**
+ * A CMOS transmission gate whose own signal drives its control pin.
+ *
+ * `analog-switch` is two corpus packets and had no fixture. The law is a smooth sigmoid on the
+ * control voltage, not a hard throw, so it has a curve worth grading -- but only if the control
+ * actually moves. Tying the gate to a DC bias would leave the conductance constant and reduce
+ * the row to a resistor divider that happens to be computed through an exponential.
+ *
+ * So the gate is driven by the signal it passes, with the threshold at 0 V. The conductance then
+ * swings across the sigmoid every cycle -- about 1/171 ohm at the positive peak against 1/465 at
+ * the negative one -- and the stage distorts asymmetrically. That asymmetry is the law; a linear
+ * on-resistance would not produce it.
+ */
+export declare const packagedAnalogSwitch: string;
+/**
+ * An open-collector comparator with a pull-up.
+ *
+ * `comparator` is one corpus packet. The law is `gOn / (1 + exp(k * vDiff)) + gOff` between the
+ * output and `vee`, so the output is pulled down or left to float up through `RPULLUP`. Three
+ * mapped terminals leaves `vee` at ground.
+ *
+ * At sensitivity 50 and this harness's 0.1 V drive the output traverses roughly 0.09 V to 5.4 V
+ * as a smooth curve rather than a switching edge -- deliberate, because an edge's *timing* is
+ * resolved differently by a fixed-step runtime and an adaptive-step ngspice, and a row that
+ * disagreed about that would be reporting the integrator rather than the comparator.
+ */
+export declare const packagedComparator: string;
+/**
+ * An optocoupler as a modulated optical attenuator, which is what the corpus uses them for.
+ *
+ * `optocoupler` is four corpus packets -- the Fender tremolos -- and it is a **stamp in the
+ * matrix**, not a lifted macro, which is the whole reason it can be referenced against ngspice
+ * where a BBD cannot. The LDR shunts the signal to ground and its resistance falls exponentially
+ * with LED current, so the LED is driven from the signal as well as from a bias, and the shunt
+ * therefore moves with the signal: the row grades the coupling *curve* rather than one point on
+ * it, which is what gives the harmonic check something to measure.
+ *
+ * **`RLED` is 2k7 because of a measurement, and the first value was wrong twice over.** At 8k2
+ * the bias node sat near 0.98 V, which cleared the LED knee only while that knee was at the
+ * uncorrected 1.036 V; once the emitter was corrected to the cited `LED-RED` entry the LDR
+ * pinned fully dark and the row silently stopped grading any curve at all -- `agrees` at
+ * correlation 1.0000 with h2 and h3 at 1e-9. Re-biasing to 2k7 puts the reference's distortion
+ * at 0.86%, well clear of the shape check's floor, and its `h3Delta` at 0.0001. Values that put
+ * the distortion just above the floor instead (8k2/2k2 reads 0.18%) measure mostly their own
+ * noise and report deltas up to 0.05.
+ *
+ * **What this row cannot grade**, and it is worth knowing before reading a green verdict: the
+ * LED's own law is three constants hardcoded in the stamp -- a 50 mV ideality, `Is = 1e-12`, and
+ * a coupling `alpha` of 1000 -- which the source has no way to state, so the deck can only
+ * restate them. What the row does grade independently is the pin mapping, the LDR span, and the
+ * shape of the exponential coupling.
+ */
+export declare const packagedOptocoupler: string;
+/**
+ * A VTL5C2 optocoupler, resolved through `pedalPartCatalog` (not the mock `sectionsRegistry`
+ * every other resident in this file uses) so this pins the actual production catalog entry, not a
+ * fixture-only copy of it.
+ *
+ * **What it is for.** `runoffgroove-tremulus-lune`'s VTL5C2 sat in the generic optocoupler bucket
+ * (`ldrMinOhms=100, ldrMaxOhms=10_000_000`, the module-wide `exp(-1000*amps)` coupling) until
+ * 2026-09-15: that law put a genuinely-lit LED (0.567 mA, confirmed against an independent ngspice
+ * diode solve) 56.7% of the way to its dark ceiling, because the generic bucket's bounds are
+ * placeholders and VTL5C2's own datasheet -- cited in the packet's own
+ * `SelectedLaneLedCurrentToResistanceLaw` property (R@1mA=5.5k, R@10mA=800, R@40mA=200,
+ * dark>=1M) -- was never fit to a law at all. `part-catalog.ts`'s dedicated VTL5C2 entry carries
+ * that fit now (`ldrPowerLawCoefficientOhms`/`ldrPowerLawExponent`); this fixture is what keeps it
+ * pinned, since nothing else in this suite exercises it.
+ *
+ * **Bias.** `R_LED` (7k2 from the 9 V rail) puts the LED within a few percent of the datasheet's
+ * 1 mA anchor -- close enough that a regression in the fit or an accidental fallback to the generic
+ * exponential moves the verdict, not so exact that the fixture is fragile to the diode law's own
+ * rounding. `RLOAD` (10k from output to ground) turns the LDR into a divider so its resistance is
+ * what decides the gain, rather than leaving `ldrA`/`ldrB` floating in series with nothing to load
+ * against.
+ *
+ * **What this proves and what it cannot** -- same limit `emitOptocoupler`'s own comment states for
+ * every optocoupler resident: the from-source deck's LDR side is a `B`-source that *restates* the
+ * runtime's own formula (now the power law, when the device carries one) rather than deriving it
+ * independently, so ngspice cannot catch an error shared between the restatement and the runtime.
+ * What it grades independently is the pin mapping, the part-specific `ldrMinOhms`/`ldrMaxOhms`
+ * clamp, and -- because `source-to-spice.ts` reads the law fields off the same compiled program,
+ * not off a second constant -- that the compiled program actually carries the VTL5C2-specific
+ * fields rather than silently falling back to the generic law for this part.
+ */
+export declare const packagedOptocouplerVtl5c2: string;
+/**
+ * A Belton BTDR-2H reverb brick in the smallest analog shell that can carry it.
+ *
+ * **Why this fixture exists.** `digital-reverb-module` was the one device law in the corpus with
+ * no behavioural gate anywhere: no parity fixture -- correctly, since it is an `ic` macro the
+ * runtime executes as DSP and ngspice has no circuit to compare -- and no test either. Worse, the
+ * runtime's own `reverbCombGain` comment claimed "`belton-brick-reverb`'s measured T60 is checked
+ * against the datasheet's 2.5 s", and nothing checked it. One packet in the corpus reaches this
+ * law, so a change to the macro scheduler, the tap, or the output source could quietly silence
+ * every reverb in the product and no gate here would have said a word.
+ *
+ * **The shell is deliberately trivial**, because the brick is what is under test. Input divides
+ * 2:1 into the module's `pin3_input` through `10k`/`10k` (its datasheet Z_in is 10k, so this is
+ * the impedance the part expects); `pin6_output_1` drives a `10k` load through the registry's
+ * stated 220R output impedance; `pin5_output_2` is terminated so the second output is not a
+ * dangling active terminal. The `5 V` rail is the module's own supply. No op-amps, because an
+ * op-amp's own operating point would be a second thing to explain when a level moves.
+ *
+ * Node 1 is the input and node 2 the output, which is what the shared `jacks` helper already
+ * declares -- so the module's output pin *is* the output port and nothing sits between them but
+ * the load.
+ */
+export declare const beltonBrickReverb: string;
+/**
+ * A CD4013 dual D flip-flop wired as a clock divider, lifted out of `pipeline.test.ts`.
+ *
+ * **Why it moved.** This was the only fixture in the repository reaching a device law that no
+ * exported fixture reached: `logic-divider`. It lived as an inline template literal inside its
+ * own test, and `report:fixture-parity --corpus` -- which indexes `circuits.ts` and nothing else
+ * -- therefore reported "no fixture compiles to it under any known registry" about a law with a
+ * working test. Seventeen fixtures were written inline that way; measured, this was the one whose
+ * absence from here made a coverage report state a falsehood, which is why it is the one that
+ * moved rather than all of them.
+ *
+ * The document is unchanged: its test still compiles it under `pedalPartCatalog` and asserts the
+ * same things, and this file is now the complete set of laws the fixtures can reach.
+ */
+export declare const cd4013LogicDivider = "schema: circuit-interchange/v3\ndeviceInterface:\n  controls:\n    - id: INPUT_JACK\n      label: \"Input Jack\"\n      kind: jack\n      role: \"input\"\n    - id: OUTPUT_JACK\n      label: \"Output Jack\"\n      kind: jack\n      role: \"output\"\ncomponents:\n  - id: INPUT_JACK\n    kind: jack\n    name: \"INPUT_JACK\"\n    sourceTypeName: \"Circuit.Jack\"\n    origin:\n      x: -480\n      y: 0\n    rotation: 0\n    flipped: false\n    terminals:\n      - name: tip\n        node: 1\n        position:\n          x: 0\n          y: 0\n      - name: sleeve\n        node: 0\n        position:\n          x: 0\n          y: 0\n  - id: OUTPUT_JACK\n    kind: jack\n    name: \"OUTPUT_JACK\"\n    sourceTypeName: \"Circuit.Jack\"\n    origin:\n      x: 480\n      y: 0\n    rotation: 0\n    flipped: false\n    terminals:\n      - name: tip\n        node: 2\n        position:\n          x: 0\n          y: 0\n      - name: sleeve\n        node: 0\n        position:\n          x: 0\n          y: 0\n  - id: FLIP_FLOP\n    kind: ic\n    name: \"FLIP_FLOP\"\n    sourceTypeName: \"Circuit.IC\"\n    origin:\n      x: 0\n      y: 0\n    rotation: 0\n    flipped: false\n    properties:\n      PartNumber: \"CD4013\"\n    terminals:\n      - name: 1q\n        node: 2\n        position:\n          x: 0\n          y: 0\n      - name: 1q_bar\n        node: 0\n        position:\n          x: 0\n          y: 0\n      - name: 1clock\n        node: 1\n        position:\n          x: 0\n          y: 0\n      - name: 1reset\n        node: 0\n        position:\n          x: 0\n          y: 0\n      - name: 1data\n        node: 0\n        position:\n          x: 0\n          y: 0\n      - name: 1set\n        node: 0\n        position:\n          x: 0\n          y: 0\n      - name: gnd\n        node: 0\n        position:\n          x: 0\n          y: 0\n      - name: 2set\n        node: 0\n        position:\n          x: 0\n          y: 0\n      - name: 2reset\n        node: 0\n        position:\n          x: 0\n          y: 0\n      - name: 2data\n        node: 0\n        position:\n          x: 0\n          y: 0\n      - name: 2clock\n        node: 0\n        position:\n          x: 0\n          y: 0\n      - name: 2q_bar\n        node: 0\n        position:\n          x: 0\n          y: 0\n      - name: 2q\n        node: 0\n        position:\n          x: 0\n          y: 0\n      - name: vDD\n        node: 0\n        position:\n          x: 0\n          y: 0\n";
+/**
+ * An MN3101 BBD clock generator with its oscillator pin biased, and the first fixture in this
+ * repository to reach the `clock-driver` law at all.
+ *
+ * **Why it did not exist.** `report:fixture-parity --scoreboard` reads one row per corpus device
+ * law and says what pins it. On 2026-09-07 exactly one law read `UNGATED: no fixture at all`:
+ * `clock-driver`, needed by 7 corpus packets. Every mention of it in the test tree was about its
+ * *absence* -- `non-executable-clock-driver`, `no-clock-driver`, and one adversarial-prose test
+ * that requires a divider to render identically despite naming a clock driver in its text. The
+ * law owns three stamped outputs and a sampled oscillator and nothing rendered it.
+ *
+ * **The wiring is the stamp's convention, not a real pedal's, and that is a finding rather than a
+ * shortcut.** `part-catalog.ts` states the polarity plainly: the MN3101 runs on a single negative
+ * supply, so a +9 V pedal ties the part's GND pin to +9 V and its VDD pin to circuit ground. The
+ * runtime stamp instead treats `vdd` as the high rail and skips the coupling entirely when that
+ * node *is* ground, so a correctly-wired pedal renders CP1, CP2 and VGG all pinned at zero -- and
+ * two corpus packets, `boss-ch-1` and `boss-dm-3`, resolve `vdd` to node 0 and do exactly that.
+ * See `docs/troubleshootings/a-correctly-wired-bbd-clock-driver-outputs-nothing.md`.
+ *
+ * This fixture therefore wires VDD to the +9 V rail, which is what the stamp as written needs in
+ * order to oscillate. It pins the law's designed behaviour so the polarity can be corrected
+ * against something; pinning first is the whole argument for the scoreboard that found it.
+ *
+ * OX1 sits on a `6k5`/`2k5` divider off 9 V, which is 2.5000 V exactly and therefore `fScale`
+ * of 1, so the rendered rate is the declared `defaultFrequency` with nothing to subtract.
+ */
+export declare const mn3101ClockDriver: string;
+/**
+ * The same clock driver with one divider leg changed, and nothing else.
+ *
+ * `4k`/`5k` off 9 V is 5.0000 V exactly, so `fScale` is 2 and the rendered rate must be twice the
+ * declared frequency. Without a second bias the OX1 coupling is unpinned: at 2.5 V the scale
+ * factor is 1, so a runtime that ignored the oscillator pin and hardcoded `fScale = 1` would
+ * satisfy every assertion the fixture above can make. The BBD's delay time is derived from this
+ * rate, so "the clock is a constant" and "the clock follows its control pin" are exactly the two
+ * possibilities that need separating.
+ */
+export declare const mn3101ClockDriverFastOscillator: string;
+/**
+ * **Synthetic dry wire -- positive control for `detectDryWire` (report-input-dependence.ts:1002).**
+ *
+ * The corpus lost its dry-wire packet on 2026-09-15 when tremulus-lune was cured by the
+ * optocoupler LDR fix, so *every* dry-wire row in the report now asserts `false` and the
+ * detector can never prove it FIRES. This synthetic restores the positive control in the
+ * compiler-lane fixtures: one bypass-switch position carries the input near-unity (inside the
+ * detector's 2 % passthrough bar) and the other position is dead (below the detector's
+ * -60 dBFS floor, full scale * 1e-3). A prose reader is told it is a working spring-reverb
+ * tank; the *structure* is what the detector must flag, never the prose.
+ *
+ * **The first build of this fixture was wrong and never fired -- worth recording why, since the
+ * mistake is the instructive part.** `SW1` bridged input to *ground*, not to the output probe, so
+ * bypassing it collapsed the whole source to ~0 V instead of passing it through, and a fixed
+ * R1/R2 divider sat in the signal path in *both* switch positions, so neither position was ever
+ * unity: measured `-20.8 dB` (bypass) and `0.09x` (tank), never near-unity and dead. A divider is
+ * not a wire. The fix moves the switch itself onto the input/output path (`a: node 1`,
+ * `b: node 2`) so closing it *is* the wire, and removes the always-present divider from the live
+ * path entirely.
+ *
+ * `detectDryWire`'s own `measure()` drives through `ReferenceRuntime.prepare(SAMPLE_RATE)` with
+ * no `inputSourceOhms` option, so the input source is ideal (0 ohm) here -- **not** the ~10 kOhm
+ * guitar-ish default `render:v2`'s CLI applies to its own stimulus. That matters for R2 below: an
+ * ideal source means R2 barely attenuates the closed-switch reading (it only divides against the
+ * switch's own ~0.01 ohm on-resistance), so a small, unremarkable termination value is safe to
+ * leave in the live path on both sides of the switch.
+ *
+ * - **`SW1`**: `a` on the input node, `b` on the output-probe node. Bypassed (on-resistance) is a
+ *   near-direct wire; tank (off-resistance, ~1e9 ohm) is effectively open.
+ * - **`R2`**: output probe node to ground, 1 kOhm. Always present. With an ideal source this costs
+ *   the bypassed reading nothing (1 kOhm >> the switch's ~0.01 ohm on-resistance), and in the tank
+ *   position it is the dominant path to ground against the switch's ~1e9 ohm off-resistance, which
+ *   is what pins the dead reading far below the floor rather than leaving the output node to a bare
+ *   gmin (1e12 ohm) shunt -- gmin alone against a 1e9 ohm off-switch would leak ~99.9 % of the input
+ *   through, not read dead at all.
+ * - **`R1`**: input node to output-probe node, in parallel with the switch, always present at a
+ *   deliberately huge value (100 Mohm) so it changes neither reading by more than a part in 1e5 --
+ *   present only so the mutation control below has one property to change.
+ */
+export declare const syntheticDryWire: string;
+/**
+ * **Mutation control for the synthetic dry wire.**
+ *
+ * The same fixture with the dead arm made alive: R1's 100 Mohm leakage bridge (negligible in
+ * both switch positions) is replaced by a 1 kOhm live arm, so it now competes evenly with R2
+ * even when SW1 is open -- both switch positions read roughly half the input, neither dead nor
+ * near-unity. `detectDryWire` must NOT fire here -- if it fired, it would be firing because a
+ * bypass switch exists, not because a wire is dry. This is the negative control that proves the
+ * positive control fires for the right reason.
+ *
+ * `derive()`, not a bare `.replace()`: the first build of this control used `.replace()` against
+ * a `"1M"` target the base fixture had already stopped declaring, so the replacement silently
+ * matched nothing and the control was comparing the base fixture against an unmodified copy of
+ * itself the entire time. `derive()` throws instead of returning a silent no-op.
+ */
+export declare const syntheticDryWireMutation: string;
+/**
+ * An `stages`-section RC low-pass ladder: series 10k from each node to the next, 10n shunt to
+ * ground at every interior node, input on node 1, output on node 2.
+ *
+ * **It exists to be BIG, which no other fixture here is.** A block only takes the runtime's
+ * static sparse schedule when the predicted saving clears `SCHEDULE_MINIMUM_SAVING`, and that
+ * saving grows roughly as `n^2/24`, so every hand-written fixture in this file -- two to seven
+ * unknowns -- solves densely and cannot exercise the schedule at all. Ten sections is the first
+ * size that clears the floor with room to spare.
+ *
+ * **And it is an RC ladder specifically**, because the schedule's hardest case is the
+ * difference between a DC pass and a transient one: a capacitor contributes `2C/dt` to the
+ * matrix while audio is running and contributes *nothing at all* during an operating-point
+ * solve. A ladder whose every shunt element is a capacitor is therefore a structurally
+ * different matrix in the two passes, which is exactly the condition that sent six corpus
+ * packets permanently onto the dense path in 2026-09-18's audit.
+ *
+ * Linear, so its own audio is uninteresting: one solve per sample, a first-order roll-off per
+ * section. Nothing here asserts what it sounds like.
+ */
+export declare const rcLadder: (stages: number) => string;
+/**
+ * Two JFETs differing only in parameter-key spelling. The corpus spells the SPICE
+ * threshold and transconductance `Vt0`/`Beta` (mxr-phase-90, boss-ph-1r,
+ * mxr-noise-gate-line-driver, jhs-morning-glory); nothing in the corpus uses the
+ * all-caps `VTO`/`BETA`. Both spellings must land on thresholdVolts and
+ * transconductance — the all-caps forms were the only ones read, so the corpus
+ * values silently fell back to the law defaults (-2 V, 1 mS).
+ */
+export declare const jfetSpiceCasedParameters: string;
+/** DPDT: pole A lifts the input jack off the core, pole B lifts the output jack; the throws meet on a wire. */
+export declare const trueBypassDpdt: string;
+/** SPDT on the output only; the input jack stays tied to the core and keeps loading it in bypass. */
+export declare const hardwireSpdt: string;
+/**
+ * Always-on emitter-follower buffer, then the DPDT. No latch, no JFET, one BJT: nothing
+ * electronic, yet the bypass wire carries the buffer's output, so the bypass is buffered.
+ * Before 2026-09-22 this derived as `hardwire` and the chain played it as a wire.
+ */
+export declare const bufferedMechanicalDpdt: string;
+/**
+ * Boss-style electronic switching: a cross-coupled BJT bistable toggled by a momentary contact
+ * through a capacitor, its collectors biasing two JFET audio gates. Meets the four structural
+ * requirements `findBistableLatches` states, so this is derived `buffered` by the latch.
+ */
+export declare const flipFlopBypassLatched: string;
+/**
+ * The same JFET gates driven by two BJTs that are **not** cross-coupled (an inverter chain), so
+ * the latch detector finds nothing and the `buffered` verdict rests on the JFET-plus-BJTs
+ * heuristic alone. Pinned so that replacing the heuristic shows up as this fixture moving.
+ */
+export declare const flipFlopBypassJfetGates: string;
+/** The declared switch only grounds a status-indicator node; the audio path never sees it. */
+export declare const bypassSwitchIndicatorOnly: string;
+/**
+ * A cathode-biased pentode gain stage on the generic law: 68k grid stopper, 1M leak, 470 R
+ * cathode, 2.2k plate load and the screen at the 250 V rail through 1k (which drops nothing,
+ * because the generic law draws no screen current). Operating point in `expected.ts`.
+ */
+export declare const pentodeGainStage: string;
+/** Series 10k into a 1 H shunt: the RL high-pass twin of `rlLowPass`, same corner. */
+export declare const rlHighPass: string;
+/**
+ * A three-way rotary: the common on the input, each throw a series resistor into a 1k load, so
+ * every position has a distinct hand-computed gain (`selectorThreeWayGains`). Throw terminals
+ * are named after the options, in option order, so name and order agree.
+ */
+export declare const selectorThreeWay: string;
+/**
+ * An RC core with a chip the registry does not know, declared as a class the compiler opens
+ * without a model (`Circuit.DigitalSignalProcessor`): the pedal still compiles, the chip is
+ * dropped with `ic-not-executed`, and the analog path around it plays. One pin on the audio
+ * node, one on ground, one on a node nothing else touches.
+ */
+export declare const openIcOnDeclaredClass: string;
+/**
+ * The same unknown chip declared as a plain class the compiler does **not** open: the refusal
+ * this pipeline gives an unidentified IC by default, so the fixture above is a deliberate
+ * exception and not a hole.
+ */
+export declare const unknownIcRefused: string;
+export declare const bbdClockDerivedDelay: string;
+/**
+ * The same clock, steered by an LFO: `delay-tap-fractional` in `modulation` mode, which
+ * `mxr-micro-flanger`, `boss-ce-5` and `boss-ce-2` ship and no fixture reached.
+ *
+ * A steered clock cannot state its length as one number, so `deriveBbdDelayFromNetlist` refuses
+ * to pretend and the delay falls back to the declared `DelayMs` -- which is why this variant
+ * carries one and the static fixture above does not. What the modulation resolution wants is
+ * strict: exactly one active device steering the timing network, read at its **control**
+ * terminal, because the timing node itself carries the ~40 kHz oscillator waveform and sampling
+ * that would alias garbage into the delay length. Here that is `Q_LFO`'s base.
+ */
+export declare const bbdClockModulatedDelay: string;
+/**
+ * A PT2399 delay whose time is read off its VCO network: `delay-tap` (integer, not fractional)
+ * in `clock` mode, which `pt2399-delay` and `ibanez-dl5` ship.
+ *
+ * Added alongside the bucket-brigade clock fixture because this is a **different derivation
+ * function** -- `derivePt2399DelayFromNetlist`, which traces a series resistor chain from pin 6
+ * to ground and reads the delay off the datasheet's VCO curve -- and nothing exercised it from
+ * source. The two clock routes share a mode name and no code.
+ */
+export declare const pt2399ClockDerivedDelay: string;
+/**
+ * Linear-control VCA transfer cell (M5207L01 law contract).
+ *
+ * Synthetic stand-in for the TR-2 VCA stage: input jack 1 through Rin 10k
+ * into the VCA input (node 3, referenced to COM), VCA output (node 4)
+ * into Ro 22k to ground, control pin driven by a DC source at
+ * `comVolts + controlVolts` (so Vc = controlVolts against COM). The M5207L01
+ * entry models the input as inputSiemens 0.01 to COM and the gain as
+ * max(0, Vc / 1 V) / 2, so with an ideal input source the hand-computed
+ * voltage gain is (100 / 10100) * 0.01 * 22000 * Vc / 2 = 1.08910891 * Vc.
+ * Renders of this fixture are the law's transfer proof: full, half, COM
+ * offset (control referenced to a nonzero COM, the TR-2 case), and floored
+ * mute. The nonzero-COM case is load-bearing: every earlier test ties COM
+ * to ground, but TR-2's COM is 4.5 V and Vc = Vcontrol - Vcom is what the
+ * whole tremolo depends on.
+ */
+export declare const linearVcaCell: (controlVolts: number, comVolts?: number) => string;
+/**
+ * Bypass-engagement contract: the switchedDivider graph (a shunt switch the signal routes
+ * around, so the connectivity default is open/0) steered by control SW1, with audio.bypass
+ * declaring the engaged position. The three renders differ only in the declared position
+ * and, for the third, a firmware latch toggled by SW1 (which makes the control momentary).
+ * See the "bypass switch default follows its declared engaged position" tests: maintained + 1
+ * defaults to 1, declared 0 keeps the connectivity 0, and the latch-toggled + 1 keeps 0 with
+ * a bypass-engaged-disagrees warning instead of resting "held pressed". `unresolvedPosition`
+ * states a Position its Options cannot place on a throw, which reads as half travel.
+ */
+export declare const bypassEngagedFixture: (engaged: 0 | 1, latchToggle?: boolean, unresolvedPosition?: boolean) => string;
+//# sourceMappingURL=circuits.d.ts.map