@vessel-dsp/compiler 0.0.0-stage → 0.3.0

package/dist/stage-coverage.js

@@ -0,0 +1,124 @@
+// How far down the amplification chain this program's output already is.
+//
+// A chain cannot otherwise know. `mesa-boogie-mark-v` renders 11.7 V and `fender-5e3-deluxe-tweed`
+// renders 7.08 V, and those numbers are not comparable: the first is a preamp monitor tap on a
+// packet that declares no output transformer, the second is a speaker terminal with an 8 ohm load
+// across it. For a day they sat in the same "plausible" column. The same blindness is what lets a
+// signal that already contains a cabinet be sent through another one.
+//
+// Deliberately a small closed vocabulary, ordered from least to most processed, because the useful
+// questions are ordinal: is this a speaker-terminal signal, and does it already contain a cabinet.
+//
+// `miked` is in the vocabulary and is **never derived here**. No compiled circuit contains a
+// microphone; it exists for a NAM profile, whose own metadata is the only thing that can claim it,
+// and for the chain rule that a miked source must not be sent through an IR or the cab simulation.
+import { GROUND } from "./types.js";
+/**
+ * Read from the lowered stamps, the same discipline as `supply-reference.ts` and
+ * `port-full-scale.ts`.
+ *
+ * The distinctions available from a program, and nothing finer:
+ *
+ * - `speaker-electrical` — the output port sits on a winding of a transformer declaring a `ratio`,
+ *   so it *is* the speaker terminal. **Position, not load quality**: whether a speaker is
+ *   modelled across it is a different question, answered by Stage A of the output-stage plan and
+ *   its §4.6 table. An earlier draft here split this by "is something resistive across the node",
+ *   and `fender-bassman` showed why that fails -- a 27 kOhm network element sits on its secondary
+ *   and no test at this stage can tell that from an 8 Ohm driver without guessing from magnitude.
+ * - `preamp` — no output transformer at all, but the program declares a high-voltage supply
+ *   winding (`voltsHv`), which only an amp has. `mesa-boogie-mark-v` lands here: its packet hands
+ *   the transformer and speaker to a companion fixture, so its render is a preamp level.
+ * - `instrument` — everything else, which is every pedal: a pedal does not claim to be further
+ *   along the chain than the instrument feeding it.
+ */
+export function stageCoverage(blocks, ports) {
+    const windingNodes = new Set();
+    let declaresHighVoltageWinding = false;
+    for (const block of blocks) {
+        if (block.kind !== "mna") {
+            continue;
+        }
+        for (const stamp of block.stamps) {
+            if (stamp.kind !== "transformer") {
+                continue;
+            }
+            if (!Number.isFinite(stamp.turnsRatio) || stamp.turnsRatio <= 0) {
+                continue;
+            }
+            for (const row of [
+                stamp.primaryPlus,
+                stamp.primaryMinus,
+                stamp.secondaryPlus,
+                stamp.secondaryMinus,
+            ]) {
+                const node = block.nodeIds[row];
+                if (node !== undefined && node !== GROUND) {
+                    windingNodes.add(node);
+                }
+            }
+        }
+    }
+    // **Widen through an impedance selector, which is where the speaker actually sits.** An ohms
+    // selector stands between a secondary's taps and the speaker jack, so the port is one hop past
+    // the winding rather than on it -- `hiwatt-dr103` stamps three selector throws at nodes
+    // 130/131/132, all on its output transformer, with their common at node 133 carrying both
+    // speaker jacks and the selected load, and `resolvePorts` correctly picks 133. Without this the
+    // packet classified as `preamp` while holding a fully stamped power stage, which is the same
+    // mistake `output-port-not-transformer-coupled` was making in `netlist.ts` and for the same
+    // reason: two tests of one question, only one of which followed the circuit.
+    //
+    // **One throw on the winding is enough, and the guard that matters is `windingNodes` being
+    // non-empty.** A count of two was tried first and does not work here: the unselected taps of an
+    // impedance selector are dropped during lowering as open throws, so only the live tap is ever a
+    // winding node -- `hiwatt-dr103` reaches this with exactly one. What stops a pedal's footswitch
+    // from qualifying is not the count but that a pedal declares no ratio-bearing transformer, so
+    // `windingNodes` is empty and no throw can be on it. Measured: exactly one corpus document holds
+    // both a ratio-bearing transformer stamp and a selector stamp -- `fender-bassman`, already
+    // `speaker-electrical` -- so relaxing the count reclassifies nothing that compiles today. Read
+    // off stamps and node ids only; no name, no role.
+    for (const block of blocks) {
+        if (block.kind !== "mna") {
+            continue;
+        }
+        const throwsByCommon = new Map();
+        for (const stamp of block.stamps) {
+            if (stamp.kind !== "selector") {
+                continue;
+            }
+            const common = block.nodeIds[stamp.common];
+            const thrown = block.nodeIds[stamp.throwNode];
+            if (common === undefined || thrown === undefined) {
+                continue;
+            }
+            if (!windingNodes.has(thrown)) {
+                continue;
+            }
+            const seen = throwsByCommon.get(common) ?? new Set();
+            seen.add(thrown);
+            throwsByCommon.set(common, seen);
+        }
+        for (const [common, thrown] of throwsByCommon) {
+            if (thrown.size >= 1 && common !== GROUND) {
+                windingNodes.add(common);
+            }
+        }
+    }
+    // A high-voltage winding is a power transformer's, whose windings are lowered as independent
+    // sources rather than a ratio — hence a separate pass over the same blocks rather than the
+    // loop above.
+    for (const block of blocks) {
+        if (block.kind !== "mna") {
+            continue;
+        }
+        for (const stamp of block.stamps) {
+            if (stamp.kind === "ac-source" && Math.abs(stamp.amplitudeVolts) > 100) {
+                declaresHighVoltageWinding = true;
+            }
+        }
+    }
+    if (windingNodes.has(ports.output)) {
+        return "speaker-electrical";
+    }
+    return declaresHighVoltageWinding ? "preamp" : "instrument";
+}
+//# sourceMappingURL=stage-coverage.js.map

package/dist/stage-coverage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-coverage.js","sourceRoot":"","sources":["../src/stage-coverage.ts"],"names":[],"mappings":"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"}

package/dist/stamp-partition.d.ts

@@ -0,0 +1,314 @@
+import type { ControlId, NodeId, Stamp, StampPartition } from "./types";
+/**
+ * Which fields of each stamp kind hold a node id.
+ *
+ * One table rather than a switch per consumer. `remapStampNodes` used to restate this as 150
+ * lines of `{ ...stamp, anode: row(stamp.anode), cathode: row(stamp.cathode) }`, and
+ * `stampTerminals` in `sparse-schedule.ts` restates a near-copy of it again for a different
+ * purpose. That is the same fact written twice, and the documented failure mode of getting it
+ * wrong is severe: a stamp kind missing a case kept its authored node ids while every other
+ * stamp in the block moved to row indices, which is an element quietly wired to the wrong
+ * nodes that still renders.
+ *
+ * `satisfies` checks this harder than the switch did. The mapped type requires **every** stamp
+ * kind to appear -- a new kind is a compile error here -- and requires each listed name to be
+ * an actual key of that kind's own variant, so a typo or a field moved during a refactor fails
+ * to build rather than silently renumbering nothing.
+ */
+export declare const STAMP_SHAPES: {
+    readonly conductance: {
+        readonly nodes: readonly ["a", "b"];
+        readonly aux: 0;
+        readonly ports: "none";
+        readonly newton: false;
+    };
+    readonly "controlled-conductance": {
+        readonly nodes: readonly ["a", "b"];
+        readonly aux: 0;
+        readonly ports: "none";
+        readonly newton: false;
+        readonly control: true;
+    };
+    readonly "controlled-resistance": {
+        readonly nodes: readonly ["a", "b"];
+        readonly aux: 0;
+        readonly ports: "none";
+        readonly newton: false;
+        readonly control: true;
+    };
+    readonly capacitor: {
+        readonly nodes: readonly ["a", "b"];
+        readonly aux: 0;
+        readonly ports: "none";
+        readonly newton: false;
+        readonly dynamic: true;
+    };
+    readonly inductor: {
+        readonly nodes: readonly ["a", "b"];
+        readonly aux: 0;
+        readonly ports: "none";
+        readonly newton: false;
+        readonly dynamic: true;
+    };
+    readonly switch: {
+        readonly nodes: readonly ["a", "b"];
+        readonly aux: 0;
+        readonly ports: "none";
+        readonly newton: false;
+        readonly control: true;
+    };
+    readonly selector: {
+        readonly nodes: readonly ["common", "throwNode"];
+        readonly aux: 0;
+        readonly ports: "none";
+        readonly newton: false;
+        readonly control: true;
+    };
+    readonly "dc-source": {
+        readonly nodes: readonly ["positive", "negative"];
+        readonly aux: 1;
+        readonly ports: "none";
+        readonly newton: false;
+    };
+    readonly "ac-source": {
+        readonly nodes: readonly ["positive", "negative"];
+        readonly aux: 1;
+        readonly ports: "none";
+        readonly newton: false;
+    };
+    readonly "input-source": {
+        readonly nodes: readonly ["node"];
+        readonly aux: 1;
+        readonly ports: "none";
+        readonly newton: false;
+    };
+    readonly "macro-audio-source": {
+        readonly nodes: readonly ["node"];
+        readonly aux: 1;
+        readonly ports: "none";
+        readonly newton: false;
+    };
+    readonly "logic-divider": {
+        readonly nodes: readonly ["clockNode", "qNode", "gndNode"];
+        readonly aux: 1;
+        readonly ports: "none";
+        readonly newton: false;
+        readonly dynamic: true;
+    };
+    readonly vccs: {
+        readonly nodes: readonly ["outP", "outN", "inP", "inN"];
+        readonly aux: 0;
+        readonly ports: "none";
+        readonly newton: false;
+    };
+    readonly transformer: {
+        readonly nodes: readonly ["primaryPlus", "primaryMinus", "secondaryPlus", "secondaryMinus"];
+        readonly aux: 1;
+        readonly ports: "nodes-and-aux";
+        readonly newton: false;
+    };
+    readonly "spring-reverb": {
+        readonly nodes: readonly ["inputPlus", "inputMinus", "outputPlus", "outputMinus"];
+        readonly aux: 1;
+        readonly ports: "nodes";
+        readonly newton: false;
+        readonly dynamic: true;
+    };
+    readonly "ideal-opamp": {
+        readonly nodes: readonly ["plus", "minus", "output"];
+        readonly aux: 1;
+        readonly ports: "railed-opamp";
+        readonly newton: "railed-opamp";
+    };
+    readonly diode: {
+        readonly nodes: readonly ["anode", "cathode"];
+        readonly aux: 0;
+        readonly ports: "nodes";
+        readonly newton: true;
+    };
+    readonly "tube-diode": {
+        readonly nodes: readonly ["plate", "cathode"];
+        readonly aux: 0;
+        readonly ports: "nodes";
+        readonly newton: true;
+    };
+    readonly bjt: {
+        readonly nodes: readonly ["base", "collector", "emitter"];
+        readonly aux: 0;
+        readonly ports: "nodes";
+        readonly newton: true;
+    };
+    readonly fet: {
+        readonly nodes: readonly ["gate", "drain", "source"];
+        readonly aux: 0;
+        readonly ports: "nodes";
+        readonly newton: true;
+    };
+    readonly triode: {
+        readonly nodes: readonly ["grid", "cathode", "plate"];
+        readonly aux: 0;
+        readonly ports: "nodes";
+        readonly newton: true;
+    };
+    readonly pentode: {
+        readonly nodes: readonly ["grid", "cathode", "plate", "screen"];
+        readonly aux: 0;
+        readonly ports: "nodes";
+        readonly newton: true;
+    };
+    readonly ota: {
+        readonly nodes: readonly ["plus", "minus", "bias", "output", "vee"];
+        readonly aux: 0;
+        readonly ports: "nodes";
+        readonly newton: true;
+    };
+    readonly optocoupler: {
+        readonly nodes: readonly ["ldrA", "ldrB", "ledAnode", "ledCathode"];
+        readonly aux: 0;
+        readonly ports: "nodes";
+        readonly newton: true;
+    };
+    readonly "analog-switch": {
+        readonly nodes: readonly ["a", "b", "control"];
+        readonly aux: 0;
+        readonly ports: "nodes";
+        readonly newton: true;
+    };
+    readonly compandor: {
+        readonly nodes: readonly ["rectIn", "rectCap", "cellIn", "sumNode", "vref"];
+        readonly aux: 0;
+        readonly ports: "nodes";
+        readonly newton: true;
+        readonly dynamic: true;
+    };
+    readonly "clock-driver": {
+        readonly nodes: readonly ["cp1", "cp2", "vgg", "vdd", "ox1", "gnd"];
+        readonly aux: 3;
+        readonly ports: "nodes";
+        readonly newton: true;
+    };
+    readonly comparator: {
+        readonly nodes: readonly ["plus", "minus", "output", "vee"];
+        readonly aux: 0;
+        readonly ports: "nodes";
+        readonly newton: true;
+    };
+    readonly "linear-vca": {
+        readonly nodes: readonly ["plus", "minus", "output", "control"];
+        readonly aux: 0;
+        readonly ports: "nodes";
+        readonly newton: true;
+    };
+};
+type StampShape = {
+    readonly nodes: readonly string[];
+    readonly aux: 0 | 1 | 3;
+    readonly ports: "none" | "nodes" | "nodes-and-aux" | "railed-opamp";
+    readonly newton: boolean | "railed-opamp";
+    readonly terminalNodes?: readonly string[];
+    readonly terminalsDropGround?: true;
+    readonly control?: true;
+    readonly dynamic?: true;
+};
+/** The shape entry for a stamp, with the table's per-kind literal types widened away. */
+export declare function stampShape(stamp: Stamp): StampShape;
+/** Read a named node field off a stamp. */
+export declare function stampNodeValue(stamp: Stamp, field: string): number;
+/** The auxiliary rows a stamp owns, as absolute row indices. */
+export declare function stampAuxRows(stamp: Stamp, nodeCount: number): number[];
+/**
+ * Rewrite a stamp's node fields through `row`.
+ *
+ * The spread reassigns keys the stamp already carries, so their position in the object is
+ * unchanged -- which matters because a lowered stamp is serialised into the emitted program
+ * and key order is part of those bytes.
+ */
+export declare function remapStampNodes(stamp: Stamp, row: (node: NodeId) => NodeId): Stamp;
+/**
+ * Does this stamp have to be re-evaluated inside a Newton loop?
+ *
+ * **The stamp-level twin of `partition.ts`'s `lawNeedsNewton`, and deliberately a second fact
+ * rather than a reuse of the first.** A law and its stamps are not the same list -- a jack's
+ * `port-engage` law lowers to a plain `conductance`, an `ac-source` law lowers to two stamps,
+ * an `open` law lowers to none -- and what a solver has to do is decided by what is in the
+ * block, not by what was in the document. `Block.linear` is read by the runtime to choose
+ * between one pass and an iteration cap, so it has to describe the stamps it will evaluate.
+ *
+ * The two mistakes are not symmetric, which is why the table has to be exhaustive. Calling a
+ * linear stamp nonlinear costs a few iterations; calling a nonlinear stamp linear makes
+ * `iterate` run one pass, evaluate the curve once from a zero start, and emit that as a solved
+ * answer -- no held sample, no telemetry, no diagnostic.
+ */
+export declare function stampNeedsNewton(stamp: Stamp): boolean;
+/**
+ * Which runtime control moves a stamp's value, or `null` when it is constant.
+ *
+ * Read off the shape table's `control` flag. A stamp missing that flag would silently make a
+ * block look `controlFree`, and step 4's whole promise is that such a block's matrix is
+ * constant -- so the omission would be a factorisation frozen against a knob that still moves.
+ */
+export declare function stampControl(stamp: Stamp): ControlId | null;
+/**
+ * Which rows a stamp's device law actually writes into the Jacobian / RHS, or `null` when the
+ * stamp writes none.
+ *
+ * Read off the shape table's `ports`, which is a **separate fact from `newton`** and not a
+ * synonym for it. `transformer` and `spring-reverb` are both linear within a sample yet
+ * declare port rows, so deriving this from `stampNeedsNewton` would drop them.
+ *
+ * The returned order is not significant: `computeStampPartition` feeds these into a `Set` and
+ * sorts it.
+ */
+export declare function stampPortRows(stamp: Stamp, nodeCount: number): readonly number[] | null;
+/**
+ * Whether a stamp carries dynamic/reactive state (e.g. companion state across time steps).
+ */
+export declare function stampIsDynamic(stamp: Stamp): boolean;
+/**
+ * Compute the complete stamp partition for an MNA block.
+ */
+export declare function computeStampPartition(stamps: readonly Stamp[], nodeCount: number): StampPartition;
+/**
+ * Whether a block should carry the eliminated (Schur-complement) solve.
+ *
+ * Shared by `lower.ts`, which decides it when a region is first lowered, and `couple.ts`,
+ * which must re-decide it after adding a stamp. The two carried byte-identical copies of this
+ * predicate, so a threshold changed in one and not the other would have made a coupled block
+ * disagree with the same block uncoupled.
+ */
+export declare function shouldEliminate(unknowns: number, portRowCount: number, linear: boolean, 
+/**
+ * The document's `convergence-opt-in` flag. Where set, a nonlinear block with port rows is
+ * eliminated regardless of the cost rule -- it overrides the cost veto, but not the
+ * linear / zero-port guard above, which a portless or linear block cannot use elimination
+ * for at all.
+ */
+convergenceOptIn?: boolean): boolean;
+/**
+ * The derived admission rule, behind `VESSEL_DERIVED_ELIMINATION=1`.
+ *
+ * **Cost goes as unknowns² × nonlinear count** — fitted across ten packets with WASM-measured cost,
+ * `R² = 0.674`. Elimination replaces an `n`-unknown iterated system with a `p`-unknown one, and its
+ * own factorisation is prepare-time for a linear interior. What it costs per sample is
+ * **densification**: the port system is dense where the original may have been sparse. So:
+ *
+ * ```
+ * admit when   MEASURED_DENSIFICATION * p²  <  n²      i.e.  n/p > sqrt(7.2) = 2.68
+ * ```
+ *
+ * **No free constant.** `7.2` is the measured on/off of the two solve paths at 72-119 unknowns and
+ * the exponent is fitted (~2); neither was chosen to admit or reject any particular packet — which
+ * is the failure this replaces. Lowering `2.4` until it admitted the three packets whose saving had
+ * been predicted would have made the prediction and the admission one choice, and no later
+ * measurement could have separated them.
+ *
+ * **`ELIMINATE_MIN_UNKNOWNS` is still consulted and is still hand-set.** The model has **no term
+ * for fixed per-block overhead**, and without one the inequality admits every block with any
+ * interior — 241 of 241, which is not a predicate. The floor stands in for that missing term, and
+ * the sample straddling it (15 admitted blocks below, 31 above) is designed to retire it: if a
+ * 7-unknown block predicted at 84% delivers nothing, the overhead is the whole saving at that size
+ * and the crossover **is** the floor, derived rather than chosen.
+ */
+export declare function derivedShouldEliminate(unknowns: number, portRowCount: number): boolean;
+export {};
+//# sourceMappingURL=stamp-partition.d.ts.map

package/dist/stamp-partition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stamp-partition.d.ts","sourceRoot":"","sources":["../src/stamp-partition.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAGxE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqMxB,CAAC;AAEF,KAAK,UAAU,GAAG;IACjB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,eAAe,GAAG,cAAc,CAAC;IACpE,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAAC;IAC1C,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,mBAAmB,CAAC,EAAE,IAAI,CAAC;IACpC,QAAQ,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC;CACxB,CAAC;AAEF,yFAAyF;AACzF,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAEnD;AAED,2CAA2C;AAC3C,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAElE;AAED,gEAAgE;AAChE,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAMtE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAC3B,KAAK,CAMP;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAMtD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,GAAG,IAAI,CAI3D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC5B,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,MAAM,GACf,SAAS,MAAM,EAAE,GAAG,IAAI,CAa1B;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAEpD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,SAAS,EAAE,MAAM,GACf,cAAc,CAsEhB;AAsBD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC9B,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,OAAO;AACf;;;;;GAKG;AACH,gBAAgB,UAAQ,GACtB,OAAO,CAeT;AAeD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,sBAAsB,CACrC,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,GAClB,OAAO,CAQT"}