@vessel-dsp/compiler 0.0.0-stage → 0.2.0

package/dist/fixtures/registry.js

@@ -0,0 +1,341 @@
+// Fake part registries.
+//
+// The registry is an injected parameter, so a fake is not a mock -- it is a
+// legitimate configuration. `emptyRegistry` in particular is the arbitrary-schematic
+// case: what compiles when the compiler knows about no parts at all.
+//
+// No real part numbers. `FIXTURE-DELAY-1` exists nowhere outside these tests, which
+// keeps the identity assertions away from anything the corpus contains.
+//
+// **A fictional part, but not a fictional model.** `modelId` names the DSP algorithm a
+// runtime must implement, not the chip (see `MacroModel.modelId`), so the fixture part's
+// model is the real `bucket-brigade-delay-line` a real MN3007 entry would also name. Making
+// it fictional too would mean the only implemented model in the runtime existed for tests.
+const fixtureDelayMacro = {
+    modelId: "bucket-brigade-delay-line",
+    parameters: { stages: 1024 },
+    // Addressed by role rather than by index, which is what lets one entry serve documents that
+    // order the same pinout differently. The fixture's own terminals are named to match.
+    ports: {
+        audioIn: ["in"],
+        audioOut: ["out", "out1"],
+        parameter: ["cp1", "clock1"],
+    },
+    // A `coupled` port on both audio terminals: 47k in (a sampling-cap-and-bias-network
+    // stand-in), 1k out (a buffered source). Neither is a real MN3005 measurement --
+    // this part exists nowhere outside these tests -- but both are nonzero and
+    // declared, so the loading is real rather than a zero default nothing measured.
+    audioPortImpedanceOhms: { input: 47_000, output: 1_000 },
+    parameterReferenceVolts: 9,
+};
+/** The part's identity, shared by both macro registries below so only the model differs. */
+const fixtureDelayIdentity = {
+    partIds: ["FIXTURE-DELAY-1"],
+    declaredTypes: ["Circuit.FixtureDelayMemory"],
+    terminalRoleGroups: [
+        ["cp1", "clock1"],
+        ["vgg", "gatebias"],
+    ],
+};
+/** Knows one macro model, by exact part id, declared type, and pinout. */
+export const fixtureRegistry = {
+    entries: [
+        {
+            ...fixtureDelayIdentity,
+            model: { kind: "macro", macro: fixtureDelayMacro },
+        },
+    ],
+};
+/**
+ * The same part, declaring a DSP algorithm no runtime implements.
+ *
+ * The negative control for the model lockout, and it is the whole point of that lockout: a
+ * compander is a real thing a real chip in a real pedal does, it is not a delay line, and
+ * before `modelId` was dispatched on at all it would have *executed* as one -- plausible,
+ * silent and completely wrong. Only the `modelId` differs from `fixtureRegistry`, so a program
+ * built from this is identical in every other respect -- same pinout, same ports, same
+ * schedule, same stamps -- and whatever refuses it can only be refusing the model.
+ */
+export const unimplementedMacroRegistry = {
+    entries: [
+        {
+            ...fixtureDelayIdentity,
+            model: {
+                kind: "macro",
+                macro: { ...fixtureDelayMacro, modelId: "compander" },
+            },
+        },
+    ],
+};
+/**
+ * The fixture part as the `digital-delay-line` model, with feedback regeneration.
+ *
+ * The positive control for the runtime's dispatch: same identity, same ports, same schedule as
+ * `fixtureRegistry` above, differing only in the algorithm name and the one parameter that model
+ * carries (`feedback`). A `digital-delay-line` that rendered as a plain delay would be the
+ * same plausible-wrong-pedal defect the `compander` lockout above pins, so this is the case that
+ * must regenerate.
+ */
+export const digitalDelayLineRegistry = {
+    entries: [
+        {
+            ...fixtureDelayIdentity,
+            model: {
+                kind: "macro",
+                macro: {
+                    ...fixtureDelayMacro,
+                    modelId: "digital-delay-line",
+                    parameters: { feedback: 0.6 },
+                },
+            },
+        },
+    ],
+};
+/** The `digital-delay-line` model with no regeneration: the plain-delay negative control. */
+export const digitalDelayLineDryRegistry = {
+    entries: [
+        {
+            ...fixtureDelayIdentity,
+            model: {
+                kind: "macro",
+                macro: {
+                    ...fixtureDelayMacro,
+                    modelId: "digital-delay-line",
+                    parameters: { feedback: 0 },
+                },
+            },
+        },
+    ],
+};
+/**
+ * Mock ICs for the parity gate (`scripts/report-fixture-spice-parity.ts`).
+ *
+ * Every chip in the corpus carrying a law that gate cannot reach is a `macro`: a BBD, a delay
+ * memory, a compandor. A macro is lifted out of the solver and executed as DSP, so ngspice has
+ * no circuit to compare against one and no fixture can change that. `sections` is the other
+ * thing a registry can say -- the chip expands into ordinary device laws that stay in the
+ * matrix -- and that is the path most of the corpus's registry-expanded devices actually take.
+ * These entries exist so that path has fixtures.
+ *
+ * Fictional part numbers, like every entry in this file. The *laws* are real: a mock law would
+ * mean the gate graded behaviour no pedal runs.
+ */
+export const sectionsRegistry = {
+    entries: [
+        {
+            // One op-amp on an eight-pin package. The point of comparison is `invertingAmplifier`,
+            // which is the same circuit with the op-amp declared as `kind: opamp` instead: if the
+            // packaged one disagrees and the discrete one agrees, the defect is in expansion.
+            partIds: ["PKG-OPAMP-1"],
+            declaredTypes: [],
+            terminalRoleGroups: [],
+            model: {
+                kind: "sections",
+                pinout: [null, null, null, null, null, null, null, null],
+                sections: [
+                    {
+                        law: { kind: "ideal-opamp", railHigh: null, railLow: null, openLoopGain: 1e5 },
+                        terminals: [0, 1, 2],
+                    },
+                ],
+            },
+        },
+        {
+            /**
+             * An optocoupler / Vactrol: an LED facing a light-dependent resistor.
+             *
+             * `optocoupler` is four corpus packets -- the Fender tremolos -- and it is a stamp in
+             * the matrix rather than a lifted macro, which is what makes it referenceable at all.
+             * The LDR's resistance falls exponentially with LED current, so wiring the LED to the
+             * signal makes the row grade that coupling curve rather than one point on it.
+             *
+             * The `ldrMinOhms` / `ldrMaxOhms` span is the part fact here. `ledThresholdVolts` and
+             * `ledTransconductance` are *not*: both are required by the law's type and neither
+             * runtime reads them -- see
+             * docs/troubleshootings/an-optocouplers-declared-led-parameters-are-not-executed.md.
+             */
+            partIds: ["PKG-OPTO-1"],
+            declaredTypes: [],
+            terminalRoleGroups: [],
+            model: {
+                kind: "sections",
+                pinout: [null, null, null, null, null, null, null, null],
+                sections: [
+                    {
+                        law: {
+                            kind: "optocoupler",
+                            ledThresholdVolts: 1.6,
+                            ledTransconductance: 0.001,
+                            ldrMinOhms: 1000,
+                            ldrMaxOhms: 100_000,
+                        },
+                        terminals: [0, 1, 2, 3],
+                    },
+                ],
+            },
+        },
+        {
+            /**
+             * A CMOS transmission gate: a conductance between two signal pins, set by a third.
+             *
+             * `analog-switch` is two corpus packets and had no fixture. The law is a smooth
+             * sigmoid rather than a hard throw -- `gOff + (gOn - gOff) / (1 + exp(-10 * (vCtrl -
+             * Vth)))` -- so it has a curve to grade rather than two states, which is why an
+             * ngspice `S` element would be the wrong reference for it.
+             */
+            partIds: ["PKG-SWITCH-1"],
+            declaredTypes: [],
+            terminalRoleGroups: [],
+            model: {
+                kind: "sections",
+                pinout: [null, null, null, null, null, null, null, null],
+                sections: [
+                    {
+                        // Threshold at 0 V so the fixture's own signal drives the gate across the
+                        // curve. A CD4066's real threshold sits mid-rail; this one is placed where
+                        // the sigmoid is steepest, because a row biased hard on would grade the
+                        // on-resistance and never the law.
+                        law: { kind: "analog-switch", onOhms: 125, offOhms: 1e6, thresholdVolts: 0 },
+                        terminals: [0, 1, 2],
+                    },
+                ],
+            },
+        },
+        {
+            /**
+             * An open-collector comparator: the output is pulled toward `vee` or left floating.
+             *
+             * `comparator` is one corpus packet. Like the analog switch it is a sigmoid, not a
+             * step: `gOn / (1 + exp(k * vDiff)) + gOff` between output and `vee`. A fourth
+             * terminal would name `vee`; three leaves it at ground, which is the common wiring.
+             */
+            partIds: ["PKG-COMPARATOR-1"],
+            declaredTypes: [],
+            terminalRoleGroups: [],
+            model: {
+                kind: "sections",
+                sections: [
+                    {
+                        // A soft comparator, and every number here is chosen against a measurement.
+                        // Sensitivity 8 rather than a decisive several hundred spans the sigmoid
+                        // smoothly at this fixture's 0.1 V drive instead of producing switching
+                        // edges, whose *timing* a fixed-step runtime and an adaptive-step ngspice
+                        // resolve differently for reasons that are not the law. The 22:1 on/off
+                        // conductance ratio is likewise deliberate: at the stiffer 1e4:1 first
+                        // tried, the runtime's Newton failed to converge on 120 samples and the row
+                        // reported `unconverged`, which says nothing about the comparator.
+                        law: { kind: "comparator", pullDownOhms: 2200, floatOhms: 1e4, sensitivity: 8 },
+                        terminals: [0, 1, 2],
+                    },
+                ],
+                pinout: [null, null, null, null, null, null, null, null],
+            },
+        },
+        {
+            /**
+             * The four-terminal OTA: the one the corpus actually uses.
+             *
+             * A fourth mapped terminal is an amplifier-bias pin, and its presence is what selects
+             * the nonlinear part over the linear fallback. The bias pin sinks a diode current to
+             * `vee` -- unmapped here, so ground -- and that current sets the output's scale, so a
+             * declaration error in the bias pin changes the gain rather than nothing. The output
+             * is `2 * Iabc * tanh(vDiff / 2Vt)`: compressive by construction, which is the whole
+             * reason a phaser built on one sounds like a phaser.
+             */
+            partIds: ["PKG-OTA-NL-1"],
+            declaredTypes: [],
+            terminalRoleGroups: [],
+            model: {
+                kind: "sections",
+                pinout: [null, null, null, null, null, null, null, null],
+                sections: [
+                    {
+                        // `transconductance` is unread on this path: with a bias terminal the scale
+                        // comes from `Iabc`, not from a declared gm. It is required by the law's type.
+                        law: { kind: "ota", transconductance: 1e-3 },
+                        terminals: [0, 1, 2, 3],
+                    },
+                ],
+            },
+        },
+        {
+            // A transconductor: output current is gm times the input difference. `ota` is 5 corpus
+            // packets and has no fixture at all, because every real OTA arrives inside an `ic`.
+            partIds: ["PKG-OTA-1"],
+            declaredTypes: [],
+            terminalRoleGroups: [],
+            model: {
+                kind: "sections",
+                pinout: [null, null, null, null, null, null, null, null],
+                sections: [
+                    {
+                        law: { kind: "ota", transconductance: 1e-3 },
+                        terminals: [0, 1, 2],
+                    },
+                ],
+            },
+        },
+    ],
+};
+/** Knows one part as a lumped law rather than a macro model. */
+export const resistiveChipRegistry = {
+    entries: [
+        {
+            partIds: ["FIXTURE-RESISTIVE-1"],
+            declaredTypes: [],
+            terminalRoleGroups: [],
+            model: { kind: "law", law: { kind: "conductance", siemens: 1e-4 } },
+        },
+    ],
+};
+/**
+ * Knows one multi-section part: a fictional dual op-amp on eight pins.
+ *
+ * The shape real dual op-amps take, without a real part number. Sections index the device's own
+ * terminals, so pins 4 and 7 -- the supply pins -- appear in no section and contribute nothing,
+ * which is correct: an `ideal-opamp` resolves its rails from the circuit's supply set rather than
+ * from its own pins.
+ */
+export const dualOpampRegistry = {
+    entries: [
+        {
+            partIds: ["FIXTURE-DUAL-OPAMP-1"],
+            declaredTypes: [],
+            terminalRoleGroups: [],
+            model: {
+                kind: "sections",
+                // The fixture chip numbers its pins (`pin1`..`pin8`), and `terminalRoleToken` returns
+                // null for a bare pin number, so there is nothing to check and every position is
+                // unchecked. That is the honest encoding: the guard exists to catch a document whose
+                // *named* terminals disagree with the entry, and this one names none.
+                pinout: [null, null, null, null, null, null, null, null],
+                sections: [
+                    // plus, minus, output -- the canonical order for an op-amp section. The rails are
+                    // null here and substituted from the circuit's supply set at expansion, because a
+                    // registry describes a part and the rails belong to the pedal it is fitted to.
+                    {
+                        law: {
+                            kind: "ideal-opamp",
+                            railHigh: null,
+                            railLow: null,
+                            // The part's own gain; only the rails come from the pedal.
+                            openLoopGain: 2e5,
+                        },
+                        terminals: [0, 1, 2],
+                    },
+                    {
+                        law: {
+                            kind: "ideal-opamp",
+                            railHigh: null,
+                            railLow: null,
+                            // The part's own gain; only the rails come from the pedal.
+                            openLoopGain: 2e5,
+                        },
+                        terminals: [5, 4, 3],
+                    },
+                ],
+            },
+        },
+    ],
+};
+//# sourceMappingURL=registry.js.map

package/dist/fixtures/registry.js.map

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

package/dist/generic-tube-fit.d.ts

@@ -0,0 +1,12 @@
+import { type PartRegistry } from "./registry";
+import type { CompileWarning, Netlist } from "./types";
+/**
+ * One warning per tube device whose part number the registry does not answer.
+ *
+ * Reported per device rather than per part number, because "which tube is generic" and "how much of
+ * this amp is generic" are different questions and the second is the one that decides whether a
+ * render can be quoted. An amp whose preamp is catalogued and whose output pair is not is a
+ * different claim from one where nothing resolved.
+ */
+export declare function findGenericTubeFits(netlist: Netlist, registry: PartRegistry): readonly CompileWarning[];
+//# sourceMappingURL=generic-tube-fit.d.ts.map

package/dist/generic-tube-fit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-tube-fit.d.ts","sourceRoot":"","sources":["../src/generic-tube-fit.ts"],"names":[],"mappings":"AAaA,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAKvD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAClC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,YAAY,GACpB,SAAS,cAAc,EAAE,CAqB3B"}

package/dist/generic-tube-fit.js

@@ -0,0 +1,45 @@
+// A tube running a device-class fit instead of its own.
+//
+// This exists because the alternative was measured: every triode in the corpus ran a 12AX7 fit and
+// every pentode a 6V6 fit, silently, for as long as v2 has compiled an amp. `vox-ac15-top-boost`'s
+// EL84s were handed `mu 8.0` where the part's own fit says 21.29, which biased the shared cathode
+// resistor to 23 V, cut the output stage off and decayed the amp to 2.5 mV. Nothing reported it,
+// because a fallback that returns a working law looks exactly like a fallback that returns the
+// right one. See `docs/troubleshootings/every-tube-gets-a-generic-fit-not-its-declared-device.md`.
+//
+// A warning rather than a refusal: an unregistered tube still gets a device-class law, exactly as
+// an unregistered transistor does, and refusing every amp whose tube is not catalogued would trade
+// a working corpus for a complete one.
+import { registryLawFor } from "./registry.js";
+/** The tube kinds whose law a part number can refine. */
+const TUBE_KINDS = new Set(["triode", "pentode", "tube-diode"]);
+/**
+ * One warning per tube device whose part number the registry does not answer.
+ *
+ * Reported per device rather than per part number, because "which tube is generic" and "how much of
+ * this amp is generic" are different questions and the second is the one that decides whether a
+ * render can be quoted. An amp whose preamp is catalogued and whose output pair is not is a
+ * different claim from one where nothing resolved.
+ */
+export function findGenericTubeFits(netlist, registry) {
+    const warnings = [];
+    for (const device of netlist.devices) {
+        if (!TUBE_KINDS.has(device.kind)) {
+            continue;
+        }
+        const partNumber = device.identity.partNumber;
+        if (registryLawFor(registry, partNumber, device.kind) !== null) {
+            continue;
+        }
+        warnings.push({
+            code: "generic-tube-fit",
+            device: device.id,
+            partNumber,
+            detail: partNumber === null
+                ? `${device.kind} declares no part number, so it runs the generic device-class fit and its bias and gain are not this tube's`
+                : `${device.kind} ${partNumber} is not in the catalog, so it runs the generic device-class fit -- its bias and gain are another tube's`,
+        });
+    }
+    return warnings;
+}
+//# sourceMappingURL=generic-tube-fit.js.map

package/dist/generic-tube-fit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-tube-fit.js","sourceRoot":"","sources":["../src/generic-tube-fit.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,EAAE;AACF,mGAAmG;AACnG,mGAAmG;AACnG,kGAAkG;AAClG,iGAAiG;AACjG,+FAA+F;AAC/F,mGAAmG;AACnG,EAAE;AACF,kGAAkG;AAClG,mGAAmG;AACnG,uCAAuC;AAEvC,OAAO,EAAE,cAAc,EAAqB,MAAM,YAAY,CAAC;AAG/D,yDAAyD;AACzD,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,CAAC,QAAQ,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;AAEhE;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAClC,OAAgB,EAChB,QAAsB;IAEtB,MAAM,QAAQ,GAAqB,EAAE,CAAC;IACtC,KAAK,MAAM,MAAM,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;QACtC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;YAClC,SAAS;QACV,CAAC;QACD,MAAM,UAAU,GAAG,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC;QAC9C,IAAI,cAAc,CAAC,QAAQ,EAAE,UAAU,EAAE,MAAM,CAAC,IAAa,CAAC,KAAK,IAAI,EAAE,CAAC;YACzE,SAAS;QACV,CAAC;QACD,QAAQ,CAAC,IAAI,CAAC;YACb,IAAI,EAAE,kBAAkB;YACxB,MAAM,EAAE,MAAM,CAAC,EAAE;YACjB,UAAU;YACV,MAAM,EACL,UAAU,KAAK,IAAI;gBAClB,CAAC,CAAC,GAAG,MAAM,CAAC,IAAI,6GAA6G;gBAC7H,CAAC,CAAC,GAAG,MAAM,CAAC,IAAI,IAAI,UAAU,yGAAyG;SACzI,CAAC,CAAC;IACJ,CAAC;IACD,OAAO,QAAQ,CAAC;AACjB,CAAC"}

package/dist/grounded-clock-supply.d.ts

@@ -0,0 +1,13 @@
+import type { CompileWarning, Program } from "./types";
+/**
+ * Clock drivers whose `vdd` row is the ground row, and therefore render no clock at all.
+ *
+ * **Why this is a program-level check and not a netlist one.** `vdd` is a *row index* into the
+ * block's solution, not a source node id, so whether it is ground is only knowable after `link`
+ * has assigned rows and `nodeIds` maps them back. Reading `stamp.vdd === 0` directly would happen
+ * to work while row 0 is conventionally ground and would break silently the day it is not.
+ *
+ * See `ClockDriverSupplyAtGroundWarning` for why a correct transcription lands here.
+ */
+export declare function findGroundedClockSupplies(program: Program): readonly CompileWarning[];
+//# sourceMappingURL=grounded-clock-supply.d.ts.map

package/dist/grounded-clock-supply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grounded-clock-supply.d.ts","sourceRoot":"","sources":["../src/grounded-clock-supply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAEvD;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACxC,OAAO,EAAE,OAAO,GACd,SAAS,cAAc,EAAE,CAkC3B"}

package/dist/grounded-clock-supply.js

@@ -0,0 +1,45 @@
+/**
+ * Clock drivers whose `vdd` row is the ground row, and therefore render no clock at all.
+ *
+ * **Why this is a program-level check and not a netlist one.** `vdd` is a *row index* into the
+ * block's solution, not a source node id, so whether it is ground is only knowable after `link`
+ * has assigned rows and `nodeIds` maps them back. Reading `stamp.vdd === 0` directly would happen
+ * to work while row 0 is conventionally ground and would break silently the day it is not.
+ *
+ * See `ClockDriverSupplyAtGroundWarning` for why a correct transcription lands here.
+ */
+export function findGroundedClockSupplies(program) {
+    const warnings = [];
+    for (const block of program.blocks) {
+        if (block.kind !== "mna") {
+            continue;
+        }
+        for (const stamp of block.stamps) {
+            if (stamp.kind !== "clock-driver") {
+                continue;
+            }
+            // **Both** supply pins, not just `vdd`. Until the stamp gained a `gnd` terminal it
+            // swung the phases between `vdd` and literal ground, so `vdd` at ground alone was
+            // fatal and this warned on it; that is no longer true and warning on it would now be
+            // a false alarm on two correctly-wired packets. What remains fatal is having no
+            // supply to swing between at all.
+            const vddNode = block.nodeIds?.[stamp.vdd] ?? stamp.vdd;
+            const gndNode = block.nodeIds?.[stamp.gnd] ?? stamp.gnd;
+            if (vddNode !== 0 || gndNode !== 0) {
+                continue;
+            }
+            warnings.push({
+                code: "clock-driver-supply-at-ground",
+                device: null,
+                detail: `Clock driver in block ${block.id} has both supply terminals at circuit ground ` +
+                    `(VDD row ${stamp.vdd}, GND row ${stamp.gnd}), so there is no potential for its ` +
+                    "clock phases to swing between and CP1, CP2 and VGG all render as zero -- the " +
+                    "bucket brigade receives no clock. The MN3101/MN3102 run on a single negative " +
+                    "supply, so exactly one of these two pins should sit at a rail: a +9 V pedal ties " +
+                    "the part's GND pin to the positive rail and its VDD pin to circuit ground.",
+            });
+        }
+    }
+    return warnings;
+}
+//# sourceMappingURL=grounded-clock-supply.js.map

package/dist/grounded-clock-supply.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grounded-clock-supply.js","sourceRoot":"","sources":["../src/grounded-clock-supply.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,UAAU,yBAAyB,CACxC,OAAgB;IAEhB,MAAM,QAAQ,GAAqB,EAAE,CAAC;IACtC,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;QACpC,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;YAC1B,SAAS;QACV,CAAC;QACD,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;YAClC,IAAI,KAAK,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;gBACnC,SAAS;YACV,CAAC;YACD,mFAAmF;YACnF,kFAAkF;YAClF,qFAAqF;YACrF,gFAAgF;YAChF,kCAAkC;YAClC,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC;YACxD,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC;YACxD,IAAI,OAAO,KAAK,CAAC,IAAI,OAAO,KAAK,CAAC,EAAE,CAAC;gBACpC,SAAS;YACV,CAAC;YACD,QAAQ,CAAC,IAAI,CAAC;gBACb,IAAI,EAAE,+BAA+B;gBACrC,MAAM,EAAE,IAAI;gBACZ,MAAM,EACL,yBAAyB,KAAK,CAAC,EAAE,+CAA+C;oBAChF,YAAY,KAAK,CAAC,GAAG,aAAa,KAAK,CAAC,GAAG,sCAAsC;oBACjF,+EAA+E;oBAC/E,+EAA+E;oBAC/E,mFAAmF;oBACnF,4EAA4E;aAC7E,CAAC,CAAC;QACJ,CAAC;IACF,CAAC;IACD,OAAO,QAAQ,CAAC;AACjB,CAAC"}

package/dist/identify.d.ts

@@ -0,0 +1,50 @@
+import { type PartRegistry } from "./registry";
+import type { Device, PartIdentity } from "./types";
+/** Kinds whose behaviour is not determined by the netlist and so need a part. */
+export declare function requiresIdentification(device: Device): boolean;
+/**
+ * Kinds whose behaviour a registry **may** extend, as opposed to supply outright.
+ *
+ * `ic` and `power-amp` have no behaviour except a part's, so for them the registry is the only
+ * source and its silence is a refusal -- that is `requiresIdentification` above. An `ota` is
+ * different in both directions: it carries a universal device-class law
+ * (`I_out = gm * (V+ - V-)`), so an unregistered one must still work; and a registered one can be
+ * *more* than that law, because a single `ota` stamp cannot carry a second section. A BA662A is
+ * an OTA **plus** a Darlington buffer, and before this `boss-cs-2`'s `bufferinput`/`buffertie`
+ * net was touched by no stamp in the compiled program at all.
+ *
+ * So this is consulted only where a `sections` model is being looked up. It deliberately does not
+ * widen `requiresIdentification`: doing that put OTAs through the `ic` shell/isolation predicates
+ * and the unmatched-pinout refusal, which cost `electro-harmonix-small-stone` all five of its
+ * CA3094 stamps at once.
+ */
+export declare function mayCarryRegistrySections(device: Device): boolean;
+/**
+ * An op-amp whose registered *part* says it is not an op-amp, so the part's law overrides the
+ * device-class law even though the class law can read the terminals.
+ *
+ * The class law is `ideal-opamp`; a `sections` entry whose law kind is not that is the part
+ * disagreeing with the drawn kind. That is typed evidence the part carries and the document's
+ * `kind: opamp` is a drawing convenience: an LM339 drawn as an op-amp is still an
+ * open-collector comparator, and the ideal-op-amp output that stamps binds the shared node is
+ * a voltage source where the real part is a sink-or-float. `moogerfooger-mf-102`'s `U2A`/`U2C`
+ * wire-OR onto one pull-up resistor because the LM339's outputs *are* open-collector; a voltage
+ * source makes that node over-determined and the packet renders silence.
+ *
+ * Match is the same whole-token exact part id (rung 1) or canonical die (rung 4) the evidence
+ * ladder uses, so a prose mention can never admit one. The default registry is consulted with the
+ * arity deliberately unconstrained: an arity *mismatch* against a comparator entry still wants the
+ * registration question to end where it would today -- rung 3 -- rather than falling through to
+ * `declaredType`, whose class would re-stamp the drawn `opamp`.
+ */
+/**
+ * A bipolar transistor whose exact part id the registry expands into sections -- a bias-resistor
+ * built-in transistor (a "digital transistor") such as Toshiba's RN1307, whose datasheet puts a
+ * series base resistor and a base-emitter resistor inside the package. The class law is a bare
+ * transistor and cannot know they are there; the part number can. Every other BJT keeps its class
+ * law untouched, because no other BJT has a sections entry.
+ */
+export declare function bjtPartRegisteredAsSections(device: Device, registry: PartRegistry): boolean;
+export declare function opampPartRegisteredAsOtherLaw(device: Device, registry: PartRegistry): boolean;
+export declare function identify(device: Device, registry: PartRegistry): PartIdentity | null;
+//# sourceMappingURL=identify.d.ts.map

package/dist/identify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identify.d.ts","sourceRoot":"","sources":["../src/identify.ts"],"names":[],"mappings":"AAwBA,OAAO,EAIN,KAAK,YAAY,EACjB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAGpD,iFAAiF;AACjF,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAahE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,OAAO,CAU3F;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,OAAO,CAsB7F;AAoBD,wBAAgB,QAAQ,CACvB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,YAAY,GACpB,YAAY,GAAG,IAAI,CA0KrB"}