universal-physics-tensor 7.0.0 → 9.0.0

package/dist/bridges/evaluators.js

@@ -1,431 +1,201 @@
 /**
- * Bridge-evaluator registry — the single dispatch surface for `upt evaluate`.
+ * Closed-form evaluators projected from the catalog. `run` evaluates the
+ * relation expression. It does not switch on a catalog id.
  *
- * The closed-form + Schwarzschild-spacetime bridges (BE-51/52/55…102) carry plain-JS
- * evaluators but were, until now, unreachable from the CLI (`upt eval` is
- * user-formula-only; `upt explain <be-NN>` even redirected to a capability that did
- * not exist). This registry maps each bridge id to its evaluator, its input keys,
- * and a typed `run`, so `upt evaluate be-63 mu_e=2` returns M_Ch ≈ 1.44 M_⊙.
+ * `run` is the one evaluation of a catalog closed form: `evaluateRelation`,
+ * the CLI and the uncertainty probes all call it. It checks the bindings
+ * against the evaluator's {@link InputContract} before the validity domain,
+ * so an absent input is a {@link MissingInputError}, never a domain failure.
  *
  * @module bridges/evaluators
  */
-import { evaluateLandauerEnergy } from './equations/be-16-landauer.js';
-import { evaluateHawkingTemperature } from './equations/be-42-hawking-temperature.js';
-import { evaluateGravitationalLensing } from './gravitational-lensing.js';
-import { evaluatePerihelionPrecession } from './perihelion-precession.js';
-import { evaluateQuantumHall } from './be55-quantum-hall.js';
-import { evaluateCasimir } from './be56-casimir.js';
-import { evaluateUnruh } from './be57-unruh.js';
-import { evaluateJohnsonNyquist } from './be58-johnson-nyquist.js';
-import { evaluateACJosephson } from './be59-ac-josephson.js';
-import { evaluateFractionalQH } from './be60-fractional-qh.js';
-import { evaluateWiedemannFranz } from './be61-wiedemann-franz.js';
-import { evaluateBCSGap } from './be62-bcs-gap.js';
-import { evaluateChandrasekharMass } from './be63-chandrasekhar-mass.js';
-import { evaluateEddingtonLuminosity } from './be64-eddington-luminosity.js';
-import { evaluateJeansMass } from './be65-jeans-mass.js';
-import { evaluateRadiationPressure } from './be66-radiation-pressure.js';
-import { evaluateAlfvenSpeed } from './be67-alfven-speed.js';
-import { evaluateTolmanEhrenfest } from './be68-tolman-ehrenfest.js';
-import { evaluateFastMagnetosonic } from './be69-fast-magnetosonic.js';
-import { evaluateEinsteinRelation } from './be70-einstein-relation.js';
-import { evaluateClapeyron } from './be71-clapeyron.js';
-import { evaluateGravitationalRedshift } from './be72-gravitational-redshift.js';
-import { evaluateKelvinPeltier } from './be73-kelvin-peltier.js';
-import { evaluateMagneticPressure } from './be74-magnetic-pressure.js';
-import { evaluateLondonPenetration } from './be75-london-penetration.js';
-import { evaluatePlasmaBeta } from './be76-plasma-beta.js';
-import { evaluateHagenPoiseuille } from './be77-hagen-poiseuille.js';
-import { evaluateEulerBuckling } from './be78-euler-buckling.js';
-import { evaluatePullIn } from './be79-pull-in.js';
-import { evaluateMottGurney } from './be80-mott-gurney.js';
-import { evaluateChildLangmuir } from './be81-child-langmuir.js';
-import { evaluateShockleyDiode } from './be82-shockley-diode.js';
-import { evaluateThomsonCoefficient } from './be83-thomson.js';
-import { evaluateFourPointSheet } from './be84-four-point.js';
-import { evaluateShotNoise } from './be85-shot-noise.js';
-import { evaluateReynoldsAnalogy } from './be86-reynolds-analogy.js';
-import { evaluateCapacitorNoise } from './be87-capacitor-noise.js';
-import { evaluateFermiSea } from './be88-fermi-sea.js';
-import { evaluateDebyeCutoff } from './be89-debye-cutoff.js';
-import { evaluateDebyeHeat } from './be90-debye-heat.js';
-import { evaluateEinsteinSolid } from './be91-einstein-solid.js';
-import { evaluateSommerfeldHeat } from './be92-sommerfeld-heat.js';
-import { evaluateCurieWeiss } from './be93-curie-weiss.js';
-import { evaluatePauliParamagnetism } from './be94-pauli-paramagnetism.js';
-import { evaluateGinzburgLandau } from './be95-ginzburg-landau.js';
-import { evaluateUpperCritical } from './be96-upper-critical.js';
-import { evaluateAmbegaokarBaratoff } from './be97-ambegaokar-baratoff.js';
-import { evaluateBcsJump } from './be98-bcs-jump.js';
-import { evaluateMassAction } from './be99-mass-action.js';
-import { evaluateLyddaneSachsTeller } from './be100-lyddane-sachs-teller.js';
-import { evaluateBktJump } from './be101-bkt-jump.js';
-import { evaluateLandauerConductance } from './be102-landauer-conductance.js';
-import { evaluateBennettPinch, evaluateBohmSheath, evaluateChapmanFerraro, evaluateColdPlasmaCutoff, evaluateCrossFieldDiffusion, evaluateDebyeSphere, evaluateExBDrift, evaluateFirehose, evaluateGradBDrift, evaluateIonAcoustic, evaluateLandauDamping, evaluateLangmuirProbe, evaluateLawsonBreakeven, evaluateLorentzResistivity, evaluateLossCone, evaluateLowerHybrid, evaluateMirrorInstability, evaluateMultiDebye, evaluateObliqueMagnetosonic, evaluateParkerCritical, evaluateParkerSpiral, evaluateResistiveSlab, evaluateUpperHybrid, } from './plasma-space.js';
-import { evaluateBoostConverter, evaluateCoaxialCapacitance, evaluateCombDrive, evaluateDampingRatio, evaluateFinEfficiency, evaluateJoukowsky, evaluateSubthresholdSwing, evaluateThermoelectricGenerator, } from './engineering-r7.js';
-import { evaluateAcDrude, evaluateBlochLaw, evaluateBuiltinVoltage, evaluateDensityOfStates2D, evaluateDensityOfStates3D, evaluateGorterCasimir, evaluateJosephsonInductance, evaluateLowerCritical, evaluateMatthiessen, evaluateOnsagerFrequency, evaluateSemiconductorFermi, evaluateStoner, evaluateThomasFermi, } from './condensed-r8.js';
-import { bridgeRegistry, registerBridge } from './registry.js';
-/** @internal */
-function spec(bridgeId, name, parameters, run) {
-    return { bridgeId, name, inputKeys: parameters.map((p) => p.key), parameters, run };
+import { FORMULA_NAMED } from '../dimensional/formula-names.js';
+import { primaryRelation } from './catalog-load.js';
+import { catalogEvaluators } from './catalog-load.js';
+import { evaluateFormula, formulaVariables, parseCatalogExpression } from './expr-parse.js';
+import { evaluateCatalogRelation, relationHolds } from './relation-eval.js';
+import { DomainViolationError } from './evaluation-errors.js';
+import { checkInputs, inputContract } from './input-contract.js';
+function toParameter(row) {
+    return {
+        key: row.key,
+        quantity: row.quantity,
+        symbol: row.symbol,
+        unit: row.unit,
+        meaning: row.meaning,
+        ...(row.geometry !== undefined ? { geometry: row.geometry } : {}),
+        ...(row.temperature !== undefined ? { temperature: row.temperature } : {}),
+        ...(row.sign !== undefined ? { sign: row.sign } : {}),
+        ...(row.angular === true ? { angular: true } : {}),
+        ...(row.alternates !== undefined ? { alternates: row.alternates } : {}),
+        ...(row.optional === true ? { optional: true } : {}),
+    };
+}
+const NAMED_DEFAULT = new Map(FORMULA_NAMED.map((named) => [named.name, named.value]));
+/** The relation source a parameter is the input for, or undefined when it owns none. */
+function sourceOfParameter(relation, parameter) {
+    for (const source of relation.sources) {
+        if (source === parameter.key || (relation.aliases[source] ?? []).includes(parameter.key))
+            return source;
+    }
+    return relation.sources.includes(parameter.quantity) ? parameter.quantity : undefined;
+}
+/** Every symbol name in an expression tree. */
+function symbolNames(node) {
+    if (node.kind === 'symbol')
+        return [node.name];
+    if (node.kind === 'op')
+        return node.args.flatMap(symbolNames);
+    if (node.kind === 'abs' || node.kind === 'transcendental')
+        return symbolNames(node.arg);
+    return [];
 }
-/** @internal */
-const P = (key, quantity, symbol, unit, meaning, extra = {}) => ({ key, quantity, symbol, unit, meaning, ...extra });
-const temperature = (key, quantity, symbol, meaning) => P(key, quantity, symbol, 'K', meaning, { temperature: 'absolute' });
-/** Bridge id → evaluator. Registered, then snapshotted. */
-const EVALUATOR_SPECS = [
-    spec(16, 'Landauer energy', [temperature('temperature_K', 'temperature', 'T', 'thermodynamic temperature, ≥ 0')], (i) => ({
-        value: evaluateLandauerEnergy({ temperature_K: i.temperature_K }),
-    })),
-    spec(42, 'Hawking temperature', [P('M_kg', 'mass', 'M', 'kg', 'black-hole mass, > 0')], (i) => ({
-        value: evaluateHawkingTemperature({ M_kg: i.M_kg }),
-    })),
-    spec(51, 'Gravitational lensing (Eddington)', [
-        P('M_kg', 'lensing mass', 'M', 'kg', 'mass of the deflecting body'),
-        P('b_m', 'impact parameter', 'b', 'm', "closest-approach distance of the ray from the lens's centre, > 0", {
-            geometry: 'impact-parameter',
-        }),
-    ], (i) => evaluateGravitationalLensing({ M_kg: i.M_kg, b_m: i.b_m })),
-    spec(52, 'Perihelion precession (Einstein)', [
-        P('M_kg', 'central mass', 'M', 'kg', 'mass of the central body'),
-        P('a_m', 'semi-major axis', 'a', 'm', "half the orbit's major axis, > 0", {
-            geometry: 'semi-major-axis',
-            alternates: [{ key: 'major_axis_m', meaning: 'the full major axis 2a (perihelion + aphelion distance)', toKey: 0.5 }],
-        }),
-        P('e', 'eccentricity', 'e', '', 'orbital eccentricity, 0 ≤ e < 1'),
-        P('T_yr', 'orbital period', 'T', 'yr', 'in Julian years (365.25 d); used only for the per-century conversion'),
-    ], (i) => evaluatePerihelionPrecession({ M_kg: i.M_kg, a_m: i.a_m, e: i.e, T_yr: i.T_yr })),
-    spec(55, 'Integer quantum Hall / TKNN', [P('C', 'TKNN (Chern) number', 'C', '', 'the integer Hall plateau index')], (i) => evaluateQuantumHall({ C: i.C })),
-    spec(56, 'Casimir effect', [P('d_m', 'plate separation', 'd', 'm', 'the gap between the facing plate surfaces, > 0', { geometry: 'separation' })], (i) => evaluateCasimir({ d_m: i.d_m })),
-    spec(57, 'Unruh effect', [P('a_m_s2', 'proper acceleration', 'a', 'm/s^2', 'the proper acceleration, ≥ 0')], (i) => evaluateUnruh({ a_m_s2: i.a_m_s2 })),
-    spec(58, 'Johnson-Nyquist noise', [
-        temperature('T_K', 'temperature', 'T', 'absolute temperature of the resistor, ≥ 0 K'),
-        P('R_ohm', 'resistance', 'R', 'ohm', 'the resistance, ≥ 0'),
-    ], (i) => evaluateJohnsonNyquist({ T_K: i.T_K, R_ohm: i.R_ohm })),
-    spec(59, 'AC Josephson', [P('V_volts', 'bias voltage', 'V', 'V', 'DC bias voltage across the junction')], (i) => evaluateACJosephson({ V_volts: i.V_volts })),
-    spec(60, 'Fractional quantum Hall', [P('nu', 'filling fraction', 'ν', '', 'ν = p/q, e.g. 1/3 as 0.3333')], (i) => evaluateFractionalQH({ nu: i.nu })),
-    spec(61, 'Wiedemann-Franz', [
-        P('sigma_S_per_m', 'electrical conductivity', 'σ', 'S/m', 'the electrical conductivity'),
-        temperature('T_K', 'temperature', 'T', 'absolute temperature of the metal'),
-    ], (i) => evaluateWiedemannFranz({ sigma_S_per_m: i.sigma_S_per_m, T_K: i.T_K })),
-    spec(62, 'BCS gap ratio', [temperature('T_c_K', 'critical temperature', 'T_c', 'the superconducting transition temperature')], (i) => evaluateBCSGap({ T_c_K: i.T_c_K })),
-    spec(63, 'Chandrasekhar mass', [P('mu_e', 'mean molecular weight per electron', 'μ_e', '', '2 for a carbon/oxygen white dwarf')], (i) => evaluateChandrasekharMass({ mu_e: i.mu_e })),
-    spec(64, 'Eddington luminosity', [P('M_kg', 'accretor mass', 'M', 'kg', 'mass of the accreting or radiating body')], (i) => evaluateEddingtonLuminosity({ M_kg: i.M_kg })),
-    spec(65, 'Jeans mass', [
-        temperature('T_K', 'cloud temperature', 'T', 'absolute temperature of the cloud'),
-        P('rho_kg_per_m3', 'mass density', 'ρ', 'kg/m^3', 'mass density of the cloud'),
-        P('mu', 'mean molecular weight', 'μ', '', '≈ 2.3 for molecular H₂/He clouds'),
-    ], (i) => evaluateJeansMass({ T_K: i.T_K, rho_kg_per_m3: i.rho_kg_per_m3, mu: i.mu })),
-    spec(66, 'Radiation pressure', [
-        P('I_W_per_m2', 'intensity', 'I', 'W/m^2', 'time-averaged Poynting-flux magnitude, ≥ 0'),
-        P('R', 'reflectance', 'R', '', 'intensity reflectance on [0, 1]; transmission is 0'),
-        P('theta_rad', 'incidence angle', 'θ', '', 'angle from the outward normal, radians'),
-    ], (i) => evaluateRadiationPressure({ I_W_per_m2: i.I_W_per_m2, R: i.R, theta_rad: i.theta_rad })),
-    spec(67, 'Alfvén speed', [
-        P('B_T', 'magnetic flux density', 'B', 'T', 'background field, ≥ 0'),
-        P('rho_kg_per_m3', 'total mass density', 'ρ', 'kg/m^3', 'total mass density, not a number density'),
-    ], (i) => evaluateAlfvenSpeed({ B_T: i.B_T, rho_kg_per_m3: i.rho_kg_per_m3 })),
-    spec(68, 'Tolman–Ehrenfest', [
-        temperature('T_K', 'proper temperature', 'T', 'proper temperature, > 0 K'),
-        P('g_00', 'metric component', 'g_00', '', 'static g_00, must be negative'),
-    ], (i) => evaluateTolmanEhrenfest({ T_K: i.T_K, g_00: i.g_00 })),
-    spec(69, 'Fast magnetosonic speed', [
-        P('cs_m_per_s', 'sound speed', 'c_s', 'm/s', 'sound speed, ≥ 0; zero recovers the Alfvén number of this polarization'),
-        P('B_T', 'magnetic flux density', 'B', 'T', 'background field; the formula uses B²'),
-        P('rho_kg_per_m3', 'total mass density', 'ρ', 'kg/m^3', 'total mass density, > 0'),
-    ], (i) => evaluateFastMagnetosonic({ cs_m_per_s: i.cs_m_per_s, B_T: i.B_T, rho_kg_per_m3: i.rho_kg_per_m3 })),
-    spec(70, 'Einstein relation', [
-        P('mu_m2_per_Vs', 'electrical mobility', 'μ', 'm^2/(V·s)', 'drift speed per electric field'),
-        temperature('T_K', 'temperature', 'T', 'absolute temperature, nonzero'),
-        P('q_C', 'carrier charge', 'q', 'C', 'carrier charge, nonzero, same sign as μ'),
-    ], (i) => evaluateEinsteinRelation({ mu_m2_per_Vs: i.mu_m2_per_Vs, T_K: i.T_K, q_C: i.q_C })),
-    spec(71, 'Clapeyron slope', [
-        P('L_J_per_kg', 'specific latent heat', 'L', 'J/kg', 'L = T (s2 − s1)'),
-        temperature('T_K', 'temperature', 'T', 'absolute temperature on the coexistence curve, nonzero'),
-        P('delta_v_m3_per_kg', 'specific-volume change', 'Δv', 'm^3/kg', 'v2 − v1, nonzero'),
-    ], (i) => evaluateClapeyron({ L_J_per_kg: i.L_J_per_kg, T_K: i.T_K, delta_v_m3_per_kg: i.delta_v_m3_per_kg })),
-    spec(72, 'Gravitational redshift', [
-        P('g1', 'metric component at observer 1', 'g1', '', 'static g_00, must be negative'),
-        P('g2', 'metric component at observer 2', 'g2', '', 'static g_00, must be negative'),
-    ], (i) => evaluateGravitationalRedshift({ g1: i.g1, g2: i.g2 })),
-    spec(73, 'Kelvin–Peltier', [
-        P('S_V_per_K', 'Seebeck coefficient', 'S', 'V/K', 'open-circuit Seebeck coefficient'),
-        temperature('T_K', 'temperature', 'T', 'absolute temperature, nonzero'),
-    ], (i) => evaluateKelvinPeltier({ S_V_per_K: i.S_V_per_K, T_K: i.T_K })),
-    spec(74, 'Magnetic pressure', [P('B_T', 'magnetic flux density', 'B', 'T', 'the formula uses B²; the factor 2 is not from units')], (i) => evaluateMagneticPressure({ B_T: i.B_T })),
-    spec(75, 'London penetration depth', [
-        P('m_kg', 'carrier mass', 'm', 'kg', 'carrier mass'),
-        P('n_per_m3', 'carrier density', 'n', 'm^-3', 'number density; e is the elementary charge'),
-    ], (i) => evaluateLondonPenetration({ m_kg: i.m_kg, n_per_m3: i.n_per_m3 })),
-    spec(76, 'Plasma beta', [
-        P('n_per_m3', 'number density', 'n', 'm^-3', 'ideal-gas number density'),
-        temperature('T_K', 'temperature', 'T', 'absolute temperature'),
-        P('p_B_Pa', 'magnetic pressure', 'p_B', 'Pa', 'B²/(2 μ0), not B²/μ0; nonzero'),
-    ], (i) => evaluatePlasmaBeta({ n_per_m3: i.n_per_m3, T_K: i.T_K, p_B_Pa: i.p_B_Pa })),
-    spec(77, 'Hagen–Poiseuille', [
-        P('R_m', 'pipe radius', 'R', 'm', 'circular-pipe radius, > 0', { geometry: 'radius' }),
-        P('deltaP_Pa', 'pressure drop', 'ΔP', 'Pa', 'axial pressure drop'),
-        P('mu_Pa_s', 'dynamic viscosity', 'μ', 'Pa*s', 'Newtonian viscosity, nonzero'),
-        P('L_m', 'pipe length', 'L', 'm', 'pipe length, nonzero'),
-    ], (i) => evaluateHagenPoiseuille({ R_m: i.R_m, deltaP_Pa: i.deltaP_Pa, mu_Pa_s: i.mu_Pa_s, L_m: i.L_m })),
-    spec(78, 'Euler buckling', [
-        P('E_Pa', "Young's modulus", 'E', 'Pa', 'modulus, > 0'),
-        P('I_m4', 'second moment of area', 'I', 'm^4', 'metres to the fourth, > 0'),
-        P('L_m', 'column length', 'L', 'm', 'length between pinned ends, > 0'),
-    ], (i) => evaluateEulerBuckling({ E_Pa: i.E_Pa, I_m4: i.I_m4, L_m: i.L_m })),
-    spec(79, 'Pull-in voltage', [
-        P('k_N_per_m', 'spring stiffness', 'k', 'N/m', 'linear spring, > 0'),
-        P('g0_m', 'rest gap', 'g0', 'm', 'rest gap, > 0; the fold is 2 g0/3'),
-        P('A_m2', 'plate area', 'A', 'm^2', 'parallel-plate area in m², > 0'),
-    ], (i) => evaluatePullIn({ k_N_per_m: i.k_N_per_m, g0_m: i.g0_m, A_m2: i.A_m2 })),
-    spec(80, 'Mott–Gurney', [
-        P('eps', 'permittivity', 'ε', 'F/m', 'solid permittivity in F/m, > 0'),
-        P('mu_m2_per_Vs', 'drift mobility', 'μ', 'm^2/(V·s)', 'drift mobility, > 0'),
-        P('V_volts', 'voltage', 'V', 'V', 'the formula uses V²'),
-        P('d_m', 'thickness', 'd', 'm', 'film thickness, > 0', { geometry: 'separation' }),
-    ], (i) => evaluateMottGurney({ eps: i.eps, mu_m2_per_Vs: i.mu_m2_per_Vs, V_volts: i.V_volts, d_m: i.d_m })),
-    spec(81, 'Child–Langmuir', [
-        P('m_kg', 'particle mass', 'm', 'kg', 'particle mass, > 0'),
-        P('V_volts', 'anode voltage', 'V', 'V', 'anode voltage, > 0; e is the elementary charge'),
-        P('d_m', 'gap', 'd', 'm', 'gap, > 0; Poisson is not claimed at x = 0', { geometry: 'separation' }),
-    ], (i) => evaluateChildLangmuir({ m_kg: i.m_kg, V_volts: i.V_volts, d_m: i.d_m })),
-    spec(82, 'Shockley diode', [
-        P('I_s_A', 'saturation current', 'I_s', 'A', 'saturation current in amperes'),
-        P('V_volts', 'bias', 'V', 'V', 'bias voltage; ideality is 1'),
-        temperature('T_K', 'temperature', 'T', 'absolute temperature, nonzero'),
-    ], (i) => evaluateShockleyDiode({ I_s_A: i.I_s_A, V_volts: i.V_volts, T_K: i.T_K })),
-    spec(83, 'Thomson coefficient', [
-        temperature('T_K', 'temperature', 'T', 'absolute temperature'),
-        P('dS_dT_V_per_K2', 'Seebeck slope', 'dS/dT', 'V/K^2', 'volts per kelvin squared; not a sampled difference'),
-    ], (i) => evaluateThomsonCoefficient({ T_K: i.T_K, dS_dT_V_per_K2: i.dS_dT_V_per_K2 })),
-    spec(84, 'Four-point sheet', [
-        P('V_volts', 'inner-pair voltage', 'V', 'V', 'voltage on the inner pair'),
-        P('I_A', 'probe current', 'I', 'A', 'current in amperes, nonzero'),
-    ], (i) => evaluateFourPointSheet({ V_volts: i.V_volts, I_A: i.I_A })),
-    spec(85, 'Shot noise', [P('I_A', 'current', 'I', 'A', 'current in the Poisson mean, amperes; one-sided 2 e I')], (i) => evaluateShotNoise({ I_A: i.I_A })),
-    spec(86, 'Reynolds analogy', [P('C_f', 'skin friction', 'C_f', '', 'already normalized by ρ U²/2; Pr = 1 and matched slopes are hypotheses')], (i) => evaluateReynoldsAnalogy({ C_f: i.C_f })),
-    spec(87, 'Capacitor noise', [
-        temperature('T_K', 'temperature', 'T', 'absolute temperature'),
-        P('C_F', 'capacitance', 'C', 'F', 'capacitance, > 0; one quadratic term'),
-    ], (i) => evaluateCapacitorNoise({ T_K: i.T_K, C_F: i.C_F })),
-    spec(88, 'Fermi wavevector', [
-        P('n_per_m3', 'electron density', 'n', 'm^-3', 'two-spin number density'),
-        P('m_kg', 'effective mass', 'm*', 'kg', 'isotropic band mass'),
-    ], (i) => evaluateFermiSea({ n_per_m3: i.n_per_m3, m_kg: i.m_kg })),
-    spec(89, 'Debye cutoff', [
-        P('v_m_per_s', 'sound speed', 'v_s', 'm/s', 'common acoustic speed'),
-        P('n_per_m3', 'atom density', 'n', 'm^-3', 'three branches fill 3n states'),
-    ], (i) => evaluateDebyeCutoff({ v_m_per_s: i.v_m_per_s, n_per_m3: i.n_per_m3 })),
-    spec(90, 'Debye heat', [
-        P('N', 'atom count', 'N', '', 'number of atoms'),
-        temperature('T_K', 'temperature', 'T', 'absolute temperature'),
-        temperature('thetaD_K', 'Debye temperature', 'θ_D', 'Debye temperature; π⁴/15 is assumed'),
-    ], (i) => evaluateDebyeHeat({ N: i.N, T_K: i.T_K, thetaD_K: i.thetaD_K })),
-    spec(91, 'Einstein solid', [
-        P('N', 'atom count', 'N', '', 'number of atoms; three oscillators each'),
-        temperature('T_K', 'temperature', 'T', 'absolute temperature'),
-        temperature('thetaE_K', 'Einstein temperature', 'θ_E', 'Einstein temperature'),
-    ], (i) => evaluateEinsteinSolid({ N: i.N, T_K: i.T_K, thetaE_K: i.thetaE_K })),
-    spec(92, 'Sommerfeld heat', [
-        P('n_per_m3', 'electron density', 'n', 'm^-3', '√E density of states'),
-        temperature('T_K', 'temperature', 'T', 'absolute temperature'),
-        P('E_F_J', 'Fermi energy', 'E_F', 'J', 'Fermi energy; the correction δU is a hypothesis'),
-    ], (i) => evaluateSommerfeldHeat({ n_per_m3: i.n_per_m3, T_K: i.T_K, E_F_J: i.E_F_J })),
-    spec(93, 'Curie–Weiss', [
-        P('n_per_m3', 'moment density', 'n', 'm^-3', 'moment density'),
-        P('g', 'Landé factor', 'g', '', 'Landé g-factor'),
-        P('spin', 'spin', 'S', '', 'spin in S(S+1)/3'),
-        P('muB_J_per_T', 'Bohr magneton', 'μ_B', 'J/T', 'supplied; not derived'),
-        temperature('T_K', 'temperature', 'T', 'absolute temperature'),
-        temperature('theta_K', 'Weiss temperature', 'θ', 'mean-field shift; zero is the Curie law'),
-    ], (i) => evaluateCurieWeiss({
-        n_per_m3: i.n_per_m3,
-        g: i.g,
-        spin: i.spin,
-        muB_J_per_T: i.muB_J_per_T,
-        T_K: i.T_K,
-        theta_K: i.theta_K,
-    })),
-    spec(94, 'Pauli paramagnetism', [
-        P('n_per_m3', 'electron density', 'n', 'm^-3', '√E density'),
-        P('E_F_J', 'Fermi energy', 'E_F', 'J', 'Fermi energy'),
-        P('muB_J_per_T', 'Bohr magneton', 'μ_B', 'J/T', 'supplied; not Landau diamagnetism'),
-    ], (i) => evaluatePauliParamagnetism({ n_per_m3: i.n_per_m3, E_F_J: i.E_F_J, muB_J_per_T: i.muB_J_per_T })),
-    spec(95, 'GL trial wall', [P('kappa', 'GL parameter', 'κ', '', 'trial wall, not every minimizer')], (i) => evaluateGinzburgLandau({ kappa: i.kappa })),
-    spec(96, 'Upper critical field', [P('xi_m', 'coherence length', 'ξ', 'm', 'charge 2e; the Landau level is a hypothesis')], (i) => evaluateUpperCritical({ xi_m: i.xi_m })),
-    spec(97, 'Ambegaokar–Baratoff', [P('Delta_J', 'gap', 'Δ', 'J', 'T = 0 and identical gaps')], (i) => evaluateAmbegaokarBaratoff({ Delta_J: i.Delta_J })),
-    spec(98, 'BCS heat jump', [P('zeta', 'quartic coefficient', 'ζ', '', 'GL quartic coefficient, not a series')], (i) => evaluateBcsJump({ zeta: i.zeta })),
-    spec(99, 'Mass action', [
-        P('N_c_per_m3', 'conduction density of states', 'N_c', 'm^-3', 'Boltzmann tail'),
-        P('N_v_per_m3', 'valence density of states', 'N_v', 'm^-3', 'Boltzmann tail'),
-        P('E_g_J', 'gap', 'E_g', 'J', 'E_c − E_v'),
-        temperature('T_K', 'temperature', 'T', 'absolute temperature'),
-    ], (i) => evaluateMassAction({
-        N_c_per_m3: i.N_c_per_m3,
-        N_v_per_m3: i.N_v_per_m3,
-        E_g_J: i.E_g_J,
-        T_K: i.T_K,
-    })),
-    spec(100, 'Lyddane–Sachs–Teller', [
-        P('eps_static', 'static dielectric constant', 'ε(0)', '', 'undamped'),
-        P('eps_inf', 'high-frequency dielectric constant', 'ε(∞)', '', 'nonzero'),
-    ], (i) => evaluateLyddaneSachsTeller({ eps_static: i.eps_static, eps_inf: i.eps_inf })),
-    spec(101, 'BKT unbinding', [P('J_J', 'vortex stiffness', 'J', 'J', 'energy-entropy argument, not the RG flow')], (i) => evaluateBktJump({ J_J: i.J_J })),
-    spec(102, 'Landauer conductance', [P('sum_Tn', 'transmission sum', 'Σ T_n', '', 'two spins; not the Hall conductance')], (i) => evaluateLandauerConductance({ sum_Tn: i.sum_Tn })),
-    spec(103, 'Bohm sheath (cold)', [temperature('T_e_K', 'electron temperature', 'T_e', 'cold-ion threshold uses T_e'), P('m_i_kg', 'ion mass', 'm_i', 'kg', 'ion mass')], (i) => evaluateBohmSheath({ T_e_K: i.T_e_K, m_i_kg: i.m_i_kg })),
-    spec(104, 'Ion acoustic dispersion', [P('k_per_m', 'wavenumber', 'k', 'm^-1', 'k ≠ 0'), P('c_s_m_per_s', 'sound speed', 'c_s', 'm/s', 'c_s² = k_B T_e / m_i'), P('lambda_De_m', 'Debye length', 'λ_De', 'm', 'one-species electron Debye length')], (i) => evaluateIonAcoustic({ k_per_m: i.k_per_m, c_s_m_s: i.c_s_m_per_s, lambda_De_m: i.lambda_De_m })),
-    spec(105, 'Upper hybrid', [P('n_per_m3', 'density', 'n', 'm^-3', 'electron density'), P('B_T', 'magnetic field', 'B', 'T', 'field along z'), P('m_kg', 'mass', 'm', 'kg', 'electron mass')], (i) => evaluateUpperHybrid({ n_per_m3: i.n_per_m3, B_T: i.B_T, m_kg: i.m_kg })),
-    spec(106, 'Cold-plasma R cutoff', [P('omega_c_rad_s', 'cyclotron frequency', 'ω_c', 'rad/s', 'ω_c ≥ 0; the Stix index is a hypothesis'), P('omega_p_rad_s', 'plasma frequency', 'ω_p', 'rad/s', 'plasma frequency')], (i) => evaluateColdPlasmaCutoff({ omega_c_rad_s: i.omega_c_rad_s, omega_p_rad_s: i.omega_p_rad_s })),
-    spec(107, 'Lower hybrid', [P('omega_pi_rad_s', 'ion plasma frequency', 'ω_pi', 'rad/s', 'ion plasma frequency'), P('omega_ci_rad_s', 'ion cyclotron frequency', 'ω_ci', 'rad/s', 'ion cyclotron frequency'), P('omega_ce_rad_s', 'electron cyclotron frequency', 'ω_ce', 'rad/s', 'electron cyclotron frequency')], (i) => evaluateLowerHybrid({ omega_pi_rad_s: i.omega_pi_rad_s, omega_ci_rad_s: i.omega_ci_rad_s, omega_ce_rad_s: i.omega_ce_rad_s })),
-    spec(108, 'Oblique magnetosonic', [P('c_s_m_per_s', 'sound speed', 'c_s', 'm/s', 'sound speed'), P('v_A_m_per_s', 'Alfvén speed', 'v_A', 'm/s', 'Alfvén speed'), P('theta_rad', 'propagation angle', 'θ', '', 'angle from the field, radians')], (i) => evaluateObliqueMagnetosonic({ c_s_m_s: i.c_s_m_per_s, v_A_m_s: i.v_A_m_per_s, theta_rad: i.theta_rad })),
-    spec(109, 'Bennett pinch (equal temperature)', [P('N_per_m', 'line density', 'N', 'm^-1', 'N_e = N_i = N'), temperature('T_K', 'temperature', 'T', 'T_e = T_i = T')], (i) => evaluateBennettPinch({ N_per_m: i.N_per_m, T_K: i.T_K })),
-    spec(110, 'Loss cone', [P('B0_T', 'throat field', 'B0', 'T', 'field at the throat'), P('Bm_T', 'mirror field', 'Bm', 'T', 'field at the mirror')], (i) => evaluateLossCone({ B0_T: i.B0_T, Bm_T: i.Bm_T })),
-    spec(111, 'Grad-B drift', [P('m_kg', 'mass', 'm', 'kg', 'particle mass'), P('v_perp_m_per_s', 'perpendicular speed', 'v_⊥', 'm/s', 'speed perpendicular to B'), P('gradB_T_per_m', 'field gradient', '|∇B|', 'T/m', 'magnitude of the gradient'), P('q_C', 'charge', 'q', 'C', 'signed charge'), P('B_T', 'magnetic field', 'B', 'T', 'field strength, ≠ 0')], (i) => evaluateGradBDrift({ m_kg: i.m_kg, v_perp_m_s: i.v_perp_m_per_s, gradB_T_per_m: i.gradB_T_per_m, q_C: i.q_C, B_T: i.B_T })),
-    spec(112, 'E×B drift', [P('E_x_V_per_m', 'electric field x', 'E_x', 'V/m', 'electric field along x'), P('E_y_V_per_m', 'electric field y', 'E_y', 'V/m', 'electric field along y'), P('B_T', 'magnetic field', 'B', 'T', 'field along z, ≠ 0')], (i) => evaluateExBDrift({ E_x_V_per_m: i.E_x_V_per_m, E_y_V_per_m: i.E_y_V_per_m, B_T: i.B_T })),
-    spec(113, 'Landau damping', [P('omega_rad_s', 'wave frequency', 'ω', 'rad/s', 'real frequency; the residue formula is a hypothesis'), P('k_per_m', 'wavenumber', 'k', 'm^-1', 'wavenumber'), P('v_t_m_per_s', 'thermal speed', 'v_t', 'm/s', 'thermal speed in the Maxwellian')], (i) => evaluateLandauDamping({ omega_rad_s: i.omega_rad_s, k_per_m: i.k_per_m, v_t_m_s: i.v_t_m_per_s })),
-    spec(114, 'Debye sphere', [P('n_per_m3', 'density', 'n', 'm^-3', 'number density'), P('lambda_D_m', 'Debye length', 'λ_D', 'm', 'one-species Debye length, an input')], (i) => evaluateDebyeSphere({ n_per_m3: i.n_per_m3, lambda_D_m: i.lambda_D_m })),
-    spec(115, 'Two-species Debye length', [P('lambda_1_m', 'first Debye length', 'λ_1', 'm', 'species 1'), P('lambda_2_m', 'second Debye length', 'λ_2', 'm', 'species 2')], (i) => evaluateMultiDebye({ lambda_1_m: i.lambda_1_m, lambda_2_m: i.lambda_2_m })),
-    spec(116, 'Lorentz resistivity (kinetic)', [P('Z', 'ion charge state', 'Z', '', 'ion charge state'), P('ln_Lambda', 'Coulomb logarithm', 'ln Λ', '', 'Coulomb logarithm, a hypothesis inside the transport cross section'), temperature('T_K', 'temperature', 'T', 'temperature in the thermal speed'), P('m_kg', 'mass', 'm', 'kg', 'mass in ν(v_T); the electron mass in the Lorentz collision')], (i) => evaluateLorentzResistivity({ Z: i.Z, ln_Lambda: i.ln_Lambda, T_K: i.T_K, m_kg: i.m_kg })),
-    spec(117, 'Resistive slab', [P('sigma_S_per_m', 'conductivity', 'σ', 'S/m', 'conductivity'), P('L_m', 'slab width', 'L', 'm', 'slab width')], (i) => evaluateResistiveSlab({ sigma_S_per_m: i.sigma_S_per_m, L_m: i.L_m })),
-    spec(118, 'Parker critical radius', [P('c_s_m_per_s', 'sound speed', 'c_s', 'm/s', 'isothermal sound speed'), P('M_kg', 'stellar mass', 'M', 'kg', 'central mass')], (i) => evaluateParkerCritical({ c_s_m_s: i.c_s_m_per_s, M_kg: i.M_kg })),
-    spec(119, 'Parker spiral', [P('Omega_rad_s', 'rotation rate', 'Ω', 'rad/s', 'stellar rotation'), P('r_m', 'radius', 'r', 'm', 'heliocentric radius'), P('theta_rad', 'colatitude', 'θ', '', 'colatitude, radians'), P('v_r_m_per_s', 'radial speed', 'v_r', 'm/s', 'radial wind speed, ≠ 0')], (i) => evaluateParkerSpiral({ Omega_rad_s: i.Omega_rad_s, r_m: i.r_m, theta_rad: i.theta_rad, v_r_m_s: i.v_r_m_per_s })),
-    spec(120, 'Chapman–Ferraro standoff', [P('B_E_T', 'surface field', 'B_E', 'T', 'equatorial surface field'), P('rho_kg_per_m3', 'mass density', 'ρ', 'kg/m^3', 'wind mass density'), P('v_m_per_s', 'wind speed', 'v', 'm/s', 'wind speed')], (i) => evaluateChapmanFerraro({ B_E_T: i.B_E_T, rho_kg_per_m3: i.rho_kg_per_m3, v_m_s: i.v_m_per_s })),
-    spec(121, 'Lawson breakeven', [temperature('T_K', 'temperature', 'T', 'ion temperature'), P('sigma_v_m3_per_s', 'reactivity', '⟨σv⟩', 'm^3/s', 'Maxwellian average, not computed here'), P('E_J', 'fusion energy', 'E', 'J', 'energy released per reaction')], (i) => evaluateLawsonBreakeven({ T_K: i.T_K, sigma_v_m3_s: i.sigma_v_m3_per_s, E_J: i.E_J })),
-    spec(122, 'Floating potential', [P('m_e_kg', 'electron mass', 'm_e', 'kg', 'electron mass'), P('m_i_kg', 'ion mass', 'm_i', 'kg', 'ion mass')], (i) => evaluateLangmuirProbe({ m_e_kg: i.m_e_kg, m_i_kg: i.m_i_kg })),
-    spec(123, 'Cross-field diffusion ratio', [P('alpha', 'Hall parameter', 'α', '', 'α = μ B')], (i) => evaluateCrossFieldDiffusion({ alpha: i.alpha })),
-    spec(124, 'Firehose margin', [P('beta_parallel', 'parallel beta', 'β_∥', '', 'β = 2 μ0 p / B²'), P('beta_perp', 'perpendicular beta', 'β_⊥', '', 'the be-76 definition')], (i) => evaluateFirehose({ beta_parallel: i.beta_parallel, beta_perp: i.beta_perp })),
-    spec(125, 'Mirror margin', [P('beta_perp', 'perpendicular beta', 'β_⊥', '', 'β = 2 μ0 p / B²; the kinetic integral is a hypothesis'), temperature('T_perp_K', 'perpendicular temperature', 'T_⊥', 'perpendicular temperature'), temperature('T_parallel_K', 'parallel temperature', 'T_∥', 'parallel temperature')], (i) => evaluateMirrorInstability({ beta_perp: i.beta_perp, T_perp_K: i.T_perp_K, T_parallel_K: i.T_parallel_K })),
-    spec(126, 'Comb-drive lateral force', [
-        P('n', 'finger count', 'n', '', 'number of fingers, both sidewalls'),
-        P('eps_F_per_m', 'permittivity', 'ε', 'F/m', 'permittivity of the gap'),
-        P('h_m', 'thickness', 'h', 'm', 'finger thickness'),
-        P('V_volts', 'voltage', 'V', 'V', 'voltage across the gap'),
-        P('g_m', 'gap', 'g', 'm', 'gap, ≠ 0', { geometry: 'separation' }),
-    ], (i) => evaluateCombDrive({ n: i.n, eps_F_per_m: i.eps_F_per_m, h_m: i.h_m, V_volts: i.V_volts, g_m: i.g_m })),
-    spec(127, 'Subthreshold swing', [
-        temperature('T_K', 'temperature', 'T', 'lattice temperature, ≠ 0'),
-        P('Cd_F', 'depletion capacitance', 'C_d', 'F', 'depletion capacitance'),
-        P('Cox_F', 'oxide capacitance', 'C_ox', 'F', 'oxide capacitance, ≠ 0'),
-    ], (i) => evaluateSubthresholdSwing({ T_K: i.T_K, Cd_F: i.Cd_F, Cox_F: i.Cox_F })),
-    spec(128, 'Ideal boost ratio', [
-        P('D', 'duty', 'D', '', 'switch duty, ≠ 1'),
-    ], (i) => evaluateBoostConverter({ D: i.D })),
-    spec(129, 'Straight-fin efficiency', [
-        P('h_W_per_m2_K', 'convection', 'h', 'W/(m^2*K)', 'surface convection, > 0'),
-        P('k_W_per_m_K', 'conductivity', 'k', 'W/(m*K)', 'fin conductivity, > 0'),
-        P('t_m', 'thickness', 't', 'm', 'fin thickness, > 0'),
-        P('L_fin_m', 'length', 'L', 'm', 'fin length, ≠ 0'),
-    ], (i) => evaluateFinEfficiency({ h_W_per_m2_K: i.h_W_per_m2_K, k_W_per_m_K: i.k_W_per_m_K, t_m: i.t_m, L_fin_m: i.L_fin_m })),
-    spec(130, 'Thermoelectric generator efficiency', [
-        temperature('Th_K', 'hot temperature', 'T_h', 'hot junction, ≠ 0'),
-        temperature('Tc_K', 'cold temperature', 'T_c', 'cold junction'),
-        P('Z_per_K', 'figure of merit', 'Z', 'K^-1', 'Z = S²/(R K)'),
-    ], (i) => evaluateThermoelectricGenerator({ Th_K: i.Th_K, Tc_K: i.Tc_K, Z_per_K: i.Z_per_K })),
-    spec(131, 'Joukowsky pressure', [
-        P('rho_kg_per_m3', 'density', 'ρ', 'kg/m^3', 'fluid density, > 0'),
-        P('dv_m_per_s', 'velocity change', 'Δv', 'm/s', 'change in velocity'),
-        P('K_Pa', 'bulk modulus', 'K', 'Pa', 'fluid bulk modulus, > 0'),
-        P('E_Pa', 'wall modulus', 'E', 'Pa', 'pipe wall modulus, > 0'),
-        P('pipe_D_m', 'diameter', 'D', 'm', 'internal diameter', { geometry: 'diameter' }),
-        P('wall_m', 'wall thickness', 'e_wall', 'm', 'wall thickness, > 0'),
-    ], (i) => evaluateJoukowsky({ rho_kg_per_m3: i.rho_kg_per_m3, dv_m_per_s: i.dv_m_per_s, K_Pa: i.K_Pa, E_Pa: i.E_Pa, pipe_D_m: i.pipe_D_m, wall_m: i.wall_m })),
-    spec(132, 'Coaxial capacitance per length', [
-        P('eps_F_per_m', 'permittivity', 'ε', 'F/m', 'insulator permittivity, ≠ 0'),
-        P('a_m', 'inner radius', 'a', 'm', 'inner radius, > 0', { geometry: 'radius' }),
-        P('b_m', 'outer radius', 'b', 'm', 'outer radius, > 0 and ≠ a', { geometry: 'radius' }),
-    ], (i) => evaluateCoaxialCapacitance({ eps_F_per_m: i.eps_F_per_m, a_m: i.a_m, b_m: i.b_m })),
-    spec(133, 'Damping ratio', [
-        P('c_kg_per_s', 'damping coefficient', 'c', 'kg/s', 'viscous coefficient'),
-        P('k_N_per_m', 'stiffness', 'k', 'N/m', 'stiffness, > 0'),
-        P('m_kg', 'mass', 'm', 'kg', 'mass, > 0'),
-    ], (i) => evaluateDampingRatio({ c_kg_per_s: i.c_kg_per_s, k_N_per_m: i.k_N_per_m, m_kg: i.m_kg })),
-    spec(134, 'Bloch magnon deficit', [
-        P('muB_J_per_T', 'Bohr magneton', 'μ_B', 'J/T', 'one Bohr magneton, not g μ_B'),
-        P('zeta_3_2', 'Bose value', 'ζ(3/2)', '', 'ζ(3/2), not evaluated'),
-        temperature('T_K', 'temperature', 'T', 'temperature, ≥ 0'),
-        P('D_J_m2', 'magnon stiffness', 'D', 'J*m^2', 'quadratic stiffness, > 0'),
-    ], (i) => evaluateBlochLaw({ muB_J_per_T: i.muB_J_per_T, zeta_3_2: i.zeta_3_2, T_K: i.T_K, D_J_m2: i.D_J_m2 })),
-    spec(135, 'Three-dimensional density of states', [
-        P('m_kg', 'band mass', 'm', 'kg', 'band mass, > 0'),
-        P('E_J', 'energy', 'E', 'J', 'energy, ≥ 0'),
-    ], (i) => evaluateDensityOfStates3D({ m_kg: i.m_kg, E_J: i.E_J })),
-    spec(136, 'Two-dimensional density of states', [
-        P('m_kg', 'band mass', 'm', 'kg', 'band mass, ≠ 0'),
-    ], (i) => evaluateDensityOfStates2D({ m_kg: i.m_kg })),
-    spec(137, 'Thomas–Fermi wavevector squared', [
-        P('n_per_m3', 'carrier density', 'n', 'm^-3', 'carrier density'),
-        P('EF_J', 'Fermi energy', 'E_F', 'J', 'Fermi energy, > 0'),
-    ], (i) => evaluateThomasFermi({ n_per_m3: i.n_per_m3, EF_J: i.EF_J })),
-    spec(138, 'Built-in voltage', [
-        temperature('T_K', 'temperature', 'T', 'temperature'),
-        P('NA_per_m3', 'acceptor density', 'N_A', 'm^-3', 'acceptor density, > 0'),
-        P('ND_per_m3', 'donor density', 'N_D', 'm^-3', 'donor density, > 0'),
-        P('ni_per_m3', 'intrinsic density', 'n_i', 'm^-3', 'intrinsic density, > 0'),
-    ], (i) => evaluateBuiltinVoltage({ T_K: i.T_K, NA_per_m3: i.NA_per_m3, ND_per_m3: i.ND_per_m3, ni_per_m3: i.ni_per_m3 })),
-    spec(139, 'Semiconductor Fermi offset', [
-        temperature('T_K', 'temperature', 'T', 'temperature, ≠ 0'),
-        P('mh_kg', 'hole mass', 'm_h*', 'kg', 'hole mass, > 0'),
-        P('me_kg', 'electron mass', 'm_e*', 'kg', 'electron mass, > 0'),
-        P('Nc_per_m3', 'conduction density', 'N_c', 'm^-3', 'effective conduction density, > 0'),
-        P('ND_per_m3', 'donor density', 'N_D', 'm^-3', 'donor density, > 0'),
-    ], (i) => evaluateSemiconductorFermi({ T_K: i.T_K, mh_kg: i.mh_kg, me_kg: i.me_kg, Nc_per_m3: i.Nc_per_m3, ND_per_m3: i.ND_per_m3 })),
-    spec(140, 'Onsager frequency', [
-        P('A_per_m2', 'orbit area', 'A', 'm^-2', 'extremal Fermi-surface area'),
-    ], (i) => evaluateOnsagerFrequency({ A_per_m2: i.A_per_m2 })),
-    spec(141, 'Josephson inductance', [
-        P('Ic_A', 'critical current', 'I_c', 'A', 'critical current, ≠ 0'),
-    ], (i) => evaluateJosephsonInductance({ Ic_A: i.Ic_A })),
-    spec(142, 'Lower critical field', [
-        P('lambda_m', 'London depth', 'λ', 'm', 'London depth, > ξ'),
-        P('xi_m', 'core cutoff', 'ξ', 'm', 'core cutoff, > 0'),
-    ], (i) => evaluateLowerCritical({ lambda_m: i.lambda_m, xi_m: i.xi_m })),
-    spec(143, 'AC Drude conductivity', [
-        P('n_per_m3', 'carrier density', 'n', 'm^-3', 'carrier density'),
-        P('m_kg', 'band mass', 'm', 'kg', 'band mass, ≠ 0'),
-        P('tau_s', 'scattering time', 'τ', 's', 'scattering time, > 0'),
-        P('omega_rad_s', 'angular drive', 'ω', 'rad/s', 'angular frequency'),
-    ], (i) => evaluateAcDrude({ n_per_m3: i.n_per_m3, m_kg: i.m_kg, tau_s: i.tau_s, omega_rad_s: i.omega_rad_s })),
-    spec(144, 'Matthiessen lifetime', [
-        P('tau1_s', 'first lifetime', 'τ₁', 's', 'first lifetime, ≠ 0'),
-        P('tau2_s', 'second lifetime', 'τ₂', 's', 'second lifetime, ≠ 0'),
-        P('C_ohm_m_s', 'Drude factor', 'C', 'ohm*m*s', 'ρ_i = C/τ_i'),
-    ], (i) => evaluateMatthiessen({ tau1_s: i.tau1_s, tau2_s: i.tau2_s, C_ohm_m_s: i.C_ohm_m_s })),
-    spec(145, 'Stoner susceptibility', [
-        P('chi_P', 'Pauli susceptibility', 'χ_P', '', 'be-94 value, not re-proved'),
-        P('x', 'Stoner product', 'I g(E_F)', '', '|x| < 1'),
-    ], (i) => evaluateStoner({ chi_P: i.chi_P, x: i.x })),
-    spec(146, 'Gorter–Casimir fraction', [
-        temperature('T_K', 'temperature', 'T', 'temperature, 0 ≤ T < T_c'),
-        temperature('Tc_K', 'critical temperature', 'T_c', 'critical temperature, > T'),
-        P('lambda0_m', 'zero-temperature depth', 'λ(0)', 'm', 'London depth at T = 0, > 0'),
-    ], (i) => evaluateGorterCasimir({ T_K: i.T_K, Tc_K: i.Tc_K, lambda0_m: i.lambda0_m })),
-];
-for (const evaluator of EVALUATOR_SPECS)
-    registerBridge({ evaluator });
-/** Bridge id → evaluator. The projection of `registerBridge`. @internal */
-export const BRIDGE_EVALUATORS = bridgeRegistry.evaluators();
 /**
- * What to say when an id is not in {@link BRIDGE_EVALUATORS}.
- * @internal
+ * Keys of the parameters whose source does not appear in the relation's
+ * expression. They are checked against the validity domain and do not change
+ * the value, so a caller who varies one sees no effect.
  */
+export function unusedInputKeys(spec) {
+    const relation = primaryRelation(spec.bridgeId);
+    if (relation === undefined)
+        return [];
+    const used = new Set(symbolNames(parseCatalogExpression(relation.expression)));
+    // An output reads the scope names its parsed expression names, the same parse `run` evaluates.
+    const outputReads = new Set(spec.outputs.flatMap((output) => formulaVariables(output.expression)));
+    const readByOutput = (key) => outputReads.has(key.replaceAll('-', '_'));
+    return spec.parameters
+        .filter((parameter) => {
+        const source = sourceOfParameter(relation, parameter);
+        // A parameter that owns no relation source is read only by an extra output.
+        return (source === undefined || !used.has(source)) && !readByOutput(parameter.key);
+    })
+        .map((parameter) => parameter.key);
+}
+/**
+ * The declared inputs of a catalog evaluator: one slot per parameter, spelled
+ * by its key, its relation source and that source's aliases, and its quantity
+ * when no other slot shares it; then one optional, unlisted slot per relation
+ * source no parameter owns, which a named constant fills when not given.
+ * Building it throws when one spelling would bind two slots.
+ */
+function evaluatorContract(catalogId, relation, parameters) {
+    const quantityCount = new Map();
+    for (const p of parameters)
+        quantityCount.set(p.quantity, (quantityCount.get(p.quantity) ?? 0) + 1);
+    const owned = new Set();
+    const slots = parameters.map((p) => {
+        const source = sourceOfParameter(relation, p);
+        if (source !== undefined)
+            owned.add(source);
+        const spellings = [
+            p.key,
+            ...(source === undefined ? [] : [source, ...(relation.aliases[source] ?? [])]),
+            ...(quantityCount.get(p.quantity) === 1 ? [p.quantity] : []),
+        ];
+        return {
+            key: p.key,
+            spellings: [...new Set(spellings)],
+            alternates: (p.alternates ?? []).map((alt) => ({ key: alt.key, toKey: alt.toKey })),
+            optional: p.optional === true,
+            readBy: source === undefined ? 'outputs' : 'value',
+            listed: true,
+        };
+    });
+    for (const source of relation.sources) {
+        if (owned.has(source))
+            continue;
+        slots.push({
+            key: source,
+            spellings: [source, ...(relation.aliases[source] ?? [])],
+            alternates: [],
+            optional: NAMED_DEFAULT.has(source.replaceAll('-', '_')),
+            readBy: 'value',
+            listed: false,
+        });
+    }
+    return inputContract(`be-${catalogId}`, slots);
+}
+/**
+ * Checked inputs (keyed by slot key) onto catalog source names. A source no
+ * parameter owns takes its given value, else its named constant.
+ */
+function bindRelationInputs(relation, parameters, inputs) {
+    const bound = {};
+    const owned = new Set();
+    for (const parameter of parameters) {
+        const source = sourceOfParameter(relation, parameter);
+        if (source === undefined)
+            continue;
+        owned.add(source);
+        const value = inputs[parameter.key];
+        if (value !== undefined)
+            bound[source] = value;
+    }
+    for (const source of relation.sources) {
+        if (owned.has(source))
+            continue;
+        const value = inputs[source] ?? NAMED_DEFAULT.get(source.replaceAll('-', '_'));
+        if (value !== undefined)
+            bound[source] = value;
+    }
+    return bound;
+}
+function buildSpec(catalogId, name, parameters, outputs) {
+    const relation = primaryRelation(catalogId);
+    if (relation === undefined)
+        throw new Error(missingEvaluatorMessage(catalogId));
+    const contract = evaluatorContract(catalogId, relation, parameters);
+    return {
+        bridgeId: catalogId,
+        name,
+        inputKeys: parameters.filter((parameter) => parameter.optional !== true).map((parameter) => parameter.key),
+        parameters,
+        outputs,
+        contract,
+        run(inputs, want = 'all') {
+            const given = checkInputs(contract, inputs, want);
+            const bound = bindRelationInputs(relation, parameters, given);
+            if (!relationHolds(relation, bound)) {
+                throw new DomainViolationError(`${relation.id}: inputs violate validity domain (${relation.domain})`);
+            }
+            for (const parameter of parameters) {
+                const value = given[parameter.key];
+                if (parameter.optional === true && parameter.sign === 'positive' && value !== undefined && !(value > 0)) {
+                    throw new DomainViolationError(`${relation.id}: ${parameter.key} must be > 0`);
+                }
+            }
+            const value = evaluateCatalogRelation(relation, bound);
+            const result = { value };
+            if (want === 'value')
+                return result;
+            for (const output of outputs) {
+                if ((output.requires ?? []).some((key) => given[key] === undefined))
+                    continue;
+                result[output.name] = evaluateFormula(output.expression, { ...given, value });
+            }
+            return result;
+        },
+    };
+}
+/** Bridge id → evaluator. @internal */
+export const BRIDGE_EVALUATORS = new Map(catalogEvaluators().map((row) => {
+    const parameters = row.parameters.map(toParameter);
+    return [row.catalogId, buildSpec(row.catalogId, row.name, parameters, row.outputs ?? [])];
+}));
+/** What to say when an id is not in {@link BRIDGE_EVALUATORS}. @internal */
 export function missingEvaluatorMessage(bridgeId) {
-    return `evaluateBridge: be-${bridgeId} has no evaluator (only closed-form + spacetime bridges do — see \`upt evaluate\` with no args)`;
+    return `evaluateBridge: catalog id ${bridgeId} has no evaluator`;
 }
 /**
- * Evaluate a bridge by id with a numeric input record. Throws on an unknown id
- * or a missing required input (the evaluator itself validates ranges).
+ * Evaluate a catalog id with a numeric input record: the evaluator's `run`,
+ * which checks the inputs first. Throws on an unknown id.
  *
  * @internal
  */
 export function evaluateBridge(bridgeId, inputs) {
-    const s = BRIDGE_EVALUATORS.get(bridgeId);
-    if (!s) {
+    const spec = BRIDGE_EVALUATORS.get(bridgeId);
+    if (spec === undefined)
         throw new Error(missingEvaluatorMessage(bridgeId));
-    }
-    const missing = s.inputKeys.filter((k) => !(k in inputs) || !Number.isFinite(inputs[k]));
-    if (missing.length) {
-        throw new Error(`evaluateBridge: be-${bridgeId} (${s.name}) needs {${s.inputKeys.join(', ')}}; missing/non-finite: ${missing.join(', ')}`);
-    }
-    return s.run(inputs);
+    return spec.run(inputs);
 }
 //# sourceMappingURL=evaluators.js.map